diff --git a/tests/.fmf/version b/.fmf/version similarity index 100% rename from tests/.fmf/version rename to .fmf/version diff --git a/00001-rpath.patch b/00001-rpath.patch index 170908e..cd063e5 100644 --- a/00001-rpath.patch +++ b/00001-rpath.patch @@ -1,15 +1,16 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: David Malcolm Date: Wed, 13 Jan 2010 21:25:18 +0000 -Subject: [PATCH] 00001: Fixup distutils/unixccompiler.py to remove standard - library path from rpath Was Patch0 in ivazquez' python3000 specfile +Subject: 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 f0792de74a..4d837936c6 100644 +index d00c48981e..0283a28c19 100644 --- a/Lib/distutils/unixccompiler.py +++ b/Lib/distutils/unixccompiler.py @@ -82,6 +82,15 @@ class UnixCCompiler(CCompiler): diff --git a/00251-change-user-install-location.patch b/00251-change-user-install-location.patch index 15aead0..7b68621 100644 --- a/00251-change-user-install-location.patch +++ b/00251-change-user-install-location.patch @@ -1,50 +1,70 @@ From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: Michal Cyprian -Date: Mon, 26 Jun 2017 16:32:56 +0200 -Subject: [PATCH] 00251: Change user install location +From: =?UTF-8?q?Miro=20Hron=C4=8Dok?= +Date: Mon, 15 Feb 2021 12:19:27 +0100 +Subject: 00251: Change user install location +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Set values of base and platbase in sysconfig from /usr +to /usr/local when RPM build is not detected +to make pip and similar tools install into separate 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. +is not detected to make distutils and pypa/distutils install into separate location. Fedora Change: https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe -Downstream only: Awaiting resources to work on upstream PEP +Downstream only. + +We've tried to rework in Fedora 36/Python 3.10 to follow https://bugs.python.org/issue43976 +but we have identified serious problems with that approach, +see https://bugzilla.redhat.com/2026979 or https://bugzilla.redhat.com/2097183 + +pypa/distutils integration: https://github.com/pypa/distutils/pull/70 + +Co-authored-by: Petr Viktorin +Co-authored-by: Miro Hrončok +Co-authored-by: Michal Cyprian +Co-authored-by: Lumír Balhar --- - Lib/distutils/command/install.py | 15 +++++++++++++-- - Lib/site.py | 9 ++++++++- - 2 files changed, 21 insertions(+), 3 deletions(-) + Lib/distutils/command/install.py | 8 +++-- + Lib/site.py | 9 +++++- + Lib/sysconfig.py | 53 +++++++++++++++++++++++++++++++- + Lib/test/test_sysconfig.py | 17 ++++++++-- + 4 files changed, 81 insertions(+), 6 deletions(-) diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py -index d33a889afe..41c6165cd8 100644 +index 01d5331a63..79f70f0de4 100644 --- a/Lib/distutils/command/install.py +++ b/Lib/distutils/command/install.py -@@ -431,8 +431,19 @@ def finalize_unix(self): +@@ -159,6 +159,8 @@ class install(Command): + + negative_opt = {'no-compile' : 'compile'} + ++ # Allow Fedora to add components to the prefix ++ _prefix_addition = getattr(sysconfig, '_prefix_addition', '') + + def initialize_options(self): + """Initializes options.""" +@@ -441,8 +443,10 @@ def finalize_unix(self): 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 ++ self.prefix = ( ++ os.path.normpath(sys.prefix) + self._prefix_addition) ++ self.exec_prefix = ( ++ os.path.normpath(sys.exec_prefix) + self._prefix_addition) else: if self.exec_prefix is None: diff --git a/Lib/site.py b/Lib/site.py -index 939893eb5e..d1316c3355 100644 +index 5302037e0b..4ef002c6bc 100644 --- a/Lib/site.py +++ b/Lib/site.py -@@ -380,8 +380,15 @@ def getsitepackages(prefixes=None): +@@ -390,8 +390,15 @@ def getsitepackages(prefixes=None): return sitepackages def addsitepackages(known_paths, prefixes=None): @@ -61,3 +81,128 @@ index 939893eb5e..d1316c3355 100644 for sitedir in getsitepackages(prefixes): if os.path.isdir(sitedir): addsitedir(sitedir, known_paths) +diff --git a/Lib/sysconfig.py b/Lib/sysconfig.py +index daf9f00006..10368c92a7 100644 +--- a/Lib/sysconfig.py ++++ b/Lib/sysconfig.py +@@ -58,6 +58,16 @@ + }, + } + ++# For a brief period of time in the Fedora 36 life cycle, ++# this installation scheme existed and was documented in the release notes. ++# For backwards compatibility, we keep it here (at least on 3.10 and 3.11). ++_INSTALL_SCHEMES['rpm_prefix'] = _INSTALL_SCHEMES['posix_prefix'] ++# Virtualenv >= 20.10.0 favors the "venv" scheme over the defaults when creating virtual environments. ++# See: https://github.com/pypa/virtualenv/commit/8da79db86d8a5c74d03667a40e64ff832076445e ++# See: https://bugs.python.org/issue45413 ++# "venv" should be the same as the posix_prefix for us, ++# so new virtual environments aren't created with paths like venv/local/bin/python. ++_INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['posix_prefix'] + + # NOTE: site.py has copy of this function. + # Sync it when modify this function. +@@ -117,6 +127,19 @@ def joinuser(*args): + }, + } + ++# This is used by distutils.command.install in the stdlib ++# as well as pypa/distutils (e.g. bundled in setuptools). ++# The self.prefix value is set to sys.prefix + /local/ ++# if neither RPM build nor virtual environment is ++# detected to make distutils install packages ++# into the separate location. ++# https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe ++if (not (hasattr(sys, 'real_prefix') or ++ sys.prefix != sys.base_prefix) and ++ 'RPM_BUILD_ROOT' not in os.environ): ++ _prefix_addition = '/local' ++ ++ + _SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include', + 'scripts', 'data') + +@@ -211,11 +234,39 @@ def _extend_dict(target_dict, other_dict): + target_dict[key] = value + + ++_CONFIG_VARS_LOCAL = None ++ ++ ++def _config_vars_local(): ++ # This function returns the config vars with prefixes amended to /usr/local ++ # https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe ++ global _CONFIG_VARS_LOCAL ++ if _CONFIG_VARS_LOCAL is None: ++ _CONFIG_VARS_LOCAL = dict(get_config_vars()) ++ _CONFIG_VARS_LOCAL['base'] = '/usr/local' ++ _CONFIG_VARS_LOCAL['platbase'] = '/usr/local' ++ return _CONFIG_VARS_LOCAL ++ ++ + def _expand_vars(scheme, vars): + res = {} + if vars is None: + vars = {} +- _extend_dict(vars, get_config_vars()) ++ ++ # when we are not in a virtual environment or an RPM build ++ # we change '/usr' to '/usr/local' ++ # to avoid surprises, we explicitly check for the /usr/ prefix ++ # Python virtual environments have different prefixes ++ # we only do this for posix_prefix, not to mangle the venv scheme ++ # posix_prefix is used by sudo pip install ++ # we only change the defaults here, so explicit --prefix will take precedence ++ # https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe ++ if (scheme == 'posix_prefix' and ++ _PREFIX == '/usr' and ++ 'RPM_BUILD_ROOT' not in os.environ): ++ _extend_dict(vars, _config_vars_local()) ++ else: ++ _extend_dict(vars, get_config_vars()) + + for key, value in _INSTALL_SCHEMES[scheme].items(): + if os.name in ('posix', 'nt'): +diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py +index 5ee9839c04..16e92ca86f 100644 +--- a/Lib/test/test_sysconfig.py ++++ b/Lib/test/test_sysconfig.py +@@ -105,8 +105,19 @@ def test_get_path(self): + for scheme in _INSTALL_SCHEMES: + for name in _INSTALL_SCHEMES[scheme]: + expected = _INSTALL_SCHEMES[scheme][name].format(**config_vars) ++ tested = get_path(name, scheme) ++ # https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe ++ if tested.startswith('/usr/local'): ++ # /usr/local should only be used in posix_prefix ++ self.assertEqual(scheme, 'posix_prefix') ++ # Fedora CI runs tests for venv and virtualenv that check for other prefixes ++ self.assertEqual(sys.prefix, '/usr') ++ # When building the RPM of Python, %check runs this with RPM_BUILD_ROOT set ++ # Fedora CI runs this with RPM_BUILD_ROOT unset ++ self.assertNotIn('RPM_BUILD_ROOT', os.environ) ++ tested = tested.replace('/usr/local', '/usr') + self.assertEqual( +- os.path.normpath(get_path(name, scheme)), ++ os.path.normpath(tested), + os.path.normpath(expected), + ) + +@@ -263,7 +274,7 @@ def test_get_config_h_filename(self): + self.assertTrue(os.path.isfile(config_h), config_h) + + def test_get_scheme_names(self): +- wanted = ['nt', 'posix_home', 'posix_prefix'] ++ wanted = ['nt', 'posix_home', 'posix_prefix', 'rpm_prefix', 'venv'] + if HAS_USER_BASE: + wanted.extend(['nt_user', 'osx_framework_user', 'posix_user']) + self.assertEqual(get_scheme_names(), tuple(sorted(wanted))) +@@ -274,6 +285,8 @@ def test_symlink(self): # Issue 7880 + cmd = "-c", "import sysconfig; print(sysconfig.get_platform())" + self.assertEqual(py.call_real(*cmd), py.call_link(*cmd)) + ++ @unittest.skipIf('RPM_BUILD_ROOT' not in os.environ, ++ "Test doesn't expect Fedora's paths") + def test_user_similar(self): + # Issue #8759: make sure the posix scheme for the users + # is similar to the global posix_prefix one diff --git a/00328-pyc-timestamp-invalidation-mode.patch b/00328-pyc-timestamp-invalidation-mode.patch deleted file mode 100644 index 011e0f6..0000000 --- a/00328-pyc-timestamp-invalidation-mode.patch +++ /dev/null @@ -1,54 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Miro=20Hron=C4=8Dok?= -Date: Thu, 11 Jul 2019 13:44:13 +0200 -Subject: [PATCH] 00328: Restore pyc to TIMESTAMP invalidation mode as default - in rpmbuild - -Since Fedora 31, the $SOURCE_DATE_EPOCH is set in rpmbuild to the latest -%changelog date. This makes Python default to the CHECKED_HASH pyc -invalidation mode, bringing more reproducible builds traded for an import -performance decrease. To avoid that, we don't default to CHECKED_HASH -when $RPM_BUILD_ROOT is set (i.e. when we are building RPM packages). - -See https://src.fedoraproject.org/rpms/redhat-rpm-config/pull-request/57#comment-27426 -Downstream only: only used when building RPM packages -Ideally, we should talk to upstream and explain why we don't want this ---- - Lib/py_compile.py | 3 ++- - Lib/test/test_py_compile.py | 2 ++ - 2 files changed, 4 insertions(+), 1 deletion(-) - -diff --git a/Lib/py_compile.py b/Lib/py_compile.py -index 0f9b59025c..59dc3fe50b 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 b58f28a4bc..7ede33d6c9 100644 ---- a/Lib/test/test_py_compile.py -+++ b/Lib/test/test_py_compile.py -@@ -19,6 +19,7 @@ def without_source_date_epoch(fxn): - def wrapper(*args, **kwargs): - with os_helper.EnvironmentVarGuard() as env: - env.unset('SOURCE_DATE_EPOCH') -+ env.unset('RPM_BUILD_ROOT') - return fxn(*args, **kwargs) - return wrapper - -@@ -29,6 +30,7 @@ def with_source_date_epoch(fxn): - def wrapper(*args, **kwargs): - with os_helper.EnvironmentVarGuard() as env: - env['SOURCE_DATE_EPOCH'] = '123456789' -+ env.unset('RPM_BUILD_ROOT') - return fxn(*args, **kwargs) - return wrapper - diff --git a/00371-revert-bpo-1596321-fix-threading-_shutdown-for-the-main-thread-gh-28549-gh-28589.patch b/00371-revert-bpo-1596321-fix-threading-_shutdown-for-the-main-thread-gh-28549-gh-28589.patch new file mode 100644 index 0000000..7dbd3bb --- /dev/null +++ b/00371-revert-bpo-1596321-fix-threading-_shutdown-for-the-main-thread-gh-28549-gh-28589.patch @@ -0,0 +1,103 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Hrn=C4=8Diar?= +Date: Tue, 7 Dec 2021 14:41:59 +0100 +Subject: 00371: Revert "bpo-1596321: Fix threading._shutdown() for the main + thread (GH-28549) (GH-28589)" + +This reverts commit 38c67738c64304928c68d5c2bd78bbb01d979b94. It +introduced regression causing FreeIPA's tests to fail. + +For more info see: +https://bodhi.fedoraproject.org/updates/FEDORA-2021-e152ce5f31 +https://github.com/GrahamDumpleton/mod_wsgi/issues/730 +--- + Lib/test/test_threading.py | 33 --------------------------------- + Lib/threading.py | 25 ++++++++----------------- + 2 files changed, 8 insertions(+), 50 deletions(-) + +diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py +index c54806e594..c51de6f4b8 100644 +--- a/Lib/test/test_threading.py ++++ b/Lib/test/test_threading.py +@@ -928,39 +928,6 @@ def test_debug_deprecation(self): + b'is deprecated and will be removed in Python 3.12') + self.assertIn(msg, err) + +- def test_import_from_another_thread(self): +- # bpo-1596321: If the threading module is first import from a thread +- # different than the main thread, threading._shutdown() must handle +- # this case without logging an error at Python exit. +- code = textwrap.dedent(''' +- import _thread +- import sys +- +- event = _thread.allocate_lock() +- event.acquire() +- +- def import_threading(): +- import threading +- event.release() +- +- if 'threading' in sys.modules: +- raise Exception('threading is already imported') +- +- _thread.start_new_thread(import_threading, ()) +- +- # wait until the threading module is imported +- event.acquire() +- event.release() +- +- if 'threading' not in sys.modules: +- raise Exception('threading is not imported') +- +- # don't wait until the thread completes +- ''') +- rc, out, err = assert_python_ok("-c", code) +- self.assertEqual(out, b'') +- self.assertEqual(err, b'') +- + + class ThreadJoinOnShutdown(BaseTestCase): + +diff --git a/Lib/threading.py b/Lib/threading.py +index 62f49c05cd..433aa11212 100644 +--- a/Lib/threading.py ++++ b/Lib/threading.py +@@ -1530,29 +1530,20 @@ def _shutdown(): + + global _SHUTTING_DOWN + _SHUTTING_DOWN = True ++ # Main thread ++ tlock = _main_thread._tstate_lock ++ # The main thread isn't finished yet, so its thread state lock can't have ++ # been released. ++ assert tlock is not None ++ assert tlock.locked() ++ tlock.release() ++ _main_thread._stop() + + # Call registered threading atexit functions before threads are joined. + # Order is reversed, similar to atexit. + for atexit_call in reversed(_threading_atexits): + atexit_call() + +- # Main thread +- if _main_thread.ident == get_ident(): +- tlock = _main_thread._tstate_lock +- # The main thread isn't finished yet, so its thread state lock can't +- # have been released. +- assert tlock is not None +- assert tlock.locked() +- tlock.release() +- _main_thread._stop() +- else: +- # bpo-1596321: _shutdown() must be called in the main thread. +- # If the threading module was not imported by the main thread, +- # _main_thread is the thread which imported the threading module. +- # In this case, ignore _main_thread, similar behavior than for threads +- # spawned by C libraries or using _thread.start_new_thread(). +- pass +- + # Join all non-deamon threads + while True: + with _shutdown_locks_lock: diff --git a/00452-properly-apply-exported-cflags-for-dtrace-systemtap-builds.patch b/00452-properly-apply-exported-cflags-for-dtrace-systemtap-builds.patch new file mode 100644 index 0000000..2e2f3c6 --- /dev/null +++ b/00452-properly-apply-exported-cflags-for-dtrace-systemtap-builds.patch @@ -0,0 +1,51 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: "Miss Islington (bot)" + <31488909+miss-islington@users.noreply.github.com> +Date: Mon, 31 Mar 2025 20:29:04 +0200 +Subject: 00452: Properly apply exported CFLAGS for dtrace/systemtap builds + +When using --with-dtrace the resulting object file could be missing +specific CFLAGS exported by the build system due to the systemtap +script using specific defaults. + +Exporting the CC and CFLAGS variables before the dtrace invocation +allows us to properly apply CFLAGS exported by the build system +even when cross-compiling. + +Co-authored-by: stratakis +--- + Makefile.pre.in | 4 ++-- + .../next/Build/2025-03-31-19-22-41.gh-issue-131865.PIJy7X.rst | 2 ++ + 2 files changed, 4 insertions(+), 2 deletions(-) + create mode 100644 Misc/NEWS.d/next/Build/2025-03-31-19-22-41.gh-issue-131865.PIJy7X.rst + +diff --git a/Makefile.pre.in b/Makefile.pre.in +index fa99dd86c4..e9ba702a5c 100644 +--- a/Makefile.pre.in ++++ b/Makefile.pre.in +@@ -1001,7 +1001,7 @@ Python/frozen.o: $(srcdir)/Python/importlib.h $(srcdir)/Python/importlib_externa + # an include guard, so we can't use a pipeline to transform its output. + Include/pydtrace_probes.h: $(srcdir)/Include/pydtrace.d + $(MKDIR_P) Include +- $(DTRACE) $(DFLAGS) -o $@ -h -s $< ++ CC="$(CC)" CFLAGS="$(CFLAGS)" $(DTRACE) $(DFLAGS) -o $@ -h -s $< + : sed in-place edit with POSIX-only tools + sed 's/PYTHON_/PyDTrace_/' $@ > $@.tmp + mv $@.tmp $@ +@@ -1011,7 +1011,7 @@ Python/import.o: $(srcdir)/Include/pydtrace.h + Modules/gcmodule.o: $(srcdir)/Include/pydtrace.h + + Python/pydtrace.o: $(srcdir)/Include/pydtrace.d $(DTRACE_DEPS) +- $(DTRACE) $(DFLAGS) -o $@ -G -s $< $(DTRACE_DEPS) ++ CC="$(CC)" CFLAGS="$(CFLAGS)" $(DTRACE) $(DFLAGS) -o $@ -G -s $< $(DTRACE_DEPS) + + Objects/typeobject.o: Objects/typeslots.inc + +diff --git a/Misc/NEWS.d/next/Build/2025-03-31-19-22-41.gh-issue-131865.PIJy7X.rst b/Misc/NEWS.d/next/Build/2025-03-31-19-22-41.gh-issue-131865.PIJy7X.rst +new file mode 100644 +index 0000000000..a287e0b228 +--- /dev/null ++++ b/Misc/NEWS.d/next/Build/2025-03-31-19-22-41.gh-issue-131865.PIJy7X.rst +@@ -0,0 +1,2 @@ ++The DTrace build now properly passes the ``CC`` and ``CFLAGS`` variables ++to the ``dtrace`` command when utilizing SystemTap on Linux. diff --git a/00462-fix-pyssl_seterror-handling-ssl_error_syscall.patch b/00462-fix-pyssl_seterror-handling-ssl_error_syscall.patch new file mode 100644 index 0000000..1eaf3a2 --- /dev/null +++ b/00462-fix-pyssl_seterror-handling-ssl_error_syscall.patch @@ -0,0 +1,214 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: yevgeny hong +Date: Tue, 26 Mar 2024 16:45:43 +0900 +Subject: 00462: Fix PySSL_SetError handling SSL_ERROR_SYSCALL + +Python 3.10 changed from using SSL_write() and SSL_read() to SSL_write_ex() and +SSL_read_ex(), but did not update handling of the return value. + +Change error handling so that the return value is not examined. +OSError (not EOF) is now returned when retval is 0. + +This resolves the issue of failing tests when a system is +stressed on OpenSSL 3.5. + +Co-authored-by: Serhiy Storchaka +Co-authored-by: Petr Viktorin +--- + Lib/test/test_ssl.py | 41 +++++++--------- + ...-02-18-09-50-31.gh-issue-115627.HGchj0.rst | 2 + + Modules/_ssl.c | 48 +++++++------------ + 3 files changed, 38 insertions(+), 53 deletions(-) + create mode 100644 Misc/NEWS.d/next/Library/2024-02-18-09-50-31.gh-issue-115627.HGchj0.rst + +diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py +index f4bba8ff03..f772bd6ab6 100644 +--- a/Lib/test/test_ssl.py ++++ b/Lib/test/test_ssl.py +@@ -2607,16 +2607,18 @@ def run(self): + self.write(msg.lower()) + except OSError as e: + # handles SSLError and socket errors ++ if isinstance(e, ConnectionError): ++ # OpenSSL 1.1.1 sometimes raises ++ # ConnectionResetError when connection is not ++ # shut down gracefully. ++ if self.server.chatty and support.verbose: ++ print(f" Connection reset by peer: {self.addr}") ++ ++ self.close() ++ self.running = False ++ return + if self.server.chatty and support.verbose: +- if isinstance(e, ConnectionError): +- # OpenSSL 1.1.1 sometimes raises +- # ConnectionResetError when connection is not +- # shut down gracefully. +- print( +- f" Connection reset by peer: {self.addr}" +- ) +- else: +- handle_error("Test server failure:\n") ++ handle_error("Test server failure:\n") + try: + self.write(b"ERROR\n") + except OSError: +@@ -3298,23 +3300,16 @@ def test_wrong_cert_tls13(self): + client_context.wrap_socket(socket.socket(), + server_hostname=hostname, + suppress_ragged_eofs=False) as s: +- # TLS 1.3 perform client cert exchange after handshake + s.connect((HOST, server.port)) +- try: ++ with self.assertRaisesRegex( ++ OSError, ++ 'alert unknown ca|EOF occurred|TLSV1_ALERT_UNKNOWN_CA|closed by the remote host|Connection reset by peer' ++ ): ++ # TLS 1.3 perform client cert exchange after handshake + s.write(b'data') + s.read(1000) + s.write(b'should have failed already') + s.read(1000) +- except ssl.SSLError as e: +- if support.verbose: +- sys.stdout.write("\nSSLError is %r\n" % e) +- except OSError as e: +- if e.errno != errno.ECONNRESET: +- raise +- if support.verbose: +- sys.stdout.write("\nsocket.error is %r\n" % e) +- else: +- self.fail("Use of invalid cert should have failed!") + + def test_rude_shutdown(self): + """A brutal shutdown of an SSL server should raise an OSError +@@ -4560,8 +4555,8 @@ def msg_cb(conn, direction, version, content_type, msg_type, data): + # test sometimes fails with EOF error. Test passes as long as + # server aborts connection with an error. + with self.assertRaisesRegex( +- ssl.SSLError, +- '(certificate required|EOF occurred)' ++ OSError, ++ 'certificate required|EOF occurred|closed by the remote host|Connection reset by peer' + ): + # receive CertificateRequest + data = s.recv(1024) +diff --git a/Misc/NEWS.d/next/Library/2024-02-18-09-50-31.gh-issue-115627.HGchj0.rst b/Misc/NEWS.d/next/Library/2024-02-18-09-50-31.gh-issue-115627.HGchj0.rst +new file mode 100644 +index 0000000000..75d926ab59 +--- /dev/null ++++ b/Misc/NEWS.d/next/Library/2024-02-18-09-50-31.gh-issue-115627.HGchj0.rst +@@ -0,0 +1,2 @@ ++Fix the :mod:`ssl` module error handling of connection terminate by peer. ++It now throws an OSError with the appropriate error code instead of an EOFError. +diff --git a/Modules/_ssl.c b/Modules/_ssl.c +index af770c7f18..7b3cf61474 100644 +--- a/Modules/_ssl.c ++++ b/Modules/_ssl.c +@@ -582,7 +582,7 @@ PySSL_ChainExceptions(PySSLSocket *sslsock) { + } + + static PyObject * +-PySSL_SetError(PySSLSocket *sslsock, int ret, const char *filename, int lineno) ++PySSL_SetError(PySSLSocket *sslsock, const char *filename, int lineno) + { + PyObject *type; + char *errstr = NULL; +@@ -595,7 +595,6 @@ PySSL_SetError(PySSLSocket *sslsock, int ret, const char *filename, int lineno) + _sslmodulestate *state = get_state_sock(sslsock); + type = state->PySSLErrorObject; + +- assert(ret <= 0); + e = ERR_peek_last_error(); + + if (sslsock->ssl != NULL) { +@@ -628,32 +627,21 @@ PySSL_SetError(PySSLSocket *sslsock, int ret, const char *filename, int lineno) + case SSL_ERROR_SYSCALL: + { + if (e == 0) { +- PySocketSockObject *s = GET_SOCKET(sslsock); +- if (ret == 0 || (((PyObject *)s) == Py_None)) { ++ /* underlying BIO reported an I/O error */ ++ ERR_clear_error(); ++#ifdef MS_WINDOWS ++ if (err.ws) { ++ return PyErr_SetFromWindowsErr(err.ws); ++ } ++#endif ++ if (err.c) { ++ errno = err.c; ++ return PyErr_SetFromErrno(PyExc_OSError); ++ } ++ else { + p = PY_SSL_ERROR_EOF; + type = state->PySSLEOFErrorObject; + errstr = "EOF occurred in violation of protocol"; +- } else if (s && ret == -1) { +- /* underlying BIO reported an I/O error */ +- ERR_clear_error(); +-#ifdef MS_WINDOWS +- if (err.ws) { +- return PyErr_SetFromWindowsErr(err.ws); +- } +-#endif +- if (err.c) { +- errno = err.c; +- return PyErr_SetFromErrno(PyExc_OSError); +- } +- else { +- p = PY_SSL_ERROR_EOF; +- type = state->PySSLEOFErrorObject; +- errstr = "EOF occurred in violation of protocol"; +- } +- } else { /* possible? */ +- p = PY_SSL_ERROR_SYSCALL; +- type = state->PySSLSyscallErrorObject; +- errstr = "Some I/O error occurred"; + } + } else { + if (ERR_GET_LIB(e) == ERR_LIB_SYS) { +@@ -1014,7 +1002,7 @@ _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self) + err.ssl == SSL_ERROR_WANT_WRITE); + Py_XDECREF(sock); + if (ret < 1) +- return PySSL_SetError(self, ret, __FILE__, __LINE__); ++ return PySSL_SetError(self, __FILE__, __LINE__); + if (PySSL_ChainExceptions(self) < 0) + return NULL; + Py_RETURN_NONE; +@@ -2433,7 +2421,7 @@ _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b) + + Py_XDECREF(sock); + if (retval == 0) +- return PySSL_SetError(self, retval, __FILE__, __LINE__); ++ return PySSL_SetError(self, __FILE__, __LINE__); + if (PySSL_ChainExceptions(self) < 0) + return NULL; + return PyLong_FromSize_t(count); +@@ -2463,7 +2451,7 @@ _ssl__SSLSocket_pending_impl(PySSLSocket *self) + self->err = err; + + if (count < 0) +- return PySSL_SetError(self, count, __FILE__, __LINE__); ++ return PySSL_SetError(self, __FILE__, __LINE__); + else + return PyLong_FromLong(count); + } +@@ -2585,7 +2573,7 @@ _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len, + err.ssl == SSL_ERROR_WANT_WRITE); + + if (retval == 0) { +- PySSL_SetError(self, retval, __FILE__, __LINE__); ++ PySSL_SetError(self, __FILE__, __LINE__); + goto error; + } + if (self->exc_type != NULL) +@@ -2709,7 +2697,7 @@ _ssl__SSLSocket_shutdown_impl(PySSLSocket *self) + } + if (ret < 0) { + Py_XDECREF(sock); +- PySSL_SetError(self, ret, __FILE__, __LINE__); ++ PySSL_SetError(self, __FILE__, __LINE__); + return NULL; + } + if (self->exc_type != NULL) diff --git a/00474-cve-2025-15366.patch b/00474-cve-2025-15366.patch new file mode 100644 index 0000000..0b4fd18 --- /dev/null +++ b/00474-cve-2025-15366.patch @@ -0,0 +1,61 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Seth Michael Larson +Date: Tue, 20 Jan 2026 14:45:42 -0600 +Subject: 00474: CVE-2025-15366 + +gh-143921: Reject control characters in IMAP commands + +(cherry-picked from commit 6262704b134db2a4ba12e85ecfbd968534f28b45) +--- + Lib/imaplib.py | 4 +++- + Lib/test/test_imaplib.py | 6 ++++++ + .../Security/2026-01-16-11-41-06.gh-issue-143921.AeCOor.rst | 1 + + 3 files changed, 10 insertions(+), 1 deletion(-) + create mode 100644 Misc/NEWS.d/next/Security/2026-01-16-11-41-06.gh-issue-143921.AeCOor.rst + +diff --git a/Lib/imaplib.py b/Lib/imaplib.py +index 54122f985b..9ab8e43bbf 100644 +--- a/Lib/imaplib.py ++++ b/Lib/imaplib.py +@@ -132,7 +132,7 @@ + # We compile these in _mode_xxx. + _Literal = br'.*{(?P\d+)}$' + _Untagged_status = br'\* (?P\d+) (?P[A-Z-]+)( (?P.*))?' +- ++_control_chars = re.compile(b'[\x00-\x1F\x7F]') + + + class IMAP4: +@@ -994,6 +994,8 @@ def _command(self, name, *args): + if arg is None: continue + if isinstance(arg, str): + arg = bytes(arg, self._encoding) ++ if _control_chars.search(arg): ++ raise ValueError("Control characters not allowed in commands") + data = data + b' ' + arg + + literal = self.literal +diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py +index f817707743..9ce59b3040 100644 +--- a/Lib/test/test_imaplib.py ++++ b/Lib/test/test_imaplib.py +@@ -505,6 +505,12 @@ def test_login(self): + self.assertEqual(data[0], b'LOGIN completed') + self.assertEqual(client.state, 'AUTH') + ++ def test_control_characters(self): ++ client, _ = self._setup(SimpleIMAPHandler) ++ for c0 in support.control_characters_c0(): ++ with self.assertRaises(ValueError): ++ client.login(f'user{c0}', 'pass') ++ + def test_logout(self): + client, _ = self._setup(SimpleIMAPHandler) + typ, data = client.login('user', 'pass') +diff --git a/Misc/NEWS.d/next/Security/2026-01-16-11-41-06.gh-issue-143921.AeCOor.rst b/Misc/NEWS.d/next/Security/2026-01-16-11-41-06.gh-issue-143921.AeCOor.rst +new file mode 100644 +index 0000000000..4e13fe92bc +--- /dev/null ++++ b/Misc/NEWS.d/next/Security/2026-01-16-11-41-06.gh-issue-143921.AeCOor.rst +@@ -0,0 +1 @@ ++Reject control characters in IMAP commands. diff --git a/00475-cve-2025-15367.patch b/00475-cve-2025-15367.patch new file mode 100644 index 0000000..9a64894 --- /dev/null +++ b/00475-cve-2025-15367.patch @@ -0,0 +1,61 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Seth Michael Larson +Date: Tue, 20 Jan 2026 14:46:32 -0600 +Subject: 00475: CVE-2025-15367 + +gh-143923: Reject control characters in POP3 commands + +(cherry-picked from commit b234a2b67539f787e191d2ef19a7cbdce32874e7) +--- + Lib/poplib.py | 2 ++ + Lib/test/test_poplib.py | 8 ++++++++ + .../2026-01-16-11-43-47.gh-issue-143923.DuytMe.rst | 1 + + 3 files changed, 11 insertions(+) + create mode 100644 Misc/NEWS.d/next/Security/2026-01-16-11-43-47.gh-issue-143923.DuytMe.rst + +diff --git a/Lib/poplib.py b/Lib/poplib.py +index 0f8587317c..f563030f7f 100644 +--- a/Lib/poplib.py ++++ b/Lib/poplib.py +@@ -122,6 +122,8 @@ def _putline(self, line): + def _putcmd(self, line): + if self._debugging: print('*cmd*', repr(line)) + line = bytes(line, self.encoding) ++ if re.search(b'[\x00-\x1F\x7F]', line): ++ raise ValueError('Control characters not allowed in commands') + self._putline(line) + + +diff --git a/Lib/test/test_poplib.py b/Lib/test/test_poplib.py +index 1220ca32ef..2655e366fd 100644 +--- a/Lib/test/test_poplib.py ++++ b/Lib/test/test_poplib.py +@@ -12,6 +12,7 @@ + import unittest + from unittest import TestCase, skipUnless + from test import support as test_support ++from test.support import control_characters_c0 + from test.support import hashlib_helper + from test.support import socket_helper + from test.support import threading_helper +@@ -365,6 +366,13 @@ def test_quit(self): + self.assertIsNone(self.client.sock) + self.assertIsNone(self.client.file) + ++ def test_control_characters(self): ++ for c0 in control_characters_c0(): ++ with self.assertRaises(ValueError): ++ self.client.user(f'user{c0}') ++ with self.assertRaises(ValueError): ++ self.client.pass_(f'{c0}pass') ++ + @requires_ssl + def test_stls_capa(self): + capa = self.client.capa() +diff --git a/Misc/NEWS.d/next/Security/2026-01-16-11-43-47.gh-issue-143923.DuytMe.rst b/Misc/NEWS.d/next/Security/2026-01-16-11-43-47.gh-issue-143923.DuytMe.rst +new file mode 100644 +index 0000000000..3cde4df3e0 +--- /dev/null ++++ b/Misc/NEWS.d/next/Security/2026-01-16-11-43-47.gh-issue-143923.DuytMe.rst +@@ -0,0 +1 @@ ++Reject control characters in POP3 commands. diff --git a/00494-increase-the-timeout-of-test_large_content_length_truncated.patch b/00494-increase-the-timeout-of-test_large_content_length_truncated.patch new file mode 100644 index 0000000..58ffd5d --- /dev/null +++ b/00494-increase-the-timeout-of-test_large_content_length_truncated.patch @@ -0,0 +1,23 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Karolina Surma +Date: Fri, 14 Aug 2026 09:38:26 +0200 +Subject: 00494: Increase the timeout of test_large_content_length_truncated + +It has started to fail randomly when run on s390x architecture. +--- + Lib/test/test_httpservers.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py +index 5eb3c82fbd..aa8ad1c323 100644 +--- a/Lib/test/test_httpservers.py ++++ b/Lib/test/test_httpservers.py +@@ -872,7 +872,7 @@ def test_large_content_length(self): + self.assertEqual(res.read(), b'%d %d' % (size, size) + self.linesep) + + def test_large_content_length_truncated(self): +- with support.swap_attr(self.request_handler, 'timeout', 0.001): ++ with support.swap_attr(self.request_handler, 'timeout', support.LOOPBACK_TIMEOUT): + for w in range(18, 65): + size = 1 << w + headers = {'Content-Length' : str(size)} diff --git a/check-pyc-timestamps.py b/check-pyc-timestamps.py index 91af4fd..e421fca 100644 --- a/check-pyc-timestamps.py +++ b/check-pyc-timestamps.py @@ -19,11 +19,9 @@ not_compiled = [ '*/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', + '*/lib2to3/tests/data/*.py', + '*/lib2to3/tests/data/*/*.py', + '*/lib2to3/tests/data/*/*/*.py', '*.debug-gdb.py', ] diff --git a/pgp_keys.asc b/pgp_keys.asc deleted file mode 100644 index 11dccb8..0000000 --- a/pgp_keys.asc +++ /dev/null @@ -1,109 +0,0 @@ ------BEGIN PGP PUBLIC KEY BLOCK----- - -mQINBFq+ToQBEADRYvIVtbK6owynD3j3nxwpW2KEk/p+aDvtXmc2SR2dBcZ8sFW2 -R5vEsG8d3/D3wgv5pcL3KfNNXQYUnXVbobrFUUWQYc79qIsE3MgiPf5NVOtwKPUR -i5g9YJgKvpBxkQfqp3LYGm9ZBtwo3DVLA3yn7KsazCmAgTNFJYw7ku1XxgmIzY6K -5J30DfbJiqDqj4f9GslCCCCH3qiPnuLG/HUyVLHMpbWlaiy9NI0GcaLxjJewHj9w -W2D2lydkxe5JGo7egUkV3ILcuLVSVKA35SKY27dYqfuyqp9tAzaRbjDYjsYdHA6G -BqrNrKBn/GwlFDPrVdcvN3ZSY2wMLTxWE3Axc/FweuHxFnou/80FwX7F3JD+oEQ6 -rofmcxOBCC7J98I7HZAhP9jBn88XIS2hztbLq8d6rZJZRtcz0k61VR0ddO+TrFmf -9rMYCPgCckRtVxeFIVIabrN1IzKynLFeo040h8hSGswd6YKDOVwjJY6Oa6EmVefZ -a8QSt4+M65RSzH6SEPY008F3nJUAK6MEkzTak+tFltZNrVWu8p2xd1j9nmxAwEhZ -/lgbxLqzYgaUWmfyHeZ8yVA0MhHzdiAL8nVUEdG3KecIq0RWCJLGLWWIjd6KAJl1 -yAmhRYKK/sjPDsL3elHsFACfZbyx3o5GGQNlas1FYoPLWbaNGaJtgFTF2QARAQAB -tCtQYWJsbyBHYWxpbmRvIFNhbGdhZG8gPHBhYmxvZ3NhbEBnbWFpbC5jb20+iQJO -BBMBCgA4FiEEoDXIwZIZuoIezqhrZOYo+NaEaW0FAlq+ToQCGwMFCwkIBwMFFQoJ -CAsFFgIDAQACHgECF4AACgkQZOYo+NaEaW2bmA/+PXIap2udLoUVOHxnsIBdqYwp -sv1Aj5lfIJmNhmxPbHShwp1Jg+w4urxe+2Dj5ofKVlIo1i83bQkvnKJMDXDVuc/K -P6zqhBJ3rT4Q3qx2mzX8bIfQoJ2JHuH4lkP+I7doDcHHRyeNASyk72VdQmU4twNw -Ibn8nSNV6ThKHdoPYzVnO2rZUFcGIqH5HNsvR+B7cc1MBCHsgURYwSVhSePIFGlZ -iasdBD6QQkDSe4QWi7AcJFWFElw4kbOKJWxAWsrEk+tMXJVGRjnmL289EmPCx/vx -BqKy7Mse0yWCSRR3vB+O6TB1S5SgEyEgqlYsfGNv1qf/rfRD4KkyCbNU3LhY1Aim -vJP4pDW+KFxTk2Ks8vrx8gOSd2aFqPeO/pFDrpsF7PD62XwsfoXu4xc5V0Giw7r1 -Nai0nax7kOrldNF8TbbtRjW0jmoC7wLIDujAkwDIOroZ0CXA3N4HVHdSbrHm/urX -nyxJXupXAQNwGx64JCBcbF2fp3Kvu1VAXBEFnd01KaopthHcbG5pA50Kl2Vhe+98 -OdezUX42fHkQpQkB7HgtXfm6W1bw6YRBamrNvs1OoHBYmUjlECpe566IIu25Hc8s -x3qA+6eca7iqizyLG+WyMT8ZIYTWGAS59jxwR4esqGczbbZPSAPHFwLbGv7Wr0Rd -TPu5B0FcKpDkTd4IxQW5Ag0EWr5O2gEQAMjLe4CtbSfofmJrz5wfNkMVsZ81Gbqe -MoYd3dtkJnQYERUj8flzBj3ucaxGJ+Cuf7ybh3naPopKvEI1q0vkcgCDqrEgXK// -jKJbP28uPSMGhOG28q4PbamG55gy5FtM3ezzAxPWWKe9qBpV65GMmFy7eBQx2iJs -yiDIOOQQ4kraS+cTqNFimEXAGLCOQRNLcwIZzwAAHoW7HEpNUfVwaBD9kMlbo1ND -I60IKcNrNcmcmRxhJqfxjj8YBMwcKHO6GBE3AVpaE/+UO9zyr4TH+0YuQUgxKlPW -Dkg5XlkDo0S1GyLY5e9ckIDIlkTdDa2pOkoE2yB5MQCEga3YiHrKUVTTWaxn9XVJ -6x5ZjUF6bgSWGkrG5dUqSYoO1iDMuNVjtiujNyf/rvfj5cNxS7/lgxchhQKZHZXL -WVqxlneeVJ6s0P4+ROVG9ga2Sve7aUJ6wXIewZwulBcV2sE/W/DgxHgLBi53CUQt -vEzFzKvo48GnDqL5VYjA7l0HMYHd4GksCLi8E8U6Cgj+imXiM8voL7pHRZfs8mY8 -udR+UT4e1Scl2MYP2qBJ9/17B/X52B3s1EZdqI/r+hfOyqrhPs+dbAN0mtMPn68+ -nrvY1+nscvrSYEP6ZBlc9Hp2mgJdb6IcTvINXBEeLRjgc3pjViva443pkiFp9Axm -ecOckMKP3uSlABEBAAGJBGwEGAEKACAWIQSgNcjBkhm6gh7OqGtk5ij41oRpbQUC -Wr5O2gIbAgJACRBk5ij41oRpbcF0IAQZAQoAHRYhBM/cokWxBDzypfl4Zf/odAQW -i9hHBQJavk7aAAoJEP/odAQWi9hHr7YP/RCLre1CmOoWYpAtoa1yVCeYMDV6eQgL -B488/BEZHQE1zbrYy16XkhORob3JF/kUMjmJW7XaFF8FrWvRcdj/xaUGbOOEulKg -v+8zWfswYQRiZ4/JlwER4vRLi6fTE89MVER6Fkj2ASD4D2cifY+EztD4flV3sq3s -vIogGFaN9IvdrdeptOVGXs1RmAyoTsiS2mKQ6xsGh8B9ZAm55W8fBOGiSzLX21Xk -Ofdw53BrFQxn3cu/JgIKpdeZxgukcvEAI62B6X+YL6Na4j0eqEGLzsNtU1+xeJlo -WtVvmRwnRHGSxF6fzIZ3mk/p/aFiXAEq/xITCTY6tDv7x7pFE/RpdlJZyNJ+R5Y4 -SQiuDsylxNCa/4G5EB6q+7iVYtbEQ9MnZg2phowEE42tlj0rz8/rvDK3LH3xibot -KHIodCWKlWByxH99u2PuHUQ0c1oCVBUE1KkruMpvI236DpU/dvdq4JLSg/fWrys/ -VIjqLZgsIE5g/KO9XqngWHkLcBLh4CNAmHJ8Iia+s+/rfgsejQWB5uJb6eYg2JjB -4WP1EI0rULM6fdrCNB+MJ36wE2Lnb4bfT0phOMgjjH5/Ki7ZCbkxkOsBs4SRjiS+ -weCsmpAtMqodWY/Cnw9pWSA/qLSRD5/mKeb9SO6OZ/OPfAatwnGHsvZ2sAueC6rR -04W5BfXZWrnJUXQP/id/EKE1Ksp5fKoxSCbkKTCig+Sf5Afwe36yFN+niZBqzn5b -BgL/HIKaZM97oDHersPPANeEgS+JVlBf95iKIYnQbZP43FLVbvOuaINhBIVtFO54 -2Y7EYwl41kP7ILDElVy36KAmdQyBAfrjnZiRA70xShOxApLug1L0lxhR3YfmLwNi -RJ0V6KnYDKf0pfdhO9VFyFFWUojX1usn2SmSsXNizsNtvRqHXzPnX0rbJzZ9+N4O -9k1nxygYFG/2R/jGonVmTjRzcAHrAkNJETMWXMA7/8wRMDwluz8j+cCldey9x8Vk -JwgLGnZSbQtVpcFAnm5r/36Gt+9wc1VWMyrUrVr6Z679aqAbG7PMaeR5h5ygMj1k -VqRTYAUPSk1f8bZKRssQkQwEbp9dVIjm9SsR8VT7/tB+UuB85dABxgHfv3psJRT+ -tL8g9V7kSZqQfcLNGmvEVvr2Zl9NtxwXtsFM2OBprxCenwb+e9Ppm1LjfJG/NE72 -mAnOERfDaiLt4bqNo36Ei5sGCJ4Fx61phzNBXzkdRNM47i8J5UZRKFkE91c99BVM -HKUaY61NRK24fR0zP98ftDU82YFw0VRFJpTeBrO5ivN1MlQxUPzUWxKxMxO+20wa -UOXroEw11Tb4SRLGOla1pCl6lCUPJRy9IzadPDgTr/OTMkob/snt/XLdnV5/uQIN -BFq+TvoBEAC8Oy1g6pPWBbrCMhIq7VWY2fjylJ1fwg5BPXkOKVK1dsGYO4QD7oW9 -L0aSqcFSNFGF9Cl0Ri4TFXZC3hnG4HeSXUWApuKdBLn21H3jba36Ay1oGcGfdm0v -Zght4c6BlMVBpGCw2wIkJbUNEy6InMM+O8CCbbaH3iJkJ4141P7pODHignx5AmZI -conMui4YOhC+IXQXynVEv1Juk7erB1Nh1RcRvsA4lb44HWx49lIwe85ejOmoZ0O3 -6f9NJRer6bV0+rHWmg4IV5Q9h/Gn4IhEDZxA0DZl1RQI7dMgaMbIFbXGq7Kgzstz -EUnOoy29hXodxVmwIsMrAiQUYtwJ9hW+ESsw47+W2iPHVgviGWl7r/SgcgMYmf6m -5kiTBtwU7BQPS9G3zwwP2Rm3AA/6g39Q+tQKjOwi1I8+GZsY2On44Zly7BreBNg5 -4gJgdAGcMOYU9etr050clH3UpTYcAEtX++ahtOKhJgLIPNcIAQNlnifqvU0VYpgw -R4YpZ7hgg+AVDzC73PIM0lFI0XiDuqChbxE+K1jmLXWe5iJF0dzgVTwP+PmsifNZ -Wg3+YxSsS+hDMPQ2xPiQN49gT4JJDHcDuyhHyCGYgyMiVJCsku9KrkubbfVRivyN -ZF2Zfo3f+nbrRxsftz0yjAq8byCvb0V0XOpt4pJ/ddlug9ytRxALNwARAQABiQI2 -BBgBCgAgFiEEoDXIwZIZuoIezqhrZOYo+NaEaW0FAlq+TvoCGwwACgkQZOYo+NaE -aW3urA//UQ/cKQ7HvWjcLphzQOZc+6m5YL0wxvZkSjemU7mqjZdpacteIvRAoers -EqXHc208liIBtNfRzoreXdcXNzie65xXkrRnWoHVH/fTWy4lOnHr2CMXLeHjUgg/ -M6PYi8+sARm05YFB8nsYhlhx3IdLhcfeVVbJedQKO0yL3CK1okT30DUVq5Lq6X/K -DC6AxuJR3D6UMSoT0WLaoX8qbhAp88qLynInfBVL18d97h916WPLTPeP0eHwhwND -bYtKDCMDuKQ9XX5+QsNH0RmbxlX274LHrUMMvkLKxcfCBvP+iuqrBeIuoeVzXYJZ -j7ZJtEH79bW44eecl/CY/STFYgSQ2XGTp2BI2q60wAmtKlNhwxY5ena0FgyFl6Tm -5OBHW/Pwo+ndQJGfbrCyWkTgRay9c8er3gl3GQYIBH6X0kCiG7h/Epj0b5CHOPU5 -hCw0kEB8MB4poTIjeiY+Q01472/lQ68CL3DX158hR5d3XaPSIxAN+qFsfB1o316p -yjxhfK1MD/IfrOgjlggPPnc/KmLkCzpgdwKcZwLCdZq9hYBvF1Zs34HbaVMYbWTK -uxLowtXGU43vatCXXqmPOvl4/g4tZD6rysJDgOrHQnEHzT+Napn07s0BRC0IbbNn -FynUrkr5KMSuRz7Hg7xMApENOrb0nqdHSUJ914ZpuMIS6RhJgGu5Ag0EWr5PIAEQ -ALfh9vPD2B+miHDTMADI8aRZ7g9tnzynZYkk3+2sCiiusetsQQ+HIPJ/ASEJB7On -ane9dyT/LTRhrK9qaxgVMimk2COXB/xyh7Mnw7nJgFU0aRSbtX0vbvQz2suSzrQ6 -9mPKzan28JGoClqB0bw1vwf3VjjxHV2dgD57CmqFPv7kAC/2a56dE+etzXattZAL -+2JWTpmfQ0ePRRadtBm0VahQhnU8x0+jvAVrEawqpVW83ozYFyW/0WInM2J7jHgQ -16OosY4lj5L/DxpVxaArhRFoRfWPXfC37iE8Mou/I95isvPQIhp1wTo4jG0KM02B -oIVbp/QRNBQ6WtpOzvJs1gqQiJJTfqbKJXQ3NDEY9crpVS83HJ+Zv99PNsyNkFjG -QpU84U3ZhsI4ygjdY45mpZueqI1RVcRQdu8Hgvoo/78Q/Sir6gMGop3mVdVo2guI -kFcJrXh0Xk3ech4aVqrmKx/mPXGwOAQU0DAul4RW3fKg1QxQE7Tlw3+95Ee/+q5j -HARL0uDbCJpRO8Sl8NDEuL32n/2Ot6kQeCSHrU7KJRYAkTxkKvr8zNow7hFhHFPE -SnHvTnskI6noh0VY6NwMhmLvhm0wKkRxZPzUNc3sgLvbK1NymIZ9aKCZamzhZrmG -vnblEz/OSLwGUua465H3hM1vvBQiartj7+6ZqWIkSmBPABEBAAGJAjYEGAEKACAW -IQSgNcjBkhm6gh7OqGtk5ij41oRpbQUCWr5PIAIbIAAKCRBk5ij41oRpbWmeEACG -+axtDC8UoNp9ORiYwEWLzZWDuugE+ah7DYYGD4Vs633FXVZW3SgM/bFtJ/0Lg8CF -74jI4LMHyIjDzEjcoItwnhBLix+kUoJTvrY58GPydwekLuw1p4KXLqtRs4fsZbNQ -YTknl4jYtRWoxO98x7tun7Gq2gqmJkIB2uj630fKz5cBk6p6oDFKjzyrHe+V7BiK -3okQPaD4x7hq8OnTy7lOy92ZZAqztS4tNEb4DkYW1MpuwsJ7hbBZitc1siI+FVVb -GjVVGZz6ssXoW67Tz8+VxdWJxNLXlv27eMcj4sme5S0th/YYNA5fRRv6zuzqZAru -YNGLpYYU7JLvZJ+3lCwa5j5ycOGBF0GvsGs6gj6h+CHkjR/BgzAgWC+GgUgslt6q -aH04rWtV6rVz+Y91LcrX5P6OM4anmXD3Gp3kl35AypXb4KyASF19+11RUziD4Z7q -wQEWfbwOltNyZv2lD8s2jPr7P02axWRQUbZAEhxRmvOQev/FZPyCF6gqUo/HxRbQ -y3bzmnipyHSv1DlXNfCFCHvN8kGyZnRWARqIKRg+j9ediJgOUqlLhg6KmrTVxd5v -3Dfv52PW2UODDTM20s3cQGuX/UswzMRwPI/+P44iCMwEKdm7duM/5oisZT9Vhy7g -P15MreFZLcZvUVgjqgy0u57cstyGK1Bo9e2sFcK2fA== -=6Zb4 ------END PGP PUBLIC KEY BLOCK----- diff --git a/pgp_keys_combined.asc b/pgp_keys_combined.asc new file mode 100644 index 0000000..c23278e --- /dev/null +++ b/pgp_keys_combined.asc @@ -0,0 +1,1281 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFq+ToQBEADRYvIVtbK6owynD3j3nxwpW2KEk/p+aDvtXmc2SR2dBcZ8sFW2 +R5vEsG8d3/D3wgv5pcL3KfNNXQYUnXVbobrFUUWQYc79qIsE3MgiPf5NVOtwKPUR +i5g9YJgKvpBxkQfqp3LYGm9ZBtwo3DVLA3yn7KsazCmAgTNFJYw7ku1XxgmIzY6K +5J30DfbJiqDqj4f9GslCCCCH3qiPnuLG/HUyVLHMpbWlaiy9NI0GcaLxjJewHj9w +W2D2lydkxe5JGo7egUkV3ILcuLVSVKA35SKY27dYqfuyqp9tAzaRbjDYjsYdHA6G +BqrNrKBn/GwlFDPrVdcvN3ZSY2wMLTxWE3Axc/FweuHxFnou/80FwX7F3JD+oEQ6 +rofmcxOBCC7J98I7HZAhP9jBn88XIS2hztbLq8d6rZJZRtcz0k61VR0ddO+TrFmf +9rMYCPgCckRtVxeFIVIabrN1IzKynLFeo040h8hSGswd6YKDOVwjJY6Oa6EmVefZ +a8QSt4+M65RSzH6SEPY008F3nJUAK6MEkzTak+tFltZNrVWu8p2xd1j9nmxAwEhZ +/lgbxLqzYgaUWmfyHeZ8yVA0MhHzdiAL8nVUEdG3KecIq0RWCJLGLWWIjd6KAJl1 +yAmhRYKK/sjPDsL3elHsFACfZbyx3o5GGQNlas1FYoPLWbaNGaJtgFTF2QARAQAB +tCtQYWJsbyBHYWxpbmRvIFNhbGdhZG8gPHBhYmxvZ3NhbEBnbWFpbC5jb20+iQJO +BBMBCgA4FiEEoDXIwZIZuoIezqhrZOYo+NaEaW0FAlq+ToQCGwMFCwkIBwMFFQoJ +CAsFFgIDAQACHgECF4AACgkQZOYo+NaEaW2bmA/+PXIap2udLoUVOHxnsIBdqYwp +sv1Aj5lfIJmNhmxPbHShwp1Jg+w4urxe+2Dj5ofKVlIo1i83bQkvnKJMDXDVuc/K +P6zqhBJ3rT4Q3qx2mzX8bIfQoJ2JHuH4lkP+I7doDcHHRyeNASyk72VdQmU4twNw +Ibn8nSNV6ThKHdoPYzVnO2rZUFcGIqH5HNsvR+B7cc1MBCHsgURYwSVhSePIFGlZ +iasdBD6QQkDSe4QWi7AcJFWFElw4kbOKJWxAWsrEk+tMXJVGRjnmL289EmPCx/vx +BqKy7Mse0yWCSRR3vB+O6TB1S5SgEyEgqlYsfGNv1qf/rfRD4KkyCbNU3LhY1Aim +vJP4pDW+KFxTk2Ks8vrx8gOSd2aFqPeO/pFDrpsF7PD62XwsfoXu4xc5V0Giw7r1 +Nai0nax7kOrldNF8TbbtRjW0jmoC7wLIDujAkwDIOroZ0CXA3N4HVHdSbrHm/urX +nyxJXupXAQNwGx64JCBcbF2fp3Kvu1VAXBEFnd01KaopthHcbG5pA50Kl2Vhe+98 +OdezUX42fHkQpQkB7HgtXfm6W1bw6YRBamrNvs1OoHBYmUjlECpe566IIu25Hc8s +x3qA+6eca7iqizyLG+WyMT8ZIYTWGAS59jxwR4esqGczbbZPSAPHFwLbGv7Wr0Rd +TPu5B0FcKpDkTd4IxQW5Ag0EWr5O2gEQAMjLe4CtbSfofmJrz5wfNkMVsZ81Gbqe +MoYd3dtkJnQYERUj8flzBj3ucaxGJ+Cuf7ybh3naPopKvEI1q0vkcgCDqrEgXK// +jKJbP28uPSMGhOG28q4PbamG55gy5FtM3ezzAxPWWKe9qBpV65GMmFy7eBQx2iJs +yiDIOOQQ4kraS+cTqNFimEXAGLCOQRNLcwIZzwAAHoW7HEpNUfVwaBD9kMlbo1ND +I60IKcNrNcmcmRxhJqfxjj8YBMwcKHO6GBE3AVpaE/+UO9zyr4TH+0YuQUgxKlPW +Dkg5XlkDo0S1GyLY5e9ckIDIlkTdDa2pOkoE2yB5MQCEga3YiHrKUVTTWaxn9XVJ +6x5ZjUF6bgSWGkrG5dUqSYoO1iDMuNVjtiujNyf/rvfj5cNxS7/lgxchhQKZHZXL +WVqxlneeVJ6s0P4+ROVG9ga2Sve7aUJ6wXIewZwulBcV2sE/W/DgxHgLBi53CUQt +vEzFzKvo48GnDqL5VYjA7l0HMYHd4GksCLi8E8U6Cgj+imXiM8voL7pHRZfs8mY8 +udR+UT4e1Scl2MYP2qBJ9/17B/X52B3s1EZdqI/r+hfOyqrhPs+dbAN0mtMPn68+ +nrvY1+nscvrSYEP6ZBlc9Hp2mgJdb6IcTvINXBEeLRjgc3pjViva443pkiFp9Axm +ecOckMKP3uSlABEBAAGJBGwEGAEKACAWIQSgNcjBkhm6gh7OqGtk5ij41oRpbQUC +Wr5O2gIbAgJACRBk5ij41oRpbcF0IAQZAQoAHRYhBM/cokWxBDzypfl4Zf/odAQW +i9hHBQJavk7aAAoJEP/odAQWi9hHr7YP/RCLre1CmOoWYpAtoa1yVCeYMDV6eQgL +B488/BEZHQE1zbrYy16XkhORob3JF/kUMjmJW7XaFF8FrWvRcdj/xaUGbOOEulKg +v+8zWfswYQRiZ4/JlwER4vRLi6fTE89MVER6Fkj2ASD4D2cifY+EztD4flV3sq3s +vIogGFaN9IvdrdeptOVGXs1RmAyoTsiS2mKQ6xsGh8B9ZAm55W8fBOGiSzLX21Xk +Ofdw53BrFQxn3cu/JgIKpdeZxgukcvEAI62B6X+YL6Na4j0eqEGLzsNtU1+xeJlo +WtVvmRwnRHGSxF6fzIZ3mk/p/aFiXAEq/xITCTY6tDv7x7pFE/RpdlJZyNJ+R5Y4 +SQiuDsylxNCa/4G5EB6q+7iVYtbEQ9MnZg2phowEE42tlj0rz8/rvDK3LH3xibot +KHIodCWKlWByxH99u2PuHUQ0c1oCVBUE1KkruMpvI236DpU/dvdq4JLSg/fWrys/ +VIjqLZgsIE5g/KO9XqngWHkLcBLh4CNAmHJ8Iia+s+/rfgsejQWB5uJb6eYg2JjB +4WP1EI0rULM6fdrCNB+MJ36wE2Lnb4bfT0phOMgjjH5/Ki7ZCbkxkOsBs4SRjiS+ +weCsmpAtMqodWY/Cnw9pWSA/qLSRD5/mKeb9SO6OZ/OPfAatwnGHsvZ2sAueC6rR +04W5BfXZWrnJUXQP/id/EKE1Ksp5fKoxSCbkKTCig+Sf5Afwe36yFN+niZBqzn5b +BgL/HIKaZM97oDHersPPANeEgS+JVlBf95iKIYnQbZP43FLVbvOuaINhBIVtFO54 +2Y7EYwl41kP7ILDElVy36KAmdQyBAfrjnZiRA70xShOxApLug1L0lxhR3YfmLwNi +RJ0V6KnYDKf0pfdhO9VFyFFWUojX1usn2SmSsXNizsNtvRqHXzPnX0rbJzZ9+N4O +9k1nxygYFG/2R/jGonVmTjRzcAHrAkNJETMWXMA7/8wRMDwluz8j+cCldey9x8Vk +JwgLGnZSbQtVpcFAnm5r/36Gt+9wc1VWMyrUrVr6Z679aqAbG7PMaeR5h5ygMj1k +VqRTYAUPSk1f8bZKRssQkQwEbp9dVIjm9SsR8VT7/tB+UuB85dABxgHfv3psJRT+ +tL8g9V7kSZqQfcLNGmvEVvr2Zl9NtxwXtsFM2OBprxCenwb+e9Ppm1LjfJG/NE72 +mAnOERfDaiLt4bqNo36Ei5sGCJ4Fx61phzNBXzkdRNM47i8J5UZRKFkE91c99BVM +HKUaY61NRK24fR0zP98ftDU82YFw0VRFJpTeBrO5ivN1MlQxUPzUWxKxMxO+20wa +UOXroEw11Tb4SRLGOla1pCl6lCUPJRy9IzadPDgTr/OTMkob/snt/XLdnV5/uQIN +BFq+TvoBEAC8Oy1g6pPWBbrCMhIq7VWY2fjylJ1fwg5BPXkOKVK1dsGYO4QD7oW9 +L0aSqcFSNFGF9Cl0Ri4TFXZC3hnG4HeSXUWApuKdBLn21H3jba36Ay1oGcGfdm0v +Zght4c6BlMVBpGCw2wIkJbUNEy6InMM+O8CCbbaH3iJkJ4141P7pODHignx5AmZI +conMui4YOhC+IXQXynVEv1Juk7erB1Nh1RcRvsA4lb44HWx49lIwe85ejOmoZ0O3 +6f9NJRer6bV0+rHWmg4IV5Q9h/Gn4IhEDZxA0DZl1RQI7dMgaMbIFbXGq7Kgzstz +EUnOoy29hXodxVmwIsMrAiQUYtwJ9hW+ESsw47+W2iPHVgviGWl7r/SgcgMYmf6m +5kiTBtwU7BQPS9G3zwwP2Rm3AA/6g39Q+tQKjOwi1I8+GZsY2On44Zly7BreBNg5 +4gJgdAGcMOYU9etr050clH3UpTYcAEtX++ahtOKhJgLIPNcIAQNlnifqvU0VYpgw +R4YpZ7hgg+AVDzC73PIM0lFI0XiDuqChbxE+K1jmLXWe5iJF0dzgVTwP+PmsifNZ +Wg3+YxSsS+hDMPQ2xPiQN49gT4JJDHcDuyhHyCGYgyMiVJCsku9KrkubbfVRivyN +ZF2Zfo3f+nbrRxsftz0yjAq8byCvb0V0XOpt4pJ/ddlug9ytRxALNwARAQABiQI2 +BBgBCgAgFiEEoDXIwZIZuoIezqhrZOYo+NaEaW0FAlq+TvoCGwwACgkQZOYo+NaE +aW3urA//UQ/cKQ7HvWjcLphzQOZc+6m5YL0wxvZkSjemU7mqjZdpacteIvRAoers +EqXHc208liIBtNfRzoreXdcXNzie65xXkrRnWoHVH/fTWy4lOnHr2CMXLeHjUgg/ +M6PYi8+sARm05YFB8nsYhlhx3IdLhcfeVVbJedQKO0yL3CK1okT30DUVq5Lq6X/K +DC6AxuJR3D6UMSoT0WLaoX8qbhAp88qLynInfBVL18d97h916WPLTPeP0eHwhwND +bYtKDCMDuKQ9XX5+QsNH0RmbxlX274LHrUMMvkLKxcfCBvP+iuqrBeIuoeVzXYJZ +j7ZJtEH79bW44eecl/CY/STFYgSQ2XGTp2BI2q60wAmtKlNhwxY5ena0FgyFl6Tm +5OBHW/Pwo+ndQJGfbrCyWkTgRay9c8er3gl3GQYIBH6X0kCiG7h/Epj0b5CHOPU5 +hCw0kEB8MB4poTIjeiY+Q01472/lQ68CL3DX158hR5d3XaPSIxAN+qFsfB1o316p +yjxhfK1MD/IfrOgjlggPPnc/KmLkCzpgdwKcZwLCdZq9hYBvF1Zs34HbaVMYbWTK +uxLowtXGU43vatCXXqmPOvl4/g4tZD6rysJDgOrHQnEHzT+Napn07s0BRC0IbbNn +FynUrkr5KMSuRz7Hg7xMApENOrb0nqdHSUJ914ZpuMIS6RhJgGu5Ag0EWr5PIAEQ +ALfh9vPD2B+miHDTMADI8aRZ7g9tnzynZYkk3+2sCiiusetsQQ+HIPJ/ASEJB7On +ane9dyT/LTRhrK9qaxgVMimk2COXB/xyh7Mnw7nJgFU0aRSbtX0vbvQz2suSzrQ6 +9mPKzan28JGoClqB0bw1vwf3VjjxHV2dgD57CmqFPv7kAC/2a56dE+etzXattZAL ++2JWTpmfQ0ePRRadtBm0VahQhnU8x0+jvAVrEawqpVW83ozYFyW/0WInM2J7jHgQ +16OosY4lj5L/DxpVxaArhRFoRfWPXfC37iE8Mou/I95isvPQIhp1wTo4jG0KM02B +oIVbp/QRNBQ6WtpOzvJs1gqQiJJTfqbKJXQ3NDEY9crpVS83HJ+Zv99PNsyNkFjG +QpU84U3ZhsI4ygjdY45mpZueqI1RVcRQdu8Hgvoo/78Q/Sir6gMGop3mVdVo2guI +kFcJrXh0Xk3ech4aVqrmKx/mPXGwOAQU0DAul4RW3fKg1QxQE7Tlw3+95Ee/+q5j +HARL0uDbCJpRO8Sl8NDEuL32n/2Ot6kQeCSHrU7KJRYAkTxkKvr8zNow7hFhHFPE +SnHvTnskI6noh0VY6NwMhmLvhm0wKkRxZPzUNc3sgLvbK1NymIZ9aKCZamzhZrmG +vnblEz/OSLwGUua465H3hM1vvBQiartj7+6ZqWIkSmBPABEBAAGJAjYEGAEKACAW +IQSgNcjBkhm6gh7OqGtk5ij41oRpbQUCWr5PIAIbIAAKCRBk5ij41oRpbWmeEACG ++axtDC8UoNp9ORiYwEWLzZWDuugE+ah7DYYGD4Vs633FXVZW3SgM/bFtJ/0Lg8CF +74jI4LMHyIjDzEjcoItwnhBLix+kUoJTvrY58GPydwekLuw1p4KXLqtRs4fsZbNQ +YTknl4jYtRWoxO98x7tun7Gq2gqmJkIB2uj630fKz5cBk6p6oDFKjzyrHe+V7BiK +3okQPaD4x7hq8OnTy7lOy92ZZAqztS4tNEb4DkYW1MpuwsJ7hbBZitc1siI+FVVb +GjVVGZz6ssXoW67Tz8+VxdWJxNLXlv27eMcj4sme5S0th/YYNA5fRRv6zuzqZAru +YNGLpYYU7JLvZJ+3lCwa5j5ycOGBF0GvsGs6gj6h+CHkjR/BgzAgWC+GgUgslt6q +aH04rWtV6rVz+Y91LcrX5P6OM4anmXD3Gp3kl35AypXb4KyASF19+11RUziD4Z7q +wQEWfbwOltNyZv2lD8s2jPr7P02axWRQUbZAEhxRmvOQev/FZPyCF6gqUo/HxRbQ +y3bzmnipyHSv1DlXNfCFCHvN8kGyZnRWARqIKRg+j9ediJgOUqlLhg6KmrTVxd5v +3Dfv52PW2UODDTM20s3cQGuX/UswzMRwPI/+P44iCMwEKdm7duM/5oisZT9Vhy7g +P15MreFZLcZvUVgjqgy0u57cstyGK1Bo9e2sFcK2fA== +=6Zb4 +-----END PGP PUBLIC KEY BLOCK----- +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFVRJ0kBEACko4KHmTBm01lcf4IsN4QxglIuf51lYqHs9B5nQbO6OSUivPXP +QBq3fu69yellpQiWaWhBvJB1s91sVuP1G30hcwl7SRxBUNQUUXT7lliLvhXEvcAb +l7iyoi3MsCdIcDdJvdMSMcbCJLSBDl8hETWcGj6Mnoj/HBr0r8IYmLf+cnCCNFg5 +f4mBQDlgsXpSjiMulprFwsEUctaJ1/7V0cMvXllsyXFw6lzd9xvULjih+C3eiKqQ +G8TInOPZgaWQSYKr5ihoVFZViRm0mlAzZ6/h9OZ3AeNJ4LhtThw6HbhNA93RkMx+ +zt6HeH4e8QGQQK5KZf4Kt3OdnTyJ3cOnLy6UQAzQAsmcFef7DwbbEQglgY56k4z1 +iB0289eJTIwA9f4fJNjlw6wcuUaGQGSF0yPYDq11PoZjc0tSUM3UxLeqwZco+o3e +oQ4d6bKEKmdHLyX9Hkg7WxXOqylNm/45roFE1d3STCt942n3+gRtOEGLmBP02ad1 +LfjOYNZyjltv2fo6xAaT06/YT2YuhgTL+aOS9nLtZ6vbV43IBw6O+xmBBZDM6Cbx +SNN2Bzu1HFij/wTUuX3Dq8cSCgkK2x/o1L5u2fBBDr4iMLthI1TFhVF5B6PAgV4o +86Js7ww4xWnXpwqXlVE7xUHumGH3IDfYLuiKxWx2ycfNJEBF807g7V2XBQARAQAB +tC7FgXVrYXN6IExhbmdhIChHUEcgbGFuZ2EucGwpIDxsdWthc3pAbGFuZ2EucGw+ +iQJXBBMBCgBBAhsDBQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAhkBFiEE4/8oOcBI +slwITevpsmmV4xAlBWgFAmCRdaoFCVYwHhAACgkQsmmV4xAlBWjHPw/+PNwNDTSF +sV2pukpSL1HyiUzgwdHY+rxYQsadQr4ZStNG7F7XScIQk7kNXqbBD9K7G56zZr8r +fTPUdxHR3ApMWIFzL0A2ry9QrqRSYJ9Vt/hWJkWYMrsJ5YOkKX6bPFUjqfGT4vRk +cvelmRBz+zTxpm1cVmZPPLYcwhmZ3lYFTOP3A21dILEgxdYKWZRjd7/DSrTps7tw +nFCI5R/+1TYuOvrQUHY3SIvXyivwRWAWZwEBYsrUrEVKw6ymgqYnRWwn1/5yoJv7 +DrshVIR9drdIa/tfYhlc5G3m1er1vC2u78Wg0gQUrCknBT3a4+bg/mNUmIQcJDj/ +IhWPUo+bv4XEfP7DBKfhvhXsDtYR6KlaIVKHtF/F5EbT4M3bC3hVZjz9ijpfeRWF +lx35kGfyI5PxU407IcvWLKysM2PLD6cFjzRpi375I2UTTMBAY8/fQiA9j/h8ke1F +kuQ3gAq4dAHxYIb/FG15WRmq75e/SRzq1tCyhwiDcr0mLkpDBJ6iCl1Yo5OyXqDL +qpuX1+XaLOM/TcTYHRNMMOOeWWPJCab8NvAS0CoaL0H6HKF6yO/bMLdgW4Bhi3fK +5GCy4TdyUjFEQ66n7vWE4S3D0OvdSOvrmi/LiYip2GQX1QXM3VBwMZFvMfzBiD9R +varsPq8cMWgUOoVX/V6BNonjwGY+9joiCPyJARwEEwEKAAYFAlVSjkoACgkQ8iHF +0sRizfhLQwgApsIjObXyMiEtNg/QRdSPdCm26prakbeSBjzXm68lk+kchhUz15p/ +7BkvGjetpGWvGupnC3+dJTOZ5HQYZVOx/2oX58MyVYNl+izbooCck+QF3DLoJZ3e +lqUlzhM4+Yn+JciGcE2WMSH052edU6wSM2Qv2zgBaZWf355afRZeD33rsV7hdnsV +hERmnMvWd/dkX3bGiMisWQsx7PcqeW47r6BiFDNeja+Vo1bjBbISGrn9cq5kNG+c +zY26OS71MCh5aEhHiOCXeUN6Io4khG7p14RYEheeNCA7Dr68JwnRNkS9o0Wrsjkm +5zKqnEckUNis2PrT4ySXRrB9wd4X1PzGxokCHAQTAQIABgUCVVJzmQAKCRCZtd4L +MJZlaXWID/9l4b5eosARYor3eEPdR/oovUzPY1fY9KESZw8yHfRFUi+qrsSYnYKJ +gnFoJ8OJp0SAQX1AI1voq4NOCVlbZN2im9jmks/eDYg510u73s7cwmZfKokyxVEL +Bo0ZA6e55s1FF+10JP//tmmCryLLIDv3/FmLdDHY04nAq11FARLRX9BoQzWSwl/u +AKsFJeKvFQQv4atV5fsl58BuVppqdg1A79lT4SekAlGtCOmO0h1/apDKoVYtHeSg +8AZjss3DKNNmFDJtAkeSRSgmojPe3lplNiUJoLgcPAOL1rhRIKKY3YieVs54/Ecd +W3KKUtOm4qrpobuyzEJWmrbeiVzV652I+cLML9iE5dxKjCNP87xBLaPKQFJbBDKf +XTJuexppiQJPjYPWt7/08odIFoM6OKdz2IVnjlYvBKSbLxmBzNIcNRK75eQCnIVl +MRfKtvAOOUGdl4Hzrf0eGMQtPcDhsQErv9hwCuV46TcZNw1jpvI//jGXKueujIIh +/YauFUP2rMWwX0vRpi1+mFnulLDewGeh5ORc0nJTEeDOq60lzT7ilnbCKuQ1UR4y +Uj2EQMyqHF/ky5dg5QTUmkTuk8f2T8FoibgF1QDfWS5Sr+W8EW4YQYzJKE9woFpl +yYH409EDYqvPbKQogTgBMtptibQBBjUnl1SiXc0XlybUd27C4KTvC4kCHAQTAQIA +BgUCVVJ6bAAKCRDg+ogVk1gtkZ0ND/9PYWzAKLIBV5EzQcoQ+NdQXcqNv8ROel1S +e4sz9h/FCI00JdI/SvnBs1JupECaRzFYT99X4UtdAsLYlZBDMB97C7Vl4Yy9Q0PM +61GZP7iANKL2JiOyKXXkME8Sk5ufVdRwBr/Yb/Xs00zMj7X811j1qqmEdalRNaPd +mRBL4kbrkmqs9b3ZeJlZtvasVT25mrR3Sh/D543y4dvbO6UiJXJeEQrLsNTszPHI +hBwu4x0hMgtfTqUjNodZ+zeUGNNe6ZT3QIYBgLGrCoz9wGMyUtX1RQBNoSIOq+aw +G3r8/8SzNNtdUnfw1NelBKSmh+V1KIpUAc9/OMNmIAEcO4rTJsEE0kL3sRay9lzO +ihpUyJMM/Z9FTqsTvKc5Wi38Vo+R07dapUBLS5TpS89+pCffaM9snQbuRfmhoCuf +Sslp8j2OSRsFTq5BA84gmQNteSlwuXs6r99EV3sQftrDnCo7AJJKDVeJ8gghlIYG +TMYrpVjsC8Rej7DxJa4fWznXhdtediFzGldQ+nBj1HlSeb9Y1ikG0ZAB8jnVDYeP +u5DtqL6AbWcr6n5evATlq3/YieDPBTBBCfZ6wAJ137gaRlPsjTsBng4V+sXUrQeg +S3D/IEW/qznJiEZljzDW6Rx+cPmMeKRdcEpZ4zQuqAbgdX82Gjn1tiAzSx6ez3V+ +2Up9RRKyAYkCHAQTAQgABgUCVVJ7xAAKCRDetUdYIbCzY7qwD/9Q6RhhHMvzV4Dt +/QYMiRwVEdo4XJxPZJfcpQe3TwyRsnS+pmMuLL2k5emLufzomXc20Dx4StHOVRv7 +ZZKlSrIPL1d4u3DFygL4mRg7BIZWEmvtWZbfCEb3Kjg6ugh/+E2tt6sIRmSSt5lk +OBsuwB8FyllTuiWe+pkkdESL4j6yRUDv5xE4jT7ha84aq1Rq+fYoLx/NKPAV5xHN +xr2u7rHL6yFn0IRqu+1EIgDqnraS40f07OoSmE7QTsn4XWAm1XD9HiOtHP/FZKiU +Pmnm0C0QLvMf7mP9cENkFP5GZjqxMO9HS9NWQolpato5ndcWxIn5c5oHmlVR2eyq +o4NBC4mu+l0I6dyR+C0Kk5koEE4KPFxCeXXXT9h7O+aeOs/eZeQuI5vCp09MUPUU +boAPzViAMNJOCKPKwwl1p6ccDA04KLKDKhL5Gt6JLosoD7G4nACUusRpyrXwihRk +1PzPB4+2INEQ0C96DcnEGkMwMy8SVzxL+bjVbQFdFg5w+OicvDZO5xrQWY1CBdqO +W9IGsSCc7g/y9DNU9dgNlm5kLnA3meEtHWIYgTFHuQ8uiRFfSgCHn5beMIzSs05Q +8Qph3gvAwflDmsT96Qr7woyFTKwL0Ioumoz1yRGRhMuB3oyd3A76Igd8ENOi3VrF +mGVXDYCXFFgIOhAo1k/Q/Xf8P/tu4okCHAQTAQgABgUCVVJ9hAAKCRD/VOEuHKYZ +shfsD/4+9FPhrHb9DBeq7e13QJTY8Sin9uFin2wTpH/9Qh6eTMd1PeF825CfrE4B +/zFK3v8v4MfdGzGvu9MaGHedKc1RN+rusxA9v+EVX1TLceAJNhTTMaphlJzMn6gn +kC0wrgdmCmspnxT0DzvCfYzf4vaGOCP4cHXOAvYqz/U/BK1t7Nuf7tmyePRn19EQ +KJzvJA2K8Gqg/v4ovYtKXtJYA9IrCK6eR4Y7A+mKUNzGrb0poDcYp9B1CxyhRrsg +WHoNUIKVpVp1xSOLr13Z1EvG0Pu24j8Ygz+PuEIPaNJ1vsCTff+fDT/XjI9nBlZn +C55khg/r81sMKPIwYH7eTKTUmzyUHZZJAn6z2JI38KG+nPk/ln3llHhTWelh9H4e +nD8yHzTZDrXuiRCZg3W8fI5StezmrjORBCE38fkMB/TL0IZdiY/K9IPgcPQEX8RS +LwAm4uua13qCsVy18BhXTRshgqAwwHyd8yj9j/H0vvFVU1thapOB+aMLr3w7tn5y +msxGfx+A933s8AWXLs/dvdr5tn2LQj7ZiCTqPf4elniVelwFL5DqhZ74ZJjBmiIA +VIykEVonH4xOneiFFH8gz7/WT9V/Mh77fnqLk8CTM7DPZLskdL2DCS4zqcMuviSs +zY35n8BJYZXsp004NQeVut+mSLCktPBdSrRb956dMiXuMgVWO4kCHAQTAQgABgUC +VVKEKQAKCRCRPzdd5iqXDJvFD/9bhqFIHOo7fwTbEg5Chb5/vPe3hyS7Ciot67xM +jPGGUWree7l9LytmLvTPJdXfcYehthd/JCB2YSMljfPUwrc3N8uahxDZ2KnESByG +4FhCkzQrQBImGCBevNmsy9SfH3G4OnXlOTaozPz+RkqYvfypczzbV6B/f9JcXcQR +YwGmTloohQhoHGGvm1CXKNgbEZjSRYaROpJ2NCmaXroe3ZhvHxd+d2Z2pQUfZX98 +2M7mjRXTkqzDjdhx5j16bi25ZV+1JDiwul7O3TWFLY/VQeK1YEpWuDbMSeSlf05l +5RsHR3W1nNThmbAf70SmqO0rvn8Idla56Siphl+Wbl8JNpM9YyWrb0fuf3o3bdS1 +uIrQzO3jiLA0DzBfjX2LEQ5JKm9M0fZil1R8MDMRZQFvNryF3Z1kl1ZCEuwUNGow +F+U3yepko/E0hNWKDd7lmtRZfCoor5KTI54WzqOg2lsDnq2Dk5Vbf97qJm9fy105 +WXMSvgIOiNJEyOvoVlN6gzA+dQ5bnuz4eKpq98I8RiO9DiCenyMk1CXSYUj0+NQJ +YU52l/f8x5QteiENGFiFwfMgZbOBuKTKL1iCp4l/RbxaHiYxc55m3mIqS4U60bpV +3be68Cp7m96kYc36osRh948SrMKPZ6Zb3QrMYGOxiWL9eVOdSOYWMwf3wF6VGd26 +Nfk9sYkCHAQTAQoABgUCVVJ5bQAKCRCotR9egDLM5JM6D/9cyvDLDOwZuH/q8/eW +tV5S3x5V75VdrjnIma9WfyTqgrv6v8oWV7PoQ2C3Rd/DQxu9ZiMxncj6ctufptes +IMCm9trlNqbFdFzklBg7LTzSXnMOYxpOf+xYWWnrzBR4pgF9DO/zsr71x2uKkQXg +bKbz+8O9/Rx6/h+33c1CPHG4gc5OopSLStnnltOpRZ9P7q3Rt+CJLutXI3fBGnBR +Yi2NOAZkszlj1yBZrgVOMvDZJJbdVR5J1nFCYHbowQD6X0OBtLwksfbnfcaJRr8q +0j8/4130eWQ0pT9CZ706JPG28CZfNJo3UtFlH2jpXAh/G+b74fdYtoMeKg1z38Lq +Vdjm19hoyYXMDiBoHKpX9Xd43ZZU++DRsS79EW+e5a6stUZLUYfwlwXPNkCls052 +Bzyqq6NN8KHUFhbIBVrRWxKJRJ3/Wo2uQJZwUKKoinSol1jHfPkc58pDOXrySaX4 +HPcaFoKWtGObYFsdlCDw0P7IhFh4I2Zus+U3kAqaC/DUPgBzRNI4nlq7ukHPy16l +Stq/I9lPxN47GPW+qb0EyewarV3JmRyag1BOH9BINBnR4/q6N9vbYb73D3Ttf18B +6K57ZKjQ48qeDVKZ3W84kZExTR+3b1DeIAEjlq5a4oHvUo1KfXXk0hePx6a2QJij +BaqJ6y0UANdCFMg5nOuckRpsgIkCHAQTAQoABgUCVVKEZwAKCRCt3ULg6XStj1Fr +D/4+J6z+z4I6GTYdm6ET0EDVkO4/ZQHGVMIoIvzhl3QYTAeE+r44OuMxSAxO+B6r +cgNUNjmbvqLaN3x3Syree76hBcqiZSKzT70t1OqdTMwQxotRsVMapwk7O4m7fthF +3eAgumZguYj0zzicHoir4IahlVOgWR7AWHA29wsM15wJVjLiIo+iIhX0okQAML92 +4d9BqEZeTB4+bV7UcH6AAFyob6cDZexkLwN6ydWNpXaMREHqGavbLdlkqmGhjVre +pFxIIPEnQsxpmGIuWaDhgcy/W0Uw7r/gQ8UHa8rzQW4+0SqvBBFTJknX2OlL35ZF +LwEUglgvrf15LRYCu8Xi4EMLULIMsCz6P1B8MrNpN/tPQyLQoKhbJRAow7kszL4O +FbCma/8nZMvZyxQ7tT52XjBagNnMCfshsr8p3UtsKSm1XkIVts8t70U1cSG+kXtC +yzs0wsNV4UH/HK4S8fiKkxTYGIGDReFqtVr6LTGOJl/6+T5z9Az8GeYK18HXU67h +H/z0eHikvem3hxSJZrHt4J5vfC15zyrhSKLdmij/pxcXjCffU2fEJ/Ngqk472EAQ +2k0EawfOWTShdsQ3yeWEOhz2CW1a9nJiAcavJtmSo6eFLK/hFCJllvClsKddpa31 +TTc0TTs6gLnB93V+tw0JlBrueNErAgzCE7qhoVDT45LXoIkCIgQTAQoADAUCVVJ0 +bwWDB4YfgAAKCRD8n7XhIU7pK2pVD/4pjC7kxq64PCKDQO4QNV/481TAVXDaE30t +kAX46waCJEqsT11hLKnYS25bD+DLXQreYSxEMV9lvSGHqa/mRG18Qw/MdUECO+Tw +BCmeArGw7EnKuLG3jrppW7/ycEvKeoPRdkioliWlFzIzfrB/tfYmiCb4W9CEDEZh +/5Mb4jQUMMLDI0sq+dcvtmOrbmSIDTCnPcvponLtxkmDtmMpgayUUCWaE/3h5jgG +Qd7BpiXE50IVD6lpmsbSy/RiiCKLNjI+yhw0SJoLZ+MhDnCDuOMOKOW8TECKm/iX +nGe99l3eas44wfP6LSttxpwrRlorgv0rT7LAKYC2EqwwVgXfGtYUgjLTfCUjGb+9 +A7uMC+L5pCeZyRGvSUoulBtmmg4I1OWz3ACV3iB43y4t+G2LKggkjgZep17Iq5KW +KzWlG8RhiI4aiMtQLl+ft267TJTkKLX7qGrIYjiYQnmtriGgq59AjWoNxOTeCmKo +CZVto7lncEvJHpj9N/3d8ob+F1FZtIgqGIYG4DJwRbPMw6AOLpXQWgwKhWfwJrpv +Rd8l0FIKfOwhxhCif2RAAqxmTQKQF21Bsa3DBdhs42xscpTiK4LxAMhZk+CTZpFv +fFxxdHFrcUbaz2jqt0LGkh4NknHEM6U+gqTksDL+tupk4bq1GXaMtzUFzt4BPDnS +p6yN+311qokCHAQTAQoABgUCVVKvOwAKCRDgldvmp8WiZqHdEACx+sFSXzECtHly +EvhzD50T0Jk3s6fFDfTNr8oMnboNvJdbwvElfL3uaBClwmqFlzjPw3xLb9kWanEr +zXfdVZsZFTb3tmzI5S86I/fRQyk9Hrgm53OUP1lTR2JzJGUwHoYc1m/8RShNgdCJ +aWsULsmKIAVxs7u34EdqlURqzbglh5lhyeKa/nuT2dDU82R6a9//ahziIwOFlNrH +zlJnthCpEdjutT7C3+pL3ohy84K60G2csEFwnyI/3CZB+rt2YM98z0QASnR0cAGG +RPMT/rGcRUeW+XiGzt5hUAexJSfWYA+M9do2o9sDiw5Ic7+gi425Fciya0z1lLMq +VFY2rbs7abm1Kqkt19mT1S52f491WggSS4IRJIvKJcL7Sj7Jk3fM2jaVllcxtOti +vg3rf83Ke/f/cMKKVJ7noExiVlpZabZY/Wl/fzrS5FMN3km83dYUhHh4LlNl/OkP +3QnRTwS1p5vBJuVytEHLg6yv6Ae6kPu4TzBkol3lP3+YSp8pPh6ZP9C+jDzKbNZu +TcP1htDariF9bZf0XPLr4gn8m/6TbjO6ezbB4IMENnWzAL+23nviDE8kLlW0ZPux +4hZwglBz9FHdOO9af1yDJgvwspe9IKPMqGCcZZ4ZYQ+7y9Z3mvzaVPjDQf2oPSGA +I6VvQy2pQtauWlBajtmZqfid6Q4cVokCHAQTAQoABgUCVVN7VwAKCRB1pVGnIpXs +H3rWEAC2oQ8aWe4aiezCgD4oMnWlE9UXwZ/ZYNlYAp8xQvbRr3dZJ707Z976PlGA +suJIejR/+IbMJUVl40npbFCiYYOMoqs6PAxDZsnuymW058WXFUSlBbwXq5w/2o4g +Qxy1TksQUSZCx0G+tPGilegcCO/5hzPgKzYNKQ1mg00TIu+PRo+cDR42Q+tWRAmt ++9k64Z2IWmA1NVCMAGcCC2hU9nr9HMTLXZPZPRbzL4TRygafZTBqCd2pC1YFupER +4Htm7yd1Xnd3nqSVYU4e/+wU3K9U6fd4qWIkSKP+F+LDqND1zTM1c28YB+WsMYXI +/cwEKjzOJsIJFJbZUdN85uDx7vT3zDObm8iL2xnq12jmm4G2m1qWVfPCqL5giMSJ +lrPQAnrYxePVvxqfDLQcGKSXW3J4VD9yTlAL3nn+9Lto2qD89FU9ikfxhQwB+BBi +SHNwXzyVs8fAlkb9+v8CjPXEaRJiU1lW9xyrcYbQy6O6Au9EpE0aoac/x1x9kliZ +1DEHmM91jJCONQDrVlbXMO9W+2/uzbWB/PtWnHSa6gDPxLld8BGvoZAJ03yc9qzy +kyz86Rg7IVuBKMA+PLRvBZsfJDmCs8wu+KfBPFNRqFAjC+yGE7v/JE3RF7fdBcQN +LvNernASmVP0SSg9NnBjAh8uhwpphMCx0ckARqBF+1gMUavaZYkBHAQTAQoABgUC +VVOLpgAKCRC9AM0evEl8/asxCACB269wUL4VODe1p8lCLiuDBPzFXnRSrU1H4udg +JD3F7Jlqc+6Cnb2SCHFwz3i8N/4tP/TMkrQoDZgNy3kQm7SWSDSPKXDItn5XieP1 +HJKMrvG/DKT5QV5JMnUmwZrsFgo7iNFEhVnH1WkWgGdbvRA7hoN+O8ruFl5R/V2k +1/17hZ3t+FoGd3jncigYbvrFwRLe43xfbzVg5PV/LUjxOsrCbix1XC1TbDyrTt7+ +CfcZSQvlCQkrimEGDDGlTvGStmUfkLaAWBp+PyvnaqCQ++KB8H3CW7Kyga5bJ1wX +aDU4FdLjYs2gyF62uKkqIbUk4NFPU+ggWdvmOuRloXm1gQ5jiQIcBBMBCgAGBQJV +VtEYAAoJEH/Z/MsAC+7u2JcQAIbVKrOXPxCNIxwSFjPY1n/CzGkFbTi4sTVsT+uw +NRthmUlG6Q089/hcGgl4bIUM3zTpP1IEWi/7lPwJKUPOeYcy7gNImVcjxqQQRiSb +WEey9ojsEu15ljuc9za/+gVpiD9e1vvOGX83UfN4o+L6MiJ7fJ632wL/tyYABTzn +nHtQSNOklsLOLpKg68cTUMDl/SlrXngOrNHVS6/bo+y34cTyEdKFkDT0KY4dBOUl +3DVKDAzXdkq14x2QK64g2hTX7Lf1654KMQgjvYMus71QF6xwdn2sm36jcfUAiwdY +RUdN+BJ/hfkDkxdMdQFL93Rm7z7d1XHMaIynFWYbN5FTTj7XmgyIn9ymZ1nMDQfr +HpOxyMuk/SQgbN1+zAFRZQhTNFTc7swDg6wj1/4iI+wlgsevhzFDS5Fg7K+aW1to +wBwPVg7BakAYMmFGTmvYZ2bJd7CeTs9JPSgKTuQAhzd1K3xMawg6GTtLlHmYXxWP +vvB/uQOieiWGLpohziNBbuvtzOJ4fc53B7Gsgr9pCNBOm8/LRtbNQP2opGA9dNkD +9bI4EvlCHtFB2Cj7mIluN20HiJeeYAZIywL9LhIwzFdAHxPEdp5GDg4Py/CIYUkx +MRJZssUK2Kt5eBDvxj39ac1u1XZbVmH8pS86qafKTldF4TsuddI17un9H5VOm7iw +whLsiQIcBBMBAgAGBQJVVn0uAAoJEFjhG7HkFNmt3s4P/3D1Ad43N6T6pLhxsCgX +jEMPzlEbNpiLzpNi/ub5BbCDti64nZVaa7wruGeBkmHcpZFTlDu8Zmp39Hx8BwKy +WxlGcWuM4OcLLeyZJ0Xdil5DYkqaB/QY1BQSa1UJQv0n3itHp6vj/KhxY+E5ykUS +VQKTyIk/IMV0kL9PcJNrfq7PWgjnB/QMXra8EwOM3nJ758pw9dgoF6JRkf68dwYW +jLL8fc4rVN6/JO4sAwxrqW4kn6r7186/M4xEOkQvIp9S21F0vLAjqk2zitK6Mx/2 +/7E0yOA54foYqy4xfv8Da2BwIHShmpBeHbM5pNIXpAwqrCw7cAhs5jXpVZIPmnMG +e3rZ6HK/w8qezwzA9Z6Ahu9hf5X4/bGewIEWLV/tprzIrBBrc2H+7OT0gSXKr+cu +C5yIxDnClMllo1p+ABy4csxmDlih+o+LqDf4eEy8hm6Bb97I/iG/o7EBvbLfzzxh +s4pbd757PLCcBqVdJ+Mm+CqsQLlixgMkziswvnpZ7ecUk0eMQrwJLNdrCIlnB6kZ +Wq7Kiyn5976jaUCydSrKRxgcqhbDkoY8H1pO68LWnyTdC+GbwOTJJeNEQOeY8MZG +5cVlJrPTrLkB5YG4zyvl7rb9b1NH3IpsmlDBGmr2gSzhvMk7XLKzm71IrnMAoJ2B +MyrNdzrkQ17Qkvxu0UDeHA3niQIcBBMBAgAGBQJVVY7fAAoJENRPy87OSW6u+1EQ +AJi0CL14THhTZtOBfr+otxIZqDkPiaVwtax+WYjyLt1VOgeDHPsEz5zaJsOdkLWD +I+JxuNUef7XxSjF5ALVH4ykpWe2E9r5bMRXc1oBFqxDmwVK8d5uh2in2Y/UdIzHg +5LKOhJmLoCEOhHAIBKgZJkwgznAnsW6/lAKPyuyH5OsiTMtIom2q88aZU7o4bpnZ +yzo3iTsWj9b0oMsn2nlNAqOy7I1Qku6ymCCoAAeY+lyhMMIt4I2mQ6pAcJQG5LFV +BhKuW2LQb+O/KHvaT4/tQL/y3B5DiSYQ2GC8VCMjcadpVV0w6oIodN5Mo5d/drpG +4bUX5TCHfA/1aZVi3KL1sgAISqswvc7qksVyHlybA4SHHZFiG1VukDDCvqcwHp1s +zTMAZBIN0sXqfR1BqS2YqlzWBxXmSYesJeJYJ8vk7RJO5JikUsuj5MPKu6jVFgEB +UvqCcDB4wYBViKjyBXS8vwoewcqaow62by+WXk/R5gynVsnME395yILEsvwW5BBZ +cJLSrI7Iqa+1iD0ZVKpknhwbsKgNcMnzqzDXMflWTUBrzhvjx84WDPfHJXPe4MMM +CIDNU3IrDt/nBN0JE6yOKfnYqi/njHwjsF8IgiHKKwssMqfKFuUBk5f4QSH0MEQH +JU7lNIrqxwjlJaaU7iUNFpRDLTIVO8w9JaxVMhH8JXrxiQIcBBMBAgAGBQJVVUVb +AAoJENqUEEiDhCgm5XEP/izyBXdZFikQkw3ewO2rpu3oZuDIx4OC5V4rgGEaGWlq +wSzGq65M5pXk0LUSU6gb4BAQOc8j9BrzHbN5QzMKxmlVWjxTfUvpq/rHtmNOFA5x +n3MolbRdVrQz/dGlMAXJQE7DvP8YDVCeyVxZsU+pQan6QoYDoUG0snqpwHFicyEe +PCzpoQOFEx623nCn+wJwMPrrPM+T9sFbhYYyCsxVkAkzYiLhfKQw6s3tm2QYDTcd +oU4ZJ63/gmSzQuiRBm2hF8/cH0dpQT1zEE4+nIcffGKcjCeb8JTmVAzf0vMRKWS+ +Ntotklh9HdVxgSBcU6NKOxH80JHABMwI0OakXrT+MbjPSoy6SKslrRfiXAOCK+/6 +qYCleqtdj7KbauCw5wWC2qRyDU9NrX27G45Xc/GXlEYHNIg/SDKrcbPFzr38TQRu +lpS9svtsLb4mFamXwZ+940AMMXyY7qQk/+1yXpOossYsA/WbutkieftFhJQJFMxY +UCD6IeYQZ9zxv7tcvjck9+K2Ap28h/nWLHvB/EBHgNKbkNZgggT4+xb/3/YGcXTB +jS19VAd6la8YTqRRHuHI92/SMDOmkQDGZ0e+u0Tak64sT/b/Sw67yNbY4BpF0rkJ +PaHQTL/rgXPpqEVTHA1qGVn+KFSFfcPJ9ym1UMrJvkfymP40Ina3qhD15rYrhdUj +iQEcBBMBAgAGBQJVVAc4AAoJEJlFM38oiD7LCHoH/0QsEiyxY9Ac9Yjijdbkjm8S +iYv6eHtlFUf3vi5NLqJgxj1H0PALzP8fswBBPTQmM8bjrvPlEJ4Tg2DiILSXDXHW +gU/gDo7fgy2VtaL79TrImXQ7jNUFEp9Np8haYyY5KQjVJITCES7+idi3q+0xtEwe +0N6plEnRUgd5yOv3dUYGwQSPk0uewhR0UxCHOTYvngoSGDJO4ddHVffnmpj3jsvK +vpbUi5ryWjKMhI7IcuJqTwVE+tL3YB2fhEGB5Z2Wor2xzB49kPlR/OnG3QpSRUQ0 +WfvdEhL8kH2lhETwCh4N6+1vZY7ufC12iuqxl48C8mXkeot6HhWqLIzUIznlxdaJ +AhwEEwEKAAYFAlVTwkkACgkQT/CPqhhgANTRWw/8ClnjO7ltJu8BbkLR1FWEpfuK +m0PWOCoRkgcr8L4ndxFEdWapvrEg0VNUMSnBE8E1kai/cAWnwXhYCgi0atDYo6a0 +ZwYLxlC9iu2t3zI2pXiCuW3jZLoFgFP9whQOkuT4VvdcVGrzlrcPNKdXNhNiZIIH +rmTfxcx0pwPsuArOZvrfQJ3SpewKHugp3JwetUkiX8le3hG509HmiDmoWu3xEYIw +Pd39Mm8Qfvyky+1vY8lKP6tvAmIJ5K0IOGKqHGOs+GbNZUMayoISxP9/tmBrme4c +63UAbS+WGoOCRvYs9eXzPEl8aWxORXRpxN7CuU+P6VrNP5Ks2w2vbz7hjr9C2GGE +CKSuByaeOEnAnO2Ttj2wRwhH0eciN8tFSsMIkpsPnjMGZs8mGjg0G8QHYE4gjAP3 +r72RrmteXpzm2JiAWkaX7WwSFZIrchpgL3HyM5FA8FKZ5vxe2P5D2PcUIsoTcFWy +xf1d3Rtx3a5L9Dxx45bqH7oUdCKFasvWuVBi6wC9zi6f2y1sqdNOqL+aMKELDPok +GC/tPXVrmEJnqcaVlx2HF0WCFS3Zgo4s0odESr5iyP66UonqIsJ38Vs6zHKpP9iu +WCNpCo645t9Bkz9Lp8SiViR7Vy8tA3bNFHYEiigp++gBRYRLDygoBjuoGd80wBUD +aE7Fc+gZiXRALsWNmrCJAhwEEwECAAYFAlVTotEACgkQgkM+NYeyrn2c0w/8DGbK +Wk1KhQ158XQp+A0Tl1hva0pE98sNrnc/K6ZSChA9JBRvYW1RoSb6HdVxxXLZxFyo +Ug8i7ceS8TU9fxi7XN6nLCD0qLAAebCz/Ft/fo2eZVwzthp5UyLTqnf77wxgNG2P +hihCO/d0/nTPZ6F90dk8bYfN0H1+y6d1ltdUKx196mqXpkMrUofc+AQfT84StgM9 +L7SjBHtN+H9Fy2zZ1PuGZW9r/HevZIpkN5wpqnjyBvsZffszZY0tROPLA6t2NqaJ +E6T7f44WICNUigXghExGag7aG2aEt3oWjlXVif5X5krza5Q0P+32O+bISy2NGGyM +NAqIi/5o6T4YC9FgTOKXODSDzm7M1v6QCKbTCsU0gdB6quQvtKZfAwlAguNq3zX1 +GLl3zu/FPy5pwqPOTVvBTrFJeaVzbPry9tdkGjygFW2MeR+DmbgWULAJsCCHQKIQ +H6TtwM/7e+SYey80Rf0Wc4gmTE72xtgaC/msGkZSYnE5+TjO8R3/p3RzJ1PCrU/f +T1VU0PwzlyqoO4Gui+FYwR81tGIiFrZGvoTT1Th7NtDGtPjUvfHchZujreIrl1a8 +siiRAc439WaOUWVS82l9rGwC7jyrNcQAbKHTFVOzDJFTqQLYWI25UReV8qYoOFsh +v+vEgOa4bh/i5xczG6tj23Nsz9XMuOCUPmPuizGJAj0EEwEKACcFAlVRJ0kCGwMF +CRLP94AFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQsmmV4xAlBWgDWg/9HhWo +4WKMZ7axMGJpv6BYxfIkTD+AM/50W9PW569OshBLSqCXK4EL6uFKW4hC3R9R7ecn +TFgdT914Aa8EG4+7pB/5T8p9hGS8lOFh2WI9CRXiW9CyacJvI2t1KEawrZITVY0e +nZ0YFdIhhqY6Fa7LhtNMG3blqoy4Ct2JdmF1DACRzIfoFIxjEM9Xb/LgD4vKn6tA +uQqUXlxS7lBsMUVhUDxXu9mfLEy2wH8tXSVXcP5RRTLZmOTV9s35izX+fcmKHCa+ +wVX04D+kyFQoacfiXbPvxkvmVmCPfiB3rhaCfvhE0Oea/I9Vo2IrUzQ+N9mCPSTX +hCVNtQ6BkdKShp5v2+A7CIr5HX0qS3nKibNBc8SlEPpVxrPhmtLoKI9qMEHT94jg +pGDj6enNExWWi89h/WERsy5ELIbE4DJzbK3tmTIPVQ/8P2Y6D+H5hIfjCkXAF+/E +loYLEzVRhHGHgJOa8tmv2ILxBffcqiBmJomUQXzlmCqsmP4vXDdCoSTw2ot/qJs4 +sSHif3DXLMKm3s28FjMp84AJpRZuXmiteeoB+B39SfTVOrquvjoRLXO4y/TqfhaO +PjJx5JxZHcRIaAY0XqINRJrTMqYlOinjNbR/z0p3097frKnFx9QPl9XEHUPlNUL3 +PiAyQ3vUZDtyNDppvuLqEXMtHob2I4aeCR8ZsfyJAlcEEwEKACoCGwMFCRLP94AF +CwkIBwMFFQoJCAsFFgIDAQACHgECF4AFAlVRJ/kCGQEAIQkQsmmV4xAlBWgWIQTj +/yg5wEiyXAhN6+myaZXjECUFaGTpD/9XXlvKLaRH+5HgbXoQKQBrenOF0DU3Mfzv +kiMEYAyOBGzHDq9p4hziH+gnd/FDuB8SD4GN2KzLLxUsjm5XVoAAql7raE5s+9H9 +C3XO07/4SVZVbjouj3UIHTzYgjJZJrws6Mg8XRt2q+hUJPbNN1gPUC7VrQAPhYdt +YtYXaQqkPMLW77uWIdAhCZThfNw1pfrMnp3fnc1MPP5N2T11ZZnzIdzVYju8rBmJ +vABQiy4UUm7Ux+wMc8PAmkgiyvb8tYnC6Z6d/j1cepnZ6KXsSWYDur+KL8BCAQHG +WfqEGg84Qdw72Dd8LT5421pPKZRJxQseKLz+zkGrS4oCxQJDAnyBSOEfNZqZ+AW5 +ZBm3CKxl4DVInVWAPntpcoXAezVMTY7/AUVNLB9oHd6QnMr0I+GNwUB4yXfywCgX +i9sgaulGhbiO+Q9Wpxc2iqlLEnI5ttzUqyWX1p8iZ3Stn/vqG8KTME8tMkLBHzhd +syC9BOacXoAaV32+VC8g2oPA9TAPIBr+GnvZIHEcPE7Gag0a/HWgUwTjJzctNQXF +HG9X7dWxYUi+PCmgHWKOy3kuFOz+jNxWJkIIzYjcp4CmQ/mcDJqFKeZ5BD0guv99 +h8pGT6ntapS0UO59QLPWgwshfHrJ3Wky2jx1PKqRJe24D2LJpPHHM7Bv0vts9TQJ +QqMRSLNmdIkBTgQQAQgAOBYhBFcWlZWw3cKgNA6ZA+Hq3HzRL5njBQJfV2GeGhSA +AAAAAA0ABHJlbUBnbnVwZy5vcmdBTk5JAAoJEOHq3HzRL5nji0AIAItRQXbECp5s +JC/TP2LDUZN6E2hksidawG3izmDpVaIpLw0+2nCcVfD/M2/KrNZW/Z813PjfLhBg +g9Ar6oB1N6X7UM8sKNO6zt4g9VVziFvN0Rl4osnE6eO0hlYRq0hWsjKmDTnKA3fg +CcNZwdtLhsU4m3f3nP79aJIGzdmnsTzEUckFhxXuG7Yr4YOqS54wkIXQt9XchZIe +aPok6oYT8zDqJP7ChD/wp49ZbAedr29VL/+XvyEOXe8xhmM4N97qIaUdVwkXALnR +9eor/YftUvPlTFVGo3IB8L6xa1mG+6WH+8q53E62CrIGMEnycX7015JwXrz++003 +mP5EyUzLFIiJAhwEEAEKAAYFAlfDYMwACgkQcpayT/HOoi76mRAAhuxCj/CeC0a/ +Y5BnvOFtnB7AvTXA++8uhNDjxOYT8nbj5Y2K8ClRlqi9X0zCf2hYHsRUliGpCEy5 +wzrTjKZj5FU0P/fWrFAhHhnhbMOU+3ZCDvlvvKkXxZ/0wbHbWKLTmSkVuispjqPH +Rdi7lwBO6n6yqt1/q5bTKYF9hT+6WHL05h9SyUMx+vhmgq2+/IlDWq7dVFo0Y5v9 +at24Gk8zUGY2KL85pNn/RCQUXl3DhMxp+//Bp4qaSI9x9lJ+K524JHlq5435CQ/8 +d7XmYyS3E9+A5K/TaRy/DRS6bt3+Um4GMmUS7MV89hbKummLwUf5dHmukWgKnXjI +fxxA3SCRrYH85V99wGqXMPnRox64etnbUFUGG4uPCU5KoXg+o4xTYQ6CxZCu2PFz +0CKRNzHjK4/Xg1dd46mzsUp+WYDD59SNMmTbFmDgyul+ZpbB6agHymdi8bMaKcap +EI11HxPrEOBfWzK179TzUIhHzxx4cwN3QSLcyDXYKYIhOD2fXwp86BZqzdL37t78 +fhHh8KAazLCJL6x+LU8E08qxGWOmqGmaH8yXQwFVBgvZwKb8JXJK7+cxutxBHmD2 +LXJvwJYt1RpL3tOzqYMIM3sigEosAn9kjDPvSCnLczssKo6VuRwUvjfs38SgWERW +kho+QVRKfl+Z+wfHjxtw9VGpNDxEP/i0McWBdWthc3ogTGFuZ2EgKFdvcmsgZS1t +YWlsIGFjY291bnQpIDxhbWJ2QGZiLmNvbT6JAlQEEwEKAD4CGwMFCwkIBwMFFQoJ +CAsFFgIDAQACHgECF4AWIQTj/yg5wEiyXAhN6+myaZXjECUFaAUCYJF1qwUJVjAe +EAAKCRCyaZXjECUFaOX2D/4i7GoGoCvSDelslxAuiQHO1lssrVLnaHRVYMxOMrYs +QK3oPRKNU0rJP9KdyOTL/mcGMf2mzknF/EohcYNMzQeyPCjjWUUrDRmOGVykZZ6X +QB6cRWilDugpIEhMxf7lpE99h5PyYxwS407A/8QkcSVg/Dc2/TfeRT/sjbmpucBo +P7K7vHi5u3DJ2SJiLYoIYfMSPXmsEvBn+CmbWgrfnag2wmC0Ct4PD3mHfx7bQBoA +2m2InGLJGDpZ13FM9I5ZJuEDwja3DYfvMRrFNP8UqTplOKN1T0Ed/tdEVV9cWd8o +i1hzhDINhmDVTMBqHT9THfkgJLt546gvQOdqfHF39/jBaSPkZl7fUZ/v9EiiWaNl +xiEglaFdJ4L0qORCRd0a7oDZF9+rOYZrx3n4EQNIMOXkmOIS+GoMlxmqSX+65YzZ +yICDE+6V3ofW8ZvJqrYhBJdv65vZtDIXAosruD6s2qhzUbWDO9z2lQUUL6E9r/+N +iRThDNITHw+HxYPYLCHwhMaoWFvHL4XY4lzByBLiQO2mUM9Ksai+AL+dYWQaIhj6 +DmkaldbCrNznGUoIwBKXrvv3XCTTBvs0JVLQvPyCGCWjSuKApfOSVeCCUrhli4vi +tYdDuK3+7nqLB6W1jSt3e6aWHSGEiHZIzbWy7i6gl41mxUM/ke6fRLHvoQPh2IA4 +G4kBHAQTAQoABgUCVVKOTAAKCRDyIcXSxGLN+AmtCACxZgrLk2X97nFs7mfubLlU +eBTS+gQ/WchF00sJAdrpckhSFNYCkp+tjm7nxHYy5g2fHc8dJ+ruF+/c68LfeJ5n +fklgrRiDcji9jPv3fCifCIQJfZGqqTYLZui9/UR8cI43e+4nrM4Ubnjcv5QZyJQd +KXUvcbkNI4sYxSxdTLfNRjDTCpF+16lhJkc/FMKcE/T8gqFJDT2tNNL0zEFrPENz +89zn4N39D+J7hCb5EulZQ9kw8GSkygfUOnIHq8VbyGkZg4bGEmMX3xedT7KsxI0e +IIjUViu8oRO6p7WExPO2VeiZxZy6umw0c4gPOaTR3un3eBHagq12G1JgYb69wIEB +iQIcBBMBAgAGBQJVUnObAAoJEJm13gswlmVpXYQQAJvWoKyd/qq3EWaF2CwJjMFE +pN8tDoP7BSlmBnO34M6pr1wdTsNUcA9U0Z80OCUbxkMKyetzL3Vc6ZhtdPBPzWOV +2YcGOP3g4OUaO/y00cHDKudi0ajiIQfLHOhTNwiBqSD0TBex5vfrYga6/TQZtsio +cytjEKwSy3A6g0ZK0IDYAITUFMdLHongt+it9vDUeRZkBdEVbNUVZblLNsSS0/MZ +nxvtlsJ9akpFaBxnaGChy1V4Fw9/EPvVT3fxYPUMo0FJsOoi8NnpUajeZLD+CV6I +I0kAsor0AijkduvnsIFV2NktBZ8Np2F72bqDdUSCTo/TkYv6dyK9lI+jjRd94AyT +EP3YMcqhZYU31rH86Uq5HPQOpfzvItdriL2QbCWk0UEiPk5ijALJPvLWswUYXmdV +f4qBFqD9eJ8fB/ekQSvhIXsSSe9vM/1fcvBRw1TJViOCYW77Z8lC2cuSjddQ28rj +z0RdvKt3gfVeiRos5MZ5jDETxpoGRRAD9qf+p0JOTsJYN+xj04FTbY3vMl948pSi +FTF8MbDiw8IyFTwOv7i6if2StPiS4ccSt0BRtYQnay/bKJ+n8SRlKOuAchCWtlM8 +U0x1lE8GnoKTWv8BozbqKw5OSNETGkKH+63QCo60oXpGDw3e9ORnESFMKDMRCCrR ++m5Xxdjq36ZxTRf/+yd/iQIcBBMBAgAGBQJVUnptAAoJEOD6iBWTWC2RxXAP/3Zg +mmHo1nxaM8emN30NoZWrxD+OM0eHav4Xe99D5jyxBYdgwQy92JPXEYRGzSd2pCi3 +bytDfmmKUiSwYFVcbY4ZqnC1mfaMN8Mty6n6L0NIAy+Ix4cZxWFvJGln6jLk8Jlg +m+BXKvZaclPmOJTrweWrgq2w0UeT8s+NX8+t8BZHnD7oliyBXzCOQEAN6UzBBqSQ +NFEVjs+5fRJ3rmlqVhLe0cwoxnGMlMNUEbxbTRdQK2ZpV5P7tWNl9I5ydSEhW5ws +v4LK+EOGHHRmiUjnxYSpsP2JszNcb+GJA6GPt26CEM7sS+Pl0dvM3inpjnscP6Jh +OQxOF6bczVHX1yT98/Cr6Aksqgycz5JyEvLca93GKVLt2C1lNuJXyaUMLpYzr7jR +APEp0dY4MGG3yO/A/lvdPWbrRJWpT0gBJAD8djrxYeeljaE0jUlYZUadu4XRVbZg +biSNgLnZQUuxe86xwjwCH1t8v6itDXyWroML7anOfl2iPdFywI687xEKaKjbIzPi ++FCcttQzuFVuDR7Y4ojv5X4OL0RU+XlLbdvqNfDTPWRfqGcYQ7jxMLA/JtHjxQNh +6q/vDqvF56Lxaj/YiPdtZb7zDQqybZX0UjEmyziFsn4gDpMyQcG3vu0MLjqwK4/L +MoQowcwhikLDfnpexzx6kFwSm82sJTraI/2BUS2AiQIcBBMBCAAGBQJVUnvFAAoJ +EN61R1ghsLNjsYQP/183jZ0N1z/nYvZYNhejc95IrNPEXvMsI7I8FLZvhCeOk0xO +jmy4nOieUFc5CCIz/khFlKaIadpp57+cAcF1jOTuV7rrMlrud3qZtdF/qYacYrzq +nFe/L/pThNzGvSB2sJRPA50KEc8jVbM0DuCn7NRZrHfHB9W2BXmMt4LTe8ou6eeX +pnST5XUM/Sn47xiOfr74xFqAY3Ef5k1O/6Vue9sQIYLmDUhSUiMVkU8O/9Y/Onhe +aXhmAqrDVkCK3r0JCEYULBxejrfVDMbPsnsS9bPRgKwDxPSrwAh87l3ssDgQa+K/ +2xybuk//0MLrW9nqI6A7zMlZ+z7V7/cc24XGtZYUkJnZq/xsscS1Tq53x8nxE/Jr +UNx+zoRagAhH1902zz+uRLZQR6ObNEy1alIcAJOWD5iodftd+mc31rRhJdqIU/1p +lccgR9+TZOEUlnM6MCI7rBabOOPQrDGWVX9d7NtWUSSv0Eqc/QTnhMnQ9x5xkQJ6 +z1Tiutd1XRe7O1Gfm6LYXG+3fX7oB/obstVCbuAYskipgBbcm1+YaUKUkp7ed4oA +LQfU4s3GfdSwvbawbCOOdbCml1cbsNXtToqHRP3W3TvAk0glgN653LK1rvbnMWED +BAXoyofEHqTKWJkUZ9a4wD3KtRkdpCfhC+eZIJksv11i1mZU0+nNbVUc9bYTiQIc +BBMBCAAGBQJVUn2FAAoJEP9U4S4cphmymTIQANnW277hmIzyosSp1QpwI4ZnjDhB +ssXLE8JaXciG7YV0I4KcgJ9qYgzoXG/epiN87QN08G7is86KN4KCm0gFIAt/kUK+ +2DrWfTSSnjhQVUo+tOsfVZ7Yb8BvB6rxIoNWsXvNPY4o5mWFVNWWNkgHJQK4urRm +JM/Wvd8sJU+zRBzXvao3wTiugCTpecZnS5H30EnGGfete5QbsBa9foha47wOrvoa +lk5SUdlihIGWFqF/DcvUjJQE+r0ShtQk4VrqiYaRPD06pYi6bxcztPpfhiVtSYqu +ULu5uAebxI5FvX750CoGStNLLZuvuQvuEuCPsSuF6BVWEqyLxXiSYAPCLwCtwP0p +sRs+T1dpwP12m9xfY8V4D5bae3aeDDcO8c9RDLEkKgRZnqhdR1o4VpZ5IKZcNrIO +FHpqlDE7QSHezAfP9vOylUndwqZDTu8RQ/jImmAK4se/iJsXYHU2Jc+NwBMsYRHH +yaJGX7fYNdUWICo2yPe8GiM/4pkGqQoru82bAJbRPBBVHQ5JnT0ZI7fqNRjyVFx2 +xyyspBEC4t46h0Kq1uHCQD6+/azZ/RRiyJfgL78iPJpTnd/50OnUv7aDpX7jUqpG +q/dfSXTloWS2fZJO0/0Owq3opTWnpm2BSG5yonc4sKwVM6OEGiORAPCPxkzJhcUi +5R463KR8q1SVuotkiQIcBBMBCAAGBQJVUoQqAAoJEJE/N13mKpcMz3UP/3LoyHa+ +pME/I3xIlM0v+WA7d818QABictBZP4is+hvztG1mUcGCnbYXRF4G3tgeIbkJGL64 +RZ2pHcLu9qyEQOQ7IofzYHSRG1OsFyBspoiIgyRhEsToBB3x12D5RamJ3xTlr82N +gCLpi+kRDNfHIUSSFIhDsIxVNGnTyUXX6Nvb4fwNx4ef+5gQCuazUp5qUoMQPEcA +hFzAgyPPNpSWFD0LlxUxx0kC0KhuXVEE1SjE/9IllNkUPpUD+cA01pv+PTygig6G +HN9HT2IjtRXAyNe+4k/8GMN0uuLwnsXTOaX9m3tchv5X8cvj+f+sFh3vhhQ/erYh +GJtdjC/S5vNAI1/pZe74aET4iVE7djru0KbqmuAabRrbnmrhrsJ3zvl3WGE+CFXv +mAdcMoS9xrjToO+Xjz/qB9KzyYGtbrP7yN+YCiXbclbQqOAzy4tX7TwxBQwevLzG +keGKKmu4dvgszZh8hUX6i1BSGaxpo+8GKQi4iPPVdsnrDHQw9sTl9DEftwMBvH6W +KsHeqOmH+Jl2vIWx9aP1AiAC1O7IICcxwd4bgVAAOzmq99h3JJXqC747ODsa/XO5 +2bjUNxx4UFvVYgQKauLBMdQ/BfMpUIVwm5fQxSFw7xDmwsaolTzqUNwKT3Z/UU6U +ZIS4ULPRgJDVWxRdJ4nJRDF+HmXx8ms3SxN9iQIcBBMBCgAGBQJVUnlvAAoJEKi1 +H16AMszkLJEP/jHyjlzF7zJO1K+6n4WNhoAiSZaTrzKEhKUhBiLEwCR+qB72GEwd +VFMeFoLPkI+Qws89g8B5nORwK7skiE4cX9MPjhSp8AqjwIyTwbi6ux+MTQybvUb+ +h2BsjnRZ4Wrq+sn5II5sO3NgtnVuSE9PcohzMN4wp/P+5zApTeot/FcCWezT+Dzu +i+PkhYDZdDAmRCijSmoNf17aDaHWTIqjC8eSkuoNIRZCMWoOaEmRdTsXRvpePCfO +GqrEXAaB0WyQMb7f/2yRZqbRpBPy8OGNVlAzSLlXxhe6jcrEN16KzpOm8lIpQrgR +xgX31H7PDoTx6x7OKAxeVO6OkDxQS2u6YMpnGiS7BmnGYK161BXIU2VczPrhIsAM +uyxhRywZLD/uBjJh3a8qanNmXoleJSZ0kcjpGs3usNzCflJECN6d7IfoVIyWdaE9 +uUYwOaYdGFO8MoyQV+iSzVSNukurud2iC+z1FOmbHh4TsJaPQqZ5iAC2bLRXnS69 +3hPMZKMgJKxg0ah/RB52TQaOmyVtGEngkENayCZUFV4xvHTmhSmYbvwS7OSppoj+ +tu22v7EzhX558DgyMcXo3zpHbMSFcSQ36Ba5D+ub1i4oF1/WDmSplqq+SfsRzZL1 +1+UHrmPWV/j7JwQgosptc6OQ1AV6uUDwOvh5whkjki2ec2X+/aG6vnZSiQIcBBMB +CgAGBQJVUoRoAAoJEK3dQuDpdK2PCj4P/2bkpd/0GpDqgtzfDG/rpuwz4spnaKwE +8yzpAiJp2FMle4dziypqzAbTqk1Zag9Hb/1BpnAQ16/G2n+9q/f0nd1OpzPIZoPu +tuocAyurshCAddYp6V6u96pH434zI8qwTYS9hPlUHdAqUjXsmRf3ThnDXwm9emAx +DiKoABR8fOf7Z326q0kJ5k7oGTnlbcNJ11VxRDr/Isirbg3q2jNZ+x0NirNJL3lm +T/3xsP4jO1o4BoC3p/fEkA+KYXSUM6ch4xvxdQG3svstUtvShfYl9sPCAiJ1+bde ++JS1VNP+86DytjU5l3KO4kXjDi5stC5j4al4Yctor3U3fmmwK/KP4X1zcNEalSEz +H7CQNbhznCUrCPfrewuy8rNesu3+ioT9WfQeNI2MNSAj4seavgyDGCM8WITVG6Wz +j8I/F9R1rItf8ZzJWMFn9okcz4j04spvr0R1kLFjApZFhgJbs723OAFnePPn2Or1 +iLcGeENoyn9YAgg1M7k0bUJSQXSqcpI6huX00vzdUszxFMTSUgCxWajIUF53ZLPf +cUuiuM/W2HBqxX89dEbFdtIynayr0DmV+E6bCZpcB0nLUXH4yXZomGqd4gNcrFej +zDxjPkyonRYo9MjsXNKlhMdqfLdTt6ywhLrn1DTDesgOobGTNkdOiOcjOsqbHk5g +Lf7TWNvfvneQiQIiBBMBCgAMBQJVUnR/BYMHhh+AAAoJEPyfteEhTukrH4UP/R7a +/Vw3i6Z2hcAxrtUzkYZpXRlrvTf2rjSBq+d+HPN7wNq3zvALvND67j6wAVYMXEEk +C19l+ZLapIqR5Xuf8q0fwSx3UcoAsa90pbWDyqamxx/AP4HKFhoamEY8oNMZkD1x +H8BRq2Vr72J8U1Bz9SXl9HIKvNdy1du1obS+0ORdcgpB148IhEeefSnGIIgRhIJF +VvBDsoq0lc3TSdBvHvqP+Mwwh68wQmILuu67XkKRkJettn7W5HocoCxc4adS1WbC +ZToPprW98RHEUACk7RhVxel1md/EuecNmh9JM4FT1dppAerk/ad6PDN2nG/KINd4 +bJ8fXij5X9hs9JsSGTnYFAJRa4JptDjAb4aks5BfmXLpbeneT8KQt9mlDXifDKOY +bx2PsmlqDoF4wI/gJRzxJ1/5yL3BOQkbcUe8js/aINJGKyySXRAe4qqg3HqiqCWO +pU9DkJsEY5BCI8cIrxSMjqqkZ5LJIktHNcezuSKeWpyqQgKn57ivQAHsLanAOdnD +iWycdAOQ2A64b4EznMCbDjGHbssacYI70R9JYrM8Plx7OHn+QUTEDJztd5TU18u8 +K2ouEOGLJRMmn0of+stE5HIw5r2ecqIr+XVqV0M84yEdwnLBA/fsWZbA9vnMWwr6 +QlZlCCDMcjS6cx/C/M0tDCUl2rKhpkgaTZ/d/I7LiQIcBBMBCgAGBQJVUq89AAoJ +EOCV2+anxaJm5gYP/1zrO8ozHabypD8wB+jsKLYUkWEaN+dijTNsLvddGWu2LF7N +G4rh8zsiHG/FuhwOjfm+5zAQ6Uybl5jxi8wUyc4XhajbFA6Zc6fp/xn0mD+TnQLN +aqBoMWwO/vzyYBmM/DwQ8bsss0j6k5jbUMX6CoCryB7B5X1iAlRr+5EWr3NDgtt0 +8qtufIL9dYVBFG0ck8IR0jvTRxEFdGXaywgBYtWx/mlfn42J5FRXjNhF3vYVQg7F +E/iHs6s8OdlNju4kllC9zt5Jti33MP9yoITXkSnymvMr2qZOMIz0TxbmhKW7RH6/ +hscjLMvz4IhLysniK47a9UrD86zd98Q1Sqjst8m8jAiZXnPECQkKbsIlIqhhCRwd +oXrA5zZ6QD4XmLnTj3L7rEYuElUly6SDZEnhNS1T+JX/X12LWBxjeRxPSMQRyoM2 +Fdykb0RmCq278hKkJyqMKZQXbyhdjDTePnF2rujV9wywtsVD0wHc9bD2qqGWjzPM +yj9HXPhz+fKpC1dXfM9aRDZCGa4gWvr4NjjX8sjV9o8FY+mDhqN1dyS8v1WaBsXZ +mr6u3HZuj6EGjyWVmrfWE2zMKdjonAJaLy5eQhq8uio/69M0nXGSv3hAqN5t0UD/ +pgoYgm3APwf9h1USVRsYuGr+IJWg9PiB1A6DJ7/3Geik0MBPykQ+hz5LINhoiQIc +BBMBCgAGBQJVU3tYAAoJEHWlUacilewfdpgQAKHzOHF8jc2NQk7rqtEvjxbixa4o +zbamXbvrqMzjqTm3gg/h8b5npiqdFJij1IW7V1nPIyS3ZeYHd9EdoVwAR39GhQ2T +ET8GAai+fjbsnDEvbITwOLoSZkOrpgGs+rbq5plvPYy2S/Ca8ZJPpBi0gJL1wvo0 +ulztlp5ZbhyvGk8rQL1K9oJkxqCgel82MWRjNM1Pzf7ErD0NUDkBRQocz21n1J6/ +QvTq0ws7d9Nl7TQWkQ61Fw8EDlHkY+wrAJ2rE6ikR6Npd2spLEzFroxhkytejl8Q +Ewe9Z+okL1KOC3HoEKWNMaGlYisI3d+Nr9jTYRYr6kNrWYNTqZUfm6soqMuSaEeW +EuS0RVFCLK32wOFf/mFQiI3ZaetjApPxdOag6CbgKvF3v+2dzVhsOOc58z+7wcb9 ++hJYiyAxZRaNA6wv/rh/Ug35bj80oK8SNqUxHbN+AdK/1A6ZDD6VWIUrWKZH5LnS +rS476agy1miCrqbGG1xcrS+Kw72ByZskF90B84lgeoPNtzW75ut/+HFVvlgmsyDr +C+N31vMPGQcf54Z9mtvJC3ruSk6tHtUx9HHGasyatMfqP1NjsEDq2N8ovYIonCCJ +qpY77qZ7p7XYC2UXmzc85ZocucUMLkAh0fdzTXT+7tHDBhV6TPLHlqFSThbIeV6n +r4tgtmbVV0YOji0uiQEcBBMBCgAGBQJVU4upAAoJEL0AzR68SXz9cxcH/3XynlSA +hXm6iLZ1nE4ynwSBO59ecAfVJyd3P0SNecl5V7g/rtw11e9WzDOQlGpAn7l25P4n +khcsnZyFBb5euFgFJ3rRp7ZwSO210SAd6AspNSYbVRWBwGbbZEYfNGoK4cwMJg/i ++lWq9J9BpcgnW7ZBBjTm5SLEtY6GxOJ1cyXRRfk6RT/+bmdQxA7BUp6GW3qaNGKA +Upf7ozH9TRiKHrkv9qBkF6jBToW3SNTP20Cqsc20/PnICUTNWAppK7C9fKn9Kd+k +3u2jZQ43TXSBGDN6++cU47Izx7F8sSlqtcywUkCUO/diZYe5fSIy0dFHS7wo8+wj +9UpnRJveyR5bOAqJARwEEwECAAYFAlVUBzoACgkQmUUzfyiIPsuMsQf/dHd4Cmqn +wHPGrBawyFbcMZSn0CnlaC3pUJof8fBpBu3Og0A84YcX9Zoh9VRSyVZl4bBtcyk8 +GM3p21bTII1bi604KM8KTH7wcubRvFbSsz1QdCPxTI3RfuJ4m8HWxm3yzHrYPfcl +tvMVmdylqOE15Y35o6jZrxFE6+UgWnhz29xTOri8Ec4uPnlvRsSrySooi5CohYkl +SuQzVLY4CJNEs5N7ktw4QDtmNZgzHtpQuRuZAIT0zEW+h988mhu5UNO4Inj6nPuS +/+3fMrnZYtebJGWX60i+csR0NlQ642EMfZN6ZWaRRmTkG4v9oVXzECjRhvmneC2u +CVKdl8TH0fjbsokCHAQTAQIABgUCVVOi0gAKCRCCQz41h7KufeNID/95ZZNV/1Sk +PUAQ7REQ4CH9w3bCmi1fWUYcXaj3GRjHPUfoMWErxnIKHR7JbiL4aVNNpXvvKpDZ +1H1TuBMCmfPoQ/ZyzfYHiLt8KDInqJmM+98IafwRcnFVdWz72fwSWlB6Syp3VE8M +Vk7JvgLUjft6jWfxp/isygSagkyHGgP6tHw1SZDUU+RffryfWam/N1pw0NTYdffJ +HeYVl8x5dI9PI4owNf/qHizVb/b1TEtBfzMDbc9B2lMVvK7IBD6MTsPW9Z/PVF25 +DkKMegRN3QJXGzgpmj1bQvC2mpv7+LiPRY8WeiKlobvlI1VtNNHkCyPxnarCRH0y +zcpS009UFEzDQAlSu3Q/DE2z1+lXEDzcQ0n8TDASfDSdpcm/Zxh8j9ainFtrj3Wb +M7KHwoaGJsy/o8+WxBDBl3FIJZdCG9toaXL47XHfwNaN+k2ICk1zinFuutDk+/Pk +g4kFDxQvNWYCTXz+YhIVwKqF5QDO7Dmm9f7tM0PGOr3fUzEYLm4nTB1oKpg6rdxD +QGmCXzlCMiGZdmUPlngn439KBInsKTwah8RtNVQVWcV6t9P6gBPCCH9Sb/wcNcft +287zKv7Hg1Ezt2ceKKvQtGNs3k0NBdco4dyimJefBlWMu5E9H2MxLcuE0SAWeRXA +zJCbuGIF3BAECz2I1d68me3yhzshXgMG9okCHAQTAQIABgUCVVVFXQAKCRDalBBI +g4QoJp5ZEACYmWwPcCc6Zv/saPXJsiEfXl85/yzS5Py3+J/YD1u2hpVGirv/Hmy+ +j83SrTOSaDNCU+Nzqxnqpu3VFT4n53KIp0Z0k2LYefSBqqWd3LU9Csezx4NMaYS6 +F8Z5JO8Y3oenG6TUjmPuaKe77THAPf9i99I2RBly37zkv2LvfAp78XD0MyusyeJS +eHqXT44xyq4TF/b/J3PBZJBlyxqFEi3F5pRHO6RyVBAWMEYZD0K44/EIVB4VAbkE +vDHMn9yyMgdRkLbeuQUtxsG2RBa8xflpPuHDTtIKmCnhAfUkEp4szy2xqUy2fLNf +8410YNCTJsg7OtFEZNNA+H/KJTQJ0oTSUBTlNEWbe/v0tvxIrhDGyUwkYetdSUkJ +qF8NyY9kfwyp2lqz5cEm0Io9M81djkNXTlen4nkZzscUIuUXH9jGSWwiQxROmS65 +Qz3JZ/ciVjg14CEY5LCfD+6/COJ0B4XSK3+hwJv6XnSHUInyWqzKEvamp9n6jSUy +buB5ooBQt++zCxfWiNq9s/yjPive2/bPbWHFaLAC3Z+frC15uzCOK0Fk4K6WRp28 +QvaoQC79Ycj/qSEurPMBmYoPnzqfaUP6z+h1KF97uPqjgF8m2ldRNVWX5yK+ocQr +9Fxf4wgDduD/JOTozsQgS8X62oDNG6dC7A259IIUWsgTSY9sNyJIs4kCHAQTAQIA +BgUCVVWO4QAKCRDUT8vOzklurrA/D/0YLssMLcu0LfTS1NBp5Y7ds8UByA2rc9Zl +js37909upKQwveZ/gxcGvsOkhlfhq1PClDjnss3kX1tS9LevKxavUOuq1OpAwaqD +KtJfRv3c5dyXGVrwfaWDhMruodCWTzoD8GlDyK8ED0MD4uAD1jjat1w4WbQSXwaD +YKqNvFHcRH8gqvXwG9EDgbxl44YC4nFbJR7XeMYGUeFSKlJC+dDoJuyjSCB0cMQr +5jYbgRHvMCG51KROF23CnjcqDf9jKO5btQUl81REwC6MdrtXiRLixn5MNNXgnQld +R47TZwNOVjHwx2fOdHZlb8oAlAX5JJay0uQF3yDYbY7cDEZlSxLfbRbb93H+mbYE +nOiRx59QABiO2Upu3z3bHJQbxie8gkOQuxGENkflHz70rAxKXtNVMaRUVmUnMABU +NhNtRK9m6R+cbksDGqqMdLFvWFtUikGVtmG7EVcxICeIkNrSygtJoUNpjFw6OcB6 +TNi8XKBQsYR7BjVS/HnXPIFG009rCTboFg3y3mZwQxHGuiX29d1g1KrcVbPOtKPo +bPOXA10jjR6fKDkZPRxArrsbNOPrGeMRejELZw931IySQtduWg625AxQ+1kxA4+Y +yHqh/5JTGBdDrVtjFEwYVeNPv5XRGIGn9hGUXP15L96KPElmD6vgZB/L+OKHoaLx +eUBpViy3nIkCHAQTAQIABgUCVVY7ewAKCRCi4qJtRTqL/bmUEACa4nqufTzkFhP/ +CUw/TYX18L27a8GQvuLWVNbQEdBV3/ACrT2QEnbRfuX2N5yY6hiwd0Z6doklEljn +thX3I22BXhmO00y5A+TP78vTAhNlZwHmT+Z0dUDW5GAn7WOF+rPs4aFIM890i4Y1 +4QmWybmcFv3UqHE2K9KHR3qsHtaBo0VPBlFdQW6YOkupixqFIrsox3KlM1BBYJ3P +X7gtvOVcdHPr1FOKyQqlUhAgDWljtHm+mJyY5MeYuLNgfsp9kdDwbyW06QkwNTJo +5GC7mz+iVurXOmqNR9oHqywnWohE6/LvFFYD4Ab0EIfkd/rBnR1icB/u25L4gHi9 +v29oqzixk+wlxfL+nXlDsg6khjO9vH5JSJdaxJtp3q7Intnr2WdeWyhBebQLOSqK +yo3YYe05g2wcc+uRkMXyJZZQT29iaGd7d8yBwOqdO5NvmYJxiPmTjlaglzeIakyV +83aPep2OzLOUNwJlQesVt2ewxjPsjyaah3ny8OQMN/iTbLoeQV9en2AtlSiKsgEr +QcxneN1iRunDtjT6HAFgCAc34zucFxHrvK/aOLUJewIbcKz43I4rcVVSx8wb35Zs +UDcbAVRoLfeOjgZTbaFGmjuj5y+Ums3GbnhqxtvOoERtknhQLQUQppgsNh+Sym1L +G1x0CzBNPO20uZpPqJ+FBEQ6GiGtyokCHAQTAQIABgUCVVZ9LgAKCRBY4Rux5BTZ +ra3mD/9m0BnXNbZgkMLIWyw3F/8XOeaSAZH0jQQv6pPO/ZtuEjBF5gs5p+b6NbxE +prv7hFudjjqPwvD3kbc7ZI3DXfCEG6T48bhALmxwk4BY84LwYwYAOLagOyHRksqc +Uhh+3SeH4T35LJttYwZCqDSjnlCvUJ8LaFa/MKqQXkYSVCeeB+XoGtIYW7yQD6D/ +ylTcQTXRVuFhdN17D0oermlrrXeQRyeZ8WZ5wa5mu8gD0eHlnGd+eU2TegMF8Xgm +qD/FBAaOssX0FHtYlJLhh/w0n/jdT0l4Zr7fPU+DNRstZw8ybhSpqGcNy+o0j7nA +lC2KUGWP9A6e/muafKUYuXL+NzF0OCgSbDNcZIGbk35wcCYB63O6HMuPy6yTj8gg +O5g1nhQh5AtbgjDsl6Js/HCrAYPKVaWK8RVLxFIZCZ+mTVlT1YSALnI8+IKQELr4 +CrefXmdOb26lY6T5fkWxyfJkz34yhMoYNNgz9fUXZkFbrG/vDBhT4Ec464iWAogF +iKblFVlzUH8J5UwYcUDpKGcxQ1ZBmAIIAHqKi8sQYjAkbLBr5iLVkr3xhUN3YNf+ +OKGPOnms1H2Y1LliJ/U9LJaH2yIWpe5y4V8PKyv2bM/gWtj4rMnMxfuB4Pe2VV90 +oCWTN1ZQmUqxp2GuPePZnKqdqgdrVzl78r2ic6Jq5i7SSR+6U4kCHAQTAQoABgUC +VVPCSgAKCRBP8I+qGGAA1N5nD/wMwwe0Dz3KhKl6SymPDkFvC0G280uxnKwuwfd1 +a9px30gyZ0x12wldFcIRq+IiE2wt3PLuqOoHNGQ3yPrF8NRVyQkJ6J5p5QLEnq9+ +qMrx28mQ7OqaN+w3K8X0ZjVYu87aEuA1zWDSVwNd4qggc1YAa0yAfBgb+uKUgKen +6mrq1W0+syV/G4y/zvCqUUECSOw86cFrcPcJXU9S1S+A/84f+LoC/p32BT4rN11b +iD0CFxXL6QJ3X8s8rQksDz6sBx/IjLHcJofXsc0StC2jhfdlKsWFZAyQABV7Lp9X +uS+Blk3VcNvUjEIFoC3a7LvgP0asVZyu6nk6MP/ADCjiJEFTaTgCBp1615zzhqng +10/NM7NZA88M2CG1vlqNRT+BU4cJ91x0nif6gt/jTZkMzDMPSPR0h29qvgnKisJx +Rm9FzlY331Xua2zdl6kh4fYsJzQnHDSE7ZZx5EgD1ynA97kzPN36O/wkUOIWzhtj +zwZUCixFWKk8hjYfNsdqvnRPccnJQG339MG46T8UDY+0+tVq1e3Xva/00uTM26+d +7DHhkxs1d0hst2DFFN9fp4iFiKGg7YPgHQLJ4PyKcfODVNq+D/KjJYLO2XYMiTxd +DwhTRVe6nPJzXvwrJeaZTXGNh4nZOTZoS9VWQ2ys3YZlJz7SJIAdcW6x5VIRs8Ec +Ua4MtIkCHAQTAQoABgUCVVbRGgAKCRB/2fzLAAvu7kW4D/9p4KbFMEVv6b46sZLF +OaEDJ30LiwFSRSLMIqd3/DNSELjR00+np65sAHgxWINWcTuQ1MOZZ7Y6ky8VCNqS +rlVNXlQxDEWdAxFgttvja8ASN4W6CT1zeF3bCVub8JmJGfeiNnOquAv2vOrwpOdq +4j6s/GDQ+zmNaYlCb5w6FVZ/XFQOf0PKL8qUx/9r4X5sdtP7xgTr/OcUJIzmkC5O +lte08CpMOBO6JXLZNY1GtSrjQ9dbF/PvL2EZ86kSv8j6lcNCnuJrfARNHmR5EjdL +CHWHYPbS0NnvKyhFc9y+ibq3EA9sOkA4cMqdOmBxW4MlIf1MKxE9wTGMgoF0wk3B +rSgI9Ce7uSSdymIc3Lryozo43oorUFpGYbMUhBLdep8xDh5JLwWkXwpfQUfa2Fin +MnPvgvBiJ0oJQn1ymCith5Kj4FenYPuZsdLgAgOVvEfmlXteYvdP2KLpq6T+SBfF +pe7gCQ4NMixjqB0Up6NH1bir5iVTBSJCYm4oqqsD5Jc/Krcq9kpoU76gEfriU016 +Ub7UcdlJXKTZNAK2jsG3+KH8nDe5qkMASBWnYtp/V49xkLYM5714yw0ch4c9gQ+T +q/hPfVYJcjCug0gEybXH+To+gHJ2I5EdZ/JuF4nVTUeZRT9jZ+dSic+BhJU9vxsn +zgnMb5ktwRGpIgBNA+8kce43YokBTgQQAQgAOBYhBFcWlZWw3cKgNA6ZA+Hq3HzR +L5njBQJfV2GeGhSAAAAAAA0ABHJlbUBnbnVwZy5vcmdBTk5JAAoJEOHq3HzRL5nj +gCcH/RRhFHoTnzDtwjY5rpTRA7y15s5SlS4sa5jUCnkEa71oVZNdomF5q9E1EPGL +fqkjM8xQRYCv0MbrNA4j7O2+8NWIsDZayNibA9dDfD5bbUgHgvnl0myr4sajZwm0 +Hc3xEsbYUvOaH+QTQjYuTekZNcmZNIJhLyhgae2hcii5Me5TMBOU9ids0r4p5ICK +Da8l8qb7UwiojaObmsIp4LkUmXB/Q7Eln8Wv1xsdNrWnk2XcA56AkDxGQS0NDoy8 +/xXr5JBN8+5r2p0RRNhCl1ACMJPbZBYf44qFxr/iSDt1iw3DnCQTf+Mm4fJKUK+8 +ACJlJ8ZM22H2T7f2jeJC3GUiupeJAhwEEAEKAAYFAlfDYNEACgkQcpayT/HOoi64 +pA//W7r8vheC8242JABkhxVORU5SQdNKwLay/Uj25bN+rrqgSmzMUcOuIY0yM0RQ +erV0UQU3BmOd/HlQle4spuIJOJwmtYGG3lQOP3JVg1yLwqNv9vrpgEdnz3hOJipf +QnooftGe6R4RI6+wS49dyfGZRQxgmRRw6GVKzDedahZJueSnCjxaXrgnKfqIcGZB +qmDMUXE3Cdc1dLOfBZLp/v6Rx3/eS704ZE/wLWm36arBMbs+OYz8LNZZTy+du43s ++UQH9jNC8FkEV71gMaOhslC0d0XuCdgOffL2ACIkxHJoKtmfXWGJ98QLKcYHHLP6 +q4cDTXJ4vaSUR7cUD5IGeSOcVcI7EGse+qpn0EbWW3vn43XeTh5pACYAB3Vmz4ij +M4qqafdn1cMPNEiPk7ltNsSk6l7QJpoGBlmZ4BSai0UAOxkPxwfpXJvK2VASzz8b +tpWxOiuhSwqcAKmnolZATKvpKv+MsiFdAW4tcOBdHdkhbQ2NMpemb522aYpAt8Rc +zp5OACiQ0c47+muNs1UV228/fECHO3S290AGEq4CmxzF6i6UaLt/KsDazFo65H4B +hrbjqi7LIkCL7rzVYoFSsz+MGdMgiIPbaktg6XiwxZdDfGMPbA/QV4wzKmdTLFYW +/MuB58eu9z1hOXYsbEiXHsXvc1qIG81BUjoFVMmGqUcfVEKJAj0EEwEKACcFAlVR +J/gCGwMFCRLP94AFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQsmmV4xAlBWib +chAAj5YtzBclKACs0owhglt7eVds7EKmMfMS9T1gT0B/gb7h6or4tfgYrLdQSClJ +nI4g1OR+Nt0UuTSvRLTqwBhSYW0IN9ZkGvumP/W++T27w8l/zij4H+1eRRvPbVDw +VGYN+VWzUutOKOBqnzEvBOpGE1a+g1HY0QwIa4/9fTjtJo8rBrTFsFMT3P9nNwh3 +tzIltiWAVcDYv8do/Zf5wAytfDg1F2uV6hJr5BClmC/K39ny05cmYFeFz7uX86wq +DiRdZ81H/2jkbQr0vwk1+ttELVGLrqc2JquvKmbbe4eFQz7pLk4d/A/PASLgJQQX +J+zxDqUddGbwd+6KEt+Oj3rAeHplvfO6ljSc0CvDYs3Sti9/llnp9KyxyJ1EjOBP +my0PyGfHMveZhy1Cr/q2EPP7eRkNV/5aUxVrkkUzRlcivJpg/B2Tn6uCAI8oH/yv +/m89ryZxgsEgeu4uGSNAunZWPhoCGbX8k9h0ksqYQutlezw6e8Y95xJI43dSyVdq +85TnYdXRoSbejS0Ra60z1CaAZEAPZl5iE+EUjM63BWtWptvcybGqt8vk0daa6Ps3 +YpXCd3p6MN8Ko0pwM5wSigcPc8nS4D4gpYMZXvlL7w6lnso6ch78TfjsJzX1qi76 +dOKrOblsXKG8l4T7HPRvvBuFCUTv5KsMGrhsuk3T1xtA1e/R/wAAX7X/AABfsAEQ +AAEBAAAAAAAAAAAAAAAA/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAIBAQEBAQIB +AQECAgICAgQDAgICAgUEBAMEBgUGBgYFBgYHBwkIBwcJBwYGCAsICQoKCwsLBggM +DAsKDAkKCwr/2wBDAQICAgICAgUDAwUKBwYHCgoKCgoKCgoKCgoKCgoKCgoKCgoK +CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr/wgARCAEAAQADARIAAhEBAxEB +/8QAHgAAAAYDAQEAAAAAAAAAAAAAAwQFBgcIAQIJAAr/2gAIAQEAAAAA6t7KPASh +d1LbCp5oYc2UMn9NdhjhVrphdXbHKKdPr1S81+2WflBTbsWDDyreVj5gkcG9r4zh +joQrndfLmoX2yvIOvGMfIvNVnbHaGVkUwEvglTwoBg+Cxiiy6DdN+dP0y9Awq27M +v5WLETfZDYZbNH1IQIQYMBQ1KNsB5yAk1k5696elAdaNq2/PVN9kJZwtinTZ0wYz +omhqngsCqj/a8QUp6D9ogKx5pdw3tBak8mqJpdUTxccTYuKoCapZVyPjdGobJf0G +AVh2pfw5txakgiCnDeTywpHjIRTKaibF16Qn4sc5VP6LQavZr78/N1pkJNBtwwOn +EZIsPLmUmL44YTcSEMa3N1njR1292i1XfVS4qW+lFtVLrUplIuWZgmy4y6lwmkRn +EjqswdjO1dxqXw59BcnVgrZzxhaapvgOCLEPKB46iRff1sFebGYyefpiVrK9Hswv +I1E3R2UftYefvN17yPYqLN2DRxFj2TNnxYi00/QtziZsETdOd0r4NPeij+7CvGr9 +UOa7qTbOpTeqVWe1lT7ZwV51dCnrU2t8iQbeFju+9r2XKfzz0zPVhYvKKBXrbkD0 +OIqMUZ8ULD4uUqwaxF+ZLJkGI5pSf9cZ26CaVjUeTdSZAtbsdbjYRCEapSm4LMLE +UKBR+uoDRwyBLFbbJXTzWQaldEnVOguqjlLabYJIrhlBaRQlbc+4XE5nK+IXtPZT +es2WhziZUxjePiopIVgNV5PwsuH9fDP19qLnVGfddfHrTqbqHWZ3nSOxNUFKQe25 +qkDQ+3XuOfVXs7HI3lC6Xh605yhc9SrjBDHCVNasSu5novrLDISKbdTxXBD1rTwg +9a8eGV6ZQ/nYE8oJUDkh7iTlF8Np0oSCsrZ7Mnz3gUzWvOdxojpwqhYVwWKlRFAt +pl6J5ueEjTCsqRtGs2+dhRq3+38KJy/eBdU0YUaiRXGMrxYXliaHnY2XnCXS7i6b +jDVx97IyhztbxxyIFcY2fCGtI7Zl4miJNv7guAB8znvsKNXXXPhDMK0uGWk6q0mx +i2CsnvpEaC9IzzvILtY9xZGHErt72fDKPLo0XErw6kBSfC2ZNudyQ/LdlDjgs6AI +MOLXPfONhVLnCjlfVMfEoSJDNaJgvM6yzGd8nnpBsKGKKKNXEXfbGyjQuH1AgwWn +IDzgCpM0XId74Ju156q94i24ww9b9xs7CNfmfuhq7Xb46u2o3dkpSq7yb4GI887w +dagBhDFdNtRdzNVqBTkyWynJ+iL4cQ9aUcRTQ1HjBPHdq3JcwarpoIJunVY5SXjK +RmmNxQSGebYr4uqGsJJmPeJdj+ofX1zmR68YxuahGsNB7FyEisNI9FNfHpG06X+0 +Zb2bUCcoLfdCb43dDHr57G7WiSvcGVNvC6GyjNV3qK4oKKIhoxxkVg5/dCLS3D6H +ubev2PDV2UKYPTlDdWaBRkIvl6LoKA10ptRDVis/Qa70jXHtV7//xAAUAQEAAAAA +AAAAAAAAAAAAAAAA/9oACAECEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/xAAUAQEAAAAA +AAAAAAAAAAAAAAAA/9oACAEDEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/xAAyEAABAwMD +AwIFAwUBAQEAAAACAQMEAAUSBhETBxQhIjEQFSMyQQgWYSAkQlFxMyUn/9oACAEB +AAEIAvNJUdN1r9U+pgvGv49gZt7YkeBaXiowY5KSoygIKDipJ96Jyiu6IKLjuiBx +lttXbClGzkm1YmI7kDbm3gyMVWkQy3VRRNhQ1FtSVU4VUd6INt6fQULGv8t6x49h +BhEdTYtV2ru7SpLe4XCZqP6f9QP6a6rW0aNEx9Pw38Ui+ajkjf1T19Mi3jqLebnA +tbPcuY1YGWmGhcVA5fBluiLWCu7Nk0BIi8Y+S46ER38tiCFTjfilEgRERpBQMqwE +/qU7sgVgLaeEZaBOReNR2pwR9qlKC+lUUi9K44r4iNJvnU2LzwlEtZ2ImZJkjhP2 +58J0bSd1W/aYhXglrzXmk/1VwIAtMg3Ibvckc07CyjeLz9sc4UbAo4oW1OIri4U3 +mqb02i440KL703ntjSNPq+RVt5THES8i3zJuh+XSVEw5B3oWtxyFBNFFA8p4VVbJ +NlkCG6mDQKqoQNRHHCUyjxCZPGnc9vTrKIBt9wl6gusuK2X6V5Vxl9GoCzy9/h+K +8b71rBePR1zfq1Rh7ZpatAKRci2lFfltkLSYpknnJSR19qCyUiQH4pEEPuBf8VaF +UBMkQEBaVNvLbgqjlApL5QlH7ibTz9NXMEyTkAlo1Rd0ohIFyNscjzCKC+yxgFNk +cPFzLK+x0PMa1JFRozZr9JD3J0fYZUk+Ke9dcJgwekV6cchRhGMS0xCR5kESysdu +iCKNKre1CJou1Yb+aRcV8h5ptNlxT1mngycaFEFoM/NFg0WVKaY4iu22KhuqqqNs +q2Itlxtr93o32QwFCRK4QL0lDFW3OEtsfNdsqGZBqFsYe51q+yttmtzX9G9yeS33 +7Trxe9e9fjyNfqRX/wDHp27De7fFVrxV0Y5wIgMMbr9ux1yEAJgpqfkWkUyVK38p +vtslb7+EQTH00Svf4qP4QQTDanNkpBQfNZIopvv7KhtbJnSC2e+OxDsZR319qaLO +hA+TzKtaXSG9Gf1C47FJQL9I8uDG17drZJLz8Pah81+o6McnpLM2gkXKRDoxtZM4 +zothVEpwx4+RHCP0iIZ/kZTI7BRyXE3pJjjfh0p6eDabmGieFfRFUkHJS5Bw380a +tp9auZGVwJJ4I72tOz40VcXVltFuajJFkd1K8MM7K53IIPIzapYP/SpFXPEIf2Ch +9Tofb3onl/TJGRepmSl8U2966xwXrh0yucZu1q0wypNaBabYZJpZDuxpse/CSUjz +TxYt3/UcGwM4UusZsn/2XWbnknnNX4O4QXdaXAfFQdR4YySG6MOcTjTLpGGVC5y7 +CrjvEqVdrmKKLFJqIp3G+zMvDr1zAFmarkgZrSa0kOJxKd6vMps+C061m2uRxuWP +W1vmuArVvkNy2eZtCwUduqzaNEjQ/pv7Rm/d/LL4b0441FYOVJvfUeHPt8q2i32y +XN9uLodFxdxmNrui1cBMQInb1rgmlW3WpSmy3iUY0CZLAliS7Fqw/LTsW6svE3Oi +zXVJEbs1zFVUCsdx7e4tWiTp+ciwilufME5NivMooULv6uYsTm/7SDGkSMlGVaLw +qcjn7M1vKYzGD0z1+Rt9hbOleuzDeXdOmt7fd4xuOiLi21/c9Jpt0BHLPMEt3Nk6 +xI61ximgbAd15FHRRyy02w3NpK6q30bRa2Ii2fVUa9EsCTq+2sWq8sOtdPyVWyZq +Q0SIQuat7ieiW1q26Hjyd5AW7TUdpoWnXjtFtZ5ZzvUrTsc+C1T+oF0f8srqxXH8 +pdpLStwkK7DYs4tuKBW2QHpQRYSTOXezwRmW84UwdI9kg9rqe+WDQ9sRbhdOoOsN +QOCMCHJ126RbwdQ9R7T6ImmetNybkjD1Za51su0cZcWRZoM00pLGzbbmXastY/d1 +4c/+cAg0n7V0bCtDGk2Rj6ahgND77117EuWGVW5hJE1lutfgs/R6XROnTgk2Zty8 +cfM61x3k+pBBIjOBam1K3aYiuN3gmkEbrq64XG8x7ezPbYl3M5TmGnYOprz3LUXi +alf3cf5sQMC6Olb2j/0ChK2RipMixHY9My8NNnIfLULn7iuq3m43TT1wb0o9qMYs +YHr5Fjr0y0mGp9Zha52o0ldOr+3A1BpZxyyzxftLJg9GVXHHX3PS6wqu7KfXqGUy +2iwGv4Mhu9W4y01v+3IOSUK+a61W/u9OxZiaNt3Ndtz1pdrRHbc0tXTJ1wYjTKyA +TbasfPqebFBV0dVXIY7ZSEjWW6szhvE+4OW3UdhCK5Zyn2TUCPHoeRb9B2Vxhu8l +NuT6OuswH3opnJ04KszGyS3uNiAkZS07MmEciPXJXd37XfO4SXdYku5JFW2Ps6Q1 +HBnsztOWu53DTb8u6adPQ931HcCuV/0xoyVpOYZ2q23R91kQebLMt6bbMCVU6uRX +n+xYTVJhcbNHtyw2O0hMxaSvztWsbd830pMijpkOA5+OrGnHnuU+m6khkSmiq6uS +r9yG8z9GnrSAmp0Vuir4X5HD7sna+UyGxJqriYtiTdGw+8qbJDJpO3Gyw0SeCKyw +ogihIjPD6qQn4rp8ZRTRVzjwWt0F2BY7Y8uI26wWKFFzJyQwgLHiuI4S+YCYUwfq +HaMI4oVa6FS1JbefTUWNeNQRWWyWk+DKoq4ldbUti1VMtNahRwHFB7SrDtpcZoF5 +fJCGxelBBBJCfhLtT9tRfNfLXQ8DKtzo+CetwNnuDVu28vdk245vVsj8cnOozaCG +KF4FBckxm2rm5XylJK5tNW0OdQKMKMIKnxMnshIAOCorwFviLQDvgsVCQ6jD/vWD +fILk8ulLXJMekqvv4T4DtvXV6B20+DqJu/2eVLTvWn8nmoB1EUMKMvfEHmstqwVw +l2cY3RaIcS3qQAueqpENJBIKPtcacYMgeOKxG0BzdGQwb2QXEb25JrIKaGEZTdXK +lRHSUwJz2aMEIsDWNEAZCrXF58DFDJHAhs5vooiBMs7pdc5d7biTumDDi22Vc3KS +tq81qqy/uPT71tSwBOhvyGTvUYmm2ro3GAm/FSMQ3WmibGuRfGRyfOIvyWPIxuFw +nNzMSVvZuWiqSuIy5vuzTLYtt70yyqNI7JNsiNHGWR5B9QQRNtXBBHCVAJGQfXFQ +acaNUahmKuCRNA2RZIQKXrCPHL7wkrsmNRV72Ym9mYCJaGGRpP8AVe9Jv+AJRWtZ +RRs15OSMiGDdqVs28j9dOcbSLzJ/58qvls2iCMdCPJGFPbY3V8ZUYEuW97lEy5il +oF50FlPR80QAEW12p1sWh9TpMxmeQLNcnDN7uy3+5ttlTayLE/UhMxwHHJgBbJd4 +uCLmUdfQm767rslhsMiefa16RFBEfekr+K9qT/SXm0R7/b+yf1fY79Z2lYkME6jD +TcwuMm03NR8KKNou5FuhLXGLTqknqLwpoopgesohoYkxGitMttxKZIN0cIRJ3dxw +ACbHHCNZTkRs3ZllfiNOTKSc4m2EZCX3KO6pJwMgglTWJnmuQ/5KYJ4qzW9m73VI +b8WHFt7XDFrxSf0ItNukldS4pheW7iTf/lTnsqBx5Bip5YpTTwe9OAKrTxIm7iX2 +Kckc2o+s2kBWH7Vq91+WrV1hxY8uOiLEFlhr68vWzMWQoQrzrlvULC26zt+yCkDL +fBAbMh8tRxAthaBd8x3QSUad2FvxoaOSvyp5L8UrzX/P+f8AEWuosIpeme7BlU2w +pBTkyQlxVK3Ql2RtgE933EEF5XpHcO8YSBQA9V8tUCQOxq08yii308uMuFGwO539 +bk+Tbjby3mTxOoy1HVKY8LvVvRCTdIxpiiDwYorlJG2b9KJu55dFEQRHS0ftrIBL +X80lJ8NtvFe3wGpMULhBft7iFwKMZ77AxAlyLBGgwVKeL6iKlxmCHoRy8xw2Gguj +Upohduhk6WKNSJj0wWnbDOKOTlTZoS3eFXJMmKYyh/cZy2xCu/c+YA0zbb4ASFYb +gTUkKnCyvM2i0rey+HTBFTNYxS5wtBiLICwCb/0e39CU0ePmupFoWNfFdjoYqlZN +7IVfcOyyDEBLa7ylFtzjbaWQ0BAtqOOKVKsslUWbIsWl3CMlq5aXuceMAxbFpC4S +2ylFP0JKCMkcbfomQcZg5Muwy4qYqZzBf/uOn6c10e5YWYh6sxxyBWUV8TXTcRHr +mspVXztSUnwT4f8AP+eK9qH+de2lydZ0nsjksTZtqQLmTTYPY7bXZBdjqtXVXDfc +it2q0sRpButXHqjpe0SDbiH1nivuOGxD6q6mFU4ovWGIhp86Xq9p6Oe1sf613gnO +S3PdcNYl7WnqNqa7zEG+XNtnHcel7JsX99p4MU9S8ho3mvIJAriWaF2FuEC8V+aT ++j296T4Iv5VBR4CZNWljSXIoq0LbhyaNAzSg3VtcrlISNMVYsDmG3KLYaXhvNcb7 +HT+K+i8MbRCtAPbOaViu/Tc/ajKkIMp015iQ5UHp7aYhFzSrFBjx0js6jsPKLRR+ +nKNsMkzIe8HhSDiO9WdtiXeGIzzi7rSf7pPgn8JW/wAP4+P5pnwqKmom1iailso0 +aG3xo+znJSTQkoMucN4hvO3RWkhOSDcVVhOKSowrRA19I9QTLjFd/sZ2qLgshBbs +l6ubshQO03jibNtwbmkjy5tkvJUgQdljLTT0G3sPBcmRdB0ORvmRpjKtFpz3Z+Qq +0ntXj4JSUnv5+H5pP91+fDSea16Uf9wyHmmnMFzBZKkC490SIphceRdsGHHB3ZkW +p1yMznSyURpQPUc9A3ZblMvMSMm9OTjcdbjHZLuj8dG3HbpIDZhzveUFbZWM2390 +R90E+m19N4UR2QYkghYNfae0ve0sF33B0EeZ9vglIq159q/Px/mvFJ71frj8ug8b +dnuzmoWpcyTx9uAthz8f3qpG3ifcGjnG44OZ4oyrrZKbYkipyR34jcyFyMnb4k3w +fyqPFJiU00rMR5gVcaBHjcrJvYzdaP66c1vc4BNTl3BVxxy5UXbqfqCQHUEbcx0l +6qlDBqHcPQ4KOt/zSUlD8PxS/wAIvwBPNa/cKcbsJrSVzam6svoMut7rskyKSLsg +vEh+ZKmeyk2p58iNm6J8DL8tyHG5QZlkrawmosFILDkt60zG7k8AFtIleh4I5jFB +lwGhVwijS5gukkeMoHBBDkNukThHQyAZVa6hXbueoNxM9E3pX5Byh6YapbeY+QyS +TZdqRaT2pPhv8E/lF/NXCZ2MZXEnqAyoTrukn1suq4jMhHUdT6Rgjg7DJbc9mhdR +xMCdjusO7gjoPmprchV+2GjayX0GozjsqC6+7aLuxbXCbebfR6TDGlubqQVyaWbL +L+3EYdjaEaVO8c7qQR8LRZSroBMK6GpHstRTHK6cDLCSsqBpebGjYpb9PXQrxa0e +eVK81+aXzXmvzX80PqLar5LGZNWMGtCcSPMnN9TmflOpXLyxZZ7UiOHFipKptuRF +caXGTCwHdBMcdpB25C+vH1Kk2Nb3eKJeZ8ZQF2ZLvoxFZp5xx+4dtI0ba7vMvMeS +61bG0LKdJuzbK/SU+eRu4RcY7rLf3byq8zgYjqrNwFHZr7qdPG5aWoSh6e7DnGdE +6b3NyFO+XSyTYvHikr/n/U9q/mrtdEhtrHawB50cdYyAd07fRHqJZWbvLv8ABLpt +eycipFksuqSelQCQGxPMeVCpdvVWecBbfaMaZkmu7VMMQGlzomIEhNpIN29yUsoX +Ce5ORp1Cc9T3EH2A48grhH7ksecp0zcdg1HPJQxqQ5vINV0axLaitfL4Epizm7cL +Xa8bfI4mbLcQuUJF/o/4lZg0JOGklZ7iyHIZEc+OFX+Uk7Sd5uIXpkj1bO2nwn9J +6mSSlouoyGBUW3QMMlQkRVU0AT3dj8YOlivZNmXjtjAvWDWexUBOIm9SEF5RydNF +8E5yPLszJUGGFbonOMMVukxU3brUEvcDqGz3M8Wl0r3tgtjcw7ewxpm4MMFY2ytE +Jq3SNKTkhTBF1VEvI71//8QAShAAAQMCBAMDCAUJBgQHAAAAAQACEQMhBBIxQSJR +YRMycQUQIEJSgZGhBhQjYrEkMDNDcoLB4fBEU6Ky0fEHNFSDFRYlY5LC0v/aAAgB +AQAJPwJc/NWkeScLle0DuvqRI+ELTNyXeIXJC4TTbkpjYgKp/NO32VvFGTCZCGbr +CEnqo0EWXxVbrKMrVC20p21wU2GjZRdMJcwfJSB6wOyqU20sXU+r4jtRaDpp1hab +R6NQNDbydlUfUpv8oODX1dTFiU6Gs0680wfc5rcXumCPwTe7yKOa6cgDO6N+XNTP +JN4id0/4rboheO8qWqpp0clumyQthvv5hY/JDvDZDWxKflq0XtfSeNWkGxTqZ+sY +dr5paaeiyQKRPyVjVe58cpJXEYsI3TTNQ8MofFNnq1XB/FOh3LmvmmjVPOQts1Ad +2x5JzTe45ozf2dFUETcEKesKTv3lVJEaQmD9oJ5XusnaOvITQvmEDYJk3ioU6fvD +cJ+YMqVWUJ1yB5j0W5mMwNRxZmibc10QAZRb6xRzX1OwWiPdMG6zaxYSobOs7Lca +lHxQyhw4UYI3TYGbZTfmUNW2lEeAK0HJU9NU+J2lNn70ppRv1VxOkocU2vdO4k25 +ByuBUHizty7cwq4d2ONrtyx3OKY+c+gFXyZ8OKYPPMYhGGNyhHLTBEt5jmmSQJiP +6uh8SgIQ+Cf8UAeaFosFb3Ju86rQ9VW0HKUyLWkJ5zc0bG0p2Y7nn4qn4WUxOqqW +Vp3V+RKarZgqRykgE/xTC0NaRUjRviq8mhjW1xT5B41/w+jOXt6Mxue0CPef8ghO +kgerZU4zC+ZaQjJm3VH3J0QbhaFfBba2WsoQ3cclqbSpUdAU7bQ80NrwjbmhGbmo +lDwWWQv3k068kNRA6L9IzNRrN9sHSUScTifJ1OphXXs1hyuHzHnKKfDWVKb3f/IQ +FfigShwtfad4XNDRD5LQdVUYDKpSD71MD2QnGOj+8h1cDyRPhKOvNqMc7ok2TpYR +aUJqZQqp43cKzPJPLRUSMpiGmy0j2l/hN1p6p5qdLnzSG1W8WVNJNPye4sqDnMEH +0aczSlxnuAbqr6sMK78SUPij4ynf47nx5IZ6ru7TWF11c59h4LE8BMZGjKAqoDi7 +xVTLJ0MFpT4pNIDgdR0VYHtHWLXWCcBO20J1ph0IatPeKpta1/W/iqhNfBEiqI7z +f6/BNc+kKhcYfAzdShRFYHLlqU+HrdPADteL/VVhpf7wTqhZNwDLmLE0szrGm+pl +JRkm19VrIhUzUMyJ5brynQoODOzbSquAL/D0HZabBLnLyXVFCpTLHVpHd3sgThWu +yYYFsHIIAkc03SzpQ3MRsq7adG2Z7tuaztIcc9fs4I/mmPc/9ZxcR8SsJWrZNmu3 +8SvJJB9kVQ5ywdQObd2emqZPLh1KYMlRuUs/uX8/BElrsR2jQNBa48N1UzMzkCVU +yyIyymVYDx2sXOXmjJkOa+mLFsapjWPfevUItTjW2/gsO65J4zYN6xuV5LYQT+jc +85vHlCwTKTt3vfwj/VYnChranG1lGD46rF03vbdgOHuP9V5PBtBItPhKx9auGNAw +7aovTb47+9CYR+zez5qhmaa3DZV+1fT4O1nvAaec/pSXvHMBYYYeqT9mC61T+aot +aK3ev81EAX6lawvs6TqU1XAx81UPe7z5gqi1jctzAKxjaTWC5qZQIWBrYtwMNOHp +2Pv0X0OsfXq1hPyX0PYJ3bVusJ2GII46b7H4J+dpPC8atVHQZtLZv9VwsFM39r+S +4y0dnJ5Ks37N+ukD+indodKFGkOJ38yqVHA0z+jbTZnevpg9h9aXt/CF9KcPiiBm +FOrRDre6F9Hwxrv7VhH5m+8G6LXMizoRYyo9tszJBTHQdbfxRnmg3NIyyVw1/KdX +MKm4o6k+/RCPsQfMEOE4Zwn3rnKae3wdcGpHLR3yV8z+FfJUTBFroOH8FTNR5tRp +g3c5Y3ta7hwYUXy9AP4rCtwNOtVy0jUHEQN15cpg4eia04itAfHqt6nkhSxbsGGu +dRq2dlItlPPxVKKjDx0nNhzOkJ5JBTvVVBryRxhzVLZjXYqrw0hxOLlV7PDi1Kdx +0CDqNL9TRpHi177j/BYbGVm1O/8AUqees91+7zVKrAwD6lfLWcxzYMe69oWKb5S8 +nVTAxjaf21MfeG8LGfWMDimZmZKk5hzCJiOHojnjuu5lahNh7w0Ax97VUHNo0cE2 +izxiUP7Kz8POP0VctPgQtKVMyqWUYqk5rq52eRZU8ve7SDun3BsjchOVAveBwgMk +lUWVH1BJFdmZrOniEKlDF0Xh+HxI4g1459Cvobhce406rH08dhzUouLh3/dqFha2 +Lx+Kb+UVHMysB2YCdgsD2bw/Ofqzxn/Zk7LDCnUBJ72revVG6fxi4TetyqLnsDpN +L2j1XY9u2ftKbzpyy6BYihWovGXJWbA8F5SbRbSxAqYWq1xzUjtB5L6L0MJW8onN +jsRUrmqS/c9BN4VV9XtP1xfI/ZjYeCdkonv0KpuPAoMketzRBOwlR7k48VVrRHiq +vaVg6mM/N2i/V0mt+A87ZcKedniELkNynongkclNqrg0TYrmgenmo6xsoPQpxAbw +saywA5ryo6M/AeQ2Ce6o55mCVwzpCec7hxAruht0PVvdO2vxaKbiChLTrHNU7k3D +U0N0AnVVA7NLnZtydVQbHNyG+qNtkL84Q1duER2dMuf70JbTq9q8ka5fQbY2Pgmw +18hnUahFNd2eJodqQRzOqEWuvFG+8lEz1QRNtN1lHPmqZnmVcyqYsb+KjxKNjouM +O1ATOFxlqnNF4F02D1KYAZsn+OVGZNnRCedd1HuV9jHmYLFtNt9TKb3cOIPifQKG +vBUPUfyVIvDjaFLX0Yp1m+C3R0VS3XdNmdStZ2VoQ6SicuXVNAhtkBbUrXcqrqRH +Mo73DbozBsnXHJEZkyDqqZP7Kdm5NKBN5ATeLeUCGwZCce8Vhw/C0QD4uO6o9mK2 +IyUWeyxlvRjtIz0Z9oKezZSPA4d0px/5pgdGwNkQb2lC4+a1mJToE2R9wTZedJCq +W3bKZlI/BNi3EFfKbps/dJ3Tm5ok5VY+1FlYztumBpYmQ4m+TRTDOStbQqnoO8rc +gvAKBpvquULKGZ4cfBNjgn4oI+cqj9ljWSPHdOtmz35qOSINtShottIKBFtwheZH +gmTewlRHJW5iFZs3PPkvmqeUkcVkALBsjdd4epGqkT81od41XDJ1Th7163IoGR1V +99FY6+Z/BnzVD0QsBA84878rgZpVPZKwdWoz1KtFhcD8Fh6lKo6mMzHjKWofzQHv +RMAXMoi61dqrS5Ol2hgfNPdL3BpJuE0FrG2BUNjcjfkgRJuZTX6kF7hbxQm3rc03 +KKbb+CMpsW15poEninktQbLxherYwERdqLuzyEviyp5R+P5kWxFHLI6II8TdQtSE +B98803XVOOUHisvirGeE6rybnxDW2Znyg+9eRvqbHOs4Vu0YfHki5skFplFuRo3O +i8lF+Fpt+0xVSqGN93NYPs6R/S1n+v0CAMaQEy4Epodf4ICVYnQIa9EJ6r2Qwfmu +9hK7X/umxREBau7xU62DUN7jmtVUtmWg5It6krhPRYh/gTMhY11WgRm7F1+z8FjH +cLuAZuEdE+q7snjM177RKaMuaHRsnbaInpBTvcveFPMFan5J+p1KF6ri/wBMefSt +ScxWcXln7wQ6BG+7kL/im3IXqjM8qkZ9UTuqgkiGWWIjIIa32lTbUY9uRkDRov8A +7+5M4pNtAGpmV7iYLTY+KxBkuyO4vmnZTnyukrFDM5ov/XwTAN3scYjoiCPVgapp +vYp4tqrE2C1dDQu6wQPMfSHmMQrNdVbiKf8AFetvKb4+Y7bolpGsIPqVDAbTpi5H +NHs35ZyZpI6Fa5dPZCzBjmw1/KSqb3u7TiI2CwrnZah4AfVWFz+t1lUcrg57cu8c +1QfmYPs5t/ui4PZ3yW6KpJo07370p2nqhbC4R0TZFETP3tkUPMPMFr6NIThXSW82 +boix1OidJpuAfA0VXTvKnmm2qh5fZrSLArH53vGSqdmc4WAxeJqMqw6o2jwL6L4t +7naOqwF9Bm9nPq4oTC+jeKw2Y3q9jmA+C8iY/EuJIzUsIQCffC+hdUOIt9ZrNYI+ +a+hGGJHLGfyX0Vp4eg4QKlJ05VRGYtguDr+BTYP1WPEaj+K2WgGjVMEocdTjf+YH +oXDmkFerULb9Cmj7RoDiN0DcLTkqWZ1yLaJsB9Mb/gqIG8pgsNeapU8rSm5cug6q +iBexLlXa/wDZVJvetmWGzg8jsmOa6k21SmNkCyuyo6+ucH+COaEfcvWJcW/s/mgg +hZc0z9eVzU8MxBshxfeTXVKZaJGm6ENAsS7upp4jqBqhBn+gqxDHd7I9Ylwd2ovm +myxNRw7eBJtCc9wBhnabpkFvqKkTzhGBT73EjULnzBJnVGRdDiyxAUfZUYHST+ef +LSBMbFX5lP7o3W2hITTreCjwg7/gmxT2ajcn1OSaC7LEAFNMHhNSoFQy3sZQZnyk +ZzaQsrXAcTp2TqlmhVZc+M86QmGw7inhbJCcNdVVNOrj29pTqZeG1olODmOuHDfz +j8y6KlazJ2G5QHY1K5+qU9+w0Dj+1r71psSjDc0e9Vm5mO1TM0G6baZ1TXG0XNk8 +mY33TpdJbmb6x5eCHaTBDNIVO7Bpm+agg1BxH1Z2TsoG0IuB7P1dukKYiGk2TyR6 +pzLvkWJVQh6qiqylgmTg6thUuTwO2esW+t5PfU7MPrCH4d/sPCMtcLEeh8fMPQCk +GoxmEpEHQ1XQ4+5oKBFCnVbSwrDoGU+D8QU4EIWO4TYOifD2781cESB0UE5rSVS7 +xghux5qYda3VOHsgTfKnAHic6Dy0Cyg9rAbOnJd9zb+y0+KPDZrJOh69FlqO6GwT +v3eq9bV3IJ1zuuNuZjQGmNG8+aH1mrh8NOKot/t+F3t/es1/3WK7RoAODr5v0jCJ +afggh6B9C7j3Qn9x2Ixb/ClQj8XqQ7F+QKVaqXW43OLj/mKH7PVc7gKzmndN8Qql +iPkmAWToymQXFVYLhdoGphPPZ5ezDty7mqo0gSFWJd2wzk6xNp9yqZuK3JFrB69a +N+QTZOpvr/NAzPAybLY2Tp6hEma51TYx9EnEeTT/ANQWfpaH7zf6sqv5J2Axvkt4 +N/qlR3Gz/tP+AICI7amclaOfolOR8x4advejH1f6IeWSHci6pTaP8qn/ANMfgsLV +tbKaEn/ME4CG2jZWdvyKsZm6cZ5hcv6lWt3ZVOQeJxY2/hCwjnYktysBYc3wWGqf +YuaXmlTOU9Oqon6xVw+as3Kc1MdVhnNb2HamnWHFyuFVNX2WGwHuQDjtBsE8lw25 +Im3dCHQoBrQIYE7NNUkouOKvi/JMf9RR71P99n8V/wAqwDyv5M64SvwYuh4Ncc8c +8vJOu4OpVL6uYYDvezKfQPnCP2hHwVSXVLgxvmYE7iZ9CKr3f9zEv/8Ayqc9t9Ic +JSb1/ImFEipS4SDrZH4qwGiqEGdYQ2uEfcqQ+GqwTS54gujZUHHmIXkxpqZcpqGn +chYemxzW5Q86gKuXH7tgtYs46IEuLvZuqk5tPBO4RsnTyXtG4Tfy6hSGOwVL+8rU +LVG/v03Qjnw/k8f+OeSv/c8nV7YuhEDu3dHPKqpcMBU7HtHD9I3IH0z1mk7XmxOl +zLH/AF9A+Z1gCTdAjtXAgK/5TkHuqE//AEX6/wD4a4OoJ5OxFYruf+eMEHHnOBaF +PY42rWLX/fbUcCE/VX5wpgb8lVBB9VMyxs7dVi3kCbKY9oXCggeybrTfMpcRfTRO +9w3Wg1jQIG/eg6o5eSfv6wR00W8ypd9Rq0scHA8TMkMxDfA03T8U2aPkHy4KOsB/ +kryjZvQhtQgfuLDE/UsHXwVVzjecDVhnvdQqT7lUDWtPZ1DOvIpwI6eb/8QAJhAB +AAICAgICAgMBAQEAAAAAAQARITFBUWFxgZGhscHR8OHxEP/aAAgBAQABPyG6H7mF +UGIUcPUsNZzlLOcXBtOhq6tYJdC+CXR/BNitNmiJNGPvUbQcqquPM8gbDe3mW2DG +3lzFFTbkm31DKLyqtC4F6siwfUzW/JYK44i4GUaejDMBzCAVl7hG9bBL3Q4Y2Ewv +PWK3HIvA2EoO3MKzDfE2OZDVQq5xDgAGE7h6kPdNvMsUV8l/sQZrdhQrQ5H0d+Kz +DH4IjeW/bEhjqv5nf14gaA7aqQEOieuOFMeIyAbRKteR2y7saAZ8llWy89/4RAW4 +FhnwjtppgWUIDAN14g0ONLiYi9+GSUIRYwLjI0yplS/MLxPmOaC2051upRqoa4B7 +izOhrcNkmFPBK/itG315gBdVBghDas5l7ehdZ/3qcGHA/bqIyuLB5iCL8qbQOCtt ++ZhH+y51KI0OwV6MJzFxts27GoS3/wCBXPHBLafLMSK6zhTg7YdsIeYk5wUw5KHj +9xTj5gn9ERrXHPXua4NuCn+YBLCTzwgi9gA7Rd4e+HmPuPbOJXOxAqvMNsm0r8It +56vsRxKgWpulHzG7LF/sxLNoNsIbI2l2sjgRdYwS686eyFcZbuoiwo2f3ggjR3x4 +eqCt3LvPiAVTPESxl2cXQ9n8wUt3DWMeJZLQaAR6NHggyPxKPLL7aIOx4y7lx2ga +6vDwO4jJxbL3ma/juG+T4/cSsCupjki6YHWoFd2AFZ3RC924KrMsuNLHi7/7GThs +Pr1CoIubD/rieCGTKeuK7eptWk3sVzKCqByV9RQpidnqablXDSS2W1zBxDyyHkji +cgVj/VMSg8NvUtqYbxLBFnWleoBrEQjfqarVplxLd1ol0Cw22MifmVtAtnLKE/cB +anca15Obpbz4iX6lUTNVjeYK3HY7lLBS+w/fdQMKvvduA+C2Wc820BeX/IWRMKiD +3/lRFZk/ohytezGbhhsQ9M9ypCfIyQXupqmVhVQGhMCwaocoAtGxi3pyHMmcpypw +a9SwwOSzKdRV9b0+AlhHG98+5hh1AZcWKwt4dJlRAsnFQBbMczH1PLjiV526jEAQ +E2XDO9aPXVkQGgPxevvGdJ+N7WHHh8y6eVtlXTw2h0zK4fuUYB9EppVTOYi9eyHA +/Er7kAVMG/5YAk1WY0wPyTboKbfMun/B8x7tFWnMyltwDcHoQPIswpp5K8SgCK7q +bgts4zhLfO1ztmuvREG5hHL+fmDwrsrVcwJvJ8GufcpyOHVC9u5+ncrm2y84QBsa +cAbfhsYHyV7xnZWZqvMyaRxVO7itta3aoIZuOtOPmVEVvcCl20VBznxyNfHPnpgt +NvqKPRslF7YzE67ym6b5GolNTbFgWX+Lh3xlla4ZK9sLGq5dun8R5mK25M0UvDik +eTJqqzxlgHAdmHJRF0qHoiHh3B8Oh9wsCfIf2hZyGEH3TzM3LJXcxsEK6cbiFkOG +rMTaxAVw7mrJRRRnn1HhjXZr/ZgWC8cQdS8uTUuuoyqrtqyv3KEG6yDQ/mGlqXPf +pFNgaxL7JV3KuJQY4ppvxASPypt5gJVngYHqccvuabv5lTbd8TcOrwVb7kEsjVF9 +F/JAHbfGcy3XNOdph9qwtK7mebNYVHkYHiC+hxbnlN/caHL0l6FSmuiO1O1t8zkl +hdA1lm29n/iMUWdbpXa9cVNI/wBICXj6/MQXPBp4RzeHHavVxHGItQVidSR5B4D7 +jhs8oabt8/mG8A1wC+zaY4jxyECC+V15iLs0letIiVMhVdtd/HMxm8nI8jmUFxyh +8n8yuGhhaeOpUCuVDiXnB16V4PiCwanSX8rg5lVLOOpliTuCXUtGNsK+8cSkG9j6 +TwbRQuudzzr4lI2yLk7mQ0VSjW0AbrI3i+V74lalivetOPcvA2rAW4sCEmvqiSUZ +9BrL1ohJhpusPFyzetxaHBHb8a/TbFASjy+X2l8Fe4F4A7WJ0IcaBTD+JkXpYQRW +POeoqv2OFYHpNbmx1c3buxSz5TI8sto0KWlNGuVivSStJXZTBuruJ1yoMPVG227x +KOABF/BujZHI/wBUR1d2vllu16mpMg2gakyUeML7ZPuEv/YRSptqnrfusRC9oDme +b/mGZGnJoK+Wv1KT/wAlLwTCEB3wz7iRDZo/f6QRQvVd7eniY7qCHa2s3RbNa3OD +U9C6q0PZqqBF499w9rqhH1ZcRIrVT2n8rhx2oTttyXz4DC1CaPLNCFS1Ill9jbO9 +kqaZzDDS34h622HAuuPJ8TVGV8Wdfl+Z5v3r4ea4h5joPPlVzZA68WZPi8qbcYio +YoIM6twE1c7FZht4GR5WknxzFvUBmmdYP53FG/BFx3XD/wAqvzGI4mONH4+I6Fst +5YSFzQo6mPSYcUQXWnylYc1DzmN/xMe4YldI6E0h6UqhHInMBuS92+jzlHvwDPDR +F8yn2i5WGrWm9xDl2L+h/wBn+tlqXzxLF9aDl0faD2vjtLa9HHniKAw7XGg3djnN +jyiSHB+kVMnMNja2shZSot48zPDCz1eX8wb8lYUMYOfUxSG45A3c2QzsHgqPmRuW +/uG/zDXGrylcNY+OuV4oKlclhVa7f9mWXi5O6jaKdCRPl6hb4sVIWbp5olFVKgKY +CC0dioIFA6KeCZDpraQ2Te6IK+DHkHaYFf8AdfibYHOO9YM1cLZrnELKrv8A23Gd +hUDxmiBbjdKC3i4+NZaBqnnMcxUtvLF8qxrn+pnUc4cvU3JV2OiJfjkg1tfk4hYv +Pp+EGwwjKtJmwQHFKycQJYmng7l/I+o93YpH8rc0Ajh6MMYVdYic6OHuOhUwvP8A +UustE3OeptM+qC15EpjRspm440xW4iAaYhyzTcRYlkN9jJC93mK5reCrU1anouZR ++OX8mVq88XGN4qurO/F5rzEli72PPHzBGqYTT1FEVcIxcXINudlW/FX8TGcTmcQ/ +cq6v1IS0NKfiLgTqs7ZdXWQ4yluW8M3AwrzAav8AMxRxwNTNlRo2x1pV1nO4ehTw +jH9rS9+5aw/RP7AvcWJijHeDJ45nU0wh7qUlqkqvEXIB0cc/EOq1L9QURujU6mNO +s2dH5lxyt4HzBnea89B5uVXKlV2cviHsUqXRset5md14JdpiCvUphUTaTfmVMsSX +DUqdG+YjHVWyGdOmnHAX7i6+mAWfmpzeZYndZvE0yFD2wzMwP9X0xX7XFQfxLTGi +n1klT3CcRatMUrXRAKNvAXiEzH5lGXtPmipWCRerxAMZeD/hH6l8cXuZCcCsX6mg +WHl6QWpwP2QAMBbO3q+OoAwovROiGBbYOeSGA1D9BmAZp5aeqmHRTO9THAavR8ep +pljOEtGHth+LmNO1wCttTRq2ay9B99QiU9+dqD4i4HIhz/wmStnmI4ZzYl7lYMrg +s9BNzkP2mfGlF3eoH1tb4aWfnUslX32EUa6qisEsCKZQVYdS8V8rOepVSyhwvHUS +11OddSuuw2Oh/uI+ZKOSJk1Dc0yk6Kc53Moml+CZrNqu3qoSLjDKAbPFswsm3K+G +J8ORV9SykOCsHasa6JKLeL3TDqBKsfULTW+l1G7bzAPEz7E0cTYxjdtzDPuM9uvU +J9GAN2Li/Qp/AfbcW25es35jtxXRA9jmaPtn2j71L01pkAxoYqnscPmVi1H8kfrA +eU2aOwhSMAuOX5/cqyJQvBME7NMCy14DT44qY3Lkq23bzLRvVNoVuNQpUu/ExMwt +SHgeJsq6GvfMr6oCmUviZq3QYzzE8U2DqoihEO5rNzLwuBRBA9qx9wx65R3BzWeT ++Iphuv7L7lTdtnh04mHJVA3CAAtblIM5tgc5TLk/KdGm5RQrU7BLwU6YR7ID4iMb +oB7MSiYEDDUdmPAJW6B0azCNCDLITygjB5uDxYRXghlBYxK/xA7KKyabmGxrBW/E +yhN0cO6BAlCjSbfEbknduYluM1otslYXQfAlQFzWoZKUW2HMBZLfV9kRMqyca/3M +BJRVVkmppFcMwPzG8qf5g4myl6iYexFtxDFlKjFXyfM0HEHQSmR9s6c+pe1TG6hl +XETdHMUa0XP9c1Wj1YuEawK3hcmyBDTTdXHo8AbxB94Bxh3guxzOcSNW5VQCQAc+ +/wBTCkFwY7UIVUYyNYjJInkAf3Dr6OYNopTERd648ShtWQCj/wAQBTU8nlDGKWus +v4hBrBqr/MMxWvg1huobYK5GkNZGhA3pC1tSwSlQGVg2OODFeJa6LbYAho+G7c/K +YeIUx5h4Zg2fHUU5aOiZ3Tf6lG/8SwL63MEkEuZYOxvl36hPTiFBMThGfgvHM4yp +wBeEx7mmhqfhwIOpk6jyj0HnWFcnzCwGGeexcRtOJ3wMRfxXmXTwO2DrwxnQZaAD +yy66j4E3Ptif8ixB67YQSIEUyvApteB8QFbNh1SVSCXY4qayZXUEWwJn4dxO2OkI +Aw/5cv8AEtrNQ+v4nXOO5Sy8eIXa+ZrHJ1PK1ua0zGulvO4fHgH+mmWTZHL3uJRA +Jg2GpfcqJwJZYuocJcic6o0wXwRQF/cTVDyxMOCN9A4lJW61Os98RFM2O7JbuXJA +D0/bXjUAes1sWx/caOM5itEjxfiDQdH5lK1q9n1KrY9yv4zNUtIjXuAQ1eDiJqDi +3HBrVq53CKk3mYY119aPwTmryx7XqU+tJxBTnZyRUbdeSUwHn4mcm3uGNdbIL2eY +XFvPaYgDmuOWyz8QwFSjwTE5FWNB5JVBZFrowqJYq22Aq45hj/cRa/pbAPf1PIZu +V3AbCPTXeYk7GIttB83lzXSYbIBXTH9fEvoIalX/ABhcbrKN1i3Z1zDY0rp1n1cL +sc2aPGfPB8RvQXYdHPScoQ4l4Y6nNBjWdSrERnTo7hbgmHm3ECHQ/EBUA9XmG/aF +4hZ/DGwYxzOKIZMX5zqNeQMGmpbHyDzG7CT7wfGf3AgXhQMCFnd6PzDVl8CYPMpR +Ft6y/p+HFnN4oiBKzlMfCrfWY+oMVVnZziZkCQI2nMulay4Wg+CDnObzdp7xKaDD +kVz8K3GkC6g4U3fUZ4qU9MMHVp1FZz068RzQuUPa+SA6iMODdp578Qhac7Ll1M7q +eGaNZQOGXawfkwP2zcK97lt9p3SFlV+U3v8AE1w7qPLe2mpvm+5pQv1M0wiSj4O4 +ZG43Jz/cBSGnYOooAcbLJz1BQovQOfEbzDE4fbC03ZP+GWryBoAyfFTNfRTAqhjc +6MDs9upelB4JPVbmJNEfgrufNRuUjuNKauyYxg/hwo+prkMMuXX+u2KcedymF7CB +j2fxGsLgrFlPhLEvuDlis8QoYbLgl4LAfMwEt8ro+CPC/iGcO9zwJxlqWBcXIiYP +c7W+JRfKWxzM9+5kqrHBBZp0dJC4KAHwkAIVPzXX1EU3bzEwZnel1EkC0RYNpeD5 +j1z9xvdufczTF4d9FRgoZ649JYu5G33LcCwpEw/Uuj3A6WOBiU/xJciHPn8EGYiq +ywVeKTU6pzw/cfIIpxpz0ddQoo8j2zO73v5zNeDhhpdRbnuKtHc7VDyfEXK+Yy7D +PcKbN7ZalmXzG69sxsxbxcbMRk+hF4gxKMpz8DmVRusPMTeaMSjsSY4yaVlxHhF6 +Eyz8xCZdzn89RA0Wsb5QK7gtPcZWhxDx+o+rhZjO/wCKuOQe1hBVfLPYQOTfxCfD +07xcbDIbKnwEVMqqq6rx8zWmVQBm/GCbIVXtXxF83IGRLY9tGm2/5TFxw9zwfmdv +xBF2ubiL4+Z5VmLI1Jdbqpdbqq4hbYfcF8puzjZfmUMs3wDMEG0+CE5XwrliLsaR +Klyg3ybuC3LV/klgYwV+eInRRhbXN8TFeIUN7x/szLdtuecfqPt27F1/moYggBYn +vuC5ev2EFloK0J7YBdBsF9BU6PEpwYCUpwvOC9XK0LkNS9gtLfb7NQG8BWyMq1MQ +a3WuptXKWMwVAmkxxVZg0UfBMdNwLfFBLcPklaJa3Sv4wZhmptqWHNh9RHLLQqZi +aIr/AHJ4jBb/AMRtRgqvz+oFaeFl4uPqMB9uV67HGhuMMom8LW3EVDEkWhSipeG0 +10H++9z5FVFu3tmkN1tS9fMoOuESl5G3fES0TwrlAOj+xX6gyYIUOvN9wc4dJKh8 +Fi9+NxyYvx149On9oM7jQqa/p/8AFHNbZTznpKvjEfBk1MPKYu2XnweYqa8IpOTx +Ux8oQZybGXuB3KtdPHvn1KCaaEvU3DMsYqMbWUKrye44Lgy10YKrCdSg/wCwEO8g +ZHS+JzMDTNLKnDuW6NAqZKF6WE/L1XA+9MK9wD6UvJfKYiYOtSw8dmasgKWWF+y4 +iVvyHS8QLamOttFdTk9W7ByVH7PFR0TMYb4KDJwCtMxSnh206+k1fGNahVtsZ4+f +yGY5lzmZKRXMX9CdDXlj/wC5iKrLwMFDHO7gNcomBedsa8/okbnbRdot8HAWCfs3 +Odqkdo2F5adTQh+Q8zP5F4zcvyuvJMkulWS17ij4wxd8L4lXd/biDMMeW2DfJtjP +wyN0HLo8z2tHDLa/mJQlRab+ahA1rnDlmk8ViVoXgbLT5feoSKdtkvy8qPaubBE1 +iuB49QmitLeSCKTIeWWB05ADWTpf3FmNq8MmB5cajLdUDrXn53OyodGFablMqzOR +9WBpo9T4qlqL+NzEBa0pmTF9Rcr/AM5fQFvpiJ+6UbhZIsCE8vthCs0Ih4ADeVjg +Tig1uEg74UdPuHWcImxonav/AGJ4EhXKLRxTvWZpG/X5BmDlnOGTuGo58eSZ0ikK +aftM9nEpCCnyV/jG+E1onXiAj+u30agnaBp2r3CSrJcOogwaMfM0zhTJbnEX+HiM +nOcuOrzFKCV8xRWTX2dEeVbEtsn5vnhU+xBTcsbSXdtmJd7bgq35qFOGM3ANrSXo +Visv+xMQqKuA382jDKveWN+LmSPW4OGfMu4WmekEH0nHiJXStxssRfY+SNXPfaCM +heRg9wFot6XKIGvNriGoBA0dHmVFUb0luow0BjL5maD5wfZYfqPs4N3wHlmBZbi7 +/wCpz3ao4vzGmFmLcYewCYsAhjV74FPKyuG51T45CSs8uphtkqsQa8SI5Op9lTU4 +hT44nOpvv1Psizd44YCAeumYgVuLV6K9V9xFDRcFUn4hHbuwptePmZWURcBj7SKi +nhp+CVEBs+LFIGBKzLgwukCEKyu5aU+w5gQz7UJlBTrhe2ClptUKZ6DwbSJJd0wj +HRLxo92JKjh/E+4S8RVkU+Y4blKXCl/4+44qeDmYXUnZ6FjJgvWs+WxTtXUMvuMA +or6CjGtKIbM4s6d5ia9JZuo/Wn4hHWSoW39T/8QAJRABAQACAgICAgIDAQAAAAAA +AREAITFBUWFxgZGhscHR4fDx/9oACAEBAAE/EFpQThdFmv8AOGtVs8HO8Ojo5c19 +YFAryc5VexgFnePeYOXPVsDX84hRYgpNkPk27dY8slUpSArru4mzGrWkdG/rWs7c +AHY2eQWzeEmhRGp3PJ9frCugguJ8z9XRiZhJPyH4794CMg+08lZveMHIGsR0/nea +DbzLr60+ufecXCXQIc34JkE1GME3aO4YIh0BJdDlnAZKDVVQe74k5ecpBMSkF+dn +TianUgwG/wCcSaidU2l35nWGoAYS3HR6eOnHdgh0QcKPt/eatjBS6t0cFeDFgNYJ +DQvN9ZdSVJqadP1h/MRVNfJTYfGsVqLLb7iu7yYm8Kq0KR+HrNCGBxOPIu94LI9b +35awa6xE2d4sZC15SvwFmEwpoJxiQWT1NDjC+Co44Qlho8XDNpNVDe1pOK6MgCCN +w2QjkJPbisKEiDdjnfzcXGAq3918ad66mCBmgi6x2Fo/OIoXkI2uw1sLDvEMgqqN +Lrzx64wKUWUaBXdCcRzhndCBBeZoH1hKAA2athvflwk0jw0po3C7mRqYWoel8e8F +9aA13UA1tk5xwgECItVjTxL5xGDVkBqIhw8OBp9D88h+OM0UgrYGIfk6mLFDFseX +k48dtY9oWnV/ltr43kIyvaknnrwY+W29E1r1+8IIMbj1/brCYsBsDaHykjzrvIy2 +cRyaVA6eKZpiSwnC6kedM3iSBl3daxE3o0311loVaDyd5NYVTQQ8HvJiriEVCron +vK3rzdiZKPbvBw3Sgp7gCVLVvjJJShDZVBNdi8qYyJCYKIKUcy5CxF4HPAf+PPOa +FFawh5GpDdMRofSkaKPZve8DYbJsWdqvDe+wyonWDeOS73vnnA4Fgep5pz67zXAm +9WN+XXOB4Y16oVuk/nHeAdOdoF5nJ95z7FqQ3z2uPeFSAViQuovNfwYY0PDKokuv ++cILLbAotlXjam5m4IQGbDpRu545wgvYjY7l1XzcI1KgW3RYjryY5xTxDsVgcYKF +6jRV9JMcKRVqqJ4+P1kNqMWI+nmH7wePbP8AJo2G9DhyQnQjZi8jWk+8QtTdTpeg +0dD3hpLvUExtKng68uaobbHi9e8lIIvsJ49Yh6Hc9R+QPGJ4lAT3bacBWeph0+QA +KkGcAva0PGSjEGrD11f4cI+WkkJA+69uNRuxpBdJxW/WAi6KbXRKBULNc49pBp1A +4cr57OFbBAbLzXPDA8BI6aqXowzSgUwp3Pd85BADZtNAeDs984e6FTQ5LqK/eaDG +3SFZHH/mC1U1IRpw3r7xk0CKgSo63zXELqQSo8aTfHGCxATXeDyPrNHCGDfRg0ig +UIhd+xx7mHG1lRXl405rggY7je2iGA+G4z2vBv7wZGsGm7orpA/W8MJyGt5UddJN +eslRObw07bBPBN9OLg01r0nYag0jS4BRBUqPgQAeZjXJHbnr+3DWTqmLRR09r/jI +fB1yH3gbNymPQcXv6uO8d3akHPYiei5YIwwADp27Dkm7XEb61h91qLSHAAxEVqns +OA8vAespClavNXeBGTA7v7C2u+PGPr5Rs9j5VO9YEgAsUHKzgPOGdpQB3e/p5wvO +jEUW3brj495Uy5AXW0hzN4Ta4pKB5DzNfnDssBtUxB6fvHngewEAgf0OFoEGcX6h +59awpwzE0ekrtWRJgXzZFmlUKzn4yUfkJciF+u5gM22oD3TjV/vNWG1ynXJ5X5y9 +IlFRy2D+sPQ9qBPrQusXSm5uo2+3qYcNajnYu7XHFmUXizVQFdw0TiO6Zxk6FAvB +EHjiOHFa68c1XhUhoau0w7FUXbx6w5OpxgGAO9lP8ZBNmFWeMbWEFmlqnBi965ye +9sFJJ1GXxgTmwgBX30e55xRfYGtB5fe8sQDSDWt6Pj+sEK43wbYnEg7zgPAmJvPi +8G8gAi17Ff6MAcIdTQbb7+vMyVZUjnQW8yb+cpNEQWDd3/BiNIzSpGGzS2eJjzaA +W0SAOteU1hUDClmowPY9ayXCqa61PCnlwI0DEI8j838TFAgpkD1N5mQkYpKgqH0g +b3MCOJYPoj7PjFgj0jfJA/8Ad4Ab2iWDb+cZAmt3fIm+8fTUGwDrbGYUHIiATfHl +E5uC7EG4Hx8hznAm6e3sdHd9uLvoztsTYNiNn5wfuFh2dioPBDdwkAeB8jiCbAW2 +ZGHzQN5MKE4PDm+p/GG9vkEwGppXOEyxEjQ/4DASHNOjviWLe8IUGzVi1ff1j8yJ +bkGQeb+cQnHUIwCWAef1hDVRzypvfX+MBLU6cHJPzjjvrV4OWsr1MlckTnrpaqfO +WwJY0QxC8jyM1wKSvwIs/RLlI0gCWxarw9fGHTRDsDqEtvn0YwUBe89u+P3jgM+c +BF8GucI3VOGakdUrXm3EIQJWBFIywmy4Px5NwgIG1dPe83quMgoHWtVVOHAouAAv +Aaa+XvA7laplGxSryJhoAlSvbboTc5xki+cNDY5GvD9YZkbDVGIHVaOFADCEqC9f +x5wWEsPMA0U8m+s5aZfuLJF6NgqaiGlGnk9YVDAHQM9IyINvgmACugDSe06zTfMn +8sYVD195dk7qagHsoX3jd4SRboC8LvrvE1oC/ZSToPHOsDhCEJbnaXtyqkkiboIK +kpydd4vduNBoLHiwoDeMMSjBABA8cRl5ygN3Z4ek6Fx4x4XqbfaERDcnm84GKw2A +6IGzv631ikoI3xh0i3sJ2iYkJygiqZN/CUY0n6TEAfK8bptxQFAskcs07HXnEy8o +qd1lsj61MBAGCoACmbITq+84yNcXOt0iHAec5Vw3B1ugNAD5MElMRYaAVE17ONTF +fIsOY6itE1KJMekQeymiAaTQp9Mth+ZI/jNjp9JlDvgyAa0OXgUXeT9ZDlPN5fPZ +suaUUUNmccnecWKwUIdjpriOJhFnSJFPZtr4m9lCzjfONCWNRXjFCCxRCNnE/vAi +rR4G35XAqQiavclKL1xmgRFIliUdj/OqSb0VCY69p35wcKA0ilt7wCt46SU6IACf +jE6qQEiIqgERot3Mtvz17EhI6V8C5KirIGsdwPPqYBWNI8FZxsjC5rzFJFwWovg6 +fDnsPLfNxCA7k61cvtLkEsKzQOXRqmJjDzwqZpEp5U4JiCWsgzHeQEd35w9A1SnV +SN3C8bmBCRaX7pXzO0HxhdRYF8Eq8hHRc03ZDMNPpm0jW3dvqFfIDnbmmEALmA1Z +qkkeBJIsMMdGlK6BSOQZxO8s9uAjSVP0Dvkcoib7VteoEpyceSsoqQiDNBS9NxQx +NFEQydEqQUOmMbjFeOUPPHGV3EGFUQXZ4Hzmjv8AtQFL4ArDqZQQvjdQrwBe1ODK +MQ59M0UUAPT8mBZ03n9RUX4zlTTY7A6E2v6uFy7DCW69EINlyA2KtqV9joDFoStG +7X9a14xQpJCVCgZBoG1TiZtJ4MPgkHyZvU0ZERB6rYNhfPeLArLgbYmsTU6pR5do +XscqkhkhqCb3oesY5MFZopBSV4/eO4YMra8Rvyt67MqQOBkVEFFD82c4TsOUWIdi +52T2cv8AIkieCjoDA+dO8rsCmF8TwlyNv1jK+XLrLVlhvSJ2YfdE0K6BoAaCA4Fy +e1A9KIbfQN7brYNG5yhN8mhOlMZav9phQwo0qDnWKxXTVCaQhEAo2TKkPg08khRN +Dkw7AA3cGi/TJsIChTRDHdifpzSOgnEPIH/XGpRjgQb4VTXvzlnSRju0aK+LcGJA +ycfw05AZtVG9PvCwo7hzcRAGHYZMRZVugUHhNOJWkwBFKukPlka4JskVYQhfzhFb +dFVdtG8sxyU7kCxJ6+OcmoGXiLuOEDjt6znuNNOgJ1dq4VZM1Y246hOgDG6s3sMK +0AqtO5hB0iARw6yMbTE0ndK9hleAh54QiRGg9pksVYG88eTvzxpMOHIKFOvb04ZO +hrb0HzwmHnOUbDZIHSnnELwgrO1XMgFuE0qXp6gAkuCdU6gdEUmk6Aex8JLgCQI2 +1gNhmHySFnIhFwUmz0M3VJwNSdkPUCMwQmLOabCoJbEEpZYDtyczh3xZzcdfStop +RhE31+cVG+QMegBo1TUxjpDSA8w5yoilojZ946+HIilJjmPFD8M3+oMleHIU+CGA +KgSvTx8Y0fuOigPiDCIgi7p+/nIY0WLKLtaeDWDFbLshVOBfyY2BBSJRnz194qZM +hjTq7iTrAgBLuOyz+5jluDrPImwdWGu0xyfjBggIgONE97cGqfeeWFRCTd6Mbzs/ +uGOT2UyA6b6xx5AokVu1UAEFHxWTMiRSkPKHHGTNrVVHnJKD5NnOjuGAbCp51f8A +GGlmHN3L5mn5xlaURT2qWbmujPLpJ0LFp8p3lzaQCanIC2FO72qu1/h0VYVG8Bnw +CyRv5KAgircOqNvBc1P9iUJAb4zX/cIkdgaKpca34rGCURz0BKbvBNBPFoAdkenJ +1nVoh34OJiRFTTLy7wY0yW0D8l9GHhbdtUD70yMgchw/0GUghA495oBzfU44zuOB +9XE8y5GyqORS35uIRI3rey/8YcXzUgT+f65o+XSEQR/9yiYiK4PShzfGagbylBJ8 +4wmkMIeUdvO66wCYm4CnDqcfMyCyPahDVDtYTiucfdIzsdlCp5s3cXuzil5AHjk4 +1rBCBK58ldu98d8mDz0SrR0Dip/eI1GQnTXzvoxLe8pU5X83wObU2xCVyrwX+cBp +LyALIuQnHhyQiJMAEE7N55G5Amgw4oTYJ+8VxU0CrPLQMmsdN0lkLTyXSnxm+S1N +Cah09fWHFLt7rJ5J+HAAcLYPxzw5eVmQmn48d+8RsOcEvDPJ+N4JIYECA6nvDBpu +n9g/hniXZeGur3g0W+Q4cugA6Cpd/wA43qYVRCH4XNfHcUksEnafWMBGwUTp+c0z +nwC5vzUHsHC4JH3F+fFOZiME1zW7yfhxc5td06edzzm/IIqqOF6PEy7HDSyBDfdw +F8kDS2SH/mW4oht1fHtrGLhBoe7ZDcQ3kUj0UUSuvjo153gJvTjVBaNoHfG8nBDo +ELtDnWvxh13sztjoOQ8XNYLJJRNs0ef9YAc5ldNnUpd4S1NICKpjia1uacOWe02D +szo/jNsEPXXQDwznfLggrawBOGd1fxlyxWsxwS+e85SBsoTl7LlhjYEvfMNgPLiN +c2AAkHxvJ0AC0p4PFtplzEirSo4ZTPG8WASOM35I/wB5EVbwN0zYV28TY4JwAbL3 +kiQvhj8/HrAFPLYUfFX4YKuZ3y6HXHPjGqtVBPU7NVHluNHmEu6X6v8AzhAHNWi8 +72Q3JnIwKsYae3jE+HscCjW7AOjFgAmAYm88dYQVmvpty0frtx47FrPIKbj/ANyN +iVu499FTlrpymnWgiHXI/nOUDUu329G7+N5CHhQhZzJ5cVSAsVHDWi9p43gRncld +pOmwTFLlokJfZrfvWJMPH+qwa267wkRjZecDzenT6xHoQApwAOGYHLqOmnwa+zIS +IdEKpXvW+8PgWHMBu/fPrGOhgCBYsvT/ACYZpWhDcJ1OfZlqCUhbAicLrxkNIn1i +/ng3vfvIRABur5VGvn4y5zFNPTiQHpppHXeTNui6XvAVhQ00m/8AWIsnEcWC9AFe +nJdsMu2BejZ9Z1bSNIPsO3rIgi+NAXl5n1rCJ1w0L2PwaMM09CGmHD83fnAr4Qx5 +ajYhdPWAfA4yjl9Yeg12WAx7Aa4u0pAHUNkbLd8mRUWBNSSkTr2UyoEaNtAvWUOr +vvE4AcGrtfS8fOAgpBMVoArUW4SChZ6ceRNaOOMEvfmHUx0kr884bDoFsFUu9/04 +LCx0RoWdLH7xg8ALvIP5nccPg1B2t0ByPzOcEEug0Ao1Yf7yVTD6Hkf5xTy3blOT +w8+HD+5RNE4QO14OsfyuGhgp4pz1znSrBa3hvWsV68hr7XjacYFJBGbFuvbgopTg +NrioITZPT1iYBpwNrgoLuKVEwoZDSerz/rC33owJ6fKx+Llxol3ULLaDvEaQ5Cpm +07b4zfFQAb2mjiaPOUlgUiFmg/jNqDwatrxtt1j9OXpLVQ71TBsCEI3W5p9csxLX +ZA6WzS1/zi1uo1x3rjmTz85yQKwB069P1+cC2jsAAXOvOVFksgbY7vl6wxZMCXKK +gEp/Ey+u0ipY2HTeTxirUKYo0FJx5wb2CLjrXQP06zU9sQ+Qel8bxTcBXqFSPQM2 +MvDh8ShVUPKbK+W7ig4hddrH7+sqYQ6EvA8knxg5DYLuDIXenOABZK9tuL7v4y/x +oiQusZ4pb7QH21iRJ2HCgGLRWapy5LII/JwS6LXJz3hKgY07h/eQKHeda5x7EBBh +5naNJihjVbGwoj5EPvHL8BLyuTneWZPboCC3tLlISNNb0N8c3I9GkBDu+NzKBC61 +CxCeO4+sSxKKB3CHAd/eJ/DQjSLNG3gwUhOOABoNc1+cjDzaSs3mNualN7aAW66O +H2oLdBIONzY/OAHCYAgEHEFP940GGusCykNyuXeA6RHaIa4oPXkxvEYdGWXvgnjJ +yUGGz3tAOcLKegSV1/Q5Zzl+oRyVJWHmT8YNofEoPn8X4xgCSiFDDjzvRk7pRGNI +UffBikvAW7I9jZrxkRNWKwF6qhcDmDkIEKtuKlKqXfP+sU0IG96c4NiOr/PziINe +C3X0uFYqb8j59ZtAqdN0PHzkZMKbmj/1kNguiEfp/nHVlglebe2O31iBaF5qSXpf +WFT60N4B9u45SkSMG+AnHh7x8jRjA077nHzheYMc6bH2cT3iJJOlEXK+O594q19n +EnE3yevbhvVdo1p5D/TDjikAdZ4SbnjAWTdIoKF06a4O2s2XnJV0rhDhwkIQom1S +F/ziRI7PrwEzyB4XFgNOagRQyPtlDXNyCmIDXW9E8Y32n1ZANmPmkxFVQ+Aa/f8A +xiEB7FDfxPjJzLklfE+/OD73UVhu3bbrGUiiwK8wf6yf55bR3+gyGsDwtbjBoJsp +tjHZRTXuecGgp4HeMBZGALr5xGDtP284CMFGllMR74ks59ecZBEcJDGhXChvZeAF ++MVQJORUCa6O8kQ6Az6E5PnDTiHY0746vjEmHgKJJtTy85SBAQOyNm+hx2cNzeSD +t89ZpLtdQbwTX1l6C2h2bE7xjWkA8QvLaSbM/gA/JDAfQ+zCzw6EVQbq3hKOoawl +a9aQLx1+ztmGlS1yBSWAOziOTnQG8gTlXR8ZYjoK2HzHOu3xhmEHik2bY/wy7giA +UXl4OB+sg22gUvl1ydfvAUXgyvMNrt04ImxpArtfgMa3FbMU2e8XRottbX8H5wl7 +qXS/R7yCKpoBp+cRbtOA4YkUQNnXowpVHIO8kp3srT01gDbpF4SYEkFVKJJm0KMF +vm85qdOC7NhObMBJVYRA/wBL8ZZhBHVTS/394HnE4EqHzrvWVz3JChm+KzFLRzCl +RA8SXFd2UkCnyqsOzxjIo52DnlELR+Oc2CayQkKDhrxxAeXEYADgkrOdDT94Zkze +yAWci7guhja+IwiHDdR4r5xc5COpB50muzXOMiEQgGuehVijmkkguZCnLAc3eDkM +KMldFaFcD7YpoWAYA7WjY635G5UZAEjhB1OHxzjNaEIS66/H85LpQcQBNP8AXGBt +ioKPZ35yBYQ0qVzDt+s0+F5ALT8YVAY/DlsmnLXGMAEnO+v84eQZQhccpIqngLlh +4Fr8+L/XvNRKq1sI+fGWYeMNvX0OVhSFZdz+MbagKPDArJaa5dOW31hEY2gWUK5s +kQkGO0+9fGbjwAAEnB7feV0AhgeW+S8ZpHjZDYFQOW+7zMLOku5MN3Hr2c4MYWcM +XRidoaFHotm6IRtLiqLxzMXSyELlHwwQ8bhinAtJiRx9Xc+80gZzgyLusRxJ1kzd +LW2VGmSk2uLFU1djXXICN59YvjLriFF0bK38HE8J2CQ3G0I06fJjWnejEBOYD5LK +2TlJWryIfzih9txEjw+txy4jSDR2Xg6jziI1VdKofgwRXJAnJXAEq8JfWIY8XTdw +84rkSd8nDHSCCB4cD521usDxGxK/75wDkBCq5+sopWjBn/fGFlQcHfi+MunOu3KS +G8QIDIsohypoG5MiLYA81PE1rEFBUiGBeiJhlNPlbFPTjDoWoiLV8JrBiwGtcRum +FZs7fGGdF+h8k3dmkHgdYlIrRDcUsQ2cgcmbAKFATw1vXVwmThq2hHPlNe3Dvdg6 +uxLo7DJ8x6MlUClOF26RzeGwOgVtp4K3rW0ZUeATo6KdbqXe8Maw27QMu2AaLM1S +sdSjtdKK6owCi2dLUeNCDsMN7vuBaQV75wswUDksJ3/OHGSZmoCHr1gLZXZA3/SZ +USJyxUPXjDGN6U+OHE1ZWo5ohNtTesNWpqQ3ifNx+x5wt7BUqi+sFqqUBsnnFIUC +66/F/wC1msg00Bzf86y4h6Tg1xgVJOooHn5wIqbwQI+NEMJZi+Q7s9ku9YNUJKwh +LO7vnFWKskHok/LrziOVDgCCaoA6b8uecvUVSULzauWveBiaFlqFfSV8OL/XGdTv +5dOUgJJ5unvhm3yYLpSOmxLfB/OUCgDKedeIz8YpCPo3SMHvbhzM6hk8mvbMOnCY +Xdg9nOJe3BQqesJRuAZ6d0MkakQ+BrAPbBORNr0969axnW5ebnT64yaCcv4Dllc5 +aNMOM4NCopxcTCVW3tfZ8YgkJUI6w1pkX5ZzE4xyHvC6HoT19PnFdNKscnGsaAU5 +6SYGAmq6Kd5DfTrX6/7jDYg0fAx7yCIA18ZysXQUIX94ZbKa6D3Xc0kx2gJFYg7A +EI84jinblHXZxUO/nD48AE+3y1dd5QUPo6GjUcO5eMe2jURYvRtH7wEgKgjBdNcb +XrFEp0zAtHLognPeAQRoD/laLt3xilBCFQFKRj6cBMWsKIsmyml6yj5E2yKGvQ3j +CcTNxpyHQKqrmjN1kVNo1vlqfOXJk/RqAAuiGUIWAiX8vfjGAbhI5Pcs/NzgnyU7 +mPVP1wDNPR0cQMk3peW+cEEnjZie8IHaC8P9ZC0Ltpp5y1r2ai8fOHStXRs3zkhH +QFHf3g2HYba/3lNkHqv05uUmgRfwPjAkWC88OPF1XSY+blaq/wCtpPGrc2H554In +Hvn1MpJRNSDp1sTvyOU6GmiuSfn4maBKtcQs+F2JiHJcVRODjTo83F14+qjV5cH4 +xg25b5TojjZzthOw5MAwksSNnoE1Cqnb84lOZEjgJ2p/6ZS2ApUE7aFfk6wtXVaq +TaKOu+sQhDDYXyTtd4KbxiQaODe3AQ2sgIUISNoHnLRlLILE63qeDFBYHOS3k9uz +NaiegBEwaUTUrIKHVUkJ4Sc63gaK86fmZaD9XLzvEkQwVervGc1Dc1q/zjkjZXeM +0itujQGS64lF4wyKR4Df1dmNjT8BaExaIBG0vvFAQx2k6mX1+80Pc6c/GIHt84bJ +dDutDkcJDLpPqL3OLzMZFEAVVMC8xpkYT7xLgvFK51zh40xBzwg5dcMjMLNOU0O/ +6wcbUfc5TwPBzjIBl06xvC2/GMrRuD0AQNvLl2CkqtJFBO/PGG8rZwKIXekHB87w +w2a4shDgGQmrrxgT0sQyN6psh9NwO9wK6ajt3ZMJdSbC6Eck4TGK5sAgmnxeUnHv +GBNtU1dofphwABR7gcrt6xG7bahCIHIkHRClJHWpUW6GgUS0cGdOdUy257EE8Kvn +4xq2QCKcnrLIXgXRMQG/C2vjJZx0UG/v/rjd2WgOt/xgh16TmGUpl2vBZ/xiuBCH +yv8AZhoL2Np7yOEFX4iJOyOFA2BSbaRffrrEVEBxD2YCroER2vvrAgYOwuAc+S74 +xUSw6h0vTy38YLleHawQ3a3f1nBF4m0Rqb4XEEONaSlyAujn3hM2InqER2CvMDH0 +DorVylk0eFcVa501zE02V5VZhTDvWzai1gJS4p6xfBjPJGd/GU5Ky5wXauDvF0PY +odjFpww3IY8eiDUE3Kdp45wFtooE4XwP7zR+dhMh3oeAv3kwk3rVol3SdCBhqECX +DCB9fGV+IkprTycOHlHHeFoFcmYTOxZTziNMiefBzc03VvQV8fWKTC4sA3k9s7AU +OzHNNVfj58ZQpbejuGBcCgNbW9dGDLzdtw+D7GZpTSoCUEvDJG5rJLw0eTxfGFgU +hNgNn5YKkRZRg8exP3gJyKxEJyu7rjhMaPWaA7gGtcR1gUc77c6UWq9Y6eRwsfHY +UrxozdSnBlqN0AOwLDWEuQYAAhDY8uYw0YqE2z7pI3wseN3BYh7jUJ1j5TblHEtS +nT3uBPneaIRWOIayg44FrZMnAANS1U2jvzesfNrIvFE/k7wG2gN2TSeF/jFV4geB +JzIbs7MGXQqQNV84f0EZLXQsTXbNoFX2xmBSg7AHjnPh/wAjKTmCD04gtBeXT95b +S9LNYls0OKIHzgZMRZw+gP6yuMIcX8/vWaggNh7MNHQXj8YKTqM2/wBMiCYOxdDz +1iwztYgVqDKXx3g3iMLoI5hY0UDk0UwPLA7BPGJip0QE5jIpHgz9vJ2YNNk5+D4y +ZVMQbaO1fXrOItEBpfBadY8FHuxZuOQDlwU4J3uDWGVgJViYceDHCnAVCRrWtYIa +g5CiRgQjUGTvdkV78taV0Dctgctup5BjDEseDA0hG6Q9CR8b6yZB13lwDo6uSrQB +e4yNQ2EJTb7eT7zTqUAEr7OWBbwujXY27MHYH8z1uzUvkdWTHKICagEE7oUAs6+a +cf5CU9emNG5KWi4S5jNcT5xIb3A8T1lpG+E/vJekdkTAKnYbdPjIaKgKtfP5xofJ +FjHaYICJ9o0urt4M50NPzbt+LEVxAQEC8Jq9zEpnZHC62QcPePtEe6ppmuO8Mo3a +hXf28Y2qAk+I9jJPWW25ADY3A7MNhZDgC3p0fOQ5qxR/P+MoUVBssxSfvDExxhMJ +H4F7zmocFwimg78WY9PU9SBfDBTK9EswTXoO8qhxQAi3lb8c/WbFOOdtVaE7Pzmz +V0K1b110Hxg6/voJDyeZzkSJQHn2mIpBRocx2c6us2CGRDAYxKga0VNOU7bQnzjC +FJkxCdpDyaWXpEFqCVKA/wDwid+sEywO197OM1SWTRd51Fqckhrke80lWgOZx1gN +kp0d8F9Z04hhCo+YYi8YqxvwuLNG3IiUdqc34zlTyqYHyn1wRNjGpJ+n9dfGM+iz +YHmoYccYvdgpC8OU3wpNklPvOcVypycfHOKSIaNOdSmusSRCzEFunjJ0aiEeCnGI +wCDsgum/xkwgo5HTOt+c5zNhLoBPcwLnuMgIq8auEL0kQA9B139Y6w7TT21fAPvN ++gj1clKn1hkEHP5w/g+c4SAmgbZDy7weXFGtrt+MNolgginP8Yl5O3N36MiokaEJ +dNmFxQmKUcmVtBTEIQB00UCwxGjCQNfQeHpyks4tH74wwaIaKefnP//EABQRAQAA +AAAAAAAAAAAAAAAAAJD/2gAIAQIBAT8AAD//xAAUEQEAAAAAAAAAAAAAAAAAAACQ +/9oACAEDAQE/AAA//9mJAlQEEwEKAD4CGwMFCwkIBwMFFQoJCAsFFgIDAQACHgEC +F4AWIQTj/yg5wEiyXAhN6+myaZXjECUFaAUCYJF1qwUJVjAeEAAKCRCyaZXjECUF +aH/mEACO/gg9l+jJRX7h0oCf4nQz0CvjhvjMCao/+Ynv59IvwjmdGyRdm0lmYruc ++F46MBbz+mSj0Y+p2gOoXQL95/SFdGoHmUaRmuXK4QlqHH9w77jfgRC8y0OK5pRc +c8NgMG2yA0Erip0HI4hsQrnU/lM6fEjk+fsAN1b27KgUSysambJnh4vqM+pmAB0g +Nzey0uIuHFEytTp3y9uNXlewFJ6seCePQ0MU8aWROMHZ6tUQq8M5UlIgVN09SGWs +y11g98T+J0sPfNWm+FV7kNJ+2DYydyTGqjEO7bOOFBKR7XQKwZHs+jh0t1/cAdla +Q+nsooOou3YNMZqdRXzS5zIIEKGYIMzfo8g/01Tf7W8uTPGSqL5MfggSWQRRHHQm +O2F19pLQr0AATagLPwSmWRh9lq6TLd8ytXMd7hsFut/7o1uhVKKcwBrqSWbwSIlD +w2+ZBGhck4J4WYokD/u685sO3dWJ2hk5kZ7nuUke/o979n9iyghHAIUysHqsUaT7 +LLiQbeX+JfPvqcObKI7WrLvDIQQHWu+rg4yWbeLgmqgT1sIlF2SRaU7HYRdqYBPS +bP1MhVwOPDkF2ZCYAxACdgezrp7Pg8hgEWY4RT7gxK/CoLisCVihORR8aezT4gCl +0aVSnOHE3mI7tWHYBRAnboU2Fgkm3fzzzbbpQv5uHlijX8BPVIkCIgQTAQoADAUC +VVJ0fwWDB4YfgAAKCRD8n7XhIU7pK6oRD/wKrbl0W51vDauCFCvfSqmzzcRNLFi7 +A8b9dQ0OnCQgoh9Vw0aKo/T4fQ7dPwprdiDuYToeUbDITnNKRf/0PNM75NEXL3ov +Wwon0PPJ3NdazJhnE9hoKX9VQI6gMzMk7CkpJiunC2gu2+9f3DOO2n/EeKKnZ6Wa +xS8Gh0uIO0aYhKPFWollaP3i92Jk+7ad71f5eb4XsDvz7V5CKxaCPJN37j7xSbbI +Ebxt03GhiavVeMuKBrIJKKdCq98dw+D3wqUWaL2gD+kILoRxNkT7aAWa1+7cxUKy +F9NB0lNaWN1Veqc+Qsr3/8eVI9JC+pPJ9xJgy70HG3emwYhkkKf1Lw4e5cnpjdfr +TNYbR0d0kdmjQz3ng0k7IkXveVdB82Cr6uAK0lUqFv6OqYiiP1/Bla6XvqtPw+so +jExpMp/SwEmMQdJWdbqZKwrypFf0kUtUbNcXHNMCm2ZxMO2ErnVpCVdVByOzalEH +pUt73yG6ygithiqX/gd6V2jDSvs0owOG3mfJyPdS6BMk9XWOZ1IPJXZOEQ+7l/f3 +ZX/svebZo+Kh1ublvfjcEa9LMmr6CMaJc73rp3uoW6ymB0ZnH4kkyWC8J+uQeMFT +nNKD9Y+ns+TvO6vkpw4cOJtr8V9hDpKjrpZiwiskL+ffFgW1mJdGLgpYczsKk1hv +/eZHnbABBRLTgokCPQQTAQoAJwUCVVEpMAIbAwUJEs/3gAULCQgHAwUVCgkICwUW +AgMBAAIeAQIXgAAKCRCyaZXjECUFaA7qD/9yFF0TPFy48/cfxM1B7OXSawVu/cv4 +YGGvQLVq9qce2G0uW3Ocjm/y49szQCWx1HbAVKdL52bpnA/C5JQGZv+GhSmAxDeY +QKkUneJUG5kt5u1ZqdQ8t1aLJwVri7CS77G15IMZ4Q6maTjcmXN8HC4lc1oM1U36 +brMvv8ZpGImPCMZ94baE0mdL7vaSluqRkOQt8rz8hu2JsZel7ou7yH3shJ0T6yJ8 +PozevsIlLvIRu/1A8j7HdYb1RA6qe8vD/Btmnw5LfsCSTLmEMlVHTRgtznuVYxe2 +UfYtiafMrWQxhHe/96EpzRv/ksU4uK5B66H/3SN3bOJvyEze4vImF5OhtGbelJQr +83vCOx7wCA3FozOosNF3asZGEOvSq2UY7E2+X0EnjQG+nqCMxE+D3m5sdtiGJtP4 +3/nvdYC3594htAKR7q+oTlasn3ap+QvGd1E1rX/zYMoBY03/4Sjy3AbQNoqHzj1T +x3ceGZJ6cUhX2gYHDQByObF9ae52B8mxgMrmh+TegtCAq4Q/wD4UJlOTYtt6Gt70 +b30GfdZjzwywG7xn/Gt/BopmHdg/8B7B1LRW3GjTJsWnGWG8jy7cNHIhWpSu5f7Z +leod1erypRxy26JttHiEkYBm7uOz9xAwslSXurIZBN7i2/+MxCfhFvNPsNmEWGBI +p+mPtWvWjVBherQhxYF1a2FzeiBMYW5nYSA8bHVrYXN6QHB5dGhvbi5vcmc+iQJU +BBMBCAA+AhsDBQsJCAcCBhUICQoLAgQWAgMBAh4BAheAFiEE4/8oOcBIslwITevp +smmV4xAlBWgFAmCRdasFCVYwHhAACgkQsmmV4xAlBWjeHg/9EhO5fNFc5ytoH1H8 +wWyYN83wq6ULKhzZJu30rbrkY/v4bz/hCkVZZGzwbgLpbXllyPPoc6gmYvSIDmL1 +cKdeWnlr4yWKMh2SGvWExvlFn8ShtIJGPykM/dRF4HgXSeeJy2VnLPUYFLKsabwU +lFM54ukZJ1e384rx4eLvWoNCsjGbHty0eXnr0lQ+5KzPIfD/ltqKyoTZp6FdJc5i +2Jl848/ck/DQkl21lhuJ/GlBoyMjbbEvj8+xDjFC2wbbFrrXSvNBMNTPqUgRbQ+a +ahHRnBUDOBhY3LhUd+NC6wTBLMs8n5f64XB8LMV2QzDwBgqAUXx/CnsxBP9kY5Vz +KxPsQYOxJiujlEvi5bC3Vj917n+mGXvcaokA8HvE4Jdn/5HyPpMjCKb1HU4D5U42 +k7U8WoFzi+H1nI0h36bbhhWJm9/feASwIGbpwHeFVNFEp0wWJS9s3BYIkFK7Kag5 +PyrcKzxlwGB8B8bKP39b2MYxyDjqSVLSVbFVKZLa0xsFyfzLR8y99sH7SxYlVwY+ +i6kbvCBu/y9q6tKZtS9faMUQLglNwchWNWBwesX+py7PbrNSLQkRaJz8yY0y4Ynx +hiDqolwIhOUer7dDjKs2EtA6ewdsih5gAQKgfZKl72v1G3VwjQ8ake/Brx5hrJNQ +l6En3VAHuJxBHyYDQiCYiG7eS8qJAlQEEwEIAD4WIQTj/yg5wEiyXAhN6+myaZXj +ECUFaAUCWmz8MwIbAwUJEs/3gAULCQgHAgYVCAkKCwIEFgIDAQIeAQIXgAAKCRCy +aZXjECUFaMmDD/9wqi/ZKfeCQ9H0Lrra9dIImCfNVu9+BNxPJReUWJlNwMOCy9hK +f/8LGCPPFKJJy0BCA+eBjEor/f8R9Pz6gIzAjSPlXhKWwS8qtMu7740mUMa4ofgo +vk8sikDbun0qGbgRIl++TOeTCt9pJnQak3xIsEg0sDs21gtbL4KZdpDHy3eGZPCW ++/+m4zoAkf2B3oWX7dHgTvCbKu1Lh3W2h2N8uMt5J6LXPu/65jI+XGoN7mJSji05 +GGPRXrjaoxtEv6x3Rp1xV5UmO7yWXhJbzzdDKcZz82Yrq+YpVfl3erNpNb7CVY0g +98cgiRDa9AMKvNFKQSM4iEUeDWNNK+qjYUFgcprOzbC3F3GhmigiYzjTH2FpIjVW +/TT4Pzd8Nvho4YgdD6UYZgssa2WUJpHUFpxGywv5jGxHZ0fbNMw23T3dobuOpm90 +AeT8VdSJyTWtOfUKX9HOjcUSp+kKaNDh/XjuNvKUHKWuh9yPeqlRRXTp+vyNLXif +WkW1aj1HUPAmI6G7dW7ctOAgTL2YbhBIyQiBFvGx4ydUuRRZjCR8m5185XOHRJHE +9S/uCKJqoBqI/MiikU8hheJzodgjxlaw2mFSaTMyJa0BJbeQTwNYFMC7LtTCTy8I +9o5PGAb5QfKqO6h/5jBrZdn4F5sS2r+0qvgaHdD/uOSh/Bb671oBWQXDIrQhxYF1 +a2FzeiBMYW5nYSA8bHVrYXN6QGVkZ2VkYi5jb20+iQJUBBMBCAA+AhsDBQsJCAcC +BhUKCQgLAgQWAgMBAh4BAheAFiEE4/8oOcBIslwITevpsmmV4xAlBWgFAmCRdasF +CVYwHhAACgkQsmmV4xAlBWh9/Q//b4iWPj7LOi2J/mqfebGczvMQgbuIu+V6gdO7 +2b0zfo/U4mT7EBw4p1hlsvkM536OSo2C5XxgApOkOPGSD5dofgh9jzF/cQ5uwmjk ++8ffYFOPnqdvvxB/gpoerTrVoKF7m0scwyw1/wE/KfNQS2E+q8bBMuaxoRgnuEEQ +auZ2ecqE0YZkLfr6HIJBQfIpqKvEbMmku209J7fd28zzO9Wsx/1APrFKBvIvvbZt +t/go2e4PeMoDGNhvOWARAHz0yy675mabI0B2iatqvQS0JTW94IfInUb3bZ9oGMsA +it0Mya8fm6K3o0o/l+adbce5cqpQXpuOAhSWRKuXRyayO5uyGH2W8Z7f9SFHEuEJ +mBAvMDSlK5vs2ufCbf+7Z8cjkkSyz0az5VV4l7CMICCCmE6nBb5GzT31p1X4ahP8 +oVdIgdJ1WlEmidfzUPvK/nbS+2HbJx7n8ZEmXIdULrq8Vq1QygmZT66pe9bx9Op4 +sIOEWXH8W3hyFDZvGpWSpVbEpUk6C8VCF8kkcykeQJp3kP4eA4R7dAzJ2QkvA1nt +AOkW8ma9iq9c34i173TP170D7Lw67SF7ZBB8mc3isvJ5dDybVCjqCD0FIRKcD9SJ +g1AF0Ay7ojSm11Fm2lZwgJR7dijzNgfXMEUwSQLuc3ADJ3gXq9Xu7oS1qEvMce5m +JylEx8qJAlQEEwEIAD4WIQTj/yg5wEiyXAhN6+myaZXjECUFaAUCXdbAzwIbAwUJ +Es/3gAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRCyaZXjECUFaLZpD/4n1nL6 +cnDImUi66gwYCLl3WmVJNi99e65XEKmVaWPjJhlBetaPy4gEylurxvkKEJyj6doK +bjPByr5c1/muRMIoLj1AZVCuEFmKy5Czbaa8xQIuCclke7VjHN38v+Ft+E4I2tQp +0YVO9rFSp161J1DFetP3rnnPFtYO4tYh8AStoIzSE0p5/+q5BIcYR7AC5zR8JFdT +bsY2VQlL9t03hv+L7mfFN3pquH2qlnGpMT7/9HCu7eIX1PWfC1nDxYB+jrhMh8BS +qEsortPdTRjaZAlJTdWShYjNmllZq78xo+1K1usJ1tbsYWVqEkl2gRw69jnHCF95 +/qVlw8bt338o1ZZEvqgR6LYcuZ4xheAbfzUJlIbbcvO4YOqz722T2JCm+4AJ5WG+ +UWcxaHAh74UHYHUHfA84bRnRYbCyCo06sq9NDsufc1CeltDHz7ehYhbVy1jfcX+O +ON0C4j7xFiFmd2IMRJ+nFrbCTRULLo33MzVMQu/KZdXNgJI0n2pa4AP+9H6eQ8G6 +UMrDXVXLrNwgmnNsncLMiM4qkJgtJOZ00+z56AGRgoK3Nyud+CFvrQA5/EiF6vS8 +JsIN4gi95HxSPOI+UJX7Wl8alJtLH6VZjRu4zzOJT3H+Us9N9ZNpTOBQR3K8t7gZ ++trEPAEkQMG8tAvwxNMMpaMqu6sYTi4KX/6DwrQoxYF1a2FzeiBMYW5nYSA8bHVr +YXN6LmxhbmdhQHB5Zm91bmQub3JnPokCVAQTAQgAPhYhBOP/KDnASLJcCE3r6bJp +leMQJQVoBQJixGEpAhsDBQlWMB4QBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJ +ELJpleMQJQVoUbUP/RuyctMWcUju01mrrRlLDECiu/i8Zxhi0Dr+8cs/LvIsviK0 +82yg/B0BWjFDTpUXjrV2xMK5pV7nXA/K+14P2hFM4J0URiaQrL5+DokAPd72aZwB +IhBW5lhcZuxFn7lqgM2tHXLa/La2705sPqNEHdw6s9ISRIK18due4CCGmDhUuamu +T5IRAYifG5ksdFSQWJeOq7z+dc0+qAAty22LcQlZCnoOxZuypXESzFMlTpS3SFcc +3unqQK6zujZeEnGA0adViOGADMT+qFUdMi6uXI8JSY37gt31qNN1sxL8bbUV0aLb +YcHDcacsawB0A5Gif9IPKONwM1lexDzI/6pHzZ04VA6XsLTuHi0EjoltqR1entJr +Uzq40UfzFfnUOwucKnbDgenOne2EKBqSCOj8Aylg4w3afw5vv+xqaUrFl0ITDc1p +98ZBGOCxwnPvD/Vhj7s2qNl5I9j4Bto6HDL7wNDjA/B5gsSAxHyOBtITl3Z21SCz +iaA07f0KgDDTdnDV3LYKzUibOTvsrYMcegJ7gdRi/V+wpDE02LNH06UdXAM+geBQ +UDTsHdsmVOeIi+axjwz3cWmgxCAanjEtoq9qerCaVnBTTHqrSc4SvSXNfgXFmiJr +8R/jdSMmha9v2Eujqn5uHS/njOYKvOl/LlDT+WX64WkMgDJefoDysIAEdS0btCHF +gXVrYXN6IExhbmdhIDxycGxrdHJAcnBsa3RyLmNvbT6JAlQEEwEIAD4WIQTj/yg5 +wEiyXAhN6+myaZXjECUFaAUCYxY98gIbAwUJVjAeEAULCQgHAgYVCgkICwIEFgID +AQIeAQIXgAAKCRCyaZXjECUFaCZfD/9wKIaUvvWsaZT4dq0zwnS03Q7XqNwlXYQh +LQ8t5WzKVr5QSQFp9yARGBVfLjyJ4Tfwc/M3HEkAQMAF8umGMp41ESI1/6wma6o6 +IwgF13CFUO2Mt6xJ0SyZlxz5q1XY71hgOYPa7rS+8OwBIXCMbONwLI/0y2Gxg+t7 +eQbpqmE3/DHpHb8EhEl0odyXh5vzxFa3jNsOudeJbE/oVbmA2KtPEw68wmg8Q97a +qSbrLhP2tXJ+tN9H+p3+2D1tF1T1eC+hYSMe90LQwOYB/aD+MyMj3ai06RdDGmP6 +V3DvfKfLZPWFC+2RRmdenPsZB5TrJX6rjHYTo4qcvG2n6yAoxy7LvDwYHHJDkjax +VQHsGVj/rnBflzgEE2hKWmKFSfJ5iTVeFW75PMtIJAIqbAd9R9U+QzLWprkk92jl +usde/qOzjSDLG938xHtPl/W1BEwYCWCmu3cc8YiIZL2+Ig/1m8tnI/i65v70qxOX +zJT4HN0aZzyHmaM9JIduMm4geTSFLAIfT+Xh53a/ugzmpwSQhkCPSpr/CSj0tWKL +p+UQOojstrwSN745bhujUMl0zpedw6JBd3Mehj54ZR5E3yP8DYpVb/531xuZGpGO +okc2sC7AQj+KsOOwlss15Pp5PcG5vHzEsViW1k2hzfJWyuXCIviex1nsbRCQLIYy +xte6FM9RirkCDQRVUSdJARAAt+LOfnsgS/UUBHlxPITQXI39A58YEHstzEjK90kl +WtLvrLPBrqklWBqWcF8QdBeiSsi/qC/Ybp5GnJ8D/QUjCWWv/gIyB6LJ7Wxj+0v1 +8FNYbVXTVm8cI9ZqG76VDCY49xbvlr5fbqiZr1fryA/XdA5co9L0avFzrqF/dl7n +LYWAfRoNgF0it5t6RMWcQ8Sat7VV0S9DtBW+PXIIcnvuSMwWANSPIzWKydT3ZTq0 +MvNs82yMk4kEc3uYQLcpF7Mw7ZT7cuB5uj9SbODAeS2dmcvWhkbaoE++CltEsdEn +qWM83rD6ABb+dIm4d2Zak+/IKQB9MOPgd3h3+g5FSJS87krZCq3NpO4NCe3jx55y +YeJktRjB+g+yqvoH3Es4SUfYrW4PajWoG3esC6b5+DjGacLupjEbc9vSr0P8+nOm +jAADzuRbMvQe6hUqeEsflIeOJ4nUsgR7Hr0h4qgsXuASRnxNiYh6cEAwN1YYXyO4 +sSETT7cbwpy4qVx5SVrNzt4wITvH1nz3C0d+mR2w74F/QgoZN9quOxWcKx0e0yh8 +Fq1pQn5LntvuIdq9K1RGNSKVz1SgzuiLNNiuqKOyuksrJMpe9qv65NiCUkGcG9+L +PI00bqs/nGiL6yF8hRFG/q3To4o1v9AShmu1c1hBguzSOYrNH0qgO8jmgDSJNBrm +3R8AEQEAAYkCJQQYAQoADwUCVVEnSQIbDAUJEs/3gAAKCRCyaZXjECUFaDoZD/9Y +kQgWlkn/MjQ2aT94DIExfGMAF36tXa/3g3UABEo334IMZ2xSYP08y5RuGwvvY1/N +Pgf82KszkY+Z1rbwoOpc4rcl2rXYg45nPnmyM3dHC2YZufB/SxFFZKEkLbZbRjhB +sUPTSPuaxed9Xl8tXnW+Wv+pAD5DZuuMMvTqENhty/Au16kVAxyI+OOqijKtfKLp +Oert0VTp9zB/VXgBZC3cDs6qSaZymNHRvRgczWYQA7U4HZvn9L2gFjmPnFaLCapx +MH6UHtTS27eEHuWJaBL7XOhqEKc6P35xRKPYH6pJpRbEbcr11vhOIAT2rqBSj+av +Q98S3U8ST9hkUd5R0Vao43wf/6ddZyvqFmP2BXhyejutZhR3kbXFY8WoqsstFjxk +go840G7gtq5ZgA111bEq+4aEA2R0xOdTfjpPUZ9KuOdqCZlLBAcK+LikLJk872GU +WQCxU/QZGRGYHaxJ4Gz/3A2DN5l2zXwcbEbP2DGadiDgYlVfjnZLdSOLSCoyuWHL ++s/V/4uY4HUVVkBLZEsd6Wh81vgUTdFfnwsnCMRCT9aWo2jOvg/KGtH6hWIHAJl3 +menwYOd9VTrjcFnWr3pfL0qsf44pOG/EkuMoCvjDTBRRkyAzzxLlb9OygUqtRQq2 +wyssv8SmSMGlLrfee+7yz1F9N6mVsuyl21KxQV8PGw== +=baTu +-----END PGP PUBLIC KEY BLOCK----- diff --git a/plan.fmf b/plan.fmf new file mode 100644 index 0000000..88053e4 --- /dev/null +++ b/plan.fmf @@ -0,0 +1,65 @@ +execute: + how: tmt + +provision: + hardware: + memory: '>= 3 GB' + +environment: + pybasever: '3.10' + +discover: + - name: tests_python + how: shell + url: https://src.fedoraproject.org/tests/python.git + tests: + - name: smoke + path: /smoke + test: "VERSION=${pybasever} ./venv.sh" + - name: smoke_virtualenv + path: /smoke + test: "VERSION=${pybasever} METHOD=virtualenv ./venv.sh" + - name: debugsmoke + path: /smoke + test: "PYTHON=python${pybasever}d TOX=false VERSION=${pybasever} ./venv.sh" + - name: selftest + path: /selftest + test: "VERSION=${pybasever} X='' ./parallel.sh" + - name: debugtest + path: /selftest + test: "VERSION=${pybasever} PYTHON=python${pybasever}d X='' ./parallel.sh" + - name: debugflags + path: /flags + test: "python${pybasever}d ./assertflags.py -O0" + - name: marshalparser + path: /marshalparser + test: "VERSION=${pybasever} SAMPLE=10 ./test_marshalparser_compatibility.sh" + - name: required_symbols + path: /required-symbols + test: "VERSION=${pybasever} ./check.sh" + +prepare: + - name: Install dependencies + how: install + package: + - gcc # for extension building in venv and selftest + - gdb # for test_gdb + - "python${pybasever}" # the test subject + - "python${pybasever}-debug" # for leak testing + - "python${pybasever}-devel" # for extension building in venv and selftest + - "python${pybasever}-tkinter" # for selftest + - "python${pybasever}-test" # for selftest + - tox # for venv tests + - virtualenv # for virtualenv tests + - glibc-all-langpacks # for locale tests + - marshalparser # for testing compatibility (magic numbers) with marshalparser + - binutils # for nm (symbol inspection) + - rpm # for debugging + - dnf # for upgrade and downgrade + - name: Update packages + how: shell + script: dnf upgrade -y + - name: rpm_qa + order: 100 + how: shell + script: rpm -qa | sort | tee $TMT_PLAN_DATA/rpmqa.txt diff --git a/python3.10.rpmlintrc b/python3.10.rpmlintrc deleted file mode 100644 index da5ed3f..0000000 --- a/python3.10.rpmlintrc +++ /dev/null @@ -1,98 +0,0 @@ -# KNOWN BUGS: -# https://bugzilla.redhat.com/show_bug.cgi?id=1489816 -addFilter(r'crypto-policy-non-compliance-openssl') - - -# TESTS: -addFilter(r'(zero-length|pem-certificate|uncompressed-zip) /usr/lib(64)?/python3\.\d+/test') - - -# OTHER DELIBERATES: -# chroot function -addFilter(r'missing-call-to-chdir-with-chroot') - -# intentionally unversioned and selfobsoleted -addFilter(r'unversioned-explicit-obsoletes python') -addFilter(r'unversioned Obsoletes: Obsoletes: python3\.\d+$') -addFilter(r'self-obsoletion python3\.\d+ obsoletes python3\.\d+') - -# intentionally hardcoded -addFilter(r'hardcoded-library-path in %{_prefix}/lib/(debug/%{_libdir}|python%{pybasever})') - -# intentional for our pythonXY package -addFilter(r'python3\.\d+\.[^:]+: (E|W): devel-file-in-non-devel-package') - -# we have non binary stuff, python files -addFilter(r'only-non-binary-in-usr-lib') - -# some devel files that are deliberately needed -addFilter(r'devel-file-in-non-devel-package /usr/include/python3\.\d+m?/pyconfig-(32|64)\.h') -addFilter(r'devel-file-in-non-devel-package /usr/lib(64)?/python3\.\d+/distutils/tests/xxmodule\.c') - -# some bytecode is shipped without sources on purpose, as a space optimization -# if this regex needs to be relaxed in the future, make sure it **does not** match pyc files in __pycache__ -addFilter(r'python-bytecode-without-source /usr/lib(64)?/python3\.\d+/(encodings|pydoc_data)/[^/]+.pyc') - -# SORRY, NOT SORRY: -# manual pages -addFilter(r'no-manual-page-for-binary (idle|pydoc|pyvenv|2to3|python3?-debug|pathfix|msgfmt|pygettext)') -addFilter(r'no-manual-page-for-binary python3?.*-config$') -addFilter(r'no-manual-page-for-binary python3\.\d+dm?$') - -# missing documentation from subpackages -addFilter(r'^python3(\.\d+)?-(debug|tkinter|test|idle)\.[^:]+: (E|W): no-documentation') - -# platform python is obsoleted, but not provided -addFilter(r'obsolete-not-provided platform-python') - -# we have extra tokens at the end of %endif/%else directives, we consider them useful -addFilter(r'extra tokens at the end of %(endif|else) directive') - - -# RPMLINT IMPERFECTIONS -# https://github.com/rpm-software-management/rpmlint/issues/123 -addFilter(r'python-bytecode-wrong-magic-value .* expected 33\d\d \(3\.7\), found 3393') -# https://github.com/rpm-software-management/rpmlint/pull/133 -addFilter(r'python-bytecode-wrong-magic-value .* expected 33\d\d \(3\.7\), found 3394') - -# https://bugzilla.redhat.com/show_bug.cgi?id=1550562 -# https://github.com/rpm-software-management/rpmlint/issues/128 -addFilter(r'python-bytecode-inconsistent-mtime .* 1970') - -# we provide python(abi) manually to be sure. createrepo will merge this with the automatic -addFilter(r'python3(\.\d+)?\.[^:-]+: (E|W): useless-provides python\(abi\)') - -# debugsource -addFilter(r'^python3(\.\d+)?-debugsource\.[^:]+: (E|W): no-documentation') - -# debuginfo -addFilter(r'^python3(\.\d+)?-debuginfo\.[^:]+: (E|W): useless-provides debuginfo\(build-id\)') - -# this is OK for F28+ -addFilter(r'library-without-ldconfig-post') - -# debug package contains devel and non-devel files -addFilter(r'python3(\.\d+)?-debug\.[^:]+: (E|W): (non-)?devel-file-in-(non-)?devel-package') - -# this goes to other subpackage, hence not actually dangling, the read error is bogus -addFilter(r'dangling-relative-symlink /usr/lib(64)?/pkgconfig/python-3\.\d+dm?(-embed)?\.pc python-3\.\d+(-embed)?\.pc') -addFilter(r'read-error /usr/lib(64)?/pkgconfig/python-3\.\d+dm?(-embed)?\.pc \[Errno 2\]') - -# the python-unversioned-command package contains dangling symlinks by design -addFilter(r'^python-unversioned-command\.[^:]+: (E|W): dangling-relative-symlink ' - r'(/usr/bin/python \./python3|/usr/share/man/man1/python\.1\S* ./python3\.1\S*)$') - -# we need this macro to evaluate, even if the line starts with # -addFilter(r'macro-in-comment %\{_pyconfig(32|64)_h\}') - -# Python modules don't need to be linked against libc -# Since 3.8 they are no longer linked against libpython3.8.so.1.0 -addFilter(r'(E|W): library-not-linked-against-libc /usr/lib(64)?/python3\.\d+/lib-dynload/') -addFilter(r'(E|W): shared-lib-without-dependency-information /usr/lib(64)?/python3\.\d+/lib-dynload/') - -# specfile-errors are listed twice, once with reason and once without -# we filter out the empty ones -addFilter(r'\bpython3(\.\d+)?\.(src|spec): (E|W): specfile-error\s+$') - -# SPELLING ERRORS -addFilter(r'spelling-error .* en_US (bytecode|pyc|filename|tkinter|namespaces|pytest) ') diff --git a/python3.10.spec b/python3.10.spec index 6ebed67..3378bf7 100644 --- a/python3.10.spec +++ b/python3.10.spec @@ -13,12 +13,12 @@ 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 b1 +%global general_version %{pybasever}.21 +#global prerel ... %global upstream_version %{general_version}%{?prerel} Version: %{general_version}%{?prerel:~%{prerel}} Release: 1%{?dist} -License: Python +License: Python-2.0.1 # ================================== @@ -31,7 +31,6 @@ License: Python # Main Python, i.e. whether this is the main Python version in the distribution # that owns /usr/bin/python3 and other unique paths # This also means the built subpackages are called python3 rather than python3X -# WARNING: This also influences the flatpackage bcond below. # By default, this is determined by the %%__default_python3_pkgversion value %if "%{?__default_python3_pkgversion}" == "%{pybasever}" %bcond_without main_python @@ -39,13 +38,13 @@ License: Python %bcond_with main_python %endif -# Flat package, i.e. no separate subpackages -# Default (in Fedora): if this is a main Python, it is not a flatpackage -# Not supported: Combination of flatpackage enabled and main_python enabled -%if %{with main_python} -%bcond_with flatpackage +# If this is *not* Main Python, should it contain `Provides: python(abi) ...`? +# In Fedora no package shall depend on an alternative Python via this tag, so we do not provide it. +# In ELN/RHEL/CentOS we want to allow building against alternative stacks, so the Provide is enabled. +%if 0%{?fedora} +%bcond_with python_abi_provides_for_alt_pythons %else -%bcond_without flatpackage +%bcond_without python_abi_provides_for_alt_pythons %endif # When bootstrapping python3, we need to build setuptools. @@ -68,8 +67,8 @@ License: Python # If the rpmwheels condition is disabled, we use the bundled wheel packages # from Python with the versions below. # This needs to be manually updated when we update Python. -%global pip_version 21.1.1 -%global setuptools_version 56.0.0 +%global pip_version 23.0.1 +%global setuptools_version 79.0.1 # Expensive optimizations (mainly, profile-guided optimizations) %bcond_without optimizations @@ -79,11 +78,7 @@ License: Python # 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 @@ -166,6 +161,26 @@ License: Python %{warn:Doing a main_python build with wrong %%__default_python3_pkgversion (0%{?__default_python3_pkgversion}, but this is %pyshortver)} %endif +%if %{with main_python} +# To keep the upgrade path clean, we Obsolete python3.X from the python3 +# package and python3.X-foo from individual subpackages. +# Note that using Obsoletes without package version is not standard practice. +# Here we assert that *any* version of the system's default interpreter is +# preferable to an "extra" interpreter. For example, python3-3.6.1 will +# replace python3.6-3.6.2. +%define unversioned_obsoletes_of_python3_X_if_main() %{expand:\ +Obsoletes: python%{pybasever}%{?1:-%{1}}\ +} +%else +%define unversioned_obsoletes_of_python3_X_if_main() %{nil} +%endif + +# Opt-out from https://fedoraproject.org/wiki/Changes/fno-omit-frame-pointer +# Python is slower with frame pointers, but we expect to remove this in Python 3.12+ +# See https://lists.fedoraproject.org/archives/list/python-devel@lists.fedoraproject.org/thread/6TQYCHMX4FZLF27U5BCEC7IFV6XNBKJP/ +# Tracking bugzilla: https://bugzilla.redhat.com/2158729 +%undefine _include_frame_pointers + # ======================= # Build-time requirements # ======================= @@ -195,11 +210,12 @@ BuildRequires: libnsl2-devel BuildRequires: libtirpc-devel BuildRequires: libGL-devel BuildRequires: libuuid-devel +BuildRequires: libxcrypt-devel BuildRequires: libX11-devel BuildRequires: make +BuildRequires: mpdecimal-devel BuildRequires: ncurses-devel -BuildRequires: openssl-devel BuildRequires: pkgconfig BuildRequires: readline-devel BuildRequires: redhat-rpm-config >= 127 @@ -207,11 +223,15 @@ BuildRequires: sqlite-devel BuildRequires: gdb BuildRequires: tar -BuildRequires: tcl-devel +BuildRequires: tcl-devel < 1:9 BuildRequires: tix-devel -BuildRequires: tk-devel +BuildRequires: tk-devel < 1:9 BuildRequires: tzdata +# Support for OpenSSL 4 only landed in Python 3.15 for now +# https://github.com/python/cpython/issues/146207 +BuildRequires: (openssl-devel < 1:4 or openssl3-devel) + %if %{with valgrind} BuildRequires: valgrind-devel %endif @@ -219,14 +239,18 @@ BuildRequires: valgrind-devel BuildRequires: xz-devel BuildRequires: zlib-devel +BuildRequires: systemtap-sdt-devel BuildRequires: /usr/bin/dtrace # workaround http://bugs.python.org/issue19804 (test_uuid requires ifconfig) BuildRequires: /usr/sbin/ifconfig %if %{with rpmwheels} -BuildRequires: python-setuptools-wheel -BuildRequires: python-pip-wheel +BuildRequires: %{python_wheel_pkg_prefix}-setuptools-wheel +BuildRequires: %{python_wheel_pkg_prefix}-pip-wheel +%else +# For %%python_wheel_inject_sbom +BuildRequires: python-rpm-macros %endif %if %{without bootstrap} @@ -245,8 +269,13 @@ BuildRequires: python3-rpm-generators Source0: %{url}ftp/python/%{general_version}/Python-%{upstream_version}.tar.xz Source1: %{url}ftp/python/%{general_version}/Python-%{upstream_version}.tar.xz.asc -# The release manager for Python 3.10 is pablogsal -Source2: https://keybase.io/pablogsal/pgp_keys.asc +# The release manager for Python 3.10 is pablogsal, +# but Python 3.10.14 was signed by Łukasz Langa. +# pgp_keys_combined.asc contains keys of both release managers. +# Upstream issue: https://github.com/python/cpython/issues/117053 +# https://keybase.io/pablogsal/pgp_keys.asc +# https://keybase.io/ambv/pgp_keys.asc +Source2: pgp_keys_combined.asc # A simple script to check timestamps of bytecode files # Run in check section with Python that is currently being built @@ -263,33 +292,88 @@ Source11: idle3.appdata.xml # 00001 # d06a8853cf4bae9e115f45e1d531d2dc152c5cc8 # Fixup distutils/unixccompiler.py to remove standard library path from rpath +# # Was Patch0 in ivazquez' python3000 specfile Patch1: 00001-rpath.patch -# 00251 # 5c445123f04d96be42a35eef5119378ba1713a96 +# 00251 # 8448a0d6edd44d0818b8c02dc603b769b5363e5b # Change user install location # +# Set values of base and platbase in sysconfig from /usr +# to /usr/local when RPM build is not detected +# to make pip and similar tools install into separate 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. +# is not detected to make distutils and pypa/distutils install into separate location. # # Fedora Change: https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe -# Downstream only: Awaiting resources to work on upstream PEP +# Downstream only. +# +# We've tried to rework in Fedora 36/Python 3.10 to follow https://bugs.python.org/issue43976 +# but we have identified serious problems with that approach, +# see https://bugzilla.redhat.com/2026979 or https://bugzilla.redhat.com/2097183 +# +# pypa/distutils integration: https://github.com/pypa/distutils/pull/70 Patch251: 00251-change-user-install-location.patch -# 00328 # 318e500c98f5e59eb1f23e0fcd32db69b9bd17e1 -# Restore pyc to TIMESTAMP invalidation mode as default in rpmbuild +# 00371 # c1754d9c2750f89cb702e1b63a99201f5f7cff00 +# Revert "bpo-1596321: Fix threading._shutdown() for the main thread (GH-28549) (GH-28589)" # -# 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). +# This reverts commit 38c67738c64304928c68d5c2bd78bbb01d979b94. It +# introduced regression causing FreeIPA's tests to fail. # -# See https://src.fedoraproject.org/rpms/redhat-rpm-config/pull-request/57#comment-27426 -# Downstream only: only used when building RPM packages -# Ideally, we should talk to upstream and explain why we don't want this -Patch328: 00328-pyc-timestamp-invalidation-mode.patch +# For more info see: +# https://bodhi.fedoraproject.org/updates/FEDORA-2021-e152ce5f31 +# https://github.com/GrahamDumpleton/mod_wsgi/issues/730 +Patch371: 00371-revert-bpo-1596321-fix-threading-_shutdown-for-the-main-thread-gh-28549-gh-28589.patch + +# 00452 # eb11d070c5af7d1b5e47f4e02186152d08eaf793 +# Properly apply exported CFLAGS for dtrace/systemtap builds +# +# When using --with-dtrace the resulting object file could be missing +# specific CFLAGS exported by the build system due to the systemtap +# script using specific defaults. +# +# Exporting the CC and CFLAGS variables before the dtrace invocation +# allows us to properly apply CFLAGS exported by the build system +# even when cross-compiling. +Patch452: 00452-properly-apply-exported-cflags-for-dtrace-systemtap-builds.patch + +# 00462 # f0db87ee65704fa5545ea25f2cca8c43fc639fab +# Fix PySSL_SetError handling SSL_ERROR_SYSCALL +# +# Python 3.10 changed from using SSL_write() and SSL_read() to SSL_write_ex() and +# SSL_read_ex(), but did not update handling of the return value. +# +# Change error handling so that the return value is not examined. +# OSError (not EOF) is now returned when retval is 0. +# +# This resolves the issue of failing tests when a system is +# stressed on OpenSSL 3.5. +Patch462: 00462-fix-pyssl_seterror-handling-ssl_error_syscall.patch + +# 00474 # 837ddca0372fa87ff9cee47142200caa21e77def +# CVE-2025-15366 +# +# gh-143921: Reject control characters in IMAP commands +# +# (cherry-picked from commit 6262704b134db2a4ba12e85ecfbd968534f28b45) +Patch474: 00474-cve-2025-15366.patch + +# 00475 # 3748209a316662d4e85981ca1a7418547a1d25c6 +# CVE-2025-15367 +# +# gh-143923: Reject control characters in POP3 commands +# +# (cherry-picked from commit b234a2b67539f787e191d2ef19a7cbdce32874e7) +Patch475: 00475-cve-2025-15367.patch + +# 00494 # 430aab133397ed44cc9ee621fd311e02fee317b5 +# Increase the timeout of test_large_content_length_truncated +# +# It has started to fail randomly when run on s390x architecture. +Patch494: 00494-increase-the-timeout-of-test_large_content_length_truncated.patch # (New patches go here ^^^) # @@ -309,8 +393,7 @@ Patch328: 00328-pyc-timestamp-invalidation-mode.patch # Descriptions, and metadata for subpackages # ========================================== -# this if branch is ~300 lines long and contains subpackages' definitions -%if %{without flatpackage} + %if %{with main_python} # Description for the python3X SRPM only: %description @@ -323,17 +406,13 @@ third-party libraries. Summary: Python %{pybasever} interpreter # In order to support multiple Python interpreters for development purposes, -# packages with the naming scheme flatpackage (e.g. python3.5) exist for +# packages with fully versioned naming scheme (e.g. python3.9*) exist for # non-default versions of Python 3. # For consistency, we provide python3.X from python3 as well. Provides: python%{pybasever} = %{version}-%{release} Provides: python%{pybasever}%{?_isa} = %{version}-%{release} -# To keep the upgrade path clean, we Obsolete python3.X. -# Note that using Obsoletes without package version is not standard practice. -# Here we assert that *any* version of the system's default interpreter is -# preferable to an "extra" interpreter. For example, python3-3.6.1 will -# replace python3.6-3.6.2. -Obsoletes: python%{pybasever} + +%unversioned_obsoletes_of_python3_X_if_main # https://fedoraproject.org/wiki/Changes/Move_usr_bin_python_into_separate_package # https://fedoraproject.org/wiki/Changes/Python_means_Python3 @@ -347,15 +426,18 @@ Recommends: %{_bindir}/python # python39). However, to align it with the executable names and to prepare for # Python 3.10, they were renamed to pythonX.Y (e.g. python3.9, python3.10). We # provide and obsolete the previous names. -# - Here are the tags for the nonflat package, regardless if main_python (e.g. -# python3) or not (e.g. python39). For the flat package, the provide is -# repeated many lines later. Provides: python%{pyshortver} = %{version}-%{release} Obsoletes: python%{pyshortver} < %{version}-%{release} +%if %{with main_python} || %{with python_abi_provides_for_alt_pythons} # Packages with Python modules in standard locations automatically # depend on python(abi). Provide that here. Provides: python(abi) = %{pybasever} +%else +# We exclude the `python(abi)` Provides +%global __requires_exclude ^python\\(abi\\) = 3\\..+ +%global __provides_exclude ^python\\(abi\\) = 3\\..+ +%endif Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} @@ -415,13 +497,15 @@ This package contains /usr/bin/python - the "python" command that runs Python 3. Summary: Python runtime libraries %if %{with rpmwheels} -Requires: python-setuptools-wheel -Requires: python-pip-wheel +Requires: %{python_wheel_pkg_prefix}-setuptools-wheel +Requires: %{python_wheel_pkg_prefix}-pip-wheel %else Provides: bundled(python3dist(pip)) = %{pip_version} Provides: bundled(python3dist(setuptools)) = %{setuptools_version} %endif +%unversioned_obsoletes_of_python3_X_if_main 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. @@ -436,6 +520,30 @@ Recommends: (%{pkgname}-tkinter%{?_isa} = %{version}-%{release} if tk%{?_isa}) # The zoneinfo module needs tzdata Requires: tzdata +# The requirement on libexpat is generated, but we need to version it. +# When built with a specific expat version, but installed with an older one, +# we sometimes get: +# ImportError: /usr/lib64/python3.X/lib-dynload/pyexpat.cpython-....so: +# undefined symbol: XML_... +# The pyexpat module has build-time checks for expat version to only use the +# available symbols. However, there is no runtime protection, so when the module +# is later installed with an older expat, it may error due to undefined symbols. +# This breaks many things, including python -m venv. +# We avoid this problem by requiring at least the same version of expat that +# was used during the build time. +# Other subpackages (like -debug) also need this, but they all depend on -libs. +# Since expat 2.7.4, the library has versioned symbols and this is no longer needed, +# as the generated requirement will be in the form of libexpat.so.1(LIBEXPAT_2.7.2) etc. +%global expat_version %(LANG=C rpm -q --qf '%%{version}' expat.%{_target_cpu} | sed 's/.*not installed/0/') +%if v"%{expat_version}" < v"2.7.4" +Requires: expat%{?_isa} >= %{expat_version} +%endif + + +# Since patch 251 changed from distutils to sysconfig, pip needed to be adapted +# The previous versions could cause serious bugs during `sudo pip install --upgrade ...` +# Better safe than sorry +Conflicts: %{pkgname}-pip < 21.2.3-3 %description -n %{pkgname}-libs This package contains runtime libraries for use by Python: @@ -450,18 +558,31 @@ Requires: %{pkgname} = %{version}-%{release} Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} # The RPM related dependencies bring nothing to a non-RPM Python developer # But we want them when packages BuildRequire python3-devel -Requires: (python-rpm-macros if rpm-build) -Requires: (python3-rpm-macros if rpm-build) +# 3.10-9 macros started to set $RPM_BUILD_ROOT when expanding macros like %%python3_sitearch, +# which is necessary since patch 251 changed from distutils to sysconfig +Requires: (python-rpm-macros >= 3.10-9 if rpm-build) +Requires: (python3-rpm-macros >= 3.10-9 if rpm-build) +Requires: (pyproject-rpm-macros if rpm-build) +%unversioned_obsoletes_of_python3_X_if_main devel + +%if %{with main_python} # Python developers are very likely to need pip Recommends: %{pkgname}-pip +%endif + +# tox users are likely to need the devel subpackage +Supplements: tox %if %{without bootstrap} Requires: (python3-rpm-generators if rpm-build) %endif Provides: %{pkgname}-2to3 = %{version}-%{release} + +%if %{with main_python} Provides: 2to3 = %{version}-%{release} +%endif Conflicts: %{pkgname} < %{version}-%{release} @@ -479,8 +600,12 @@ Summary: A basic graphical development environment for Python Requires: %{pkgname} = %{version}-%{release} Requires: %{pkgname}-tkinter = %{version}-%{release} +%unversioned_obsoletes_of_python3_X_if_main idle + +%if %{with main_python} Provides: idle3 = %{version}-%{release} Provides: idle = %{version}-%{release} +%endif Provides: %{pkgname}-tools = %{version}-%{release} Provides: %{pkgname}-tools%{?_isa} = %{version}-%{release} @@ -503,6 +628,12 @@ configuration, browsers, and other dialogs. Summary: A GUI toolkit for Python Requires: %{pkgname} = %{version}-%{release} +%unversioned_obsoletes_of_python3_X_if_main tkinter + +# The importable module "turtle" is here, so provide python3-turtle. +# (We don't provide python3-turtledemo, that's not too useful when imported.) +%py_provides %{pkgname}-turtle + %description -n %{pkgname}-tkinter The Tkinter (Tk interface) library is a graphical user interface toolkit for the Python programming language. @@ -513,6 +644,8 @@ Summary: The self-test suite for the main python3 package Requires: %{pkgname} = %{version}-%{release} Requires: %{pkgname}-libs%{?_isa} = %{version}-%{release} +%unversioned_obsoletes_of_python3_X_if_main test + %description -n %{pkgname}-test The self-test suite for the Python interpreter. @@ -535,6 +668,8 @@ Requires: %{pkgname}-test%{?_isa} = %{version}-%{release} Requires: %{pkgname}-tkinter%{?_isa} = %{version}-%{release} Requires: %{pkgname}-idle%{?_isa} = %{version}-%{release} +%unversioned_obsoletes_of_python3_X_if_main debug + %description -n %{pkgname}-debug python3-debug provides a version of the Python runtime with numerous debugging features enabled, aimed at advanced Python users such as developers of Python @@ -552,43 +687,6 @@ The debug runtime additionally supports debug builds of C-API extensions (with the "d" ABI flag) for debugging issues in those extensions. %endif # with debug_build -%else # with flatpackage - -# We'll not provide this, on purpose -# No package in Fedora shall ever depend on flatpackage via this -%global __requires_exclude ^python\\(abi\\) = 3\\..+ -%global __provides_exclude ^python\\(abi\\) = 3\\..+ - -# Python interpreter packages used to be named (or provide) name pythonXY (e.g. -# python39). However, to align it with the executable names and to prepare for -# Python 3.10, they were renamed to pythonX.Y (e.g. python3.9, python3.10). We -# provide and obsolete the previous names. -# - Here are the tags for the flat package. For the nonflat package, the -# provide is repeated many lines above. -Provides: python%{pyshortver} = %{version}-%{release} -Obsoletes: python%{pyshortver} < %{version}-%{release} - -%if %{with rpmwheels} -Requires: python-setuptools-wheel -Requires: python-pip-wheel -%else -Provides: bundled(python3dist(pip)) = %{pip_version} -Provides: bundled(python3dist(setuptools)) = %{setuptools_version} -%endif - -# The zoneinfo module needs tzdata -Requires: tzdata - -# The description for the flat package (SRPM and built) -%description -Python %{pybasever} package for developers. - -This package exists to allow developers to test their code against a newer -version of Python. This is not a full Python stack and if you wish to run -your applications with Python %{pybasever}, update your Fedora to a newer -version once Python %{pybasever} is stable. - -%endif # with flatpackage # ====================================================== # The prep phase of the build: @@ -610,6 +708,7 @@ find -name '*.exe' -print -delete # Remove bundled libraries to ensure that we're using the system copy. rm -r Modules/expat +rm -r Modules/_decimal/libmpdec # Remove files that should be generated by the build # (This is after patching, so that we can use patches directly from upstream) @@ -656,14 +755,15 @@ topdir=$(pwd) # 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" +# https://fedoraproject.org/wiki/Changes/Python_Extension_Flags_Reduction +export CFLAGS="%{extension_cflags}" export CFLAGS_NODIST="%{build_cflags} -D_GNU_SOURCE -fPIC -fwrapv" -export CXXFLAGS="%{extension_cxxflags} -D_GNU_SOURCE -fPIC -fwrapv" +export CXXFLAGS="%{extension_cxxflags}" export CPPFLAGS="$(pkg-config --cflags-only-I libffi)" -export OPT="%{extension_cflags} -D_GNU_SOURCE -fPIC -fwrapv" +export OPT="%{extension_cflags}" export LINKCC="gcc" export CFLAGS="$CFLAGS $(pkg-config --cflags openssl)" -export LDFLAGS="%{extension_ldflags} -g $(pkg-config --libs-only-L openssl)" +export LDFLAGS="%{extension_ldflags} $(pkg-config --libs-only-L openssl)" export LDFLAGS_NODIST="%{build_ldflags} -g $(pkg-config --libs-only-L openssl)" # We can build several different configurations of Python: regular and debug. @@ -695,13 +795,14 @@ BuildPython() { --with-dbmliborder=gdbm:ndbm:bdb \ --with-system-expat \ --with-system-ffi \ + --with-system-libmpdec \ --enable-loadable-sqlite-extensions \ --with-dtrace \ --with-lto \ --with-ssl-default-suites=openssl \ --without-static-libpython \ %if %{with rpmwheels} - --with-wheel-pkg-dir=%{_datadir}/python-wheels \ + --with-wheel-pkg-dir=%{python_wheel_dir} \ %endif %if %{with valgrind} --with-valgrind \ @@ -926,15 +1027,25 @@ find . -name "*~" -exec rm -f {} \; # Python CMD line options: # -s - don't add user site directory to sys.path # -B - don't write .pyc files on import +# Clamp the source mtime first, see https://fedoraproject.org/wiki/Changes/ReproducibleBuildsClampMtimes +# The clamp_source_mtime module is only guaranteed to exist on Fedoras that enabled this option: +%if 0%{?clamp_mtime_to_source_date_epoch} +LD_LIBRARY_PATH="%{buildroot}%{dynload_dir}/:%{buildroot}%{_libdir}" \ +PYTHONPATH="%{_rpmconfigdir}/redhat" \ +%{buildroot}%{_bindir}/python%{pybasever} -s -B -m clamp_source_mtime %{buildroot}%{pylibdir} +%endif # compileall CMD line options: # -f - force rebuild even if timestamps are up to date # -o - optimization levels to run compilation with # -s - part of path to left-strip from path to source file (buildroot) # -p - path to add as prefix to path to source file (/ to make it absolute) # --hardlink-dupes - hardlink different optimization level pycs together if identical (saves space) +# --invalidation-mode - we prefer the timestamp invalidation mode for performance reasons +# -x - skip test modules with SyntaxErrors (taken from the Makefile) LD_LIBRARY_PATH="%{buildroot}%{dynload_dir}/:%{buildroot}%{_libdir}" \ %{buildroot}%{_bindir}/python%{pybasever} -s -B -m compileall \ --f %{_smp_mflags} -o 0 -o 1 -o 2 -s %{buildroot} -p / %{buildroot} --hardlink-dupes || : +-f %{_smp_mflags} -o 0 -o 1 -o 2 -s %{buildroot} -p / %{buildroot} --hardlink-dupes --invalidation-mode=timestamp \ +-x 'bad_coding|badsyntax|site-packages|lib2to3/tests/data' # Turn this BRP off, it is done by compileall2 --hardlink-dupes above %global __brp_python_hardlink %{nil} @@ -992,6 +1103,11 @@ for file in %{buildroot}%{pylibdir}/pydoc_data/topics.py $(grep --include='*.py' rm ${directory}/{__pycache__/${module}.cpython-%{pyshortver}.opt-?.pyc,${module}.py} done +%if %{without rpmwheels} +# Inject SBOM into the installed wheels (if the macro is available) +%{?python_wheel_inject_sbom:%python_wheel_inject_sbom %{buildroot}%{pylibdir}/ensurepip/_bundled/*.whl} +%endif + # ====================================================== # Checks for packaging issues # ====================================================== @@ -1050,16 +1166,19 @@ CheckPython() { # test_distutils # distutils.tests.test_bdist_rpm tests fail when bootstraping the Python # package: rpmbuild requires /usr/bin/pythonX.Y to be installed - # test_frozentable fails with Python 3.10.0a6 (https://bugs.python.org/issue43372) + # test_sendfile_close_peer_in_the_middle_of_receiving: + # https://github.com/python/cpython/issues/120226 LD_LIBRARY_PATH=$ConfDir $ConfDir/python -m test.regrtest \ -wW --slowest -j0 --timeout=1800 \ - -i test_frozentable \ %if %{with bootstrap} -x test_distutils \ %endif %ifarch %{mips64} -x test_ctypes \ %endif + %ifarch ppc64le + -i test_sendfile_close_peer_in_the_middle_of_receiving \ + %endif echo FINISHED: CHECKING OF PYTHON FOR CONFIGURATION: $ConfName @@ -1092,17 +1211,13 @@ CheckPython optimized %if %{with main_python} -%if %{without flatpackage} %files -n python-unversioned-command -%endif %{_bindir}/python %{_mandir}/*/python.1* %endif -%if %{without flatpackage} %files -n %{pkgname}-libs %doc README.rst -%endif %dir %{pylibdir} %dir %{dynload_dir} @@ -1110,9 +1225,7 @@ CheckPython optimized %license %{pylibdir}/LICENSE.txt %{pylibdir}/lib2to3 -%if %{without flatpackage} %exclude %{pylibdir}/lib2to3/tests -%endif %dir %{pylibdir}/unittest/ %dir %{pylibdir}/unittest/__pycache__/ @@ -1235,6 +1348,12 @@ CheckPython optimized %dir %{pylibdir}/site-packages/ %dir %{pylibdir}/site-packages/__pycache__/ %{pylibdir}/site-packages/README.txt + +%if %{with debug_build} +%exclude %{pylibdir}/_sysconfigdata_%{ABIFLAGS_debug}_linux_%{platform_triplet}.py +%exclude %{pylibdir}/__pycache__/_sysconfigdata_%{ABIFLAGS_debug}_linux_%{platform_triplet}%{bytecode_suffixes} +%endif + %{pylibdir}/*.py %dir %{pylibdir}/__pycache__/ %{pylibdir}/__pycache__/*%{bytecode_suffixes} @@ -1299,10 +1418,8 @@ CheckPython optimized %{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 @@ -1328,15 +1445,10 @@ CheckPython optimized %endif -%if %{without flatpackage} %files -n %{pkgname}-devel -%endif - %{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/* -%if %{without flatpackage} %exclude %{pylibdir}/config-%{LDVERSION_optimized}-%{platform_triplet}/Makefile %exclude %{_includedir}/python%{LDVERSION_optimized}/%{_pyconfig_h} -%endif %{_includedir}/python%{LDVERSION_optimized}/*.h %{_includedir}/python%{LDVERSION_optimized}/internal/ %{_includedir}/python%{LDVERSION_optimized}/cpython/ @@ -1371,10 +1483,7 @@ CheckPython optimized %{_libdir}/pkgconfig/python-%{pybasever}-embed.pc -%if %{without flatpackage} %files -n %{pkgname}-idle -%endif - %if %{with main_python} %{_bindir}/idle* %else @@ -1389,14 +1498,9 @@ CheckPython optimized %{_datadir}/icons/hicolor/*/apps/idle3.* %endif -%if %{without flatpackage} %files -n %{pkgname}-tkinter -%endif - %{pylibdir}/tkinter -%if %{without flatpackage} %exclude %{pylibdir}/tkinter/test -%endif %{dynload_dir}/_tkinter.%{SOABI_optimized}.so %{pylibdir}/turtle.py %{pylibdir}/__pycache__/turtle*%{bytecode_suffixes} @@ -1407,10 +1511,7 @@ CheckPython optimized %{pylibdir}/turtledemo/__pycache__/*%{bytecode_suffixes} -%if %{without flatpackage} %files -n %{pkgname}-test -%endif - %{pylibdir}/ctypes/test %{pylibdir}/distutils/tests %{pylibdir}/sqlite3/test @@ -1418,6 +1519,7 @@ CheckPython optimized %{dynload_dir}/_ctypes_test.%{SOABI_optimized}.so %{dynload_dir}/_testbuffer.%{SOABI_optimized}.so %{dynload_dir}/_testcapi.%{SOABI_optimized}.so +%{dynload_dir}/_testclinic.%{SOABI_optimized}.so %{dynload_dir}/_testimportmultiple.%{SOABI_optimized}.so %{dynload_dir}/_testinternalcapi.%{SOABI_optimized}.so %{dynload_dir}/_testmultiphase.%{SOABI_optimized}.so @@ -1433,10 +1535,7 @@ CheckPython optimized # all of the other subpackages %if %{with debug_build} -%if %{without flatpackage} %files -n %{pkgname}-debug -%endif - %if %{with main_python} %{_bindir}/python3-debug %{_bindir}/python-debug @@ -1548,10 +1647,14 @@ CheckPython optimized %{dynload_dir}/_ctypes_test.%{SOABI_debug}.so %{dynload_dir}/_testbuffer.%{SOABI_debug}.so %{dynload_dir}/_testcapi.%{SOABI_debug}.so +%{dynload_dir}/_testclinic.%{SOABI_debug}.so %{dynload_dir}/_testimportmultiple.%{SOABI_debug}.so %{dynload_dir}/_testinternalcapi.%{SOABI_debug}.so %{dynload_dir}/_testmultiphase.%{SOABI_debug}.so +%{pylibdir}/_sysconfigdata_%{ABIFLAGS_debug}_linux_%{platform_triplet}.py +%{pylibdir}/__pycache__/_sysconfigdata_%{ABIFLAGS_debug}_linux_%{platform_triplet}%{bytecode_suffixes} + %endif # with debug_build # We put the debug-gdb.py file inside /usr/lib/debug to avoid noise from ldconfig @@ -1575,6 +1678,256 @@ CheckPython optimized # ====================================================== %changelog +* Thu Aug 13 2026 Karolina Surma - 3.10.21-1 +- Update to Python 3.10.21 + +* Thu Jul 30 2026 Miro Hrončok - 3.10.20-4 + - Skip UDP Lite tests if it's not supported + - Fixes FTBFS on Linux kernel 7.1 and newer + +* Thu Jul 16 2026 Fedora Release Engineering - 3.10.20-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_45_Mass_Rebuild + +* Sat Apr 11 2026 Miro Hrončok - 3.10.20-2 +- Explicitly build with OpenSSL 3 +- Fix ssl.SSLError: [ASN1: NOT_ENOUGH_DATA] not enough data with OpenSSL 3.5.7+ + +* Tue Mar 03 2026 Tomáš Hrnčiar - 3.10.20-1 +- Update to 3.10.20 + +* Mon Feb 09 2026 Tomáš Hrnčiar - 3.10.19-4 +- Security fixes for CVE-2026-0865, CVE-2025-15366 and CVE-2025-15367 + +* Sat Jan 17 2026 Fedora Release Engineering - 3.10.19-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_44_Mass_Rebuild + +* Tue Jan 06 2026 Karolina Surma - 3.10.19-2 +- Require at least the same expat version as used during the build time + +* Fri Oct 10 2025 Karolina Surma - 3.10.19-1 +- Update to Python 3.10.19 + +* Fri Jul 25 2025 Fedora Release Engineering - 3.10.18-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild + +* Wed Jun 04 2025 Tomáš Hrnčiar - 3.10.18-1 +- Update to 3.10.18 + +* Tue May 13 2025 Charalampos Stratakis - 3.10.17-3 +- Fix PySSL_SetError handling SSL_ERROR_SYSCALL +- This fixes random flakiness of test_ssl on stressed machines + +* Wed Apr 16 2025 Charalampos Stratakis - 3.10.17-2 +- test_ssl: Don't stop ThreadedEchoServer on OSError in ConnectionHandler +- Fixes: rhbz#2355052 + +* Wed Apr 09 2025 Miro Hrončok - 3.10.17-1 +- Update to 3.10.17 + +* Mon Mar 31 2025 Charalampos Stratakis - 3.10.16-6 +- Properly apply exported CFLAGS for dtrace/systemtap builds +- Fixes: rhbz#2356303 + +* Mon Feb 10 2025 Charalampos Stratakis - 3.10.16-5 +- Security fix for CVE-2025-0938 +- Fixes: rhbz#2343276 + +* Thu Feb 06 2025 Miro Hrončok - 3.10.16-4 +- Rebuilt with mpdecimal 4.0.0 + +* Sat Feb 01 2025 Björn Esser - 3.10.16-3 +- Add explicit BR: libxcrypt-devel + +* Sat Jan 18 2025 Fedora Release Engineering - 3.10.16-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild + +* Wed Dec 04 2024 Charalampos Stratakis - 3.10.16-1 +- Update to 3.10.16 +- Security fix for CVE-2024-9287 +Resolves: rhbz#2321654 + +* Wed Sep 11 2024 Miro Hrončok - 3.10.15-2 +- Fix ThreadedVSOCKSocketStreamTest + +* Mon Sep 09 2024 Tomáš Hrnčiar - 3.10.15-1 +- Update to 3.10.15 + +* Tue Jul 23 2024 Lumír Balhar - 3.10.14-4 +- Require systemtap-sdt-devel for sys/sdt.h + +* Fri Jul 19 2024 Fedora Release Engineering - 3.10.14-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild + +* Wed Apr 17 2024 Miro Hrončok - 3.10.14-2 +- Require expat >= 2.6 to prevent errors when creating venvs with older expat + +* Wed Mar 20 2024 Tomáš Hrnčiar - 3.10.14-1 +- Update to 3.10.14 + +* Wed Feb 28 2024 Charalampos Stratakis - 3.10.13-6 +- Fix tests for XMLPullParser with Expat 2.6.0 + +* Mon Jan 29 2024 Karolina Surma - 3.10.13-5 +- Fix test_zlib when building with zlib-ng-compat + +* Fri Jan 26 2024 Fedora Release Engineering - 3.10.13-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Mon Jan 22 2024 Fedora Release Engineering - 3.10.13-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild + +* Mon Dec 18 2023 Lumír Balhar - 3.10.13-2 +- Security fix for CVE-2023-27043 (rhbz#2196187) + +* Mon Aug 28 2023 Tomáš Hrnčiar - 3.10.13-1 +- Update to 3.10.13 + +* Wed Aug 02 2023 Charalampos Stratakis - 3.10.12-3 +- Remove extra distro-applied CFLAGS passed to user built C extensions +- https://fedoraproject.org/wiki/Changes/Python_Extension_Flags_Reduction + +* Fri Jul 21 2023 Fedora Release Engineering - 3.10.12-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild + +* Thu Jun 08 2023 Tomáš Hrnčiar - 3.10.12-1 +- Update to 3.10.12 + +* Mon May 29 2023 Charalampos Stratakis - 3.10.11-2 +- Fix for CVE-2023-24329 +Resolves: rhbz#2174010 + +* Wed Apr 05 2023 Tomáš Hrnčiar - 3.10.11-1 +- Update to 3.10.11 + +* Wed Feb 08 2023 Tomáš Hrnčiar - 3.10.10-1 +- Update to 3.10.10 + +* Fri Jan 20 2023 Fedora Release Engineering - 3.10.9-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild + +* Wed Dec 21 2022 Miro Hrončok - 3.10.9-3 +- No longer patch the default bytecode cache invalidation policy + +* Tue Dec 20 2022 Miro Hrončok - 3.10.9-2 +- Supplement tox from the devel package + +* Wed Dec 07 2022 Tomáš Hrnčiar - 3.10.9-1 +- Update to 3.10.9 + +* Mon Nov 14 2022 Miro Hrončok - 3.10.8-3 +- Make IDLE work without python3-test installed +- Fixes rhbz#2142602 + +* Wed Nov 09 2022 Lumír Balhar - 3.10.8-2 +- Fix CVE-2022-42919 +Resolves: rhbz#2138709 + +* Wed Oct 12 2022 Miro Hrončok - 3.10.8-1 +- Update to 3.10.8 + +* Wed Sep 07 2022 Miro Hrončok - 3.10.7-1 +- Update to 3.10.7 +- Contains security fix for CVE-2020-10735 + +* Mon Aug 22 2022 Miro Hrončok - 3.10.6-2 +- Don't use custom installation schemes +- Fixes rhbz#2026979 +- Fixes rhbz#2097183 + +* Tue Aug 02 2022 Tomáš Hrnčiar - 3.10.6-1 +- Update to 3.10.6 + +* Fri Jul 22 2022 Fedora Release Engineering - 3.10.5-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild + +* Mon Jun 13 2022 Tomáš Hrnčiar - 3.10.5-3 +- Rebuilt for Python 3.11 + +* Thu Jun 09 2022 Charalampos Stratakis - 3.10.5-2 +- Security fix for CVE-2015-20107 +Resolves: rhbz#2075390 + +* Tue Jun 07 2022 Tomáš Hrnčiar - 3.10.5-1 +- Update to 3.10.5 + +* Sat May 14 2022 Tomas Orsava - 3.10.4-2 +- Move _sysconfigdata_d_linux*.py to the debug subpackage + +* Fri Mar 25 2022 Tomáš Hrnčiar - 3.10.4-1 +- Update to 3.10.4 + +* Fri Mar 18 2022 Tomáš Hrnčiar - 3.10.3-1 +- Update to 3.10.3 + +* Tue Feb 01 2022 Tomáš Hrnčiar - 3.10.2-3 +- Backport AC_C_CHAR_UNSIGNED/__CHAR_UNSIGNED__ removal +- Fixes: rhbz#2043555 + +* Fri Jan 21 2022 Fedora Release Engineering - 3.10.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild + +* Mon Jan 17 2022 Tomáš Hrnčiar - 3.10.2-1 +- Update to 3.10.2 + +* Mon Jan 10 2022 Miro Hrončok - 3.10.1-3 +- Backport fixes for two Python 3.10.1 regressions +- Fixes: rhbz#2030621 +- Fixes: rhbz#2034962 + +* Sat Jan 08 2022 Miro Hrončok - 3.10.1-2 +- Rebuilt for https://fedoraproject.org/wiki/Changes/LIBFFI34 + +* Tue Dec 07 2021 Tomáš Hrnčiar - 3.10.1-1 +- Update to 3.10.1 + +* Fri Nov 12 2021 Björn Esser - 3.10.0-4 +- Rebuild(libnsl2) + +* Tue Nov 09 2021 Lumír Balhar - 3.10.0-3 +- Update patch 251 to include specific install scheme for virtualenv + +* Tue Oct 05 2021 Miro Hrončok - 3.10.0-2 +- Change the values of sysconfig's "posix_prefix" install scheme to /usr/local + when RPM build or venv/virtualenv is not detected, + instead of patching distutils + +* Mon Oct 04 2021 Miro Hrončok - 3.10.0-1 +- Update to 3.10.0 final + +* Tue Sep 14 2021 Sahana Prasad - 3.10.0~rc2-2 +- Rebuilt with OpenSSL 3.0.0 + +* Wed Sep 08 2021 Tomas Hrnciar - 3.10.0~rc2-1 +- Update to 3.10.0rc2 + +* Tue Aug 03 2021 Tomas Hrnciar - 3.10.0~rc1-1 +- Update to 3.10.0rc1 + +* Fri Jul 23 2021 Fedora Release Engineering - 3.10.0~b4-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild + +* Fri Jul 16 2021 Petr Viktorin - 3.10.0~b4-2 +- Provide python3-turtle from python3-tkinter +- Require pyproject-rpm-macros from python3-devel + +* Sun Jul 11 2021 Miro Hrončok - 3.10.0~b4-1 +- Update to 3.10.0b4 + +* Thu Jun 17 2021 Miro Hrončok - 3.10.0~b3-1 +- Update to 3.10.0b3 + +* Tue Jun 01 2021 Python Maint - 3.10.0~b2-3 +- Rebuilt for Python 3.10 + +* Tue Jun 01 2021 Python Maint - 3.10.0~b2-2 +- Bootstrap for Python 3.10 + +* Tue Jun 01 2021 Tomas Hrnciar - 3.10.0~b2-1 +- Update to 3.10.0b2 + +* Fri May 14 2021 Charalampos Stratakis - 3.10.0~b1-2 +- Use the system installed mpdecimal instead of the bundled copy (#1943359) + * Tue May 04 2021 Tomas Hrnciar - 3.10.0~b1-1 - Update to 3.10.0b1 diff --git a/rpminspect.yaml b/rpminspect.yaml index 213d92c..8cc18cb 100644 --- a/rpminspect.yaml +++ b/rpminspect.yaml @@ -1,13 +1,22 @@ # exclude test XML data (not always valid) from XML validity check: xml: ignore: - - /usr/lib*/python*/test/xmltestdata/* - - /usr/lib*/python*/test/xmltestdata/*/* + - '/usr/lib*/python*/test/xmltestdata/*' + - '/usr/lib*/python*/test/xmltestdata/*/*' # exclude _socket from ipv4 only functions check, it has both ipv4 and ipv6 only badfuncs: + allowed: + '/usr/lib*/python*/lib-dynload/_socket.*': + - inet_aton + - inet_ntoa + +# exclude the debug build from annocheck entirely +annocheck: ignore: - - /usr/lib*/python*/lib-dynload/_socket.* + - '/usr/bin/python*d' + - '/usr/lib*/libpython*d.so.1.0' + - '/usr/lib*/python*/lib-dynload/*.cpython-*d-*-*-*.so' # don't report changed content of compiled files # that is expected with every toolchain update and not reproducible yet diff --git a/rpmlint.toml b/rpmlint.toml new file mode 100644 index 0000000..b532441 --- /dev/null +++ b/rpmlint.toml @@ -0,0 +1,106 @@ +Filters = [ + + # KNOWN BUGS: + # https://bugzilla.redhat.com/show_bug.cgi?id=1489816 + 'crypto-policy-non-compliance-openssl', + + + # TESTS: + '(zero-length|pem-certificate|uncompressed-zip) /usr/lib(64)?/python3\.\d+/test', + + + # OTHER DELIBERATES: + # chroot function + 'missing-call-to-chdir-with-chroot', + + # gethostbyname function calls gethostbyname + '(E|W): binary-or-shlib-calls-gethostbyname /usr/lib(64)?/python3\.\d+/lib-dynload/_socket\.', + + # intentionally unversioned and selfobsoleted + 'unversioned-explicit-obsoletes python', + 'unversioned Obsoletes: Obsoletes: python3\.\d+$', + 'self-obsoletion python3\.\d+(-\S+)? obsoletes python3\.\d+(-\S+)?', + + # intentionally hardcoded + 'hardcoded-library-path in %{_prefix}/lib/(debug/%{_libdir}|python%{pybasever})', + + # we have non binary stuff, python files + 'only-non-binary-in-usr-lib', + + # some devel files that are deliberately needed + 'devel-file-in-non-devel-package /usr/include/python3\.\d+m?/pyconfig-(32|64)\.h', + 'devel-file-in-non-devel-package /usr/lib(64)?/python3\.\d+/distutils/tests/xxmodule\.c', + # ...or are used as test data + 'devel-file-in-non-devel-package /usr/lib(64)?/python3\.\d+/test', + + # some bytecode is shipped without sources on purpose, as a space optimization + # if this regex needs to be relaxed in the future, make sure it **does not** match pyc files in __pycache__ + 'python-bytecode-without-source /usr/lib(64)?/python3\.\d+/(encodings|pydoc_data)/[^/]+.pyc', + + # DUPLICATE FILES + # test data are often duplicated + '(E|W): files-duplicate /usr/lib(64)?/python3\.\d+/(test|__phello__)/', + # duplicated inits or mains are also common + '(E|W): files-duplicate .+__init__\.py.+__init__\.py', + '(E|W): files-duplicate .+__main__\.py.+__main__\.py', + # files in the debugsource package + '(E|W): files-duplicate /usr/src/debug', + # general waste report + '(E|W): files-duplicated-waste', + + # SORRY, NOT SORRY: + # manual pages + 'no-manual-page-for-binary (idle|pydoc|pyvenv|2to3|python3?-debug|pathfix|msgfmt|pygettext)', + 'no-manual-page-for-binary python3?.*-config$', + 'no-manual-page-for-binary python3\.\d+dm?$', + + # missing documentation from subpackages + '^python3(\.\d+)?-(debug|tkinter|test|idle)\.[^:]+: (E|W): no-documentation', + + # platform python is obsoleted, but not provided + 'obsolete-not-provided platform-python', + + # we have extra tokens at the end of %endif/%else directives, we consider them useful + 'extra tokens at the end of %(endif|else) directive', + + + # RPMLINT IMPERFECTIONS + # https://github.com/rpm-software-management/rpmlint/issues/780 + '/usr/lib/debug', + + # we provide python(abi) manually to be sure. createrepo will merge this with the automatic + 'python3(\.\d+)?\.[^:-]+: (E|W): useless-provides python\(abi\)', + + # debugsource and debuginfo have no docs + '^python3(\.\d+)?-debug(source|info)\.[^:]+: (E|W): no-documentation', + + # this is OK for F28+ + 'library-without-ldconfig-post', + + # debug package contains devel and non-devel files + 'python3(\.\d+)?-debug\.[^:]+: (E|W): (non-)?devel-file-in-(non-)?devel-package', + + # this goes to other subpackage, hence not actually dangling + 'dangling-relative-symlink /usr/bin/python python3', + 'dangling-relative-symlink /usr/share/man/man1/python\.1\.gz python3\.1\.gz', + 'dangling-relative-symlink /usr/lib(64)?/pkgconfig/python-3\.\d+dm?(-embed)?\.pc python-3\.\d+(-embed)?\.pc', + + # the python-unversioned-command package contains dangling symlinks by design + '^python-unversioned-command\.[^:]+: (E|W): dangling-relative-symlink (/usr/bin/python \./python3|/usr/share/man/man1/python\.1\S* ./python3\.1\S*)$', + + # we need this macro to evaluate, even if the line starts with # + 'macro-in-comment %\{_pyconfig(32|64)_h\}', + + # Python modules don't need to be linked against libc + # Since 3.8 they are no longer linked against libpython3.8.so.1.0 + '(E|W): library-not-linked-against-libc /usr/lib(64)?/python3\.\d+/lib-dynload/', + '(E|W): shared-lib(rary)?-without-dependency-information /usr/lib(64)?/python3\.\d+/lib-dynload/', + + # specfile-errors are listed twice, once with reason and once without + # we filter out the empty ones + '\bpython3(\.\d+)?\.(src|spec): (E|W): specfile-error\s+$', + + # SPELLING ERRORS + 'spelling-error .* en_US (bytecode|pyc|filename|tkinter|namespaces|pytest) ', + +] diff --git a/sources b/sources index 89085d0..1833fd0 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ -SHA512 (Python-3.10.0b1.tar.xz) = b8366f1fd92690bf78dc8ce07724d1b79a8c7f246e9a13ba3043687c5553b52d4d7baf48bf96f9fe088de73baef1df2131e2704ffed9a7549890723a7898c4c5 -SHA512 (Python-3.10.0b1.tar.xz.asc) = 7e22dd9ddf37d0c2116cfb9f08050f0909ccc04f1a63e67b96f0cec743845c492659a661af518fd76d513fa36d08da11fe3a1166ede31de583369b4c3389de57 +SHA512 (Python-3.10.21.tar.xz) = 6f6de7c5e4c0457f2d189ed5d111c83fb8775e19123afe4f9fd0ae2b93f3fa2bbb7ad849ade6bb5227d4a6a3d63abc8e167fbe5fb54fa715660c89fd6274daee +SHA512 (Python-3.10.21.tar.xz.asc) = 72d6aeaa0f51e527f82392cf1f969b0ad50a48fe10e8b7e5feb6117718223d00757f7b375b3ac82e257571d5a61f8162e9dd59b81fcf8f2a441c6deb42be71cb diff --git a/tests/provision.fmf b/tests/provision.fmf deleted file mode 100644 index 1a4f0f0..0000000 --- a/tests/provision.fmf +++ /dev/null @@ -1,4 +0,0 @@ ---- -standard-inventory-qcow2: - qemu: - m: 3G # Amount of VM memory diff --git a/tests/tests.yml b/tests/tests.yml deleted file mode 100644 index 1af5868..0000000 --- a/tests/tests.yml +++ /dev/null @@ -1,33 +0,0 @@ ---- -- hosts: localhost - tags: - - classic - tasks: - - dnf: - name: "*" - state: latest - -- hosts: localhost - roles: - - role: standard-test-basic - tags: - - classic - repositories: - - repo: "https://src.fedoraproject.org/tests/python.git" - dest: "python" - tests: - - smoke: - dir: python/smoke - run: VERSION=3.10 ./venv.sh - - selftest: - dir: python/selftest - run: VERSION=3.10 X="" ./parallel.sh - - marshalparser: - dir: python/marshalparser - run: INSTALL_OR_SKIP=true VERSION=3.10 SAMPLE=10 test_marshalparser_compatibility.sh - required_packages: - - gcc # for extension building in venv and selftest - - gdb # for test_gdb - - python3.10 - - python3-tox # for venv tests - - glibc-all-langpacks # for locale tests