Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-acme for openSUSE:Factory checked in at 2022-05-30 12:44:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-acme (Old) and /work/SRC/openSUSE:Factory/.python-acme.new.2254 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-acme" Mon May 30 12:44:29 2022 rev:58 rq:979811 version:1.27.0 Changes: -------- --- /work/SRC/openSUSE:Factory/python-acme/python-acme.changes 2022-04-08 22:46:16.478768940 +0200 +++ /work/SRC/openSUSE:Factory/.python-acme.new.2254/python-acme.changes 2022-05-30 12:45:28.292511999 +0200 @@ -1,0 +2,9 @@ +Mon May 30 09:04:49 UTC 2022 - Mark??ta Machov?? <[email protected]> + +- Update to version 1.27.0 + * Added support for RFC8555 subproblems to our acme library. + * The PGP key F2871B4152AE13C49519111F447BF683AA3B26C3 was added + as an additional trusted key to sign our PyPI packages +- Refreshed python-acme.keyring + +------------------------------------------------------------------- Old: ---- acme-1.26.0.tar.gz acme-1.26.0.tar.gz.asc New: ---- acme-1.27.0.tar.gz acme-1.27.0.tar.gz.asc ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-acme.spec ++++++ --- /var/tmp/diff_new_pack.LMtYMM/_old 2022-05-30 12:45:29.008512952 +0200 +++ /var/tmp/diff_new_pack.LMtYMM/_new 2022-05-30 12:45:29.016512963 +0200 @@ -20,7 +20,7 @@ %define skip_python2 1 %define libname acme Name: python-%{libname} -Version: 1.26.0 +Version: 1.27.0 Release: 0 Summary: Python library for the ACME protocol License: Apache-2.0 ++++++ acme-1.26.0.tar.gz -> acme-1.27.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/PKG-INFO new/acme-1.27.0/PKG-INFO --- old/acme-1.26.0/PKG-INFO 2022-04-05 19:41:33.131234600 +0200 +++ new/acme-1.27.0/PKG-INFO 2022-05-03 20:33:19.934802000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: acme -Version: 1.26.0 +Version: 1.27.0 Summary: ACME protocol implementation in Python Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/acme/crypto_util.py new/acme-1.27.0/acme/crypto_util.py --- old/acme-1.26.0/acme/crypto_util.py 2022-04-05 19:41:26.000000000 +0200 +++ new/acme-1.27.0/acme/crypto_util.py 2022-05-03 20:33:10.000000000 +0200 @@ -120,7 +120,14 @@ def shutdown(self, *unused_args: Any) -> bool: # OpenSSL.SSL.Connection.shutdown doesn't accept any args - return self._wrapped.shutdown() + try: + return self._wrapped.shutdown() + except SSL.Error as error: + # We wrap the error so we raise the same error type as sockets + # in the standard library. This is useful when this object is + # used by code which expects a standard socket such as + # socketserver in the standard library. + raise socket.error(error) def accept(self) -> Tuple[FakeConnection, Any]: # pylint: disable=missing-function-docstring sock, addr = self.sock.accept() @@ -135,6 +142,8 @@ ssl_sock = self.FakeConnection(SSL.Connection(context, sock)) ssl_sock.set_accept_state() + # This log line is especially desirable because without it requests to + # our standalone TLSALPN server would not be logged. logger.debug("Performing handshake with %s", addr) try: ssl_sock.do_handshake() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/acme/messages.py new/acme-1.27.0/acme/messages.py --- old/acme-1.26.0/acme/messages.py 2022-04-05 19:41:26.000000000 +0200 +++ new/acme-1.27.0/acme/messages.py 2022-05-03 20:33:10.000000000 +0200 @@ -79,6 +79,55 @@ return False +class _Constant(jose.JSONDeSerializable, Hashable): + """ACME constant.""" + __slots__ = ('name',) + POSSIBLE_NAMES: Dict[str, '_Constant'] = NotImplemented + + def __init__(self, name: str) -> None: + super().__init__() + self.POSSIBLE_NAMES[name] = self # pylint: disable=unsupported-assignment-operation + self.name = name + + def to_partial_json(self) -> str: + return self.name + + @classmethod + def from_json(cls, jobj: str) -> '_Constant': + if jobj not in cls.POSSIBLE_NAMES: # pylint: disable=unsupported-membership-test + raise jose.DeserializationError(f'{cls.__name__} not recognized') + return cls.POSSIBLE_NAMES[jobj] + + def __repr__(self) -> str: + return f'{self.__class__.__name__}({self.name})' + + def __eq__(self, other: Any) -> bool: + return isinstance(other, type(self)) and other.name == self.name + + def __hash__(self) -> int: + return hash((self.__class__, self.name)) + + +class IdentifierType(_Constant): + """ACME identifier type.""" + POSSIBLE_NAMES: Dict[str, _Constant] = {} + + +IDENTIFIER_FQDN = IdentifierType('dns') # IdentifierDNS in Boulder +IDENTIFIER_IP = IdentifierType('ip') # IdentifierIP in pebble - not in Boulder yet + + +class Identifier(jose.JSONObjectWithFields): + """ACME identifier. + + :ivar IdentifierType typ: + :ivar str value: + + """ + typ: IdentifierType = jose.field('type', decoder=IdentifierType.from_json) + value: str = jose.field('value') + + class Error(jose.JSONObjectWithFields, errors.Error): """ACME error. @@ -87,11 +136,23 @@ :ivar str typ: :ivar str title: :ivar str detail: + :ivar Identifier identifier: + :ivar tuple subproblems: An array of ACME Errors which may be present when the CA + returns multiple errors related to the same request, `tuple` of `Error`. """ typ: str = jose.field('type', omitempty=True, default='about:blank') title: str = jose.field('title', omitempty=True) detail: str = jose.field('detail', omitempty=True) + identifier: Optional['Identifier'] = jose.field( + 'identifier', decoder=Identifier.from_json, omitempty=True) + subproblems: Optional[Tuple['Error', ...]] = jose.field('subproblems', omitempty=True) + + # Mypy does not understand the josepy magic happening here, and falsely claims + # that subproblems is redefined. Let's ignore the type check here. + @subproblems.decoder # type: ignore + def subproblems(value: List[Dict[str, Any]]) -> Tuple['Error', ...]: # type: ignore[misc] # pylint: disable=no-self-argument,missing-function-docstring + return tuple(Error.from_json(subproblem) for subproblem in value) @classmethod def with_code(cls, code: str, **kwargs: Any) -> 'Error': @@ -135,39 +196,16 @@ return None def __str__(self) -> str: - return b' :: '.join( + result = b' :: '.join( part.encode('ascii', 'backslashreplace') for part in (self.typ, self.description, self.detail, self.title) if part is not None).decode() - - -class _Constant(jose.JSONDeSerializable, Hashable): - """ACME constant.""" - __slots__ = ('name',) - POSSIBLE_NAMES: Dict[str, '_Constant'] = NotImplemented - - def __init__(self, name: str) -> None: - super().__init__() - self.POSSIBLE_NAMES[name] = self # pylint: disable=unsupported-assignment-operation - self.name = name - - def to_partial_json(self) -> str: - return self.name - - @classmethod - def from_json(cls, jobj: str) -> '_Constant': - if jobj not in cls.POSSIBLE_NAMES: # pylint: disable=unsupported-membership-test - raise jose.DeserializationError(f'{cls.__name__} not recognized') - return cls.POSSIBLE_NAMES[jobj] - - def __repr__(self) -> str: - return f'{self.__class__.__name__}({self.name})' - - def __eq__(self, other: Any) -> bool: - return isinstance(other, type(self)) and other.name == self.name - - def __hash__(self) -> int: - return hash((self.__class__, self.name)) + if self.identifier: + result = f'Problem for {self.identifier.value}: ' + result # pylint: disable=no-member + if self.subproblems and len(self.subproblems) > 0: + for subproblem in self.subproblems: + result += f'\n{subproblem}' + return result class Status(_Constant): @@ -185,26 +223,6 @@ STATUS_DEACTIVATED = Status('deactivated') -class IdentifierType(_Constant): - """ACME identifier type.""" - POSSIBLE_NAMES: Dict[str, _Constant] = {} - - -IDENTIFIER_FQDN = IdentifierType('dns') # IdentifierDNS in Boulder -IDENTIFIER_IP = IdentifierType('ip') # IdentifierIP in pebble - not in Boulder yet - - -class Identifier(jose.JSONObjectWithFields): - """ACME identifier. - - :ivar IdentifierType typ: - :ivar str value: - - """ - typ: IdentifierType = jose.field('type', decoder=IdentifierType.from_json) - value: str = jose.field('value') - - class HasResourceType(Protocol): """ Represents a class with a resource_type class parameter of type string. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/acme/standalone.py new/acme-1.27.0/acme/standalone.py --- old/acme-1.26.0/acme/standalone.py 2022-04-05 19:41:26.000000000 +0200 +++ new/acme-1.27.0/acme/standalone.py 2022-05-03 20:33:10.000000000 +0200 @@ -153,8 +153,11 @@ certs: List[Tuple[crypto.PKey, crypto.X509]], challenge_certs: Mapping[str, Tuple[crypto.PKey, crypto.X509]], ipv6: bool = False) -> None: + # We don't need to implement a request handler here because the work + # (including logging) is being done by wrapped socket set up in the + # parent TLSServer class. TLSServer.__init__( - self, server_address, _BaseRequestHandlerWithLogging, certs=certs, + self, server_address, socketserver.BaseRequestHandler, certs=certs, ipv6=ipv6) self.challenge_certs = challenge_certs @@ -303,16 +306,3 @@ return functools.partial( cls, simple_http_resources=simple_http_resources, timeout=timeout) - - -class _BaseRequestHandlerWithLogging(socketserver.BaseRequestHandler): - """BaseRequestHandler with logging.""" - - def log_message(self, format: str, *args: Any) -> None: # pylint: disable=redefined-builtin - """Log arbitrary message.""" - logger.debug("%s - - %s", self.client_address[0], format % args) - - def handle(self) -> None: - """Handle request.""" - self.log_message("Incoming request") - socketserver.BaseRequestHandler.handle(self) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/acme.egg-info/PKG-INFO new/acme-1.27.0/acme.egg-info/PKG-INFO --- old/acme-1.26.0/acme.egg-info/PKG-INFO 2022-04-05 19:41:32.000000000 +0200 +++ new/acme-1.27.0/acme.egg-info/PKG-INFO 2022-05-03 20:33:19.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: acme -Version: 1.26.0 +Version: 1.27.0 Summary: ACME protocol implementation in Python Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/docs/jws-help.txt new/acme-1.27.0/docs/jws-help.txt --- old/acme-1.26.0/docs/jws-help.txt 2022-04-05 19:41:26.000000000 +0200 +++ new/acme-1.27.0/docs/jws-help.txt 2022-05-03 20:33:10.000000000 +0200 @@ -3,6 +3,6 @@ positional arguments: {sign,verify} -optional arguments: +options: -h, --help show this help message and exit --compact diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/setup.py new/acme-1.27.0/setup.py --- old/acme-1.26.0/setup.py 2022-04-05 19:41:27.000000000 +0200 +++ new/acme-1.27.0/setup.py 2022-05-03 20:33:11.000000000 +0200 @@ -3,7 +3,7 @@ from setuptools import find_packages from setuptools import setup -version = '1.26.0' +version = '1.27.0' install_requires = [ 'cryptography>=2.5.0', diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-1.26.0/tests/messages_test.py new/acme-1.27.0/tests/messages_test.py --- old/acme-1.26.0/tests/messages_test.py 2022-04-05 19:41:26.000000000 +0200 +++ new/acme-1.27.0/tests/messages_test.py 2022-05-03 20:33:10.000000000 +0200 @@ -17,7 +17,7 @@ """Tests for acme.messages.Error.""" def setUp(self): - from acme.messages import Error, ERROR_PREFIX + from acme.messages import Error, ERROR_PREFIX, Identifier, IDENTIFIER_FQDN self.error = Error.with_code('malformed', detail='foo', title='title') self.jobj = { 'detail': 'foo', @@ -25,6 +25,9 @@ 'type': ERROR_PREFIX + 'malformed', } self.error_custom = Error(typ='custom', detail='bar') + self.identifier = Identifier(typ=IDENTIFIER_FQDN, value='example.com') + self.subproblem = Error.with_code('caa', detail='bar', title='title', identifier=self.identifier) + self.error_with_subproblems = Error.with_code('malformed', detail='foo', title='title', subproblems=[self.subproblem]) self.empty_error = Error() def test_default_typ(self): @@ -39,6 +42,14 @@ from acme.messages import Error hash(Error.from_json(self.error.to_json())) + def test_from_json_with_subproblems(self): + from acme.messages import Error + + parsed_error = Error.from_json(self.error_with_subproblems.to_json()) + + self.assertEqual(1, len(parsed_error.subproblems)) + self.assertEqual(self.subproblem, parsed_error.subproblems[0]) + def test_description(self): self.assertEqual('The request message was malformed', self.error.description) self.assertIsNone(self.error_custom.description) @@ -73,7 +84,11 @@ str(self.error), u"{0.typ} :: {0.description} :: {0.detail} :: {0.title}" .format(self.error)) - + self.assertEqual( + str(self.error_with_subproblems), + (u"{0.typ} :: {0.description} :: {0.detail} :: {0.title}\n"+ + u"Problem for {1.identifier.value}: {1.typ} :: {1.description} :: {1.detail} :: {1.title}").format( + self.error_with_subproblems, self.subproblem)) class ConstantTest(unittest.TestCase): """Tests for acme.messages._Constant.""" ++++++ python-acme.keyring ++++++ --- /var/tmp/diff_new_pack.LMtYMM/_old 2022-05-30 12:45:29.156513148 +0200 +++ /var/tmp/diff_new_pack.LMtYMM/_new 2022-05-30 12:45:29.164513160 +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-----
