Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-certbot for openSUSE:Factory checked in at 2022-05-30 12:44:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-certbot (Old) and /work/SRC/openSUSE:Factory/.python-certbot.new.2254 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "python-certbot" Mon May 30 12:44:29 2022 rev:41 rq:979812 version:1.27.0 Changes: -------- --- /work/SRC/openSUSE:Factory/python-certbot/python-certbot.changes 2022-04-08 22:46:17.354759217 +0200 +++ /work/SRC/openSUSE:Factory/.python-certbot.new.2254/python-certbot.changes 2022-05-30 12:45:29.520513633 +0200 @@ -1,0 +2,10 @@ +Mon May 30 09:13:58 UTC 2022 - Mark��ta Machov�� <mmachova@suse.com> + +- Update to version 1.27.0 + * The PGP key F2871B4152AE13C49519111F447BF683AA3B26C3 was added + as an additional trusted key to sign our PyPI packages + * When certonly is run with an installer specified (e.g. --nginx), + certonly will now also run restart for that installer +- Refreshed python-certbot.keyring + +------------------------------------------------------------------- Old: ---- certbot-1.26.0.tar.gz certbot-1.26.0.tar.gz.asc New: ---- certbot-1.27.0.tar.gz certbot-1.27.0.tar.gz.asc ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-certbot.spec ++++++ --- /var/tmp/diff_new_pack.l7kspA/_old 2022-05-30 12:45:30.236514586 +0200 +++ /var/tmp/diff_new_pack.l7kspA/_new 2022-05-30 12:45:30.240514591 +0200 @@ -19,7 +19,7 @@ %{?!python_module:%define python_module() python-%{**} python3-%{**}} %define skip_python2 1 Name: python-certbot -Version: 1.26.0 +Version: 1.27.0 Release: 0 Summary: ACME client License: Apache-2.0 ++++++ certbot-1.26.0.tar.gz -> certbot-1.27.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/CHANGELOG.md new/certbot-1.27.0/CHANGELOG.md --- old/certbot-1.26.0/CHANGELOG.md 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/CHANGELOG.md 2022-05-03 20:33:11.000000000 +0200 @@ -2,6 +2,25 @@ Certbot adheres to [Semantic Versioning](https://semver.org/). +## 1.27.0 - 2022-05-03 + +### Added + +* Added support for RFC8555 subproblems to our acme library. + +### Changed + +* The PGP key `F2871B4152AE13C49519111F447BF683AA3B26C3` was added as an + additional trusted key to sign our PyPI packages +* When `certonly` is run with an installer specified (e.g. `--nginx`), + `certonly` will now also run `restart` for that installer + +### Fixed + +* + +More details about these changes can be found on our GitHub repo. + ## 1.26.0 - 2022-04-05 ### Added @@ -20,7 +39,7 @@ ### Fixed * Certbot for Windows has been upgraded to use Python 3.9.11, in response to - https://www.openssl.org/news/secadv/20220315.txt. + https://www.openssl.org/news/secadv/20220315.txt. * Previously, when Certbot was in the process of registering a new ACME account and the ACME server did not present any Terms of Service, the user was asked to agree with a non-existent Terms of Service ("None"). This bug is now fixed, so diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/PKG-INFO new/certbot-1.27.0/PKG-INFO --- old/certbot-1.26.0/PKG-INFO 2022-04-05 19:41:28.292491700 +0200 +++ new/certbot-1.27.0/PKG-INFO 2022-05-03 20:33:13.174623300 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: certbot -Version: 1.26.0 +Version: 1.27.0 Summary: ACME client Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot/__init__.py new/certbot-1.27.0/certbot/__init__.py --- old/certbot-1.26.0/certbot/__init__.py 2022-04-05 19:41:27.000000000 +0200 +++ new/certbot-1.27.0/certbot/__init__.py 2022-05-03 20:33:11.000000000 +0200 @@ -1,3 +1,3 @@ """Certbot client.""" # version number like 1.2.3a0, must have at least 2 parts, like 1.2 -__version__ = '1.26.0' +__version__ = '1.27.0' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot/_internal/cli/__init__.py new/certbot-1.27.0/certbot/_internal/cli/__init__.py --- old/certbot-1.26.0/certbot/_internal/cli/__init__.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/certbot/_internal/cli/__init__.py 2022-05-03 20:33:10.000000000 +0200 @@ -409,7 +409,7 @@ ' the new certificates and keys; the shell variable' ' $RENEWED_DOMAINS will contain a space-delimited list of' ' renewed certificate domains (for example, "example.com' - ' www.example.com"') + ' www.example.com")') helpful.add( "renew", "--disable-hook-validation", action="store_false", dest="validate_hooks", diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot/_internal/constants.py new/certbot-1.27.0/certbot/_internal/constants.py --- old/certbot-1.26.0/certbot/_internal/constants.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/certbot/_internal/constants.py 2022-05-03 20:33:10.000000000 +0200 @@ -151,13 +151,9 @@ """Default logging level to use when not in quiet mode.""" RENEWER_DEFAULTS = { - "renewer_enabled": "yes", "renew_before_expiry": "30 days", - # This value should ensure that there is never a deployment delay by - # default. - "deploy_before_expiry": "99 years", } -"""Defaults for renewer script.""" +"""Defaults for `certbot renew`.""" ARCHIVE_DIR = "archive" """Archive directory, relative to `certbot.configuration.NamespaceConfig.config_dir`.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot/_internal/main.py new/certbot-1.27.0/certbot/_internal/main.py --- old/certbot-1.26.0/certbot/_internal/main.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/certbot/_internal/main.py 2022-05-03 20:33:10.000000000 +0200 @@ -536,12 +536,21 @@ # If the installation or enhancement raised an error, show advice on trying again if installer_err: - steps.append( - "The certificate was saved, but could not be installed (installer: " - f"{config.installer}). After fixing the error shown below, try installing it again " - f"by running:\n {cli.cli_command} install --cert-name " - f"{_cert_name_from_config_or_lineage(config, lineage)}" - ) + # Special case where either --nginx or --apache were used, causing us to + # run the "installer" (i.e. reloading the nginx/apache config) + if config.verb == 'certonly': + steps.append( + "The certificate was saved, but was not successfully loaded by the installer " + f"({config.installer}) due to the installer failing to reload. " + f"After fixing the error shown below, try reloading {config.installer} manually." + ) + else: + steps.append( + "The certificate was saved, but could not be installed (installer: " + f"{config.installer}). After fixing the error shown below, try installing it again " + f"by running:\n {cli.cli_command} install --cert-name " + f"{_cert_name_from_config_or_lineage(config, lineage)}" + ) # If a certificate was obtained or renewed, show applicable renewal advice if new_or_renewed_cert: @@ -1581,12 +1590,24 @@ lineage = _get_and_save_cert(le_client, config, domains, certname, lineage) + # If a new cert was issued and we were passed an installer, we can safely + # run `installer.restart()` to load the newly issued certificate + installer_err: Optional[errors.Error] = None + if lineage and installer and not config.dry_run: + logger.info("Reloading %s server after certificate issuance", config.installer) + try: + installer.restart() + except errors.Error as e: + installer_err = e + cert_path = lineage.cert_path if lineage else None fullchain_path = lineage.fullchain_path if lineage else None key_path = lineage.key_path if lineage else None _report_new_cert(config, cert_path, fullchain_path, key_path) - _report_next_steps(config, None, lineage, + _report_next_steps(config, installer_err, lineage, new_or_renewed_cert=should_get_cert and not config.dry_run) + if installer_err: + raise installer_err _suggest_donation_if_appropriate(config) eff.handle_subscription(config, le_client.account) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot/_internal/plugins/selection.py new/certbot-1.27.0/certbot/_internal/plugins/selection.py --- old/certbot-1.26.0/certbot/_internal/plugins/selection.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/certbot/_internal/plugins/selection.py 2022-05-03 20:33:10.000000000 +0200 @@ -249,7 +249,6 @@ installer = pick_installer(config, req_inst, plugins, installer_question) if need_auth: authenticator = pick_authenticator(config, req_auth, plugins) - logger.debug("Selected authenticator %s and installer %s", authenticator, installer) # Report on any failures if need_inst and not installer: @@ -257,6 +256,20 @@ if need_auth and not authenticator: diagnose_configurator_problem("authenticator", req_auth, plugins) + # As a special case for certonly, if a user selected apache or nginx, set + # the relevant installer (unless the user specifically specified no + # installer or only specified an authenticator on the command line) + if verb == "certonly" and authenticator is not None: + # user specified --nginx or --apache on CLI + selected_configurator = config.nginx or config.apache + # user didn't request an authenticator, and so interactively chose nginx + # or apache + interactively_selected = req_auth is None and authenticator.name in ("nginx", "apache") + + if selected_configurator or interactively_selected: + installer = cast(Optional[interfaces.Installer], authenticator) + logger.debug("Selected authenticator %s and installer %s", authenticator, installer) + record_chosen_plugins(config, plugins, authenticator, installer) return installer, authenticator diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot.egg-info/PKG-INFO new/certbot-1.27.0/certbot.egg-info/PKG-INFO --- old/certbot-1.26.0/certbot.egg-info/PKG-INFO 2022-04-05 19:41:28.000000000 +0200 +++ new/certbot-1.27.0/certbot.egg-info/PKG-INFO 2022-05-03 20:33:12.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: certbot -Version: 1.26.0 +Version: 1.27.0 Summary: ACME client Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/certbot.egg-info/requires.txt new/certbot-1.27.0/certbot.egg-info/requires.txt --- old/certbot-1.26.0/certbot.egg-info/requires.txt 2022-04-05 19:41:28.000000000 +0200 +++ new/certbot-1.27.0/certbot.egg-info/requires.txt 2022-05-03 20:33:13.000000000 +0200 @@ -1,4 +1,4 @@ -acme>=1.26.0 +acme>=1.27.0 ConfigArgParse>=0.9.3 configobj>=5.0.6 cryptography>=2.5.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/docs/cli-help.txt new/certbot-1.27.0/docs/cli-help.txt --- old/certbot-1.26.0/docs/cli-help.txt 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/docs/cli-help.txt 2022-05-03 20:33:10.000000000 +0200 @@ -35,7 +35,7 @@ --agree-tos Agree to the ACME server's Subscriber Agreement -m EMAIL Email address for important account notifications -optional arguments: +options: -h, --help show this help message and exit -c CONFIG_FILE, --config CONFIG_FILE path to config file (default: /etc/letsencrypt/cli.ini @@ -126,7 +126,7 @@ case, and to know when to deprecate support for past Python versions and flags. If you wish to hide this information from the Let's Encrypt server, set this to - "". (default: CertbotACMEClient/1.25.0 (certbot; + "". (default: CertbotACMEClient/1.26.0 (certbot; OS_NAME OS_VERSION) Authenticator/XXX Installer/YYY (SUBCOMMAND; flags: FLAGS) Py/major.minor.patchlevel). The flags encoded in the user agent are: --duplicate, @@ -168,6 +168,11 @@ default behavior of Certbot. This option may be used to unset --reuse-key on an existing certificate. (default: False) + --new-key When renewing or replacing a certificate, generate a + new private key, even if --reuse-key is set on the + existing certificate. Combining --new-key and --reuse- + key will result in the private key being replaced and + then reused in future renewals. (default: False) --allow-subset-of-names When performing domain validation, do not consider it a failure if authorizations can not be obtained for a @@ -638,7 +643,7 @@ --dns-ovh-propagation-seconds DNS_OVH_PROPAGATION_SECONDS The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS - record. (default: 30) + record. (default: 120) --dns-ovh-credentials DNS_OVH_CREDENTIALS OVH credentials INI file. (default: None) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/docs/contributing.rst new/certbot-1.27.0/docs/contributing.rst --- old/certbot-1.26.0/docs/contributing.rst 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/docs/contributing.rst 2022-05-03 20:33:10.000000000 +0200 @@ -75,7 +75,7 @@ source venv/bin/activate -After running this command, ``certbot`` and development tools like ``ipdb``, +After running this command, ``certbot`` and development tools like ``ipdb3``, ``ipython``, ``pytest``, and ``tox`` are available in the shell where you ran the command. These tools are installed in the virtual environment and are kept separate from your global Python installation. This works by setting diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/docs/packaging.rst new/certbot-1.27.0/docs/packaging.rst --- old/certbot-1.26.0/docs/packaging.rst 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/docs/packaging.rst 2022-05-03 20:33:10.000000000 +0200 @@ -33,12 +33,13 @@ .. _`Semantic Versioning`: https://semver.org/ -Since version 1.21.0, our packages are cryptographically signed by one of three +Since version 1.21.0, our packages are cryptographically signed by one of four PGP keys: - ``BF6BCFC89E90747B9A680FD7B6029E8500F7DB16`` - ``86379B4F0AF371B50CD9E5FF3402831161D1D280`` - ``20F201346BF8F3F455A73F9A780CC99432A28621`` +- ``F2871B4152AE13C49519111F447BF683AA3B26C3``` These keys can be found on major key servers and at https://dl.eff.org/certbot.pub. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/tests/main_test.py new/certbot-1.27.0/tests/main_test.py --- old/certbot-1.26.0/tests/main_test.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/tests/main_test.py 2022-05-03 20:33:10.000000000 +0200 @@ -314,6 +314,36 @@ mock.ANY, mock.ANY, mock.ANY, new_or_renewed_cert=False) mock_report_next_steps.reset_mock() + @mock.patch('certbot._internal.main._report_next_steps') + @mock.patch('certbot._internal.main._report_new_cert') + @mock.patch('certbot._internal.main._find_cert') + @mock.patch('certbot._internal.main._get_and_save_cert') + @mock.patch('certbot._internal.plugins.selection.choose_configurator_plugins') + def test_installer_runs_restart(self, mock_sel, mock_get_cert, mock_find_cert, + unused_report_new, unused_report_next): + mock_installer = mock.MagicMock() + mock_sel.return_value = (mock_installer, None) + mock_get_cert.return_value = mock.MagicMock() + mock_find_cert.return_value = (True, None) + + self._call('certonly --nginx -d example.com'.split()) + mock_installer.restart.assert_called_once() + + @mock.patch('certbot._internal.main._report_next_steps') + @mock.patch('certbot._internal.main._report_new_cert') + @mock.patch('certbot._internal.main._find_cert') + @mock.patch('certbot._internal.main._get_and_save_cert') + @mock.patch('certbot._internal.plugins.selection.choose_configurator_plugins') + def test_dryrun_installer_doesnt_restart(self, mock_sel, mock_get_cert, mock_find_cert, + unused_report_new, unused_report_next): + mock_installer = mock.MagicMock() + mock_sel.return_value = (mock_installer, None) + mock_get_cert.return_value = mock.MagicMock() + mock_find_cert.return_value = (True, None) + + self._call('certonly --nginx -d example.com --dry-run'.split()) + mock_installer.restart.assert_not_called() + class FindDomainsOrCertnameTest(unittest.TestCase): """Tests for certbot._internal.main._find_domains_or_certname.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/tests/plugins/selection_test.py new/certbot-1.27.0/tests/plugins/selection_test.py --- old/certbot-1.26.0/tests/plugins/selection_test.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/tests/plugins/selection_test.py 2022-05-03 20:33:10.000000000 +0200 @@ -199,5 +199,71 @@ self.assertRaises(errors.PluginSelectionError, self._call) +class TestChooseConfiguratorPlugins(unittest.TestCase): + """Tests for certbot._internal.plugins.selection.choose_configurator_plugins.""" + + def _setupMockPlugin(self, name): + mock_ep = mock.Mock( + description_with_name=name) + mock_ep.check_name = lambda n: n == name + mock_plugin = mock.MagicMock() + mock_plugin.name = name + mock_ep.init.return_value = mock_plugin + mock_ep.misconfigured = False + return mock_ep + + def _parseArgs(self, args): + from certbot import configuration + from certbot._internal import cli + return configuration.NamespaceConfig( + cli.prepare_and_parse_args(self.plugins, args.split())) + + def setUp(self): + self.plugins = PluginsRegistry({ + "nginx": self._setupMockPlugin("nginx"), + "apache": self._setupMockPlugin("apache"), + "manual": self._setupMockPlugin("manual"), + }) + + def _runWithArgs(self, args): + from certbot._internal.plugins.selection import choose_configurator_plugins + return choose_configurator_plugins(self._parseArgs(args), self.plugins, "certonly") + + def test_noninteractive_configurator(self): + # For certonly, setting either the nginx or apache configurators should + # return both an installer and authenticator + inst, auth = self._runWithArgs("certonly --nginx") + self.assertEqual(inst.name, "nginx") + self.assertEqual(auth.name, "nginx") + + inst, auth = self._runWithArgs("certonly --apache") + self.assertEqual(inst.name, "apache") + self.assertEqual(auth.name, "apache") + + def test_noninteractive_inst_arg(self): + # For certonly, if an installer arg is set, it should be returned as expected + inst, auth = self._runWithArgs("certonly -a nginx -i nginx") + self.assertEqual(inst.name, "nginx") + self.assertEqual(auth.name, "nginx") + + inst, auth = self._runWithArgs("certonly -a apache -i apache") + self.assertEqual(inst.name, "apache") + self.assertEqual(auth.name, "apache") + + # if no installer arg is set (or it's set to none), one shouldn't be returned + inst, auth = self._runWithArgs("certonly -a nginx") + self.assertEqual(inst, None) + self.assertEqual(auth.name, "nginx") + inst, auth = self._runWithArgs("certonly -a nginx -i none") + self.assertEqual(inst, None) + self.assertEqual(auth.name, "nginx") + + inst, auth = self._runWithArgs("certonly -a apache") + self.assertEqual(inst, None) + self.assertEqual(auth.name, "apache") + inst, auth = self._runWithArgs("certonly -a apache -i none") + self.assertEqual(inst, None) + self.assertEqual(auth.name, "apache") + if __name__ == "__main__": unittest.main() # pragma: no cover diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/certbot-1.26.0/tests/storage_test.py new/certbot-1.27.0/tests/storage_test.py --- old/certbot-1.26.0/tests/storage_test.py 2022-04-05 19:41:26.000000000 +0200 +++ new/certbot-1.27.0/tests/storage_test.py 2022-05-03 20:33:10.000000000 +0200 @@ -461,7 +461,6 @@ ]: sometime = datetime.datetime.utcfromtimestamp(current_time) mock_datetime.datetime.utcnow.return_value = sometime - self.test_rc.configuration["deploy_before_expiry"] = interval self.test_rc.configuration["renew_before_expiry"] = interval self.assertEqual(self.test_rc.should_autorenew(), result) ++++++ python-certbot.keyring ++++++ --- /var/tmp/diff_new_pack.l7kspA/_old 2022-05-30 12:45:30.432514847 +0200 +++ /var/tmp/diff_new_pack.l7kspA/_new 2022-05-30 12:45:30.436514852 +0200 @@ -1,168 +1,308 @@ -----BEGIN PGP PUBLIC KEY BLOCK----- -mQGNBGBw52EBDADuieMX+hnF50SFU7UbQ2DZQty1Qd5q9UP/XOOauItD70CNXLOv -HT/L0IHfov15YxCUToKJMJkG86EOd53A79RxZ/hClG+MlaUO7d6LwZ7XW0WkBCt/ -ybBQR9/kgL9EhfE9d9iYiZPlE0A5JQvEfAHFBnWIZIWQMIvmbtFUrOYtb55lBP3b -papUNjgqTX9h400DR7LZ27W5wkHXwyMiY6hbwtUkqJ0LlmlGqgo/BRurBtHFuvfw -HtCPqmAI3ebS8V7eb9T2zCZW5CO7VbGSEb54y5LNW947jmv52FQtn4t2SzO0wtND -7i4svVR3HLPeAxA+ChZhw/ZAg0CfM4D7b8s51fIGZ7Zp4TarN7E2mm++Hf/yPTCf -aIEsoR7UKaJL9kXXv9QCatcwERfOgJo2zENAmo2U0SzHLvRD7PhY1AwtEZdzyCHc -pKN6CnDV8YGE5iPQcNVT0SGGlo/l3SRhh8tfwnK4Wkk0zy3nBYoiFUhP3oasPpm8 -7OorvzVbdBPNW0EAEQEAAbQnRUZGIENlcnRib3QgVGVhbSA8Y2VydGJvdC10ZWFt -QGVmZi5vcmc+iQHUBBMBCAA+FiEEIPIBNGv48/RVpz+aeAzJlDKihiEFAmBw52EC -GwMFCRLMAwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQeAzJlDKihiFAewv/ -cNmCh4NRL9P+VjfKhio6+MsZ5UHLQJPYk6ocQQc+JzF7GRm9UjY59mKJfgF3yzVk -F1tQ9MMI5sXd9v/RvE2tFre4HRXPC9OjdsyObX0hH6zVJ0vvkeopAyNaNhIyuC37 -SmlSM1g0QQYzVZw+mbA0pbe8BmtKnSjMZickKZ/lpsVmoPUcb7v7KrSGXgol/JTf -tl92hSgAm5ba1qSzwva1FiQYiSyiDk73cbgpMH1ZT08tU97VVwMRBQr6tMF5P8IN -0CfqpO/ANtJNVs6ftPesmkA42tOZwBhwA/TNlzrdwCfu93E5vjz9b0oV6SM/uA5K -Qzp3bTCouKq9EOHiS4gManvBUpthtILUKJDgZeOd+giL/bXzvozpZ+Nq4YXtwmTJ -KWDJX9+iK5PZKKmTYZ3oKpT2hoVSrbWouNUEQyUragPHO+GfFVBtH5tijC2rwNiq -a0KlO53nlZwxUERJ67WEe5Nlq81stGuyIirGchVF4qPVAVS1qfJVqLS2DKdmBuT0 -uQGNBGBw52EBDADp45g41IpsPEebvAmOLHetTxASOGPHOnO9v1vlDXQTOPcnugRH -jKCdageDo4fZTluQWu/KIfhVqdKOQ2z0J7Z+cnt0gDy8SGff//la/LP2CjluAo7T -yW6sXtyHvfLkNGQCsTlk1lzMBWxUReELfn7tWA9fKQcRLmXi/S0iYkA35TGBudPv -y0Eo0/WImnvwHhuHlvfeLaHatts4BsCf7zS77v70mdfKI8zUtQB968DCK0JRLnvQ -AObMG5anmJYuwHPFXx7MccKH+I1ovOPlDMUfoaLWCEqiyhSTs8+0Jg3VFoa32S7p -EU7Ipe71TmFbl4nTEQd5r4G03BLmYBNC6VVxmKnM1TNq1YajG0E0t6FP8MUrA03Q -AbGwh/+vLCvuJIh4PgL9Y+ll3KN5PhALsA4ubMzhPQM5D2ybWxHtXpp1qggD5LPF -7KP/T1SQyWx1LnRUeGqYRVKz0q0SqZVckEQFMgeCLskBmi27xCMWD+H05Qazzm45 -Hx3zMqMSoemijh0AEQEAAYkBvAQYAQgAJhYhBCDyATRr+PP0Vac/mngMyZQyooYh -BQJgcOdhAhsgBQkSzAMAAAoJEHgMyZQyooYhiAcMAN6sormdI354x7zBamAOnoKU -GDA2kxqy5U/Zj6gGWMDWY8FoInTpQe+ed26+qxVYSUKCOaLSiUjJAYwrqxVzTnhk -lelkB8c8sjEncaZLtr/7w4FZn2d+hx/oHZ0cZJwPAgST6m0vpxV/9Xyfi6vuo6yM -X3BKM5IL4VH3Qztct8o3QZU6N7v12rPewAUKGFbhmdBauSAJJcueW4Q8hqEJvWs3 -4VjXQXwTpYAKXyb4TZMCZDTuNOY/kdHftRpDk72p9UNULJhH1MzsuPFuWtc6SsDL -ALVrB/j5GSnFeuhuFkJJeUaqBMuRBiFS08ycPhrv+2sNsLlNJLs18En4gMB70P2V -j7Qby6qSRazMMYq1B6jwyWeV6TNeCYUylw1Oq8/+AG2Nr6Q+MWI5HNL+a9yDBw7i -/HnI6U8gLdqiLwqLpdtrLFKRNhgn1m/tZEezaQ29TcHJUHIWGqo42MdJUNGsCGB3 -/rOcM4TlzjiPI52z3r33RNRAosOU+EQaaJstqUqwbLkBjQRgcOdhAQwAoHJcJqNI -9uU/eSXq7UoWe3CzCd1TEKWKAWBWZfiJKGE0vFBym8pZdy+UxY/v+PeKFopYdgHx -ZmB8SCC/ZyK1z8cJoUmRp/Vs5cXAVGO2tzy6md9ix3F63vtSgV2JRjl8dSuhQkoh -Z0Jbu5s3bSVI4e1ayzq6hBxUmXoceih2QtIwFkvV/1In9wBJn6tRf0ZaMt5V6bQA -qT1oTR4bhZQgHFXOhouyPAOSTgEGz5HsTuVu5Bvi9W6w868GZxwsfvoiRPnFBauk -kpdSsJmFFJIFtzT3BU7U3ucJPWTvJKlSyuo5j6vfP3YfblSrmFo7WKsLcE0gYzjz -RU+3kuFwmR26YtsXEngOOtVYLaay95+ALZkpoUpmOoN0AVIWxURN+9Pu6lMYB2to -k72mtljuy2gGQluYMHQvKXmdRVraKvcoFCdK4Qc/djnNm5kZUVwrUPApAQqjnz6q -rxBadNnh5EQzEGGCYLRRfX1YP4alfmSp7CZGLMziagA9wXIABmtCOG9BABEBAAGJ -AbwEGAEIACYWIQQg8gE0a/jz9FWnP5p4DMmUMqKGIQUCYHDnYQIbDAUJEswDAAAK -CRB4DMmUMqKGIeBHC/0Ua1QV5lmKzgtEURh1qvPmLSJSEPgxH7lZqBhAh1Vf4Vaj -QUHKuVLohC+8ZMyeBN/qSJBILnNfUvcj9j7M6cWdygSoG74P+EQsotaQX1ZPEm+M -7WVEaDhJoC+SEgVTKZ/Qo5C0gstC78XyQ30gxN/Zpi+1/NB46oQpDW7tqFo1BkGy -lly/ekA4JGCqTbfd4PeYPvYf8JDaBjLZrTukYI1wan1OPqn2qfOvu5QYp1eXATF6 -RAAKARd8PxloyrAx2lujdkhNZmBzGPBsAyye89N8g7571U773G198WkwSvx/OS1j -mO64vnujNUdKyiODyLjfwlwGWQ24bE772I1CMbSPJXBuw3MMD4ZzzqZg5SIW66ie -1ZfJGIRiI6WOBV41Za+4fWpGNz7Rb9Le7cPVeTQ9ogJtSkI5Z4/1CKw76dd074lm -1ijg2cx4UVnY6tkfx+SWPi++yq3d657QqBleFqgoU1TsfUW860sC+qYztTioqrgi -UU36FJrwOZ+x8dyZUpqZAY0EYHDmXwEMALyWCrPe8V83J0sK8pimbb5mcGTXBOqV -g3pBMPcIhcmelroH6cI1+CjO5BYnyBTApTKRyB4SYnEvon5diMCfAPE+V/Nskcoc -9LSu4XMW5jnE/aj9xyXc2iKK6wqMEctY5ld/9522eXzASywNEvm0q5/xbR6qR0AJ -JPgoLydQKcZx1pzgUB11kA2fFKsJqXW3IYfnbCbxmhvFQmNbY6Jb8qb2jlCWxMtp -agec+6gYc8BVnyr50yCFSqtydrerXzUhDs0Wx5VnkAtBpc1sBSNlTST+Ee32QPj6 -m5PxfTNZF78lNd6x8jqQDvKIfwzzALxLpPHjJDxdWkQBRKGeg7TT71n/QcDCAQY3 -mwt1Rc96OKNvRkQjpf1bLF+4p6GjwiLeYkXwQ0Q/we1/UqyhO/6uO1nZg2QVkdtN -tnYgxP0rePW6wG+TjEJXi/PqhA0HQws3Z5ozgZ3UyYgyVmh/sOyrVCMkp4J6QDhf -3evSVG37gMKrEJi8s9w4Ih/tz4RqzTSXyQARAQABtCdFRkYgQ2VydGJvdCBUZWFt -IDxjZXJ0Ym90LXRlYW1AZWZmLm9yZz6JAdQEEwEIAD4WIQSGN5tPCvNxtQzZ5f80 -AoMRYdHSgAUCYHDmXwIbAwUJEswDAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAK -CRA0AoMRYdHSgJQ/DACJzKZJODZpJ8a3OLzL+8Et6CqHKU7pskGaVGbkJ8o4Mb3F -plfhkcZ50/hKi5MEJnuorrNpqWx6+xUfLz5n5AeT9aabFQnTOv0KEqut0kHk1wSu -ioLIXjORE/U6r/Yi00dkWmXZktWAWWiC/RU6nnX1EeD0ifAMwQEddP3aSYPhXgH2 -0x5AVwUKXPimwMMLeJMryoCl10OvhPerQRHkOinNeK/oPDqjq9WCoUihpxpTECju -DjEh93H48ikgqmm1TvgPSo7jf6G/oUAS5uPsmToIkBVdSVpT/IwFFvf22UBUrON+ -Lf6qpM0wCPCzpa66LKfGNo4KQTQAB/73vBX7hWFEy+qzZpCA31knROBA5loIyNm9 -IsgWW7RyeIewcZAG0JvDkgw0BSQaT03WRlbGjGnBq7GhKZIlydunrbENM5ID6o8+ -NK+ru6KHCy/OmJ0LwzdePBih+21I1JGauFN8rwzTlVSvH3t/03J7AjgkpQEiMTt4 -9YhJ1LdTOlzQqe95Y3u5AY0EYHDmXwEMALneawKCc9k06FxY7Wq+RY/jwSyF0cTu -dBVupX71bS7yzlaQN5TNcVKSVwqivq3i/WProQWLhAV2qSL0IYPCRZiQEqLxO/4d -WI4Ag0I+HQY8DWnnMFw4yRScafcuY2zkVg2lBBlYiFaZmIGjdMF1Dr5IlFX6Mt+1 -42p1GUTFOk3jo/3u2QL53T/7Eq35eWhWs7vaQzt4KoivGl4y6zPsUBNLQQBmgvKK -liaUmkM2FFjVVR6jYl9qQ9Y2aO3E1NQyZ4Jmh+7Apf6mXdVZoj+uuHLc73MBgDn6 -F5UJ9Zryt6ZgUJqOR75CIcWKccT0k57khNHnn+pmWvk9hsM3wmc0P3oyyY0WpUSO -EPhQjcOHd0OwhJ/jjtGmMdfCSzc5QmkbDDOtEP1TE9oOF7KzBBb9i4ZVwVLQfL7e -/UcIuk0ZGA2MG+blH6GXMtTlF8i0DaO1uddSev4SsCOD5svOWyW4aslR9s6z9ETU -qYegmh0bmdLL7haRhOkTmaSCRc8t9H4BNwARAQABiQG8BBgBCAAmFiEEhjebTwrz -cbUM2eX/NAKDEWHR0oAFAmBw5l8CGyAFCRLMAwAACgkQNAKDEWHR0oAdsQv+Pt41 -dwQYURCzONUsmc8o68e/joPRmiaZvWCUtdaSejqwwfC7XVyE98KvcGxIgWBCf+tV -b65E6Olg0B+CFFNG35DENssLSB+YVqtHzyy6M6H4CXFakm6ieInW+iYXqdutArXn -MtLwGqNfd7ZxGeKxBacx3/f622uTwdzvxoW2cCka7fyET3MwtFLUJGWwE5NwFQeM -SFZHKMXXZTPHQkHFZXjdyBr7LbSThhuSpIwGV52EXfCsciMa7LD8ZDR2Ek1NqhAg -Z+zx3Ds8EEdaBxn4H4k4q6r8qTKKJJQipN5iRjdxa+NFClddiEihbi0H++dXukPP -zmYkr5enziYhf0B1UyJ365VawtCz5/WKeoZBJ9r1bGmJerzDqbs8yfJXRfvMpWZK -ynuLpHv4Qa7E8u5swKFZjsB1sPEvabEfj5gz6pxV5FQ7KfJS1A2MKMoaU1taxO7t -8B+cz2UPVK05hSZHWrb5FCJ/dqyAr8Pn0Dy5Sebvn0XE4VQmZAjuUQJEJd6juQGN -BGBw5l8BDACoGgWh5/DbyEUP1hONDX5gUoNNlwFXpGOGSHY1ePLMD9GILWofnn94 -Aw4JYXxAG2yxRWRIfddmEubbUs7BOG0lMdIZ51SQqFK6K5Y2TGlUySge/B7EZiMe -6lXLrdWFGoDkCy60H21gpxHyPjcBzaetztR1KLa4KMbse/kxURx6QF9zfP1v5xKT -HiJ6+0QGgookZw2vJQsCoafLHIS+XkNR73WMPvO1d3vlEVylsLtwpf+LsYwNoLgt -f3zkpEO6+9Q1D+Au46CI7mP3ozHCg9NNYhz2Cua4hPa5LPfSvzfk9yfFLGvLhxa3 -30I6GcEF7ppwlZH0RNunlju6lwAKDeqmyfEFjDfQBoaFs8g6hcPxRU1VZ6FZwTRR -lPVE6CsZCoA74pW7g1HsTqiz4Q5KY7UxT7hx2bRxJp4Tmydvm/TvCi/5Wgx2L/FR -3svgs44dFOrqFVaJt5OgkYblObsH8ov+ql/axqbu35Rg7aueMEluuhB2G6xUYIsw -w2ovtGGvRQcAEQEAAYkBvAQYAQgAJhYhBIY3m08K83G1DNnl/zQCgxFh0dKABQJg -cOZfAhsMBQkSzAMAAAoJEDQCgxFh0dKAKq8MAIUv5tc6i+hE5h2EdOX2JTnU2+NA -PgivyBYUk1O0u0V1v6wdub/PVXf8ku4UxWma2WuOgX4UHc3Mt/vm6yieNaOvTJti -Eh9pyLByigrqlBga9DOUNO+NaybmAj2gcNhM+IlqWgMtQNLxQtboSny0S9K2qW9H -lp7Yhaulv+8X2ScGFDGLVcpZrxwKVAwd4ViMVUjh7IxMtAbPewCDKdZ1n9u5J+XO -1/4B+yicnVOLK/KSsPw7cIeYRj/kvPHe2ISrCIPXdd+cJA0PNGXIS/K2h2cw9nPQ -NCW6CA2FXc5feFwHjA2ES1UKbGkaaOROBStu/LTcmqj6CveVGkmYOEn5SmEp0f/k -CxhFsbtoyVnsDA+9zZ/Tvdb55ZaMVfYmqG3oxXJc3pqOf6t4lGukJ5uclMZypODv -By8eBx6hW+3k7LpGwya098WKoEgIoCqBdTc9/U4FZ4Iwzs02Fdsr4MtMqTZaQBkO -OukJ/TuWLsI0NhrKKmJl7tkcCLfSyi//Ys0he5kBjQRgcOV2AQwA8WFRBqfUZrtR -nGp5UXlP1iiMJu6B+mqpf55ayouBTvPhkRZN9ArLiZpnzm2gEE+DIockMh423Y6q -shHMkxsdyevqyjNsvBk4oJZcybW846jKMHz6YyocgJPo3H6Km2DHwLK+lPHdUAuP -crrZC5igTU9dDzHxdt+OB1yMV+1RcTUTLtb961TRQgQM8rI1VeXikPORFgtBUc8c -8ihtTrOUc/HZSJp+F5S5IHq/mFaDQv0CSKoajOsOruycZruftQOjoufekncQHhh6 -aM76TKxSoZGzjhqQgrCuZdqHneTT3uBLYBv4MC0JFMvraZYPydVpL/EKh+5Ki32B -WIMspDjP705ffujgNHjd90YXjdg2L1w/CgBIij7xXFRXibilsY664PGn+dL2b9a2 -oe/LbeZU6f3S7ueN3+Kb8rT8tOM9EqBOeLdZ6ws73HViDAiZzYIeTVNG9ANV/7nk -RnN2PouVjboDBL6FqLFERJv83BzkT/2d8ALFqts2H/46Eb9xUNO5ABEBAAG0J0VG -RiBDZXJ0Ym90IFRlYW0gPGNlcnRib3QtdGVhbUBlZmYub3JnPokB1AQTAQgAPhYh -BL9rz8iekHR7mmgP17YCnoUA99sWBQJgcOV2AhsDBQkSzAMABQsJCAcCBhUKCQgL -AgQWAgMBAh4BAheAAAoJELYCnoUA99sWA6MMAICtDk4TQpuOanpr3/h6C6KTqcNC -R3H3Yzx92MCV4rzXz8BC02mfk+Eplu6LPe3nhoiL86sneP3VdhgymWgtUcaLXBKK -6TIr2fsDcp797aSBuGIImU5JFqG1AqN68kAhK6ztggpuT1loBK2dHgHTPE1OlltF -Qep2JaX6d66qAR/PM7WdR8ahDqfl8j7yLtePno35tSFIsihgwRX2l3HvxajQZFDM -BvcnpG5d/CcudsvMf/CAJAdcsOBVOZz9dtd78jYrWLUEiuM69coD00NlQAYxOy1s -Vvsf8IMf535ucENB/PitJKQHTv5CDVDgy2W3g6zsscgz2qEgtWJyRRhVp5u1xP6s -0ER72Y0DyA5GkGal+S1vU+8KxKS0SYaz3VmOpvGBraqW5icQhTJd7WcWWTvQRbIv -lfg8eeO09TD8G7WS0/fQ2Izs1EjlpXIL6R6fcEQvkfGN9c3HiGpinJGCfHa2GQX3 -fNmZYOOFvxqTTGGWSD0eqRsW5hprNCk634lRFrkBjQRgcOV2AQwAvPOxv5z/xx1O -n3jvBBuzPP+SqRQG9woakjA0UWtKzi4wqBsmYYKFccAqh277ETu5bTyXDCytXkw2 -2sPvWnm5Micya3SgQnuwi79RrOYTOvptDrpFcn0Ys0YrMTX8/wkI6C7SyffkaOQm -GA5+eyFY3FEgm3t9mrjatRbg8/XOyJ3RV7VGL9wVmnTzr9KqLQTlHuJ7PP/OYz6K -jvYewIgB854mWbBEnE0di5459n1YXOBMQ8Qq5bTLgEdhBnVVrvQP0OnpYSOSDros -ZZD8Ui/nIPITcAcLV3Trukd6+mFiAmaIBuqkiHA8PCRUbNdyIU9CXvYoEnTCTtnd -unaxuW53+5gYwrqCgnBoF12cOjfVrdZ6yPPj3bQzq3sPOChyGV+sctyHCrjv9OLB -hQLa3kWPoHQ5njYwB1ljClza2vGRfZP6iA19r0hdoJ3zGnsVzYdA3sGfN7FrHF0+ -NOjrIzlXwaGtqaB2+6UP/D+ny7MbXD+xxGR9J1WI/ZDCt7K2VrRfABEBAAGJAbwE -GAEIACYWIQS/a8/InpB0e5poD9e2Ap6FAPfbFgUCYHDldgIbIAUJEswDAAAKCRC2 -Ap6FAPfbFniYDADw1qk5wBlcPrWEm4uOoQdV+19ksy8mojZP1ZyNcF0HsJGSrT99 -q/McmbL4nFw8djbKeOmlHPY7oYCecFKMfwDEod24qLqrB8y6MKoJ1BFSTFzOi3Ic -B5DsVjkU9PDjWJafa+vBRYxeZOT9c2Usr0uzIjY2YC/9wlJ7Y3XTqYxXs+KadSe8 -LM3wZml8KO1U6j6qnS6RaSH5qev0WESsRvw5opdjpf0CWck38Wd/NHexoIjZ9Rx9 -KhwmjNekQfZ6eMohyLlRQZK64tn7aU6BQSGnDjSX01lUazpIANTT8PFJkCLKeI2f -0hlzj3PGo5MxeXqVr/nDlCKj3xOYKTejOosdZyhl50EohNpaAdH2wsTIJkPrlHkH -0+6kiSq6UhVmmYBSyn0uu1drbQpW1zKYKWKAV3r8rTS4nIZ5VNMUFOk3wdXtEsWf -LfeJnY/nUk5Ydpnt3L6N9buY/QiPMa2hxfr+kpuJL3rX2rek7uUso69BycsdLpIj -q/oqTpvOJ8BdhS65AY0EYHDldgEMANx+SPfPUucO5f5EIjmm0vrJwLbNU8hSGvNh -/l+MYxHzCWZneVzG6dQkuz7W0XdiZitXOq0BayviEb3bdV9P5douPQw04kbvtdvg -FdEQxLdZHHhCwTdHoHm0Wmc7sCgo9c0YK/j6eS7Stway7WRYCsn0uC+j7O7UB00L -StcMAYGMx5ia8weXrsh9bCpbnlaQwRCey451ybVnz+sgm2XdsK5DnlyCnOLmAFDV -wZUgO1Imx+vnLWwemPBBoLioqONu/CAw+5iN1ErDOckPRT38w8C/s1AWuYsCdEf3 -LpHTGr/wKF4ZlJYzQrXH5L3tl9k/Zqq+XoT5ENPMMNRI4Nvk1bfJn2RBd+csDiyx -OFKoz20D4jWJNrgRiMH2gpWkDOcmAG6q9/hOlKLhrgAkOWbwu2ilJLcCt5Rpeh7O -iU+2oZcwk8n6+xltVIUsZ1KYCS4QnSk00pguor/Bjnt+9eLBxPL7rnQ+Cw2/9reP -nuPdNDMiTAWSgu0mro5fA8D3b+ZPhQARAQABiQG8BBgBCAAmFiEEv2vPyJ6QdHua -aA/XtgKehQD32xYFAmBw5XYCGwwFCRLMAwAACgkQtgKehQD32xaecwv+Ovygd9Xz -r2vaE+OILUPJI47iRO1VyrrMzgtJ/s4UoQLtmdoBiRs/hlyehRijcwrxo6zjQujD -fVlcaQLGeAUZifhoY10StOx79O3Y+XEJBvDhu+vk1IXiCDqgne68FgNDa3NY4yZi -QFiTlaTAXSiKfh95A2gsLR51nR3TtvP0q/60gETx13PqFaIIHH+IlIk/m5qkNB/x -px89HLw9dxLRIbGsCz/l6L64oQ0QYDNdLZgnKP5fiO5LbpuQCaE8xH8K6hsTGd5/ -qRKSXsEGBkbirhrmD1wZlwOa6Q6DMv6HnkrOsBzzFWkt12GZ17Yg2NKmYOywHn2x -YlSo1j4gvmWFtA6XYRKypesoyEa5hwudLU1TohOmbuquUSSjfvK7vtB8MVlygl5u -rIJX3PrhY/zphuBIGc7JF8dsmOmi4HOSMgYbMvm7RZeeonaSLi4i1D3Io8DeEhLH -eSI9pS/eC+gQEdCRrnw4iagzbmbP3BjZAj1XSIfpOVVFKKBgSMEFabOe -=1JZK +mQENBFZVq4kBCADJvp9fLg1WqQ3KJl9ayOk23i5PNGSF6loT2muvoUcbQFUKC6ie +xC3chvIIIrXPG1lJhNxXONUaiooBrDLo17MGM5C6k8j5FZfAqxirC40rL4yDF+cq +2ObuURaWX6t0eS9k6B0Kg8aqru9bKHO/NQNqN/nw8Kyyg5D2jdn2HPcMn6/5RWrv +q2TRk3lFggunm4wb2i8Gegu04/bgcfEyxvI0Y+gLR4n3vu1/m4oEVuwxwqggb5BB +Ac5knkiCNZl6sGwZxCXxJcK4J+3O5RNdF7K7v/B8S8djN6fKmcjtPn0tsB6xkaQ7 +osaGQy2dOlh3ZWZDhtACCBJmCp1hx5zerkuJABEBAAG0NkxldCdzIEVuY3J5cHQg +Q2xpZW50IFRlYW0gPGxldHNlbmNyeXB0LWNsaWVudEBlZmYub3JnPokBPgQTAQIA +KAUCVlWriQIbAwUJFo5qAAYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQTRfJ +lc2XdfISLAf/XJzoA/L2cIErpnJUuhuPcHHDnt2wspiNuzpwH5ojob6L3DTXCYrE +NQUm8wbBgruDpO9OLvQrzmlRIdDU/IkcHD6lfiRT3lhfAcZBZfEVqhSvyRP2VABX +1V+bSGJM9sLJZqgw26fD7GX5VUxvZfeqN4wW4ufdtrkRb+evtuOWDGjV/OfD285U +0mv1JIdJ/DnUXoNDn1Lr7RJJtTfYUzQXAvgmB2Fkn1nkg3drhJ8+mj5VAzRTEX8a +zb/ss56cW8BFGNWcfwefMQq5PLQIOczBtkVyTNKKwMorwfTcp0GnNSNil/mTkrcJ +mjRMTbXwlNxcq+G7Sg7hG6+PYj2zbjXaD4kCHAQQAQIABgUCVl5DMwAKCRBJTyG5 +1nxNISKiEACdSAXiylrj0DM6+acUwZ8yiixitZXFUVS32Msv3TzYnEhOxl3b5RY4 +vY8AXjKGrzb92SZdQaHjFoY5Jyt+gzfoAhv3ESozTvN4YeY1FY5qWZhoKVnFOTYF +vqd+6zg6FmlQQiJQjDABGyEJVmwmJaMyAlDaG9Y1g2qmji5Fv5IP4aA9ieYligJq +7S4c8oXcQpIgEvwi/QZQCHnMGKsBR4Tub2gMyXwApgMib8dsaq8wE8hGzhrAf3FD +hRPwkckOL8ICou/d9reDaxpQU5dpJVBQCsPCkpyaINnUf9LS4fkX9TKw5A4M254P +5Se+FGqSrA020lctS5DUMCJz7Zug9o01JlH7kb2IOwYXbV95J9mWBIdn38RJiOh9 +tQgE4nUl4Y8Bg8RqQIjPP4dUV7LVpC3AXiAvIpO0x8W7SDjrlHb8saTgSfBpjr+F +z9nI25pNTdmQ8ep4GVZ9A3nlyeuZpxPO4hG0FNyw0XoIMWYR/VRySsvaibR7Hlyh +6jwJixtYx5oxOJ1xS1zpn4aUGLgAH1/1QfCocpzYBRbcxvaYOJm+bGTKX/0wPXiu +WNzwkD5d47mYOcIxrMfkG7OZH8tVhcrbzcrKhBPkKC3QSvSRdLXazsD+rFZ8vuVo +c26gbCX5s5Zj0raa7ZZVjPFL8uTV4esdaW82KcuOiAqZTsjIvaB9Q4kCHAQQAQgA +BgUCVl4x2wAKCRA+W0FS462x/U4tD/0Yakf7ELhIIUEl2WActP6Zd/iQTJZhDUXp +SnFs0++mpx8ZnnR3QMYq1A0fukbRCwEgkU2JBIOMNIUFFezK/x1HaaEKxFQ1oi1e +Tk9CHPA5hT82JTuPTRrATRRzFnodPlWHNWpGeeshkDOAvUOwq42xSLHnmePtNT17 +WnFNRrG8BZffrWGpADFWkCtZ1ypCb5jQnklURn+hqrvneWqkfZxVj+xpVcbrUuKZ +7lq2MwVoexaZQMHjGSyiUr1sc56tuJ1+ZuAyU58CXXRo8Jz9ETS6bUrGQHSKTeI6 +HRbGLhjj+2d3aabCjM2I5UciLFJ3TNO1cK7N4VWYglJb7Lqv7i7yalD8pLywfb6C +SdAUaNyOlCzxdJCk50115y4CyKyySp1wmmjlTQTRToBirdjWT9hc8uzKImlRSWwB +wYr8YpL7hoSqcl8ahLMo3PSU4ZuHw/ewjbS5VlrTb3cuWg0QeprGUZSXDj3wEyZC +LF+X5Q4wJdjh/4jEwf7jcrQO/Ykhi6aWSAiQRuk4gN+KopfFQV9UWg9HXDHqR8mz +L714whKibxymQj+Ud9q9lCMEoHsvtHJStauzYVfGS8GJrgXEzIrrUc2jFwntkwRp +mny5DFW5cCgDK4raHG6/IP5jYhU214L7arzntwOqhjEdR1gAL1WfuqxWFmsDaDQD +1ZZiArY2s7kBDQRWVauJAQgAwXk3jChBJmlH7ir4IPVC8D8FI3oqMotEX05DbvjZ +B0+S8MCqkxor5MaMBEXZMiMUO7u5+FRWwFL1befIPFxKI48PRm1hZNaQPu+3qXfE +utCWhNYBIQogSdN8oOg2HX+tNk9OUryRhIdeDhYEPtZzJv5bca9GaJilhMJrKuK4 +FdQFiCQVXLKwY7g2knzIG81IyQj+pd0EhJlMeGU4WVXA/LG4tOejRCkJSNAEeFkt +NOYKR3ERWwgZxHB8/apPeww80Kk6Pbc9uPfGTeecpcpwdUqIxTzkfkdb6SL7VQa0 +1BzgbidFeKEKCPD7eq/kATcUPl6q+fC9AismlKmCzU/a4QARAQABiQElBBgBAgAP +BQJWVauJAhsMBQkWjmoAAAoJEE0XyZXNl3Xyoz4IAJ8HVTvss13crU2SBNIFce2E +IkXquUPqnv6vuNFFq+3Qv4atHch+p3rnkSZ8yTudIT0tyYO/5dRPoiKFzh2HqHft +Ke61oT1i6xGkfQmMdz2Y1A1Jl6EUEs8/8uiDONtz7PrKTMcIQOSRdUkDHO8OXALi +A/it20cVLq39bP7bFDT31bIGyRKlF9beNnd1BINTQPa1O8JxeE6NLPdmGeHAXyEP +UgcjvXrCLKUSvM0KlB81N0SjX0RpM7qyX3XLnj+fQOJ+0pbvluMnn2Ooejkz9F6b +Nr1SN9cu0TWFMgoqvES0mL3PD6dSW5QNfIDNy+TAzaOjYTu55/3JvbyRD26ouau5 +AQ0EVlWsMwEIALhDTFjI97adohYQMgIBFbfkY1ETbtQiwyxqBMOVDY5857cYgY5K +KcdM50Y9SbK0VX9ScBsB0x28IIr/gBHk5SB0yc7LxVByT3oOf6dktXLS2LljIFws +z+g1qi7bdS3ROBmQW8U1Jbae/XsLV1OcEsu7V8RebdN0nyNzsyw4C2DcyNDD4SG3 +9PnBMV0JSeSIrAhJm+Ca71KmMqS0kklYqXUcScopEvYHNJf4EBxHd2BMSMwSDCQf +nNXR3b5ddKVUQsgXl9HVnWVZGXo6IGAIVGZCQ367yhuGfJKXxyR0NHSowk1/MHWv +1/R3pjhEnW8zccyWUhG+LB2ufKDSwaV5jmcAEQEAAYkBJQQYAQIADwUCVlWsMwIb +IAUJFo5qAAAKCRBNF8mVzZd18hqLCACCeF+ySpKK30DyfDJ26wRjmx6OQigz5ZdP ++qmuavyajDFnforKZh4iOfScN/jMvRh20WKHkmazOWG4HgvnLeWj3DMxTpP46wH4 +XWgC+XQ1jeWMi4fkUa3E8JQiPS970miaUXKakhSEz+pfY6uf9Ay5FBgTqg2zAmCA +6yAzMogqQRKi8yvR9MWCbEAJtuTcR3fi3d61dskohKuiNfXDlFt3+aTr00lEqqAS +Py2cguj97kfycT/ANfpYI7iN2DkgR9EOGx0H1WOxfc5eEtQViqAu2qrnUOEpsoCB +Or7pktv/MWHMwJx72E3L5qhjjC872dWPU2cH5Y0yn7BVBdxwDVJQmQGNBGJGHdoB +DADqhRFH6VcRQHqLQc6BtE5OoEn3TFyVxK/u2J5+OI+NhjQaY8N50isZxuQdRaSZ +3HIAoNEfuLLObbSJ1JbEDJroQlQ3VhE+WnTW8g6LhGJ4/Yds1uem+MOnUvWVAIsQ +iC/cYp1SeQkyiElaG6irtar8H+QLXLb3xAhUCQPFt5vUMaHZtJqzliya/z3q6ZuY +SkIWtEZGBdO+UtvnV3/x81MZi8Ny5Qx0iw2/vMLAJWamARTOOm/PmhOXeZceUuTm +V75IgxTkSuQ+aqEkw5FDt2Xd4PulbVaZdhh9zd+knfNbwLfcY11nvpAx3PrKkRhG +kufHeEF9NOWzPIBy+6wPP3Cmbo8pa8At1vp1dP+xWTscf9BveQo1M9km1Ry2uppT +MhENCTDy5DR6P6M/UIB+M33KCF5Jy+z6KE+0ZYgEB9cO3OdTI3GBhIbujVZIhpq9 +iIQ61XfvVkWFAedyyH7Xhhq3fLFlVyGe2TJjexBNAJexRK0MIOnr6rXTwYSgg5Mk +icUAEQEAAbQnRUZGIENlcnRib3QgVGVhbSA8Y2VydGJvdC10ZWFtQGVmZi5vcmc+ +iQHUBBMBCgA+FiEE8ocbQVKuE8SVGREfRHv2g6o7JsMFAmJGHdoCGwMFCRLMAwAF +CwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQRHv2g6o7JsMwtQwAhrLbRNa9fRhu +ZYjgbLmvVSfP/coO/TkbLrT4Axv0ExEAvkFKDGO0zmtwS9+lZhQRGpWse6sJMAvg +D6mzVLdjmaI/LFPUQvCRu4woUyaiNl3EW9hxH8ioSN0zJN9QMKpMVjYTwy7Bcl8r +7TZQZh2oNbc+jxpxNf0WYQS1X5qy4ky1RWD681df55tnn9IROBjrReAaFfHMaox7 +C7yBFt+m8tWrAGxklWm/JharuF5IYH79cJOKQsnF73aV3IDpLQ05u6CqjD7iZf1H +tgwp7WsBQA+85I6Z18tsznDLx2w3dU19ru/8LbqNAM5V3ADU3DG11DLFEipSNQdk +9kELvHycJ7x2dNHJxT9T+VxQ75jJ8VO8HrhBYpypQwRMTB5eHR8EUSMWbZD6urC8 +CF4NvqHccp2uDb5/+up7Zi0e3lo/t2EqVm99pjEDDz4MNytRS4L/oiI7gvO4tIyk +/e6u1Piyz8u1aiwh/1l9SEkiKWaVRg739OZtGUFdCW7gNn0C+ziLiQEzBBABCAAd +FiEEos+1H6J1pyhiNOeyTRfJlc2XdfIFAmJGNdAACgkQTRfJlc2XdfKXrAf/Qpjv +W6mP83LoH6ymzr6j6JYNrcWJiu9QFf6NXMTsum0CFMAawcUdrdW7caZVKTiu7M3v +2BjajhV5cxW+FpObaU+ibXO6oHtcnEC143alvrOw/dTss5+yfz3f0IkUOFMYa3Ej +pLd0IjEUs6SnFES7EfhYQN4JlVX/HIsGGYJ0ky4w6qiKxQ/TRnuIZFwvSgka9iNZ +xCW6+ixNySKoGszjAURyyKLPEWnoNp/o6BSRlXS4/MLPn7dDi3R01HVZRF7qrACA +vO0NzrcBuQDGraRu52loprLV6UdRkg6uyL4pOwr1/ZxM+ZEyYGWal1/oAc7LPehc +8m1/Td2LHCtwP5geVbkBjQRiRh3aAQwAuJDzjBOl0GRXgRrprr3gMoVKshKX2xdW +j72SaS7xF3cClJclUDe7e/l+lymzbkUyugxkHiT9+2SPYAUJuB360tfouAv5KEjh +7jopXuraGy3r0Ppi7V1tajQkjsJ/uTFRFbiE3Xa1cFBvdS2BL7Ffwd3wr59MRv9U +QR7TpaNPKRnMPbYifQRZi/cilPxhXKfj9mpACWdq2Rkgo/Z868wECkwAcWEZGceT +Pn+DzzoQvJ82HbAYBYko8+ZqA6bCzrC6xrExJMdQb/1KJY0C1tC5vdz9tw64INpV +R+oV3ty34/zNOhtYrifv791Xv8rvIMUtOkjO6jL7QprYFS3mZRyZ02W+yg4/bLz3 +QnTdSe4w8NBmB+mWsn3YgSKBw5qsLuTaOb6EmBSw/cgfvpRw7awomz3MTizHU+Yi +U9fInRJ5HjCMGEGPDsKHQn+LOry+FNro84dLYJhKKgWLVwvidCyhGfcxLefzgFP8 ++8yb+WMCP0nv3lBrOfp2CrpI6eO066JPABEBAAGJAbwEGAEKACYWIQTyhxtBUq4T +xJUZER9Ee/aDqjsmwwUCYkYd2gIbDAUJEswDAAAKCRBEe/aDqjsmw1Z9C/9p4IYF +yXe3BHmnNxBNC4AUnNJZSHTtF4Kt9f5ZgBehFwYO/JUZjqyzbV1IItFAKZw5Iyj7 +c37H/jw5rUDcBbV7xozy6wkeneQ/w10W4GqMxzrbXEoALT7qEbTcJkZvtPiEJ/8n +yYDqsLdMgKMTfHj7a1Da6kaPlskDI8Mx4idTWLv+oEUgTI+DxLoaoDZ/apeLT/PK +SUj6fv343cM5hRiU+KRppIbfottx1NuS4wy7DeWagJQfOlr++3r3sl64p5H72v1X +5ei5dz9UrMOrDiHH0/5PzuCmZA8tTHK68hAiK1VH8ELkTTmdP/OROarJG3g31i/3 +keZgebwuLa8kipUzcExFiUPtw/LnEIzz2BbF9ZoMebXjvf6ZjZAly5yPh/65AJPf +ADVMqkzh12uRF4OcitPxZ+HwtufdzRir2v9RYztMcGpd8R6NFBZ/82eHNzNNCqps +hay+6iOOV3nW/2ahOHGnuuSSPX+5GLrltiRLbtBES+24hDnNVNe5EehiSca5AY0E +YkYd2gEMAMS4L5RqZXgpvhV+prmJfaBIoJnb1hbEO0aSSKQCO/MPKyEggIuYnv7A +Tr1yPvPzG4yTagyX+WVzqRt2KNo+6LsEXwtWAvMb2AaZShz7rLFQoA+tETNhe7Rb +B90BcHzW3b4NX66lk5H/IJDGhkWblxidp4AD/I+8mb1CwzX3aNomzcjKkAogGGtr +rwRk1/ZG24Zl6Zatw1IUNyvhyZ9r7FFuLf4j+vma8YhVXJ3gJKl5Zv60gNVfcTYP +ohZRD/4SGPrNObNJs7tB7VsTeKdTcCRPfSZQwCpe6nCjrnHNQu9wQrq15pKYleIA +P15HjTdvp7EDfiA5UXYvSKNUDYDd7ROZlLsAzivG2jDWf8PrRkC9vKuQyq9GUWyi +8cBUAdfU08lNIBYE3jQbStN3xIun5V1Rz0+PQjECkjrLYRuI5xrWYzKC4TlMwXbk +JkagPI6XcmeXa1OVBq9WsmruDD75OcA/6wfi12Pw56MORDqSbZWkny8lkvguzdhu +bCyxIaMw5wARAQABiQG8BBgBCgAmFiEE8ocbQVKuE8SVGREfRHv2g6o7JsMFAmJG +HdoCGyAFCRLMAwAACgkQRHv2g6o7JsOmwAv/Qr6APY82eROEY48pmQvVzprHXv/X +GMnUFLdi+VR7xAspJnfUwKL+RxWcKKU6gACVuvC6AJCYlEkcp9C08+TfeOmyetBl +q2q3R8rwWP6G/F26f7M/EU4Fkr6iXKtaBEU8WSpPNC7LtC8c7QVNY9clce1DEex6 +D0FWa67Zxg3p/eaA5e3fjcS5qipR+ISj92ekZul63iLv1AYxpa5CQrfEsCfq2xMc +MbypX/cWKq8dwfSOhkYAt6aiQ9FFkHsiREl7qbnKv2iB2qFkKXtokA+/8WDF2Jt1 +bB0phtWu7GmddK3836Lb2NoTWEumtscxMQsEyhuPn7OyGFdnPwrSXmSKFzWz/shb +tvuJEXMcsIWjVO7uwT4JDY9jGZX6Ij9EZhGDCa7YGDa+RzQrsHDfsf056YEj0nl9 +pkLoTZztiftbYpN+VpVtly0sHjD9M5qwzOVzY4to4lMXwGLmNZHxes0aSnGROpOe +9hyJ1Adq3CXQmledrOt1HQfK8lwFDwfPc6b2mQGNBGBw5XYBDADxYVEGp9Rmu1Gc +anlReU/WKIwm7oH6aql/nlrKi4FO8+GRFk30CsuJmmfObaAQT4MihyQyHjbdjqqy +EcyTGx3J6+rKM2y8GTigllzJtbzjqMowfPpjKhyAk+jcfoqbYMfAsr6U8d1QC49y +utkLmKBNT10PMfF2344HXIxX7VFxNRMu1v3rVNFCBAzysjVV5eKQ85EWC0FRzxzy +KG1Os5Rz8dlImn4XlLkger+YVoNC/QJIqhqM6w6u7Jxmu5+1A6Oi596SdxAeGHpo +zvpMrFKhkbOOGpCCsK5l2oed5NPe4EtgG/gwLQkUy+tplg/J1Wkv8QqH7kqLfYFY +gyykOM/vTl9+6OA0eN33RheN2DYvXD8KAEiKPvFcVFeJuKWxjrrg8af50vZv1rah +78tt5lTp/dLu543f4pvytPy04z0SoE54t1nrCzvcdWIMCJnNgh5NU0b0A1X/ueRG +c3Y+i5WNugMEvoWosUREm/zcHORP/Z3wAsWq2zYf/joRv3FQ07kAEQEAAbQnRUZG +IENlcnRib3QgVGVhbSA8Y2VydGJvdC10ZWFtQGVmZi5vcmc+iQHUBBMBCAA+FiEE +v2vPyJ6QdHuaaA/XtgKehQD32xYFAmBw5XYCGwMFCRLMAwAFCwkIBwIGFQoJCAsC +BBYCAwECHgECF4AACgkQtgKehQD32xYDowwAgK0OThNCm45qemvf+HoLopOpw0JH +cfdjPH3YwJXivNfPwELTaZ+T4SmW7os97eeGiIvzqyd4/dV2GDKZaC1RxotcEorp +MivZ+wNynv3tpIG4YgiZTkkWobUCo3ryQCErrO2CCm5PWWgErZ0eAdM8TU6WW0VB +6nYlpfp3rqoBH88ztZ1HxqEOp+XyPvIu14+ejfm1IUiyKGDBFfaXce/FqNBkUMwG +9yekbl38Jy52y8x/8IAkB1yw4FU5nP1213vyNitYtQSK4zr1ygPTQ2VABjE7LWxW ++x/wgx/nfm5wQ0H8+K0kpAdO/kINUODLZbeDrOyxyDPaoSC1YnJFGFWnm7XE/qzQ +RHvZjQPIDkaQZqX5LW9T7wrEpLRJhrPdWY6m8YGtqpbmJxCFMl3tZxZZO9BFsi+V ++Dx547T1MPwbtZLT99DYjOzUSOWlcgvpHp9wRC+R8Y31zceIamKckYJ8drYZBfd8 +2Zlg44W/GpNMYZZIPR6pGxbmGms0KTrfiVEWiQEzBBABCAAdFiEEos+1H6J1pyhi +NOeyTRfJlc2XdfIFAmFCQSQACgkQTRfJlc2XdfKajAf/au4LwciXu3gwlHrmWo4q +FXH/zyKVG9KOng1SBfxeSKjVy4ny2xehrEaA+7WGn4QsGsfGbOwB9sbpfwofUUCx +Mw+vBFdlnovKNb8ShhReS3XXXTMrCnV0o9ozmrtYW1bf8XK46Wb3sRaaiD6jKHW8 +NE9US5I9EZCaTho9YLwO7M+iIUArK0+MO26O5IelzNtYPlQ2bTb4VcJey2iJLohw +1yjSycX3xooYYVZG1UbFYlV4Jw1Hn1fV2B+GU5aYZJP+styiBwvqdXqd7VsT1dku +JSeBVJZ/Q9aYLPaB0JQ8v92IHcPhnQGDeY4YNswWw/km3Hnj3MUhFEsJWIt1BcqO +1bkBjQRgcOV2AQwAvPOxv5z/xx1On3jvBBuzPP+SqRQG9woakjA0UWtKzi4wqBsm +YYKFccAqh277ETu5bTyXDCytXkw22sPvWnm5Micya3SgQnuwi79RrOYTOvptDrpF +cn0Ys0YrMTX8/wkI6C7SyffkaOQmGA5+eyFY3FEgm3t9mrjatRbg8/XOyJ3RV7VG +L9wVmnTzr9KqLQTlHuJ7PP/OYz6KjvYewIgB854mWbBEnE0di5459n1YXOBMQ8Qq +5bTLgEdhBnVVrvQP0OnpYSOSDrosZZD8Ui/nIPITcAcLV3Trukd6+mFiAmaIBuqk +iHA8PCRUbNdyIU9CXvYoEnTCTtndunaxuW53+5gYwrqCgnBoF12cOjfVrdZ6yPPj +3bQzq3sPOChyGV+sctyHCrjv9OLBhQLa3kWPoHQ5njYwB1ljClza2vGRfZP6iA19 +r0hdoJ3zGnsVzYdA3sGfN7FrHF0+NOjrIzlXwaGtqaB2+6UP/D+ny7MbXD+xxGR9 +J1WI/ZDCt7K2VrRfABEBAAGJAbwEGAEIACYWIQS/a8/InpB0e5poD9e2Ap6FAPfb +FgUCYHDldgIbIAUJEswDAAAKCRC2Ap6FAPfbFniYDADw1qk5wBlcPrWEm4uOoQdV ++19ksy8mojZP1ZyNcF0HsJGSrT99q/McmbL4nFw8djbKeOmlHPY7oYCecFKMfwDE +od24qLqrB8y6MKoJ1BFSTFzOi3IcB5DsVjkU9PDjWJafa+vBRYxeZOT9c2Usr0uz +IjY2YC/9wlJ7Y3XTqYxXs+KadSe8LM3wZml8KO1U6j6qnS6RaSH5qev0WESsRvw5 +opdjpf0CWck38Wd/NHexoIjZ9Rx9KhwmjNekQfZ6eMohyLlRQZK64tn7aU6BQSGn +DjSX01lUazpIANTT8PFJkCLKeI2f0hlzj3PGo5MxeXqVr/nDlCKj3xOYKTejOosd +Zyhl50EohNpaAdH2wsTIJkPrlHkH0+6kiSq6UhVmmYBSyn0uu1drbQpW1zKYKWKA +V3r8rTS4nIZ5VNMUFOk3wdXtEsWfLfeJnY/nUk5Ydpnt3L6N9buY/QiPMa2hxfr+ +kpuJL3rX2rek7uUso69BycsdLpIjq/oqTpvOJ8BdhS65AY0EYHDldgEMANx+SPfP +UucO5f5EIjmm0vrJwLbNU8hSGvNh/l+MYxHzCWZneVzG6dQkuz7W0XdiZitXOq0B +ayviEb3bdV9P5douPQw04kbvtdvgFdEQxLdZHHhCwTdHoHm0Wmc7sCgo9c0YK/j6 +eS7Stway7WRYCsn0uC+j7O7UB00LStcMAYGMx5ia8weXrsh9bCpbnlaQwRCey451 +ybVnz+sgm2XdsK5DnlyCnOLmAFDVwZUgO1Imx+vnLWwemPBBoLioqONu/CAw+5iN +1ErDOckPRT38w8C/s1AWuYsCdEf3LpHTGr/wKF4ZlJYzQrXH5L3tl9k/Zqq+XoT5 +ENPMMNRI4Nvk1bfJn2RBd+csDiyxOFKoz20D4jWJNrgRiMH2gpWkDOcmAG6q9/hO +lKLhrgAkOWbwu2ilJLcCt5Rpeh7OiU+2oZcwk8n6+xltVIUsZ1KYCS4QnSk00pgu +or/Bjnt+9eLBxPL7rnQ+Cw2/9rePnuPdNDMiTAWSgu0mro5fA8D3b+ZPhQARAQAB +iQG8BBgBCAAmFiEEv2vPyJ6QdHuaaA/XtgKehQD32xYFAmBw5XYCGwwFCRLMAwAA +CgkQtgKehQD32xaecwv+Ovygd9Xzr2vaE+OILUPJI47iRO1VyrrMzgtJ/s4UoQLt +mdoBiRs/hlyehRijcwrxo6zjQujDfVlcaQLGeAUZifhoY10StOx79O3Y+XEJBvDh +u+vk1IXiCDqgne68FgNDa3NY4yZiQFiTlaTAXSiKfh95A2gsLR51nR3TtvP0q/60 +gETx13PqFaIIHH+IlIk/m5qkNB/xpx89HLw9dxLRIbGsCz/l6L64oQ0QYDNdLZgn +KP5fiO5LbpuQCaE8xH8K6hsTGd5/qRKSXsEGBkbirhrmD1wZlwOa6Q6DMv6HnkrO +sBzzFWkt12GZ17Yg2NKmYOywHn2xYlSo1j4gvmWFtA6XYRKypesoyEa5hwudLU1T +ohOmbuquUSSjfvK7vtB8MVlygl5urIJX3PrhY/zphuBIGc7JF8dsmOmi4HOSMgYb +Mvm7RZeeonaSLi4i1D3Io8DeEhLHeSI9pS/eC+gQEdCRrnw4iagzbmbP3BjZAj1X +SIfpOVVFKKBgSMEFabOemQGNBGBw5l8BDAC8lgqz3vFfNydLCvKYpm2+ZnBk1wTq +lYN6QTD3CIXJnpa6B+nCNfgozuQWJ8gUwKUykcgeEmJxL6J+XYjAnwDxPlfzbJHK +HPS0ruFzFuY5xP2o/ccl3NoiiusKjBHLWOZXf/edtnl8wEssDRL5tKuf8W0eqkdA +CST4KC8nUCnGcdac4FAddZANnxSrCal1tyGH52wm8ZobxUJjW2OiW/Km9o5QlsTL +aWoHnPuoGHPAVZ8q+dMghUqrcna3q181IQ7NFseVZ5ALQaXNbAUjZU0k/hHt9kD4 ++puT8X0zWRe/JTXesfI6kA7yiH8M8wC8S6Tx4yQ8XVpEAUShnoO00+9Z/0HAwgEG +N5sLdUXPejijb0ZEI6X9WyxfuKeho8Ii3mJF8ENEP8Htf1KsoTv+rjtZ2YNkFZHb +TbZ2IMT9K3j1usBvk4xCV4vz6oQNB0MLN2eaM4Gd1MmIMlZof7Dsq1QjJKeCekA4 +X93r0lRt+4DCqxCYvLPcOCIf7c+Eas00l8kAEQEAAbQnRUZGIENlcnRib3QgVGVh +bSA8Y2VydGJvdC10ZWFtQGVmZi5vcmc+iQHUBBMBCAA+FiEEhjebTwrzcbUM2eX/ +NAKDEWHR0oAFAmBw5l8CGwMFCRLMAwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AA +CgkQNAKDEWHR0oCUPwwAicymSTg2aSfGtzi8y/vBLegqhylO6bJBmlRm5CfKODG9 +xaZX4ZHGedP4SouTBCZ7qK6zaalsevsVHy8+Z+QHk/WmmxUJ0zr9ChKrrdJB5NcE +roqCyF4zkRP1Oq/2ItNHZFpl2ZLVgFlogv0VOp519RHg9InwDMEBHXT92kmD4V4B +9tMeQFcFClz4psDDC3iTK8qApddDr4T3q0ER5DopzXiv6Dw6o6vVgqFIoacaUxAo +7g4xIfdx+PIpIKpptU74D0qO43+hv6FAEubj7Jk6CJAVXUlaU/yMBRb39tlAVKzj +fi3+qqTNMAjws6WuuiynxjaOCkE0AAf+97wV+4VhRMvqs2aQgN9ZJ0TgQOZaCMjZ +vSLIFlu0cniHsHGQBtCbw5IMNAUkGk9N1kZWxoxpwauxoSmSJcnbp62xDTOSA+qP +PjSvq7uihwsvzpidC8M3XjwYofttSNSRmrhTfK8M05VUrx97f9NyewI4JKUBIjE7 +ePWISdS3Uzpc0KnveWN7iQEzBBABCAAdFiEEos+1H6J1pyhiNOeyTRfJlc2XdfIF +AmFCQZUACgkQTRfJlc2XdfKVlQf/YjZmoDfGqgx+h143kOTX+ISwsoLpsmG1wJX4 +mjwXc0AAYWamTthbxBAS9/oSct9nvY5CtwweNVgOFYLKmYkDnq0n+P7AnxO7hZ9U +syVX5ybecZx++qCA8P8JIgkXsImzSVUwlIEJk1bVEyOyChHd9P5DS0g0ALL4MEVL ++iGyKo3hJT4s5NHXyiV6yczejwQaJm4S6C70BJAHA8NjOyg5EjX1GQ5x8rQySHwK +b1Ih7q40J0qZh+EfJz2atVmkFgCUDoin+ZOx8acFUcdJSzkTMtwPrEwp2Ukj6GWv +Bj9/Jv9ZDzDSZPeas9Qp5+eKP8lb3+DPKMb9Mh6mmDNYB13sy7kBjQRgcOZfAQwA +qBoFoefw28hFD9YTjQ1+YFKDTZcBV6Rjhkh2NXjyzA/RiC1qH55/eAMOCWF8QBts +sUVkSH3XZhLm21LOwThtJTHSGedUkKhSuiuWNkxpVMkoHvwexGYjHupVy63VhRqA +5AsutB9tYKcR8j43Ac2nrc7UdSi2uCjG7Hv5MVEcekBfc3z9b+cSkx4ievtEBoKK +JGcNryULAqGnyxyEvl5DUe91jD7ztXd75RFcpbC7cKX/i7GMDaC4LX985KRDuvvU +NQ/gLuOgiO5j96MxwoPTTWIc9grmuIT2uSz30r835PcnxSxry4cWt99COhnBBe6a +cJWR9ETbp5Y7upcACg3qpsnxBYw30AaGhbPIOoXD8UVNVWehWcE0UZT1ROgrGQqA +O+KVu4NR7E6os+EOSmO1MU+4cdm0cSaeE5snb5v07wov+VoMdi/xUd7L4LOOHRTq +6hVWibeToJGG5Tm7B/KL/qpf2sam7t+UYO2rnjBJbroQdhusVGCLMMNqL7Rhr0UH +ABEBAAGJAbwEGAEIACYWIQSGN5tPCvNxtQzZ5f80AoMRYdHSgAUCYHDmXwIbDAUJ +EswDAAAKCRA0AoMRYdHSgCqvDACFL+bXOovoROYdhHTl9iU51NvjQD4Ir8gWFJNT +tLtFdb+sHbm/z1V3/JLuFMVpmtlrjoF+FB3NzLf75usonjWjr0ybYhIfaciwcooK +6pQYGvQzlDTvjWsm5gI9oHDYTPiJaloDLUDS8ULW6Ep8tEvStqlvR5ae2IWrpb/v +F9knBhQxi1XKWa8cClQMHeFYjFVI4eyMTLQGz3sAgynWdZ/buSflztf+AfsonJ1T +iyvykrD8O3CHmEY/5Lzx3tiEqwiD13XfnCQNDzRlyEvytodnMPZz0DQluggNhV3O +X3hcB4wNhEtVCmxpGmjkTgUrbvy03Jqo+gr3lRpJmDhJ+UphKdH/5AsYRbG7aMlZ +7AwPvc2f073W+eWWjFX2Jqht6MVyXN6ajn+reJRrpCebnJTGcqTg7wcvHgceoVvt +5Oy6RsMmtPfFiqBICKAqgXU3Pf1OBWeCMM7NNhXbK+DLTKk2WkAZDjrpCf07li7C +NDYayipiZe7ZHAi30sov/2LNIXu5AY0EYHDmXwEMALneawKCc9k06FxY7Wq+RY/j +wSyF0cTudBVupX71bS7yzlaQN5TNcVKSVwqivq3i/WProQWLhAV2qSL0IYPCRZiQ +EqLxO/4dWI4Ag0I+HQY8DWnnMFw4yRScafcuY2zkVg2lBBlYiFaZmIGjdMF1Dr5I +lFX6Mt+142p1GUTFOk3jo/3u2QL53T/7Eq35eWhWs7vaQzt4KoivGl4y6zPsUBNL +QQBmgvKKliaUmkM2FFjVVR6jYl9qQ9Y2aO3E1NQyZ4Jmh+7Apf6mXdVZoj+uuHLc +73MBgDn6F5UJ9Zryt6ZgUJqOR75CIcWKccT0k57khNHnn+pmWvk9hsM3wmc0P3oy +yY0WpUSOEPhQjcOHd0OwhJ/jjtGmMdfCSzc5QmkbDDOtEP1TE9oOF7KzBBb9i4ZV +wVLQfL7e/UcIuk0ZGA2MG+blH6GXMtTlF8i0DaO1uddSev4SsCOD5svOWyW4aslR +9s6z9ETUqYegmh0bmdLL7haRhOkTmaSCRc8t9H4BNwARAQABiQG8BBgBCAAmFiEE +hjebTwrzcbUM2eX/NAKDEWHR0oAFAmBw5l8CGyAFCRLMAwAACgkQNAKDEWHR0oAd +sQv+Pt41dwQYURCzONUsmc8o68e/joPRmiaZvWCUtdaSejqwwfC7XVyE98KvcGxI +gWBCf+tVb65E6Olg0B+CFFNG35DENssLSB+YVqtHzyy6M6H4CXFakm6ieInW+iYX +qdutArXnMtLwGqNfd7ZxGeKxBacx3/f622uTwdzvxoW2cCka7fyET3MwtFLUJGWw +E5NwFQeMSFZHKMXXZTPHQkHFZXjdyBr7LbSThhuSpIwGV52EXfCsciMa7LD8ZDR2 +Ek1NqhAgZ+zx3Ds8EEdaBxn4H4k4q6r8qTKKJJQipN5iRjdxa+NFClddiEihbi0H +++dXukPPzmYkr5enziYhf0B1UyJ365VawtCz5/WKeoZBJ9r1bGmJerzDqbs8yfJX +RfvMpWZKynuLpHv4Qa7E8u5swKFZjsB1sPEvabEfj5gz6pxV5FQ7KfJS1A2MKMoa +U1taxO7t8B+cz2UPVK05hSZHWrb5FCJ/dqyAr8Pn0Dy5Sebvn0XE4VQmZAjuUQJE +Jd6jmQGNBGBw52EBDADuieMX+hnF50SFU7UbQ2DZQty1Qd5q9UP/XOOauItD70CN +XLOvHT/L0IHfov15YxCUToKJMJkG86EOd53A79RxZ/hClG+MlaUO7d6LwZ7XW0Wk +BCt/ybBQR9/kgL9EhfE9d9iYiZPlE0A5JQvEfAHFBnWIZIWQMIvmbtFUrOYtb55l +BP3bpapUNjgqTX9h400DR7LZ27W5wkHXwyMiY6hbwtUkqJ0LlmlGqgo/BRurBtHF +uvfwHtCPqmAI3ebS8V7eb9T2zCZW5CO7VbGSEb54y5LNW947jmv52FQtn4t2SzO0 +wtND7i4svVR3HLPeAxA+ChZhw/ZAg0CfM4D7b8s51fIGZ7Zp4TarN7E2mm++Hf/y +PTCfaIEsoR7UKaJL9kXXv9QCatcwERfOgJo2zENAmo2U0SzHLvRD7PhY1AwtEZdz +yCHcpKN6CnDV8YGE5iPQcNVT0SGGlo/l3SRhh8tfwnK4Wkk0zy3nBYoiFUhP3oas +Ppm87OorvzVbdBPNW0EAEQEAAbQnRUZGIENlcnRib3QgVGVhbSA8Y2VydGJvdC10 +ZWFtQGVmZi5vcmc+iQHUBBMBCAA+FiEEIPIBNGv48/RVpz+aeAzJlDKihiEFAmBw +52ECGwMFCRLMAwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQeAzJlDKihiFA +ewv/cNmCh4NRL9P+VjfKhio6+MsZ5UHLQJPYk6ocQQc+JzF7GRm9UjY59mKJfgF3 +yzVkF1tQ9MMI5sXd9v/RvE2tFre4HRXPC9OjdsyObX0hH6zVJ0vvkeopAyNaNhIy +uC37SmlSM1g0QQYzVZw+mbA0pbe8BmtKnSjMZickKZ/lpsVmoPUcb7v7KrSGXgol +/JTftl92hSgAm5ba1qSzwva1FiQYiSyiDk73cbgpMH1ZT08tU97VVwMRBQr6tMF5 +P8IN0CfqpO/ANtJNVs6ftPesmkA42tOZwBhwA/TNlzrdwCfu93E5vjz9b0oV6SM/ +uA5KQzp3bTCouKq9EOHiS4gManvBUpthtILUKJDgZeOd+giL/bXzvozpZ+Nq4YXt +wmTJKWDJX9+iK5PZKKmTYZ3oKpT2hoVSrbWouNUEQyUragPHO+GfFVBtH5tijC2r +wNiqa0KlO53nlZwxUERJ67WEe5Nlq81stGuyIirGchVF4qPVAVS1qfJVqLS2DKdm +BuT0iQEzBBABCAAdFiEEos+1H6J1pyhiNOeyTRfJlc2XdfIFAmFCQZ0ACgkQTRfJ +lc2XdfIwXQf6AynYl1bs2ajXA0lqtsGs/HuJ8yKprWyozpZKUBcj4IRhTNyGfXFt +7RF56r3ENdqFwzM7X4rIkPDFMvjYccE6EY9sGS22ZyxN0BvujfqKq3jVL0ybtp6U +eKb1pXJTHvhgTr43IOUxH/HM7rwfoTuy06/vG/vAzNWY4T3Jr6SKXlgNsbhhJ0hJ +CubUdcfYuLTiDGPCD28LNLbiibmRudq2+3jbfcW63nk0NHYpUUGtgpItODsaUTBo +XOsUcJCG6vLj86KkivbhX1y0zArnyDdNGz5rAdf3OP6aCJxxeTTlpC0OVcziEvto +kM/DAa74UAmZi1k0w9QTXHdCWxgBLifrerkBjQRgcOdhAQwAoHJcJqNI9uU/eSXq +7UoWe3CzCd1TEKWKAWBWZfiJKGE0vFBym8pZdy+UxY/v+PeKFopYdgHxZmB8SCC/ +ZyK1z8cJoUmRp/Vs5cXAVGO2tzy6md9ix3F63vtSgV2JRjl8dSuhQkohZ0Jbu5s3 +bSVI4e1ayzq6hBxUmXoceih2QtIwFkvV/1In9wBJn6tRf0ZaMt5V6bQAqT1oTR4b +hZQgHFXOhouyPAOSTgEGz5HsTuVu5Bvi9W6w868GZxwsfvoiRPnFBaukkpdSsJmF +FJIFtzT3BU7U3ucJPWTvJKlSyuo5j6vfP3YfblSrmFo7WKsLcE0gYzjzRU+3kuFw +mR26YtsXEngOOtVYLaay95+ALZkpoUpmOoN0AVIWxURN+9Pu6lMYB2tok72mtlju +y2gGQluYMHQvKXmdRVraKvcoFCdK4Qc/djnNm5kZUVwrUPApAQqjnz6qrxBadNnh +5EQzEGGCYLRRfX1YP4alfmSp7CZGLMziagA9wXIABmtCOG9BABEBAAGJAbwEGAEI +ACYWIQQg8gE0a/jz9FWnP5p4DMmUMqKGIQUCYHDnYQIbDAUJEswDAAAKCRB4DMmU +MqKGIeBHC/0Ua1QV5lmKzgtEURh1qvPmLSJSEPgxH7lZqBhAh1Vf4VajQUHKuVLo +hC+8ZMyeBN/qSJBILnNfUvcj9j7M6cWdygSoG74P+EQsotaQX1ZPEm+M7WVEaDhJ +oC+SEgVTKZ/Qo5C0gstC78XyQ30gxN/Zpi+1/NB46oQpDW7tqFo1BkGylly/ekA4 +JGCqTbfd4PeYPvYf8JDaBjLZrTukYI1wan1OPqn2qfOvu5QYp1eXATF6RAAKARd8 +PxloyrAx2lujdkhNZmBzGPBsAyye89N8g7571U773G198WkwSvx/OS1jmO64vnuj +NUdKyiODyLjfwlwGWQ24bE772I1CMbSPJXBuw3MMD4ZzzqZg5SIW66ie1ZfJGIRi +I6WOBV41Za+4fWpGNz7Rb9Le7cPVeTQ9ogJtSkI5Z4/1CKw76dd074lm1ijg2cx4 +UVnY6tkfx+SWPi++yq3d657QqBleFqgoU1TsfUW860sC+qYztTioqrgiUU36FJrw +OZ+x8dyZUpq5AY0EYHDnYQEMAOnjmDjUimw8R5u8CY4sd61PEBI4Y8c6c72/W+UN +dBM49ye6BEeMoJ1qB4Ojh9lOW5Ba78oh+FWp0o5DbPQntn5ye3SAPLxIZ9//+Vr8 +s/YKOW4CjtPJbqxe3Ie98uQ0ZAKxOWTWXMwFbFRF4Qt+fu1YD18pBxEuZeL9LSJi +QDflMYG50+/LQSjT9Yiae/AeG4eW994todq22zgGwJ/vNLvu/vSZ18ojzNS1AH3r +wMIrQlEue9AA5swblqeYli7Ac8VfHsxxwof4jWi84+UMxR+hotYISqLKFJOzz7Qm +DdUWhrfZLukRTsil7vVOYVuXidMRB3mvgbTcEuZgE0LpVXGYqczVM2rVhqMbQTS3 +oU/wxSsDTdABsbCH/68sK+4kiHg+Av1j6WXco3k+EAuwDi5szOE9AzkPbJtbEe1e +mnWqCAPks8Xso/9PVJDJbHUudFR4aphFUrPSrRKplVyQRAUyB4IuyQGaLbvEIxYP +4fTlBrPObjkfHfMyoxKh6aKOHQARAQABiQG8BBgBCAAmFiEEIPIBNGv48/RVpz+a +eAzJlDKihiEFAmBw52ECGyAFCRLMAwAACgkQeAzJlDKihiGIBwwA3qyiuZ0jfnjH +vMFqYA6egpQYMDaTGrLlT9mPqAZYwNZjwWgidOlB7553br6rFVhJQoI5otKJSMkB +jCurFXNOeGSV6WQHxzyyMSdxpku2v/vDgVmfZ36HH+gdnRxknA8CBJPqbS+nFX/1 +fJ+Lq+6jrIxfcEozkgvhUfdDO1y3yjdBlTo3u/Xas97ABQoYVuGZ0Fq5IAkly55b +hDyGoQm9azfhWNdBfBOlgApfJvhNkwJkNO405j+R0d+1GkOTvan1Q1QsmEfUzOy4 +8W5a1zpKwMsAtWsH+PkZKcV66G4WQkl5RqoEy5EGIVLTzJw+Gu/7aw2wuU0kuzXw +SfiAwHvQ/ZWPtBvLqpJFrMwxirUHqPDJZ5XpM14JhTKXDU6rz/4AbY2vpD4xYjkc +0v5r3IMHDuL8ecjpTyAt2qIvCoul22ssUpE2GCfWb+1kR7NpDb1NwclQchYaqjjY +x0lQ0awIYHf+s5wzhOXOOI8jnbPevfdE1ECiw5T4RBpomy2pSrBs +=wDFT -----END PGP PUBLIC KEY BLOCK-----