From 09e27f7b72bfc3f8ec89a220a873c3b33882bda6 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Apr 28 2020 09:12:21 +0000 Subject: import python38-3.8.0-6.module+el8.2.0+5978+503155c0 --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0a63432 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/Python-3.8.0.tar.xz diff --git a/.python38.metadata b/.python38.metadata new file mode 100644 index 0000000..f6fe148 --- /dev/null +++ b/.python38.metadata @@ -0,0 +1 @@ +7720e0384558c598107cf046c48165fd7e1f5b2c SOURCES/Python-3.8.0.tar.xz diff --git a/SOURCES/00001-rpath.patch b/SOURCES/00001-rpath.patch new file mode 100644 index 0000000..d9dd3ce --- /dev/null +++ b/SOURCES/00001-rpath.patch @@ -0,0 +1,33 @@ +From 8ecb6d320c03242ca94bf2e99d9d80510d5011e1 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 d10a78da31..4df4b67810 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) +-- +2.21.0 + diff --git a/SOURCES/00102-lib64.patch b/SOURCES/00102-lib64.patch new file mode 100644 index 0000000..f1f0c8d --- /dev/null +++ b/SOURCES/00102-lib64.patch @@ -0,0 +1,261 @@ +From b9f1dd6be195cc3b11a80e6f0dde2096dd8b9855 Mon Sep 17 00:00:00 2001 +From: David Malcolm +Date: Wed, 13 Jan 2010 21:25:18 +0000 +Subject: [PATCH] 00102: Change the various install paths to use /usr/lib64/ + instead or /usr/lib/ +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Only used when "%{_lib}" == "lib64". + +Co-authored-by: David Malcolm +Co-authored-by: Thomas Spura +Co-authored-by: Slavek Kabrda +Co-authored-by: Matej Stuchlik +Co-authored-by: Tomas Orsava +Co-authored-by: Charalampos Stratakis +Co-authored-by: Petr Viktorin +Co-authored-by: Miro Hrončok +Co-authored-by: Iryna Shcherbina +--- + Lib/distutils/command/install.py | 4 ++-- + Lib/distutils/sysconfig.py | 6 +++++- + Lib/distutils/tests/test_install.py | 3 ++- + Lib/site.py | 4 ++++ + Lib/sysconfig.py | 12 ++++++------ + Lib/test/test_site.py | 4 ++-- + Makefile.pre.in | 2 +- + Modules/getpath.c | 6 +++--- + configure | 4 ++-- + configure.ac | 4 ++-- + setup.py | 6 +++--- + 11 files changed, 32 insertions(+), 23 deletions(-) + +diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py +index c625c95bf7..ae4f915669 100644 +--- a/Lib/distutils/command/install.py ++++ b/Lib/distutils/command/install.py +@@ -30,14 +30,14 @@ WINDOWS_SCHEME = { + INSTALL_SCHEMES = { + 'unix_prefix': { + 'purelib': '$base/lib/python$py_version_short/site-packages', +- 'platlib': '$platbase/lib/python$py_version_short/site-packages', ++ 'platlib': '$platbase/lib64/python$py_version_short/site-packages', + 'headers': '$base/include/python$py_version_short$abiflags/$dist_name', + 'scripts': '$base/bin', + 'data' : '$base', + }, + 'unix_home': { + 'purelib': '$base/lib/python', +- 'platlib': '$base/lib/python', ++ 'platlib': '$base/lib64/python', + 'headers': '$base/include/python/$dist_name', + 'scripts': '$base/bin', + 'data' : '$base', +diff --git a/Lib/distutils/sysconfig.py b/Lib/distutils/sysconfig.py +index b51629eb94..9a4892a737 100644 +--- a/Lib/distutils/sysconfig.py ++++ b/Lib/distutils/sysconfig.py +@@ -146,8 +146,12 @@ def get_python_lib(plat_specific=0, standard_lib=0, prefix=None): + prefix = plat_specific and EXEC_PREFIX or PREFIX + + if os.name == "posix": ++ if plat_specific or standard_lib: ++ lib = "lib64" ++ else: ++ lib = "lib" + libpython = os.path.join(prefix, +- "lib", "python" + get_python_version()) ++ lib, "python" + get_python_version()) + if standard_lib: + return libpython + else: +diff --git a/Lib/distutils/tests/test_install.py b/Lib/distutils/tests/test_install.py +index 287ab1989e..d4c05e0ab1 100644 +--- a/Lib/distutils/tests/test_install.py ++++ b/Lib/distutils/tests/test_install.py +@@ -57,8 +57,9 @@ class InstallTestCase(support.TempdirManager, + self.assertEqual(got, expected) + + libdir = os.path.join(destination, "lib", "python") ++ platlibdir = os.path.join(destination, "lib64", "python") + check_path(cmd.install_lib, libdir) +- check_path(cmd.install_platlib, libdir) ++ check_path(cmd.install_platlib, platlibdir) + check_path(cmd.install_purelib, libdir) + check_path(cmd.install_headers, + os.path.join(destination, "include", "python", "foopkg")) +diff --git a/Lib/site.py b/Lib/site.py +index a065ab0b5d..22d53fa562 100644 +--- a/Lib/site.py ++++ b/Lib/site.py +@@ -335,11 +335,15 @@ def getsitepackages(prefixes=None): + seen.add(prefix) + + if os.sep == '/': ++ sitepackages.append(os.path.join(prefix, "lib64", ++ "python" + sys.version[:3], ++ "site-packages")) + sitepackages.append(os.path.join(prefix, "lib", + "python%d.%d" % sys.version_info[:2], + "site-packages")) + else: + sitepackages.append(prefix) ++ sitepackages.append(os.path.join(prefix, "lib64", "site-packages")) + sitepackages.append(os.path.join(prefix, "lib", "site-packages")) + return sitepackages + +diff --git a/Lib/sysconfig.py b/Lib/sysconfig.py +index b9e2fafbc0..0ae6d35b69 100644 +--- a/Lib/sysconfig.py ++++ b/Lib/sysconfig.py +@@ -20,10 +20,10 @@ __all__ = [ + + _INSTALL_SCHEMES = { + 'posix_prefix': { +- 'stdlib': '{installed_base}/lib/python{py_version_short}', +- 'platstdlib': '{platbase}/lib/python{py_version_short}', ++ 'stdlib': '{installed_base}/lib64/python{py_version_short}', ++ 'platstdlib': '{platbase}/lib64/python{py_version_short}', + 'purelib': '{base}/lib/python{py_version_short}/site-packages', +- 'platlib': '{platbase}/lib/python{py_version_short}/site-packages', ++ 'platlib': '{platbase}/lib64/python{py_version_short}/site-packages', + 'include': + '{installed_base}/include/python{py_version_short}{abiflags}', + 'platinclude': +@@ -62,10 +62,10 @@ _INSTALL_SCHEMES = { + 'data': '{userbase}', + }, + 'posix_user': { +- 'stdlib': '{userbase}/lib/python{py_version_short}', +- 'platstdlib': '{userbase}/lib/python{py_version_short}', ++ 'stdlib': '{userbase}/lib64/python{py_version_short}', ++ 'platstdlib': '{userbase}/lib64/python{py_version_short}', + 'purelib': '{userbase}/lib/python{py_version_short}/site-packages', +- 'platlib': '{userbase}/lib/python{py_version_short}/site-packages', ++ 'platlib': '{userbase}/lib64/python{py_version_short}/site-packages', + 'include': '{userbase}/include/python{py_version_short}', + 'scripts': '{userbase}/bin', + 'data': '{userbase}', +diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py +index 41c4229919..543c88432a 100644 +--- a/Lib/test/test_site.py ++++ b/Lib/test/test_site.py +@@ -266,8 +266,8 @@ class HelperFunctionsTests(unittest.TestCase): + dirs = site.getsitepackages() + if os.sep == '/': + # OS X, Linux, FreeBSD, etc +- self.assertEqual(len(dirs), 1) +- wanted = os.path.join('xoxo', 'lib', ++ self.assertEqual(len(dirs), 2) ++ wanted = os.path.join('xoxo', 'lib64', + 'python%d.%d' % sys.version_info[:2], + 'site-packages') + self.assertEqual(dirs[0], wanted) +diff --git a/Makefile.pre.in b/Makefile.pre.in +index 502317aa0c..4ad3df1122 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -143,7 +143,7 @@ LIBDIR= @libdir@ + MANDIR= @mandir@ + INCLUDEDIR= @includedir@ + CONFINCLUDEDIR= $(exec_prefix)/include +-SCRIPTDIR= $(prefix)/lib ++SCRIPTDIR= $(prefix)/lib64 + ABIFLAGS= @ABIFLAGS@ + + # Detailed destination directories +diff --git a/Modules/getpath.c b/Modules/getpath.c +index b727f66953..a0c5fb6139 100644 +--- a/Modules/getpath.c ++++ b/Modules/getpath.c +@@ -730,7 +730,7 @@ calculate_exec_prefix(PyCalculatePath *calculate, _PyPathConfig *pathconfig, + if (safe_wcscpy(exec_prefix, calculate->exec_prefix, exec_prefix_len) < 0) { + return PATHLEN_ERR(); + } +- status = joinpath(exec_prefix, L"lib/lib-dynload", exec_prefix_len); ++ status = joinpath(exec_prefix, L"lib64/lib-dynload", exec_prefix_len); + if (_PyStatus_EXCEPTION(status)) { + return status; + } +@@ -1067,7 +1067,7 @@ calculate_zip_path(PyCalculatePath *calculate, const wchar_t *prefix, + return PATHLEN_ERR(); + } + } +- status = joinpath(zip_path, L"lib/python00.zip", zip_path_len); ++ status = joinpath(zip_path, L"lib64/python00.zip", zip_path_len); + if (_PyStatus_EXCEPTION(status)) { + return status; + } +@@ -1197,7 +1197,7 @@ calculate_init(PyCalculatePath *calculate, const PyConfig *config) + if (!calculate->exec_prefix) { + return DECODE_LOCALE_ERR("EXEC_PREFIX define", len); + } +- calculate->lib_python = Py_DecodeLocale("lib/python" VERSION, &len); ++ calculate->lib_python = Py_DecodeLocale("lib64/python" VERSION, &len); + if (!calculate->lib_python) { + return DECODE_LOCALE_ERR("EXEC_PREFIX define", len); + } +diff --git a/configure b/configure +index 2a933cdbeb..bec365124e 100755 +--- a/configure ++++ b/configure +@@ -15182,9 +15182,9 @@ fi + + + if test x$PLATFORM_TRIPLET = x; then +- LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}" ++ LIBPL='$(prefix)'"/lib64/python${VERSION}/config-${LDVERSION}" + else +- LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}" ++ LIBPL='$(prefix)'"/lib64/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}" + fi + + +diff --git a/configure.ac b/configure.ac +index a189d42c2c..154a0aa5cc 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -4668,9 +4668,9 @@ fi + dnl define LIBPL after ABIFLAGS and LDVERSION is defined. + AC_SUBST(PY_ENABLE_SHARED) + if test x$PLATFORM_TRIPLET = x; then +- LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}" ++ LIBPL='$(prefix)'"/lib64/python${VERSION}/config-${LDVERSION}" + else +- LIBPL='$(prefix)'"/lib/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}" ++ LIBPL='$(prefix)'"/lib64/python${VERSION}/config-${LDVERSION}-${PLATFORM_TRIPLET}" + fi + AC_SUBST(LIBPL) + +diff --git a/setup.py b/setup.py +index 20d7f35652..024a1035c0 100644 +--- a/setup.py ++++ b/setup.py +@@ -649,7 +649,7 @@ class PyBuildExt(build_ext): + # directories (i.e. '.' and 'Include') must be first. See issue + # 10520. + if not CROSS_COMPILING: +- add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib') ++ add_dir_to_list(self.compiler.library_dirs, '/usr/local/lib64') + add_dir_to_list(self.compiler.include_dirs, '/usr/local/include') + # only change this for cross builds for 3.3, issues on Mageia + if CROSS_COMPILING: +@@ -953,11 +953,11 @@ class PyBuildExt(build_ext): + elif curses_library: + readline_libs.append(curses_library) + elif self.compiler.find_library_file(self.lib_dirs + +- ['/usr/lib/termcap'], ++ ['/usr/lib64/termcap'], + 'termcap'): + readline_libs.append('termcap') + self.add(Extension('readline', ['readline.c'], +- library_dirs=['/usr/lib/termcap'], ++ library_dirs=['/usr/lib64/termcap'], + extra_link_args=readline_extra_link_args, + libraries=readline_libs)) + else: +-- +2.21.0 + diff --git a/SOURCES/00111-no-static-lib.patch b/SOURCES/00111-no-static-lib.patch new file mode 100644 index 0000000..361af70 --- /dev/null +++ b/SOURCES/00111-no-static-lib.patch @@ -0,0 +1,78 @@ +From f6df02cde47874f10e183ead483c90941bb8076f 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 4ad3df1122..72d202d71b 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -562,7 +562,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) ++$(BUILDPYTHON): Programs/python.o $(LDLIBRARY) $(PY3LIBRARY) + $(LINKCC) $(PY_CORE_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/python.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) + + platform: $(BUILDPYTHON) pybuilddir.txt +@@ -610,12 +610,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); \ +@@ -693,7 +687,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) ++Programs/_testembed: Programs/_testembed.o $(LDLIBRARY) $(PY3LIBRARY) + $(LINKCC) $(PY_CORE_LDFLAGS) $(LINKFORSHARED) -o $@ Programs/_testembed.o $(BLDLIBRARY) $(LIBS) $(MODLIBS) $(SYSLIBS) + + ############################################################################ +@@ -1557,17 +1551,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 +-- +2.21.0 + diff --git a/SOURCES/00189-use-rpm-wheels.patch b/SOURCES/00189-use-rpm-wheels.patch new file mode 100644 index 0000000..83487e3 --- /dev/null +++ b/SOURCES/00189-use-rpm-wheels.patch @@ -0,0 +1,64 @@ +From e5c11f104e1d2543ac3ba4b3f0a7989821e57947 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 +--- + Lib/ensurepip/__init__.py | 26 +++++++++++++++++--------- + 1 file changed, 17 insertions(+), 9 deletions(-) + +diff --git a/Lib/ensurepip/__init__.py b/Lib/ensurepip/__init__.py +index fc0edec6e3..4d17e413db 100644 +--- a/Lib/ensurepip/__init__.py ++++ b/Lib/ensurepip/__init__.py +@@ -1,16 +1,27 @@ ++import distutils.version ++import glob + import os + import os.path +-import pkgutil + import sys + import tempfile + + + __all__ = ["version", "bootstrap"] + ++_WHEEL_DIR = "/usr/share/python38-wheels/" + +-_SETUPTOOLS_VERSION = "41.2.0" + +-_PIP_VERSION = "19.2.3" ++def _get_most_recent_wheel_version(pkg): ++ prefix = os.path.join(_WHEEL_DIR, "{}-".format(pkg)) ++ suffix = "-py2.py3-none-any.whl" ++ pattern = "{}*{}".format(prefix, suffix) ++ versions = (p[len(prefix):-len(suffix)] for p in glob.glob(pattern)) ++ return str(max(versions, key=distutils.version.LooseVersion)) ++ ++ ++_SETUPTOOLS_VERSION = _get_most_recent_wheel_version("setuptools") ++ ++_PIP_VERSION = _get_most_recent_wheel_version("pip") + + _PROJECTS = [ + ("setuptools", _SETUPTOOLS_VERSION), +@@ -96,12 +107,9 @@ def _bootstrap(*, root=None, upgrade=False, user=False, + additional_paths = [] + for project, version in _PROJECTS: + wheel_name = "{}-{}-py2.py3-none-any.whl".format(project, version) +- whl = pkgutil.get_data( +- "ensurepip", +- "_bundled/{}".format(wheel_name), +- ) +- with open(os.path.join(tmpdir, wheel_name), "wb") as fp: +- fp.write(whl) ++ 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)) + +-- +2.21.0 + diff --git a/SOURCES/00251-change-user-install-location.patch b/SOURCES/00251-change-user-install-location.patch new file mode 100644 index 0000000..1e0ddbb --- /dev/null +++ b/SOURCES/00251-change-user-install-location.patch @@ -0,0 +1,64 @@ +From 76330e0a8798b3b03160edc7e8d42d3dbee756fd 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 + +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 +--- + Lib/distutils/command/install.py | 15 +++++++++++++-- + Lib/site.py | 9 ++++++++- + 2 files changed, 21 insertions(+), 3 deletions(-) + +diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py +index ae4f915669..0e4fd5b74a 100644 +--- a/Lib/distutils/command/install.py ++++ b/Lib/distutils/command/install.py +@@ -418,8 +418,19 @@ 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 is set to sys.prefix + /local/ ++ # if neither RPM build nor virtual environment is ++ # detected to make pip and distutils install packages ++ # into the separate location. ++ if (not (hasattr(sys, 'real_prefix') or ++ sys.prefix != sys.base_prefix) and ++ 'RPM_BUILD_ROOT' not in os.environ): ++ addition = "/local" ++ else: ++ addition = "" ++ ++ self.prefix = os.path.normpath(sys.prefix) + addition ++ self.exec_prefix = os.path.normpath(sys.exec_prefix) + addition + + else: + if self.exec_prefix is None: +diff --git a/Lib/site.py b/Lib/site.py +index 22d53fa562..9513526109 100644 +--- a/Lib/site.py ++++ b/Lib/site.py +@@ -348,7 +348,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) +-- +2.21.0 + diff --git a/SOURCES/00274-fix-arch-names.patch b/SOURCES/00274-fix-arch-names.patch new file mode 100644 index 0000000..f383a58 --- /dev/null +++ b/SOURCES/00274-fix-arch-names.patch @@ -0,0 +1,86 @@ +From 64c67dbfa789f242e8ffd1ac88bafb4df2842401 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 28 Aug 2017 17:16:46 +0200 +Subject: [PATCH] 00274: Upstream uses Debian-style architecture naming, change + to match Fedora +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Co-authored-by: Petr Viktorin +Co-authored-by: Miro Hrončok +Co-authored-by: Tomas Orsava +--- + config.sub | 2 +- + configure.ac | 16 ++++++++-------- + 2 files changed, 9 insertions(+), 9 deletions(-) + +diff --git a/config.sub b/config.sub +index ba37cf99e2..52a9ec6662 100755 +--- a/config.sub ++++ b/config.sub +@@ -1042,7 +1042,7 @@ case $basic_machine in + ;; + ppc64) basic_machine=powerpc64-unknown + ;; +- ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ppc64-* | ppc64p7-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little) + basic_machine=powerpc64le-unknown +diff --git a/configure.ac b/configure.ac +index 154a0aa5cc..273954f461 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -741,9 +741,9 @@ cat >> conftest.c <> conftest.c <> conftest.c < +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 +--- + 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 21736896af..310bed5620 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 d6677ab45f..88059b127e 100644 +--- a/Lib/test/test_py_compile.py ++++ b/Lib/test/test_py_compile.py +@@ -17,6 +17,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 + +@@ -27,6 +28,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 + +-- +2.21.0 + diff --git a/SOURCES/00329-fips.patch b/SOURCES/00329-fips.patch new file mode 100644 index 0000000..11371c9 --- /dev/null +++ b/SOURCES/00329-fips.patch @@ -0,0 +1,7136 @@ +From 85855cf6fdc076dee6cd884c8b46d491458c431e Mon Sep 17 00:00:00 2001 +From: "Miss Islington (bot)" + <31488909+miss-islington@users.noreply.github.com> +Date: Thu, 17 Oct 2019 20:48:42 -0700 +Subject: [PATCH 01/32] bpo-33604: Raise TypeError on missing hmac arg. + (GH-16805) + +Also updates the documentation to clarify the situation surrounding +the digestmod parameter that is required despite its position in the +argument list as of 3.8.0 as well as removing old python2 era +references to "binary strings". + +We indavertently had this raise ValueError in 3.8.0 for the missing +arg. This is not considered an API change as no reasonable code would +be catching this missing argument error in order to handle it. +(cherry picked from commit f33c57d5c780da1500619f548585792bb5b750ee) + +Co-authored-by: Gregory P. Smith +--- + Doc/library/hmac.rst | 8 +-- + Lib/hmac.py | 53 ++++++++++--------- + Lib/test/test_hmac.py | 7 ++- + .../2019-10-15-09-47-40.bpo-33604.J12cWT.rst | 3 ++ + 4 files changed, 43 insertions(+), 28 deletions(-) + create mode 100644 Misc/NEWS.d/next/Library/2019-10-15-09-47-40.bpo-33604.J12cWT.rst + +diff --git a/Doc/library/hmac.rst b/Doc/library/hmac.rst +index dc994b07c35..57ac8bb1612 100644 +--- a/Doc/library/hmac.rst ++++ b/Doc/library/hmac.rst +@@ -14,12 +14,13 @@ + This module implements the HMAC algorithm as described by :rfc:`2104`. + + +-.. function:: new(key, msg=None, digestmod=None) ++.. function:: new(key, msg=None, digestmod='') + + Return a new hmac object. *key* is a bytes or bytearray object giving the + secret key. If *msg* is present, the method call ``update(msg)`` is made. + *digestmod* is the digest name, digest constructor or module for the HMAC +- object to use. It supports any name suitable to :func:`hashlib.new`. ++ object to use. It may be any name suitable to :func:`hashlib.new`. ++ Despite its argument position, it is required. + + .. versionchanged:: 3.4 + Parameter *key* can be a bytes or bytearray object. +@@ -28,6 +29,8 @@ This module implements the HMAC algorithm as described by :rfc:`2104`. + + .. deprecated-removed:: 3.4 3.8 + MD5 as implicit default digest for *digestmod* is deprecated. ++ The digestmod parameter is now required. Pass it as a keyword ++ argument to avoid awkwardness when you do not have an initial msg. + + + .. function:: digest(key, msg, digest) +@@ -127,7 +130,6 @@ This module also provides the following helper function: + a timing attack could theoretically reveal information about the + types and lengths of *a* and *b*—but not their values. + +- + .. versionadded:: 3.3 + + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 890eaba08e8..b769876e6f7 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -1,4 +1,4 @@ +-"""HMAC (Keyed-Hashing for Message Authentication) Python module. ++"""HMAC (Keyed-Hashing for Message Authentication) module. + + Implements the HMAC algorithm as described by RFC 2104. + """ +@@ -30,23 +30,25 @@ class HMAC: + """ + blocksize = 64 # 512-bit HMAC; can be changed in subclasses. + +- def __init__(self, key, msg = None, digestmod = None): ++ def __init__(self, key, msg=None, digestmod=''): + """Create a new HMAC object. + +- key: key for the keyed hash object. +- msg: Initial input for the hash, if provided. +- digestmod: Required. A module supporting PEP 247. *OR* +- A hashlib constructor returning a new hash object. *OR* +- A hash name suitable for hashlib.new(). ++ key: bytes or buffer, key for the keyed hash object. ++ msg: bytes or buffer, Initial input for the hash or None. ++ digestmod: A hash name suitable for hashlib.new(). *OR* ++ A hashlib constructor returning a new hash object. *OR* ++ A module supporting PEP 247. + +- Note: key and msg must be a bytes or bytearray objects. ++ Required as of 3.8, despite its position after the optional ++ 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 digestmod is None: +- raise ValueError('`digestmod` is required.') ++ if not digestmod: ++ raise TypeError("Missing required parameter 'digestmod'.") + + if callable(digestmod): + self.digest_cons = digestmod +@@ -90,8 +92,7 @@ class HMAC: + return "hmac-" + self.inner.name + + def update(self, msg): +- """Update this hashing object with the string msg. +- """ ++ """Feed data from msg into this hashing object.""" + self.inner.update(msg) + + def copy(self): +@@ -119,7 +120,7 @@ class HMAC: + def digest(self): + """Return the hash value of this hashing object. + +- This returns a string containing 8-bit data. The object is ++ This returns the hmac value as bytes. The object is + not altered in any way by this function; you can continue + updating the object after calling this function. + """ +@@ -132,30 +133,34 @@ class HMAC: + h = self._current() + return h.hexdigest() + +-def new(key, msg = None, digestmod = None): ++def new(key, msg=None, digestmod=''): + """Create a new hashing object and return it. + +- key: The starting key for the hash. +- msg: if available, will immediately be hashed into the object's starting +- state. ++ key: bytes or buffer, The starting key for the hash. ++ msg: bytes or buffer, Initial input for the hash, or None. ++ digestmod: A hash name suitable for hashlib.new(). *OR* ++ A hashlib constructor returning a new hash object. *OR* ++ A module supporting PEP 247. ++ ++ Required as of 3.8, despite its position after the optional ++ msg argument. Passing it as a keyword argument is ++ recommended, though not required for legacy API reasons. + +- You can now feed arbitrary strings into the object using its update() ++ You can now feed arbitrary bytes into the object using its update() + method, and can ask for the hash value at any time by calling its digest() +- method. ++ or hexdigest() methods. + """ + return HMAC(key, msg, digestmod) + + + def digest(key, msg, digest): +- """Fast inline implementation of HMAC ++ """Fast inline implementation of HMAC. + +- key: key for the keyed hash object. +- msg: input message ++ key: bytes or buffer, The key for the keyed hash object. ++ msg: bytes or buffer, Input message. + digest: A hash name suitable for hashlib.new() for best performance. *OR* + A hashlib constructor returning a new hash object. *OR* + A module supporting PEP 247. +- +- Note: key and msg must be a bytes or bytearray objects. + """ + if (_hashopenssl is not None and + isinstance(digest, str) and digest in _openssl_md_meths): +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index 1bbf201727d..ea00367c802 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -312,10 +312,15 @@ class TestVectorsTestCase(unittest.TestCase): + self.fail('Expected warning about small block_size') + + def test_with_digestmod_no_default(self): +- with self.assertRaises(ValueError): ++ """The digestmod parameter is required as of Python 3.8.""" ++ with self.assertRaisesRegex(TypeError, r'required.*digestmod'): + key = b"\x0b" * 16 + data = b"Hi There" + hmac.HMAC(key, data, digestmod=None) ++ with self.assertRaisesRegex(TypeError, r'required.*digestmod'): ++ hmac.new(key, data) ++ with self.assertRaisesRegex(TypeError, r'required.*digestmod'): ++ hmac.HMAC(key, msg=data, digestmod='') + + + class ConstructorTestCase(unittest.TestCase): +diff --git a/Misc/NEWS.d/next/Library/2019-10-15-09-47-40.bpo-33604.J12cWT.rst b/Misc/NEWS.d/next/Library/2019-10-15-09-47-40.bpo-33604.J12cWT.rst +new file mode 100644 +index 00000000000..fbd73003cfc +--- /dev/null ++++ b/Misc/NEWS.d/next/Library/2019-10-15-09-47-40.bpo-33604.J12cWT.rst +@@ -0,0 +1,3 @@ ++Fixed `hmac.new` and `hmac.HMAC` to raise TypeError instead of ValueError ++when the digestmod parameter, now required in 3.8, is omitted. Also ++clarified the hmac module documentation and docstrings. +-- +2.21.1 + + +From f01bee1d24524c80d446f702e8b8ff054a583064 Mon Sep 17 00:00:00 2001 +From: "Miss Islington (bot)" + <31488909+miss-islington@users.noreply.github.com> +Date: Thu, 5 Dec 2019 08:51:30 -0800 +Subject: [PATCH 02/32] [3.8] bpo-38270: Fix indentation of test_hmac + assertions (GH-17446) (GH-17450) + +Since https://github.com/python/cpython/commit/c64a1a61e6fc542cada40eb069a239317e1af36e two assertions were indented and thus ignored when running test_hmac. + +This PR fixes it. As the change is quite trivial I didn't add a NEWS entry. + + +https://bugs.python.org/issue38270 +(cherry picked from commit 894331838b256412c95d54051ec46a1cb96f52e7) + + +Co-authored-by: stratakis + + +https://bugs.python.org/issue38270 + + + +Automerge-Triggered-By: @tiran +--- + Lib/test/test_hmac.py | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index ea00367c802..23c108f6e3c 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -367,7 +367,7 @@ class ConstructorTestCase(unittest.TestCase): + digestmod="sha256") + except Exception: + self.fail("Constructor call with bytearray arguments raised exception.") +- self.assertEqual(h.hexdigest(), self.expected) ++ self.assertEqual(h.hexdigest(), self.expected) + + @requires_hashdigest('sha256') + def test_with_memoryview_msg(self): +@@ -375,7 +375,7 @@ class ConstructorTestCase(unittest.TestCase): + h = hmac.HMAC(b"key", memoryview(b"hash this!"), digestmod="sha256") + except Exception: + self.fail("Constructor call with memoryview msg raised exception.") +- self.assertEqual(h.hexdigest(), self.expected) ++ self.assertEqual(h.hexdigest(), self.expected) + + @requires_hashdigest('sha256') + def test_withmodule(self): +-- +2.21.1 + + +From 480c5e0c1fd8ed871f54b124528b35e570839a09 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 25 Jul 2019 16:19:52 +0200 +Subject: [PATCH 03/32] Expose OpenSSL FIPS_mode() as hashlib.get_fips_mode() + +--- + Lib/hashlib.py | 5 +++++ + Modules/_hashopenssl.c | 37 +++++++++++++++++++++++++++++++++ + Modules/clinic/_hashopenssl.c.h | 25 +++++++++++++++++++++- + 3 files changed, 66 insertions(+), 1 deletion(-) + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 56873b7278b..63ae8368aba 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -243,6 +243,11 @@ try: + except ImportError: + pass + ++try: ++ from _hashlib import get_fips_mode ++except ImportError: ++ pass ++ + + for __func_name in __always_supported: + # try them all, some may not work due to the OpenSSL +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 1513e4e35ed..43a69c73d1d 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -26,6 +26,9 @@ + #include + #include "openssl/err.h" + ++/* Expose FIPS_mode */ ++#include ++ + #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER) + /* OpenSSL < 1.1.0 */ + #define EVP_MD_CTX_new EVP_MD_CTX_create +@@ -1068,12 +1071,46 @@ generate_hash_name_list(void) + return state.set; + } + ++/*[clinic input] ++_hashlib.get_fips_mode ++ ++Determine the OpenSSL FIPS mode of operation. ++ ++Effectively any non-zero return value indicates FIPS mode; ++values other than 1 may have additional significance. ++ ++See OpenSSL documentation for the FIPS_mode() function for details. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_get_fips_mode_impl(PyObject *module) ++/*[clinic end generated code: output=ad8a7793310d3f98 input=f42a2135df2a5e11]*/ ++ ++{ ++ int result = FIPS_mode(); ++ if (result == 0) { ++ // "If the library was built without support of the FIPS Object Module, ++ // then the function will return 0 with an error code of ++ // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)." ++ // But 0 is also a valid result value. ++ ++ unsigned long errcode = ERR_peek_last_error(); ++ if (errcode) { ++ _setException(PyExc_ValueError); ++ return NULL; ++ } ++ } ++ return PyLong_FromLong(result); ++} ++ ++ + /* List of functions exported by this module */ + + static struct PyMethodDef EVP_functions[] = { + EVP_NEW_METHODDEF + PBKDF2_HMAC_METHODDEF + _HASHLIB_SCRYPT_METHODDEF ++ _HASHLIB_GET_FIPS_MODE_METHODDEF + _HASHLIB_HMAC_DIGEST_METHODDEF + _HASHLIB_OPENSSL_MD5_METHODDEF + _HASHLIB_OPENSSL_SHA1_METHODDEF +diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h +index 9aaea47e832..30fd8a9796a 100644 +--- a/Modules/clinic/_hashopenssl.c.h ++++ b/Modules/clinic/_hashopenssl.c.h +@@ -620,7 +620,30 @@ exit: + return return_value; + } + ++PyDoc_STRVAR(_hashlib_get_fips_mode__doc__, ++"get_fips_mode($module, /)\n" ++"--\n" ++"\n" ++"Determine the OpenSSL FIPS mode of operation.\n" ++"\n" ++"Effectively any non-zero return value indicates FIPS mode;\n" ++"values other than 1 may have additional significance.\n" ++"\n" ++"See OpenSSL documentation for the FIPS_mode() function for details."); ++ ++#define _HASHLIB_GET_FIPS_MODE_METHODDEF \ ++ {"get_fips_mode", (PyCFunction)_hashlib_get_fips_mode, METH_NOARGS, _hashlib_get_fips_mode__doc__}, ++ ++static PyObject * ++_hashlib_get_fips_mode_impl(PyObject *module); ++ ++static PyObject * ++_hashlib_get_fips_mode(PyObject *module, PyObject *Py_UNUSED(ignored)) ++{ ++ return _hashlib_get_fips_mode_impl(module); ++} ++ + #ifndef _HASHLIB_SCRYPT_METHODDEF + #define _HASHLIB_SCRYPT_METHODDEF + #endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */ +-/*[clinic end generated code: output=38c2637f67e9bb79 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=5467006d93e7479e input=a9049054013a1b77]*/ +-- +2.21.1 + + +From ad854d7f0fb26aea7dff9b1da50de9e81fb3ba5c Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Thu, 25 Jul 2019 17:04:06 +0200 +Subject: [PATCH 04/32] Use python's fall backs for the crypto it implements + only if we are not in FIPS mode + +--- + Lib/hashlib.py | 207 +++++++++++++++------------------------ + Lib/test/test_hashlib.py | 1 + + 2 files changed, 81 insertions(+), 127 deletions(-) + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 63ae8368aba..1bcfdf9f7f7 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -68,7 +68,6 @@ __all__ = __always_supported + ('new', 'algorithms_guaranteed', + 'algorithms_available', 'pbkdf2_hmac') + + +-__builtin_constructor_cache = {} + + __block_openssl_constructor = { + 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512', +@@ -76,54 +75,64 @@ __block_openssl_constructor = { + 'blake2b', 'blake2s', + } + +-def __get_builtin_constructor(name): +- cache = __builtin_constructor_cache +- constructor = cache.get(name) +- if constructor is not None: +- return constructor +- try: +- if name in {'SHA1', 'sha1'}: +- import _sha1 +- cache['SHA1'] = cache['sha1'] = _sha1.sha1 +- elif name in {'MD5', 'md5'}: +- import _md5 +- cache['MD5'] = cache['md5'] = _md5.md5 +- elif name in {'SHA256', 'sha256', 'SHA224', 'sha224'}: +- import _sha256 +- cache['SHA224'] = cache['sha224'] = _sha256.sha224 +- cache['SHA256'] = cache['sha256'] = _sha256.sha256 +- elif name in {'SHA512', 'sha512', 'SHA384', 'sha384'}: +- import _sha512 +- cache['SHA384'] = cache['sha384'] = _sha512.sha384 +- cache['SHA512'] = cache['sha512'] = _sha512.sha512 +- elif name in {'blake2b', 'blake2s'}: +- import _blake2 +- cache['blake2b'] = _blake2.blake2b +- cache['blake2s'] = _blake2.blake2s +- elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512'}: +- import _sha3 +- cache['sha3_224'] = _sha3.sha3_224 +- cache['sha3_256'] = _sha3.sha3_256 +- cache['sha3_384'] = _sha3.sha3_384 +- cache['sha3_512'] = _sha3.sha3_512 +- elif name in {'shake_128', 'shake_256'}: +- import _sha3 +- cache['shake_128'] = _sha3.shake_128 +- cache['shake_256'] = _sha3.shake_256 +- except ImportError: +- pass # no extension module, this hash is unsupported. +- +- constructor = cache.get(name) +- if constructor is not None: +- return constructor +- +- raise ValueError('unsupported hash type ' + name) ++try: ++ from _hashlib import get_fips_mode ++except ImportError: ++ def get_fips_mode(): ++ return 0 ++ ++if not get_fips_mode(): ++ __builtin_constructor_cache = {} ++ ++ def __get_builtin_constructor(name): ++ cache = __builtin_constructor_cache ++ constructor = cache.get(name) ++ if constructor is not None: ++ return constructor ++ try: ++ if name in {'SHA1', 'sha1'}: ++ import _sha1 ++ cache['SHA1'] = cache['sha1'] = _sha1.sha1 ++ elif name in {'MD5', 'md5'}: ++ import _md5 ++ cache['MD5'] = cache['md5'] = _md5.md5 ++ elif name in {'SHA256', 'sha256', 'SHA224', 'sha224'}: ++ import _sha256 ++ cache['SHA224'] = cache['sha224'] = _sha256.sha224 ++ cache['SHA256'] = cache['sha256'] = _sha256.sha256 ++ elif name in {'SHA512', 'sha512', 'SHA384', 'sha384'}: ++ import _sha512 ++ cache['SHA384'] = cache['sha384'] = _sha512.sha384 ++ cache['SHA512'] = cache['sha512'] = _sha512.sha512 ++ elif name in {'blake2b', 'blake2s'}: ++ import _blake2 ++ cache['blake2b'] = _blake2.blake2b ++ cache['blake2s'] = _blake2.blake2s ++ elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512'}: ++ import _sha3 ++ cache['sha3_224'] = _sha3.sha3_224 ++ cache['sha3_256'] = _sha3.sha3_256 ++ cache['sha3_384'] = _sha3.sha3_384 ++ cache['sha3_512'] = _sha3.sha3_512 ++ elif name in {'shake_128', 'shake_256'}: ++ import _sha3 ++ cache['shake_128'] = _sha3.shake_128 ++ cache['shake_256'] = _sha3.shake_256 ++ except ImportError: ++ pass # no extension module, this hash is unsupported. ++ ++ constructor = cache.get(name) ++ if constructor is not None: ++ return constructor ++ ++ raise ValueError('unsupported hash type ' + name) + + + def __get_openssl_constructor(name): +- if name in __block_openssl_constructor: +- # Prefer our blake2 and sha3 implementation. +- return __get_builtin_constructor(name) ++ if not get_fips_mode(): ++ if name in __block_openssl_constructor: ++ # Prefer our blake2 and sha3 implementation. ++ return __get_builtin_constructor(name) + try: + f = getattr(_hashlib, 'openssl_' + name) + # Allow the C module to raise ValueError. The function will be +@@ -132,27 +141,31 @@ def __get_openssl_constructor(name): + # Use the C function directly (very fast) + return f + except (AttributeError, ValueError): ++ if get_fips_mode(): ++ raise + return __get_builtin_constructor(name) + + +-def __py_new(name, data=b'', **kwargs): +- """new(name, data=b'', **kwargs) - Return a new hashing object using the +- named algorithm; optionally initialized with data (which must be +- a bytes-like object). +- """ +- return __get_builtin_constructor(name)(data, **kwargs) ++if not get_fips_mode(): ++ def __py_new(name, data=b'', **kwargs): ++ """new(name, data=b'', **kwargs) - Return a new hashing object using the ++ named algorithm; optionally initialized with data (which must be ++ a bytes-like object). ++ """ ++ return __get_builtin_constructor(name)(data, **kwargs) + + + def __hash_new(name, data=b'', **kwargs): + """new(name, data=b'') - Return a new hashing object using the named algorithm; + optionally initialized with data (which must be a bytes-like object). + """ +- if name in __block_openssl_constructor: +- # Prefer our blake2 and sha3 implementation +- # OpenSSL 1.1.0 comes with a limited implementation of blake2b/s. +- # It does neither support keyed blake2 nor advanced features like +- # salt, personal, tree hashing or SSE. +- return __get_builtin_constructor(name)(data, **kwargs) ++ if not get_fips_mode(): ++ if name in __block_openssl_constructor: ++ # Prefer our blake2 and sha3 implementation ++ # OpenSSL 1.1.0 comes with a limited implementation of blake2b/s. ++ # It does neither support keyed blake2 nor advanced features like ++ # salt, personal, tree hashing or SSE. ++ return __get_builtin_constructor(name)(data, **kwargs) + try: + return _hashlib.new(name, data) + except ValueError: +@@ -160,6 +173,8 @@ def __hash_new(name, data=b'', **kwargs): + # hash, try using our builtin implementations. + # This allows for SHA224/256 and SHA384/512 support even though + # the OpenSSL library prior to 0.9.8 doesn't provide them. ++ if get_fips_mode(): ++ raise + return __get_builtin_constructor(name)(data) + + +@@ -170,72 +185,13 @@ try: + algorithms_available = algorithms_available.union( + _hashlib.openssl_md_meth_names) + except ImportError: ++ if get_fips_mode(): ++ raise + new = __py_new + __get_hash = __get_builtin_constructor + +-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] ++# OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA ++from _hashlib import pbkdf2_hmac + + try: + # OpenSSL's scrypt requires OpenSSL 1.1+ +@@ -243,11 +199,6 @@ try: + except ImportError: + pass + +-try: +- from _hashlib import get_fips_mode +-except ImportError: +- pass +- + + for __func_name in __always_supported: + # try them all, some may not work due to the OpenSSL +@@ -261,4 +212,6 @@ for __func_name in __always_supported: + + # Cleanup locals() + del __always_supported, __func_name, __get_hash +-del __py_new, __hash_new, __get_openssl_constructor ++del __hash_new, __get_openssl_constructor ++if not get_fips_mode(): ++ del __py_new +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 8b53d23ef52..e9abcbb929f 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -945,6 +945,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") + def test_pbkdf2_hmac_py(self): + self._test_pbkdf2_hmac(py_hashlib.pbkdf2_hmac) + +-- +2.21.1 + + +From 351fa613d2e194a7fe5c1f63bc89cbaa340deca5 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 25 Jul 2019 17:19:06 +0200 +Subject: [PATCH 05/32] Disable Python's hash implementations in FIPS mode, + forcing OpenSSL + +--- + Include/_hashopenssl.h | 66 ++++++++++++++++++++++++++++++++++ + Modules/_blake2/blake2b_impl.c | 5 +++ + Modules/_blake2/blake2module.c | 3 ++ + Modules/_blake2/blake2s_impl.c | 5 +++ + Modules/_hashopenssl.c | 37 +------------------ + Modules/_sha3/sha3module.c | 5 +++ + setup.py | 48 +++++++++++++------------ + 7 files changed, 110 insertions(+), 59 deletions(-) + create mode 100644 Include/_hashopenssl.h + +diff --git a/Include/_hashopenssl.h b/Include/_hashopenssl.h +new file mode 100644 +index 00000000000..a726c0d3fbf +--- /dev/null ++++ b/Include/_hashopenssl.h +@@ -0,0 +1,66 @@ ++#ifndef Py_HASHOPENSSL_H ++#define Py_HASHOPENSSL_H ++ ++#include "Python.h" ++#include ++#include ++ ++/* LCOV_EXCL_START */ ++static PyObject * ++_setException(PyObject *exc) ++{ ++ unsigned long errcode; ++ const char *lib, *func, *reason; ++ ++ errcode = ERR_peek_last_error(); ++ if (!errcode) { ++ PyErr_SetString(exc, "unknown reasons"); ++ return NULL; ++ } ++ ERR_clear_error(); ++ ++ lib = ERR_lib_error_string(errcode); ++ func = ERR_func_error_string(errcode); ++ reason = ERR_reason_error_string(errcode); ++ ++ if (lib && func) { ++ PyErr_Format(exc, "[%s: %s] %s", lib, func, reason); ++ } ++ else if (lib) { ++ PyErr_Format(exc, "[%s] %s", lib, reason); ++ } ++ else { ++ PyErr_SetString(exc, reason); ++ } ++ return NULL; ++} ++/* LCOV_EXCL_STOP */ ++ ++ ++__attribute__((__unused__)) ++static int ++_Py_hashlib_fips_error(char *name) { ++ int result = FIPS_mode(); ++ if (result == 0) { ++ // "If the library was built without support of the FIPS Object Module, ++ // then the function will return 0 with an error code of ++ // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)." ++ // But 0 is also a valid result value. ++ ++ unsigned long errcode = ERR_peek_last_error(); ++ if (errcode) { ++ _setException(PyExc_ValueError); ++ return 1; ++ } ++ return 0; ++ } ++ PyErr_Format(PyExc_ValueError, "%s is not available in FIPS mode", ++ name); ++ return 1; ++} ++ ++#define FAIL_RETURN_IN_FIPS_MODE(name) do { \ ++ if (_Py_hashlib_fips_error(name)) return NULL; \ ++} while (0) ++ ++#endif // !Py_HASHOPENSSL_H +diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c +index edab31ea222..1daf5c38e2c 100644 +--- a/Modules/_blake2/blake2b_impl.c ++++ b/Modules/_blake2/blake2b_impl.c +@@ -14,6 +14,7 @@ + */ + + #include "Python.h" ++#include "_hashopenssl.h" + #include "pystrhex.h" + #include "pythread.h" + +@@ -96,6 +97,8 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2bObject *self = NULL; + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ + self = new_BLAKE2bObject(type); + if (self == NULL) { + goto error; +@@ -274,6 +277,8 @@ _blake2_blake2b_update(BLAKE2bObject *self, PyObject *data) + { + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE("_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 e2a3d420d4e..817b7165684 100644 +--- a/Modules/_blake2/blake2module.c ++++ b/Modules/_blake2/blake2module.c +@@ -9,6 +9,7 @@ + */ + + #include "Python.h" ++#include "_hashopenssl.h" + + #include "impl/blake2.h" + +@@ -57,6 +58,8 @@ PyInit__blake2(void) + PyObject *m; + PyObject *d; + ++ FAIL_RETURN_IN_FIPS_MODE("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 ef2f7e1980f..389711abf14 100644 +--- a/Modules/_blake2/blake2s_impl.c ++++ b/Modules/_blake2/blake2s_impl.c +@@ -14,6 +14,7 @@ + */ + + #include "Python.h" ++#include "_hashopenssl.h" + #include "pystrhex.h" + #include "pythread.h" + +@@ -96,6 +97,8 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2sObject *self = NULL; + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ + self = new_BLAKE2sObject(type); + if (self == NULL) { + goto error; +@@ -274,6 +277,8 @@ _blake2_blake2s_update(BLAKE2sObject *self, PyObject *data) + { + Py_buffer buf; + ++ FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ + GET_BUFFER_VIEW_OR_ERROUT(data, &buf); + + if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE) +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 43a69c73d1d..661ceaa1986 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -17,6 +17,7 @@ + #include "structmember.h" + #include "hashlib.h" + #include "pystrhex.h" ++#include "_hashopenssl.h" + + + /* EVP is the preferred interface to hashing in OpenSSL */ +@@ -24,10 +25,6 @@ + #include + /* We use the object interface to discover what hashes OpenSSL supports. */ + #include +-#include "openssl/err.h" +- +-/* Expose FIPS_mode */ +-#include + + #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER) + /* OpenSSL < 1.1.0 */ +@@ -65,38 +62,6 @@ class _hashlib.HASH "EVPobject *" "&EVPtype" + [clinic start generated code]*/ + /*[clinic end generated code: output=da39a3ee5e6b4b0d input=a881a5092eecad28]*/ + +- +-/* LCOV_EXCL_START */ +-static PyObject * +-_setException(PyObject *exc) +-{ +- unsigned long errcode; +- const char *lib, *func, *reason; +- +- errcode = ERR_peek_last_error(); +- if (!errcode) { +- PyErr_SetString(exc, "unknown reasons"); +- return NULL; +- } +- ERR_clear_error(); +- +- lib = ERR_lib_error_string(errcode); +- func = ERR_func_error_string(errcode); +- reason = ERR_reason_error_string(errcode); +- +- if (lib && func) { +- PyErr_Format(exc, "[%s: %s] %s", lib, func, reason); +- } +- else if (lib) { +- PyErr_Format(exc, "[%s] %s", lib, reason); +- } +- else { +- PyErr_SetString(exc, reason); +- } +- return NULL; +-} +-/* LCOV_EXCL_STOP */ +- + static PyObject* + py_digest_name(const EVP_MD *md) + { +diff --git a/Modules/_sha3/sha3module.c b/Modules/_sha3/sha3module.c +index c1fb6185e24..34d09b45d99 100644 +--- a/Modules/_sha3/sha3module.c ++++ b/Modules/_sha3/sha3module.c +@@ -18,6 +18,7 @@ + #include "Python.h" + #include "pystrhex.h" + #include "../hashlib.h" ++#include "_hashopenssl.h" + + /* ************************************************************************** + * SHA-3 (Keccak) and SHAKE +@@ -160,6 +161,7 @@ static PyTypeObject SHAKE256type; + static SHA3object * + newSHA3object(PyTypeObject *type) + { ++ FAIL_RETURN_IN_FIPS_MODE("_sha3"); + SHA3object *newobj; + newobj = (SHA3object *)PyObject_New(SHA3object, type); + if (newobj == NULL) { +@@ -173,6 +175,7 @@ newSHA3object(PyTypeObject *type) + static PyObject * + py_sha3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { ++ FAIL_RETURN_IN_FIPS_MODE("_sha3"); + SHA3object *self = NULL; + Py_buffer buf = {NULL, NULL}; + HashReturn res; +@@ -704,6 +707,8 @@ PyInit__sha3(void) + { + PyObject *m = NULL; + ++ FAIL_RETURN_IN_FIPS_MODE("_sha3"); ++ + if ((m = PyModule_Create(&_SHA3module)) == NULL) { + return NULL; + } +diff --git a/setup.py b/setup.py +index 20d7f35652f..0066006772f 100644 +--- a/setup.py ++++ b/setup.py +@@ -1688,7 +1688,6 @@ class PyBuildExt(build_ext): + def detect_modules(self): + self.configure_compiler() + self.init_inc_lib_dirs() +- + self.detect_simple_extensions() + if TEST_EXTENSIONS: + self.detect_test_extensions() +@@ -2187,7 +2186,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() + +@@ -2208,7 +2207,7 @@ class PyBuildExt(build_ext): + 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( +@@ -2216,7 +2215,7 @@ class PyBuildExt(build_ext): + ) + 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( +@@ -2226,12 +2225,23 @@ class PyBuildExt(build_ext): + if krb5_h: + ssl_incs.extend(krb5_h) + ++ ++ ssl_args = { ++ 'include_dirs': openssl_includes, ++ 'library_dirs': openssl_libdirs, ++ 'libraries': ['ssl', 'crypto'], ++ } ++ ++ return ssl_args ++ ++ 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']) + ) + else: +@@ -2239,22 +2249,12 @@ 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): +- # We always compile these even when OpenSSL is available (issue #14693). +- # It's harmless and the object code is tiny (40-50 KiB per module, +- # only loaded when actually used). +- self.add(Extension('_sha256', ['sha256module.c'], +- depends=['hashlib.h'])) +- self.add(Extension('_sha512', ['sha512module.c'], +- depends=['hashlib.h'])) +- self.add(Extension('_md5', ['md5module.c'], +- depends=['hashlib.h'])) +- self.add(Extension('_sha1', ['sha1module.c'], +- depends=['hashlib.h'])) ++ # RHEL: Always force OpenSSL for md5, sha1, sha256, sha512; ++ # don't build Python's implementations. ++ # sha3 and blake2 have extra functionality, so do build those: + + blake2_deps = glob(os.path.join(self.srcdir, + 'Modules/_blake2/impl/*')) +@@ -2264,14 +2264,16 @@ class PyBuildExt(build_ext): + ['_blake2/blake2module.c', + '_blake2/blake2b_impl.c', + '_blake2/blake2s_impl.c'], +- depends=blake2_deps)) ++ **self.detect_openssl_args(), ++ depends=blake2_deps)) + + sha3_deps = glob(os.path.join(self.srcdir, + 'Modules/_sha3/kcp/*')) + sha3_deps.append('hashlib.h') + self.add(Extension('_sha3', + ['_sha3/sha3module.c'], +- depends=sha3_deps)) ++ **self.detect_openssl_args(), ++ depends=sha3_deps + ['hashlib.h'])) + + def detect_nis(self): + if MS_WINDOWS or CYGWIN or HOST_PLATFORM == 'qnx6': +-- +2.21.1 + + +From 502fab3354771128a7b18a4e117cf09327803a6c Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Thu, 12 Dec 2019 16:58:31 +0100 +Subject: [PATCH 06/32] Expose all hashes available to OpenSSL + +--- + Modules/_hashopenssl.c | 150 ++++++++++++++++ + Modules/clinic/_hashopenssl.c.h | 298 +++++++++++++++++++++++++++++++- + 2 files changed, 447 insertions(+), 1 deletion(-) + +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 661ceaa1986..625e2d2e8f6 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -190,6 +190,12 @@ py_digest_by_name(const char *name) + else if (!strcmp(name, "blake2b512")) { + digest = EVP_blake2b512(); + } ++ else if (!strcmp(name, "blake2s")) { ++ digest = EVP_blake2s256(); ++ } ++ else if (!strcmp(name, "blake2b")) { ++ digest = EVP_blake2b512(); ++ } + #endif + } + +@@ -708,6 +714,142 @@ _hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj) + return EVP_fast_new(module, data_obj, EVP_sha512()); + } + ++/*[clinic input] ++_hashlib.openssl_blake2b ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++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) ++/*[clinic end generated code: output=0d65acd1d9bb5e3f input=d9e6f84fa97e630d]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_blake2b512()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_blake2s ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++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) ++/*[clinic end generated code: output=0f1330138041ec22 input=f1aec29465fc49c6]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_blake2s256()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_sha3_224 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a sha3_224 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=e3817bed6ecafc20 input=adc74bf14410af70]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_sha3_224()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_sha3_256 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a sha3_256 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=9c15fac1ce09cd62 input=2922c3e78ab8bd2d]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_sha3_256()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_sha3_384 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a sha3_384 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=0923a782b9b81a40 input=742b499c372c8316]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_sha3_384()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_sha3_512 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a sha3-512 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=34bbe194704dbce4 input=46383f88e59a0385]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_sha3_512()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_shake_128 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a shake_128 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=a6ea5917ce65ef10 input=f256751eb810fdaa]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_shake128()); ++} ++ ++/*[clinic input] ++_hashlib.openssl_shake_256 ++ ++ string as data_obj: object(py_default="b''") = NULL ++ ++Returns a shake_256 hash object; optionally initialized with a string ++ ++[clinic start generated code]*/ ++ ++static PyObject * ++_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj) ++/*[clinic end generated code: output=c91aaa96b000e186 input=d1331313db34116c]*/ ++ ++{ ++ return EVP_fast_new(module, data_obj, EVP_shake256()); ++} ++ + + /*[clinic input] + _hashlib.pbkdf2_hmac as pbkdf2_hmac +@@ -1083,6 +1225,14 @@ 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 ++ _HASHLIB_OPENSSL_SHA3_512_METHODDEF ++ _HASHLIB_OPENSSL_SHAKE_128_METHODDEF ++ _HASHLIB_OPENSSL_SHAKE_256_METHODDEF + {NULL, NULL} /* Sentinel */ + }; + +diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h +index 30fd8a9796a..e96a752e273 100644 +--- a/Modules/clinic/_hashopenssl.c.h ++++ b/Modules/clinic/_hashopenssl.c.h +@@ -331,6 +331,302 @@ exit: + return return_value; + } + ++PyDoc_STRVAR(_hashlib_openssl_blake2b__doc__, ++"openssl_blake2b($module, /, string=b\'\')\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); ++ ++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", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2b", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_blake2b_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_blake2s__doc__, ++"openssl_blake2s($module, /, string=b\'\')\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); ++ ++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", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2s", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_blake2s_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__, ++"openssl_sha3_224($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a sha3_224 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHA3_224_METHODDEF \ ++ {"openssl_sha3_224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_224__doc__}, ++ ++static PyObject * ++_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_sha3_224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_224", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_sha3_224_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_sha3_256__doc__, ++"openssl_sha3_256($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a sha3_256 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHA3_256_METHODDEF \ ++ {"openssl_sha3_256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_256__doc__}, ++ ++static PyObject * ++_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_sha3_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_256", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_sha3_256_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_sha3_384__doc__, ++"openssl_sha3_384($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a sha3_384 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHA3_384_METHODDEF \ ++ {"openssl_sha3_384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_384__doc__}, ++ ++static PyObject * ++_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_sha3_384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_384", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_sha3_384_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_sha3_512__doc__, ++"openssl_sha3_512($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a sha3-512 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHA3_512_METHODDEF \ ++ {"openssl_sha3_512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_512__doc__}, ++ ++static PyObject * ++_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_sha3_512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_512", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_sha3_512_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__, ++"openssl_shake_128($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a shake_128 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF \ ++ {"openssl_shake_128", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_128, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_128__doc__}, ++ ++static PyObject * ++_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_128", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_shake_128_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__, ++"openssl_shake_256($module, /, string=b\'\')\n" ++"--\n" ++"\n" ++"Returns a shake_256 hash object; optionally initialized with a string"); ++ ++#define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF \ ++ {"openssl_shake_256", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_256__doc__}, ++ ++static PyObject * ++_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj); ++ ++static PyObject * ++_hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"string", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_256", 0}; ++ PyObject *argsbuf[1]; ++ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; ++ PyObject *data_obj = NULL; ++ ++ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); ++ if (!args) { ++ goto exit; ++ } ++ if (!noptargs) { ++ goto skip_optional_pos; ++ } ++ data_obj = args[0]; ++skip_optional_pos: ++ return_value = _hashlib_openssl_shake_256_impl(module, data_obj); ++ ++exit: ++ return return_value; ++} ++ + PyDoc_STRVAR(pbkdf2_hmac__doc__, + "pbkdf2_hmac($module, /, hash_name, password, salt, iterations,\n" + " dklen=None)\n" +@@ -646,4 +942,4 @@ _hashlib_get_fips_mode(PyObject *module, PyObject *Py_UNUSED(ignored)) + #ifndef _HASHLIB_SCRYPT_METHODDEF + #define _HASHLIB_SCRYPT_METHODDEF + #endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */ +-/*[clinic end generated code: output=5467006d93e7479e input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=be8e21a10dff71e7 input=a9049054013a1b77]*/ +-- +2.21.1 + + +From bc9f365705cf600dc26cd16585a25bcde6b43ff1 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 25 Jul 2019 18:13:45 +0200 +Subject: [PATCH 07/32] Fix tests + +--- + Lib/test/test_hashlib.py | 58 +++++++++++++++++++++++++++++++--------- + 1 file changed, 45 insertions(+), 13 deletions(-) + +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index e9abcbb929f..2a55fd4309f 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -190,7 +190,9 @@ class HashLibTestCase(unittest.TestCase): + a = array.array("b", range(10)) + for cons in self.hash_constructors: + c = cons(a) +- if c.name in self.shakes: ++ if (c.name in self.shakes ++ and not cons.__name__.startswith('openssl_') ++ ): + c.hexdigest(16) + else: + c.hexdigest() +@@ -240,7 +242,9 @@ class HashLibTestCase(unittest.TestCase): + def test_hexdigest(self): + for cons in self.hash_constructors: + h = cons() +- if h.name in self.shakes: ++ if (h.name in self.shakes ++ and not cons.__name__.startswith('openssl_') ++ ): + self.assertIsInstance(h.digest(16), bytes) + self.assertEqual(hexstr(h.digest(16)), h.hexdigest(16)) + else: +@@ -254,6 +258,8 @@ class HashLibTestCase(unittest.TestCase): + h = cons() + if h.name not in self.shakes: + continue ++ if cons.__name__.startswith('openssl_'): ++ continue + for digest in h.digest, h.hexdigest: + self.assertRaises(ValueError, digest, -10) + for length in large_sizes: +@@ -282,7 +288,9 @@ class HashLibTestCase(unittest.TestCase): + m1.update(bees) + m1.update(cees) + m1.update(dees) +- if m1.name in self.shakes: ++ if (m1.name in self.shakes ++ and not cons.__name__.startswith('openssl_') ++ ): + args = (16,) + else: + args = () +@@ -309,15 +317,36 @@ class HashLibTestCase(unittest.TestCase): + # 2 is for hashlib.name(...) and hashlib.new(name, ...) + self.assertGreaterEqual(len(constructors), 2) + for hash_object_constructor in constructors: ++ if ( ++ kwargs ++ and hash_object_constructor.__name__.startswith('openssl_') ++ ): ++ return + m = hash_object_constructor(data, **kwargs) +- computed = m.hexdigest() if not shake else m.hexdigest(length) ++ if shake: ++ if hash_object_constructor.__name__.startswith('openssl_'): ++ if length > m.digest_size: ++ # OpenSSL doesn't give long digests ++ return ++ computed = m.hexdigest()[:length*2] ++ hexdigest = hexdigest[:length*2] ++ else: ++ computed = m.hexdigest(length) ++ else: ++ computed = m.hexdigest() + self.assertEqual( + computed, hexdigest, + "Hash algorithm %s constructed using %s returned hexdigest" + " %r for %d byte input data that should have hashed to %r." + % (name, hash_object_constructor, + computed, len(data), hexdigest)) +- computed = m.digest() if not shake else m.digest(length) ++ if shake: ++ if hash_object_constructor.__name__.startswith('openssl_'): ++ computed = m.digest()[:length] ++ else: ++ computed = m.digest(length) ++ else: ++ computed = m.digest() + digest = bytes.fromhex(hexdigest) + self.assertEqual(computed, digest) + if not shake: +@@ -357,12 +386,14 @@ class HashLibTestCase(unittest.TestCase): + for hash_object_constructor in constructors: + m = hash_object_constructor() + self.assertEqual(m.block_size, block_size) +- self.assertEqual(m.digest_size, digest_size) ++ if not hash_object_constructor.__name__.startswith('openssl_'): ++ self.assertEqual(m.digest_size, digest_size) + if digest_length: +- self.assertEqual(len(m.digest(digest_length)), +- digest_length) +- self.assertEqual(len(m.hexdigest(digest_length)), +- 2*digest_length) ++ if not hash_object_constructor.__name__.startswith('openssl_'): ++ self.assertEqual(len(m.digest(digest_length)), ++ digest_length) ++ self.assertEqual(len(m.hexdigest(digest_length)), ++ 2*digest_length) + else: + self.assertEqual(len(m.digest()), digest_size) + self.assertEqual(len(m.hexdigest()), 2*digest_size) +@@ -395,9 +426,10 @@ class HashLibTestCase(unittest.TestCase): + # _hashopenssl's variant does not have extra SHA3 attributes + continue + self.assertEqual(capacity + rate, 1600) +- self.assertEqual(m._capacity_bits, capacity) +- self.assertEqual(m._rate_bits, rate) +- self.assertEqual(m._suffix, suffix) ++ if not hash_object_constructor.__name__.startswith('openssl_'): ++ self.assertEqual(m._capacity_bits, capacity) ++ self.assertEqual(m._rate_bits, rate) ++ self.assertEqual(m._suffix, suffix) + + @requires_sha3 + def test_extra_sha3(self): +-- +2.21.1 + + +From de23605b73ef563766405f678822ec3b6e3645ea Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Fri, 26 Jul 2019 11:27:57 +0200 +Subject: [PATCH 08/32] Change FIPS exceptions from _blake2, _sha3 module init + to ImportError + +--- + Include/_hashopenssl.h | 11 +++++------ + Modules/_blake2/blake2b_impl.c | 4 ++-- + Modules/_blake2/blake2module.c | 2 +- + Modules/_blake2/blake2s_impl.c | 4 ++-- + Modules/_sha3/sha3module.c | 6 +++--- + 5 files changed, 13 insertions(+), 14 deletions(-) + +diff --git a/Include/_hashopenssl.h b/Include/_hashopenssl.h +index a726c0d3fbf..47ed0030422 100644 +--- a/Include/_hashopenssl.h ++++ b/Include/_hashopenssl.h +@@ -39,7 +39,7 @@ _setException(PyObject *exc) + + __attribute__((__unused__)) + static int +-_Py_hashlib_fips_error(char *name) { ++_Py_hashlib_fips_error(PyObject *exc, char *name) { + int result = FIPS_mode(); + if (result == 0) { + // "If the library was built without support of the FIPS Object Module, +@@ -49,18 +49,17 @@ _Py_hashlib_fips_error(char *name) { + + unsigned long errcode = ERR_peek_last_error(); + if (errcode) { +- _setException(PyExc_ValueError); ++ _setException(exc); + return 1; + } + return 0; + } +- PyErr_Format(PyExc_ValueError, "%s is not available in FIPS mode", +- name); ++ PyErr_Format(exc, "%s is not available in FIPS mode", name); + return 1; + } + +-#define FAIL_RETURN_IN_FIPS_MODE(name) do { \ +- if (_Py_hashlib_fips_error(name)) return NULL; \ ++#define FAIL_RETURN_IN_FIPS_MODE(exc, name) do { \ ++ if (_Py_hashlib_fips_error(exc, name)) return NULL; \ + } while (0) + + #endif // !Py_HASHOPENSSL_H +diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c +index 1daf5c38e2c..97ce89d33c1 100644 +--- a/Modules/_blake2/blake2b_impl.c ++++ b/Modules/_blake2/blake2b_impl.c +@@ -97,7 +97,7 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2bObject *self = NULL; + Py_buffer buf; + +- FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); + + self = new_BLAKE2bObject(type); + if (self == NULL) { +@@ -277,7 +277,7 @@ _blake2_blake2b_update(BLAKE2bObject *self, PyObject *data) + { + Py_buffer buf; + +- FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); + + GET_BUFFER_VIEW_OR_ERROUT(data, &buf); + +diff --git a/Modules/_blake2/blake2module.c b/Modules/_blake2/blake2module.c +index 817b7165684..a9c7cbc7ebe 100644 +--- a/Modules/_blake2/blake2module.c ++++ b/Modules/_blake2/blake2module.c +@@ -58,7 +58,7 @@ PyInit__blake2(void) + PyObject *m; + PyObject *d; + +- FAIL_RETURN_IN_FIPS_MODE("blake2"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ImportError, "blake2"); + + m = PyModule_Create(&blake2_module); + if (m == NULL) +diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c +index 389711abf14..c4447b4fe83 100644 +--- a/Modules/_blake2/blake2s_impl.c ++++ b/Modules/_blake2/blake2s_impl.c +@@ -97,7 +97,7 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + BLAKE2sObject *self = NULL; + Py_buffer buf; + +- FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); + + self = new_BLAKE2sObject(type); + if (self == NULL) { +@@ -277,7 +277,7 @@ _blake2_blake2s_update(BLAKE2sObject *self, PyObject *data) + { + Py_buffer buf; + +- FAIL_RETURN_IN_FIPS_MODE("_blake2"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2"); + + GET_BUFFER_VIEW_OR_ERROUT(data, &buf); + +diff --git a/Modules/_sha3/sha3module.c b/Modules/_sha3/sha3module.c +index 34d09b45d99..3079e1e3a4a 100644 +--- a/Modules/_sha3/sha3module.c ++++ b/Modules/_sha3/sha3module.c +@@ -161,7 +161,7 @@ static PyTypeObject SHAKE256type; + static SHA3object * + newSHA3object(PyTypeObject *type) + { +- FAIL_RETURN_IN_FIPS_MODE("_sha3"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_sha3"); + SHA3object *newobj; + newobj = (SHA3object *)PyObject_New(SHA3object, type); + if (newobj == NULL) { +@@ -175,7 +175,7 @@ newSHA3object(PyTypeObject *type) + static PyObject * + py_sha3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { +- FAIL_RETURN_IN_FIPS_MODE("_sha3"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_sha3"); + SHA3object *self = NULL; + Py_buffer buf = {NULL, NULL}; + HashReturn res; +@@ -707,7 +707,7 @@ PyInit__sha3(void) + { + PyObject *m = NULL; + +- FAIL_RETURN_IN_FIPS_MODE("_sha3"); ++ FAIL_RETURN_IN_FIPS_MODE(PyExc_ImportError, "_sha3"); + + if ((m = PyModule_Create(&_SHA3module)) == NULL) { + return NULL; +-- +2.21.1 + + +From 104d4b32cb6b28f48f6e03a0b9ec51126a833b72 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Fri, 26 Jul 2019 11:24:09 +0200 +Subject: [PATCH 09/32] Make hashlib importable under FIPS mode + +--- + Lib/hashlib.py | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 1bcfdf9f7f7..898e6dca565 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -137,12 +137,14 @@ def __get_openssl_constructor(name): + f = getattr(_hashlib, 'openssl_' + name) + # Allow the C module to raise ValueError. The function will be + # defined but the hash not actually available thanks to OpenSSL. +- f() ++ if not get_fips_mode(): ++ # N.B. In "FIPS mode", there is no fallback. ++ # If this test fails, we want to export the broken hash ++ # constructor anyway. ++ f() + # Use the C function directly (very fast) + return f + except (AttributeError, ValueError): +- if get_fips_mode(): +- raise + return __get_builtin_constructor(name) + + +-- +2.21.1 + + +From 168538a496916c0b92c11c433fd0f9545c33f535 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Fri, 26 Jul 2019 15:41:10 +0200 +Subject: [PATCH 10/32] Implement hmac.new using new built-in module, + _hmacopenssl + +--- + Lib/hmac.py | 32 ++- + Modules/_hmacopenssl.c | 396 ++++++++++++++++++++++++++++++++ + Modules/clinic/_hmacopenssl.c.h | 133 +++++++++++ + setup.py | 4 + + 4 files changed, 564 insertions(+), 1 deletion(-) + create mode 100644 Modules/_hmacopenssl.c + create mode 100644 Modules/clinic/_hmacopenssl.c.h + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index b769876e6f7..daabc8c1425 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -13,6 +13,8 @@ except ImportError: + else: + _openssl_md_meths = frozenset(_hashopenssl.openssl_md_meth_names) + import hashlib as _hashlib ++import _hashlib as _hashlibopenssl ++import _hmacopenssl + + trans_5C = bytes((x ^ 0x5C) for x in range(256)) + trans_36 = bytes((x ^ 0x36) for x in range(256)) +@@ -43,6 +45,11 @@ class HMAC: + msg argument. Passing it as a keyword argument is + recommended, though not required for legacy API reasons. + """ ++ if _hashlib.get_fips_mode(): ++ raise ValueError( ++ 'hmac.HMAC is not available in FIPS mode. ' ++ + 'Use hmac.new().' ++ ) + + if not isinstance(key, (bytes, bytearray)): + raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__) +@@ -93,6 +100,8 @@ class HMAC: + + def update(self, msg): + """Feed data from msg into this hashing object.""" ++ if _hashlib.get_fips_mode(): ++ raise ValueError('hmac.HMAC is not available in FIPS mode') + self.inner.update(msg) + + def copy(self): +@@ -133,6 +142,18 @@ class HMAC: + h = self._current() + return h.hexdigest() + ++def _get_openssl_name(digestmod): ++ if isinstance(digestmod, str): ++ return digestmod.lower() ++ elif callable(digestmod): ++ digestmod = digestmod(b'') ++ ++ if not isinstance(digestmod, _hashlibopenssl.HASH): ++ raise TypeError( ++ 'Only OpenSSL hashlib hashes are accepted in FIPS mode.') ++ ++ return digestmod.name.lower().replace('_', '-') ++ + def new(key, msg=None, digestmod=''): + """Create a new hashing object and return it. + +@@ -150,7 +171,16 @@ def new(key, msg=None, digestmod=''): + method, and can ask for the hash value at any time by calling its digest() + or hexdigest() methods. + """ +- return HMAC(key, msg, digestmod) ++ if _hashlib.get_fips_mode(): ++ if digestmod is None: ++ digestmod = 'md5' ++ name = _get_openssl_name(digestmod) ++ result = _hmacopenssl.new(key, digestmod=name) ++ if msg: ++ result.update(msg) ++ return result ++ else: ++ return HMAC(key, msg, digestmod) + + + def digest(key, msg, digest): +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +new file mode 100644 +index 00000000000..ca95d725f01 +--- /dev/null ++++ b/Modules/_hmacopenssl.c +@@ -0,0 +1,396 @@ ++/* Module that wraps all OpenSSL MHAC algorithm */ ++ ++/* Copyright (C) 2019 Red Hat, Inc. Red Hat, Inc. and/or its affiliates ++ * ++ * Based on _hashopenssl.c, which is: ++ * Copyright (C) 2005-2010 Gregory P. Smith (greg@krypto.org) ++ * Licensed to PSF under a Contributor Agreement. ++ * ++ * Derived from a skeleton of shamodule.c containing work performed by: ++ * ++ * Andrew Kuchling (amk@amk.ca) ++ * Greg Stein (gstein@lyra.org) ++ * ++ */ ++ ++#define PY_SSIZE_T_CLEAN ++ ++#include "Python.h" ++#include "structmember.h" ++#include "hashlib.h" ++#include "pystrhex.h" ++#include "_hashopenssl.h" ++ ++ ++#include ++ ++static PyTypeObject HmacType; ++ ++typedef struct { ++ PyObject_HEAD ++ PyObject *name; /* name of the hash algorithm */ ++ HMAC_CTX *ctx; /* OpenSSL hmac context */ ++ PyThread_type_lock lock; /* HMAC context lock */ ++} HmacObject; ++ ++#include "clinic/_hmacopenssl.c.h" ++/*[clinic input] ++module _hmacopenssl ++class _hmacopenssl.HMAC "HmacObject *" "&HmacType" ++[clinic start generated code]*/ ++/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c98d3f2af591c085]*/ ++ ++ ++/*[clinic input] ++_hmacopenssl.new ++ ++ key: Py_buffer ++ * ++ digestmod: str ++ ++Return a new hmac object. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hmacopenssl_new_impl(PyObject *module, Py_buffer *key, ++ const char *digestmod) ++/*[clinic end generated code: output=46f1cb4e02921922 input=be8c0c2e4fad508c]*/ ++{ ++ if (digestmod == NULL) { ++ PyErr_SetString(PyExc_ValueError, "digestmod must be specified"); ++ return NULL; ++ } ++ ++ /* name mut be lowercase */ ++ for (int i=0; digestmod[i]; i++) { ++ if ( ++ ((digestmod[i] < 'a') || (digestmod[i] > 'z')) ++ && ((digestmod[i] < '0') || (digestmod[i] > '9')) ++ && digestmod[i] != '-' ++ ) { ++ PyErr_SetString(PyExc_ValueError, "digestmod must be lowercase"); ++ return NULL; ++ } ++ } ++ ++ const EVP_MD *digest = EVP_get_digestbyname(digestmod); ++ if (!digest) { ++ PyErr_SetString(PyExc_ValueError, "unknown hash function"); ++ return NULL; ++ } ++ ++ PyObject *name = NULL; ++ HMAC_CTX *ctx = NULL; ++ HmacObject *retval = NULL; ++ ++ name = PyUnicode_FromFormat("hmac-%s", digestmod); ++ if (name == NULL) { ++ goto error; ++ } ++ ++ ctx = HMAC_CTX_new(); ++ if (ctx == NULL) { ++ _setException(PyExc_ValueError); ++ goto error; ++ } ++ ++ int r = HMAC_Init_ex( ++ ctx, ++ (const char*)key->buf, ++ key->len, ++ digest, ++ NULL /*impl*/); ++ if (r == 0) { ++ _setException(PyExc_ValueError); ++ goto error; ++ } ++ ++ retval = (HmacObject *)PyObject_New(HmacObject, &HmacType); ++ if (retval == NULL) { ++ goto error; ++ } ++ ++ retval->name = name; ++ retval->ctx = ctx; ++ retval->lock = NULL; ++ ++ return (PyObject*)retval; ++ ++error: ++ if (ctx) HMAC_CTX_free(ctx); ++ if (name) Py_DECREF(name); ++ if (retval) PyObject_Del(name); ++ return NULL; ++} ++ ++/*[clinic input] ++_hmacopenssl.HMAC.copy ++ ++Return a copy (“clone”) of the HMAC object. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hmacopenssl_HMAC_copy_impl(HmacObject *self) ++/*[clinic end generated code: output=fe5ee41faf30dcf0 input=f5ed20feec42d8d0]*/ ++{ ++ HmacObject *retval = (HmacObject *)PyObject_New(HmacObject, &HmacType); ++ if (retval == NULL) { ++ return NULL; ++ } ++ ++ Py_INCREF(self->name); ++ retval->name = self->name; ++ ++ int r = HMAC_CTX_copy(retval->ctx, self->ctx); ++ if (r == 0) { ++ PyObject_Del(retval); ++ return _setException(PyExc_ValueError); ++ } ++ ++ return (PyObject*)retval; ++} ++ ++static void ++_hmac_dealloc(HmacObject *self) ++{ ++ if (self->lock != NULL) { ++ PyThread_free_lock(self->lock); ++ } ++ HMAC_CTX_free(self->ctx); ++ Py_XDECREF(self->name); ++ PyObject_Del(self); ++} ++ ++static PyObject * ++_hmac_repr(HmacObject *self) ++{ ++ return PyUnicode_FromFormat("<%U HMAC object @ %p>", self->name, self); ++} ++ ++/*[clinic input] ++_hmacopenssl.HMAC.update ++ ++ msg: Py_buffer ++ ++Update the HMAC object with msg. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hmacopenssl_HMAC_update_impl(HmacObject *self, Py_buffer *msg) ++/*[clinic end generated code: output=0efeee663a98cee5 input=0683d64f35808cb9]*/ ++{ ++ if (self->lock == NULL && msg->len >= HASHLIB_GIL_MINSIZE) { ++ self->lock = PyThread_allocate_lock(); ++ /* fail? lock = NULL and we fail over to non-threaded code. */ ++ } ++ ++ int r; ++ ++ if (self->lock != NULL) { ++ Py_BEGIN_ALLOW_THREADS ++ PyThread_acquire_lock(self->lock, 1); ++ r = HMAC_Update(self->ctx, (const unsigned char*)msg->buf, msg->len); ++ PyThread_release_lock(self->lock); ++ Py_END_ALLOW_THREADS ++ } else { ++ r = HMAC_Update(self->ctx, (const unsigned char*)msg->buf, msg->len); ++ } ++ ++ if (r == 0) { ++ _setException(PyExc_ValueError); ++ return NULL; ++ } ++ Py_RETURN_NONE; ++} ++ ++static unsigned int ++_digest_size(HmacObject *self) ++{ ++ const EVP_MD *md = HMAC_CTX_get_md(self->ctx); ++ if (md == NULL) { ++ _setException(PyExc_ValueError); ++ return 0; ++ } ++ return EVP_MD_size(md); ++} ++ ++static int ++_digest(HmacObject *self, unsigned char *buf, unsigned int len) ++{ ++ HMAC_CTX *temp_ctx = HMAC_CTX_new(); ++ if (temp_ctx == NULL) { ++ PyErr_NoMemory(); ++ return 0; ++ } ++ int r = HMAC_CTX_copy(temp_ctx, self->ctx); ++ if (r == 0) { ++ _setException(PyExc_ValueError); ++ return 0; ++ } ++ r = HMAC_Final(temp_ctx, buf, &len); ++ HMAC_CTX_free(temp_ctx); ++ if (r == 0) { ++ _setException(PyExc_ValueError); ++ return 0; ++ } ++ return 1; ++} ++ ++/*[clinic input] ++_hmacopenssl.HMAC.digest ++ ++Return the digest of the bytes passed to the update() method so far. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hmacopenssl_HMAC_digest_impl(HmacObject *self) ++/*[clinic end generated code: output=3aa6dbfc46ec4957 input=bf769a10b1d9edd9]*/ ++{ ++ unsigned int digest_size = _digest_size(self); ++ if (digest_size == 0) { ++ return _setException(PyExc_ValueError); ++ } ++ unsigned char buf[digest_size]; /* FIXME: C99 feature */ ++ int r = _digest(self, buf, digest_size); ++ if (r == 0) { ++ return NULL; ++ } ++ return PyBytes_FromStringAndSize((const char *)buf, digest_size); ++} ++ ++/*[clinic input] ++_hmacopenssl.HMAC.hexdigest ++ ++Return hexadecimal digest of the bytes passed to the update() method so far. ++ ++This may be used to exchange the value safely in email or other non-binary ++environments. ++[clinic start generated code]*/ ++ ++static PyObject * ++_hmacopenssl_HMAC_hexdigest_impl(HmacObject *self) ++/*[clinic end generated code: output=630f6fa89f9f1e48 input=b8e60ec8b811c4cd]*/ ++{ ++ unsigned int digest_size = _digest_size(self); ++ if (digest_size == 0) { ++ return _setException(PyExc_ValueError); ++ } ++ unsigned char buf[digest_size]; /* FIXME: C99 feature */ ++ int r = _digest(self, buf, digest_size); ++ if (r == 0) { ++ return NULL; ++ } ++ return _Py_strhex((const char *)buf, digest_size); ++} ++ ++ ++ ++static PyObject * ++_hmacopenssl_get_digest_size(HmacObject *self, void *closure) ++{ ++ unsigned int digest_size = _digest_size(self); ++ if (digest_size == 0) { ++ return _setException(PyExc_ValueError); ++ } ++ return PyLong_FromLong(digest_size); ++} ++ ++static PyObject * ++_hmacopenssl_get_block_size(HmacObject *self, void *closure) ++{ ++ const EVP_MD *md = HMAC_CTX_get_md(self->ctx); ++ if (md == NULL) { ++ return _setException(PyExc_ValueError); ++ } ++ return PyLong_FromLong(EVP_MD_size(md)); ++} ++ ++static PyMethodDef Hmac_methods[] = { ++ _HMACOPENSSL_HMAC_UPDATE_METHODDEF ++ _HMACOPENSSL_HMAC_DIGEST_METHODDEF ++ _HMACOPENSSL_HMAC_HEXDIGEST_METHODDEF ++ _HMACOPENSSL_HMAC_COPY_METHODDEF ++ {NULL, NULL} /* sentinel */ ++}; ++ ++static PyGetSetDef Hmac_getset[] = { ++ {"digest_size", (getter)_hmacopenssl_get_digest_size, NULL, NULL, NULL}, ++ {"block_size", (getter)_hmacopenssl_get_block_size, NULL, NULL, NULL}, ++ {NULL} /* Sentinel */ ++}; ++ ++static PyMemberDef Hmac_members[] = { ++ {"name", T_OBJECT, offsetof(HmacObject, name), READONLY, PyDoc_STR("HMAC name")}, ++}; ++ ++PyDoc_STRVAR(hmactype_doc, ++"The object used to calculate HMAC of a message.\n\ ++\n\ ++Methods:\n\ ++\n\ ++update() -- updates the current digest with an additional string\n\ ++digest() -- return the current digest value\n\ ++hexdigest() -- return the current digest as a string of hexadecimal digits\n\ ++copy() -- return a copy of the current hash object\n\ ++\n\ ++Attributes:\n\ ++\n\ ++name -- the name, including the hash algorithm used by this object\n\ ++digest_size -- number of bytes in digest() output\n"); ++ ++static PyTypeObject HmacType = { ++ PyVarObject_HEAD_INIT(NULL, 0) ++ "_hmacopenssl.HMAC", /*tp_name*/ ++ sizeof(HmacObject), /*tp_basicsize*/ ++ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, ++ .tp_doc = hmactype_doc, ++ .tp_repr = (reprfunc)_hmac_repr, ++ .tp_dealloc = (destructor)_hmac_dealloc, ++ .tp_methods = Hmac_methods, ++ .tp_getset = Hmac_getset, ++ .tp_members = Hmac_members, ++}; ++ ++static struct PyMethodDef hmacopenssl_functions[] = { ++ _HMACOPENSSL_NEW_METHODDEF ++ {NULL, NULL} /* Sentinel */ ++}; ++ ++ ++ ++/* Initialize this module. */ ++ ++ ++static struct PyModuleDef _hmacopenssl_module = { ++ PyModuleDef_HEAD_INIT, ++ "_hmacopenssl", ++ NULL, ++ -1, ++ hmacopenssl_functions, ++ NULL, ++ NULL, ++ NULL, ++ NULL ++}; ++ ++PyMODINIT_FUNC ++PyInit__hmacopenssl(void) ++{ ++ /* TODO build EVP_functions openssl_* entries dynamically based ++ * on what hashes are supported rather than listing many ++ * but having some be unsupported. Only init appropriate ++ * constants. */ ++ ++ Py_TYPE(&HmacType) = &PyType_Type; ++ if (PyType_Ready(&HmacType) < 0) ++ return NULL; ++ ++ PyObject *m = PyModule_Create(&_hmacopenssl_module); ++ if (m == NULL) ++ return NULL; ++ ++ Py_INCREF((PyObject *)&HmacType); ++ PyModule_AddObject(m, "HMAC", (PyObject *)&HmacType); ++ ++ return m; ++} +diff --git a/Modules/clinic/_hmacopenssl.c.h b/Modules/clinic/_hmacopenssl.c.h +new file mode 100644 +index 00000000000..b472a6eddd3 +--- /dev/null ++++ b/Modules/clinic/_hmacopenssl.c.h +@@ -0,0 +1,133 @@ ++/*[clinic input] ++preserve ++[clinic start generated code]*/ ++ ++PyDoc_STRVAR(_hmacopenssl_new__doc__, ++"new($module, /, key, *, digestmod)\n" ++"--\n" ++"\n" ++"Return a new hmac object."); ++ ++#define _HMACOPENSSL_NEW_METHODDEF \ ++ {"new", (PyCFunction)_hmacopenssl_new, METH_FASTCALL, _hmacopenssl_new__doc__}, ++ ++static PyObject * ++_hmacopenssl_new_impl(PyObject *module, Py_buffer *key, ++ const char *digestmod); ++ ++static PyObject * ++_hmacopenssl_new(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"key", "digestmod", NULL}; ++ static _PyArg_Parser _parser = {"y*$s:new", _keywords, 0}; ++ Py_buffer key = {NULL, NULL}; ++ const char *digestmod; ++ ++ if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, ++ &key, &digestmod)) { ++ goto exit; ++ } ++ return_value = _hmacopenssl_new_impl(module, &key, digestmod); ++ ++exit: ++ /* Cleanup for key */ ++ if (key.obj) { ++ PyBuffer_Release(&key); ++ } ++ ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hmacopenssl_HMAC_copy__doc__, ++"copy($self, /)\n" ++"--\n" ++"\n" ++"Return a copy (“clone”) of the HMAC object."); ++ ++#define _HMACOPENSSL_HMAC_COPY_METHODDEF \ ++ {"copy", (PyCFunction)_hmacopenssl_HMAC_copy, METH_NOARGS, _hmacopenssl_HMAC_copy__doc__}, ++ ++static PyObject * ++_hmacopenssl_HMAC_copy_impl(HmacObject *self); ++ ++static PyObject * ++_hmacopenssl_HMAC_copy(HmacObject *self, PyObject *Py_UNUSED(ignored)) ++{ ++ return _hmacopenssl_HMAC_copy_impl(self); ++} ++ ++PyDoc_STRVAR(_hmacopenssl_HMAC_update__doc__, ++"update($self, /, msg)\n" ++"--\n" ++"\n" ++"Update the HMAC object with msg."); ++ ++#define _HMACOPENSSL_HMAC_UPDATE_METHODDEF \ ++ {"update", (PyCFunction)_hmacopenssl_HMAC_update, METH_FASTCALL, _hmacopenssl_HMAC_update__doc__}, ++ ++static PyObject * ++_hmacopenssl_HMAC_update_impl(HmacObject *self, Py_buffer *msg); ++ ++static PyObject * ++_hmacopenssl_HMAC_update(HmacObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"msg", NULL}; ++ static _PyArg_Parser _parser = {"y*:update", _keywords, 0}; ++ Py_buffer msg = {NULL, NULL}; ++ ++ if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, ++ &msg)) { ++ goto exit; ++ } ++ return_value = _hmacopenssl_HMAC_update_impl(self, &msg); ++ ++exit: ++ /* Cleanup for msg */ ++ if (msg.obj) { ++ PyBuffer_Release(&msg); ++ } ++ ++ return return_value; ++} ++ ++PyDoc_STRVAR(_hmacopenssl_HMAC_digest__doc__, ++"digest($self, /)\n" ++"--\n" ++"\n" ++"Return the digest of the bytes passed to the update() method so far."); ++ ++#define _HMACOPENSSL_HMAC_DIGEST_METHODDEF \ ++ {"digest", (PyCFunction)_hmacopenssl_HMAC_digest, METH_NOARGS, _hmacopenssl_HMAC_digest__doc__}, ++ ++static PyObject * ++_hmacopenssl_HMAC_digest_impl(HmacObject *self); ++ ++static PyObject * ++_hmacopenssl_HMAC_digest(HmacObject *self, PyObject *Py_UNUSED(ignored)) ++{ ++ return _hmacopenssl_HMAC_digest_impl(self); ++} ++ ++PyDoc_STRVAR(_hmacopenssl_HMAC_hexdigest__doc__, ++"hexdigest($self, /)\n" ++"--\n" ++"\n" ++"Return hexadecimal digest of the bytes passed to the update() method so far.\n" ++"\n" ++"This may be used to exchange the value safely in email or other non-binary\n" ++"environments."); ++ ++#define _HMACOPENSSL_HMAC_HEXDIGEST_METHODDEF \ ++ {"hexdigest", (PyCFunction)_hmacopenssl_HMAC_hexdigest, METH_NOARGS, _hmacopenssl_HMAC_hexdigest__doc__}, ++ ++static PyObject * ++_hmacopenssl_HMAC_hexdigest_impl(HmacObject *self); ++ ++static PyObject * ++_hmacopenssl_HMAC_hexdigest(HmacObject *self, PyObject *Py_UNUSED(ignored)) ++{ ++ return _hmacopenssl_HMAC_hexdigest_impl(self); ++} ++/*[clinic end generated code: output=10b6e8cac6d7a2c9 input=a9049054013a1b77]*/ +diff --git a/setup.py b/setup.py +index 0066006772f..6b376040ffc 100644 +--- a/setup.py ++++ b/setup.py +@@ -2251,6 +2251,10 @@ class PyBuildExt(build_ext): + depends=['hashlib.h'], + **self.detect_openssl_args()) ) + ++ self.add(Extension('_hmacopenssl', ['_hmacopenssl.c'], ++ depends = ['hashlib.h'], ++ **self.detect_openssl_args()) ) ++ + def detect_hash_builtins(self): + # RHEL: Always force OpenSSL for md5, sha1, sha256, sha512; + # don't build Python's implementations. +-- +2.21.1 + + +From a5091b7016e4d86abaa733cd0dd7c0d066c4c33a Mon Sep 17 00:00:00 2001 +From: Marcel Plch +Date: Mon, 29 Jul 2019 12:45:11 +0200 +Subject: [PATCH 11/32] FIPS review + +* Port _hmacopenssl to multiphase init. +* Make _hmacopenssl.HMAC.copy create same type as self. +* hmac.py cosmetic nitpick +--- + Lib/hmac.py | 2 +- + Modules/_hmacopenssl.c | 112 +++++++++++++++++++++++++---------------- + 2 files changed, 70 insertions(+), 44 deletions(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index daabc8c1425..2ec24da5733 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -48,7 +48,7 @@ class HMAC: + if _hashlib.get_fips_mode(): + raise ValueError( + 'hmac.HMAC is not available in FIPS mode. ' +- + 'Use hmac.new().' ++ 'Use hmac.new().' + ) + + if not isinstance(key, (bytes, bytearray)): +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index ca95d725f01..216ed04f236 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -24,7 +24,10 @@ + + #include + +-static PyTypeObject HmacType; ++typedef struct hmacopenssl_state { ++ PyTypeObject *HmacType; ++} hmacopenssl_state; ++ + + typedef struct { + PyObject_HEAD +@@ -36,9 +39,9 @@ typedef struct { + #include "clinic/_hmacopenssl.c.h" + /*[clinic input] + module _hmacopenssl +-class _hmacopenssl.HMAC "HmacObject *" "&HmacType" ++class _hmacopenssl.HMAC "HmacObject *" "PyModule_GetState(module)->HmacType" + [clinic start generated code]*/ +-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c98d3f2af591c085]*/ ++/*[clinic end generated code: output=da39a3ee5e6b4b0d input=204b7f45847f57b4]*/ + + + /*[clinic input] +@@ -56,11 +59,18 @@ _hmacopenssl_new_impl(PyObject *module, Py_buffer *key, + const char *digestmod) + /*[clinic end generated code: output=46f1cb4e02921922 input=be8c0c2e4fad508c]*/ + { ++ hmacopenssl_state *state; ++ + if (digestmod == NULL) { + PyErr_SetString(PyExc_ValueError, "digestmod must be specified"); + return NULL; + } + ++ state = PyModule_GetState(module); ++ if (state == NULL) { ++ return NULL; ++ } ++ + /* name mut be lowercase */ + for (int i=0; digestmod[i]; i++) { + if ( +@@ -105,7 +115,7 @@ _hmacopenssl_new_impl(PyObject *module, Py_buffer *key, + goto error; + } + +- retval = (HmacObject *)PyObject_New(HmacObject, &HmacType); ++ retval = (HmacObject *)PyObject_New(HmacObject, state->HmacType); + if (retval == NULL) { + goto error; + } +@@ -133,7 +143,9 @@ static PyObject * + _hmacopenssl_HMAC_copy_impl(HmacObject *self) + /*[clinic end generated code: output=fe5ee41faf30dcf0 input=f5ed20feec42d8d0]*/ + { +- HmacObject *retval = (HmacObject *)PyObject_New(HmacObject, &HmacType); ++ HmacObject *retval; ++ ++ retval = (HmacObject *)PyObject_New(HmacObject, (PyTypeObject *)PyObject_Type((PyObject *)self)); + if (retval == NULL) { + return NULL; + } +@@ -147,7 +159,7 @@ _hmacopenssl_HMAC_copy_impl(HmacObject *self) + return _setException(PyExc_ValueError); + } + +- return (PyObject*)retval; ++ return (PyObject *)retval; + } + + static void +@@ -338,19 +350,24 @@ Attributes:\n\ + name -- the name, including the hash algorithm used by this object\n\ + digest_size -- number of bytes in digest() output\n"); + +-static PyTypeObject HmacType = { +- PyVarObject_HEAD_INIT(NULL, 0) +- "_hmacopenssl.HMAC", /*tp_name*/ +- sizeof(HmacObject), /*tp_basicsize*/ +- .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, +- .tp_doc = hmactype_doc, +- .tp_repr = (reprfunc)_hmac_repr, +- .tp_dealloc = (destructor)_hmac_dealloc, +- .tp_methods = Hmac_methods, +- .tp_getset = Hmac_getset, +- .tp_members = Hmac_members, ++static PyType_Slot HmacType_slots[] = { ++ {Py_tp_doc, hmactype_doc}, ++ {Py_tp_repr, (reprfunc)_hmac_repr}, ++ {Py_tp_dealloc,(destructor)_hmac_dealloc}, ++ {Py_tp_methods, Hmac_methods}, ++ {Py_tp_getset, Hmac_getset}, ++ {Py_tp_members, Hmac_members}, ++ {0, NULL} ++}; ++ ++PyType_Spec HmacType_spec = { ++ "_hmacopenssl.HMAC", /* name */ ++ sizeof(HmacObject), /* basicsize */ ++ .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, ++ .slots = HmacType_slots, + }; + ++ + static struct PyMethodDef hmacopenssl_functions[] = { + _HMACOPENSSL_NEW_METHODDEF + {NULL, NULL} /* Sentinel */ +@@ -360,37 +377,46 @@ static struct PyMethodDef hmacopenssl_functions[] = { + + /* Initialize this module. */ + +- +-static struct PyModuleDef _hmacopenssl_module = { +- PyModuleDef_HEAD_INIT, +- "_hmacopenssl", +- NULL, +- -1, +- hmacopenssl_functions, +- NULL, +- NULL, +- NULL, +- NULL +-}; +- +-PyMODINIT_FUNC +-PyInit__hmacopenssl(void) +-{ ++static int ++hmacopenssl_exec(PyObject *m) { + /* TODO build EVP_functions openssl_* entries dynamically based + * on what hashes are supported rather than listing many +- * but having some be unsupported. Only init appropriate ++ * and having some unsupported. Only init appropriate + * constants. */ ++ PyObject *temp; + +- Py_TYPE(&HmacType) = &PyType_Type; +- if (PyType_Ready(&HmacType) < 0) +- return NULL; ++ temp = PyType_FromSpec(&HmacType_spec); ++ if (temp == NULL) { ++ goto fail; ++ } + +- PyObject *m = PyModule_Create(&_hmacopenssl_module); +- if (m == NULL) +- return NULL; ++ if (PyModule_AddObject(m, "HMAC", temp) == -1) { ++ goto fail; ++ } ++ ++ return 0; + +- Py_INCREF((PyObject *)&HmacType); +- PyModule_AddObject(m, "HMAC", (PyObject *)&HmacType); ++fail: ++ Py_XDECREF(temp); ++ return -1; ++} + +- return m; ++static PyModuleDef_Slot hmacopenssl_slots[] = { ++ {Py_mod_exec, hmacopenssl_exec}, ++ {0, NULL}, ++}; ++ ++static struct PyModuleDef _hmacopenssl_def = { ++ PyModuleDef_HEAD_INIT, /* m_base */ ++ .m_name = "_hmacopenssl", ++ .m_methods = hmacopenssl_functions, ++ .m_slots = hmacopenssl_slots, ++ .m_size = sizeof(hmacopenssl_state) ++}; ++ ++ ++PyMODINIT_FUNC ++PyInit__hmacopenssl(void) ++{ ++ return PyModuleDef_Init(&_hmacopenssl_def); + } +-- +2.21.1 + + +From c482ed4a74e06d17a612d3a286772b62e5a8001a Mon Sep 17 00:00:00 2001 +From: Marcel Plch +Date: Mon, 29 Jul 2019 13:05:04 +0200 +Subject: [PATCH 12/32] revert cosmetic nitpick and remove trailing whitespace + +--- + Lib/hmac.py | 2 +- + Modules/_hmacopenssl.c | 4 ++-- + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 2ec24da5733..daabc8c1425 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -48,7 +48,7 @@ class HMAC: + if _hashlib.get_fips_mode(): + raise ValueError( + 'hmac.HMAC is not available in FIPS mode. ' +- 'Use hmac.new().' ++ + 'Use hmac.new().' + ) + + if not isinstance(key, (bytes, bytearray)): +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index 216ed04f236..221714ca434 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -363,7 +363,7 @@ static PyType_Slot HmacType_slots[] = { + PyType_Spec HmacType_spec = { + "_hmacopenssl.HMAC", /* name */ + sizeof(HmacObject), /* basicsize */ +- .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, ++ .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + .slots = HmacType_slots, + }; + +@@ -407,7 +407,7 @@ static PyModuleDef_Slot hmacopenssl_slots[] = { + }; + + static struct PyModuleDef _hmacopenssl_def = { +- PyModuleDef_HEAD_INIT, /* m_base */ ++ PyModuleDef_HEAD_INIT, /* m_base */ + .m_name = "_hmacopenssl", + .m_methods = hmacopenssl_functions, + .m_slots = hmacopenssl_slots, +-- +2.21.1 + + +From fceba59a20d8f22f618777874a63162f520bed69 Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Wed, 31 Jul 2019 15:43:43 +0200 +Subject: [PATCH 13/32] Add initial tests for various hashes under FIPS mode + +--- + Lib/test/test_fips.py | 64 +++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 64 insertions(+) + 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 00000000000..bee911ef405 +--- /dev/null ++++ b/Lib/test/test_fips.py +@@ -0,0 +1,64 @@ ++import unittest ++import hmac, _hmacopenssl ++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() ++ ++ def compare_hashes(self, python_hash, openssl_hash): ++ """ ++ Compare between the python implementation and the openssl one that the digests ++ are the same ++ """ ++ if python_hash.name.startswith('shake_128'): ++ m = python_hash.hexdigest(16) ++ elif python_hash.name.startswith('shake_256'): ++ m = python_hash.hexdigest(32) ++ else: ++ m = python_hash.hexdigest() ++ h = openssl_hash.hexdigest() ++ ++ self.assertEqual(m, h) ++ ++ @unittest.skipIf(hashlib.get_fips_mode(), "blake2 hashes are not available under FIPS") ++ def test_blake2_hashes(self): ++ self.compare_hashes(hashlib.blake2b(b'abc'), _hashlib.openssl_blake2b(b'abc')) ++ self.compare_hashes(hashlib.blake2s(b'abc'), _hashlib.openssl_blake2s(b'abc')) ++ ++ def test_sha3_hashes(self): ++ self.compare_hashes(hashlib.sha3_224(b'abc'), _hashlib.openssl_sha3_224(b'abc')) ++ self.compare_hashes(hashlib.sha3_256(b'abc'), _hashlib.openssl_sha3_256(b'abc')) ++ self.compare_hashes(hashlib.sha3_384(b'abc'), _hashlib.openssl_sha3_384(b'abc')) ++ self.compare_hashes(hashlib.sha3_512(b'abc'), _hashlib.openssl_sha3_512(b'abc')) ++ ++ @unittest.skipIf(hashlib.get_fips_mode(), "shake hashes are not available under FIPS") ++ def test_shake_hashes(self): ++ self.compare_hashes(hashlib.shake_128(b'abc'), _hashlib.openssl_shake_128(b'abc')) ++ self.compare_hashes(hashlib.shake_256(b'abc'), _hashlib.openssl_shake_256(b'abc')) ++ ++ def test_sha(self): ++ self.compare_hashes(hashlib.sha1(b'abc'), _hashlib.openssl_sha1(b'abc')) ++ self.compare_hashes(hashlib.sha224(b'abc'), _hashlib.openssl_sha224(b'abc')) ++ self.compare_hashes(hashlib.sha256(b'abc'), _hashlib.openssl_sha256(b'abc')) ++ self.compare_hashes(hashlib.sha384(b'abc'), _hashlib.openssl_sha384(b'abc')) ++ self.compare_hashes(hashlib.sha512(b'abc'), _hashlib.openssl_sha512(b'abc')) ++ ++ def test_hmac_digests(self): ++ self.compare_hashes(_hmacopenssl.new(b'My hovercraft is full of eels', digestmod='sha384'), ++ hmac.new(b'My hovercraft is full of eels', digestmod='sha384')) ++ ++ ++ ++ ++if __name__ == "__main__": ++ unittest.main() +-- +2.21.1 + + +From 556b34545c0f7d72470faeb186371ffc9c2c997c Mon Sep 17 00:00:00 2001 +From: Marcel Plch +Date: Thu, 1 Aug 2019 16:39:37 +0200 +Subject: [PATCH 14/32] Initialize HMAC type. + +--- + Modules/_hmacopenssl.c | 12 ++++++++---- + 1 file changed, 8 insertions(+), 4 deletions(-) + +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index 221714ca434..239445a0831 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -22,12 +22,12 @@ + #include "_hashopenssl.h" + + +-#include + + typedef struct hmacopenssl_state { + PyTypeObject *HmacType; + } hmacopenssl_state; + ++#include + + typedef struct { + PyObject_HEAD +@@ -39,7 +39,7 @@ typedef struct { + #include "clinic/_hmacopenssl.c.h" + /*[clinic input] + module _hmacopenssl +-class _hmacopenssl.HMAC "HmacObject *" "PyModule_GetState(module)->HmacType" ++class _hmacopenssl.HMAC "HmacObject *" "((hmacopenssl_state *)PyModule_GetState(module))->HmacType" + [clinic start generated code]*/ + /*[clinic end generated code: output=da39a3ee5e6b4b0d input=204b7f45847f57b4]*/ + +@@ -71,7 +71,7 @@ _hmacopenssl_new_impl(PyObject *module, Py_buffer *key, + return NULL; + } + +- /* name mut be lowercase */ ++ /* name must be lowercase */ + for (int i=0; digestmod[i]; i++) { + if ( + ((digestmod[i] < 'a') || (digestmod[i] > 'z')) +@@ -383,7 +383,8 @@ hmacopenssl_exec(PyObject *m) { + * on what hashes are supported rather than listing many + * and having some unsupported. Only init appropriate + * constants. */ +- PyObject *temp; ++ PyObject *temp = NULL; ++ hmacopenssl_state *state; + + temp = PyType_FromSpec(&HmacType_spec); + if (temp == NULL) { +@@ -394,6 +395,9 @@ hmacopenssl_exec(PyObject *m) { + goto fail; + } + ++ state = PyModule_GetState(m); ++ state->HmacType = (PyTypeObject *)temp; ++ + return 0; + + fail: +-- +2.21.1 + + +From 425d95325f304b0c2a04511a9f8e62208a5bace2 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 1 Aug 2019 17:57:05 +0200 +Subject: [PATCH 15/32] 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 c9f995e5fa7..64180b245ea 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' +@@ -735,7 +739,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) +@@ -751,7 +755,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.21.1 + + +From 5369e3fd06c84a648d056226616c6e796e014b20 Mon Sep 17 00:00:00 2001 +From: Marcel Plch +Date: Fri, 2 Aug 2019 17:36:01 +0200 +Subject: [PATCH 16/32] Fix refcounting + +--- + Modules/_hmacopenssl.c | 35 ++++++++++++++++++++++++++++++++++- + 1 file changed, 34 insertions(+), 1 deletion(-) + +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index 239445a0831..9c2882833d1 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -373,6 +373,34 @@ static struct PyMethodDef hmacopenssl_functions[] = { + {NULL, NULL} /* Sentinel */ + }; + ++static int ++hmacopenssl_traverse(PyObject *self, visitproc visit, void *arg) ++{ ++ hmacopenssl_state *state; ++ ++ state = PyModule_GetState(self); ++ ++ if (state) { ++ Py_VISIT(state->HmacType); ++ } ++ ++ return 0; ++} ++ ++static int ++hmacopenssl_clear(PyObject *self) ++{ ++ hmacopenssl_state *state; ++ ++ state = PyModule_GetState(self); ++ ++ if (state) { ++ Py_CLEAR(state->HmacType); ++ } ++ ++ return 0; ++} ++ + + + /* Initialize this module. */ +@@ -396,7 +424,10 @@ hmacopenssl_exec(PyObject *m) { + } + + state = PyModule_GetState(m); ++ + state->HmacType = (PyTypeObject *)temp; ++ Py_INCREF(temp); ++ + + return 0; + +@@ -415,7 +446,9 @@ static struct PyModuleDef _hmacopenssl_def = { + .m_name = "_hmacopenssl", + .m_methods = hmacopenssl_functions, + .m_slots = hmacopenssl_slots, +- .m_size = sizeof(hmacopenssl_state) ++ .m_size = sizeof(hmacopenssl_state), ++ .m_traverse = hmacopenssl_traverse, ++ .m_clear = hmacopenssl_clear + }; + + +-- +2.21.1 + + +From 11bc3a8ba5179defa0c6e86e27bdf25ab43809d4 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 13:37:05 +0200 +Subject: [PATCH 17/32] hmac: Don't default to md5 in FIPS mode + +--- + Lib/hmac.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index daabc8c1425..0302364642e 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -173,7 +173,7 @@ def new(key, msg=None, digestmod=''): + """ + if _hashlib.get_fips_mode(): + if digestmod is None: +- digestmod = 'md5' ++ raise ValueError("'digestmod' argument is mandatory in FIPS mode") + name = _get_openssl_name(digestmod) + result = _hmacopenssl.new(key, digestmod=name) + if msg: +-- +2.21.1 + + +From 074d6c62025226c381eb0191eddb86322be9d4f1 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 14:20:58 +0200 +Subject: [PATCH 18/32] Make _hmacopenssl.HMAC subclassable; subclass it as + hmac.HMAC under FIPS + +This removes the _hmacopenssl.new function. +--- + Lib/hmac.py | 26 +++++++----- + Lib/test/test_fips.py | 2 +- + Modules/_hmacopenssl.c | 75 ++++++++++++++++----------------- + Modules/clinic/_hmacopenssl.c.h | 39 +---------------- + 4 files changed, 55 insertions(+), 87 deletions(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 0302364642e..e4222be7dcc 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -143,6 +143,8 @@ class HMAC: + return h.hexdigest() + + def _get_openssl_name(digestmod): ++ if digestmod is None: ++ raise ValueError("'digestmod' argument is mandatory in FIPS mode") + if isinstance(digestmod, str): + return digestmod.lower() + elif callable(digestmod): +@@ -154,6 +156,19 @@ def _get_openssl_name(digestmod): + + return digestmod.name.lower().replace('_', '-') + ++class HMAC_openssl(_hmacopenssl.HMAC): ++ def __new__(cls, key, msg = None, digestmod = None): ++ name = _get_openssl_name(digestmod) ++ result = _hmacopenssl.HMAC.__new__(cls, key, digestmod=name) ++ if msg: ++ result.update(msg) ++ return result ++ ++ ++if _hashlib.get_fips_mode(): ++ HMAC = HMAC_openssl ++ ++ + def new(key, msg=None, digestmod=''): + """Create a new hashing object and return it. + +@@ -171,16 +186,7 @@ def new(key, msg=None, digestmod=''): + method, and can ask for the hash value at any time by calling its digest() + or hexdigest() methods. + """ +- if _hashlib.get_fips_mode(): +- if digestmod is None: +- raise ValueError("'digestmod' argument is mandatory in FIPS mode") +- name = _get_openssl_name(digestmod) +- result = _hmacopenssl.new(key, digestmod=name) +- if msg: +- result.update(msg) +- return result +- else: +- return HMAC(key, msg, digestmod) ++ return HMAC(key, msg, digestmod) + + + def digest(key, msg, digest): +diff --git a/Lib/test/test_fips.py b/Lib/test/test_fips.py +index bee911ef405..34812e6098a 100644 +--- a/Lib/test/test_fips.py ++++ b/Lib/test/test_fips.py +@@ -54,7 +54,7 @@ class HashlibFipsTests(unittest.TestCase): + self.compare_hashes(hashlib.sha512(b'abc'), _hashlib.openssl_sha512(b'abc')) + + def test_hmac_digests(self): +- self.compare_hashes(_hmacopenssl.new(b'My hovercraft is full of eels', digestmod='sha384'), ++ self.compare_hashes(_hmacopenssl.HMAC(b'My hovercraft is full of eels', digestmod='sha384'), + hmac.new(b'My hovercraft is full of eels', digestmod='sha384')) + + +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index 9c2882833d1..7d3d9739f3a 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -41,33 +41,25 @@ typedef struct { + module _hmacopenssl + class _hmacopenssl.HMAC "HmacObject *" "((hmacopenssl_state *)PyModule_GetState(module))->HmacType" + [clinic start generated code]*/ +-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=204b7f45847f57b4]*/ ++/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9fe07a087adc2cf9]*/ + + +-/*[clinic input] +-_hmacopenssl.new +- +- key: Py_buffer +- * +- digestmod: str +- +-Return a new hmac object. +-[clinic start generated code]*/ +- + static PyObject * +-_hmacopenssl_new_impl(PyObject *module, Py_buffer *key, +- const char *digestmod) +-/*[clinic end generated code: output=46f1cb4e02921922 input=be8c0c2e4fad508c]*/ ++Hmac_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) + { +- hmacopenssl_state *state; +- +- if (digestmod == NULL) { +- PyErr_SetString(PyExc_ValueError, "digestmod must be specified"); ++ static char *kwarg_names[] = {"key", "digestmod", NULL}; ++ Py_buffer key = {NULL, NULL}; ++ char *digestmod = NULL; ++ ++ int ret = PyArg_ParseTupleAndKeywords( ++ args, kwds, "y*|$s:_hmacopenssl.HMAC", kwarg_names, ++ &key, &digestmod); ++ if (ret == 0) { + return NULL; + } + +- state = PyModule_GetState(module); +- if (state == NULL) { ++ if (digestmod == NULL) { ++ PyErr_SetString(PyExc_ValueError, "digestmod must be specified"); + return NULL; + } + +@@ -106,8 +98,8 @@ _hmacopenssl_new_impl(PyObject *module, Py_buffer *key, + + int r = HMAC_Init_ex( + ctx, +- (const char*)key->buf, +- key->len, ++ (const char*)key.buf, ++ key.len, + digest, + NULL /*impl*/); + if (r == 0) { +@@ -115,7 +107,10 @@ _hmacopenssl_new_impl(PyObject *module, Py_buffer *key, + goto error; + } + +- retval = (HmacObject *)PyObject_New(HmacObject, state->HmacType); ++ PyBuffer_Release(&key); ++ key.buf = NULL; ++ ++ retval = (HmacObject *)subtype->tp_alloc(subtype, 0); + if (retval == NULL) { + goto error; + } +@@ -130,6 +125,7 @@ error: + if (ctx) HMAC_CTX_free(ctx); + if (name) Py_DECREF(name); + if (retval) PyObject_Del(name); ++ if (key.buf) PyBuffer_Release(&key); + return NULL; + } + +@@ -145,19 +141,27 @@ _hmacopenssl_HMAC_copy_impl(HmacObject *self) + { + HmacObject *retval; + +- retval = (HmacObject *)PyObject_New(HmacObject, (PyTypeObject *)PyObject_Type((PyObject *)self)); ++ HMAC_CTX *ctx = HMAC_CTX_new(); ++ if (ctx == NULL) { ++ return _setException(PyExc_ValueError); ++ } ++ ++ int r = HMAC_CTX_copy(ctx, self->ctx); ++ if (r == 0) { ++ HMAC_CTX_free(ctx); ++ return _setException(PyExc_ValueError); ++ } ++ ++ retval = (HmacObject *)Py_TYPE(self)->tp_alloc(Py_TYPE(self), 0); + if (retval == NULL) { ++ HMAC_CTX_free(ctx); + return NULL; + } +- ++ retval->ctx = ctx; + Py_INCREF(self->name); + retval->name = self->name; + +- int r = HMAC_CTX_copy(retval->ctx, self->ctx); +- if (r == 0) { +- PyObject_Del(retval); +- return _setException(PyExc_ValueError); +- } ++ retval->lock = NULL; + + return (PyObject *)retval; + } +@@ -169,8 +173,8 @@ _hmac_dealloc(HmacObject *self) + PyThread_free_lock(self->lock); + } + HMAC_CTX_free(self->ctx); +- Py_XDECREF(self->name); +- PyObject_Del(self); ++ Py_CLEAR(self->name); ++ Py_TYPE(self)->tp_free(self); + } + + static PyObject * +@@ -357,6 +361,7 @@ static PyType_Slot HmacType_slots[] = { + {Py_tp_methods, Hmac_methods}, + {Py_tp_getset, Hmac_getset}, + {Py_tp_members, Hmac_members}, ++ {Py_tp_new, Hmac_new}, + {0, NULL} + }; + +@@ -368,11 +373,6 @@ PyType_Spec HmacType_spec = { + }; + + +-static struct PyMethodDef hmacopenssl_functions[] = { +- _HMACOPENSSL_NEW_METHODDEF +- {NULL, NULL} /* Sentinel */ +-}; +- + static int + hmacopenssl_traverse(PyObject *self, visitproc visit, void *arg) + { +@@ -444,7 +444,6 @@ static PyModuleDef_Slot hmacopenssl_slots[] = { + static struct PyModuleDef _hmacopenssl_def = { + PyModuleDef_HEAD_INIT, /* m_base */ + .m_name = "_hmacopenssl", +- .m_methods = hmacopenssl_functions, + .m_slots = hmacopenssl_slots, + .m_size = sizeof(hmacopenssl_state), + .m_traverse = hmacopenssl_traverse, +diff --git a/Modules/clinic/_hmacopenssl.c.h b/Modules/clinic/_hmacopenssl.c.h +index b472a6eddd3..861acc11bfd 100644 +--- a/Modules/clinic/_hmacopenssl.c.h ++++ b/Modules/clinic/_hmacopenssl.c.h +@@ -2,43 +2,6 @@ + preserve + [clinic start generated code]*/ + +-PyDoc_STRVAR(_hmacopenssl_new__doc__, +-"new($module, /, key, *, digestmod)\n" +-"--\n" +-"\n" +-"Return a new hmac object."); +- +-#define _HMACOPENSSL_NEW_METHODDEF \ +- {"new", (PyCFunction)_hmacopenssl_new, METH_FASTCALL, _hmacopenssl_new__doc__}, +- +-static PyObject * +-_hmacopenssl_new_impl(PyObject *module, Py_buffer *key, +- const char *digestmod); +- +-static PyObject * +-_hmacopenssl_new(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) +-{ +- PyObject *return_value = NULL; +- static const char * const _keywords[] = {"key", "digestmod", NULL}; +- static _PyArg_Parser _parser = {"y*$s:new", _keywords, 0}; +- Py_buffer key = {NULL, NULL}; +- const char *digestmod; +- +- if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, +- &key, &digestmod)) { +- goto exit; +- } +- return_value = _hmacopenssl_new_impl(module, &key, digestmod); +- +-exit: +- /* Cleanup for key */ +- if (key.obj) { +- PyBuffer_Release(&key); +- } +- +- return return_value; +-} +- + PyDoc_STRVAR(_hmacopenssl_HMAC_copy__doc__, + "copy($self, /)\n" + "--\n" +@@ -130,4 +93,4 @@ _hmacopenssl_HMAC_hexdigest(HmacObject *self, PyObject *Py_UNUSED(ignored)) + { + return _hmacopenssl_HMAC_hexdigest_impl(self); + } +-/*[clinic end generated code: output=10b6e8cac6d7a2c9 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=d93ad460795d49b5 input=a9049054013a1b77]*/ +-- +2.21.1 + + +From 0cc9eab738876807a9116ee6fee57ac5757c1eb6 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 16:10:36 +0200 +Subject: [PATCH 19/32] Fix _hmacopenssl.HMAC.block_size + +--- + Modules/_hmacopenssl.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Modules/_hmacopenssl.c b/Modules/_hmacopenssl.c +index 7d3d9739f3a..a24c8ba0229 100644 +--- a/Modules/_hmacopenssl.c ++++ b/Modules/_hmacopenssl.c +@@ -318,7 +318,7 @@ _hmacopenssl_get_block_size(HmacObject *self, void *closure) + if (md == NULL) { + return _setException(PyExc_ValueError); + } +- return PyLong_FromLong(EVP_MD_size(md)); ++ return PyLong_FromLong(EVP_MD_block_size(md)); + } + + static PyMethodDef Hmac_methods[] = { +-- +2.21.1 + + +From 79442a65e763d1942a14f52f8ceb83d51d39ca2b Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 15:02:08 +0200 +Subject: [PATCH 20/32] distutils upload: Skip md5 checksum in FIPS mode + +--- + Lib/distutils/command/upload.py | 12 +++++++++++- + Lib/distutils/tests/test_upload.py | 13 +++++++++++-- + 2 files changed, 22 insertions(+), 3 deletions(-) + +diff --git a/Lib/distutils/command/upload.py b/Lib/distutils/command/upload.py +index 11afa24b777..79a6315a43b 100644 +--- a/Lib/distutils/command/upload.py ++++ b/Lib/distutils/command/upload.py +@@ -102,7 +102,6 @@ class upload(PyPIRCCommand): + 'content': (os.path.basename(filename),content), + 'filetype': command, + 'pyversion': pyversion, +- 'md5_digest': hashlib.md5(content).hexdigest(), + + # additional meta-data + 'metadata_version': '1.0', +@@ -122,6 +121,17 @@ class upload(PyPIRCCommand): + 'obsoletes': meta.get_obsoletes(), + } + ++ try: ++ digest = hashlib.md5(content).hexdigest() ++ except ValueError as e: ++ msg = 'calculating md5 checksum failed: %s' % e ++ self.announce(msg, log.ERROR) ++ if not hashlib.get_fips_mode(): ++ # this really shouldn't fail ++ raise ++ else: ++ data['md5_digest'] = digest ++ + data['comment'] = '' + + if self.sign: +diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py +index c17d8e7d54e..b4b64e97737 100644 +--- a/Lib/distutils/tests/test_upload.py ++++ b/Lib/distutils/tests/test_upload.py +@@ -3,6 +3,7 @@ import os + import unittest + import unittest.mock as mock + from urllib.request import HTTPError ++import hashlib + + from test.support import run_unittest + +@@ -130,7 +131,11 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + + # what did we send ? + headers = dict(self.last_open.req.headers) +- self.assertEqual(headers['Content-length'], '2162') ++ if hashlib.get_fips_mode(): ++ # md5 hash is omitted ++ self.assertEqual(headers['Content-length'], '2020') ++ else: ++ self.assertEqual(headers['Content-length'], '2162') + content_type = headers['Content-type'] + self.assertTrue(content_type.startswith('multipart/form-data')) + self.assertEqual(self.last_open.req.get_method(), 'POST') +@@ -166,7 +171,11 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + cmd.run() + + headers = dict(self.last_open.req.headers) +- self.assertEqual(headers['Content-length'], '2172') ++ if hashlib.get_fips_mode(): ++ # md5 hash is omitted ++ self.assertEqual(headers['Content-length'], '2030') ++ else: ++ self.assertEqual(headers['Content-length'], '2172') + self.assertIn(b'long description\r', self.last_open.req.data) + + def test_upload_fails(self): +-- +2.21.1 + + +From b37078729378cb7c0b93ab15da0b1e4343a0b976 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 15:32:25 +0200 +Subject: [PATCH 21/32] Fix HMAC tests on FIPS mode + +--- + Lib/hmac.py | 3 +++ + Lib/test/test_hmac.py | 26 ++++++++++++++++++++++++++ + 2 files changed, 29 insertions(+) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index e4222be7dcc..394c81037b5 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -158,6 +158,9 @@ def _get_openssl_name(digestmod): + + class HMAC_openssl(_hmacopenssl.HMAC): + def __new__(cls, key, msg = None, digestmod = None): ++ if not isinstance(key, (bytes, bytearray)): ++ raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__) ++ + name = _get_openssl_name(digestmod) + result = _hmacopenssl.HMAC.__new__(cls, key, digestmod=name) + if msg: +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index 23c108f6e3c..0a859817f68 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -288,6 +288,7 @@ class TestVectorsTestCase(unittest.TestCase): + def test_sha512_rfc4231(self): + self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128) + ++ @unittest.skipIf(hashlib.get_fips_mode(), 'MockCrazyHash unacceptable in FIPS mode.') + @requires_hashdigest('sha256') + def test_legacy_block_size_warnings(self): + class MockCrazyHash(object): +@@ -337,6 +338,14 @@ class ConstructorTestCase(unittest.TestCase): + except Exception: + self.fail("Standard constructor call raised exception.") + ++ def test_normal_digestmod(self): ++ # Standard constructor call. ++ failed = 0 ++ try: ++ h = hmac.HMAC(b"key", digestmod='sha1') ++ except Exception: ++ self.fail("Standard constructor call raised exception.") ++ + @requires_hashdigest('sha256') + def test_with_str_key(self): + # Pass a key of type str, which is an error, because it expects a key +@@ -404,6 +413,7 @@ class SanityTestCase(unittest.TestCase): + + class CopyTestCase(unittest.TestCase): + ++ @unittest.skipIf(hashlib.get_fips_mode(), "Internal attributes unavailable in FIPS mode") + @requires_hashdigest('sha256') + def test_attributes(self): + # Testing if attributes are of same type. +@@ -416,6 +426,7 @@ class CopyTestCase(unittest.TestCase): + self.assertEqual(type(h1.outer), type(h2.outer), + "Types of outer don't match.") + ++ @unittest.skipIf(hashlib.get_fips_mode(), "Internal attributes unavailable in FIPS mode") + @requires_hashdigest('sha256') + def test_realcopy(self): + # Testing if the copy method created a real copy. +@@ -428,6 +439,21 @@ class CopyTestCase(unittest.TestCase): + self.assertTrue(id(h1.outer) != id(h2.outer), + "No real copy of the attribute 'outer'.") + ++ def test_realcopy(self): ++ # Testing if the copy method created a real copy. ++ h1 = hmac.HMAC(b"key", digestmod="sha1") ++ 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.") ++ old_digest = h1.digest() ++ assert h1.digest() == h2.digest() ++ h1.update(b'hi') ++ assert h1.digest() != h2.digest() ++ assert h2.digest() == old_digest ++ new_digest = h1.digest() ++ h2.update(b'hi') ++ assert h1.digest() == h2.digest() == new_digest ++ + @requires_hashdigest('sha256') + def test_equality(self): + # Testing if the copy has the same digests. +-- +2.21.1 + + +From 9481cec81e30e0dfaa988ade89c50bea91762856 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 16:37:12 +0200 +Subject: [PATCH 22/32] test_tools: Skip md5sum tests in FIPS mode + +--- + Lib/test/test_tools/test_md5sum.py | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Lib/test/test_tools/test_md5sum.py b/Lib/test/test_tools/test_md5sum.py +index fb565b73778..7028a4dc214 100644 +--- a/Lib/test/test_tools/test_md5sum.py ++++ b/Lib/test/test_tools/test_md5sum.py +@@ -4,11 +4,15 @@ import os + import unittest + from test import support + from test.support.script_helper import assert_python_ok, assert_python_failure ++import hashlib + + from test.test_tools import scriptsdir, skip_if_missing + + skip_if_missing() + ++if hashlib.get_fips_mode(): ++ raise unittest.SkipTest("md5sum won't work at all in FIPS mode") ++ + class MD5SumTests(unittest.TestCase): + @classmethod + def setUpClass(cls): +-- +2.21.1 + + +From a12dec28f06338b7529da9bfeda2a8fe835395d2 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 18:23:57 +0200 +Subject: [PATCH 23/32] Make hashlib tests pass in FIPS mode + +--- + Lib/test/test_hashlib.py | 67 ++++++++++++++++++++++++++++------------ + 1 file changed, 48 insertions(+), 19 deletions(-) + +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 2a55fd4309f..9ae5efc451e 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -28,6 +28,11 @@ COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount') + c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib']) + py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib']) + ++if hashlib.get_fips_mode(): ++ FIPS_DISABLED = {'md5', 'MD5', 'blake2b', 'blake2s'} ++else: ++ FIPS_DISABLED = set() ++ + try: + from _hashlib import HASH + except ImportError: +@@ -88,6 +93,11 @@ class HashLibTestCase(unittest.TestCase): + # Issue #14693: fallback modules are always compiled under POSIX + _warn_on_extension_import = os.name == 'posix' or COMPILED_WITH_PYDEBUG + ++ if hashlib.get_fips_mode(): ++ shakes = set() ++ supported_hash_names = tuple( ++ n for n in supported_hash_names if n not in FIPS_DISABLED) ++ + def _conditional_import_module(self, module_name): + """Import a module and return a reference to it or None on failure.""" + try: +@@ -95,8 +105,20 @@ class HashLibTestCase(unittest.TestCase): + except ModuleNotFoundError as error: + if self._warn_on_extension_import: + warnings.warn('Did a C extension fail to compile? %s' % error) ++ except ImportError as error: ++ if not hashlib.get_fips_mode(): ++ raise + return None + ++ def _has_shake_extras(self, hasher): ++ """Return true if the hasher should have "shake" API (digest length)""" ++ if hasher.name not in self.shakes: ++ return False ++ _hashlib = self._conditional_import_module('_hashlib') ++ if _hashlib and isinstance(hasher, _hashlib.HASH): ++ return False ++ return True ++ + def __init__(self, *args, **kwargs): + algorithms = set() + for algorithm in self.supported_hash_names: +@@ -190,15 +212,13 @@ class HashLibTestCase(unittest.TestCase): + a = array.array("b", range(10)) + for cons in self.hash_constructors: + c = cons(a) +- if (c.name in self.shakes +- and not cons.__name__.startswith('openssl_') +- ): ++ if self._has_shake_extras(c): + c.hexdigest(16) + else: + c.hexdigest() + + def test_algorithms_guaranteed(self): +- self.assertEqual(hashlib.algorithms_guaranteed, ++ self.assertEqual(hashlib.algorithms_guaranteed - FIPS_DISABLED, + set(_algo for _algo in self.supported_hash_names + if _algo.islower())) + +@@ -213,6 +233,12 @@ class HashLibTestCase(unittest.TestCase): + def test_new_upper_to_lower(self): + self.assertEqual(hashlib.new("SHA256").name, "sha256") + ++ @unittest.skipUnless(hashlib.get_fips_mode(), "Builtin constructor only unavailable in FIPS mode") ++ def test_get_builtin_constructor_fips(self): ++ with self.assertRaises(AttributeError): ++ hashlib.__get_builtin_constructor ++ ++ @unittest.skipIf(hashlib.get_fips_mode(), "No builtin constructors in FIPS mode") + def test_get_builtin_constructor(self): + get_builtin_constructor = getattr(hashlib, + '__get_builtin_constructor') +@@ -242,9 +268,7 @@ class HashLibTestCase(unittest.TestCase): + def test_hexdigest(self): + for cons in self.hash_constructors: + h = cons() +- if (h.name in self.shakes +- and not cons.__name__.startswith('openssl_') +- ): ++ if self._has_shake_extras(h): + self.assertIsInstance(h.digest(16), bytes) + self.assertEqual(hexstr(h.digest(16)), h.hexdigest(16)) + else: +@@ -256,9 +280,7 @@ class HashLibTestCase(unittest.TestCase): + large_sizes = (2**29, 2**32-10, 2**32+10, 2**61, 2**64-10, 2**64+10) + for cons in self.hash_constructors: + h = cons() +- if h.name not in self.shakes: +- continue +- if cons.__name__.startswith('openssl_'): ++ if not self._has_shake_extras(h): + continue + for digest in h.digest, h.hexdigest: + self.assertRaises(ValueError, digest, -10) +@@ -288,9 +310,7 @@ class HashLibTestCase(unittest.TestCase): + m1.update(bees) + m1.update(cees) + m1.update(dees) +- if (m1.name in self.shakes +- and not cons.__name__.startswith('openssl_') +- ): ++ if self._has_shake_extras(m1): + args = (16,) + else: + args = () +@@ -359,7 +379,8 @@ class HashLibTestCase(unittest.TestCase): + self.assertRaises(TypeError, hash_object_constructor, 'spam') + + def test_no_unicode(self): +- self.check_no_unicode('md5') ++ if not hashlib.get_fips_mode(): ++ self.check_no_unicode('md5') + self.check_no_unicode('sha1') + self.check_no_unicode('sha224') + self.check_no_unicode('sha256') +@@ -402,7 +423,8 @@ class HashLibTestCase(unittest.TestCase): + self.assertIn(name.split("_")[0], repr(m)) + + def test_blocksize_name(self): +- self.check_blocksize_name('md5', 64, 16) ++ if not hashlib.get_fips_mode(): ++ self.check_blocksize_name('md5', 64, 16) + self.check_blocksize_name('sha1', 64, 20) + self.check_blocksize_name('sha224', 64, 28) + self.check_blocksize_name('sha256', 64, 32) +@@ -445,22 +467,27 @@ class HashLibTestCase(unittest.TestCase): + self.check_blocksize_name('blake2b', 128, 64) + self.check_blocksize_name('blake2s', 64, 32) + ++ @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_0(self): + self.check('md5', b'', 'd41d8cd98f00b204e9800998ecf8427e') + ++ @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_1(self): + self.check('md5', b'abc', '900150983cd24fb0d6963f7d28e17f72') + ++ @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_2(self): + self.check('md5', + b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', + 'd174ab98d277d9f5a5611c2c9f419d9f') + ++ @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + @unittest.skipIf(sys.maxsize < _4G + 5, 'test cannot run on 32-bit systems') + @bigmemtest(size=_4G + 5, memuse=1, dry_run=False) + def test_case_md5_huge(self, size): + self.check('md5', b'A'*size, 'c9af2dff37468ce5dfee8f2cfc0a9c6d') + ++ @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + @unittest.skipIf(sys.maxsize < _4G - 1, 'test cannot run on 32-bit systems') + @bigmemtest(size=_4G - 1, memuse=1, dry_run=False) + def test_case_md5_uintmax(self, size): +@@ -842,14 +869,16 @@ class HashLibTestCase(unittest.TestCase): + m = cons(b'x' * gil_minsize) + m.update(b'1') + +- m = hashlib.md5() ++ m = hashlib.sha1() + m.update(b'1') + m.update(b'#' * gil_minsize) + m.update(b'1') +- self.assertEqual(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') ++ self.assertEqual(m.hexdigest(), ++ 'c45f7445ca0ea087d7a1758fbea07935f267c46a') + +- m = hashlib.md5(b'x' * gil_minsize) +- self.assertEqual(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') ++ m = hashlib.sha1(b'x' * gil_minsize) ++ self.assertEqual(m.hexdigest(), ++ '63fda1efde982ba1ffe9d53035bff5c9ce4758fb') + + @support.reap_threads + def test_threaded_hashing(self): +-- +2.21.1 + + +From 35ebfc357302e14372529a63334ca60cbec49b3e Mon Sep 17 00:00:00 2001 +From: Lumir Balhar +Date: Wed, 14 Aug 2019 14:43:07 +0200 +Subject: [PATCH 24/32] distutils upload: only add md5 if available, but + *always* use sha256 + +--- + Lib/distutils/command/upload.py | 3 ++- + Lib/distutils/tests/test_upload.py | 14 ++++++++------ + 2 files changed, 10 insertions(+), 7 deletions(-) + +diff --git a/Lib/distutils/command/upload.py b/Lib/distutils/command/upload.py +index 79a6315a43b..553617a8d8f 100644 +--- a/Lib/distutils/command/upload.py ++++ b/Lib/distutils/command/upload.py +@@ -102,6 +102,7 @@ class upload(PyPIRCCommand): + 'content': (os.path.basename(filename),content), + 'filetype': command, + 'pyversion': pyversion, ++ 'sha256_digest': hashlib.sha256(content).hexdigest(), + + # additional meta-data + 'metadata_version': '1.0', +@@ -125,7 +126,7 @@ class upload(PyPIRCCommand): + digest = hashlib.md5(content).hexdigest() + except ValueError as e: + msg = 'calculating md5 checksum failed: %s' % e +- self.announce(msg, log.ERROR) ++ self.announce(msg, log.INFO) + if not hashlib.get_fips_mode(): + # this really shouldn't fail + raise +diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py +index b4b64e97737..f720a7905dd 100644 +--- a/Lib/distutils/tests/test_upload.py ++++ b/Lib/distutils/tests/test_upload.py +@@ -132,10 +132,11 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + # what did we send ? + headers = dict(self.last_open.req.headers) + if hashlib.get_fips_mode(): +- # md5 hash is omitted +- self.assertEqual(headers['Content-length'], '2020') ++ # only sha256 hash is used ++ self.assertEqual(headers['Content-length'], '2197') + else: +- self.assertEqual(headers['Content-length'], '2162') ++ # both sha256 and md5 hashes are used ++ self.assertEqual(headers['Content-length'], '2339') + content_type = headers['Content-type'] + self.assertTrue(content_type.startswith('multipart/form-data')) + self.assertEqual(self.last_open.req.get_method(), 'POST') +@@ -172,10 +173,11 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + + headers = dict(self.last_open.req.headers) + if hashlib.get_fips_mode(): +- # md5 hash is omitted +- self.assertEqual(headers['Content-length'], '2030') ++ # only sha256 hash is used ++ self.assertEqual(headers['Content-length'], '2207') + else: +- self.assertEqual(headers['Content-length'], '2172') ++ # both sha256 and md5 hashes are used ++ self.assertEqual(headers['Content-length'], '2349') + self.assertIn(b'long description\r', self.last_open.req.data) + + def test_upload_fails(self): +-- +2.21.1 + + +From 36204b47f4f48d4be8e4772f4ab8fc39ca98934b Mon Sep 17 00:00:00 2001 +From: Christian Heimes +Date: Fri, 13 Sep 2019 02:30:00 +0200 +Subject: [PATCH 25/32] bpo-9216: Add usedforsecurity to hashlib constructors + (GH-16044) + +The usedforsecurity keyword only argument added to the hash constructors is useful for FIPS builds and similar restrictive environment with non-technical requirements that legacy algorithms be forbidden by their implementations without being explicitly annotated as not being used for any security related purposes. Linux distros with FIPS support benefit from this being standard rather than making up their own way(s) to do it. + +Contributed and Signed-off-by: Christian Heimes christian@python.org +--- + Doc/library/hashlib.rst | 17 +- + Lib/test/test_hashlib.py | 9 + + Lib/uuid.py | 7 +- + .../2019-09-12-14-54-45.bpo-9216.W7QMpC.rst | 2 + + Modules/_blake2/blake2b_impl.c | 5 +- + Modules/_blake2/blake2s_impl.c | 5 +- + Modules/_blake2/clinic/blake2b_impl.c.h | 27 +- + Modules/_blake2/clinic/blake2s_impl.c.h | 27 +- + Modules/_hashopenssl.c | 151 ++++--- + Modules/_sha3/clinic/sha3module.c.h | 48 ++- + Modules/_sha3/sha3module.c | 41 +- + Modules/clinic/_hashopenssl.c.h | 407 ++++++++++++++---- + Modules/clinic/md5module.c.h | 28 +- + Modules/clinic/sha1module.c.h | 28 +- + Modules/clinic/sha256module.c.h | 54 ++- + Modules/clinic/sha512module.c.h | 54 ++- + Modules/md5module.c | 6 +- + Modules/sha1module.c | 6 +- + Modules/sha256module.c | 12 +- + Modules/sha512module.c | 12 +- + 20 files changed, 709 insertions(+), 237 deletions(-) + create mode 100644 Misc/NEWS.d/next/Library/2019-09-12-14-54-45.bpo-9216.W7QMpC.rst + +diff --git a/Doc/library/hashlib.rst b/Doc/library/hashlib.rst +index a16c7cd4d7c..6eb3a7bb4cc 100644 +--- a/Doc/library/hashlib.rst ++++ b/Doc/library/hashlib.rst +@@ -67,7 +67,7 @@ Constructors for hash algorithms that are always present in this module are + :func:`sha1`, :func:`sha224`, :func:`sha256`, :func:`sha384`, + :func:`sha512`, :func:`blake2b`, and :func:`blake2s`. + :func:`md5` is normally available as well, though it +-may be missing if you are using a rare "FIPS compliant" build of Python. ++may be missing or blocked if you are using a rare "FIPS compliant" build of Python. + Additional algorithms may also be available depending upon the OpenSSL + library that Python uses on your platform. On most platforms the + :func:`sha3_224`, :func:`sha3_256`, :func:`sha3_384`, :func:`sha3_512`, +@@ -80,6 +80,13 @@ library that Python uses on your platform. On most platforms the + .. versionadded:: 3.6 + :func:`blake2b` and :func:`blake2s` were added. + ++.. versionchanged:: 3.9 ++ All hashlib constructors take a keyword-only argument *usedforsecurity* ++ with default value *True*. A false value allows the use of insecure and ++ blocked hashing algorithms in restricted environments. *False* indicates ++ that the hashing algorithm is not used in a security context, e.g. as a ++ non-cryptographic one-way compression function. ++ + For example, to obtain the digest of the byte string ``b'Nobody inspects the + spammish repetition'``:: + +@@ -99,7 +106,7 @@ More condensed: + >>> hashlib.sha224(b"Nobody inspects the spammish repetition").hexdigest() + 'a4337bc45a8fc544c03f52dc550cd6e1e87021bc896588bd79e901e2' + +-.. function:: new(name[, data]) ++.. function:: new(name[, data], *, usedforsecurity=True) + + Is a generic constructor that takes the string *name* of the desired + algorithm as its first parameter. It also exists to allow access to the +@@ -308,11 +315,13 @@ New hash objects are created by calling constructor functions: + + .. function:: blake2b(data=b'', *, digest_size=64, key=b'', salt=b'', \ + person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \ +- node_depth=0, inner_size=0, last_node=False) ++ node_depth=0, inner_size=0, last_node=False, \ ++ usedforsecurity=True) + + .. function:: blake2s(data=b'', *, digest_size=32, key=b'', salt=b'', \ + person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, \ +- node_depth=0, inner_size=0, last_node=False) ++ node_depth=0, inner_size=0, last_node=False, \ ++ usedforsecurity=True) + + + These functions return the corresponding hash objects for calculating +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 9ae5efc451e..08bb91f27b1 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -226,6 +226,15 @@ class HashLibTestCase(unittest.TestCase): + self.assertTrue(set(hashlib.algorithms_guaranteed). + issubset(hashlib.algorithms_available)) + ++ def test_usedforsecurity(self): ++ for cons in self.hash_constructors: ++ cons(usedforsecurity=True) ++ cons(usedforsecurity=False) ++ cons(b'', usedforsecurity=True) ++ cons(b'', usedforsecurity=False) ++ hashlib.new("sha256", usedforsecurity=True) ++ hashlib.new("sha256", usedforsecurity=False) ++ + def test_unknown_hash(self): + self.assertRaises(ValueError, hashlib.new, 'spam spam spam spam spam') + self.assertRaises(TypeError, hashlib.new, 1) +diff --git a/Lib/uuid.py b/Lib/uuid.py +index 188e16ba14e..5f3bc9e8de4 100644 +--- a/Lib/uuid.py ++++ b/Lib/uuid.py +@@ -772,8 +772,11 @@ def uuid1(node=None, clock_seq=None): + def uuid3(namespace, name): + """Generate a UUID from the MD5 hash of a namespace UUID and a name.""" + from hashlib import md5 +- hash = md5(namespace.bytes + bytes(name, "utf-8")).digest() +- return UUID(bytes=hash[:16], version=3) ++ digest = md5( ++ namespace.bytes + bytes(name, "utf-8"), ++ usedforsecurity=False ++ ).digest() ++ return UUID(bytes=digest[:16], version=3) + + def uuid4(): + """Generate a random UUID.""" +diff --git a/Misc/NEWS.d/next/Library/2019-09-12-14-54-45.bpo-9216.W7QMpC.rst b/Misc/NEWS.d/next/Library/2019-09-12-14-54-45.bpo-9216.W7QMpC.rst +new file mode 100644 +index 00000000000..a97ca4b8b4f +--- /dev/null ++++ b/Misc/NEWS.d/next/Library/2019-09-12-14-54-45.bpo-9216.W7QMpC.rst +@@ -0,0 +1,2 @@ ++hashlib constructors now support usedforsecurity flag to signal that a ++hashing algorithm is not used in a security context. +diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c +index 97ce89d33c1..16df2327930 100644 +--- a/Modules/_blake2/blake2b_impl.c ++++ b/Modules/_blake2/blake2b_impl.c +@@ -82,6 +82,7 @@ _blake2.blake2b.__new__ as py_blake2b_new + node_depth: int = 0 + inner_size: int = 0 + last_node: bool = False ++ usedforsecurity: bool = True + + Return a new BLAKE2b hash object. + [clinic start generated code]*/ +@@ -91,8 +92,8 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + Py_buffer *key, Py_buffer *salt, Py_buffer *person, + int fanout, int depth, unsigned long leaf_size, + unsigned long long node_offset, int node_depth, +- int inner_size, int last_node) +-/*[clinic end generated code: output=65e732c66c2297a0 input=82be35a4e6a9daa2]*/ ++ int inner_size, int last_node, int usedforsecurity) ++/*[clinic end generated code: output=32bfd8f043c6896f input=b947312abff46977]*/ + { + BLAKE2bObject *self = NULL; + Py_buffer buf; +diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c +index c4447b4fe83..66a7ee567d5 100644 +--- a/Modules/_blake2/blake2s_impl.c ++++ b/Modules/_blake2/blake2s_impl.c +@@ -82,6 +82,7 @@ _blake2.blake2s.__new__ as py_blake2s_new + node_depth: int = 0 + inner_size: int = 0 + last_node: bool = False ++ usedforsecurity: bool = True + + Return a new BLAKE2s hash object. + [clinic start generated code]*/ +@@ -91,8 +92,8 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + Py_buffer *key, Py_buffer *salt, Py_buffer *person, + int fanout, int depth, unsigned long leaf_size, + unsigned long long node_offset, int node_depth, +- int inner_size, int last_node) +-/*[clinic end generated code: output=b95806be0514dcf7 input=641c0509debf714d]*/ ++ int inner_size, int last_node, int usedforsecurity) ++/*[clinic end generated code: output=556181f73905c686 input=4dda87723f23abb0]*/ + { + BLAKE2sObject *self = NULL; + Py_buffer buf; +diff --git a/Modules/_blake2/clinic/blake2b_impl.c.h b/Modules/_blake2/clinic/blake2b_impl.c.h +index cd329c07c99..07258c31c9b 100644 +--- a/Modules/_blake2/clinic/blake2b_impl.c.h ++++ b/Modules/_blake2/clinic/blake2b_impl.c.h +@@ -5,7 +5,8 @@ preserve + PyDoc_STRVAR(py_blake2b_new__doc__, + "blake2b(data=b\'\', /, *, digest_size=_blake2.blake2b.MAX_DIGEST_SIZE,\n" + " key=b\'\', salt=b\'\', person=b\'\', fanout=1, depth=1, leaf_size=0,\n" +-" node_offset=0, node_depth=0, inner_size=0, last_node=False)\n" ++" node_offset=0, node_depth=0, inner_size=0, last_node=False,\n" ++" usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new BLAKE2b hash object."); +@@ -15,15 +16,15 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + Py_buffer *key, Py_buffer *salt, Py_buffer *person, + int fanout, int depth, unsigned long leaf_size, + unsigned long long node_offset, int node_depth, +- int inner_size, int last_node); ++ int inner_size, int last_node, int usedforsecurity); + + static PyObject * + py_blake2b_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"", "digest_size", "key", "salt", "person", "fanout", "depth", "leaf_size", "node_offset", "node_depth", "inner_size", "last_node", NULL}; ++ static const char * const _keywords[] = {"", "digest_size", "key", "salt", "person", "fanout", "depth", "leaf_size", "node_offset", "node_depth", "inner_size", "last_node", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "blake2b", 0}; +- PyObject *argsbuf[12]; ++ PyObject *argsbuf[13]; + PyObject * const *fastargs; + Py_ssize_t nargs = PyTuple_GET_SIZE(args); + Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0; +@@ -39,6 +40,7 @@ py_blake2b_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + int node_depth = 0; + int inner_size = 0; + int last_node = 0; ++ int usedforsecurity = 1; + + fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf); + if (!fastargs) { +@@ -175,12 +177,21 @@ skip_optional_posonly: + goto skip_optional_kwonly; + } + } +- last_node = PyObject_IsTrue(fastargs[11]); +- if (last_node < 0) { ++ if (fastargs[11]) { ++ last_node = PyObject_IsTrue(fastargs[11]); ++ if (last_node < 0) { ++ goto exit; ++ } ++ if (!--noptargs) { ++ goto skip_optional_kwonly; ++ } ++ } ++ usedforsecurity = PyObject_IsTrue(fastargs[12]); ++ if (usedforsecurity < 0) { + goto exit; + } + skip_optional_kwonly: +- return_value = py_blake2b_new_impl(type, data, digest_size, &key, &salt, &person, fanout, depth, leaf_size, node_offset, node_depth, inner_size, last_node); ++ return_value = py_blake2b_new_impl(type, data, digest_size, &key, &salt, &person, fanout, depth, leaf_size, node_offset, node_depth, inner_size, last_node, usedforsecurity); + + exit: + /* Cleanup for key */ +@@ -261,4 +272,4 @@ _blake2_blake2b_hexdigest(BLAKE2bObject *self, PyObject *Py_UNUSED(ignored)) + { + return _blake2_blake2b_hexdigest_impl(self); + } +-/*[clinic end generated code: output=cbb625d7f60c288c input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=2d6d0fe9aa42a42a input=a9049054013a1b77]*/ +diff --git a/Modules/_blake2/clinic/blake2s_impl.c.h b/Modules/_blake2/clinic/blake2s_impl.c.h +index 560bd68160b..71c5706fb66 100644 +--- a/Modules/_blake2/clinic/blake2s_impl.c.h ++++ b/Modules/_blake2/clinic/blake2s_impl.c.h +@@ -5,7 +5,8 @@ preserve + PyDoc_STRVAR(py_blake2s_new__doc__, + "blake2s(data=b\'\', /, *, digest_size=_blake2.blake2s.MAX_DIGEST_SIZE,\n" + " key=b\'\', salt=b\'\', person=b\'\', fanout=1, depth=1, leaf_size=0,\n" +-" node_offset=0, node_depth=0, inner_size=0, last_node=False)\n" ++" node_offset=0, node_depth=0, inner_size=0, last_node=False,\n" ++" usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new BLAKE2s hash object."); +@@ -15,15 +16,15 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size, + Py_buffer *key, Py_buffer *salt, Py_buffer *person, + int fanout, int depth, unsigned long leaf_size, + unsigned long long node_offset, int node_depth, +- int inner_size, int last_node); ++ int inner_size, int last_node, int usedforsecurity); + + static PyObject * + py_blake2s_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"", "digest_size", "key", "salt", "person", "fanout", "depth", "leaf_size", "node_offset", "node_depth", "inner_size", "last_node", NULL}; ++ static const char * const _keywords[] = {"", "digest_size", "key", "salt", "person", "fanout", "depth", "leaf_size", "node_offset", "node_depth", "inner_size", "last_node", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "blake2s", 0}; +- PyObject *argsbuf[12]; ++ PyObject *argsbuf[13]; + PyObject * const *fastargs; + Py_ssize_t nargs = PyTuple_GET_SIZE(args); + Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0; +@@ -39,6 +40,7 @@ py_blake2s_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) + int node_depth = 0; + int inner_size = 0; + int last_node = 0; ++ int usedforsecurity = 1; + + fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf); + if (!fastargs) { +@@ -175,12 +177,21 @@ skip_optional_posonly: + goto skip_optional_kwonly; + } + } +- last_node = PyObject_IsTrue(fastargs[11]); +- if (last_node < 0) { ++ if (fastargs[11]) { ++ last_node = PyObject_IsTrue(fastargs[11]); ++ if (last_node < 0) { ++ goto exit; ++ } ++ if (!--noptargs) { ++ goto skip_optional_kwonly; ++ } ++ } ++ usedforsecurity = PyObject_IsTrue(fastargs[12]); ++ if (usedforsecurity < 0) { + goto exit; + } + skip_optional_kwonly: +- return_value = py_blake2s_new_impl(type, data, digest_size, &key, &salt, &person, fanout, depth, leaf_size, node_offset, node_depth, inner_size, last_node); ++ return_value = py_blake2s_new_impl(type, data, digest_size, &key, &salt, &person, fanout, depth, leaf_size, node_offset, node_depth, inner_size, last_node, usedforsecurity); + + exit: + /* Cleanup for key */ +@@ -261,4 +272,4 @@ _blake2_blake2s_hexdigest(BLAKE2sObject *self, PyObject *Py_UNUSED(ignored)) + { + return _blake2_blake2s_hexdigest_impl(self); + } +-/*[clinic end generated code: output=39af5a74c8805b36 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=c80d8d06ce40a192 input=a9049054013a1b77]*/ +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 625e2d2e8f6..8d0c7de2b20 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -517,7 +517,7 @@ static PyTypeObject EVPtype = { + \ + static PyObject * + EVPnew(const EVP_MD *digest, +- const unsigned char *cp, Py_ssize_t len) ++ const unsigned char *cp, Py_ssize_t len, int usedforsecurity) + { + int result = 0; + EVPobject *self; +@@ -530,6 +530,12 @@ EVPnew(const EVP_MD *digest, + if ((self = newEVPobject()) == NULL) + return NULL; + ++ if (!usedforsecurity) { ++#ifdef EVP_MD_CTX_FLAG_NON_FIPS_ALLOW ++ EVP_MD_CTX_set_flags(self->ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW); ++#endif ++ } ++ + if (!EVP_DigestInit_ex(self->ctx, digest, NULL)) { + _setException(PyExc_ValueError); + Py_DECREF(self); +@@ -561,6 +567,8 @@ _hashlib.new as EVP_new + + name as name_obj: object + string as data_obj: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new hash object using the named algorithm. + +@@ -571,8 +579,9 @@ The MD5 and SHA1 algorithms are always supported. + [clinic start generated code]*/ + + static PyObject * +-EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj) +-/*[clinic end generated code: output=9e7cf664e04b0226 input=7eb79bf30058bd02]*/ ++EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=ddd5053f92dffe90 input=c24554d0337be1b0]*/ + { + Py_buffer view = { 0 }; + PyObject *ret_obj; +@@ -589,7 +598,9 @@ EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj) + + digest = py_digest_by_name(name); + +- ret_obj = EVPnew(digest, (unsigned char*)view.buf, view.len); ++ ret_obj = EVPnew(digest, ++ (unsigned char*)view.buf, view.len, ++ usedforsecurity); + + if (data_obj) + PyBuffer_Release(&view); +@@ -597,7 +608,8 @@ EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj) + } + + static PyObject* +-EVP_fast_new(PyObject *module, PyObject *data_obj, const EVP_MD *digest) ++EVP_fast_new(PyObject *module, PyObject *data_obj, const EVP_MD *digest, ++ int usedforsecurity) + { + Py_buffer view = { 0 }; + PyObject *ret_obj; +@@ -605,7 +617,8 @@ EVP_fast_new(PyObject *module, PyObject *data_obj, const EVP_MD *digest) + if (data_obj) + GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view); + +- ret_obj = EVPnew(digest, (unsigned char*)view.buf, view.len); ++ ret_obj = EVPnew(digest, (unsigned char*)view.buf, view.len, ++ usedforsecurity); + + if (data_obj) + PyBuffer_Release(&view); +@@ -617,16 +630,19 @@ EVP_fast_new(PyObject *module, PyObject *data_obj, const EVP_MD *digest) + _hashlib.openssl_md5 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a md5 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=6caae75b73e22c3f input=52010d3869e1b1a7]*/ ++_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=87b0186440a44f8c input=990e36d5e689b16e]*/ + { +- return EVP_fast_new(module, data_obj, EVP_md5()); ++ return EVP_fast_new(module, data_obj, EVP_md5(), usedforsecurity); + } + + +@@ -634,16 +650,19 @@ _hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj) + _hashlib.openssl_sha1 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha1 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=07606d8f75153e61 input=16807d30e4aa8ae9]*/ ++_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=6813024cf690670d input=948f2f4b6deabc10]*/ + { +- return EVP_fast_new(module, data_obj, EVP_sha1()); ++ return EVP_fast_new(module, data_obj, EVP_sha1(), usedforsecurity); + } + + +@@ -651,16 +670,19 @@ _hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj) + _hashlib.openssl_sha224 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha224 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=55e848761bcef0c9 input=5dbc2f1d84eb459b]*/ ++_hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=a2dfe7cc4eb14ebb input=f9272821fadca505]*/ + { +- return EVP_fast_new(module, data_obj, EVP_sha224()); ++ return EVP_fast_new(module, data_obj, EVP_sha224(), usedforsecurity); + } + + +@@ -668,16 +690,19 @@ _hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj) + _hashlib.openssl_sha256 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha256 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=05851d7cce34ac65 input=a68a5d21cda5a80f]*/ ++_hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=1f874a34870f0a68 input=549fad9d2930d4c5]*/ + { +- return EVP_fast_new(module, data_obj, EVP_sha256()); ++ return EVP_fast_new(module, data_obj, EVP_sha256(), usedforsecurity); + } + + +@@ -685,16 +710,19 @@ _hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj) + _hashlib.openssl_sha384 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha384 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=5101a4704a932c2f input=6bdfa006622b64ea]*/ ++_hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=58529eff9ca457b2 input=48601a6e3bf14ad7]*/ + { +- return EVP_fast_new(module, data_obj, EVP_sha384()); ++ return EVP_fast_new(module, data_obj, EVP_sha384(), usedforsecurity); + } + + +@@ -702,152 +730,179 @@ _hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj) + _hashlib.openssl_sha512 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha512 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=20c8e63ee560a5cb input=ece50182ad4b76a6]*/ ++_hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=2c744c9e4a40d5f6 input=c5c46a2a817aa98f]*/ + { +- return EVP_fast_new(module, data_obj, EVP_sha512()); ++ return EVP_fast_new(module, data_obj, EVP_sha512(), usedforsecurity); + } + + /*[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) +-/*[clinic end generated code: output=0d65acd1d9bb5e3f input=d9e6f84fa97e630d]*/ ++_hashlib_openssl_blake2b_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=7a838b1643cde13e input=37247f187d9c4f4a]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_blake2b512()); ++ return EVP_fast_new(module, data_obj, EVP_blake2b512(), 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) +-/*[clinic end generated code: output=0f1330138041ec22 input=f1aec29465fc49c6]*/ ++_hashlib_openssl_blake2s_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=4eda6b40757471da input=36e42912f87ff123]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_blake2s256()); ++ return EVP_fast_new(module, data_obj, EVP_blake2s256(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_sha3_224 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha3_224 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=e3817bed6ecafc20 input=adc74bf14410af70]*/ ++_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=144641c1d144b974 input=450128ca92633287]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_sha3_224()); ++ return EVP_fast_new(module, data_obj, EVP_sha3_224(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_sha3_256 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha3_256 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=9c15fac1ce09cd62 input=2922c3e78ab8bd2d]*/ ++_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=c61f1ab772d06668 input=dda801b8285bc25f]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_sha3_256()); ++ return EVP_fast_new(module, data_obj, EVP_sha3_256(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_sha3_384 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha3_384 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=0923a782b9b81a40 input=742b499c372c8316]*/ ++_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=f68e4846858cf0ee input=3e2c46d271c64ec8]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_sha3_384()); ++ return EVP_fast_new(module, data_obj, EVP_sha3_384(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_sha3_512 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a sha3-512 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=34bbe194704dbce4 input=46383f88e59a0385]*/ ++_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=2eede478c159354a input=64e2cc0c094d56f4]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_sha3_512()); ++ return EVP_fast_new(module, data_obj, EVP_sha3_512(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_shake_128 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a shake_128 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=a6ea5917ce65ef10 input=f256751eb810fdaa]*/ ++_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=bc49cdd8ada1fa97 input=395c17aac1eb4d2e]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_shake128()); ++ return EVP_fast_new(module, data_obj, EVP_shake128(), usedforsecurity); + } + + /*[clinic input] + _hashlib.openssl_shake_256 + + string as data_obj: object(py_default="b''") = NULL ++ * ++ usedforsecurity: bool = True + + Returns a shake_256 hash object; optionally initialized with a string + + [clinic start generated code]*/ + + static PyObject * +-_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj) +-/*[clinic end generated code: output=c91aaa96b000e186 input=d1331313db34116c]*/ ++_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity) ++/*[clinic end generated code: output=358d213be8852df7 input=4fcf0b80fb663690]*/ + + { +- return EVP_fast_new(module, data_obj, EVP_shake256()); ++ return EVP_fast_new(module, data_obj, EVP_shake256(), usedforsecurity); + } + + +diff --git a/Modules/_sha3/clinic/sha3module.c.h b/Modules/_sha3/clinic/sha3module.c.h +index 554442df0ec..1c79c269391 100644 +--- a/Modules/_sha3/clinic/sha3module.c.h ++++ b/Modules/_sha3/clinic/sha3module.c.h +@@ -2,6 +2,52 @@ + preserve + [clinic start generated code]*/ + ++PyDoc_STRVAR(py_sha3_new__doc__, ++"sha3_224(data=b\'\', /, *, usedforsecurity=True)\n" ++"--\n" ++"\n" ++"Return a new BLAKE2b hash object."); ++ ++static PyObject * ++py_sha3_new_impl(PyTypeObject *type, PyObject *data, int usedforsecurity); ++ ++static PyObject * ++py_sha3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) ++{ ++ PyObject *return_value = NULL; ++ static const char * const _keywords[] = {"", "usedforsecurity", NULL}; ++ static _PyArg_Parser _parser = {NULL, _keywords, "sha3_224", 0}; ++ PyObject *argsbuf[2]; ++ PyObject * const *fastargs; ++ Py_ssize_t nargs = PyTuple_GET_SIZE(args); ++ Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0; ++ PyObject *data = NULL; ++ int usedforsecurity = 1; ++ ++ fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf); ++ if (!fastargs) { ++ goto exit; ++ } ++ if (nargs < 1) { ++ goto skip_optional_posonly; ++ } ++ noptargs--; ++ data = fastargs[0]; ++skip_optional_posonly: ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(fastargs[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = py_sha3_new_impl(type, data, usedforsecurity); ++ ++exit: ++ return return_value; ++} ++ + PyDoc_STRVAR(_sha3_sha3_224_copy__doc__, + "copy($self, /)\n" + "--\n" +@@ -118,4 +164,4 @@ _sha3_shake_128_hexdigest(SHA3object *self, PyObject *arg) + exit: + return return_value; + } +-/*[clinic end generated code: output=5b3e99b9a96471e8 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=c8a97b34e80def62 input=a9049054013a1b77]*/ +diff --git a/Modules/_sha3/sha3module.c b/Modules/_sha3/sha3module.c +index 3079e1e3a4a..fc8b1b262ab 100644 +--- a/Modules/_sha3/sha3module.c ++++ b/Modules/_sha3/sha3module.c +@@ -171,22 +171,25 @@ newSHA3object(PyTypeObject *type) + return newobj; + } + ++/*[clinic input] ++@classmethod ++_sha3.sha3_224.__new__ as py_sha3_new ++ data: object(c_default="NULL") = b'' ++ / ++ * ++ usedforsecurity: bool = True ++ ++Return a new BLAKE2b hash object. ++[clinic start generated code]*/ + + static PyObject * +-py_sha3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) ++py_sha3_new_impl(PyTypeObject *type, PyObject *data, int usedforsecurity) ++/*[clinic end generated code: output=90409addc5d5e8b0 input=bcfcdf2e4368347a]*/ + { + FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_sha3"); + SHA3object *self = NULL; + Py_buffer buf = {NULL, NULL}; + HashReturn res; +- PyObject *data = NULL; +- +- if (!_PyArg_NoKeywords(_PyType_Name(type), kwargs)) { +- return NULL; +- } +- if (!PyArg_UnpackTuple(args, _PyType_Name(type), 0, 1, &data)) { +- return NULL; +- } + + self = newSHA3object(type); + if (self == NULL) { +@@ -532,22 +535,22 @@ static PyGetSetDef SHA3_getseters[] = { + } + + PyDoc_STRVAR(sha3_224__doc__, +-"sha3_224([data]) -> SHA3 object\n\ ++"sha3_224([data], *, usedforsecurity=True) -> SHA3 object\n\ + \n\ + Return a new SHA3 hash object with a hashbit length of 28 bytes."); + + PyDoc_STRVAR(sha3_256__doc__, +-"sha3_256([data]) -> SHA3 object\n\ ++"sha3_256([data], *, usedforsecurity=True) -> SHA3 object\n\ + \n\ + Return a new SHA3 hash object with a hashbit length of 32 bytes."); + + PyDoc_STRVAR(sha3_384__doc__, +-"sha3_384([data]) -> SHA3 object\n\ ++"sha3_384([data], *, usedforsecurity=True) -> SHA3 object\n\ + \n\ + Return a new SHA3 hash object with a hashbit length of 48 bytes."); + + PyDoc_STRVAR(sha3_512__doc__, +-"sha3_512([data]) -> SHA3 object\n\ ++"sha3_512([data], *, usedforsecurity=True) -> SHA3 object\n\ + \n\ + Return a new SHA3 hash object with a hashbit length of 64 bytes."); + +@@ -558,22 +561,22 @@ SHA3_TYPE(SHA3_512type, "_sha3.sha3_512", sha3_512__doc__, SHA3_methods); + + #ifdef PY_WITH_KECCAK + PyDoc_STRVAR(keccak_224__doc__, +-"keccak_224([data]) -> Keccak object\n\ ++"keccak_224([data], *, usedforsecurity=True) -> Keccak object\n\ + \n\ + Return a new Keccak hash object with a hashbit length of 28 bytes."); + + PyDoc_STRVAR(keccak_256__doc__, +-"keccak_256([data]) -> Keccak object\n\ ++"keccak_256([data], *, usedforsecurity=True) -> Keccak object\n\ + \n\ + Return a new Keccak hash object with a hashbit length of 32 bytes."); + + PyDoc_STRVAR(keccak_384__doc__, +-"keccak_384([data]) -> Keccak object\n\ ++"keccak_384([data], *, usedforsecurity=True) -> Keccak object\n\ + \n\ + Return a new Keccak hash object with a hashbit length of 48 bytes."); + + PyDoc_STRVAR(keccak_512__doc__, +-"keccak_512([data]) -> Keccak object\n\ ++"keccak_512([data], *, usedforsecurity=True) -> Keccak object\n\ + \n\ + Return a new Keccak hash object with a hashbit length of 64 bytes."); + +@@ -675,12 +678,12 @@ static PyMethodDef SHAKE_methods[] = { + }; + + PyDoc_STRVAR(shake_128__doc__, +-"shake_128([data]) -> SHAKE object\n\ ++"shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\ + \n\ + Return a new SHAKE hash object."); + + PyDoc_STRVAR(shake_256__doc__, +-"shake_256([data]) -> SHAKE object\n\ ++"shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\ + \n\ + Return a new SHAKE hash object."); + +diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h +index e96a752e273..967884727bd 100644 +--- a/Modules/clinic/_hashopenssl.c.h ++++ b/Modules/clinic/_hashopenssl.c.h +@@ -66,7 +66,7 @@ PyDoc_STRVAR(EVP_update__doc__, + {"update", (PyCFunction)EVP_update, METH_O, EVP_update__doc__}, + + PyDoc_STRVAR(EVP_new__doc__, +-"new($module, /, name, string=b\'\')\n" ++"new($module, /, name, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new hash object using the named algorithm.\n" +@@ -80,18 +80,20 @@ PyDoc_STRVAR(EVP_new__doc__, + {"new", (PyCFunction)(void(*)(void))EVP_new, METH_FASTCALL|METH_KEYWORDS, EVP_new__doc__}, + + static PyObject * +-EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj); ++EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + EVP_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"name", "string", NULL}; ++ static const char * const _keywords[] = {"name", "string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "new", 0}; +- PyObject *argsbuf[2]; ++ PyObject *argsbuf[3]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; + PyObject *name_obj; + PyObject *data_obj = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); + if (!args) { +@@ -101,16 +103,29 @@ EVP_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwn + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[1]; ++ if (args[1]) { ++ data_obj = args[1]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = EVP_new_impl(module, name_obj, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[2]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = EVP_new_impl(module, name_obj, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_md5__doc__, +-"openssl_md5($module, /, string=b\'\')\n" ++"openssl_md5($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a md5 hash object; optionally initialized with a string"); +@@ -119,17 +134,19 @@ PyDoc_STRVAR(_hashlib_openssl_md5__doc__, + {"openssl_md5", (PyCFunction)(void(*)(void))_hashlib_openssl_md5, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_md5__doc__}, + + static PyObject * +-_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_md5", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -138,16 +155,29 @@ _hashlib_openssl_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_md5_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_md5_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha1__doc__, +-"openssl_sha1($module, /, string=b\'\')\n" ++"openssl_sha1($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha1 hash object; optionally initialized with a string"); +@@ -156,17 +186,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha1__doc__, + {"openssl_sha1", (PyCFunction)(void(*)(void))_hashlib_openssl_sha1, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha1__doc__}, + + static PyObject * +-_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha1", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -175,16 +207,29 @@ _hashlib_openssl_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha1_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha1_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha224__doc__, +-"openssl_sha224($module, /, string=b\'\')\n" ++"openssl_sha224($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha224 hash object; optionally initialized with a string"); +@@ -193,17 +238,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha224__doc__, + {"openssl_sha224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha224__doc__}, + + static PyObject * +-_hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha224", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -212,16 +259,29 @@ _hashlib_openssl_sha224(PyObject *module, PyObject *const *args, Py_ssize_t narg + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha224_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha224_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha256__doc__, +-"openssl_sha256($module, /, string=b\'\')\n" ++"openssl_sha256($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha256 hash object; optionally initialized with a string"); +@@ -230,17 +290,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha256__doc__, + {"openssl_sha256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha256__doc__}, + + static PyObject * +-_hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha256", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -249,16 +311,29 @@ _hashlib_openssl_sha256(PyObject *module, PyObject *const *args, Py_ssize_t narg + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha256_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha256_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha384__doc__, +-"openssl_sha384($module, /, string=b\'\')\n" ++"openssl_sha384($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha384 hash object; optionally initialized with a string"); +@@ -267,17 +342,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha384__doc__, + {"openssl_sha384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha384__doc__}, + + static PyObject * +-_hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha384", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -286,16 +363,29 @@ _hashlib_openssl_sha384(PyObject *module, PyObject *const *args, Py_ssize_t narg + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha384_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha384_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha512__doc__, +-"openssl_sha512($module, /, string=b\'\')\n" ++"openssl_sha512($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha512 hash object; optionally initialized with a string"); +@@ -304,17 +394,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha512__doc__, + {"openssl_sha512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha512__doc__}, + + static PyObject * +-_hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha512", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -323,16 +415,29 @@ _hashlib_openssl_sha512(PyObject *module, PyObject *const *args, Py_ssize_t narg + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha512_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha512_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_blake2b__doc__, +-"openssl_blake2b($module, /, string=b\'\')\n" ++"openssl_blake2b($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a blake2b hash object; optionally initialized with a string"); +@@ -341,17 +446,19 @@ PyDoc_STRVAR(_hashlib_openssl_blake2b__doc__, + {"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); ++_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", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2b", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -360,16 +467,29 @@ _hashlib_openssl_blake2b(PyObject *module, PyObject *const *args, Py_ssize_t nar + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_blake2b_impl(module, data_obj); ++ 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\'\')\n" ++"openssl_blake2s($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a blake2s hash object; optionally initialized with a string"); +@@ -378,17 +498,19 @@ PyDoc_STRVAR(_hashlib_openssl_blake2s__doc__, + {"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); ++_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", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_blake2s", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -397,16 +519,29 @@ _hashlib_openssl_blake2s(PyObject *module, PyObject *const *args, Py_ssize_t nar + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_blake2s_impl(module, data_obj); ++ 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; + } + + PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__, +-"openssl_sha3_224($module, /, string=b\'\')\n" ++"openssl_sha3_224($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha3_224 hash object; optionally initialized with a string"); +@@ -415,17 +550,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__, + {"openssl_sha3_224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_224__doc__}, + + static PyObject * +-_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha3_224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_224", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -434,16 +571,29 @@ _hashlib_openssl_sha3_224(PyObject *module, PyObject *const *args, Py_ssize_t na + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha3_224_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha3_224_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha3_256__doc__, +-"openssl_sha3_256($module, /, string=b\'\')\n" ++"openssl_sha3_256($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha3_256 hash object; optionally initialized with a string"); +@@ -452,17 +602,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha3_256__doc__, + {"openssl_sha3_256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_256__doc__}, + + static PyObject * +-_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha3_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_256", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -471,16 +623,29 @@ _hashlib_openssl_sha3_256(PyObject *module, PyObject *const *args, Py_ssize_t na + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha3_256_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha3_256_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha3_384__doc__, +-"openssl_sha3_384($module, /, string=b\'\')\n" ++"openssl_sha3_384($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha3_384 hash object; optionally initialized with a string"); +@@ -489,17 +654,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha3_384__doc__, + {"openssl_sha3_384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_384__doc__}, + + static PyObject * +-_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha3_384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_384", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -508,16 +675,29 @@ _hashlib_openssl_sha3_384(PyObject *module, PyObject *const *args, Py_ssize_t na + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha3_384_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha3_384_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_sha3_512__doc__, +-"openssl_sha3_512($module, /, string=b\'\')\n" ++"openssl_sha3_512($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a sha3-512 hash object; optionally initialized with a string"); +@@ -526,17 +706,19 @@ PyDoc_STRVAR(_hashlib_openssl_sha3_512__doc__, + {"openssl_sha3_512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_512__doc__}, + + static PyObject * +-_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_sha3_512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_512", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -545,16 +727,29 @@ _hashlib_openssl_sha3_512(PyObject *module, PyObject *const *args, Py_ssize_t na + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_sha3_512_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_sha3_512_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__, +-"openssl_shake_128($module, /, string=b\'\')\n" ++"openssl_shake_128($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a shake_128 hash object; optionally initialized with a string"); +@@ -563,17 +758,19 @@ PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__, + {"openssl_shake_128", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_128, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_128__doc__}, + + static PyObject * +-_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_128", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -582,16 +779,29 @@ _hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t n + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_shake_128_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_shake_128_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__, +-"openssl_shake_256($module, /, string=b\'\')\n" ++"openssl_shake_256($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Returns a shake_256 hash object; optionally initialized with a string"); +@@ -600,17 +810,19 @@ PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__, + {"openssl_shake_256", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_256__doc__}, + + static PyObject * +-_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj); ++_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj, ++ int usedforsecurity); + + static PyObject * + _hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_256", 0}; +- PyObject *argsbuf[1]; ++ 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) { +@@ -619,9 +831,22 @@ _hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t n + if (!noptargs) { + goto skip_optional_pos; + } +- data_obj = args[0]; ++ if (args[0]) { ++ data_obj = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _hashlib_openssl_shake_256_impl(module, data_obj); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _hashlib_openssl_shake_256_impl(module, data_obj, usedforsecurity); + + exit: + return return_value; +@@ -942,4 +1167,4 @@ _hashlib_get_fips_mode(PyObject *module, PyObject *Py_UNUSED(ignored)) + #ifndef _HASHLIB_SCRYPT_METHODDEF + #define _HASHLIB_SCRYPT_METHODDEF + #endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */ +-/*[clinic end generated code: output=be8e21a10dff71e7 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=3db4f18f12892fa4 input=a9049054013a1b77]*/ +diff --git a/Modules/clinic/md5module.c.h b/Modules/clinic/md5module.c.h +index 12484cc0e3d..c109f9efec6 100644 +--- a/Modules/clinic/md5module.c.h ++++ b/Modules/clinic/md5module.c.h +@@ -66,7 +66,7 @@ PyDoc_STRVAR(MD5Type_update__doc__, + {"update", (PyCFunction)MD5Type_update, METH_O, MD5Type_update__doc__}, + + PyDoc_STRVAR(_md5_md5__doc__, +-"md5($module, /, string=b\'\')\n" ++"md5($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new MD5 hash object; optionally initialized with a string."); +@@ -75,17 +75,18 @@ PyDoc_STRVAR(_md5_md5__doc__, + {"md5", (PyCFunction)(void(*)(void))_md5_md5, METH_FASTCALL|METH_KEYWORDS, _md5_md5__doc__}, + + static PyObject * +-_md5_md5_impl(PyObject *module, PyObject *string); ++_md5_md5_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _md5_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "md5", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -94,11 +95,24 @@ _md5_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kw + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _md5_md5_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _md5_md5_impl(module, string, usedforsecurity); + + exit: + return return_value; + } +-/*[clinic end generated code: output=53133f08cf9095fc input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=dbe3abc60086f3ef input=a9049054013a1b77]*/ +diff --git a/Modules/clinic/sha1module.c.h b/Modules/clinic/sha1module.c.h +index 001c6af7378..fc37b1ab880 100644 +--- a/Modules/clinic/sha1module.c.h ++++ b/Modules/clinic/sha1module.c.h +@@ -66,7 +66,7 @@ PyDoc_STRVAR(SHA1Type_update__doc__, + {"update", (PyCFunction)SHA1Type_update, METH_O, SHA1Type_update__doc__}, + + PyDoc_STRVAR(_sha1_sha1__doc__, +-"sha1($module, /, string=b\'\')\n" ++"sha1($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new SHA1 hash object; optionally initialized with a string."); +@@ -75,17 +75,18 @@ PyDoc_STRVAR(_sha1_sha1__doc__, + {"sha1", (PyCFunction)(void(*)(void))_sha1_sha1, METH_FASTCALL|METH_KEYWORDS, _sha1_sha1__doc__}, + + static PyObject * +-_sha1_sha1_impl(PyObject *module, PyObject *string); ++_sha1_sha1_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _sha1_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "sha1", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -94,11 +95,24 @@ _sha1_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject * + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _sha1_sha1_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _sha1_sha1_impl(module, string, usedforsecurity); + + exit: + return return_value; + } +-/*[clinic end generated code: output=1ae7e73ec84a27d5 input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=3ddd637ae17e14b3 input=a9049054013a1b77]*/ +diff --git a/Modules/clinic/sha256module.c.h b/Modules/clinic/sha256module.c.h +index 658abb15cf3..2a788ea9849 100644 +--- a/Modules/clinic/sha256module.c.h ++++ b/Modules/clinic/sha256module.c.h +@@ -66,7 +66,7 @@ PyDoc_STRVAR(SHA256Type_update__doc__, + {"update", (PyCFunction)SHA256Type_update, METH_O, SHA256Type_update__doc__}, + + PyDoc_STRVAR(_sha256_sha256__doc__, +-"sha256($module, /, string=b\'\')\n" ++"sha256($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new SHA-256 hash object; optionally initialized with a string."); +@@ -75,17 +75,18 @@ PyDoc_STRVAR(_sha256_sha256__doc__, + {"sha256", (PyCFunction)(void(*)(void))_sha256_sha256, METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__}, + + static PyObject * +-_sha256_sha256_impl(PyObject *module, PyObject *string); ++_sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _sha256_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "sha256", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -94,16 +95,29 @@ _sha256_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _sha256_sha256_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _sha256_sha256_impl(module, string, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_sha256_sha224__doc__, +-"sha224($module, /, string=b\'\')\n" ++"sha224($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new SHA-224 hash object; optionally initialized with a string."); +@@ -112,17 +126,18 @@ PyDoc_STRVAR(_sha256_sha224__doc__, + {"sha224", (PyCFunction)(void(*)(void))_sha256_sha224, METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__}, + + static PyObject * +-_sha256_sha224_impl(PyObject *module, PyObject *string); ++_sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _sha256_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "sha224", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -131,11 +146,24 @@ _sha256_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _sha256_sha224_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _sha256_sha224_impl(module, string, usedforsecurity); + + exit: + return return_value; + } +-/*[clinic end generated code: output=c54d0956ec88409d input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=c8cca8adbe72ec9a input=a9049054013a1b77]*/ +diff --git a/Modules/clinic/sha512module.c.h b/Modules/clinic/sha512module.c.h +index 459a9341cfc..b8185b62bb6 100644 +--- a/Modules/clinic/sha512module.c.h ++++ b/Modules/clinic/sha512module.c.h +@@ -66,7 +66,7 @@ PyDoc_STRVAR(SHA512Type_update__doc__, + {"update", (PyCFunction)SHA512Type_update, METH_O, SHA512Type_update__doc__}, + + PyDoc_STRVAR(_sha512_sha512__doc__, +-"sha512($module, /, string=b\'\')\n" ++"sha512($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new SHA-512 hash object; optionally initialized with a string."); +@@ -75,17 +75,18 @@ PyDoc_STRVAR(_sha512_sha512__doc__, + {"sha512", (PyCFunction)(void(*)(void))_sha512_sha512, METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__}, + + static PyObject * +-_sha512_sha512_impl(PyObject *module, PyObject *string); ++_sha512_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _sha512_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "sha512", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -94,16 +95,29 @@ _sha512_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _sha512_sha512_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _sha512_sha512_impl(module, string, usedforsecurity); + + exit: + return return_value; + } + + PyDoc_STRVAR(_sha512_sha384__doc__, +-"sha384($module, /, string=b\'\')\n" ++"sha384($module, /, string=b\'\', *, usedforsecurity=True)\n" + "--\n" + "\n" + "Return a new SHA-384 hash object; optionally initialized with a string."); +@@ -112,17 +126,18 @@ PyDoc_STRVAR(_sha512_sha384__doc__, + {"sha384", (PyCFunction)(void(*)(void))_sha512_sha384, METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__}, + + static PyObject * +-_sha512_sha384_impl(PyObject *module, PyObject *string); ++_sha512_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity); + + static PyObject * + _sha512_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) + { + PyObject *return_value = NULL; +- static const char * const _keywords[] = {"string", NULL}; ++ static const char * const _keywords[] = {"string", "usedforsecurity", NULL}; + static _PyArg_Parser _parser = {NULL, _keywords, "sha384", 0}; +- PyObject *argsbuf[1]; ++ PyObject *argsbuf[2]; + Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; + PyObject *string = NULL; ++ int usedforsecurity = 1; + + args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); + if (!args) { +@@ -131,11 +146,24 @@ _sha512_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje + if (!noptargs) { + goto skip_optional_pos; + } +- string = args[0]; ++ if (args[0]) { ++ string = args[0]; ++ if (!--noptargs) { ++ goto skip_optional_pos; ++ } ++ } + skip_optional_pos: +- return_value = _sha512_sha384_impl(module, string); ++ if (!noptargs) { ++ goto skip_optional_kwonly; ++ } ++ usedforsecurity = PyObject_IsTrue(args[1]); ++ if (usedforsecurity < 0) { ++ goto exit; ++ } ++skip_optional_kwonly: ++ return_value = _sha512_sha384_impl(module, string, usedforsecurity); + + exit: + return return_value; + } +-/*[clinic end generated code: output=580df4b667084a7e input=a9049054013a1b77]*/ ++/*[clinic end generated code: output=bbfa72d8703c82b5 input=a9049054013a1b77]*/ +diff --git a/Modules/md5module.c b/Modules/md5module.c +index b9a351a8c1c..f2c2d32cbe7 100644 +--- a/Modules/md5module.c ++++ b/Modules/md5module.c +@@ -503,13 +503,15 @@ static PyTypeObject MD5type = { + _md5.md5 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new MD5 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_md5_md5_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=2cfd0f8c091b97e6 input=d12ef8f72d684f7b]*/ ++_md5_md5_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=587071f76254a4ac input=7a144a1905636985]*/ + { + MD5object *new; + Py_buffer buf; +diff --git a/Modules/sha1module.c b/Modules/sha1module.c +index ce2ad267e77..4d191c3c488 100644 +--- a/Modules/sha1module.c ++++ b/Modules/sha1module.c +@@ -480,13 +480,15 @@ static PyTypeObject SHA1type = { + _sha1.sha1 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new SHA1 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_sha1_sha1_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=e5982830d1dece51 input=27ea54281d995ec2]*/ ++_sha1_sha1_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=6f8b3af05126e18e input=bd54b68e2bf36a8a]*/ + { + SHA1object *new; + Py_buffer buf; +diff --git a/Modules/sha256module.c b/Modules/sha256module.c +index b8d6c4cf800..245f4c04542 100644 +--- a/Modules/sha256module.c ++++ b/Modules/sha256module.c +@@ -601,13 +601,15 @@ static PyTypeObject SHA256type = { + _sha256.sha256 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new SHA-256 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_sha256_sha256_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=fa644436dcea5c31 input=09cce3fb855056b2]*/ ++_sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=a1de327e8e1185cf input=9be86301aeb14ea5]*/ + { + SHAobject *new; + Py_buffer buf; +@@ -641,13 +643,15 @@ _sha256_sha256_impl(PyObject *module, PyObject *string) + _sha256.sha224 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new SHA-224 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_sha256_sha224_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=21e3ba22c3404f93 input=27a04ba24c353a73]*/ ++_sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=08be6b36569bc69c input=9fcfb46e460860ac]*/ + { + SHAobject *new; + Py_buffer buf; +diff --git a/Modules/sha512module.c b/Modules/sha512module.c +index 98b97917f4c..df4f9d2d741 100644 +--- a/Modules/sha512module.c ++++ b/Modules/sha512module.c +@@ -666,13 +666,15 @@ static PyTypeObject SHA512type = { + _sha512.sha512 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new SHA-512 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_sha512_sha512_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=8b865a2df73bd387 input=e69bad9ae9b6a308]*/ ++_sha512_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=a8d9e5f9e6a0831c input=23b4daebc2ebb9c9]*/ + { + SHAobject *new; + Py_buffer buf; +@@ -706,13 +708,15 @@ _sha512_sha512_impl(PyObject *module, PyObject *string) + _sha512.sha384 + + string: object(c_default="NULL") = b'' ++ * ++ usedforsecurity: bool = True + + Return a new SHA-384 hash object; optionally initialized with a string. + [clinic start generated code]*/ + + static PyObject * +-_sha512_sha384_impl(PyObject *module, PyObject *string) +-/*[clinic end generated code: output=ae4b2e26decf81e8 input=c9327788d4ea4545]*/ ++_sha512_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity) ++/*[clinic end generated code: output=da7d594a08027ac3 input=59ef72f039a6b431]*/ + { + SHAobject *new; + Py_buffer buf; +-- +2.21.1 + + +From aed5f603fda874d823ca04b562c8289bfa42d8f3 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 26 Aug 2019 19:09:39 +0200 +Subject: [PATCH 26/32] Test the usedforsecurity flag + +--- + Lib/test/test_hashlib.py | 88 ++++++++++++++++++++++++---------------- + 1 file changed, 54 insertions(+), 34 deletions(-) + +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 08bb91f27b1..1368e917089 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -21,6 +21,7 @@ from test import support + from test.support import _4G, bigmemtest, import_fresh_module + from test.support import requires_hashdigest + 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') +@@ -29,8 +30,10 @@ c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib']) + py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib']) + + if hashlib.get_fips_mode(): +- FIPS_DISABLED = {'md5', 'MD5', 'blake2b', 'blake2s'} ++ FIPS_UNAVAILABLE = {'blake2b', 'blake2s'} ++ FIPS_DISABLED = {'md5', 'MD5', *FIPS_UNAVAILABLE} + else: ++ FIPS_UNAVAILABLE = set() + FIPS_DISABLED = set() + + try: +@@ -80,6 +83,15 @@ def read_vectors(hash_name): + yield parts + + ++def _is_openssl_constructor(constructor): ++ if getattr(constructor, '__name__', '').startswith('openssl_'): ++ return True ++ if isinstance(constructor, partial): ++ if constructor.func.__name__.startswith('openssl_'): ++ return True ++ return False ++ ++ + class HashLibTestCase(unittest.TestCase): + supported_hash_names = ( 'md5', 'MD5', 'sha1', 'SHA1', + 'sha224', 'SHA224', 'sha256', 'SHA256', +@@ -95,8 +107,6 @@ class HashLibTestCase(unittest.TestCase): + + if hashlib.get_fips_mode(): + shakes = set() +- supported_hash_names = tuple( +- n for n in supported_hash_names if n not in FIPS_DISABLED) + + def _conditional_import_module(self, module_name): + """Import a module and return a reference to it or None on failure.""" +@@ -122,7 +132,8 @@ class HashLibTestCase(unittest.TestCase): + def __init__(self, *args, **kwargs): + algorithms = set() + for algorithm in self.supported_hash_names: +- algorithms.add(algorithm.lower()) ++ if algorithm not in FIPS_UNAVAILABLE: ++ algorithms.add(algorithm.lower()) + + _blake2 = self._conditional_import_module('_blake2') + if _blake2: +@@ -132,15 +143,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 +@@ -152,13 +169,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): + constructor = getattr(hashlib, "__get_builtin_constructor")(name) +@@ -218,7 +229,7 @@ class HashLibTestCase(unittest.TestCase): + c.hexdigest() + + def test_algorithms_guaranteed(self): +- self.assertEqual(hashlib.algorithms_guaranteed - FIPS_DISABLED, ++ self.assertEqual(hashlib.algorithms_guaranteed, + set(_algo for _algo in self.supported_hash_names + if _algo.islower())) + +@@ -305,7 +316,9 @@ class HashLibTestCase(unittest.TestCase): + self.assertIn(h.name, self.supported_hash_names) + else: + self.assertNotIn(h.name, self.supported_hash_names) +- self.assertEqual(h.name, hashlib.new(h.name).name) ++ if 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) + + def test_large_update(self): + aas = b'a' * 128 +@@ -347,13 +360,15 @@ class HashLibTestCase(unittest.TestCase): + self.assertGreaterEqual(len(constructors), 2) + for hash_object_constructor in constructors: + if ( +- kwargs +- and hash_object_constructor.__name__.startswith('openssl_') ++ (kwargs.keys() - {'usedforsecurity'}) ++ and _is_openssl_constructor(hash_object_constructor) + ): ++ # Don't check openssl constructors with ++ # any extra keys (except usedforsecurity) + return + m = hash_object_constructor(data, **kwargs) + if shake: +- if hash_object_constructor.__name__.startswith('openssl_'): ++ if _is_openssl_constructor(hash_object_constructor): + if length > m.digest_size: + # OpenSSL doesn't give long digests + return +@@ -370,7 +385,7 @@ class HashLibTestCase(unittest.TestCase): + % (name, hash_object_constructor, + computed, len(data), hexdigest)) + if shake: +- if hash_object_constructor.__name__.startswith('openssl_'): ++ if _is_openssl_constructor(hash_object_constructor): + computed = m.digest()[:length] + else: + computed = m.digest(length) +@@ -388,8 +403,7 @@ class HashLibTestCase(unittest.TestCase): + self.assertRaises(TypeError, hash_object_constructor, 'spam') + + def test_no_unicode(self): +- if not hashlib.get_fips_mode(): +- self.check_no_unicode('md5') ++ self.check_no_unicode('md5') + self.check_no_unicode('sha1') + self.check_no_unicode('sha224') + self.check_no_unicode('sha256') +@@ -416,10 +430,10 @@ class HashLibTestCase(unittest.TestCase): + for hash_object_constructor in constructors: + m = hash_object_constructor() + self.assertEqual(m.block_size, block_size) +- if not hash_object_constructor.__name__.startswith('openssl_'): ++ if not _is_openssl_constructor(hash_object_constructor): + self.assertEqual(m.digest_size, digest_size) + if digest_length: +- if not hash_object_constructor.__name__.startswith('openssl_'): ++ if not _is_openssl_constructor(hash_object_constructor): + self.assertEqual(len(m.digest(digest_length)), + digest_length) + self.assertEqual(len(m.hexdigest(digest_length)), +@@ -457,7 +471,7 @@ class HashLibTestCase(unittest.TestCase): + # _hashopenssl's variant does not have extra SHA3 attributes + continue + self.assertEqual(capacity + rate, 1600) +- if not hash_object_constructor.__name__.startswith('openssl_'): ++ if not _is_openssl_constructor(hash_object_constructor): + self.assertEqual(m._capacity_bits, capacity) + self.assertEqual(m._rate_bits, rate) + self.assertEqual(m._suffix, suffix) +@@ -476,31 +490,27 @@ class HashLibTestCase(unittest.TestCase): + self.check_blocksize_name('blake2b', 128, 64) + self.check_blocksize_name('blake2s', 64, 32) + +- @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_0(self): +- self.check('md5', b'', 'd41d8cd98f00b204e9800998ecf8427e') ++ self.check('md5', b'', 'd41d8cd98f00b204e9800998ecf8427e', usedforsecurity=False) + +- @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_1(self): +- self.check('md5', b'abc', '900150983cd24fb0d6963f7d28e17f72') ++ self.check('md5', b'abc', '900150983cd24fb0d6963f7d28e17f72', usedforsecurity=False) + +- @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + def test_case_md5_2(self): + self.check('md5', + b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', +- 'd174ab98d277d9f5a5611c2c9f419d9f') ++ 'd174ab98d277d9f5a5611c2c9f419d9f', ++ usedforsecurity=False) + +- @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + @unittest.skipIf(sys.maxsize < _4G + 5, 'test cannot run on 32-bit systems') + @bigmemtest(size=_4G + 5, memuse=1, dry_run=False) + def test_case_md5_huge(self, size): +- self.check('md5', b'A'*size, 'c9af2dff37468ce5dfee8f2cfc0a9c6d') ++ self.check('md5', b'A'*size, 'c9af2dff37468ce5dfee8f2cfc0a9c6d', usedforsecurity=False) + +- @unittest.skipIf(hashlib.get_fips_mode(), "md5 unacceptable in FIPS mode") + @unittest.skipIf(sys.maxsize < _4G - 1, 'test cannot run on 32-bit systems') + @bigmemtest(size=_4G - 1, memuse=1, dry_run=False) + def test_case_md5_uintmax(self, size): +- self.check('md5', b'A'*size, '28138d306ff1b8281f1a9067e1a1a2b3') ++ self.check('md5', b'A'*size, '28138d306ff1b8281f1a9067e1a1a2b3', usedforsecurity=False) + + # use the three examples from Federal Information Processing Standards + # Publication 180-1, Secure Hash Standard, 1995 April 17 +@@ -925,6 +935,16 @@ class HashLibTestCase(unittest.TestCase): + + self.assertEqual(expected_hash, hasher.hexdigest()) + ++ @unittest.skipUnless(hashlib.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.21.1 + + +From fa3ce5149806b1ef588b75681147636d55c5c604 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 29 Aug 2019 10:25:28 +0200 +Subject: [PATCH 27/32] Skip error checking in _hashlib.get_fips_mode + +Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1745499 +--- + Modules/_hashopenssl.c | 30 ++++++++++++++++-------------- + 1 file changed, 16 insertions(+), 14 deletions(-) + +diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c +index 8d0c7de2b20..ed92514e786 100644 +--- a/Modules/_hashopenssl.c ++++ b/Modules/_hashopenssl.c +@@ -1249,20 +1249,22 @@ _hashlib_get_fips_mode_impl(PyObject *module) + /*[clinic end generated code: output=ad8a7793310d3f98 input=f42a2135df2a5e11]*/ + + { +- int result = FIPS_mode(); +- if (result == 0) { +- // "If the library was built without support of the FIPS Object Module, +- // then the function will return 0 with an error code of +- // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)." +- // But 0 is also a valid result value. +- +- unsigned long errcode = ERR_peek_last_error(); +- if (errcode) { +- _setException(PyExc_ValueError); +- return NULL; +- } +- } +- return PyLong_FromLong(result); ++ // XXX: This function skips error checking. ++ // This is only appropriate for RHEL. ++ ++ // From the OpenSSL docs: ++ // "If the library was built without support of the FIPS Object Module, ++ // then the function will return 0 with an error code of ++ // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)." ++ // In RHEL: ++ // * we do build with FIPS, so the function always succeeds ++ // * even if it didn't, people seem used to errors being left on the ++ // OpenSSL error stack. ++ ++ // For more info, see: ++ // https://bugzilla.redhat.com/show_bug.cgi?id=1745499 ++ ++ return PyLong_FromLong(FIPS_mode()); + } + + +-- +2.21.1 + + +From 282056eda492073e9e03904e8a513547fe2b9836 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Thu, 10 Oct 2019 13:04:50 +0200 +Subject: [PATCH 28/32] Skip error checking in _Py_hashlib_fips_error + +https://bugzilla.redhat.com/show_bug.cgi?id=1760106 +--- + Include/_hashopenssl.h | 12 +++--------- + 1 file changed, 3 insertions(+), 9 deletions(-) + +diff --git a/Include/_hashopenssl.h b/Include/_hashopenssl.h +index 47ed0030422..d4cbdef984d 100644 +--- a/Include/_hashopenssl.h ++++ b/Include/_hashopenssl.h +@@ -42,16 +42,10 @@ static int + _Py_hashlib_fips_error(PyObject *exc, char *name) { + int result = FIPS_mode(); + if (result == 0) { +- // "If the library was built without support of the FIPS Object Module, +- // then the function will return 0 with an error code of +- // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)." +- // But 0 is also a valid result value. ++ // XXX: This function skips error checking. ++ // This is only appropriate for RHEL. ++ // See _hashlib.get_fips_mode for details. + +- unsigned long errcode = ERR_peek_last_error(); +- if (errcode) { +- _setException(exc); +- return 1; +- } + return 0; + } + PyErr_Format(exc, "%s is not available in FIPS mode", name); +-- +2.21.1 + + +From 6c5a3b45f7754e7d19084794f573189ba38a00fa Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 5 Aug 2019 19:12:38 +0200 +Subject: [PATCH 29/32] Fixups + +- Adjust error message of the original hmac.HMAC class +- Don't duplicate a test name +--- + Lib/hmac.py | 2 +- + Lib/test/test_hmac.py | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Lib/hmac.py b/Lib/hmac.py +index 394c81037b5..b2bff7d9758 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -47,7 +47,7 @@ class HMAC: + """ + if _hashlib.get_fips_mode(): + raise ValueError( +- 'hmac.HMAC is not available in FIPS mode. ' ++ 'This class is not available in FIPS mode. ' + + 'Use hmac.new().' + ) + +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index 0a859817f68..0b481ec9c01 100644 +--- a/Lib/test/test_hmac.py ++++ b/Lib/test/test_hmac.py +@@ -439,7 +439,7 @@ class CopyTestCase(unittest.TestCase): + self.assertTrue(id(h1.outer) != id(h2.outer), + "No real copy of the attribute 'outer'.") + +- def test_realcopy(self): ++ def test_realcopy_by_digest(self): + # Testing if the copy method created a real copy. + h1 = hmac.HMAC(b"key", digestmod="sha1") + h2 = h1.copy() +-- +2.21.1 + + +From 63426a2f6c7904800094db9fd3476a5d4711ad25 Mon Sep 17 00:00:00 2001 +From: Petr Viktorin +Date: Mon, 26 Aug 2019 19:39:48 +0200 +Subject: [PATCH 30/32] Don't re-export get_fips_mode from hashlib + +Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1745685 +--- + Lib/distutils/command/upload.py | 3 ++- + Lib/distutils/tests/test_upload.py | 5 +++-- + Lib/hashlib.py | 21 +++++++++++---------- + Lib/hmac.py | 6 +++--- + Lib/test/test_fips.py | 6 +++--- + Lib/test/test_hashlib.py | 16 +++++++++------- + Lib/test/test_hmac.py | 7 ++++--- + Lib/test/test_smtplib.py | 4 +++- + Lib/test/test_tools/test_md5sum.py | 4 ++-- + Lib/test/test_urllib2_localnet.py | 1 + + 10 files changed, 41 insertions(+), 32 deletions(-) + +diff --git a/Lib/distutils/command/upload.py b/Lib/distutils/command/upload.py +index 553617a8d8f..8653caefc91 100644 +--- a/Lib/distutils/command/upload.py ++++ b/Lib/distutils/command/upload.py +@@ -127,7 +127,8 @@ class upload(PyPIRCCommand): + except ValueError as e: + msg = 'calculating md5 checksum failed: %s' % e + self.announce(msg, log.INFO) +- if not hashlib.get_fips_mode(): ++ from _hashlib import get_fips_mode ++ if not get_fips_mode(): + # this really shouldn't fail + raise + else: +diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py +index f720a7905dd..a198b213577 100644 +--- a/Lib/distutils/tests/test_upload.py ++++ b/Lib/distutils/tests/test_upload.py +@@ -4,6 +4,7 @@ import unittest + import unittest.mock as mock + from urllib.request import HTTPError + import hashlib ++from _hashlib import get_fips_mode + + from test.support import run_unittest + +@@ -131,7 +132,7 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + + # what did we send ? + headers = dict(self.last_open.req.headers) +- if hashlib.get_fips_mode(): ++ if get_fips_mode(): + # only sha256 hash is used + self.assertEqual(headers['Content-length'], '2197') + else: +@@ -172,7 +173,7 @@ class uploadTestCase(BasePyPIRCCommandTestCase): + cmd.run() + + headers = dict(self.last_open.req.headers) +- if hashlib.get_fips_mode(): ++ if get_fips_mode(): + # only sha256 hash is used + self.assertEqual(headers['Content-length'], '2207') + else: +diff --git a/Lib/hashlib.py b/Lib/hashlib.py +index 898e6dca565..2fc214e7efe 100644 +--- a/Lib/hashlib.py ++++ b/Lib/hashlib.py +@@ -76,12 +76,12 @@ __block_openssl_constructor = { + } + + try: +- from _hashlib import get_fips_mode ++ from _hashlib import get_fips_mode as _hashlib_get_fips_mode + except ImportError: +- def get_fips_mode(): ++ def _hashlib_get_fips_mode(): + return 0 + +-if not get_fips_mode(): ++if not _hashlib_get_fips_mode(): + __builtin_constructor_cache = {} + + def __get_builtin_constructor(name): +@@ -129,7 +129,7 @@ if not get_fips_mode(): + + + def __get_openssl_constructor(name): +- if not get_fips_mode(): ++ if not _hashlib_get_fips_mode(): + if name in __block_openssl_constructor: + # Prefer our blake2 and sha3 implementation. + return __get_builtin_constructor(name) +@@ -137,7 +137,7 @@ def __get_openssl_constructor(name): + f = getattr(_hashlib, 'openssl_' + name) + # Allow the C module to raise ValueError. The function will be + # defined but the hash not actually available thanks to OpenSSL. +- if not get_fips_mode(): ++ if not _hashlib.get_fips_mode(): + # N.B. In "FIPS mode", there is no fallback. + # If this test fails, we want to export the broken hash + # constructor anyway. +@@ -148,7 +148,7 @@ def __get_openssl_constructor(name): + return __get_builtin_constructor(name) + + +-if not get_fips_mode(): ++if not _hashlib_get_fips_mode(): + def __py_new(name, data=b'', **kwargs): + """new(name, data=b'', **kwargs) - Return a new hashing object using the + named algorithm; optionally initialized with data (which must be +@@ -161,7 +161,7 @@ def __hash_new(name, data=b'', **kwargs): + """new(name, data=b'') - Return a new hashing object using the named algorithm; + optionally initialized with data (which must be a bytes-like object). + """ +- if not get_fips_mode(): ++ if not _hashlib.get_fips_mode(): + if name in __block_openssl_constructor: + # Prefer our blake2 and sha3 implementation + # OpenSSL 1.1.0 comes with a limited implementation of blake2b/s. +@@ -175,7 +175,7 @@ def __hash_new(name, data=b'', **kwargs): + # hash, try using our builtin implementations. + # This allows for SHA224/256 and SHA384/512 support even though + # the OpenSSL library prior to 0.9.8 doesn't provide them. +- if get_fips_mode(): ++ if _hashlib.get_fips_mode(): + raise + return __get_builtin_constructor(name)(data) + +@@ -187,7 +187,7 @@ try: + algorithms_available = algorithms_available.union( + _hashlib.openssl_md_meth_names) + except ImportError: +- if get_fips_mode(): ++ if _hashlib_get_fips_mode(): + raise + new = __py_new + __get_hash = __get_builtin_constructor +@@ -215,5 +215,6 @@ for __func_name in __always_supported: + # Cleanup locals() + del __always_supported, __func_name, __get_hash + del __hash_new, __get_openssl_constructor +-if not get_fips_mode(): ++if not _hashlib.get_fips_mode(): + del __py_new ++del _hashlib_get_fips_mode +diff --git a/Lib/hmac.py b/Lib/hmac.py +index b2bff7d9758..5055027bbbc 100644 +--- a/Lib/hmac.py ++++ b/Lib/hmac.py +@@ -45,7 +45,7 @@ class HMAC: + msg argument. Passing it as a keyword argument is + recommended, though not required for legacy API reasons. + """ +- if _hashlib.get_fips_mode(): ++ if _hashlibopenssl.get_fips_mode(): + raise ValueError( + 'This class is not available in FIPS mode. ' + + 'Use hmac.new().' +@@ -100,7 +100,7 @@ class HMAC: + + def update(self, msg): + """Feed data from msg into this hashing object.""" +- if _hashlib.get_fips_mode(): ++ if _hashlibopenssl.get_fips_mode(): + raise ValueError('hmac.HMAC is not available in FIPS mode') + self.inner.update(msg) + +@@ -168,7 +168,7 @@ class HMAC_openssl(_hmacopenssl.HMAC): + return result + + +-if _hashlib.get_fips_mode(): ++if _hashlibopenssl.get_fips_mode(): + HMAC = HMAC_openssl + + +diff --git a/Lib/test/test_fips.py b/Lib/test/test_fips.py +index 34812e6098a..86e61e29c0b 100644 +--- a/Lib/test/test_fips.py ++++ b/Lib/test/test_fips.py +@@ -6,7 +6,7 @@ import hashlib, _hashlib + + class HashlibFipsTests(unittest.TestCase): + +- @unittest.skipUnless(hashlib.get_fips_mode(), "Test only when FIPS is enabled") ++ @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 + """ +@@ -30,7 +30,7 @@ class HashlibFipsTests(unittest.TestCase): + + self.assertEqual(m, h) + +- @unittest.skipIf(hashlib.get_fips_mode(), "blake2 hashes are not available under FIPS") ++ @unittest.skipIf(_hashlib.get_fips_mode(), "blake2 hashes are not available under FIPS") + def test_blake2_hashes(self): + self.compare_hashes(hashlib.blake2b(b'abc'), _hashlib.openssl_blake2b(b'abc')) + self.compare_hashes(hashlib.blake2s(b'abc'), _hashlib.openssl_blake2s(b'abc')) +@@ -41,7 +41,7 @@ class HashlibFipsTests(unittest.TestCase): + self.compare_hashes(hashlib.sha3_384(b'abc'), _hashlib.openssl_sha3_384(b'abc')) + self.compare_hashes(hashlib.sha3_512(b'abc'), _hashlib.openssl_sha3_512(b'abc')) + +- @unittest.skipIf(hashlib.get_fips_mode(), "shake hashes are not available under FIPS") ++ @unittest.skipIf(_hashlib.get_fips_mode(), "shake hashes are not available under FIPS") + def test_shake_hashes(self): + self.compare_hashes(hashlib.shake_128(b'abc'), _hashlib.openssl_shake_128(b'abc')) + self.compare_hashes(hashlib.shake_256(b'abc'), _hashlib.openssl_shake_256(b'abc')) +diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py +index 1368e917089..a4b78406a5e 100644 +--- a/Lib/test/test_hashlib.py ++++ b/Lib/test/test_hashlib.py +@@ -29,7 +29,9 @@ COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount') + c_hashlib = import_fresh_module('hashlib', fresh=['_hashlib']) + py_hashlib = import_fresh_module('hashlib', blocked=['_hashlib']) + +-if hashlib.get_fips_mode(): ++from _hashlib import get_fips_mode as _get_fips_mode ++ ++if _get_fips_mode(): + FIPS_UNAVAILABLE = {'blake2b', 'blake2s'} + FIPS_DISABLED = {'md5', 'MD5', *FIPS_UNAVAILABLE} + else: +@@ -105,7 +107,7 @@ class HashLibTestCase(unittest.TestCase): + # Issue #14693: fallback modules are always compiled under POSIX + _warn_on_extension_import = os.name == 'posix' or COMPILED_WITH_PYDEBUG + +- if hashlib.get_fips_mode(): ++ if _get_fips_mode(): + shakes = set() + + def _conditional_import_module(self, module_name): +@@ -116,7 +118,7 @@ class HashLibTestCase(unittest.TestCase): + if self._warn_on_extension_import: + warnings.warn('Did a C extension fail to compile? %s' % error) + except ImportError as error: +- if not hashlib.get_fips_mode(): ++ if not _get_fips_mode(): + raise + return None + +@@ -253,12 +255,12 @@ class HashLibTestCase(unittest.TestCase): + def test_new_upper_to_lower(self): + self.assertEqual(hashlib.new("SHA256").name, "sha256") + +- @unittest.skipUnless(hashlib.get_fips_mode(), "Builtin constructor only unavailable in FIPS mode") ++ @unittest.skipUnless(_get_fips_mode(), "Builtin constructor only unavailable in FIPS mode") + def test_get_builtin_constructor_fips(self): + with self.assertRaises(AttributeError): + hashlib.__get_builtin_constructor + +- @unittest.skipIf(hashlib.get_fips_mode(), "No builtin constructors in FIPS mode") ++ @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') +@@ -446,7 +448,7 @@ class HashLibTestCase(unittest.TestCase): + self.assertIn(name.split("_")[0], repr(m)) + + def test_blocksize_name(self): +- if not hashlib.get_fips_mode(): ++ if not _get_fips_mode(): + self.check_blocksize_name('md5', 64, 16) + self.check_blocksize_name('sha1', 64, 20) + self.check_blocksize_name('sha224', 64, 28) +@@ -935,7 +937,7 @@ class HashLibTestCase(unittest.TestCase): + + self.assertEqual(expected_hash, hasher.hexdigest()) + +- @unittest.skipUnless(hashlib.get_fips_mode(), 'Needs FIPS mode.') ++ @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): +diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py +index 0b481ec9c01..cc77928fa30 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 requires_hashdigest + +@@ -288,7 +289,7 @@ class TestVectorsTestCase(unittest.TestCase): + def test_sha512_rfc4231(self): + self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128) + +- @unittest.skipIf(hashlib.get_fips_mode(), 'MockCrazyHash unacceptable in FIPS mode.') ++ @unittest.skipIf(get_fips_mode(), 'MockCrazyHash unacceptable in FIPS mode.') + @requires_hashdigest('sha256') + def test_legacy_block_size_warnings(self): + class MockCrazyHash(object): +@@ -413,7 +414,7 @@ class SanityTestCase(unittest.TestCase): + + class CopyTestCase(unittest.TestCase): + +- @unittest.skipIf(hashlib.get_fips_mode(), "Internal attributes unavailable in FIPS mode") ++ @unittest.skipIf(get_fips_mode(), "Internal attributes unavailable in FIPS mode") + @requires_hashdigest('sha256') + def test_attributes(self): + # Testing if attributes are of same type. +@@ -426,7 +427,7 @@ class CopyTestCase(unittest.TestCase): + self.assertEqual(type(h1.outer), type(h2.outer), + "Types of outer don't match.") + +- @unittest.skipIf(hashlib.get_fips_mode(), "Internal attributes unavailable in FIPS mode") ++ @unittest.skipIf(get_fips_mode(), "Internal attributes unavailable in FIPS mode") + @requires_hashdigest('sha256') + def test_realcopy(self): + # Testing if the copy method created a real copy. +diff --git a/Lib/test/test_smtplib.py b/Lib/test/test_smtplib.py +index d0c9862edea..9a44c0dc7af 100644 +--- a/Lib/test/test_smtplib.py ++++ b/Lib/test/test_smtplib.py +@@ -17,6 +17,8 @@ import select + import errno + import textwrap + import threading ++import hashlib ++from _hashlib import get_fips_mode + + import unittest + from test import support, mock_socket +@@ -1021,7 +1023,7 @@ class SMTPSimTests(unittest.TestCase): + + def testAUTH_multiple(self): + # Test that multiple authentication methods are tried. +- self.serv.add_feature("AUTH BOGUS PLAIN LOGIN CRAM-MD5") ++ self.serv.add_feature("AUTH BOGUS PLAIN LOGIN") + smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost', timeout=15) + resp = smtp.login(sim_auth[0], sim_auth[1]) + self.assertEqual(resp, (235, b'Authentication Succeeded')) +diff --git a/Lib/test/test_tools/test_md5sum.py b/Lib/test/test_tools/test_md5sum.py +index 7028a4dc214..3ba1ca0f146 100644 +--- a/Lib/test/test_tools/test_md5sum.py ++++ b/Lib/test/test_tools/test_md5sum.py +@@ -4,13 +4,13 @@ import os + import unittest + from test import support + from test.support.script_helper import assert_python_ok, assert_python_failure +-import hashlib ++import _hashlib + + from test.test_tools import scriptsdir, skip_if_missing + + skip_if_missing() + +-if hashlib.get_fips_mode(): ++if _hashlib.get_fips_mode(): + raise unittest.SkipTest("md5sum won't work at all in FIPS mode") + + class MD5SumTests(unittest.TestCase): +diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py +index 1cb358f8ddc..6f5cb7fcd17 100644 +--- a/Lib/test/test_urllib2_localnet.py ++++ b/Lib/test/test_urllib2_localnet.py +@@ -7,6 +7,7 @@ import http.server + import threading + import unittest + import hashlib ++from _hashlib import get_fips_mode + + from test import support + +-- +2.21.1 + + +From a8f87fa94aae8f8ed05607974e2bd30c54d3f3ce Mon Sep 17 00:00:00 2001 +From: Christian Heimes +Date: Wed, 20 Nov 2019 10:59:25 +0100 +Subject: [PATCH 31/32] Use FIPS compliant CSPRNG + +Kernel's getrandom() source is not yet FIPS compliant. Use OpenSSL's +DRBG in FIPS mode and disable os.getrandom() function. + +Signed-off-by: Christian Heimes +--- + Lib/test/test_os.py | 5 +++ + Makefile.pre.in | 2 +- + Modules/posixmodule.c | 8 +++++ + Python/bootstrap_hash.c | 75 +++++++++++++++++++++++++++++++++++++++++ + 4 files changed, 89 insertions(+), 1 deletion(-) + +diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py +index 4a076e3bbf5..f60ad6ddbd7 100644 +--- a/Lib/test/test_os.py ++++ b/Lib/test/test_os.py +@@ -1546,6 +1546,11 @@ class GetRandomTests(unittest.TestCase): + raise unittest.SkipTest("getrandom() syscall fails with ENOSYS") + else: + raise ++ except ValueError as exc: ++ if exc.args[0] == "getrandom is not FIPS compliant": ++ raise unittest.SkipTest("Skip in FIPS mode") ++ else: ++ raise + + def test_getrandom_type(self): + data = os.getrandom(16) +diff --git a/Makefile.pre.in b/Makefile.pre.in +index 502317aa0c7..924367d2ada 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -116,7 +116,7 @@ PY_STDMODULE_CFLAGS= $(PY_CFLAGS) $(PY_CFLAGS_NODIST) $(PY_CPPFLAGS) $(CFLAGSFOR + PY_BUILTIN_MODULE_CFLAGS= $(PY_STDMODULE_CFLAGS) -DPy_BUILD_CORE_BUILTIN + PY_CORE_CFLAGS= $(PY_STDMODULE_CFLAGS) -DPy_BUILD_CORE + # Linker flags used for building the interpreter object files +-PY_CORE_LDFLAGS=$(PY_LDFLAGS) $(PY_LDFLAGS_NODIST) ++PY_CORE_LDFLAGS=$(PY_LDFLAGS) $(PY_LDFLAGS_NODIST) -lcrypto + # Strict or non-strict aliasing flags used to compile dtoa.c, see above + CFLAGS_ALIASING=@CFLAGS_ALIASING@ + +diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c +index b09204d6339..99d1dca1180 100644 +--- a/Modules/posixmodule.c ++++ b/Modules/posixmodule.c +@@ -388,6 +388,9 @@ extern char *ctermid_r(char *); + #define MODNAME "posix" + #endif + ++/* for FIPS check in os.getrandom() */ ++#include ++ + #if defined(__sun) + /* Something to implement in autoconf, not present in autoconf 2.69 */ + #define HAVE_STRUCT_STAT_ST_FSTYPE 1 +@@ -13388,6 +13391,11 @@ os_getrandom_impl(PyObject *module, Py_ssize_t size, int flags) + return posix_error(); + } + ++ if (FIPS_mode()) { ++ PyErr_SetString(PyExc_ValueError, "getrandom is not FIPS compliant"); ++ return NULL; ++ } ++ + bytes = PyBytes_FromStringAndSize(NULL, size); + if (bytes == NULL) { + PyErr_NoMemory(); +diff --git a/Python/bootstrap_hash.c b/Python/bootstrap_hash.c +index 43f5264d862..67166475a75 100644 +--- a/Python/bootstrap_hash.c ++++ b/Python/bootstrap_hash.c +@@ -409,6 +409,77 @@ dev_urandom_close(void) + } + #endif /* !MS_WINDOWS */ + ++#include ++#include ++#include ++ ++#if (OPENSSL_VERSION_NUMBER < 0x10101000L) || defined(LIBRESSL_VERSION_NUMBER) ++# error "py_openssl_drbg_urandom requires OpenSSL 1.1.1 for fork safety" ++#endif ++ ++static void ++py_openssl_set_exception(PyObject* exc) { ++ unsigned long errcode; ++ const char *lib, *func, *reason; ++ ++ errcode = ERR_peek_last_error(); ++ if (!errcode) { ++ PyErr_SetString(exc, "unknown reasons"); ++ } ++ ERR_clear_error(); ++ ++ lib = ERR_lib_error_string(errcode); ++ func = ERR_func_error_string(errcode); ++ reason = ERR_reason_error_string(errcode); ++ ++ if (lib && func) { ++ PyErr_Format(exc, "[%s: %s] %s", lib, func, reason); ++ } ++ else if (lib) { ++ PyErr_Format(exc, "[%s] %s", lib, reason); ++ } ++ else { ++ PyErr_SetString(exc, reason); ++ } ++} ++ ++static int ++py_openssl_drbg_urandom(char *buffer, Py_ssize_t size, int raise) ++{ ++ int res; ++ static int init = 0; ++ ++ if (!init) { ++ init = 1; ++ res = OPENSSL_init_crypto(OPENSSL_INIT_ATFORK, NULL); ++ if (res == 0) { ++ if (raise) { ++ py_openssl_set_exception(PyExc_RuntimeError); ++ } ++ return 0; ++ } ++ } ++ ++ if (size > INT_MAX) { ++ if (raise) { ++ PyErr_Format(PyExc_OverflowError, ++ "RAND_bytes() size is limited to 2GB."); ++ } ++ return -1; ++ } ++ ++ res = RAND_bytes((unsigned char*)buffer, (int)size); ++ ++ if (res == 1) { ++ return 1; ++ } else { ++ if (raise) { ++ py_openssl_set_exception(PyExc_RuntimeError); ++ } ++ return 0; ++ } ++} ++ + + /* Fill buffer with pseudo-random bytes generated by a linear congruent + generator (LCG): +@@ -493,6 +564,10 @@ pyurandom(void *buffer, Py_ssize_t size, int blocking, int raise) + return 0; + } + ++ if (FIPS_mode()) { ++ return py_openssl_drbg_urandom(buffer, size, raise); ++ } ++ + #ifdef MS_WINDOWS + return win32_urandom((unsigned char *)buffer, size, raise); + #else +-- +2.21.1 + + +From 5539f0001fb2785c2d2feea97fc2a910ca954f92 Mon Sep 17 00:00:00 2001 +From: Charalampos Stratakis +Date: Thu, 28 Nov 2019 17:26:02 +0100 +Subject: [PATCH 32/32] Fixups for FIPS compliant CSPRNG + +--- + Lib/test/test_os.py | 3 ++- + Python/bootstrap_hash.c | 33 +++------------------------------ + 2 files changed, 5 insertions(+), 31 deletions(-) + +diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py +index f60ad6ddbd7..be057ad3a35 100644 +--- a/Lib/test/test_os.py ++++ b/Lib/test/test_os.py +@@ -28,6 +28,7 @@ import time + import unittest + import uuid + import warnings ++from _hashlib import get_fips_mode + from test import support + from platform import win32_is_iot + +@@ -1547,7 +1548,7 @@ class GetRandomTests(unittest.TestCase): + else: + raise + except ValueError as exc: +- if exc.args[0] == "getrandom is not FIPS compliant": ++ if get_fips_mode() and exc.args[0] == "getrandom is not FIPS compliant": + raise unittest.SkipTest("Skip in FIPS mode") + else: + raise +diff --git a/Python/bootstrap_hash.c b/Python/bootstrap_hash.c +index 67166475a75..7466d5fb5cf 100644 +--- a/Python/bootstrap_hash.c ++++ b/Python/bootstrap_hash.c +@@ -409,40 +409,13 @@ dev_urandom_close(void) + } + #endif /* !MS_WINDOWS */ + +-#include +-#include + #include ++#include <_hashopenssl.h> + + #if (OPENSSL_VERSION_NUMBER < 0x10101000L) || defined(LIBRESSL_VERSION_NUMBER) + # error "py_openssl_drbg_urandom requires OpenSSL 1.1.1 for fork safety" + #endif + +-static void +-py_openssl_set_exception(PyObject* exc) { +- unsigned long errcode; +- const char *lib, *func, *reason; +- +- errcode = ERR_peek_last_error(); +- if (!errcode) { +- PyErr_SetString(exc, "unknown reasons"); +- } +- ERR_clear_error(); +- +- lib = ERR_lib_error_string(errcode); +- func = ERR_func_error_string(errcode); +- reason = ERR_reason_error_string(errcode); +- +- if (lib && func) { +- PyErr_Format(exc, "[%s: %s] %s", lib, func, reason); +- } +- else if (lib) { +- PyErr_Format(exc, "[%s] %s", lib, reason); +- } +- else { +- PyErr_SetString(exc, reason); +- } +-} +- + static int + py_openssl_drbg_urandom(char *buffer, Py_ssize_t size, int raise) + { +@@ -454,7 +427,7 @@ py_openssl_drbg_urandom(char *buffer, Py_ssize_t size, int raise) + res = OPENSSL_init_crypto(OPENSSL_INIT_ATFORK, NULL); + if (res == 0) { + if (raise) { +- py_openssl_set_exception(PyExc_RuntimeError); ++ _setException(PyExc_RuntimeError); + } + return 0; + } +@@ -474,7 +447,7 @@ py_openssl_drbg_urandom(char *buffer, Py_ssize_t size, int raise) + return 1; + } else { + if (raise) { +- py_openssl_set_exception(PyExc_RuntimeError); ++ _setException(PyExc_RuntimeError); + } + return 0; + } +-- +2.21.1 + diff --git a/SOURCES/00337-test_ssl-test_min_max_version-add-range.patch b/SOURCES/00337-test_ssl-test_min_max_version-add-range.patch new file mode 100644 index 0000000..df60a01 --- /dev/null +++ b/SOURCES/00337-test_ssl-test_min_max_version-add-range.patch @@ -0,0 +1,38 @@ +From 4e4445efad2d3aa17b455a2683884e500d1a7c90 Mon Sep 17 00:00:00 2001 +From: Tomas Orsava +Date: Fri, 29 Nov 2019 16:07:27 +0100 +Subject: [PATCH] Adjust the test_min_max_version in test_ssl + +to accept the new settings in RHEL 8.2 where maximum_version is set to TLS 1.3. +--- + Lib/test/test_ssl.py | 10 ++++++++-- + 1 file changed, 8 insertions(+), 2 deletions(-) + +diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py +index 419506f..c9b2cf9 100644 +--- a/Lib/test/test_ssl.py ++++ b/Lib/test/test_ssl.py +@@ -1200,12 +1200,18 @@ class ContextTests(unittest.TestCase): + # RHEL 8 uses TLS 1.2 by default + ssl.TLSVersion.TLSv1_2 + } ++ maximum_range = { ++ # stock OpenSSL ++ ssl.TLSVersion.MAXIMUM_SUPPORTED, ++ # RHEL 8.2 requires maximum TLS 1.3 ++ ssl.TLSVersion.TLSv1_3 ++ } + + self.assertIn( + ctx.minimum_version, minimum_range + ) +- self.assertEqual( +- ctx.maximum_version, ssl.TLSVersion.MAXIMUM_SUPPORTED ++ self.assertIn( ++ ctx.maximum_version, maximum_range + ) + + ctx.minimum_version = ssl.TLSVersion.TLSv1_1 +-- +2.20.1 + diff --git a/SOURCES/Python-3.8.0.tar.xz.asc b/SOURCES/Python-3.8.0.tar.xz.asc new file mode 100644 index 0000000..942a421 --- /dev/null +++ b/SOURCES/Python-3.8.0.tar.xz.asc @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCgAdFiEE4/8oOcBIslwITevpsmmV4xAlBWgFAl2kmqsACgkQsmmV4xAl +BWgUvRAAjomYhRM5CBKP99ygaTKAqeTHVnJt32O8n3OHPWL6YSSm2GBSnX4fhtqn +uX9VysXFc90zEX+ww2+n2+IwDzsddItWtdZfNnVAUeBs8GNGpq5KbnGX7LB7+orp +nJPcDUMsF2Mutuk7fREr8KHFUGSyMkUj+bh/1Ml+R7LGoTtPKywqtu7X0ACoJ3N0 +hds0qd79o8u5i2N5rLWfuj6/1HmorNwNhtJo7vIACZIUyIKP3rB8WXtE8+drptuv +ApYJdxE74iixntMuk6sCwPKBquIzwfEI3NzcmtJCV32cpASHB3+8FHJIlp94++9y +AUF4Kxp3aQui1XaeeLRdIpprl6M+PwB6tTQKoSkkecTVysj5GOdBRFEhGl5bFNO9 +DSiHU7uy8JkeOZVdcz4zIdZnlUUtCq4Ycpc8PXKjI0kbHlsp38y7F8lFNP10UY/D +iKDDGxQowCtVgKCORNhmKWCmEZcgbDZA9EAz9rgCdhPY7we3Qdj68L820ELxJeQj +50ss/6GcIJK1jgOSXng7DvUhlpsp5avhaM3iWnqCtU+a2fOVm0pQR826q62majLR +uui7SDKtVPU7VaLetfppuNjI3T8xUX86niSRtmlYjsjweJ+jXJWTnkkHUNI04UjH +2WANZRJ10NXl7UVRlnGYVzAcslyabnnlRw6Zf1haWtAWTLyP7Tw= +=bg98 +-----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/macros.python38 b/SOURCES/macros.python38 new file mode 100644 index 0000000..0086d90 --- /dev/null +++ b/SOURCES/macros.python38 @@ -0,0 +1,6 @@ +%__python3 /usr/bin/python3.8 +%python3_pkgversion 38 + +%py3_install_wheel() %{expand:\\\ + CFLAGS="%{optflags}" %{__python3} -m pip install -I dist/%{1} --root %{buildroot} --no-deps +} 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/python38.spec b/SPECS/python38.spec new file mode 100644 index 0000000..6a1326d --- /dev/null +++ b/SPECS/python38.spec @@ -0,0 +1,3018 @@ +# ================== +# Top-level metadata +# ================== + +%global pybasever 3.8 + +# pybasever without the dot: +%global pyshortver 38 + +Name: python38 +Summary: Interpreter of the Python programming language +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}.0 +#global prerel ... +%global upstream_version %{general_version}%{?prerel} +Version: %{general_version}%{?prerel:~%{prerel}} +Release: 6%{?dist} +License: Python + +# Exclude i686 arch. Due to a modularity issue it's being added to the +# x86_64 compose of CRB, but we don't want to ship it at all. +# See: https://projects.engineering.redhat.com/browse/RCM-72605 +ExcludeArch: i686 + +# ================================== +# 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" + + +# Flat package, i.e. python36, python37, python38 for tox etc. +# WARNING: This also influences the main_python bcond below. +# in Fedora, never turn this on for the python3 package +# and always keep it on for python37 etc. +# WARNING: This does not change the package name and summary above. +%bcond_with flatpackage + +# Main Python, i.e. whether this is the main Python version in the distribution +# that owns /usr/bin/python3 and other unique paths +%bcond_with main_python + +# 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. +# +# 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 + +# 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 + + +# ===================== +# General global macros +# ===================== + +# Set python3_pkgversion so that python_provide macro works for python38- +# prefixes in this spec file +# This is also set in the python38-rpm-macros package so that it works in other +# packages of this module. +%global python3_pkgversion 38 + +%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} + +%global SOABI_optimized cpython-%{pyshortver}%{ABIFLAGS_optimized}-%{_arch}-linux%{_gnu} +%global SOABI_debug cpython-%{pyshortver}%{ABIFLAGS_debug}-%{_arch}-linux%{_gnu} + +# 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 + +# 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 + +# For multilib support, files that are different between 32- and 64-bit arches +# need different filenames. Use "64" or "32" according to the word size. +# Currently, the best way to determine an architecture's word size happens to +# be checking %%{_lib}. +%if "%{_lib}" == "lib64" +%global wordsize 64 +%else +%global wordsize 32 +%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: glibc-all-langpacks +BuildRequires: glibc-devel +BuildRequires: gmp-devel +BuildRequires: libappstream-glib +BuildRequires: libffi-devel +BuildRequires: libnsl2-devel +BuildRequires: libtirpc-devel +BuildRequires: libGL-devel +BuildRequires: libuuid-devel +BuildRequires: libX11-devel +BuildRequires: ncurses-devel + +BuildRequires: openssl-devel +BuildRequires: pkgconfig +BuildRequires: readline-devel +BuildRequires: redhat-rpm-config +BuildRequires: sqlite-devel +BuildRequires: gdb + +BuildRequires: tar +BuildRequires: tcl-devel +BuildRequires: tix-devel +BuildRequires: tk-devel + +%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 + +# For %%python_provide +BuildRequires: python-rpm-macros + +%if %{with rpmwheels} +BuildRequires: python38-setuptools-wheel +BuildRequires: python38-pip-wheel +%endif + +%if %{without bootstrap} +# for make regen-all and distutils.tests.test_bdist_rpm +BuildRequires: python%{pyshortver} +%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 +Source3: macros.python38 + +# 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 + +# 00001 # +# Fixup distutils/unixccompiler.py to remove standard library path from rpath: +# Was Patch0 in ivazquez' python3000 specfile: +Patch1: 00001-rpath.patch + +# 00102 # +# Change the various install paths to use /usr/lib64/ instead or /usr/lib +# Only used when "%%{_lib}" == "lib64" +# Not yet sent upstream. +Patch102: 00102-lib64.patch + +# 00111 # +# Patch the Makefile.pre.in so that the generated Makefile doesn't try to build +# a libpythonMAJOR.MINOR.a +# See https://bugzilla.redhat.com/show_bug.cgi?id=556092 +# Downstream only: not appropriate for upstream +Patch111: 00111-no-static-lib.patch + +# 00189 # +# Instead of bundled wheels, use our RPM packaged wheels from +# /usr/share/python38-wheels +Patch189: 00189-use-rpm-wheels.patch + +# 00251 +# 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 +Patch251: 00251-change-user-install-location.patch + +# 00274 # +# Upstream uses Debian-style architecture naming. Change to match Fedora. +Patch274: 00274-fix-arch-names.patch + +# 00328 # +# Restore pyc to TIMESTAMP invalidation mode as default in rpmbubild +# See https://src.fedoraproject.org/rpms/redhat-rpm-config/pull-request/57#comment-27426 +Patch328: 00328-pyc-timestamp-invalidation-mode.patch + +# 00329 # +# Support OpenSSL FIPS mode +# - Fallback implementations md5, sha1, sha256, sha512 are removed in favor of OpenSSL wrappers +# - In FIPS mode, OpenSSL wrappers are always used in hashlib +# - add a new "usedforsecurity" keyword argument to the various digest +# algorithms in hashlib so that you can whitelist a callsite with +# "usedforsecurity=False" +# The change has been implemented upstream since Python 3.9: +# https://bugs.python.org/issue9216 +# - OpenSSL wrappers for the hashes blake2{b512,s256}, +# sha3_{224,256,384,512}, shake_{128,256} are now exported from _hashlib +# - In FIPS mode, the blake2, sha3 and shake 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 an string with OpenSSL hash name as the "digestmod" argument. +# The argument must be specified (instead of defaulting to ‘md5’). +# +# - Also while in FIPS mode, we utilize OpenSSL's DRBG and disable the +# os.getrandom() function. +# +# Resolves: rhbz#1731424 +Patch329: 00329-fips.patch + +# 00337 # +# Adjust the test_min_max_version in test_ssl to accept the new settings in +# RHEL 8.2 where maximum_version is set to TLS 1.3 +Patch337: 00337-test_ssl-test_min_max_version-add-range.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 +# ========================================== + +# People might want to dnf install pythonX.Y instead of pythonXY; +# we enable this in both flat and nonflat package. +Provides: python%{pybasever} = %{version}-%{release} + +# When the user tries to `yum install python`, yum will list this package among +# the possible alternatives +Provides: alternative-for(python) + +# Runtime require alternatives +Requires: %{_sbindir}/alternatives +Requires(post): %{_sbindir}/alternatives +Requires(postun): %{_sbindir}/alternatives + +%if %{without flatpackage} + +# Packages with Python modules in standard locations automatically +# depend on python(abi). Provide that here. +Provides: python(abi) = %{pybasever} + +Requires: %{name}-libs%{?_isa} = %{version}-%{release} + +# In order to support multiple Python interpreters for development purposes, +# packages with the naming scheme flatpackage (e.g. python35) exist for +# non-default versions of Python 3. +# For consistency, and to keep the upgrade path clean, we Provide/Obsolete +# these names here. +Provides: python%{pyshortver} = %{version}-%{release} + +%if %{with main_python} +# 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 + +# 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. + +# Previously, this was required for our rewheel patch to work. +# This is technically no longer needed, but we keep it recommended +# for the developer experience. +Recommends: python38-setuptools +Recommends: python38-pip + +# This prevents ALL subpackages built from this spec to require +# /usr/bin/python3*. 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 +# All others require %%{name} anyway. +%global __requires_exclude ^/usr/bin/python3 + + +# The description used both for the SRPM and the main `python3` subpackage: +%description +Python 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 %{name} package provides the "python3" executable: the reference +interpreter for the Python language, version 3. +The majority of its standard library is provided in the %{name}-libs package, +which should be installed automatically along with %{name}. +The remaining parts of the Python standard library are broken out into the +%{name}-tkinter and %{name}-test packages, which may need to be installed +separately. + +Documentation for Python is provided in the %{name}-docs package. + +Packages containing additional libraries for Python are generally named with +the "%{name}-" prefix. + +For the unversioned "python" executable, see manual page "unversioned-python". + + +%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 libs +Summary: Python runtime libraries + +%if %{with rpmwheels} +Requires: python38-setuptools-wheel +Requires: python38-pip-wheel +%else +Provides: bundled(python38-pip) = 19.2.3 +Provides: bundled(python38-setuptools) = 41.2.0 +%endif + +%{?python_provide:%python_provide python38-libs} + +# 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: %{name}%{?_isa} = %{version}-%{release} + + +%description 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 "python3" executable + + +%package devel +Summary: Libraries and header files needed for Python development +Requires: %{name} = %{version}-%{release} +Requires: %{name}-libs%{?_isa} = %{version}-%{release} +BuildRequires: python-rpm-macros +# 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) +# python38 installs the alternatives master symlink to which we attach a slave +Requires(post): python38 +Requires(postun): python38 + +%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: (python38-setuptools if rpm-build) +%endif + +Requires: (python3-rpm-generators if rpm-build) + +%{?python_provide:%python_provide python38-devel} + +%description 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. + +If you want to build an RPM against the python38 module, you also need to +install the python38-rpm-macros package. + + +%package idle +Summary: A basic graphical development environment for Python +Requires: %{name} = %{version}-%{release} +Requires: %{name}-tkinter = %{version}-%{release} + +%{?python_provide:%python_provide python38-idle} + +# python38 installs the alternatives master symlink to which we attach a slave +Requires(post): python38 +Requires(postun): python38 + +%description 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 tkinter +Summary: A GUI toolkit for Python +Requires: %{name} = %{version}-%{release} + +%{?python_provide:%python_provide python38-tkinter} + +%description tkinter +The Tkinter (Tk interface) library is a graphical user interface toolkit for +the Python programming language. + + +%package test +Summary: The self-test suite for the main python3 package +Requires: %{name} = %{version}-%{release} +Requires: %{name}-libs%{?_isa} = %{version}-%{release} + +%{?python_provide:%python_provide python38-test} + +%description 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 %{name}-libs, or a library such as +%{name}-pytest or %{name}-nose. + + +%if %{with debug_build} +%package 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: %{name}%{?_isa} = %{version}-%{release} +Requires: %{name}-libs%{?_isa} = %{version}-%{release} +Requires: %{name}-devel%{?_isa} = %{version}-%{release} +Requires: %{name}-test%{?_isa} = %{version}-%{release} +Requires: %{name}-tkinter%{?_isa} = %{version}-%{release} +Requires: %{name}-idle%{?_isa} = %{version}-%{release} +# python38 installs the alternatives master symlink to which we attach a slave +Requires(post): python38 +Requires(postun): python38 + +%{?python_provide:%python_provide python38-debug} + +%description debug +python38-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\\..$ + +%if %{with rpmwheels} +Requires: python38-setuptools-wheel +Requires: python38-pip-wheel +%else +Provides: bundled(python38-pip) = 19.2.3 +Provides: bundled(python38-setuptools) = 41.2.0 +%endif + +# The description for the flat package +%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 + + +%package -n python38-rpm-macros +Summary: RPM macros for building RPMs with Python 3.8 +Provides: python38-modular-devel = %{version}-%{release} +Provides: python-modular-rpm-macros == 3.8 +Conflicts: python-modular-rpm-macros > 3.8 +Requires: python3-rpm-macros +BuildArch: noarch + +%description -n python38-rpm-macros +RPM macros for building RPMs with Python 3.8 from the python38 module. +If you want to build an RPM against the python38 module, you need to +BuildRequire: python38-rpm-macros. + + +# ====================================================== +# The prep phase of the build: +# ====================================================== + +%prep +%setup -q -n Python-%{upstream_version} +# 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 + +# +# Apply patches: +# +%patch1 -p1 + +%if "%{_lib}" == "lib64" +%patch102 -p1 +%endif +%patch111 -p1 + +%if %{with rpmwheels} +%patch189 -p1 +rm Lib/ensurepip/_bundled/*.whl +%endif + +%patch251 -p1 +%patch274 -p1 +%patch328 -p1 +%patch329 -p1 +%patch337 -p1 + + +# 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 + + +# ====================================================== +# Configuring and building the code: +# ====================================================== + +%build + +# 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 -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} -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 + +%configure \ + --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 \ +%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} +BuildPython debug \ + "--without-ensurepip --with-pydebug" \ + "-Og" +%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-%{wordsize}.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 \ + DESTDIR=%{buildroot} \ + INSTALL="install -p" \ + EXTRA_CFLAGS="$MoreCFlags" \ + install + + 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 `dirname $0`/python'${LDVersion}'-`uname -m`-config "$@"' > \ + %{buildroot}%{_bindir}/python${LDVersion}-config + echo '[ $? -eq 127 ] && echo "Could not find python'${LDVersion}'-`uname -m`-config. Look around to see available arches." >&2' >> \ + %{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 +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 +ln -s pathfix%{pybasever}.py %{buildroot}%{_bindir}/pathfix.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 tests for python3-tools which was removed in +# https://bugzilla.redhat.com/show_bug.cgi?id=1312030 +rm -rf %{buildroot}%{pylibdir}/test/test_tools + +# 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 +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} -O -c 'import py_compile, sys; [py_compile.compile(f, dfile=f.partition("%{buildroot}")[2], optimize=opt) for opt in range(3) for f in sys.argv[1:]]' || : + +# 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 + +%if %{without main_python} +# Remove stuff that would conflict with python3 package +rm %{buildroot}%{_bindir}/python3 +rm %{buildroot}%{_bindir}/pydoc3 +rm %{buildroot}%{_bindir}/pathfix.py +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 # main_python +# 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 +%if %{with debug_build} +ln -s ./python3-debug %{buildroot}%{_bindir}/python-debug +%endif +%endif # main_python + + +# Python RPM macros +mkdir -p %{buildroot}/%{rpmmacrodir}/ +install -m 644 %{SOURCE3} \ + %{buildroot}/%{rpmmacrodir}/ + +# All ghost files controlled by alternatives need to exist for the files +# section check to succeed +# - Don't list /usr/bin/python as a ghost file so `yum install /usr/bin/python` +# doesn't install this package +touch %{buildroot}%{_bindir}/unversioned-python +touch %{buildroot}%{_mandir}/man1/python.1.gz +touch %{buildroot}%{_bindir}/python3 +touch %{buildroot}%{_mandir}/man1/python3.1.gz +touch %{buildroot}%{_bindir}/pydoc3 +touch %{buildroot}%{_bindir}/pydoc-3 +touch %{buildroot}%{_bindir}/idle3 +touch %{buildroot}%{_bindir}/python3-config +touch %{buildroot}%{_bindir}/python3-debug +touch %{buildroot}%{_bindir}/python3-debug-config + + +# ====================================================== +# 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 + + +# ====================================================== +# 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 + # test_gdb skipped on s390x: + # https://bugzilla.redhat.com/show_bug.cgi?id=1678277 + # test_gdb skipped everywhere: + # https://bugzilla.redhat.com/show_bug.cgi?id=1734327 + # 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 \ + %if %{with bootstrap} + -x test_distutils \ + %endif + -x test_gdb \ + %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 + + +%post +# Alternative for /usr/bin/python -> /usr/bin/python3 + man page +alternatives --install %{_bindir}/unversioned-python \ + python \ + %{_bindir}/python3 \ + 300 \ + --slave %{_bindir}/python \ + unversioned-python \ + %{_bindir}/python3 \ + --slave %{_mandir}/man1/python.1.gz \ + unversioned-python-man \ + %{_mandir}/man1/python3.1.gz + +# Alternative for /usr/bin/python -> /usr/bin/python3.8 + man page +alternatives --install %{_bindir}/unversioned-python \ + python \ + %{_bindir}/python3.8 \ + 208 \ + --slave %{_bindir}/python \ + unversioned-python \ + %{_bindir}/python3.8 \ + --slave %{_mandir}/man1/python.1.gz \ + unversioned-python-man \ + %{_mandir}/man1/python3.8.1.gz + +# Alternative for /usr/bin/python3 -> /usr/bin/python3.8 + related files +# Create only if it doesn't exist already +EXISTS=`alternatives --display python3 | \ + grep -c "^/usr/bin/python3.8 - priority [0-9]*"` + +if [ $EXISTS -eq 0 ]; then + alternatives --install %{_bindir}/python3 \ + python3 \ + %{_bindir}/python3.8 \ + 3800 \ + --slave %{_mandir}/man1/python3.1.gz \ + python3-man \ + %{_mandir}/man1/python3.8.1.gz \ + --slave %{_bindir}/pydoc3 \ + pydoc3 \ + %{_bindir}/pydoc3.8 \ + --slave %{_bindir}/pydoc-3 \ + pydoc-3 \ + %{_bindir}/pydoc3.8 +fi + +%postun +# Do this only during uninstall process (not during update) +if [ $1 -eq 0 ]; then + alternatives --remove python \ + %{_bindir}/python3.8 + + alternatives --remove python3 \ + %{_bindir}/python3.8 + + # Remove link python → python3 if no other python3.* exists + if ! alternatives --display python3 > /dev/null; then + alternatives --remove python \ + %{_bindir}/python3 + fi +fi + + +%post devel +alternatives --add-slave python3 %{_bindir}/python3.8 \ + %{_bindir}/python3-config \ + python3-config \ + %{_bindir}/python3.8-config + +%postun devel +# Do this only during uninstall process (not during update) +if [ $1 -eq 0 ]; then + alternatives --remove-slave python3 %{_bindir}/python3.8 \ + python3-config +fi + + +%post debug +alternatives --add-slave python3 %{_bindir}/python3.8 \ + %{_bindir}/python3-debug \ + python3-debug \ + %{_bindir}/python3.8d +alternatives --add-slave python3 %{_bindir}/python3.8 \ + %{_bindir}/python3-debug-config \ + python3-debug-config \ + %{_bindir}/python3.8d-config + +%postun debug +# Do this only during uninstall process (not during update) +if [ $1 -eq 0 ]; then + alternatives --remove-slave python3 %{_bindir}/python3.8 \ + python3-debug + alternatives --remove-slave python3 %{_bindir}/python3.8 \ + python3-debug-config +fi + + +%post idle +alternatives --add-slave python3 %{_bindir}/python3.8 \ + %{_bindir}/idle3 \ + idle3 \ + %{_bindir}/idle3.8 + +%postun idle +# Do this only during uninstall process (not during update) +if [ $1 -eq 0 ]; then + alternatives --remove-slave python3 %{_bindir}/python3.8 \ + idle3 +fi + + +%files -n python38-rpm-macros +%license LICENSE +%doc README.rst +%{rpmmacrodir}/macros.python38 + +%files +%doc README.rst + +# Alternatives +%ghost %{_bindir}/unversioned-python +%ghost %{_mandir}/man1/python.1.gz +%ghost %{_bindir}/python3 +%ghost %{_mandir}/man1/python3.1.gz +%ghost %{_bindir}/pydoc3 +%ghost %{_bindir}/pydoc-3 + + +%if %{with main_python} +%{_bindir}/pydoc* +%{_bindir}/python3 +%else +%{_bindir}/pydoc%{pybasever} +%endif + +%{_bindir}/python%{pybasever} +%{_bindir}/python%{LDVERSION_optimized} +%{_mandir}/*/*3* + + +%if %{with main_python} +%if %{without flatpackage} +%files -n python-unversioned-command +%endif +%{_bindir}/python +%{_mandir}/*/python.1* +%endif + +%if %{without flatpackage} +%files 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 +%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}/_sha3.%{SOABI_optimized}.so +%{dynload_dir}/_hmacopenssl.%{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 +%{dynload_dir}/nis.%{SOABI_optimized}.so +%{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 + +%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 + +%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}-%{_arch}-linux%{_gnu}/ +%{pylibdir}/config-%{LDVERSION_optimized}-%{_arch}-linux%{_gnu}/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 devel +%endif + +%if %{with main_python} +%{_bindir}/2to3 +%endif + +%{pylibdir}/config-%{LDVERSION_optimized}-%{_arch}-linux%{_gnu}/* +%if %{without flatpackage} +%exclude %{pylibdir}/config-%{LDVERSION_optimized}-%{_arch}-linux%{_gnu}/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}/2to3-%{pybasever} +%{_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 +# Alternatives +%ghost %{_bindir}/python3-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 %{without flatpackage} +%files idle +%endif + +%if %{with main_python} +%{_bindir}/idle* +%else +%{_bindir}/idle%{pybasever} +# Alternatives +%ghost %{_bindir}/idle3 +%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 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 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 debug +%endif + +%if %{with main_python} +%{_bindir}/python3-debug +%{_bindir}/python-debug +%endif + +# Analog of the core subpackage's files: +%{_bindir}/python%{LDVERSION_debug} +# Alternatives +%ghost %{_bindir}/python3-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}/_sha3.%{SOABI_debug}.so +%{dynload_dir}/_hmacopenssl.%{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 +%{dynload_dir}/nis.%{SOABI_debug}.so +%{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 + +# 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}-%{_arch}-linux%{_gnu} +%{_includedir}/python%{LDVERSION_debug} +%{_bindir}/python%{LDVERSION_debug}-config +%{_bindir}/python%{LDVERSION_debug}-*-config +%ghost %{_bindir}/python3-debug-config + +%{_libdir}/libpython%{LDVERSION_debug}.so +%{_libdir}/libpython%{LDVERSION_debug}.so.1.0 +%{_libdir}/pkgconfig/python-%{LDVERSION_debug}.pc +%{_libdir}/pkgconfig/python-%{LDVERSION_debug}-embed.pc + +# 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 +* Mon Feb 24 2020 Tomas Orsava - 3.8.0-6 +- Implement alternatives for /usr/bin/python, python3 and related executables +- Resolves: rhbz#1807041 + +* Fri Jan 10 2020 Charalampos Stratakis - 3.8.0-5 +- Add support for FIPS mode +- Resolves: rhbz#1793589 + +* Thu Dec 12 2019 Tomas Orsava - 3.8.0-4 +- Exclude unsupported i686 arch + +* Mon Nov 25 2019 Tomas Orsava - 3.8.0-3 +- Build Python with -fno-semantic-interposition for better performance + https://fedoraproject.org/wiki/Changes/PythonNoSemanticInterpositionSpeedup + +* Wed Nov 13 2019 Tomas Orsava - 3.8.0-2 +- Converting to RHEL8 +- Changes from Fedora + - Removed gpgverifycation as the tool used in Fedora is not present in RHEL8 + - Added versioned pathfix.py and 2to3 scripts into bindir + - Depend on python3-rpm-generators always, because they run on Python 3.6 +- Added python38-rpm-macros subpackage + - Fixed py3_install_wheel macro because python38-pip does not have + the --strip-prefix patch + +* 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 + +* Fri Aug 30 2019 Miro Hrončok - 3.8.0~b4-1 +- Rebased to Python 3.8.0b4 + +* Thu Aug 15 2019 Miro Hrončok - 3.8.0~b3-4 +- Enable Profile-guided optimization for all arches, not just x86 (#1741015) + +* Wed Aug 14 2019 Miro Hrončok - 3.8.0~b3-3 +- Rebuilt for Python 3.8 + +* Wed Aug 14 2019 Miro Hrončok - 3.8.0~b3-2 +- Bootstrap for Python 3.8 + +* Tue Aug 13 2019 Miro Hrončok - 3.8.0~b3-1 +- Update to 3.8.0b3 + +* Sun Aug 11 2019 Miro Hrončok - 3.7.4-5 +- Conditionalize python3-devel runtime dependencies on RPM packages and setuptools + +* Fri Jul 26 2019 Fedora Release Engineering - 3.7.4-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Mon Jul 15 2019 Lumír Balhar - 3.7.4-3 +- Move test.support module to python3-test subpackage + https://fedoraproject.org/wiki/Changes/Move_test.support_module_to_python3-test_subpackage +- Restore pyc to TIMESTAMP invalidation mode as default in rpmbubild + +* Fri Jul 12 2019 Miro Hrončok - 3.7.4-2 +- https://fedoraproject.org/wiki/Changes/Python_means_Python3 +- The python-unversioned-command package is no longer Python 2, but 3 +- The python, pydoc, python-config, python-debug, idle, pygettext.py and + msgfmt.py commands are now in python3 + +* Tue Jul 09 2019 Miro Hrončok - 3.7.4-1 +- Update to 3.7.4 + +* Tue Jul 02 2019 Miro Hrončok - 3.7.4~rc2-1 +- Update to 3.7.4rc2 + +* Tue Jun 25 2019 Miro Hrončok - 3.7.4~rc1-1 +- Update to 3.7.4rc1 + +* Tue May 07 2019 Charalampos Stratakis - 3.7.3-3 +- Fix handling of pre-normalization characters in urlsplit +- Disallow control chars in http URLs (#1695572, #1700684, #1688169, #1706851) + +* Wed Apr 17 2019 Patrik Kopkan - 3.7.3-2 +- Makes man python3.7m show python3.7 man pages (#1612241) + +* Wed Mar 27 2019 Miro Hrončok - 3.7.3-1 +- Update to 3.7.3 + +* Thu Mar 21 2019 Miro Hrončok - 3.7.3~rc1-1 +- Update to 3.7.3rc1 + +* Thu Mar 14 2019 Miro Hrončok - 3.7.2-8 +- Security fix for CVE-2019-9636 (#1688543, #1688546) + +* Sun Feb 17 2019 Igor Gnatenko - 3.7.2-7 +- Rebuild for readline 8.0 + +* Tue Feb 12 2019 Miro Hrončok - 3.7.2-6 +- Reduced default build flags used to build extension modules + https://fedoraproject.org/wiki/Changes/Python_Extension_Flags + +* Sat Feb 02 2019 Fedora Release Engineering - 3.7.2-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Wed Jan 16 2019 Miro Hrončok - 3.7.2-4 +- Security fix for CVE-2019-5010 (#1666519, #1666522) + +* Mon Jan 14 2019 Björn Esser - 3.7.2-3 +- Rebuilt for libcrypt.so.2 (#1666033) + +* Fri Jan 04 2019 Miro Hrončok - 3.7.2-2 +- No longer revert upstream commit 3b699932e5ac3e7 +- This was a dirty workaround for (#1644936) + +* Tue Dec 25 2018 Miro Hrončok - 3.7.2-1 +- Update to 3.7.2 + +* Fri Dec 07 2018 Miro Hrončok - 3.7.1-5 +- Make sure we don't ship any exe files (not needed an prebuilt) + +* Wed Nov 21 2018 Miro Hrončok - 3.7.1-4 +- Make sure the entire test.support module is in python3-libs (#1651245) + +* Tue Nov 06 2018 Victor Stinner - 3.7.1-3 +- Verify the value of '-s' when execute the CLI of cProfile (rhbz#1160640) + +* Sun Nov 04 2018 Miro Hrončok - 3.7.1-2 +- Temporarily revert upstream commit 3b699932e5ac3e7 +- This is dirty workaround for (#1644936) + +* Mon Oct 22 2018 Miro Hrončok - 3.7.1-1 +- Update to 3.7.1 + +* Thu Sep 27 2018 Petr Viktorin - 3.7.0-10 +- Compile the debug build with -Og rather than -O0 + +* Thu Aug 30 2018 Miro Hrončok - 3.7.0-9 +- Require python3-setuptools from python3-devel to prevent packaging errors (#1623914) + +* Fri Aug 17 2018 Miro Hrončok - 3.7.0-8 +- Add /usr/bin/pygettext3.py and msgfmt3.py to python3-devel +Resolves: rhbz#1571474 + +* Fri Aug 17 2018 Miro Hrončok - 3.7.0-7 +- Backport TLS 1.3 related fixes to fix FTBFS +Resolves: rhbz#1609291 + +* Wed Aug 15 2018 Miro Hrončok - 3.7.0-6 +- Use RPM built wheels of pip and setuptools in ensurepip instead of our rewheel patch + +* Fri Aug 10 2018 Igor Gnatenko - 3.7.0-5 +- Fix wrong requirement on gdbm + +* Fri Jul 20 2018 Miro Hrončok - 3.7.0-4 +- Allow to call Py_Main() after Py_Initialize() +Resolves: rhbz#1595421 + +* Sat Jul 14 2018 Fedora Release Engineering - 3.7.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Thu Jul 12 2018 Igor Gnatenko - 3.7.0-2 +- Rebuild for new gdbm + +* Wed Jun 27 2018 Miro Hrončok - 3.7.0-1 +- Update to 3.7.0 final + +* Wed Jun 13 2018 Miro Hrončok - 3.7.0-0.21.rc1 +- Finish bootstrapping, enable rewheel, tests, optimizations + +* Tue Jun 12 2018 Miro Hrončok - 3.7.0-0.20.rc1 +- Update to 3.7.0rc1 +- Bootstrap, disable rewheel, tests, optimizations + +* Mon Apr 23 2018 Miro Hrončok - 3.6.5-4 +- Fix multiprocessing regression on newer glibcs +- Enable test_multiprocessing_fork(server) and _spawn again +Resolves: rhbz#1569933 + +* Thu Apr 19 2018 Miro Hrončok - 3.6.5-3 +- Skip test_multiprocessing_fork(server) and _spawn for now + +* Wed Apr 18 2018 Miro Hrončok - 3.6.5-2 +- Add flatpackage conditionals + +* Thu Mar 29 2018 Charalampos Stratakis - 3.6.5-1 +- Update to 3.6.5 + +* Sat Mar 24 2018 Miro Hrončok - 3.6.4-20 +- Fix broken macro invocation and broken building of C Python extensions +Resolves: rhbz#1560103 + +* Fri Mar 16 2018 Miro Hrončok - 3.6.4-19 +- Add -n option for pathfix.py +Resolves: rhbz#1546990 + +* Thu Mar 15 2018 Miro Hrončok - 3.6.4-18 +- Fix the py_byte_compile macro to work on Python 2 +- Remove the pybytecompile macro file from the flat package +Resolves: rhbz#1484993 + +* Tue Mar 13 2018 Charalampos Stratakis - 3.6.4-17 +- Do not send IP addresses in SNI TLS extension + +* Sat Feb 24 2018 Florian Weimer - 3.6.4-16 +- Rebuild with new LDFLAGS from redhat-rpm-config + +* Wed Feb 21 2018 Miro Hrončok - 3.6.4-15 +- Filter out automatic /usr/bin/python3.X requirement, + recommend the main package from libs instead +Resolves: rhbz#1547131 + +* Thu Feb 15 2018 Iryna Shcherbina - 3.6.4-14 +- Remove the python3-tools package (#rhbz 1312030) +- Move /usr/bin/2to3 to python3-devel +- Move /usr/bin/idle and idlelib to python3-idle +- Provide python3-tools from python3-idle + +* Fri Feb 09 2018 Igor Gnatenko - 3.6.4-13 +- Escape macros in %%changelog + +* Fri Feb 02 2018 Michal Cyprian - 3.6.4-12 +- Remove sys.executable check from change-user-install-location patch +Resolves: rhbz#1532287 + +* Thu Feb 01 2018 Charalampos Stratakis - 3.6.4-11 +- Define TLS cipher suite on build time. + +* Wed Jan 31 2018 Tomas Orsava - 3.6.4-10 +- Disable test_gdb for all arches and test_buffer for ppc64le in anticipation + of the F28 mass rebuild +- Re-enable these tests after the mass rebuild when they can be properly + addressed + +* Tue Jan 23 2018 Charalampos Stratakis - 3.6.4-9 +- Restore the PyExc_RecursionErrorInst public symbol + +* Tue Jan 23 2018 Björn Esser - 3.6.4-8 +- Add patch to explicitly link _ctypes module with -ldl (#1537489) +- Refactored patch for libxcrypt +- Re-enable strict symbol checks in the link editor + +* Mon Jan 22 2018 Björn Esser - 3.6.4-7 +- Add patch for libxcrypt +- Disable strict symbol checks in the link editor + +* Sat Jan 20 2018 Björn Esser - 3.6.4-6 +- Rebuilt for switch to libxcrypt + +* Fri Jan 19 2018 Charalampos Stratakis - 3.6.4-5 +- Fix localeconv() encoding for LC_NUMERIC + +* Thu Jan 18 2018 Igor Gnatenko - 3.6.4-4 +- R: gdbm-devel → R: gdbm for python3-libs + +* Wed Jan 17 2018 Miro Hrončok - 3.6.4-3 +- Require large enough gdbm (fixup for previous bump) + +* Tue Jan 16 2018 Charalampos Stratakis - 3.6.4-2 +- Rebuild for reverted gdbm 1.13 on Fedora 27 + +* Mon Jan 15 2018 Charalampos Stratakis - 3.6.4-1 +- Update to version 3.6.4 + +* Fri Jan 12 2018 Charalampos Stratakis - 3.6.3-5 +- Fix the compilation of the nis module. + +* Tue Nov 21 2017 Miro Hrončok - 3.6.3-4 +- Raise the release of platform-python obsoletes for better maintainability + +* Wed Nov 15 2017 Miro Hrončok - 3.6.3-3 +- Obsolete platform-python and it's subpackages + +* Mon Oct 09 2017 Charalampos Stratakis - 3.6.3-2 +- Fix memory corruption due to allocator mix +Resolves: rhbz#1498207 + +* Fri Oct 06 2017 Charalampos Stratakis - 3.6.3-1 +- Update to Python 3.6.3 + +* Fri Sep 29 2017 Miro Hrončok - 3.6.2-19 +- Move pathfix.py to bindir, https://github.com/fedora-python/python-rpm-porting/issues/24 +- Make the -devel package require redhat-rpm-config +Resolves: rhbz#1496757 + +* Wed Sep 13 2017 Iryna Shcherbina - 3.6.2-18 +- Fix /usr/bin/env dependency from python3-tools +Resolves: rhbz#1482118 + +* Wed Sep 06 2017 Iryna Shcherbina - 3.6.2-17 +- Include `-g` in the flags sent to the linker (LDFLAGS) +Resolves: rhbz#1483222 + +* Tue Sep 05 2017 Petr Viktorin - 3.6.2-16 +- Specfile cleanup +- Make the main description also applicable to the SRPM +- Add audiotest.au to the test package + +* Fri Sep 01 2017 Miro Hrončok - 3.6.2-15 +- Remove %%{pylibdir}/Tools/scripts/2to3 + +* Fri Sep 01 2017 Miro Hrončok - 3.6.2-14 +- Expat >= 2.1.0 is everywhere, remove explicit requires +- Conditionalize systemtap-devel BuildRequires +- For consistency, require /usr/sbin/ifconfig instead of net-tools + +* Mon Aug 28 2017 Petr Viktorin - 3.6.2-13 +- Rename patch files to be consistent +- Run autotools to generate the configure script before building +- Merge lib64 patches (104 into 102) +- Skip test_bdist_rpm using test config rather than a patch (removes patch 137) +- Remove patches 157 and 186, which had test changes left over after upstreaming +- Remove patch 188, a temporary workaround for hashlib tests +- Merge patches 180, 206, 243, 5001 (architecture naming) into new patch 274 +- Move python2-tools conflicts to tools subpackage (it was wrongly in tkinter) + +* Mon Aug 28 2017 Michal Cyprian - 3.6.2-12 +- Use python3 style of calling super() without arguments in rpath + patch to prevent recursion in UnixCCompiler subclasses +Resolves: rhbz#1458122 + +* Mon Aug 21 2017 Petr Viktorin - 3.6.2-11 +- Add bcond for --without optimizations +- Reword package descriptions +- Remove Group declarations +- Skip failing test_float_with_comma + +* Mon Aug 21 2017 Miro Hrončok - 3.6.2-10 +- Remove system-python, see https://fedoraproject.org/wiki/Changes/Platform_Python_Stack + +* Wed Aug 16 2017 Petr Viktorin - 3.6.2-9 +- Use bconds for configuring the build +- Reorganize the initial sections + +* Wed Aug 16 2017 Miro Hrončok - 3.6.2-8 +- Have /usr/bin/2to3 (rhbz#1111275) +- Provide 2to3 and idle3, list them in summary and description (rhbz#1076401) + +* Fri Aug 11 2017 Michal Cyprian - 3.6.2-7 +- Revert "Add --executable option to install.py command" + This enhancement is currently not needed and it can possibly + collide with `pip --editable`option + +* Mon Aug 07 2017 Iryna Shcherbina - 3.6.2-6 +- Fix the "urllib FTP protocol stream injection" vulnerability +Resolves: rhbz#1478916 + +* Tue Aug 01 2017 Tomas Orsava - 3.6.2-5 +- Dropped BuildRequires on db4-devel which was useful for Python 2 (module + bsddb), however, no longer needod for Python 3 +- Tested building Python 3 with and without the dependency, all tests pass and + filelists of resulting RPMs are identical + +* Sun Jul 30 2017 Florian Weimer - 3.6.2-4 +- Do not generate debuginfo subpackages (#1476593) +- Rebuild with binutils fix for ppc64le (#1475636) + +* Thu Jul 27 2017 Fedora Release Engineering - 3.6.2-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Tue Jul 25 2017 Charalampos Stratakis - 3.6.2-2 +- Make test_asyncio to not depend on the current SIGHUP signal handler. + +* Tue Jul 18 2017 Charalampos Stratakis - 3.6.2-1 +- Update to Python 3.6.2 + +* Tue Jun 27 2017 Charalampos Stratakis - 3.6.1-10 +- Update to the latest upstream implementation of PEP 538 + +* Mon Jun 26 2017 Michal Cyprian - 3.6.1-9 +- Make pip and distutils in user environment install into separate location + +* Fri Jun 23 2017 Charalampos Stratakis - 3.6.1-8 +- Fix test_alpn_protocols from test_ssl +- Do not require rebundled setuptools dependencies + +* Tue May 16 2017 Tomas Orsava - 3.6.1-7 +- Added a dependency to the devel subpackage on python3-rpm-generators which + have been excised out of rpm-build +- Updated notes on bootstrapping Python on top of this specfile accordingly +- Involves: rhbz#1410631, rhbz#1444925 + +* Tue May 09 2017 Charalampos Stratakis - 3.6.1-6 +- Enable profile guided optimizations for x86_64 and i686 architectures +- Update to a newer implementation of PEP 538 +- Update description to reflect that Python 3 is now the default Python + +* Fri May 05 2017 Charalampos Stratakis - 3.6.1-5 +- Update PEP 538 to the latest upstream implementation + +* Tue Apr 18 2017 Charalampos Stratakis - 3.6.1-4 +- Enable link time optimizations +- Move windows executables to the devel subpackage (rhbz#1426257) + +* Thu Apr 13 2017 Tomas Orsava - 3.6.1-3 +- Rename python3.Xdm-config script from -debug to be arch specific +Resolves: rhbz#1179073 + +* Wed Apr 05 2017 Charalampos Stratakis - 3.6.1-2 +- Install the Makefile in its proper location (rhbz#1438219) + +* Wed Mar 22 2017 Iryna Shcherbina - 3.6.1-1 +- Update to version 3.6.1 final + +* Tue Mar 21 2017 Tomas Orsava - 3.6.1-0.2.rc1 +- Fix syntax error in %%py_byte_compile macro (rhbz#1433569) + +* Thu Mar 16 2017 Iryna Shcherbina - 3.6.1-0.1.rc1 +- Update to Python 3.6.1 release candidate 1 +- Add patch 264 to skip a known test failure on aarch64 + +* Fri Mar 10 2017 Charalampos Stratakis - 3.6.0-21 +- Use proper command line parsing in _testembed +- Backport of PEP 538: Coercing the legacy C locale to a UTF-8 based locale + https://fedoraproject.org/wiki/Changes/python3_c.utf-8_locale + +* Mon Feb 27 2017 Charalampos Stratakis - 3.6.0-20 +- Add desktop entry and appdata.xml file for IDLE 3 (rhbz#1392049) + +* Fri Feb 24 2017 Michal Cyprian - 3.6.0-19 +- Revert "Set values of prefix and exec_prefix to /usr/local for + /usr/bin/python* executables..." to prevent build failures + of packages using alternate build tools + +* Tue Feb 21 2017 Michal Cyprian - 3.6.0-18 +- Set values of prefix and exec_prefix to /usr/local for + /usr/bin/python* executables +- Use new %%_module_build macro + +* Fri Feb 17 2017 Michal Cyprian - 3.6.0-13 +- Add --executable option to install.py command + +* Wed Feb 15 2017 Charalampos Stratakis - 3.6.0-12 +- BuildRequire the new dependencies of setuptools when rewheel mode is enabled +in order for the virtualenvs to work properly + +* Sat Feb 11 2017 Fedora Release Engineering - 3.6.0-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Feb 01 2017 Stephen Gallagher - 3.6.0-10 +- Add missing %%license macro + +* Thu Jan 26 2017 Tomas Orsava - 3.6.0-9 +- Modify the runtime dependency of python3-libs on system-python-libs again, + because previous attempt didn't work properly with dnf resolving mechanism + +* Wed Jan 25 2017 Tomas Orsava - 3.6.0-8 +- Modify the runtime dependency of python3-libs on system-python-libs to use + just the version and release number, but not the dist tag due to Modularity + +* Mon Jan 16 2017 Charalampos Stratakis - 3.6.0-7 +- Fix error check, so that Random.seed actually uses OS randomness (rhbz#1412275) +- Skip test_aead_aes_gcm during rpmbuild + +* Thu Jan 12 2017 Igor Gnatenko - 3.6.0-6 +- Rebuild for readline 7.x + +* Tue Jan 10 2017 Charalampos Stratakis - 3.6.0-5 +- Require glibc >= 2.24.90-26 for system-python-libs (rhbz#1410644) + +* Mon Jan 09 2017 Charalampos Stratakis - 3.6.0-4 +- Define HAVE_LONG_LONG as 1 for backwards compatibility + +* Thu Jan 05 2017 Miro Hrončok - 3.6.0-3 +- Don't blow up on EL7 kernel (random generator) (rhbz#1410175) + +* Tue Dec 27 2016 Charalampos Stratakis - 3.6.0-1 +- Update to Python 3.6.0 final + +* Fri Dec 09 2016 Charalampos Stratakis - 3.6.0-0.6.rc1 +- Enable rewheel + +* Wed Dec 07 2016 Charalampos Stratakis - 3.6.0-0.5.rc1 +- Update to Python 3.6.0 release candidate 1 + +* Mon Dec 05 2016 Charalampos Stratakis - 3.6.0-0.4.b4 +- Update to Python 3.6.0 beta 4 + +* Mon Dec 05 2016 Charalampos Stratakis - 3.5.2-7 +- Set to work with pip version 9.0.1 + +* Wed Oct 12 2016 Charalampos Stratakis - 3.5.2-6 +- Use proper patch numbering and base upstream branch for +porting ssl and hashlib modules to OpenSSL 1.1.0 +- Drop hashlib patch for now +- Add riscv64 arch to 64bit and no-valgrind arches + +* Tue Oct 11 2016 Tomáš Mráz - 3.5.2-5 +- Make it build with OpenSSL-1.1.0 based on upstream patch + +* Wed Sep 14 2016 Charalampos Stratakis - 3.5.2-4 +- Obsolete and Provide python35 package + +* Mon Sep 12 2016 Charalampos Stratakis - 3.5.2-3 +- Update %%py_byte_compile macro +- Remove unused configure flags (rhbz#1374357) + +* Fri Sep 09 2016 Tomas Orsava - 3.5.2-2 +- Updated .pyc 'bytecompilation with the newly installed interpreter' to also + recompile optimized .pyc files +- Removed .pyo 'bytecompilation with the newly installed interpreter', as .pyo + files are no more +- Resolves rhbz#1373635 + +* Mon Aug 15 2016 Tomas Orsava - 3.5.2-1 +- Rebased to version 3.5.2 +- Set to work with pip version 8.1.2 +- Removed patches 207, 237, 241 as fixes are already contained in Python 3.5.2 +- Removed arch or environment specific patches 194, 196, 203, and 208 + as test builds indicate they are no longer needed +- Updated patches 102, 146, and 242 to work with the new Python codebase +- Removed patches 200, 201, 5000 which weren't even being applied + +* Tue Aug 09 2016 Charalampos Stratakis - 3.5.1-15 +- Fix for CVE-2016-1000110 HTTPoxy attack +- SPEC file cleanup + +* Mon Aug 01 2016 Michal Toman - 3.5.1-14 +- Build properly on MIPS + +* Tue Jul 19 2016 Fedora Release Engineering - 3.5.1-13 +- https://fedoraproject.org/wiki/Changes/Automatic_Provides_for_Python_RPM_Packages + +* Fri Jul 08 2016 Charalampos Stratakis - 3.5.1-12 +- Refactor patch for properly fixing CVE-2016-5636 + +* Fri Jul 08 2016 Charalampos Stratakis - 3.5.1-11 +- Fix test_pyexpat failure with Expat version of 2.2.0 + +* Fri Jul 08 2016 Miro Hrončok - 3.5.1-10 +- Move xml module to system-python-libs + +* Thu Jun 16 2016 Tomas Orsava - 3.5.1-9 +- Fix for: CVE-2016-0772 python: smtplib StartTLS stripping attack +- Raise an error when STARTTLS fails +- rhbz#1303647: https://bugzilla.redhat.com/show_bug.cgi?id=1303647 +- rhbz#1346345: https://bugzilla.redhat.com/show_bug.cgi?id=1346345 +- Fixed upstream: https://hg.python.org/cpython/rev/d590114c2394 + +* Mon Jun 13 2016 Charalampos Stratakis - 3.5.1-8 +- Added patch for fixing possible integer overflow and heap corruption in zipimporter.get_data() + +* Fri Mar 04 2016 Miro Hrončok - 3.5.1-7 +- Move distutils to system-python-libs + +* Wed Feb 24 2016 Robert Kuska - 3.5.1-6 +- Provide python3-enum34 + +* Fri Feb 19 2016 Miro Hrončok - 3.5.1-5 +- Provide System Python packages and macros + +* Thu Feb 04 2016 Fedora Release Engineering - 3.5.1-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Wed Jan 13 2016 Orion Poplwski - 3.5.1-2 +- Drop python3 macros, require python/python3-rpm-macros + +* Mon Dec 14 2015 Robert Kuska - 3.5.1-1 +- Update to 3.5.1 +- Removed patch 199 and 207 (upstream) + +* Sun Nov 15 2015 Robert Kuska - 3.5.0-5 +- Remove versioned libpython from devel package + +* Fri Nov 13 2015 Than Ngo 3.5.0-4 +- add correct arch for ppc64/ppc64le to fix build failure + +* Wed Nov 11 2015 Robert Kuska - 3.5.0-3 +- Hide the private _Py_atomic_xxx symbols from public header + +* Wed Oct 14 2015 Robert Kuska - 3.5.0-2 +- Rebuild with wheel set to 1 + +* Tue Sep 15 2015 Matej Stuchlik - 3.5.0-1 +- Update to 3.5.0 + +* Mon Jun 29 2015 Thomas Spura - 3.4.3-4 +- python3-devel: Require python-macros for version independant macros such as + python_provide. See fpc#281 and fpc#534. + +* Thu Jun 18 2015 Fedora Release Engineering - 3.4.3-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Wed Jun 17 2015 Matej Stuchlik - 3.4.3-4 +- Use 1024bit DH key in test_ssl +- Use -O0 when compiling -debug build +- Update pip version variable to the version we actually ship + +* Wed Jun 17 2015 Matej Stuchlik - 3.4.3-3 +- Make relocating Python by changing _prefix actually work +Resolves: rhbz#1231801 + +* Mon May 4 2015 Peter Robinson 3.4.3-2 +- Disable test_gdb on aarch64 (rhbz#1196181), it joins all other non x86 arches + +* Thu Mar 12 2015 Matej Stuchlik - 3.4.3-1 +- Updated to 3.4.3 +- BuildPython now accepts additional build options +- Temporarily disabled test_gdb on arm (rhbz#1196181) + +* Wed Feb 25 2015 Matej Stuchlik - 3.4.2-7 +- Fixed undefined behaviour in faulthandler which caused test to hang on x86_64 + (http://bugs.python.org/issue23433) + +* Sat Feb 21 2015 Till Maas - 3.4.2-6 +- Rebuilt for Fedora 23 Change + https://fedoraproject.org/wiki/Changes/Harden_all_packages_with_position-independent_code + +* Tue Feb 17 2015 Ville Skyttä - 3.4.2-5 +- Own systemtap dirs (#710733) + +* Mon Jan 12 2015 Dan Horák - 3.4.2-4 +- build with valgrind on ppc64le +- disable test_gdb on s390(x) until rhbz#1181034 is resolved + +* Tue Dec 16 2014 Robert Kuska - 3.4.2-3 +- New patches: 170 (gc asserts), 200 (gettext headers), + 201 (gdbm memory leak) + +* Thu Dec 11 2014 Robert Kuska - 3.4.2-2 +- OpenSSL disabled SSLv3 in SSLv23 method + +* Thu Nov 13 2014 Matej Stuchlik - 3.4.2-1 +- Update to 3.4.2 +- Refreshed patches: 156 (gdb autoload) +- Removed: 195 (Werror declaration), 197 (CVE-2014-4650) + +* Mon Nov 03 2014 Slavek Kabrda - 3.4.1-16 +- Fix CVE-2014-4650 - CGIHTTPServer URL handling +Resolves: rhbz#1113529 + +* Sun Sep 07 2014 Karsten Hopp 3.4.1-15 +- exclude test_gdb on ppc* (rhbz#1132488) + +* Thu Aug 21 2014 Slavek Kabrda - 3.4.1-14 +- Update rewheel patch with fix from https://github.com/bkabrda/rewheel/pull/1 + +* Sun Aug 17 2014 Fedora Release Engineering - 3.4.1-13 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Sun Jun 8 2014 Peter Robinson 3.4.1-12 +- aarch64 has valgrind, just list those that don't support it + +* Sun Jun 08 2014 Fedora Release Engineering - 3.4.1-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Wed Jun 04 2014 Karsten Hopp 3.4.1-10 +- bump release and rebuild to link with the correct tcl/tk libs on ppcle + +* Tue Jun 03 2014 Matej Stuchlik - 3.4.1-9 +- Change paths to bundled projects in rewheel patch + +* Fri May 30 2014 Miro Hrončok - 3.4.1-8 +- In config script, use uname -m to write the arch + +* Thu May 29 2014 Dan Horák - 3.4.1-7 +- update the arch list where valgrind exists - %%power64 includes also + ppc64le which is not supported yet + +* Thu May 29 2014 Miro Hrončok - 3.4.1-6 +- Forward arguments to the arch specific config script +Resolves: rhbz#1102683 + +* Wed May 28 2014 Miro Hrončok - 3.4.1-5 +- Rename python3.Xm-config script to arch specific. +Resolves: rhbz#1091815 + +* Tue May 27 2014 Bohuslav Kabrda - 3.4.1-4 +- Use python3-*, not python-* runtime requires on setuptools and pip +- rebuild for tcl-8.6 + +* Tue May 27 2014 Matej Stuchlik - 3.4.1-3 +- Update the rewheel module + +* Mon May 26 2014 Miro Hrončok - 3.4.1-2 +- Fix multilib dependencies. +Resolves: rhbz#1091815 + +* Sun May 25 2014 Matej Stuchlik - 3.4.1-1 +- Update to Python 3.4.1 + +* Sun May 25 2014 Matej Stuchlik - 3.4.0-8 +- Fix test_gdb failure on ppc64le +Resolves: rhbz#1095355 + +* Thu May 22 2014 Miro Hrončok - 3.4.0-7 +- Add macro %%python3_version_nodots + +* Sun May 18 2014 Matej Stuchlik - 3.4.0-6 +- Disable test_faulthandler, test_gdb on aarch64 +Resolves: rhbz#1045193 + +* Fri May 16 2014 Matej Stuchlik - 3.4.0-5 +- Don't add Werror=declaration-after-statement for extension + modules through setup.py (PyBT#21121) + +* Mon May 12 2014 Matej Stuchlik - 3.4.0-4 +- Add setuptools and pip to Requires + +* Tue Apr 29 2014 Matej Stuchlik - 3.4.0-3 +- Point __os_install_post to correct brp-* files + +* Tue Apr 15 2014 Matej Stuchlik - 3.4.0-2 +- Temporarily disable tests requiring SIGHUP (rhbz#1088233) + +* Tue Apr 15 2014 Matej Stuchlik - 3.4.0-1 +- Update to Python 3.4 final +- Add patch adding the rewheel module +- Merge patches from master + +* Wed Jan 08 2014 Bohuslav Kabrda - 3.4.0-0.1.b2 +- Update to Python 3.4 beta 2. +- Refreshed patches: 55 (systemtap), 146 (hashlib-fips), 154 (test_gdb noise) +- Dropped patches: 114 (statvfs constants), 177 (platform unicode) + +* Mon Nov 25 2013 Bohuslav Kabrda - 3.4.0-0.1.b1 +- Update to Python 3.4 beta 1. +- Refreshed patches: 102 (lib64), 111 (no static lib), 125 (less verbose COUNT +ALLOCS), 141 (fix COUNT_ALLOCS in test_module), 146 (hashlib fips), +157 (UID+GID overflows), 173 (ENOPROTOOPT in bind_port) +- Removed patch 00187 (remove pthread atfork; upstreamed) + +* Mon Nov 04 2013 Bohuslav Kabrda - 3.4.0-0.1.a4 +- Update to Python 3.4 alpha 4. +- Refreshed patches: 55 (systemtap), 102 (lib64), 111 (no static lib), +114 (statvfs flags), 132 (unittest rpmbuild hooks), 134 (fix COUNT_ALLOCS in +test_sys), 143 (tsc on ppc64), 146 (hashlib fips), 153 (test gdb noise), +157 (UID+GID overflows), 173 (ENOPROTOOPT in bind_port), 186 (dont raise +from py_compile) +- Removed patches: 129 (test_subprocess nonreadable dir - no longer fails in +Koji), 142 (the mock issue that caused this is fixed) +- Added patch 187 (remove thread atfork) - will be in next version +- Refreshed script for checking pyc and pyo timestamps with new ignored files. +- The fips patch is disabled for now until upstream makes a final decision +what to do with sha3 implementation for 3.4.0. + +* Wed Oct 30 2013 Bohuslav Kabrda - 3.3.2-7 +- Bytecompile all *.py files properly during build (rhbz#1023607) + +* Fri Aug 23 2013 Matej Stuchlik - 3.3.2-6 +- Added fix for CVE-2013-4238 (rhbz#996399) + +* Fri Jul 26 2013 Dennis Gilmore - 3.3.2-5 +- fix up indentation in arm patch + +* Fri Jul 26 2013 Dennis Gilmore - 3.3.2-4 +- disable a test that fails on arm +- enable valgrind support on arm arches + +* Tue Jul 02 2013 Bohuslav Kabrda - 3.3.2-3 +- Fix build with libffi containing multilib wrapper for ffi.h (rhbz#979696). + +* Mon May 20 2013 Bohuslav Kabrda - 3.3.2-2 +- Add patch for CVE-2013-2099 (rhbz#963261). + +* Thu May 16 2013 Bohuslav Kabrda - 3.3.2-1 +- Updated to Python 3.3.2. +- Refreshed patches: 153 (gdb test noise) +- Dropped patches: 175 (configure -Wformat, fixed upstream), 182 (gdb +test threads) +- Synced patch numbers with python.spec. + +* Thu May 9 2013 David Malcolm - 3.3.1-4 +- fix test.test_gdb.PyBtTests.test_threads on ppc64 (patch 181; rhbz#960010) + +* Thu May 02 2013 Bohuslav Kabrda - 3.3.1-3 +- Add patch that enables building on ppc64p7 (replace the sed, so that +we get consistent with python2 spec and it's more obvious that we're doing it. + +* Wed Apr 24 2013 Bohuslav Kabrda - 3.3.1-2 +- Add fix for gdb tests failing on arm, rhbz#951802. + +* Tue Apr 09 2013 Bohuslav Kabrda - 3.3.1-1 +- Updated to Python 3.3.1. +- Refreshed patches: 55 (systemtap), 111 (no static lib), 146 (hashlib fips), +153 (fix test_gdb noise), 157 (uid, gid overflow - fixed upstream, just +keeping few more downstream tests) +- Removed patches: 3 (audiotest.au made it to upstream tarball) +- Removed workaround for http://bugs.python.org/issue14774, discussed in +http://bugs.python.org/issue15298 and fixed in revision 24d52d3060e8. + +* Mon Mar 25 2013 David Malcolm - 3.3.0-10 +- fix gcc 4.8 incompatibility (rhbz#927358); regenerate autotool intermediates + +* Mon Mar 25 2013 David Malcolm - 3.3.0-9 +- renumber patches to keep them in sync with python.spec + +* Fri Mar 15 2013 Toshio Kuratomi - 3.3.0-8 +- Fix error in platform.platform() when non-ascii byte strings are decoded to + unicode (rhbz#922149) + +* Thu Mar 14 2013 Toshio Kuratomi - 3.3.0-7 +- Fix up shared library extension (rhbz#889784) + +* Thu Mar 07 2013 Karsten Hopp 3.3.0-6 +- add ppc64p7 build target, optimized for Power7 + +* Mon Mar 4 2013 David Malcolm - 3.3.0-5 +- add workaround for ENOPROTOOPT seen running selftests in Koji +(rhbz#913732) + +* Mon Mar 4 2013 David Malcolm - 3.3.0-4 +- remove config flag from /etc/rpm/macros.{python3|pybytecompile} + +* Mon Feb 11 2013 David Malcolm - 3.3.0-3 +- add aarch64 (rhbz#909783) + +* Thu Nov 29 2012 David Malcolm - 3.3.0-2 +- add BR on bluez-libs-devel (rhbz#879720) + +* Sat Sep 29 2012 David Malcolm - 3.3.0-1 +- 3.3.0rc3 -> 3.3.0; drop alphatag + +* Mon Sep 24 2012 David Malcolm - 3.3.0-0.6.rc3 +- 3.3.0rc2 -> 3.3.0rc3 + +* Mon Sep 10 2012 David Malcolm - 3.3.0-0.5.rc2 +- 3.3.0rc1 -> 3.3.0rc2; refresh patch 55 + +* Mon Aug 27 2012 David Malcolm - 3.3.0-0.4.rc1 +- 3.3.0b2 -> 3.3.0rc1; refresh patches 3, 55 + +* Mon Aug 13 2012 David Malcolm - 3.3.0-0.3.b2 +- 3.3b1 -> 3.3b2; drop upstreamed patch 152; refresh patches 3, 102, 111, +134, 153, 160; regenenerate autotools patch; rework systemtap patch to work +correctly when LANG=C (patch 55); importlib.test was moved to +test.test_importlib upstream + +* Mon Aug 13 2012 Karsten Hopp 3.3.0-0.2.b1 +- disable some failing checks on PPC* (rhbz#846849) + +* Fri Aug 3 2012 David Malcolm - 3.3.0-0.1.b1 +- 3.2 -> 3.3: https://fedoraproject.org/wiki/Features/Python_3.3 +- 3.3.0b1: refresh patches 3, 55, 102, 111, 113, 114, 134, 157; drop upstream +patch 147; regenenerate autotools patch; drop "--with-wide-unicode" from +configure (PEP 393); "plat-linux2" -> "plat-linux" (upstream issue 12326); +"bz2" -> "_bz2" and "crypt" -> "_crypt"; egg-info files are no longer shipped +for stdlib (upstream issues 10645 and 12218); email/test moved to +test/test_email; add /usr/bin/pyvenv[-3.3] and venv module (PEP 405); add +_decimal and _lzma modules; make collections modules explicit in payload again +(upstream issue 11085); add _testbuffer module to tests subpackage (added in +upstream commit 3f9b3b6f7ff0); fix test failures (patches 160 and 161); +workaround erroneously shared _sysconfigdata.py upstream issue #14774; fix +distutils.sysconfig traceback (patch 162); add BuildRequires: xz-devel (for +_lzma module); skip some tests within test_socket (patch 163) + +* Sat Jul 21 2012 Fedora Release Engineering - 3.2.3-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Fri Jul 20 2012 David Malcolm - 3.3.0-0.1.b1 + +* Fri Jun 22 2012 David Malcolm - 3.2.3-10 +- use macro for power64 (rhbz#834653) + +* Mon Jun 18 2012 David Malcolm - 3.2.3-9 +- fix missing include in uid/gid handling patch (patch 157; rhbz#830405) + +* Wed May 30 2012 Bohuslav Kabrda - 3.2.3-8 +- fix tapset for debug build + +* Tue May 15 2012 David Malcolm - 3.2.3-7 +- update uid/gid handling to avoid int overflows seen with uid/gid +values >= 2^31 on 32-bit architectures (patch 157; rhbz#697470) + +* Fri May 4 2012 David Malcolm - 3.2.3-6 +- renumber autotools patch from 300 to 5000 +- specfile cleanups + +* Mon Apr 30 2012 David Malcolm - 3.2.3-5 +- fix test_gdb.py (patch 156; rhbz#817072) + +* Fri Apr 20 2012 David Malcolm - 3.2.3-4 +- avoid allocating thunks in ctypes unless absolutely necessary, to avoid +generating SELinux denials on "import ctypes" and "import uuid" when embedding +Python within httpd (patch 155; rhbz#814391) + +* Fri Apr 20 2012 David Malcolm - 3.2.3-3 +- add explicit version requirements on expat to avoid linkage problems with +XML_SetHashSalt + +* Thu Apr 12 2012 David Malcolm - 3.2.3-2 +- fix test_gdb (patch 153) + +* Wed Apr 11 2012 David Malcolm - 3.2.3-1 +- 3.2.3; refresh patch 102 (lib64); drop upstream patches 148 (gdbm magic +values), 149 (__pycache__ fix); add patch 152 (test_gdb regex) + +* Thu Feb 9 2012 Thomas Spura - 3.2.2-13 +- use newly installed python for byte compiling (now for real) + +* Sun Feb 5 2012 Thomas Spura - 3.2.2-12 +- use newly installed python for byte compiling (#787498) + +* Wed Jan 4 2012 Ville Skyttä - 3.2.2-11 +- Build with $RPM_LD_FLAGS (#756863). +- Use xz-compressed source tarball. + +* Wed Dec 07 2011 Karsten Hopp 3.2.2-10 +- disable rAssertAlmostEqual in test_cmath on PPC (#750811) + +* Mon Oct 17 2011 Rex Dieter - 3.2.2-9 +- python3-devel missing autogenerated pkgconfig() provides (#746751) + +* Mon Oct 10 2011 David Malcolm - 3.2.2-8 +- cherrypick fix for distutils not using __pycache__ when byte-compiling +files (rhbz#722578) + +* Fri Sep 30 2011 David Malcolm - 3.2.2-7 +- re-enable gdbm (patch 148; rhbz#742242) + +* Fri Sep 16 2011 David Malcolm - 3.2.2-6 +- add a sys._debugmallocstats() function (patch 147) + +* Wed Sep 14 2011 David Malcolm - 3.2.2-5 +- support OpenSSL FIPS mode in _hashlib and hashlib; don't build the _md5 and +_sha* modules, relying on _hashlib in hashlib (rhbz#563986; patch 146) + +* Tue Sep 13 2011 David Malcolm - 3.2.2-4 +- disable gdbm module to prepare for gdbm soname bump + +* Mon Sep 12 2011 David Malcolm - 3.2.2-3 +- renumber and rename patches for consistency with python.spec (8 to 55, 106 +to 104, 6 to 111, 104 to 113, 105 to 114, 125, 131, 130 to 143) + +* Sat Sep 10 2011 David Malcolm - 3.2.2-2 +- rewrite of "check", introducing downstream-only hooks for skipping specific +cases in an rpmbuild (patch 132), and fixing/skipping failing tests in a more +fine-grained manner than before; (patches 106, 133-142 sparsely, moving +patches for consistency with python.spec: 128 to 134, 126 to 135, 127 to 141) + +* Tue Sep 6 2011 David Malcolm - 3.2.2-1 +- 3.2.2 + +* Thu Sep 1 2011 David Malcolm - 3.2.1-7 +- run selftests with "--verbose" +- disable parts of test_io on ppc (rhbz#732998) + +* Wed Aug 31 2011 David Malcolm - 3.2.1-6 +- use "--findleaks --verbose3" when running test suite + +* Tue Aug 23 2011 David Malcolm - 3.2.1-5 +- re-enable and fix the --with-tsc option on ppc64, and rework it on 32-bit +ppc to avoid aliasing violations (patch 130; rhbz#698726) + +* Tue Aug 23 2011 David Malcolm - 3.2.1-4 +- don't use --with-tsc on ppc64 debug builds (rhbz#698726) + +* Thu Aug 18 2011 David Malcolm - 3.2.1-3 +- add %%python3_version to the rpm macros (rhbz#719082) + +* Mon Jul 11 2011 Dennis Gilmore - 3.2.1-2 +- disable some tests on sparc arches + +* Mon Jul 11 2011 David Malcolm - 3.2.1-1 +- 3.2.1; refresh lib64 patch (102), subprocess unit test patch (129), disabling +of static library build (due to Modules/_testembed; patch 6), autotool +intermediates (patch 300) + +* Fri Jul 8 2011 David Malcolm - 3.2-5 +- use the gdb hooks from the upstream tarball, rather than keeping our own copy + +* Fri Jul 8 2011 David Malcolm - 3.2-4 +- don't run test_openpty and test_pty in %%check + +* Fri Jul 8 2011 David Malcolm - 3.2-3 +- cleanup of BuildRequires; add comment headings to specfile sections + +* Tue Apr 19 2011 David Malcolm - 3.2-2 +- fix the libpython.stp systemtap tapset (rhbz#697730) + +* Mon Feb 21 2011 David Malcolm - 3.2-1 +- 3.2 +- drop alphatag +- regenerate autotool patch + +* Mon Feb 14 2011 David Malcolm - 3.2-0.13.rc3 +- add a /usr/bin/python3-debug symlink within the debug subpackage + +* Mon Feb 14 2011 David Malcolm - 3.2-0.12.rc3 +- 3.2rc3 +- regenerate autotool patch + +* Wed Feb 09 2011 Fedora Release Engineering - 3.2-0.11.rc2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Mon Jan 31 2011 David Malcolm - 3.2-0.10.rc2 +- 3.2rc2 + +* Mon Jan 17 2011 David Malcolm - 3.2-0.9.rc1 +- 3.2rc1 +- rework patch 6 (static lib removal) +- remove upstreamed patch 130 (ppc debug build) +- regenerate patch 300 (autotool intermediates) +- updated packaging to reflect upstream rewrite of "Demo" (issue 7962) +- added libpython3.so and 2to3-3.2 + +* Wed Jan 5 2011 David Malcolm - 3.2-0.8.b2 +- set EXTRA_CFLAGS to our CFLAGS, rather than overriding OPT, fixing a linker +error with dynamic annotations (when configured using --with-valgrind) +- fix the ppc build of the debug configuration (patch 130; rhbz#661510) + +* Tue Jan 4 2011 David Malcolm - 3.2-0.7.b2 +- add --with-valgrind to configuration (on architectures that support this) + +* Wed Dec 29 2010 David Malcolm - 3.2-0.6.b2 +- work around test_subprocess failure seen in koji (patch 129) + +* Tue Dec 28 2010 David Malcolm - 3.2-0.5.b2 +- 3.2b2 +- rework patch 3 (removal of mimeaudio tests), patch 6 (no static libs), +patch 8 (systemtap), patch 102 (lib64) +- remove patch 4 (rendered redundant by upstream r85537), patch 103 (PEP 3149), +patch 110 (upstreamed expat fix), patch 111 (parallel build fix for grammar +fixed upstream) +- regenerate patch 300 (autotool intermediates) +- workaround COUNT_ALLOCS weakref issues in test suite (patch 126, patch 127, +patch 128) +- stop using runtest.sh in %%check (dropped by upstream), replacing with +regrtest; fixup list of failing tests +- introduce "pyshortver", "SOABI_optimized" and "SOABI_debug" macros +- rework manifests of shared libraries to use "SOABI_" macros, reflecting +PEP 3149 +- drop itertools, operator and _collections modules from the manifests as py3k +commit r84058 moved these inside libpython; json/tests moved to test/json_tests +- move turtle code into the tkinter subpackage + +* Wed Nov 17 2010 David Malcolm - 3.2-0.5.a1 +- fix sysconfig to not rely on the -devel subpackage (rhbz#653058) + +* Thu Sep 9 2010 David Malcolm - 3.2-0.4.a1 +- move most of the content of the core package to the libs subpackage, given +that the libs aren't meaningfully usable without the standard libraries + +* Wed Sep 8 2010 David Malcolm - 3.2-0.3.a1 +- Move test.support to core package (rhbz#596258) +- Add various missing __pycache__ directories to payload + +* Sun Aug 22 2010 Toshio Kuratomi - 3.2-0.2.a1 +- Add __pycache__ directory for site-packages + +* Sun Aug 22 2010 Thomas Spura - 3.2-0.1.a1 +- on 64bit "stdlib" was still "/usr/lib/python*" (modify *lib64.patch) +- make find-provides-without-python-sonames.sh 64bit aware + +* Sat Aug 21 2010 David Malcolm - 3.2-0.0.a1 +- 3.2a1; add alphatag +- rework %%files in the light of PEP 3147 (__pycache__) +- drop our configuration patch to Setup.dist (patch 0): setup.py should do a +better job of things, and the %%files explicitly lists our modules (r82746 +appears to break the old way of doing things). This leads to various modules +changing from "foomodule.so" to "foo.so". It also leads to the optimized build +dropping the _sha1, _sha256 and _sha512 modules, but these are provided by +_hashlib; _weakref becomes a builtin module; xxsubtype goes away (it's only for +testing/devel purposes) +- fixup patches 3, 4, 6, 8, 102, 103, 105, 111 for the rebase +- remove upstream patches: 7 (system expat), 106, 107, 108 (audioop reformat +plus CVE-2010-1634 and CVE-2010-2089), 109 (CVE-2008-5983) +- add machinery for rebuilding "configure" and friends, using the correct +version of autoconf (patch 300) +- patch the debug build's usage of COUNT_ALLOCS to be less verbose (patch 125) +- "modulator" was removed upstream +- drop "-b" from patch applications affecting .py files to avoid littering the +installation tree + +* Thu Aug 19 2010 Toshio Kuratomi - 3.1.2-13 +- Turn on computed-gotos. +- Fix for parallel make and graminit.c + +* Fri Jul 2 2010 David Malcolm - 3.1.2-12 +- rebuild + +* Fri Jul 2 2010 David Malcolm - 3.1.2-11 +- Fix an incompatibility between pyexpat and the system expat-2.0.1 that led to +a segfault running test_pyexpat.py (patch 110; upstream issue 9054; rhbz#610312) + +* Fri Jun 4 2010 David Malcolm - 3.1.2-10 +- ensure that the compiler is invoked with "-fwrapv" (rhbz#594819) +- reformat whitespace in audioop.c (patch 106) +- CVE-2010-1634: fix various integer overflow checks in the audioop +module (patch 107) +- CVE-2010-2089: further checks within the audioop module (patch 108) +- CVE-2008-5983: the new PySys_SetArgvEx entry point from r81399 (patch 109) + +* Thu May 27 2010 Dan Horák - 3.1.2-9 +- reading the timestamp counter is available only on some arches (see Python/ceval.c) + +* Wed May 26 2010 David Malcolm - 3.1.2-8 +- add flags for statvfs.f_flag to the constant list in posixmodule (i.e. "os") +(patch 105) + +* Tue May 25 2010 David Malcolm - 3.1.2-7 +- add configure-time support for COUNT_ALLOCS and CALL_PROFILE debug options +(patch 104); enable them and the WITH_TSC option within the debug build + +* Mon May 24 2010 David Malcolm - 3.1.2-6 +- build and install two different configurations of Python 3: debug and +standard, packaging the debug build in a new "python3-debug" subpackage +(patch 103) + +* Tue Apr 13 2010 David Malcolm - 3.1.2-5 +- exclude test_http_cookies when running selftests, due to hang seen on +http://koji.fedoraproject.org/koji/taskinfo?taskID=2088463 (cancelled after +11 hours) +- update python-gdb.py from v5 to py3k version submitted upstream + +* Wed Mar 31 2010 David Malcolm - 3.1.2-4 +- update python-gdb.py from v4 to v5 (improving performance and stability, +adding commands) + +* Thu Mar 25 2010 David Malcolm - 3.1.2-3 +- update python-gdb.py from v3 to v4 (fixing infinite recursion on reference +cycles and tracebacks on bytes 0x80-0xff in strings, adding handlers for sets +and exceptions) + +* Wed Mar 24 2010 David Malcolm - 3.1.2-2 +- refresh gdb hooks to v3 (reworking how they are packaged) + +* Sun Mar 21 2010 David Malcolm - 3.1.2-1 +- update to 3.1.2: http://www.python.org/download/releases/3.1.2/ +- drop upstreamed patch 2 (.pyc permissions handling) +- drop upstream patch 5 (fix for the test_tk and test_ttk_* selftests) +- drop upstreamed patch 200 (path-fixing script) + +* Sat Mar 20 2010 David Malcolm - 3.1.1-28 +- fix typo in libpython.stp (rhbz:575336) + +* Fri Mar 12 2010 David Malcolm - 3.1.1-27 +- add pyfuntop.stp example (source 7) +- convert usage of $$RPM_BUILD_ROOT to %%{buildroot} throughout, for +consistency with python.spec + +* Mon Feb 15 2010 Thomas Spura - 3.1.1-26 +- rebuild for new package of redhat-rpm-config (rhbz:564527) +- use 'install -p' when running 'make install' + +* Fri Feb 12 2010 David Malcolm - 3.1.1-25 +- split configure options into multiple lines for easy of editing +- add systemtap static markers (wcohen, mjw, dmalcolm; patch 8), a systemtap +tapset defining "python.function.entry" and "python.function.return" to make +the markers easy to use (dmalcolm; source 5), and an example of using the +tapset to the docs (dmalcolm; source 6) (rhbz:545179) + +* Mon Feb 8 2010 David Malcolm - 3.1.1-24 +- move the -gdb.py file from %%{_libdir}/INSTSONAME-gdb.py to +%%{_prefix}/lib/debug/%%{_libdir}/INSTSONAME.debug-gdb.py to avoid noise from +ldconfig (bug 562980), and which should also ensure it becomes part of the +debuginfo subpackage, rather than the libs subpackage +- introduce %%{py_SOVERSION} and %%{py_INSTSONAME} to reflect the upstream +configure script, and to avoid fragile scripts that try to figure this out +dynamically (e.g. for the -gdb.py change) + +* Mon Feb 8 2010 David Malcolm - 3.1.1-23 +- add gdb hooks for easier debugging (Source 4) + +* Thu Jan 28 2010 David Malcolm - 3.1.1-22 +- update python-3.1.1-config.patch to remove downstream customization of build +of pyexpat and elementtree modules +- add patch adapted from upstream (patch 7) to add support for building against +system expat; add --with-system-expat to "configure" invocation +- remove embedded copies of expat and zlib from source tree during "prep" + +* Mon Jan 25 2010 David Malcolm - 3.1.1-21 +- introduce %%{dynload_dir} macro +- explicitly list all lib-dynload files, rather than dynamically gathering the +payload into a temporary text file, so that we can be sure what we are +shipping +- introduce a macros.pybytecompile source file, to help with packaging python3 +modules (Source3; written by Toshio) +- rename "2to3-3" to "python3-2to3" to better reflect python 3 module packaging +plans + +* Mon Jan 25 2010 David Malcolm - 3.1.1-20 +- change python-3.1.1-config.patch to remove our downstream change to curses +configuration in Modules/Setup.dist, so that the curses modules are built using +setup.py with the downstream default (linking against libncursesw.so, rather +than libncurses.so), rather than within the Makefile; add a test to %%install +to verify the dso files that the curses module is linked against the correct +DSO (bug 539917; changes _cursesmodule.so -> _curses.so) + +* Fri Jan 22 2010 David Malcolm - 3.1.1-19 +- add %%py3dir macro to macros.python3 (to be used during unified python 2/3 +builds for setting up the python3 copy of the source tree) + +* Wed Jan 20 2010 David Malcolm - 3.1.1-18 +- move lib2to3 from -tools subpackage to main package (bug 556667) + +* Sun Jan 17 2010 David Malcolm - 3.1.1-17 +- patch Makefile.pre.in to avoid building static library (patch 6, bug 556092) + +* Fri Jan 15 2010 David Malcolm - 3.1.1-16 +- use the %%{_isa} macro to ensure that the python-devel dependency on python +is for the correct multilib arch (#555943) +- delete bundled copy of libffi to make sure we use the system one + +* Fri Jan 15 2010 David Malcolm - 3.1.1-15 +- fix the URLs output by pydoc so they point at python.org's 3.1 build of the +docs, rather than the 2.6 build + +* Wed Jan 13 2010 David Malcolm - 3.1.1-14 +- replace references to /usr with %%{_prefix}; replace references to +/usr/include with %%{_includedir} (Toshio) + +* Mon Jan 11 2010 David Malcolm - 3.1.1-13 +- fix permission on find-provides-without-python-sonames.sh from 775 to 755 + +* Mon Jan 11 2010 David Malcolm - 3.1.1-12 +- remove build-time requirements on tix and tk, since we already have +build-time requirements on the -devel subpackages for each of these (Thomas +Spura) +- replace usage of %%define with %%global (Thomas Spura) +- remove forcing of CC=gcc as this old workaround for bug 109268 appears to +longer be necessary +- move various test files from the "tools"/"tkinter" subpackages to the "test" +subpackage + +* Thu Jan 7 2010 David Malcolm - 3.1.1-11 +- add %%check section (thanks to Thomas Spura) +- update patch 4 to use correct shebang line +- get rid of stray patch file from buildroot + +* Tue Nov 17 2009 Andrew McNabb - 3.1.1-10 +- switched a few instances of "find |xargs" to "find -exec" for consistency. +- made the description of __os_install_post more accurate. + +* Wed Nov 4 2009 David Malcolm - 3.1.1-9 +- add macros.python3 to the -devel subpackage, containing common macros for use +when packaging python3 modules + +* Tue Nov 3 2009 David Malcolm - 3.1.1-8 +- add a provides of "python(abi)" (see bug 532118) +- fix issues identified by a.badger in package review (bug 526126, comment 39): + - use "3" thoughout metadata, rather than "3.*" + - remove conditional around "pkg-config openssl" + - use standard cleanup of RPM_BUILD_ROOT + - replace hardcoded references to /usr with _prefix macro + - stop removing egg-info files + - use /usr/bin/python3.1 rather than /use/bin/env python3.1 when fixing +up shebang lines + - stop attempting to remove no-longer-present .cvsignore files + - move the post/postun sections above the "files" sections + +* Thu Oct 29 2009 David Malcolm - 3.1.1-7 +- remove commented-away patch 51 (python-2.6-distutils_rpm.patch): the -O1 +flag is used by default in the upstream code +- "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) + +* Tue Oct 27 2009 David Malcolm - 3.1.1-6 +- reword description, based on suggestion by amcnabb +- fix the test_email and test_imp selftests (patch 3 and patch 4 respectively) +- fix the test_tk and test_ttk_* selftests (patch 5) +- fix up the specfile's handling of shebang/perms to avoid corrupting +test_httpservers.py (sed command suggested by amcnabb) + +* Thu Oct 22 2009 David Malcolm - 3.1.1-5 +- fixup importlib/_bootstrap.py so that it correctly handles being unable to +open .pyc files for writing (patch 2, upstream issue 7187) +- actually apply the rpath patch (patch 1) + +* Thu Oct 22 2009 David Malcolm - 3.1.1-4 +- update patch0's setup of the crypt module to link it against libcrypt +- update patch0 to comment "datetimemodule" back out, so that it is built +using setup.py (see Setup, option 3), thus linking it statically against +timemodule.c and thus avoiding a run-time "undefined symbol: +_PyTime_DoubleToTimet" failure on "import datetime" + +* Wed Oct 21 2009 David Malcolm - 3.1.1-3 +- remove executable flag from various files that shouldn't have it +- fix end-of-line encodings +- fix a character encoding + +* Tue Oct 20 2009 David Malcolm - 3.1.1-2 +- disable invocation of brp-python-bytecompile in postprocessing, since +it would be with the wrong version of python (adapted from ivazquez' +python3000 specfile) +- use a custom implementation of __find_provides in order to filter out bogus +provides lines for the various .so modules +- fixup distutils/unixccompiler.py to remove standard library path from rpath +(patch 1, was Patch0 in ivazquez' python3000 specfile) +- split out libraries into a -libs subpackage +- update summaries and descriptions, basing content on ivazquez' specfile +- fixup executable permissions on .py, .xpm and .xbm files, based on work in +ivazquez's specfile +- get rid of DOS batch files +- fixup permissions for shared libraries from non-standard 555 to standard 755 +- move /usr/bin/python*-config to the -devel subpackage +- mark various directories as being documentation + +* Thu Sep 24 2009 Andrew McNabb 3.1.1-1 +- Initial package for Python 3.