From a0845011edefff4d43edccfb5f519659a347d98f Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: May 17 2022 10:23:34 +0000 Subject: import python3.9-3.9.10-2.el9 --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..59b16ab --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/Python-3.9.10.tar.xz diff --git a/.python3.9.metadata b/.python3.9.metadata new file mode 100644 index 0000000..2556089 --- /dev/null +++ b/.python3.9.metadata @@ -0,0 +1 @@ +936fc25ac4e1b482a0cefa82dd6092a0c6b575e6 SOURCES/Python-3.9.10.tar.xz diff --git a/SOURCES/00001-rpath.patch b/SOURCES/00001-rpath.patch new file mode 100644 index 0000000..778c077 --- /dev/null +++ b/SOURCES/00001-rpath.patch @@ -0,0 +1,30 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: David Malcolm +Date: Wed, 13 Jan 2010 21:25:18 +0000 +Subject: [PATCH] 00001: Fixup distutils/unixccompiler.py to remove standard + library path from rpath Was Patch0 in ivazquez' python3000 specfile + +--- + Lib/distutils/unixccompiler.py | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/Lib/distutils/unixccompiler.py b/Lib/distutils/unixccompiler.py +index d00c48981e..0283a28c19 100644 +--- a/Lib/distutils/unixccompiler.py ++++ b/Lib/distutils/unixccompiler.py +@@ -82,6 +82,15 @@ class UnixCCompiler(CCompiler): + if sys.platform == "cygwin": + exe_extension = ".exe" + ++ def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs): ++ """Remove standard library path from rpath""" ++ libraries, library_dirs, runtime_library_dirs = super()._fix_lib_args( ++ libraries, library_dirs, runtime_library_dirs) ++ libdir = sysconfig.get_config_var('LIBDIR') ++ if runtime_library_dirs and (libdir in runtime_library_dirs): ++ runtime_library_dirs.remove(libdir) ++ return libraries, library_dirs, runtime_library_dirs ++ + def preprocess(self, source, output_file=None, macros=None, + include_dirs=None, extra_preargs=None, extra_postargs=None): + fixed_args = self._fix_compile_args(None, macros, include_dirs) diff --git a/SOURCES/00111-no-static-lib.patch b/SOURCES/00111-no-static-lib.patch new file mode 100644 index 0000000..390eed2 --- /dev/null +++ b/SOURCES/00111-no-static-lib.patch @@ -0,0 +1,75 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: David Malcolm +Date: Mon, 18 Jan 2010 17:59:07 +0000 +Subject: [PATCH] 00111: Don't try to build a libpythonMAJOR.MINOR.a +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Downstream only: not appropriate for upstream. + +See https://bugzilla.redhat.com/show_bug.cgi?id=556092 + +Co-authored-by: David Malcolm +Co-authored-by: Bohuslav Kabrda +Co-authored-by: Matej Stuchlik +Co-authored-by: Robert Kuska +Co-authored-by: Charalampos Stratakis +Co-authored-by: Miro Hrončok +--- + Makefile.pre.in | 21 ++------------------- + 1 file changed, 2 insertions(+), 19 deletions(-) + +diff --git a/Makefile.pre.in b/Makefile.pre.in +index 11230fa563..dc763e7197 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -588,7 +588,7 @@ clinic: check-clean-src $(srcdir)/Modules/_blake2/blake2s_impl.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/clinic/clinic.py --make --srcdir $(srcdir) + + # Build the interpreter +-$(BUILDPYTHON): Programs/python.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY) $(EXPORTSYMS) ++$(BUILDPYTHON): Programs/python.o $(LDLIBRARY) $(PY3LIBRARY) $(EXPORTSYMS) + $(LINKCC) $(PY_CORE_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/python.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) + + platform: $(BUILDPYTHON) pybuilddir.txt +@@ -636,12 +636,6 @@ sharedmods: $(BUILDPYTHON) pybuilddir.txt Modules/_math.o + _TCLTK_INCLUDES='$(TCLTK_INCLUDES)' _TCLTK_LIBS='$(TCLTK_LIBS)' \ + $(PYTHON_FOR_BUILD) $(srcdir)/setup.py $$quiet build + +- +-# Build static library +-$(LIBRARY): $(LIBRARY_OBJS) +- -rm -f $@ +- $(AR) $(ARFLAGS) $@ $(LIBRARY_OBJS) +- + libpython$(LDVERSION).so: $(LIBRARY_OBJS) $(DTRACE_OBJS) + if test $(INSTSONAME) != $(LDLIBRARY); then \ + $(BLDSHARED) -Wl,-h$(INSTSONAME) -o $(INSTSONAME) $(LIBRARY_OBJS) $(MODLIBS) $(SHLIBS) $(LIBC) $(LIBM); \ +@@ -723,7 +717,7 @@ Makefile Modules/config.c: Makefile.pre \ + @echo "The Makefile was updated, you may need to re-run make." + + +-Programs/_testembed: Programs/_testembed.o $(LIBRARY) $(LDLIBRARY) $(PY3LIBRARY) $(EXPORTSYMS) ++Programs/_testembed: Programs/_testembed.o $(LDLIBRARY) $(PY3LIBRARY) $(EXPORTSYMS) + $(LINKCC) $(PY_CORE_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/_testembed.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) + + ############################################################################ +@@ -1651,17 +1645,6 @@ libainstall: @DEF_MAKE_RULE@ python-config + else true; \ + fi; \ + done +- @if test -d $(LIBRARY); then :; else \ +- if test "$(PYTHONFRAMEWORKDIR)" = no-framework; then \ +- if test "$(SHLIB_SUFFIX)" = .dll; then \ +- $(INSTALL_DATA) $(LDLIBRARY) $(DESTDIR)$(LIBPL) ; \ +- else \ +- $(INSTALL_DATA) $(LIBRARY) $(DESTDIR)$(LIBPL)/$(LIBRARY) ; \ +- fi; \ +- else \ +- echo Skip install of $(LIBRARY) - use make frameworkinstall; \ +- fi; \ +- fi + $(INSTALL_DATA) Modules/config.c $(DESTDIR)$(LIBPL)/config.c + $(INSTALL_DATA) Programs/python.o $(DESTDIR)$(LIBPL)/python.o + $(INSTALL_DATA) $(srcdir)/Modules/config.c.in $(DESTDIR)$(LIBPL)/config.c.in diff --git a/SOURCES/00189-use-rpm-wheels.patch b/SOURCES/00189-use-rpm-wheels.patch new file mode 100644 index 0000000..e5cf8f7 --- /dev/null +++ b/SOURCES/00189-use-rpm-wheels.patch @@ -0,0 +1,75 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Miro=20Hron=C4=8Dok?= +Date: Wed, 15 Aug 2018 15:36:29 +0200 +Subject: [PATCH] 00189: Instead of bundled wheels, use our RPM packaged wheels + +We keep them in /usr/share/python-wheels + +Downstream only: upstream bundles +We might eventually pursuit upstream support, but it's low prio +--- + Lib/ensurepip/__init__.py | 37 ++++++++++++++++++++++++++----------- + 1 file changed, 26 insertions(+), 11 deletions(-) + +diff --git a/Lib/ensurepip/__init__.py b/Lib/ensurepip/__init__.py +index 2a140a2624..5bd16a6c59 100644 +--- a/Lib/ensurepip/__init__.py ++++ b/Lib/ensurepip/__init__.py +@@ -1,3 +1,5 @@ ++import distutils.version ++import glob + import os + import os.path + import sys +@@ -6,13 +8,29 @@ import tempfile + import subprocess + from importlib import resources + +-from . import _bundled +- + + + __all__ = ["version", "bootstrap"] +-_SETUPTOOLS_VERSION = "58.1.0" +-_PIP_VERSION = "21.2.4" ++ ++_WHEEL_DIR = "/usr/share/python-wheels/" ++ ++_wheels = {} ++ ++def _get_most_recent_wheel_version(pkg): ++ prefix = os.path.join(_WHEEL_DIR, "{}-".format(pkg)) ++ _wheels[pkg] = {} ++ for suffix in "-py2.py3-none-any.whl", "-py3-none-any.whl": ++ pattern = "{}*{}".format(prefix, suffix) ++ for path in glob.glob(pattern): ++ version_str = path[len(prefix):-len(suffix)] ++ _wheels[pkg][version_str] = os.path.basename(path) ++ return str(max(_wheels[pkg], key=distutils.version.LooseVersion)) ++ ++ ++_SETUPTOOLS_VERSION = _get_most_recent_wheel_version("setuptools") ++ ++_PIP_VERSION = _get_most_recent_wheel_version("pip") ++ + _PROJECTS = [ + ("setuptools", _SETUPTOOLS_VERSION, "py3"), + ("pip", _PIP_VERSION, "py3"), +@@ -101,13 +119,10 @@ def _bootstrap(*, root=None, upgrade=False, user=False, + # additional paths that need added to sys.path + additional_paths = [] + for project, version, py_tag in _PROJECTS: +- wheel_name = "{}-{}-{}-none-any.whl".format(project, version, py_tag) +- whl = resources.read_binary( +- _bundled, +- wheel_name, +- ) +- with open(os.path.join(tmpdir, wheel_name), "wb") as fp: +- fp.write(whl) ++ wheel_name = _wheels[project][version] ++ with open(os.path.join(_WHEEL_DIR, wheel_name), "rb") as sfp: ++ with open(os.path.join(tmpdir, wheel_name), "wb") as fp: ++ fp.write(sfp.read()) + + additional_paths.append(os.path.join(tmpdir, wheel_name)) + diff --git a/SOURCES/00251-change-user-install-location.patch b/SOURCES/00251-change-user-install-location.patch new file mode 100644 index 0000000..074e59d --- /dev/null +++ b/SOURCES/00251-change-user-install-location.patch @@ -0,0 +1,110 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Michal Cyprian +Date: Mon, 26 Jun 2017 16:32:56 +0200 +Subject: [PATCH] 00251: Change user install location +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Set values of prefix and exec_prefix in distutils install command +to /usr/local if executable is /usr/bin/python* and RPM build +is not detected to make pip and distutils install into separate location. + +Fedora Change: https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe +Downstream only: Reworked in Fedora 36+/Python 3.10+ to follow https://bugs.python.org/issue43976 + +pypa/distutils integration: https://github.com/pypa/distutils/pull/70 + +Also set sysconfig._PIP_USE_SYSCONFIG = False, to force pip-upgraded-pip +to respect this patched distutils install command. +See https://bugzilla.redhat.com/show_bug.cgi?id=2014513 + +Co-authored-by: Miro Hrončok +--- + Lib/distutils/command/install.py | 9 +++++++-- + Lib/site.py | 9 ++++++++- + Lib/sysconfig.py | 17 +++++++++++++++++ + 3 files changed, 32 insertions(+), 3 deletions(-) + +diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py +index aaa300efa9..18f01f10d4 100644 +--- a/Lib/distutils/command/install.py ++++ b/Lib/distutils/command/install.py +@@ -3,6 +3,7 @@ + Implements the Distutils 'install' command.""" + + import sys ++import sysconfig + import os + + from distutils import log +@@ -142,6 +143,8 @@ class install(Command): + + negative_opt = {'no-compile' : 'compile'} + ++ # Allow Fedora to add components to the prefix ++ _prefix_addition = getattr(sysconfig, '_prefix_addition', '') + + def initialize_options(self): + """Initializes options.""" +@@ -419,8 +422,10 @@ class install(Command): + raise DistutilsOptionError( + "must not supply exec-prefix without prefix") + +- self.prefix = os.path.normpath(sys.prefix) +- self.exec_prefix = os.path.normpath(sys.exec_prefix) ++ self.prefix = ( ++ os.path.normpath(sys.prefix) + self._prefix_addition) ++ self.exec_prefix = ( ++ os.path.normpath(sys.exec_prefix) + self._prefix_addition) + + else: + if self.exec_prefix is None: +diff --git a/Lib/site.py b/Lib/site.py +index 9e617afb00..db14f715f9 100644 +--- a/Lib/site.py ++++ b/Lib/site.py +@@ -353,7 +353,14 @@ def getsitepackages(prefixes=None): + return sitepackages + + def addsitepackages(known_paths, prefixes=None): +- """Add site-packages to sys.path""" ++ """Add site-packages to sys.path ++ ++ '/usr/local' is included in PREFIXES if RPM build is not detected ++ to make packages installed into this location visible. ++ ++ """ ++ if ENABLE_USER_SITE and 'RPM_BUILD_ROOT' not in os.environ: ++ PREFIXES.insert(0, "/usr/local") + for sitedir in getsitepackages(prefixes): + if os.path.isdir(sitedir): + addsitedir(sitedir, known_paths) +diff --git a/Lib/sysconfig.py b/Lib/sysconfig.py +index e3f79bfde5..e124104876 100644 +--- a/Lib/sysconfig.py ++++ b/Lib/sysconfig.py +@@ -86,6 +86,23 @@ _INSTALL_SCHEMES = { + }, + } + ++# Force pip to use distutils paths instead of sysconfig ++# https://github.com/pypa/pip/issues/10647 ++_PIP_USE_SYSCONFIG = False ++ ++# This is used by distutils.command.install in the stdlib ++# as well as pypa/distutils (e.g. bundled in setuptools). ++# The self.prefix value is set to sys.prefix + /local/ ++# if neither RPM build nor virtual environment is ++# detected to make distutils install packages ++# into the separate location. ++# https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe ++if (not (hasattr(sys, 'real_prefix') or ++ sys.prefix != sys.base_prefix) and ++ 'RPM_BUILD_ROOT' not in os.environ): ++ _prefix_addition = "/local" ++ ++ + _SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include', + 'scripts', 'data') + diff --git a/SOURCES/00328-pyc-timestamp-invalidation-mode.patch b/SOURCES/00328-pyc-timestamp-invalidation-mode.patch new file mode 100644 index 0000000..fbe9ed5 --- /dev/null +++ b/SOURCES/00328-pyc-timestamp-invalidation-mode.patch @@ -0,0 +1,54 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Miro=20Hron=C4=8Dok?= +Date: Thu, 11 Jul 2019 13:44:13 +0200 +Subject: [PATCH] 00328: Restore pyc to TIMESTAMP invalidation mode as default + in rpmbuild + +Since Fedora 31, the $SOURCE_DATE_EPOCH is set in rpmbuild to the latest +%changelog date. This makes Python default to the CHECKED_HASH pyc +invalidation mode, bringing more reproducible builds traded for an import +performance decrease. To avoid that, we don't default to CHECKED_HASH +when $RPM_BUILD_ROOT is set (i.e. when we are building RPM packages). + +See https://src.fedoraproject.org/rpms/redhat-rpm-config/pull-request/57#comment-27426 +Downstream only: only used when building RPM packages +Ideally, we should talk to upstream and explain why we don't want this +--- + Lib/py_compile.py | 3 ++- + Lib/test/test_py_compile.py | 2 ++ + 2 files changed, 4 insertions(+), 1 deletion(-) + +diff --git a/Lib/py_compile.py b/Lib/py_compile.py +index a81f493731..bba3642bf2 100644 +--- a/Lib/py_compile.py ++++ b/Lib/py_compile.py +@@ -70,7 +70,8 @@ class PycInvalidationMode(enum.Enum): + + + def _get_default_invalidation_mode(): +- if os.environ.get('SOURCE_DATE_EPOCH'): ++ if (os.environ.get('SOURCE_DATE_EPOCH') and not ++ os.environ.get('RPM_BUILD_ROOT')): + return PycInvalidationMode.CHECKED_HASH + else: + return PycInvalidationMode.TIMESTAMP +diff --git a/Lib/test/test_py_compile.py b/Lib/test/test_py_compile.py +index e6791c6916..b2d3dcf7fb 100644 +--- a/Lib/test/test_py_compile.py ++++ b/Lib/test/test_py_compile.py +@@ -19,6 +19,7 @@ def without_source_date_epoch(fxn): + def wrapper(*args, **kwargs): + with support.EnvironmentVarGuard() as env: + env.unset('SOURCE_DATE_EPOCH') ++ env.unset('RPM_BUILD_ROOT') + return fxn(*args, **kwargs) + return wrapper + +@@ -29,6 +30,7 @@ def with_source_date_epoch(fxn): + def wrapper(*args, **kwargs): + with support.EnvironmentVarGuard() as env: + env['SOURCE_DATE_EPOCH'] = '123456789' ++ env.unset('RPM_BUILD_ROOT') + return fxn(*args, **kwargs) + return wrapper + diff --git a/SOURCES/00329-fips.patch b/SOURCES/00329-fips.patch new file mode 100644 index 0000000..0548005 --- /dev/null +++ b/SOURCES/00329-fips.patch @@ -0,0 +1,2215 @@ +From 355e975a386b60d787b98cc4cd08b98f876ff858 Mon Sep 17 00:00:00 2001 +From: "Miss Islington (bot)" + <31488909+miss-islington@users.noreply.github.com> +Date: Mon, 7 Feb 2022 00:08:10 -0800 +Subject: [PATCH 01/11] bpo-40479: Fix undefined behavior in + Modules/_hashopenssl.c (GH-31153) + +va_end() must be called before returning. +(cherry picked from commit 59e004af63742361b67d1e1ae70229ff0db1059d) + +Co-authored-by: Zackery Spytz +--- + .../Core and Builtins/2022-02-06-23-08-30.bpo-40479.zED3Zu.rst | 1 + + Modules/_hashopenssl.c | 1 + + 2 files changed, 2 insertions(+) + create mode 100644 Misc/NEWS.d/next/Core and Builtins/2022-02-06-23-08-30.bpo-40479.zED3Zu.rst + +diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-02-06-23-08-30.bpo-40479.zED3Zu.rst b/Misc/NEWS.d/next/Core and Builtins/2022-02-06-23-08-30.bpo-40479.zED3Zu.rst +new file mode 100644 +index 00000000000..52701d53d8f +--- /dev/null ++++ b/Misc/NEWS.d/next/Core and Builtins/2022-02-06-23-08-30.bpo-40479.zED3Zu.rst +@@ -0,0 +1 @@ ++Add a missing call to ``va_end()`` in ``Modules/_hashopenssl.c``. +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index a4889450821..4873bb11aa0 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -311,6 +311,7 @@ _setException(PyObject *exc, const char* altmsg, ...) + } else { + PyErr_FormatV(exc, altmsg, vargs); + } ++ va_end(vargs); + return NULL; + } + va_end(vargs); +-- +2.34.1 + + +From b906713972396823c9e2e04421f9dbcfdc6a6c94 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Wed, 11 Aug 2021 16:51:03 +0200 +Subject: [PATCH 02/11] Backport PyModule_AddObjectRef as + _PyModule_AddObjectRef + +Having PyModule_AddObjectRef available should make backporting +newer patches easier. The new API is much safer. +The backport adds an underscore so that we don't break extension +modules that define PyModule_AddObjectRef themselves on Python<=3.9 +(which would be a virtuous thing to do). +--- + Include/modsupport.h | 10 ++++++++++ + Python/modsupport.c | 13 +++++++++++-- + 2 files changed, 21 insertions(+), 2 deletions(-) + +diff --git a/Include/modsupport.h b/Include/modsupport.h +index 4c4aab6..d9fac52 100644 +--- a/Include/modsupport.h ++++ b/Include/modsupport.h +@@ -136,7 +136,17 @@ PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords( + void _PyArg_Fini(void); + #endif /* Py_LIMITED_API */ + ++// Add an attribute with name 'name' and value 'obj' to the module 'mod. ++// On success, return 0 on success. ++// On error, raise an exception and return -1. ++// Backported from Python 3.10, where it's available without the underscore ++// in the name, to ease porting patches to RHEL ++PyAPI_FUNC(int) _PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value); ++ ++// Similar to PyModule_AddObjectRef() but steal a reference to 'obj' ++// (Py_DECREF(obj)) on success (if it returns 0). + PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *); ++ + PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long); + PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *); + #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +diff --git a/Python/modsupport.c b/Python/modsupport.c +index 13482c6..fca1083 100644 +--- a/Python/modsupport.c ++++ b/Python/modsupport.c +@@ -631,7 +631,7 @@ va_build_stack(PyObject **small_stack, Py_ssize_t small_stack_len, + + + int +-PyModule_AddObject(PyObject *m, const char *name, PyObject *o) ++_PyModule_AddObjectRef(PyObject *m, const char *name, PyObject *o) + { + PyObject *dict; + if (!PyModule_Check(m)) { +@@ -655,10 +655,19 @@ PyModule_AddObject(PyObject *m, const char *name, PyObject *o) + } + if (PyDict_SetItemString(dict, name, o)) + return -1; +- Py_DECREF(o); + return 0; + } + ++int ++PyModule_AddObject(PyObject *mod, const char *name, PyObject *value) ++{ ++ int res = _PyModule_AddObjectRef(mod, name, value); ++ if (res == 0) { ++ Py_DECREF(value); ++ } ++ return res; ++} ++ + int + PyModule_AddIntConstant(PyObject *m, const char *name, long value) + { +-- +2.34.1 + + +From c67b383ffd3ccacedacbeb91c3bdeaf5f829ca09 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Fri, 13 Aug 2021 13:16:43 +0200 +Subject: [PATCH 03/11] _hashopenssl: Uncomment and use initialization function + list + +This simplifies backporting of future changes. + +We use this change instead of Python 3.10's: + bpo-1635741: Port _hashlib to multiphase initialization (GH-23358) +--- + Modules/_hashopenssl.c | 30 +++++------------------------- + 1 file changed, 5 insertions(+), 25 deletions(-) + +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index a488945..62cf769 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -2216,7 +2216,6 @@ hashlib_init_hmactype(PyObject *module) + return 0; + } + +-#if 0 + static PyModuleDef_Slot hashlib_slots[] = { + /* OpenSSL 1.0.2 and LibreSSL */ + {Py_mod_exec, hashlib_openssl_legacy_init}, +@@ -2227,7 +2226,6 @@ static PyModuleDef_Slot hashlib_slots[] = { + {Py_mod_exec, hashlib_md_meth_names}, + {0, NULL} + }; +-#endif + + static struct PyModuleDef _hashlibmodule = { + PyModuleDef_HEAD_INIT, +@@ -2255,29 +2253,11 @@ PyInit__hashlib(void) + return NULL; + } + +- if (hashlib_openssl_legacy_init(m) < 0) { +- Py_DECREF(m); +- return NULL; +- } +- if (hashlib_init_hashtable(m) < 0) { +- Py_DECREF(m); +- return NULL; +- } +- if (hashlib_init_evptype(m) < 0) { +- Py_DECREF(m); +- return NULL; +- } +- if (hashlib_init_evpxoftype(m) < 0) { +- Py_DECREF(m); +- return NULL; +- } +- if (hashlib_init_hmactype(m) < 0) { +- Py_DECREF(m); +- return NULL; +- } +- if (hashlib_md_meth_names(m) == -1) { +- Py_DECREF(m); +- return NULL; ++ for (int i=0; hashlib_slots[i].slot; i++) { ++ if (((int (*)(PyObject*))hashlib_slots[i].value)(m) < 0) { ++ Py_DECREF(m); ++ return NULL; ++ } + } + + return m; +-- +2.34.1 + + +From c49c1416d22fffc78204d66987f40e6d17a95c01 Mon Sep 17 00:00:00 2001 +From: Christian Heimes +Date: Sat, 27 Mar 2021 14:55:03 +0100 +Subject: [PATCH 04/11] bpo-40645: use C implementation of HMAC (GH-24920, + GH-25063, GH-26079) + +This backports the feature and 2 subsequent bugfixes +from: https://bugs.python.org/issue40645 + +Signed-off-by: Christian Heimes +Co-authored-by: Erlend Egeberg Aasland +Co-Authored-By: Pablo Galindo +--- + Lib/hashlib.py | 1 + + Lib/hmac.py | 86 ++++++---- + Lib/test/test_hmac.py | 114 +++++++------ + .../2021-03-19-10-22-17.bpo-40645.5pXhb-.rst | 2 + + Modules/_hashopenssl.c | 150 ++++++++++++++++-- + Modules/clinic/_hashopenssl.c.h | 38 +---- + 6 files changed, 265 insertions(+), 126 deletions(-) + create mode 100644 Misc/NEWS.d/next/Library/2021-03-19-10-22-17.bpo-40645.5pXhb-.rst + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 58c340d..ffa3be0 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -173,6 +173,7 @@ try: + algorithms_available = algorithms_available.union( + _hashlib.openssl_md_meth_names) + except ImportError: ++ _hashlib = None + new = __py_new + __get_hash = __get_builtin_constructor + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 180bc37..8b4f920 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -8,11 +8,12 @@ try: + import _hashlib as _hashopenssl + except ImportError: + _hashopenssl = None +- _openssl_md_meths = None ++ _functype = None + from _operator import _compare_digest as compare_digest + else: +- _openssl_md_meths = frozenset(_hashopenssl.openssl_md_meth_names) + compare_digest = _hashopenssl.compare_digest ++ _functype = type(_hashopenssl.openssl_sha256) # builtin type ++ + import hashlib as _hashlib + + trans_5C = bytes((x ^ 0x5C) for x in range(256)) +@@ -23,7 +24,6 @@ trans_36 = bytes((x ^ 0x36) for x in range(256)) + digest_size = None + + +- + class HMAC: + """RFC 2104 HMAC class. Also complies with RFC 4231. + +@@ -32,7 +32,7 @@ class HMAC: + blocksize = 64 # 512-bit HMAC; can be changed in subclasses. + + __slots__ = ( +- "_digest_cons", "_inner", "_outer", "block_size", "digest_size" ++ "_hmac", "_inner", "_outer", "block_size", "digest_size" + ) + + def __init__(self, key, msg=None, digestmod=''): +@@ -55,15 +55,30 @@ class HMAC: + if not digestmod: + raise TypeError("Missing required parameter 'digestmod'.") + ++ if _hashopenssl and isinstance(digestmod, (str, _functype)): ++ try: ++ self._init_hmac(key, msg, digestmod) ++ except _hashopenssl.UnsupportedDigestmodError: ++ self._init_old(key, msg, digestmod) ++ else: ++ self._init_old(key, msg, digestmod) ++ ++ def _init_hmac(self, key, msg, digestmod): ++ self._hmac = _hashopenssl.hmac_new(key, msg, digestmod=digestmod) ++ self.digest_size = self._hmac.digest_size ++ self.block_size = self._hmac.block_size ++ ++ def _init_old(self, key, msg, digestmod): + if callable(digestmod): +- self._digest_cons = digestmod ++ digest_cons = digestmod + elif isinstance(digestmod, str): +- self._digest_cons = lambda d=b'': _hashlib.new(digestmod, d) ++ digest_cons = lambda d=b'': _hashlib.new(digestmod, d) + else: +- self._digest_cons = lambda d=b'': digestmod.new(d) ++ digest_cons = lambda d=b'': digestmod.new(d) + +- self._outer = self._digest_cons() +- self._inner = self._digest_cons() ++ self._hmac = None ++ self._outer = digest_cons() ++ self._inner = digest_cons() + self.digest_size = self._inner.digest_size + + if hasattr(self._inner, 'block_size'): +@@ -79,13 +94,13 @@ class HMAC: + RuntimeWarning, 2) + blocksize = self.blocksize + ++ if len(key) > blocksize: ++ key = digest_cons(key).digest() ++ + # self.blocksize is the default blocksize. self.block_size is + # effective block size as well as the public API attribute. + self.block_size = blocksize + +- if len(key) > blocksize: +- key = self._digest_cons(key).digest() +- + key = key.ljust(blocksize, b'\0') + self._outer.update(key.translate(trans_5C)) + self._inner.update(key.translate(trans_36)) +@@ -94,23 +109,15 @@ class HMAC: + + @property + def name(self): +- return "hmac-" + self._inner.name +- +- @property +- def digest_cons(self): +- return self._digest_cons +- +- @property +- def inner(self): +- return self._inner +- +- @property +- def outer(self): +- return self._outer ++ if self._hmac: ++ return self._hmac.name ++ else: ++ return f"hmac-{self._inner.name}" + + def update(self, msg): + """Feed data from msg into this hashing object.""" +- self._inner.update(msg) ++ inst = self._hmac or self._inner ++ inst.update(msg) + + def copy(self): + """Return a separate copy of this hashing object. +@@ -119,10 +126,14 @@ class HMAC: + """ + # Call __new__ directly to avoid the expensive __init__. + other = self.__class__.__new__(self.__class__) +- other._digest_cons = self._digest_cons + other.digest_size = self.digest_size +- other._inner = self._inner.copy() +- other._outer = self._outer.copy() ++ if self._hmac: ++ other._hmac = self._hmac.copy() ++ other._inner = other._outer = None ++ else: ++ other._hmac = None ++ other._inner = self._inner.copy() ++ other._outer = self._outer.copy() + return other + + def _current(self): +@@ -130,9 +141,12 @@ class HMAC: + + To be used only internally with digest() and hexdigest(). + """ +- h = self._outer.copy() +- h.update(self._inner.digest()) +- return h ++ if self._hmac: ++ return self._hmac ++ else: ++ h = self._outer.copy() ++ h.update(self._inner.digest()) ++ return h + + def digest(self): + """Return the hash value of this hashing object. +@@ -179,9 +193,11 @@ def digest(key, msg, digest): + A hashlib constructor returning a new hash object. *OR* + A module supporting PEP 247. + """ +- if (_hashopenssl is not None and +- isinstance(digest, str) and digest in _openssl_md_meths): +- return _hashopenssl.hmac_digest(key, msg, digest) ++ if _hashopenssl is not None and isinstance(digest, (str, _functype)): ++ try: ++ return _hashopenssl.hmac_digest(key, msg, digest) ++ except _hashopenssl.UnsupportedDigestmodError: ++ pass + + if callable(digest): + digest_cons = digest +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index 6daf22c..adf52ad 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -11,14 +11,21 @@ from test.support import hashlib_helper + from _operator import _compare_digest as operator_compare_digest + + try: ++ import _hashlib as _hashopenssl + from _hashlib import HMAC as C_HMAC + from _hashlib import hmac_new as c_hmac_new + from _hashlib import compare_digest as openssl_compare_digest + except ImportError: ++ _hashopenssl = None + C_HMAC = None + c_hmac_new = None + openssl_compare_digest = None + ++try: ++ import _sha256 as sha256_module ++except ImportError: ++ sha256_module = None ++ + + def ignore_warning(func): + @functools.wraps(func) +@@ -32,22 +39,27 @@ def ignore_warning(func): + + class TestVectorsTestCase(unittest.TestCase): + +- def asssert_hmac( +- self, key, data, digest, hashfunc, hashname, digest_size, block_size ++ def assert_hmac_internals( ++ self, h, digest, hashname, digest_size, block_size + ): +- h = hmac.HMAC(key, data, digestmod=hashfunc) + self.assertEqual(h.hexdigest().upper(), digest.upper()) + self.assertEqual(h.digest(), binascii.unhexlify(digest)) + self.assertEqual(h.name, f"hmac-{hashname}") + self.assertEqual(h.digest_size, digest_size) + self.assertEqual(h.block_size, block_size) + ++ def assert_hmac( ++ self, key, data, digest, hashfunc, hashname, digest_size, block_size ++ ): ++ h = hmac.HMAC(key, data, digestmod=hashfunc) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) ++ + h = hmac.HMAC(key, data, digestmod=hashname) +- self.assertEqual(h.hexdigest().upper(), digest.upper()) +- self.assertEqual(h.digest(), binascii.unhexlify(digest)) +- self.assertEqual(h.name, f"hmac-{hashname}") +- self.assertEqual(h.digest_size, digest_size) +- self.assertEqual(h.block_size, block_size) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) + + h = hmac.HMAC(key, digestmod=hashname) + h2 = h.copy() +@@ -56,11 +68,9 @@ class TestVectorsTestCase(unittest.TestCase): + self.assertEqual(h.hexdigest().upper(), digest.upper()) + + h = hmac.new(key, data, digestmod=hashname) +- self.assertEqual(h.hexdigest().upper(), digest.upper()) +- self.assertEqual(h.digest(), binascii.unhexlify(digest)) +- self.assertEqual(h.name, f"hmac-{hashname}") +- self.assertEqual(h.digest_size, digest_size) +- self.assertEqual(h.block_size, block_size) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) + + h = hmac.new(key, None, digestmod=hashname) + h.update(data) +@@ -81,23 +91,18 @@ class TestVectorsTestCase(unittest.TestCase): + hmac.digest(key, data, digest=hashfunc), + binascii.unhexlify(digest) + ) +- with unittest.mock.patch('hmac._openssl_md_meths', {}): +- self.assertEqual( +- hmac.digest(key, data, digest=hashname), +- binascii.unhexlify(digest) +- ) +- self.assertEqual( +- hmac.digest(key, data, digest=hashfunc), +- binascii.unhexlify(digest) +- ) ++ ++ h = hmac.HMAC.__new__(hmac.HMAC) ++ h._init_old(key, data, digestmod=hashname) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) + + if c_hmac_new is not None: + h = c_hmac_new(key, data, digestmod=hashname) +- self.assertEqual(h.hexdigest().upper(), digest.upper()) +- self.assertEqual(h.digest(), binascii.unhexlify(digest)) +- self.assertEqual(h.name, f"hmac-{hashname}") +- self.assertEqual(h.digest_size, digest_size) +- self.assertEqual(h.block_size, block_size) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) + + h = c_hmac_new(key, digestmod=hashname) + h2 = h.copy() +@@ -105,12 +110,24 @@ class TestVectorsTestCase(unittest.TestCase): + h.update(data) + self.assertEqual(h.hexdigest().upper(), digest.upper()) + ++ func = getattr(_hashopenssl, f"openssl_{hashname}") ++ h = c_hmac_new(key, data, digestmod=func) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) ++ ++ h = hmac.HMAC.__new__(hmac.HMAC) ++ h._init_hmac(key, data, digestmod=hashname) ++ self.assert_hmac_internals( ++ h, digest, hashname, digest_size, block_size ++ ) ++ + @hashlib_helper.requires_hashdigest('md5', openssl=True) + def test_md5_vectors(self): + # Test the HMAC module against test vectors from the RFC. + + def md5test(key, data, digest): +- self.asssert_hmac( ++ self.assert_hmac( + key, data, digest, + hashfunc=hashlib.md5, + hashname="md5", +@@ -150,7 +167,7 @@ class TestVectorsTestCase(unittest.TestCase): + @hashlib_helper.requires_hashdigest('sha1', openssl=True) + def test_sha_vectors(self): + def shatest(key, data, digest): +- self.asssert_hmac( ++ self.assert_hmac( + key, data, digest, + hashfunc=hashlib.sha1, + hashname="sha1", +@@ -191,7 +208,7 @@ class TestVectorsTestCase(unittest.TestCase): + def hmactest(key, data, hexdigests): + digest = hexdigests[hashfunc] + +- self.asssert_hmac( ++ self.assert_hmac( + key, data, digest, + hashfunc=hashfunc, + hashname=hash_name, +@@ -427,6 +444,15 @@ class ConstructorTestCase(unittest.TestCase): + ): + C_HMAC() + ++ @unittest.skipUnless(sha256_module is not None, 'need _sha256') ++ def test_with_sha256_module(self): ++ h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256) ++ self.assertEqual(h.hexdigest(), self.expected) ++ self.assertEqual(h.name, "hmac-sha256") ++ ++ digest = hmac.digest(b"key", b"hash this!", sha256_module.sha256) ++ self.assertEqual(digest, binascii.unhexlify(self.expected)) ++ + + class SanityTestCase(unittest.TestCase): + +@@ -447,21 +473,21 @@ class SanityTestCase(unittest.TestCase): + class CopyTestCase(unittest.TestCase): + + @hashlib_helper.requires_hashdigest('sha256') +- def test_attributes(self): ++ def test_attributes_old(self): + # Testing if attributes are of same type. +- h1 = hmac.HMAC(b"key", digestmod="sha256") ++ h1 = hmac.HMAC.__new__(hmac.HMAC) ++ h1._init_old(b"key", b"msg", digestmod="sha256") + h2 = h1.copy() +- self.assertTrue(h1._digest_cons == h2._digest_cons, +- "digest constructors don't match.") + self.assertEqual(type(h1._inner), type(h2._inner), + "Types of inner don't match.") + self.assertEqual(type(h1._outer), type(h2._outer), + "Types of outer don't match.") + + @hashlib_helper.requires_hashdigest('sha256') +- def test_realcopy(self): ++ def test_realcopy_old(self): + # Testing if the copy method created a real copy. +- h1 = hmac.HMAC(b"key", digestmod="sha256") ++ h1 = hmac.HMAC.__new__(hmac.HMAC) ++ h1._init_old(b"key", b"msg", digestmod="sha256") + h2 = h1.copy() + # Using id() in case somebody has overridden __eq__/__ne__. + self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.") +@@ -469,17 +495,15 @@ class CopyTestCase(unittest.TestCase): + "No real copy of the attribute 'inner'.") + self.assertTrue(id(h1._outer) != id(h2._outer), + "No real copy of the attribute 'outer'.") +- self.assertEqual(h1._inner, h1.inner) +- self.assertEqual(h1._outer, h1.outer) +- self.assertEqual(h1._digest_cons, h1.digest_cons) ++ self.assertIs(h1._hmac, None) + ++ @unittest.skipIf(_hashopenssl is None, "test requires _hashopenssl") + @hashlib_helper.requires_hashdigest('sha256') +- def test_properties(self): +- # deprecated properties +- h1 = hmac.HMAC(b"key", digestmod="sha256") +- self.assertEqual(h1._inner, h1.inner) +- self.assertEqual(h1._outer, h1.outer) +- self.assertEqual(h1._digest_cons, h1.digest_cons) ++ def test_realcopy_hmac(self): ++ h1 = hmac.HMAC.__new__(hmac.HMAC) ++ h1._init_hmac(b"key", b"msg", digestmod="sha256") ++ h2 = h1.copy() ++ self.assertTrue(id(h1._hmac) != id(h2._hmac)) + + @hashlib_helper.requires_hashdigest('sha256') + def test_equality(self): +diff --git a/Misc/NEWS.d/next/Library/2021-03-19-10-22-17.bpo-40645.5pXhb-.rst b/Misc/NEWS.d/next/Library/2021-03-19-10-22-17.bpo-40645.5pXhb-.rst +new file mode 100644 +index 0000000..a9ab1c0 +--- /dev/null ++++ b/Misc/NEWS.d/next/Library/2021-03-19-10-22-17.bpo-40645.5pXhb-.rst +@@ -0,0 +1,2 @@ ++The :mod:`hmac` module now uses OpenSSL's HMAC implementation when digestmod ++argument is a hash name or builtin hash function. +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 62cf769..71ac832 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -260,6 +260,8 @@ typedef struct { + PyTypeObject *EVPXOFtype; + #endif + _Py_hashtable_t *hashtable; ++ PyObject *constructs; ++ PyObject *unsupported_digestmod_error; + } _hashlibstate; + + static inline _hashlibstate* +@@ -420,6 +422,48 @@ py_digest_by_name(PyObject *module, const char *name, enum Py_hash_type py_ht) + return digest; + } + ++/* Get digest EVP from object ++ * ++ * * string ++ * * _hashopenssl builtin function ++ * ++ * on error returns NULL with exception set. ++ */ ++static PY_EVP_MD* ++py_digest_by_digestmod(PyObject *module, PyObject *digestmod, enum Py_hash_type py_ht) { ++ PY_EVP_MD* evp; ++ PyObject *name_obj = NULL; ++ const char *name; ++ ++ if (PyUnicode_Check(digestmod)) { ++ name_obj = digestmod; ++ } else { ++ _hashlibstate *state = get_hashlib_state(module); ++ // borrowed ref ++ name_obj = PyDict_GetItem(state->constructs, digestmod); ++ } ++ if (name_obj == NULL) { ++ _hashlibstate *state = get_hashlib_state(module); ++ PyErr_Clear(); ++ PyErr_Format( ++ state->unsupported_digestmod_error, ++ "Unsupported digestmod %R", digestmod); ++ return NULL; ++ } ++ ++ name = PyUnicode_AsUTF8(name_obj); ++ if (name == NULL) { ++ return NULL; ++ } ++ ++ evp = py_digest_by_name(module, name, py_ht); ++ if (evp == NULL) { ++ return NULL; ++ } ++ ++ return evp; ++} ++ + static EVPobject * + newEVPobject(PyTypeObject *type) + { +@@ -1238,7 +1282,6 @@ pbkdf2_hmac_impl(PyObject *module, const char *hash_name, + + PY_EVP_MD *digest = py_digest_by_name(module, hash_name, Py_ht_pbkdf2); + if (digest == NULL) { +- PyErr_SetString(PyExc_ValueError, "unsupported hash type"); + goto end; + } + +@@ -1443,25 +1486,21 @@ _hashlib.hmac_digest as _hashlib_hmac_singleshot + + key: Py_buffer + msg: Py_buffer +- digest: str ++ digest: object + + Single-shot HMAC. + [clinic start generated code]*/ + + static PyObject * + _hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key, +- Py_buffer *msg, const char *digest) +-/*[clinic end generated code: output=15658ede5ab98185 input=019dffc571909a46]*/ ++ Py_buffer *msg, PyObject *digest) ++/*[clinic end generated code: output=82f19965d12706ac input=0a0790cc3db45c2e]*/ + { + unsigned char md[EVP_MAX_MD_SIZE] = {0}; + unsigned int md_len = 0; + unsigned char *result; + PY_EVP_MD *evp; + +- evp = py_digest_by_name(module, digest, Py_ht_mac); +- if (evp == NULL) { +- return NULL; +- } + if (key->len > INT_MAX) { + PyErr_SetString(PyExc_OverflowError, + "key is too long."); +@@ -1473,7 +1512,7 @@ _hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key, + return NULL; + } + +- evp = py_digest_by_name(module, digest, Py_ht_mac); ++ evp = py_digest_by_digestmod(module, digest, Py_ht_mac); + if (evp == NULL) { + return NULL; + } +@@ -1505,15 +1544,15 @@ _hashlib.hmac_new + + key: Py_buffer + msg as msg_obj: object(c_default="NULL") = b'' +- digestmod: str(c_default="NULL") = None ++ digestmod: object(c_default="NULL") = None + + Return a new hmac object. + [clinic start generated code]*/ + + static PyObject * + _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj, +- const char *digestmod) +-/*[clinic end generated code: output=9a35673be0cbea1b input=a0878868eb190134]*/ ++ PyObject *digestmod) ++/*[clinic end generated code: output=c20d9e4d9ed6d219 input=5f4071dcc7f34362]*/ + { + PyTypeObject *type = get_hashlib_state(module)->HMACtype; + PY_EVP_MD *digest; +@@ -1527,14 +1566,14 @@ _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj, + return NULL; + } + +- if ((digestmod == NULL) || !strlen(digestmod)) { ++ if (digestmod == NULL) { + PyErr_SetString( + PyExc_TypeError, "Missing required parameter 'digestmod'."); + return NULL; + } + +- digest = py_digest_by_name(module, digestmod, Py_ht_mac); +- if (!digest) { ++ digest = py_digest_by_digestmod(module, digestmod, Py_ht_mac); ++ if (digest == NULL) { + return NULL; + } + +@@ -2106,6 +2145,8 @@ hashlib_traverse(PyObject *m, visitproc visit, void *arg) + #ifdef PY_OPENSSL_HAS_SHAKE + Py_VISIT(state->EVPXOFtype); + #endif ++ Py_VISIT(state->constructs); ++ Py_VISIT(state->unsupported_digestmod_error); + return 0; + } + +@@ -2118,10 +2159,14 @@ hashlib_clear(PyObject *m) + #ifdef PY_OPENSSL_HAS_SHAKE + Py_CLEAR(state->EVPXOFtype); + #endif ++ Py_CLEAR(state->constructs); ++ Py_CLEAR(state->unsupported_digestmod_error); ++ + if (state->hashtable != NULL) { + _Py_hashtable_destroy(state->hashtable); + state->hashtable = NULL; + } ++ + return 0; + } + +@@ -2216,6 +2261,79 @@ hashlib_init_hmactype(PyObject *module) + return 0; + } + ++static int ++hashlib_init_constructors(PyObject *module) ++{ ++ /* Create dict from builtin openssl_hash functions to name ++ * {_hashlib.openssl_sha256: "sha256", ...} ++ */ ++ PyModuleDef *mdef; ++ PyMethodDef *fdef; ++ PyObject *proxy; ++ PyObject *func, *name_obj; ++ _hashlibstate *state = get_hashlib_state(module); ++ ++ mdef = PyModule_GetDef(module); ++ if (mdef == NULL) { ++ return -1; ++ } ++ ++ state->constructs = PyDict_New(); ++ if (state->constructs == NULL) { ++ return -1; ++ } ++ ++ for (fdef = mdef->m_methods; fdef->ml_name != NULL; fdef++) { ++ if (strncmp(fdef->ml_name, "openssl_", 8)) { ++ continue; ++ } ++ name_obj = PyUnicode_FromString(fdef->ml_name + 8); ++ if (name_obj == NULL) { ++ return -1; ++ } ++ func = PyObject_GetAttrString(module, fdef->ml_name); ++ if (func == NULL) { ++ Py_DECREF(name_obj); ++ return -1; ++ } ++ int rc = PyDict_SetItem(state->constructs, func, name_obj); ++ Py_DECREF(func); ++ Py_DECREF(name_obj); ++ if (rc < 0) { ++ return -1; ++ } ++ } ++ ++ proxy = PyDictProxy_New(state->constructs); ++ if (proxy == NULL) { ++ return -1; ++ } ++ ++ int rc = _PyModule_AddObjectRef(module, "_constructors", proxy); ++ Py_DECREF(proxy); ++ if (rc < 0) { ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++hashlib_exception(PyObject *module) ++{ ++ _hashlibstate *state = get_hashlib_state(module); ++ state->unsupported_digestmod_error = PyErr_NewException( ++ "_hashlib.UnsupportedDigestmodError", PyExc_ValueError, NULL); ++ if (state->unsupported_digestmod_error == NULL) { ++ return -1; ++ } ++ if (_PyModule_AddObjectRef(module, "UnsupportedDigestmodError", ++ state->unsupported_digestmod_error) < 0) { ++ return -1; ++ } ++ return 0; ++} ++ ++ + static PyModuleDef_Slot hashlib_slots[] = { + /* OpenSSL 1.0.2 and LibreSSL */ + {Py_mod_exec, hashlib_openssl_legacy_init}, +@@ -2224,6 +2342,8 @@ static PyModuleDef_Slot hashlib_slots[] = { + {Py_mod_exec, hashlib_init_evpxoftype}, + {Py_mod_exec, hashlib_init_hmactype}, + {Py_mod_exec, hashlib_md_meth_names}, ++ {Py_mod_exec, hashlib_init_constructors}, ++ {Py_mod_exec, hashlib_exception}, + {0, NULL} + }; + +diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h +index 68aa765..4466ec4 100644 +--- a/Modules/clinic/_hashopenssl.c.h ++++ b/Modules/clinic/_hashopenssl.c.h +@@ -1106,7 +1106,7 @@ PyDoc_STRVAR(_hashlib_hmac_singleshot__doc__, + + static PyObject * + _hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key, +- Py_buffer *msg, const char *digest); ++ Py_buffer *msg, PyObject *digest); + + static PyObject * + _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +@@ -1117,7 +1117,7 @@ _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nar + PyObject *argsbuf[3]; + Py_buffer key = {NULL, NULL}; + Py_buffer msg = {NULL, NULL}; +- const char *digest; ++ PyObject *digest; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf); + if (!args) { +@@ -1137,19 +1137,7 @@ _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nar + _PyArg_BadArgument("hmac_digest", "argument 'msg'", "contiguous buffer", args[1]); + goto exit; + } +- if (!PyUnicode_Check(args[2])) { +- _PyArg_BadArgument("hmac_digest", "argument 'digest'", "str", args[2]); +- goto exit; +- } +- Py_ssize_t digest_length; +- digest = PyUnicode_AsUTF8AndSize(args[2], &digest_length); +- if (digest == NULL) { +- goto exit; +- } +- if (strlen(digest) != (size_t)digest_length) { +- PyErr_SetString(PyExc_ValueError, "embedded null character"); +- goto exit; +- } ++ digest = args[2]; + return_value = _hashlib_hmac_singleshot_impl(module, &key, &msg, digest); + + exit: +@@ -1176,7 +1164,7 @@ PyDoc_STRVAR(_hashlib_hmac_new__doc__, + + static PyObject * + _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj, +- const char *digestmod); ++ PyObject *digestmod); + + static PyObject * + _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +@@ -1188,7 +1176,7 @@ _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyO + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; + Py_buffer key = {NULL, NULL}; + PyObject *msg_obj = NULL; +- const char *digestmod = NULL; ++ PyObject *digestmod = NULL; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); + if (!args) { +@@ -1210,19 +1198,7 @@ _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyO + goto skip_optional_pos; + } + } +- if (!PyUnicode_Check(args[2])) { +- _PyArg_BadArgument("hmac_new", "argument 'digestmod'", "str", args[2]); +- goto exit; +- } +- Py_ssize_t digestmod_length; +- digestmod = PyUnicode_AsUTF8AndSize(args[2], &digestmod_length); +- if (digestmod == NULL) { +- goto exit; +- } +- if (strlen(digestmod) != (size_t)digestmod_length) { +- PyErr_SetString(PyExc_ValueError, "embedded null character"); +- goto exit; +- } ++ digestmod = args[2]; + skip_optional_pos: + return_value = _hashlib_hmac_new_impl(module, &key, msg_obj, digestmod); + +@@ -1442,4 +1418,4 @@ exit: + #ifndef _HASHLIB_GET_FIPS_MODE_METHODDEF + #define _HASHLIB_GET_FIPS_MODE_METHODDEF + #endif /* !defined(_HASHLIB_GET_FIPS_MODE_METHODDEF) */ +-/*[clinic end generated code: output=b6b280e46bf0b139 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=7ff9aad0bd53e7ce input=a9049054013a1b77]*/ +-- +2.34.1 + + +From f7ce31ebf3200952dadff556bfcbf2876139c823 Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Thu, 12 Dec 2019 16:58:31 +0100 +Subject: [PATCH 05/11] Expose blake2b and blake2s hashes from OpenSSL + +These aren't as powerful as Python's own implementation, but they can be +used under FIPS. +--- + Lib/test/test_hashlib.py | 6 ++ + Modules/_hashopenssl.c | 37 +++++++++++ + Modules/clinic/_hashopenssl.c.h | 106 +++++++++++++++++++++++++++++++- + 3 files changed, 148 insertions(+), 1 deletion(-) + +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 969e5e4..5b46016 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -354,6 +354,12 @@ class HashLibTestCase(unittest.TestCase): + # 2 is for hashlib.name(...) and hashlib.new(name, ...) + self.assertGreaterEqual(len(constructors), 2) + for hash_object_constructor in constructors: ++ ++ # OpenSSL's blake2s & blake2d don't support `key` ++ _name = hash_object_constructor.__name__ ++ if 'key' in kwargs and _name.startswith('openssl_blake2'): ++ return ++ + m = hash_object_constructor(data, **kwargs) + computed = m.hexdigest() if not shake else m.hexdigest(length) + self.assertEqual( +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 71ac832..0b2c65e 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -1138,6 +1138,41 @@ _hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj, + } + + ++/*[clinic input] ++_hashlib.openssl_blake2b ++ string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True ++Returns a blake2b hash object; optionally initialized with a string ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_blake2b_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=7a838b1643cde13e input=4ad7fd54268f3689]*/ ++ ++{ ++ return py_evp_fromname(module, Py_hash_blake2b, data_obj, usedforsecurity); ++} ++ ++/*[clinic input] ++_hashlib.openssl_blake2s ++ string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True ++Returns a blake2s hash object; optionally initialized with a string ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_blake2s_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=4eda6b40757471da input=1ed39481ffa4e26a]*/ ++ ++{ ++ return py_evp_fromname(module, Py_hash_blake2s, data_obj, usedforsecurity); ++} ++ ++ + #ifdef PY_OPENSSL_HAS_SHA3 + + /*[clinic input] +@@ -2124,6 +2159,8 @@ static struct PyMethodDef EVP_functions[] = { + _HASHLIB_OPENSSL_SHA256_METHODDEF + _HASHLIB_OPENSSL_SHA384_METHODDEF + _HASHLIB_OPENSSL_SHA512_METHODDEF ++ _HASHLIB_OPENSSL_BLAKE2B_METHODDEF ++ _HASHLIB_OPENSSL_BLAKE2S_METHODDEF + _HASHLIB_OPENSSL_SHA3_224_METHODDEF + _HASHLIB_OPENSSL_SHA3_256_METHODDEF + _HASHLIB_OPENSSL_SHA3_384_METHODDEF +diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h +index 4466ec4..54c22b2 100644 +--- a/Modules/clinic/_hashopenssl.c.h ++++ b/Modules/clinic/_hashopenssl.c.h +@@ -540,6 +540,110 @@ exit: + return return_value; + } + ++PyDoc_STRVAR(_hashlib_openssl_blake2b__doc__, ++"openssl_blake2b($module, /, string=b\'\', *, usedforsecurity=True)\n" ++"--\n" ++"\n" ++"Returns a blake2b hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_BLAKE2B_METHODDEF \ ++ {"openssl_blake2b", (PyCFunction)(void(*)(void))_hashlib_openssl_blake2b, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_blake2b__doc__}, ++ ++static PyObject * ++_hashlib_openssl_blake2b_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); ++ ++static PyObject * ++_hashlib_openssl_blake2b(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2b", 0}; ++ PyObject *argsbuf[2]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ int usedforsecurity = 1; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } ++skip_optional_pos: ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_blake2b_impl(module, data_obj, usedforsecurity); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_blake2s__doc__, ++"openssl_blake2s($module, /, string=b\'\', *, usedforsecurity=True)\n" ++"--\n" ++"\n" ++"Returns a blake2s hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_BLAKE2S_METHODDEF \ ++ {"openssl_blake2s", (PyCFunction)(void(*)(void))_hashlib_openssl_blake2s, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_blake2s__doc__}, ++ ++static PyObject * ++_hashlib_openssl_blake2s_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); ++ ++static PyObject * ++_hashlib_openssl_blake2s(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2s", 0}; ++ PyObject *argsbuf[2]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ int usedforsecurity = 1; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } ++skip_optional_pos: ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_blake2s_impl(module, data_obj, usedforsecurity); ++ ++exit: ++ return return_value; ++} ++ + #if defined(PY_OPENSSL_HAS_SHA3) + + PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__, +@@ -1418,4 +1522,4 @@ exit: + #ifndef _HASHLIB_GET_FIPS_MODE_METHODDEF + #define _HASHLIB_GET_FIPS_MODE_METHODDEF + #endif /* !defined(_HASHLIB_GET_FIPS_MODE_METHODDEF) */ +-/*[clinic end generated code: output=7ff9aad0bd53e7ce input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=fab05055e982f112 input=a9049054013a1b77]*/ +-- +2.34.1 + + +From b8956168975170b8e7a797b6aa23e0d356f5ebec Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 1 Aug 2019 17:57:05 +0200 +Subject: [PATCH 06/11] Use a stronger hash in multiprocessing handshake + +Adapted from patch by David Malcolm, +https://bugs.python.org/issue17258 +--- + Lib/multiprocessing/connection.py | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/Lib/multiprocessing/connection.py b/Lib/multiprocessing/connection.py +index 510e4b5..b68f2fb 100644 +--- a/Lib/multiprocessing/connection.py ++++ b/Lib/multiprocessing/connection.py +@@ -42,6 +42,10 @@ BUFSIZE = 8192 + # A very generous timeout when it comes to local connections... + CONNECTION_TIMEOUT = 20. + ++# The hmac module implicitly defaults to using MD5. ++# Support using a stronger algorithm for the challenge/response code: ++HMAC_DIGEST_NAME='sha256' ++ + _mmap_counter = itertools.count() + + default_family = 'AF_INET' +@@ -741,7 +745,7 @@ def deliver_challenge(connection, authkey): + "Authkey must be bytes, not {0!s}".format(type(authkey))) + message = os.urandom(MESSAGE_LENGTH) + connection.send_bytes(CHALLENGE + message) +- digest = hmac.new(authkey, message, 'md5').digest() ++ digest = hmac.new(authkey, message, HMAC_DIGEST_NAME).digest() + response = connection.recv_bytes(256) # reject large message + if response == digest: + connection.send_bytes(WELCOME) +@@ -757,7 +761,7 @@ def answer_challenge(connection, authkey): + message = connection.recv_bytes(256) # reject large message + assert message[:len(CHALLENGE)] == CHALLENGE, 'message = %r' % message + message = message[len(CHALLENGE):] +- digest = hmac.new(authkey, message, 'md5').digest() ++ digest = hmac.new(authkey, message, HMAC_DIGEST_NAME).digest() + connection.send_bytes(digest) + response = connection.recv_bytes(256) # reject large message + if response != WELCOME: +-- +2.34.1 + + +From 20d86957b863e80d1f71b5681fccdb1fd16128b9 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 25 Jul 2019 17:19:06 +0200 +Subject: [PATCH 07/11] Disable Python's hash implementations in FIPS mode, + forcing OpenSSL + +--- + Lib/hashlib.py | 11 +++++++---- + Lib/test/test_hashlib.py | 17 ++++++++++++----- + Modules/_blake2/blake2b_impl.c | 4 ++++ + Modules/_blake2/blake2module.c | 3 +++ + Modules/_blake2/blake2s_impl.c | 4 ++++ + Modules/hashlib.h | 23 +++++++++++++++++++++++ + setup.py | 27 ++++++++++++++++----------- + 7 files changed, 69 insertions(+), 20 deletions(-) + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index ffa3be0..3e3f4dd 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -70,14 +70,17 @@ __all__ = __always_supported + ('new', 'algorithms_guaranteed', + + __builtin_constructor_cache = {} + +-# Prefer our blake2 implementation ++# Prefer our blake2 implementation (unless in FIPS mode) + # OpenSSL 1.1.0 comes with a limited implementation of blake2b/s. The OpenSSL + # implementations neither support keyed blake2 (blake2 MAC) nor advanced + # features like salt, personalization, or tree hashing. OpenSSL hash-only + # variants are available as 'blake2b512' and 'blake2s256', though. +-__block_openssl_constructor = { +- 'blake2b', 'blake2s', +-} ++import _hashlib ++if _hashlib.get_fips_mode(): ++ __block_openssl_constructor = set() ++else: ++ __block_openssl_constructor = {'blake2b', 'blake2s'} ++ + + def __get_builtin_constructor(name): + cache = __builtin_constructor_cache +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 5b46016..72fdc67 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -35,14 +35,15 @@ else: + m.strip() for m in builtin_hashes.strip('"').lower().split(",") + } + +-# hashlib with and without OpenSSL backend for PBKDF2 +-# only import builtin_hashlib when all builtin hashes are available. +-# Otherwise import prints noise on stderr ++# RHEL: `_hashlib` is always importable and `hashlib` can't be imported ++# without it. + openssl_hashlib = import_fresh_module('hashlib', fresh=['_hashlib']) +-if builtin_hashes == default_builtin_hashes: ++try: + builtin_hashlib = import_fresh_module('hashlib', blocked=['_hashlib']) +-else: ++except ImportError: + builtin_hashlib = None ++else: ++ raise AssertionError('hashlib is importablee without _hashlib') + + try: + from _hashlib import HASH, HASHXOF, openssl_md_meth_names, get_fips_mode +@@ -116,6 +117,12 @@ class HashLibTestCase(unittest.TestCase): + except ModuleNotFoundError as error: + if self._warn_on_extension_import and module_name in builtin_hashes: + warnings.warn('Did a C extension fail to compile? %s' % error) ++ except ImportError: ++ if get_fips_mode() and module_name == '_blake2': ++ # blake2b & blake2s disabled under FIPS ++ return None ++ else: ++ raise + return None + + def __init__(self, *args, **kwargs): +diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c +index 7fb1296..bc01cd5 100644 +--- a/Modules/_blake2/blake2b_impl.c ++++ b/Modules/_blake2/blake2b_impl.c +@@ -96,6 +96,8 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2bObject *self = NULL; + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); ++ + self = new_BLAKE2bObject(type); + if (self == NULL) { + goto error; +@@ -274,6 +276,8 @@ _blake2_blake2b_update(BLAKE2bObject *self, PyObject *data) + { + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); ++ + GET_BUFFER_VIEW_OR_ERROUT(data, &buf); + + if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE) +diff --git a/Modules/_blake2/blake2module.c b/Modules/_blake2/blake2module.c +index ff142c9..144ec03 100644 +--- a/Modules/_blake2/blake2module.c ++++ b/Modules/_blake2/blake2module.c +@@ -9,6 +9,7 @@ + */ + + #include "Python.h" ++#include "../hashlib.h" + + #include "impl/blake2.h" + +@@ -57,6 +58,8 @@ PyInit__blake2(void) + PyObject *m; + PyObject *d; + ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ImportError, "blake2"); ++ + m = PyModule_Create(&blake2_module); + if (m == NULL) + return NULL; +diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c +index e3e90d0..e45f8f6 100644 +--- a/Modules/_blake2/blake2s_impl.c ++++ b/Modules/_blake2/blake2s_impl.c +@@ -96,6 +96,8 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2sObject *self = NULL; + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); ++ + self = new_BLAKE2sObject(type); + if (self == NULL) { + goto error; +@@ -274,6 +276,8 @@ _blake2_blake2s_update(BLAKE2sObject *self, PyObject *data) + { + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); ++ + GET_BUFFER_VIEW_OR_ERROUT(data, &buf); + + if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE) +diff --git a/Modules/hashlib.h b/Modules/hashlib.h +index 56ae7a5..45fb403 100644 +--- a/Modules/hashlib.h ++++ b/Modules/hashlib.h +@@ -1,5 +1,11 @@ + /* Common code for use by all hashlib related modules. */ + ++// RHEL: use OpenSSL to turn off unsupported modules under FIPS mode ++// EVP_default_properties_is_fips_enabled() on OpenSSL >= 3.0.0 ++#include ++// FIPS_mode() on OpenSSL < 3.0.0 ++#include ++ + /* + * Given a PyObject* obj, fill in the Py_buffer* viewp with the result + * of PyObject_GetBuffer. Sets an exception and issues the erraction +@@ -57,3 +63,20 @@ + * to allow the user to optimize based on the platform they're using. */ + #define HASHLIB_GIL_MINSIZE 2048 + ++__attribute__((__unused__)) ++static int ++_Py_hashlib_fips_error(PyObject *exc, char *name) { ++#if OPENSSL_VERSION_NUMBER >= 0x30000000L ++ if (EVP_default_properties_is_fips_enabled(NULL)) { ++#else ++ if (FIPS_mode()) { ++#endif ++ PyErr_Format(exc, "%s is not available in FIPS mode", name); ++ return 1; ++ } ++ return 0; ++} ++ ++#define FAIL_RETURN_IN_FIPS_MODE(exc, name) do { \ ++ if (_Py_hashlib_fips_error(exc, name)) return NULL; \ ++} while (0) +diff --git a/setup.py b/setup.py +index c6023e1..371674c 100644 +--- a/setup.py ++++ b/setup.py +@@ -2313,7 +2313,7 @@ class PyBuildExt(build_ext): + sources=sources, + depends=depends)) + +- def detect_openssl_hashlib(self): ++ def detect_openssl_args(self): + # Detect SSL support for the socket module (via _ssl) + config_vars = sysconfig.get_config_vars() + +@@ -2333,16 +2333,14 @@ class PyBuildExt(build_ext): + openssl_libs = split_var('OPENSSL_LIBS', '-l') + if not openssl_libs: + # libssl and libcrypto not found +- self.missing.extend(['_ssl', '_hashlib']) +- return None, None ++ raise ValueError('Cannot build for RHEL without OpenSSL') + + # Find OpenSSL includes + ssl_incs = find_file( + 'openssl/ssl.h', self.inc_dirs, openssl_includes + ) + if ssl_incs is None: +- self.missing.extend(['_ssl', '_hashlib']) +- return None, None ++ raise ValueError('Cannot build for RHEL without OpenSSL') + + # OpenSSL 1.0.2 uses Kerberos for KRB5 ciphers + krb5_h = find_file( +@@ -2352,12 +2350,20 @@ class PyBuildExt(build_ext): + if krb5_h: + ssl_incs.extend(krb5_h) + ++ return { ++ 'include_dirs': openssl_includes, ++ 'library_dirs': openssl_libdirs, ++ 'libraries': openssl_libs, ++ } ++ ++ def detect_openssl_hashlib(self): ++ ++ config_vars = sysconfig.get_config_vars() ++ + if config_vars.get("HAVE_X509_VERIFY_PARAM_SET1_HOST"): + self.add(Extension( + '_ssl', ['_ssl.c'], +- include_dirs=openssl_includes, +- library_dirs=openssl_libdirs, +- libraries=openssl_libs, ++ **self.detect_openssl_args(), + depends=[ + 'socketmodule.h', + '_ssl/debughelpers.c', +@@ -2370,9 +2376,7 @@ class PyBuildExt(build_ext): + + self.add(Extension('_hashlib', ['_hashopenssl.c'], + depends=['hashlib.h'], +- include_dirs=openssl_includes, +- library_dirs=openssl_libdirs, +- libraries=openssl_libs)) ++ **self.detect_openssl_args()) ) + + def detect_hash_builtins(self): + # By default we always compile these even when OpenSSL is available +@@ -2429,6 +2433,7 @@ class PyBuildExt(build_ext): + '_blake2/blake2b_impl.c', + '_blake2/blake2s_impl.c' + ], ++ **self.detect_openssl_args(), # for FIPS_mode verification + depends=blake2_deps + )) + +-- +2.34.1 + + +From 76d17b46469d642f2acda31bb5e9e636d69fe945 Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Fri, 29 Jan 2021 14:16:21 +0100 +Subject: [PATCH 08/11] Use python's fall back crypto implementations only if + we are not in FIPS mode + +--- + Lib/hashlib.py | 69 +++------------------------------------- + Lib/test/test_hashlib.py | 23 +++++++++++++- + 2 files changed, 27 insertions(+), 65 deletions(-) + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 3e3f4dd..b842f5f 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -67,7 +67,6 @@ algorithms_available = set(__always_supported) + __all__ = __always_supported + ('new', 'algorithms_guaranteed', + 'algorithms_available', 'pbkdf2_hmac') + +- + __builtin_constructor_cache = {} + + # Prefer our blake2 implementation (unless in FIPS mode) +@@ -83,6 +82,8 @@ else: + + + def __get_builtin_constructor(name): ++ if _hashlib.get_fips_mode(): ++ raise ValueError('unsupported hash type ' + name + '(in FIPS mode)') + cache = __builtin_constructor_cache + constructor = cache.get(name) + if constructor is not None: +@@ -176,79 +177,19 @@ try: + algorithms_available = algorithms_available.union( + _hashlib.openssl_md_meth_names) + except ImportError: +- _hashlib = None +- new = __py_new +- __get_hash = __get_builtin_constructor ++ raise # importing _hashlib should never fail on RHEL + + try: + # OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA + from _hashlib import pbkdf2_hmac + except ImportError: +- _trans_5C = bytes((x ^ 0x5C) for x in range(256)) +- _trans_36 = bytes((x ^ 0x36) for x in range(256)) +- +- def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None): +- """Password based key derivation function 2 (PKCS #5 v2.0) +- +- This Python implementations based on the hmac module about as fast +- as OpenSSL's PKCS5_PBKDF2_HMAC for short passwords and much faster +- for long passwords. +- """ +- if not isinstance(hash_name, str): +- raise TypeError(hash_name) +- +- if not isinstance(password, (bytes, bytearray)): +- password = bytes(memoryview(password)) +- if not isinstance(salt, (bytes, bytearray)): +- salt = bytes(memoryview(salt)) +- +- # Fast inline HMAC implementation +- inner = new(hash_name) +- outer = new(hash_name) +- blocksize = getattr(inner, 'block_size', 64) +- if len(password) > blocksize: +- password = new(hash_name, password).digest() +- password = password + b'\x00' * (blocksize - len(password)) +- inner.update(password.translate(_trans_36)) +- outer.update(password.translate(_trans_5C)) +- +- def prf(msg, inner=inner, outer=outer): +- # PBKDF2_HMAC uses the password as key. We can re-use the same +- # digest objects and just update copies to skip initialization. +- icpy = inner.copy() +- ocpy = outer.copy() +- icpy.update(msg) +- ocpy.update(icpy.digest()) +- return ocpy.digest() +- +- if iterations < 1: +- raise ValueError(iterations) +- if dklen is None: +- dklen = outer.digest_size +- if dklen < 1: +- raise ValueError(dklen) +- +- dkey = b'' +- loop = 1 +- from_bytes = int.from_bytes +- while len(dkey) < dklen: +- prev = prf(salt + loop.to_bytes(4, 'big')) +- # endianness doesn't matter here as long to / from use the same +- rkey = int.from_bytes(prev, 'big') +- for i in range(iterations - 1): +- prev = prf(prev) +- # rkey = rkey ^ prev +- rkey ^= from_bytes(prev, 'big') +- loop += 1 +- dkey += rkey.to_bytes(inner.digest_size, 'big') +- +- return dkey[:dklen] ++ raise # importing _hashlib should never fail on RHEL + + try: + # OpenSSL's scrypt requires OpenSSL 1.1+ + from _hashlib import scrypt + except ImportError: +- pass ++ raise # importing _hashlib should never fail on RHEL + + + for __func_name in __always_supported: +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 72fdc67..ac9c057 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -167,7 +167,13 @@ class HashLibTestCase(unittest.TestCase): + constructors.add(constructor) + + def add_builtin_constructor(name): +- constructor = getattr(hashlib, "__get_builtin_constructor")(name) ++ try: ++ constructor = getattr(hashlib, "__get_builtin_constructor")(name) ++ except ValueError: ++ if get_fips_mode(): ++ return ++ else: ++ raise + self.constructors_to_test[name].add(constructor) + + _md5 = self._conditional_import_module('_md5') +@@ -257,6 +263,20 @@ class HashLibTestCase(unittest.TestCase): + def test_new_upper_to_lower(self): + self.assertEqual(hashlib.new("SHA256").name, "sha256") + ++ @unittest.skipUnless(get_fips_mode(), "Builtin constructor only usable in FIPS mode") ++ def test_get_builtin_constructor_fips(self): ++ get_builtin_constructor = getattr(hashlib, ++ '__get_builtin_constructor') ++ with self.assertRaises(ValueError): ++ get_builtin_constructor('md5') ++ with self.assertRaises(ValueError): ++ get_builtin_constructor('sha256') ++ with self.assertRaises(ValueError): ++ get_builtin_constructor('blake2s') ++ with self.assertRaises(ValueError): ++ get_builtin_constructor('test') ++ ++ @unittest.skipIf(get_fips_mode(), "No builtin constructors in FIPS mode") + def test_get_builtin_constructor(self): + get_builtin_constructor = getattr(hashlib, + '__get_builtin_constructor') +@@ -1052,6 +1072,7 @@ class KDFTests(unittest.TestCase): + iterations=1, dklen=None) + self.assertEqual(out, self.pbkdf2_results['sha1'][0][0]) + ++ @unittest.skip("The python implementation of pbkdf2_hmac has been removed") + @unittest.skipIf(builtin_hashlib is None, "test requires builtin_hashlib") + def test_pbkdf2_hmac_py(self): + self._test_pbkdf2_hmac(builtin_hashlib.pbkdf2_hmac, builtin_hashes) +-- +2.34.1 + + +From 95c861dda1659f5bc47d56bed8d096f4debbe281 Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Wed, 31 Jul 2019 15:43:43 +0200 +Subject: [PATCH 09/11] Test equivalence of hashes for the various digests with + usedforsecurity=True/False + +--- + Lib/test/test_fips.py | 24 +++++++++++++++++++++ + Lib/test/test_hashlib.py | 46 ++++++++++++++++++++++++++++++---------- + 2 files changed, 59 insertions(+), 11 deletions(-) + create mode 100644 Lib/test/test_fips.py + +diff --git a/Lib/test/test_fips.py b/Lib/test/test_fips.py +new file mode 100644 +index 0000000..1f99dd7 +--- /dev/null ++++ b/Lib/test/test_fips.py +@@ -0,0 +1,24 @@ ++import unittest ++import hashlib, _hashlib ++ ++ ++ ++class HashlibFipsTests(unittest.TestCase): ++ ++ @unittest.skipUnless(_hashlib.get_fips_mode(), "Test only when FIPS is enabled") ++ def test_fips_imports(self): ++ """blake2s and blake2b should fail to import in FIPS mode ++ """ ++ with self.assertRaises(ValueError, msg='blake2s not available in FIPS'): ++ m = hashlib.blake2s() ++ with self.assertRaises(ValueError, msg='blake2b not available in FIPS'): ++ m = hashlib.blake2b() ++ ++ @unittest.skipIf(_hashlib.get_fips_mode(), "blake2 hashes are not available under FIPS") ++ def test_blake2_hashes(self): ++ self.assertEqual(hashlib.blake2b(b'abc').hexdigest(), _hashlib.openssl_blake2b(b'abc').hexdigest()) ++ self.assertEqual(hashlib.blake2s(b'abc').hexdigest(), _hashlib.openssl_blake2s(b'abc').hexdigest()) ++ ++ ++if __name__ == "__main__": ++ unittest.main() +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index ac9c057..0aa0129 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -20,6 +20,7 @@ import warnings + from test import support + from test.support import _4G, bigmemtest, import_fresh_module + from http.client import HTTPException ++from functools import partial + + # Were we compiled --with-pydebug or with #define Py_DEBUG? + COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount') +@@ -55,6 +56,11 @@ except ImportError: + def get_fips_mode(): + return 0 + ++if get_fips_mode(): ++ FIPS_DISABLED = {'md5'} ++else: ++ FIPS_DISABLED = set() ++ + try: + import _blake2 + except ImportError: +@@ -96,6 +102,11 @@ def read_vectors(hash_name): + parts[0] = bytes.fromhex(parts[0]) + yield parts + ++def _is_blake2_constructor(constructor): ++ if isinstance(constructor, partial): ++ constructor = constructor.func ++ return getattr(constructor, '__name__', '').startswith('openssl_blake2') ++ + + class HashLibTestCase(unittest.TestCase): + supported_hash_names = ( 'md5', 'MD5', 'sha1', 'SHA1', +@@ -138,15 +149,21 @@ class HashLibTestCase(unittest.TestCase): + for algorithm in algorithms: + self.constructors_to_test[algorithm] = set() + ++ def _add_constructor(algorithm, constructor): ++ constructors.add(partial(constructor, usedforsecurity=False)) ++ if algorithm not in FIPS_DISABLED: ++ constructors.add(constructor) ++ constructors.add(partial(constructor, usedforsecurity=True)) ++ + # For each algorithm, test the direct constructor and the use + # of hashlib.new given the algorithm name. + for algorithm, constructors in self.constructors_to_test.items(): +- constructors.add(getattr(hashlib, algorithm)) ++ _add_constructor(algorithm, getattr(hashlib, algorithm)) + def _test_algorithm_via_hashlib_new(data=None, _alg=algorithm, **kwargs): + if data is None: + return hashlib.new(_alg, **kwargs) + return hashlib.new(_alg, data, **kwargs) +- constructors.add(_test_algorithm_via_hashlib_new) ++ _add_constructor(algorithm, _test_algorithm_via_hashlib_new) + + _hashlib = self._conditional_import_module('_hashlib') + self._hashlib = _hashlib +@@ -158,13 +175,7 @@ class HashLibTestCase(unittest.TestCase): + for algorithm, constructors in self.constructors_to_test.items(): + constructor = getattr(_hashlib, 'openssl_'+algorithm, None) + if constructor: +- try: +- constructor() +- except ValueError: +- # default constructor blocked by crypto policy +- pass +- else: +- constructors.add(constructor) ++ _add_constructor(algorithm, constructor) + + def add_builtin_constructor(name): + try: +@@ -337,6 +348,8 @@ class HashLibTestCase(unittest.TestCase): + self.assertIn(h.name, self.supported_hash_names) + else: + self.assertNotIn(h.name, self.supported_hash_names) ++ if not h.name.startswith('blake2') and h.name not in FIPS_DISABLED: ++ self.assertEqual(h.name, hashlib.new(h.name).name) + self.assertEqual( + h.name, + hashlib.new(h.name, usedforsecurity=False).name +@@ -383,8 +396,10 @@ class HashLibTestCase(unittest.TestCase): + for hash_object_constructor in constructors: + + # OpenSSL's blake2s & blake2d don't support `key` +- _name = hash_object_constructor.__name__ +- if 'key' in kwargs and _name.startswith('openssl_blake2'): ++ if ( ++ 'key' in kwargs ++ and _is_blake2_constructor(hash_object_constructor) ++ ): + return + + m = hash_object_constructor(data, **kwargs) +@@ -965,6 +980,15 @@ class HashLibTestCase(unittest.TestCase): + ): + HASHXOF() + ++ @unittest.skipUnless(get_fips_mode(), 'Needs FIPS mode.') ++ def test_usedforsecurity_repeat(self): ++ """Make sure usedforsecurity flag isn't copied to other contexts""" ++ for i in range(3): ++ for cons in hashlib.md5, partial(hashlib.new, 'md5'): ++ self.assertRaises(ValueError, cons) ++ self.assertRaises(ValueError, partial(cons, usedforsecurity=True)) ++ self.assertEqual(cons(usedforsecurity=False).hexdigest(), ++ 'd41d8cd98f00b204e9800998ecf8427e') + + class KDFTests(unittest.TestCase): + +-- +2.34.1 + + +From 62cf5b80d205ff6d6e719286feccca6bd6fdd862 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 26 Aug 2019 19:39:48 +0200 +Subject: [PATCH 10/11] Guard against Python HMAC in FIPS mode + +--- + Lib/hmac.py | 13 +++++++++---- + Lib/test/test_hmac.py | 10 ++++++++++ + 2 files changed, 19 insertions(+), 4 deletions(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 8b4f920..20ef96c 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -16,8 +16,9 @@ else: + + import hashlib as _hashlib + +-trans_5C = bytes((x ^ 0x5C) for x in range(256)) +-trans_36 = bytes((x ^ 0x36) for x in range(256)) ++if not _hashopenssl.get_fips_mode(): ++ trans_5C = bytes((x ^ 0x5C) for x in range(256)) ++ trans_36 = bytes((x ^ 0x36) for x in range(256)) + + # The size of the digests returned by HMAC depends on the underlying + # hashing module used. Use digest_size from the instance of HMAC instead. +@@ -48,17 +49,18 @@ class HMAC: + msg argument. Passing it as a keyword argument is + recommended, though not required for legacy API reasons. + """ +- + if not isinstance(key, (bytes, bytearray)): + raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__) + + if not digestmod: + raise TypeError("Missing required parameter 'digestmod'.") + +- if _hashopenssl and isinstance(digestmod, (str, _functype)): ++ if _hashopenssl.get_fips_mode() or (_hashopenssl and isinstance(digestmod, (str, _functype))): + try: + self._init_hmac(key, msg, digestmod) + except _hashopenssl.UnsupportedDigestmodError: ++ if _hashopenssl.get_fips_mode(): ++ raise + self._init_old(key, msg, digestmod) + else: + self._init_old(key, msg, digestmod) +@@ -69,6 +71,9 @@ class HMAC: + self.block_size = self._hmac.block_size + + def _init_old(self, key, msg, digestmod): ++ if _hashopenssl.get_fips_mode(): ++ # In FIPS mode, use OpenSSL anyway: raise the appropriate error ++ return self._init_hmac(key, msg, digestmod) + if callable(digestmod): + digest_cons = digestmod + elif isinstance(digestmod, str): +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index adf52ad..41e6a14 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -5,6 +5,7 @@ import hashlib + import unittest + import unittest.mock + import warnings ++from _hashlib import get_fips_mode + + from test.support import hashlib_helper + +@@ -339,6 +340,7 @@ class TestVectorsTestCase(unittest.TestCase): + def test_sha512_rfc4231(self): + self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128) + ++ #unittest.skipIf(get_fips_mode(), 'MockCrazyHash unacceptable in FIPS mode.') + @hashlib_helper.requires_hashdigest('sha256') + def test_legacy_block_size_warnings(self): + class MockCrazyHash(object): +@@ -351,6 +353,11 @@ class TestVectorsTestCase(unittest.TestCase): + def digest(self): + return self._x.digest() + ++ if get_fips_mode(): ++ with self.assertRaises(ValueError): ++ hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash) ++ return ++ + with warnings.catch_warnings(): + warnings.simplefilter('error', RuntimeWarning) + with self.assertRaises(RuntimeWarning): +@@ -444,6 +451,7 @@ class ConstructorTestCase(unittest.TestCase): + ): + C_HMAC() + ++ @unittest.skipIf(get_fips_mode(), "_sha256 unavailable in FIPS mode") + @unittest.skipUnless(sha256_module is not None, 'need _sha256') + def test_with_sha256_module(self): + h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256) +@@ -472,6 +480,7 @@ class SanityTestCase(unittest.TestCase): + + class CopyTestCase(unittest.TestCase): + ++ @unittest.skipIf(get_fips_mode(), "_init_old unavailable in FIPS mode") + @hashlib_helper.requires_hashdigest('sha256') + def test_attributes_old(self): + # Testing if attributes are of same type. +@@ -483,6 +492,7 @@ class CopyTestCase(unittest.TestCase): + self.assertEqual(type(h1._outer), type(h2._outer), + "Types of outer don't match.") + ++ @unittest.skipIf(get_fips_mode(), "_init_old unavailable in FIPS mode") + @hashlib_helper.requires_hashdigest('sha256') + def test_realcopy_old(self): + # Testing if the copy method created a real copy. +-- +2.34.1 + + +From ff7f518d32b7f1c47f35b841da78f5869470e381 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Wed, 25 Aug 2021 16:44:43 +0200 +Subject: [PATCH 11/11] Disable hash-based PYCs in FIPS mode + +If FIPS mode is on, we can't use siphash-based HMAC +(_Py_KeyedHash), so: + +- Unchecked hash PYCs can be imported, but not created +- Checked hash PYCs can not be imported nor created +- The default mode is timestamp-based PYCs, even if + SOURCE_DATE_EPOCH is set. + +If FIPS mode is off, there are no changes in behavior. + +Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1835169 +--- + Lib/py_compile.py | 2 ++ + Lib/test/support/__init__.py | 14 +++++++++++++ + Lib/test/test_cmd_line_script.py | 2 ++ + Lib/test/test_compileall.py | 11 +++++++++- + Lib/test/test_imp.py | 2 ++ + .../test_importlib/source/test_file_loader.py | 6 ++++++ + Lib/test/test_py_compile.py | 11 ++++++++-- + Lib/test/test_zipimport.py | 2 ++ + Python/import.c | 20 +++++++++++++++++++ + 9 files changed, 67 insertions(+), 3 deletions(-) + +diff --git a/Lib/py_compile.py b/Lib/py_compile.py +index bba3642..02db901 100644 +--- a/Lib/py_compile.py ++++ b/Lib/py_compile.py +@@ -70,7 +70,9 @@ class PycInvalidationMode(enum.Enum): + + + def _get_default_invalidation_mode(): ++ import _hashlib + if (os.environ.get('SOURCE_DATE_EPOCH') and not ++ _hashlib.get_fips_mode() and not + os.environ.get('RPM_BUILD_ROOT')): + return PycInvalidationMode.CHECKED_HASH + else: +diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py +index 4ced130..11818ac 100644 +--- a/Lib/test/support/__init__.py ++++ b/Lib/test/support/__init__.py +@@ -3249,3 +3249,17 @@ def clear_ignored_deprecations(*tokens: object) -> None: + if warnings.filters != new_filters: + warnings.filters[:] = new_filters + warnings._filters_mutated() ++ ++ ++def fails_in_fips_mode(expected_error): ++ import _hashlib ++ if _hashlib.get_fips_mode(): ++ def _decorator(func): ++ def _wrapper(self, *args, **kwargs): ++ with self.assertRaises(expected_error): ++ func(self, *args, **kwargs) ++ return _wrapper ++ else: ++ def _decorator(func): ++ return func ++ return _decorator +diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py +index 7cb1370..61df232 100644 +--- a/Lib/test/test_cmd_line_script.py ++++ b/Lib/test/test_cmd_line_script.py +@@ -282,6 +282,7 @@ class CmdLineTest(unittest.TestCase): + self._check_script(zip_name, run_name, zip_name, zip_name, '', + zipimport.zipimporter) + ++ @support.fails_in_fips_mode(ImportError) + def test_zipfile_compiled_checked_hash(self): + with support.temp_dir() as script_dir: + script_name = _make_test_script(script_dir, '__main__') +@@ -292,6 +293,7 @@ class CmdLineTest(unittest.TestCase): + self._check_script(zip_name, run_name, zip_name, zip_name, '', + zipimport.zipimporter) + ++ @support.fails_in_fips_mode(ImportError) + def test_zipfile_compiled_unchecked_hash(self): + with support.temp_dir() as script_dir: + script_name = _make_test_script(script_dir, '__main__') +diff --git a/Lib/test/test_compileall.py b/Lib/test/test_compileall.py +index 6e1f4b2..ec6b165 100644 +--- a/Lib/test/test_compileall.py ++++ b/Lib/test/test_compileall.py +@@ -773,14 +773,23 @@ class CommandLineTestsBase: + out = self.assertRunOK('badfilename') + self.assertRegex(out, b"Can't list 'badfilename'") + +- def test_pyc_invalidation_mode(self): ++ @support.fails_in_fips_mode(AssertionError) ++ def test_pyc_invalidation_mode_checked(self): + script_helper.make_script(self.pkgdir, 'f1', '') + pyc = importlib.util.cache_from_source( + os.path.join(self.pkgdir, 'f1.py')) ++ + self.assertRunOK('--invalidation-mode=checked-hash', self.pkgdir) + with open(pyc, 'rb') as fp: + data = fp.read() + self.assertEqual(int.from_bytes(data[4:8], 'little'), 0b11) ++ ++ @support.fails_in_fips_mode(AssertionError) ++ def test_pyc_invalidation_mode_unchecked(self): ++ script_helper.make_script(self.pkgdir, 'f1', '') ++ pyc = importlib.util.cache_from_source( ++ os.path.join(self.pkgdir, 'f1.py')) ++ + self.assertRunOK('--invalidation-mode=unchecked-hash', self.pkgdir) + with open(pyc, 'rb') as fp: + data = fp.read() +diff --git a/Lib/test/test_imp.py b/Lib/test/test_imp.py +index fe394dc..802f0e8 100644 +--- a/Lib/test/test_imp.py ++++ b/Lib/test/test_imp.py +@@ -343,6 +343,7 @@ class ImportTests(unittest.TestCase): + import _frozen_importlib + self.assertEqual(_frozen_importlib.__spec__.origin, "frozen") + ++ @support.fails_in_fips_mode(ImportError) + def test_source_hash(self): + self.assertEqual(_imp.source_hash(42, b'hi'), b'\xc6\xe7Z\r\x03:}\xab') + self.assertEqual(_imp.source_hash(43, b'hi'), b'\x85\x9765\xf8\x9a\x8b9') +@@ -362,6 +363,7 @@ class ImportTests(unittest.TestCase): + res = script_helper.assert_python_ok(*args) + self.assertEqual(res.out.strip().decode('utf-8'), expected) + ++ @support.fails_in_fips_mode(ImportError) + def test_find_and_load_checked_pyc(self): + # issue 34056 + with support.temp_cwd(): +diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py +index ab44722..480cc81 100644 +--- a/Lib/test/test_importlib/source/test_file_loader.py ++++ b/Lib/test/test_importlib/source/test_file_loader.py +@@ -17,6 +17,7 @@ import types + import unittest + import warnings + ++from test import support + from test.support import make_legacy_pyc, unload + + from test.test_py_compile import without_source_date_epoch +@@ -239,6 +240,7 @@ class SimpleTest(abc.LoaderTests): + loader.load_module('bad name') + + @util.writes_bytecode_files ++ @support.fails_in_fips_mode(ImportError) + def test_checked_hash_based_pyc(self): + with util.create_modules('_temp') as mapping: + source = mapping['_temp'] +@@ -270,6 +272,7 @@ class SimpleTest(abc.LoaderTests): + ) + + @util.writes_bytecode_files ++ @support.fails_in_fips_mode(ImportError) + def test_overridden_checked_hash_based_pyc(self): + with util.create_modules('_temp') as mapping, \ + unittest.mock.patch('_imp.check_hash_based_pycs', 'never'): +@@ -295,6 +298,7 @@ class SimpleTest(abc.LoaderTests): + self.assertEqual(mod.state, 'old') + + @util.writes_bytecode_files ++ @support.fails_in_fips_mode(ImportError) + def test_unchecked_hash_based_pyc(self): + with util.create_modules('_temp') as mapping: + source = mapping['_temp'] +@@ -325,6 +329,7 @@ class SimpleTest(abc.LoaderTests): + ) + + @util.writes_bytecode_files ++ @support.fails_in_fips_mode(ImportError) + def test_overridden_unchecked_hash_based_pyc(self): + with util.create_modules('_temp') as mapping, \ + unittest.mock.patch('_imp.check_hash_based_pycs', 'always'): +@@ -434,6 +439,7 @@ class BadBytecodeTest: + del_source=del_source) + test('_temp', mapping, bc_path) + ++ @support.fails_in_fips_mode(ImportError) + def _test_partial_hash(self, test, *, del_source=False): + with util.create_modules('_temp') as mapping: + bc_path = self.manipulate_bytecode( +diff --git a/Lib/test/test_py_compile.py b/Lib/test/test_py_compile.py +index b2d3dcf..7e4b0c5 100644 +--- a/Lib/test/test_py_compile.py ++++ b/Lib/test/test_py_compile.py +@@ -139,13 +139,16 @@ class PyCompileTestsBase: + importlib.util.cache_from_source(bad_coding))) + + def test_source_date_epoch(self): ++ import _hashlib + py_compile.compile(self.source_path, self.pyc_path) + self.assertTrue(os.path.exists(self.pyc_path)) + self.assertFalse(os.path.exists(self.cache_path)) + with open(self.pyc_path, 'rb') as fp: + flags = importlib._bootstrap_external._classify_pyc( + fp.read(), 'test', {}) +- if os.environ.get('SOURCE_DATE_EPOCH'): ++ if _hashlib.get_fips_mode(): ++ expected_flags = 0b00 ++ elif os.environ.get('SOURCE_DATE_EPOCH'): + expected_flags = 0b11 + else: + expected_flags = 0b00 +@@ -176,7 +179,8 @@ class PyCompileTestsBase: + # Specifying optimized bytecode should lead to a path reflecting that. + self.assertIn('opt-2', py_compile.compile(self.source_path, optimize=2)) + +- def test_invalidation_mode(self): ++ @support.fails_in_fips_mode(ImportError) ++ def test_invalidation_mode_checked(self): + py_compile.compile( + self.source_path, + invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH, +@@ -185,6 +189,9 @@ class PyCompileTestsBase: + flags = importlib._bootstrap_external._classify_pyc( + fp.read(), 'test', {}) + self.assertEqual(flags, 0b11) ++ ++ @support.fails_in_fips_mode(ImportError) ++ def test_invalidation_mode_unchecked(self): + py_compile.compile( + self.source_path, + invalidation_mode=py_compile.PycInvalidationMode.UNCHECKED_HASH, +diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py +index 2e24388..11e7978 100644 +--- a/Lib/test/test_zipimport.py ++++ b/Lib/test/test_zipimport.py +@@ -186,6 +186,7 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): + TESTMOD + pyc_ext: (NOW, test_pyc)} + self.doTest(pyc_ext, files, TESTMOD) + ++ @support.fails_in_fips_mode(ImportError) + def testUncheckedHashBasedPyc(self): + source = b"state = 'old'" + source_hash = importlib.util.source_hash(source) +@@ -200,6 +201,7 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): + self.assertEqual(mod.state, 'old') + self.doTest(None, files, TESTMOD, call=check) + ++ @support.fails_in_fips_mode(ImportError) + @unittest.mock.patch('_imp.check_hash_based_pycs', 'always') + def test_checked_hash_based_change_pyc(self): + source = b"state = 'old'" +diff --git a/Python/import.c b/Python/import.c +index 8358d70..1b7fb85 100644 +--- a/Python/import.c ++++ b/Python/import.c +@@ -2354,6 +2354,26 @@ static PyObject * + _imp_source_hash_impl(PyObject *module, long key, Py_buffer *source) + /*[clinic end generated code: output=edb292448cf399ea input=9aaad1e590089789]*/ + { ++ PyObject *_hashlib = PyImport_ImportModule("_hashlib"); ++ if (_hashlib == NULL) { ++ return NULL; ++ } ++ PyObject *fips_mode_obj = PyObject_CallMethod(_hashlib, "get_fips_mode", NULL); ++ Py_DECREF(_hashlib); ++ if (fips_mode_obj == NULL) { ++ return NULL; ++ } ++ int fips_mode = PyObject_IsTrue(fips_mode_obj); ++ Py_DECREF(fips_mode_obj); ++ if (fips_mode < 0) { ++ return NULL; ++ } ++ if (fips_mode) { ++ PyErr_SetString( ++ PyExc_ImportError, ++ "hash-based PYC validation (siphash24) not available in FIPS mode"); ++ return NULL; ++ }; + union { + uint64_t x; + char data[sizeof(uint64_t)]; +-- +2.34.1 + diff --git a/SOURCES/00353-architecture-names-upstream-downstream.patch b/SOURCES/00353-architecture-names-upstream-downstream.patch new file mode 100644 index 0000000..578e786 --- /dev/null +++ b/SOURCES/00353-architecture-names-upstream-downstream.patch @@ -0,0 +1,97 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Lumir Balhar +Date: Tue, 4 Aug 2020 12:04:03 +0200 +Subject: [PATCH] 00353: Original names for architectures with different names + downstream +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +https://fedoraproject.org/wiki/Changes/Python_Upstream_Architecture_Names + +Pythons in RHEL/Fedora used different names for some architectures +than upstream and other distros (for example ppc64 vs. powerpc64). +This was patched in patch 274, now it is sedded if %with legacy_archnames. + +That meant that an extension built with the default upstream settings +(on other distro or as an manylinux wheel) could not been found by Python +on RHEL/Fedora because it had a different suffix. +This patch adds the legacy names to importlib so Python is able +to import extensions with a legacy architecture name in its +file name. +It work both ways, so it support both %with and %without legacy_archnames. + +WARNING: This patch has no effect on Python built with bootstrap +enabled because Python/importlib_external.h is not regenerated +and therefore Python during bootstrap contains importlib from +upstream without this feature. It's possible to include +Python/importlib_external.h to this patch but it'd make rebasing +a nightmare because it's basically a binary file. + +Co-authored-by: Miro Hrončok +--- + Lib/importlib/_bootstrap_external.py | 40 ++++++++++++++++++++++++++-- + 1 file changed, 38 insertions(+), 2 deletions(-) + +diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py +index fe31f437da..b5b70757f0 100644 +--- a/Lib/importlib/_bootstrap_external.py ++++ b/Lib/importlib/_bootstrap_external.py +@@ -1636,7 +1636,7 @@ def _get_supported_file_loaders(): + + Each item is a tuple (loader, suffixes). + """ +- extensions = ExtensionFileLoader, _imp.extension_suffixes() ++ extensions = ExtensionFileLoader, _alternative_architectures(_imp.extension_suffixes()) + source = SourceFileLoader, SOURCE_SUFFIXES + bytecode = SourcelessFileLoader, BYTECODE_SUFFIXES + return [extensions, source, bytecode] +@@ -1692,7 +1692,7 @@ def _setup(_bootstrap_module): + + # Constants + setattr(self_module, '_relax_case', _make_relax_case()) +- EXTENSION_SUFFIXES.extend(_imp.extension_suffixes()) ++ EXTENSION_SUFFIXES.extend(_alternative_architectures(_imp.extension_suffixes())) + if builtin_os == 'nt': + SOURCE_SUFFIXES.append('.pyw') + if '_d.pyd' in EXTENSION_SUFFIXES: +@@ -1705,3 +1705,39 @@ def _install(_bootstrap_module): + supported_loaders = _get_supported_file_loaders() + sys.path_hooks.extend([FileFinder.path_hook(*supported_loaders)]) + sys.meta_path.append(PathFinder) ++ ++ ++_ARCH_MAP = { ++ "-arm-linux-gnueabi.": "-arm-linux-gnueabihf.", ++ "-armeb-linux-gnueabi.": "-armeb-linux-gnueabihf.", ++ "-mips64-linux-gnu.": "-mips64-linux-gnuabi64.", ++ "-mips64el-linux-gnu.": "-mips64el-linux-gnuabi64.", ++ "-ppc-linux-gnu.": "-powerpc-linux-gnu.", ++ "-ppc-linux-gnuspe.": "-powerpc-linux-gnuspe.", ++ "-ppc64-linux-gnu.": "-powerpc64-linux-gnu.", ++ "-ppc64le-linux-gnu.": "-powerpc64le-linux-gnu.", ++ # The above, but the other way around: ++ "-arm-linux-gnueabihf.": "-arm-linux-gnueabi.", ++ "-armeb-linux-gnueabihf.": "-armeb-linux-gnueabi.", ++ "-mips64-linux-gnuabi64.": "-mips64-linux-gnu.", ++ "-mips64el-linux-gnuabi64.": "-mips64el-linux-gnu.", ++ "-powerpc-linux-gnu.": "-ppc-linux-gnu.", ++ "-powerpc-linux-gnuspe.": "-ppc-linux-gnuspe.", ++ "-powerpc64-linux-gnu.": "-ppc64-linux-gnu.", ++ "-powerpc64le-linux-gnu.": "-ppc64le-linux-gnu.", ++} ++ ++ ++def _alternative_architectures(suffixes): ++ """Add a suffix with an alternative architecture name ++ to the list of suffixes so an extension built with ++ the default (upstream) setting is loadable with our Pythons ++ """ ++ ++ for suffix in suffixes: ++ for original, alternative in _ARCH_MAP.items(): ++ if original in suffix: ++ suffixes.append(suffix.replace(original, alternative)) ++ return suffixes ++ ++ return suffixes diff --git a/SOURCES/Python-3.9.10.tar.xz.asc b/SOURCES/Python-3.9.10.tar.xz.asc new file mode 100644 index 0000000..ca807b4 --- /dev/null +++ b/SOURCES/Python-3.9.10.tar.xz.asc @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCgAdFiEE4/8oOcBIslwITevpsmmV4xAlBWgFAmHgts4ACgkQsmmV4xAl +BWiDfQ/6A6ALwx3xrU5ks0Fec91x56ixg+S91cMGDwHM78/KT+gOSva0FxLlpVDO +OD0yLoBOwVjSaiFAZC9wH2tf6xWLujVeBscrVX3Di1DZznZGgusDhP+gWpugULrF +WCr1ZLxnerhOMmBU9hSOx1ObBc91CIsagqafeMuAWoEwsQpkG0hDHuRN8QeJn79s +mFt4/X6/2NQEw/ucxftwoLIfqDbeP468wthOBgr9TrYfseSojnnYCxOiitC8k2GS +ieLq1RQu6ZjSYtHyL+mvXwTy2tEyc6v/3s+3lJCcM6uK+vyAvwP4QwIXwpjwHMDW +0YdyB812pWUleAt7P+BvVbumjGCs3hFHydMm6iA1eiONQk5Z0QQv0qrh+rqorXkJ +aUgjiXjbNkx93m+hftUXXEcKWm6hi8CikcajBPbTZt6PlOCL2ZbN5NclTDpG3JMK +8WHFpeFF1uaKcsDF5L9QU+ilXR0wxrh99DePQiLqsMvzbocB3cd5x8Ws1MNX/5tU +6p88qUf1Zdg3EA7VQD7m90cTOHcskH8o+Bw+Jd+uDo+H8Pg9Yz9yHik6rHe8OwiA +ol7eiEO07WePwqX4PqHozRtCVNSOZtrSSoWK2LNQdK9Z+EhVhQvDDk3hFQiE7ymM +ZXHYHATjmGFN7WSThMR/8IFgTSqpuird+RXEkVZKorYPsA0P55I= +=KRy4 +-----END PGP SIGNATURE----- diff --git a/SOURCES/check-pyc-timestamps.py b/SOURCES/check-pyc-timestamps.py new file mode 100644 index 0000000..91af4fd --- /dev/null +++ b/SOURCES/check-pyc-timestamps.py @@ -0,0 +1,55 @@ +"""Checks if all *.pyc files have later mtime than their *.py files.""" + +import os +import sys +from importlib.util import cache_from_source +from pathlib import Path + + +RPM_BUILD_ROOT = os.environ.get('RPM_BUILD_ROOT', '') + +# ...cpython-3X.pyc +# ...cpython-3X.opt-1.pyc +# ...cpython-3X.opt-2.pyc +LEVELS = (None, 1, 2) + +# list of globs of test and other files that we expect not to have bytecode +not_compiled = [ + '/usr/bin/*', + '*/test/bad_coding.py', + '*/test/bad_coding2.py', + '*/test/badsyntax_*.py', + '*/lib2to3/tests/data/bom.py', + '*/lib2to3/tests/data/crlf.py', + '*/lib2to3/tests/data/different_encoding.py', + '*/lib2to3/tests/data/false_encoding.py', + '*/lib2to3/tests/data/py2_test_grammar.py', + '*.debug-gdb.py', +] + + +def bytecode_expected(path): + path = Path(path[len(RPM_BUILD_ROOT):]) + for glob in not_compiled: + if path.match(glob): + return False + return True + + +failed = 0 +compiled = (path for path in sys.argv[1:] if bytecode_expected(path)) +for path in compiled: + to_check = (cache_from_source(path, optimization=opt) for opt in LEVELS) + f_mtime = os.path.getmtime(path) + for pyc in to_check: + c_mtime = os.path.getmtime(pyc) + if c_mtime < f_mtime: + print('Failed bytecompilation timestamps check: ' + f'Bytecode file {pyc} is older than source file {path}', + file=sys.stderr) + failed += 1 + +if failed: + print(f'\n{failed} files failed bytecompilation timestamps check.', + file=sys.stderr) + sys.exit(1) diff --git a/SOURCES/idle3.appdata.xml b/SOURCES/idle3.appdata.xml new file mode 100644 index 0000000..94f87a2 --- /dev/null +++ b/SOURCES/idle3.appdata.xml @@ -0,0 +1,35 @@ + + + + + idle3.desktop + IDLE3 + CC0 + Python-2.0 + Python 3 Integrated Development and Learning Environment + +

+ IDLE is Python’s Integrated Development and Learning Environment. + The GUI is uniform between Windows, Unix, and Mac OS X. + IDLE provides an easy way to start writing, running, and debugging + Python code. +

+

+ IDLE is written in pure Python, and uses the tkinter GUI toolkit. + It provides: +

+
    +
  • a Python shell window (interactive interpreter) with colorizing of code input, output, and error messages,
    • +
  • a multi-window text editor with multiple undo, Python colorizing, smart indent, call tips, auto completion, and other features,
    • +
  • search within any window, replace within editor windows, and search through multiple files (grep),
    • +
  • a debugger with persistent breakpoints, stepping, and viewing of global and local namespaces.
    • +
+ + https://docs.python.org/3/library/idle.html + + http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-main-window.png + http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-class-browser.png + http://in.waw.pl/~zbyszek/fedora/idle3-appdata/idle3-code-viewer.png + + zbyszek@in.waw.pl + diff --git a/SOURCES/idle3.desktop b/SOURCES/idle3.desktop new file mode 100644 index 0000000..dc1d3c3 --- /dev/null +++ b/SOURCES/idle3.desktop @@ -0,0 +1,11 @@ +[Desktop Entry] +Version=1.0 +Name=IDLE 3 +Comment=Python 3 Integrated Development and Learning Environment +Exec=idle3 %F +TryExec=idle3 +Terminal=false +Type=Application +Icon=idle3 +Categories=Development;IDE; +MimeType=text/x-python; \ No newline at end of file diff --git a/SOURCES/pubkeys.txt b/SOURCES/pubkeys.txt new file mode 100644 index 0000000..c409e96 --- /dev/null +++ b/SOURCES/pubkeys.txt @@ -0,0 +1,11542 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQENBE0yGHgBCAClbIKFESe6Ae/wJv4c50K2C5BnyAVIbNObvl/maM7X0sTpi9cv +AoOIjXvVKT2G2KPwtBLilAltsmmY6kPVSrevg90laMLGH7/kDeNuKC/TL0lLQcu9 +5L224n2UiB0N5AV+arMuuBlX6m7SsfkI18Yi/LAli4eMLg/ecLtA8FpVDjwXlKxo +U4vUOC0ePxeSeDtU8AR15UY1c5id7xkn4EC3jvOXm/KRcyaBX4FD2Tes1XozOmwF +d1kGjclSC9M/lmKwplhe/dYULpag2F6HF34PKRuQmwF73+ZMNUDNWQ7fVa7q/e8+ +zldsOjWTrt27MDWXeW7XocX4/Md4/bm5FxfBABEBAAG0F05lZCBEZWlseSA8bmFk +QGFjbS5vcmc+iQE6BBMBCgAkAhsDAh4BAheABQsJCAcDBRUKCQgLBRYCAwEABQJU +Vft7AhkBAAoJEPuZIShvXhVA/68H/2PQPdPypaBjvngBh7RaaSsQjB45DMSVXOsj ++7AvaCK0GSCWxXtNzAGE3ajhO0iljhCgDD8njjKele5WwvNQOSmkjXfnxEb8qTyS +AgKtAEazI3mFCROekO1ivAVXokUjUdcshaQLpjoYGoK0iT4BcP9fJR/Q4WDST/ra +4EtUZXb1cLS9gdDVEENRjly2L9eXGzm2uNk39K2QAiL5+BER84PucE6dKRL/jN8K +wD7nwhoF6zPcQb3EMQIsaAULB49EAU7ORNDz47erpChEHtfstvfBcYpd/vuEMWTj +yOtelpJ3cHlzN06gp83COCZRK+EMxEaHXpw+o3MjuqIcs8JULHWJATcEEwECACIF +Ak0yGHgCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEPuZIShvXhVARpcH ++J147mVz9wi4h8falLH37RTksN4f0ztibBzne7qPc88wHkPXH+5kkALkhWhoiEDC +JlfNfQWp07q6LIt5d/VVo4sbHJxmDUmyvT0b+9M7zKckD/isBYTlJG9PrO2qnsep +NJghXYLeKjGF9gr15ZoVxzbS+AtG+MgK25AkQQ2T9pz9n8Uf5C4rp0AjLlajWkYA +1OUve7k/Dlno8JJavJwo3R2oc1h2LyPXk9gvHW1E+ffPsyU439HA8jQTSeyhKmBK +ToBdAC5rvC7WIDqe+/c1gag7HZMEnT58dNh+RHvWDnKx8t2EvMu6OJ5KZuND34Iq +u0jwwNWPvmYDLYsDqvIqnokBMwQQAQgAHRYhBGjnz3VfGMOGkVmEBuxX+F4WzNj2 +BQJaQJRFAAoJEOxX+F4WzNj2bygIAOENFp4OUaTMVfo0liwpAzErDk+KK2fL8sqM +6ohg7cojazu/YKabw1276+ctKr3SIkbYjQmbIc07brDavFze7676TJwtvhrn+exo +RzQIPqestCRqyW/yBt59grFdO5ozY4fZDXiH40+6su7BXJ/qbzFYnucQOWDpSNRB +Dlvg7MoZU2+680JU8sn61os9ND+VbHYSZo+AdMLiJi2mPJSnNPlzPklDAJ8wYp4W +6z45IceChpJemWKvN8nVIgGNVeappAhE1ehga7D5Tqf3B1IPuHtIXm5lTcDy0g9G +/UCX54BiiKQoyRTf6kDyAnvIt7l2Ci+6B6PQ8dNZOt+g1D2pTb20G05lZCBEZWls +eSA8bmFkQGJheWJyeWoubmV0PokBNwQTAQoAIQUCVFX6pAIbAwULCQgHAwUVCgkI +CwUWAgMBAAIeAQIXgAAKCRD7mSEob14VQP8WB/9aE9tkYvYhjbeMKWRXgcKfEKL8 +A2etmkt6HEO+VqxbgFdavdtzZSJvyhkcitZx5WmfIsWETR206Rth9l/ykuyaK2gu +KF5OmZwQ+8w0+Vpdq3VsgbGN+a26XkXdln/X1FKpuMH8Wi0DzKb3HBzvi2qpPGcx +/M9s8OyI37064R1EvshXgtXcMe52Nex6iK46PkkyYx36obxie/hhocyreJR0czy4 +i3w0KQeBtYnUZM5bJKtw4pBGrT3VPu80rgVxDzEoiB+Bt5GU3hVlZzvpOlA8U/e2 +lNVZWEdQdu+WcJm7dSwmhs/hjXLc1xmjr8lnUTw+qcEdVxlOJg0geB+RPgwtiQEz +BBABCAAdFiEEaOfPdV8Yw4aRWYQG7Ff4XhbM2PYFAlpAlEYACgkQ7Ff4XhbM2PZq +wggAimv1LbpttomLOFxNGagJrZQSHb8nGQaRJL2ot6da6jmpIJiTf414nhgyshwE +oeuJgIshmGU6WnF8Y7OUyyk3lE3saSmIVO/60s2wkZe5unreKijqphmFMmJMecqy +ZcPf0H7d/iWgjPAOVIhiL8CXCBOtjl2mD7Ih/BOF7ek72UdG0D/51MsRStH0uAMU +ScKGrGHW2TLHewBnyHqOWfsOE1L2hQ5RkVucVcXWh+LLgq65Fx3fAtRPzLRBVylL +jTVRFURBlXqC3Wh+X8/YRkPJ46nALz7icjMedUF/oWrSthzd66zLtyVrbCCDwR3L +YPyl2UA1eGLmC3fygXLWA2xsWrkBDQRNMhh4AQgA5DaKSCroRArEu6YlG0NF5JII +cquEdGh8hWtB2vuV+AneKMKEma+t/+J/mOGSiyXwM5QpcMw1BTnRmUXnvBnc7lNb +V1hRiGcwQ0lbby1EQqJZnoVznFIfvmaxYvgowcTR1UCU/87NDE5yu/7Irz0pY5sW +U9ZKDbLpz2q0oR6//2XCSqBg2Yp4p7nCAfsBub8KKcarZBp+oo0xbFEbr3BBRDyB +89oVctNH9Tu5pDj79G6jnJqCcWhb2/VStH9cTa0uBVz4NZ9xnLqzcWYSK8uUAhYg +yJxlUS1oFGmUX9UJ4qdxp72nowR3QqPTaNH7C7tV5jbx7OWOtDUtfAIZdpcV9wAR +AQABiQEfBBgBAgAJBQJNMhh4AhsMAAoJEPuZIShvXhVAtiYH/3Cdw/3aIZM0pHcs +bl8SjwAAkBxccwnc44G9+MDzQZ3b8XLtekRoHKId3R5EEOm7ORXXqpORtlVH0FFi +2iSL/VjsjDqmsrSrOasy0HCtWIkRvfc3RHX7spyFnEgX1BVSE+Un59BK3prmyFR6 +eoG40Q929vwNHV3d3YRiwmhlwTjs/HFhZxpssjvos9ahob1I2588zMIRraJkpIxc +S3Lzrr6XV+k7ovuXfn0rYbCY1A7ZTs2Cj8ft8dRfMzuBh1oaSVpu7NsmRSSRlm5P +VjJOcR2UJ7RM4DSXdn5c4yn0Ob+KePTy4Hch8UM72aWMhr1Pgno5QgyRdzch6CD1 +EYLKy7eZAaIEP3EXAREEAJ7qNMLhMS5HX3idRdheo8p7vqsDQngg/y0WxX+/Xxj1 +9lGDVMSf5SfQzLuRX6pPA7e5HI1OPOiDaqRp+CkaOMyEpqOqxTnHm9jPWy3g1vk8 +tyac5q6a8rsEdmr3SmHph346dKe8qb6FJ1PHlZDdJVmysiXsbKEGEM9LrE7NEeNb +AKC+ZhfCe+FQ2FSZfaJrtrAxhjdItQP+Icwaqf0QkyZP5owTzbEamGaxlmpHiwhU +YW/b0mD2otHjfHJuUH/+UFkS0zwVTXjPtGt6JUIBNETYPh8dncMralw37nzTGxCA +A4MsppV5ijV57F6a/BqAm/Pc43cgw8j3OJ8+TAfi5PfIj/fZmWK6/iIjKmCFvqxC +8NhrO4AnE/0D/3kvvqWF6HdUvNg1NVhfiQISI8RFWsPy37NiWPL6nOsVYM13eZt4 +GliGl+iShRvyJS6f27+FUvaXLYsfyJBhbSYZT+XRi9XyVM6YcXFwe3zFDxJB6658 +IJZVp0PWhPoG0aVH7bk/k3AprtaQtJi3ztB3RmAUtkTX0vYTd4RSNnSwtCNBbnRo +b255IEJheHRlciA8YW50aG9ueUBweXRob24ub3JnPohFBBIRAgAGBQJB+rAyAAoJ +EOyZPWNl/c3ukNYAnRNzvbdEVmjkoGHm8xIFBQLOYEitAJjNcwDjoh8nTruEHFcZ +EOiQGmECiEYEEBECAAYFAkJyID0ACgkQ0/mV1Xdq/hLfCQCgw+daUy1wEmqp+j88 +InzkBN6vTIUAn38FdQVJtRKxJjJDhDsT0sYp+zNTiEYEEBECAAYFAkKUrSsACgkQ +i9gubzC5S1xVRACgk0AdbYjCHYr8QhU1NHFP71/bu/gAnRsvcCz1M10dAdBOmyeg +qu28ACnfiEYEEBECAAYFAkhnIQwACgkQlypuBSUcZe/v4ACfToLmt3DFaI1TeG81 +vMNBU7IBDHcAnRf6SHjYwX0yiCPesDoJT6xZq7hqiEYEEhECAAYFAkHC+JsACgkQ +K8hAFiBoeJUerwCdHVsgxS0vEEMdBz4ijYXidDu/KCYAoK6GPoaAX2ralnC20rCJ +Qpcr6x3IiEYEEhECAAYFAkHccboACgkQ8+hUANcKr/ldKQCePd8XlIwXph/kag4D +nDorvfMypuMAn3kc9EF82atmEa6RslL4dnZiFBWiiEYEEhECAAYFAkHjuRkACgkQ +jmLn92QBGotccwCeJ6ZFSDklL1DvkksKii+3dndqQfIAnRVnflpYB0fAXkFNUfHn +JTHGAIzqiEYEExECAAYFAj9xIzYACgkQrGisBEHG6TCC5QCdEiMDZemHrz2WFcoH +rphvZg+eo6cAnRL/8bA01yvvpCrC2vMLq11LDiA5iEYEExECAAYFAkAnN2AACgkQ +AfqZj7rGN0p2/ACff0IdwLnqf+fB5B8oEyqIOKfSWxsAn3RyxshCbYg/4pybaj1V +njz1+tTFiEYEExECAAYFAkGtiQoACgkQq3pgvCz4ZCdkDwCgjNgg8cLCggwykCE3 +D+iit9dM02cAniakJNDPRVhqJkcIdQWLlkoNKhJBiEYEExECAAYFAkGvALoACgkQ ++i3LsNJvIlkFzgCfaG/yk8G5WtHm7ErgxKbnIbHX808AoIHXjz1N+qUREmZRM3yb +XOS59o4ziEYEExECAAYFAkGvvnMACgkQ0OZ+tAQU6+OiZwCgl2jvzSk96uDOJ+XE +n4FKIltWy8gAnAh4aGyaPGEOge+OM7gjsQooVNHWiEYEExECAAYFAkGyIR0ACgkQ +GvGiCkzACFGZ+ACfQmfMmnW2NkGaBCKuLRj/7LRwAKEAn2CvW6njZAfU+AQN4sug +Nh9aaSi+iEYEExECAAYFAkG0dpgACgkQvtLr/tL+0yHk7QCfSAo8lAOo3OeeL3pV +p3/6xM+CuJEAn1v8ztD7ECW4mfv1nKFl5SIV3Bm0iEYEExECAAYFAkG7osAACgkQ +NFDtUT/MKpAl6ACdEXtGj3Vks8Ej7D42lC9eZ89RGtYAn1+9Qe0mhLqvEYxG7xPM +pKM/eBQ9iEYEExECAAYFAkHCj8AACgkQoWMMj3Tgt2a+TQCggT1eZOCaRf9aQVeO +t0LK9ZFUx+YAnigO3BVfSg3FKl24+NsBk2s1mMatiEYEExECAAYFAkHCoX4ACgkQ +kVdEXeem148KbgCgkVFTJAfp+Kq9BW01f0RAmbZG9zsAn2ibh/ybAWj2QgkQyrfL +lSZ75JAkiEYEExECAAYFAkHC1t4ACgkQZEH9AkgfRL2+9ACeJO5HHkpygw4d0iWr +axFgs/j2EkQAn0spRXj3NUfCwElBQzSBx+qXbmyeiEYEExECAAYFAkHIE+sACgkQ +Aa+T2ZHPo013LgCfcVDROpPeo2HwMRVT552SWNJZBDsAn1HmR4RCUvGqJHbhsqQB +JwX6zIF8iEYEExECAAYFAkHIWDcACgkQ9t0zAhD6TNHRRQCfdnPTayVl/Hn0Qg6k +hWSMbdPDbOwAn3GYZU0Oc1iertWTFEwwOi26QFEoiEYEExECAAYFAkHrRKUACgkQ +ic1LIWB1WeZFkQCghLDWvsJJXE09HzlRRDk6qoKh/tIAn0Tn2JYNm51uqfiBDjVv +SmvtS3D+iEYEExECAAYFAkHrVzsACgkQ1U6uS8mYcLEbuACgozXXrf6BGYGpKLD6 +3uK21ZaW1UwAnRAjr72IvylX3kHuv1RwFxmBGWjoiEYEExECAAYFAkJNqTIACgkQ +zN/kmwoKySftHACeMo9mW91s69/FBF9gVGzb+yJ4PVAAnRSPTPXvo992n9Nahdie +LOlVq7whiEYEExECAAYFAkJyNEoACgkQpQbm1N1NUIh3zACgjkRdv7yHIK1BMMvM +ktN/jNozUGUAoJxCR0oaieAKhJgI3w6sTA+BuSZ5iEYEExECAAYFAkJy4ZkACgkQ +d/4g/qpqtcs7MwCeITErWatjRi0MQm+PPjJfer/e8bkAnRwK7lVv17uqy1OGTB6G +sOYr8xpgiEYEExECAAYFAkJzDPMACgkQr3O2CKlAUK8MUQCeOEEGbmSQFYJy+yWW +wlMa9FtJkT4AnReYg4nd6O+uURMsIdomdY43cZmliEYEExECAAYFAkJzV+AACgkQ +oDV+ZULiweWtRwCfbc74fBLiLCtmDGGFcwpUDSjUOG8AoMzNQ/ryEvPe5Eyc5w5J +cwDyq6WwiEYEExECAAYFAkJ1n9QACgkQu8b/uaAhL+SC7ACgjI91uYkVAN/nkZEf +YvVV+Gc5mEkAnRnBcf0cya8EAmLXXD2dNA9/pUE2iEYEExECAAYFAkJ1ymAACgkQ +vjztR8bOoMldQQCfYH8FD5ho8PPGa6kiwvYSnnW/Mm8AmwVZE1XXHuUh/XrizEpQ +ABZn5rkniEYEExECAAYFAkJ2REoACgkQ/qs2NkWy11v3RQCfaUtqIWJ8e4HMWy67 +RgwcP7bbNjEAoLIMAJwD6wC74F6uVduBRPh77bDZiEYEExECAAYFAkJ2RhoACgkQ +RsWY28vsX4DWvACg0QWhLKt31nPf5p3JftUHjb9YTVAAn2TYXfAfh23ANlydVFcS +RUoXdeU6iEYEExECAAYFAkJ3I1gACgkQDecnbV4Fd/KLGwCfdYcl8YgGxRXj/IhB +1BKQABRAHhMAoIggyPchGQ3MyzrHtyLseZHInxVriEYEExECAAYFAkJ3PGYACgkQ +hCzbekR3nhg8GwCgovj/Hzpn7hNk6JvJVCmQJo8RN1IAoI9m4DQEtRaPL3ra38IA +fO35TrLIiEYEExECAAYFAkJ3wxYACgkQSsOT+6LQaTYpmQCeNTeD5YzZDckh7onw +kI2TTpFdIiYAoJJaHQsaZWcQoNK33UxtET4gDsXsiEYEExECAAYFAkJ40OQACgkQ +cJo/YDt+FuHaDACdHybxx57I4Dt/o5FpIA8MLmOZRE0AoKDHnnmaNT2z3ds/WWsj +0gbLgyruiEYEExECAAYFAkJ5/hAACgkQb67zLlCCcv4HmACff4SHWEPzh2yzUAk1 +N66KwtTrbnYAnimHTqZZ94ZRrLxgwRbnSuv4njHciEYEExECAAYFAkJ6TDYACgkQ +H9eQw/Gi3tXv9ACeMP9gcty54gQeuc2Z6L4Cd8KKrHIAn0P/Y5UFc+K9Z6eXipeo +cXDDCYcNiEYEExECAAYFAkJ6XYsACgkQem/rb/9SwVDBxgCghBcG4MRb3wq/V+LA +AVP7patsulYAni4emao2m2aHTceMM+DZ+d/G7hP5iEYEExECAAYFAkJ60gsACgkQ +BlHlJnS3xyqwNgCdHzD/1Q5gLilVMusSv/+PG4KKboQAoLCI3uDTimcDIRPTuWhw +y27hu4oxiEYEExECAAYFAkJ+y3sACgkQPGPKP6Cz6IvODgCglHUAKdZwvbwJomQh +w91xiRQ0RyMAn1EblZT/tiYC7ctfZ5MzVvP2S5FxiEYEExECAAYFAkJ/D28ACgkQ +uJQObal7aaA0+ACgjuwaORagSiSHDUCroZ5EJ2QnExIAoKGG111flnPDo8PzB7r/ +KJTZ4rd4iEYEExECAAYFAkKCVfMACgkQE91OGC5E08qyBQCgyKuzLNSc1jGOw2Rr +Gd40gwJYfBAAnRcCEWOs0mSMyLWKYjeaI5xshCzAiEYEExECAAYFAkNDT/UACgkQ +j2gB2J43n8bEZQCfX1BvZTSbAzyt2b6BKKOmmFabFZ8Anj8sNDIomUIzMQep5vRi +ragrSXPZiEkEExECAAkFAkJzHS4CBwAACgkQuJQObal7aaAebQCgtLscUV9MTls2 +jwQePStkUnzbacAAn2DNuVPb2ejy24l825OrgsGgVR6riFwEExECABwFAj9xH0EC +GwMECwcDAgMVAgMDFgIBAh4BAheAAAoJEA7dxfJqRcgW2pkAnAirny6QfIj2mqWT +aI221/oEP+xZAKCpkIAZcxEXSqt4OjgxG2pfVH3XXIheBBARCAAGBQJL3EkUAAoJ +EPrvEpNt0+PskV4A/01AeG4IrkXF2SWThWgkAyTAI2zmLTGqqCKF+uE5MnaaAP9Y +HKXLsOOj8UA7Eqem+E05rP1cdjt4BdXd/5a3qG0LtohkBBMRAgAcBQI/cR9BAhsD +BAsHAwIDFQIDAxYCAQIeAQIXgAASCRAO3cXyakXIFgdlR1BHAAEB2pkAnAirny6Q +fIj2mqWTaI221/oEP+xZAKCpkIAZcxEXSqt4OjgxG2pfVH3XXIicBBMBAgAGBQJC +TaoxAAoJEKv/B7RG8yEth2gD/Ajc5x9fDtolZYfqg+C6TS8AwBThdDT52UM1bK3A +4q17coxNwhxVcLzsQDRX9og3Y6XqDjxO/RmE/KPykmTOYQxgPGSmynWkSEMYDG49 +m2ImrwAxlFAuJNNNsc1ZdoI+oGMhZmIril2Z0XntD/r1ECuDnHKgEThTa7OozeDw +CizNiQEiBBABAgAMBQJB7iB8BQMAEnUAAAoJEJcQuJvKV618A1EH/RfB+okZ/wL3 +MxVSLAnMFIuEct9gBV8okSd9fPRI9ogm7jYWLPg/djq8YghMP3YoECySRqYeEEIb +n9duGjoH2l8EjKrER7Rvnt1KtnVXzAbjA2Qrc51bofW+q6nwRBC/Ine1IjyMcKSF +UZoBOQ011NfZZpL2RIcCncP79fKrtE9GepTknGxbtHJM6jxfEx7c6fliyyL0Wc/u +Ufm+a73GK2fUuhxdRr7Mp6wFceofXjsmcL4JTAdecGDSCZeRPydCPIT0fmuvgxp0 +pUKgH+xFHDBmB0SDsBZeku23exLjb23W18+x2PY/Fg1jfxOOFEWjY0frESP//n1/ +rdJ7Ibc8cgOJASIEEAECAAwFAkH/390FAwASdQAACgkQlxC4m8pXrXwywQf/a+XM +dLddJ9YveZYCaLthA5FAFtqmn0TWd/VH98zFceRUxaruM4qYk+uPr9cgEuM8mtxe +LIkE+rnrC39fc2rmw5AlM2Q0c8nr9ErG0VDHzSRK9TLzegiy+aZ7lS61WX+hOd5P +PxWky7BKmB+I/Ctddux00DqOKLmaaEGATfjUKX4SO/5VumlPLv5hNq9PKadbuOpm +EHrdxsKK0hl+UOq6wbjNz2hWYnArzJeaYoKYwm6Ulr4PrZsBRa/PSXHKII+t8gCZ +RHpzxn2D6ZPPezzpm8I1Lp9cu0AJFslBWJwthk6GyI+WX8eK50xI+FHTEkjvdrWw +TNz/yfJqqkSLyFLvI4kBIgQQAQIADAUCQhEEFgUDABJ1AAAKCRCXELibyletfOlv +B/9NZqfN3WGAlkjES8rxZfCHRVvKA/0TRDi/zvx1ArxMAMmgYIv9iqT4wtC5OT3q +Hb6O870CBIkOGB+/qIwRR25rE5ecfCKqMrwLKVGR2TO/JEviKf8zxFUKRmWviql/ +KS26TsmjEacLXj8mWlDzcqVQJCH4hp7PR63To70RVTUhjrJ1BzJ++Mu0ZxhO7kD8 +Xqi5GCvwNnnJVGQggj9NoWxINd8ok1Lx5nihzhQaWtkpB03UlAQ5IqP6pueL4c1Y +Hq7lks2OEwIrVGgowJb6CSvgw/HLvSBUXEr3/MzNBZNnTh3lkbLxAgfTbWmJ0GOx +arrtcbEGA+3GHoHPMMsQd71xiQEiBBABAgAMBQJCFwrUBQMAEnUAAAoJEJcQuJvK +V618BBoH+wcKJfQiEXM+0mo0Kb6gEL5VDdmqY2o11snggHVfmE02wQJ3PlpvSvyN +yOPbBxbereRgfSva1mQRdoMFLuwOkpWaoo/0rgYGCDjCdMirG7GyuSDoKCzSfg58 +8LaLnH/ClHuCsccwb7a+UEnr6EOwuXIGbYNRPbuVTXiFGM9pQpYSDqcHTu9ijul4 +RMZ7xjyws9r77X6aFz2rwbK5X0qIYf4QdxLoqCALYLx+FXdd1tQi/xzkFKiSBrSK +CIrRha065NyRK9ySfBESAKk/gQuc2mElR3S1xGzb065vczA+eW5/xx33B24A8uMn +atvbGSKEw5TtFpXV/gSBd7tiTfX4y9CJASIEEAECAAwFAkIpfUYFAwASdQAACgkQ +lxC4m8pXrXy3QAgAj3EnT4ZAwG3T4eOjI6u0SUdhq1MYsUNFPPV1oTe7h2jrm7tB +owjdpibMfFpRdkMhbe0DTZmucx6HP3nduLTe1ScSTUVSoOOCOy3kHrm4hZi6NO8j +YqqwXZ76pFcW1ESyiF30sye+O9spm0AIcHVY9stIN0KH2Cg49YS0sbnpy6XbrRzY +E4ZFd0yP78JzM0nw2SEST+3nNAd6NZIJcVnoohZek3UH/vFgA1mLYrt0Rebxgqyy +dnGw/nEiLf0UR0awDA71eOjZQZQVhpnr7nxnSYCKVG+fOEPmsOgFKQlLPxF3yJMk +5//yv44pLqQGEtZOdjZhy5N0UWiVj97I6KJQE4kBIgQQAQIADAUCQj0wOgUDABJ1 +AAAKCRCXELibyletfLcoB/9RVeyD7U18MdXzpo2eiHl5anCCGzzjvC9xUBG5SkKi +X0HvPjF+k5nFhUVDVoQLNkE6pKXSjJnaycDaCnmmoWUxZ/cYhKGwgasbQPUrUqjS +ZI2VJuQ/Ci+h0rtpu2F70Es2F5lkxrVqpBgy+4U9LSR6Qh+wLNZkvAZzdUQhPfeV +IGMTSDx/47k6uShVEDrCvLgm9G7y1tqW6rOCJpOz5mdWCnl8aIWJ5RvVvgY2kCoV +14sDb8c1EML4m5pQVj0mcv2J1kpS2pNJGoZWJwHlLKZYmykNc7CdzvHd1dxHYPUJ +Lcr+vIHlvW/xA9tEMOSS9KLMQb/UgzzjWLmE8aVj0uSviQEiBBABAgAMBQJCT6Vn +BQMAEnUAAAoJEJcQuJvKV618H/0H/0wf0N8hkIseZO2Yb+8tgZTUYdeTV1Dv6+W7 +6nSiKbxEHcaUUGtEeI5qNEPlpM6xLBl+XjpKxD3aiLcugzSlGN9KKBsqa3WQHdAI +J9xbL9HZB1X3JWjd/HNJFjPPe1aBxspbJe43dV4brJk04fV3UMjvXBBuxYrGX+Nq +ipTM3O7HDmr2hXurqCsyiBLbMm66gpga5oz3SOpdMHAq2tedGJfoApJtSaanGPAE +Bpl72OfiinujCdkjo+JBjLYC/Nej7va6/OaVfbrs4gn3GNIqUx1yEgjxkScabjSn +H590fTp2C34XkMuAr3IZUanrEVSlSqaOSu76oPHkUoy32aG2xfKJASIEEAECAAwF +AkJiFQUFAwASdQAACgkQlxC4m8pXrXydIgf/Q0R6Sjw6DWWdqQF0kdlsnIsdUlSt +E3uEhwm4DzENzfu37U5YkFV9p0vgYQfk2La4PC8KfzKZz35KMVdYX/zn0C32z0Fm +LGp6R18hV0bgu7ZE7MKuRMClFYp/UOhKP9CF4YubdxOq88H2sjXAZtf2L/0uSDja +mtTB/8GgdTXXp3RaorkesGPHb4ZPCfT9DaNHML1L6sQHpHo9JhvIUplZcO/SQ6xt +qWnyvi17an2wcDkqB0tWwPphaMTQg84Z1cehihY0ZTuqulRyGqFsfJvXXUxA+Prn +sWlJ6HJT9VXt3z4NE7bXPZB2gB29sMSmQEb0NgF73285OC7sQFdufY5fi4kBIgQQ +AQIADAUCQmK+FwUDABJ1AAAKCRCXELibyletfMK/B/49ZrqLlfSIeII4K+rR89aW +QSTsiKtnbGuF3X0uTmSYryTTnKtP/zFEm385HDR3i4Hb8k3IdBDG6Xps3Qqvpl/S +wyfeAe1zIzvxjU+ITGP8NfVJ31UVSu/4xvdOTJYJkTf+01CtrqjxWgYN/wVEVtq0 +htlIjMbju9cnF4vbOPL0TLYH9oTun7b/hX5zJU4rZexs0o0HtLTp3/HSF+NKxs/+ +t8MWUoONuXG+RJPXa7ZafXm7Kb3jwhZzOAlCqRkwba02S2qiWr6dXe0VSZwmZoOO +tXhwo7xOoKFTvid3xzpAh26xkFvGSZlZO/SrCep64Loht5Wpxfdksz4hwokAWmNo +iQEiBBABAgAMBQJCY4LJBQMAEnUAAAoJEJcQuJvKV618qM4H/2MgiX5QPhMI0t6y +OYJS/tVWGJH2n8mgIMNxRnfQo9LJBtgEUYJ9OdppVaQ240+G5f3/PxWw/7PAuH0s +k6HjRgIEMSoYFxUCW6ifbdo8YQj8aWS3FZaDu5Lm7n2PQRPmk8/8xHrvunmqZUAf +2Q3GP4bjFJ2+lhUkMBvy4kT8w7pTUzCvRgGlUT6xNOdIs6bXZOSHS7TrDg6Dm2Rv +Rc6lARpY6gzZcFQye+Zm87duBmJmzBaDF9/ZakXUNZgfw993IeTbJPu+iQMayBwz +cUGXLffT0LNCdGwTB/qUX6eDj37uW8z+Lyhd2JCeD/6KditzyKkBKMh3Zwnuu6sP +tSjvxmSJASIEEAECAAwFAkJ1MUUFAwASdQAACgkQlxC4m8pXrXxDAwf/deubGmlX +0YLGyX9Uat0gpqfRSqycXnggpBVDELSzudHo+FS23saj/VtM0k/ub0/hdVyeaugG +JtMRifSKwir5q+DBDgll71Z8U5N+0SIucrVSiMVJwrZTZNrMwo+5Q3wadmLsmf31 +npeonuV14Dy7Fx1zfsnEIqKYD3BvS+7FF+4NwkeVgnjJWwTccMvky7AeM4Zuy0ql +aK+k27qbb7QmciFxwukhFty7WYNUtLT3PbX/Q7p2tnVvmXAsRS1J5mVVKKoM4hMZ +/+zKatr8zMqB8DO2dVJg17iLR6CxeoUt0LDyH4oXF2CuTbqqmCGefPUUzmbIHC7X +2QhNCSrX9dfArIkBIgQQAQIADAUCQocCOAUDABJ1AAAKCRCXELibyletfLeHB/4h +28N2gEVYhRsXM2if9tZaRWK9gu8TNwaD5qBgABv9Ucn0+0MPZPPj7cGQrVE2gFuT +kNjZ6E5K5JYG6dW9Rfm7t83QBfbuyn+vJSQbHqw4zgg6ZIPdHOPKrrtA7tONbf+Q +rgek+lIiMb58kNim+P0LF9/YfuddYhx8nzg8fb2LxQl9JLcG2fzGdL3j5MlSOx+N +m5PYaOTxbgktk8KgacvcIN8/4DTqvHSHImRcErxlA6KWAGEETQIZZ6e3ETwHwi2S +Pm1AxbFKBdqRRGm3xxs44n4hls6L1kd7L8GY++FfsrDX9+a3Qj7s0Y2xZdp4EYAL +9mNi111Wh8MC/bIp8JOeiQEiBBABAgAMBQJCiaYiBQMAEnUAAAoJEJcQuJvKV618 +uaIH/jFUOaFfflG49FAyxvIAuoTWPcyu5oYtD2j3s3x3XazoMobnwA0iap0i8kHP +opr1097jL/SQAJUEJRDCy+A1i2G9WDfAA8IbqLtAtnDRaTve17Yb6v9SHlPYx39B +cv9Nc09PdTKFD+N2YFJj08v8ccb7UYOib/asqL8H7MKdPmj39q9+EIa+XHapD9cG +AA5DiL/zbJjI3e73snzAPgM+KIzAdHlkkxIhbse9DQJzru3cRe+At/CknueYw04e +3+kHM1mOgQ84+mZiv12oy/v01uSq2rSU/kgy1zK4S3eiskTl1yhbK/wOdikcmQog ++PWHH4mbV3fNOT8cBSYcHWo/+0WJASIEEAECAAwFAkKbf0MFAwASdQAACgkQlxC4 +m8pXrXztAwf+JZzvVqKzhl4QFt+0tWTpVJgKtg1T0fe3ryn3KIKaM3NDLNrX7Y56 +dvqIOR0LYLY2PVZOiVdeKyEL0CLBD8zCJj96C0Tg83Siqr/2RvSaKS2E17WHXNTz +nwTiWdYh6soYmO0/sNs7BxJFxQKoIHEjFLj8WYIX7dCov9fgZaEFtmlet2kqdX42 +a7FYLxAg8aXr0TDX1Oi+vEsmu1lTNwppuWnINWrwULD/uvVfsd2QgjTLqf/jA4fw +lIllwa3ZtHJN7TGV9XwsegJ8Q4/uevAwD60aFvK950eOo2S74YaChXEMG3ZYNQLd +ozi8lXLpbBdCaWUwLCypi0kIwB6GDhpM0YkBIgQQAQIADAUCQpzQXQUDABJ1AAAK +CRCXELibyletfDTTB/9fcTywjlw6ixXF8FCDWraNxp1PZVBnFllXThg4U4XV/OxT +pKQUjBGQXFyraRRnJEGXDCKtXLgk/KdRdWcRle80rSQqrVvqNT4MWFfi5Benxf5Z +5hsFFPrhYOBU4uwRu5FdjCakR5jnzoAausPjy+/I7EWH5Hx2Q7kIjpezrlmYnGnX +2maURKcwYzKkI55JXHQUVxnEG6zAdSdXQCnh/zbIRgJpWhJ7eZkddBYx1EN4+b4q +I5uWDcebsp0CnQIYd5KpHHSR+9UrKwwyOTk8yJyp8NGSU/0zd/sNB0j2O3NfgYmN +Eu3TJn9c7tsGTm5JGPJg1Bc+0CrDt9dqX2ISd4URiQEiBBABAgAMBQJCr+QBBQMA +EnUAAAoJEJcQuJvKV618QjQH/RKTKRtFrMzD5tDRBag6Wu3H+Oq43AGa79Eptfvb +N1go970/NaVhzshs7ksTde9iaqG6k+/VVc6RHKv5ZKyN/jI/3HZr/uhzVaSfT49j +LssGY2UMrp/FeSQfUDUwghh4SMV1SyiTy4JQYhKofV7UY9c9XbrMqj+WzPAHXcVL +zjwcECIe9EOZH5ZsYzdmMc1X6N3/d9ZG8n41Rh/GCvr7W3DD0H7DPVGLzzc16dCc +69VWWWHac1DFeqJx6AzjHXqmQzo0EGd7CLfCr/2PfiuWwy6ArbtZRAECeAu8l+fq +ZKxche26uBELAMHOGc4k82r9o2o7vvhZR+nThrifwMNzP9GJASIEEAECAAwFAkK0 +hWQFAwASdQAACgkQlxC4m8pXrXytmQf/Q3SOtxKtUngVAviTMACPA6+5Qo8lNWnk +bEj8SIaw+kBL95zDpWEbIijIqNXoPfMK7QvLqcQL6uBS02acG9cbbnK3pgYQJd4M +bApKpxEKizC/hbvdSCDoomdc1+BA3b9yiIb0MHqGHhyqU1TI/KmThM4DBHyjywZZ +2HMFrQvszK6Is348rhjGi6SDBdRZRYB7pEcPt+cfA8oFfnIgWXVZXn+m68YAWDOK +fVN5ztFdM8LhCJReiVeE6n2l1MOhqK+d98RxpqYvL6uCNukpvDspPTWXrhK/Bsz3 +ZyMhqgE9qdo0EKYm9PMZO6o/7TRbs62xuoLJDcKBpOxQUmo7BL373YkBIgQQAQIA +DAUCQrcrQAUDABJ1AAAKCRCXELibyletfItbB/9lmYwMpiYSMs0PM5e95cwX/o/B +fZWdapoKXR2QRfP0o8c2wjhDxssb1DVVZ2ke6L/DMzodIP2g+lZR9d2tE5T5dl4u +f3jdaVczTiPId47dMVHn7sl29th6Qiuldf/TpMJoiNPeEMRzl9bl1Oj/PY1BKPw8 +EyDwJVPRXsnyiu6UsL99T4BdDXmFd4Gx6Ytz5Eg663773T/r5zGAlTWtm9mCehvo +RaEbt1oFzB4caVLB+u6VkDOJif0uMyGshGdwPT1ku92uHWadCOBKtV/NBsOaqqWJ +4bvp+J/zl0BsW03dDzqUO0i8ee6yXT7/7PMcEx/mQVOqZHbcOG6QIxfKUqZbiQEi +BBABAgAMBQJCyPp/BQMAEnUAAAoJEJcQuJvKV618n3wH/3D/fTjO3z636nmXMfSD +W76/LCvuliHrqWNIlayvRQLZ2WzT9VbFomCzuuIGHEKhn9gZPSq/p6GrLwY05T3A +/mb7d80H/c67rRQ2Jq9UOm2x0BPxDA/XnUFlHazJTTbTMT2a8r0NPF9dReZrdnPw +Pjqs2OTbtjxCnH9bfDdQT0TU8Z6G3Q7dR4C7B4VrhrnTmPH66sozI1K/jiv0ENYZ +S+eurYF3y0jiqvyQchYRerp1eMX7H0RcX3ZvqB+kN/zyhq+jwqoR/00WcW2/9V/2 +/anZBxZQQ4RwqwT7dOUjrGun6ZbbP2iL9ZT/792BhRk5Hf2zucx8NWySaQD5QFLk +M56JASIEEAECAAwFAkLMRo4FAwASdQAACgkQlxC4m8pXrXzBCAgAkYOtpWquk/iv +1kYnZqv+wjxYRYHtQMAvsxf1RcIfiDmWfHlwoN2MrXFfMPQ4GqXc6o1lCXMNUOKj +L4zcZEpmiMcgmMbP00ZKL07bj5Fi+GvC4bLR52gkxygxprKG/HpT+Eer75RHZgjc +awnAFRQcj5x+zUdzhDBqSA6IqqgJ9ga56R8uJQ7hBo+XIN11FYGL4LT2MYF4DmUg +wht5m5I2Wb7UvbL0VqBM0YepBB4fbzaSHJZ1UVyj8BarSkzlh/orUkgR9uxZ/MF7 +pvJ1c5Jbo6sm35g0zjmiymHK20d3Mzl0VmULrZ+LQ492fQY5GAUqt1CBI8dzy0q2 +rXbWJu+wjYkBIgQQAQIADAUCQtGOxAUDABJ1AAAKCRCXELibyletfJ0QB/4g4PGF +8Gq20PsHyr4ldT1B+3vNpnKOKfHfnxbgagP9O+R1okrSYy7HVVjay6sIlOTqoFlg +Uk0OfLdMCy7mDCAxo3BHNwms9UIxIP6BpuSYtJWcEzaPKt83kzfdssKMxu3H1N13 +Hil1YbZhD/Dr5OrMQUHLAQj9of9HsgbQBhI4eQK/wYNR6hy96GyUwT8GY71qKetW +I24gyEM9q/mpuvbi8meeH+SBcYlSDcgRNbmIN6JO4DeVnUwVKcCGDl7QAdXamSD7 +8QvZGdZQjq3kkv0KbPMzS7ROijeiQ2EeE6WoHOOqVhVJ1PPO399LcmoOBnE3jXaE +mRJCoyzhL9YZFHiziQEiBBABAgAMBQJC41lfBQMAEnUAAAoJEJcQuJvKV618+r8H +/1ykgGnsMTBnVTSpwgYa9eZ12wsjKJzbeitgh6+FT1sGvrhxJGnP/AWV4Zldd9KQ +g5W2SXH9jCEk6NozRvwuIv+9WB3DCW3G2BCFOyFcKthLSO2RzI0qfSq4oz4XwgTT +OaJTFLGxHVrnFFvoQ9EOio3j0PQmpB57x4yi+exEHjLi34za5LsfRgtlirN8nELG +540MX4rdCeOMAWCqapapFHsEefiCQgZeGV9Pay3VU/X3Wk243gZ5GigDPYHnfWt4 +ARiOxINieKfdAYgzunJT+uaNc8V/uec2BAeCx+jK0tFlsR3x1QwwwCkbNRoLqf4Z +aPRJE9TD3dYDcExStxWxPHKJASIEEAECAAwFAkLpSRwFAwASdQAACgkQlxC4m8pX +rXy2IQf+LCbOQXGD/cYEoeDRRpkWb0ElUHuYWigWKMkERFHCYIBkFLiRgQFg0lfp +Y7X1e1zynHg+Vb3pqF2gD7WN2y+nw3vPR9ztbVTHzrVOEyQOrippTKdE1+gJkKUf +3iWmKiCqwhxwM6K/XaxjspXfynucVxoX0uN40VC4SFUUNN14EkQSlR8WvXxqHhtp +LHrxFmX3E8iXDfUVSeuOnzJClk2ZyMZc1/2h+Lk+agbKLWBSOnHBTfj3FmB3IkdO +RiS1rM2Zgetkqt6ae16S4J4KUKW17GEhgtNNkymxsrDhjH8AajkL33CD+R3LsaI/ +jfbWX/a2eBqgHhy7aeMpsGGLl8FXYokBIgQQAQIADAUCQuyVygUDABJ1AAAKCRCX +ELibyletfCWbCACq4RVD2E5eko4N2ZG40R1ImrbGX256XXb2TMq4eQ+AO43kxZ9i +HzgiRT+Jzr+E6QEf09n8EuOavzH9BAZ8pYwgXAIEH3ZeUEJ1QcqDbim47oB2Pu2C +0vwp/bjN7EFmjY2s74vXA65sXq7MTr3dQdhPZHmV6tfgFRnR2Ha1grbkbJfjxyOZ +6Y60Ne8Sq6Ww+dSdsRlHYDZ/nRdnFgBCxxEtmsIAZUOfihVbqbeQg09xWh1CzO4b +8/gZ9zQ+uvC3R+vZbBtgBMYFjxG9xf49IuyHMbMZQGjdNwTcdN2DolVFoDM3cLY8 +lwz7ZUU7eynNUCnMJcveUyc0cFzFXvoCuu4UiQEiBBABAgAMBQJC7T3yBQMAEnUA +AAoJEJcQuJvKV618XQEH/2d9cfMsayK/+kssPLdfHGydZJgP/wWwISBJsPcRyZcX +OBQ3jmj3mNTijyuNKCaWj5mg8IDH3kYnC1mG/gTxIObVthfbwRCj6nlFdXVpYeBe +a/KDoBryFMCXHwf2ftszBVEv14u2OZnPiaNMBgF1PXJe1rDxaB28X93EjDDE+3Gd +z3EempIMOR+qFgOZb82ZbaT3DogiCXDm1AhFv05Ja5rmucEP0fEVP/ekxMWAkNqP +2TAF9v5bU7Yc6Of1JMpuJbTQeYjA9luBm5eh7NbNq7f2vss1wHaUtux8sKr8p/Ow +e28khoPf0YoCYEJUx3f/ocGMJfSZ/PjAmHThZzGsEX6JASIEEAECAAwFAkMAYx4F +AwASdQAACgkQlxC4m8pXrXxdbQf+O+vfyZVmUennJEvE4RNbdOa2XRruqzEaHoIZ +lHyuk0lOzlk8xbgC2puBCW/us3a2EqNC+cxJz5wYXFRRXmwFGdV3Ht1pLltctNCC +k1Zk2EknapL5UOeVkw83xkdAZ99WIWVZCWDUYpvyG6R3d/cez2UVK/tPWT3xzDu7 +Dn8NpPKhRJ261+Vj671GryvzFtKRYiG7e6PHuC6wHVifjN6jv1NfTtOFUgsdKDg8 +JgfoB4wqLStD0a5JsQWqwykQhxSw6snH+Zo9qsuHE8L0pceLbYiPCE2uTYLQACjw +KgrgK6vWJ8DDKQbGTINxoS5jnbs8Zd6pLMs5sVuPC0vFuEN0gIkBIgQQAQIADAUC +QwhPPwUDABJ1AAAKCRCXELibyletfJ2ICACyF3PAjOl6mKAhVkKrdeX+M1JoDpMp +y6LZVBlSHf0w/NmAZjry/6otd6Aas69BDyJ8HOGf9fTIryvCiyXXdXrA9Tw1CzF3 +h0GWFXAx/nMhePZPJ7dezOa3LEVXSjhKXMmEEeYLEwZZ4B8ssZylYNx1BT4BmO76 +TKuInJ6qO/yCia69mpV8m3rhk4Ve7nuZV0xNCqcikv9T5o681nRkLzhp1cERSD8r +8qcp5u4BqZFAWs6M72IHr/pD9uptzPXGqs1mYDcC4hw3aNZsxO8Y24hD9EadQDby +apIt5U0AzHYACTjXrRLwscfMNlAbPkMq/jSpNZP3quWlo2qlppyHciICiQEiBBAB +AgAMBQJDEOGsBQMAEnUAAAoJEJcQuJvKV618OfAH/0eOxEu+Omgg7qiRzV/BbGBm +i0mvcN4actGtiSkdlTxRmtvJRe5CNBmLVKpKCTCrAcjEoEknEAQjb2zVgY6AXuxJ +Gv12pJkghkpOZmLeZc3OLeO4l9gMKrs8CQEsR4sZeD7k/9fogiBPk//8nl9B8vex +3pCZmtSa6wSo12y37gliS4QTr8DPnTWy7EtHkxTJdGy7FLMeksRVCL9GCo5iVf88 +FRpCytkDSfcYLe59GM6dV/n07abnMS1cuTOl9OhmbbetFl28NcHxfPGkz2bd0lBp +vTie1i99fH0UswhTD3sQD7AXnoCHRgoSnRXqPV7fofcMTnJPGzAYexg9MHg0/OmJ +ASIEEAECAAwFAkMSMtgFAwASdQAACgkQlxC4m8pXrXzuegf/WR2u5TWyu0VPjvY7 +zju0OPfn+dGOL63JadZMD18IxUwrQY9hrNB5EOUMc65xf3X4eB12tA1rroHI4WDv +HPRIVciJmvdnhCCaWVLfMxDVGB86I2/IB53tLiFZOJ+B50zoulS3olC65M+d4RD5 +/lhm39byVdWdUYjIrOeBX9EZWpNtJA8wUo19iPunKKuyf4dGGEY1hfmswvroSp9y +7NKsASezUDIpXajJvvvRH4qpb6KeWIABJVZcPlppUfVd5zC9OfS4YBd2y0Liw7/l +vrDe4Gt/eklVmQoObjOILaxGoy2cGps+NVuwF+nhueib95/hozopgCHi2l3ka7g6 +PFu/n4kBIgQQAQIADAUCQxQwYgUDABJ1AAAKCRCXELibyletfLxsB/9nVz+mif+q +VN5+pygHuZV9dW8MUM2LYXAwHWeD5lZrH2fWSKQT7AxQqW7hg79vL0leQN368uqa +czp3HLzfkgu9k4HbkDJuysesaGXcdE95hXg9SZt9FZwENYPNRLcstTQ7Ch72oOBy +UnTqZkioVyiYlUppnrmmIWuIULSoHVLEjISn//MEiACwH4KcsFtpve/yh/tw/bCN +yjssd2vMFebxVJ7eb7mhJpy1gFHfBppLKCiHvYmW/aF2LucjZMsnoNndYDcdI6n0 +Cg6XUOZaeLDb40Ryszi+oWKFE67aK557X3M/SckXzBuxw4e9ofqzDR8KDBrSDN1J +hxEsGSE2gvGWiQIcBBMBAgAGBQJCdzxmAAoJEAgUGcMLQ3qJK7oP/1TTABOQrHTx +5K27TvfziDAHcPJ5zB6rplTvjYmQeQR0SM+dZjahN2MS5qaxGGNuMw+USGhvy4Xf +GVL/Q2eRyiP9wcXckBUcAVrZh11DSX+5g4bmREKKyEsiv1N0eUAS/zp4ikI0g20K +5kAg0g3eSa/UI9F/daarB10jEZwFAFq9w2z3CJPuxJVZ5VpxqzEXNPnc92+2TO8z +f+uSbE4FFz6VCH9Eb232yzLSvvPOhmaV8oiQRe9tqCFAWZOehmwOFrfhHHk2LVDB +OELI/zXEwmoOFLJIVJ6e+FqC86ao6SQWytsZzvJ9nPMImEEnouHz2mg9rNQgbQZT +UUfQWRa4QMruHZrEZlWhxGbSe5JNapSPqCaDF5H97J14Dy5i10EqHfXy2y+T63Vb +PUUVIxSJRw21zIBAxWmXPWzAek7chzHKg3ZeWTnuSEiAtwx4SjN3Mo9Kx+BLiYjH +NheD/acEyXoTROixfiK90v34AkpvB+Ne2/IIq4R4c2dPUW8kvzuKGDt7GpEBo6Ii +eI0TxT3BA3HwU87OBGAWjkj+lF/Qdim0SJudg3GFqlP77dv5HmG566FJhbcGakME +L2+U0SS1dQ+OcfOaFMfzOah0ZThOvVo1pfAa4Vpnyk58GOYlK9RUApgtukyBCTau +MFrILJTS+Mahdk0UlTLaLrXXMzezsUNtiQIcBBMBAgAGBQJCdzxmAAoJEFA6oBJj +VJ+OK7oQAKGmQ8T/tYC8XrvzpyPW8hw92QIHfv+bM5egBDjUL8XulZvYTQZza2Ug +TbfYhkxZbLngyDAWAA+Rxd28/ziF3FlNock6BN+M4nKnOoKz0ZgbwzMT4YBPhiGl +fe37gTEx0fMWCZytktsfGH9KJw6OwuKxZTf/bhhnWOnCa5ATWTOrMvq0JXBWXjmR +OZAo7IHTQfQJx9NBuKfL47CMJ9Mp4JS0qV9CmHTjbjw6FUFjnbIcAYim/CS8b4M+ +erntksXznFwwMKYOncqs0TJrw2DgJXi4bsERkxuCV2S5NiotZwcTLGxVTa0kjFIp +7+Zv52HRE93DGxcAcDfwojDFx9/7NAH+ty1D4/dzQaqR4ZGyMUyWVCJtOs9xX866 +ufuCg6mXPSXhK9qKpra34lh4sNX3aIyURQ7iah2VvFW3mbgQ+wrDgeoGIl8lIz1t +tWBHH8s6QH+MmKgpnGf/RKJcR9cxC+14byS0OhjvCOpuHGRFBkXShJzcAJpXUe44 +uxfjrtDW4Wicn+G3t42h1qoQ6vrFM/nUJdA6qvQgqzwU0uecZw07JCG1UaD/yKSQ +R8FnJ+zK4YdwG11pgaxwYMao7i6Ath4BsbnF5n5Cc9cjzDsjhm31jlnODzue6+TD +xWeqdu5k9q+H8r8axRmNVWzlqCSSzAS5QZFeIy60SuObuRnebXDVtCVBbnRob255 +IEJheHRlciA8YW50aG9ueUBla2l0LWluYy5jb20+iEYEEBECAAYFAkJyID0ACgkQ +0/mV1Xdq/hJqcQCgun7Huf0wz59XISsN05b+ov3J8qMAn1A3o0KHFvW8IdsiS7ZM +BwncVjnHiEYEEBECAAYFAkKUrSsACgkQi9gubzC5S1xVwwCfUVPvwqqz/NcZr5Zm +97OL+iojcpAAnRX1H7wWpnmHr9Q7UnYVaNDE4PMGiEYEEBECAAYFAkhnIQwACgkQ +lypuBSUcZe8aiQCeKURRgeuqrslcK41GuyFvZHprRW8AoI2sineGFvHMz3BUDMZk +7uuqL06JiEYEEhECAAYFAkHC7loACgkQ3+27IiW81b8/mwCeKPjSProR483OZkyZ +LG/U1gqIXSQAoMOHkG3AZ6+zFcbW2JzfGhKjza2PiEYEEhECAAYFAkHC8CIACgkQ +IexP3IStZ2zkSQCeID7Qw/tQukHsbn1A0pO6T5jSpMUAnRwMM15mLdT5azYxeL3q +nCv4YNgfiEYEEhECAAYFAkHC+JwACgkQK8hAFiBoeJXKzQCffWF3idk2RypLp8S8 +reOgh7eUe3kAnjWFRGnV48PsBSvfmAygewlUzZR0iEYEEhECAAYFAkHccmMACgkQ +8+hUANcKr/mS+ACdGsfEHiUYuevsQDml0Wjc53cWSL0An2FWEkJu46w31MfXmWqG +j8HXHHPFiEYEEhECAAYFAkHjuRkACgkQjmLn92QBGovNEgCfTnKsSAIsvK+vfrIn +eMncooP6qZAAoIw+T1BMAqHe5bBc5EmR62+TZKQMiEYEEhECAAYFAkH6sDIACgkQ +7Jk9Y2X9ze5X9QCfXKtqUusNyIkLgV+5GvYtUOgQQpsAnRy9n/wyONLfh2CmrhS7 +EXU97JA3iEYEExECAAYFAj9xIzYACgkQrGisBEHG6TCN4ACdGm1FnAuHvz0Tg8u/ +GmkFp1zJOgkAnRYnICFtgSy8xYZuG+lG9uruZruZiEYEExECAAYFAkAnN2AACgkQ +AfqZj7rGN0rFvQCfUXBxqMykJlS7hrbkRs+gE7yGO1gAnjfAec4msmbGhNCrVi6Q +xzpVzRK7iEYEExECAAYFAkGtiQoACgkQq3pgvCz4ZCc0GgCeLGjTdotgtP4oL8Lc +duBLxkzEhDEAnjVsAxa5S4wHgcyWKTEmgv/pY/FeiEYEExECAAYFAkGvALoACgkQ ++i3LsNJvIlmp+ACfXH+PEZ5ApcUFczAHhpIJCSpxAdQAnR+0pAoj+tePUNlTpllm +Eu+GBShiiEYEExECAAYFAkGvvnMACgkQ0OZ+tAQU6+P9lwCfYh9EN1dhBwzeSY6k +RJ1RkvMAarcAoI2Ssm3b/xNi5xrLFUZvp25Rn/WIiEYEExECAAYFAkGyIR0ACgkQ +GvGiCkzACFGZigCcD/zW1oa247sboMrQUD//Pn5IkZ0An2P/asI8bZ8VxMk9QcLT +9jAiru5QiEYEExECAAYFAkG0dpgACgkQvtLr/tL+0yEQtgCeL2zRY+xmGs7yI53E +bVQQHNA5bKkAn2cqmxjEzfEjmf349g9nUhqpsYR8iEYEExECAAYFAkG7osAACgkQ +NFDtUT/MKpCpWwCeLDACqaq73ab3OMyYRDON7d45jFgAoPalMbNLqsh9us4icexD +Gd60Nf0eiEYEExECAAYFAkHCj8AACgkQoWMMj3Tgt2bVpACfZsMDeRnl8b2WZbS9 +o5GE2OBdQ4kAniXDRFEXX4KTjd1TuN6dCU68C7pbiEYEExECAAYFAkHCoX4ACgkQ +kVdEXeem14+awwCeIQ2aOpRQRw022mvbCo8ty64geoYAoIL994XdojsZS51Bb3vU +TMDCfzAZiEYEExECAAYFAkHC1t8ACgkQZEH9AkgfRL0q6ACfcdmohP/5uGzL47Ck +e+iFzxrQFjUAoLyNxu+Cc+l+QBVXCUj4QaVAqqI5iEYEExECAAYFAkHC3ZIACgkQ +hCzbekR3nhjEtACfVxy1dHURTZllfU1OFfvN03qZxfEAoJHi32K9L1myb0pZVDI3 +TZbotrJJiEYEExECAAYFAkHIE+4ACgkQAa+T2ZHPo01SEwCfVr/5ylJFUETRrXWa +X8sQDvx2MGcAoMjJISALywdy02WHECffA57t/ifAiEYEExECAAYFAkHrRLEACgkQ +ic1LIWB1Wea0KwCfacIaqel36v1kr/ihZR5DqndfKt8Anj/HkqJWHIZVj9jgUPzd +6YvyQIpYiEYEExECAAYFAkHrV0YACgkQ1U6uS8mYcLFNvACfbffqJnMbbKaCpAR0 +exjBjra5dcEAn2s9LZkP3UjlNfXczc6MrWT+mQYSiEYEExECAAYFAkJNqTMACgkQ +zN/kmwoKyScwtwCfa+Tu/CZ5jjTiDJ4rfKLyUE5PSJgAmwYsjFdbBCwPtFslfPm/ +ylp2VrCWiEYEExECAAYFAkJyNEoACgkQpQbm1N1NUIjbAACeJBWwWAO5cnVXk0fD +2+d1Ftp5XLIAoO4YEWPPIrNl4SrK0S3hPcc3fzHpiEYEExECAAYFAkJy4ZkACgkQ +d/4g/qpqtcvqIgCcD0q64o0Pju23KcEYR3fsdYaqVaEAoMnTymx0lAz8eHLN24LM +MrBNkGdciEYEExECAAYFAkJzDPMACgkQr3O2CKlAUK93BgCfVSNwMMEZbIa8B5gr +bVya3O+j2dQAn2v4Z2QfogtM6WvBVKphlbbFEOVIiEYEExECAAYFAkJzKZYACgkQ +4ZLAVDsbsuuazACfYrueUjoh8fMuRjOS66FaMnKCI80AoIdwZTRvFwHZs8brg2hE +1/FSiX9piEYEExECAAYFAkJzV+AACgkQoDV+ZULiweVC9gCg2ehs7eZF9WQyRB1T +7r7O0VO1aUkAoJMVhZmbK3kFxN360pDjv3wIBRdBiEYEExECAAYFAkJ1X38ACgkQ +ArxCt0PiXR7SEQCfdiMnRnX0Hyh5N+Cs8C30Ax7O/QoAn0r5tuOAn82OUl/faDb2 +PPSEo3AAiEYEExECAAYFAkJ1n9gACgkQu8b/uaAhL+Tm3gCgnOWEs2n7Fgl33Kt5 +kZ79v0jgTVAAn3mc5wEKolAZ+5r5GLgQSWpJBrn7iEYEExECAAYFAkJ1ymEACgkQ +vjztR8bOoMmZJACfRLcjQVQ+oru3rxv7ar4VMh29V/IAn1cgvTDjRSk5P3HZsB3Q +fpvi+hxfiEYEExECAAYFAkJ2RE0ACgkQ/qs2NkWy11vOiACfR1cDbW67mKnjcPly +P902B1eJi8cAoIFMhyVSRcy8tIFwJrJbGBlGVxkqiEYEExECAAYFAkJ2RhoACgkQ +RsWY28vsX4B7VACgnYOYtygPhy7i0cQ6f8Pr3yp4cg8AoMPlE3X2ANiGDTtYT6FT +fx6Jja01iEYEExECAAYFAkJ3I1gACgkQDecnbV4Fd/IsXgCg37el+d5RaL6lNazS +JOYgKd6H3ngAoPBBrei9yzasVv8G0fWJ+s5hR/YWiEYEExECAAYFAkJ3wxgACgkQ +SsOT+6LQaTbADQCfX2byzhsnNPMEDQfBw78CX2iTsxIAniPuGLrAoAfrWfPdWi+G +w8fm+bXWiEYEExECAAYFAkJ40OQACgkQcJo/YDt+FuFr6wCeOl3Tu0MbEhZd8SQP +y6PINUJckw0An0SXEClPMpImxyomkQAppocWl5MniEYEExECAAYFAkJ5/hAACgkQ +b67zLlCCcv6SfgCgv9I8QNCC8s9AhVW7NNYkP1OaYfcAoKKXEaTFdQuL3S2wiqLO +i0png+6ziEYEExECAAYFAkJ6TDgACgkQH9eQw/Gi3tUNDgCfT8x/vjNiwil4p0NF +vkuRClLeLoAAoNhpV+vsEP2X009SQlpM00dVw+TKiEYEExECAAYFAkJ6XYsACgkQ +em/rb/9SwVDjTQCdGJilTUfMc2UfDe25OA6L2zXr5vYAoNmZHdTPKnlBbY+jLue2 +xKAFRbNuiEYEExECAAYFAkJ60gwACgkQBlHlJnS3xyqlOQCfd/oBittshgWBc7K1 +foAjXkM4PhMAn0r3H235Ys7AVwULXudvHIWib1uViEYEExECAAYFAkJ+y3wACgkQ +PGPKP6Cz6IsknACfYUEJfoaYLCaYpm1BybDnY2NKvEMAnRUMGvzyClAn9z4Gxt5U +F9hBsU0LiEYEExECAAYFAkJ/D28ACgkQuJQObal7aaCeOACgmJRvBQPt6q5fxww6 +hWBUUhBa4UMAn1TwQASQiy1JaSS50WKf0dPaZb4HiEYEExECAAYFAkKCVfQACgkQ +E91OGC5E08p/WgCgnZhQW0lm+xYR+6eU6KSleGhoHDEAn28xnHpwdZ72vHqLxfo4 +X29GAW/9iEYEExECAAYFAkKPLQ0ACgkQ9t0zAhD6TNHNKwCghZNKmFr1FgW38fMR +FOMZ2b4K2rsAn2qSWMnl6FxeC1ZiX/AWiWTzR9GGiEYEExECAAYFAkLe5ngACgkQ +DCFCcmAm26ZweQCfdDfZzIlDDHs1M6igPMkWnhEFf+IAn2lmo9MMQvvu7513NUlC +VOyc4OHFiEYEExECAAYFAkNDT/UACgkQj2gB2J43n8bM5gCcCi/c6NksFjukOtjm +kLSmUmB1W4wAoIbasxvxb/O9IAQsxL9+Di53wFcYiEkEExECAAkFAkJzHS4CBwAA +CgkQuJQObal7aaACqwCgqbN49Af1Q3/DLDhk3DmQsJq6OJ0An0tLqBaTpdc+4RpZ +zJcXXRwCLXDhiFwEExECABwFAj9xH2sCGwMECwcDAgMVAgMDFgIBAh4BAheAAAoJ +EA7dxfJqRcgWFcoAoJoOhCoaQ83J4SbzrjCYgbrh0ddyAJ4v8GIft8ED5wDC4qlf +AXhe4K0Ow4heBBARCAAGBQJL3EkUAAoJEPrvEpNt0+PspaMA/iJRnZQkJso0ZRHb +NPTpWGiA2QcTNygn9qSC3CoSosuxAQChXFGmX+zpgQ/af642DkcZYYVkqCtdwvxw +xLexizfLX4hkBBMRAgAcBQI/cR9rAhsDBAsHAwIDFQIDAxYCAQIeAQIXgAASCRAO +3cXyakXIFgdlR1BHAAEBFcoAoJoOhCoaQ83J4SbzrjCYgbrh0ddyAJ4v8GIft8ED +5wDC4qlfAXhe4K0Ow4icBBMBAgAGBQJCTaoyAAoJEKv/B7RG8yEtYq8D/04fncLC +aCL2Af70Chc35Ewkv9ZF6AH38KbEHlkqwTcpm+xLM+LkVw5YxkCfBPR+GBXTD/Re +1iVT812wf4e97SZDLajqbvcnAeSW6MOZQRdukHQwHpe3nYu9g4P8UDiXSia6B379 +oZXsMR2mi8LNOgjiYd3K2gmOr8Rht48Fs7w0iQEiBBABAgAMBQJB7iB8BQMAEnUA +AAoJEJcQuJvKV618ohUH+gKUiyF6yoMHmrH99+qukuAAMLZGRTeElnZMh8e6VhPs +nWOBpq/f8zSe9pqAIrT5/twmBhhg38LPFq+BzNaVi9GLF5bMzfPqcsrW5WIMeOiZ +5iB2LJ44hKJ6PNmNsJNbnpKRHXd9iBTyh+SSriDaGRKG+ktzu4dHYgqSlAm+4r/e +KEs4Y7p4hrLY2DkQ/PUHXJMZZlnwtbvh4o9/oG5m7LLdJReRXjneSnpqwey2wReU +ao4+uQDYDQXDvIDtumiRFgkZAttTcjVGqYPdsDZd+0p1ssqU8KGwWOLZsrz1DAc4 +vBv3XZCgG40mMBIVKb+P0bKadeXJrihYGpfAnaKM9DeJASIEEAECAAwFAkH/390F +AwASdQAACgkQlxC4m8pXrXx8QggAi8VBS3yFG+zQszrCp3wjkslosm0apc3q9Yrb +s1U61cXjHPqaEgsBKDfzWmPJR3kDQFjOjEJb/qvJHV6qe8HbmcgZjfuWljb8YWco +KIQqDOvCVPq2Q6Awu2zEKiLGk6KWDA2Cz4XkF+Su837rv83mEZwPotcJPCl5wN2g +/jefxpznFH61b1SS8gRKaogDC/e4JtYk/LwGs+dJeVGYtzdWNPIDSR8K3nxfdlPt +ykXxFUqOZr7m1aAfusqgd7ykL+LeAz7vqxqN1yx039+rr3zsteMp6fef5YB/pAGe +TEEGUhyGS9ezEt5OL/ELrCpNtvzq5Un7QawiRkBull1kr0WkLIkBIgQQAQIADAUC +QhEEFgUDABJ1AAAKCRCXELibyletfOR2B/0dphUcbzVJcsszJ+B6Otq0GcY0xNSU +wtZt0dDbSkQmoOlk8CP+81sfFGxTwDGKvn23172ExQON43z1WFUiCazJGF/f/udB +xIKQlQJo1YM4zlsHBBly1TWlRTLOhIy+nBro2I8T2OH4M2eTg8oi11DekRf0FVrv +cD7DmuOppocLVdyP0pCqxeGKrbJkwY4Ht2SkdE2Ubvx0T+o32+IAaIevsrjzssf5 +oZrObzZA4sBjFao+4puyF6QeFVjyhDOc6Lq7ZnxD8K4dSzCKA2t5IcTrqQRPzpR4 +229VLkqoszBFnN4cHBxYymzPX1vlyatVWA4D3mB15mbmIQK9rznpo/oEiQEiBBAB +AgAMBQJCFwrUBQMAEnUAAAoJEJcQuJvKV618TXoH/RB3qmbHaBuDVAMw54Bdxm25 +Jxejeh9JWfUv6xxB0TuTdN3fjzYQ8nov0cYnKyDiPq5hxhbC2SXhgkmHgXdCt9aL +7XXCHuiWPq5jI8iTHIA2FX5IbPf1Mm4TLocZQDXhZ9sa1Ij2hFLuViL392cskGe4 +qFZN0ME3gf1XcNfSBAw2c6GaMQ+Uz6iAiXHFE3r9BbTnxZ4eIEM0ovZ70wIEnxnN +YZZchG8Ou9kTmx8QTziQh1cY3b4nLWY81S18H0ztkJIiMKu1BiI9wOrAhLHUyNhn +qczz1OOlaWYKlu2ZWqVFv4J/GgoJ/IwkAVXcPcHKqVNgTkSB6zT+Jseb4wY/XnyJ +ASIEEAECAAwFAkIpfUYFAwASdQAACgkQlxC4m8pXrXzTiwgAjhh6QYGj75AjxUrK +Ef9xZqblCh8zZCVCQTCGlDb3r7UcYFxbNCa3qPZChlcKeVaLQffizIjnvK42BL3y +l3kqqMR3o+ivW8cxNBiLeaGyV+izwtlMi2iRc4A7j5DWRJlqDtV+C1VKX8KiYiWz +hEsLtC2ABJ88EDvt3m8hcv++RhCQtVLeWamE99CfwVG9hMP798I9hsul+e4r2xEJ +HJTQymt/GieoqJs8x+K2+yFelgbuaofapKAp4iNfldw3g7IFeCV/pIFPWfUp8lEB +a/fwUXY4+F2K0ICLsbK0iePBef6y6QJsT8vmcG48/ZjJzWQfr3ltX5Zh4fBpcj1S +VyNsMYkBIgQQAQIADAUCQj0wOgUDABJ1AAAKCRCXELibyletfIQKCAC4JB9ymfiN +Lojp1fX8aKpWIqGnX5FqY7lBVQPh1kABjbJ/fqVnzL/cJf+UPOr88UmZVDKD5k+R +F6zNi9UMCXrIsJ8yLPphEHcqvOS9VU+t2tDeYKPwB3v8L2aThn0VFjrAfmq2zrFS +rJ3rYQVt3vDQyBGlwJ0n5FX5QpyZRYuDC/PPSP/DQfBRfHGwTl1K37nnCmINVlVh +adBuQGtHaz9TtlCVEnBYC6OggcLXUZfNUsv/puyiE3lrn53WGcvO+fYK/73GA02w +5ZZXq8hPXmjmpQFSXc+c0Z6dbiS8U2UtQOSrI9dpjZDr2MbUdsq/GRTt9M7lAoJY +tK50T5DihDAPiQEiBBABAgAMBQJCT6VnBQMAEnUAAAoJEJcQuJvKV618XnkIAMsZ ++B93fxkgFT1my2hTCb6rIldFGEyjj1UpWA/Ip/EHygj0kRlD03rM99R6KKwkrrUk +a0P9v8KxPVtjdZKqLEQ2JHNblWGhZaZS2bo8dNz/JI23oXQEcfY5UoAD41O4CnP+ +B2RMxu7/jutwZh+90Z69p2bhcc9asjyLxVuKx0kdUpwLpnGz7zQxyr1M4TJWm1fl +oa8KXRvFar2+CCjIC2EcdTIuN3DhS6PDLGOho7UWxa3cw1tL7QWxiL5XVKw/ZF/J +fF0PnyiVyWFzXs/n8C0OgalUyvrpi6p1J7FP4cN4byP1HK9s6+UN8bJ04S77pjy1 +inIqOlXxs2P6X8nsIrGJASIEEAECAAwFAkJiFQUFAwASdQAACgkQlxC4m8pXrXxs +CQgAihNTBsptHyHR1jq8WjLTSsMdKxBjcwIlJTCpiSDQ1i0bEK6VbW0lqxBRhFyj +0zjyng10Kb4TAolyg59xUElX8kihKRBWe6iTvlPrVOsg4TGT8UVzoBzAT6GsZdiN +5+x/xKkcWfXiUBdwpu+c2BdccP/yFVL7wvTQU1MpYHO8YEqMX5WVQ5czWVpiy0YP +MYJK1bC4OWd9GaaqtQZe/SPhUENoVHcD4hv95QQ+117RtxWoT+lruAFJgiM/jDPu +MTOI657iPGLBajIznIwM8TK8avNoRMF2E6gqNl2HZKtOf/lzrHQYHZhEnVkOYggg ++0DrPbh1PETPtI/uikUbeNt3OIkBIgQQAQIADAUCQmK+FwUDABJ1AAAKCRCXELib +yletfEctCADD46hZwAkLecVPN/E7kldnROSSrIepiketWDECtw8v4jjLxXaB19qY +G/+lixIATVLA76aF0PmROlL9SaxCd8wyMZIAIWYzXDf3OVBRg09TEeZIMuG1hpUS +u2RhHOZAHrdvyDDaRCdLfDftGRN2R9V5ohtoELM91IqZ4ain+r2hamObZWG3Y7MT +xpwE6CJsCjfXACuTo+6bHXuNJS/IQ4pS9fnjB/ssTd6NDAUjihygB1eQnHbHhBGP +PQBnfkSIjMRKGcTdV3XWxzUO6Z4wxHdkgdevW6Q9A1n2OBF+yHbSsJ7X47Cx1CyS +0dzqh/MXN5qZfzbxO97GTpP1eHqTwjnNiQEiBBABAgAMBQJCY4LJBQMAEnUAAAoJ +EJcQuJvKV618zScIAKlyj9J6poxfy4LoKVZPxWlsRn/F3EEiI8ocA//MGeiaP4/c +m148R62hMlmYLn8WSiy+rsCqjqjEVH3PeFfUvG2vWF+rjXaoerks4OWjYiMnFNA/ +pdaa65FgSh4tSeAhcp6F2OlrIfSBmv1YoyFoE1vZRNzMEGqcvEr+OFzWMsDhDsuv +LZpABGy1bu2IKNY331whR+ufhb2zfn1xic9IeoUav6q1S9e5y4yAx8w/HzX5oX9y +StbynHXzXnN0SyWVxydoZ+drsIkuMK/cl09hlLPyPMhdg6K2teiDbmORCDjp8zAE +U3/XmfZLQZVHfQULtI3yQzgKxK3Nf+XhoCQVLFaJASIEEAECAAwFAkJ1MUUFAwAS +dQAACgkQlxC4m8pXrXwyhQf+J4qQLkgKhrtUO5AKiX1kefhznJm5t60IMomOwctE +O6SaZnmpCTgfLiwdS0GM5pXRjtpn2pWOWFtKgSAVkCKBvp/B9WsvmK+4OdhxiJz7 +WGaIfOL5srCo3CHF4X9nebongzdleJ27f77MVqErZCJDVXqxzdFx0BDs3o7q+k2l +AHZoyvOrLiCnikf65iK0l1S/D4U5nYwSsA1K3UOeFfA9XbGjJ9Q6FhZrMlEXjQVQ +4qrDHQGWwj89c348x7cE0NJFUjQE8k9pzU3IbrjzCyIssV/Hzwqu71i7qFomy1Nk +gzxuZ+ow0XokKPELt2DTKNjoFObCIjYxcMZwe4/ZbuHcKIkBIgQQAQIADAUCQocC +OAUDABJ1AAAKCRCXELibyletfIvyCACLI8v8Gk1QB1U2+F8ZJaBEoZTQGHI0XLMN +j+bZfpSg/cvreW16omimthFNhWgO1HiIMkugbEmpthqG7NylXM/HrBVAoR7zsYJ+ +C3TUGkFmVaBMv7j33YIQHhfKsALFkEadSiE9GTFDMD/QZ07CqQCcBWQD2+aRXUwP +w64VA94aBvvzwRmDpOLqWsj5Ph50p/528O21Rt5xOVFZnTFpB/6oh2pJtXHNeLZi +b+Sa/7LHgYgMK7zLhbC7l5tyU3LyPhIaKXNiAsZriRbC/NhupbHm1JwIU5e+3I8R +WTpzsfC1atvi/R2E7FaZp2y6of57pNeSzJBMMQPNitIQmro0iaPeiQEiBBABAgAM +BQJCiaYiBQMAEnUAAAoJEJcQuJvKV6181e0H/3d2UD45r9syAtKJwXE/0+KS82ph +6CGGa5SuEx6lbIpZjxwBbSPgQ2VSuuD77GhZ0KiSMpcRVXvt+UnOK1jhz3jJgdfy +6FfFuUZQ1IJXXX6x9GentjdGQ7hwaYA/Q8yja/Vc8rreKJmnOdeHESRY1tc7kve1 +jXolTW18SgRobU2y22G/9kndcwgcF/XkR0Pbf7lEC88bg9eOLVvJTaO4LQvrErUs +jjWdowr1M+JWGzihxuQCGTiUl/TIoTtN7THj6ES++iXUKAcCqS+FCJmE2am4S6k0 +cyRlO2e2UZ/rhk/M1M88yr0kxiLPBR1vTMkIhVnpUWHJDGNBb3ezxyPGTVSJASIE +EAECAAwFAkKbf0MFAwASdQAACgkQlxC4m8pXrXwDmwf/UjtyLycjfZkErqY0gTxv +Y/sebNW0YkoVBT3+kjvZCduGaYiJppS7VS3DZwEk9Iv/oWPQSdVrdkAJ/iE8JmXw +jbPw69HEMNwwcgB+iIBxiNq4N2zowis9HschXcS31i1F6Z7ciJcYtPUVYbelEvLl +pAYPKt7q6cbzn1HKuEg1+ysYgG0IzCuMhBY8PCjos9D4KOjlbgXV3xUO4dCCu+B7 +LZHFD8B1Gp2Ei5ub+KwfQ52TlW9F+gE3LHLfDwUR/T5wJ7MNvNR0afByM6uukfxy +s5SA/S6dtiHTuVt+QUotLItkXZuMFoURPxCovxTAb45kIim9XREvJ/QnrQ9KJ3HY +uokBIgQQAQIADAUCQpzQXQUDABJ1AAAKCRCXELibyletfCmhCACoehgq+x47Ib9S +ZMXBmJeVmUuICJujYTPjQDi+HebTS7sBA+lqnPIzZQHNqZ4FBHqMBNWOD4qZYnoe +2dyMfryRndtHy1GYMFShyoCL871GRAm1EE1m8bh2dmLQ19gMlJIPNXjSMP+uevjz +zohjUfivA4WfqfSuaf5Yjiqsatih7nB2y6KS4JPY733dQ9vOJMycXjb/iuL9ielk +ge9dqXnMnpRgIStVZgjJs4N925Iba5Yj/1nnOVnB55D76fGX0ZLKjQII16ozp7QK +hQlSSxOBy3wG80A1roN/AkB36ALb0QxBZSnev1mLAc3TXfQbjvxJpLIOTi6m2nH7 +lnLXyquZiQEiBBABAgAMBQJCr+QBBQMAEnUAAAoJEJcQuJvKV618WDcH/1Aa/7zt +rZRHMP96M7GOPQShaOnJyFf7AGsLOCYeZUZkpYXGw92kPdipxrcZDuzwayfTWi1Z +E45c4T2QYhVmN+NDYE2Ye10xDRxarNhUS7ddRJyNCTpJ5VzGk5qBzfdbd3UIFDGV +F+lgcAmHF0LYjb9H1vlvCWaxY9qRsuzysOPB8YH5YebhrLCcYS3MOyf/GKSZgzrT +piNejfocmB9Zd+jiEmmd0w1VSBAgO2009OTdHjSfHPPJ3knjiRf6oQgO5H+m2AmV +H4EIMO17k/T4+OlSs4+4C7WxJTrjoBO0c+qJIzAptJZWMxkTMZrfqsCpBD847a1U +vS2Vx03qvslsz7KJASIEEAECAAwFAkK0hWQFAwASdQAACgkQlxC4m8pXrXzMIQf/ +UnUkEQgWn9PlEpNjQb3uILsrJX5CC/NmaSIWt1EDxxxq/LD9Z6AoMWesbQTyR66D +MrSh3WQrnjgUKKsgDzmaEd0BI80QAqsJej969RuPtH/Ow2M66VFswmj0DSfmzE21 +6Q7qVZKSh/EaG0oQH9dlEPtKhaesetKQLFxzznDB0xor6aur8CxiwD2TY8t7U/nK +klxSPxowuEQXsLPtEA5tGH+EUX/5tdd9xDWT8RebcFQ/EiUaT95R6IS5jCnRPAdT ++mnMxqOdoSSJIW7gVyCZc41Bckp3aN+KQyQqET87gWbkouT8vyBohScXP4fSHFjd +UGZn+YyBqK4KEx8DnoXBa4kBIgQQAQIADAUCQrcrQAUDABJ1AAAKCRCXELibylet +fNDwB/94Rj357pqkfFDfNZ6ic9T6rNIGwFF/AXSS33ke8LMZkZw1/Q5chEaQdX5V +9ZYyN+5crIwr0NyGI0m3wyNeRpVU5nlMpBRC5QKPN2hFMRyYldt6C2zjrhbhX4pu +zK0cFN2eh1jYxtpOCMQjpZIegFPrRY87ydKgECUh/Y42durwsfKLkH8roEqZFCJ+ +7QBeirfOMBXYKl7DlXZu0d7eF3t0+77Qs8fpOYnbqSAe63PhxKkSshPLmk8EH3+O +oUbQusYh9xNCoiW8utL8jrf7xe8tj95jnHwfegwRDJ/e8OIireW0XkS7a6maY2BI +lCYm8hIzsDUmHSwRptovRZcFgq8GiQEiBBABAgAMBQJCyPp/BQMAEnUAAAoJEJcQ +uJvKV618QaUH/iIpytf3QPottgpT6pNo0lYMj1cBpDMkTT46RcFeBlFvslSsnabm +edcBO2pJ9EAT9kI9JA1W35JQiKDn06b5ChwVOcV7rE94fTb4Vdg85uDoZbz2WbaD +F9gIfYleYehTR0foqHFCeBCbbSQhh3IpPw47IgvJZlUZm0UUpU+Nh3YHfWpS1QsS +NmLLDziGFJ8jOIbqyQDKZPk+60FMiUY0Nr6C72z3i/jwcTkuPMQjkJ1mgwexmrTi +nCPpUIW+8QI6V1Wl54PrSrIj3UAuwbMqGDaYumsqW5q61S4mjiX6ZpPBP+XZiQvo +rt1MGA5eMvGZj4YLnL9GOMqbaTtoIS/rk0eJASIEEAECAAwFAkLMRo4FAwASdQAA +CgkQlxC4m8pXrXzjmQf8D9j3K+vG+KRVHqUMkIqyyACxe4nYnwg3Fuenh14XqsX1 +UY55i90hOsb097h830EUn5b5vEn3+HcjexnAH9ZPlGJRgkKQ1Ud1uqRiBfeC75CP +CXrUrOIMnB7utaIBn5nCLlqKjTOqPAnY7ddUcYcUuuLTqxcg+bLarhyO18tXvMu4 +rtLs5XWfzORhFGN02wLNgvrbo5JmMILe54xyg3R0kQEQNwdQWiKihd/jJvBB0piy +pQF8BcLHSSjxWB5scsa5NQJApNljaqb6KdjF7h7JDAFVjg1HhOIQ5BwGV0nAT8wg +v6Dl9UVoE+TQdcMk9XGtbMjUp4dO/bnQdSw2CPz09IkBIgQQAQIADAUCQtGOxAUD +ABJ1AAAKCRCXELibyletfFBsCACBfqyXiXJ+dhVB7ZckNd0Sd7Aj3ABosNTJpKbD +jKdQSOFhk6+xO+VXCisi3NY0V5CysATfbOhCSapmT7Gy5fFhp0JB+FiAguA8CN0y +0kXx1LDnhD2HcmewCjKWE3xsjyDXOB215uyuzgYpbmyfL2dqXN6+acN5PrenKjMx +WIwr1rkX6tjKGDXw4BNaoC+AxB2Ds6HyWhgPnN84bKimXtd4iVI30tIlqWKYej63 +N4IUOClGJf+S7Qs7BQzOtDw3zRDl/XhctMrWVFUJWExYb4IWO8fw1OJckXN3le4g +p8DHvciRjuYy2D57OJP3d4bMGB+MoVZljjCfVRLxFxEGnxwNiQEiBBABAgAMBQJC +41lgBQMAEnUAAAoJEJcQuJvKV618p14H/jLeTMSPwRPxfu7Cf6iLM8biEmYR/6dw +uhXAXKlT6AnSa35knP2l2f8gfOP0R44aJ3Pt0V1SlWkRwqcl8TSTVHkikouc6aSU +Q7DtC/LaSFrS5u787GQLuvlzeb3VSnflauZ91prnh4EMJhRLWI2vcE6r2VfCuE7v +LAqFtd+56FeiYesjXo2evn1BIp0vlp8ntePPILq9Xid1l5xD/wb11BTECUo92aDe +r5WCpyi8Ea2hlVsECO4y7Z22+bNw/kjpXRP8afMXbnHcZmj8mFUR36cvEzwMbiXg +Z9Xg3DBDYm+wRG6ORq78ReoiT3Z+Ax16WJDLgYMX76VxzRFdHJGNNeSJASIEEAEC +AAwFAkLpSRwFAwASdQAACgkQlxC4m8pXrXxv2wgAvV5h3lQp1b2hCNtDpi7KkKK+ +B4RID5kHzNa92L5wKuP7GAhjjnd67jzYEyoqGmRfG0IanNvDTypsRdB7AgSIhLQ3 +oyhNO2GioC2IdBD0VyKMnRrvlxVEZdx8HY/ennh9qKsI4laapGn/nmzOC6rD1/77 +yEATnBeflwFlBX+Cr6+m/cF5x9FQaf5bxDuyi8gQxcb1KLuOIlUui7NwbMO1kcal +zUEcPgitAykms7PcAGZC3tYX+NQsjHb2pU/eN0UG7e5yKWCjDl+NtvPVQmbDaXug +TW3XCkL2Pl9up2ODdXqDRWyCZPB5kt56LFeHh3/RL9Q6LODDaBQcDDAqFI+6GYkB +IgQQAQIADAUCQuyVygUDABJ1AAAKCRCXELibyletfOpKB/9RRH7P2bVY28zRbtEE +B2FTuHtSky0iMli9Y1skT2hAeEQl5aAB8lXJTWUqll/sMAYNYlCKMS6jkM+5WwBz +XWg/EqwSYtH79gK2dhh6fxYJzkqXOC65wGAzGDaMIyS5KwwxuyWSBrwKTBIkXNmv +meCsk3xfL2K0+Gmb53yuSU0gWUdTMAQf5tMT9jRqAbZylqRL0QBfnowhXLXwBeAc +C3NzuamWmOY5YYEaVE1yjLpZtfVQS4Za7b1ix64etSxS95xTNtcGuwDZz3+8xiPz +5Eisu0azX6msIqReVSceLQo9RJOaQdFRal7Xl/yO+cnY/f//rqQ8EiS+KTMp26kg +b7lViQEiBBABAgAMBQJC7T3yBQMAEnUAAAoJEJcQuJvKV618uN8IAJkCNePWeQwm +44mjdTLeeJM/3lPh3mFWEKdH6O+62m/Rq2i3+94iu7arFQ/WjpPOd5yiTb+MzYBW +BS7OV1tcGgQffA5h8KHST7RafZqNZ0GGtIBcXXP6U3mW+4y50Zb35dhhvTq2Jo06 +3ZjzgK1+h4nVdgVf0MoWNuLQbo9TWW0g+GyCVJW7DZGh4VIFwCVWnx5BpUEsRREQ +5c7UoS0Khnc3eQ9EcubfQwMngC8VpfgMBx3+tDbJ84p9TSKhlttcq9XqBGBIPDp2 +wuDNRrOGJk55MOq0Q4f7b/YR1zcuQG3vlW36cfUWc5xytRtEDqAlPiHMW1Pt0TXD +5oCpXve64CiJASIEEAECAAwFAkMAYx4FAwASdQAACgkQlxC4m8pXrXwWjwf+OtQa +0cYSIxGuKtmoPoAQiSDQBP7sWqINLIMHwyWDYb+nwF+1v7pJzAQZmdkJiiH8gBrw +rL5PMjWsUb6m3NU+OSu/ix2cVAtlei7UHkJpYtTpHr2Ln+yrD/CVDTdVwihok93j +qdqNQFpJZCRdY3rYkOunQANwgBChiShD/6j1D0/AfkVgU3bg95VHHgavv1KkZFSf +/HLVOMZt9GFqUwh2k6Z0HwRYyRHKaeav9okzGJm8viKgRu6X3GcaZBrmC60qYY1B +uPvlcWVibJyrMGZnaNmx1/lZhuvovvigSm0p0rScuCHMiDLnvZL9exOTsLoeb+iF +tNgmheFnxTeobMrVTIkBIgQQAQIADAUCQwhPPwUDABJ1AAAKCRCXELibyletfK0M +B/43od+zVDI8iTFYKMKTh09URxw6uEt78eRdWeMi6Ccz1nUXPABffSTvwafz4C9F +54eiNDH/9bfS0cB5Qgjz/WjCP8/XEKqyehLk4xG5iIqmUuRjnV/im+lpY4Zf9Y4u +YM4f3lrRwcGXKhyFmoJmM9AFC1P1rdADCCb0nsrhGkBM9AkscB30d5/u8pR9Lbzv +i014C6oy3OGgforCTlG/fY1OAroWoFpYmKU/9tQlHl5/+xQYyHbawfDkwINKPZTt +lwv0yzWFkQsw8rGaIpyKHG7NAhwNd4MlMR9ka14a45wM1IX1DJDKDBUzduikCRr2 +T1WU3bodZ6oo5HiSWHAM4Gr5iQEiBBABAgAMBQJDEOGsBQMAEnUAAAoJEJcQuJvK +V618nmIH/0sR7xHvLfvU1r1xw4FCA6gmEKB2xkj03q+Z/pllpf8jbzryc1KIgXxe +eqI77YjtZKoEvym8TP213uDmvNP2KaPwQzJqxENYAk7qyAyUIRoPTLGp5dt5BIvH +w4Q+Ss20DBwWZh51skuYvEiORF/VIslw/zj67Hds1Bv8CK2m3yyvR1eyDs/1uUrW +ocwTfr/1RvEx2zzhWAuRm1sr9xL2jT1gSgd3PbMDIIK4JPR+r0/8o+6iJTM1soM0 +Obmbd0NYHLXk4SyheYsjVSMjN91gkdzSxRS0eMf7NqLaLWR7g3B09goQy6B7/WCf +OKf5pxEtpPws7EPIv2qHONledvnBIByJASIEEAECAAwFAkMSMtgFAwASdQAACgkQ +lxC4m8pXrXxWhwf/ZiZrsmk8nfjlFJzDOPfFxrpNgfQ5BchSI+Tgq0+advzSSDbI +y9bXsHtzEVAcjdSAtwC3PdiQrlp/NxWHs9M0JgN2YgtAyhbtN9kALlunv6al8+Fv +mWLT8gkdBuzqXnvZz0hnKBrV8yyxCrYrBWj/rCsMmjGmkamu8gm9Z+eFo0r0lZQs +liefjL9BebBPKsdfM7A44jbPqXUZyd9QVZjg5xauDI5cr20pB/TQ38EhxwICo/sT +6Q3kiEuE42F1Ye7R5B4CNsfx8Jzyz0L1T6a/+Ur2hnzH/qqtYQaSiOANL4H7GSrX +DJjYCHGk/s+TmiEz7G7VjcVIbsY0kuKCZ4Vg64kBIgQQAQIADAUCQxQwYgUDABJ1 +AAAKCRCXELibyletfHKJB/4tkiUBPhxW6mH69/V4GPIijGHDDVX8K9IKGmhSuFOc +X5xQHMWsiti1DTqDobFJdzbxau/djw5xzLt+Uq9iRHWwnkGtmcLAoXU+Y0oJ0pKE +rdFaiGSSX8UFGTJW7hgrdNiIOJ4QegcXIJ0sAzg/wIoX6QLYiQeai4K5ZpGh0lmR +64fBxQe69ZllVA6aJdxE/ZK5l9JfwC66qkINGqjTJznogZWxswmC2sBg6U43C4mi +0Etuc/DB+XiRGr4B389w1tbrGhZDgP6W6TMCp5tlTKQJWNVkh9TgeOmcdJeNKGOk +0NE0i3roiP7QT6NZUzYuGHGjy/o2AjTe10QTKj+CyVZMiQEiBBABAgAMBQJD0q3p +BQMAEnUAAAoJEJcQuJvKV618KKwH/i18Venc2AwgivtBhIIhyGHOhziUb16ncJZT +Zav3tIxBM0XGCpd0km1Kc7jNdsRDTfM0dJssst60glwOdsE+RoJPBxjz+HgstSkX +HcnycSteCX1YracyiUtfNOzpZkb3M3DZrLFAOP8OT0wgSOLTlriAYZIX0GdVMy4m +vaJtyghAOoFA3+Kfvvwr0cTQky20mzD4zXcAk045w2t6CnsdgSbnCfwbj/yvm/sl +YbKrNCATQGpMyi4ds87ghjLI6IygrRdzmJXGbEb81DpbROe9T/+PU41mP2WkuIPj +PAkIYC5kGOlWRBLj2qgbyFCvppVM/MXQyrMKEPptDhppDapEPlSJASIEEAECAAwF +AkP2QxYFAwASdQAACgkQlxC4m8pXrXw08Af/e3tLE6dgOy2aa0BHFD5OTv/17LNB +esP4sjWfBE9WaQe9m03biRgchGxc5Su/kbXSTNbnOgXg5xlvAkV7O5wFV2VKmtcW +SD6JoehGldtadlljNHDtu3b9XpH9+wq/hKDqYHQfemhLwEgKhwO9dNWDgGTTC8mu +MIy0tKajHqirmWrL74ocjXH1m+37VzRd7DHmRQdGFPodY1jeaeU082J6DU5ODizE +EsPo3b7BIHgdamdQvKlQy+1zr1H/ahTAIurfZaSptZH+X+kaKWlFI5DP/PU+W5Gu +RPjLXYsC54pFXDUJsRYeucgfvczXhHb9CMG8O2clas5laZ/6K7WOt0gttokBIgQQ +AQIADAUCRHVcbAUDABJ1AAAKCRCXELibyletfJhVB/4n6uCEePZtPg6kCLnenlZG +bqF4mJNdlcP9ZDx7EXUGeK8i6xrSdhNgXdkdmNj9wu3igbwDY/rcoWgTr0+wgd6g +daJzS3J8J4PWJo9wcgdUUJ3qpOr9HhdNG2AieTF9SSDq0S2u/4OtCw9qLrGadd4p +wuXeu/8BSW4cjmuq91Vzlj0KcyhkcKxD0v5AFDNBU1YX83eIYu3B6uceE7iN3DvQ +giP4hgCIbV89gG1nPc6j3RyGtCTygKitv10cE9krsNhq+o+rVFkkcnGSqfu+V5o2 +ka8ybwISrcO2UY6LPc8Xz4vYQThk3qLfN/SzWVG14j9ti3BapOiMgVuMMrMOM+6j +iQEiBBABAgAMBQJEhybKBQMAEnUAAAoJEJcQuJvKV618yugIAL/HKv36weHPy2Rz +XQK3IpyjwsLiCXV3305PVTvTHO6IG85gC79+2iXvE5nblLMp2eD8zlj4yYHsHkPG +OJpc9Fm69uGfrgIPiRnLtVZrdSL9kiwEP8BgB8Ca0SKXxd4dtynjAy3U42Rnqbmu +D1X45eDjHr9Hbr5qH7sLbkZAwjBTqAoMNBIaLnT/p6x6lePiEzDEPjUcw2XY12RC +6/Vk2SyfYqXkbV2OTbFCGePJtpKYXcvD6EjPaDwXlO0Hb22MQbhla3QhdezfsPTt +fhUWBa7Z12QSVxwVku1dxoxV9jTzvB5AL/B6WYat4yw99MjDS/62jKnOaKM4++ei +nLlErFGJASIEEAECAAwFAkSY84AFAwASdQAACgkQlxC4m8pXrXyHRAf/SgYcoOP1 +Bk7OeNDgblNxGFepyWJvHi+WQ76kXIgXMIxoKVD5SRK9SVZIL0tcTOL8qFhB5R1b +8JSTwbcqcYWXHVRv+j0jHyMOsDLtrZ0o5jZL+mdALaAS70CgL3350KlX2bMUKiZ0 +l9CEu6jPWaL/dRw0mOm3uao+lOEUDgR59O0nrtfWepU4QuK+XBi3I+DSDtWFlTKM +kmzwVirYJWWNRCsUzcnidvCecVB81Zg8M0+oUjgc86j7zEc3zW0aCbO4FAUsFS1M +HdX2jMQafSUqirOkMcO4NBvr7wlvKjn0PJbF1nldqaown/RZAdX4T29PHIdiAKXV +uggCReOoBDbfrYkBIgQQAQIADAUCRKq+dAUDABJ1AAAKCRCXELibyletfOvRB/9b +zdgaBfDGelPn7Qk7DGmcWz6RPneWpEe5SyysPYmcXFAQCv3hC3HX/fWzDAW3EniT +0G+7URMkBxoLcFmDfdWCCmgmeiiy3u0EIasakmICfwmPk5JGshJmJ2PkjZ28s/ce +9o6/R3gywSPwde1XM2bzW935qVn5ljID7YHmyC3anPmB2h7nD2exrs9R49v9zJlf +BKl/PLWWpWDct8bgOweqkS5uMitHUyiXkhv7XNXqrAX67sLc7lnfQBldcMgfIgxl +/4MyZHaacOJPpX3b6ahaqMa/DCkX2Jcnyx79O0LO4amoBMxKErIEfDQIR2DvMqxy +qqlxRdZdKe1iTkmkTlmOiQEiBBABAgAMBQJEu+ImBQMAEnUAAAoJEJcQuJvKV618 +hzMH/3EwCUp3K+Id7Oo01x1kM13dTm9jwDE+c2VyJg8NbNSeQhsAJ4RuV1X/lBGo +afec1iBRoK98SMM3PKUE0jT7+bJ2riiCDgv9WrbOiIAZwcdIs+QkoQValTmY/1FF +9ESWa+d5tXBH1zdCytgkmLclUEyDq47LBPYYn7DUur/7xVtH5g6tDSo3fCTGHuMG +683qp2aya1y4y1JyDRFKAtGY0JW8pbIkO1WgnZb75ByThiGtr/tHOUKkUk6IBfC/ +KcWKbX4JP89gFwIAW8Av/3O22HuHPXSslHh7wWPDWb+rXhP9IhaR4peiC/M6s9Zk +RnLlFlF6c3Qy4asCEdYBYomzdX+JASIEEAECAAwFAkTNB+UFAwASdQAACgkQlxC4 +m8pXrXzdYwgAxmcGZJn4KKKeoTrCcF//x3dzS/FQtu+0EPlfiwasPNyuOrBYsTAQ +qHPGHe5Qr/O7DhNiI4ZV5zlSG2+hOlFz2iw9uUQvqA7h6F6CmJJ97BB4bWxsWcce +S+7ZOHS31x0th9p/MsUy+knamI7MKq0UncD7mQoW3L+5c+D/poImbj/jMGP6i5r8 +fx4pmH1lPQXxZOnsOdqHMm7TqEQ647v3kqfUmOuqZ9IOeqM7DjBM1rIBLMaOaTHU +RERQhQ99WsX8kOjJxAOLMTXNiutMrXQQAuNIPQcE/zjsvRJYbq51UKHjHnyy1E4P +k+YeTw5TF9rFR2odelFdLzXuAS97fTkal4kBIgQQAQIADAUCRN7TcAUDABJ1AAAK +CRCXELibyletfAF2B/41OOMB8zZRCuzEsXUvZogJT5bnY3l99feXw49Y4LTBkL8y +lxYD/7biRZXwX0YOC0+ahE1H4XVVvNKLcO0ppUqkXAGE5Bq8guIeTviRnGXt+0n0 +MEM6XrWHfg9riFCZkALyaG6fdj6DFORDaf3t+e8Frm2BbS/cYrut7d5cWqhtkZVp +uASFL/G9zx4L8ii8Ww+l9tCQcz6BXV2XDoqR0hJI3iAvZ7m96reBsYWm3V/2dTRt +H8lTjY6XcZ5jPbvZPAKc+eJmsPdaCei7AxMLRBcdygxQjs0rU1cfJtjfyOAl4Td3 +Wcunq7yo4t9kYo6pc+6EyvdEmmKIF2HO2MGRyO0fiQEiBBABAgAMBQJE7/qEBQMA +EnUAAAoJEJcQuJvKV6180wsIALc4mplDBdguJYVGNaN4lYFSx+slwZCxZ47lgbRi +VjzpoIm/UfFOU1apko5PaxyLdSJtN8vLdgXTkbfpBnvuHAEaNhbhYigLgKR8Aeja ++J0P3Vm4VIV9aYKCwazGiTlg3qVQi9CjAalFy/u6AfjtvAo9dho/sv2l74ev2T2N +wKVKSAmL/6Z4nwU6uDnF07zleYnE4x/sDE6UqI9YX4kT6qmgnLbSxS1APlSs/rBp +gqKI/idBPbzVO6mIu4tjBb4PAzIwrHo/Oaage3EOaI/Q4HVQpg/x7Bwk88p+45K1 +7qfhmQ3Rnd7PWZ/bU56DLjKBYoTPxFLwIlMfRnEw7kMczoeJASIEEAECAAwFAkUB +xQoFAwASdQAACgkQlxC4m8pXrXwOTggAuK7HhEMxLUB/vHJaH4cQsJw1w6S9lQUh +trbaMrgLM2mP+2W1FDyr1dB4XR6vxco2pIKY6k7c5xox4f1KZQ80M9kb2e4CZ3Aw +grmYVDuyJ1qIzV2AAkbCgrwZOWSs0QdJnB1Y2EUOiQIrtlbiAocdf+jfNPVkyaFt +LM1ig6IXc2m44T1T3d3P2pCk2HYSLRMxlwDH+wW+Q65ic3ZFomFhpcmt93LJaQ2R +z5J3RKvniy7IfnCDHuYJnex8srbNyrG5aM0alTTzf9lxME+cN5ZjNaQJrLbrFG3d +JELKDX566/WCp9eAhgGKWR6brWM6qEAFrmVtY1rOnoUukUsd6WVwxokBIgQQAQIA +DAUCRROQ9QUDABJ1AAAKCRCXELibyletfMZIB/9qU5IG6guM9ksWywkeiYi7B8EV +EMbrBBWEXmogbK+cvCy1aFeHlpMJ9tePGLgnhj5CMGKXKLTjde5WZ3ItETCaSzxT +p2tXwwgrer1uYvRmgRyorrcwzckS424ffnEn8ZsuwkbfAiylFLGnyC0+AZZaifLB ++e+Azv1Uov/F3e5Ifyhi5WekZl1vV/OhJ+AP05fwddO66Uhx/+M9H863CcoBft+3 +PEy47632pKXzifWqB74F67VbEtFcHapwOU8iFTaXriQ1mmrFWsS30WzhMsPidpdh +YsW9TyCtEPHW5qaxxS50heaW6v4WzHz+JaFInVJTbBEZJEQRHymSrPVXoqcviQEi +BBABAgAMBQJFIhn2BQMAEnUAAAoJEJcQuJvKV618nREIAMUYVlUpv2o1tcAIbO1m +3m0xd40XeEG6juJneYS8YjQr5d1RBgLJi9RI59A2AkQWy3KrML2DGf9pinGcJ23Q +GDSZkYvE2U0vbrZi2iVWMGz4EgXND8ahA600aXIXXn1/uFoiDFWQs4bJXcrTTbKa +Ixyu/lDbaSXTxEwYgMGuZOP9HH9vcqnL+QBBokepLGUFcz7Wc+5huPxgCdV2bdqf +N2xv59rsp1hLb6wO9V6AFMjzWDBMNrNya0H2uVt1cZhGUtEEMgYk05xzh7LCk7Te +83b9D5Zi4ppPPvI0pI3grEF5xPFXw5Gh3Rv8/MRVRKJarXzYY0CQu0GOEEBHgHzF +TNqJASIEEAECAAwFAkU0CZMFAwASdQAACgkQlxC4m8pXrXx/Igf+PIQ3MmtQ00Bx +PfxolEaipmwaaIxDt3z9QZiVpt/JeXGLikWy656+VHF6ieMpZUEI1IDfUTXZ6ZAQ +6Ni9/a1PMvvh9o50KL3kjVrGAN8GWS1vWoohVp1EGHJDgFrLY8ovg9nteV0usSOh +XTPKlkouOppUtPOpsM236p95FValQwUFlGngEk7oUmSWWRHzpsS4RFhhZOtvlWIM +6oYABQUkGr0edOK/SRWSlx7hyZti49SbG8ygPmw0sQNKIEARfy57izEcr+2zkpnV +If9dg99Y5qru/xgssbrCw17JCYY1qJg+7Cw1+zc2zZH6oy8u1vT1yM92ZfNVpG/x +idTUpDJE6IkBIgQQAQIADAUCRUXMmgUDABJ1AAAKCRCXELibyletfAQ0B/9fmA/h +a/cS9zQyDVI/QYF3a+MzobZxu6rqSX9K2Yjnwr8S7BcgZKcNCWrufYuhXHEAOINo +1LCIqW8uQvQ17H8c1eGiEVbU+UHIPkPXW5wSUWWfQtaA3KlNsTYSfwHtN0cSSeUa +tdsp7+aDDvRHId9jqu9jhvsjIWs4O0XOrrW6ALvX3Qd2HI6PWeSpkgjVduedTXF2 +Spjkm3siHnCwf3WiV5SpKCMkR52AhZkaxNGsFHR+Gs8cAppDjHNO4M63jAeCeHTt +wnX2wSD807TNbihYH3h1dgUNnZG1hFAWTH0yvJ2FBDwzoQ4aBSZ7c9Wyv7qSLfe1 +YeH6/3rVAPFbK4/PiQEiBBABAgAMBQJFVwasBQMAEnUAAAoJEJcQuJvKV618URwH +/3CZJY08C2AAZIzN1xepDSR3O2kWcStJW+hP/V90JEb3BtO696R3M5AnFpKkwS9j +QjztFaMCs3onDhPz1hW1R/rQw+De80Frl6d43XpBkhqCA1jc3vN8Evw9iqvizMYY +g9U53NBt2l7RyadWcxlWzobtR6rY+zo+eXvj/Ya7JOQh4UgVsSqxWIxk7yFMLy3N +OiKpcLkzj1YvJMJy2vWqN7YcEScqLfcw5SmJTJrYHryYRr09fgS3C+ePMCRtWIAq +0MQ/bnAhnhAid7GIF60VuYq0+qo0HuO/Wr8OuBMD+4RCRmsgFr/JvgQf/B7xWQcD +9kyr2fKx933zuJ9kdxkChsWJASIEEAECAAwFAkVo1cAFAwASdQAACgkQlxC4m8pX +rXw6IQgAhqYFM3CYw7RI7SQXgrlWrQDZf6GLyNU1ad6vmyU2zzLy7308tEiM1wMC +gwExbP3D2Ivxbl828Cn2dNtKSHDk88LxyaU9xxy3jzAzmD2rQZK2bDI7q6fZasAW +0iDKVARTj500T5T3xrNuBM+MVdthb1CU9E3Gg03QaieBd0mVqOCGy0Htj80mdvTD +1YtGWz5QehYBJ5SS+FYJmcGiPQNRRVRl7Z7xi5qcV7ElI/hp+Ua06TV+oUvEbZI7 +yZGw6L5b00nZhiMtx78xi5wYcXL2XZCP8r0iRBt0c+PNPaqc88epuX6267mBjtyO +K5dRjMAGJdQWWevBCNh6Rv2UiIub1YkBIgQQAQIADAUCRXqhhQUDABJ1AAAKCRCX +ELibyletfO6KCACltzZqfwig5zW/S/AOB17g9gYUMIzF690qrIVl5nL/G+11Wrhn +ID6R0BmiUzE4NSaclx+2jFHumMRCDAxoyzlMe+LlM2Hjv8HhwPP2L17QH5QE1tmX +SByFkajDLLHNeOabzKsDlW0HFu+ykdcbDb7PqDLJgxIy18Ievdbjy3dTOaX8K09F +i+lW4mDkcvhWDs+ecNKKsfl2SPfuhFLKzbQ+NeHvg7b+1jSWYBYhhExFajYUzg4P +zvnfX5erAZZ4WNOYwDkZEdhMtyy55goCxPU/CTznxOi0lXoXdW+GMqVQ4DTqriwh +mYznofb68OHDWuMpQu5EE/P+WJ0WaREkl634iQIcBBMBAgAGBQJBwt2TAAoJEAgU +GcMLQ3qJai0QALRNjm9m2OaKjOO3/Fx673tP4w4xFTlxh7qFwAGMDre9S3Q7yZR0 +TGftWL2EuPYfYfjQWGnpKWS9m6VZ5gK/PSg70pv5L8HMomv3L1q/hz530yKn5fip +M1x5xtiiRhZuIGmtdcwgh3Bm2oziWCAictnoXYHlfNyPe4pL9jrca8lezuQ5MTjI +iVlFIKJUNr0vFCsLqhTkipdXVUkARQoo7JrJMElYr/lkw/nfMVinFcM2ys8MsGvS +YVx2RqHXHyHqAfAedxn8lvI52aZhlZH1SgouXzClE8klcZX9ZRIe9ZjlEHGpyOTH +XXrGF3KTOyWoI2ZAicf0ky/0oxoUrgnGnG+JP692OJWcsv6ltsi/5zkyLJYD9pUE +caucerOyW4Yf9Qf6ys8JKxcsS0oi5ekvG6L1BzLkCJGPSMGnPuqARmSWgQko1uf7 +y6bSMhkA8AJK88Us+wc7DHi5ixwmJG58AJ/vzpy0xzgtZNctZnOTM1+oAtAyJ5Bv +4b6+g6synZaYEfBRY9oscUlVf5wVQtBYY9MAZzujgi9D8UStzFGQxRnDlHkxqTd3 +RXlWSYQOx48vm+TDikF2dxugAkc84b3ZGNyYc4zSs4b9igCtsi0BEsZwwsB80h4H +M6dT8L8mQM7DSMEspYNKaWwCLnYCizyB4zjWaYKT4ZV8p+ACYQeyALJWiQIcBBMB +AgAGBQJBwt2VAAoJEFA6oBJjVJ+OU6wQAL4ugeC04RVF44PMPQ+UWi1W/ODIYMer +3hrDHtZSBFdcs7/LZWKNo9hHeljrN4BwAuE78Q9YBQO482V/ukPfcHh8YDmxvXgR +PJWNFBg/IThMLrhiAGLooeHmpHYPuyb/bOiEy4z4rK6nqMyTiLtVHfkKsBQrWGrC +c69JAAyU1yJyU21aSsWFWgSKI7nV2DySZOPbZNkwOcTfHfc3rpM9MDwmUyBj1aNF +9dNUI+9cTInZww2NBctFdavzMYMD4oJqWbGgJKSTSIrgt2rfvSv+6NZ5/pcjRfT4 +kLQDWhT5cqhJQWfnYsJg6dIKw+1A9s9kGjv5gtd7wtoOScfnSQgL/WO+AxTXfqI/ +2xdbCsI0z0T/q9p5dTLHSDns4rpUw6Dsl6fiMe1Hs+tmkBUJpxE+haoDGzQfwEZY +NZZAMEp7xe9i6HVE4//mT3mcCzdWq/uAZdriDqDRi+TVgW/Ztuizcxy8HAyRYrvD +tBXuByBNXXmIFQQKVO6s9X2EtFycNKI8kInnnCrMjlhdOG8UONz8N4vk4rX5rZuP +rjoaYuY3mGvPOBTy6T3hJhM4f9FA4Fy3kj4W/h32sARRkYMTQ6qWrSpYy7BcC/oD +njuNrVOI5qG26CIYg9HuARCVL0Vcrg3Id6PUJoH6Sm4i3DClELRa2hGtXIY20dej +/m/PVkdirnaQtClBbnRob255IEJheHRlciA8YW50aG9ueUBpbnRlcmxpbmsuY29t +LmF1PohFBBMRAgAGBQJCcwzyAAoJEK9ztgipQFCvRLQAlRG4i4KU7JA/ppHK2kNm +KaxqAZ0An1TiNOCpKXo/QYJfwFDvm2AgFs6HiEYEEBECAAYFAkJyIDsACgkQ0/mV +1Xdq/hIPHACfcgnB7KEwNrDyQWaqD9QcnoYaqV0AoIMR3mXosTFRzSyRWQ/1s68U +lzWFiEYEEBECAAYFAkKUrScACgkQi9gubzC5S1z/6ACgg8HmhZ2aTU7gKMSLIQK2 +WpgDLb8An2Y38bGeis13eli0lDcxoQPW1mExiEYEEBECAAYFAkaoinQACgkQlSz6 +WvcYsDKR3wCeLBe22vy2NUisH9oaudBq4+q43HEAn3pdE+91nahEkenQXsd84FBw +xqRWiEYEEBECAAYFAkhnIQwACgkQlypuBSUcZe/WaACfdfNVoV7mrqftp0QT6kmC +EK19LMwAn0Xp2T+cekC4/QwMBOhfoRyIRYiFiEYEEhECAAYFAkHC7lQACgkQ3+27 +IiW81b9GTACcDG5ACFaLupZFaEYQR5RBxoyOBdgAn0Sx5NHhLwkze8UxmT2XCuCT +PwoaiEYEEhECAAYFAkHC8B8ACgkQIexP3IStZ2y+XgCgl3E8rm9hMEANTjq+zbvn +g1jsPZ0AoI+ToWrIgdf90W37xfFlZLUnpF1wiEYEEhECAAYFAkHC+JkACgkQK8hA +FiBoeJU96wCeL6Oumm8jAm96QG8W0JUE6PO8dqEAoM7lIYPXMh4QyPV07pS0AhPN +r+pHiEYEEhECAAYFAkHcbrUACgkQ8+hUANcKr/lgjACgo5mpyhLV1t7gxvvUjTQn +hawLod0AoKT2Z+ITNFrbTJXk0RLv77rElD1iiEYEEhECAAYFAkHjuRkACgkQjmLn +92QBGoteFQCfbLHyP1JgUSt1pVBVq7xZ0m2p3IkAoJVJWXdLS0J5AzLh4Qg8THYJ +wfW9iEYEEhECAAYFAkH6sCoACgkQ7Jk9Y2X9ze6aCQCgqqXFqMtpfFbvHSWBLluc +c6L5RhgAn1tfn6jdYHZd3MjL+0yNKNIUI/bCiEYEExECAAYFAj9xIzAACgkQrGis +BEHG6TDEAgCePKSgw4zUVBz569wrSBSKcyYASWIAnjBlVxr3fzfF+NCpkzciK+us +AmbZiEYEExECAAYFAkAnN1wACgkQAfqZj7rGN0osTgCfdZb6TmKb2Yqx1RMO4SIB +rpsAgCgAn2K/TJM0vAg0v/Gw+Mn+RvvNIbL6iEYEExECAAYFAkGtiQcACgkQq3pg +vCz4ZCdXlACePgmkCXT4IYOgV3FZWbQv6Pd5nJAAniMsp5hl8TkG6KnxYwQbfZk6 +cYMwiEYEExECAAYFAkGvAK8ACgkQ+i3LsNJvIln3zQCeJLY7gFhhLlNh9MlLRaxd +rNMMVGYAnjai6Flnfy2G6A2brt61bf4LFQ7uiEYEExECAAYFAkGvvm0ACgkQ0OZ+ +tAQU6+PUjQCfalYKuTKTk7hMIXXNLe02j7AKflUAn14UoM5XzbYo2WsoYTBxavmw +vNjHiEYEExECAAYFAkGyIRYACgkQGvGiCkzACFFnOgCfSmvi/NbwPDt5b/wdZG6c +y6PpxLYAoL87bacrg6t+fuy9nhLRmQlLrax9iEYEExECAAYFAkG0do8ACgkQvtLr +/tL+0yE0TACeJqDhdYBDO8+6BOmh1B1Rh4RYML8AnRrlWb1lCtmt1okujCQfdWTR +jq4GiEYEExECAAYFAkG7osAACgkQNFDtUT/MKpCtywCgjgyYEmqnAmzg5dhppQ4H +jCWpZk8AoNBvavkBm8DPqZlV3PwBPHZfOeKiiEYEExECAAYFAkHCj7wACgkQoWMM +j3Tgt2aycwCfS3poVSeWarfPbZ+AGDTZmP6rtBUAnRcmbVR5ICXH50Ti1xgKt2Ff +JZS0iEYEExECAAYFAkHCoXoACgkQkVdEXeem149zdgCfc0wlTw3aVj5F+YG5ocJ4 +jN7N8KoAnj8UfciUCpWqcgWeArxc2yr9IOXOiEYEExECAAYFAkHC1twACgkQZEH9 +AkgfRL0P2ACeK4gCAPt3UyTSJyR88y9NyXqqgRMAn2MTbJtPKj2AUw6j4wvfxvJ8 +wKJQiEYEExECAAYFAkHC3YMACgkQhCzbekR3nhhV6QCfSLZDKo899lCEb4j2M1AQ +zoabjpkAoJ8lrJxyNHN1bCfIycuizytLMYvDiEYEExECAAYFAkHIE+cACgkQAa+T +2ZHPo01hhACcDsy5nn3ylm+wMPdMG7Sv3ChDlUYAn1I+sGLqkJET/5TqIGI6404G +6wpuiEYEExECAAYFAkHIWDQACgkQ9t0zAhD6TNG3tQCeLogMWNKflimQVUuse7eR +zYicG7AAn2LDCozKo+aJCXLmiQJH3D1MITu/iEYEExECAAYFAkHrRJkACgkQic1L +IWB1WeZ3+QCeORpOrIfm95X9+UfD0np6KPaku3UAn3/sgHq/LNk+q0fOQGNG0unT +zH0niEYEExECAAYFAkHrVzAACgkQ1U6uS8mYcLFtqQCfU1PudGowBiXNlrSvFc01 +9C4+bUoAoLlRLrym8BxwSNj5fUR7T8t4uvmXiEYEExECAAYFAkJNqTEACgkQzN/k +mwoKySf4GwCeLMKr4e93Ybqlu1vQ4r2AJgYr18cAniFRzdZhYKs9JbKDxbcyolC4 +r5ayiEYEExECAAYFAkJyNEkACgkQpQbm1N1NUIjiEwCeNRgrA6pVknguTWxmOoSF +Oxgv0iAAoPCDtZ/d/0njhY+bt1oqgHLYtP+diEYEExECAAYFAkJy4ZMACgkQd/4g +/qpqtcv3xwCggvrd7cWVvd+YhQ3wIzynMf7L84YAoLRlCRWQiIvt7F7xAw+FW2H+ +WRiWiEYEExECAAYFAkJzKZUACgkQ4ZLAVDsbsuuDmQCfWSEwTM+4VSQnicVKjMyA +yzs3SJ4AoIAbG+8dNdlnq3NC8tQL93Wo7mysiEYEExECAAYFAkJzV98ACgkQoDV+ +ZULiweVnQwCgpMlB6fuuP4YJ6WkGgVoNcbaRuBYAoJVHJaF4xGiQJa1P9n6fUjnV +FJcbiEYEExECAAYFAkJ1X34ACgkQArxCt0PiXR53XgCdHAb1A9XkH6Yw3kDTly1O +IqdmanEAoJRi/S0kr1NenQSTQzt+6krTD1UZiEYEExECAAYFAkJ1n9AACgkQu8b/ +uaAhL+ShOwCgjQ4qk3Ikf+ACr3mA2Izvvn/LQ4MAnRXzOTZ4nGByCQBhqjR7/aeZ +Ru9IiEYEExECAAYFAkJ1yl8ACgkQvjztR8bOoMl6ewCgkXuVDIA2erqH+qUMaGd/ +wQMjjUYAoMd3pLL8vwnhT8vAnFq9O9XbRWOziEYEExECAAYFAkJ2REcACgkQ/qs2 +NkWy11vouwCgjJMIrwjZHnralf+r98nWjjlZIzUAn0TJF4u6PmDkQf5zwa7hXTmC +607FiEYEExECAAYFAkJ2RhkACgkQRsWY28vsX4AXRQCfVnfsIB8k+JV+c12pbYZE +GSzoehYAn3Z/hlKqoSvfnTOX3sbHwhT5QIrPiEYEExECAAYFAkJ3I1cACgkQDecn +bV4Fd/JDAwCdElXQSzSsxVKnw4eT/l0CvRdlCuEAoMgd7T3n4MUlq84qEKqE5vfh +YsUaiEYEExECAAYFAkJ3wxUACgkQSsOT+6LQaTb7AACgktFj8Tz+Z7x0nd3qGM9I +h5nAyDEAoIeVWQeirGs9Lv5xU71pCHMx/NatiEYEExECAAYFAkJ40OEACgkQcJo/ +YDt+FuGAegCaA4MCT32OHKzzqj0E/OG1uKWoduIAoI/MwGYDWSDn6UZrNfLrjT+N +oMdbiEYEExECAAYFAkJ5/g8ACgkQb67zLlCCcv4ixACdGS3Z6AT152VBpMCsGRc2 +zkH3JtMAoL7VWtVvkxgpgVhiTCkJp8ehEh3TiEYEExECAAYFAkJ6TDUACgkQH9eQ +w/Gi3tU7XgCg3QeB3p7dlXH10J66IdlXDo4INTcAn3GLWMC1nXt+QcvrqBNjGliI +6uvtiEYEExECAAYFAkJ6XYsACgkQem/rb/9SwVBVJQCaA8gA39ZUUknjv4U8lOcz +4cbgEdwAniRvheJOQM7tsBctXmiSWIgsOMC5iEYEExECAAYFAkJ60gsACgkQBlHl +JnS3xyoRoQCaAqfHCsKb73cB5jt+gF+aOpd8FeIAoKDfFaFd1zs0PqxFLy/XrFTM +oVmciEYEExECAAYFAkJ+y3sACgkQPGPKP6Cz6ItmawCfc4mpyvt4tsXuyKOAJaGA +HxWs+ZEAmwTHVsefNSfR6qXbqj3QGk2ociWeiEYEExECAAYFAkJ/D28ACgkQuJQO +bal7aaADSwCfQi09VnQs/QEoTxYYviM2uNiuZ4UAn31P109U+Cmgm7+LZhVdSTp4 +x8OhiEYEExECAAYFAkKCVfIACgkQE91OGC5E08r+xwCg6AMfnBDXjTjbmKUh2a9E +4A+uVJwAni4IYWktaXucMSfJzwZSAuYsyCuFiEYEExECAAYFAkLe5nUACgkQDCFC +cmAm26bYNQCfTroVxQlvtIkEwpqy5s/NwckzTWEAoKNHM6vMHJADGRV46yH9vm6P +FtBwiEYEExECAAYFAkNDT/UACgkQj2gB2J43n8bpsgCgoBa3t84iEv4F8ROpql9r +24HGHYEAni6JOdxJRs17eubox7z80/40XcmDiEkEExECAAkFAkJzHSICBwAACgkQ +uJQObal7aaDZ0wCfZwsZ7JxXX96h1++0kIJSxHl0ZmQAn2IFyGIIhn8WOs4ySn3i +SH3jHtPWiFkEExECABkFAj9xFwEECwcDAgMVAgMDFgIBAh4BAheAAAoJEA7dxfJq +RcgWgfQAn1dZcYbbpK8httmneSbINwTekOg/AJ9Q8OPSI+w35Nc/tmfz3WZ7w/Bx +u4hcBBMRAgAcBQI/cSFOAhsDBAsHAwIDFQIDAxYCAQIeAQIXgAAKCRAO3cXyakXI +FjWjAJ9bZRH0z0WMKm3TFl0e2dXLDh4t3gCgs0b+3h/pa0YoiMG8wSu1i/hp/2SI +XgQQEQgABgUCS9xJFAAKCRD67xKTbdPj7AFnAQC6zS8BdX63+M9Ym1L5Z9SIKZTJ +rJCqxaJ7/HWzTLOrdQD/VeMzlDwd+svTmOTum5rEdzZ+g1DuGKyzCtmNtX685zWI +YQQTEQIAGQUCP3EXAQQLBwMCAxUCAwMWAgECHgECF4AAEgkQDt3F8mpFyBYHZUdQ +RwABAYH0AJ9XWXGG26SvIbbZp3kmyDcE3pDoPwCfUPDj0iPsN+TXP7Zn891me8Pw +cbuIZAQTEQIAHAUCP3EhTgIbAwQLBwMCAxUCAwMWAgECHgECF4AAEgkQDt3F8mpF +yBYHZUdQRwABATWjAJ9bZRH0z0WMKm3TFl0e2dXLDh4t3gCgs0b+3h/pa0YoiMG8 +wSu1i/hp/2SInAQTAQIABgUCQk2qMAAKCRCr/we0RvMhLX2yBACzDuVZhRcO3LKs +MnSCBiyW4nvoychxSicL+o/0Pd9FNk11ruN2naPkHIbX9L84PvRxc5k8RTy4l380 +P9Alm3sHgioYQJ+dhwPyqvRXBdgccQEyv4Ke8wJN1QhNLGo6s+DHQgJK9NPHaQ+e +Ep/hqSc5l1YZSIf4PYe1KzOYSRA+VIkBIgQQAQIADAUCQe4gfAUDABJ1AAAKCRCX +ELibyletfNXMB/9AWclKenRM1HZn3wModzKgHIqf2oHMZsvSuUK9jtA9IWz/Gve+ +k8bmmkmBzLIrg+Zq7IPaYMZ2YUiVF9Ww/blT5rzk4lkOvodil/ukCaP7gAc2pHgg +dZj/8uLwVqNYIk9w0PQoKYA9qtHZ8zZTVtVTW11xm+8nWPfZpUHUw/x/zclokH2Y +gS6JXcBEGHpGZWomJYl9IiH22AQLcwHcSWFZFCsCekzgihsGgE89J+vmUObYFRq4 +paPmTzlgts/W/6bFpXfHFtLUBNSC3rKxzW6lxnSlpCQh2LzXBFC1GrCruWhh4JCq +9CD+0251hXPLbPmyFwevYbvAgceupdd7gkFpiQEiBBABAgAMBQJB/9/eBQMAEnUA +AAoJEJcQuJvKV6181LAH/i69+PZsvyh8EhA+BWO2x5rxp2VV983NtVJmdfZGDnmP +B/e5/T/rVR3yVsBlE8xXesGdEQsacxkVGXh+u6W174E48YkP9rjUO9qvc2jhdpC1 +wDXc0dkWcu5CX+q2LXNI02Vjtm3V/pCV8kcUpPKBZJ370yCZBY2DXK+fEoIvHQGI +d1PmZfYR7Vo7zb/F3hAvHYZVhcGmnjhbm1g8OFGZIwugVlUidIZU95do5oAVxeu7 +kvHkJm3DJbMhhvVenoEmeV6TRMAHtK3oH4G3GPxSbKdxoiawpBkG+P/xN+Xx55IY +q/RC2TRzWYQW/If+Dyh8RGLe1pumJTDMm0Min59Qa4mJASIEEAECAAwFAkIRBBYF +AwASdQAACgkQlxC4m8pXrXzCegf/cTkBtAvtcpUJHmXM0rutBk3SKSCYJERHvbNl +T5G3B0SJD9Fw6k6IFNnOIqC+m9Tt7m0WQNaKF1vICP9fL1wrMg+Zm83nHUO6JXEx +SRDVC68eR8TGALjuzz+52XNYIUUQIAbixHLUVQqukogdN5zScuIqUuRJ7MvqFcsc +jCkZJbl2M2boAKhz2Wv1lRMJlS8QNGxPgRoH5MIRrWzwDTkCvOe8kFMP/yEnUahR +EGVqsvdvx/XAeZPQNihBztav75gJspa3yoB5KJhBELZHa3IvcwhKhAvL+R0awNMY +qC1gIN5LAoKVqEgeDb/jjbvwwvNVq4tT9E3xr0jmf2OaqkW2KIkBIgQQAQIADAUC +QhcK1AUDABJ1AAAKCRCXELibyletfNCTCADAgs/acVth8yoIRPjbZeieZ/C0frOa +KgiNnuE3B/i1ENH/p6bChL7sIswyAp4/L+6z68yd7XjB4nPlvYDlmmHF833cuzmw +T/BqrPy9jDOW4hnnLWlhA01WW8X/dxd0HGEd/Z6+enKB2imd9bx8/PIz6KPK1cXr +UpM+7GU4G05Cvz8hRnSKsXHBoUFdlDRMKeyt0yNr5mcO0GMiwRmwLYh2H7dAsxYC +cS5FFdjWhE6S8uJOqPwaBaYKHogKhgT8vEUnMEF3qORm00IXhD8FOJdJyElCsi1A +Hqs+dlb+OvWB/gcGzdWPYYrLGfM2eieWoVzVnA0SdApuV7Cpdpd0RKjKiQEiBBAB +AgAMBQJCKX1GBQMAEnUAAAoJEJcQuJvKV618iRYIAJzCuSq4Y2wp8JJ1ueMWh9Kz +7YpOsUPdqZfJHf8BE9TyyB8zxxZ1yvORKWG1imFun5NgaihoB8dYNOUXFM1y0AJi +D8N3mkquuF70oZRMPPQInhl6p5WibYPFyjO1TGy6FHP+Dhkw6rRdUWnJeL5qm5Gl +NJFGjmUW8liBkM3zrXJz54f5DU1dHoDCA93B7AdBir3sIwiyumHNhHUKT/LlSsVR +xtG5jsc3itRJckjVvT9g13mHU0lc3Hxf3QG9ykx0uhT8MIQ/9l7zNiRHjybeqg1P +jk+dMilE2oqbxmB1k/6kl+oZYAk5zEm1v+9FZPenZI5TlGiJzbPzBeEJAVWis/6J +ASIEEAECAAwFAkI9MDoFAwASdQAACgkQlxC4m8pXrXyvhgf/QK8CMVwlfJnPSKQV +wcMzrG0nYtL3KIEnEm1LQET5lNX+SDwSLofB0nEiUAJ9x/Wa80nWwZNsc90LXs2b +C6DloPh1NH+iKmo+Y3Mnc4FTRuCu/dDkomG4T81+DMtLj3Cug77SJSp7u46SSgDQ +M9GFWeQGXR4XoK+bBuvYae1qJ0P8U6kxoUpfAYSGi7OSKVJkji7jfOyfhMCjvzJz +UeTvsQBgkI7CkyxFORjZsLN49muC1nqGcVEVmnjJ5L6eotj2MykppKQOtGeBKeH9 +P/1u8nIP7UZ6gsUQMQkj/i9gCyqCLG5q8qhUd8YfeJGMrCi2G/IMI98gj+7ZMKNi +3YgmXYkBIgQQAQIADAUCQk+lZwUDABJ1AAAKCRCXELibyletfNpnCADFi/j9yyQ1 +uEJzNKdCixDcuEmVUV5Vw/m195g/s7cUyRPyqXWNVndmTbBLzVOnk47pAUAv2JCW +UroQgLukg27ZmLP2o2AStsXt1/VkmUComKBc9eJkvvG1/MxpFwTKZew+TeTXYb1q +IBClBgiz6o0M6mPrOtHxgqBUaoRLMID1Ue6pcO2M60It3rvp2pYNE2WqGCdIGTPJ +w2Gsy9/sOdVBgepA57FO4NcMBDoXzAPxs1Ux/ZJHumcX9knntYMdLoVtvz79LyzH ++4Pl5tfy9jABQyvjRS/gZksPxTUdiPJMbSOpD/0GiWIOMj6ZCL7jHL/mAe5tJmmH +yW/7WJKPkam4iQEiBBABAgAMBQJCYhUFBQMAEnUAAAoJEJcQuJvKV618zDQH/3LH +Ku+esklwzvb9b1eiqi7Gz9dfAjRNRf4H/SZbWMSdhdZPo3+ikYXE1pzeUWv/6Fo2 +v0kPsV35srwM56viKWMiUJB40Quwjv+49LNrRN9DYf3L3b08F0QtxWL9VMi2MPys +H6h99zwweCu1uZIAbq+IIklY0i9ErxOKwXJDpBqS2bin4Xa8cGAe/XAofwDJgWCw +TGH+c9UL6KvHdZjLXjtFH+avjWjkwjzGGYXMyt5lRHL+3EomXInUVGLeiz2erN0C +RabfRnPXkt8kPDQG0eET63wki/64ra+3oTirx54XlZ3RaDH1SFumk8/sSfyAyoHN +FS52OV/kmRbY34BCbm+JASIEEAECAAwFAkJivhcFAwASdQAACgkQlxC4m8pXrXyS ++AgAr4mfOWZk8ZQFq5cBgwodJO/SJTtSCbvPHNkr3SW/LTe81PBZZNF/NALtKvpA +CwaXnxX/ivT9kbGSLZd8ZhNd5F4+a+QwqhlEdmbVPAlWorCLNcfgDcwbFIQ4gLep +8NuO1KEpk253lA43A2iJ378chmcUdHs67gn8cvhHZJslrlx7VG5jefSWpOwNtMjM +ligqJ+dAe9VxPGMh36bYuiDYaxExMttUznJD0G79CNEZawKhf4d5hpafJRjLcfjD +BbDw4mmE2qj2CooOQ8Mj0Iw8a72m/4q/QdSM6AJu7qJe3mbW7/X73GMZJpYokpKN +75Vm94Wck5P5FhHz+6RB+sZYMokBIgQQAQIADAUCQmOCyQUDABJ1AAAKCRCXELib +yletfO2ZCACV7b/kjHuXKpDbiXfp06KrBAH+BoPdEvJKxDAUMW7Znw2daWE/FSRN +VvAw8362RXQdPNafiWdU2MvUWZ7SNtGrsiRTAaKoTQq1/8GZa5VSzgAN9nUCiM0a +FQfu5a0UBTOfWFovH+D7pngNI7wpSmdNoXBPs7Rona+BPRs83BKskx4EJj1jQ9r3 +jT9BKBvRldqpWJXlVpDradqJS2OAnzduMjQM5GXhAqHW7VEsvT20uo75uwPMfSKg +9eC+YQTUTVNNV6M66g0hEHMiltHTuR9MSwqce2yp38PsWwq+QBdciFYO3RuKK7FK +xagjdFECO0sMaQDa4Ybj7vILBEFHW9T7iQEiBBABAgAMBQJCdTFFBQMAEnUAAAoJ +EJcQuJvKV618uVIH/jsFFQ45+4aH67EjAT3obWQBsWB+72CLnuay1C7k3I+BeOi3 +8opAMn1vqAWj9AYT252x0UzFV83jdpL8nKpw6wb1mbAZd2DtuEhtpSUp67ygvCb6 +VCxDeGGmiJZcDQBMDN+5XG71t+98MVfBpi3r8zJv31Ne83SVVL4GO9A+cSKANGxu +o03q8ZD1vR64c6+YCNed3TaGQS6+nwyFi5rVpWIopugOg+gh0rShk/KlN4lE32XY +U25SCXiRmTYvUDlKc9ww7+Y2rRSmEd94EJbsnHXRRyB4h6/RYezoPeynv5tO9E9M +gS2+SqJuERedL2LCCirxqKuqaL+mx4dXmy0cpyqJASIEEAECAAwFAkKHAjgFAwAS +dQAACgkQlxC4m8pXrXzG7wgAqSioBUcrn7GPc4Kp00JPuqAbx4+AhT/Iqtg40CZk +hCJ0pl0nd9Fft1VVwe5NbndIhha43kH84yrmte53J/a1nH35BFYhE2KdVFDr2qlN +HpIZTe3TDUWNC7JQeuvY94kHTv+9XKLTn5/ZCZ0YddUyj46tw1lChZhZF2Oqg/sX +u4ZKp5yISYOw2+5DbZCNX8T3jJ+4kc4A91pe5IHpt4e5SfJFbMvdUR3H77mZnZcR +H0wD6hLUE8B94MRH8xs8hpOVz4OhoXsUxPryD4Xb6VObiM1mMtVCe/+Z2MKOcswp +18AmY1dAtTtVPDdGWey2omrNBEFihBvQiNvyGVKW7H6whYkBIgQQAQIADAUCQomm +IgUDABJ1AAAKCRCXELibyletfJXyB/9c5LmjN8Qf0iseC7zXYla9qNIvK0USVsTg +O9LhnLRDjg/OW3pXoZDt9bTO/42mYG+j+WuUKpbn3r3ePXHik7a3Bu7YgQVnfAj3 +2o26sTuiagv8nfBj5w3/lyqt/XA1n1Q7BEhd9PO1Z+oMMkiC8FFkciMKqK2+bLId +/7Gs/1NS6I4SBZwU01DRyu4h20zmrre2G3PhyeY9z0NH9H3nPjlYlJOTEV1KZjPe +rX320CWwd66HyhI/WUO95jCZW/xquw/bf/vYugQll1lY9cYn7sjdzKBNlZzue/Ls +gNgN8o7vfwuwlV9KKuVI6eZcRyWD0/FE14yBFocsFg4qaZnCLRK9iQEiBBABAgAM +BQJCm39DBQMAEnUAAAoJEJcQuJvKV618kKQIAIKNLAt/X8glpLqrulFIUXZ42rqV +ar5ak1BVoVZizG/rIcrjnymtiwRix1G6It98pIT//z74iPRuGEvAaZuVo8bWRaOd +zBbk09RX8OSJPLq53UHJxG7LA4vIaqVkmGKg2W2cYA3srGd3CGGoKYanVHd2IoTS +BzcUbuzUXXqIYx+Jr5nsfuvD8VkwcLP+ODFiufn882rF7L2kOV60nnrkpNkNF5I7 +nlZKltE+XWVWOvRwKXv36aGnF1h+b4YJ5SMwQHiFghX4psLIZfHhxE2g52BQrs9N +qGuaV+bCfKq/e0vUdwN0ZDpE4Xi6TwpMVUMWgsCrQkIS2PGzR4sNAq71YcKJASIE +EAECAAwFAkKc0F0FAwASdQAACgkQlxC4m8pXrXyn+wf9HAoX48L3kvvsZbIZ+vec +U9VpYnRYhgLlOV8PX9wPU2RnvRfuHBhDnS/1r8Ng5VYmff/wQl/Tmozr9GkkPaf6 +MGmsLPEg4NeLlInzR6kCpbd5wErlKK8b5q6/eDL357doJBGX6MXL1VNBkM32K7iX +Iz2PzRcANHqlnYaOdBM0pWfNfclwKVABMTTPtGesb1MDijTpk//r3brvlxM4kf4u +ON1NgkUMSTro/Rskp3ki2ydNghjpcGn7dU2cMdZ7jfSQvjHm7HZHYcU6r3PtB92q +MiX0ArTwfokrVGm/Hjj1O1DAextKD+5xzwfrzU5mVMVTN2PJW69XrFXvkICoeMiS +sokBIgQQAQIADAUCQq/kAQUDABJ1AAAKCRCXELibyletfHRLB/0dsVrXnSfnL93K +QJWO0Qq6AnHIf1ocRa7Lqk0NhxfVi2EjvqdWQhckCxfz+ZqX5EgwZhPERL/hhySo +VF+sZNqfhhqHm2RYFzWEoRI/P+ww7/zCnZK5wMAn6o5AzGX9Y57Oq4VOEHiXwacx +hL1jjvo5pFfk8ED8pEjlDWScMv2h/DWjEwhWOn8eGklO9iYZSblqHxxOXO5zo+6R +OPZgx64d1JCOxaqjaBLeCyvZi2ENGLoNWS4EQQDPjfE+rB0ff8D4WUtXneOleUGt +Orc1dInqL6iWjdmStYkAoJeRLHqI1yOlTeTwJMU5QYIL5temqDojrA9XgKvAMDBg +72iWXFXFiQEiBBABAgAMBQJCtIVkBQMAEnUAAAoJEJcQuJvKV618lf0H/2r9EheX +Fu3ZItkC2Es/j7bqaLM4Xz1FYap9iPL0lPDW/FgoL7cry1TPMgEPdaHE4gLSrXp3 +NCwM4/CzzoREuxuOK7IfWqoZEPsGxhEcO4zLIvXOyRxOImYxgVDJAT1QXG2sqItR +otGu1dAOMqiu+LpDVVSQLDhw3vBFdxdIfXA2H/81d+d07nMAsxPWbTIErROlvvmP +XEvLl7gIntjrQg/sFh+JpqXFNBOiVXJ55I1nRzd4+myHfWyNRSrYSdNEVok/Jyj3 +sUZ97e3hCDdFXFU6L2/Vp90goz/ibpqsr3YD4/dZfV/BvtwmXyimPjdEBqfPBYfs +6c9tnrqlTzt/ZbGJASIEEAECAAwFAkK3K0AFAwASdQAACgkQlxC4m8pXrXy9QAf/ +eseh2YRutIvE3w0Zt7SKUpDsq12uYAYmCi1sjY+pxUpTr9ntFibu7Sk3qltzgbwH +RGfM7qOlexN8FAgBw0jAHkrF9aB37pAhFkVoRMzUplmo8BLwj6Xieq+d8cRkh0kQ +bsaxuzILQz9C+K6JdfAfZxlcFNJacW/IAIzJ68fYybqZqOxTA7f7TG5clAaep9Ud +KGjlTb4p1ZKrJcQLsHtjQ1ZPAr1j6Xv52Pl8GLgZqFjmw2s23A67aeE0xoOooR1T +F03HLpLlFqkJYZQR1piI4EXNMXodyAj2Y4dq/t63I3es572VrOouDCykfWGwvQTG +0/qjLwUaNegrAtlqNBcKlIkBIgQQAQIADAUCQsj6fwUDABJ1AAAKCRCXELibylet +fJgFCACg+2tVWc65zW5hQjmNY0Y5qxTcGokZ+yvr4K2+TnAdkIh4iOM/z5+8F19e +YNrI7gfXIOloamThAhIfLLp7oXp6qiIZlhkw4oCCkMlAsbsohu73iHyUYNVfXoLT +2AkSartajyTMGNga3IoaP5s4PCXxClE6vjvpkNSTWxRPYvRgtfS9PTsK1BbeVLQW +Fsy6HUNOBW88LB3tyzej02eVefCo5xbUmDf3yMyZOFS5FsWSn1OvPSVlk0XidShy +mz7cnMwEZBtIy8Ijf/8rquaHlY4J+4izt+j2Y1OEaUco23L5HaQIEg/EzGwBMZa5 +Yy5gSHV/9E0xaryNlcBB+dh5SsGciQEiBBABAgAMBQJCzEaOBQMAEnUAAAoJEJcQ +uJvKV618rbsIAMgMmO4TR43vPr/0vo3UxX2zLnrywhN3s0bDYc8JcT9+OY6YOFdk +6KGqZ4XTvn6oKa4cjtVmLw0ZCCqwkGWjlgCa20PQgPWTt5CjZ5F9PJOu9q9vTeNh +Ns6mS7dBt2kJ2ROyGB0vmrgs8rs5T/WIVJ/4tPWPNubDoSzKstyg6+IH4DzmXzlg +dNLecmJl/AEWbPnPBQiILjQZSD0KCvwmZnURKbmWOxC+OrJhD072IS3EQL8SyRnl +DXUqPzkpEAODr73bP5jcnRYdC/F9aWbIi679CZQt4Xw3Tn/ZEKP63CW4Z/3eyAp+ +2Pc/GPQe24VnDh9Iz/f0VZ0+CufVTOkqT32JASIEEAECAAwFAkLRjsQFAwASdQAA +CgkQlxC4m8pXrXzNDgf8CuaiS4yiDLLy8Ad4l/y881vR/FSt7Pu8rniBzobjwHjg +kf2xNVi9rN7URGTJkT3oEJrjRtQBz45oAMpG1QhA7fM15FlZWX61XecGBenGRXN4 +b1p69wHxlJjAd6OVR1UzDk9dk+ITk3HpJD4YifRy+wAwvTCFcVp/AZm8r29wgIz/ +M57VRGxs/Ma+Vnzhxxtq5tAPwThQas9pFX+WegiYqqxcVluoNSD8sOcOp1lBgC4U +mfajn3ECgyA+0XN0+v5z6i3qwM1InhUI9SLGX21CG0hnLFdZnEA2+C7PscQ3i3Ks +kOOlbN3ihnHZZg88HeZ4qaTU+gcTp+CSQGMQX/w0T4kBIgQQAQIADAUCQuNZYAUD +ABJ1AAAKCRCXELibyletfFZZB/wN9j616l+cqPIaCaP9hWf0uJ7AxjVf1JhrCJLE +TKX6W22b9k2MGcNwha030QqDDDbAxePSil5aViIh/vtpuMw18sKYKl+GFnlQhD5K +Gw11gamLSLKoL1d4js8Wuv4Zboxtuk3og7VwWb3IGsXY3fgRD1PdxwThP4OdBu+3 +F00i4TE9V3UXX8s7U9bPxQASOkE+E4HgBywdHrlpjQVHpi4XhI2A+ZL6nd7SHuYo +XrPXsvvfID4wcmrbmrBY5EScJ1TXQqkGR8W9Dumbpy3Hud2olS2/nATsneiv/Jn9 +GF49/gBcgKFj6Je294uNr+PFPVjt7perwGUdHBvxQ0V+3zr7iQEiBBABAgAMBQJC +6UkcBQMAEnUAAAoJEJcQuJvKV618Ni4H/08gadbIllyGEs6AR+dhxgR0D0P4gzD2 +u6LeO/NsoNyaxpchFsHTg77/Fg4p07WU/jAQuSCtf2J1E838ZaFjGt7uVTLZuhaf +xCbkXfVJk+w7MqoowzDw0m4MNNTYQ2V8/R4xhd/IrX+mW2SpdoJPEUTqiIJCBsbc +usKQt114Vb0mhKNecDfWNmWvnMGEflv7/VNnGxinDpCDLKSo0/Z+HZXys2bSC+YZ +foqILUfNJ3pOsSfQUqJMIWTAjUjb0nAOLbqzGJix3nJtr42gnaRZ2VYatUyNfEqQ +qoQekMd6BcLuVdaDvV+ktiPfAwD5bIm9Tg8lQ43fzb+lYXuBEBiZXaqJASIEEAEC +AAwFAkLslcoFAwASdQAACgkQlxC4m8pXrXx5sggAmXVXtlsde6DsIGc4DwmRZWtm +yDD0tYMp+sr99+0B7sQU5HHZso6oMHy2boJPeyiS9q2zBBEAL+LC7StPu10HMmmn +n7WfmKl0jffYKfoW7mVEQoBGFDWfU5UATgMhnMuJMeXN6FYkPNvCfw4Ju609zxR9 +c2H5Rn6u5OzN34ponM3N4L6ifBmQrpwvYdLAitrryNUDw6KPoWyxp/IKzaX8nNCs +flFXHGI5hn1zuT6Ye1XvN2qoyOQlLmksn9VLWc72eyH1bbu14jG5Vvc5FobfIAiI +22sRMzdIc9ksEWd/jJWCDN9Q5ycRWxKCji3L5LQ/89YF4rvRKZkdfgapIJ62lokB +IgQQAQIADAUCQu098gUDABJ1AAAKCRCXELibyletfIrTCADGWJt3AdKUfHu8kzUH +umv6DwTopQhgQCpjLVct71ryfoQUh0QqWJr3K3J/glmgYfoEvrnQfIMRH93RU8OU +qD83XbfKLyILUMOnrby6tnjbb8gQJA3V6rMwsDKcMPAbHSEYV2Y1PV2ge63JJHHR +QD7NtHiDxr90Plz1jx7OZkXPEPnJPXI8+E6+h92rm3cR4b46pUPem1i3vVDg/yV0 +e++TAvknikpyeiZndjlhKVHBItZeQ3Drglt73pk3c8MFIzCFeUOSTNueQxqtsqPs +ntn0g9MeeK5Rel2y6feIWlJr2QSHnfW4Mcgv1E1zSKCv1MojEOPt/vKmccpdUhJv +XDXmiQEiBBABAgAMBQJDAGMeBQMAEnUAAAoJEJcQuJvKV618P9IH/iBZ7x2IzMx2 +pGJk86RlxNzgGLcj5cg0KietYrOR13GUwT0aIXP/E7kPia5BJB7JoDG9TWnmXNKd +bpA4ySFiGBX6qC0fMQL3MCuhfqRw58TeFyY0QldBJUp3fTbQz6sGGDQz/WT5+TM6 +aWCDO2reHwmvBo+uk96COdZIwbKFR28XnSqi6p3Ba7Pv2wchpNCpY5hjcp9LEvYU +/HNMdqyAjsjRGXmvTthS/ZWk2Dag5aW3lx6t7EETZDYSYUUzvwzZs10SB/PmXH01 +yX1x7hPrCSNPNLNRGPZUhAwjuKRinc0usyf8z0f0uWciLv2Hiqwjum6PC7XgI+Wl +Z5U7I2Q00yGJASIEEAECAAwFAkMITz8FAwASdQAACgkQlxC4m8pXrXyV/Qf+OiZD +jnzmSTcPDwrySqDiklivTQr0fFslFHynXhCRbM9v7YhW8VN0Jqviz4yjGBaXclwq +i8nMpY4hcFGI5ykVNElp0bfIOGGPx+oknGttx0GulCQkOKBUaP7I0PNDf9XDwIwP +bBG2Uu/EzYzwegAzpPV3s7FVQ46FH4UhH4jG1PkVqDZCOhoQFJO++e2XugfV5HPX +8BBFYUR1aBTNzTnTVv3nwnWBkvcNDCQjq36oOI9TamL86jyA4XTRrUoWUJEVCO3o +HrogLM+a5JaQgQYMBfvwGHulDBqjb8Z4aCX+vmC6S6iVAW5HQJ4gPCT8PxY0mxCx +VGRRavFBBMnGL+kgAokBIgQQAQIADAUCQxDhrAUDABJ1AAAKCRCXELibyletfC3w +B/0WFb3d+7m6wFGoCg7VW0BmzcuSVgI8aeAFZwVs691DVYpl85OVsUxUsZ8LSEQp +3WcDQQdoYZOD9LK7VxhB9Twmxj1O364VvfEon1E1iIJjp6hJ3Boa3BvEzqpb0Yqd +0GBBSpByMk0t3GqhRxq3q3NIas+pq+NTg9076YjSp5I5DSBphItW51MOwdO13nM7 +Ywe04mQZHhGDsnclwkWfsql2oPEtbc6+lty0d+CuuB63oxDne43QbWLCkjl9z63v +jAJ6FMyWcoSFijpZcMlUlToVh/nwarsH5euSoMNJ+EC/osvkkn2yntnPeYZCMbm+ +tAKGxcWmsRTgVJ+4Nknnt0ZviQEiBBABAgAMBQJDEjLYBQMAEnUAAAoJEJcQuJvK +V618qP0IAMPkS4UyaQvv/c/QXIILOB9Y2VXJk9SBub79b3SB1xORJzKXryB2Obj/ +UzmM1fTY349SIKtfHDW/D/BSo6vMH/vF3tW5iD3rMCsnGP33yLyzRsjJVpLyzHkn +GFX+2wf4DpULfnA+wHEDf2/2VnoSe1gcf9XZuq0fAbCsnCOD6NyP0ctlKqv5X7cK +Cf5yr/stXJwKoApE1R0bKywJWPGmBsnALJ0/4IhcB5OW6YJdep3/PyBkO1fclPXO +sqbo/Uf5SoPANJFnsTjA1wJz7ER0P2RZN6OxDStE+KyXaMQrm/IxFod52MgO8dSW +q+xF3JRXyGA6QReiprCXzfNRdmtdN4mJASIEEAECAAwFAkMUMGIFAwASdQAACgkQ +lxC4m8pXrXyhygf/er2FF8VHLIJffnW9Z8mPIkdMkQsQUCqzfYquTYA8QS7GjIW+ +spYKcxuYmjg8U38DC6YcURZ2yOqIoXZyFMDH3EEGx75eOK1EmE1N+7f3EcFRgIpb +Kt7RKVUuUvVIHODGF8ASmUOShRWlrVbHEPQ4dL7UZDZbU6o1++ZVp1/r6tS9Hp5W +3CwAmmzKMaFXrZjADNEebYDF166e+KeBZSNbqPmZ1G/l4fmyigkq5rOE8y6auKaX +ZtXqw9/BApNAnQ7uK0ONMiKU+B+01pVi4tTbLywtq1OgEIVmOXNzSAdqPokf36Wv +7hao3hV7/772Xv0wTqN6q5iPl5kfJxepT/PuI4kBIgQQAQIADAUCQ9Kt6QUDABJ1 +AAAKCRCXELibyletfN17CACbjC37WUHx5caJlQRrnyVFvQUGuqtw95UKBytYlzHj +CCEDX3EdnUU96AUHo3n+vum//aJPLFAsQ8t4IGKyCZ/RzYe5e2ZuPVEkT8edq37G +OwiHnjFHWz30Ugi5IqEXx2nAJHKJyK1DpjzRh8YgtoJ9NrFPff3hieiVE5tQv+87 +VyvcXSXLkowQmEIib23f1gGVsEEB2b5cJCKW9DTTxdWKSqgkiY4eXzj/7RevOtlH +WXIIN3dULNSrBybjnGJze+VFP2rJcEOuawP5DAB+FU5Lam6eygDCi83qvIjfGQHI +ywvVIscJP8FYu5+w9LMP9u2ac3fxD5xIVMCchjsuHXKfiQEiBBABAgAMBQJD9kMW +BQMAEnUAAAoJEJcQuJvKV618A80IALbU4WRu4u7MwgOY/QnYy40oHOw3Tc9VwCNb +e5Rguo1cCxZ6sxDU8EsN0ROE3jz8T5vKJLnfLGg/cTrDwv8B6e/m/j0jGzEsGo4t +EKAW41tJgOvsm6ioYiTQ/Nw9VytSq/elLFDim09cVo3mArO4hVws7v8m6QWSi7A2 +DUBOGsQU0VpxUQaXOmV9l9m2B2D94Yuvd0qSn4C4p0y5bMavVyuGv8xPa5FIo3Na +ziy4utBMOTjMwW+QCMxnT7IA5wdefHB7e7zFltLLYS6XCAYj8/NOn6B27KC40IMg +HKwJ+SLh54tTBzwTK6Qkk1A4GHVCOpKSxAltD9z3gylpISDG02CJASIEEAECAAwF +AkR1XGwFAwASdQAACgkQlxC4m8pXrXwuSAgAkwD/O8tYdNxp9vsVLgedetbSSyZR +fRbDbQZdcgHAjfDpAUsPk5BOnBYJcWEfkB3kklwAWsUIilLT4S9GhpKgpH6WB7CG +IU4W1OvAKUJVL9Y80jxSlm1CJvBP/dAL96PrkOApXaESgczu8o/0Vme0obPC+v3x +aDWbUifdeL059xbLEyhl1q2a3K2dCDRwkhQZZWigFySNTtozgjQF6DKMNnryUBA1 +YtIuhCLJWKmt0pPordyL41d8ywQk1UfBVWMeboXB/XO8UwApuzkkVQOaODu48E+v +pIGKPm2ERvCTe8ws+HCRkg7ze57yjf4yfS2+Cu3gF6fhSMWGa61XRqlq/IkBIgQQ +AQIADAUCRIcmygUDABJ1AAAKCRCXELibyletfHFmCAC3WwoPJbqkUJc146oT7iEV +S7HKkrfuts128V6Q/QGsYGINJdSO5V4bvqq1a234/8N5XfvBsTNvdpKJ9IjbhgCr +V7ujkp8bI4Qs3gUWgI8Nm5AEtNU1C6BRoxhn6ZnwSA1ajdC5AooT5tCiLh/GerKi +Aoxoxdf8O2TTYkEf1sM/qvaIG4QwTuBmCLOQMdbbJaf6NX5suHmQlHiq8cL7RRWt +85wfx432EEeHzOa6wqHKZjorWQBxLXgDdc2aXvlxKyi7b+c5gTgOwaGYFjOUOFvY +KLH5cUkDt2Op8E430cDWBMYmdATJBUUn3Mu4XhVN29NWEftwCCNOgSuAyho1Wx+X +iQEiBBABAgAMBQJEmPOABQMAEnUAAAoJEJcQuJvKV618XFwIAJJMOu3Rs1/qX7/c +IFHyNq+feJFuHMfBjnkbaKPOfy1Ln4tZypnR/JKGRo2Hf4MCs+jbUJ49ZEaSIvfa +hLr4RqbbqjwCtljJUKPPNP62JbehIjaMcwD3TEuMCYauXCdyWnSNYtoIVXBB8ruz +kCPgTIgnubmxTjX2KS2M79zB8JVMjrSC24MR+fCxOCmlGUHCrR2kBq2eiqJ2GFgd +yRW6UPsmtuX1etZaN8mwaWZa+x6I4wO0KKa1ItKPwRi6qpCZ3uzyQ7S2ZKyjcesR +w44e0qlTTNplkKqng09MpU0DPOkvm9ei2IHtWyuZ7EkHaCqHNItbyxgDgyhZ84k0 +CbN16oOJASIEEAECAAwFAkSqvnQFAwASdQAACgkQlxC4m8pXrXyhFAf7BU3yoJkj +uvJQhLCW1T1jRtyLeHMwPdsaxNWoE5szfBjcrDgfJbbnKGsRvOiHDptUVqpR8Hqn +AOKrG37I4/QBxkkksjFq5KMI17X1O6bS2scg9KBFtYvS9b2ogyoSbhzjAgV8A7xV +qE6TfTzpxQd00B1uA1Wu4p7POU6YrEZz2Raq4R0tkm+BgeBEI7zt8PR105CHRmzD +tZxYiCh9TjC4+4EnuTtJPIjmueKCV9bljvZCEcjil9lAnDVRrUggZuaarEg5DyCX +TQuKP+dRfEvPxTIplHlsnqhtDipQB2TkLJFIAjQsbfdciZ8AS0JYIR6g+pUdR0XA +T5oj7W/w9R4xN4kBIgQQAQIADAUCRLviJgUDABJ1AAAKCRCXELibyletfLa5B/9T +MHno8J/qhxvxejukO5+XnTLyc6c6s/Ji+VwsseOgHRVknTz/KNih1TjIYxSfcAaW +wIHSTJjXNqcXPgExOyAYQFVY8nhHd4N1H+Xn3M3JJ8RStq+jKY3asTXbbZTNN+vf +ETH1NlNvJSNhAe1vMrArW3JgY9GObF6WH5MJVhjvezNDOikG9p21PoB8So479U3u +BSg0GWOFQTGkIn6aSxcTlYh52pTdaWYEvth91l/7bPh5oM/ZhsLZ9wWn5NofghUP +fqnak6VPx/TETqLcvCbHoOWhDJXovUz8u/t1NirqsjYx01X+YqyeuIwOmGXRMddH +D4eYyzSToCjNKSZCanociQEiBBABAgAMBQJEzQflBQMAEnUAAAoJEJcQuJvKV618 +Z9cIAJ80o4NxEqYbujABc+Zk/PFF0Q13F/daqzB52OUYWXG4EQnfXyfgIPXrFKv+ +VAdW68Cy4PRVorg6ZhgBPQCXNJ0aJfLY6AUmoGpp4AVKrwoO99tIGlMuT+73IA8U +VABi37SB/JZ1zoB9AYlWAJ6TNQ+o3m+xSBrMRDCY7ygKNoMAVJddU9P6FHMfXG3p +7URvgE25ZadHpu3GX4maPZOLeTzTNIMS7a7gKvZg1IE/o9DYTVfAnVs9II/Q0pP6 +lOtIkX+EcDm0CXIdShj3g7HxxjwLzIiAIRjq6N79Z1gy2oW4tn+0a6Wc+LTu8J/P +v5zuTGhgb8mmHWtHZjHoX7suvGeJASIEEAECAAwFAkTe03AFAwASdQAACgkQlxC4 +m8pXrXzYpwf+Ke+R2MM0pHvdiPqzPrOD8W5UQlk+Zg3iLrji/HNfOFknPVjdLF2h +ss8H7UgMbrYneryPyPBDtKPY3ecGhUejvUlAFdYqjOuHI/cEyLHFGutsMaE5/3l9 +ZuJFTINGvOT1PWCtVAqMeBnc5kEKI7w8HpvRjEufeW81iIWvjAZiBvVvYi+RWL7V +vplqcrSxsYfDyjM/ybXm1a3rqv3H5hX8nvbB8VErxxWYoRJSrLs2zgtU/kWyNG86 +bynwS4oovNobjFkp1HzZdxf2D8aRMrY6HI2t2BR6fk7ZdzjXhpu+XC6m79hTgpHI +KFHLfR8yweKJUNjiUtC0Ef24eeKGFgxvfokBIgQQAQIADAUCRO/6hAUDABJ1AAAK +CRCXELibyletfLg7CACb6jU4fxYNnSIX1ZzyR6EmlRWexjb5HbQFaK8+RdEcc0P8 +C4SyFUU6JF3ORv0f755pFKJtH0/kqHucqhHxrM1bRyuxNpAeN97uL/qpVR+ufdIH +r3wVLAgNzKNSlUKjta3PM9olnq+4VsfXMHlW+4t7q18Ym0bl7gM5nJKHv4g3QxgE +wBVl0NE8TT1FxkGd7YoOZMpYKb4PwWw+Nb4tY3+4D4Mv2hA6cmaOVRu50cUbvNt5 +2UuXnLDa+yTCk27C/7oL++Dn3+gG4j1rjIQmtAS1q6X0MZ+1cd+OsuDmQZe6N99P +0b4aFeHOnRGGGwqe4t+BNp9ZADlHRH/fxDx/f6FiiQEiBBABAgAMBQJFAcUKBQMA +EnUAAAoJEJcQuJvKV618kfQH/R3hZu+IwFVVSZFW1irCoCbJTn5ejoDqNNZJO8Cc +TnT9oLRwHispcIc78Lill3sZ1haEHVhATqtR/c5pjbf82t1qsGhrSe6xuTb/87HP +dpbcxm2TMFYf8cGQLxQ++qQoBtAL/4Cf6gZ0DaH6Gv/wOgLQjwN54rz3ry3YZVzN +rREnhZ3kwjI+ZX/J0cGtZcJzgRsydEh7y/IPrBkgr853K1zS5iUjW8xraO1qnyUW +Yr73t3j4kcGWK+d02xbf3e4V6dPk+yvxqNbn0+pGxx98ve4MR0wM4cI/w6ZO3jF6 +dgbMFbTfmOLj7k8iwFfwUAHZdUHxCPpgHCldyNFp3fQ9wmSJASIEEAECAAwFAkUT +kPUFAwASdQAACgkQlxC4m8pXrXytWQf/RlGx8bygRWa0OQnu+IVHKNfepiL4YLLf +Tl6FmLF/EAxaljpyE9ec3XygtJ0a6Bh+sRPAHJmVuqOSZCEfHLMf03UeA1aFYPqn +hIWXq685Q0/z9HwBh71mxSeUsMMkqViYCa/83eUGXc7/xh34J/0jNTC0aoOyN/Y8 +pAYmG9dwsQhZM3QNu1ZAoIM29WbFo6+/PZLDQQ5rQE6+q6ShtsYdSbi3cWDKzOtW +BjbQ082SzOZ4qaMPkXylueZUzO+h0Mv5MxVz5MQjLnM46572rBwPP9FqzJAKTqba +2+E0cQJZ8Dg6DFj5a33CSDk8iKrfPOc3T/Am4AtHkD5T9zKlGhe4hokBIgQQAQIA +DAUCRSIZ9gUDABJ1AAAKCRCXELibyletfJFxCACGlMlSUtJQI18ZplE0MwStXZUL +GJq4vXj4MQNVA3BteqiEtq0V1X0MPpXPO2KC2VxBeP688rpinwbpQNvQBkZJ0aQu +Qr54FbkaQLM8h6CaKIbmhHFxD0v2xvJgfsEldiw/oXVZAkUF4dv8yIyXCJlyvvm8 +YbcJAzTG+vYDSa+1RZ8qUncpch5ifavXJmCgEP3JItcho0KxV4lPybUHMkwljZnn +EpxbkcTeVGjBURq1eNfVPtkC7pWXDs6GPQ4Z0prO9JJnn/yIzPpMkgIvF2R+LqW/ +GrHzB192xCjaXc7YHMEsTgH2dzc2w9wDPSu/k64L1Ck0HQLsbKJGr61X+N4IiQEi +BBABAgAMBQJFNAmTBQMAEnUAAAoJEJcQuJvKV618yMQIAJBE1vbABXTJNTbIW+Eb +/a53gawgPOWsatiIyBuAusYbfzdro5mO9ToJ3/880J8nAMTZpCsYiQV3HaofU7Of +5ekNuKO38jlcIRmcQ5UG8odtXv+xtPurx8zXcFfpJ/F775JWhcZa3Ivzaz6c3WRg +sPmGEyh5auJG6F9cIrPrHoNaeoFiErX3jS0nTOGvrpIsnmBpLoDUbqeOBmBRnGhC +Vew572/pfsENHMhdPWAj66MahTSyb/U8JJ5BsbPcVWE9ChFW7lfbLPnEf4PV12ZJ +2u8A/AGn3MsMULdh5MvWiV4hB7utHjBgF7o3F5XEySivmhFGkq8i47t4PDvDr1NE +QkSJASIEEAECAAwFAkVFzJoFAwASdQAACgkQlxC4m8pXrXx+dgf/THIgH47+Bdqf +T3Vgi5ohIpRaRQI5qQLUn9tkbTqJkYKsj8Qx2p4gTG7hVeH+0Ht3zhQ+YJjUhOi6 ++YIfPHTgNxUVoenfJ0lygPCcRiXsILJ8vKaOqQw1uZC7w75Fw2IVlKth8r0PuIaU +Z5EpmbxwQhbfDmlmxRfX60zOOFKlBfYYV6dq3RsRLKSa1Yh9f63AiqR+14d29pes +CUR7Mw4NVxkZ7AyonEJEo2vliFv27v5n9SVnOMep7AgAvISaOTXvH4r3XDnczZRx +HC4Ix3moBovhFON37LqGXTZ6XcTKNJO4y/rvnt4cz3ztVR9glCrq69k13kFjGllJ +N5vz8ikmDYkBIgQQAQIADAUCRVcGrAUDABJ1AAAKCRCXELibyletfHymCADCfxha +DctdLPFSCQ2nFt5QXFkwTbtvm/vz8zxCy1TGxZY3o2MWFMd7N146HpmJnCCsrvhW +0sekTPpmVx1YK+cv7XRlUO/Dos/m7X/qJIYFfNira5ecIZ5FwgLmHR5qhtisZJX+ +Q8sBPV5T6/CyNJWJjZ0B94rGe3oLs7a7kPowT4OQ8WDMKaFE5xN5iitngqAki7+p +lcBftC/YhK5PB/JnQmHEHEqJ+GZujSjR/29zNfh2+NElpz3yq7QpgLsVvjlnjQtz +8HQrlzXlS4n2xQtzFw1xjVVIK79njKae2/Yoz3yV8eflVv4dyB1SwFeICmbucdw5 +7UQAOdcTIXlyhKQMiQEiBBABAgAMBQJFaNXABQMAEnUAAAoJEJcQuJvKV618uKcH +/1BpjgGbzA0go/D9WCRy7yWzhDmn9yjn2oj8Ti3uD1aZVrVlsy8cp5v5L8givW0/ +/G+cJNcR4BsI7kiIydWrFcwB71Q2rQap2Lh+xBx0ZM6dgSi0AT5RSfKDI1HC+BL4 +zAAPJssbSxKhSOfeYfpbOt6R4JeX+0L8Rf7GTus/qQsZQk/8zTWCr9uJgO/KSGON +tziHhHi1Qt7NGH/YBAbj4m/qUtCTtcpxp924vFdSKJKBPOGasjbz7WxVRk2NGCJR +6+FcbY6Et6/0Uugh1burZ0MRCL4oCmTkzpe7kSqmLS4B/Ouy0gHZUuDU9iuACQoW +nA9W33QzbEwBAK+R+gY5bPqJASIEEAECAAwFAkV6oYUFAwASdQAACgkQlxC4m8pX +rXxihgf/cPK+1zop1dcPpMFharKu1Hch/zlBm0KaG9ATp85cYsTXVFO60HTgaxrB +3u4vOmKfWtmf8+obSGkdtFbbF3+G3zsyGlV4Id3WuKCMY5vHukeh3C2fG4sJwuzE +EpKFxc7UEB+kAQt+bac4sKPdNWYAj7OWhZfEvNox+QJrC5w3uQ705+99Ky8mr2Dd +N0zecIo/KwPElSfhpY5OeXbGSfq4eevn9J1k75/c3u9o7dZhg8BOVEbC0/IcmSRX +g6fYu6tRuaYH+UHi20LQd88ZhwEbu0+bwtZSQ2zZWSxwpIAypMPgMCxz6qk3BSE5 +oI+e9UH3f5W8vo8wBp1I5eAOcgJLCokCHAQTAQIABgUCQcLdhAAKCRAIFBnDC0N6 +id40D/9TmqwjlWS1f6x6tRqacpB0ltRkf6XZAvvPzGGY7S/Q8LngU0qQs/MCAzTt +0eq4Zhg7T4QDmHAo9tjEsroiQpWgouSNp3TWI0cD6PozhvkfOygkT3/t9NISdMCF +mfVtDcI7ciuWF+t3nxQ5diRtjj9krs16NaEUXO5irr61Zi1tUQ9kcvo6CiTML06q +BqB/dm3ahOEvAHxB7J4DPHB7NvrSZqJw7jo2GU+h9fRI2OKq6qfJw/CnjhWAQn9K +T0vF7wri5MuVK0/4OwZvdB0v4uCADlU2RsgY2r7a4oS6IXw87LV+pDqtfgbWrxnR +lknn52qRIA3jJvyRxAjPD3+f2sWJ3rimmEBG1foMTQL8y/Jd4J95gchGjU+B+aAE +7adBZtRL0/zkbeH82uAVgxygosweC7qDQwr9EdIoknoZHXw8ODf0z02n4+GfXPM8 +mSFsdOk6OJuftdgzZaEyHSq5mTAsfR+QcfO6QGjYV7fiMfKqC35fSUhdmsvYPEK2 +GueEKwKEYUUATvmgpYzOryQwA/oIHyMBTyrLO3zRuQfjLKKaYttPrHR4YPfDHamk +9QUgjRfRy07FIyMh6iDpLbbKaWxKPGPhXxhPaaHSNjq+OEv4AyV75YNnotXzF+3u ++N9cyHK8pNKgLAkhbe3AVX5JCBBdyHSazZwr05cIEJD0sMoXIokCHAQTAQIABgUC +QcLdhgAKCRBQOqASY1SfjqK4EAC6giTQIiQC/j1PQ7gdKkv0XYbasEUYIlMqpUhp +sFGFNRm4FTQ4G93GM8EcOGrnectPhU1putaGRRP832XBYqXvImAPVmfnPKnF6tzb +Ip5Xxq6CsssRfbAObx7HTst2bDU8O3gwY1IOwhGRHpYiAS1N/i9pSIOHB2ZRE9Yw +zfqY6b/vEezuQAwZgt+08PO7lpLFA+tWNxOCvebo0jO/2K0MOHCTBDf1J/OomyMb +EFI13EHuN3FyF2pjuev+4467onHwk/l6R+SqztlWoEniLKtvAsvK2m6AXZ4zY0DY +3j1VbL055XO+kNtrrH05bFc8FasvCEeayXnqQGKGzEh88ipYLWtsc/SwGZfqCwrg +RAZiPWgXxlmbYX3VU9x2SoQXqCezknfOH5n5JFLAyTl9xL2OQNjhVuuJZFSqz5kj +Nb8bKSgxy9qX7InR0CIhnTvqsojTHaNaJLQPhhK7J5ER3VMIQv9KI6EE92fcddzA +0juSp2sE35WsOZEp0IENAcDgk8BzXIp1dYFkEDHHaUeEPykZ4bce2cbPRusPnT67 +xqtaEc2tYJs/QFficXSQ8jwiVhxHfdgp13lxyoOh2WN8OFK0DnQBSM8ztUaDJDsw +WNFIvuWJ9UrMRNdmNfq1J+aSA5GZLRmpYY0pn5NJWK2jL01Q0+O6YOckQHfLAY7U +G56fp7kBDQQ/cRcCEAQA1iPRRl/+8/5DSsj/whzy3alaW6sX1RWbOqmCPKP+CAZ3 +pVYmp4gcl7bzZDbKvjcWWc6lD8xIttS4VkGM9p5soYZg3g9JE8KWpJuF2YYDPGz2 +XkJYoo96PU+UZZL+qhu/jq3i4jEw7Omte4d8umeiV+y0tThkARsYLy8xbg6vqScA +AwUD/2lFYDW8umcKiEQwOH6RqjcPfHk18TDJ/PrtIMqUtt72rHW2lsb/qKKaWnBU +Ep3uSTBLRGIzMT+6rF+uZu+FQwMtQKNIPWNuTTNPRf+oeHBSpCZsVvTudrTY8aHL +G753ogWKH+u91uGVEFEoInAMGMCrvPCYtdrmYPLBW5UUMGtuiE4EGBECAAYFAj9x +FwIAEgkQDt3F8mpFyBYHZUdQRwABAasAAJsHq2PxSlXts2yuomnnRtjyAZC0JwCa +Aqq6TdFWjZIxZuTAYdVBdvgDGfSZAy4ETFQdZREIAJ+KWdd00QUHNSnP7lthKK2Z +nH2kmws4+M0Q1ITNo1StX5Os4qxknCHhAUv0bofuBT8KMx/TBm7lQUUJJ+ACkLcQ +/X3QbUmPWexMG3MOwq0YgfFEE6q6TSi15eSLuJo/KetVtu2MWAhAyK9IlBuu7m6j +JJ0oMX82Wrb7+/qfx0I9VtdgJDvgMUe+p8no8bN9ZQmXNK76+V8GCFrkUk93VUt5 +oTN0XqLWnadW0O+w9CPQWfgknJ2Y5oBSnZJV1NjPLM2tlj20AYaRFd/UVRyjNfBD +V+NGq4SmrYLUR4U5Fwnv0CBzm2fRbWgnUh964M0vz5LwI+tbt/AqNE0qPGvD6YMB +AKVJYT3YH/0gO+O8ut3GSGwHAN7gLu7h/Ie7aZOMBDvpB/wI3UgbM01PeBjMR9Iw +9Th6jNA37CdOEb74wSoNQCP1UGdwm75305uuquhPQMHDmfjFSUxH/YmRtcnM9ziE +WpyGuGo1Fk+hhWx8m6lOm+cmQ34pp21nU+5M4gcgkqhwnaYuirK1DTCfiL03dq9E ++51uJqs9zfGpSoJ5sbrsUzG0xy8rYalrSVJcOq7lo6LjiGmdSJwfz8/B8PtwdpXw +aH+CjHPF/w2T82aJXFKMR3cUeuFEwWWDxiUaL9vEgr97TLd9V9Ha9CCj8T28FKFi +PsaGhMVAYdJCvGIdvtnhWPPLo+CIesknDHjh21SC14tbYWMMdo5gP2Xepu8X2xUK +d4bGB/43Y99RfVfEF5ev6+LoFbnB3SA9Ol4sF4ARtCr/Tvke2eZ3u805s0Kh78xM +UDLt2vy3gCLmWODO5PMWJ/iKuBn8sS33VLz5ZFWgboBFlM8BD6FdB5J74jEyrgF1 +5uzRSt3DtPotBqIgzTTTp5aVNMdMGNXzHgxh8QgZAg68pGfH/yysbTxzgf8BXYRy +90YkLyBL1gO3JGeQDKp2xDqSpPOHwQQCgskFhFNaimnUONSEPi6QpJ8Vxasw5kjp +DeHjHN9FeuHgrFp/y5E3KZ+q56yXf3gMy4Olz02LWLOkc6ZwylLOHC9a35spbQBP +sVM05y93F9MgqIkd1SptvtkIgN3otDxHZW9yZyBCcmFuZGwgKFB5dGhvbiByZWxl +YXNlIHNpZ25pbmcga2V5KSA8Z2VvcmdAcHl0aG9uLm9yZz6IRgQQEQIABgUCTH5T +QAAKCRA30ZwhiGmcsECwAJ9TYyTk1ezIs/mKC4QD2zfW4w4eYACffiykrd3x8VXn +DJXVC9cwEzdshQKIegQTEQgAIgUCTFQdZQIbAwYLCQgHAwIGFQgCCQoLBBYCAwEC +HgECF4AACgkQClsQGDZYAoglzQD9EisL8sy8kTyQrRLiB1nC/vI1apqc7L6uZ3FD +2QSV2GcA/1ou3QgsLH0b8BKcT2ue6oAFAfRw8uxfVZPbtnJi1URKiQEcBBABAgAG +BQJS2iW/AAoJEAIn3UtsAe61GyMH/1itX9zNJ9D3CWAaSWtuAJRnLAcX5KUZZaWp +7QqIrlQdSHVfmBPRE9i5AG9k5+Z5AgBM0aKrf4avhLwlcb8zCS6uMUmyBa2H2PB5 +UJDO43hYann8vtRG9yCgKv4BAezEzjgA2eDsDI/KyBB3pY0HY+d8lGW+uTIQGaH4 +cW4rqS8lAHy02KyuVUDCsoUvt2hzUcswMRKcT6S6/k6jcUpQf6z2BRluGvfsGwP3 +76xrrZN/yhGvPalwCuRl5C9WQoIaDnEcva26VlKQMPzyzUlfGmmnCb1cZDLK2iL1 +Err9qlr1jdyRtudmteuN6GDQadgvIg+L5Rro/6MB3KPLlAUekViJARwEEAECAAYF +AlD/S78ACgkQLJrFl69P+H8ZOgf/fVWOxOaRbWpDxKq9iJ2F48Q+TKVAB2WB+OdX +axXw8b2OKYmKNYJvX8Y4WVQHgaNuIJUcXGaBu0pRYtTfYSgrDTf5mpbmpqO3wKVC +W2dVjb7UgmQoUSgfi2ys/5RO5PLB9sMEkTM7jkY67et0SU05s2JmxjkfE5hYrehk +SeniYcAoflAK7Qcu7pMbemn/+yeYdgPf4kG8eB6xTkQL5hauxk0AO4lMkQbnLWGX +7nIlrDx1hy0OmT3qTJVM8OoCY/beoyhyvubCl+RCVAAbMZ4h55MAPyHoRLEiCFAg +z8KUeJSRGDZ6lOrU2P+CMbweqqmn1nFXVqcDP19vc96/HGBD/YkBHAQQAQoABgUC +VpMGxwAKCRCEpURidEab/n4OB/9tlvsx6HCJ2QmzgUqrRjgkUYM3cAkr7xcCmVvq +1ibaEmFBks+CjOxvO2QnrBME7wL5l0bpggIruslCcTAegsYyraZSgJA7O3Ui0zOe +JWYjzgvPOGblt/SaXowX3eBNgSsrNlqojvzGwPjdZhtntUqB/p1kpE8JC2V2+jny +11n0PjjbPZDgEuMIJAQeIwDdzCQJFG8wxzaJh0C4UfkXx8HerR94fCQW9AEO9dnD +qW4oz/6wgPPlwZHSmWoCwSdBMIXLMuTZajzbp2305f6tNVX6huP/PE6JQRtA3tFI +irMWKhOw9/vf9z6kIaSu3CLfturKK3eYwhSvUH3CAcScPaAviQIzBBABCgAdFiEE +u7O48j4EHD4gDoGAA2Lo+mU82iIFAls6BFwACgkQA2Lo+mU82iJPOw/9Hy2fBEAg +M953BO3lUlGsk3p8phCEegTtlGEB/JBwQVhZ9yf6RTltZuTg/s1JPIq5iw0+Yz2O +1r7B8xwfL/5/QMKBjMW2gZ7UdsoBzB0HS8Bv/Q5jce1y9zKK7Lwbsjky5nlWmHV1 +7PmIs4UApUuJhqgtV22x66ncr48XJXNMnbZFU7ZtJ5+0y/wqILbX7SjVe/nP9M5q +Vf/yXadGucY8QO2GpKqb5AXjCYahyH0xUTJeI3w9OeM7YkRApFgAewV6lfgktoV0 +XSxzDu1w9diI5+p+7mJg07W7vc7X8ssyWYEYslV5HwpG0VdZZ/OCrsEst4FDr6Dc +kbODXenc/iMfwSG7PPrsbZOtj1dBrEAiTICvY619jr+i6SALMg3cPIeDt5gi8DGY ++fzlvlLwKaJf9blp44n67vMnIEKoasKDnXg5XSZQ1AsLU7tfu6kOTYeEKbfgl8wX +jWXo8JHjXvaZXvUyosC8M7e1EIklMP15X4RHkl2eFfVO8k4BAp7cHTNvgHatNwpn +vnk+ottNF3ojY78QSFLiJdnacl5qkcIF598hdtDfU28f88TUiZebcQZ352GbCiOb +uOwSP6uj9+YRJMDvCO0MvhXvdD9qaz+D11pUCABGK2Ka5GDt5mjF55DMxTMk6+no +KU2TFqywj9kJmiMqXmmDoJ9kHphJW1mBM0+5Ag0ETFQdZRAIAOhmmTFZa+eFiACC +xWLDlnHk7Gbag/Ga4GLymkWwp/5fIltztlIF3UjXU6tRdDj40sIhz+pL7xrdVytZ +xqJ7Un7aPl28ekQAKklIqpyCF0iD8PuU60SIbnf1YAQ8+tEhqUTFbxgmnq0OXJFe +TbXGEvjYE52IwJEMQPX9uEcmxJNXCwcdez7Fak8SXIX8tFRbBCPYF0S1ysZL4Kvz +NWzqA7sEXTus9nhhl7IZQvBZzFtMhxiG57xyd6xZokTMpHVprOswAEUh7GRU07ve +3mr3UAAiDkL49akXxNpV3ieytkSCnuUlUC4nS6qGDNXtiGD7X3VYIF1wa2Aaowym +MpWfF6cABA0H+wYHFfhrb7z1FCFGV8kkikuq3AgQAu2goer8/ITKDxZwNJZWCM7t +iS24I0aOmKSmsHqtrM1i3pVoxTC+bHa28OLs896JbCqTdYLanAXE4awPEAtNlJpU +vJrkER1BY02ubQLSlXSlNwpmxmk7L5VA3JfMrjkVjPGx0/afaK/n6qLVE1SfEMOE +oDqkRgF4/Xum2zxplZ9mfMzGgn1qM3SRM0ublW9CdKBBmS06ww2lMaLzztK6p7mp +M8oBlAQTrzawxEhOsLbOf/FSfpWfE7glj4uDleaFwK49ZBKl3mhqPUGNYcjVxfpv +nje8xHYK8JnR1IE4bKzTLveQ6GV0hDBqy6+IYQQYEQgACQUCTFQdZQIbDAAKCRAK +WxAYNlgCiA22AP9r2OUHmkB3IZqKqFazbn8fMTGcXpZu4+28sK/RGYbU5QD/ZAyO +rYX73QzTEwXoVtbwgX0UqPkdpUnxXKbWLAax7gOZAaIEPgCf7hEEAIrEj4u1PPSM +vFKf6W8gRY2DhVkExbywtIKz8z2kzNt8MN6OEe3dOH6bPPqXsN1Y5rj50Krn2jjW +Bn457hZzylh0mksm+XE/6E7bU55GRH4Vn9zMs47DTG9qKQFxGwl+gG/MjEG5aewD +izcQcLn/8aomjn6vQFmb9ScwMyXGrIHTAKCD+fz7Y2vJIO3p1+qzpbLenvDxZwP+ +JEGOvkCDFi2npxiXaCwMuNaNhWO76vYRAlDHuN06KgAC9C+M8vb1t+Eexr1Xl4Dl +pAwLQsJi/lLlt2DNG9zPgxSA7f42uNYkLYjoe3S+b+XzBUFSCorPx+g4tLMo7BP4 +WLeTKgQmBupP5L3YvHpnLjHiqc8YHe3uqTOR4Cr5NCoD/jHqc8t7LT4fqmmHFy7/ +/AjNimvcIOPMRS0hcyr6y5LZXh8RdE7qYfAWg85VHeAsyBT8aN8jxw0NeJaE5A9B +F7mEE4WO/1gADvOcs+y3gw0F7clXaJlF9qqG7zMy/dlycvFyCgr+Wvd80QgKIxSu +93oHs+NSZdbP6wh/xbT7qz5AtCVNYXJ0aW4gdi4gTMO2d2lzIDxtYXJ0aW5Adi5s +b2V3aXMuZGU+iEYEEBECAAYFAkIsHkYACgkQ5GwONXmN2Vzw5ACglCq36FmvHKRQ +SZZhIam9MmyWQxkAn2JXAQx4TX10xFbhZtduKC0url+fiEYEEBECAAYFAkIsHpQA +CgkQTXj5ne9DlpDLIwCgtnTG0sENXt8BjaQMwse8l6olt6oAoOoY01MVNDeHlozp +Yxs2Dp7waDL0iEYEEBECAAYFAkJDjwAACgkQrqIPjB1FxosvYACg4uQauBfT1Zyp +8arFCJ2BJnRoLgwAnR+feTbFfGYjUYXL1vzVCMiz5/JYiEYEEBECAAYFAkJGUIMA +CgkQfOGOMFbsOIhUNQCcDf1vKVn1vqU8PnE+DieNang/oloAniEvG4vdvcefkDQp ++5zJy5XJRrLJiEYEEBECAAYFAkJGWDQACgkQ0HvsSTa/g6gG3gCdFheYU6tiRYeY +HhOOXLBC5HciNYIAoIaKAbgUXBQvFQzIg2KVPYjuHUgSiEYEEBECAAYFAkJIFBEA +CgkQ6OLMk9ZJcBTxAACgk6HPFJ+/gwV2h5o/9ymIKpBqNz8AniQwutpJOtLK87oC +6vorjqMF+SBKiEYEEBECAAYFAkteScQACgkQUj4UN0jIxgn4QQCffuhppCAL8iCe +7NDB0nxAPBtUFqwAnRUNIic+YunNMBQGUz3T1Gaud3gIiEYEExECAAYFAkJDjNcA +CgkQv7PtmSbaRoEpXACfWBql+6nr5NH1rdVfECdytI3OCcIAn1I0hYiC/1BeoPTe +RaX779bpvdlEiEYEExECAAYFAkJEFlkACgkQrGisBEHG6TDF+ACfURfiXHgfSg0Y +Lgt5YRFpIm2Fd08AnRIXDpNbSFfQQ1kbr+oqWYEBcFtKiEYEExECAAYFAk26IqgA +CgkQtmLE/CpNF/4MlwCfY/53QTioC3blYJ7sCb+PTkuQmasAn1Lq2N+XtXyBaC1R +v4bDFvw+NiKXiFkEExECABkFAj4An+4ECwcDAgMVAgMDFgIBAh4BAheAAAoJEGrw +U/B9ncjSkZ4AmwYXYNWrbsKiTbg76NMd1kSVkhSwAJ9/q0H4PcDz+1S85MtBF6JM +VRi9F4hZBBMRAgAZBQI+AJ/uBAsHAwIDFQIDAxYCAQIeAQIXgAAKCRBq8FPwfZ3I +0pGeAJ40Qg3mjh2tJ9QQe2wwSghQEoXurgCgg3xGUSjIbrfc3xN/Xepe3z8iu7aI +XgQQEQgABgUCS9xJSgAKCRD67xKTbdPj7DtYAQC1MRbI2c2UAi6+Uux+XQzhG5iN +ZpbWW1xOWOUhGDjiwgEAzvsALiyRbNzJaSASkYz5Absv4ZkryifxLD7RojfWUZ2I +YQQTEQIAGQUCPgCf7gQLBwMCAxUCAwMWAgECHgECF4AAEgkQavBT8H2dyNIHZUdQ +RwABAZGeAJsGF2DVq27Cok24O+jTHdZElZIUsACff6tB+D3A8/tUvOTLQReiTFUY +vReInAQTAQIABgUCQkNCYwAKCRBxI7wT7Z131a8CA/kBNQZLV22YUogScNFuj0nc +PQw00YuS9lKALyF0qfA4x/duv2eXVKfwNUcUio2ln999Gknf9ivrRV4kijHcWVIE +Np7IVD89kGMDR4SLHenjcpLnOFDIZ1DoqP8VVSYEW8+kHeiONCWzauVTDsu9EMRp +yZpch+qR/24TaypPEQqx5LkCDQQ+AKArEAgAkWo6Qoms6PY/CNQQGVOX8qsKZXjD +R4AsILlgkz9aE55NMVx2VHSOJZquPCZ2K0jvQI7nkuifNivxoHzMGYOxz7eW3erm +YWtnTT3HBze4EG9MTdV6bNh+Io02yHDPYE/AnqYqA6C338I4jDtxa+x8J6pqClZL +9RSehm5fp0kg2rbSsa90T+N6TEvxnnRgF9j6IRda6l5q+Li73yXCug6Hoo4UKnNM +vjggzokqhN9Ys66NKvDI8KCGLO6/56C/znECQus3JcQwzlY1BFe8fScGZM3Beeny +YkHoikRlUPytpcdreq8k5PPm7oydRoOV7cduyvE7wDq8n98eesPt7x8zjwAEDQf9 +Hr+A/WtOMNpvFZVfBC4D3U50ZWV/ezUMCAxCVq1QKkgASHFxRA6Yxhx+zaudhxMz +kQDO/foXifpgGJeZfJ4pfXCf31ytEGKOqCYgMMWXCQGrEXWn+6eH5jN05F2sQrNY +02RpzX97TwKGow8D9KQaTHf1qNYZ5IG5us1KTJ1xday8jZSuB7seqhql1QOCpIDu +pYqAPSrfFjY31BO+MsJ2euHKo9YsH/eHy3E5oktLR1fnYj/ijYTlkPU7I+WQhiJy +Vka7JwC/FImCNtr1nR8P3QZOtbmo8KbNuVE7yThgNvRCLUSgAFwhzbfaGsnth1Zf +BWcvVFWlMZBg6wPwpwVHMohOBBgRAgAGBQI+AKArABIJEGrwU/B9ncjSB2VHUEcA +AQGH/wCfVQEXMylq56qzEG1WR3knCVZNh/sAniWzyYOkgZM5ya+n4TTtFpLGAmXn +mQINBFJU2UcBEADD4P4XByL20E7Jl52AJupqSe4Vv+SDSVa/60RQajNJ9lks6Jod +nTG2QKY/PeEGBvxQ/ifbynV+z648Nl0p5aiRGPSDqT1qYr5pD9Cf1Lb4uHGTSOib +CFr9HYTRyKwXJBGILlusKlMgre/RhQ0oh6Dn6awzWMWkQNofqJ97VUo1bgctDJPZ +zpGwYf4tWk6AMr/pMNvHdLEcTqUD8WCF1paYoBzhZhScdsopVmJSygLTNC7QT+Jp +AD4DKOY+M5kkneTv0VQhmyrLw4ubKmy2mvA54Sg+RdP/WrYOIx/MAhK9K8WQnvkh +1jzcCnTi9qbHzfCo19XOkII3cYb0jpbrKrBomYC9eVwJvwW/FmuoDqMcxPEajem0 +Hjngrhw+MwxYTvmBalug7RKuNpxs0fzXnflwYD0XT02RGHtF5zhG0F9abr3I7c2W +zt4SXFGZZAh8MRrXIuFUGiA/mixE3JP3KvxkAVGUzd81hltmb6eoFjBQ5Er4EoDr +YPgcY6Tzd7SZP6SkydXr7MfHfvkxn1KmlxC7ypmxTltVkTF6TzY+ygiQxpF5O1NV +aHhd3XGgbKN4Vp7+5PdtFI1nnaqFhGctu1vWVZxZ6GmdvHz/oxaT8z13K8oGVlX2 +yiJdH0ItEj1E8J1gJYgsYrHLKLq3reEjkg6qmZEGDsKJQXyqvWadcE1jIwARAQAB +tCxCZW5qYW1pbiBQZXRlcnNvbiA8YnBAYmVuamFtaW4tcGV0ZXJzb24ub3JnPokB +HAQQAQIABgUCU0mPNgAKCRCIFZwkgw9vfn88B/9qNBkFZsEIxM6iEcvjCskCrHGp +7IKgZ53HvEAvzEP+IXs1qJpiohvI/X8M2szChoDEiVIxAvTtz1v9TWJDdC7EaVdT +89q0YHIkYSLiKMwcAySvjTSYnJwgARi78VwEjAXKNtGJKmfQZyz6syPMEY9nTeI9 +8EuZhrBz4APPQd11W7+BqRcezrvtLHqh3az0lRUWCKwCZqQNq76N4bxjyQzCCAg7 +Ic0BLrdc4SB4JW0iDDXBvsZbmq6urFv3pfkddBD9qIpkPNkv3t4JyMtVgMEgFARO +5goQAUc0J1qZDlHonXB4r/FqtaW+ZTY18eTDhCoTlPO/51TRQbyevKXvn4c0iQIc +BBABAgAGBQJTSZO3AAoJEI6hAxVJjBV5WsQQAMpnEx1fVFfiWmpCTwjYP0GMFjCK +VwsjNt1tyK+Kr8l4y3Dd6v3aKHEYJxOsQ3Z+t3JXQB5i27WTRhhvfFdBUF1ZfgoP +0fCIBxPgXbwYYK4QO+P5xod6wqBFG/GKkCPrM0WmIVMk4dTdj7q58RZbI+UMrkQz +oz23PwotzVOb31SWLF+MTTR8U1QhCKVkUFEyUW6ZUgNNXrYxii/+g3Wrd2k1X5zh +bQ3oBfuwYEER3KhIaMJjwVR1r/oFuucXMTQeItzzxsmpVdSGGrom6EEghK4z6nWj +NLovBf86dEEEqOAIlteXxGalLVQlgz/PSulNpuEttKeXreJQ4P3f6+gKp8DgvsYc +3uWDNXZYdO9yA4PqvnXc68ezUfMDPwv5bare+mW79Tg8FKPhYfLQSmL0LCtwz4Bn ++iTgbLxZAv3UgXe1rRLMQcgt04fPZyFbWPwGMC++YPjvt+UCSMKnipt7OeNv2vyi +e0IT7Ix3y5WzxdyYLDOnSYZlHmUwLaM3ajHQ/bCWO8qzVEoCuAnBGk/Q0+l8M4+O +NgkaHOB+vVmEpxCE/2mNYJ1y6dvyvHfmsTUMa/dAYzc+ELQ/pcD9nLmPWubwzZcf +FXX+r3DKiLFspv40o4qk81IUAlJ8eKDacGrj6u4EZeOWnniKhtNtfDxfPjwhhwzD +4Do/5uc8BC+hmcy6iQIcBBABAgAGBQJTVSlSAAoJEBJutWOnSwa/8XQP/igKBqKR +Q8iGRl50x2IMqh3Jt33/SwW3MAwSihhPfF/HMA6L5MbcNQdjmSUKIGwBmSjvARXv +CyDSx7kSucG+ngJrQNdX2hElFylD4oTb06MREsw8fXpXicmbPBsagueSz6gr/1ID +lGcGVMMfcmoBpsLdKhvhHuvC7l0kQS3355B41oAkawyJBx+zNuiwyHbas5MEBdAe +4H6WNAOeRgsLTjIboRcu3+Nx1itGUc+uEvLlC9Vt61OYFp9EBB/OWJLos97Pgpdc +yoepxSH4Vo9ADDf1Ne5sh4jr58sU4IbvZjBDtMVdLftpa9EDVkcy216xISH/4CkK +ks8exjtIaPGl0Y9fBoA4PL5fEOUyM74GmB3GH70Oqpyi9e/8jdtdCIVmspLbRfbY +6mMDRrP1c1XLvjBQlJ1TvgWmCs+3yeQbV7zlYA3GqdgHFbi0mYtXl28Qs8UUsBDx +k1nIrF3iLbr1xkai0/BXpvdyTtYu5lU/myeMKIGSFvs1AYcELb1CK/mP/eqZV0cd +em8+Xu8Xdk+gq47afLBLHKsoxFo48UZ962gziPoRRJwuAVgOmN8buadp89Y2in31 +96+pjtJ6dmG77Fnv0rg2fO+qSps8ObZbjwVJl7Eh7Ic3GR0YSCZrOHrSVnkWWVkf +5Qab+A2u7lruOeQK4t4kCJI3U/wovTJUUVJQiQIgBBABAgAKBQJUTAEvAwUBeAAK +CRASX1xn3+lAhIVHD/9yqtjtrqw64X+FHP7w0fop3cFcGvl8h1CmVBf20KX4nqK/ +HkrTHi5w/woKEp+OP2NaSnvgoX65iEgW0p1HyVXVq75J5e7e7beBZX+Ce6DVFLOB +l0AwJvAKWo707DC/hQo1xK5ARdY5k0PiTGI3ykFShQDZCQcUFWsgozRG7/zWcof1 +FK3l/NZno2OTMYesV9JfctcIoFGl3kumxRW82spYEW+RRod8chsocALXIsJ59piG +z60C769CBO/KaSK3z3sVkYIShpmbxrjbeZ1Z6X57ObSe9moFTbPxgjTk47SopS/+ +Zj1vKEgkecPi3+gZEnDOMUUnvPED0OJgbbPlE2VodV7XI5PhwZg+1eXZKsgVd34V +jZEwaZGGROpqzjvLc0U/m77VIPBjsoWTxPatowcVx90vTkCXLfFF1yC56vOp4/io +T3TxMoUlmFvV+O4lxB22IdG6JAGGH4inaJ3522ahek2fP54ETS1JYKPWIaRbZkpB +vUJ/e6Vo/b6ZiW3HfOMEoN6vSEgxu3NQc/h7wR7OVb3mU9aC0FbMiiq5VVPnMb9v +PWQJ6znITEPlNyx4NkUiwPnc/oAlfBmd4oUkfNByZ9G4kNhbpKZ6i5q3QmZ5i+jd +aLBm+JevY3Q9KSLRHtJXDEABRgfrHMCpqMgBKXOunDwrgNA4BI7jUI9qy4FdDokC +PAQTAQIAJgIbAwcLCQgHAwIBBhUIAgkKCwQWAgMBAh4BAheABQJSxaXpAhkBAAoJ +EATDZ8IYrdT/JUoQAJfbQuRLTwRviwXmLq4eZXfGQlQU+SweWHDNLbynpngoauRJ +u5oMI5ZEvt0iUp38r3wrhCpfI244D7DjGfO85MCdR29TJ+P0ONGA4qLmchGZ5GeT +TXmqAbrQ2HTu2UUDe2TJoAIt/b/+77+QXdAwR7ZdznC3wyjXZngjivVdnLLqoBCV +OvxBKbu99otPSQPEWaU/NYkeir1S/4n77IfmVVdHXGgYyT4P9KiMoe/TTaJd2q8r +huu7SWfyjMwiWEJeBd1moL+nS0EZAqt38Sy+tZ/02aUycRWwsSA9moVzBQJA6E06 +XanegaGTs55BVFDmwOGHhx18wNzg36TM3WEPiMhP2IPNHL2oPdsmgpZhxiwrkZ5X +BKwJfjMCXuzym9GKycKKr665e7mO43kKvWUmuc5YC35/wBPdLdsO+yNehruLW8Qw +HjGDto+O/VK7a91PhSF3zUIWqGFbv4A1eAQRw8CWaamzYCPQmhJfcw2TYTPU4+09 +/X0UkjkElJqS/hBFUkshy674wjwWhrLPEBidu0KPrEI6+mgvZwbJL/e1VJowJx1a +jUO+QmTJlhCONYTkcMTyrtOGMum+JsPPJysqYutMoTEoAcoYQ6jp1jTbSLWAHunC +iiLICnP7ChogeTHxdMbOWjESlTE5c0MvyrED4WLlx8YN8O1rB7h2Hng+HvroiQIc +BBABCgAGBQJUVgIFAAoJEC00fqaqZUId+MEQAMUkjsl0lEDSBnR91oaWnsKxQybo +T52cbFaIuIJMWiLGRei+Dg5E+NEWp60+iFvZM0Mt17lwtGEf/8Oj8PF3/KQAmovB +UwyxXfKoWuLzCd9MyL0v834Nqjw6RzCvtP+PfIHYbkQxVfHg62pXl1aM20qRgO6p +AzvlMHwUX9V2FCCrc/lh7qC5Z63s4dsB0yaTjWb5VCkwwuOrbSH8wTX/LKMOwZ2t +ka+qWkDvBSZXuSbLEZDAbtWteqXkd/x7VNFfAP1mwEWijnz3OBk7NpJnGU5CvjCx +QAggk8KYnleeVrdYh6j5ua4vXGuB4AvS3TSs8z57xv5Yli05BQmUUCIowir03dC1 +ee7BDcGVFn9/eMW2k5kSmGrh6KaDjZV0sbpwqzjQ+BxrOhPh4x7l2Fog00Hq/mpo +b7TO7he0qNkGRmkItGmXklKyKb8ix/cyfvOB1EJCmzCzc1w0BCbyvNOx9NWm0sdr +zLaAHF1rvd25Xncg4lB98HmsCTWTIVwezVmYCxNeMQhrBFVrIGT+GD18SUvrDC6I +SHUQ5neZcKNawZv+5Pf/IOL2A4k33Gbv9vx7rJOExI/nk9johw/Ck/LM3SpxPYDY +GDHSAIRt9SZi4FSG727e523lVxg6WFt3EjA4FpRpq6fBz8BQpH4X5ANIQdUj/8rA +RVnRBFAIQL3uYPhWiQI5BBMBAgAjAhsDBwsJCAcDAgEGFQgCCQoLBBYCAwECHgEC +F4AFAlTOZiAACgkQBMNnwhit1P/GWg/9FSSvHJudzhxop5EER08gQVag8Ba6WGnb +qlRCH+KufinCQnNQBpRSO/MVJsQiAbkW4GH2kkiNLRsJkZe4+aSWqyHJ+VERoEe+ +Za6Npos63Q86DlaA/FQIzdDqwPHUvDu9jAvlyiNv0pZ1A5SBRdimHWAdJRFgJtAA +stV5RD/Cg9mXpCqnKC4zhXsaFtNgkP+xpVTURQkZFGSeWcamVLMmUmR6Xf9/j9WW +TTXc4Aop5kg9NpB69lsDMU/apJhiTzg6yE6IcPO/Is6VGxWHsAjQXexdSrS9d6Oo ++WPJs7k69QGHIOsko1Hw6KpEibwL676gexU7nt8+Y29ZcMYdzvzWOE9BTs44WVEm +yPpH+BmWdyArHgRnFUQEV978ArPF6etyGBEU7zQE3aBc9jxFCauIOpb5MhYCecQI +25pESfl66gXRmmxKe8MpOd7X+a3+4d4jBpIeXIZZrpJHjOmkVjFW9vFHNObUxfjc +pYtp7lf1/Jo+pyht3b7w1zYo0UnGuJkcJvN3SmbI6wqXv21VGnYR0g/0QVprSLY7 +DhE0LHc1zXOdg4t9zJghK+UforXomnSaBBnJgOi0/kv5obKviCHqLqt41IjCoHdz +yemny1YnRNb0SF3DWIxlVCFT3jvSPs25xZo8klS1tvF+qkTS1eFzSfAUnjd/4EOv +5P/7upINwuuJAhwEEgEKAAYFAlZqnlEACgkQkezo28rFwwWkFg//VZNP6koix7Ks +b4y5+YdbKhcsQdFGyFJyAEWLCtxdRqeJASMr5+8v3A/SHxlhUw8AvPAl6H693Ws/ +7CVssMUXbZ6pi5s8Q7oxlN7Kvs9ajpTkrzWlSjYEfyVjIaWPyFEjUmskjXkI38AB +/3tKinsFD3ZC004hjj9fLSF5hk+ZH4hVIcPceehpy1zZUNRxf1D6FmuKLmJSZ17q +zCF5q0U47BvTF/AYku3nacaNx2yMGLE2jmoSb5kXf+sO7VfM5nGnzv9xeHMLuS0n +bPZSnpomjoIwSwO3yns1n6wrhbID9lFkAqE6XRlzES15pgjXaAv9jW5kGQHNMWd8 +HQFOl02PmTKz/abAIpw9R7t+wULVUK6GSQZkYT9d1CqMgBe4rdy0YtnANSOqsmvl +g0k7kh1H+2iwowljNWoEjAOnOmtYXB5MNhoDY0LPPfavr6osPhK3VhGtyhXyMxw4 +3tJAPDlEz8UWajKEcAeazC0RH4crt94eJP9PQ2FYLH0WLqApXbTM1mI3PRO3wUEy +06iOOSQcGHchTUPEZ3roorqe2V2Ur2z16qxZWkPy3URoIONKlJFs/ZSRbiX6lgJE +O57lF4IuQZPdfSTOlv6lmrgyHvnGZBexRJf03argdCf/IPmUeUvpF/mSIlfEHsdn +4QPRysRbG7KVMgn3vougjPgKHPPnwDWJAhwEEwECAAYFAlZx63AACgkQMJNnUbpH +1Og4vRAAo1TtzpOHsvMB7KEgzzW4YKT8onVoSMQDSCYilAW6DToDCOTqzZzBaysp +PYbwXa3EdS5uc64btih2JF7q8aLHZ8d4Iy4BTYTHsw92Rny3ICEzBfHKKZRF4gTA +o1SWalJ+UdSpJlpv0VDLa+LfXiEfk77MqUw1IGWq6VtMBJuTiOx45/RV6KZ40HjB +nrjYiKF2lg7YLiLzomtKIBQHyisSBWG6/nmbjnuGyhDi+D43b2GaPR9ki9YdwCs6 +1124psPhuibN7pR9sK15mpGOYrcIgdU1++pEdJ3y2JyeJwM8WolECDqK5E3y/9RI +rbXodRbsc4bqdI87e3UEtP137SkMiie0Mp2C+MYqoW1iORkmWRj+0aaQivad9W1x +cqx3rNbeAxPqMw5QwzMTkglaSELPqdMLqcsh8wKjSIHqT0raiqUzZLkHMyqK7upi +FQTmshWyMIxL8OU05oqX/B3NkHE/DTo5y8UmAJ7zRizbUYO3NbFyoFrKeUZx5q5H +5l+4VvZOZuG7PpWfV6XCJ442olGSvfj8ZsvXY9mK0ugMC+rEnCqmo1rwho9F0ur8 +8gPX/Pz+SOXXazVQnGFzuv9Mpx/eQj5I+s8Rpgk1pp2yRakRiA2PyZpXzB+QVVrq +QtcXR5W2Ea3N6t+tJVaEY2aMm0z7KKH8sl3cdrupPh7Z3rgV3LyJAhwEEwEIAAYF +AlZx0X0ACgkQZRBRqo7+BlWJhhAArd/CUL06GKESJTMZ56Km3rYADLv3d5BXni1e +KSCrpwkvQ0xggTlVHesZyyrmZXecP+ZuPO16gNgeQW//yJgrSGO9+bsV4buhI0ae +Qy9qAyXBu1/gK4EPLW8vGRmNA0hcacFitCpe1zy2E1h3YclfPtGvV/ZuEOr1SRXn +LF6CHz/g64ugswoNHcJbvYBQJ1pdjzKaxEgk2dtm5pQEz9h9fM6e+SIePSJ5FdG2 +KJnkDMKmxttdeWN2GwELTpy1NDAc3JFjsnAzEq9zs+N+w3k55wlPygLEHIlF7Jsv +HEHaTAl4h9x581YcuJTqX1NAOL5P+mazQVH5L8uG35vbnlfUX+t9iJ7aSfbdRjS1 +zw3KuMs3hX2fjpDk62mtKPPO9GjScGK/Vilm39DCc3FN2PppU5xoYXgSGGcW9nXU +QrUPnXosKzoaSJr94fcigp0SjHvE/IdsEyoS1Z7U+OsdeTxA1tJjanJNjcZ5IrbG +GteWuffoihFraVNQpgvHiNDukPfHJZxttqIb7/CXF9Ec//H5cX40fIInmMwhjdtQ +8hpXV1wQaXRd7Tw6hsvxSItLbByJ/IY9l8EAU6symatr2D7LOeA8YSXGsAwmlxaO +EkNoH2gYY/NvuwC7lL/E9sxTUarn+tigoVwjJS5vy4iwTskxaztt2kszDVnkJO19 +WzRZr9WJAbMEEAEKAB0WIQTYuYdIBrQCx/ecP+tHXYGfhBKNdAUCWxlT5QAKCRBH +XYGfhBKNdA9eC/9HEu7q2/gW15gZT+sNUP6uYsm2I9u+ynHAPuIHdxQg5Js0p54K +n0fqWqjtTHM1jcbPl2v0uVvGNlFGHSKWpaudLpT+Lzs7EKlyaEGgl6Rka0ypQ8cf +veQdJjSF0S8aibR+EhjNsvCBbygSSFaKikW+iWjG0qAA5kKVD1IephInx0bL44ok +QWAVAbnwWAfJzASW8sIEBzzsKdzvfQaJLmhRda8l4b+zWBfO2CJJ6ctPtQZ6M62n +OFtuvS2R8H3qMtzJi/j14HvH+yHgYaNOU5Q2gA3o8HGX5KINfe2w3MU3F7Xbcqt8 +ZXOowlWBEtutjatLHxji5E5siocZXTAFQ1P5n2q89NWjTUVVIAdVt/RZFWMU/d5Q +TAx9F2EoM3kiU5+RLcSVXqT7Yc/I1QNc+rTV6AYwKJvBRyX7SvviQFNUyThCtWpe +h0/qjm4xBqyIWlco/jn08cxhFYNs/s9bFp8xOchUwjoLxhD6GIFAEtm7R2wJqo86 +BjagN/Gds0Wmb7a0J0JlbmphbWluIFBldGVyc29uIDxiZW5qYW1pbkBweXRob24u +b3JnPohGBBARAgAGBQJSVNtnAAoJEJnN6p2kE1s44tYAn0i2X4d1RfPVHUNLRSI6 +Ex9TctiOAJwK75OnGVAcUP7EwDu8/58P4ot1UIkBIgQQAQIADAUCUmb4hQUDABJ1 +AAAKCRCXELibyletfDY3CACU7jj8dSI1sUOWbn6MRqKj6zVhbdnCLwcEra+gWHj/ +pkFroqRHeku1urP8WZ6EHS1t3/DmpIY4+rmoPmw3D/jvGe6vXIBBiyBy8BvDCl5c +i0mnaNlbOsnyk8bHeXm2oQXYwSe3/KgTypil0fxehnewl9AzvT2Zys+o5kqLMHz3 +nBKDLKSNbfZyARXGK912K0nupaWcVaR8g2FHV6QNq5lUg/p2vLGpM8Egslyl+bDE +pKIgY/rbWwXggV0fztUfUeguyms6mNFQVo941VpvAx5/mLU0J5jfUZVFS5MZ74Et +pCZGk3SIBBwjne8DberQqZfa/yGYqXXNC0X6x1z2qz9eiQI5BBMBAgAjBQJSVNlH +AhsDBwsJCAcDAgEGFQgCCQoLBBYCAwECHgECF4AACgkQBMNnwhit1P9AQA//XO8Z +0XpcIekPPjDHXXa+8TM66Wl51v4CG0Q0792ZQhMq2yCkdGKiLd7/SI/v1Bn4yvt1 +DGsyu+r/tsJb++VQbmZkViJeTG7GnsgPbHMEkZIWd3YdFjR9o7NFWNK48JYoOUTr +VrU/QVWaqvzB2gR2unqqZT2zWURKlfizQZL2pjYyk/yxH6IeE0/dGy59ZbcuxErN +7bLOCTBxlR3qxknt4jtBO6A/EV0yXPOMRXH3JRSfEHAEAhcNCrkwm5J3UjpB1eDR +3AwwiqLX0+262otfXHhjAapyl2NKbfEQVoTneIH5UfmxwDVzWBosKQ4BODWqbFrr +IShZYBluw+TLunbLnrbOswbwFvlGbSo6lnHRPRP3prO+nLrdCHObKRv/MQEUrmXB +9OKbBYBVBx9gY7IMXDU1Ou9kwF2udpMDmHAnvRc4tX3cXXtdqO6F5J4OYQnEZywS +u8e/Xd4rG/CLBwuPZJt9tHluV9E8HTxjJAvV/EuhKdwLxt0aOuB54R25MJzx+A1Q +HEPYIKgzqfslIxY51VH+KW5RpHhkUPePduQLu1jFx8lP4NIrXRb5F5Konq7ZACUK +9Qk4rrTqCsPV2ktb05sMkh8z1xAp+FrxU6wjsZpuyd9mJy6yiVIZXubLyK1XXb6b +LqKn0zKEy3XahdSvGtGVkQpqi1JxnmFM6rrrvmeJARwEEAECAAYFAlNJjzsACgkQ +iBWcJIMPb36O0wf8CNqjPocys9T675X0NyIWIGwFLgaXWJZ4ZphLHZSBE5SlROeu +6jildfem5mkOAn9WhRZiW+oTC3lmo3BYB7cdJG/ZTSgOCM5yoqRy0NcdepmRr3ed +tPtwijeioh0o+3jdGQM3s8pMftrwveGKxwhwrwFvEXLq+aZVYdTrNXTTf8I4a8XK +8nsBe9qgqPlHCOnyZKI709AlbuW6dPD2mfxjpP947Iate1ZMOAh1zswM7z9JxJbE +4KDT/FnDESxTPpgfmV8Q5ephQ1EE6fYzqMHvs5PmC5kEeCT3msWlJT+6pXvY5B8n +WtsBPa5YCiaAX/5FYUtIBYaF4GNzEZdrQVFIU4kCHAQQAQIABgUCU0mTtwAKCRCO +oQMVSYwVebhDD/43MrXhYknVZZKDDw9bpErIE3GTf2Oyzam0+zruacbKsCLXvsml +6AOSQVchE2c0SkzowA5Q+9sYPcZYCDewU2xFQ/76fV/OKJKEZTYvXLhSwHrEh2qw +BKilCzKhmBe0639PSvRXNye8ymRvVpyhGG5Qjl96S9XLEr0aa4bb2P6agb/aFapf +qMPycY5aUvj4I/d8+u2jrVKybHnm4OeTm3PXvYEI15f1KtTTFugIMwEnUkq9UDw8 +z+eZgQ21wN4NTAU3fgUA5Ud809lW8XCmXs1l1feU0rm2ADedahETgCVG0RynHtWK +k51Ili+WODKRq+jvr6leK+quWJuRsYyafXRtaC2hUwTlfaIeTuTErhkgAKjhYhxo +gy3g4eCsqDTXZ8mcA6nAT6GRkY4GugugyEiDzU8k8bD4Wne6OPIw9J6S5b3uABzr +BkrCCHZ/BkX5FXK+7WF6Ol20wqZVEr40Ar5JEqzhyD0PUIumQLB7LfUHQfi54ib2 +hite4wjIyMHu8dj9VMtsl+LTCbYkaf1vunDtbdsRwZiReIXWBAxZq1tveJN+fOVQ +gzroWDKdFZGWmJKgceLRfN2W0JDPX11lqm6xLk9MMdGblJMRR/3jcOCy3lG1RR9v +panmhcLzy/qXyISgYpM2tKR4BnCf/FF5dMxZO+6I7YKLpwujfa0ehMtn1IkCIAQQ +AQIACgUCVEwBLwMFAXgACgkQEl9cZ9/pQISZ7Q//Vl5bTc8r33o//kWUWIrCabIj +kGwoGJtF+ENE4ab+YgpbHOGyn8EhwsluRbvg+rYrMVcar08XubWguEIsxdDbe4rV +uvmrarkRP7Djp0UHWUwuRzvbfJRVfHV+fjwnk3BLzUk9+rr/mXMWMmmTwEdnBVun +TAAd+/LuSpd8ksvW+lIinYwlY8ErxJleD9eu92yaEgofMUVbk0WPpgTnlUhPKKy8 +x2+jYszOK4HNaiGoFWimyuUxULjdCIXuPH2pWCSru7PtIxmBweQl5ELqSp/uQyGE +naAiann/8G/c3lXQIXbXwmx4r/mpllrTIj6/D6mv+OQVlBB+PUtGt/uSIVnCTFHe +H+apLHs8RfywNphF6PeqUeaMeoVPEG7F0pYAz7kxAG8FOtAZ6TqUFsDPWjsfqsgi +nc7hUunuEHDddGDB3xttbEDGyq5BbWHETlrfop7dTASCnNEcViC2f/d/n6qxOHe4 +hk6CvVG/l+cf+Kaci/TB8J24SbHqqaJggP1bPCviwvAb9MF4Js8xPpvhF/K0PzKt +Tdqi/f/1d/fYlJORrKTxcaj9TmLBwh/JauTIlVPsomJB/1BxVXw7ewEe2SJN5BZ9 +wNRMkrcYLf2h/cFNltmLVXDnTrS83pZLobfn0r9sQIukFR27sX/jIwrLqKRjZInF +7MKaiXpkOcFzNr0uymmJAhwEEAEKAAYFAlRWAgUACgkQLTR+pqplQh1lixAA6FXx +40AdJWg4SkgnZqB7fLA3cJDhvr2sU3JjXqE0ZEjQwHij1HWOD6Sc7qw7mdR0Psnk +pri16P9AX9k5VzRPfE9QR6y9DOw8LFSYGhmyi4sqVZsmg3EauwVG6FRNXL4Ezdu6 +dKrZjwsN3TQL5j/nzcB74RwsTF911kpdjLSgWhPxV73ZX1VsqQ5lRox41NX+aF6K +DBGqlERF8FJb+ycw6ng6G5XZSM7YzTXwtxUqww1hVBq+LNyiHdCbYc25ru72JAiT +JZPqA2A1mDkFtyOMRTkPtP9lyvDPMLrBhnkARJRmHlDFeJwVGCFIsrj3fGeAEn83 ++dunpLrrKW2UGKDaLi2x+h9SRRUn9e473RJcUu9W3qjbc8x++/07yt86Rfnn2cRP +SJZkZIRboDpY7P798IDvjGbHjQrEAKTksycbf+AgKo8E4C2YyEjDSx/BqHlYZHSh +v0Q5DPl3v6+s0OLjqpCOkjEfLD5e7LV8eue0gXTaVBJTdbpVvpb1VJMQ2YjsJJ1W +fVDA8Sw5q9Ica9stsoNWixnkt0sfFDAzzKYNEibM1iC6FAAgjrpPWqLbvzQlOxj6 +JWTj8BXxvtfgQTWV9GrRpipI9bdq8DQ37dEyyDzLugFvTPoLpTsRoJCSziANKdnh +3h31OBNHyMom1TeL9AJjxegr/IUJvbu3DkkL9/2JAhwEEgEKAAYFAlZqnlAACgkQ +kezo28rFwwUTlxAAkBmc5RUsLPtD1nZ1M/LdV3G2K7Qn2RWvdGzd9roNpe6YURUm +rbJRm/8TiEzXkGuMq3XKo1zc3Va6Q/iP7FckjDOcThLR/NWWj/QOZLpH35kSufs2 +3O5C7EucHyHZ82x/w061a3DEHiH5SS2BPqJ9mg5FiRZ4G63OhamijmqoUIwVgQzh +DONcJyjf5Hw15ChZslKTyDnq4vB7ni6oY06xcftcTCJ2jac3OMXSseL88ZruxyoO +lbJmnsdmBYJwIJ2aeucQ6wujZAOdkg7eyQ0MBIwWfoBvxPQyHa/Qcu2S5GmMvzYg +hA8TtERDV7Qqj7PxWWuytqj+sEBmLImVFWXp6wpbqDjeOR2gFkm8thBxyWtx3Roh +ih1OuRSg42HqJ77xuI5dkCwgx2bfhIPQl7LO6nD02t8eYU/+/GtXkevrwLqsptfu +zI/0UfDzkaFhzT0UKWVzZIq43IqUdyZQuuJR4oOF+ZfeMyp+1a/nYHPUpJ0j8Bpw ++pNlRyWL4AzrdnkXCn1tZeeJaEhl9VFMHM+s1WtpRYwYBVsaQAUUA4d3QKNBwA5R +oN6OAOfO+nELU5LmLJIoowVmU3Zty5eQqhz+OC7anM8K5Xd+6YA7V6E2ESjBIiOf +F7IiXKTpvQ+0ngQPltXBFbQNIJr6ydR7jjmMOn4KGl+KOSqNEmUkeP5u41qJAhwE +EwECAAYFAlZx63AACgkQMJNnUbpH1OjC+Q//fqkPKJ9BfCWg0EqmHfT5JEYWc/3r +htCvfQ46zMIsFf1J5LS7rhVBjBYKDSZdp4Ei+MCAwJOmetJB4xfzkaMMk+0WMfEk +/+Y1h9hzAU6l8qxL+UM+e7sqbWzz6pC2OYORJANIYcVVOE9ft5xqnEPGDnbFNGpo +NE1a9ks2SGO1hgTeIaxjKfP6WOH+nqZSGFMoiYBdIfPaw6fSI7TzR4JnF8BMcf2E +kZPiFLEat2liPFbB6fUftahYvjZDpw5+J4zc9d9S19frzL3BbIFYDc83P7czS5p0 +BSRqiM43XRbXIKWpa/OoixcLfJxw8UDG2v3oE2dTyzMZqqydxJsANHHVldJnwLc4 +uRtmR+lNe496VUUcKS+XSGA/HP/Jrd6O8XR0wvY75dQgDsFYKJm4hE9NWDq493ws +8myUPXkQQhcbYsUHv9hZeO5UQi2pP8uWRl/8xTbTgHdgZRngH8nqLAjWFKwZq7Bn +hLG10qDLuTi5jWHIHTMEG8ITofRelS6iJs2Zg/r8NpY5uxvicCy/+NtIc09Km9xu +0Oqo1mjH3QMZDzYqMDjhA2ZcPikjnHYB0/5qb/623EjxGspbda3fCNy6/xZCZu9R +cp3TDgAl8vE4nsDZR9D2+BHtY9aP+raH4yzu8Q/SUGF8oke/+a815lWtCkEsN2l6 +/XJ6wCT8sGMZEr2JAhwEEwEIAAYFAlZqVW8ACgkQ5iDIp0uvXQlMiQ/+PmbSbayN +V8xWo1+pEl5+HI8S6EBXGlOWsbiz4h5o+Xx1SMROM3Ukzm6rKCSmRIZYojnIJD+a +mixSHXGDMxkWJ4yhAO4nDUAQPS8lbeESBL+uyS36MpcLrh7wVvGdobWAvZDOybGx +XMJiA3S/rbiqACBKCwgt+rWMbMOuCdYjQ7AilWfqtVQh3ZawBq50PADO5A/LTb0C +1zjzRYKja6fi8pvus+9TJcJETMEQi1qN8n8h7e6XfqqPLAH0FdcURFmldNX4Zi66 +tCslZLXyOvpa3uyeu9TQZvd0J5n4dMzRthmwnzaM9qgAMvLu1bA5p9OFaymyHsD3 +NFY0/exYc234vFVYJrNJdhe6TRUjwbjFfEIJgtPAL1kDJWssVNcGX+yuWUwEXRO1 +0WB8Amhsc0jQPGMCFKEl52n9GMMBnDfggwyPaaoIk4UFqHYlN0Kb8g59DjPxe+G/ +3TrCVkMyOJG8JcamRhPv++zBQEudT36i+kEYsZqM0BsBQhcmAiUwszcJ2tIl7O68 +0iqVE3OM6VBC1cETOwv/Vn7zni94rOGVVmiSg1Oz1k9DvuMiHZEjUiTHUXzCznQL +kge8Uppe2eVdWdm9LaQtQh+YyJDt/XKIN387CE4K/0tGvewA16EiQJM0l2Zw0mpE +tlaCqkvV1WFe/okEwn2CIQVogSiks6UIF9+JAhwEEwEIAAYFAlZx0XkACgkQZRBR +qo7+BlWitQ/+O57GslgtioHs6mcTIFfAywaFZqMqHE84Hl779yHBUbsfkp6b5rSm +k/f1PIK924nRex/0aGyOUpF53qKqpwYiE8B69u286CiR+TEmXH+qOP1o6NUlK4LI +VNnPbG63gtfSH+GicZAsm1RVqenTKN1YS+dERI3jTHw8il+o5XS34PRHdZzytW5z +kQwDQXqOLgLfgRXDZlsr35u2O0evavnBw8mnAIX/kZ7CuCxQDFQX/fTqtrlN9kp7 +dzLisXcIYRZHG73Vpew4wfeEyPCU9nwzdq6LpZeMRhRkztQKvGRVpzJfbIx78A8L +U8d/6d3ztOedzz5y68GsWuozSHoKHd8ZKCYMKh/EE+PVBTz7LtIJBqQOANFWJVYF +1B5uBRZ7or4Ka6PpYdLY8MsoOEOGemxn+gkQxuqsmWyXD5ILJK5Ob7uo/3rVVtw3 +QJuAEA8sCicYFgJJY7/T7OIdM23dnDZVbZ3WyrdnW1XOyyjkXYMfcb8vZRUAFgd6 +/MHMKHQ6sp87AfYpA4legAKoROE6woJXHV9QkcE8l1tRcjtjQkPNSpuZ/2lbJ4dd +ZMzSn62cU3GIu+SA9RdoL6K8gM5+GvOVgH1S8Dc7pGqS8RJAMaHiS1NdVuSQgCw5 +k+Krdr3KgnP4I/p06AGQ8LougU9X3K1Vd6nW7P91Vl4bjp9YNdErKC6JAbMEEAEK +AB0WIQTYuYdIBrQCx/ecP+tHXYGfhBKNdAUCWxlT5QAKCRBHXYGfhBKNdH7dDACC +5XzwG2nryLrdW+dkUFKjy/4Hjl6k23Ng1IyV/j2fD6dNrqyfsF0SsgbPItg2Ft9k +QP1iu5sQZKz0PhPROAlDKpKfM9KSp7KncIs+nhYOaimFjtrTDC61HZ7ZPDnXe07h +pGWwQIpSToe7ulGyRszTUL1u31tZsJd0REv5O31qA0riI2ZwQbNzAzMXsrNFsA3S +XYmCisXbeyT894KDYwSgdmO6EkbuVGmINY1wiVZ7sUAQ+YFW8EmLEe8uq4AGfUuN +s+NttqZ2cYcmdY81aplWIrZs7CYYBtbhxSExdCpPDpePhqisJc2czBcuCRxHhXku +BtAAdZSYAtz2gOQKdR4bAX8IwpKebRLirSb549yPojATg/XFwQT/BGg+pVBxJaho +NIjUzSIXtFR+vAnyyr7CNsprgB3ba0nQPWbQFHpu8xaDFvkUTCrNS7zYT2S07BPL +luZUVl6NjKb1wOwbetORrJlXQ3S1cP9+/S/bzpFj554ln5Bt12rma9NY3jH6FDq0 +IkJlbmphbWluIFBldGVyc29uIDxicEBiZW5qYW1pbi5wZT6JAjwEEwECACYCGwMH +CwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAUCVM5mIAIZAQAKCRAEw2fCGK3U/9pp +D/sFHePLi80+kle3yDlP/YskSeHiRVCqZo7jfxeC1W6PJmJ41gcW9mlACN+20UhR +zdRJoSB+vy3jyuJSNDr5h1Q3ocOgxmSqnBopuLGWSDcZFZ2KP1EleYeidTI6i4Yf +dFDnY1bF239KP3ToXbqdilnywaBGls7OXUt1MqKn7VKEld5A3H6HFKcQnEF7AeMK +J1hctJq6/R4W6u1Sy2knBpAZASXrqqmATZUoY7oTWdc0AvkwX+Vwq+n+FeUslsHF +sVOqSeDkhNLh+xDKPgJoFHt0g9GonAnEdCycvUfMg0bdQIrHAZVRk7nDQOAwGJMX +mYwpOs4Vk90cTBfJEUmkdwsjhQkcAATJRwlpeonNCIQwNGBU7UJuUNDwgkm1fwsD +1svzM39SUKiwe8wxuE8BLWdP3nfdSQPLmvDgX+vYpHkv+wTrm9AILx1Dv9OCVgE3 +Yc3PKDZerYDtFGbgFKhlGq9nRrpEnLgv0aJwZ9eC1O2izSa24Zun6110/8Iyx19W +aMDAINrjTNhHyF2eyKMkxZNdx4MgfdTaoxzznpnKMe527k6XwZzQ/q1lBBqFDpNY +SCY9AF56KNOOa0BHjll9vR+fWPePg+4htM3B10pQ3LOtvdG/9x5Tc+wvo3cgvxGH +MGRitlL2zEBVBNRcrD8a5+Cnmys8aspuHmeY0Uw2lOXlyokCHAQSAQoABgUCVmqe +UAAKCRCR7OjbysXDBVQhEACCftods0aA/SWUwulrZmB4fsAA3yRO2vFiKocfVGZ7 +oAswG8ys/n6Rt2X8D9qewzTPNJu51qfwISv1dQOLpbdi8XIKuX2mSAZXXFcmUg9E +mIo7ZjYcfKNxD4qKbUR0xfVSLT23JhIK3kpUFC5r/LShtm4kRW6Vb8X/mFsmFMRG +vKJuYsjgqMeasamsjbZyUySUn96ZQv2ERPDynq33CiShBUUG8RivFQ0EjdzZ0r9w +VS3JjGS7+H6AAJuCBAfyW+0NeoX4jDOB6aBm7FSbsM4RpDevYAirZi7xG3FsMOvK +GutTulsIzcirP1ALouisbqvJbGLlFIqQn62VFM6ZnQMblA+ZUzOFBVt24/Swnxld +W1eeenmkiRToAR/5M4X2PZ+GZPPOwJ8XTmzgbE7iV5c9YyVGv4wlV9AlZnMTSkxt +ZoH0zI2/fzoxAYr79UhatjHBesg/9C+5ITrTDMhNJE1mvj+1rvdOj8HxSBsQy2Qa +WOGWVwglJdaIGfBOWMzv2R2Bdg4vPOx83kLNj6o85mK8B69jhXTVuJp5gdeeeDZx +XzH2NpO+3kl8/sGTSDkXmErYxn7ZYcIvGk7eGCz/UwQsJ/MdxBsYaKWXtb0MVI/x +b0HyOmNfAUd2RJxJ7Tp4/ZSkOi6Qnknv41Am2lxeWTwoSd6LlkB7GbURL08v233o +CokCHAQTAQIABgUCVnHrcAAKCRAwk2dRukfU6KvkD/9RVCl+vyFc1B/pyecRpdec +NHArKkdHEE2B9ABIuFEnTbRYkVdPzU2sKUeSGO5ESVMqGy2024XQVs0DzSD6Br0h +Vpm5RiwieupmFweGFTGw9OsRlpz9YRZHssAkXbQKKAdImhKO4jfmjbXmTtUz7moV +T/jyDuSreaTRdZa6rvRElv+C/x3aPS/B5JajP3TDabKM/qo0G3NPSB5KdwbyzqtM +LeQh0LvYzFG8TrbQJSh86BACAOZyr63Nn6aygDeoiYNbryGZreCk45rHScpnGoDq +wlDTVFBexi+W5Y79hd/kmpo6Op7BCQ3h/1Y6Lc0NFrtf7nxCcVja+qg5/OaTXNYT +r2f3JWHL41bFBMVuXgbieJZM6SH37jPfAgYyeAFHfieYmqNNcH79uq2V5QOXjzF9 +2Yr5UO6yOuKW4NYQYoZktMwVYDSjmnYXtPXgHz4jKalIFRP7SM4IKYD2+MUAsDGU +E/vQgwr89I8rSFQzrWtvcXkI9AIIWEPR2dIlwuinlYi6/lYZJASvllUwik4oETWT +98c9/VLvl5wULkhVXanhF4v8q6Lr39oiOz74ipJ0tcnHWR4fVXAashemtOoq9YQ3 +HtYwvZT7bPtC9AnEbIsHj4wXCU44RIGFWlIwoR+s+1nWCX/nE/043D7Ehe+/0MXn +6jIDQz7sX46FCxhFoBNOH4kCHAQTAQgABgUCVmpVbQAKCRDmIMinS69dCaT4D/oD +HjFH+eFYRPPyRsABHXeeVOdf/m6dYyGr3LQYxwJNfSfXVC3FQySbUYhbrzUR9iDD +FGtFq2s+8psJEXiqivKvS5qEX04JkfR4jj3ggpVPgvwSz8Ur5EshNNDesK82iw7J +HSWP6bDwMt3BGQgpFPDnZKMbFK8pEpXt+/pQw2m/WEcJZOityLXcW5j67xJwlDcO +uCH4RmwKPXew8KvD3Vgvpu2M1d/zJDbBodOtkwBLC9AOtCRu4PoCcdAG6it4CWf2 +oRCEHCu+wyPuZl8xTcoiybMy0X+g3u8f7x7afSDkHj56Mm91l7Q5mHbich54WVWE +Ezh5QkHGylC2BJsiwyABq10BvSo7/Mghl+1GKEuUum9pKPlFdf1jsyUDudk+Kmht +2m+7an7IFapspy/1LXrghf48EO1SgJGaBxjLnNQSovhPCViQJzB/F+SgM1E7cXai +onf/1MBTYPsmNkTaRfJpev05V81pJac4VQ4krGuMPB7xKmFFy6XYo9gKzH5Q1RMW +Nh6s4teC8v9t+QcVbCFQGvnPQHHseIEShzfQ0hoKrA6ptgTYNyF+5nE1xUb2DWDm +bRm8jBaIVC0oD75VFTTl0FiVJ63TiQKwHBHAwjMcJPZSw9ufM1pWO8fp0GpEhdpr +xdUZaFxkU7ENn/KB+V6EpTj6oYWyy3REatVtXdwDcokCHAQTAQgABgUCVnHRdgAK +CRBlEFGqjv4GVeahD/9NUdURt5Yc/5vgXmtEz/tvl/1lUG2cgnrR3XMeloC/5LpJ +MuHT9Lk9TurB/qRjUb4unoz7nm9pzApB/+qHuGHRs14tQwF6Hauwkf0KVhI6NYNb +T5kYgSpYgyshv70vmnFXqwQGDVf92DOuVMOHoTElkEfeaBRvCHWhWKP0uNynR/l0 +myW/tOiHgEhv8s/1TljNt4/03V2l6pkRbDIHHC/WzEF3Kdahq/c091kr8rL1ODkt +9cpYM+FbMtQs++k6jEnmhUhVsjslKvulsKKcNLmB+RRbUq7oPq68p8bbd6pjLTvE +1xAMoRi94VAXV4S7tDoHIvUCg74QYKm+5SZlYjzUNojqy/rGGxXZwSAM/w2GQUfm +zzyXr/wW4XmEg87oWf4emV75o9YszU50mDXDGAMykUYZgbRDFvUsFf9TckJllexk +IhYOdEzPr1H7slNqGR1fxf9OqKa2mbEeAypjTSGXxTxDMbsebhjf2Yb28+WkuvhL +eVkJ/CW7EU/wwjoi/YV+5mr91viAVwMKqrgAKnRLv2gVveIiR6EG6vPmrBMpRaQO +6sCtc3l+pAOP1UVN5Q0KOtYELXQ5NUhD8PgN1TLmPMtB10XIfewJiFZgie9K+crS +qfPzrG2sCRw7BMfB1JuVQlz3OMxdSa6N98Z8VG+ah77eyo5gkyPl7E/KjnU6DYkB +swQQAQoAHRYhBNi5h0gGtALH95w/60ddgZ+EEo10BQJbGVPkAAoJEEddgZ+EEo10 +GbEL+wSN7Qf2a60RSYUIylA1juTe5hCrzXubg1pJg7mlSErtLka8dHXcd9WSUZwh +zuYr6RkO9MPgsa7ZSVaOy+TSZw3BY4Y7CGFKbXATj7ZlFXF0wNK4XDLIWNPao5cv +JQxcLtnh2vuOR9OUcE8NZEquWRznTWsdzabiXVp03djstDJEoSuGr7S+7rWrjeeH +UlaOF6k0m+TKasqEmZbsUTYoPa87DT3T2PAGCbS6gxkleqetPB7G0Exp5UN2f7cS +7wEuk3AW7XZdZYtV7FWFsN5uCH9heSedrDFcDjLkrsGVE4lRU3IvDK07ZPGziAs+ +EoqOACZLZ56dd0dvmrmznKIyyAPHEu+4z3AIY61oZ0FMDUqNkHrxBfRvI2Kog3Te +Ib4R+AZl0rkriYBIMaBwwKuLnr9Tg3EBYgwhbASzhOGYgnwrr+XYub3ai4skbaUy +4hLRje0Hfs0/skLOie9hplk6OEnWw3T1fjty2+JZlwCFNEewxd79aXubMxE4h5Bf +s+pqJ7kCDQRSVNlHARAA1uUNr45Ywc+QXF17/PGKqQKLL6cG/jVRqCMTZgYtGXUl +pjEpOz9jt0zGzpwoHRwmOZM6fW17NSqOadYnUttP1AXuLJCgae+MOlHe/wxDYzkT +BKUm/CA/x6ghxWFLXOwNRwLXdnNJrs8II+yBhPR63XyqDUy5eUF0qYGxytTNs9pU +f3VQVQpWzot0bwTYT0mzSqdeU0q8LT0CpqeGLoO/Y3hxM9Y/742MZn76I8hBFGf4 +50xg19/PBzAM1pLy0VF2Rq4G3yrjlX7ENMp575c1bLxy4MJ6BUD/Qv8iqefLZcHY +MsysM+etIXSK/gQQDSR2kGoR2gBTWff5HuAvDOPvUwWaE4yrQ4AlSqdxZeRrMU1K +Pj4GKeuzvfR4Mh4B0jGj87872ins07OVlUjVhexYEBOUKlVB1CkoelKGZyYhjRoM +URGq7+nZbQT+jc6v8gm0mLh3PWTQgElq1SO8tqT+o7+a0Nrwk4OMQQSLGcqoJtXW +u+N6EwDMr+sn1XS1XYnnsnEXf/HNM17M+O9gYITivKbduwsQqcdRKv8IONMnbCS3 +HUu1WnFpVSgi5Bh0xJofJPJI+IH8vttsRnkymFv0KMCH5abwa3L+K1ZUwdQG8s8o +PnuLnzJSxmT4nLdo9L9DtRpSQtcPYcQxlnD+HulWLq3rIv6EMFshZPcHAQc1FzUA +EQEAAYkCHwQYAQIACQUCUlTZRwIbDAAKCRAEw2fCGK3U/8AmD/41w3qXsqGVgzdS +l9iaEJsfKDgj1O8yqoQ7orcqg9Bd9xrgCYc3FYyP3kVk2cMwyHK0lTLF8zLzYJhm +cVsUviehrPb2gu75UlBMp8A3PWcn/4IuZj0fLWTftOpoxDaba0ZT6Uj/neSPFSWa +n1pqfrdWs6L+mZ8R5tmyEtJ/GxkvOZ1d7QDudC3EX4EnBmPE5GERrYy/HnGoqbCp +0EJ5xRBkY5glWu2kuCwaBE/hx7cjHxEZutO1LJ9JzMeaRd7qbBwZe6l2CN1UJx7x +xO3aXSLgTw0GBcJ9JzynvxNY82Ztpq5nJn7CxjIHcy9GceRARq33sf2Dh6eV+3SR +vYN1qOslST+gQlhFUlx86zJfmllcnbloppX2Gfa5UsI2crD7DoNubMs/mlCOap6p +s4wOm+4fx2JP9fqFRgOi+t5pIFwwXMHelrTQf8QZC0i7SIqoEpdjfOe88mZ702S5 +w/BipmjrsCenJhZ9WZC2X7lHh0FjlSj/C32VtZy1n4Lm7a7N9pPYEvKl4Ze+MgsV +olRsBwFtiWOwtarB8Njo6r/L12f/bRLxCwEdnQv6NtGcTNdKxhCTWhGWJjkcQvAV +up3FVY5cejUAzuk1HqdlR4IaN3/B5fOq7PAp3RpjnHVMHvxajhlNGtnHIKmQ6vlz +NCfQHCFXxXunnAE7gKY4mTyXexdMxJkBogRHyLe4EQQAuOuaPdDYqwocLylt57wt +nWAjehH/rzm9BFpclmuYzGa4HKh6etAFSmMVdoAH0mohKRWCk1KT6RiFANj/VAD0 +mJyxKoEx2FTVZsauMIKIhoaJ/hcrhse1rEzdYOMUrRmNO1GLpfglwOPCuCvkGrtD +QypiwepAAyekQX2cf6z+Cv8AoLRqjGWcEVn93IfAnJIMqbvyMyNXA/90pf0ROB25 +dot+HQ6VEZlu2E/5Isn0OeIgiYuSyDLjxerIuPeY36ztr+kJCIyuhMltsE9YKyr8 +NH91RIMTualmeBRBy/nEcS0+jwC0RrKRdYtmVATFbMPyT1Fdhkcy/PgabWmluo4N +M7T3uOJZbEutKbK91gOW1tgyHCTAS58B6AQAm6oNE9CaD3d52JGuDK0fn+69xxsS +bhSBwkbupKY9dG1m5ELZV03mHDQnPQWEBVXYejIvapuZxG4CgcPR0XHc6iiIGuq6 +hsmAThcn+HpasgZWtUYSKT0FPsFCoxVzN71PfQVQx80xhnLV+6CMqG8u1YWSbZ+P +faabo2cvHcgWz/m0J0JlbmphbWluIFBldGVyc29uIDxiZW5qYW1pbkBweXRob24u +b3JnPoheBBARCAAGBQJL3ElbAAoJEPrvEpNt0+PsFPEBAMDsWpMfvfHMeqv60BJY +2HOW/VO0HHhQE20/G//Fm2X7APoD4jZhqt+rtp1j74vjTonc6Im5ElCkKF5zsszG +MXA5hIhjBBMRAgAjAhsDBgsJCAcDAgQVAggDBBYCAwECHgECF4AFAklRf5sCGQEA +CgkQmc3qnaQTWziFmgCgg+gCEI3HmG+sGjPYag6SA+xE/9UAn2gf1zLHf15kUpk8 +uhQSsaNiYUI3iQIgBBABAgAKBQJRR1kIAwUBeAAKCRASX1xn3+lAhMsoD/9vqN/9 +fLyR0s+f/yD+hFEFeKf40ZKvUGcEm7qw8txOQjALWdtQW207p7vdzTW2U7WN2gOe +W/RhVviZsCPawFZRN25liNMD01JWqgt7F2V6dm8VZ7Shuy/DPzMK113r61wp1wOV +LvEsBni5QiL9LvMGiAdIJ1we1KhWAKRKk9Tv/LDvo/hU2Dd/Ko2koM812ieppiKl +ocLDPc/VSc/W7VXAmr8/BDLQo3XEGHK6Uqr7G2+rPy9MO12CSNpGENMHg8om2x7q +feNW0YOkXPq3x2q+VNtHA9e76Q50JeXNnEDqadSi0ZWh8UU8LbBC7fYlISw+uoKM +F17zaW1YT8/JHNRM2GKG3RLXpFfwr4nYwpFP66kCqlcAs7HD+5O4pSnks5r4NRX3 +WADpy1SX9GNmHdwboZgBywr4tzlRtoCe9a25b2gsBgwEkyGrggnbP810bVVZ7q6f +lhYHgA/kbpAiCbtcDNSN6awxEUc7moIbSjcWs9BDPRg7gWPGeZtVBY0O+0vihD8U +idQlRKIf/VMOjRs8TchQWox5aB3M8k6g01AWBE2Cc0eXBfBGGMB8fupdCiDpSPAg +8KlUxvbbujf5hm8RuHzvrRAZBJt/Fa2zES9LiWSx+NxCVHWteJ55uwtDs0hv5VW5 +HMRkUMyfR7mrxf1b22BQGzwvb2tDoK/vS/Y96IkCMwQQAQoAHRYhBLuzuPI+BBw+ +IA6BgANi6PplPNoiBQJbOgWhAAoJEANi6PplPNoiWr8QAIyIDw6UfLwHnNXPq/rj +XJR6rdg/n6RqoYocJm09dnTz2aPiNx4U0VKhpwnN70X9jGxhRvWLzxO2nv0JnLWE +0nNDqPiufJwaHGrqYwbja4ryqOqfeuAgB7bLkfaX3bunkRidjVNUif9XIEr7PCaS +KRFvOj9NXPQ+T2UYrLFmqmJVky/HVbQ8Wzs+AJzqS2pCmYNGqyDtvgrJjLyP8fp7 +xHBe84ceO0n5hqenqdvxaTmSqgV/TNHd/SVel4rYFNIcOe2G7a6Sje48WBKcTTyY +492N1Vr++M7yxdHnerMyTFF1slUBqETtqKKV49uIQKxcS/rmy80CGuuhlfsUQQWS +20E3ZTmDBZ0imAOYbguSguzJCUhxncd98GR6jBjZx26kFCHwg43s+Uh+F2vnxHXe +z+UJtBWuEB1MD+K7n+MACOpwiFSZb3zruuLpIMNd8l1I+lFWqwx/oLRQevf32v13 +lJ0XM1V2URAoVSGnqP0pueJoHPj27b6h8lFVa4x79FKE1w/VmYKkXHG558dv0EUG +dM+B8HEIj9Q7Jn8DYbJug9hvzu4IZKc5eWZlAjzoW8mGtXXoKgpl2eJXRbbpPG2k +SdPXXJdMAYJeqhBCIMjNTCstapYa0TXPGrdKQxp0hp5GO9soxpP9AL1fxOHK2Ni6 +cziGJGKXzZm0M0JOpnvuyzahtC5CZW5qYW1pbiBQZXRlcnNvbiA8bXVzaWNjb21w +b3NpdGlvbkBnbWFpbC5jb20+iF4EEBEIAAYFAkvcSVsACgkQ+u8Sk23T4+xicAD/ +dFGu3ocSQuK8zL8T+T9y/qyf3LOmyLjxDWkkJGlhW0MA/0LbnSdKK4QOYwD9SiQT +cgpwQxfHTn95PcfvVcltaLJ6iGAEExECACAFAkfIt7gCGwMGCwkIBwMCBBUCCAME +FgIDAQIeAQIXgAAKCRCZzeqdpBNbOJWhAJ0fC4LLzh/zEUOURawqyhlNavFBoACd +F3I86YOwSfZXXWwpiIUp+JPopxGJAhwEEAECAAYFAlFbZjUACgkQEm61Y6dLBr/P +5A//fGn4pLUZ9wYxb5T4G5QmEDTYzt50AZQUxdfxEfdtz0y82sZpgdy+n/oKpIrV +1tWrwhas17clKcdlZxRLXsDWBxRV8AaUQ/9UMFNs4zxsElbac4i7nLiQ/1yOzeHR +JgFwobEfdYgejv0Ic0dIAocHtxG7KbQlbl0lfa8k6dsvDopLr+O2A3JXdDZ91u04 +21H32ChbEzgYb31dvD6KXLso3NAJ/YmCJ7jMQ4BzcDqVFPLjLsccJ2r9rWX1ZFrD +xN1WjfC2lJeOfntpE0dFJJjsdHtChxT08MTXHJ+tOLgGNRL/sM+P45bbb/aofY+j +XuV8DvtNW0tLjqKMvy0P0DB4ca9TL7E1nDsO6p1Q5QfmaFbMf/ACmtcxfP0ph2Yd +tbTK2QRxPf9/tF9rym5VEDM+ZaAxz0w/0yJMA9eqUoR3jJcrYJrKNTL633Zz7vor +nmNtyU9owqurV7CikZIjHCJB22rcqXTQQdPk14jlBaj+EsJpJ7p8Gn1lLiLsrxYF +EYSmEVfsiZX5RKNk3yhEpQkn+at7jpIb7HQ5O0PGHxT1Ju7UzGExus/KanOAhaRa +Xv5AgTCUBTS88qivBpTIyFtxIP0itbR/gypC6AQcuW9afd3MwnAtIzCV5EZr7Ko4 +Oi03/RmnA7ANKaCbGN2zLEAkE4ugyl20p6O/dTr9dhgyA2SJAiAEEAECAAoFAlFH +WQgDBQF4AAoJEBJfXGff6UCEkVIQAJyMq4OvWzzCl0XjKykehPJkmfQy+pS/Z2G2 ++g8I8vGEodjEIvVdC1jKrE+QJIJfTsLpKkN4H2JkG4usiclgqw+ZYqBn8LwOxNWE +b8uo2LYeF2VvsJkWiMSrxSH3vFsnA68+Z9MpS5lFyCaa1I8qrbMu3KUsiZv4n04e +QA+zbCjtXHJFgO5eIshU4Fc8ZPvHU0RH/fg2cAO1wmeLWM4v3mMwrNes93bcFyh+ +cj8fXqXQJ2uN0hkcM5NxwuzVIjs02gCb8GnLJNvPYSdJs9CwGS6O7gSDrtd2X938 +79yoM9+EvDthKeQFhLpLbWW3wbMcIyb4XwE5VR8uVDpOfST4Zf6mNasVI/4JrKRv +5Mp8yVUrFSleAWeInGoNwnKHVgIqYRSl5zlVKkjGtOZN0p/dMGKQ+huX2ZMKrN/1 +Czuktvn+mYujCrUOpcuLaeWAa6rBAgAOml44Qkk9qtbnXY+9WI5QsxhFQpBMwaRj +xVpfrAxSEToBmrHk/ggQ8RLI446XCrPJ5EHlVDVvTTQxeAJKsyh7b086GMzn3Xd1 +0PUAr4OrlmLRdaLXJS9GhcS5OMowlHXP/pmnnuwfjSUCwzILx+Z1u2/+oPUUV+/R +byRkNs2BhPnlFEVgTgT3IUt0hjnnMY4A0rB7WZao1Zpz5Xi9nNHumx/Gvtxb70tg +UL/PPBjrtDJCZW5qYW1pbiBQZXRlcnNvbiA8Z3V0d29ydGhAdXNlcnMuc291cmNl +Zm9yZ2UubmV0PoheBBARCAAGBQJL3ElbAAoJEPrvEpNt0+Ps2EcBALLMa3ekr2F8 +7hjt5yf8ehy1MipZIF+alpGI4R3DT6cgAP9XUru6Yn6NCLC7wrECeNB93tLiox/t +vFuknNHlixgG04hgBBMRAgAgBQJHyNTNAhsDBgsJCAcDAgQVAggDBBYCAwECHgEC +F4AACgkQmc3qnaQTWzjpTwCglDzTlcpNMmurL0DvXDpaOy8DvIgAmwc7DDUVT5/9 +W3TmtB0n+/gki1UiiQIgBBABAgAKBQJRR1kIAwUBeAAKCRASX1xn3+lAhK7mD/9Y +RsSO0RDR/xe+IIKFfxqVStAowpVhrUR9ZdSABAGQ2h+qI0KxFmQQGvtyAhAg6jpP +jpFD0ajOgxRXA5VVXyC3iyIefxqQiEyXmX4UVe/Ogf7S71wJwTUfe6Ckm/P2MDo1 +kUnyE3M9QZI3cTS4Q5oYCKzH9DaSICG7dMt6uXKTtJJ2ql0vyds93BI73puMSIsp +vEmBLnUvg5/O3NvHwXGTjwNALbwd5wqbBgDLHi/LVfKbvYckQDZEaBmtMKTX5aW1 +PKjpiNMYo7Xp3zKGAILwq4VnIoCkwX3gIwt4D1Mj6CVk9R+k/wW+/fq3NdsjrscE +dguUsDliGYcDl/zheDGMNUVeSX/DXS5r9iew3AGECRZ5JREonqzJxaBPvT6HhgZD +Ihge8a0GSYB8nQlsvN6BRY9vMUta6FWcxeaZp87Jun0nTBpcwwp+WgAaIx2ym+Hb +Nov64EG2jmb1lSnPKwVNdung121uIFdDpOuc899KLfbJO1oGQgCTVv0+qDZsk2ba +IVtooxG0OqE+Vi8r41M/F6O1nj60/yL/+nXcdPF3r93CNHJm3VvQIyLs3soFJZgL +pr25G/xuV4sHBnDh1IxT4xweEPi0xqBpWRW2xlYXNvOj82e098f70c85n+613gBz +PYw+zsJQEccMo4NLfwi2oTlNfhmRR7tNT+e/RwCW0rkEDQRHyLkdEBAAxjE0ptPF +srjz4u67hvt2mKvOmzoVGyhC9BRWkTRGs6DZf4ZooYpjz/nEdhcAFk+parkBDAoC +p13pR96yPWcZS2JhfWF1uabo0018h5SmYMz8eMnw1DdPOeO7kCN1dGWXWzuId0WD +lkrBhp8vN7MkULjfxbjqAdp/kyo4ddht7cZIzQum8Ru7yIm5mh48GwBvVKEjAjPz +B2jQlp56IzdvwITXzXNFTRPY+UxrwNbssOcSqDCzBqS3/EGsHVCs5S/I2fLKfIXT +EPlH3JUAIrk0pVnh48LdZcoHNyInKpOQQkMDWrdaOGjjYFRoJDGJwzZkbE75JcdW +WSdw/PpthjuIcoS1fAXh4LoTdy7GFKCjll+u9fEdAi14r/DJWcLPJCXq/HWqcbEu +gwmp6YG/gidBFfTC4Bu5JPszmTaJ4TOyyia1qjcEWzEdFnu7OzDs8Z/MEvnie+MH +ym6a0wrI8AvktjpZ+h4iXxtgIzpUGJ5XZ3OFdE64XJrpyPfZidMTqumr8yn/ISlF +vsvBvpnIVukYmAoV5fZh4N9+NDM8D6I75f4vZVoVAJeOED0XbRCTUnr5GNkHfaxE +dMi6N3hElxddYUqaVWek46GKisamaJw1CaidQNbu12WbahfEqKtuBPekkVk89Q7d +O1r3q2tQLJ7qwRFDWYaZ5QlPmTrCunOrJyMAAwUQAIgzEPJhq36TmGptpPM0sFDQ +uUSzYgcPVRfZrnFOpB/kGrlXDsxbEcdCQeiMUon8eW1MXxia6ryo8/ZnFg4bo4Sg +GsNh4e6SZWrSCUtfYmQxtmmru+r0W3NNnp40KiVRpjNJ2m/JaUo78AARKa+Px8Fn +N9Btq4C1DelSMlO+jILT2CYpK6c3wAwmeUlLO8XtOhRU/tAg1a2Lk9mSrOElpr0x +aD5CWzLdmD3wqigHbkad26x5oaJ79BjWuunVmjCFQcOuGww1vpIu+kfqMqz/ZAyg +X4O8GL6rJ2V+nZBziRooZfljS3hyYROTSWf8whJQWYKv1drzdyZ3rNM/69Tv5myj +tpaMx5zaKdqsua+A/mj0MEmUvaVuM7uHp/yoisGMSpFe/afYyPnHgpUeSownoVgM +qc8v41z7oorNVxAIw5cHTY6E7oGRshg6o9bjDm/vGG2q3TvO2F3WQTqGE7rMeLbk +Du40BsveDCp8XdzBg8PhQofEi43BLZTVVU/SeQ9x7g40uDIQR/j4L2v1Y/j4p7CR +95yGLEM+rh6hj57v64qNoHI4NRP6UYV8jN1vDHvwwnPnt/fGAP3HOi4iCG4/UVAL +rjbjWBGYRRhYWQKI8Qu3QMXVB2G0AMvrfznYjosfqOenhwnYsuyhFcPMRT6+/o3w +7AcbXhqQlxQL/FJ413xxiEkEGBECAAkFAkfIuR0CGwwACgkQmc3qnaQTWzidIwCc +DfPjDDhkMfxqQotxkjdHCzEc+WIAoJ8JEyulf7GeGogbxL3hiyygCwGNmQINBEoL +bqsBEADDqGTCQIqIEiDgE/CBu0HGrJ9C+sD05zfU1UU081ZpEIjXnSBj+J+tLaoK +XQ636PIkaAWcgMkdZf2OhHOeIWA3vkBIUHr19tD5RIcK6+FOnGoR/pgiRjKO4d31 +ItXNqlj0y7Y6gs8kveF4HD048ij+lv28k8b3c6VEpI0tRYpwW2t7F/Ays4REybZd +p7YWi3sv/+bw+padRHC79Y0nAoYlk+4UH9kQI5fJMkUjJR5idX/3O7I9yK5UoY5K +QBIbqMMdFT7Nn9P1HBHDIwGPPHdGC6qhg05zmJBLCrdW/wjpqVlHUCQSpE3zlpfx +3nxDZx1g5tMZSiXSCVUupHFvaJ7IPdzZFLbvpRbviMR7C6JExZxT8u06GHg10NOa +n3MLlBktw7D2oieD/xUeK+I3bVXhaP9yuucV7n7eHWSSxLFAqjG39TyNeduioE44 +ZQ1+4/xnZNp3N2uiQi5qkHKk/0/Fdo2RwamekHOahkoNchefKgX5GF5mtGx1EZKS +fjZyNDXNxpZd5ZTpM9oYlCh2lL7CoAnSsQP4g5eH7qabZQPl7SYcUlGx7rsXinEO +igWGwi3wdHbT5dmxqkddJoi7GEWr5NEMAWYrjjVzwdIcGNtd52VDQAjTqLk1OAMg +NhHakb/sNBpQYqxc0OBgXaLvqRKWGGC59lNixTtep6RS7MZUswARAQABtB5CYXJy +eSBXYXJzYXcgPGJhcnJ5QHdhcnNhdy51cz6IRgQQEQIABgUCTDzl4gAKCRCMJNFg +jwaJ1HNbAJ0SPuAhk0ll3npFmWIrVJY6p0WVzgCgiA8xhyulg/+rCTjyYkLgE6YB +WJOIRgQQEQIABgUCTLN7EgAKCRBVW5delTuGkzF7AJ0ZUW+CRILhJpquoUUtLhYG +gvDqugCghlYSfqk6o7h3lO8cDu4P15+tngKIRgQQEQIABgUCTNXtXwAKCRAdqNoz +3c1oakXiAJ97zJAiGSa+LL0UVxdlWC4DhYYU+gCfYMdUBEVjSdIBySQYXGoOCOFi +7VOITQQQEQgADQUCSgtyqAIHAAMFAXgACgkQ2YZpQepbvXFFdQCglAIVzZ7oL++n +Gvg7WGJy8hPY0z0AoJhrODn0DIJGwwVQePRIhXFZeFWOiF4EEBEIAAYFAktXYt0A +CgkQ+u8Sk23T4+zwpgEAzlM2F+8Mn+pIadVx0p2zuuWeXZQtS5RFpqS4T5NbhhQB +AJS5DS+VGKPyxr9pxmbXJNbrAjJltgknjKMR38HXPa41iKMEEAEIAA0FAkoLc5QC +BwADBQF4AAoJEHEjvBPtnXfVqekD/1X8kUnrSGqnl1RbrgSCh7STfwnsph6SZM3y +srd5fe1TN9+ydCN3EMr2du5fvOOjkqOGITr2rtkb5K6Vc+rs0v0C4Umgh1XU/BEw +QQLJLosYdoJAQ9cwE8hJn6+d2HMivla2eE4zcQgCXAVKEoQac4YKiAYvO2vF7gJI +E6YGZKSYiQEcBBABAgAGBQJN0WUoAAoJEKax8/DmtfWj3NkH+gNYNFLReFtBP1VI +6ssg7FOf78jA3WnaA9zNVd8Gcab5ncpMfRqJubOl7d4OMDMVrZ1Pe1L+6sZNDRFK +6v7wUMp+bZGEi8Ps/lvwaS+N3Y6imSZRQEvw+eGo61MlOrj+rASRtdppUVJjcUax +h4sZN1t6wyYIhtrgBxzMPzg7/c+dOPRF3KWa6kZ2HnKGmMDJX11trCfRlOw9R8uS +8vqEYpUa9AQ9LSG83/p19Zo5CJ7llcfTaCQMIKnuhFzLfwL/KWujfyRiTuY30e9g +B6FS6BjHlc1s+6R50kAFBIlTDGgmg2G4YF9fimI6yLnFAV7QsKghTrlV3/7BRSxU +Ax62cB6JAhwEEAECAAYFAk3M6ukACgkQuN+3G1/svZKhdw/+OWqjlcfo3HNzJbs6 +oQWuWExKCJ4s2XZdcOcz+FQ8ZTkmGWkraw5wJw6cii/zA379SizhuLVxYl8hfbO9 +ExMqGDstM9Wi5of45yTK2ExIIt0RlQPi6MYie4/hffyifQtMikmxSRs98Hl7liir +UwqCc90cwb2YcF+z8xvXF7AhqHKn4SGu+N/+Q7e+bavXOaYrUtJB3Q2AvEoq1D1j +m/ahUwbCqGlW57u6FOHbjpTQM9P1RdOb2j7Cfq8xgUSnAI58Kfw+m9E0sb+kY+SD +R8rgRayHqaJhU4nQHmnvAkV4iM67qhbO3coRqpvDCfNtZhGqTO6GOmoQq9vFh1rD +Zr5Ka+YJ/MG5hQ+iOU+0FwDL5GzPgqVvSm64ixTW/q/4VH96W0+IETI3Ft46CVTH +3GHQAKbivG6UbOXLXGVEjc5WJcVEpglbmro6XJw8pEMY4iKc+AaWmDDDlgX0hc7G +XYoN2Yn4OiyFNmjmqgcQU0VAggsofvTt2kY35YUZr5PGHfg6NGMwiNdd13IX46Dw +LncMd5/pm3kldGE58ers/l8KL8CZkMFdXsqf3vRXbIzgqNX3SEccEhoT1GElfBMU +itMoaPvA7iWRejPgEgpECf04oWayTg3Tg2x6Fx3OwGJ9h1jX8IOb23FNDeo4FU7o +aG5wLlNRZ0hE9qmDknTTOvk1jCyJAhwEEAECAAYFAk3M8N0ACgkQ4ZcBJna5tzmN +uQ//dpSfjIS1c0T+ugGqUXMxuRiBE21Sg9e+kHy9tBX0xRvmx1xYRgvWxTG8uk9E +E6fOdpnz+Bl+CsEzo1Q4HZKrYvkuj+bYkIN2zT518nnk4101u8tn8kBSg462ivhO +QTwuGZA2+zJ2ANof7el4Y/X5MdzeV3y/RtjuMkxHg82R/CF01zbbVKjn0FB5ySxa +POJPHO7rA/e0VE892ExpOKPVF9ScZD9fIeLcJyMEEL9qxE5lPE6d7olr6hfUbaC1 +MYNMSoVCWXRqmn+YDbiomgoXc3LGbFaJVNekeXsZf/7HVteFPe85jpaQsSlf0mAw +FoBqrJ6pCnCuKKBZkiY/XVRuJXWGKLMKOJlJbaFiA+X6IEZocubdBQqaR0inSAwn +9tBEcA2K3IA5cCRG5EddeXH7P4XFNJJUjxVM+uvawRiS0FES5ugb7pjgt+e1MMjI +7hbuBvTHdGNC5q8KhiMj0nylZoKJsaK/uSeU5IfXVdHlPSdbfY4C08Zti19AoUA0 +F/cgkoTam99iPcPahyX1BAtRn+P9KpouZKFw68OMAi/phh0fXWXp2Q8HvMjw/wak +xBr4pRuN8Et7F1/7jbfOd8LMC3JaPL7vIRI8qcDRrFlXJ3IfCzuDW3Dp81Oy16Jn +lhxiW0Ks7ZEgZEgHQzxe/wWfBHjU52PHGFmiikQgmRBK/POJAhwEEAECAAYFAk3N +MikACgkQhlYfRSGA/P6hcA//XdtjTGNOzK8x03rhJWWIONbGgk0EmlzkF160d3ME +dyP5YZVKHJI/HyKwwFVCccw+VPdxyaLLb2FVNW+94x8fsxcde/MdgGbqTvMQeaBc +TTvdmvAGU63HO4GkV3jcHPxUnvtQmWqDBtQkO7BmdqSKZy0fyhJPo4SBJEb4RtUt +aP4/GCOk1iN2DQNq1oOsRK7qfwWAxtT7lU0HPCcDIs1H3sbDskv+xYx93IH0/IRk +SfW78P/S/G5vzcSOvWIzr+BP1VsKKA7DXpdJm/V683MM+AXwtX7ZphECN11TQvI4 +nY6/LjHFkL4mwRl94MSJdmMDFdaNZ62bbd0lBg2qRq9Vz/jshTaLCPSZMt2INc7G +tlHqaCtWuyUQInCEJekmPchT1pw+9g6wVs/DZjnbcYa4+0BMP2/LAIM+AkZgNOGL +iXP8Mmbp6NtCAxWdYJBGYxTovKQWmoE6jW9wHcePLGMImWFnmU8r2DksM6Kzst45 +FYeV5zWOjSAOkLYMqtG4HHtMjb4hIU1OUlBZWt3OwOpQtYOO84L0WSSwQmYK7FDT +Im9SCUbSeTU9WIUiGypm55LHbOqZW7SkzQB+6DZgmsQ6bHzGziO9MqmalvZ0F9iv +rVx9GGU89Oj5dTk+Xb+KHxrCsAHCFN0OLnS8arzOKm1IHyVmx+nmUBHql6WvuQLN +wpKJAhwEEAECAAYFAk3NXXwACgkQRdd+njDLGxEEmQ/+Myg4BdinA7i9d84pwa66 +tPxAGcADm4tFGHWp+hc88d4Z3kzX6qsFzrHqDsa+3xbpMHlxkqrPFJRgl08gjc83 +S46hCwh+rVRKKQ7xgaa7wUJTNhNl0crHqZ82MZJV7HUqCgvqlvCaa+4q5K4lno2m +C4gDZdG16wSKD0TNq/DE9pkA3tQl5RSWhxaqCPsNiz8K02adopoFw/be+CaWjGP9 +mbBRK/VzPEoSu5myhCZZDdB6Lu7br8VaddEEh2AykgxpVwAIVTaGawKyzwmjpuGw +YptgPcJRLS3AyhEXDNZacJJrx82lL3nluYG/B8Y8t2mWmNnRiY9rttkQwWcls+h2 +ymB6ffaZWmSEcIBWXTuTJs53g0LuJJMXRrrvokteNKd4STpeQIuQcruma9Gbuah4 +yZIHo++rJYK2sTapgQo4bdudDdgwUw6tKIdHiCZuIkG5vJCCjrCOwBR/z88Ilywd +3aNcAnf+5Q+9Njxs4dl/YJL//ksYr18JIKkzcYMQTabcDA9m0UzFNo1ruk4RbXiy +YPrierXbtr3710sznst4sM1FvSOLNiufNxVASZgvlTh1B6W9Y1C/rIKWgQT9t+/T +8/2fozTLNTo59L9Wz4OcAh5SNFnD9fL14i/xcvw8LR+VI3s2L2tLVXN4QU937DSJ +Wq8oe4xXxSAqowbJJnKARreJAhwEEAECAAYFAk3O/wEACgkQYAQmoRj1+85ZyA// +Srr5WQ2NTU0mWpt3iEgJcZOsCYtHvvOEjeo4fbwQU+ZqUhecQVNe0R+zRa99jE1G +4JKE++hPgcF9322zk7sDrYPFoIgt3XGP96wgwiXA4Aqb1JU0KOkhKGRLC11CnVrF +7YWkBIixTyGPhNddQC5MwtJC+D33cgawZ9B1+fRLcQrjLA4k20+a/zxlD/+dcp8P +vvGDHEvkXne2X0cK1vAmmFXMezI5Y1ttrIeELclj2Ig4INV4xtWjMHcVTaDhKWST +mR80oyLnSF3N6IaV3q5nQYgHdEUXmDuGlgNmfaLRCyEk6yRQMiDpErTsEWYQ4Nye +/4ispxUKRT4mwrdc6zHBYXX+LjsCiRmz9VEylq9Osct0+/iIYY92ZxS8JOWsLWMW +VFbVLgH2S3z3kvg+0exogtW/iZfC+hum6/1OkOzLZCg43E+Ijs4+a1rn+osgBIW6 +QYSQrNEbxOomqHXz+RBp5FbS8th1welYIQE0dUSSt+vy71/8jF6st8JQf8Ww8IJ2 +xQU+2K/So74cUIYr3d3J6PeBlUoASAyHv3jMu8vYaMxVvJ1ZEWJZCwB6zcPUjPIn +KLbW5wKnSU1sq53CxvHSzDNneSSBIqwdmOtyfhONicdZQ/RARKOOV80vWK8+allr +q7ch+kJrmfUO74J4mIUAbJGvvsqgA7buYKiV49r/uTyJAhwEEAECAAYFAk3RdQAA +CgkQxjiXTWR5LWdJTBAAiDG7b6KYA+hZEJzUMXJat/IHVtIWmi1ulkD8MWNR6fWu +kcyD5FhQUcXD7L5XNnl73sDsuwBN4FBYkC3RjuuMEQVaDgCA6KOZC9XRfiiIVid9 +etiSN4P2C0YcluB27o3+opXfzNZVIVY9jsVEatK0aEd/tX8MuyhKZg/ycnzPj/d9 +YI5Uyo0wXxhp9oQFx347nnptYvO1dk+Ull/LZoJrxZOBFgfaOFgzf8zScbNYIxTm +rph9JCx/l1yCreLWQB7cDyPVnsBxTM43xNVBFCha7EOj15OfUnydsYsdhTDQmy9T +oR6KQY606Kr+zOE2lG0kJTxUa9U/xlCKQcwfPmOHq8tkm6Z6qzA6kJUSNEIzyFOz +x8Mhz8iS1rulLSb8CCbmJ40re4nKkzZ1mDyzRbSTnn66Pt97H9WsU17ns1MSV+1f +F5iwE7ppuGGNgLjeOk4asGoU1M4Lbh8axc1OxpbPrQc79XEwWUB4A17Os7YFLHbg +6FoJ1dwQBd4Xjjq1yPvRKn7gmJmWtVIjF0KGBqy077zHnRn6w8jW9g7kMIafx9i5 +BDcYFMykT9OVpIwKcm26Nmqb3aoc1zqJ/OqTbEBMXlTLTNRyY537NK+kjOXlKIVR +0FBVKwx+QIU3g3GERIony/QAU6WeMRlGFDeSzwuBgqn1nbq5jTPcWduosIcngQCJ +AhwEEAECAAYFAk3R5p0ACgkQwSYz4e4BjJOFvRAAxIzSgd2GCG4mRADkC4FMWd0y +bjs5B++RrkyIh8eXuYdJIwxD8HY7f+N6nnBwYVMP5Ajp4ea2avY+NAtAMmpYXEfC +3A8L4u1Om26K4KbCJE3BCQGKi78IZ5TmCMFTRHqc/WN8FTcNEbh3tl0PzUjJf6Co +34GKIBaO5HricmjL95I71HzVCphmUcG/vdBgPk7Zz2n35cprJTxdnoc7pbBZ1Cxb +gNu7SYGEbOwtrShRV/cCs78EwKxXnr2PG6cjYV5Ud6oixxzRAlXi/35qsFT3UoiY +fNaehVsNNOESwSkqnhwDP1WHPaH4TG/BJkEkiWSL/nRzb3Im3aXnHWnpzZuYsjY6 +RS2aLk5YM12Kn/rT47itnG2k7riBer7IUJHarc5miHCc2+N5woW4xPtTTQjg5xnK +FGOSTWX6V/Lao+OYhL2vsFHNGNj/yWjHhDxY8b73+K5Rnpn7ItmApUplloIn8mVG +m0uv/nDWOF77JEvAzU1hXF+5nnWRVop412wdhOd07EeVsjRP5V5bkIMYIBAKjMaX +9FJZ0iDuCU7oOffDdDmUES5BNePRKKd2ZDX6vILgtPE+iYtzHrU+n4VpApGsquEu +s/2TOCNf1X34gIrBQp+b2/2FC0+5VIxbq5yUuYiw3ziIdJQJ2If0dEgq/H+x9YBI +cpmHNBK3buzVwUhfQ0eJAhwEEAECAAYFAk3UEKcACgkQ41LVxRxQQdQKwg//U9aj +S3UVeH2kNAHQEREfF+z9U/wIgZXVCKRCvIpJAGWajkcMA1XH2BY5f94zRCWUcTt1 +b2XvQ0JCARRI7/fYcFKCv3uVihT5Ibvpu48UxI5nOTyiHueMHU4QKwk4cEGgUDjO +V86k6cfYKERoMFIQFGPsceQHm4C7omIM2CnCMVaF6xIxzOTgTCRs7LQPUj5lztCy +Xh/FP4ejMFeR+iStnIZtxBJ3nr47KWI14q+wEhWDMsd5YwVUZ0BoEmDyWXIm68O7 +dl0/UJ1KfC/ZaBZOFNEJdfUhey2Bvc8hB7mudB5QkSnlByil/Ev2k2aGjAT94+59 +7DU9QmqkDhcO1OCmQxv6vI+GdcYbV22we6+rvqE+9ha3GSf+2NGkCk1LJP2j8NLI +/mxe2PoQG5YgUUzFPx00Oy0n+Rv6Cyzl7afIDyX/vG/jIcXnqO39SZMvcwP/URgP ++NjmIrkqNoZzPZSvQqDODyQ5e5ukGT/vx2plY2O/3ipNWeySctdoAHhyrAc2KZ3v +rxdq1S+iF8iHZ+kUXYh6dgmvfbTL0mju7n2z00vR8hjUotHo7Xx0cth/fh6553mS +5dH9zZSh1xDwzaeep4uSmuv2cUMQbgAvyjvg4ZU7qt9EYxUM2TAPEE5EahDdY6Mv +vQPlEHhqLpwB6XCbW4EaLlsvesJVyc2lqn6L1dGJAhwEEAEIAAYFAkzK1fIACgkQ +nDFQPG2GY5ayFA/9GPF7RCQqLZnCc1Sbas45keK4D9OwrDl3lbFqtV2XSt9b7kXJ +t5gTNPyFEU74sNhDyfiCdS5o/kd4NWsjyN07LDVrB80mo6m5Hf7mIGwXEuURRH+3 +hPaEzJ1J/aRgTHd9BTh6MELfH9GSbRaAJdFv+xaZSW6Jewb0WBprISYnAck4/f4Y +kfcJeOFX0zph4KY2BinlCZ1yebz4lOuOCeHPBJS+tQBNGXzjqTFVaFVu/ZlBfmhG +4DljaIrvl5vVrPP+XQib9uhSSTJKS34lM6swQucbwwTkXkGKnSD+KyIRMdndZfue +qU4McdTakZ7lz5VzQt0tYU6gsAfybV/f0C92EjdndgI0clgtEl/cdSsAZrzqS/RR +gbPMzBWqtpltT8jYER1gnBwHKvStXyMlzZd4YQ813q/r0vm+tJ1RY3Iy0XnXEiZG +UPdF5KLgyHRElqMFkugXc1c9Y3dyAYZixSURmSQRNE9TtrAHbujiMNvbfr2yNXMm +w8bUJANHm3IPNhZzfEkS32kGLvJ+7KgsnYic1URr0v64/gjSzBcdO/mDCSLYpplP +GgUbfcEgoyJHhADBCoYJ6gEtxHqirJDq8fqXnGmWUyw9HZ9u+XV38hIrrWpOAdcl +qPGB17z75K7TPsiwVjPCq3h1nyNi14EE2wi8ytmJuk1ytdtbnkhICr7gn52JAhwE +EAEIAAYFAk3NKS8ACgkQGLP1D+WSPBjgqw/+NMf9Mw2GkU8efhpXFk1aq0i6g9k0 +JNfAqYE/2r9LmrJbdBcJp9Mg1mdMgpMINKUzvGY15T68JJNL4QmqTAAfNxml6WYs +J5GSuhXUAoTIBeU6Td5hYLmdCS26yYtVc2NK47oLVo/8yrCoSucSkEFXBm3hz7IR +CxaiSWr0RmiRFTG2Z/Kumhts1Fx9Z/I7iCSHHdtwWpkMxzMncyetmg57dX0uAXwR +89nd62jE9Oo3UHU+zGGHqJYcreeOfmQ415i0zOKfaOQmarQOenJpL5yTN2msQbFd +HOOimdjuZTl/xStTtvUid9Wta7FgE+Olp49aOExV/tfg0iYIoZpkWxSd7TVezIAj +SeRsHjV9ubJgqgQfYaIvqmZ0DMHAfgFdgWgXW1wN3WzDDCV+L5YN7Irn7IK419e+ +lbJNYmhZ6nSA9+mNj6uz+W2INQvR73Z7dfd1YHpUE+cO1l2xnxDApdsuBs5lb0LX +tugo1Iyg7zVznLS/HfF1hpT6YwMFI3MmZIKyxb8gwptM5UrUIfbg3Hxp4HlYx+RG +1PvNC9qK7Ngbdixbp41NmMvIoSMFX/5qPZBZKnbo8GUQzBFyLQ6UaM/h/0ToTjCY +Yh/h63AlkTkkRPj53O9Dn4h1y2B7OZKO67mHU4y6Qd7LGwddo/CoXT9jQ2pgxGAI +EqOJXy/Gp0sCC6WJAhwEEAEKAAYFAk6yvRkACgkQlzJd2Pn91QZxiRAAwD39gJ8g +kddxJ7r9mRjBolh5PDkTkdrGbOp8BUhX6jFcbXxm2hbvX2Qoll9T6HPYws4IwJjU +ZjiorclxrWrUtl00bf5odRacj7/fao4BO79RibaZ0yj3FQCdOJXZ1sHEWKPHT6lF +4ibZEmch9oKseEhOUBbgyJ7MJ4U5ipJGSYoVfwDHvgSkVm31huWZ7mEFvVch6UG4 +UQzClMg6VNKAP7qqNDD7EULX51xqCy/Y0ljIpgIkHtxTqYKNlkNweKt0/wtinbHD +5O3qP9rXAgEGk1+HvpISUIRKFvfOnX175mGettpzPEupMmb5mfovqZsQyNHEdBeJ +zpNdldZIbLLfmw71u6mQpJF55Gyr3x8cLsBFS1zZ1f6oWch8SSZQqz5hzizL+4U3 +mTxvyvOAtqRDxiv4acHx65ex41R/5VYTwz5+uvO6Zq4ieJ/3TTT5QpemQhh5xSMB +ZSnQeGIp6gor0pLfio8owgHfZwDtMVM/pJsQxxkOWVIM138uakksPtAvhTeVqQ1u ++aWvHtbBFHXX3zH1jOO2H0brKDy+Dcx8BKM/2MKXJ43LPJxB1tBHH41g1h7kj/nT +DXaWdR2V2uC9kmu4mNO4xwvMG4Vg5DNTNEFlmg8jnEIDx4BvRk/nXRV2c6++YIz4 +pWFCsKG6j0M37yWMqOmivT9BYgsefDGt1ZyJAiAEEAECAAoFAlFHtUwDBQF4AAoJ +EBJfXGff6UCElD8P/i0RoexnuaucDp5a5ikTYc3IlK+18zMiCrT1JZYQ0B7H31cI +i8epi8Fbi+3wXxdgxhTdaCSaPUp58qGScORL4MBSiopTwFJoB16in9ihcGgGCbse +mB0Hj4ONl4NMWUEcBls9D/AcZm6jyUSZR0sfHfrY4x/Z6oqdyIn6AfzhLv4vIylx +QDJFgEa8SA77JRpP2fodAHHnFKdbJkoyHecdlnCvPK4X9uGtNyAJVfcd6MgJETfV +3Qwux/+bbTNOBiep+aWDr8j80ZxuHpiQWsBVOhMhyDTM0nHuAceTaRucyS1wV0Ug +Uewk4uo63VGBfDRr+1wI9DdfDgzXJyrVjfdSKOQIyBFiTjhobmDLt09r2LRIhy8a +ID+p42TpFBr39fzWnY1Yu7AdO+/VXXLjKX3jNPbYh77dUhm921tcOLSnx2WT5zyl +JCmRGVi7tv1OA7pr13IavdeGbgYGXjpzzxFMKPPEjhvty/L5oE4mhRkN2DiCMNfQ +8DIntDiohvo+r/LqLfkhqHs99VrAx8qLpcrq4apj04iANX86c/jw15AXEiK501BT ++9XIU+KkDztZVpKEShoTdAZ2Osl6J/9YkBf4g0ifoYLTHNUQLUBAucpohclpyjQT +aLisn3QHmYLvvvBxl7hvNvND4Jq8ObnqG36YOa2/DX88Atn5pj37xNDqGpk/iQI6 +BBMBCAAkAhsDBQsJCAcDBRUKCQgLBRYCAwEAAh4BAheABQJKC3nMAhkBAAoJEBJu +tWOnSwa/IJ4P/00Z8uNPXlLmQLDomdegXiNmej1vkHSLJ6iWlGvgFXfv02G1MShu +WY1wFs4a2pdV6QFTaWbEn0lYM5AwWvmYmilpGCJQ9oWVaUkZrPQCzT9H1PQRo9If +JI8HT7RHKUKwdqXR0udbJk+OFTA2rYrdj2CzBbvW4GmMkb3MTiMkinfHNIFaittY +gWE5Plv7EvQfYvYsbwejso7cWYRqV47/4Rt6BgIQwbFYJ7dIPC+TDJsCmmCtEzwz +mRAP6jFKGBdPualcCN/t6U16oOhyAMuZML723nS5M1CsBb8V1LlNQ0tgputQxhHq +KuXYJnVkYXT/7ydGe0bHDIdNmQCXOzCSI08PlmxEBclBrGYcuZLovCCFh5zyKrB/ +A7MNDcCUE+eiTJu/C1YzvyWASoovVKbYRozcAIKVe59GKWGwueZNdDWDFfR+BaAy +ummeUpEOT6Kt4kPCTVHpytwtJyrKpQJtPy4RIGiodDVV5/XFFR7LoVy8TwB8emFd +xT2oNfXIAMLSFXsn/acvmx6yL9nQ1u6B17jI68xJzmBcMlVzyUoDy2A9zDEY7Le+ +s7MmVD2N7IlTrWKO9e0Hs5kM+z/f2WFDCII3OTgYMY0TesUJmxPpvldN1jj/FYIK +wa5OUBtt5l6ppnNOxsCvdlQisi/cUbPNztSXzHp1mGdCOmjhiD6CB34ZiEYEEBEC +AAYFAlFHfhsACgkQmc3qnaQTWzh/OACgn5Pzr6qcdZoy13qb8MkXrIIqZokAnA8w +5T5G+vQ+eyzcPO4mH7sx1tTEiEYEEBEIAAYFAk+tJLUACgkQ9t0zAhD6TNE6KQCa +A+gAEoGBX42X8GvfSN6U2MPzWeUAmgP2AKa56GoLie2cCB5c3yA79tzCiEwEExEC +AAwFAlNVvq0FgweGH4AACgkQvMseJzFyYtLE3gCdHflt74faJ8JIRePEymr/ElLY ++hcAoIz57H5i9RT8jFOG/grAsJ/fU01MiQIcBBABAgAGBQJTSY97AAoJEATDZ8IY +rdT/RsQQAJKfoXzu8VEJ/fYVsJvy6RfgTpNZCDyCGMOTLklNLyVS7m0KjzTdISCi +Bs/RZJiZcJqtgVxPLHM01ofoKBJkx+uFt+4QxRbYgsC8AuLvmecqwYqAQoC5r32j +l029V9IpKv/BnjzvUr03VqT/pj0w6MBzamu/+99JutRZvUjNkPZU79gSY+qxJBjc +GTb1UgfQjbI8d/W+dbD0iLrdDb2CDY9vO5DB2PWSYVK6VGneXAo9s1/rYYmdgpxn +FSNhR2j/brpYPngKWU+hd9MigApawSX6C0TGqE6iIlAH0RlXkAutGBs4GmQja5pW +FEwgrAcVoNu4FjD+A37pvq2lvV9wx8JBO3RxmxVuDyt3qzLFmrmVnmlEOAbRKzil +T1LXgEGHW2vqp1weKLgJY584SBfK4GKcG/PffFNr7gkZ1CyiXPctoBsb91TSGRRZ +Lsrdmedcl8I+tGTzGYf9qxFrmPy+Ogu33VNV4Z09/V4HOkO8i8jl6BqpG5ez4Z7H +Jhj+UI28YOJj5tgz5jXRhmPsMVniAgwO4JJGDSzI/L/MAL6sJ8qRu8tBH4q+h81p +KE5eTDmJ1biseuRL515Pcf4F9fUBssiAbp2ir20IWHFFNRaTR0vS8XvpRUfMJ1zI +liRmsZNzM+xxkGvStRR1q/thhT8D5aklAszu7PXBXm/qasz9ygyMiQIcBBABAgAG +BQJTTZnTAAoJEC6na5wrRm2dxGMP/RoRB3W51pSynV3TlrANJqs3Y1tHWzuFRbPR +U9LxSKuqJFkZP50KD5zhjym+pWkaLOs+xUyJJefzh3cKJGdkCpQLwmmYGmmmjGM4 +fINeNYxcg/P332Bkm44Xh3U1JubOpO+hU1Ay1xKNToP62/dYoBgH4mVucsj6O9QV +xHSNvMnjeOGjCGbDpssOh75PXSk/5y4JFGB9P/DdS8vemgyQO37gq+P3e8erGUFa +Uxmku2re0Z9+VuzwlJKZhYKIMzNqmAhnVMaOfERYxGncBMG7vSn2e+GaR5BVdZFB +aPjtWrftmkB1KKV0xxi9nsKjfFKtsU7TCcMZLwrqM4VLb0xXCNqnVgvypX+c0FqU +7ejIfWkgtiDNogiD36HMMJVtesVwMdWqvh8I04t2+kzo2sG7eRMW2bBSBTmI7USs +nweCRCKmyvCpD3SXE1wVVJyxgfyaN9/tsDcujGTYYnd5f0UHiQNa/gvDhBUM3KU4 +vwkgwzhGlXU5sEzq2UZ6W4Z0A9+GmN9OQCMrYWVJF8kGbqrs3ckcf4W3aTofWR2x +GU5uDrX2VmyarGJVRmTJkY1xP4GCVV7BbgZH+qN2bUgTWYQw/cp9BX5NiW1HLYWT +MAx/Sg/mFcwpfZoP4oFOCOJ84X9MMVSQltGJEtRpPqntqKSCLTNY2DJgxl2l+fVQ +MZahTJ/giQIcBBABAgAGBQJT+8BKAAoJEGSVn+mDjfGcNhEP/RMiWe55OX9CHVb6 +cM7JfKXJHYTyJ/Z2urVBfU5Y4T1/cRdXZ1VWJzik6lSyf41L181f5yfwX6mORH32 +m8GhzSR6Pjs1x8LSx8tIPbHXd27ybzormgdEKK3tFkUgLtn9zN+XTjIxGItewbpg +OyNYW4WgXBDsycUt4Z2SnkZxkJizGIYskknltE382tFF7fuvZb0PZb0JJTYmTB7J +xnqqX/61HYN7o7slVHjtc/zwpfhD2bIYGbUyIeskF/hxdaN7Ix925eXxL/R5NrVu +CBI/+uCz2CxOcqwyH+vkFPwaLVXbUfRacmzpXynOFI1zdwJ28rzhZ01F/bSSwPXG +j0TogicZwg2Td1cnnBcSAkvrsEOjtKN23ed9jI5ldOvm2gRHd+cZxHgcVSec4mO/ +ftE8uPQ/kr/Gj35V9MYkTkXXXM+tQYqj9OB/wFumDlD771PY22BN6ZOjZfV1g977 +ENH4o1nka8JVy4Tn2xFHFAf+MM6MmyxYCLXOEOtWrRA/ma+h9Ltm9dhaD7k90uat +GL8aeiC6WO9EJPEFJnvwnSgQFp1zysv/JE2BkOF66UaTJoxRJTj55Pmly7Ht7Yys +ePZM/018uEUJU5n2/h4X1qTOylBT77ROwgCgVv7zVZVA/n3UThPYY0b9UIRdGaIA +SKTG2DX+CQJaHP9BI5pl3YOXyHY1iQIcBBABCAAGBQJPrSRhAAoJEDk1h9l9hlAL +JwoQALH1QEOWP5op1yCAZBh7/5SV7wnt8wnFrzt6uLSSmB5F6JFR13vuo6fspsVs +gz5KwBWxEhHoRkoD/Q3VtwjjgtcnYfLxOgzoELmBQGQoNmI2ATb06wCqiQkehwK6 +0Xpv5LaZpq9gDbSlwqdN0t5uDVzosPyvc5xPXpoFu/yVFAMRCNXk96Fd5Y96rxNR +o9bTS0cSgDucuyPr1UOY3UWQkr5tC60a4j4FhB92pzMq6kFvhfEzsAqiKD37j0KG +bj0an5QaJthR5sViMG1uiTh/9VN2sAnJm+8MORePk/WKgevN6L1GXmXD4iVYVk0z +nb1X14Sjv1/DVMszIrOCg0eOB8eOgjnXnAB8b2g2u91cnMcnzbS8/g2DryqsPZtY +1nGtQtjvvNaVLAvM5axglSA5NwoezSRjcJnRtp5bOazn9T14FMTwMPVeFhBTAAzY +lKM1qOrDv+5ChYB1D015Urnm1NqEl1rKxguLnwHE1yjhrowrw934g6iWG3rpchlD +rzGuye/lIccS4g/L97gQiuN3ksAxA/5HETEsbOyVOLs+owEggB7Vl9M91JrC0rd3 +GaMv6L5SiAEnZqrabVoozuR9UUGLN6BK9z7tpYHF9zSaMRz9jUD1fAD/SpxCn7Fx +bDx38VF8cshVK9iwOHeU9UEbhOzqtAvO7HV84R3ogGgU5BEjiQIcBBABCAAGBQJT +Wc2SAAoJEL5c9ofcWrfCNjYP/Aqdi4wVvHWRPdLeUVNsH7xWIjUN8kbFbapk1c3a +1RzmZxXpz1CQTulk/gMVirqDFY7Kx7iQMSN1OWM5pJjhVjrX0mTW4l9xLvo1vw3D +qcC4v/1/2mwB32u+plMMQwub6128rXl/rwHcqdw7ZCWFU3zuCHjhjFN2GNmcwkJo ++mENwAu6RRKIzUsHAGXat7fugy3szRdixuYoHRgT5J9vaJHqggK+h01nZJHmLljc +a4+loFnHaHVrxaAHEI9aH31bO4S1xI0skh7ppkX0frky+1/qMctTHSfXAJmmSNnE +gc89bpXhGJr6PYIHM0grhJxwm/CR3EgEQRz/7eJGvVysDpCpzGtsqmZEjmVBJQ6Q +fiMm3z7O+3d2hBbungBH4ogiuU45z2ceFMRaNwvz4A5JQt+Y//S2ejea5yAjYnuk +bX6CFNf3zs1bA3TXWAgDtD5TLTWw/uL3z2CgV2F4jjTaNOPznhtjFR0gNMrXjpUf +Ea4k5Cnc4B2nkN93jF0IyaPno+0PIJm82Kc0XTrabSHHwTiTMKZwC3rNL4MDiYLm +dgujug1xk4hf3stpNJ062LCUr/CsGeiHu/cqunqzg1MsEOwsFtJs78PUfYWTLYjU +nrEDvzylrobHL1wDNCzLW2Milu30kuBxg7fCErF1otsp+D/IlRW0Ae4ZD631Bc4/ +91gDiQIcBBABCAAGBQJUAQfzAAoJEE+gSkySV37Em6wP/jAibvjVUuv5weSHffOD +uuxDm9LunepowpMCK8VnqFqhmQIl/hfDmbQfrqmECedpvY84DTyv9ZZwyi5U+C0W +FywYgv3ViudTWMZVpvrGgE8egM3df0H/lmcGkBKmD/7QYltegcjfnWvmzN5j+S1+ +ignNaVJX4GW0jlYmZcUxDOIz6JxUST1upZ0LgPYUnOAVLPhcpi/SBioT+8U0gkUs +llVACo9nb6cnWIcMBk934EpHibujOwW+hy8vcX6YmZRjoeiYtpwyluf1ZK65Yuia +KqXIYq5JcirPGoCwIYlZIwljMJOMjWQUaPxBpL8GNyTuMA+/Cf6O2C03dfXCPWv2 +6peKMGijPSJowAAKlajntkZ742XiNps1IF/8y6zEmmMnRfOi8HBBAoU9sqgKV7bR ++Rpkx/yTnxHpR6ogxAlQZ5AfhBStxihLn+oZHMh5zEn7HDOxdmfVe9+gMf8fNEHA +urSoTW2/xosqynvEcNBkDT+DwDIrWZpd1OJl5gz/CsFPBS7C4veFO6lOJGZAW5Jd +FiJ7vzR4fE0FsIyYBwn50uY8MdkzhcKA5qcPnLgs0meizuXVK6T+Eiazebw3FtGo +To3SlBmj0SXazoJqjpTbVJxYtYfcLNsoLSZFJBbYb1ymUw5ScRNyEASdxMI+Gt2t +Mkoftvc0iximCi24aIPAlehwiQIcBBABCAAGBQJUA7LCAAoJEGc6A+TB25IfhnMP ++wTWdegjdQOeVgJf8rhzQs2iWAvX0Ns4mvndoUqpwfAZQW/AGvM8EG0B8SzJe1k/ +CZFCSDL9m6kP/qi3oLASS9JwCCl16BNwe3irzZK+vlQjaiEbGTm4XiT97LyHaKFS +Ez/WM6LyIgF4e0Wi/NU8/UbKmGow2poUWcy1BHhpNbOsUzQ1lZX8HqxncP/0NVV6 +41wyTEbbVa1X2dBuzvcGJiUOPM+k6liJ9awxg8xGB9Ix6o3fmQKP/qkFeMM6C6lA +Lmj1O7P+MtH9+87nCXO/Dssrq8xihszvY2NJigWiFozpzATclbuDCMRJNFA3IA+9 +cq7UzGjUYsKRdRS3v+Jv+E40blAb1WDNusnQgg5Uq3LesMbJaeoXfCi/dAlC2wiH +zVOQrtmDqeWARpbxE2BLiF+UQCpbbKNjPcA9gSGRY+iQsBjRDrWCKsZzmvE927UX +cMr75+HZq/pznZvLaXSpUIVSZ8ZNDQkNNvfi5Z9x7vQli/uuko2jvPVYZmfyoEjx +wH4s3fPqATG7EJmLFSSL1rQwUvqb/m9ax/IIyhskZ68RpmAVCgRhEZP0hoKNchxl +mgPnQMfsiPMMUXFcIPEjZJn0nL5NNnqpNMH6GBZlA114cSN2DGIjQK4/ZGfQdv3b +ZZxUowML6lScNFFglDfECtFohaItInkHSGwAK+VBMn8HiQIcBBABCAAGBQJUBRwm +AAoJEMD4hkzaPQNYnlEP/32UVoj2EcGMWzOxfcIq6Y72Umk+QW9NNrn9khDA77ti +UwwQQIpU6i5GiZ3/tPHihPOZPnZ35pvbe/iWvcbKXEuZvk6TXarkE5asDRJVlW3n +lh+jibMnvV73zWRYn7D91hOQ2dopa3BgXBqu6PTvmXmG7JLXztfpQd18dOKfHsi8 +l0tKnX/hopjmxUgj6iT8iv7UMtSMpROnzKba/v+s/fCBYf6Bu4FQ89PtGt88JnmA +66D0OT9O8ocMZGB9vPJsNgzD9338gVafLfpYpLmEoj/M2hsFXfTsQFi8mvI0Mtw0 +MQtFRHtaSHhkXC48KIQiRSKGM5d8+ITy/LQMpdtH0sLrdjxIQwYC9W8MggDj18gj +O3VRJg16tvHxWtv52y+uY70Eo/ebt1XJ8u3cwgbiZvSux7zH6KkuV5bR8FtS4uuJ +34gW8dSvhoTY/8dQ2/4XV23hHNzXvmA2pJN/UHGp9iAu8LndGnieoJQ1AtDDJy5L +l3jiPLrKDNk5QE1NSfma/U70vTiTKTvJvL6aw3DqxIGL9RyHjH6vpQCO9sU6TCsL +B1X5ABQweamZtHtwYovcd0z7a9ddsJAzoJn2RGdNFQ2aSx7v/FpuX+hz3ALSKOWp +9eXwPdxjM484s9Gng+ac/ZHwETOCvP8mZsu276VZsrUqLVkO87anmDySUA5KWsKz +iQIcBBABCAAGBQJUB77kAAoJEDtW4rvVP9yxJLAP/A6/31I9gq97iCLk3/asRL07 +A+emkApDvXClLRRo3ecrB7qCqFThVVJowivMUx1x9gDAXs0dviAIjOkvqotA3Qd+ +O66jiTrktF2D3reT3U2Hb7ViF9BtL69cq7cGWSEH2naLbW+4nsZKe+Gojya8irtJ +AwDclyJ81QjOSwiQnP1KKokD7GZos+QAFjNyBjmhI82DPms5sClW3JhnsBF3ijjq +XjvUagcEYQ7h/184zq8PXuYwpteF+Hnd8lH8piuINyJukMEZAObBeeFm+HUZqK4H +E05T6c+ckyPr+opa7vmtdtS5i7Mhu7rBd6KjPpvVf+Nv0ma1de1xw8z2oJGzZLTe +GucfWyriWz8UkMVYAoQdltyEh6Pl7Le5y31rAQxQ1riiRVz7dWrVqyDo9/pVWFhZ +LAP6sV9Lnuy6+N0hFY0cCG0ijj3te9VUo0I0+pzIwzdOHvcB2QWoYLrOwzqEuN6x +JQm6tCPwxwNgMPVK8kmFYG51HReTtdgsCnivBDkaODx20rGpwjHLDaN5tCRlP5qz +BEFMAULebUTXomPgCE7InwaLFN9UyuFGDaAqvLt85g2RRG0xI8BXRrta7AG4eBSz +hASpCg+ykZNtFGtP0e4P+UOJN4udOWYE3k2Uet7KIeoyszklIbADYFlfVxx9nMZH +RlV0XiOhSgjX599yGJOIiQIcBBABCAAGBQJUHC+vAAoJENkp8pkr7wozjIgQAK54 +FxWzQPCJ5wLIhWNCpy+OTc+Db/v2xNgc3pf6tzhuNhDRlQ66s0LG6Lk+7TQBJ7bq +mY957lisS6Uuz1nfsYvDefmIRfEH8M+0szLxkh4O5eCruq64q2ziu417seQVoNMt +JtESwJ4BDJWyKMmbMLYS5fhvNDb4FZlYDwIy2Oa+tLMAPeClo9Q5+pkh2wX+z8h4 +a17WrNdjMRhjQZjJBrJBMchLzyIZweKqKU/0sSSDjks0kbOouSFcMCA8RWhX06re +UkbIUQN3KqAz+dYuegpAy8Z9UrLj2gm6PVkArdy78KWTxWF4fXWmf/2u5U9pyqNI +MM+0fMdbRv3QrWS+iVqPr2J6TEnwFLsKJq/voS8GBonQPAGbS2r/vM08VArtC1Km +YA2AX99cbS0pQm4rquRhaba72Bxj2SOoPCfkrAvyOppAzzX0fCexcp7lwGuLXSqe +rowdrcd8ZojtpYoD+KP/loY3CGRrSUkaRGAbvXt+QnWpbuDkPJo0mjijwvk5e/LU +PNSCloHJ/Uc5oL6mJs1aRWbssu/Xx/lMawYDwPfAJvnyIXTNIj5G8vxuvuQf9x7h +1yk2++JNvNPR+K1MuhHWeeqypohQ17rTm/rAUj2+sbdRywcYFrrewSaMDODEK32f +J+e/d5C2Xv9S1avsOSTZkozwpqzFC2v1G7RPCMkKiQIcBBABCgAGBQJUAoM8AAoJ +EB51mnJqn910XdsQAKLsZYUckS++VHB5YAMPcKD5kej3tah3DBqJMTqPlm10hMLo +eO3BdkjrUFaFgf07RxUCcCUsdfU6iHpTmzmKDtJSJTwdWsULUEm+Xnx71t0CKz8F +zTZr9I7P2pKEFhQh8IAnYmEuSqzD1VOphOvEez4vp8xOMBLuHOhzjly9zdCxL4wN +sN8GvFvfSOJUUYC/xLUauruFjeTm0FWc1iCFZaxa5kBly2d6tEXfS8bQvk8cA7ch +zIBmQrHrp3STqI7qrYJ3gEtRUZiOsz3l4BSk4XVE0r11/BCLjUNijn/hJcmssDRS +RLif2XXx8fXuPxb0hxpp0o6RkXrPuUDDtgR1ovZPrV9JdLxjgmYWslLjoJU/m2VQ +ruQaUzHaho1z0V1hfV7MsGv1WOwATAhBpCS0ujKaOo0pnnLLo1IArVuLmsmNyl4l +HtRYdIijkiHzG7NxY97FfMH8k+BoiW/0uITm5/plT7yLtUPqxypyrd/cf3fSMj55 +J+9E3ZzYJf5JjgCUuzhNv+fSR3LLnesQ1AKj0tmj3ztSiqxDHHTsM08H7ZZZeLvA +sZeRzNi4pYk2Xh4RHDcv7GwEAVnXO7n/ucj7MVTWlzCEp4tjLQGVVGhlyvw131oK +Jw+V5Rib8zsLQbLrT6pcdueDAQOfXmOgXZxJjwL7q3MAL2lm1xDcxWp6pLloiQIc +BBABCgAGBQJUBze7AAoJEANqnCW/NX3Ua3wQAJ9tHFyUBLm9qZ8zRED4jlBm7Ozi +wzJ0OKAP1SJeVePnvxwWSypzNi+j9N7Gxn7GlsXJ69aqfpGFbY6XwRSh1qtGgJJA +LzaR7AzEgmMelMDVejScssRN/XpZF5/c1FauhDn8eeQUHB6gBwN98dqvXJF9n+70 +VGgorYgoWqgycTFkJi+p3zzBXmcC4jbsQioahHtiF7rtHO1RqDnlGB4hZPMTzcDg +tuhaGBT1FWYXlPpOfd4tRVLbPKK6/FrqsUTBt1tVKpd1qg0dKDaDMssDKKXyDzme +OH/fzoZol7dnmF/9B5dmvG+jeP0msv2JamRArZsgbzVQitCRQIl1tJTGfG7HGx7f +6WNCCtujmmzXDYISbpPSZB7Va1DAcOeF9PabXLCeIGxTXIMEij5ci0k0DMLAOqAv +Do7y+aeNUgREsi4VcuQktO9bLtBl5OPB+D/HrEjWknmmbC3mpzz+pVWWfOWcdPlI +tMtzdaPfNAFz5KGvGSttrJSTD5gx5y1mKiAzFYVu+Tb0OBjNrnktUcJWrp+D1GpO +pgU8OaZLxvcQ8Soq/SMip7ekCuvHMdVKXYnUS6KSWdZrX9STl5o/IRXdDCp2Vvxt +mNZkWf7dBWV7/VEPu3TQHBe8r0/+KlNOUzqaIICvQf3x6CFPeIyk5UllSh9Q4pfK +NH0yDayeQPkiAmPNiQIcBBABCgAGBQJUDRsHAAoJEHUatd2nlnnM5WcQAL4H0cd2 +TjWXOLj+LTUgjSJ0IKcIGEOQv0PpXC/oBcse/PvYQT9PgjO2roHyd/gKVmwyW1ia +VQATo8fukkWsQAg//+MX64UEM94iJ50gAoihRHvI5vPlaLe3L/1nzZ270gEJ80KC +gKoz4551EiNaeiHK432B8GMb4wRZOTe1aJjbZBFCDzApQfZ6llwtLtrPrseRdMRh +i8P/8XzOyDiq89CMmpUbauFIH3jAct6iHxkg6KWah+YLZ8UiyEEoQrU9iVfF/mL3 +JU8L9s3eTGpAXtyTAh4iA0wkTk6+mxgA1HtKbsxOU2MlAMOdlTIzrBb3ChS+po5D +d3qCK1DoDg+ElDsLAn2E2midqCFIk/V+JCkSbSy3jq+shByHr2i3yv2k1RjSWsmR +kBvE8FQPu8yD4gA+mCUvwW2hXQa1nHcIXGsd5InPQpRviMRwwJTJhOSUvBjFy2AJ +cqCRnN/wVblFvISJZwD3zwZgDBx7cM6HHW+4KmumygGyKaUgweoEDE21a9QncqXP +WPafUB5BCjo7Qwv5V52cYi1OyigoPaH/vaTialeljBazA0165Ki4Ty5GRIeOEAC9 +cCyZmRcZ2p0A62SxRN+s7t8WUblWLIxzHmBuk5cLuymKtPjDP0AD3LwEy26WJhIc +geaEM1WFo/LZac7eQ5vxglYez8xR0F0zGo37iQIcBBABCgAGBQJUD1XsAAoJEG5g +i2N9iWfpxL0P/3S9jNjUV3BXRhEOGVAVnbkWGegW/rjvd1qLB7Z2WZ0fVpqWF6Yx +TrcMVvGuA+MXIOhVdNJhVbFzVw34cWpBCcqtdm3NBexCwBVwtV1vEH4Lmx8RFkjC +TPSvF24bK4nzs+/2BwBtFIap7DxlV0iqWRjPsQxYiM8Ch2qAghzuth8bBTE47/Xd +OmPBe4GiY8XxdEKwtM6Ippekks8yX9x5ctFoPYroxPXN+pYAwEgWrwP+0ajPmsIv +bt8Vfwi6mlHHq7N/46plkFAZ+xTxxWSoyOtFT6BrnrBfHswdxmEtXuRevKFzzpB4 +AxkAJzHLKoh8feItGOsiZKySWQtWQQbl09qb4mtfv5FZbjgKE0/hsZ8hFtILnUIP +x4wXjJwJt3e60+tdhXWaEUNYfX/WaE4Xl7n4/VC1Kt595Lva1jmLJs6j8CKtbrRr +lJURQ8xDTK5evW0xAApQYZoNe0wPrcLlu4k4S8nokM03J7sCHWbGiBXmDXfhnvQW +RudJUm9QWhv3j3jp36qiJxIshk8gPyfWpW58AwJclyO+jb0ucz9o+3HK1ZL3Sl25 +zGOmchyfT/Kj2T6f7xfvh7O4ju24J6iflu6kBrMTOLMFBtLxxTI8oo8ZQO8wm/va +r3Y3M/eMmZtWZTGyXPNBFLeou8PDJEjnpGefjRDTSefRW/QIyxUTPkbciQIcBBAB +CgAGBQJUD2W2AAoJEPs9JYM7aq/4XTIP/j6cpylPIk17IGspIGbG+KQy6ZsMdEVE +6bgkPF+xsK/MkeT30UigZdEtpXWgt/ganPNUbzV0mJkdaahXWtATvgrpMjBCw19S +pEgzxgAhbb6wWPJoFbsv/YlHpOuAK0r4deD9X5zwGfOqDt/BTqyL3q7k7T8Pzgq4 +b97sFXM4TKjXErNozmUYV7O1HukLuZss3laj+GUSH1Q3REmXJzKNEdJbpOHaLB8D +QJPtE5YCTD8cMIwNmdkvog/DXv/0yLxhidoDJND0BTF13XSszIiw6Ng+X/73W6KK +DN9otEE7lkr1Opg2qzdUJNAv3FiOtvs6n++uPlsuLcWmZs7o3MKlZVDw9P/4T+wI +VQs770w3oqblQ2IP4iQpVs0RdlgmFI8QK/CdiRZTHOsb6WTmGQ0OcDkADn92KjLa +vtvqRubffUGr4U4W2Fy/moRsRPVYK1XRlAMw9GoBDkkM5AGMlUBLvYoMUlsmbwNg +E3f5+gUIyew/rBLH9h7mB46B97Ma2Xf+MgLi1yS5CWNkcrGzuqmwO3ceDqCpOI2A +T60Wm/8TZDT9UMTIF3AVn5jwU5G16z5lWZHN/nmFCDohwDUtdYzHp9uUZoNErrC2 +Tm5v+aIpUSewh1+hBdABKDDhQEnd519yqhdSKF5DMnlonEf33G6R1y+8x7chkqRH +pWpBsiUYnckniQIcBBIBCAAGBQJUALGMAAoJEE+tenU4RVnbVuwQAKk7ApRng4nY +Y2Fi43IrD+GGIgZEsljRyYbO4BVpxF4xG+BhhkIw9JigP4YiDqVLWSSG6OYbx1I/ +pDnORM7YIwhjwatwkoEl700Lm/Vu59L70B6k3YMEj8BnAEcvIyXvpvc2wPC18QSr +vnWW7ir1FREBfjSvF/lA/zmVVRV/h8YLmsJ8D8cWvXrHUrEGldyJ/+KS6od6l37j +JA2QshPZVVaWxZXa/M5yYLsUktA+OPqV5ZCoR0I1GdJPy9UPIejVm07UuhoQAkrU +w+7ops+wNOst8rV7GyuDcfSnN+Ai0dpBijxb49er8dHuIlv5Eoitu5ML0S8n5VIp +cCZGkG6CZs1JvS8WsalW1vBqA0lt+Y99sJXDtXj+NTTDPgOhPpb5vX4eVVT4x/8F +WQNzTKUjJ6QzlsTqXkSx7Dr43PNr7Y26vwZzpZMeADGXYVIu2GaL+qPMhXG5P+P/ +rASgok+vUf+6iJAIPOp0noJSZwgNUwPqxptoSw2gGvU5Rr1DZ2GK86+GswfHu5El +u9DBENuP885WzzYDyQ1U9Den4BNh+xshgSiIEo6oIHXBoE6eWYXIJQmBcbXEapQL +j3/tZqXMRvy/9GN1YJ6A+lUiLtFoMijYiGYqufcz/SskNJToGjsbQf3PgVWip04J +Bf2B9mxCpf4kX6J8CYUGQ3ZEZsYmy8bUiQIcBBMBCAAGBQJUMY79AAoJEIh7YGGL +PBauzo4QAImXVlLopxkUbUFExaPrL4DIaNsrDaBJuJeowXNFQKecfBWyvauhfHrH +GDeZb/YT8xxfCyeQgDCtMYjO2+GPl/bg4AegaPXnOYpTGG2KcNZigqNNPU89tW9S +iu+6myMV9yDQxZmcIJ4BbIg625DAX063UhdFGXWy+esPWKQ/T5dU/ydw6bCzlfqK +ppn7pFnaQSBW+U+csVtjICnVFJglgsbn4k6dJuWKx90jR3w93K5Te2+DGLXNtPC5 +ro2k5X28iOX15F6VeZF5GfmbJYPVjoqyX7CwlGHFcG6CzJ/LlrtaRjvt2O/w+GF1 +AajoTpykV8YrAYh/sY2sM4+qb3VrwOmIW1K7vtg7YSYMV/1ZlIKHQsRcqcqZ3MjY +9Y2wvNJFv5e0wKo/ZqUl1OZqQcaA+YPYSoZV5VoSyTjkrk6ei227EJM5QS4Yc+Yy +1NypdU0Xec/K72d9TCEThxnU6LLr3YqbURhNIZPzln6g2vil3t2DbMjKKEdpaWwe +vm7iTEJLVun6ZVpYub7XD+B6svRPzMJm971zjlnei+WUSbEkZmI4YO7WQo3E41c1 +Ya7W8LdgIm3uE4tEnIUS6DFD47s1gfP+PHQH0OLPmwVnbL/6IOg3MM9LaSocFcfU +ny2reMJqWpmmRcaSHCEr/WgnrqDzbYMDoX+KHt8W9dJvMLCgTFSNiQEcBBIBAgAG +BQJU0E7uAAoJEJTpLfkqqlw7InAIAIKyKCagv3znLGiiEfOpkA2MJoRd2EGncpfb +K/vgH5ZlLU0AusPMcgtqVtUbh2dIQJaZwlUgPGzU2Vnd+33HQTNq1SqwtfuEEhsg +f+2jCtPl1xkucVWpJmFVttKlYbu6dRtUO2I9rE4sMLPy9gxohoYJ94Kod157MEgv +yB3/lzPoociZpbfuFpRN5oXDrHvLnOYsjtXt9EZEIoVyA9pwhO5geoDzTrn237VV +CJHnotz18KYDOHtaSi8IGQ5EIRsQyr+BmRQNZJcKZGInb6M5HR6Tuj+ESDrgj8zr +Lf/HSCHab7GfOBSEYEoz8muBZo1/iP3f6DUwfQCReg0aqP4jaJKJAhwEEAECAAYF +AlTGMAQACgkQw46BYKF4Qf4ohhAAktTfS9tMKq9anJTkaviDq25c8TSZIKJ8wMiK +iF23wdGVITf6oE1Jh5B4IIjnuVOqtV2vziZoYtr0WDPOz5HKnX8eF85Rotl2goRn +e4MpmxK0Ew9pdcSOr01SRPLZrJqWs8WYgLTjD+xNOTQ+giD4QbkQ04RrTTyjqJNI +MCuzLLUNcyfGXQxlhjMCr/PhgjzpevbYFGpKl/x4MPjRvIZ7m462OPqm4lbSHWYP +4Yw/TCOKKKhCm9YnJFvEFX07S+iFepdiDtexri/9YX31HLcSBnKl8tYKCd3LcVkJ +CJ/VvlhL32Pq4RXDWMoL2M1mdvVtmTvectNA8tzW46qcoJq5q4vMM34SAc7nX63+ +vPy0U/QtOGcIsxORfEprZIDKwUYTQ88sqppoF11CI4ZAGyF9xsyEFeyEclu5GCRg +bCurWt1V41BzowRpU6quKu6CU70wblJNqIss+osfrwhdPiBJ/G+9OlobhIa//byl +Nojo62l7iKiENNTJ406Lvhh6n52YhkeNMmhb1Tk0WvoyVCR5bE+2f8KMlAvWcFbp +n8U/C5cgUB8IAva86yfrb0gcVwH1x7ObH8uf4tbWBPdfRfDfjtuwuPRJIvpRuOlL +fSIUDBtEqh04zdCHlBhXR0aQbnwH5A/qwCcuWu/MXyFXbbn1FA0er7z6C/5uiwTd +IzsOrYiJAhwEEAECAAYFAlWAMjYACgkQV5MNqwuGsGfR0w//dPI5DUreAc+1UN0a +YnsMPhXp0GNgNMUQskKHQDA+1SPLv9VXH1KI7ULzDInQcO8e+44dOhIPIHTI7oed +DSffiXi68U1ONwGAlkDlA9vA2F/biNLAzZoMH+np9AjgSR/MIrQeiiYvgUiwGpTk +PTATogWqa7ECOqj80O6vJ45cBfd08G23vB7CR5le6JKxrUZCTsPyvEHUpofC9IvA +t6nR1cf0KoblyDztu16gaqEhHCl7TTalFoitTfE+hxU32ANoLSymPa38FlkwInv8 +XoepmQswdH7wohKC1ZWQjyEwuo0TvZJFjs31vlNQl0F4JYaWunyhYh7foq97ZUzG +Lb/IS4a3yciClDRhCOtl96N4NZp1bXqhG+PTc/7RokdoBHPszZbpnLPYBbhbLoGr +jIQhD69mglxkzT/9sAf+i7Ihj7acYCLcHTpqMTILu6D3OfXpK2Q6AeP1g0mcT+Fe +mrH+ORklJoWNn2QyT4wcci6i8w+UXqLkbd+D5HK2MOEJsHzXILzcczanskRwkm0a +DcrdBkyVM8VCNBIZsBSRaEjiTruZcNlSVJXH92EzwrXO/czQm/L5FiVxg1k2QVxp +ggplqrAozMiujaSIlwkf4G+6aTSx69EErYf8JqwRcEqiqMBhKcQeHFw9Vlz4bSt2 +JUc9BCh0EfwiHLwPJ7WbSagHM46JAhwEEAEIAAYFAlSQnNIACgkQuOUId2ZHWq9/ +Ig/7B1tk8PKQJprinI851Kuju62xtzVSrxGqma94aVt6xuFy1UxSche4chzAXTlo +sNgvBSZXWMePgUIVQnDyFYYSedFqoRt9cD1FISHwSa8zYbJJR6+27KwZZNqbFYNn +NKKQOFlY5sq4WkjyN6syfL/J2ohnT93ZSabUSOVb2yTy74jdi2Q2Fcpp75LvNr4d +gBQ5daJ6zeKAPasYYcob45oABOEmeiUb95miJ6kaEHcjtnL2gZe0I5r673jhfVyu +GJpNvW3X8leOvP9QoEe2voa9vKaFtoZNZyDEDrbI8v0iwMoTxNnqqScEv6x/UHlh +AcbJSFwQEATatRe7y3JHH5MssjHdI3I3QkdPvSwIW2nTjCGv1B2vxmG67AQlLyuW +JIEzo2fSRde8VOh0p16PZCrzICACxPU3nvL4fUsRLb8svbM8gMoGhKtkSXOg3VEj +pYY5nU/05ZsymJ22w5IALWwWzKek+m2jhncPnj+OgqtH2WJ8q4fgLGcKbVJVwKa+ +VwOOFC7MfHBCn23BK5MICGTwYUauBIUbDYFEVoFkLmj9K61ecJYj95AdFHLW15ti +1PsK8ahQNRmJ0bXbHknAEIrbj4rQSvEuL0I4wjQlulK3jPfKox4uMT/amyZSHUmZ +IgkXf9eVNI/BiTIiUCGsqZdICj6sFLND0mWfHp4T9zwLWheJAhwEEAEIAAYFAlS0 +hiwACgkQUEHxiR9E4JBEvxAAuI09e9Yl+ATkBZ4IL7yqWF+T3YnsmjAP1pCtWlsq +gzJBo1GFQ/rQ8q0ly1nQ0lficGPU5zWtXQW1UQMeT3AHsu63l9YfFzZkQKeu05vE +AKvV4UZkEIKvKoOEn4fs8sp1Bhub0SRueEI9rpBVov5Uil0kPrPWIrB9gb3RrHz1 +GH+ZnPRe6V3/irceQi/7StOmua+lkazQfoJPhYC93mgxAbC/Uj6l+cDZGmteK+Ki +4u1/yrYQUvCP/Ywr5kvBAMExrZ+7wDDHPiJDsjanRy1u7rKQfDqGsx68QxaPpbx+ +E1efAGrf1iiT5Z/3EABVK1zxs0t5hOct7fBUz4dVOqPffWmRDcbo8SfLpID602yQ +uhBfYXd099Mry03kN/g1eu5EIgWtEwfOLEr3CVVdKTuBDDDS13+IEJlUGftWC3MR +3aHt/meejeYHmAEW3KPQtyoQofPd7a+nlFAIZVwEySCa+AZIzYawvekXYtVcQzZL +I/4+YdHqoJDEM6zTXoCjxzdyPXVgc/RZ0mdQqg1QjNxX/3KOeyelIMqL70Fggtyw +I+LJ6DWLNQWPwVp2ATvHCsr3AqpUiRBU7aJEiOgl+SmG6713ScIkYHIko5cQCXAf +LxD7zmOvU54rU+RgWa+zQF9SEjXMqvU/WyrzbUcmuy37FfpzLO2cHFDVuvktBZBd +e7+JAhwEEwEIAAYFAlU2zTkACgkQx4jEwdRVDUUFVQ/+PrrzYqPspBP2eBuPF3b4 +JgONZ3K2KoXrvujB0bGVQezGu+QeMEw3rwQ2gChcWSNJb3NB0wxsn45VwWnhnbLq +N3RVdEyWTGPUUlzkqfGup5K13YrA0L7fWif/3qn/+wAUT4e0ddXEyNNiSBAheAYi +mXy6zYbLVTVzIZL6bUWsFDZpl0r+Gy1mydAzOkFpXS/HOD5LwWUyPmPLhCubiP4F +fB0MldT43UyBfOpyWNvZT4+qTdlDypuC8mrzpmOaG36nvas6QsPGmRnRoQPbpcOE +s3Q8r244mzoMTDb1mJMkqnByb/NVOm2BDRXkAv2Hn2TLRgafBE8lgBmn123OFmA6 ++eh6Ym81NYAXPMNh6yVX6ls9YN2UWpib8sPSw5QbE2xsNhgWdZGiQZc3MyDbarSN +AXJiaHl8MeRawybwPF7b8VCtsR+N2eCiunwEnGfYVpwIDpZjqJ/tQN8AgJv0SUCB +1P9Fhxl1X/iiOC5+jAsMuekAk3BPs2l5co0vKElbJJ02Udl89r15vRWXTWze2H96 +QWjLQCX78TssLXUU/eYaI2XbYdiQcaKnZI6rJMwGWvvk1CvWZb4NShdnddHvRcac +7bDdUGz+oY9iyqc6cq/twKgXDyuZKd36zHvfTxnKfubZsgImGTOVC31yxUA+C7pW +O4fMqWB7+aq/sOBiJQVONdGJAjcEEwEIACEFAkoLePMCGwMFCwkIBwMFFQoJCAsF +FgIDAQACHgECF4AACgkQEm61Y6dLBr+mLw//VdnC4YbYI+N/WGLtKfm1X1YD4Ian +fvmQan+eZZeuGIPaKY3bpMXFG24iX7//GBKS6t6tQ1si573ssnC1Uq3lKO07tFwv +TbAOx/e3ogSdyMHWN4QpPDEXhuoAvP4OYtJRrC0vp9XFNjMz4hfROtdL0LygUeoJ +qNrm8Y/3nOzp+mndqdHup/Rc+J4SEG3koGEqg7rWoTmT7kcvpExTB0GDapnbrYOs +lF15UhRdpWohTH0zokve3LTIhfb9PfyFJOAvtgvfD0sQ4bSMtSs/PMohvb5R62fT +8zCVvpR9t6lqIwwzIai3HzZDgocbBzYRTrHbSQsjnic0qhRMqcrB5I1jWkFRYmaP +pzXPdf+lsGo/aH2VLofFwZMrYHRM8APS+MDsnpJvg2J+Oy4S0wyTH2oQdKD7jXE4 +RH5J6+x0VLlhx4HGn1eXdgiZJPrX1rbQe1QobCzW1v5dIvu7iAbOreVyOZYcaHPs +hFCyPqTMMxWM3uzcigwmnLSdvHectjAoJBDl2/irInst6DgH/9YweKYvlOMTF9h/ +QfiUaMNO8B7FM9LYK3tbvQJ3GOgSEtT6/HwDGbwqPostihMJPTgz20jq5eGFNe+J +bk/ict+MS49DQkQn5iQIrSUnyhjU7XwX8nHpYlwBODmE0Tnr4+Ll1E6KEkM9vu74 +g7IindhxJuiACcOIRgQQEQIABgUCTDzl6wAKCRCMJNFgjwaJ1BBLAKCd7tgt2Dfa +Kduk0CDvvutagGbJeQCfWS+3fyqAFDtcoHHr7hpAUIqeT6yIXgQQEQgABgUCS1di +3QAKCRD67xKTbdPj7HTsAQCXnVfYJOaEU01yQl5P7Wdo/ZI5UpsrDKxa3+lGcPuL +HAEAgv9A37CiFDDQmx/KEt/sHuDXiOmFN4cH/Ap/HokcuXmIRgQQEQIABgUCTLN7 +EgAKCRBVW5delTuGk2otAJ9ahXeRiT/rb/7Ow7dE5wy4wUSodQCglYSAft1kuGXp +pTwJakErOOi3PxCJAhwEEAEIAAYFAkzK1fIACgkQnDFQPG2GY5ar8xAAio8BDeBV +4olApApTJB9Aqjx3f9kUM+qmLjKUcVI0/CjArDV9n+qws5NrjBMDWrCV3xa23jfY +8uGVc7G5YEeV1OeGknVvuTkNkbq8hPdnwqWFSXBSNRQoTHCUTR2cZ3mVKY52NFrQ +Z53Y37cXtr62sBL4GfK/6dPlKzVKI9NmqOUOvFFaQBsBO47NMvgVCPfr6FJ5IZEx +I7ZPZzYdSStH9xxeFJjwYtBp2CfgFp9lJxPKdsP7MRAlLKTfkjQd0SHOXkfwzFtE +maLd8h8NBDM3nTAQo41sHYtmYaJt4TcY2zEwwEbIDd0rVwhfFOQ0+f+gagNRw/F2 +Fe5PZI5JuqsFFdhvnOPf3e9W44XEIgSefOyzKozq1hQaBaQFqXGX+9HK+TqdBZGo +1zxRWhIzncVn+LVUtpVg/s7ZCf1ail+TVCKrmqXB45JSPUMj+WKAHihX3Rh94FzW +kp6r7x6EID4ImuvOz9ov/54XLkL9yYIO4NhTBi0G3SzA7VFE0VG90qbXA6S6O280 +SR6U/4nvdbono/afIG9wIHGOl0gXUbfQ4h2UglD+FXQd0JBOh9vMaTyQMG4kcWjV +hInXFsKXvL2qishfQDK1MyKYxGvNyHOaMdEieRof0UXbHUzfWRjtmS0MoA4RhT4H +YruiigwUAN9/CqCf3ppVOWw+CP7QmnvVMamIRgQQEQIABgUCTNXtXwAKCRAdqNoz +3c1oal5YAJ9ZTbIo3BUA7hZpLd5hYCWf8iLYJwCfc7khDxfiVqToq+rXrI4q+t8k +NLaJAhwEEAEIAAYFAk3NKS8ACgkQGLP1D+WSPBixsxAAlbuGFtT4Sa0h+xj3w39L +6+ZxZb0flkUm70CuYJx5Ww4YdOjkc/2LSAK+uiQS6XQCrHWfcf1jjL7GSf2cZWXW +vYCrB98lptyccHkgXP7wA3ga2HsZgFG6u/y3JxwB9N++KsbFJmtUi7Hnr9Ltw9Wi +V7cLglFmyXOmQUPAgyJII1nphjyhJdtS+U1OAy6fUJXXFDfMHd5aFNUhmUZ7jsho +3TT4s2RFvXBl+jbZNoSbzspkI9g+VyaMkxbA0QTgLKufhZqt5XKmtGser0YkpWJS +lVUC1SRJEac3NtHiylYVcXAfxdnM4KyJA31MO0lsl0zWVvALAVpVsEaDuOAaBQV3 +1+WOvV+VX0ggb7zKnOoI5g6XPXEj2YK1PHBieuyIbpjPhcifzeDw7JsonxlYRsr1 +n6YLvgx4W1yms9bMlcfFfrLjhgzhmk4jct1i90DHtX3GPJ7JMNludmVQ96vmC/uG +m/9BiVl00Sx4bpBle2xNwXHCPRNSWi4c6jJAVCofJZrAirWAcof0xYm4Zlc+8TTv +LZw+oesgsyMz4JOGL8iyHE01NxihrEqtfelqyaAxmrxbrkPNW6cyhJyVmAjcbRco +FHD51yaZ8gX5th1zarv8bffFA5EFhGnh/4/nq/4u5iogNqaYW8pl+Ljx/zLCwWE0 +JJt6CHxXYc9b97dsxswNo6GJAhwEEAECAAYFAk3NXXwACgkQRdd+njDLGxH09A// +Yl0UJqA0GMkG4EC/cm12nu/7EAy8i9/UXMBD6MZ8ITmw0EzNoVN/PDQ510PNo30R +CF+isOCXhz7lvBqvKDFJFnNR2kiU9Wn/4iUieUldy9LChTFrI6bBw40Hs+8Xvodb +jJyClE52qw9Eg5U9JCo2ZmZpjk1BcCiELpx8o6pkM9JPiXjlsRV/vd9FZba3cAWe +BVvUADmCioaBOkqooKacFJNCPRCU0RmDupVetKJ84q1q2X1a1Gt4vbI5WmR+Tuuk +PqzvpnebLYV02y/mIMEOZOheZxAfkAlgVj83ed0EtLFFoXwKQg8yPkxUoKnOgU1B +wA5CTlaCpGmQM567E6TI8PTN63ZOB1SiBCD1dKVsP9+ve9wioWjH0IwbygqEb+m3 +zOo2M+EHSc9AYZCtQFsrsUjNw1kWPU0aFAi7hk0ggaviwXemKAW+Q+xi882GXYwF +dl3DBPz2kGL0N6UU/+0ruBFrmxMDgJmiSevzLU18N49t3n5OHkvDwj4hdYlq4bhE +3z6lCZlNVyyO9F6pLRJchxYrXWB6Z6BgSwPCJ7LmfdrVUTViZdUXv8ooNvXUp+bk +f+jtI7j/sss6VcG3vwknlJWQ28mv6lWnRkad5hXu47+ypz9artAnXf+B/r8mbYCB +KxsfC3iLNcOfIGgwtCHbpS0N7jH5WUGP1ntrJl5hsc+JAhwEEAECAAYFAk3O/wEA +CgkQYAQmoRj1+84iTg//Z7YR8rqjW6beSrYE9/SDW7wX5hi5c9mpvLvtUP3l2FSj +ppeZvmIhgSEdGd8MK3hS/I6MCqRqIFMWVirgpBPRIRYNPSpTFT8FNlIgkTB08Mr7 +furMapI9L2JYdxw4IBNWUNIetAtfs2RMYhumBp9wOCB8h4z+BW00wEltyXwoQT9X +ylYx58bfsXnvDtGqy2lkFVTqMufaEqLF+1qf4jgcRmZFMvSZBxIhUKVNwpaHqmDz +yxpLwtxRcQb1+lOyXZdpt3WuZ//vPkyMIe5FY8Fzf9j0eFz5bLqgfZcdKUpS+3ZL +QKm0ZKY+BxOzcgCPm10Fz0jxUc+AisUwzcnyJmwrfMKW6bdmlMqToPadTflESwu2 +G3NErkzkBE4bUFg3ZOGrzmgqSVj8+nnoIEoGgxZg2ly4ft/JuMBkxN+s37heh80s +Hebm3/PJPcG69yfRDFRLaP0smbTCNlHIXUs/OVXgOPIU//rF2wYl1iJZVwd3CN19 +creuAdyZeEcp8o5FAJw5zmW20VChSAkjYQt4A1OETDXDX9As/0atNOwHOIUEVfwO +EVrqinK1tEIbNNwcvw49ovBf6xArE3kcHU/4uNi0apJSjccs8zvkm0O+Z2XCgPxd +aASUsLg2ia+FOcjtqL0hY5HHO1F4yp3fGmTJIHBu1EkHTLTsGi+JayUpjDdSnn2J +AhwEEAECAAYFAk3NMikACgkQhlYfRSGA/P5I6g/8ChgFJFxSEwtesvjF0zjDJWFG +SOAYCc19NK2o33Ra5511S6ZQFkzanxdAstrmNduOmoSgx9FSSUcqNH2WR5a8HTxg +2cfyW1+rNjBcpknXqdCmSan+gv2e/4pV4Z2ZuC6ZqybDFNrmvm+xyHDIdqyJXjbi +OlFaI5d8panSKZBm/vp6BGj9wV+C810euz6jdYbnQyJxHZhw3O20VcUKxgVsUc53 +cMRDLxLjDSuBwEbQdXfbvV6w3N6gBu1NDSu6JTsf8qFlujmPN4vLsNN6qFTKRuxK +V17Av1UwKlF7Pe9TbBxL6P20SghcP30TdO27qqof3Hb5EQvFKweA00yJ3MnAhERQ +HNMuRDmF97LN+Z8Kec7/MJOW7sb3CkywAHMYScbiOWwSs2k0WWTx9fbGfsHZQ8Dz +6+PKUQ/zg7zylT0aSnndI8Y8MWH0rBZYMANoTEPON2GSxyZMHX0vvetVbYxVGIL5 +LkuaZTTzRwt6aCdEh9OB95X4zZP8uuTYBm1mTDA3tByyPp2XLWWTKttAtRM6Yuo7 +1TiO9KWPRSeVsj1FA9c5A/Ot2xGPYkJIsESmMtAb3LfzC2xramKEVRhf53WZTw0v +YofeVwnh9rsQA+drrXolj1j2854OP5hKGJo1zf5Hs/fH4LxMH0UGVjJLa8vhFsla +8lTV5JM64z1tO6CBI7qJARwEEAECAAYFAk3RZSgACgkQprHz8Oa19aM4CwgAjwbJ +w1iSjnmFg6KbMXA8meVyLIFrOKiG/ZUz+KkNuy2bz5DHxnPsGl2uZF1yodm8zTel ++8VjpPdbdTmUvt2PBwCUAH+UDTj3VSSgfK4Ku93yZmavGAoE7DHf4AU6UGENraeD +IosJimkdhdTLnQN4zMovK2KPE5LsA0ctbyDKy7bAJrxPyKpnYVMeywDylq7vrMaI +9O3FOnB4r0KIXMA2u42rQ6yfAYuSftze4Lyi4TA0ShjE49a0SAQHpp2QILhGQA2J +SAMD1UpA/7WOfJ50qc0HZGafGthDlkSCmS7CFeBP8ADyFRlUDMsyMdCXHX2i6dLQ +QLLXw+KznY9d2hfKB4kCHAQQAQIABgUCTczq6QAKCRC437cbX+y9ksXMD/4l/zH9 +tlOlPfgHFo7k50PAUXxLwhL4XvcxQ/FM42tlrsVCi+ripih59lQFfagUks2xEWV2 +IL3f6XSB/xybOE/OiiXx/dFzsmaOtjYrGR8tPwnz/WjW96BBB9BnkjASNRYYDfSj +RR9OmyTDCp4SSLwf2AAbtD/Kprh6tBdldK2x3YGZcyPg55U++zjBdm5fhnfQb2c9 +uQ64CnBq5nD5U/T6A0XxvstGc27Mpy/0gFUUGHc3+R6Pp4YPeEbAwTloITrI/LR1 +088xyY0WjL1n5gAEMAOYD287NVu5pj9+yrlaMUPavQrq7s2Ljmm11HtwBCgn/G26 +A00O8xR5QUqeFxCCnjTQh65OUS8XC9c5RIqE9hUTA8StP+QWjqH2htzEsmKtkeU3 +y9lhxoSgZ0tvGjcJx0ggxcDCb68krre8Mt6olfse444LzyRJOcE/7ZBEd+vyZD47 +sWqxBtOZmm07vhukmJtthzjSIApiGYVlSjUzV1Lc3QjsDz6oh0hrtElwBoHXcYnC +oLtFn5YVIb+N9Y0iiSdhCvaSTI9Sn+1p6bzE/uyr8vlU9BbxdOT4987wSNRlh+/f +rXkGr4xUp2YbF1asVqbUeuN/cOx29ZhpJeGoYDhksZ2PuJkhWsD3JHub+okyGE9O +yz7GDaNYnp9DuPzu0Co4qxKleJHZNyynysnjhIkCHAQQAQIABgUCTczw3QAKCRDh +lwEmdrm3OUoQD/9PrwjSz2AIXf4/pipA52f/DF5ZdIJ9yJHk7Bxu95H9s8inAGf3 +J7PCl8zF1ZV5JumtrNvzMTQTk07zIlNzTgRS1OaiAOZjI5zCrWPaje8q4Ykgs1s6 +U7Yg/8aMaM1Z5GGbN3xvmMC7Kj5ERw7VMggKoVGAMdEPXA25+edONkDFDK1k6UgA +RycTcZiNw0ntGC3YCFleueX1HRTwJjzi7BU1w5IttLZq7m6ighiYAmPa5xJUdeFJ ++trxZBldiNDGLHAJUvjrupLSoUD6BVXJHu0BF0P83a9WB9EIRYX+QjSOgPhE8GmU +AJJ+JIjIWDAiqiwvXkPg3g0DTb5ULlLNnJEdhDXyCubrPgPzYAL8LACRvIT3e7m8 +hak6SbZ9rGD7CHa8Wt4mLalPkuMVpGUQ7TMRJ/gQ2WOCUDUM3SZQYXfmk/t2eIU+ +3gX4mePYIeaUJ+FX/Cj3YueFJGX8ZklvdPu3hZvnvP21BfucgXbpxPMUB6k+0Ias +DXoyV105nT6CVkx+7sbZBeGLq4hJfyR7sFNF6BdsAhOXA2UP8zNHqj12oWY8fJIn +rhR67R8XvpQCnhUz8JZWHbQ1+oLVUMblTjAjEGE5lptyC7tNkKG3CUdwk//0NonU +3GF6WNy7XaLj17YaSVq7qY6crLGao0OWLjeqJ+vmoD8mEDYKpsaBq+SNFokCHAQQ +AQIABgUCTdF1AAAKCRDGOJdNZHktZzuAEACMfwPuFDUeyjGxCjePoHcH+ET5it9d +aqL/pAq5nLD1Yb/pHoqEJnbxK5S2ami6wqA3Ue2gc0kU6EAPN6x/+jRicSGEckE0 +FyF7pdS1EX0MNGqJQSd8xkDl0pFe3sISpVUfkJC1TRRa0pG5ocm62Qg7B7qtRpK3 +asOwhGdaktd/dvl/3MUyfvkCis1JXNhrrvXIj/N/tzUeONp3VNsdhRqTB/MXRfQx +6kxhgvGkwENgL3Lt9DMrmcZWoA8GEgGNjxh3O/PzN5yMiL3fJE+uqeinPbfi0QFT +eKG9r3eCtecE+az1sZLLUSWfV7QQ4MvGIFQFTPWSrJvKZtFr8o5vN5RDH7DscNcO +VVL+9+kFrHVFeBepQ9dvsyNCmPICmekHzDrmi5SHbJiTK8ltC0tWHCLgZzYxQfYm +/BTgvt4KvEW0vy5u2jE5L/u2+0OxeG+8oGqvguSF0HNZWMGNBaSBHyLw6+6Rxh6x +Y1KybIvW3mAOTqLRQBjDQNzhIYBMd0n1CXpd1XuNbKJTdgNSZCdOtj66QCTwhCLU +5VUbI4iURCxtuWu1gq6nUk3d2z9nvVxnXNA1wAxrH2XVQpwhzsNANExtx3etqUmL +r9ljFAR2kRoRt/94/hfewJ1sPNzvQ0c2Uvq3xU71MO7ush8bgBlxu3oi7+N4Trxg +BauqKWvmdjOdTokCHAQQAQIABgUCTdHmnQAKCRDBJjPh7gGMk4FID/9GWl1/P+u9 +hdd86i8eq66It+FDEvgvd5eV6bu6mWfw43Av8vRTzpshSpYjikLSSdE/WfqEaklz +I3DPXikAu6kABzeWf6aN72rp1ZQUBLZQlHWYthkPe9MCj3ClcxezS1jwAvJkK22f +h37iSdnIQkCsK2pZRYAbQC5HiMsozyuDUinFEZP9f7/GZnFymHar4/OAVRajSz6N +DGtXKpVNkm36RcAaDMFCKDQZYbW5FSxs5hMOMkOvGuKJxwdZrmT9uM9KOzN+SXMJ +CcOCcPvTmwgQwROGPKwwGRUy+n413U5oyK06XOIPGPhOJ5Q8uCy8Sew5NKiiOKYQ +KEZ/ZP4fxHBxt+EU59HlwkXSBPyLrRXVYAqDRNtFhcxTkgj17G2zs34HgNVdlqDh +XoSnmZrBYynzJWU3OKfyaLoG3vt82q4zIzjpLr3cbryuXngqJTtU/qUWuYXJBZsW +6QdHDcfyDx61wUYHvhx0JJU5Iw0Sl4zwz74/vuDjusdQTGMcqU4BPOMO+OO8Gr8R +R5dzFSCCy/+CmWCg8g5htVvEU+Lz++FxX6Ao/9WZv+VjO/Ksu+NDSO1A5tAqPB8P +4JzGEd63DnuaJeFyBUdqbWglnpYxaDpL5L5VvzeG9hQ8M7ElOFn25TrA4Tvfhc9p +DX7ND3/cwBqJI1mHylhVUV9iN+OcIxxyPYkCHAQQAQIABgUCTdQQpwAKCRDjUtXF +HFBB1B6GEACwfD73uIWENaxEz3vdv45zwgPC14lT4ZQka7i86ronsW3NVpKCe1ZE +5mhFBOx4jMG1qPEt+2/IaPhY+izmve8JER1yP62eVxPyOtWKmfnm9IohTsLKoJGz +fcx4Mxw2Tklgw4rHWtnFOuROa0Qb7WqnBWldyIkXvVkm1EgRGya6HQDDib/Qd9Wt +lm7EooIfz1C8tuSCSZ2yD+us5abPVzr0zaBphtxsWaV0IXC+SK1G2ZV+BRk8PC04 +fTCpPFliPXWtRiMifqVsunjNWQoKFIQ4YxDnFm1CO05E8GWuLCNVK6GTQ/usTB2X +o9UDCXRnNhMfeg9+apzYLQsnEH76CDzUVyUk5J6VqlYZdrfJ24M2qoqiPAXXDo27 +At6ERx1Uh4Snqyx3tF0jMNNz71PpsaepIjOav8X1jqExLGjdeRzgqt0I7Vrmk6VB +K+cG45kePB8fJ9L9hhmsfybXqEcqrSee9Vmxyqzi+1nhIDa1Pwp1URMh3c1ow7X6 +3Sq3KdXVD7kGYF52eYUua1zj55j/rdzxU5I0/H5JLk/8xaRp0KZAbM37sdeG6Vll +AOQx8qsAKv8Y76RNhWdqWnq5APceIxXxda2S9kNqSHgdd/CLj+bwvuUwoLuE7QNs +YpaSZZd6zTF13J3XXj2mHQR+CHBa680LVTzaBEn3k4S8fYcxhm3aZIkCHAQQAQoA +BgUCTrK9GQAKCRCXMl3Y+f3VBuK6EACDzZdYqNeEItVcCvniylLBT9SRe19SBcUN +/9UZBZZafXho2mqc+B+wioldsBSVT1N5UU7LlmbYVWMJmCXjcVY5DiP/P9BDQxHh +rVuAX0iAmLfI1GeM+pzjiEQ/jpg+zULC+lfCPTG7FtIzo3yooO7qxxGG5VR0dmTC +tm46GdMRkrzmEg/33yzod25XWTTE7PNZbh4f4ov/RaVDcAsKUrs1j4yXIKM0R1zN +Jh5opkGGf02MIPnvEZC94NeISr3ylK3ptZbTSCfn7JafnPZqXiP2Y90QaeJ3p1Tp +SkZogrVrqXvmXdpO9pqTrnxWZF3ukMyptn+q00MqhOjQUu/WEjaxbsvuUL4WLOPi +x6YbNI+CVZrFX/2aayBfEBijeUFH3FkpzmQUhWGViN8R+iNDbE+OOWqXtGy/TFZF +CCAvPOathuuiZgsuka/sKBVzxSpeUi/X7/XxGNN+U0qBrLDk4/lNOQscxYZoW0+h +LL2VBZMLS3zIHGyu039s3YXQ5k1vS9RlLWRq6/dqW7RH9RxfFdgaOKUjGqlAfDpb ++uBALg/e3YuzvInkCnZ84BVBd3efar4d9zyJ4BTzGioHhkYqhwWSdyAl01dDDm2T +lt0attul1el9WtJFyKU/fWm5JymvCls4qGh1Mu4xAlqHTzgO8/8P4nebDNB4KlrB +r4J3aGlKx4hGBBARAgAGBQJRR34fAAoJEJnN6p2kE1s4jVAAoJi//u7iko9q74ZJ +SrzUK4BJnYA+AJ4oNXvBcNXl8I5Zx7ovgwyKRVk8uIkCHAQQAQIABgUCU0mPfgAK +CRAEw2fCGK3U/xd+D/4kxIAejnCYeWnltAUML+j9bvjrVV/WEiywVNrnWQj+2Bjo +l4ORBxniSnTrL7cayCWNL567uorosp9o/4B+BAYtQenqh/5gxt8euYHe0kakb/9R +5K60Er62aCoRwzECWk+Xxn6JwKPEFS2g/XNjS6+09F70ig1PGLHPtxkCsCWw2Kct +TRKTZg5oYt4WIX+jZLn3z7p5sCI1Uc5OjQK/7cDvW4KnF9AfM6Fodjlut077hyZb +gUbWUEjhyqkmBM3BXRWPXE62T91PFNNtqKgFIvQIBPn+i7Lp8hyADS7Jr5baPPW4 +/WaN0sLrzKs2+pLP6pILPrk0vVVFkZuMjrsC/sYPMqjmUJEFLWW0ybOYpPZEZts1 +FOm5+UE022Lp8GCuSq/8tYgp4T8zhH8/Aa2AINzB33Iks03uk7I6SkYOcjslGKKa +IMPCwjquDb4twP7JYeVN+Ax00Sv1Ff90yahXwh1WIAHy/t/OmK4aqvX7N1YCefWi +GdoMx+b/MYUumSLwUTCKXjlfrqeLeh5YOgv6Ep7tBi32Qq+CfHVJvQOGGGaLJb9Q +jDuYwqFhasaLdbgg6ECwWMmgbattjFb4QVffkBAqKRO1arvGl+5Nrz3PG9VmgKEr +Y05zeiTLXnsL3asnliSWEQ6wl9UcUACvxEUNCs8Yl33cwXrw5Ahoy2nOwRArKIkC +HAQQAQIABgUCU02Z0wAKCRAup2ucK0ZtncF0EACgY6QtcxuBFEgsRQcST8JJBbW8 +qzaXqWbQdFVi80w62QhZYUV+vIjoijdV8xJB5GR9Erq/dwuvnNM2qLmm3kgXnaw4 +fj3l4srwuJgzVRHgMenhoNw3hYAiiP9jrNPylgsKwJTOQ09PDiFUkIV7UdPdG7jb +MdlQOUU0XgQQ3P514ktEnCRYBt8jWsDXPM9MZ/aeqh+AjN5dTtyaD3ufJEfIPido +QhCTZCuO7Olv/kyhu3dSVody+M4I3cOXUymULZfjrTttI/wrkODio1MHGmm9e9FQ +JJBg4ENhsPJ1sLc5tleWA+hhXniOyi+r7ErmpEetzAOHj/H22VHL41sTJlJVfEys +8z6BKxLNx6WZDp12QstOhSXjZRcWw+2dyAdVQqEDmKGIMQHxwbZQXE3gWKDnunpA +ZV0vjANEhnnAe3Sj/UdyMd80Dpj4OuK1cUH0mw5R3CwROLlp+/AlxLejbm8cl9Jq +tGlI7SO81lLuGFQK7wHeMJI8TZ/foumfs4ZTA6v4mEsG5ESj9utIMXuYBZ0VJgKp +XuqGipDOeQ/MagWFReOrkQSiNFY5J37YUzdkxtc4rHK7htE9e16gOCNdqSJQt3pM +zz1jx1yp900ulIHEicZrLIgbkHwEPInAcYUavAmKfL8i0rshC2S+FzzqtnpvEeIn +3+L/xRZn9ymoA6p4aohMBBMRAgAMBQJTVb6uBYMHhh+AAAoJELzLHicxcmLSkZQA +oIQxX1zjxh9CwICDBqQm/ZPMmgySAKDByGs+h1gu/3DQ2TQN4s8hvpUl64kCHAQQ +AQgABgUCU1nNkgAKCRC+XPaH3Fq3wkWYEACsk48PIgct6jnfQ1oFS+e5AYeRcnhe +58Hl6TVVuG7YQ5nZURdYCaCaJ+9JznIvCLviI+HxHAflnWvqySKkcvNSTN4iOaYT +U+/jcdSojAumQm1U5iLkntfBnnulcx1uv2UcLzRceHycA35VlsCIL7kW9fRQXodz +Mx2pbWbxcUy5BdLst1MJFcBXn6fIvcNXYrcFf8AH+avC06qVMeYxGqJuIHxmPo1P +j+yn2HXiVrVhlsYssy4lPFdoV1W7dWu+dzOYZvop8uXa9QTDabqLBTMl8mLNBLkB +IolT7HjaXtVNgx6FYD/vj+J5APrDz9UujFirUuq+ISCYDteZhfgYum4lHgpiAfjc +aaMGW3NOlld4LZ0rV/MurIqUZvstYdNTCZOnAL77Ygtr3xZFKw5DQXrW7gpdyOW7 +CzdO+u0IZyDyhvFMMnpLltU99+jYq9HHqQnMlDRmIDdWNEupybdSaVJKaoStPWA0 +GHX7q3qw6dlrPanG2/tZWYtqbIc47gQZqal2Mgwf/mcczgbku4eVvyfsa4RJ/yw3 +ITQJPNMmxZ4OY9zbD2hC8CgYAz9QWDVdWGM8eaNIaAJbDRSV+lAT6TygnxmFGRsc +x6x6XDQmtlmxbak1ELm6PXDdmSKtc5fODmlvV81WJxwf7NWpfvw8HUlFRFWpd5mN +11oMyVOsTNmkhYkCHAQQAQIABgUCU/vASgAKCRBklZ/pg43xnIfvD/95RK5futSi +8ueJiZvaKQwTfEvRQOo9q06YQuP25OVzkYnywEbANkI/xDDIxX+2HO+bxTi+MUWv +c2/kQtpscgf8HWMkaZu27nvd7g/CDFWw95x8P0SCS3NIdmdi6Z5SLDN3NLvOD/kp +t4Wh75ROFBXiEj38mZjb9V/TBMJNLH6wDgDZOGlOELwkXWi6leVYhMmWWkCJ24Ff +aGoaFRFGoS1mMjjP8kkvEQQ6g8GlyPNwFasj/H8K09N3/gTLYDSd6UdfY0zc28Y7 +XYm+zFj2XnqVaxGV0v4p6LYXAz81LnBzlm5WhRaenZmFBoFEmpIQj/VzrjBmvDjH +v6Dt5dYIh8eqUhgFt+U9riC0NXRDrysAEvTEVNDGEbKY4KekOjYMk2HNyUussHFF +6xsY7NBq7s01B9pb7TPPt6f0ZKADUm3TXmQer3govY7ueMq/u2JQi6hYVpUNp+uY +3/9OKtHDEe7opQsDUiBlF2YdlnN5jOXZAwm8l/QZMzgd4q+RHtpwBq3oJI1FZ8gy +wbenfgk69OUwEGBspgWGMZA5F1yomI42D/XfCl27TKEqi4i/meGoenr8zlrFpITR +La/gD2+E5tslDWq+1trEHGy4HI0MtCYFjFTvD3A+KstZI3THVS+5M1obBKqsGpM4 +LZK2FXgBf1JwcCLabkUKY21yA7mDr0pUjYkCHAQQAQgABgUCU/z4XQAKCRD6ZDum +HSJ6+1YuD/460LVIFO+vXAuGolOlsITjgpDkDMT2oLOwwm+Y3KzV10cBtu9rbcTX +MRWx9QD1vTxmvnMhZpaa+TnRxWkaHTqSl+QIUxpuYvvGl9AFvxMyZGvA6zZR7gpK +6r7g34x2LcIqI04M3qf/Xt5DRSuBlY1QR97xoPgA4nn5WK0F5LfHVoWGmjl3cdI4 +1RpKZjXw/Vxg2QHfxnq/jw79R0xrks7okHqIf27SijEdJgFu3DcNO64kIPRoIA4d +m38q0bdu+qM2mZN+j5ASEUXCZ+YX3vlRwe0krBr/4NNV/cNB0djwE72uNKJ45yg1 +rbdb0sJCzsv7KFbSZ+5fYMItPOlOB3+qNpKO5mPhAo+tlGAc72hQY8XyLtI7Ni8H +veq5MH7IxlJ9g9Nm8AOXUGDMF4GWKCBiKdGE0lU3eyWNErFLwGc0N+c1kqDYBx25 +IZCVmPwlC8Od5nr6NUZP3qluvHegsvzoGcbh/D7rkVek3tnqpROsRurIwmw3cmEk +734oi6V7NLTuK9lPe6UjQguiNdiegGUTRky6ey6ntk5itCBYCjPZDzvTRuUI6MNO +rlU1/iZvOhLWFHiFQO9ogTGBHhOh6SPQHGqRxAv84gKNlQbiyH6SURxH+HLiuMwi +pq+YpgNvYjoW0dryOx8pQ+n+PD0OqGkuX9uulCu00VX+iXtQeZrBTIkCHAQSAQgA +BgUCVACxjAAKCRBPrXp1OEVZ22vJEAC4H2YZ3vMId4FDh82YnYsq64s9FPC+wePM +o39y2tkotXZFEk63U8qQjSgP5KCYPX1cfJQsJ7rG/p28uLkwUalBuEAjFx/KJaMT +eMXuE4O/ddKoIqF1G6c8zUmmyqWxBTPU2G1Lu6Dql767u9Zd+Lj4y3Z4l9+wG8K4 +y1rCJjGoafwho9OVEW3TspS1NjDsC7s/QtyOngT2lRMHV55mtENavLizC/LnnmvM +6f/p+vDxA4o55khziY0I03Am+pWe7u9Owd3kA6PaC5CjJT66LoICyxf59MmWQZ9W +Jju8UZA4AEhx/jGv67+l1Vf4uSJoG4FsnRUqmDGOBMMI/JnUocSrFQz0m1J2m00I +GFcEHFf7UnHoMRGBJcM+C0JFf1ojYwyrCckhFZKU4c1Iu+Qns+U2NELhlzBA+eXW +lVsmq3HtyCfr/P3YEeyf7bUI9zJSjV/5LItnIqeEB3uQyNijfJ4+R/uBBqVGuhqP +2X7esl98U70ekXq6OJuJhrbQgUxkHtZo/sHBuNcMIG+uhxr2GAJbFP9HZsNhnsgF +XyQkZL4/sSiIZS7ajY+EIVzxb/EVdiuFxwm1RzDy6Mfl+1DVfH/+rXZeh6Uv3o37 +yfHO2/zn/mZXvN7FuJ2gWbZdnNpmsvhFaq1Fk9/dofukM1p8kdtzpQi7ayjNLedq +HULeJOq4oYkCHAQQAQgABgUCVAEH8wAKCRBPoEpMkld+xNEND/0TOeU9BTfePasS +SeUJo2pBbQyICGhx8Jn70pND6Z1KZK1rSbnh+r4RFZKvi/EZ2HAygn2KdK2z6qIa +QX3dkq53LNe6FvV1pF5DDwc9BNh4RYqX6TevvHEc1BwY0IIp9qFqlIENj9166VuJ +ZBykRvVF48ktLtl+qTSmoO3Xf8dsksKeFeCYBWRZ81CpyEazY2TnjYmD3xcq9VYS +k5dodUYsYXKv83gjaldXOHu/mt/F7EoYQUt7g5prFLHdhSL9xlu7OW+kxcgonAwU +lmbidqQZaeMO19yptJ4ZEa7nJR0q9kz+ieV7ScV4VQBU617orCc6jS0TG/7s5/c9 +IhqgJ/mp49uHGZ/KMKml/Bokr57OEq69t0t3ZFzaH4KEahyjmBPKxv/1h/2ocmsZ +X6aK1LTmNshIL807/rBx1Qk0RW2d9YrN8d+TsAZ8R3u6XaABz4OpPYYTKgo9qMbi +o5yj8fPMDRJTY55531BaEVcXa08zY9ltFOjOSPnciJnegZKMnZF/pdaM87GPgexI +MBBXzAKZBoql4C5PcgqybF5SLUc5uVgc0pJDy9U3YBJ/ehJ87PS6jb0qUqGuodik +XuFwuavppIOFivts5z6KYJdPT+wfehc2qGARaJvsKF9cTqFHjnNjZyayfYmf9J7K +iI2RkXsvdzmpF5So3ATXnMQt8n6w9IkCHAQQAQgABgUCVAOywgAKCRBnOgPkwduS +H23PD/0QJlmXhHbuQUW33oLTb90bxiv5AY5CwIdysLv9xmBnzbNbG+FjEjhHmVFn +OEArrdtLKd8k+rsuUwReICsjFeIGIMv2ProcgA7wLEhMM905R1jp1NdHTWhbqFHn +rw6V4iofwI/fp+dPqVnihM2qz4ZQBkjolVEV/G9/jYXHyxSJWVHITH7zEbnTpIe/ +PRC7B2MBam+e5IYWmLeWqrZEvS7kD9pklVt/y4ac/lt1+PV9wGiH4nMfkGW2H3wi +iDRQxsc3Wj/3hfumoBKJ/Rfs34ro1dNTf6tUcJ7mGw3UOLE++fIdhCHzfeOqbJ07 +PJg0yaXk8kuHVCqpp3F/jYyCEcilRTNygHqRLnUwuOOa0JIatwIwJqKVOVenGeJb +7kvJe3dDN7F+9KcuTEIPf8nUW1wGcNtla8X31CE9ZCkiTbrcXnx4HzLrOqUQtP3j +R+62CYAWnMutncwpFZgzaY4OduTga7MeAJpTJU1cxP3orKJ9A8cIaXigObiCFQbd +WFFEL2B/PRJuhHu2AXkDl8SVzWgUAz7cHeNrvktCWfe4ruGg5MafzD6p1czO3ASI +XiyTdhBwN6F8bDX+stgemfgE7wSrg6L7Ekw7JDjD0GOuZdU4lwLz/TtsrcR7m1jc +s852xTD0ls40Emi4SOk6UjbmlUruHDOKaxOZNfjC2xeKVbphbokCHAQQAQgABgUC +VAUcJgAKCRDA+IZM2j0DWFyWD/4nDHWQmqMMq0eWadDsvDN5Sx//d1y9sFwI/4d8 +x3q+cFO5xlrQAL5FNsJNGMu3qWxIzuzZC6auCdrNAhxPfmV6YZ/4A9kMDU8dIn25 ++yTIAvBLPrED+bQoFrErnpwhIBT3Fm3UCl+4bZfmzhayI3i9mlDgmuAVAPJWjYsR +4ZlEUJmvStgKy64jqLxzDQfy6zsVFnK/ND3WWPs4NMeVrK6JulZ+TlbUslTKeeGe +SOAhxDqIXqa9U3X5yOhMozOkE93iZRiFzSwf+CREEjF411JZ6j1KAdiGNsF4lSm9 +bI+qXDWnJs0iYk7EQxktVONp7GdnjXRF95iGy38F4WEVa3Cct9COrevLD+I/03uj +JfR1qbEicRxRFZWZezKqbKeG6Zv/d32mtrEVdjBO2X+iyax7FWShgFJIl0lu/M2q +9tgMRuYt/i7j/eUmAT9SwWBXcUXFHGPp0UTrckKpz9ULxSrwZBe1WCCOZDW/pCc/ +c/rE1AYOVcF/lW3pZNJ4VvrdXyxE3sp08tQA6V4gmlhB9vG3YXvygLnq1c4rs8k0 +2VopqZtz2616npcfnGsBmv066If6iV/m+Ea2VrHzg+cR9cqSQoSAOGajWJgz7zOP +xGuAWK9kKfRqZqY7VMBOnojnOh7LPQwMO8QpAxaEeO8CzKCpJzuqEyDX9BOKwFYi +fJs6lIkCHAQQAQgABgUCT60kYQAKCRA5NYfZfYZQCzodD/4vVxCeA3s6l4urzRnf +uk3kXdScPGeoFrqJTsqsIckw9rGB6HUJC31vjk0lG43QcSOnfXvAkYnnLjR3CJM5 +NS+2YefPYvvv7UyVXm+37N1XONluGbcBAQE+6dW6dgsxjQGmPG0tjedJg26PC16w +C3UKQ0+pr6bbZWxf7Rom0NWJjKOIykNIbysrO7nlyphCBmYTnyKFZIKbQ9aQAVhl +Aj+kUAKRoQPE4xBRlHJTc1RP86Tqyb4Z1sQdWae9A5JaSYFY/d1SqSEkw8p1vc82 +4Ev+M1yQmWVi/hOr3AGpeZZlLv3AiO7lx9s9KMaFWwkffAt1k9ur9VeHX4k1Xzye +UwWwmNjGYVKz5dw/aDdrk7V8q5M+2tSDGrq4GCXxj99XTKwZSEseE4FfEUdqXM5D ++qyPSL0flA7bH8gAHPj7lTaKpSUeThrXDOQvtrfxF4uo8Rgkk4ioP/fKsr4kLbAY +G1hXj2ZhHWmMoaVmSp6xY2kHW5WvZq0NKRK9EsrDX8CDK9J3iL0jeVXO+YAdWbWI +j6Xno4IiuKPmRNQbZDHn2LkZUoobReOfo4WIMXc/ID4qXehN0Z82Z1COnZ+oQWWD +r5u2d6BwRcVsSjdyqqdAA5PfgWBOsMSUHrR5TqoJsDHYEqZuzZVG0s+ntEJyNE0w +Z0EkAaz+MhHDGgdDvesc9CeWi4hGBBARCAAGBQJPrSS1AAoJEPbdMwIQ+kzRCjQA +n0fm8T0l6rl+ALdLERyh9x+NHlYcAJ4vc2uLIWYs3cB3H+p65oZCWWDpLYkCHAQQ +AQoABgUCVA0bBwAKCRB1GrXdp5Z5zNjCD/44D/uySetvxIUVOWPVEMWXseRvJ1+X +6LdgpHfBAoNJxCQfD5mfrLp6dVXObdmbutFrk+uvz4gDKYJ1WfUz2xcqqb1X6/lx +ycaQsCRKIP39PwCvf5yExGW3rbqOZQBqdShGJXiShzXS0r+C/3uXP1MrkRjW4xUs +KjI+5rt3sv5gaGS+Ow6x1JMiq6tZiB7DLXylGccP8TTBwrhsG/7p9asKYv76fnjv +qRFSUAfC7yEr9mqPGVFKefPy7HfCZ0CNomSow4PIJHNDVAdklWmkq2O3zrz1ng15 +rDiHvh1FE2SbzrjcKPPGd93WuWctFYF+RFxHlVaC3iM9bsKvsJplHIJm8AjivbXO +OFHhrSAZWifn5Zu1FXzlH7KJGAjCHhrYG7UZqAlMtQhR8pH1q1AJTc2NX2CFrauJ +7EUdBc7/dUAE1sOoEbQmgXLDKI86+gY2bvERvU2t8kzfF5AfbY9VjRUGqyW5qBYH +nfVZ5c3Moso+JN0JyhfIu9qsirbTBwmAX0IWZXJSAjK+q9H8k/7WT3swojr+KE34 +o65544jviLCpECUsPKlkFseJ4lQFTqql88cJGTEj4xF1IxL+65ib0zSrCcBQRi2+ +bdLmgw/a3nqCcBWkovuxhac8wYADPGOnu7kJlJH49dDHezMZqKh9/OOLD1MWzAe/ +GDKZdnhz3QKANIkCHAQQAQoABgUCVAc3uwAKCRADapwlvzV91NulEACTBFP5x2qB +5sgOWS1ukz3R0rJD0Q034bM/HrSiOyW0StR6qINDIg2rCphYhmoG1qskNdf4oH/H +SJNUOdXkgw3yWX2v3EzRE7fOOAJmGVrqRLwjo+XXUHdOhw81PQmURAIJN364qWQG +6+XojVG64xLd+TfkkjmaBHihbolib2LFf0MMykRTkLmI/xJjuBW0OO//mwKLPPiQ +gyn+o0iKpdpl2wllLXY0Nr1GWNYz/R/Cp8nOUKkPNwIF1jHG+6tdqZTn1QncRjIm +nIGXnrvnPCQ2UvffZSe+uQHF9f8hawnHfCGc2gFyc3f2nbcf1p4vB7F1Jl8EG+ET +Quw6HuDVq/1WedloZHQmrVCTHxVOr/HbQamrYX+5ZluLmhYTee/BXh/Fs6uaf9Ma +xECJV+Kq86I2+BWjxsRQWbkhm1g+zTbokk5gDdEEj7PDfbmiV4XYpGR88pknseOJ +HgKXNPkjyka21KrcOUhJHT2l72612nUL4GXIp6rjIg7hImRYs/30daX+yifbR+nL +W0frrbmXfNFgXKj2prmaXIHjdNmqoV2UUsQSj9ZNmYpGhFifmW3hwf/+0ygEJl0Z +1bqHwx7KsTzgR4ewbluv1qI92+M9X4GtH6g6tu3ytjOB5sGb+FtcZ1yLG91FNwa9 +TS5aEMrAOtZDl+nPfLeaN6frbA/942V6fIkCHAQQAQgABgUCVAe+5AAKCRA7VuK7 +1T/csesWD/0aUVv8obOop5P2aVvq7Z+wKwuD4HbJkBPtTWVrgk22ids7MKF7b/Xr +juQzI5VDSw9rPmDYzd5LayH7LX3m53KgjTQvdPQot6yhl7LHb3KL+4HNzFPkqr3p +5oYun0pHGNf5h5MErf5jhzDhNwh6ECnQ+IIpPZ1x3WOTKyDMbjfJLJgfZy0nFSlX +Hvgpcj3mirq+i8vdxeAXqrC1OUj7ewxS5564zPE/K8IPyCpLZ/IN7ly9MURMoxb/ +gMayLg+Q0KjPzEYpPTXpGt6wU5M0KKCftmo/7EaUbmsrf0kNWLOiJiTGDLZiWTBG +gKw5b8tC+eL/wSvgCvDDrIcwmrwCnDYVp9ghugdP8xYDG7DiE/9gyOqvDJI61FQ7 +EVDEa8GGJRrXd6t/74+fFY0m2NBpEkS8TeC5ujq8wokZvMEU8KsZqxMIMVWc1uO/ +KJM868oRk5uEghJRI/yssJk4nuabi46GNt71uXQ1VVDl8s4VdALZMv6xfsMmlKXR +3DRVcU3OyYup6pCrbvwjHsNoMEU4LxR00B/P6oGCMY2NvaMsfX0Utwgl/pb17gCP +V7HSNJcqcTCsNxlJXNp6LGv8XQ7TMaHOfptoXGfAeZ0WcbfPwjNG4AtgFTZ+Swwp +xCXBnYbWf1EpvPJTkDuEoV+Fv6dCvxPY97EDF70zxp/ydqw1Usik7okCHAQQAQoA +BgUCVA9V7AAKCRBuYItjfYln6XqQD/41wqRigisLWMcoiZqaN+UrcLEs0k3OEZ36 +o07eszEKSubq2WvlTjy/tzaNmEQLgQoa2S7Llu9/WvBtlj4Vf8wAltQtnv1CaDFV +nCFLo5bMILBF6B0/jUmn8NfMPAiwrsgYDm58oBPwW/asF14FaoYIrEW40WBXBj3z +FYI940zI4nSxPGgeWKC+Elv0mBoM/9PV2fyMgGdukSOMcIQh33I+pd45WNjseloT +AuRXN8W6DWDb51A5bve8Mh/thScx3zNZso7mP/uEuX6SFvb3KkCv1Ea6gIQuK94j +lYslBTwZxrOtvJ+S20Ia3Y3MFsz7uC+Mc0j23L116plgLtaeqmKhL/TIMUVFDWBj +ATb6hBdwlDGLY2eLVo8nC8IzhHwXWeWZRU9Ro9k2McmGc9tVbu2kQUWlzA7csRhT +5ATlAP9WLYWQaaPqs4A50uv8XRufF5BNw7/tGFrSY0jfhNyZs05VpMjTB1xPVpDx +E7PzjyrrgEp36+AEDnegwuIomeiugHw/bx8FUi619RGvsjd6vzmEi+rzMtWIkNWR +gMq6tTc6LlM2Mu4N5A+ENgdbqcn/DXIMYc0SspaKzrBEM94O5W2oZTI00ZIl1kEV ++k/fec2qnWXNQtlZyYTlcKZttYjAJbGF0aYoc/SjRMCWo0mLnK5JNjZkfHTOMyAM ++6vKuXo/x4kCHAQQAQoABgUCVA9ltgAKCRD7PSWDO2qv+I44D/9jtnXoTXIQR8k5 +wDHYp+2+MprjdG9fWVxYTsSV15ambxI//nGFjU1BTjefWFQcRWKIMn8NqPq4e6Lt +M59DDhviem5SsiYyrNhoOsvW1COpObYapJVlJg21dbLYyn2pmYUFv20GSmeCOy7D +r6bcnTI4Y6ZPVkTRZ7WnBJuTC+WQtpcZVi+mUNyVAHl9YtLSOIjFFapMmzuYtkSk +757jI88JgRU3j2HM520Iat+zoB47dMe5NkS8DkUpc7JclwIcrsa9NMW3U986d2IY +bqmrbsMeiqG9peeGyWCoYlgVQQgQ7bamXJaJRlMfPLi4RqBzHDI6a4kDQbrxD4Rw +OBHt1t4ykwiMTVmrGFMDyXaOnONF9NeuevSMFMNUFRGSIS8QSiTVxO4h5kniWVR6 +PZTsrp97WvvOYVgkF4Hz7A4/hkRP3NPMGneiDmRQ673dgEuBVSvYUTFpn7u9YO2q +O555bRIw7UcxfsNPHyVNwHm+3uQ2LBZWCp8BxViZcp6H87mHrs+B3sJMyivDZ7Rz +t2dqRpEqn8Vr1epBCENB9AHAvIz/OHQwMWTCkZb65H9Si6UIvbVjtZFZGyD7Ps8e +YHTmgOK0a8OPskI8hDfNaFLUKV4InLlgoKl+haIvnl1HqeIMjV2abY+1QJQ4NnZe +VVAVMWflDdSVh9HqnWBLuGk+2BzoTIkCHAQQAQgABgUCVBwvrwAKCRDZKfKZK+8K +M7hzD/9WDLJ51hcczGYqP8vMdmBFti5AxWUkGsEh5+gd/S5px3sy8+O6AQIDDvNP +UUqYuXAB76YOUkYplER49uL4LFlMH/St/3nc2/Ed3NfeS8VwuPQo1x5/ksTa165U +AMP2ORylsTHpReJnNPszOxOndZabRjf7X3zQsrQUQf3NrAU6Asyn6qsQnLh3VIXJ +sMBU4AWC0fBr/oQbQN24B/bZaHl1aHR+/7nQzS6YLtYUnbfIFd30w4Jd58qO8YYR +5pD7qs+7Cry5nvxHZh+vSsdX5pfW7sbS6ruD5H9o8mheFsQw8MidWW5a4fwc5ZJu +jZN8MtAGN1wVbh1EYngqKvcJpHfyGXvrJ7Hso8cUoxJ8vQqw6URkxGUJjarrvMuP +xYL4U/RrV5Mc5rg6p0Oa4WKPeZEH1g3GI94j2xBDAbhizb3up59Z7XS6LBwtghDT +S5mGGKWXwMrXZyGlz++oZPzVCjyED2QsTmQkqTeuYeJirty+60vHnPxnvzhyolVZ +jyCw4JE8q3vE8aOw60Oyo/WgdOyU9mCKH+CSVr3dPZZJG5meLcI1QLrHNSV7uYn9 +LXzWJDU7pjN7LvUF9yJrrBlv+kTr7woJf3EZEzY6K5AXhGYmgiaXf4fHdXWVkmlt +cCzVG7zU0M5t/0BDXkX6EVMu4B+MErMlFVzXy0xxqR6xQ/V0iIkCHAQQAQgABgUC +VJCc0gAKCRC45Qh3Zkdar8WoD/wPCMMFSzdm5fyy0YLFi2DcAroBYvaHpjsRSozU +SS2FH8MA/KOlemg96fuvA+m1JX2rtC2QEAmZczYM1FchONppDu3uZ5/Cp5MLS+fI +6bk7znSAO2b4fVRgq6feVrvlLGfOVSUgkT2/hKdbT24GzDjbbDqfF7GKiO0Df+Ja +IE3ZD7w95CXVQ4hlRu8V6gc5Ggd3OXzeLqt93ph39lCTbWo4UJFiGZGUzehSvxt1 +/7jXYmHqfMp4pq8W4cEOAqg2rQ9eE7jlNPQOj8wDU5aEzKQpwuY0JkNxY2CbXGFj +GOndthaGAjkrnYRX4X3vP2kHPu/dpPNzL6f1U4SdhDEYR73+D4Em3RA6ZBC8i/j8 +WxzUGfGdppxYy5+QkuznpzfHbZJtUlnos6vLEdvS9u3MDoVsFMsTlPapSF+BzyP1 +FcLjST71y8KgCQSVjpR4iaoWiXobri2PtdTw/MAyar8u9kiBaJcEc89lrqE2xWEP +zjEfy3p+gaKn01gh7ZUKcKS9AExGxWL/hBFgRoUtrR3c5sdBK1hMcIVRv7y3COrC +bANuyOtlS7fZW/NNmoMdjA1lMfXUI/CGMUZz6Rj73n8E9WNb5fqSRGdurYFxGrt+ +kADB9OX3cOte0kSZU2qtUK9AEo6ob7KObyU6DYnhrl6L5+V3qjCqq1HjYdsSNhqC +1uTWP4kCHAQTAQgABgUCVDGO/QAKCRCIe2BhizwWroQXD/9+H/Oly9yqbN3d7WJO +ko2NkcXG5poYPetgaQo9qBOBORQo4xP/QVAp+Ye7xTwOT4VQcLFiVMfozso51KMm +CTF3OAnGTMU13WPpQh1OJIt7OLklqBZN4SIj2fLZ253cxxWLyXWVatuTEUJAKd/o +G07O210xkV62CtUi6+woXWz3rDlFan2AskX6KUmbnZMlzdYVEI9wlZBZhRYQplWd +KBdhQDWztcncrTf08Mi31FoT+shU2K7wCklfMCel2TWbZXo5ULtsQYBZK+9qpQke +57nkU824f0ifeP47UVC6EIoQHou5vMjyqQ9cx4jQb/Gl/gMzgV/zPda2l7fAV2FP +RKUNL9Ud3CJ6t7KB9ca38CicEYaTtdWtUiYo1sV/x7GzRt++4iBddRui4QdIgG48 +KG61kUS3dBy91nUVRljIa0r8LlNN3aRRnCfXxIjOEk9gJu++6zxt85UB5xD8be3G +3zYBpCtOPvwfUi4UM4QDrGzgsGRol6rdXprWVssKUgqqGSKFHqeSUls1xNLom/kI +9VDqBI6CMGX+Opwhc8b+XYrQDkixZ2HokXl73V8pHruDfiaqmsuPxRLNxetR+bXB +2ye1p0bDcX7bVDbZNjC91eXk8LryZP0F9Z/Khgf1lB8ejuujeL3bDnyTNbfl0XlF +S75PKVnI4Rd/0S+fURhZRM2jRYkCHAQQAQoABgUCV1uYvQAKCRAtNH6mqmVCHQF2 +D/9/6346iGXDYo8JeqKYRJLaE23TfpOvUd/oUt8srRLWmbRYWLioiYYrLLDR0EX7 +fQliPDEDPJlcvcPuER1AasZq9K4fF4erB6aNq1FaGmytFH2yRv/X1KgFN93vXbhE +52wZm7uNM5TV8IPmikFhdzL9+0f1Yz79+CzFGS59nwABQH0eQ4igSFObTj6Z7OH3 +V28C6L8SLRinkPJcI9A0dAsELSCWObem6H46GfUkfnpO/3Is1sE0QNqUhVw6rx7P +q3LT6bMbpD+Y8Viav8hZ/cIF66CTyH3u58+yYcg2raU9ahMgg3W8kiICLzh7UbaO +1t0O8B3OpuNcbJ2iJfdWj6vsPcu02M9CaHevx27CZjeBY758IWia90GzhMgl8tcj +xotsjonJKPivptM9UI2+T4quDsz6h67CNrpbqxAh64U5SlApqY9FL72jWhRzJRcT +AF8iaxnx0zg8/MUTjyYrWTtSmDNTQx09lI5FGe/4sqoKQUXZ64yobsq4sykSf0XB +aujHpTwvD5YpX9HFNK1pGEoiH76TWZ7J+wYEy15qzNDQAgix+y0UBqWsbeMT4Qwj +LExXk3WSOtoWrbPCH2q3IJXRhBznVV7eGTWkU5opoSmZYCaW3mwXrQgMyW+oKSsN +AFAgvM3rDp7HfQN3Vs24jpG8EhfbL0F27EeqOK/6v9qH2IkCHAQQAQIABgUCVt8E +2QAKCRA1LGcgseO5K8RtD/908R4MkeWGPwvDHLD3T9RyH3PPJCnpmtS6XaGsB4pp +XXuYnH9ACVz+5dOdYPM2sYz6Bd9uJPF6OUnaGy5BIP8RlgFGEgT06eTr0GcIawdM +p/QcBut5Te9QncR49/Fl0V6/6Lk0OJ0TFuFLPWOpQXbmqe0HEmmcegL6fzQjFOjK +l0Ii9OSKdjoBqs84FzKRYZn7v6AeXxCnfkD7PwOcW6AcN2SIuNIGq5/ByYvoCXsb +nsA+c3dqY4jEmxTvN32KiQOFua1mABXUHSe0unV/qsS7ch+EsZx2XSLa0y/UGmgL +SYXJAaQTgfBXg3b7sGvKDPFuSTSaZxopAY0Sv9cTYdum8w9QKBC+HER2koT9nd4/ +lmZWGOH0t9rpdAvDrb9xw1rmG+v4NDOZQuun8FCoemF/6hXMj3oC/LUgPido5RbP +lxnXQDyBOnwtXvqWP3X8QYRtsQdZdqFlRsZSmt2cv5OSg1HpwfkLQMTY+q43fWZ0 +YL7AElbvIdCh59o9vLJhfilAtCKZEBgVUJL1G9wI8kPTVSd0kOGrOLeEOr8zDP2e +0R4xZ/3SHi7xv156UnquCxIP4ASm0wKf2w2xOpjmJrmuw22WLNZQIuckmGYg74ny +3eiMWAvIOPdIwtrOFRrMlsAkLeiTurpbaOcC7Nd3oXVEBHAYSDHWGEO7PEXZm1kl +TYkCHAQQAQgABgUCV1MZugAKCRAJSwnQndU0bS7WD/98GsShE2t+FkrhMKgzLkQr +e8Z9S3uNs4fCt3qr/tu11XKcQ3hTtMf61FW29qr6Xw1VnDPfeT23n1fPHljXbAOG +ZYCl6M5doCQr3ge+lKeSeMnnN7hHEI9PMFPZnG7RrVkY6kigeH4+pUBAxajEycdl +M4LhPP8DV/ZjidvZpAEX7QUhgQRjpD0ycRQ+TZYixuwXs6jBawS227462hACER3H +11k/MueStqWnfjv6a5bPp5JQSphyP8GkRQs0Rl0m6MrdaFPPGXlXdO5J7eHYloSb +PCe9MTKPBGeRaPK4KqlS/5mQeQxnmWenv87OH6IXSZjcFCmfQf3ak234Yew/M7/n +0z02w2gI8g9Ip86nt3txQ1i/HldezGrlf5nrBuP/LFfm/zkICFOvkt0O3R0y8Bp6 +YewHSPzI3AYSxSFT/2m1WOC1TCYCBNJ8X+s8x2mBkKg7O8DxMSigAbJb1Tte1u+Z +rjotbdgQMtIA44xMmmK1bWhYS5ri1QYOm5D7JpOEeBdcfM30AU/mZkoIdl77dwx/ +2064LjrwR96quTc1/03wsjSyveRkvqkxLralhZPffR2Ry7I7Iy3Zbdise4TSgsgW +MXaKrkmRtUILYHD2KYaPmljAwrP6BZ9UQ1hIcHmYW0j8T2Si4+2tOQ+CV7LAncRU +tje7hhMJWUP6EZRVFqNlf4kCHAQQAQgABgUCV1MazAAKCRDAD74tkhkniO9xEACU +oz604DjmS+vj4d0nZ9VGKTbtTsZrmGCFmfe6qaRnRxqwVIcMAYyHABDpWsLLYmnP +Xnak8Ll3e6rnCqcHqbfSDYe5yBPie1xUuCXtTfGmQp4BraVbbEtv8rcBObVdWPM0 +IwF5U6RQxScMXxi2QZF8zN9sMYgKV8iMcvbCwGV2S3xv7fF5rFEagZP7ZJtoGnBy +6o0Bui+pGMOaPPCrey5xSEDimeU3M3LhY/OlV/uXk1Zp1uXtK5NPR/bNbwbMNUiP +hPP9W0fa53EI0L12v5nWbPKZQNQYvA8kXDWj7eGW/KPADcxqlsoHs5gbEKJEU//O +pA8H5fdR/LYUsVLnoUmHgTGHVpiL5UF7QO9znuJZe8uoYQtjFV3tULD0kYf/hNJr +miE1J+Hd7EAqjplRQA7EFyG8BgZnQhPqHgsyuPU44jdeJeFkxG8CUA0oESVrZDvd +bLpl0+KyT8w+5SbibMgGOPSGDhsIo02b6Xgu0kpjy8kkcqmcdmTR3SdjGOlZCcYB +p/8CKwx/QM58X3ntYtLIjshLiV0/ZOHRDy8kNzPgKENn14TpkFrUiuOWzyU1C1u9 +2RiQA86hHITe2S9BRPSl11Zk0hNlely5EZosdvQu/y3djzOeJAYxaPVAFRzcYCX9 +rWO+8jxOC3UCVUF7vpGVxmfXqiBQb83EU6lKSkCPRYkCHAQQAQoABgUCVyN+cgAK +CRCHVo8VYs1RMmRjD/wNG0Mw2ygZURtryQH1z54iIVaBao/F5ovYNT7l8XzPHeJG +1y/y4/C6tD2BuVuKdGEK4iovXPkP4MDsq60MKbzfoVZ8vNBORG97wL0mDF7FUGvM +fH9FXDz2IL2FfLhS38EQUI9UrrQJabvhZFX2NjvAnEiptDs9tN4beCB+8FeqDRhU +YBkTjEXCeM3A75d41kEzYAmkEW1h9HySVvs2TX/l/um/FfWJj4/hEUdqs6PUaOYL +rA0tA7Nd4iRB2NCDglJX3RMsdHJ1oTcohASO84BzbYun3RG8c7HDafMW9c2phHv1 +S2L2m7x0fFjta4aCin6FbxaG921MY//iP7ydsHycQ5fHAPmf0xETQVzaX4kzUzWF +Zx7zMPwggJd945zoRuoDVeU/Rw9dKcxdmQUKvRY5X8sAkb4YBRSiymGFvIk/KnDD +4VUS4OWOv9Qzwn/84lqYffXkYJlh+S5rdSmmCvZfwU+hEnLCDeNhP88qIh4sV28q +2CkeGpRa7kWpX06PM/t6nkaRUYmp6N8Bh8S41U5Xo9PitjQ+39ch3FRVVdtAMThI +HSy3FL6RZYEjdenp1ttQ48MN5i9N6quGiJ0QFR8O3dVFoStzHCIBazU2gwjB9Zje +EiC31K5puH80jfWAdydW03l5wSJVzIH10lCJUa9SeBpMm0sRDSxwtV/ul2jluIkC +NwQTAQgAIQUCSgtuqwIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRASbrVj +p0sGv7j+D/9OQ3otnCLWwyffUTSaEsz5oWdEq2nEOVTB8/eYIUO01e4h4Skbw6Hv +KneWnoiYx4o+JjI+9yKUh+0UubRD+SSygxw5Dxl8NsWa6o5yV1GppdSVkQQ/qLmX +5w+xjTFLIEvB89A1gUaupAP4tFzFsHCt3ykf36A/demyYv0J3H4j9hBG0WmGynQV +37vqD2S6PvjZss1zXQHEE7iqygllfFThzOfbJIe5lcmVeUWjkZVgMOXINnGy6Dsa +1AoMOue0kUWWcqtTsB6AbnfVR2JqUdyzkfB6YNsR6jk94UT5KXs1fr/9gByuuX5/ +h0sbluW7e07jXinb9Y7aPCpmmBQVBuYmBB0TyRrFf+aCU++ZxiHwva8g0OBmMN1c +hvFxlQq65SNikzmJ8vyEj6//6OEkt4LMa8JY262gNoPKGGhY91NzsgIvqZSWIEhd +zJwiUY+EoZ+RvhQ78U8ZuGLO6dH5nTFkf0KA5/yOTyth8gNK8Y5+mY6nR4eFAVlL +LeB8QXr4P2JRsp/b073g3UDykXhXB4tMgw+YR+ahVLOY+I3V1iJAH8epXFurfatC +7AaRdDwFW645/OcagtrKDuPOBK8zAQ0QM1xmV7nedhyFLg4BjFi83rvTpStH/Z4Z +5mWeFZJop1PAmPmXuP/TYraBNp3+YMAtO7sCkAf7gDdyXzoq1jrNpIkBHAQQAQgA +BgUCV4EeqwAKCRC3i5CPI0MPgDDNB/9GmDXWLCPJFXQQpssUnnPQht6U3/Yi0RzP +Zfuc1Trff5Ww+llQbC/E79oViLsQ7Y2i4XXExPLKwpQ2GZXdYkTMtfYScZF1J934 +jWrz/Fr6yK6DuY/UJwWU2lLLp6sNP222exEWEaNh8Bdb3cJ8OeOZTJGHUmGLHfuS +rA1YIzS0BJqLsBIUWcOrfy5uVxaWzdZTN0ZFGBcTh2+oRlZYvMf3clV5H3Bx/jER +AuHWRxJvE44iM5J6uvgW2KugcssW8pzuIb2fR6a5ruQockwGVfSrMICEezNjLtyH +Q9FOfKi7SpzU4GVA19T58Qy1NSYr0+9j88/caT7grcOIJ/4aWUMYiQIcBBABAgAG +BQJX1kl0AAoJEAI8BeLJwGjw0REQAJtfOxUmlJbs7EuWfVUR9/fiGu1HayzdpgDJ +RCJhqotXdGpVIfeqHDVY6P1OHEBVfdUUu5PWnafYX0wh9oyefDHZ5CDuqOmPPr8f +Pmk1m/OX/xxSamudUo8cw9iucnoOu4NlvONecRyxSdCrEkW3bZ/fPu2/LdCov/Hp +5zGS9oVn0TEdiFcMLk6LbOGPwLmf1vBVOrd6nR6wMZg6yUxU4eGD+A5fu182sIZA +Or1RzqMnFFwIsktY721LzqY01qUADhHgUCUvXq3DM0snhmsDa1NpiMwleZCSP8WG +V9HmSJGS7Qb1xQSM7I28blNo3APlu39hHN0bB5hQUSJs2M93hagHSMtsjGOJ4Jsy +IPdNp5X/wIerBipEXRg3jDxOzvYsyzGTqid/m6VD6ttHJiK0UrAzPYgr9AIHi0N+ +p9hpZR0EvBO9yXloAlls4/LVOGQLW+HMhBJ/AAbk6JHn5y3ppQ5QKAVGQJULnq6R +akOGouJVCh085NNbXaoge2AvYmJkpbhjEQcpwTvtLDpNZ3eijxU5ptC7vnwRhfWG +lsHnp3PTtDwq8X4HbqIwo6z1XJPu62lmIKzImzJ2H8NyJ9UKRlWACS3LKppJ9300 +Qu4AwegEdGQ+p0GzrkQ9sHkJiBCX9lB+uZPi/1T0f19eKVXjIxEkmLTX76Kyo6sO +jVpZ1HQtiQIcBBABCAAGBQJXaWDLAAoJEIs9hnyCPnphOOEP/2LsFrPAeEXPS3ef +J5FFs3HNJqatidNTTvNRXUjMIFxG+EjB5QU032tUOwnvQlN1V5VnAUcNgpHh5+Kn +Cc2TukQzdwBQh7CqsaJQ0FJ6jx1pfWf4M0PbAmLB8iWJQGtoVa5AG25nWxqS0G+y +JmScErmugKwcBNV5zSlGJxTI8y9E1CnbyPwdNEGTFoCef4U1PaI2JosV5RY3w8ZH +ZED0HrUIrXqOJye2RlhNuZM53RwA/V9jwJnBc5oU8hO6805slygTc4F1FOjrKigw +Cxk+fuABtIlxdKUA2yA6plI+6q+pGCoO5m0XVyL0mpt6CZnjMMwPe+m713fmVPOd +CYOLlsWWQzzGuCtwjkqO9lxwZ0QoMIaJA6v/EDe2ht2F3d3MwUxi5js++HWTZ70q +CgW2lwhQ0GNFVG044/LsmyWhgycM6XrKE3ZNgwxbPUOip65FD3HkNEMst5oMznhl +5yLgxIHz9c9/7I2V9tA43iwbvosNi4CkHh0Xs0hTRqYP6tQnI/ywUQyLWYOnUqlh +SNCIo7joCtb+fHo32yQXAYhcp5yq8dIfcHpZGFW7pY+9y5ZMHGbj5zufYF+r3MZb +uDRzA4uWNTkWWjoxPcWai6mticLPCXSrnFQcHkYL3CCHS7cJRWf7ZuW8B/3O2a5p +tq4b8DADHnIYkzfJDsRSJJh/ohQtiQIzBBABCAAdFiEEa0msutz2vRyiBmerzVT8 +49lkvvsFAlki8Z0ACgkQzVT849lkvvs3rQ//WMvrMM5TkU50no0G0SjxLeK723QQ +YbkGjV3yzm/aVwrMRi2Be+UyXG4m1mNnbSgftFe9dniRdjOsDaJ8SlHtIbWjTq4C +b8Pvcos0yOZbbMUhNlbgYet7o0k7VG3gx7Ez9veHCFBaQ4mLpxjGCa4Gdnhy13rf +rONadpmUAiHmWH/xez6NTUxIdnrQWpLjuz36S34vtBsqQ/4b7GeJFpbIuQ6Lo2wb +TkeE9Rp+tzDurKuld0ObEUTsySSJUjQQYJk1hrjGWbATO8S1d8v21QEpKVgSw54g +meI1v38+1rYdmnQWUHzKMMTqBcTF1PGMU6ik6HQ2c478x6+TwSnjnxHSWU/F69eE +mLygBet5POibwst5OnDxC0N+Tjw455Qc89a/pyH+Sgzt8kDR/yGkeA+WNIXgrA+Y +rxQmWqCsmu1nQTMtkVOZ/E33X6NWM9iTrv6QsQ8aH30Mgdhy0Ke2MSexvMzEzaHB +geSV0xApeKcrx45tpYTzf+TVOs9Zr6JmD2ZAWOxogTlHz6nRqhpo0uSvx9nH4bnW +UaFM+IKnwo3nhMEgtu1XHQQnI6Le23NBg0wW+jD088XRWSCDGlWYaefTYZAlWmbh +3yT6XJ1snQa/s2W2k6WbXk3vKRkXJj6ilnOCbC1bnVZNypqwuiXI8POcw9DB0vWO +AYcShRORTNNJ3ge0H0JhcnJ5IFdhcnNhdyA8YmFycnlAZGViaWFuLm9yZz6JAjcE +EwEIACEFAlHLYs4CGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQEm61Y6dL +Br8ifw/+J6UEHmwpbrhHNrqkLGirHowuHwox+u2ueQJq78KCCDlcF4n9MoS3r5hE +QWAUYyEz5up9asvZ/jIuJKmSAyTPzUjRQdTffXfQihHvWzv4hqQA1nO91VgnpfJ6 +bM8OPaKeJJstImsVvCKf3NH+zaQoGR7IKjtARXPz5yJq6h8NvZyExUSjVAuNJXIG +as+aQXEfQlYe1Ewa4oJRXJd2f6XZAGDjV1YsIItPr6l1xeQEhdSlZAEmQRZo/JCX +z8z21bMG0ED/8vyLwkmEhM7tQpQFCXl1qtNDfxyvZbHEc5ezbyulUyD6rP9wc919 +HUWnmppwP0MwDDxaLyX8adROIRvMGRjdwVD+6m0ZVEskaqENwqanTY7U4R+ASyUJ +tCmVzOaAho1qBfQVimE8u6ToG5d/HWn1f2L4sUcy4TiW9hPY+0ZSjMpPTzq1MGQa +B6jO3K7f7ugugyR+GQ7OMBeTzUVy/hJPShFL6kGcCmf105X1sW3sBccZTStN86Yq +QaUnWLoKbdbUaExtV9NDJFmlrcJAdSrz1VqZhPRif5Uk58ebjZkyH3dqbYaVHpy5 +W/4XdFRZx2PRrHi6gOJgqN5jMivEpakAEFtTDAyxzd20xuZZaOLVGkX9jHfDR+2P +mkmi7GIrxU0zzm9FY7WuGv5Jfiy6SohlwEQAYbVJaqlGvBAO2MaJAhwEEAECAAYF +AlNJj34ACgkQBMNnwhit1P/b7w//fm2cqf4F5bEBJt4XM9IBCbV49q+pJ7hrKQfe +rmMnBSDP0XX/COliATU1YPhMykUGSDlH8GU9Z1XA7joPnsjKAmV0FdtnNDIWDkMp +9KKzkudnf5xj8f9MZ/81cM5RfOcAMCeK86ySGYcQ9R5z0FFUicflUL3hVUYWkG++ +FetUjBn5MUjZ1b+FAMgzcnZg5aoZUGczrnNhj1uFruoN4I+gXTTtTxMtTkhguoiR +B6yubXXfgtT/FKc+crb7ZG229RIRaAxNrX+JEsLKVSk89osIPhMLNhgvSZDv5Z0F +I/GneQUkRZsGCB572PBQi+UB0x71VqqW1gFbCdeFudfGjN+kYMJq2Hvh0DiGxhzO +nJ4J2TeIJeD7MOKf6bxzmi2gWMZTetnRK/g8ZuG12fOHQPA87As3kBsWCY95AqNt +RXdVqnqUelbCitl7iqHSzcOBwgmT0mXXZqjFQeieyXz/3oFZr9QWeKihXrLy/w9k +C0ustehLaq5cHJ93MqO90o5+AA1eBv7/YMBbx6TOgYqK6KV6IM2Ni0moyhOOtA+p +pGALJp7Z5VK30z2kbgTR81I7o7dZIzTy4upV3ZGR0yyaUjE/s0g8/xR6k8f+GO10 +8mSmKM+2RrfnS5NiA4SF/4SgcRGy9/deKA2+cG6L8lTler5DbzAGJ+hMWqI0flJt +9Z6VK3eJAhwEEAECAAYFAlNNmdMACgkQLqdrnCtGbZ3jhBAAoj9LaeSYYNdsNKpv +sRxRNn7IzwcTlU0IJtFqYFCZHEaG4eqal8UxgKDvyEJbqTcwdxw0CPgRmIePOoZR +AS3Ey3aohv9qdOW50BqCfx4QdZ9bVxjag47lCzFiIxPb6G7nfREduAE20P35MC3U +8E1SmL8fXic8lwPEMWWrG2cD0io674ooj8SCeznvYwjEBKMmt11cqhl2ffT/UW+2 +UmBxC65rrkR1yOhRVRQAS8L38tMMUsenVcFQEo/yr2MvLx3ewMzyBr3o0exB/k78 +J0GIzL9+K5lqasTBHE9ti4AxrL3pQ26nshwCweYBCK4a47qv2pKOBEPX3B+cIBu2 +WX7Z2oyIpqZX6tQzE0FPwKXOffSiEjYthqRJgKFKISRz2Dh4Qh7gyua6FLXfvH6z +uWKlxIwR3Sqr7PY6kT/7D1vNwDIwUFO1zuAGK7BL1CpcmsEeWS4HfrXDvBfuy06H +R32Qok8JxmqUYbvC7o6aKlgKoouRBL8/TkIrvTeetTmG3iOPEF8DCFUv4HhZbfI+ +Al1y/9Ud0uiCWFuDvsSqG8vMqAi0lS3+uzYIdoZYEAXAO1XrL3YDabe3q/Dvla/j +XwA69Zko8F6ubKbzzdNqm9N1BsNmlzwy3YPROTs3Nl4vj7KiY8rlM/7EusP9jXPF +pMhG8KzV7I1gGDaDGJNeLCZfdBGJAhwEEAECAAYFAlP7wEoACgkQZJWf6YON8Zzy +aw//YG7F1hUelOXSO9oT2qgN3xRJU33h7ds8pOZ9pypneBgmBAwcGmfmlMiweV/i ++CwjrnYHe4npKyg1OhvPQ+I4iy2cOIIsYX1Mq9SU0nd8reKBc0/GMU6a3u8fTGjg +LKwW5nSaooTgVeynr9yU4sFmdHnu4z/BKc+fsvndo+U959ZO8qW3uRUOvaMlAZV6 +mTc21Bs0DJ/iCQGeJ3R6/8vDkW/WqzLS0Kz6cKVKaFd26Xmw0D+hwIZgQUosQXrW +ylWEgddkEr4NjQSI86j64sm7SnRCF9vK6ejOu2RioEf5N7hNWhalaT7dWCyRvshr +ntpBSGxrbOj0EAcEbS0K9qzXTDx1MrRMeL5BEOjYTSpTYmW1LXoCj6Pf5ZWojs74 +3j/Pp+J0G43eOZRs444S7OYtTsFMtMp1VFpKPr1l3x2OrluzZveeYHQ/zHpvBZxs +mNmgpXoNXOuxxLzbAGjch6JtsJn4VcYvcoXXWnpP1tfpzaXWR/ehpmzPvGfEMzjD +ya9PRnjhEtFECMFkV4N57nudAT8ia/GJA52rZKT79oCxGuO0suhcDzft45BTOauK +1wp1Y5cWvKrT6G3PZWdsxgddOxOcv5J+ZM7rCI/3Zj44aezTVJRV49IZAlzvb4nU +10nfDvMXAe5fyNebpRChsxEL6cG4j912i+s2iYa90bIJ6uaJAhwEEAEIAAYFAlNZ +zZIACgkQvlz2h9xat8Jukg//aV2Y9ACPWL4K4vfLWosMRYwMW7PIqjDeQYv6snBQ +K9V2CthmEmCiRNWYNuWSVuwwYBjPLGx8dpTmS1bvR8LTXMGWXoRsxd8R4OWAFvXq +CSTDH9iOMH1060fOv8TaQaPocy8nCNyRHQh54z8m6sPunfyiVqUms4rhKY0pp69B +u+z9nn3Kxak1UEbwBYNj+7lVXO8mvQFLJdehX24ynTGUawDyszujZevlB+yJTxdr +J+kPIOtdzKpFpNZhlvNrM2IvUV35WGitumaebYU2YRaKjWbAKdvTfsj0R+YScOF0 +uh3BfjDdgqa0rDGDRMZqr9xyLdTXs39upz8EoNPZep83lxB0RgvJ4LnQfd1lv4dq +UW8ydMKT4sjyUimEXhxipuIi5lXuXLBKzKxhTcM0hAH+I5Gz6DaNAFDEoHbtUOSs +rnqEdlWA5IOZVWky+P9lRCSHpz/+WqVHgAgAKmj+J2UhzPCm9GysRC3jnNPYI2ME +WAcPew9/jCbZ9FdsHDmTh0RWS6Z6i4BGixv5cixwYNEtAOOI+nUA9jlCu269FLpR +8uFZfDlzlf5k00Oswks0sgPQ3nA1Gk06dHKjT8d2gd+fljpgX9jym4clcDYV9vJ0 +J7VZBWCGNN3+NXFkOUdP0DC20pxhqGbY95Jo7RnipIzELZS4Pyyp2z6C3XLO2aCS +Gz6JAhwEEAEIAAYFAlP8+F0ACgkQ+mQ7ph0ievux+g/6A3zHRO4JCm+DHJ7Aoh54 +IsusLYdl9rUppQ+EuTIKAXmUajQauClytUaq8f9Un33bL3Kxln7PQDKYGP/cRk0a +GkJapYJ99Lp1NkC+tOdWl+fYHk1Y+t8zOfbBMlE8GWXd9IkoFcLpzX/8w9bGrjLs +3R1tJOyFEWyJZujgSusEcTH8G/Ra0Mhd0o4ZCKmm1cudQaQZpzP1qhC35fScAo0L +ZiadEYWXyWyu8IEI/aZkRk0kGUFiDLyZx/5n8Ix4+QRBZJzRzwN7aAUNndvCGYhB +PYkCWZVhITHMCwfd4SI4cl5Q1V2WV7j/8l+zt0hcFdT4k6BmE/2hDz+RJ8nwNh/I +xWQActYLcjc6rS/dO7sHSnlK1++oMIQIJv9ycczE+3h0wxlbFVKeXH3drwIz3b+A +Ko3GfSHahNKhd6VKPqebC4RS46o4ZdcpZBhcrTPZof6IrcQGpbMVLPp/vaM5SFHG +FKHdQT+fitKxtWv/W5CHb8kimlDcpKOqK42/8mWJ+pHZLGVQBgr8aISkb4zdLhDJ +4Q1ntQ8tk5RZFog7gpFeroyrzQMtG8YDK/zQvgMpdSEBv9SDS1AihOpd6jMgQXJL +bbrSD+j328bpX9/Ia/eIesbG21rd7BnJSfoCwIXMW2ANkwLWzRBUrxOb76B3vzpP +VFZ7p4VvuW9xYitGg5r1LAyJAhwEEAEIAAYFAlQBB/MACgkQT6BKTJJXfsQIVxAA +mo4vL5LIJrawTPn1JLVUm+eISQWcj0RC32DKmpL4eqYz/oBGPgeYQHtYMO5h3oa3 +RSli8yyhiUxVXgtuO2+9hzZgUtONoHdUw/IYOzyJ5n9u50hxafDZ6oNFIlvfhZBF +SANg7RmYmbCzNDvOd1Uz1m+BrBb5Fm5jnatEc+B0DLlU8u+cA6jiK5XIPx43BIHo +9pdA6pImw2mpA/7Km8pwXOXjEtRBMssmJc8YpF0o3wj1aSmXN6IaETs0BOZI8Tri +wk6+77Cjv++vE6VyCxnx0cDiSIix+JnIEL9syIgEaPgjG6Fsg8jRQgn21pqtdaEf +V/XG2PvNJcUN8ERqQg8zkNFTtUbwLyhsjywL/B5rPC4Dvu1k+bPv/IeliDnr+hnM +LueQ6XtbD/vmbhSo2MIRoP0j0quBQoK6Ah9/jJKzIpfGGHgHurxSa5A58r6lqMFk +dak72WOB2yZmHQZSVKPNG3DEyjRZsMrE3MTrwlMdIXHgTCt0R34WRSiAYhyo1s3a +otOXKvjKr3CCq6gpGH5XDuPBIWH8uXv6pc8x05dDhS7xUiYPE0ELB6Qr/QXd6Jsb +7L6uAAt3KigYBPoLc92ChWe/o+0RxVx4tAU+B/bg/ZURYa25KlVwLqOMEIzMUeSd +WV2KtvHr56n0Qew5kPNoKjZ4hIUUU+XkhyGFlsOCoeuJAhwEEAEIAAYFAlQDssIA +CgkQZzoD5MHbkh8biBAAsqYHDw2gm3Yv/1tWENzI/V5rtRnboVRbxjbgbHIEBrLr +f8M8Mu7ROWrdpnANG+mHMip7usnW9bywkK4C88VUT81DZnp7P2JktfdzhFIe3Q2o +6gJOT1uawspev2f4nITCHS/lgetErjyAqzsrNVcT1FK05s25G/LqhXhnguxILm7O +4zq/9ZXaHQZHcBY7s80KBPLE3IzL2y75MgjipPhIIHTwNMSsp9NyVr73dDaGo5EK +QqTMuKjEDQ81/XfEsCeFh+iB8ufdQfGRlcxPTcwXB59w/+cBDacUC/PdnsfKelp5 +nztm/TVnbBnBdrLbg3d9oYorAoBfwiYIpWJOrYRyKdMKRgCxH/hXsHB184yPlqR2 +zlqJxQ4ASTp3sjmUO+HKgBWsJryMcUY3cTndfoLGnaxRdL/V9K04PSn0p8ouOBVU +xG8+h71DQMO+th/TN6zZJ9yUlU0SH4CukUE91TbqTgTBSBGunDA7OC3DixRl18hL +tQlbBvKbvu62FvPlSJuaslDD46n0SjBCobAqOUGgjTte4HM/a47mhrTklD/XiN+T +xQeohs5KTJ2uBw6O6FR6NyhDpLU8ii7oqtUTl6QQTIWMsKliktT/hYQeiO5whVGr +3kpPiqwnb3IGecbOVMFEZrq8U/xeCkcQQhE1ohKgwpGq8zIYfWzUphrE8WhM++KJ +AhwEEAEIAAYFAlQFHCYACgkQwPiGTNo9A1hZlQ//RbxDS38QLp9oznZn767zzRtP +kH59EAT0SyVE0ncskwqvRuGF2sD7bRaQQ/btzzQecc/gEY535sHwsO0QI6WjDdMo +Y0+C6vNNvl9cNST6C8y80kICDXdgLX0f9mKE61xib4FMNq+epJ8SdFf6IM+C2yVn +VYvjNI4KdNUrBtGtPtm7KSILk4jHiyl+Fk1puXR6QdefS/BofrOi/ZrgQohAGbus +ACtQk/IMEwj6lPU2GZWL/mOpZs85o4PDJVGp0l8XW4RkoCRSAaCAEDALta+CI2SM +l13NWO2jla8YhZtYW1pf8HAKzjJHirDCzD4vUtJHbqgjUCkdM1M9AwrxgBn2qS8u +4DRH18aRcQMJXpAYuWN6SvuFagPNGhcdZ4icLXOp7Y2Z+7ln8LtvZOnReXgDkyje +MEtGV/Q1B6Us6br2KE1YODb/aHxSj5B421zoyihCKLsH2JgqbivhnkKh+ZX0vbT9 +JxLu5R9+qVxLANiTVQMuYJSmFghfuQ/DTurEBMiDxJ2v435gtSQzZzl6RywsWB8y +Nn5GII9Gsooj4qj6rs+2/oLaKu71xfa8weFooOOgqlHTrlJOuJQBXdknHsdOZKV0 +tmhGdGSMaWPAXPIycV+KmTxtRk/VQjfCkTPgMbau9/bKymZO5f8rVqzacnpMFd2n +o07jTZ6/zzEdZELOYEqJAhwEEAEIAAYFAlQHvuQACgkQO1biu9U/3LH4xRAAgHqi +jYVOP0a7kw904kJYWaA4Gc7wJpXeShAWHMsAuR5pVFeW8RO4hIcnMnIia7zt2SCg +6UyD9AFRLIYteCyrHHf8Y0Bh5pbDyuOrVjQhEYty8mHqiPkT3p0v4FbbPaE21MiE +AEqDd7ejmestXW+0lmKoW3ozOqxX165WIbFbddZF3vuz7fFLD4wHIxJPELH+63oC +w2+B4U3+kz9zj5Zt+mGucayOT/I+9/0IYrfPkKim0/gbi6JzemAQ7Ma7yOFnDdtW +PMLXcQgzDNd1G91bJWeD41zJ5c65FwTDOrhSotk61YKMfwq/ujACKMZgRwnlZWNN +LtgTFSaZWSUyaftgslre1HU9TEDyv0eW4zeYUYWR61SzT95lMpvMKuP7ZtWCSHGF +i1fIr+gxIsZy5625Ld6WnADZY0C9cyLZIECQbTMnxs9B8WbGP//r3xOs+20l7YvY +sBwSA8h9ugdkhUuqGQxfAWomMMxrG0F4KUQkprIteitdl9qnGTdqoEurnpdIHGEk +yJOzTqFa0GieORdlje/O/9OuWmkdHNG5dw2GSOJkgdqSi7D21b/+526CHJAaq68+ +NtIEWuFbV30M9Q6qs1qPk6VMYHG1Y96j6EvbDjM0HKoBn97RJEUSTbkmdcjV4Fyb +sKSO1nkBt+dVzmL7g3C2cJYVtTGLolGbWGTcHpOJAhwEEAEIAAYFAlQcL68ACgkQ +2SnymSvvCjMpDBAAx/4DuhSU4BbYgFl2E4CDO3V9K0BNfYJrBkyq2OEkHvEP0DVL +5uMdVTQUIDc/jKqN8L4ktrm29XdZkBr6+swGQgbtrv6OFwpLbH8Qvcm63DZDc4NK +oyOcA+E5hA+X7C5qkS+Q6SAtTeeONg+X2CQLuhHSfP0HuwLcP5CGCZp0kYbA+ZG9 +lF5c4/BcvWrOhm3LYafu6UYZNaP966I3z3EuF99ZClWLw+BNgdRMi5uAA8WO/gP1 +35Ie+PTBYkJkpiMX4AuVGOakfP5YFaZlVfeUasbSqZn/o+MIuBNvJp86f3Lk46MV +LBMQrLlpMtS1eZjBhTpxvhhQVy0/Cqdh3Zj8TkVT+6+3i/1iWZpH9o0GQLIpkiKh +Z0KUUzTIj21l1cLZNsMMBHfMSrQJYYQ37uP84v1IKLjXk5c084RGzixxYd+JvtCE +uaMCm88QJ9Y5pBE28bqaaGVv7N+sx/LpBx+YQn/nlW6tUNgRDQxORS8Y955Z8Mg3 +u8G7i6+FJCjHLLMks3YmhNIJZLQxxeGZnzpeoD6HFXBDsrk1JcFJ7kPUOGmE6GnT +zcxfGJFGQViSPi6WclAhhQbeFe3XxTsuKgsiggRwrHpTLql8s8GdQYHkg+UTojUW +5MuM6Pg6qiVUQNK3OA9M6nP5L5FMXBzv1yAspnMnd8r9dwY9OdBPI0QqRnOJAhwE +EAEKAAYFAlQCgzwACgkQHnWacmqf3XTB6A//TxNPnRi9zT6+JcQ24xbaAYcWT5B+ +ckLzFMfu6tjMC3wqrMtrTJlBsfglydHvxPQqJcgeieU73bnYUIcYvMUoFlHDxJqJ +aAGBhZUtWWQmpgADAHBLOXZReTYhDHTEhK7tVFeA8AdJlBSZVABzbAdaaqf8Yaza ++ZZO4MO281y9FsRNgIGP8sxF2YjGHb/v0Cvlh1G7CSSp7H7knr7T/N6Z1Slcpfvg +N7mvI7BGthhePJCErx/NcQy2HNgcKwz5adY7v0f/vAxyt4WZmtsXUfNfTQIbZUUt +5k/lB6kP0AJyXBa6FyLeYF9sTxNXOoFgMiWly3yow6ShRWMdTj+PFDZAuMVkL+Ih +ya46M8dypK0NK9nmLo1HosYI/V87LgAxKqSNpsucozyfN9km8WTMnsoiIKyt42nD +VkbqK+JRv25+RZyFvG7wteHx4ykNo5eBpnITwphrendUT1Y/hIfmTbZCr/ZuXrAc +Eno+cme4ixVAFNEsXjmayTZqXY2TyiOvNMQ83S5V7KzyVNDx5/9Uqq6cR4x3PjQ8 +pMngVS3QqIlwXlR4a96PmIotv2ive8kcQ9BClpM+j+xSPmoM3aEtwI//IENsvpyW +27Ljtvq0/6XnuVNzsCtk143/RrkrGsTK1Z6GUK1KRrsKtP3s4OAwjQMkyWaU0+xX +8RWgHUHKX8u8ScCJAhwEEAEKAAYFAlQHN7sACgkQA2qcJb81fdSzFBAAr6OJTmFA +XmCtpG7epLRx+NyffbFuCqwo2GoZceTMluonq9y8x7jM6L7ODWWpBuTa6sa7M3XM +iMCYPqTW6bXnRLmUkrqc5j8/BHdLCBJ74GVeugktCtcflOHdefpjnuItJGCiWoE4 +Qrn6EDMZINVM/gE/A1Gc9tswN5xAHusZZx53fn3qizdpfgsBby2TYApifEuUOweY +q0TUSjMU8AbcgUPNur7j1KV6Yl4AuWSr2qkMFKBadfOtG/O3Blg6SqbMLyhxLy2P +tIpakeH5BOdjoN2ILmBD3w9iGFPQ8+ev+X0G0shaRO4/+O3l+0A2phheVXdYMfy9 +TL0Ma6BQoroW98OO3w+WzpFNI4f8gLp+mj2TTS3x3E1UcZBqDDzUkLDSHxp14Q7X ++lMkjEfhXrnTjDz281sLs3aO+qlNUVe7LrCmY5BajUGtxU74YtwGuAlKdX7IfszS +d9XHgZMLJ/9+BxaC7s+eJZwRDrLbNvx+0nQIOyckelajTCduukO/zUCG3KJLhhK4 +L20gs2x++MgI5qRc2Q1oKU0DoiFiTxpqIw0gOlXEb8kIYoDPxQn27GhzzdzVCtfA +9QxDQr1Jq2x3mXsTT0hGZk+0hQfUV1NOGq5dP0V0Nd3+6TPnY4ioBH224aLgKYLZ +NkvQ1/xD2ouMTpqexau8Fspd/XR81V3sUiuJAhwEEAEKAAYFAlQNGwcACgkQdRq1 +3aeWecywXRAAoqBa549GaeqXvVD86letetlMH4oOjnULCO72MAfeXNTQLRgyagor +DOVI925B+6bGCRla++guH2apy8crQzpqeolgFjZrT89yYkLZW2pK+vI8jktSZaHB +cxMqNnqmAOkDkYnSgcGoh0Jn7P8cUWq6wjIDNYYOZHM7oXpDOzqehdYuw64NwvFd +DocsQDUdgX03AHSGXkT4lVjTF+XkpQzWK0wqjIsa2odO5Rp1YfTSUd1AYEC02WKi +i9ZbZZ3bGPz4hRNJv58RGjUqBrfj0ObuyjqU07jvvVJulVjmCchnAdOTQ0wR39Cf +9U9itF0GI+NShJGDGpjDc8A32TZcHkFnUwWMQ7MAd04kko+msa1dN+faAOuEMFq3 +Ic/qhB5mnd1Ut5FeyzR4VgORJr7h2YNzba2pt7i+n32K90TWqZ9OeUyRUV/9AdvZ +nLfzbmtDofum9EvxZ4IddUiBjPQyZYTayHonIdS1aJinSxoVp8U5xLY3gbgUwiyH +igmbfxNHJlUlPTzFVUjX058mIfsjOysuGezcRASdUlpSsiZtr6BIIPBItvXj/0V9 +9zTGoLuWBHR8lKyPFyxgTgqNk3wHp2Z1q/eO2QryS2lBPLuZ88zWPXq4wOWpj0nA +2xbGyBkertSxBB3yPr2xR8yCviqVYjxYuJFuBKDkRSN6iZrzeMAWr92JAhwEEAEK +AAYFAlQPVewACgkQbmCLY32JZ+lGPA//V1UR4QxQ1bA8vqDfvEu/J2BGziAdtKd2 +4jrdy6eoWpGbXsSAP8jw6gB8cTG8I8G9upOLeAwh1tZeXPQSOGEL/eBcaU5SFOEf +Rc2dr0pcok4imG7hJJ4Za7Oyr+GZP3SnBDvOHCi9U9bYjvVE71YmFgyMyESPlLl5 +1dJGb1A39nf3PamQewzS7BNgA8gUuw01shzkUliw/fO406t94ytkHlvQatyweFvg +Gh+DSH8R9Gy7WzzT4qu4w1Kx9VR5S6lUSEN4j19VkpHyxoLdNWVPmy3euHdqu8Xd +FtpBMNLpO8+wyHIYeogdL8Zjc8vAjm6Jal0ndPJXPX7H97NA4IsYvbL9Wp2oTGrI +2GSfwfl5lwMRlWK+GLzTqJ3bJM6Zrsh6CcryD25aBMY3imsuk5btKxBUxT6Z6CbH +vuk/vCVQO8QG4Thx6ZrQ4KELh69g9p0KJ4qaCUT+0OP5aK0ai1/O7BdRqKBdHT4y +A2iD0agmXwPoBJJTAJqNk0p9gVqju8zs4i/Ikvr+I8sueR+fC9myhxmBw9ML6mC/ +AmrylSP5XEk1RajUKPYwRxpEmH9Jd5rc+G8ODarld5R+rf0c8h7BL7WbTEM1rGxf +VH2Nusij1JeM3CF7i2qYmSpc1sTo7kCQShEolKlsCUtHBO/KKu0EKvuG3QxQrYw1 +/vm9CKrHpTuJAhwEEAEKAAYFAlQPZbYACgkQ+z0lgztqr/ipYA/+L+J3+gnFk9nS +iKeIpndDt6S7oSmOkub6HiPZKjppMqKq/mgI6eLyZJaJy5xKw3DGUcBAqwMAowND +xeSJeKvaq4AQFrfxbIc3l0Gl4RYBfLS8voSEOyqIW2PNYjqoPzUD768SMnkNsajP +KqiBCPYLlJDmDZbPFCU0/iwT8CKO6FJj6dgy1h8jbBd/DlptCs/b5Wh44CAKUXsn +HQwg67HDJfnhxVvF78g4zpldODPnFRQKmOXM4GzHw/UYiPnCTUcoIZQrGhpPftV9 +Nq782X8nj+XQzNAmMgzooRHrDGmcVGPz9WJjLyhHO9ky2n8xiv3EEVS3YXxW32K6 +385FdN/Gvp0QNBZGk8bdcFWQaRe7J8rrU3uSHqd7Dg7SACVsprKEvHXy9z9f3mzP +GKV26qVW1QBKnXM3JPt1y3kWSgnSGH0WjbinjrS7m1gVTKIEq5o6aIjUP94tjA65 +TbB08L78coh3AKCIpSlmpnifIzVfWbCtURL3bFqyHYqBvHzXsqwGiYkcVrq1GLBl +MOOLXggCcDo9T4vofIGKgzBnACWJnc1owOBWY/JINZJwsApIdhgqRf9AoHkfWERZ ++4VJ/flfqYUD3OsJ+Jztvdx/oI06Fy2zxsf0IROJ1ejWKWeVZxF1ecjmOH279d2X +wlUWagyTb//bd1Tl3mLacBU+n0rSDJyJAhwEEgEIAAYFAlQAsYwACgkQT616dThF +Wduqow/+LHJWvJYxWrcMNYdH3vdFm5tzoRKKGCPsAKFHvg3hUbwNdNP18bZ4rzZG +w1j1MTunsp9QhVZQxto0hGB+Xilhp+DQk2+TZwI7LT4zUkNypMcoQCzUJlVk2KXo +6AnaI/5wic/qnP0jxi2XUIZ6f4kJ2KeaKrrFHsTqb91hoycuPUXpdrjRe/QFc6bQ +FkGdn0i2LIt/lSTl/k6bf6bRuEMIht0Vwsqi4Q50hD/aAVk5WA7r5M02ypPZTrRZ +JoJ0xSQsdNQRLyx5MzFOmxaGu5848LeGa5kVM62k+j43k5yP8fNrcIWFApO3Nnux +3Nn3ZjEgboDvRGltxRjQt+iKAAMCMedcEcb481Ix0ViFc2n9c5hiHcqHa2qoURwu +dpT4QOuFOWeFpOSQwbwBU88JyHA600zJamHRyZpHOj+2zvoHKqnNmgAS9kkRqNNF +gvMoEvqU4Ml/BpbQx2gHTr+I1PJJh/1Csp9o00JcW8bhC9rNYPZOP/8mtej2Fmks +ay+EKLMhgfeOOVq8RxpmvYNusC7kvSRfIsSw3AYCif72gW3sdrQPZaAuj7zJQBQ4 +XVu6B0YO1hjLD37mpXZpcJlnCf8KL5JVcqVjvD9C7ico8TEC3AGSLH6gQ9LySzx5 +e/boITk1GHELlMzcwG7PI0mRjyWNfzLyYM1YG4WmvNHDFaEbUCCJAhwEEwEIAAYF +AlQxjv0ACgkQiHtgYYs8Fq5/nQ/9HCDIwi79cCPfuq+httdkzHqU6mB975AHUvb0 +WFLT1JR9/sEy/UkUBNoesAroHCrvEfqqWPoJAWFN0i+40nEMYlIgoePLVtjDRaJm +GVHWSTaxCe6PAH4Q4ZFYbRXXFFYVxIDb2Yn7j6oanuO6qenBx7zwUhfCPC/OHJvw +ARg6PjO4gyqdhtLBkbfis+DTUFMr2eGmB4Hn4qaCHMacMtOQn4h56XWKPlw4io3u +FmQc0EC+gkvfoScpKG+1/8cWSFX6csfkwwSGI7ypfZC32E422C8zJblBorw2dfXd +dEJMkrlDWe7/rmOPHCpO/mqNkrFe0nFp6CN3TgTyPgJmybibsJafovyP2Tz1Ko+g +X99JKiDPYasQ1nMLVB5KdD111F+ff2y1xgY7BAxSM1hKOgpyQyhxKRwlSWculItt +GEJb6My6+VwbYx/5c83ooJithtj+/+Vy4AAWWskBMQO/x3J/2/lOaEZjfTDLgTtn +r5CypcE6n4awmYeaWmrbdE83uoIbrF8nJxLhhHtF5dFik27RuRm+yEPieSlrrv89 +jGJie1Ygs6Bq0AfH5srEc6E0u0ZW9PTE7he/ZuHHB0vweBUmD5COtHI/l2viJPTj +tq/3BJhEnEmR7NrHsZAGPm9ut/RhpxJPDqy5ltONcBIxqvRB5aVyuFUfrmjRVcQj +Lh0IRRaJARwEEgECAAYFAlTQTv8ACgkQlOkt+SqqXDvVgQf+ImNY481iCdAKkYTR +3ucqOXrjViTGelidbMqC3s+KKoziJwAPOo6EUN7p/IhMQA3wsT2KIg+2MaM+aAsB +Xew3f4jr+l3dtjDPEEOVh0FV0XZHHwg7NTjSLXuEZ/XYgJSVq3J3RT5lLz7vsV2m +HHAAS5Zf2Zq3rbA7DB3aIkWJQpo/ngldtWmSjFGvHaLcS9l1DvBTdBI39YNMxe98 +ves3yH29zyizebqrDBUrnFxmh9S59In8SdmVePfHfTnjdQEpKc5k3po3Za794kdN +689zsGnaaEDCiCGmh91QPltRhL76ud3FSj9saQDNWH3EgReDeMDxUH1X/4t0Zs4t +MvZGCIkCHAQQAQIABgUCVMYwBAAKCRDDjoFgoXhB/l/PD/9KzZshgdXE+UpzFAPc +oPvfCe6OUUtB4NhuuMowlJsTnGNB24Bb70Jct+oz3lcYcVzz9nyUJvlyq4GKRIzV +K3a6j1d5fMkme0ZS8+ym4H1FriCKS/c/yo1CUdUlHfFFKWxRS4dThCORg16K7vtO +f/okNzxLM8XSdXcG9SZrWK3+hcZiwVFO4SLovyVMXz+JRcXLVMOJsiQ5gVi2Y4on +Z/OWVbPiG7WbfYt+bNcmsA/hPZtB2jUu7qMuN4woqg1S9RXUt7RbbXyuXy6OItZM +0F1q1i0nPCXJkEl/mr5jtw1UACi0qkJ/M20NHem/HA1G/zx0zk4HYUEb5zOhKvWX +CjWRzWAL6wP0JYh5bs3zsrzzo5GZSmJ5h3K+Kn9qf1z+KbbTLhsNqznxtapHiHNt +eaEJzAzrCYok+OxtcQBvkSm2EL4cNEUM8eHuDLMS5sIQVcpfRMlJIlyYm50EjHIX +WopVG+DSN98GNrn7ts4gt1xoY25xUQqYRhf7VQmyBX+q+HXMoxi+kvq3745R5cu/ +pdTM1ZWYgJY1nTH+cIj5Xlg1vRRzFUwe8Tyr6E1EREN7SzGvwk+XSUNMfCcCqTYm +++iY1+HEMQRvpbf44ijGBPELVTLPto7YfdqBElHwHM2z3+uG4E3Zwnz7WFDoCAqW +OKnJISN+ZfdoTSai86cSbEPQBokCHAQQAQIABgUCVYAyNgAKCRBXkw2rC4awZ4i4 +D/9P+P3lbAt8sYfjsm+fS5j9Hn2yfkiBZtAv7XoVUI4wXkEuOxesASgwMCpLX1gm +w9OCcV/pbbqtptGosYA/JXv53fs1ndVe166aSaBnAyoOh+ZiTNICFXp8InurozAN +qN+VFMRCURisjo6tsrSNrqWF4LjHhHzxPXcyQJEH4q/F9Bm75oNKix2X4nzdISqe +IB7pttuDIQkeY0VyefIvf55iZCSVZG9p+QuUiOR+bYHavSpJrBspyYXOeupCB3sa +skeQGR0h1JBXV7HVOWMP9gOYkz7mg89Ta1Z5Jvf+75YjH5u7scg55TxHiDfD/h8d +oZIZH1xK5lIg6HGjOIlGn4C/xh99xrUXdpzpK73PZA2rjCvKXbj9YuhrWJDOVTwB ++ZFxbTMsHPF1Tzq0P6UPT1/rZBCjtHYC8lpimVZZ3StSIbUfm0zpXUiO3E/Ni6dY +Cs5rJN51Bse2CsZdSTHCSQ1pqQfMXnz0xK0fqT9MgUIkLsnMLBBo/T7xkRIO3cC6 +mNy+Y+RGiYAWhY+u+5l0MaIrlEheixt7KP3VcDSje0pZMGOo/+HyHxkJRmvJBnQF +uTb3Qhd2MmybQo3Bnomiq3eHt2jV34VHTGYTQipP0yzJRKaHo2gxxEZY2pAfsefh +yBQUHktLiNYMR/Ipl2D7VFCsPmExAB/DpTGVilJJo2EYtokCHAQQAQgABgUCVJCc +0gAKCRC45Qh3Zkdar0o7D/wIW2mRDmrwP2OEL3ZiWVLN9nnXXHxISjM3vXawzM2H +21iBeJuDib2q54SmLZ64Vb8NTElCgx/Mf1HeEQZPXsc5oy0pRkJbAL/FYdiDs3xU +aB9gNCVzO2KuRmGTmUNZOxI/ILta9of9DKHBHWo16PzBF123SXOt9qM+4vNInucP +PPahAw4mulJsppHzWgV8wNhdozSyzoZD8zHxUDVTOBBcBD9uh96bQf+fETWz09SC +WSC5Z+z/VIuc7V6rOM11QerJ0n0WP4GpKdb7/s8snAXbN8WBVu+5VEsNfMZ7I4LO +djgPhVcWzokvlwvOojjHyfhPKDRuNPJQoD5cvUp8HekCm0SW7k3sKxHzODaD+p+A +9UWkPlWcWQtuhwQ61nxwn3edq6sw28YgpXocP0HBx6VMvrP6uJKPY7SBPyD6kn6O +SEVjuJXnlv2LnbkXpD+QU1PJ6czywAQPG1INJ4Zu1X9CG1KjGgqe2JC096yVSaII +jf+W7E2Hm3JrHwF4CfYaBhCptUjKt4SUlI7+OlVc3BPZR0ra4Ln5qVz6Hd7Hm6gu +ZZ7u0o+VXO49kS/55OLTxHFVPUyra8yPIPO8GNUUC/r4Ak9/jtU7fl/hUtS6XlI+ +apCbAh1N2xqeD0hqfSw2lLbUYWkr6VXgztXQQxIWso+z+Clfy1yyubAEa1iIaza6 +SIkCHAQQAQgABgUCVLSGLAAKCRBQQfGJH0TgkJTbD/92i9BJN6B3KSJGpafaD1CF +NAy3JTa+B7ey0AsJObz6G011uDtAPJG+Is9ILB4EB7BjaFu5xHelmCVfXEd/Wp0i +bXuTqhBg5aaFaygcPghGEi39SsQBUJ7KLvBOS4C3mGxo6PRUVMzWbbfQ8jN0C0dX +cZbJYjbSyOaSRnkbKSwHvYWZm8gec/RnhoBs8IwDkdfR65KMB2NRCqfcXq/zK6kf +Sxx1tiXoqh18TfjHqSLTv66wIsPdMxEsoB/DCGj0xH/3IIkr8RRGd//eefjar9tx +S9nTlbr4QMmjFFAsTz3tBKpbFqAvC/4NTWsBMQbBPyspNd67pNX3+AjVqEl6Crf0 +h5WiSb7fCvSJbdxmnF86XEqb6J3p65SOxEjDS+4ABL681SG1LE+l3VKUTkIQfCaC +0otCrgh+2C/ShHbkvqwNkGkVHX7d+OIdcFF9u/5I6UMIPaYK89804CxQ+cM9Y/3h +KYhlyun64qE9XQ+m5nC4VQcnK1w4Omh+Tc7+Z710GNFu0NY7vyfBc7H7GHulslDJ +Gn9M33TqFpA3u7kvcRn0A/3JvjGxM+CStwJOwUuG0TI8fPlMbvS3FPntKcLvY+7/ +5Kndp/tfxzHbVlxFaqRFsekpC6+e30RAgx9Djrrsgb7m1qD70z4SIlMXiSiqYNcL ++RjY33gnD7zWiWzKExh+z4kCHAQTAQgABgUCVTbNPwAKCRDHiMTB1FUNRc1qEACh +ZcdLBezz+2sNm62ZVK9wTBNd0W/TowwAiuK3TvZc2whFiwYTg9WUgZ2+G6u89TGU +n2RsDJkFHXBsOzQE10jJY0l515OPeS1UiTxR0NX9dqyftr2SYaNGHFDybzZHVSiJ ++fK9Gzz5DEHVuG+loW6Hj67dpR6KTrxSE3y/9KpuBhrVJE0Os/F6xoZ3ogkkb3hg +qVSeGfrAuLyY0ycX8m6notHPVdSz6VfL05duKiEogao3OPAV11DbOHfveC9fNjmQ +lS8MxpOc+C7gVgpAWPazmSKwUPqJ9NrG6icIq0SzKxSSPCO8+FnaTFvpqWLERpSx +npIZRsQUzHMoyathGxKZzN2ed14oVxgRGLfRHcbt4GB4rtb6NZE+Swyi0ZmlVO0/ +2a+hIg9AYyJ7be3nITySuLrYYPTOgAvqaihhAzpE7bDPOGks+Lr6l2JYN7jImIc8 +T5uZJSP/sI16lG0KZ/AzPQqevNvS/w1rUgJD9+MMo15W+QlVieLaIJ2H5Y47Xjnp +MOXCzbG7b0V13umHoiu+FC9SJoJ8b7pwpRdXyt+xGAZrsMxQr4GWNwffrDBdkyKM +Mc4qLcF1X8T0/z//vsRvar7iWA9/lMM924ET/4/1Krv19LSZzPKIiWpouzbvKX2W +F4qMWw6N08vWq1R+EARE944BirSqgTFhOxSTplFqwokCHAQQAQoABgUCV1uYvQAK +CRAtNH6mqmVCHdJ/EACg7UiesNKb8/+B9jooUiYXuWKAa3Lt4LJ/beLFhTXH8HVS +BiIb90KYYbokOp+rTZ0Sj+ctH6wqwyqE4gA9z7LPHzjzdNQZeRcOvJfLjdPOfREn +pP7vjsa60FMvM5Mw+pBTEu+12KmDDIdL1SKkKnSIW5i5rlkWZJqSDHVuK2R061A5 +5HSfh4HF25sCuKlg34o+rd8o+IVrGzpMN9yUQdf3j2a76bJCM8N3+T50bQbq7GWB +0r9cBeCyhDQWqAOPPOwIu7zaxJRUpXCGRbJpvG3Tv5cXLbpc9+p/zAS6hLXrOX7H +0pqr1K9UCIDS6O63bwTU9yEpZGdlXH+qSLkyGpTjmu/6L9c0VJmjw5fBMr5Vj9n6 +VBaUvJM4Y4kd3hea87gJFCZQM/XypvaraS6en9ACA/pCoScS1XM7LB7Ctw8PrU2X +nJJw9kEZsf/hvVW/RGVfKOuBZUSmMj5Fzy/MOBeZ+mTcbg3BVt6Spc08JgkSTpZr +3Ep3dQkCZ2uFGHgHZ4ODwVf8nE9H8Dy76WhHO562hvnH4uH6HiK2symv3hJW82Uc +mpEk5FkjNuDZNj2FhT0CiaTwwgBt/xvhyWWRfVPDGZqPCgIWuesUBxqu+ruK8m2Z +VPsdrKlEOUGEuBT6Fn9C6P7HF4wZCZ/sP8wqaffjGmdTLRSHTJJOQ94Pk2j4JIkC +HAQQAQIABgUCVt8E4AAKCRA1LGcgseO5K1a5EACxfImBM6NseAkHwyiyf0Lpfzzl +J5S8FGPh8yzY7xAr77DFsCTRcSahHPxCjv7NnF5bgrg0+GtM6nnPTzSKBtmzqolZ +blt31822DZwx/TQktNth0/7aiTa9LtUwEzMsBrXyK6fO/LAxjhs6DxZTAvaeq3Lq +T5Uv1iRdUXQkwKsoq3zV3FDGWSM9cBzU6w2V/sjFPNx7sspuntuTAz9dq7RBMCoz +umokZq9KRDK4HZYY3pOpCAekPnFbwGL8145dpf7cs36h2iBeVyhrDx+sn8gt7pN7 +C903NwKhBHFyPNBap8Inup9mpDY5RI8upcNLPx7pwed4bbVzT36nB7iD9QrhNliP +dUWR3mdCHLNWI4LYP4OQjZSPExELcwp0gjy5Ll6LRF8YArWDvVz+eiQ0tq32XRAS +l7Ze+AMY8iAe1yanm0xpawx7LYOYhGmLViBGJovZDHRatpe/t18tzDGp+tSa7zPM +dSOAKU1EoxaK2VBBE88ra0B52yyFtGcK5/wEB8hcHDbA2KBEB3sZVtyLLpuxq9p/ +MZDRBjU/6WCX9BDxGDzAnuoG0k2UYM0Y1v/7Lcyo+ze5ztSJzNn+l4XTeaGF7mWg +zb/67vgLZKtMjSJ0cbqpQMdfoBepsNWQdKgtkboh/qTiM2maUVCDwXB4NC2B7ttu +12/aADcUIAXEqd+pnYkCHAQQAQgABgUCV1MZzQAKCRAJSwnQndU0ba+tD/4osfsj +IXOUfe4nuBh+ayQsetiEmfD42BWswSZXFeoUUXwdDlW8027NQnyipWMQ2iu/8LrC +r2eom41oJMkBycyeiR1MAMS6QC44+Tqlp5AjebW7LizZUXsdDOP/HxZ04bmx28Ur +nDUjgGq+yTJrd5iFV940wfS+mbN/+vtOKQRV0qfeUVmgGBBAwqCMbm/+Xtzo8krx +cRdBU58rMC3hNE01X8UbOF7nePUmfVtOZqiUKOrY5rkbt0oLxt5gmtmHd+EoIQyX +4MtqEx64t/U6D7PIMhKV8CfL+StGCpWaPdNSCvr49j8YyfJp2I1JkyjTNeGpHwlt +RYlccoIlET2aKFeW6PWCKTD8qIQKx8ESYPbxATd5qlHqKnLVrteX2dPzprRD+MCP +eZct6E77qAj0nZ0txpaThb2iTiW8lDsCwjyBQYWEKVGla0qyGoT5bnsgyM5ruJ8o +nQtJa6vlCno6ZPezWurLQaMjgfC+iw9+NKSEPXcaHiJB6YSb6ZR1Sn9L3atwJn9U +1Sob08PjXKHAi4VsxdCYitPL/p4fTMuKAxehAwy7ECvWthI5WhEXm38OJqxpAkgd +/XZdbZAY/y+ttxQONBfYBIGAuqQ3+LwWb1BiBPx78F+GJOgtwdbWFsFAg8349Jg4 +viYD5CkCfcLm0ufI+ATmwoxJhX1bNrq1WO4WwokCHAQQAQgABgUCV1MazQAKCRDA +D74tkhkniHHQD/9tVjXlnQVnURCd1tMb3Rvl1bqs2JiI7bXss87/TAEsPnKKh2hd +K6J4F3hdNcwoUkcwDjzVrrX+TPYQosXyP05tQf793CFK8P7J7PhisoDd0VYp4COc +Dy5O+IpCF2epuubKluIHtBz7Rajjv3HC5JyF/OYIS8KzwaWn3KeM/DQNJ/SAA9HV +aN3PbBq0hlfuMiiQkqQqwR9LVNe1b8eaYGY8GuKi9qwolXDLNaLJ8pPE9c14f3Mi +YMKrEwzvd7LTx+05WY5q4dxn5WVNECVbUPXmcJLkT/3QNohVc5uZcLNXMnar++8o +XmjtD0JqCfy6xd4aE3apNGxHsiupLi1xVMze6UFJelRJaDZhndqgD5c6vIkUqj82 +ENHKdjOcOD2By1xIY0ZvoO9RMYaNnctBMv9fGxUd1k35QBw0Zxf4Y65gXlTDTSfc +bliDByGFsLuBtiWE/kXrZ66VbDIOPpfkM5J2X5S8UNUczHyZFNYVpCFcsaG2Qo/W +HzOY9uqq/xbu0xuxjtk09yvkA3CnfZtBSqfDPM0ol4Dgri4NSHjG1xmfzK8GSHb5 +SQlEd28xe55U/zyTVXeBtJ+HFAX47OZpBuvWv1eMtYQXBUKXBwdARRZJr2Hjpxt0 +LEyu5g/nsuXhvq7sHFv+5qx+J6v2IR15u4AzrAqxh/HMePBoU25djeJvsIkCHAQQ +AQoABgUCVyN+cgAKCRCHVo8VYs1RMt35EACiSPe8RCMygvI188Z++dzZ+aBxSEcR +DxxiAWFP5/6EaqiXhez07Jacswq8TSkng3FIW7MiCzIdIxeCYtgllEemqIpkVAXX +0R6fAda+QgniMZ4iPj36WWXVvUAIASuz0dmFjsQje1cDT/27oJordh/BLsdfvjex +IX1RzVjVjTmgc7CyO7xLJwrIMn9Io3E1TQKn2xVueG2jMOk2xjjwGetbuD4vHAyD +5FfSIQLbYosl+ZnMuOquPTgV0Zz1lvlP3UfW6VpTKJHAGFaEUIEMshg24fSdUb/O +ofYIhHVRjtdHZNKpcZ66WgGTqGKxgsIy7guOzcSnHSMQr2fsbbl0nQkwArkG0u6Z +k18+GEByIw7ASoxpCFNOTIhoRr3FgJjjmf23VBliWpN9lkyf9r6bbmLZm4v9Sv4z +GMupz9T0SMV5gSqzBMdtwqzY1Yd191fqrcsS3OokTgGzN4tJTbMDgvB/KnL0MUei +u3ZOARas39ncVmnT2sbF2ZkCtOeRDqIjdCqisHLTCVJMW6kLQFUcVIH+VnW8q39H +FPNWBC1+NwBZs9yTAuHwfud3IdBsCSqYtaSUPaiaD0lbyPt2LC5PsohHdfaXqLN0 +WMEihInAGy83jTc57GlhW9pDYXcqFzYsvVy6/eVDBggA1uAh9PbZPVOFxuJJEebK +i0/mZw8BXbMf0okBHAQQAQgABgUCV4EergAKCRC3i5CPI0MPgIO3CACy30F46cgB +5zNX6M1IFOZeudu2K8NXBBGegJ2Wmav0NUdIqLBhA0tzg4eeomGoxrFUAch/FuVs +wHmu/4odYC+VDSDpnVt4a8EbvF13K12sydEwnabMBFHcVpx7yUp+qXZ/5ZXas+9N +dvtnGUm46btqG3onNPjAFDH+HNsuMtdK7NVOUbvE/sDUofdjOi+5t1A4bX2H9QsI +RoiuIBsmVA6hvNxcARMIvtzWA6jxoBlwugyDWKMXui8jUXFDETFdFYxN+gagmgNK +Gru6cT42zccplumrmnbXW33Ky59uxhl9qMd1oqn3JPtl9H+HEhwHTnwcQNxEgNLb +3sCb6Tx1jwgziQIcBBABAgAGBQJX1kl1AAoJEAI8BeLJwGjwtBgP/1xqsXX7+rbD +BV9M1Cyiy5ZqS/5pn0jfjd/4V7KxZS9vQzYq26P3aByA7+LVMUeiJoLaNr/JeB1M +rEdWcVPFLNIOa3sECmx9+rjJbTR55DjszRtGBKFVxTV5aBDJ7VwZv9WzcoywffF1 +32uAh9V4j0qSTWcqnLmD/TgsNE8JkT5IVm2bLOGyjHdrHONqn6lZaQE77fQXyT8O +GOU5XVZC0PXNrc78WPZIq5w3IpzZgHZhOlNti+mbRwVgYXy3TGIuBvZSKlBm0Sw6 +kO7ytmg78HyqAe3YElm+rTUF8phvAEte9X6rfQoLb2B687i0Z4cHOnpGyGKQSyZS +ycJJK0fdHABAIvUwT1q3ZEWXjS0P8Ub5ymGXf0CLoFQRL9Sg8BTbFh5kP+GLFhHW +od3BnCXWySL2LTAnK3k+/NHg44MRmUaNBJCkBUxINNSs2Scl24mxnTdr0hjPvv2c +hD7po1uauGb4t+l+odXZ+ZfLW5HFN4hd83Zus8kMO6cFuzB1rGm3hHU+y8J/ZHz9 +8DO6cpvHRxFUNDJABoXQ6WsfPzRU//31Ac9hDOsTi3g1S+kUJ7WAnxD2xD8lVfge +Kcd/ePK8year6Y5JZwF3RyfOvm0XRj+wVtnqGXA2R6ngbP3Lu6RCnCqfld1LROQr +oAjJ0/bqtDFp7Sfx/LrQ5LLsu4qFqngWiQIcBBABCAAGBQJXaWDLAAoJEIs9hnyC +PnphizIQAKuxCR0cmpOc3mnJzjIdsle+EZtc6z0cUbR3ItvR0vyecfUwOi2vXQuQ +I7PKqxQOeE7REuYC5rRZ/AKEAPEoN7R2B1s8wlBp4J5dml6cBMy47hO+vx/yxBFq +kJ/4ExDDiUX1PBzmuMk6h+uD/YjXIRrF5V005IruRFH5NS67vFWCCszvhJTmHKM4 +nEfup7diRS9U4ISvaKmoagOnOSXjANTN96LDrEPXgDVxO+CBxh2vtkmXZc8+Htfu +jQgObL72OpSgXiSwIovZg0kM670mUZdM3GZJFGFAYWQr7iDOMbqIIH/EvzaL/xzT +BF2JoOlO2Gy4emysgKT115W9I3nWGWng5qlGnCeWYhe+CexK7qAVdpZrq5MOubAL +YzFZYVK5HUYYWBxz15U13Q3r7on/pQywHnfETJkRLeRr1V+AxBzv2HW9jvdTG5+q +HekzQKygjUpl2oeHd1noRcbO1e6HPRNZMWErlag2+Laxjmr3IKJW6mR3Sh49TOpF +mlw+OoYq8G7yVhihEnJjMp970f5d8ytNgJAaJJDTzLrsE3EEfpl+lJz0EThm+JPz +hhioZb5mFoS3A1sP2uJYrkI6oTO8bkuqw3kv+1OjXqf4iK7KFWlCkpWwCGjluicq +RYAiILouCkEBerayuoyZ/vJEDyTnQzHFr8Wj3w9OMimwQ2X5e4XwiQIzBBABCAAd +FiEEa0msutz2vRyiBmerzVT849lkvvsFAlki8Z0ACgkQzVT849lkvvtCMw//Yvv2 +ZRDpTklCJ+A0+xcv2nrrSEJKO1PWGDKTwZRAh2vl0IG93ra14WzgLXMgfFbWMrM0 +Ekt7AVpOJVlnu8t8X93GHL2OgczSDr4Ivqdeqf7edR7B4EXDwS4HX02i05UJoZm9 +L+CiFghM0vNPzUzleDON7CoJQ/+DJQuJ/UOwxbsX0KgFYL+bqP3BoA444JFEJlLV +gTJ7zYa0lJUODI2XeKt/Gb+zN2aPIgMSt8Zgb2ALzoZqbLiJrn/xL0yzvYnKD8bj +AW/a674X+cw/Tx+5sSjQnskz4I1pakYtGBO1KDvqolUDOhh+pU/b5jd+SNFumjA7 +RRYH3lClEZa5iLe4JXTLXkueEjp9gCWuFAxkS3X8MlkQF7HqK6fJZDBorzYKIVmq +gQHNjhZa4KWrKbuSKHf8cx88MCVhMQChOYwVR2g+elYiJcT7DEEpUMtR1jkUF0jP +gOHqHpuB9ELaA2J/6d/C/zO4Xff34sc84sXdg7Pbh/yfqiRkr07vcLiiTvCZrXja +J7/7Ga64W2w1be29gDy5UQvuVPzK9LZVl6Xuz2d/FSn8ZovPN6rpKNqyGXhuhsSY +8qUZG9zXGkJKA/VaX98SzIcHXSEhLQi/mxVCtJny+TrMtsJZoNCNhwJwjtlK3FlG +cN59khbPw3w+3nqS6Mw/ee0xaaapJK/dZS+DiF60IEJhcnJ5IEEuIFdhcnNhdyA8 +YmFycnlAd29vei5vcmc+iEYEEBECAAYFAkw85esACgkQjCTRYI8GidS72gCgiegl +ZuNDcBgO5Itv1FSQF4HaR7AAoJtNgTWQ9dWaQ9m/HQJ7+wwvP7WPiEYEEBECAAYF +AkyzexIACgkQVVuXXpU7hpPsxgCgmYebMqdApSpVApYAlm+hFEbVDiQAn2jI0blO +NUm0pnmhP+VxhHQXegAjiEYEEBECAAYFAkzV7V8ACgkQHajaM93NaGojSQCfbvMe +kKVECfc2nHv8eZtZt7CjtKoAnj29U0Z1HCWclypDJIAmDHZ0c9AYiF4EEBEIAAYF +AktXYt0ACgkQ+u8Sk23T4+zrrQD9GlYUFXi5Z9ttQHLxKhgs8r33N5HDsucXfN/T +IKSPVeQA/jnS7sx3VwJkzH9P/uqwaQGyhNAlqCAjeAthM+HD7912iQEcBBABAgAG +BQJN0WUoAAoJEKax8/DmtfWj9K0H/2au7cEQ5NZPKEkShozXarpRRl0idu9/p5RR +nYaYIcmghO7fZs0C3tRARqgnV8r+IeUXyL2ysz8EI4glwEMeh/9zit1suuiPf5CF +yu00QlvvuEaudkZ8cV4Vu8Lw28IlbkKQ5aSQcgnqXS1IPPTlB6ON2oRmbRDvbZol +vLoPuDcpz4CmchKNfF8b6aisIj/QZ4nw5Zt0tCROwAIkOKkUvR2Z66aR0xoSlnT9 +/M64rqkynnRHk+/UM7z9sfI9QiNERq+RWH9dmrMX9nlg4R3SnCJO3KJ0KELure7C +U2/LznxJ29PDdKK5cbckdoMWV2JLsCyfbsQI7kUv7iWnwRn5gJGJAhwEEAECAAYF +Ak3M6ukACgkQuN+3G1/svZK6Zg/8Cj5Ph4uQnMh3pOtqhFM1J2UXSJBg0TxmJikq +txqGSsjsM79mQuU6yzqaxvXLCQyAVvID8kNZQY72gCkoXVxjoaxV+6BT9TCgTCd5 +Um0MRxozRyrvZ5RbKw9LwCHzdyCV4Moncuduc1Pn7+WxqAh2cXkilQoSXsoey9uk +cSCukuJ77KYe/bAmXGygUaozLbRiJ5qd3pHupkTxm1GnIw+c4bakoXrP2eQ49SR/ +FeKJYDfYI/lpijDF+3acdeY9flQJ8YduVze+6ZdFygjmeUXFddMUxm1PWxN1C4rp +SCElHktkDmq9U3lfyeGzg/gNgaKXqOZq11GhY446fXZUoiAw4SA5N127B44zxiyI +Xo4329owS7B+mFTHVy9yvZfSfSFUmWSJTI9ZKYuvHf9hGUOHCGufj48srgCoGAtl +J3rMttToM35iwBfSmLYysuiQwLvUn58+Or95nnlf5kI12OwTgA5K3oLRSNPopjW4 +HGbp9UWJzhWx8rkvFR+eLYqQOO+RngZP3zSwUVj7QnRGDSNF7nB6V+24TkySk1Pr +Scp3tfsX3sMhHfVpzArAA4e3LH8hc3hcWXqyOHTokk4HGAzxpHVmqrPpcdZvGP4p +iohmds23+zAqa1oJ0NzCStzGVR/EmAkpHoXcaUGo7EBvDpmd70E70BiuFjviUyGV +nTq6+JOJAhwEEAECAAYFAk3M8N0ACgkQ4ZcBJna5tzll0w//VBc11E4wjfx+azaD +oYzJ0ETiRP/NfCxz99glHon4jbfZ4KEGa6++xclCAyjgw3a17wbaLtra82dsu1Dq +bNQmWn5wRQFvUBCNU7mAmsh+1z6TDEFYK93oloAp/Pwtcvs3gu7MORbLwZztd9ZF +SG5EOHs5YJuXgLrQ89Ht3bYkEmWewq4cd0MR1r0dpmUBBXXt8u0MftQlN8LMWBAy +lQ1eWszQDobycjoj0z3fuo5kOtTuj4ohh0fT/07i0Q6inaq2XGYXqUxNbU821NXY +W7WY6k/C1jsajGitCvvNnrm5dK6xrx3bRuajvriq1x/5wUqvTguY9wifQfy/MzkM +bJiWwG81+qOj8p4KVxqwQIwo6ia02KNZXnOTTJQbgwjTwzoaa/CXFYQGA6PR/6DT +65EYdN1N4Cc5+WB+vC3BloOrXLqCZ+1EL9y5RBjsUSH9lsyMZljMugAT/mQ/9eoT +6Z9d/xsIDm8ESmnms9zyJ/enPk0fi7+EjXrt8izBlLygXp4VTS5rkuhoNYSToLoi ++hG0vq2VqtE7Jbl4YuQ+OnTZf4P0d6a63Lxlu5qPWpNEWgoHTlvhw+AbLl+RXH8n +dPKEUKlklkPKwk5QoLtvIDArYxFKGyLXzAmQ7ahopCykm2zP7suoePvh6/ySMbxl +JRM3zRK0pLFeVF4yFJLcBzcF9AmJAhwEEAECAAYFAk3NMikACgkQhlYfRSGA/P6C +Hw/+PMaO2Yd/EMCJvdwTt6W1soJ6hhWLvqUUZhhKBkiIggr9oBF4e5aILGTFsgaH +OmsZLtldSyFKwLvypGPaps5Rdu8Jz2FrNZhoq8ACn0OI2ag58y2dwz1t5HaP0Z5/ +FIY93oBQlKdzP3Aaad7NUqtE7PBsSJRilz4wpHCxLcQ335Z+y/kjqWtUd3SM/rfb +oW/fh9WkUxckCxmi/jPxV/Bp6fqmH2iozMMpqe0zqPFbopBjAe1B8G7xGl5kwXVS +Z5bxSOR1+L/KdnQJgzOWYl+gP466eQkdW5gWrezGn+YHHGLeN3yi4Pvc29AvY1oi +1l6+NxvGlF7qLlWkEv/6c8ceXwtHQARdqP5kscsAt23YOrIl/BB3ZsrBx2rmE3sR +P19Pg0sz3w9yqkeeuCNz0zsvvj8+7rrCagiPqrCmluL0uu3n/ql1zHAuvyEJ8Rze +zO6c9hPcWBc1KFTOu60mbJWIK1Qkmbs4g/E6pU/UY7/Po05/tJsJQVRdB6eagyU4 +Orxms4e0hHR4lcQJgIwe0POCHdg/OvnBXV+wvpijSrb/CKxeffSk3/OJHUJpOHVZ +oxp6ZHBMfk7VKFomysGkJLIgQirbfcJ/3p3NTEkq/cZznaHtyUxub/WQ6H9Qip11 +443wCel3HNP+uncfYXZViOgC/2aoHv5iuY9dK8co5A2Lb5iJAhwEEAECAAYFAk3N +XXwACgkQRdd+njDLGxFLaw/9EJj15yBuxnMKLuvsgpdQIjT7hRgJmMppSq6NI1lw +heHIDgQPKHIkBfit7xFKnZtu0IOPxzLKMSt1f1L0US5nnvbMZPmd2zgMqx1gIwcT +O2sTv5uI5DFuqsfINP+RLfBUZiBlQ1zMgudU0q2lcXVoxF9IxdMnhIqUY9Hklvp1 +j1NpInAGQVAE+7hyC1kRQlKv4sfx6KeWHVZOTqoesU8Mjq8yl7bmrRRU50TVy5fT +HF74fUz/nl/dikFn5byuiCXeZs5A8BwLledBGmzcCLZz4/0+vlXYNVjWyK3o5DUC +ElixqqIiHnj1LhPGrjj8TSPLlNwe/jZv1TO03ac1uTeO7R2tfCaj4AM8bZ8FYYBr +igQEqWHTopmemAXwTcxILLSprGyXtuLV2dwDupJMF7Bfqivne/VDbLKqEMtZ1mqT +wxmhKGBxS0VkXxFepgpxlLmyM1uVJlgSvecr2DctyE4g0aggrHW1oO7CwoTE6o0O ++cmwvhNEPdWlkbIg9ZNx1nRbz8uAlxNtz3e2mmI5S5nRy/vzBUl5HPNoNeejB6QR +fGfYyoLmOfFvQThjcqGjDpsMwjwx6ZIkkmGy6jqLB3w0ENf9H1QFuT0ktRmuza0q +fGPcswDEvHBrZ2ubTH8kjFpoub/j33ZLrWkh94w4sCi06riSKSKSfJjjZbO6Hs10 +OH2JAhwEEAECAAYFAk3O/wEACgkQYAQmoRj1+87nvQ/7BTAJ9EYYZ8h8OYB6OqEj +BIXODNv/ca4h5easDepcOSg2acjUZJeQI1gjQEgGxTGxHmHzTEEyOontcQgJuEyN +um5yaFGpEuRM9tH2fJ0e4j6nQOKDvlneQV+IXxc7evjOQoASEhG2O7r+KT4T8rdS +Sha7soUSt53HucIWN+4TdFtVotoUlcej/Bfnk1b1p+u/6zBK7FmTb7M6WQHrlA9u +P1g0Af8hZxkogYtq+ENC2khWrDGuZxtsXOuk5oOZoZ+qttqsokvSOnu+AUxk2Ake +cyQzAa6i6tD3Jag8I7R5sJ0wcLSKQZTg8Zuh3r+WV9zDQy8zgrirWOPOMKHeRP30 +SBvV0+oVfaK3bSlGV/LrazJm+IeHrYbxDecxdZoi+TSyUkjWXwJzkDnzRSfEw0Ee +HcR9tSWMMUCJhXFpEgNBIK+e1x+VrhF6HPFg/YVZceQFo5P1PaL/NKlQe+VoJkew +HlzzL3LuT9lPSIQ8e2FeanMM+Tw4125JTkG2OuSeGoWoD+Nr4AamGeVLN2a+AS1z +uald/rr2z1IMiVo7evgvCTAiMkLZxn3vD/j4r4BMB9SQEVSGV8PKp+NgVZIOMtrG +H+2sZC2xnOjNxEUgsUJYP2+aYTwcrJfMyxrU/nPmrINX1s0kZYcQFNnhVL9RutGZ +g0bnM0vyigl4ypAT/JZnKEuJAhwEEAECAAYFAk3RdQAACgkQxjiXTWR5LWdzsQ/7 +BcJa0Rxh9KZrcokMNcGxYWo8q2qUqRXMObBXYUI/HS7VGLoRe0imoLkukjICi3Pg ++bZNqmEi0dsMGkhpe6QvO9YCEIm0k4YU0Joyf3hxEPeCLgC/L7A8hNNPhliIYknq +rjAg5ifD53T6i6uGUT7MAXpc7KAt0PUTq7HbIK7RvyOXfyAmh/07J2NbtJCIbCNw +0JV8r73uuxPdT6fFov2G+Az9Rfs3DbYBkCb5eIqe3vDsnwAuvSqQsE2W2Qe6j09+ +Gvv1FThNds70GYZTu5VTgjV8fIkHCiVTMAJ9hoeqmTbe2uELjr5Seg5iH2D25I6m +s06TbvahTQjCQBmt2X2mni4d5eTFuM6qzhlbg5bQi4bHImjLV8DtVvWSvWmDkA3f +lj5BMV7RVxCEhpT0GMXywr4Pd22wQNRC8PqVPsxJa1qS635LOSswR3l3QhVY/0xk +ByFyZUHlUfFF5MDkFGcjP6fld4m3mNWbBleQk8SOvOaTI9I6eBnow+q68fkl6Jm0 +Cm8AP8ttGAAxXx5H/jvWUmYjp4s5NQ5C4PlfN4JLwA5ngt7mxP2fA9ZSA+234ivN +ewPG9svy0h8VIS8Gm1iS0qoCuGysHZ45yIZCwiJ3SpvPDoAS457jvZZA65uXxfqQ +MEyBKukxdLHbhnC4Zn8vGDxtqtJhqGCBi+5VDGXWNf6JAhwEEAECAAYFAk3R5p0A +CgkQwSYz4e4BjJNAFg/9HMOiryBXX++P+i6vzXONybRJeZHV/AOZIG/OqHzyTYwI +cNWaMv/gNuF+fzsbNGlrhSkJVZMckNmRogafr2liTnCwTYEOHh9yH40a4hB3hYMQ +trnrV3KH9H0naWsus13m4GngSbAg3qacZYiDgauui6uk9gL59mNPi2zyB0gH5dkK +itjsnU/owVNtI4uplixe1O2TfjrwUkHol0deRp4sJ3r49ASTfY42S3SgcrePPks3 +g7OxxQK/0dtP9XvHvK6lhL9hGznvkaqw5CpJNvdbLDpgmWAJwWGkgtdCeJ6LudDj +ZRs8lGEKyuj8Id9Eyd06PwhjtRVnSa7qetBJSzmT1LWOEo49m1+76K0NlUsdsTQ0 +sURa0oZOAQPw/hX942wm5Y1+LcO417kWBYAK4fdHGYq67TUUsWKewJWWEdq3yvac +dBR/irSM4H+meD8/AmCo+J9G8bKxrZQDJlckE8TJ3Tau3I1FVBYm1QFMzp8Z1t36 +6TI/Crvf4c9SA0H6Mv1nFUYBw64pQmJ4i8j8VTY5il+fKbECNwak0QpKCnoMywF9 +zI4f3hcmk2ZGbkr6oXcr5G9wjz7V1kuw3PtmNsQWkYgHJjnQpzX1TNhMe690pffp +d9/Lds7didTTpIUzEemk3X6DxbqUGfs1q6dP0csI6Gb6CCDxcuXQN7UD1PxDT16J +AhwEEAECAAYFAk3UEKcACgkQ41LVxRxQQdToZhAAmtKbk0cu6rsfCvfxs1eKrf7d +gOJ07mwSzUJG1o3Jtx2PF6C4ppgSYIK/ewxUjMOp1sYtH6gacpq0Cq4K6/1qCYxT +wdTDrzZYmTxZXKPd4ARK3ik99NCqiR59kjy1BAyIoUUzv0jxucAyGgey7BoUlgjn +XdHj/XccM9mOYkU0pYUZlIaq524BO5yepfQtg3J4U21Vxdt2AuSs95m1WkYzOLy6 +pLMlQM7tZ8ULqF7kPafdmjq3NY/uJCrqG/zWjObwMYoyKro6B+j1a9n9SYWHKnBG +tOVbJtb2jY8NdoxJIbMO2UAbt4Ic6xyesSqHAhd9I5eG9fhyzt3yIV0xoYpOnApO +C/HQf3xy0TnR91FepNOhP9WDWGSLHGrbi2ShDRz4QuMK067C360obJO9FD8/iv+Q +Pijm01d+198Ulc6mt++yJ0am8g76FnsXBoGTSpU1NqEliLqbc5xoTi9sEuTFJbML +qN8n6rGod7BBk0OV5NwWKWOQMJVZkMWwIsj/OANyG9V0ThaHL0cNQzBZ8tU4SRg+ +3ao/1fE4ihh8NfTpsc1M1ZDlL/YdMsYyk+RWtJ9TkC1luaPqUnFHtl7TQu38EtF9 +DQ/DVUZPsJHYFZI1PgpGsmwBsDNvEbS440LWzu+6iB2DLSBGx5LWOZ8mCqAxNU9d +m7VmdNHH+1HO6HPtEZCJAhwEEAEIAAYFAkzK1fIACgkQnDFQPG2GY5b3Hg//V2ia +0BCWR7tEPCzGPfaNgLRoSb39VPbWy0/tQFbWtx7AHkQ4UO7QjXwg/oJb4Pl5n/Z3 +XlOmAUR/x8cMEudGGPavTeb67qKCAe8HkSSZWcvXYvuVmpbbG3BLrTy9EopP6ZjK +k61EdWTTZA0VO23TiNXjRY17BP8hI+WFunpopXcHP/y3WW6gbESScWr8YLgDuK4S +bh9z9H1PgHlIqUnN81SLc1zml/uUL/xqhJO/aRvAVIL1XVBkpxgkoUdUgRZjXFXE +YEKlQMXyVT9ca1fj9xAhWu1PsowdbJXK6SG3yCgitNEIs2JT+TdfUNpd1CHnz9IY +cVomsiYUK53Gevfy6SWXuD+0Ml56w7F3yNs1Y+m3XzsM2RIMPwh3VFh0u3XSOY5F +cc4Qv9a+XajtvqtUcO7VK8/Tbu0utBzmMU/VAL3y8F00Ak2SeyxwdfQQrmmMffQc +5Nn3lanlKl0vTq2xMNB0HOQwUE7lueGi9Og7GJR4dFXhzYDHFUoMv3uRVW9MLjFU +N0xnez1eZ4djfJD7vS9Hawi9JcLH+b39oRaqsnMX+Jia/nuGyJsa0WBp6B6zIqwr +P919WzF24FCFPMjANRpN12dwePKwXX+Y2tpOowED6UcuLArY1GOsWdmAdh5noURY +Rq+9TxHyT6dMCQen+zzDa/8Dq+TU2r9yQZN0fGOJAhwEEAEIAAYFAk3NKS8ACgkQ +GLP1D+WSPBj8vQ/+M9KwUbF21DQxYlcXtf8dtJQH2fRNOoQn3tfWKN1jFpyV/OF3 +wTPbTchKiMQQGdQgxS8xziBzwkDbot3PyScUakep1iwCu3ZGvt5SVABwCqSD8lAk +0KVmv3U7eEI71BWSMsdPSdXS2GVIwS1sCjUjNUjEoqZuiWkhp+xW/h2aJwdwr65S +ehMTUe3PjEcLYdg/ilf7+bibWFxQ5u5rKL+2sZveXU7rg14VhQYH9nubiW3Lsfe/ +RPMkkIUin/ImNikO3Fr2TvlUocqudB+3wGOBaz0KBGFznF5Gcqy40T3icOMArCMn +I7oGBmcg8Ks8k2APBdxPLBol7ZDJ4KpEzZTbCSjUcfIPnMKAsTNchYGUzoBiViyq +tEDNF/qQ3GkKHjfmRo3Tg9MDcciK0tTkbQcokjC1O+gm2V6Q6vQbr8DavaFqAoR6 +sjGT3L1KCaW0p/p24/6JOGbnhhzMMbexW93Z4YxtSawPEwLr0spuQTr/6yItVuFC +8ksviLpgWIgYi/mkGhFukANnp1B3m6Py3ryjvIsJBYb+BDiJX6Nhe78xm84GIAJ6 +v5SFoIRdKI0U/KkDTRgLzepf2b8suRNs7OLVwiAfJPrmNCpqcUM9VoL9D+d/TDl3 +Jrz885uBF+IqpdEHzoV5pqm+cc/zJAhoGxeVLKSO+pKjLDQ09FJcGw9plKWJAhwE +EAEKAAYFAk6yvRkACgkQlzJd2Pn91QZYkw//erqEK6Nui2VorFfMgpu4GPk4UAV3 +xtk1GlabIJXB28vEyZ45FP1ME9Mi9neJJVy07hBEwAdav0jrJp6vNSwPpW9/aZJP +VEv9r54uglB5rKuJwP/7/3ozSubPNQKsoLwqHBtiZLcYT1nBv0BHXohWA4J3VR8r +9YbL/47LPd+xJozl0r/VL64/rW4fjN9eqSq3A0WNe65QEP7IEtx3G5Tx0HeLkhRh +qDoqkZQp/4g6l7ZNgl+5H5m3CH4m+Vc9NsXa+YoeXFFu5qovaiUckZLNC+O4B6VV +c1ZkCOjGeE6XVKmH4OxTg/Ixqu+6pahcIjAI7GCTMx77O8wVW91e8Oyw8xhfXqZr +0Vbk+2vV9/wS60A22ZYthJjYt2OF6d1Qcv02wNeLNy/tK+9Dc2lpmIjVX0VE3/9O +/nJwnZ+hX+ARJLMwocpi0tJnQXq47LP93CH2gC8bU8aIGpPHrKNsiAAh1h4pFGPQ +N0PvQULmZtGronPyDLxUX7wKsNZsve0aNNulmi3X0W4znsi5usw0ES+blKsD1iEj ++wAOPFyL8zy8WlWusY91B+yq7QnywdQkduyFRYWei8ufVMV2qaCTKUQ7bmr47f3v +OXZ2TMoA+XMFhbCSS3v2ujEJ1ZeT06W27U0Fhy25QmsPhEJ9KtGVdjaHNwjQGT+b +gRFpQ5I/dMre24eJAiAEEAECAAoFAlFHtUwDBQF4AAoJEBJfXGff6UCE3yAP+wZM +8LeijIKMMnNIY/e+t9pjW+WCtaFIyR4t0gBnG0MNTxLkoF6jfWX8JjiWSYPcsDfl ++XyLvA90XzmN6hZq2lj8R8Y8CYDdMAS7PLy/PbM/89kAjAUm7lT/hE30yMUMmr9J +NhRhsr+YoV16Kwmu2m80c/AJQ1mwWqMJAC4+snXjmx71D1ZUWXGyrwVxCJZ3kFCk +tdJnwklzjleqCx4zD6CvXFK0iTTk2CGiKnaly4Lv9KkebipG8vKAV3LpmQu2l8mM +J2+gVuwj2USdqec5mT390tnWOGh4hkLt0sDymXa+j6B8GD8JjVzW9v3m5LAZkkPl +l8s1AY7fLlSwJ/7n8kgcgkgqdcm3q2BvsozPaQRcSe4wkmtR/Nm0dhbR2afMoOxx +TT03umL6uZPEH2JtgkqshH9AuDwwzaVv7bYne77Pe1CetdaCB7Z/Gk4dvQ1rJ7fi +9wRmfgCI5XM8svptKgOlfGgD2asM07P8uRfMNoRTk2z7lksJf7zMZ7e4LVauY0Tq +EZ3ucxJ2eUkWSQcvFPSwy2ONV3qYwS85WeiRTWqMELRu04rxUOs7pA4OM6TSjYcO +n3AqQDj91+lHPbgOJjNbucebpWdO5Pm+WY+PVxrHVxbZZ5cVZQp1sD9FIf0/SBEG +95nkvERlaBQZgEked2Gz7C9qJ2KIQRqQT48SxVPaiQI3BBMBCAAhBQJKC3mfAhsD +BQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEBJutWOnSwa/TfsP/3mKycL6uayD +h5Y4QhUjKp2dcjUj+GhpzZSz0TfRZ330efjzWYbi5s51Gp+VoZ99vPijiRtow5sg +nfmTBSV0WYKJZhv9SR+1eUvAe5lJmebWPEAdLh4HzUMO6hSVgTdbcjpvYOKEC4IX +fv8jkRJlF7536UEiGXnEkJLDyO4KhZ7CfWpLBRcG/MnOW8jNxo/Vv62MEZWk3YK1 +7Rc13xsOSM+eux6taCMsx262lQcHjUPkZYcR4DpTeB+GDrvVkK1rPsAHXQZv+IBT +qsllOSQBI6bxXcPZq9Gsxlu6FjoJaPnTmqud6GGjCEd57J1kcHblbZGpvlJ5Ae93 +0BigGSDFZcchJEpMsYnG4oxIJFXeDWXIrAZKfSFTqkxWjTeU1XhTknzw09tLgjSG +419c4aOD1hJzM19B1xdqzd24l3Kb6NHIAL+yN4H2vOMAzgqs97g1Nnrkhbc63qT8 +JikWjaz+kBdO2etr9RIglBYLn9amXtzQ+GAs9cKA/6wBqyMzjSocAgXwpMGGkH5c +JyNkEIEqgwDQQK04JHfJLMIDdnjbHbjUGJS73B7pcMEqtLxCfElTxZi+OXc+QsLc +b2M/bhk6HY/o3c8ovkPJpxZnwU2iX9fSsYUtpT4OMx1kSW7/8IT4VmwcLpDWs/N2 +LnoLLH1Df8pVg1DbN75WzkD75KUArLQwiEYEEBECAAYFAlFHfh8ACgkQmc3qnaQT +WziDHgCdGtDdekD94WZgIqWryGbC4RW99FQAn1tJAvGPvKEFjMG72lRXE8x0XPgh +iEYEEBEIAAYFAk+tJLUACgkQ9t0zAhD6TNE21wCffNfDK27ZgPFWS/h2t5U14NuH +yc8AnAhL6AkM4h93QNId0k3cP3YiXKxmiEwEExECAAwFAlNVvq4FgweGH4AACgkQ +vMseJzFyYtKVegCcD4cGDgWuqE8amI/v1YahoHZbPtMAnRvjD4EmJqsf6B01/CrQ +UkR3tuj+iQIcBBABAgAGBQJTSY9+AAoJEATDZ8IYrdT/jpgQAI6uSn0XZJiKi937 +5cyUHXir6muZOysfyjL7iEyWqrcaocfJR+vI3qWxiWLhyEpFYz04qRXmYSJFwRSx +KMK8uSzZPgEE6qZU0eCbRWeOcfuaG/M5l0MKBEaAUVgZ+A/QTSS6Z1mZN+JhvvHT +iteY85OpAiCjLMvLOdZZQBj8G3bgaKf92EhlcpvUy/DO77+Mr6j9t+1UXoNoEzom +IykPQGxPhUrOkWJbCxCP/I2+RYw28PjIQ/MHSSM4rzlseNeEkdzGHdzaoUwG3xgx +ezI+uQXI3IMY9VdkZKHsoK1tgbm8WBQGGSkSlnCtYdsrWQMo/8YtjaYJM+GBq8S0 +Tw4KADEDCgWAIKKnYhxzTSgRiUF7qxsPBcCXEMapSOF86cmr1o6ifZO3Mm6UPKuj ++cvCU/xKqkn1gcIc2EKDZhd/iJuZFOSQQAvYfHXP7Iko7XYBSMscuvv0rXdVaEM1 +yh1XbPm8mekAtlEvOyibGsq7b4AeqwaqPU2fyWEsQeVhYul7ZMsLEO7QiLy04DMH +DKWxOiBNOiBBl6X8igOjW3oKN8+fxXY9Gg46HPpYrbmQ9juHU3/Heb3HPCEtoKrg ++AbgIjw+NBlEEc3nJQH5cukAyRQrJ8uR+69pFmkI08gYJcLqdqu0AFf4u169lYRE +5jUxchIoBKYUBmBzTgE7r9WntvGFiQIcBBABAgAGBQJTTZnTAAoJEC6na5wrRm2d +mxoQAKtUvQyHvh/hHa+onKKYzRaBgZiJi0MHqcnKlJLZUICUsh+j8lt9jdYOZRFJ +yca8902sb2vUNMq9MvhDISSdp/8jEsR/Ism4Vj1bYZjbl2JLTJrwiKCaKWsSKGcs +PR1xIM9KbBnIZTEbvbjv/6Xza2Uf21wMjzxDa6HtOB8sU6krpMQAlOai3uvqetl4 +NcpjJe8NjRe8PwQN5Vp8TFgX2VQMtdyTUk8tBzsfDlQV7cPv3dqJiE/klBvYI+nW +dN3qztg0bT5BKF/qU2rUqm4n4nhF+zYFj1p8t6QG8AxrNfC5nU0fQvPsYwnlLrig +myCj6d1dfoyg4UL8rkAcML5eOSkwmlgkCXD1beu3acMHsJTHyzYWjyueDKTTerlu +0DhLTxbidLwH7BATtLF8VFgTVpWYZsEnWoMOkWS8SztMd7gg7D0O3o1QmslTSfnV +QmuLR3mysdiU/wHefTtRQJniQI82AyYC7saMT44LoMcOQm45Cj5pFYHk5z3nLKMs +U8TrqyEldntusY/EHvoN6ymCH+4XdpQ7Xv17zJOWWf5xWZh5/olDKN/QanHw/rTC +H0oU2Q33gLLsF9JpUOQSWsxce0aC4k6k7sZYzdvsNw3c5gmWBJ9yHFWzHb6uPcTn +pAfh8MtUUYrCKYnyUJpo6kP9Sm9jfHjRIY0Iz36u/O4iyyGtiQIcBBABAgAGBQJT ++8BKAAoJEGSVn+mDjfGcxOMP/Rf/hbBMHk2aXVxYDi/St1Wcb9NClGwfNMb+xjBH +0vFEmllGdpsJnnVlwujmN0SXTKPBjWEF862PXsE/aHuLpCqB6fuAKjjT433lBFAy +YjbC53hIPnkLA65A9/y/el0OSp+B68iEzeHT/941iiAQLFu3jv8HTGw5OkwraZiH +UdiqG7DPoYr+b/vW0eWOwc6FOM9wBlWFy6jkavTg2rdWvnk43W7UR8KMEXrqrPSG +AgPnWD7Fd+X0SdPa22zn6sYNAs8WtL99ae8oRdhI+V4Wfvr5Q4QPOku3tHmrWgrp +yp5OnF8QY6V75XwqkG+5OQEPxdlDeAFEoN13g4wALg+UjaqnDtehVKNbGx9FhzaG +Ik/S7ECUW7Mkj3+eyjAXH4csr0ATDrLQov8KoByX4mCGWdaa0cnVjYyng7qu4eqB +VeIKAgkv1RlVIsQZQei/+ptMLE2tfG3wRCT4bFFWZvANmeGljuaekaIIXur0eCfV +Ky7RBHawFZZiNwGxfdo/DhYzuLUX70Wh5EgDw9Ts796zsODsvrRtm5kN8uphj8mE +WbSsiT15yM2Dg+1w1XVbC/cPylP11zaKXm/2Yn/8pGvwPq3rwAW9HVR4PeQqRGKN +1xLnWo4QCOh7lXRIfuyjIwmfYwL7Sltrg9aZcFc2iug+SflALoil+pagwAQDPGRD +W7w/iQIcBBABCAAGBQJPrSRhAAoJEDk1h9l9hlALsCgQAKY8caUr0ZOpQC6HwLOp +ao4d0lrRH1SMhD2YMJRD/FW+HxwWkUnAIUSaFy1116EtlzHrN4KDvtmFHUt9plOm +Wdz48bkQzhB+oS3rj/xyNoEJjkllj83QsfJfi4HriUP5OahtswW+JznZrYb9fAf0 +LkaFwRY222Wjqc+3jxgo1cvbZLustrcum9QecSyGYCFP+1aCxyN1sslRW90LVfnV +rxkRL+kLENw5WRK6LIjrGaDeWphHa0/rELEaMr9Rl2Yaoh9iXI6JORyIPKKc7VO0 +nYUMg906W4Q2cSY7kWHP/rZ9j+xZG4qDCX5Yn61iwEGIOrmIvANcWRZvoyd05jCd +pRFsZnDtG9EtP3ynWxr5Pz+DWvdUaBPAR7vTEpqTU7k7s9e6p0+6biG/PzDUQBJB +BWD+D2XayDPx3aUmnWsD3KMDuSSZe1TqLMseJt7OTsiSKVZcF3qRGoD3Pc5R/J3V +1UhjzW2BR4vEQzSpYV3ptp4WiE4dyQ0rQ3I+p1obJxa7d7xp2yCjEa96zUAH0v1H +UjsVWBHOH/Q/YSE/ab6L6SCVuwDAM8F3Y03UdlzqjoCrSehRKtJrg/2CNOG7Gu1Z +I76vppcM+2eKRiaVmPA3QG8CvY7zo5tANiZ4pRKbubts6IUmovC7alOpvjOLC0YW +AimLSsT/h9B1+dCDxslvEQYZiQIcBBABCAAGBQJTWc2SAAoJEL5c9ofcWrfCfasQ +AJLj64P7TySbGV6DbzrJgUk/E718gETryTA3V79PmM6Sn9n6/J4cbtzvS3UYetHQ +eIfZ4Vyl2tt6mUBTZsR0WTeBOfURL6DGeaLmoZqS3aCBtnf4Cia2QpAOLrwy93AF +EIY9PDY2LOKoeAk0Wj/32QJEV+izKkrGyFhp+exqfn7lIYtz1ERS62mh8o+BK/3/ +5Tmkcl3gN+LUtkFzBRUoYHrQRNoMAT80/XNDFddSp93DmsgECpStNR4L69eoryav +CpMzCwua4b5mSGhsLAdWBIIw9aPfFUrvh6a7mWhq6BM5vI4zgG2hdcg3tm92Ggrr +fV0LbCBF6rl3bCXAYgVwU/oHXTsmk2+xR9fb+x+po6DUdawg33qRsZfuclBJacNP +55k93LFW+rJnaatpJqJpPcnc6FmOV6vU3eFWnIUDqXWm4VXzo37QW4xQHg2r5fwz +9enyEPNGozK+jgvhKGlkqOy1ZSg6mmAeVXU/1TYLUwMw7sawoMQDlJp5lHhJZQ66 +sh0xt6NO/1+5coO28pJuz/YkRiiVgk5eHbagvt1H9RqsSkpYyD11/62G+ba3IsEi +lRV5GGkWXlcXpQ3X2YnWSiM/HTugB0HRhABTMhxS0kw3Q06htC5G5hTVvimxRB9w +ZP4se7tCxoAZ9kJACSgF0eAeF3K4Rvi4FWqImbbeLp76iQIcBBABCAAGBQJUAQfz +AAoJEE+gSkySV37Eh9wP/1MPywsK01mRD7tU04YFpTwcLs9KJtdRtRerJDQegK21 +hNQ4mLFX9I9sVVUlazsWyH1NTqN3TaMEIsi23OAe9mtlwdOdk9u5MwPohl9u3rW9 +fYnebdWIPJmz35l/hwvWXhYWamjIOFRZL10SRfveKdIJFL+I2vyQglcPDz25lU0c +jOd+XWiR8Wte24sizqjFbM3n1fjBe8+ZofCTFdLO27M1g2YSsI1Tvv876nh5vz8o +R/f7NhM2RhYKATOplobgRE6cp4cV2KvGKVupw/bmqj4Ga2Y6BvSRR7QxQIpT6wBf +43w58dIkSk66YqyYYEo2EThw8IrHsjUub9hadWxTX+v8fvQ3GSDFm3vlWh7NJBlC +c+vf2jWIiNIFWmcXJSExlE4oIT29oQaOhYfOPu4slQ9kbWwFjMSifyyzei+KhED6 +SiojLZb5Z4sATT9dSUf2jWzlaAJbSmTCx+OEnkWyzkR4GYgjioHS7TpAaQOLAcGn +BaEoR3lgl39A169qkPBYsLS6AG//DJR0cThFXNgUHavO+GzyIdZD94g/CF++ylDp +et8Wx2MhF05kemq5S1CxDKeJJnUS/Lc3JAs+9BSyZFpXI7ZmLuqgZLD8X/fxRNgJ +ZPxOC0XFPX08MRjrVeHeOSig+Z5zHB9wQqdN6EHgvYw8dySdGqMhtBC84qRzZzny +iQIcBBABCAAGBQJUA7LCAAoJEGc6A+TB25If6vAP/iiYDX3Qw4SYEuWxUHakm2cw +6NUNwg4jt0xKp4/HgXJYni2hoBnbyEBPEDkdWmwdFNUaO+vsKhLXxk2AbKwiUUiG +fxsbHIyvWfER8H8JLjDgw8vF9roPRJIYi3HYh+AsyruFgSTXJQe+5ue0Td/yMmYb +1VZ2glTGQk6S/UGKzwMu3wUteDJeaP5Z9VPlfX8dMKDW89OmvXZ1TpJ71Mdv2KYo +3T+niS0/ChJmuL0PrWUjVX/NxAz6AJercdSQxl4kNnZUO+bU5sRKDzLdmLze3mVk +f50CSHmFvQROaE7MRvNNmzoRvrebypGE5Vb1gB/OgDh2ObA4KT2YZeJaOlmW72H7 +Wex/ivMtzkHB92XD6QfaO1tRN5PQkg0Ovb+EJYKVJy94sNVGcStLNYh58WbhsKfK +jRFI8AFZGi9M+OUkRMiMubOL+efEw9OXnRsXcJkfdBR1Ej2+DiR+XvX1LtnzSk8b +vKF/nbamWzrfBksRt68+jIweJx6pxPAQkq9C6I0OWDBdEPDcio8Lrn+qgJPsQYRQ +CE52ABzRwG8xG66TKjYL1PLrhrP1BP0B9VoLZgPD/NOmXr0sCfdu+h3DMwO52cup +EaJ+NLuxxxHkgWd2bLOqBBUNadYM7kJFPXHrbWZjn8M5b3SIxPnwTIlhLY6OWjip +mcGcz27V4sYozYvFNOJQiQIcBBABCAAGBQJUBRwmAAoJEMD4hkzaPQNYGBoP/3n3 +CfJ4OvOUfH1JqPFDaWePLZUdcG3gNUh5s/k7Z+OuLNP8LzcSKS9DVTESfx7iHCHs ++jTnXIPYCf6MNTNemgWdRDZTS9fmsCesTP/wxPtzfey0W0uiGduzFkYw9XO9dmbw +84Y8OWOF25onMX+wkx2Juex6lh294LDvCqQXdwop9TEwCv2C21olQsvJor+97UbE +DyZkUzbzjPETXh64in4eqPjC+meJ8tL5FbVmQ54q2mqzW68oyWbMlOG1jmovA00j +wUsrMe/BExpGvFrs1l3KWQwvx3OTVjEqfNBzqB7GiO67zi7svy1QpQMiKNqNml+T +rPliD2ZmjLBPj9RLCsZBqCBmANDvnUErBe0JMCkb+ErafSWaYX5lqAgo6fQ16ODn +i6eoyfJnuVe9DHQzLrwK1Ftuv7cQ6P9J4c7o6AYenBveWLLwomNbKivSAPtvRy14 +HLe2X1W460Od0O80vuWc7zLazyIYuiTwfhNmkcz0LrHqk5v5c2XummeOdYADvdTC +GBkxnSBoDBLqwqMDZI8MR/RK6JlyuJeJ0YqCKAWqZu471MEBSkF+YrU22V68yzmU +LtqAQsQd5RhPXVQG4zqF2ofqxDM9fgP5v4XRfABVMEy9IVfIZl5VY7lDb09jamgz +Yr9FoZOsjTYx3aUx5uXqDTtl1Aqzb1L5XtQ82HXCiQIcBBABCAAGBQJUB77kAAoJ +EDtW4rvVP9yxl30QAKj3DyLc69bSYm6vAWmZbUTqV1H+XUhTIgzjQTXH7u1rMGqV +rgUMJ4hjR+n8PtHlVGDCcwaWZ432F8N+VjnLwyZ0q7fKKtdXG2f5HCrG1xfHrD/f +7z277HrxTedgfOaluBq6iDqWnntHXOXzkR4k5ZNtFvqmNCP6CVU5PNRfwshiDa+m +L0PpgvsyhRDBg4Egu7BpKYqFJvoCALGTlPt6Mq7kebWwnE9/Ku3sHSRvdWYEpOyK +0zgZ4f9ZJUJNvEpUiTmEfy7shxehtbZgC0eJ+3l65LpK78QTVw3t9k/mf/VLktX7 +veU7hitzUR2JvQxn648Mu4L1Bw00JgDeYTPTYQnw0RkSSVit0yXu8n8/nHtKExf3 +bX5AicldeJoYsxx945QH7516t0MDjOts03b6mGjwv9H4gyedotGWrpXp0qx4FCHW +HpHA7VI2rIPtesmsNeNmSdMNLDn6GpAXTOSa+Avnz82ryc0wNk9TL0yLYOoS8MVR +PCpfavgmjP1zgG3JkatmSLMDZl41UFXKZMPEUQfqTjWkmJJf7MpMqfoElJh2/hwd +ksZTK6RDc9DtxY3bNWD+M8eg3RIiL2+5gjDc7RrgdhZACuA6gn70x+ndRv5J0r39 +TdezPO3wTut5xgDCLkKUbqf7eiElTgSB/V+p7VsHwHVik4hxKyKHj4k9R8jiiQIc +BBABCAAGBQJUHC+vAAoJENkp8pkr7wozo+gQAKd6YF4zrqcJReJNCWRuGLawx97d +3yR6zCPI67iCpO4rLakoquSwR53LPqBV4IFvIqDmxKgV/BdhwBI+OBlrinSxjoiZ +FOhr7Bq6fz/nChFgFsihS/x2CHJ57Neco3YsD1atmg2ACY36WS4cFBr/9zYd5IYN +N4L+TcKtf5CqvXysJL9LmT9CP4dCqq24MKPayjLCeOJ1g52vFD9bZGB7CntkIcNP +JS/rS14xhomA50NNnmZ1VvuiRloCJu7HHFylvBYRoEL0chjfOlI68pLJGSJPxBAb +YCeV24lvolsMiwq5Q9UlxdUam937YRZZGPPGvTysY34ifrdywKgDE2La9Z5WnIiD +JWML6UCql/PU847iNKeAvOt4NGzNzbnCy8LkjghCBgBoRBrelb9NtOedhYVD1zoV +SwknSRidGzOM3WLI7HPqRWUX4u8f0LCTS1oFubbmdLwccy65yC6+uC89A4GUkB9R +/ED4pN5d18mSeGaWWjZtkRrjt+BjUOEQ/U7DwPf1xzi3wZn2j5e8cvEZNfBDO5Ns +Zx+jCPIt+58fjbhURmkZI2baFzSjyhAyS/EuyHd1uXyDr+nDejPD5ztY116jpdu+ +eUKBlG5kB/ORQdCvjyNPBBdrY2UTi9VpuoNnuWV4Vb6HVH9c9WxDzL3fY7Q/s0uw +7jcis9aejkK01RfliQIcBBABCgAGBQJUAoM8AAoJEB51mnJqn910vGQP/iyQg9Ox +kIvlQkCAT/sqUP06hGqGPg/SQu4pz7/NP6oKnqdZxGTiElYZL4P/hO7gkXZPPDD6 +Z8Sg/qdk6rmGTudPvCcPW6O1jXPfc1nQB/L5HvHm+a7pQHNjoKeVDAeEroofRL6p +EXAdHFD1Y4UsEi5CYatr2LTHxQ+cDSdPI/ABhYWaNTd8ryvS10v51ac1lyv0zncS +RmP7WdvmHwfREx1hQJbw+NpE5Ocf3NhX4lB0KyLa0EhWx/zq6/448dGHOiamhK3Q +SmAIxrrBXBn5i/WenIKPJ2fVQhdqveQucfdKFBisf3FTUk5PhF6p63PJKygTEv0F +w0SajS8iFyGPlmp9Yptib28iu3DxrKQzvlCxDsp7KFVsFHeHb92ZU2rLsJ5ZrMmP +oGh6CugfhNA60Z74kE5QQc0oFlffYvKcujK7aLrpfwoqj/jPCd2ttuP+f3gWOnD4 +RJbu7OVYpl5RcLTkv6tUrWWQxmISKz8/r1iDMaaT4GaTaUrrUd6/z7jIllDLU9EN +F3ExtWA28v1l3Z7VPwQ8a2U88x1fISibFHZRzDuTtC+Hd7NtpzV0omJYg5b9Icz4 +bQ06R1Ycb4YmGwqXOMS1kBeQvHycyOWJ8mwIQrYkNiT50Fdd8vG8AifcKa120NQo +s6rjcASfee4mefnjV5D2jQv8nf4Hg5QoHtXNiQIcBBABCgAGBQJUBze7AAoJEANq +nCW/NX3U9MwP/RrWzTmXCaEViU/Qvm06H40yMHRMSgu2m6p+h89E97XqDPjqBKm8 +nFu7K+zWk9d3daZZShlJGrpKIrUoORWZEmGOieiBZt7knOBOP2ebCxcJ1BY/YkLU +js8HBGJ4fGFzw3SlWR1m2Jv58AWCdJp2kiJG8ryBTjC2m4tpjIPt02O+8vomkSov +jlXHml47KGLhHXLSHo9QBfHHcAT0hTJc9kHKb81QmbKtml3IBhBuqwJzxN7bNck/ +NKtuMBg4w3nk7dwXCL0C7ZkYaGq3OTmanhGhezzpFO65YSr4fHdUCfDvMObkdLVE +f0n+Tl6SuadlhiiOUN1dAlivTNpx5yaTc/aZRE2vjiv2+Q4N9aUCSVp1w7nKQ9cX +pVFcujyw8CNzqh2PHhHlhcct/FPOhkdbLEaKD2VK5lxG4h2lHR60xh76lgYgVXEP +NWsj1rv85NDIIvRm2TIPuBLtFVSjpSr90Bn3+xDjUb2H4kC+Ox+VMWA1Vf+PcFTN +nWaVvMt+8Rs1p/Yw55PSUz/Il/AEQ2IKdsIcqLTWwTXziMVHg5Fof2aolskpLFoB +PQTlYHu3WFWYNGq8edQhWA34mBIsIW+UejjVXoIU9VFWLrJtgQo6OWFJH8R6rCFY +10zvsxoq6WjlDIk7bDJur4JRFGAXsQo0//QkLx7wJURrHeGa2jvj7T7UiQIcBBAB +CgAGBQJUDRsHAAoJEHUatd2nlnnMapYQAJAah9o88zQzCi0oCizRdIzkDDjRB8CV +9WmUA6m9oKV760qWDEUf8Ex+yBQNU00klKt1pSKRc6y8ZWGzq8FjYZqukhKJaHTy +jvcjy2Sq778rbl2ekl6cXTjU2y2oc6k41Nbru4OLVBWQVFvTJEBtl4H9OtGRJRIP +LUGjohb0/2Fkbc3cjcz+iunDThlS4Y7x6SY6TsOklQ24SMqJS9/4kXunr0JhTP2k +nhD4BI80dGcziVtK24XpoU15/nPO+PYxp5r+FKjiRl0jtSOU3DkFVloVA8h0fbpV +KypOeI1iqT5dXOormMzOEn6kVRyzpvuopiOON+QlEkbijBqvWSCSq0nlfoLMZPif +jM+xmXjaS7Nk+S5sMX7EWLDKLIDHHbGSkZvC+nJyNDZbWUzqq76JcjUipUIwOjUK +j+bQ4vgY1oDejk2D7n/0yVf7VASnDJD/MzikNEpuF2A45SOrOLShIai+87WNisUa +fSvTO94eZ9Np7tua4m7S5bdWBoeXDzr5nn6nP4mNWGw9TC285j96vCSCNz+/i7jc +MpjILaLjR1etci52YNal/26DzKoHnvv+leD6VyL7kYY3nvBYzBoix6jUrTitpVvq +sHOi5r4B2kIyyuOL+EN428+kAyPNRshirHnF5WzMzvN+oiU8oWK3OM1v+mUWfXWa +U7BdGO6yE1imiQIcBBABCgAGBQJUD1XsAAoJEG5gi2N9iWfpPaAQAINylBBrxS0H ++SZf8ZNURZjMAtKJPmPRUyULO2ncxLTcmI3xaqPSHPo12UxRguVFLRdZXLUcY9xe +/c8qhm65Dx26kdin3rJ85wjovAgmHisbu0/Snf4uyQ3TfTznI54JeYBuPiyhZQhI +y3/2Um5daNqC0uJ4q8oiTcBaIaE9Bj8dwffj14aFgUzrRU1o91kD4ygPX/pyBjar +W79UlvzgN7n/D0M6szINAJZI90CE2fa9HRSFTHgER2tNJgEFmDYzs/9tOJpxBIbr +SC7c10v6k+ZYedmiTFE6OxmQE5rMKv/uYcAEBzRaAMEO/LwLQwVkZEtMFvDegI7D +hAIRSzqya9/qBh2ybvNl1xExrFJs15k0uGVJNA8HykqcAzneju+AkCspvHQ2EZyE +eCd2jd+o3oXyfjtlTzW8J/5CT6tdFzkiWUU7VwBY8PAMKuWHNkgqHUe+OqpTSVyQ +zh1e9gN8880Gyo8z0ilYIzRWC0sMJwJ++Kpzcr+tKf2w73ekdYuRCfdUD6B4ek5Y +ePWSwWra08Pb+L0MXt82jo4/2Y0S3rVShldDqtHeA8qMon/E83bE3lcW2ozcyWFb +xwEpAqISYBuL2byEOu1c/I1gIETWwhjHfzHLlh4EGBlLvzB5ynZxpawTuAPMMFiH +QAvSI/tck9sNF3+18vBiaVHyX/dbVXDviQIcBBABCgAGBQJUD2W2AAoJEPs9JYM7 +aq/4JG4P/RMRevP4S/9N6wRbhlvXPQAxnSB3EdTDN/+IWRKeGR3TSKmJqHtXj/du +4BdNNWfySMYPSJVbRyZthpq3diM+K7Gv4RXkRyIYLvXa085Ys+4jg4jRXLU8Cg41 +Rn0LsNof7QZIZnxyZ8SO1lxh+15Qw105IE0XO3jv22na/c4MnabPdtMrlies+Wmv +32fiGccgjP3mc4wG43PjZ3rx9KTDBRGYDu3yKH7wDQCWsco34LNDBcKiQrvN5lzM +ktpV7NaLjd/2Lgj7tLjQxs9PpH8x+s/LudbDelQk5huHcyUksX421j7tAivJkDY1 +sj7SDZV+usfNhrEPhEv8wl32gTz3Yx/5XGj3NpmioDHMFo1KQrO+x181cPMAZ7Fy +L1ebXd7inYJr84Tdqaco7YOY4LuJ2A6x9s54Y2CrgzasObz5fV4NS6BFEd3zvRkf +l5Yh8DlIqh5G1pZQV53FE0UDn2U5WJclKIsGapagBlmekEGbI3JTOIY1tGpn80zh +YY0pf7HzogbRjYr5P7d34/38XIJ2tOjHY4sLVHyDs8w6FJnXpqesdIVavcRO3k4H +EAe3HyIqE+M0qEHlJMf9GlrsEqf1WDeiKpkRltL+PI51C/hKOXk2cL4/iHC4tAts +V9robtua3s9Ny1ynuB0lc2PtuzKlFNA0crnWSJ4QveCyEI9XF4TGiQIcBBIBCAAG +BQJUALGMAAoJEE+tenU4RVnbaVsQAL9jqyydi8RS5mC/jPczGkikka1a+u2TuQi9 +9PR6OsGyms9oUvFMTfRxVklCarJjh5I4QFC9+ZNPO4ziIKH6N6o3oJsW0PcN2gVy +N0snS7cqBgwHn9fOT8kHhfGQRk5YRZ3QqAMSNcv3Az8yE7YWGSEDUYf0s+S4nSI8 +231JqjAjNDdClm2suMHJkbWSid4C0tQKSLthKKqnwoK5K3TsC3Khf4H9I0UC6l4J +eKrHDn1vUa29AAgmb6tJgFt6lgDsib2HJUCCZAhdv99ZfkkypyYoUgnsvog8fHXm +lLxNk8/9OxTVUDF0YgHHjtGjkyQRpDJHegg+Frhn/qCl/PzGSK6bHH4bML5uEZBp +2B1HhTe2WqS8flxw9++BZJd/bnM19D+jWcO2euB4kYFhHNmc1nvAuwhqAg5/XPiu +e94rpj6PUD5DosVZLHpAc2o/ZqkOYmPmqQFiLzMXtkL7d9qPNG+C+7KUZEB4VCKi +n/bg3Ts1cThGkARTiWoK8ZpS4sq+ezAVvLr+Y1831r1g971g9LKYPvjB9+k2AGi1 +AuQMs7vQ590JkRNSiEH9cRxiWVSha14l+fvm0kWLkl0gs0m94BczLmkyoRaJfy7g +fR7Z0hVcnmZRRZ3A8Y8jHaaky5TAPuDADBUdw/98UFTaYNpzrdAz62ZlReyATnDg +ing/Fg6MiQIcBBMBCAAGBQJUMY79AAoJEIh7YGGLPBauCMEP/iGurLFXZWw+FZrC +y3IHyLygn9VMJ9/xV8+3lDNXRJJ1WyUNL5ha4a0yUs5xE8lj8y2K7Me9Bd7GW82C +RDPNGzUksN9Vy7FOPNub/U0BTAfdgJbEfdAQGez6VIEyvQi23IT+Y1bTOkJoi/bT +s/Kf3jpPvuCmFMkKMfoMn0pgSQXlLg12FmsVXAl44fbLWGLip4jLxFbe+vSflCGF +W8N3WBefjr06xWtEuNqnRASdVNQ5gwBwpsbxJ/iGr236kpB+6LGa3PdYwM+6K+M7 +WEUazJJ4nliJWv9hilz8RHNZaTnp+FmRTIq6U51sCLFcAPzXFtvZsSVjAtV4/sx3 +6TaW/TJvbXBuJPQNMkVlZgAv4hz0IML92sGvt9wP7gC/tmQ2/O1PMvV7VsAzc5wd +szUT1BVY40ins1KVkNNs0sXE6YEm05O4ngfaS5/gE3PaxL/sQbw7r3tUuk+j8c4q +QD8APnXspjZqxhopzyMEaPsZiUzRe6dTUjt0QLludAvQiJWUYkkR6/KkPjRsGPlk +9lZhFVT5CIUF1gpun9s5rFnRQHl53Gc1o1Pg8QeFT322TP1YRMp5Sze/mu8IFE20 +n7bOfC266HvloKC4s5Css/nqq3Gsmc5mtWs0bPhXEG6gj6N/GgRuuSBIfbs7jOWK +CmoWQeZkDbiL4QFeYcH7EejUGmjCiQEcBBIBAgAGBQJU0E7/AAoJEJTpLfkqqlw7 +/UoH/AmdrRSw07W96LSGz5IjsMFeagF6q1BpwpqWlJMtqRu8jlTN6Q/vhQIit+ZV +xIp/8WGeu4v3KL3vQ7M6dy9gWhR7D7vJr6Zuqk/aJibstFPXt/fZ7x8TpodZkdtQ +bvoiiwInfvuhJ4I+8601DnXHIEij3la/7hV20e7kuJ3lLDRyaX8eN5Ad0x7gg9H6 +hvx26n3TxQG+fHtjNQ6x428r5qW+nXM8eLQzXPu6o0ACQcrpw+w2NeAzgTPUASRh +ltFdija9+K86vulSQyaABF9jr4pczdtylPtOAkVFUmvJ3JffOvxkqzs8B5TskqL+ +JxgQggCyRqjW4vfpIx09MBZQyY2JAhwEEAECAAYFAlTGMAQACgkQw46BYKF4Qf6S +jg/9GPU2AgINsGnOXQ76S54MSzxfEu1GPNNpN8LQqN2csKAeYGtmOBQUsZoWdEGk +leLqeqbEARJ5ihS2B0qrIpsiLark25+S0z4ulfHdm9Djv36KbtMjAZ02+C+jXn0F +3pBmwXqr2/LB3drhxFrnlyuVayvDF8HhcGTBoGF7j+6ExbU1/sh5cco8/HvHKuOE +106Vu5Re930hYb4zpzdoO/M7jpjFsUYLsPokJYBMk8BjeDIwlYLJ/X5WMT2CnJPt +Mmbue45WLZLBR3ETGV0X0Rm3YMFXkCe6h9b6rfXLDunYNTx53/8k4fLURpksuXZz +4PCGYVmw+X5LYool1e006fjxLPiUwxk7tyLP1ihhPtXiQrUyoRjuLbzeIp8lRU3/ +n9vdEAXZ7NiIOf5mjWLK7f2Ox0x5fXvqvQpdHiMd1Xw1zmJpWX8jLpYxd8JqnzRt +oqtWk306Ny+M0+f3fDkV3H4pQQzRAbed/5AF+v/lp0dImSXGyCyNwSlIEqj/ysFx +RiElTUuxLU7cbwSW02sjy5v97BgcBV/E4LBX7r3a8ogugtCldLifSpHXoZIy8dZv +qVJ54MOHtKCAY7rg/2NvvHvZUtIPS/m0w9GWg+4ieTDg3ix9gqakmUKEyXh0q2V/ +FYXtlY4zn2aDL3mXsKHOP9JJFJcRlqDUX7uUTbdg0G+MchyJAhwEEAECAAYFAlWA +MjYACgkQV5MNqwuGsGcRVxAAuv+N94BBtmrKhIm7QWnY5vZ62KOVFPN7bSHiefwO +GLl00cc0f7dTAy1XDUiodLrJvYWHpXUrm8okA9EqtH694bY2cToc843KvP/UIo8M +OVI93nheVQC2tUjd+xi7TWKZFeisJ+ksXSuiveD0xIuYd6BRRMhXeELOD1EM2eBm +LV9aYv0pjh/IYvCHkmniSNoNkAKX/TccIX7D6KS/93Qbocjm4VGmIKQIW/1pk0xT +l7YH2kjeiKg7EdqA4K/3e7vvnsEl3UQTY/wl7eJHyrMqpSEnYmgwLE40YfbR4Z/X +m87pVrPmh2LkOycpkY0X/P4PR85bwHLkMFzDZQgkMzax7J/9v5eaS4NxKfwnuHco +6mlqH9UXbX28tu/ITWWE9XpBiyrxStaUOf/gnEPbDeKnNNvczlXUqfaympzYctxB +21azfr/AMCPV61ZhMcymkViatWgYAMHX2OXMphcljoy9QwzdlGvWM1Si4qIH4JPf +Y7P4bREIlZLStTxz3UyOGtSEuVWh8Xp5iRQnCepIvT9g8L72LICZrjpeG/pFKHCw +eAjwO12FjEMbXP0Tm4wZMO6J+W0j05zC1whJDjr3X4CEGGpTkpEKX9E6fsdTjqdv +7XIFb4CxdhMjOWaBdi7rLl586skTasMyrVH63V6bJ5Ap1l3bCuC3IzAOHnEMlXai +eY+JAhwEEAEIAAYFAlSQnNIACgkQuOUId2ZHWq/g/g/+LiKWvUaUBbgMcecFuVnt +CsKyo7jSETXKgliErsAk0CMXfHEawOPoYCGrMg8y/9A251YvM6e6P8geYs8ydokP +x8F2ZZKS+p589YxKCuOQzS/vACOKyDFTicmgGatV3c8RB4QKLZcxdISBAdGgjxtX +6OE9XI9GJDN4F+O4i6rZv5qJCM/mfPCrx6Q+IdSxhb3p3J8JPtyIidAuKLlTZ8Be +ibYGorPs6YvChq7BbTasYXWlDqYhvbbYz1bKHpGJbykvDEtLi6L3AkksQuwMrHAV +Fu8nO4TItP1RcMmagDpqvKgxQyJr26+v178FPJqqz0NmZZn3H0JPX4M+s5FzFr7U +frZj/qDKxZqeWwAn2Ir5HAPGQ6TNOkBrcuAG3Y10COO5eJaKU+QPuwxood+O0ORz +o/21FpqsvPF15OosYmLsoSxhS9nhbyVq+LGg0/MO6Zfgj+Z32/dJxeIijHjVjd2W +co92fQzRG+46PhmnhBRrrdZ0yjaVAeB6lyOvPgkjBGCms2mPuCkkqeBl6gn3O4rb +iTqtWJol+Av0dmnJjPrm4Kb0cKJa98f7qqGwajVmyVwrgviqkNLQvHSkjAazV44J +maivv2xXOQs7YE1I5WqrWkXhzv8b4C0bdY1f8J1bpNdaGpKU6cR622650wEIb7yA +tAJO+wnma1RK1IDXmkW/+5KJAhwEEAEIAAYFAlS0hiwACgkQUEHxiR9E4JBgXhAA +17AqzA3QOylTaogblI7TEsj55hXPXZ6UxdXDo1RivbeWiFdRy6AtudjOEeHu8rkw +iUcR1trcXWnVxfqApCP90yo2vKEGC5153CK3ZhwZejX1CMD4Jv/4r7h5B/yEnI6l +gpYPHuJB7A6ZHSsuDMYlJRpBRbDFqhMrULNSQzN3B0MJ8cmHw+lU0K4f4cEbF91M +9RsdT8WCVB6ZJwMrlupwmRINyQTkHrUVrXroK4vPdsuJ1qDnVtnwUv64HiGiV0VL +b+DSR9aaLVHMkOOB2daPfk/JLN9tQXbteCokLLbY+5XyvZm5iAz/nNjD50k9iwAw +/1Xgxw4jXMJQf6WO5xckJrmbOMlMjI1bzPDWBb1yA5n2zVZHqjhzO4plViF67pIb +VmwxrEDGImHb4MhpZWqRqpXP9n/uoW9HaHGCGQS+jbZJuHLGw2JT9yUaxKkf5UMa +JCfRWRoMuUxYuNGaVQ3quKSJGAm8JNkh5bQiO3h2JRdrv5FGneP3en0Gd1cgH3LI +bnwKg6WvlcHtHFE7/cd9J0IAj27UmYqol4Q2vxSmkmeX5mUmr72nscWdLn3qdgGX +zO2gWdkK7m23kVB1JptaOkIUL9VuoG5+mNLWrZWcs0nyPH+7hgS/7p7sdNz/s8eg +UzRWBiFEwQIsI/W2ILQcktnYzw2eh7HfEwnMWPkrNziJAhwEEwEIAAYFAlU2zT4A +CgkQx4jEwdRVDUUq6Q//Ts+PYuTKanIhUzKvoof8EWWm82Y4BwTEoEldEs+zhCOj +x1EH0glpY+Mj/CwkSCsewMkzJSgTtAtl5iR/GvXVLovfeHdJOteYdimt5uVlKjgH +eZ4UUrXQH9uWmwWCVz9qiwkfPLXQfjQjkPorEMVnU7/vr2ql735pzr+UqFfrhxAR +FtugamYr7R8KKSi8gpL9ecugttm5XtOkZeHbhEOXjyFzCMurZpUzDUB3JBT3fRym +oKBcqHki7qkK1kxlVoiNw+6tckzbry82LIod63gqT72lAUjltijOTIMHq+HsFfqR +VIMaH75fvQneMGuHgsTsMD9jL5gxI4t9156HSU6Vns2iGKh4ldyN0PQXyxmG645A +g67urN1PmVhADkBOT8gTxh1+UPH/wzDdX8p7KEn1nwTO+FBIGo+O6Z1RFOb+ETvz +m+3wawwUgmlUqfWnhuQJEv+mQdyqFj9U+LJ+gHnEblFpeodljP4eV2oZ25sPvsvp +ihqAvBq4f+nNCMB/PiAhmaTN+1cBRJ6tAMW4djnnYUhxwwJHBiwd+sHRNKEyJVoh +8/T1+TcGkhxrd+TjUkrppLOemg34pGefzZ2VzMRvSApmA6Whb4h2v1tpBWuIe8+s +UUK6I2knPSi8LGNePXusfK9jHsGjvzhSG58ny2ZhyBTa7aCGmRgm53TKvYQhMEyJ +AhwEEAEKAAYFAldbmL0ACgkQLTR+pqplQh1w4RAAvGHXvkB84QvrFujR1Qznz7JX +9+dYyQ3VXncMCBFDRO4BjCr9pEPl0zAPtlLxKwKM3+6ZMkj4ZYEqhYQUSNePpxoG +g2q/j3kLm8nR4m+vz/WH549H7xi8KFafFcumHEv6A6v6lkZ4LJtnkcn0JDfONBCI +g+bnjDqxGXVsyALGQj+3DZTfE2kIQyzR7wO7UUjg3RVBgjEJwTUAZ2lOlgbcEBqV +IA2uNgNGWp3kEgaMksQp8qswWWTbLOBSvTNADBTxOREAKAJJlX/ocDCaJ+vfWala +/YotMJQuRHwEMyVlcbWcUIs+VTRgg/hh7o3hWS2uwBZIAe/fT7PI3vjFpkr6uyEo +plZtZoq2YujYsg2qPJ6Mh2mO7RaBaNl5+fazBbi+8Kst8qu6JbtyFCX+L8O1FM69 +7NySSfyNOAbhot4wI3exn301yPW23gdaCtq4WECfxEjm/8QKIRs6iET7CIJLzjrJ +vnuNCYlIGna/TgzHYw4+ElHCz03uBO7nfyiR0cavBjnExILfPzXP1315w8tGa1zw +mcNMn2oRk1+c5nqcCEWy/RGqh0A+dkfUqJKLAYjIFqd70l6vkcv+rh490QyONuOz +w8aMjnnWTdtblW/r97ymbmY7JAZlWa9WJ0mfDApQC1NVKc+ze4yivktr3GKvj4cX +4jVm0D2b8A+yPDVQw2GJAhwEEAECAAYFAlbfBOAACgkQNSxnILHjuStJbA//WwPe +AcrSNij0d+z+L0fpzu1DqHQTfA/0aGVn0/nQSNtvVmT+UZGxDRB+iiH3f4i+dXDT +Cd0JogIUvjy0/Fn+5nKgIY0aeK6TpQ4Y6c+v1aJ7rabhuGrafFbUenGB2+w4dwiu +XNGzJbL+HDj7zIZ1xtOWC/AJQ+h3FNqM1H8FWACXSNCQt8hj/w1XCMevVIAbs8ha +4pUvKXplNyflEfVqtQ5Ofv2EIkh9fQEWnGdy1sbm2OVZQIeiFvD/woW1WwEgWg0w +7fotD44yMCQix3BmEXMMtsB5r5CjQbjMCZpFUvl3UCadnop6/FUPCvl+ufkg/MXg +n/uR1+hAY9Egi7qJUcPJJ2/3Dw4Ta7CZkgwmrMK622ColDViL/1B+cFhXsfdk9Cg +uyFr7DY7TwwsJ4/c820RyVAqHtzDkSJ1IlK84jZEw2E3yfhBYJ1VYPrjhIHNaMV9 +yJMPIlVrdAc8x1acBIVrX69fL5HH3RAOZ6taYS+kumQstdASa8fAg6C7wuPqyEVp +v5SFPNSp2x3VmSN8y6sghYp46T2mrq/k36qHBnLUnbLTWFNyC+rddwGUgK0p4eCp +X+OGGqJ3hf8XYcQJStaCvuRsrk3rf0K3J1ELFRbHc9O5BOZucTgMT6bIIRXX9PDF +UkEqV27czWC38PjOc4+nDKZhObdkS2FD4GSwngOJAhwEEAEIAAYFAldTGc0ACgkQ +CUsJ0J3VNG2srQ//dtR/yIitehYuozbImWKbnNzKmwLd+S0A5pDi54km3KkTpGph ++MqIlSp73AMJE99ihU9nYSYMCTb428/Ad7bPP+Eb3Txf37XQkS4O9ttStnVmuVPt +GbHjvChJbZkr5spAgbartGocyTAeq6ls4PhicX3Z5MGJ+sRbXLBN/JPyq2sLCkcV +m5XUvKW2D1hZlI5QYtfSGBXYixjA42nQf+W770oBKT7TZzD0kYzxnTdP+XwhNqFj +zA/5FsDtCh7sy3tBB1HZdsTX2nJWb9FCgw0WAr7p1pWMXPHeVJ9S9qvcM9rkKLZ+ +vChj1M+lTfKiq1e3X1VYSrvK74Eup0098dzUrSsB9SKuJG5ktrpYbWcqnNKTl00b +KMYty5So9ZSO+1MTwdLHr1dnwDpEhb2WU4e2ODucQBlEEUgmMF85Wby808FrUTUY +o2NYvcHI+z+fFtWfIFMvIZcvVAqD+ZFXdzKYLQeUthVwbm9e7B39Dm/O4jL35G9N +eBRKeadbtWdC4tpvJuBbt2RhEXIUB2/bHU1I3ejbuDhKY0pbAU4h0QgPqmEKEz+X +bHk4zHrr+U9CtCVTuc9v7OiFsxkp6eFv7ZNwL2lFRMSrRYGsp+yVE+U4uoOSfBMC +uD9PIPthU2pLnuCwolIRmUrNTmk7CTHgeCmzGWjn6FKcVdq5nv767SR/Z2aJAhwE +EAEIAAYFAldTGs0ACgkQwA++LZIZJ4ja/w/8CutLFDTi/HrVUmqARKMmdr8fBiuD +/DJIjzcg9KtOLc6T4UqZ7kiB9vmH00E7q/1Ebyd/x8qQaMT9TSiJ8Flkl17HldlZ +OT7A/ACkBcQc62iZR7vQaqo6d7jmXcky7gbPiIzJSkxI+6QL5yeIt4pYEnxTbg4F +k4SK3Dytz6Roo721wNDMAUmWyJLuA6ui6QgCMmZi22cGHCN5GpAnJRr6ZNt1p34y +XE+a6ZsmVi7ABD9EBanI98uayXwCYR1l+skm+IVb0Nl6R+60OwJO1dnfqGsBMfDt +4QbKagVscY5Jk3ONQrrDg8CxlORD3kO5BmoYckHeMOn8uO9hvJo/WTPhzH4ZNOAD +jq8RMI5OvoAdlCL53nO8jK+9OZR+fkX8Wd6D0uerElxnoifOjsaOMbE0CplNfmGT +UGpJK80KoyP/UH6fAeP1PNpXBiU9XiPXbhA0hpKYPSsQE/EO5ZLfIHQZnyADS/4z +LwN1A3QgTjm902qPEdtsmj1W+aRveL3lpCQxDjBE8nkfL6mECqI3/vPelHwnDB5L +TnBJ7rYpregRJzBKqY5k26DuhDcPYMZ3ge4ANpJ0FW984t4gGAbPVThQgG47F8Ds +rRY1UxRF2RW6NsX5ULLHcSOpuJUSm51mc5EfTfkeaJJRpmzOfCS/9WhybsF7gKZI +D1RjyXZ2xBNViX6JAhwEEAEKAAYFAlcjfnIACgkQh1aPFWLNUTLd3RAAuKRSuSHV +cRZL7/9QFUdO1Ftm/x4ip8zINaencYWDE/MY+l2hQ3OpUJe/9rwvMr2IVUNoHs9L +jE+MBInt4Qzd/1rEJKsKKOM8qmsuEK8SoAPxj4jJOn5WtSW3be78EPCnHu9D8Ccy +t1zPbKHgvCd6JO55Lfoly5c3lzw9l1jBLbZK1ScRQfrDj3JNmAfcVe5sRnI3QglP +cp/x+bCqANwAUh3uQq0PvY5Hy1WMuaf7kd8s/xGWGssKENXliI2xEjNMPe6jozyu +C8i75KKZTzDYMkqsG3Ro1nkQo8PsxxIsoyRGrBQZJzKM0tZjbyPxUNjGSOoZ2dJb +n82XaFi3czaIW9YgzaH7SfAjcYYSj/eqZrnnv2i0ewMi8Lm51vyl7gcaiGj4uKYe +cfmy1WWZT9tgXk7RjtEwdhxpJRMGdAlZhvyplM6UopA69MHjKkGnz2H1xQ3G5Dvf +KelLduRc8ThskpVHA3a9GhcD6HGpRx1PXLrnjKiySdnFj2HxS/j/Y7Bh2Oipsd+c +mPN/vE096ldKdrnqSaS1EhuXBliC2R/+qfMnCCkXMd8aQIKUiXRBCsljfNTmw+Lx +JixayzKoA5uXF58qlMoYl9ojKaSny7Zqki4O90V3e0fV+rVHQ5lVoDdpCPvhg8u2 +K5+HSyALnJ3CB1sWAczRkFgPoh+ew3zx5L6JARwEEAEIAAYFAleBHq4ACgkQt4uQ +jyNDD4ACmAf8DCZdO71HppIs5yxo/s/JJww614leyr4LNOlk2k2KpDwbZpCJ0RbS +xIAegqJFMoHM8fHTrGnrP4EZhJRYJvmaNrUFe1jtdYaC9FZq0BbedkVkmpnRWuix +6jOkvd7W0cnwT1e3bOYvyJ/WiSXU1+Tk0v58MkSU0pxPxhTbw41CVJ+SO15pcFyh +hPFpxFUV1P0N/qT1RB8/4Sqtok2Ma7gans7XNf2erToPjnLVIQdpWE+DEqA79FUv +0sxIvs6d9nMQ4ymqOgsuDN/S/uD5dM2PC3KBgGq1uNvT+ndb3iU6GXjCyemtZtHY +tT3TTWRz3TKMmF1yItJnUXAJyBpoNAOCMokCHAQQAQIABgUCV9ZJdQAKCRACPAXi +ycBo8P9uD/9PsLH4EB8TIYE91jAxXF5Pa8EQGwXslD4o06SpAOePAg6CaczflEbP +5uyJmDh/aBd83A9vAFiCFQlD5ZpVZruS8dhvJ+AblOpXRLPlGKALfMY0iN44x1ZU +kmitiKoDjX68iHaeaqrm1AoUwFYn91nNkjhUqrezZFjUMVNcx4JQtYpHXV0n+Uz4 +NaE3GCjTnbiapwb+LHh6S9iqPvTs5Gro+UyW5RAVM95aGwDmFEtwApE8+D95u2cY +EepjF9T5FeyJkAVwXexWoIbrwENiLWFEC7ulwhathJziuMBhAngaR0kmeOnnhosE +55FJLtaxHWrrUrmneMOweUStoJlSh+d4FzKEs/wMJq/JDR3t4Me2RL1U0GyjoqHC +yhnR+yT/MTQEdWxHynX/L1ANqCDB7olqLBnbwe6EoWgB/CyRpByjr6nBsdlKNQao +ievfDY5oKo5XxxNfdl0UQMVf6GugiPs0qPEMZl/SX8pBZeNdIgrQKiC/bZ1NFuVI +KEw/KWWahU3IOBcIMTaeiDyxzBvj0lbSsqOYLRzvtsAqUF4uOcFhd68aLpRDoyoz +OfydEfsdpExWKMIAUbmaYGNQ9TqflzumDQI3ipHJ0agzbEEIlRk8+RB6Zvq8GHwE +DrfgptbOcveeVc0B0Mbn7RaojYgJ9hZcqfib5Ju3krhHWF2F1OeRg4kCHAQQAQgA +BgUCV2lgywAKCRCLPYZ8gj56YW2nEAC+EL1z8Q7+w0urMN3RFe3Wbadxa/Kt4tWo +6nUHmdq149nPlrWtb2X1KwgPYrjp98h6GE+rUDGCTQHNshvJh1ZM0xiH4hYdwIlA +RcCd/TNEV9XIZ8PuF9zVfoMx5jRZU46BbTqopTwrl4PM1zkhES7asZf7C3FJ5csZ +/pCcnGxgjLLTmZTV+1DLmkNRr6hwUcXEgxQVXco86GwUfv7smsFIx9OvtQHZY9xf +pPupSs9F5gKQHGEagfYHyFRXiF552ywYKQqpmyGop94UraGb0y8l9KFJzFVZhS/D +ZvhTbLsySazlpGbiFiTy86RRUf6c5Xca0Ek3ZvVe6uqxHPbo7PhlKwz/MeLJpOj4 +qGpieINwFyHYCe7iunjoiVQ0Qd2Bsv2FSgxA8WS7L+WS7gimqHY5W0wjT96IbpD2 +qf8Z8z46+lR2hOOvxmZG9LApK00BmiVsDWC1fQVivuxI7wsCQerDEnTt+xKoQXSp +fmNhqp1XCt0zcN8ocBNyHkC1nqcvd3jhy/38OJ9cGChso1HZHrw44pG1dSIjKww4 +I5qshljZsGdkL03ikJ/2jUmvph4fIXRG3uBNLv+vPcQGciiP71mD9+Et6vOGHv2M +Jn6e5MhZ85BPXJDlNw2dLoOB5BT50UYQmY2veNJnskS+DQ3dpe0xCoVYRWUru/m/ +FrqS50mKP4kCMwQQAQgAHRYhBGtJrLrc9r0cogZnq81U/OPZZL77BQJZIvGeAAoJ +EM1U/OPZZL77M3gP/04qrNA/tpG7XIWphKiqYMcLUz/+Pcb0jj/Prn2+7LdwNKTI +tM9Kp391qwm4ULrYDtThBl9wby3HVOfaG2z3KUYAKljQmWckRhUbz7FdVSla1rwv +f8azLAPkj3CGZGSX9eng/0qfZ6jnG3boNja8IFNSMOUDwui87zvPWoPCS4wPHp2e +QGS0LFBbgt5bDEmMm5cOHtKTdCcHUQNCGEhiDcWmHSfDaUO7jvGMfIs2NhjtrBag +Edu7U/blgAZ5Smpz4ueToiLwOws18Cfq9lDsTiVWjRxBwXEIBvupNbtd0NJ4Q5tw +9mimq9Isqb1X7HKOGz73/cHbfFD396bQ7Lra/aqkrqLUT0tHLHau5wLSlQnZblLq +wzj0TpSkwWzdZvnIYYPtzh6WlmmKHzMYMpy8TCgAtsNkE1a9Jbt2A5KO2RbmzSzE +dFl9ZtDSgM0pN25e9jf9ft81D/jagKAL8xcx+VrAEbEs9MN0j+vPiX9zyvCxG4xH +wiaW2NgsV4xMmoW8Typv8uiQKLylHzCuuONhGnIxQ7/p5cOXVFK+2NYj0A2Sk1Zd +NjTjnD+KGpR++nGm7BWXndvfTXkW3UFbpcQDpyDIGlqBk3z7deVgYYwq7LjNH1cr +ijKUfHCyE0yy8USkQgy0SesFWE2eAMQp2pKcg2RWq8XtE0EIVIMdrSbCRl2PtCFC +YXJyeSBBLiBXYXJzYXcgPGJhcnJ5QHdhcnNhdy51cz6IRgQQEQIABgUCTDzl6wAK +CRCMJNFgjwaJ1NLdAKCF99rahzKzL/zO+tt73mhhHoaLtgCeP9MM1uas5So5GSdn +pQ1Ef0eQUlqIRgQQEQIABgUCTLN7EgAKCRBVW5delTuGk0HbAJ0VLWPxAu5tKHBj +Y36vrY6kqgGyrwCfeQdynnDjknno0O4YonlgJR6XfKaIRgQQEQIABgUCTNXtXwAK +CRAdqNoz3c1oaqNiAJ9gEs6dy/N8s3h7565UNKoIo/XVCACfWMX1YK24warOcwqT +xx5wfSXa8ryIXgQQEQgABgUCS1di3QAKCRD67xKTbdPj7Bk7AP0baynQJEDvY2WN +e376g0/+YFEwhxP16uJqGTg3AcDfUQD/dEKac2AbglH3yPUm3ExpGXANky5Y8ucx +Di1aPfZlpcKJARwEEAECAAYFAk3RZSgACgkQprHz8Oa19aOgCwgAujpEfVzKLRwc +2lHOovvyRXlhEVs/qHTnxYLAKHeRg/Ly44XdIT4njQ++wiXQpS6UMpBmnZZyhSzP +pt0DdEVZYMmeJwmI+8TC+mXFVXxYnpr+tK08gDCh8X3XXL1d3hrITyCkgf0jjWJa +6eKIQKVsScjOnRoFk71pCNgJ94iDdGxyVkV8SlsgS6/o1U3KLkiE8GUx2SlNFFKT +/nVa8Aqxv+7TpNaV8iYfAHONgDLXO1zTGO8FAlEniqAqvocoi98lTqVbHjKMpZg8 +Wjj93qrhaovKg0vKBvFCWCrhTnyGF33hJRMYq8uyzoqbSCW2PxmYHPQNT2bkYMYW +b0oLiIFCzokCHAQQAQIABgUCTczq6QAKCRC437cbX+y9kv0FEACpW+liJM+kFLiB +IDXo5nCsET036Ey/g7daptSD/zLQgB3qmjnwbr+gQCOT+vfI1Y2XC+z+GoS/88Hj +LZzpQbUKgoTRYj1l32SawjlyBoKCXKeWTbWS1VDLeDVOpVWgBYPNkEL/7XU4AlkU +h69AFp9FLdIwz4/kL9HfvSCmS2eYjJX7GW9VpKWvFe9tRMU6t9rx/zja7ihPAtiz +DVKOAi3wMMGMLv2e9rbrHjaYcN4WF+HVSneK4xvEr0m3l91TAy6VzZ6RKmPuN6IG +u3+5s2HMtDnO3M5OCxbYoC36P9wZBHKcf4jTp+3GGzx2F3J81suT4NIX0ItjdZ6T +PYl1ih7DS7erDyRsXowSnONo7A63gAo+qoPezgVgROsbkrRpxp+x9TzOLvvlenfi +61zDyFEusgNVhFRahOsvalqMq0QCVBjEKbm5D26YjAcs3JDPoKIsSlaEEKT5Y+MO +i1pyZJV10tLTQ+8x+4KFYsjp/QK2fatVuI4aJ8imtHFE+YgjR+9vf4btRrlJEgrm +s8bNlHCX3wDFuAXR8QDsWIisw68eIBTy0WDKFVpFCwqXuHz9odgDdQbCfsufXIZB +RjuGR54xeR3T2kMBE+3bklniHV8m0PzYFk8u3Dexk8gvRleGFEwPsDXyIW8Oi5md +rpzskW/v9W0lkLI7PpZz8FoIXbShvokCHAQQAQIABgUCTczw3QAKCRDhlwEmdrm3 +OavfD/0Z6Eyg2UH0w0R8CUKvnnmUp1vFBzOE2b8HxBWyt1IWtg1ZR36Z9f4SLlLl +J8m0abdpGSxV1v+ZnLsRXwZhc1jvegNnw1+z8wicR5eH/4egcqWs1XhcYICY8yvg +8qgirUm4X3s85qJIjtdLBQMOlCJDrvh4BPOkJTSo07MCzDXkJtw9Nc8ROZ9sAlJ+ +/r4kQ+odoJV1bxtEtFIcMjWwEvVw5AJ8eVuq9CBQm8BFPbN/X63VtcF3Dl5ZbPqf +eb7Y/2JQgILRkFOIJmsoHES9sVSROUs6u5+TnA1YIo2D7zaxcNlxmJ02w+aNJpVt +rdFH58IwH1IG+ISp8wgf0LIkRuN6X79g7AyRBwPJEjA/pHlYRI2mCbs/wgsILfqo +rRE+05PgY7Y2TP+sWdCKZwxu/TUyIuDgdvaw5HDmbwGuqRw7q9qkB41H+JhcL6Bs ++LfoHoij8qrtmyWoX/h9MG2ReZxfVTOWYqSWB3FvezVL4Rtte145SvSmP5T8BQOK +7ZDprsbaz23UmujElboL1vTR5WVLpLYg/joXKuWO4irUKdNvzgWB5bEBaMatiYy/ +N/tW6VNlC/nhGYoDCXYsIaltPMGrO+D4YBTWF1kBQO3Q+LjArkeeabVHHkgI8xvU +LUScCPe08IuwWiHP9gn6XohqqPay0r31MJuaeMT6kc63yhKEY4kCHAQQAQIABgUC +Tc0yKQAKCRCGVh9FIYD8/vJSEACJXnyYHKN32XSjC2wgWoCb9fraPwRL/sg4QLyF +mz0aFR2M0+0lGaVBgFo4KFFf1fLKAGVXCj1srZFSQ9oqBYOR/G1DrmzA3mSbATQJ +fkoIDIvopa1a7DlJYzKRaVkezTMW9QIZGTWFGmW39K01KO6kNP9eb0vqD3jExKRm +4UhEjCfp3/ftCM/ODOJ7ajUFolJ3DDRDo/XhdyPUBfAfNcWpkfVmMUVp7UE7oh1T +HbqNl/aPh6M/aUSZTuv/ONspu9lHaJJaBhBLmMZbXjOYmk3G2LwTT7FE3hTz1LRO +ksYfH8MiGkGRwkTc49i+OgS5VVgc0zhkDgFMiXFYmoFQUkU9WbGdQC4WQxEA+Net +oYAv3R1rKlu0YgcO1ZokVlzQB9pehNEpHQNGLkJkJT1ghRvYcjPbRSBSCXNSgKF5 +lLm+gd+/6zv78rsDFFwHtRvRJMiD6N9LB0V0CE9CUmRwOXKp2Mit4pg7IRG78PN8 +GncXXBaRj8lNWJcvy0fkQytS9mfteXdkDITbtiGOb5RGSdoOuCk2ec3gmphCE2Yr +2mF+gMAtmcMxKJmLz9e5e1zkkw5FfI1uDMRvn3zAdS79yrxp0XtmggSbdON4nkiI +hdqkTYeJCroE9a4mpSafHiIAcaDiVZFkuEr5tvPEsygaED4/zBNRJs3jX2azwtuK +5mSk84kCHAQQAQIABgUCTc1dfAAKCRBF136eMMsbEUQeD/44M+32ZpOXPjbtKhaa +GVYARahnJWq2RiTrEQRzBpMeWVeD2v+h6HhaobMhkkWZ7P36afA7pEKadWPJaCRJ +Ir1wiEgd/YOVq+SzxceYbeZM4LTB03NP9sg/+pCK3tg2wRmKipY9PJpBYL7ykiiK +AjtnNqlg/PWqM4xt3/E+YOhuDjXTvMVoRfVeOpQvy+VF6jqLE1sbJxWboWaBdA3G +8B30FyGnctvTPKAk5scg56Mtl7pfLxOIZun77myG5XEU0m0bcg/40ClS5noq0bhF +75hduT3tj3JsLZpXwcmkDdoSxiqCnYQ7Ese4slPvlwtRTRJg8Abf8v6izyitXITZ +atuYby3jPoGJXbCjUBTSh/I0B9c6WNPvwm/Q0iJLErGl6BfH74G5GOrwZS2rAIWD +T+msYpZvP99w/wCIqI8YW+pNALDTtcytxRUFfdKZ7CXRzvCM1VTpXhg/FjpcUckb +/MSSQwWrgF58Pe7dFS2PTF4xldgChL8h9gPTsKo+SvrA89T0X5j+W+2NIt4vod9W +6t4EpjgUim3eME+nmj+GwOSb/InhkVF0scLCdylJV3ckp3p/gC69iM6qNr7KIELx +gOfX5OHh6L2RJFVD5KZRtGjDRiLDfu9CXzGBGHNJQXIBfBmyfHS/SAO4unQHe1Gw +gwuH66jdfLHMKFGCv/L1uaqbaYkCHAQQAQIABgUCTc7/AQAKCRBgBCahGPX7zqYQ +D/9RQinwiIvNYndyjxnC2iI5+K/x1d/wmaXt+SH1YJbyDGRKViIQ9x0X7kcx29LE +7g42YEiZ6QM0dBMiyz5JjKnpyljeRRtZnX+41DMn2jyRqoGcGMX4X+Q4vHcXJgPh +nHpi8dFQ/V8yuCfxnbmI9n2/yo6Bf1PKRBb/qQO8LnS83SV2GxpGUMHTAR4KwJIO +9hg9AnQl/6pzlW1VlMQlJ/eN9FBG6JzgyCAFFSPtqFVhoRCDlsDaV6EZNNFwHJpi +2KzZ9G9kipNUHrD0IAnw/DdRt0ZK5AsuXSwOWTIqX4q/a73dGZu0T079losnwof5 +IZ1DiW3wgjfg9SmnYDrJOM+U1TimK31PJpOrngG4icO3uxdy6gs6MMDXn0RFYLYV +SjyXQvc3n3vx6q8ARlxlpdmJUqEq7giu88GoOQR+G7qCX3CILEu+YHQtCJKW4CHV +AaEV1WesgK661u3onIBKxVmJETRjb7hQs3ftspENkdtyeLPGpk8ZOS5pFFAFGuSb +iMhJcXLf0TPdJ+St1kJekLsU33Z73/nFDnK/32E2waqm6dMmOCnPfny8wj0b9r+M +LJyTfQ9X5biIrI7k+d3wsK8uD0Ani3Ii6F6PoeGcsHYuegc4ZqHzIpt4f6pbGFnP +4vRYeqDiW4h2gX7n7S6wff2UDzbYjz914Jh/Lke1SyL1WYkCHAQQAQIABgUCTdF1 +AAAKCRDGOJdNZHktZzjfD/91Iy/Ba5MBLYsxwVTYcNDMpjty2EPAwXth0M6p7Jze +21uY9yNyb1bPVcI1R7fZ0cfDcIKaIQm1kXMqp2WoXUpPwM4E7+QtACWJjuLJEHZG +YsmmdPzdXkWbYT8RrHBSYL5HjV2g69bUWT8/Fu4di95QQJpixOmHvAwG1E4SIMOv +98q4iMv+n6rSmEaVRCuZEhyPBzE8Gwgu7VvH74U01hIRCwt+M4H0D9CPWTuBKJ/Q +/t0igzyQAIRXFAU9iCK6Hvklm6cLmgacg1XdWhPXmVVvu73cvaSFu7D86rXcC5ci +LyTcSeQomzdSKQS6P+3OGTPVuNRQySclV2AlMY9UEZtusjBa+tSsI6N30TLVCsnu +gYAryl6yFYbL+OyAD/+68XZ26v8eyot0YzO17dMwM8BYcGkYBI0JMEKnIpfz09yG +OGpdGV0VuIwik4OXkJvx2lAyv5VdT4NocEJs8quThaQ1QcBt/kyETg5Zmh1zEoQv +Uji8eVMS4dQgf7AM+WQ2et0gjxu00hMz41aHzRwrlZetORi+QmDH4cH4KYlBv927 +3SPkIB17KiqVST5WTRoyuhWLB32YzQ6WLEYZamdBB8Wz4XLdRNForYfgbi/h01bf +mMo0wq2ePsaV+16Xz7pbk+rYDS7KdkW9seu+6CqROYUzizhPnBX1HyIHj0lF50z9 +D4kCHAQQAQIABgUCTdHmnQAKCRDBJjPh7gGMk/1GD/9AKPVttE/ikscY7hOPWznw +9u9xfEvCUlaFrf390UBCHPQNx92pCf6tfcyOWhjl93NfKyXdHmzFRojo3ElgMFUf +zlZZeszbXo5Kcl9EPSigTVzSFm+K+7LzjaanONjougwIlQUokRiAj9t4sM9RLij2 +ztpWh2vxkp7GaFqwA9unRPDFnmwmQZpUbuOCvBOVLRuJqfO4NqXzQev2EuDHLs3a +5BhDsxyvVqq1DJD0ob8f3PGKsTPRwrEhk1NGKBO8IOsxHDS31wdaHlK3IiRE/gsP +DM+xvnxYn2djz6M48qM0UyxAu2gBMIrlLkeFoC7capf/SOEbhNfel+lLbrUABOUo +8Bs6qOwseI8SYeCCD3ufqZyjX6UlH9hRTuvXlpXICzXGx2NnTj6/nvEaYW7J5yyV +bofkOc84oYiGrAATekTYWN/VtpY1AiYLWJX40y+ci18ZV9EVob35Ehwwz+ELaT7L +uLCh5PH7D8I8N4JxtXR3zAS3LF8qGBEcK+IHw8cZsga5GeJto/6YeUwoPndJbSi5 +3QlZrtgBCqJC1FgSx0LPoR7bjARBR09WA49WjgHNSvziR8/4Qt1+8hDX/fwWAF9n +FKVuK0FpdmSkX03T5JVNoA+HiXiS8HRBsgsPJs4ewukRMSFo/nH1tD8DMC/gX18x +A59aGp8kNvSawbp2Frz124kCHAQQAQIABgUCTdQQpwAKCRDjUtXFHFBB1D5NEACq +GRz34/+igTDUidLOdSJo1jAqdxUq1HVkWA+i7WxDz1EBQa0d784A6oaKe+TyMIzD +yICB7z3x1bpTIesU4ivpbGEpMiorEIQHdqPwXBVtH0ysC3AxcdWKjl7CORNYYi16 +H8/oOEIWG+xbG5hrzI56dxOfOvOpHSUqyth2XR45M6MFbtz7iQnVleuHqHK03FHj +0eQiP/7RML3xHVCn0VE7OSkx0I27UpP6gA9Rb5jKdOGN7rIJ3oR51FjVYozv1Ul0 +PNQB2Pypc5BZ9tFY4Qp4iFvvcg7y/b47o58+l3B/qZ2p605YIlXK3m/mSsUtEfXS +bIU1778qOUQzi50WWL3ImVy0O26T1AgX7y81fWWC20eH0WaGvHcay6pYFhCB03F8 +8AKVeK62YEvVGOfTmesLZuladdVJPxNFnb6SvoO9wxJfX5F7HPrJZ2yRlCraBMsk +5bUPfAOjzC5W4AZEJi/T4U5ixJScr5Mv+zHHAEHn/R60Jcnx8N4GS2jywPZp8BmV +9ET2KIwY/lqS2wnobRQozvfSRmpzohluFmD3WijJopR1ZagM3pyQlc9Ci8eu5eXS +gXgFyjwuIivhlLZJw1tDzfj0aNe+RICbmRH/nV3+FrE1XhsknI/XzjCMPUNBB7md +Iilmx8wvCUoH/cvt2JyojcaFJqMS8rcQv6X2e4fxnYkCHAQQAQgABgUCTMrV8gAK +CRCcMVA8bYZjlvUTD/sH6YOJcBboke16vluJM7i7hXTstPdZdMF6cWY/Xy3YXoaV +BuTgKsJYN/mn6VWgjJIfPUotclh2875fQnREKStBSp+QLjBavHRPGTJrS3wVbx1X +PYhO/xV5obnFUqmr9CmpRfYrjjoJW8V6gMKbDEdSoEcuXChbBtfUOQO3SAZ+RjkS +dtwhjWMwR7JgScLymnidk0u1FL7T32r0C7o2+iA0oDAhFLD5Q1yisEUS57YLUWS2 +pPx6gPEG7VhKi9t1roemwPUEs3ny1tHE7wlI+SW2+9MqexdrnYb6QGQfqh3HGvKG +zYgzWdRQc1NKIFeN8WEliXWidYgOnwNA2rkDT94tN0EEvPLWO70pVDG2WLAFwZe9 +ZsNovTW0Tf8mZPI215G/HlClJBaFp5SuihiuFDt6sXkNNIBKg0uq6K0pbvtGvrMf +XqH7lBfSNcxZPzpsV33TnoTIeLrKWt0JE2DS8nXUGZ+7HE4bnLZY8yzfmWEi1jp3 +P3B5aykyREQxRBUhWCETpSVeqvoHqjqK/oTg6GGnJK7hSQ3r6WB62w6vhRAgdad4 ++mcLYAVYV7zfm1VhKvLRtI9Z8lvBtgPfiz5d4S6t9V3R2zjgzvEHHe56femLr22o +RJJvAyYdlOBZEmH31Esr0/SlIEnTvDYsQm/R83zf4b+S+LV/e71Ub6bCRYLiB4kC +HAQQAQgABgUCTc0pLwAKCRAYs/UP5ZI8GCBMEAC6cJz30P35M8y3pIr8mOd9kOE8 +jyNYHtYF4EhnP/Z7sXRtZHg1GeRf7idh95Z79z8EGd3mN8NqSRB9oBV8KTv7A8q2 +LEbAfuCU4Mg65lz+Tp8Y9rF9Y1H0oGFXl/Y3e/KpUbtuR3e9T/Cv+ZF0K4Swf+R3 +DvDS5QGo4PqF7q/2tQ8epzqgEJAWPgfMRF6kNG7q3bSNMv2WH6cICJG2pMfDd4nt +aee512SPH7h1WfGAJel0DN4j+gc4KW3RGxQHXLWO/S/0PNn8o65vDDnpzt/jAH5c +vdaV+hrvClun0hNNwPQ6RzbBOt4eqzf0lLI6Py99670GK/x+HMMB4r9/r3f5ktEN +J/E7Qu6/bDwUoZiCOw0o1khNYRjlqyiWqRB64anrjyPkbGtEMAe2v2wYWECJCvux +BxFwwK4GBeukfTf6DWlVwENNwt7LtqHlAM++BDR3VQrwhH7qGOEDzEpH01dTCwM6 +w/tPbX5pkzFCvbfPyP4Hjn6azz/JXmjCeDKV1oFkQzQI9LhzsXOSqzwcT/oJ9a+G +V0MrSho/s0IqoR8fOBUdppTR6biv5/WgS0I+SiS73Dxj0YHXWgHfQA8SezY43S5A +8x8itxG3PfiPghfVvbGeN1zOcAI8Mn6NjoMbj0dHwyZhvd7WzzusYJAgOJQ2BYuG +GOZi0rfsnIc5D3RUcIkCHAQQAQoABgUCTrK9GQAKCRCXMl3Y+f3VBiBWD/9bXpwL +PoycP4YDu6kEZ2aZJI+kwmCO8e5ln3Jw0G52PLNNIazrGYeqEzNqXaQwi86dhnQ5 +kym4MMcUhEscE2Gk/t4o6quZQywJQBXOWIOpmEZF3UghmXA0PFAwqL2TNos7jEJb +5POzlq/ONiknKZf5sF7xyhxIcXOL1b0bcefhfJJO2g3R1U6DnfujDgomtPiRscGP +M5aOs/6ZMt5FuSRZEeaTI5mr1aYHDfZgygaW8OkV1gNMpQSgABmJDeD+pFfgDNLZ +ADlVceABZ0aH+RpKyTwDSnhRyPGbD+/bLp7oTIYG4mUiR6r6x6XioyVz/l5KHM5G +rEHIGV/h0ogreKBMxHmoa5r5TUGqfCjtOPMbyBDR4+g+0Wy50b5IBE4qYCcgCHxk +LXilE+QchSWpO64M14B33M6EX+5Fcs60/t/7WhXVZxrjCzSJM9RUSPdTWr8wuhi1 +dN400WK+Qn9QycgpvI87Ujk0ZwSOIYiIRDROsLnDLKkNSjhBpDkDn+M/Ribmledu +3q0iXJyr6lkLGkGJceLKDNHUa8Ac2xF+0VZeHem+HoUlDPSgjQyHDZWVWdw3RZGu +VH3+eWGehp6KIAkwoa8Z5paFddR4mza221yqCed78N87nryXrkaToWG1nH0Z3QrY +X7gxk3GekgELzVSCd4ZsgHRbqM/BdKlYNv1lO4kCIAQQAQIACgUCUUe1TAMFAXgA +CgkQEl9cZ9/pQIQ6xw//TNtjqHhQGrb+rlyWBTMNxU7XfborsZoujDBzy1JFgs2z +MKDvOvWrXFjN1TfqAWSA0GreSo6SILbEj0zOHqzbbtFudJvFV9Bfg4lk+LADldkk +JmPX1dxJ1yKU2ANHqeQ7kHGykD4zEHVYrVPmHYCYcCXDAQ2PV6dAb/Twm4R09Q2K +BSRY6WP+Bs8gnlUVJzH89UyFl680CA2Ia3OR04Hb+1fsM/Vrxky7LIfCUBaAE/9o +U1Sk1s1HNDv39nhNuEzuqS/gXbwcC+buJDdvWaJWg09ETKOR2uiCwosFM7haf9Of +sGF+ubxtc9W9UG7rzF85t8BVNkyfCR3Z0+sFjQ6YpmVjDO9vhAAtTfwBcxFywxna +EGzAkLl4S5pvvsRdCFcZR9eSmbFHiNgjjRQGnya6idTcf6gYd2uEzUOASUft3opC +kygmqwkCtzoRuDvRt4otRgcLg8MI59uiC644Nwsvt1Zg51R3bE6TIA3/nG8u+jt1 +ePdiEoYYDwELxMuQZxmDNB4/QUn4cm68E6FxSLEjkePFxVNPIr2gt3FnvUZd/LTo +gY+nig4iN6OY1lHUmkZc3KR7/Kgbeh/gEHrxgMuCa/p6EHEd0cltH9EpkaFOkIyE +aUzQnP4dPmJXYAVTI2LmvP1n6mcnklAahJZWdVwKhCF4df03idiytgQtBm2txXGJ +AjcEEwEIACEFAkoLefACGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQEm61 +Y6dLBr8iww//dMgObbfQCQ3z0Yl3h7L9tQhTNlNtHV551kAMksfVwp8vpvoRSaCK +Y9h5yBPDvLX/ZGqOY/nmFJOdrSuwF1I/GLriGmdEUqXPZceY9GvV+aGmqkiVkDMC +p/KNWWrRhdUjooHFlJnE1ZricWCpj54NWHrHi/uS/6vGdBd0MUmJr/xf3cFBV5Yk +uvAET2aW4lrxhaUh3lmSwAEYNGcbGcYglKHMHhV45QQYEI/71uum+SQ+DlRydlbp +WmU4KGNmQzEw8GhNMfLC5aHWRspEb2M2O9uZgd0pur8rUnQuNARvVm9GnoXUoLtX +HkuJ3yW7WOTxfwC9uaiIakRBZJ61ubQtwQNe+2vg50yyo/mbrFXB4BUUjXrukwGm +KH1jTK6+zoxY2Q/hgzMdh2547NmQYuj5PKoCjJd/PisvZT3JDfYwvYxHvpSXW2+0 +3x06QuLaZkliZywtQWo4gwfG++CXc0QgjCo40IkWM72/vyuN2zlzMrym1njkEAxb +E56bgq2EOe9ztkWM6g8MteDp7AtocvQT9h32VowNvdze1zIEKci8mSJ59BWFLX+A +Q2xWB63Sr8usKwZjhHWxWjEOi+Spu+03JS2CnumOBcSMOkazNfQN5avpDaeoqMOh +qINpGpC7GTQa5SB7VpcZIoLavrw2n9s7cm/dJrbY6JW9/WNiYCgx14KIRgQQEQIA +BgUCUUd+HwAKCRCZzeqdpBNbOIs9AKCUPs+UzhwYCs/S4y3/+3iC6yK4kgCgmwHc +q/KNbKJBvv6XgCdC0xKecrKIRgQQEQgABgUCT60ktQAKCRD23TMCEPpM0TLyAJ93 +CecXo3fv7MOelbNZNPDA9yye0ACggFC/bEj7xppVsmMksw1gPSqkDECITAQTEQIA +DAUCU1W+rgWDB4YfgAAKCRC8yx4nMXJi0nMBAKDCBRSY539ZjtgbKDJShWf46VcG +pACfRUI8+b0LNJgQ7VqRpLJLcT0kJlaJAhwEEAECAAYFAlNJj34ACgkQBMNnwhit +1P81HA/+OGClKXV81ycRBEK7EudDiVFq4woXQv2T+V7q/4vJYZUd/vvprb2lLUAg +I/GexUGSRsCuIglOs31pJ30NtXwi6FCXT/s1UnuWUTdIPC3SM1kzo3pT4s3EwZC0 +0vVJ5kXNfJoOTS0PpyHS5soAiHeni8w15raxNleq6Uttk21Io7i+VgpAZcd7c9he +YtUz4lGApojThLMmnpx16uR9bS/tzeUbRmgWsjXCLuHi8P+Mnh3PFEpMj5I5iOC+ +zVNcZiV8NyaQPEoZZYfwLsxqqK+ANg0vRE3PaoUCDkVs7lXJkpSPClU4ILuuJlcb +N6OF5LiJmmnfok3w67vHmNEN0A0PxzvcfqdLOa9gekcuCQrP/UHU5CJ5cVv72YiM +ic2Xs0EGZDJ5onPdRzty9frjSxH6oFxA0taVJ8z2ktIgXDSLJ8gMxTytB9fcE2CU ++YCcrKLV5d9VPzrZ917cB1bibOevxOsXZiv3rrzQfVk1H+/lK0a6jkLbqz9j06Aj +Z+U4h5Rl1neCiXv47TLlALZhGHUldFdMJwwNHMFyDCdjxogGPwVbe9U7nzB6Um7h +JenZOrGUY+tZYLz3kJbjjrll2zbbrvCijswTJzmIOwA3QBU62Mtu31/QOCyx15jH +cxf1Yn0cvSPPGuh7e27+LUQEe103/FoNV225xw/tnFG2lx2U0+2JAhwEEAECAAYF +AlNNmdMACgkQLqdrnCtGbZ2NnxAAspqQveodz3EGG8FZmGs0bboLFk3NYdUd8sJa +bNzFlgafSSLb/4aj24l2NTqm7cryEbDqCdfaoOHZ3ydoIQP9aLOLfsn9mufGtHSS +dryG09+uNgjsNDN5JksP7ytVPJvJbqlnj/TXJASurozXTkC5PEVwTGR5OExVeBv8 +wQEjNQDmXqZejCj1dyNVbskC2Tm2TUD3fquHE0e3mW9ZQo8UqBkJtgjZ8KehsrpG +C+FdRbop2hEKowwYGe+P9nXbUDqL5pd9EGTBQ8uvtEMJNc8t3sP43XFok91ijIPt +4mtLFIi9NiRNh2YEFaWFiMpffTTp63Ti1E3/fvih2wkf7PF6VQW1FQD41uYODLYa +b2L01K9oJ5A33X+UqR0BjS7mCRqS4E5XpjpsPWoL3TmStw09GXd0d6TW44ssTtPM +pqJYRANjKrVLjfGRe+CypaBjyozYLwIPngnqeTbknUYvwg+LX44+pajSYOfJR3us +QWojdZ66U0OJ+SSN/dGLj0ifAXIM/2hpy7NaCthVIvCZ1AThNx4553w+XhF4KCm6 +Scc+vMHFu/IxoEkxf0R37BD4uiVruuZ27ibU6p2Ptcq5WCxRRRCGqqiPhxntOWTC +WuLcER4PIl2/SwQE5ltxJxxXNypQSWSBp8xzqdiFOmSwUNQockhfd4Lb9VFQ+asf +GmN8Jn2JAhwEEAECAAYFAlP7wEoACgkQZJWf6YON8ZxfXA//dcqk3pVJ6UtwZtfl +sZdqvE03lHxrFZ1U6EzmjyaACiYbAXSRPTWacWUwJXaZwSNGm/q+fhqnovJ58NDL +ZvPgbLCzvWrO+Z3YRNwhGGnS1JFnfQpCn5E2qjjn4ZgsITL6ZwrXG6x08tgH34Z+ +rVnGTA+RR8WHsfAyZLTzdKJZ9VRNGHOSgyFbA1oUQAYlHY+HjEOqu0SkqX215qpd +zA50ldf3wr/NNlhTZy8xGLV1Pq2cW/+F2vW3D0wuojCvKq1srzuUi513pKAooIi3 +FXQTRtpGjhDK6Zn2NTA8QenufqhLgabzz01kWwB7pmWz1MPRRivBSunahAShJ8ia +sLib0Z6nkR4cTmg0C9DFz3mg2sl1ujwjLNNVSRrCqxT37Q1TxcHdZRSE3DFBsDzX +x8NEV3FO0Z5RxcET9IRQHpOliOxLnJFUJK/XR1c4odJ3NUdNI/HWM6CyqI6VfxO4 +x3yqPNvA643+ZnsSc6McCIet1qugamMQLLge+/AwnA0V0X4UrTuUurph1hDlr9hM +A9yEmAWwfnHXLvag5QJRgQ0P0haILjGS1+bT1+aCzs6WvdIZrRazwC8eXxkUM40M +KVrmTaeS4VsIrj96K0D8VSsjsTsY0wzpe6nvc9qD81/YwOmYl0JFmxQYw9M6N5yh +IXyr5d4KaNEQ9nC5W1E7kTdm/qWJAhwEEAEIAAYFAk+tJGEACgkQOTWH2X2GUAsD +Tw/+OvWt2H2SfSrR0UXyo885XEEB7YCDhEnVrxogspNmltcBhnc824oVzx5MvN6l +kKsxHYEx6lHQxPyZNG3Dg8dAFzU8HEoW09xgDfiAjT64fPW0fIGBm4jROjhw8VLe +/qCPeBU1SHcdiUHPNz3kxIoNeHiiIX5e4WeXCK8iYhiYEmhlemwVkOCEP9gZbMx6 +GaRybGjcLaUMCTWwiAz9CN4t0+dR5a72CrJNjUNd0CaFHp0DK0GIPDXIx2lLarvj +nP7x4TVnwZaitvTy6MsOVzOxcHQDaNfDw1O7tGQ4BP/rpwJru3D6Y+q3tZDn1Li6 +Frxjq4UvbdUyg3ju05CKU/SoRPqTediXe05AmnoK0FmIl60jy/ZlL5HUZDvJD02m +98o4rHaf5ge6aZ1tPDsc9Fd/SEAO4LdvkbIL4U72iPF1CWoMeaPzCvBWZIW1Z3YM +qswU7bUlFlDkDMHwW+qeXFgd+DrBX48U+PgS0IBfVL4prZqxLqN+2OWbQ4WEH80q +Vvt60rXwOJI+X+2GOvrkgpdITMLg7d+UZ/zknWw15FO1lddP+aWGTu2Pbe/vHuzI +uRie06bHTribC9i+WdIdaHVvpJAv66J7coOJAnWaftSeKf2mNKMARmJVpdvVT89J +rWra0vKlVb8mapERkuBdXrgYujJcoFKnEqhocPStfWZYLdyJAhwEEAEIAAYFAlNZ +zZIACgkQvlz2h9xat8I6Sw/8Df9X0xG+yK/QgccgxFe28NZEo158bJDGou1MyI6R +dv4DRyPGFSbWEZjmWk9hyECmRKxgPDbP7/eEYwUKLjcXgOzrz/LYJcR8yK5VNpkP +qydoqoy7ohIEHicUmvZkpomQDEhU8JkkVGhGXxMA4U5b7xqWJdJPi4j++kT9oSpG +lUUbkiXBcZ6fZeakBFGXwLs2JOq0I7ouhKIQOZi7Shm7VKpoqWX0OPBEOmcCXi0i +0lq4CaNyX6VLZUYP9XLNwWZdLH/j+VnE66FuL0/7QVTk106s2LpbkO4qVdfTXvrv +REdKNwz0B1PAnc3cKtGb0U6YDZlxS6UwmpWj0KT2ANE2wP0Ynr8RTZg8xIl1FuPH +y3eAqklkW/l01831xVKsj0AaUNM2NGXoI8GllzuJNgDiDTpgBe98A2DawpSMpqOF +3W5ywV2p+XLqUfw3khd6r1HgFT6mJlG61gRywblbGfcX/Aq3wGo5xLoaepmSiGPO +TRCHzDhzxH872vLxaiwNUlmyJMPaudiTEUN1rw8RU1tNOjt8nuIfzVNaFhaswzS4 +bq+cgf5fSlmhW9JV4Dat0qN+sidUu6crbaVN0AZD5oaGfW/7/wNv1nwfbcUmyVDG +AVoIOgM+wSpDzgq/1NG0kUup1hmuflr3Gldok2vwUKEhSfb8wi1qFx3jEguhp17R +OkKJAhwEEAEIAAYFAlQDssIACgkQZzoD5MHbkh8ejA//SnfO0oURizYM+//RqBQ7 +n2dFUvcMQr3YQmrjcc+/SO6/xiBrwxRjn4S8dDhn2mBKrFypT5hLtkPxgpzLLQ/z +Pb8+gV4jAKGgSHOdDis1y9yuhTeG1YZLu3ZmCRVrcHahR06MSnRbhEr/+/4QHaGU +Wcu6PZRYXnW+RP1uSXGUnUbRWVAMW0BdK1bNqkD3bS/WBALOOEv6AHMN5l/+vZhC +jb1yPlo2+cnKLJaQtC7LKKU2m3PcUWXGwwxeSPsIECvmKpkehETYK80ZFmXIPZFv +ZwzlvA4qmoFg0mWbNmludSGATUmGR01kkT7tJqfDp3dcquQLijvQpOjwx+xWoFvb +MWGZW6jS6f83CZdmNtlmGDnf55ZlO52YqiwKIyZ2ZuW5+HgUux7BlG3Zala44Y0p +C/x03DPFkt69FFaHSNHM/DrtzfeMYm5Yivumsn4hZMc6zpm3T2DZFNLtWAHB4tUQ +SPz6cDvQrd86/kPIpRp88S1/mWIvtiAEI4f0WzAM0U+mzZhip/qgk1wVZpBYdQ4m +fa6Sua825t23YY+Gnq6NZL01ZGFhGRQMdA/Y3uw5S+BL4CCTNzmc8og7M/htApyh +UuO0GfLulHd5VhZdYbprjvjiAU6vE4zf1oYa3w+g/S988mnWWmDK/NW2eR1c1qLt +u7qvU3LQsbW12t5EUmiJWiSJAhwEEAEIAAYFAlQFHCYACgkQwPiGTNo9A1jOQw/6 +AnA5tTlOp6jbLXDJArcJRDxJd913CHxz7pE/81MzAxSKG1619yl+wgWMkWgxd4gx +aITPrHEX3sj4Ad5z5yf1uVOS0WA//X4+yBn+nav6Ad7XaYCPzm/G9Dx4pzXjyXsx +OiZDUnMPagz0hbzr+YO6rXKu1EFxooRqmMejG58siq/XIE6ulEiDEN+nHejIikJI +9keHxs5IrIE8A++s6AO1jEF7l2JImVrcZcObycKtdMmfjgmOAVjxul+jgoC0bq4I +azeG71fEv4PQFoijIQTGYXwCRY/FUEUIVuaW60feRuDVECdjbTMxglC8enEvNKye +d36huXM/7lMi9tRmwE+yhc3gLppvx3C9wgjJhB/8nF7z6RgvY7RHwQxeqvzqxdLd +Elme3+AzlJNrb6cCeAuF7DSL+W7wCPt8jsTIBiag/kV1aGFSk2zZcH7fD4+RcxnH +XRcxwHSF8blHgQgXUp4F+mWfRKz2VarFwT3ZpJppwOeLbdXbn+rVpRSveAXj3HLX +uOn2t5G+jLl9XFvVLw3sOosVrRchjoPPn24gH9y9jegD2gbJOOtQ2QWT3zFyisHn +4I7/BbHcH+pj2IZ9cdhGNaXfQfA2Xf2Sh/jBkYU4/aCzYs5npWLqLrBkex48vSC9 +tDmCtCxekE3Nph4umbqZV8zt3G1tWHa39uXrbez8pY+JAhwEEAEIAAYFAlQHvuQA +CgkQO1biu9U/3LHYKw//eEom5afIvQ+x/t5QvU2NvDL5IITbeenQgYiG0V2VAgCa +Gw2JcHEwLFyp2pAdxpBIJrThg6Tzq4W7S64kU6YkRq7FT0C1Wo9v4UJzuHv6DjKs +Qs01NDupHVtbLGbTtFTqskGhmURcP7pz5zZXJM7QLqwbGUh3hIxwyNqmlaJQOTOj +6oyorekSPzpwuf4ETGUtI5REJRkriXMXYehNaAMHVk5zIGhVmM1NTX7QHdib8l8A +Cb7OPCUdRNPkXNQ3lx2e1WQw24NGi5ADd/QHPTbvpPDhv8oqGzX8eKW3yWwHuAGO +VyFnoO6/NzRfy+EoaT+eLs9yS74sjyxLQ4pdjniewfkGzXfUA21F4B6kXElcbg2z +Q9WTJl7kvpgBH33l/rl7cvJYRgCZ6BVebAqngWDx5tVgMRRy+IyyoSxAb61dGRbt +uipU7h7NttgeCjuQZ6W7RVDLWCmToAqvgENSFCpUXINl63zCRsaE35ibmnEmU+XR +wHqL4NdFe8alg/zt2tEK1ydoX8BybbjVntrVpfeR6sWhNXxMZSVxuOFyMgZHxPF+ +enbcDns4wWd+/pP7ZCe6R96R/CUF5BLlBbpNJEhBIrzW1O7FdnwnnPVgpWOzy+Ip +lPSKzvlqeYIbTdTcVt4MpZfXf+BZFcd+RqU2I94n7pdlceDmjYpip0B//CRBGTyJ +AhwEEAEIAAYFAlQcL68ACgkQ2SnymSvvCjPp6BAAvagpSFg85M3gdkTlejpH40WN +OCeklhW6zhSiIJNBAxuXj/9TXKdbvS3Hfp/1kMx5sKhCww31S7JRv6Ji+yjsY5B7 +jr9CDJ238QspnDUCSFZi2R/r6mVzflr7dr/AKZ1tdt7qlsCUKyUbOgMju0e6gY4x +N8ctjb46KHZsrmQjVjBS4Z54sWPr1j16QvvGHHgfQOl2OjTogpcWH0CPcNwyzZdZ +JtJRJRvuTo5zpSKrDD1L1K4V/kWwBF6SJYZy/CqbPuqUlgu+rZGb19fn7RqEs1MQ +2WQ09amIYFwdJ91pgf9h7WBDsjHoxzBL6FHO5CMkidULt46U9Tb+8oqzlzSQxYSk +vkaGO23121j2HI0RVSK1lt6Wdqb+wZSO/ACb9yGYw+y0zNVEx5cg7iJ4HTbkOwOg +rOMuLHS7gB3BvNZ6qUTTgL0TMaADHVuthHambhPydVDmwmDk2w4jz8ahcbAZQ5fl +OctSr9SxUzs96QHkTP74E6p9BLVv7l+e/X44PK8a4gK8izoql/61szDq/tMM/SMY +HChqh0A/Ap8KrZJFM1mfZfamKHsAvNrowsqlQ+R0w4NRNCtA/67NLuosoK/B/510 +VdyDM4ZREiNdbKbxAd208mYhzeBbqQ7Rpxoh3ceKfNLcMTsHN5FO+JPzk/gkW/Fa +M5EP4T8ijydxuSHhfG+JAhwEEAEKAAYFAlQCgzwACgkQHnWacmqf3XTnyhAA0y8p +PmpWdaU1DwwEkJ+f5G5XaB6HNY5OSBZ0PV5cZmE+rxVpZD18a4XumMt01cqLt7xZ +uKQ09eQMK1NkHRUbH26fDPcd7yt1z69ifb+nEosAIwrr2QuqrGMIcZSsxnXVJmmM +oZ4lwYF8aIa1WLDNn6BOlhRvCashhPRmoNyHFjHVsUh7HY/40qDc2guoEKlgyZjy +BaWZw8pTa6JIluim8TJ4VhvMbzj5tMYM1+P8pctD+KtBcDFGOzcH2VGEC6043bBC +0WvXJOXHSseBuA1p9Jch55EQr+h4Q9uvmjn9IKrUBbN1dUJPklt0YtX3uc8ErS0t +0xHkyaFGSNY4dywhMj+8SBEbdAr/kwS+P5tdFud2L/Ww39lXMSzi5lyNdZ29J3Qs +wPCCfB2yx2d9E6Pj1mkgw0IjJ7eIByZy5vkBj3IoWSrP2KfCrzwypUg7zbZZit63 +ahoGPf10Mj5AAICx8UEk4ZzsgiVZmiHmOlxLjE4z7lNLTQHvPj8tCBODQgIVrofG +hjIYoN66Mchw5iSmJGC2OC8BI2d8lDLr69BigHw2L84Fti+DWmxNqJcaB9CRgpnW +L9Nr4OvKoV0OpHo64lUhbx5hJGVQ5SMN3kLeN7ShgW/hCllc+RuggSLzNh27AvZs +ig5+J3RNrFE49QteUZ2sSwPyAsJtgjg8XeZTMPmJAhwEEAEKAAYFAlQHN7sACgkQ +A2qcJb81fdRrkQ//fB3DhqM7R8FmOAKBmO3RVFWB/rhcKWxS8lIENIHkmDeHkCLP +ZFn21xHWAOUh4z/o0/GArdiaPuXhv3qlZGBkARokGil1TupwRgnxV1c4qQJARNg5 +E7HgKATIiWPJNcACDW3TqkbyepQQQrPGUpAhszWznbQQYzF9jDmcfpWeO1R5VJzs +9KXhdY3DipemIc8zTmh9drufgIUg2a3vIchW/317GVzSBd+xU/ToVFsrgONT3TJC +JgvXKfaYhHunCHQ3fSqu/ZUMKin3P3Bg5mxs5dfbUBvMqkH8V/QfvQtX56twrR99 +JFNln9lwyriwUe2NFpJICfN2lQzp4E43hD59xeltqCaPLs1IhQcDDiiljEYdyQNn +NhtFlyuLh1Wm0aFK5W5NuLV3Ja5TbyUKJmnRoEWiNUWUOxktPRm/PIHjw2dlhXCE +wgxS3UqlCFtMyEL+k3cHvmL6Axu8vJ5H6XPVUDAIEvUdOOvPDiJVcK3N3r99WqQo +xoyQy82XgQnEbf5zfrwmCrO28myI4k7SHM/o0P0qOrPumWkzNL6C1DnsZYtW3Hrf +7zI9zwiGt3ww9haxeD6TYZBbPlfnRTPCEstOuHShWXvKJvtj/AuGo8OLcQTkxOA1 +zPogGFe0yHFINise4FauENMZrWcVK+34vxJUEuHitu3ZVNQqIf6VP1f01VGJAhwE +EAEKAAYFAlQNGwcACgkQdRq13aeWecxnRg/+LSfFep0PZ9C6kQ6eFTZ/PXFQmZgj +Cu8anrPQxi70Grlzd1ZeBktUa7xSseSdmaa3WotrKM3sDH0ZQUc7Nbz1KTpyr0lF +r9UVQYcQBBnWcn31nJb45QCj2ddGOklzQ8RepJIAPl+AioeG9p34jP2kg72YKLPE +dx9IeKSx2d5VWpD0mUnd9btuEmF5Nbscfo5P59UuA7u35G8nTr5oJllrTkvpeSAy +gyTNhAfqumblrt5MQYOKOS5TBBG4Yk5jDWaE8nWWCUUZMY/TczMTdUYyRb+JXDWc +bcIwbC5vXdOT/heebmgxeXn+I3kJB3fvP0UMl59MWdyH5Y/Jw9fV5uX9hxs4wrWh +zPdnR5DefaIPeHDn+hT8vWvZIJPi+NCV9bAHj5pllxni4KTQVW97GIkZAMwoJjVl +oGYA2fz6SN5HIB7+3ikYPO04jy7E1h3yrebS4SuBIRA/IbZBUWk4MQhr+eNI6Eh2 +9sOReUy28fjdHDbYTS6uJTYIIlXMjMknw9/XJcCcOLaN6s46u34U63boCBltrgcM +ssLfBupwpbrDTfdnuaWT0FLd4sqiDQRi//LsAHp+jDX12x9i0VVZMWiVENPkkEdi +MWYPLdoWtiKNxyzVszMaUgR4gVOTELqKQO8lKEIR+lncNa2fbJ+vmLkGOZa07ls7 +jsW2ylJwHEdkEsWJAhwEEAEKAAYFAlQPVewACgkQbmCLY32JZ+lkfQ//WyP/Lx3h +5mchfZYGia9C4X+wb3RE1N/+vcuT7R7sZ8BFEdxP62Iqpr90hyT22+8IMWu5evyi +qN0FXWQS2y/NHjQ4bswtodyN1EjPB1lrmMJugHau++eRjVeirHL7YYPwUTC+Tp59 +0FKdeanwkcIc/YmFJSpBbY7iCvO2UKB7LgbGL4GG6y9jc/jZ7ByIXuqeeWDfxg98 +TbaS3URxhd8Gw6tzjDDnz+PdsN9c3/xmivwYBSFSOVYxBrNgmjDxbA1gYqnx6UcF +zbyzEfN4z3BMLiABvivJk8qSMNYVBdhn8fgkdR38p+FZY3B+s2Oud1PsNeDHXJZi +94L6ExiBwxMx2jTvruMfVNHUOEsF0Q38s/qLbWLo7dY0lOmnQcgmKXoFQIpXLoe/ +zlgpsP9McKr6IM2JdydnhnA6c83J+e4l30/ubSXEpLOdxISAelmIAScEImI1D0hF +WbbD/4W2ZvV3siVmArnaN1FNHD/K01b89ArhoyzUzpaUHyssujSnt7+iuTrGtgfo +enYFU7SALtJDRTxbo3rQOdW4Gm9vUtJSaUugyPGPVfHGMVs1nRVraP7SpeNdAnfg +h3M0cgROzQ0f6etzfAyKNSnMrIZXVPjtkiQ5wN+nQO1eKyzy1MoLMD8cym40cVim +KdffdihnlcNQbITUdFFDQrFVk2amn6Hhb4CJAhwEEAEKAAYFAlQPZbYACgkQ+z0l +gztqr/iEZg/+LMT2LTr3EOh/dtx6OkNlSli7DRShQomGDHmMqWI7MgP2B4sa2lJb +Pv+00kJOkP3fcQxNnBYqmsf7EfAdY89SY3wCgDdT7O1h9rlfbq88MQQtmrBRT3FN +wmr/crxayObQvYFbnPtQV9OFu4TnKNEx2JNfCW8uHgvHyAuuTOEoX5hBSxt1Nih2 +f5cZWf615Qy2Qx4RT5wX/KBoG7qBiTNpfJdujO/TIl2fnvN3TLehvtB63ZnfFs31 +WlzXaKtfKN9bv2gWJurCRs2hkQXLttPr5hmpNjCvF6pMi8rVU/Z1jo5UIQ0MVK5+ +l1c6D9OnvQnoZfvZLNJ8gukHXU+yhGWpxHgm7TQn6LCYc2QeD+Q8n+E+PCuWfnkC +ev6MFkKL3DgoGuqmiQR8auZhPLNXzQcmc6uO1LMGAVaXgHentlmJR1TgVuquygsy +4FgFm0FLN/9gMbGY8xS1IUo2EI2C4ZbtBjiscuUuB04fgXzzWiugebDzRM8BQs9c +rckuSYsdLi38BlNya/LxbuVy0v3fQeaxiXIaewcZrgtX8OJnGqOpafk0Zn9YtNKM +PjNhIIO0CdzlL/WuC85gpqyQ7xcNut3mBptbGAQ6g9h5BZ6pGhefE2qoKDbJCcN+ +/6VxgdSC28SFmc6/FSd/qiFHjg3izQMJDoBy2MFcr9OTFetqA7NzgYqJAhwEEgEI +AAYFAlQAsYwACgkQT616dThFWdvqnRAAko14zKh7Ggs1Kf22VkeUBtuIOUbSE9it +mS1DG1Wlcw0jWFsFACaazkXMoE5pY0dGYyIbtEdiciudS00Co5JFxRNaucFSzEHm +/r/xZnUV7m9eM1J1UYCERHLIY8i6xoJRcx4wrU0o3pdb7VBu2F9Md7aIueJe6wHm +ZkAmkR6THHQwBF9JROBrS/rqoKlgs2L5CXAuloQtVzVwoEDT+nmVn7FfEweKqeSn +KaGOau2nd38ipZ/XJ2jXE6yukTK4pjnLnCAOeD50XLpzl9aqguK7wrViUzi52pl2 ++Z4DfJRX8gotG5mkatCjylYD9ApQs6KCK9Mn9CqhUf/ioMsbXOEqOc8BYMCM9e0z +moC/tAmarbGLJrSiuTqiwcg5DXadd3jN/URqs6EgKUTMRAzmdw0cDe/BQW238eJX +yCwNkOvDJ4lc/vmEwYT5R+y2L+WccdElMQ52aXsGJUiGtJj/feWImCtgHIUGY8jH +3/8tgshplJi1t32uhSLgsN0a18f1FL1l0O+oVWIkcP2/HtNvuBBIJQ4MqqXAZOaT +8ByQTU7cMC3nXvdO+yC+26lUHjPg1U7sa8RLH256Dfzl7jqkvs2YgXqUbQGsEhKE +BApYlkj+G3OPoBNwRBcBLIlG3O7gb9Ri1r0TJVkdwX5tn1XvA/JiBWTtSjtBNn8H +ZfziOehKzjWJAhwEEwEIAAYFAlQxjv0ACgkQiHtgYYs8Fq4hZg//ZNPAJlCzIc9n +WrBcKpfWEK+0h9KJQhKzRdfV09xIsujdNCLJoqooPyI+a30lZohw1Gz1Ik+R2Fu7 +tauS0ngImoQnuCtcKFaeBDiXk5vvp9Qx6YvWsmmBVJD5ADJSfYcOAjvoNViGFB6/ +T06Sp41LmmuT00X7lebmiz0NBTl7AvxIreE8XS7rKjtzHPOJloONhCmTFtC8fcNw +KT3/FaDfD32XGszqobg67+5HczImYz2maPodkd/FF0CBmMWtvT6JtA1cti5RQ9NE +lrf/K7nsPcDUxzh5wTfmOP77d15KeHKZqp+Af1aRxPyPHuBR0mposUF+uaX5oxwr +SuAxb/9qEItSDxSgx7JhFEz97/e5f/h+ZEIb9HSpcj1LK8LbMQMs6ov8bptAgGCd +xyACIyldtdkoqjqyCCq9c/N94MuGVOWHu1f3LHS41Ec9m5olBEp/3J0MTVwu0LXg +lHCL4rO+xCxxALxpspl2lvrJK6XOjiDGUWQi1X7qigCiCYVqELzMHvCQR7QOXK3Y +6xhlUd8lLrofia56dV4eCO47g8bFuijEmzSx1O27LZnkXzyETJF/VC5MlWfut4ae +AUsjM0qNNu3r00VSv1FQNN7Hv60Fe6pKksNKr/mterKQ4rnH7N4AHhtAK71hpyMe +tyb7fO4Xs1Eu46uNYepzOWz6YrQwC/OJARwEEgECAAYFAlTQTv8ACgkQlOkt+Sqq +XDtQDggAhTUqk4hPv8WuMpGckU9734hnyZG7+E3+4hWpCaULnxsbrPvyVvsDUUZW +Q4NGYl6FUqTjcE4r6iHG9asUAGxH2URkcFP8xqF+sWhLEL0aH9rcDvUXgDsh7g2T +wQNFKeiwYjAyP9bpUcJx7sXNhBUGE5tJzPhCZ+LhFw+sn4gKJXEgvPPdSPn+Ij6s +TCfezEZYkgHFX4aO5WPw0RO9y6SZRCptrte58XUUUAdFqHOza8pFfTOZWZb7plWy +vH6ypWDJpKzAVK310AsUxHxBP1xXkZp8NjqRzKTcyLDxfwFV0M63cgoZTsFK5vpt +OJAiu0BFv14ZjP2rR/alF789Cbbz+YkCHAQQAQIABgUCVMYwBAAKCRDDjoFgoXhB +/tu1D/9TbD3jzW8uQekWHnXGYKFNqM2i+WrfS9GHE0web7hrgSDQ3JfxHNsJw9JS +D4CaksI+mpxbEFfz1rZm5740lai0ah026b1NLujO15egoYSrEZMKNgaf4da/1c7L +gJIrqV0BeipLN0HeyZjo8m49DFN3WHsjYbS+WVOiSM2LG1tDFZSLeAxf6VW7hIXw +ivW66icJNV5CINkeNIPC5Zo4xiVlcgTyEuhcRiYJ3+vmleQ7E1u89Qm+gJ8nYbkM +QgQFN9S2WX/YTGl6x3XwfwTC/hE3XoV7dRDb5tVP/MWHy6D20xI40AXlee0HRTnE +qSHHjqfaoZ9yjyebQ9YLFTLt2g3fD1B8jwOonOlXnWhGkwKSRqT36/WULFT9BCTh +GeXVnFxNe3DN4amz0jlk8nR7xm1p9isWUARJ8HpzYMdtm0kcTaDoTenNeBQIq68D +lSkbbrCekLhCMh1AfX4pbKKbeZKxv+TmfXV8TmNGEnXBqYexD+Cryf7vr6aDjoez +6M7fVKaNyXJ8PWoDlOBEplmo+snRvvcSTIsv/R2Mp9mmRTndWBw+FQDyMhWweMKC +wTP3+mstXjI/GFAGKzcYhzmuSeZccl1Lm1HIV0u/AL0DPKv6z8AcrerQMFnq72s7 +AdLSCk/vA4U4f3BjkyC8+C2qU7KfQlv1338run3MnOMBGFm57YkCHAQQAQIABgUC +VYAyNgAKCRBXkw2rC4awZ9suEACCJ9DllPOCSsLE+1Za/eUH4b40YyhNhJ25UAlc +t/20JcEfSitYRTRW11wvZvdNnOM0veBBBScUgdEG4G6ujFkNcjtxuCHO83n2m9SL +lQBnB55GA0Lc9kmThLsmK1W+W/X0xyaBy4wfCf40B1KLSJ1vgPFeW3/rIV/M5S9X +LNQCs5urnUCSm2jnymcrylnJHxYCxfXn+xJCjLV5DhdefCbRmCBUnC2wZB09n0e8 +XVmMlKomK7gWEqIngIwWeyfsKfb6ovRBJPWJv4ZVLNOvwbPV16EqJqn42h4uh5er +ROh9RwC7RQYM/c6XzHM0PeAexMelmgaCf9VOvP2kdpUGUqxl9O7PkfNct6OO1dGV +rTPh2PGfPnSJ0szXMpVE4xlEwoNGQsnVW7vTDD9lhS0MOwI9gpmA34hGbj/PTNyY +7bHpWAhSF8pAtQ0O79mTikmHYrJ34oEozXet5a3nHAEY8f3ADo6h3FU33hjAf68A +wyJtiKHpKgePUHC8UR2PL09osiUPQhEf6xAkIL9ApjmGK171Tnp/jW316HDBxbvZ +zDW9nso/DM72dy42Ldh5XvhLaSqCRBc29o9WYlROudth+Hbchgl4U3zXOLtslcBG +VNECOZgbBYlIk5+/FuQcVlvRX0nqGvjQKNxTijHGD+mIoVUn3Nf0UKpxWH2suzVF +nUF2zIkCHAQQAQgABgUCVJCc0gAKCRC45Qh3Zkdar876EACEA1Mdoe7cMLQU28ii +ln0YH2UKw/obdNpN4JKhn3argVWPdDlN2lYpcBiHMJ0fJX7aDD+x3QUend9m4xHL +IaaALC2DXWtPdHo6qS4z5F8N+V+o+ra6t4vaEZmCw7uTBUWo6zuOtwWS0VAMT3qb +FRZ9CuAZerR5tUBb2haqoDwBWrjwgqVvlHmKJgLDmbJWMfoIOhc6HqamJ1UcfJpU +zV7+P3SBPOasDCWIHND7UL8A/kPigbcZY82XGYrtKf4FWSCffPa4w4dtk2WJUt5C +4wyfn1v1mnNqWDF7pmT+1tflBFnaGWM7q+GqKkVZYuxS5BqWdZl2Az0hBLM/aGGt +93iXteCjex9LC/vjw5EdlR/REidmVmMTHPPtihjI7gUgcqn/E+5OLRWFHDSiM7c1 +eU+0tRSONEmC+PPdG2/EYu+vpaq494YvSE0T2I0Xh+rKuW1WvWELj1Y1auMz1EfK +Coxug0LpCpaeIFnWxzDe8RdZ41r1riFu078J/w7/Xcvl/tZTNeIzNMmfdD9hV/r0 +diIYFztmYaWTOVqUUk+gssrWBoJ1WxWBxDEAvkghnhpJYCyV8rnPSJXORJvX0YcY +iGrEFAXi7ikycen6SdK2C9sgI4pOz87r7LSZxR1M0x3kaSHwrkWE6Q1N+Hz+xZZb +HKTDeLsYF7ggnrqGb2f6jLc54IkCHAQQAQgABgUCVLSGLAAKCRBQQfGJH0TgkHI/ +EACelJVHsFlZnksucDAqdoWg7XFckF8aWdGqyFOG3r9nDiQXa6zmYCRAM33Ma59B +nKPAv5tSv5JB/iueBfFNdlbLuTXpz9a8U8v7N3APALTJCDxhIQp+LQw5lQ7Ii3ls +2UVSmYH1unIQ5Aytah94xzw4tokIh3dcbtvzhRU/GU1ZlXOnoNUuw7dbTEYiBniP +68Ssb4obiQzxxtyZNfmREralg+dm1q2lzKZg52Gndoe6BAsYV59GS5ryIYZq2CHl ++A2EdqPpKmujxJ7T2mZ8o1dx6jNtJx6TKrs725fQQdXjMC+R+HVoEpixHRObp8E+ +JCOX+WQZfDU4w7+7hrA8dHryr4tgixql/r7LQZZ/nSVNf6nnxEPYtpe+fdZv60RB +a0lY0LrsOvGWRJ+GGsAg2zr1uWTXzR2POS8wmzUNqL+w9/6KIjrgHnnFUz2NEkLR +bvSFK57ncaD74a+oMOPT+khwnCk+pvY3zMquC0XLgdXlfB6W3qB+ooOCWOCGxnin +VGftFjfxR4FDUrsMK5t8z+VgMVtJCyV5/gV23evsWJ9pEipjIGji55kdWhg/msK9 +PVJX3O7c7Ju8EZzfOr/BsudSnVwrXJ/yDAtQU0gX3Ik/xk3RR74MDKC6ajXmsm0W +YvplqCjUBTIcvyJYQuTd4Uti2tiw9aMhhmgfD75QQJyrz4kCHAQTAQgABgUCVTbN +PwAKCRDHiMTB1FUNRW6XD/wMfh21o5K3WVw+eQdcTEYZlbkz97d2O8OTkpaaOGjJ +yXApzztYIuZsvwy8xQdDKi9jokO3Ex8ARRukUdVOpHtO8UFmKp8CnzA69sHIIVPW +OKMKTWofr2IyYUazNCNhCiowkqggZ/A0rNI9bDFKUpX2dn01tVhwIsbdy7n4LCqq +uQ1k5aNYNTPESgO+q5672jergKZSmzA4Hu30TJPXlPOHo0QarMOwNKmOf75X4OTB +slLIt2tFg0Do/U+JBvGBF2sWcAOBh798iARMwZuIX5FNizWu5Jflnn8TBBPenYFI +o+UaZWjVwPMssdszl6gR7GihH6Uj8c1ua3UfjL//uLAa2qKqKwqz7fHZGHD6EeyC +Q/4yQuwzyZ13rheiEpKPRKP9CFqOZAejFqcplKW9Xxvzc9AgrAX1pueL/tXo0e9o +dd+7yBbZv66DeJlE8/HGlov45R3of2nulM5R0lmvXY3be1swUH3NNxMAKAYXmmJw +SvzAvlkYap/Zqe5SiqPNikhUr/ZDqjLCUZGMFS8U2UojuKesNym6za1tvsBHxha6 +Xo9R4CncVWMCRj01E45q/qu11CkevoQpamfJtanRpaAcbtkYKq7l0nENCKjZtRL7 +LdNFHGl/0gPCVERmG7jFqPy1gOItbOyFUcEPLE9mGESsCyiiKMU8uNDCNpeTASZ4 +1IkCHAQQAQoABgUCV1uYvQAKCRAtNH6mqmVCHU/AEACROpt+JnEcWgUUNxNwbqXG +xMVDYbIzihKxmIArvQtUJMMrJdwBeyCCcEZqVqrKcvspjD51IjGhN5fG8U9TBvSx +Ik02X71CT0ls9Gc3wkJHs3+yoECHr6yn1u/LAAq8iHsdpUhljS8eb48SgUMqzCfv +LTbdMHvwslqTzr6FELdUQveCF2f2HzRlLzl5q5nxYBv29feNzNhuUDJOu1CpQvcN +fzvHVcR5/zQ8lGJIXbxThsOCxotM4SCIFkbZfwF+mnwN9iLIzNF4q8moGS0v44V7 +z+TFIvqBR1psozs63oPfp+pJ+IPdm58mYO9s1+BJGtjz3e+EaeIIHPoR13m9VtAC +SCK6lxW6dYXM9LzeiMTIEqK76m3thZbF8b0DxPaTSoJ0vVRZbO5shyGs2qi7YcTj +0wBTXcGXKFKU2Fc68EBIX0oNnFTFin/1wSL4hLmJStd68OUiqISmzWUDVq8wkdGP +T89BrlWqvVZI+Pq3qZ4JOU96/5lwkL3UyUAl110ZR+GMS14SM2KqjLWN3alw6hmz +WOMB+Q+JI+X0Th+5aAJvCwBHVJfuWYD9Z9TEdT9Hrgsw0iMsEBjOBifJ5PCt/rki +H6xJOJRWhuvR5rpljRwskiXGNMOssBTocKZ9G9Dwg+qppEeb+J9UqMyzoZDNgWRN +mqAQqvZf3uFVZVw1A6CEZ4kCHAQQAQIABgUCVt8E4AAKCRA1LGcgseO5K4fdEACW +behoBT9FBlXa/G8USon7AhuriEY9e0SAToa45IY1ccNNHsB5+9YpC5DPqdt4W1ds +tJHn3T/r32PWeEWT20fR1A9vDAnnrWpDHW1i1cVZVYXNvTDFyVBgi8r8MCX9CyqM +L79dqw1X2kQq5reO+EmWl84QrDPq8Cl7vtKXmcckDU/mxwVEw/UGvAolLKzqA+yb +7vZQB+9wBYHDPgk7yJsWGTkZsOaLZG6zEzvfCIdr8qqoJf0JY+XbbGFAUtsFK983 +Lkx4n6/A28f8rIWQ30jMbYNotzajl7SRd9Ll+PaO3jqRBWfCq+bCR4U51aMPsLu0 +iWN0gL0N7o5igKf1h2MFOu+lWlAA+EXntglDM3APlsVcC2KYo/sj7TumOPsipDyx +TRphA6ICMY3QNAtKpaK4LE/LFE0qm47EZ/rMckybYbstqCLH9oFSr2MauRasRCQW +1/zXrI2e7MZhRyczpk8zBAtz3z6BPweoivTLNqzoFjHlHG65wUM5MkfOnMb8FnkN +cK4Y+5+6DOCFfckbwcHZ3oUqon2zUEqGMPzPEW5yACuIqmHOU7cO90NenaGEXgV2 +lUXk1r85JmHrdLcCSchRnUI3nRI8qXLtVOLTaja3o6o6HAZ4a+Kp6SD7eiCkyc6S +I6iW3JXJlzsSnLsTg0K1tBo2xKcN2oJH/7cJZUv6hokCHAQQAQgABgUCV1MZzQAK +CRAJSwnQndU0bSVFD/9MxfsAp80D82wS4vE4c0a9HjBp6OUFgoPcwqH3TTVIDmw/ +ts0kBQYAJwiGI+tj7Gujl782v/f4reMlaotj/RGYH7Z3s/f316+XutzQyasYjeRM ++lMVpHYZ69ZNK18SPam9T402RgXJfWfyCnjBt9C+YGMaZn4fe9K8O463JW5m8fK+ +M+GV4OWdEJTqVE/35uu8fAQKSE8Xvw/VCUpX2TKXODwanhyxobaFTnXu+cJzHz3T +Rcx7sIPZiUycfYCtSlblxjE3e3Z6Z6v8FhM+3kBSpRaql3OiXAgHBoymZDGsHA+G +uA899yz4pM6Vo/aYs0qxVOPYofyOV7ewaNBQ29o61KoJ3TbVNrD7LHVLVnLSuTyB +AJCLY/TBk/D3okoSW7ndJ28DII8gOg5iop9x1Jhb90iIl0n4cnt0hVrUueTL4WjY +sXmcsFuYHadCw12tZZQ4XatCD6ntmVXFMB4sSewv49R2lSr+yWe3XNudOvs34a74 +DVQ3AB8E2IGY9xE8asgX1yDA+m4/YMonLrtvecYLCrbqVJuGt30LFWZsLW8lfiDT +uM5HTxi72rw0hS9UC0lp3xEkdBkCaEKO0fqIkS+PHTs+n6DQkQcMvyrWQOeDWETI +I5PbLgbDqifeTUN3xjiqPB3LTnlHLmrdySPv3LHpTqvVsRnQY6JQXLTHDekLsYkC +HAQQAQgABgUCV1MazQAKCRDAD74tkhkniECeEADGNT9aXOXL03WpWCF0Qi9nWP11 +jd9e/Ppx5IiWMdFLQdfYV1ENOJD0/UeVjAXPN8hLai++HfucUECAIVKC7ESqIlVk +jexIEs9m+6Ce+E0h6uMC/cxyzVdFzJDT8vRknuNpYu7qcFyFnRE523O1KvEoBzHb +GGwbIUC9TZ4b9Jph3xfpf1IAEGL1Jts86uEhsXnIp6azH9cqccHf/93SzQGwDi1v +cdmWeDdCKiL/UwfCEUUpk/6TAvbru9S9GdfFXJEDNerXjYK4q+RVGY8tHz2PigtC +a1BfeyfQoLKhHUvtoLHftc9qD/TUD9p8RYnsSrEOHyuRFlFceNXdfssoQT/Xc2r2 +FrQ3Hw9Mc0aIFO5um4lrEi3LYODxiGWA7JUxdDCD4pQSWn5R8sVVT4tMjKyQz0vZ +Y97k/9JWM43gYfprCsFY8d+cCt16bxQ8raLfxq2UqcYOx4S+RSRomiW5amcVDqfn +77h/+S5tGe11LDW64JpttHRAhZLLy+mG+eimvOvlwx9Gv46bpeBX7wvQVRcncDEs +TPHbpjdaXsktL81Womr2+VokoM30+c6x4cLrObL+DaecMD1lC2mcJpT2xESPCjrm +DoAIKxw3u96eU09jasuTX4+F2FRq8+1ngljzQjZjXd8jYKk4DRk6klTqY1LwPLAr +F7rhs2DqBY6j51/v7YkCHAQQAQoABgUCVyN+cgAKCRCHVo8VYs1RMuBfD/99N7Po +kyEws6ST/rz/hoZf/6xGRNThurcxwyvx4h9bHXp9sx5iwgCrVk78wuDvttbduc29 +40jmfoFFRtkxmbTbTUensHG0c643ivddY2Bt8l7jhZTQ/RV1UUfFYossPAcU/b1h +NFdv+DsGYgg29N8/il1deGYUCdzDliB4id7I0wTPee4lwsMreDzCshMH7R2l3+ju +/UA6f1jnBgn/GnFq2TsgYvQpPvEEgZGzO6gFqF5hOYKts1ODdU5la1d9TXmJAQYz +pO5/Mz3x6BCXoJDY9Iuo5VVNkeaphPGyn/JQVjhfAM1dVjoWV0KysIhiKK9VXwZc +7OhuaK9uPCUU+4RtTFe2dZfIsFKkPC73v3JER61aXFGFY6vLJ6T26shZGZtrzoxK +P36LStfh5iqHZhguZafNMFZtaIXk5uJ4VIK8uPwVaPao5x51NBUILBy/pjppCyOa +5KcLocmBi0HEbqdOAD/ahakBcHmq/2DyaHBuDIpv7k8SgsDsP48J2xU562Yp9iWB +88sIm/GcdP1UrLPXAKArI7hx/lq+pBDsbq6TyQTthHoCGnBsWxvyWKDz6KjiwKdL ++ML0GkdHstuC9yaVmyLBqSNu/4J3zRCLvnEYDI2evJGziKVGrLlqY9xI9pgt+A/7 +WPHFP3iUekhYjSlR93PtQjFwn2JN1CsUERP3T4kBHAQQAQgABgUCV4EergAKCRC3 +i5CPI0MPgMbSB/4qNXgVSxgqtUUKJRZOk7Bh7G6egtfIg3oFIAmXXzZQmsCxXk1X +lKzBGqD19cUPmLQ6IgjFIG2CvFaVt6ypq5zxKB+dg5oW+WBt7thCfo37n43T7EAy +ByYMXRAK06dO1B4ePbsqqIQZhOQOjmG35U+vFl1J5wKrkjKgZBqmGyIanRXIU7OP ++iL+mwrzLEN6NkeQYPGxMX4jvmVGI4EbltiNCoUt42SaVxxhRhAC8SDPn3/CkI5U +lzrpW8PUsf69UZGfk/k7FjlSIzkbKU1GKTerqSOTBvVrB7paMrdWGQhMxqnpgDk/ +65ZSRazm27/Ur6uIMFXmdjbbXJuKsYTOmiE7iQIcBBABAgAGBQJX1kl1AAoJEAI8 +BeLJwGjwquwP/1+4VtLS8PB42wN8iHm3YDKgmRrPmlMKKTzIbjJorfq2kDMLI6Sz +OKcc/7JtKCyyF54ROIdtaiOSnTGQTcZcac/Em2fGr0IszIjcMTJaYE8RXnxqTQG5 +xINHwL3FQ/4Z0d+5f9Wn4vmIkEb2fdDK92I3q9Z86pA9fI5PaI8bPMlNF6GWmIJW +sA8N/cDwAsxXlmoPu201t+oW+YwJ5uD8kTQQcqgXR9Q+XVMvy5OR0r+4E8i2xSsv +Wns7CzSwCO2ouJf1a46e6MYD3xXhY4aRCl+1r6Gbu6JyJNWVNMKzL+ksDnXAnzdd +jLPmgy7DR327SQh1FoE4mMDzQQUVtYZTZOoeCIfhkp1jCoeoE6OHtUlfTN1e0Z5B +0fmamRIiWi7ZHHkq0Uvo0uJPZ3XblliYMAHNbPakso7nAmenM0zoRLdCh/qvPOe2 +VdnH+/ggUFiiVOtGVju0st23sXHDNEWq2E+s/DifWhFVVZXmOGsN7lPqLVkKih/B +agVRqUEshEtJoJSPZyJe6wKPX1WogBmafU+FkEB2KL88qqf718VyaqQ3MB8QCugM +D4mMxbdkzioLf/C3yLZ2DbVhwCLOCsD1Rv5uLEZOHoCKcI6Jhy2opeLGtZUJUnOm +MluXNLD87A+NKHWnzHPunuX6xnCMQKSh9GCV42zonjq54HoH6AQSsjXIiQIcBBAB +CAAGBQJXaWDLAAoJEIs9hnyCPnphw8oP+gNpsRnebhV7YRh38sRvn2s0XArfddm9 +YJT5yPW/19UcpWm+HPwqItMmrtXOMOk4RpnJdglu1PJneinVrbWn8IWKlb0mgdic +OKiVewkuQg+zoASS/72jkSAlcPQD3hk9ww+VkizzS1SMZh/UALHrz2RSHn9ViAbP +c2elmutHAwsge84Hl6ogsjXIbuGAi5Fj02aoOJPnZ2jwkhgYMT09X1QWkHsZPsBl +zx0gmfaN1cwhsE3RoQklNTs6sTX+oauZ7mNuyUut9U0KieNhejLXxl7fpWybO/IZ +gCMD7CDEcNyT1hJ/wf3kybi1GGyjoAmAMPvbZmqvvkS5sOEd70GJxRrXvnf/FA7g +BV2htWE7OVBdBN6j9l7Lb+jpFamG0f+6HgC9HEZaXuODSQlmSoRnTofF6oD6ud7w +Yg9Y0qxQ7x6oFI1I2hOeR1PrhXvfNqVhR9hwQKk4eDZIbQmA1ZriS3EzY7LZlYgf +gZ8g4ytGHXZJw2HRrCauj6zXOgN82+MOS6Gp+/JGxc3K2KeOYLpovoKdQwn5aGN3 +oQslUR5Ki0HHIXsStxhCDrupnAMMOC+WJGCu4mS/RfpwwFwZhvYWOr6qDptDgC3c +XnDzRM+isV5cR7/94zfTmY4YYcnMJ0NHoiKRd2GEMIxN4HJzUJeJXQPothN1/Aj2 +/swBV1+TvVwHiQIzBBABCAAdFiEEa0msutz2vRyiBmerzVT849lkvvsFAlki8Z4A +CgkQzVT849lkvvv4OA/+IX0zt0OemmnHw4VvL1eC6CaCT6s6UA065OZRqlYLF0iL +Tide08ovs4y37Zjd4odK5vWIijhuTHbFBJFafWEpcE4oi8l9GrAj36k3uWdvVrRc +CJHtF2z39zu+qJ9+yoWoTniW0fbDyeyLlI6VOI9RNLt0VYKHW+faVn7mTORNlpMl +JHXTZrL5qTfLLZL1r4P5le1MjQvHegxTPa8hMoul6xn+K02ElMH3mB11mhN7q4et +LqWW3GGLtCoeHjySHYAOMxsfcNSNaFtKfdM3kFx98qW2/+dN/0JOLVVO03LlE5H8 +VBjzBsjCUDbkgqJ8mp0q/FG5uYHZvgv6IoPlgpneVnAVCwou/XUWca2mrbsuqL9u +ehRAnru/gZrjLmt+kakkDajymE8lZ6redhNHY4kiIlBe8qvWLMnnD78VQLQ21oub +4cufzT2/DwlEyzJMCd5oa0xf74juCTAC4u5Vsk59kMksV3pmCPIAf0T5iJUzR4B/ +4sOcy0mNmzKp2vpKqI0fV5k63Yj0lC7xvv+lTo9Q2MNJBh80qNVcRGtQ2buZbXxy +OmJE1jfrOsRplnkIPrTZhh1Ttsh2ROpfW5z02l1+yUC8ZQj7nKeXORR+rTVact68 +V3Vg8Xb+8pYKaLJGqpDyStccETvY8cfU4p5LtABTIsh1qmPWPveYUyIM39ISz1C0 +IkJhcnJ5IEEuIFdhcnNhdyA8YmFycnlAcHl0aG9uLm9yZz6IRgQQEQIABgUCTDzl +6wAKCRCMJNFgjwaJ1IslAJ0XIlFSWFssxw4TwPJKQTzikd7FCwCeLhIdv2CbNorD +s2Rv/3o7iHWCsXqIRgQQEQIABgUCTLN7EgAKCRBVW5delTuGk5gdAJ0Qfd0rY7ub +dBpJjM4PfEhe/AvR0QCfWB3PhLTd5WxIuMlUTy7VcZwc80GIRgQQEQIABgUCTNXt +XwAKCRAdqNoz3c1oaoqUAJwJkp48XsnjN/8Me6sIQ34WUOLwSACfaO5RmHX1s0jc +D0Wi6S4rybH06Z+IXgQQEQgABgUCS1di3QAKCRD67xKTbdPj7PECAP47XiqxE6n0 +17XG0Jd4izJ4kIal3Ds7jCGxEpKFAXbDGgD7BVf5J7reuk94Cn5h7stDpQJppHmu +DPkAbQqg2hntudWJARwEEAECAAYFAk3RZSgACgkQprHz8Oa19aP/DAf+K6nIYk16 +kmJzLT4t1BPSJlpA1v3j8ooFd+mClETxJU6NTRpmH+ISpb2WfPJOrHmZlF+TdzwV +G6AzftImxVJSJ0psMob6uShgFsd3lpFo2JV4ra7cA2fxm4HFhUjFi/uUaKMurPQJ +4wJapTEeKDeDw4UPTi/S+perH4tbYlDzt9PhKpH8okPjmyoGrhhZkYzlVZCQ+wYr +5yGckR29jkHQkPir/jLfOv1hJ4QZGJM8la0o/ruG58viNsWmWNFgBMaxT/e7B143 +cKL4l+RKqIM/D3QZ3gNmI2TDnnJBNv1K37dxK6aKygZOH37akzxyL7tcAj2xMmlY +5QbvOr6dtqUxxIkCHAQQAQIABgUCTczq6QAKCRC437cbX+y9knWlD/sG3UDzVBFI +2Tjca0aKT7bfQzFB2DpoDUuaSff0kyPBt9usr0ffkllhQz+T/qAuWR7gYVVs9SZv +nHL0WhyLX9IHZ/d/8wNI+TJyU43u/hhQx+F3A6uZh9FXs3SAU1qEXm6a8RSi0ced +GCuikpfoFPFrUBXxWS+c4yoEtvLcEVCKhJ2QOc/I8V6Plu2bokfIWZ+nTVCWoht3 +L707wQxHJzN7zhouLR20qDnhQtNzXp2Z8KpT86VNBzV/yIJDPBx1BiEJSy6/qymc +vt25pZ6Iuks6Cmr3SyCp3VWJKFAPhlAs1GH15YUgmt4AkSGWmq6VEWg2A7Zg3BjL +oBNMEpmNJhhQgkEr0WDL19x/kGSIRsXJQ3twnnKynOl1oRb9ookETQ5zLnaNgwUx +AIT0GihIY9FifveRFm7J4+TnBr/WI7hTo/aQkrJqlN/NOEUzgZRYVgsMRBQyYltd +v4A8GgPTiUxWhV2x9ZXMXONeohscCnVpg57lWrBjGTXVlG0dlXxUIMVxDI1Bdna7 +gLtpbNj8VzT67rSjn/067Gogt8G7hy2AM/FbSzq+Qm0WYBgkkBKLhQdu0CyhE/8V +PTAY9slaAaqpeF56utZZ1ESZsMjzkbdmztKC6LELr6uUUrOVB2sTW+Brq/M/Q98s +GXMzzdXi9FBDBWgjaAAoHNynSkiSzjjDa4kCHAQQAQIABgUCTczw3QAKCRDhlwEm +drm3ObBjD/4rZfP/LjIZgPCFW5aatBhQfexJt9oNxEvge2UZqvovnDpFYXLU2LEn +6Fp2LgXhcR7E3ajBPEYprQYqVtXvO2hIFen7XzAF3Z8gHLsTbQKk9OyriTCMr2zE +8oV5zPdTHosWZEP1UkRXW0KD2ZXAhbdyPNDwh+vd5dPnqsWn5/32aQYJ5TcpeDM8 +LJsqhYtvjXKelcmRQQ5N+rG3qgXWk1a8CkVl/s8kQGc85ToWICw8ZAf4eHF0RbiG +65velSP3s8thEFHKil/zFyxwBdeRQM8tjq0Sx8B1jvPfiFmzM0e8qb71ngJSvNFQ +vS4G2vmaBe8EFUQfYozv7lzBTwxdzn1x2Pb8hGVERiLi6WGtwlyJuwBciHGuV2zS +RboUzQpUDPZxF4LcSnnmx1TL32muslJ6AfwIBoy+IAbCVhAu/fc0ypxuQBpXs8jS +2/OMD3Ng/8jP0O6/A/o1Mgh736ZjH28M3/r7OWXY7wmBIojze3RTHNUKMdcSCKqx ++qqgN/7moZWPBm/bhUYqPnf+cJf9RpFYVU/xTIGQY9w9HCyBDLn5zzv6cVAzzBBl +7B162i/sAHWTTBksoqdMc0Jd1LVKAzQnbc5FhL+I5oRnb996xCWXQ8L2gEXUB2aC +H06QGOYbs/xzs2MJnRLy8FuMv2dXYqh1UmLREoZ/1gl3lpdat9nz+IkCHAQQAQIA +BgUCTc0yKQAKCRCGVh9FIYD8/q6BD/9qz610ghLwbFxjiz/H82fo0YzZYhesmlSE ++5M94aJvK9iEQuAxRw+UHHTvTZPPzi0fozOQCW3UOTgb72/WEEPXqakSRayfQkbZ +VR90CIOofbURMS4OXwkDrKOzPyj3IpaKhMcvT8ejqh3tnzsEkvjXksRwd0+b2ws5 +3TAkEVXTzXpzjSvZIzfFq0rC5maq735GIL6d7bCBQ6j4xVuiCPYNxaRzAWKDlC8o +FRuOZZZKJNvG93ES8O4+gZeYOV9H7JdftQ3sqfcaimy8RB5sKdMDjwH9JMYC/8E6 +sSh+aMcJp58dYH809SfkjtBlx6PWmv7QX/JkSTJJRiOxRQuqNFHujd5wKs6tH0aj +XARmFoHOROyp77fLOxPIGHpNJEGfYWtM42dfrLdRoM0JZPocSDZs1XjGO9FIVVrP +hqjox4GbQxGUaUOOh9gvsMGffLnlPZfPLkOBL2X4f99Sgy3nGb0TsytbZQnc5v+w +vigs50CIl997AcwSw9kBdpvUWQNonDOAcnFGbkjhKdcORWJDBubEtYw6fjog+F6N +I9Mcv3Bvc5+GGzy7MCAWaqotqtD36GLELOP199+/YPoNsK8lngnb4mCwJPzKiN8n +OGxHENNyyNfQNwQampDtr42VkwsJxQUEuLZW3h03AfT0RO41UmKKxQ1xuwAip7ok +T8d0Brb6dIkCHAQQAQIABgUCTc1dfAAKCRBF136eMMsbEXrrEACvNP9wjEbvgof8 +PIfc6SJHZqpuKVS5xE4Cz6IACSdHtvokEhVq4ECVN3G5uyqeGhhQFVLLtbipFiyC +Fuwp8Sv7CH/tHO6ew90eWuoH6yK3fMIKf+m8d0N2OHBrJAi+EJ65ytgiwSuYYIJ2 +OquB6vfM0wkRABrEriDG8HAfIAwXBgYiBSRvOlPj07WYxrxoTiPCaBAoNQx5doK3 +MM6Xn1dXYO2ROdvvcOOikc++qAcHrGeVhx+y3FWUZZlJ9ETK8MvZJ/7g4CfJkRPZ +35mR0MngTXXgSk6QYfZigXTJjPuCezsvl5mXFUUGW8K79AL6wOba/eRU93dlVe8v +OZBNi15gm5t6Y+ply7ugYeCCfcjuQmRrmimfsqlYB+p52hPvb51O4zb67HaTFsen +4DKEK/CeboJLiX9ewol39tXFi9BbDBAeazvK6Tf+iiNQPtPVxVEWgoKxVEMRSBsf +1QRUf6dHKoLbf/homD8u/tJb8YhvDiQ1ry2VII98jZ2AGh2YDtGEfrCKHottBAWP +9W+uo9CdkHcFTS4+YiaJF2OaqA7H5EyAH6dx6tCZ+ZkFLfV5duMTbzVzHDRk/fxx +omi6uj96ChXCOUmJmGIMw7KLVF9vU4Og37/oYis5YK2HH0cr5Yfi+f7z6D1AF9TG +7HAlX2fMpr0ShgGzdYLXymJ8Ov1uuokCHAQQAQIABgUCTc7/AQAKCRBgBCahGPX7 +zqhcD/4hH2az0BIE9DBgOC6+iSfDwVIgq24J4gxCl3EcVmgfazFqk7CQZKoJzfBE +xtwTQOTueUb/DHXV2RJrwoCCs7ULbePtGFTpQG01dbpxynOF2yMqgMBzVBPrlO9d +IRuxEAao5vVu29XI8MpXqLlQtM2pZpTgv6LXf79yVC0HK9AaEPQwrInmsc9CpQUZ +NuTeae6L9sYEQgkVbcX4GvMtLh84ghWQgHKojMWU7yD1QcjQ0ayKrNmTUuj6h8rr +pETbYItaoRnWmMh3vbcFZrPLeUJTLs0mPXx8fV1zlJe0rOfuFtx+li4vBAoDLsVn +FdYSacS9/QiVLcEZHlYIwokvA3c7DTf+6s1UCYEC8NtQSvn1W5pK+/oWV3Gm4pEF +OX47yX9gtk+/iIMackMvfYZKaEXez7+/3lCEfhJCnldjchwUlr85PCwlG+/ixnXd +OQnHNnnqwMRPGghO4aXk5wsIwNCYAnRBkwRWjKBdA3FTacD/Qwcx/3eGbFsCb9jg +VeVOuWddCZMjmGqunqukS/2fRtC5RuMscc0VTRkr5xR4Z/vTc8Nz/K1lxBYQVHtN +LXK4y2tHfKFgM7xUAcvjM19VDAiEiJ1bymgPMCRG5ic/yWOw8gvsIIPJ2LtCYp9r +D4Y+ioL5DD+ubyIWYBnysufVbU3TVDnIp7vjKVmDHytdCAGsCokCHAQQAQIABgUC +TdF1AAAKCRDGOJdNZHktZ+YMD/9Ip8eCITqF/QHlzR5r/0kbFBMZn6clKok+5jJ5 +6ewCG2QEp8aM1bhv8e8GzbfuVDzkMwU0DM9F9R8oQIGqKuGe7syyAQt/lMS1rOAr +trKze+0F4viAXBEv2zp5wg9ZsTw4MnPY24Wx4M04JRtGvfyQbtXTdd5xVC+yLbXl +gqZnydWjxxfoFL6hHu5b5BBQrGwtdhzlHBnS6zQm7WZKkqZzMH6Rsgn+rqXtyxdz +9HxF59wisW2RA4eII8yzn2my0GfBtQIcFVUhseQn3xS7AQzD1WgdJTW5XT2Hdz7w +vQyWYOO2wY+5qY7fOr7Fov3wKQ7JnCeyYg7Jb9vUaN5MSYkeEp6tpvuAxMWtH/yQ +b7FbdJhRGhzZWYyPfEwKEzi9WFVv0XV8l2kyZdgKW2kF75HsxqyopYF9odky8D3r +fSLTjItQCiLNjoDpXvoT3pT9eyBK3v5NFb1CfZaltDHRe4T21IQYvG0RIk7ip0ld +wMeLKSRksqnoaa32Yr4+u2qDO6+cxyx+rb8IVGOJ+qF+XVg8v+ZLRDeICxAj5Aas +jf5yE2hLsdlBqJlWsXjtvmTxcIjK5YmV6CSRwxjEkwMDFZAuGWWSQ5DvjSrASuPA +rneRk7kYOmm+w9mBFban/gK5Krl+8ZGnr9/djto3jBCBJQ4uRWOzry3+99OlbXx7 +A7OX6okCHAQQAQIABgUCTdQQpwAKCRDjUtXFHFBB1FjgD/9fpQu0V0maDGw8CXMW +pb4Q6p4r+NASmr5SPSGK/gxyoFVe4ksKhJxRsqB4emAYY9GbVHmT4jcq+olSfP4H +gFyoU4rqNUhgaE9fb5sjgZOczQSMaXMW3/jqz6QxtVNMIBLeBcMOTIYI3U3yUzyB +Pk/E8tmxRCcKJPtZ0wFOMGcpdw1Uwwj8vGRH55vMc2L4yG9D1MSEmIGIg2rXdwkM +uV+MAnhFTOlVsKYChqkwXtFMLBGaDS48P6QRknWYz/tTDTA+IET7T3OdDfANeNjo +sTPuqHRzFFfkUYR2YETMKNvne/4Ug7EMOqHWvx9OycHrFkwjEce164g20W+2EF02 +v6xI11K8sEG8PuqxfcUE0/vzOOjaFcNE+mFDAqk48qCS3rh4991O2A1dSKG0jCnI +WYqiiUGfZEBx6A/IeNZSTQTq1aDnOeA/7Ev7j+3zuDCE4ZDzOGbhytQ9p8n4av4M +L1dpHUge5+wHzKPLH46beX/MMTiqIGShK9niQredkm564ICgJtfxMwf9f4riVXqv +dkaQFBVp9pFaVEcUo+vX/VHSv4agb7WiYRYBEGEr/x9X3m3HpCEkjQLJtmG3T3au +E7gg075COHvNZaVvN1Ui0YyFrM3cwMdcV0bYZvJImlQ21aF/RIq9KP/zS+KpFgAl +moXnijak7R9Ogj/fxemNIMFTu4kCHAQQAQgABgUCTMrV8gAKCRCcMVA8bYZjlsIs +D/wOGzmEG1afgDElyRvrMT6z2lR1ZpdUs6CuA0OBO7VtqQ81SkNJT4ZWhnjCofXu +Gg7riKRY7Y9Ms+EPiTba8IbUnfIIE1vD3LATbSo8ikdC3DlhOsM5QqwdeWdNBXLw +KMiQuQ7i9Ell88MNGKUxB5jYv8vucgizk6s+lhsgqt5O4yv1z93VoOkCin2X++Ij +2ikPMDH5JrgNVl03LKJPPvjnK45XKSUGI9D0u62zLlxMnAWueq1IfOgJzRh0PNOe +Tj0r6emVEXd/rPpoxZ0qa3cA0Ylv4o1CrPZpSUbCSFhTHSa8QpiMoiQ8FcU5vCN/ +GmdKhiUrJQegBg+idn3LIoWQXirPx6/5rOQTTlQqbsk/45AwZrMZLgnGBrkGyxFM +pw4yJwfgPL/O52oKIImw0KwtxYX7dTPe4bbmvbg9scjFOV4E+SUF3I8h7i0YrMGR +aAcb/1uyTW28PJxiaOdFLF2MfC2QuRU9jBgwX51Qd6dQI4G0p9ShpRG7zUQ/Ct6N +P4b4rHRaczqMDfxTvb4/LHGH/NuXbC5PP2wtaACfEhNs2z1MSlnQQt8mIU8orvmn +mj4ePbPxCnprjU7UK6eP1pB/pQAnOLkj0u3KO9Hn/YvHJH3M+/pFqZCDXztq5/TB +gwy1iP1WSCTiJEt1Ecy5IIv/llmdl6xrpLJJ3nDla61ZXIkCHAQQAQoABgUCTrK9 +GQAKCRCXMl3Y+f3VBtvVD/9N/jyXfojw5Y9vJwUV96IGrbnfY02W5YlUqmsswD+p +lqHDhh1yZ6w9dCx/AO0Xw2ZaDW8y2+JHRUY4UhACEz2WiNBT/RrFvLjS9AL8XhTy +oaiM658sXsWEoLzBndFtFZm64b5u4199SgcQ48cmNIKpo8xjKC/bwTwClGdij6AN +GJ7vY19QU/JZpCWB3eV3Xp1bmJq8xuNQ4NutW7Yu6At62ApqA6hOymcCH8ApnyvB +kwcJRoe3k4KxBPJ/2yi0IopPQ9bZnDzwQ0ipGJ4XUfhlrpbKhMf/h967SkiSDHvr +tqRBVkcAj3+skaL+26VjO4Mxvn0kPbqlioI1cNxRpHPqv8FSIbn0ALiqTGxeWOWs +RiZKKWBJyebJPXCwRs0e8sP8wIaEYm6MUQZ7kdZpljGYUUu5rELQ7dwwueCRyvhz +wVTt3z/guSAecCAFYo3ZJKp4NEi24YOohEwWw4ta/8OzgBfMhJ6cWK1WShmRjJGi +RfWyYPlsiCDS6EWGeg7I+Z/V4OdyEA+qoeskjRUiTJPu6Vg3G0+tWpNXngtF/Kzs +rPGaOxA5sEuhYS+jOgsk9H14uC53O5ym8/M6qHr3PyURu8KoNyZqwsJr53Him+4s +E/Kv9nVhGmI1riASduEam3iDsGAS56aKTIMWFxgOblqmuxLV4dNX2tkU6SrAXdbF +aokCIAQQAQIACgUCUUe1TAMFAXgACgkQEl9cZ9/pQIRRbg//TEaga4s6Qtux/XKO +q8I/mo5L7ZsavR2d1rO4u2+XOmPUq/4XK9SccTki0a3lOw3h0hq6UKHkseN29oC0 +QxV016sau13BNDFZrcP7tUyYRVEs0t7m0g0bbNEgyMMGWygFdaFn40qi6egfbLnP +bbEqfyRjJEuw8dE0VNep2MTA40Vt1tVFPrFyfEx4Zw/PqX8PMpyJlJdrsY37tHJX +vV4oC8bz+1WI+NnPRbBvW6hYFXk31uW4yJ8r1DzhFKH8FoFMUS2KV7u+26PkrM0g +LriKXkei3MnuvkxoE7Bs+OwG9j1UB+JJ+2bJQIeWwZnI9PS7Zp8+ODW7pIteDDs9 +VwXNkEMniwSB+IXwNZinOiwGzU99H7bGEeRuQP//U+6fNxaaZ32osjtf5jX0gZUc +cgnM0tsQhhb6nPOhbj1OSFX5llBs6q2HMNVmxXuIAkHZr7la0C4NNAVj5Y1XVz+t +kcnJ5/Lt/Z0L9QEU3O7HxnHTIajUeUqdARTrHRozsMjUnlVLivmp0dcpJqoiAyw0 +1zV2dCKYYls0kGVg65Nnf2o0PETvDfahneXnDlEHV/9Qzbpg/cmt4q1oaqsx2VAO +OfwOm+CddHNNJ+wU9d41OxFG74j+fKKdzOx0zYdz5Dg79mFt1+vuIKD6CZoHzL3N +FsRcNWzF4QInnMkM/kAdUYbAWDuJAjcEEwEIACEFAkoLehICGwMFCwkIBwMFFQoJ +CAsFFgIDAQACHgECF4AACgkQEm61Y6dLBr8roRAApxJzrfU4GobCrRrQoEkjX3fk +KQjHSTB7R6VIeXRKPNbfOpRYk4+qtGMY1WOLnYWPqpd94AJ6cxOuY6xJ4m8wlSCk +1A2L3r7w8C0MNF1e0wefzOlBgSeKWfJV0Ih1LFt1YlH556B7EVDLNYH8T4GAWsS+ +VsfSRe4MDUXD4mNb9Perihn3WMsXIRt/0EK8Cc6IUJoXS+GzppJxiI3MzsMSL7ms +thO01ML3a0PB67HWEfjbThSb3PsnQmNnCx/T90YKofG0XW4uBS9zYz6Eh1FW5NzL +ImE0lfyTtJAWDPXAQKKB7QC+BTZxW5RvC6+Hr9ySG6SYuh6vgl4hk73VUPbO5VhR ++CZMCeWh3wgTqbU9fKH0LH1iJvVp6NlOSShgFKq7pbBEX0MMMOCprIq+eC4my7sA +wYAs5c/Hr8V4GUqU6b1Y4JV0K/2uIFxAfyAfpZUWkLyBoOWoz3/hvyyRR9YcYBjK +pgMZ/H+OVU/DXZ0vaxFs6X7dYnuCPWmYX9pjYbtmSNEodCtu50UcGMseumoQCtYe +aKdQsdZv7PS0nnyHh8X+qvrbX35shpcyTcfxIOz+3Vgw32ni4CM2sm4TUnociZTO +sVMfZaJBWGr4XGoOCTbVTCdOOm3Fal4dMOVa4kiDVBdEY76BnkCJX+hYysTH46eP +0GkoKXo0pHWFfX2PWVKIRgQQEQIABgUCUUd+HwAKCRCZzeqdpBNbOE4gAJwNQSVx +0EcUmmpIN4L4FyAcd97H8ACeKGUCZUGOFKHBqjafF0itf6YEBFWIRgQQEQgABgUC +T60ktQAKCRD23TMCEPpM0fy6AJ9GOcddrLVqXlmzFHzjTCT84TfUiQCbBYavMz58 +CxNHqtiPJyBKyULOPv6ITAQTEQIADAUCU1W+rgWDB4YfgAAKCRC8yx4nMXJi0pwJ +AJ9JBE8hFB/By0BBfUStyqfaYij5/QCePwMmzIu/CQS+a7QUrydwKtIOfPGJAhwE +EAECAAYFAlNJj34ACgkQBMNnwhit1P9MTw//cDr9IOkz5HEEGzbTGZgb/eJPPHNz +EFWJaoDZBNzvfJCwKlUBQK6Kgcia6IYHrvedItmuo0y16yUfMW5+2Ut1E09VKbGQ +l5ATu2rwesX9TLsiKHkKIV0pJy+DHqJO1hikuJE5Wf9IBcM+pSScDoQw9IAb278O +BhkGU4JiKt2ejWUThwWxKMoe8CCyn3mpZmKVxgAg+A3AdWtkReir3nKZPyyIqh1E +5PlyUGTIFucsU8vx/E42OZgLtkgb9MX8hRdOqxTvviY7JMF+cvF7itA4hw96TtX7 +7WHhJr2CVZP8dFY5CulURlBpAtR1VUpF9qDmhFQg4nU/LhnADGTNHEzSRVPe39ww +pdTCEH7gVAQUE4xKtmE7IGgpXOnpD408n/m73M0DtG1EO74HvNnULCC3tWcdNxSj +jr4zfrkiFEn2c8nRueM83Y7JL6lUHCDnNVWROZhFPPS909oo2SIhF5/RH+WbHhnS +Yy9IKHEzQE22g4x0FTaCpmYjKG0mDIN2orFM1CAYGG6KsI4Ea+J5WvuoAjS93dQW +DFZvAnim4LyqmJ8Tsy/CVXJmSzUlnZHLhgTOAZxQR/5AZNBRgKCANsN0VgjkaTXY +pcXhWduaTbgZBjC92/JiFpMXvJIrhx355ic3A+0Q0RizSLOAAlmCJfijl/GBK1Cu +ohlNwNEU9P49ofyJAhwEEAECAAYFAlNNmdMACgkQLqdrnCtGbZ05TxAAsLcw9MAk +kb7GLl5aFRRGlTpbNML+tRzmfD1p32J8bZWLRbViN4pzXQUq6ZNFtRudXtyXOYMK +yKhLXHg2R5b7RDBB6ru/4/lyYaEAodJUI7mrQslSDB7HeZaJhMAGSlQTbqi6Z+O5 +8EYqmf1GP6bWXd629VZslrBx2yB80YLP4BcO0o16TEKcdLfFURvt8C1JxU3JIYhD +LZGg3Thc/JPX2UOWSD09QU8VLoTcRvnOGkRjoRfMNAlyG2NwXZIj6kCGz/xiJwUZ +NPWYbKc6/SN3vqjGtQpdflb+RPUgQmtetunst/gghAVR+JSOfZR17fqRaZYLk7Y6 +JR8k0P8jI2EuT8CS2acJSTBdn9Tnrx0lZRQbLxzB7ch8sg2ekkTDc6yePfPmaby1 +2vn1ZRrr3vcKjhCZqT3oiKBBn1ZMXwXeYCnQlqNyt+bLqYCLieAUhGfl67/4m4hc +TxICNCrfrofOReVkGke/MgpPc4wpy0SEo9kp4BSHeUBu3yawLc+DQOrA+0SfW3Sw +LZZEvWkha98u+/LZ2uXxcAjASR8RE5RIF768B+8k3oXjELyKmqTUFxMhzWfTTpGJ +2N09VMQaWOMKfU8xEMzDaCs6JV9U0nqytJymz3wt9yOAkkAEPXcIPKjl8zAeALsH +BYpz/rr1WYLa3xXXCX3ZlqXBrDHJ5ob2T9eJAhwEEAECAAYFAlP7wEoACgkQZJWf +6YON8ZwObw//Q7qqCnFpk8JKQHy4fz0rVX07OoS2seSHb1OX0VDIWdpNmdeyyr1l +PxwsEO6DBy6cgus26dFpIDOEHeNptqDxGQ0ayM2HoGeb6/xNqNFO/XfldxJCIIE+ +VygPpldT+iZY1vb9Uzx3XXsug33WkC/Yt0vJQLjCLevoDlqGOkvweCsbfx2k3D8Q +5jzRl5HoHqzp7K7EFIE35TdQD01IzYnRHOpPDJSriATlac5uJtAh1BZEB/b5YqcZ +MgIwbVQ/EYkpyUrmLAY+y5Rut7796MWISNaTkEWgW9alHxr/e3GuLU2HiCopvDDk +xmRGD7r7m/6SxQQA7vE7uRkODlMdEmdgsJ/LypHUGBh7OndgeJwDLjduBP6N/YtY +ZjbO32h5MtwBOjSBrHq1rG+rk12H6AVcKTCUCrXCjc/S7CYIlsdLARctl4m/Rg64 +NMpF98lgdPtWB1g/leiS7VvTQFIDa3xnP83p9F6J8oGRtXrRyvPqJtgp1h3dLTSK +cpKMGVeNv7hNxRRv7u7eJliTnXRgOTb48rta1W6RyOVJBZ7Pykqt16Fg7pCngO4x +Q2SGwWczPwb5MW6A61e7cXxOn616Nt6PGMM19b5Eh2Frq4u0l373LuxBStBQGL0d +ZfdL4hds8r9b+8t7EUBfgLigKlYycTK4OWg4CS1B2M8uc0uKK0kzLnCJAhwEEAEI +AAYFAk+tJGEACgkQOTWH2X2GUAsrLA/+PlSmFe9Cbnzveg5cSWvB0a/UgpYLSf3z +QgnGQSYNMQ+B0cCI9GmjbIaKrqZmrsqAv9lX5FtX7VhJgW+a7UFms5Airi+bQmni +tmuJg5Cydnm4nApSDXEzQoIYxXfyMCpAa2YcZnONcH3K2Au4pHVxX7Tk2QPqjcfZ +Jj29XkBCZjIf8Dg+CixC0NA7Aok4lAhCJwDRveIK5fJIP6ixYbmPM1e2NeX0sihM +jAjYci2A2YoU84T6kbrvNfwAsbokR9i+8QRDZfcn1ube4JQ57fKBE6dbZ+YOmTJ3 +0btMpegPb43kMmI63NJ+T7OT3uguVwSiznCYHvjA9+siNFVJ5dPQAPQ+stTUZiWt +eAyOZllGL9qcRjjwmMowdVYJSSkn9QTQfveIxf5ROlA9KHEe58YGFq+C3P9L0PtI +53objvpU3GxvkYiYazBvxwyrPHMN19HzGfoFTIkgQYVNFxSN8ksfFzIDNWYbtd/c +rRROKNQgdyYbptupKMQUnJV+PXz5bRH6TcKo2NrV8R/4SR7KwghiiqOQa9rWg11c +PEJUepGnXn8ZwtnoLjp6wBHFZGEgcQB/MY0SSvRP+31Z9+DXZD9iiOf7uRQF8p46 +R+q1d38qCfpFiUVid+jlN256vKJIOgdhSB6bZGzhY+Xqrh+60xaqxtj+Ef/cT7d7 +aadvJ4RffjCJAhwEEAEIAAYFAlNZzZIACgkQvlz2h9xat8LzSxAAlaSkm0lS8uPy +sFevQ8Z0LIgVlVuM014t1Zqvsbq+B26RMw8Bk/y3aj3i3lVJXpo0RNu08v2yGNOp +IdN6SwzPs0Ep6fcKtDk7dsT0R5/TffCLQcS+pCujl+HGQsOvtUkHhJGfw5yvwZed +8RDkLwpor16cgJyEC9CJUmXTzwxgwzqufgCZsd8Tz0QRgpYpx0+/CGtT2lg2/5GT +uQrJhsVTgzgEv2grJzPhGZvBDIDXuU4GjDuqRlc5nYCRYT/y/wWkTUPsgGCJIosE +tc5CAGhUYirnJ1GuaHmU1SWOnHTDoTXk5zBU6iNHjJi2KqrMXUJWqqoOyob/JxtI +Om1q3ChZwZ7GyCthKbgIYyRRHc7Ev9CEKouke+J4Xd/URf2hC9s2bFROp9w/UzsG +0PsyTwQ1Dqbhwf+5+nU32wyDTcHsnpkK+DkUNMx2xp9ZK3FcGM++pPdw5vL3IeqC +44jS+ioaycYat0DOtbvlbVwuuXgrONA9zEK+Q5pzUzwdcIWNpamRlF4plBwLv0gA +tL0E8TpKnQN7uR6inI9d8F5nNJPoetrOf+tpW+EF+iWxDtzQzbMfFipjsO1hXyzp +wd8yjHHCAK7OOzI2/Z8F23jMDa5t6CRdiUCBRzb7NZ8xbJymLHwVhH5N5CbCjyGV +TIuvG770MV7zt0tJ8Sqp762DmDOUrPuJAhwEEAEIAAYFAlQBB/MACgkQT6BKTJJX +fsTPNg//Vk75eQfLUIH36taCJxt3iGyP2FWiumEfvVSkC8esxf9hLy7vxYJKVgU6 +R0fmdwVg3FbCvxFqCJx01NL4Prlh7gQ/7iNl8DvSoGd3Jg0SI5TD+WvgYFB6vfW6 +lqo3yDFbkaiEK86Lpxu9jxqUDuDFB/UZuLEgG+OPcdR7b/YiF5tmzibYjYAqRbT1 +GQacSuV+t45H1X/m60SIJBm4CWPtDNT4EEpR10QbIx/+Cpn4eqhcxHNskpLhO5EN ++JkP8JByb9ewK/66YRB9evhZWrnNjB8fj3BKj0p8wZcJnLrWV6o7Li2AJ/XE5Z6j +a6diWO6GwkxDRZK3hUOZCeqqp0Agbw73NlvvRgG601dK9R9gXCvUEBqh9XwHK3J/ +zglgm8hR9QtJZLUwrQCwReNbvhRi5uGP5jpbikLjBFX7V70ubzXa8pDBoOdjxbI/ +j7V5cdo+AvisnPWAhs4TqrkQvYs35NZPJ1F72n5I1HTa4CUswV04ptSEsBilHMsf ++HCCmTaauxj8jR0a5BaRWpEhuk3pEM7QJlwegsnzd6E5kaL25/1xOgiG77Xqd2jr +sZoNnN+RjycxmS5AD4Mjz807BlyTqGSQNMTbtuHobqJLsqb2HNi3/4X3ywynDV0l +zHWLjnJHKGhSOD7NFsVeibP+0VK+hJ4O7GpZt2+0Qutj0eOCh6+JAhwEEAEIAAYF +AlQDssIACgkQZzoD5MHbkh/nKBAAsszSx4tx7h0GT6LAWtAMABILnr57JClNz1e3 +a0eK+prortA4pOe92XrTF1ZhFZLZAJq/jxHghd37fUIOK78bR0FVngW4U2qQxcRp +F4b8neVpjBFY0Np2QHd0swCbEztSIGj8sc0pUipaRoP0nEfWVG27QYmMh7Gw23ES +4S9xkzsAl9ZBP8YS6qZWJXYZVBiBHuRNRZHD+9w+1zItjvmw/SOdkVFstbi7S9Hp +GGZvb1dgd9Dcxlh0rENMwNFS3Lrb71CSSDTdE3iM5wQZ+J+HwJt4Uh9c1W92uPE2 +e7t13WulIcaGnN2PE05YPTTeSPSz1jwy8TrlbpSxvOIhdP+1LrCsCWuW8YwH6xL+ +skibJtabbg7yluBeM01bZb+VrzYsoIpZbQbE2Dx41+vUGMAry3XWzFDiXW/efgz0 +c8m55xc6eJ/NFP74c//T/7982dhE1mmO3CJwsRGm3VrDhPerfRt77Zt6boFGyDrg +cDlmQOcLdsXwcvOP4mFH2JBicdgUiHmrMdjWPnREDqfHrzniynCqP8LhUPJZDRwy +Fy1JevyXOrsv4SxwYRZynrkksu0YYhXP8wm49fwnexLd8I7pMT3k7U7QwYfyJRO2 +KlD/EaykxHIzQaEnNXI/ULusmCUaw6UEoQSKk3JK/VPG/g4dawrVqyI7BQ6ha8Re +GrSQuIqJAhwEEAEIAAYFAlQFHCYACgkQwPiGTNo9A1iYuQ//TcaHGVVAFYfOMnsR +RTmo7mG8OhJqTlCmj5JlukE+SohVBwP48e9Mrzg5nEKgvVChKDjpUfJMLvBYkiq/ +AocPpSaphc4fzo3dB4IGz84jtacXU1oORxA7JTFsF4TQdR4neZYW409vraN8+w27 +Bo9/KOJWEjmw6B+5WoMKk+XRP6+oo/34O0Ql4GweeHDZ94Qv2IrStVDBcX31xu6u +Rhj0kTZWNeNhECd/TInACwR/v3uJfrX6NmxjDsy5P8ZAu9Dz5THC8lj0xbTGEw/l +LC2f0UDDXQk7BjHZGOXeioS378oYqzru+wSIXXdq3QDEmg+bTAbYG3+sGCj4GyYV +tfDysKhQUJ/r1YJBGEUg8nm7lmS+M7mWIX7wEci5pS1tkNpPwfgCg/WiOC0zQZ0n +aOMRnEAssLK/xo2kDaigsdH6v2mnpA7T/rSt9jGcrkKj+CC+sN/6kNJcPNvMpUU0 +sDKH6O1IGnjvtzAeI9mompuQFzGpCm2H1QJkeJaBT6ohhDQjKSvT4+BsgzLfBYiL +xu66kVK6fb8bd/XYWdmGUckdguj8qp5Z0P3/tZRj4SVN8MGv4SUmlx5Ije/1P+O7 +lWItrPjzbS0ihJICOgCxhiE6OJ9bUzBN9w2sed+f46ann2UIY6WtPH6hcq8SwAgf +rWyL+yYN8oA2hrRnYuFFApzS2DiJAhwEEAEIAAYFAlQHvuQACgkQO1biu9U/3LE4 +Eg/8DmHT12fKGNsaKnPGltE23jJQU2z3Hxc548+7DglweJ611fhRVSvRJO4vQsjm +HnwE2rduSOhtckBWncl2z79BcP79BLI6UU7/v/FXDaSNhX/MBBOr+oULw5ZWG4/C +UI18lRRC5gDCxbOq2lV/64Ut19/t0W2DTCFl7h6InZ55E5A2N1OVFc+maXG4zf7u +fmYUCZ+dBrCA5jxHzU8NW1OzMVJwzCmdZ5yre1Tw2/MegZ/JAhnXKjYPKUG5+CYM +Y7QyOz6aWNmR3BJSvhQzz5bv1XKjcYWy4tgTmicBVex74RjOLO/o56Cu/ZpmgLMS ++zNKpsET3C4BC6iAn4dqed1lqp+Z/I3Q+zk0T/51VYcBImNimGVPK+CJUJkH2zO0 +asx7aWT0y3FuXGhy2zyk77NCKwl5Wjxbet82SEjVZnRFFO+19MgLEjKlzPoLw/OE +fVeOV1mre0Ld4BpeqY15HgcTPnGHKj5+g//WIbLwzXnuIdAx2t+u5bMD08+4729b +f8U1tQYuNenSaLuXlrsTHw+SHeShsYeTILe8+aH0TS51us9/F8iCFJsI2Sg5sDiD +cyIz2lCsCwHuDs9rGWTKqYMOl4j0JK59mCcU0UNE+8tmQ2doNEldCSCZnhoj5NL8 +50nBfYvz2sgNf9AwYc4VeV2f/9zqtfkbQx8Y901l7hFNKbeJAhwEEAEIAAYFAlQc +L68ACgkQ2SnymSvvCjOOQhAAkzmbqhSd4GzI1VNfo7IFXR6y7Ht6tekU8H7NdNgP +I6vEhSZJkT7M9gemM108vBdKEWqemC27ng7wzuMOYuolowmSnTlxTJ6a6xlo4Ufj +pjtV+MQxWKWUll1ObKTOg40kTW7SKJxYi70yexdFalahcKfdbS6wI4BPRE7wIU7f +6lm4FGKHwtpsOBGchKfyhwYQg2ffgs7p7hluN5nlbCW7ZC94gDsrJliOqRFfg6sr +TbOv+0xhWQs74EKt3XkmNGTBfPvRXkgmwYT/qz6JF9KWH/Uuv8hKnStaj8oLlNar +S/UvyKJEykGytmD5avpte/CPKG+MBTcqBtfNkzZvAY/C6zPTaWlOqNU51n9Kw92H +9qfc8D3eciuhunpEV5mA7CsAtzTyyImSD8hKbs0UobfWWZmv7xq1vwgnH1G5Kyds +ayy3wakN+EFjq3Qii5/X5Lt8kvr7XkNrGdosDsGaDdloZb7wy1ehwHBGhtHRL9YW +jSCWSIqenr1DwTOqc0OHI8f2haYBQPp+R9xS44Jc5o9opRosjB6s5geQP2w28J5S +1g2mPnY+G5mSYY2BJa0NK9+C6jU2ooQdhqpaZoCVGd6WsgBWw3gL3j4Fh+SUlp8u +ZE7ynaXMMT8lgtQDv10uim3wKMkhHw7eUs6dxZmuQO9gjgVytpQe1slXuLygt5xq +17CJAhwEEAEKAAYFAlQCgzwACgkQHnWacmqf3XTXdxAAiTydD4Fjv7K/wB9Aax67 +zH7puvExYKR0k3hXWqMt19zPbEBZtEdswxNnNnxL2t/Ba3SFvzsPM514+NPlLy+l +u9vC80DSh5ND+sA7ZRymY5/JGRgE6ynM5Hp7HGvAtbXVegNDd2MG9t3wdiSTYa1N +tBJp8uorDIriVCS+EsaNC4AB/I5QLh1ZqtAkDX9D2t1qnGhWvgsGYYfiM/h9Egd7 +7uKJvr0vwP570eft+8ICuVvFbDX2wqhCF4LHmHe4fa592af3ytrKqyd2S3/AG39l +b8lG+qhggclCrSVERi36U9XfNDfGGXXRadV4MPNT4niu1hDOctSVi+38r0oDvB6f +Ddnk4lkjV6AkmItL0K5vcU7x3YErrq4jXRYPHBZNpJJrXNLd7uq5gqhAfXKJYKrQ +308NY/ZKD/JVUAjFDR5RtbEpiGK3QwUuDKx34uEvOXs9zC4rQJo0RjbNO2a1q0J2 +/nGoIAkqAtxHslbaxUzXoBcQUwvyzLNzS7ep4q5WLHhwNfZOxsqj7MW1zzM2jkKS +RKCPGADi9+CKi4zizY/wWQpFjm4PyaKAygGa8AEyHiDBHKcvgaNGtEKN/3EVl620 +q0ygO2s8dr0hoAyvAbuoiiDZ4cAAMQJz6F2xj8/7bTLy3LbCTf9Zb9dCKSC16HKu +TlRlYXCY/9J1f9SLnytivwKJAhwEEAEKAAYFAlQHN7sACgkQA2qcJb81fdTvWhAA +p+tYwsy2XQRhwzUp9CZ1UmSqUh+iB2dHWPGrD+QSoEgBWw94WWjlkQ73igdSLdax +bZpizPFoujRTGJe+pNM0sWWOik8pvmu+3SxFjqEPSkKcCbOSUb30/2U8u7rie1a2 +/56zEtGztK+bbxsTkznOxoj2utFr0PLq20ghyW1OhtrNskRVSV2zmOpsX7ABwM5o +UM25PswqZFPDDTLgnNjiRZrcIVBzJYFYQcRHnz531rKIYTIUskJHhfG70GzYxmGe +mNgtGpXZN/JJYR+0fouuL55t5Efslm+8N/JL9dJK0SWwQb5PydOf9XVVb46dKpYD +e8i88N2cLib9z+yPABF3OnG7lULupquPIvKSTvqhShYSW04jYW3zZF1qKFZSj3Vh +kDKAro915fCAvJUXM8Esg6MxoNeGZo0RhHDCDpuHdbsG1huIbswNOh5illIxUjwh +CYAXCiozYelmQg4bdj1xoXBbQM8lZIsXyZiMCLJ2KqzSs/KTWE/X6uATD4g57rE9 +rWixPR8bdJESMH8jzL3Z/XPWK4+YqAJVa5fBEB3Q9rtp7UHiLn+JxP/DmOHaZTa7 +BrhPHsoXfJAGp3xiGL4CiFT9XqSzbsVf3hlL3xtCQkWO1yZ3AYYiidyGCdfROUlT +PuhVjUAit8VJPSuz0hldvKLv7nndy44WGevEdupKEJmJAhwEEAEKAAYFAlQNGwcA +CgkQdRq13aeWecwWwxAAuIl+puumhb4lVHSct3pofnC6e6jHwzFE0eQE3AXHa+aN +jhogX20BmzDHECLoR3hxVbjRBXjFQ6XCeWp9V2CdvhDFo3gY610zLf1r6ykXFfsT +K2HlnQMjVKJJekWRhP/uslalKt0oiMY+/cRKceMJ14oMjTFwVFz9ibV+vmKyLnRe +AQ6ziQZMRh94U5CXWjarGk0Du0A/z4791Rv2vvyReQ4A3ESNz4ThYVEshxs2rMAY +nubbT7sBjuPtjOw2yjfg2DcESZydxsyQYttjoW/YUb6hIAjaH8WN4rbEvWfiyaXp +KuA3Yv6bKqdrto6lbeqRgwrrIY1ow3NolafMly4JDR7fNG5/4mRQzdraK02b1C8K +LymNH0/jadFokQ34r+oNjDT6u4YX7VGPkNBdCFnkluza75l9yzYMUn7QiKwgi7qv +nyBWJiC+FPd2e9AgqbtOD3vYNPxG+OAPPKNvTKQvuLqk7HmwtYk6qjC/Ob8I3z6p +sVIBCrqYRAOEBnwLQAB3G6AiT0v1lHd8le6LhbewK7whM0JKioB0f4gfViyhBno/ +SqxVryabE2seBDbR5RkWWPBjIxjjVcHFDPEgtQ0L96JajVlE46gIdm8b+3Ybhknk +JO/cZh3waxVKXZ0kY24W1YGuUDZGjFrAbuQHNpE9RfjjyyFHumuhwnSnz4+sy46J +AhwEEAEKAAYFAlQPVewACgkQbmCLY32JZ+lEiQ/+NWBgU7gcB3oyVprRBxAADYFi +RbknlBY2jYmYdjEJAXjlTrH3pBeiPb+Sr6VBXlpx73uyJ5FOo3z6eGwRXAc+F/c9 ++cNcYcRsCYsbeI3bTbGQw+05gZ30FLfWHJ3Cg/ME2cu1rX4jdM/aTB/UfjXG9pR6 +AUXXrZU7tA1U3ox9OEnazm+lTOW7Qagz+H4xAUkS5vA1SyZVAM2SJHqJT2Q18DoQ +Nkl/G6jBP0IbvebeOrkq/k3gvmo49q4kVMay82L8Qd3/nTfsBB02H36q16fVvOPf +WZz8BM9PDMHpDBIxFhbfWoe/StFI/9CXkrG0pzHeeSFNA1+Lbes9LGaUJSlSUeAu +jNzvd/9vCe3kDflI6roeQ+/vx3p2ytR06WQUeZWLHkHzbwecVZCHE9ovt+Ys4F97 +qyXIEKIWgTHeFulCZoadd6Y/R+WWSmbwucWkRXGHGA8K/9lnOJp7Fn2UYHVZCinJ +SyKcQlw7dGhkP5C3sZP8KIzk9g87/mRxktvvf4nldIJcgwXsv5Y1MRrJWVQPYfNR +zPF6SgfRg/iuQoZxxN3PvKsfNJh5WN3i2FPp+idXXq5B6m6F6D5I7wmPAJr92jns +9a7+ciOWUAEU9uodZw3aj1EyxAUx0DPZBDrALavss74SVF45qkQ/+5QITdQm6Con +N5A/CMJa9EPJFrfd0PeJAhwEEAEKAAYFAlQPZbYACgkQ+z0lgztqr/gjLw/+Mlm+ +9xRDkn3W285LXfb2WLaLYfHSQ2d5uyy0qkrX+riKhtaF0x2WZx+mHpLFu1wWW/Wy +iEF+gIHkOQzjsys9+Wk+Udl3ipbXQ8tDnfcUKa4JSpvMms/k0lcHHS6sTWvp35YO +EkLdo2b47JVYbgwnF18sa/FeNgwwHPoGrcNLAPhT+6QuW0N0aMs5IG0xb5+PVN/f +tTHMbKfvDrUagiNm06oVaVK/5svCHmNEUb0a2mlmgG02PKQSBgeKoC5+aSceRzks +Tk8cdCWclznzDDGGhxJ8CTdSB2b6a8d4VWv2tnZ4gfHTW6RpWRZlFSu0dt4kHla0 +r/eTa1UNB7eE5Atb1VdESHn9SAiFSD3GwDDN9Y+KRL0W6Lok3jeANd4Y/mq8thB1 +JERNrD7g+NYCOsIIbt0YUj/HYsU3IBJ0E+bAKljTH5BIy/VZTuGm88ss72A2QvK3 +QpzPcjk5EFGZO6DNkFO/1n3q7k9j7o3Wma8dzHaeeVLTQ8Qw3VXydzZAqiRJmQ1w +WIgN5Bj8AwhMKnLHgqgA1vWOE/ZrKvCdtWujLhxDt8cebY4NwqyfmeMGmj0jgxWJ +vaLzelBwxi1toECf5WCFGStqHW3sz7C4cAglbvdANloas976Tb1LpmykqV/XnAAr +MVQghvcKcmCxg3JKmQLlCa8FNZaEnmhvfHroPhmJAhwEEgEIAAYFAlQAsYwACgkQ +T616dThFWdsUcBAAlCioUHmebvQmoGHldYZ3GnudvhSFU7e3xp0c4mSqc9Y6OcZ8 +JzEV+gUoUh8YQW4r5BmaJLQP7rg6VLfNkTUymxGzXW1yezgUI9E2df5XtgEyS0Ij +j2iHeSqbN8cs2B6k7l3ZbngIhuoYzKB7YcyjRuM81MzzH09FPDjHLmqTyinGoDac +19vbCDWbp7RTiJDjcjvbEQq5M9dMusp9ZMNuc/VIknFRF9o3OOQe5E48aFmYFPRq +ZJlYJCB3jnvWP+1ILQWqIzFJmjkz1H1yQIA9uu5B4/K2e6a1BFXCg/djxC8zQdSN +dEmVWhxTqPYRZLCC6bHZmKGrZN8YASOsOQBlWa1iDKKDtKjLngz4LFsCBOBKso7a +jDCkLKYYKCdduWnBuJSiDYW7N1lU3sCqc4vh1f6t6EjFK+7jKgXKByFwWS8sskCL +S2K6FhubuzrrYHtBc/VXlJTau/qU0x/aa1jGSlQbQ7C2jA5cjX1S6JxwH7DLLpq5 +z67OYKI3uTPmGGLI0+h/SffHDbEOyGKAISc1YqsBH4v7+NL12AlNxQhum+DYv2Ru +oLkZHUUaLoOzqq1fpY5PC3jnAJSGSPrPHD2TzxikGLsWUvd4jbogDgk9A9ERWu9/ +xV2Xud7uHKUyvUm08sWYZgw6lRqnH3CQIOfqCw/Let31ILuABqPIkXlmvjmJAhwE +EwEIAAYFAlQxjv0ACgkQiHtgYYs8Fq7YgBAAqQBoOmKIUBC8YyZ7wiUrZ3IOWbch +w/YtedYGOkFKS21v7I6XQLn2McZN5jSNjAnyRaos25S/n4DVrm9PEmxHr8TRz682 +lD/OvWKOYlIn+fv4xHqpMm6HEcQZWZsobNeBhp/nMEmJlz4S6vprO8MJtmQ0/mpM +pRxvn8I7Zk2uLsqBNgVyWB+tOV5o3NuLP+6sK9HQWG/AFVkFNbDZNRKQtzgPXiZF +UoIleCGDjW4KE2tUM/3ypoKok5ptc5YJDRRx1qQmU5MVSQIvzSx3z0/rCKkmgG+t +nDaBBrxs2wpeVg5uRAiVZgjQqvq1iBmOGNwF5/B2T72V1VtLUoYXkFL5RcbwgkOL +9kP9b2xxyCmNevzmKNnmcB8/0x62P6NI1Rpbi5CwmqWc5vHZzNBbC/H1e5SmjSM1 +W7Uc30fcyiX+Vo7xihuk+vlryZG4IQKdM4sgrsqb2efKQMw6e4FR3fNeKuz1lwnv +JK+radG9P4dhsbYYfiaXw32MSPIiHFiQ+k+pHVgCb3Ofs+KZ7tq8/MjTauAWFKUg +8iYb2q0/9w0zHjUBe5g0rvz+Kppjr3DddgblZZN8J1+vTqBUgRl5l7BQ8q+efGKc +12qwARWbOUZf5Af42LOYN/GftztH4MViWMirVa6L3OuKDuFitcKALLrUCo+G4z+N +ItveRqgoWVZpkteJARwEEgECAAYFAlTQTv8ACgkQlOkt+SqqXDvsvwf/fBYIQe67 +Er3cZIU+iZ85UTQjpsz3a/21gQwQFuMBMaORgdH/Db7RYdqVumihCWK4U7OaZAgV +Yz4s/at071GSmqykkZLapAJOeijuWHW8WtJqXs5N+j2/Hb8m33UPWzE5SD1NNc5N +l38dHgQrtJIlFjB2dyV2XHzr75NXChhZkIBOznvMTAXwenMReKWGkhiSaFq+n+M1 +2d/FjM/Y9xY/+E4x7uebD7N37ZLDWUE23xgiGgKB+NIGPkH/QVvnIP/niTBulNqL +SFBoj+aIuAVixITjYwEkxIJLdAlzGs4qyMDK65nBYLk+PiaaW/sW27tXNoPCv5IP +lP28ra4DQLi4BIkCHAQQAQIABgUCVMYwBAAKCRDDjoFgoXhB/rkyD/9pH6F8l8Jg +FSrNEs2YCbfev7lb/XZh2qFW6kXumfUL9CyEQeDEhnO8E3vcjf/znWJT1ScpNgAe +05NrB0H2qDTuSKldwIe/m1/VbkjnUZxX9/mW44texA6LQG/kg/4mYEdMacId46KT +lFKiXBSI8CrfKNJduhwjcZPXrV5ysBIU3S0fx/cBqPRwZm1EwiobiSz1rfzW4Nuy +Va8BywPuSAVovBUjUvai27w/EVUEXWntrFgIhBJFteh8gZ2dSNDJF/AZV1VDsgAz +w3Xh4rg4BRlMswGlQKdKU2BaHf6FyMQZ59k04/olTkYIDNmz73kl72FZUPcx9O+Q +jPjKDLF3HCsFX1b1tZeuOotvjkx7mljjYG9zfppm/EPfKZhJ3NuUdFkRBbja8EMh +cLAoI5HYookY+L7AvBFfj57Ba2HME7pP4UTpMnP/Y7t2SuLesbsbQwmJb2BXiQbp +AYeqQCcWX1Y6Rb+/O4EN/x83B9kcra7kroYevvFtFfWCVVcK09rAim00KVeKbjt9 +srFbyfjiQ7c5ZqNQohA6USy4XjK9cC90HMrnKo+LZW9Jp2TNRqyRgvOrGJE/Qyb1 +PNW8u5v99/McwFLZtMzurLv+0vVDOK+kFpSS8SfenAPQ2z07wZVg/yLaEnWf5luQ +CG8kTTms4RWdT1mB7nsk96UKEvdFH6BuOokCHAQQAQIABgUCVYAyNgAKCRBXkw2r +C4awZ+cqEADDRlHEr97H60eNryRb6IG3KbbaVk0UpMwSsgLMnXi9tSbnptpdDuiF +KuK+Y0EtcqqmlM5A5P2h6bdMzmiXsf+c03QyiXBJnn0L5LkWl1QSH45XtViutm+8 +JIRQmahpJPknIzr2pKTZ4hc5H/Nn097Yzrdvi+MTdihbO46dMP24HQgx08Klbegb +ciVT5j211QkaApCBRTNUHYKKY7zN2ynUd8JU8tdQYnYhUfsvqeDIgusZdQmj1er6 +1vOAj54UgEfMY8ii6z/AL/q+kNW9gyMiutXN950aN9gzdMcoR2y0L9N3P8FCNsyZ +BIbK4jAJQ5BCDR5j1fsRZDvyV9qoSUIo4fgDJ2dxfWLc16NXZL3G3+ypqSVrNfP5 +yjKPZmRmR2OFZM3bkeQFkhthewCNIOyIDcVQbPllTKOVDGPme4sXcuVjSdObg1Av +rEW5Jar4UqjOGooI8eHoSzrg+QMYG7q6IfmX88wuLxIP3EOWBpRp6RdKSHO4pvPN +dFXMagUp8S3984w0fL9+PdPv+daCSGPEkRWEBKutmYvyfpmD3uj01SyB6NE9goPN +O/rqBSWUGBw0mT5BSd97TSGJJ9capvGdoVgZS3enQKETpHHgfIfehQjJ3C3TwgCy +DXDbNZ6eBTbo6xiEEksIItwlXPf6ChcurwAd9sWt7AY/HbNUepz49YkCHAQQAQgA +BgUCVJCc0gAKCRC45Qh3ZkdarycKD/95BxYiFvPDv2QtVtvZMOE7D+5bzaVNXdhi +BIwm0gxFTIEs3dmc4+9aGlYWcLhhvVinSnrCrZKPB7/LMyvCWg4K/7W2Di4OJodF +Sw4TuXTKOvTh5n63CKV/yXJRt7bpfy6oxSTFUQ5tmSBNZYxhgdCwTSL05NWWX2r8 +HfBF6eqkbRQyxFE9Wt2X9CYVqgNBW62VIYGTAB37f4YQJB7cc0wlixyi6WpYw2tb +baykCL32yX0/mMuEzdtrsX6onYW32wYmX2nwSncpt8+LUGjnrsXA0rFkpL6cZLyt +7XI40b7UmSxdxQLuSjAicWcaRdjS2OLMV9M+0Mhf+omq6z+/fctDFVWWwtaVROzU +N7KaJE6B22zWkGeyILf6G/7GKMMQgVT5ZPS6/n9r26EKrA2PBd0pBrV1XLsVc6Gr +NhYlMDE7nmd5++X0FZiJ1WJcqXDyekYXAWbETYFeD62+0tJLj5Mz/md/UaZlhKEI +hIi3ipt77p2NtqSn/gSCubAjDr9mkV9iCfrherUfY6xBJiO3+FaCXsJ6qqv03RtB +V7iNu+1fIU7MBJyTyvDOb8jkfGhzpyt1MHMw7GOdsbtqfVrvY596NJlbdXVC7eE7 +0GfN+6drd2X2ZfXCapTRRxvIl/BbyXgkMTnRLhcHStPvEBMxRZ2uSEzx6KeaZD47 +aEj7c3CHeokCHAQQAQgABgUCVLSGLAAKCRBQQfGJH0TgkBf8EACic7OXDCka7N0X +h5ZHTkL+t3mzjmkCLjFoZ47Rjp/up7t72TJjUiN/AdngeKvNaRyrvdxSGCQWSqT/ +AiXkVDBBQGs3M4h/hNeIfqRq36W/3/BvK3BNwqjWVzFdWGkNWRTixoW09be7Sfof +hdjMG1h9hLNxIAnmTsWs3SlAV+i8uM6Cky0UeJ/4c3AkmXu4lYHBtZr9uljFUekj +yhU0S2QT020qwq7Bw/pUvoxP2JPQ+RV6B6XiuhPvd+RlKeCZcP1dEywJnGyMn4UV +Dy8SbpSZNkjkDxmSwDWAT+jNHHTotUv90MJEZdwtX7sNkhycR/vW7y1+Hitvw5vY +Q296dn7Teg1aC7SZQB8eQ73/rOzaWT3VoMfEz60MuYOBOGNPumht5qCI6FjZdukP +/0ftwXe1VFrdBGqjmV3A9fhS8q7rt+aFNRHDt02zXgVpOpLyUNbv0NUTa8zuuhqZ +ZtNeplMOJdJlUz0UYE7KEFlLBJxfJr2FhVGlGk/MXkkocnYvdpIgV7HyxrWsX4Qe +zCJgzm3lBFGhCapvAmsfC0VEyg6XIdgjtIENrJE3HQL/c7UWendJ3NrBR6OHTop9 +H+U45zi+UbH9CddOO91Ybd9Q+5Tw1MxcJov+8GKz5v8ShmVA3UhTh2axYHrhLtVy +hqHBPZ5bR5pzsUVI0PGj04XGY7uj8YkCHAQTAQgABgUCVTbNPwAKCRDHiMTB1FUN +RWJlD/sFIk/QVjsLxv/CSMzwSms7wBgZtzkHrC+baxbHYcnAycX9MTN67wgHh7Cr +7rxk1DcFp12ANp7+ONPZz1zGDTZ3HvUzfeNsy6Jll3CuY6++rEigF/Lc0Ha1Kevt +eviLDmm2SfL+goWKLmTmv4gy+BTHJNnZR7L5k4GazWZAq+JxA8n1IaOXlgBEoaDJ +eiiCmYLFDos4PFo+8+TkjP3X7Bz9NdATTRdASGNXuXLGzvy08xG8cyfH+A1H0G9B +icWlgTtnPkijCLo0FgYrrPHEYbMvxh8kSxiYO4+zyMlR4/93TMlQmkzImGzEHyYX +bZTcvsHP59D1dZQys1xhvXnc3PrGBBMR7gW29xJnEUTBDRoJf50t5EYNXKagJxbd ++a8qMJzccP2jOt/G5agHNwo1M607ghwnCQArAXFEWy8eR+Y1w+MtivdxblkxCB1m +lWHY/p1Gy6+4klKYemb1LASq8kFYI7ywrl/qTecZnT9lccKdLkLK8q3tGRAqqnXq +UkcD1Zldg6jPjuy3nLQRjJI8bIfmcBR6u3ktkZlVrJbda7AfcEGKztDB6V69JNSM +nc9+Q45MZFJ0rq5vEY3EtpGajrjT9T6N62NwcgXwNHhkgApR7VO2HZ3co8cy+V7Q +3Jah6ZcFQuJePH8VHLfyDauw/9XE9V8hQgOmunu2/Y5MQpeUY4kCHAQQAQoABgUC +V1uYvQAKCRAtNH6mqmVCHQ8BD/wPQuM3N4v4zg9uNQETVjzB31gR8lkS2pXP0aQy +SoMUnfOuzLl7HPY2M49xT5Ol1tpCuhi4CQW8KsZQMfXPnd03ADWdu+H1nVia9jFW +JwU6r0wxzhUznF/IMyA6F+IPAubuML8UM1LJmRIbkq4i4WaJ1nFOnD/i1QNdq8Hr +zPcwwshGpLqivbdFkzhm/3Jq+tMJuDyNPqx7ukc4HiEziPYZCWsrZm2sDkLKwdv1 +CR5Eio1m52NwTjfVUXkS3ydqJFOEjm47cW5irRJ4SHtdCKL6ZhCQLiv3IR3BZDVY +wv/SoTNmDv9fKAcS1Rx/yFObHvKKFR5USnjaKOV2Dhzl4txXMArWyZG0VOaV5QiU +4a7mKHL2Bc4EA9jQnCVgD3HgE64EU3crGbHzfuq2x9bbKqix6yrGpkVhueNt86yD +lB7hk+fGPNJG7sCLn/5TQPQd9xI+gO1O3a0MlHptfPJjCoIO/SbddnPESEeNBlMh +Dfwq+8RWIzQl5PRk2hZ5nih5VDBQWI8ru0MVhMgvOCend1xMkAl5iBpAyFwpwN29 +Y8YT71S9kpMKOVHz2NZwdl+1D5bfzI3YqQ0sX6y5Q0JKwebCy6/3ZV+l34MihkP0 +j9l1Zsj9YM6+SXm+vYvHYn1bqvHOJJYGZn4SdGRMJFdr43bydc1X2rHiywm51F7e +g4GLfokCHAQQAQIABgUCVt8E4AAKCRA1LGcgseO5K7E8D/9wSZ5ymn9PpbqcigKD +0ue14zLPkZd4kcp5IumsD5p65hmkW7CjxQy/GHWAzC1faY7ztSQbuRWsDK5BLNlV +3HM6z56i/CrcNU5LToCkGULCJryHkQ6RmzkovKCC2I9xxl+JYH66qxJxAKnumGOe +yd4J1dWYGxhQpN/CtiwPflvd8d9vxYO0Ym7d6bPBifRl+CyZf/L9Gmf1fpRL0t+1 +QiBZLOJKBudo++VXLvJIvO09GfBm+sGP9NFFbjUCUtA8UXdIjrUJ8tmKtjnJqaL+ +r3+Re1RX0XYcqaRlzqwK2WoltBrUG6Cp0QIFd6X2hQxrAuXKoNfXAncE0YOVygWE +UpR9qoel3Cd0IJMCUQ3zFx2FAdjr8udafyfceLZXP/CO5jMVLWSjschc6w169wxp +An8GfHmwRhv07M3ZLQK5Ia2EziWVl5QBTQJC/UZu1LnD25Fi0C3OSg0DWKw/xYoK +zCFS+mD4KdcwpXGE5lHOl1Fmv7c8ffVn3LFqR9l+oOioA1e13DvjF/X2cCDfeIBE +6bdFgUxjIaM3J2IbKxkscvEUAJPSUvmE6qjmYRSHacgzyRwxAuHPrwK2qqpLtva8 +1qdAMlCZQA25n/iNN70oXik2geZlcx+LMeOdEd2zx0VKpPeJx1evGkJYvI+7+n/o +883+pXCjGXjgn3uTMJ3BCST9vokCHAQQAQgABgUCV1MZzQAKCRAJSwnQndU0bXip +EACPqECLIgnPSvB+Gz4tJnc9HVpyJpyMYgvWAKR4gAsdx+1NS9USiaFMyOdDXtYE +jD4XILylRfCqt9qseaYlBP0yz4Z6DdWS1JJT6NgSW8Krc0XEqGa6oe9j1HR6aZhK +ty/i/qCiY5Ic5oUfoEI3f8Q3zLrlyo5TkZEijNGeprWgXkAbytYN124hGco2pcUF +PYpcKieooJuZPN27vbo6iZFa8ZlpApmmhvdwcn2bof/XCpaHszBKwmSWgFNTHJc3 +v4+uFECYH9dtk9/l4TagG8FoX7mzoFBd5gf0hgF5fokd12nyl5RMWv7tCytaqgC5 +kKuWHSl9NiWYinfVJgUvfauvV2TyoXqNG1RX/NnStMP3zCxEsPRmHP1ywTYrQhJ8 +i6CrGNBfpbChzp9r1aNc0rsPNSXlj//PyIApZt7mrCheVSap/s6bmHgsHs1rrZfZ +XLHCpng1WTLGo1ZWkx1moooXlHSDY6Cv4Z1dExIbWz8GVxRxqeQgbPi3rKxTYX5c +1wXs2LNycWIbJ7EMfVh6qvN1R/IGufIc63VG3jIDpjfNzTJ2YxpRO6bB0YkKu+U+ +EsmXe5YxwZGDyuLaqJVdwGEnlzmfJeYLdCX9YmDo5zBvOQhY3pN1tQN5XwH0oS85 +gz1IcrOlkyjazHd0NJBBOEVjF7dQBLxpRYHWHlTtXGXbQ4kCHAQQAQgABgUCV1Ma +zQAKCRDAD74tkhkniNJ6EADIpESSZFvDQ60J6v/zZSGN5ny84YHE2d1LITp8YK8M +Bq7dR+08qZITJLSuzFO/wRguZvup5tjNUpims1VEK8LuNzns6qkp6V9tjzheMsHQ +jYq7ntuOuO8GwlzRJ4BUiGIUzZiyZlB1LrUyO2D++jx32vhW+eXDs6aLMHoYn3rV +wDmRGYkdTHhpqulU6AgwTzlsXhmAtmNXa9CWfGUPfnIZ1nY9z67eeRV61XkIm9w4 +DF/YGJhrgi+Km6qHVnC1/nojeATtj/VJkLG5ZJuSKB5vDYJUTc377PD7A8rQMGSE +bRD3bSyPbbsdYpvaKakHN+7d8Vjy591XnPiBDH80ZQPm1ke4XWncpABeaAsdVZBJ +3f7HfB8PPgv2hym2oydo5CNsARBk/EOqjz/eo9N+ERNHhJOVl8B3Kd1dyrOFK/ch +IkTO5rIMilmRkJHtsnOOHXL83oh1KDABZ2rOZEXm0k3ZDWQlcv0/dO/9lU3LzZJW +TF1N8EXdCCwe7GexqKmTyaoXi4KI8xIP20vYXvJCVUt4gZymGygArcnvaYP/z+xv +7ujohsB4phnF4KK0tpfY7lIL9D2KhPHD9A+fYi7DbFvNBh9awtYyxBfP84GpzOwm +j7b+AiTjH203e/3q3wd6Cuvj+wgPx5SsHydMS5jwuSUmALydRMTW4RWi0VMgY20I +i4kCHAQQAQoABgUCVyN+cgAKCRCHVo8VYs1RMnzWEACVxwTKbkGw74Dw0b4o0PNt +7U93hKToeS41hCb2iB4rPEJAZqhuJWhwkr8Xf11L/FuEeO+cuFAF/OXR/+xbSpc3 +8XyqQQnk1eLtN8ppxcOtCa3RNsdrB/LVfzx9mAnWLJ5chklG+eFo5SLZzUpb9b0d +2Vl3p7InLVpJAsHcKi6SjLnIy3rXeD4oqOxAPWIaQMe8QklP5P6O7Ym9/vAwgTe/ +74jzuhaKLQWwD5le1Qa+Z3Cw4WCmux+jPl4zVYFWLhLm++xI0a3cBF18DOzTcwG2 +ulHbBFmQ8sfpBMaM9ebEVpC+dk+RMs4psP4mnMRgpKJX6QDFtsXJo7hAT1/6o9F7 +WDq6Z2ZI/bqekyl2GXSjbL92pWVr7eSF3mNPBQLYQV4mNo+vIFecGvF1LNPMzhaY +bygg3fa/g2v6INnp0Sv7tZQrSOQJFzmtoZ1ZYqsLDvA3JW0KjoP0ZjjPUwUq3rK9 +HE+4IHCrThnlX1bJYO6ZDo/HJq+anw8Kt1UCPbYzvBSlAMoPlmHFISUr9s82tl5S +G3dHH0N6NNz0K/zO0xX8pHoT0GxkihrpgRCCqk9J4MfjUHvwvLSpIUzucy9s/kfr +DgTyXQQphyjk4CqZxMioAmaVI37OMPKLFaf+hJN8BdmRNMEcwCgemv9JNImgYye7 +QgDhuxLDJVaHa6pMeE2NdIkBHAQQAQgABgUCV4EergAKCRC3i5CPI0MPgCYQCACZ +ooYM5o3zT6khnw/1lfPjMqn7kIBNBsA/P3Dc8QBC+iM7jdFAXJDC3zQHt8eKTnkz +Ww5Tt+93sy7JwPYpWj96yBLeb1cPQ3qZdvwPxsJdauhL5+RkPJdl+BvXzJdRWAMG +SlQ6gCQprUB79FIpwHs+oLoNI3BUpCfDx1DcJ1k60kse1WpHtfK+qHbiNsrVOjwa +Hoi5jNpcaLzAjfDFgQH65Ja5ZPUMXcBkjJKRNu3hFlpAKo3Cd161qJDBfS1i43aY +glUixeyfLzOb1/OmVhX+0j5qgQQy7CKnV+Vl/El5yDpGCS9AT8hUbCN3XdOB87E2 +tHRJyVayPQ4EIwk2HaCsiQIcBBABAgAGBQJX1kl1AAoJEAI8BeLJwGjwjHgP/jLU +QiPqAUsKmgISzjaJOMThSvVa7ZozT/G1xiJs61D43pYfWvXawkgpyO/0Rja/SDMv +t/RX7MWf2GCzm50O6KHMLgNRyII6zAJWZauFMAR6sng3AJWOp7U3mTwe+ZzwWMHw +/r6GtEy9GW9hW+izsYp0LJVrxZ4H4KtuFrbGJ6XMOHNAHXK+zGHg/HUlcG9nreeB +yg3fMZwkJvjaPc0IJT9rW3sRGuitmPSd27320xIEsM5duHlINDHtug7W9fcw4GFs +K0dOM0VvY4T3YVpvSxkywfmaYwuje4bSaaCdA+a+1ITvm1/BfIFGRqn1q0CjSXpQ +58SoVVG7A8bE0kpX96uInVcgVBUV4KnGSnFQ3Wqxnq/U0MWaCJrBE2MLeKjVh0Nu +9V3s3Xf4T0MM0h3dbVyYFlFBkzFbQX++k2nXCp54JX7sSyy4SrMnvfZXzcaoq5HC +KBenX+wF/zV076EZBiDblihuIXJus7gMQqSWkUeN9mJZLS25f0Mf1MxmTqTZtJSM +T+RCOC8eAi0LAlRn/1vphIGTciZ+iCRLntMQebdXLgxMFD+i/VUMgsfPutjTMNfm +08MQaxHaxAIQQglLW9lFxVZ0MgUDFWVDFlASmjJmY4YkhoHnCKoZcgRrfsQzrjGF +Mqg6ULl7gVSQO4kmmw0tKFihkaIHWe3AeIcyo8XPiQIcBBABCAAGBQJXaWDLAAoJ +EIs9hnyCPnphwz8QANhFGbu+LRHKhOHZ7f18KZQeNIWVTi1Z8IJMpwomwOp2JLHq +BPKdafSaNdXw+jiLKjrNsBr/gL+C7tojn5DTSFNnl0Sw2RWruAKG8T8ZZCJkWoCt +/mbkUFty/EbhtExfKprKg5n0GLJdqYrWgcBKGhr16l6vrDe2paB9kdxuWr1/eYjS +vQQxLDgqFsvOAC2/GL3lKLSpBD3+WeRPdNhDC85sBhTyIU8ED7I3iHayg+68r+X/ +uYKJq5GyEGJHZA/RrnH2PezFMNOjLYaD5K4C3ZrGNxV5TbstIN8OT30sQB4S8B7j +dxOQvsa5exocYe4HEyE8sO8vJ+cZ97RzTU6lSFSY7bztILZq9scxllaJppxwK3J6 +6RjwWGiVR+wxvSPVEhBgsxH0F3eYj6hTxUQEMnne19WgUmcykv9vEcW31JTJsoOc +hOv9mihlzRirodpUcwkKIbmPbdT9dHxWwayYV1w7KhvTuUQhy31whPV0FmRjYUsS +4LyNBa8nL4pt7P6WxVzwtBccLLP/NeG6KRgDAZD19fnVog+H2y0zM+j8ogjxPmEw +WGvk1ikyS7ShObKRqjT4L+2VgZC0e+0gkJ37tAV++HLdZDPRFQgzKqD9+/gfnRq1 +6aiSrd4crIKN2iLGFex5go4O1aO2HW+LIuWxwwyOvErSuWcUGuoDh+DmaH1viQIz +BBABCAAdFiEEa0msutz2vRyiBmerzVT849lkvvsFAlki8Z4ACgkQzVT849lkvvvl +pg//WWpf9Bo7bllTKkkKgpTGd5jM50aEhlnLCSP06lspws54Cgt2e65El/KHl4+X +QmfIFmpYot4DQIhE6TE8PEuMWmDEFfFPMnvW0W7RmqwDq2p4QN4DOY9vGBzTyFn5 +KN7/8nEkPXthv0mGoM1/C2iOk3tSO31I458WdJ4Eaoi0vcO/LQClrdSCNN/3DMaR +nGWJSRF1gTRApLy20/JjlvhNjLX3fnIWFMkK5R8pJ4Uk8L24k4/4rhnhG9EVfzhY +D4+S1fEMPPxrninKB3MlJfxUAa5TS3sbfKUrjpqFMKLAmAxFt9FLi9TqEZJsRCjB +MnUozoNJX8l0lGJ24p1XOIsCr6ngvk1BUm8itRXK7PdLgugtvLdVIFm3vGjrwIPX +izhdztX0j4EB9n4HEzlfqf+OOh1xvjNnN5Zar7dcJnf5dmXndEkYR4F/hVyQ74nQ +pnKmUyZKvpP8SrX55V7ckvEZ4ubAe7pdk/Xjwe1onUzXC77d/TG0dKmM5Kg6xyJF +kosnEtXiTHFRquVLxxdxyFIAlGHhQRdnwK7r+30NkWvzCIx6FcgbgjUXm0fzwgE5 +2D09LtR9cpE+aO/4YIhBJvSGOR6Jr5xofcjfejxxENgQvAHHc1rgkUP57xlbIfuB +2BscYpMEboqYJGFlT0TLAwGJCuUah/IVu2cKQKDxQcB1Vcy0J0JhcnJ5IEEuIFdh +cnNhdyA8YmFycnkud2Fyc2F3QHdvb3oub3JnPohGBBARAgAGBQJMPOXrAAoJEIwk +0WCPBonUh8cAn2ldzFG71Isketdmw2VkYcyMLAjpAJ4g+NDkZOce1wzeCo5RBlvK +brnp8YhGBBARAgAGBQJMs3sSAAoJEFVbl16VO4aTs5wAoPuhi0VGOb3YuYcTN4Iz +y5UjzX/0AKD8pp5+VjsacHpRK5TH1Sg6xdsakIhGBBARAgAGBQJM1e1fAAoJEB2o +2jPdzWhqCE0Ani6+y+fDvtfiYAKDfGyu4eCJ8vywAJ4p6gqzbj7EOOicAcGJjRe3 +VtV2JIheBBARCAAGBQJLV2LdAAoJEPrvEpNt0+PsP74A+QEejTqiV6b2SBuseFGG +5pWRp97SGXAupL/RbvokN4+0AP4rFQjcYPiKwkvNVFvsxRSskrS/v+QocJvjNh55 +5rrnNokBHAQQAQIABgUCTdFlKAAKCRCmsfPw5rX1o3a/B/99pdt3RemIlesXQq+0 +c+2qVQaIU4j5GcjUsKM586u5sueX7HMX1a+ItlA/l5jJvHgL/UKu3fOXXeutYbJH +IFI6qmpaw6h77MmY5TCGcyxS9NeE9Srdaa65JRPyAV3CU6iAZV3Vwm+ximvxOAcX +/uB77XLPP5PkRruz2OizVP1OJMiIaqBuo1aFhA2LK6iNj3t1DpmHFbMgXTEgxV/E +BI1Rj0r2JK25whiYSPK6khTRpi2WQG0vOmSzTqhyY0WdBjJQZzsMdzCpFXvEABdo +dCR+vb4OO20y0g0ekw5unL2L69H5oFL37Pj/fCK+LHo2lfzlvhtcxc2UWXcKrANq +aOxniQIcBBABAgAGBQJNzOrpAAoJELjftxtf7L2SlxcQAKbrpPWO5RKnjAvP/Rtx +LjA985jc6oHnrJX0YElPQlOAwTZRGqyJf9MPldv+8nhhdfXuvkhcyzH5fFQTCuyv +hzHFPK8fAY3qeIHmcYIZUy3luRbbyV2oKhNOh79KErnJBye1Y2gRgmvfQsDaYBDa +GgSMY6HKwrTC3vcIiINbVjf5uCCMY+Mkb+FbrxQEQkJFj/fSx9glCnGUW6vwIXDb +oxd8AHyGb8tWy5zfW3pivaxEhc1cjvMnkKRgAFYrIfAAnqey915+VocOwkCWNeaa +v9JKyRwvqb87Hi7gnsOSr9LseiDgy1CKXLyAC4gEb/jZbYwXLRnrtjZAUT2dGsaE +Pmse6CbSCsYtI5DQFMP1yQyxMnuZ8mr/4bDRC5EAMa0vRH3UzqlcTxepDSl9MB4r ++8UPP42lbFdkTPknDrzwrzM+caz3k5B+XVZCDoAW3blXbTdk5AvtYqHlzakPAEDD +vZNxAILglLs0lCCQ2Byc8YTDY4YiHhSdnROGhu7KMxVBeMujdbmjQlJlUno4MBK5 +zf18QO0wFzdXehbaSG7Ju4FnEQFQEGdJm5N/8hrN0lAGmpTu2qt6sKndO2+WESBH +DNI4Ky4m+0DP/TWNz3aaT1aOyX6O8y3IQ45ScaqNOaUowPyC+l8hLD04EVlkvx8g +rc+0xmgCZ58WziCMW+KEYjGMiQIcBBABAgAGBQJNzPDdAAoJEOGXASZ2ubc5W3MP +/Ru2UUgesZuAgCPDFJ/Xs5KECuMgljNVKgHfgYA4xK6eUj0oHRDyhhB3NBkZYfPV +K3Mhf6azGTfBHKDEtPR/ZHNCu0IUnBhlIlDgiyRdXBRhAF59IWT+DFD09HTQM+hW +5vqe+XVr6lRdQhuFzlkYGAr1MfgRACnGVNWV1gc1QX9m0LTiCqNo7cifoafGVoDT +CRnwEI2RiqByTdTgqlCJaHaAUoK7hnICQJeT0ktG9232H3qzOyaVavE+iZWRe527 +PrvnWVhBKy3hKvCoGADRqrJ5mAvNzySGCMF688NV4wyEy89/0sRUzVFUmHC87hkG ++Pr2gDXNfoDpxj4iGHpZS95f5sj+PBthbq6khHrKH99CKM6q2ST+fOTM0rf2aFGC +jqxELZkIFNZrKTweomQxYvDOE8FrGpBmP2G4vqbilYIuqQtAQ3MFOl5bwwJd1d8Y +XDrN0WK+hNODwip2i/lOd+srXG8TRSemZ+UIVkZWkHFEJlfDNc8uOJ5nKUdvilde +zHKSbs8tVY1+Tw2bWZN5BXqCAfLOtfsCAiuYtPbelnUMk+bo2YIwqRth3jgpvRzu +aeleN34odBDhqYM6i6hrHsxba4CKBVfHvbrFzmCTXXktApxpMsRB1FC1fL60tjqs +Hpi9lBq0ODwaejw+sOpHvJBTrW6fIoYuhUF+2TK6/L0LiQIcBBABAgAGBQJNzTIp +AAoJEIZWH0UhgPz+t40P/277mVwZDnXSRnzgUv55ZntWxzxJOqAfr4pNGvUd0t/n +qu2IlMb2GJCFKuRmu51jW3ysV2sZGuMJxiPWkt3C/JySnPc4ISKg1DNk8bpsa3JA +c5XWQoUhFDM3UR/avPeI0ShOswJvzhBZZ1PA/r5O1bv9MAs0Mgl0Cvbl9lMwmdJu +QoV+eh0piwaxsINdxjBMktPoHMglZ46u9YKdEaK7DLmXiBxn47S4twSPaCDS20TD +5UamkOsVl4TgoPN155P7RAAR0t80S0M0CqYMIwZjpaBq3o3LAn5z25y+lDU5RjD5 +lhONxnLizb3rN2watExukydTkBHZkRDPuGx035tpqlHTX6wjZFDXOy4pXWLzXUWH +HTp/i0QpF6xhvWULuxcGneVPj7ubIAgY6++77nXb4iAiUUdxXr9t84h4TXGZglut +6bgwFakjD9j9h9YAfuxnK8577TOrk48vhVFDRr1MsCHlejb1gdv1VItx57wE7igt +9twoERQFVdaWIFsWmhyliiYsUAN0QkWyWnWObzcx2Egrm47XEDLX8CvkeBW8hX2p +osB0H9oYwvIEBnJ23doy9RG+YL8crKwypu3NHhTWKuEzZh/yJrC8FF8TaAPLijGT +qhfvA6KfuPwszSgU9bDVXqox3x97GUpLLe5ehT9LG9M0EzurJqYRjyrHOpUzLyZH +iQIcBBABAgAGBQJNzV18AAoJEEXXfp4wyxsRpi4P/jjR67ZKGzRImsm4fOQc+pjQ +L/B+Kfah0uXDNY1IQnTt7KN4iisdopsMlixKPqzD7Uxs9kqGHxvB/9JPihLhl2oG +8++TUnKBpPLAcduKvyNp4UlC1VduLY7qY5i6/13Ues2dSWnzjxegi6z1DDgc+6aB +IdbAooAI/+jiNEty8d20Ay7njezSbo9+9A89Gbbthuk6c1ARw6qvcdXdMAYyGf9n +ne1pZLN3GN8h6ICEO4sbfwI1YomTHBv1EbSC5holXP0z0m9Ghcnu932HIXDfM9Aa +Dw5OjtvZyiKwt027C3C149mGHpeGj21n96tl20iLrtW/s6HFFPue11H6y6knL36b +ar7RyD8NuraZ91B6F58bzW3GDLurLYmgf1V6ARWzdlO6/pA+AyewJvbh2va+5gjM +RbAO2PBiRsdhQSoiCsy6TTFddZ1db87GANCHDKuNxIetPmQRS4WGlMNKC2yFirVB +DlKWtZweJHTWGynatS5zSM8WzY2kGzO4tdOmllKMqaBvcJuqkNiqs7eLYxSYZW0C +Ti4SMX1ODRmRa8bq9xYOAl4X0HgzFKF71LnKTvymDR6GEyQIV9UaOo7ODNGOJudw +3ue7ya+2UgEneSi5dvk+rQqIfkzMm8HxDQYBKlcKuNPITeguE/Dv5f++ri7tdhyD +WPbOisIBg26QZqWV1riOiQIcBBABAgAGBQJNzv8BAAoJEGAEJqEY9fvOvWwQAJD8 +SH4jkTU8RkLrzJCEOxwX7zrNlnhPlqbvBvD7HkDQwI+uhcXh9VodLGv5pzKjeXBX +6bUo/VQ351NPyR10eDxD+Prn6n4GiEMN4ne3kT7Hu4Em4sFYz5w1vDZsxg2cfNMT +4mz1IUtg/xR5PL3+An6b2CXphyftva43/HL541KjXcx8939sbZhNEU4VY4tsMRs9 +L55gAtGzLE0R3jYFyfDJAUHUR5xo6hQhGZprfJNfzopJ1pCeyKOQMlreMWAS6X4V +BoJvSFFxxJNBJn3Pgo9lJjniKC3/y52bpzz2PMLRLqisBU4J8SKFIxnn53r9IKsL ++pNq5bD1+tavvA0/qlokN8K2j024DgfWhKZThEDpCHJm4C2sfsFDIZCeUr4EK5xZ +I8JbrCeDvxiHCgJ1e4LUr8J4Z1dKwI89qeENJRO3+Jk/cl/BASsR/9Aqkv1Uv+yk +je7lX2hc8OhU+ppMH+PYiDLzrUOywii/2/VKPAR94hBvuMGktg0XW/ELk9eB/3sT +GRw4GK8wOPIIS58K3e8CT59Z0jjdOWIRtlRAoCu3JPn36tLKSF/butVMLPkh5Gx1 +6frLwx7SLye2OCHOq2PHFnPDcVmAIL8wFfyXcHKpgAEpqeT31O/sKPC/bE1Iai6A +9/2fH4FrbsdfqLXYmcoq4URFiR8ilb8AArxikPkYiQIcBBABAgAGBQJN0XUAAAoJ +EMY4l01keS1nNIkP/1VzBlKRh3KouwnLR7iB2zj+AXtX5lzjRsChIqglP7g8RKOH +YqH6JIMGaOAH3IyRHTvA42PoUk7u7tTDL2AUXgjU2v3hhDxzW2vkkI+YPg2KJgAP +1Fp3zEjSCa/Ubh/7RjGSz14sA2DL5uvuSl7UxWdBHGc45NCprH2F9K1MbchVq/38 +dKMTkO2mlUJRWZCPP+acSBrfDl0z4SWKBH3PHDiwWctXw6Bm3PIdRiYgd/kohMfU +hegTxf/4zqtecCvn4b12bsxQb29Vjp/XBbpkhIM1j3p2/Hq4ZpiQvzpueXqepcPx +fcF73vvyJtT+nIwo3wCg4ibA9f7vpkTu7X57mEWVcLvzzXdcfaZa49pyfBO+Ikn8 +k3tWsfk2Obcsr3OXR8Eu01JU4iJARDQ6rPT6swBakxmrWKYEIbBqfJeFNBHDssqh +4Zy1sOSyBSo5C7N0bkg43Ufa4elBIK1vVpytC2xdc5ZSZigkx3YgzwW8eWiF326x +av7UbViGfw9spzPgRXs7zHdi3lL05d/JhRzyhiIPWr4WLxWN+KKEfO77UEdqHDMM +Lno3G3m5uyqV1x7E32Cbj5lAxS4egUtyqGUlFF+P+F+LQy010i1yaIjmtgtldsOS +csECagtdxgKio3tmJ9YFSSgTNSdxF7fcXUwz8EkqACHjt7kACHA1eGM16DrIiQIc +BBABAgAGBQJN0eadAAoJEMEmM+HuAYyTI4sQAJLP64IfyDHDyEYAi9CpfE2+AsGm +q1fN+NMJlOok8kz8UuiU47eh40hhYZDEU6Hy2tzkpFu35AmcLx1ijVploWUOuP4x +U3Fc990F29u1ieg76rGHIvE9BHIx+Q5JGWLV/BMjcgVMcyzfFfnctQB4/mKv6sTW +5C5HtEcwdsNDuTsRU9tORijRz+CbA10X97qW5NRmKIvxDYVltq/VHeqzUY5MVNuU +2GU2aqC52TJ93OR/rmZ3tGWlEGiq6EhYspmQjWOMMwr5mIyoKAJ6pElr3NlGiKAv +MiQjuHzB1inBdWE63YPM0nUMZfqHcZCuJJVwurCf9D0n9mbRpOFmSB86Yf9/rbr7 +oCGM7qNh2hFmJntQdS/XhN/G7gnx0lGfy53dOlsJk/hXTvQ+ayTKO+nlnsQ+cVhY +wSVUSMJitLxOxF0uCikR6shp9QsS3zfELWKQDAoTFfQTaF3J4RyLgJewfJzBbgpW +3XD1IRwiNqIJdwejKAmDFxiBtw6MGhykvsXUjBH+uDLZDFB31YWf4yd7Qicl8l8X +f/trtazBNUvFQPxAVkxkU1IMj+Axi9qI2YkC+017FWrVUR9ESEe1PQ3O7xVBB4Q4 +wvM6+xAESzjqAWdNelzomoxyc5JjJxP/Im8CxYLmCgdKH6mTdUZeTUT91WDOtOQp +BCbmlAF7eObqOmtFiQIcBBABAgAGBQJN1BCnAAoJEONS1cUcUEHULYYP/2jUC8Ey +4BYD84M9eD3D7b+t9Lo8C4Tn5JbvZwAMpvbT8UZ7hrCIWnN2iQsEBudmjBktGTLS +KDU4nXO1cn2xFKmpJQh2kaMQngZruan/1kG0Pmm+FDmwGmVglxftiN/lPiOt4g3k +oC3ocN66ymScGRCDfn88x0NW4hhxCCFTxnid4MyTMKSzXlgeyTY5RZ2FkgsPTNi5 +xexKHi/FtOnCyFa0mweHT40rwvue6OfKb5p4RPazE/raqzlyPeP7WbRhw82+9bb6 +qMICobTF4ZTcfay5xTm4yFoCpLOKR/ZxfvQEWb39dEGr9tPiHSBMiBGH2wH4/1Uy +CAYr40Qal6WnmVLvA4S0KpxjTrFGFg9vhgA+Newwq09g9SpV6tqtVFJdY8AUb9gW +ixboQ1XQIoTjGbcecJAFIedn4GUe4Y9ZA5BjoGgmDBDlvYI2LgYdpD05GQGWJLTL +9d0sgNlhzjZWZlc+OV+cBQVDjqY1R9yTkbU09ZDRfCj5hZlTIA79ZUokGyoJi+KH +1QYKfG1rhqkejaBZ6uQEXO2LFveYoJBUxwoDaNt/tWUClDhpb3jcebPrUKgFE88g +xcpHCvGqffh4rmCnUBQCJU5iP0miVLMGEWejR7VfNbVa69CouGXZtKJgZeEr4PsH +tOLOoO+HNU62UftMDhsZ2uONPoqK/vhGYNB/iQIcBBABCAAGBQJMytXyAAoJEJwx +UDxthmOWRUIP/1SXscl0cllyDqcybYEkQsWKOjlkk6faFNXFsjR0b7xpUJXNToRY +7zzF+x2CPfXHzjjqSEihr13+pZY9yzvvdP+EECPpqKQ2Upr03tpcne5LlRQmKevU +fnrCrbGlcHNlXA/RkRb3bJkWLIV2FeWtJxg0BAOZqT9izeSNRKGuclAQtPIhdGAQ +pbtkCV6wRoBejANM4jRIERnM6DlCRyhmp2PvI2buLXW4SjtQn0vefTUY+Ro4+GsX +pDeitsoJ3NsJ3sA0sXKwICOJhSBcGczT5IiS2sVLUdLlcy0pEhWNEkQgmTAoi29S +kRm4cd7I701XTQT4fzCE/SvJO2DkeozRebVOBI1jOBQmyondJ52IFmBlzqec/FfN +pA9Qx+bjnEE+j6n1nGFPjCJKO9iTSRq+BxWXrBillaK8jFVz8bOXUzG5SbyNInZT +pi4BVDnKjnhsIWT7n2hA/FnW80v2cjFf8nlasD8uPd2vVBKdZvqUIiSnK3h90d0X +0zYz+XARo4AplI6nc8G4h6YHTSKlfNh1rdSchseSfxtSsf2Hkk6ip5rXLjAlgYYK +jH8CZTW3TfOUYDVBk6jg7G0cn4GM067vZ7LfGYvgmn2zYV6N6VFbO4lXPOVZ1HY/ +/2su87TV5cVYFj5iA/ca8XotbIqze4ziY/cyzu25tKWkMkVV9eHsmpcwiQIcBBAB +CAAGBQJNzSkvAAoJEBiz9Q/lkjwYLZoP/3WTqS+2S4CH+Brk5UJstJEY2GQYo/O9 +V8o+VXGOHLnqaiAZGeGlMC+D0gB8Vz2Z0xB4B1cXDL0wapFPJgerdfMPsxcYdura +3YzJXXu65hHWWWhHKvq7dzQNJN5L82XsO6RQwYV3N8D2OYEZFrS7eNUAuIZgUlO1 +KGoBpbXfXtD3BsU5BNfNZkwTzHbypgM4rKu5E7wDEoGvC/0rm8JckJZoI5vMq7hc +F7HiAmYXuflzm87b4GpEntXbb4tdDW2LpFvxEDAM+hjihTUZUNT5paUyUWnz9r2D +L2FWcNgBea/RXbF8ytx6sskLPVxqWWOVffI1gqXEsBBaQF6Gk/hmB5zN/rNQe9Lj +gYtBgJgr13E4oflGf4a86xvrrGmQzYiWy0rybRcSjS7FY6hjTTlNBbjwQkR5jDkj +eXvwAhwJUxddhLcFZZX4qxn7QN6OdUNN30ZyQWZwfEkNERpcZbydoByAxStKg8ET +pN7Q3H2SH0YT2AxKFWTZnhx8144k3yJy7KMo6tp6VjhkecppnEWRNNodsfq621rI +WO+liLLGmb+IS27I91Yexif+WZzYjvEd3T4iyKD5AtlIjN+rxmkclNlI5GNAtiVH +JViPhS2iDxiO5zaksLjJ1CxAofx0+FAvJ6dEdY7HTDKLirZ9+xRm7xASNRCvbFpF +Bvxkuunc8s7ziQIcBBABCgAGBQJOsr0ZAAoJEJcyXdj5/dUGzp4P/1b/wkUl5aWO +kaN1pYraUl+UaoKQxXYm7RbAHkEAhnaHoVpCYwos2+kOhIZvZhevsWSQFZgx8REk +YSKINXgiKHYU/zbccoUJx7k4ZApiggp4FwWus46VXFCWziRL+TuNmJkxgLcAlyhY +JZgY8P6zUSZjU2yJN2sTSE2iec0Crb3oe3yWS5dSAMRKpKU16uxcdt/Ur79PGtv9 +/4zy2j1+8LSKu/v/LddxgzNuXfVo8EXRBcvG/9iBmY6u7/B/XB4yOh9Eif0iJZDH +iDzOehenBtER4pLB6JyZNg2O5JpnDDF+sPFm1G5ysOJOAKwNEXYvCdPYMggHvd/u +Bv8Z9RuU3yvo13k+SjAPb+dkum6mGHq23sGqpC+xDioiwasHeaGUp8jl1bR0xPye +j5WdFdpZuY9lBCEW1jEG95+eEK8VzgKfyZjKtVpX+Beid64RgqkesZJ6eQzZLKMl +ixr2entrj2ULV1X6oxeiQWFGpborVn0CuIR5Ghkjxc3qKrktY8EHeGOJc5F+SEzy +N9gLKrvf9h0gITDWhv12wJaCMYCKilWLOHMdrVR43AYdSsdEg/LHx7GmP46OqdpD ++jP8yPJpxBwH1Al8fORhYHXT+JxNyuTkU24CLC4zoRo14ohZE+hPRH1+Yt/TNu37 +7G55WdS1HFQcfFF7XbpWE6tW/TqTKLhZiQIgBBABAgAKBQJRR7VMAwUBeAAKCRAS +X1xn3+lAhIX5D/9jkKAgKQ0bJrZzDgsE/iZleC7qV/GPttTglN8Fr0I4e3wK2b+Q +YBhl/Jq+Ulo97noYgPZlEgQ1EA+E9K+h5agcfl+XmrO/xMWCWm+YM6Op82/GEVeD +bqT+gJfczLcgkbw7X/FUc3FIxUIY7SRJ39tgqeR+OSrlI5/eWStmdvEhAL5LPEBq ++HfRZImGIiibwHTJT1koLGLa/h0eTaz3h77j3WNLYDsORiG2KTIMZ+eVN2CAfiES +2e620/tRpNhWQJ8PtmNujtlidTpIidhYcBUJ2DIHrJxBZLeTcbewDtWCt7qn5uxP +zYv/p1n1VIF9KNn3t5XUO/3xjyA3TGMkAhV5Xcn5a5CkOJxqQspiGlqVSgFlVfvu +63NiYR1TDj83S6LKht38HB2vK8LoK6DUEE10xoFAkLmpBSrkCs29xql/xFl1mPgF +fENyeMKa40eqBcpm/xV7+D2DhM9o6/T/DuqEV5b/I4/rIuEX65VU5fK3wwHv9Oms +rMJM7JVEYeeAXAbt87t3knNL0zPsZZ8hflkB8nrBNF77H7f4Wu76PNNk3WtLfvld +L4PMf/LeUseSB6EjzPuvqFwwMn8UzUkjrDWOOOsl7eokmwycSAoxYhQ6fS2wkCPz +eGtYwpcLEvqhorQevFxTCgxAFqOsehrXbVEnBOuecmhUQdOnrq0yStxBqYkCNwQT +AQgAIQUCSguHEwIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRASbrVjp0sG +v7lyD/4l+mtrOHJ+tZZowG0/oeXHHma89grM2y9E3GuuW3ZRxx4RrZBKeBa4Baxd +3m8ewpCPUOiGlgps6kPApm52rjL03XqOFDZqTi1cB5pniW2N+BqAkFS9eZa400CD +xrJsh3sW8UNbq/FhGOo8S0aFyIA1gr0nNg6noUhSbKkdaIsr66G8S2Ir19qUAxNk +djlW41noN6RX202ioyAD6epRJ83/eXgPxvSQN3CdXoeMFKUBBKei1r4e8HvVL+zR +X8l0DfUUb3GQTRwZHB2KanqyqwHyDPMm/BNB5YNcD4b57Z5AGDwQG6VQXr6FdQgh +Dy0fYRVtfODYRtc7yHaWEp3wLesdBgSZIFTDSPjD2qsVAoSawuJ7nwZTNXlDFtXp +j13n7gZ5MqPWcWihTrFB1LunX/S6OCED8ruggTzZM1CzhxZE1nr96Y5NvBKtneV+ +QphXm2kHospE3bRma91vxpZ21Blm7TxEnqVyJV64Ix+c7ZOXtKT+iMN49K5rqBxN +1rvpYher7d5XtENco0s3KwsafhCQTt5DkLRf2dL+X4n826KvcTJZAn12gEdW4rWb +PlvU4ZgIQqrMpX7m88Iq0jw+eQqtIMbXI3tHYMPTcY/+aG91021v6n9ouV+uPk65 +hrhxKWCi9Sb1E1i7FBzx/3fbezciFBrojG/JrxwDpyXrbVOw/IhGBBARAgAGBQJR +R34fAAoJEJnN6p2kE1s4kDgAn1e944wXuI1VUUWS8VtTihG//M6BAJsG1gfb2Qs1 +kL1esBmLnI6ckCtcwohGBBARCAAGBQJPrSS1AAoJEPbdMwIQ+kzRHMgAoIQ6MSTp +LNvqEoJ240Ze8E60r5nJAJ4sb2MlbVE8eoL56sQP87PbV8eJIohMBBMRAgAMBQJT +Vb6uBYMHhh+AAAoJELzLHicxcmLSlGkAnjmi9Z3s/LMlllWJbP+RscF0yszZAJ0f +EH0/XHaCNGL48gf+BSziPjZ/hIkCHAQQAQIABgUCU0mPfgAKCRAEw2fCGK3U/6rf +EACxJXFUbGp3TTHleXD8xgif8u9XDtMRZcljFxoxtHjBrRs4X/G1ecnlxvRLTZVW +Jds8fA+7CKcdAl0ZUOLqHWWzg9t1ribmkAINvCieUG4NY6FUGARR8xq9g1eXWpLL +nAQ29veHHziYX45MgnJ6E5M3sicn9aP1vBgTmionqn4A4/wO9u0qHgEfyHof8GCz +CjnksyOSXNnj3O/tcX8XVjScoi0F0fgcSVmgOcKH+MC9Nwd6jq5tgvqVrnzbYkAB +Ov79e0hav/bPxj4EjWFE8twSCswXMptvLmkfwBgwC1SWOZiC7UDjyXSFf+L3p1Kt +/eoyM3PmmzMUzvoeBuP02IIMCLJvI3UssX6AhkXUifZ9yaKJNUD1g095d9Est3TO +9dNQevFqGYv9W3ac96Bg1Jz2LvgGh24bFWLCl8VIb8VecvgWKJTSZs1/7VPSjFF9 +qfrYqGNJH+k+9KG94fouwHWpkg/YLQ17on349HuekiW22AP3XLThNHbVJHEOeWhV +2Y0BpqjNmN/uCPpGc7nXMYnTkpgkwM8MZGSBfJf7DpMMQ8a2p0hXwdVlWuG6YKtc +QXynpJi/xEthTb2TgLqT+Pvjh8iLDwVFdMuE4+dVFHUkA5rcJIfY1S2uUHhqBD/H +Wz36kDM9s9GDfSFF1hlE50IoE0BUFcmuq1Po54eAF08xzYkCHAQQAQIABgUCU02Z +0wAKCRAup2ucK0ZtnfM7D/9DA1g5KOVaU8cHp6Cv3iEC/TyHZU1zPO4zuLuD8VBH +Fx4ORiNKwuVcKzn6u96jY0mPY4aqpaO5SjU9HjKtIMHKsdzqvR+OsTgYlPh6DNYU +nZ3nNbx5L3ihnsIr5zQfXnrI3CUXiTdbHvMAl5xUHxfYx1jJoT4lwaJQlABqHA9a +q1HPHzXWzIcImcqCnibFSkqnuznuTwVzsdAjyWQMbVnbaqiHEyUhd2Cocfne1XcV +RtGJgYKndCLxYRJugDNOSvzZ4dpT/SCFlkt7q0gKiDumlpRG0RM8uc1YuSlB1MH+ +513YJorl0i/vSFhtHWICf0LCnbVWXAhMACp/6rFgmq5dmjOYUXq36OlAMaqfrznG +h7MjhCu3qIQS88pJCO4dMtMiDf+s1MNkTciQEJSdeMhKCzbfUUv/fCznrrtbkWp4 +sPxtIdcC0uw0m0QnYee9zMUnszOtbFESrdE6Jzxkns+VZdTBT/BryV1k6Op74A9j +nEYH9U0vWmzlXP6ZqdFJLa3oSoEqoC/XwxViwjWf8toAL9haq8kT7serouZ+bvHL +jXAlYGyXPCacmhxi9yVZ2edKaMQ15Mu3mpU+ZH9RT3wY4C/jo7lxQYNpJVRBZVdo +TmJztsXgJtfjIQm+Oyyh3B5pyjYB85E6kcS4IxBi8GDF40KkEQww3J2QVOHOsnSE +2YkCHAQQAQIABgUCU/vASgAKCRBklZ/pg43xnMpAD/9qSlnjkUSOkGHycIRFIbyV +nWzxI+wNwVl2US9FK1bnnITvSp3Povt2QgjN+pjp+JFlInM0+ms+By6ltlN69Gvm +4Z+6OSzyArbazzDdq7dnYGhodU/UjcWXiErjqhAB0/MUrF7rarbo66qd0873pJD2 ++WpHoEmIGhYvuqPydlgZBtOVcxzO5pSd805AjS5dxFAlxYdgu4VsCMUayDg10FIE +uvoK3z+QF86dggZUyeGnCshaUaPzBcisExmkDi00XlYreZtfNnfYqfhzcWW7pUqJ +SKkW5Xb3P4pSPFnnpmEQCqZr7WCFSMmWSZoMbPKIZujqs0ygjJ/yeJUyBKNZgIpc +v0iKXPqxu7mhJQyajbQIo8t80NNVlQbTm1SGlsFjJXIhA0orALbEkPJ0GrbQncG6 +0rHfkMAJ9skxJVGGXr7ba4U6hhtnLwC41nOgX8YFZfS0xpM8xCIijPX6Vo6mbTS3 +VVjyvfIZQ7Uaz+QFAEUjwFHRAbkIc8E8zGY4ecAQ0y5Nu4EsCNCUGFnIM/YIDBoq +wPjVCGgOSN5IQDgYjEXCOEd5qXmHYb61Hg/OV+YSySbj0rzsBKCH1sKfw4L0LYYx +1zXHFJFP55K5Z0Rwe+AtvcuV2pn1Hb8N1Wu0G5Gr65Pn10x2kep/pK/dxZmivgQi ++EjBvVRpif0S8fg2xAJ7TokCHAQQAQgABgUCT60kYQAKCRA5NYfZfYZQCyvFD/9k +/ttNFNF+MGvL/oSRg8aI/FmEKILnoxX/SbQDLDzlwAWf5FluBnhkjz7ZRDodpzUy +V3oJFt+N06002GedTlobaBcJqeqNfZZuBTyISs/J39fIqzcxMTqGAqcUO7rAuVGF +nCKyt9EEkdTzkhJRpppaWVtTzRvDF77x3IfAN/Y/izquWvZ3hdokGrPjBrFHFNnw +f7B1CYO2Qb/R0XjkRDfSMJ8hYkdk1NiG8BWOSQHgZ8odls9iV91XqSyyz7+JABfx +OSkdDkFN2nJYZPgHTcKXyfGDg/pKC+8AstbM6pwkMXf6iLZrlHD/lN0CHjM21GdA +K2UyfzsfGeIqQMMpVLtt8N6wHjtm3oD9l7gNozFo+b2WSToOo0bMmTBRMg7JvEID +7Dmra6NKGUVxSw8bMrUqEg323JVeGzsehGackzzTr13/2/J+mfMxHOfqlo7vmJNU +JxowYGpCN/AHvS5Z+ZEQ/p5oMSSYJAltHewvw80migoWSGgOHypOX0VwuBYUjMAa +EK41MU4cdznJbcQLOtNOZw2qQcOaufEqb2ixwovSee0rzI02jZ/XSkrnYlkxUHDQ +MEyoWmRjHtep3wvcBplqbir/g4TQ7U2GE6PnB0ljlrY5zzouSsuaz4u9+mKfvRVB +aJnq5u7MoO4STdpTf8NkOdOgMS6myiRS7nXlzOY9pYkCHAQQAQgABgUCU1nNkgAK +CRC+XPaH3Fq3wr5yEACJVNY/Hn2PlUv1V8a0D4jx1BTHhJJd7IR4XhHR2+/U1lT2 +A5Acns9qxxwvB46JPgeS+g+qDswhO8OwWmHh/jKkL6vDI0yDnPExmBUEP4ssMO+F +fTQ9pa1dHdD8ohJ5wvik737ropzC4Jr70BxGVxJRR1ira8gCTBevMuJpSTEFslPq +3upoAB/ni1KuzFo6bknTJS2ak2SVjbpypD7is4xXQlxhgpyZG15Rp+ohw/BCzCF6 +miuSqru4nh6/b6qLOAdxm2dorkXpGnU+mPWaUg5rLPSe+xkoTxCLDv9ro3sUTWEU +dk+LYm8/u/24gNPkYxUJ50HO6zABDSaHCDANzhB1bFPhdIzjhfYOrd7c0+LDCdcJ +qbaOKZBH9b0Ee38ZbWGm1MtoCGoXfq83t7VChRHmcKpBDwJGKohpCiz50f89P478 +yg/Kh3ssy+WROcQjepvzXTNULQfKOR1eYAaDl6H7bLKf+IQ7WqL4AtEPHWMCmLRr +TzT9jPwiAEQQ36XgQaaN3F25t1pVFP5RI6BnMq5C+fzbfpWSvV5gPElzSC+U/Qbu +f40nWsndzSycE9N5Fe4Z6lfX/tvXqMYVOMdb8zloX9WgMjtNrp+RM2Uy9sY+ojc+ +YLPdWNEL1GnBVyLmEXkP9L/mlgn6HYAAMLmpFcVGx0HqKe6Qvf8f8OGsn9qZdYkC +HAQQAQgABgUCVAOywgAKCRBnOgPkwduSH4zQEACnKMJpzIHrSnu2Hc6p1BKNBWTo +n5liZ2Y6NBBt5vGz6YWwsT8o1KzW9uda7r7hDzn4H8aki5uOyW1sn2MZzgGAItJX +iY9teMYJK8dtl8wcOrozNnpaFC04u1+YuRtcPhn5U0j9Mqf5zqGymnIQUBb2/ymv +o7ZZ5gLcBbXe5bgAUv8/INsM5NwO0070pz3k33mEICEQV8hjrQmHENFhjPfMeNUm +IqNojSMf9WJ5gY7WbykwobVWCP+kzZfQnTWNcGI48uUyoyFQesk/nCZaJpO9d9ir +FbiRiIYpg6B9a1SJdahG/CsWyFjtd9y2ZBkxNfJJC+0xPNBbvxNuMFAJMkMSGu4L +QtBZ0Eq/IVP2DUweq3IatC8zY85MWVAN8oor7X/OpUgNrBE7Yc6TJfIDIhAjmok4 +PPuPws2AKvaYSiACKS/vvlMPDtwHmLBW0gHs1UjcsTTuEhFwgLwAjCTZoQxgMo6q +6sW1gUssonV1wEqjmiDCfez/UnjxAS9rH8dq40x830vf5LCxH7auhvPDNOaJrcTu +0gHi6dfZyiSGR5tsAFurS0Ig3Tb7c6adAh7jqLoR3474jibp8C0OEtFXG6Hwe5pk +Batfw3Owb+MYZcz3fFpPcpCXn8dWNjYzgJQOBobaWWN1kyuRH48WX2kuOpkGIHTx +50LiyupCNDwk8VszLYkCHAQQAQgABgUCVAUcJgAKCRDA+IZM2j0DWPq2D/9GXmMr +/9t28/oTcotH5jeegduF7QfGWK2eCjKCNf063LxWcPeW2n3fahqj2mgtQpRm4Fk0 +dMp0yo9jrm2JCvuw07S98YJNGaY63vp2ljsbTvYnIfANznSi103j9zrjV+Jz56KF +1Yc8eucTpjM/sPffawIMb7EkobftjgJNDPYrqCezY0tkYDsKAuaC/rw0BsHkXUdc +uMpXDUPmgwCq68BnRTYexIEg/CTZIrP27oRyk6X1o+hznmrv6r3UXajtFLZaMwDH +19e2GFXXR6n8N0K99KShRih2qOzCJpkB8QWUGm9ZOfZnslAX+jcGBp28NwnLc725 +Q/yJoHccyP9Ymx0Nqaxy/NPcEsjcSEDRqQBeWgtc/jvzLB+6ZVPvFLWt9RbPCt2h +D6WrhVEOlKVapY/JcI8zPDJnG8FCaAcC3qbXKF+ISgkLDlUTwzPMxNr67lHMi4Bl +jIz5LC8eKZJwYt3edXJ+x4D8xh1Id7PLfIoNIbGWb51Vmte0+I1xZqpt5RHYG9cL +911g+mYq0/XSFkFXX9DccqMO+7N65hmY8G75bdWtqsapmjJaiQtWaiMgyL1H1N7a +U0xGXvnY7BcLIRiPxEF1GI2SILYSwJojnWFn8l1qCj9T60AwlmUuEkufgMWQEOYW +qbWa41M3mERPAigiqZeAj1V/jrUjIqOCZH0xf4kCHAQQAQgABgUCVAe+5AAKCRA7 +VuK71T/csbLeD/wOef38MG82HJ5tnDBH8eI7K1UG3imknacUtgnuHR1gHH2k8nR+ +b/izTL5n1yJtKjemf6107VFanEkKuWZF/uwWgyH8AFf/YUGg+A49eLKzQ9zsTraO +8t9IoWDk8OJSkgT/gYxzQJ0iBKn7Pjqq5/XngZPZ2MWskCVzBjmHeI5ENxRcE+qN +V5bho603A2STz0an6nAsjPX50Xr8v5tBzNqK9QduXE1igi0lU4/7nCXAYiN1Upaj +GVXIXopht7cLiWSC0F63b0rXFzbd1ZcYnVJeZ3B/EiHxjksHcfoIelC50UzggtKG +XxR+IOXRwpGcX0q1KvsNt4G5FDyP59vRLvOoCtq4LUE4HJc+Ln5sQ5nup1gF0yKv +IlhfwIO44bRSKKIWETHCX3IZIO2QE8zJl/izLGKEKxWG/7SX12AMAQBKqmLqX6fx +TPgq+xU1Y+mKmwCw4ee9dyU44cR5KpXk98aGdV+Ybew0BOHNeJz4+w1hi3weddog +tAxjZxFa8Tm/lXZK6eDGhK9JaXwqVUE8/kGmvJbb2uUbDjdMcTTRRj+6ZAUnwCHc +6R1xhXAo0cmgQIMMft7jZi9pb2KqUq7Kw5mxqICav97eAa12N0qc43hH+uJe5l9R +L/Z5YyMh2vdoA8ps22TXnvqYwvYP/RAD2+0ywQAcJcYyrpH/5wiTbVRBb4kCHAQQ +AQgABgUCVBwvrwAKCRDZKfKZK+8KMyZBEACr9eEtTRhmH/K4KAkATxOT5NPcyhJv +cf4tgcjbmWGuzNu5cqO9wPKByZrT7PEfQ0UuLFAe5SzKClent1Wo6ISzYCLcNPx6 +MdEMrORDJSUxTsh5Y2lULuCo/jMfd+dybWMhww3UWttkAE58cLyWLe1vxhvnRbk0 +8p3T/yLjrjKt56oOXcO7uieRmiNbMHtdt4QWLXbYFDn0NEIcFmIWvDibFUuGsF4V +hnwNLf0m1fWD+wkfGEMfTEFiOgDCiGZVcnEvEH1CjupmjUfSw7BWHOhEMp9WjyxC +JTezXB7YBGn4v2xXkmO+ppLxQc5y+bHPbLTA+jOhZ3DiQaZ4FuQBOenSjeGI2cMC +TttqlF1oJ6IeWz0gFynW78TFxMPtS4VZQXmQPFMlwE42MlG9NgFVqpDyFiC1xSyV +1srlJIb+sGSzQCWf/vt1V1sEviyrwyYjcR1p36B9ka7sqG02JHE2UCgcSmVRNMXT +Y+tNhzn6BvBAyhqy5qR2vdt0m8yWWbfsVihpmJ7mkx6qKG1nWzkMj5Fdbt91fKP7 +11WWPE6Epf56J85x/A9/PxNry8wB9tPymZpWwiGPkhZlySZSxpcZcimisfxokkO1 +oC7PPNq1YXecr945HaYSSoJm8mOcw06ObGgkTeykMjjv4hOx6YGC8goCev3OfNx7 +9Wjvp4NTop9t8okCHAQQAQoABgUCVAKDPAAKCRAedZpyap/ddMewEACo3/liYDPI +iItbK1EfZrwvPKMbuiu/NEhLSpkad0ZBm1qMQgvXKRCMboM0b1Gx5vm2va/GfC0D +BvpAkV8NMluz1bI05eG9nAas9Snj05OdaiF3Lpii8iRz75TsYGdnaewLb/L0unyZ +laJEiIT5vWs9i2XWSSUkBS31XJCz3tjVoqkceTHLgddeY4LOtbB7lNhTuzpX7atk +N7l1Vodso6IRqATrH2IQfnQu1Clsz9VgsTyxVAlogfYMWsF3TcenC6Nf7yDbybtk +7S3U6V+1n4PYGbkA4bSyy+Psi0adbee07IL/7nMf2WkU9VuwgP4IjUlEqYSv5M22 +fOJehHcMt1ikDRzggRI5hlFTR2LiV7YDdNHK2S0mBntJAbFnSncOBBWM10vTQ63e +G02YTf56mBtcONHt1SWVYXixsWzlqIV85iT1nQdpPocpQoZIUIoh6ZVuDkfRcBca +pc1xgkAtjywM1Wf4p0gdM5N9A/MJ2Loo91ulOlZoQetzNv4sVzWB7hgHulPRFGx8 +NM5u1K985AnBClJXKwlFSUbPnGhO/52Lpmt6FBI/R3gHXfC1bgYUgz2O9esUlDv9 +DktjGMuW6V86+pKTkrxBXI2s2Rf3C90U3Vco3tYnWiDLwCEHZK77P2XLQJK98rUU +uRmLd9e3XJPeTJQydOS3viNlgWLmtspaMYkCHAQQAQoABgUCVAc3uwAKCRADapwl +vzV91K1MD/9VD0ZXg3CAWiBZmM4JxLgHk6V635iGZ767fAGa101Xa0GXsMX3nqdb +NefvsfTxR13ZfwiCb+mGfc2p0yf94AQ/pF2oMZXrvWvLKgHDHVudZ1P0ZaN6CAu+ +pE93Nmsmcz8HHmKnCKaRAJIRZPbSn8NnzulTN5s7dzS5bSttlaI2RyhYeLTXLcID +K2T+/b8DHiPItOlKOoJCmfiUnSKANIaCASTR+bsn6MLh37AdSY5jXukQSaVkD1zQ +gkfMtbQu7ILkCyMTcucitDP2BiwjYAw54WUD3euaeZiofKxEJsJbmChZ2Ykx+8XU ++zEWA6kk6M2kCUbMBmKs4R2kvW4dZIL3Zkw/K+Gus9I75Vs+MtBLPHtNvnd5iq2W +etfgapz92vcwrNOvRgAVtdHMqaQw7abqZmXnDxWdl8vsO+ye9H285IKRuItPvVHz +R5sMlWMrC6QC+0DV8WiYZ3JJyFellXoAra9iZh6JOjWNH86s0r8uE+5tqHGes+Od +sL7Hi6ZOphb61gVDyo119XT5vV85cp0/u8mTzxSRWU5HkRQibaS7M0mhiQcT7DO3 +1NEjLJ1Esb+OF0fyWCEYB6lKwkIcd9nWC6YQ0xfbp0hrOWC48Jjr+18Eu7vxjUXL +AhK835WHiaRuFojgRjVH0gi2ECVgAk1pBUxTgoHa+rb4rIbiwp7zhIkCHAQQAQoA +BgUCVA0bBwAKCRB1GrXdp5Z5zNvwD/9abLn2Bql8scu96U3P5efS0WsmJnkOFngX +uLhIxYjvT6IGD29DLUu0e95j08Ojp6OGWBXARTIP4E2WdiE/vEGjGvGJTaz9ZCi5 +iDCqwuowKcjOJ475zM1mGAqsnTSCUuvEchxv2rlWAGxdbIIWAG53aluzCJO3TkNG +JZPNmMl8TQcCC2pRlHOrYuWlNi5VkMvmh7O4bfqo8jFqWRWIJ2Cbtpkgb9mEbLiH +GRMp+1LGSRDdnWjL7zQ//JZZ73hPaVR5aBuRNitix1sxEPTkCEvqvYXIQMxB+CAv +v6+vTreYeB/F40XedY75xFL5IBCVvhOjosS6fEdHW/ljry8J5GgOK8X9eMlWhU3z +dVcVtn/fSs0SmECjj+PGOIA4NHUCy9nnYQujZAZgWbitIiEnhVZp+JfCKFolk7cl +syzoo3eYn5y7PrqDxwuI5GQGqd/N4xlIr8YVDYoTAhUbNLxbVKv6/QvKaV2IeOFC +sDh93yFSKn0pVr/NGmDVDJv6WHr1xFfMsdxfRX/IvgY95n0Pr3UpuhVGzLhfVp/b +fo9NSejB91HuBB7bKpkikwNfhQtI0DIu1QgxBKxCcROEF79wQ7cv4zrK9K7p2sKN +wihYjEvU02mGvIfVcD4RUe/C/y7p9PPZTdfsVXEbfxnEiiy+vF6KltRHRiic9PtN +pxEiCt5K2IkCHAQQAQoABgUCVA9V7AAKCRBuYItjfYln6XHuEACVzn4RnjHavK+z +N6H5erw/us5Fy8u6i+AmWs0+bdGn1SjZeGkxWCGtXjpqJzVzyIV4rmJM6LyjXPS3 +kCAK/yi6SW5ykTQBo20DLNi1ToF2zPfJDPGzKEE5PaU5E9B2o3ylcMDfqKjAO+b1 +M0Nis5K9M6ejXq36d6aQ36JFbBbGAbS8Ty4g0LJw+15nUkZzsgTyVfkFH+t+HwB7 +ewGS5AbL4AuttBxZi90ch6KMzkvERj70ycfe1CPt5VPJ7zhXo6OGrIUsuuJrl7H9 +EMAmUFHOO9VaX6hn5URHxkHravznZPWu9btt6rBBsH50yDGIcXxvL9sGankYAGto +qLWA4Yr5+7/B//2IlfIupgxjFMeYU8d8w7aBn54N0DiHSB7Mg+OavMh+a2JeoXWq +FdUE9lWZVxXqYO0rvRp1a3hbTC3A493880BQ2+EySid1XdPHyOr+XWnIDcReBOmI +wMeI1Kuz5RQep6Tq3qNsJqv5h8PuO0sEKvhymcvXo4tIlPLCJSXYHERA+FvJVel2 +t3HCimN3SBOy++UQ+QBKfffpvSBOVdQ8GFsxXOpYa4C5jv7tfx0HOcyTn6y7hsqN +YMaXgliDvz2NursQLYR6FVwBOUPSEg5pouB4TD95lDzcEvKRooDVNhiqcFO9Jk5B +U16ckAVk9HIIxDp+fUQ9WcrFGR+QFYkCHAQQAQoABgUCVA9ltgAKCRD7PSWDO2qv ++BaKEACr6UXdYvHDuX7lASvaJHR2OI0voI2zRQeMUTrfq2ELWlKTN9mi/Su6HHhF +2Vor9GVCp7IyLGB2NpNIHcVC1Z4Kjg5U0kahnczOGZcPb9XsoZXpDrtX7W13vfmD +vO92nNww/dwd+0eR51mHe5xcs5+/veXd2q4jD8pmgnHAKFTDGlqlX9ZRfEaSnwQq +ztii1pfoHW6iG2AhRsN0sA+R+AM3T8YVOgcR+ZMSSyS343w2uk2kKByPcqii7E3v +PXE6+lOKUpjsnLmIQn8Y3tyPqQhrlTzfYbwyO5L5IsOEGipV7Qt+PEa+BvD6BzXh +JJRRiOcdSZnYrXpW1UaYZIrary+AVtSlJ99SjAUIepopNRM30zZwdKeULhFfBf4H +YnFAbVvW4tWHtMzywaSEaBNvv1ij2TD6kylp/gHJrqyS2xUseP+glmN64dsJ2BM2 +ZakokObJf/O3kuYvw2R81W37IRPK0WsSg+pIPedqTJ6Lk9Us3wPcunISduMk9LL2 +nXMu51zuxEI+EJHVFwFATGnIRLn/nXQ7CjFataPIC7KwRBtsycc7AeOI1mESH0be +ukFMlqBs0XzGisR5sJiMXIY6EFncmuluD4QOUOwKzMRBe/ECNXbl2Zsi9Jk4lR08 +kLR6+wakthVb0y2jdoXj/dEhv3o9cQCNrCd4aiX7tDvo899kF4kCHAQSAQgABgUC +VACxjAAKCRBPrXp1OEVZ25y/EACh2kncNLp7MWElhvUYgaGV8Pvgf9MECVvHYEUa +FbDCjwns4Plh3C8NxSTmE8QepYxAFBNwWM5WG+kosV8jzgPUBpZ25hx5A0qL7eFh +F2aSZxl4uMcJIN/hyYFa3tplXOHtzkR4gV9WL9F4v19YwwX6qcB6djE0ChsIqELP +cW235YkVzXEP6lOiNmFm5ORaEPhMliHN7JFP0JEes/oz4ePS/zkny5qOZcz4DJkq +i39LVB0+n3QS+rgx9xUjuspAQu6BiDVzidnAfAjtYpCa1tdoXC2l9NbOgL+Esmgv +JWvm9a/W/dsXVVjRxMT1+A3KODhT+9ZDG4itXaP2RpkqBkzN6rHu2izc5JoKaOty +gAOgC6GUQeHm3hvxv5du1PxDD+QdvNpyZX5KKQUCruNgosDHXpBXJpmc9no7XKCl +xTpN7Cy4O2/5OU3tmgQxy92ES6wJARbFbnXCZCDW/k+Xjulcp2HRKMUe9TSnFI5f +FLQEr7bRV540BgZI+bXwsq7hb0jOpVUtbzO0LwMBn8wdga4eC3H+OIsIKbiY6Bo8 +8gaS1u/LwTDl94y4wqK9qafVJ3406989tbdHP0TvgSOCxs5CJQ16Ceo/xHfZB0b9 +7B14cik8ka5rszN+GPZChDwgpamaNBh/cxmLdqyTDwh9S73R9U0vCIynpjB0yL5w +ZLsiYYkCHAQTAQgABgUCVDGO/QAKCRCIe2BhizwWrqIJEACOkM0slGz/iHG2HieN +mxfeL6X89wf1LVRX2Xq7H40GP0Mih3RiCeK93yHmpNyUKT4qfvEA1GSdT9MyeY5s +6XMtnau+QnHHqlGOqF5gr6bqcWNM5Kjht9VvaEa1HrVQvrs6JBif8BXq6eQK3acs +tPxzw8dw2yFaW0uiqhjo49cQcez2kVYXiodMXr4jvriLg6+plp+K/Cv89cAuSnNS +6Mt76CQoCrjrTFhkNs8oRo/P6NdxhM+Oipv7djV60UmmSSCRgX9HRFK4LkqoQbqe +Ryvh8xOvN1oe7ztEoAFHdyuzCLabkWLyY3DszT09KEDZbtY1wH7YUF6xZDFvOdDB +u1SAjCGmHRp3tpAcwBcy3ca7R2owOJIMi7Y3WUTnAL0DOBsvz9Acb4g6KaM4TO82 +Q8dRBWa0d3TfvakuIg4EsfsKsifFRNX65/oq+y7I2Q0P7iKa/Z0Lrb1zP2z6PbTN +NOCWJ+Egy/nVF5uHXnj0tPBNoZ3Eb+AYsHrelbgusqlAkXYO8+Yy6uIpT4vMR6Gu +s5rjk2VbM87/B1UQU15pMVBbTfp8EgZ6iGaWD6dAw4XICaO276cWPAUTdiwDmGxE +1Y1BvfITs8OuE+wGjg6t+l40Xj6aQ3I7Q9nXRHkkXd4rZjYbZ0Gqyoy+BfXuXvOg +1zL5xa5JDJTLrGM5Kk0bGGtre4kBHAQSAQIABgUCVNBO/wAKCRCU6S35KqpcO1JJ +B/0Y1+bt5frD6yYBQxKDFAys6rbAOKBuKqegHOzTLqGULHmaHE74KIxy+OeG38Qw +/xjDmtxFoEDlE2U82MAS1q6/pIsrltVA5d3kj0gH1PnUpDjSXIi4XGZMFz7YCOPN +sHZO10hbeed8u12mSjFUIzsge6tL0x3qMH7oeJUPA65hUMw1oMfAviizxE2OnEVu +Mb7BJ9n8TxLyR8Wwo6f0Pc8/B9HPfBvJF2aFeMaknOyNtYGa7z4p/Bk9Pqx07TsR +jrqCTYpvxECnx+Vh2hUpu93aeQ9UxdlCHyDAGO/SCulclDw8TZENJQh5Cf//Vd1T +0RV0KQ4v79KYqBwQaQS6uTmYiQIcBBABAgAGBQJUxjAEAAoJEMOOgWCheEH+OjsP +/3vwS10ptFVe58X9R1YzWldT1MUn2emo2MpTuFCrHjMFl3PFEVsRaAo4a1ejl1EQ +wblbIqz7a8EhLEMBYT6MsxeNvVm6wGmDDz0vbWwR1eWOz7LLdzoyr+dcDXW8WzCU +yBshM7bmZimKVPdI/a4DTL9vhczoQBMTqd8iXfxIoyU7A0EcImMMk8MrGD8OV6jR +wLz3QjiuJaFpjVdGBi/XJ/eeJRLaN9/2diNA5Yk1EAamku80SFDIorXILGHFoLTX +1e15mna/ZUGvfj55ylq0kDM1fZJew4yKjNjGvRrxKhSWMx13sfWECay7OVvwk9/X +UBzivVySL5p7r/Nq9c0hl2lQG/v1+8EV3UeKlFv0rayFDE+Zzzcgjz47MtrfLpxR +srLIh4LdZ0zqq0ZltxMYXcN2C+AXwXyhTcqqo7LDrrwPeHGMkhbEskY6QhEQV7X4 +zpHbwMhO0qHhpD8eYhaoYnxb7wUagsyT8eHLmke7A7g46KZ8Boh2eOQjle+qKOlz +H1VzOmNjVjN2MCuIzyWBy2m/3Bxlqofl7nrPT3iikUCD6XIwtuJKha2EFhOhTFTo +/gOQLjRu4qmvYgJNdo4TMGIJfgARdWZCMGyo34L4Stz1JFdhzwWw1TzJhE3i24HG +BpTGDQarva3z9KUALi5F+WKM/S5rm2vJo+MDo8nZuA5IiQIcBBABAgAGBQJVgDI2 +AAoJEFeTDasLhrBn5Q4QAIqVwOJ3XkjmDQCev0M8R0HwHQxLgjDUfsADtHvCfWpb +JOb9laU8eWzwm0sfbRbiZCXOY7QJ7CcrVqpE0tO9XYMzatUttODL0gNFRSvIH5fq +92bq/1znyALWeILMWIz+sJ8SFgMHlEAwUOhSzyr4WgOIYiiRatl6Rmiw1arUPQCl +CBBfu2JMVTM4DK/eY9eT0TZqphzQFWIOsbYYOFYIsEt/SYn5i+k2oaJ0fuD9FwdM +fE3Auqc0R632Pzyhdkgwc/jbumAaYwIoiVGRXLHJKMgKgqUNxpEHm8pDQR9mMgfe +Ty8vCoBsGAP/SHZpl9rvamFdAf14XHLRUqoQLs6IwclivV8zD3NzVh09EKQxZjV9 +JnZZBUf8V63lgYAN2eWAxL+YZguAcafm/SL9DrkIuCONeazWL91bP/UYp48XsNzo +q0ydOziU/jy1lXdaXNzbujPTE3veYkYRZkHkxrD8bTtlzIbWgNbryTA8AK3X15Z4 +rJC/CVjpDSRLBNuo0SaaZq4YIYwrZVAL07myxfG4nDMZFAiBNZvtJ0Ubq9tFzu5k +PGy10pTGhrW3FqbFESE6qNa6Lhu4Hfi7xVfm64sIZHwXS6h7jvri/NoubDJmlroP +vFAxHQxKHndVeDWjtpTR2tYHMCAItvbqmq6XESHa2TMfBGrK4QNsuwwQ8/gDDwcM +iQIcBBABCAAGBQJUkJzSAAoJELjlCHdmR1qvZY0QALJ0U/bPwkfYum/jNkLssP4I +x33yJiwuGc29i5KtaQ0W9LPoeilWIGHocDSynhC/BRj8f3pqmqAdU7X3FQYH+pZ5 +8BlV3tyH7GStSYRVj3x9JBMhXcetBlObLSeNXackfAWDK+8QyyrXRZY2sgHd3qFA +pb0qc/dA+j3sp23WWt349wJK+X2Ufi+ZJovrgGcZM7iJfqredwmisJ373CxQt0tb +73tYN3btjboCa3KHcnvaQdOhXb8ZIEicMISRYkgdpxPiXBClmt/OBr5oUOnaHeDE +PQP7ODGJoyj+x3VpL+nYn+1Revu+CIPHrmHtzUh21RhowDtWFYcNgMJwhfbDh0+T +LEkCgYi+EyzTjf0Q83fnIU8igFy2qSLzVRiTicrlms1/0aMdf16CBpiZ+vBR5Bn/ +WkKGqzGpiR11NvFLeo1fvKl4SpRdVhjulq6JlV4GyPa33DxVggWhSK3/Qv6ijgQW +3x0padCJbC3OanjWhZqqGIIDDUC44qPZcWQzkngjKjavTFqcM60Sib9QY9HbqWxZ +yZg2fL4dE8vTAQsBsBzy0q2as93VbzuDMtI6ZwlkT89jx2DrmQMAWlvDDLfZjcGg +tZZPes1WiRkYINDSPk4/tHMeDBY1VQxCQRQUzn5cMylBrNyoUkcWVIW5xSzhbLNM +RRKPW29hT/+pjon3ENpqiQIcBBABCAAGBQJUtIYsAAoJEFBB8YkfROCQNokQANFU +BhLJ/9I+zz2IDiltwYdu5vzqWD3+leec3mV7tRQOO6/Z2PQshpXQuQ7XqgPfktpq ++NO6e+x+2gWW91obG13UeMCC7kFlxJyMNQXThJjOYikzeAt8bX2cljtXlpj0x4nN +5a0Flvk5fts5aTuGgXZki7akOhc8/+LSFCCov1bfzg4d39wN3LbQuihfKxR2ed0/ +vcH9rBfM7ScmNu6gFDdaFQWzhX1GbL0qL84lqY0Qv0BQONHq341pNbQnXZAw9dL+ +6XgiPVuyBndkhgrtaFu6xfR6Zpe5blB9tdl2O6e1gP3S8K67xO8qpbUWlz4mc1uu +Ui9zRfqLrGwfJxC5szIYfUxxDvHZBF9r1W/c0w8LmuQMcCrhIKQRCxY7h6N3i8ad +dRPvievBO4Ru6RKHY3es+6MgELyF9FaAfdNo3Ita8o+SkE+Xhcx8cHKvgAHwSnis +COQIaPB0QY3TE3sIYkyoWn2hwHxn3TnTo6kmqRrKobQjdAKRHavNvRsWXFOGdW1e +HHXhQoUCFe+JJ/Vosz3UyYu2PPZ14n6ltiA+4Gqk/pw70u0+WH0o8MR1dst5Jtgo +lxhB4WG0797WMiicQhN/8Nl+ckCg8ng/DgTsiJTjw4H5WOLPtVKhP6S5XsIWV6N0 +nJT9DRT0CdNXM9trdygrFC5EMcn7qGkucDb40gJYiQIcBBMBCAAGBQJVNs0/AAoJ +EMeIxMHUVQ1FnOMQANIPjhHLi7fqtg3JkuUnBsG4mpCyb/EZSWc46og4mqeA8c4w +bghCde+NtIss+2uYT9FXitWpT+0in05flVbaHN3xCYTV3rSftNizLlD9IayspXN7 +iboyrq0wLK8L1qoTsUjG/FxCPBNs6nFyBfGv0xIo4tGUlFLPjHthRj3GSBMVMcWw +eUOPRIMtXatOX0XY20U+Nj95hFSzFKq6qkdrULDCrUGIQyyhM1h0mVEiSwb8RVxe +xZJltLFtEHzA+IBzjzJ3qt8lnLzBkNtCYX4WX5u7mb2+516pYsLEkEKzjnCuzaf2 +vJirr0JyPAmNwxtNEK2uhChDuVOxyJca7nmEAJXy8hgzq1HoduWV1ULOg7pl+aRx +AZe2e3WFKYex0emLx9ZZ7/w9U8hT7WrPsWBe3CBYPkrryCSoOqCCUH2xL1NKVjZH +pNSjZvZ8scN3b+snu8IwL2Rfqx8GaA62TENqRBrrD2TdgjZBdBvamFuGYstJk7dZ +Zf3P9GRGxcUrnidcv/71cWLFSpVIX5FW13uf8YhcPu///sQrN+wius7DSEmZzxv6 +ejXvn8uSRoTOVlWJlbCQhwxDlDWxbass1pAYb1aHjC3CJLs3sl79Se2TjlqVwX1U +Jm7e7LYkGen2FTr6mCOxs43zw/SSTKIveJDF7VjTyTMHcp6tKjVNSP6OfTp7iQIc +BBABCgAGBQJXW5i9AAoJEC00fqaqZUIdvmYP/RMcfnF0+4A1jJexIye1NOkoekgN +IHJx4gtzc63/6/ORobs0UqQPql1BaxR3JXQDqDqfoBhKZLLa0c7MtfsCX8wEtNmt +NZZiCteCvaZ+rirlM907FgVGgE2ZjP4XZeYuelaYFO9UGL51GqFWlDYdTjgypqTn +klUftGl+3SpzksSwYdGBdXAWaMTjFC+kutg2dO8mwHyuCSP/9gdkFUQPmgmSeDfJ +QD48W/1WqBGgXOn1EGvucyw7vF/N/2Q6MZI37EyemawEZirlZVmKdIqsU0z+qDvb +NxXua9AGHZ6mRHUuBKSHp8bDIoT9/279SZ/0rOY4CxQf4qxECxi/U6wcT+5N/WOp +L3zKegkaITG+cFQhWNGqX1UKDF6zda/fuBSCIq+KcYjwPHF2ayBisxKy2uCzM20F +aVxDRbyoM5KRGaB543YhY1x6v01+Ojo4XOTChsoxxnwj/3O1saNIQXkuDvG+xUtg +sFXzkXEbMxtePHyllgLigHWiroTmztp6Gqpm6IEB1s2gx6eTc2mdKyH/+zet5ewG +v16j2T0h2QkC3lgKQnMyIIvJAOQTd+GBppwcBzRl1e28KrlmG+kaydQqBI8FNUC4 +raQwEOIXI7gkqeWA6U6JVYGTkYWHPQeHhV7TgO5Q5/tj3tYmBwLTc5wDuXbkVF+C +jsbiIbFiE0uskFn4iQIcBBABAgAGBQJW3wTgAAoJEDUsZyCx47krrRUP/A5KS5px +AI3ak1ycwCdVrmEJhzCTfRhqAwblnOlgGnPncbL0SjgvG0kwxPY9zZKPRgRLAQDn +cYM8aziq4aK1gowDQcZ4HclpxWo4WtxviqeIA0xa0PcO3OLNPn8I4CxyZHUlGJnS +04oi53yRjjS/2fAG/rMrkwHJfu+CwsdLUI0z3e1vlm4bCJDjHjyt55ApzhiPVltN +MasIDRSp2B1buJkXGBZH5KqgXXTlWpChWT0alWwDTDEsWPiUPj0gtn342rYbO78p +/N5dtQgbdH7cUmUEFt3bb4CbX/HkIC2xUnDCKla7Co3VkZiXcg9Eb8sa+1xAGiKG +Pfsi1F/fllCYmGYFOEHu9a0xsxZvjvFqcqJZ2ZaleNW1utv3W9KBD0qaK1JJ5chw +6X7m1b6vYDz0xc4vvrKq1YFyARKN+sG7Rsu2FJZ+0/PS7W7zuBEP9HLocm19JgiU +2DB4XrhOYt87UQgsXQrSLPksW8LTteG7lrFuFOgWawWoW9nGO5EMKpukiFsFJUA7 +P99PUH+QyQOyBpPCyo0Sk4UCYRqf1ViSYFdVwU6Tw14vr/A6CU7J+1zrWqNThF/S +j1xDirXmM+lFfglVQIzbz0c5CIdByT0eBW5L7zYY/0IDTi2o4DIDQb4aibNB6fCX +JIIIVmSM3ud2Egwm8aiPXo6LfzTLSt6e3M3tiQIcBBABCAAGBQJXUxnNAAoJEAlL +CdCd1TRtlLgP/iBen7BMnrfHcq2Wb3fXUdlkUiyocydcb/5vkQyCuT5sAtmYNCYB +YZxFdBVwY3jSzA/25raVz47TGF9rM2lAEUy9sEo7D6pk7iqedO+mFnDRN0cw36L/ +wbz5F8wXaQn/LxETilPzTdvZDIpH+7hG2y1LvHyavOJFq95hUJmWNITcP051/+Lj +0hxuQRFmg7FHpXDvZw3e0qVnQRW7gViNQjoezkyIfTvaPS0u/lHp5VrKk27Pr81q +ZIKa14VdwY9+QgZQR25fwhav2fQmpMbjWPPxZmkg0+zkRi6Esl/CEs+RIGxb/MRh +B7hoChtDIM7qv1SJWmGSVtohoQgeuQycYa50g0OIWtK7OVXVn1FSzmBP7P6lzCGu +6+5qC8v8kLZAgxeoC8oApQjo+G4T0epO2Nh6fskwD763PLKuW8Rsr5WdYfcZKkbk +grAmUEMXG0RrVHqPMzSxauitVoAKCOiK/gRdadvcg3v21LY5UIoiIQvyx15OwaS5 +B7fdXJ+Vo1fWZYVJY8A42AbrUsGTO3HOrs22Gn/NrlI0ScSm657Tp9sLokiNvQhO +n3/P4Au6G6eD1/GNQRD16faUi5ERte+b94coCJ7dSm7qVRkri1yH+3/ZTws6v13U +2Q/QNCsf80XC6QTbEjarVlCobCPX/iBIsVfBacCn9Xuz0EmTRg6hJR0IiQIcBBAB +CAAGBQJXUxrNAAoJEMAPvi2SGSeInJ8P/iTAkIhMJqLKcSGsLVm+HrR9wLF796IC +vlQCnKeaRMDOjk4RF+numl1MftpNnUfsumSO0crU6HnJ/w6UZXzQhnzNtrTUOBqu +tPHqtQeQs2CEXNannkn5ysMpemtZ873Rh4Izvh3/7Z/Sd2BXl7qvHLujtEvw4Mlu +RDA4ukwgN006DK4mldIssGR7roe/spmVI81+9Q8krxGJNIlLoBiUeYBksVD6Luj8 +pxX2ugJ7LiwF7JG9bzEmbNoWdG1F3fIqx/yGJkYpOs7ZUV5XyFa9+andZ4wmJPCx +rfS8bzKdGJ/BtZLgklywjXS+IxP4avx58eVte0QhEBYjyCbET+l3I7NZQzGnJR3H +B7wqYXuyBVHQ2vLYvyIX2AKV/5ykjgnZr9SanXEYDAK8CBAsGZaSgSAbeMoRlh9v +GVvyHKV2O6PSuG/p5+jXWmknk4C7YvGuv6fIaGSh44SzXHAViVu8R1WPRQiSiNFu +SY2ddwxYiGLh32I95K4Ti9Lul3l2ypVKS6djXhpYIIULPAGuSx51nt5mkL+grAw8 +h8dvst7ElEo1wfQECkQEk4IMiyeO2bYH7mjkEgLiiKUSlTOMZb9MdR7lKYTHzT0o +ON7oeQJiIT2NE0cXwEAbocPXktZic/K31P11BlN8wRUOVbBEMRiCCBiySA41+sDz +3Blq5YKb29l9iQIcBBABCgAGBQJXI35yAAoJEIdWjxVizVEyp+sP/3mfZL/rlHun +SUTeeDFYCP8+fHTBAKKWHnpbKhPXYZ0d9rnWsxXuzqK2iIG5Xkk1A5U/u95RdPi0 +9DcQRKPAEAxKZnhmJV+1i1cuz2SYGlXbLlgIJCDSOgdusjqFw5bE4qsD/f5IEdrt +/Tk6ALFdXuD4K0/qfigS0PSTnrZQsqyOcW2fGaSGCoZvPdsPd5uWBGpxPpmC1rNQ +LlVdyAwYPna+L9Tqt2XMwPc/huShkStVYD3C7VfEyBFn3CUb2k+hWh6qvlZ/r6OL +QgJtZe7khzk+9/uuXssfNgVUM84ZEAbmqx1TyzjNdAyDKm6ihUPudL2rgIe4uie4 +Y2DUXhtrxUHbRvrJq29ZEnaxnYDunLoH04AwtSgCnX0+nsbc4Xwzgp7MIsIsCQvN +YMA2zOXgweEDJiN9Mf7uj8nDI9reRLHH0lURYGuH2JkqWaFgKHGxk5UMr0dNO8ya +1OxXUzchoVWXgUxsDBdKRKG8Rv8a37sB4sRtp5lz6QXaH+FefpZ/fiQOACqxrPrp +tfBV8S+yfFolsCAC9QRRQqS0ks1dZxICuO76M8rBsupZoFcHQmoWtewVz07Wsh/1 +s+AStiCRd922LRQgJIonKzHf2S6TwPDIEWF59N6qnHctToHuwsiOr+JBAz+YoLKN +1xJgPlrn1+MjU5jV0hs70jEloiyiDRO8iQEcBBABCAAGBQJXgR6uAAoJELeLkI8j +Qw+ALV8H/38EmYxmVODECzjg1EFsURI9f66vvssOHuY+ng8dTICmnMLqw0gdcMl+ +i8/PvQB0iCSsYCDtKda+kzaGNUdm47RJu72/+oJIoocrgyTja/zgEAaPUK+rFWfE +wGYqVeB77B98dA8zs8GyHcEAreDhK8d5uIYpJlTVTrvJnoOwLsuXzQbezYFIljVJ +2saZ3UBrNobKEbMwx4T10jXT+X31bTptY9tRfcvJmbgxEWIGR74sKpj3A+LcohF3 +wvpNJjPMu6J6+TYvaxYxUoshkfXvm5UkGOarFKWhPpNwzKPljKtykfwjASG2gBnW +MQbQJWkhtpkCQiyFWN7PlGnugAK5/TKJAhwEEAECAAYFAlfWSXUACgkQAjwF4snA +aPDnmA/9FFGOPFeFc8aOpiF1lnM6eHsCFNAjXCQP485OBwYTE9zak40NJVlxpDb0 +AHhI8NNFKylJLpJTrvQumbVJ3IxgUk7gxR7e8293Y4QY4sMNrMzUHVQJhFoXiXfA +KOXLxh70Zl0oPhoLbswBCi5HakxFckiWsk+Li09NcUXfG/znPCioicXTasZJVgIH +6YecdOeP6M11509kexhkv9AKTWGQG8l+G89GMdwzM4vHqU7VX3GvgEcfHtoUeJDi +q3z6XmwnWwJqE9NP4Pj5RnCVN5Nkq8tHkRDdhn+RghFRntCVxAUAVxEetcXOboey +eSq2xQSmyJxftim/KlxBibRwHXGTKwYtvDpxejrRcJfzhdsnA999JRFvEesQ6QJI +AzXQESOocRMHitO4Ecy6t4p5hIMoGk0KwYabElvczjTNibRb1Jp0Y0+txZBJcVWV +LfRlXX3YzTMgaXMbATkszhR0Eix7cLneHvUfo933ymfnJUCJdhko0hTUS2hwyqtj +Q5GHhRC8Z4Ut9DX+rChOsHznMVdzJsRhHtlRNWMq5Tp4QwPxY2SjfdFXrvfJna/R +e8Kc4JMGqcjFZG8BGJaouq8SbUqocrJYiZpCLvRbHpzsRAzAuQq4MqJfLZqXtPQE ++IuG6IwBIaMda1NEzDHapD86PZbbRWv3flozeEb6xf6JAn18xHGJAhwEEAEIAAYF +AldpYMsACgkQiz2GfII+emFf1xAArlT7EuX5jzcnzLCqHdSBg8niubS2o7eIq/9J +G69v5D309SAEXpDkMEHtmyEoCVucIl5WmmgmijbRgcNqu/ph/zpkTl6R6fPYVCFO +OCU07MPI6Hvb6Ynpt7Xm06HUyT/YzcQwF1hreo7hDmma1evrXjskm88xfmbNZzKt +yir99tM7Ozfztb7HaC86cIbqGBa/iwOCBpeu9iUKnSBVtc3JkknUyzL1NwaAgjVp +/wkIWL6injT+vLW9Vt93rMJof/RXHBv/c5WW8QiPsS4fK/kzZE1iYlCmgLoiRcxL +U1aLBVPLkPX55wsYpT+UEA8MjaKvRAV6/p/pa/JbkYLIQgsJqu1P95EqpfiYl/2S +R72CqxZ3EvTpfDCY4we0F9Pm9ZK4M8tJefIWxux+NEYIi0DAZy4grDlIFPjolts3 +C+FOqaoDN0iO4t61GVQB04Ys0COB3IHnOA/7axLIEUUeQkoBSWcdmkoQsH5YPm8M +n2lWQx7+RXW+WOpeTAw4gMkGWT7EvILtMBxHTDT7m559m6hZmNGTEuVwYwwaKeF4 +wcu9UN2gIfFdBuARrg/duY9aF5FS6rTK3KYh9QwIW1l7EtD6UhErmqpVzsWSAwHl +7Nep6s1wxe1gTc3ViqJkUx6ITp+m+2bLIWpTggfE9ecyj6sp5UMdGnNiO0FM+lMh +erFkU/CJAjMEEAEIAB0WIQRrSay63Pa9HKIGZ6vNVPzj2WS++wUCWSLxngAKCRDN +VPzj2WS++20vEACP+L7b6cyfvm/X0+UtunbzbBCoDrWq2czLQV3APVGAqvPjami/ +0WxIG5h+B47Mgqdw4XREMJOo5sCgvYPFGkh904IDqx893jn4CfDyeyFXM5ff+9dq +7POKdMgzvuHHMyDpmis4qPupo+hbGf4X0uZh/+SyiIgwr3o4UH+X6CTYRnRnGZx9 +kk9oKGAPFenkuE9Ia3ic2LIn0/pg4C0lzpahEnQ5k8BNXqZ4D/oVMlxJtoNyUvcR +JBuMGGvYhBV51kX3fhhSudwVZIUGzHkiDzR7HCrznFp4GvlfHxWGRFmQzAfOIKKt +hlV8FjLgERovVKT1k1AcYe49nJ9QTiwdRPv/9zS4jjiSsjCVd/MvFMxD2851hPe5 +vPVaGRU0ZzQfiKA/7k3U+LpCpYMzUhPSSUKRWbzlOjWCX7DHhemKnkycsOByJKmU +Px5QZ1MBqvFtYIw6hZ/aWWtIKhEBEG/ADU76hUdSwg/QpySrVWKgiynMU3/i7Jmb +cCMpmkiYrADzNcFG6qTxsK/bv9wrLICRvG7tQTLia8six+F2rapI1kbjcO/YKpNO +JAKRa4FQsCNxXXU2IJUlaDpVhM3OGwBPpJBFjitYyK8HSkszJt6pJljUd2sEmMN7 +pxEBaNcba1DTDaOmUqKdqzvIt5JYTymZLaycx3jC/gvQe1EGAjCoaaNswLQrQmFy +cnkgQS4gV2Fyc2F3IChVYnVudHUpIDxiYXJyeUB1YnVudHUuY29tPohGBBARAgAG +BQJMPOXrAAoJEIwk0WCPBonUw/UAn3hB3No59DBzQv3bBPr5gZgLjgQuAJ9SrwLU +VBuFI2U84YJGCdCYccM26YhGBBARAgAGBQJMs3sSAAoJEFVbl16VO4aTJCsAoNyw +G51kBZ+O8zBucgeuQ/AUopn/AKCtsIe0+YC0PyZ3J+2FHy6VpxrsrYhGBBARAgAG +BQJM1e1fAAoJEB2o2jPdzWhqwA4An2A01yLfn5i78lCPPhfjM3t5iXnPAJ9oSPHo +XaGqBkaXIxrfCv/JJUxR94heBBARCAAGBQJLV2LdAAoJEPrvEpNt0+PsbnMBALJg +pPMmDCceVwK4zDfSXDEpZl7f22GmCGAdWZWZMFzyAP911/Qk5N5I9cPSXlzhzn9H +Sd8WykmbYJBf+JOxkaD3UIkBHAQQAQIABgUCTdFlKAAKCRCmsfPw5rX1o2YcB/9v +5sbI9OWUxx/HLgIDA+NfGJsBawXSuLrMmGPpkkT/RvTQb4O2LS6CyZV2Ck6tiLWA +XZRqhUr3PJ8zYHr21A2Qq8k1vqElXXKgABmUalPZoFO9duDf2MCbHVh/xYOS5KpI +Gk2Gzj5eJH5M8EpjHCnwOfm8S5FJ88L97onu7pi2R8NaC9L2aexST2ImWzLLY2vk +n2EKOLASZkWmSG0HQ+RpsLksdKNO6oGqnki1sYDxl+ySj1JQzZXkLMewvfFEx9V6 +QdAMfnhmhSWa+MwRlVuq4uEO3I1Y3zzwPe5ERLr3YPcYvtXbSKGEFPBY5k28q0Ii +7VVjdT+TV7IWMnMMtINyiQIcBBABAgAGBQJNzOrpAAoJELjftxtf7L2SCooQAKSc +l4rjheDyULt+kfV9l25pn9XISalLcVQ79pPuP3yB7Z1sSP981zgZI8uxM/42AUGt +7xZKu5aLFlJhI6yDOEs4mT5X8VzC7A7sFWksSkc395yvdFNDXyy1j6fNZ/0JeuXc +1o4KLREY/nuDGDWDWJLMobeoZYZIzuTPhLQEkbIMYQcEbfuVb4ixwVAe/wUtrgZx +JX61BSDjGSPGkoMG0fQuj2W8B0YDaik0Q3SWumRSSH5AVT436byMcpgnJ6pjxLHQ +91nIypDkD4jsiXHWFUwvHc9N5i/ZHyika9W6M786EHVLd3+411lHWl42NfxjPGiy +a0nTAh6Mx0jE5WRdfHsRej5kF+/jXO6XZ8J32/9Ji58kdzdSnFlS4Vmt8Qo7egwe +YKRTeAAYAPn3gU0NGtrSTkPyWVE2q2rzsVSU9BAvte9J3K3hqcRcW+v2QNzGkFEN +7b5+z5593st1HwutrrcjMOgOKKUBLvyiBmfK6p84ac+xceH4NXiSYc5gHt+zp0Dy +Fl6ix5AwloycuWhRSnKJT32QSfKb+O/PbvtIvlolUi7zrXZ/zCw7Pyo9Y0RqUP1x +Y868ZtUeuoJiidz/HfTATBzOiC2L/CS96ppxlB4HYBXpOy1Cbs+YbgAv1nFzxfSd +QX2Zc+HbdTp/odt5U5lLqMIeRYHFiia4qxRb4gpYiQIcBBABAgAGBQJNzPDdAAoJ +EOGXASZ2ubc5ZVgP/RWoH9GM4X5nfJyEx1Iyc0m7f4uNNQF6vr2QlmIgaY5REKEt +E1YAJLWPJf19Xla41PLSElqyuZRyNKx7f7nb31P0XpEEWlV6DHtdxlZ3IhmZDt4Z +OXPkZ0z940/r8NA7n27rMs7iFnOntK6CzMjlD7mYcoyurV743GPLP06YN4zYyyeF +Y4AzhXXtY4Avxu4PzswZfST/Z1c5tc6KZBs+9MxIs2CU8zbkdFyCG8PqqjZHpZ/w +9H+/S/wYS6fw/LFFv9SRp6y6dTmAFqNPtgqORpPJxqOadLH7AjtkA6tJwXdAvz9p +/9uLRGjEB2sXxUo87AqTWKiJCv4HT7pPFGiH4BnCZ/+LPHf3OxWuV2kF0/mIFQlW +L//FWsu5HsZUiVDOqYQJayDTKk8UpyVeNhRtWM6Zf5SC8OHH3tQ+i5oKAuanA9Er +aTdLiTFRYWsM0YLCW6CSnAbHwpREEDP1HY8YbQaHtLxkPy6UbiL6ynZlSxCVwjHX +CHK1QSYAb1reT4kTqqobFhmed7ZdcTqxnuHcIjIzZ9TRE4i8lqHs6HAVA1maGo2x +YD6bFvIYCPaLbmDyM2tmU5Py2AEfJ6DQXlwV9qoJ30r+h0loBEBDrwiM2YsH0fSm +XFPeEpTThymNz+Ll1msWt6t0ZHlhrmBJFPRiRNNeGrGnXTLKdos2OELU/3LZiQIc +BBABAgAGBQJNzTIpAAoJEIZWH0UhgPz+mb4P+wZ0reI3lHnGG96D8KM87f1L5SCg +Al9BFk48GZXX3Vy18gz4tc1x71RTwWjb8C3HCAGp4H8PG4SnsX0sTyLLVqlcji4u +B6A3AA4p7y5LAKwmk6s7XokuECO5UlwwU21TZSgKwW0dHO5pM5YtKO7HfKYkYht2 +QG//vSGhwPSaOMlAo+8ucfpjeBfLAtZFOeK2552oLKrkvdSdMKOWabwjL+qA6JkU +sZXyX0CV5DOGF/NyFM+UV549dmcRTR9jVgfz4RbsiTYGtfLlBp+4Gh4U+yOBnkO2 +0mo1r64SZ4ui/7TJArlYWCRpHSAOF2Rs9fCztgZ41r4NbcCIa99GL346mSW0oC+2 +XpCk1sGoqKmIDsOCrW6wkL+NYqvVMmdgTheijqCYB7aypMMCSBrn5SzQS7V9DEW0 +D26mrMYqyDBr9f0Qk/ete0SnbLekk0LJuK+/U7h9q+KUp712evTngv3ioVfgf6RV +FbgG+jYC8gdt5O8vqy8JA5PRriquaohf+XGKWD98cgT2nBacK1SxW3Lps7AW8jwD +wyPkrmsU3yD0ECXRlLpKz6oRe74hJgTlHAyhlTQCXDJfkdhDm5hHFSCcM+kkLZCe +Rn9hxUkoRifnN4BCFOyfH3cgzU7LTVoDeheJ5TwxAh+E+vITkW7LlDuj+KjanC2K +UjdSvXpL/Ylr8BuuiQIcBBABAgAGBQJNzV18AAoJEEXXfp4wyxsRGDMQAIEo59/C +ReJ968sI7hTDRjq2MJ2Bd8EAu8iTLlTGVzEJfk6NjoTaEtXH1A0Hd70RBr82QZPm +dY7CGzxpnJ+6rWiizRL/Lv/4IhQffOfg6+Wuem/WQyEhCSoSoWcLyiN8O6RZU1iv +J4BeV6DgDIetY/Vj7oj9A8hq9IZ9FJJDFzvVXX490T5BzNySPeezXH363CLFWlRl +S7/TNLoE0E3oU6rRlVtNy8RvyR7/Xf+o13MrVZCnHuxkHYn1lwvfgQyVSf3xMDbj +LN1RCrrwEXqRy37Y6NA+G+KBeNNSgtZq+2KBkhIIAXSUvItIJeOBQT8mpkjWvdRE +jnHr4ZzuL4fbWoJzcVh1GL8s6reyZ+r/BbvJcHG2alDgK8HFRVB2ZpsF7GPq+ZpP +qR6k71OToGHykAaWQILprxibd+EHewshvI4KpWb6RXZfCw7tAVKyJ5N/UKCIErNP +7If5XdfJNboQCsm5a8cIVcAjnQUzxiZWvAbKWI8cV4QYdSEHS6rw55OPMTWxWpji +fokhBLgNP/N3CGdLJTPav14Wqb8HDhxXjemh4ks1lZUBtS9qTebmoZwKXfEuFwzp +uTr6nO8p/2Gqk/UVHIuNpWB2n0dIjvqWM4BC+gKuDOjjdR5TlWFWEn1fWvTLAqzD +qbH8X0nvBo59Ul/9ZYQpqIH3g5dl95v9+1UNiQIcBBABAgAGBQJNzv8BAAoJEGAE +JqEY9fvOIt8P/2n034OsAKm3Jmx4IuiiHiqERQGs1lxdRDluC0A6KOepHQ4mqw6P +s4c0qAglmv649KHtTf1mMhsA8sm3A2hEJ0bH67fGHnAPSHhfQhIAjIHiJ8SIUHSJ +piKlXHKIPntcLk5dLRMtImvN6vEgrxF3gvebRMu5S4gbHI30plgIoc2uyPWWIEtB +2+rZGFhJVWuGSURflmmv74x2RhgqyJRZ8irjna7uBU2RVhwCTAtPvRUbgJiskL0N +PsR7fPv9fq/mtOomppjWvZTVAQP2u1uxG2iCXBHwzrxbXil7VKbNcbuLB+a0afBF +Xt8PpzjG2CNkz+bZ7Z7f2/aSpi1DDRoRVqEpSixhXqmbav5vtXV8+KXkvWUwyL08 +FwQfOW8qa2nmyuD9BroNE2x2OqLqrmRERpNzwik4SlqusR2l1oD0CTmWR/bz34k/ +SjGwBY2DiFFL+NOkrBPDmWWZ7eNTD0X4ow6ZoHuyNzjX+27MIyGPnMCyfXvx59YZ +ZRpN96keNLp5E/OsI0Oxgrcn7ptc2BNgR9ruZzgYdp6niPLhRwAFAWXpBe9zJF/w +E6nsTT048/5qDwiU/Yku2jMRUPRMSVzQpdzaRd61ihPkhdYUlgWqcmvLGt1Al1bW +lR18XET0pcUqLLnMqF3xhlVmfvx6r9nvAPd2I9liz2sY0mMQHoip6kj6iQIcBBAB +AgAGBQJN0XUAAAoJEMY4l01keS1noZwQAIdGAAJLRlQDQlO0VySwyQnWHoJOuxzY +jpuPESXXHAQYzGh5E+LxSG2lceCv7sqYjw4Z74TtCfdds9BglTEwZvCQCnT/uJMs ++AaZSAxlpVcwcB8zJ/blfBAIAxqheVSZN9ywOrq7nifRwi6lrTTPNN0CEEDAvkkj +awNkKSroBnzbxC8i+lO2QvwobDpb8L9KQLNckQv4bJ14Ir4APWuKbZNR/GryiLkc +3OMBJhoiQpwVibcVLty5MpnMfNtSegTwPRYvgmgaEswRxF00A7ViLrIZ2oYflInn +Vo+hAvUNTl8e0zX2uqFIxEefzx91b53wdSVYuGPQFip7SkcGL2NYMAGo4pDDJ6BM +58jpoVvsOlSp6uAIau+g1UXYy+filKGio86j2t+zTfy/RkkT51CzKYk7PTNZVe/x +yjBxCi3y6IlXGhxkJXCEkcJNzGOYJ+TxlOStGsjwGNq4dcgT0gz7lIdEkDCdBwuw +0s7wBUTDObAy/z2q9pPgfr5OZN4bxdwrRzRRJEWfvTia/SZ/4nL/pWIEkUwHDS1C +YXi0zoMdv4J0Qt9sc6nAZA1MfhkND9iUrVaLJEYKEpmgo60yNBfYr9RoI+DNeOGc +nKaIeDkI794rO+YpZGBUY5Y94IxrwT6AhlgTuAgcLjT22the3qQ/0zOUSnQ88ssv +7w3+VLf+G0P6iQIcBBABAgAGBQJN1BCnAAoJEONS1cUcUEHUM1gP/0Q/iplD9H7B +yygMQmL76X1Qpl8CIIyEFO6CNgnAbNzhNr/dxcTfz8TGfnSNsh0PfdhVmaU6D2OO +ibg96mPBi++Uu0PWlwq1WPrVusrJ8dSnXVlOvZbyGwBTPeJtKWb+IF93HVa/0ly0 +/K9R7V9+9/t64+Gc5wXe1qHKWIU3HLcnPXleFEnh9Kg5KZ//apTQtyAojPbcVqDO +XUPzHTKVepyRCd9mYnMl9XSnx9H+qUz2CKflbo87tne4dLhmv9fGGUSGhVQrDQiq +THrw4ZrknY+lNphtpzQj3t8852ihGx8PsxfI+47yv3GKrWnGCuyynkSq5FFWtcCF +V/U0SfEh3pEByBSk/ykiqKjOF1VJir53UCV0IHIchLIe2K6QSzSTDOQkPI/iTtGq +ENjwlCX3Hik3eE+Ha8eV9WDE6D+CYfzIjQlxXFNYKO2x3Wwfg3g6IossvlLQPapU +JvWU+Qhh79Si/XXwYB/9K+GJGO5sHU1ikbtvzQnNj68bMS6TZnPIy7WCa1FlHkCT +GtFxOzeZyEFM0LTaljK6ZVWaNbLD2BW/wXREH2SLb4k24relwRWQMQ8ZNd7Wf46Z +0bxCwgGocfNgg7axNgYjT2YgcsHAp7x1FcSO0/2ijHguMEjzPKRLrHCgqOcywjSC +4QEUyB7aGIXGeKYwH0iEva4LopBC8nvMiQIcBBABCAAGBQJMytXyAAoJEJwxUDxt +hmOWY/oQAI8Hkj9C53/L7SUOuLzVUaBSQ5XzEMCcBn8rgIpcCvbXdtSnfy1VzbmD +4stLeulJUBy9EFSMI5ts1U7+QWDI4oxvPwGmXDQPaIvHoXeabt2ez7NEy/x/tx9U +2izt5557p0U/ioqLu+oT1inYnBnvXDLAZfZdi3bxTD4Jec3juRc5S2MAOkpAs7Fe +MVRIk75e6WIDKfxqZuC47ycOrmPXMQFWxsWjaVSBWzSOPFZ+Luc9Gn4uHwen1tP7 +7zIYW6rbl5BOImmmNB6D2D98kz1rKbvNEp1r2QzasxVRdzEXeNbpJi6nc/yqv2v6 +FOSIP6rbxPSPkRWZa8XUmFUpeTVeVpZMWQOLNZbH1KgH7yGfgYYn4kkoSiuKNVvt +SBArf4/RLPKHUNlC9+ZDZEsGqHlpwpZfp+k+RIQhbxz6bKzNfM/SZuNHGh+aHNgm +H3eXe+/vUcraaP8qaaslU1q6tPDaEH+aIsdt9Hj9hjMoiKsSmzo2RJB033gMeaB3 +iLHPZ3mxDfrngsRSIH1Q2RHuaKwY//44/Xie7mLo7Ng6V+nM/s9e4trv7eYwYcGx +wIQ6lUb0YYZsrmIHAO/apoPO+1+DENJG+Jkgg69O9CEGk9LAlKKCUFj8X3H/7AO7 +mV788p7NgFPPvNZkqFhsN1mTluoZHTomLFkEkAcLoGhnfxAwXIZHiQIcBBABCAAG +BQJNzSkvAAoJEBiz9Q/lkjwYkgkP/ih2IfUTH8FD1U+HCYnMLmaiS5oUEqXBHE4S +3/H9Apz23XtYP9n31Xrj+PR2B3i91d8vJE2bp3AMGGjeJ3fktRtx9t/kB1g7KvvY +I5U9pgkxFqelkJVr+hTmSxYEEMehRZyVsUvsFH/fys9FS6S1EzdHVFPOl1ozZ5IT +jJM+OpSTShfSXtOY/bB5MFtC6NfZ/3NgJUKJC2B+qhpuQlstWcjTkRl5/aV/vj/s +NSOFBZbghWwx+lHUWm3aCywJVjb+CJgC5QfXMBw8IjkeGhaWvoGn2R8wzK2G+F5y +GTVHMEgjnQ6Qq9H4BcMCl3PBzdISH+lyHR+XRKZIvtRS6YnLiGVkwPcNndm12cft +zysedKohlCgkNewyn7I87/gkLXxmSUc+FHzYqKyKEODyDB7lZrrjGrYmOUyhny2i +BL7UOPkhbLsdzt98NkgUXEToAmBny2iW+5Grmd8IXtxlDL5wWAryU/xNlu31jSIX +XHQIAAmsaxJoyYceLn+4rV+pPkOykUOMSR1s/UVis/JfsdXOF6zM4OoXxgC8dMA2 +vicswJUbjAkwdSWfqRHMXOpv1D5dkn66AQi33ArM+5oIVsdYM2PaWtXEjdHTj1JQ +q3NzkOCBqzfUVGuMBjzWzGW6gwlPKC6NDknVQqQ69aSrMtC5vf9RwELcZDwacSSw +k1w2ZRuIiQIcBBABCgAGBQJOsr0ZAAoJEJcyXdj5/dUGZ9cP/RYfq6CYcBBfwSRi +6Z8CBgFJDP3wNcBPpOG5vw1/AgBPvqu1MEDih+4nrq+KyjqfphUS4qfP9xUi8eQ3 +V396kRTuFoKo/X4ojIyLk3FvKEXLhM6CiiioSAr5ujxc9ja+2VtYWKGgLLlNOF1S +YufgcqL9iScPtB5UA6eNpxsyy60pJKeWuXjUipNNWqG3+cnBYnQ9NqpPzyucOJLE +JLz9SgySlSNAj4ceRqa8XjtHWNPvo4rF7vGkHDxfJPjAqj+/wGXUdWV1RlDq+uEI +ONQOfM1kj33pSU+VipkKmssaL+aueRMS4RWxncok9j/UIbZX7j6sdQaKUeF7EA// +5f2Ts5Qnc6VYhCv7eotVBEwn0O3tO9FHs5R619ZXxgyw03inXglI1Gy9w2/7zj6f +cbxfJnrXCkvJZ5udnZn7jpcdtn5pEOLvhBIbwc9kybmbr50ScGTz8k+dZJXzyNSd +S8VQm2Ubi9BdRi2lBvQq77wZ6hIjuHQUTM8Lhm3baKn3L+CgR4QbdlakMO+/Nmgy +dQ2j9EGQaGWr+CQ639zwAV4jsib0OwFDAFpEI1kAABeAfaD2O1osg62kITBBgNEr +qKdvysBShWNSha81cpRUyk/XGLcoUnLvdRJANlw0gkftJyYI78q6KJKdivogBOY6 +TJJAqtcjKmy7pmPcpn8t7kOEZeGmiQIgBBABAgAKBQJRR7VMAwUBeAAKCRASX1xn +3+lAhN6RD/0WvyA5ky5KyDto/rHVzPanacV/qkmntZcGbLpNk8Twq6zRA+Oint2H +DN6/xdf/WB0UnT6zS+yF/rVtavMPEkw2yfknem+3oddR/a7aZ9bQVk5fEATohlyj +O6C67VxyZrhk5RsTdS9M2N7OiX9iN3gtU5SB7SWJbnIw9z8pjkzk9y7u/sj1CQrh +n0C5TFDDNgmPKO3EIac1uJLzLM/GCbIn++qL312y7O7FNV2GIBJJ9ml9jdpnViJR +o/QZdNEMmECIUkycmwpxbLznIP3VoMkRYJHOei8D7ZfaDChMs+6b8HwGOXzEiWje +ZsyTTlWmHjbWCGynl/njmM7FG2d6RZra4bVxFagp3c/+ougFxJjxjImMI9k2Tc4V +SFL9CepGcCpZZ6aA3e9egQooYMDATpmMFSNt3aVuHlYu46ZxUEu0uuUvE/m0LQEe +MlZnyB8qUrR+HgZ9Z5HE0k89FlGNkY2SZh6QmB2QXneFA8F7hleOzG2wA3bm+drY +Hr2tf6Tu3cY/unNbOGDPswmBY/B6QJsYKQ8o9njvH7xI9VauAQ6cT1SSlQmOzqta +7qnOjHcxVmoHLJHhlsWrIe9SpyQQIpS3RKi1c4nTJopDeazh0DvpFD5NBEqvPdB7 +FwRpAZEi0+AVY9gTlFxrAGionyyRwBLLL7cRF3/bmHUi2XaoI3LsNYkCNwQTAQgA +IQUCSgt7DAIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRASbrVjp0sGv/uK +EADC8ly1E8mvZNzHGv3HDvneJdZyG6Lk8+od5JpZFDxRPguPIm6GX3kFqvQZyQRX +Dmmec/HerQqe9i6PN2QwmVHPlxX3Qy/PBtoA71XTi0lKB2BJQYoa+NoBSd5GLa3U +JDkzPEVomIbt4ecPgRBVVO98mMT/LFrqQ/xNnIpY1iC2F8QnUpQc58Lg/JeaBYTL +IEkeqBXWZ18PfhIoqlQnVsxTI9iVwHtV2VfcbPeGcdbRg0TNjujEPzvHzjTW18rH +DWJopQxb0h/87w0mprQN5YxKWBYpitgNoaGICt972sZzvjakJ5jKbmFLmHrtwPML +rRPNm1OivPXNs2MssZrZxUBjkCdV0sT6/pRK97h06NCL8mwE75wDnKJhlRTSXTOM +GELRb/LDrrKPetPG70jFlC8LuBuIVHRgfWc2WLkVDpPQ2mAgKWFUUo/4AKEa/WYr +gKsc1nvG+yGN2Rp+K5P3Iles/h6+X/k3ZQ95fTsxcozvs8isdo2DaNxEC4YWmRFm +hUSddIpGXe0yecv+Fryptp03+7jzhXmU/p0tnNoaqZgArcLznqvxqxz/ib8ET8kh +22RXdhYJxuvu+D8y+BbO3HZ7e6i4bu66cl4YzpIQzdeyDFpKjj3JMcCDnmsAeeHq +4omDz/mATEv5kiA9s5/XavHZIDqP/YiGk0kUTRQzmqhKjIhGBBARAgAGBQJRR34f +AAoJEJnN6p2kE1s4mmUAn0S3nl4NavJKaGb/Vdu8noCMeho3AJ4k0SFLmvck5X6M +DmML7OJ092TqP4hGBBARCAAGBQJPrSS1AAoJEPbdMwIQ+kzRcakAn0KFpbnuAp9d +rR4zqqDI+SGeC0H7AJ4h9kdAoxqeICahypdGw/DMEzsixohMBBMRAgAMBQJTVb6u +BYMHhh+AAAoJELzLHicxcmLSWksAmQHY5pyYe60K3jtPXzN8nAXu2sTRAJ4g89dj +MOyt3T/mf77WIChBhoPswokCHAQQAQIABgUCU0mPfgAKCRAEw2fCGK3U/0PlD/94 +K5hJKIga6jEGvegludiv1HyhBdRwh8+phQTkvY9ga/aLXPkkqfywr7ZfKUkrn24b +/4095SPHx11GibG7MHpkXPX/bqwh7oYZKPudXAIJEIxwVo9RY6f2h51wh06Wl7D+ +DbtWM42KwvF2Vh0JEpUp5RrMkimm1qThw34V0MXQKBWPBmaIShZXbsa1Zrd104uf +YpEMFYwYWa8m6MtFEud8i2A5shrLg6llM0/YTupgsRVu/vCXAImOfXNxdiilQN9b +9V7pP+J/n3K9T04CIWVP6D6RrTcx0vWYz1kHGuYb8zORCDG8IEkuNsp73movry7X +UABnBeKjN4v7ZqVx/6kUWjpdUA3nd49pw5HTZiVGJfpTE0wx0zhffuK1qtFuvxQ+ +pSAOeJ3wHI40YqgJDJJ8HF05vVIHRZDBW0Qlsj3OE+73QIQm0FD1eCUPcCR4Fuw0 +jeQ4diVQCqeWOtRuH5dFwLDb+k/fvUzcl52FM9HKpjFYzU3O0+wOc4fIiQjKkEKi +Vv4oR019xzumUxu/GByAmuzLiZMy775YmZRmsbAq/yxTcb0713YdVVgqHI2ybuff +1xruyA7/3Nba7zOiEF+iV9NKu+gjlNdVJmwXxG/lTWHhi5QGMhDq2N2wdVZJNnd/ ++i57upLQm5vZgyitAkSKriOCzTQINC6JDRB5Ns3W34kCHAQQAQIABgUCU02Z0wAK +CRAup2ucK0ZtnaaGD/42X7BB27Sk3dXdn3wMcM3+Ye4itYtQCtCzEjT6ECWMCAKb +KBUtK5BLBbwILllECYWaZrCktNMrO+YbX0cqp+/339rJt1QL2Vs3Ajz01R6UKuLT +1D8/Bnz4XJdUG/5OpToLrRHxhqFshjMbFLNOoyLeC822gHHEYcYvrlRrbR4kXPFt +q5oAZr3Mk41ush3Y/bTDhLkF0qgoZJp9vtFVs4i97d/Y3c1cJ0pFP4Zpqw19SzX3 +ibLWD9zild11+jBr8Y4Q6ly8+xSgPd46rhTYKErxvHx0cmGo4z7NrSiE7WyyEiia +XK55RRLf+ebMtzf0HStDyHMrIh5FSteXaJn3s5dd/AEbiNLUyaOuUoy9Kn3OEgNm +soFQd4ht02DJJhxvub66nJJNj0K5IftBcJDUII5HuCItvfEvchhcekMcw+EuhjRp +tC1aV1zhezqK1VFDOY0HDEX+uQbgPXIR1TySM56f0CpQXBCbs7vJdvDB5o+QEIwW +bF0WgR7Cmcb3WTOpWKkyPBeVf58idCdfZ8kB3QBlh2JFVeSXnSAtj2O7HQhvaGIp +aBQt+U91c36fnQQydtP7vYzjEENAOIg4zBWV0W9KPCN8n8A99machczOn0NaNTfT +uSuMsqIRMP8kykkqL56V0lnflK5rkaKL3ObBfUiab3nlK7Mt4WzLaYDn5xx97okC +HAQQAQIABgUCU/vASgAKCRBklZ/pg43xnAnmD/0V3mIVDO6aqVhpOSaVc7c4G41G +BvWM7kH9DXfvm6NXjbN1UXRiM5EVmRgeq6rGcw35LygCX8axThzAITd8yGOYVtaM +umKEyE4Ry2uqgpB4gLrqxgna8JVHmpjZvOXd1ZNmT1SxWGAaXcJOfuHtJvoL0Mpd +nWqEljrnbySd1fPWlo2CSHrn/BaZHtlHt5/ehtDtg3lJ/oH+YRCOpP7b1puHqtTr +6rVVd5FsMpmmDJLKuROds/TKyo5wOwaTOfbJoB+6+oZ+4fTc2j6jRJl/wPqaM40B +3B6rwPrj4wNlp9Fv2syUoq2Breh+flu8zwtAzACYv7ZYQeus6TWNkMb9CLNO4u3l +X00sWWsXgGpxN+YeV9KYGrCiEyJ4wQlHDlCLclsxi/UhVcQZewUdQyIiBzzDmbbt +8LAIxhXsc3OFD5lVk/DXoW15JPqpsJUfBhNhjpvIcJYMSUefaiXN1Og0GQcL5iij +3hyKcRasQQHs7X/y8OfgrIZT2y6XD2PZ7+vpSH+/+q8ALyzKTMafGZB/5HGqx4PY +tzIsCCHBn0UuguDxapCtw6BMBoJqtD9tT69ENx29BIeASHF2legsokmwec8ZBGoE +ovKoQlw/nQYyxPextbRTL0Wdy+yED31qroH1OgpOZTF/X1FNs+7Yo1A1un0pzV+x +WVCrvRUfNwptNhbFjIkCHAQQAQgABgUCT60kYQAKCRA5NYfZfYZQC1gEEACW0/q/ +09bY/gArmPfDFCVTDzewwCLL/ab8dCkqGUEMyNQe5D1tB9SaVdXCbQt4efEke51e +wfbf9/urPktKvOv/XBN53x2xFCQrC3LrG6k7/Oj+xDV0+OUalh0c3jiiWs/PZEde +renAri4puCS7OzW+TKE+LtYevYnTJNJU4jdigEjsYCII5nN8Q0vM+vLU8flYDfn4 +pj5NYoct7/eTF5aGSDSoBbEPGoXBVdnORbROdsFIHpnB6ABuzKdy9c3LRdbiV2gp +z2vh9Cvjeuqx76QqFDMKTcF0h4plXxGAYIaS8WEQViyy7XwlvcqhC4UOmi+Ysg39 +d+A73w82z0IOg7yrTRx84R4LWmWZaaz9WQvE4lwcrxRqCeX8lyJmzKpZrXctu3Ep +k3F8/+TnfBZKmn+YPD8oORGlXXvKfYuLb1UB7CJVZisHAU4ykvnopNyK//u4RVpn +HOWUjVdhMuJ3EDnt+pw4V+NRHIv8+LPia6oB9pyjbk5F0yhrctsIjbiiP3Gm1jd6 +lxVp0j65Kt8hSj2TVQDaAxKIKPJk1QM3JX7OWV7cJaKH5zWAVm53amTyveraUO+J +ucSKG+Q4YSI8IN09baHYCgu9H72rYvoE5v/P9n1EXLxznj6B/wAR+W6LWu9N/zYY +ylG6nkX59SSghBAOxdRhUHkUdl15i6uwmkpOMIkCHAQQAQgABgUCU1nNkgAKCRC+ +XPaH3Fq3wu/PEACJHuTXh7baXj6MmK3SFbDZglky6yjADU59iJg8ujtXR/876dDt +SZM+JIt/xS5g7nFgZ2k9lvXLpgChInVIdlMqXWl0wsT2hWowswsp5GyStYkDHrOv +LN9D24XhlB0QdipwNYQJa8FGGRxUwc/U+W2EOwsSCY8/+G6WR0sMsXKSRl/ri0JI +DjEOiUH0N3bYAPhpuWTdlP2nr6/HcDJEtGK58TqPtSB4qQ8MzM25dgyDkQ07moKy +mL1ZSQ+CrwytaPsvNBQUOcaZU0kPwLqucGZu/eYeKjfuLcVSHcAumfpCVI4nqofB +H/Jc0j3408MDfDfoshue224Te6xWnqkm7CMYrJPa2LuY/lFL2ApqekzqPSD1I8kn +sae+btND/qY/8iCuwIYlZr2Bl5VM2qrSj1iFoIkkzS/ps+BDMxmDDQlnczsL0gXm +9xwKzGtCPsGI64OR9UqONCynVF0Ml+O7rmAgN9sBSoP27yqSkQfdIMGi8SnWEmu0 +zgjEK5bOerWM5noP9xE8foSnqUeW2nNzUHv6Z/nOEmsRQb1coGjnr7+cFGEvP/kx +FQMtPQJ1Ns5Lb0HAvPEflrX5/J7nr+Vam24n7JE3gaASky0KSNaDt8KsOFBncowQ +t4pqom8pK+wkw58sPJHRHnUgLAq/FgjfEhRe77yY9N1m+xd3qzqvS0ag+YkCHAQQ +AQgABgUCU/z4XQAKCRD6ZDumHSJ6+zhqEACu2qqYXncghbsPnF9knzn1tmtolPMA +D9qp+YcApUdJmUgLPDjMx0cda1ClursEJMmQPx16JPGgHovm9gvTYZ/eAhQrxPXR +YFeE1vSGd4ZQ1zHsJb2ZyvmMFDqtrvtJW2SWcXGi5w+9Tm0Ql0AgV6Ao6v6WGuOf +YVcSkbJw4YOgu1W06sIGrRl3ZvGoNOilSfbsaTVMaBSTJD6iFizBCFnhVfnYH6PF +qn5R2w9RNBBtL7ft5+Fl4lGrJu1+3XGir6OQmQl7LnCQQWddJ7zygSlsfHZeHpV/ +T2Tu3Yp8qQAeP/8jt4+MqpU9KJ+Ky6BbEwtMTH9T1MqDe/kQqcMWgkVFVzt4NFfb +VE94sdw5p6cR3xvG6fJ2mZwd5T+rve88saSNwJWbSEg2s9S7zTySYLN5bnyS2YxB +b3tNyPtGGUemCjUkk1K9aTx7dACIvyWFZd3L4tS4BhoUse7Ui3Qnyh6DziLLbANC +yyY5OPEFzqw++GrM+xagxWL41irCM46ZGhLxImLgSNW5vydKUomXhPPNsL0afSXP +5W8hciBBFjdvViW8ZRlhe3tTQ0ZUZWTp3JYO1HXwF1fqqd1m9c2YW18LJLt+SW3n +R6koIDmt59rN9BAmxjnyh9/Fn4r7exl3USnBh1vYY2BR8Ja2BuyvgeNRyzQP/IU1 +9OpEjmgFa32uhokCHAQQAQgABgUCVAEH8wAKCRBPoEpMkld+xM/vD/48VmBY1JIA +g+DEO+X8tmyiXiNc6pBI99Lv6MhdyJca5LJ0zmlywBB5xqKJkI+UVuMaOB1YEjB5 +TZIXTdEYFw9uVUZXXwVJEUAHnqC3LwLh3oT1X4TFzwJb9Zqmp6Cp25meu6/P5BF7 +eC219SUACrr8tmPv6CYGLN535Cs5iKlZIY7vUxwZTkirkocJmBZNlyXjnxWlYCHo +JDoUnCbypp9B/LPOFGZmDZjBuCA8/ctPJB4bEeFM8+EB5isDnvTrOlygU5sBIcFg +qHNDafoejqF2qgP4/8aq5Xmoaqyl0n/MWMh7rGpLOUbNh+fxG7FBZDotCnRPKZ21 +pAwVhGGD+Btqq1mBI5CCa1dsc8bpueHsgOmqCCbs5LHgIw3B/UrmFSkLrULpd5Bk +Tgik7bLC8CN8yK085SIb3sl0Wj3IoBK3gith565qIne3LSWDFnI5Eq9BiO5xQXUy +ER0lAlskF6FwVp9JLPwoTNlfn0Wls3iiZCLiaJOIaj1npwAHW1A2wIXOdzSk1rw8 +JFtXYnNNk6Lqlvx7tvJ+ls+sNpvQrsEPGsz03bXatXdEfaRTXfUPliTpbH8QpvsS +GRM+kqxo9b1hkX2vWd/tsNoVeH6vlwI/rtX5zfYYmAcpTp7EYmhJcIl3+rvfxGi7 +qyPwjquahievt3ZRNQh4ETQbwkt62hMxv4kCHAQQAQgABgUCVAOywgAKCRBnOgPk +wduSH2crD/0cF9qD3nRkaZBIF0iEoWksS81QSt3tF/UbXjLs6yam7NCCGxf7mWJW +8cm/uXNGNqSgRZJnqoizdQoQA74MB0l2h0ZUj5kOcdjCAY1GyD0YMElD/sVlr+OB +qjZSHKe26N/ANNpiiZDTpl71te1W/m0XyEotFoj6SLA1qsjzyq7nZV0zx7QWrU4x +TCvIXSstzCMVFM7LHGqWBRSwlboInTHHNKQ7ilBdSQ3rvhjNpBMnutcAtFfLrIdm +/7PggU9kYSSmjIeFYo7/xkWG2OqlVTXXowbiFmjKAPWr2K2sZ5YdR2j4Gbl5r8Ix +NrF8yi9YsrtXrreUE0Tcx9m/8y2IvK551Zj435Y0NOMhF59wW5uExvWILyDFQmJL +PR0Bl9ugG09TTIX7l3LX7gEfTOfPi3oKeR0g0vqPf1nE5sgXrHj4vgnBHHr5gwuZ +Gk3EKa/0ZYBfFJSAqO1ggv3s/5XPOltRhbkEWzxrJaLkM1qreu941IciXZzWJaE1 +G0LEbrwxAyP+pSlxJi1r8/0khV49elUvSXSP2zExq9JNpl8OxdcLmxIP5a3/Sz0z +TQCaLFYoAy3BP3gnCWrcbJ4iqNBmNmf/AF6/VELT4EXQWoe0569LHRte5hwQCv/z +YfkLYn8yMcZS+krMC9OTRUbH2p9cbGGjGZS8+SWSGiO7X+/DCKvXTokCHAQQAQgA +BgUCVAUcJgAKCRDA+IZM2j0DWOaED/9eSjL4grokEGAi6pZj+hv30SvlS0R3OwD2 +MvP/K9fTbth2ucPfJDz8ZKAsUGXIQIqzKt5geBI93mb9oAqLJfcQ9wyu7JlfsVBL +bCICpkpRduC/JmK+5DcutrQsQjwRIuhdpH0cEUj1nOV3h+3Umcq2MCQPbQZbgTMH +EB2f4yxsnwNplOD/LvML+2MbglX4O+J+LeGSvpAehCUTevX+L8G01aDiEqSiXSdx +a7fUlcUU7tWpK2GOKgt91umBC6MtAiBwl6i+9euigLp9KuMFlOmj4ryG0oAEP1vV +Q3Eok3reTy7cvQUc0vX6oFgFI7OC5hggwFewzW+5w9nZrcllWQ+MrEeLWcGZ/Cc6 +Glpb3j0dUxVG0l+zff7MxaajheBHOi39ZzHIGva/ooQWx66VWo+VtMiiEDfSjH7s +edFMBEIh55qxCZJGU6YPpit/4266iqto+ZRC2YpbQ7JWbKDBBiScc5tLEuDZYz/C +GvOx8v/D4MAg8/aQPkZ+zIlm2ccpfTeliYZkfweu495U9WiWQlfz3wdWrGC/779g +QT+zzwAD4wHQIhLMekNC4ONFLfmGnSi30ATik/ACun44LQH6inyOQYiLxJU5QJj6 +3dkkAxvactZ8+NmPgkO6GpiHd6t92iFQ2FKW+mPzrNx9ctmsbmE5YLV1kMJwZkyM +NEzBjwTSSIkCHAQQAQgABgUCVAe+5AAKCRA7VuK71T/csV9jD/oDse+t2S08hjNE +FPwGD63JP9fGumbpACbQj6p2WanpINM+gBeONy3ikpbWl+hYKOEGlNEL0iWBx11r +xLq049q6CN7624OvIkK6CeZYQGZymw+tOYMh+YfYJIL3FxytyxSeI3oQsEcIng3F +Yzm6j1EX/YJ5/VIGaXMOJgO9WJtb0H9L++pzgzHyEv5jD7UcsfOKg4iCPDFxqFsN +2hbnkrRwtXDPcWZvvtjDTAtgO5KqRZGcrAJlLqpHAlRrbvUMsq2Hn3lLcXJlbIN9 +ZevRAjTndjA8rZGDH3lElxTXWTFHMVblY7mehK4Tx/0UqIj2+VIg0c9e+Vd/s4YO +Umo6GG7ZFVClvBzVeNiMbukH3phAaqXphJ7OQtRIkslaDn+yuov5aj5da3KEhs3a +F+EDZuGvKWhLqjy9jXFBL3/3QNrzBp42eaXlV4pgGIcL2JWtkPqrPf8/nfRCuzDv +/fQU7KezAXRt3WHm9CYZ0BYI3hDji/jMEfgWPP7rnr7dNHyehAIFvHD+srKykoKh +7w6R9zymwnV7/lWfnRp+7evYQ0dCRQ+sZKe1KDDEvGIfcTTJ8NqXFZxIQ6Ky/EfE ++n5hMXVKu+uDqJQ3os+yzGz4adVb/dTSoceoWFXVbl0PtmWWFIRFLMVhT+K478b8 +JWgayhRdcPkLnlb3KZJSe6EdoEnj0YkCHAQQAQgABgUCVBwvrwAKCRDZKfKZK+8K +M9/AEACDDFHNie42D0JruyX7TI/qRXkPtuFx8tZqAwB8s23SgJrfxfpI1JVq9nFY +D9DvdEyvM9tkwY+4szqwkkp+8zGhIyylwn5pMkPZ0UYSFEIVvsy5XXhhKbD3GAtJ +r5a2PrZyyLv5ptJN2TllHYrJpPFgaZrjgUYWxfaOs6CRVDkrqqs6eEEcm9Y/7WDf +wMgNYabugPPcJk3abmQEoQNlQWthUPOCYbSaT1+VPpLzsuykiwPyHwRDxJJxEjbf +561ymB/omB/mRyrTDXaJaUiCXCeptix0xP7Vywx/C7cAou5mBzGCwL8LRxRg1Nsw +rAGj5SCWOL1jBWVoD4jjS28zLW9d+yPgRltpFHmsMAjADJ2Vk9tVJqwGTx4TDa2t +T7v2wtCXnDdr7OoI9H1lhZkFhp8Cjw8pWkhfTMngm38JjlFvZVwJ11XxxHymunMD +YHLvO3l68VPEF5oxFtwPGESc92NiimjOJ+vsTMPaiD+UKZysCtin/rs2i7/gxGbm +tlc35JIzkAcYDXpKtogQHwAzI4hSxMwKb+Xt2mzZHsL1C5u8K0cg+YItsoK4jO1V +aC0F1YWXhZlvWsFkgKhd/MCmuKPYMtlqYxLZQlceI7RtUsdiRh9lYmAijksGlHze +5GeN98L5uV2rhx5yLm5c2KdNH4VjzyKaBKsGYFshCzREaAxT0YkCHAQQAQoABgUC +VAKDPAAKCRAedZpyap/ddPdbEADIsWCqQBh7TMZpUjvZLrYu3kSr2wEP7LF5OeHr +P//W/eMWYPHEaHYlui4K6P/kZnmQNpRpyHTSo+iYcwFtiELm5KHEWREvr+TMJkmk +SslhaHXbM5rDUW1her8j61jrJN1Rr1aFpFEv3+4oYi6QKv5/2bij3zC0mYcBHe4G +JmeAgOMRr3B0D8HddLv+nUGeku08deegWOsUA0J9AXy1rtwwCW6mreqav//gCS5G +BejLFdqE/M2GiuCG/VnxzkVl0UrAlrgoQIH4si/Avf5OU2zJvvwOeYKyE1p36xEG +I4SFEomNFlLRVBpI142p19v3m49msfVcEoc+C//KC3stvLenHXKmEiZEVNfvGuej +7+otGMUOVOqgznFU27DmYjgHkPrw4ickBPT4BX68xdnfBP68+Qz88R6E/qerJu1m +wX9c8UAlmjIp9acCtuDBtlt860wUbAuf0u5g0Frybx4kse3YnS2y9AyEU6+pm/My +4+FWhglM0ofr3WwvnCNjPAsg16R/4NoH1qVMF8utursAMPJTWa+TRGB6FXXUhb1J +KZNpHSXpWhvFZfylTzoA1jy1NP8d3P5Xeo0bAAF/C6cpGREA0g9bVWDZyh3317Qr +meaqttMYgF2jbtw0JfQ/GY6RPsnXhHmdyTr7CsBVT6GE5JuIjKJciIItOAe7MLah +SgvoookCHAQQAQoABgUCVAc3uwAKCRADapwlvzV91AJuD/9ND4Qk1H832ce3SwIX +1TnMrbyd95GBjMy3AfLLNvjdMsuY+PtTisbtR1NBxDuUUl//icTA+dI7sbl5TTqN +L2Vr9YFfRWqA4pN6eDUz1zdjIDo57RIYo8z0laa1VxB0By4O7o0vXH/wOhSwce40 +ucUOcglH1/jsHUqKLHtx67GN1jvEVGCJc8EqbPbupSJ1V6uzxQxUVPzm9tP4twcl +x2uvp/hemDUYRAGDwgB2PNwFpRkCPsjfDk3d1s9FZIgpG/75unDxITP9hvCa7TAG +OhYp37ys0GIyiQUu49mHajIdQFA+kxkPeQnTcN7xZ6pvxLTyaA70u6T8SVc/NPFh +NFO9f3EZ+EisM18rihnfkEIfAnC8TbvTk+s+dzPS8Y8jywV/X3SOMWRMBuMIbzgm +Fr8pIJO/9EFf8eElPEHZzA9+oyrmsdYMI2LZni+abigtDxHb+XwKa3snbba5T75d +xrCBCxscp4rnzIFKvQ5nFauRO+VpXel5zmy193ZnaiNGutZyPcedjEd6qULy7Uje +J9yuukNyNQckgDg7BRs+RJyEAkpf2W98awMW3nSLAu5o+Qd+aVfjZyoNopeFg7Aj +VWvh2Tu4fJrliIumBOI6tvOw65w7KfInRP6847yppFpxWkWEsIG1Elet7kidrU6x +VNx0e3t1xtIfyvADqii4aXZzgIkCHAQQAQoABgUCVA0bBwAKCRB1GrXdp5Z5zOAh +D/96mI5NTpSIxhhbX4KmMVkFPEpns3YX3XgYsEL2qo2F+eyfaReCSuDmECLbfYMw +eaeyK/QNUqg3SmWObcykzViC8a1mIpEtmtoTXFThuPtEr95ADBvPmbBpDCuRwg7J +kLvpynySltW/KwrKJcPIx3MV60bq2/BbCU65xar31IrFdDYaiGM6oCQUJJ+RghSP +Gj2IdbQTse+XWVp/bu2BIjV/1PJ/Dfvl9DDXaV/QumtiEiolHBIor7j/MKGVKfmt +TshPlzvr3ABLEuZ512YOdw1MO4d5cx8N+xItZsykS762M/DBxRBQlHdgM8C5qXul +vIQ2Ec7iUapB2QsNnd/mfZ4OcLvGFHqyxYZZg7FSxTxRhFRbBM/XKoqi+eUFIgyJ +rY9WcnKAYZuAigzubaCTuebJx8GICj4lchKdLP+hRecqTcLjMIV7Xwe7s0R6nXzc +GWZUnjOjRu7Md+0QIsujcc3CrGW3jK7+d2A6jb/leZDNihGS0dzZeOO+5TCOOgHJ +rnSDi227+CV1sBdsZkKsm9t9J2Cd0uSZ/C0XvH/i+cPaeZOnD6tC7l8eYZQxtxik +MSXFBqcwjssiwCUHy/Pbpr3mJFzjY39tFs/iYzZHWyjC/RMzg8X9zNEhQv/00P2y +J1PxPKW5t0j/7XJTGtt8xNhhw3xp/QpJgyE2iXrnDcMGu4kCHAQQAQoABgUCVA9V +7AAKCRBuYItjfYln6Ud2D/9+DNX6ihr5BPhoN1c23i/O9zRbsHoE1rTxEhVUhtOh +n5G5bxaYM6BaYCL1H83mQ1yUp6pMZyUaAEwFyZr9EkugzfSQlpbi6WfaX7+Lt10x +tzyT+b5FIAtUv27rTPTwycyL8+GrtbS1BritIEvDaaDCYhi3VBGNbz9L6mlpK/0e +ZSWa1/O8s7L5Qn5XK/6IQXykQMvkbUf6QuWWIbkFctZyZen8TRZ2WAdreGIIdT+A +tdxKhuPGssegD/KOWi3V+dulySUPqRcPDfZUr57G1DqUvjFVCej/Aaddx+5ZZM08 +XzgjSFVz9lAFw1kUyY/WQEoT6mZ1/iUvVGJ6Kd14Es36q8PhAxfaTHMDMi3CKY/h +zOxVhx82l4n73uhAgLwpbEt61DzU6ABW2lz9T9Cj70dq1sD/q+KoKsZQguvze+0g +Q2hldhDH9k5s0sEHET9iWr+vCRVeQ25KFoqBsh+lXGSkXdxFp39+6R1AhcqCTCkh +xPx5qpLonjlZHLm71hAfY8heKgaHRKyBuoSWjzge0l3qgScZAMwGbatNIQkmL3V7 +PaELGzmyHYXJgw0xGhKYKd5ezZicy2JuM8yznP0JrUgZWL/p8cuHizmqpAVyPFln +nC0Ns5cavM9d2R8I+CEaYpEB0SxQskVevlWTa4FDjE5ZRqF5vbbaVR22n4UE0nL8 +zIkCHAQQAQoABgUCVA9ltgAKCRD7PSWDO2qv+DB2D/4zrulGg5aW34lnTLZzx+Fh +POLxsGi24fQa17oV73W7r7UC3IP4FFH1wNfSi/dKOorG2q/kDG44Qw6i8x9agXzA +20tHqMnUWCwE0FGg9LhgvZ2cvWWvBK1jYNBU/+53vY3CG57jU7UvVlbT847mRF/h +pVfVwHHXS8/o7VtyDnvRLc/w9mhr+JJqENOCS03Eqb3cA+NQf87Mb6ohKf+zWcF5 +RHVc7w5gqDxIubmnA45cPnPmk5od61q6VsU3+1mtxO2PJHiy41RTBsX3TqO2OvDd +V32k5jEADGJtt4gkSWSL2G4SAaZy611S65zBW9twHu/AZq/SjkvcRO9eoKgCrILI +B6fgRkZGqRsSq/b55f+XRrGawlCV1/xmJBQsG8ME0XKM6iz97u/cgEXoZ9a5v3By +sNfPMnUdF7mcOQosTFNS2eugG5LiWxJU4JORXOrg7C1xLhxFzm+s0CERT505rW62 +LDoDYCFYlefl4IGIjjYG0YeBH5EXOy++6GKeP1tL7BWtmk7HUrXaJuzFv3FtWOe8 +2n9BuwQvChtCo0qwXe5JInFnT10lommciwUw5QrW8O7elP+wnvTkjaK0q325Q1QN +jJzXlpGEmkRjJJXV8KwCduQWNq9TgZhdriLqgCZLOy7UzYayNOyGT+X5IZeYrMZj +YQteicwS77jWHImV2XD+a4kCHAQSAQgABgUCVACxjAAKCRBPrXp1OEVZ22DxD/0V +Rc40ZorXy2JYLkvs2XeBfUWAYX3A5YiyRG2XFypcHxnyDENsmcxKanHrSrIPM8rt +28Az/CeXMZzZXPWC1haOIpzcqJBJP9zLN1RKwkvXhjDEWQySQUtcueXaP/ysFGE7 +oMYV87/NA4A8OiguX3D9JQZ23GMQWPx4HSzwMyR2A2qfOHEnlNBpL25RqgMG8ac/ +32vsM2PUTDSLCIecjyo6/2zvEsftbTbeaVQ7a4vdnnD+x4NPA280+O7JloXq77JI +cj2YsrMEBAeaBC+e9XtvesjZeaJtIFLrnMPOD3/02RTAFZ8mSXezSCdcnS+V0/ak +SjB3yryYYMt2uUHQPiVm3lkDsibjVWgzomfi7AJLAYIr1IgqqlCtuYOs6B5MNgHj +zIO8R2GYmN8MnjDiLaQ/6LzXAERhAOQBgRYIisq4+bg/gpgq1RpNO1WR1VLwkmzH +epEnYD3404G+4W9UQmzY5+xgwMfC4t/GYXqSh02ijy1DhFZdGnvgIqahzegyeZfY +Rdf7/hQ50FD3gguYpjZbdcL5Gq9RSrmY2uOYdluL9H3/hNEMoq9HqK2ZQIpZGIT5 +C2BDiINBrjyAz3W6TIIOp6n2MpTm+PMDBrUXxrA3vfdZMbNxGY8mUBkKLz7rRImL +f8eNqzSeSXOun/Qkyu0r7iNq8EOuK5pKovxx7yOU74kCHAQTAQgABgUCVDGO/QAK +CRCIe2BhizwWrvJ+EACKJ+kZyCOqoTDdHTPyHB4cu8YDbtLpkp+tzLZKQEco5oO8 +HL81fkvhMN7OM+r5z+VoGDxjZ35qdOuCMgDvT60cFhLhzxCo7etNSmDkVKa5GNyI +VmzI5S6uGslYevpPiUzME1Oz/Vkt6Yyww4y8/qInlXbKSzPdDNF97p8dbAF+6Zp7 +UC+txJzi3P3ackT9mDFBrP1FkDaWNPUKH7JV3Ul0I0zv4Gc38HckrYUS/TLe+YST +Ci3qCD1zfxbEYQ59maKuOA6vbu1EGzfNDCuEu2TR9+lkS3BLVbZ9VK59KAcjh7wE +Hawiejhnm50WCAGiSf6JNrMQY36y+hL7T9AxWlwUjHMR6J2EQmfF6lD1fzBRgLNX +9utRilX5bAlLa8MDOwuu3TlByX+4FvNYvQrpRS/a34HRFoIk1UkBngFbZ2+golpN +lggzspc0OFLOGVvKUc7Xtfz2XUIZ/7HZi+3qE5ybcP2twcADgl7BippqRJLyndfK +i8ZYWNg2zuaEXBWMpQP82JMl1NqzGucB18j/pnhpvCP7gK1H+1FqCCgtedx5FLzo +uyCGIo2WCMTtvuOrLcyCrrmNxiXVbpXqvjBgXIOd8/XdvR5cnF7aCGr/ko65YXfG +WGm8QOrO5UwWdpJVqHW/uwd1DDKhKyGTI6cYOmoXG4iBwdt8PrUlTOHbfCwvV4kB +HAQSAQIABgUCVNBO/wAKCRCU6S35KqpcO3d/B/4v51kXn/Ukzs8vrc8C7dQvoPnE +6LCRjt0QarmNUU2j+iBSqmsBSKMdJAZ69WnxoMJu2EXXWvxylp33FYddRvGSm992 +xCCTUDag4E82MsAwtoWaVmUq/P1CnVAwDIR1Qm+u8GyESaaxaSWLx2nIlzT4f/5p +ML0td+WchxgPHZrcXWHlL8nM4//JhHMOXZngZ5W+CuuspY8XYhdfqJ+VT01tNcke +5moAnqZEg03itwbFvMjfMyCisa7wog3tAIHzFPyC4b0UJj/VLdkuUnqxeLLW2rwL +Tn+WePlaWRqXz1VI/OxpCbDMVtvo/xT19M1PtFDjjTyAhePv2DHcbDqXICRiiQIc +BBABAgAGBQJUxjAEAAoJEMOOgWCheEH+gjYP/j8a4U9HOunm85RT0Gab4xd820BW +X6eza79xPAuF3EdhwVvscv7Np1vYlAfucplQdQiCJtuxZT6UtWToOd0frqzr2KkQ +2bGBlqgK05XOWBwWuJd5dHTCIlawm0GokILu3aHf3ib8j/5MqE+aHcz22MdfeJMu +ActoagtJ8vENqLmwImrvqpcRH3aZ75YPj6XoSb8Ax+vp+ZMTOn1pll2/R8Gxv/ml +LaNi3llY4G4HwySV2j5cC2opJww8nd2/ULcF5YhaGvMlWgJk9fcRLOYir28xtqP6 +kulAvLUd4Py4AbMPHRLqPRTfWpxOxzOE5T+m5+pdWJiutClWo+wo0ydhkTJ6yLzz +kZ69BLITD/KY2aDagRikTEf++ML3CJmQH+DrunE2BVdpqgRuK7Jjw1cQuzL56Qzd +Ee4s+L2rIkb4MPcZkIe6LKAKzWxMhEI/wI0PHkYcQgHM/UWH7VBZaU5bP5jqDWMD +qDoHpF3IuNf+LOvKDuf39qp9qPMRjq91d2dRee2+Zejr28eIrJ7IRRjHfQmFhO3h +o4pXO/oiPfauWwF5DLFXbLyI5YO8DCuVPOP6+/arY6Vkb03g+S8nHcq7q6cUHrct +piLCb2MGQ2XAbXOz6IyH6+MNAPwpRJlN9L3oPBlaZOqWt2HHiCYHtj+/FuPdli0Z +QJ0Taw0eZgir3ZMZiQIcBBABAgAGBQJVgDI2AAoJEFeTDasLhrBnuNYP/0pg0txg +dCeo6e4etoX2OX7Y9eHTpQuSdTwR0LHLV2dODE3tdx4a/Dno8X69VsyA4PJNZH7h +aEppXO1ocBqiAn3G/bXJxqlfniHnvXQByl8nXKGqs9JJIuUnUTLglIxPhqn8VVPC +skpTZNM43YRszfZ/C8pmJP6wLLRSpNtFqXnwN2UybFOgyk5LoCvChIRz4itYe/G3 +zpsNxgE3vtNfZGi8oJcLXf64i+eJw2hsvTSALFk5nRXl28TG20m1zN+wzHPxSL62 +WlRyo64m5sXpIompV9By8e7xh5mx8VQyAHKdNZ2NossCDh4ruP+xquDT8Nzp4fdV +H+1ak79JE39ZKFdMyqOFE54YaC2STAg1EFkaGx596hK1LmqJc3hfoJwGUl/jafEE +/BRUsBClpm5SG2MQqBYvL1ToJRqcMo9s3dYPOyq4Rr2DcmL2ztqbVd3KJXFpzCsQ +X/nZ3xSRJa9kRWkj+MydVRkRSrPJfoOY/KxhrMPtFNpeJfXl03zE7/wal9v4RSf2 +mrbr1xRdYAfIaSYnawlP3XMlM4E0EZKsM9Abkjhc1x/tadiu5T3t5skr9D2T4lsc +256zF/LSZauavMOhXNV+Uxp/iHZF9h7Sck/hwtvP827GJq58gBOhO+51T5k5cTrd +7wCq49gkSKXzsD1Un2YG6F/hVXiec65Doj8riQIcBBABCAAGBQJUkJzSAAoJELjl +CHdmR1qvaWUP/3R8qnAmg3f2KfUz2vdDh2nZ8/A3klmNyeOMsQ3+TV9OQcGuLtly +6rF7SALcWIjVtm2HDpxFdjQ1T05cufZkzulsNgEZ3wd0rJqRqFLXAQUXWauDBWAc +8f33WUSW2tUQ/HYCqMF4N4wVesoLasK4ZPWm63ztOBZ59t3n62mNuoyP//HyZzqm +kF5SaiXgSa+Q1FY0DzAAh3bncFk1h+rPycLDb6JyrrR5ppBOGeO2mIaL6OWaXVOU +HCxwDPZ+F/x1bMuPC0Ul7skJ5IGYF/q5L3nY0BkHJ7qpuOn77HsWRl+OwdzGJM2z ++XQZNI5qrQUqKLb3d4aMGd2fHwY5KeweV5bKV30qZS5Sf8ZvuntZWf7CLxreY62x +MEo1Sz/E+f/U3lI85icl1JB+gBrL5z3o9T5mpD3tfwTMPcsLOLFsrqTDbgSLruFr +9IequVcrVvZYQWlLOut3mrZ6Pyv0bxhuixGLkSquAafmjSpHB0SXL52MpI4Pz/db +trUqim27XPw0gSe8utH33HkDGmGWvcYW4ztIbsVvMKewwqHPK1hWrbfSFJALJJVw +Pavc+bHZ6/T8k5O5wFBKglUBnaw7rJTLIUqAXkwilWmuS29TmCaokkuo43Sr71Yp +THEFFiLpTVXtY4ua6694IbA6t3IwMUEN2t3IWrshn0n57YkPZIEIcOOkiQIcBBAB +CAAGBQJUtIYsAAoJEFBB8YkfROCQeScQAJagq5IJTd2i2WqrVro95Tbcbm1TITfZ +feUYisJCshUFqkZjSeWAi2LPReMPuyJ4pHuYn1PKOuzmuJPpw+wG8mu4IX4z/rmL +p1KQ8UWp23m8sVXVcrI0FKcQUjDJtwqJap9qfN1+j5hmOOj55Ryetlq1mTmW0/aO +ILPY4SHfzg3I0i34gLtiNB4TrM0kjupoWG2ppF2FsGeAimImZsTrlbs6IipnVzMg +BgQeZuQ1b7tp9U4r/SktfLjfqEUftJ4YCs3eW1GXnuSmT06anK9dbX7HJFBvwUxB +chpESMHFAwO/ulqRTLwmU6EoDKlCGfchc4/GeB+oikts2co12pJZ8cRyRRinMrVS +Dp42ddxC5XMpOZ8elVAxzBE2AioyGMuIiVsnujFe8Ehhf7vja/wWooLmmQa6MKkZ +2xte68cjVCqfZ8M6zgT4zoTse4uxUKx1VYKAqypczVIPMuHerY7FbNy88hqQ+yOm +r2W7fE5OfVD9menCH3+jxbEMJenVl8DdCrJ9Pom1+BLROQ2m1SfZGXJhUTYGoCc3 +BPh9VRNp8u4XbCZGTAyPLzdGxVQXBvEXKAZ0UQLX1x75WnmOuLwYqmzjQ2qmamFu +aVOpTTxkbA90gKbsjtdYLu/vqj8XSKao/JGcfJGEGJVQ3TwX0DlQqzJGueou0DTu +atB7sFcqsZjIiQIcBBMBCAAGBQJVNs0/AAoJEMeIxMHUVQ1FA4AQAMuD0iOZUBQh +o281VKY7uS/EFuNM7qtXR6N/aBiyQsRPaxEILqvhZRb/vtxTZ/6D9kCrSF/k8KDL +Ra/Ir8yfG03siVp0iPWK4s8UBPqBRACHYm3fxiiycFaXciL0UUC0m4ZrIE30WiNX +ff5AEn5rG4U/m299+jiboMotFGm9SrLhciJNmn+RET28n2azVXJYzr757ERO71zt +32AApGo35/3EvtkD5E0w/DohWJETV7j+yCt9ElL1YjvK+tPOSaWChi68S/LWKOl1 +Nuu2uZPxXrXGsaoREH7vHP2KeKp58fbkjVcvNke50725aNtjS24PRAyQ0SHEA2K5 +pQX1IhWZN725HHy1sPk3fK+2IVc3PXKumtk01F3B1hYWLUFiKKL5uYGHKGP5LYDQ +mUWoB3UJzUuqZAW2d/UFodURvthBz+GDmGhbp1JtA+YkSnrtHpaR4aNj3KEoR7cY +qeIL6R3frpUeNtMcXLMWGzD64OsMWZJJXUJRAd3Xmtprx2quKknmGkbnp7cL8BGa +jQmzUUiokNTHzkRgdfrDXBw1QXFKpWLTtKBjlUyx7+p/beRYm8RWkWKMlciLcFai +oWaHwFFtYFhgu9ofXrE9nBNBHInUZOdFB1O/ZYGi7BF2zOLZI1Ul7I5gdJThAH7C +q5vqKFZc8rloXp2VzPEt5Zs8YoRK09qCiQIcBBABCgAGBQJXW5i9AAoJEC00fqaq +ZUIdufwQAMzES7s1Rb4hdrlG8ZsijcRuhffMmWQRcbSpyYbmrrNkdTEpoYlLKu+k +g8om4EmCb+Dtr0nl2BETfL2wJ1CAbkMoXkhqu8csoid019E0xVzMunH395nJCxUC +fRbEl5UwOhLDo8AxFiSG8miJkK0XMjGmtqjNjyhFl5L+OU6aPexgxyoTYQq4BiJ9 +1BNDMibdTxZoP4KqI9rf0fd8dMW+XxlbL6MaVABKxBQRjhPG9YGYqQVe01D8d5Vl +1KnwlfZqXwy5gzGbAEGvilfN7Adrbx9HiN/m/A3lwIB6U7sCvJ2+Y+clqWMJspQF +vQvPuWeXF0CGf9v9XtV53JAna67VNCSq2Xb7h9SKgCA9Y7lG0vyJmn8/MCBOCWSt +quEu3PmS86mZJxwjrUsJ76QblGgUnLMrkjwUE8xifz+416R3QpUUPqGX2x5zpTUP +5LH0TFHJCCIiQtzp/4RJEovkxRrMK2fYBlwWUBtAq2xx8lH5p9qLcQ646x40thYT +dLTUxUg2qq2vTRK/FkeZlj96IkUcfGR+H47zi1Rr0Oia5NBKu7c+buJxsWXYk7Wx +AFJoTxRJirmKMzxh07gMxtR4vgE3x/QVlwFI+LYClXUwF094kTU6jnrnF2A/4czm +K7e2FyghIS43HygNddvMIK2uTcRZSQ0f0GhAn8Mo/ZPYEMqQv0MeiQIbBBABCgAG +BQJXI35yAAoJEIdWjxVizVEyACcP9R0ibs+M23sizaIRbJYCYX4EIz0zrpD50Diw +FfHHjnfNjXC1MuUNtiLVrVq/pKM6o7M/O23ywJ5ZjKULYjOeK4rH6kcKUhwlzPwG +GYnmjx82z4Qci4s3Zt9ueMDSBcWyHhxyORcoel1+1jOUbprRu+rng5qR7KCw2unA +sFw3eC4bcKclm3saiQ1E09GAG3kwEGWJM7gDR12vnHuAAJAyt9r1RY/atxYBDts3 +1FjBi881tu4QoMpLR1uPV65/nQvModCLBeeLpxW4wVj0d+Lpyrw7o2C/4jtd+hX4 +nP6IF/A7R7dWcdaWvPwnXGuD7w8PgvGKsdfFGPL2Qpo84aDgg/E71pvymuCmvyFQ +AArdhPE0EvnUyjMdDTRpGqzyPTbIJQpH5hfhLJCNx2ikLKJ5riPIq+xLwkjWkPh+ +rjUVjHgU1sm3vvePtYz/T/0hHQ7NO5D3scy+ZjjKZfYBYErYEQYibTgi8g+N1uTN +PED6hqJT+iJ85AjbDbDcYQULjQdxNK9E8uRL2FttVqq2tU2MkGoLc3I4C7Y37JN+ +C1qUse0dWuhTqsnXlKAmenhLGxmgfz7cm4ihBoFLhFl41FIAwfAjtFmGrLCr3pls +SbwtABlQLVrMbRcZCLcwKhbG591rsXVSsGveXAJKuEjOTDHXUuaBTp38CJoy9vIh +1iD6LkuJAhwEEAECAAYFAlbfBOEACgkQNSxnILHjuStINg//YcX90PTahJnRn/O+ +AGKStMcpCb9CmBcfTpsJejCF+uPB/GBzOxv1aZ1CttV29/Gvyh6ia5YsT2LhAVs4 +4xN0qTp3z7TcMB5GvOEo+pPPFgSKCyCi3BnzuPq6QR7vY6SOvUo8m5Q0g763sTl0 +WjJUgNaq//Jg47QUjxtNQo+DMOARmLQO9PlURPSHKq5+vz2PatSPRJJ2sZs9B94J +mnK7qR3kBdsNrtR09hYbMtjuo36gsSPBwb4ujt4bY4L4DkKVZM328z/geQpT3455 +2Qgab89He7uBhV2itLroW4E6s/XH5O8/VDBmDPv1Oo5d83SE5bH0fLxKel+8ioJh +9F5//V4+3oy9SQjsiiUJlDXwdmeLNZ/YJbKOkjVQQa5WCu356LVfuzkOu5EAvnLB +iDsYnw0VVQru654JPxR4b9XJiPFV6rF6e9HXZT4m6cJo6ueBk1YEBSnpDJ/00Pxb +BWPwrlgKR3yeKQHmoaOn5/arXF9xP/RGNsmYuW+PDwqlCsC6k0YZf3YaRyB/OVde +czB5qbooXPgXx/uA0752hQduCO2FZkJtnmK1Uzg9LT2gOiYofpZNr8YykLVTb5R6 +hynYVqkO4x/PxYvUtjiJoJToR+NlJpv635wGHwdMCWfPTE0FUhduzYuSujEWLEMT +gL6ETDDcShIql7wgeTXRB9GilDSJAhwEEAEIAAYFAldTGc0ACgkQCUsJ0J3VNG3D +/g/+OwNlVTS2lqZMkgw8A5GYJXzHnCJM2DeLjCZJVX4jtK87ahtLPx+NSRyHvB29 +YjUoBNzWcCTnnRDBa7jxzn4GIR/6sfF993UbX7AwfrZoCdewpvmZ/lYIgUTci7ad +XXj8I2l/hXQ8GilhYz9oamU6wH4+lhw6Lg1dd/z2Xivtpb3jgzi9JqL1XdzClK+K +hYLI0cDfsIlWoJ7qpEWfzUl1VbRo8f/+rn6EPDmsUD8BKOYYhoQz8UNnfBbfFY+7 +xlbmiF5ILDVy8s5VLYvS/JXicdmR6bbQDJi9ELeNmmVqUevQdM41ek2DxYbpbf1c +2tCiqGHQOW9HacyitUWmBmmtRfkP5htLvROOdtOm+mh+fa9UR/CHfcPLUN0epn3D +iLCl4ZAGiSx0FsopXH9p/rEqk5gli0nM3UNrY9cxN1OCKP4AVYrhr3YY/Fz80zav +rAn+hejCtJ35bLK52liKfg8MFzWX0f/vIyGiYs3EIRaP94mIDfPtB/AghfBlYJX1 +f3mSbpbPQmT88wQj4QheZsu2UnU9wQChUC4byArbvz+BCHltvaEizJe5cjQ3hHD1 +7I6X6xbVGUdFWrmNSnxA8cj5YOjuvw5K/n7jBIXIjLmI5b1+dreu1uAAXYHsk77E +gLkZXv71JDBqQNBlystwjk+SPy/F8EynixxMXdyHy2XRHmyJAhwEEAEIAAYFAldT +Gs0ACgkQwA++LZIZJ4jXHw/+P2BqXoHDy0Zb1gwdJ7XjGPlCSximGP8UKzbdCquq +jGHSRLcJimQ4i55YrVH2/o2jD1pWPIOpk6ELNDDtO8EQsqxSR4LjfWQVpnDvu4j3 +ROVmUG7B4FFLWpWg+H5BquKtOx68FOJK5xKm8WhPDUylvDDKON/spNk/QTsnFKt5 +IRWIbCvCXJHN5ygfUMA2lj9+I/Jz8zuArZ3NwDx6jinCmiEz96fEFjGa1iSWPM8w +1uidBCGOvEIETs6eIa11LxyryJ8OcHRJe7VbKDixSNWWMk00tmEz4vdnzVkpYqP2 +rsf57ht5wqAHjTkMbzaEgpg5LjuYIBSXfSiwAtiSLieQlH1I5OJyObb6325t3spS +gW4tYlaOZ/h/B2+oA+1knb2qFA6fcGBNlt84OnZgQScGD61iJpLF+yYkoQfSDi0L +GdNCBlsfDinF8fYHi0snzZ9wU2G22L0EcoN1ZiYlFJi0t1MmQuQAHD2HXSmoaOGK +JG6yb0ne7S03d2aXD6O4b5ftSbYLR5eOaeTXpDAJ144DxldRKuzIETVaXC2BitaY +RJ/wq2LtYvj5SJPrfNZkdNv2vdWkZs2vvgg4Ju44J4CVviGmVVRxvPFil6h6Wen3 +IOJRppJBbaRccHEODVfAhSmitGGqI3l8k2eA+iqaDFy1PNh6wHxG+P+pPROHCKpZ +wgWJARwEEAEIAAYFAleBHq4ACgkQt4uQjyNDD4Brygf/euj2vcS+rauDVP5jT80m +z695rjIv6Qd4Pj2ByZXM8WDILWTjFXN/Y0kRUGyRIN2Mpt6lZG+30f20okv0E1wv +ScGrqi95Zji248fj1pzWjriU5zrgSdUN5wrzaEMmg+O0z8qreaBiu/CX2bVkIstt ++aATE813ryJZyrs3SbQI3WgpFaWCNmG2IVqDDNSPKUaRljeu1f0Gb6NWiOjDQBct +A5elcckHP2xxyJYvQTrkYKlw4hLLY1lINNoJaAAxTwu+FHj/Ipt4PfQoofyN4mCx +WJztsPwKlzsB7ivKorahWBYc5fm67IljZ9ntp+HWPhOjYjeFmXmVHNTu/eu0tDJE +RokCHAQQAQIABgUCV9ZJdQAKCRACPAXiycBo8DShD/4lLpsGWZW2mAYFIgVbXx3p +2n6DYV9dDoUHV+lKGz57Rr6H4BhSK9ZnCRHWDD/PsJbHxyaP0D9TI3S5JJziAQov +YqQ0y9u1/mh0WBIJ0xDtE3HcXQT8O/D9G8aj1msnBrpCjelDeKiO+HeM6ESgxmKF +uenE9wLDwuKFa0A88QT622zpFJFOpgBnfSMEbnx09tiR6iqxp5ClUJOoJY2zA/PO +tBEROmTMT+9NdChbz7nf34E+IDqpSKhaYS88Ozzs0XE/+XPNZPIOZIDKLU3CQhaO +wxl8JgdTOE0NN0U3WixrnNftzte1LJhB+6byPKAlbOKYDOdFLZ2nJSPVU/rLzq+s +b7kV3iq2RTWcc/BwRL7cN8kfONe/30OPjsuq7o/QrPYHhQooQzRu/z2tIafoR+Tv +X4VfnUCEeBONtRJxma8fWT//YXlCKp5Yxaai0Ie3etlMamK1JnuwtUcaCHBcjzVa +P2N7UZz5Y/854lUZu4iJX4N5q6eG78TIfrB3u2EZGbs18aOuNzmwsELeCv0ulJkk +h4qKvDvuD4P0cREn1QgTGQqHxQAmagxCR2rAz3cHieytiKT+yHMx5QB+J7aYECwa +r8/jXoQtPdk0Yf/qj+PcpExya0ZyLan2C5slu36geEYfdkH53BVzlG3h557f2+pn +O4ZWcMHn3SVCeEkJGtoXKokCHAQQAQgABgUCV2lgywAKCRCLPYZ8gj56YT4NEADV +BaMB7ltcaf4Sq2CHL2Vjm+FQK/F+mTkzPpwOZd5NKa42Wz/ih6ceyNW/hnT21rAm +Lr4jQ7zMxXQ8Mvkf3IuYHJzIBRKGgM01WqrRpugtGXH+oPbOUdkd9wB1v1VCvzTa +2C9cOqZl3/Y9kINz0B5XoQktkjokhx6ArVDxZjk9OVwNfvRNjU1scchezJS0opDU +v6FZ9GQkke6CjHUArEWYdgmHJmp8M4YhxxVe0MuOnNZdP3Ndj4FXU+6axvJXArsr +d7Gl6iEJwJyyN1fIwCIYvbe9BMu33TFUdXNX3J3wgYf4QfMvZmZIxAd/kbmG3kVU +pvjH+Hn5/+5Rry8+WZJM1b81wyD1UBf7yUMq5SgcFgPpQ+vS67OkmsEuZnOxr7Ig +ITIcNAMgGP+N+/kxmAJfQpmGSGUXLpZo7OTBAbSDSo24yRWcNLr5H3F3RRrXgyvF +pQ6ulKq0c5vEuy0BioD6LmehCuHFUhiddDoX2+8hze25zKf8EwJY88VSpCyRjZDC +CcRX14TFrSA23QkpYE9m0dCMtsmvIljIlftkmXlzWLQYalaLgs4t8JT+Q/M+tDbu +BDema2sItgggnW9V0TTgsCMAmY6qP6ivvSgA7xVNeZHgWMA0m9cqXTFXmvyGbjOi +zx0QnGMSjct5gFZukmXtSu5/4NF7iREO1afLP7YZRIkCMwQQAQgAHRYhBGtJrLrc +9r0cogZnq81U/OPZZL77BQJZIvGeAAoJEM1U/OPZZL77oqQP/iK+h5NZPLvjlOXv +GNwJcGHFPg3O9Zr3UvngiwADOSSUpbLIJ33h1r3Tl8T1jfMr+/LfaP129KBZ+Swt +GAgVwvSSohGEvk6u+iCL132EIPdqBchxO8mvcxYcHlZIjaIlWh10jploW5nCmMR0 +M2bkoOUw0zw0mQZH3vJaMdWrSHhib/oFhe7aTNgW8FM1XqIBvgxK+fJ274bGVb9H +gN/DVj1RZktwauj4pUXXUKqIJILbOg0Hrk3cyVJQQb56FbHLFLeH8SiPrJzViF6E +PixEEWbdCW4cL+VYIROTlsVZy0XPNXED5FF0Mk2v3CQyUpajBIhLXOGxL39TTeh+ +qe09EI9YAxWP6+uVXgNsQBR6ujCBJd9u8jvBnP+kpi9g8jBH9BjeyDKfAN5mVB2g +PZOlwRy0zbIOzt4LMOIxcAjdwDOitFsY9wRbLun6saoTm51X5HNej5IvGzfA9gvx +3+29sTnLNsrED7i/CNSdmJqpHnJSx4PU4J7yf3TwOpCV6FtbaVtx7qkWI8gcatnV +H715MtUtopYOPtYD/RFVJQxaHVRpZsthitCN4iOGx8wL4l/ghPsbRncptDYrWJbr +2N/ZYwRfti3YMEW86/JSJDHOvYy5+vtWFSn0FkrOAVQjqO/0dxB3WCux0t09L50u +Q3lI9+PhHw0V4+hc77OMU/xoAqm/tC5CYXJyeSBBLiBXYXJzYXcgKEdOVSBNYWls +bWFuKSA8YmFycnlAbGlzdC5vcmc+iEYEEBECAAYFAkw85esACgkQjCTRYI8GidRv +twCfZRhhhngwZiIl1+n5r/0n1955tCoAnj/YcuCos5M5d8UDHwlkO5uVFDsuiEYE +EBECAAYFAkyzexIACgkQVVuXXpU7hpPCMgCePO1awoyWKjBA6ZLsM3ldJh25/XQA +oN2oT/+xkTLPYxv3MCXeqRA59klbiEYEEBECAAYFAkzV7V8ACgkQHajaM93NaGpd +EwCfd+GTI2cNr2vsiD3fHqRvuAyD+FsAnA4SJz8ZerCNhSQldTc+v5N/JIEEiF4E +EBEIAAYFAktXYt0ACgkQ+u8Sk23T4+y76AD+J1eMUWab+oZipZK0TjerVV9SN1fR +eHKHi4TOne9zsE0A/Rwia9Yf7kAy3kK4y1OOWl0lfoEeG3e6gNP6AHhRhcFuiQEc +BBABAgAGBQJN0WUoAAoJEKax8/DmtfWjs94H/i0lqjp1IV4EvhE5ignwjg932I81 +E7/ulIQXTj24hchR1T/112UOym6V6jN1TDaelE3pX1CQ7pcEEsBedKuMV/rwfM6d +msrwOYBqMWK1pxG7mO8eMLE8oUPTJkMGcqXRpBRE+3xeR3euxz3upjjXE3pHTKfx +UXnP6KaJXXAHeMxJ/D6LTDbjDgBckRipMmeAdILJpNxFSNpCiAOGUqng9MbgR/0p +NJrwOndd1T1gaR36QZpZc+LmCRAQqMtGx2EFKkOJ6bP8xbPe8foP4x/rygXKs675 +ygMn2lJxJ2XBsu1pz2Y2t7rhBeZ1TupbJFSryLHIvllTKArL3XSFvSCg4umJAhsE +EAECAAYFAk3NMikACgkQhlYfRSGA/P6nqQ/4g6hwO/BpPJqYjt9WgSobPbbdN88U +Ce06YJ+kdBPkioFaB0qtLHO98s/Kti0tp2oxn5UkOqcmDv8Auw0JfvFQpJ2uNiER +Xbg9eTRGdpj/nfJ44KggaNx0iejaWf2NFkzh3svhgRPpBQ/4vwQgh7zF+4OEBxkO +yWlql5rOS1FR2X4c/3UaS8dJ65V0A/qn7ow953NUV+blxtXUUDnc8Ni+RIOv9et9 +SDs5fNbkgq3jiiog9qLgTiFLlzlmjiaael5/Pq+3aOu4a+7e+IKZxm/6atvQrDEz +DI9uZv8CK+AZIZf21PMguPzkxlLiBoCpk5+UXYLq2bVUhw12ZUqwcsHoeda7A3RK +cQrD/9PTZj4ovp8WW7AJAtKSTb7FAd4eBalveKDJSIUb2KeXwfZXl2fClByF18DA +hnmicgImP90xBGqVKhavl5TtFblgjMDY78gfvwuvW6T2JwYDiZXHe1eqKiGDBRy0 +gyePGud4mMT76y328mvPQgi477Vk3rBifS0TjY7d25AvI+PnMMs7HoIduek/8X2o +YPlAEZXH4K6kDTw7IDOdX7EO5fUeWVTosaVzd1UMPh16Ug0JOf1SnIgWpoO8svr9 +8/af3pIlgOS1YYn7i5e3Ctz8AixsNFpaeWbQ7M17D+Q5gOuKF1vbdbIDpT7Kezcp +enXSPEJYxGWOVYkCHAQQAQIABgUCTczq6QAKCRC437cbX+y9ktXkD/9sQ3mHjex9 +KxJFTSElVO2fT4pBNFVUMI8+jBsHZ9pIwE1R6cfGt84fXfYZVSVUKNIsrBvb9i/Z +APRiPKHkRoFVSiJqEKgHEnGTykrM/AbZxqbV4D9In4LXGIWMSy/l04TqevYdIv7R +hdyExP8tFMTdMWbx5sfjF8ljI7HOutGN80anhMhcJ9PlIcR0becR9r0in90K2/df +HHF26tjh+INL6lSAn8ic18go9AYz8919ZxXbqyu7YQmrHzyXzJm4eST4lDNITa7m +cX4hj9nyW7hN4c+izFcgsSXQsbS17GG1K8VyHj6cD5o6I8zUUlvjVSEov2V50UhQ +QKvp7huNIautlcDvFokxwE/8TgY4yIm2NUT+FMPGR4169m29vaY5of/g5Vb63fHA +9x+XuzhLiSMMSMS/LbfN1pj4wIKix8DyJHjN5w7jeNvIt9v89ThMFSfG64Tq+zzM +iPty3DCGZu0GxxUJO6ityACt8JVdb0i8p6IiylLtzzLDFPQitSkcpCn6ImboJOdY +W4ET2TnuEgPMivQ1hkhSVPrfzIsRqqy6aYaNGGh1ePz4PRhOAcr1Ku6hq1qyK6Hl +zL1wD8XrPeyT9RpH8eA9O4ZLbvXCgMzZWVia6bb0Lg9x6u8DYG5lJHbZPZk7WSMP +GRc3SEghp5i6teGPrBhCJEiTzbG9jCvC3okCHAQQAQIABgUCTczw3QAKCRDhlwEm +drm3OaXxD/0crFZFF+Xq5bDi+HkIpYqHuH4OwRo0GVIfp0EDoX5xV5aRv+XRrmpw +5YDV4+Qmr5CAnlZeLS0YZLfL5RWbplnzvt7uDhRDws0ZDVnmQVadqDdp+FOHcS/a +UPSlRLkoJQlDj2UXc15gj33aqQd0amKj32iy6Jh6AOufpTs3QZUa8+Avhb+FhNP7 +Ryf9+k8XWKE53VR5WJw+TSbGQ/Q0o29v+PR5w7rXV5dsXA3p03DcycS3Q84RwCGI +rSwvogI6jXxElKPWlexLOoGXBlkUJHjTGEr097FmPVa2twBKUfCYoJKvID9XoIqW +CvsSMt4Ug3VYZrC+9tDuOIhHhk87eKjGnaeSTQC7vTM1M9jS0ddlyIB0Zr562E3o +zEKBuwnxwz1JIVN2u5FqzE2Hg04jKqkD6AlkGYSNQzPkJB0J5tTVImDZhdSQtHxJ +O/7QXBbyaCuAN4zm1XawIHVBH7fyTugBxKMj6EkDAHdtT+b/TxaKaSWJz3MlCE7y +ei/caF3vdFjnHVtAqG+V/IZfLHNTVPEX1J7I1E5t0nwk7ivO37N0dXzCmVMQ/hK1 +V00UslGNsPnameq54KaebmweprXeeNaFVQGFcfYu/XnNpOQAeRdYbq7/TOwHGhUE +zkbXUOHXyAY6c88Cax/okH7psOEBAAQfk6uaSQPQXnCofmV0NPcg44kCHAQQAQIA +BgUCTc1dfAAKCRBF136eMMsbERJ0D/9M2u8hvU2zZ1mWrHYAcYht85YlCgXkkW8U +Fa5s1cQ+05aS6EMNk7+LTZy9oCDc6jG6X8Ausp3eJdJagHC9FUfqBjrG2oBOlyhh +ZAoyGDVbg7uRGg1GMc6wf23apg1YyAPRo5LfAaewRygY3fTbN27NMAiRWw5HGmge +oelMqGOqAAhDqg+3z4UzKmAoFx6wvTuQyoanc7gqRjWA0jjrUbh8y+7y6hEFH04m +g7xRWredllhqj+LO5AfEVMOeancb5hAYMVOQIWESK1YL66nb/ksW/++B10kGIf96 +UDbgEio15MAtPzLw5CjNSKAZkX64CdFyPkgr+YLHtHhjAve1ga7jX3KTSAMumsXG +Sbqwig0KcyihmqoTvbVAp1RD9py9gosjlUKJNYvnl0byMnQUK/oUxzfJRJR7xuTt +BDE1HoZAujbApuKH0u3H8TycyK4P+lL9Ymsz29RJHSVnUop8T6R1RREixVsOSTpD +hanXDS4zfqjOYEzgzKQChZ3IpzAAJXhIfi6sHq9IrRqAqF7jJMVHWJnWGyL1VPI0 ++ZwDfWmgo7IRsubF8AOR0VL+gVim6K5RRUvVeOP/C3XwrWc3RFSl68tl+Q4R02v4 ++oQ/mxlO1dGPk4nHLhE9AEK7Nr/c7vbHEKoMa1IbKWg/lgg5WIW0z3yIToEzNAJQ +pix5O2MIHokCHAQQAQIABgUCTc7/AQAKCRBgBCahGPX7ztAoD/9Y0/H21qQ0XJNn +S8W1wbPUOVTM5IBzaCJDTi287utrnxgLIYhOxByvxXlEgAvxbkvUwso66rJNEHow +P33YbFEc4Z0UBVqSX3YciEaG9lcp6682bMCuLHlDg+ZwDfPqw/CThfGh90Javlbr +YU/wcIcp5/cEKikPKRjXE2CBHWFJ9TZTXECVG+sIhhMA8YHQhxT/ih22iW+jNLzT +Ott8RZgnkGN+G+jfij5f6bnf8h0L91Wtjqymb2IhHTQI7oE616mNAxs2QWI2vJJ0 +pM4citup6aa6o61Q4Pv2EdV6hMwWTu+lkzrPEDEAXEIcVAVlyujqRKL/wNQBgJqb +fmrPidkmN3LtHq1rjx49WmvP/L+NBaGrTZcKr/FLmSj7IAJXPdMFa8qoHS/v84dF +m/3WxG/0ESXewcJREI8UNvzWm9IP4G+U5D7Hm0mrJ094Oc46C2Xe5wWrC1XdYh2d +vBbs5DqKdfeVKwxSBTe0ZYUHXGTkRAB+ONvRFE2QSSwevuU5abjBgii0wZPVmJYm +K77W2S3QlpsLEJqGBION+wDvPU5CQZz4KxQ7D7NPHKK2NIufn0HO1Yl2pY4LLd1i +fKzHk3dBQ7jmutkkbf8vupOxdwvtlryw8Y7RFeLwc2Tt+Z5ZQWAcQxM1jShwCU4M +aWOvDW9zTSfYqaXAaj/E+/tV+xvOoIkCHAQQAQIABgUCTdF1AAAKCRDGOJdNZHkt +Z4E6D/90NmJcn/gJPxR6nn6vgFwaoPyMwoIXrmqcMoZkrv3YoDEWBfvZlVJS7tVL +XSyYlCtKbqCbhX5jPtMxiUFQ918YL7l7hmQbjyQywSoQ2MnMqPaR6mQg67clvwv8 +PnJWD22R3HBNkBhbBj4kT9sW1CGxLMlU0aAFjJ01jhz/btiB+fYe6etu2pGW0+nB +/roFJbc1ngizZMd9Fl9g/qtKEbEQLTLgr3RBlLPpkeGVNIAJxfrZSv4GLqnjOaQK +gsWI+xW+2t+QbrcZLkQSm8FmrrqDoKsaCqtE2tYtS2X05VYpk3Je9fpJrvdv+GOh +T6bndP9RXDYFG3GeY8EvJDemdGLsGFrmssjkLm0Kkjo7CzyhcsguBWpRtbJrvPxj +Xvt6er3atr0K939BE+5j7gGRbFEFFcQmvK1f/EjAzGmvmou/qzt8vKWgUMaraO7g +lKM8BvRlon5y2Ck9GESQIQBJe97aHA3oG/ExiNdvOxTviLxcAKZf8eLAMJ90efZI +uxHYupGQ8CYaWGYQFVt23tbwN0YbJuXtUzQNzJMC0pYtq/cadsbLuQJ/Hr0hZKFL +b+W+8BEuQO/ysx0w2xuXpleJsjJfHbKgZtJnaVSaMvejteVhlBlXW0T3JXQ+78qf +e/mEQZ7BecoVA+QzAPuOnWnKGU5a58+b/EkVu3m4z5mvdSoee4kCHAQQAQIABgUC +TdHmnQAKCRDBJjPh7gGMk8FVD/9OhxhEnmcE/2+VUAIpkwfzd/1rlRmb+K9Tn5oq +jB36JymBOsR0ewWWava7oXpI7JoHEr1nCoTDHYDptc4Y49z636FiUQj+FZm7Sbj4 +/Jrb9x320QE+ODZAxId5lzZD+fQlp+TOJtZIPxznaDNywkS7Lvldo8hA77fTHyZa +K1oAnpPqgMrYVaBMG/se/cmtpjYXojDH9AwiQOLlg89Kb2IhjB8oCZVzGBb0XwyK ++9mp4HlGJ2rc5jEAV9FdV+J4JxRkEGhYpDRxPQ/BCDw4lzZy7HpMk3H8pPAVYf3l +5ItQWhU2J2/cZwxDHqZypcIgHGRJVS1Kbu1nJG8DqZ+Kev9Fv6SWi8tmgfQLm9pt +TjxImu+IJF/MIJ94u0BX409HlgyOPgye5crNpdO2kX8Sl6vIJFgRpMeReHl5pJtb +VCBZA/Ea4YH7raulqxHPi0IGwXmxTAye0Rbg1yqvO9PIqGVu5NDrXJvldK4ihQG2 +0ZOkag3e53mtxBrJFwRVr1+hgowIIGFEsbl+OoWmbfqIrkLVfqW7aKLlfQCn6wIF +fHV/+s7KKGfW/AOADpDYp8OPezV4R7bK3Ewi21vcespsA2RfpKHeBWunonOWOMbQ +Pu7u7ES5ZuapMtiB6OfKrBDBr2ZbCzrAx96bS3YRC9HSTptqRMZqJgg4WoHkOAOa +hkHntokCHAQQAQIABgUCTdQQpwAKCRDjUtXFHFBB1NJYD/9xemxLxWSh9doOKD24 ++hgkmhJ9A7lmmreW6eGyMzqWQvK4K+JQfBSfKhn0cGvpypigpyisKwdnRwcshAJi +WkA7iv5wT9Ix5lu+Fq0svUCW1eHOwTQmfFXjq7MH5W4TVGj7EjrDFzLeP5XzY2J+ +NNUu0laBB9ACzlWktQPzZ2jAAfcX4ZnL4rR36N0R0YYM9Y4touctTVAYMf/mgPbW +cE2ikqhlSpApKRtV82ekksaU7AKEm3e3hHdU2SZ1BRdRnomi73TmGVaF/Gg+SeNS +IYiwt6CjdjKmp1uWKkBxEo4ke0cjg0s4wM6cYIOxKCmFZIQEduQBVW1FRCC3CHgL +SsS5jSUe3OSADjklLk2bmAjXojK9FAUg8y88QIk7YBqqfhQ57gXe5t3OsISlGxjk +ixl/C+/KQcoLKHY0rqV3anFXbR2Xitd3Zz3+jZ46VuVf1dNJgyE6ijXFXEG+oBhH +RJansBD+f113CQA9+/qV5XqelFwsWPeTMB+M/e0Je5EV7MRT2bs7dSxKfrsGrpYl +bXbxarn74fy7km0tMgilIbaLPNqKodQjKD6nzDSiwEmS2zo+44JqLmETcMcoeFZO +3m35EuDOvPm8TZeGN6DvTxsak/gV8qpSwQ1KNskE4waD5fIhUJyh+HXbq5+fZ/dm +nVE7mhmz+QaN6I5CnbGSS7du2YkCHAQQAQgABgUCTMrV8gAKCRCcMVA8bYZjls61 +D/9+1V2dCf9GW0HwcWhmiiucNCQUqSb2hxJTzofnFSI8OKFe0MyP9MP3LsCA/KXS +7i+//ZWzDB8MWHgo8kFUL0Qlf0lds7b1bhwi6DOIWz3Owl9MGBvox7bBlyaRtb6G +hpC1bogBaUsgB/8NJ8h3AFIoCgUc4d+yLefd9e0vwrQMghD8ixgbzsuaWov8rL1Q +rQBL+h1c/lczsu9uxahk7y1Da/5KENB9QZfHglwJELDJu5bQkhol/aXg+ZA0eRXL +yygTfSWlw0jea4qSLHoopAg6s1Sbro++rWSgTinN8v3DxSTvpZHcGf7kRrKpc45g +RhCpVRpebhsiNSliCa+Tzv3LRf9qO73w/0AEwnQ+/jUb0Y2r3vVd1YDImOnAit2Y +iPwqASm/a9ALFOelzpU1eDAsR4LpPDGcsYxYREGRk+kHpkg8cDe7fdJmRdpXa7na +hv0G0oo7xetxq72hZyyaFYvpLaoeUFon/sgAvXUMI9Qz+V/hU35mXPBZ3uIMdZnT +xyhlYvqEMjIjI84jRd3Wam08euDCNTrxsrb61LNXaV5+KQXw1mkC2enA5zjjHAGQ +lYJlB6l+x/LM+7DCesjtvlbdO33N0R/THmUWYyAzFGsvFJ+S4ABhaUFw6Id4YrUx +Gz1pgpDFxEpDmeoZzUr9EHSz4bQH7vjbE0BrpEZYUkRFuIkCHAQQAQgABgUCTc0p +LwAKCRAYs/UP5ZI8GAhED/9QdpTSDB5ZQuI1Xj33ArkgDlKEPq1h500RSYFRZRpw +MuVpAyCn2wGWfzbjWvAAfxpjcj49q1aEAhyYcfThjB1Seo5JpVv5K9cPLJthgJsv +jsqkNH45YHnhnd1bqZjIgfssYYi1IJna3O0eN1DrQPLGPboP0KhlynDCqb0mFSm7 +OvLLmeHHeevIh2Yp39MmXzrE70x7FlUHJUWeT/KNE3dAl7r2qYYSkA8Mhfzv2LIZ +vModMiukL1Jootl4j/HL/Sg3E4rBW3OnYsRu+BliXoVgc94kH7s3QGu1dFeeGKYh +R/TVxvX0uRxukC1RrOdkgydcceqBAqkZvMjIf50+B7mRjaJ1Oh9bsUYBxTc0Tin4 +cQJtC9YhsvKU+pUg8aZtb6ApVBqeINeNQ3sEk7nF5JlVK3gOv0xIvzuJOd2E5V2W +HHK2RNeo3tni2ip++wQPoul8Kq4BHbPxIXzRwDKWBtKyRHYPXqek+FzNyEPepWHh +86MDgDbNZzb9YFO3zx6h7DHIS4zHRiWJchitQizSTpkuH69fFOxojQH5FaRNojiB +bkMTf3TAHR77huyalx1r0xghDieBcIhn8YM9Du8KzIS2pA1WO4a7dti8s4bMEkN9 +FjHy1lu0lCl+zcgHWbUD4XTyBEJL4XIQJupNkFdjWMXknTPuY/M8Ui74bHNqeq0T +ZYkCHAQQAQoABgUCTrK9GQAKCRCXMl3Y+f3VBj5CEACtskjl0ERATYOzzb+wXqOJ +JShONrrsGymjeZdiwG2e/6+WJtWvV/7dUBM8B8c4mcALu+8m3QpJL6l4gGkdMO/h +TXZLoPUUAjM7m4TUOvNrVcbSBkto2guGIbXrqx7AnbsWW6k1juJrsqYhEb7Dgd/V +VjkEJ112y0Em9HKMdijjpeE8oME9N4aKMIvY3pZQgdX3IJKbahWIJ549gfMvus5C +ldB2oWIQ4omAvqCPGvm14+Crjqch+j5ca//Cr6CWck/2wk0JvzPlqnFlcwF505BV +lDBq/+R7PYB6tayhwtfBVdE0UmrCTisLVTvSCk/4IRceche9/v+DN7zvEUCJpTR2 +xSTJWppPqzVCh50nyjiOKPqi5gM+5DHkaPVpPSXUKxl91lX6qRJbpnLAR8DLW9Mg +kvWfL3RAG5QdRLKfVQ1xErticSiNINiFGDM8dCtwhGMqDaiu8MIJhTPuvHVajrv6 +sq+Y7JZey5zgl2B4QEICqUGJBoaTiZW5Wjr9VdIm9yQ0M1H5bev4UrAdhoJYIZQ8 +SbIY0Af/d5XnN8jPtHY6ZzPcN+AFoO/T1CKkckvxyOvPYG0LKud5S/Riu+Qe1wyQ +ipcMWwBRDbO41lsnddfCTVdmmRVa9bR8beyeM5z8lio+Pf4oSOihllhu3c/gLXON +WU0h1TckGSmHSE2R09vd8IkCIAQQAQIACgUCUUe1TAMFAXgACgkQEl9cZ9/pQITq +Ow/9FUZcAAx6ilOmWsLKkq0CbZi4YUHv0WJJa3enoPDO+ZApJPa2B3k603f1U2Ns +4ysUHcg9Hj030Kqv1xEULzYfw4kzVON2KfDuTRkjuLfOPko4Pk96aYBC66UFDyas +2QPy6bUg47UHmDtdGGSAGIz5CAuWn1g6Q37JbYaVXRiMai5A9+XNU34l6NvfU8gq +lD6dTHFjKq4LML84f03ftoj/tOZoMVbzLIWkFzIIeQaz/sYjlyCPJRMsKHBhjyIO +RMEvPuDoXdgQvp3WqqqPJ/0xlO5OZPwmJoZpg//s6rBwTrqKGOpccj6TmtjSraBl +Mswd21DOfRUB0NenxeXmu6hp4+/+9a6ueYxLgAZhsXufmjvGOuVXPoRSqffZMco6 +cb2PTL7SUqvifzaOmjc0Hd1iCPEzhatP4PfO3UW6iHN0ADk8ukzWOzJxxbewzpdo +EQXubNc5tY+RctrTLoDL2wK9SEPvY28JnzrH/3nortKqmlL5Zho6qk9MWmVKfKOB +u7+ysGMailOQGD4leVW6XFlu2F6d9QU5NXdG6NtbLuFkbK36UhquVXt3ifNsOF35 +vnIIRHMsJMkofdXKhaqzywoe+lQN0bcmTPjDXPuDgcakVVOx3J3UlfAEqSUshdu5 +yKZrQkwXBNqUmWFG9nI1orROi0jJXzFlbHqC+IqM/qP0WTOJAjcEEwEIACEFAkoL +ejkCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQEm61Y6dLBr/1+RAAmm4e +tImIkh6xbuD9jZrffyiTlp8ZAdkVGH1mNEArIaSJd5c9U1545/vjPdTBCA31zI1d +n1TV4DwSCO/dTT3E2eSjCxiHfrTdLRYr8tsZSPnA1lMNlRNCBOV7rD7Dw1UOSybz +TL8Md3Yvln5ofUOtX3Wn53+idQQeXLG/BZMyg+JZC9i/3ymnuJEriZIcT5q6P453 +xBYf+OHFb7l0AgZqQ72vdAObWap6qx449Q7NqeqWMbVPdqX3nGg2Zo3QdoFRVZdV +DPqgprYJU8ncRG06sgnTgmGxpdo2mNiK7IdFPY/XLmw0WEB5iRS3wJDTRX9ma9fr +ZIfC+EzBkP2BAtqFFKWCeHCE+h8IKPJLic0vCphXwleAc3vJUz7OPtvMBXOm7Hki +imZMFRAkHxlinS9IfhnNXtMOL9pMnOGENCvBvQQMLFQ4Rzvh0owWXFYAoqj/teFf +EDOvP1K/MVhmJ3sUsqU1oAFLDVgT7Wd/AlxBvAlNP7x2IBxLNr2NEcl/z1WAWMPc +WQZYzbGO6LV1km0rUrA+w46Mt9rTtrzpl/1dd3Bli+gVFkWjfW0HgyfIGX4Rdgzm +URbWJqayDdkk5he2QPw2Jfc6VQ1Q86v4R8UsjhouES+UOFFr6bVoRx9SAPfswgqm +1e8RYAbT57v9c9XmvomwAfZiElswq55anL0JHt+IRgQQEQIABgUCUUd+HwAKCRCZ +zeqdpBNbOO6wAKChFegJnrd8u/tq9pyPzcdDD2tNOQCfTDuicOPE97cKAh0nL9Xt +y2iSuq2IRgQQEQgABgUCT60ktQAKCRD23TMCEPpM0Q7SAJ9vlEhATerwYp08QDnj +lGZuw22r3wCfYTPiEy5Bg0ajW5sn/6iD0jQaRJKITAQTEQIADAUCU1W+rgWDB4Yf +gAAKCRC8yx4nMXJi0oXOAJkBRogxRtT8DbIFjNniZQQkPEEtDgCfcicD9yDrC/tP +ZJKXf/Sb7Hf6rEqJAhwEEAECAAYFAlNJj34ACgkQBMNnwhit1P8qFg//ce9dnc3t +ygrXDBueBa0i+/2frlmkqLol2q8nyZIl1uIZFqKL4qwTRflkQtccuZJ3tdQVzpsx +1Bh2DIlDCqcuLvu54Uy2y1tlMIeo538NZLqeG47Q7vMRGPl3/ORoAuH+vyfpuj3d +ciKErGl2N7CqXYRH85hjU6wUj/OAucMSLffLuT58ffL5Qvz2IphRRs/a4FHEupAH +lEGtFaLJMNsNJNARM7rO/7j1YEi02SD7sbe3y5mQJagaAkYlet9ZV43lprPWQ4zL +1fZMbD45Zsb82Q3DNTyqEg7+8sEwOdptYQzl6caulVjc9hT+2Z2yXD19ktE/qX7X +hSiTSRVDkVaNj8mGj3JqjqvZByryLx+RnLI/2gBSDgASJefF2w8ka5ThRIrQDYmB +Nx/IRQByXBjALGYZS2fn2UMf/kZvMSm9RJGyKkTJAlcCiL5D3xP+WndQfskzbqKh +NrXLJXzuz3X5ETLTCN5dbU3EeWEk4lJ4kv+iFpxrfNkBkunRkwm7SSQCVT6zEvq8 +g5Jo/MY6Y1YowUGoopnvYoHH/uCswFJOzbnMEGlSjoeaeyAbfvPROs0SWzI/iBzA +olKCQxInULEKlFQcu7Yeoqv8G4D2rrOKeREFLouXbGiGsmbavdmmaP49HizIKZFx +GhG69DRgQVf73OGd8cb0EQ1KqOpaOy9PpwSJAhwEEAECAAYFAlNNmdMACgkQLqdr +nCtGbZ1llhAApMZxCjbeTGEt8Pr8QcCBD3WjMQB7H9E14h7v01TMl6QLRbP3GJah +E0xGK56mCkwdnMngVT3V2fKwiJnvmIJrHHvOMlXfs/9/iskxYCTh95OQjkMR+Ljr +GsEZL3vyC9vn4UsQsMJHBsMgChP8FUU+ec4yD7EFcKrSTXfsjLr/OIoAQzHF7k2R +Q+Y9ijZWuJ9L3TlelufYQ+SMIOM+JCqZxp0g3YS/fukuJS4aXeEd5m2IUzRcxX2G +tTMSbYJJ6sm8XdrOAT1bFJMTvL28isoF7Pd1y+LWLN9D+VGj5XjpFPg2Vit+DqUN +RDVU6n86SC0rRR2eRYerdLDfHf0YSrj9dmm7MRAzkkrXXch3wHDVZAi1eXdIiisq +SolvWv2l218VCrzKM6G1knJvyABLwCAERz8vqLZ3fSj7uJ/YN50pLfNniXbhiL2q +F6AgTHdhXxIXra4xUe0T3wi6Q4Oo+NxGRiICgzKSoWVP9HTEBs94eMtze8VD5TLN +W2pabcSlVVWJ+py5oXjqxWP2n1gVJUs+BFyQWeYJ+Bkq97V0JMfV7vXMD+UINaWb +KFvHXAmx3QZce+q+Wf8lma7PWmeijb10DCFOTCBu8O2lkhC/5fVhIE1G/fIEj4/d +fwxh57tML6hUP5BXce1YvHn0gY+kzjfZYwotGSFsNl8+l6UN7DxlJ26JAhwEEAEC +AAYFAlP7wEoACgkQZJWf6YON8ZyUJA//fs5uVeh9eTNUhisrT6mBCXOnTeG6Cxrm +6qeh+WT7cyVA1LhRxh/L4dyfKech3XewpSxMqFBTKNAIYSbw75BC8KucZPUPmvG2 +7SY48e+E872XTaFGNRcjx6rsSH8d6Xxd1+bKLcDGSojOMpFpM53UGVc6x5MNy+Pu +xippyxOFKHlnsd9awClJik6VG1ZgRfdhEl7bGytx5i1Puen+4Xd1hgjWZLUzXXIT +0prKs9fseKk0v7Y+HrqtQRsHKEOyjb0hiF8cUtFcuUQ4n3+Lo3UOTvSat/JIjTQK +S1Wfvh6Y6WHWeFPDaDcvQ2Ib55GmTbN3BYkiAOexqVEvUvYd9EZk7ytQr5tUwxHB +qsswmf9UrFmO4rnlTQcUHvpyJa8odL7sSnaISCcaUu1W+9eTlyu9M04yHlOwPi23 +0GamPsUebvoY82AxexOUSGjIVS1s/TsF6QVnrqaAlJKkM+0aWA+JpvFyIjEQb1UX +AL0kL+K0zeXpJAIjm+4gFcDPSvDyOPLJcJp5g5kn5sX6HrC0UbKMGSgbtfyc66rb +rG7z55ytrdCem5nok12uzFL+A9mBQUxCObIeDmMJ4o4Gp6iVIPv7d0nTPTrb6j9u +TGtjaufVUdgcipqOXzeuMTWxCxVpdI2AyIuVlrgOLEIVkhxj6LkiiYqGRNa8KBE7 +wjcRGIcLeaeJAhwEEAEIAAYFAk+tJGEACgkQOTWH2X2GUAthfA/8C5qz5ohq3eBL +tsQz+Kn7hftcfK7Z8l5k/1KBdxAc8hfUWXOgDfErNHW1Yb/iaW4hV28zv/roU/FW +PjtcO9JgYqO5JuspcvYSnx2pScvRmn2/VJ/OwiHDKykHqQtRSgsOu9oLQFSN5TQ6 +sQeAQp/z2Up7jy3ZMJuyMgkFtQhjl53tcXYzDYiZHqu3egFBD3hhJsdgzh1/EajC +5DTqt0SnsfqKnS8mmFG6MfjYn6Dsmnga8Fu1pUEnOmtCSoBv+lnlOb1nV6g3ADT2 +dH6pB3BSa9qLd/sk9qHbfcwfoheMukLM2Mm7dvs0VncXPcD8KwJRgfuzOz9BTU7F +se7dSUjX/Wj/1JjNr600qqtXIcbfmN8kQX45xE+4NiB5fVvS9mEuZYp7uGGbJ/MY +iCy3HSAy5COYUWpmIz9G5GgyjNAnyp1n1HZjGNSkn0HbUHd5si/eQDzMNC3mahVO +NyEtAaZFjt7MQr1xn01PW70dHtHcHNUGMb7iz0HcFqJUmnAgsvMrX8Pr0pMQzwsD +G9N8DkWPw3sv96MLFE1bqHSjKTV0qdtnZkogZ0YhhXGNyMJXy46/4kamC8ov4+42 +x8tlQZKFQQy8FanaljSSrcC+jaUa7tsBDyLqtnmws7wy9SNTs0XhidRjXo8BU+tQ +gCBl+9euupX9WVue+7KQtW/GkTkFsbiJAhwEEAEIAAYFAlNZzZIACgkQvlz2h9xa +t8J2iA//bXGGtmkHTG2ZGClu/ggXsyws9PxFsA0YMeTm9am36q7YhQVWR07nGX/G +LzUB5fWWINDkTq4WCK3Cf7/v8CUKwJDXv1WYUtgOrTb9qK8ElaSapavBS2M5qLBz +2totq13kMbHt/V0pV2MzqzQQ17+7M5GUeWD23JUSK2biSJwQEKL6fNXLh/t1te2k +8N9sfHnKRWCGaWNQjpvxN8wijFbeYnmJ/P8KLo1C4Eug2utlcLc22bqrPnipllS9 +pwSjc42/PczE6H2af8/m81KWWyG7q/3zMDyb6pV8cS5GWhlPSBspbc1TL+2hh6M2 +WfejRJb5ZX4qjFhjBRx2XoSbbuotdI2JZLtzC+g/Dh9TMIJBsuJ5Jf4nUWTmO6fq +M/4m+aHCJEAT/wwYAzMPHwNWKqV0BmpefDTHMVayCuHte30WTJ+weq8ld7pW3mYW +ZOrm+EM30O2GIJ8uSJDljPucZSIrjp8+z5pjznHvsjGAEX1P5zrm1rGPf+N7esd+ +ah7N6I/LN+V6oqJdsbGQBgEtICY6gQcsOSfSyKYnnRNZYHPAtRaEvns1Ph5uBOkp +4ncBxlmxDw/RHjtshz/HEOwTVyGy9pWfMzzItmvwVNmBPXQDdQmRTlacg9gJdiaY +moK3AwW13eyqu7nzq1690D1SueSKeLVUW6ODO6gqEzy/Ibnmi0GJAhwEEAEIAAYF +AlP8+F0ACgkQ+mQ7ph0ievthSw//UY7DgGC5kNDNQOosnAEJpXJmEW6SdE0SkjaU +qBzkh8z7GH3Ci2lHVQ/vlkuPF6bfqAK1Zf0N/ganuiZxghebaXlmEZKIOVvGcHUX +WAtROljYQwwZ5z8UqhptaptzhpZrBSbMLoTCHrD6eBZMRvXw1r14x5w7KyOztoQ0 +TnIb/z9f/4l1TZw859edsiZX7/bw1V97lazgEkt9gQhiPxMLDgYPDW2AHUiu4Ufj +VwdmQNxIBzphL2HmcfOoJrkv2SUyqOUps+Qxjakt3GypoRQ1q4j0ZLBnX1mEgrcr +zkXcq5ZcPhQ0NV8GIhp9wk2ea2IMf/awxE1ZqyEKvIZRu1EF+I/jOkLeBQti3D6j +ji04D6lt7YGvubaPD7ukupq5Rgb83718+ijezyYWVsDiLCF7LYvBNZf2Pq1MPdqS +pDexZJjVKibKnkOKurMhYahjJ6rgTksR02hQuRm8WGf/aTUqhTMbiVolMyJxPXyI +k3N5yarjD7lOm7LerXpw2VL9dtXRDePB1sjbKOdK8/JDrs5BcMyYniZBf2Wui9V5 +HUPW3qiv2ylodZEy3IjRnvG9hj/Gp1TcdbaWVC7b7S9N9Yva28oORMqGpNIBkQlW +NnVz7cvNspbH/SHSVdrC/gb+NUb54jNmqelS1NimbMbtvdJoqHvmMsCbyvAM/zOb +ARevrSKJAhwEEAEIAAYFAlQBB/MACgkQT6BKTJJXfsRK1hAApca/sGefHHstRePJ +7mvlcQy8N4ZeUSNlsegcnX5lLpFty7Dgau83x7mb0jTwWocf/YYgGO7Leu4ns7Pe +ku2fENpAQHNgQIMx9sH0TigYoMexixn8hROjRQwuf7gmrpNDJfJHwFaVxJf30Y8f +uN+ng35h/qnoBHKz0UiHy5eBLd0vgqQojV+WK0if5SaAfOUd93RNk2vQyfl6Co7F +pY1Um4THcytNHkzxoI+h60WYejTn/shRXIUJEH4M3V4eSqGxu28ieMSupJCPf+uq +qSrb9m4/c526Ca9nlBd7J/xfiCTlQSWdTy46EV5u6u2gNPOtyiWWX8axQd6EmtxV +kEOaCM/rIHlZQZwqXYDcP3NChNZR9d3qDg2vV+LRiRiXvSnn+qTna819lK5f5q8G +l8wA/HqyW1tQ2Pv7I/ZvNbJlk3NoXWT351Y9PIgtvOGPfzqV+snBFe6OXB8BJJYm +GE5yNkFPFpmRHCRe0qgiODzd6892+79wKtnBRNixFrhrfP9YXls15bzBiJ6ZYagS +zNKrWXFuOjv3/j14STeuk/bEArHXp637c4mbHpg9sRqmverP4ZA1ZTZ0cpK8AyvU +HoSYlwGGh0MKCld0NdZgHjvbFSij+q2HgAxGQV8D+7L2TFZRzap5/NKKXHo5Vmky +RfPODYzKtMoDpxl051nddzKQCN+JAhwEEAEIAAYFAlQDssIACgkQZzoD5MHbkh9I +/g/+Lp1bWMagn0GlQb7Ut+l4hwFvBB6ttRoYk8GqJKzg6YokTecHgYiY0EQL2fKA +pFvQxbY5fUanFtkwc+8dL3Tw1oqyEY6oUhzKERdT+7lC48jJjjcUOaeczxyHHBdk +lYBF2Iy36M25eNVEXIc7SL7DckGm/NkRhH/Fd5FovNgz4eryfvBiUxTIIsXRDfU+ +Mym2wgjM8ZvP4zKSL7k/N1dakZvpgPHsoDMscafQ5aaPoapDGOj2ubW/lHAmlXyM +M3xd3S1vFZoIk2WjlYn0BCADUEjluF4yp2mwhulqA75j6WX5Un/nEI7ZZ1nYZFpU +HVcFdRDd9U2i8dyUmQTDVjr5lGQrYPrB2WuOuEL/ShHz+XuiIILehT7ulEyJbtnv ++GxtZdtyl9TNgjxecJmwL2GAVRR3pql+P0BlCDqXkhQ5io4xwpKc8s4ovuiG4qs0 +NavUlNyUfW/Ba15mrAS97U7wiflCcOe9xItLYIZEESJ1ZjBr6GSvBMb9o9V0WMCI +DqaNhA/9f2P09FXjyj0fasSZUwKwRP/Olh/XXKAe91y4squoQ+iUBdyw8/jmKzdu +bj5BvbxBgm5CdUmuFEyTvbNLeIT83M0POstpoW0L9Cr8f+5nWMvhN3tFv/ccbA0u +DgfMz/4kt0ouAkO1UCNJ101lO/L1n712UK5muGQRu77ZS3eJAhwEEAEIAAYFAlQF +HCYACgkQwPiGTNo9A1hlHQ/+OxfsDyfnjPtbuXhbhFDEh1I99YKrV/cGiiYXJmSx +brqnjDMgP0GBbAsslkX6FgLw7VfwIpPf1nsRfLERdzlTt/HJFbXqJk/225/ZdUu9 +jbD8HfcyLqd6YHzUrPK9PkCp4n1IajKmworSUHSYp3P8fznVSQjvQucarWIMNb0x +XuvLOjbi0BWCwUQ7TwbgOlyfq7olX1+PQIL/GeQg3EHz8KbEb9Op2e17vsaGXELC +3cM5MICwTTL1VXcOQ/RF+CgLJg3l7i3EtPKa4dPhCzXyWsPqzEmH9SMj2TMjE1rx +eTy8RJ0qmB5FP+tgM/ZtPcpxaN34zQp97fj6EcBITpf/IEjUW+ZvD5ImEZ9AvG2n +Y3LC0wxyVmBzggAb18tdN4dDjabMKKIWO3D33bZBIgvEMVcHhiqV03xJuGf6i5iO +7XVt2QlcK9jXpSCh+w5wSPXKzSob+g4x0P5IDOp5ruNoYQUHUAi6Ke9IcmRq2fz7 +Xb6pR79nq5VnXDkypFCsd4YIKa70eViPNBb196FNvX7ncRnYNAE8DPc83FQ3fpk/ ++em9FraE7KydpEQyP5XSQmwVGC33zws/phyBAtoLKYRbnZ9wbWqA9E6NqSlNd/Mh +0Bo99LzmD0h8+Hl2ac+horD1iAbK30O+feOp50qHDf/+f1KjWCdj0jGWVb6B3wwD +l1eJAhwEEAEIAAYFAlQHvuQACgkQO1biu9U/3LEHJBAAh/PPPy+AoRWzBU6+v2ar +eEbBLHCSiDYYgbLKUtGMVkfsnsF0cmTU0EVll0hQjcJHrIAnjnvLXUBDuLyRIiUe +1KMU9IVtT4uqA/TK8t/zZ4PxtD1ADbNA+FQgUU0mfmrIqNpOPScliRqxtBr2TCrd +ldro6ooAFTR3c1zzl5u5DqP6MJT2YZWnWaUPCuJ2D7oecynqOwH8VdkJFhwPOxFx +/BmuBeVzta0ZnEYC34cSKOGf6PWWWchHYIg6Ja5+JWTEB3MxG/7uT2nzrTXpSLcf +NVp/mQ7BVxZQ6yVEUVvZQ6RU+CGPhqsh+0fS+BiVhK3McMNG3gcgvndDGFxIgP4b +vKy4Vvf/goo1UeJY++CzcV2hJXQCt/nA/qYrU8NCtLiuPZkYZYAQJ1Ey+V4x4DjI +/9Y7IJxUH4ZSstUH6dv7mzWXmsrbUxpL0O73F3BZljcF0E9lQeQiTBXrVKbmrjYx +Jij6HTJqR5PnHTXL4W19zkxkh0Qm3IhduELzqJ/RiYu4zTZbmParZnTdPzjRqmmm +PHD4ODnVN9nRvgMSawgpj0MAnzJByWTRJkiIhYiFBiceSTMHiy9UUDtOzxWg23nI +a1+AXHJ/hcHfNcVAQU2p9z0/kbIulx7YlKcH4NB1Map+/Q+Q3NOZr1C7WRzBK7ok +fLFCu6YWkBcDWgqJeRdFU1uJAhwEEAEIAAYFAlQcL68ACgkQ2SnymSvvCjOInhAA +yFCyx2BuBJRo1rSRF9jIVx+cWZ+TU/vaV0tnoOaz/KOzCqEKuikVqAUmt0PMhd+5 +ShWV264ybJlheA8UeNo8vRv3zEwRQN3mkAf+aqd3al9o4laf6vYjR9/FTWbJPYUc ++VeAopzNGwaPce6q2VTtNnIJf/M9OCrTSLJqK1X8z2oP0FxcYMF9DP9G88DJRFvE +MOROSWK/XCcCsgIued+7IVAyHGzsg+wS58igo/6QHDpOvwSEBiw0FL6BqMqv935L +8O9vTuQCRJ6m9Plv8OpwWDSGeOJ3yI6MpMqvq2YYSP89lPpKvqUIzOmqoJH+fxNM +MjmGduaxGtZgFCbTE8MnrlX06sFMDuR5up7qd6z6UbPL4XjXS8cld/lIQQN1COy8 +/VciGgMYXdidGgHfvV/hmbDLicKVCggDZ8NvNq6DJ87D89CBJxHCpgG8vtycrSLw +xLPSuAuvJFZLo0gjnLHaWFxfsCBHHeWre8ggTAbrkDY+ix/PYjo2cmrtK39kgYK5 +8xOkbuyuv4/9Jn0HFsHb/TMnw8yn6/SkudZPpDMRNILGJ2+CMc7fEVX1O7ZtO+Tz +BJ5L9ZAUlrUzCP5A8K8oDhfzw2Lqc4mUOVz4wVR4lzaSfz6WGsJ9DB/bgAzzUdYa +vxh8zvSFym4nCfv5EJmiaSTKhSmvK9Bd+/OuAv0Oah+JAhwEEAEKAAYFAlQCgzwA +CgkQHnWacmqf3XSsvhAAsXNtuN0kT4QO/Vn9lw1bNYxzVviniirfFVtDcq2cIMvV +YGOwk7HqW5JkJcFc8fOnqXOCzkfIjtYlldAb0+Dv4hzGTy0HVJUTlUSitdkQO5Nl +o7TR3D7Qv/zeQTsAOcyKyKrU7W2eNDLGh9MZbbO355h0gAc56aiJn1hT8isAbV3j +/ReDPsUYOX8v77asttoGPSaI9pyd5oYhBxuE4dR6K3g27Pi+E/+fh0QUxZcaBPyy +F2m/G0H0Z1qHNrbUrkwGtKwC/Mq1gRtK6It1IebD2CHZ0JYy+kcmmr3zXXjUQmC8 +5d6nVefnZJ3pSDEVzMYwEWKt8DncvMNabxreTfYaVWi8f8Cj3L/w/rfUzMO+Bjsh +7Wdjk8bIvbn5UzJP6uWB1+W/2RnbZvPTeXdfe22pwVkreAHUHz4Uf0aU+rnb6M6K +o5nfW1ZxZRlJfNgZzWPbjWcZCtvT+2KLwZpzzKaXVbg2aCP0lkVpmrLZiQa/Igqg +N5TlPhEoJh4QpQs3k4WBXCpgpj83RMepouJIdKlLDXRzZsY35L+g4Va9wqqO8wun +Nc70PorLVWmdcs0ejv6gnk/9st1676wPZhxNx9UZPKyMQSqENfsuHbRTxCxL7FMT +wdPon6S4QdmL3fQ3uqbuYw9WrM22/gA5IHB5mYps/QPMMwcV61GIlpHG5BVj6ZOJ +AhwEEAEKAAYFAlQHN7sACgkQA2qcJb81fdQ5/xAAtrHPJEoF2ufaHnDt+vz3Ak5l +tdGLrGXfaR5n5dYGxGH3QPL3VLacte52p8Nx1sWj67Ec6c7wEl6rcwXDWbpfpftX +DEg8WPW3GRfUE8GELOQOteilHgvcyPn8NP6WCxNHieY6WulP7sVajA177XmS7ZaP +srNsXEOLvpjQBnGXfMKIxp0TPrzLweDL99sy7YkVIC0WlggNP4bEU7tdGjXdD00L +mK6gb+pYVtBjKZJ6dObDQ5As1xpI6+BbTlhDtsjXhHtNYZYOjAKRRUgDnJGPx1rZ +FhVh0uz7wSOoxfAoru8nIpYxRk0qPSRPw5soEg4aR+nRosSSGEXJpaINeNyPKb2J +LQccsNHdX635Fiv4dnUq4c+0oRXYQukvfua77JdO/CP/Skp6Eoh/ItTSkOshrwCI +aJGLKdZmoH8O9YYjaNO079mHf/wryKeUJVeGScWjuFl49jQjA45P2k131p4gjkOL +KmmfpNwckOxKcFYGVqXgxOFgLc+D8iqax0O/eWn/xkJO0pcJvyPMFEIEZg7gKeP1 +5/OvHU+ZFCEq0E/9J9mR2LSzCAtQ0CKtCcSVnHi//feZ/v825xk8UWopk+/2DdPJ +CpyAJqWK2N1ZIPr+u1g5W4lh3uiG3vhLIxF6gCNkvd8IoMo+WXDoesagOK+djXlW +JSUuGCmr/jEQlWBb5RCJAhwEEAEKAAYFAlQNGwcACgkQdRq13aeWeczQ4RAAwgqV +UfWiT+J2vm8BXE6N0JFbLqgWCLVXvrH6t0U8xxZMp7U/ScKK+alLTKbvZVklu1Xx +6mgPrRdfV2/Rxbke1aFMfVVsGyaCS33JkW7bgq7GiTzz24SDcBacznH7PYAF1q8H +MO7g7G8i93DwRl5kLCCdLOHjgBixlWUMyl53FcQK+OuUD+VGpKfU6WirHsEsZY4H +30ejBdC1lgz2HB6/11JxQo3muAvqamOmxwiVJba5wlyHObiyEzZNRxKCEhuwYIeF +aPKzI65xXy1mUlflKX3eUlxZqFrWIy/eCnltjDgt+p2+qGHyeLFxsI5l3Qo/5aMw +u4Sn8Tijh84zlivVzEs14ip5YDJoypFugWnDiuSspo5LzErhsd8PuhrTyxyKJEEf +0SpERODZS6l3h+ElB43rglSackI4Y5h9mAuAJ5FyEj/fXaAGH5CMbpMJvpsftj3t +3zgBfIov5bP+6bj6CSL5HU/oAUHI6OsBet8zRDGpNYrPOZYBXrn9dXoRBKQSi8qt +SpoJ/2iPDKWfHuLQSiXz9LIlYNQCJ9AvPutbQBdpY2Ys6NoUNlzsOPbgniW94m/5 +B/HsGG0tfcAgq2IBmer4CTjNbXCYvKY8Wh1Y92JzDJTHh8OSUtlzKwEl8k55nIBY +1lP+jUCzFbdPOaN+8RcLsTgiLP7IQzDlIcdBdjqJAhwEEAEKAAYFAlQPVewACgkQ +bmCLY32JZ+kxVhAAo8VDr2AG8hiq4tuskN3waX2gu9AOtpwHlPBPrx4ii4ddei2w +U++dn6EVO91GCeB62yvxiPIReH7+qtJIiYSjvULbzlm1jBqrJrgEPeVtS3uFi/6a +Q2kAeY5VenFXC9OoyN68VSsaYiblACr8Eg2lSezr3hOXlru0Lxo1WJ45c3uN11rP +SAQsvzJJt7p9V7wLGNu019+m067WeqIsWN2PFr8hct+oOIV8JNfyo0aEpxq6iP9Q +K2dHnL3fcSUa5O7lVXI3BATrL9e5uYcEk+c4Jxn4xvm+1njjjz92RXxW7UxBgKJ6 +kUNNogfXFL1Sko9CrV//uqnj8QQfqsgIm2qhRt1/wi92Y7o4bdrGdPN5RafIzif1 +IVaqbDnABPD3KilgtluK1v2rn1rMW+Xx6lecnHFYFw117Ge5NdhSIjjCN5G7tKRE +jCkDOIPHhE/Cyt3J2fAqdpIGiadq2G2L4aVX9P1kKoDxsNP9s4aKA1f+FnXZuPoZ +5PDmuynyNyf83oISy/Firg7xLNq7BS51LGrWxqdSnuKXDsNCXOcL5xT0YsrEzvuD +xKYD9gfgj+41Bdj3OxauSMMdRjWlMkhRp+f207DmeadgZyUlUmCUcXnMcRHPy5JD +dxH4Wi9b4/35rSVO2LjNnn1UYq6ES3+gceCaDYjcBPLMvqd1Qj64FXFeiqeJAhwE +EAEKAAYFAlQPZbYACgkQ+z0lgztqr/jdQhAAiBsiF7BLlKf8LOgBQ4PWSx36bsZP +mTFVXGVGSQ/EKkV7+OGTBARUs1Q6JufWpLEKJCHrKDOcYRkOCLRA83+i3sUtQ4dX +5v22K9Dhy1hai2nWWgnRRmYsgsDdzcNfNusaOiSS5HqwMA64pJeO29R08mYsOZHQ +3OvWmGeJYM+zw/Wo1sTr6pM1z2IzbpLMDjCtWYucGaIUEarYOgXTi6+zqHwDaApK +OL42vwCumGXlqlLIN2ciBcjGzCV+L+mzXrw6WOwJAZgA85qlOdccnMvkTT9bQfZN +Jb+F9AlirBDwzJSr4xSG3/PVveIgcQOvPhKojU0BMWaKpVF6Pfo2Bd7PwWuE9Rz3 +8eB9HiJA39c70Jt8OOraK+AnRNqSOkN7fxsZayG3VR01teV3pAboJXVc48dSvUAT +XYPgW45h0xGVL1QQFnjjlbON9Mp52KkljC7IAlsU8DHjCAySTESrvoSEA4Issovb +1t4PWWo298TiBQRIcoFHsabyDodmFjKrWE38iVTkRnUn7UKluC9AR7QjMkBTkv9Y +/AWqLqa/7ZDxhEASK/EkHML5kcpmhO28nkRr1fXtxZKtOmrNknhozXqxPB9feGUr +Vk6zGkc3+A/z18DbY3roEtEyNtrG7ldRLh1d7stQblA9WqlbvOiTv2QGp86XrNqq +YYppj5OQDC9lIdaJAhwEEgEIAAYFAlQAsYwACgkQT616dThFWdvBxg//au+lvRCM +ZmCuNv1/GWsgb6VLi1u4tGvk2Xw9aXqxcgqgKZcKuq+tXus/uc27oH5UyuDUexZp +kU2XtvDm2NvZEydVNwIFmDz4dR3sH6VVXF9mX32TaW9pPB/LvwLFPkJ3k1N6Bfjh +dur1/3kIvfEiV3zd1zJUIL3vmAJN5cSRar7snHZMQkG9k14uh6BnurJQNb4QF6i+ +4pOlHa4BMy4QzhW0kQELcejwOzqtDDP7K4nkrcRXlaUnu+V6gBNg0QdrG5MXMzbo +lJD2yKZ5KE39k/rVXs3PTRnaSUa6zm6lJ89aCjzkJ6G0gGF+Zz0XGw+uZkSK3lh4 +gbbz4D1MDvEJY+bu0qMrNWEyGeNMoABWQxTIrKx0hWNhY7vuVw3ccJeA/1JPjKtj +8eJoL9sE2cS+83rVBzdGYjVu8gcp5AgeieFFdCdWAyTD7weSCbkdCqnv8/9H70FO +hvnZKek9EVtLHR4XjAJ+LW4OOCxHsF0x6C5Y0V0qfm4LQ9kmqskz/NvmB6wN8FSI +x8gPCOctYSvAIUfE2wEKQx70hoTbVfbjjztKnunyisDmB9N1NubQHFmJfj96EJW2 +10LXaMvjAWR9l9QzpC/4iV2/gkfW2Tcmeh+v4E9FFWHgZ6409gV8qGAv0W5g7NQ0 +aH09qPYwKn+YigaB5NQlLw4iUY+scCc0yluJAhwEEwEIAAYFAlQxjv0ACgkQiHtg +YYs8Fq6WKRAAoB4XcFZdIiezcN88QHyaXNAljuCvxpKs3dOdmgvJ0sizfmdj4LHX +X9wNIk8rFu2dMjoOFiIDEK2KkkW0/iYgkd8SPVRS4j8lxyBLXxm9b1E+rxf54ryj +JmjdwRtqbYerIkOKc6GYm66i223m8bhedl1+axjV/HKRBbVsbCuLJEezAi1KVaQW +FdP7SYscAiTW7vdbt+eoKZtpTVikTX4PHe8vdm/2kUsDBkfyisHf0qDEgzWkYP/o +J8DghxAX08ZPtJkapMkbvd1rWV1Pn21DiFt3A4V6HjlzwNcEC+PquS4oARZ9o91W +QG2GMOxu063ko3CBBOZMKHIqX6Bwv9fVlxWF1OVTLmTR9tOE1ECqLPTQktLEmMOO +m802LfSpv9zIUnNF/RvdQJHl1tJbL5Qnt5oXkvCtqqkqEWboO44TGK2c/q5ipLvS +2wJ9fbtkD2Pmtfe/iC6+XCdkeWTeyaGNyNQ4JkjB1rVcWsnJduddGtGSCcO5koeG +Fyf+7gFkJtXepjjT4vi+DF+4GbhhRBcDz5EPmorV61stEymkf+6z8zx1cpIUk+31 +nk2xlL/jAg8BkdumKrnM30ApK7fMBvbL2KR8tvPFIWpbUXzLU58NWfW3spjhCrDO +2GSxkpZhWAFPvhvGqc9r1dAnWRzl0AwgHDqLRivR20IDI9AU/dqRVLGJARwEEgEC +AAYFAlTQTv8ACgkQlOkt+SqqXDseAAf+OqqAl2GyFob6NYsR+txhz5UJBGDSFf2B +BoFeY8N5qJxdQsLRaZHK9PwvH3Hspk3Z2pRhnYBKgjaZY2FQ76euMQc1Taxis/6x +9qZhSG35lgRpPoTlb5YWgCCAvV/85aY8HotXJqSQ1gZj+C4KyD7a4nFIvIkCOnEc +85qdXGKRhv9BCqzRrP4VMt1C7etQH067U1LCDbi7RpuiMov4sYIdC82akfHpASjP +IzF4PveYLkWCVxfPHZZ/DAKrPyOTOzHoarHbRILt9yIauh4lvN6vYtAFD2KtSY4k +VzbHqDlCfeVtAP/e9wM0TZshb3D+A+fTQnHhhczOYRzBSjdbm99/pYkCHAQQAQIA +BgUCVMYwBAAKCRDDjoFgoXhB/sfqEACSGUlie5/grjk+xkKsKJWKZwkpgTyrZTJ+ +QN53wOc7sCuZf2cwtarK736a+UcVBqrpjEOE0rbzzpZaEEe7qb09dowSrEeh7uZ4 +dEPeMI3Hi6Hhl5C+ncYm2ev8XI2Zs/5axjPUW8nfGDYdmbd9XtYTLAxydp5wFLXW +NxZOezpjVpIy3j1uTIpBCqvvtwIgGu0x3Byvd+2G8VqybBD1C/IsTYZ+poD1MpoQ +c3FsAh1mfI+jvwr4gZLm0lCxS7Eo2ey8F/QM4js0Rencu3SoWfKO3fXCCdAAki5l +JG1PGkZRJgsMl17oa6nrEQpy4LubdyFATOdpLZbNjFEiSl/bix7HtuE2g/H55gqA +K39erqTgrnAjHmFLX5eOeGoH2VjO3JRl/AftBupqdtZ6Fk6KEbJt/uatQJse80IO +hLKGYOHy20bVWDAR9Wq2PpRnlvddTNaP9YvM7OpA2hoMTYh+9cjn5uwod/oIJKJd +Ov5gZ7NnxGZq6x15j1ax9IhXUer4qpRDrhRGpM6kxkB6YyspCrL6Efdm2HzzdT/v +cWcDVgr8jtOSOMhUH8DCXa0wrxVHQFdr9t0YsauloBDEo2GstuFzHnsF7fxBk7xB +khBK7ffLj5HRlabEVkkYYtpgYzuF0ISzGs/LY0Ncs/1/vxpeZmNpANn5XQyDVn9s +eNW/6wp3BYkCHAQQAQIABgUCVYAyNgAKCRBXkw2rC4awZ90+D/9H4YcO58lWkcA6 +4A8FeAVQyNMywkAQeyFbKoOsfDO3PMbvW0BG7bVmLuNlEctpUVMQqid0K7n2RONN +XekMvZwCN098LLlxaruAewTbOf8o/hDOi69fiPsYAhF0nnHZzSJVJodrBo4CQ4xi +OQ58TMyYOn52GCK6dzZCFZikn8Jhwdzp3GZND/lMsf9uX2Qub5Y3Z3ckRHU/mPZl +v3vfBa9bptOTG0h50zJyQXV3QRQa6nKbYw1rSpjRBKVV4lXIlPOzgPeE5F2wCwFd +NBgHkqDCCWL8sGAiDWJUaz8NKBiUr9IlSha3sHoxQg28zWuQ8Gt3+SHN9qdraBGC +CX6S4TW02XD9x3y8wrXAtYHy89f6/vs+5IY9UHLUVNF/TKr3Q2sRWcaDrfsc7lnx +3t4ZLrnIrnO4ep7exMDAkVUnW05pTwnLw5usvyCv2SScgRUKPdbyKco4YW1iUBm9 +/XWwq5RgzvLwcDhGSW+S/SncJxhHMskvJttloJ/brNSgdmAr4sGWdHZojhYH+6MP +3jNK9cTr3tjnZfN44Mza5JFwG9HfDiPbCcuNwx/T62jz45z/U2KO2Uf/c5fH25Wf +0steEAjGYgcRANyKwbfFrtil2fBxuq2KjxR1z8e6WERKVicyLYQ7H8a5WIH7Svk/ +G/wSVWp9xYlZeKtBWef6n/S19AGJG4kCHAQQAQgABgUCVJCc0gAKCRC45Qh3Zkda +r4LoEAC6do9yhEs/IFd7fbk5m/TB+YgacF0EOu9L+YpDBo0IXDl+xgWIuGhZb6p2 +DLmpEQAIXBl2VyXk99W2bOQ1IyXRD1tXR74jLeLJyjl+I0IK+Y4DW73BDEsbUxtK +SRmzY3/8TFPl+lpRRNJOXHey3k3eoyAoSWjHDvkC4sqNgsQeGVLXgFPgHPIaEmtB +2oLAyCvjLRTVembcseEVPuickM9uGbOZIlx2kL5rpxzIrDwoYIJ+s7EQ5RYpV5db +7s051QHhNnhCeMpjisw02uj5YHUHgeAb5xyCDU6/BlWGuRcAjc1kxHrog4MQaoLA +wnCjmXuJD2YIK60aZT1JoQLD1jl60W0vKKPCglRSXNqRobYlb6BDvfrwq9y2yMbD +CM3bsL4HhlxH7ht89wjBEmMwrozpmszDJUpwF/LLfyINRkjF+E8t4SrqXkDPJPk/ +LZO5nent+tuwpiLTZRdFAAahoh+jWUuJEeHo2+jDSMmYHhDVF8ozslcMGG4oj2u1 +V9uFhCz0JwFjLJ6j6zzLxcQl0a/wcA1O2gSDBmjxbDU+C6IbsBHoM43GD/cRiDbz +jv0/qBXVGjpx01djk9DQgpP7gUw7qmIeJa0S0QzeD9UfRgfn/FB9o0KI/+M5ZTio +QKYIpTqzfZBFQp6Uqhxvsiz0D4S9CtPmRVxmYqChB7v/VaDX4okCHAQQAQgABgUC +VLSGLAAKCRBQQfGJH0TgkMe0EADu3KYF3nJwTvmqN3r/iAxPGlLH5XJIOHslzejz +66yOk3iXTD+bE6UGLySpA8a8OyLGfmKbc0krC/OvQJB53XrCsAwpq36VRzrqowvd +pY8Xaj0EYD/GAeRJlaW2zYmFleD7ecLUJ3gcrq0RPNYmMhXHGNdsv/JgyVbENQqf +5CrJWwGEa7s2GrEwI4QPpqUTECYnqF1K0sbro8WpJ2aEcXILsR7LFJeSzMyYXgCY +WLluERywnCL+GrQHGh+xlWqMNIan3sqfsNAfAfKMYoA4RvTPOEAK96l/P09Epshg +5V0+ewWN3YA2ZncFRJjV1hqy+h+OyTjTkD6LyOPHpsoksU9kDOFMv62+JBE/BTnw +VUYNYygMj97KUI6puGub74c/POjrZg6g4AbPuG9KAzHBkvkq2zuLBaSHX3usweQ+ +tu8eKIHyVcJRj4wxOv/TRuILoO7+bamhoobG/26s0Hpqyv7euQc2vLhTQRC7bkqd +S8FaWqzW3wbCuvqyNzkUWjw1dqgY9h/m7t24sUXenSzaTr4uWWn51YDCxXETl3Eb +WyG73xlQlJ3JYc9GN/nX5yeQ5fgsgBwHES82TXYmDDx+Eniv3+3SNND6Nf5hIMhL +trLVDLw/bGRvdxEDCim6exD9vJiSWzA080XRASZZV7DkmaT66F/cjUyrV/6pncSF +dsKEGIkCHAQTAQgABgUCVTbNPwAKCRDHiMTB1FUNRdFsD/9JdiP8LZcsHru8FcgY +hYO2pmszvJQ5CjmwlS4X5Gqnbm7eXtYNaSRpskqgG/NsnSYCxda7VWAeGIAqNtPF +AdgOfg57YehhZGTxBjzf3+Q6/EGT7OFmslh6gwlNBvR5EWJkMFsqQzd5v6JxA5kA +pzrH+4+69iPSlkbpR9KP3qgrXEf8f06Zsn52QKI4xu0+plXIZxq8PcqQyuV7T0dx +yL3rX0xIoydTlYZKBXR7f5nyh3rGipVxPCsHVbUsZfUAscb9RN1+aO4T9cpamxiG +kIvMFB9uFywSHUPxgI90punyH1/v1mJKigKTADuFx1YTKNmMKbWfroRAUib5nVS7 +B1MjBJaNZeW+krl/Q4/adnfg0XF7Ibmf2O1Tk2Fbe2xUleBpvjSeXV3Sdw8kwsug +DOhywy4t/rLjYiYYReEzWz0q6I2kzZHOA1AwJ7qtXnawNSZbjwWyiWCDD3qOPfLt +hz7etQMupXDhuu3z5H3AOxZf8K3+DmBYQtXqjk1UohlfaU74+wC57zbWRsjM3cp8 +D4cxxRDUYIUyJsObZL4G1Sb5Gh4BNDJ2tvkHt6UYLBPnH6XxLR2vUxDyrfUwrB4A +ulcElMZG8i94aLAWjlPYCar9jfs/2egaZij+jAGavUnAfVF4369F0fLef9pQZabg +gH/U17Tjb0PIsLxlsvGXRkWcc4kCHAQQAQoABgUCV1uYvQAKCRAtNH6mqmVCHamr +EADkjOugRP5ih6iSam+Xwz12wZQtwawsontomociebGc9GdMgGn0pygYm1lfuLky +r1Kt0gbPV1pO6dCu+yMpkdXAWOIyQUR6UTI00QJ5fV8c67TdFGF5Q5yOwdgeb/VP +L3SYr4sr9JPrkjgkHDIDYxPsZDOx+xX5ripkWalyv+yYY1hPm60MH9hDLwpILhtb +C8sc590e6t7hSDWM7iv4qsR8bAqonJzIoNgkCPGn9ChbTPoppIES02XNzgKr1rkY +jBkFrK6x7W6Byy2tOeAOAqz0cS7TVIQmKsJsN1Ttr3FuPCHSKMhrHRu3k/Z4IsGx +yx+ck8TVgzUlP4b6PLy2FZ93btCvORd5CZDBfWljcapXjSnD1olwUpHL60jHIKof +kQue+iJFVDlDLL4WfFf/ASCeTqbdvzXS5KpiESkG7jf7YtpAC7mGUkJb7jcYUBiz +qoXIBrqaifhB55iJ0TLrK3UPXX9MlTnzOtGBXdznopuf/myR3/oxQBTC+XDrurYS +36Pa7EZwVTaSuAOXjcyUkI3WB+U07APEeBvgkddp9mqV67C/9z7wKklV16juAXeF +cj/hwY09bZfXr0pFoXmhDoh3iVGO1HhgHCNLY6snQgTRA25uLZ6jyYBHyyV1PX+C +aMH0t8T3clGVsM7yh6L7gYIpj6+jDyZEmSy0RD+EGqdXzYkCHAQQAQIABgUCVt8E +4QAKCRA1LGcgseO5K9USEACOs+rooGZR1EtJ7a+OUE7C430Y0dcqLjziMJNXkY4a +nR+3DQyshelw+oiB5yG4MG8IRWsqjR+PbQX1SEGx7AzZuvxORmbwiqnCpM4WpnAB +9PQFYiVA/yav1QSUEy4JSR3uWcvUFic9oqLHKLQ13xyRZ2Z2VH8tY4Rxdce93mst +y56upiQyraIZ4op5bSGVtVnG7u1Nh1em9juDj4KfwkU4Fd9DwggjWQWur2EcROuq +4+Q0W6VJnKAREzEKTFDLvcNI863g6wYI5fRhXlrYb5Qsew2Gz28NcFND9Ctu222s +mvEkssxKpQ3cINxGEHRVp6mK3ByQUeVo97tB52eH0bQ+7WpESSRxSDpdGfJ9iD7+ +2oNJhD0Uq5Yu0KUmCvg+GpjvfBAgMm8O8ajFtXae4d1+9RLfaf7sjAubZxkljnT/ +xmPSCP13sahyW4tT0asNloG/vNFWuDPXsbP2fu6fB0trl72hLlBd0SFBHr/HY0pZ +/hds0zd+qBsHWGH3mz1Pks525aSCk36TFn0a2H6pApjGUQoamwkr3qwq59r/wlqZ +3/mi5XG/Rb9qSRcvSiOsGgfuExISHQIBAq3CfwbXvUfCiY14z0YJhuv8kCSBfSjb +8ELd8hxZRpOu1A8HNn8XftuJm4BfeqK7Zad6cAZUARCbv+3x4RXiT3sN3LDYOPhH +BIkCHAQQAQgABgUCV1MZzQAKCRAJSwnQndU0bcgeD/46OusiRifbTYKvJ5hCu2gF +w0R0EPA4mGr/2o3B/cMHrxRNVoQTcHgIPG4iBDdmZ/5wzYdH1IOvxeN0jdS7P2yv +k/2UrhS56nNp0nLGkk1YAw76sk3BOn8zF5hjX8HOMKjWvtT9c1jAniNz+p4I3gpy +4lOmaAxli972fX9XQ1F22k7jr1t1xNuMTFm3axOG47ANunQHdywMUf0eHwDBe6rz +FX0fhExwOyH2OkWQHhC9KqC2Pn2osrMFBI9/CO8Xqu+lC9A6GgXK88IbLJyLWdt5 +B621SKXD0a+v91/gFTKlIlD9xeVVycPCKrqQ4eiD/IQJnY+TvLwJy2xT2cDDtb6z +31V0Uo8ARS7QtXiibtpcNaAL/9Eokma0E5rQCRfuYqc8DGskKVczq54Fpb22GTi+ +a56SQxaXapdvcpwOzlCe7l32Zuus+08EOCbRQHxAQBweQNeK0bgvpxxPWslkewSe +k26d245K07jvBy1VjvT0QexUdf284aEaPVfpye6vOB03fJOOmkXKwR3uqfkP54yP +8wm+MytHz6onJ8R7XcwYH52hLTKXHFluBiYcjK0en/V2bK1SVI0NKa4kZFrvPHy2 +UM5KtcWW2wBYVMQdUDSFfODPJVvnRZQ179hqqIXbE4Ho13vjuuoGYtnryQlT1Baq +GtqAebKkxwqMokePipnxf4kCHAQQAQgABgUCV1MazQAKCRDAD74tkhkniGpXD/wO +b5ie9+aWAaGLOyZI9PUMFZVtgdHgJctRAhkpoWVvtTGR9frsbNp+/W5TZZe12mz/ +O8jLS3eq6xDHlfu7F4FBVHXZvPbmPBt6t5sCfji+Nc1b+oZT+xxFS5qEZjGGmUhI +6Dhg5QyuSGPRlVd1gRb7arNRM7kUzM201NB9G7WVQ9bQLOLlNJGmdyilBx61ZZUK +X96E0RvEXlF+ZLpwZGtBo3ZtCEo0HQdlse/ugr2LYoNaIEPCSjOfTRtrEEPwBypk +G9LCftXSMllywNMzZO5OhoC8DsyoW+vB+c2je+dKVBj86OKgPD5RXpyS4r7Gvz21 +gokLgJWW9XECJdo7XoHyreekbNueTILZaiaqDG4BqIQ1tx59C5O7TvaSkB7QE9+p +bdFCAP9WQcU8KgFZNQeX01kuPLAgfLCyl8XHB99A3MfXCJ0VM85ZB8kKZH1eiESC +5yPSFtuRd4YG7a6/Rx0H0XKmApN6+wJgKz9wwa+mFSe8S1sDctq2L7cyNmlDPfeo +7RUUBrXb8slcmHbjvY0k73LB+ktiytKBDxYPd7aVKOVAP0ZVSgvtLSzCAz7/+9bz +MwSsi5xBTYQcf5AykaxE+/5aJ3YSBUzhImV6KhTCTL2qAaFrJfZ766JNOUb+Wmg3 +iWsswWZYfKyUgMpQ55XTzCpVJGldSf9k9Shcu1CxFYkCHAQQAQoABgUCVyN+cgAK +CRCHVo8VYs1RMtr6D/9NkvUO0eaZYOZyMeYUezGQ16DjRl5q7vjJUaGSOkSIBr2M +zbB67Nn+bCLCedmRi+YH9i4sg+D91hM8eLgWHTG3h/y2iAbz+vxKQ/MTtfB3N3ET +Cv5l41b0OWuxHmiBMKBKU6dcZx+P4r6JC5l4NuoHkyLh3xJKMDYkZssNnMZiApq6 +3wUvMXKYy9xnd+LvkqlSyqjzJfurTW4rAqXaOADp6AbuFNUylHZPss/W7vZFxwht +5gt/QA2HCzD/Pv7fJku7HM1UGtDXIJi92akss7i7Kr6Iz43raHx8fMnwhSAu4vwN +kjOkodp4mnazQ/ZrBnECK6jeG4t62+Q2K8LijZ88+Vy8zW1ElCqoJqefj/iS5e4y +SkJNlbgARy3RRU6vw4kyrd03JSt4n0ntJB4crF4Pc6vU9/7JM0Fxdu/tWcvwP7ug +z3s/6Jb2CgunIuzy0gIhELTukYhyv8TpmBsc4KsgoLDhnRd3cTDq0TfD2kny2ET+ +rA8vAS61zoV2kqeI2i0mbaxzOGxh1VGcc6YPi6UM8EGslWCj01KkuXW7rrDOHS9y +Jnnj5edSspL8AiYdspdtT/Mct4RnS5YOmPB//uO/On73At6IInfKO6Ivk85hzfsG +r1dyV1PUVgdtcX7Mp32shcgKz3vNXgKQOuoHk0WXDUiqLUK/HAKlQ2sTXGbFpokB +HAQQAQgABgUCV4EerwAKCRC3i5CPI0MPgHErB/90l8jE4aMCUKau0ZPJGqLyWmYu +fehTI1XxS19vPqNq2/FgcMDDPye0gLwJJZ7m5VVtQh2C9Pq0c+OfekJX8qcCl6TE +3BZuWmPl4ZHWkr9qLLnWx72ITzrqv97BMNgrMZ6XhF50wbsikDTsDnwzzIbcREqh +jgScOXhvhrzOOF0SusZFdQjOItvGkS2g1mraLeTFuSv//ugRfwhVGfufbzaCJo1m +l31P2vjoJCXtH6CQmkLEXgME7b5FThT8bd9DEsL6+rclAXHfelbUL2sPBl5ZJm/H +jNeS14A4HUQxRbq+XUglBCSoZAb57wCRLBxIZ1/V+mTnSftl3AkfAtRYwy3iiQIc +BBABAgAGBQJX1kl1AAoJEAI8BeLJwGjwXKsP/2CEYZ3WFccDm2utYBn7zocCSxrq +YYHV0e+gNZnSr8+IOdblvoYzfanBZ874y5u2RROATLawoBIMTdYY9Ff0yy0M/Igg +tootzOmok8KR4u4J5Kx/b0UbEJt79+rXeQUZilUpoP8eFilQhuuEmBlJVpfcu4P7 +7/qq7R2Q0dh5PxIN+fAXbmW+kjQAu217IIPj9A6MtuAGO4bx2SxprVep9aFCoReb +C2YEfiwY26y4MEj1e0GtxeecpuLiqnfm8mQuFxBXv4yZuYkNoXtSggqSnBGsrv60 +KBjDIvzdkxSbY0VcWiPQC9PDFopG0o5ni8mNbErrdDZD7hTJFG8ARwiBeW3+GDaA +49LrltMoCeIcI2ylyAy/i4oS03dmYB+3sot+8uQ2Z5Jg61s2N/Ik/jmSxLB8FOj/ +ZLLbbhUq+LgBrlrrbJXBL12SfZowPTFvKi8vs+wFz46J15PXmmuPdA6cbC0iw21K +n87LHjJMDLdBhhPDW7DRW1gkQ65H9vZ4F38kcspJZlrIggLqG7C6OMIStjrAZyvi +wHQzRa4TS9dbzWQWNLvRyfVinR/wU+18xrIBSi4QaL89lqq5OJ50thcGoSb5cAvm +IvWcs1MwbV3ZBfxi57c+P/gSK2e32GjPysDwE3bjISgzI2F16xHhQfyyv0Zx7KLF +4hOG31W8xyAKpbB+iQIcBBABCAAGBQJXaWDLAAoJEIs9hnyCPnph1q0QAIS+qxLS +oBiIeqfM/AJG6j7R7uXXF4Nu70pJ9R9ow4oR1Qys4VpTU3vOM2NeU/fj7vTxV6QG +fEFLqQD7RpiVhySPGJxpg4MEGivSUy5jgc3Ki9FtX+I6lewHj8tSXe3eJyjYymM+ +4o/53gEA0zQZMkRyrhD68ix4kAv4dFmVJ8UqcihUvKfzBZvszqn2L0iCHPWVGemy +hcBWradF3+ude8l7D2eunPGbvjhNK3EsSg8MzvqPOvPnzjymBoiYogbkuMeejdMv +hKsUh0WIWnlxrUXpun25wT8P1GDV7LOO3RQTBpXnPv5R18jkMF6A1KtYWTTpWMId +sOMIItUa0i0bnTqAwmTiHItJGyPSWp57RdA4d+ODakhRN3KzwpioKtdRIEghvfmU +Yq9dqEEZW8NrpuGn9N5PxhTbxLLeZlwFkALyLOcatjSwMhejqCbIWB7T2ado5BLR +nKl4w+MLIupRlH6tvZCxwnPbg9begPA41zqZkHSseYfgZLg/sB9soNNVnqM0NeTV +T+CWtaV6Hc8sEMYtl+4qyusHZL8SFcD2x77V4zkX52ErR7VcGFy0eFRMX73CBvS4 +Wa3jpOyoEZ5A2oTvh5gzqWIvNEAu1/qUnxGf4jpuQN9HlmQ0fthcip3yb6777l1D +Z/BZjUmTr4o+EfFAujkXxihKR1r6uk92Oh3biQIzBBABCAAdFiEEa0msutz2vRyi +BmerzVT849lkvvsFAlki8Z4ACgkQzVT849lkvvurZw/9Ec2/zA8w+vafQLps5KVQ +kMDeuBIey9OUH2VfjHSJisdKSsAWvfMWXAJ8YP/mx7wEdJ5tE2J/5mQLyAEUpJBY +fzYJ++Wp90z62dm67ZlvI6KS3eNBLgBuY2u4ff1IbkUBDFx6KV74UCtEyUJBqnXw +f3rBOiiFTy40735//njCwz9u0RT00DtCHXR0YEw88MpxrOZFTNwDRmg/DMITaxfU +y8VNRFhZuBcdribZZs4AEZyBRd9BpvxjVcmH4fCFUYqinedyL+EDPR+Ho2+aoaYx +PPS953khFYUawxW5G0eKnGdPLlwqv5HCdVlT7Wnji5czcejqA6cL7NT9KQ9vGZ+5 +6Au+Ypuo8Npvk9IBk8Vqdxy7EWsfbiSNKFNRhxS5LJK675dGrnfQKf13tpJzoTfU +86hNCrkjtDgyR5dle7mqQq8L35laGlGKBgZyzJaK0C2JTOvqTFe7xUTAybwVEbRO +WpnFa9puaxyHVXDgjpkHFbCcd6vMmrSfNz/k3d5dIsj4BW7j/qdP5YQoU4TeOc1M +oBumGvm+MjfElUYbHQWBihZNQRyH3n2uSLIClLqlDSXfYeeR4ADiD38jONiUuT7e +wLoWrzgGunBunK4gyOdDMCpbdlLCRF8fAu/V6VycEXwDCKNMPwBgnjvGaHlvGINW +pyUYzvVvn6e0PPMXIffbmCe0O0JhcnJ5IEEuIFdhcnNhdyAoQ2Fub25pY2FsL0xh +dW5jaHBhZCkgPGJhcnJ5QGNhbm9uaWNhbC5jb20+iEYEEBECAAYFAkw85esACgkQ +jCTRYI8GidQVpwCcCiqK3FefRYQo3nLneY2oRWYCD0wAnRPiHeDFCfsJqXcCtbdR +D3gPrC2ZiEYEEBECAAYFAkyzexIACgkQVVuXXpU7hpOB6ACeJpnyMqnrvSKjeskL +xitmYzz6uYMAnjafJX8igVXEprSfupQYP8DZkZ6WiEYEEBECAAYFAkzV7V8ACgkQ +HajaM93NaGr+WwCePZp5mlhWgr/GVK/2HCKcy7NlMcMAn1tpWrqyciynCda+vZUt +Jh4Hxez4iF4EEBEIAAYFAktXYt0ACgkQ+u8Sk23T4+xc2gEAo5bMBEdO+OgmSPL5 +iQJKKpJeJ56RtDzaS75+Z7aMHeoA/2kVdgGacUYxn1iL1Xlhc6ktGkUw4gWWxuqY +CL6hbMmYiQEcBBABAgAGBQJN0WUoAAoJEKax8/DmtfWjEQQIAJ0l8b8sk3NaIoMU +OoU+MeIPE46gOHGJdba7t952aElv4NtGid5MKh5lkueWxJaZ07u1PgbyRtlF+pTQ +Ciso26QQWxmLGPXAfgdOcWCRWm7L4PgtPHvsII36g0BNIDgiOlhk9i1HCyYni9XC +tZHribVP7xcmn/8sowM14D/smGgYCITWytAVXIfSNlq9rR+4Rjf6TcVf5rPcyAcr +FdVYe6xufGd2xKb0/TKeKrbNk5OmItdNgEDvAORZ1z6HBHEBi3RFLivH2ek+bwUu +zRQisFTE22OVOpfOA+UtN0CA14gxRPeqrBn1mR6z3fqYrxb7cR76QlGzAteH1H3h +sTyR6FSJAhwEEAECAAYFAk3M6ukACgkQuN+3G1/svZLVqg/+OMKNReBgOgTGoDos +V0GKWXE6u/z7lKKQLtVdIoIeO4OxH5ESaIPid27asfGUDgFDAhuUIGzBwUWQLsoy +9EcWgPFTD/Qs5iTzXAyvfDRI8S5Csh8NAcnEsa8c+wTv/IiK0GP6IKSL0u9AvVVZ +K1ewLKjNgZ9R/RFwodPCYchk85bcq0D8TxNFwHL9NYY+Vg/pFG2HaJItfUQTuaKo +Xa0Kv+57L5ybVQNOkH1JTH+GA7jjBwZWik6b8kqVhRsN2Z+DzSkZL+kAxD91wX/p +O6RaEgVWaKFJ6q6NB0UZDElysMLNqNiXbEGbWVvr28YoMJGgQsPkEAYl5kEfX+BI +jB3O8o+0Wj4TIhV/yECsqHJ3HTo1X17qP/wZRqgQIqr/YB0P8dR7l+MkrSo8Sk72 +fvAEHN7GKsUTkKT5c13Kg6BO/3LRHTSSg0M9MV6GJK8+vLDWrFICktseU+yzXJ+m +hAs0Im+nClNQi7KfjSsuBVm9R6vFJzlEU2jXqFEsZZI8KsFsCPmeg3lzo3uFFMWV +jY51eMlDn5HvvzSr0/mzfOQ/5WDWvzur2uBOCvsX11/zp03u9EbKimFRB4QP6/Bl +U0ChcbLluiRjfrl0IxNN6Ny1Qbrd1+3spVkyVHLnYAwg+kwahdxzk71sL35slwbO +w7pU4yhaQHg4TEBSeJgJjqv0s9uJAhwEEAECAAYFAk3M8N0ACgkQ4ZcBJna5tzmx +MRAAlXJLRUsOaDOKJlITiM4DEIwHEN02FTgWmt6oNxH7gRy8s417jMSUubehRm9m +L2EIggf9vzeBOjBLm8f//wUB6AayKbgl4cIhzL+B+s6GHzgyWSFZxp4K6yRbckvj +SVzRH5LrnwDAy7hQGLCF/7lmbrhXjw/mm1xALt8Aqkcx6R7vUpsgJ6DP500IPu/N +i/ipWspdER14/JBfJu3f39JS7L79ndlRRrK6XpYJCzrF48lKhrpj3fprE4QuGMqq +Ws4zG+u3WwuPUfookvepTftiZoQKtm7AS7Qs0WRKJNUUUf5F5du6COjZTjcIvZ3s +BgGeDJo6U0OfT0npKsXtWaFfgUjv2XdxCI35+YLVD91fzyfTWlOq/Q54DFrfDSVg +IgdlD71vO3ftNTBZUPxj4WX71X4bG4e978JpnkcVrhcpQpJuopUjUz65B9GoUEPi +uT1IYJTuR/dYaCByfLJDLEqqelUyn6J4mw1BoDpq7M5NKiEfJBRmjVRgqvUXAyEn +B4SROxwjjlN9Tq/XGz1D87Jv62xagWR8VT54wroaNunYoTGT5hDAfjnxnwUvDHLJ +L2u1EBjZ9RbyXAVZW98sQVItNEIQi657WGdrs/SUj71VQbflER7aqR1SR26CuWhP +dqaMi6XlQmHPc2wpu4Cg3DiCEfCFkdsmgGU6XgeAf8ZrxaaJAhwEEAECAAYFAk3N +MikACgkQhlYfRSGA/P4RXQ//Y9BgU6xA+bRMjqZF3/syiu8R18Nl0UUSqAq29uBN +PHS6XSgfkqhoYCSZNbNq6GXSN1yf3LhW3bMiYrS1CHDnpePIOJkYhRdulqMmOK8p +MnXQnOE4aXQTfdZvMhg91PHcd29BiDMKlOQftxnFsNIy580/xBF6wbXVjRR+fZLQ +wniKrrABiPmSTsA58WRVMzi6TODbOaKtvThaYD/ZSZEEAOsQspt/2m5u1XuV6rMh +VigOCxufu1RuAaD1k40x93Mn9hNIjDJdSNXluVytiguUotKenBgOX3UdTCfkJrgP +WHdSeOdsqti5tIbDJA6G1+1LyBd0bwGFmEr8QS9W7JxcGok8tvYOT7PIjja/+98v +PoizM689nRldC5D6hb0VaZhEtBkTTkgQzJAGxAjvwctfHfndi3hoj0dfd2btY2Pq +D/n/j8aQPSkPlpL8moBuaOjjjctPqGijsYEIMhpM4pLV8qIiwpnLSMsy8ZvBvng1 +NCMlTaHJ5Ex/x/4lOShPTdCU3KDOx2/+1rUsTwW9WvCmFCfxSu44VuWxjG9C87EP +f7byu00gPH/dheESYIrwnoso9yLpXvADBkxWPxxtUVjuAaf7QoFRI0NzxbjKxV9F +jRvop1p8yX3uEeuFn5OXga+Kw7wtpoM91lSinJgn/8fqF8Fz6WlMlKcsN5pGCbhd +ryCJAhwEEAECAAYFAk3NXXwACgkQRdd+njDLGxEFShAAs9eS4Oqd0WDxavejNsKr +RRi+l+p1zLLLgZtCdSwTvpNMJIM7kS/DWCJQlhsDxhi7dbgaPiAf2IPFpfcihZ/n +P28havFq8//Sv3ESkgZjWZ1dHs9wxJbyWfVtZadkbyj60lmB5DGateFdJRzaC2ce +9X/fFIh20+Nd43Fpw/i7a8z/O6GAN84lA/2CK/JaOHDKsgiq6VX0lSE6pZUwgBi9 +aq5oD/7Igk4oBW8x2nLozl7a2IFeF9bzdHo4HhECYCpe1vJtzRau41GgA9DJlihq +e0grZkGBQ0oHeSQmCkcLCDqStxmqrlQVVdJcNiNmutBmI9zq2GvrLoQ0y8bimPls +RmXejhwOZg7Y2sJXLXId6I75A0P8OGqPgqk+qAbF5ugaDgRe9Z1QRoT7uMCIj3/8 +N1864D1UhpmsVm4LqbhR1TXe04k4dIrX71myXjda+bsfrPvT1Dy9Wp88iMnySlvP +8S16Jn1XgS1kdb2aZ8aOG0pheCbDl3DMqCmJKf5a84/MeDDpQq6k3htXh0TrkiiB +3F/LV2uawQQUYNT2D8zcTUH3yiocGinnOPC1CzLZl9gxleKWuKHJ1mSDx+BlcSLb +Q098jD1y5nDb8W9UL6cm/ADpnJZudCzBFriThezN7QGvdyxtXImS4p3CkJRwZRV1 +au6jgdVjT8irOteBGXNfexyJAhwEEAECAAYFAk3O/wEACgkQYAQmoRj1+84XChAA +h9mTIYholOHzeSJYCXDrxC2LtNxo7LtGTT6ibnL+Lcz8C7p9btwobnz0rMfbBU9g +8vCe80xpW2QbK5LaU6lSsRsIDSq5Im0vKjIyw6lUB+J9n1u3BDqcAIn4a7lzYUz3 +I1g+/letXDS56wdSWAzubRUn8oqjPZK+8Il3DEznXHgA/IH2ZfuZ1KRZUIt8/ZlN +EOlDMYONH5zkiaAM6lhQLzZQLlP66RtMrQwqBm6nkcsuMZ6SwIwpGirfbr3rtwaF +fgWNFYrzNkK7HtLfLJog4qa2zj6xjRR6yiaMqPLxO6G4cKCdYfFGeWqDkPV4wLJM +5pcLaclnbWSiNk7RAdv/t/iegqM48PXHycHMX5dAyk/sghyKkm5+YdKluuSC909d +SvoZaLJ3pOn61zSK38uyUtYByvmU/TJpn4syCe6SGzvKvKW37B2PgTpO3WjjEqyE +h+PoUFKunR8woFPDYoAaABJNIA8VCr4Y+TR+Ss3MecZbYxJ+zE7GubWkW8AFlQRh +fRnkZjpES8cHLnnCbwbhSLGgeDNy1jMa/oToMBbvbcxWK+c/ddVSNRBAjoQ8t5pK +GaVTlKIE3m36xYPp8tyZ6B5PyQCTw2ERI/aGn7V/lQ7FceeU1jw4pQmlMmLLw+4K +jmjgGc97tQA5qum93RLOlMzyI7gkHRg99foQlrtuwuyJAhwEEAECAAYFAk3RdQAA +CgkQxjiXTWR5LWcZ7w//b+GSC7bDf38vMHZkDYQ16biq3K2BdIr2A6VTkr2pe1tT +p1ywCyVPv3HpsZq7KL/REh3H/PyoUAybhagUJozb29uesG6Ykm5w9wu8pgij/7Z1 +DjcqYvKv2/I8EbCkuriZOKLvsHbavM+3C6VH1yu9kqTrmwrve5d09xPprBAsTCJT +R5ZE7ErZdlcxzJMVzMLwsPOuv1HjeEcyqCJeMnoP7GcBKsey3gZwjdYdOpsXb2RJ +5ewO0FFHqFI84fq8zNBml7LJoUL9zZtW8T1EgH2hSocjXLuSfCpNkuyN13ttqXQv +B4n81qTUObifuBPatOMKXIyS+bk9rudKtUK318CAMaTZuHNQuUFowiV0TeS0SgHZ +o/dU29Qw2p8G+x0k7MI/FbelaOv+HVKXCIQEJUCfhksz/auxGMv5Iew3asTIao+Y +v6LqAoZJiZDah7rJJ3fwtFuyOxHbsKzzjg3udajxDJatnncHdgXzcmTexh6BzkCH +ZuHYnOwhbS157Pbak0r9rGBeZOukg7KPDt/3ku5S+gHHb7Rx0iJNxLclWl3acrPU +N43ltBC1iW2HcoA9kEi3a3aU4hTbQI12W8zTYxGop6Gw2028hOGefJ7gLNZve0jv +jZe14IhivOxtbP271hT9i/0ZcfqaCPPEkzQOPhz1t9XSDg9aLh9pLM7rLpwd96WJ +AhwEEAECAAYFAk3UEKcACgkQ41LVxRxQQdQ6DxAApSazP+Th6aEYbJ4cPa4/KxTV +QKGpcnyq6I44qiQYyiFMWwImWTCs8U6ZQMNuWWso7Shhw9On8enpShfKqUYtq0cn +oAN0fe6d9zMlFNtx8fRo8UYO5/oXZ21wBSBQA/Z9+Zg3vCoyzFYf0IA5jek/Ss5Q +3gk7qiDH61oOU76KJGjToSzPXVqQNIho5XcGDsf0QjaZhz6wp4M9E3ytUZ9AGtFZ +9xVaT7edlfpPbI78j2ctOPztna84w96p9Ndos4AWmY0SQRu/rnYdsQocBvy/CnsR +F0M2PIM8C+LNx6n0QPRGINKCd25TJwa14Lf0liV4CtYnwkqnNcqpqroTwcCzL15D +KVsynDaeDo1C5ROjpVSfEW2AwhSt+eHc0NuAFOVYgNoMU32Zi8JuUchMRtlBGuN6 +eouVTPkNBM9oYn6Q+ixRrTzBNkvrHL0jl3yBPQ3s7ljK/bl7fyzOB62Z2dpSLXhX +Fc4t5QoCDeln6Ww/Te3qndPD00J5ANfUBaTPagRH9WfnwFmwzTcdVwwSJe95yCIp +9B6jvMML2DE28fGQnKujqQV2USnhw7lRBgkQoE6GxqM0s6/JNvFnJrTuK5tMmF9z +2wzzRY9gUAaG1j4UdodTZ568w77WpUHxEFh7G3IalqAu4QMJdDMI6C4o95Nuu0P6 +g11cigM13nDDDQf7BxGJAhwEEAEIAAYFAkzK1fIACgkQnDFQPG2GY5aRHQ/+OxW1 +DeuIKmDtOwyuWbfM0nMvxBVlXGsIPNzWFrHo/upzDxKRqQG/+Op09K+10PBluMS7 +yTqPe5FG2GhwMWvFJOhGBm7yfmOLIkdJt/wr85NY0nCxLY3hCA7JjPYIcoC5+F0A +WZWng42urk/envtSwjd2A0yQGYRoicJwKBlin7MbG4DIf1G+Nun11g9pAbIm7Hla +JKG1/3fpJ9wmtVyGwGzUEXXpX6WEVXhKvLd7HCujOU9u9GEh4FeBH34hcaZ1p+bm +Wq6705rzpEqIb3IZaz51r6jqYV+7jz/WXtK0WmK1sUG7pFkF7N8hgffw3qk+DNC+ +oEyqFVroPqyd9ZhxIuuMqsJhMGMftBJdznhBSdXOxk4mxbraC784qL0Yk9gmse5S +oJxeoB9J/W9nZbNQlG8qAphUo7PQAz+BJX4Yoy9+TI22QnCwnQyXPp5t7Xeaqu7b +EiapqFMFVT11JGAgpaBoTGjFAKtol00vGwdxvc3Pn0vzI6Mxaiwr8ibt8Ng8CRhx +eTNdz6fu9mIOXLlcDQRm5ftErufn2cL0b8BKKUIDBNW6OCKA4mgXPv90hUPlAYps +VbevF83LPbGtttRF240mra8fMjpS9MBw3LoXyV/PfBKS5fn1R971HANSMMdaFAPq +KiYfpdCHFibfuqQzMOh5yXxW9VSy2dOVC+xtEPOJAhwEEAEIAAYFAk3NKS8ACgkQ +GLP1D+WSPBizow//Q2aWOzPoKtpKW7WQNSyJNWA9xTw6Ng4DWahMBWHt1DnNdjxy +pnRtI/F11AicRCbrPSHHb7RG5Etcnq5z1GHxG6BlhgoOYqt0UuSEH82uCB2IcFcO +kNha8vSWijsDzRcoyT9fHnBQwyqww4VAqcE8W2Iao81GnY2nGEs4NVI76TTiKgiR +jNdk3SygNAJOSI+Opzpf2y0pyLPGNSnUvB4UvFzOyXFg3X2W/UBxs2GipeZ3vbqq +y9fQuhoscbH+xsABOlW1Rn0hM8iLUqPW/SWLtAp2T5eg68zmqnLhLCEyKJ6vhfNS +WIwAOS5M2Ny6LGR81ukbY1htholELGMKFsaJJivapp6tRgr2dgHyW1mNLaphnYCw +4vT2YO9g0xdxQNpHAxuUEJOAMhwB7iCQ/C0WCJBO2IDf7KpgOZBHlTSi4vnHIMZh +FQzFsyGlxgjTJYlMRuo3xphxwvYxcf5HmYaaHGasDvpFwqUxDUV0gRQiMo75bcZR +YX+ykrYGKS5GKluO6/Q7xUQjjdEj+7OyocXkKRhEtebzKX+ikZKqDrXrRDoLBAcB +3PnYXwtyOKD8pvkmPoatHBInz7kDdt1qzA75OomQCB+4X6glLx0KyZ6wOH5DItu1 +CrLaH/gCDwv4Pznf7BBwnWlqgKyMXq8jtg176/qVkPWKy38HdYb8dUS2zYWJAhwE +EAEKAAYFAk6yvRkACgkQlzJd2Pn91QYDEA/+Ia9J+ENjjU2HM851SWJ6+8hVB0c0 +qiB1bO8ggjWxEmSLavTIzLILlGcWAIEXJNx4/Z2yBz50QfHtQA1D2bKDhHspSHvM +kNKkWiIOjqCetjdqcx5xvOxZ3OHCnmnT/xsPs3OZ9Adl9uH4xmPlRfV/DpHxJauJ +0FV3yYO4L42NIMx7nEIvgz4iqXODzQs+6cErMrYodcTLHGHoS94nl+VjvNean1XD +CYomw0HKQ6SabiCNdMshTRCjMPNcoyq4A/0/ry1TX2cVvSQ0LWUcv931VCpBpxYV +dlEZmVp4T0BPrV2DBHoYy5uZbRiFI7f2YaknrQIf4DCrBrq3zldmpKWjucY5tffJ +rZPsG+F4lw2fsWp/k3ZbD5qxt+fannKiv0kqrQDVCt+e+du+CndSCDgiJpbmMnle +Zmo9bqXTZcluALpLgT4l1TleXnDoOPWcXoOqUbXPKWiyh+qcj6fHMuZAi3NSLMu6 +hbAb45j5m9kLrmHgDkc4yKqDsonNZuG1qsxzGXH5z3aZNs+jDab5t6iG1o01HNYw +N8UJWd5LtjBKu2xBG4v/DR44qppmCEBlDSF6bkNOfzI/NUw3JQDd0GAEeTqicGAp +K1RTnHuWxNUG2qMZ0ISQkh7x2ZBhxWJUWik0+mfi/xlz0UyIG+7Cv3gq+GFvzGnN +C0FSvENOIqRdG8KJAiAEEAECAAoFAlFHtUwDBQF4AAoJEBJfXGff6UCEBegP/iXa +OZtoTB5e1Nn8+7WzryKbNoqzTRLm4zpwtCtP6NkJjVuIFEB//peMqFfSApj40n1P +WAqfR2Y7NIXoRZ3sTyjvB+qf717OlsXLGpoe3qdnvn4CvKoNM2H0mU8o5q1kYAol +jla+9JHc8Lj++Oup7RerYHf5T9DN/evUXN5N1qcdXaDfScsWuR+95O3h0/rjIvoC +CmwcQEuNHl/Whc2RdVhpDtTp5d01ABjxnwXAP/R5vOhLu89EQ7bcF7bDrkU3faFN +gonO8VSPMo5AB+sEDFnjcQakCl01T9Sn8ZkGROKX3hRBkGJqhAhcfx8nst++QUGS +8duIVvI2rLh5+kWCQ3SIY8w4T1Pu1ZDyVI8MFeaWGIl7783JXzCxToiantl8XzsX +xBMvWcJg9OH+WTyDWiiq2oqQzBtQd5yXZTReY82XURxhs1bBA/hBEpLZVcJ6MEWj +VHHUjp+aTsNcsXfXfuG8EUEJuQLhq+xOwJ8vrLcmoOc6gt6vmfVC8smh6ubK6Ezt +YEI82gRGL4r9nhfiIryrc6bnz6IOldMn8dPR06S7Hbu0ztYt0tdBjXdSYkUOtECv +CQAunvUUxTfEUfXdy7z2HvCxFKCqULWdARxYrOuJEf0CyDcjr4W3xqyz6ubMc6V1 +QckfS/pERO6WIa9iSsXggXCpeLkHfGLo4fm/BPjRiQI3BBMBCAAhBQJKC3p0AhsD +BQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEBJutWOnSwa/VjEQAKNySwD0qIw0 +nfAxGNfGP74kYw39RP7sTjR5Mb4sphbEjk5angZyjYHqIdhYSsvjDnBtlHZQH+Vn +k9nb05erA7TeEu8zb7drDUPXJJhROcJ1mWHxz3SV77Sorxc7fg7n8O1iemvrwB8T +62L2Ise4x7KhYuP5JQ9PRD+BOPRlk6rHjzQKxEMPvFLwFY27kpPgciYrf4SkMLzZ +XcpgyVZcTl9ZntwfnC9Ni/Ipu/TFLVZTrzZCIA4JWbr1k2Zj1EFmDIdjvXP/2bO/ +ZEP2zwfJpxjgW17P1UoOkE8HQu8zalsTtE74dPAA5L5X6jhTGq8h2a/LQDCGIEND +UD5PhXXQfrmQ5mHOSyMhItwObrHW4RxBkZ8eB3nk3GPcFCabY4R9fsTU9Ebhz7tE +VNJH+98qBfakleFx637nOgmdrFQKAN+OvLRyAqbWA9LrClmyI9zCHSwj4vRfUp2l +LNCPrhh+Qm+k0HxK+IcK3nDv1zFVyLfIi+j4EkKiK/25Qb7H07bn7GcLxNxgN7FS +pRvalMJoFJINXpkRr9WyaMBQn9KKFbjkX4c6R67qA6A5AcSoV3TF9ZjeXvGf4DGv +GZPYudQb8xTX0Ctub8TQGXKTRglfru8gkMC8xenvMz+280lNGKTnwHfJ49dI0+po +CXOaOTMsMqxKC64UGzKxKZVLxuAVlj49iEYEEBECAAYFAlFHfh8ACgkQmc3qnaQT +Wzg1TACeJiTLq2FKIaG8XSmPalVqWAchduAAn1J20dsNjaYmNjeXVkB6vOvnYTNf +iEYEEBEIAAYFAk+tJLUACgkQ9t0zAhD6TNGnOgCfSUz1G5+UB1tYNTKKkq66OFoT +oPoAmwdE3kv7gzWZNvCylxhFHBctV9OziEwEExECAAwFAlNVvq4FgweGH4AACgkQ +vMseJzFyYtIcgwCeL2nR8hpne+5qHuxTDt+mVQiDG0IAoIR7OwuC1Oo6gR34to4+ +rVdJXe2liQIcBBABAgAGBQJTSY9+AAoJEATDZ8IYrdT/xwoP/RK/I/jtFeLX2N+0 +IM5gRj5bkw+h3G7qNU2z7A8xYhHHw+OxVfld5TczMpPPjgnsk6iRU1+k75hkFwht +7hLXFe1JwzMVtUBeKnZWBOzI94CumrLXFuPDGy38Q0e+RqGselqP6sUd/BDkQQSf +LCXk6V+5xzQbQbAw1tESNAo9kGOsYC8p9x4cpHYcmhryk/E90dYpsL5KMxbEOq1+ +VrSUvqwm4sq4l99qaiwsLDo4FPkc2vjE38tq84hjeiJ/Thcd00I1im6d2tkulPzN +a90NQxM2kFjZn5pRWsWalQjn9Wflls4d7wmaGY7Taf6jHkIbw3E1PSLdVeuILSQ1 +cubFxD8vHEp45xVEAl7HhIQuFuv0PVOH8//yTHQ7n/OQ3l4HgxUeZiB7YkMGiy/K +KhNOGVsFnEbAaGxrW32JFHQfPXInR9BCtQWQHCCp6Da5zEvLe2gwIw7utz3VzYKx +qK4rW1Jv7YNMLtP+XXh10HrAXbetIvydqYaX3v9k1KEhWiRe8OKJQrtzlbfBckAW +iz1YHMhjwfpKBGsgGxtVchMq/swk5/XGa+gTcKYWVKK4yfezWwnudAo+gvi2/+lN +52eruQ1YKQ1jJ6Wj/tmDK4f5VGztW4+NN+UygmH4I8mOSTEVEqTYvC9Ak0nO81XY +SQqwq6FWPaZHzXOeR5abz4CDQGOxiQIcBBABAgAGBQJTTZnTAAoJEC6na5wrRm2d +cDQP/141VcIg3UXBVqOULrRlANcBieinMgSCbbC/gZnmN+T0o3hQLZVR9tpMRpvb +BHddUD7WqMCmrBlxLPvys95F/n7te4MFgn3XiZBnDFfwYuTzI29JydqMQ4rWsV3x +T37mMY99lu6OZP3oRutIPte9Vg6zqUf6fpO8cQl/79dQliKIOn0yjQyROw7h1hj4 +jC0VVWhgQBZWHwurgf3jyHjdlJWOre5xR6ASx15QsJ52mS/LGwycuqJwz97DigiD +yKewfLe5ZrcJZFgDYHJuOhJjyDHQERdr+DZgRx4XQoRWOn/ET4N3mcNZlQ+tX5x5 +q9rKOaO5RXwysBaIWxWzkmnbGFtpksSoUis/ZQnbJ/6XAqLTD28Clz1V0MZKnd1s +3PS3YeMWrsssmil2HrwzZVeiG5+aP33jiwLTSSeKv8Ku2t8qiYIJ0Op6smCySgqX +YDegJmzw2YatrrUdST2gTx8hZ/3Uo/8aLxUYexhHbThqnCUG9lifzh5KM+qUNNBm +WIuGyPIhZxp73H9qRmmL72yJBJP5mjYowIzuTxMSMiPne35/xRoPGywPjTYul82f +hhCBf07YwDuwnHCxMcTBiqlSIH+WLZih23aVQRP2IIuT3Y8MaKKIVd9ci0PzlCLe +BV0mZHqMYWyoMo9UMhVXlVraldbMpxNz2W85sI8PfXxbbwtmiQIcBBABAgAGBQJT ++8BKAAoJEGSVn+mDjfGch+UP/0/JZbMEz+1+jkvg+zYY+dddUjMOfVO8ywNsrii9 +oco5cyXbnyD96wXFtaEodHBn4F8Sbb5gQ3q3hNs76KA0tbEOCeLFlU+qEP/9NKkX +0V1YWhGrciKj4p2+4xI6s1LicHOwe0/WZwCGYJV7chek7ulbajJHylj5GyaQO9G3 ++SQipJAidW/hruUUNSKypSQUaqS0udEVNAN+LrFqKP034m9ho2EAaXguLTAuG9m+ +XHzcnwyuEF0EiNSPaKc/TmJlk2owlPi7wP1axGS7QConE8IWHL0TFbztiZmVMbKs +v+pmKphXA9q94LziteBMhTanbkJEJ2iJnyseGUPhZIN/96CUF3+WL3ASaQycrpRy +ydWCfivM7D4+cQREJyUldcV1QHu0X5P1pVGj8JZyQdzgb5+Nogbm+wmu2CbuCGF+ +CF19BLoNl6Zq6wakKQTHbJBdSxy78Gt7pa3mpZuu+st4hygT1Vk2oGJz5BpOURP0 +ft++JZYLFsQ2XRn3yzZG/4zyj/DGzXPB87IznYha04qE/MwdPr7vZfJK8heY10eC +XVcyAsREj3xkmPb1bxPyu8cxEwejZRRpFcepOHhTj78EokWZE7Iy5V5cgMgFqzs/ +ag+ktMqPeN657eYjVelQZwToQwFgqE34Ucbplbya4FVykR96dPd+vhMDiW7Rb9W6 +AgNIiQIcBBABCAAGBQJPrSRhAAoJEDk1h9l9hlALcg8P/3+iH6zUuNZwxXHFGhwh +IENkoiJJahdL1vlf4UfnwosP8wS2f/gFWrlcqs6nlrhQIlg8g/uRhbnxWshUMwYz +jKFC2PhAP0N3s8PUA10PWgf7OBFIL4GGGGW8bxnQVIF4WO5Zpm1Z+ApsOfQRZBT1 +YudKYyTLKxzEpBNVWxQAFIbsBmEPkK98gc/3dy5HdMm2fclE0yCvQ9cyhlH9VxQL +DQPMk0TYioh8BF2GbKFQJ9hpH9FfGc/TaAuObb3ABZHxDp4vipQWuhLdsIWMI0x2 +pov/NPf4P4vA9wrSleWJe7EJbEaOvUdYNTdg2ejklyHQVDUvMf+7pb8c1pPqJ2Jq +d13ReYqSCzDf0p/z/+zfvZuhYQTHYaoXGtT/6cZ7y2i214qmoMCIBabYoX96GNzQ +/C6G8m286sKFsvqqBIKzb6w8i9c7bTUZwbmUlvbdVTzTldn2LaYmyh4Ki3+dJ9Di +WoUVe5FWOHDjK0QrXii4GQh4pz+rKstSwP7LAODX9VkStiH9i/AAuRfbYkKvLQ5u +PJRsuQILLYeIbfZ2fzQOFq28o6LdUCiL6w6GCBcHdmImhukWOesVWj7WUqRWnMrS +4YqujAaAhIxMLnYQ2K/mV3P0Uwj1k1h8W1L+pR+IZoZkqok/7t9vX8MnAPCCO38g +pR9Q9eWmz+J/QU8vOouOP4q9iQIcBBABCAAGBQJTWc2SAAoJEL5c9ofcWrfCib0Q +AIf16+0FJxj//KB5V3OTYZbBIC1CRgUJP/JvmEJDECNZ1U8vjiu8t15s+7WEtbCh +YeoCZVJOYDQhwpvvSu/hoEE2GEQB/LTDeaCCP7g6eMJLnMVesCfDCNsFg392Tt0L +8HpVNSQXQ3W2I71j+BAQCi0JKgIH2PgGG58rc+Bdd/47jg6mpMt9dFHp3K/bEDwB +HmmrhJKB4xTfVeCj2MY7jQKQGMIEDIaN8kA97DbNzYBZ8BfbpWRbtsCRB/jsRNnR +yrQWyhhnhRbHR5+gNW0yxApWBJFIcN9DoCGlG4gPKtyGIkJlvnw20e3qZuVk9wlw +nmh8tfy2u9PW5l/Elhk9zW0ACEiWjZZIrojqj7/QSqr5YVAvTsPl53JMQTy7ggOq +nK/u8IbghxEfqY2QK9DYcloDYveSyT6Q6O7yDbLJRTAUlb5X1p+jwOMv6pjAnVdG +SODDMfxftx1XreBJ5rVCzobh7WsunhvBiCE197xKYIjs94tioehapOgThkbXVSXb +ND5sUvm/4XjsKQlz40JwWDDB0DRbQDnXdjj4YxShPmE6NR4uxq8f370e06Njo8gH +mYER64sRr/PN5q3newxYmVGvOqsE9ceYy8RCFGm5wd78UTX9FD9EAs9p78YgoMtp +8snhHCJLTNzDsv5amSiVeyKwnvyRCEMu1hlxzu5F8NGUiQIcBBABCAAGBQJT/Phd +AAoJEPpkO6YdInr7dOcP/22M8kDrtIAE1DeLgA2isDhJPObxSe5OfB1mcKKzCijo +jq6ijXRMVR8ei8iaAvNjaxziB3GmwaxsFXuN7zcdH2NKLyDj4ni9Lp4nUWCdXpRJ +900OmwWSpgBgpqVfNfFIKSgLQvdF0BbkcOntpKc8KIhhaU+rEP9wzqmTo+AiLSVh +Ho78//Fxks2aBF3vn8upJvAajQ3tMqr2GFN3lkCX299RjESYrAp4Mr466inDVbgp +YcYMI4alIHHSQ/fngMsaIA+ZFqAWTnyJ1a2dvWrpeXfXgti35j12npWWP+nlnYPe +V+gzT9gkarYSyMXKrGegwCOQrb9nT3IRa9R/32/deCIDBuRpnqaRDGmVm1oXdjsV +NSwCZwB+P5XwRlcmsJxBGhYKyJ9goHqPtUXwV32Cozj9gCytjn34zm0Pma63BCDu +ca3nK0P6dYAopeSXh2P1ps/GOKfs6kAa11Wrz2tkleu8tf4b31tp3UjLAdyIOXsy +U2myhkP89uYY6IkuTU2HTUcio+Alqf0lfzr3TR4diOHkeR81FekyyQht9UTOut/p +AHzM6nRzSn3Q/3h0Q3hkPChzloDF1oWNys+ZXG+QuwZbvxK+RY87XWhPtsHbw92K +8WyokIaKUra6OtznZqkJ4gJ/De4DXjD3QWbYhu1gLKT7UGSY8Gcat0DGnt2b0D+j +iQIcBBABCAAGBQJUAQfzAAoJEE+gSkySV37E22MQAJWH+iQX/t5U5T1eazJoc20b +hsPVUArBJ4sdKCW2XQJa6N7ecAGzBdNtH8bQ1uK3oSvJFiIYXXHgmIThE1/mRo9O +rKxcTZIzSk8b9yigdjJ/uUDo5LoHQzptjOyx0bvw5BkwNO0y6lZsUR10w1W17sx1 +L1m9AyHkgZJ2V5sNRvc3yxkNoZBqQsn3v6DaG2UzOASaHXX0SlBXLAJHT7QddUZz +u8wQ8D688JkY22aZbEG/ng4e49N8FW4nzCH6mbXwNaLndCJ1S1dKU4cB/15LaKw8 +G4pXwffUxk6s1/b33w9Av1vgqTccYY7yS8bOyQoKreS2L6yzXuv38cDsPf33433D +9/tBkI7tYy47Z2JrPiUZmiz3dLIbvtNPEWvnyL/rZ2puWNNyrveXrImwHEfv6u5F +j/jJU4iirl/3n0H5hosMFRAn4+GnVop1ksKkicuXcp0sFvuoRTGYZneFb6jJ8MLT +4PCsgD6N0K6oxrd4FcLt8rlX84Y7TyordCmkENa/D4U0RWxcoR5skLYW8VJc9mjV +yb4YQnc8yrAq5HCEarghhd6zHy/iMhiaHYA9Bl4FYLolpNSgRIHYWdROwnLBzkv+ +U/CxhxO6EAcE6rSKRl2fo15Xk1utSlNPdV8J7fpTlKn9Hq37zMhuVGzaSRk2c0L5 ++PjIRGwN8LlofxQgwA3AiQIcBBABCAAGBQJUA7LCAAoJEGc6A+TB25IfXO0QALHU +B+xmoCrXPOhZRHGsEdoZUiLZ7Wyj+lEPZQfA5zCc5nJ7oQABwgMRlO1XD0p/iAt8 +lMTyN9dkAvUZAY7logXIt23pY8dYbLWeEHNWvwRBQgKjyH8z240UehaZA5D0P17l +XF+e325eStdPrCqMMw7yEP1eHWBIkC1//GCC3TEwL+8gZEj0sTRhXwa3aWyeDrkh +o+uVvepKKb2BlTM0+bv/WyqujCwz4GeE/M7dbi3czFbf9wB7nz4DmCxki9z0zdLt +hwh/KJNqPSgimAm+ZDF3SDF/vHyIKAlVPXjVT3LbRVqEC35MNsZSguQv3c/cTU52 +6sPauIo00DWwrBKc6IJT38RJl8Kn7f92ijW5E65oXe4YxDxorKT2TVGsiIJMQtNj +Y17LVhxwbp6KlzAPkJsFQhHRFcHEGGRD5hxtBdy+SG3+jFnciyo/X5YV5xY3qLx7 +x1qcc2hUYXoA5H2KaVRLJUTr/IyyeMAR+SMpUbCTACmsiNio1klPtzaLAvrtUrLg +zc53EiRxtQjin4VEEhBxqB87vAKzXYiaozTy7ypHuR4Lrm/9PxpU+/Ls0Bdcq47U +Qs6gAmw3yQbtJO2ruwgjWeGp8z/S9u6RaSLQWdeT7cS9L5t1PlLHvbXwwMLU0LCt +Gs2/1NV3VzrMsalwItqyBRhDCu/zW1cLXTDydLjtiQIcBBABCAAGBQJUBRwmAAoJ +EMD4hkzaPQNY9xsP+gO6hHIfnDV6RaYjs1NCtAkftbE5H+xsmxfNPRvO/hjpLiws +ytKBk9TILmG6VpD0pCzB2EiIv2++69y91d26qmSlSjegl8pTgsq20PvzK7ltdmkC +9K6gIykB7FeHHU73l/Q66iF7wlwHhvTvAM7c0pE0jFn/U7E3QUWUjEDAvvt7j37Q +Yvb4fy5pYu2g2Jj6Fovy81Rf/7WEmyNGaIewixHSjdk66QF+qQOkVGdOFGNzLGJs +2z6NqgjUMwCTHr/X4tEfeW3gveBbYI9l5FV6VUXhWiv0oaA7xy8xE493C+1BtaPO +2G4D6V39ttZdvVj9aVSjQkMUidt6NUoQofmi5HiLEZfwe+4HXNxkOvlAF63o3U9S +5QUkIe0cdtA8+xa6OzMfVzqS70A7dq09WeumFy128zV/axRSaHBYLtOiMEw8OA/L +a+gYQLBzimQMkLyskdF77cRAX3QOdM+Q8ZKyAgxc+A1sTJdE1m1bIt9Yqrd1P4SL +6rGFRGn21oZzLTVoKbjvHmNp5UkmkWF8XY/9ruYXa/Z2IkujUAZYfHYqwluV8s8b +jZkUvDxn+mZIR8mMBxLtIFRXWMJuXO+5gryyRsnaVK8+AwUx5Pvh/dsrZjWgUWxo +hApnbegU/j+IWKkvf9kvpocFk3jqztxslp+x6lV0vCUaGoaCEJ6xtxKBF88AiQIc +BBABCAAGBQJUB77kAAoJEDtW4rvVP9yxCTcP/2QWALg/blHhKEIrh4CGFOXg4Mtv +jr6DrWy4NObXu5Y2XtBZZ1eCywPgzMMfL9204MLkRMTl5zaE9+kqh4Lmx/lOGP+6 +I8IUCiRoDGhKzXjDwmbg+a6JPkdQALH9BAghMAdI0LkUXaJwv+Ze85OhPQBKH/JM +hKVwbBBjrYld2iLuIBBuze0v8JgHR5x8w/0Qe+FQPCz0ID5+j7HF6sxGJe52R2HC +eF0wC2OFMM3iC1nG8poReCp8iS93nXBOGLALunY444YdQr3frhd5O46l4aU+yDIm +2lpUfIK9ZWAEiblp9IzRa0EhZc2T/nUwn03OgNduq5iWoiMPFfc+Irn0/nTcLzro ++/HD/pOju1EiRy6SCMPs7Gp+YD84J+JpmA7tAucHBSnv5U6qN+b5ImY/VKNofYCr +DWjAmISroK93mPGpnwKf2qv8ZciGY2VuzNb36oL0SNfK0JqgfwtUbXrShv99IdGo +BahrOoRxS5JVgDAUH5U3huJtFH50sjLPxsLLHdpXEnCtVCp3XZVPMIqOMv8+LpNd +VKlGf9LLCeiR68U4e9ktgcOSOhmf8BaqSTSGn48k8AhoaRMwzm03rn0jiAivGAsk +/p3BhovFtbe1XmGARoHyUYqP58fude2PoXIVbMR3k4icdVvKMckdIfoSn3ybx+uc +G+UZzoit7mOhcwJGiQIcBBABCAAGBQJUHC+vAAoJENkp8pkr7wozPl0P/0PJhEcf ++WSHIDyu7Lpn2P2xw5MVlvKMM+dO3Pz7Z4d8+uxKDit+w3bdIXNdgJfQkWE9kukc +Yc6pw/bTGX9TkHGPStL46iN8ELQVgVkLkEuCk5Brl7Qv3THrnB2VHfAruyGhhB0p +mW0DB0nyW89wFSqb1kNMCtqMyUYApllpno09MLq1wMaTLOmClIHzGPhdmCijYssZ +zVx8h6pwoliA262UbxOw9K/LluuJAC+UC+MRRnnESy+CJLvkXuSQQt4YarZ/qVHX +PO5h7qAjY+mzY/oYbrGghwcxLm4IrehbtTAG6s2BsefeLmYXR3qyvZ2yV3fIZ2Yi +HVwBRV8A5t5TNA3g7t4XbJC8IW5UbTdjwFFpl0MWlYWvuzeZmpZdlJVrydVQLUC6 +khDGu8hvCYEtyK0Kf/TzMY7zivoya4JAunx3GTWxcd1AFG+UwNUesrA5Y7+AKVEk +5rKC7mfsEQsFV19SWq19LhopdlpkU+0+XwnbmEIe91umNiuNhm59uJCLgeTlIreS +dFg/GDtGNYYvBx+QTEMKNv7SzqOftKU3M2z3EKkS/CHg1sk4kE/IKohLVDzymagb +2a5Kbetm6CP8jyA8+ZaeL35EmGkoubtUEuxB2Cx4hp22mDZD5ON3q9DDxbb9+xSS +wy0dZyLYSbx+xJlxcG8OzJWRQXrc+LIBn9MeiQIcBBABCgAGBQJUAoM8AAoJEB51 +mnJqn910LdUQALBdaWuz3qGarGktQvO93YwXVHjMqDZUaGdxqHvyKMemUaPm6coQ +3DcathArxfSfx+ovawxOSgaE74Ol5QoGi2i9t5nvxtr+j3ZPzA4PCl/rDdVVk5h4 +5pimbLP6REAhCNBrIxK8pBTncjnzrtyAy6npS9GCzupZ4f35U+D8e4PQWw4OBUAx +amib3Er57LZ4ctYZMNILzUWodzy/3GoF+PFpG2Izrt0FSv0PYh27lbyXQE4IdF9/ +Wi4rmUJosTbBW4bWm4mLjHELDNI3jnR18Lp7AInC7O3dLTKuTkCsRkXLjYS4BvTV +MFC0p7sYfPOyJIWkZYQSlK9XIk77MaL16q2fN1YETmw3m0SSM/DlzuH7gmhbfIpD +QauqFo510nyTGlwxOtXo308l2UIqtlBir0h79G1s817QI46laxOPQSE4wFzuuTyT +PDeVAeA2g62iDdlXzIhHztlzsl7D/xe22CaAEhKh18IZsI69LWxtUNmK2OvGYkEX +3r4WUEAga5Vnxa4KzIDj8RhszYdPJ9kN2cyspHYU8kJX1Rptu50w2bqUrLorP/kp +SlsYlwmfHygycWJUSf8dkQMHU+Mbq9IJXOHWNXOFDcFJIAW8wK+lEACpID3ZzaNB +ijp2lNzJPeW9WSuP8c12+kUl9HhIdMFxF3q+wpcWtN/gBKTrDJB+U8WeiQIcBBAB +CgAGBQJUBze7AAoJEANqnCW/NX3UnKwQAMBAkJO0tqdOd+rw5P+y0uDSaO7ZlG4e +sL3HqkylU7tut1bAU6L5eQWrqWBWTTN5ZlXaI1pwfS08a9TlD/plI+hMLx4nM+4O +R2d/XnxmL646dptSnb0WYxztALlG7tMyhTsitQyt7rHqeh4aR0gTQ7JS6jUb89O9 +303PJgB9s7xlcv1ttIdxtVSDtrcRYoBHkv+ZKma3n66x42nKbtQlVAJ+OavstaqF +y+/sXPXvJ48Zh2lKX35sXk6mj71ndUqxiINkC265V5Ie8R+Rnye6pQusjnNwDlSV +/cRq2Y/5kkRREft12XSP3wRZnJOrFSbVZseV1nH85UOyMz2F+Ih4dNcrIuO1PSE+ +J+c9KPITnSuegJ4mMz/CJ48O6PfxXjV0nwvetj6i3B+73YjLP03OKeigAyuSsQ2J +IXHxN1ipw376Hr1oKnSIZJPU9MNwOhdeWzBVSfS4H+3lx2mRLvrdhqOOqRssZWrD ++YLQOvc3Sb1jjYgyBzuSQLzyTMJbdaztbOS95j8Yuu7cywlFGrlGXJ/JsrT3xiwP +/0AImA4zctJCzE1dls7T8q5w49clpQRigongIA9z+S2nHe66XmvkkyEvsxNyH+lc +2yw38Pl3yEO927L/amcPy+Z29LuIQvNQpw7oT4Ab7mHAVg9R9Chpi09pFSFcCSPh +bXFroIIk5ZrdiQIcBBABCgAGBQJUDRsHAAoJEHUatd2nlnnMNYAP/RmNV7DF5l+P +ZbtP8HG38emPGPaIEUDV8tKTDW5Ks34XmruYfzaAD+Z3et3PENDCRPj3a4u18n/6 +RMaRkekQb25h/d67qQ7HZAMduLje+hXbAJkERDjzoTNv1+5aL5zHNY7JM8qJNRfX +sf9UrGq/ZaTJIJ5d8+eeT454y5SGMd3Gb9fwv/HduaSOsxfubEgPUkG1EwAzpvyC +fLMUIXzPUshsa+JWq+P8H+0MJ2EeuLhPQHxVpt0ga0Y1jeEP0L6R+4zBv1YdRIth +kNJrMue6UZmbLeALJfUx24ZwWG6/iB2m0NrKh3wGAbIdRhNfmqP+ATphBX1q7E8k +o5uq99Hzs9ZGiiM6x67AmfDmaVURe/TMEbgyIIZfWYmtnt2gXU+EazWk3I+ebOpf +21k+Y4f5EoOed81cSHxFXP0DFnC4o6XGdDtONcwVnSy4ComlP30/SXz3oZlGGgWN +P5d3fEYw3VViMHPPeF6WPj6EIRlhB7h8f5JtOpWls8izorOb65nk7VYzCnTBCcTc +RryY2Ss7H9X2LOmUNGzaOw9IYuG7m42gn+fW0PkehiklCR+ejmDYJ06eyL7aEOEC +ddv2rcuhES4Mn3zEIXGP4tqdRJryFAPMBdyjk29UUkc6t6MA/sp+gmIedkuQl/7X +P+ZfAlAnz0t4PBol7CCa9d6341w3MRVKiQIcBBABCgAGBQJUD1XsAAoJEG5gi2N9 +iWfpxEQQAIY7aMXCtNlyvP5xmrjG4pRv6l9eoHg43Kx7LNOb4DUnRtEWDO/4OAyz +0S38bp9TMjKN+8YZLXn+EZf6U+QTt1FoTUYRAID4bHZFHqNWBqWh0iG2+qTVYQ9L +QeuNRiCKt+uz7vJfvnz4MId8AK4UNl/LvxEEeTI7ZsAlwpeZ1ljFiiLQi5A3UDsj +FI/dBxH5eVAkCWQ5FYDOnV3H33vcSVqrS3Myk94JrLzBrJQgLdNlfw9goLIEdelb +6j1WiINNc97bxooaRNEKPopU+gldBtM0BIshvGOQKYKeNjdJeMfP21ciU5n/IqLt +ftScMFuz1HgzbEOMDB6lg9Tr4wXfMtd/75HYmQI69p2DPiBH45bIg1hYwSzsd/cb +CQMMyJot8urKqO3TkzTkHTbPNAGX7ata5k8XhwQhX/pU9C1sL0G4KyEC/ns3vSnz +Zhhkn09sHqM8qURL/60xvLje8uQ0SIt5SEbR95aHjIJQRX44Qrrz41Y/sKzzwGzp +BFEFM8LRYEDleYMQhieI0SRCAOgVSHNjkcgVK19XGB4X9jInl6lTnZa2FEu0q7yl +rMbkO4GeU3k76AhNo1PcjRIsrsBVxrI1zbpwJ4YuUoR1rvGE4NjnsLb9GrcFbfmF +Rib+dllDYHwojEGm9A9on2hwo3sgGZnWh5RWfkXDCx19hEOT9kR3iQIcBBABCgAG +BQJUD2W2AAoJEPs9JYM7aq/4LRQQAIN9eMetOwQWOuU32utSVMpmh5xopQp2Yw6k +iy0Oa+9YfDegu3xhr/n5B69yzhN8GT1ovLpOWlTG6hP8Fe/MMmGnw33F89PYfdRW +C9Skwj2REZVjp10ckb30ozdggaZ0PpWDpFvTqw6uJUClWhyJSSYbSpd6SQS+/Ku3 +SwB8NtF95odu+VH9Fx+kGIhcs1n/swWt+/OQ+L0FcpWp94fWwoDb0duThCiD+yVF +YQCM85zZ0IXWpWTme+8O4HAsL3lKOj9uP3Z+ew9qWtMoDPVGsltUP3PX/l7WuxKN +Fp1Ywf7ObNA14w0TUdLs68l1SZdO0Rl+BaO3FecMkvdXflhaAP4ADJXhJhVLq0e8 +4r/kwUt6eJ3ToA+DDfe2c6RgufDLyZPP9FGzcX2Mv3Vm2IzFrid/FmQ/TWMIeLIT +XNwINL54eydXBNXxmf/InuCmPn2gksRdp24DGSbr7MoMikgBl5cIbXyh89qBZ8np +okYxu1VQQWCYeSCKM17mo995drJ6bQvnFALxQW21gakBTBngHoaj3PzDM9Y31nVL +uydiCoA+dfxaitNSetgoBU1gi7rmM9CmWTlU9e2aJhFy75+UMbQBmsJdY9cn26WQ +a3S+mVXsqMlqIW2mNkxJGpTOaw8zWmsAGSPPxVzde9q+xr9gOne+UAyNJaaXzPXO +2oxGczxriQIcBBIBCAAGBQJUALGMAAoJEE+tenU4RVnbwlsP/AsZtR3tvE1TpQQZ +u31HcufDKde1W7rB2rql5XstzJgbNPOv+nClA55M/UOkOrMsfc9i3NLwy5P9Etx4 +cHCGHt8G8Pap9iFpH9gViJm2ZuPTADyyfO0n/I12smt3ehWuZt3yVCo8aS0IpueE +ueO8yOZ4PXql0NJOyl4rP9N/nqQQy3PDqx282A2nsiwKox883l6we+Ldnfswoo+x +jm8QMKwy6sTkq3aVyacgr/OO1uGY2jtO9xQwowPWTeS52huhXdd5zHHrAkD/YoIK +t2tKVCUwgS3H1xvpJh2js53LiqkHCHOTbky9YaZq0Hu03CByxGBz+vLt/Y3OHLJs +Bd1vQqaKYrMSVxda1+SNr/qE9rYM6JxqluvZvzREXSP4RQ6Rki6zEMDKCVXppvx9 +p/s+Y5qCU7/vOCzU30hRoX/dXiLdIj6zu5Yw5AP24Ks4tVD3s4DJIx1IywHj8eBa +JOyKK0ZiEygUTn2JNyGz8XQpjC1PuuIzIqP51gxIJkq8oX94fl6Z8/VlWhn91RJD +8aMDqfBFGLqeRJm7hULHLJQcvBWMw9kWKC38FBGQts6fK0ZhSEF9MJrQwEMkhFFJ ++lWHSbQaoTY2969cm7nNhxsH7hCRZCj7l+cCYGZenfc5njGrZB3lNk4B9CdpdeCQ +HHT4VmwNI9eV7Qv0sC1yIxx+FogxiQIcBBMBCAAGBQJUMY79AAoJEIh7YGGLPBau +he4QAIWB4eSl/g/+ClWWp34fVYyJo7tyEwhlSaNTtg8/+xvX0xo/u2kdxVfWoeaY +PjOWULWp0t6OE3j/jrdhP0qoZzJBRlCisLM6X1zAlRIPmIK+R9/HviyBuNQ1FxrX +4cFoNRKIfOilSSv1tC+oXj9p7eQ6UYzuLolUan7l6Do3aSqYfDlMlfrV5ckJO1s5 +ptTt3oB/A+st0jaThugXslUBJXsSeZi3xcw7UsKLjQhIw+qldlll0JlKlvZ3416w +nWd/qDtLc05rwXG9XXH38xyAbmKEDXQukFykMcHx4yRhFAuRroqAWyBc9YtXw4UU +dF8XULT8OtUxtlh7g/CVJiZVs7lPX8i6/fvtu6o4n1JUsuTUrWREvPl6Ry+dqCbt +ASMPPQo4uE/6rLn8xwbzGUp2jxfHSEYCmBEEeSXsr9yARjule2JRko0LKWu8UpaF +o4hupoKAYHJFd3pqzevyXzoaqQTce+U8v3mUalSw0oJ2Pz4rxiNSm1TLLEs8axfu +Uw9nyeLynV5LLjNmNMJJYxLiTPreWZUGWqlIJyfcHuOYfgzfGteiNUk14AvnbutF +0LIXRdsts1MQr7Ee6V6RL55E52IrI1QdSa1rYa6ahszZ6QC8cNlDUxe6WbQHMzrK +1XK8K/fYRMqD8YaZS9mZvK0RyCMSonsouA/vsiqhojxszyVRiQEcBBIBAgAGBQJU +0E7/AAoJEJTpLfkqqlw7towH/R11RBmHyWrdJWX5wzcjc+lbh0Ep8vtX9VH5Kk0l +dINKMrbuMD+lL1UPbqoEn72XsXMe4PrFbabt6U+81q4eGmZdG8iIBLPptWBruS65 +MJ0GpU+uW5GPJ/EYKDAXkqcton3S+pCupSSGsbPbln1ei1uerqLwFBf9pnwAlT9S +4boSqaM54hcKtSjCzWaWQ8D2APwdVYCqzTllCmZKTjElARj+6XRJJlUOHmYeUuA5 +AYb+YwEUnOMhLXPqUCIGEvw4cwwQ+LLsLz5OTp4sBnKAlq/DXH9ITKiM1JcDcfVZ +XYaXmKsbbUS+TdT+lGd2EIurvp3tAEsGJt28+9DmJcAyWdyJAhwEEAECAAYFAlTG +MAQACgkQw46BYKF4Qf4RcA/8CWg92OQnmCEr3doQbGN8bhGZdyo3zh4smksZnmVO +cNUIkhp3vDkNGQ8DYVjd0XacxjS667fnmNaJMNmLb9wc9thOJuoCtL6m8dqUsc5U +y3IV/ctjbloHWC1CnFOqWmorAUGVLCqyR7+Tq3PD39Oopy9OE/Jck/kHI2CQhSja +9QqyyaOjmgE/p5FbDABg4N3eXdCdqkSHYnot4TJh8Kq5RIYjpO6etJDfmUxn+uJL +w9Ya9MmmKrkrJpUdJowL0NfmNpvJwrMwTp4qzMJWLWF96HDy9/I8fT1mreq4LFOs +SxyZJtt4z0yMpmI5hWKZxk1PB7+iwr5PYu2K63Bemo+XlZ6mHpepZmsgs9rUMeTD +VTGE3gvJHiUjDi+egmCOYPKg8TNxr4L6ZtiIOT/8Y3lQmvz1KXKXwNwzelViJf/u +zKC8RuRmNg6nUfxR1ilH0EHuHqsdssTauc84BUxs++cPDSVY7TdG5h0XptjkyJWs +CwKURI0KrNaaWcCZP50pOL6n6ifPFqgQfgE5uConRULNokvTzVSkzkrmCcfXfb03 +g/Ve1y//nj+GLZSUhYmYeHXWc5xT1QH6oJqUg8edsk3mHJO+0XHoR6PJJQFwClnR +X+LrTzZ4xV5NxwVH3l6RF8votZt3USlqKr5Y6RxWtd7g1GaqkzGKj6uWIQ5CQj8b +uAKJAhwEEAECAAYFAlWAMjYACgkQV5MNqwuGsGfT1w//VIKz4KOnpK7wiusoEeGF +H76LSaZIUZk4PxeY8mqeC+/y6Xl48h40lz1vPhB1WI5eCgAILHkYEsbk1XcQTdWq +KBnS7bCCYqJx5R5Zk0WbOSn/VJPtvUzKjCF5txFXITguQHzenPPp87LODVosMdQ6 +sVIHZnzZo1kbnkSKAgAKXSX53lsgJxiFsxGmNs2IWzuDuwyTLrZZ+YIz7+y+d+jV +VP8/4or+gyw5H43kdcd7VhSr0UKe4GWvcPJBEkqQna9ehL//07xTr8kEGq/tr4Wu +tZP3twP9r9pQL0pJCIQhilWZNoQrELFqkcxpwj80iw1RbNHuJnYoQE2I5l/Yxfxh +AQI09/j4Tvby0E+oFbUauGDIb7PmBRYoYiHUQ0EE+I4tArSnBiL60ZxEhIqDZFVR +W+1+PVXuy0qA+vy5KrirCO6eJdp2UqMdsO8BSxQuEpHKrNq2N7o8zEKdhbe8U9yv +EJiB3X/LfX3n0Ni9tMCYMpcMaezj+4Qy26B/NuIH++Y57THsOaLKRgZbz+FqUu6t +zEbAYz7o3qrrnODk9wSxSv6WHnqYT91kUOpfNz2nel0vqNBr/MfCdswyz1tpN3vy +IHHHcmX+TZ9Xyzacdp6VgNqyYbghWUIAfsLyKHjkyAWmqGTOftIkw5Ecl9WnFlLh +vVK0RH8P4v5n9RTP+0uAQIOJAhwEEAEIAAYFAlSQnNIACgkQuOUId2ZHWq9RBQ// +eapqgOdek3GsL8E2fle6dwzuI1thDJeuGIMb6/Fk7FCidw+ftT6qQbCB8EzH9577 +mRfKsjXOJwEvsjkwrtBhKk9lPyh34GqXQwua0pdR7xxDHCWD2bC4OwYgafovREe+ +jFizYGeVRT6xzYViWPDBeOfuPmQRiM8DpJ6BYLfLncSuswLm/Gyreb+12WVHoN+7 +h5p+c4z4ir5BK6O6gNPCK2HVqIu+C27PF9f6bnow2f7AEqTYsjhV7dkXNE76C2Jy +tiO67eE1+WiPeHMK/K6h0qksLZ4zfCkYLlYAa/Gd9t9f3GIBqnypzOHlzv12ZwFU +4A5r3OmbAQevazLiH2Bv8Cu7hFbJ9PVukrJNwl53yM+ff7gLbtGW1cvynmp37Bq+ +3HE5ea9E1GLKP29W0RtPvEnLdSdKZoXswuhRSgH7/GMcgyOse4ojpkT36wxWoCVY +12v16LJdDZ4LA9vm0L91wT/frwry0wTRR/5QwGfUYJ1IMe/8jP5eQXLsd/L6G093 +9tWNxVNPvZ65201i0sLUjxZ+mvcWLHUN8KQhZmcGHM4uMBKyoKzaxZm3KOjyQwT4 +/op6M8TXG5cdBhgwJvYHcvryyeVKEhRSkIBnhyHHmDnkUSLNQgNEoOE6WxJ9bY1J +xxlAlGn4NVLuj2Fo8QJFCApb3S1bg9f33adUgvxJesaJAhwEEAEIAAYFAlS0hiwA +CgkQUEHxiR9E4JCKoQ//f2VdJvbK5n24peT8T6ah5ZJgvLMP9Ve3np+I0u8a0pkx +M2d8jlSQwkUp+R8uuUPVMLzB5nBsgiIT8tsYLfORQtdJDzPfJJuHPI7YBDSDUvu4 +I7Q3g1ugKUoBPsbNUQsjsk8CGtscap4o4BIt/vAy23D2nHnOJQLfv8+8AgUvKpCX +bekIiuX1DTp27CxgoFGZZDvbDM3p6i7VWDgh9Xz0MrmOKcYLLO7PiZCqICaeuHd6 +rdm5a503dKe3tlPDibFNLI1VSxi4JSsH9KLS16iGUpb/sZEHUUYtm+C4Zhita2Q5 +MfL/RsjmFGd+iRZ5KrVpBfRaDoRySraGuX69BYqJwDwnKN1E7a38SV6EXvgV0ztw +lLS8Q8AAFsmlnSgVzueL6dg1KCaSIf0inCGhLW7ALkR1h2rT3tbbxg7rK9VI7XVy +mXuHdJn/qsenh2SDZHIXsqIGEmjnAUiZMJE7k5SWWj9Zbaxq1kGhw7K9hsyh7Z9a +OVh+TGSKS7v6uuxmXnbFUprEKipleyMY1MiRASpE0Z7TT3g0d9hRnW0yJ3N5jPYh +jejz24ucCljIFLtn1QlbaReeVFtiwaNiBuwteZ9olDOsvzctfrGau5RGRII2OvY2 +PwCgU+ZvyiFx+yY1z59GiX/hZU14VEJ8Vsdeh+dcbzjPO+cmL7lpyYMJysFmI9uJ +AhwEEwEIAAYFAlU2zT8ACgkQx4jEwdRVDUUmxg//RjqbMZbjRmqRIOBMX37I8hKV +m23a1YMjXVzCcclChXC0pxPzN/kRh6lCkX0b0tEtTvxVGp+Xc7Dlm0wuoZLWhmRq +8cnWTH/py6dodkpRF9n6VqGtC39uaXhJ2IHC2CBOESydGoWG0T1IEQfeqnwFRZ/C +aq+vERDwk6ZrVPDd7fnnD/ec/Wc+3LMKz5OvCfHDBdDArVE7yRvhuYKXAI/a1c1D +/XtPc1JcAbFOeyWxoBi0iHcwzbD9bL+JAFrA+IhhCmrg9FXCF8TbBXXKSs7itiA4 +IF1yiDt0PAh1ktyBTT37HalannLhpd7uBUeOv6bMVGTH7qHVNaEY3q8xWTb3953d +QbunmSYhLI5VrfJLUsef9crRiY2OOdjDa97egaNukl6W5SUslYdI6vQ5MBWoTHZK +kuta8eUoQhJ9ECW1bIrlXKQiEyKW8o4L0KHYMLHrVN7oQQw55dOHFpxuB6mvAoaO +p89BYyEP0Z/LcIvb2o/2a6otSRPo67GRlQO18YVg0ZUhu2/VnREHmIz+W0jT5DdC +/UhnLxogL5mu0fF8LhGIqUIjMm8wDWj5vLIrjFHuMrEOsZMTKV4hJOJG2oA4dZNE +LZfI9eNIg9eMCcPlpxVySKKS41xvwIGplcm9kPi2D0G15f5C3zaF7pQiy8dKa9wN +bT//IEp0AJLIZnZ83KGJAhwEEAEKAAYFAldbmL0ACgkQLTR+pqplQh0l2g//fm/N +eNz+ithZkcLmgdJDwFCcqQDPsXR8FaP5wGsLeqoqyzbn4KR4BWBF1lX32+IbVUMc +ggzoxCGxL3J75UT3nTN2J/rCdbyPsdmwZrMyfwJ6+c9b3ekYcIs/w3RD6KkgDcM0 +O5yBfmnCflfPHybvWD1PWOu925Fa4Non8anC87KhiqMe6Ji62TvgGAzBDjnYySLc +7JsB4tq2P4rCSp0m0mslWacCJnRKS2LOQEDF5zSGMTVPrba9XNU0vIRsJnf4nxLG +VeBn/gTkP+HhGidkWlOr6RQjC84ACmIE+hZpzfwHn0XBMXtIW1goSsSFRa8J+DZT +ea9FiztZJWzWo6LOeZ7WcZ5+0fOfYMquAlvI3uXqpmMxTa7XoicfrP3HH/OgaH2n +df9JKbIoPJCguyN1CwauPR6EH+lMpet/L+UvFUYyeljfVWvxDUwy17msqCU9jAhe +T7g14CqBaX6KrdVfx2cDZwd/ts4FkWBHxgi2BVG2SWKi/ZRi/qRErcmLHBVSqw2c +zUeRm9zzFwQESvXcRz3KGWnTm23RdhiotW6nnlIkCpT778C1EPb6rae8cyRlpfvo +gP23OSPdt2gk6DLH0n7lL1qa5VkhqgVTZJEDJwMuH9ikih3tTxZ+0Q186hX+aGAP +mcXRCLZCZNVGKDjWUcsIV/AXp4VbzeBVt0WLeMeJAhwEEAECAAYFAlbfBOEACgkQ +NSxnILHjuSuRQxAAj+htpeBf3MJ5+TXgXTA7Ij+jVdIPvVGsTiNGn2IbID5os3IJ +VUMISuWhNYyv2mkEuQ9seU/Hu1nOJWLHSjlLpkezPp38b29s98R0viXr9EFQ77C3 +M9p6cbAC7BDbRpXEsZ6NmCW4jaKAX4hF9hSueURUrh6LT1BVF3XVR9LJRNqJuP1D +YR/I5ZHGtx0v1SVRrIPtG/Ur1Ds4VGhI/0pitHg25IrERbgq+l0TcYVFmMUXiy8n +FjljKkvgRAvO6A0d29SBE4h2oXMIOGjuLeARLDTo+YgK7yDCsOnrPfmHEepKZKOz +aKJ1Mm8+nRHaMMIso7pT3XSF7evzIJr5GNzDU0DOGmUOUXTdnczbWn3xjoYIEDYh +rLMI3pXQkedRdEnd/2j50ucuftPL/ymE8PU/49HMiag0O+4WfXjrrR6H4hcLR2G5 +qqq8PHmoMqfjNq8pR9YXHSQqtf7VHJ5qzoB6eM004pDJMmoUui9cfnJU9TuZKlPZ +4ugtpSbKFDwjTnEind/7qacId63lruyTrYUryagM9oiQd03bLy65U1CYIcfqnfQZ +iuawyt5PHyUHewjZfTzUneGOwnXoxhmdqspPK8z7EQvpgbGwGviuo6kcoIJCD/N+ +Rv9GGbtbyQeALAQg8L0Zc9X2b8DoqTR7MbCXJKMzzevjdyMGHmbHTVDIfmOJAhwE +EAEIAAYFAldTGc0ACgkQCUsJ0J3VNG2VJg//QejjvNK8Fz46gVdvBAmMWcmgY4xM +D60Kkxme0OWOHqyQR6zd3KYtXiyqd2Jpb2BI6qfa6+XDyo8a6H9ePbbhlDM/aYXz +scppvn7Wt+3UxekjzisSNQJXcWVH+hWQbTWDwMlh+Js8FQIAjB1z7BIsgXxs23YW +BVT92NzwkpSBxmEG6VjQi+OIDv0fZHXYqLyScSHFh72afYg2gcDWuSH9eBOzurOC +1gVDlNxplE3Ae+tIEbW17CFrgYx9h9xtMAnRfi+maUvBXb/Pkx4SgJ4HG/vqOm9d +Hkx70gVIW2Bk2Caz3cN2t6C4kYoEqmSOV2+tV/rX6sjj7XIcSvsVEkRupwWyJpLn +bAZ6s/c6bt6BfH7/6TDJ3Xs2/9JbSKPbjbPJC/evx9vAxLSqN93TtVOMX8wyHf7u +SzyAHl6GuevGPUIZUCyNu1aay7kgtA615puNfG7or1mY9ltZbo7Osx0YRKGPDP2x +P+5Zv9mGXTyaCIo97Q/TkbZ7D181M8kldsltSqGH89xFktddTdo6AkwHVNwSRvPO +UplErBo+9qHeh/vsZl83Jmg/lBR0xt0PLFL/bg4cHwzr1QxeZPC7HGv+vJOW6OCU +iPa3A9mJ1JKGTtxi25uPsmFFqDLErm54YoX3YAyVfnlVUuMSM7e7yZWDcx3DyvD/ +HZDDh7SJZJbNFQiJAhwEEAEIAAYFAldTGs4ACgkQwA++LZIZJ4jqvw//dMbwEipe +79WC8F/H+2KzRijjKLsfq8ol2Bkm80i1g+F7fXvtSHDG1a+T4IHqtBqE8Af4whpT +Q7lAzkvK/N+uW0NIMSn7PsLOLuiPgxVVJuE0MXJm04HDESqjqV0YtQ0sQyeCNnkd +oHjoEU4yYinkdos1G2k4dDan+WmTe1K9KdC6EUSj8cON8Sy1yFrMok2qoNgQIXh3 +pR9UxoR/hTYdcFn7d+RYrPsv/x27C8lAY3s51+ou2YqRt4eS++NqdxmnUy0rFBvN +sB6dmDJKuCFc3PXncEysdCSkDgWHKq2m1v9JAvAk3bFTF3AOy70jAoNBTWDs6/tj +QVfjVzN0qrXglNuTQN71Jq63p75bZ54xl0ZOWhSrlJWvCNQ+nYNBM/Ff8R8Oi1ho +TDxWKyzjHzIAZR+N2OWb5jg//GAQtSeRSYfC4I2CzWli81orkjkkivr+u1Ll1DXw +/rtUL97wY3fVwpI9Diz501n1tVA8TqLTRO9IJ0FZYj3d0kYVd+eYYCQGW3hCWs4y +ka36NP4SwSDFBBeeSgB6RJBG+e5rv9iUy/UUm9BWF0y9yfIjTzGFk5fDN2mnrh/a +YeEyJCyep8z8lIO9eRFRlZ1DXlZO4wCAYdhoBnZv44XOX5uzPkEYRX7YRJly8qF2 +KJBeNXRA7ZhTIlq3tjAmkHCeAFUWYUtLcIyJAhwEEAEKAAYFAlcjfnIACgkQh1aP +FWLNUTLpchAAiIHFf9shZOM44PfcEzN26xau4wkw6ArFBzQBtG5jIz6mJHW0p7qi +Nd7g2R7GWzX9OlhUh9fPzN9c1ASKW5xn3W4d+vhvPmwxmUkIF9os/iSF7AD2EKj8 +ygB44MDBpLhbIc+aPZHZq0NwLhgSKbbcazsT0tufm7BbasV64RyeNtbpa/3b0PpU +ZAvBHfMZ4cnZcYo5ClvvFqepGnqLt0I7eJDL2gp9WbIV7hN7/kF6XeJUh8lJrARG +nuKsTaPuh30bC65zndCFxfD626ZH8qX/SW6a0l5NlUVbl7YstQTWZvpXAFBhFa1B +U6gdujNy2Zu+iZcxnT4CUf81+tb/FA9fyuv6n6lpsKK0ROsGtnwwFsm55NUMDYYd +xsFhSvCKk1DXJM9EdJ/sNq0DoFDgh08SLAShVidVgdSRwa9tSELSrx3F3tdUmVHH +Fs7a1VrSfrBOEyeHzO0eKTlP4RUhXHnvkC3lOhLKTxRfW6b1BQZi7ocuQV15M8Vj +Ni6ZpP87YLRsv62qWqv53tCVFkT4B6J0y08+RF8jZp4RIQAEnUrbz4DvlZ38NtVo +y40gYJ5RKH0BwIpDJox0SqZKvWEaR6znpzDDGwlaFR60aUQVAfXviPDDuqCuUM+f +4egV6g3l24l/Iq5QxfxLwc7nPJZEUzUSJ4w2aodtGbBoQX9YotncoD2JARwEEAEI +AAYFAleBHq8ACgkQt4uQjyNDD4DvlggAqU+eqOXjTG2tI0m8Ft2EQ2qZpiwmSLdS +nu351VIFGNGzzl1HhacZQ92OyD6K/yQIRVqC3HKkXNdXTPzW/MudWLc5iWoYUF9q +mFEXJexcXyB0MWumKv3Zm3Md2EYYaKEOWf3OaxJYhJHayAQ4Njium36I9txxPH3x +LUVXj8rK4r/g9pvDM2JhwgBW9/a5NLmIGglSz8LQpbgY+UuKcZej407gLFv8vc2b +iFcr9Acj9n4Ja8s1YBcSkkPcGrXxzfr0nLmkfVZpMWG0+ZTzTIc1Rpod01Bc9V/1 +suiJSp9db/t5zI7zo7zwXKRNBUqWSTVUXA0uXj8oyD/8K9vtWU/XAokCHAQQAQIA +BgUCV9ZJdQAKCRACPAXiycBo8OgvD/4tkqEHmyiiStHZnOuQxSuxO2I4GCy644w2 +BAaRhmvNvsIAw44qcmLHYwGClYO4fPBzNawqbJlpbutG+MI7RzZ5xmXA5r8aHA2I +PGdXXO7nz6phjxbiwpOKcFVnlcbrmxgXgRrXWsXCdHAJzDWDcNaZl8og7EmqwxjW +UQ4HF/DBBsdDdlAVLf2Ybjg/Yabl9Qj/6+sFlHQCon2fb/psjF7MTFBKZyR0Xico +mljPw7DYrjpMX1QXSMx7s+jB2gpNxm5ROGB6ZtWN2TZYZrSswXFHheU8K1w3R0Xv +usoDlfO7vHdGBEB+foYowLiB8cjbn0JFf0Qdf9hKX9kcqNp3AreDbWKQHHmYbPex +jd2xirirU910sRWK+p8UoIADrDyrBwCmD2ECAK8mOlFyopSUj4tUG/wjKHN4G2F0 +HODqre2/rqylMwHY7GvPfa68YFG0L387vkv8o193PkWw90M73SiQLsSk/Uj4FtQ8 +jXO9W7lTeNUbIa0dD7/kBNmdMiJ1vhRfyS++CspblbtEACV5eEo7zOV1Yr46v58U +BaNlYinTQOIrhr69bRmYgrmOm5QiTALCjrT3SgceyyWhzvjfaXboLsVeMwwcg7aO +Bv8KIck8Vxj/wkhTK9wF5FSxbKvCDBV53xZ6eoRppaEoWF1HKnJEqJnOx6eEbDYB +N6OX9h35VYkCHAQQAQgABgUCV2lgywAKCRCLPYZ8gj56YS82EADVIu6didzu5QRt +dCQCWboDbH6DoYNwwqYUAR9AF4rNOKrsL2bnbXWTV0cklHKHA9/3sbryeebvQho5 +MD9R9MpVlR7jEsYKERCE/sYVIxwdwrHSSHtd5a2efYPiFbsvCzawoGaDcUqtjtay +LxSzHcuzM+h1jSOmNOwl8q9bV7tAC3RLLBr8OVLNyw2aJkUrJPeaH3Bw2uklsrvS +cYCTOIpLlOUC0ETOhIwmVSokgXHS3vgDOEj0JxEuopiAL9VGSXoBryCVs9V9y9pw +1Tu6jvOZCGE0YbRl6b3BkeXPnOfGPCkOgIReswyYSk09MND3OfQ23S8+IfCj9qpY +7q1Mtz6flUIehn3Nm5aQ39L1FRa9av01w7hdPZ6Y8NBu2bFSBWWBXvqfmD+iKvEz +Ukq3N0s9kLny6pdTEgV2/qr0NYCuDcOJ1S0ghvq0M9UEEVAv6kd/kBPwmt2nrAxy +U6nJY5YzMzenQFpOPdi+L6BEhNuk3/NO96CqLauOCkRLg+eaDgtkugaZ6T4Eq+x/ +St4nrx4R/5mVgWBPhhfalQyGD/la9tyBE8xSniAFugH970r33RbY2jzLwMWxUhmN +lBz2FUMet3BKriu9yzIj8DIpXmObXwLN6eGcHqC9bxNoBEx0AlbcqpjrfwC3md98 +O7T1rM17jRaOdDcjqcrkbGB88PplS4kCMwQQAQgAHRYhBGtJrLrc9r0cogZnq81U +/OPZZL77BQJZIvGeAAoJEM1U/OPZZL779ZUP/R8MkzxZHRgmRPeibRbu9A6/dAf9 +y1cVGAy2FUByW4ysp8mAp4mPgBrOSfu22DIpvGQnZ+eX/5HXxKYzRKmttENk9+Fw +hlhDSNrV3psfVJJeTVAUmRZ5sBe2I3iwKwF1lnwcsg4AgDTKS0hVBGC4ybWYEkFu +uYARSpOi1aFfQpeOlLBhmpy8s6AcmxSp68zH0tnrDgOoIdr660jEjkY+kkgrlWlm +vHE4NgCOCHPAQKRgmJLv55jKdADlqtbtlVedwM3SeyIPVxnfhvygug5/ZNvUvNyb +BNqctepw57pORrOayRjQuuz1+x9nYRfuQT3rM2IXw8HTvqKQV9xzJbFEwUBIjRC+ +rMAdVE0PZG1iWuGANQcYRrd/h1ZyaUYkx55LsKgUlAftXEwEVnKpg8xcIEy2WDgK +h1+iC9D1jH9X53MrjWOlg2er4PPUrs/7YQ6LblunMg446I54fAqSMK1O+Xjr/GrK +FLComrhj6YtHBtQrPYgDwoCj8jTB7AZddEWcWj3ZPIO/q9aMrfEn/hm8lZELf8KK +eQsMHMfTXGHXE/bIv2qQmk+8pMOF0cxFi75qPfoQV6cRk6WAWNybbcu8I4EmU42p +ac8NLwfHjSvIXkdM+3X875vLBKVOidW0CU/3JNDKbUM1DYeUjNZk//ufwoginw1l +MhAkcaCffZF7BbqEtEJCYXJyeSBBLiBXYXJzYXcgKENhbm9uaWNhbC9MYXVuY2hw +YWQpIDxiYXJyeS53YXJzYXdAY2Fub25pY2FsLmNvbT6IRgQQEQIABgUCTDzl6wAK +CRCMJNFgjwaJ1DRbAJ4kbXJ5amwWjviDviDszc+hhD5yqgCfar+1d3rf9NdoOyKj +UjI2hrK3F4GIRgQQEQIABgUCTLN7EgAKCRBVW5delTuGk94TAJ9i/njzdkzGJtqe +d3a5XSqhQW/F/ACbBRDu/TIc0M/Q1T7p4cdf48s/MSqIRgQQEQIABgUCTNXtXwAK +CRAdqNoz3c1oamj2AJ4kP5wVZrmW+NPu/X5iPU6FmuvlZACeOj6CNW3uhSJdJzfS +MVTq4DT3HlWIXgQQEQgABgUCS1di3QAKCRD67xKTbdPj7HyoAP9WdaVGA6AfFrTa +NmjG27fIYCarkRxSAADpHWB+AFmOrAD/dj+zV+//LW5MZqdxPjBfj17FUrX/zYSx +3ulbSJFEV8aJARwEEAECAAYFAk3RZSgACgkQprHz8Oa19aPRAQf/feXJy/aIn/Uq +5wTJNvEl1nNETy79SnppU6Jlcorz20C3J1pTMyOeAFFXIunIZ6ow0jUAYfjm8Na+ +p+9EnIPUqo90vQr+RP+FmHchHtV40Zy0kbCpymAj/Bm1SeZEOAbfl4lWeZzI1TJA +WxeJdvaz737Uwm+0ar4I8ugwdXXQ4CXJ2aPkU1ZjhTziJozUcAX4xJ+fl8bvutSH +U+tQxFHgflxEpP/Ix8+87tKLQVOOtJY2vp8Dd1Ch5zD8uonQc/z15mC7ACYNvZpz +xf0u4DXx6ZQiyCLO8wJ0ji7VZ6O543OgbxajV3j1Mx91t52Kq9s9iDAVr+Y3KmgD +PweoPnxYeIkCHAQQAQIABgUCTczq6QAKCRC437cbX+y9kvwxEAC4FeXRwcwYvNgW +ZuKkUeTVKc2FNEFrMv1rFwBC4p3OyEcLGTatoeBD6HRn04je2u/oSSNHdqUiwBln +etWsIFv41Wzx+gByR6krkx2JuNNcyWO/tJLVow1P1ib8IAKpn8dBFC6GQCitPZ1a +sOO5SN12Kzuw1JtfNkfFg7reaUkkgCtONoW1eqY2U8DmIa7oFPg24hFpsXtAKHf2 +v9+Un76b5vu/fLovAEwahwHu+5jXkZte2pC+vh056F6zj7JSr8g0VE8DndSOIvZ2 +NV+Fht7p+9kjMrfCtzbbPxTdNkCnSSvrSvftHinEhn5VCh+7PsfnPMWXYyB1sxC7 +k8PdR3+6k4JQVPS9DI0p074FpGQkRh43GWCfOJdcYmjbN7DEe90PxQ6jY+syLdoV +TsTiqTrv8DxJACis9yZzDJChixMJ3NsT2L9hH4Ams5WtUCxjtdbZZ1fpnaJ17GUL +CCuOzHL5DS6oL4SvZwB54c9M/1nbf0Dz0rGmj9ubcjjpGnyjhnfhzCHhAuv2OU4C +bvpryvbSX8CdJ/UGcJ7gaHSDL195B8RVzdQqYUP75vBGkh8jDrRh9nvASm+gFXLa +f8oFSLAUMYzTlughtKP5sUoa2UnjxejieRaa4eUZzRkSE7dKjd8Pn/pQh1e5MK/j +Mnqi5bdem9DYVlA08bVLOVQl3K4n/IkCHAQQAQIABgUCTczw3QAKCRDhlwEmdrm3 +OXmfD/9CevPElq5+XL0wLgwWh10blhwa1lrjbuXYy/iF21egJUXG4db/T9fmBn7a +/CRY2aWJ22sJ2+xrbYsJkEJtDTyV/OblQLKTXHfRM4pPosimOa3DXCQnHaof/U3a +il5BeP8HU4BOIAOSORqIhQNfo/X5JS2p3CyrtojmuhqpOm/SxvNhrteLqZfdmljT +iLXV9EgaxrkWgUZYqlug1oEAKWD/Ovfs3xPIMp2O6ysOrRLGv6JvUJ26LQSAcd3P +YojZwT3C2+1jsWt/xMzjmTW3Gj0iY/vOY8NAEtiP19ElvkVmSIqJUK17cc4lGQpi +Y+KxVZidLJ6VaQ1IXgkkVHXrHMS6SvCYt7joZ4BKKNHIuORYibQ5zXwKovqNjKcS +I2vL8cxeWPeBp01Ptdh7B+BhYNV7brzkpAEuWAXlT4T5Tnz+wdx4Em7Tb1QBT39O +5dtVME16vvj5a7dQaFkDyJzGACFZ7yvpREBghUKwfWq6TPqCFmmCiT99/hIODQCG +f9CRuLLiLIRHB3rxLy1LOpk9OIN7F2QZgUxCIcIdOibNXuE+QvnoputQSBYuj3yp +FW+2GuEm+IUpSy9p31BSaScIe8NP92w/nU5BoqlgV+TEvKZ8t1DnbX7/lJBhbyCY +a8p5GjrDPZfm09JwmcJ60ku1Dq7fBKF1IwmbJVN/gc1Bio7kH4kCHAQQAQIABgUC +Tc0yKQAKCRCGVh9FIYD8/pDGD/9nXVdNo3GUMFXOOAPTHndpLpL837KTD1bIN9om +bBJGnzbk8Hx+j3abq1AqsryitCQA476dkqvpCaryX4f0ec8xq43nG+WKDIHnrfvJ +zLWbIC0sq78Ma5IjyVFTQUShtc8bxq6EHfBW4r5iNQxnAY0iIUBX+9nr9Bp1s9T4 +pkqd8AZP1TJgoujmyhQ75dnQ3hslZgO+5phalu/10PH+fR5SShpQ3buOf53K1Kto +gD6VwVC9ZILWKn7SNJR9TdRmiqrxc8M2bhID4GtU4pd2RPR75cyf6ViiRxC/iRIn +EbKhJaO5muMMjRynLdcR0hW6UspbI7borIWm75zIk1K+upyEl3RfLMSvyFB0ps/3 +0kIUuSqq1PLMS8Qgo6TYQWAQvPK2uyRitnXAZfjo3MEMCqV0O+fZPmNYppe9r9rE +VcPo/yB6mTyp0lgDkY3NbdKSmyNBj+XlyhrYMfQ0brnxqx+w4xF9/jITMhcvRBWJ +c5FCboAx3WRgG/5kKO7XSZiM2fe+l2rVNA0hs6gZgof/oIaJJSlxvrGgnL1j+LNY +SKS7jNTcwjr9hUKYpoEaREk9ibhUJNXTe8Tseg+yR77QHO1FK9roc4+M/41FrohI +XTpzw1JySAccl1+6a0ZcUml2r/aRotuhISAM3B7J+Ov7H2UWW53warMTOulONorf +JcO4sIkCHAQQAQIABgUCTc1dfAAKCRBF136eMMsbEZsSD/sFeBRYSt48BTR+euzx +gkT7+vKUoI/uMEKcH+Eaq5XmK17BWS9RJINF94OPHI73OdKe7GhmO38LLadoQSRu +9/TNAqI3T6Zf66/PuORZzN9fnXksEb8JYcrooUkhs64Nzv+oDcy+VrpKFbwi0Xfv +rKJTvNtIuqtV5OF/z/NFlAZcX5kkQr1MLvnVRt90SlWjxytEdQqSFPHU8cljtDa9 +1SjhC4z4zAdhdTKoVEQIqixgZySZl+qcbBUFfnyZye4aoS2UAtSIVFDhoe8QxgtC +vGbtlfGvmmzPBqpHHzjqU1cWLT2c3rFW3FunvolHs2Mz7jhQMlCG5MTNaBv12bYa +yPQO2hUZwt0xnj+ElKsHhM03Yd3+vre7hqxJVz6gZHebshd+0l65RnP707k1jLac +tdstatNUUI7OF9YeexNmHR9VaQSBr2gqRE1hFLksmNDlP4xJPbTFf2Wv4UalSRax +gLWYeHsif//vc6xWmeVeThJS2tqJ+XvfsFpdqbDLu02XRhU90rQF8mlkexbmgzl3 +mzt87XBDUAgV7iciZ01HNRS0nJ+zRMFAoEMbdgTQnMsG8lJtnRbiIoHCKV7a6LCL +OzD9MyyFLuFTUsHep0D7KVIBirtHq16o47tzDcLCJr6322+iYDEzXbCqI3U42zj0 +DkwPdhrR8QK9B81mqk3Nrq9EoYkCHAQQAQIABgUCTc7/AQAKCRBgBCahGPX7zkJ0 +EACJES+qddJQoJVgzH+iQUNXK7u+ae9+XcpUF+oA9aTUDa4rPSBRhiPyEvfMItc5 +0c9wzK0pCtLAnPaJyTsu4XyWEujvqVBxfmz/uDOBaEXCuezxVrZSg+8W92tfkjLJ +NsRoKWAEAPguis6tCNc6x3dD+Yh8JyyXelg2MxTqycQoovlS0WF267xT+ecAJ+OR +ueKSpGCSHQ6UWs5rWUljlUFWMnjOZay38dygF9c4v+XCWpXyhgmYKXXQVjGtYYjw +IDcAX2gWvTC5bLpjsg6I23C3Id/qPCCu36a6c7GfmHPsP/eF/8hSX/BGkIO0k1oZ +wmZTNg7WJSPAbtAsPZfDoLoR7fBDcuZtOMbB5oAZ2y+/40ak3rOxyxKuGnZmNiJP +dYZLdUJqwFdzoQ9DQfxLnWI3KxMtfLzy7maQddYZ8ShzcXUxhvDx+QtZZM22mw7l +tnB3JC5QSxwvJWciweny2FTJgkV9JEQrveM3k4o56TSbV4YtNTlZ4WPCvDfVoz0Q +FU5w+pu+sQjdvStmCqb+Zq0D6Qf7qzhiUQP3X5xTTD1A+juLhVjkZrXpW9EAXawo +Q7pfqGNB/XXrdygy1oTdYwawmBuKHNV75Fq8dI3bCOHnS3Q3dcqrMrA3VcqAJALo +Vb4GxQQKbcOfZ/B7LKNWkzYU6pQG0tiP1+AugM9DJsvCK4kCHAQQAQIABgUCTdF1 +AAAKCRDGOJdNZHktZ01DD/9WOfCk/6+s1MOrOVKdWW9ryXEO5N6rzmh6Y4biy+6U +hBcfbVfrGgxWDgCCGr7C9SSGNdGkI2u/OQ2m9++ANlk1Jk3fk0Oy9paU6JHr3IJ1 +beFrHJdfQp19OAsLAI7C4twYaFG1hDe976TSSXaTtjwm2XXra/FDtBVGIjT0t0as +VLWJWBIbnZKGn3qQhtDGj9VbffInWOXpDXVOMfImXz5feZvR1wi7HXUN1iYlVZ+U +tu45ey/rfpEdNmQETDBDlKMCSDynWg0ZH4nXEjtW6oqvD8NQLQ3mlxv7/k9HdtNF +Tni+rt+7AInblkjLFP4OEBKgb3OS0R94Yw76FL9LfVoHxooXHxxEwAlyE6H8pqNR ++RZwVqXdx927rk0T20JedrcwoB8KJNrg2BzH24v/9wvA/OgMpmJ9mljiIbWFQ7gj +W6+tK5QLTQ7tsxII7vY9wKrfaM+GYztk8bRVFNUDmhVffmpK1RrsBXvSxV6KhAYo +ehf6Fzamg4YsaE+qUHZas4ExLaqFFcqDehB3V+QbVvDM2sY1pgQMeNlH3kuJ5vDd +DxHgHQD/uJzW+9W9PXHEf2ZiNfhrv51A7aRS4J/Yl1S4/rx2svVelOTY0OEBaIqV +8seW+DssY9mYVVOoj1IEVlZNWxETCJSbxAzUGSdkUGiXE/Jx80oLoMSGxSwHy6C/ +34kCHAQQAQIABgUCTdQQpwAKCRDjUtXFHFBB1LrIEACT+ge5t+kR87V1RYq3fa0A +GINk5qkxW36fPpyqrxxKXoFuxFKuTH7eh8/AfWD+LlHn0SWq3bkp5xFtoLDBHZGC +ngSXue4Z24dPOjYBFCDXBF56iLdGcqE6zx4FC53KxdBfWUqcmLWothyKXMfXVbuW +sCsC3wHqBR/3qDsOtyHTX02gqgb9dTHHLg18gE1XpdXAnfr4DD5QE+I09r/bA5on +9WpbadBhQW2ajRlEMhhrgdg35SjbERa1blCXNWkU2Nz+QLwQMH+k0Yo7ZSKO84ai +2KH6OPWsdQco5RD1P8SFto1Xe+ICYiD8eIlU1DPnnx8JiH96V+drBGAmm/Q169lU +K2QN0JeJceYkwNqozAy7lHABkE9ucMtYhiNsIYde4g24k8Kkyq0o6z8a2Lt5wNE/ +Tdouhn+gnWRSXlBUfMR5RLjxbTeWCV3w463WeHh3+//pbjuR2MW0VaEq4x4LCBzh +eiVmjjHkiTwpI1rdoqnW+ZChHTfn5rBlYyjA3RMruKGH/5vcqssieZF3SDP3UGTT +xIJi+JLXCCYXIDUuckc/lAULaWxEp352TpEdwWjAwEE3X0MnmvBYBfLP7x4fXMfd +UI83stLhpQpx8zlLUKCrEImKS6t+kcT1eFcspTk4kUTRBoyQdOCy3y0/Gox0zG73 +SsIzjJp2m2lzCgLlu3nGTokCHAQQAQgABgUCTMrV8gAKCRCcMVA8bYZjlpsUD/9S +x+1FrLRIbm4Qe5AG4GjHF3m1lDVtnHI6odKN77ryaiKnUxKLlR6askQfvYgne0rK +iGwcJ82H26oQn8tSfdNilrbf/db7QIXyrFP4qUyaCI1iEngNYq95O8SdRXr4HLbQ +wgcO7yj2bV/hEHlTWbpPx4QrryzF3nK3zYM9pblUwKJclyXupoXqaDgU9AzcUDTq +VOj8Fl5HZ/6tu2ifTrtFnNRvycOzM7I3VXUj0iJaPgjIJB63OeX2X9gkwVgxr6Wh +Nz8nhciR676NbJDGMeprlHNp2JlUmHO8Wh9g5/QElbcFzw1qp6NhjcUaPd4Ht0XP +L5JqPqC2HI5C138zH3lWj0nYeOsBDVI287cVbQ8d/YSg4jt2ITOL+gmB999tCrjH +clh70e7SvhdQmIRByegjydxrAZz9IVePa0/TDjkCEFz5jnW0fUxKeWrTDXAwrcJ7 +Bj9M7tGwBKk3a7wu0k75NP0GPIRiro8OAzrvgopJ5zkvUYlLd8LYpFvjhVL54m3C +SGVEEhLEOCoyov1PzUWsavQ5Wj5szHww3DuIYJUrVFqDtvCrUGBs951Z0ueo0m9X +kw7P6RHPmT7QSZtktBGRCUr8YdChziG+vCfpS1GW2byVbRH5Kma+AB8f/VHsftcL +LijiZ1RkX3mLNXMRH66sqbAjvn55lEQhhodnqfVtaYkCHAQQAQgABgUCTc0pLwAK +CRAYs/UP5ZI8GC5GD/0VN0c38GF7a5Wj9CQuevTelSgee+an1K6G50kSO83E1S3A +JdLrkXxStQkXm+eFYCp6Fe6GAut4KW0jiZipAkt7FfUv7+3SJ2J3JSuq5BA/Z5K9 +9W/MC7SsogWhQSntizeENoA70H6uck5xlclvq3DFqRPk9EiwGFu0JEcGbifUstVO +nsv/Auo3fRIemE/2fR9fcEGY5OTWJQ7atqvOUBNBqnuVO6EG0YqX4dC05SBzIgbE +PQci4KCvOAfLRd2bTUcxmsOe8o8aVz/5mMMqbqI5nfRurJyctUtmhGZU697HB5pw +UAtAg5BjLMGhue536+Rq32g/qRXUffinbzRpRw5WB/EoEtHD9XPoVwm1K1lvwyuO +kGIN1wuuNgeqB3ThNy1SV2cw8Cpoa5x5yEBMCGJjQ1XLKoF3y1KazcyM/x+JJpTh +X378TctEUykURGRZW8ESTmcr05MeuAAE59llV5N2nyVeeUUptJzGZ43cUypj1z6C +ZN5935fUtQlcvumhA2SL+iV6q3SGqqv6yBJFz4pJNJfLKwiJM0dkZBU+1JcGjfNx +D+aB5nG+jIgLIi2aKm4mWirkMjz/mmW6WyCR/fQx6xx1hETI+hpHzMiT/WNZAkWL +5aERgwSqoknrny7GCU7ZuWL5t8jO3PYSnNtyIOOIyD7FqDPNwMEHNkzb4wkZyYkC +HAQQAQoABgUCTrK9GQAKCRCXMl3Y+f3VBp5fEACQauvUsKPk7haHnO5fTRxq1fI+ +sq5CSg/n1x/5L8KF9l3AazyRJ+BgfDmyhtTUsb3GnTnv5r0EnmP2+/klZTheiDAM +AkqlJmBlYAli58FgWp+7aZgkZOZmOKIGOHiQxM4zCcve3RHDbp9Cot3/HnU8WGVG +BdIPXMODM3vF+3FPPuKuUMeyWrvPgXXMLgw5C/7r0qF5nTpEzMsnULpIow5QVgPt +4p5x8eD8GRKLJs2hufOzzJA1AxAQLSk0hIPQyeHcMrQWyTi5VSBLhlsHgqf6QsPk +CW1kaPFKmqv4/ltu47tkmOXVFh6uvWkRiZMoEE92giQrnzHG09GMLBFJK+YNIVIx +LFIQFcJGEmcjOTjfQxgAduiB9YN9i/mYW8Cf0EtfG9K+xbBevWDuqlbYvbq6rRlz +q0tDsxvY9DcSm9O8HA5pFq69Kd++z+Ehye31OtSAo2cPhNvZ+8sSTzbQajzcsbsW +BhzLClViN1lWyEiikF4jusjwDUJvHDh15Q1NqhRavDjyaXdSJSJdSDlJv5TRaArF +GcrolYDlqBpj+EIWuJS4UA7dWR5IsJu0X65LEqq9NwxhGvxjrL/a3ebyqcJh3lxw +8fNYt5gAVBHY8NDNkKnB8kzlG28Jb5LhurwiIcvfNEFksbKyWFTwSXKR+RdKqOlL +zYfflrxDWqaI+kU4kokCIAQQAQIACgUCUUe1TAMFAXgACgkQEl9cZ9/pQITD0w/9 +HaTPpoOzUwhVpEsgXcUbXqA+gm8U56gkJ6zppj4X4Yg92na/8MZIK5o/MRUYmefZ +yEfMhhIqwOa4VefH6snb58ku0y7ftI5y664d4VgSkALGktDImEsaJfmtwmmNxQZP +fhW0O+EC9ZSO/NeqBeUGRkwMTnCAI2MLaInJENWp8X1S9GsldGW5alHgizLoegFS +LLCixl24+eIFlkUGhopPffn72ua1eHwC2GOx7bPBMlOMm0uSD6RbCUWPfYu/AfcS +/HJ+MktfbyzVQZQjLPmSxMyg/QYyu0t3Q9mjH9ZTqQeQ/6BXeLMiHNB4iv0wD9QR +px8Nu4pGsQyA4Nl0mZsDI4H8YRGj5AvVe/XBk6r+rCLkl7yT7z04cqN0VslYqChp +/819wJOySuaSnV8G2kL8rz7/qDl1l2xMkAGLBG9v403zMrW1ariDkN6aLYYwMEmY +RCn59Epfhcf+bCw4qPpNuICvS4dTY+fYRb7ZbLjMi/NrA6aITov3BLQk+yF7GuXs +FxBP7suYuc0Hooy6hUL/5FEV1go9pojQQ/9ALJXbeg/QJyuY937Dxwi2uhJ81tqT +HHR15OoBxRFY4fhbySTdRzR36pdALS7jnavJMbDq4YV3x3HOLZIl2OHPkPjyDTZR +eHO3dFORKwVmGp6PvmCl51iQoT+wHxitDVf24qXlxweJAjcEEwEIACEFAkoLepgC +GwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQEm61Y6dLBr817Q//e+W4w+F8 +EOq5HEH7EXxs0unphkkm+zDe/r5rbu9LtpXGmy2gqXVAT4/J7mBn2JGf+jeb1VJq +FCdZ8W+dp9hnoTyBkUbvh7UFG1qxIb38o3ia/e5VAK4imZP9iU5SVTorddo2bGzW +fTzGKkV74DIYOovfvflC/QE9/GK0bOQehX1bX02mPBNtE43C4ONRSqcpXiCPBEtF +/b24OcJr81w4BT+tqGlhmXeHtDl9jcu8G1hBWbwZdRQJvy+VAaKRpxwOj2dSjlDx +hEzJcOkjP+HTyhbEZ6kkyO7cJiNysgc0hWNLmAxH+0Et6pHwdeVa36W4YJE07HVL +YnQkWbNB+YA4HR7v6aOS0MZ5TtXQ1EKVI/r3am/le5cbpR7IAlKO9NJMAxHMNQY7 +3SGvxt3yUUqnZoYu4BboAZXH3WRviHBx9IsGBAmpTZpcuBRvb6nwfsPYWPfyPPpJ +m2lw9kKPcJtKoDZzkZIUMPqYNFJoru2Wit1M6DJM0WpSMLzbekOUDd64vYruTTPH +U+xW3q6AiCRq40l0NddxDjY2m0IymT6rbyxFbLN4OXtX2h9OTX0qPOsUBB/j5u8s +IfPW4/ituqOrqpSvKYHyfmUVo682L1/wErzm7AjptEoSw9/YhamuHihcE0MQo403 +8VK4y7FZW4/VAI3/xCWy5KDishMECRKPyb+IRgQQEQIABgUCUUd+HwAKCRCZzeqd +pBNbOK8dAJ0Qp87Q/iTlUoAw/kberKXc4RqLLgCfUxT6oPiYziqIZYbFU0wjY0M8 +DX6IRgQQEQgABgUCT60ktQAKCRD23TMCEPpM0aspAJ0Sl1tbFy1nemkfBZEnxc6J +925XDgCdHrxuB0+dxF9VKBBxqImhoEAbNNeITAQTEQIADAUCU1W+rgWDB4YfgAAK +CRC8yx4nMXJi0mUFAJ0VG+AH5WUWaiASxtUDsu5BYEAsSQCfT0efm5+d+14IEPqq +UUUPjB9tcrCJAhwEEAECAAYFAlNJj34ACgkQBMNnwhit1P/rYA//QYlA3+qp3ABb +2HiqB6R7PZZMCs65yAfcL442eGpdSd96iX3G/wz55YeAkhIvNYb5CRmK4w6gKvWy +EzgtVPYsSyCobuU0Pmu22QSeYH2W/SiUpPRvsPxuYCwINO6WF/LKaqeXwv1d8Ecq +4Ngvu0v1nHHGPEAgVied7w8lUxPhj8e+VdoDOP8xqAx83AOePNvneg6A/+1cy/bM +WYEL3oEP4rTM/zPi4tI+tqGXpbVwF19EiKOKURKK8B/qYV3uSG2JYGS8PpeF6I6z +mAuRD0RIE7vdOtFQok18YDyuZYUcw1+ue0tXBYcLA0ymxQ4WqZcuHjnikaRMOQIw +0c1q0+rgSQsFYn+eFidU3kX1eOQM0gACQrnwshvH9CX+QMlTWcl6IQI+L9P46Q5T +R7fMHC8puzpwthLkcvCzaOTTA3UneVReSIfsYrmwa2/LfBfHXYeV1gPP5GtDGR03 +uxw2vtHReAaf0vtB+LxyILGb9/Ny7+gPPnJvKSQMQFl6ojtmPAVaPq9ayOmB4O6b +cMLScHp/lUb4S359KcBadKxcBnimZcKhJZociPabhZVA8QdMuMyrWz9R0NxPsmjU +mpRD1qyvp67uEwdw3WvNvmQ40ayNp3e6oiYVFXpvCjeGHYmVd7fs99MACYg2lSQD +dcHIgGbhZPOIZ7Sybx02nbk4PnN2Q3WJAhwEEAECAAYFAlNNmdMACgkQLqdrnCtG +bZ2W1g//Wp5SaPQSkL4ylkpNE3vck1JieCyYMMUm1tXpBwn7j4HmNeWskhCXksff +Zrboy92W8IYLScgJN2tnsQxyoLrYNbxiCPDz1wbqSbG1V7JvqpSTMIE/u2dKF8LB +WFkK1wZpInXWw6CrPJPL+/YsKbnS1yyY9/KMIuPKFp52BPwro2PxVByOTYZBilul +qMXqUCswyYPitdmG5+a3LXFWurlOHJrVm6QfcuHqEBj3bIl5haRnvyBFnuXF9mQW +h5kur8kGPeOIrD6aXEY0Sr5Mrqen/ROLC9FJxsYiBiuPKBijHEHnuPFl9wjzZ5k2 +f9TNCNiZdHARlqPeeYyPLqShhlkE/RYe+JQsP/5in3Ag9Bt2omI8TenzqlX9Kxmx +6aIHVnMWX4nP6ncVUXG7l0gig5obPknQlJuXItRj8lJQ62L66VEBvNGX0LRmBLNn +0SQnpzpnhlUFn94dVPezcpipZ9rFiSgNKtDLxZx7EcSbdC6R3h3xzHlcC6lYjcq6 +Jhzgytmw+8/wB79WZZjjhHXz9lhK5aHv+/F5TACQCnaTEEyL24aFUjVTaYhRDLtg +GzR56oahvK3Ny0P9UquyHGVyBu55ElZyiBQjppMyVjoHlCmqGExef+w6ym6X1YAS +2nzLwPjLykPtaSX7sM0p6eAnETUCGQTdB7ynA+bHs8KCrqsoCVGJAhwEEAECAAYF +AlP7wEoACgkQZJWf6YON8ZxMVxAApS5mNNbDxFO76dbqFi5M48aVIq5esXvwDeca +DIeXfmKF6cjKmsQ5R90idBG7Z+TkxK/gphePAixDwgQCFzY73Y17OM0W2Z5HEvqX +QVOEW8NGqqjEQ1qV6Xy/CO0dMb4IbfUQSrqCMvQWK/kHIWZyhziOw/dW1OdPDmFH +xO2JspSInPTAdhYK3fviHm+hVrK6cyYRfZmvjKMKQbFPpq0HrCvWOnNALjdYnJRT +IYGAZOjdLU0qRHzREpHEQ6aS8C8IgTChWpT2F5f/z4YWlwHg9UC64zHVAM5AAsgp +D8fs3S/7p4anVhAB+1mtTy+z3TMn/HPOk9jLwPwTXaenjto0JGpZ1zSmyQaiOBTk +cT3btt7imZ7jf5hv03caalTGVdRPZiExzvMrnqAfss9lce0TT2ta0PJt6wi/Ir0O +KHgfxWGkHb0PYzCaAcJnVXYSElS5lQQuwDKsjEs5QKjfIGNE6T1/es7lHkDotuvb +NUOnvZkLv5Lm2o5JF12veeukQK/2RY1WNY909cOrjDCLo4PmIjgVOqoJu5vsri0e +Rw8sDgJns6RTFN/fD+5fp1QG+Ev3cMcQ6/yEqE9heL/IT1YtOr3d3YWTT1B1IYxO +7paSl/GIieq+tapj15pdDF9suRNlJUZoVkS82PNqKAG6OVFWmoMygTRTuFdmTNgR +2TI5oSeJAhwEEAEIAAYFAk+tJGEACgkQOTWH2X2GUAsd5g/+Oo1I4fy6pEr1HjlW +UTcy8yhY385MVlSZc+ZTEEpVHSz/gT64UHXnICLkUWSkUb51ZzvHBS3d9ySneyfp +tsPNxSlwfiRkKMYFq9fnXJNClK/xiR3PDZKlP7P9sPYmheLmXRsK3JOfXA7bYwVC +I9muAUr6ULdct6UFwQHkfj1UXXle2uoRsahh0Qr9XXx5p9tZtCJDEJOgfSAJFF7o +SaBdVcpy2/Gf7lg5kRBpsACRa+ZyXYpQSjcnZwYpt5LSaZV+PPpw4c1Z/0rVjXm6 +vaDrxsF60t9FUY2GSoKsguojmbFgH22vlPqm/dtM9yx1KxoFtebHH+hzbp0Sq/tj +C66jwx4Z/RYYiqz99x8p+4ds1gDf4UCnLK4e2/qjpWwihKnNT5zOr9PE0yPsMB4t +aWKmKZYQGONSV3ZB0p3kZVG+ZiF+7jrplI3GbKm+9vpTKXk7RXYc3KnACQdvvU4A +KRp4qENJZ4VItVkToXzvy+ZyxHZbdv0IyHtaAcp1weGRj4e+tnzCCkqwG6hnQu77 +bzj80QkHEV+aoqXW/wYRRwpd+TqzC5GvqbXmzJP73/DSeP6kNF42/TrlfvrprMaw +uAgAUAP/4Xnkz54jMOMqLVZhht+ChMUJqmVfYEioA5p6LH8pKgQBtiiScTgchtmG +p5aWoL3H7ybhelC1v+tHqD4L3RmJAhwEEAEIAAYFAlNZzZIACgkQvlz2h9xat8JS +pw/9Gld+TtnIyu8fp0VhUN335t+D8w0isQ1A/4uXX/W/v5b/zzkNBqINQYYfBR74 +NP4KoQNXEjPlSwXKbYaF4G0KTTTvRi0YhLSla59e1lVBdkAbBhXFaxmSWtOCHBoc +oYo8q6DeShWs6rc/9xpjF/KXwGf7HYhtEVCHukHFkiPiXSv+c4n49mR0huOZcPTH +jjbeM7magXlzt3kLIq0ywvTSW82OF4K4T3wREqj+T3PUoCGEbRC2k31X9ecukr0P +SeKLgsPW/Q+OgrhFl5wkkM8z2xyY9F1BS4IDfj+bxy8B6wFZHlB78IAvW4dEbYvG +mjTMlUiwXuwNQlfJF+YzGUnFLvHPcmAlCfVuggsCA8aW91OirB3ca5VDyVTuJq2j +6fsNd2OGT+1Cu4MTFbMAHj4mcckCQHg4oFRpFN9Lw1j0D4MA/l7n2FJwzHBLhch5 +cKUZd0VHszrgQ0rjuuEqLvTDUqPPBYjdPrvunYsR0g4ZPdgOZCbPzVo0h0+lla74 +OnNcnWrC6QB2mbVPRNHVNn65fRR6PEHkiB5/5sdIsmtHu1T3g0cCt2jieorSo0QY +EZZWT10l+JJ4X+w+DXNqJoBI3/yxXQAArrOTVt1OZwh0Mx8KJagSJyVQH/ke1OUt +r9bMUj1/vYO9u960AkdLmT/7VO9mXBYjAYKSLVNo2Os2cWSJAhwEEAEIAAYFAlP8 ++F0ACgkQ+mQ7ph0ievtlzxAAn/nTh07a9yjMgR1YZ9DTBRyGC1r2fQ38zSF1829/ +bvea3ix7RzFmykQEfQ2eMns7Wwzq+EkTL7OWY+Z5GDXdWgaCpf2v/6iH35vY8xc8 +u3Dp3uz8crhVKByL6Yo903gwObrqDUidRAQw5O7PTA8q0tUZ61zVteMzwXcn9pyc +DijrodaHBU5KC0cQeG9wKH++kMWIgDKvwxNT7RdaMpynvOX7GUxNaJgCj+VyLwe5 +hpOCZxw7LqgheZrrpkk4mgQXW/Su1pVf7gohcauCgNKnyE1siVeG8gPNPXYRXBEP +7mCbjfp8F7eqYeVzm2lbEpKpSO3saIPkaFVmSZlXYxM99X7iPu8mOvuXlBk0Qy60 +6V972rOKDn5dZ52ZJOWHFwIjgMbtcSByL7Za9fuym40zoAcTuS3HYgmAZbOmuiBq +cJWq2tmRa3oglmhO5chT9q8LoT7Q4dD2B/KUYaKz6V9Dw1DxfJGZ0ZHH28RcJPpF +JXCUGSpvy8+sThP/M8IluIXc78qH5+RiIJ7yRPRhMnUAdyoXD5RqM9aed3NFTOgI +i9GbmR3fxkFRSA630evlYRZcCrrEYKeiCXry+vuWXTt+gbj4HEudA67KYd9kXf5U +jRL2RF1jZpLaen6bv47XAPmR74oHe/duKCc9+TUg4mLab2LHszvdprawmgEXoWRn +25mJAhwEEAEIAAYFAlQDssIACgkQZzoD5MHbkh+YoxAApW78yQDKpiXEpqKZGvPm +wnIjaA9Fug8olQq9sbwhG7pdyFcWmttRu9JGimRnhhoHB4MKkSZSPOG5ny8FNzXW +qK3KWHj5nqzTIMlpMOLZUabYK26ocqyiGXNPUuUstSkOuiVbWmegjLLZH+A0B8HB +f0bkHztmlQmS0mpjtNA5FMwJsRhfEOFJH22VQZCInBg1tgSNCHPbMtzNdehwTHId +BO8KrWEJHmJ/MKhYS7cR6XibHSmYpBovE7AU/ufj7TatzobHRW12bRWvzEekyKAj +XyafpdWcWhQbVVzCuAMFYKw3vmoE+3AoHSU0nGfHv4ajTtXlnkEJvP1bv31tQnd1 +1A6oZNM0VFCXAKIiq17IFi4D8ecbJklu0qyO+j/8ezdJLwTfYx3qalfWzSCrqQ7K +5YDSPkkAGO3b9eb1hh0O06sf6m2ElgqVz6qVXOfj/Jh/YmPtsoajhZ0N53kcyksz +ckBx6JCYUl5JDyutNVlNDIxhWmNMVcymONOG9zhh7aR8gkLeaCpedya4EjYEref0 +TwWb6Zl3vC9Scigdwm7YkrN8VS7k4l+5qKnBJ1tdrMg1xv4NwnvSmXI/1q5aITjs +C09DSZEZ0vgcDBdCQKYNrNcR8nphLUt4xNGS1omwSvSMWeocOb2e81M4zXKcIxwa +9CHrmex8eBYimrzS0G8YGxyJAhwEEAEIAAYFAlQFHCYACgkQwPiGTNo9A1hW5A/+ +Khpi73IRA/lkm8ZPYcu2dvY6EhlqmkhFNkBSpO3TLbIpsatvGPSocCiD0oVe5fgZ +8qa4PwzFTH9YOpZH43MLu3QvzdTUvJ7PMDxrC8ZPW7zRtBswK3xIbemJQFmUYgGH +9FgYFnDGA2d2p7WW349nkndL0prMFBcM7ClECBD/TbRcMbOwTd5Eq86+H205/Ki8 +CboAltn/wYhtqUCAuQUisQEgr70v5KtlxCAcwieZJUbBiDeeCdrOG1YGHObKKZdL +PCtmSYYLAAMf9qhlLT2fYktIIg+dCqUhlNFWfC+uPKQj4CpNwUX7s3GaY8kGtJlB +KMPvmo//isRIlIWfE1oIrN6d4bFtpRw8sMZHCZ/qW5kzWZgoAtdH4gOyxjyQf0yD +uJgFyJ7ea2X4z5yoP3Yh3+H5FdSE9wED/tdM7EfgSyCBrfgiBOinzv9UkaQP1i+I +L8r9nnyqhEFj761lzhd7bcjJYUwXlAGAAdV1cVBrYEAvf+QKx5+Ryhk2S2z6fosB +pYYlIph3z5AdAd5QukerfN6LMmcSL7OfSFihP1NMPNqw1sNy5FzlhVyfm3Uy1Y7F +VG7IIv+qwJouoP88+6+MquJkR7DV5dCVjRRzL6B/4dBY+rtJEdwLDIsjd8RDXReo +y2Z9PeTzyG1jU8LCHpDV0MFdR7g37brMDLgJAkZmAZSJAhwEEAEIAAYFAlQHvuQA +CgkQO1biu9U/3LF0PA//YN+5NHOXrY8oBXF6QaSfRncfACwld3Qb1WomO8zu1AqG +8/V6phQqd51Jm2rmWgeOezYqfG7eHJYgm8ZzVE/UOC443gCSC9O+eth9I3YkKZK0 +oRgGDmZzPSYr49PL65eDA7LIPAZlAIFd4RWrMkVCoIFdGEyzD87zY6D2U8TAEIoQ +o5AKimYa0NmQjJ1vRIDB72zSTyhldaser0HEJ3J8Akltq8FQpcCH/xTYTjJc5IYd +lX95z02sb+Tg9jjSjACsSSh5YAKu0MZ0p5Qb1zB8OMn5liFqVhz+JC5ps3pSF9Ko +ZmM+OoiYVtVfoBVg39Ath5c/dUrkexO0FT2nUyFkCl453221OiJ7cUeECyPvBQUF +61KXOQ20W9iHONsrDEi6q37f9VTthP8ypc9TKjMDFfiN7+hdEtxyWlj1JqhBjymz +T+dJTRSHsKr3jkzTiYLxm6mnQ9YFglI4uZ83iUUBq18yOeOQMcAu7IhJYQBG7nDy +y0s0XE63NHpiFrXYmUQX1Kwvsn5H4c3QewmcQtasuMDuxEW74btAKny0ikTUgEeI +qiPPvXy0Y8x4trOaNY9IxwXovV3eD164sY8d4KPXypXucd1QB/4hbAiArtHFrk5L +qULRE80jtJKPtSg+Lb2xoCIUNDdlLxiGjMM2PUWJvKA+YqFUOXxip+mzmI07XEmJ +AhwEEAEIAAYFAlQcL68ACgkQ2SnymSvvCjOeVRAAt4sheJ7UJPRiJwCqP3I68Enl +2SwbjcD3fruByrRts11YAXGrVrLX0TifZ7jU17Ka244NWVc6fqXYiBPuROaQRwRd +JiC9iEu2OS9J9Hw4HiDiwB/sN6+in1OtjvhhdXkbPENl4rQDkHhBfU5uU2feu/Wh +o6reUsPMQOpoQIxF0PGxy4IRLSFBanIIKus2HGlAT4dj6kU40P7h9EyaVOr9TMOT +PBZBOof/dlHFyQennU17PjlY0rQBiTVk5r/kwklJJzy/fgfVia+HABfiax42snmy +rAEoT52JqcewYLld/qezKsG+rAk/TsxfBbkhoao6vUVV/zW6/A3cAue0gVh1RDrx +UrytAZC1WyRIKEuIp0h7Cog9VkDVtElWsZk0i5NBVYq2J85f0RQaVdQk4cIP46jy +C5x3SZ6oLTPEBZUc1eRI5R2T5NByZLYTfRE9XjyCp7irvE8iFZ4zM31GDWfK4yYY +pMHmCgA909it1pUPeHYKhpUsxKzKcAZaQwEpgJivqTrJGk0iTxhtWC1humFVkPuj +EJnkf3vZXse52pVtGrGk6cXuUoADsaOukueYJecM4L7FMPtrxPDdGdvpCPgNPu9/ +LL3Y4tXtJChEAsGgDZt4eQC9MUYwXcu8MOA/03e3jK4EOVhNRX49iJZsvg6zjPE7 +f6D+uioCTmfF86bnH+yJAhwEEAEKAAYFAlQCgzwACgkQHnWacmqf3XRlphAAnJMe +jqGCjpMyh+0ox3D65sR7utg8jYB+/JuFjyWHtpwkC5HvsPvHxEtzUly4d/3Y+cwi +1d/alyLjtSXFO0XaJc/CTkgQ5KQUsKUiLguqgJopv+grTDpQzhJlEdGI4NU5zMPO +nk/PkBs4VJLt7TP+xwz7kfb/05iShVydjxb5bB8c63v2ndSeJtEiE3v0QkBxhaQh +l+bp2aPELec3pf4YBmKuJjY3VryKZhgZ8bsmr5Jn2DFC3jfZR0vPj2DBxE6ZemJ7 +cyxk3w4+O0t0b32XA4YCJpoU0tPKPWVw/p+i3NDEXGD0v0TrR8jSzFspyBPBuoFA +JaBQYfvD6ZKtg4LK8BddOttIJwPdoxLzYWgtNoMRNDJJB4EkJK+9CzCYDn34pqJz +4qF41r/CZnoLC4IU+1CfTg6zM1LciNGpEc6ALXVvNHC3/yOpuQ1VYy2xEy7nDAVX +yiwW3NG+SlAnROZLcf19Y3zZZwnpSH/dIPHAsA75/A9wRRev0G32ZcBfwHKyju5a +n4E9M1rcNP+pfsxf2pc/6PYI9snZavNVWpU400Ie/tQwlwmjflUE1aDiBwBAjucP +f0+rBGkN0nRK/vY/KvxdATvjOgVJrBhFIcw3SuwI12c1k8dnvaoasHGjxKRh+7tO +0Uek0mzkraMXyuw/zgFPbjq+Qr+QDfoQhVI121iJAhwEEAEKAAYFAlQHN7sACgkQ +A2qcJb81fdTXrA//efARoSayc4QLJyHuCBaq5MdSuw8+KJgaqdUKQQ07Og/WleJQ +LrZD1erPlApXvLIOUa5iVUTaBZCGqkTuMt+hCG7I5VmSw5Q8Mpxnyj9SSPIk2A4n +cOuKMWHgQnvkJWjSxUCAg6tRFN97XDrrlPLJh4qwyeRi67mzwBIUSxtIzEx/HEAC +nZegSeltx1Ra4BmGOsHeA3/eR4ABbzynwHBKnH4HwWRMJmr5wgqfVzK6bBYpYLT3 +lMN6yI3JpVtzdqNZTdKI6f0jcp4F/0VJIuqbxGtFjK78Y6Xl0F3FcIh1EjYdrT6f +wi/VelZ53TaSd0no5IcGAedOyC6t08lPVehPGR1qXhOHn86YGzek0oAbv0IiHyVj +ufHsURgRMy9ivEdu17HduTTUWWrU9HZ8R6JHVY0V9yF5Vl57DixIcFH+zmevxWZz +7uMVSKPUO8DrlFNtJcDb0ITBcBntsBgN5lURGm2uAbaZrvD/+B0sawSgBFnwTfdA +TfKQ7Fiz/eAdXZjgCPoJ8ANOMuakcRM3ip9QVncQ6UJtPQI89D/F7n43iduQwTcC +Cv35ReeB07gc/yYC/A7oAtsKP1QxwIXhFOTiOMA1BF10GwxVAxzhC5n1eFhOAmwj +CRty8ZXkMLpahYfRtxxtpRVdaDJJ2xdJ3hDDFNQRgr8VVuto7+OsGDgJ0bKJAhwE +EAEKAAYFAlQNGwcACgkQdRq13aeWecw7KRAAoiEr7BufbbuV6f1tGHyjH+CyJZRx +oApkhEwv8lWCFlSqEOjb7jxjYPr4/760ceJ88w66dVggy68SIymfYchL6QVGCusH +RoBxBZP6qss9BMfCX9EzjXPjsWGjiwgoopPHpkjePFsxKumZYsVfzsX3SROc1AFQ +7ajpbv8iwXSEbreblzJadImqD9IHL9ag5Uv4qoFO70QjxXphP4bl7S+SIpFAOiuA +hckUJcp3M2V/Ocz6xTgBKiNgzaDkwegYQoJr0UuverFBMNKSKfEgD4knC+hPwTuL +VkLOSZmxcaWM1Ea6PPnV4Bg7q6EsI1QJYbFFADYNsm4vLcO02VM76P/IyXUuaW8k +BvoezB+oG9hepQkpl4zSpzQqLfMLQCqoV+bmpfXcLkuYjMAMkFCjTOAr+ZQ9ROd7 +g9NDyR30oQbTXgKpHjn2tEOgqbPrjxm+U6ELXxy9qAVx31CUy5NQXvam9V7xOjOZ +geHOE72/9xI/KWa79Giz66wbrplY3wwNSzD9gzkvNdCdhgG1FD+yBT/QQqlkbgx2 +mqHsjuS8OM37qUvaRTOmi0KIyqVKlQyK0LwpRqwreht/bTaxMg0VHr5rdokFNSER +JIvna2MYh9DoOIwWcHbxTEE1RJyE9ZAvQGGSP8JufD8JhQOqG0sYECG8TgCXzWuJ +01K3kjzNt7edSI2JAhwEEAEKAAYFAlQPVewACgkQbmCLY32JZ+l53hAAgi8+jxfY +AVlEsfwkADodZ8ALrj+mgdJ4Z35PJkQnwVoJ1PsDtkjauuwG1Rr6pyd8aATQNxLe +6aGaJuGBfzVvpzKctJtlPnhcM/Tj5t45dvkgC7gW8ivN8GtHX6Mk1Raz3GYQXhLK +zlLgH+4szxqTD7oiUygn6BhKTZCnCekCfp2oFdsdnkiz71ml6SBNg1OePHDxWpzb ++PI9EqPk1JH16yRxfWa0Ffodu0yknhlq6CJPZQS4u8U89GEE9LieQYZx1jgWzFz3 +hAKgrfSgeYJtor1iUtyqkb6BMwOcmIi+PD6oMuFzqiAmxU52Jv/QACu0iEU5Q2pT ++167YdlWz2SRx4HEm0me0y3JyUnHvfsIIv0nlOmeLBjo4p9Lm68ubyqjukq3VI5d +fI2lqcd8gyvGk0WM6R8f3Ky+gkXmhQ+Kk7vQMrIYVSgQ45jQ4T+hjp/q550sAdpt +1ixyur4biJ2Wgg9OhC9bsj5hcjdAEBLyxtq8MDw3KcpmT9oJSOY5W3QSUsUyp6QN +ETTyel0ozv9/ZnUdm5rPkYsNz5yt4om23YpAr8esBIo2ywSDsTjRdyq4ZyNgUux8 +UVXr8ztU/Z3jo/Ek8uRT3fcOMV1uFCX8KBCUt+pxRYe6q2a5K6hSoqnZX29eWfAe +qkEQuLWPUwzxw2MV1TXOoNUQm88FKu+CmNGJAhwEEAEKAAYFAlQPZbYACgkQ+z0l +gztqr/icmw/8D7mTfQUuGHUzAV9lt8sqvzYLOF+c1B4ARfbzVflyGQOP+6OwrD4w +AK2x+FEDJ9iBbtcFiHcfycQbSx1O4EeDex4rvxA571P6d/WvV0UQX3JpMOw7PzdT +XQLOtmLfcehkQvCFESMot1s6YfPeTLGx0DtRUz4yY5HE2nOOUgp9vPb1UbZx2l9Q +3FBRm+xTLt8hmJyyEFgAGULxoou1WPWUXDeDlrRR2F5DRYums3cgnW/Kj0wOEt/P +EMbNmvEPjgKvl9s/PJ54JHXkGNwumIbVhY6jrz6L8DQfDTvBYkbWpCZKwQngnQaz +1Aj36IVLRBgntUvQJplzViRJqquIVS/8/uR5aZt3p04hsh7bMucSryST7QJOl+9C +lItuCrTJ5Zvr36YjW6ZmDu+YIkVTRNBjomy0MkW98LyfdCizMLEJGbDbMEL1tNbS +C9kwGRar3Q22mnt9iQ3P6DDplfOH1558Zn0ROCoQ345i1WZx2wdCwkPkH9Qulw8P +SGHpX9uujckzfXp4oB4yGrXuotwRMvKLCPR3CzDmQkfnjtWPgqGuf6jVH400ox35 +VjiwHCb/K+N2L/ruFCUqkka5dq5rq0lTMtdfvinoHzzRFRelrwPxl0lTiaMQghXK +zzpwTKrlld+GAfkkzOrF1XosNt6DfCSdwmSZV+WYgRBch5/fxRvFk6OJAhwEEgEI +AAYFAlQAsYwACgkQT616dThFWdtowQ//VG5Gk22TLp0eFVHfr0WypsS04G9zCdAy +C3lGdRMZ76KCPzz7yN82MfZMmC+bktW0i4zQMW327jW5CIeiVG/WiFelXP/UYpB3 +nRAGqV/ylF/jlIhq6WWXOy16XdUzb17FfctH+q9fA4U+iKYLt/+G1zKyyhB+ATx6 +u1CW8cY8j4ohuok/uocQ1W3P595IZlo+0PACIqZatBzYQQn6OixuJ7tzdka4PVau ++jeLNYvZIQyy2pDKA8AwwIb7jvFXcL8eTN3+hopKiBqnNJV5rAuxUL32mwMMN5Uh +2RQOb4FaR6cAliOAvUmZHeruzhdhylGDdHOW9WrLXq1PiIKdvQR9IDYbib7JtwEp +WLCuc/vy4vVXYL9SMIkQZZRe6+NLxqhu76NQVccS/Omeg5CPMBtpn+pvxjsgrXXa +LRJD86Ya6q2y1gtjC6VTknnePE8KHHfvaQPwkEtPzLVSqI6NhCuFGj/ddfoKcaE6 +fJTWjWsiUdlzqF2GFORHUZbO77SEbOmejmV7wnjFqgyVr0F0lRF4dj7TVVMfB0xu +b6MgJFLFasA4Ipnzy5Pd66tYEWXDxMsBBRIP6sfnShSC19l2YEUObYHR018F05aH +WsEn4Stq1pYa+0TB4U1+6rIjFlzai9Hx+7Jf2/ZepTVLsqkkjZHc0VTCOmsipp3E ++YH5R4lMhbmJAhwEEwEIAAYFAlQxjv0ACgkQiHtgYYs8Fq6QZRAAi/AIznv7OKJy +GU9pML28dPrA4aXCJLV/vEoes9c2fDP1Tf6dkEXJM3ZSKrf3pNd+ddbXesqk9MXp +iy948Ahunf7FTmxuBTK1qAxjdbr5+8CXrk9G4G+qr2q5y4GrFWNTUii7gAKe6CkT +K6OTZta/1v8I6fukpmvMfkWRJ6kCXLynlQs7PxOvQtrbNg33i7i1udK2bHl21LRo +ZE2CqgvU5rXK7s/AC0Q5S14oQn1UFE3jSimBue6fXB5YeL6BK/8XWwB4Q8q1211z +fmltyW41h2VHmNMCA3U1yfa+V5/GzZ/OEmr0Rc/LVkj17heAPxBNKL8njAKW4VAs +wh7n3hxDlHjgUJaLYSFbo3XkI/JymT9CJu1AKWijpN8pkOxvBcK5d6jT6oKLUzLr +aeELEMlwFULTPSsWyCFs/15lad+G2gHPzVBo9Shywo8CQ5HxLzEubPvSU0ztTRvH +jj2yZuY3X03h/qTExhgWT7YYZ1PqmEskuGQf7ZEBm2MaVpN48wTf4uAtp2hOoV8v +/jtu7e4Yn40eHleKaaTqneX6aCfq7NTw3aivCs7Gx5vF5bJ4h84yYnNFDjeLvW0R +NTR05GigTfBo7wFhrNcq9qwLt8L+EBQyjej41aGluch7VpddUzm4LG+F1mt0Rhj0 +wXPpT9UUY6cuS1De+ZQrDlJy3PiY9dOJARwEEgECAAYFAlTQTv8ACgkQlOkt+Sqq +XDvdNgf/RPXUgf0Rlf5TGlUAs+DPOtyt1xyC7pd76p35Jy3FhaA+9rx7qPQ4O3QT +kxXc2vYdii1jFUpto1hr0+qmjEUKE+xGokiSFt2lYDPTWiMRS72C/n1yx4YFD0iw +rdyyKRA91wIr1UsWTUN2fetyZGb40SlkmfDYQ08/e6FOf4fQr0u5cWMHAgK7NNCI +u6POV+A9TYfyBPPwMr4SrQ1lQbvXQlu8voOulVTbjuL27+keSYqpqRR6VkxzMXAc +ZqOTvUmD5Sdp0xKMwkZc/zI255nXFxrdUo4YcllujmbEx5kOwD8oXK1ICr1t9I0h +UKseQfkZE5FF+BlO3GMNM0XTnhvx34kCHAQQAQIABgUCVMYwBAAKCRDDjoFgoXhB +/vhoD/9rSe8Kd6QhhGdfABJJFLm84iCcIKHd8cFJACTTW1a9nUV9zBXlFDLSBPth +JC3pRIWDXkfbcjwWRTtsZpsaoApmByxra4gLrBnSFHnEBmvsXe6vRonbfLXTKpSt +jbwjyYgccdIZaUXFFUeXA5A6xcYTdY4lOfXQ4ogPlN8X1tMc4cS/Iia3zATSaeip +WhN61C1SZol/b+DWOFppLHEgRP9ATU51g0uOtc6ynZ1LKRocHxceFOpLCdlPpLms +avLLCwH4/YXrlv57EEndxf1zwt7H/QbDzXb5B0zrpL6zTR3wQJRmMa2IftbW5pUJ +CL1+sO5YR2dUF2zwjF/oX2+Wn6TvpiV/zGmUD0XZ8RdnrtcV2LolldGNmRaP09NN +lxJ5GN712kx9SXuAaeBoqkkoLqXBGCre7CQUKz+jdY3HlRhRWSp2y9D8lQANZL6/ +RYerFnEBtMoO6tbirz8RKbm4Z62dlIJLJYJTKY0ZDJ5Lobh3Ip5QSj3c/3dIeZhN +Zc+nLuYJf51t49LyoTk8DP7oscpwEQ0wDjs+jlbjr4iLp+g/+uHHvwUvO1s4VROx +bEWMu7ySWCzCJv4D0HcH9s+o8aTpE9HAPkSBWYcImnTuBMnM0u0Gafnk43Ixk0S1 +Peuc0Z19OyC9Uy5cxiizQVR6nn/k1oROZcdsWFPYrtlouRtGYokCHAQQAQIABgUC +VYAyNgAKCRBXkw2rC4awZzt8D/45pX1eshVM4r1QxIHlHww/uPqCvBzBBfRRy69o +h1E5NoFcuIwzyzcsZe/jLNWwMbwfzOVZwpSySTlccsBJicdcSWartKeTutIVa3MC +7G+U3N0N88mfZwkp1sygNvuDklShi1f6o1c6MtEOpuvdWSsQIExt/a1/8iABylOG +1KuYfQ3vavA8uExCNRE3LhwBYGImQjXqFUNByZO1cXE2XY5qNxcVnflwK1XDSxyD ++3DMeHNXJ6V5rDR44rqr1cDX/6cE7+Z8PRClr0QMfgnXi6koBRYSpYcjCBc8XemL +y6raxWazbqHyr0CnEsh5s/wa1gUeAIfEUEftFc9FM3cn66KCvqgXSiJH2ZnJEAuU +YyqSX6y9L+BCUqr44FYlW0/2hwpDztjjRsRtjdn/1N21mxAURDGKAZUBkR3E7HYL +ZZmKzQdo7ds2s5tKfcC+FGYq+A7bzVfPVeGIf8CSntIkBOFej6u+BGJURRcAOmqY +OdD0++gWe5sd0rHS+V2aQtunAMWxK9AdxY6GMzY0et3+Bc2Ynph/o2Q+iUc4Q0l9 +YnGpfPet+t7qtXdlkVfA64+I8Olx0oWRmHL4+Gmwy8cGn+pqFuGQ8AOJPH7zO87e +IQ8wv2/KSFtTA8BLIZTt7xRF45zOcfutq77CNEquj5IflRTKxVMTew26QNF/xqoD +d4Sm7YkCHAQQAQgABgUCVJCc0gAKCRC45Qh3Zkdarzf7D/9vaMoPU4An9RN2Q8Ui +nlin+n8dyoN6AWRSKVXQ6W10bHe5itsd7hpv6lW45u7Ce8i+S51P/cSuNdOOiWPe +OH64df8yaYS1ELTma6wHd9KkNA55s0CC9UkEmpArNrDBZZ4zqBCQQfpSkn10rGs/ +qp5Q6sNjeeobx/8oEX8DuwYOxI+d5D+1cBiqn5x8V2mzCOSPrmRWTq4dM8YTbKY9 +YfFXGDogp7AyMesg4D26WfTRDhdgqslI6VE/ncCEX598mVM1C/yBP9FBqnBANoa9 +a6triC2BmHPhLInKeCbb1onU4E3pKM3HtoPhwQK94vBVzHpbIjDE2sIhBNIgOOkV +zWwGyNfyiOw+QZz0dkY5FpH88keSMYN8p46sZfb3+Y0u9UVQTyOC0iEHMXjg8Rj9 +NQmlJywW8SXbU5TAg+79xR/ISIW67WPBCRoUZFBMHf2r95UfmgyYsjcftQQMYcX/ +77JTJA9Acm+ii66HcO02h4jg4s2Ej/EJZkZv77JpyuEg8y0SxrQ4evYgDK264VrC +J5ODpv2ugxvy2sbmj5KzD6bNoCSZ/9Tm0Hc2hsh87GusfcQz/kYJ4flXO52eo7AO +BCqBakpoDFXm5mAcieCIoPXVpu2begGi5oVV/hYa4b9ZEVkreYMXScIXP1QIKf+c +AOy1vd7Eg3O5fv0Cnok6Ug8KJYkCHAQQAQgABgUCVLSGLAAKCRBQQfGJH0TgkFdw +EAC3e5O6TEo6ehycoT/9nycdM0iPuuBGBC05m22pkXVk+H0etkS6P30h1q4FCj7V +INkEhFEAVfdKLKJsHeAC/nb1y4pOohsU+hNqiamksOnkSn4WJnemLII36+l59NYk +mSzYk2p21Na47MEK5qoDHF/n3Qb9D5GO13ldEbBxlc5uu5QrHJ8BVb8KLyTlr05T +2twyKoT6uTfi+dcOFBFjJvTidl0N3vDMOz8jmLbe4XnWeP7ZcoPdzpzk27IQXhu6 +ZmI59LIko7cwQxeLHgEb/so8BP/+R0ngVuqio5r22TNGcEkOj3EAMYKqfK7ZpBAh +AASFCKGQ9CfMv4yBH94zJ5ESwgD3UOpv2XdLUP1q7eWYBb4Vq5BDZcVt6FOKBOcG +8As01p9o/CB8rztgPLv/X2J+kyeX6waTJy5fRS+JwdZDepoGEyMpmVaJlZWD7ZlN +RN1qM34TyeRM7C+ZBi0UqNAiF8PY2uwX23Q8h3YfgKzYIX6WZz3ASC8m1ixVbhmf +cNICVQm5p1Ug2n+Pc9QWEE4TkW2Gc6ExVnYwQV7/BE/8DWt1qw72nrPIDG8sTNow +ZnLDnwS8AutdeWmMPuR7wbSeLz97Tz8xA/sIZIfygJGcaaa4RnALxPeVed/sc+oQ +0F+0Gao8m1ui84j54FaOsde+HEKtnOdNLG7DiQcdINbxNIkCHAQTAQgABgUCVTbN +PwAKCRDHiMTB1FUNRY8AEADKxXG/pgDzm1qt4W501CosJ/mBt5iWYkDyy91xUKce +y4Ndh7zXbe07niZxuw+EUZq3O5LmLw34L8mlixWjnOhMx9ZS0weR+oPSwZpcpjs2 +bziX7Fx9VC1Et6eaT3K5m/HlOi9wW2ygfgPou9TmYGu4vK1zzcZ9W3G5lqsgfVB/ ++dsAay5Fqt2cGf9jMxyYFSfpBDVbBOW2USLOKXgC5ZI77i8wxfWKG2SHWfV/b4os +NpPygSBfoby+EEb2SVA9c/cecOPLcwXFb9NynrWsLBbEo3plqhb67aeIYYeJS8rY +1KYZgQmmcQ26CuIQyfAHfZZwySkaBB6v+hEnmPSatT67/Im/Nze3tq94bGK7rvYs +x6TeFolWn9rdJyG+n+ehnregM3I9LoiJDLS+sc2FqJsRufN9Qj+hYPDUrLvZzRHq +Wp9VWk2wUuRBip0wJdLQ2lnb/otmVYzUcpLxS7+2Y0mzkizKB29OI+PSgdVZJy3Q +CDNMYSvUSFXPaqAqznOR8Vi6NL75uxPfp+yZRmpWHdQreWXMt/0XX3eAXqRMs3E5 +BxGk8BzgADp9tEEwPYJ/G9YU/FC8uHevUc4GMkK+q0qYKNnQ+QNDerhocUFLZ/AL +2inEOZAH7VGtFij0lUQiPvA5aKg42O9rChuPpZ6sOm+GfU0c9iarm2uEyX1Iuikh +cYkCHAQQAQoABgUCV1uYvQAKCRAtNH6mqmVCHbLbD/9th03IvCN+Ke/SiWaqsiXS +kSlD/TyFeibRcP3gE4wju/3r5Apb2PHTC8bluqPr1fYpt/NAjlsEfcfNC+9Tjv9k +JtV4C1oMYA5bTyYZGGNJWFGU904sRRpKeGSdrXoWCrhNIDxhradPc1/rnRd1ULdx +DdLhDzyEZOi7XgjpY9L/qXnoz7MdrPO/AC0TQNVrxz3EWxaRHCpAMjdn3ZSCqpmx +XbBw2CnQ6LeLUZ58dF+SDMUtEnzZM2mgB51zaMj9KngeEJDLeReC3/ibY7+ni9Pm +Xvq3hHChiEE7LyUdGCWhbrtU3Jg2CSHJmNgBx9X8q4kJp2y4DKZ3LBIYUVMuEm4G +Z1TximJAZXl8Ws0CFKfIhX3L3hWeiD6BHBOpYkiOaG4WKXgY10Zyd+dETdHLHBwo +wIMay1LwG3yvk/ziEbvD1oAU4ttdVwjAivJqstT7OwKh2rE+cOB/bc7BcWtNkSoI +bMCZnotggMRzcT0VsydEuU0Y8+r158VAAjlqP6mDizbFm+pWmUxkS92WZomURn3U +4E11T6e4XV3fOV8+YkK6WlZlKxrZnNcq+XN03hawnS+Ae+oS6+55Lf3/RcYnShYq +Q+kxAJ9lP5GXRj/wqoPQAy0fwq5enXhIAxKGaETGdkkr8tlyaPVwQC8jiuhlA5wc +9gBv56BGSzRNvqO+jB0XX4kCHAQQAQIABgUCVt8E4QAKCRA1LGcgseO5K2xOD/45 +CqNNk/oHtSau9vxKuj82xosS1Nt1KD7rPZcI24vFr7gESqcUYrH/kkxUsGAGIQ6y +jAcd+iVdYw1wXhivjER6DYWAcz9JxbwgTItxwvhRgxUGG1vwl8CGBOB74BHUSGdW +jfLl7gSTJ1x+8ksxQrlrLa/97If+iAe+2kprpGAhRZrQMdeWSyBKUDAT2cDrPQdF +55hwdYBDFIcMah/vP9dh9h9LCk9y39C5rlXEt7/JesLKPk271exh+reroyO84V8x +kSbamu6bYZ9nqBCaOmjM+Sbf8eYyY179EZoOxjRJvrVVa3lOQnxUSgQIMKocMTs6 +/4yr9U6+m+Uf8ZZFFGzSC0365JacRKMdw8mkTyLHXbfAfAY+YBOIRbc8JUptzoa1 +jpedBOP2DwOMnS/f/YaXX3bewOMDUE7NBA6IY8dbV5SScecG1wxQ+TltOI6/0CPr +FjpO4KqR1FD0oH5sxHR4J7Qzr1nzhx1q+Prl0gwBX9fqMx6Ja8GyGUOb3BgKlrC4 +fPBiMdgkXIscsirRPLsC3Ub6tv5btOhrEn5/TXDcOxjBpxrPnXdgNx4+vRiikhqa +FmjJQ+OZhvi6vCM6K9V8fFowRkRpP3wbSD7te0DsLTI7bNnbFRX5NGu8hEZrxjVv +WI8nVtyNgRIU+qyakFzQSeN27uK5L2fGZfgCumW5sYkCHAQQAQgABgUCV1MZzQAK +CRAJSwnQndU0bVxfD/0XlwmyfG99kfidyqfUtrwBv3Ze9A81T1boGNTK3+lYazrS +XPW7D5ZfehDA8xh6lDEJOfY/rx6zI5r4ihdNRPwSCgOWQ3sYCp2L13G9+/RxU9hq +74c/fpJGDI4PZsSYu5tZrLtCZkfdhgBPYuAEJsFKqJMqwAnZEUEPB+Jcu4nfj7Hz +usopkmDDWZB2vAgozEabTXsTebwIJC0K6foJZegWZ9uZoShvuLxjsnluRFyZSkgi +5w3A54v5g4OAI/g3IwqiQA3BJNGbjsfp35P1NaELgRAgfEBfqIrc0g7TrgHRHU4E +rZI7T3Y5ld+DXt2lWUMOe/YlkbKAAVwUd09EMr75lm1ipwhqKnZ27A2dnYqKuvwS +F6KiNMOIiX6dWqtlLDLau8cH96ZiIvt5/vVMNprgI7y8pUNyciAnNvKSFowOeA7i +mrCEgZn0MayNZbYCNX769FXSeAgvf606Xiql5mBabLYG8dNsjvMyLWf/dLF9TsvW +Wju3540OJRW6JQc+Rd4YywXApqAmRiAyNCmkOiDBnDI7c6te2sACXbPsN4ZLOgVC +zQ9oyqAta7zRJmY6TE2Ter8Ey1kSH0HY4huOq8ixVhppOO8/b0hkmYm8Q6DTXyoX +DKGjtFT7eZireu18S3gIwP1Uojmw9hnwjDIGa0REMZa3XqKcoCc6sSKwmxbSEIkC +HAQQAQgABgUCV1MazgAKCRDAD74tkhkniKftEAC8/bn0uD+ZYTZAsfV1ZACuu3jW +IvBddWQnXbZAN0wJSx/HmMEE73CuifaMLPr6GyRBmUPpLyVlN8nrSHATr7fd1h+g +bLEk0HH4j8uVJchMqPP6+VnO32X5ri1AiFopa7cQmwN7/CcAgLMQXqncwa/Px7wc +98wrKE+u4zxTN7eGhcgoRmAoGSJp1uojXm3PTInOHiw9wpKHNm6eJgh9sfufpjIx +shWjY5c0763GDTGYp+cKm3useQitDXu635DvxQTPx+UJd0lIYPteSM+hfl3eGF08 +xCYTtCrkbI4GSQfPrq1uu4+qYwJqtei0YlzLS2Ea08aVIM3Lh4ILXeqqNGvT6bjT +oFYVRFj9jCF6T8E/H9nm0ZcigZGSq5zUDH6ajKIwxHukIjBkpG5UCo0fO/Wd1xf8 +YXuJr5im/3xPUnE7Tygg0xdy0ENhmvyQPc01dazVYa+/UKxSolbHlialOQWtGNpM +lhScaGOXYzvScWHa9kpcyMgBdjaoiUSp+CAb0HIUrjqIKOP0eFLJdupa9Lz3BS/H +0UBxVdbEPDhO02FHjj4dGjFazFdtK2kD+8pDao7e4UIpFQ6gEDQXn20Lm5qkZr/r +StbgifHkKNW9QnaQxSkxoxN5E61yp8jGRJKY3I7ylGzUfPCrESFSRjIEAsNqKYbn +ZjYQJ+8qgWJVZAZ7lokCHAQQAQoABgUCVyN+cgAKCRCHVo8VYs1RMnJRD/9vF+Ti +e0vFBKPQ4fjnBusX3ConhISzJ5dAlM0rIBhdGhvGaFiBXhPJBsaOUfSjRYJlTrEY +1quF54pEaz6jtKszRPcBFzPg8bsPAjt1zFrfio7ujpS0k4+6IeTbaRzjyHe/qGeb +Cs1MjJf+NRfAcT9ha0jvvplNylzaSSPlcMow3WasKp1687RZ4qNTHVjYgB14aWi4 +zqNzbT4AixGBmcN8NaMj3ns9c5Nq7WQMGNovEAcbWlkP3SbHRF60xoseDA8CHZ40 +vBGr8AxsozHKsh1k637z76ctxiWmMItRtG2msXRfO+iqU4RlrcmtpqEf/o9pBIAo +hbcVdS5MIEiSlGg9ammgkNQK5Tb8JzwPaCpnCnNl15bG14YH+0hPRHgDquKItb1/ +NrWMsmU8fQjR4cU9Dv896Hpc+d51V1PF0R9jF2DO0TV5tx2EdWlFoE/ilbMod1x7 +1fwh4rPWKOb/Lx27KGBVjABxkyTJwNlDmhU+8iafiee9br3QZP1Ma+92G7WuBylj +D2ox97abBKp5MWIxYBEnySAIUe8tulJ9pVGmgPQ2fX+iaAM4vd5lt01OUdA/0A/B +n7XgRd40fGlJWWk6M2Fxm0U/cU0s96giRLnQzoKJRCZ4E9Trt+vnEmNS2/vaSAZT +c91p4xckYRoYb9fn2lHKOgdh4WXOirT4Jl/qFIkBHAQQAQgABgUCV4EerwAKCRC3 +i5CPI0MPgNwrB/4lC6YcSIMZS8Hc8JAv7gzbKNyhJ3BEen4pFrUtEmKLeEq8D+1I +flRJgE+STKGWoDLKhg7BHP7BRYd9bOM7FdfrndC3TCVDlwjCLly1deYpPlx6IcDb +zAXCKcz9YLKUpGOkpUohJKCJrbm3xFNnDeAjstxB/o5xyKwNRhSgjAC2v7TYQ/FR +3Rt+adePR4drQTGs/1isbHhIHiLoMbz15w8s20H/25CxrbQp7QL+dtumCAkOv9rF +VYvpB5r2HYQkocnmMzx/BIzdBVpLHxyDZccoKrf+pe3HcJbQJ1PZzTv9bXJ+xlMN +Ly+u/lf5OaC2FnszvQD94z3urds2H5cwFsuIiQIcBBABAgAGBQJX1kl1AAoJEAI8 +BeLJwGjwsC0P/jBQD54x9rYoukN9WldSFTanTwGHYk2pgawLYctLPg7n5e+pLKh7 +KMa7VKOGytX+iN/kKUR/u6JWGxLsvjQF60AUCZ/Vsd4CSeuEqGQj7hGT66F5F8tj +ug/L+5mRUwfaOGgknY/v0hJ2vhNWRV+vNRLbg1VKFPvttTnH8wYbb4GLdriV/uiP +pYlH7Dc1eLaBxv/1vjfW0Prm2x8eBP+GGGGVpe+eBEeK8J5jRNFN9IeWyqk6yDh5 +3xS9WDC6Rr6epkBBBAzI8KoQ0BFoDM0N/7nRa+IIDo4z28ymXrZoACYtKUi+lBqd +7JyV9dHmAqRYDqfEgneuOJtdiFg0LLYxub3jBeO7ZqrI/9VhnsqgSJQ2HybAMwWi +ifGOo8MgRIMdJI2B47WJyvApkbhEN7446mmirSME4iRRwvuYUtwRgD64QSs1bKGW +/bTT5v8bshabXL3yZl5sapqSnTI1xvOdtdjMcOof24ZYe2IJcZ6rR47hGWEVo6O3 +cuqF5E+5yOCjZT5Z8sWZQqvpOMuHl3E9kxaPsF3WEs4f+m+83Hmeaommoocb6xW8 +tZsVxpYLQaE5NsOFXgntsXFRGK2WM5m+zoX9WtSiLX0Q5fHzJ+3QpF20KJRY5dMN +6mUJTcaUjrE4dWQqwHDQ0n8VJ1l/AUJv5e9nzdPKvc9H/sxQwgYpqev3iQIcBBAB +CAAGBQJXaWDLAAoJEIs9hnyCPnph76MQAI1j5QxGjykJrDFmKZWafWz9mvXB97v+ +3UATJ7u6Hcy3MzZeR0/JkVoNAnetqk9fU5CVaMsvw3gted3Yd0ZhqgLfpI1J0DFg +ViGuT12vAxI7RR7NHvXgRNiT2s2jQKp6r+MNsarvjG51QR0wQRr59uEROGkrHye0 +mEX9BznEaNlkVmLIZ8NsHEWZU4lfvHv3Hijka8j75MMGTugYojG+gcPKcLFF5tRb +BUZM3z1Jb3/DZwL8l/nuBOR6eBo0VBXAK1BeUD0HSowFyJPaZKHMMhshGmZ+H+Ak +qvss1y2VUKoGyX+a9GVBPs66T6dobqUXgwW093dO4NDZNtcZkGqViBRBOmDBGy9h +NpoOEqYoFOcsKFQ7OGQVMXvA3hNx0CmGprVwn5ZWn3WTYYCPaX215C2N8NWJsxm+ +ZIBfXYz9n3Re/HfCx8JSS338L6osc2Wb/DkmRYjmVay4S2nm+3CqycGyV5v/9a+Q +5QB2FyfClsT0IJpbmHCv9PT/nwOBojHRCd47ru2HMQLzsMO0exQE8JTwc5acpyBB +xmLJDeps6Ws7O2TDYNjNRYhJdMWst9Dt19eUIE9jZ8i6ePdGrHLHre/PRucKlLsr +Mrz8CEWbQfc0ycCAEwh9fy7vs7oG7hs0Kr77EeZ5mOYGSVS896Kkoii/TNzcBM/S +fD4P3CUh2lAEiQIzBBABCAAdFiEEa0msutz2vRyiBmerzVT849lkvvsFAlki8Z4A +CgkQzVT849lkvvtduQ//UxzHsrlOWV2EiO3Fx8lP8ooHhy+p5E0mye784VXM5QEK +RVZeuIXbTl6ezzWq/UmzEaMUO6VutX+g/OPltg8qbFLXzywlklP2dmp488Rqjb4E +i8eUBMACUq0KnM0D4JPzT/cPcg+0vrIH9gg0D7g4u7UsEaOoB6u61TayJfibJcYk +DXG/dDagDELnTNbSpF3hfF0y7oAXADJUK95gTzHlvE/gjax5OQTGqXrun41/1zyH +ZhulONYnoEZ3AFVWKLXk3kwEp0LZ5N5xdiNdKH9Xsz8gUid4sJwD3XRhtPQzkDBG +YvuTFlm7VAMeyLgLV2ho9wXXAvO2JVyAmLnynpYDnfiNKQ5+/J/u0ujtd57J9sCj +dW/LRBN2Lssj9f+CJvi3JaobuQ9s89srvisCfyit5607MVRRdbyZKgcaVgCcFyXl +MXVwEiogwamtxWY29ToosMysepSuG3yaM22yd2fm/W6PIQqPVCFMrVISERgHIoWr +EM/PrVobhVLM1j+LlmUYqDD9o5lZlHRQyWVnHn0OBCxEZ4WFwW8wlNsZxJ9ayamh +tqZHT5insaWoZSx4m/bMPIAy16CJZv1V0MoDyhluBMEK8ymeZtXKba+sduLKQ9XG +KAvcckE7cdZoNubsf1q4+muGF6NfvbfziUvWty+d7rmVtIHh83yFUkY0h0g8WkrR +/wAAVXv/AABVdgEQAAEBAAAAAAAAAAAAAAAA/9j/4AAQSkZJRgABAQEASABIAAD/ +4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkA +BgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA9tYAAQAAAADT +LUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAAC +BAAAABRyWFlaAAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAAC +VAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD ++AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJDAAAE +PAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXds +ZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0y +LjEAAAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEA +AAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFla +IAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAA +FklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3 +LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91 +ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQg +UkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVz +YwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2 +LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJ +RUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk +/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVh +cwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3Vy +dgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkA +XgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA +1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWAB +ZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0C +JgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsD +FgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0E +OwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYF +lgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkH +Kwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI ++wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvML +CwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUAN +Wg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P +7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMS +wxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V +4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZ +RRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc +9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg +8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQkl +OCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p +0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIu +ty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz +8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5 +fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/ +YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVF +mkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JM +KkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdT +E1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4Wgda +VlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh +9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp +8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfBy +S3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7 +BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qE +HYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGN +mI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqX +dZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUeh +tqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+ms +XKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3 +aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C +28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbO +ts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba ++9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/n +qegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0 +wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////4QCMRXhp +ZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAA +UgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAB85AAAAbwAAHzkAAABvAAOg +AQADAAAAAQABAACgAgAEAAAAAQAAAMigAwAEAAAAAQAAAToAAAAA/9sAQwACAQEC +AQECAgECAgICAgMFAwMDAwMGBAQDBQcGBwcHBgYGBwgLCQcICggGBgkNCQoLCwwM +DAcJDQ4NDA4LDAwL/9sAQwECAgIDAgMFAwMFCwgGCAsLCwsLCwsLCwsLCwsLCwsL +CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsL/8AAEQgBOgDIAwEiAAIR +AQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMC +BAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJ +ChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3 +eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS +09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAA +AAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEH +YXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVG +R0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKj +pKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX2 +9/j5+v/aAAwDAQACEQMRAD8A+BVTB5p6pzkUqrhh/nFSKMivSRgIqjuKeEB7UKvH +P5U9Rx2o2APL9BzT/LBGaEUEAcjPpUijBOMUANEXzfOM0oXPQc05Rn/PWneucZpC +GiIA9KURjoo59PWhpUXcXYAL1J6Gqw1mFJlAk2MSNoOAT7nOMD3rOpWhTXvOxtTo +zm/dVywUwOO/FBjAODVG3vnu5A7tFb2qNhnMitnpyApP5cVBqHiJo9wtxiMKCJWG +VznBHHP4D8a5/wC0KPc2+o1exqBMHDfU0zYGOCMH+VcbeeP5VfdLhDu2kp8y49uc +VtaNrTSrvupklkYcAHAHA/z/ADrSGKhP4TOWGlHc1/J4yP50wx5/Co7fVre5fbBK +GwcMF559yKnBUkg9utdCknszFxaIjHmmeVgfWrG0NjHU0xlwOeKu4rELxDqOKY0Y +A+tWXhIbDdeoxzmoymSc5pXHYgZPy96YY+f5VOy44pjjrigViFkGMHtUbR9MirDL +k96Y6ZHNTYdiu0ffoaKmKZ64/wAKKmwFhenNPH/16jB9OTUg+vNVcLD1OOvenLx1 +pgFPXrzSuFh6fninoeOaizjGKqazrkGk2jPdTRwHB27h1PoKUpKKuxqN9EWrvVI9 +JxLeyRhFOSG4J+lc9eeKmv7p47WK4eNmA84NhB7gjr2/Oudk0XUfHkjXMEcvkxtg +ssgcKDnuPpn8a1tJ0rUmiiWLMLNvUDaVUgDJAHP/ANfIrxsTjHLSDsenh8Ko6yVz +Z0vV4LRVS4h+05/56Fm479PTBGOelauozPqaeRHbzRwYyvkRgqeOm4dRz16itDwl +o2pWbqJdKnuoYl80gN5e49d2GHzfiPxrp5V0u7niku42sJ7kbkVbUI6dDgqQQeee +pHpjOD4VaWvMz3KEW0o9Dz7UtJnSKKPT9TeFgApiKblz69zj05rH8SeDHExa41CG +Pd1SLdI3Tnjtz1ya9l8T2sFvYos9hb37x7FEy8SDJ5yjSYzz1CjnpiuTuLXy72X+ +y7a5tGGTveFXC8/89FHIxjqayjiOxu8Ndao8fm8LQ2KmSbKruHDBl3j/AHSckg+n +p9abqEUtnGMRn5hlS6kDb9AcivRovDt1dXYGuLN5O/LSuTHkeg45+nOQfpVXxB4F +m0y0lvNOht516xtJG+/HI3AHAHPb1PHTNdSxKvqzB4OTWx58bTZIRb3Mlq6lSdoI +D5HG0k9eBx9easWWoXTB5Yb4yPApd03sGjGegB69+AT1q1qmhXLfNfI7hvmjjZSP +Lz124wSCR/nuy20qe3uyLjTpGV1+QuxIJxx0wf54rpVZ20ZyvDWesR1t8QLywmiY +bWVSTGz5y2OoP6/nWtp3jpdUlCyo8c6t8wAznnnv0rH8Q2MkMYmMCrAFCHaDGYW5 +wWT0P94ZHIzjNXV0N9WsRLZQNHJGNkipgMhI6nAwc+vTj8+iGOnDVvQ55YGMrpLU +6ez11b6MhV3MjgcHgD3P51Zt491p5rktu6AdB9a5bSDNZx/Zr+ORfKwSp4BB/iye +ufauiinjZfkUoCON3U+9ehh8T7SWsjir4f2cdIkr8HuKYeM5yaeAdgNNY565xXpX +PPsyM5FMcc/WpG9qYTkUXFYaR15ooNFK47EqnA+WnhsfeqMHmnrx6UgSHrxyT+FP +XHc1H0PFSxEeYATj8M/pSbshpX0INSvDY2zNxlRnFczZeAtS+IGovdahiKOI8KxB +YDP8K56kZ5IroNWgjnuDHnzmUAgMCRu7HHt/Sr2mJrLBWAmETDlgnyOO2V/P/PFe +JjMVKb5Y7HrYXDxj70lqdj8OvDFjo1ult4os9QNszB4pI4VkXHIyyg56noQDxnpX +eaR8EdC1PUmmstUtJHKjBEZjy2eoTaWz79MeteTww332yNNVnbJYgICHTJOMbV5I +z2zj2r2H4V/s+ah4wsLZ9Bvvsk2ciFizIR3Xa4GCMZ5GeevavAxMvZLmc7Ht4SnK +s+WMbnXeGv2Zbq7tZFhvIW8kBg1uWWQlu4UgHgnkcdal1P4A6j4e0djYxmVt5ZEe +1JcE+5YcHHXH0Neq/DX9my/0S0VPEN8b/dt+eJyTH1xy3zfQ4IGcV6XpPwMlmjBv +PllHCuhIZh2L/hXzeJzRRdou59bg8mcleasfIFx8Lro/aoNfgiQlcrFFC25Wz97k +EkdeOPrWTqPwflNxuNrKyW652yYZnA6YTJCj6+nFfcenfALRoCxviBIeVkA2g+2B +1/Dirq/BbTSsxsrWNE2gBiuN3XsRmvNnnL6Hu0clpLc+ArX4Darq19GYYXdJUzsd +MKgzjoOn0Hdfz6+8/ZMk03QZhcSSqoQhUYZLc5PfnJz+lfZXhH4QWFpqM0q24+TP +LA7QeB8pP+easeIfh0mqXLQwwFgVIBUc+/4Yrmnnk5P3XoehHIsOt0fAGo/suJea +UZI4M7eiAYZgDwR/OvMn+HOp+AtUMd3A15b3J2BZk3DGffPTI4r9SY/gZZ29u7wx +KspGELLnBPOf1ry7x7+y2urQv9rg877MxYbeCADkbR9P1FduE4ga0nscOM4bo1da +T1Pgu48Kw3dnFPLZmG1ifyZDvMslnJ0KyZ+8nAIxjgcDqKh1H4QX1vKhRYELkNEY +32ecuM5jYfLgA5zwuB25r6D8ZfBEeF/ES3cNtOYLxSZY2xtk+Y7grduQTzyMDtXM +eI/CU2nE2AwIrSZpomQsI42HVkUjKgZyQTg7u2Mn3IZip6xZ8zXyiVK6ktTyqLwJ +NqEji+3xGNWCqU8qRTz0Hfse/ToOlcsNNv8ASNyyzXjRKxUqwxsIIyCPyOMfSvoq +48LSWenb7adbh3IaXzV/1Dhh8ynqvPBB/A8iuI+IVpb3+6+8kW7SE292iLlYHJ+W +QFf4enuNox0GerD42Tduh5mJwMUr9Tzua1N5aiWyj3quA4THynHp1qi/0x2rWmsf +J80XcDRzRkecycKozg+xGSMcce4PGZcxtFK6vnKnnIwTX2mWYlV6dr6o+NzHDOjU +vbciPbNRnnqOakY+1MPzDivRuedYY3fA60Up6+lFFwtccpJpy+lRjpUsEfmEnKgD +rk4p6CsKQCOtWtPRzcKltkvIQo+UHk9sHrS6XZw3F0guZP3ZPzFR2/L+ld54I8KR +yXy3VjEfIjzH5k4ypznlV4z0HPTHoea8/HYj2MLLdnZhaPPK72M2y8HPBF/xLLIT +zk/vbiYHy0I5xnpnPYdMdBTr7wlrE74v3s2hY5IVMEj8uOvr+Fej2ngwRs7jaxUl +y7dTnnjOcZzjrS6DoS31x5KRsYzjPJPSvma+JVGLb3PoMHg5YuaitiL4ZfCOTUru +HygUU8FiMlx6EjqOO9fVvwU+FNt4ft1MSsd5BKnJXPsP69a5H4Y+EV0+2jklXbwO +B1r3vwJo5jRDGuHYD/gIr4PNMwqVm0nofp+V5bRwkFpqdH4e8OCzMZRGMhwCR1Uf +Wurs7CKEZjAIJw/cGqeih2KYXJz0/vV0dro4kWQqcuR93GM/5zXzlScme7ypIo/Y +45JMQDan+7x+FQPpjJaLtjOcY65ZgP5c/wA66fTNF8i3VVG1h/e5/CmWemCa7eWT +IZCMDHC/TP1rNttG9OMWYWn+GXayH2hfKPJJHPJ6gCpo/CS2km7h3bnJByPeuqOm +LcIAqkDPNPOipPB+5fawODjnBHOK5pOUGW32OSTw9sdnkUKT2U5BqtqPhqK4jZ5o +wdwwDj+ddvJoC7gQSN2chhwap3+hNsYwkhl4FTGcosTaaPAPin8IrXWLB4ooRt3i +QHGNjD/6/NfPfxO+GcmoaYtrdh1MMpFpc7cPGRkCN3Hbrg/T2x9sa/YlLVg6AFh1 +YcH1ryjxv4J8yCYxxowfPmIRwevIr0MPjXSa1MatBVY3kfD97pN74eNza6hG8Uqr +82w7Q4+7yOQMhiMjjjHrni9YkaJ0nit9ohz9ogJyJkB5+UZw3TgHjJ7Yz9S+O/hc +9xM5ZVZcHBbqpxjB/vdvwrwfx/8ACq48KaquqaaNsbnyp0JBGcYDDsPTNfV5fj41 +nyvc+UzXLXTj7SOxwfirwda6zop1Pw47hTGpmikTB24I/TgHtXEeKNP8kw3EQcwz +KMMx6Y4wfTGP5V9GfDjw9b6tJdJbsojuo5I2j4+VzjBz2O5f1OK8h+Jnw+1HS7MS +WkUggtiVmhP3oiOOmOnXj2NfXZNjVSxChJ2T01Ph84wbq0XOK1XY85ZQe9N24HWn +txnimH2r7k+KsNaikbv70UriYAgdKchwaYDxx1p69OKYkzp/CGmvdxs8aBvKAZnZ +cpEDxlif4ieAPrXrnhmw+xW7GLCuqjHAxGMck9uvH6c15l4DupmtbayjcMZ5t/l5 ++WLGRvYd3GeO4H1r1IiOez8qAi3SFuIw33fdie568E9a+bzGb9o0e1g4XiJPep5D +L5jNITyS24Adcg5P8q7X4SeFv7VmTAHzNkn+defxwyTTv57eZyBwePp717j8CtIx +AM45GOnXNfH5lWfI2feZLhlBo9S8GaKI9j8fIeAe4r1vw3ax20SFhksOB6964bwf +Y+RfbCpPGR34r0zT9LCoGfJcgEKednGTn1r4+s+Zn2sErK50Gh2vk+UTnhsLgfdr +pIQ0boSNhfjgdfp+dZnhy0V4kyQoQbsnPX/IroIIklz55GxSSpwfl4rlcEzeM7Fr +TY0ZUzyWPzAjJHv+lOmt4tzDbty2FYfr/KrOhYiEjqm8lfr/AJ61Zgg3Dco27jja +VHymh0rpWKjNRZHZxx2kYJfJJHXtViRttwMIpI5yoq1Bp6iEPPkkjDYXOcelKyqV +/cMq9wSP89qmdF6XGpp6ooXUPnErOpXYeo75/wAms7ULJo8tA42gAgZrbKcOWdVZ +jkAj8v8APvWLqRMHzFgQR0zwOOlclalyamlN3Of1iyE1u8RBBPIOOCfrXnfjTRmt +nDYPy8kA9q9HvpvOt9pD/UDgVzPihVl05wygnoMisktLGt3FpHi3jS1iuJQUXAdS +c45z6V5N4q8Kxa7pd1FcRo6EEMp5z6frXtXjKwE0TtbgkhsED+E9zXmd0ps526/M +xGMcV2YaTptNMVejGcXB7Hjfw98PSeCdeli1WB4R56xJn5kYnK8N26jgnqQfeul+ +JngSDxZo8rxiaG7bcsxDckjapJBGM7sDB7MD2NX/ABNN9hWd4BG6uArox/1gyPwH +PT0/WotJ8QmXw5cXlxbpdyeY4CP8ySYA4PoSN4/3Sx5r7WlVdVRrR3PznFU/YSlS +Z8S+MNKl0bxDdW11GY2ikK4Ix0NZROTXZfGizji8aTy2jq8FyBJHhtzqMfdf/aHQ +5rjmGK/V8LP2lKEn1SPzLEQ9nVlFdGMP1opWH/16K1MRqcg7s/WnDjHvTEPSpF68 +jGaszO/+G1mlpOstsQ/lqJJG4JJ+nYc/1+nd6zqdtZWpEeN53HIX7n0z9ev8sVwf +gW6gbSpY7QZYKqnPbLDcT9M/kPwrQ8Q60DCqvISSxDKPU8+nPUnv17V8xmMffbPd +wMk0kdt4Ls/tsKbdzl23HPXGa+i/g7pogjRVX5QAzAHnB9/89a8H+Ddr51tERjc7 +hB9D15/z1r6T+F9ikVooAy8j7+p+gH0718LmUujP0vKoK1z1bwPp6y77mUkANhQB +yAK7W0jZM785IAORjFc1pdhJY6dCiDKblJC/54612Gjfvrr96CTjhc8Htmvmqkt7 +H0MNkdLpSyQRJC7jC4y3GTjsf89q2o5GeIhFDMMADsfqfx/SsbT0E4QM7KiLnPua +2bS8+wyKSpI9cE54PP61hfXU3jGyNO0vzGyiQiMNgE88fy9RWkAtxAEJ5AyctnPb +vWbDdI4UTk4DBlO0gjB/I9vyq6jRR7GmdVUsOuSMdf51vHXR2sKUXujQkaKO2XCD +bxzt4qtcwLLGPLYH0wMYPvRJqdq6NvkUbeePx/z/APrqBr0SsrR7mXngKeeMf5+t +Y1rd9CoJoWaBpUAwNxGDg8ZrGul23DI45Bx14Y4q9c6qAzhUlyRhgVIx71mahNDM +ATJ86DJXPP8AnNcNS0tU9jqpxdmmjH1KQRbyCoU/Lnup/wA9q5/UVDRsSSyHKnnk +1vXTqWAf5g557Y5rO1SzW2hKxjcOqjHC/wD16xTSLlFpJnnXjfTC1g4A4P6H3rx3 +xPb/AGR2LZz9OmOle9+JoFubTD4yckL68c14r8Q7dbaa44Gxe3oa6KL5mTz9zyrW +JxezSQSqpWV9jNn5o89CPocZB6iuZ0XxBcaTJcxeUhlt7uPz0xhSFP3hz3V+PZj6 +VS8calNaeKf3MrGJW/eIfTPUen9PpU99fJJd20u5GW8X7NKxwoyo3RMT6/eXB9a+ +3yyP7tJnwOeW9s5I8L/aSt4F8aNLplu1tHKMyIf4WySMd8bSp565715u6+1ehfH3 +T5bfxX5ko27kXdgna3HykAk4yMcV5+y4r9Ty7XDU9eh+YY5fv5+pEyhuDxRSsuTR +Xa/U5LEKnHTqaeD83oTTVA9aevB+WqM9ze8HXBtUncSYA2/JjO87hx0x61PrmovF +eILqQIzcYb7z4PP4n39Kw7fUTa2EqKF3OV2nAyOecZH+fxrP13Vf+J1tlmXcWAVv +u7ueccZxnJ/GvEzGneVz1MDJKx9V/s/xi6tI5X4SP5uOSTivpr4Q6eZRFvAKRqCT +718t/s9XjLoFusfG44+mcY4r64+GFn9m02AICWYcgDqOOP0r81zZcsmfquWPmpJr +c9P0VDdpHklgG/h4yK6nQ4o5pSZBubdgcdDXLeEp/sq7GGw5/hOCea6bRZAk+5gV +O7BPavnHFyR7MJ8rN/T7P7XHlxtBGQSOmK2Y7dvNj2g5I25J6n/Iqlp85eNt/GSA +BjPpxWppF9Z290h1CYbiR8uM5ByeBnrWMaLbPQVdOJbgtjYndc5ZMccc89q0Hi8t +Q8aMC3zZJ5A6VHfXcUo3xbWD4yCCBjB5xj6VbuI/NiV4ioTb1Jzjpx+Bz/nmulUD +H212riRNC0YWUHzGHQDPf1/WkcLA3lqhbnkAYK468VT1TU/sk9uHwpXknac4wa0b +O+iQRh1b96SSS2MA8cZ/GpeHVRtFc6jZlKaEmUsFyDgED+fWqVxpxecvL99s7vl+ +9XVz6It1C0loT9n3ZVyOCAOmex9jWFqTGNHUkRqCQWPtXLXwcqejN6OJjNWTOb1K +xRZAQMqBxkZFY+uxlE3sTgj/APVmugvrpNr5OQT3HH4HvXP602GDRt8hG3B5A9q4 +PYtPQ2c/M4XxLE4VyzHuR/s1438VZFkhleEgFlwccZr23xMwji2yDajnGc8g/wCF +eH/FmH9xchMArnIxWtBcslcS967Pln4i6+2neMVMgQkY4B3EjGPx4PSm+ItXWC1j +gf5bS9RZV2t8q4wcg+nzD8Qa5n49339neLI5QduTkDPT6Vma74sM+jaW2ZPMjLup +BwZB0OfqS3av0bLKN6cWfnWd1bVpROb+MeuDWtVg8wbpYogolVsq6dsjsQMfjmuJ +Iz0FbXi+/S91Fmtx8uMg9yPf9ayGXHXBr9IwceShBeR+b4mXPVkyEjiinsOfl6UV +1XOe1ysF68//AF6cqZ6c+1NUc8809R39a1sYjmwsbFuuDg56e/txXO3V0j3Nt9oI +eeSQoRg9Mj+ufyr0b4ffC67+Jcs8GlyJGYlySwyD6ZrgtM8PTQ+OorK4Co9tIUkD +HqQTnb/OvExtenUm4Rldx3PXw2Fq04wqSVoy2Z9Ufs7qFW3iX/VxEE8YHAP9SP0r +658CeObDw9piTXTmVzwdp4Wvj/4TXkeisgY58xAB8x6kk+n0r6J8Mzulpaparbp5 +xwQUwxz6sf8A61fnObUvaT0P0zKZ+4onuGn+NdPSEyzzRAsoP3gCPxq5Y/Gez069 +VLyNgGYAFTuBFcRH4X+3WiedGks2zCkOBtP0x/WuA8YeE9Y8M+Z9oiuzFIchVAKg +fhwf0ryI4S56v1jXU+r9H+K+krB5kysZGIUheeOw+tb1t4p0bWriP7G5YyDa28Eb +OMjtnFfCemfFOfRLwLq7XGxPlZihAx747e3tXqfgf4ux3tkI5n845yGUlmx6DnPo +R/8AWpSw0qZvSrxevU+o7S+uLa5MSMCgHyE5KkdRyf8APNXLvUrky70d1IGQEYjH +515l4L8diWKGKVyw2gl855xnvz610kviPybhA8qshyAAR8vtXK3y6GkW5STR0Ota +oJWUxO2VcMTjBPrx27/lWvpmpQtIrKwBZTmQDA+h5GfzrjLnWFMSSW7q0g5GB83H +asfXvGnlWWIX8uRc7gDgHPc8UUZJTbZtN6JHZ+LPjY2nz/2bpcsexkRgMnkE5PBP +XG4H6D1NeceMfjlcWjOdUAYOwEUO7aFQclm5zz0rzzxj8RY7OZpQYlnyT5pORj/9 +WRivNdc8f/8ACR38q2+ZpScEqSTJ+P8AStXTlW1ZMHGnoj3E/tMS3snlXiFU3AGS +MAbRjpg9ev8AKpNQ+KsmoqsdjBL5LDKExnJPtjP+eteU+Bvhbq/iSSF54bi3gX5m +Qsdz/THavULPwgNJ08C0jjgkIIBK8H8D6VnPCLoxqqr6GDeeLLuS4K3s5iibjG3c +Dnr+Vcd47RrixuGnfcZF3EjgdO3PtXb654etpcpOVVguC64Yn02g9/yFeaeKtVWw +3xOQYQdpZ+35Vw+xcZaHdCeh8rftIeHhd6b9qRY28uY8uQufbP5V5n4puydDsI4M +JH9lClWJBR8qx4z/ALXFe+fHHw0Nc8Napau3yFWlQjvgf/WrwX4NaCfFvjrSrTWn +klS3nIdgclkOOCOxGK+5yquo4eUn9nU+GzzC+2xkIr7VkQ+LfhTrng/TobzXrRlt +ZwGSQHcOeRn061y7Jzn8cV9T+PdGvfiz4t1220tlTw5p8D21hBGow/lJhnJ/3gQP +YCvlyeLypGDcYODX2fD+ZVMfRcaqSlG23Z7fPufI8VZNTymtGVFtwlffe63+XYgK +evPtRTtp3ewor6A+Vi7FReakUcUxO2fxp69eta2MD1r4cJL8KrHTPEYWR7G6hMeo +oP4UZiEcD2xz7Ma4bXryy8UftH6vPoK/6JG4MZQjbkqoJ98nJ7V7S9vGnwJt2kCs +lxZQxhf72flP9a8X+DnhhdM8Sa2yIXWG68lAqnLKp7D8f0r4OFRSqVast9V+J+k5 +hhHQpYejDWNk/wAD1jQ2ax1K0EgaJlAyB3/Xr/jX0T4I8WW9rYq104w235WHJ9eS +c15b4n8AJJpVle6Sc+XGuWTnH1HfvXAfE7xVrsmkf2foc720ErrFNODkqCcY3Dp3 +rx6sViWrM7sJN4dO6PrDVv2zPBPw7uDZ3moG8vwMm0skM83TPKRg4/GvOte/4K7+ +FrK4WwsPB2u6mJpPKRpooYd7HgDDuK4/4H/A2HwP4S1GBYYprnVFIjvFXc8odcde +vGc18y/E34P694R8cmXTwun3lkksUizwB1VHUox2sCDlTw2OpyMEV6WByrB1Y8zm +3+X9fM8fNM3x2FreylT5V+fz2PqQ/tax/Gm/uIbLwB/Z0MAy7z3IzHn+8UVgPqcD +PGao/wDCUz+H7tpdAlutOuFPNpcZKt7JICVb/PStv/gl7+z9qGiapc6/4jjK6LZW +BthLPnZclsEqFbggAZP4V2PxI+GtjZeLpofD0aXek3D5mtZOEj6cxE8ggkYHT6Vy +ZhRw+FajE9HIquLzDm5lt1LnwZ/aWj1a+S11SVobhSoYHjn8fyr6e8IMfEdpHJCy +OGAYHJr44+IP7OFx8PLu31LRriQwXBDwufXAK8+/Qg9K+pP2WvFz6h4KsZLrJZ1U +Yxgg18pmdCFOKqU3oz67LqkqjcWtUerXfh822liQmNmAHrk/XivDP2hPGo8A2k0k +srA8hVznr6V9GeJ7yOy0KSSABAqlieua+RPjp4em+JXjmC0tnZ4lZUyegdj1/AV5 +OHnF1kpPTqerKjJw5kjxjUfHEviOeW78RXrwWSN90H5m9uOp+lQ3HxW1bQbF5vBG +mpAsCNJiSIy3DKo5dl6Ivux79K9z8f8A7IkHg/RbcaA0n9o3AH7+SA3C2IVQSxRe +5JOPT36Fvwn+HmkR/CzXNJ12C8W+1eAwXd0wV5GJBAPODjOcAflX1ODr4WU0pNcp +4WOoYqeHdShFyl0sfFl5+3h8WJNVvjb+J4dPtrKD7RctFpf2iPT4DIsavKyD5FMk +kaZx95lHeu++EH7Yvxm8dtLJpuseH9bltI/NFvPatAZ1yFIDBvlIJHUY5rgPiR+w +zrE/ieOOPQ9RuYrZjE9xbq3lyR5yCcDJznoRn+de1fs9fAW5+Feiz6l4mEdjcSxC +OGCdgPKQEElvckLwM8D34+jxP9mU6blaLfy/C2p8fgMNntbERpJTWut00vx0NDwf ++39BretPpHxI06bRNYjzHKrOJImbpgN2H1Fbmoa7/wAJVfhrJhKGOQex/AV5r8Rv +grpXxF15IvDsXnateXILXYHyxgnkD1H1r1r4afs9+JfB0Frb6lZLdwKoKTxyYDD0 +bPTt3r4/GPCr3qTt5M/QIU8Thn7Ou033X5GF4+0F4rS3E8X7uSBo24zuznP06ivl +j4aaFqVh8Z7/AEzRUKXCSFPNxwiHIJPpj5a+3fih4Y1afUNNtbq2ijhUsDtkU7QF +J6V4Hb+CpfD/AO0at1ZFFjurc+YSSMleD9c5H5UsuxSjGpTTveLMsThHialCpbaS +v6Hpvw10GLQ/CsrKQDCsiEkdtpzmviXWsHVbkp90ysR+Zr7ytYDofgDxXcXHH2W2 +lnUkdmQ9Pxr4InlLuzN/ET+NfZ8F80/bTf8AdX5nz3ic4R+qwj/ef5Fcrz160U5h +joOpor7s/JdiipyKevufwpikZp681sYH0j8LIk8Y/A/RrRQZZvtL27KOqhMuv8xX +PfCjwoll8U7i1MfAvyZPlxkgZP61B+yt45PhZ3mkZWTS7yO6MbdCjfI2fYcE+2a7 +H4ba9D4q+MviHU4YoYlu9XuZY0TO1FMrYA9gAK/OszpvDVK6X9X1P1PB11jMNhpP +e1vuVj6jtfDOn6v4ftoLuG2kmEYG5oFLHHrmuA+KvwlsL3QZ7K0tQjyHdvjj3fN9 +K9K8KQpFpq+cx3Moy2QD/wDWHtW9J4Qj1hY2hhEuwliWbYF9/U//AF6+IWMlSne5 +9JHBKorM+a/AGn6x4cU22k3Ts0J2CORdwxjgY6/j7V2KLqd2Uk8VaDpN60RASSeE +nb/tD8a9Xm+GLLdGW+0rein720ScexHzVetPBWnZVf7Pww+b54ZGH5Ef1rs+uKXv +J2OyHtIpRnHmXmkzlLLxLq0mnRray2FoBgBIYvu89B6UaD4nv/Dl9LOVWfYv712Q +Y/Pn/Jr0GLwRFJGqaesFuE5YBQufwx61l3HgqK0WRr3a1sGz8wwzD6dhXNLEwi7u +V2dTi6sOTltfyOD+IWo3/i+xabVQsFpHmdY9uFB56fgf1rrv2dZo9K8IW0bFg2Mh +cdc81x3xn1yGfTHisz5e793jtj6V2/7O2lm6tYWfJXoM+nbFc+KqXoq/crLcIoVJ +N9j1vxJ4imOjjzThNuMA15dp1nFqOs34RcSErPEe4I613XxAlFnZhSGAKAgHuR1r +zq01BItZWW3yGzknoD7V4Wqk2j6D6t7WnZI19W8Za3c2zpEJDnIOWCliB1BP0/zm +vLNQ0uTWdTZ43nt7kEE7spJ0B6d+3Ne8eHbm2nhRZyGDnHtyK15PhNYasvmXFsko +/hwPp36jvXoYXGwikp6HkTozw8m4Lc+YL7Q9WkYhtVvoFGSAsjKqtxz19hTYfAdp +JDnWZp712B2l5OuT6fjX0WnwEtLV3XTXmjViSQZDjP0J/rUc/wAMFt2ZYLZB5hPz +BOmMdGJ9q6auYwWil+A4yqy0Wh5B4C+GsKyCcGKBo2BiijXPPqxxXrdhqEsFqsZO +90G1yuNrLjgjtkVv6T4dttJtVjbllGCqpgnPqetZeqzRQyTLa+XGrHHThueAf89q +8evUdT3rjUHJ+8jgvihtuoVuI1GYju4PJ6g8V4T4P0ex1X9oDTrfxEjvbzeYo2MM +9Nwx74U17X8Rb6NZgowI51KED+Bvevn1PElt4S+NGjXuoyFYradkZh1AKsB+prsy +7mjfl3sXpTcebRXR3X7V2tWPhn4e+N4tCDRQQ2UVmoYjO5mPH1xX5+yEEYA96+pf +2xfHWz4a/ZpN4n8R6gbvDcMIUAC5+vX8a+WSSOnIzX65wXh5U8E6kl8Uvy0/O5+U ++IuKjWzCFGL+GK+96/lYaxyPpRQ5zndwPaivrz8/M0Hk09WyRUQf0pytkcVumYHY +fB/XItJ8YRxagT9k1BGtZh7MMfzxXo/wMZ9G8eXUDP5rwX80YfpvIcjJ/U14U92b +QCSJirKcgg9DXp/7Pfisax4sNxKcStOXY+5Az+ZJNfKcRYW8XVXVWfyPsOHMbflo +Po7r0f8AwfzPufStcW30q3wvG0hnH8/8/Wuy8MeJiIo0mkcnHJB5UemPyrxrQvFL +JPaW5ZJUQZx/eHHau28O6vG+oxIq7DcHOAOBz1r8pxFHlvdH6zgWqjPZNO1RZkLN +kBgQGJPWrkMOFAMZmVR65x61jaLIZLaNQdm0cAnrgV02mWiyIDC+4yjr9On9a8f2 +Tb0Pei4JaodbEyxB5QEXJXaRyK4r4kSB7KQWxb5G6Yrvb7S1m054ics/QZwRwcEd +K8L+OPjK40S3aLa0ZRtpPf8AH866sPQk5I5K9eKfunCeIrZ9XvhEhDDeOOua95+A +ejmx06OGHImXGTjkAe9eE/BWCbxR4jlk1IsU8zCrjoB3/OvqH4f6cNMuW8gAuRwC +pzyMc+tdGMlyWp9jTAxc4Op3JviHarLYEEfMq9cZzXkU0BjuCOdoPp0r2Pxdpdze +QmWZSFcbgM5Ppz6eleNfEi4bw1cbmXKNIFUjvk14sZNyse5BKnHRnUeE1QzAuyqT +xnPFej6RdStsEILLwPl5x+vvXh/hvxNPHqUCeSGXhjntxXt/giRbkrIxUR7eSDwC +Bgf0/Kj2Tbsjlq1VH4jbeJJy/nSHIG0YOCKrSSASBUJkUDk9j/gaTWpHkUtAzyMw +68fL/ve3H69az77VHt4ZT/rHUYyTjrj9eaVSg4ELlaViPWrlYISCCpx8gxgiuIRk +mnulu3InY5AI7Zzn36GtvUdYa7iRHB3ep61xuuX0mm3HnA7mBxkjqKSuiJUtH3OJ ++Im2GymSABVtZ85zkkHofxOK+eNQMOs/FfSE1Nd0Ml9hgRxhST/Svd/ilquNLncs +qpckShR1AB3fzB/OvlT4/eOp/BVi2racu2aKSQx/izID/wCPV7+U0HVkqcd3ojxM +xxCwsPaVNo6v5HK/tW/EEeOPijOlq4e205fs8eDwMdcV5izYPHU1naZqkupTNLeO +XklYszHkknrV0v0Ir9yy/DRwmHhRhtFWPwXN8dLMcZVxM95O/oui+SFc9xzRTN+7 +Iors9TzjNB9DT0PFQ7vWnq+DxVpmViPVZNsBro/2c9SkHii5itvmlUB157nA/mK5 +fVQWhPNXvgFqv9mfFKJWJxOvrgkqc4rx84jz0ZJHsZPL2deLPrfwr4xeXxJmUMjR +xiMqTjkk5/z7V7b4FmZZ455ATnpntXy/oes/atUt7wn5JmDEd+Mf1DfnX0d8LfEs +d7ZRMrneucgdgexr8uzOjy2aP1/JsQnFpnt/hO9Y2sZdnY/ntHc/qK6rTfEi2ALS +lRtH3DxnnOT+nIxXnel+I44LDDvHCOh+bp+GRVLUfiTBOfIinWUYwAowfp1/pXhx +hbU96dZS0PRda8aSTybLV3kCZOQA2M85rwX45eI/7W1xbaXOVBZieC2OnXn/APVX +pPhrV3j48sBWH0xXhn7WHjUeH/GVrLIvlxT27oGHAJ4z/SunAwdWrY4sTVUI3tod +t+y5cQ6lfXMg2kiQhQR2B/8ArCvrD4c+Gf8AhItUkG9I40iPMjBQxxwMngd6/O/9 +lj42RaLrUls86qZCMAnr2P8ASvsrwd8cEttNxbSANL1wR6f/AFs11YvBxp1XKa0H +g8XKpRtTeux7t428D/8ACJ6RFFdpE5mhWVSjBlKkAqQw6g5r5c+PAjtbm0d9jDz0 +YjHYOOv4V6JqnxvS90xlmuQ+1QuSfuf5zXz18bPiza6xqkcCTJxJk4Oe9eVWw0HN +ukrI9bB1qkUlWd2dbqsEtrFLLAVZof3ikDG9OuPyrt/B/jyfWtIiGnLjYA24Lge4 +ryO++KFmNLSOOdTJt2Bc5JPYV7f4Ut4NN8GWMPlLFcPAm/HZsf8A164H+6fvdT0M +ZaqlyLYu2XjKWQLHeA5GR8pz19j/AI49qlu9YBtwpZpHc4XPLMTxn8a5jXp57KUy +ou8ADIb+dQaZ4s+0EiCTDk5KsuSD9f64raT9ojy41eR2Zp380tvdFLgryPl9/pXD ++NtdQXItIySXzg+/eui1TW3S0lleRWfrlV4A/p9a8s8deIY1cypJkwguG9SK5oU+ +eR6CrRcdThfH+syarcpYWLZkF3tBz2bHX8TXyp+1ZqLQ+HxbM+V+0iJQTzgcn9Rm +vo+fWlnS/vVJZklDoB+Q/X+VfIX7TuvfbfE1vZoc7XeZ+3JPH8zX2fDtBvFRj21P +h+KcRyYOcr76HKeHvuCthnrI0Fdqc/yrSLelfr1H4T8Vn8Q8sM/Wiomb1orQkzQ2 +6no+OlVkkzT1YY75pmVh1588Bx6Vi6Pq58OeMLC9HAhmBP0zitmU7oyK5nxBBnJH +H41yYuHPBo6sJPkkmj6k+G+dYWzhRso02xCOS3DH8Oo/OvaPglffY7R2kZ2KuVIU +jjtXzH+zf4zGpWNizSYltblN6/gFP8j+dfTXwa0hJvE+sW9vOyp9o3qncB25H5k1 ++cZtT9mpJ9D9Lyer7Rx5ep1fjPx7Ppelp9mjAeX5I1P8ZPAq/wDDzWtI0u4R9Wk+ +2XjnDvn5S54Cp7ZrM/ao0eXwnpmlR+G7NmublyRI3zY4IBPOTxuPHtXiGq+Obrwh +rNrB4i86yuo1VzvBDk4BB3Hjpjj6V4FKH1mFoI+gq1vYyXMz64HxEtrZpmJiVUPl +BQRjI69P/wBfSvOvjjZaJ8VfDTweI0dnUkwmLiRT2KkdDzivP/C/iS51iC4muDMB +Iu2ASYbaOjOcDjgHv1Kk+8t34hkTWpPOn3WyY2gNyV74yevQdPWnh8PLDyvsFTGR +qR0PBdW+D+vfDzUpNU+G91caitid1zYTv+8HceWe5wc4Hv1wcd78P/2yrU6Wn9p3 +c1pNCNkkM/DxsP8APXmt2xtdRW/udTgjKrN+9hgU7wS7HJPuFA456Vv2vwb8L/E2 +9+3+MtAsLqRSFkmQEY744+9nn6Zr3JYunNJV1fzPFiq1KfNQdjk/F37a9rFo2zRr +mS/u5srDb2uWkkPpjtWD4T+FHxJ+MMp1TXr9fC1q7B44ChknYE9WJ6fp9K9i0D4L +eCPBl79r8MaBZ2l2SChjG6RGADEgk/LgHt6GunutWOsaJP8A8Iw6idVCKrLl5CGB +4I/3l578fSvOxOPo4ZNUIa92evhKeIxck682l2RL+zf+zxpnhPUItR8X6nf63fRE +kJdSgRxnswUcHkHr/SvpKTxdaDP7webGDuB46f5FfPOk65NpMK+U29I/kkQDJYZU +dumDk9+prdj+IUcUmpecQzeTnczdQeoz/eBOK+VxTli588j6yjJUYct9j1TxD4ks +pFaIswlfOMHnpkfyNebeNrebSdNXUdLu0uFVS5hPEmO+DnqK8q8U/tCR6Wsd20sk +hjwpkUkDIZSD+Q6e9Ytn8YrjxZHNFHO0kss37iJFO1x6DHqM9O44B4rejQqUkpW0 +PPr1oTdlLU9v0H4hjWdEQDc6uuNxOMD0/wDrVw/jayea5EcDHbJIzBD0K7S3P4iu +5+G/hCNPCrjUQqGNtsTYwJBtBGD6jOCPUGuV8TL5HiNRcMoUBgoHf5W/wopuPtXy +bFptwszzjxU66ZoExZChKK3HT72f8a+Ifidrv/CS/Ei+nXJVG8pefSvrH4/+OI/D +/hK9leTARCQc4GB2/E4r4x052v7uSeblpXLnnuTmv0DhXDXcqz9D8+4xxa5YUF6n +S6QNkQzVtnqtafu4RT2bPSv0OOiR+ay11JC/JoqLdkcUUwRmBuvNSK+R1qtvx06U +of3rQxLIkyKytctt8ZIq6JMe4/lVfUH3xkNUzjzRsVB2ZL8GfGH/AAiPjBYrhtsN +yQOegYH/AAzX2V8KviCuh+O7W5yPIv41TnpnaMD9K+BNevV05jKHCPGdy885FfRH +7PfxDPxC8GxrbNtvYVUqOu2Re3+fWvj85wSmnK2j0Z9fkuO9nJRvqtT9K5dGsPiR +4OzcmKW4tlEkG7go4BPr14/D6V49deE7HW1mh8VWonWVTEY5UJBYEAncB9OTisX9 +n/42jUrKKDUZzGU/1iE7VyCAVIP0xz/Wu9lvk8TXynw8+0RRjziBkbiASOe/Q5x1 +Nfms6VTB1eU/SYTp4unzLW54t45+EOr+EZbkfC7UzbqNwWwul82Bh6I33k/Mj0Fe +fj4xan4SMcPxQ8Oz2sVtI7G4VfMgkJx/HjAGQTgkHnpX0trdo5hJ1AgSK+AwH3v9 +r2rm9RtFbetzbo7FsbioZWzwcj/PavocPi4VIJVo38zz1gFOVqbszzr4d/GLQPEc +j28d75UE0zmD5giRKw4+bvjn869C8Iz2sl69vpM0V0ka74nBwCNvQkdT/wDX9K50 +fsveF/F97JdRQf2TqMh3eZZHyeSTjIH3vxzXW+Ev2N9QspBLY64JV27lZ4Pn/wC+ +kI9+1ZYmOFl8MrHr4PLK9veivvLtjaQ6RfSWt2ybJZS29lwJTg9uw5JqrE2leFmE +l7qMELE+ZIu5QGIyOnrjH04rbb9lK4voWCaqrMASC0bv05PJf/OKiP7EGnmFrnxl +qN5cxMMlEbyR+nP5k15tSjh5aylp5I9qjltWC0SucHqH7Q/h3wRczSSanbuzBhFH +EC78k9Ewcnnj6965S3+KXiT4oXElp8N/CmoLFckAX2oj7OgXOfuH527c4A9DXvfh +/wCA3hbwqDD4S0q2gwfnlMYLsD1+b1rtvDPgmCOYvbAKjcM4GD/9asamIwmGXuwu +/N/ojOrl1SPvVKll2S1+/wD4B5Z8LP2OvJiivvineDUr0sZBCibLZWbtt6t+Ndcn +wd0jSPHOlrbQxxtFN5Y2Y2FgpIPHXkKPyr1eNIbewWKPLBFwwyQTgf8A1qy106Dw +zewalqifPFGXIJztJ69fw/75rxamMq15tt6djljRp0loVNbuIvD/AIYkt5JShLtK +FHXJJ46cHFeA+Jdae71q4liDEQo5Gedq9Cf0H512Pxi+LCXUc4tblfLkOFY87CM8 +Ee3+eteAfFz4sw+B/AOpXrlo1kicb8YeQe31r1MvwU5WVrt6HJicVGnFtuyWp82/ +tyfFprqe38OaXJyw8y5wfu85x+OP0rw7w/4rutDKgMJU7q3OaqeKvE1z428UXep6 +oS0ty5b/AHR2H4DFVmQmPPftX6/gMKsFRjSj8/U/H8yxjzDESrPZ7eh6dpPxIsL6 +JRcs1u/cMOPzrXs9ZtdTH+hTxyeoB5/KvH4ThfnqWCdrch4XZWHQg4r0VWa3POdB +PZnse+ivONI+I95p2Fuj9ojH977350Vp7WJk6Uk7HXb+PWkD+tc3qXxBtbYEWIM5 +9ei1m3HxJnmiK2kaRN3bOa6XUhHqcahJnXanrdvo1sZLxwoHQDkt9BXFeIPiJc6h +lNP/AHEX/jxrJ1C7lvnMl3Izu3cnpVSUYGeuawlV5tEaqHLuJcs14haVyzZ7nJrp +/gn8U7j4XeK45Qx+yTMBMvYf7X+Nc0yYQMp9s1XuIONy8iuepCNWLhLZmtKpKjNT +juj7l8C+NxY+JEv7aOOSPU1Do74ZVOcnB9PYD/GvoL4AfEG5utNJ1YQxJcTPEu1w +Nz579/XHr2r4H/Zl+KQuNDudA16Z8W4822IIEiYIPynvjnI9K+j/AIE3dxDfwy3H +2iZAoWMk7wQTgAMAenzAkDoPwr4XNcss2mtj77KszUorle59U+MrFntc2pTzWXdt +Jxj2I7d657SdVj1C/wDsd6u1uGVsck+n+fSpZdZiu7K1gjhD6gsIa4MM4kVAcj5z +xg5zx/iM8r4p1aXRrlXsYWe4Z/mK444z3PtivApQt7rPo3WvaSPUNA8PrFcL5Q38 +5GBn17duteoeE71rGLJX5IgBsJOOPf6n9K+Zbb47y+F3SNo548AEmT7zE9do6evv +XU6F+1Cmoww2qllZnACgckHGCx+ob65FYVqUl7yPTw+bVKa5Wz6SudX04WWYoGRm +6kEYx8xwf++hz7Vk6pGuuKkdmsssrAlmdvkycf4V40P2iU1G9SDSI1iQ5DSmX5AV +GSq8Z7Y5J+pp+m/tPxm0mit45fNU7Pl6biOp9ME1zVKc5LsejRzqcVotT2HSvC0e +k2wbUGiLrhpCB17Yxn3xWdrHiVLZxHagIgbZkHvgn6GvPT421LxLBZu0gdJ+DIPl +2DP6ng1sWEb3iRx3jIFTCgt+PX8DXm1aaW5pHESrPmqO51S3Mv8AZksmno08m1to +IGPr715p8Y/i5Be39jZWtw3mThomUvsYArkk56jBA/D6V6DdKpa1j0pS4RW8w7sL +GNpIPvkZ6ehHcZ+ZvjbdhbgzyLILuznMLRIv3eOCBn5gCuc+mAQT0vBYX2suZnHi +cT7MwfHniJvE+t3lvbxx28dvc4PPJ5JbI7HgE5718g/tm/GeTxl4m/sHT3/cWDBZ +dhIU4HC4z27/AEFew/tA/F2P4S/DN5mAh1vUnbyl6sSwIyec4GCT2yfevjWOSW+e +W6vnaSe4Yu7sckk85NfpOQZel+/ktFovXqz874gzJ/7vB6vV+nYbFEFHpjg1Mh34 +A4qIAYY0RH5Pl619WfIrQllBVzilgYEYPSo2kzE3qOtJC2Ys0WGnZlkoAuT6UVHz +IOASKKnYplOKMOrA8gCoR8j1NC+Ex6UTQZAKjB9PWtzgtoK0uV4HbrTUAf73PtSR +nOc0xJCjA44poG+rJJIwgxztJqNhxirG8S/dOPrUM6bJM9iaYmrbFvwpq7eF/E1n +foWUQSAvtjV2K98BuM4zz2r7h+DnihvEumW82mC2SObEhAPkSbSAyFwVOOOhHXHG +RzXwn94mvcf2X/iVDolm2lz6oLSa4dFjiWDduYs3OMqGbHAwc/Mc5wAeDH4dV4X6 +nZg8Q6E/I+4/BWrzWQVzPFI91JkZn86LJPHl/LuPUEenXoK7XxX4OXVo4bnRm3Xl +vlrhCvDJnG7GeDnn8a8o+F6RaxBFeXt5PDDC+JGWPbGDnJJfGCc8Y5bjBA7e7eFP +Ddu1x9otEkM1wiJk4DP3UOCTzjHH09cV+e46i8NNtH6Hl9eOJgonPab4Dh1uR3uw ++9l2lGOdo9AMfy5rP8X/AALfTrC81azjW1uo0PlhFG3A5BJ9sflXq8dhZ6beg8je +4GVI+Unn/H8q6OyfTte8yz1+WGaHDhExgkADOfw/nXi1MXOPwn0OHwsJNNnzvZeA +kiudOLZjvLmEBwBkKGK7jjp1DfN9PWux8H/s5xX9g5jZoTcwNxjBZmbOD346f/rr +0jTPB2lT6+v+jzyi1x5agZByCCjEdQB/Ouz0nToNLdbk7y0YZI48HAXPPB9CBz7V +51bFVL2TPXhhaUVscZpXwwTR9KtbSTDvbYGVB6jvj8avJ4YtbDDXB3Q7wHZhyCfT +/PWut1+8htbN5m+XJyQp5I75P41Bd2kX/CMkwBkKsWBP3GCkkqSeO3B+nY5HLTU6 +rszOu40ldHK6rHFaG8hvmlSazIFocEBlwSFLe4JXHPQfQ+B/F/VdPv4tRnuNqXAt +1kSYIq7SGV+cDkHB569en3T7J448U3Wi2Eq63B50KjCyBA/l7sdQe2ARuz1wMZr4 +s/aY+P2jaXoWvaRczfu9SAuLSa2tUnliYkHa8ZZAeNy4yB8/TAAr6/KcB7Zq2x8l +mmYOkn3Plb9rHxUvirxXZIZ2do03vF/AuScEAnPPXPfcT0IFebRshQopBaPhh3rf ++JUD23iaG3uJGuLlYUkuZZOWaRwX9TjCsoxntXFyyyreGeIkkn9P61+m4eiqdOMF +0PzWviHOo6kurNORdqn3pluOpNMFwLqAPGMZOD7GpohgY9q02GmpO6GmPJO3rimW +wOGU1LH1OPSo7Y/vWAGaS2B7odGxQ9TRSE/Nycc/lRSKWhXhjDSlX43D8qlMZUcM +eOnrUW4JPz+HFSFt+SD2rU41ZESHbPz3oliAJx9aSXhwRzipZBmPPf8AnVCS0sRQ +tg/LUrx+ZGQagUbWPFSxzbOGzTJTIY25w33h2q3YzS215HPZsEliO5GKBgD9Dwar +3SAESpwDw1SQS7V+Trmk9QR9J/s3ftDFL6a18W6gI0kZVU7VAdMcBegQknoMYIwM +5G37g+COtfa1hvxLJJBPgAytluic5znncx9QcYyDx+Q11dCynQx8yqd2COFPYn1r +6S/Zu/a4OhWtvpE0f2O3ASNpvtG6a4lOMs+ctjOTngKMc5HPiZplccTG8dz2cszN +4WfLJ6H6C6r41kjvJfsNvKsS3ewzkcqCiooOONuWOTx+lamm6nHc2JnsGDyCIBiW +ILYOGIPUcjkew5rzHRPjppfi3w2tppkq7r5Ge1ZWH78IymRcnARhhWQsRkMckZzU +WueMT4XjtLXT4pDHb+d5s5QqZG3Mo+Xrjcwx2Jxjggn4TGZXKLSPvsvzqEtbnudn +8SLbwlCTEcKJPLkZcsclV2kY69hx61on4ohv3cVxukwrYB3ZWQgc+hHNfPf/AAm8 +V7LHHqLRtEwM0cTH53z8oGPU+n+zn0ra8NeJW029nvL5kQCWKMF/mVUbaUPH49Ow +wMmvM/syT33Pb/taCTZ7TrniK5v7byGaRzLZG5g8obskc/05z2zXQxa2X8DwhnSa +dmw8YGVlRyFHpgngc+31Hj/h74q2z3X9jag4nNlExUbxt2s5Xk5527QvcAFvSvNP +jz+1RafDrwJJc6Jqcd+FuHtoYInG7dGGQhlBymPqeMY7Gu7BZRJyVloePjs5i1a+ +pc/aR/aSt/CXh+JdclW6jKeXKIVHnhWBQspZuWwNxXODgcZ5Hxd4etv+F3fFpbrx +IEgsIVfUNTeNMBIY1LMcAYBwv8qpeJfixqfxtljtZLd444nyiq5ZUG4njvk8ZGSC +eeOMej/HOK2/ZP8A2dLfw1aIi+O/iPbrPqDMP3um6afuof7rS9T/ALNfaYHCxoyj +Sjv1Pi8wxM5xdST1ex8r+KfEDeINd1fV5V2G+uHeOP8A557ycKPoMCsEJt4Parl+ +yS3aQW/+rg5PuajWMAsSQQDzX0sXY+clG7SG2qbUI6bzkVdSHah28+pqrYIbu5yQ +dvRR6Ctn7Oqpt/pWc3qdFFWiZkfBNR2y/v2qeSMxXDKais/9bISeaFsU90JIOT69 +aKJPmY0UIT3IJVwenSmhsDtViWPI9ai2gA4q07mEo2YhOe34VJAm+LA69Ki3bOtS +2hxIR+P1qmTHcjSEPIytgHrTpLQjoSakuIyHDrwasW7iZRuxn0NF+o3BbMzmO1Sr +jg+tMt5TGzA8lBkcdfSr9xbK3aqNxEbdw6jOOvuKpO5k04haWeVMlx8zN2qGSJtP +ullt2K7WyrDtVu1lDKNvKN+YqV4dn3sFT39aAsd/8Jfj0fCkkiapdXMxkG0b4gUR +cHOFycsdxHT0969Y8P8A7cdvIIDqhkhWwiaKBbhw+3bt8ttoPP3M4HfbknGa+XLr +TcNutc9fTpVZ43ViZlJ9a5amDp1m3JG9PE1KSsmfXsP7SdlpVrpmqXWsRTx6hEys +yoRIgyQ4CkDDDIx6gY9Kuy/toQ2tlfO032prh442s5WdfPgVQqKSoIUjYrg/wk/7 +VfItk73ESKsjSRQj5U67ATk4/Gum0LSJLsJ9nhMm77uBnNcFbBUaO6PUw2IqYn7R +7z40/ayn1LUDd+EpZxLDJ5W6cYeVDneyFeBnGeRx5nTivLLqfVfiX4h8mMPPcXs2 +4pGoVSx6naOAT3NdD4B+AviDxzqENvpenzlZCAzBDgV9x/srfsDWvw4jXWPE8a3U +5AKh1wV+gPevJxOPpYWOm/RHqUcI5P8ANnjnw6+Fdn+yf8B9V+I/xH0+3urjTHjg +0qyuR8l9fv8A6tWHUxoMyN6hcd6+PPi38Ydc+L3jfUPEHjrUW1TWdWkLzzdlHRUQ +DhUA4CjgAV9jf8FgPjhYwy6T8N/De110FhdXgQjaZmUjBA6k72+gVfWviHTtKCJ5 +tzje3J46ewr2sBh3Qpc0/ilqzw8TX+sVPd+FbEFnY7IcswLtyfepLOe2j0q5S4ia +S4lKiNv4UAOT+Parl3DttnaLAOKySpitsEjiu5e8c8rRZa0ePDlh/Kr0zYTg9T6V +X06PFruGPWpLg5kQHHH61L1ZcVaJVvDi4z3I5qGyH+s+v51Zvx+8zg9KhskIgcju +apfCD+JEUp2g7qKSZcsFXByaKpaESeo8AbahZNr8dDUsRBPGPpSMBv570kwcbohe +Lvxmm27mO4AP0qwYwD1zUFxHsIYcEVad9DKUeXVF2dd8eSOvWqqObeX5iQKtwP5s +WTyDVa7jG8daS3sVNaXLgdWQbO4+tQTwBwcdf5VDBMY2+Xt2q1FMkuWIPTkBsCns +Row0dtOt7O6g1eGTzZQGhmRj+6YdivcEfyFQ2swmQpJx/d7U64hDjKgc9qrxwPv2 +r8r9Rk8VW5FuVkobyH4GfrT2RZvnAHuPUUsDi7TawxIvBBHSmKTHJjt/OkhrVFWW +yayl8y1bpztx1r3P9jH9rofALxI1r420aw8Q+E7+QfbLG5to5ntm6edAXHytjqvA +YAdCAR43vHXuPaqksYSbz7Y/N1K9mFKUVUVpIa916H7afB3VPh/4u0611PwBbW9t +aahGJLe4szuicHr8rcgjoVyCCDwK9B8f+O9C+GPgPUNcmuJbxdLt3uEjEWxcqpYE +kk5xjOPYV+Pn7Hv7YWpfs7eKIknlmu/DN7IBd2hJPkknBliHZx3H8QGPQj7A/wCC +hPxyurL9kO3vfD00c2l+M2jtLK8hl3x3EZBdyp/3VKkdRnB54rxpZRh3VVTk1Or6 +/iIR9lz6M/Pf4i+M7z4p/ErV/EXieV5bvUbqS6cu247nYnH0A4HsBVPduh781Fps +Ajtg2RlzknvU0rfvgqjtur03uKKSQ2SIC2YDnj06Vm6lEFHIAJ9K05pP3Lcc1n6o +Ny9Tz0px3CWxagG2zXtnHP401fmmYnnnFSbNtvED1yKgu8pc5BIz1pJXG9hmpkKy +k/ypLVAtpliAWOaXVPntVKnPeq8UzSW6hfSqS90SfvC28fnXWewoq7YWwgj56mip +lLUqKKVxF5F0wA46iiWMNDuAwal1L/Wr9KIgCHyP8800xWIEbevbilChyQR+FRxk +5/GpLY4l49KolajrBN0RXnI4zRPGNwDHof0pbE/6TN/n0p91yDn0pN6gldEdzaLu +JjwO+KhUeUwB4B/SrC8gZ9ail61fkZ2JrdlZiF5B5psqCQYJJbGVPf6Uy3P75ac5 +xImPWgLEDgk+Yhw69ferO5b2Hcg+YcUyb/j6eorE4vWA4FPdCtaViaIAk54bpj1q +X7KrdF5x1FDj/SR9atW3KDPpU81rF8l9zMntmtS7x84+8P61sz+MtZ1nwjpmgajq +V5No+myy3NpZySEw2zzbfMZFJwN2xCcdcfWq10Mg/hTLTm65/vH+VJy0JhHWxbXC +qoGAo4FNJAkOD2xj0prgcHHOKAf3o/3ay6m9hJWHkN0zVa++bYAeCc1PKSEbHpVR +zmZM8/NVx3JesS7KM+Xzjmo9QXMXqRUl3yE+n9KZdD901SnZjexBJILjTcZwMVBp +qkgYz3otT/oL/j/SjTOVOfetbWTMo6tPyNRT8gwQMelFRucKce38qKxtc6L2P//Z +iEYEEBECAAYFAkw85esACgkQjCTRYI8GidQQSwCgne7YLdg32inbpNAg777rWoBm +yXkAn1kvt38qgBQ7XKBx6+4aQFCKnk+siEYEEBECAAYFAkyzexIACgkQVVuXXpU7 +hpNqLQCfWoV3kYk/62/+zsO3ROcMuMFEqHUAoJWEgH7dZLhl6aU8CWpBKzjotz8Q +iEYEEBECAAYFAkzV7V8ACgkQHajaM93NaGpeWACfWU2yKNwVAO4WaS3eYWAln/Ii +2CcAn3O5IQ8X4lak6Kvq16yOKvrfJDS2iF4EEBEIAAYFAktXYt0ACgkQ+u8Sk23T +4+x07AEAl51X2CTmhFNNckJeT+1naP2SOVKbKwysWt/pRnD7ixwBAIL/QN+wohQw +0JsfyhLf7B7g14jphTeHB/wKfx6JHLl5iQEcBBABAgAGBQJN0WUoAAoJEKax8/Dm +tfWjOAsIAI8GycNYko55hYOimzFwPJnlciyBaziohv2VM/ipDbstm8+Qx8Zz7Bpd +rmRdcqHZvM03pfvFY6T3W3U5lL7djwcAlAB/lA0491UkoHyuCrvd8mZmrxgKBOwx +3+AFOlBhDa2ngyKLCYppHYXUy50DeMzKLytijxOS7ANHLW8gysu2wCa8T8iqZ2FT +HssA8pau76zGiPTtxTpweK9CiFzANruNq0OsnwGLkn7c3uC8ouEwNEoYxOPWtEgE +B6adkCC4RkANiUgDA9VKQP+1jnyedKnNB2RmnxrYQ5ZEgpkuwhXgT/AA8hUZVAzL +MjHQlx19ounS0ECy18Pis52PXdoXygeJAhwEEAECAAYFAk3M6ukACgkQuN+3G1/s +vZLFzA/+Jf8x/bZTpT34BxaO5OdDwFF8S8IS+F73MUPxTONrZa7FQovq4qYoefZU +BX2oFJLNsRFldiC93+l0gf8cmzhPzool8f3Rc7JmjrY2KxkfLT8J8/1o1vegQQfQ +Z5IwEjUWGA30o0UfTpskwwqeEki8H9gAG7Q/yqa4erQXZXStsd2BmXMj4OeVPvs4 +wXZuX4Z30G9nPbkOuApwauZw+VP0+gNF8b7LRnNuzKcv9IBVFBh3N/kej6eGD3hG +wME5aCE6yPy0ddPPMcmNFoy9Z+YABDADmA9vOzVbuaY/fsq5WjFD2r0K6u7Ni45p +tdR7cAQoJ/xtugNNDvMUeUFKnhcQgp400IeuTlEvFwvXOUSKhPYVEwPErT/kFo6h +9obcxLJirZHlN8vZYcaEoGdLbxo3CcdIIMXAwm+vJK63vDLeqJX7HuOOC88kSTnB +P+2QRHfr8mQ+O7FqsQbTmZptO74bpJibbYc40iAKYhmFZUo1M1dS3N0I7A8+qIdI +a7RJcAaB13GJwqC7RZ+WFSG/jfWNIoknYQr2kkyPUp/taem8xP7sq/L5VPQW8XTk ++PfO8EjUZYfv3615Bq+MVKdmGxdWrFam1Hrjf3DsdvWYaSXhqGA4ZLGdj7iZIVrA +9yR7m/qJMhhPTss+xg2jWJ6fQ7j87tAqOKsSpXiR2Tcsp8rJ44SJAhwEEAECAAYF +Ak3M8N0ACgkQ4ZcBJna5tzlKEA//T68I0s9gCF3+P6YqQOdn/wxeWXSCfciR5Owc +bveR/bPIpwBn9yezwpfMxdWVeSbprazb8zE0E5NO8yJTc04EUtTmogDmYyOcwq1j +2o3vKuGJILNbOlO2IP/GjGjNWeRhmzd8b5jAuyo+REcO1TIICqFRgDHRD1wNufnn +TjZAxQytZOlIAEcnE3GYjcNJ7Rgt2AhZXrnl9R0U8CY84uwVNcOSLbS2au5uooIY +mAJj2ucSVHXhSfra8WQZXYjQxixwCVL467qS0qFA+gVVyR7tARdD/N2vVgfRCEWF +/kI0joD4RPBplACSfiSIyFgwIqosL15D4N4NA02+VC5SzZyRHYQ18grm6z4D82AC +/CwAkbyE93u5vIWpOkm2faxg+wh2vFreJi2pT5LjFaRlEO0zESf4ENljglA1DN0m +UGF35pP7dniFPt4F+Jnj2CHmlCfhV/wo92LnhSRl/GZJb3T7t4Wb57z9tQX7nIF2 +6cTzFAepPtCGrA16MlddOZ0+glZMfu7G2QXhi6uISX8ke7BTRegXbAITlwNlD/Mz +R6o9dqFmPHySJ64Ueu0fF76UAp4VM/CWVh20NfqC1VDG5U4wIxBhOZabcgu7TZCh +twlHcJP/9DaJ1Nxheljcu12i49e2Gklau6mOnKyxmqNDli43qifr5qA/JhA2CqbG +gavkjRaJAhwEEAECAAYFAk3NMikACgkQhlYfRSGA/P5I6g/8ChgFJFxSEwtesvjF +0zjDJWFGSOAYCc19NK2o33Ra5511S6ZQFkzanxdAstrmNduOmoSgx9FSSUcqNH2W +R5a8HTxg2cfyW1+rNjBcpknXqdCmSan+gv2e/4pV4Z2ZuC6ZqybDFNrmvm+xyHDI +dqyJXjbiOlFaI5d8panSKZBm/vp6BGj9wV+C810euz6jdYbnQyJxHZhw3O20VcUK +xgVsUc53cMRDLxLjDSuBwEbQdXfbvV6w3N6gBu1NDSu6JTsf8qFlujmPN4vLsNN6 +qFTKRuxKV17Av1UwKlF7Pe9TbBxL6P20SghcP30TdO27qqof3Hb5EQvFKweA00yJ +3MnAhERQHNMuRDmF97LN+Z8Kec7/MJOW7sb3CkywAHMYScbiOWwSs2k0WWTx9fbG +fsHZQ8Dz6+PKUQ/zg7zylT0aSnndI8Y8MWH0rBZYMANoTEPON2GSxyZMHX0vvetV +bYxVGIL5LkuaZTTzRwt6aCdEh9OB95X4zZP8uuTYBm1mTDA3tByyPp2XLWWTKttA +tRM6Yuo71TiO9KWPRSeVsj1FA9c5A/Ot2xGPYkJIsESmMtAb3LfzC2xramKEVRhf +53WZTw0vYofeVwnh9rsQA+drrXolj1j2854OP5hKGJo1zf5Hs/fH4LxMH0UGVjJL +a8vhFsla8lTV5JM64z1tO6CBI7qJAhwEEAECAAYFAk3NXXwACgkQRdd+njDLGxH0 +9A//Yl0UJqA0GMkG4EC/cm12nu/7EAy8i9/UXMBD6MZ8ITmw0EzNoVN/PDQ510PN +o30RCF+isOCXhz7lvBqvKDFJFnNR2kiU9Wn/4iUieUldy9LChTFrI6bBw40Hs+8X +vodbjJyClE52qw9Eg5U9JCo2ZmZpjk1BcCiELpx8o6pkM9JPiXjlsRV/vd9FZba3 +cAWeBVvUADmCioaBOkqooKacFJNCPRCU0RmDupVetKJ84q1q2X1a1Gt4vbI5WmR+ +TuukPqzvpnebLYV02y/mIMEOZOheZxAfkAlgVj83ed0EtLFFoXwKQg8yPkxUoKnO +gU1BwA5CTlaCpGmQM567E6TI8PTN63ZOB1SiBCD1dKVsP9+ve9wioWjH0IwbygqE +b+m3zOo2M+EHSc9AYZCtQFsrsUjNw1kWPU0aFAi7hk0ggaviwXemKAW+Q+xi882G +XYwFdl3DBPz2kGL0N6UU/+0ruBFrmxMDgJmiSevzLU18N49t3n5OHkvDwj4hdYlq +4bhE3z6lCZlNVyyO9F6pLRJchxYrXWB6Z6BgSwPCJ7LmfdrVUTViZdUXv8ooNvXU +p+bkf+jtI7j/sss6VcG3vwknlJWQ28mv6lWnRkad5hXu47+ypz9artAnXf+B/r8m +bYCBKxsfC3iLNcOfIGgwtCHbpS0N7jH5WUGP1ntrJl5hsc+JAhwEEAECAAYFAk3O +/wEACgkQYAQmoRj1+84iTg//Z7YR8rqjW6beSrYE9/SDW7wX5hi5c9mpvLvtUP3l +2FSjppeZvmIhgSEdGd8MK3hS/I6MCqRqIFMWVirgpBPRIRYNPSpTFT8FNlIgkTB0 +8Mr7furMapI9L2JYdxw4IBNWUNIetAtfs2RMYhumBp9wOCB8h4z+BW00wEltyXwo +QT9XylYx58bfsXnvDtGqy2lkFVTqMufaEqLF+1qf4jgcRmZFMvSZBxIhUKVNwpaH +qmDzyxpLwtxRcQb1+lOyXZdpt3WuZ//vPkyMIe5FY8Fzf9j0eFz5bLqgfZcdKUpS ++3ZLQKm0ZKY+BxOzcgCPm10Fz0jxUc+AisUwzcnyJmwrfMKW6bdmlMqToPadTflE +Swu2G3NErkzkBE4bUFg3ZOGrzmgqSVj8+nnoIEoGgxZg2ly4ft/JuMBkxN+s37he +h80sHebm3/PJPcG69yfRDFRLaP0smbTCNlHIXUs/OVXgOPIU//rF2wYl1iJZVwd3 +CN19creuAdyZeEcp8o5FAJw5zmW20VChSAkjYQt4A1OETDXDX9As/0atNOwHOIUE +VfwOEVrqinK1tEIbNNwcvw49ovBf6xArE3kcHU/4uNi0apJSjccs8zvkm0O+Z2XC +gPxdaASUsLg2ia+FOcjtqL0hY5HHO1F4yp3fGmTJIHBu1EkHTLTsGi+JayUpjDdS +nn2JAhwEEAECAAYFAk3RdQAACgkQxjiXTWR5LWc7gBAAjH8D7hQ1HsoxsQo3j6B3 +B/hE+YrfXWqi/6QKuZyw9WG/6R6KhCZ28SuUtmpousKgN1HtoHNJFOhADzesf/o0 +YnEhhHJBNBche6XUtRF9DDRqiUEnfMZA5dKRXt7CEqVVH5CQtU0UWtKRuaHJutkI +Owe6rUaSt2rDsIRnWpLXf3b5f9zFMn75AorNSVzYa671yI/zf7c1Hjjad1TbHYUa +kwfzF0X0MepMYYLxpMBDYC9y7fQzK5nGVqAPBhIBjY8Ydzvz8zecjIi93yRPrqno +pz234tEBU3ihva93grXnBPms9bGSy1Eln1e0EODLxiBUBUz1kqybymbRa/KObzeU +Qx+w7HDXDlVS/vfpBax1RXgXqUPXb7MjQpjyApnpB8w65ouUh2yYkyvJbQtLVhwi +4Gc2MUH2JvwU4L7eCrxFtL8ubtoxOS/7tvtDsXhvvKBqr4LkhdBzWVjBjQWkgR8i +8OvukcYesWNSsmyL1t5gDk6i0UAYw0Dc4SGATHdJ9Ql6XdV7jWyiU3YDUmQnTrY+ +ukAk8IQi1OVVGyOIlEQsbblrtYKup1JN3ds/Z71cZ1zQNcAMax9l1UKcIc7DQDRM +bcd3ralJi6/ZYxQEdpEaEbf/eP4X3sCdbDzc70NHNlL6t8VO9TDu7rIfG4AZcbt6 +Iu/jeE68YAWrqilr5nYznU6JAhwEEAECAAYFAk3R5p0ACgkQwSYz4e4BjJOBSA// +Rlpdfz/rvYXXfOovHquuiLfhQxL4L3eXlem7upln8ONwL/L0U86bIUqWI4pC0knR +P1n6hGpJcyNwz14pALupAAc3ln+mje9q6dWUFAS2UJR1mLYZD3vTAo9wpXMXs0tY +8ALyZCttn4d+4knZyEJArCtqWUWAG0AuR4jLKM8rg1IpxRGT/X+/xmZxcph2q+Pz +gFUWo0s+jQxrVyqVTZJt+kXAGgzBQig0GWG1uRUsbOYTDjJDrxriiccHWa5k/bjP +SjszfklzCQnDgnD705sIEMEThjysMBkVMvp+Nd1OaMitOlziDxj4TieUPLgsvEns +OTSoojimEChGf2T+H8RwcbfhFOfR5cJF0gT8i60V1WAKg0TbRYXMU5II9exts7N+ +B4DVXZag4V6Ep5mawWMp8yVlNzin8mi6Bt77fNquMyM46S693G68rl54KiU7VP6l +FrmFyQWbFukHRw3H8g8etcFGB74cdCSVOSMNEpeM8M++P77g47rHUExjHKlOATzj +DvjjvBq/EUeXcxUggsv/gplgoPIOYbVbxFPi8/vhcV+gKP/Vmb/lYzvyrLvjQ0jt +QObQKjwfD+CcxhHetw57miXhcgVHam1oJZ6WMWg6S+S+Vb83hvYUPDOxJThZ9uU6 +wOE734XPaQ1+zQ9/3MAaiSNZh8pYVVFfYjfjnCMccj2JAhwEEAECAAYFAk3UEKcA +CgkQ41LVxRxQQdQehhAAsHw+97iFhDWsRM973b+Oc8IDwteJU+GUJGu4vOq6J7Ft +zVaSgntWROZoRQTseIzBtajxLftvyGj4WPos5r3vCREdcj+tnlcT8jrVipn55vSK +IU7CyqCRs33MeDMcNk5JYMOKx1rZxTrkTmtEG+1qpwVpXciJF71ZJtRIERsmuh0A +w4m/0HfVrZZuxKKCH89QvLbkgkmdsg/rrOWmz1c69M2gaYbcbFmldCFwvkitRtmV +fgUZPDwtOH0wqTxZYj11rUYjIn6lbLp4zVkKChSEOGMQ5xZtQjtORPBlriwjVSuh +k0P7rEwdl6PVAwl0ZzYTH3oPfmqc2C0LJxB++gg81FclJOSelapWGXa3yduDNqqK +ojwF1w6NuwLehEcdVIeEp6ssd7RdIzDTc+9T6bGnqSIzmr/F9Y6hMSxo3Xkc4Krd +CO1a5pOlQSvnBuOZHjwfHyfS/YYZrH8m16hHKq0nnvVZscqs4vtZ4SA2tT8KdVET +Id3NaMO1+t0qtynV1Q+5BmBednmFLmtc4+eY/63c8VOSNPx+SS5P/MWkadCmQGzN ++7HXhulZZQDkMfKrACr/GO+kTYVnalp6uQD3HiMV8XWtkvZDakh4HXfwi4/m8L7l +MKC7hO0DbGKWkmWXes0xddyd1149ph0EfghwWuvNC1U82gRJ95OEvH2HMYZt2mSJ +AhwEEAEIAAYFAkzK1fIACgkQnDFQPG2GY5ar8xAAio8BDeBV4olApApTJB9Aqjx3 +f9kUM+qmLjKUcVI0/CjArDV9n+qws5NrjBMDWrCV3xa23jfY8uGVc7G5YEeV1OeG +knVvuTkNkbq8hPdnwqWFSXBSNRQoTHCUTR2cZ3mVKY52NFrQZ53Y37cXtr62sBL4 +GfK/6dPlKzVKI9NmqOUOvFFaQBsBO47NMvgVCPfr6FJ5IZExI7ZPZzYdSStH9xxe +FJjwYtBp2CfgFp9lJxPKdsP7MRAlLKTfkjQd0SHOXkfwzFtEmaLd8h8NBDM3nTAQ +o41sHYtmYaJt4TcY2zEwwEbIDd0rVwhfFOQ0+f+gagNRw/F2Fe5PZI5JuqsFFdhv +nOPf3e9W44XEIgSefOyzKozq1hQaBaQFqXGX+9HK+TqdBZGo1zxRWhIzncVn+LVU +tpVg/s7ZCf1ail+TVCKrmqXB45JSPUMj+WKAHihX3Rh94FzWkp6r7x6EID4ImuvO +z9ov/54XLkL9yYIO4NhTBi0G3SzA7VFE0VG90qbXA6S6O280SR6U/4nvdbono/af +IG9wIHGOl0gXUbfQ4h2UglD+FXQd0JBOh9vMaTyQMG4kcWjVhInXFsKXvL2qishf +QDK1MyKYxGvNyHOaMdEieRof0UXbHUzfWRjtmS0MoA4RhT4HYruiigwUAN9/CqCf +3ppVOWw+CP7QmnvVMamJAhwEEAEIAAYFAk3NKS8ACgkQGLP1D+WSPBixsxAAlbuG +FtT4Sa0h+xj3w39L6+ZxZb0flkUm70CuYJx5Ww4YdOjkc/2LSAK+uiQS6XQCrHWf +cf1jjL7GSf2cZWXWvYCrB98lptyccHkgXP7wA3ga2HsZgFG6u/y3JxwB9N++KsbF +JmtUi7Hnr9Ltw9WiV7cLglFmyXOmQUPAgyJII1nphjyhJdtS+U1OAy6fUJXXFDfM +Hd5aFNUhmUZ7jsho3TT4s2RFvXBl+jbZNoSbzspkI9g+VyaMkxbA0QTgLKufhZqt +5XKmtGser0YkpWJSlVUC1SRJEac3NtHiylYVcXAfxdnM4KyJA31MO0lsl0zWVvAL +AVpVsEaDuOAaBQV31+WOvV+VX0ggb7zKnOoI5g6XPXEj2YK1PHBieuyIbpjPhcif +zeDw7JsonxlYRsr1n6YLvgx4W1yms9bMlcfFfrLjhgzhmk4jct1i90DHtX3GPJ7J +MNludmVQ96vmC/uGm/9BiVl00Sx4bpBle2xNwXHCPRNSWi4c6jJAVCofJZrAirWA +cof0xYm4Zlc+8TTvLZw+oesgsyMz4JOGL8iyHE01NxihrEqtfelqyaAxmrxbrkPN +W6cyhJyVmAjcbRcoFHD51yaZ8gX5th1zarv8bffFA5EFhGnh/4/nq/4u5iogNqaY +W8pl+Ljx/zLCwWE0JJt6CHxXYc9b97dsxswNo6GJAhwEEAEKAAYFAk6yvRkACgkQ +lzJd2Pn91QbiuhAAg82XWKjXhCLVXAr54spSwU/UkXtfUgXFDf/VGQWWWn14aNpq +nPgfsIqJXbAUlU9TeVFOy5Zm2FVjCZgl43FWOQ4j/z/QQ0MR4a1bgF9IgJi3yNRn +jPqc44hEP46YPs1CwvpXwj0xuxbSM6N8qKDu6scRhuVUdHZkwrZuOhnTEZK85hIP +998s6HduV1k0xOzzWW4eH+KL/0WlQ3ALClK7NY+MlyCjNEdczSYeaKZBhn9NjCD5 +7xGQveDXiEq98pSt6bWW00gn5+yWn5z2al4j9mPdEGnid6dU6UpGaIK1a6l75l3a +Tvaak658VmRd7pDMqbZ/qtNDKoTo0FLv1hI2sW7L7lC+Fizj4semGzSPglWaxV/9 +mmsgXxAYo3lBR9xZKc5kFIVhlYjfEfojQ2xPjjlql7Rsv0xWRQggLzzmrYbromYL +LpGv7CgVc8UqXlIv1+/18RjTflNKgayw5OP5TTkLHMWGaFtPoSy9lQWTC0t8yBxs +rtN/bN2F0OZNb0vUZS1kauv3alu0R/UcXxXYGjilIxqpQHw6W/rgQC4P3t2Ls7yJ +5Ap2fOAVQXd3n2q+Hfc8ieAU8xoqB4ZGKocFkncgJdNXQw5tk5bdGrbbpdXpfVrS +RcilP31puScprwpbOKhodTLuMQJah084DvP/D+J3mwzQeCpawa+Cd2hpSseJAjcE +EwEIACEFAkoLePMCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQEm61Y6dL +Br+mLw//VdnC4YbYI+N/WGLtKfm1X1YD4IanfvmQan+eZZeuGIPaKY3bpMXFG24i +X7//GBKS6t6tQ1si573ssnC1Uq3lKO07tFwvTbAOx/e3ogSdyMHWN4QpPDEXhuoA +vP4OYtJRrC0vp9XFNjMz4hfROtdL0LygUeoJqNrm8Y/3nOzp+mndqdHup/Rc+J4S +EG3koGEqg7rWoTmT7kcvpExTB0GDapnbrYOslF15UhRdpWohTH0zokve3LTIhfb9 +PfyFJOAvtgvfD0sQ4bSMtSs/PMohvb5R62fT8zCVvpR9t6lqIwwzIai3HzZDgocb +BzYRTrHbSQsjnic0qhRMqcrB5I1jWkFRYmaPpzXPdf+lsGo/aH2VLofFwZMrYHRM +8APS+MDsnpJvg2J+Oy4S0wyTH2oQdKD7jXE4RH5J6+x0VLlhx4HGn1eXdgiZJPrX +1rbQe1QobCzW1v5dIvu7iAbOreVyOZYcaHPshFCyPqTMMxWM3uzcigwmnLSdvHec +tjAoJBDl2/irInst6DgH/9YweKYvlOMTF9h/QfiUaMNO8B7FM9LYK3tbvQJ3GOgS +EtT6/HwDGbwqPostihMJPTgz20jq5eGFNe+Jbk/ict+MS49DQkQn5iQIrSUnyhjU +7XwX8nHpYlwBODmE0Tnr4+Ll1E6KEkM9vu74g7IindhxJuiACcOIRgQQEQIABgUC +UUd+HwAKCRCZzeqdpBNbOI1QAKCYv/7u4pKPau+GSUq81CuASZ2APgCeKDV7wXDV +5fCOWce6L4MMikVZPLiIRgQQEQgABgUCT60ktQAKCRD23TMCEPpM0Qo0AJ9H5vE9 +Jeq5fgC3SxEcofcfjR5WHACeL3NriyFmLN3Adx/qeuaGQllg6S2ITAQTEQIADAUC +U1W+rgWDB4YfgAAKCRC8yx4nMXJi0pGUAKCEMV9c48YfQsCAgwakJv2TzJoMkgCg +wchrPodYLv9w0Nk0DeLPIb6VJeuJAhwEEAECAAYFAlNJj34ACgkQBMNnwhit1P8X +fg/+JMSAHo5wmHlp5bQFDC/o/W7461Vf1hIssFTa51kI/tgY6JeDkQcZ4kp06y+3 +GsgljS+eu7qK6LKfaP+AfgQGLUHp6of+YMbfHrmB3tJGpG//UeSutBK+tmgqEcMx +AlpPl8Z+icCjxBUtoP1zY0uvtPRe9IoNTxixz7cZArAlsNinLU0Sk2YOaGLeFiF/ +o2S598+6ebAiNVHOTo0Cv+3A71uCpxfQHzOhaHY5brdO+4cmW4FG1lBI4cqpJgTN +wV0Vj1xOtk/dTxTTbaioBSL0CAT5/ouy6fIcgA0uya+W2jz1uP1mjdLC68yrNvqS +z+qSCz65NL1VRZGbjI67Av7GDzKo5lCRBS1ltMmzmKT2RGbbNRTpuflBNNti6fBg +rkqv/LWIKeE/M4R/PwGtgCDcwd9yJLNN7pOyOkpGDnI7JRiimiDDwsI6rg2+LcD+ +yWHlTfgMdNEr9RX/dMmoV8IdViAB8v7fzpiuGqr1+zdWAnn1ohnaDMfm/zGFLpki +8FEwil45X66ni3oeWDoL+hKe7QYt9kKvgnx1Sb0DhhhmiyW/UIw7mMKhYWrGi3W4 +IOhAsFjJoG2rbYxW+EFX35AQKikTtWq7xpfuTa89zxvVZoChK2NOc3oky157C92r +J5YklhEOsJfVHFAAr8RFDQrPGJd93MF68OQIaMtpzsEQKyiJAhwEEAECAAYFAlNN +mdMACgkQLqdrnCtGbZ3BdBAAoGOkLXMbgRRILEUHEk/CSQW1vKs2l6lm0HRVYvNM +OtkIWWFFfryI6Io3VfMSQeRkfRK6v3cLr5zTNqi5pt5IF52sOH495eLK8LiYM1UR +4DHp4aDcN4WAIoj/Y6zT8pYLCsCUzkNPTw4hVJCFe1HT3Ru42zHZUDlFNF4EENz+ +deJLRJwkWAbfI1rA1zzPTGf2nqofgIzeXU7cmg97nyRHyD4naEIQk2Qrjuzpb/5M +obt3UlaHcvjOCN3Dl1MplC2X4607bSP8K5Dg4qNTBxppvXvRUCSQYOBDYbDydbC3 +ObZXlgPoYV54jsovq+xK5qRHrcwDh4/x9tlRy+NbEyZSVXxMrPM+gSsSzcelmQ6d +dkLLToUl42UXFsPtncgHVUKhA5ihiDEB8cG2UFxN4Fig57p6QGVdL4wDRIZ5wHt0 +o/1HcjHfNA6Y+DritXFB9JsOUdwsETi5afvwJcS3o25vHJfSarRpSO0jvNZS7hhU +Cu8B3jCSPE2f36Lpn7OGUwOr+JhLBuREo/brSDF7mAWdFSYCqV7qhoqQznkPzGoF +hUXjq5EEojRWOSd+2FM3ZMbXOKxyu4bRPXteoDgjXakiULd6TM89Y8dcqfdNLpSB +xInGayyIG5B8BDyJwHGFGrwJiny/ItK7IQtkvhc86rZ6bxHiJ9/i/8UWZ/cpqAOq +eGqJAhwEEAECAAYFAlP7wEoACgkQZJWf6YON8ZyH7w//eUSuX7rUovLniYmb2ikM +E3xL0UDqPatOmELj9uTlc5GJ8sBGwDZCP8QwyMV/thzvm8U4vjFFr3Nv5ELabHIH +/B1jJGmbtu573e4PwgxVsPecfD9EgktzSHZnYumeUiwzdzS7zg/5KbeFoe+UThQV +4hI9/JmY2/Vf0wTCTSx+sA4A2ThpThC8JF1oupXlWITJllpAiduBX2hqGhURRqEt +ZjI4z/JJLxEEOoPBpcjzcBWrI/x/CtPTd/4Ey2A0nelHX2NM3NvGO12JvsxY9l56 +lWsRldL+Kei2FwM/NS5wc5ZuVoUWnp2ZhQaBRJqSEI/1c64wZrw4x7+g7eXWCIfH +qlIYBbflPa4gtDV0Q68rABL0xFTQxhGymOCnpDo2DJNhzclLrLBxResbGOzQau7N +NQfaW+0zz7en9GSgA1Jt015kHq94KL2O7njKv7tiUIuoWFaVDafrmN//TirRwxHu +6KULA1IgZRdmHZZzeYzl2QMJvJf0GTM4HeKvkR7acAat6CSNRWfIMsG3p34JOvTl +MBBgbKYFhjGQORdcqJiONg/13wpdu0yhKouIv5nhqHp6/M5axaSE0S2v4A9vhObb +JQ1qvtbaxBxsuByNDLQmBYxU7w9wPirLWSN0x1UvuTNaGwSqrBqTOC2SthV4AX9S +cHAi2m5FCmNtcgO5g69KVI2JAhwEEAEIAAYFAk+tJGEACgkQOTWH2X2GUAs6HQ/+ +L1cQngN7OpeLq80Z37pN5F3UnDxnqBa6iU7KrCHJMPaxgeh1CQt9b45NJRuN0HEj +p317wJGJ5y40dwiTOTUvtmHnz2L77+1MlV5vt+zdVzjZbhm3AQEBPunVunYLMY0B +pjxtLY3nSYNujwtesAt1CkNPqa+m22VsX+0aJtDViYyjiMpDSG8rKzu55cqYQgZm +E58ihWSCm0PWkAFYZQI/pFACkaEDxOMQUZRyU3NUT/Ok6sm+GdbEHVmnvQOSWkmB +WP3dUqkhJMPKdb3PNuBL/jNckJllYv4Tq9wBqXmWZS79wIju5cfbPSjGhVsJH3wL +dZPbq/VXh1+JNV88nlMFsJjYxmFSs+XcP2g3a5O1fKuTPtrUgxq6uBgl8Y/fV0ys +GUhLHhOBXxFHalzOQ/qsj0i9H5QO2x/IABz4+5U2iqUlHk4a1wzkL7a38ReLqPEY +JJOIqD/3yrK+JC2wGBtYV49mYR1pjKGlZkqesWNpB1uVr2atDSkSvRLKw1/AgyvS +d4i9I3lVzvmAHVm1iI+l56OCIrij5kTUG2Qx59i5GVKKG0Xjn6OFiDF3PyA+Kl3o +TdGfNmdQjp2fqEFlg6+btnegcEXFbEo3cqqnQAOT34FgTrDElB60eU6qCbAx2BKm +bs2VRtLPp7RCcjRNMGdBJAGs/jIRwxoHQ73rHPQnlouJAhwEEAEIAAYFAlNZzZIA +CgkQvlz2h9xat8JFmBAArJOPDyIHLeo530NaBUvnuQGHkXJ4XufB5ek1Vbhu2EOZ +2VEXWAmgmifvSc5yLwi74iPh8RwH5Z1r6skipHLzUkzeIjmmE1Pv43HUqIwLpkJt +VOYi5J7XwZ57pXMdbr9lHC80XHh8nAN+VZbAiC+5FvX0UF6HczMdqW1m8XFMuQXS +7LdTCRXAV5+nyL3DV2K3BX/AB/mrwtOqlTHmMRqibiB8Zj6NT4/sp9h14la1YZbG +LLMuJTxXaFdVu3VrvnczmGb6KfLl2vUEw2m6iwUzJfJizQS5ASKJU+x42l7VTYMe +hWA/74/ieQD6w8/VLoxYq1LqviEgmA7XmYX4GLpuJR4KYgH43GmjBltzTpZXeC2d +K1fzLqyKlGb7LWHTUwmTpwC++2ILa98WRSsOQ0F61u4KXcjluws3TvrtCGcg8obx +TDJ6S5bVPffo2KvRx6kJzJQ0ZiA3VjRLqcm3UmlSSmqErT1gNBh1+6t6sOnZaz2p +xtv7WVmLamyHOO4EGampdjIMH/5nHM4G5LuHlb8n7GuESf8sNyE0CTzTJsWeDmPc +2w9oQvAoGAM/UFg1XVhjPHmjSGgCWw0UlfpQE+k8oJ8ZhRkbHMeselw0JrZZsW2p +NRC5uj1w3ZkirXOXzg5pb1fNViccH+zVqX78PB1JRURVqXeZjddaDMlTrEzZpIWJ +AhwEEAEIAAYFAlP8+F0ACgkQ+mQ7ph0ievtWLg/+OtC1SBTvr1wLhqJTpbCE44KQ +5AzE9qCzsMJvmNys1ddHAbbva23E1zEVsfUA9b08Zr5zIWaWmvk50cVpGh06kpfk +CFMabmL7xpfQBb8TMmRrwOs2Ue4KSuq+4N+Mdi3CKiNODN6n/17eQ0UrgZWNUEfe +8aD4AOJ5+VitBeS3x1aFhpo5d3HSONUaSmY18P1cYNkB38Z6v48O/UdMa5LO6JB6 +iH9u0ooxHSYBbtw3DTuuJCD0aCAOHZt/KtG3bvqjNpmTfo+QEhFFwmfmF975UcHt +JKwa/+DTVf3DQdHY8BO9rjSieOcoNa23W9LCQs7L+yhW0mfuX2DCLTzpTgd/qjaS +juZj4QKPrZRgHO9oUGPF8i7SOzYvB73quTB+yMZSfYPTZvADl1BgzBeBliggYinR +hNJVN3sljRKxS8BnNDfnNZKg2AcduSGQlZj8JQvDneZ6+jVGT96pbrx3oLL86BnG +4fw+65FXpN7Z6qUTrEbqyMJsN3JhJO9+KIulezS07ivZT3ulI0ILojXYnoBlE0ZM +unsup7ZOYrQgWAoz2Q8700blCOjDTq5VNf4mbzoS1hR4hUDvaIExgR4Toekj0Bxq +kcQL/OICjZUG4sh+klEcR/hy4rjMIqavmKYDb2I6FtHa8jsfKUPp/jw9DqhpLl/b +rpQrtNFV/ol7UHmawUyJAhwEEAEIAAYFAlQBB/MACgkQT6BKTJJXfsTRDQ/9Eznl +PQU33j2rEknlCaNqQW0MiAhocfCZ+9KTQ+mdSmSta0m54fq+ERWSr4vxGdhwMoJ9 +inSts+qiGkF93ZKudyzXuhb1daReQw8HPQTYeEWKl+k3r7xxHNQcGNCCKfahapSB +DY/deulbiWQcpEb1RePJLS7Zfqk0pqDt13/HbJLCnhXgmAVkWfNQqchGs2Nk542J +g98XKvVWEpOXaHVGLGFyr/N4I2pXVzh7v5rfxexKGEFLe4OaaxSx3YUi/cZbuzlv +pMXIKJwMFJZm4nakGWnjDtfcqbSeGRGu5yUdKvZM/onle0nFeFUAVOte6KwnOo0t +Exv+7Of3PSIaoCf5qePbhxmfyjCppfwaJK+ezhKuvbdLd2Rc2h+ChGoco5gTysb/ +9Yf9qHJrGV+mitS05jbISC/NO/6wcdUJNEVtnfWKzfHfk7AGfEd7ul2gAc+DqT2G +EyoKPajG4qOco/HzzA0SU2Oeed9QWhFXF2tPM2PZbRTozkj53IiZ3oGSjJ2Rf6XW +jPOxj4HsSDAQV8wCmQaKpeAuT3IKsmxeUi1HOblYHNKSQ8vVN2ASf3oSfOz0uo29 +KlKhrqHYpF7hcLmr6aSDhYr7bOc+imCXT0/sH3oXNqhgEWib7ChfXE6hR45zY2cm +sn2Jn/SeyoiNkZF7L3c5qReUqNwE15zELfJ+sPSJAhwEEAEIAAYFAlQDssIACgkQ +ZzoD5MHbkh9tzw/9ECZZl4R27kFFt96C02/dG8Yr+QGOQsCHcrC7/cZgZ82zWxvh +YxI4R5lRZzhAK63bSynfJPq7LlMEXiArIxXiBiDL9j66HIAO8CxITDPdOUdY6dTX +R01oW6hR568OleIqH8CP36fnT6lZ4oTNqs+GUAZI6JVRFfxvf42Fx8sUiVlRyEx+ +8xG506SHvz0QuwdjAWpvnuSGFpi3lqq2RL0u5A/aZJVbf8uGnP5bdfj1fcBoh+Jz +H5Blth98Iog0UMbHN1o/94X7pqASif0X7N+K6NXTU3+rVHCe5hsN1DixPvnyHYQh +833jqmydOzyYNMml5PJLh1Qqqadxf42MghHIpUUzcoB6kS51MLjjmtCSGrcCMCai +lTlXpxniW+5LyXt3QzexfvSnLkxCD3/J1FtcBnDbZWvF99QhPWQpIk263F58eB8y +6zqlELT940futgmAFpzLrZ3MKRWYM2mODnbk4GuzHgCaUyVNXMT96KyifQPHCGl4 +oDm4ghUG3VhRRC9gfz0SboR7tgF5A5fElc1oFAM+3B3ja75LQln3uK7hoOTGn8w+ +qdXMztwEiF4sk3YQcDehfGw1/rLYHpn4BO8Eq4Oi+xJMOyQ4w9BjrmXVOJcC8/07 +bK3Ee5tY3LPOdsUw9JbONBJouEjpOlI25pVK7hwzimsTmTX4wtsXilW6YW6JAhwE +EAEIAAYFAlQFHCYACgkQwPiGTNo9A1hclg/+Jwx1kJqjDKtHlmnQ7LwzeUsf/3dc +vbBcCP+HfMd6vnBTucZa0AC+RTbCTRjLt6lsSM7s2QumrgnazQIcT35lemGf+APZ +DA1PHSJ9ufskyALwSz6xA/m0KBaxK56cISAU9xZt1ApfuG2X5s4WsiN4vZpQ4Jrg +FQDyVo2LEeGZRFCZr0rYCsuuI6i8cw0H8us7FRZyvzQ91lj7ODTHlayuibpWfk5W +1LJUynnhnkjgIcQ6iF6mvVN1+cjoTKMzpBPd4mUYhc0sH/gkRBIxeNdSWeo9SgHY +hjbBeJUpvWyPqlw1pybNImJOxEMZLVTjaexnZ410RfeYhst/BeFhFWtwnLfQjq3r +yw/iP9N7oyX0damxInEcURWVmXsyqmynhumb/3d9praxFXYwTtl/osmsexVkoYBS +SJdJbvzNqvbYDEbmLf4u4/3lJgE/UsFgV3FFxRxj6dFE63JCqc/VC8Uq8GQXtVgg +jmQ1v6QnP3P6xNQGDlXBf5Vt6WTSeFb63V8sRN7KdPLUAOleIJpYQfbxt2F78oC5 +6tXOK7PJNNlaKambc9utep6XH5xrAZr9OuiH+olf5vhGtlax84PnEfXKkkKEgDhm +o1iYM+8zj8RrgFivZCn0amamO1TATp6I5zoeyz0MDDvEKQMWhHjvAsygqSc7qhMg +1/QTisBWInybOpSJAhwEEAEIAAYFAlQHvuQACgkQO1biu9U/3LHrFg/9GlFb/KGz +qKeT9mlb6u2fsCsLg+B2yZAT7U1la4JNtonbOzChe2/1647kMyOVQ0sPaz5g2M3e +S2sh+y195udyoI00L3T0KLesoZeyx29yi/uBzcxT5Kq96eaGLp9KRxjX+YeTBK3+ +Y4cw4TcIehAp0PiCKT2dcd1jkysgzG43ySyYH2ctJxUpVx74KXI95oq6vovL3cXg +F6qwtTlI+3sMUueeuMzxPyvCD8gqS2fyDe5cvTFETKMW/4DGsi4PkNCoz8xGKT01 +6RresFOTNCign7ZqP+xGlG5rK39JDVizoiYkxgy2YlkwRoCsOW/LQvni/8Er4Arw +w6yHMJq8Apw2FafYIboHT/MWAxuw4hP/YMjqrwySOtRUOxFQxGvBhiUa13erf++P +nxWNJtjQaRJEvE3gubo6vMKJGbzBFPCrGasTCDFVnNbjvyiTPOvKEZObhIISUSP8 +rLCZOJ7mm4uOhjbe9bl0NVVQ5fLOFXQC2TL+sX7DJpSl0dw0VXFNzsmLqeqQq278 +Ix7DaDBFOC8UdNAfz+qBgjGNjb2jLH19FLcIJf6W9e4Aj1ex0jSXKnEwrDcZSVza +eixr/F0O0zGhzn6baFxnwHmdFnG3z8IzRuALYBU2fksMKcQlwZ2G1n9RKbzyU5A7 +hKFfhb+nQr8T2PexAxe9M8af8nasNVLIpO6JAhwEEAEIAAYFAlQcL68ACgkQ2Sny +mSvvCjO4cw//VgyyedYXHMxmKj/LzHZgRbYuQMVlJBrBIefoHf0uacd7MvPjugEC +Aw7zT1FKmLlwAe+mDlJGKZREePbi+CxZTB/0rf953NvxHdzX3kvFcLj0KNcef5LE +2teuVADD9jkcpbEx6UXiZzT7MzsTp3WWm0Y3+1980LK0FEH9zawFOgLMp+qrEJy4 +d1SFybDAVOAFgtHwa/6EG0DduAf22Wh5dWh0fv+50M0umC7WFJ23yBXd9MOCXefK +jvGGEeaQ+6rPuwq8uZ78R2Yfr0rHV+aX1u7G0uq7g+R/aPJoXhbEMPDInVluWuH8 +HOWSbo2TfDLQBjdcFW4dRGJ4Kir3CaR38hl76yex7KPHFKMSfL0KsOlEZMRlCY2q +67zLj8WC+FP0a1eTHOa4OqdDmuFij3mRB9YNxiPeI9sQQwG4Ys297qefWe10uiwc +LYIQ00uZhhill8DK12chpc/vqGT81Qo8hA9kLE5kJKk3rmHiYq7cvutLx5z8Z784 +cqJVWY8gsOCRPKt7xPGjsOtDsqP1oHTslPZgih/gkla93T2WSRuZni3CNUC6xzUl +e7mJ/S181iQ1O6Yzey71Bfcia6wZb/pE6+8KCX9xGRM2OiuQF4RmJoIml3+Hx3V1 +lZJpbXAs1Ru81NDObf9AQ15F+hFTLuAfjBKzJRVc18tMcakesUP1dIiJAhwEEAEK +AAYFAlQHN7sACgkQA2qcJb81fdTbpRAAkwRT+cdqgebIDlktbpM90dKyQ9ENN+Gz +Px60ojsltErUeqiDQyINqwqYWIZqBtarJDXX+KB/x0iTVDnV5IMN8ll9r9xM0RO3 +zjgCZhla6kS8I6Pl11B3TocPNT0JlEQCCTd+uKlkBuvl6I1RuuMS3fk35JI5mgR4 +oW6JYm9ixX9DDMpEU5C5iP8SY7gVtDjv/5sCizz4kIMp/qNIiqXaZdsJZS12NDa9 +RljWM/0fwqfJzlCpDzcCBdYxxvurXamU59UJ3EYyJpyBl5675zwkNlL332UnvrkB +xfX/IWsJx3whnNoBcnN39p23H9aeLwexdSZfBBvhE0LsOh7g1av9VnnZaGR0Jq1Q +kx8VTq/x20Gpq2F/uWZbi5oWE3nvwV4fxbOrmn/TGsRAiVfiqvOiNvgVo8bEUFm5 +IZtYPs026JJOYA3RBI+zw325oleF2KRkfPKZJ7HjiR4ClzT5I8pGttSq3DlISR09 +pe9utdp1C+BlyKeq4yIO4SJkWLP99HWl/son20fpy1tH6625l3zRYFyo9qa5mlyB +43TZqqFdlFLEEo/WTZmKRoRYn5lt4cH//tMoBCZdGdW6h8MeyrE84EeHsG5br9ai +PdvjPV+BrR+oOrbt8rYzgebBm/hbXGdcixvdRTcGvU0uWhDKwDrWQ5fpz3y3mjen +62wP/eNlenyJAhwEEAEKAAYFAlQNGwcACgkQdRq13aeWeczYwg/+OA/7sknrb8SF +FTlj1RDFl7Hkbydfl+i3YKR3wQKDScQkHw+Zn6y6enVVzm3Zm7rRa5Prr8+IAymC +dVn1M9sXKqm9V+v5ccnGkLAkSiD9/T8Ar3+chMRlt626jmUAanUoRiV4koc10tK/ +gv97lz9TK5EY1uMVLCoyPua7d7L+YGhkvjsOsdSTIqurWYgewy18pRnHD/E0wcK4 +bBv+6fWrCmL++n5476kRUlAHwu8hK/ZqjxlRSnnz8ux3wmdAjaJkqMODyCRzQ1QH +ZJVppKtjt8689Z4Neaw4h74dRRNkm8643Cjzxnfd1rlnLRWBfkRcR5VWgt4jPW7C +r7CaZRyCZvAI4r21zjhR4a0gGVon5+WbtRV85R+yiRgIwh4a2Bu1GagJTLUIUfKR +9atQCU3NjV9gha2riexFHQXO/3VABNbDqBG0JoFywyiPOvoGNm7xEb1NrfJM3xeQ +H22PVY0VBqsluagWB531WeXNzKLKPiTdCcoXyLvarIq20wcJgF9CFmVyUgIyvqvR +/JP+1k97MKI6/ihN+KOueeOI74iwqRAlLDypZBbHieJUBU6qpfPHCRkxI+MRdSMS +/uuYm9M0qwnAUEYtvm3S5oMP2t56gnAVpKL7sYWnPMGAAzxjp7u5CZSR+PXQx3sz +Gaioffzjiw9TFswHvxgymXZ4c90CgDSJAhwEEAEKAAYFAlQPVewACgkQbmCLY32J +Z+l6kA/+NcKkYoIrC1jHKImamjflK3CxLNJNzhGd+qNO3rMxCkrm6tlr5U48v7c2 +jZhEC4EKGtkuy5bvf1rwbZY+FX/MAJbULZ79QmgxVZwhS6OWzCCwRegdP41Jp/DX +zDwIsK7IGA5ufKAT8Fv2rBdeBWqGCKxFuNFgVwY98xWCPeNMyOJ0sTxoHligvhJb +9JgaDP/T1dn8jIBnbpEjjHCEId9yPqXeOVjY7HpaEwLkVzfFug1g2+dQOW73vDIf +7YUnMd8zWbKO5j/7hLl+khb29ypAr9RGuoCELiveI5WLJQU8GcazrbyfkttCGt2N +zBbM+7gvjHNI9ty9deqZYC7WnqpioS/0yDFFRQ1gYwE2+oQXcJQxi2Nni1aPJwvC +M4R8F1nlmUVPUaPZNjHJhnPbVW7tpEFFpcwO3LEYU+QE5QD/Vi2FkGmj6rOAOdLr +/F0bnxeQTcO/7Rha0mNI34TcmbNOVaTI0wdcT1aQ8ROz848q64BKd+vgBA53oMLi +KJnoroB8P28fBVIutfURr7I3er85hIvq8zLViJDVkYDKurU3Oi5TNjLuDeQPhDYH +W6nJ/w1yDGHNErKWis6wRDPeDuVtqGUyNNGSJdZBFfpP33nNqp1lzULZWcmE5XCm +bbWIwCWxhdGmKHP0o0TAlqNJi5yuSTY2ZHx0zjMgDPuryrl6P8eJAhwEEAEKAAYF +AlQPZbYACgkQ+z0lgztqr/iOOA//Y7Z16E1yEEfJOcAx2KftvjKa43RvX1lcWE7E +ldeWpm8SP/5xhY1NQU43n1hUHEViiDJ/Daj6uHui7TOfQw4b4npuUrImMqzYaDrL +1tQjqTm2GqSVZSYNtXWy2Mp9qZmFBb9tBkpngjsuw6+m3J0yOGOmT1ZE0We1pwSb +kwvlkLaXGVYvplDclQB5fWLS0jiIxRWqTJs7mLZEpO+e4yPPCYEVN49hzOdtCGrf +s6AeO3THuTZEvA5FKXOyXJcCHK7GvTTFt1PfOndiGG6pq27DHoqhvaXnhslgqGJY +FUEIEO22plyWiUZTHzy4uEagcxwyOmuJA0G68Q+EcDgR7dbeMpMIjE1ZqxhTA8l2 +jpzjRfTXrnr0jBTDVBURkiEvEEok1cTuIeZJ4llUej2U7K6fe1r7zmFYJBeB8+wO +P4ZET9zTzBp3og5kUOu93YBLgVUr2FExaZ+7vWDtqjueeW0SMO1HMX7DTx8lTcB5 +vt7kNiwWVgqfAcVYmXKeh/O5h67Pgd7CTMorw2e0c7dnakaRKp/Fa9XqQQhDQfQB +wLyM/zh0MDFkwpGW+uR/UoulCL21Y7WRWRsg+z7PHmB05oDitGvDj7JCPIQ3zWhS +1CleCJy5YKCpfoWiL55dR6niDI1dmm2PtUCUODZ2XlVQFTFn5Q3UlYfR6p1gS7hp +Ptgc6EyJAhwEEgEIAAYFAlQAsYwACgkQT616dThFWdtryRAAuB9mGd7zCHeBQ4fN +mJ2LKuuLPRTwvsHjzKN/ctrZKLV2RRJOt1PKkI0oD+SgmD19XHyULCe6xv6dvLi5 +MFGpQbhAIxcfyiWjE3jF7hODv3XSqCKhdRunPM1JpsqlsQUz1NhtS7ug6pe+u7vW +Xfi4+Mt2eJffsBvCuMtawiYxqGn8IaPTlRFt07KUtTYw7Au7P0Lcjp4E9pUTB1ee +ZrRDWry4swvy555rzOn/6frw8QOKOeZIc4mNCNNwJvqVnu7vTsHd5AOj2guQoyU+ +ui6CAssX+fTJlkGfViY7vFGQOABIcf4xr+u/pdVX+LkiaBuBbJ0VKpgxjgTDCPyZ +1KHEqxUM9JtSdptNCBhXBBxX+1Jx6DERgSXDPgtCRX9aI2MMqwnJIRWSlOHNSLvk +J7PlNjRC4ZcwQPnl1pVbJqtx7cgn6/z92BHsn+21CPcyUo1f+SyLZyKnhAd7kMjY +o3yePkf7gQalRroaj9l+3rJffFO9HpF6ujibiYa20IFMZB7WaP7BwbjXDCBvroca +9hgCWxT/R2bDYZ7IBV8kJGS+P7EoiGUu2o2PhCFc8W/xFXYrhccJtUcw8ujH5ftQ +1Xx//q12XoelL96N+8nxztv85/5mV7zexbidoFm2XZzaZrL4RWqtRZPf3aH7pDNa +fJHbc6UIu2sozS3nah1C3iTquKGJAhwEEwEIAAYFAlQxjv0ACgkQiHtgYYs8Fq6E +Fw//fh/zpcvcqmzd3e1iTpKNjZHFxuaaGD3rYGkKPagTgTkUKOMT/0FQKfmHu8U8 +Dk+FUHCxYlTH6M7KOdSjJgkxdzgJxkzFNd1j6UIdTiSLezi5JagWTeEiI9ny2dud +3McVi8l1lWrbkxFCQCnf6BtOzttdMZFetgrVIuvsKF1s96w5RWp9gLJF+ilJm52T +Jc3WFRCPcJWQWYUWEKZVnSgXYUA1s7XJ3K039PDIt9RaE/rIVNiu8ApJXzAnpdk1 +m2V6OVC7bEGAWSvvaqUJHue55FPNuH9In3j+O1FQuhCKEB6LubzI8qkPXMeI0G/x +pf4DM4Ff8z3Wtpe3wFdhT0SlDS/VHdwiereygfXGt/AonBGGk7XVrVImKNbFf8ex +s0bfvuIgXXUbouEHSIBuPChutZFEt3QcvdZ1FUZYyGtK/C5TTd2kUZwn18SIzhJP +YCbvvus8bfOVAecQ/G3txt82AaQrTj78H1IuFDOEA6xs4LBkaJeq3V6a1lbLClIK +qhkihR6nklJbNcTS6Jv5CPVQ6gSOgjBl/jqcIXPG/l2K0A5IsWdh6JF5e91fKR67 +g34mqprLj8USzcXrUfm1wdsntadGw3F+21Q22TYwvdXl5PC68mT9BfWfyoYH9ZQf +Ho7ro3i92w58kzW35dF5RUu+TylZyOEXf9Evn1EYWUTNo0WJARwEEgECAAYFAlTQ +Tv8ACgkQlOkt+SqqXDs37Qf/baPg403LYvidQdSYy52BfRi3JzNOpVHUojOJD1ei +lhRSeON8fSsgpDaYWte+ns0mli9Un0hqFnpP51ZydMWwjyiZnnD8bF/g5rPp87Rt +Ap4hSbSh25Xs2lpzVIjVeNy8fVzvTbDUj6nfelXhfHZOYezxZLkvri4fIa0ZUF7C +lY4r+3hTDQ+2yJJHkeJLt5yF6/b7rXvNFKz6HM2NpsjvwdXiZtPp9dqZXgeccdxs +v9Z3evNRtczhbxqU+mBiF/Kze71Qr6STvpdLbbutUeGhj2mYyegYsYbp6oSLTxan +n0/q7AxI4GnlZSZNebwlcIqthPIbPPG/X6vAjixFPLmOpIkCHAQQAQIABgUCVMYw +BAAKCRDDjoFgoXhB/gqyD/9Ubv1DrOxf/xroZexCewfJEbU956GzCfg01fqDXe9l +S0RYm8pvkF2yIZFLqkm0ZkfM5zjPFMOOQbo0CFuJHqnpR1l6NlJXtD6vGvuuLHHF +0Q7vX5nxZmJUCYytl7RcR38SfiiYzZ81iAg1zDN0invw7c54VbCYRBO8RaNDB+oh +++UbTccOyJ/vu81wqBXmkOxQjpWwqRw9BKN5fk+cDTt9ms32F3za3tM8KgA2pY0l +nOsk1deRyngonj8Al21UTB9w+85zGBieRUJsd3PdfF07T7nKeEoptd7ewQSfUuQL +iAsr5QlyuxqeWvMBjaSqmstyY3vLliRHaOZz1XoKqvxb30m2wQuQ5tsFUpjtgSZD +1Kp4y/tpk7CH5MYpcrbSm8HBH+GOqdNmUEvYGKkfWMtr1xMZ1Acz0NcGjJ+SsQpZ +VQeYSbAPN4Ecn6d3ClmeaHsUfPKj7MsQiUaPRNc8ouCH3uuWvGu0RV6cq2Ai9lgH +HXNdyubyXFmFmRM+SBFPTZfRvwq7yVVNaQLFs94Ja7+J2mT7UREl8sNvjOaSBGvn +LTX3d/rwvMF6HLvaTMKJIJgc7v3Qt5ku3Xp9JPwJ69zY/aSsSROrh33DGNTLZIy/ +7GkPf3QbumydIM5iZtMzcJ13A8yMnaYt1LyE9gHGG7Vr5C83I1TZCLHsE9/IlTCk +FokCHAQQAQgABgUCVJCc0gAKCRC45Qh3Zkdar8WoD/wPCMMFSzdm5fyy0YLFi2Dc +AroBYvaHpjsRSozUSS2FH8MA/KOlemg96fuvA+m1JX2rtC2QEAmZczYM1FchONpp +Du3uZ5/Cp5MLS+fI6bk7znSAO2b4fVRgq6feVrvlLGfOVSUgkT2/hKdbT24GzDjb +bDqfF7GKiO0Df+JaIE3ZD7w95CXVQ4hlRu8V6gc5Ggd3OXzeLqt93ph39lCTbWo4 +UJFiGZGUzehSvxt1/7jXYmHqfMp4pq8W4cEOAqg2rQ9eE7jlNPQOj8wDU5aEzKQp +wuY0JkNxY2CbXGFjGOndthaGAjkrnYRX4X3vP2kHPu/dpPNzL6f1U4SdhDEYR73+ +D4Em3RA6ZBC8i/j8WxzUGfGdppxYy5+QkuznpzfHbZJtUlnos6vLEdvS9u3MDoVs +FMsTlPapSF+BzyP1FcLjST71y8KgCQSVjpR4iaoWiXobri2PtdTw/MAyar8u9kiB +aJcEc89lrqE2xWEPzjEfy3p+gaKn01gh7ZUKcKS9AExGxWL/hBFgRoUtrR3c5sdB +K1hMcIVRv7y3COrCbANuyOtlS7fZW/NNmoMdjA1lMfXUI/CGMUZz6Rj73n8E9WNb +5fqSRGdurYFxGrt+kADB9OX3cOte0kSZU2qtUK9AEo6ob7KObyU6DYnhrl6L5+V3 +qjCqq1HjYdsSNhqC1uTWP4kCHAQQAQgABgUCVLSGLAAKCRBQQfGJH0TgkERiD/9e +eWTnvlVa3C8ONppQVX1KYskYzaVHXVpgwyKrqoUTjSY4DGLd2276OAAWdYWHnu0m +mJ+ggkcGn0Ls5BINfcDp95YzGdUvLq6qvr8MPIIr98bNpkBT3XBekACk2bgFcBng +VsEXCjtbl9FBVaXEeYKdHXBIuQQ1tvCmFSbb+SmWTdjPtTkvxQEdGC3nsS29IAKD +MF8Y3LD5sowz0C87FNPh8ppCj1xmvu8R1fbJRMBxdPZvUAJKEeNCNkgeg0eoSRi5 +4KxT2yloHXLeXg9vdt4dPP3BLel0cJTxvyCEMP4Hd3khDpZa8qtH2YAcUAZqyFF5 +aUDUdfWl55OHkK3TlAYBZRi2w8nASZiLsNE6Zt9OXfZ3rfy+NNSPmVvmgOAXKTm5 +zi19M0Idz4ZEhbiJtLJVrIODfG1TRTgEPdg816EG7Joavv6jrRzw+uoVIKuFogQi +i7Gh/LCTUmz11R9oRKOoynl2/V52+1VBNsSqPq8WTB+lFLFEpw1NlryCFlWkB0w0 +Va5I9to31aSubsFTVQdBTEIF18miQjOyTbHkHhW+AmOzJChR4YxwL6uj5eKkWEkS +rmAB97mQQ4tf6D+LPELlpGXqGCXlRuF4cU6VHpxssBbNtzrChKZGqzKqoLbMRS5s +TVgNhBLv0y/2s3Jpd2bJOeQklEb0WzntzDbmh4LBIokCHAQTAQgABgUCVTbNPwAK +CRDHiMTB1FUNRVuzD/43GD0Ga7ahaZNazjST2JwcmwwHJzCbPegmj90/lX4C9db2 +3VELDQVGhVDqrtC9OT9YfA73TjR58KgwnWo7NsSigNyVICgr1WvYzRhToSg3ZDJP +KdbV1B+HYFNn2BStPrq00wmFGJVyfvvAwFUKN9C7BukTfKRF47WuGMNMlsW5iRs4 +SXp7k8XTSo32EFdRf8Kp/qHoU94c+NjyqLGJoVSwJG/+QVN9NOVeIRhPzrFqNT0F +aXo+JJ6moTNup0Vt8Gl+nFfMv6dU/fxrJ0HBiVX2WEAB5pmOFQR0FdTTYjP/I83v +7buV/IKq6DPxXvM+om1E13XN3GveqfBRVlD6XD7/VYvpflbkIqEhduqPgd968Vww +P53Lxl79Zg1WHsB0NSxwyIt46txGGYtwhYB04aRIRd/OYfF59b7NXcAACeZAVcFj +BYZV+ktoyJCtW2pNxb0zt3QEuyelb/LMsU+X0opEk8GWTkC8cmSaqILYsqzSGx5E +7OM7EoKWVgh7f1lZiE5ch6C9O5pRujl4YHJ1bk8z1qvXDnQdh9dXWOfi0qn8HwB0 +025BxJKXqDofHsy6G0kJmbm7a2dDJu45aafOlf9BTyxwJgJW+BJOWBx9atbS+UT0 +DC8cO6xNR3OUWaxJLBd3P1xn+3vuFNIAhYdfPZSHpPDZm3NBsOOK4AnWdGL4wokC +HAQQAQoABgUCV1uYvQAKCRAtNH6mqmVCHff8EADBlei+g6byam1Ru9U/kDEfJ118 +DmAwi66bh7n+2VL5i4qyhVoJuHtp6aR7zzhm7ZS4bJDVDl4BecCqZgUvsF79cRsm +MRH1Ve3aho9b0MNkFTmqWIrRRJmkXJ/XrGo3A+XZPjGQprN463G3jdG/iySpMAiq +xZbFKM4581YRoCOg3XysNGVgBJ8fzGKiSrv8N9i2YpnFt/cekO/CbRo5U+BXC/xH +zTN2f7aFLN+gzM3RuLB5JYmpUjP6djmD0xWNEgGMGotF4cHUXHLlhZCcRFC5a6eG +YzFLtQtvYQ+ZBaYO15fXh9GjPDwD1qIQ6ml/lRQBoD/6VMtVzeawtzTYWvIpR5GO +nwpY0CilMcK9leZ0sSaUFO97p55EoMDWglsMXjrg9yUHouojtrWmS/hw+NPaYRwV +sugSXbFz6mPYzyW/lIY0jGjB0Bh+FPoBqS4/en2Ln7Hmh0MRx9AfAM8rLlJ/MrTN +In5WRRC8iMBUSyRAfn+d+U0UiaZ38vIqif9OlAlQyHznhHAacIhUHEf6naqS2Lkq +UWZ6wmhasJdXYfRUfVQiGodlephHpusS9bRVZXMy6eQbzdHQIU7OR5nZqTByZT0X +n+QyVEL9DHqun59y5ULdwOKYXMqAVqu66m7bSoFHuNgWO0WwQYn51go50dmz2QGR +gXVwuwNB565MVXypvokCHAQQAQIABgUCVt8E4QAKCRA1LGcgseO5K10sD/sEVRp8 +DEjHVjOtYEAkCSc5LRl4YZGFN5vd+xlSfgas6YdXGd0Ygw//Ltq7MRSLDrPZWSMP +xMBQ2oGyxK3QPENrk5WXtKqRjkjG2ysD0sZNJvEl1FAlVs5HFB8eZtzzPfEEAyjz +ZnbNOvB0YxNqNBPI/h1F+iv0SZLJqNYMtFl0s4ctq/AYJrrG+kbznaamWsqu1hzv +O6sbAVRAyg1OJBwr65mrc3K+MRcYE7OaWkQt8DHUbz5Znuf5o1hPv0afEiz+jfkT +p6X9TLv9cIT4+TKP3D/hK/EKox5wS2WK9Wm5mC0gB1qyNLLLOBYRLh9wlY66RqYQ +SpbrQc4Isyz38pGI2Ewd42109bRHdfWH1ZVSO53C60lrxS33CxrgEdeG8nlZ8Rcj +DaJkltS9dMTf/b4cGfovlcTzG37pEEf/CxIj6TxpYE2Tma5mUb/elzq3WCIo7lpH +hrw6/FRePjYMKfOHM1HOLJmCoNPVFpRLPkXYGAuMoE3+t57rCUs1L6vbWeTgir1H +j8oJqrohfm/QaBFpWTgmIQjg+6CE4GhR8WeZp2fBCD1ZUexo8Eii5pNJnDc6CGE3 +PiwKcuQyeSz06T2aWaYqpz1IEKX4+r7QTDpd2s1qTkbheDfXX12inayXnOPOqAAa +VKy7fp5XKgOreHxt4u23/onsmsMURdeWvNMyu4kCHAQQAQgABgUCV1MZzgAKCRAJ +SwnQndU0bVPrD/99j+LPGS8M8/KFnMqbF+9R5yhYhVODocUriRp7OwIWQKCGL8F8 +hZRPqqh7lacs0/HB3Na0cxsanUOySRMIWEspK5S/Hq1AZG6qbvLQnjtdozsI0k9A +R+h1sz6bJILDJetNrzHbzA1YKlf7j/cpclcBrZ4MPpKRUqPSphkVRXqU3meW/qpK +keVLKeSWDCvoY8ObMmIg7UlBHPEkGf2vL5au+6pxYtQq+qxaCqM+6SssxIWXB8RB +gsLCnSeC7mAyKXt9gpX3iyGu/QSryGlN/vbxA8fUvIQquzeTq3sNwWwmBVxyzTxQ +mBTd1X9QQ5Fbfg+8CoeAeV2dHMVwVYV0eblTrfNOwRtOCxH8YQW30deWs0tPPagr +mFk9QQDn/VWmIjYaaBvygpHERo01hCqGRGkFiZTBQb/Qqe2ii8WkB2XIOmv4yosI +PPaLERaNLw8goV9jzla04b8bqDaMcc6B4ei4ByvodfOOHpIcAMH7HMKfUQJHH8+9 +YY6f0i1Ux3+c+4GtFPbK2mvFcW6QERctyJ1+MgHJpavxGrjFNjkHEYinVjerby9a +cSpU7evSv6nQtZmFEoq9fdK2C44PX10Rteg//c1TWBXSb4BP6RtdlHBI3BqsXI+K +SVNeJ0H+PLJrTOzu2SAdukkQKIzNfmzDQ7Al3u22SAGhxR3hiqgXpuadjYkCHAQQ +AQgABgUCV1MazgAKCRDAD74tkhkniFRfEADKZ/RMudpdOkxRfrSuA6BG2Yp7QTWz +1WlpWHR+iF9Pe47klv0vnV9NDZ7Xn8OUTpTeuYFq0SCAvqpIGeVeEDfqWXbu7w1J +SBFgVS9XI8qJYixr3Hg3OTNChNOaZBsVKSISXVknaHWJbiVaLwBTZC4wQU9bLS1p +ksCyMDpcJTbSByQ4EI0i5fiwgiU+ln2EAnFWrTRPGBYlf2FEsscgERUVRit956bx +jYBp+FoEdbkb2F6SF3dN3tFvv5a0MaVRs0jHIZffMTx3lWr+BlZugOdp+CObBU7W +z3Hg4kIWA/mDHiKEH+v37PuzSAdi+5qD1a1ixgT2Vr3fxDs8wuEoQWcybSH8yao1 +q0HW3eiPzcuWCXe6ZLKERMG1F7oDyp1ttQ2sPLvywS+/lIB5YvJo/px62hI2Kvem +M9EPp8Xnukfpm4Kx+GWX1gEs2eytwneBiLpvXZsT1MHrMwwlxdjp8UrMLsWICufJ +6Jy8du5BmQwjuxHtiQk7e4FsMhw/LVJoS3zOQ6bmsxwbn7h/6o2yc5BCS19oLip2 +iTe1vFvB53H0zsJVPpSdHrpb8ppInnmhEKn2KBWjDI6JHDPqNG5zDo2EbcUI9mJQ +NEWAuWSZ6PZ9AP0+cZ46RWQ1lhQy+afpVIElghEiqXCx5trLGPfTIUaxejg6hlNk +9gwyIo9c5u55SYkCHAQQAQoABgUCVyN+cgAKCRCHVo8VYs1RMv10D/41Te12/2ze +1cafvqOk7wjRXiGJarj3ejh7QDvjiuNp5qTp1Zw3LkiqgSj6308PcDrnguH7pcAP +Js0EWH0ET938W6bhU/tsHcmGHh8PZcainAwpEXUwO4XlYteDBI/lYXP+r14CUbTk +H9mz0ojDM+QO/nu2TYRlQ+Xw6pnyLgblYsb3Ij+LS8Y693L50Jy3HSqXsi0Via8G +oYFWvjmQpfOyOqw7NeV6jZ+nvi58fKKsUrSsGt7z0ACldJhin8MX2eAQNdbR6Tv/ +qAn6/3ddYy+3QtQWZNbscdfVCGyrI+nVE6aqxx39vKetiYRTfozhSS6m1tpz/4Ot +goi32huLiUbC4uO3Hg2XN7FfFxlVj4unBXknybKfeK2n5AlfSF8uhZ+/BBCzq76V +3WduhtYbfhADAqnH3/TMjq/tNUEslpNip9wG0twsor4cQKHCtQzE86GfnxFjic2x +Y3/B9oaPdd2QlSvWzpbKKqSgulR61Ww5o9eLV9j5H6q938Vyc7sIdp8JHN0qVFtM +wuaZVtc55yxO8FmrJSzIkp5lEJg6NoJV1hCGYzZVUBg6xsD8S1EuYVADzw/5siEN +2OWnaC/rMi04mHs4kYwCjxhOtRZVlrdmpGzQjQNG5kvhXFMD/8LGVGdrC+fDzZQc +O3MkGIE2QxDCNOE2dqJGLB7Bj6CMFTpwVIkBHAQQAQgABgUCV4EerwAKCRC3i5CP +I0MPgFNSB/9G5tq70oVo+97jPRYhWktDZDoX3pmvBVtMSg14Efikn2f6JBMyZfZk +J7GVh19hRvcUADXIyFCU2w3/hyKkYojdnQhxNdHKO1z3tZbNf3fpUhwapxGXeugd +FfsI6y8ctR7xEy2GxswFDM/ocKRwXUin/Kx8RccFsn1Txw8Tlt0pQvT8/yf5ZlXC +bMs8l1qoqySlipaZtKRZZv8BY3CIqFWAd4ELyKu0NGSENZL2QhytBF+/PY6WLQ8H +PNL/kI4DCOz0PKEESLfw0sG+QL1Of7iMoMnDir/417xO14lXJMZSbVCyhTu8uy3j +ltno0Zt/b2SkKnSJueMBnUK5pp1Kv8S6iQIcBBABAgAGBQJX1kl1AAoJEAI8BeLJ +wGjw1c0P/R3Ywu++Dbx2GRSgF3jbxD8C6fSJvVnFTGfxyDnSmVLsu/2RR42m4aXL +1KpvVsHxrlJ2dsy1nSQsHnROisvyjE38o0Ln5vyK1eeeueBhrp+qYcy8Vk1PrwJs +Q3DPHkP4GO/d/euiIJdVtA3EcNKjEssOhpGk4JaLiz9A5EmcyuPJ2R2VND5MHNrV +XvRanng3sCJBQf3GfDnqF25VZqFGeUUXW11KqVzx/Manfv4cYrZ9U85FDbtPoXek +IRZhg4aiZ8/u74vCnH7OQsZ+aWehHMWQq1fL6Z9K4P+URbo/6U24EMxXdF3puwzD +qUgPlHLRN7ZI2ghMnaK0MH4w8DewL5S3MDTVMHlD/oSfSa6YQQbosP02bCRpWQ/e +iQe/Id0c+B56ktHwP0yFcXypjmULE2g3Y9FVdmB4DaSIdF9K1kBCXxSv0UxRUn+n +20cBez8Zd2d8yt3DPsNaKU/N4r/HtpqjE9mbzCuI+AO1Qoi5MAhm4x+7a8NMOofF +xGhLR6CFOafkwRT4sIG4R9pVc2Y+IwsmCtrllZp5hgZcCHGBFvPFBpj7gytE7tbA +c87QOpzj6YXhzTga3mxkYxrgcV/UtAq6+5EQ3bQvZOueQn9zCHuWueIgiYa7VG7m +P2rYDshS8HGyKoSjjO1gVHgeo4IRtmb3uvUA5/njxen5V3spOa3NiQIcBBABCAAG +BQJXaWDLAAoJEIs9hnyCPnphDJoQAJ0XvT/pHgo0rghcKqF9PyDafWLqzZSfm980 +5110l1fdL7zJB21N0MfNiQEECSE98SdXxYRaj/CBIAnpdkV6ZqpLMkmKDBQqAgTx +T8w9irFyhDsX4sxOU3YJKaVX+1+ITzs3nL/xXPL9xL0ZUR4mslNovOht7FUhklc7 +qohqkV761rWm5N3WLrMn6BAcdHucGRWrAJ774hDLiAt+Oqjxl/wxVVk6zNdc1sue +WmiE4mtEDa5gZreBKTs+1zoVsnItu0R0z2pFbr15Ndr4lMFOZkAN30sqvFmY4pWV +fxAnAty7dx7Sw/FavulESmqb9W9UfUDWnDx21PKgkBm++P1LBtb88M7nTem7N+Yh +jXplCQ6rh3VLz6rbv/pdSMlVJDpSeqIIe7lWxeuCxCs6whmo1G0CsN1dxpMVYI7E +ldZB8ke/cUDNHHDESCO0D2+1QGQk1KWheJ1Ai8tv71lLymdiJdpu9XrzOgibBSnj +uelnOgfYbDLL9TJZVkxtytkaqYj//L0JLWSg+1G4drLVeE6W9ZPckqUVW5+gU48Y +ATn5UlnKVIoWzNxQvV0oDMeRJxBbXPmeIrlZmp/tMHy5OaVA02qde1GPlBIdFfUy +IEAD5OhWwVaM2mjIuQ6dF92EeR0oH/NGPuHVTEH0rmL1zly7iutb21Nl5NARpHmM +UfKFmuvYiQIzBBABCAAdFiEEa0msutz2vRyiBmerzVT849lkvvsFAlki8Z8ACgkQ +zVT849lkvvuvUw/9FBpfsMMAVjYYDZTTX4geLtBXAb/fWyIeDH71NjA53ZlmQ3zX +igB6ju6is335MN3hRt2dwgQxJUS2PT6uvmMgjZ0i14Uw1sPyIMar6TgwDHw7WQ2x +dn65Kz/lqfAvNW4KPk7KF1MY3xU3I4slQ1K4rwkS+HehmQw6NJhm6NpbEu+jbTut +QKmVHI7YbkMO732Sbri+fGRt8934jkYMFUER/vlNzlxHn1VYrRr73enJofqaigg1 +9lzC9BjtScW5gL3I3Mi52KCkpFu02km72OExJfP5obv4hIbpAuVcotupzPpQIXbv +Lhw4+icq83l+v3LrXK6XKv6w1Ecyb8IlyDxy6mEsjSaq43HM2OFelbMU+0eKGwOJ +yns6JXCckcXa3I9SGJi2DfdC+gl+CrtfUt1yZmmYWOgr/xFdWChCtMlxS52p8pqr +j3dmaqD79E84z9lJpRUx1A5MpgOI5obvfeZvxRHZcvjIS93BtfNn0KHf56Pt5Jy4 +nBkdSo0PwRjfUZwcJxedyGc+7XXw3QwgZqzJsd3hktG8mUm5dBYk/jLi/l5+iUqR +CK0PYqef6vd/aA01rLmK1IWS75o1QNymcRc4mFv+7gU7RQ0AquyqcbQmmnain+mb +eWY6BB+lzbAtaCDu3aKasD63PiMihCKi80D/9v2aKv4NAhNnqoP6AYemBVm5Ag0E +Sgwg6hAIAKkAgN2nJQjSNFDwuh9S0aXUYk1gIBLDo26chWRXwlD7G6gE3rmm0E7g +RF19M2w9AvUHxQOV6Xqj1fuZU0wbJJcpaeYr7DNQnREU3KYkwBMk7Sw3ZiBdVc7Y +xPUp3xRAb0n49WP0wmXFbLZc8IqJW8Hv8qduVCWcsIyHwJ7GSAPCycnuBFs4DFkW +EbdAp8r0DmBFrMwpegITAdeNQ1RwE0PUJIwdY4BYC1WQSnbXc7gqkNYf+FOH2t4J +6cEXRtVpCZ4Oohl0kBGcn/F/7n/4H4BzmuQ5h+ctXZXgvqC0zCzt0XE6QEI3UqUp +qpR6LAs70TN2ePfL/oJFLRTFtQe9T2MAAwUIAJ/QRqcQv9PsKSDBElSuCFcvpIJ0 +7TfhuysrQlTRYjko4m5ZFZYfAbxQfpzh4krxOvkmTuuBqsHRsvxYToxtMbqYreGK +3UyoIebUCrjPl0VmOf4V6QOBKg94d7AEhwGfiofEcw6LfctNKO6PXz6qk1mUuF6H +GcV3A9EYq+WFhIEJCYbtHavHGWRQU/PwTZzx6RLxdeMyAJD6aFgnDd/XJNcgBEX9 +pXZ1QCLNAiRJIlpDnhaFM8xxTQ2HHZcVIfsLK2TTmyyjCyEEBPEf/pojx9PPt6ce +B2cVTcY82G/O/h36Kstvutsqb/8DyrSxusSXopMY4SqUGCYLErPgAO2e7xiJAh8E +GAEIAAkFAkoMIOoCGwwACgkQEm61Y6dLBr9bXA/+LUBB9+1RR1bDBlecbfw0vmw1 +t8Egkj1x8aPa/tlyz0LjjIwRU2FQKiqBLFU3j47GvlQcTcemjX0iNkssVJv5yosY +5i/KwpxjnwkaK4XheYTheG+cTQm1XT6N3pL9LVncBDtptYLFROnq3aZ3OckcqyLw +vt9ZCBnIzUkMebUdYwGiHjJYhoBjvy6N4zA9cHMESWcLjXeV8gh602SkrO8Q3Q0F +m+EA3JvFj++cfk3XE7RBqghrM5ANRCFm869Rq4GX+VVVFOeOLqpZaRQzv+vi4L6S +KATvb0RLl5S3xJv6DY+eV02g5/C1XLVM0tBCXuLC/BLFWzA+RLxbPI5nSJr+9Dm5 +iwYQWFAby7RrVOwRdCwVAST364/PnW1GcnWCHsDA9sA+vZ7QEV2BNrQmtB7eAuMp +BO+GLDH5IS9HQ+SP/M9y6FHjsH1bBFJ/qkPeEGqZQesEmzlnw7XiE+f8zoO4cQy5 ++8w0Xw8bgprc4co2JQKGzz+WxIg1n/klP5FlmFW1HX1KMwrZ1wDeckd1lT0ZMpe1 +UK9fhH5aR0unzryCV55BZfDfcYmKWy7KCdILAnA81/K1bMH9MhGtMOQgJROnLmI7 +uRo6HVRrat9MSb79Ua/4+gRT/0fwzOCpXDC8EMPpANDG4rscOxMpHUkNIipqVavZ +eI2JF/eQVERfa92fhLqZAaIEQ4UTphEEAOiJ+hPdsCdDyG6+fHStBMELxELZF0vJ +WS5uN4LjTTFjwhI55DCjToxLgaNoYznl4fghO8BBF6twAoJXyn1Ib4hJ1O3FbTMj +XmyUklIKyT2ZZSMJjMvxnNFLQh+xxUznHrnlHFN8j2dFo+6QCXBxl/1HWDU7ECy9 +bb2xq71dygk3AKC9T4aZ49xKScIwxbDEoIjnemTkeQP9H03tb6aGP9D7XlZm0+DQ +7dw9wSVa+ruMXSIKb7oDdaTYXz3SzG+5Muu11C16J3wateF0lJWkeKnnWIQm63kt +fMFlYIOiCyKXRbGrb4HSfzkmx2l3fiksFEw+OVpu2jSWM5TuyCeMQzXB7tBN4Ian +lzT6K2yCsu6/BPYTDTbQynID/0M0IHc3N/i4dtk9sztMo8idccq5nErrwdYojGU9 +mWr4KNyWfjmCurmPNOMAWQr5E3priO6weX63N5/BLcrmueF/ErwOdGm9PmHuG+7g +XnF9zCrT1F4goPOsN86TzdvoWZhNi+eRmeScQR3HovkupdValMM4rd2gtamQaJJI +x8LutCBCYXJyeSBBLiBXYXJzYXcgPGJhcnJ5QHdvb3oub3JnPohGBBARAgAGBQJF +4TQjAAoJEIfO9Njm8zLHkOUAoJNgozJBLT2R8U5OaX5truuTM+YIAKCFahf/Clsq +OJkZmfXJEiF+RARI84hGBBARAgAGBQJF4TdDAAoJEAPXxKdnkbFPBX4AoMreychX +XrAAK5FeOJlbDl77mXUCAKDeEPHe+vIHii6UjtygAusOhL1Ix4hGBBARAgAGBQJF +4TdDAAoJEAPXxKdnkbFPShYAoO18CiPpnGkruzwO3K0L4WHHr/bvAKDbMUah3k+9 +W4ZsOBPB5KuJI6PZVohGBBARAgAGBQJF4eYpAAoJEOBpv3JFQ9V3548AoJZ5+9T8 +Rqk3D/hIfBRpT4DScWHIAJsHh5pUBwLDopNGC/RfY8wgxRcq14hGBBARAgAGBQJF +4eYvAAoJEOBpv3JFQ9V3qJcAnRLicAm3klDfj5MVe/G3Fku3+GtsAJ9wlSLcNOAX +dJlH58cJCYSNtvebXIhGBBARAgAGBQJF4uXzAAoJEJE73F6LvXfwcgoAoKQda2RY +M75FFNv05nDl0ftG0Fv8AKCkkcs7MN8QXEJMHBHA5c32RZDjPIhGBBARAgAGBQJF +5FrIAAoJEBmvK1RHQhGNwLAAmwRIaVdAXzO2w/6Uakw3Usd0X6MzAJ9RQFlezFEg +4P19uqR+O1Q9fuj6FohGBBARAgAGBQJF5FraAAoJECJTsppmZDoMUosAnRjQr6Ps +YYTxQGZvJGwJ4rnhl1ddAJ9Jj6Ws8vnGrB1Tjt8Yx878vLjiaohGBBARAgAGBQJF +5F7SAAoJEL4mAZFR8ySWIgUAoJnzcJrPvuyatrIvM7xcprQzWK8cAJ9CRUwBaukX +dAdKrGjJDDv5R1JfVYhGBBARAgAGBQJG1z+zAAoJEBouN4pgjAESk+QAmgIHaP/b +w6d3q77Nwv0BHn6xgdXhAJ40W2aPncDjWEgf7+NW0aXhQR4tN4hGBBARAgAGBQJG +10DbAAoJEAGvk9mRz6NNga0An3behbbj4YkTslYynERi1GH/3UwPAJ9Rf71cCRDC +QYzGnp5S3ClNjtrHTYhGBBARAgAGBQJG10NGAAoJEMlQXDSKUQEt6xQAoJvCJwfS +o9k6UeQre1LRBJCWEaTFAKC8OZtCZo+DYa7nS3k/Cj2w0s2gYYhGBBARAgAGBQJG +10YKAAoJELvG/7mgIS/kB2gAoKuqldxMXPm/aRgAlhvOOVL5YDqsAKCKiNkSZ6eg +klx1O0k4dMzA3weOZIhGBBARAgAGBQJG12GHAAoJEKu/l9Kx4NBvfnEAoJ/Uv3Ud +21J8sQNewYimADl1WuC/AJ40BQGtB6NrCta9nuG1rx4pfIqir4hGBBARAgAGBQJH +erftAAoJECXXgQmEjQADS/YAnRMRh/MwPb1RpL+XB4aEhs3/la7vAKCmRG9p1HEZ +PuMWK5jGyNJC2QG15ohGBBARAgAGBQJH3sndAAoJEM4kmr9LDWE5BZcAoIU+IswG +WfOy8IKeC+vp+d2XxaMGAKC2GVij73QsY5O+HFUtvdsBCMfr2YhGBBARAgAGBQJH +3stPAAoJEH949IjaMUgNCB4AoJ4xX1nAxPwTd5snpsIl+o1SNwpiAJ0T7kp/h1FX +EnZfCjqjIkdKBu0/9YhGBBARAgAGBQJI/L/EAAoJECfZonv582BYa40AoKgiiQrM +yxVN0LUHzCACOXx22JW+AKDbBaNnGrEKsrXgI3jGhFtZxi6qrohGBBARAgAGBQJI +/MK1AAoJEEOs/5YjroXShLsAn2gCE1Ny6HSfBWVpGN42xTPD4Wv4AKCs5v2tMp6q +rhtLw+Hjt/eJEqd+iIhGBBARAgAGBQJI/MY7AAoJELcXLWlgf6xSAKAAnRjexQ/F +jeB0dY4MvtCwOXr+b5PaAJ9iBV/pDxMkxeDm/PxpKy6Ax8IBxohGBBARAgAGBQJI +/MY9AAoJECV52pGmWtdosIYAniiXiSwq7K6L+lAkWCUZaQgPZmrbAKCzEOruHU77 +hYB5cg8RqYRycZ2MiohGBBARAgAGBQJI/MgaAAoJECuOMUZBie0ny4wAniGxXKed +t3cRgVKIeuN26LkGgZ53AJ4s1Ze3MZ0dfed/NTtAO12Q6RLyhYhGBBARAgAGBQJI +/O+6AAoJEHNiZMU9t567+GgAn3cmU/U2wYX1cDR3sqOw5h/SPFGuAJoCn2ee2tRS +OIVqRyfX5p7YuNGfGYhGBBARAgAGBQJI/PHZAAoJEJ/yWD5oG2RpC60An0U+RbRX +aUguUXJcjFuUBM7c+hMyAKCTdAoHQ2WAwpl9rsScUzGBmkfAfYhGBBARAgAGBQJI +/Z41AAoJEIgkNeR2fla8wMQAn3W7rVJweAbVBa/LkU5rpgsMKhsuAKDsAgmGCPXv +672urPDE97aA5J4UX4hGBBARAgAGBQJI/knMAAoJEHdX7yOBu1kQXoQAnjUroe+A +5S22DJ5Q6LU6Gd9755//AJ0dstEewIiIoEY/7hwOn/L/Gzp+g4hGBBARAgAGBQJI +/4ZSAAoJEAH6mY+6xjdKD7IAn20pZ24Ub9b7uQOe6vWZZQCl7XPjAJ9/1YD9rOZv +9ONpRAy5wDR0arTAKYhGBBARAgAGBQJJAyctAAoJEFoRpUxfBvx3W7YAnRtbvu3A +2IhgTvoIkfu3cnxHEbloAJ94QFQmV/G9VJOyXMM+UXiygzScUIhGBBARAgAGBQJJ +BLgqAAoJEHpAT4ZvDa7QfL0AoI8Vlcuxb+4hyDSXqwR69vxzCdclAJ9HJGRQO/LL +8xSNqe2g+ddg1SvrB4hGBBARAgAGBQJJF5WaAAoJELi+6NyIBBRwZ+0An0e1y7tN +nAmBqSO/NUHR7ldMhXs9AJ9P8Z0Rg0g+MmpidtpnBNSRISU46IhGBBARAgAGBQJJ +Yy4gAAoJEF/tMT7TE6J8+iQAoNkGi+W9ef4mIjqQ2lzcueFIzI+6AJ9nRZl14Jy/ ++dG5mySsu6SCZHC/V4hGBBARAgAGBQJKocSzAAoJEJnN6p2kE1s4pq4Anjwm4BWh +uX6gZiXYhrMWF0LP/Jx+AJwPRIX92BbeOkdROqfeUMebepDYm4hGBBARAgAGBQJL +XkprAAoJEFI+FDdIyMYJqAIAn2EwkDzOpLJIK+IZTGONM+TvsBz+AJ945+6sdhsy +AdglCBHaEPtQFCntGIhGBBARAgAGBQJMs3tIAAoJEFVbl16VO4aTD8YAoJErF3ZG +wZ2xxUpXne925K2Yw320AKDh3o+wX26taliLjPhlTaFZdHjI/ohGBBIRAgAGBQJF +47raAAoJEE4u896cRh7z0/AAnRlGJ3yl/xnWYi8U5321jHlcKzgoAKCkEl4X/lkt +c9TFeypAARuWgWbRa4hGBBIRAgAGBQJF47r7AAoJEHvEYCkpFp12mKMAn1ZiPzgi +69DWnMHXskeuFsQiYCsBAJ9UB89w2HtibvpY8WF+oyO95F8Aw4heBBARCAAGBQJL +3EkmAAoJEPrvEpNt0+PsU4gBALgUzIfJkNtN3Z3sTNFgPcxKSEUOOjv7CgjsO799 +NLmLAP9IIG5uevhX8quslgC1aqmHhDyyCSOzxp6m82UcNxoTM4hgBBMRAgAgBQJD +hROmAhsDBgsJCAcDAgQVAggDBBYCAwECHgECF4AACgkQ2YZpQepbvXE63wCeLnJn +hc2j28DiicbXTft6Kid4CGsAni8ZeYhNNUtM8m3aZpxSuXDD2l1YiGEEExECACEC +GwMCHgECF4AFAkoLbOQFCwkIBwMFFQoJCAsFFgIDAQAACgkQ2YZpQepbvXHVDgCf +Tyx8+YkQ5I1+dbTuU1q5s/G0VcQAn3rmZ/rF23Q/OwJBpPd4CnF+0PeniKMEEAEC +AA0FAkOFFE4CBwADBQJ4AAoJEHEjvBPtnXfV+TUEAKCy5umb3R+j+MivlKozQykH +3Vtjdvx04IXJfNe5nhpmnAxt3sO0YG66G/jEgOl6aLWvhgko6dDdLzmYNfL6EUAH +e/4D4Q2x/EwE8/ZCXk1iQbsJvN5e7VOQpzplUO+iDrcpBAP5o//hw4bpjO0O9O18 +owM0Q5c6FaP5zFFCA5AQiQEcBBABAgAGBQJN0WUtAAoJEKax8/DmtfWjJ2IIAKfI +Jg/MEYOd3zRQ0VOrnTzozwrlhS0KD+tEg1mL1RysZqVQNJrruD5ph4PkAlunCKIq +gRP1SQP6fOPQZPrMPE+JlBPw5xhBQu7z0y04SXYIULMyXfKx7f4AMun3S2xiv4Q5 +8nl3J+toMzJ4p7dcdsbybYbdlRrcnR5lSxmdOp/oHKOJQiw02SpnsFOkbgjb6Whj +6MPOJk9ZczchyahyvOzV4nmZ1nv+l4O2AA7qVzblK5WUHbuY6Ov6FvvsOfxQJiKQ +5rw/tf2xD2BHW7JTPUu3pwCkK0yIgCaK2ie6Tw+0Z5P9M1G8CQaSQmXzR395dZH+ +iJfnpH5D+IsY04kym6mJAhwEEAECAAYFAk3M6vYACgkQuN+3G1/svZIPSBAAneiz +hPWJqARo1wzDBmVs7bKYyr0NCXPQ5zzsA22NAPQMqHi99+8LfYPeMU/r92+wrmEj +sf/3rGDXnLDD4kadCoe4+LhvL+70AdObZZp+euf4xZhHHuf6hRGm0nRhi5S82KVq +uMYIVr1vWKAc8RXGcK4LlgwTW/96hyaOj+X0+2uP0mEn4DYk2+37waePgaseP4OR +EV0LgKQSBB+IBisKxPBjQrFjVMmEpTI9tcR52VhT8VB434E4ArymULUn/ddKCtH4 +71Qd2o8jzFSre9vZSiMCf77u38zgx1hrSaC7dp+sW1Q0YfX2iOIKf5tbTzisjRQo +/GX46cT6+y2wL6uR1y0eNxe5l/3uN6xkKfKGS9X0yDObY2ZCYffqgndbuc+jlV4s +0bXr7obRTo8Mlr9cJwi1xZHKcNBWTN1kB+L6t9YPcni2CGUnRMhug6+8svWc5sHi +j/Cmcb6c5CpuwCvbWpngz16eyPgl+FOzoOcFnBUoJq2o7gsvX1C95v4HSGXtl/Zt +4K+o99GQ22epkUluxEwZoitWn+XnjIua4Nj8mxIIfNtPvcd8S7ZTxEwLGZBqtRGZ +Hl1RVi2XRF/8KlTX47d2uDLx3uY+U/LogBBpA61GedHX4MkhhqG6HwriO1LgYgCq +4EC9TfB19EPIpOvyvAYJPYDGj9vFQkTh+qNkJKuJAhwEEAECAAYFAk3M8SAACgkQ +4ZcBJna5tzldig//VtQM7FgKr0ATmh1EAsuhynGGawBzhvYejMjeqGWpcsRS/hfl +r/hJhUYwvi8q1exHO7oK2mi792AfKVlnb768lKYeODRm47nWdtFcEjOWpGBJI1uX +TYNsI46ChAbbzAtJ/yyiRi3ghCFUSoA3uQz+AdUq7UDw2uY7+kBm6t9mrZtJlaYu +LhYx4m4S3pvonu9CLaKnp/Nnit1HFQkJuNl8MBY90fVureq/cvczyI23o+puO6Hy +ZRaSmRhiI0P10xn4hnIPCizdnOD+4i3unCuyj6Oha/zTsAgJxsxP9SRxDJ0fTx6u +GSUUVINq9DfreFpOUTEsq0P9A/n7zRt3Rko+9Ze8h6qJg/uRj8YT1/n1/LmE/iKP +Wf4/8VBAb8MuTRrHLeQ/1P87VA20Y6pM0xeWwoP7FBRTp8PcNxVnHG8/wJIW+YDQ +Dbfhe/jfT3yN4eAN8DoiPIgvpMufLmn0M48wagEMmfGF0YZW6wAJoAFToB3stvBN +YWzqtHOnpQCIcIEDdGKTAb7uAxCJgbLyzY0SmBvGTlXRzUqrUmeTeDlr8mSVRd0L +3OBfr60w3DuG9cL7Fns2MUn6gkItqNlo/sAY6e1QoQDYChuVF6xGGMMGQYmZQk6X +gT5nJ7GruzRGDRePeC/Z1xjmon3eMhceC9wuporfDS3M0LfMSFFSOaRUzd+JAhwE +EAECAAYFAk3NMkEACgkQhlYfRSGA/P5dBg//XogQBD+czXpgeqGZSud+OqkncbHA +sBTtOQekz3iDUsNZ8VmSqrYmKbuqgmYSGIwPqU4ouR7Nu/zGh0q5/+fkNhgK7aXB +pMftWOswDDOG10BDJ356mZY/QDeWqnyv2Aji1Loquu4E/sf8fB7n95ll0cnlOM34 +TeN23tvxuN5gMjgOarZkczBr+g2Gb003GTTu0XQeYZmqKxJvdmZCHcF53bifrXTg +/JYg+uexxzWukFnvCsWPHwm/Ws3cU3WE0/6nhqdSvBkS9WEMygbaB/3V+mUBeztz +znM+2vKI+SzxHdnOxmzOMCZuPQargt37HSPWn1zJNpYiJfTsYOcxNTJcMhqJKeIm +o0EOTwMNIPg0+mMKFgq1WHdvTnYQywX/tYxQUSgjQWFQwAwCUVjQHxoUAzseNOr6 +6ByXyTdZhjuOoRqR5L8JCFRilC3lKo/isV0RmPfwvyhV4tvuVd5Lqu1d0QMgx/zp +ysB8rR/E1mgCOYb20UzOIEruACYOQrKg/EMeleGf1ONXBjgRYaqUN5wXBg7UgmqS +ZcTnHKNObs6EXF+4RPWPs7lqcJaBgwrTTmedUtqlefHkqpJou1MNOrG89pbuQhlB +51c9B1cawysMNcuqqf1qRbvW2rv/epGNTK2OSI/d7oYbsdGB1cMpiaTGKRQVtIJ7 +GXcF+ncUck4jvSiJAhwEEAECAAYFAk3NXPoACgkQRdd+njDLGxGZ5A/+N7m9cyg9 +3YEvWkZbpfGPD6ldxKdGFeTIrp89FrxQq7+pcXX8mlt/8WH6Bgyjuk+aDoXbQcVI +KM/tjmm9w8aE/MOpk5FqmDAKztQvt177ME7o6IGLwsJxWmqqpAz+380U7I2blx7+ +rakAKs+Tqi/VqQa7qF59ySX6jwDmMk8G7Fr2t39HE/IK9i2DX29ENTZTqfRY5eor +OpVa4DofIEEc/qHeYfpUNchSfuse9/Gspif5nrO653GG6a35zJGlHg6+jAD4ZcPk +jAsttDgHUNMUUyl8CVrFu5bW4HXBnN0I5wnXlbT23Cs4q9qcTI93/aIwRZQrJlTA +Wjf8sGSrIqFp6UXpuXSXWQWl0jMSEr84p0h8gNsuuBjVfRVjTVTXxf2W0Bl795ww +iX8dWOgJ85zEuCthx50fMPstVcvHVgwVwKY4NLhWa6ocLxwBTQphbX6AKerTED5l +FtZ+/rpVqWBTSaQUFy7HiXIiicF4+UZX1Eykeon+5kjXWjRPeHKOkYr5OjbDUGA9 +K3hUKbw+HGLyHYrVG1O/6fjZHSSMIqKwBXAxaxHLF/nk3a/tLfXfKS30JLHjlKIx +BLlLleZP380UqSSmg84pGQDEtIQhgtfgsj4I5rFEOY5BSjQ+rbbAdkUahP+K/uO4 +iLWcEvXjcretFoLCfrR4lGY3DBSstiKDX16JAhwEEAECAAYFAk3O/yIACgkQYAQm +oRj1+84RNBAAxL06WgJ6wy0SCRVITeR0ArJXI+pT+cJMG+Mf5OfDtoBURxibsUqY +SBVohTXMJNAf5Scdbjp642T4C/zALSC4bdFv/uzg4DToZFcIJxVptOM7F2A017W6 ++uqAg7eqyjO7LuAOSewBY0ggobqFp260CMDS1iaIfwLqwlVS8HT3LyUIK/zXlcMs +6Bz6yPrl4uGhfA4YaunW58YUjC2EYQV4qQtjtDyzqWZ5IxHvFpb5nspUSVEmYuFn +IYN0DR0v+fNZb7zQ1aTks/YfsBEYUmyWPXFC42VRw76yKsj5EZlcmhW7nz/LQr2B +jFFg/2VBSv65HiPwrCFMQTFQJRsICwnAJsb7G2xbuTw9UpUpoG0IhZKFpXeoCgBh +ut7352+5P789sv5yMsIp76ygweJSbZKxNAiiY9XGjJcBXvwiEdgdWqovFaBnRXpK +ceErduyRNJHeP/e9Le+Odmd9yMLHFZXt1NLZ1B2TqUk675K9qtNCJqIR8rBM6FqZ +e9Y1JJ04kDdLEhvHlZpACgNDOye+dwSM0i+hMALmtdkT+/geYJbLs5lwni4Oq4u9 +jlejhQXvXeizFMpxF9QfM52wsUDISUaPCIo9tJbi5CBR3bK/Han4M9nd7GkRnxzL +8asznGy1cKjm0tY44SuPCvPM7PvwO7ezq+9OEtXexvAIDsXqjVUtpJiJAhwEEAEC +AAYFAk3RdQoACgkQxjiXTWR5LWfF5g/+KQmEai0o8RMLdL+n9WWlL00LGW9b38Y6 +/CRr1ZygupMn7ayoeEq4nOfJDkS2oiRL6GyAbhCIyn5Jx1KUn9F/4w5BRmuOZLE5 +8SzKUNpKnCY8HujbOoNASSknQMsdZbNSKnfYea9f9F03iVxRJ5TFOPKumAC+js9i +QQqAOFzb23u8fgZZ0ictGAy2T2uNCPLJvvyjgEeWd2XIVbpUdd6BSt8mJO7bfQRC +a1sR0RmQ4hZ5Bda58Y6ymlDEntdPNF8CGHm/t4aAOWJMnsjKTwr77ARwGBQ++m23 +qoBMMNTM7CJKieNQhERaltI9iezVPVd7Zn4PZTZp8EqxawWWU6U3M5UyB2QetJwB +rTApVGsprdALm6EZ1y0oRAq6p/ryEPJTL9E21I+xhW77GwCOKwnrLsWbjfTW7Mwy +i6qdB2Ac+E6IRr8EZuuhNjD82lkppnEkrYhsj3AwifAPHD5F+6JZCkhwtMkevYjm +1af8JaHIVhM5fcmqOLfTLPHercHD00MNK3wgzwckUo9pAhUeG36Ri5AtnJME/1Lk +/N/goo6lz7k9YEr0gD8/+C/696+z84BSBPZ+DoTdYqTXCvqWU+bk1Ns48mtXog3M +88O4NHtGsXMTK5uYv8qq1i1b/f2itZfl8dbxoGuV5wFLkXcFbD+jb4/L+Rn1ID+c +msAylvgEThmJAhwEEAECAAYFAk3R5qcACgkQwSYz4e4BjJPx6w//Wfpk/fogqjDB +CdicF2UJ9xmv2u1dmpzWBzAJQ5wobvLaXLqaZ0tSdsmEY5MCMZ4N0u8xoi/s8qVl +Wv04jc8kei1aK1CAdr5LDmZONajZW+gAaC5Lc7WF3yzAfhs8+ylA8du7UMflKro0 +yC0HorZxeCCS81Z+bKx9jHvpWfG511V0W3mrGTqBVfP0gj89EbmPC+Y1ffW6YinC +75Nzq3FWG70Ema0op+KibdcE8K+rK2dJxkLYQOMXxxm4CXeN+E9APmy35vbdZVoY +WNgQSPl8mGaIHechnuXX8/e8q5FVKIzbjXnH6Y45UmY/EqC59xzezoG08UieZANy +h/hKcWPkeLVkqUUpcbYFYrdMjaJnZEeyfTZ5lUVC3tAvWp+R0o0fByNWwKtvKq3U +tMbxeS4tMoN41XLJKn/iu/1KL3l43r+JchxUEP6A5q8RFlGPJw77FedvmdKMjE74 +Ol5XvJJhtKWwg1pS6cb6g7nruvvp/6HcpQRxoMOBJ7e40hZl0WphPvcYlSJrEdPY +M19OMqJMXK4nOaNLeY4zJBDLKcTcTiU4rvuTb2M9XAvhOVJj67Xrm/dOz/bvsXjM +LKuywrFTLiaoQdiQ04UwKFRzBEGc1dErKZx27GrYIR2H40qzIwH1BhlPupLU2AmS +dLfoaxJFWnA8dEcGhOPwFqN7HjRNyESJAhwEEAECAAYFAk3UELAACgkQ41LVxRxQ +QdRYoQ//ZH3ktwwtnNLjqYPK/5XNb821xX1GDkBYxb8LI7pbNuNxZxiAGzbXxMYn +Ac0fBASfeeaMsUsLaR9nfASWlOvVpm4wvBb4kyj//XFbkiTyrpflh3Bu3EEmvNrX +CLhuGms7na3T7K896UqcH6TGO6EDuWJzli0YfbJa2N5pFfHkIucWnjJ3vVlaQv8r +LmlT3AkpWetJlqhuX09ijUQJkK/m0HNmwVZYRdv8pmQJM8oB3xIIcVuWghJWX8wT +qaSXIsSgsGOJYTuli/tQRPD8jwNkPVfoEwouzzI9Rt5rQzfEMdIfaxeQZRK/KWvk +6Uyil+Hheuo8+1m6tAoM/pbt/3mILv5ynf8eYxAqrBkOdQz17htg0xrkJ5gO8hna +YCI7zTUYyPEZ4la1kcuI7vhgwe/8As3nbBM+OdgJ2IOMsGb8wrB5Y3TLssSegMge +xN1be6rFvjypBf4jifdlOKinfqsZSLAWbTcUnxDBCkzo9oYlfrpGZYp181RPZELl +J+kuQz2WxHKvXJaWqYAQ73KQI8FT2SoRqo/4RGZay5jh4Ul/hVX7yQEUHM+NVT/f +DrH/Ki0s9xXNFBiEYHTvqAX/mqC5lMVkp/Qabt1Ol9iQkLpjn5sd4+Wh3JsVbWrW +e9EWTZ/FmDa8Qdfsg0o2dd79kGGwM44tCWV1Ke1vJkK2fHDtFJSJAhwEEAEIAAYF +AkoZpyMACgkQIZ9rYLK7/Pzn3BAAr70qHoumZJJqalQNDAjm03SHtJheKR4J5H87 +XUbvvEiIfFeBq7jZBW8NIGXQONaLO0PA6bIAH/WT5ah+T4CWYbnU/08ssnfJ+i1D +h8dqXqtVI89WBeYrWVnEYJ4RqW8iEXmr15F/KJclUU2zqQyLUmy6z4imAQ7nFTL1 +znFsifsCOuNssrNXkLJNyBIY33fo1jKwz8k3YcbkYSsUYarPPkZAqpQ6PjK3YGhX +VMAzaGW1JGZ5z5JaK80+5yehL5ylyDFMaqgsaGOVxikJAudlikyVmW2PxDBCTKHc +8KwwStII+RhX9YL1wOX9M3Iah2U5gHv1zlrEP1MV1FDIxayZ4U7uuyAF35xa2ugD +X+mojal8lR+TFhQUOE9B5eTuWGjAeQzA+CI61rl2pYbEuy1EJeO3+xXPr2LUmR8+ +4n+BuLFCMrgma3ilC4cka4OTuCS/lcKZsxvOulZCOPCxcAwAju5ThcIrmV+znC6l +UuR1TTWi0YVjEbhKidrSgPF/Qo8aTAS3BzgSHf3Ug0fgpyGZqVLSu2fabSglKvDX +avzuSulJEWUK1fNFWUYY7t8or1J/5kRpd8bNu0X/jrD/GzWd0+/FR24imlqq0/nq +72OuK4SCUoXdkwWV6cAOohcbzPWLn33szB92c/ygfrKlkxamxqHl4OXqfT51BXd0 +/fLjmEaJAhwEEAEIAAYFAk3NKTQACgkQGLP1D+WSPBgp2w/9EaYCi5BEnnRXhFyY +OGpAK6ZHA3gXhgtzUyoebnqrXiZ4VnZ4SQE9+6ryvDm5f7IpqAxxx6xscw3I2ANu +wxQJ5htXFjoY8VpSJcjIffH7tQcGrmt8vPD2OiuyAG3j3HNHOL1ekYCABkJFccWf +5+43wl7o0FE8PJy3dtFLZnu7dBz+dqKdX2ns/PqOxE8p14pN+qMDEtj1NkXglTEm +lA4md42JP0dZWIy/xU8I0z8EuTj7NvgsKMl7mlCh9dAm7PP5/mEg73xTTSgU1eC9 +yG9FrDGbXHXAHtAv4onMW1J3zyRrIVuxmwh+g4VhkELjV7vVn8TM85mB4gSyFjrm +Wkft+XWRznZFQoOvroa9zlYewFGiZzSMF8EnmQAEOqdB5VjVQg76lnFEjJnj8epC +HNeLnLHocqVCUntc17czngbxTLy1s1rblwkY0PwLfjSlxHN8YUepbbQmLtr+7fOq +Tmr4dHa8HeJDlpqijSPZiaokheTV++fOpUhRgb8gNzQpMNnUaral00qD0Ugz4R5B +xBi4CwyKHUfVmtl+RUYsrJywFwpHLAOCpocNf7E9IIc/LTXI2gabmw+x3VRBuq8q +bDD8SbUdi5oxA4KxpSygEd6RnLLyzC3dBJ1jzJAjWxjRYz3cb8qFhD/cbwLWdtNt +RSDUkSIpRmU0lnpW3vii95dL4IGJAhwEEAEKAAYFAk6yv3EACgkQrvbxoqdFdkVr +hBAAuwv1fkhzCBCcMkl1Hyuq42GXmKNyYmbZcKUctzjBRp3oFPlyoegmI4C6vsXZ +C56AypiPS++rbBBJcVXuAQTq+M3Zbe5+vE6ZtPcNpSBjgoMrMlx/vo0jPpyHdolJ +WbyReqDrsrKNCD/8gYmaxnO3Xns1G7ozvEcZxDC7iIvYokuIHMtEFweARYcGiPP0 +hVZrNn/dVYRrhSgF1Zzj2XUk4Laba145kEnUo/Wncbxag0J0jKNiytF72RQFqRr9 +9q/8+hY2XO6/fDLFYoDOMEQPH6fB+U9SZu51QcsFEVA4jfoqD2X4Z38pEWIBO0hV +krNnujq+NvvARoojmEAr1emky9+1U7k1fSzPFnw5yRmGO+HauYyEcMLm+Uf/iCmk +EtWn/uBINzIAwq2maAksnjs7yBj6Z9oM7k9eHSSl2dvKdtdc48c6rKa+hC61P03W +kaDgGlC03Y33WLS5WdqAgorDJMvAmfrh8XwlLdPj4inhrawLD+GLZ6kJ6pjEr+dG +SrZ35LU8L2at/dfwUyklhsLdvLM/ffF4auk6O6NnrXp0sjrYlf12R+/w2L2LdpIm +Et84VX1/gbJqs5U+MsEXQqQzrxB/bAzPISOxb4rycK/RC0WNGZCxpdgE1pwItGHm +qyB9grmI/a1x3C188KrGAbANC3AboCmmTFFcW+Y8pJIuJziJATMEEAEIAB0WIQRo +5891XxjDhpFZhAbsV/heFszY9gUCWkCUjAAKCRDsV/heFszY9qzkCACkF9fbmTDz +Y9XD9EnVdH14hVkrHTabtM1X6MPSNttbUjrvUpUY+84iip73FzsEdL1VdT+BnsFg +bQU9J/dKw4PczpeIuMG0CQpDuZvf8NnLu/MP0Ao12NX4nMdTmu1N1ClCSgY4pQip +Q419c49bttkphlWoU/aMuGN2forjJIPb2X3vGxqPFlRsKUh7qo09Ff1y8cAkDvfq +rSb5fMOsd0WtWFFMfnPRIM4UQZg//zSoclNhInNGFdUQPmCZt6VGjD85y9Esvpc2 +q1pDsVEwspAB1PlsM65SX5ox0IALquZ4mzH2kQ0Popuqzpot0narmp/e+ud5tTrT +OCaV/RbWPFTLtCFCYXJyeSBBLiBXYXJzYXcgPGJhcnJ5QHdhcnNhdy51cz6IRgQQ +EQIABgUCReEz4QAKCRCHzvTY5vMyx4TJAKDQT/UTqFyAQGGD/T2LyydELqT5mQCf +XbOWIIffvaz01cdHr3VCiqTyKa6IRgQQEQIABgUCReE3QwAKCRAD18SnZ5GxT0oW +AKDtfAoj6ZxpK7s8DtytC+Fhx6/27wCg2zFGod5PvVuGbDgTweSriSOj2VaIRgQQ +EQIABgUCReHmKQAKCRDgab9yRUPVd+ePAKCWefvU/EapNw/4SHwUaU+A0nFhyACb +B4eaVAcCw6KTRgv0X2PMIMUXKteIRgQQEQIABgUCReLl7QAKCRCRO9xei7138IR5 +AJ93XxoZbI4YbqrR+yhQShPNJ4ss0gCeLdgAIn44beBUgHOfUOCX1JhvqECIRgQQ +EQIABgUCReRavQAKCRAZrytUR0IRjb+uAJ431PWt97UAu0ypk/lHic1ENXt2nQCf +UOi/TmoFqaGmmr+bFZXeHSeY6JSIRgQQEQIABgUCReRa2AAKCRAiU7KaZmQ6DKYq +AKC9bE/mIPtpXnX8D5Cv4hzsDthcOQCeOVmIIjcLpe1AfK2oaB+Kuho7nYOIRgQQ +EQIABgUCReReygAKCRC+JgGRUfMkls6zAJ9jTv0PbvhLFx4iJ6t2ssWcRfiDBQCf +URolrr6fsJLI4Uf/FnlkkBEfH6WIRgQQEQIABgUCRtc/rwAKCRAaLjeKYIwBEpWc +AJ400ODmJKpEMVgm7pTYO1e8exz4xgCZARPncBqK7pxV7tY9b5IK/IhK2qiIRgQQ +EQIABgUCRtdA2AAKCRABr5PZkc+jTd9SAJ9Wy9iwz1S+kS8tYqjNkXPgdeCdmgCd +FYBVFfBS8D1Y+zLfxR7jL8lzfAeIRgQQEQIABgUCRtdDQwAKCRDJUFw0ilEBLdwP +AJ0R5jRjqk/ls1mRWZk6UtTqvTo3QACcCWpgv+pLdxSs50G/zzmeVPAHtOOIRgQQ +EQIABgUCRtdGBwAKCRC7xv+5oCEv5KGyAJ9HxbLaWSgj2xLmyubUNgbUQWlTbwCd +H6MvwC/qz6awRWtFzziCJxE1ILGIRgQQEQIABgUCRtdhggAKCRCrv5fSseDQb+oW +AJ46eiySEyUyjp63dFbRJ4TDBCexCwCgl5CjpBYAJu52Z2bMN4zJ6/xhYKqIRgQQ +EQIABgUCR3q36AAKCRAl14EJhI0AA7LEAKDJo5jNc+7gjMwz04TCy5KM0aZO/wCg +h53AwjejhCzXR4TOFfI1S+t/ehiIRgQQEQIABgUCR6kT1QAKCRDTeUSLtBvVGA8r +AJ95K4uJIHhKoa2S1L8+Kejygk9ngACffN0wvokY/n7GonmDRIx+bFzADxSIRgQQ +EQIABgUCR97J1gAKCRDOJJq/Sw1hOfn8AJ9QUdMvQcMOU7BfJGdHBnQr+7OJyACf +RKSnTX34qRfYDbTNTKY9MMZpyJeIRgQQEQIABgUCR97LTwAKCRB/ePSI2jFIDZXn +AJ9NgQVIxQAjcgZ7clj3v4XYtz+OIACfZtWS6N3HF70YN3zkVyRAXHbjMS6IRgQQ +EQIABgUCSPy/xAAKCRAn2aJ7+fNgWOjoAKDNQ2vkH71yOTkIFUcqXqpTKPAk1wCf +ZKFk/Z0MNEiWURgvmXaBWJW+tn2IRgQQEQIABgUCSPzCswAKCRBDrP+WI66F0sjK +AJ9CU62I7kNSxeMmcihaSXzCOB3FtgCgwFH/qcxVqRlya8ZoO7LhoMd61YCIRgQQ +EQIABgUCSPzGOwAKCRC3Fy1pYH+sUl3sAJ4+YO2SYhrOqxUGAFjU8fI9gBgIOgCe +ICetv9iqurqEviY6E3fxcTNpxd6IRgQQEQIABgUCSPzGPQAKCRAledqRplrXaPL0 +AJ9/49W4NMfOt9MonUvzY6nEWeC9BACfa+BpuQeNgnkwi2FKnRKI+TMrXryIRgQQ +EQIABgUCSPzIGgAKCRArjjFGQYntJ7TfAJwJMB9SAGCYl0/feB4LONNi5g9e4gCf +bzpn+PUpn11PBXqk4AqykFpDq/WIRgQQEQIABgUCSPzvugAKCRBzYmTFPbeeu+XT +AJsEIwV61D5/X5x1F5crOSytYUrp6QCeJAQEHu4fnHwX3GHyWZeI4taaA/WIRgQQ +EQIABgUCSPzx1gAKCRCf8lg+aBtkaYv3AKCQshXlx9Q20xnWgzDdr0LPg/rs/gCg +g77y1mkvfsAbGBIW+DB9+rg1MyGIRgQQEQIABgUCSPz56AAKCRCcaVNGVyEyfQ+K +AKCzpF1XXFi01x53vLQEYKw5rOQkkQCfeUEMetyZVusgjXhyhUVdEK8O+MyIRgQQ +EQIABgUCSP2eLAAKCRCIJDXkdn5WvJdLAJwMnP8XJwnM2pn3h47DrFa4hH75XgCf +SmetFbLGKwanA9A8xYgXJEXz5SSIRgQQEQIABgUCSP5JyQAKCRB3V+8jgbtZEDyP +AKC/rWzVcdSMhNDUWL/GSLgxjLNZywCgnGH+usDxt5P3cf4E0miObctE54CIRgQQ +EQIABgUCSP+GTAAKCRAB+pmPusY3SpLqAKCGTJUHatf8qMvZOkx7WwI1xWbaVQCf +QE8V7K6NOyOjlWYvixkUtUO25rGIRgQQEQIABgUCSQD64AAKCRBLJoToTp2qpG/k +AKClqN66g1h3wkrZK7R8vnCHxZ3edwCeOIniiBAQkofOYUfjzOre1/jdmSOIRgQQ +EQIABgUCSQMnLQAKCRBaEaVMXwb8d3S2AKCWrdT4pqBovKWfWW+l6eo9gQwQuACg +ikR5iX+NaQaXcJY/B/aPZz3AXYeIRgQQEQIABgUCSQS4EwAKCRB6QE+Gbw2u0Nly +AKCWWOL0A9TQob+3O9Oh0RHHyrNQ8QCgu2faYA0x6h2Ltv6mk3k2Iu4qMhKIRgQQ +EQIABgUCSReVmgAKCRC4vujciAQUcGmCAJ9uoXAfVW40BB1S8v047+XI4vrP8ACf +Uqbgqw55U+wV/NKaV4impWFsfiyIRgQQEQIABgUCSWMuIAAKCRBf7TE+0xOifKtr +AJ90d+whhwhX9wGQN/+ZNQLAMtQxgQCgproMOUwvmDdiJlSIs7z22vWMoxiIRgQQ +EQIABgUCSqHEsAAKCRCZzeqdpBNbOAg/AJ9zsljK+MXwe+s30Yu27aFKc/TN3ACg +rAjxIHLUj2knOxGdOni1dJUCV8SIRgQQEQIABgUCS15KawAKCRBSPhQ3SMjGCTPZ +AJ4nkL/hdCwW+QDdPPgK9QTOIvct/gCfZFYv67XTfrzPgmnlRkLztZcG6eiIRgQQ +EQIABgUCTLN7SAAKCRBVW5delTuGk1OzAKCgRiJrxrcPdfRzrYJMfJbnRBQADgCg +u4DrwZ7Z+BOuP2N+tqDvhO13/2mIRgQQEQIABgUCTPZjVAAKCRB3c2uh19nd+4pg +AKCW4TcssOmj6CnlBSpuE1N8+zkkXACgm+GtNlmhJhuLxQecaCB1V1s9uQqIRgQS +EQIABgUCReO61wAKCRBOLvPenEYe85tbAJ9RfKq/k6lNX7KJQ+1+aTngN68mdgCg +sERiGwslY1pns+Er5IWHDzzpKH+IRgQSEQIABgUCReO6+QAKCRB7xGApKRaddgqO +AJ0Zn0oMpeoDMHU/OPb/vbPKdEFOzACdERhJqZl6imAQ6oAk9xXxPTpK2oqIXgQQ +EQgABgUCS9xJJgAKCRD67xKTbdPj7HIkAPsET6BybogwMpeBOGkogsCIE9Z/A6Fk +Zy+8IGXDVDa63QD/RbelqhkMyC/QV6OFgWdgOaOMnuXVqH6sukOG+vC4RRqIYwQT +EQIAIwIbAwYLCQgHAwIEFQIIAwQWAgMBAh4BAheABQJDhRR3AhkBAAoJENmGaUHq +W71xUOwAoLHnkuRgau7ubG6C6naouZpznCwAAJ9MUDXyoLG++cn8kmSGymDpBlDf +NYhkBBMRAgAkAhsDAh4BAheAAhkBBQJKC2zXBQsJCAcDBRUKCQgLBRYCAwEAAAoJ +ENmGaUHqW71xOHoAn3KY7Jahj8U4dVEsSmzjj/ko2/S1AJ0esHrxw/qGRt1wGAWs +Rt5uUspFHoijBBABAgANBQJDhRRRAgcAAwUCeAAKCRBxI7wT7Z131YpEA/97j3j2 +hZ5ERxJUN5DSzToG1EKXbsN9cAPKw8Tq9p6o6gdT2+qa+gOoF8BJ8MycJ8pQBPlO +BEx/R1zi1+EnJh4KV8BU7NVniFyDNAfPbBevV7bZif5lv2MngcrKAQDhmc2TplkN +iycyvTf861wzD4+ruCxwTFYRgpwJLeRZ8M8I44kBHAQQAQIABgUCTdFlLQAKCRCm +sfPw5rX1o2HRCADOEWmfQc5hSG4usIoEUMzLghGZVmS1bcdP45Jy+Jvqet9tS8Rv +U8yN20D1OVqmHsEG9ApT+R4zNOh1ChTE4qGqxtaDKKV+/U7cYJsQTN98OaDOQpMl +dntsoBiKA04yNghfZWLMvY7fwo6OeyCDxDd7PJ0YOK6oR+60QuvL29ITA1+KQHKd +qOYOLE2ohes3aikdNzyWA/KqiRGg/h3kcZ5nzsD3lPa/CWGRjhNggB+fx06tVOAV +pzN4CVzqTjT3ronPK1oGF7S0ymb+RTKuyOIW0qe+lr+AKrCtciuVdv8V6vYwQfEf +hDfaEydhttu0sp9FsKT+Ngstqnd8FkwlCb4miQIcBBABAgAGBQJNzOr2AAoJELjf +txtf7L2SfGkP/AuZCMVosIUEhOnr6IbZvV16LGWd3VxAbmlBbOBHkwCT56aHwtb6 +ylPUcnoC0RxH9b7wM3miE4Dcx4/l1KcP2PCCENOXs79ODXJQLlLaCLzawNf5oeyc +hU/pqbm0+ijwrxxT9yMKKTSIbf3PSBNx0l294ZknAIe6A3DSfO6u1OOf4U88zs1C +HrNcy77I8WpF4ZcfsZ+M5EmnJxM/viX+iL/Abn8/CAudWo107C8p+mjuvnDzIWh/ +CdKlP9josVbaT6xiw98hlgTQV0mqEAUqtRG+kBh9n32ctjtsVAVtycIyhc3Rz6Wh +swnqACNQWIA6HiEJrQqC4DZzrvTDIA5TlG0OB1E2fxSJ0REJHENTshm7d7+ltTn7 +gW0APy+Wj7dZvH4OLl2jhbXN13d+O+XSgBMM0rTd+JQHb4JZ91L+QUROQRnGUiYG +/HuLKDVE17hqW04JeIJiQKzdFkVA/ccfnLLtglezmtQj90I+0wJECQSOROAEcVq9 +mZa/W6jc2yaz57n9pKNFFEbhGtRZekIwvr8bOlwXoPUs3l8STVrLAAymMK1dKSAq +RUYnI7gcM7kWQdKlzeyXF72V9EenK2Tc/QXENbLnAkBTK9BFIrEQUZUIh4wsIppk +Xyj7TvSPD8fUBzFWUXaZqitUDGHDkDPJZ2b5N1LooJREa2TF7TL8PEI6iQIcBBAB +AgAGBQJNzPEgAAoJEOGXASZ2ubc5NuAP/iY0TaZlEV8FU+FLTYrqhbTHk6OqpFix +cuKCQyZRxsvPTbOempbAkKDJ6LwT57/zSSflqACWTdKZHrUOBL9cEdjgDyH58nid +qsAMrV24lj7Pw0FLKTBDxrl9i2ylLcv9hzmytQf/KeODsap7oAKq585kakwEY7yY +P9fzbaXfRzjPotpxXTClz4hrVersZlWtsIQ3yMj5KPYqRidvglukj+6RiAffttk/ +vfdqLDrH6zx3yTpnEQIbshoeV8MW2QTDhyDRP8CImqAZYX5bltHwqEKFGjJ09URl +3q0jkXaq4xozDZCTmZ2Vl8KW1AFUJ3m55aMZKRQ5rDTBMUvimvnaEMktB+vZFkRw +RgY5D/Y47r0FTLOEtd+33Zzty7WTyNo8gl4/hKPIN+MaULUfjBbCQCOuU7W+YCzn +oXjSzvFwbvF9pc2sRhpYmTOBS5oeK3TZNBwLDtLRf8PhsVDCEJMFxHexS+8xha5b +meW15VaXSMR+pNt/xivNa2Rr3/3LvE+iyVlaP+5lT9pIFA9Z7rf2ZZiyQX4iNrrU +aUD1yj2YgmhoNG8OaGOcYoO/pem7ptmI7smTlIMqvnpq43KOYt4+uNvLOvva486e +jI/DNTTgJP7Yl9ZQHjYpwBhf/ww3bgL7MmKIHYU1tlLLHVvIY8aiwBHeNtoVU32i +W/sn6jkgi+driQIcBBABAgAGBQJNzTJBAAoJEIZWH0UhgPz+Kw4P/Ax22/206VKm +A/yKWsWipFIKEII0gFzLb80aifJAMCM7tK9INHkSEcpbCJaGU5rmZsvvLcxTqcfM +QaQEnE2Lcb5aQC54FDQDIMfiRC4puMcj8vilYTsDp9Y0LQ87Hi/tEGGJSbv7rzDG +uKOFKu9CKS5dJdG3dwm+upoHZy12EbCcZ6CV5d1sRlcWx/CZZN1lXKDh5ur8ulQv +K15BcgSvlbi56Ug6Ksy12d74788QTAJ9ETWnRlW19iDt13gL++WS/MjbQkEV8ay5 +q8CtM11xu29LPKYtp7MFyPbnvI/VjubhXbdd6C6csgL1I7MgT0+MjyZsl5xeI4tk +QWgeWvZ0bAt2gT9ZSCGRZcr7HeUHGjsz0E9JDohSDHB+hyoGz4W9eAqRKBJHPt2I +QzanDiHzJRdAcNLPdS3qNXvhqXpbspfcQdi3VE9HVMICd9sZ6xTN2YBd5Ry2WU/6 +ips+DxC+5OxSck2ssxppT9dGRuiBfhbkEizaYDO9MwdMWSKMRZFvqg2O3lE+9Zjh +K2slu/eEHM3zzr5LmgviHfDnSy5To1Xvq+tJqKeZVLNgcy3basFkEaaEDlrywayV +ILYI3YrOqrfjlT8LlMfPA2UJjiLpOYufg+WTRVIaj3Tco0YChwCPVybbdpibBP+5 +piup9CgOhlLpqXEPsXdOziJHNW0GbFQPiQIcBBABAgAGBQJNzVz6AAoJEEXXfp4w +yxsRiTgP/jAKEOze1hEspzp4+/pIsB6aJs0pSJN3RC126m8vAD4wfgvkuh00Gd2e +SYur0SRYlskP4Hs1UPZ159gXW2S4Ro/mZdksLMQsAyk2mt+I5aCnRKY+vQQlT0I3 +PGX2JwntPkEbiagJmb/ChmHImSLeFxUoyjY+VxWsYObtSAkV/Q5qGZwnNwJsSIjD +Ox6tYQCa7aUkmKyRjtF4pO6qsobV1OOVtWF2vMamRPhc1lnsmehIh3XV7j1NVj9h +EgpdeFoVQ637H6mEfQuZFPvHvltcXxNSLSWDuOyu4KHuSGUAcOzYNyXNiBJIvNa0 +rc2TzUtv35Yo7e0ZTm4U/QZg8ls6CEMZuC8efip1EF5AE/mA6TtBpv+OzLGR6ffk +X9JEChszXHrD1NXIUo5Wf62K4kJTt00PdiiFrvIS76eMozLwbnrE9mu8h9im7Eg1 +BsKu+NXyiqucR5hPBjoT0V4oht2UDdVrMF4+j124d90wh0qYQiy4Iuyfermu9juT +b8kkGjACULLZNLZqTdbyr34nP0iBy0nt2LuPbde1NIJV+o4gEeooDn1o5GCqC4Gj +wzpaacU5QoOX+JPZGoCWJXBW9bygi3NKMZRgpUNy3tBpR2RvApyrmEYGp6DJ5Hak +zccD6jfLuj0rKQMX0W5WNdNd7NCZd1nkL4cZ3ws+LXHuUkdoc1tsiQIcBBABAgAG +BQJNzv8iAAoJEGAEJqEY9fvOaNUP/35CDk/9zYOjAYiN/JCm2iXgY234v9MFplNd +b20zdlsUnsINe/dB8Ldji/cggd+w5LvP5OMYQD2Yf3SHxMfzRBsBcpNr/uRiwtPj +0wMnCMPkThnulMys56wSFmtGPhMcyoYbYiKj0ofXRpwZARRG/2Sb/P4b1db+V6+E +doTrOB8M2QDMurauY/PdRHkL9UUYK9tPd0elj1w1PClgbKVq+dYH1rOn2Sf+q0pa +x8Mmuas0cZN41UNakJ8ST7iYr7zmgRBka1+hTKuwqTYm2YZN6PXIqWLTLslFBEFD +39ImgwxPVh904Qx1w+3bHWkSVYO6RXVnOdhAlU8dax4HNWDDbVJG8uO2gU+IUvGd +qxLlmCNrmugA9tVD78LzS3Jg8CgsR4CGuiO148q0s5qJfPGnPKf4g56ARxZdkD1f +rOVkqw8V18z2+b+LGYvyxhqWXvNQMzp4a65kEQM8c00531HHjL+C+IdDbXSK20cA +s7PK6eko+j0W6zjPJFOcCCgh6JnIttKSK2T7ORkE1cnNB+53BV64Rnu2o35mDlmu +xCjWpGTbj7L6zkODD2dvAlePwkc1K2T0eWYFIo0VyNSgPWMZlMRq+am5tVyknRF1 +GH0Zc5qZFSIJNoZidqFq3kWof9ExCNj6Z7FyRXTzG0ZzfHv537kvGf3ILBGcEKdA +QujM4PIUiQIcBBABAgAGBQJN0XUKAAoJEMY4l01keS1nKJgP/1NTFBCTulZc5BhA +I+OHMCpqyCKQ+/tKgTT59VM97ukS+c1q0rVoq05moUk/JNZjocxZaKssFG2EbbtT +caiXNJP/pYkTlYsn52KEODO3Si9LPQsDkdqIxAqdSPRJ+MZBUAGZxHMAtXGwpBr3 +mlqvGg21sWZ+aXlaXcEeqVYOidhgay05UkVaAvUqfsHEc0Ph/dW7/L0cZh5EetrM +3dVnqyGTU7Dt9wSRrBiBCI7gSbb2Lj/h6A1d3T0mVd7osgG4Ovh19c7HgoD5Lc25 +05re86bXpx3OTJvuVGbG2CHeqDWDFtH40zc4Lw9I5GgXD91jD5AjbnhRXjNPuCDA +h462MxTUhThd8zIi/rHdlO9HqB5DzAzGniN3OHtqv2kHZwnlV3Kz3WYs+rzyHNgB +Sbvhq9fHEVNMTpW6VW5u/kvYkbACM7MRZo9JgCi4bLxvLnpbjO6q3q3S8jVcBiv8 +k7eeWKHLjeXDMufeBDqHh7WWeTjc8KUP5cmzQhO3RZb0zwF7FOSuPfqw9KY6YE1l +bGRr1TWOSAJZ/CY1tEwepg6Bh3MQEbv2uW8b1P5N19gs3Kcn8lSsEOzW1CEB/Tup +DmyLI/tcYMyahd6etZNayUztZr6Ao3vVFh+UwJdGrwbYSnfF3nfz1trObvjbKzqO +6lciTUFKkzea3e8BeMg5q0szVC4hiQIcBBABAgAGBQJN0eanAAoJEMEmM+HuAYyT +4BcP/2dgDos+8kqCuUE3CO4F6YYei2PjL7Wo9S0umixy7mULUUwsjiyORKr5D9za +jqSae2cxOhghTJx1O4zSXpryd92saILmrIddXQmupKyGm3qKPb4wC/mwZpDcsfp+ +EiCPBSDa8TaZd510CZ593l7/7Hgf7TYB8H1Ca8Edgys0eGgpF54MiItQSmoVsLcg +rUVnl0Y+wVoExwU8YcpDi9mXvMgutHnUXbaUtIj3JFunVgMgjziDp9vdy0AczWDN +/CTL8tNkpVvdMyl0FJeqRlgupXaM199ddTWl6x1fAqWL9eXNDT8clg/0aV6MJ7jG +4wQM0eXkxQ5wAQIm9BV8a27sOHBgxYjaPOgpwQvqDASsdar3ZXNbW4YH1FYXZX6t +egmTRnh5ONcKdoH282+OWpyZ+kTk4uB0E2Fdmw8zdDqZjtg2vTAAGVzsCk3dVew1 +8xY8NYJahEQdJT5T34puejEtrcAP+rB6ZYizRqj/kYbeBCJdbvkMiQSIcvBlZl7p +/of8zcMpmSh2M2RZ/6eTXeKAo04gs6EztbRGg818ixTFZorfyom89LFfaEvDQoQO +aw4yzZ8le4Bw5YLtvMw4iqm4nWu5niBwxsQW+hSt993xdoC4VnJtlOdN/kRHqZl+ +ysAQ9IaIoRsq72DLQrx7DxNdS/eOpgBQXHe1xkg9KlrobY5biQIcBBABAgAGBQJN +1BCwAAoJEONS1cUcUEHUz5EP/im3kfQHuVs209mXxTue7vOe41jpT/8IsamIrjB6 +UeErX4nlmf/IT5g3lSj21btaspRpqwwcOpDzcJLlqYl9gUTw7XYctgyjLVc5IJVr +6v6lgT8kimfkYMHUHTU+M6mx/d/YvUh9siGacasN6Fsdqo7O1LrJF7Jdr5OpNfZh +eZ2wCuGw1m24n8QuqIIX4c4WuGY64MBy1478yHceZqLr0WZgOAOPx9flSQBE/l0S +4eXpUu9i6R6rQUIMVqdmA3oQou1sRyPdRgMc8QQgBhI+qkbHdbeysNMwtcABP1jL +7e/TE6FycpScgosfakV5r3d018yVUSgGMyd9+p4SP966Kr9cwFgo979v77bQ5rPY +BVkFZIeYkc6Z4pw1qzDBFrz+cJsrNmOd6RwXJOXyXWjmbrTDMfKtlFhpcy5QgqGt +VtTHvgstBFesGDJw2UczVLS8g6iueQPx6S54vSKoOxR9qyQIOGlsWgFPzSDDoA84 +Ox6YxYlh022U/AwSewrAg2IAXYfZqS4RBLUe+HPbhrZHniVxIP4l311rZr1sb4hf +5wEunF+TF7xXWYRfr2CJ9gXVEUOzCKRHHbNeTIEd1R+zP1CYHq1NE5PPoD12GLAA +i805qQbz4awcb8Y7xqEXAtm9TSy/X/RipHOX0dqhoqkOqFoXo3v2amZyny35Eo5+ +Ep8niQIcBBABCAAGBQJKGacjAAoJECGfa2Cyu/z8rmoQAKTHIZiBaHOFP8BqYyg5 +CuULy70D17asSMdE9SrRya86WgqDM5Af9wOsZtlCWE4pbxE9X0Vj5+Z0EbWhcikJ +03PPSGwIAfVEauO+yRBs8Qo2KYROOJ3QKChvvYhbq4h7JwhiQV5mr7S0h3RToUF0 +4zbYIcMHYEnIeMlZMFDwypjpEafY+irb6+2qBZJjhuEtKUKkq3PYeEAJ/X+f9Tvi +pvJDUZccyafWPXPvBoJav1QmMUcGGtJHtCzSM9A6dJtnQexNe4r6a4wEM5up21q+ +ySaYRVUJOjlYKnvXRgh0ZFQkTVT2q3NlZz6HZcoh5A5bVQk2z8TAvz+Vp4hu7aB7 +T678sIi7PsZp5hGwbfCCoRo28b7/pdNJUBifsvcwHWqpWfWuYScw+9nNArTG1Reg +wZZ0MQcDWcEGHyQnkVT525wnuKDteHQ/mXjWmDg8bUAmw5PLfCkH/l29Z5cODam9 +QOnZXNq5Hwt4DN4VBB/AZlwAzRA6bUSMyZgb8DR16MZZu50OGis6CNdM++wKFcrP +lso/kQuuciyzwEQ6orO2DheDnbnWAGNxXD/maqZSUAiLYa5MHx5suWpzWCPZBEp2 +v5C3pXIDfmmkL8J9Pq97zUb9MlcQxsMDngGtD/yYbeIuhT05a7OqT4yzI5PCNMGH +VJXggQV5msogb6lF8RitzM3uiQIcBBABCAAGBQJNzSk0AAoJEBiz9Q/lkjwYIwcP +/0mcaCOzOkLBAXGtznv+VfEMQRNGMHmLSkw/Sn13v3lH4wd2fWfWyNXoJE8VWH7k +qzFYB0DxGUr5SSxRBLGuBtYSGUoGLMlyr0h6DLtHsEuvzf/qR/CuhjkR0gxxcRAs +KI1WTzHVPbNiOWqpyPjbrA2tK3ltkkowz+mlT6VTk3w9g2gGuQc1iSVYF7Bagclk +P3HGf6oMKIeI0zPs5FhbI5eeIIuu40z7fZBjSYZtJiBmtOdCuxhaIjp31QCBwEX5 +ZP/Du5nAOyPCpNQijiUDYlL3tx7RjF483f/ebmmbRc9vONbUWCQmR7DDoopsT3uN +4lKXKqcfqQUjiuDUAPR3VrDVhHe+pygg8FgMxIR1qi5Crv3c5nVtZ8/lGHi+ZXdf +h2YV/S2AZdK9cvXq1PGZxj23rKxegmEt4PpyYwClwcUUXq+Il3sSwqHdRRz1oy3B +uLWDyYI36CxWuG/yi18F27cTm0cUfGwqoUUG9OKx/as5BdpIQrt/r83f9eF6aOzs +rIzUDc9Ne+vE5TsRrx0VNWkgVOQhgmHj08vh2v7ZiTvyncsmWmLAULKDzl/9Le8m +DYm/U6EhvtSEcnHZEm5ixQouf/MUk+hoTYkb+wA3iXJh7ZsOZvgXCoIYlBi4V/b1 +Fx6BJl2jjEGdOEHSJVO1s9Ys1VasNJNnkvIB28DSnLjuiQIcBBABCgAGBQJOsr9x +AAoJEK728aKnRXZFuwoP/0RMiZC+MzNNN6gW54uPHB7+PycfLym8kaJucJjZOa7r +hTf/P4uOm/A43004VTWfkbGt1I3Nohx2rK8nhi64nA61X5kUw53qr1WUXsLzN8K4 +s8lUZ2YPzKU1t2u1/Wj6m0npzptB4mQU+EMfRkTSzVAJMKMfpldHwJPinUcJKB7+ +na90pIVLwveUa0Ti3Ev26XjYUepItOuK67u4BB/sr+rLworC8Nh8YxV88XiR6AUm +En27xYwc8W+d4YPMYDOm+TprMRBhGwBIIh/BXVaQOR6F+1ftdYRt+SyLABukHON6 +IbetCCE3fZxsPqQQePpg4AO0BWBFSkDDAODySR7W51pu9Lk3TUhzSvbZtx+SX+qb +xQnqtLhHicTEgbzrbDo040ijN1GQUIolFI86FU/KBxRCHdcL74GpokJ4hvZd2eE6 +cOiLd8oU0cJpuAP9XZkuWvrQQ17/I4+XYWjZUeS0zbZLCY6MNol6kXtY3whoau6S +eYQfznE72u0ZpeANI3djh5yC9qJqnOaFSup0sUTBfVK44Y9GZcTCf2XcfeWDZt1N ++gGILbTQmaUXmWkbqTSalWpaWMg63OmHHB2afQMbK6go7fkoGSW5jpOgZOSxprpX +PEtZVVZAeKtZFT+R8v34oLZcSw4og5LZrnS9qL7sP5tneKqeIk+OimIyfJOG0Xdb +iQEzBBABCAAdFiEEaOfPdV8Yw4aRWYQG7Ff4XhbM2PYFAlpAlIsACgkQ7Ff4XhbM +2PacuAgAu58Lgl7yd0ktVxU3FXL9p3iNDLzo6e29McsAnf3r5BAYN90yjwcLmFOQ +SJLVLKl+G8RyuFR/Hfv4DcMzN4EnXDuQ0YKFKsyY2jBE25RXIgtfKoHzpAzlGMpU +LSiUvjcTXDReDN96q7LfHYnrfL+m2B5t+1VtncBtKsVazqx+IYovDu5eHSO+QTUx +f06FX0XuJjEqEDFAdwvNvdKpEssom+IFVcCO4UZG3wQ/MpJ52kajhDZU5lOCAkgy +GpolXqHpZAOTOsWNbtXCtiHEMvrCJpMW4gMGPA1QR/HGB5aXTtejJ3yg6AtfyRJ7 +ltypozrna0EuB1FQnPEmMeULILJaw7QiQmFycnkgQS4gV2Fyc2F3IDxiYXJyeUBw +eXRob24ub3JnPohGBBARAgAGBQJF4TQjAAoJEIfO9Njm8zLH5yEAoNIOE2cjLfco +E4dmw5e/ASmHPMm3AJ9tM2cWuwaY74o3uPraNFr+9il+4ohGBBARAgAGBQJF4TdD +AAoJEAPXxKdnkbFPgAgAoPHm31T4oTI3Belov0s9ktajXMiNAKDVrY5zODKsN3pa +anaDep68/zJ8h4hGBBARAgAGBQJF4eYvAAoJEOBpv3JFQ9V3q+UAmgNETqUHdUyl +724h8TtXjwFMmPEBAKCYoSi3e/LhVB06t9ILHTnqmdhrKIhGBBARAgAGBQJF4uXz +AAoJEJE73F6LvXfwjeYAoOCxp4nTmiaLjrIHvIgdxiVLEBGjAJ9duBtI8N+qsQ9K +XqSzGdt8wwJAyohGBBARAgAGBQJF5FrIAAoJEBmvK1RHQhGNwvYAn1YNY7BpwW9I +KtxojbSG0U01gNZCAJ9An2tRIik0xjWGQIr40OkffFGlp4hGBBARAgAGBQJF5Fra +AAoJECJTsppmZDoMoJgAnjr/muC3dBmmZNvOElwIsD1B6i3dAJ9En4nlyqX1dJ2T +OfC4FNV+mkUBzYhGBBARAgAGBQJF5F7SAAoJEL4mAZFR8ySW6IcAoKfyC4Xyb3xT +behkNTUvas3YRZQCAKCAy4yTf9eW46BVD5cq88slRhvlUYhGBBARAgAGBQJG1z+z +AAoJEBouN4pgjAESLnMAn0Gqr5aONhoO7CI0H90Zg3iQu37WAJ9j2nkJhWG4jUH6 +RJ9EnbaGWyViuohGBBARAgAGBQJG10DbAAoJEAGvk9mRz6NNaMUAoMbZsCxpe4OO +yqf4yS/d8iLSCDMaAKCgIiUioIH425DJkRzhW0E26pJ52IhGBBARAgAGBQJG10NG +AAoJEMlQXDSKUQEtp30An2KVQ1d+c/Q8YfV4muzfOOXRRkIjAKC7WJBkfgpMskhb +e17xag1xjzrryYhGBBARAgAGBQJG10YKAAoJELvG/7mgIS/kIU0AoJ2+3c1J+/dc +KTmifEyqQeamrUpcAJ0Y3iFD0pG+Y2ojNOzF173mqPrGHohGBBARAgAGBQJG12GH +AAoJEKu/l9Kx4NBvz5QAn2f7Xk3gspe0u4eBMRf/sxPk5LltAJ92vnlNKibkCG6r +Q5VZ3Ja2plUUO4hGBBARAgAGBQJHerftAAoJECXXgQmEjQADwskAn0wIVAs1BR+P +o9QM+DhfNHKb0N37AKDKex+bD4uL0PjW9sJ0oyM8j3q08IhGBBARAgAGBQJH3snd +AAoJEM4kmr9LDWE50rYAoO9Lmf+X47OO57DE5e9CNQ58zgBFAJ9YnsQYuun4fUZf +Sd64R3LFnyI+BohGBBARAgAGBQJH3stPAAoJEH949IjaMUgN0cUAniVHsucMmpz4 +7Yeg73pmGCWJ0au1AKCh2gAef6Ua6ESYRvzJe56IuWqN0IhGBBARAgAGBQJI/L/E +AAoJECfZonv582BYptYAn06yDJirsYsFqongIC4zGcguX6XoAKC22fluujJWT95X +zPO9BC/kNhF93ohGBBARAgAGBQJI/O+6AAoJEHNiZMU9t567AS0AnjCXuu4mIzRd +XGjtts20c6MRwZijAJ9PR06e6AkBO21V6r+LuBWFcoled4hGBBARAgAGBQJI/PHZ +AAoJEJ/yWD5oG2Rpdh8AnjVsTDrFrWLCZd4QiIONDmM/kO0OAJ9ojof8iThK5fbY +q8VSvS1IyJ/HrYhGBBARAgAGBQJI/Z41AAoJEIgkNeR2fla8JFIAn3P2a88dN4w8 +ig563On9V6FdFS2cAJ9tMZ8uODlZYrn7n8nm45ZvYrLB74hGBBARAgAGBQJJAyct +AAoJEFoRpUxfBvx3jyUAn0v++CJcXb0d6Xb1zBa3BL4FfsfnAJ4kB5YYTb0IITtM +Cft2A64TH/JS0YhGBBARAgAGBQJJBLgqAAoJEHpAT4ZvDa7Qd/0AoItcsrUvBqEf +0GkvzMmGTYRueez5AJ41vYXGxw9LoQ63T+fnLdlRjM5EbIhGBBARAgAGBQJJYy4g +AAoJEF/tMT7TE6J8yUQAnjKbBssZBfHbo4smXFRe6koJPygXAJ4msG6m5Bp1Ipr2 +IIvNZ6dQSVcW/YhGBBARAgAGBQJKocSzAAoJEJnN6p2kE1s4Fc8An3z12XDJdmfn +64DH43ymkEnZOdfMAJ4mqGCmxnM4EqCrzcwFzkVRgIDHl4hGBBARAgAGBQJLXkpr +AAoJEFI+FDdIyMYJkcIAmwUXZGmiHko98h0/PZhQPT1bUHg/AKCVZ6hOE+UNfCBn +1JxcfHQXX6z+T4hGBBARAgAGBQJMs3tIAAoJEFVbl16VO4aTANgAoLAA2eb7Cdgw +GAxqV6LKajKgIfeEAJ4/BvYraEG/dWeYIsT5aMtj56fRU4hGBBIRAgAGBQJF47ra +AAoJEE4u896cRh7z56QAoJkT6f1hP5UHGWhVcSq60xL7fz9KAKCo9pMf0o3FFEpu +g5w5nILsQt1NJYhGBBIRAgAGBQJF47r7AAoJEHvEYCkpFp12Nc0AoL1NeXCAX8bv +Ra3wY0xOFgTeuO0DAJ9tDXIhjrlcGZ4wr0HHTYrXOMoYcYheBBARCAAGBQJL3Ekm +AAoJEPrvEpNt0+PsbPwA/0neEQMg2q4TNH5XAIozbwOuc5t9YPANdKEfhJI8iCVX +AQCEoj+vQABKkggT5BZD4DbKoVDRydTRWp2HO/OfsgjFDohgBBMRAgAgAhsDBgsJ +CAcDAgQVAggDBBYCAwECHgECF4AFAkOFFHoACgkQ2YZpQepbvXFvAACfdjUZBszG +zO2BemF4LjsfqOITTsMAoJRoNKgrvM8Yk9esnww0dH1rdGh6iGEEExECACECGwMC +HgECF4AFAkoLbOQFCwkIBwMFFQoJCAsFFgIDAQAACgkQ2YZpQepbvXHdjACghDxJ +oWavQ15wSvNae1WEVF43FJcAoJhqQQMYj0wuNTIZLhMzyljnQOFHiKMEEAECAA0F +AkOFFFECBwADBQJ4AAoJEHEjvBPtnXfVbaEEAJ6odsL6e+1LePiXBrAWxCWIldEH +hAOo6pOZoyDmYl7OdSxq/PfnyvpTzxpowDaYs7SazNygaNbCpCDV9PYgPD1IylVq +MgT6iAgjned3Bk+v05EmaBZnRCZqPXfarE+TZT38wCivpRVr7Irpxj2G70dkYs24 +ershu8PNH+9fK1FOiQEcBBABAgAGBQJN0WUtAAoJEKax8/DmtfWj1r4H/Ro1t1PF +sPMaBGghz2WDdVsTK0g9kehVC/HfB21jSCt3BOhypCeHxx3uiPwGJbmIFdh+eKiu +igfWoH8pP3wNE+bk0kMWQ3PUPkYL6vLjzHPDRnw+Qlfs9oZqGPy8PvXN9mJnzEtn +GNbmewfaDc2Xievbj3gNd1jvw5bTiFDHGLok2LJQGzqy8txLuJcgvpTsn5cY/tA1 +ncf0YTWw16DKj3kO7VZjg2YPWxvsSrrV+bM+nyPkmJXWNOMIIOsSYP3JuvHKVsQl +I3yvTfTWVElclOvkwXbo9/iEm7+A7OQJ5bEfCkX0ZtJ7K2z7vv9U9nN/Lx6f2zUx +QgRUrZwTJlFGjTuJAhwEEAECAAYFAk3M6vYACgkQuN+3G1/svZLHTA//QGiOyTnp +1SEG/BWSQ+2QHqaPRRPGqxrWxyIrIRE+R7EU7hAGKfaCLlGXd/vdKIIs9PFKrtPM ++L8NEYWBBbV+6TWCZHe0ZXf0TAZItetvxYUXLkVplzja0/vwa6hq2pwN3Z6V0jeX +IHH0Q6ZhpVYEEYaZnFAiWLZlw597tpU26qpIAo/gHtAW8XBWjFytE4FK4shQ01yh +q+6xdR35QyYYqcfrQ9eJiHEVtI1tRJETAv0lqqkD5kMudmZwEH4S+GGlNbjPvF7H +jnYasZEbbg73eWXDd555UaOx9Bl83r7XJuwpw1olKpBXT/ujtLtv7pofCtnz2Ixt +pY6UQsjOlXuXvUp4brGLyyNnbFuTib35MOMaHR+jTJ+2U9ecuomF1RTUjeg5pVmp +1J0X02wQcT2eIkaNrkZBqS8TWaQ48FKZcjvF5i5mcjnhxKcdacXj9g561IgLV6A9 +/QY5yeAGpyM0WyRpbZ+wRvLuLIK5jjlkUj52QPIHCHxQBtcpvB2AKW3HuE8t18ZZ +gB2nRKOAgsRBsYUpC2eUrGNgXMEiiz/WUj+Tv932KG35B5U2Ja5LriVBND78DA9H +PpOJ0nuLf+GHootu+XDCcNwH0cx8vxwkpEd8k6PhtzGHfhH7f4HQTrcpRFq5hTx+ +LP1IU4lzewDHdIptUE86MZ6lHCZxvBetRpqJAhwEEAECAAYFAk3M8SAACgkQ4ZcB +Jna5tznyAA//UMJPdPvIgjRYJ4HDjV4ID+cs2cHcgI3FU/6ZxgA0YHhsUe7gOeDS +sQ+sxWOir5n6PpSWLon7U4mBjB/lGz4Yxydz6RkD0NYN4FkFjkJJTWihye06p6/3 +RiXiPXFOu1qZYadjY+HpeCyQAVh2sy+w+T/liL+kY36BojpSFt4ohAl6+JLdfh98 +DTm6zdXh4Q+1q1OL7+1/OCYw94/gV6O3m4KVTZeHfhIx/t/+enfAgg2ZCJgBJEUs +woxxtgoBh73/WEUGmagcRt1vFpFtCzYSfsTns6lpa7tJ0vB8r/fPktGquSIJNUHx +tsZbkr8DVvaxv9G8oi2zrYsoNuOJj6A620XvoM2MkFKg8XaR8bwH6Wk++5guBQM4 +zb5Xx6tFuIkRHYezV7I14yPHBsAIM1+su8x3NFPFwD4VR1RNtAp0J0ffMqdYWasv +4BEVI/iYLQVra6aZ0Lh0mlB5M29mg//Q01rVJleODklpZo+6FPwRwT5j27tc2EyK +33aQtF0dyig646MIlQEBmkEXkJqi5IX2wLOI7O1J1YPsl/m2iQ6k5i7SZU/p64zB +qn821sXOmwbbBdKlpJaV2eAlRcYJLYULLmXsWwuCWJhJ73TFls/pQXtFOU5U8RZ1 +0UHLv6gQMj+XHx1HDdmTxKbdNvDwgDwr5GB1Ypf0EockwPU+YW4sQ5qJAhwEEAEC +AAYFAk3NMkEACgkQhlYfRSGA/P4N3xAAjiJ+KEARj8ocbqiEpvgg2jfAaEOKKyNv +x6OBhbLVKXcRACSoYhrhv0f6FppW1r/oK3hsfIJvPU2xb5WvM7U55Sn+WerURvgL +HgQStqLMibLI4FCvm2XAuimud2V1crqI1p1zGMObiAx6BIHDES9CG8x7Esug/ibp +j+dqYxCGlgo7+BI8F57PNhn49c0s12UBx/KEUq+en9ghyDBArrXmblslTe7Xi1ae +6gVRzhWFeyenLXdXkbSfh2u6gQvFY8iSX6lR+rXBw7kWDgl1s5wdjqqa1xkj0MoN +lJVdSeyqco3WhQi5WSLyBVYMVLOOTQpLaACDbziCtlnoF0dmzf93Nu0Rwp2Xc+pV +MUVg4ZwHGQbH8gEAKCBFGHue1zGqIjvjZ9nub1mrKVcLBTe2qON+ntAyWwERmrbN +VdcdqJ5jYUAY0SSjH0BbRbqgFbFWiG8ZubSWex7cg3878CK8N5bioDA0MH5jB7rm +pzB55UApBkXPbBCApJlRtm1grjYUoZG7a88QYcTtfouchHtYwIy6KSX/VLqCcZIR ++x0HJvFdzfycsK1yNN3EpLWKZsPCUUdfGn97xPQgPLlrelMWt3RDslRWOua5+Nr5 +aBipnRdDW2B/lVYWTYu1OR7MYO7rzfSbdP+BiH269oCj7NY9HQ7QRRKPbNL2YJSc +tj9s8atVRvOJAhwEEAECAAYFAk3NXPoACgkQRdd+njDLGxH/eg/+LuTt8C7QX/x7 +js63JEaHDs74ZjH8zk9WZ76GoiH4/NkaCkyjJ9RRfH98T+tfG0YI6CY7KblOqvgA +Luinwmu/Hh4lBHK0ts65RKlEFZv0O+pJIir2LMxLrRUp3EQl8RNiUKY0U4LzoiuJ +PdVdaJrYhfpYF2EicElVnQ8n8foaTnFOgRcwtl5c+flY/aVGNfgtzgH0Ofhs2YwR +TQ61vRAEL8PhSLbXoMCQRA9Nq3qEz3T3LhKNd11h8+YnH3EUFWcc9H2QzmZ3tLtE +pAhZQFU/hQj8bKl6cn9jhCVXaou4aN62KHVPQas68NyU1NV5G1OVYME9+1f1H1Th +JmBFLTIU4olMQMcCmuA3bfmfEuH6nXTgI5cZYr/Gybvsdz6/DIBigolj2p8EVBrH +2QdxaEX6hRsVqNpTO/C3oUoDyUXysKnDh/+96IV1M0YoBNHeZWlMWl372UP+VmYj +i+sxiJ7sNmhRbnuTTaxtehFFSdF1keyMgTrJRqJUJ/qwbXFcuZiX8F36FalDPLlT +gRoKMe7loi1QWJBfJuYS8p9TDmdAGySJ5FpQ02H5lOJPrUup/oZk+N9aDlfARQnn +gfqi1d+Kum9Q6HcI7/w+7cxVrsGRcckYWXbZEL4Av4E6wUKprVMjIcFgPp7I7yUb +63ampN44VewXjZLL9Ut1hgbZVQBpQLmJAhwEEAECAAYFAk3O/yIACgkQYAQmoRj1 ++878+BAAm/3Va9kmKHvf4BJaiTcK2yEW8LMOMG9opayfBzXR1VKXjyPPlGkGEoUk +1VaJ9y0Yk1PN5Agry+51JlaeB4qcBGFhr8L6q5mPszMCh/zb0byVd67Tw6VTtDcg +MPRsT8vaLb0TI72l5DhXUXFXDPYIZlH1tHrNrvRvTuhXz3Yp0A+E2CMshzmzwlBo +kA+tnsUA3HUvPC00rIjViSYNgUdbxiw3DyeFJ7wtCiYIz6ANUT2pB0UoNMFD9Uw+ +VziQYTaHunT2cawkadQOZA7dsSivE5+WG+SV5Kd58hFPCQ53l15+sQ+L0brX0A6e +l8BWGWoU7lFmeu+4e0YrH8ouNGdNm/0fp9h2aUjNRZJgEBOmUO8Zd0d3JkK0e+nG +ZZlCFJIRZcaEs0f5ujjGuXMLfaBQcs8shHyLlVEDRGpRPObpJJ847SpWZnxfPf8Q +/GizGyY7J8wVLA+YAGmBRTCYms2kWFDdlB2HLx5juGM1y1KNLn2Aegfl1jP0F+bX +228hIe5VTMuT9kK/NxOX9XqSQe2Dp1/Eq3/JZ7JCZ5piwvoHzRW1vqT441LmbLsC +naqDQkE4SPynnKPXcPXQQCJQxP30LHZ+QzMsEYq/FM47KhdG/L5x3kkHT3pUewUd +pHdUXiiZWRyzw2HSqfEVAoCQ7XmVD6gvvF/VfyD/KkjjDLC7kTOJAhwEEAECAAYF +Ak3RdQoACgkQxjiXTWR5LWeVaRAAt5rnwF7C8+x55OEZg7Par6nLe+VdKSmp0XJ1 +EL6zcT3AIzprxhnX1XfkyCAjLYGthuD45XjwVymJWxDyEUH2sQkJ35buAMwSQuyR +64+40yq6W3RP9ftfnIiJA7nplMmYRSFXVJvR2l5KUkXgH+KNH7SJ+fS+j3Vc1taG +dtl6ZyL4A+GtTEqtzVEZEUsqff8eGQAFEFj/IPiFPS/86oDK6ABEytRZxoFFcOoL +xZsVk+hWiFhsBZ/Q2wYHUhAdI7Le92Wt4DjWv1KVctyR4yBzZscUbao4gZrho0jx +rP24N0J+/OODR7eCG6xDAZ+r4+6WpelU3fDh1WjlJfJODwrZhsIbnbOrMIXba6XE ++AgixczVCqzwvxs7fdZ/V84W5eP5Bx8xRyMkypDZvusOCSLSq9iFrvVC8lVCp/vD +8wAB++yOen5V2ShcGTDZ6PdWOkmbl7/H/+5FsA5Mo3Y+2vwiJWQqrquE57O8X6Xi +qqOXC4bhEpZ8BfweLTCTrWysh7BpxjYEgBnYiT2mfsM3SaRTqqLgNSOfyfLcE5iR +PfAhhduzmiBL661XvxxxecIzGxCLIVNt+qHlb0yM/+X8CBDdUObmYYKNHtVDo0zO +6MgpNMA6vHyqdWXu5iP9RMBbcnuvTMgCRzF1BkGlTNvYtuaDxNGsJ3f6o49Nz300 +05Frq/6JAhwEEAECAAYFAk3UELAACgkQ41LVxRxQQdToPxAAhEJUfH52e1BPlZY8 +03Hv1aqMc9cLH6JzzqOO9ZJGpVuJymuPwNArqzpVPElZhuE/Mb7XlVTptZ9g7s/E ++xIlDDdXkEwk96uzcq6xwhyjUuXYZ6y1FXki7Dx5NJ8eOaBcp4yyYLkED3kMS4kR +beNqCCdPZ07h6YUb1Yf9GZNKsFtoENVXNUZ9zq+MyTOAwzXSQlgh0+yaJ+8bNdah +H30p5HXU1MXKO3M/FKQscD8dtqJQJWJsVonaz5EkJMoAMuHRT6UiLCdVS0nLIFDB +jQbc9MrkVdFJ+p9RYblcOIPvrqZZTDohcrJADtQTtriO/reMCxunuT1ocytGABe9 +VBKmlSNqEWHfqBAlkvjjWA4oqn7RxlwYpNuGzWAcaC6r/VNuOmN90bR8FsSnh6CN +JM4KUQ5orz/aGpfkBCU2FLAfjtazp2MapeFmjZsyG+WeawnIGyBvAgX6OMQg02WF +I14GRjWXbdVh40Q2IJO4Y4gHA67Z6jODbKbXnD0OyHGTPKkA2JQ+RbgQWijBeS7l +0FHc5RE2J8Qj4Oj80yaa9qmC1aI42bCXc3KaGB2kOkCk0lY4dVcyYVtUQaGDX4ld +f58jkSDOjD3xPJw7TtgVnRe8FG33x3pdU7eV8EGIzi8c0fhbfI5X4k6ftQSCdhdl +ZvEvSrrRDYv967u2hze8kb3yAlGJAhwEEAEIAAYFAkoZpyMACgkQIZ9rYLK7/PwM +sg//cnJzlMBbkVlakDw8ageeD7Uhc0Q3pP5lvI0wzbkwVpGxugbXw+fw/DNXi1mH +9e0acy/ZsR0g/CHk6MbW5zDgQiSis6Fa+jFV6iuCQSNqTE4W637mSkIWHnOS+59f +t3RVzlgh1EkwvWpZMMEW06gkIykvrTggEO30CImhUCtJHqne4nKTg9NNoNOsXF57 +ma2YCT3rRZy3VrfzbIlEomihv++O/Kud/3gTccuPWxd1T03QFq7OClOUR8bwSnWI +IRZS3G9zdic+envYdxT7T9w3H0H3MsX9jIPHTlVs/9P91YkZ7IO07RQoE74oP9xR +SoANVKTmbJOomvXT5iJIWfGqrVL88R1ewlgl4J21Wq7b3PPValPe2fmiX7vKWaCU +zBCd7j7c8E2fq19awmsfuO9ygNVR5b8GkoeZmkvLBdA3szAA7m3q57vlO6DZQDLA +viNDUbfGHgIIZxgDX76H006J+jbV60dgd4aHUQdpJUZesLYrV0r8bA/NEMyLXBVl +tF9ssWxCdB8iAbtElq9YRI4tw9zh/iEvXdM3awwcDbA0MkX2Bgy4bTRbtPhS+oqh +U2NwpZAX1VSX237rndPe7JqpSBdeyq+3YZIv/G9U0yNcdoZ+pybi6gNtFlpSVmc+ +3riLrY2clK+F8+WCrmvTK7FuB8Wa0gHGK5Dxp+JnhsndXPmJAhwEEAEKAAYFAk6y +v3EACgkQrvbxoqdFdkXQKA/7Bvw9S9SkxCoDbA2D06MawbSfnyD0vSmxgHq0sQbo ++kh+CnMvbQ6WAb2OkjQCluu5HRRs5p6BMWLDCQIDjaTNMR9/oK1ZCXmZVohJ+hI3 +VoovB7fd0F9/3RbnjbUCJK77Iy6pekmjy4wx0CDVUJzZ7I2cxMoMpTXsPb9UGuET +jkXsD401Vr+hopTwFuPegu4RApuEh6jCbtmoEw3ZSUlGDYZtOH8of6E5RsIAEuSH +gCvOEpbQPOcCYzcrO+V5Sdqyk5lFLG9qam13+63HcFn+2IppcyEV7eK1EA0ddLxk +nHG3P7bhsYEjddLu0Uki/ynR+t4RmsbdzFBjvY5URelBgnEsNIbIyw7jjkQheEPH +zTTg3pL2i3X9w9jx1HXnRK5pIlbVpHTCXd7UAtXJZw+0LRqbs5oZTMhETjEOSRV5 +gkPHT7kz8GlJ1n4BN0AcgEGADZhABOhc0LzQ5XTv9vcr7HGmyc6JESi5k1uJfstd +QdudPN2WLH8yiOkM/GAt/TPDQOpIm9p7pFE83eFdHWreUQqqlwhACcYCK+mjsYn4 +2L73NMfayLVKL3x4qFmF+qYGn5+4LqO8eCzDLtd2gPcpqxYTPnGRc4PY5oyL1APz +1rS9ViGmvwwdIdT+1d0rRVoSp8l4aokind/TYkzOfBF71klGYtHox13UW37fAyQY +L36JATMEEAEIAB0WIQRo5891XxjDhpFZhAbsV/heFszY9gUCWkCUjAAKCRDsV/he +FszY9umAB/sGYeyzwu0cfDdvUZ7TyU1GdA9hLuYK4l8Z1J9FELzqPdUUwrL2zpRv +fAPh+pYdD/Jd9RpDqgqgxmwBVFaSy840pqI7qdriaTBJZRSHfCff60Jb4a/IrQpV +ysYjbMrO0OyTpj0nPTHlw/O0W930+rqrPCmLJgiCzpsnu2ZxeFyWgXs5oOUINdJU +KODV1uFsoumZzqNQ2fUOzj7Gue8XCUH0x8LxELZOLK93tmVi3Hu9kFucRQX+Dr2C +ltRGgA4Q/BqHYm8ACqIhv5FONvEKku/85h09C5IKs/2rZBbrp1ayC6pq5i/R9HUb +JvDfNdLUat41OmrU6cTU0HmKM9QZuNxNtCVCYXJyeSBBLiBXYXJzYXcgPGJhcnJ5 +QGNhbm9uaWNhbC5jb20+iEYEEBECAAYFAkXhNCMACgkQh8702ObzMseJPwCfVM/c +QUFwI+Pi1D7Helgi1NwDbN4AoKyaSwMnYSEbIysSDTiif/zFVz26iEYEEBECAAYF +AkXhN0MACgkQA9fEp2eRsU9DagCeO0avHuo5Wsg7H+BJZeRo0ddJ5IIAn3qp0Yzo +A/EpNSQ1AYuPUjZkRDegiEYEEBECAAYFAkXh5i8ACgkQ4Gm/ckVD1Xfq9gCglDC2 +xcud/ycRSuCXbvu0VVRXipsAoIOiF5CHxXEHrXnulpPXBmB4jm38iEYEEBECAAYF +AkXkWsgACgkQGa8rVEdCEY1vCACeIy/UFJBz7o48K3ON5NWCrvUngfEAoKpC4SDh +WjBMYv0je23YT1niEdcYiEYEEBECAAYFAkXkWtoACgkQIlOymmZkOgxrGACgmsm7 +oIqCCXR2htM6an9EhGYVHVgAoMcDUDYGjO3Fqv5u2hKAXlRM1uvaiEYEEBECAAYF +AkXkXtIACgkQviYBkVHzJJau3QCZAdWjaXNBW9/QhTLP1yNwEWIezfUAnjK/aAG1 +FDFByKTI2YHfaFkVr44piEYEEBECAAYFAkbXP7MACgkQGi43imCMARLxogCfadjI +oEGkV6jjVhDaWD948NZXnywAn0IYGBwW5N7vuOSX2mYUIJa+O2OFiEYEEBECAAYF +AkbXQNsACgkQAa+T2ZHPo02MbwCfY+BmtHpgBfpmxEFSEhoBDKlGM5UAoMM2SgRn +8OZ/Fr1Lj8u7pr4Fs9yciEYEEBECAAYFAkbXQ0YACgkQyVBcNIpRAS25fACeLCwa +q7WQFEgr05ia1PZehXhaQX8An0RCHtfKTYMRpWD2XXwVgzzuU3I9iEYEEBECAAYF +AkbXRgoACgkQu8b/uaAhL+Rh8wCdEB6tPzPZCep5CQWs1hg9p0RDt7QAnAt1b10K +uBM5xikKHv1clz9PTekEiEYEEBECAAYFAkbXYYcACgkQq7+X0rHg0G/2CQCg7if+ +xqbeB1x16blOWPHm0bu5dDEAn2H5nseRnEnYDp8XApm8RAQnAIu1iEYEEBECAAYF +Akd6t+0ACgkQJdeBCYSNAAPSTgCgme2V3njVB5F1bLWogEmavOejz+IAmwSMlYzc +W+iPkp7qtGAaZ/b/F5aJiEYEEBECAAYFAkfeyd0ACgkQziSav0sNYTmhkACgveLH +mzINmeok29nRXzzkhPxYqYoAoOIZDNfxJRDPzhGFuN+9iYvcDg+2iEYEEBECAAYF +Akfey08ACgkQf3j0iNoxSA2O+ACcCsyPYOjVgWA3G7c/1feXtP0L8XEAnAl5FNnC +MHsM2UUc3WhEBXZ8utZ0iEYEEBECAAYFAkj8v8QACgkQJ9mie/nzYFiZKgCfU+E8 +9yqcDG6aX7nPTvDS2ShwgzIAn2RM6T0DFFp6BiSKm1V66amDtPMeiEYEEBECAAYF +Akj8wrUACgkQQ6z/liOuhdJKBACgvcr66pvznrQXHNc5L5rwRBrIKA0AnR5iAO6x +oPnnKGrf+FS0atRbpc9UiEYEEBECAAYFAkj8xjsACgkQtxctaWB/rFLfRgCgjZtJ +kHeAFNptwfJ02/N3a5hpS2AAniybZD9rRms4R4Wk77bbv8QkYIn5iEYEEBECAAYF +Akj8xj0ACgkQJXnakaZa12ipXACgohQhC+fy4EO+c4bRCd/Sw1eqnuEAoJJ2RUGK +9T0P//9GeMG9SyFZ/16jiEYEEBECAAYFAkj8yBoACgkQK44xRkGJ7SdMlwCeM2Y8 +V4tX/rjY2+Tu/Li1cnxz078An11X3Sb0lDrGAJwFag+1fqEs89QciEYEEBECAAYF +Akj877oACgkQc2JkxT23nru3sgCgjYVcWP68djWamYIqG7Wuridb5vIAnjyX7m2n +iWEWqDyjNZWCAMLeHlhviEYEEBECAAYFAkj88dkACgkQn/JYPmgbZGmxpwCdGUmw +J1e5etpPQ5UKzINQc5iANFAAn33h0WVrD0X022hyPvKZT43Lfe+TiEYEEBECAAYF +Akj9njUACgkQiCQ15HZ+VrweSQCglbNX14J7m2BhXd0ypYbirbaAEP8An1YcQFbh +KGojIz7Oj1zYHmuQnFW/iEYEEBECAAYFAkj+ScwACgkQd1fvI4G7WRBFWgCePY0N +b/1xj9iUFhHcqCbIlgeC7PcAn2LiK2ZVOKSI2O0lIBMk178KujRciEYEEBECAAYF +Akj/hlIACgkQAfqZj7rGN0pjiACgmuWDExPIrfgA2etWB+o5cqkvQBAAmwSSLleh +ZavqV1GabLaslTyEZ3HriEYEEBECAAYFAkkDJy0ACgkQWhGlTF8G/Hf8AwCgp2bL +GnNo7pF5CJyg4Hul4HAzt7EAoKIwfdNcMTkEFfkF0Svq5CgZL6MAiEYEEBECAAYF +AkkEuCoACgkQekBPhm8NrtAFPgCbBLkTOgBwe2/q4hXawmb7b9thusQAoKkDfRqO +MQzVcc2Nut+wmwm8c5wHiEYEEBECAAYFAkljLiAACgkQX+0xPtMTonzEuwCg6++n +VxX9mrTDDZJzYxU/WAJIes8An0aJ2bvG1vpwOp6q39Tz/3zlEVAUiEYEEBECAAYF +AkqhxLMACgkQmc3qnaQTWziZ6wCeOuVtL1yT5RExWD9r5qHVBclitEIAniVH2Fd8 +W+SpEh85heVOl0BAhJjWiEYEEBECAAYFAkteSmsACgkQUj4UN0jIxgkETACgrwD4 ++k9B15+hGs/XF4S1cjbFom8AoIHRjV9r8FeA2oUUV3x8pRn5a+KIiEYEEBECAAYF +Akyze0gACgkQVVuXXpU7hpMpXwCeJaW3KKaIism49LUL8ZfoNbIpS1UAoLTYKmWm +L9ceikaT7Z+Nv6/0QsJriEYEEhECAAYFAkXjutoACgkQTi7z3pxGHvNDHACfcMtO +1QBXjQMHcVSJxgxG9EwOSZcAoLsZbk690H8l0KI574JsxPbV6BgHiEYEEhECAAYF +AkXjuvsACgkQe8RgKSkWnXYg/wCgtQrJ6NnUSeeIGuN64bS/75mU68MAnjINXjOJ +qbuVBCRcsx6CzNg/7YfNiF4EEBEIAAYFAkvcSSYACgkQ+u8Sk23T4+y77AEAuwcq +67imwmMWKdUY/1MhdK8YSEPteHJOTs32iQ+9DxkBALfvKe51gGea7e+2jkqYHxCF +1Irn0bNzBkiGnsvvTISCiGAEExECACAFAkXMzZUCGwMGCwkIBwMCBBUCCAMEFgID +AQIeAQIXgAAKCRDZhmlB6lu9cUXfAJ0XnZc7pHv398ajdVm8XW26yYMjKgCfcwUj +zZS2Zy+htb9Zp7aD00aAgCmIYQQTEQIAIQIbAwIeAQIXgAUCSgts5AULCQgHAwUV +CgkICwUWAgMBAAAKCRDZhmlB6lu9cRnhAKCeZpWgVz3WOf+5iZei1TtvX3vmsgCe +MieCpxCleb0sJI5JT87kdx7CNCuJARwEEAECAAYFAk3RZS0ACgkQprHz8Oa19aPN +QQf/bBa+ZEy1Oz++KZgoUYmhvBBemRjlv6djLcvXR9RxbUtj6wpZyhEtZZIVpznz +cT6b1r5Nf2r9+DK9+wwnYHJn/jdqbCBXt/mm6yR9fNP5g7ZyrM0S+fw6TccJkaEI +AQeig+YMnADQtNyLEE4L5ccjmF3S2NcDXAQCeOFjf7cDQ2jPsr11JjzwhG9OLwKD +DgsWzP+bwaEEK7+BTaxKBrH6SprF0HBG/R3NJODCG0+s/C4U9VEQtMEx9yPQnX7K +sOnBciTdZXW1wlaOqYOwOwIw5RpFd+HF9NorWReoZTLeo9BquZiovSeP7xQg4hDZ +EN97q0w8oC0uBy12sZOdVnHF3IkCHAQQAQIABgUCTczq9gAKCRC437cbX+y9kjcc +D/4jszuaDldDRBG3Zflu4b37Z80YobkZa+7qD91kCfvkBToyKoxBSGz0QbsfiMVZ +RGtmkm+t7VMyOLVzH96TcUF15tpty/Jwbw/DJHe4eHM0uuEUIu+TSybPpbweiCQX +FVka+3C8ScA+LlZNod506Kh/xSJrLKeIcbgXPsyVa0fwGIs7+88ryKRHur3tl21G +xzQZxXEUbXS3Y4gSy54W3haquvmxLF8ZHLxshYHqpNZTc12e1UnvD+lHSUX/qsRh +us4T9Mf0REwlV3bBCbwibOCTrn+5LzVV2a85Kh2e4iAqDCqybPrWfuJtTHygTARn +99Yc5AcTr/uK5EfEHvfH7n2vg9j2kwMWTYdfIIJzokJa0etdJX9zfOJihOzbBxa8 +ECoj5w+vMAPv7zw69mXvsrWYDw6T/0G7VQ84zqclAXpCUK8sL3uVuxd4TT9ByVpq +NfKmeUIx/iiXZ1dw3IlRhSZwWMsM5KM0okufD13I0UY6YBunDSO4ssm+bgPoCZpZ +MytIFLVLHjgEK5LIwgvYQLUMDTQy8xO1rCvd/FPtxLQOxJzYOIv1GBn9Qkye7NP3 +h562k3rxuZnD8kXkGyMiYwjFbU1PNQkuY/Hdsv/c2cgiYdEBT0zUM625yRK5aTWo +D8DNSjOcO95wKfHrifT7POhc9mzqqhhG1JpuFdRsigHH3YkCHAQQAQIABgUCTczx +IAAKCRDhlwEmdrm3OSVsD/0TPsN/FNmraxO2cOg5BSdpbQo+cd+nUeN/EiMwA23I +aIJC6Rw8EA9P/JoeUHQk9qtccaogSWsVPbdMWEbTOwQrZyzLzqCYr+5SsGBNumGb +un1HPRjo0zZ2fIIgRPqmDXEdRxfE27BX7WOnFiZyuCmd0UNFiM2z29XMxqy4ab4D +G6VsNsJCKnlP1d7JWqkqyZKcIj8b3cEB7+AolRgbLTyFSvo3jHBuxowFiNcBp0pK +WhctUv5Vns15LplhE4gb00lRW+5fv4uThNu9a2xpDAs/adxt6QPiNzE5fP1aHtGw +pvzxgGGAqzUGJ2V0AEjnf/pzFN+h1cXCyIUVFXbwRdJ2PMpEL+Md4ji0lDAprnYx +2oNGx7nKIxjt5qB8ZyH8Vx1a1vwFMLEjat3xNcBuOYRrTKsvnILzkVnp8sDl22lO +eBOB+ygCneRoRUarzykKYJ3g8L0pweIHGgf5MHSxmh5zfSBaX2t+YfJkcJ0RCP70 +alfINUV6dERMEgjEJbYU88jWpNthFNXHvCxybuXCNYFWyU8lbk048KQDq7IPodto +hIZUeCe5GoU833rc9iSHd4P4NDyKuFbTgfETAiDWFSSp/qsxE1v+DyjV1wKz8ZJH +6AcXo7RUsDmuaeXIxvxOj7nfb7KxFSIOFlI73c6RK5EttY7TU/de5RGELsgOu3Wj +AIkCHAQQAQIABgUCTc0yQQAKCRCGVh9FIYD8/kiED/wMdAsltMa1S+9vXhLz6izy +ZUjntWZ4vVTshAvDz5C2M5js6EBKgN0xexsP1EObqR4BxNnyT0Uft8y/neJdcLLA +HeGkvRoPodKgYZHDT5MBORiF3FtY3HynI49U0ZWoDupyRGU3CW4CEuq+sDsjBICz +zxuixxdvAzYiGqso/hC6Wi3g025R+kRJIEsMQ4cx7sIxG791mJkFvwOXbOIHEkv3 +0UfdxdzQxbN6wIKQQmvKVE5J5c3diKmNI42FkKj/EZek1/z4Be9kfr9B4xo+4s59 +0MIZcWovy1MeHddxt45WuNF3mt9gjnUKElmZ4qG8zctP1KVZ44SPCq9ZgCmJCfJo +0aFAu8Ap85XQk498RPXURH9Iysta5gRShh6cIF4ATwwgHi1DqXahnjxhjiSyChd6 +TB9Qe9LOpzluiQPB4muCJfBIbB/aYf94+fDy2m49hEfSgX+9M22tivb/T7zqRdQa +hXp7rTyksRwq5Di3amOV3ZvIxVejKfpfmrU/Sh+gwUbw6Rq4LYOSme7J16ISDVzu +IzNgQNb4kMrWI9tyCbRJ3Ovq0SFnnW2XIW3awNOQSm7wuYu9CvqTkiasf6z0OGVY +Fc/2UEopr+PWR45t36dEJ0ZIXA5TPFIvtMXE3fvboLuHh/sMTIxQ3BYxFem8R0Hm +6ZPijoSiernI3ZhpawH4DIkCHAQQAQIABgUCTc1c+gAKCRBF136eMMsbEWPRD/47 +0+A57hyOv2jNI2HJP8C33sF6wraR8nPSXW/3bZjbDyyWVi0u2c28H3ht0JQVgur+ +nzXczgBkQS+bxpItgx2SXCDbwm1TwCU1k19Jp4FSgSlRO5tlBZMkLD0HzX9fP7ss +w9DQyfo5rAA20Q9OULD1w7KleLafp6+nj8IjqHwmMsIvKm0fXiP9wzDSjYAlmayl +824CcB8804QrnsBFBsWfHxFZ9N8naBW7slF1LiLvgK/e1mhigRqriHbWSZfrxmou +pERt+2Iaf03EBFwnspaiALzp74AnF5xPSBd5oEd8BPctslJeofsd9Z694o8Ulxk4 +adpPFyl36GtMbdNhan8QuYPww0UIkn2k8cfKgoiPoGlKGkozoKgKHEMpftv54lyr +bCM0zxNIRlnAhyLxJ+j3Kb04vn27bt765aIwHZ7f6wQ3rprXdIddSoWjz+7hjKIp +BqmMAKtJm4YLUeALe2BZVLLfBFg8u7NXV6VcNZcmS3tt97WB6QReDehEVQnzj7LH +nCRKkhEwNiVIL/K69hyaDQWJE8rV8pAY6QvGqCo8DfxP6hjaGE9ipipwkIvr9hJC +LSiYZ90oiU1xikxVTJIWqH3yeKSyA0XOWvsx8m7pHWhh9A2NNGWZLdusnOYuDEnF +neRtl3x3u+dUv8G+0qkMeL0IGETrNkg7xeXD+ZZrVokCHAQQAQIABgUCTc7/IgAK +CRBgBCahGPX7zlz1D/9MjVMtTKUHuSSgfgECw9GnYR+YGsNW/VoQQHxzztX6bERq +CKpOGLukGWH3JWN4dNvhVqIs0r2LJRIN77E8uou0h8l/xQw8svuvwMzEKLPsKj5y +vQckHITJllFXxVBaGaKqkFtiMKdlioYB2r/FHrqeI7tgFBTYzVCsdkjmOmsubYQF +/MYhQg0Ir2PztJeNPhKXMb3Jt2xufutEZ3KqBOtWz4mvmzTipbxn0tUlv5ELlwWh +48j98VCtlBKrZN152yjoDRtvQsrWjr3ixzscSTMoE2Zt/x5X9lUKPYP9qiUxvws1 +O7Ra/n5d6uD4PVHya8W6mRmDXO/sDcC//BqKv7gqEGey6QKOMozBlw+fcP5MwrLX +wVqAxqkYkch6dvzR17OhZGVY/qmihfL/S+dPJPhWIHNGitVIAqyoEq7eC6+WgBi7 +c82O373hfebqfCHE/P1bZWgZwXCvR/kc/jw3drnDPy6PY510wwzel2pGplcG0jfT ++EcQpoXmLBglTM+4M9GtqypyC4tz8mphVkh9Q11QrGz26sRC53nM00d/lj264irU +yfzJeBShs2O9/tAM05Am3ySsOZeBQf0sgijMo1O0wgqoQ5q28Pih2RRVQZ5okXZm +RoJC3wfHRpKgOdgNet1bFCB3tL9uSgCWsNypaVJMqRSapf2oqTbQ/GoK7L61VYkC +HAQQAQIABgUCTdF1CgAKCRDGOJdNZHktZ5c6EADOIGa5Je3ov893q8QLIp0d8XFX +hvvYTZgbVm7j0oH2SFtstWzorXs30ftXw73cYHKyAL6JPo/y/KUDuwtT1b6k2vPc +vypLwHMRl8V6AOmwZ67DuE17IZc2QFItuzGbyy+Q58m/XsirGv0ZtYF9ZTIVNfMy +O2ok28yZAf5waOL/zQNVkdkeMVK5Vrda/FApdhjj9Cu8r3RIHU0Sn8WD8XKjRA+r +vyVkH4x6O7VYVqtiRUUq6oa1lpwANHxBcH2dn0d4oiFnIDtG3SYxUh3nw6KnmxJi +xtG4nYZfjcwAPO0A+U9bTfvvMCvAegTjcaotSNyOrKG60wjYH9DF1NC9OkXLL13j +SvoBJUEsVgklwpfHmSg2299BcWY3Qg9WTf9WXOqHJUdMRgI1RgIAxrwjxSDWe0ft +bQb4mJKDBHHsqdboqP1Y4WVIXgHpHxLcagCVBhNonfcZaiOWKydZeQaTsBGErukd +jgiJj/CzK90mqa0WDES+ytZKhLU9I+fHicmrSuShVCYySJKz0BeOA48Z3aQR6xUv +CNHk2/XXKQSNFNfE9lUtzg9PuSB5mHByqwEjUElQ3FhPGnoY4pY4AN6h8zIWesaj +trrhRzYMBoZjoNxbLOH59PCHbEGG6t+R7sowRaiyL54+HC+/wW4TkjVM1N0XQxkJ +8odBsYVsc18Lcog1iokCHAQQAQIABgUCTdQQsAAKCRDjUtXFHFBB1BKMD/0WGib3 +AqNEloVkPrATU2yrt8D9IlC0JKC+wqurzK0pidhQ6XSSPJOfspvD1it5s5w+fJmM +yI5O7RLK10CxcMMVI0Y7iHYnxOlh++DorXWGI5s3RFdmTORgyhXRDTdLHCuHOM4d +If80Cfxwez5fvDmVEMvjtdYSUhdPtqOT7TKFzicO8N9BdnrNBYzOBLx5dybok0Zx +WQTogvfJaKWX8olwSKSfo4Ap9Yd1q/fk7ALWwwmG2CQbPyzun/VJU6ZWbif568xt +Pp8g9II3OQ79ONKKLyUMhtj/Krqe8IavUGK9dm59tiFZpofLgesx5LXokc1D5x6w +QRcmwIsN/KG2znMo4E4q/NBsR/vNvcaAaYZjrzulv+ZKHI4oHlB2V702fcEiwRDt +4Fbvx4oA6CNA0pXkhQ92fPI2O+2rDQnS8H0XDmNy++QkVQKZ5jjZgsZuVjO9feB6 +hwNOW0O88HnanV/BO4c5f6pc/Dp9UMN56EuEBtLVCH94OsDXYVrpn+VRbL4Yyj0f +kMn6A2f49I6gueVrbS/BEiC8TO3KtS0au0fmWIsmbqaC3PhCiiGHBXDhgCXhChNV +lc1hPma76mBsA07899AdbqPzIJRuZZFjVgksIOYAxHdwyrp0fIQOIywCN6Ar2DH6 +dc9MjludOgOUuLqMzmlNjPVXVRjM7c8ll+tZLYkCHAQQAQgABgUCShmnIwAKCRAh +n2tgsrv8/GgFD/9ende25tquSrFdQ6Mo+DlZmXJikjk7UB9tW44F7s84R19+I7ze +1sV9v/wZW1ZaZj11wiQ9Pv0WOF1lsinlbmmmkqXezXgTdwPNk8oy02WY1fgOJw6G +zg8dLW/6HSj8/nxsmYEa8y9ms4ZC2fTZvMV60Bp23KQh3+xHNobX/wb50uQmbn6H ++dYkvcwsMRRNDa5XV71kcWi/Wr7Ess4aau4jLzy0Fz/GLQPCocXkr3VeTGqLDCfb ++NnWQxoTQ2XODiji9sTsh3mpGEdaAIx/yfaezxGISIWDGzTmhXCOgq4BZcdS2aTb +xf6y4S4I/k4zgBazHlJrqQS6IdL+ybzPpwa7PIU4AhlkhYShy4I8MO4MCBJUiOGq +Rfs4pVByipKt+3HJbahQhavI3KA5jtQUupc3+tsRlPczSyw8R4EZ8nRbEVclJaP5 +zLVXasr3AnSMtgIjXMb2vr18cC1B5TkhD6iV0+3IS+RyysfaS2UVv9pyL9sxF88T +fa4SsuG/FdLZgnK749LUKat0I2s5BXVigRTy1As/JULZNYuM8FGoWwTMDMBUNaLt +m7JxecWi20Zfu+kvgmyayR/ODN4cNQRuBVoMjp9+ecoQftsB9nFhOQhHQKAwcCPN +zXGtyRDu10oQdKnn14pLui9DVOxWLi3eg4QOMjuZpm1WL0nLgoTbeLqBs4kCHAQQ +AQgABgUCTc0pNAAKCRAYs/UP5ZI8GIuHD/9A0nlIV/K2P7pDmNXdydIkTU3wMOeW +Wk/l7+CGkhu+ZINnfhUOhIOApxZyxF17vaSD/CxpqaKFXY/RwNEQJ1aPl+jhEVVl +Gu/roEhnD/p3IJuWU/RkuX5HQP6fJMOCdsv8EX7qa4DenWXP9xkzsbpSppnimfsG +23scJzzl61b/MxvSIM8xJslZWFmDTs7oVImKJ6j+Ve4w9p9MmIJ3NNJ0kIdr7run +fphID9+s9pt7x5XdiZGHT1QJDbj5A5bOtWB4MjXdY99ObfdpVG8P/1p1YbwKt+YA +nlJVuPb91CEsHT4AA3wCByz2FWiJYqKAcOCTGtLWhze5wYYwad4ZU/Tzu6WZwZI2 +IVpu/0rs7SlXDNJIuvztAiBzHf7jURjHYMfG+qUTiHq+H1UA5epR0FJ+0DMpgHxC +zPySGWbHB4ejthm420yay1jvlDARrkWaSrQ0RdSaLOXqZ6dImM5fyZkmojJYMsyj +xSCq7xzSR/xXsQdnKJXsdTShAZ9Du4nSDCAiWC+2ntz/NOV9H6SPjX6uu/3EXRaH +iWN56uFluJxkP3geGxb9ayrGkJOPbJ2Nqcklrawj47zhv7neVeA6YIdIhwrmO5bL +iH5NNYHWKyp59cMy5nkFpw2mABlRgkJMR4tnuN+uBZCjBH6YHiZAS5KQ7i5oVuvq +uPo3zkpmAYvtGYkCHAQQAQoABgUCTrK/cQAKCRCu9vGip0V2RVgmEACskh4X28sI +LwI4+MSmU+93qBvRYPaUV/fQMyuLNV8bqu/cppF1CNXpxQ9/IP9nV6ge+Y97qrV5 +if+//QQOFTtoAaahgbufKVVkDhwDN/SOmaTlgloNnc8/P2vJcXWzvjTOwIFwfSlq +4ZTwAbMEE3FihjxcIxW22p0mgPZHxDvqC/swKsJrNbRLDiIXiKPSxS4R+aXrLhwb +Sd5SIANR4TlWQH+WQVlppkUN8/lR0rjvoxoz2oj4inHl/QkMf3Q+5YSIFLaIpGhv +URZn//bGvuetJq0PBOHqCU02DHwKz/8dtHop2eCiDO+f1fJu9YvyQaQ1g+f1jgyP +WZfvGr+NVWrXB5tMaDaC8ui1jk7bl+JXCbRK02cxf3ApH+QNLx5f+RwqnAO9SQot +CFYGsPCr7KkSPnTHUu0lPSWg4op4j9HX57uQJqf5S0zmDevWdLO3JSXNwaN9YPFO +6yCXMcIDeDYiI4njMCDtt3v+3ksstkRtypmyCgItcdHYCPTZ1rXBn3jgZA1iu20L +4XeCU68iS+PuLYbyf8tgq+PGwlahtB9dTLZBXVoZO++zr/R+dIcfFaraSvO40GPJ +Mxo1m54WOZoPkg9oHyj+9TWGRAHpioNH/NNSEh4fWyfhUYszOnOUPiKatm7BiBbb +Z13b934xW7MqzFgaYwjdrRlASFli5iX+vokBMwQQAQgAHRYhBGjnz3VfGMOGkVmE +BuxX+F4WzNj2BQJaQJSMAAoJEOxX+F4WzNj2WGAIAMJHhc1MKWm+jo/+f+7RF8St +JneZoFcrnUimzOmRaGveTw0w6ORId4Tr8RBa+MuV+5GAckp+x4NjglgqaLIl3Cuv +UYionSdzP9DonHnmcJxkeEfx3UJOw3Vh3EE5gM5ohCktlhKOr32DeA0iK16uyM5X +RI1bhQaDj/QNkUmXJD03L6r048Q3J8brV0jR86JdRfvGTHf3OqJ8u2S9f/2n/M+v +WSnU4V3XF2bPGCYjOgcvAG2+NYbUL4/g3ft1sf0+cP2hxCgri/gjnSgOQ/EWkfD4 +BPgC5hQgUJQX43//NPtjmVb3zW10QdiIhTSyRqg9k/AAOKfcqMHziZOsxKZzTYK0 +K0JhcnJ5IFdhcnNhdyAoR05VIE1haWxtYW4pIDxiYXJyeUBsaXN0Lm9yZz6IRgQQ +EQIABgUCR97J3QAKCRDOJJq/Sw1hOQZWAKDos3CDLfI/3NhE9cON8X7uJTLKEACf +SxAQwmpbm525nU3v+JvWIWvZShqIRgQQEQIABgUCSPy/xAAKCRAn2aJ7+fNgWLsd +AKCQBOzVmImsGbaIc+Jv95VRm21L+wCfUCESWOzSau+OSmV2VGOcoqVwQRiIRgQQ +EQIABgUCSPzCtQAKCRBDrP+WI66F0rgpAJ9N39sYIj34M2gWf+WLW5S1N74wxQCg +nOZPE/01mPKu+99mA3x5NZxWLWaIRgQQEQIABgUCSPzGOwAKCRC3Fy1pYH+sUrA9 +AJ42IHb/1tY7n1egjb0Yc6UQeWuAvQCdEOdAiHE59Vtv5zvraRlxBVKB2WKIRgQQ +EQIABgUCSPzGPQAKCRAledqRplrXaHkUAKCjxvTiir+muXaw3QoGKYBmh5uMLACg +x6yQaAXE6CS2pC1jzKB5WlCSGHmIRgQQEQIABgUCSPzIGgAKCRArjjFGQYntJ0wo +AJ9RFkjM3ePymAkItmlEBTryN6Gu5wCfX8iX+d6NhttJ6Gwn5WS8SVPpkIqIRgQQ +EQIABgUCSPzvugAKCRBzYmTFPbeeu9QdAJ9vZFFNK+zMaLOR9NsWvU8ZMkx7CgCf +TSfjO76JUOd4lVGvhbdQT06XCuaIRgQQEQIABgUCSPzx2QAKCRCf8lg+aBtkabRM +AKCGZqaJGTcf9qsPFXOlXVqYPolmNQCfWaRuOjbWnZ55VTiViT9HW3VtouaIRgQQ +EQIABgUCSPz2YQAKCRC7xv+5oCEv5BEJAJsH5432tbSm+uT+I1eFkLvjxNat8wCg +gMbkUTVQccqROCylR5evEiKQ2maIRgQQEQIABgUCSPz56wAKCRCcaVNGVyEyfRi2 +AKDFkJtyMJo9sFnDIer+7p2EDjCYDgCg2DBwqNWzC3MjP958DaypiaVvd0yIRgQQ +EQIABgUCSP2eNQAKCRCIJDXkdn5WvD4ZAKDR8p4WC8EyLVOHYUaVdOW0Siwa+gCg +zqObP5s01nKBc323nJ8U6kdVDj+IRgQQEQIABgUCSP5JzAAKCRB3V+8jgbtZEFbH +AJ4snQt3rmdDHBXoKrIWxVkVr0EprgCfdGDSXY6jYrA7kAoOhMKcxR/02+WIRgQQ +EQIABgUCSP+GUgAKCRAB+pmPusY3SpDtAJ9Uvco+1Koct9HYL2XXZ7JwIcJIFACf +YlvcPyksxafIzvDGkD/LAjZvNJSIRgQQEQIABgUCSQMnLQAKCRBaEaVMXwb8d6FC +AJ40jV6hOJ7qIBVBpHqn5xoWaWhdIgCfX2Ei/bxrkMJLIaOUi0y2janGGp+IRgQQ +EQIABgUCSQS4KgAKCRB6QE+Gbw2u0DkvAJ9pGy4KSKv/9T4tZyInAwH1F6pcnwCg +qi8If9/NgmeUY4oqF9XBfJu2l0GIRgQQEQIABgUCSQ8vqwAKCRDwXkC8nHXEpoPe +AJ9eSJxkvQfFIsgCDhZ7RXz8UUjpjACfaWEFnYhC+DtJAKxiEa/dcXdMAXuIRgQQ +EQIABgUCSQ9rPwAKCRCrv5fSseDQbzXnAJ45s/XHJWwv/Wj8MNREODfUqnI14QCg +rACM2I/AaMWPWIc4ZH/hcSG57WSIRgQQEQIABgUCSReVmgAKCRC4vujciAQUcNY5 +AJ4qRePqiIdgy7SFTSN/625+xWc5BgCfZpN0TMOX58a8Jrj4QehUTNRFVkmIRgQQ +EQIABgUCSWMuIAAKCRBf7TE+0xOifDHIAKC0HY9AECk6jUX/HI+wO0iJdcKHEgCf +Tla6atr726LkTJ1lvWHtFN0HY42IRgQQEQIABgUCSqHEswAKCRCZzeqdpBNbODkq +AKCTKXhtvJKX50pWq7OhdGQ2PsCBJACgpgGEt6AJ/Xy4Q3W5prvU4b5B8tSIRgQQ +EQIABgUCS15KawAKCRBSPhQ3SMjGCZ6FAJ0QRumJDs2iZccQqUhfnCYMJR80AwCg +p7oQcHncvw8UE5GV5DUy5fWmocaIXgQQEQgABgUCS9xJJgAKCRD67xKTbdPj7Mar +AQCxSe9k+/bTQ8AMiPQiwj/JeorX6UqQbttCy7m7u0u6hgD9FJpYLd83z9jbXgnN +htNz1ZOveWTQ5+Vk0GuyXbyAHgmIYAQTEQIAIAUCRuhPPgIbAwYLCQgHAwIEFQII +AwQWAgMBAh4BAheAAAoJENmGaUHqW71xmrsAoIUP47f3p/0MP9IGards/yXus9zx +AKCedbwQrQmzKUZ8C4j5T1cQYbezTohhBBMRAgAhAhsDAh4BAheABQJKC2zkBQsJ +CAcDBRUKCQgLBRYCAwEAAAoJENmGaUHqW71xlGwAn2bZNhH5haiAMxoCyepErCAu +fo9ZAKCjv4blDGd1wcIpAdEl10i4iTwpvYkBHAQQAQIABgUCTdFlLQAKCRCmsfPw +5rX1o0sRB/9Uh1W7poCtzuLfSKOI++mzQALG9LpM16F8H/1nua1lrrQnwzKbJEMR +iZ7nkBJj/8EL6nM1lktX4e2Tt8sr9vaNl8ub7K1cCq2EqK+mYf27vaJqMvdLIkf1 +f4A6LG1ZDdtnm0kc9txB8Aq1H3JpVL+DQx0+lW7W5z5VGs6ijh4I2FtzYXwHjusH +lpqK3CRlw3HY7LGaS+U4x5Rq2CQZLLOzOql7Edv6xnx8W84rK/zyTHR/HmqCP/M/ +8bAEiPOIrKCTbpKU0jfKxHOs3iRorm/mS8kQlDynh5nHmIYkfBF6+yR7lVqyG3tP +8RtRp9Qt2aWmPFP0h6XlSFz/R/SeD8rMiQIcBBABAgAGBQJNzOr2AAoJELjftxtf +7L2Sm5wQALqV0Ka/wkut7Wbw/7h3WKLz4SfpC2tu6aNNWQK5kd8Mf41LFDwEsE/l +aAMLiG0ByIaPIk8TEEE61yCyGE+HlrFpwwZurYzGfuf8RNzAKkLwuHMTxOCagOw4 +9vLjxOA7qlznvCW0SEZ6sw9SkRX9Uf8Fukz7NakyXgaQVL17i2Q6XiNBlMZMklbg +JqegvkeJtpq7kP3EIH0UJE7Ey/5cEGAC/rZ7vto786QuXVXQDUNbhM+AAzoI2+5O +UGjG2Vok7TVsrtQ6Kbr3dDWs3f8nHZvFs4Zeqm8Oqa00j76Rq7f9N1Vts3jv9W90 +lmh0mqaPNisCImIJepXHLfCjguK6RSG6cxjrQRvtP6YFCzrKnccF49GWBzfoJH+c +olSUyefOHSilIi34RTD9oSujecaGLaT45dHtTo9OGNsVihtM8oWMU3kSWLsJ90Kv +WVUYqKH2FVxlO2jIfbcmMYCWEat/x+paElnAqjCHRlSE/88csrpIEfBPnLEhwXxW +MEMvpGRR6m+lvG+PA2I/JQl/Hc9dN0NkFUCkMCPa/yrcrIXHjolb201r10dOCevg +nfbdz8kTSp0WbJnFsCyQfJ1ntk9G5OwXoW2arJQltod32YGPliBza86XUTx0bSkL +FGqS84XSPqUScgvvanUmJkPAmZvSx9GaBmcaArq8vcq0wiIRMhpziQIcBBABAgAG +BQJNzPEgAAoJEOGXASZ2ubc5uZ8P/RuEqMqk25dDF4Zzpnt7PvxtNXS4EErHSYfv +1XrT4BxEdfKsur55M0TYygjusoKdYlFY0HtFMF/4vftQ39MJN2f3AqHHtYYvQ96g +Opf3tZrignkRxOwFu5iWApFYZOSjSmiNF5sva2ua84ZZOxalZTER2pdVKHs24yRH +EHKOP2fqKL6xdyCGOv5vLuBNTitbD2BHU/bbiTZCeAsitYYjQiElKfXlkvvJALDd +h5byx8xuhBTOICJ1/6g0ptH567k+T5UffSiiNDvErVaDe472Y1cwsfLnEEhaAbjy +Ak+C9WUjh87Sxa956Fp10t/Q9mEGsxX6f8hWGkt3oJS4xJa2IpH+L3yvprU5NpTa +2kIWdXTPUebOP0Ufod2HdAF0CGsE5vfMypoHHAKdv2hVyh9aFL6UBCcqTuNTWkJ7 +cmYLmLgzEmlkWQIxfqzI2/eyvJ10FTI2RzNyq6TEFLIoKu+2w5Y9PF6tAPPKee74 +C7u5NYTN+jFPVIu9IJ5ilzJXaodt/FDRhuGKXXaRgwKk1myzBf46Zu1i5hCVh0uv +CFHMtZaxDj07QxTLEhg+VRxunXd0bPeiCOfSdZnKimlFAUPQQgn7cI/BWMCV25z+ +lrLRaV0a1E8+SpRq4wWCri8tVU03tHTOJRac9HVqXHtItA3NgSzE/RCdRrVs8Ijm +8UWRd/Q9iQIcBBABAgAGBQJNzTJBAAoJEIZWH0UhgPz+odkP/2LAxhGusRWLBmSf ++I28lNuNascY1kg6YNtGPvPiX8brmmB5fo/lVyj2yAGWMLi+QKL5Jfe7tzwJWY6A +T71qPlZkUi6uaUALQrarDwkA1z6VmE++yCO+Ew9J5Tds/NEuqvc2O8C6oPwwqGJR +//omBww8cV6rXxNFvlMg7soz9JpSFzzv6BCWdP4z2pmOiFhlFlsvqjL6p5XLgx1e +Mx6LCxPPb3HreJ103/UtArVZ/cLyeQLaaU5iYKG6JefbteQpmtNhMvG4BQG4Av45 +UxtRkKR6NFsm2tbAP7qgo7qTI44Wp4/qBNTdnQ9CjZx3X8kzhFg4P/Xq1ehKuvCJ +rA9+ip+ont82cCJSGeK8vZoWFAuud5UhgDeg2i0ozFMYzvLkdkpSSiwLXjgUo1Cp +IJ89LULoyUBo80HuVD7AnjSf/ZI3m7rhFApVKbOF/VS7KcOgcgG2jNSN8f6w+YP6 +g2URyXqLT8sGeAWH2ct4k9nYCQdxweCz5F00JD7vjctwq5FnhXPRQe/0VeWbt0LW +IMvc6z9PmlJ9AK243jt/BHi9Z2FHp5CXRXfSecKhaWLNlymgp/KHiiPB1FK213Z5 +a23bouYUbF9cGXaX7Gp+hI4Im23V16/Au8ZhxLnePjL9xMnX492nTmoF7+gGSkEL +T7pIy35hTaEb8PqqDEZqx1ExXDYwiQIcBBABAgAGBQJNzVz6AAoJEEXXfp4wyxsR +yNcQAKVcH1AMmnmMNgoQ1eGuvAwyotbmGJW7kyI+rZkWFaSImJDZDCJAM9Nk+UNJ +fl5e8p01g780WD5O0lNBwo92dC9Xyp6AQJCzMm6kCxjbqmvXL1tk1AqrZeYFHeoN +7Wqe1/w7MyTlYkUtkQ9TUgKw9lwr3wUoBykaM75r3w1OFppZyR7mm81WqEqLkqHl +/ppy+Phu5ePKiRNPBnTLMoLzeEQqKI8LgUOR9DaR8A8r69FhLrU3TyqmMat8QVj6 +VhfJlNeInIfJBUgjQRv+IYD9Qy9RX5HXc8oaUWIrJcmIvmBifnpaTm+lqNoaCmZh +5yEqbAJUfb673JqoklFevRC6Mvyt8pYCUg4wWBhV4fYpPBaoy/W11YCH/iKZQJ41 +Mj4o9vX8Wo5sIcZWQvQMWBobyYwZLxu+xSQGAvK/dQVLkjdXOx1xUDe6MqNukAgh +gX/fL2nKkeiw4fHq0ULkVqkHaGkP8WhAVs7Y7zh8o/Zvtc5Xeh7fawVZQ91mcXI2 +iFn1jZbloEvgOKtEnMv2kY1mQP3s7j+hPzsA8Ps9aBogu15s1Q4xa9BhDqKJQqJl +KrPoXCyGReJcjV2/rvHGgBwcsJaJrUY3DAuhb6+flnDpYH5BqOxO6HxtdsSghd1F +9v+vIBIdfWoglnEwsNbUJ4MjGS3fYBUmV7eAKteTo2PvPh3UiQIcBBABAgAGBQJN +zv8iAAoJEGAEJqEY9fvOA84QAIjcJyKYrsv289FLUoULTiIAMlLPPbpleQ5ZuPy8 +xpW0bZyKceU3fe1OuG/sjwgVHZC03/kRYGl8YgW9dJyf7MG+ToIU89yOpFYCe/xW +gOHbrAnglPessiJrWL2hn7jyUO47vzHSMjrYoq2SJxumHrUOzlJVzEHeV8Bei4Mo +RO6j8V3CMWY+74bhBDd0EybBRwJ33aUZQ3VHXfDmvwYXG1xa5Kh+dKrroxrp+GfU +AC2lVnd7oFKn4qyNJqEbWn5LY9MoNnaRQkdJSHxKc+abtd3RhaHu+qNfTBT7gCjD +IqCuz305RJt/0rNZG1TH+ZJkdw9abNSS4kIHuf47R35Nmb5CztVaOr1bJUDieFZP +fF+jJ0rc/A00k+kWcLapd2wuZt7C4OqWie97HzAgFkw65BxGMIlMb9j6hB9Z49dT +i1bVfdC4DZsmA1K5tpQ2OtIEqbjmt+GplDCmPxHmdrAgmb8abv9oeFKdhSP7JgK/ +rMLYbPmdrnUD/W/SVW3Al/rHkiU9sewADzetzrBu1Qi4EqUkYuf2CCkO5Kq0iAb0 +fxXo9/T+iq6yfY7N+TXjpraNvabIBiLs+HgDKSaw6aFNZkyF4mbVx0iZhBXqSykE +qyAzJlTN5ofdIXNtg/lc0rOJthdqbNDjQlCtXr9dISwpaqYaL8iSW+VRh8oTJ3bj +B/ymiQIcBBABAgAGBQJN0XUKAAoJEMY4l01keS1nf78P/2L3otZJOhMewnJkHaLc +fEZW11gujqvrMM8GJaS5xxPN6UwxkL4Xf4kHbWUQ+EN+ndVetJQ8xrAcEUhhmX+/ +W9lD0vcal5U5bs7Mj1qCwl23wAP3AHAaRhB7lPsctTc75ReTIjk9OTWimoYA1ImG +tUR3BB5dW+lv5K7xQe0Cl8KJiQfYJPUw62+3GRJg6VMMIUwUNfclEDDqJBhWBS+S +K7ia6R0e6CWCP1Vzeb64HZKnSRt0qw6xLocMzu+Fnru4k2pKVPGA5506VFGFdCSV +fIORgkgKzBWm6MnwAuFJfdGufYhX5H1nzXghjHdqhl2FQbWsugyG5KWUpCLAptI0 +OibnbBckcJK6pijkZt3cR0yV8q9Fg/HNH+jbCFPYdUhMRR9WfCBIvwAoIvXe3EWT +lt32fddXwgABylPXy2TYvanaWzbv3KugbCixzQXlHd8+cpRitWs4MZEoFwLR3Eah +hxI292XtZcihSM98mjVhD0S3upQbOzIHRtWRq4bc1NoDxdnR/5T5JfWGcvsqE8gn +I1nyy0t0PSx/1o4mb30BHJRuQCQxBCyxG+jbbiHmqQt+Y5sCq4FxsE11g81DJLCd +hLQpM0zG0GOMPzUEYZnzdJriPEz9lV3dO9qPrqwU0GdT3I/45NT0pTIegQRgfVjS +bZYUP9O6SCRoMZXgy7jp4Ga/iQIcBBABAgAGBQJN0eanAAoJEMEmM+HuAYyTadAP +/iNy4do0+Zo+/j5s49jerrsHgxuEpHC6HstJR+uVhPq0ssE/HfF3KDLnyBP84CLr +3/v8mbH2L4MXqA/NZHfrrCw/lR1xisrV5yCaiCFaO4IG0JHh9r1Kr5TDaJbFf1kc +xItrf5sq5inW9OM+7xvwZ74PYJ4Co1EcT8Y1cNQ5HtAKYqtTHqM8xPQOlisyJSzV +vGan5uGwGdghkMOl+NEynz0xVnMSM8BXzaj75cSNoBPCpx4tkF63OPpBUM5uM3gO +jXYfDu56615992n2auAR+tD+NKk6X9krOrMKTUDRMVvEq28Ftpnz0HXRfNlMAU5L +AJIMY/JNNsXNjTdQQl4IFsZtz6RhyXPg/n5YLEV+ZPTXp3NNehq5FYcM8ZRJvpeK +gTnmsIBX1ejK6pYOk5atzO7I2E4SJ/TEl5LD4j5OUrM4tl94kqAduwRrRB9jECZA +m99XRQfRM7VmVa7nWFGDtgOagqNcoUwR3NQ58jtZ9ilQxoNzSlyQ7YiUKZJw8iQc +kMOSWrfyPF6+Ii8x0qlgrRAB+T9DiIqZhd3zOOdIOeDXnMwKcb7MRbDhQDXqk11S +5FZUvZItzmJLR5Pc40+voB0+NLiUQyYllDzhxOfHoj5Mji1G8gDKvcPlo4XuSufO +y1/HFTCywKr4T2b8t2xIQZUPQnELCSo00SQkpS1Bk9RjiQIcBBABAgAGBQJN1BCw +AAoJEONS1cUcUEHUMO4QAIVUS/uRqIfQOMQE9+ILuhntdpP21BsVogtmkFZ0veUz +2kyIrnjmy2F2hMI3LDMsgWZPNygZ/DmfpLPH6kBdOuTVN/QpwNanmuHADcfI70XM ++NzimVKM0aMuYy/PtIxNE8ILThDE1S+VpFSn4BUEUouafJZUTuCp5PPiAhZQt7u6 +zMxJLgqRFiGwI53NXXG9GOw5KtEPZdEAsIzcdceLFV7WhmPDFuM0WWD5QYXDgkKr +6JxFZqprRtFHMZXpTcTnYFAUVISK3jOG+RQAYDwFNjWQ3FJxAYgp0uMPkZo2/pOl +9rqd9qpqI3OTJY4jRLRP44pDjSZbjf+xUNM/aWRyM5NbF/4M/FqfQDjBoqq+9BGc +2KfX32FKsINZy/UWfOaTPjY3UENYXjzfiD/Zy2nRd8PP3uBxG9xXcdfyRglBx2bO +AJ+/3xpgcaC36j/SiKw5gvXUupg6SJmYIq06SMz+QaJqyoSNhF7js4CuMAT+Wh7t +fV9cauKvGi31Ir1XSOhTEL/3rRw46vZDbS4R8DYW4KsWIpSeXGv5e/ewsGjbmLjd +k71hlqj89lrpJG7JzPzzqS5+Xmr/+5hAqDJOEPv0EHYy24Y9O7zh1Eo59eKlEuhw +zipOp0RZvkA5QoxqDMiZsMCuKLkosIWNXdEQo6cGBP0CNpd2Bt30dg3I4Mov5G5W +iQIcBBABCAAGBQJKGacjAAoJECGfa2Cyu/z8QccP/RAkUZ0NmRLZsnHq9YUUy8Sc +x+ygU2e/Nvvhd3v+IWPBltoM30afjDjaOotLg5ny2kW1Cv91VLg9eJ9Pa1e3w0ke +CG+fo5ObErk6dS1nqaLFNqpFXC64Uv2E3b77M5ErfF1G9hsidystc3jvhpZ2vu/y +7NsJfeiKCS4pxX3fvrcIn3zhXblWQ74HjWIMS10SBdC3rkYKdLa5B9vTiPiEj1m6 +mrtG1th4ZOgsweRxi/1FvGT9iz73GFBgTqBex2QiJ7q5kLSEO3iu6HpoDdOSghxp +QSTvWzdLQg3xPi1PX7TkETXtF2GmDFZXo7MQkgobNH2yNIX+Mh+k1pckEkLjfc/A +3CC/l4NPHMHxx1Kw4/ZczEWOJliTgGz0NObq4JkX6TWbno1Cy0K8eYx/14t8cduP +eLAKMhp98NA0YkQ1aGY5USn1+9OIByyoYYMCPYkL25OBWS3ve0dkuZMW/P9KhQwp +G1+PHDswipj5XGO/0moOHevnVGQ70U64z/KNv7hQPTk2V24Pi91bzy4HijRCuuxE +itn7pfn5b3uXjIBpdBlaS2wWT3d6rLpYTxG0lPKSRXrhoKuHmOUEaaj/yAV+9nHZ +FnMs0QhmeG2ZlsplZdPeF/S2CDQDM7dGyIpbOjgdcj4SNmIfJhQUnUnjGjwPBQ+5 +M6oPvCc6/yf8b7D4nAf0iQIcBBABCAAGBQJNzSk0AAoJEBiz9Q/lkjwY88wQAKPH +0grD9mTQjNpG/JPAXVZZjteEQhbDej3bfeiOebT9dHWjBKMTueDxRDFDmVRi/Qnn +LscJzMLXPMUts6OQ41Y9VK3xaSqaRa5zJKkTlNPsfPjv4+nT7kxGhFM6yG8nBcRo +BHElsJnk9NaouThMDJn3NNdliQC4OBPH4Kr6hyIirHBdLiATOBIfiaf3WB2uT/r0 +NwdzZqtmednyTdImQDR9VWFGC2LH0YRUFE8Q/7hcVahDl0NT74idYl5079jZeOBJ +ZFdq19E7ypF6t1dtlknWi37wb2R/cruME2NHzH2ryYp/e/gO0QQZjJIXxYL+dIQy +dCsiy7wX5J0zjrdm93SsTfvYEeZIq2bKuVbGIYxSjRs5XgACyTirXpRwWSrqTKMD +KaPq6YxVFciM+zkARh/i4h37bo332Rd7E0w288/nzUBBpD3D/jPJfyhd56re91cj +Ez4UZzV8IDUvA/azH1YgF7HUZz7za1RBEp6ZfYpbYVJw0FkWizpHFvlJIlbHQBCM +oT3kr1i9UHA9Acwt60fz6LdAzSe9t0yFriyDl/E8b5792zfKQ5eNk/hyUxAb+0M/ +h5meHI9AyfcLADZe0gmVMUzK1nJng6LA86l1SeRGIHIhEZZ1s/7ToQWYCxni0XEN +5Pj1CfzOV9ksKd9IHeKJnH/HP2L24Xw7c1zysqMCiQIcBBABCgAGBQJOsr9xAAoJ +EK728aKnRXZFLBAP/A+3iVFxayFb1s5Lomm2OgoCyFGmIUUJges8aJYbY+yupZQg +KsZoQ0CPWflXcTcOm32t3l58M9bNJpLMbLM/OJUcD5rudyP+qL+Tmk9MTnXkNBGn +EiUl+UU2F7/O6y6xJLUSMXkjdnnnSjfWdtONjXl58JRcOJE6fGH9LbEvOFcFcmg9 +YaxFtxd1dOspkxZwxVRBwXSPwCu6Nq0sj54hCEZPSOyzZeON0RDB9kfSl2jMuxGJ +ROJBkqbRI+NQOSJWUYbRBXdBI5eFQAxCsIu7bzWLt24okY3DaRwUXDeXEXJLV7Ph +p88l4E4nOk3gKzoyCjDEQ06M0WBe499X5WevKc3oM3C7mam3gpRhwLqUm84vQ9hv +KFAvlM65V4kp1uVAzNJ3/c+b3NghSiNXBOjP8FUgpNpUjt0NSPKUKUfKWzMaVq3s +tX7ITSOd6C2gmqgo3SzxZ1KcYg9W9oDj5xSM9/SecpnKVAcehweo9mSEc0vBLjgy +7tc84a5Ho4VnfsNf3pc1t7//dokxqZfJibbQ7f71DTymzjq9veEmO3V7X/E0t5Gw +80gOc91ax5EEDrlCf8B/8ZKHyQAC45+vEpUBvIsOlPo58cm6mzzmpwuWTMBRV6dm +2DFhQMYPRgElPEK9DfiGnW0+G4sCdUhL2AWoeyZNKRpxIja+GPn9nrgxXo64iQEz +BBABCAAdFiEEaOfPdV8Yw4aRWYQG7Ff4XhbM2PYFAlpAlIwACgkQ7Ff4XhbM2PYS +sQf/ZLHI+8Kx3m4Ohws8RmR2nmqs8HUMLsQAZvglTgtFyTn1UX3KnpVjlRea+M5Z +VWyP1Jc9GwP7NYiu0zli6EfGdlUDrg4bDFzUH7169smB2PTx+0m2XlnnwAzTnvPv +yskjyXgVZ7aMmShvN8XnxLfJVr4PBnh+8XanboH86X5mqYRZSSFxz9ETUHDRGkwh +yYpFgcHHOyQQnwXPHoJglvLQXUL/HyeT2wkAlYJ85bxQodmZA++HYgKAPOJhezCZ +In1PvlT3UMNrGsEUnzLBhdPExMptg87/6qw9zEzIJvYyJzlPtf+nz6Raqrk22eDn +XIB8iNcW7yHWVgnz+xn9JUVk8bQsQmFycnkgQS4gV2Fyc2F3IDxiYXJyeS53YXJz +YXdAY2Fub25pY2FsLmNvbT6IRgQQEQIABgUCReE0IwAKCRCHzvTY5vMyx4pQAJ9T +tUGW2F5rc4FcN2kjwdQTrDc+zgCgjUM/hyoDfELXULVfQT9n1rsH+/CIRgQQEQIA +BgUCReE3QwAKCRAD18SnZ5GxT6CPAJ9gQ4tW9POlJOiXqULG/yFxAXM12QCfSyGs +rEDkxTEMpzzv22DKZCo7j8+IRgQQEQIABgUCReHmLwAKCRDgab9yRUPVd4PUAJ4j +gp3OjFI/iF4pi7Sby6WbTTq0+wCfXUxUoswWVa7Pd/wbJjJzMwEO2/+IRgQQEQIA +BgUCReRayAAKCRAZrytUR0IRjaLbAJoDno6aguddqZOW4pJdRHiK2uoZ8gCgphC7 +Kjxlfdg55zPIRaEkHRxdBfeIRgQQEQIABgUCReRa2gAKCRAiU7KaZmQ6DBPkAKCp +jPjfoUEHKPx8ZNJjNSeGXFfSNgCfULrpwGRzDtH4VcGVEavPr8WVoKmIRgQQEQIA +BgUCReRe0gAKCRC+JgGRUfMklq5VAKCn43SubCN7gsdgCzhwcRImmFb0pQCfeXpD +qORWwcpam0vDQt4kifC/4feIRgQQEQIABgUCRtc/swAKCRAaLjeKYIwBEqWPAJ46 +vNWgBfbfM75f6ZGV2jJdGyWAKgCdF2H0umjdfqlpI8abBlhy5EeK73+IRgQQEQIA +BgUCRtdA2wAKCRABr5PZkc+jTYsPAJ99ORiHfhgE0o+UHe8ZsImnOqcLHQCgyDZY +bibu0uTb7wY2YdYnoW0J5f6IRgQQEQIABgUCRtdDRgAKCRDJUFw0ilEBLbt0AJsH +YzqgyNFUmc3z2G4bc3ixC96GEQCeJLs1OlVcO+7U/juhJLH9L1+EZgKIRgQQEQIA +BgUCRtdGCgAKCRC7xv+5oCEv5CwuAKCQaaNtYEyL+mewAcvRk9Z/h8qQmgCfdSmi +qe5juVNQntnk0GvqbDAlbhyIRgQQEQIABgUCRtdhhwAKCRCrv5fSseDQb7KnAJ9y +EgCcinSECKVprvM9nEFM84JgjwCdGg6pFk1ds9BhtrjuWxXu0eZsRDGIRgQQEQIA +BgUCR3q37QAKCRAl14EJhI0AA7voAKCE7AgWGFCEdG0P8Zsa6KyMVjr8FQCfbGxV +h02coq3Z51/5zAQ4twL+5iOIRgQQEQIABgUCR97J3QAKCRDOJJq/Sw1hOQkpAJ9A +WLibsvjpcQfnKxOt83o1QVqHcACg3RQ+QdbV5TufNGrfc59XFDxWAlGIRgQQEQIA +BgUCR97LTwAKCRB/ePSI2jFIDULkAKCgqxayn8W6c62DDVDAGG0UicGvYwCcCTUT +QQRuTVCiukXSIHBJFaWJWjyIRgQQEQIABgUCSPy/xAAKCRAn2aJ7+fNgWEiJAJ9o +KWVKoDpHNQlXMVRdfkdccVTqowCfaLuGEOFeI6zgs8VsWHjJ7/tbgRCIRgQQEQIA +BgUCSPzCtQAKCRBDrP+WI66F0rovAKDcL8c7AIhO0bWNhxtbTB6tUP/XUACfaB3/ +XfEl4AocSN/yPTmQ+K0hf8yIRgQQEQIABgUCSPzGOwAKCRC3Fy1pYH+sUrUdAJ9x +IOxYk7y1pPtywuJQUDh10aXGaQCfWNJ9yP0INXXS6OWVjbBGrES53F2IRgQQEQIA +BgUCSPzGPQAKCRAledqRplrXaAkPAJ9r5yyxa+eHdKdDT9J3SlbA1gx0AwCfc6ux +Md53fVSCYR05C0PE2S04bR+IRgQQEQIABgUCSPzIGgAKCRArjjFGQYntJyHFAJ46 +GpVTjVowtOxUlucqdoQZv9RNPwCfShiigjWkjy2PHJnzJX3+hjI6srCIRgQQEQIA +BgUCSPzvugAKCRBzYmTFPbeeu9nTAJ0ZUTUdgCMsimqhYm3tOkyt1/LtdQCfYTEi +EcxkSJPdlRGa/2qKJjZyaj2IRgQQEQIABgUCSPzx2QAKCRCf8lg+aBtkaflgAJ9V +mcrQxO0jfBfWBz3DdwCpAzBNmQCdGyW0fe7vvNw3Oxn4ajTLyhTpVsOIRgQQEQIA +BgUCSP2eNQAKCRCIJDXkdn5WvAoAAKCiIQswDf9L0RIPsAHZGAxspcunlACgvVhc +4OAgsruA8x0zEdo8eAMzAI+IRgQQEQIABgUCSP5JzAAKCRB3V+8jgbtZENa/AJ9+ +eLp5LHf43+nr+u/QkF5DNMz6FQCgulop4w0jPoBRlCfczfSzshelhz6IRgQQEQIA +BgUCSP+GUgAKCRAB+pmPusY3ShRjAJ9AAZ7CfNuUav59i0oBG6N9OaMjOACfTHw2 +GHHJmHOrBl5lHrPZ5V2enS2IRgQQEQIABgUCSQMnLQAKCRBaEaVMXwb8d01dAJ4n +iCri1bHnhrLjl/tYRk1UXuP5GgCfQtAFDDnZsQL5Cq1JwINOuXwkMyGIRgQQEQIA +BgUCSQS4KgAKCRB6QE+Gbw2u0CJuAKCZAk0MEZN9YmwBU7/9vkp9tlId7wCeK/JK +f0phr/Fx6CHkaH7FuBs80nmIRgQQEQIABgUCSWMuIAAKCRBf7TE+0xOifMZoAJ9d +e1yCDxaGVMJ9o0yuHO8bWngEswCghsqu+C1D6z5EaQx/bxgUFs0SnACIRgQQEQIA +BgUCSqHEswAKCRCZzeqdpBNbOG0kAJ9XjU1fp7PuLC2HmXbCusPd2UV0wQCdFdLf +Aa245dgOlCNvJ4mjMELBGKiIRgQQEQIABgUCS15KawAKCRBSPhQ3SMjGCeusAJ4t +H11sN+OSsSQrSq5gJDPnvT3jvQCghIODVOVh9vPD4gTYowJTYUKmj7yIRgQQEQIA +BgUCTLN7SAAKCRBVW5delTuGkxprAJ9iyvDRP3CpS6PnS6s1XgkuCWWbPwCfWBCk +kjzeJGtxrjFfHDRDLepcaHmIRgQSEQIABgUCReO62gAKCRBOLvPenEYe8+DjAKDJ +tlRsSkwuEH3FiCFGMBtIXLKYSACfRUq3W7b6KTMSwykKpoBeQ3iao2GIRgQSEQIA +BgUCReO6+wAKCRB7xGApKRaddqrTAKCdDxEQCoOM6S8IvtBX1mhIetitDgCeMfzY +DvhQVUqBhkpoLhN7FTDf/3aIXgQQEQgABgUCS9xJJgAKCRD67xKTbdPj7MqIAP9G +ghDmqsSBPRuHwNsD0L/wq5SUXasVkiud2dc4OmF9/AD/RPYXQ9rxXwSq3FIIVDTp +vvdQfLZTHmWdFufcIHfA1hOIYAQTEQIAIAUCRczNdgIbAwYLCQgHAwIEFQIIAwQW +AgMBAh4BAheAAAoJENmGaUHqW71xM1EAoKAxKW9sgmSjW6CKDf3lU6DBT1S9AKCA +PxaANymJAxBwS3aBFn/GxKRLFIhhBBMRAgAhAhsDAh4BAheABQJKC2zkBQsJCAcD +BRUKCQgLBRYCAwEAAAoJENmGaUHqW71xkbYAoIUFAVfY19cMjk/1UlEDZcCC3c8a +AKCV0J8M4WjePHUhh6v6FdSDyXgnJIkBHAQQAQIABgUCTdFlLQAKCRCmsfPw5rX1 +o2CPB/0ThSBL3sechjvh0BpcuLCXKbLv/6Mdu/+26aRGogfhzne7uuQjB2TWSk9l +Mp++9MaZRBAKAtBndNR5xDz4rs1/DB5wbKCPDGFEgytEbl3IPw+EOPvI/evrd1vn +tDorrrj1xGuSOa6e9JEeNCfRt6V7v6pKj21mLnLdb4swuULvZAEF1yB/Yb/JrTBs +aKNzR1luN5MIOuauJy5tQMHdn64udK70IkQrHeWTCP3D8qDlR/YKqwzIk7wmgsGX +447k+4LK6YPZ37rAcRH8kamvDRjqZIP370jNDB4rDag9xDgzO4FA3EoMI8Qe395q +LRXlsOE/lZyk9otqMLrLzByF1v8LiQIcBBABAgAGBQJNzOr2AAoJELjftxtf7L2S +WUUP/jgLeiOf9znQtulE4c8R4IZ1dgCL0ByAgK33F4bo8GrpuGr5plSyi375SIvf +AarmHf4P0uoBN1rCwr6Y3tIFAhzhfgQWAzNpn9wEbMS4EUMepFGAzgBlCu3QHYsq +VdkyI/loiOq+jYZ3d5JQmTiASVzs4vkOaQ9goDNTK5sg8hDvZVHJwk9FWvgb2B6s +BihMyX1Vq2qDJcJiEp7oFexCqr/KjbRDINe8gtYqaGSFrlQjVKrHCESi9JSr7NgT +/ams+JmHMdjDZrcJbndJhKiRX5BB5EBpQLbcYUwAerV41RxnowGaOORqpLOfVjP3 +/S1lllYu9viN27xkbYsVSC623HDN6695dVzBrca8hjuWvHCQsS75Jrg2bJedEmh9 +xqPlkJuZdp6gPSBt+9zM+JfZei0TvlUmWZbfVS1WiiFd6dsle6PppEGt9ZCVDKiK +GqOjulGChkVHnleNJmgwFVbAtNZnK1KWfwm2zEMsc7hxv9ovXo6/l4yPViPntUMF +JUs670NP0AXzEWyflscUt/EopEYUgZZVYuUj7WTpUFs5LYQjld9NeV1VhYhFKy8o +cwK2YOdrtKCPBY9Mh2chas2tFJ14++cSCwhMHtmeCIm+3CMLGyZ0X9zRLuSWsKtk +Qib4Ne+PYdagijDf+QN3UnHp44FZzWzTPRnCwUlV4DcPsIFpiQIcBBABAgAGBQJN +zPEgAAoJEOGXASZ2ubc5SjgP/2hBdFz3Peo6ETnFZlG+46gzQYSSCrS3wb4aFvUq +1OYWz7oVNc52OWTKEksh4Qh9xoPBC+BtukKrsSjlKWm7xvN0wCcd1NIjB11kH52C +EaVTVy3x9pwKwWtNK68+tTTzGzDaIKIN1h4ER8b7hIXgJGOM2I+e9g2+CMW7UtOW +4PjxhkYUBRP6zVkPLbRqYGoaqQ9Hfi+eVEEggVl0oy8WBq/xhxSV1GddxlF1g4fz +FIwpYCc8yMf0IUD5IDrO09GsBYPBVT4QJTaN1WZG4eevYMPMkdFlIg8tXq7c0g3i +f/efUbOKvMVVA+xHN0aiVqMyApqmiPFUBVAhhiJ0kl1TqUK9fN9z7moXelQjp8bf +uFWCWDKD0Nbq27kqlqzDFn82GEFfnEakKKi8ARTQgDceVkGUNfglDT3OTrfjCxNx +cPW1WVl6iBllMrYmrUtR13B+HDsAwGwoA1g5XbIxwTQ86EX8+K3w5rzFi4qSUuRu +c1G1VOae0FnANlHRi46xR/sJ3Yd2pDRIwVUytjuR4DXYN1vQugUFK6crEhpW4Avr +FhDzIMpzGCZ2HKqs/hjqFwyqNjOjvgrPt7w9ZsqfsYRFAtVbFsZxi+HuH0tlDwgx +Eh9fG4LV24rj+Kykj9emJTf64YjxVJlxMKqnFZcq5J1nnaYbLOPVwScYLBObl177 +WzBxiQIcBBABAgAGBQJNzTJBAAoJEIZWH0UhgPz+XawP/R53F7F3tEdhgmvLjfUv +W9aTLxTSgnZtekU6Ky9SJDNl/EMls89SiiVU4VZsU4t4ArHtZHJtYvvL0LjiDk82 +PafULlH88We9AX+ycaLwJWa16Gk814XM3lIuB+aMkNbSd3eVtTXmp9kX0QpRYOki +89VSjBcsXvZDufWs5AQaKXGsSDGsbQ61uwE0F923IYf8wkboM41HYssxNf9ehlGl +bBtsxhytAv/0G16HKYkK7tOXsfwr7CLg95lWNY8JDAV42kNOMRMbnfhXeeIw0gA0 +d6/I934bQYZ/GPa3g3lDHxveOuv7zRa5iEK+a6znenuU7Q9GUeBFpwQoktnnanEJ +2iNkW/g7o/GWdx07hLJmQd12TxZpxzbeucLooAnlzIaxjd7aBrZ4p3+ZalGmBaUm +zjT6OSE/xrnyBRBMnxUcOf7Yw7YrsJjBmRplkihU6VKKxEKW4IRb+3H/FsOzjJ4M +FdJMxLfecWw6BJDuhq47nCGAYdVApbhd2FfTlHG8KyvzBxFvzyoLyvL6pnnnvaLl +nnsH67rN4T0QDplVCNe23PSWWBQDr1d74K636QpBvGH188C7eqYjz1i7kj1UJVb6 +BwS4fi2SnvO5g+LVdUIjzLTwPt9ZUsIvkdX6Df0ZOqNEDJyVMpknB7bUAxpvyrTG +7tHSZ4H1IYiWXsrydYvPUtbciQIcBBABAgAGBQJNzVz6AAoJEEXXfp4wyxsRfVAP +/20Jeu0NG+8L3cW0/PXgxOC3lMu7kxNprKNPZf4BOXrig8tfDiRl9WaubL6UQBsJ +6u5Kn1fVm5kvNAfHp2DcYt4zl44c8wwAaYu5jd5oAXZek1p2Ghlr1Dtugylhixnz +3Crp3ogQYYpn3sNNuwq2NHy2RZiAsEuQbdzeFUWHOKmBoeMgkzIT8og6mk56W8nT +IEzCXlVB+bTUt/gmrzgYIEccGDPdJEto/PqAeWV+Mo7O6u5ww1CgPndoMq9tgiyb +89bcaePoYvl/WjggsbscpeGzUAuz4f9UKdziiNZFSHJDzYClQXiu0sv2okHIr8kB +vvdV0x+xXapHhgmdf3w6mj4Ab/jr6J5W8SJR11/Svto5jFSYRYo7+Xogp3jLX1lb +IQpAz8XG5zviY4h13q/EqPF8OjPFj4y5abtgstHhOqdZAuBJDSrKhut4Ash4Jm0u +UE2WBau4YYAaMd8AbQLhO5BTfp6aGOwxzPe5E1iLxgl8/UE4+bj9Qhe7UXRaaS0+ ++3E5LJY4C+q4xpLaE1h3YdcId4RohDJ4SuHHvbpz17ZKlkxau04i3/MVQ7MHpUhO +Rd/1ZQ3yeqwp1wPIinaOH9X2RUtLCZpa3WbdAWyNmceIdAZwhylZ/MO/aYPCB6ky +FRDTaPj5zUYOAxdHaNp0OlZx2ntj6gTc3DqMRdz+P7YRiQIcBBABAgAGBQJNzv8i +AAoJEGAEJqEY9fvOJ6sP/05m2ZyNeb1EqoiG5YgCM7KH/+NCFaGCULHDoDT09w/j +RBks9ILTJYF6/wIPanR43pAVMXi3dL4/TiEcw3bm/89e3seNQQeLoaw0tLtmTaIh +UH3X2WcZhGlAjyFJJYXgD7So08kEBeCYpQej2kNUYLaqkbc+FTZJ7IQ3TjMsM4n7 +HDmWVQDURfGlgbYHZYgEoeaPS33STcgqhIvIQ/MyZVpcCwnPsFQoRhkGazzkzj8c +ltYn3uiN1cvLcMn06rZJOMJ3kXL/rQ/3bvhdVeTLL1cq1PjDt+i1Ut8mmnfyPBPH +Kvo+AeLdqyAXId0BNqL4oq1yJ7uHpWYLTgXx3Jx0imbarMwrwlfD1gwLI28zqWwS +dIz6DlYvvnzkvjVDGJHt+FkgITGCMgpjAdkMUZltcuPL3+c+d1cP77k+UnyTaD5F +aS5Eqn3f/QBgPUAVdIUF7Z8+HsaWhD6GDI0P93Z3sqk9yfNC3vl1fyWsueg+ez+L +UngGwuz11f80SSjklE4lJgaDqFBxDCxf3F6amNYMVOdaSsxBERbMX7gAQa683IJh +lo+UTtZb4EBpF/QxSxxZxxJyQ2NxhXVdIDg0E4gsM1ZaqIKRIv9OF6F0xAbRXXl0 +87Ry+NChfjRT5aqS5/uPY8NXj7SWAf/fPGbaitXrwK3TQhQKGzhyMzBdSfZ8vGPE +iQIcBBABAgAGBQJN0XUKAAoJEMY4l01keS1nPLMP/j5g/Fe3ZEIQUGRj/REAI0Oi ++Dm3WcKXDuyVIXMQ1QJ8E/Rg8r/GNwNYAfyo3nI/AZaaoGxgv3UT92BO6mAxclLV +BG05iGbtb4t98i6WsA5jENViLZE7UslrNwL3qLdc6FapEz7MG+RN5Lp2DWk2eQ8Z +VrrOtcdmP2+FIsjFrkR5ab+1vfEXspJZWoDHWmNxjQtDSTobQDXuemWlxGAptCMl +hvR2t6OY0fK7NH4XXeA+l/LFQgTWYRJafyGGUNlqrPVyUny0gl1qgDraea1LJX+i +U3oHASwxWwXYwHZBIobivYQPBIk7iDo4Rsg3x4K+Di2qZUfaJgL6Wjj4QyHjO5aJ +r+ZRSMXTX5GXxGXCDJNMzuTScDGilK/IfPj8RYhQ08zcQEIKfVFxAToMQ6UoFIgD +OlKyNIDu4JxRrpRqw6c7Zn1Y3n4grTcDZwG1vRnoY6mLIMDwDtR5jg0CovHPERKy +jRjK/gO53KOkj4+m02H2gK26pTHPARc1eLOSrCxpRFyyxF93SZm0dXzVfvpS+FUs +LN+1CsFKOvzXxgtcYbwKPGcm6WjjBCOv2poBog2rIFEnbOOeXZzRQUCHUnBa3GIS +KGVA5ci3Jpsc/oGU+E+pXbwm3ys7yp6rtgMCU/w+YwKj8ZL0jUy+bfxYk6cJGkk1 +RBKj2TERaBZlUI2ax9BYiQIcBBABAgAGBQJN1BCwAAoJEONS1cUcUEHUkK8QAJg1 +FwmaaLz2meLzEY3LLFfUkY8YiGigGkDwiV/dRsJyhl2vDwA7BNb7oCmXy3heCN/G +eKTBUkXBMHNFAMdpoQLe6ALel5yp+WglIhQxEQxeJI/2tEdbby2gUDv/TGUKJrxg +BG9SmXuP7W0pr+EKjwJ2/bwU0IeKrHDWCKGSTCPfPjUA4yKSYVbjiounvlddItPz +vv5ewTCEqYbhMOAh8pGw8G2D86fhwdfRNC8zTC0UT1lS7ZIXxRS15AOlDMQ0z+QW +yUl22nc56XyFg20ULED8LY5VqDsQfDBu3BPyidnfPRdl+K9sWZygcJG8NWkBppuV +SCwixa2bwH7GpJMZoMMDAQKu/TbqhNPhVj3egNklFiy3xqxlyXsprm3RJf87Bb5D +RnGYs9QstTZdY+yH/W8KJRxDyQGhkD94JOaYSzB5VbJh68jiguZddXjOiRURezZA +LOwwvYClHphKlpfzu5JORjWooDeggdqjDJBEbmVehlEAW/gUPAIt0cUtCO/8JE04 +y4owQmzAYboc/s3vLx9/gtFz8gG/rk5VHoK/FrPJWiA2Ojr9dZcIaOQkF04cXEpf +AEogQSCmjYxpragzNUYmZNs4Q+qfVgdIoLyvZIn4/o63bjCd3lC8A+YzIoNxgT/+ +KsYr/+oV2mcjU5d+NDibloHhH3WGgPlg/Td3os2iiQIcBBABCAAGBQJKGacjAAoJ +ECGfa2Cyu/z8vMYP+gPsiCs7GEe3RN/JfLU8sIq0WGemkjixUrlrO3Y0J9CLM2Pa +S7h7clkudE2MV9lsQgZIER1hQotdEnp9Sm6Gnn1eqceCJJLjloqLMeOpnMTjpVys +KQtNkO1ZG+hj2FgSPDIf+HOcrhGYqok26h9BxWspYwJd3l8pZ8DFPuA24AqMNLQI +DG8yzEse0a37Q7zkiSvHHgE1SKm6It77fJ0gbcpDJ1grba66PsGRsjaQQuMEv/Sp +LSEhmLFA9FERnkyIztruy25lanE0w3x74sr36sdXt1+irYAlB/s8amdOzRqnPfxx +YjECZbD/x1eEtzmPL9i4itz17BQRvN9QfEqx5MJOMfyQen7qgiRNr0OvCNWrDPFV +jLONWd0rffwrATCq6r+TtjXnmGrzLPSeIHV2C7ip43drPcOUdjWEDUphcYFJKoPG +If2s9/7oq9159Xnwu56lEWeTuEkpyCMvFFY/2aYebHjTraWBluvwRQqVp25cCe6C +9aLRoC5AZjnwI4e6xf4s6QQXWtV+HM7rL+IsbsS1cedsPmBoISzuJ7px5fUuNB3G +fGUnLNGoH7zFKZBaAWxNSBbrKw9aXRYIqmWdd8jXgq2VejUKEgTsLMVVDff2hvEp +wYfZHrVGEdkfExXdnr2wtGdlSSCq95rTRMZ2jGET8quY9Hds3NkG6AW8D9KNiQIc +BBABCAAGBQJNzSk0AAoJEBiz9Q/lkjwYCb0P/jACnBAVAZhyoNYADu0SE/qPkN8o +rrsXpMlTM0akQBdpfDFbf4T3UO34chPxtA/d24J+Wy7A+Q9xuDPCpdIHC8cXbAGX +BP1NL+qTMkqMqJ+bfQHVn3SeyM+x6AZyHRRUBbcEeJXHl/cMfDSnMZa4eKPuyVGT +VcOEv7E5EwMxegZNNjUjzxGwbZWMiOkVBLy7sz38Zs6y89u2ngzVq/TZMxorVcSz +u2Wk9JbkvwFY7TTfgINPl8j7pBrojhiVLhhx+3zdPLzCswfbjlWUeIBZDMCNHs7b +xKRod2YloKTBqZPtkzjNZrJqNQ8O1lb3XGTtGf3aWxwb4hRwK0Tqiui4EMbTjd4d +DF2bRPZBD6rOCRK498UKkLBwYlPRD+yebFGdRwCsrd8bp4VhZx082ikQfHKVznxb +Ri4SCf+BUDV5KSOmjj+nnmUMbJxnbTbdnNdRc3s9Q68vNgQjzbw/RNHPUm6DOywd +xKGfMQihptbGgPIT42nn1QHoV67A0XWHAHdcalETLjTi9ob576MgHvTy08k6zb2x +p/xoxGZ1VT90nVzFsshfuxcwp8PhbyiZYP8wee+oyAhnlrBDfcNFf03O+R7naS/C +ImDJXLvuhG8S9GUA8lw/DFVwOIMHVlJIkIt6RhlzOiqkNMWFV4My44KeaCf9I67b +lTMPBcRMOoN5ZTAKiQIcBBABCgAGBQJOsr9xAAoJEK728aKnRXZFZbEP/An4S5Ws +78qCGpx1SJMGf252M8KBSa73u2VMA7sxlqNdouPhfkPJoQC9emxmvMLj1VYUH+3z +MxnSWQ5/deT/71XXzqwMi3v9yRQ14G5pBk/3awotaEMdyifQdS9n7004nmFK+N4O +At8d0sYLl3wMrFkJ9oteO8VB5Tx666XWYoyp15sIlRIib/jM/6n5iKMTuG/UOCLv +orNPqU3TYcpoN9PZ8jdfmYrYdyhdvZJhltF0TnWQnLmcf2GN8Fo3sMp8E1vv28Ri +AT7yAOg3ZWM9V0Ewj5Gx5yWfH8hkhx0jfkECUlEKESp62zmuJY4hxbbGawIYcCq6 +WNOB9P2R9jxJxxiJA1kihM/PCiYirhl0hwi/PX7O7zRlbSzowLVtvCTBbxMKPqIe +jkhh8YcZCsHsVGJ+CSR1oNMz7bKro0KsmkixF423JuC2x3uyOB7b/OuJwFYzylLD +i7jVa1LKsaKHROlCBYY0BarkNiJjsGWbilsRLSLZie/4lF9/VEJ11Zp+f691RTtW +rPOEmbg7FzG8Xbzlr0mT969CIG+os1OBRMBdV56SvQzSjT1ExOa54FWCcNi7Oj2C +9ULIWLDZbkTSa0FY2VmYDV9YNuU3VTp/1ol+BxKmcirXho7QSXzgKUn+suVOb9Gs +zqA/1LgHP/WvphFi0ZpBHxTKEmEBw2mMkJgGiQEzBBABCAAdFiEEaOfPdV8Yw4aR +WYQG7Ff4XhbM2PYFAlpAlIwACgkQ7Ff4XhbM2PaLEAgAgeHidQFsDU0srLM+uXx+ +iDLi/y2cKnSPYA7d3hUYBxfYvt7qZ6zkq0ObN5RYMphWzq453QINnrzTKTUiT6wq +0I2if1uDEjb4IGObFYk1BbPKSrVPG9GlbhTt8R4wbmHXOQHl83/rm8Fab24eELHF +ft3f23iI74cJHvI/lctnRXMzycvIea3B0mYfRKDZMKMDw2zg0xqoN7CLz8t4fm9r +c7ydn3NpvQuViXHirKlbYvxfs0lJ1B8WSBl2sTiJ0V3hZzC40AB9EJunj/q53eMs +gr20Hrqe5SF+W/HAJ6qa2bzezFdYRp7svHlD+CaLmZe6khfOq7XtLOgXjK/FAZRI +WbkCDQRDhROrEAgA4bCpgEMbdHhBP0jXeMRJl8IDP0IjbHbJ5yDQCQ/g2fCl016n +2NtlOriO0YQ/SpEUwxHF7oq0B41KEqdmkXSGogd/hlqJDIYXOKK4ZYJlJ871cadO +14gMdV07Xt71TDZGHIldcaAuPXGNetyv02UXalv+X/7f1To73xfstUgJLFug26yJ +YfII5VWwJepAe3VLjaC4Fp1MAUQU3Mhqt/ZLH3SI+tblt0cq9itCQOoYWNTG0BNl +XvAQC16gfVwR6w5B0O65nJdk1hwxoK6b7N6gaFRptrSicc682eu/keC2kdk0Gyuw +2sHB1UHDd0pJkPfRTs2tL5g0Fwe6Pu/fSBAt6wADBQf+Mq6pdgR3ojdkwczac55Z +rhTVUTsF55OeUrNLT4/W0EuPjTrlyhMy9fIrwxhDOrIzCr8Xq+jelJl76WNKRQl1 +6n79RB2gjS/Q7tD6/bnNIdRrBL7nIZXz4idRuvQJplq01pRAeKNQ6bWiO/Cs2UYk +fUufa38TeBCibCBIx8Y3CE/KqUImKwTJGTumH2l/pGD1WjOdUPdip+a6VqmWERpx +ZaZuMFbAb2B8fe4YQd1VFBN0Moe2l+ZrXcK4u2HQ9eTXsM581EKUopwOMzNGsNWK +HJahNT5DTLdwHXJLFxXCW9K190PkP6Ac7l4p/Kb6M1JeFLwk0DtVAqkwD+5XFONK +qYhJBBgRAgAJBQJDhROrAhsMAAoJENmGaUHqW71xmUYAn2ddDYHsCWKCRpUw2yf7 +66QMlauTAKCmXwVbDy4eaRJViIdwIUK3MIEBXpkBogRJmowJEQQAmxvxIkxSy+4i +JbdDZP/tJLsy3hZB/mIbQJhQyaFRE6iTi3+ljGPrOxlebUzSTrsSR3ui9jYSnjZK +ZsJSYRcpih87ar58KjKA9qzSe+Th3O16ZlgugGs1eAzvE8Zji/w9ay6YllHvGIlg +b85EkPt5KJRWZ+lTT4bgXQEmuxV0y2MAoLx3+jHdxzWBbQqULtUcatBpBI3DA/9s +6gxOkmt4CzWKQSIB6Z3ppCySEAg74XD01nIqwj7Ox1YFkFZMnSkuggjU0zgWILPv +anYcwjxKH4R87QOd3M6Go9mxIQc7lFwLzQJUQJqMXFS0S/tQzPg0uVBu64Ya4ORC +cswbJmhwFGOrzsuXmK2kVVtTguBtOrB8ddZcuf7WFgP8Df32mW+DSFEqDLlltB4S +5cjPEurt+OsO7LKK3rzQPkz/7eBorkBRR1ubxmc4cpGUNB/UPApxAxdbN6rHYz9u ++TkCKm33lEjVMC4vUubJYyj3S4lLX29ZktT5yfWuAfbmR5aPXHUoWHAkYZkPtBRL +71RvPFarztxPovSyDZSPzNu0KFJvbmFsZCBPdXNzb3JlbiA8cm9uYWxkb3Vzc29y +ZW5AbWFjLmNvbT6IZgQTEQIAJgIbAwYLCQgHAwIEFQIIAwQWAgMBAh4BAheABQJQ +tf6DBQkMvwzwAAoJEMm+KN7m3wJcXVkAoKbx/UxDa0PhhBsCTwopFdUsKdJtAKCC +7emjZ6vFkcIH7wL+MkfBa3FMz4hmBBMRAgAmBQJJmowJAhsDBQkDwmcABgsJCAcD +AgQVAggDBBYCAwECHgECF4AACgkQyb4o3ubfAlxXCACfZCKuMr0GxMhdcEdO4wze +/M6HSGwAn2xGCHdMlrPjU/tIS8iR+96ETzDbiGsEEBECACsFAkmajdEFgwHihQAe +Gmh0dHA6Ly93d3cuY2FjZXJ0Lm9yZy9jcHMucGhwAAoJENK7DQFl0P1YuOUAmQGi +aQsn8i8r8MbVCQHXN78eAQBUAJoCqWMOIcymqObvM7LBkvhEWAZmzbkCDQRJmowJ +EAgAq9WXggTcYFp5XNOOcFmokfnzBgz4W4zqQF4rSCGbjISQHl1pZWVOD/bfCSa0 +EI7joiRDrs1v0mWb8UPnQv3h7t5LJy7mjz471o05Ou/JIXWZskeqDsOa+ie4ctL2 +AVbPMmFrbEF0dSni70HyHLoSqAxkA5lfS25pH4rCl3PTjj2d9cSThFywLxTqLEQa +GplAHRcRTjzWkt80Rcoju13/XxSR+torQHUzwZZl5r/T/4jk9ld3AFvS38qYn79K +lcH25W2jrzfpUVFhc9uwUuNtg3dKBUBfekhRFstk1+Jk43KmLsKX/w9I6DtVhRCX +/7P2kIlOviGOUp1liUnjfNGPpwADBQf9HebNna8lhC2MyX34fK7p6UdM3aWRy4l7 +WIWUJHsj4V6vY6a89aIIXztPgmEJU9uazMiXVfeg5Gaz1iIb7E6aEaRN/iZtLGyT +8aXtPeXoalA0h+eHJbrkRTaDiVXyQC7j8e5Nu3Ip8h3LPglHAGoHkTNqojvm+9ls +ESx6wa+Y4U3LJ7xKSihfZmMlWCQ4oR19XhfG5DxU3Ch04AYIPEuohmiPR8NnnWdK +bmwkHl63kgTZLwollrJUD1xYcUREczeHEhzCKZr9LDGKrpWrmT6/iTjuUvn4/DhX +bePNyNh5qpiAHrKA6WyoEl0wJANXnwxz1v6a8Z3d8GVeW6LETNyb3YhPBBgRAgAP +BQJJmowJAhsMBQkDwmcAAAoJEMm+KN7m3wJctNgAnAyw10AL93efyIyHZaAYR6Sp +izB0AJ48f2Dpbn9xbhOz5MfeQNtMcM8jm5kCDQRR/bhIARAAtJnGqgEnIAG8Vkc5 +vK9Lu/c6xkhY8Lo1UU3AYpZFpO7GCHFm0WhuIe6fi6ew/Zly9il3ekUT6NLZZMC0 +j4dbc2g8JT2472bxHA2lWHmMtPfU+jHJgzMz+Fa9STqIqAt+5KcH0OZgUWZJ+p8n +9UFLltE+o5Iqka23SNQi7S3LtOl6lSx8CXxCN1dOApYUKX96Tf95G+Cn+uDxyarF +z4FJ0LPsZMAEWpyY77FDXrG6W+wjZlLARiH4nzWNDMjqxV2W5bSJqc+ZIRWN+zXK +ZJ0Un40l5mYVrn14BLRDZ7Om2U36gzJepPb8GLrJIveeEvbRXW4neDWN4pUUNKcy +msInLWEeAeX6KnEMTQ2C0Mu8ZxsYSF/hzQkGYNPWwb3nKV2d1qsOtIqKMBNWvXvP +mz7oYXPwQzzDdlXi44BqZ5N4Q55rnHuqeTxUFnmRRw4XZ5UIny2ZhweakVzJApxV +mvcBnWvwpcF8pM/Ws0j2hRC1S4PN80zm1e1L6KEOmKfaH8vhGgE9/QXA3wvvPs0u +Kkcwmm65s0SaWAYwgtL+UGr7S65KCa5ejJBGY5jIgSjiM/ZaTnuUEF1O65zK08g2 +SS2lVy1gW0XUKZxSqOrGRFXTsFMYyffHP0wL8/9gsW5vVedkeo0fuHdomVzVJiOJ +OeZVlfKdCVRFZFVzgLxGkGph4ZcAEQEAAbQjTGFycnkgSGFzdGluZ3MgPGxhcnJ5 +QGhhc3RpbmdzLm9yZz6JAjgEEwECACIFAlH9uEgCGwMGCwkIBwMCBhUIAgkKCwQW +AgMBAh4BAheAAAoJEDpcqVP3PHANdIgP/3/x/RVyHzr385+1LmeVIf8iHC+hSQPA +aIhUthNWyWYQ0GXfNIzkervG+W+WlMlqMIQ19NbDzhWvIbiZZ1CyF7ue92JzCUjr ++H3HALsTfLy4vTA/tOjyQYy59WeOvZ+uodceLgx1g50yCrRo/s5w78kO/FBRUIf+ +04lLPWM/sJEeaXDv2XhqHBdfuVkGdxjHos4UJXttMIu56jaZyDQjXDAoIqwxLb3h +uUdXHUcl5skSDVaDKet8hMbX6FdT6AnCxYps2Vo0pzb29p94sab0m43Pkc+EluUU +gxnNW2leKQn13WNEN1rC7Qf2qOieaP0Qk+tdzQNtwJHNimceR/qBPteZWLEo0EWF +1ysU+19wE3hzCRgZaYRX41QO/uxi4ZnDx2MhXVFfg255CrMbmWElj3j4lJ+X9DYx +DkXcueHGhWiaqiVglbUkujd3iCNw1E81FoEPO93gfHAl8F1P9E9/DJMelv/oysJO +MCX+HIT+lq4UZ3jcQ3KiU1X2jM+LWw8oZNXDrEjW5/uMpL8ZDTAvIRqLoWgpmPeF +dWmaWmVfh0lMMdXeoZFquTAchvoigqUCJtY8AzrVQDPENRbDO0PHYWuahjDHTEW+ +s3jpZ4xpB4WK2MqDIqHC5eIWH9QUlB3HE7OqWexWIhre+DSzBcjyUsK00QVE7XkA +lAUMEmVxTB1EiQIbBBABCgAGBQJXW5uyAAoJEC00fqaqZUIduQkP92lGx22ULz14 +IEmMWMhZ/osDx2BLhRCKBadUXlS2t5DplUUxLlBK/H5vV935i4dxW+EgpQE0pnuH +yim/R00ITfX1vw/nBo5mJ7gpZB0lBc3lhotC8YPJ/BwlPKRjTGvmyE1qW6k5XDgf +traf5J14SdeIOJQ0+sAf6S4jOZZlNBvmWKpwrKqqGhk+ZPDXOhbup0pupRD6ekyg +jxE3balLAWkSHbGLgo3rgL5MCvigLv7k+pefUr9uUQ8RGERxyZI0HBkquPvuxs9m +W4bvjExdjNon1OZ2wAB+dKm4J6hVXNQoRW4mKX8mPiqsx+amAKEDP/DIgv+kZ43L +F1P6waW3Jk/CrTUKd4QDy0D0mdMdEVfX9BmZolapVTENa0I45H6MICtPnXemfyhy +J27fAF9DcahbpY99ujnH5hu/a0KK4XWdvmD4QsTO/LcE3re711+zsOj1Hrqm0Ftb +BeHhpCCuGxVyVidUqGy65J1mmGYgRaoeSeH3KiOCWKkT6clKX0sSmSCvr4rBKhLV +/ojSVfngkATi++WMDF6vOv0BYpLmUyyTwYPJdsSJWyHbLV31F5smN6wBQpGscXiP +EIw9rLpuiZPQBd0Ph1OLJR8aoynmoeoEUQOC003CPsPlbBp4Y6Tlxw6+KEBGUbH0 +JLZoLLeXxJk+Ag/I/aPnMxYGTav5pseJAhwEEAEIAAYFAlZRV+8ACgkQxiNM8COV +zQr6shAAqvy606R84YOCV2FOeS6+mk4l89FkVmZNyAGJnXVkFnMiRU5i9s/tXLdF +sC/acunk/2CyipXJJKtZ+OFN27uaUFKqFuOo/b+TJykaasL8FAbDosBZ3VU99xJE +bPpN6AUfjojd/RWf4aygje4X6O2UihqBHiSpiIQTBHPKcIDpg7vdre7WSj9FVKC4 +sWcm1EfbA+A/v3WXzM6IoVfYpMmrxTBj7hR1fUKMeKJ+gnPu3YsQY55UiD8nPv39 +ft5dTJcc6fpb+k9s30OvWWZyMyjmw9FhXFzIfeIFnnqkN7XAcegyEMzscqwVFiUs ++JqgD89+CSewCnVb5AfYcplWI0zD0t2dBeZ2YmQgk/gUHOcL/WpIK+FRT5w58/dl +BMOWpwm43hbYhlQ2iK07AQeaUHcAiu+dmknQXsGHeEDyRSQpBMBgwOeHPE1am0z0 +Du8z9Yiu206cB+X0GlHnYYqE86t1bynyP21p8XxnZ5k9UVV0i8fBnW8gYRlg+xgi +zcRnDjl1jP0EkNA+rixvThCyQ/b1bVAYIL7CJoq4ZQwAb9jIbGsnyF0MMUA+sQbu +oQpsSNMuf8ASoBOQIssbNV8d6gDhNOD34F6oTDEYk5976DkN3vwrm/wVXX8H3l7a +Szk4/z3o27YoXm+3ZObpt5psyAPQsqSDmvEkpGMSMJD6RR4qdju5Ag0EUf24SAEQ +ALLtGPunMR7PF4w2diGcEAuEjYNi8PoaXSytCppEVtx2HNWBnD/eZ9pIoVBZ4Zbs +1D77a7stmKwDujQBG1a/EtFPRr4V48f4FSEh1VkkNS1HcYgJqeWFN6BUJKtuAjbt +okqMMePkObnGtAJee8SpzAjHLq/cZvTfk9lW1PYI0UpimUGRjzEL7632eYq5cOdW +R5Dk/7fTE1t8gzuqmziqMiUwv7WGuqUnUfo9YIw9EhaLiKg97v+5VIS56vk8lAG6 +K4ekMUl71Xt0MuP59wKvCtjuoe5ZrQAR9sx5iESwP26Cck5K9wvkNi8xCb54dms9 +h7ZWmTJ9zbN8qudmY8/r+8Afh7LzwewTZ6uEJiYk6Eqh5ldZEHSVk9uFdKKx9YkJ +3D04JHopWr2MHkgKagZ8NByoqOQ00eS4bw31AyXu/9iYZNRZi2Ta3XeSeZLidgnT +TW7suILTJggM8YycQ5ROBgSXlGT37nCP/xHdFzMWpR9FCHI2zrA31TqRpoDGSdTP +Nq9QE5GWUx4WuAoSkXWDopOhV0bTokVWSEO0QACvSjwwRdS8zQVhY+KmAWlELQ4u +tzVtHBtuZNdMD1MUPcl7V77sQlIeqFoQG6lNjL2RInOd8zKwxqNzG9eh4w+D5iMl +b8ZOF4yOSgKApWfk5lY4z4GtlkKREhJUIreSx8NGR1TbABEBAAGJAh8EGAECAAkF +AlH9uEgCGwwACgkQOlypU/c8cA2BuA/9Fl4b5o6R9+ZOsr79RKIs7IaIdlGPMvUj +MvzD4EaaZ0+ACLd9pDf9mgdhukP0fqHZXRY8aQLBHUZHlYF/K6LWcmQTbYJg2p9w +ghv6+b1Z9GuhWdyNKPM45+G4QsQ7IFu9Bt/TAPKBVSjncdgThTfCaEX+/pTzEuDk +rervWYAZInL7bYhO1MMvy1RadBsMlt3I99LQRzNVjqpLgMxx6HKv8bHOaM0oX/Kx +eTmRI7Eb0+VwfS5DnBxysbZHsEPTjHfb2EZyYjN0UvX/2KSPXr1NCkNqrb5M52FE +lzQmgGx/7Mi2l1M2Lr1BN2Wrjom6ZUFoUvz7NaJPGZHb33Qt+eRB0oTedZzquJ8J +Zg8wHXWLlY3uFrpbuiyPKFMggHjwa6PzitlmcXTduqtYZ6IwhAPeEQLnma/2/9bb +BXgCVhZJEs4IJ39eZsQRzJUd43BwlAFBGlPKiIzD11f/j42YvfbdSvw++aana+gJ +Fqaw+ByB641eMjYPmrE28Q0jkFUBSZci17ETZivTc138aDXAUiHmRefUx89+ZLKA +znaQFEzjByY0vybCUJlTJ7c/CqhfDGyegL8dg0QcirFp7NbWQktUt6L5Z2y6Ze3d +OWr3hOYlHKxIzaoopnYhu2pZX8ZjZwqMMbIjaYvzQZv7OfVyBPQgQE0JZEdnKOdV +oVTJUzUQZl6ZAg0EVFX86gEQAOzXVz1ElQOvUzPwB+JkYydtroy243OzsqwdpG7a +YJmxPQx/Y++lnGnRa8m8IumWzuc7N1nNc3o66ZUP83BqvWeQKbo0oRH52GhoH0A9 +7vQx7xBi/VfeuGTp3HbAceTQFcVMqKCAPquySU50XcPWEDR6VzgAUjJ1zS3GX2mq +uK0KlG5MBEBJYJQ0ELfZRAOv99gZDK7eJeX5VnKNmUD8lMLpGn+ff0VehPveYnbI +SlLbUJOR93jcHHcad9GzakolCzpiZ08xjX2QCGOiZ+KqZdCmU5qnWayGlqUFzcZn +LrkcMRDA7v6VYlIR/IUxVMPbp+w3LEKXvzGkzcO53lJbZYu9+WfltLwtxB97MdVV +VpsST3nPxruRYvzNvzx0213r6VT/2ztbpCZW82di9d5u3nabcdCLQxCGGqaL5iAp +lkk5xieFTCxCEcMChkA0unPPVc4fbsYIY2D+oG8aI2gV8szZ6cO/tAY8/zPQPyR9 +B1b9PeMTXTTGBy4akNZrFxhTnE4yGTLyvPwMonP3Bha9J7iIl6M97TSmnXe2hzwv ++n6qbY/UQlTpc/bTLpCDrGhWcTzSbLl7nfzVN9uj8OmAfemrv+KooigvBEebRaFH +ARvdO7Xnd0+BJ8nWrsYuZBI7UIo0yJr0lt2Rlgus/I8pBFh81xNmsLlnzxBPWRbd +DPxNABEBAAG0NE5lZCBEZWlseSAoUHl0aG9uIHJlbGVhc2Ugc2lnbmluZyBrZXkp +IDxuYWRAYWNtLm9yZz6JAjcEEwEKACECGwMFCwkIBwMFFQoJCAsFFgIDAQACHgEC +F4AFAldblNwACgkQLTR+pqplQh24uA//UgzMubdHhsbCZULMJrAVp1JABXBkfvn+ +PE8AyUay05Q0uHk59WBavqQZLHKES8lgCNCiR0Ag79j5cdaBGpNWB+lZn3VpXMCU +fYUkoazw8qqKeOoax/Cwe/Qmq8ssXv5Q2j8tePwwWf/aGcSGwFXM8d/gyJPF9d88 +/22nYwEl0laonF6PnAc5ANXNENIeaz6DJHTVyFCIdoYUyPOkPFViRZNV9lg01VHj +pJ2ttn0JwglKNBpV7NYFzkjcGHD6HmEnH4SPByNvcHRC68M7BonYLsjeFXIkdSGb +V0kqchSFhYELDW3DRMpCdqTl/6XRfst1RqZ9Vtkoyk1P/b5wBGt2xWmzVvxzxIr6 +4KuH9RpfnmjrsPPVBrPoDPbhkd1ekHLXuIsBQxsqW7lFegYSWWuCrFt1CPFnmnLg +e5TXlT/WPfXiBAcU3msGQb47P7Vx3c5/Ud9mh7qGdYvWhVkZTcA+tgHtBfQYyu0e +cf4C/Znm2EaXeCEX9FeEliAKPdqMJwWNaLxNN+FNx2Dl5BwoRhwtjTn9VBDaGpoR +TkIUIoqHwLSdBZdM+vkN5JyhSH0jjFQ6VOVlumdayGOK3buubpl/MLj6NyXoZ+fr +CyNK3H3NuL0pk36rbtPUiZ+YDPjGU4zhijl5IJc4RlVXS6jR702QWIdmcyho2EHi +hjO/4851pDiJARwEEAEKAAYFAlRV/Y0ACgkQ+5khKG9eFUAyQAf+ITh7XBCHyGL4 +FWsjsgaBk6H8UAEopjAHTeOAQkQZ0wnyDUpsp/5LXCZyFAUcwwGwlnZDh4iYDQGW +e2+gr2bp0kQLC7n2oWaQUWAUqdJDzNEEg249ZH+wQdL+OY6WFtTuD2Nk65+1QdHX +EFdWF36znOIvYuglC+m4aOlDBKidJ1FpupNw5g+eIuJMcUz3Xs91abhVh1yr3Lvd +qN7WDYBeg2FSB+JG7R0LcBegagL7cffuoIpkxxq4nyG21kM40ORYePJ9/6rqdDBV +wYCux7Ux4ToKMYByWH2hMv2oDDgPbZFct+HYy1IOg721DMnpi1EYsZqNtHWldZTH +H7CZblsne4kCNwQTAQoAIQUCVFX86gIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIX +gAAKCRAtNH6mqmVCHeF6EAC8O0IVnj+jDwmdhHDNfBLkg5yEQ9uPyX/XKmDLfrpi +0rHi4hqbzyTIOE32+vHZEtsBANwspN9CA9Kptxf82N907CbGnQ47HRxyVv21jGqj +v+B/vV9v0E/4bPcS+mCMvmXAvG89nBYL1NfS+5dbMugKIdCQxR+krRmC3ltUArXk +isRogHOwDNY5Zz319k5i5u8ndLBUr6zslbQU8CEugCxvEiIE6eBUbmlYotiyQ7/6 +A4iH75VxHnUyx7rmB5Vln1MDLDVswnfZrGu5QGQesT7s0+AySP1lR2hdl/TcanTn +HcmoypZDBwFCB6vavUoe7iEstOpcdTFRN97HidGVMqM4z+2yrcf5jkmpxqmvMuTc +gE+DweOo5yiqirJXV9bm8IG0uMzdm66vwreRWjvJ6nGly3YgiE1v6Yz4S15T+hR/ +GWddKkPgunJaVINdKETHJccf5Hc4BkWH1MItuCoU3Ry7MCMQRmdPREw2rAxVZtAj +fMdPQpmvcrCxUYj1ZWpWhKOBFvTeo72KcEjp23zYphhRlyMgCnKpRGqAgIG0VB03 +3ihiGQccRq7PQ7sPM+OWO2q+xiBnTvB74wRsZPel6wsvrMpPWdZYp7lhNJ8ZaH21 +5EkfD9za/wxTTwC4XuOexLU2tAoC0hxdgpsjpbak71Cb0doAzJmpHmLudFBpeeOa +R4kCOgQTAQoAJAIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAUCVFYLgQIZAQAK +CRAtNH6mqmVCHZ/DEACgXukktlWbRc6C36jq0YcPh8HZtKpUy3BgekGUDdJ56/AM +LfK3FH6268JmSPvdD1sOwwcnJzsN69ixW/K7c8cby2YClAvJQ8UnrwhVSgjQZhuT +onKUIgYoSvK0BFlvm0/8FvCTc55qGg2rbo3LnkehKuXyxtcAM95KJD6IL5fU/P9I +Iw00awhqOs0cZ4tSdGJVuAg/bQb5Yig5BcLIVxCILhVOmkoR8DH+f2OsOvnWOZIp +Zaz4k8639K5VvGliOW06sLV+DuPAfBVdY1ktzX8KSeDx/ScXey/dDsgOXQtQfOhY +Wm8KGDLYaKoHsIyMWfv/vok1HGz1Map8wgspADqDBXEuaYU++PpJ34kO4W69B7ka +SJhM7Hsa3Q/WaU/NpX7SivutsLLQRbLlCa1c2PV++ISVyo5a4r7vYmIxr0kJCTBK +7QT0bJ7eFAux3OusH6wCsKc7YsQnOjxv5Fhk5zqWXHdrwq3KHqJ+wEaGVZs8eBNI +zWC9BN8++n3GmfBrL+5/pHd7Mu8cEzlfsmvsezCuVwVZ20ENsoh+qPLDYESkafKZ +5dzs+Eovi1Jv7ur31ap/ZbYmbjecWbEVT5qkqOqyOQjZddRhdyi0gJTpVI7iaKGl +NVOrwq2o0iHD0PKTCZep2YJcd/d7bfCTo8F0xVEnb4zFiVis9amWPxqlcxyokIkC +HAQQAQgABgUCV2bVagAKCRASbrVjp0sGvxS3EACwMQ16Q5q2uN/n8qaXV1TB8vvY +qC6ySAxZVhMTQHLyUYTkSlrmd4NuH/QO4BmUK34IZQ9SGQmm0TSdC/4fiKoP3en+ +CJAnCQCj3yZwbYzJPnxykvn85yw8YO3ltw7SoXL02nESFpyvGH7VtqiKYsLzUMct +8SBWjHyvIpfBvB8q4zAfWJrwpMG+PBdbp/q/RDj+Ni4qiIg6PmSiqmE9bSbsusKI +sQC9NlM/mL8p8DJ0dcDkkZ2cyBU1WbWKxLEN/2CIJ3WtzAztUB/MKcKCf1dflgyQ +s9Fm0tax7SqGtmFnhXsXdY4oqL/FIOwZiazRRU6DCDhNVPM+pZ0WdF0aFMaaFFPB +MObZ2iEY2hf+Wkg7d8MXcEGArB0GTK1CGM4SANoR37vaqiCfjW6Y54KmvIxT98FA +is0oTMwLF+oUH+4Sb3AG112USkWk8+Bz7E1jxGCaqa3gTA5XLp/tu5MUS8u3l4/K +RxyacoIMBS7FJgTBywpBGqk9CVXS10zG/zTTiCpkW6WYcutfo1YL49jSrH5zqnZE +xVygqZjABqrZGAk47IBAd6YY21FXAogZfm2MFC3HNUYecm9sddM01OJ7RO7bbKUh +Kr+k9uNJNUYCWVvYuV5yfUTkQ3lHfUVcpafUpcPjZNCuU9Cv1fCB1DIp7Y8gXTWl +iKyBnYZzW+/2XJwMbIkBMwQQAQgAHRYhBGjnz3VfGMOGkVmEBuxX+F4WzNj2BQJa +QJQxAAoJEOxX+F4WzNj2BjEH/1pY3wdVChQurbbaJBYeuSWorEbj9x8JbEi5iCOK +z9sXR2S/1CBp+CxKa5WeAcvwDHqCGf0IybfxOgNQ7C41NjCiJBPlVK2BQ6UbCd0X +i1Jgp5cCy/0Gz9jc2ARyPlhDYVPr6dlQnQur46qZF87en7EiJ6rrRi1a7dL/F2VJ +qxjgugMVcrHYEHkmutxz139QNnqnKu4xQpHpArYylDK9OkhjT0wQ2Qs3AhvrTxmJ +VehR63eRumYjGZErf5y/Dea4bIae6oDORZ8x3J2dlQUt3T1Xn84fbq0CHzjxN9Om +lsbr3faUmSnm7IYm4r3xdkYeXZpRzwnZdwWnHH0QyN7JU4iJAhsEEgEKAAYFAlW6 +ILwACgkQjIFgit/bP6BL7A/3eU+kJx0WI98Z3LqbAhUwkEaH38Lp2dZWiO2cWJ4u +D3Dbom/4DjVfS5QJmVWGs+SMc2y1tiF72p3xM0l7nQO8gOoMpbkco0pI6tN/qhnY +9EUSHebCfkGII+o9vZaUaotdAMB2hjz0P4/QMQ1Kjn+sgdSn/a2iWvLRHABtCoB4 +NI94FzBAs1gwfsboNoIBRA+Uq040nLiSTm6178tNbLbehBz2+NG54Qp9IHeAJSdP +F3J+u9DNaQ79Z2l3yoi4fRQI/mlKrkPBJ5B9bi45KEa5HXuqiJHn2FNWlAS0RlT1 +lWQWgFFMnGFX7DIntSIsmB6gVPMJA1JW3QwWjPxtDU87uIMCxv6QzNOuhkhrGdah +1RmH3RLqiH0NZvh0NLdMB7FbpTLTyQZNkIznmGyoZuw8QoceJHo9KMYZbnIcIq/W +IMFvX/x5iV7v+CAXTIsylm1Wu72JofU4RavHuTyidJ63kPKPES9QGnS5EtaR5eCU +H5Q9NqUXTtDqnKsQrJimU9P/IznLuEMznMiLG5+J1LALPdDrHWuykwiyf+Hyglo7 +O2PIzf0Pd8FKdUW5ZQqW0zBJjQ9e2T08YkPy9/G0lrmacLjDpRgVrnNr0mVaftQE +6UqG7DgIarH4XzcAYdzfGHTYw3scYpPnp2fVZz9/vuIirAPldGvT8ws25olICm7e +9YkCOQQQAQgAIxYhBLYubrFJ+5p0/lWV+hZrGZHH64lEBQJaz1kIBYMHhh+AAAoJ +EBZrGZHH64lE7VgP/i82hRIsPxMy7qRNjxm8d0kUuW3nMg7/xo3MUARFKBpf9Ydu +5Ro38eK4yTypuAzg2z0Ccg59H+MwW6rdtr790F1qNrKv/FfqZYn/zqZRX0JtzXiM +JvObM1Y6Sgw45e7X4iMreS3kUVz0gBaucpk/eupQthhwgMln/eeE5vw5vnARx4jk ++VYWh7/JhcFNJBGjg7Pdo4P/JcGclSbE3Zc1JL06F4tFOfkhq1XXWNJTfmjEM2Bo +NUwjkR8pGznll3Kj3Yxr/+IhlXk7PcpN92ReriZ70uhJiNWc/TfNtIDGqHB69P2A +BYMcKAF8oqBf+YsKUjXfSnfGvOpZqOKlhHKF1NKq+n+CvF7lc7DMc2p0b72aPnXt +iZ+vtsYIineEa9AWUpVBcdsKev5idd1zWL3QgTe8QH0aLDM1vBeGAgWYD5RoXlmP +Xsr27+dO47BLtXOgnncD0KtBz9OY/gusJIUCFISkUgPjAJKgYK9VfvtfLraYwGSJ +sbj8gcxVQALRnxfRGV0ZyYbSB2jURGu3Ja2NrcphBdWqZs8P7WSfeR0nRbEwkrt3 +L70AUL/DLLYFWZYy2GwLjoYFcJ7hJ0uA5QiRYzmI4XihSRWYfii5actvA+Pi/usz +iPUgtrtyb/AIQ7blsAFH02tsRd4S1pPo0lrTF9L1OchzBbpCAMo0+vR8b7v3iQGz +BBABCgAdFiEE2LmHSAa0Asf3nD/rR12Bn4QSjXQFAlsZVBMACgkQR12Bn4QSjXT0 +CgwAwT4O+4QaqdLaHOjjvEFA27K/xqhw0Ak8JDbU0R+wSau+AoLESCw5dLGgUXoE +LVyu25b3rpjgZidBenoAnEXkXfrPtEUGQHzKLfDc3qoJ5AYmQ25huZIpEBeadOyw +Qo7MvLpSvQ/SwPlLIG8h/56mKvZps4E5wZkbhXrl01XwVJQ4WJdwZNEtmuCYvTQQ +CEyBNIuUcESEucZL6l3MvdlQJqnQpGsmQtU7a28NOgySsHtzSLg6/CM05GjiJiEm +KIf7ndXLRf0vmdxcztHO3pUTpu3FwBn+VB25ZcXF3BrdGpBljt/4qFZrUklx7qoa +wdcO7XogxxUJ4jSc+0PZl1U8tJKdG+4NAdNvySrvDlHKJbkTJPcfUBpdUG1pogZc +J9v7Afwx83caSnxgitzcSlh0ZVlX6MITb9w80xDRG2wv9UC77+8cMUyImWGMWooJ +AdAmMGwPolDLNq9NgwFOF/WuCtJ1gj+ttRXe7mNnw3Wd2I6EeMIyIPNf9NVwdycX +yZTotBtOZWQgRGVpbHkgPG5hZEBiYXlicnlqLm5ldD6JAjcEEwEKACEFAlRWC0MC +GwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQLTR+pqplQh3SVA//bJNAINfQ +/gBOLR6vtNkN3Lz/S4Q6D5BH1owkfT1f2oIB7RXYxJlQe6TvTwElKRSR3cdXlgPe +wwsUGog+ATLdq7A1WSJ2Lg11vN/fgpPH/Q+ti9sEgkMjbHA0YdUYQ+UBfK/DJN+7 +Sv1O4/f9Led+SMMwcWVOaJtJ5dS2ePuhpaPDlgXV9uefCUE9Mo/hN0G8NWzJLHaf +/1LEazlKjw7YjM4ainTk+5vt3DEjWMDvD/QsGSNqRB0u/qp3DS1CjQcP+PZ1wYoF +5xFPctfs4NrvZT6Jkj8xL3HTtkoOtQSwDgp5Gsus3HYgbp/Oq4Fjjy41TUq9GkxQ +l4gqKhK8KwSyxC8B3C4w0IVY6tLlk0ErWACMJD5+hlqP7dP3KjPs/qfP+iuuP/A8 +HZcCzdCmaCGoxgML2anXbYT6W97MBiZZEbH3ehHQF5ryZh+dINoDLu2aMKFw4jzg +xqeXDEccQ/opXBkiFJE3gD3GxfqswTg+wabsxFA+5kI9NpJJOmvSLrdT4doMxR7d +/nx+ZzATHWXZ7hrmNPEDoA9MXHcZpdKCp+EOi/KqTXazUFAzUNPjNy3X14czj9GZ +xNNtmLZidK+LBjhtQhROXjf/CpddDt3k632Oc+2A+10Wpw3Qf6ZxgEiPM3+1SZxP +CEit+mM5VkfetxZ3M6yajOYPpjAG3GDO+uqJAhwEEAEIAAYFAldm1WoACgkQEm61 +Y6dLBr8rLw/9FDtjSjVNdFIzVnrW7acMJG9Ob7QjzzqA6ZPElpWAssr/CZcFOqA/ +EshnibTiQTX08yRjFiCYNOTGz8su9hzUBtXsLXmhHD0DJi1HyI/tB8KJizKA0CO9 +jMmLCq5Wn03ePL5OHYFEFlRGd63ZNFoKoKI9Nje2fS7h2rehIF94NOAY4d+hFiUN +BblYVfOWfIT4g4rLaTC6OSwBXYcQmW0u49+xDBBykVzqRFuHuGTx5I8gFsds6AOr +couMAIgOKo3MlYlC89IF8wRjumjODtdHW/yxDog06em29/0uEQY3g5Ea83lbzSuW +25Vcy54GhlovYCHtcWnWNEt6w1qQP9HmLynHtyt19CfVtiwq/vO59REhVaP95cOh +ADfyEDNrnMp1G1KgmF+xB6tNXP6sZyDYeWbyizJ/d/6N4KhhvDyQSLkRLjcVDC64 +ov95r2v+xSVAAar5kzZSWE6BEzDHpfWtafZKxLMFOwdMl4wlRUGCQ+9ObjPyHlJI +BPU4FQgpwPkFJudEUStLOdsO/pxt1HvKYeh8idpHqwS0jis5/qG0LTYYfTE4g7wN +9D9QSZMqvpd55JojnyFFSfZyfhkGLNHi2To+C/0uHH4qgsorcfBTGteixxzeSyX3 +jA+QDmyxT5/r63b9SNwF9Cx9RE4F5H8DipotQkBF1EHHKJ+0vNbVcC6JATMEEAEI +AB0WIQRo5891XxjDhpFZhAbsV/heFszY9gUCWkCUMQAKCRDsV/heFszY9n37B/4x +ev2cKpS8eF1EopIyODflrUQEza0iPFDqS0ARObfg8jrhO7BWuoYTqjzYD+9smjK6 +ELmybSyFCkNp/yV+XLbcpMT7n/HsJhlN0qcohq1WGZ4JyT2Y2nIN9YgNVqvbow/l +2mnnyPpD1L6VTEZURCktNOxJsjxbhGOauuZyQv4wPTUO6K/VpoWvrvt7MrttdZXH +OR5MQvE2PgneZny9/ARGpvXtNzzSeLupABAQZ0Og4Y0aEIuO2a6YGZzpRVUm/gBj +XSbxicFAIEoKPlEO/zwX0lEr1KypVLJ7+4dTYkcdxNzjOYWRwkSWKwfOnFvit21J +cKMm/4o/J4+7vbteu6lMiQIcBBIBCgAGBQJVuiDGAAoJEIyBYIrf2z+gZ6wQAIbV +Ct+c3PZNjGbM1AAkzSP+VWIo9qMgrUck6nS/MUtTfIejJbLfWuR+coGgb+id4d2o +GZ9MYq3s9Es9p1L2nCAqek0LDSD6shGU899ABaRN9JChOwhmV6Wv981J/Hvqo+YQ +JPGsQ3TR7aMsyi+sbx3xLxLAWGw7VkD2qU5qKisDJgzvgd9dldrBeJRChsOc7LUK +ATtYzsN6rsZPBsDH9NA8NIjFANMwpsv88LadmvL8g6tYDEI/A1wP4tc6Lah0xcdz +WL/Kl3pwFDz7Qg0y9H+e4wE+b+QN155R9L0nnK21Un1MSbBfa66Hre/wyPWs9Lpq +hcSVDrFtmn5S0SxJM89PIpxPFKIVA+DcyWPALQecAxZVxaSxtC5G3uWh763rh8zU ++P2gbCwr5mZK2Vtn9B5/0UJPbFi6HPI8CRvarryNsvBWCPqQ9MN1KyFaE2Ica2YD +qCzET8rm7BQdTSAycv7bOy0Kl3gvAhLBR7/iKaBlKKp66ScEjiUAvNwpE46aymld +b5/H5AE6XbhOnEaYtPQRw/XR2DOk+JlhC8YKghaGPaWyWo6Um4wqOJhe0GTBIGEq +1jTdDNMa0wjTr6hwULohbx2x0Vc3ibrDxg+E+TP+axvXihXt+AFUSTbTe541TfIr +G8+lxvoeEUcjtmenusDeIiRcbytDV+Ng9WJ5xz3SiQI5BBABCAAjFiEEti5usUn7 +mnT+VZX6FmsZkcfriUQFAlrPWQgFgweGH4AACgkQFmsZkcfriUSMjQ/+Kzd4BV0r +uvgiwow1Y3RF54zIEl8wVcrFoo5Pz0YJAxUB7h+au9WHTSx6YcYfOn9gvLuOh/r4 +VzfVzrdNEG8sq4l5ayab854bUXxd9dap/EJ42oj3TKNR0zq2CH93zBdBcVGB4AxS +svOlCeF0y2bjmkhtf66SYkvoFXlKTskJdZVnKTFk40gseOwET5Vt/QYJd8C5va6B +dh3AeRmVE1tiJ/POWC1AqpHpZ9ZloqVfoJ/p+qXMtk4SSf2Rf9HNd/xsTC8MOWny +aw3jkeKFwhSn5MZ/GHD2NRGoESfSSjL0mS6b9MOpNVYxDRU5eacFnETQFElN9YL4 +VsOxcIdDm7RMM+RVRYW8IqMhfGAYhOrsulqcxfCqdIzPYENBzs3cJYFUKPGjbY7M +PviqIk2/QtteBEDQ7l1Sj9KmOBAI+qrJku8aBfMF6OhhEIcwyUvXTn9hFmFT5ToW +5C3YauZravia+EZOmNMvGunJRObDkcYG54wcuaCMs3qBkl4v9AQzOrLKK78dvEO2 +hsQxkrQaFdzkq9J3p+oqtOgGM8lEucdfMRSysqycbXnCzb3eWqAhtr4KgGtsIvvS +OzesiNUEoWLT1rKy7Nx3cujBGNJyarG3wt9cHSFS6+UcZnOameSU2qMFfPMfCM2U +DjGmNCixsHv25feLOr/8JiqaR5xLlxN/tpCJAbMEEAEKAB0WIQTYuYdIBrQCx/ec +P+tHXYGfhBKNdAUCWxlUEgAKCRBHXYGfhBKNdIhAC/95ik+NegxM79UnaQZIva4y +08mQflHXC0aiAuhiF6/JvmtHALD1najkgyIZI3Ac/OGx/f1g/BC2uqJxh/b6jvPW +o3hhjl3JIeRfW+qluxvLOZRXPo36f5hpkjg0M2PNdJWeslIDG2oN8VJqFfK4EAwR +J564Lxy4ky3JI+MuPJGtiv4xlAwqtyrWtb4pT6Kmjkcw1g8nqmJCE51f+ZX9oAkz +yUbsX6K8J+b/L2gl3gidgnqy6f/NokXVe1rtEDSMZWUD7voj+XL1ZW39Iiy6Kxz3 +G5+Cby18CyJ4fkyMZxLjx+z/6Nbhoq23zSxXXKYp8eg1ikQqsD2ituHyn7oDYW0+ +YG4UUO7j1Gv+rlmOElPtWN2jUoFODPpdeqtrcLlJ6uE+XvSjSA78S8Tw03Chm3yC +03zw9u+GUAmexYX82TMtny3MTWBqO/64ZIE0jf5KLBpKZc22FA3AFU/+SvRsq5Va +yvbFa2L4rPyAPAWMi9sB2G6OdrYjs8jRdveyvY/8h9y0H2tleWJhc2UuaW8vbmFk +IDxuYWRAa2V5YmFzZS5pbz6JAi0EEwEKABcFAlRV/OoCGwMDCwkHAxUKCAIeAQIX +gAAKCRAtNH6mqmVCHZbND/wOakdHwIc8HK/I+yvZtF+5WrE3jqLdjQw7zvFifZKr +97Z43zqzdj7CgQ22iihEEScYZJ+rjhCxKkptO5/Ki554+flIxiZeUO52ls+Mryfu +XpDXgubCyOZc+b73n21ac5SLvQTjitbwVpCeA8DUM1EjCzW1XVaaCgzHHY7J5vAG +yGwHLnP5bc1M4sH6pv4U4lizfRJ1PfM8ObgTEOXgsxCigGokxFQu1k3RrzTuKHvm +I5OSHuNbvpC+RKkO59NiDSaaf0JTI6QhfoQqayVOA1/A7wbYzwu47zKzYsLKh/I4 +J+8RBiUMBYh+ffpZ2fbvH8J8KkIya1Iqo7rh6mbhAci7+Nu/sv/AffDmqgzzd6r3 +j3YSIgvRQfEfKyPpCZdX8ft3I7M/51Yv/9EaM5hV7Q8LKmpSarU3Mbs4Cp5sbvlE +St3k0TPQomBvaZw3LuM5QNqsMU3fuIemiQK/S2JUbdW/8Ab1MCivkf3XTlaP1R8S +7teqtQTnYEB2KkXw3lMtHC8NDgSVsnDYJacDHeX4uV9U4ckO+JX3ar3lCjL+TrKO +2lhZkd8FPsUnc+HLc+iNg9ZRzoAtlWfnmGer2MEnEw1wmzfnhznkjgut8VBx46N8 +gxX4gwbZLRCdojtZtTEuthCq6lnR5LYTl+oWK8iKzmVoVlq9QTE2bj/X5yCG2HtB +cIkBMwQQAQgAHRYhBGjnz3VfGMOGkVmEBuxX+F4WzNj2BQJaQJQxAAoJEOxX+F4W +zNj2EXUH+gJFm4QjCCwodQaI1IC9qi0I+vjYb4HW8eByWtPlV0cqgzq1fZD/Bn8M +4cKadYKw9wdRU8LKCGEy9SCUI32YOu80mBU+oKaL1UJbm5ERqz6wv2dBHprOF5Q8 +zR2QV7fpFEa3Y76WoE3meNKYfJOK42Ms24P0KBfuvQAFqQtpNl3nasbrenEOwFtg +KKJc5BPjpPGi1XCSQAyy+YfKBcd/+lvJFian5wzmVL5W/U/WFfk6ktMzUdM+Cr0+ +M8CtqG9o2Q13oOI6VwX/Sml0fsP8ZHXkPAKoWEsTdhJx/dJiOMJEg3Qk+hVbQKXG +XutywCXYK9988nTYz1I58qTBtFtuV3OJAjkEEAEIACMWIQS2Lm6xSfuadP5VlfoW +axmRx+uJRAUCWs9ZCAWDB4YfgAAKCRAWaxmRx+uJRMvpEACE/zqlJTOegVLCuXhD +P6+DK+mB0HAkShUs2lmulwwx0kzQQMob3ukFSUL0XkQFyyYTZr5HTKUzGNNQbUcf +4ucHy7IY0n3etGzhS6v5kBHW+WkVTJo2BiOUnec+Qak4jdhciF81QWSf1M/KUrg1 +JTcPqyYhV7YEWbhqmdhvyr2LrzGXaIVw5Rr2+m3Y7S4oywSInGpCii1YbYBXOF/D +b2IQCcEB2Z8zqsO3Omgi9h5E9TP9slunOhXTBvy16hhNCdMWw63TBT3nlGg/pYgV +dwa2xd1Y6uUl4NXgCt7vF7+epwQw0No3cdDyh5Kd52H0LvBhcAvVP5sRK9SM1dEZ +XGT78kat+Pez31Y1aCByD5dJwkuPZd+UKHEuGqO1KH2wMRy86K0E5Ffd6Bj6N8pv +iWOOcY6vOMoV6fjc2sEYcpy//GdU2YcTdE4Bc4pfuimYBl20vQkuTRqa/gIsunra +B+ZBGKl5DhSRfgyMmTu9cz1vai9NQwHO/Gn7rr64L1WqXpCVv0HGxrEQXsqljXJs +8Duo2elUhdUpPg+Yn4yLL2qGWoAUYiU1o8x1PWxfNzChEVbydnWHqHriS1S+x3lB +Jr6ehcWQcqkp05eWCsP5iDxF4eQ7UiiXj8jzkGl5Js9/LTn9PiBi5BDtNeK+31DL +CDpuzaGUW2zr0d+4kK9TVBkZcIkBswQQAQoAHRYhBNi5h0gGtALH95w/60ddgZ+E +Eo10BQJbGVQTAAoJEEddgZ+EEo10Hn8L/01Func+PHlWm54djooPxDOAV+M9teLi +8G9Ymlca4ov26B7Y/e8YcYkftIuxIkBUBpLgXDrbXOLHjV6FvZuqs6RioWZjPSA5 +cR5A6JA3gPJfY2aNCjSuLLOGdhM7uTbsWqtrjai5jmKgnHqhqRbgvLBmKYXUgCGW +mMRpxA2Ig6iXyUpuQ1m6HxieeQG7LuV4NJIO7cMz02EgurUpRLNbqk2ldeSodt+G +gugXRk4SDT0lSuoKKTBuYsHqIsUpQjhY0YFXOQY0nrzt4YkYGvCnXj/c0FF7j/C4 +tSYNw2kOLbZK6cNcODahkn+WUp5j4eNLipEwSVuh2hjUrpziilifzndhecifkt0A +YhJYO+88W1K+pXYvH9agwLp9xp35q+XAKfv6bng1krKqxw7Hd7Fq/jUJw6wvTfos +t2/q3zu+YCHK6vC8EHu2ZhCycMw4grNqYCjsW+joBnheLO1I3pusbzEothjHf0XS +8lnYMgFqjJWmdUZtwvWkVb8jpigXMS1zF7Q3TmVkIERlaWx5IChQeXRob24gcmVs +ZWFzZSBzaWduaW5nIGtleSkgPG5hZEBweXRob24ub3JnPokCOgQTAQoAJAIbAwUL +CQgHAwUVCgkICwUWAgMBAAIeAQIXgAUCV1uU5gIZAQAKCRAtNH6mqmVCHVfAD/9t +JohTgd+zrpkcvwuVmxyJMkKkRNyw8ZN06mn5q3NB68TKhoOi7isz5wjtgKOrHgQE +YWm94jhRf8Usao21b+oBr1FYzdL4K2gNars/ZZ3HQn+vUw26O6/FfXLaXixlz9id +zMrSr5+VDPsgnoKMpJla+n8FyFoVTIyvx26hjs6ilh3I874X2+1RSZ9wDpHrsgxC +GGu3j7ZrlCwk13jhT8eYedk1w+WfA2r0g0ZbMFwlFFWwy1c0UCdAn7tAchrylVvu +XECBiJu6HUrRhrHJPy9J3siq5+1zkwC6/AJLQU5ykpgqn68eSi0NnjCVUWXgUxJo +9I4pSGMtGN2xHJTdZ/fr2JVYRFvJi11ldc0EX5F4VGCjQseVXXKSMLFq7Tk/cfJM ++ATnjhM/l3ZEF68YH+fFwQ2j3NQOZZVOVHqxWL1dDMR8oLxNTuFsTBve93hu7BVs +xGk+YBTdbywcCvWRVWdrnYPidpzOInzDMMLay/r1HhaF/vMuDu1evdRyix2vMXKm +D56LvLNEHiPRDxW0HcY/qerx6PZ3E4dUx2VBbFM3OMz/g2uJ19Jt8kUhtVh1gYAb +35+mYFX8G1zVPvZn+/UCW41I6YhxY4GyJp1QQ9PSF2XlqVHFdyKJ1E4Cv0cFxsuR +3XJPpg5j29BEOloAxKaacoqgNvWqZ39dgoLsQDCbeYkCHAQQAQgABgUCV2bVagAK +CRASbrVjp0sGv/E5EAC6YoyBT2cdzanIy2Wgql7mN7T8W/NYXoy2yd1RnhUHq+g4 +wrw1E0zwQZJhTPljWu0bCU2CpP3pqVpPxVDrUCWJ40iSZgmM3XdsJ+fIFAE/hNPN +tBUNro41QygNKWEJxqOAzlbxl9rzM+2HbSKHqWOqbo8Q8LhHnc4ZVz/FsJD7g6PI +dqXWQ3/FgGfWhaNvxcyQwV3gMeJm0JkMCBLSgV5+wqr0kz5qHXEATjKw2RgNX8pJ +rxqS3xR8iUec4HLa4ZXArWX4a+tyxqr5IIDPa5/qA4YLGWIEKpYUP38dF8GFD3dz ++gIkqt5qJndDHRu3yh/iigrB/0wv7Q3pMa1kvB5uLcBbSlELOuKkOL23xVfnol3W +Hax72uZBkzsDQ/1PC2qZebOoaGcxPsRt1/VdfTRbjz81VNrFuAA0xlHt4jEVk+in +WuKxkVAyqSVizkRQjWOInOywI/zAyBe6PARliDfPpLrDfUwyYI0RZPf6VKk/U9jh +N2t9TssFGYbHWlMSIe/OgX/Otv8DCgqetPR11etgidFoS+g1E35YqaH+p4eDyPJJ +sWOMLBZwPM7+c2OcHlIBX9kBunrxUPz1UfamiKKhDFSTJVlrrJN9fhHuEezvDKJy +Lb8WwJpzq8ElLuPJsdmtPLHNV54dBOyjwnxeGA5JC7QnxPxMf1r+ui3x5kyqW4kC +NwQTAQoAIQUCV1uUCQIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRAtNH6m +qmVCHXtBD/9mm2tvUim6DQjegkpfiIzV3U8xZfjbAjCSxGspT96vxACDJxZTE4J/ +X7LL18LWBQLvEqvcmJ4NvH4quDE4JuhanuPg5/hudTfpYoBQ382bq+g8l4iu7Tdb +QTTaSkmWQuc3wMWPLJRfrYz3W1VomUmyiYiVubaArhh4zM871aZiMuYYPtwBAECt +VBs0slYbIZP7dRP1t8o1PUklP3sOnPuPeRxFRKhXY5vqxEd8I1SbtuZjOKmb4oDi +GHaeuRgHqNO2el+vPe13rB9OJbY6g8NlYsgghwVXz9EQsjAmUE8p9s52N9lc3Ikl +Wkv77fRZiUZq4m7+T9jkyiZcrYRV22zukRcmVarBzBw0N8GT4DU1zJn2WZYhjfpQ +suQWJFFo91JMZKVybqu+/xc/c5tb013WfjMRmM9Hc3Enuu2fIO8CB7JTOwpGnkJj +ldK1CGbWLpF0x89mHCNRNnH8NGJtvZSIc9bCBMWS4SVQ1kp0FO9yod7qYTd5MVcE +AilgTxT4ahCmrDdMOVU2vhj0P9t1geokTiZ7RQa20rBjYVCG8Ce690EGK7eNbZj0 +64KYKXSy12omLcQsv2S7mPAACqIp5x9EVLyT6FyiPXs5NpECZaGH2zhUMhsD5g/Z +1meq8KBkq6C5Bmpi+baD+qdV3BJYlq/4O8Pkl4o+Voo6ec8X6zSxH4kCOQQQAQgA +IxYhBLYubrFJ+5p0/lWV+hZrGZHH64lEBQJaz1kIBYMHhh+AAAoJEBZrGZHH64lE +XEMP/2tTRDtU48girp3OE5uoqx5qiUgiOUMhfpPFO9LNFcHc2Rm7fgtVSWdO+VZo +9fKonFTPZpDsF9RV302+88/hy24Npmgk0RJwmenQgBcEXkO4eN7fgq50PPQELUsx +2FeZT1jYAgB/WmVXSoaUpVESVg2TyavBE3Cu+bxDaEu3B/yyUzg/6MDqOuwiJ8XS +MsXl0sjNh/NlLIIFMTvo6YWKGpp3LDVyN+ACEnUPo9gdGObF1AKvkLsfZ2uKD0Bp +83HYey0qKwtCcnhirVbgXsOHo0frz1B9Wgy7K7IyB21JEUPCu4BEDx0CpGSgN8D0 +JMmvE6Czo6wAnViKvI8/3VSfrUMuIiH3KTdl6HH5scEdQrMn5nXMPtiCsc+xu/dd +q9DMdCu0YE3r5wObGA5fzypmBldkuSPoNU6ktlAkMTbLI2YBI+PJHf6pchCJLmD3 +J1nNQ4/32D5CoFzc/JOH4C/xybaFpJKfQ8MK3aLo1TeT7Nvd9JrFnELepakoE2uq +NEA45wI621qrI4OHUxgNBc9q4ynutT75GMTVC7Rv5KGo6ZYYENB99AP+xBsmNh5z +KamlZ69fMwIrsV7k6ERnYua9UKmLRLef4C0uVgL3rAsMzi6y5pyEYDs/x4ykgu3i +E+p3PMhxxgd9iM0Y1BdHIdhqQryD0VXoREQfZoAZN/49nZuHiQI5BBEBCAAjFiEE +UivlR1m9a/9HyLuX2rsuCYkqnPIFAlqlNJYFgwHhM4AACgkQ2rsuCYkqnPJf+w// +QWiptszJOaZJPV4VU/dzwPZ6rHn6Fi8mH1JjKvGHa1OMWgXEP8vZZGomyB635PPO +7dYl85v2D+6CTYpiHqMbglu3YbiVeGBqU80SKYScigq6LN4ibmyVC3yjrl2QCU5N +rqP2mIvMcFdxF1lNnqnUKX6FMMGEwxAPTMqGLrvm5WDsZzr+c2DjwvzdEO7aVrIT +wbe6MgQdodnzfecsbIbiOjFZZe14rEgGkciq9Fie4GItenAPA5VKcwjWVGZuRQBG +xhSm9PIvPBEek2WpYHdcY3dCgg/rxwAOQwA5Dgv4bY7h9gU8GCOBBtg+s0RUIXmz +8o+41zsd+XDAhluvQuLsx3vG72EsqDKCUbmO59AerqbewekhFMD2hZH5K8bQsxJG +lxGf1ZqBLLGOkgvmSlqj5noqM4lpy4ycUI8wc8847INmPC2W3pIPHEnYfyww2M4U +0xExpEYF48g3s0FGkzVkGwlwPwJjhbYJPxKVsa20xotbu1LRzi7Dk4zm7in7dWtF +B+9dI1AniGgf/f6dG0/UMONPH1YcOuSMxMP9+SEXbAq0D/2Kkh1M8kNxra8Flpui +FXeiTZZ+HFXvbpES8TbGt7XubTEl6lEFXOpyE01rAur4VJbshr+ClvIyn4B5HZ3O +0t6ABUKPIK6Xi5o6o+N7MBZQjRmRvpmkixXiZ1YofM6JAbMEEAEKAB0WIQTYuYdI +BrQCx/ecP+tHXYGfhBKNdAUCWxlUEgAKCRBHXYGfhBKNdFhvDAC89eXoGA/URwhN +AWZv7GaSyprKv2+UAO3Wv9qWEdHxy9iQcXNWb1JUDQDoGzVw1/dPdlC4/8pezm7f +Qc7tDjRjJxF/GhfWHfJk6A4OeuUHL78LjWiq25mCPo7JQZsEn6se2VdEoyH0r9fj +S7jh8iwu/5ftGpQNfMFILOqkgyb1cGvBB4lVWUoilDgD5wiTgaEENC/s+ozwK+Lb +CR8XXCi4gQFSprSq3ZeVxs5wsw1sChiMpzvyad/jShgLyZ/hItiWMx4fNjHyp1z+ +p21X0XRB9HMkyvnx0vu2v8OvHL8seQ6hm1YwJk758iBWSNCDdOIJ/b44RyeM64u9 +5XFUqxvEOZmpqEs1QUONqm+pa96w/xIRVlyJV2PtJWvjq1OQxlR8LQ/endqKOmHr +sWpCSil1nhXKf+V6cLrflakm8XN/wWh42eoL6DMuXRCf/igHJfUswXKruoBENF2M +pllTy+yhJaeWIEsfrsrLcaSTaonKPVcn1EzoHqQk6XK4i0aFXtq5Ag0EVFX86gEQ +AMgw5N0ICIJXsBkIUANjfqP7LqkHxVyGFYq0b7JEJOOiyt5Yym5Zh+vUpqlzyKLK +Li/bfbpXEfFkBHFT0n5Zw644Dw56vPoqkvnuen9MGB1hvR2J9tBNNQAa4qLAC8Qp +ijJ2JTY226l8lwBw6xFO0FlmlL+x9IpD+F+HlnJEQJzTRN2iEQfyqAoR0Q4m5war +LZpEKsKCUKpYLlKaFu8H++x3PVrUnbZN8tb5WUWhXuvS1EHxjJATWnflQEigcp25 +VQPb9BUmgNXAn2TRpUZ1fj+Cv4IBmOXvP2sRGf8F8Cjtq8oeU77lhwS/B/rHWNZy +Hyp2gHB4MIm2d6P3CUqyC+Fg9rBKKzdKpIVGDrktX0a3vrmOOM85DgPqxZOAv+bt +q//a3pyoDcXFeVnWrNnZi5+Z09A9gViuEk2y67ODBP6WAf37pzCTQw+PEjiw4Fdn +sqGf52KoMecl/VAJt+s5jCI8ek5TfCKmjgGGa4iYPrpr8D8vpM8LVkm60N+qrB3q +oC2iEL8Jb31gmxv/D1mCn7xMaD5zK/cKAFuS9c6uSTfbLwEBxYSD5mK84r9BlpLW +0YXPSVWvEJKj5MT7eJKeaRjmOrZR751NZ/e20/dcsRYqQPeO1S+KFKFMwW3OipeL +X7yvIvoAiSnmU5Xprr0OKvvHQ0dod8hNgJ+s+BRCPy0NABEBAAGJAh8EGAEKAAkF +AlRV/OoCGwwACgkQLTR+pqplQh1TyA/+JzqCFz6ryBMTFfAQWlnRshe0x+t1Xgy0 +a2tNf7y2/nn30is/m052/mdAJClT/sjXLycUOjK/ajhQ2s4oGtAxXdpD6qRLhm+x +HrTA0xM1vzk9ByH4lXvjywnXQEaPbykPesPLntg7O9BrrUyZrdQ1Ze5pr32vt1as +/iy3eCKuzVnj41DBh8+iVp4WzdWXaFoHGLxTVLjTLS3XnTjhreh4hb2a8RSAAZkc +lWqvrE3dh6LtoeEU7ObIjIcWpC21pXW1aNlsznZaYksCq2ixDgTHXaQPM1qodkVy +0UFXJwm4NeW2OLzL7SberqxaTJCs6tycxYTL1wb4crhJT2pl9m/Cv04bcy0ZoiTk +uOYZoXrbkUgZW4IvAZzcE0C8vW2T8VT8ldsas8L+3HuP/3M1RlQpbjfKL0EGvNBB +om0vWOIdGLsU1tbk6x1jAeYmDAfTib0EZ7eR/lq9nLTWfuQqNswAOSxgJNfLE70S +Bb7H6SjTINyH1SFCAB7RK9zsmKhntARmf22f4kvba8KQOOUDFQYZjcY/qPs64X6x +opKXBwj0FujyWw/yBMqyKkau1kUg+WSa8hzqy1l/2Kz4x/X+URQFHNwjC0aOQFH+ +8S09TM36SfGFyNABZaX7lE909QpxJr1fZblftobQVsuMU2dopypr40s+DjHnzrfo +2WJLV3XjwqmZAg0EVSHUBQEQAJ1Q+3o/AlU7bfMZmqC2AF4D0mw7bZ2TcIzOvA8l +1SYx3qZxFZq+XgGgBtrrp+4LXsa86AZeKYoj6JrDlW31Aje5KNSMVJ9zbgnxPs0H +/ICv/TMRx7GtocPZ3FP8mkT+JjTJYfFGWK2/AZLDVCWrc2djy0MjUMkQkP6AG4KS +29W+7UV9BPDpt35oSrRzixYkcA6cou4sfSk0U7OefKcAUY8YEGyb9jBhzkE/YlW+ +RrvvktSMD5bWHZKCDcUBQ8ibrilzg+rqZSjpO6XDvbGxYykIvX/lq1c09dPqslQ4 +Hx65Nw0yviXU7oYpKyIt4sC6+rhuaE4q0vONbNedjWANWg592CkPqjhkeTjGJWx1 +UTyEJr/KXPzVnBFbaAajaM/y3eEpyJHaL5Cz7qU81ml4UjFrpSj0RHUgGAIcdqkh +H9R1w4XKhLQw2ftSLsMtA0ziAj8bXt4b21++NbZ2XhKAVJhYyr861ec8NQEaoVRa +yfxp04vY8UsHuQzllFM9zlKdj2GhIZrkTbSslkhdynLVrKBHP/FSOgrA3MDJJITL +IiitTFnwpocQQFBKyrB7TgxcgQ2qcOjMfT9y8/glcQNKXwSTMxIJZKhq9BIhgPml +CmnIVCkYeprkK44Dbklr6yCnbGpqG2vd8SplSSc9BKhiWcltoefOwZKVEBVYyySW +xmJtABEBAAG0QFN0ZXZlIERvd2VyIChQeXRob24gUmVsZWFzZSBTaWduaW5nKSA8 +c3RldmUuZG93ZXJAbWljcm9zb2Z0LmNvbT6JAjkEEwEIACMFAlUh1AUCGwMHCwkI +BwMCAQYVCAIJCgsEFgIDAQIeAQIXgAAKCRD8YkZDSHA05RfdD/97wPXnoe7eipP7 +UXQ942z1buV6pTGv0Lea2aHn20o2BBjHp97YXroF/e/8W6h+Y+Fq8hWoXdYJdC9D +VgzJhvbXAIG8VrF6/IDGQ62r4ff/AIyQY+kiCOCCVhjwuqOTjVYw2pYRUcI3UwXV +PeptDSXcIZkHCLtEUnS5YMTdkPuZrAmucCCnfcJtevXbHD2yJYP4vwfXMbalsNBD +KJi6uYAFc4yv+/DyS13rfXJvu2pYGvtRd+fs7mBETvUTubhI440pIss6TX6MlxWe +xX6Ty8vI5HCQT281H4zqdbe5GdzGmIx1EiYx1sJbgSBNqCh5sRJY5/BXzVJ3dfM/ +Mv5QYY4ulO/qUNFdC8f1cZm0euOo3maB4jY+Sjaff7t0WIz0GufO4dHARwJg3s0L +O9Wf5+z/fbWOMcfvvcfaHNbhaKWk16kslc/g7NYvMfOuleM06YGyGPz//a9cbaX5 +3OiMupNvLlhyPO5NfGppvRn5xAElcAw1RLhHJcgvTtIs/zVVfHPaK41u8A9cXKnm +IUC39K4BGvOpPzEvCdQ2ZbAqzQLmZ1UICr15w1Nfs6uoERJbnuq+JgOPOcOkezAW +ELi5LdZTElnpJpZPTDQ03+3GvxD4R9sR+l5RT8Ul7kF+3PPPzekfQzF+NisrBhPF +b2lPt3Hw32FgTTIuXCMRTKEBb/6z74kCHAQQAQgABgUCVbZPAwAKCRAp4Eebmcij +l9qGD/4hBJIT/IfwJ/zY9gjsgaoNU3BHDajt2ryKxwH5+EUd8UWFcA3BRQWnM94M +ysyt2aoGR7tWDUPdsgWhxdg6I3B/Ynt/iYE7o4vRUC8NfTZXKH8LZlJzXm5nJToJ +YVAwIbwk5KaBAWzeQweQviq263Vjmt6hh6ya14h7TpRXJHDzJPVHUGTE/bCFn3ur +Cy9RQT1xUPTzAK8fjzp5/DsSzAjNgZrUpxleOLQy+Nd+SxW2QRBBvEwwjtJVejTf +jllF7DBu6KgYvmC+8A85uBTjeyQ5FqcUcXGIcQqaqAcEdcr8sqpoVQUwpxviIVM2 +zZcquERewSLkQwjUAWwnONxdGpPnRaLZxmFd5FzvS4XqDOqt1a+jBrag4+I7rMYO +JOpkJbUACuT9AHMa0+NWH6coR0fCe+kr33XdQCQA3rzaHxCShU9hc68goNhlEGvk +R+lTJC3Lav0xh7DPRg3jOUY/U8VL0XGdx1JmJkmpBWJ/QKQ6nW11LEvKcdy6NCAB +Nk22By5f0nBTA+nrQy6uA5whmJbednD/P/m/MEFp1Jr39MgVIkAU0GWp4p0gZC6K +TRQf4LNFG1IVvfwXuMw/CvRBRKS26e1DQda682qPg3wMWbjn+fms3X3R5Gi2tUNd +maMZ6KepY8hO4gKyUYgoCn5DrLe3skDvUwht679ljplx+06RrokCHAQQAQgABgUC +VlFaJwAKCRDGI0zwI5XNCrltEACS2ddx47cYKK8y33JHVCvQ6/gDhD4IlIgvjl58 +sWZLfSRxuQce1qr7QVk2HZloxqu0LXoxSNrhrY5R6ODndUGFpJWRCtWT/oz8cDr+ +joK8iFsVb/kL6dFYF3mB+/Cxa+Ou0LdwplyjjCD7JhyWQNtIf7YQ8Nk4ogekHLjp +hPP1ZDXxInnVZWQ1Q2JmpEEDo3LkYWjJ3oSlZlgQ96WbM16a/fM6tB1XMtXbj+Yt +6Nwsva0qYjqeBfhdWJdQJFRTcwfz9X5XZhNAZxMz/ocZoek3QtOqSd/rMS2j2r0W +JFNqJTaTMTGEGrxB/5xWrCb7WQy3QUY6ClPjtUFYx5RarraBDeHk18CzgN+uIuA1 +RGVMLV0lgASq4WEH/ygFAPWH930KNDKTzyKJvakkidEEOwrYVx9AFqn2Jp4EVigF +ZPMxAnGD5G5YrXAibafSiprm6sFhm1EcTlEh0M/xkuiCsE4WR9cYnGVEFAPUZpvv +uqiF2nRKcSsbDg17eAkf9I2Er7PMeQcREitFkJH3nN1iQp9naPI4/NK4AFVGKARB +VA8IOfSFu/dxuVMJ4ljAbaZ9F2Z/KpIwAsoiBd73K8naSXxCBpU6wmM19DMgp6gc +U8iblTDdgHqOAMVzm7MRoftZLPvgDsqEZiMLuG7DZO6CiwdtbGmEkp13DF8rVa6N +hoB4nIkCHAQQAQgABgUCV/aw8gAKCRB9v612zeyg25cRD/9eRZgeYmwrJ4NkLwwV +T7++xWp2GcWzpRdmS9/syg0WS4wMv7OBWgykUd+1N3IGo0CgSed1qSTbXaMrxhYX +yDiRBchr24xGoksziaoKX3Jyj+3An3P0QwD4ktJdgrRltOQt261INkQMqCkduZ6T +HYLU6xaVEuz09qEXk8BlCzQ36b4skGfDpsQc5JO/g4Tm5VR/2e916zc4BG+QZIQZ +RE2ZRoVyHFa1n9IXWr0l+PQr/GCz0a3znmi5695FcsgamOIRWgof92uyDIoUwlWu +lkMOBLgZVcbxurcZMWIwCzsE8931uMj6OC+q22Ai1lxixb8hArUEigboV6t7hw++ +74iyEJySb1Pyc4r3y1m6i/yEts0P2ZbZ3ssKEkjWv8dvNsoiXSTo6KB0UysmW6fb +Oa0PFP1One7E5hJpbZiCByk1SMjby2/oDCgDyiRVj3ctaM7mR1kaRuWJGd/94nLs +0lifQs6iCy8xQkKVEAadlMcsSvfZaGrQwiaVdrjeSvqg8lPl3BdfLDkQuy0RDO1z +MJ3U9gGRtAdSkPmPc/CA1U6KcKdt3ilz+pW1hKqmDaDpMmLVeInXrfyOGfaT6LzC +in93J62I3yUZHvq3BgZ7H0Bq8QBSlVH2vqp+mngoGJsSF28vqjY7TdFC7XsZxHNd +IBjOZSLlTmNnd0HPkxhSOBRkz4kBHAQQAQgABgUCWLAaYQAKCRBIUiqIWdvYKGYI +CACypYMqHnA+b97pYdXqHLUarQjsZAKBDRHz7d5ecejfFqvPch839dE9a1YqBFzh +4Q4tZt+ww6EJkSQ9LDmEMpqtdMQxkWACY8jn919Kb0ZGfhe09FOHUldw2rCyB3Dd +upEcL9cgmLH9EL4YE+hCWSslDR7Vfaq2/btwNWaenqQvxMk/MzGY/ttRs01K5257 +oNwJPae/gDwmUuAIYfWRxbg9/DGe/jsK1HeqLfunG29Z50C0gBkDh0qehD+pLa57 +Cs7bNC/rcx7q8bSYFJEdNYpibkhX2KS6GWvy+6lzchKRFEwv0ls0Vg/ctkJDOwy8 +13GkXlQMia/a4sdZQ0GxBSKriQIcBBABCgAGBQJZU4fYAAoJEFyzYeVS+w0QJO0P +/1/HlIcBL5f3fUr9pATQmRYwFt0Jmadi/7MYUnCWV6zhcylHZo2qfV5bpdaq+v1o +n+2CymznTVCOys4hAZ/vUhHfdF2rqFZM1NhdCZ/SCxkH1BwCKaHEUyrgsAa53Gga +Mx0MAztw5N9wIWepak7/wFS0Sh0F8IoBkwScSuHAhGflcCvbSpOga0AePEZu6YPR +xeXsuSRj0VoFJ59b9CCTecrGeZvQoWG6hfFcLzMNLcZoCoL3QyqV2xf0ufQaeEx/ ++w69g5AHjU3Ls0xQWhRPrIjIJLGSGCmdVZFaIjdqkAO2WgOS0G1KJtFnaymRnnxX +z7fREgOMMi9zn8UbJlpnf+Rca8JtVW84D6DHdQ3ORMZcqp3nHRsw7otm5pbTakSX +fcrUaumFBmM16eKkJFjutQqAt5pJtjPBMewxm1LV4XYNM6GtPMPZV7jrR1YWO15S +1oztVKfHKeA1cbDf8Dl7ch9aXJXhqOGhLIMlPwx+e6axSxs+xIKdiYUQx52ZpaJ1 +qe+BtVS36pDqmZak1OJjwPNuwvKjwsenDLEbxUuzhIgwbMJBVgSo5FAsOKywtbQT +AQsSVrWZXPmNCzcjq8id4ehCZkSBzue6C3p9+OXtVjouETjgv8EDBKxZOwdz+NS6 +pq8G/Bxrip93GvgMO9IVa2fu0N0URUy5Tkv779dOxaruiQIcBBABCgAGBQJafaNh +AAoJEMOw3g546s9eya0QALCjf1wSCUswGtRWvRiFjhBL7ynsL3gN7cZAqQGdX0aB +0estQes7n8VZjkfv1ZeXeTI4pQ1ouzcxHLpwQ7NCiwgXUdqCnZ1mm1M7B9aqJGxN +nW8Cfwqx1HmcMcprZZpFc/7JFc9NrS+cz2DuK0zGoE9Oyq3VaHxsaU6evoQ77YsV +VeQbERMwRvtmwiQ35DSjUqFWmXIpMM3SXveKzX/UYIocUNzdDHX8g+S3B7iXXI1s +vDgsoAn5sUw7AhVDZ3Ngl5/uQ7ipLKaROIwb0Sjs9LNvcwxCHZydId+VxXxCaq1Z +iU/yB9e0xYRojECpp2FZGQ5bMUHDT2Bf0QelaDwG+1PbQCFnXBlieXTpsFAkhj5a +22qiNR2+oHLufX47nlx0K5jjOVhhDHal7LIaEl/Het9qdW0N6Tis/TRlu5lD1HWp +d6C7x9SNBrfBEIv53/yFl7FF/f0lUx6GWweT5sBmfkbGn6fOL6ka6ww/oM9z4g0g +R5M/GO8QUJVyXuOxV39tXvp76BL3hdlXJDZwkEc9+dy1Uo/1PJjbreSGSZqU57iP +aoKQFFhAThLxlyDFC+Fc8VQ8ZCJy3YXDfs12L9RmRtXO21OOYfAFaKpCMJnmbiov +a9sFLbEfTN66lqnIxOepsbVZ5GFuwqxPRIaH1nVo//1j1Zj9tsyhgH8GucY97ZDR +iQEzBBABCAAdFiEEOOn84tqyMDqaxg0YTn3VBQ8zqOEFAlwsCVEACgkQTn3VBQ8z +qOFB5AgAlFVwqF87o7p/pqanExRT/nECrlUqHINpGVi8Fm9/UbFb3VwdoRVZkWi6 +UWvaOdYJAFsXDhtvS1fieNbwtGrE20hZkHy66m8zJp7YwQp2qyKw8bbQeyUpgk57 +UqgC2nGsHStdgbvEsFiNgbtF+0bDvh4Lag7wtCcQgehXy5kpyJFBY09q6oEXd8HN +XZU9+VafxBuJvaT8U+8GT5VeRiYv57tB5q008qbw0o3eZklTbg5ss8VibOPq6X1X +u5+PoL3lXtmd4ak4guCk52KCr3GTZ1oSZaXLB8PiWLdiIG7zLQFYJ8tfqJWbzNZh +4Gk/FDh7D2ytVcKukXVpG8B9p3Tz3IkBMwQQAQgAHRYhBEkzQd9njuqjopYRSdQO +QGJurFcbBQJb7STTAAoJENQOQGJurFcb9+UH/2+U6+2b9Aa1i4EcpHU1b6VMM+/o +2St340Z1GKxDn4KIMjN3aY68fOgw0Zjd1Au/BRi3h3F1RVtOUf7T4LzB7oU141g0 +ENBf9C35DnOYE7jc6t9K/ictKaqhXtvGhJjuWynRwEP2oTRaeGefnHGFAlWGPyHm +1RXv6NcrakCU8KRKLdGgdcxgXHAPDEGMGSJ7Ewa3uDCwZywuXQfIeSQzq635nfME +5afTEFqAFPtOOCR9Eq+jWUWlb059kLi2RlQKcuOvtVZCiVrt296loeAwmyoeo6Xz +thd7UxwB1cafBzirl3ugb+jV/hFODaI1aAAE5RPz+xr8018OhVeUW0dv7aW5Ag0E +VSHUBQEQALZp7GfQPKLySCfUZVniMpRIR0ckIn6s4HP6+dLg2VTwY3sDgOOti4x9 +/hesxRhJFPqtmqkntANEiTxf1oY+jDWFy6Im8YuQ+JhpKCGqPRMZ17eC1wHOqIEK +WOrxUASVOTa/Fwnn0G5tJaGv6MubivCRy1gmdowKLLJ1acw8DXjdu/gfIefjon51 +oUAk7p9cc+RCYsnNMqAZn+Os35lOAjFAbD7613C5sOCd8Kd+apqx4NbTcj4Xe1QZ +YpDK4La1l/SGj2eNHZ6xhv1ozhWAdwisRm9KUwo+xguLm8aNrqXlmahy5nSFXOzc +7H6fBHMCW04/o2dmX6uhfMvo3rG4IfAmsWJ+IRLNt2j2EauR+P27lZmYVMN/wAC/ +WZsl+gLQENB5LVbUHu8pD+wy7BKXixvrzyRWN+t0Hg7Cx8DqMZ2Unxs4lZQeDfyq +iJIsTVnBUxvBkhNcynHSVTaFvtzAd/hbTGVlCYR9BcioOai2iQrQu2KOYLHXVPkA +qk5+oHGQZzF+Y+C2gJluIYdUV338MLG374iuboV0AnlJ21GqJInnrQ8eLOimsurf +WoU0a9K/2d1Vs76/sQE8TVmc4sU3XswhjgdsnGdL6uGylwbjfAgMjsuV9YX+0XNQ +YgFUAiCxyQ7c9AJPx2segwGtgB58fWJboB0H9NNCq6CxGPhmsamBABEBAAGJAh8E +GAEIAAkFAlUh1AUCGwwACgkQ/GJGQ0hwNOUbchAAnThJhqJS9cRuiPpQ1XaLeqAW +agvXtNtWi1qglKViRQ6dJtGk5gn5jiNYE2hY0nMYatVtBj1KCSlGYZN7ZVX3UgrV +HJCPsblihH6iWLb1LU16SuIw3mmQaLydyjaSUSMp269eeuswkkCYR4ghlphPzOSj +d4D7DkWwgUFxJDjUlbLJX9VpuuoVOrqkllGnHg/uH5eSwpW3JNQz1nIQD+/riyjx +DrTkch+ikU4Cpe982KO8VNSuEDDf9WjI6Gz5Kjb75F51DcDu0DM9fDcflqj3OJLC +YFtTtWj0Nqi/wEWOY2rWegQXe4srX8+3eiTodBTiJZoQam1ne3xBqy7EgPhIwRgc +FuQZyDJsT9cYY4cK3CNfMvJACuVM3VtoW2wJXNq5bLsRHPsTmIfJBnHPpmdY/2jJ ++IAC7E20jv9E/mCYXzgzZy9XQo+6D2yRpphuqW/6Oz+GswVFQvZRzrld15QD40pi +cpZzbFe/j8cD5V5byoIeEuAuGT1HP4j3rbMV0dnY3HDqDcVVOAqiQamCoLpf6VKY +V5Ie0HxCsh/uNlBE21YbLXQVVGsyeknlJ7/QpVQxrAhIXxGXzTpzqA8yRsQ3xEqA +MO4ofdbyIU8hx7CvN6dhywzCz6bS88f9ABQX6OjFhhqXdkUpzFjW74efcIk4ZQ3i +Pg2rN5Z+Z7AKOu3TGHSZAg0EVVEnSQEQAKSjgoeZMGbTWVx/giw3hDGCUi5/nWVi +oez0HmdBs7o5JSK89c9AGrd+7r3J6WWlCJZpaEG8kHWz3WxW4/UbfSFzCXtJHEFQ +1BRRdPuWWIu+FcS9wBuXuLKiLcywJ0hwN0m90xIxxsIktIEOXyERNZwaPoyeiP8c +GvSvwhiYt/5ycII0WDl/iYFAOWCxelKOIy6WmsXCwRRy1onX/tXRwy9eWWzJcXDq +XN33G9QuOKH4Ld6IqpAbxMic49mBpZBJgqvmKGhUVlWJGbSaUDNnr+H05ncB40ng +uG1OHDoduE0D3dGQzH7O3od4fh7xAZBArkpl/gq3c52dPIndw6cvLpRADNACyZwV +5/sPBtsRCCWBjnqTjPWIHTbz14lMjAD1/h8k2OXDrBy5RoZAZIXTI9gOrXU+hmNz +S1JQzdTEt6rBlyj6jd6hDh3psoQqZ0cvJf0eSDtbFc6rKU2b/jmugUTV3dJMK33j +aff6BG04QYuYE/TZp3Ut+M5g1nKOW2/Z+jrEBpPTr9hPZi6GBMv5o5L2cu1nq9tX +jcgHDo77GYEFkMzoJvFI03YHO7UcWKP/BNS5fcOrxxIKCQrbH+jUvm7Z8EEOviIw +u2EjVMWFUXkHo8CBXijzomzvDDjFadenCpeVUTvFQe6YYfcgN9gu6IrFbHbJx80k +QEXzTuDtXZcFABEBAAG0LsWBdWthc3ogTGFuZ2EgKEdQRyBsYW5nYS5wbCkgPGx1 +a2FzekBsYW5nYS5wbD6JAkAEEwEKACoCGwMFCRLP94AFCwkIBwMFFQoJCAsFFgID +AQACHgECF4AFAlVRJ/kCGQEACgkQsmmV4xAlBWhk6Q//V15byi2kR/uR4G16ECkA +a3pzhdA1NzH875IjBGAMjgRsxw6vaeIc4h/oJ3fxQ7gfEg+Bjdisyy8VLI5uV1aA +AKpe62hObPvR/Qt1ztO/+ElWVW46Lo91CB082IIyWSa8LOjIPF0bdqvoVCT2zTdY +D1Au1a0AD4WHbWLWF2kKpDzC1u+7liHQIQmU4XzcNaX6zJ6d353NTDz+Tdk9dWWZ +8yHc1WI7vKwZibwAUIsuFFJu1MfsDHPDwJpIIsr2/LWJwumenf49XHqZ2eil7Elm +A7q/ii/AQgEBxln6hBoPOEHcO9g3fC0+eNtaTymUScULHii8/s5Bq0uKAsUCQwJ8 +gUjhHzWamfgFuWQZtwisZeA1SJ1VgD57aXKFwHs1TE2O/wFFTSwfaB3ekJzK9CPh +jcFAeMl38sAoF4vbIGrpRoW4jvkPVqcXNoqpSxJyObbc1Ksll9afImd0rZ/76hvC +kzBPLTJCwR84XbMgvQTmnF6AGld9vlQvINqDwPUwDyAa/hp72SBxHDxOxmoNGvx1 +oFME4yc3LTUFxRxvV+3VsWFIvjwpoB1ijst5LhTs/ozcViZCCM2I3KeApkP5nAya +hSnmeQQ9ILr/fYfKRk+p7WqUtFDufUCz1oMLIXx6yd1pMto8dTyqkSXtuA9iyaTx +xzOwb9L7bPU0CUKjEUizZnSJARwEEwEKAAYFAlVSjkoACgkQ8iHF0sRizfhLQwgA +psIjObXyMiEtNg/QRdSPdCm26prakbeSBjzXm68lk+kchhUz15p/7BkvGjetpGWv +GupnC3+dJTOZ5HQYZVOx/2oX58MyVYNl+izbooCck+QF3DLoJZ3elqUlzhM4+Yn+ +JciGcE2WMSH052edU6wSM2Qv2zgBaZWf355afRZeD33rsV7hdnsVhERmnMvWd/dk +X3bGiMisWQsx7PcqeW47r6BiFDNeja+Vo1bjBbISGrn9cq5kNG+czY26OS71MCh5 +aEhHiOCXeUN6Io4khG7p14RYEheeNCA7Dr68JwnRNkS9o0Wrsjkm5zKqnEckUNis +2PrT4ySXRrB9wd4X1PzGxokCHAQTAQIABgUCVVJzmQAKCRCZtd4LMJZlaXWID/9l +4b5eosARYor3eEPdR/oovUzPY1fY9KESZw8yHfRFUi+qrsSYnYKJgnFoJ8OJp0SA +QX1AI1voq4NOCVlbZN2im9jmks/eDYg510u73s7cwmZfKokyxVELBo0ZA6e55s1F +F+10JP//tmmCryLLIDv3/FmLdDHY04nAq11FARLRX9BoQzWSwl/uAKsFJeKvFQQv +4atV5fsl58BuVppqdg1A79lT4SekAlGtCOmO0h1/apDKoVYtHeSg8AZjss3DKNNm +FDJtAkeSRSgmojPe3lplNiUJoLgcPAOL1rhRIKKY3YieVs54/EcdW3KKUtOm4qrp +obuyzEJWmrbeiVzV652I+cLML9iE5dxKjCNP87xBLaPKQFJbBDKfXTJuexppiQJP +jYPWt7/08odIFoM6OKdz2IVnjlYvBKSbLxmBzNIcNRK75eQCnIVlMRfKtvAOOUGd +l4Hzrf0eGMQtPcDhsQErv9hwCuV46TcZNw1jpvI//jGXKueujIIh/YauFUP2rMWw +X0vRpi1+mFnulLDewGeh5ORc0nJTEeDOq60lzT7ilnbCKuQ1UR4yUj2EQMyqHF/k +y5dg5QTUmkTuk8f2T8FoibgF1QDfWS5Sr+W8EW4YQYzJKE9woFplyYH409EDYqvP +bKQogTgBMtptibQBBjUnl1SiXc0XlybUd27C4KTvC4kCHAQTAQIABgUCVVJ6bAAK +CRDg+ogVk1gtkZ0ND/9PYWzAKLIBV5EzQcoQ+NdQXcqNv8ROel1Se4sz9h/FCI00 +JdI/SvnBs1JupECaRzFYT99X4UtdAsLYlZBDMB97C7Vl4Yy9Q0PM61GZP7iANKL2 +JiOyKXXkME8Sk5ufVdRwBr/Yb/Xs00zMj7X811j1qqmEdalRNaPdmRBL4kbrkmqs +9b3ZeJlZtvasVT25mrR3Sh/D543y4dvbO6UiJXJeEQrLsNTszPHIhBwu4x0hMgtf +TqUjNodZ+zeUGNNe6ZT3QIYBgLGrCoz9wGMyUtX1RQBNoSIOq+awG3r8/8SzNNtd +Unfw1NelBKSmh+V1KIpUAc9/OMNmIAEcO4rTJsEE0kL3sRay9lzOihpUyJMM/Z9F +TqsTvKc5Wi38Vo+R07dapUBLS5TpS89+pCffaM9snQbuRfmhoCufSslp8j2OSRsF +Tq5BA84gmQNteSlwuXs6r99EV3sQftrDnCo7AJJKDVeJ8gghlIYGTMYrpVjsC8Re +j7DxJa4fWznXhdtediFzGldQ+nBj1HlSeb9Y1ikG0ZAB8jnVDYePu5DtqL6AbWcr +6n5evATlq3/YieDPBTBBCfZ6wAJ137gaRlPsjTsBng4V+sXUrQegS3D/IEW/qznJ +iEZljzDW6Rx+cPmMeKRdcEpZ4zQuqAbgdX82Gjn1tiAzSx6ez3V+2Up9RRKyAYkC +HAQTAQgABgUCVVJ7xAAKCRDetUdYIbCzY7qwD/9Q6RhhHMvzV4Dt/QYMiRwVEdo4 +XJxPZJfcpQe3TwyRsnS+pmMuLL2k5emLufzomXc20Dx4StHOVRv7ZZKlSrIPL1d4 +u3DFygL4mRg7BIZWEmvtWZbfCEb3Kjg6ugh/+E2tt6sIRmSSt5lkOBsuwB8FyllT +uiWe+pkkdESL4j6yRUDv5xE4jT7ha84aq1Rq+fYoLx/NKPAV5xHNxr2u7rHL6yFn +0IRqu+1EIgDqnraS40f07OoSmE7QTsn4XWAm1XD9HiOtHP/FZKiUPmnm0C0QLvMf +7mP9cENkFP5GZjqxMO9HS9NWQolpato5ndcWxIn5c5oHmlVR2eyqo4NBC4mu+l0I +6dyR+C0Kk5koEE4KPFxCeXXXT9h7O+aeOs/eZeQuI5vCp09MUPUUboAPzViAMNJO +CKPKwwl1p6ccDA04KLKDKhL5Gt6JLosoD7G4nACUusRpyrXwihRk1PzPB4+2INEQ +0C96DcnEGkMwMy8SVzxL+bjVbQFdFg5w+OicvDZO5xrQWY1CBdqOW9IGsSCc7g/y +9DNU9dgNlm5kLnA3meEtHWIYgTFHuQ8uiRFfSgCHn5beMIzSs05Q8Qph3gvAwflD +msT96Qr7woyFTKwL0Ioumoz1yRGRhMuB3oyd3A76Igd8ENOi3VrFmGVXDYCXFFgI +OhAo1k/Q/Xf8P/tu4okCHAQTAQgABgUCVVJ9hAAKCRD/VOEuHKYZshfsD/4+9FPh +rHb9DBeq7e13QJTY8Sin9uFin2wTpH/9Qh6eTMd1PeF825CfrE4B/zFK3v8v4Mfd +GzGvu9MaGHedKc1RN+rusxA9v+EVX1TLceAJNhTTMaphlJzMn6gnkC0wrgdmCmsp +nxT0DzvCfYzf4vaGOCP4cHXOAvYqz/U/BK1t7Nuf7tmyePRn19EQKJzvJA2K8Gqg +/v4ovYtKXtJYA9IrCK6eR4Y7A+mKUNzGrb0poDcYp9B1CxyhRrsgWHoNUIKVpVp1 +xSOLr13Z1EvG0Pu24j8Ygz+PuEIPaNJ1vsCTff+fDT/XjI9nBlZnC55khg/r81sM +KPIwYH7eTKTUmzyUHZZJAn6z2JI38KG+nPk/ln3llHhTWelh9H4enD8yHzTZDrXu +iRCZg3W8fI5StezmrjORBCE38fkMB/TL0IZdiY/K9IPgcPQEX8RSLwAm4uua13qC +sVy18BhXTRshgqAwwHyd8yj9j/H0vvFVU1thapOB+aMLr3w7tn5ymsxGfx+A933s +8AWXLs/dvdr5tn2LQj7ZiCTqPf4elniVelwFL5DqhZ74ZJjBmiIAVIykEVonH4xO +neiFFH8gz7/WT9V/Mh77fnqLk8CTM7DPZLskdL2DCS4zqcMuviSszY35n8BJYZXs +p004NQeVut+mSLCktPBdSrRb956dMiXuMgVWO4kCHAQTAQgABgUCVVKEKQAKCRCR +Pzdd5iqXDJvFD/9bhqFIHOo7fwTbEg5Chb5/vPe3hyS7Ciot67xMjPGGUWree7l9 +LytmLvTPJdXfcYehthd/JCB2YSMljfPUwrc3N8uahxDZ2KnESByG4FhCkzQrQBIm +GCBevNmsy9SfH3G4OnXlOTaozPz+RkqYvfypczzbV6B/f9JcXcQRYwGmTloohQho +HGGvm1CXKNgbEZjSRYaROpJ2NCmaXroe3ZhvHxd+d2Z2pQUfZX982M7mjRXTkqzD +jdhx5j16bi25ZV+1JDiwul7O3TWFLY/VQeK1YEpWuDbMSeSlf05l5RsHR3W1nNTh +mbAf70SmqO0rvn8Idla56Siphl+Wbl8JNpM9YyWrb0fuf3o3bdS1uIrQzO3jiLA0 +DzBfjX2LEQ5JKm9M0fZil1R8MDMRZQFvNryF3Z1kl1ZCEuwUNGowF+U3yepko/E0 +hNWKDd7lmtRZfCoor5KTI54WzqOg2lsDnq2Dk5Vbf97qJm9fy105WXMSvgIOiNJE +yOvoVlN6gzA+dQ5bnuz4eKpq98I8RiO9DiCenyMk1CXSYUj0+NQJYU52l/f8x5Qt +eiENGFiFwfMgZbOBuKTKL1iCp4l/RbxaHiYxc55m3mIqS4U60bpV3be68Cp7m96k +Yc36osRh948SrMKPZ6Zb3QrMYGOxiWL9eVOdSOYWMwf3wF6VGd26Nfk9sYkCHAQT +AQoABgUCVVJ5bQAKCRCotR9egDLM5JM6D/9cyvDLDOwZuH/q8/eWtV5S3x5V75Vd +rjnIma9WfyTqgrv6v8oWV7PoQ2C3Rd/DQxu9ZiMxncj6ctufptesIMCm9trlNqbF +dFzklBg7LTzSXnMOYxpOf+xYWWnrzBR4pgF9DO/zsr71x2uKkQXgbKbz+8O9/Rx6 +/h+33c1CPHG4gc5OopSLStnnltOpRZ9P7q3Rt+CJLutXI3fBGnBRYi2NOAZkszlj +1yBZrgVOMvDZJJbdVR5J1nFCYHbowQD6X0OBtLwksfbnfcaJRr8q0j8/4130eWQ0 +pT9CZ706JPG28CZfNJo3UtFlH2jpXAh/G+b74fdYtoMeKg1z38LqVdjm19hoyYXM +DiBoHKpX9Xd43ZZU++DRsS79EW+e5a6stUZLUYfwlwXPNkCls052Bzyqq6NN8KHU +FhbIBVrRWxKJRJ3/Wo2uQJZwUKKoinSol1jHfPkc58pDOXrySaX4HPcaFoKWtGOb +YFsdlCDw0P7IhFh4I2Zus+U3kAqaC/DUPgBzRNI4nlq7ukHPy16lStq/I9lPxN47 +GPW+qb0EyewarV3JmRyag1BOH9BINBnR4/q6N9vbYb73D3Ttf18B6K57ZKjQ48qe +DVKZ3W84kZExTR+3b1DeIAEjlq5a4oHvUo1KfXXk0hePx6a2QJijBaqJ6y0UANdC +FMg5nOuckRpsgIkCHAQTAQoABgUCVVKEZwAKCRCt3ULg6XStj1FrD/4+J6z+z4I6 +GTYdm6ET0EDVkO4/ZQHGVMIoIvzhl3QYTAeE+r44OuMxSAxO+B6rcgNUNjmbvqLa +N3x3Syree76hBcqiZSKzT70t1OqdTMwQxotRsVMapwk7O4m7fthF3eAgumZguYj0 +zzicHoir4IahlVOgWR7AWHA29wsM15wJVjLiIo+iIhX0okQAML924d9BqEZeTB4+ +bV7UcH6AAFyob6cDZexkLwN6ydWNpXaMREHqGavbLdlkqmGhjVrepFxIIPEnQsxp +mGIuWaDhgcy/W0Uw7r/gQ8UHa8rzQW4+0SqvBBFTJknX2OlL35ZFLwEUglgvrf15 +LRYCu8Xi4EMLULIMsCz6P1B8MrNpN/tPQyLQoKhbJRAow7kszL4OFbCma/8nZMvZ +yxQ7tT52XjBagNnMCfshsr8p3UtsKSm1XkIVts8t70U1cSG+kXtCyzs0wsNV4UH/ +HK4S8fiKkxTYGIGDReFqtVr6LTGOJl/6+T5z9Az8GeYK18HXU67hH/z0eHikvem3 +hxSJZrHt4J5vfC15zyrhSKLdmij/pxcXjCffU2fEJ/Ngqk472EAQ2k0EawfOWTSh +dsQ3yeWEOhz2CW1a9nJiAcavJtmSo6eFLK/hFCJllvClsKddpa31TTc0TTs6gLnB +93V+tw0JlBrueNErAgzCE7qhoVDT45LXoIkCIgQTAQoADAUCVVJ0bwWDB4YfgAAK +CRD8n7XhIU7pK2pVD/4pjC7kxq64PCKDQO4QNV/481TAVXDaE30tkAX46waCJEqs +T11hLKnYS25bD+DLXQreYSxEMV9lvSGHqa/mRG18Qw/MdUECO+TwBCmeArGw7EnK +uLG3jrppW7/ycEvKeoPRdkioliWlFzIzfrB/tfYmiCb4W9CEDEZh/5Mb4jQUMMLD +I0sq+dcvtmOrbmSIDTCnPcvponLtxkmDtmMpgayUUCWaE/3h5jgGQd7BpiXE50IV +D6lpmsbSy/RiiCKLNjI+yhw0SJoLZ+MhDnCDuOMOKOW8TECKm/iXnGe99l3eas44 +wfP6LSttxpwrRlorgv0rT7LAKYC2EqwwVgXfGtYUgjLTfCUjGb+9A7uMC+L5pCeZ +yRGvSUoulBtmmg4I1OWz3ACV3iB43y4t+G2LKggkjgZep17Iq5KWKzWlG8RhiI4a +iMtQLl+ft267TJTkKLX7qGrIYjiYQnmtriGgq59AjWoNxOTeCmKoCZVto7lncEvJ +Hpj9N/3d8ob+F1FZtIgqGIYG4DJwRbPMw6AOLpXQWgwKhWfwJrpvRd8l0FIKfOwh +xhCif2RAAqxmTQKQF21Bsa3DBdhs42xscpTiK4LxAMhZk+CTZpFvfFxxdHFrcUba +z2jqt0LGkh4NknHEM6U+gqTksDL+tupk4bq1GXaMtzUFzt4BPDnSp6yN+311qokC +HAQTAQoABgUCVVKvOwAKCRDgldvmp8WiZqHdEACx+sFSXzECtHlyEvhzD50T0Jk3 +s6fFDfTNr8oMnboNvJdbwvElfL3uaBClwmqFlzjPw3xLb9kWanErzXfdVZsZFTb3 +tmzI5S86I/fRQyk9Hrgm53OUP1lTR2JzJGUwHoYc1m/8RShNgdCJaWsULsmKIAVx +s7u34EdqlURqzbglh5lhyeKa/nuT2dDU82R6a9//ahziIwOFlNrHzlJnthCpEdju +tT7C3+pL3ohy84K60G2csEFwnyI/3CZB+rt2YM98z0QASnR0cAGGRPMT/rGcRUeW ++XiGzt5hUAexJSfWYA+M9do2o9sDiw5Ic7+gi425Fciya0z1lLMqVFY2rbs7abm1 +Kqkt19mT1S52f491WggSS4IRJIvKJcL7Sj7Jk3fM2jaVllcxtOtivg3rf83Ke/f/ +cMKKVJ7noExiVlpZabZY/Wl/fzrS5FMN3km83dYUhHh4LlNl/OkP3QnRTwS1p5vB +JuVytEHLg6yv6Ae6kPu4TzBkol3lP3+YSp8pPh6ZP9C+jDzKbNZuTcP1htDariF9 +bZf0XPLr4gn8m/6TbjO6ezbB4IMENnWzAL+23nviDE8kLlW0ZPux4hZwglBz9FHd +OO9af1yDJgvwspe9IKPMqGCcZZ4ZYQ+7y9Z3mvzaVPjDQf2oPSGAI6VvQy2pQtau +WlBajtmZqfid6Q4cVokCHAQTAQoABgUCVVN7VwAKCRB1pVGnIpXsH3rWEAC2oQ8a +We4aiezCgD4oMnWlE9UXwZ/ZYNlYAp8xQvbRr3dZJ707Z976PlGAsuJIejR/+IbM +JUVl40npbFCiYYOMoqs6PAxDZsnuymW058WXFUSlBbwXq5w/2o4gQxy1TksQUSZC +x0G+tPGilegcCO/5hzPgKzYNKQ1mg00TIu+PRo+cDR42Q+tWRAmt+9k64Z2IWmA1 +NVCMAGcCC2hU9nr9HMTLXZPZPRbzL4TRygafZTBqCd2pC1YFupER4Htm7yd1Xnd3 +nqSVYU4e/+wU3K9U6fd4qWIkSKP+F+LDqND1zTM1c28YB+WsMYXI/cwEKjzOJsIJ +FJbZUdN85uDx7vT3zDObm8iL2xnq12jmm4G2m1qWVfPCqL5giMSJlrPQAnrYxePV +vxqfDLQcGKSXW3J4VD9yTlAL3nn+9Lto2qD89FU9ikfxhQwB+BBiSHNwXzyVs8fA +lkb9+v8CjPXEaRJiU1lW9xyrcYbQy6O6Au9EpE0aoac/x1x9kliZ1DEHmM91jJCO +NQDrVlbXMO9W+2/uzbWB/PtWnHSa6gDPxLld8BGvoZAJ03yc9qzykyz86Rg7IVuB +KMA+PLRvBZsfJDmCs8wu+KfBPFNRqFAjC+yGE7v/JE3RF7fdBcQNLvNernASmVP0 +SSg9NnBjAh8uhwpphMCx0ckARqBF+1gMUavaZYkBHAQTAQoABgUCVVOLpgAKCRC9 +AM0evEl8/asxCACB269wUL4VODe1p8lCLiuDBPzFXnRSrU1H4udgJD3F7Jlqc+6C +nb2SCHFwz3i8N/4tP/TMkrQoDZgNy3kQm7SWSDSPKXDItn5XieP1HJKMrvG/DKT5 +QV5JMnUmwZrsFgo7iNFEhVnH1WkWgGdbvRA7hoN+O8ruFl5R/V2k1/17hZ3t+FoG +d3jncigYbvrFwRLe43xfbzVg5PV/LUjxOsrCbix1XC1TbDyrTt7+CfcZSQvlCQkr +imEGDDGlTvGStmUfkLaAWBp+PyvnaqCQ++KB8H3CW7Kyga5bJ1wXaDU4FdLjYs2g +yF62uKkqIbUk4NFPU+ggWdvmOuRloXm1gQ5jiQIcBBMBCgAGBQJVVtEYAAoJEH/Z +/MsAC+7u2JcQAIbVKrOXPxCNIxwSFjPY1n/CzGkFbTi4sTVsT+uwNRthmUlG6Q08 +9/hcGgl4bIUM3zTpP1IEWi/7lPwJKUPOeYcy7gNImVcjxqQQRiSbWEey9ojsEu15 +ljuc9za/+gVpiD9e1vvOGX83UfN4o+L6MiJ7fJ632wL/tyYABTznnHtQSNOklsLO +LpKg68cTUMDl/SlrXngOrNHVS6/bo+y34cTyEdKFkDT0KY4dBOUl3DVKDAzXdkq1 +4x2QK64g2hTX7Lf1654KMQgjvYMus71QF6xwdn2sm36jcfUAiwdYRUdN+BJ/hfkD +kxdMdQFL93Rm7z7d1XHMaIynFWYbN5FTTj7XmgyIn9ymZ1nMDQfrHpOxyMuk/SQg +bN1+zAFRZQhTNFTc7swDg6wj1/4iI+wlgsevhzFDS5Fg7K+aW1towBwPVg7BakAY +MmFGTmvYZ2bJd7CeTs9JPSgKTuQAhzd1K3xMawg6GTtLlHmYXxWPvvB/uQOieiWG +LpohziNBbuvtzOJ4fc53B7Gsgr9pCNBOm8/LRtbNQP2opGA9dNkD9bI4EvlCHtFB +2Cj7mIluN20HiJeeYAZIywL9LhIwzFdAHxPEdp5GDg4Py/CIYUkxMRJZssUK2Kt5 +eBDvxj39ac1u1XZbVmH8pS86qafKTldF4TsuddI17un9H5VOm7iwwhLsiQIcBBMB +AgAGBQJVVn0uAAoJEFjhG7HkFNmt3s4P/3D1Ad43N6T6pLhxsCgXjEMPzlEbNpiL +zpNi/ub5BbCDti64nZVaa7wruGeBkmHcpZFTlDu8Zmp39Hx8BwKyWxlGcWuM4OcL +LeyZJ0Xdil5DYkqaB/QY1BQSa1UJQv0n3itHp6vj/KhxY+E5ykUSVQKTyIk/IMV0 +kL9PcJNrfq7PWgjnB/QMXra8EwOM3nJ758pw9dgoF6JRkf68dwYWjLL8fc4rVN6/ +JO4sAwxrqW4kn6r7186/M4xEOkQvIp9S21F0vLAjqk2zitK6Mx/2/7E0yOA54foY +qy4xfv8Da2BwIHShmpBeHbM5pNIXpAwqrCw7cAhs5jXpVZIPmnMGe3rZ6HK/w8qe +zwzA9Z6Ahu9hf5X4/bGewIEWLV/tprzIrBBrc2H+7OT0gSXKr+cuC5yIxDnClMll +o1p+ABy4csxmDlih+o+LqDf4eEy8hm6Bb97I/iG/o7EBvbLfzzxhs4pbd757PLCc +BqVdJ+Mm+CqsQLlixgMkziswvnpZ7ecUk0eMQrwJLNdrCIlnB6kZWq7Kiyn5976j +aUCydSrKRxgcqhbDkoY8H1pO68LWnyTdC+GbwOTJJeNEQOeY8MZG5cVlJrPTrLkB +5YG4zyvl7rb9b1NH3IpsmlDBGmr2gSzhvMk7XLKzm71IrnMAoJ2BMyrNdzrkQ17Q +kvxu0UDeHA3niQIcBBMBAgAGBQJVVY7fAAoJENRPy87OSW6u+1EQAJi0CL14THhT +ZtOBfr+otxIZqDkPiaVwtax+WYjyLt1VOgeDHPsEz5zaJsOdkLWDI+JxuNUef7Xx +SjF5ALVH4ykpWe2E9r5bMRXc1oBFqxDmwVK8d5uh2in2Y/UdIzHg5LKOhJmLoCEO +hHAIBKgZJkwgznAnsW6/lAKPyuyH5OsiTMtIom2q88aZU7o4bpnZyzo3iTsWj9b0 +oMsn2nlNAqOy7I1Qku6ymCCoAAeY+lyhMMIt4I2mQ6pAcJQG5LFVBhKuW2LQb+O/ +KHvaT4/tQL/y3B5DiSYQ2GC8VCMjcadpVV0w6oIodN5Mo5d/drpG4bUX5TCHfA/1 +aZVi3KL1sgAISqswvc7qksVyHlybA4SHHZFiG1VukDDCvqcwHp1szTMAZBIN0sXq +fR1BqS2YqlzWBxXmSYesJeJYJ8vk7RJO5JikUsuj5MPKu6jVFgEBUvqCcDB4wYBV +iKjyBXS8vwoewcqaow62by+WXk/R5gynVsnME395yILEsvwW5BBZcJLSrI7Iqa+1 +iD0ZVKpknhwbsKgNcMnzqzDXMflWTUBrzhvjx84WDPfHJXPe4MMMCIDNU3IrDt/n +BN0JE6yOKfnYqi/njHwjsF8IgiHKKwssMqfKFuUBk5f4QSH0MEQHJU7lNIrqxwjl +JaaU7iUNFpRDLTIVO8w9JaxVMhH8JXrxiQIcBBMBAgAGBQJVVUVbAAoJENqUEEiD +hCgm5XEP/izyBXdZFikQkw3ewO2rpu3oZuDIx4OC5V4rgGEaGWlqwSzGq65M5pXk +0LUSU6gb4BAQOc8j9BrzHbN5QzMKxmlVWjxTfUvpq/rHtmNOFA5xn3MolbRdVrQz +/dGlMAXJQE7DvP8YDVCeyVxZsU+pQan6QoYDoUG0snqpwHFicyEePCzpoQOFEx62 +3nCn+wJwMPrrPM+T9sFbhYYyCsxVkAkzYiLhfKQw6s3tm2QYDTcdoU4ZJ63/gmSz +QuiRBm2hF8/cH0dpQT1zEE4+nIcffGKcjCeb8JTmVAzf0vMRKWS+Ntotklh9HdVx +gSBcU6NKOxH80JHABMwI0OakXrT+MbjPSoy6SKslrRfiXAOCK+/6qYCleqtdj7Kb +auCw5wWC2qRyDU9NrX27G45Xc/GXlEYHNIg/SDKrcbPFzr38TQRulpS9svtsLb4m +FamXwZ+940AMMXyY7qQk/+1yXpOossYsA/WbutkieftFhJQJFMxYUCD6IeYQZ9zx +v7tcvjck9+K2Ap28h/nWLHvB/EBHgNKbkNZgggT4+xb/3/YGcXTBjS19VAd6la8Y +TqRRHuHI92/SMDOmkQDGZ0e+u0Tak64sT/b/Sw67yNbY4BpF0rkJPaHQTL/rgXPp +qEVTHA1qGVn+KFSFfcPJ9ym1UMrJvkfymP40Ina3qhD15rYrhdUjiQEcBBMBAgAG +BQJVVAc4AAoJEJlFM38oiD7LCHoH/0QsEiyxY9Ac9Yjijdbkjm8SiYv6eHtlFUf3 +vi5NLqJgxj1H0PALzP8fswBBPTQmM8bjrvPlEJ4Tg2DiILSXDXHWgU/gDo7fgy2V +taL79TrImXQ7jNUFEp9Np8haYyY5KQjVJITCES7+idi3q+0xtEwe0N6plEnRUgd5 +yOv3dUYGwQSPk0uewhR0UxCHOTYvngoSGDJO4ddHVffnmpj3jsvKvpbUi5ryWjKM +hI7IcuJqTwVE+tL3YB2fhEGB5Z2Wor2xzB49kPlR/OnG3QpSRUQ0WfvdEhL8kH2l +hETwCh4N6+1vZY7ufC12iuqxl48C8mXkeot6HhWqLIzUIznlxdaJAhwEEwEKAAYF +AlVTwkkACgkQT/CPqhhgANTRWw/8ClnjO7ltJu8BbkLR1FWEpfuKm0PWOCoRkgcr +8L4ndxFEdWapvrEg0VNUMSnBE8E1kai/cAWnwXhYCgi0atDYo6a0ZwYLxlC9iu2t +3zI2pXiCuW3jZLoFgFP9whQOkuT4VvdcVGrzlrcPNKdXNhNiZIIHrmTfxcx0pwPs +uArOZvrfQJ3SpewKHugp3JwetUkiX8le3hG509HmiDmoWu3xEYIwPd39Mm8Qfvyk +y+1vY8lKP6tvAmIJ5K0IOGKqHGOs+GbNZUMayoISxP9/tmBrme4c63UAbS+WGoOC +RvYs9eXzPEl8aWxORXRpxN7CuU+P6VrNP5Ks2w2vbz7hjr9C2GGECKSuByaeOEnA +nO2Ttj2wRwhH0eciN8tFSsMIkpsPnjMGZs8mGjg0G8QHYE4gjAP3r72RrmteXpzm +2JiAWkaX7WwSFZIrchpgL3HyM5FA8FKZ5vxe2P5D2PcUIsoTcFWyxf1d3Rtx3a5L +9Dxx45bqH7oUdCKFasvWuVBi6wC9zi6f2y1sqdNOqL+aMKELDPokGC/tPXVrmEJn +qcaVlx2HF0WCFS3Zgo4s0odESr5iyP66UonqIsJ38Vs6zHKpP9iuWCNpCo645t9B +kz9Lp8SiViR7Vy8tA3bNFHYEiigp++gBRYRLDygoBjuoGd80wBUDaE7Fc+gZiXRA +LsWNmrCJAhwEEwECAAYFAlVTotEACgkQgkM+NYeyrn2c0w/8DGbKWk1KhQ158XQp ++A0Tl1hva0pE98sNrnc/K6ZSChA9JBRvYW1RoSb6HdVxxXLZxFyoUg8i7ceS8TU9 +fxi7XN6nLCD0qLAAebCz/Ft/fo2eZVwzthp5UyLTqnf77wxgNG2PhihCO/d0/nTP +Z6F90dk8bYfN0H1+y6d1ltdUKx196mqXpkMrUofc+AQfT84StgM9L7SjBHtN+H9F +y2zZ1PuGZW9r/HevZIpkN5wpqnjyBvsZffszZY0tROPLA6t2NqaJE6T7f44WICNU +igXghExGag7aG2aEt3oWjlXVif5X5krza5Q0P+32O+bISy2NGGyMNAqIi/5o6T4Y +C9FgTOKXODSDzm7M1v6QCKbTCsU0gdB6quQvtKZfAwlAguNq3zX1GLl3zu/FPy5p +wqPOTVvBTrFJeaVzbPry9tdkGjygFW2MeR+DmbgWULAJsCCHQKIQH6TtwM/7e+SY +ey80Rf0Wc4gmTE72xtgaC/msGkZSYnE5+TjO8R3/p3RzJ1PCrU/fT1VU0Pwzlyqo +O4Gui+FYwR81tGIiFrZGvoTT1Th7NtDGtPjUvfHchZujreIrl1a8siiRAc439WaO +UWVS82l9rGwC7jyrNcQAbKHTFVOzDJFTqQLYWI25UReV8qYoOFshv+vEgOa4bh/i +5xczG6tj23Nsz9XMuOCUPmPuizGJAhwEEAEKAAYFAlfDYMwACgkQcpayT/HOoi76 +mRAAhuxCj/CeC0a/Y5BnvOFtnB7AvTXA++8uhNDjxOYT8nbj5Y2K8ClRlqi9X0zC +f2hYHsRUliGpCEy5wzrTjKZj5FU0P/fWrFAhHhnhbMOU+3ZCDvlvvKkXxZ/0wbHb +WKLTmSkVuispjqPHRdi7lwBO6n6yqt1/q5bTKYF9hT+6WHL05h9SyUMx+vhmgq2+ +/IlDWq7dVFo0Y5v9at24Gk8zUGY2KL85pNn/RCQUXl3DhMxp+//Bp4qaSI9x9lJ+ +K524JHlq5435CQ/8d7XmYyS3E9+A5K/TaRy/DRS6bt3+Um4GMmUS7MV89hbKummL +wUf5dHmukWgKnXjIfxxA3SCRrYH85V99wGqXMPnRox64etnbUFUGG4uPCU5KoXg+ +o4xTYQ6CxZCu2PFz0CKRNzHjK4/Xg1dd46mzsUp+WYDD59SNMmTbFmDgyul+ZpbB +6agHymdi8bMaKcapEI11HxPrEOBfWzK179TzUIhHzxx4cwN3QSLcyDXYKYIhOD2f +Xwp86BZqzdL37t78fhHh8KAazLCJL6x+LU8E08qxGWOmqGmaH8yXQwFVBgvZwKb8 +JXJK7+cxutxBHmD2LXJvwJYt1RpL3tOzqYMIM3sigEosAn9kjDPvSCnLczssKo6V +uRwUvjfs38SgWERWkho+QVRKfl+Z+wfHjxtw9VGpNDxEP/iJAj0EEwEKACcFAlVR +J0kCGwMFCRLP94AFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQsmmV4xAlBWgD +Wg/9HhWo4WKMZ7axMGJpv6BYxfIkTD+AM/50W9PW569OshBLSqCXK4EL6uFKW4hC +3R9R7ecnTFgdT914Aa8EG4+7pB/5T8p9hGS8lOFh2WI9CRXiW9CyacJvI2t1KEaw +rZITVY0enZ0YFdIhhqY6Fa7LhtNMG3blqoy4Ct2JdmF1DACRzIfoFIxjEM9Xb/Lg +D4vKn6tAuQqUXlxS7lBsMUVhUDxXu9mfLEy2wH8tXSVXcP5RRTLZmOTV9s35izX+ +fcmKHCa+wVX04D+kyFQoacfiXbPvxkvmVmCPfiB3rhaCfvhE0Oea/I9Vo2IrUzQ+ +N9mCPSTXhCVNtQ6BkdKShp5v2+A7CIr5HX0qS3nKibNBc8SlEPpVxrPhmtLoKI9q +MEHT94jgpGDj6enNExWWi89h/WERsy5ELIbE4DJzbK3tmTIPVQ/8P2Y6D+H5hIfj +CkXAF+/EloYLEzVRhHGHgJOa8tmv2ILxBffcqiBmJomUQXzlmCqsmP4vXDdCoSTw +2ot/qJs4sSHif3DXLMKm3s28FjMp84AJpRZuXmiteeoB+B39SfTVOrquvjoRLXO4 +y/TqfhaOPjJx5JxZHcRIaAY0XqINRJrTMqYlOinjNbR/z0p3097frKnFx9QPl9XE +HUPlNUL3PiAyQ3vUZDtyNDppvuLqEXMtHob2I4aeCR8Zsfy0McWBdWthc3ogTGFu +Z2EgKFdvcmsgZS1tYWlsIGFjY291bnQpIDxhbWJ2QGZiLmNvbT6JAj0EEwEKACcF +AlVRJ/gCGwMFCRLP94AFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQsmmV4xAl +BWibchAAj5YtzBclKACs0owhglt7eVds7EKmMfMS9T1gT0B/gb7h6or4tfgYrLdQ +SClJnI4g1OR+Nt0UuTSvRLTqwBhSYW0IN9ZkGvumP/W++T27w8l/zij4H+1eRRvP +bVDwVGYN+VWzUutOKOBqnzEvBOpGE1a+g1HY0QwIa4/9fTjtJo8rBrTFsFMT3P9n +Nwh3tzIltiWAVcDYv8do/Zf5wAytfDg1F2uV6hJr5BClmC/K39ny05cmYFeFz7uX +86wqDiRdZ81H/2jkbQr0vwk1+ttELVGLrqc2JquvKmbbe4eFQz7pLk4d/A/PASLg +JQQXJ+zxDqUddGbwd+6KEt+Oj3rAeHplvfO6ljSc0CvDYs3Sti9/llnp9KyxyJ1E +jOBPmy0PyGfHMveZhy1Cr/q2EPP7eRkNV/5aUxVrkkUzRlcivJpg/B2Tn6uCAI8o +H/yv/m89ryZxgsEgeu4uGSNAunZWPhoCGbX8k9h0ksqYQutlezw6e8Y95xJI43dS +yVdq85TnYdXRoSbejS0Ra60z1CaAZEAPZl5iE+EUjM63BWtWptvcybGqt8vk0daa +6Ps3YpXCd3p6MN8Ko0pwM5wSigcPc8nS4D4gpYMZXvlL7w6lnso6ch78TfjsJzX1 +qi76dOKrOblsXKG8l4T7HPRvvBuFCUTv5KsMGrhsuk3T1xtA1e+JARwEEwEKAAYF +AlVSjkwACgkQ8iHF0sRizfgJrQgAsWYKy5Nl/e5xbO5n7my5VHgU0voEP1nIRdNL +CQHa6XJIUhTWApKfrY5u58R2MuYNnx3PHSfq7hfv3OvC33ieZ35JYK0Yg3I4vYz7 +93wonwiECX2Rqqk2C2bovf1EfHCON3vuJ6zOFG543L+UGciUHSl1L3G5DSOLGMUs +XUy3zUYw0wqRftepYSZHPxTCnBP0/IKhSQ09rTTS9MxBazxDc/Pc5+Dd/Q/ie4Qm ++RLpWUPZMPBkpMoH1DpyB6vFW8hpGYOGxhJjF98XnU+yrMSNHiCI1FYrvKETuqe1 +hMTztlXomcWcurpsNHOIDzmk0d7p93gR2oKtdhtSYGG+vcCBAYkCHAQTAQIABgUC +VVJzmwAKCRCZtd4LMJZlaV2EEACb1qCsnf6qtxFmhdgsCYzBRKTfLQ6D+wUpZgZz +t+DOqa9cHU7DVHAPVNGfNDglG8ZDCsnrcy91XOmYbXTwT81jldmHBjj94ODlGjv8 +tNHBwyrnYtGo4iEHyxzoUzcIgakg9EwXseb362IGuv00GbbIqHMrYxCsEstwOoNG +StCA2ACE1BTHSx6J4Lforfbw1HkWZAXRFWzVFWW5SzbEktPzGZ8b7ZbCfWpKRWgc +Z2hgoctVeBcPfxD71U938WD1DKNBSbDqIvDZ6VGo3mSw/gleiCNJALKK9AIo5Hbr +57CBVdjZLQWfDadhe9m6g3VEgk6P05GL+ncivZSPo40XfeAMkxD92DHKoWWFN9ax +/OlKuRz0DqX87yLXa4i9kGwlpNFBIj5OYowCyT7y1rMFGF5nVX+KgRag/XifHwf3 +pEEr4SF7EknvbzP9X3LwUcNUyVYjgmFu+2fJQtnLko3XUNvK489EXbyrd4H1Xoka +LOTGeYwxE8aaBkUQA/an/qdCTk7CWDfsY9OBU22N7zJfePKUohUxfDGw4sPCMhU8 +Dr+4uon9krT4kuHHErdAUbWEJ2sv2yifp/EkZSjrgHIQlrZTPFNMdZRPBp6Ck1r/ +AaM26isOTkjRExpCh/ut0AqOtKF6Rg8N3vTkZxEhTCgzEQgq0fpuV8XY6t+mcU0X +//snf4kCHAQTAQIABgUCVVJ6bQAKCRDg+ogVk1gtkcVwD/92YJph6NZ8WjPHpjd9 +DaGVq8Q/jjNHh2r+F3vfQ+Y8sQWHYMEMvdiT1xGERs0ndqQot28rQ35pilIksGBV +XG2OGapwtZn2jDfDLcup+i9DSAMviMeHGcVhbyRpZ+oy5PCZYJvgVyr2WnJT5jiU +68Hlq4KtsNFHk/LPjV/PrfAWR5w+6JYsgV8wjkBADelMwQakkDRRFY7PuX0Sd65p +alYS3tHMKMZxjJTDVBG8W00XUCtmaVeT+7VjZfSOcnUhIVucLL+CyvhDhhx0ZolI +58WEqbD9ibMzXG/hiQOhj7dughDO7Evj5dHbzN4p6Y57HD+iYTkMThem3M1R19ck +/fPwq+gJLKoMnM+SchLy3GvdxilS7dgtZTbiV8mlDC6WM6+40QDxKdHWODBht8jv +wP5b3T1m60SVqU9IASQA/HY68WHnpY2hNI1JWGVGnbuF0VW2YG4kjYC52UFLsXvO +scI8Ah9bfL+orQ18lq6DC+2pzn5doj3RcsCOvO8RCmio2yMz4vhQnLbUM7hVbg0e +2OKI7+V+Di9EVPl5S23b6jXw0z1kX6hnGEO48TCwPybR48UDYeqv7w6rxeei8Wo/ +2Ij3bWW+8w0Ksm2V9FIxJss4hbJ+IA6TMkHBt77tDC46sCuPyzKEKMHMIYpCw356 +Xsc8epBcEpvNrCU62iP9gVEtgIkCHAQTAQgABgUCVVJ7xQAKCRDetUdYIbCzY7GE +D/9fN42dDdc/52L2WDYXo3PeSKzTxF7zLCOyPBS2b4QnjpNMTo5suJzonlBXOQgi +M/5IRZSmiGnaaee/nAHBdYzk7le66zJa7nd6mbXRf6mGnGK86pxXvy/6U4Tcxr0g +drCUTwOdChHPI1WzNA7gp+zUWax3xwfVtgV5jLeC03vKLunnl6Z0k+V1DP0p+O8Y +jn6++MRagGNxH+ZNTv+lbnvbECGC5g1IUlIjFZFPDv/WPzp4Xml4ZgKqw1ZAit69 +CQhGFCwcXo631QzGz7J7EvWz0YCsA8T0q8AIfO5d7LA4EGviv9scm7pP/9DC61vZ +6iOgO8zJWfs+1e/3HNuFxrWWFJCZ2av8bLHEtU6ud8fJ8RPya1Dcfs6EWoAIR9fd +Ns8/rkS2UEejmzRMtWpSHACTlg+YqHX7XfpnN9a0YSXaiFP9aZXHIEffk2ThFJZz +OjAiO6wWmzjj0KwxllV/XezbVlEkr9BKnP0E54TJ0PcecZECes9U4rrXdV0XuztR +n5ui2Fxvt31+6Af6G7LVQm7gGLJIqYAW3JtfmGlClJKe3neKAC0H1OLNxn3UsL22 +sGwjjnWwppdXG7DV7U6Kh0T91t07wJNIJYDeudyyta725zFhAwQF6MqHxB6kyliZ +FGfWuMA9yrUZHaQn4QvnmSCZLL9dYtZmVNPpzW1VHPW2E4kCHAQTAQgABgUCVVJ9 +hQAKCRD/VOEuHKYZspkyEADZ1tu+4ZiM8qLEqdUKcCOGZ4w4QbLFyxPCWl3Ihu2F +dCOCnICfamIM6Fxv3qYjfO0DdPBu4rPOijeCgptIBSALf5FCvtg61n00kp44UFVK +PrTrH1We2G/Abweq8SKDVrF7zT2OKOZlhVTVljZIByUCuLq0ZiTP1r3fLCVPs0Qc +172qN8E4roAk6XnGZ0uR99BJxhn3rXuUG7AWvX6IWuO8Dq76GpZOUlHZYoSBlhah +fw3L1IyUBPq9EobUJOFa6omGkTw9OqWIum8XM7T6X4YlbUmKrlC7ubgHm8SORb1+ ++dAqBkrTSy2br7kL7hLgj7ErhegVVhKsi8V4kmADwi8ArcD9KbEbPk9XacD9dpvc +X2PFeA+W2nt2ngw3DvHPUQyxJCoEWZ6oXUdaOFaWeSCmXDayDhR6apQxO0Eh3swH +z/bzspVJ3cKmQ07vEUP4yJpgCuLHv4ibF2B1NiXPjcATLGERx8miRl+32DXVFiAq +Nsj3vBojP+KZBqkKK7vNmwCW0TwQVR0OSZ09GSO36jUY8lRcdscsrKQRAuLeOodC +qtbhwkA+vv2s2f0UYsiX4C+/IjyaU53f+dDp1L+2g6V+41KqRqv3X0l05aFktn2S +TtP9DsKt6KU1p6ZtgUhucqJ3OLCsFTOjhBojkQDwj8ZMyYXFIuUeOtykfKtUlbqL +ZIkCHAQTAQgABgUCVVKEKgAKCRCRPzdd5iqXDM91D/9y6Mh2vqTBPyN8SJTNL/lg +O3fNfEAAYnLQWT+IrPob87RtZlHBgp22F0ReBt7YHiG5CRi+uEWdqR3C7vashEDk +OyKH82B0kRtTrBcgbKaIiIMkYRLE6AQd8ddg+UWpid8U5a/NjYAi6YvpEQzXxyFE +khSIQ7CMVTRp08lF1+jb2+H8DceHn/uYEArms1KealKDEDxHAIRcwIMjzzaUlhQ9 +C5cVMcdJAtCobl1RBNUoxP/SJZTZFD6VA/nANNab/j08oIoOhhzfR09iI7UVwMjX +vuJP/BjDdLri8J7F0zml/Zt7XIb+V/HL4/n/rBYd74YUP3q2IRibXYwv0ubzQCNf +6WXu+GhE+IlRO3Y67tCm6prgGm0a255q4a7Cd875d1hhPghV75gHXDKEvca406Dv +l48/6gfSs8mBrW6z+8jfmAol23JW0KjgM8uLV+08MQUMHry8xpHhiipruHb4LM2Y +fIVF+otQUhmsaaPvBikIuIjz1XbJ6wx0MPbE5fQxH7cDAbx+lirB3qjph/iZdryF +sfWj9QIgAtTuyCAnMcHeG4FQADs5qvfYdySV6gu+Ozg7Gv1zudm41DcceFBb1WIE +CmriwTHUPwXzKVCFcJuX0MUhcO8Q5sLGqJU86lDcCk92f1FOlGSEuFCz0YCQ1VsU +XSeJyUQxfh5l8fJrN0sTfYkCHAQTAQoABgUCVVJ5bwAKCRCotR9egDLM5CyRD/4x +8o5cxe8yTtSvup+FjYaAIkmWk68yhISlIQYixMAkfqge9hhMHVRTHhaCz5CPkMLP +PYPAeZzkcCu7JIhOHF/TD44UqfAKo8CMk8G4ursfjE0Mm71G/odgbI50WeFq6vrJ ++SCObDtzYLZ1bkhPT3KIczDeMKfz/ucwKU3qLfxXAlns0/g87ovj5IWA2XQwJkQo +o0pqDX9e2g2h1kyKowvHkpLqDSEWQjFqDmhJkXU7F0b6XjwnzhqqxFwGgdFskDG+ +3/9skWam0aQT8vDhjVZQM0i5V8YXuo3KxDdeis6TpvJSKUK4EcYF99R+zw6E8ese +zigMXlTujpA8UEtrumDKZxokuwZpxmCtetQVyFNlXMz64SLADLssYUcsGSw/7gYy +Yd2vKmpzZl6JXiUmdJHI6RrN7rDcwn5SRAjeneyH6FSMlnWhPblGMDmmHRhTvDKM +kFfoks1UjbpLq7ndogvs9RTpmx4eE7CWj0KmeYgAtmy0V50uvd4TzGSjICSsYNGo +f0Qedk0GjpslbRhJ4JBDWsgmVBVeMbx05oUpmG78EuzkqaaI/rbttr+xM4V+efA4 +MjHF6N86R2zEhXEkN+gWuQ/rm9YuKBdf1g5kqZaqvkn7Ec2S9dflB65j1lf4+ycE +IKLKbXOjkNQFerlA8Dr4ecIZI5ItnnNl/v2hur52UokCHAQTAQoABgUCVVKEaAAK +CRCt3ULg6XStjwo+D/9m5KXf9BqQ6oLc3wxv66bsM+LKZ2isBPMs6QIiadhTJXuH +c4sqaswG06pNWWoPR2/9QaZwENevxtp/vav39J3dTqczyGaD7rbqHAMrq7IQgHXW +KelerveqR+N+MyPKsE2EvYT5VB3QKlI17JkX904Zw18JvXpgMQ4iqAAUfHzn+2d9 +uqtJCeZO6Bk55W3DSddVcUQ6/yLIq24N6tozWfsdDYqzSS95Zk/98bD+IztaOAaA +t6f3xJAPimF0lDOnIeMb8XUBt7L7LVLb0oX2JfbDwgIidfm3XviUtVTT/vOg8rY1 +OZdyjuJF4w4ubLQuY+GpeGHLaK91N35psCvyj+F9c3DRGpUhMx+wkDW4c5wlKwj3 +63sLsvKzXrLt/oqE/Vn0HjSNjDUgI+LHmr4MgxgjPFiE1Ruls4/CPxfUdayLX/Gc +yVjBZ/aJHM+I9OLKb69EdZCxYwKWRYYCW7O9tzgBZ3jz59jq9Yi3BnhDaMp/WAII +NTO5NG1CUkF0qnKSOobl9NL83VLM8RTE0lIAsVmoyFBed2Sz33FLorjP1thwasV/ +PXRGxXbSMp2sq9A5lfhOmwmaXAdJy1Fx+Ml2aJhqneIDXKxXo8w8Yz5MqJ0WKPTI +7FzSpYTHany3U7essIS659Q0w3rIDqGxkzZHTojnIzrKmx5OYC3+01jb3753kIkC +IgQTAQoADAUCVVJ0fwWDB4YfgAAKCRD8n7XhIU7pKx+FD/0e2v1cN4umdoXAMa7V +M5GGaV0Za7039q40gavnfhzze8Dat87wC7zQ+u4+sAFWDFxBJAtfZfmS2qSKkeV7 +n/KtH8Esd1HKALGvdKW1g8qmpscfwD+ByhYaGphGPKDTGZA9cR/AUatla+9ifFNQ +c/Ul5fRyCrzXctXbtaG0vtDkXXIKQdePCIRHnn0pxiCIEYSCRVbwQ7KKtJXN00nQ +bx76j/jMMIevMEJiC7ruu15CkZCXrbZ+1uR6HKAsXOGnUtVmwmU6D6a1vfERxFAA +pO0YVcXpdZnfxLnnDZofSTOBU9XaaQHq5P2nejwzdpxvyiDXeGyfH14o+V/YbPSb +Ehk52BQCUWuCabQ4wG+GpLOQX5ly6W3p3k/CkLfZpQ14nwyjmG8dj7Jpag6BeMCP +4CUc8Sdf+ci9wTkJG3FHvI7P2iDSRisskl0QHuKqoNx6oqgljqVPQ5CbBGOQQiPH +CK8UjI6qpGeSySJLRzXHs7kinlqcqkICp+e4r0AB7C2pwDnZw4lsnHQDkNgOuG+B +M5zAmw4xh27LGnGCO9EfSWKzPD5cezh5/kFExAyc7XeU1NfLvCtqLhDhiyUTJp9K +H/rLRORyMOa9nnKiK/l1aldDPOMhHcJywQP37FmWwPb5zFsK+kJWZQggzHI0unMf +wvzNLQwlJdqyoaZIGk2f3fyOy4kCHAQTAQoABgUCVVKvPQAKCRDgldvmp8WiZuYG +D/9c6zvKMx2m8qQ/MAfo7Ci2FJFhGjfnYo0zbC73XRlrtixezRuK4fM7Ihxvxboc +Do35vucwEOlMm5eY8YvMFMnOF4Wo2xQOmXOn6f8Z9Jg/k50CzWqgaDFsDv788mAZ +jPw8EPG7LLNI+pOY21DF+gqAq8geweV9YgJUa/uRFq9zQ4LbdPKrbnyC/XWFQRRt +HJPCEdI700cRBXRl2ssIAWLVsf5pX5+NieRUV4zYRd72FUIOxRP4h7OrPDnZTY7u +JJZQvc7eSbYt9zD/cqCE15Ep8przK9qmTjCM9E8W5oSlu0R+v4bHIyzL8+CIS8rJ +4iuO2vVKw/Os3ffENUqo7LfJvIwImV5zxAkJCm7CJSKoYQkcHaF6wOc2ekA+F5i5 +049y+6xGLhJVJcukg2RJ4TUtU/iV/19di1gcY3kcT0jEEcqDNhXcpG9EZgqtu/IS +pCcqjCmUF28oXYw03j5xdq7o1fcMsLbFQ9MB3PWw9qqhlo8zzMo/R1z4c/nyqQtX +V3zPWkQ2QhmuIFr6+DY41/LI1faPBWPpg4ajdXckvL9VmgbF2Zq+rtx2bo+hBo8l +lZq31hNszCnY6JwCWi8uXkIavLoqP+vTNJ1xkr94QKjebdFA/6YKGIJtwD8H/YdV +ElUbGLhq/iCVoPT4gdQOgye/9xnopNDAT8pEPoc+SyDYaIkCHAQTAQoABgUCVVN7 +WAAKCRB1pVGnIpXsH3aYEACh8zhxfI3NjUJO66rRL48W4sWuKM22pl2766jM46k5 +t4IP4fG+Z6YqnRSYo9SFu1dZzyMkt2XmB3fRHaFcAEd/RoUNkxE/BgGovn427Jwx +L2yE8Di6EmZDq6YBrPq26uaZbz2MtkvwmvGST6QYtICS9cL6NLpc7ZaeWW4crxpP +K0C9SvaCZMagoHpfNjFkYzTNT83+xKw9DVA5AUUKHM9tZ9Sev0L06tMLO3fTZe00 +FpEOtRcPBA5R5GPsKwCdqxOopEejaXdrKSxMxa6MYZMrXo5fEBMHvWfqJC9Sjgtx +6BCljTGhpWIrCN3fja/Y02EWK+pDa1mDU6mVH5urKKjLkmhHlhLktEVRQiyt9sDh +X/5hUIiN2WnrYwKT8XTmoOgm4Crxd7/tnc1YbDjnOfM/u8HG/foSWIsgMWUWjQOs +L/64f1IN+W4/NKCvEjalMR2zfgHSv9QOmQw+lViFK1imR+S50q0uO+moMtZogq6m +xhtcXK0visO9gcmbJBfdAfOJYHqDzbc1u+brf/hxVb5YJrMg6wvjd9bzDxkHH+eG +fZrbyQt67kpOrR7VMfRxxmrMmrTH6j9TY7BA6tjfKL2CKJwgiaqWO+6me6e12Atl +F5s3POWaHLnFDC5AIdH3c010/u7RwwYVekzyx5ahUk4WyHlep6+LYLZm1VdGDo4t +LokBHAQTAQoABgUCVVOLqQAKCRC9AM0evEl8/XMXB/918p5UgIV5uoi2dZxOMp8E +gTufXnAH1Scndz9EjXnJeVe4P67cNdXvVswzkJRqQJ+5duT+J5IXLJ2chQW+XrhY +BSd60ae2cEjttdEgHegLKTUmG1UVgcBm22RGHzRqCuHMDCYP4vpVqvSfQaXIJ1u2 +QQY05uUixLWOhsTidXMl0UX5OkU//m5nUMQOwVKehlt6mjRigFKX+6Mx/U0Yih65 +L/agZBeowU6Ft0jUz9tAqrHNtPz5yAlEzVgKaSuwvXyp/SnfpN7to2UON010gRgz +evvnFOOyM8exfLEparXMsFJAlDv3YmWHuX0iMtHRR0u8KPPsI/VKZ0Sb3skeWzgK +iQEcBBMBAgAGBQJVVAc6AAoJEJlFM38oiD7LjLEH/3R3eApqp8BzxqwWsMhW3DGU +p9Ap5Wgt6VCaH/HwaQbtzoNAPOGHF/WaIfVUUslWZeGwbXMpPBjN6dtW0yCNW4ut +OCjPCkx+8HLm0bxW0rM9UHQj8UyN0X7ieJvB1sZt8sx62D33JbbzFZncpajhNeWN ++aOo2a8RROvlIFp4c9vcUzq4vBHOLj55b0bEq8kqKIuQqIWJJUrkM1S2OAiTRLOT +e5LcOEA7ZjWYMx7aULkbmQCE9MxFvoffPJobuVDTuCJ4+pz7kv/t3zK52WLXmyRl +l+tIvnLEdDZUOuNhDH2TemVmkUZk5BuL/aFV8xAo0Yb5p3gtrglSnZfEx9H427KJ +AhwEEwECAAYFAlVTotIACgkQgkM+NYeyrn3jSA//eWWTVf9UpD1AEO0REOAh/cN2 +wpotX1lGHF2o9xkYxz1H6DFhK8ZyCh0eyW4i+GlTTaV77yqQ2dR9U7gTApnz6EP2 +cs32B4i7fCgyJ6iZjPvfCGn8EXJxVXVs+9n8ElpQeksqd1RPDFZOyb4C1I37eo1n +8af4rMoEmoJMhxoD+rR8NUmQ1FPkX368n1mpvzdacNDU2HX3yR3mFZfMeXSPTyOK +MDX/6h4s1W/29UxLQX8zA23PQdpTFbyuyAQ+jE7D1vWfz1RduQ5CjHoETd0CVxs4 +KZo9W0Lwtpqb+/i4j0WPFnoipaG75SNVbTTR5Asj8Z2qwkR9Ms3KUtNPVBRMw0AJ +Urt0PwxNs9fpVxA83ENJ/EwwEnw0naXJv2cYfI/Wopxba491mzOyh8KGhibMv6PP +lsQQwZdxSCWXQhvbaGly+O1x38DWjfpNiApNc4pxbrrQ5Pvz5IOJBQ8ULzVmAk18 +/mISFcCqheUAzuw5pvX+7TNDxjq931MxGC5uJ0wdaCqYOq3cQ0Bpgl85QjIhmXZl +D5Z4J+N/SgSJ7Ck8GofEbTVUFVnFerfT+oATwgh/Um/8HDXH7dvO8yr+x4NRM7dn +Hiir0LRjbN5NDQXXKOHcopiXnwZVjLuRPR9jMS3LhNEgFnkVwMyQm7hiBdwQBAs9 +iNXevJnt8oc7IV4DBvaJAhwEEwECAAYFAlVVRV0ACgkQ2pQQSIOEKCaeWRAAmJls +D3AnOmb/7Gj1ybIhH15fOf8s0uT8t/if2A9btoaVRoq7/x5svo/N0q0zkmgzQlPj +c6sZ6qbt1RU+J+dyiKdGdJNi2Hn0gaqlndy1PQrHs8eDTGmEuhfGeSTvGN6Hpxuk +1I5j7minu+0xwD3/YvfSNkQZct+85L9i73wKe/Fw9DMrrMniUnh6l0+OMcquExf2 +/ydzwWSQZcsahRItxeaURzukclQQFjBGGQ9CuOPxCFQeFQG5BLwxzJ/csjIHUZC2 +3rkFLcbBtkQWvMX5aT7hw07SCpgp4QH1JBKeLM8tsalMtnyzX/ONdGDQkybIOzrR +RGTTQPh/yiU0CdKE0lAU5TRFm3v79Lb8SK4QxslMJGHrXUlJCahfDcmPZH8Mqdpa +s+XBJtCKPTPNXY5DV05Xp+J5Gc7HFCLlFx/YxklsIkMUTpkuuUM9yWf3IlY4NeAh +GOSwnw/uvwjidAeF0it/ocCb+l50h1CJ8lqsyhL2pqfZ+o0lMm7geaKAULfvswsX +1ojavbP8oz4r3tv2z21hxWiwAt2fn6wtebswjitBZOCulkadvEL2qEAu/WHI/6kh +LqzzAZmKD586n2lD+s/odShfe7j6o4BfJtpXUTVVl+civqHEK/RcX+MIA3bg/yTk +6M7EIEvF+tqAzRunQuwNufSCFFrIE0mPbDciSLOJAhwEEwECAAYFAlVVjuEACgkQ +1E/Lzs5Jbq6wPw/9GC7LDC3LtC300tTQaeWO3bPFAcgNq3PWZY7N+/dPbqSkML3m +f4MXBr7DpIZX4atTwpQ457LN5F9bUvS3rysWr1DrqtTqQMGqgyrSX0b93OXclxla +8H2lg4TK7qHQlk86A/BpQ8ivBA9DA+LgA9Y42rdcOFm0El8Gg2CqjbxR3ER/IKr1 +8BvRA4G8ZeOGAuJxWyUe13jGBlHhUipSQvnQ6Cbso0ggdHDEK+Y2G4ER7zAhudSk +Thdtwp43Kg3/YyjuW7UFJfNURMAujHa7V4kS4sZ+TDTV4J0JXUeO02cDTlYx8Mdn +znR2ZW/KAJQF+SSWstLkBd8g2G2O3AxGZUsS320W2/dx/pm2BJzokcefUAAYjtlK +bt892xyUG8YnvIJDkLsRhDZH5R8+9KwMSl7TVTGkVFZlJzAAVDYTbUSvZukfnG5L +AxqqjHSxb1hbVIpBlbZhuxFXMSAniJDa0soLSaFDaYxcOjnAekzYvFygULGEewY1 +Uvx51zyBRtNPawk26BYN8t5mcEMRxrol9vXdYNSq3FWzzrSj6GzzlwNdI40enyg5 +GT0cQK67GzTj6xnjEXoxC2cPd9SMkkLXbloOtuQMUPtZMQOPmMh6of+SUxgXQ61b +YxRMGFXjT7+V0RiBp/YRlFz9eS/eijxJZg+r4GQfy/jih6Gi8XlAaVYst5yJAhwE +EwECAAYFAlVWO3sACgkQouKibUU6i/25lBAAmuJ6rn085BYT/wlMP02F9fC9u2vB +kL7i1lTW0BHQVd/wAq09kBJ20X7l9jecmOoYsHdGenaJJRJY57YV9yNtgV4ZjtNM +uQPkz+/L0wITZWcB5k/mdHVA1uRgJ+1jhfqz7OGhSDPPdIuGNeEJlsm5nBb91Khx +NivSh0d6rB7WgaNFTwZRXUFumDpLqYsahSK7KMdypTNQQWCdz1+4LbzlXHRz69RT +iskKpVIQIA1pY7R5vpicmOTHmLizYH7KfZHQ8G8ltOkJMDUyaORgu5s/olbq1zpq +jUfaB6ssJ1qIROvy7xRWA+AG9BCH5Hf6wZ0dYnAf7tuS+IB4vb9vaKs4sZPsJcXy +/p15Q7IOpIYzvbx+SUiXWsSbad6uyJ7Z69lnXlsoQXm0CzkqisqN2GHtOYNsHHPr +kZDF8iWWUE9vYmhne3fMgcDqnTuTb5mCcYj5k45WoJc3iGpMlfN2j3qdjsyzlDcC +ZUHrFbdnsMYz7I8mmod58vDkDDf4k2y6HkFfXp9gLZUoirIBK0HMZ3jdYkbpw7Y0 ++hwBYAgHN+M7nBcR67yv2ji1CXsCG3Cs+NyOK3FVUsfMG9+WbFA3GwFUaC33jo4G +U22hRpo7o+cvlJrNxm54asbbzqBEbZJ4UC0FEKaYLDYfksptSxtcdAswTTzttLma +T6ifhQREOhohrcqJAhwEEwECAAYFAlVWfS4ACgkQWOEbseQU2a2t5g//ZtAZ1zW2 +YJDCyFssNxf/FznmkgGR9I0EL+qTzv2bbhIwReYLOafm+jW8RKa7+4RbnY46j8Lw +95G3O2SNw13whBuk+PG4QC5scJOAWPOC8GMGADi2oDsh0ZLKnFIYft0nh+E9+Syb +bWMGQqg0o55Qr1CfC2hWvzCqkF5GElQnngfl6BrSGFu8kA+g/8pU3EE10VbhYXTd +ew9KHq5pa613kEcnmfFmecGuZrvIA9Hh5ZxnfnlNk3oDBfF4Jqg/xQQGjrLF9BR7 +WJSS4Yf8NJ/43U9JeGa+3z1PgzUbLWcPMm4UqahnDcvqNI+5wJQtilBlj/QOnv5r +mnylGLly/jcxdDgoEmwzXGSBm5N+cHAmAetzuhzLj8usk4/IIDuYNZ4UIeQLW4Iw +7JeibPxwqwGDylWlivEVS8RSGQmfpk1ZU9WEgC5yPPiCkBC6+Aq3n15nTm9upWOk ++X5FscnyZM9+MoTKGDTYM/X1F2ZBW6xv7wwYU+BHOOuIlgKIBYim5RVZc1B/CeVM +GHFA6ShnMUNWQZgCCAB6iovLEGIwJGywa+Yi1ZK98YVDd2DX/jihjzp5rNR9mNS5 +Yif1PSyWh9siFqXucuFfDysr9mzP4FrY+KzJzMX7geD3tlVfdKAlkzdWUJlKsadh +rj3j2ZyqnaoHa1c5e/K9onOiauYu0kkfulOJAhwEEwEKAAYFAlVTwkoACgkQT/CP +qhhgANTeZw/8DMMHtA89yoSpekspjw5BbwtBtvNLsZysLsH3dWvacd9IMmdMddsJ +XRXCEaviIhNsLdzy7qjqBzRkN8j6xfDUVckJCeieaeUCxJ6vfqjK8dvJkOzqmjfs +NyvF9GY1WLvO2hLgNc1g0lcDXeKoIHNWAGtMgHwYG/rilICnp+pq6tVtPrMlfxuM +v87wqlFBAkjsPOnBa3D3CV1PUtUvgP/OH/i6Av6d9gU+KzddW4g9AhcVy+kCd1/L +PK0JLA8+rAcfyIyx3CaH17HNErQto4X3ZSrFhWQMkAAVey6fV7kvgZZN1XDb1IxC +BaAt2uy74D9GrFWcrup5OjD/wAwo4iRBU2k4Agadetec84ap4NdPzTOzWQPPDNgh +tb5ajUU/gVOHCfdcdJ4n+oLf402ZDMwzD0j0dIdvar4JyorCcUZvRc5WN99V7mts +3ZepIeH2LCc0Jxw0hO2WceRIA9cpwPe5Mzzd+jv8JFDiFs4bY88GVAosRVipPIY2 +HzbHar50T3HJyUBt9/TBuOk/FA2PtPrVatXt172v9NLkzNuvnewx4ZMbNXdIbLdg +xRTfX6eIhYihoO2D4B0CyeD8inHzg1Tavg/yoyWCztl2DIk8XQ8IU0VXupzyc178 +KyXmmU1xjYeJ2Tk2aEvVVkNsrN2GZSc+0iSAHXFuseVSEbPBHFGuDLSJAhwEEwEK +AAYFAlVW0RoACgkQf9n8ywAL7u5FuA//aeCmxTBFb+m+OrGSxTmhAyd9C4sBUkUi +zCKnd/wzUhC40dNPp6eubAB4MViDVnE7kNTDmWe2OpMvFQjakq5VTV5UMQxFnQMR +YLbb42vAEjeFugk9c3hd2wlbm/CZiRn3ojZzqrgL9rzq8KTnauI+rPxg0Ps5jWmJ +Qm+cOhVWf1xUDn9Dyi/KlMf/a+F+bHbT+8YE6/znFCSM5pAuTpbXtPAqTDgTuiVy +2TWNRrUq40PXWxfz7y9hGfOpEr/I+pXDQp7ia3wETR5keRI3Swh1h2D20tDZ7yso +RXPcvom6txAPbDpAOHDKnTpgcVuDJSH9TCsRPcExjIKBdMJNwa0oCPQnu7kkncpi +HNy68qM6ON6KK1BaRmGzFIQS3XqfMQ4eSS8FpF8KX0FH2thYpzJz74LwYidKCUJ9 +cpgorYeSo+BXp2D7mbHS4AIDlbxH5pV7XmL3T9ii6auk/kgXxaXu4AkODTIsY6gd +FKejR9W4q+YlUwUiQmJuKKqrA+SXPyq3KvZKaFO+oBH64lNNelG+1HHZSVyk2TQC +to7Bt/ih/Jw3uapDAEgVp2Laf1ePcZC2DOe9eMsNHIeHPYEPk6v4T31WCXIwroNI +BMm1x/k6PoBydiORHWfybheJ1U1HmUU/Y2fnUonPgYSVPb8bJ84JzG+ZLcERqSIA +TQPvJHHuN2KJAhwEEAEKAAYFAlfDYNEACgkQcpayT/HOoi64pA//W7r8vheC8242 +JABkhxVORU5SQdNKwLay/Uj25bN+rrqgSmzMUcOuIY0yM0RQerV0UQU3BmOd/HlQ +le4spuIJOJwmtYGG3lQOP3JVg1yLwqNv9vrpgEdnz3hOJipfQnooftGe6R4RI6+w +S49dyfGZRQxgmRRw6GVKzDedahZJueSnCjxaXrgnKfqIcGZBqmDMUXE3Cdc1dLOf +BZLp/v6Rx3/eS704ZE/wLWm36arBMbs+OYz8LNZZTy+du43s+UQH9jNC8FkEV71g +MaOhslC0d0XuCdgOffL2ACIkxHJoKtmfXWGJ98QLKcYHHLP6q4cDTXJ4vaSUR7cU +D5IGeSOcVcI7EGse+qpn0EbWW3vn43XeTh5pACYAB3Vmz4ijM4qqafdn1cMPNEiP +k7ltNsSk6l7QJpoGBlmZ4BSai0UAOxkPxwfpXJvK2VASzz8btpWxOiuhSwqcAKmn +olZATKvpKv+MsiFdAW4tcOBdHdkhbQ2NMpemb522aYpAt8Rczp5OACiQ0c47+muN +s1UV228/fECHO3S290AGEq4CmxzF6i6UaLt/KsDazFo65H4Bhrbjqi7LIkCL7rzV +YoFSsz+MGdMgiIPbaktg6XiwxZdDfGMPbA/QV4wzKmdTLFYW/MuB58eu9z1hOXYs +bEiXHsXvc1qIG81BUjoFVMmGqUcfVELR/wAAX7X/AABfsAEQAAEBAAAAAAAAAAAA +AAAA/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgIC +AgUEBAMEBgUGBgYFBgYHBwkIBwcJBwYGCAsICQoKCwsLBggMDAsKDAkKCwr/2wBD +AQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK +CgoKCgoKCgoKCgoKCgoKCgr/wgARCAEAAQADARIAAhEBAxEB/8QAHgAAAAYDAQEA +AAAAAAAAAAAAAwQFBgcIAQIJAAr/2gAIAQEAAAAA6t7KPAShd1LbCp5oYc2UMn9N +dhjhVrphdXbHKKdPr1S81+2WflBTbsWDDyreVj5gkcG9r4zhjoQrndfLmoX2yvIO +vGMfIvNVnbHaGVkUwEvglTwoBg+Cxiiy6DdN+dP0y9Awq27Mv5WLETfZDYZbNH1I +QIQYMBQ1KNsB5yAk1k5696elAdaNq2/PVN9kJZwtinTZ0wYzomhqngsCqj/a8QUp +6D9ogKx5pdw3tBak8mqJpdUTxccTYuKoCapZVyPjdGobJf0GAVh2pfw5txakgiCn +DeTywpHjIRTKaibF16Qn4sc5VP6LQavZr78/N1pkJNBtwwOnEZIsPLmUmL44YTcS +EMa3N1njR1292i1XfVS4qW+lFtVLrUplIuWZgmy4y6lwmkRnEjqswdjO1dxqXw59 +BcnVgrZzxhaapvgOCLEPKB46iRff1sFebGYyefpiVrK9HswvI1E3R2UftYefvN17 +yPYqLN2DRxFj2TNnxYi00/QtziZsETdOd0r4NPeij+7CvGr9UOa7qTbOpTeqVWe1 +lT7ZwV51dCnrU2t8iQbeFju+9r2XKfzz0zPVhYvKKBXrbkD0OIqMUZ8ULD4uUqwa +xF+ZLJkGI5pSf9cZ26CaVjUeTdSZAtbsdbjYRCEapSm4LMLEUKBR+uoDRwyBLFbb +JXTzWQaldEnVOguqjlLabYJIrhlBaRQlbc+4XE5nK+IXtPZTes2WhziZUxjePiop +IVgNV5PwsuH9fDP19qLnVGfddfHrTqbqHWZ3nSOxNUFKQe25qkDQ+3XuOfVXs7HI +3lC6Xh605yhc9SrjBDHCVNasSu5novrLDISKbdTxXBD1rTwg9a8eGV6ZQ/nYE8oJ +UDkh7iTlF8Np0oSCsrZ7Mnz3gUzWvOdxojpwqhYVwWKlRFAtpl6J5ueEjTCsqRtG +s2+dhRq3+38KJy/eBdU0YUaiRXGMrxYXliaHnY2XnCXS7i6bjDVx97IyhztbxxyI +FcY2fCGtI7Zl4miJNv7guAB8znvsKNXXXPhDMK0uGWk6q0mxi2CsnvpEaC9IzzvI +LtY9xZGHErt72fDKPLo0XErw6kBSfC2ZNudyQ/LdlDjgs6AIMOLXPfONhVLnCjlf +VMfEoSJDNaJgvM6yzGd8nnpBsKGKKKNXEXfbGyjQuH1AgwWnIDzgCpM0XId74Ju1 +56q94i24ww9b9xs7CNfmfuhq7Xb46u2o3dkpSq7yb4GI887wdagBhDFdNtRdzNVq +BTkyWynJ+iL4cQ9aUcRTQ1HjBPHdq3JcwarpoIJunVY5SXjKRmmNxQSGebYr4uqG +sJJmPeJdj+ofX1zmR68YxuahGsNB7FyEisNI9FNfHpG06X+0Zb2bUCcoLfdCb43d +DHr57G7WiSvcGVNvC6GyjNV3qK4oKKIhoxxkVg5/dCLS3D6Hubev2PDV2UKYPTlD +dWaBRkIvl6LoKA10ptRDVis/Qa70jXHtV7//xAAUAQEAAAAAAAAAAAAAAAAAAAAA +/9oACAECEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/xAAUAQEAAAAAAAAAAAAAAAAAAAAA +/9oACAEDEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/xAAyEAABAwMDAwIFAwUBAQEAAAAC +AQMEAAUSBhETBxQhIjEQFSMyQQgWYSAkQlFxMyUn/9oACAEBAAEIAvNJUdN1r9U+ +pgvGv49gZt7YkeBaXiowY5KSoygIKDipJ96Jyiu6IKLjuiBxlttXbClGzkm1YmI7 +kDbm3gyMVWkQy3VRRNhQ1FtSVU4VUd6INt6fQULGv8t6x49hBhEdTYtV2ru7SpLe +4XCZqP6f9QP6a6rW0aNEx9Pw38Ui+ajkjf1T19Mi3jqLebnAtbPcuY1YGWmGhcVA +5fBluiLWCu7Nk0BIi8Y+S46ER38tiCFTjfilEgRERpBQMqwE/qU7sgVgLaeEZaBO +ReNR2pwR9qlKC+lUUi9K44r4iNJvnU2LzwlEtZ2ImZJkjhP258J0bSd1W/aYhXgl +rzXmk/1VwIAtMg3Ibvckc07CyjeLz9sc4UbAo4oW1OIri4U3mqb02i440KL703nt +jSNPq+RVt5THES8i3zJuh+XSVEw5B3oWtxyFBNFFA8p4VVbJNlkCG6mDQKqoQNRH +HCUyjxCZPGnc9vTrKIBt9wl6gusuK2X6V5Vxl9GoCzy9/h+K8b71rBePR1zfq1Rh +7ZpatAKRci2lFfltkLSYpknnJSR19qCyUiQH4pEEPuBf8VaFUBMkQEBaVNvLbgqj +lApL5QlH7ibTz9NXMEyTkAlo1Rd0ohIFyNscjzCKC+yxgFNkcPFzLK+x0PMa1JFR +ozZr9JD3J0fYZUk+Ke9dcJgwekV6cchRhGMS0xCR5kESysduiCKNKre1CJou1Yb+ +aRcV8h5ptNlxT1mngycaFEFoM/NFg0WVKaY4iu22KhuqqqNsq2Itlxtr93o32QwF +CRK4QL0lDFW3OEtsfNdsqGZBqFsYe51q+yttmtzX9G9yeS337Trxe9e9fjyNfqRX +/wDHp27De7fFVrxV0Y5wIgMMbr9ux1yEAJgpqfkWkUyVK38pvtslb7+EQTH00Svf +4qP4QQTDanNkpBQfNZIopvv7KhtbJnSC2e+OxDsZR319qaLOhA+TzKtaXSG9Gf1C +47FJQL9I8uDG17drZJLz8Pah81+o6McnpLM2gkXKRDoxtZM4zothVEpwx4+RHCP0 +iIZ/kZTI7BRyXE3pJjjfh0p6eDabmGieFfRFUkHJS5Bw380atp9auZGVwJJ4I72t +Oz40VcXVltFuajJFkd1K8MM7K53IIPIzapYP/SpFXPEIf2Ch9Tofb3onl/TJGRep +mSl8U2966xwXrh0yucZu1q0wypNaBabYZJpZDuxpse/CSUjzTxYt3/UcGwM4UusZ +sn/2XWbnknnNX4O4QXdaXAfFQdR4YySG6MOcTjTLpGGVC5y7CrjvEqVdrmKKLFJq +Ip3G+zMvDr1zAFmarkgZrSa0kOJxKd6vMps+C061m2uRxuWPW1vmuArVvkNy2eZt +CwUduqzaNEjQ/pv7Rm/d/LL4b0441FYOVJvfUeHPt8q2i32yXN9uLodFxdxmNrui +1cBMQInb1rgmlW3WpSmy3iUY0CZLAliS7Fqw/LTsW6svE3OizXVJEbs1zFVUCsdx +7e4tWiTp+ciwilufME5NivMooULv6uYsTm/7SDGkSMlGVaLwqcjn7M1vKYzGD0z1 ++Rt9hbOleuzDeXdOmt7fd4xuOiLi21/c9Jpt0BHLPMEt3Nk6xI61ximgbAd15FHR +Ryy02w3NpK6q30bRa2Ii2fVUa9EsCTq+2sWq8sOtdPyVWyZqQ0SIQuat7ieiW1q2 +6Hjyd5AW7TUdpoWnXjtFtZ5ZzvUrTsc+C1T+oF0f8srqxXH8pdpLStwkK7DYs4tu +KBW2QHpQRYSTOXezwRmW84UwdI9kg9rqe+WDQ9sRbhdOoOsNQOCMCHJ126RbwdQ9 +R7T6ImmetNybkjD1Za51su0cZcWRZoM00pLGzbbmXastY/d14c/+cAg0n7V0bCtD +Gk2Rj6ahgND77117EuWGVW5hJE1lutfgs/R6XROnTgk2Zty8cfM61x3k+pBBIjOB +am1K3aYiuN3gmkEbrq64XG8x7ezPbYl3M5TmGnYOprz3LUXialf3cf5sQMC6Olb2 +j/0ChK2RipMixHY9My8NNnIfLULn7iuq3m43TT1wb0o9qMYsYHr5Fjr0y0mGp9Zh +a52o0ldOr+3A1BpZxyyzxftLJg9GVXHHX3PS6wqu7KfXqGUy2iwGv4Mhu9W4y01v ++3IOSUK+a61W/u9OxZiaNt3Ndtz1pdrRHbc0tXTJ1wYjTKyATbasfPqebFBV0dVX +IY7ZSEjWW6szhvE+4OW3UdhCK5Zyn2TUCPHoeRb9B2Vxhu8lNuT6OuswH3opnJ04 +KszGyS3uNiAkZS07MmEciPXJXd37XfO4SXdYku5JFW2Ps6Q1HBnsztOWu53DTb8u +6adPQ931HcCuV/0xoyVpOYZ2q23R91kQebLMt6bbMCVU6uRXn+xYTVJhcbNHtyw2 +O0hMxaSvztWsbd830pMijpkOA5+OrGnHnuU+m6khkSmiq6uSr9yG8z9GnrSAmp0V +uir4X5HD7sna+UyGxJqriYtiTdGw+8qbJDJpO3Gyw0SeCKywogihIjPD6qQn4rp8 +ZRTRVzjwWt0F2BY7Y8uI26wWKFFzJyQwgLHiuI4S+YCYUwfqHaMI4oVa6FS1Jbef +TUWNeNQRWWyWk+DKoq4ldbUti1VMtNahRwHFB7SrDtpcZoF5fJCGxelBBBJCfhLt +T9tRfNfLXQ8DKtzo+CetwNnuDVu28vdk245vVsj8cnOozaCGKF4FBckxm2rm5Xyl +JK5tNW0OdQKMKMIKnxMnshIAOCorwFviLQDvgsVCQ6jD/vWDfILk8ulLXJMekqvv +4T4DtvXV6B20+DqJu/2eVLTvWn8nmoB1EUMKMvfEHmstqwVwl2cY3RaIcS3qQAue +qpENJBIKPtcacYMgeOKxG0BzdGQwb2QXEb25JrIKaGEZTdXKlRHSUwJz2aMEIsDW +NEAZCrXF58DFDJHAhs5vooiBMs7pdc5d7biTumDDi22Vc3KStq81qqy/uPT71tSw +BOhvyGTvUYmm2ro3GAm/FSMQ3WmibGuRfGRyfOIvyWPIxuFwnNzMSVvZuWiqSuIy +5vuzTLYtt70yyqNI7JNsiNHGWR5B9QQRNtXBBHCVAJGQfXFQacaNUahmKuCRNA2R +ZIQKXrCPHL7wkrsmNRV72Ym9mYCJaGGRpP8AVe9Jv+AJRWtZRRs15OSMiGDdqVs2 +8j9dOcbSLzJ/58qvls2iCMdCPJGFPbY3V8ZUYEuW97lEy5iloF50FlPR80QAEW12 +p1sWh9TpMxmeQLNcnDN7uy3+5ttlTayLE/UhMxwHHJgBbJd4uCLmUdfQm767rslh +sMiefa16RFBEfekr+K9qT/SXm0R7/b+yf1fY79Z2lYkME6jDTcwuMm03NR8KKNou +5FuhLXGLTqknqLwpoopgesohoYkxGitMttxKZIN0cIRJ3dxwACbHHCNZTkRs3Zll +fiNOTKSc4m2EZCX3KO6pJwMgglTWJnmuQ/5KYJ4qzW9m73VIb8WHFt7XDFrxSf0I +tNukldS4pheW7iTf/lTnsqBx5Bip5YpTTwe9OAKrTxIm7iX2Kckc2o+s2kBWH7Vq +91+WrV1hxY8uOiLEFlhr68vWzMWQoQrzrlvULC26zt+yCkDLfBAbMh8tRxAthaBd +8x3QSUad2FvxoaOSvyp5L8UrzX/P+f8AEWuosIpeme7BlU2wpBTkyQlxVK3Ql2Rt +gE933EEF5XpHcO8YSBQA9V8tUCQOxq08yii308uMuFGwO539bk+Tbjby3mTxOoy1 +HVKY8LvVvRCTdIxpiiDwYorlJG2b9KJu55dFEQRHS0ftrIBLX80lJ8NtvFe3wGpM +ULhBft7iFwKMZ77AxAlyLBGgwVKeL6iKlxmCHoRy8xw2GgujUpohduhk6WKNSJj0 +wWnbDOKOTlTZoS3eFXJMmKYyh/cZy2xCu/c+YA0zbb4ASFYbgTUkKnCyvM2i0rey ++HTBFTNYxS5wtBiLICwCb/0e39CU0ePmupFoWNfFdjoYqlZN7IVfcOyyDEBLa7yl +FtzjbaWQ0BAtqOOKVKsslUWbIsWl3CMlq5aXuceMAxbFpC4S2ylFP0JKCMkcbfom +QcZg5Muwy4qYqZzBf/uOn6c10e5YWYh6sxxyBWUV8TXTcRHrmspVXztSUnwT4f8A +P+eK9qH+de2lydZ0nsjksTZtqQLmTTYPY7bXZBdjqtXVXDfcit2q0sRpButXHqjp +e0SDbiH1nivuOGxD6q6mFU4ovWGIhp86Xq9p6Oe1sf613gnOS3PdcNYl7WnqNqa7 +zEG+XNtnHcel7JsX99p4MU9S8ho3mvIJAriWaF2FuEC8V+aT+j296T4Iv5VBR4CZ +NWljSXIoq0LbhyaNAzSg3VtcrlISNMVYsDmG3KLYaXhvNcb7HT+K+i8MbRCtAPbO +aViu/Tc/ajKkIMp015iQ5UHp7aYhFzSrFBjx0js6jsPKLRR+nKNsMkzIe8HhSDiO +9WdtiXeGIzzi7rSf7pPgn8JW/wAP4+P5pnwqKmom1iailso0aG3xo+znJSTQkoMu +cN4hvO3RWkhOSDcVVhOKSowrRA19I9QTLjFd/sZ2qLgshBbsl6ubshQO03jibNtw +bmkjy5tkvJUgQdljLTT0G3sPBcmRdB0ORvmRpjKtFpz3Z+Qq0ntXj4JSUnv5+H5p +P91+fDSea16Uf9wyHmmnMFzBZKkC490SIphceRdsGHHB3ZkWp1yMznSyURpQPUc9 +A3ZblMvMSMm9OTjcdbjHZLuj8dG3HbpIDZhzveUFbZWM2390R90E+m19N4UR2QYk +ghYNfae0ve0sF33B0EeZ9vglIq159q/Px/mvFJ71frj8ug8bdnuzmoWpcyTx9uAt +hz8f3qpG3ifcGjnG44OZ4oyrrZKbYkipyR34jcyFyMnb4k3wfyqPFJiU00rMR5gV +caBHjcrJvYzdaP66c1vc4BNTl3BVxxy5UXbqfqCQHUEbcx0l6qlDBqHcPQ4KOt/z +SUlD8PxS/wAIvwBPNa/cKcbsJrSVzam6svoMut7rskyKSLsgvEh+ZKmeyk2p58iN +m6J8DL8tyHG5QZlkrawmosFILDkt60zG7k8AFtIleh4I5jFBlwGhVwijS5gukkeM +oHBBDkNukThHQyAZVa6hXbueoNxM9E3pX5Byh6YapbeY+QySTZdqRaT2pPhv8E/l +F/NXCZ2MZXEnqAyoTrukn1suq4jMhHUdT6Rgjg7DJbc9mhdRxMCdjusO7gjoPmpr +chV+2GjayX0GozjsqC6+7aLuxbXCbebfR6TDGlubqQVyaWbLL+3EYdjaEaVO8c7q +QR8LRZSroBMK6GpHstRTHK6cDLCSsqBpebGjYpb9PXQrxa0eeVK81+aXzXmvzX80 +PqLar5LGZNWMGtCcSPMnN9TmflOpXLyxZZ7UiOHFipKptuRFcaXGTCwHdBMcdpB2 +5C+vH1Kk2Nb3eKJeZ8ZQF2ZLvoxFZp5xx+4dtI0ba7vMvMeS61bG0LKdJuzbK/SU ++eRu4RcY7rLf3byq8zgYjqrNwFHZr7qdPG5aWoSh6e7DnGdE6b3NyFO+XSyTYvHi +kr/n/U9q/mrtdEhtrHawB50cdYyAd07fRHqJZWbvLv8ABLpteycipFksuqSelQCQ +GxPMeVCpdvVWecBbfaMaZkmu7VMMQGlzomIEhNpIN29yUsoXCe5ORp1Cc9T3EH2A +48grhH7ksecp0zcdg1HPJQxqQ5vINV0axLaitfL4Epizm7cLXa8bfI4mbLcQuUJF +/o/4lZg0JOGklZ7iyHIZEc+OFX+Uk7Sd5uIXpkj1bO2nwn9J6mSSlouoyGBUW3QM +MlQkRVU0AT3dj8YOlivZNmXjtjAvWDWexUBOIm9SEF5RydNF8E5yPLszJUGGFbon +OMMVukxU3brUEvcDqGz3M8Wl0r3tgtjcw7ewxpm4MMFY2ytEJq3SNKTkhTBF1VEv +I71//8QAShAAAQMCBAMDCAUJBgQHAAAAAQACEQMhBBIxQSJRYRMycQUQIEJSgZGh +BhQjYrEkMDNDcoLB4fBEU6Ky0fEHNFSDFRYlY5LC0v/aAAgBAQAJPwJc/NWkeScL +le0DuvqRI+ELTNyXeIXJC4TTbkpjYgKp/NO32VvFGTCZCGbrCEnqo0EWXxVbrKMr +VC20p21wU2GjZRdMJcwfJSB6wOyqU20sXU+r4jtRaDpp1habR6NQNDbydlUfUpv8 +oODX1dTFiU6Gs0680wfc5rcXumCPwTe7yKOa6cgDO6N+XNTPJN4id0/4rboheO8q +Wqpp0clumyQthvv5hY/JDvDZDWxKflq0XtfSeNWkGxTqZ+sYdr5paaeiyQKRPyVj +Ve58cpJXEYsI3TTNQ8MofFNnq1XB/FOh3LmvmmjVPOQts1Ad2x5JzTe45ozf2dFU +ETcEKesKTv3lVJEaQmD9oJ5XusnaOvITQvmEDYJk3ioU6fvDcJ+YMqVWUJ1yB5j0 +W5mMwNRxZmibc10QAZRb6xRzX1OwWiPdMG6zaxYSobOs7LcalHxQyhw4UYI3TYGb +ZTfmUNW2lEeAK0HJU9NU+J2lNn70ppRv1VxOkocU2vdO4k25ByuBUHizty7cwq4d +2ONrtyx3OKY+c+gFXyZ8OKYPPMYhGGNyhHLTBEt5jmmSQJiP6uh8SgIQ+Cf8UAea +FosFb3Ju86rQ9VW0HKUyLWkJ5zc0bG0p2Y7nn4qn4WUxOqqWVp3V+RKarZgqRykg +E/xTC0NaRUjRviq8mhjW1xT5B41/w+jOXt6Mxue0CPef8ghOkgerZU4zC+ZaQjJm +3VH3J0QbhaFfBba2WsoQ3cclqbSpUdAU7bQ80NrwjbmhGbmolDwWWQv3k068kNRA +6L9IzNRrN9sHSUScTifJ1OphXXs1hyuHzHnKKfDWVKb3f/IQFfigShwtfad4XNDR +D5LQdVUYDKpSD71MD2QnGOj+8h1cDyRPhKOvNqMc7ok2TpYRaUJqZQqp43cKzPJP +LRUSMpiGmy0j2l/hN1p6p5qdLnzSG1W8WVNJNPye4sqDnMEH0aczSlxnuAbqr6sM +K78SUPij4ynf47nx5IZ6ru7TWF11c59h4LE8BMZGjKAqoDi7xVTLJ0MFpT4pNIDg +dR0VYHtHWLXWCcBO20J1ph0IatPeKpta1/W/iqhNfBEiqI7zf6/BNc+kKhcYfAzd +ShRFYHLlqU+HrdPADteL/VVhpf7wTqhZNwDLmLE0szrGm+plJRkm19VrIhUzUMyJ +5brynQoODOzbSquAL/D0HZabBLnLyXVFCpTLHVpHd3sgThWuyYYFsHIIAkc03Szp +Q3MRsq7adG2Z7tuaztIcc9fs4I/mmPc/9ZxcR8SsJWrZNmu38SvJJB9kVQ5ywdQO +bd2emqZPLh1KYMlRuUs/uX8/BElrsR2jQNBa48N1UzMzkCVUyyIyymVYDx2sXOXm +jJkOa+mLFsapjWPfevUItTjW2/gsO65J4zYN6xuV5LYQT+jc85vHlCwTKTt3vfwj +/VYnChranG1lGD46rF03vbdgOHuP9V5PBtBItPhKx9auGNAw7aovTb47+9CYR+ze +z5qhmaa3DZV+1fT4O1nvAaec/pSXvHMBYYYeqT9mC61T+aotaK3ev81EAX6lawvs +6TqU1XAx81UPe7z5gqi1jctzAKxjaTWC5qZQIWBrYtwMNOHp2Pv0X0OsfXq1hPyX +0PYJ3bVusJ2GII46b7H4J+dpPC8atVHQZtLZv9VwsFM39r+S4y0dnJ5Ks37N+ukD ++indodKFGkOJ38yqVHA0z+jbTZnevpg9h9aXt/CF9KcPiiBmFOrRDre6F9Hwxrv7 +VhH5m+8G6LXMizoRYyo9tszJBTHQdbfxRnmg3NIyyVw1/KdXMKm4o6k+/RCPsQfM +EOE4Zwn3rnKae3wdcGpHLR3yV8z+FfJUTBFroOH8FTNR5tRpg3c5Y3ta7hwYUXy9 +AP4rCtwNOtVy0jUHEQN15cpg4eia04itAfHqt6nkhSxbsGGudRq2dlItlPPxVKKj +Dx0nNhzOkJ5JBTvVVBryRxhzVLZjXYqrw0hxOLlV7PDi1Kdx0CDqNL9TRpHi177j +/BYbGVm1O/8AUqees91+7zVKrAwD6lfLWcxzYMe69oWKb5S8nVTAxjaf21MfeG8L +GfWMDimZmZKk5hzCJiOHojnjuu5lahNh7w0Ax97VUHNo0cE2izxiUP7Kz8POP0Vc +tPgQtKVMyqWUYqk5rq52eRZU8ve7SDun3BsjchOVAveBwgMklUWVH1BJFdmZrOni +EKlDF0Xh+HxI4g1459Cvobhce406rH08dhzUouLh3/dqFha2Lx+Kb+UVHMysB2YC +dgsD2bw/Ofqzxn/Zk7LDCnUBJ72revVG6fxi4TetyqLnsDpNL2j1XY9u2ftKbzpy +y6BYihWovGXJWbA8F5SbRbSxAqYWq1xzUjtB5L6L0MJW8onNjsRUrmqS/c9BN4VV +9XtP1xfI/ZjYeCdkonv0KpuPAoMketzRBOwlR7k48VVrRHiqvaVg6mM/N2i/V0mt ++A87ZcKedniELkNynongkclNqrg0TYrmgenmo6xsoPQpxAbwsaywA5ryo6M/AeQ2 +Ce6o55mCVwzpCec7hxAruht0PVvdO2vxaKbiChLTrHNU7k3DU0N0AnVVA7NLnZty +dVQbHNyG+qNtkL84Q1duER2dMuf70JbTq9q8ka5fQbY2Pgmw18hnUahFNd2eJodq +QRzOqEWuvFG+8lEz1QRNtN1lHPmqZnmVcyqYsb+KjxKNjouMO1ATOFxlqnNF4F02 +D1KYAZsn+OVGZNnRCedd1HuV9jHmYLFtNt9TKb3cOIPifQKGvBUPUfyVIvDjaFLX +0Yp1m+C3R0VS3XdNmdStZ2VoQ6SicuXVNAhtkBbUrXcqrqRHMo73DbozBsnXHJEZ +kyDqqZP7Kdm5NKBN5ATeLeUCGwZCce8Vhw/C0QD4uO6o9mK2IyUWeyxlvRjtIz0Z +9oKezZSPA4d0px/5pgdGwNkQb2lC4+a1mJToE2R9wTZedJCqW3bKZlI/BNi3EFfK +bps/dJ3Tm5ok5VY+1FlYztumBpYmQ4m+TRTDOStbQqnoO8rcgvAKBpvquULKGZ4c +fBNjgn4oI+cqj9ljWSPHdOtmz35qOSINtShottIKBFtwheZHgmTewlRHJW5iFZs3 +PPkvmqeUkcVkALBsjdd4epGqkT81od41XDJ1Th7163IoGR1V99FY6+Z/BnzVD0Qs +BA84878rgZpVPZKwdWoz1KtFhcD8Fh6lKo6mMzHjKWofzQHvRMAXMoi61dqrS5Ol +2hgfNPdL3BpJuE0FrG2BUNjcjfkgRJuZTX6kF7hbxQm3rc03KKbb+CMpsW15poEn +inktQbLxherYwERdqLuzyEviyp5R+P5kWxFHLI6II8TdQtSEB98803XVOOUHisvi +rGeE6rybnxDW2Znyg+9eRvqbHOs4Vu0YfHki5skFplFuRo3Oi8lF+Fpt+0xVSqGN +93NYPs6R/S1n+v0CAMaQEy4Epodf4ICVYnQIa9EJ6r2Qwfmu9hK7X/umxREBau7x +U62DUN7jmtVUtmWg5It6krhPRYh/gTMhY11WgRm7F1+z8FjHcLuAZuEdE+q7snjM +177RKaMuaHRsnbaInpBTvcveFPMFan5J+p1KF6ri/wBMefStScxWcXln7wQ6BG+7 +kL/im3IXqjM8qkZ9UTuqgkiGWWIjIIa32lTbUY9uRkDRov8A7+5M4pNtAGpmV7iY +LTY+KxBkuyO4vmnZTnyukrFDM5ov/XwTAN3scYjoiCPVgappvYp4tqrE2C1dDQu6 +wQPMfSHmMQrNdVbiKf8AFetvKb4+Y7bolpGsIPqVDAbTpi5HNHs35ZyZpI6Fa5dP +ZCzBjmw1/KSqb3u7TiI2CwrnZah4AfVWFz+t1lUcrg57cu8c1QfmYPs5t/ui4PZ3 +yW6KpJo07370p2nqhbC4R0TZFETP3tkUPMPMFr6NIThXSW82boix1OidJpuAfA0V +XTvKnmm2qh5fZrSLArH53vGSqdmc4WAxeJqMqw6o2jwL6L4t7naOqwF9Bm9nPq4o +TC+jeKw2Y3q9jmA+C8iY/EuJIzUsIQCffC+hdUOIt9ZrNYI+a+hGGJHLGfyX0Vp4 +eg4QKlJ05VRGYtguDr+BTYP1WPEaj+K2WgGjVMEocdTjf+YHoXDmkFerULb9Cmj7 +RoDiN0DcLTkqWZ1yLaJsB9Mb/gqIG8pgsNeapU8rSm5cug6qiBexLlXa/wDZVJve +tmWGzg8jsmOa6k21SmNkCyuyo6+ucH+COaEfcvWJcW/s/mgghZc0z9eVzU8MxBsh +xfeTXVKZaJGm6ENAsS7upp4jqBqhBn+gqxDHd7I9Ylwd2ovmmyxNRw7eBJtCc9wB +hnabpkFvqKkTzhGBT73EjULnzBJnVGRdDiyxAUfZUYHST+efLSBMbFX5lP7o3W2h +ITTreCjwg7/gmxT2ajcn1OSaC7LEAFNMHhNSoFQy3sZQZnykZzaQsrXAcTp2Tqlm +hVZc+M86QmGw7inhbJCcNdVVNOrj29pTqZeG1olODmOuHDfzj8y6KlazJ2G5QHY1 +K5+qU9+w0Dj+1r71psSjDc0e9Vm5mO1TM0G6baZ1TXG0XNk8mY33TpdJbmb6x5eC +HaTBDNIVO7Bpm+agg1BxH1Z2TsoG0IuB7P1dukKYiGk2TyR6pzLvkWJVQh6qiqyl +gmTg6thUuTwO2esW+t5PfU7MPrCH4d/sPCMtcLEeh8fMPQCkGoxmEpEHQ1XQ4+5o +KBFCnVbSwrDoGU+D8QU4EIWO4TYOifD2781cESB0UE5rSVS7xghux5qYda3VOHsg +TfKnAHic6Dy0Cyg9rAbOnJd9zb+y0+KPDZrJOh69FlqO6GwTv3eq9bV3IJ1zuuNu +ZjQGmNG8+aH1mrh8NOKot/t+F3t/es1/3WK7RoAODr5v0jCJafggh6B9C7j3Qn9x +2Ixb/ClQj8XqQ7F+QKVaqXW43OLj/mKH7PVc7gKzmndN8QqliPkmAWToymQXFVYL +hdoGphPPZ5ezDty7mqo0gSFWJd2wzk6xNp9yqZuK3JFrB69aN+QTZOpvr/NAzPAy +bLY2Tp6hEma51TYx9EnEeTT/ANQWfpaH7zf6sqv5J2Axvkt4N/qlR3Gz/tP+AICI +7amclaOfolOR8x4advejH1f6IeWSHci6pTaP8qn/ANMfgsLVtbKaEn/ME4CG2jZW +dvyKsZm6cZ5hcv6lWt3ZVOQeJxY2/hCwjnYktysBYc3wWGqfYuaXmlTOU9Oqon6x +Vw+as3Kc1MdVhnNb2HamnWHFyuFVNX2WGwHuQDjtBsE8lw25Im3dCHQoBrQIYE7N +NUkouOKvi/JMf9RR71P99n8V/wAqwDyv5M64SvwYuh4Ncc8c8vJOu4OpVL6uYYDv +ezKfQPnCP2hHwVSXVLgxvmYE7iZ9CKr3f9zEv/8Ayqc9t9IcJSb1/ImFEipS4SDr +ZH4qwGiqEGdYQ2uEfcqQ+GqwTS54gujZUHHmIXkxpqZcpqGnchYemxzW5Q86gKuX +H7tgtYs46IEuLvZuqk5tPBO4RsnTyXtG4Tfy6hSGOwVL+8rULVG/v03Qjnw/k8f+ +OeSv/c8nV7YuhEDu3dHPKqpcMBU7HtHD9I3IH0z1mk7XmxOlzLH/AF9A+Z1gCTdA +jtXAgK/5TkHuqE//AEX6/wD4a4OoJ5OxFYruf+eMEHHnOBaFPY42rWLX/fbUcCE/ +VX5wpgb8lVBB9VMyxs7dVi3kCbKY9oXCggeybrTfMpcRfTRO9w3Wg1jQIG/eg6o5 +eSfv6wR00W8ypd9Rq0scHA8TMkMxDfA03T8U2aPkHy4KOsB/kryjZvQhtQgfuLDE +/UsHXwVVzjecDVhnvdQqT7lUDWtPZ1DOvIpwI6eb/8QAJhABAAICAgICAgMBAQEA +AAAAAQARITFBUWFxgZGhscHR8OHxEP/aAAgBAQABPyG6H7mFUGIUcPUsNZzlLOcX +BtOhq6tYJdC+CXR/BNitNmiJNGPvUbQcqquPM8gbDe3mW2DG3lzFFTbkm31DKLyq +tC4F6siwfUzW/JYK44i4GUaejDMBzCAVl7hG9bBL3Q4Y2EwvPWK3HIvA2EoO3MKz +DfE2OZDVQq5xDgAGE7h6kPdNvMsUV8l/sQZrdhQrQ5H0d+KzDH4IjeW/bEhjqv5n +f14gaA7aqQEOieuOFMeIyAbRKteR2y7saAZ8llWy89/4RAW4FhnwjtppgWUIDAN1 +4g0ONLiYi9+GSUIRYwLjI0yplS/MLxPmOaC2051upRqoa4B7izOhrcNkmFPBK/it +G315gBdVBghDas5l7ehdZ/3qcGHA/bqIyuLB5iCL8qbQOCtt+ZhH+y51KI0OwV6M +JzFxts27GoS3/wCBXPHBLafLMSK6zhTg7YdsIeYk5wUw5KHj9xTj5gn9ERrXHPXu +a4NuCn+YBLCTzwgi9gA7Rd4e+HmPuPbOJXOxAqvMNsm0r8It56vsRxKgWpulHzG7 +LF/sxLNoNsIbI2l2sjgRdYwS686eyFcZbuoiwo2f3ggjR3x4eqCt3LvPiAVTPESx +l2cXQ9n8wUt3DWMeJZLQaAR6NHggyPxKPLL7aIOx4y7lx2ga6vDwO4jJxbL3ma/j +uG+T4/cSsCupjki6YHWoFd2AFZ3RC924KrMsuNLHi7/7GThsPr1CoIubD/rieCGT +KeuK7eptWk3sVzKCqByV9RQpidnqablXDSS2W1zBxDyyHkjicgVj/VMSg8NvUtqY +bxLBFnWleoBrEQjfqarVplxLd1ol0Cw22MifmVtAtnLKE/cBanca15Obpbz4iX6l +UTNVjeYK3HY7lLBS+w/fdQMKvvduA+C2Wc820BeX/IWRMKiD3/lRFZk/ohytezGb +hhsQ9M9ypCfIyQXupqmVhVQGhMCwaocoAtGxi3pyHMmcpypwa9SwwOSzKdRV9b0+ +AlhHG98+5hh1AZcWKwt4dJlRAsnFQBbMczH1PLjiV526jEAQE2XDO9aPXVkQGgPx +evvGdJ+N7WHHh8y6eVtlXTw2h0zK4fuUYB9EppVTOYi9eyHA/Er7kAVMG/5YAk1W +Y0wPyTboKbfMun/B8x7tFWnMyltwDcHoQPIswpp5K8SgCK7qbgts4zhLfO1ztmuv +REG5hHL+fmDwrsrVcwJvJ8GufcpyOHVC9u5+ncrm2y84QBsacAbfhsYHyV7xnZWZ +qvMyaRxVO7itta3aoIZuOtOPmVEVvcCl20VBznxyNfHPnpgtNvqKPRslF7YzE67y +m6b5GolNTbFgWX+Lh3xlla4ZK9sLGq5dun8R5mK25M0UvDikeTJqqzxlgHAdmHJR +F0qHoiHh3B8Oh9wsCfIf2hZyGEH3TzM3LJXcxsEK6cbiFkOGrMTaxAVw7mrJRRRn +n1HhjXZr/ZgWC8cQdS8uTUuuoyqrtqyv3KEG6yDQ/mGlqXPfpFNgaxL7JV3KuJQY +4ppvxASPypt5gJVngYHqccvuabv5lTbd8TcOrwVb7kEsjVF9F/JAHbfGcy3XNOdp +h9qwtK7mebNYVHkYHiC+hxbnlN/caHL0l6FSmuiO1O1t8zklhdA1lm29n/iMUWdb +pXa9cVNI/wBICXj6/MQXPBp4RzeHHavVxHGItQVidSR5B4D7jhs8oabt8/mG8A1w +C+zaY4jxyECC+V15iLs0letIiVMhVdtd/HMxm8nI8jmUFxyh8n8yuGhhaeOpUCuV +DiXnB16V4PiCwanSX8rg5lVLOOpliTuCXUtGNsK+8cSkG9j6TwbRQuudzzr4lI2y +Lk7mQ0VSjW0AbrI3i+V74lalivetOPcvA2rAW4sCEmvqiSUZ9BrL1ohJhpusPFyz +etxaHBHb8a/TbFASjy+X2l8Fe4F4A7WJ0IcaBTD+JkXpYQRWPOeoqv2OFYHpNbmx +1c3buxSz5TI8sto0KWlNGuVivSStJXZTBuruJ1yoMPVG227xKOABF/BujZHI/wBU +R1d2vllu16mpMg2gakyUeML7ZPuEv/YRSptqnrfusRC9oDmeb/mGZGnJoK+Wv1KT +/wAlLwTCEB3wz7iRDZo/f6QRQvVd7eniY7qCHa2s3RbNa3ODU9C6q0PZqqBF499w +9rqhH1ZcRIrVT2n8rhx2oTttyXz4DC1CaPLNCFS1Ill9jbO9kqaZzDDS34h622HA +uuPJ8TVGV8Wdfl+Z5v3r4ea4h5joPPlVzZA68WZPi8qbcYioYoIM6twE1c7FZht4 +GR5WknxzFvUBmmdYP53FG/BFx3XD/wAqvzGI4mONH4+I6Fst5YSFzQo6mPSYcUQX +WnylYc1DzmN/xMe4YldI6E0h6UqhHInMBuS92+jzlHvwDPDRF8yn2i5WGrWm9xDl +2L+h/wBn+tlqXzxLF9aDl0faD2vjtLa9HHniKAw7XGg3djnNjyiSHB+kVMnMNja2 +shZSot48zPDCz1eX8wb8lYUMYOfUxSG45A3c2QzsHgqPmRuW/uG/zDXGrylcNY+O +uV4oKlclhVa7f9mWXi5O6jaKdCRPl6hb4sVIWbp5olFVKgKYCC0dioIFA6KeCZDp +raQ2Te6IK+DHkHaYFf8AdfibYHOO9YM1cLZrnELKrv8A23GdhUDxmiBbjdKC3i4+ +NZaBqnnMcxUtvLF8qxrn+pnUc4cvU3JV2OiJfjkg1tfk4hYvPp+EGwwjKtJmwQHF +KycQJYmng7l/I+o93YpH8rc0Ajh6MMYVdYic6OHuOhUwvP8AUustE3OeptM+qC15 +EpjRspm440xW4iAaYhyzTcRYlkN9jJC93mK5reCrU1anouZR+OX8mVq88XGN4qur +O/F5rzEli72PPHzBGqYTT1FEVcIxcXINudlW/FX8TGcTmcQ/cq6v1IS0NKfiLgTq +s7ZdXWQ4yluW8M3AwrzAav8AMxRxwNTNlRo2x1pV1nO4ehTwjH9rS9+5aw/RP7Av +cWJijHeDJ45nU0wh7qUlqkqvEXIB0cc/EOq1L9QURujU6mNOs2dH5lxyt4HzBnea +89B5uVXKlV2cviHsUqXRset5md14JdpiCvUphUTaTfmVMsSXDUqdG+YjHVWyGdOm +nHAX7i6+mAWfmpzeZYndZvE0yFD2wzMwP9X0xX7XFQfxLTGin1klT3CcRatMUrXR +AKNvAXiEzH5lGXtPmipWCRerxAMZeD/hH6l8cXuZCcCsX6mgWHl6QWpwP2QAMBbO +3q+OoAwovROiGBbYOeSGA1D9BmAZp5aeqmHRTO9THAavR8eppljOEtGHth+LmNO1 +wCttTRq2ay9B99QiU9+dqD4i4HIhz/wmStnmI4ZzYl7lYMrgs9BNzkP2mfGlF3eo +H1tb4aWfnUslX32EUa6qisEsCKZQVYdS8V8rOepVSyhwvHUS11OddSuuw2Oh/uI+ +ZKOSJk1Dc0yk6Kc53Moml+CZrNqu3qoSLjDKAbPFswsm3K+GJ8ORV9SykOCsHasa +6JKLeL3TDqBKsfULTW+l1G7bzAPEz7E0cTYxjdtzDPuM9uvUJ9GAN2Li/Qp/Afbc +W25es35jtxXRA9jmaPtn2j71L01pkAxoYqnscPmVi1H8kfrAeU2aOwhSMAuOX5/c +qyJQvBME7NMCy14DT44qY3Lkq23bzLRvVNoVuNQpUu/ExMwtSHgeJsq6GvfMr6oC +mUviZq3QYzzE8U2DqoihEO5rNzLwuBRBA9qx9wx65R3BzWeT+Iphuv7L7lTdtnh0 +4mHJVA3CAAtblIM5tgc5TLk/KdGm5RQrU7BLwU6YR7ID4iMboB7MSiYEDDUdmPAJ +W6B0azCNCDLITygjB5uDxYRXghlBYxK/xA7KKyabmGxrBW/EyhN0cO6BAlCjSbfE +bknduYluM1otslYXQfAlQFzWoZKUW2HMBZLfV9kRMqyca/3MBJRVVkmppFcMwPzG +8qf5g4myl6iYexFtxDFlKjFXyfM0HEHQSmR9s6c+pe1TG6hlXETdHMUa0XP9c1Wj +1YuEawK3hcmyBDTTdXHo8AbxB94Bxh3guxzOcSNW5VQCQAc+/wBTCkFwY7UIVUYy +NYjJInkAf3Dr6OYNopTERd648ShtWQCj/wAQBTU8nlDGKWusv4hBrBqr/MMxWvg1 +huobYK5GkNZGhA3pC1tSwSlQGVg2OODFeJa6LbYAho+G7c/KYeIUx5h4Zg2fHUU5 +aOiZ3Tf6lG/8SwL63MEkEuZYOxvl36hPTiFBMThGfgvHM4ypwBeEx7mmhqfhwIOp +k6jyj0HnWFcnzCwGGeexcRtOJ3wMRfxXmXTwO2DrwxnQZaADyy66j4E3Ptif8ixB +67YQSIEUyvApteB8QFbNh1SVSCXY4qayZXUEWwJn4dxO2OkIAw/5cv8AEtrNQ+v4 +nXOO5Sy8eIXa+ZrHJ1PK1ua0zGulvO4fHgH+mmWTZHL3uJRAJg2GpfcqJwJZYuoc +Jcic6o0wXwRQF/cTVDyxMOCN9A4lJW61Os98RFM2O7JbuXJAD0/bXjUAes1sWx/c +aOM5itEjxfiDQdH5lK1q9n1KrY9yv4zNUtIjXuAQ1eDiJqDi3HBrVq53CKk3mYY1 +19aPwTmryx7XqU+tJxBTnZyRUbdeSUwHn4mcm3uGNdbIL2eYXFvPaYgDmuOWyz8Q +wFSjwTE5FWNB5JVBZFrowqJYq22Aq45hj/cRa/pbAPf1PIZuV3AbCPTXeYk7GItt +B83lzXSYbIBXTH9fEvoIalX/ABhcbrKN1i3Z1zDY0rp1n1cLsc2aPGfPB8RvQXYd +HPScoQ4l4Y6nNBjWdSrERnTo7hbgmHm3ECHQ/EBUA9XmG/aF4hZ/DGwYxzOKIZMX +5zqNeQMGmpbHyDzG7CT7wfGf3AgXhQMCFnd6PzDVl8CYPMpRFt6y/p+HFnN4oiBK +zlMfCrfWY+oMVVnZziZkCQI2nMulay4Wg+CDnObzdp7xKaDDkVz8K3GkC6g4U3fU +Z4qU9MMHVp1FZz068RzQuUPa+SA6iMODdp578Qhac7Ll1M7qeGaNZQOGXawfkwP2 +zcK97lt9p3SFlV+U3v8AE1w7qPLe2mpvm+5pQv1M0wiSj4O4ZG43Jz/cBSGnYOoo +AcbLJz1BQovQOfEbzDE4fbC03ZP+GWryBoAyfFTNfRTAqhjc6MDs9upelB4JPVbm +JNEfgrufNRuUjuNKauyYxg/hwo+prkMMuXX+u2KcedymF7CBj2fxGsLgrFlPhLEv +uDlis8QoYbLgl4LAfMwEt8ro+CPC/iGcO9zwJxlqWBcXIiYPc7W+JRfKWxzM9+5k +qrHBBZp0dJC4KAHwkAIVPzXX1EU3bzEwZnel1EkC0RYNpeD5j1z9xvdufczTF4d9 +FRgoZ649JYu5G33LcCwpEw/Uuj3A6WOBiU/xJciHPn8EGYiqywVeKTU6pzw/cfII +pxpz0ddQoo8j2zO73v5zNeDhhpdRbnuKtHc7VDyfEXK+Yy7DPcKbN7ZalmXzG69s +xsxbxcbMRk+hF4gxKMpz8DmVRusPMTeaMSjsSY4yaVlxHhF6Eyz8xCZdzn89RA0W +sb5QK7gtPcZWhxDx+o+rhZjO/wCKuOQe1hBVfLPYQOTfxCfD07xcbDIbKnwEVMqq +q6rx8zWmVQBm/GCbIVXtXxF83IGRLY9tGm2/5TFxw9zwfmdvxBF2ubiL4+Z5VmLI +1Jdbqpdbqq4hbYfcF8puzjZfmUMs3wDMEG0+CE5XwrliLsaRKlyg3ybuC3LV/klg +YwV+eInRRhbXN8TFeIUN7x/szLdtuecfqPt27F1/moYggBYnvuC5ev2EFloK0J7Y +BdBsF9BU6PEpwYCUpwvOC9XK0LkNS9gtLfb7NQG8BWyMq1MQa3WuptXKWMwVAmkx +xVZg0UfBMdNwLfFBLcPklaJa3Sv4wZhmptqWHNh9RHLLQqZiaIr/AHJ4jBb/AMRt +Rgqvz+oFaeFl4uPqMB9uV67HGhuMMom8LW3EVDEkWhSipeG010H++9z5FVFu3tmk +N1tS9fMoOuESl5G3fES0TwrlAOj+xX6gyYIUOvN9wc4dJKh8Fi9+NxyYvx149On9 +oM7jQqa/p/8AFHNbZTznpKvjEfBk1MPKYu2XnweYqa8IpOTxUx8oQZybGXuB3Ktd +PHvn1KCaaEvU3DMsYqMbWUKrye44Lgy10YKrCdSg/wCwEO8gZHS+JzMDTNLKnDuW +6NAqZKF6WE/L1XA+9MK9wD6UvJfKYiYOtSw8dmasgKWWF+y4iVvyHS8QLamOttFd +Tk9W7ByVH7PFR0TMYb4KDJwCtMxSnh206+k1fGNahVtsZ4+fyGY5lzmZKRXMX9Cd +DXlj/wC5iKrLwMFDHO7gNcomBedsa8/okbnbRdot8HAWCfs3Odqkdo2F5adTQh+Q +8zP5F4zcvyuvJMkulWS17ij4wxd8L4lXd/biDMMeW2DfJtjPwyN0HLo8z2tHDLa/ +mJQlRab+ahA1rnDlmk8ViVoXgbLT5feoSKdtkvy8qPaubBE1iuB49QmitLeSCKTI +eWWB05ADWTpf3FmNq8MmB5cajLdUDrXn53OyodGFablMqzOR9WBpo9T4qlqL+NzE +Ba0pmTF9Rcr/AM5fQFvpiJ+6UbhZIsCE8vthCs0Ih4ADeVjgTig1uEg74UdPuHWc +Imxonav/AGJ4EhXKLRxTvWZpG/X5BmDlnOGTuGo58eSZ0ikKaftM9nEpCCnyV/jG ++E1onXiAj+u30agnaBp2r3CSrJcOogwaMfM0zhTJbnEX+HiMnOcuOrzFKCV8xRWT +X2dEeVbEtsn5vnhU+xBTcsbSXdtmJd7bgq35qFOGM3ANrSXoVisv+xMQqKuA382j +DKveWN+LmSPW4OGfMu4WmekEH0nHiJXStxssRfY+SNXPfaCMheRg9wFot6XKIGvN +riGoBA0dHmVFUb0luow0BjL5maD5wfZYfqPs4N3wHlmBZbi7/wCpz3ao4vzGmFmL +cYewCYsAhjV74FPKyuG51T45CSs8uphtkqsQa8SI5Op9lTU4hT44nOpvv1Psizd4 +4YCAeumYgVuLV6K9V9xFDRcFUn4hHbuwptePmZWURcBj7SKinhp+CVEBs+LFIGBK +zLgwukCEKyu5aU+w5gQz7UJlBTrhe2ClptUKZ6DwbSJJd0wjHRLxo92JKjh/E+4S +8RVkU+Y4blKXCl/4+44qeDmYXUnZ6FjJgvWs+WxTtXUMvuMAor6CjGtKIbM4s6d5 +ia9JZuo/Wn4hHWSoW39T/8QAJRABAQACAgICAgIDAQAAAAAAAREAITFBUWFxgZGh +scHR4fDx/9oACAEBAAE/EFpQThdFmv8AOGtVs8HO8Ojo5c19YFAryc5VexgFnePe +YOXPVsDX84hRYgpNkPk27dY8slUpSArru4mzGrWkdG/rWs7cAHY2eQWzeEmhRGp3 +PJ9frCugguJ8z9XRiZhJPyH4794CMg+08lZveMHIGsR0/neaDbzLr60+ufecXCXQ +Ic34JkE1GME3aO4YIh0BJdDlnAZKDVVQe74k5ecpBMSkF+dnTianUgwG/wCcSaid +U2l35nWGoAYS3HR6eOnHdgh0QcKPt/eatjBS6t0cFeDFgNYJDQvN9ZdSVJqadP1h +/MRVNfJTYfGsVqLLb7iu7yYm8Kq0KR+HrNCGBxOPIu94LI9b35awa6xE2d4sZC15 +SvwFmEwpoJxiQWT1NDjC+Co44Qlho8XDNpNVDe1pOK6MgCCNw2QjkJPbisKEiDdj +nfzcXGAq3918ad66mCBmgi6x2Fo/OIoXkI2uw1sLDvEMgqqNLrzx64wKUWUaBXdC +cRzhndCBBeZoH1hKAA2athvflwk0jw0po3C7mRqYWoel8e8F9aA13UA1tk5xwgEC +ItVjTxL5xGDVkBqIhw8OBp9D88h+OM0UgrYGIfk6mLFDFseXk48dtY9oWnV/ltr4 +3kIyvaknnrwY+W29E1r1+8IIMbj1/brCYsBsDaHykjzrvIy2cRyaVA6eKZpiSwnC +6kedM3iSBl3daxE3o0311loVaDyd5NYVTQQ8HvJiriEVCronvK3rzdiZKPbvBw3S +gp7gCVLVvjJJShDZVBNdi8qYyJCYKIKUcy5CxF4HPAf+PPOaFFawh5GpDdMRofSk +aKPZve8DYbJsWdqvDe+wyonWDeOS73vnnA4Fgep5pz67zXAm9WN+XXOB4Y16oVuk +/nHeAdOdoF5nJ95z7FqQ3z2uPeFSAViQuovNfwYY0PDKokuv+cILLbAotlXjam5m +4IQGbDpRu545wgvYjY7l1XzcI1KgW3RYjryY5xTxDsVgcYKF6jRV9JMcKRVqqJ4+ +P1kNqMWI+nmH7wePbP8AJo2G9DhyQnQjZi8jWk+8QtTdTpeg0dD3hpLvUExtKng6 +8uaobbHi9e8lIIvsJ49Yh6Hc9R+QPGJ4lAT3bacBWeph0+QAKkGcAva0PGSjEGrD +11f4cI+WkkJA+69uNRuxpBdJxW/WAi6KbXRKBULNc49pBp1A4cr57OFbBAbLzXPD +A8BI6aqXowzSgUwp3Pd85BADZtNAeDs984e6FTQ5LqK/eaDG3SFZHH/mC1U1IRpw +3r7xk0CKgSo63zXELqQSo8aTfHGCxATXeDyPrNHCGDfRg0igUIhd+xx7mHG1lRXl +405rggY7je2iGA+G4z2vBv7wZGsGm7orpA/W8MJyGt5UddJNeslRObw07bBPBN9O +Lg01r0nYag0jS4BRBUqPgQAeZjXJHbnr+3DWTqmLRR09r/jIfB1yH3gbNymPQcXv +6uO8d3akHPYiei5YIwwADp27Dkm7XEb61h91qLSHAAxEVqnsOA8vAespClavNXeB +GTA7v7C2u+PGPr5Rs9j5VO9YEgAsUHKzgPOGdpQB3e/p5wvOjEUW3brj495Uy5AX +W0hzN4Ta4pKB5DzNfnDssBtUxB6fvHngewEAgf0OFoEGcX6h59awpwzE0ekrtWRJ +gXzZFmlUKzn4yUfkJciF+u5gM22oD3TjV/vNWG1ynXJ5X5y9IlFRy2D+sPQ9qBPr +QusXSm5uo2+3qYcNajnYu7XHFmUXizVQFdw0TiO6Zxk6FAvBEHjiOHFa68c1XhUh +oau0w7FUXbx6w5OpxgGAO9lP8ZBNmFWeMbWEFmlqnBi965ye9sFJJ1GXxgTmwgBX +30e55xRfYGtB5fe8sQDSDWt6Pj+sEK43wbYnEg7zgPAmJvPi8G8gAi17Ff6MAcId +TQbb7+vMyVZUjnQW8yb+cpNEQWDd3/BiNIzSpGGzS2eJjzaAW0SAOteU1hUDClmo +wPY9ayXCqa61PCnlwI0DEI8j838TFAgpkD1N5mQkYpKgqH0gb3MCOJYPoj7PjFgj +0jfJA/8Ad4Ab2iWDb+cZAmt3fIm+8fTUGwDrbGYUHIiATfHlE5uC7EG4Hx8hznAm +6e3sdHd9uLvoztsTYNiNn5wfuFh2dioPBDdwkAeB8jiCbAW2ZGHzQN5MKE4PDm+p +/GG9vkEwGppXOEyxEjQ/4DASHNOjviWLe8IUGzVi1ff1j8yJbkGQeb+cQnHUIwCW +Aef1hDVRzypvfX+MBLU6cHJPzjjvrV4OWsr1MlckTnrpaqfOWwJY0QxC8jyM1wKS +vwIs/RLlI0gCWxarw9fGHTRDsDqEtvn0YwUBe89u+P3jgM+cBF8GucI3VOGakdUr +Xm3EIQJWBFIywmy4Px5NwgIG1dPe83quMgoHWtVVOHAouAAvAaa+XvA7laplGxSr +yJhoAlSvbboTc5xki+cNDY5GvD9YZkbDVGIHVaOFADCEqC9fx5wWEsPMA0U8m+s5 +aZfuLJF6NgqaiGlGnk9YVDAHQM9IyINvgmACugDSe06zTfMn8sYVD195dk7qagHs +oX3jd4SRboC8LvrvE1oC/ZSToPHOsDhCEJbnaXtyqkkiboIKkpydd4vduNBoLHiw +oDeMMSjBABA8cRl5ygN3Z4ek6Fx4x4XqbfaERDcnm84GKw2A6IGzv631ikoI3xh0 +i3sJ2iYkJygiqZN/CUY0n6TEAfK8bptxQFAskcs07HXnEy8oqd1lsj61MBAGCoAC +mbITq+84yNcXOt0iHAec5Vw3B1ugNAD5MElMRYaAVE17ONTFfIsOY6itE1KJMekQ +eymiAaTQp9Mth+ZI/jNjp9JlDvgyAa0OXgUXeT9ZDlPN5fPZsuaUUUNmccnecWKw +UIdjpriOJhFnSJFPZtr4m9lCzjfONCWNRXjFCCxRCNnE/vAirR4G35XAqQiavclK +L1xmgRFIliUdj/OqSb0VCY69p35wcKA0ilt7wCt46SU6IACfjE6qQEiIqgERot3M +tvz17EhI6V8C5KirIGsdwPPqYBWNI8FZxsjC5rzFJFwWovg6fDnsPLfNxCA7k61c +vtLkEsKzQOXRqmJjDzwqZpEp5U4JiCWsgzHeQEd35w9A1SnVSN3C8bmBCRaX7pXz +O0HxhdRYF8Eq8hHRc03ZDMNPpm0jW3dvqFfIDnbmmEALmA1ZqkkeBJIsMMdGlK6B +SOQZxO8s9uAjSVP0Dvkcoib7VteoEpyceSsoqQiDNBS9NxQxNFEQydEqQUOmMbjF +eOUPPHGV3EGFUQXZ4Hzmjv8AtQFL4ArDqZQQvjdQrwBe1ODKMQ59M0UUAPT8mBZ0 +3n9RUX4zlTTY7A6E2v6uFy7DCW69EINlyA2KtqV9joDFoStG7X9a14xQpJCVCgZB +oG1TiZtJ4MPgkHyZvU0ZERB6rYNhfPeLArLgbYmsTU6pR5doXscqkhkhqCb3oesY +5MFZopBSV4/eO4YMra8Rvyt67MqQOBkVEFFD82c4TsOUWIdi52T2cv8AIkieCjoD +A+dO8rsCmF8TwlyNv1jK+XLrLVlhvSJ2YfdE0K6BoAaCA4Fye1A9KIbfQN7brYNG +5yhN8mhOlMZav9phQwo0qDnWKxXTVCaQhEAo2TKkPg08khRNDkw7AA3cGi/TJsIC +hTRDHdifpzSOgnEPIH/XGpRjgQb4VTXvzlnSRju0aK+LcGJAycfw05AZtVG9PvCw +o7hzcRAGHYZMRZVugUHhNOJWkwBFKukPlka4JskVYQhfzhFbdFVdtG8sxyU7kCxJ +6+OcmoGXiLuOEDjt6znuNNOgJ1dq4VZM1Y246hOgDG6s3sMK0AqtO5hB0iARw6yM +bTE0ndK9hleAh54QiRGg9pksVYG88eTvzxpMOHIKFOvb04ZOhrb0HzwmHnOUbDZI +HSnnELwgrO1XMgFuE0qXp6gAkuCdU6gdEUmk6Aex8JLgCQI21gNhmHySFnIhFwUm +z0M3VJwNSdkPUCMwQmLOabCoJbEEpZYDtyczh3xZzcdfStopRhE31+cVG+QMegBo +1TUxjpDSA8w5yoilojZ946+HIilJjmPFD8M3+oMleHIU+CGAKgSvTx8Y0fuOigPi +DCIgi7p+/nIY0WLKLtaeDWDFbLshVOBfyY2BBSJRnz194qZMhjTq7iTrAgBLuOyz ++5jluDrPImwdWGu0xyfjBggIgONE97cGqfeeWFRCTd6Mbzs/uGOT2UyA6b6xx5Ao +kVu1UAEFHxWTMiRSkPKHHGTNrVVHnJKD5NnOjuGAbCp51f8AGGlmHN3L5mn5xlaU +RT2qWbmujPLpJ0LFp8p3lzaQCanIC2FO72qu1/h0VYVG8BnwCyRv5KAgircOqNvB +c1P9iUJAb4zX/cIkdgaKpca34rGCURz0BKbvBNBPFoAdkenJ1nVoh34OJiRFTTLy +7wY0yW0D8l9GHhbdtUD70yMgchw/0GUghA495oBzfU44zuOB9XE8y5GyqORS35uI +RI3rey/8YcXzUgT+f65o+XSEQR/9yiYiK4PShzfGagbylBJ84wmkMIeUdvO66wCY +m4CnDqcfMyCyPahDVDtYTiucfdIzsdlCp5s3cXuzil5AHjk41rBCBK58ldu98d8m +Dz0SrR0Dip/eI1GQnTXzvoxLe8pU5X83wObU2xCVyrwX+cBpLyALIuQnHhyQiJMA +EE7N55G5Amgw4oTYJ+8VxU0CrPLQMmsdN0lkLTyXSnxm+S1NCah09fWHFLt7rJ5J ++HAAcLYPxzw5eVmQmn48d+8RsOcEvDPJ+N4JIYECA6nvDBpun9g/hniXZeGur3g0 +W+Q4cugA6Cpd/wA43qYVRCH4XNfHcUksEnafWMBGwUTp+c0znwC5vzUHsHC4JH3F ++fFOZiME1zW7yfhxc5td06edzzm/IIqqOF6PEy7HDSyBDfdwF8kDS2SH/mW4oht1 +fHtrGLhBoe7ZDcQ3kUj0UUSuvjo153gJvTjVBaNoHfG8nBDoELtDnWvxh13sztjo +OQ8XNYLJJRNs0ef9YAc5ldNnUpd4S1NICKpjia1uacOWe02Dszo/jNsEPXXQDwzn +fLggrawBOGd1fxlyxWsxwS+e85SBsoTl7LlhjYEvfMNgPLiNc2AAkHxvJ0AC0p4P +FtplzEirSo4ZTPG8WASOM35I/wB5EVbwN0zYV28TY4JwAbL3kiQvhj8/HrAFPLYU +fFX4YKuZ3y6HXHPjGqtVBPU7NVHluNHmEu6X6v8AzhAHNWi872Q3JnIwKsYae3jE ++HscCjW7AOjFgAmAYm88dYQVmvpty0frtx47FrPIKbj/ANyNiVu499FTlrpymnWg +iHXI/nOUDUu329G7+N5CHhQhZzJ5cVSAsVHDWi9p43gRncldpOmwTFLlokJfZrfv +WJMPH+qwa267wkRjZecDzenT6xHoQApwAOGYHLqOmnwa+zISIdEKpXvW+8PgWHMB +u/fPrGOhgCBYsvT/ACYZpWhDcJ1OfZlqCUhbAicLrxkNIn1i/ng3vfvIRABur5VG +vn4y5zFNPTiQHpppHXeTNui6XvAVhQ00m/8AWIsnEcWC9AFenJdsMu2BejZ9Z1bS +NIPsO3rIgi+NAXl5n1rCJ1w0L2PwaMM09CGmHD83fnAr4Qx5ajYhdPWAfA4yjl9Y +eg12WAx7Aa4u0pAHUNkbLd8mRUWBNSSkTr2UyoEaNtAvWUOrvvE4AcGrtfS8fOAg +pBMVoArUW4SChZ6ceRNaOOMEvfmHUx0kr884bDoFsFUu9/04LCx0RoWdLH7xg8AL +vIP5nccPg1B2t0ByPzOcEEug0Ao1Yf7yVTD6Hkf5xTy3blOTw8+HD+5RNE4QO14O +sfyuGhgp4pz1znSrBa3hvWsV68hr7XjacYFJBGbFuvbgopTgNrioITZPT1iYBpwN +rgoLuKVEwoZDSerz/rC33owJ6fKx+Llxol3ULLaDvEaQ5Cpm07b4zfFQAb2mjiaP +OUlgUiFmg/jNqDwatrxtt1j9OXpLVQ71TBsCEI3W5p9csxLXZA6WzS1/zi1uo1x3 +rjmTz85yQKwB069P1+cC2jsAAXOvOVFksgbY7vl6wxZMCXKKgEp/Ey+u0ipY2HTe +TxirUKYo0FJx5wb2CLjrXQP06zU9sQ+Qel8bxTcBXqFSPQM2MvDh8ShVUPKbK+W7 +ig4hddrH7+sqYQ6EvA8knxg5DYLuDIXenOABZK9tuL7v4y/xoiQusZ4pb7QH21iR +J2HCgGLRWapy5LII/JwS6LXJz3hKgY07h/eQKHeda5x7EBBh5naNJihjVbGwoj5E +PvHL8BLyuTneWZPboCC3tLlISNNb0N8c3I9GkBDu+NzKBC61CxCeO4+sSxKKB3CH +Ad/eJ/DQjSLNG3gwUhOOABoNc1+cjDzaSs3mNualN7aAW66OH2oLdBIONzY/OAHC +YAgEHEFP940GGusCykNyuXeA6RHaIa4oPXkxvEYdGWXvgnjJyUGGz3tAOcLKegSV +1/Q5Zzl+oRyVJWHmT8YNofEoPn8X4xgCSiFDDjzvRk7pRGNIUffBikvAW7I9jZrx +kRNWKwF6qhcDmDkIEKtuKlKqXfP+sU0IG96c4NiOr/PziINeC3X0uFYqb8j59ZtA +qdN0PHzkZMKbmj/1kNguiEfp/nHVlglebe2O31iBaF5qSXpfWFT60N4B9u45SkSM +G+AnHh7x8jRjA077nHzheYMc6bH2cT3iJJOlEXK+O594q19nEnE3yevbhvVdo1p5 +D/TDjikAdZ4SbnjAWTdIoKF06a4O2s2XnJV0rhDhwkIQom1SF/ziRI7PrwEzyB4X +FgNOagRQyPtlDXNyCmIDXW9E8Y32n1ZANmPmkxFVQ+Aa/f8AxiEB7FDfxPjJzLkl +fE+/OD73UVhu3bbrGUiiwK8wf6yf55bR3+gyGsDwtbjBoJsptjHZRTXuecGgp4He +MBZGALr5xGDtP284CMFGllMR74ks59ecZBEcJDGhXChvZeAF+MVQJORUCa6O8kQ6 +Az6E5PnDTiHY0746vjEmHgKJJtTy85SBAQOyNm+hx2cNzeSDt89ZpLtdQbwTX1l6 +C2h2bE7xjWkA8QvLaSbM/gA/JDAfQ+zCzw6EVQbq3hKOoawla9aQLx1+ztmGlS1y +BSWAOziOTnQG8gTlXR8ZYjoK2HzHOu3xhmEHik2bY/wy7giAUXl4OB+sg22gUvl1 +ydfvAUXgyvMNrt04ImxpArtfgMa3FbMU2e8XRottbX8H5wl7qXS/R7yCKpoBp+cR +btOA4YkUQNnXowpVHIO8kp3srT01gDbpF4SYEkFVKJJm0KMFvm85qdOC7NhObMBJ +VYRA/wBL8ZZhBHVTS/394HnE4EqHzrvWVz3JChm+KzFLRzClRA8SXFd2UkCnyqsO +zxjIo52DnlELR+Oc2CayQkKDhrxxAeXEYADgkrOdDT94ZkzeyAWci7guhja+IwiH +DdR4r5xc5COpB50muzXOMiEQgGuehVijmkkguZCnLAc3eDkMKMldFaFcD7YpoWAY +A7WjY635G5UZAEjhB1OHxzjNaEIS66/H85LpQcQBNP8AXGBtioKPZ35yBYQ0qVzD +t+s0+F5ALT8YVAY/DlsmnLXGMAEnO+v84eQZQhccpIqngLlh4Fr8+L/XvNRKq1sI ++fGWYeMNvX0OVhSFZdz+MbagKPDArJaa5dOW31hEY2gWUK5skQkGO0+9fGbjwAAE +nB7feV0AhgeW+S8ZpHjZDYFQOW+7zMLOku5MN3Hr2c4MYWcMXRidoaFHotm6IRtL +iqLxzMXSyELlHwwQ8bhinAtJiRx9Xc+80gZzgyLusRxJ1kzdLW2VGmSk2uLFU1dj +XXICN59YvjLriFF0bK38HE8J2CQ3G0I06fJjWnejEBOYD5LK2TlJWryIfzih9txE +jw+txy4jSDR2Xg6jziI1VdKofgwRXJAnJXAEq8JfWIY8XTdw84rkSd8nDHSCCB4c +D521usDxGxK/75wDkBCq5+sopWjBn/fGFlQcHfi+MunOu3KSG8QIDIsohypoG5Mi +LYA81PE1rEFBUiGBeiJhlNPlbFPTjDoWoiLV8JrBiwGtcRumFZs7fGGdF+h8k3dm +kHgdYlIrRDcUsQ2cgcmbAKFATw1vXVwmThq2hHPlNe3Dvdg6uxLo7DJ8x6MlUClO +F26RzeGwOgVtp4K3rW0ZUeATo6KdbqXe8Maw27QMu2AaLM1SsdSjtdKK6owCi2dL +UeNCDsMN7vuBaQV75wswUDksJ3/OHGSZmoCHr1gLZXZA3/SZUSJyxUPXjDGN6U+O +HE1ZWo5ohNtTesNWpqQ3ifNx+x5wt7BUqi+sFqqUBsnnFIUC66/F/wC1msg00Bzf +86y4h6Tg1xgVJOooHn5wIqbwQI+NEMJZi+Q7s9ku9YNUJKwhLO7vnFWKskHok/Lr +ziOVDgCCaoA6b8uecvUVSULzauWveBiaFlqFfSV8OL/XGdTv5dOUgJJ5unvhm3yY +LpSOmxLfB/OUCgDKedeIz8YpCPo3SMHvbhzM6hk8mvbMOnCYXdg9nOJe3BQqesJR +uAZ6d0MkakQ+BrAPbBORNr0969axnW5ebnT64yaCcv4Dllc5aNMOM4NCopxcTCVW +3tfZ8YgkJUI6w1pkX5ZzE4xyHvC6HoT19PnFdNKscnGsaAU56SYGAmq6Kd5DfTrX +6/7jDYg0fAx7yCIA18ZysXQUIX94ZbKa6D3Xc0kx2gJFYg7AEI84jinblHXZxUO/ +nD48AE+3y1dd5QUPo6GjUcO5eMe2jURYvRtH7wEgKgjBdNcbXrFEp0zAtHLognPe +AQRoD/laLt3xilBCFQFKRj6cBMWsKIsmyml6yj5E2yKGvQ3jCcTNxpyHQKqrmjN1 +kVNo1vlqfOXJk/RqAAuiGUIWAiX8vfjGAbhI5Pcs/NzgnyU7mPVP1wDNPR0cQMk3 +peW+cEEnjZie8IHaC8P9ZC0Ltpp5y1r2ai8fOHStXRs3zkhHQFHf3g2HYba/3lNk +Hqv05uUmgRfwPjAkWC88OPF1XSY+blaq/wCtpPGrc2H554InHvn1MpJRNSDp1sTv +yOU6GmiuSfn4maBKtcQs+F2JiHJcVRODjTo83F14+qjV5cH4xg25b5TojjZzthOw +5MAwksSNnoE1Cqnb84lOZEjgJ2p/6ZS2ApUE7aFfk6wtXVaqTaKOu+sQhDDYXyTt +d4KbxiQaODe3AQ2sgIUISNoHnLRlLILE63qeDFBYHOS3k9uzNaiegBEwaUTUrIKH +VUkJ4Sc63gaK86fmZaD9XLzvEkQwVervGc1Dc1q/zjkjZXeM0itujQGS64lF4wyK +R4Df1dmNjT8BaExaIBG0vvFAQx2k6mX1+80Pc6c/GIHt84bJdDutDkcJDLpPqL3O +LzMZFEAVVMC8xpkYT7xLgvFK51zh40xBzwg5dcMjMLNOU0O/6wcbUfc5TwPBzjIB +l06xvC2/GMrRuD0AQNvLl2CkqtJFBO/PGG8rZwKIXekHB87ww2a4shDgGQmrrxgT +0sQyN6psh9NwO9wK6ajt3ZMJdSbC6Eck4TGK5sAgmnxeUnHvGBNtU1dofphwABR7 +gcrt6xG7bahCIHIkHRClJHWpUW6GgUS0cGdOdUy257EE8Kvn4xq2QCKcnrLIXgXR +MQG/C2vjJZx0UG/v/rjd2WgOt/xgh16TmGUpl2vBZ/xiuBCHyv8AZhoL2Np7yOEF +X4iJOyOFA2BSbaRffrrEVEBxD2YCroER2vvrAgYOwuAc+S74xUSw6h0vTy38YLle +HawQ3a3f1nBF4m0Rqb4XEEONaSlyAujn3hM2InqER2CvMDH0DorVylk0eFcVa501 +zE02V5VZhTDvWzai1gJS4p6xfBjPJGd/GU5Ky5wXauDvF0PYodjFpww3IY8eiDUE +3Kdp45wFtooE4XwP7zR+dhMh3oeAv3kwk3rVol3SdCBhqECXDCB9fGV+IkprTycO +HlHHeFoFcmYTOxZTziNMiefBzc03VvQV8fWKTC4sA3k9s7AUOzHNNVfj58ZQpbej +uGBcCgNbW9dGDLzdtw+D7GZpTSoCUEvDJG5rJLw0eTxfGFgUhNgNn5YKkRZRg8ex +P3gJyKxEJyu7rjhMaPWaA7gGtcR1gUc77c6UWq9Y6eRwsfHYUrxozdSnBlqN0AOw +LDWEuQYAAhDY8uYw0YqE2z7pI3wseN3BYh7jUJ1j5TblHEtSnT3uBPneaIRWOIay +g44FrZMnAANS1U2jvzesfNrIvFE/k7wG2gN2TSeF/jFV4geBJzIbs7MGXQqQNV84 +f0EZLXQsTXbNoFX2xmBSg7AHjnPh/wAjKTmCD04gtBeXT95bS9LNYls0OKIHzgZM +RZw+gP6yuMIcX8/vWaggNh7MNHQXj8YKTqM2/wBMiCYOxdDz1iwztYgVqDKXx3g3 +iMLoI5hY0UDk0UwPLA7BPGJip0QE5jIpHgz9vJ2YNNk5+D4yZVMQbaO1fXrOItEB +pfBadY8FHuxZuOQDlwU4J3uDWGVgJViYceDHCnAVCRrWtYIag5CiRgQjUGTvdkV7 +8taV0Dctgctup5BjDEseDA0hG6Q9CR8b6yZB13lwDo6uSrQBe4yNQ2EJTb7eT7zT +qUAEr7OWBbwujXY27MHYH8z1uzUvkdWTHKICagEE7oUAs6+acf5CU9emNG5KWi4S +5jNcT5xIb3A8T1lpG+E/vJekdkTAKnYbdPjIaKgKtfP5xofJFjHaYICJ9o0urt4M +50NPzbt+LEVxAQEC8Jq9zEpnZHC62QcPePtEe6ppmuO8Mo3ahXf28Y2qAk+I9jJP +WW25ADY3A7MNhZDgC3p0fOQ5qxR/P+MoUVBssxSfvDExxhMJH4F7zmocFwimg78W +Y9PU9SBfDBTK9EswTXoO8qhxQAi3lb8c/WbFOOdtVaE7PzmzV0K1b110Hxg6/voJ +DyeZzkSJQHn2mIpBRocx2c6us2CGRDAYxKga0VNOU7bQnzjCFJkxCdpDyaWXpEFq +CVKA/wDwid+sEywO197OM1SWTRd51Fqckhrke80lWgOZx1gNkp0d8F9Z04hhCo+Y +Yi8YqxvwuLNG3IiUdqc34zlTyqYHyn1wRNjGpJ+n9dfGM+izYHmoYccYvdgpC8OU +3wpNklPvOcVypycfHOKSIaNOdSmusSRCzEFunjJ0aiEeCnGIwCDsgum/xkwgo5HT +Ot+c5zNhLoBPcwLnuMgIq8auEL0kQA9B139Y6w7TT21fAPvN+gj1clKn1hkEHP5w +/g+c4SAmgbZDy7weXFGtrt+MNolgginP8Yl5O3N36MiokaEJdNmFxQmKUcmVtBTE +IQB00UCwxGjCQNfQeHpyks4tH74wwaIaKefnP//EABQRAQAAAAAAAAAAAAAAAAAA +AJD/2gAIAQIBAT8AAD//xAAUEQEAAAAAAAAAAAAAAAAAAACQ/9oACAEDAQE/AAA/ +/9mJAj0EEwEKACcFAlVRKTACGwMFCRLP94AFCwkIBwMFFQoJCAsFFgIDAQACHgEC +F4AACgkQsmmV4xAlBWgO6g//chRdEzxcuPP3H8TNQezl0msFbv3L+GBhr0C1avan +HthtLltznI5v8uPbM0AlsdR2wFSnS+dm6ZwPwuSUBmb/hoUpgMQ3mECpFJ3iVBuZ +LebtWanUPLdWiycFa4uwku+xteSDGeEOpmk43JlzfBwuJXNaDNVN+m6zL7/GaRiJ +jwjGfeG2hNJnS+72kpbqkZDkLfK8/IbtibGXpe6Lu8h97ISdE+sifD6M3r7CJS7y +Ebv9QPI+x3WG9UQOqnvLw/wbZp8OS37Akky5hDJVR00YLc57lWMXtlH2LYmnzK1k +MYR3v/ehKc0b/5LFOLiuQeuh/90jd2zib8hM3uLyJheTobRm3pSUK/N7wjse8AgN +xaMzqLDRd2rGRhDr0qtlGOxNvl9BJ40Bvp6gjMRPg95ubHbYhibT+N/573WAt+fe +IbQCke6vqE5WrJ92qfkLxndRNa1/82DKAWNN/+Eo8twG0DaKh849U8d3HhmSenFI +V9oGBw0AcjmxfWnudgfJsYDK5ofk3oLQgKuEP8A+FCZTk2Lbehre9G99Bn3WY88M +sBu8Z/xrfwaKZh3YP/AewdS0Vtxo0ybFpxlhvI8u3DRyIVqUruX+2ZXqHdXq8qUc +ctuibbR4hJGAZu7js/cQMLJUl7qyGQTe4tv/jMQn4RbzT7DZhFhgSKfpj7Vr1o1Q +YXqJAiIEEwEKAAwFAlVSdH8FgweGH4AACgkQ/J+14SFO6SuqEQ/8Cq25dFudbw2r +ghQr30qps83ETSxYuwPG/XUNDpwkIKIfVcNGiqP0+H0O3T8Ka3Yg7mE6HlGwyE5z +SkX/9DzTO+TRFy96L1sKJ9DzydzXWsyYZxPYaCl/VUCOoDMzJOwpKSYrpwtoLtvv +X9wzjtp/xHiip2elmsUvBodLiDtGmISjxVqJZWj94vdiZPu2ne9X+Xm+F7A78+1e +QisWgjyTd+4+8Um2yBG8bdNxoYmr1XjLigayCSinQqvfHcPg98KlFmi9oA/pCC6E +cTZE+2gFmtfu3MVCshfTQdJTWljdVXqnPkLK9//HlSPSQvqTyfcSYMu9Bxt3psGI +ZJCn9S8OHuXJ6Y3X60zWG0dHdJHZo0M954NJOyJF73lXQfNgq+rgCtJVKhb+jqmI +oj9fwZWul76rT8PrKIxMaTKf0sBJjEHSVnW6mSsK8qRX9JFLVGzXFxzTAptmcTDt +hK51aQlXVQcjs2pRB6VLe98husoIrYYql/4Heldow0r7NKMDht5nycj3UugTJPV1 +jmdSDyV2ThEPu5f392V/7L3m2aPiodbm5b343BGvSzJq+gjGiXO966d7qFuspgdG +Zx+JJMlgvCfrkHjBU5zSg/WPp7Pk7zur5KcOHDiba/FfYQ6So66WYsIrJC/n3xYF +tZiXRi4KWHM7CpNYb/3mR52wAQUS04K0IcWBdWthc3ogTGFuZ2EgPGx1a2FzekBw +eXRob24ub3JnPokCVAQTAQgAPhYhBOP/KDnASLJcCE3r6bJpleMQJQVoBQJabPwz +AhsDBQkSz/eABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJELJpleMQJQVoyYMP +/3CqL9kp94JD0fQuutr10giYJ81W734E3E8lF5RYmU3Aw4LL2Ep//wsYI88UoknL +QEID54GMSiv9/xH0/PqAjMCNI+VeEpbBLyq0y7vvjSZQxrih+Ci+TyyKQNu6fSoZ +uBEiX75M55MK32kmdBqTfEiwSDSwOzbWC1svgpl2kMfLd4Zk8Jb7/6bjOgCR/YHe +hZft0eBO8Jsq7UuHdbaHY3y4y3knotc+7/rmMj5cag3uYlKOLTkYY9FeuNqjG0S/ +rHdGnXFXlSY7vJZeElvPN0MpxnPzZiur5ilV+Xd6s2k1vsJVjSD3xyCJENr0Awq8 +0UpBIziIRR4NY00r6qNhQWByms7NsLcXcaGaKCJjONMfYWkiNVb9NPg/N3w2+Gjh +iB0PpRhmCyxrZZQmkdQWnEbLC/mMbEdnR9s0zDbdPd2hu46mb3QB5PxV1InJNa05 +9Qpf0c6NxRKn6Qpo0OH9eO428pQcpa6H3I96qVFFdOn6/I0teJ9aRbVqPUdQ8CYj +obt1bty04CBMvZhuEEjJCIEW8bHjJ1S5FFmMJHybnXzlc4dEkcT1L+4IomqgGoj8 +yKKRTyGF4nOh2CPGVrDaYVJpMzIlrQElt5BPA1gUwLsu1MJPLwj2jk8YBvlB8qo7 +qH/mMGtl2fgXmxLav7Sq+Bod0P+45KH8FvrvWgFZBcMiuQINBFVRJ0kBEAC34s5+ +eyBL9RQEeXE8hNBcjf0DnxgQey3MSMr3SSVa0u+ss8GuqSVYGpZwXxB0F6JKyL+o +L9hunkacnwP9BSMJZa/+AjIHosntbGP7S/XwU1htVdNWbxwj1mobvpUMJjj3Fu+W +vl9uqJmvV+vID9d0Dlyj0vRq8XOuoX92XucthYB9Gg2AXSK3m3pExZxDxJq3tVXR +L0O0Fb49cghye+5IzBYA1I8jNYrJ1PdlOrQy82zzbIyTiQRze5hAtykXszDtlPty +4Hm6P1Js4MB5LZ2Zy9aGRtqgT74KW0Sx0SepYzzesPoAFv50ibh3ZlqT78gpAH0w +4+B3eHf6DkVIlLzuStkKrc2k7g0J7ePHnnJh4mS1GMH6D7Kq+gfcSzhJR9itbg9q +Nagbd6wLpvn4OMZpwu6mMRtz29KvQ/z6c6aMAAPO5Fsy9B7qFSp4Sx+Uh44nidSy +BHsevSHiqCxe4BJGfE2JiHpwQDA3VhhfI7ixIRNPtxvCnLipXHlJWs3O3jAhO8fW +fPcLR36ZHbDvgX9CChk32q47FZwrHR7TKHwWrWlCfkue2+4h2r0rVEY1IpXPVKDO +6Is02K6oo7K6Syskyl72q/rk2IJSQZwb34s8jTRuqz+caIvrIXyFEUb+rdOjijW/ +0BKGa7VzWEGC7NI5is0fSqA7yOaANIk0GubdHwARAQABiQIlBBgBCgAPBQJVUSdJ +AhsMBQkSz/eAAAoJELJpleMQJQVoOhkP/1iRCBaWSf8yNDZpP3gMgTF8YwAXfq1d +r/eDdQAESjffggxnbFJg/TzLlG4bC+9jX80+B/zYqzORj5nWtvCg6lzityXatdiD +jmc+ebIzd0cLZhm58H9LEUVkoSQttltGOEGxQ9NI+5rF531eXy1edb5a/6kAPkNm +64wy9OoQ2G3L8C7XqRUDHIj446qKMq18ouk56u3RVOn3MH9VeAFkLdwOzqpJpnKY +0dG9GBzNZhADtTgdm+f0vaAWOY+cVosJqnEwfpQe1NLbt4Qe5YloEvtc6GoQpzo/ +fnFEo9gfqkmlFsRtyvXW+E4gBPauoFKP5q9D3xLdTxJP2GRR3lHRVqjjfB//p11n +K+oWY/YFeHJ6O61mFHeRtcVjxaiqyy0WPGSCjzjQbuC2rlmADXXVsSr7hoQDZHTE +51N+Ok9Rn0q452oJmUsEBwr4uKQsmTzvYZRZALFT9BkZEZgdrEngbP/cDYM3mXbN +fBxsRs/YMZp2IOBiVV+Odkt1I4tIKjK5Ycv6z9X/i5jgdRVWQEtkSx3paHzW+BRN +0V+fCycIxEJP1pajaM6+D8oa0fqFYgcAmXeZ6fBg531VOuNwWdavel8vSqx/jik4 +b8SS4ygK+MNMFFGTIDPPEuVv07KBSq1FCrbDKyy/xKZIwaUut9577vLPUX03qZWy +7KXbUrFBXw8bmI0EQ8n6HgEEAKyi0t8ZOC6bkBrFdQii9DAbswT20XQz96kvXjXL +8pjBYN+RvfiKaxmLnPlHtP30BqWoG1XwY+TQSbtwhwdAOhQMn5FkSiHroBDBO2fO +EhKD17IeyYmL6r1zK1Bm2xhwe394mFEtvBLAdpgM/sIK5fXxtErnsyOSuj5tisWU +OS9VABEBAAG0L1RvdGFsbHkgTGVnaXQgU2lnbmluZyBLZXkgPG1hbGxvcnlAZXhh +bXBsZS5vcmc+iNAEEwEIADoWIQS6dJrHMb5aKKZURsAgVv8uSHA05QUCQ8n6HgIb +AQYLCQgHAwIHFQoJCAsDAgQWAgMBAh4BAheAAAoJECBW/y5IcDTlk+4EAI6wYju1 +SK1qoOBtgnew1Zz6GeG5uQUuJOIsiMhrIEHSpE/cZ2/use+NC3EWFglrlTgb7aNE +waMYssVTYhwI27xPzYPTt+sK8voIhRG8Kyg6u53+ySlh/yR/y5KD7Ry5U0Rn58uQ +ziAzRmaOVUczi43RmAH18E/45Jl6W3J/SVtWmI0ESkNkqgEEANMADQ52/6FEHFTc +c03zcD7C3aCxx6qPKnziwDz4g2TwcKNVczSgz6yYSTJM7auBf93tqXp2jkGjrM/0 +RbxTJdQNMz5aprMkBIN48kpGfqf/dNkYpZx4ZPrh586VmRviR7u5KAUAsaUz+B93 +M2ybgx0m0VCY+xAScZJgbRJJUnqFABEBAAG0L1RvdGFsbHkgTGVnaXQgU2lnbmlu +ZyBLZXkgPG1hbGxvcnlAZXhhbXBsZS5vcmc+iNAEEwEIADoWIQR/VPlaxh7hRlz+ +eh/C6Nc59zxwDQUCSkNkqgIbAQYLCQgHAwIHFQoJCAsDAgQWAgMBAh4BAheAAAoJ +EMLo1zn3PHANrjIEANH7R6ScI3GZlgpzySVCmRSEmY8yy8/awdfTlX5gYBdVMmqk +gIrVXm7cOdULittPz/To3NnY9XMzMdD+r8hb5Np5PahkYHGTSsVLPmREQYBFIR4K +kM/qGzgf3j4xVKjEtwKvbV6MkgFq4XqTFDGuninqo0SATrVDoZNilnkrGgXAmI0E +Wig+ywEEAMERJab5jswaHo9imzDBiailzjmAqa/Rd3PnXXZdo131i++7qfAAMqft +G9w1uQANQkGipN2N/roRm8jfAxH87NiN3Tz95L5vi3/MFz/MPDbLyRImWBhc07Lq +LtJLNgBQPdmuI3z1DE+Gg+xpeSJw7uk0z+3Dkdi8q+en18P1TL27ABEBAAG0L1Rv +dGFsbHkgTGVnaXQgU2lnbmluZyBLZXkgPG1hbGxvcnlAZXhhbXBsZS5vcmc+iNAE +EwEIADoWIQT9AbpUrl2bnEaOZeP6v057b14VQAUCWig+ywIbAQYLCQgHAwIHFQoJ +CAsDAgQWAgMBAh4BAheAAAoJEPq/TntvXhVAYFUEAK13rbQmVGSt9bFVtvu5Dfg6 +MSDqCSv7wLe5g4DUJmCoPwuZHCUrG/hjqcpd9c2OyNHucn7lr0w6FWBtc1ruDROy +aLhJIoVEOzZZTGIyxU1NfHPEmLt5RZYFnlQSYgl5JbS1pK8y0RIjATBdN7NFxO+i +hqcsqLC8E0hysTNWMbQimI0ER6iWmwEEAMNemk/mOhv9Xd0v4cP5yBnYpeuDS3C4 +1em1X9fhvO+NcqDbjFXoOKBK5B2YWKb5QLkPOEouchNbUxEjLvv29z3S2bWhRno/ ++renVMf7ovXPSUWPFYK5SD8Hak56Ujo52qoz/NLDN97hvdiQnb9GM4KoGRQ4/0Qi +ZyrViMccv3IVABEBAAG0L1RvdGFsbHkgTGVnaXQgU2lnbmluZyBLZXkgPG1hbGxv +cnlAZXhhbXBsZS5vcmc+iNAEEwEIADoWIQRBojlHar1suo/I/KkOk6pzqmVCHQUC +R6iWmwIbAQYLCQgHAwIHFQoJCAsDAgQWAgMBAh4BAheAAAoJEA6TqnOqZUIdZLAD +/Aj99i+9T1M7du2fyWVSpyyqNbQabeNdFkwgqJbuO/GtNgzx9tFoKcIJyMd1QgF+ +cetbxN9kMc/2mRRYHb2/+HDivFRV+ItkMI71guSiVy532hZMqG6e9y7dT78GugcO +7UL3FF6NkUAnt/ai+8wma3qldWXscmSSIMDr6U0WJ4iGmI0EUOqItQEEAMhVJtd4 +ahM1bq6ccx1uhaeFQPr5g2/0twPOFO8v2HPkYQXQmI02X8g+AGpChXIfSUQYBGLk +wzfkS/3h4vFdUfFlxK4KVrwgh504vxczjq3D6yST5ChRpdxZdTPSgiCF+plV5/c8 +nT9AJE9WEH8R7bJ+YgQ8rcsAKHRZGS5QtBKjABEBAAG0L1RvdGFsbHkgTGVnaXQg +U2lnbmluZyBLZXkgPG1hbGxvcnlAZXhhbXBsZS5vcmc+iNAEEwEIADoWIQSetJ3B +ZvZADvXaU/V5tFfk5t8CXAUCUOqItQIbAQYLCQgHAwIHFQoJCAsDAgQWAgMBAh4B +AheAAAoJEHm0V+Tm3wJcWjkEAI/0giyWy85DrMnJM7Q4hDyCjLEv+pN4VKAAcYBU +ABDaJ4jvMAXkjjPR4kp4wd+mdE6OaVXGI4Vm6CWv/nfLX79OLvem7IzA5/3zRQKW +Bu5/deuQbMCTNqRxxcUb6mN0JAr29/n++TNnEnCEMOpI9c4eVGysr3BU9AYbMgxf +5wpNmI0EVV7zcgEEAJ084/KZCnF3LNjAnag4CrJe2N/4HY10K2+wrzJPkpP6nJ/C +/cSF4214tWLeP3JUuhK8cfQDYd4gHUXjxSh8X6W0alNUPytKGyyutfu/AXsC3OOr +yCB/++BJCEO/Bt1WuFHy+YIMRazCvo4hDyoXf4giPf5GshXoYqULsK/59fC/ABEB +AAG0L1RvdGFsbHkgTGVnaXQgU2lnbmluZyBLZXkgPG1hbGxvcnlAZXhhbXBsZS5v +cmc+iNAEEwEIADoWIQSAG9Wuk9OS4i3cbHr+o9xt6lu9cQUCVV7zcgIbAQYLCQgH +AwIHFQoJCAsDAgQWAgMBAh4BAheAAAoJEP6j3G3qW71x37cD/AxkV2KkKC7Ag0TP +28itBr+HYyIKPFyt34AkK/NscyUNK+uhsxNre6noV/rl61gKBgqcp4uOaPiOEF21 +Zh79x/k5MxR/XRN4S7Q8k4CxPQ1eafPvgB/+KL4qPO8I3cCFvq/6p3AFcxoGk6G5 +SQv0GYPRmWUShE0y+N6P11BdfGFpmI4EU554zgEEAObabQh5zAM31ZNAi7pek41m +lrnAJiJVGfnEA4ItQmOevBIs55CFifhgGMobM3I9M3ty7TVw10AUdw5pxGGXkkic +Wj3ziaOD1igaDBDvhTxzGTb+zTXmEKddcfwGl7ZVcmB72avmq2UgvPMQyAHQkw+j +Bq0jwLhZhuXpt5B/gOAPACCxO4MBiQE3BCABAgChBQJXsqAKmh0CVGhpcyBrZXkg +d2FzIGdlbmVyYXRlZCBhcyBwYXJ0IG9mIHRoZSBFdmlsMzIgcHJvamVjdC4KSXQg +aXMgbm90IG93bmVkIGJ5IHRoZSB1c2VyIGRlc2NyaWJlZCBpbiB0aGUgVUlELgpT +ZWUgaHR0cHM6Ly9ldmlsMzIuY29tL3Jldm9rZWQgZm9yIG1vcmUgZGV0YWlscy4A +CgkQGScg9+pbvXH+EAP+JoMEpYItU+4M1+CCluv79GO2Vv+v26VGMfCw+kjhpHOd +ssa2yxDdYR5Ihadl1tKZgeHBO4cRPfbYxJm6c9fVxvYP2lO6UDMf/NEa2Lxxte77 +fL93MPnQxQBYy8Sjh8gpO3rAVvagez1iptOT3k+o4i80hTCATItZ6v1gs5N+QjG0 +IUJhcnJ5IEEuIFdhcnNhdyA8YmFycnlAd2Fyc2F3LnVzPoicBBABAgAGBQJT4HiR +AAoJEEpFBn+LvXfwXwQEAI53rYeJhS7bedw6vWEU1gL+EdtDuFxNdO24qPTQ7Q37 +iD69hILPoRUAvldrmD6rOhgctbxK7qFPxWuhhht2yXAb2kH0lJ8cA0yWSfm7rlGN +3+sZZBUUEAufHKBly/5sYGd0hSHlRLaDZ5PE8XApCMq58liwvFrYqrIxXs3Z9PQW +iJwEEAECAAYFAlPgeJEACgkQTi/IT0VD1XdfBAP8DcnKbEq9KJAbjMC+bpHSGn1K +A/dKehkIFxrKjZtX5p2OHMoftL/5unbgZjjbNNELx5K5kbJ+nUZDi7NjeTLr0KlP +GNAAlJTI5ByNM/bVO85rMCXr3vdHkALjdZDmvKgZv9RyZXDAimRek4+0MQ1Ni90h +hdRxuWw5oGv3HpRuWnmInAQQAQIABgUCU+B4kQAKCRCC04i4Z5GxT18EA/0URUqv +kwtkLNhjetBD/COYPssntHAtdJLkoeWY8bvz6uT6nHh9Fm5Q5QTaoqpsOg7qrIZT +exUImsShJxAO3D1jUQM+uqv71PR2KvaFf939HLlG8cPWnNFYAp42FRLEDU0QO04m +D4DJsOTH5SEETYP9rU1pnp0ovWhnQzXyQ23vv4icBBABAgAGBQJT4HiRAAoJEJb9 +czBHQhGNXwQEAKPDJx4sJOfBfIB1yUsUiqDh4wd0cBnA7BTVFEz4YKov60TCPMXF +QRzS/tCDosNB6KR18zq6EvVldNmPoLnpdEK4t8/LDNWn1rqUDX6IvV4aHtKhT+1d +RYxwt2csFNfy9YHr0K/1Zl/Gi6ZiCi9vcWguDIm/3O5ltxlGymvzMkTbiJwEEAEC +AAYFAlPgeJEACgkQr1GSnFHzJJZfBAP+Jg7/t5+hMdoeF3I4pkRlmh9shr0ft7Ho +cW6Ctt7GXPIscoGx6lArgvnGm+mvIv095PhV4dThB6onwfQmkT2hHkg+gDVDrJw8 +iY1taTXTTK7llmYBoBbk11h4U14+nj6XygYzRK0hqh+UkqrPB51CZER7tRIitIte +bZGDxmvpp1qInAQQAQIABgUCU+B4kQAKCRCxihPbZmQ6DF8EA/9mdV/w+KxmxuRd +xUvYB4udiyou8GB0URBQMS2XVnCCfnV2bH3h/O8lAJQl5+RBAZ9fxitXtDgrtPTs +ol52638xEH0Sk3ACg+GbKCh3Wki9HompA0cyYEaBNx3VqwuV7O88fk7k/UT9mW5b +6JuOl6LvgFurjs/nXn7/QnhDBGjy94icBBABAgAGBQJT4HiRAAoJEPN5BDzm8zLH +XwQD/RF9wNoNkmMJ7ZIZNfbUKJcK0pKx4HV1BxYTstD6utXhnXKxED5xoefbErKo +6hibg/pq6SSNhp6bQ19WN3KugMiEThQjzjPFtiaA2rEK8pEBt/WVLFtsDVaIqwvH +eEQIJ2MzjdYnofc5GzsPTuVz3ceetQjQnDegwWcHBU6A/rbhiJwEEAECAAYFAlPg +eJIACgkQAwKxHqZa12j0lgP/W0joYSqz9qd6az7xLDQbmnfzUtd/29r5qWefqL02 +mYnyRS82lc58M/bJ4sr2bW6irI8Hjsba6+unDDYbdrX8pLnAz7FG5XcRvqBemYy5 +SEZKUFl0jqsWSchmUwwlaUfE52Le6EDVNbjYaflLb0VPF/tPAc5LJ45rd3WnTgDK +o+aInAQQAQIABgUCU+B4kgAKCRAEXTZcgbtZEPSWBACps8hB+a+6HRAAzr7R1l07 +fZGY7wIEYwCvGXSODtr2ADU2aOExHPj1JQ6j3Ve1mlFSS8CxW9AUFlzsKJujq8VB +kYmPd+NFkDab/Qu3eNWMMxCHAyjdgQVmqxhnEZw2+QO8qmsThbqJwvI0DuPqp8Yp +bbVdDlWPdwklPsQyefsbFYicBBABAgAGBQJT4HiSAAoJEByNfzwjroXS9JYD/3uz +pKpBR3Sw75bZyzQ82l2vRmiOYZMEham1I9xD+RlgV00GH/lef84ZowZlMpVmCsjm +om7OomhYVYtDFxVrQH7DaOh9L64huIs2hr58u+Xm9mbdiDBxhwpHldwRyzp5wZmF +2bozL8zXgOYxoQF3bGY5U8N7zgf3Lh4wWDktEW1WiJwEEAECAAYFAlPgeJIACgkQ +M43t5aQTWzj0lgP9HkmmY1erLy9IzVgR6qzghL+oJn2vuQTCQuw+idhkYdAukIo0 +Lo+SHIrtSIe8mCRSDhScU3uxEDp3EGW05G7qoDD6mgsQ9g+sr6loJPHi4IBwQkcT +nKoPnmz9yNcInm/MSUIMoOeriQAyRq7HR6YRZ4c8z8+geYNXaenZybSC1ziInAQQ +AQIABgUCU+B4kgAKCRA+7jpOhI0AA/SWA/9W3MsoJJoTxLypFeMTYmld0RitiJsx +Rs+Ezg6TbhdmCElEgPsofVYDLgBzxSRSJB0zEKW/WZBwUyKBDeO/UMWlOLdIfl28 +9Bh4YMJvA6haA4nAuvNIeVv+lEjkf2RWIrpH0j1JXuTSFu8tdOvjs3k64MRTiU5H +hI9xqKMCd4a7CYicBBABAgAGBQJT4HiSAAoJEEExedt2fla89JYD/38EOUUjAmXo +nsYXNT3N7a33VQ4HLJMwLKKQVEDtdt9T/IJuBamLYKXUfwxbHo0Q6PZ+qjllWgvh +PuM1fK1y/2/PK6OM7GPOOPPOVrwEG+olo9NwlmWj5ZhoB0kyXcd3eyzNCwv//fRr +E9v14zTuBTeZEmYPNLbVut/AM2bNfAV7iJwEEAECAAYFAlPgeJIACgkQS/+RHaAh +L+T0lgQAjrmnC+AMcroROIQLP9AOgGINS8Qv1H1B84jqvCB1EPN3s39QGVty7Xoa +426JLw2Fc/4KhIl2KiC62JxPkIEZoTgKoPqOw/KlrJi/5ozyzUrTUe0uFO7jVjrC +XaNQ4XhhlSrmXYFVsiueomO2v4s8xkFpKSa5BAAalhiZW8n/qlmInAQQAQIABgUC +U+B4kgAKCRBW/vGCkc+jTfSWA/9WljQQYpZr9TX1PYk6TfvBOPl1cOumVdIogGIT +I1tuRkci3cbOdq33rD36uBER4tu82+afmYA7tWYoKRikkyqH+0rOUJJ9qUSS4zv1 +C8LKBLojrKVaaQWnrI2FlcqgD95WQx4SkcsQq/j3VvFVWpKPqwZjJTkKjWglUid4 +wt+SfYicBBABAgAGBQJT4HiSAAoJEHGlqXux4NBv9JYD/3STQZtl4LTe9uuGdwVm +n/aQrDEMVr92mBLhppiVySncgS1w5n/RLBMvQvwHjL2kw9qMn+5QfJzkzYfUXe6p +MKEmZ8fL2iZkdHJ+Bio3YJMdsOua4GuChMoICwhYIEZknmH9FOiAAmjoeC9Y5hPQ +HPl8xLNyuZxfAmolisHLoM7giJwEEAECAAYFAlPgeJIACgkQexZ7BIpRAS30lgQA +osi/SmXet6obU15pYhWxH71/TXEH1/UB8GxMw7owV7fF1sMLmklx61zKBpTXZ4NR +FBfHUWtmjIQAraIy9FA8xJ76SBlnjbpgLkZaz9JWBBKMA2mPXX3vp2CVIgXKnY98 +XsQzPYp+cX+RsalgYo6ZpSzyuBAnTqWcd2pjIMMU4XiInAQQAQIABgUCU+B4kgAK +CRB8aL4qXwb8d/SWA/9EAICdaRB3yXehphLvdOAnNV2KNSdLKzgTDjW1SebkG0Qk +u0z7KCcnTJ6JgEEqCES6Z0D3p3HdX4QtlMvhS6Fi53NIXlSD1xrIsNh/hPuk1hBj +LAGVR5Eovfq0mGieG8ssHaHZMzmkc7WjjJgE+tEK0+TdfnEwLcX6SgoLLsw+dYic +BBABAgAGBQJT4HiSAAoJEINXgRW6xjdK9JYEAJ13JHJ28+BlJZs0o4C+EreyYhvJ +KpGd13erG48KjTBv1Ih3mRTu8rLqjrfBFmQP21mi0ElAuXzmwzRg3CfuClWQXDuu +frbXQ5Pwj594TlQZlov3U/iq6IkGDX87CMR0s+NQHFVm9hAPRmcHZzlbQrJgChGj +IrqzrsH0fFwU4cJ+iJwEEAECAAYFAlPgeJIACgkQhLnJk2B/rFL0lgP+PXy9hty3 ++ApPY8dELc0SRJ6JhiZ27CPvYwz5KnfT7Hz1Cj4nKgKZihwJP3kBSSPgyyrGP62E +2NAWpjry+SjvECoBaGgn0ptrI1fG9FdvL/5X6eXGi9dxz7CQ/c6ilLQi7muziXMA +eAoWuKeCTlDzTWAGIFQOXW4HgUDYeda0peGInAQQAQIABgUCU+B4kgAKCRCKDLb5 +aBtkafSWBACcIo0dIIuW0q9km4sS/r5KZgB/7UStqOWmoqN4OdarXIoIC654NvUi +GvSu6ilo8IiXUbxRImT6R+QmPHenviCRFKgWV0S6Le7dUPhwFMSBWOjz/ZYizAW0 +CCgaZdjYRAS/uoS9/hY4tAMOHSKvt6aGHiBea4R3FjGNGUWSktvI6YicBBABAgAG +BQJT4HiSAAoJEMCwT/lvDa7Q9JYEAKuWzpVY1JzBvrjf5IXGYVzSqh0kGnYGQmiS +DPZjqUYpfRIoUj4XwGXBbzjusxsAuiZroYli/mivTAEJMv48/v93P5TUpyqo22cx +L1h9jbvEORMdYvxCE650EECJcn8znCmYr2ScQiHregQHIq2d9ZOA8zWEUzy6/501 +gBumeb+riJwEEAECAAYFAlPgeJIACgkQxEN78PnzYFj0lgP/XMTbXCrnlaxcTfs7 +bXRuONKUDMBAdlfjbGDUB4+c0octG6hszWyK2c/dsYvz035tNORSQjwpstxkdrRG +04wj9Dwi2HDR4PdxYTQgqtEL1yviZFANdvhvTSXrKs4ad4jxBFYNIss0zh9KX7uJ +HkKrkT4Af4Q8ldB1ykXp3Es0u4KInAQQAQIABgUCU+B4kgAKCRDGnZt8nEYe8/SW +A/9eKj4wckTuB2PYBb84X9oeQtDUVpw1uFA6pSs4o1MKkEZqyJMCZXBrSuNAiMkp +Wcj2PZteBiccHBKTVhpbAQTTGcSn9FiOtfq/mZtKGK0HK1NpsJYGqpOf9uNFopbs +mQzeBaLvARuHZ049WYxgDoLCGLm2fcvbq5dKNqH9lzeWRoicBBABAgAGBQJT4HiS +AAoJENdqvBY9t5679JYEAIagJYtA8b/RWK037IEeTwN0BpyPPsMuvismX3Y2ajOL +IR5+PZetQgwon6WYH39C+MWuLrH4g4k10pJuNXa494MxqrvLjWyMpP0JjGtCdxC8 +vz+dnq8+1gwueBNhoytsI29IXXkDWk6SOH+OBYwwlM9RaqhA6Kc9ucfHDnKSHiFA +iJwEEAECAAYFAlPgeJIACgkQ3Pu6vNMTonz0lgP+IJ3JN21S34eBmtvvKlo9NWVj +GtzKSmdPA6euteQLDc4Nk/3NmeFQEDJ2Bb/Jt5vaH4jwoY/jmdDxT1BkBXMD1ZBi +gAHAMUNPiTvVWre/nEEZ3/eJ4uZiWg42iZx+AD2m1kexhpox5X3O094PzFKA3HYa +1U31vDGBpOspsMr3V/aInAQQAQIABgUCU+B4kgAKCRD0TahQlTuGk/SWA/47OyQV +lsywS2+lFUt+Wl2ptxd1WrVd+enlOE8FKySyseyRNJHdONkiptXx36l7NF/vj9DR +x9Nqg5aD7yWmhjJOGn/Esg17klIpy9qcqcv10fT1HPBmpdViBoiRJDIENq0L4kLO +HdbvL6Fr28xC89/nffHP7SX2zrdM6BJSDpe5BYicBBABAgAGBQJT4HiSAAoJEPbj +tuJBie0n9JYD/jjLNkhMj7LpMH7w/Hpi45z2gmiIM2ngCEsUu1lP7957ibmxBSxm +muxbbNg4S0XTQmEWRSMmdvFwNdHeJlitv/iUMb/IfdK8X83I78ZYUcHq8SFjprL6 +1umPCXkTRh6Q7p4DIa9cNIvdxPCfZnP0l0nh0v+QVDYfuxUIs4j3tH7CiJwEEAEC +AAYFAlPgeJMACgkQlMTG9SkWnXZGNwQAnWn/jXKKibJYKBzkXxlCZyjeQg+rRAxC +1epwmJhO8FdiQHpaCtXiodM+ipd1saT6c58uKRlexGJ715yEkNqx0S+DMyPK/OdQ +lsO6rCPhkJpc5+ZZjYOoVppuoJ+j+OglZeUIPn/HZ90JdGWl365bug4e4KVyL9cX +TSbv3jjgsMiInAQQAQIABgUCU+B4lgAKCRBarNLwVyEyfSgaA/4jmpiZegz47zzY +cdX1pQNhJcPvSwQVwZxGc2cm1xzgLj8mV2/4lodUKXyJL6TNVFCNHUzMRX4oPtpo +BiJmgUJ4cFtBr3WFfd/+yjQZMndhbWUth3LZu7/gUC0qjrpvHVwUns6S72QiZil3 ++GqorjvCxdexA0WuqB0QgcNdqzMeF4icBBABAgAGBQJT4HiWAAoJEKMhg1KcdcSm +KBoD/iFeyzupng4L5w1iOmuo9jasZWPXJc8+PZFxlDmiJ6LuWoJ2uHpNDiuR+TgU +ae032Uht/BHsGwRXdPycATNiauN3fLKhI/DIgFCBMIi0midC1PhsIqqPbNYG3E7G +YjmQdLUkgb2UFvwYMPmfxzgVrsS02NWuGQ0GZiqjhzoGyC0liJwEEAECAAYFAlPg +eJYACgkQ0Yuqj06dqqQoGgQAn5oYFIf7cDLUVG/0vQoPDYV6z4ZXDx0sv9R1Kdk5 +azrhiA7if0am10Oe3Jx9h0qVfhQi3l51mlCq5XiKme1M5JIbv0yMDDYMXANmEwcL +VdxDtMqWgfIcTwtbWreoktqQQMPzUGLDSnkdaR+hSx/4rcxhhHHxcWqf+DndKdcV +WV6IuAQTAQIAIgUCU+AyFAIbLwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ +GScg9+pbvXE5ogQA1zePR52Yf4oSQf305PsDwE28lWRLguiCMJQxPm5aWdLxM6oX +N/NuIc1DVs0SKyZWVI1SAx2fvKEg2FQFZhjKIeL1CJXGxpOtjcU8JpAe0CQjiUoj +zrTYwYCeFmMD/Uhf8YaL6T4ygEm4lFhZxpw/+1At4Y+vm9mVQ68g5KgZbnSJARwE +EAECAAYFAlPgeJMACgkQ2q3sP+a19aNGNwgAiF/5EC0GeG0/Ctm0bKtIj8MnINVd +PaWbYpVVgKzYl7LtROKTrvyar9rwwoaSpvUMwRFxuwfP5lddmTB0MfhLYGqbj51M +ZnIy8CdTbP3a6HezGLAwM50SZcO3KUhxaHwMFp3527RoFjQPPE0Mq249lzvIaA1o +n3ZGiYNGBJnIu2XVm3nUW+e3wIEpkrJNQDTMiUesDdS/2nsvGXn91RNQRFvThvjV +pXez1IiXXtnXwkYo71uM4qbL5Q07/iBxe/fagegIEzcz01Oxm8789GWKgdZg8emZ +xm8/CGiQbA4cNeCLla0pJtkfezWgnz6SogIdfIhRkkgq6SHARI5T3zWUUokCHAQQ +AQIABgUCU+B4kwAKCRCVzbKJdrm3OUY3D/44/AbExIrZ+IPlbhgHhceL5I7AbabS +PiGUJWprcAoZDoTusSce8XkIFLVGzK8qaKJwMlryPpitYRfStAQEeZGzq7XW/6pz +oxrS7mNiJcttSy950fRN8HEeMDoD9VILBlrrlp/hWkIYiFtZNwqYv78WWpzgE+Vs +wOq45AkobjB95X+clRJ7hGV4AQ4XRj4ujpuXOHeyRzosVST7DEUnPDJCAlw4ExxY +hAvwaEIAojxTOjybxL9+iochKmaZsAQkqKzzprKSeDyMqRhyWclkA/er9qnGE7Bn +qEbtaS8W8OsMj5uKxPWQyJ8YcU51WbzYOFX6hkGRjgU5Iw6NZlTobW7HQH9UMB6m +YXZn5B0Dk0x6fjty90xeadrqDgz1pR7/WNnN76/iB+bk4LXr05Ty9pI1n8K+1BfC +A5wNDXJguow3ECCJDzwadMcSw8UJfFXRqncRW3NMZhGOciy1Dt3xUD+oio/aUWgX +su2gmikl/ltg59mTVSjy5EMU2FBvijs8BVZzfpllCGfZcTrRGwxLQdUgX5gmfQAX +O42VHwy+V6LPFVsjHHLt2KFwMW93rr+4yKINSH1LmktEM7g9WDWanCxNk67fLbqI +VzwOKopEGqL4bfbgRXilhbIOtF3L2ZPKwXsI6JgIUwnRxg6DqbRLeItfZwNPEOTe +DZhmf0C42sDkLokCHAQQAQIABgUCU+B4kwAKCRC4YzxmIYD8/kY3D/4gGVSP/Ppr +ytgt4msvizTYazfowV5XOwABYkBj47ulgm0K4KzurwyVEI4d5750XInDqF1NJmoq +ccuq5bMvN+OuzhkGJ1xkz2wxkW9KinLecXqoc1hHo8fONnfO6PyWBsqLc19/FYjf +lzU6e0nVSiw0aiy8aWFo22uX+bIz8jyybmtjc2qbngWX74JdUC6YCYo03FgbyHVJ ++3S4Jyh1yKURy1CVwhErCa6AckblOvFRh6aYRUSDJWsJcNOCjCJlCbacBBAGl+FK +VN0WH4d2c7mdAeQZ20Btzo9POwdpBujfTg+D9MfiaiqQ5RetO2MtJbtEH/GSvCR6 +pUpuS7reDwlns0/J3nK+xaQUFEtdbuKyycsVJs+qM5JgQZ3qRoBbqUInoxhuC22e +fs5Vh7EQ+lzq20Z1HxnGFv/JxhsMRDmfXfd0tZJ3dqo0vsjgBYuhk9FL1y2af6Xf +8rua/G+d19zT5gaPV+j8CVA50t5f6qkyKLp4PNYdiC65vEZ8fW+L2ZpXzSwxMnr8 +eTrsJADe1ewfILIBiBb8BEBuDNnUo7a0jMCcTaQMqRI4YDPV/3wMBQ2EyAS8zLMH +sCMBWd4liUk6swDMNuJoUYKp05KSftWNCDpaWebTDr+5H5Wg3yIzbm/vK93LvBv8 +L979aTwMAEVH4wHjTC/ur1gFp8KSIpLq64kCHAQQAQIABgUCU+B4kwAKCRDkUHfP +X+y9kkY3D/9qMs1khj4HdXir8dII1OZrNqj6A0BVKWYFneMnS894O9OO7j47VL6I +67oy2ljOvI+0OoX3gj+I1Z/UEDeyPjUogza3HfWLG3gIaw8/bmDUWu0Wr9IMq65D +sXWp6nFMG6JSY1SVo1H83IG0ROnefKfJ4ZEdr5qfEAatzbIBgVe361NABOK3e2c7 +kC76UZdKT+tu/mY1vVUTLYNhdW3jHoR1VJ2K2+TnlgRWKzbi8xHEAl+ucnMS9Mry +vAwhTipXluLWQYWqkO13h9wrCX18f+Yr4D2CT/QQQunW/BJyzhfeTQ8Efw6dKnx8 +dnLZLro05bLWm8cUDaKM0cQfDyBftOBvSdxWqSNTfibmomoDoGBeA9Rs6Qpd4ooX +rEy94MXzAMygPynI86NexWg2hEY5mQ4lZ02FgkgVjxPPwD5DPjbp8toA2AGcCk8r +HrtD7oL00tihEMrtAwnKpMWuyzt5W+Sc98qLf99oowBidBFnDJFjTbhoqcQXUOg3 +zprOq/oKFxdtzvV9+nndzBTkQHQepFNgJh5vYCUVj1334JthsO2+KC/azTZT0RJO +Qrg10+MOdVmyou1rm/R2CRFoCHIC+tq0pgqmg/javlz8wHZRqXWINQ6O1sGoRkBO +X1tqOwSgF74Dn3TMIUQNM/hgoRz/Gb4hGQQ4w3UEENDhY/goWJ4r6IkCHAQQAQIA +BgUCU+B4lAAKCRAOQNs6MMsbEcsND/9AV1+67b0kLflRUjwQg1O6F/+QT9vQwOAv +n7jebQH0Wj3lJjgq9tBcm4jdfaGPTruJ8MJR91Z0rgN1o8qsJLysAYH+0KCQd542 +FHdyvRxx3KJjqZZpmJ9Juj3gMegzMZ72h20aB167ZXFxlQAq81enaqjWP9UIATGg +Zs4/42Bd4lMm5jCDlfAClohM8obVYlgrgDqksHyo5gZNW1RYVZQ3rA9yFrcU4aaE +ersetkgtXvHWPSf47+qfGHM6dr9X0S5tKeZnre4lhctrXLPcBH/Oaa3i/PEfMaEs ++N92o3oiKTJvtKnKKM1NGJFWblzFg2H9WcauH3C7f3rbQoW23RCi2IiC/S32J+uk +a51qAweo7AkdgRYBWLaOdSCA2BSOLhdKNSNBlHJQPEoUg6P2krq5KsFGLMS5riqZ +ft41Qj4FBbAVNO9s93XKuEYTo7Z8eVGhdOtoKiu2pVVc345QBbkdaKV61aUnw3BZ +91OLylNA6EUedbjGrqqI15Owz/7Zoh1kN544un+6qyHrE93icYNHas10OpnFooUG +F6RMb5xaQjU6THKtY8UYntdRRQplIHchzcVb3SepU4b6jVuMZzvr5LN9a0zZLMiy +ZA4hIIGJ6sPFfJO2tC4FmzU5oceUFbIlSn0J8EnBduIxwTlNPTsBHApZ3qMcMoP1 +TtYhMmaruIkCHAQQAQIABgUCU+B4lAAKCRAVFjWg7gGMk8sND/4nXBhSi6vLRdzG +SbAQZAu4abtqybzBg21TXbE9TOGv9kDNlj90Bqx0g1Ac1uvoDQpYmykEvj7scFig +llBhMVbPcW8Jh3d75TAZj6GXFbozEL2A4wGSmvKv3tcM/tySaElMOeMZt21SnBZ5 +vmCNzCVRiTLD+lzUPrZE2/U/2IVZ5XouBxHwVE8rJ8lEh4t1OcHJ6nwxLGpeYyMp +Ld7iHZjO7Yuq4dYkxLKlU7o90p/m2IAwYRqFJD1uP7UMHvEZOY42dXWsATkw+KFS +/zKJttXJMkhj+OKX4P4MJn6y/u5IFwWfx3rlXO2/RlLP71igke8tVFROud7UBAKL +ptqJug0IWMKAzi5YD9S/pqjyNxcYvcrldaOpppGNk41MwobDf4Jl4xjSWz38arP2 +EfLzGpPElILoaKWWlNAZSHZOceSV7Kpmkq66dLsI0peNIuuXRKIJMZPAyJ1XThJY +HEnZ3Ek6CYU65Wg+432skNfVly+W8CchIvw0Sava5PTLqU6d1tDOGpUXLwbs31t9 +UrHx+9xRBa1k4rqRrBYe3XRTa3ehmaIDTvV3H5XhuLnwjNQ24zeJyexl+QHbm9u9 +pqVKIUayUm/li8Sgw7fDhrf4cj2HzpwQpS6/7eFe/WKDebVTBSjGQ/hIvxhpbbRs +r4ZpfIy3SxMhIASjslUmTzpgPkwDIYkCHAQQAQIABgUCU+B4lAAKCRCapKokGPX7 +zssND/45+Ak+iZdWfXrXhT/RxLnomoxxLLuqIzsz3IbhnpJxpXRa2nqY/SIBz9Ih +FbGx/KDFPOf68OuK6bzZDykeGkA/mRLk/Pzsn2W7HkIqLbeo/AsWGZgUudYLrqcI +CXraql8F4SEyC/QpRTGjyK0XbGJVY0i1XUMZd/j6egLNQU7HMoAK4ga3Al262zIm +hEBckNz4dl9+fH6Ob9iol64QBOV3bmeSXKQivDdf8kr7zKYROZ+2yRWB2fPSunuh +3j8vOWb48AraEE2melFa2gGIWR+uDw3Cdn8clM6vbXCAd5e8nUkiZWp2tT7EwITP +bxUVIXZjlkY/Vrr+CdrQRhkw1qYbfBQmH6PGoecsWoGJ+dkcjk8wb0hG35kl5gaH +37nboKbTu7vM88FRlXRi0wduk8v6qUZX5YsN50Gi/0D27t3eV4SBRKrAc5HHK9vf +J6b+K94ADlAIIdUcHtSxIO7Gh9c0bb9H64Fuh/UUgCmhL4exfBOIh+u21l7Z8VS/ +LZyhcodlIJrUXoHRO5+27YPYll8m3f6iXLTkrJDQX/tjC9aYOLYsH2Iy+i3OsZ63 +FCNjXPzFlucHm6dDgqua74Olc0p4eJsmmBlgvk3fKOV898padsMoZW/B8qpQPmds +ryiAD9nEI3BgzGUVceWP32aHSXx3BCysbXScFDZDugtWqqlF84kCHAQQAQIABgUC +U+B4lAAKCRC9GbvSZHktZ8sNEACCZI0Vw69ujDqTs1Ue+Ba4Rt9m08vxuHd6AioY +hujuAJo/YGVtwRCxm5Uq80dfRBDpgq+FbGq01B2PEOlZ2mRatdb1r226lLq/+K0E +osECAnGTo1mWtX0RT4ZadEeu7pdok8MfXfpPSpBNCLOjCoPgfdf4yzJ28MfBLos+ +2EUQgrGwWewpND/Tfn+KxrySPKwkCmL4vI7OryAkqheyCgvi+2ElRsV6KbPsxh/3 +15FgJnwzKc7p5g6PtNMs8UBiH7IKMAQbzGxIT4qx/JyF8E/3y6xTdquI7JA53hww +GlGGYOU0HTpuxMU6zUN5iqq5aBKc8nka214+BmmPwjS0dqGkJiyJ/8GfLvaNsQxV +LmU+Ff60RDsdyVf9X5mvytSoP6eeDPJASj0i17ywhDbyhAK+d3ElBQBxvlRj1IlE +8O5BObbIqPj/8etdFQIzcTWVbykX4Fm1DnuMpkz5J58bKIxJ5oOgmFCZLD8R1NvZ +AkNEAUz+fWgourDG3NkioyraZxCkT1DIKq2LTORrAUccuVwVeGDMCTNnkoJ0IHl2 +ByKKae9wkMadDnfB2P3/5S9cS3JkwoXh/ngdjO5vH+DHQSaOTOjmtkkl3Nju9/Wo +woaPwsBkKDlGfWI4/HWPB4ppGYZKJTihWK+g4l7f+jJvGa5z52nbJNo44YA3iFD1 +sGiYDIkCHAQQAQIABgUCU+B4lQAKCRAcxIkkHFBB1IRtD/9NBiRrOa+EVMVA1N39 +v3xnp5OBTLt7x+0S8XcD/UYdHT+XzRm4Gng3hcMbvfRuheVMJHodQaRHru3TJzb1 +lY3p1u/v4Kc2W/LVY1UR7xiOkiix9zqaX9wAkRbJq/HJA5XTIRwUhCfV7sEow2iB +C2a2yq2wp4O2zgM/ouwISgZNfi23xV/ZYLkJI5KmLlkkly3ODBFHvIGPmFpNmvlJ +3Wa3c0NwDYRkFQSxSpwMhD9ZVUs/DGQzfShPb+PTROEeaGy80LrvdfY+naWO8YGP +FkmS7FXPbF3A7lwtweHkoy2l4vED72jd2/2cpLkMdKkSYp8wUycEtV7PdrbMwyzD +BVT/sZzC8yF4LOsS01Hgdt9OynLDvG/ErbKCj6QKAzhEZHVDjCZ6mDWiOzAO9fJV +oU+45nLhcz1SRQC3JG2PblzoFSinflJHyZA88HAct+PDfqFwUsVtLyH8tB4iEcdI +o2tIxfv7Nhl6Hwewvd5e6XZl5COOxNkpzpwJtbJlcm7h79JiKpBXzs/IGYDf5E8O +NFxLMDAaQYsNk7T65OJF08WUIW5A6O97ok+SaJx1uUel1IMBJUgDPJVXlFWx24ev +ZXTkMReCGxwN70vJ8MRy1SN+YR8Q+cxIh1aD8dEJbPPQ7p6VwQzbLqRE0GMvpJm0 +S8Rg7IwX4EZrJ2a7b04CLgyFCIkCHAQQAQIABgUCU+B4lQAKCRAxZmWw5ZI8GIRt +D/wOIOP9NSOGZYK0MVvee4O1Buz8x4dBaRhxiXAh9+GrowfJkr6RYb6IOWm2fj9I ++2u8ALQyutJaEZakA1VJVDZEKXzC2n/Q0g0vnkZaGgFLp8z9e2F8Hy5MLAPJ77qr +HHbVwclxZVN2xlLWGciOEZko7UFQtmyhHj6DQbNbk6cYqRAWz3NEm+0fZV7s468J +Nww4RFBYKHvJzn9J9/jRoalylN46syls9nkqfqPegpgERYmJKnZU5RAzoBJ84l1C +u+2nHuqJAGjhTpPMv4SZ0PhtzFliR/QmyWtONL44AMffRb1v1KfdrxvaZelK1ERX +LHliSPt8ft8ocWTGB9Kz/ak8+j5PqavAX8ZfUDu7GRuApqLcOit4wRwHWQwN3RIO +QCjFib3Zjdae11LFxxAh7tJW3sc72XE2/bsTh8oYM2DqVrixXUjB7/WR5Ae3BS27 +S9hETVzR72kFIqXf5rzyqkmwG6i6y7N6vmqsIPQCPrYAIvI8JYDP6Pcxx0RTXWK7 +oCZtu4DVEyhfM2m/8yeYlE49E3P9PG63xpeiU+JPKWoz58D0bK0PTB6cO9Io9s0r +VQgywIUyYGpMnngpJwMWsXZk7ZZbdGhGznAoVt9fp1jMPsfURCCpWvbZvoGWlXOK +oWbNcD+SiRQrza1k5PeUCPdB/V8VjD5gXaPu6JxMG+ZKWokCHAQQAQIABgUCU+B4 +lQAKCRDHDKtpsrv8/IRtEACfTY9L4mHwBiE2lk6vETmVptx+Jb756f6SPgzdyz4e +wmnv+stBcVrDpf75rIdUcPLDS7j9J96JVEVCZlAWdzLNVP90V7sj7mM0FR1fENhe +IQpd8okyQ7JuTnqpCqzEGFTE94d6Cwt2DtgEF62RISxrYuXCDputYISIwmcCbq1P +d4cKSO0MgEOFeyWxi1Tllhbz78KwZCFxssUPz0RERw2kWm8enrb+7kuzNfJBiUVU +yUYDSMD2vxs8Otg1pzovGgn3EwzbGv29l3mHZwNmdoiY5Rcm58HjRMdlg1Bk12V6 +1nyEw0WV8IqjUCqpryd2+SG5xa7+lsXfmC73YB4B247bgNADxx364cGy2C04OFXO +y5iZJvTpGWwtgknfBZpa+0SlL4z9WJIQ2YafZEVPJpD/6VZ1SF+tk5GqiMfYzN0j +iU1n129Qpe2Uak69hUXYMIt6tZO/bxwlwoZ8Dxd5bzPOQxUCKVXvXlNV6ohwHEL1 +QrKAFzINZfKvFPhDs3MH+2zzNIUzFCUBwsP4BoP5qT1Z1J7KPsyYlQDicfA7ke1b +FtOrMmR0uAs6AnbxV4R2LGxohQjetWglF4x8ZqY464B12qUsIJAkFTG+xpQYKzjJ +dVneKbGVvhQ4K3zNo2tnO86V+ONMzAo4Jj+VdkoeoQBFyN0RO75EAIqWzw4b3qTZ +8okCHAQQAQIABgUCU+B4lgAKCRBHj36Ip0V2RSgaD/47fDuQv+IA8KW3daWF8oa9 +JV7wNqNcV/rBEVMT2TxPTOpQr7x6rFY7sp5qHx6gTOUFWOBl2uDcBic4ShRlJijO +hv6v/Z98fGS8ZboacB/AKQLugQ+aTcL+BOJH2b4zzCQ3u55ZcWcsRH5nWGEurFdM +IOraMvb1zS+oztVsTTA2oKdfmA1X1+sOX51zFZC4mHMHnnsNHwmAqQ836+Hp+jnr +Xff0+0htiFxg9OnzO+WvSBP5pyhjX3gROKsCR6aKOSDqmdpTmFHg+jT2c7+rCvnn +iw0kMJnVF/+S9CzTNgaKrjtrOIlU6P94efF2DjGqfYlRqSC+WgR9zcnV56ZNtlG5 +4jO6/jQmql0KIDa9haC6Sk4joCsT/VEvOXrop9VLDPx1bgj19/6ER2dd2Jpmrc9R +Cy752w66m6ihWxJBD02Qy/Cg1xSFSaAOqYJ6MGgy+IK6P9+93lXie9jJiVkwlaN5 +zu3fn5BlYpj3ag1sTDiiZDMXOeWO3TdcDf+Umf9Pu1NfxtmJZC4LIJkPXfl3KS7u +hz0guJo6G/9e7yAisndTCa8+Jf49pXhUwah53fQEWWDz6EWzlvom7lVaeJtDDOzq +NipypneyIaJchOXqqOX2jkGINC+JM4Ml1fcicriBYx+r/RdosWRa5/q5jPPEyOZg +5Ee3A66CZI2zbtmdU8hDRpiNBFF4ZD8BBADTAA0Odv+hRBxU3HNN83A+wt2gsceq +jyp84sA8+INk8HCjVXM0oM+smEkyTO2rgX/d7al6do5Bo6zP9EW8UyXUDTM+Wqaz +JASDePJKRn6n/3TZGKWceGT64efOlZkb4ke7uSgFALGlM/gfdzNsm4MdJtFQmPsQ +EnGSYG0SSVJ6hQARAQABtC9Ub3RhbGx5IExlZ2l0IFNpZ25pbmcgS2V5IDxtYWxs +b3J5QGV4YW1wbGUub3JnPojQBBMBCAA6FiEEtDofnt6Gf+SK0dcYI2pDSqdLBr8F +AlF4ZD8CGwEGCwkIBwMCBxUKCQgLAwIEFgIDAQIeAQIXgAAKCRAjakNKp0sGv5Up +BACoJ19tBWPBDMzxE3EHnjpmbBTc3jUxkPxKXBovGTTgA7rsffx1xFvr9E1d04ab +l8Oa1LhCsZxaVYfeSGP+Qn1zi4l5UD1D63R8w2b4zDCDgJVLDS0Bj6jSKImXvF+m +6Lo97VtPdpV13jhkIswzaUMzZREF363d8Qs1eA82U0ymKpkCDgRTny24ARAArpSC +25YvTcrQq1u8XKRwC6kHFJAOWCrEVznUfZExDxtGudNFUpLQHencDMDmOGRI5ofP +6EhnDZCbNMWh0XghU2Ck3Vbdxv3CPlTksNtp39NyGgCRVoD6nUlKxTLWbDuBZkpk +oZXT4+lEWFRHoWH0Kv3hO+jysYNKsb6wVHKV5wBYFLMcuG9mP6deuwQvqQVqhB4v +K8UJPulHmYY/K8lY21bfj1wK4hzoSZCqpILeNG/NuGRaOUjfIy+BcWJdObQgtVzu +64Dmz7124ZZ9LhZWGZwK5uJc+9I2afhU7zC510yQ7K9s0ejcTH/nUxhddSTFQ7p4 +KHc9FKHlxMY2G9msrxJJ5Q62q8nGZJWaZIm/+RRH4Gd5UY6RtJEUEJVXR4vxSwLq +Jo9aseDVyjIw/n3+hMAQcnZe1yauH1cB6cqdlug2V7nAbEuV6uwVBbO9DDU+CK7x +nQZxhVeaiGAEvrOYNmUoTpk0sEvyVxcOjMW2DdcSJOor/XkiSn/56I+7ZK9fsqRm +EU+RXPAt+/a6Du+WX/6RhuqCXROciPek60eVbPW068moUbvrHoscofzsOEHhnf88 +NTXzHMC95FmcjH/Fxn3SANEE5h0YWX9XYv4mZ0LKF5hXvCB89RzzdddXUAuMhAS2 +qvTkPkcNcfQw1hYzYhB0hlGoyjSE9Wth3e9nCzsAIPfegf+JArcEIAECAKEFAley +oLyaHQJUaGlzIGtleSB3YXMgZ2VuZXJhdGVkIGFzIHBhcnQgb2YgdGhlIEV2aWwz +MiBwcm9qZWN0LgpJdCBpcyBub3Qgb3duZWQgYnkgdGhlIHVzZXIgZGVzY3JpYmVk +IGluIHRoZSBVSUQuClNlZSBodHRwczovL2V2aWwzMi5jb20vcmV2b2tlZCBmb3Ig +bW9yZSBkZXRhaWxzLgAKCRD+WfgTp0sGvzhgD/0fzz3JzuUeggnXfz8Tw4ZKC9Vl +t5dn7KvsXfXa8jfRjdvn9lYeOUxi9OpinNojm/Jm/aVfPo9ZtjOXlquRP74zQCW5 +YIc/HtNpamSqJJKhxQvHQAHJ2+YNC9IM3cafDwNFZEJC0KDhb2eVwazptH2nckfC +1foCccyXfBlKS3ZCd9z+8mkO56mIdeFQKG1scO84RxdNDQVdei5BSfmbJlTwbdko +p3yeg0Oc4bpmpNFwNtVsVv59JtvGtmbpuWOU3Tw6mTubEoorFL8tkQuMj7AWqiTc +5qXN37xS63+VddwKlTEC+Q1SlK1GqVMTPosXeELJv5AQDmfbYJ8bVoEqK0+kjAN9 +tyJzzz4aFrUztoE1qNEmwrZYT8pPmhndVE4hZ4xIX8/uLVdClYYLLozHnzOCCVrH +xIIeT02KRy4glo0daeeBrw6pwn4Qzjsnvy05+rfxe7Fql0fi9mCUQnKS5yZF0bCd +qqXc730e9sEkeTyRn9zyjdT6EXW2nM8grkkinTTL5izcYZviM0aFkvSD7surVsvh +h/8RscpWQHokp0Y0lb9gGDe701FacV6mO0bFkJBmZdMI1a9J6lwzDWsjDlCywVxP +9TkRZasTFehgephqpRgnTzxjy5uux9GE5Tujpj/jUzbtcOmjlfBBb1Zm8vaf5xJC +8ljywm61mOca0vbCcLQeQmFycnkgV2Fyc2F3IDxiYXJyeUB3YXJzYXcudXM+iJwE +EAECAAYFAlPgmd8ACgkQGScg9+pbvXHpKAP+J+FPJiRe3Qf4UdVSs5fIs2BVrb89 +dP7EJn2RDrwCLUEqGNi9S1ccNGfFKt5omfXEyEruVYyKI9/lS5RxO7urs+sTNj7f +2AUXXwE4cN71fzkfmrb9GEDJuBQL8SccUCCRTzAqWwvm5Pn9vF3QFhEQqU/4citx +IWBqYvtB5AsGMe6InAQQAQIABgUCU+CZ3wAKCRDxZZRZ3c1oaukoA/94acZdSKRp +9liCgCZ6jQmrsBWtbIhPbnrIz8x+/7o8FnGMbYdoBSrOkcU6Q2JDasjcwrhQkZwq +f8kAf2xREjGGSNVz7y1BZ45p1stJNZxLl0c0+sbLBdCQfZQnoFsSiX6G1niylqIx +NwIKoV+rQ+NGYM/mKrNUQoaZ9IKfMVlKxYicBBABAgAGBQJT4JnfAAoJEPRNqFCV +O4aT6SgD/29h9/5qsHzYYInIFFLQ7Dd8TEzHXAOYG01rfu6Y4GuyfjXg1nR5ZglT +dxb8ypRuTL5w5f5S9ltrin8zQ2ugCIRxj5XbP/lZMoSu/8MUaH+fI/PVa2rUrjul +0iYqaEUQVlRcDDOxGqbYBflG9eM7FfRYihZ3oJUI1TR4b01OcoaYiQEcBBABAgAG +BQJT4JnfAAoJENqt7D/mtfWj6SgH/0miBt4JScSwFXe1fsDPRDrgI9NhNJRowFHL +p+61cOCeLaIkIRfp0SWL84LJ8OV8pY4cnVrjWLgRRJ7HSZ2XgBE5iJodaBRAVZ+E +OKUC/QtqZUCmNQiOw8WYRp/GgM9qoFyE3ArOF+G0ou0fXVhpba0YszloPFSlW7wF +PcP6Y6xhlWB0UHRlkNWisLTQaHRyYGLSJllWlS3gIfTGG6dP7OOGxkobm87Ppknt +wxkbauFAc6lRO6hMjV6tI8gywx1Qeyx/actYmHZyvOSUOxbUFbXjsASX6SYneyNd +i0+qy6k7XkoENesOnruZCW4yMCvqWIz1qHoX4S0Z2cthibDPc9GJAhwEEAECAAYF +AlPgmd8ACgkQlc2yiXa5tznpKA//RpPOqx8KSSYP2297sDq7U7ZEWcFm3G8eOOFd +k0h+Xwy+484ivWph/Quj12+FQFn7C1x/fdNGCCMTXyM+ECGdznL3R/APpmQIuBnl +CaBjiapsDQRbaUSLtjQ50IfBYa19qy+a6I/h3BFP8n8/rgGHILjSIR1pfDLETHFK +BlLTWu2rANk8DE5uURj/wHN1ADVdIMhyXQt3L6RHXVCV/LqIkqQ4s+sKcUzymyow +v8BpYsEO6iP2fOBaCPz1ldRYeCNvQh7sRCMIRMDcew2FS/L0j3crhrZc6bxoHGk4 +cvzuVfvBQYmqTt4/0PnlA792pqRQKtwJMcogagbTLOd2J8g3qPQi66laM9KoehvQ +S05FRH+XaibHA5OkiowdfN+xOk9hDVfb9BmGRJwGE90QSW5nsIa4kFm3rUVm+P7w +E/KqM5JS3MgxOV5q1Yr6C1SNoxnewbzTNRETUvz++ypgLzSn5f2kmy6+reZ8n5uS +jW5a3KRXrMhyxAeeYn83dakWhcbB7leJL5hkVt5TPs8B+vcKyAd+2PZfUC6Xgas2 +SqXulNXSOg7ZYZ9QltFBn1NvgZ0UMqXpH7pZSoqUFeCV/efE6kr4oGYGDpwVwKRx +Y5HgS9ertytx+eqOqKWwlpjqSES1lFMhBk9KfmMkJKmm0wsIkQg3+QHXWW9T5q+C +2+g4aQOJAhwEEAECAAYFAlPgmd8ACgkQuGM8ZiGA/P7pKBAAp9g2YVOoszWLRPXp +F2DoP5nS0fisW4QLbVYBOkI8tnklsKbqAE7kprCyVCj5UmecvXI8dhH6KWBdnNO/ +AUtn3cs4TzX4UdlD4wn26IlDC1wxlvF6SIi2+15Z+n7kVcGc/j8HFXbbwcOuCLpY +dgVYtIlLeakbQdCxrZM7zWSKxe+mvJNIxCP0Zbsyue2bnI0w2hu/IGyhdrxaHtP4 +EsZJy3qlr08LyCHKNrsydMhdfgIOqzI7zGYQZkeP43BjWuq785nD2o33nIm7z5d7 +VcXNLsQ3PJtD4X3qbxkRKKnLC2FUooTmHjRayAI8TVrocQx7Q3/nPol2qWP5IYNu +Rj5In5nhxas3dOH+S8NXW+xQa5ukGlpZcZhBo9vuA1eGqfqgf6aiVOxyz41k0Q4A +JpURGf44neIJ+oSzqhH7v8m17neE/git/wKW7YsS6CfBSFL5d1x4q4hIYcHCwMsE +IdSX5QiqaZk2KeZGsnr5s3XMC6iTaWO3ZkJlZePCDEX/m87AGjMqJE/sQ5EI3m9X +y8fr4lAxUEoFa5tRzfGf13yD8gJkiVHwqbswb8Jwk9iD11s9c5J2dVY8wVNVgQ8d +nhwmVtb01zxMYMsJTcIm4WWpmSrJ1M7zmdXyb+FtZhLoSiuqiGrqrE5Uj0R0iOG4 +kO6/8kEsxXt1Dlia0md08jgLhhqJAhwEEAECAAYFAlPgmd8ACgkQ5FB3z1/svZLp +KA//ZaZLAk3dI0WLbACQ9/uehN0DwivUuMO2ZXBIQwKterEKGIBHEZIJMYpv7u+Q +Wh6vzqsbI6YZrPg4x5PaTozgc22S3LGRZIgFH+929Ao8/gcv5cSUmCL9QuMSV0F8 +/mKucRoBGTN8m3VAuHhGgZGuSgQvvLhCjxM+I90sq+XlrMVQP1dbOH9aAQoqmri2 +0jwyfTkHL+0AzzmfSiPoyL0dJQyL9pBVRlYrfHLG5JiDMQjdAbsYR5/oqo8zjDJj +2rwUYg5LUvN21prU8wtaGrvzurOX2Hr2Jsr1vuPl4A264qc9gb3+SYeI79S0eu74 +fa4Eibr9uliwJkBfQNfZtvv+WFCyYdid7kErXFBOa1dMxspniGi/G57ReZLmUIt4 +i2iJQ6DTyhI0JTJHQO5yi39PM/v9eaLvUAUXu+yoAhZazFeYL3rAXPWtb1EcGvLS +JQRlB29dBWXh02BtTsE1QlpWjBq9tcx0HhAjO6KSsDo9CqYUZuKjCUwxsAmG479c +Wj+UabPXUEERiZyZh2ZfsqHUT820r4/KxNaMHo0Wi+rWs4B/V8G4ZzIU+oXa4t3t +3q82Px0ZYTR/6isWKMPAFHGYO5NQt1H0F261K2VDlhpRXdHR1JSV7Vu/LoYwi0GR +wsKstVH5xcXlPGcX06876c6wbAccjh1Etd2OGSsBYco0SqaJAhwEEAECAAYFAlPg +meAACgkQDkDbOjDLGxFKMg//YbulMYMc2L2ugInMkNDi30cMEJ4K4iF/NKR0QNY8 +Ha43h/clyhUepZOMECuul3aid5C9zrGkNqwKGOTqz92HJ1r7AKjyVlMMpSkCZ9Ok +mBmJtb9tkRou01r3pTMiJ3qRgslWoRubXPOM306O6hz6XOWEAiiBiKOHEUAuyEyh +05++7dJkK3OlYrfDXayEc5qq38oDfbeX1NZjqgUJsglVhF4ghGXBAwGQtx0gDXmR +r+kp3a1LsL5yYK2zVeIJhRnvl+sZGMKLd9aM7PYbC73Z1z/ntwnS70cuMUnFV2q6 +hVTMfQZ/iD9s2quJRs5JYiAWIhLc5HsnmFPnRwZm12ds9mIGbAtkcQwpENg8PmB4 +udQ4fblNiFHP9UUg4OnRhWkUGnUKr4cf2+jxNmJp26/7zBBAj+aJeTmTGcUViQ1O ++Y+cqUFczLmWIi13nQNREg9WsSLm5tnzs5x6toYfymOymV5TMoBVaUpRGqNQ2DZr +OsFwnpxJDnJozfmBH6qS4gD3aSniXkpa5hy9vrYmtqROoQQOA+8qMSm7K1+x97ru +pdEZ9CKpqfsjVaxo/QpssdFj1H5aCAy4BDzeV4qmC+FlhIOUAWbo/KEnzGo7q2AX +vvwbBqWbFkg9r4cBBVxaQ1KBikNCRVtn+GCB5arSn0HgZOHRaPyF23j7lquFZdgr +qiqJAhwEEAECAAYFAlPgmeAACgkQFRY1oO4BjJNKMg/7BaVHlA5FvU51eM5CdvOX +N1OblkadnxfAqfTZdXS8KwTscl5A7kC0hlCwJXYTJ35q9Xw7xbiTTQ6Wgo8E0aFn +8xg6t9fTQmp/dTmMVEaFoz58WMGBetNVAqlxSWb7Pjgi+nbmJEdleeI3sWHdUiFn +yYbwGwr2AJBvmWUUvks+xHWmEzdBHD06DRd+RrV+EFDnFaJiWptiw4w8ipIirx6J +G8P//SD6NCQ8b9tb2GOP1UVfX9Bio1qjJzWC4n6QJHzC5j78mvCI/omYcxJN2d/F +fyav5tkmlM5OewT9mvZxnLpLgTVSEBrvlTTwB5Mcc5QYrp5uKtpBj3jWCqgAuvH0 +/okKa9W+/gWdpXtFAxcsWOBQ6fHVU5oTwjdvDU22KEQSlgWhRNgW90IwJKazy/Kr +f5ZXtDNU1NZMLJxiG6oyN9sOVt4ePkjVZyeJb1NkRxlOLs9asWuhktlnQeiEJUrW +7p24iFoT7ckQfnXXNbzxgA3cmPCrnC0KH6lxgATtfVyDZ09G1RpLqGcAs6q1c042 +GP3EtaDfE2ey+70NGFOfUGBup2Um3ZlYJVfxIsY/BXW2RxyiLCssVdVftf4hk+Sp +0qo8evS4lMUtdi5cb5TaYqDXwwoJrSUZCqapXj++Pj+yc0guuPbtlDEX4rQGv+cG +UAEVv2RSXsXuJCwtD070tZmJAhwEEAECAAYFAlPgmeAACgkQHMSJJBxQQdRKMg// +Wvjfelch2yw7Xp0A0OZEvsQvZr24f8shKy7+kVV20/iy+K72WdgbyKffzDS4WcS7 +p90YMJscB6AOTRWsl+ssPkBxAXhfl8Sxr4gd5gYqSsYw9Bvel1kiJJFedVcSKnrp +EA/SWKISl8bPDs2wuC8D8APQalSKkjO2YPa5H97RqyQe+jzaCEubiUPxq5PU0wza +Jh8UvLazcRuIT9IseYTyQ4tvzUDFAYM/0HJS34FYuLy4+48eZG4lyp1m0jjo2oQN +balyl6KDbdf8RyOkQxJ01/fFbR2NY+wHcEkYfQQxofV4urr6fW9HSz9pUHPAcnep +VTYvzBJwXVekAVc4elk+nTRFSTNYqofMbo3lvNrFr/FIj/7Xq5UlBoOIqa42dpRr +Roo/uBBXH9KfIwQ1IZfr4mi4GqRb2GnWXBP2/f3KBXKautiGsCwCYUw0K5sz3Vlm +bRPcYMkT31o1qslCBA9QHZssSxUiYbyRBM7MA7f87L91jeEA2CJbaGGkNB4GBQgY +BQVhDIGZn29KpSXngJHNTwfxfKjoSFkqSv9MOQRq9CkRIT4huiyGor7pRHYGmUCi +JNInul0LQypbpR2bQTBsRXweVrJSElxGKw+pI/4rSIVD/hKuCZ4A2iHP7l2Cqpm/ +Psu5h+lu0qGjMxcF3M3ElvLO9b0DO9B+MyxlPLnDanaJAhwEEAECAAYFAlPgmeAA +CgkQQuaeRm2GY5ZKMg//RaUlQ5E2tNZfZ4HYBRjG0tdiPPFe/Y+i+x5yrWUYuH0U +PJoNaKUfmzjWbcuACmT/v5Nmi09MFxdB8zykeWhHYEU1wpzCdOlIHx0QYDL5WlW1 +UB3gzXG4zQtCg1qGEkSMK6cYG0Y+E0aW+gyIPotymXoh60vmNQQ7o7Ch2fLBKD/+ +Ra5545WbqAoNNaKd5UZYZIxvbdwNS1Q80lt5yzen+oM0v7JUBpAwMKSedYgMgAu3 +3hppy2pHbg2XufkquK3whIMk8K7ifIvKP4dRbRqmR5Zxu7lwyesM/hMny1KZWsCT +ECitj8LsZo+Z8hIQyoWEaeafRfKgDrRw0Gv/x/Rh9ensLNpYMmn7P1I8lyRxwt9n +NMIQg2XYYh0n9JaWa2HSQ2M90NyNIsVsrgjFgHk1Frsb+I02pgxPcrCR+XkmJNut +MIv6yAq3MclX0QoXWGlTIaNY2m+nod/F0lJhuPCIq4qgjs6AsZVKb2Ux0qiMlMbK +L1W29Qs6YrZ7GZJDtvcvfVuMIQV2cF4e9qT2IR8DSeu8kLginzBjGGTTP0zIhko0 +y2RX1O6UPTC2Yh/0xHivoAF9MrufO3lP6dyTX/hP2zJRkJ68oho2SE0PNC9DeJy1 +/DnbXsk9GP1BOkggIPFtHqKMiHeDTWucDTgZPk9SdLm+gvvN65GisVL+0kbOtGaJ +AhwEEAECAAYFAlPgmeAACgkQmqSqJBj1+85KMhAA2rvSeE+OTTYMdqd6/G8Keugq +0S0qH00qJFYmZ8QunLvrcj4flHxtGECAHHI1lzhuwX6vA5zYQz4fTmg2c30bDt3i +0fAf80QKvhJdRbzJfMPIdhYYIC/Iae9TrZcRfLKBZz4b8nDf6ysapSpNkEy0jzIk +MEsPk4d64qzEebuq9NW/+f5eoVbkICFpki3jCMezKgKxzahhizsMEqrSxAS0T9jl +z99u6v3xY7H8xjsykrJdy0lubgoV3OKNQ6uDGZLGRLHRwyj0uUxOS1OUF6uziB6+ +njDTRNjb2e7puFo0AZsrSXXsY9RDvGHBPvX8LPABi2+VNZrS5Y6Lu9A3DxIlrFTw +SXyp7nPE4xOghxaeC0PtROrYJ8JsvVGKLfK7244FioMCiWMQ2Dg7bP1NfsgQ6L0a +EkhnVIFOd7cMB3ywjUXLfscJiqeNaME3MO6CRv4XmMfwl7ZHIcPC0axHPlj+x/Fq +/kPYBIX9uo4h58bi+xvRrPBrPI/hgf9uP7aZwkb/+eNW7KZD1snP8hSW1AzqxFz6 +86j3E3s/phrexXC52Gt2ZoEbDQjhdgJl1VREUB7guLBe6kvNsuZlb5yMiDP4myrW +TlwfopO/CNT386z3ZokITfa4/CuGvrXzhluIvMVWCCqhx9ylrE2p+CzZjTMHc8/U +8j/bDjlREZA8fDxsVUqJAhwEEAECAAYFAlPgmeAACgkQvRm70mR5LWdKMhAAjMHd +XlYP9hqekd1Jxexqm+GYvh0LES2pukfqyy2LGv9zRtULX839pcvXlqkIwMMyrJee +/bgIxNiUkroAbSNKQNWIAEa4tNzWa1dzW9UjBEQ97Z0cmQIE/vyqFfYdJn0PpXYh +ivQNITe+q9Qkv2ALNwB0Eq4qvsPmciyFiJA84AEEPVI4mirCbsA1fpt/UpWml/SA +f660gibJx5BX0Z23+2NvPp65/0aYYuevMMZIIdHq55E5R6mR9lioPmbSemP7sd2O +gvBfw55sZAvLtwaqMv77f+T32wviZKF1uHgQ7l4KzBa/hoK0exmB/hrzijIDv4sE +xFsmpfvtdRtD/us6eOyyDU1riiopENqZzSyyWWoL7B80ub1R8wbtAORVKD9h9V8s +XQj9xB2y4234C226YL6lE0/YWWcCCIeYhVFSdRcCqToGtIE4atM5jPCv+DHfev79 +jIR12G1TPD1L9d2km2/54pekuE6tnIbUKjVahnlbktCyXxIGSDIZypJsPfzGBDOA +IqMvfvDRjbsbjX63Osg7Dl73hsBLuZkOVLUh0jWepSDISkLj1Pa/1AS1+smkcIc6 +tvrNf5wTM8s5p5rwzuf2U8c7Rlopd5ChHYG/Sjgvs/QPRpf42pWsGxTtiEucZON0 +/SUs8UZlLBRp+cQMQjXzvBg0b7qNJeHaXZyW97+JAhwEEAECAAYFAlPgmeEACgkQ +MWZlsOWSPBg8nQ//St6+A08MQDQuLUynmvvJxTNJrgUvAQKnoGMySfZYYr1opr5V +GCIMxkypa8kknOhWBlnatksRtyqlGj6rdW+z3AEJLBek+rtv/yr1+yIYnwkCvWvj +KgIDOuzusJ1VP/xpCyataDyIFgEznyA3r0f/s6+i9W92ZJtNvVwCLjdM8YZfGJ/c +nxnDCzfABfDczPQWYXCg2KdXwdjv0T9N8nWVhtK5//L07RDjQwkIr7IUeESeaUT1 +bxU11AGvQAGE20b1lYUmT75nHqR1aGF8UfMFD4c5iezdUvlkxcWs1QqOEq0QykwG +YD88yAg5zu33+yEpIIiivQ0w4vg6+dcza1QAI+o35bcBA55wm8ezNBIRjmXs4BN6 +2IzzHrUL4izmGt4idWEEayVMzcXPLPpbsCCnkuudaiwh/I4DSX6bCCpObrn2Yt+y +504fQOObSfG1wov3k5gx7XQiRbVho/8/i85MA2yXbHFXYX6JB87PeetV28F1aoLn +1xKHci5Sdb0w4XZiiVSZCAM4qdZbSgTzai+S30dWirOvg0FzvQTCtO2Vwyn6V/Ug +owBwdmKQSiw2MKZeRSd3Dee1/OSrBeYvcVf586D17PKlaKdDqib48PoeKvEBr8KP +vGVI6+S0m0WYNLYt85U7syOgfMTC6xXWn2p3mZcAnJR+pcXUbXLXREV6QfaJAhwE +EAECAAYFAlPgmeEACgkQOGrcWvn91QY8nRAAgs6gFysaRWmIKOQ9KFF7NZ/KK7XA +PcKr61LhVt4SmPPsmrrNQCi3FMvjJQqB2hudHpTUeFAeeE4golkj18bbowii13QD +dh49xLXT7BCLwXZkwPm43cuJxQm7oQeBft1bMRcNV8VzbUhX1Lz9mCUnpnlWnpEr +GdzDE2oEfxBPQkWKj37FI5n+IzhOb8oDrHPcjttBQFaUAPXz2tYP71I4Mq6UXKri +cU/xxfJ3NpJ7rEV2Xgs6va3EAQ0AQgTj+//2h2xkqZDplOf3/lFgat1MVvXBu6Zk +hJtR/q8BubEdw6l8+qplpEfvmv/QEsnqgXvnGyq7fWtY4numpJXukHso8+H1nGeX +nOCgQr8PD3wp381kCpp4c47YsOC8vtiTAMrtuw7ZrE+8OLjZnZGuwtRL1CoU3OuR +OQI6H99I3bzGRLuD+mV2DVOgqadbNG9djUZIhFP7oEAuPPOBdoTTt4+hZYgMUNNy +KE4Vvcpk6Bxyj4QDbcGht4g6nUehBZ9eKJDqcE91tDGeiwwGW5BfU9S9LxmtsXNp +XybWw54akQoKt2kMG0W8YvlYNiwG3Mtbl7Im6tCwVsJHWdrhBn5Mu4NJn3Z8YYim +61uW7PhLLB7VbAX/t7GXICjS2DjPDinOKZxX8g4qsIoOHE2cu7SPOnTP4zDjr2zG +/CLvwwGuOQ5UR6aJAhwEEAECAAYFAlPgmeEACgkQlFVrHt/pQIQ8nQ/+M+wj6mud +ngdEgQAlsciofCU2BKlpawyODIcUMnlAUginand6fhVqBe/ut3V0MVpNFbmMIaXA +QWTRfFESxwu8gHmgPaCWKE6YzQIK5+6cN6V+6w+yscY9y/hUaqTtrQbIFNQOVUuT +Hnl47B7AXMv9cwhoVyv79G0f+JsvWflP51bALZsFGCRN+WtBVCHtufcBS2O9VMf7 +NjPanfxjwCwJt3fu7JCrE4we2Xo/fHMTSBmqCf21AXzVXwIQ5Pmpc61OKZsrOiG5 +jQvnL+fs5SkrrJ+PzH1td80iokyKSkDmB8FF/isCoSuRm4zUSHmVdSyboNZdxCYJ +Ts2K3JN7vgsUTic+F2yE1LVJI/+7I+rLcV1qT0gXxs/PyF0SmxbVqPtrgV8oN1nt +pr2ftCmjUpB9q9HMF36Fai9dPptHmosePUo+8G29AroLBeB/POqmyFIKrZaAksRM +zpSGn4z7LyHqVMfu1k2CItF0wyxTEv6tbWsuQe7eHuExbzaUIVbdu26jq7BXyiAz +/5U+r+4X54D+uv1q63TjgQzI9HeD84ZXKjAgm//HLLmO//5yctwk/pOR6yAIKQbc +Mu/rKLJ3HBgHe0uaaRdvMfpEAFYepdhmkyUfprPmOeChQ/xEM/UU/u7dXhEHzO1E +AOfINtBxmVnpsNCkEFreDwc618CGV4k3CN2JAjgEEwECACIFAlPgMf0CGy8GCwkI +BwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEP5Z+BOnSwa/xOIQAI8st823C5ExxDDD +N4b9arl3Gz/JiUo+edWe2tg3xsQY2XKefG/kpG7pzxOBZFGz3oU/kNVOGiI217nL +7LW/+tseKwowS5rZ2e4EZMBlIQUbwoFkCcdwYTMsnh5Q+s4RmbYN1zz9wa26s9lZ +sJqyTXuGqclmLAjtLozoxDcxd9GrLWlLNIXqWqjaY6++6xVA0POQDWb72MHlyjAo +7y/Twbl0XaoW1Jn1RYSDiIml7setgkpJW3QpUoIswDPk7uiPTw7b8zsigWscZiKy +IcR7vZzBYlcBV1oka+ZjkwQ8f/KYkfNSPo8CgNjnkTiAbcSJYIyWDZY7YVf7xr63 +MvEPdPrU9/8pgWE9k5E4L/7W49udJVKAzhLibIZfN/y20O0Ohga4Zx27BjKhLpwR +bzh/aYre2yvsZ4adpXNkjMmaqdirFtS5C35Zg7Zj/vCxS37iXrrKiga53N4ws6+d +0cIf7vJmsvbU6TO38VKwWga6PXNWk0sJi//E2OuBS2lEQTcXrhPxppbVNDSnXs/Q +5LfGFNpCxGRgk8M7o2sa87jy+IFy70sBGYUdpAnwx+E/axyYrBr5i6+Nl51Z96dK +QiPbz3igCjve0f+oLO/Zz+u36gsttkFlUYCV1OZnQ1ZSBdw+OS2fw/9rLknnUiTK +ayq/Rrf83NyXOD5E6jZ/FQAHethEmI4EU55iSgEEAMi63SkHZmk7K/SE21sxrShk +wCExuwH5XfztE7dklykNG2Crv7pRuZ5dMslXvXnjdm6JiEsZPtNcBQFFfSCNdVyj +s0EGHTsjsuFmNi2rDSndzL48juzQ/m3+34Tp9sTztWJb+J1BJmEUiehfEZvBvkAJ +bA/GfagCKk19sQXdn4J9ACDbfVzRiQE3BCABAgChBQJXsqAfmh0CVGhpcyBrZXkg +d2FzIGdlbmVyYXRlZCBhcyBwYXJ0IG9mIHRoZSBFdmlsMzIgcHJvamVjdC4KSXQg +aXMgbm90IG93bmVkIGJ5IHRoZSB1c2VyIGRlc2NyaWJlZCBpbiB0aGUgVUlELgpT +ZWUgaHR0cHM6Ly9ldmlsMzIuY29tL3Jldm9rZWQgZm9yIG1vcmUgZGV0YWlscy4A +CgkQM43t5aQTWzgpqAQAvNsSYdFkVCr7mC3nO9Bw3aswf+9GuyJXo8L7tSQXD/jY +KR4IoqnEHJ+B/FIhylJaswEVrxk1MJxLr4eEaplj5HCNIF+2fACrLuXW8aCgUc5W +dHUwo7o3RxEFABS5XDUcPhTuYDxTZ1HUfAju9DgLmqk+cA8doUqXkrdQ/InYyg+0 +J0JlbmphbWluIFBldGVyc29uIDxiZW5qYW1pbkBweXRob24ub3JnPoi4BBMBAgAi +BQJT4CBqAhsvBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRAzje3lpBNbOODy +A/9z0Vw+/hMMMMhdnXyvSDNHMm3deWYg7ilgN1b4eeTJvRxlsHAj4XeRXXdnMMVZ +GVDOwr2MSux3y7OmmybN0Ytx1xGjXj0RRJoKVc8bc4xQgwtMNoGdE3GhaGkocqiE +AUA4VZsEJt/h9/OP+37J+KSGNIcEvJ4tKW4m27hlWY7hhIkCHAQQAQIABgUCU+B8 +eAAKCRCUVWse3+lAhL2YD/0aBu4YanCy1Vwt9UCKZAZuEtc21K0zftwg8iqANXu/ +W1UJD7Fz2WVYHwvmR5Z1ddRvwNv0KWQdNJuMu+L0t8lDMSKV0jssZ/6hOLA6Zlq0 +3h5vK5soqgcxTRxLCSSf17AiHOpH+15K3D+FCGZPkCTsEQs2UfI87O66N9Q/m65C +ngnzbIm5D0CSfDiNrNqNZNfOjMSEEY0pu75WraIE7bKTEzmwiL+B0grsdh+zid3/ +/1hadq0ycxArFItnnwL/J9q7244VpMcDjorUkNhAKxaOFVns7/RRFMriZYmQdCPV +vJVDULzXXMKHGvbz2aYco2lMuV0zibTYTgnJENXWSdViQ1Wb4ilkOlUlnVMdI4OY +0c/bnTxOjvyfouBCI9v158QMwVjZckR6p2fsbzE943Lg7MJVriSonggCWe/faa6B +4GqXtZrcDp9vVF0ZL1BmSoiC2NCT01rSdRq2DfL+4RwLJpbiTvWT9lKT/x6bp8HV +EHnN5lmPVnrY1hQHXNvzynAf9RnzWgXchMAWOXysXHw4p3YZws4vay9ZFkT+d5Ux +VgAo5cj0r4T6bPDMs2SmZomZ9whLUDDidacgU0FDcNTwUuUuXCDNPwkofyUfTET8 +uRfJKkbBW4Pv68cMRaZnwqjm21Nr0LrGm6XlhyBvMg3frKwZeQ0TWya1kPIdhQHB +JokCHAQQAQIABgUCU+B8eQAKCRD+WfgTp0sGv6ksEACC+b1O8cz8GsVD7MK+9Ql7 +O+qCss7EWh739gQkH6dRzyV3/n13xz1vp9QcjXsu1bNpv7j3BmQjjAGUhjJe5111 +t0784KfTj3HAQ8YORy56OhdDIvqLF4131y35S72icdO9wPtVYymEYdqQO/u64qck +3qTkU2OFeMne6wQXg/6fl+aDxowQ8Jv8az+fkHxGBWfXtuXcVSQbjeaIxpEC4Nsp +1Hg4uS5I4wOwiH67R82WRKTxLv05135NyPJNxZyhYSPETBB5/+ZthfC8wIDA12ch +CM6axRLPYs2/WorrFePMi8iLiU43ulVWKertGJ1NjimsqVMfvxm5Pi3FCnuDJ1NI +/aYDoG0YHbOrfrk/gPl5gx4tMmE2wpoEuJ6BAcT6L2HB0OwBXjccVXMBbrYyf1mf +J2lQ9HFsUozWA0WZxUC3Iuln3AJdM18dkWrEHeLJ/bFQdX8AB4BqJ4YTNeQUWrXT +/b6NOwvuWYb8iBv9ENyvrJLbF3Se+uu9++AnwgO+yUUy35BTzNECSsZiPlXVgf94 +MEgJOdCVJ7lKFsOqCmYkwx1mgyfyuIvblaT8LotMr9gzA7jPlp/MpBAGhmN+sTLm +gSmuMsRN5cGOG+ouanLyu7ic8bG9UZXVcYV2Wm4ujTIGegQHHKbis+8FO4umQMFz +jfVi4ER+l3lldw6KQiZE2JiNBEqPYWkBBAC6P7bDppabe819d+pi++fxn/6M2EIw +njndIM/fKFTJCHjX0eBU97K2q0sp0qBs8miczMdNgj565kyUU2Thzz88rNkIdl1W +1kClOD3Oo4cjrwQto8+bfhLn2HGWcjMI+Vz5xzjf8RB/z79LllViiLnZi9WSTg/p +DNR06t6tNugLRwARAQABtC9Ub3RhbGx5IExlZ2l0IFNpZ25pbmcgS2V5IDxtYWxs +b3J5QGV4YW1wbGUub3JnPojQBBMBCAA6FiEETzuDJkvAyZ7a2/kf9fQ1HqQTWzgF +AkqPYWkCGwEGCwkIBwMCBxUKCQgLAwIEFgIDAQIeAQIXgAAKCRD19DUepBNbON0t +A/9TDeUj/SQSpveMNAm+HYFGEpMWWG1PwOvweAU8pIDwKZr8XOkRz9BxEsG+Us09 ++fSYUZB+AJDp8ZPJniLfytzBXwS4CBX8mZ+wKaEAxWejDZ4ZvXRtq1nJf6CbirIN +ioT8C3gshh0FqOjjg3L+PMuq9L/0PkzjiMR7D3DkWa19CJiNBFh3l9ABBADJCM6G +rjy6p49B37DtOqAcQDL9Hj7x1aIkBXYHy/TaFz9H1N3ZacWySi7xA/l5H9r8zgqK +A3qPnjqNNLw5L/VNDz8fgZX1s2fP5Bt0F1ebVXmgQ5gRjygQi92DyUkfxSnzahp1 +asiofxqOKluXzO32DxlRMLUzn7mbFJ0J/v2z+QARAQABtC9Ub3RhbGx5IExlZ2l0 +IFNpZ25pbmcgS2V5IDxtYWxsb3J5QGV4YW1wbGUub3JnPojQBBMBCAA6FiEEOj6D +ydsj74teXa2+2E4X+Rit1P8FAlh3l9ACGwEGCwkIBwMCBxUKCQgLAwIEFgIDAQIe +AQIXgAAKCRDYThf5GK3U/+YYBAC4Z17ACn8XQW8ozUjQICeNIs+9cgrKPwBJ4xYG +hDsJxQClcd/eYH7lpsO1OA52PHHTDnkRo1LZ7yRwkuUTDxm3fwtVeR7YHHZj4Rph +RKeZCOiSHaUkhDyoShlV/mNtlWw3HsGkp6v3NXL7yYtgtNlS2kJmmWsg8Va7lRet +Fx6P4JiOBFOeVesBBACXj8SBAMC5hzlWiUxNPlUl3W+9v/somVa1HkJJcXxgrl53 +MnV+r+bUqrKBwapQ/0KJoqN9AvcQouCYGYJUtHlPpDaAJavKJJP18IlKYvTgZ/Lj +O9rO3wpfmWGXpY/M2m1njZAhgpJZ2mZHJyfBX42jCSHLacUMeRJBnl6m3VZsawAg +lXk6YYkBNwQgAQIAoQUCV7Kgc5odAlRoaXMga2V5IHdhcyBnZW5lcmF0ZWQgYXMg +cGFydCBvZiB0aGUgRXZpbDMyIHByb2plY3QuCkl0IGlzIG5vdCBvd25lZCBieSB0 +aGUgdXNlciBkZXNjcmliZWQgaW4gdGhlIFVJRC4KU2VlIGh0dHBzOi8vZXZpbDMy +LmNvbS9yZXZva2VkIGZvciBtb3JlIGRldGFpbHMuAAoJEJ5j6H99ncjSKmUD/jHo +fk6gGueMkbwR3Mii4uRnT2SyjXHPYYC6hV87+MC8Ax9t5Psx4pZJUw6Ne0L1vPxt ++b14ue1p8un89RH/CRBItOhhrwhkxtHDZ5+22MpH9GHKaeWDQyQhQ71oQvqc4WHA +0slwql5Vzr3Osc02hpRPRwbPPljtAh/3P8AT/vw9tCVNYXJ0aW4gdi4gTMO2d2lz +IDxtYXJ0aW5Adi5sb2V3aXMuZGU+iJwEEAECAAYFAlPgi5AACgkQAguqiipNF/7U +pgP9EOJ4dl7eJJ/JVbt8td5sn5kL9lk4ampPGYfk5IcK6M+CTl26UmggfR0Epxzg +AZXBn/PUq8FiWb8QZ0LYlMPA2NMwiKBMLfC1t7v2Kk07Z2uVnxDeo+91d0GI29Q4 +QhvU24Nd+dY61az4R4ReNCgrGxwgi1eQW/3GXrLtnWYfNWSInAQQAQIABgUCU+CL +kAAKCRACa550HUXGi9SmBACJCkRgBJxtaCHktGBM/K7Y9O9CWMOkfZreY8MZQp7E +kWsvxpa4VPa8SoZIXX9zHar1Ai+qxMw6DYMYHcXm3+cF9AS5PY53RF/Ubrrc4PL4 +SQMFL1WE6zknb56Xx7o8pSX6EglGhjhDPFoanRy9tgokzlaS76h0ZRuE8hMsRtYH +6YicBBABAgAGBQJT4IuQAAoJEAUiZYlBxukw1KYEAMCJQCclRdkKdEUuLPbl3JK6 +SpYRsHnzCniK+8ugFlG58hpshU7n60Gsv4PYVJ0ORyUT+hzYOIKbs1Dz8cPBK6ju +2/66m3hS6nZZQznai5Dd/m2Fhxb7BJEiTm2NIUFkYk/I9AuWLUXYZ9nNqON1YDEd +0rLez92Qv016rhQoOfd6iJwEEAECAAYFAlPgi5AACgkQEbPeiibaRoHUpgQAis/l +MqSkMcjvbrx50t9ftOLEuXQ0kjxBQg8ICr/jPp6JgZEqW/YcNXavJfo3AoHcUoPB +miLm49CqSpE9KuF4cR/AsXTxz69g/OpXqUmmLGOQUTImddG01LuF5XVuB4jpd5DI +InN1mBnhJw9ftTzkIm01u+SNL7exnvVyt8eUBCyIuAQTAQIAIgUCU+A/wAIbLwYL +CQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQnmPof32dyNJMNwP/Z0AP2aaBBKeB +gSb4bn2v9CyXNNPRZeL7kA7At7UEBopHGnR69DMfOxy/KcHpOnAqZHvaqBYIs8Ge +UYj8zf9L89VgL94RzWn0NkEqO9agC/I8rs2p4VImem41BHKtCd2EuGeRV1VuU8df +hl+40slUNXtyqSzP3It28bg5xWFVZdeYjQRFbX/xAQQArKLS3xk4LpuQGsV1CKL0 +MBuzBPbRdDP3qS9eNcvymMFg35G9+IprGYuc+Ue0/fQGpagbVfBj5NBJu3CHB0A6 +FAyfkWRKIeugEME7Z84SEoPXsh7JiYvqvXMrUGbbGHB7f3iYUS28EsB2mAz+wgrl +9fG0SuezI5K6Pm2KxZQ5L1UAEQEAAbQvVG90YWxseSBMZWdpdCBTaWduaW5nIEtl +eSA8bWFsbG9yeUBleGFtcGxlLm9yZz6I0AQTAQgAOhYhBMH8rqvCHFTAMSDvaods +zOF9ncjSBQJFbX/xAhsBBgsJCAcDAgcVCgkICwMCBBYCAwECHgECF4AACgkQh2zM +4X2dyNK5uAQAoR/NCijo4dyPLL39gRhcUK/wpdtaQLFNJg4k10M5g24eE8ZTV6Iw +9usRDjITzVKH26DEe7Er0a0Lj4kJ3KCBg8wzOaI/O77lqZfOrLgYA4qQynwZRbWp +vrBmPVMYAagqOS4YR5l2x1hkp4ihq3Tl+gmZ+L82rs527XJLgbmOFVSYjgRTzaAa +AQQAoF6LvB2LCTyOT4E6gBMmi0TD1f4NBv8JA+E5kMfXQ4FsPq+fGEMwywColOUs +phUtFAj0qACn7URMHXfZIPXJkZmrRmL0NiAcnrdCdXTHsGbOmAPxn7EchlwKoL7F +CYwuwdXKeB9XAwmaX/AEVOXB1cxJqBTuHNC1U82VP+H5qUMAIIWrOGuJATcEIAEC +AKEFAleyoHmaHQJUaGlzIGtleSB3YXMgZ2VuZXJhdGVkIGFzIHBhcnQgb2YgdGhl +IEV2aWwzMiBwcm9qZWN0LgpJdCBpcyBub3Qgb3duZWQgYnkgdGhlIHVzZXIgZGVz +Y3JpYmVkIGluIHRoZSBVSUQuClNlZSBodHRwczovL2V2aWwzMi5jb20vcmV2b2tl +ZCBmb3IgbW9yZSBkZXRhaWxzLgAKCRCi0N9iNlgCiNFgA/41iZkWn8uM8MyXfgBt +rDNcV+nf6mX+L3PYbirTFvmIWxXQkMDVyg6WHYhzUI7upkr+stYpGg8/dpeyJ2x0 +WW0SbpVoRO5VXaarpwCOFTbvYF2ue1wPrYyIOjFnb5rkRna7a5tHU5UHydMmXu3/ +cf6PvIvloDdiFPZ+zYSPJZMAKLQ8R2VvcmcgQnJhbmRsIChQeXRob24gcmVsZWFz +ZSBzaWduaW5nIGtleSkgPGdlb3JnQHB5dGhvbi5vcmc+iJwEEAECAAYFAlPgjBcA +CgkQbARs04hpnLDHPgQAuPfaHNdvq2cQ79LWPBOW6RkAIQRvlKFPfFJtEtvqKR2n +Js4oWK1dO2wxsUt0Ngn+Ry62G5IspkMSXzLvpUFjo7fc/LNatA5mx+gbONeANuOU +dHyXOz1x/525vt4QDeaPgpRJJKtF6sWcAc2b/uyDnQdb1lbuU0oSgcvf3SVQEFSI +uAQTAQIAIgUCU+BJMwIbLwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQotDf +YjZYAoisNQP/dTuMVncISHY+5P818X7vBULMlCkRlmz7hCcPz4QjKeBjqXMPsUlY +nHnwODe8LPGsas2RlZAw4lpiTQjREpc0BnIuzOPp79dqdl9cgJaGt2ZoHLVttuWH +8aHGd3St1WUZFwxTePSXxvEM64HM8TIHixwu6XwamAX0e/E2XobVUwiYjQREALqU +AQQAw16aT+Y6G/1d3S/hw/nIGdil64NLcLjV6bVf1+G8741yoNuMVeg4oErkHZhY +pvlAuQ84Si5yE1tTESMu+/b3PdLZtaFGej/6t6dUx/ui9c9JRY8VgrlIPwdqTnpS +OjnaqjP80sM33uG92JCdv0YzgqgZFDj/RCJnKtWIxxy/chUAEQEAAbQvVG90YWxs +eSBMZWdpdCBTaWduaW5nIEtleSA8bWFsbG9yeUBleGFtcGxlLm9yZz6I0AQTAQgA +OhYhBBL/JMe87hroLsOLOg9yMtA2WAKIBQJEALqUAhsBBgsJCAcDAgcVCgkICwMC +BBYCAwECHgECF4AACgkQD3Iy0DZYAojf5gP+KIol1aoPtzA9WLePBMNt2ppeM2zH +0VtOQfxBCs8oylh+dsTM3BDh7BjcSLxp34+AMOj9QVGxetGZ098aaHzBoS7wpiug +hxvDQVeEOMCvcsjVHBRixiYK+RXa6Eqgrld7pvK6mOCZt8QvgjNIqFb0/48l21UM +XrFxJ7UoZnfD1i2YjQRMus3+AQQAxz4CdLPxK/7B7qy9vd6br1gR3al7vfKy+zgS +HLFsggqmcNlzIObWnVU3615CTLlcPLFgGkGw4mjC/dqENNz7U6azJGeDR4mK0y4P +0wajt4QpSDGPYqnsclJy+MasQl5tExV1XCWHy196FbPrSaKu+7n0w/0Y+iZEXKmJ +lEdtTKUAEQEAAbQvVG90YWxseSBMZWdpdCBTaWduaW5nIEtleSA8bWFsbG9yeUBl +eGFtcGxlLm9yZz6I0AQTAQgAOhYhBIypju5v4U0R3zdpSSeAHX5qRcgWBQJMus3+ +AhsBBgsJCAcDAgcVCgkICwMCBBYCAwECHgECF4AACgkQJ4AdfmpFyBaUYAP+LtYU +xl6GlKna20lfvM/Thng2sDYVUPEexSycy7Li/2TShUZgagleiZWZBUeyXSCp+03b +1G0wf/yruiEv4DU78oiqHwizAHLAirVdOxL9CqMzZO7KEC0R+M2OepyUUJVnlfre +zUWvMKF+Z181IQ2K0H/6D9YyuYT0+ucMH6KjPu2YjgRTnk+7AQQAzQBvKVGcDazm +lC7HgChSHRmmMDqTN6cGREChDeTlV28xOy2TeTnpgHTAl1vOlM5r8bIAw03ysQuN +A0WNXKDKh1iVEkCaIYad8i+5ILmxH7RZ5yb7Q0Ib9DZ2lW3AiorEfFrie9CejRpT +M1jzZSymwGCbmpjDHA0xp8lRWQA/zFMAIOLUd0mJATcEIAECAKEFAleyoAeaHQJU +aGlzIGtleSB3YXMgZ2VuZXJhdGVkIGFzIHBhcnQgb2YgdGhlIEV2aWwzMiBwcm9q +ZWN0LgpJdCBpcyBub3Qgb3duZWQgYnkgdGhlIHVzZXIgZGVzY3JpYmVkIGluIHRo +ZSBVSUQuClNlZSBodHRwczovL2V2aWwzMi5jb20vcmV2b2tlZCBmb3IgbW9yZSBk +ZXRhaWxzLgAKCRATwhXAakXIFqMRBAC11c2HJ2a51oVil371fACt/WO1MD/Vwk6W +gA9wqBsNkDVYMBNFLjfF+YcVQpc8xuh/dHZwBbMd12w7NczxUbvOcy0eqXEHTKG7 +a4YU3eOBcPOG5vHPm4vTMKiFuinZausPmVC31yCo7mUOtlhDAd1PXA9QtbFE7QDr +bJ3R6yfMALQpQW50aG9ueSBCYXh0ZXIgPGFudGhvbnlAaW50ZXJsaW5rLmNvbS5h +dT6InAQQAQIABgUCU+B3uAAKCRA74bi7MLlLXInUBAC/X1z2onYWEMt/fSNSJYyK +0dSW6vqd5aZPH/eR6INXlMJIiGXcIxnygHwzH3BEEYfhI2oiMztLlTVW7QFymMK3 +BEP05uj5wBuEZl9RCVku/sYHZRFMSuxcGEM5Cn6OAEvLtVz8zaw14wrQvtsf6OZn +eZsepqxJul0Jfji7cDbXLYicBBABAgAGBQJT4He4AAoJEFdlTp4lHGXvidQD/3jK +natl6Yo1GXwxrHNV+gNPXTvS7h1TAhCdn9NMnUpz/Q/izukFtaUjx4ZYMJDA071J +1iVlnATJcolWKWXawI9CAvypRuSaetD4gmYaukFjEhqduRw6fsOI/TYlhBVY8G5z +kwO79O5TLQQhgKRyibXvm1wrelMmudN+rNhS1XI/iJwEEAECAAYFAlPgd7gACgkQ +n7q7OXdq/hKJ1AQAharG83xBSDL2QJ35pTugdDwBYRLBXCNl4xG+iAqRUZ8KethF +s7TKIA6RsR9cen75aRT3dxp44F78fh5yelMMQ186BFMQi+Qt4HlkEsZFdGFtl0Qq +O3PVhJ7wi4b+lSR4tOKHUyJLEFj8TEmHtRWGMSihVsITdXRoAblKxor48mWInAQQ +AQIABgUCU+B3uAAKCRCxz8ox1wqv+YnUBACzLxjrrkq351SvtRIlPJYtAfewhisM +fXZ31lq1I8IWxRAG9yz2Mv8dLwP2C/YI64TnJnAXd7ZG32fyuMhb307SeNb90EkY +w7faLcqqP6KOBo/kIGp0SEE/b53nShAJpNJNWSse0nLAvKKYvk/h13C+8Szqnqqw +TdMG+Ji/US/rSoicBBABAgAGBQJT4He4AAoJEMzFweFkARqLidQD/2Rua3bNUSR+ +W+WJxsek8pY1MJYYyi8zyCkZRv+8wL4VXMGl6Vw1gzecrdWEajPqVnyZqus3yA0c +JllTlVIm1NbqMWZOS/RNvZGJvlds6/yRq9dsG40xCujGR3b+nZ+P5I078trbVvKJ +/BEHuxes7QlPCCwDrvgdqesJH/umUibhiJwEEAECAAYFAlPgd7gACgkQ6jHThmX9 +ze6J1AQAtevC276cP3wXHHoRvX8Xr7w7k8Up1mstL5ynBgH4/kZKN9nCXnJgthgS +jYPeB8qYEg0PDgfAliorbrDztEjbKuB0e8VUzEtkNwzHs4NDZiMJ0o1D6VN6jja1 +97QsO2yeMRBN+Vfr/rwjzEWo4dIe64Ny8+rwAT3wWlJwiZLHCOuInAQQAQIABgUC +U+B3uQAKCRACaQhJdOC3ZiWqA/sGlXar/v1R+SJpa9Yaz1CYLG3ljE1X1hFvBQS0 +zm8+UfblGqnMOdvJ7d4m5i9YCX5/MXXXwQGtWR3O5udxK6SDH/DbOvYS95ymaCXg +Ml9bnHrX6tT5o1PtKRAjbQJTfohDJQgIvE77EAS+kGN6xM1NgxYBH1dzz72l5KoI +w21GT4icBBABAgAGBQJT4He5AAoJEAPFNsrJmHCxJaoD/Aj6ID/yBqBjhhyKwFpm +FcMb9HUfigYrMqgsnK86bTaTYT/ICBqTIPaabYnLGtZ37BPbKfY7qhtKCm2CTRyT +3oZAxgAFkShNqt1GZO3dDc7Ym/1y6mK6rm4MLQb+YbXb6L3azaMRqp2BpMOnyQfV +/ECfe1zB0EbfWtmiH52SqyFViJwEEAECAAYFAlPgd7kACgkQBSJliUHG6TAlqgP+ +K8o4euFkQr3PWBLR1QE88SUXLseWAhQU84jpD2onrVNiva5YIR/goeLb4w/nlRMH +PzZ5wl/8Dk0HdZuxydFk7ri1kfbwzgtWShe9ODPlM8fxq6ubRYQBo9gjVEymsXWK +Ur0MMJv9ZdY6Nq2suu5FCP8xFE/G8GHKoP98VMLQ1OGInAQQAQIABgUCU+B3uQAK +CRAYyW5NRbLXWyWqA/9UHM+eLtWpp79wHS/DPryCrnjxnZXvQa7Fs1LKMDg+3/eJ +WWQsISnDcAQYLLTbLU/sar+2pZx93ivQbaSNfOorSOIMq58FDcA8guD0i1nHahN0 +6sZHpNV2G9gwyrt4CJx0OPUNUbdDciIevOt8lsZpkW1XmEUloDTdmLQau+Jeqoic +BBABAgAGBQJT4He5AAoJEBw6VCVIH0S9JaoEAJRsrh7Z7oqtHIj3a/jXTzeyXboT +ZBA8KN7hNGooHUPcLAfKflUA2vvZpx+bSw+MM4LCrii67AuMV5AVfKeod+5vbRar +ul7RrOZKW2L1RwoFyfgyn6Fig5RJKi+Q3ieYFA/Zmn6lRwsFlpPEqw4xJ41082Lm +KTRU0eS2SNvgWAPbiJwEEAECAAYFAlPgd7kACgkQHbXgucbOoMklqgQAkfxE3B9e +FA7AwzWamHO+EnDzlfs8XO0mIU/bj8VuSDmiQGOtlJIuinEOdn+G/6rQ9ABGCdoj +KYBAb3yYhy/Duj3cBaWEjPxfdx252mll2HfTsHjg25j8wCUe+5LApvEk4W1xCTOd +l/X0JnY5omuf+5Mlh2wnFmuDdXwu4pyQy0iInAQQAQIABgUCU+B3uQAKCRAh99JS +56bXjyWqA/9+GHqalt40xz2xaNaprWHzULHqY4NuL7eqSUNBhPtT4i64kCQtLdtj +XW8VrJbM8n8NNkQTHfpxP77Zmil3ni+FOnkZD3sF68l3JyIp7LcEapCIRlpEfRw1 +CkBmROBAH4+B8NPhMvA9aMKzfqAj+cpAIWYeXC45aeiiRmXfyniH7IicBBABAgAG +BQJT4He5AAoJEDQeTYLdTVCIJaoD/3uW2nrXYQwScfeIbfQDIYu7xFW9J2Ct+S5T +OvF39AWZRev89iMQlVQaBpeCJaTg6p5A4T0fagw+UKyel8NcYQEID8TA3wAp59Vj +5k9adtYrZIXHMgvFz8uMVoQqiL+CmfgeEL+fu7x23g2UncNR9EvCqKjxAK7VtKjT +dglt8oCMiJwEEAECAAYFAlPgd7kACgkQRigU+kzACFElqgP/aFAf4QonrbyPAmdK +hYoqxmqbnk8FdPN9ISx2mztygTAkiBEDJdpgLRoNO9zdn/gFvX+PgnSQRUueJx6q +nXmeKHGaKeBrVIvrZytuIk9jiPpBzBQmqlt0rXriAdPDjhn87iNxIqhS/tvF/PnL +I0NGNaO5XJZ1sdWaXXVZnd7uVSCInAQQAQIABgUCU+B3uQAKCRBL/5EdoCEv5CWq +BACPZ5FNKnEPeFjSFwIeKflS7YwIOKTUghBUrbh4vNsRY0gein7T2P5wRIqmJD66 +jBb24BRX8O8jiXHQLixUdRQKxEfClcmt15KccmvHp5QAI2PkfzzWOaXb0fGcHkWl +pB1HGsm8lhf37y8mGtGxfw52ULy451ZAk459248ZRgTFpoicBBABAgAGBQJT4He5 +AAoJEE81mWFC4sHlJaoD/jV8KUG/vvqd8+t0PBzA91xSZaeFI5zRF2nHzLuAF6vp +zpC7NVuK1RA3aXwvC1mDx8J+4300QICv48PNBb1hd9fQWS3fXIlHEqczcX53W3wP +vgWH0KDj8nGtcj9dOi9New8fy5ASiXb59GrB3uCSDFhVU2qHExHqp2Xf3Sj7Ek6L +iJwEEAECAAYFAlPgd7kACgkQVv7xgpHPo00lqgQAlxbXjXxHax7LbJwNirZ1m0BM +3nnWKhzR0ilZYcd6Qu0lubvVzjXoNIdQ1+JoOJuOwdi4ngVj1qOyfjJVU8bNT0MH +WbtQKquC7PsgQr+0yQ4Zk7XFIzq978YEwaj0lf0EIfUSZpzWEibP3vvL9p27kWaP +NiMkvwUhW7iFijoUPyGInAQQAQIABgUCU+B3uQAKCRBvwVTKCgrJJyWqA/4rpNBX +nEOev8AC3aScysyJ7f/FgF/YnKFwG0B7SzSVzclOrBkXYoGhhTkbV3f//8eD8cxg +5dU2+n98jBx5MIHCkn7cGt/8gyDPgAteQN7hzXQF/c2HtXIDDV4wDCEBc6qoVaDO +f0Djl4f2CodY3nVVnmQ91he2OFtjH+Pn7ncbUoicBBABAgAGBQJT4He5AAoJEHRx +BU1gdVnmJaoD/1PKonK5Ub3qi5fOv8W+80kQnBfaFy6a62cgFlJT4aLem9Sy2JHL +LuznQN6+w6cq+5hTmjpGnmtTR0MH/3Hp19TNXUcCgL3rs7RFHsaLueZPfNC9wSQU +UhzTRGyBsVTB5m8rl3dwjpPefymDU1SsYUxzxdu6W9EvaqJuaEgoi3MtiJwEEAEC +AAYFAlPgd7kACgkQew0c5xD6TNElqgP/Qcpu/Z0+NKn0JUSXMLblc22q2+evwgTW +4zVvPWy7/zPlUCEXMR/qpRpPuoPdWIwynxKPvRyY8UICtkWzFWIHCmCE4pyiJEJ+ +ibgB25SKiBiNcM64haWcVUuIp6NsmxdDZa2qFPa+MFT7w8zxi0F6+cGQIAfFAti6 +DU1yI72u3XKInAQQAQIABgUCU+B3uQAKCRB8kAoMqmq1yyWqBACV0+KNv43MbI/z +8LM9dJhcWGuyAHD5CAqN7OdnZ/gbYsg80g9N6B3I4wCzQ0GEhXieTNKoDAksgFJ0 +o8dfb1HEhfG+k5WeTTjGcqSuAy7ZSTOeVCrfZSSZ76Mo+JJDV96h8qOnmyYyZ4Fb +pNW5/U8X8of033fg6ysC5Sa2aFHb64icBBABAgAGBQJT4He5AAoJEINXgRW6xjdK +JaoEAKyjPC3++Zku5sK9S4AXsQNda1BIG7+fg/M67DWdOgQj3JX4/Vb1XZ5Z81/7 +AVrQGOXLW8v4FcV9+aJvNB3/zmGsJlQ8d9f96Z09DoQhRA6amNUKbC9g9f5mMfNj +RS+4BypTxP5DG38eoZnKh5wiDJ791APFY6joIO0lzKaRZoi9iJwEEAECAAYFAlPg +d7kACgkQrgtU69JvIlklqgQAznyEkm+8KtEa+aD8GAuVlI/ygesHSQH6ukS7DT0L +zHqYCORckdup8aS0rXzvnvfqWYVSTmtUMYLaCTK7e4Y/jTbxiesN/6dOY3S5r3jn +ocvh5ZhaOiyFMTB7baIUqSLUsONQ+kaNityQUIiRuUHZUYcWSmo+aCB9konOKNwO +Hn6InAQQAQIABgUCU+B3uQAKCRC16sERP8wqkCWqA/9DmGN79/9SkKux3Z/3IFIL +LRQ5oXekuXi3Un9TOOTgBDl4cIEkRfbr+76pT+ZmIhCNaoxBfkOIId+CmkPuPR7n +PeTEeiQjZQ5TRefKDi7riQnaI+sOAHpZpvqBBlmFnuvsVP/tqhO15O0o3grMu+Zs +EYdqBIM+4JGFjK2zJPJsiYicBBABAgAGBQJT4He6AAoJEANP1Zk7fhbhNjwEAJZb +lVstwnhNak0OOjjhJz/yzkIMYxVtKR4zNU8diZT21r2fzedYhY9YePZDWCr5GNgC +ZK8GrhdAir7owvsAZOiwBehPBdfnTEpxzMQrRw8dBfHdaxq9OeeV3/g3uzQm/4AS +RBXofH6UcUCygJS7YDSLcne2WvnvmfxHWXlIXs+ziJwEEAECAAYFAlPgd7oACgkQ +M63afsvsX4A2PAP9HaGSqRWdy48iVrNxz4SuoFTQQ3xwD8yKjfQYFqMO8nscKnOF +jrDsvdWaR52B682SPxov56gIUsNtbxR03pQn3yZfhmWBzrp9NUdPzd4ab21e9oyd +ZccAo+Ln/3A31jsEGJY0W0k4mbdocTBD3jJVl78T0AeVBhDr26bVFQoPem+InAQQ +AQIABgUCU+B3ugAKCRBO/QnsotBpNjY8A/4p6CaDOLmYfbS2tSbrqOCzgb6Ubciv +Y+LHfiZzrDfJfDpxtSv60t/Eff0ZjDirCVGN72H8r8HVqjKDyUKhR8C3m6445G4z +KyMzLVQIxjzykV7JKz7az0ob9iaPTBDP6mjexgB8nKYHqby5IUQlcD5reELNapIx +eCq3QAJbU/HxZIicBBABAgAGBQJT4He6AAoJEGbqkIGeN5/GNjwD/RFr1wCdk7Lg +2BluoANNy+OVdMlmZX32mvlY7lH4m51l12LBe3eh8TDYE9M9/WzIBMCHriqAwqk/ +phTPiBpuqRmNPIly54u5g6gyryjndCbdfnl8yDL9pW17ABtXdjomS5CVQLS82Pgn +s0cxtv5O6IhVOpaz6HJFcsHlKDW9u6/5iJwEEAECAAYFAlPgd7oACgkQb3b9h3S3 +xyo2PAP/deV3LNKKoObe78I6u6tQLCpY18WmGQlxUXC81heOnHK/BNhPjobGEVeN +7O+ruP1OZbxLLMyP8sToPtJcJGx6P1cIqLEG2yc4p0GylK87UDcjENaCKvwcXBE6 +Nu7eHJjadKf95orp+OYEH4OKGgZ7GCQRYad1UOoO4Ja0mntEOC2InAQQAQIABgUC +U+B3ugAKCRB0w088/1LBUDY8A/sGPleHIeSdZM24FV4mm7wm9DCD7YXoe8ky5jYL +x+Ri9BBwwtbxT5vYh80lhpj2FvD76dr6qhmwYOInAd0x1X+JlvFFpeI4uheWa5Rl +nsoyOocXexKW9gN1JuSzUHMMXAYQPETsa8mk449KTbre8axNEur3is9mTBrxYYXt +qpoaPoicBBABAgAGBQJT4He6AAoJEHzQzisuRNPKNjwD/jHrHkF2BRYJwPO/eC2T +ilYuWdDOrBJmGQmLAHx74V6fKrI2EKAuivQnDi4WYAXg4C8CRO0lga+GsLpDBrd7 +TbWnTSjJbqgJSb8gLXsn3NlkqiwTyGKSjFQyZi/61s9TdRhBepA0JiuEvy0FMH9S +eVA7oi4xrPLEwzOSkwCg+a53iJwEEAECAAYFAlPgd7oACgkQfbZ266Cz6Is2PAP6 +AvAEzxIS2dCvnVHmiTYPTLDNwL/1q7uPP9/7letfzOo4yS8uo19GUMaOH5mitC/S ++y0lTVLnmGCm87S46VjXTdsBoNAjbs6iz8hhMMiQkDwW6SxdL1vZp5N+eEYHykBh +cpzEvybuxKLh9EUMaej6Szo0gSlU0O32hDr/Ja7Dl5qInAQQAQIABgUCU+B3ugAK +CRCNxg3AUIJy/jY8BACBtFFPA7D8rJj2qbPq1jR0nS4NPD8N5nH44NkrSHoNuusy +1jeNEmWV//Ir5NBA8TrLtE9Xe/A9WAyVOUB2oXVjNH3FlZmrYUUD0ht3XV1YuPc+ +H+GiKckKSQ6qB/ed6qh6+ll+0slR7+Um+iHG1b4+G5h5b7qM8eRcjMrik2SDeoic +BBABAgAGBQJT4He6AAoJEKPJSSZEd54YNjwD+wWOtVeBI0RjIiaQmQbgd9Yin2kI +MkizuiBtyUGfWerlWbiZZbss6c1yT6YosFP3yU2yO8CuDzU3syy0QI9eb5959Tqf +8yH5zJqgJy+bgPl8lq4i5aiVM0W7gNQeb65mu0MuG8YUneW5XRyWRyP8wZ62gswV +7SEx1a+iHHb9p3I3iJwEEAECAAYFAlPgd7oACgkQsoiKePGi3tU2PAP/ccj9ocWg +N7mx+ddDYMSA1/AXeWuqW/YE9nuvWvSPmAI9k9hL5PSDgOvUHQDWBQ/dLFm6DNka +yKYg7wVRFK36rl5/GYuu+KE2ad4ipEeuaGLB6PKqvqC7mGo4GcaGz9GG2ZgLtm59 +lZnq3Lp9hqXKHencz9bWjhDPEIjdFDgteYeInAQQAQIABgUCU+B3ugAKCRDvRCwG +qXtpoDY8BADrrZbMrHeJISR2o7AAIo3M+Zcv7Jrz41IO5jET4kXZKj1eFCB58Oin +U/ibdvc2UTtCxon7DPqrvJAarse7W3YfmpAY+/ZcB9mgYnaepnLmPJSn9b10REg1 +xR0wcsvGz/S1JgKAVlvl0ek1ZyLfw5NCZ/S1/E8SEpC1+b9peLVBbYicBBABAgAG +BQJT4He7AAoJEAy4OWRgJtumfswEAIE7o1nkQacwSlhiQyQKLq45M7XbY5JyUQN2 +561lLQCFSLYtFo8Em/J2NBx2Bzc7ppn0mGv0s5Xof9GQZE5iOwlfXZCvSqyqD5x+ +0EXMRggTZbwFReKOrRYILMmvAt0osnqIBlUxfWRBwiZTDyigP4pWkE1LOoua3Izx +Hwb7LixziJwEEAECAAYFAlPgd7sACgkQElx5TEPiXR5+zAQA1DFleu+RKijrRQ4Z +5nc74mm+P9b6quAD0KeCE7pC208FKQJ36evf9+f555gq8wgBFQ0sIA+oWr2lDZ5f +EtL/mx3yiNg0uARUGeetyG0ma49GiVAcea6AMjEpR3Gep+t9tOSqD4OMM9w+t2JT +El1iI44xj0TU9i5Dvyz6to/cZSiInAQQAQIABgUCU+B3uwAKCRBixjyNJbzVv37M +A/9/C0aYe6JHu5JsCS37ZvDo5LD6ka/zZu8Cvu+EY6yEd6cdl5OjQrN1O0olxE+l +lFgZ2EcgjJ5yUE4JS9BQkNNUF6jE9na5OCvqm3YBysZ4zy80QZQ8P0F/G5e7nD8c +ro+sIDqNONfcmQUaYCSec0kdaJ0z+b+G1xjgYUF7QPSyRoicBBABAgAGBQJT4He7 +AAoJEMfkV1qErWdsfswD/A26qTiGBMdvNNLDA4zTV/d+ytHgWAdGrv4c/i1NBuBE +jE1G/prEs8AgzsXe8uCLZb/RX1Yyry8fsjtgRe+Dos3i5w2i47CfrK8floqM118R +K+xsCP0fODAQPfIB8VksqrV2piHTRQiC/C/PD83ZB9NEW8nhhuP7XSPSq5WJqPqE +iLgEEwECACIFAlPgHcACGy8GCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEBPC +FcBqRcgWNroD/0gzRvGgJ2BsPd1rfNLz+AS7ww62RxqYURDc5nFFcwKf4JqElkHH +nFs8Rnmt9sk8cufq1lQORrLCspe/lbamHqA0BiXzw+FZhy7rKEwgV9hBgTgNsUnz +oFBVP7FMLzQcN1tHb+LpzGltfmyzquQupOCMof9Y7uFAgQBFbgzR5iMYiQEcBBAB +AgAGBQJT4He6AAoJEOGqXdfKV618NjwH/j+fSXNA/9C1amg73vLMvFEMScdiNt/Y +kBcC6wi2qfEKaON28WDBaZ1p9UH80xiIseKLkua21TAXTs0WjGO6AjePiKsYO8ZE +9GIKURjWsWLOGZ/BOl3/OXsep3Z1mMzB2HsUtIKrehjGiAH+J8hSlfwFicRc/FCz +DkSG4PzUCsgAWEipbUb1U6SY6nM3+CywMJTj7jlRzfbKjvCmCHp9yV9aR0TNsVVO +ycM6sdCXa2kTIPKSto/PsERCu+jrGuCqfD5b2LZtvR7/jy05NNKovHCK1YWdVYAK +Totijz68bq3ZGI/qLspUEFWcX8bod9P7nQdVd3Gqwtv7x1BcIzKyPtWJAhwEEAEC +AAYFAlPgd7oACgkQnDA80QtDeok2PBAAmVqOpV9YxU3rcx5a9ZYzRHDXUvRB7oz4 +5bijt6OQZIBfX64NxXSdvwPsNB3NYU6xTlzdRz4BrpenPJm89sCydp2iK4HRnUTq +JU/nWXVyww9xeYNxFtyMcjHS6lOSG9ne6y8sTWWMezjGwFyL4d7WQLSwkJmp1E85 +B68rVFSDEQvFcjIPknsvLnNz3u5NLGFDKK4VbvYAYSDpBd6rJS63k0jkbQPDi/pJ +04EAH2UuTwI8/VgP6OgvhYUV8Q/MA9dZTuU1WeQW3oa1/LQ3RybdpSd8Mh9QznKz +woDWf30MDfx4/ji0gOaXkj6WrNBVSy+ENC2FCHqX8BnjNy1WFTqTy1sTTJrgn3vJ +WyA6Z/l5MVKTJPN9kFdkCVf+yPz1nOfmlL04L+SH5pMl22/3XIzvfCcHAg/DHT/g +otXSu1f/YTxN3evOpl8S3MjSQe8lvreNd+C+klmQOEbRGZ3M/ZaonuVpvd8VggH5 +nCb62BZj80Cfl5ysXQQbE0aPuFciL8bg2PneT+Gc8DX6FA8xAkotaFgUkqFRHOH7 +6jjSSDk+ak7XtQng16lPBTffaDXjGWQQM8N+OI9kL48VytaY2o8LuqS1jU0T+etX +e+Q8P1MLNLqbH3Yip5Hq63SVNN5zuNqnLHhJcvfWO9Alks//z7EeB9mRlMGwYAlK +Kberhs88vIWJAhwEEAECAAYFAlPgd7sACgkQ8HSCRGNUn45+zBAAjlyfpziwx+tw +XoIREjZxVW38TLZplJd+XV/MLUp+PiajbtHcY6SAmiYHPRem9BCGu1JO51L0/Uvm +j64osW16aObJtqDTz8iSoy5kDXPNSqBAr0L6MKsnUiVT1h153r7lzc7rmGcNDyVh +V1iEZC5ju4/cgSw/9AuuYrzGRKjT6HJyHZLYNgg2D61+hTCYcsKXcyXWtDJq/88X +O9BEaRCCAtSx+d6bbqIsZSNqPMeAdtrMdVOV2d1mcntAvOYkuL5jHYutUCFBVNpX +HEIam+6F5K9GYP83ObU3rCKvlJw4OU6jbPVga1MjOP+X3308i46j3fa3sSiElLKo +KfQ8XtdV2fFIdafbJmF64X+NK9a1E2LyhRlOfmTFbXnX/bhJ5Pa+KIjIGrnpOrjo +ETaUowAnQe5reA8JyYlAx7ycB9aLMib/aHO8LjyMi/5eu+Zl/sDt0nz2d7t9jhFV +5Zd0D6I2SpaP2YBmCwEV25Qh0tmpedhFaVyUfnLQ4GV9KFNe6vzuD4oAGJB+OXJM +HXGoFaVeli3WEISlPvbRlEtreF4O6rJ3JyWq1gH+EYZBk6ryjb5Bv0SKUrxF2XDF +Gk2BFLsiAiwbElKsZlWXNexjwPkP76kAbKLW12UCvCC1M+0QlVbe8FGdCy8HH3vv +/G0Y7bwgUQIp4Al6TQ3tq5MB/u4xKpc= +=3Kg1 +-----END PGP PUBLIC KEY BLOCK----- diff --git a/SPECS/python3.9.spec b/SPECS/python3.9.spec new file mode 100644 index 0000000..dea8a1d --- /dev/null +++ b/SPECS/python3.9.spec @@ -0,0 +1,2041 @@ +# ================== +# Top-level metadata +# ================== + +%global pybasever 3.9 + +# pybasever without the dot: +%global pyshortver 39 + +Name: python%{pybasever} +Summary: Version %{pybasever} of the Python interpreter +URL: https://www.python.org/ + +# WARNING When rebasing to a new Python version, +# remember to update the python3-docs package as well +%global general_version %{pybasever}.10 +#global prerel ... +%global upstream_version %{general_version}%{?prerel} +Version: %{general_version}%{?prerel:~%{prerel}} +Release: 2%{?dist} +License: Python + + +# ================================== +# Conditionals controlling the build +# ================================== + +# Note that the bcond macros are named for the CLI option they create. +# "%%bcond_without" means "ENABLE by default and create a --without option" + +# Main Python, i.e. whether this is the main Python version in the distribution +# that owns /usr/bin/python3 and other unique paths +# This also means the built subpackages are called python3 rather than python3X +# WARNING: This also influences the flatpackage bcond below. +# By default, this is determined by the %%__default_python3_pkgversion value +%if "%{?__default_python3_pkgversion}" == "%{pybasever}" +%bcond_without main_python +%else +%bcond_with main_python +%endif + +# Flat package, i.e. no separate subpackages +# Default (in Fedora): if this is a main Python, it is not a flatpackage +# Not supported: Combination of flatpackage enabled and main_python enabled +%if %{with main_python} +%bcond_with flatpackage +%else +%bcond_without flatpackage +%endif + +# When bootstrapping python3, we need to build setuptools. +# but setuptools BR python3-devel and that brings in python3-rpm-generators; +# python3-rpm-generators needs python3-setuptools, so we cannot have it yet. +# +# We also use the previous build of Python in "make regen-all" +# and in "distutils.tests.test_bdist_rpm". +# +# Procedure: https://fedoraproject.org/wiki/SIGs/Python/UpgradingPython +# +# IMPORTANT: When bootstrapping, it's very likely the wheels for pip and +# setuptools are not available. Turn off the rpmwheels bcond until +# the two packages are built with wheels to get around the issue. +%bcond_with bootstrap + +# Whether to use RPM build wheels from the python-{pip,setuptools}-wheel package +# Uses upstream bundled prebuilt wheels otherwise +%bcond_without rpmwheels + +# Expensive optimizations (mainly, profile-guided optimizations) +%bcond_without optimizations + +# https://fedoraproject.org/wiki/Changes/PythonNoSemanticInterpositionSpeedup +%bcond_without no_semantic_interposition + +# Run the test suite in %%check +%bcond_without tests + +# Extra build for debugging the interpreter or C-API extensions +# (the -debug subpackages) +%if %{with flatpackage} +%bcond_with debug_build +%else +%bcond_without debug_build +%endif + +# Support for the GDB debugger +%bcond_without gdb_hooks + +# The dbm.gnu module (key-value database) +%bcond_without gdbm + +# Main interpreter loop optimization +%bcond_without computed_gotos + +# Support for the Valgrind debugger/profiler +%ifarch %{valgrind_arches} +%bcond_without valgrind +%else +%bcond_with valgrind +%endif + +# https://fedoraproject.org/wiki/Changes/Python_Upstream_Architecture_Names +# For a very long time we have converted "upstream architecture names" to "Fedora names". +# This made sense at the time, see https://github.com/pypa/manylinux/issues/687#issuecomment-666362947 +# However, with manylinux wheels popularity growth, this is now a problem. +# Wheels built on a Linux that doesn't do this were not compatible with ours and vice versa. +# We now have a compatibility layer to workaround a problem, +# but we also no longer use the legacy arch names in Fedora 34+. +# This bcond controls the behavior. The defaults should be good for anybody. +%if 0%{?fedora} >= 34 || 0%{?rhel} >= 9 +%bcond_with legacy_archnames +%else +%bcond_without legacy_archnames +%endif + +# In RHEL 9+, we obsolete/provide Platform Python from regular Python +# This is only appropriate for the main Python build +%if 0%{?rhel} >= 9 && %{with main_python} +%bcond_without rhel8_compat_shims +%else +%bcond_with rhel8_compat_shims +%endif + +# On RHEL 9+, build without the legacy nis module +%if 0%{?rhel} >= 9 +%bcond_with nis +%else +%bcond_without nis +%endif + + +# ===================== +# General global macros +# ===================== +%if %{with main_python} +%global pkgname python3 +%global exename python3 +%else +%global pkgname python%{pybasever} +%global exename python%{pybasever} +%endif + +%global pylibdir %{_libdir}/python%{pybasever} +%global dynload_dir %{pylibdir}/lib-dynload + +# ABIFLAGS, LDVERSION and SOABI are in the upstream configure.ac +# See PEP 3149 for some background: http://www.python.org/dev/peps/pep-3149/ +%global ABIFLAGS_optimized %{nil} +%global ABIFLAGS_debug d + +%global LDVERSION_optimized %{pybasever}%{ABIFLAGS_optimized} +%global LDVERSION_debug %{pybasever}%{ABIFLAGS_debug} + +# When we use the upstream arch triplets, we convert them from the legacy ones +# This is reversed in prep when %%with legacy_archnames, so we keep both macros +%global platform_triplet_legacy %{_arch}-linux%{_gnu} +%global platform_triplet_upstream %{expand:%(echo %{platform_triplet_legacy} | sed -E \\ + -e 's/^arm(eb)?-linux-gnueabi$/arm\\1-linux-gnueabihf/' \\ + -e 's/^mips64(el)?-linux-gnu$/mips64\\1-linux-gnuabi64/' \\ + -e 's/^ppc(64)?(le)?-linux-gnu$/powerpc\\1\\2-linux-gnu/')} +%if %{with legacy_archnames} +%global platform_triplet %{platform_triplet_legacy} +%else +%global platform_triplet %{platform_triplet_upstream} +%endif + +%global SOABI_optimized cpython-%{pyshortver}%{ABIFLAGS_optimized}-%{platform_triplet} +%global SOABI_debug cpython-%{pyshortver}%{ABIFLAGS_debug}-%{platform_triplet} + +# All bytecode files are in a __pycache__ subdirectory, with a name +# reflecting the version of the bytecode. +# See PEP 3147: http://www.python.org/dev/peps/pep-3147/ +# For example, +# foo/bar.py +# has bytecode at: +# foo/__pycache__/bar.cpython-%%{pyshortver}.pyc +# foo/__pycache__/bar.cpython-%%{pyshortver}.opt-1.pyc +# foo/__pycache__/bar.cpython-%%{pyshortver}.opt-2.pyc +%global bytecode_suffixes .cpython-%{pyshortver}*.pyc + +# libmpdec (mpdecimal package) is not availble in RHEL so we keep +# the bundled version. +# The version information can be found at Modules/_decimal/libmpdec/mpdecimal.h +# defined as MPD_VERSION. +%global libmpdec_version 2.5.0 + +# Python's configure script defines SOVERSION, and this is used in the Makefile +# to determine INSTSONAME, the name of the libpython DSO: +# LDLIBRARY='libpython$(VERSION).so' +# INSTSONAME="$LDLIBRARY".$SOVERSION +# We mirror this here in order to make it easier to add the -gdb.py hooks. +# (if these get out of sync, the payload of the libs subpackage will fail +# and halt the build) +%global py_SOVERSION 1.0 +%global py_INSTSONAME_optimized libpython%{LDVERSION_optimized}.so.%{py_SOVERSION} +%global py_INSTSONAME_debug libpython%{LDVERSION_debug}.so.%{py_SOVERSION} + +# Disable automatic bytecompilation. The python3 binary is not yet be +# available in /usr/bin when Python is built. Also, the bytecompilation fails +# on files that test invalid syntax. +%undefine py_auto_byte_compile + +# When a main_python build is attempted despite the %%__default_python3_pkgversion value +# We undefine magic macros so the python3-... package does not provide wrong python3X-... +%if %{with main_python} && ("%{?__default_python3_pkgversion}" != "%{pybasever}") +%undefine __pythonname_provides +%{warn:Doing a main_python build with wrong %%__default_python3_pkgversion (0%{?__default_python3_pkgversion}, but this is %pyshortver)} +%endif + +# ======================= +# Build-time requirements +# ======================= + +# (keep this list alphabetized) + +BuildRequires: autoconf +BuildRequires: bluez-libs-devel +BuildRequires: bzip2 +BuildRequires: bzip2-devel +BuildRequires: desktop-file-utils +BuildRequires: expat-devel + +BuildRequires: findutils +BuildRequires: gcc-c++ +%if %{with gdbm} +BuildRequires: gdbm-devel +%endif +BuildRequires: git-core +BuildRequires: glibc-all-langpacks +BuildRequires: glibc-devel +BuildRequires: gmp-devel +BuildRequires: gnupg2 +BuildRequires: libappstream-glib +BuildRequires: libffi-devel +%if %{with nis} +BuildRequires: libnsl2-devel +BuildRequires: libtirpc-devel +%endif +BuildRequires: libGL-devel +BuildRequires: libuuid-devel +BuildRequires: libX11-devel +BuildRequires: make +BuildRequires: ncurses-devel + +BuildRequires: openssl-devel +BuildRequires: pkgconfig +BuildRequires: readline-devel +BuildRequires: redhat-rpm-config >= 127 +BuildRequires: sqlite-devel +BuildRequires: gdb + +BuildRequires: tar +BuildRequires: tcl-devel +BuildRequires: tix-devel +BuildRequires: tk-devel +BuildRequires: tzdata + +%if %{with valgrind} +BuildRequires: valgrind-devel +%endif + +BuildRequires: xz-devel +BuildRequires: zlib-devel + +BuildRequires: /usr/bin/dtrace + +# workaround http://bugs.python.org/issue19804 (test_uuid requires ifconfig) +BuildRequires: /usr/sbin/ifconfig + +%if %{with rpmwheels} +BuildRequires: %{python_wheel_pkg_prefix}-setuptools-wheel >= 53.0.0-7 +BuildRequires: %{python_wheel_pkg_prefix}-pip-wheel >= 21.2.3-4 +%endif + +%if %{without bootstrap} +# for make regen-all and distutils.tests.test_bdist_rpm +BuildRequires: python%{pybasever} +# for proper automatic provides +BuildRequires: python3-rpm-generators +%endif + +# ======================= +# Source code and patches +# ======================= + +Source0: %{url}ftp/python/%{general_version}/Python-%{upstream_version}.tar.xz +Source1: %{url}ftp/python/%{general_version}/Python-%{upstream_version}.tar.xz.asc +Source2: %{url}static/files/pubkeys.txt + +# A simple script to check timestamps of bytecode files +# Run in check section with Python that is currently being built +# Originally written by bkabrda +Source8: check-pyc-timestamps.py + +# Desktop menu entry for idle3 +Source10: idle3.desktop + +# AppData file for idle3 +Source11: idle3.appdata.xml + +# (Patches taken from github.com/fedora-python/cpython) + +# 00001 # d06a8853cf4bae9e115f45e1d531d2dc152c5cc8 +# Fixup distutils/unixccompiler.py to remove standard library path from rpath +# Was Patch0 in ivazquez' python3000 specfile +Patch1: 00001-rpath.patch + +# 00111 # 93b40d73360053ca68b0aeec33b6a8ca167e33e2 +# Don't try to build a libpythonMAJOR.MINOR.a +# +# Downstream only: not appropriate for upstream. +# +# See https://bugzilla.redhat.com/show_bug.cgi?id=556092 +Patch111: 00111-no-static-lib.patch + +# 00189 # d06cf137c00fd3907b436fdb92a8f007a7f2fb50 +# Instead of bundled wheels, use our RPM packaged wheels +# +# We keep them in /usr/share/python-wheels +# +# Downstream only: upstream bundles +# We might eventually pursuit upstream support, but it's low prio +Patch189: 00189-use-rpm-wheels.patch +# The following versions of setuptools/pip are bundled when this patch is not applied. +# The versions are written in Lib/ensurepip/__init__.py, this patch removes them. +# When the bundled setuptools/pip wheel is updated, the patch no longer applies cleanly. +# In such cases, the patch needs to be amended and the versions updated here: +%global pip_version 21.2.4 +%global setuptools_version 58.1.0 + +# 00251 # 1b1047c14ff98eae6d355b4aac4df3e388813f62 +# Change user install location +# +# Set values of prefix and exec_prefix in distutils install command +# to /usr/local if executable is /usr/bin/python* and RPM build +# is not detected to make pip and distutils install into separate location. +# +# Fedora Change: https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe +# Downstream only: Reworked in Fedora 36+/Python 3.10+ to follow https://bugs.python.org/issue43976 +# +# pypa/distutils integration: https://github.com/pypa/distutils/pull/70 +# +# Also set sysconfig._PIP_USE_SYSCONFIG = False, to force pip-upgraded-pip +# to respect this patched distutils install command. +# See https://bugzilla.redhat.com/show_bug.cgi?id=2014513 +Patch251: 00251-change-user-install-location.patch + +# 00328 # 367fdcb5a075f083aea83ac174999272a8faf75c +# Restore pyc to TIMESTAMP invalidation mode as default in rpmbuild +# +# Since Fedora 31, the $SOURCE_DATE_EPOCH is set in rpmbuild to the latest +# %%changelog date. This makes Python default to the CHECKED_HASH pyc +# invalidation mode, bringing more reproducible builds traded for an import +# performance decrease. To avoid that, we don't default to CHECKED_HASH +# when $RPM_BUILD_ROOT is set (i.e. when we are building RPM packages). +# +# See https://src.fedoraproject.org/rpms/redhat-rpm-config/pull-request/57#comment-27426 +# Downstream only: only used when building RPM packages +# Ideally, we should talk to upstream and explain why we don't want this +Patch328: 00328-pyc-timestamp-invalidation-mode.patch + +# 00329 # +# Support OpenSSL FIPS mode +# - In FIPS mode, OpenSSL wrappers are always used in hashlib +# - The "usedforsecurity" keyword argument can be used to the various digest +# algorithms in hashlib so that you can whitelist a callsite with +# "usedforsecurity=False" +# - OpenSSL wrappers for the hashes blake2{b512,s256}, +# - In FIPS mode, the blake2 hashes use OpenSSL wrappers +# and do not offer extended functionality (keys, tree hashing, custom digest size) +# +# - In FIPS mode, hmac.HMAC can only be instantiated with an OpenSSL wrapper +# or a string with OpenSSL hash name as the "digestmod" argument. +# The argument must be specified (instead of defaulting to ‘md5’). +Patch329: 00329-fips.patch + +# 00353 # ab4cc97b643cfe99f567e3a03e5617b507183771 +# Original names for architectures with different names downstream +# +# https://fedoraproject.org/wiki/Changes/Python_Upstream_Architecture_Names +# +# Pythons in RHEL/Fedora used different names for some architectures +# than upstream and other distros (for example ppc64 vs. powerpc64). +# This was patched in patch 274, now it is sedded if %%with legacy_archnames. +# +# That meant that an extension built with the default upstream settings +# (on other distro or as an manylinux wheel) could not been found by Python +# on RHEL/Fedora because it had a different suffix. +# This patch adds the legacy names to importlib so Python is able +# to import extensions with a legacy architecture name in its +# file name. +# It work both ways, so it support both %%with and %%without legacy_archnames. +# +# WARNING: This patch has no effect on Python built with bootstrap +# enabled because Python/importlib_external.h is not regenerated +# and therefore Python during bootstrap contains importlib from +# upstream without this feature. It's possible to include +# Python/importlib_external.h to this patch but it'd make rebasing +# a nightmare because it's basically a binary file. +Patch353: 00353-architecture-names-upstream-downstream.patch + +# (New patches go here ^^^) +# +# When adding new patches to "python" and "python3" in Fedora, EL, etc., +# please try to keep the patch numbers in-sync between all specfiles. +# +# More information, and a patch number catalog, is at: +# +# https://fedoraproject.org/wiki/SIGs/Python/PythonPatches +# +# The patches are stored and rebased at: +# +# https://github.com/fedora-python/cpython + + +# ========================================== +# Descriptions, and metadata for subpackages +# ========================================== + +# this if branch is ~300 lines long and contains subpackages' definitions +%if %{without flatpackage} +%if %{with main_python} +# Description for the python3X SRPM only: +%description +Python %{pybasever} is an accessible, high-level, dynamically typed, interpreted +programming language, designed with an emphasis on code readability. +It includes an extensive standard library, and has a vast ecosystem of +third-party libraries. + +%package -n %{pkgname} +Summary: Python %{pybasever} interpreter + +# In order to support multiple Python interpreters for development purposes, +# packages with the naming scheme flatpackage (e.g. python3.5) exist for +# non-default versions of Python 3. +# For consistency, we provide python3.X from python3 as well. +Provides: python%{pybasever} = %{version}-%{release} +Provides: python%{pybasever}%{?_isa} = %{version}-%{release} +# To keep the upgrade path clean, we Obsolete python3.X. +# Note that using Obsoletes without package version is not standard practice. +# Here we assert that *any* version of the system's default interpreter is +# preferable to an "extra" interpreter. For example, python3-3.6.1 will +# replace python3.6-3.6.2. +Obsoletes: python%{pybasever} + +# https://fedoraproject.org/wiki/Changes/Move_usr_bin_python_into_separate_package +# https://fedoraproject.org/wiki/Changes/Python_means_Python3 +# We recommend /usr/bin/python so users get it by default +# Versioned recommends are problematic, and we know that the package requires +# python3 back with fixed version, so we just use the path here: +Recommends: %{_bindir}/python +%endif + +%if %{with rhel8_compat_shims} +Provides: platform-python = %{version}-%{release} +Provides: platform-python%{?_isa} = %{version}-%{release} +Obsoletes: platform-python < %{pybasever} +%endif + +# Python interpreter packages used to be named (or provide) name pythonXY (e.g. +# python39). However, to align it with the executable names and to prepare for +# Python 3.10, they were renamed to pythonX.Y (e.g. python3.9, python3.10). We +# provide and obsolete the previous names. +# - Here are the tags for the nonflat package, regardless if main_python (e.g. +# python3) or not (e.g. python39). For the flat package, the provide is +# repeated many lines later. +Provides: python%{pyshortver} = %{version}-%{release} +Obsoletes: python%{pyshortver} < %{version}-%{release} + +# Packages with Python modules in standard locations automatically +# depend on python(abi). Provide that here. +Provides: python(abi) = %{pybasever} + +Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} + +# In Fedora 31, /usr/bin/pydoc was moved here from Python 2. +# Ideally we'd have an explicit conflict with "/usr/bin/pydoc < 3", +# but file provides aren't versioned and the file moved across packages. +# Instead, we rely on the conflict in python3-libs. + +# This prevents ALL subpackages built from this spec to require +# /usr/bin/python3* or python(abi). Granularity per subpackage is impossible. +# It's intended for the libs package not to drag in the interpreter, see +# https://bugzilla.redhat.com/show_bug.cgi?id=1547131 +# https://bugzilla.redhat.com/show_bug.cgi?id=1862082 +# All other packages require %%{pkgname} explicitly. +%global __requires_exclude ^(/usr/bin/python3|python\\(abi\\)) + +%description -n %{pkgname} +Python %{pybasever} is an accessible, high-level, dynamically typed, interpreted +programming language, designed with an emphasis on code readability. +It includes an extensive standard library, and has a vast ecosystem of +third-party libraries. + +The %{pkgname} package provides the "%{exename}" executable: the reference +interpreter for the Python language, version 3. +The majority of its standard library is provided in the %{pkgname}-libs package, +which should be installed automatically along with %{pkgname}. +The remaining parts of the Python standard library are broken out into the +%{pkgname}-tkinter and %{pkgname}-test packages, which may need to be installed +separately. + +Documentation for Python is provided in the %{pkgname}-docs package. + +Packages containing additional libraries for Python are generally named with +the "%{pkgname}-" prefix. + + +%if %{with main_python} +# https://fedoraproject.org/wiki/Changes/Move_usr_bin_python_into_separate_package +# https://fedoraproject.org/wiki/Changes/Python_means_Python3 +%package -n python-unversioned-command +Summary: The "python" command that runs Python 3 +BuildArch: noarch + +# In theory this could require any python3 version +Requires: python3 == %{version}-%{release} +# But since we want to provide versioned python, we require exact version +Provides: python = %{version}-%{release} +# This also save us an explicit conflict for older python3 builds + +%description -n python-unversioned-command +This package contains /usr/bin/python - the "python" command that runs Python 3. + +%endif # with main_python + + +%package -n %{pkgname}-libs +Summary: Python runtime libraries + +%if %{with rpmwheels} +Requires: %{python_wheel_pkg_prefix}-setuptools-wheel >= 53.0.0-7 +Requires: %{python_wheel_pkg_prefix}-pip-wheel >= 21.2.3-4 +%else +Provides: bundled(python3dist(pip)) = %{pip_version} +Provides: bundled(python3dist(setuptools)) = %{setuptools_version} +%endif + +# Provides for the bundled libmpdec +Provides: bundled(mpdecimal) = %{libmpdec_version} +Provides: bundled(libmpdec) = %{libmpdec_version} + +# There are files in the standard library that have python shebang. +# We've filtered the automatic requirement out so libs are installable without +# the main package. This however makes it pulled in by default. +# See https://bugzilla.redhat.com/show_bug.cgi?id=1547131 +Recommends: %{pkgname}%{?_isa} = %{version}-%{release} + +# tkinter is part of the standard library, +# but it is torn out to save an unwanted dependency on tk and X11. +# we recommend it when tk is already installed (for better UX) +Recommends: (%{pkgname}-tkinter%{?_isa} = %{version}-%{release} if tk%{?_isa}) + +# The zoneinfo module needs tzdata +Requires: tzdata + +# https://fedoraproject.org/wiki/Changes/Move_usr_bin_python_into_separate_package +# In Fedora 31, several "unversioned" files like /usr/bin/pydoc and all the +# "unversioned" provides were moved from python2 to python3. +# So, newer python3 packages need to conflict with old Python 2 builds that +# still provided unversioned Python. +# Since all python packages, new and old, have versioned requires on +# python?-libs, we do it here: +Conflicts: python-libs < 3 +# (We explicitly conflict with python-libs and not python2-libs, so only the +# old Python 2 builds that still provided unversioned Python are handled.) + +%if %{with rhel8_compat_shims} +# In RHEL 8 platform-python-setuptools/pip were always installed due to dnf, +# but did not provide user-facing binaries, which were in the +# python3-setuptools/pip packages. We Provide the platform-python-* names from +# the python3- packages in RHEL 9, but Obsolete them here to have a clean +# upgrade path. +Obsoletes: platform-python-setuptools < 1:0 +Obsoletes: platform-python-pip < 1:0 +%endif + +%description -n %{pkgname}-libs +This package contains runtime libraries for use by Python: +- the majority of the Python standard library +- a dynamically linked library for use by applications that embed Python as + a scripting language, and by the main "%{exename}" executable + + +%package -n %{pkgname}-devel +Summary: Libraries and header files needed for Python development +Requires: %{pkgname} = %{version}-%{release} +Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} +# The RPM related dependencies bring nothing to a non-RPM Python developer +# But we want them when packages BuildRequire python3-devel +Requires: (python-rpm-macros if rpm-build) +Requires: (python3-rpm-macros if rpm-build) + +# Python developers are very likely to need pip +Recommends: %{pkgname}-pip + +%if %{without bootstrap} +# This is not "API" (packages that need setuptools should still BuildRequire it) +# However some packages apparently can build both with and without setuptools +# producing egg-info as file or directory (depending on setuptools presence). +# Directory-to-file updates are problematic in RPM, so we ensure setuptools is +# installed when -devel is required. +# See https://bugzilla.redhat.com/show_bug.cgi?id=1623914 +# See https://fedoraproject.org/wiki/Packaging:Directory_Replacement +Requires: (%{pkgname}-setuptools if rpm-build) + +Requires: (python3-rpm-generators if rpm-build) +%endif + +Provides: %{pkgname}-2to3 = %{version}-%{release} +Provides: 2to3 = %{version}-%{release} + +Conflicts: %{pkgname} < %{version}-%{release} + +# In Fedora 31, several "unversioned" files were moved here from Python 2: +# pygettext.py, msgfmt.py, python-config, python.pc +Conflicts: python-devel < 3 + +%if %{with rhel8_compat_shims} +Provides: platform-python-devel = %{version}-%{release} +Provides: platform-python-devel%{?_isa} = %{version}-%{release} +Obsoletes: platform-python-devel < %{pybasever} +%endif + +%description -n %{pkgname}-devel +This package contains the header files and configuration needed to compile +Python extension modules (typically written in C or C++), to embed Python +into other programs, and to make binary distributions for Python libraries. + +It also contains the necessary macros to build RPM packages with Python modules +and 2to3 tool, an automatic source converter from Python 2.X. + + +%package -n %{pkgname}-idle +Summary: A basic graphical development environment for Python +Requires: %{pkgname} = %{version}-%{release} +Requires: %{pkgname}-tkinter = %{version}-%{release} + +Provides: idle3 = %{version}-%{release} +Provides: idle = %{version}-%{release} + +Provides: %{pkgname}-tools = %{version}-%{release} +Provides: %{pkgname}-tools%{?_isa} = %{version}-%{release} +Obsoletes: %{pkgname}-tools < %{version}-%{release} + +# In Fedora 31, /usr/bin/idle was moved here from Python 2. +Conflicts: python-tools < 3 + +%description -n %{pkgname}-idle +IDLE is Python’s Integrated Development and Learning Environment. + +IDLE has the following features: Python shell window (interactive +interpreter) with colorizing of code input, output, and error messages; +multi-window text editor with multiple undo, Python colorizing, +smart indent, call tips, auto completion, and other features; +search within any window, replace within editor windows, and +search through multiple files (grep); debugger with persistent +breakpoints, stepping, and viewing of global and local namespaces; +configuration, browsers, and other dialogs. + + +%package -n %{pkgname}-tkinter +Summary: A GUI toolkit for Python +Requires: %{pkgname} = %{version}-%{release} + +%description -n %{pkgname}-tkinter +The Tkinter (Tk interface) library is a graphical user interface toolkit for +the Python programming language. + + +%package -n %{pkgname}-test +Summary: The self-test suite for the main python3 package +Requires: %{pkgname} = %{version}-%{release} +Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} + +%description -n %{pkgname}-test +The self-test suite for the Python interpreter. + +This is only useful to test Python itself. For testing general Python code, +you should use the unittest module from %{pkgname}-libs, or a library such as +%{pkgname}-pytest. + + +%if %{with debug_build} +%package -n %{pkgname}-debug +Summary: Debug version of the Python runtime + +# The debug build is an all-in-one package version of the regular build, and +# shares the same .py/.pyc files and directories as the regular build. Hence +# we depend on all of the subpackages of the regular build: +Requires: %{pkgname}%{?_isa} = %{version}-%{release} +Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} +Requires: %{pkgname}-devel%{?_isa} = %{version}-%{release} +Requires: %{pkgname}-test%{?_isa} = %{version}-%{release} +Requires: %{pkgname}-tkinter%{?_isa} = %{version}-%{release} +Requires: %{pkgname}-idle%{?_isa} = %{version}-%{release} + +# In Fedora 31, /usr/bin/python-debug was moved here from Python 2. +Conflicts: python-debug < 3 + +%if %{with rhel8_compat_shims} +Provides: platform-python-debug = %{version}-%{release} +Provides: platform-python-debug%{?_isa} = %{version}-%{release} +Obsoletes: platform-python-debug < %{pybasever} +%endif + +%description -n %{pkgname}-debug +python3-debug provides a version of the Python runtime with numerous debugging +features enabled, aimed at advanced Python users such as developers of Python +extension modules. + +This version uses more memory and will be slower than the regular Python build, +but is useful for tracking down reference-counting issues and other bugs. + +The debug build shares installation directories with the standard Python +runtime. Python modules -- source (.py), bytecode (.pyc), and C-API extensions +(.cpython*.so) -- are compatible between this and the standard version +of Python. + +The debug runtime additionally supports debug builds of C-API extensions +(with the "d" ABI flag) for debugging issues in those extensions. +%endif # with debug_build + +%else # with flatpackage + +# We'll not provide this, on purpose +# No package in Fedora shall ever depend on flatpackage via this +%global __requires_exclude ^python\\(abi\\) = 3\\..$ +%global __provides_exclude ^python\\(abi\\) = 3\\..$ + +# Python interpreter packages used to be named (or provide) name pythonXY (e.g. +# python39). However, to align it with the executable names and to prepare for +# Python 3.10, they were renamed to pythonX.Y (e.g. python3.9, python3.10). We +# provide and obsolete the previous names. +# - Here are the tags for the flat package. For the nonflat package, the +# provide is repeated many lines above. +Provides: python%{pyshortver} = %{version}-%{release} +Obsoletes: python%{pyshortver} < %{version}-%{release} + +%if %{with rpmwheels} +Requires: %{python_wheel_pkg_prefix}-setuptools-wheel >= 53.0.0-7 +Requires: %{python_wheel_pkg_prefix}-pip-wheel >= 21.2.3-4 +%else +Provides: bundled(python3dist(pip)) = %{pip_version} +Provides: bundled(python3dist(setuptools)) = %{setuptools_version} +%endif + +# Provides for the bundled libmpdec +Provides: bundled(mpdecimal) = %{libmpdec_version} +Provides: bundled(libmpdec) = %{libmpdec_version} + +# The zoneinfo module needs tzdata +Requires: tzdata + +# The description for the flat package (SRPM and built) +%description +Python %{pybasever} package for developers. + +This package exists to allow developers to test their code against a newer +version of Python. This is not a full Python stack and if you wish to run +your applications with Python %{pybasever}, update your Fedora to a newer +version once Python %{pybasever} is stable. + +%endif # with flatpackage + +# ====================================================== +# The prep phase of the build: +# ====================================================== + +%prep +%gpgverify -k2 -s1 -d0 +%autosetup -S git_am -N -n Python-%{upstream_version} + +# Apply patches up to 188 +%autopatch -M 188 + +%if %{with rpmwheels} +# Temporary workaround for https://bugzilla.redhat.com/show_bug.cgi?id=1954999 +%{?!apply_patch:%define apply_patch(qp:m:) {%__apply_patch %**}} + +%apply_patch -q %{PATCH189} +rm Lib/ensurepip/_bundled/*.whl +%endif + +# Apply the remaining patches +%autopatch -m 190 + +# Remove all exe files to ensure we are not shipping prebuilt binaries +# note that those are only used to create Microsoft Windows installers +# and that functionality is broken on Linux anyway +find -name '*.exe' -print -delete + +# Remove bundled libraries to ensure that we're using the system copy. +rm -r Modules/expat + +# Remove files that should be generated by the build +# (This is after patching, so that we can use patches directly from upstream) +rm configure pyconfig.h.in + +# When we use the legacy arch names, we need to change them in configure.ac +%if %{with legacy_archnames} +sed -i configure.ac \ + -e 's/\b%{platform_triplet_upstream}\b/%{platform_triplet_legacy}/' +%endif + +# Modify ensurepip, patched by `00189-use-rpm-wheels.patch`, to insert the +# actual %%python_wheel_dir location +sed -i Lib/ensurepip/__init__.py -e 's|_WHEEL_DIR = "/usr/share/python-wheels/"|_WHEEL_DIR = "%{python_wheel_dir}/"|' + + +# ====================================================== +# Configuring and building the code: +# ====================================================== + +%build + +# The build process embeds version info extracted from the Git repository +# into the Py_GetBuildInfo and sys.version strings. +# Our Git repository is artificial, so we don't want that. +# Tell configure to not use git. +export HAS_GIT=not-found + +# Regenerate the configure script and pyconfig.h.in +autoconf +autoheader + +# Remember the current directory (which has sources and the configure script), +# so we can refer to it after we "cd" elsewhere. +topdir=$(pwd) + +# Get proper option names from bconds +%if %{with computed_gotos} +%global computed_gotos_flag yes +%else +%global computed_gotos_flag no +%endif + +%if %{with optimizations} +%global optimizations_flag "--enable-optimizations" +%else +%global optimizations_flag "--disable-optimizations" +%endif + +# Set common compiler/linker flags +# We utilize the %%extension_...flags macros here so users building C/C++ +# extensions with our python won't get all the compiler/linker flags used +# in Fedora RPMs. +# Standard library built here will still use the %%build_...flags, +# Fedora packages utilizing %%py3_build will use them as well +# https://fedoraproject.org/wiki/Changes/Python_Extension_Flags +export CFLAGS="%{extension_cflags} -D_GNU_SOURCE -fPIC -fwrapv" +export CFLAGS_NODIST="%{build_cflags} -D_GNU_SOURCE -fPIC -fwrapv%{?with_no_semantic_interposition: -fno-semantic-interposition}" +export CXXFLAGS="%{extension_cxxflags} -D_GNU_SOURCE -fPIC -fwrapv" +export CPPFLAGS="$(pkg-config --cflags-only-I libffi)" +export OPT="%{extension_cflags} -D_GNU_SOURCE -fPIC -fwrapv" +export LINKCC="gcc" +export CFLAGS="$CFLAGS $(pkg-config --cflags openssl)" +export LDFLAGS="%{extension_ldflags} -g $(pkg-config --libs-only-L openssl)" +export LDFLAGS_NODIST="%{build_ldflags}%{?with_no_semantic_interposition: -fno-semantic-interposition} -g $(pkg-config --libs-only-L openssl)" + +# We can build several different configurations of Python: regular and debug. +# Define a common function that does one build: +BuildPython() { + ConfName=$1 + ExtraConfigArgs=$2 + MoreCFlags=$3 + + # Each build is done in its own directory + ConfDir=build/$ConfName + echo STARTING: BUILD OF PYTHON FOR CONFIGURATION: $ConfName + mkdir -p $ConfDir + pushd $ConfDir + + # Normally, %%configure looks for the "configure" script in the current + # directory. + # Since we changed directories, we need to tell %%configure where to look. + %global _configure $topdir/configure + + # A workaround for https://bugs.python.org/issue39761 + export DFLAGS=" " + +%configure \ + --with-platlibdir=%{_lib} \ + --enable-ipv6 \ + --enable-shared \ + --with-computed-gotos=%{computed_gotos_flag} \ + --with-dbmliborder=gdbm:ndbm:bdb \ + --with-system-expat \ + --with-system-ffi \ + --enable-loadable-sqlite-extensions \ + --with-dtrace \ + --with-lto \ + --with-ssl-default-suites=openssl \ + --with-builtin-hashlib-hashes=blake2 \ +%if %{with valgrind} + --with-valgrind \ +%endif + $ExtraConfigArgs \ + %{nil} + +%global flags_override EXTRA_CFLAGS="$MoreCFlags" CFLAGS_NODIST="$CFLAGS_NODIST $MoreCFlags" + +%if %{without bootstrap} + # Regenerate generated files (needs python3) + %make_build %{flags_override} regen-all PYTHON_FOR_REGEN="python%{pybasever}" +%endif + + # Invoke the build + %make_build %{flags_override} + + popd + echo FINISHED: BUILD OF PYTHON FOR CONFIGURATION: $ConfName +} + +# Call the above to build each configuration. + +%if %{with debug_build} +# The debug build is compiled with the lowest level of optimizations as to not optimize +# out frames. We also suppress the warnings as the default distro value of the FORTIFY_SOURCE +# option produces too many warnings when compiling at the O0 optimization level. +# See also: https://bugzilla.redhat.com/show_bug.cgi?id=1818857 +BuildPython debug \ + "--without-ensurepip --with-pydebug" \ + "-O0 -Wno-cpp" +%endif # with debug_build + +BuildPython optimized \ + "--without-ensurepip %{optimizations_flag}" \ + "" + +# ====================================================== +# Installing the built code: +# ====================================================== + +%install + +# As in %%build, remember the current directory +topdir=$(pwd) + +# We install a collection of hooks for gdb that make it easier to debug +# executables linked against libpython3* (such as /usr/bin/python3 itself) +# +# These hooks are implemented in Python itself (though they are for the version +# of python that gdb is linked with) +# +# gdb-archer looks for them in the same path as the ELF file or its .debug +# file, with a -gdb.py suffix. +# We put them next to the debug file, because ldconfig would complain if +# it found non-library files directly in /usr/lib/ +# (see https://bugzilla.redhat.com/show_bug.cgi?id=562980) +# +# We'll put these files in the debuginfo package by installing them to e.g.: +# /usr/lib/debug/usr/lib/libpython3.2.so.1.0.debug-gdb.py +# (note that the debug path is /usr/lib/debug for both 32/64 bit) +# +# See https://fedoraproject.org/wiki/Features/EasierPythonDebugging for more +# information + +%if %{with gdb_hooks} +DirHoldingGdbPy=%{_usr}/lib/debug/%{_libdir} +mkdir -p %{buildroot}$DirHoldingGdbPy +%endif # with gdb_hooks + +# Multilib support for pyconfig.h +# 32- and 64-bit versions of pyconfig.h are different. For multilib support +# (making it possible to install 32- and 64-bit versions simultaneously), +# we need to install them under different filenames, and to make the common +# "pyconfig.h" include the right file based on architecture. +# See https://bugzilla.redhat.com/show_bug.cgi?id=192747 +# Filanames are defined here: +%global _pyconfig32_h pyconfig-32.h +%global _pyconfig64_h pyconfig-64.h +%global _pyconfig_h pyconfig-%{__isa_bits}.h + +# Use a common function to do an install for all our configurations: +InstallPython() { + + ConfName=$1 + PyInstSoName=$2 + MoreCFlags=$3 + LDVersion=$4 + + # Switch to the directory with this configuration's built files + ConfDir=build/$ConfName + echo STARTING: INSTALL OF PYTHON FOR CONFIGURATION: $ConfName + mkdir -p $ConfDir + pushd $ConfDir + + %make_install EXTRA_CFLAGS="$MoreCFlags" + + popd + +%if %{with gdb_hooks} + # See comment on $DirHoldingGdbPy above + PathOfGdbPy=$DirHoldingGdbPy/$PyInstSoName-%{version}-%{release}.%{_arch}.debug-gdb.py + cp Tools/gdb/libpython.py %{buildroot}$PathOfGdbPy +%endif # with gdb_hooks + + # Rename the -devel script that differs on different arches to arch specific name + mv %{buildroot}%{_bindir}/python${LDVersion}-{,`uname -m`-}config + echo -e '#!/bin/sh\nexec %{_bindir}/python'${LDVersion}'-`uname -m`-config "$@"' > \ + %{buildroot}%{_bindir}/python${LDVersion}-config + chmod +x %{buildroot}%{_bindir}/python${LDVersion}-config + + # Make python3-devel multilib-ready + mv %{buildroot}%{_includedir}/python${LDVersion}/pyconfig.h \ + %{buildroot}%{_includedir}/python${LDVersion}/%{_pyconfig_h} + cat > %{buildroot}%{_includedir}/python${LDVersion}/pyconfig.h << EOF +#include + +#if __WORDSIZE == 32 +#include "%{_pyconfig32_h}" +#elif __WORDSIZE == 64 +#include "%{_pyconfig64_h}" +#else +#error "Unknown word size" +#endif +EOF + + echo FINISHED: INSTALL OF PYTHON FOR CONFIGURATION: $ConfName +} + +# Install the "debug" build first; any common files will be overridden with +# later builds +%if %{with debug_build} +InstallPython debug \ + %{py_INSTSONAME_debug} \ + -O0 \ + %{LDVERSION_debug} +%endif # with debug_build + +# Now the optimized build: +InstallPython optimized \ + %{py_INSTSONAME_optimized} \ + "" \ + %{LDVERSION_optimized} + +# Install directories for additional packages +install -d -m 0755 %{buildroot}%{pylibdir}/site-packages/__pycache__ +%if "%{_lib}" == "lib64" +# The 64-bit version needs to create "site-packages" in /usr/lib/ (for +# pure-Python modules) as well as in /usr/lib64/ (for packages with extension +# modules). +# Note that rpmlint will complain about hardcoded library path; +# this is intentional. +install -d -m 0755 %{buildroot}%{_prefix}/lib/python%{pybasever}/site-packages/__pycache__ +%endif + +%if %{with main_python} +# add idle3 to menu +install -D -m 0644 Lib/idlelib/Icons/idle_16.png %{buildroot}%{_datadir}/icons/hicolor/16x16/apps/idle3.png +install -D -m 0644 Lib/idlelib/Icons/idle_32.png %{buildroot}%{_datadir}/icons/hicolor/32x32/apps/idle3.png +install -D -m 0644 Lib/idlelib/Icons/idle_48.png %{buildroot}%{_datadir}/icons/hicolor/48x48/apps/idle3.png +install -D -m 0644 Lib/idlelib/Icons/idle_256.png %{buildroot}%{_datadir}/icons/hicolor/256x256/apps/idle3.png +desktop-file-install --dir=%{buildroot}%{_datadir}/applications %{SOURCE10} + +# Install and validate appdata file +mkdir -p %{buildroot}%{_metainfodir} +cp -a %{SOURCE11} %{buildroot}%{_metainfodir} +appstream-util validate-relax --nonet %{buildroot}%{_metainfodir}/idle3.appdata.xml +%endif + +# Make sure distutils looks at the right pyconfig.h file +# See https://bugzilla.redhat.com/show_bug.cgi?id=201434 +# Similar for sysconfig: sysconfig.get_config_h_filename tries to locate +# pyconfig.h so it can be parsed, and needs to do this at runtime in site.py +# when python starts up (see https://bugzilla.redhat.com/show_bug.cgi?id=653058) +# +# Split this out so it goes directly to the pyconfig-32.h/pyconfig-64.h +# variants: +sed -i -e "s/'pyconfig.h'/'%{_pyconfig_h}'/" \ + %{buildroot}%{pylibdir}/distutils/sysconfig.py \ + %{buildroot}%{pylibdir}/sysconfig.py + +# Install pathfix.py to bindir +# See https://github.com/fedora-python/python-rpm-porting/issues/24 +cp -p Tools/scripts/pathfix.py %{buildroot}%{_bindir}/pathfix%{pybasever}.py + +# Install i18n tools to bindir +# They are also in python2, so we version them +# https://bugzilla.redhat.com/show_bug.cgi?id=1571474 +for tool in pygettext msgfmt; do + cp -p Tools/i18n/${tool}.py %{buildroot}%{_bindir}/${tool}%{pybasever}.py + ln -s ${tool}%{pybasever}.py %{buildroot}%{_bindir}/${tool}3.py +done + +# Switch all shebangs to refer to the specific Python version. +# This currently only covers files matching ^[a-zA-Z0-9_]+\.py$, +# so handle files named using other naming scheme separately. +LD_LIBRARY_PATH=./build/optimized ./build/optimized/python \ + Tools/scripts/pathfix.py \ + -i "%{_bindir}/python%{pybasever}" -pn \ + %{buildroot} \ + %{buildroot}%{_bindir}/*%{pybasever}.py \ + %{?with_gdb_hooks:%{buildroot}$DirHoldingGdbPy/*.py} + +# Remove shebang lines from .py files that aren't executable, and +# remove executability from .py files that don't have a shebang line: +find %{buildroot} -name \*.py \ + \( \( \! -perm /u+x,g+x,o+x -exec sed -e '/^#!/Q 0' -e 'Q 1' {} \; \ + -print -exec sed -i '1d' {} \; \) -o \( \ + -perm /u+x,g+x,o+x ! -exec grep -m 1 -q '^#!' {} \; \ + -exec chmod a-x {} \; \) \) + +# Get rid of DOS batch files: +find %{buildroot} -name \*.bat -exec rm {} \; + +# Get rid of backup files: +find %{buildroot}/ -name "*~" -exec rm -f {} \; +find . -name "*~" -exec rm -f {} \; + +# Do bytecompilation with the newly installed interpreter. +# This is similar to the script in macros.pybytecompile +# compile *.pyc +# Python CMD line options: +# -s - don't add user site directory to sys.path +# -B - don't write .pyc files on import +# compileall CMD line options: +# -f - force rebuild even if timestamps are up to date +# -o - optimization levels to run compilation with +# -s - part of path to left-strip from path to source file (buildroot) +# -p - path to add as prefix to path to source file (/ to make it absolute) +# --hardlink-dupes - hardlink different optimization level pycs together if identical (saves space) +LD_LIBRARY_PATH="%{buildroot}%{dynload_dir}/:%{buildroot}%{_libdir}" \ +%{buildroot}%{_bindir}/python%{pybasever} -s -B -m compileall \ +-f %{_smp_mflags} -o 0 -o 1 -o 2 -s %{buildroot} -p / %{buildroot} --hardlink-dupes || : + +# Turn this BRP off, it is done by compileall2 --hardlink-dupes above +%global __brp_python_hardlink %{nil} + +# Since we have pathfix.py in bindir, this is created, but we don't want it +rm -rf %{buildroot}%{_bindir}/__pycache__ + +# Fixup permissions for shared libraries from non-standard 555 to standard 755: +find %{buildroot} -perm 555 -exec chmod 755 {} \; + +# Create "/usr/bin/python3-debug", a symlink to the python3 debug binary, to +# avoid the user having to know the precise version and ABI flags. +# See e.g. https://bugzilla.redhat.com/show_bug.cgi?id=676748 +%if %{with debug_build} && %{with main_python} +ln -s \ + %{_bindir}/python%{LDVERSION_debug} \ + %{buildroot}%{_bindir}/python3-debug +%endif + +# There's 2to3-X.X executable and 2to3 soft link to it. +# No reason to have both, so keep only 2to3 as an executable. +# See https://bugzilla.redhat.com/show_bug.cgi?id=1111275 +mv %{buildroot}%{_bindir}/2to3-%{pybasever} %{buildroot}%{_bindir}/2to3 + +%if %{without main_python} +# Remove stuff that would conflict with python3 package +rm %{buildroot}%{_bindir}/python3 +rm %{buildroot}%{_bindir}/pydoc3 +rm %{buildroot}%{_bindir}/pygettext3.py +rm %{buildroot}%{_bindir}/msgfmt3.py +rm %{buildroot}%{_bindir}/idle3 +rm %{buildroot}%{_bindir}/python3-* +rm %{buildroot}%{_bindir}/2to3 +rm %{buildroot}%{_libdir}/libpython3.so +rm %{buildroot}%{_mandir}/man1/python3.1* +rm %{buildroot}%{_libdir}/pkgconfig/python3.pc +rm %{buildroot}%{_libdir}/pkgconfig/python3-embed.pc +%else +# Link the unversioned stuff +# https://fedoraproject.org/wiki/Changes/Python_means_Python3 +ln -s ./python3 %{buildroot}%{_bindir}/python +ln -s ./pydoc3 %{buildroot}%{_bindir}/pydoc +ln -s ./pygettext3.py %{buildroot}%{_bindir}/pygettext.py +ln -s ./msgfmt3.py %{buildroot}%{_bindir}/msgfmt.py +ln -s ./idle3 %{buildroot}%{_bindir}/idle +ln -s ./python3-config %{buildroot}%{_bindir}/python-config +ln -s ./python3.1 %{buildroot}%{_mandir}/man1/python.1 +ln -s ./python3.pc %{buildroot}%{_libdir}/pkgconfig/python.pc +ln -s ./pathfix%{pybasever}.py %{buildroot}%{_bindir}/pathfix.py +%if %{with debug_build} +ln -s ./python3-debug %{buildroot}%{_bindir}/python-debug +%endif +%endif + +%if %{with rhel8_compat_shims} +# Provide RHEL8 backwards compatible symbolic links in %%_libexecdir +mkdir -p %{buildroot}%{_libexecdir} +ln -s %{_bindir}/python%{pybasever} %{buildroot}%{_libexecdir}/platform-python +ln -s %{_bindir}/python%{pybasever} %{buildroot}%{_libexecdir}/platform-python%{pybasever} +ln -s %{_bindir}/python%{pybasever}-config %{buildroot}%{_libexecdir}/platform-python-config +ln -s %{_bindir}/python%{pybasever}-config %{buildroot}%{_libexecdir}/platform-python%{pybasever}-config +ln -s %{_bindir}/python%{pybasever}-`uname -m`-config %{buildroot}%{_libexecdir}/platform-python%{pybasever}-`uname -m`-config +# There were also executables with %%{LDVERSION_optimized} in RHEL 8, +# but since Python 3.8 %%{LDVERSION_optimized} == %%{pybasever}. +# We list both in the %%files section to assert this. +%if %{with debug_build} +ln -s %{_bindir}/python%{LDVERSION_debug} %{buildroot}%{_libexecdir}/platform-python-debug +ln -s %{_bindir}/python%{LDVERSION_debug} %{buildroot}%{_libexecdir}/platform-python%{LDVERSION_debug} +ln -s %{_bindir}/python%{LDVERSION_debug}-config %{buildroot}%{_libexecdir}/platform-python%{LDVERSION_debug}-config +ln -s %{_bindir}/python%{LDVERSION_debug}-`uname -m`-config %{buildroot}%{_libexecdir}/platform-python%{LDVERSION_debug}-`uname -m`-config +%endif +%endif + +# Remove large, autogenerated sources and keep only the non-optimized pycache +for file in %{buildroot}%{pylibdir}/pydoc_data/topics.py $(grep --include='*.py' -lr %{buildroot}%{pylibdir}/encodings -e 'Python Character Mapping Codec .* from .* with gencodec.py'); do + directory=$(dirname ${file}) + module=$(basename ${file%%.py}) + mv ${directory}/{__pycache__/${module}.cpython-%{pyshortver}.pyc,${module}.pyc} + rm ${directory}/{__pycache__/${module}.cpython-%{pyshortver}.opt-?.pyc,${module}.py} +done + +# ====================================================== +# Checks for packaging issues +# ====================================================== + +%check + +# first of all, check timestamps of bytecode files +find %{buildroot} -type f -a -name "*.py" -print0 | \ + LD_LIBRARY_PATH="%{buildroot}%{dynload_dir}/:%{buildroot}%{_libdir}" \ + PYTHONPATH="%{buildroot}%{_libdir}/python%{pybasever} %{buildroot}%{_libdir}/python%{pybasever}/site-packages" \ + xargs -0 %{buildroot}%{_bindir}/python%{pybasever} %{SOURCE8} + +# Ensure that the curses module was linked against libncursesw.so, rather than +# libncurses.so +# See https://bugzilla.redhat.com/show_bug.cgi?id=539917 +ldd %{buildroot}/%{dynload_dir}/_curses*.so \ + | grep curses \ + | grep libncurses.so && (echo "_curses.so linked against libncurses.so" ; exit 1) + +# Ensure that the debug modules are linked against the debug libpython, and +# likewise for the optimized modules and libpython: +for Module in %{buildroot}/%{dynload_dir}/*.so ; do + case $Module in + *.%{SOABI_debug}) + ldd $Module | grep %{py_INSTSONAME_optimized} && + (echo Debug module $Module linked against optimized %{py_INSTSONAME_optimized} ; exit 1) + + ;; + *.%{SOABI_optimized}) + ldd $Module | grep %{py_INSTSONAME_debug} && + (echo Optimized module $Module linked against debug %{py_INSTSONAME_debug} ; exit 1) + ;; + esac +done + +# Verify that the bundled libmpdec version python was compiled with, is the same version we have virtual +# provides for in the SPEC. +test "$(LD_LIBRARY_PATH=$(pwd)/build/optimized $(pwd)/build/optimized/python -c 'import decimal; print(decimal.__libmpdec_version__)')" = \ + "%{libmpdec_version}" + + +# ====================================================== +# Running the upstream test suite +# ====================================================== + +topdir=$(pwd) +CheckPython() { + ConfName=$1 + ConfDir=$(pwd)/build/$ConfName + + echo STARTING: CHECKING OF PYTHON FOR CONFIGURATION: $ConfName + + # Note that we're running the tests using the version of the code in the + # builddir, not in the buildroot. + + # Show some info, helpful for debugging test failures + LD_LIBRARY_PATH=$ConfDir $ConfDir/python -m test.pythoninfo + + # Run the upstream test suite + # --timeout=1800: kill test running for longer than 30 minutes + # test_distutils + # distutils.tests.test_bdist_rpm tests fail when bootstraping the Python + # package: rpmbuild requires /usr/bin/pythonX.Y to be installed + LD_LIBRARY_PATH=$ConfDir $ConfDir/python -m test.regrtest \ + -wW --slowest -j0 --timeout=1800 \ + %if %{with bootstrap} + -x test_distutils \ + %endif + %ifarch %{mips64} + -x test_ctypes \ + %endif + + echo FINISHED: CHECKING OF PYTHON FOR CONFIGURATION: $ConfName + +} + +%if %{with tests} + +# Check each of the configurations: +%if %{with debug_build} +CheckPython debug +%endif # with debug_build +CheckPython optimized + +%endif # with tests + + +%files -n %{pkgname} +%doc README.rst + +%if %{with main_python} +%{_bindir}/pydoc* +%{_bindir}/python3 +%else +%{_bindir}/pydoc%{pybasever} +%endif + +%{_bindir}/python%{pybasever} +%{_bindir}/python%{LDVERSION_optimized} +%{_mandir}/*/*3* + +%if %{with rhel8_compat_shims} +%{_libexecdir}/platform-python +%{_libexecdir}/platform-python%{pybasever} +%{_libexecdir}/platform-python%{LDVERSION_optimized} +%endif + +%if %{with main_python} +%if %{without flatpackage} +%files -n python-unversioned-command +%endif +%{_bindir}/python +%{_mandir}/*/python.1* +%endif + +%if %{without flatpackage} +%files -n %{pkgname}-libs +%doc README.rst +%endif + +%dir %{pylibdir} +%dir %{dynload_dir} + +%license %{pylibdir}/LICENSE.txt + +%{pylibdir}/lib2to3 +%if %{without flatpackage} +%exclude %{pylibdir}/lib2to3/tests +%endif + +%dir %{pylibdir}/unittest/ +%dir %{pylibdir}/unittest/__pycache__/ +%{pylibdir}/unittest/*.py +%{pylibdir}/unittest/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/asyncio/ +%dir %{pylibdir}/asyncio/__pycache__/ +%{pylibdir}/asyncio/*.py +%{pylibdir}/asyncio/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/venv/ +%dir %{pylibdir}/venv/__pycache__/ +%{pylibdir}/venv/*.py +%{pylibdir}/venv/__pycache__/*%{bytecode_suffixes} +%{pylibdir}/venv/scripts + +%{pylibdir}/wsgiref +%{pylibdir}/xmlrpc + +%dir %{pylibdir}/ensurepip/ +%dir %{pylibdir}/ensurepip/__pycache__/ +%{pylibdir}/ensurepip/*.py +%{pylibdir}/ensurepip/__pycache__/*%{bytecode_suffixes} + +%if %{with rpmwheels} +%exclude %{pylibdir}/ensurepip/_bundled +%else +%dir %{pylibdir}/ensurepip/_bundled +%{pylibdir}/ensurepip/_bundled/*.whl +%{pylibdir}/ensurepip/_bundled/__init__.py +%{pylibdir}/ensurepip/_bundled/__pycache__/*%{bytecode_suffixes} +%endif + +%dir %{pylibdir}/concurrent/ +%dir %{pylibdir}/concurrent/__pycache__/ +%{pylibdir}/concurrent/*.py +%{pylibdir}/concurrent/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/concurrent/futures/ +%dir %{pylibdir}/concurrent/futures/__pycache__/ +%{pylibdir}/concurrent/futures/*.py +%{pylibdir}/concurrent/futures/__pycache__/*%{bytecode_suffixes} + +%{pylibdir}/pydoc_data + +%{dynload_dir}/_blake2.%{SOABI_optimized}.so + +%{dynload_dir}/_asyncio.%{SOABI_optimized}.so +%{dynload_dir}/_bisect.%{SOABI_optimized}.so +%{dynload_dir}/_bz2.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_cn.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_hk.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_iso2022.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_jp.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_kr.%{SOABI_optimized}.so +%{dynload_dir}/_codecs_tw.%{SOABI_optimized}.so +%{dynload_dir}/_contextvars.%{SOABI_optimized}.so +%{dynload_dir}/_crypt.%{SOABI_optimized}.so +%{dynload_dir}/_csv.%{SOABI_optimized}.so +%{dynload_dir}/_ctypes.%{SOABI_optimized}.so +%{dynload_dir}/_curses.%{SOABI_optimized}.so +%{dynload_dir}/_curses_panel.%{SOABI_optimized}.so +%{dynload_dir}/_dbm.%{SOABI_optimized}.so +%{dynload_dir}/_decimal.%{SOABI_optimized}.so +%{dynload_dir}/_elementtree.%{SOABI_optimized}.so +%if %{with gdbm} +%{dynload_dir}/_gdbm.%{SOABI_optimized}.so +%endif +%{dynload_dir}/_hashlib.%{SOABI_optimized}.so +%{dynload_dir}/_heapq.%{SOABI_optimized}.so +%{dynload_dir}/_json.%{SOABI_optimized}.so +%{dynload_dir}/_lsprof.%{SOABI_optimized}.so +%{dynload_dir}/_lzma.%{SOABI_optimized}.so +%{dynload_dir}/_multibytecodec.%{SOABI_optimized}.so +%{dynload_dir}/_multiprocessing.%{SOABI_optimized}.so +%{dynload_dir}/_opcode.%{SOABI_optimized}.so +%{dynload_dir}/_pickle.%{SOABI_optimized}.so +%{dynload_dir}/_posixsubprocess.%{SOABI_optimized}.so +%{dynload_dir}/_queue.%{SOABI_optimized}.so +%{dynload_dir}/_random.%{SOABI_optimized}.so +%{dynload_dir}/_socket.%{SOABI_optimized}.so +%{dynload_dir}/_sqlite3.%{SOABI_optimized}.so +%{dynload_dir}/_ssl.%{SOABI_optimized}.so +%{dynload_dir}/_statistics.%{SOABI_optimized}.so +%{dynload_dir}/_struct.%{SOABI_optimized}.so +%{dynload_dir}/array.%{SOABI_optimized}.so +%{dynload_dir}/audioop.%{SOABI_optimized}.so +%{dynload_dir}/binascii.%{SOABI_optimized}.so +%{dynload_dir}/cmath.%{SOABI_optimized}.so +%{dynload_dir}/_datetime.%{SOABI_optimized}.so +%{dynload_dir}/fcntl.%{SOABI_optimized}.so +%{dynload_dir}/grp.%{SOABI_optimized}.so +%{dynload_dir}/math.%{SOABI_optimized}.so +%{dynload_dir}/mmap.%{SOABI_optimized}.so +%if %{with nis} +%{dynload_dir}/nis.%{SOABI_optimized}.so +%endif +%{dynload_dir}/ossaudiodev.%{SOABI_optimized}.so +%{dynload_dir}/parser.%{SOABI_optimized}.so +%{dynload_dir}/_posixshmem.%{SOABI_optimized}.so +%{dynload_dir}/pyexpat.%{SOABI_optimized}.so +%{dynload_dir}/readline.%{SOABI_optimized}.so +%{dynload_dir}/resource.%{SOABI_optimized}.so +%{dynload_dir}/select.%{SOABI_optimized}.so +%{dynload_dir}/spwd.%{SOABI_optimized}.so +%{dynload_dir}/syslog.%{SOABI_optimized}.so +%{dynload_dir}/termios.%{SOABI_optimized}.so +%{dynload_dir}/unicodedata.%{SOABI_optimized}.so +%{dynload_dir}/_uuid.%{SOABI_optimized}.so +%{dynload_dir}/xxlimited.%{SOABI_optimized}.so +%{dynload_dir}/_xxsubinterpreters.%{SOABI_optimized}.so +%{dynload_dir}/zlib.%{SOABI_optimized}.so +%{dynload_dir}/_zoneinfo.%{SOABI_optimized}.so + +%dir %{pylibdir}/site-packages/ +%dir %{pylibdir}/site-packages/__pycache__/ +%{pylibdir}/site-packages/README.txt +%{pylibdir}/*.py +%dir %{pylibdir}/__pycache__/ +%{pylibdir}/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/collections/ +%dir %{pylibdir}/collections/__pycache__/ +%{pylibdir}/collections/*.py +%{pylibdir}/collections/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/ctypes/ +%dir %{pylibdir}/ctypes/__pycache__/ +%{pylibdir}/ctypes/*.py +%{pylibdir}/ctypes/__pycache__/*%{bytecode_suffixes} +%{pylibdir}/ctypes/macholib + +%{pylibdir}/curses + +%dir %{pylibdir}/dbm/ +%dir %{pylibdir}/dbm/__pycache__/ +%{pylibdir}/dbm/*.py +%{pylibdir}/dbm/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/distutils/ +%dir %{pylibdir}/distutils/__pycache__/ +%{pylibdir}/distutils/*.py +%{pylibdir}/distutils/__pycache__/*%{bytecode_suffixes} +%{pylibdir}/distutils/README +%{pylibdir}/distutils/command + +%dir %{pylibdir}/email/ +%dir %{pylibdir}/email/__pycache__/ +%{pylibdir}/email/*.py +%{pylibdir}/email/__pycache__/*%{bytecode_suffixes} +%{pylibdir}/email/mime +%doc %{pylibdir}/email/architecture.rst + +%{pylibdir}/encodings + +%{pylibdir}/html +%{pylibdir}/http + +%dir %{pylibdir}/importlib/ +%dir %{pylibdir}/importlib/__pycache__/ +%{pylibdir}/importlib/*.py +%{pylibdir}/importlib/__pycache__/*%{bytecode_suffixes} + +%dir %{pylibdir}/json/ +%dir %{pylibdir}/json/__pycache__/ +%{pylibdir}/json/*.py +%{pylibdir}/json/__pycache__/*%{bytecode_suffixes} + +%{pylibdir}/logging +%{pylibdir}/multiprocessing + +%dir %{pylibdir}/sqlite3/ +%dir %{pylibdir}/sqlite3/__pycache__/ +%{pylibdir}/sqlite3/*.py +%{pylibdir}/sqlite3/__pycache__/*%{bytecode_suffixes} + +%if %{without flatpackage} +%exclude %{pylibdir}/turtle.py +%exclude %{pylibdir}/__pycache__/turtle*%{bytecode_suffixes} +%endif + +%{pylibdir}/urllib +%{pylibdir}/xml +%{pylibdir}/zoneinfo + +%if "%{_lib}" == "lib64" +%attr(0755,root,root) %dir %{_prefix}/lib/python%{pybasever} +%attr(0755,root,root) %dir %{_prefix}/lib/python%{pybasever}/site-packages +%attr(0755,root,root) %dir %{_prefix}/lib/python%{pybasever}/site-packages/__pycache__/ +%endif + +# "Makefile" and the config-32/64.h file are needed by +# distutils/sysconfig.py:_init_posix(), so we include them in the core +# package, along with their parent directories (bug 531901): +%dir %{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/ +%{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/Makefile +%dir %{_includedir}/python%{LDVERSION_optimized}/ +%{_includedir}/python%{LDVERSION_optimized}/%{_pyconfig_h} + +%{_libdir}/%{py_INSTSONAME_optimized} +%if %{with main_python} +%{_libdir}/libpython3.so +%endif + + +%if %{without flatpackage} +%files -n %{pkgname}-devel +%endif + +%if %{with main_python} +%{_bindir}/2to3 +%endif + +%{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/* +%if %{without flatpackage} +%exclude %{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/Makefile +%exclude %{_includedir}/python%{LDVERSION_optimized}/%{_pyconfig_h} +%endif +%{_includedir}/python%{LDVERSION_optimized}/*.h +%{_includedir}/python%{LDVERSION_optimized}/internal/ +%{_includedir}/python%{LDVERSION_optimized}/cpython/ +%doc Misc/README.valgrind Misc/valgrind-python.supp Misc/gdbinit + +%if %{with main_python} +%{_bindir}/python3-config +%{_bindir}/python-config +%{_libdir}/pkgconfig/python3.pc +%{_libdir}/pkgconfig/python.pc +%{_libdir}/pkgconfig/python3-embed.pc +%{_bindir}/pathfix.py +%{_bindir}/pygettext3.py +%{_bindir}/pygettext.py +%{_bindir}/msgfmt3.py +%{_bindir}/msgfmt.py +%endif + +%{_bindir}/pathfix%{pybasever}.py +%{_bindir}/pygettext%{pybasever}.py +%{_bindir}/msgfmt%{pybasever}.py + +%{_bindir}/python%{pybasever}-config +%{_bindir}/python%{LDVERSION_optimized}-config +%{_bindir}/python%{LDVERSION_optimized}-*-config +%{_libdir}/libpython%{LDVERSION_optimized}.so +%{_libdir}/pkgconfig/python-%{LDVERSION_optimized}.pc +%{_libdir}/pkgconfig/python-%{LDVERSION_optimized}-embed.pc +%{_libdir}/pkgconfig/python-%{pybasever}.pc +%{_libdir}/pkgconfig/python-%{pybasever}-embed.pc + +%if %{with rhel8_compat_shims} +%{_libexecdir}/platform-python-config +%{_libexecdir}/platform-python%{pybasever}-config +%{_libexecdir}/platform-python%{LDVERSION_optimized}-config +%{_libexecdir}/platform-python%{pybasever}-*-config +%{_libexecdir}/platform-python%{LDVERSION_optimized}-*-config +%endif + + +%if %{without flatpackage} +%files -n %{pkgname}-idle +%endif + +%if %{with main_python} +%{_bindir}/idle* +%else +%{_bindir}/idle%{pybasever} +%endif + +%{pylibdir}/idlelib + +%if %{with main_python} +%{_metainfodir}/idle3.appdata.xml +%{_datadir}/applications/idle3.desktop +%{_datadir}/icons/hicolor/*/apps/idle3.* +%endif + +%if %{without flatpackage} +%files -n %{pkgname}-tkinter +%endif + +%{pylibdir}/tkinter +%if %{without flatpackage} +%exclude %{pylibdir}/tkinter/test +%endif +%{dynload_dir}/_tkinter.%{SOABI_optimized}.so +%{pylibdir}/turtle.py +%{pylibdir}/__pycache__/turtle*%{bytecode_suffixes} +%dir %{pylibdir}/turtledemo +%{pylibdir}/turtledemo/*.py +%{pylibdir}/turtledemo/*.cfg +%dir %{pylibdir}/turtledemo/__pycache__/ +%{pylibdir}/turtledemo/__pycache__/*%{bytecode_suffixes} + + +%if %{without flatpackage} +%files -n %{pkgname}-test +%endif + +%{pylibdir}/ctypes/test +%{pylibdir}/distutils/tests +%{pylibdir}/sqlite3/test +%{pylibdir}/test +%{dynload_dir}/_ctypes_test.%{SOABI_optimized}.so +%{dynload_dir}/_testbuffer.%{SOABI_optimized}.so +%{dynload_dir}/_testcapi.%{SOABI_optimized}.so +%{dynload_dir}/_testimportmultiple.%{SOABI_optimized}.so +%{dynload_dir}/_testinternalcapi.%{SOABI_optimized}.so +%{dynload_dir}/_testmultiphase.%{SOABI_optimized}.so +%{dynload_dir}/_xxtestfuzz.%{SOABI_optimized}.so +%{pylibdir}/lib2to3/tests +%{pylibdir}/tkinter/test +%{pylibdir}/unittest/test + +# We don't bother splitting the debug build out into further subpackages: +# if you need it, you're probably a developer. + +# Hence the manifest is the combination of analogous files in the manifests of +# all of the other subpackages + +%if %{with debug_build} +%if %{without flatpackage} +%files -n %{pkgname}-debug +%endif + +%if %{with main_python} +%{_bindir}/python3-debug +%{_bindir}/python-debug +%endif + +# Analog of the core subpackage's files: +%{_bindir}/python%{LDVERSION_debug} + +# Analog of the -libs subpackage's files: +# ...with debug builds of the built-in "extension" modules: + +%{dynload_dir}/_blake2.%{SOABI_debug}.so + +%{dynload_dir}/_asyncio.%{SOABI_debug}.so +%{dynload_dir}/_bisect.%{SOABI_debug}.so +%{dynload_dir}/_bz2.%{SOABI_debug}.so +%{dynload_dir}/_codecs_cn.%{SOABI_debug}.so +%{dynload_dir}/_codecs_hk.%{SOABI_debug}.so +%{dynload_dir}/_codecs_iso2022.%{SOABI_debug}.so +%{dynload_dir}/_codecs_jp.%{SOABI_debug}.so +%{dynload_dir}/_codecs_kr.%{SOABI_debug}.so +%{dynload_dir}/_codecs_tw.%{SOABI_debug}.so +%{dynload_dir}/_contextvars.%{SOABI_debug}.so +%{dynload_dir}/_crypt.%{SOABI_debug}.so +%{dynload_dir}/_csv.%{SOABI_debug}.so +%{dynload_dir}/_ctypes.%{SOABI_debug}.so +%{dynload_dir}/_curses.%{SOABI_debug}.so +%{dynload_dir}/_curses_panel.%{SOABI_debug}.so +%{dynload_dir}/_dbm.%{SOABI_debug}.so +%{dynload_dir}/_decimal.%{SOABI_debug}.so +%{dynload_dir}/_elementtree.%{SOABI_debug}.so +%if %{with gdbm} +%{dynload_dir}/_gdbm.%{SOABI_debug}.so +%endif +%{dynload_dir}/_hashlib.%{SOABI_debug}.so +%{dynload_dir}/_heapq.%{SOABI_debug}.so +%{dynload_dir}/_json.%{SOABI_debug}.so +%{dynload_dir}/_lsprof.%{SOABI_debug}.so +%{dynload_dir}/_lzma.%{SOABI_debug}.so +%{dynload_dir}/_multibytecodec.%{SOABI_debug}.so +%{dynload_dir}/_multiprocessing.%{SOABI_debug}.so +%{dynload_dir}/_opcode.%{SOABI_debug}.so +%{dynload_dir}/_pickle.%{SOABI_debug}.so +%{dynload_dir}/_posixsubprocess.%{SOABI_debug}.so +%{dynload_dir}/_queue.%{SOABI_debug}.so +%{dynload_dir}/_random.%{SOABI_debug}.so +%{dynload_dir}/_socket.%{SOABI_debug}.so +%{dynload_dir}/_sqlite3.%{SOABI_debug}.so +%{dynload_dir}/_ssl.%{SOABI_debug}.so +%{dynload_dir}/_statistics.%{SOABI_debug}.so +%{dynload_dir}/_struct.%{SOABI_debug}.so +%{dynload_dir}/array.%{SOABI_debug}.so +%{dynload_dir}/audioop.%{SOABI_debug}.so +%{dynload_dir}/binascii.%{SOABI_debug}.so +%{dynload_dir}/cmath.%{SOABI_debug}.so +%{dynload_dir}/_datetime.%{SOABI_debug}.so +%{dynload_dir}/fcntl.%{SOABI_debug}.so +%{dynload_dir}/grp.%{SOABI_debug}.so +%{dynload_dir}/math.%{SOABI_debug}.so +%{dynload_dir}/mmap.%{SOABI_debug}.so +%if %{with nis} +%{dynload_dir}/nis.%{SOABI_debug}.so +%endif +%{dynload_dir}/ossaudiodev.%{SOABI_debug}.so +%{dynload_dir}/parser.%{SOABI_debug}.so +%{dynload_dir}/_posixshmem.%{SOABI_debug}.so +%{dynload_dir}/pyexpat.%{SOABI_debug}.so +%{dynload_dir}/readline.%{SOABI_debug}.so +%{dynload_dir}/resource.%{SOABI_debug}.so +%{dynload_dir}/select.%{SOABI_debug}.so +%{dynload_dir}/spwd.%{SOABI_debug}.so +%{dynload_dir}/syslog.%{SOABI_debug}.so +%{dynload_dir}/termios.%{SOABI_debug}.so +%{dynload_dir}/unicodedata.%{SOABI_debug}.so +%{dynload_dir}/_uuid.%{SOABI_debug}.so +%{dynload_dir}/_xxsubinterpreters.%{SOABI_debug}.so +%{dynload_dir}/_xxtestfuzz.%{SOABI_debug}.so +%{dynload_dir}/zlib.%{SOABI_debug}.so +%{dynload_dir}/_zoneinfo.%{SOABI_debug}.so + +# No need to split things out the "Makefile" and the config-32/64.h file as we +# do for the regular build above (bug 531901), since they're all in one package +# now; they're listed below, under "-devel": + +%{_libdir}/%{py_INSTSONAME_debug} + +# Analog of the -devel subpackage's files: +%{pylibdir}/config-%{LDVERSION_debug}-%{platform_triplet} +%{_includedir}/python%{LDVERSION_debug} +%{_bindir}/python%{LDVERSION_debug}-config +%{_bindir}/python%{LDVERSION_debug}-*-config +%{_libdir}/libpython%{LDVERSION_debug}.so +%{_libdir}/libpython%{LDVERSION_debug}.so.%{py_SOVERSION} +%{_libdir}/pkgconfig/python-%{LDVERSION_debug}.pc +%{_libdir}/pkgconfig/python-%{LDVERSION_debug}-embed.pc + +%if %{with rhel8_compat_shims} +%{_libexecdir}/platform-python-debug +%{_libexecdir}/platform-python%{LDVERSION_debug} +%{_libexecdir}/platform-python%{LDVERSION_debug}-config +%{_libexecdir}/platform-python%{LDVERSION_debug}-*-config +%endif + +# Analog of the -tools subpackage's files: +# None for now; we could build precanned versions that have the appropriate +# shebang if needed + +# Analog of the tkinter subpackage's files: +%{dynload_dir}/_tkinter.%{SOABI_debug}.so + +# Analog of the -test subpackage's files: +%{dynload_dir}/_ctypes_test.%{SOABI_debug}.so +%{dynload_dir}/_testbuffer.%{SOABI_debug}.so +%{dynload_dir}/_testcapi.%{SOABI_debug}.so +%{dynload_dir}/_testimportmultiple.%{SOABI_debug}.so +%{dynload_dir}/_testinternalcapi.%{SOABI_debug}.so +%{dynload_dir}/_testmultiphase.%{SOABI_debug}.so + +%endif # with debug_build + +# We put the debug-gdb.py file inside /usr/lib/debug to avoid noise from ldconfig +# See https://bugzilla.redhat.com/show_bug.cgi?id=562980 +# +# The /usr/lib/rpm/redhat/macros defines %%__debug_package to use +# debugfiles.list, and it appears that everything below /usr/lib/debug and +# (/usr/src/debug) gets added to this file (via LISTFILES) in +# /usr/lib/rpm/find-debuginfo.sh +# +# Hence by installing it below /usr/lib/debug we ensure it is added to the +# -debuginfo subpackage +# (if it doesn't, then the rpmbuild ought to fail since the debug-gdb.py +# payload file would be unpackaged) + +# Workaround for https://bugzilla.redhat.com/show_bug.cgi?id=1476593 +%undefine _debuginfo_subpackages + +# ====================================================== +# Finally, the changelog: +# ====================================================== + +%changelog +* Wed Feb 09 2022 Charalampos Stratakis - 3.9.10-2 +- Fix undefined behavior in Modules/_hashopenssl.c +Resolves: rhbz#1942527 + +* Mon Jan 17 2022 Charalampos Stratakis - 3.9.10-1 +- Update to 3.9.10 +- Support OpenSSL FIPS mode +Resolves: rhbz#1942527, rhbz#1835169 + +* Sat Jan 08 2022 Miro Hrončok - 3.9.9-4 +- Instruct pip to use distutils +- Instruct pypa/distutils to add /local/ addition to prefix + +* Mon Nov 22 2021 Tomas Orsava - 3.9.9-2 +- Read pre-packaged Python wheels from a newly versioned directory + /usr/share/python3-wheels +- Resolves: rhbz#1982668 + +* Tue Nov 16 2021 Tomáš Hrnčiar - 3.9.9-1 +- Update to 3.9.9 +Resolves: rhbz#2024322 + +* Mon Nov 08 2021 Tomáš Hrnčiar - 3.9.8-1 +- Update to 3.9.8 +Resolves: rhbz#2003759 + +* Thu Sep 09 2021 Miro Hrončok - 3.9.7-1 +- Update to 3.9.7 +Resolves: rhbz#1995162 + +* Fri Sep 03 2021 Charalampos Stratakis - 3.9.6-7 +- Add preliminary FIPS mode patch +Related: rhbz#1942527 + +* Thu Aug 19 2021 DJ Delorie - 3.9.6-6 +- Rebuilt for libffi 3.4.2 SONAME transition. + Related: rhbz#1891914 + +* Tue Aug 10 2021 Mohan Boddu +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Fri Aug 6 2021 Florian Weimer - 3.9.6-4 +- Rebuild to pick up new build flags from redhat-rpm-config (#1984652) + +* Thu Jul 29 2021 Charalampos Stratakis - 3.9.6-3 +- Build only blake2 from the internal hash implementations and use md5, + sha1, sha256, sha512 and sha3 from OpenSSL +Related: rhbz#1935437, rhbz#1942527 + +* Wed Jul 28 2021 Florian Weimer - 3.9.6-2 +- Rebuild to pick up OpenSSL 3.0 Beta ABI (#1984097) + +* Tue Jun 29 2021 Tomas Hrnciar - 3.9.6-1 +- Update to 3.9.6 +Related: rhbz#1950291 + +* Tue Jun 15 2021 Mohan Boddu - 3.9.5-6 +- Rebuilt for RHEL 9 BETA for openssl 3.0 + Related: rhbz#1971065 + +* Wed Jun 09 2021 Charalampos Stratakis - 3.9.5-5 +- Add virtual provides for the bundled libmpdec + +* Thu Jun 03 2021 Charalampos Stratakis - 3.9.5-4 +- Stop Recommending setuptools and move the pip Recommendation to python3-devel +Resolves: rhbz#1947857 + +* Tue May 04 2021 Tomas Hrnciar - 3.9.5-1 +- Update to 3.9.5 + +* Fri Apr 16 2021 Lumír Balhar - 3.9.4-1 +- Update to 3.9.4 + Related: rhbz#1950291 + +* Fri Apr 16 2021 Mohan Boddu +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Wed Apr 07 2021 Petr Viktorin - 3.9.2-2 +- On RHEL 9+, build without the legacy nis module + Resolves: RHBZ#1942376 + +* Sat Feb 20 2021 Miro Hrončok - 3.9.2-1 +- Update to 3.9.2 + +* Thu Feb 18 2021 Tomas Hrnciar - 3.9.2~rc1-1 +- Update to 3.9.2rc1 + +* Wed Jan 27 2021 Fedora Release Engineering - 3.9.1-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Mon Jan 25 2021 Miro Hrončok - 3.9.1-4 +- Rebuilt to be signed with Fedora 32 compatible signature, + to fix mock bootstrap chroot on Fedora 32 (and possibly EPELs) + https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/message/OBEFWGCFXHE4EDBXFBZWDUPAJJS7QZAR/ + +* Wed Jan 20 2021 Charalampos Stratakis - 3.9.1-3 +- Compile the debug build with -O0 instead of -Og (rhbz#1818857) + +* Wed Jan 20 2021 Miro Hrončok - 3.9.1-2 +- Security fix for CVE-2021-3177 + +* Tue Dec 08 2020 Tomas Hrnciar - 3.9.1-1 +- Update to 3.9.1 + +* Fri Nov 27 2020 Tomas Hrnciar - 3.9.1~rc1-1 +- Update to 3.9.1rc1 + +* Tue Oct 06 2020 Miro Hrončok - 3.9.0-1 +- Update to 3.9.0 final + +* Fri Sep 25 2020 Miro Hrončok - 3.9.0~rc2-2 +- Use upstream architecture names on Fedora 34+ +- https://fedoraproject.org/wiki/Changes/Python_Upstream_Architecture_Names + +* Thu Sep 17 2020 Miro Hrončok - 3.9.0~rc2-1 +- Update to 3.9.0rc2 + +* Wed Aug 12 2020 Petr Viktorin - 3.9.0~rc1-2 +- In sys.version and initial REPL message, list the source commit as "default" + +* Tue Aug 11 2020 Miro Hrončok - 3.9.0~rc1-1 +- Update to 3.9.0rc1 + +* Mon Aug 03 2020 Lumír Balhar - 3.9.0~b5-5 +- Add support for upstream architectures' names (patch 353) + +* Thu Jul 30 2020 Miro Hrončok - 3.9.0~b5-4 +- Make python3-libs installable without python3 + Resolves: rhbz#1862082 + +* Wed Jul 29 2020 Fedora Release Engineering - 3.9.0~b5-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Fri Jul 24 2020 Lumír Balhar - 3.9.0~b5-2 +- Add versioned pathfix%%{pybasever}.py to main and non-main RPMs + +* Mon Jul 20 2020 Miro Hrončok - 3.9.0~b5-1 +- Update to 3.9.0b5 + +* Thu Jul 16 2020 Marcel Plch - 3.9.0~b4-2 +- Remove large, autogenerated Python sources and redundant pycache levels to reduce filesystem footprint + +* Sat Jul 04 2020 Tomas Hrnciar - 3.9.0~b4-1 +- Update to 3.9.0b4 + +* Wed Jun 10 2020 Miro Hrončok - 3.9.0~b3-1 +- Update to 3.9.0b3 + +* Tue Jun 09 2020 Miro Hrončok - 3.9.0~b2-1 +- Update to 3.9.0b2 + +* Fri May 29 2020 Petr Viktorin - 3.9.0~b1-4 +- Add cherry-picks for bugs found in 3.9.0b1 + +* Thu May 21 2020 Miro Hrončok - 3.9.0~b1-3 +- Rebuilt for https://fedoraproject.org/wiki/Changes/Python3.9 + +* Thu May 21 2020 Miro Hrončok - 3.9.0~b1-2 +- Bootstrap for https://fedoraproject.org/wiki/Changes/Python3.9 + +* Tue May 19 2020 Miro Hrončok - 3.9.0~b1-1 +- Update to Python 3.9.0b1 + +* Thu May 07 2020 Tomas Orsava - 3.9.0~a6-2 +- Rename from python39 to python3.9 + +* Tue Apr 28 2020 Miro Hrončok - 3.9.0~a6-1 +- Update to Python 3.9.0a6 + +* Tue Mar 24 2020 Miro Hrončok - 3.9.0~a5-1 +- Update to Python 3.9.0a5 + +* Thu Feb 27 2020 Marcel Plch - 3.9.0~a4-1 +- Update to Python 3.9.0a4 + +* Tue Feb 11 2020 Miro Hrončok - 3.9.0~a3-2 +- Update the ensurepip module to work with setuptools >= 45 + +* Mon Jan 27 2020 Victor Stinner - 3.9.0~a3-1 +- Update to Python 3.9.0a3 + +* Thu Dec 19 2019 Miro Hrončok - 3.9.0~a2-1 +- Rebased to Python 3.9.0a2 + +* Wed Dec 04 2019 Miro Hrončok - 3.9.0~a1-3 +- Build Python with -fno-semantic-interposition for better performance +- https://fedoraproject.org/wiki/Changes/PythonNoSemanticInterpositionSpeedup + +* Thu Nov 28 2019 Miro Hrončok - 3.9.0~a1-2 +- Don't remove the test.test_tools module + +* Wed Nov 20 2019 Miro Hrončok - 3.9.0~a1-1 +- Rebased to Python 3.9.0a1 + +* Mon Oct 14 2019 Miro Hrončok - 3.8.0-1 +- Update to Python 3.8.0 final + +* Tue Oct 01 2019 Miro Hrončok - 3.8.0~rc1-1 +- Rebased to Python 3.8.0rc1 + +* Sat Aug 31 2019 Miro Hrončok - 3.8.0~b4-1 +- Rebased to Python 3.8.0b4 +- Enable Profile-guided optimization for all arches, not just x86 (#1741015) + +* Mon Jul 29 2019 Miro Hrončok - 3.8.0~b3-1 +- Update to 3.8.0b3 + +* Fri Jul 26 2019 Fedora Release Engineering - 3.8.0~b2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Fri Jul 05 2019 Miro Hrončok - 3.8.0~b2-1 +- Update to 3.8.0b2 + +* Wed Jun 05 2019 Miro Hrončok - 3.8.0~b1-1 +- Update to 3.8.0b1 + +* Fri May 17 2019 Miro Hrončok - 3.8.0~a4-2 +- Remove a faulty patch that resulted in invalid value of + distutils.sysconfig.get_config_var('LIBPL') (#1710767) + +* Tue May 07 2019 Miro Hrončok - 3.8.0~a4-1 +- Update to 3.8.0a4 + +* Tue Mar 26 2019 Miro Hrončok - 3.8.0~a3-1 +- Update to 3.8.0a3 + +* Mon Feb 25 2019 Miro Hrončok - 3.8.0~a2-1 +- Update to 3.8.0a2 + +* Mon Feb 18 2019 Miro Hrončok - 3.8.0~a1-3 +- Reduced default build flags used to build extension modules + https://fedoraproject.org/wiki/Changes/Python_Extension_Flags + +* Sun Feb 17 2019 Igor Gnatenko - 3.8.0~a1-2 +- Rebuild for readline 8.0 + +* Tue Feb 05 2019 Miro Hrončok - 3.8.0~a1-1 +- Update to 3.8.0a1