commit 5f7464ef910fdff6ed2836fd1663e58d6aaf5813 Author: zyppe <210hcl@gmail.com> Date: Thu Feb 29 15:53:34 2024 +0800 Initialize for libtasn1 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a137661 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +libtasn1-4.13.tar.gz diff --git a/.libtasn1.metadata b/.libtasn1.metadata new file mode 100644 index 0000000..1fa484c --- /dev/null +++ b/.libtasn1.metadata @@ -0,0 +1 @@ +295e18f117d3ebc8dbb7cc396f47157a144a18dfcc49a68997b28def6be8ad5f libtasn1-4.13.tar.gz diff --git a/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..714e14d --- /dev/null +++ b/baselibs.conf @@ -0,0 +1,2 @@ +libtasn1-6 +libtasn1-devel diff --git a/libtasn1-4.13.tar.gz.sig b/libtasn1-4.13.tar.gz.sig new file mode 100644 index 0000000..d1763c5 --- /dev/null +++ b/libtasn1-4.13.tar.gz.sig @@ -0,0 +1,11 @@ +-----BEGIN PGP SIGNATURE----- + +iQEzBAABCAAdFiEEqBLL/fzcTQvnoJMSnV6q9pATuEIFAlpeOtEACgkQnV6q9pAT +uEIWNAf/YnmT4u3ShAfhUKE4sIap+8ivG5AxCPw1Rwgwc8qcS2VKOVeiwYTWmt9t +g5CDrVu27DTPbCkdS7sTKrHQT3Pjc2DRJWHJbaHr5J717sNp50XWWXjNyZGrmyN4 +ais1d7no0GMXRsR6SUOFi+M52Q/vWhhYz4gaDAV9XSOqbJ6MPiw4BhjqyVSQ4lwD +Lfn4upk+1JFjzCpVft7iXrx1P4RXvFJC1sBYpUJAbdm9y0rO5jGiY7EHokDNq1rT +71hBWUclo37GsJnF65CRD1Mb5/wdZxm2wvEL/SFlHKqnY/uB3y4u7il91fi9zrwY +mDmVimu7E563pqum16000pybZIEmFw== +=LTAv +-----END PGP SIGNATURE----- diff --git a/libtasn1-CVE-2021-46848.patch b/libtasn1-CVE-2021-46848.patch new file mode 100644 index 0000000..a3f7e4e --- /dev/null +++ b/libtasn1-CVE-2021-46848.patch @@ -0,0 +1,12 @@ +diff -Nurp libtasn1-4.13-orig/lib/int.h libtasn1-4.13/lib/int.h +--- libtasn1-4.13-orig/lib/int.h 2016-09-11 11:53:52.000000000 +0200 ++++ libtasn1-4.13/lib/int.h 2022-10-25 09:40:21.061918424 +0200 +@@ -98,7 +98,7 @@ typedef struct tag_and_class_st + #define ETYPE_TAG(etype) (_asn1_tags[etype].tag) + #define ETYPE_CLASS(etype) (_asn1_tags[etype].class) + #define ETYPE_OK(etype) (((etype) != ASN1_ETYPE_INVALID && \ +- (etype) <= _asn1_tags_size && \ ++ (etype) < _asn1_tags_size && \ + _asn1_tags[(etype)].desc != NULL)?1:0) + + #define ETYPE_IS_STRING(etype) ((etype == ASN1_ETYPE_GENERALSTRING || \ diff --git a/libtasn1-object-id-recursion.patch b/libtasn1-object-id-recursion.patch new file mode 100644 index 0000000..0211e4a --- /dev/null +++ b/libtasn1-object-id-recursion.patch @@ -0,0 +1,122 @@ +From 9c40f7796c9d33179b602f65f4b587d175fba23c Mon Sep 17 00:00:00 2001 +From: Mike Gorse +Date: Thu, 11 Apr 2019 11:14:58 -0500 +Subject: [PATCH 1/2] _asn1_expand_object_id: Limit recursion + +Resolves #4 +--- + lib/parser_aux.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/lib/parser_aux.c b/lib/parser_aux.c +index 786ea64..08c2167 100644 +--- a/lib/parser_aux.c ++++ b/lib/parser_aux.c +@@ -675,7 +675,7 @@ _asn1_expand_object_id (asn1_node node) + { + asn1_node p, p2, p3, p4, p5; + char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1]; +- int move, tlen; ++ int move, tlen, tries; + + if (node == NULL) + return ASN1_ELEMENT_NOT_FOUND; +@@ -684,6 +684,7 @@ _asn1_expand_object_id (asn1_node node) + + p = node; + move = DOWN; ++ tries = 0; + + while (!((p == node) && (move == UP))) + { +@@ -738,7 +739,9 @@ _asn1_expand_object_id (asn1_node node) + p4 = p4->right; + } + move = DOWN; +- continue; ++ tries++; ++ if (tries < 3) ++ continue; + } + } + } +@@ -747,6 +750,7 @@ _asn1_expand_object_id (asn1_node node) + else + move = RIGHT; + ++ tries = 0; + if (move == DOWN) + { + if (p->down) +-- +From 57d6bc19d44b0693023031c6dbc0d21a36550f34 Mon Sep 17 00:00:00 2001 +From: Mike Gorse +Date: Thu, 25 Apr 2019 16:40:18 -0500 +Subject: [PATCH 2/2] Add reproducer for issues/4 to Test_tree.asn + +--- + tests/Test_tree.asn | 9 +++++++++ + tests/Test_tree_asn1_tab.c | 13 +++++++++++-- + 2 files changed, 20 insertions(+), 2 deletions(-) + +diff --git a/tests/Test_tree.asn b/tests/Test_tree.asn +index 0ad0dc5..a253bc8 100644 +--- a/tests/Test_tree.asn ++++ b/tests/Test_tree.asn +@@ -154,6 +154,15 @@ X520LocalityName ::= CHOICE { + bmpString BMPString } + + ++id-xnyTest OBJECT IDENTIFIER ::= {id-ix 29 1} ++id-ix OBJECR ::= {id-ix 29 2} ++BMPString ::= OCTET S ++} ++UniversalString : BY id O} ++id-ix OBJECT IDENTIFIER ::= {2 5} ++id-xnyTest OBJECT IDENTIFIER ::= {id-ix 29 1} ++anyTest2 ::= INTEGER ++ + id-Test OBJECT IDENTIFIER ::= {1 2 29 2} + + END +diff --git a/tests/Test_tree_asn1_tab.c b/tests/Test_tree_asn1_tab.c +index 7869f85..0f211c8 100644 +--- a/tests/Test_tree_asn1_tab.c ++++ b/tests/Test_tree_asn1_tab.c +@@ -68,7 +68,7 @@ const asn1_static_node Test_tree_asn1_tab[] = { + { "set", 1610612751, NULL }, + { NULL, 3, NULL }, + { "oid", 1073741836, NULL }, +- { "time2", 1082130449, NULL }, ++ { "time2", 1073741861, NULL }, + { "bol", 1073741828, NULL }, + { "oct", 1073741831, NULL }, + { "bit", 1073758214, NULL }, +@@ -81,7 +81,7 @@ const asn1_static_node Test_tree_asn1_tab[] = { + { "any", 1610637325, NULL }, + { NULL, 4104, "1"}, + { "gen", 1073758235, NULL }, +- { "time1", 16777233, NULL }, ++ { "time1", 36, NULL }, + { "SequenceTestTag", 1610612741, NULL }, + { "int1", 1610620931, NULL }, + { NULL, 2056, "2"}, +@@ -160,6 +160,15 @@ const asn1_static_node Test_tree_asn1_tab[] = { + { "universalString", 1073741856, NULL }, + { "utf8String", 1073741858, NULL }, + { "bmpString", 33, NULL }, ++ { "id-xnyTest", 1879048204, NULL }, ++ { NULL, 1073741825, "id-ix"}, ++ { NULL, 1073741825, "29"}, ++ { NULL, 1, "1"}, ++ { "id-ix", 1880096780, "OBJECR"}, ++ { NULL, 1073741825, "id-ix"}, ++ { NULL, 1073741825, "29"}, ++ { NULL, 1, "2"}, ++ { "BMPString", 1073741827, NULL }, + { "id-Test", 805306380, NULL }, + { NULL, 1073741825, "1"}, + { NULL, 1073741825, "2"}, +-- +2.20.1 + diff --git a/libtasn1.changes b/libtasn1.changes new file mode 100644 index 0000000..62a480f --- /dev/null +++ b/libtasn1.changes @@ -0,0 +1,343 @@ +* Tue Oct 25 2022 abergmann@suse.com +- Add libtasn1-CVE-2021-46848.patch: Fixed off-by-one array size check + that affects asn1_encode_simple_der (CVE-2021-46848, bsc#1204690). +* Mon Apr 29 2019 mgorse@suse.com +- Add libtasn1-object-id-recursion.patch: limit recursion in + _asn1_expand_object_id (boo#1105435 CVE-2018-1000654 + (https://gitlab.com/gnutls/libtasn1/merge_requests/8) +* Thu Feb 22 2018 fvogt@suse.com +- Use %%license (boo#1082318) +* Fri Jan 19 2018 kbabioch@suse.com +- update to 4.13 + * On indefinite string decoding, set a maximum level of allowed + recursions (3) to protect the BER decoder from a stack exhaustion. + (CVE-2018-6003 boo#1076832) +* Sun Jun 4 2017 astieger@suse.com +- libtasn1 4.12: + * Corrected so-name version +- includes changes in 4.11: + * Introduce the ASN1_TIME_ENCODING_ERROR error code to indicate + an invalid encoding in the DER time fields. + * Introduced flag ASN1_DECODE_FLAG_ALLOW_INCORRECT_TIME. This flag + allows decoding errors in time fields even when in strict DER mode. + That is introduced in order to allow toleration of invalid times in + X.509 certificates (which are common) even though strict DER adherence + is enforced in other fields. + * Added safety check in asn1_find_node(). That prevents a crash + when a very long variable name is provided by the developer. + Note that this to be exploited requires controlling the ASN.1 + definitions used by the developer, i.e., the 'name' parameter of + asn1_write_value() or asn1_read_value(). The library is + not designed to protect against malicious manipulation of the + developer assigned variable names +- includes changes from 4.10: + * Updated gnulib + * Removed -Werror from default compiler flags + (drop patch 0001-configure-don-t-add-Werror-to-build-flags.patch) + * Fixed undefined behavior when negating integers in _asn1_ltostr(). + * Pass the correct length to _asn1_get_indefinite_length_string in + asn1_get_length_ber. This addresses reading 1-byte past the end + of data. +* Wed Aug 10 2016 astieger@suse.com +- update to 4.9: + * Fix OID encoding of OIDs which have elements which exceed 2^32 +- Do not treat i586 warning as error, adding upstream + 0001-configure-don-t-add-Werror-to-build-flags.patch +- fate#322523 +* Mon Apr 11 2016 mpluskal@suse.com +- Update to 4.8 + * Fixes to avoid reliance on C undefined behavior. + * Fixes to avoid an infinite recursion when decoding without the + ASN1_DECODE_FLAG_STRICT_DER flag. Reported by Pascal Cuoq. + (CVE-2016-4008 / bsc#982779) + * Combined all the BER octet string decoding functions to a + single one based on asn1_decode_simple_ber(). +* Wed Sep 16 2015 zaitor@opensuse.org +- Update to version 4.7: + * Fixed regression introduced in the decoding of multi-byte tags + fix. +* Mon Sep 7 2015 astieger@suse.com +- libtasn1 4.6: + * Allow decoding OCTET STRINGs with multi-byte tags. + * Add asn1_get_object_id_der +* Fri May 1 2015 astieger@suse.com +- update libtasn1 4.5: + * Corrected an invalid memory access in octet string decoding. + CVE-2015-3622 [boo#929414] +* Sun Mar 29 2015 astieger@suse.com +- update to libtasn1 4.4 [bsc#924828]: + * Corrected a two-byte stack overflow in asn1_der_decoding. + CVE-2015-2806 +* Sun Mar 22 2015 mpluskal@suse.com +- Update project url +- Cleanup spec-file with spec-cleaner +- Add info preun and post dependencies +- Update to 4.3 + * Added asn1_decode_simple_ber() + * Only assign a value if the previous node has one (bsc#961491). +* Sat Feb 14 2015 jengelh@inai.de +- Put C API documentation into -devel package. + Use modern %%make_install. Description fix. +* Wed Oct 8 2014 tabraham@suse.com +- updated to libtasn1 4.2: + * Noteworthy changes in release 4.2 (released 2014-09-15) [stable] + - Added sanity checks in the decoding of time when + ASN1_DECODE_FLAG_STRICT_DER is used. + - Fixes in the decoding of OCTET STRING when close to the end + of the structure. + * Noteworthy changes in release 4.1 (released 2014-08-23) [stable] + - Corrected indefinite tag check in ANY constructions. That allows + the decoding of BER-encoded structures that contain indefinite + encoding within an ANY element. + - Added DER decoding flag ASN1_DECODE_FLAG_STRICT_DER. Over the + years BER functionality was added to the decoder and this flag + provides the way to disable it. + - API and ABI changes since last version: + ASN1_DECODE_FLAG_STRICT_DER: New definition + * Noteworthy changes in release 4.0 (released 2014-06-26) [stable] + - Optimized asn1_der_decoding_startEnd(). It no longer requires the + additional decoding step. + - asn1_read_value() understands the ?CURRENT keyword, which can be used + to indicate the current element of a sequence, when the provided node + is a sequence element. + - Several optimizations in DER decoding of structures with sequences + containing many elements. + - asn1_der_decoding2() is introduced and allows flags to be passed on + the decoding process. Currently only ASN1_DECODE_FLAG_ALLOW_PADDING is + defined and that allows decoding DER structures that contain arbitrary + data past their end. Contributed by Karel Slany. + - API and ABI changes since last version: + ASN1_DECODE_FLAG_ALLOW_PADDING: New definition + asn1_dup_node: New function + asn1_der_decoding2: New function + asn1_der_decoding_element: It is now an alias to asn1_der_decoding +* Fri Jul 25 2014 mgorse@suse.com +- updated to libtasn1 3.7: + * Noteworthy changes in release 3.7 (released 2014-06-26) [stable] + - Fixes in length calculation in _asn1_extract_der_octet(). + - Fixes in DER decoding. + - Fixes: CVE-2014-3468 CVE-2014-3467 CVE-2014-3469 bnc#880738 + bnc#880737 bnc#880735 +* Tue Jun 3 2014 meissner@suse.com +- libtasn1.keyring: added Nikos Mavrogiannopoulos + key, who did this release (and shares responsibility with Simon). +- updated to libtasn1 3.6 + * Noteworthy changes in release 3.6 (released 2014-05-25) [stable] + - Corrected an off-by-one error in ASN.1 DER tag decoding. (CVE-2014-3468/bnc#880735) + - Several improvements and new safety checks on DER decoding; + issues found using Codenomicon TLS test suite. (CVE-2014-3469/bnc#880738, + CVE-2014-3467/bnc#880737) + - Marked asn1_der_decoding_element() as deprecated. Use + asn1_der_decoding() instead. + * Noteworthy changes in release 3.5 (released 2014-05-01) [stable] + - Correctly handle decoding of recursive CHOICE options. + - Allow deleting elements of SET OF. Patch by Jean-Louis Thekekara. + - Several small bug fixes found by coverity. + - Code improvements contributed by Kurt Roeckx. + * Noteworthy changes in release 3.4 (released 2013-11-25) [stable] + - Added asn1_delete_structure2() which allows zeroizing the contents + of all values in the structure prior to deinitialization. + - The parser accepts negative numbers in an INTEGER range (but + still does no enforce them). +* Tue Jun 25 2013 coolo@suse.com +- remove gpg source checking again to avoid this cycle: + libtasn1 -> libssh2_org -> openssh -> krb5 -> python-Jinja2 -> vim -> libtasn1 +* Thu Jun 20 2013 meissner@suse.com +- updated to libtasn1 3.3 + * Noteworthy changes in release 3.3 (released 2013-03-23) [stable] + - More precise overflow checks using gnulib's intprops module. + - Updates to compile in Android systems. + * Noteworthy changes in release 3.2 (released 2012-11-30) [stable] + - Corrected buffer overflow in the error reporting of the parser (reported + by Andreas Metzler). + * Noteworthy changes in release 3.1 (released 2012-11-24) [stable] + - Completed rename of types: + ASN1_ARRAY_TYPE -> asn1_static_node (was asn1_static_node_t) + - Added new types: VisibleString, NumericString, IA5String, TeletexString, + PrintableString, UniversalString, BMPString, UTF8String. When re-defined + a warning is being print instead of failing. + - Parser outputs more detailed syntax error messages. + - Added asn1_decode_simple_der() and asn1_encode_simple_der(). + - Added asn1_read_value_type() to return value and type. + - Introduced ASN1_ETYPE_UTC_TIME and ASN1_ETYPE_GENERALIZED_TIME +- added gpg source checking +* Sat Nov 17 2012 andreas.stieger@gmx.de +- update to libtasn1 3.0, SONAME libtasn1.so.6 + - Added tool in tests/ to benchmark X.509 structure decoding. + - Added asn1_read_node_value() to obtain a node's value. + - Optimizations in internal tree allocation. + - Optimizations in tree search. + - libtasn1.h no longer exports internal structures. + - Types were renamed for consistency: + ASN1_DATA_NODE -> asn1_data_node_st + ASN1_ARRAY_TYPE -> asn1_static_node + ASN1_TYPE -> asn1_node + ASN1_TYPE_EMPTY -> NULL + static_struct_asn -> asn1_static_node_st + node_asn_struct -> asn1_node_st + node_asn -> asn1_node_st + (the old types are still available as definitions) +- fix W: devel-package-with-non-devel-group +* Fri Sep 28 2012 meissner@suse.com +- updated to version 2.14 + This release adds asn1_read_node_value() to obtain a node's value. This + is to deprecate the export of the node_asn internal structure for the + upcoming 3.x release. The ASN1_DATA_NODE type and the ASN1_ETYPE_* + constants were added to support the new function. +- removed upstreamed libtasn1-stdio.h patch +- make check +* Sun Jul 22 2012 aj@suse.de +- Fix build with missing gets declaration (glibc 2.16) +* Fri Jun 29 2012 cfarrell@suse.com +- license update: LGPL-2.1+ and GPL-3.0 + Tools are GPL-3.0 +* Sat Apr 14 2012 tabraham@novell.com +- update to version 2.12 + + Cleanup license headers. + + build: Update gnulib files. + + Corrected DER decoding issue (reported by Matthew Hall). + Added self check to detect the problem, see tests/Test_overflow.c. + This problem can lead to at least remotely triggered crashes, see + further analysis on the libtasn1 mailing list. +* Sun Jan 8 2012 tabraham@novell.com +- update to version 2.11 + + qa: now builds without compiler warnings with Solaris CC + + qa: added clang analysis. fixed cyclomatic complexity output + + tests: added self-test of bit string functions + + build: added windows/libtasn14win.mk rules to produce Windows + binaries + + build: don't hard code path to perl in doc/gdoc + + various minor fixes +- changes in version 2.10 + + lib: small optimization, possibly working around gcc/valgrind issue + + build: update gnulib files + + asn1Coding: actually implement the -c parameter + + asn1Decoding: the -c parameter serves no purpose. remove it. + + doc: add examples to asn1Coding and ans1Decoding description +- changes in version 2.9 + + tests: link to gnulib to avoid build error related to 'rpl_ftello' + on Solaris. Reported by Dagobert Michelsen + + doc: fix bug reporting address to point at help-libtasn1@gnu.org + + doc: fix returns: documentation in Texinfo. Reported by Jeffery + Walton + + build : update gnulib files +- changes in version 2.8 + + update gnulib files + + use libtool 2.2.10 to ease MinGW64 builds +- changes in version 2.7 + + Doc: build PDF manual using GTK-DOC + + Doc: fix of asn1_check_version, documentation was missing from + last release + + Build: avoid warnings about ignored visibility attributes on + Windows +- changes in version 2.6 + + Fix build failure on platforms without support for GNU_LD + version scripts + + libtasn1: simplified implementation of asn1_check_version + + tests: improved self-checks + + update gnulib files, fix many syntax-check nits, indent code, + fix license templates +- changes in version 2.5 + + doc: improve GTK-DOC comments + + misc: updated gnulib files +- changes in version 2.4 + + Doc fixes + + updated gnulib files + + clean up copyright notices +- changes in version 2.3 + + libtasn1 is now an official GNU project + + solve build problem on Tru64 related to TRUE/FALSE + + More careful decoding of OIDs + + Fixed warning in ANS1.y + + Use "Software libraries" info dircategory + + Drop GPL/LGPL copies from the manual (not needed there) + + New configure parameters to set packagin specific information + The parameters are --with-packager, --with-packager-version, + and --with-packager-bug-reports. See + for + more details. +* Sun Oct 31 2010 jengelh@medozas.de +- Use %%_smp_mflags +* Sat Apr 24 2010 coolo@novell.com +- buildrequire pkg-config to fix provides +* Thu Dec 17 2009 jengelh@medozas.de +- Add baselibs.conf as a source +* Thu May 21 2009 vuntz@novell.com +- Update to version 2.2: + + Change how the ASN1_API decorator is used in libtasn1.h, for + GTK-DOC. + + Changed license of libtasn1.pc from GPLv3+ to LGPLv2.1+. + + Building with many warning flags now requires + - -enable-gcc-warnings. + + Some warnings fixed. +- Fix license of library packages: it's LGPL not GPL. +* Wed May 6 2009 vuntz@novell.com +- Update to version 2.1: + + Fix compilation failure on platforms that can't generate empty + archives, e.g., Mac OS X. +- Changes from version 2.0: + + Optimized tree generation. + + ASN1 parser code re-generated using Bison 2.4.1. + + Build with more warning flags. Many compiler warnings fixed. + + Compiled with -fvisibility=hidden by default if supported. + See http://gcc.gnu.org/wiki/Visibility + + The libtasn1-config tool has been removed. For application + developers, please stop using libtasn1-config for finding + libtasn1, use proper autoconf checks or pkg-config instead. +- Remove AutoReqProv: it's default now. +- Pass --disable-static to configure. +* Wed Feb 11 2009 ro@suse.de +- added baselibs.conf (needed by gnome-keyring-32bit) +* Sun Feb 1 2009 mboman@suse.de +- Update to version 1.8: + + Fix crlf self-test under Mingw+Wine. + + Fix build problems on platforms that lack stdint.h. +* Sat Dec 20 2008 mboman@suse.de +- Update to version 1.7: + + Add libtasn1-config for compatibility. + Please stop use it as it will disappear in v2.0! + Use standard AC_CHECK_FUNCS autoconf tests or pkg-config instead. + + Read PKCS#12 blob as binary file, fixes self-tests under Mingw. + + Fix use of __attribute__ ((deprecated)) to work on non-GCC + + Fixed namespace violation for MAX_NAME_SIZE and MAX_ERROR_DESCRIPTION_SIZE. + The new names are ASN1_MAX_NAME_SIZE and ASN1_MAX_ERROR_DESCRIPTION_SIZE. + + Fixed namespace violation for libtasn1_perror and libtasn1_strerror. + The new names are asn1_perror and asn1_strerror. + + Fix namespace violation for LIBASN1_VERSION. + The new name is ASN1_VERSION. + + Decoder can now decode BER encoded octet strings. + + doc: Change license on the manual to GFDLv1.3+. + + doc: Sync gdoc script with GnuTLS, changes license on man-pages to GAP. + + doc: Improve gtk-doc manual. + + Assumes system has strdup and string.h. + + Remove libtasn1-config and libtasn1.m4, + use standard AC_CHECK_FUNCS autoconf tests or pkg-config instead. + + Change detection of when to use a linker version script, + use --enable-ld-version-script or --disable-ld-version-script to + override auto-detection logic. + + API and ABI changes since last version: + asn1_get_length_ber: New function. + ASN1_VERSION: New symbol, replaces LIBTASN1_VERSION. + asn1_strerror: New function, replaces libtasn1_strerror. + asn1_perror: New function, replaces libtasn1_perror. + libtasn1_strerror: Marked as deprecated. + libtasn1_perror: Marked as deprecated. + LIBTASN1_VERSION: Deprecated. +* Fri Sep 12 2008 maw@suse.de +- Update to version 1.5: + + Update gnulib files + + Handle 'INTEGER { ... } (a..b)' regression + Revert parts of earlier fix. asn1Parser can now again parse + src/pkix.asn1. + The ASN1.c file was generated using Bison 2.3. + + Move examples from src/ to new directory examples/. + + Duplicate copy of divergated pkix.asn removed. + + Merge unnecessary lib/defines.h into lib/int.h. + + Misc. fixes. +* Wed Jan 2 2008 maw@suse.de +- Add a %%clean section. +* Thu Dec 20 2007 maw@suse.de +- Properly package info files +- Package several documentation files. +* Thu Dec 20 2007 maw@suse.de +- New package, version 1.2. diff --git a/libtasn1.keyring b/libtasn1.keyring new file mode 100644 index 0000000..152df1c --- /dev/null +++ b/libtasn1.keyring @@ -0,0 +1,1300 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.10 (GNU/Linux) + +mQGRBEgd5bQBDCDc8Z7h2Damx3Xm+kMFXMKHqVUdPOqvcFT0c1gnQ9LPw3JiswvB +dM3SBRb2LxtEAnXt0Bw8WBbcCF9s05h8xjCSLDmBwQ1EBEeTvUN18TgeM6t4rNTZ +NrXl5wRmvkAzdO+EOHWx2gDRApLbdkkBK21+M6HPhtqRiMWK6zd5bPmiiAKNRv0G +aC71qUpdNSrWVzB02s8+LUivwH+kUksMX2nXps7b6RPhQyFl6FSv0LsHDd3yxRrB +JIikUAsSnQbDSPws+Srq1VFLhaARiPF2tg7ag1n4qbbZiK3XOSjK3X+b2XkdZrWY +7orBke/J1cMv/9XnqtsE1P1EYcuPk34yxjz/E5+0vf8DlzQ86c2DHRCpr81XV3qD +tNeouQFLDI1kkpG6QTY3S2SPMUht8V8JxhqBzbjWZmKGUf1ISYI2p9FqtXF4rL2D +u1QLPQGLwqYaUvnGCYFxEMpnDcYheF6zOUtow527WgrJcATDXW/HCzidwi2+o/cU +bdCeYOiN28IMCOIBJZjLABEBAAG0N05pa29zIE1hdnJvZ2lhbm5vcG91bG9zIDxu +Lm1hdnJvZ2lhbm5vcG91bG9zQGdtYWlsLmNvbT6JAcAEEwECACYFAkgd5tUCGwMF +CSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRAp7li5loZRcQvjDB4m6HO8 +bbiRSgYRd7UrUuSmRNcoWP3W2metytSq9ugRsFhgl3llHEMkgWTEXzsQTPZXPq7m +7aNXPa8s/ibD+qZAbFSRvJISrp/E+c1gCt4AQm/nD32F5RIsVKpg9J0pK7rCrMyL +lD+PiG++jJrG3inuk4Krc3EHj92LJpfEnVgaJR0ajwuVHNd9/QOrkrxQ7jlLckl9 +ZWmquTym/GClsH7NcPnqwc7YO0nG1X/l9HJmvSyaHGi4UnzjC8Tqh4avs1A2uUfX +o0OCwLO61bqnst1lIyAn7HtidVNBIfQXKDd3jWz+WwyZk0GRgzRBfRWShpiymxVi +3LWUgtXL0FTEK/pFpHvIbhpivNq1RPTeulO1uO+Bb78VYzvQx3cIX96gRoqapdI9 +zO8BlEze9lj1gZsRVBlWVkR58IZnuPYtOmuIoGX3NFaTBk4rIKPeXEzCGC/ieHDH +En29mZoLk89VrCq+7WNKdSYjiPcMLpRYmvBcJSxY6YxnM5rfiBSW5huV3uYuZQ89 +iEYEEBECAAYFAkgd5t4ACgkQ4V3YV7FcN9FGqQCfU1gaFrkGi5abivU9BQkJkr44 +kn0An0VSGMOgEsfzsDzy8sKnJTvdD6e6iEYEEBECAAYFAkh+2sgACgkQSgobyOT0 +/+aasgCghMcsnklu+37Qe9df76p68IGNEU8AnRw7QP8tYJ5Z4GAmc6FfP+3unrN6 +iEYEEBECAAYFAk1OpR0ACgkQaeRidk/FnkRwmACgmwEiVmtLCR2ffl/2MAJi+tNt +KyYAoJL6fLS8xycGA8G7ls4qYewDlr9piQIcBBMBAgAGBQJNTvdcAAoJELzblbcK +o78OfHAP/Rjx9YUKbB8ruIbVwzaOpaoiIpBcK/F/aafqxBBENEO7IajQfRyxozrl +XzzUIQyOC3keQdw7LwyURYvIYxcm0k5x7eVnhavu4TBL8FAnIsA9BTkNbSVCgmKb +rclfUriu7ipFPsaSEJApKDhQU3ijFtwHCUxFg9L/lm5N/PwIL0GQC6BNrbVrOCVd +QflMhX2MRNVAfvAbNcRJYUCAh0hHFigkE8FhAqJZuUGK62/Tbc0/np9ga4q7b3dT +Bg0l+UVVAKc+XcvABcomZeLcgNT7YTYZ5pJMjfx8Nk7R73JNYLLUnB7fFSoOolbw +dBkz2BupNlmRmoD/lvm7Sbnn4HkyLFdnx9CzFZ3Mn1IMkm6Kkcs3Fm3VHQgLgs9K +lewKOWzDBQeSgPbhhiqzjbFXB+e/7MDTJgITLZol+3/OlELvcTcSU4RloJzjJ1mQ +5KdZe1ZrCs9dUwQi5+guiLZJ/MuqeNtXPey+HliwhyG9gy8uGYFW+6eLj3yv4YaE +AmlzTYneHqBNX5kTw73GBWy8PyZz0wiIX/700BEw5IPCeJV6h+xBdpqk8l9PZ2Vi +Piuod2qWJMIw5oldChMTp9Wtk0+EBg8uiUz1q5hgIts12578fkH7EPGbQCF8RITT +ThrK6m/YOjf2n03irT52Umb4c3FbBxn3hQX76QuhK+TrYkDyREtFiQIcBBMBCAAG +BQJNTx73AAoJEPlBB4h4NHwMohAQALY/Gq5yXfWTmBQWqLfeXBXSCZAz7yC1f+r2 +RNNf8dx8xTW/dyI2G1SbMqqHc6rJqW5yPe99aP4AQsr8lAsoLbY1LhJi3Imfpk+h +vAVqInSXyQcOnprceL5iyADpkpLS+/5CM83VGfFQoVUTgLcFWU97k8vT0fQT3pFV +QTQzVu2ZbBkHhaLTkV1Ep1KHWrSEVN7kFZaA6DmnR5W+L2k4aPEKDgpVSflLmd/9 +XbDFYsDzcHlbK8G3fEh7SjMJGyFyA44EeqLA3pRoHj4bF/jVCXqS5LN0LarBmM+6 +Wioi5thj7jZ8NlqSCvuaFbajd5asY5oASZKa9M30sSU6oWSVdOkqkjagQf65teHw +64UyaK57l7NWIenv88mPfEJK8Ce2nt2j4cOZ+OkAimUGBsvFNNMQae2Q+dfb20Eq +XeATKRtBzJDSKVK2RcKUi08PYPK6PTAsubMxJnjIbMohTdUc9QOvCRa0o+f2/VhZ +DrFNTwiF0dxjl3fFxt2NpVsDbKmgJegov9lf50oFrTreRG2kx3iGpiKXyPWqgIN9 +LPFkHdT1uXQbasTRi51zMfcYVmk1Do/CzuTw+PJGnTgmC1Va1NSv2Ck7xl4H7HV5 +eDlWHCb8plE9QE38AlU/pv+34JVSC5mf/HDIxL68IdUENMiXyBWynDeQkuI9roUb +Li0y+9J/iQGcBBABAgAGBQJNTwf+AAoJEODYD8Y41NWHpIUMAImOAT+PyjCec7sM +xfx7XY2I+1vovSt6dKTBpHVq7Wj5575Sl+0Rp2YovC5nGpLNx9Tt3V/qNDHZAokk +F8/XPqwcwmvVFLsXfPDbwcASf+1FEdXAf4AK3qalt7BKVV950oUKw88DJuigc14D +tIgYOIiKHRQ8hot8tFOl6q1iR4tPYslz+gkbkxc7wWQYsPpR/37Shn60QZMkZK7Q +7Rwc9g1/g9IZDA8A3qVIzPAvV15GMYb7MWmji+ys6zPGdd+dfX8AbE1ZFG9xEkVr +fJIwGd8Yuq0nb0p9SKW8kFmnblXVPAE+harUSH1oWhzUcit+O4gYa63rMS3Ai6uc +MDJ9YXXqVT2sQNKAxR1fCcSomVPGx3HD95XIWVbQXBQhPE/FJY/4y172cxlC2KpP +09MRTKD5OrXlsn2nCso1fd8qn43aGxE+9ouC7pWcLSkPhLRPfQQ+1RxGf0tSqghk +A/gY0qLpp/wMnM056aDgQllGjA2G6Ujk3Jh8uRt4CwVzNFbUo4hdBBARCAAGBQJN +T3n4AAoJEAJasBBrF+oevZQA+KcQbKpgCwYqEjc4UyVQ/lL4fNapao8+Yj/N6oT8 +HBcA/2PB62hLyyIQwGSqovcYC3R5QWxcpEg0+FXBq52prCj6iHQEEhECADQFAk1P +0V0tGmh0dHA6Ly93d3cuYTJ4LmNoL2RlL2tvbnRha3QvcGdwLXBvbGljeS5odG1s +AAoJEHFtRBM9jCItc7IAoLU6jf1+Cm8vLmNUawf6VB/uAQe+AJ9N/1vAyeY31req +TYa22XKHrMhnx4h0BBIRAgA0BQJNT9FvLRpodHRwOi8vd3d3LmEyeC5jaC9kZS9r +b250YWt0L3BncC1wb2xpY3kuaHRtbAAKCRBW1Sk+yXoGVJNHAKDX79218zw3Gtex +5PIchhsP3b/hmQCg5k1D9PJbfpbKRotpmp55eokhwnKJAhwEEwECAAYFAk1PhSwA +CgkQmZMeJdkeASziBA/+J235eEuqz2I+P+S1RXWa0SGUDk4CTtsYHeLbr91FpEOj +WMVIYoj1i25Ne+nqjs+goYc0n5oVC72W+jJrT/ayGunMnYwkmLI+OnJ9/FNkwKj9 +phi5Cx9BNe7+ZrjCSxxg8Ar2/UIzUhUXnIII+OIsdAUwz4P8UhVXfCfXeja0pTCn +2XjNoxKOdHLU3DH0YXqJAPsWSJEqyZyVP0SoKru6Uq536/Z6VRNA9hFR9QWIi0ib +F1tngyfzwevIEjN6OBdT4fwZzmdV1cQ+adoiUr9wFeA1JbjJefAXOq15uTxMMMJV +gRVnzHPAWosLHYnKaJzKd8rcxMsftiD92NbU0t24YsDmXMVAo4u3Q2YVgbgGWu2t +PqYPZHk0i57MmAIn6YrL3+TTqDNN35enQMKKJmnBAg84ZZvQ9pGJQDMcMv31Yvau +vt4dkw8u/Jbksuc9RTw6w0Zn4WYPRxZtUwqKYlR5Khr0f9HrKOeiJuvOs37F3+bJ +CYaKYzy0BUfSmujKHPcP1l3IJe3gIT4hrDWc1J4rcZ+dopBkddBVQrMc4L9V0VMX +2bR3fcC5VraEnRQxkkyF3GSYoXNm5ClH9LV22kuS4A5WPheTDbD4wFKqT1UHMush +5rjd/BwyDXTcym+bMH2ZAft5w7VOquFM372GUI6uXNiZS/iMWj1w6MlzlaI9q3SI +RgQQEQIABgUCTU/a2QAKCRBJNgs7HfuhZH1DAJ9IFcqjB0K/310XdIXQPd06Ev34 +oACg7Pe+DW9C6+gJ3foFZo+TrcC5K1eJAhwEEAECAAYFAk1P2zoACgkQfpcqy/4K +evMLmRAAj23Tdm5GO2HxV7IP2x3Aa7kFo/pzVUUuvpn0HFIWBFK+fJEOMeD1SpI9 +nGHfziUrNruwtjqgSMHGy+ZP7IM0ERvmkp8r1La67P4AsH6Qk+jBwwlGPs0bE5y1 +I9vip9rWhVTrnBWUgblAWWvjNaArCRA0XtOLYZcoUNZUf9KGFns7OSVCKjysoLuA +yw05ZIUcHyRe9Jf6Ps372726qDAcDFM5175rL2Mo3khm4riq4ezIa63SWSfUCHfU +g7z2ZTPA+9JfwAyYw1+pOgwM3Sg6NFhWYlG2itewJd71PfAOU7D5jRTjHGGyYkxq +2Xu6Yt3auBIo1M2ZDQVYaxxfBalOyk8HRMo7+IXiMZLfP2cqBghGBjfO7usfKU/2 +WkmBlO+gZ9v4snVynfJszwjqqJaulfzKdOlwfYvoEuA6C+ZtXQsjI6vniWoiuDN3 +zQaDgjvEDMBHuaxDtxJP8ElbSByKNB9ilCe81H0vDWtzHrrntK+yekt2OhfwbJBT +a5Zyu54HF9Ifcpv2AAU1/kquZz5lWDzx8GQc42L4dIs2JtSbnIzZI+vOBkgUaepf +fvM+vmI/z4zAAMwXuPgH7jHZVSXz592Kc8vD0SMryiajdm7+H9m80JZoJGvGa8tL +83wjE3AfkNt4x4jFyEkrqNzFMG4Pf3KCYIgE4EGGXWZh1QE1f7KJAhwEEAEIAAYF +Ak1PtoIACgkQtZ63IgLRvGVFUw/+Oys3yltQUkudCAhmW7Z2hg3sFbymd3KoW8cp +WbblC59p3t8owLgsRDgu0tzQ0OgjdXkjcaGTH2tRlcrJmJ7Zk+QyU+Vb0+nlXpIa +btr8GnGFPT092Et+pFaVOJDNRCFIVYeeVfgspX+RJohUsNAjiTHS4GJGyXTDHpOR +PH5xokbCRtlG7NRV4i9zg8D9osSW7ijsF+g5peaEiSUF1rToJ+yXMldnsJRXHC75 +zrB09ix0VFpOzx4N763WUrobIvDPWKl+25s25zkdw5jfzSX1+cZjXO35zeMRltyD +ECSS0j9v/MtplbnrumErL0BLPUPb5sfn3Akpjk6a+8oo5qL8u2vtAMxUWX2LAdeY +9Mz/S3pRa+gd/s/R8XL+5R4imW9w1GeDO4MIa4afMmpC1bjDH5vEucxWUuYyfZbn +O2XQ/ElneV0VO/c7FKc8xYNC0urX679Fsoq273UVL+psNTkAscwY13wEQw5mT4VR +cWt9Wi6o20gdsFqozAd4J2xstbkXsVk2pijAQc1+PL8nkHi0btBxO/sTCk7/yNtG +cjnXwD4amtZGnELIyiF0lTGbn555KKvuR6OpNLraY5QrkW5tbwA9WGZRQe4dAWv/ +czxRrb41e7LpWIUkXUqww53RsDBzuqtgV1D4ghFY+xzVDY1jkrO3J66sa3vNx3WW +LVTABwOIRgQREQIABgUCTU/vtwAKCRCa3YdBWqMiVjikAKCP/1BUiDupZbAu2nMx +NWdZ7+AkxACcCt/d5WdYlNY6GBsaFCnJzp3tCXKIRgQQEQIABgUCTU/l/AAKCRDl +MRXluKGcafpTAJ9Kwsu8X/d4DiNO4ptCyG7bnc+fCQCfeANjtliTDIiDqlV0CDhI +K9sMo4OIRgQTEQoABgUCTU/3aQAKCRD8sLtcXx+/cMwVAJ0ZizlAxB4E/1cEhY6A +9JdBkljE4QCfQYgsJRznwXVYNG3eO06+KVUz59yJAhwEEwEKAAYFAk1P93gACgkQ +ntzJkdmrRX7MPxAAoUcYn1RG7XjtDOm+ijduz4gnaXXKgFhOMaVqG0HjMA5ve0oe +3VvnFdZsYxObD3us3mkvt63lmMx61JH9aMzBhLd2EEWDQXfKSPJw+Ll6da7gD9Nb +p8KPrlLMAVdQO0PsfBieHIITdrV33wDEmZ5nRfZ49crFWzaIAZ3FS2h0aOj+/DP8 +ovhENdvykCWAcmqzteFJnKGx7IpBl0jGye59FJ4xc8SkSqwzQ2jJDM48FZmE242F +cj/DLWvF8BNMEAouZLR5NpLE7k//40PQMqO6nSOeQtnpfUP4mMiw77kXp+ZLpg3x +pGfWYVnNWsBTyG/jcdx9Pv71p1/I13q6+O0rCbGrjb9Czq+QQu7kfPwWDDyrU5Sv +A6/Yvh3HfDdjpavMDxfBY+KHjHMaAMJ5rm3//EZpBtLyHZXWTiawsv1eraFpxlRZ +mrY/JlB0XMV87Ma01x9NggQfMjj2AwhaTx0JWvLZjiN1fV0GN6gHtYLDJRS6zdUO +mfTFbCFgIwEWAbVKFapVe6jA7sak/X4kdwOupK88FGofUrP4WXWtjStOHeS4irXL +BGTQOAoizeLhDGvXKyoP3RZzdQKRvw4DNkNztXIhWb/ZgRI3R5ULoFUY4d6Za4T3 +Q9iK8oz3o7nEsWaHGE2UTZtdKo0eaXMrJM+rthr6yPER0G6WvTfadssJJYiIRgQQ +EQIABgUCTVAFAAAKCRCNvOfruxnoAyv/AJ46wOFCbVWS73IaeupVygLkNGZDAgCf +ZjPwGvRy9fj4mvxWpBfWbn8WcvaJAhwEEAEIAAYFAk1QIMgACgkQqC+7g/PVcDP9 +3xAAwgm8FfGcF1WbQYUi7K5VaiwPqXCJ1h4cx5YewSGeue9On3ltRSxbXmtpTcdm +mcZULXrFYhF+cwhwgQu2BAHX327tW3AO9NZtLNbdAUFGGPky0g5K4tk26OeyJAMT +9n5t2d7cdD3HiamrdqIHDPjYXCCGHgkycWiWGRBWcrBeYInk2iLMu+hgV31pAiEl +iIZYKEoDAxZKO4eLoFqSlqO9WIAhARlcxk9WmN0q9v+E1+CIuq976BRU2rJ0pWEZ +dwRl4dL62ucJ+Yazlq2Ix4PMliSxTA7i1xYi9Fodr7XQahbVx0/+WFB5GLZwyedl +9u6HWCkwZec3xGJUoas3g6+GTPTD5xpqT5gPgC3jnG8WBSXtifl2iq8baDpd5U86 +WWtNs9bWe9YV2e4vQltyfXJSetbEQTcaObxLwWuvm6mg9da5rQksXf6Ljukx97O3 +02tylc4BQ6cskqGEX8LixO+w+iPhs1NMsIymdi6qScWa/nhtoN3hsA7OCINVDDMb +VGVItOUjNi55ezuaDc7Vhyd9SS949zKfRfamttvUhqYHDrxXDTDPdd6O8aH1Ar38 +rn7AE5IEuaNLHaBdqE+Gs+DeqQX7+BiaQziMs7l3rLhJH9muvbrJAFsmodGKnb4/ +MW9vAVK0HR/P15zti+JCGrykiG1b30qYLXS3aj3dfBCdClGJARwEEAECAAYFAk1Q +RPwACgkQfcMm2s1ypv2BfwgAlgCzrVI1f4bZHN6YfEx+1r3p/EKODTNl4KvRl67w +ztckm2o7awsu3qvfb/TxUTSKzUE6OjE9B7T3MsvvzGhPySSiqZLGjf9zyrxL2NLU +FQiceQ9L5fupWZb+Vps+QFnmZLP+RuZmKAronNq29oL+huSEg5os8GQswovxmlq/ +w7auj9GkEHus/dGX2MRpHqrSx0JjTCj2laXes4x+oEuUUvfbcjGDGijvS8hwEa+b +iphHTwo+PHt22bH9lCzvy0Ca4J6vRF+JrS20hXxKbiT193O6MnlrFvni3m6tcm5I +TeEdCHBc6XyanN2KPBeeiHab3RdSBMWlpMvoQsdq781gPYkCHAQQAQIABgUCTVBb +QAAKCRDnYQLgzf6sLzHrEACDjWJtlpdRV6Fmumo/gAq05dLaV4AiLn59qFLt9qwM +CqhD18GpaUMHtu/arJTEed/c+nYl51uzvoxdkmtwZMjiyLZx5R7wm2LC4DzgZ5Z4 +UCxoASLwvxd1P33wLT3vkYF9ZHAMI+SQn2v5hrY3cgzpEYCDGNhKgO8empzI+na6 +3+su+/OFjaSVKkBiC/Ms5KRDQBDJ7oNbMava5rpdDmLHUzjKi7M6G7pAzEBWrnZc +5WXOIk0UYuo6QBSRb5laSDDnvKW8BFc7EDj4cWbXoolNNXFCrD98FNZ1FuPoZTt6 +kddQ6oW6qJydCgvPD11ILcL0AN9SD29DRdwMeSp1vkVHYA/tw+W3JCyP+gbDt6Wq +Ar3yfzBgJbMTFvDJcZh49YP6LL7vHnym1PZ5QyYJTaiKCXa28tKLDONYrbX59CXO +lwxE2SHZ7EZrjHmwyJM+AE6xL5P9GT8RZL5LxOzRYZvWvmSHY9MpEINI4ILtEk8J +1DnBzclulRSJOU2hEGQwUvHRPAy3Eof46455rdMEzsomd7n9LiMlF8GRg1dX9wTz +A1PYlhCn8Ed66kFPGW9AmryFP7/ysMa1CN3m8QR2RJoQyPjvgwmdVSc5vsOTFNce +5E/OVUDRZqfteaLCS2mXrl+/KGISL5Y+/b4Q7DA01OZZtUiE8ApPbhOez5QUvZ/e +aokBnAQTAQIABgUCTVBl4gAKCRDg2A/GONTVh+1FDACAulggWlQytMfrzaIWpOMd +5NqoURxpWrMcY0fqcMq8mqew0HOIqY2LSI0qxVYNKaECcuUI4kCfhyRDuZErt9zI +QcMNc4FPyTcnt5iBEzah8UXZhK1ICFACX5o75ZX+wRnzj2NgnCzprBHSrL4t1qaW +cIpL8Nje6QZmyswp68M+B/ScLYZ5CPeoABuyK5ayc6pjfXE6EJT96+q/A+DVq91r +F6gwQChYyULGIK3ONljtC4woJiqjIkqQ3wKR8fqFR7HCZjqU/uPuNY59J37mVKyR +E7uVhFSeYNsCVgg0XiU+4KFa2FjJcJHPesAFp7a7y7A0p7CWXIvbmgaHAvyo6z9x +d1+uXPChDPSpq4WPrCcqumrzoBLB4XUey//imTA2+x01qWgkHZFXNg+ytrXzyjZ/ +S0JLzx3hyz519kEEAg19LJPZY0kmLpQP572BdTJ7bXOaTuOz0Q6pcZBFrvFVpy7W +1/0RfT2BeXGFPTBjClzcfZsic0TrFGJHc/KEVnjx1h+IXgQQEQgABgUCTU/qNQAK +CRCdQoEd+4uzdjaLAPoDMLS1M4drh8qKy8ChaU0SOrFuCz/DJ929p7IAwoNmggD/ +c+B8+wXV1iqbZaJRTNLp8TutqX5Qu0DoN9LazoFXbX2IRgQTEQIABgUCTVBnZAAK +CRAvlRUIquYCLqixAJ46LD1vCgy7n6BEjYfpNVlEhkBdAQCdH5dm9o406eTWW1Kt +PFb1KkOXO/iJAhwEEwECAAYFAk1QZ2wACgkQrDCHmqtVsxJ5jQ//fEZfgrWzWAlx +LUnQxJ2xR4XD/rLoTq7iNJIVhfpr8MDNczG6BVq2x8pEit1XbJp+PuvKONDtWSbu +R/GoiNA0IDx1b127Mpz1KfPN7hdsQlTb8uKF+ESgsZYNBCjvCSFydTN5qpxv5xl8 +cQJpiU5RScOzqRpj+bdPv58OBPRCOXKhdQ+F9u+3ayE0PNr7kXGH3dwDtox4b5x1 +qghZPgI1NN6Y+jvERiSBxDsVURdaLpEb7WEYmsQwuO/UqdoATY6nH+C2V85OQZnU +leKKbSwnUyoQ/VIGI+rsAncpJ6j/1z+6FyfTOaItbijzYlJF09v9Mc5VVJz3S5oQ +RhDychO7xDYIWVzW6h2FV8XjyugWyE0x6blcP6Iklsu9Nxb/n0w25G0F/pJa1U+p +aZxfFVh3wUPwOy95ZUiJmWn3xVE983kjvZ3CyE123t2M2qcM0LxDZqkfGSNu8VhW +qhWBg9SKtBrJL2RNZowl44R/RaBW+EWQkD3GrdNgmEjq7Qa4dY3zm6N13kuyfg/q +2l4h8gaOHVsGJ7J+G3A8N718iAhtzxrJtNvGy8z2XneE7v1uH2KbE6BpvWM8BiMe +rrb2H6RJCrx8usGqdorF6ZYPbF0ymN8Prke9gg8hcoaQ4qoGcgW4U+hMLM6BsuPr +hVfVIRwfjnhN64k/M+asgTD1tb8BNFuIRgQQEQgABgUCTVB+VQAKCRDRgd16bEKC +cpWLAKCb6JUL6EMdgZ+2Ys/UM6Od8fhfuQCeP5YaLh91juJocCnTLFmXRjbuhxmI +RgQQEQIABgUCTVB7LAAKCRAwAo0kSBO1/hFsAJ91et50yD4Ui8vsGXqTLwUq5+Kx +TwCgg1Ud6vHGTks2Lxg6b86BzJeyeCSJARwEEAECAAYFAk1REY0ACgkQnK/PEVZ0 +b5VaHQf/RFXlrpB4ArNQwt1HkEc0BfgTcUt2zv+muBn6EtPcukZib06LwI3wWoTy +8hHpQoU20sYWOKtBLV15aw8pwESJkiCeK70LYu3lgn2csPM2EQsB+/AaW7H+TqUy +2orr/RLcgi3ZAVGofygZ/lcSuMpbGhQFBmlpXUI+TQPVayKPs1lvzBIM2EUMwNye +rEnwZE76StfzmzEGeyAMuclOCPHa7eZQW4A0d1Q4KhjfiLZDF7goafkj9UnoLCU3 +MqwiFxyo4OuBEBR0DHqa63cVOGlz/sNH9oG8stdyH9127kOwNhsJJTQlgsxqnZz+ +lgnHVmSrjf3nCG9Hs0JieIy4CkDOTYkCHAQSAQIABgUCTVFfYwAKCRBa+2eD84TR +jSZ5D/9XJj/IZnF70iacp9WWpMggi4C/6vFCYyPInDs9iLiKXNwhR4ymczRCePar +kDV5FLQGtFlJP0afl5aESYqysGIBpB5b9LsNwcd+UJ6Hgy9IGhRDifGZRcWBwZeW +Dqu/K2tALZvaueHb5fDDago0UMemFrgJOrGqQmF+SCcJjxpPyAoamb2Hg6ZaiWje +LDvJQ+xoExcQCAFsdlm9to6O/ieIu3Op3V3rPtn+BEFzQH71QVFwm77nSWQBL2Du +D5keseOnxZ78X2gKSx/ah2I+RR5J1aYMqhZ/GG323Taq80RYKjxFYn5HQ9E1dqQS +JDUtETHhfYPRv0lWmMiL5Xy+OOD+ZdiXwVzxHIq5HSFdgvZ2dzcWGk2ze2+i5zc0 +Gz8oT/CsYRSfWIAhWFu8LKsMJOneW+eFaVhpvu0k1hlyP2n23GKfBM7dr322+hYK +vkEcvF3iVUQwcSrvpay0BbpDb7h/r4M6cONQNuFCrMkWDIxf2Ldr7nw23Irs1agu +R8WETZMIeol5rlk5EfJD6+p3TOGMwpgvS1vj89opcmdgVxfqE+MHkmMUfzeRIyFl +/1P3YI0q5vNEbJacbVU20yWJiUYK129YCTgS+iNwlfM9uPIoBhVkFAE3NaXu06UI +Eo2K4GMCFK7vV2fq+LdlqcFdUtqJ6MWazlf62h7vZcl6EOywV4hGBBIRAgAGBQJN +UV9mAAoJECM7ilfkh1/5zEMAnRg1/BOVICQxes2w2vaOyUx6XfEaAJ997McxjI30 +oMrWudXMoxrpuOcDpYkCHAQQAQIABgUCTU7qoQAKCRBnZgDc2lqZQ2UUD/9VXM1z +paQvzAQplApRAfo0EL5IYkGzlgPfLugr2zrYWod67GXybrOrhmI40rV+S2j9t3cW +wjv6yQu5MrcP1OT4caycGhBGqA5TO66B//45LIf4VqtoypzVbfkciu2b2NawnhHs +FCOoJfPaEytPmUB6DgOk+xR17fQK41Balro82R103eCIKRZ7FvXq5wgdkBMqMtn/ +710BuZdfaSYH7LSp06tpVA/pKTIPEYAjWiw8so6GbwcG2tQlF4BwbcREsueOpbac +giPy5ESnH4C23T+y8qc/gmI5oF2RI8dtplM8RxKudwE2WqtpRi8zHiT2MPygrbCv +F99tgcYG/WzWBFTIp3HTNpmr+NKO/b1xPVmxaG4+Wz7Z2wEHAguR8z+NaVE9mLls +68bfyXM/yqQYKw1ZPKf/TWTBFJZMTvBAWEbBzB/CwZQmArrZTMPqQo4o7nVwf0Ck +CvjYEmbK5wx/HwGZm8QBg3cpTqJ3AtohGtRc96YUmobMLtTnnWMJOlp0f4dh7eUE +fTgk2mDAg/nb07TARh2CFOlE8N1tgJ34uyxfgfarlvhNyAv0+9dpQ6edtrvNrwKL +y4ppoEe7sbY5xDKhfw/EP/Mc5MTfxpSQmm15OtOUbaJYUgQ3oY32qJZC4p+K3wpV +GGxLzwtyDonuHy9ErnzdeFlOwrt4Uy+CV+3gG4kBHAQTAQIABgUCTVGm3wAKCRDp +WoG4nkG+Nha6B/9MQ+qffiBEwLUQ0FZU0wMhxYCcEwW37I5hYBArSUfX/vVM+em5 +2tAJXQ3fhc+2UfAds375B6LuirJQx1QlXWWYj60/a46iebqYMNpkLhLLonC2OKM8 +HIQS48gRzR2yMYNqSCqSiZR+B//mIwaHgTBvxTLjA4z1zvieUnb0W+wODrqKyi6v +kXawBm93XSyiE7bzm+zSnxlWQGN85OMmvm7ZNaNX/Fu7qUFwRXQ6o2HcQ2x9HnHo +8FLGITgRHvyajalvcSkyI3hO7zRiFuRDG7MvHR6q9+FJ9iQ6NSptM61ldOBBwkBK +qA91P2v3knrveHgQA9C2+xV5i7x/85r9NVUIiQIcBBMBCAAGBQJNUcZvAAoJEH0V +kcae+vKGncoQAIDgSadO21sTYSuWtxYTZoxLGzuM05httPShqKJNFp8XN26PTxrs +7FRNha4L6ahpuKlVrk7/jyGF8gj4wb4dgmIV0XnfENs82KtkSM4qJuVHlgxYzgIl +h49kJAvMN4SKN+gRblrc1+6xEeqgyunqhxVI4MOuzr/S3Cs8fGOfQpY9LtKJon8j +STvCHdgsBO9DWTzoPbUvblWa1xm0Xh4VmqaULORGCY/hx3z85WW/N3BGi0fvsjrv +ZgnqJD1c7LsJ+GbJzil+bzVrKiCtMApOyDoC+eRPkavADdLCSqUtP6RnNxO5XbOb ++7sfKIbA/gGkdBdNmL7a50fKTGI2RmxuU//iyh2KsxTTOGohtwAoDdBucFYN+cJy +v5j47+MAIMPN2fTKsPnkKAtiKyYWnY+EakBIv7tCF19UcrsQsP+I2lhDrUAjElb9 +SJZK3vFBNxdQHrj6p0I/YwLcksXAN28KZIPtiNo0nLby2GqQZE3/pvcjB366Aw+R +Sy+puZxmJGS+ETfNN+MAbOVQeme98DIiFjx3V511lBoWOgde4uxiFwLJWf+UPAv+ +gH+7hb2fRYkiFLCIBOA/i493TCO+q/haTjxdcUvy/7ugBioNiBlHPFJUpX0KoeRB +cgAcYRwo+5sh1zko05S6BNIUr/qdHa3hQIBvVkBbRRuQqI2Ncw9Yh8mEiQIcBBAB +AgAGBQJNUeDCAAoJEF6xPp1Ajzw/xmoP/3ylIIY2c077p9t8X2HweWjRt7B+gEaC +OG/s3d88E1sHDga4/PztuWLTukaPHAOthp0K2tJB07CKBN3p2KpG/arxiVWYftfX +lOhtE5WD9G1U97raIARKTj7LSpt1pRmmGIc0c2LAq4HmvRM7faIl+RKuYcqEnuED +cpwVajbZ56mLNvJ0EvWwfQcu5mHRN+Q8ol860OdshDiVeP8ZSfWrUnzrKQCBE6cQ +rHvKlCre/NIXd2d7PLj2KO2Dd8Rrg9KoNbQtYIOgHSWc6u6dgmx90y1xq71XitJ0 +Rpsb0WPd1r+YAqAOxkK0q/ROq00iFIsCu/I0ljS8mDDuWHs0UZkeY8lvzHDdNyr9 +WpWpABQ/O+u49XIi2q0J9KjDgbIuYHGcjFPy0mVgRnJkML4iexFbnntvCXAtgubg +0HDYC1joTRp/Vp7qINm6fcS+dHS1H2+Jtdy0t+T8RiM3s8Zd8U1JjTIMyn5wJjAo +NxHRZRw2q1kFyU/CNLlgcEAndEVk9iCaW0QlSE2g2PmCu9xB7DCDeAdUM/Fy7wuF +z0WvwM9NjwSmnqU9NSi1IQLP/6MSu2tFEj8GbsTGp3IUs6nJHPWjw79OJJ6hc1nr +sHzdwjSguB/m7EEXNCRSN8DLhCjqjGLffLSOH94uKDBng9nuc8zgfIHpUJK+0QqT +L1Il65AMopMEiQIcBBABAgAGBQJNUeDwAAoJEBEv90CDiX4SNYwQAJQ0+QB82tVN +n0kyeCn0R2xgQ8qM4oYliPsJfC/Q0OOYry5Ir72IuFfX+r2wVTiULIHDuIAcHsQf +bXtzxYKHVvajwQibCZcJGeacDEqKD9Qeznxy/Xg6sRBB9rEA6A8QIC7sjLfMxeeQ +SQmuH+8Q00u5+RpjQu3WpdUXMF9Zop3rrPb/uonAGPHn53lfFJ1vdymGa30zLyvE +vKpZsraC6fHDlHY3RsHqIKw+DIjs+syU9JJv+RH/lHj7sa8QcjAnQwJEqBbFjI7B +Dg0/ltyoE48eKmIszD74sb+wHYW8LrGzET93/pM86yN+ZPYWpaAUUo168uyXyfac +LZDjTPEYqmFd9RlTTZW0Plf5JWYovdArJkN9TrlUkK28uKYULdSB8Y4hzp1mLAMa ++4fKbGUs5UHXcA6JuKR3tqGw6NNk1u014bBFqAvLvFYRXMw1XayOzRJq4QBZQyaK +v105hpCbHBKR1QY1p1CYXDfwyZBJVhyp/Mm38eNiT6yCzdPN/Z00NeX5wg+muNe2 +BrJsBjvaRxhM6E68foBB7FCdtW60+FwqbeDqHSS1/yRXq29KcO0DfbTwlZUJJeEI +lCw2l11WmbHMh50k0kqhDW9gwBjxhgZaYRITMeNApkb0EeUWgIkFv0NEnkwG54BR +fFKmuMUGLCxecmA2AmCaKym5/077WQY2iQIcBBABAgAGBQJNUm/jAAoJECrpAeXH +AhjSWCgQAM7FRqBjXbNDM/izLCsqWasAIgxouITqYylPVeNLI6eAypDP8fInmVPl +CYDkf9dxB8tL0w9tjRU+7AtvadVVm6G3ZPo5bkACatCIDWQKjRpBQNo71dc0Y+aP +KyduvhugPeRMoqtDZ6ygw8tG7DvJ1bTOhgZoEmOjFCiLxnAwrznsA89wffCKBHre +ifu6sRL6AoPHz5cCsw7+x9TYzpKU6u/k1J7+K7z0Wd3iHEVyH0Z+HIHypNdyvpPG +GU4jLZf9srdOj7QvUtb2c62KSgSBAMvqQ1kc9mmSZ12ljq8+WjWTS4qr43PYZjDd +Lg15fd11wSP0hZRRF/69Puv/Szz1L8AXXrfCOl9EFIbL1twIcPDaMl2R0xOmrjqL +aIq7A3S0vM/07gGefGJzBLSbMDmsoc59TIpqa8sEuvUvf42+QTh1v5UdlQf1FHzP +k7/9voaxiQgHACOZtm4qldbB2IR6EVTlr1uDi2kO7rlP5JOqeE6tzHimogYH7q5g +Jy4k0Avj25LbuNXtQN60thnsz5Xgr6CUTL7jf5nwCH6sbTXOh1dh3jXm4TPqgKOW +u4ZKxDl82MTwepjXpwOkYISuBGEfXClqGeeyFQLMkYMURSoonA/udKkB9kmVE/Ke +mrypGLGzaGcL3554iHVMyn+X1G4rvPO/dcBCS/vUh97NUIhssyXIiQIcBBABAgAG +BQJNUpMnAAoJEGTIydEeXa2YKYEP/1BSG3z93IVbkLhcFYsIIvgXTSVmjl7n8XX9 +H0DaOyBExUNs+vS3mUqUcj7jYBh1kjc/iY3UleIRwL4BUNY9ZY5mqma2foJQ2khp +b/zmm814jsxCGKtef6kW7getubbUgv4xqlgtCgNtfGwZIKge7kl0IaRM2xHbnUla +Yp1B6RcZx4vQAPM25nkdQbKX/RxjHpek3oDTvY3kXS8yV4LXWRgzmVIinMmz6l3h +eKbqkHFPCRvLLid9QhLEXjor/vyqPIToDjEqlHZduC9/C+zNenEwSiaT0U1+qoLv ++AlF+/gNbGfcSKXqx7la1RDjjj8H2CFxtehF8tWBSNrIbZ5bJ8jla6FkNLbp3oJV +Sjt5S5lVaBJIWIeSJJR/VOzxIEezvXZGhmpk7Yy0E/uzI4kuKZ+CJdl14Bb46R08 +rxkFgP0aeKS2o5+VPue7/wZTbFtnorT2MIHxk9jrOnCa/BnX9wGaRnf7CExrSA1U +qSxgVjM0bXyzL9ykpVzFeoGNSRicdVTaGuocrvwPOo4kjfF7czSiG+DNvmHkBuhD +/c7r0P+iMOkq3hOeHAX8Uotsk+jSK9VXDwMsZZisPBFMkcUqSolJMTe5vMYYgzt/ +KayFxVNDsIqu1consYgmhgPFHOwG/PaYnPGKda0GQcwhTN3mCIAZZnGuCJFM1Mim +kfbg0nPHiEYEEBECAAYFAk1S7qUACgkQcxyv01PBoy9RMACg3L4/IS05NQrxqGs3 +vewff577n14AoJdIuNAkBIw1Pv3on1B0oBO0oqrpiEYEEhECAAYFAk1S+w8ACgkQ +6FZiOLAMtTNecQCeMdRVI3ZsieT0YGsVSE7wQ9o42rsAoM5n6GXoZOzoDNlZ/umv +oDJ2wQZDiQIcBBABAgAGBQJNUw/hAAoJEKnIbI3Tro06B60P+wXAYPsVi5mBxoTe +rH2oesnTaya69uPAjNJnaFkoXDXAOJdotxDWPfA9XL0/k7SaLCb1OQ1UaKcsGe3u +99R3/iElmUlWuhTgV2F7nUmUTjCWXQD7ZnQZRK/ik59cwn6FfNywGruG5oARNUhi +FXDG1q1WCgYYlI9iLIZ+YEPhS2r+BTRF0+IRYS72cKBI76xzuXQT5qOLWyvqAMuM +rkbooZ8que5hztlUevjYjWPpC+zCw4SB7iTfWOGWxQbM0PtLGHNrABUjUyqb59dQ +lHrxdvLX4NoJ69eWurYuPet/xzvZ2RXxusisWSscGet9md5TchyyTf0oEFPBNlKX +gozwJEtdTuAivzUTnWG8WeSXJOEzxJvuwpt/aboNzM5DjpCt9BlfqHrhaGJi7ZFk +xVUC2/+EDBqxPAwLEtBQ12SFFjNcCsR2YEv77mNTCZk+oRbt+n5ez7UXammlTrcA +WKD8lfKm8fi6nH5j8dKuHyGTP4wpUtWVZIQsO3Lsz0GK5bsXuVXh0g3sqX5F+M1z +kPMBPqpdNgVn6hWe/HvUasTAi7c7B3UGL1kjg2SftW/MJpXWcaIYzLbRRB1zFS2z +qjsP5IPasbOXk/SdAV0u1MiZDDMMjiir/sICKl0MCpdGWn936iverXVIoVns9MNJ +d5QJoPGQv4so3CgkNyFnk3r4sE61iEYEEBECAAYFAk1TH+gACgkQjuCbLeYc358j +PACeLqBzec6DTeYCXFpeUgcpmy5MZgAAn1we3oD03k0yBR6Q22rScGXqVVaGiQIc +BBMBAgAGBQJNU+OGAAoJEAfefupVe84MF30P/26+FdlfM+0GyhTjWb6fz99N7vPW +qCUpxYLsiB/lcGr5h5Wn/E/hwDETNWsX7rKwQwavoWSJ8Vj061eM0xy8nBI9Vzzh +rzaMUBFCh7b2vtsokIUt0Z1bQfL+gKESU0hLqjSNC3WE8/fxPwSWBmiczWPixzfW +fHyCHwEwR5OUocRxORA9cVeWvfzb5Hdm5hNpfFNMrdG1LkoMJ63/SE6OTm20zdtT +/PM0zptC39TP7bmoJueYnnncDmCC3Er0mwC6f6VnMQmBh+yPgGV9J9Tta3EcOVk5 +g9SbEAs/c/CZ4okTv6NJLYX5VdKmF60E9BkwAZq4JVAZyrFfNJmB638Zgqa8q5Ya +sfaLV3yoFCMX17sLXMiGc3dOwneFTEz745hAqOw2cwDoaNWR0B880p4buOR4wFcV +nlsiSy+B6iD0zWFISNrrjs5izARYclxVmGGm9KlLSX4keuEXxaSj18PsSn7Muk7b +BTcjuY0+xmdwzXabHBkNZfDr13Lxb+L2OPkAcTlNH4473AK5rH3B3MUfBmOqpfw9 +5AyZ7IILieiFhrk4Fmz9Jjbc4GdsEU1/qtDmc/p9rXiPCZhqeiQi3qA0CLLmFpK7 +ArlFI35wDUXCJnSSh0mzERojiB4Slp96qQ19LmynEh8fCoDBYMnJrBpjNJZyBwSg +Thuv7bHWpQM7efbGiQIcBBMBCAAGBQJNVApjAAoJEFSie62pgy67yTAQALUp2yWR +/2VH7oqyIrMkDBWHjPUEJ1/beSnL0c7rNpLBybtIrkFNjeZIWfS4/jKNmoHqOgnP +b877MENp/UK6jF5Qc3QeyI/OXr/CJC/HWPWZ1o3/o6PIptDNMCuy7c9Uu4KFYnlA +c0EHuVfi1k5eLu1YJnXya2vXyE0MkngnYcPo1I6KQs+vMsW1X+wcgVj2mpcAfECO +F450yomtmwLbrWRxpRCT/vtM7y/sgVmfuBVV4jhd0hGm2jDR25p1tWb15cu1vXPn +FguBBvVZ6cVU41CEJtE9DfVN4esuKaLmA2pwk1wkruiPPCvTUhO13HNwEenG/QVW +fUR8j8d/64Iw9d2t6jRfUKdctvPhnY6iIZ/2DKq+zFEy2cscMd++kqmR9WCCqPht +obafxJ9LYoZ42IMNvTzo5xh4322shcOV/jZtNNvSg/UmhspgpA0mNkqUxMbUmhI9 +vRKTWT9qHbOuYGCt8Kp03v0bk/oEuXF2JcviUOOG+Z/eflPTfht/8baSrTjVmcYf +NXHmaamAfoHzOvaxlbBXMfhxQ9pTCYF/3DWkfbmBSEkqxpcFgj5AWheSUHzGYrsK +1plPLJAP2dOWfHVlHoNKqvUKH6K5H9ruKgAFUphLMJwtugVXFv9gykuDkGJ6+0Jf +fXxBghOl1ZqdeNr0UrvLmxJoPs72VznWcQXJiQIcBBIBAgAGBQJNVB8FAAoJEMEA +17V/Kh4mxZUQAIGalnSZuIg8B9BSgVP5DGBoMgqXcExG/T+Ee7R4Edcf7YfR8evU +tWa8QeA7p9hVZCB53Ijdu4wkA+RFgZg62MjXBFrbfigDm0uXYmEdQosnsFPUwC7o +4PGSaV9gs5UezKkD1ykDajbICxAtLPZhyQ6Gpdnfy+oed9Fg1o3aRZMbuI0bN7Ra +wp+QYXeUhbxfraIGYOtI8nnuBJiO8eSz/KoFEQFnctJwg7CZgVc0woxMyIRT0AfC +ynafLMSwdX5zJPXO1uy3sz5U3+P+YmxTqV02KgIVr1HpOPQrLCdZrsuOO4hNvY5s +wTG26I1SgVraxvOy77MYWcs2ojTVjUopImS9qMjIyPgGl/5++jrAkMhWRxTzUFEK +x1Ib7W696JNJlq6nsYXZg3M1oJm7ayFFck53ldq2U9++1C2gGbSC+k2E00O3uO2F +U3q7yxY+dqtpfDcvQxjaVBZFfz1023vRquf/Odt+JyR2Pi/zVYO195PKV77Tsl8a +1p/FTN4jN6BVn4oe0HKw8ZdxOxMESMhE2wqhat1vBbaK9YWnivJbFhZu3BShKiWk +jvmOz17++aboGT1lLLE0aHbp/ojV6O/5Whc0v8PxbMMJyoZe8T1dDotC0pFvOLnR +xWpfwOin4VGEWnFmEBrLHoY49XCuuZJTKlTC2XQP213Hdc4CTjWjJjs0iEYEEBEC +AAYFAk1UfCkACgkQLxrQcyk8Bf1SlACfZjVrVpMijWXnLlwNZhtebz1DmC4AmwWY +WyaHaLbKjL0D9jspj1W/8+l7iF4EEBEIAAYFAk1U+1IACgkQ7o02PRaHlziNaQD/ +Va8yZU0v/UbrbB7uZ6TSrfzvf6SUx9Wnm0kiOTcOGoQA/3BcTLSDeiEWG/hbI2va +QjuWHCisRdbFx0cxSEFjxeE1iEYEEBECAAYFAk1VLqwACgkQvuFuLCp9giBgkACf +eTdajdfiNr135pdh0+pP3iTss4wAn3pNcbohhLfjowLPb0/yQurg+KKyiGUEExEI +ACUFAk1WxLgeGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5ldC9wZ3AvAAoJELR14ge6 +tYIpBx8AoNRcJvGN+QmiOqxZSBZkFy7zawNAAKCjBJUz1dzYDiDlRDdJEkIIP6R5 +2ohlBBMRCAAlBQJNVsS7HhpodHRwOi8vd3d3LmdvdGhnb29zZS5uZXQvcGdwLwAK +CRCUj9ag4Q9QLp3gAKCIe0+D6ZYXfdISEWMDxWVwuFfliACfVp70kqaGLsOR3duq +U7JNrp9ikVSJAjsEEwEIACUFAk1WxL8eGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5l +dC9wZ3AvAAoJEHoGhUIeiZBCV0UQAI0wf6PX48YGS1SlwxaKZF4UOQdaQkIWXDO9 +1OUwr0YVhYdngtWsj56qg5wpWpPrerT34ZvqVL8Glp0X7DpKBMJuE0RUmOsx70jN +ikCTsgVUyic6AWdtctMOuZhVMqgZSNOFiZ17S5LKisFfh6RNDUuLBjw1v5ntGuGc +zZt1tbT2HyncbrM3otohJNVTUFf6+5M7VPqC19zAm/vvwA9bJpQNabBVK0zdkCKD +b4A41RDwWGZ3bW6YbtYdmT4B4ldEAkSzNlaqD33w8iMOaJVYvYr5EJluDdfolYHb +dPlTZ/zzxlU+SlvJ/tGSFCV6gbSXkwvR0q6921F0WZ6+Cl+woelKRjZ99IbhlhN1 +JqgRyQGKa44/48As8m4RLlSbq8qCb2MNWaROXgduLKIADQgElTtO+RLzesNwagn6 +zt+8aDIlERhk7nwygxCVGv8l2TuBkfzNvIdeBJn5o7opfpDaEFbHUmZDOOWmSxWA +I0m4bQtn+MiXzEEbwyhxYZ+zP9zXf2CcyUn0Bz4nnPybr9XC+9rVQ6qTx1AFCYfV +1BFmKh93dQv97M4mzp9XT/7crtccyxHN8HlaC+bQCz0dJWyZevyPdqkEfdwDxpgo +lFxCztMgl3q8eA2EqN0Oo+RKgFKGyjhxi0jWzykug9yRLBLzQ13s/psuBauPchdg +O+oEADUriEYEEBECAAYFAk1Xw6oACgkQApCeGpL9E3JLwACfXFpGkHzknIPBQUfS +foMGu8W6BlkAn32Xh//Uap7rjTCvYHNLymp4YvlMiQIcBBABCgAGBQJNV8N4AAoJ +ECbjyHWnRCDvzjIP/A53JyzmjaBrgxiTXmFdTSMTzL64CneBd9AS8OAiJ+PPWHZJ +I8LjJzwt+8X6I8iP4GKCrcMM/yn6pbc0JP6HboEgY1JyFAf4Cd1e6DrYNrfGYSkw +W1MuaagjiBZmwFGsAy4dfQvla0/dLhQGdLDAhbpb4evfxMQj9VaGyBAPTgAJL5fJ +JMQiVMyI3g+PEm4SW7Lbt9/ooFREgOorY7GBeRLtoYMxkVcsMOzWcNZjgg1AtMw7 +ewRGx+JIaRPeDL7PWU4dgLvcBTj2YDDnPrpHp76xwncyhky/ipeQj7/+ZBqsaY0p +KvJON90IeDLL5xvJoFjrvSu6pVJnLqQwHNL/9dbaodiGe09st38ylCLZXUbaw+uA +/5fUUb6dpaeQ29RjXMpsz9uPlWnO5nrrFlkU1D/LGCduvw9WdWMFvWFXeNP+8kLR +hOMBhWawLXN7sDiy6R96GON3F4XIgz39UP63KI73VB5o0XwLSkw7GLlBQ/9t6ZT9 +/DuPhE4m2zIhUy9O479PkFlSmswWXzIIcs/6zhzrNugeRaT5yNBdgYaHOrB/vgQd +PzQ0FBZXnQOPzJ3mssV58PZQ9dLAXkYNCN1BauwyYJBACc+sraLWdE41t+oq+ghO +R84sXgT+Hw7TesJ4Ap84Ns8CF3s3u2bLBCNgG+qdPUXyipn5uZgSFw+7uFiEiQIc +BBABCgAGBQJNV+wKAAoJEEC/7oaLBV2aN5QP/jzgJAHp3mJ+j7XfVCj/462XDwHr +3RDZkgAnlNHP/XymQNa3m43bBnLdXy1sF9bMhcrBzDmC80eFXKkaJuOx1Tozu53E +ABDuMJV/ycu5PvHZ7+nJ4vxFCeua/ZiFkTkHKCHgPxwhtAQK9DaGnFaIsod0Ytj8 +XXaZM3eKLhfmsvOuHAbLpRMsEg/f3wlNZ29v52qywNun3j1OokRK9nOeVPqxbvKd +4yY1aGKsnnXsGtY336b8/t6IVhPGJ4oIUegEo13LJqe7xBoGPXfqrXlz+K+ZcLvT +tx6iuYBg8u3rS3hgvo8RASBjsJ+KclCg739FarftHBkrLltueMJVb0+aIKSerIx7 +1zR+1dGgY5KKMBu+ZiQ5zwLdUKdm+07WNYk6x8qCQOu0+1hZY+eOUgIlSa/iCYck +6MpOrsMYazIgTS3pLB1tHWpfVKjX+Q4Jdax6UFsyyPkIePwJDJSudEqOJwgA+tes +gIWlWnsb9itUE/TB06Bm1kNcmwi7NAWAlMMcfzPsla/Ab+sJy7AyUunpfQw5aeZV +6JfbYeSCwgM2vnXFgvbXxwlmUuf8GxV4P84pZmrGZt+xSHdVT09N/kbtOd3n2ZgN +25FpdY4pd+zlrHaVSWa9ByZ+MOenZKoChLc9aWjl/8xrmJw3eYCI+1ZL2k5YeZTv +hQQlEuO54iSNlyVOiEYEExEKAAYFAk1YLdEACgkQ3FzfxAeN+kGH5gCfYBXDJUcS +ROnbaU1eVgTfNKSVE90An30onInYRyuScQ/zr5CfUAxVh9V6iEYEEhECAAYFAk1Y +V/EACgkQOHp2lX66df8JwgCg+f2fBSlYrViPxyKoRbX3x1whp+AAoJaWkbxLYVbB +RQ6P0azqeLidtzA5iEYEExECAAYFAk1ZS6sACgkQ7oGSpuRD1thC0wCeMNgp5YnZ +wNXASkpB8vW7HYXVplwAnRUqQitdpPD0lmMWGJtgpanSi6+UiQIcBBABCAAGBQJN +WZf7AAoJEBFvXjqzaKTrmlAP/1l51fwvmvgN6sibadyub0CSkMjZucsNqK71Cmbp +Rv3PG/za/cyrZHXa3r/Uaphh1pA0FbXzRLQ+npavM4PjgbmEH5n0xEwsUi15xi7T +9JxqBWSzBOvGU6QhoX6Oajc7jnF93fnth/o3q+Q5tAMEyOfEvkXsNYe62oYRHWAI +d3OGklJH3wg8gYBdOJRatM+R8PgS5y376NMYgLGMKL/6UPBqqMsL+aTyVbeYFNLA +cNYUiv9QzYrHrP3UEWv6IKnX0xyXrrneSWPO705hl00Ep8fkGkDBS7zLkiPpPSPR +HYpg36fw2UdooSaQpCXqujuAgBmQP8hcM2I849jrLb4Rqith75lywBYUWPXeYQV/ +dS4WTKMNU2yfVzm4b48nAojrrOml31WmIVYQz9vRj4VOJtB81xuaSufe/vgMqD5M +RARwMz0oNZzUNL3mhvjkLVuDO1DbWKwwNuuVtepC/z04YFWqokQ1URj6EMvGMSIp +wnKeZHZlk+nvnW7DeD+2JWGcU2xJHVZpxfz+q9gtWbVI1lCAqsH7fetlkI774tQg +ocfk76eZtq+RIs266wF3NaGLpeoUD31BKLcgZUYaw5aoT5B9B2i3PAOAhD9uAJOs +2emUO4sT2zJ6dyEnCx4L17fzjXhqLSzzkzNSg38SXOF7/y0MBj3mdRLPpmWDynvr +Qr8JiEYEEBECAAYFAk1a8aYACgkQiOa6Hv703QPxcQCgroAzGRBf7WpiaIDVBsI3 +tigDK50An2SjnZbY0pJGHBBPHJBLgnV1ntv6iEYEEBECAAYFAk1b6HkACgkQCVo/ +7lJLCVh2rACdEa3aMojb0KC/x+B6tMSevdi76KMAoK61Egf13D+VRVYfEJ6EvPoB +QlisiEYEEBECAAYFAk1TE8AACgkQbQvHOkBYGDc+2ACcCsTLQZDeQb42IVCJHg+Q +38J/c74An20zODbkxxaoTHoTxpZVn0ZhiduniEYEEBECAAYFAk1YPpIACgkQ3ao2 +Zwy3NWpjzwCeMbyrhsXn0UANXhMgbFJpUMKT6bwAoIut6V80X8EsmNHClTZo69bR +GKEziEYEEBECAAYFAk1YPr8ACgkQL+gLs3iH94eurQCbBIg3OajOp53mJSmI3Iri +OGEVOSsAn1379k/KEiN/cGDD7y+LRucUmytGiQIcBBABAgAGBQJNUyTUAAoJEPO5 +2Iy4f3mpqh4P/181amy4VxANibc7N5Q0uSq021KcpUQbs9xrvURrSZW+nNPmDHEB +pmL/vuDlNN8SNknF3NBLzCfr426aw2LbNewb5McfajJqv/CWRATqMMdSCUuFV3oy +QKzzB37NBPzyZMrol8HsrNcuUJeguIqVbqY3lZkMi2Mml6mCr/QjK+BGadU3/dIE +wl3HnM33vBNMTVjfvNB4HRQQ08cz01EJzQ0JIYZFG1gmK8gJWi/m+lBsWJ+b+E9H +UEfF32kTUVtqfKcfgmaYMBiL7zszWvj9bN4mivmWDZQNeCitxwLzhZ/70QYNu0tl +sS9NnGop54Fiplqt6cGpD1jQganCiWB6EEM98ziCj5ifrMjN3jhp4F0VYyuZqqYU +H7FUD/G0SXo00c3paoPZWDAfxvHRXZgtmaY3+uCdLp+Uk1basLjjR/TW9tl+OsFO +JatHc2yKMaOdbX8kGAYTI758rYqueJ4oDBpU2x13XBqV4BPxU/Sxwy6zxh8OkFWt +yNb+LTHyVf9/G6FJKIuA7eyxLr0vO1N96ogwY4kGIDp3HZGamWHMOPnJqdLBqdUw +RXc2HYPEhLEf2g6abPdthE5VGrrehpcqOiWkBnlRl9jaMAebbvAvbsLHL0V3sNks +8mR8tCNfih1j7cyXUKaoOPJNqSCWCNHHzUcBnwBOMIOQSZ0V/nccLr0XiQIcBBAB +AgAGBQJNXYFEAAoJEL2ZlXIk5RGerOIP/1D+ptmgkdC0ZY5kTX0A1cGog/COfs1d +fVGHi9Vt8TUcUuG3xS9y4mls4iNAU81mTfj8JNUcdaLc+mafp83vycGv8me40S5v +cBwmFOh2BSs5NeqfOTDPoNfsPfo6QEg2B3Cfl9EEB9+8RuchnrnWJgcQgJC7/bT3 +DSEw12xQcBRFBfoNSfFF46uczHmKCOGuRIruYVCiJXLoGDdP9x+0eS09RxlzIhD+ +7v8TFe8XhS+l2XL0D7UsmbqY+q31Rw2dKpDqZcW92bW1avmnE9cbXnpTQQJ7M1yo +8xqyAYDqtUWRsPUp62xeXHOAqARDqq9581I/IL4v5kWBFSRw4XIaFqnoskBVWWGk +uAXNCWnkahUFYQ/jTAh633hySqX0doa+cVeHbReWp5eIKnDFY5Kn9EdBK3U8bKXi +5AfdmUmdAK8vAMRxy9TDr8Jq2mlgh0GtaHx2t81m7HGUB+dOyRA+97qHCW+6O3o7 +eDUJUgOnRCAbCRX11FR+WkjTO4GKNWMnmYmO3FHExaQZHmjzktv0MCHQVpfWk3RH +YF0VoqJNgxWKG5sOghZAUzoFcKzqt1P7k/dd1cp/sNDWJy5mXAplvk2Lw+0jMXo2 +tZ5xZHBI+t0PdzoAuxGCBEV27iVtzMnN45zmhsS6TpSBhQcbQ1yCDLrw4c72VmWj +htGK56M3ZdBziEYEExECAAYFAk1dqgAACgkQkDXDf3AkB/ephACeMwyih9kdYqbA +Erd81FMlMOP2ymQAnicz+bCi9Np19SqW5+EJ4zy8LifmiEYEEhECAAYFAk1dsFoA +CgkQPHmTtDdFa6xqCwCfVaLc60XqFWb24VqSwrN2t0eOh0wAnjrrTLPOb/S+eCfb +ARgs/bfu6YGjiEYEEBECAAYFAk1evFoACgkQe/sRCNknZa/KgACdGt956d/UCnKM +1fbWi7CqHPUsnKQAn0AcvmyzqzT62HyZnTJD9YmaUW0fiQIcBBABAgAGBQJNXv/Z +AAoJENNzD7MkeDIgx3gQAIPrpEcCdEx8hlawvgoHSi3MKPxLUX3EZ3aa8k1Fxe/z +DkRs08R4EQ3eA950ThwtnCKSP+qQkcCjwqX6YNQlyw9FpqIoCkcUILxvgJk3Crq8 +Dg3Mwssq7/flknroQTV49IuuEzUdLf1C7JtXIJnXqAQrmPocnYq0ZFbcuExq1f22 +0l6FRL4pIT9mEgfIKXbsPJNaukpoV9TEXr+/JdyO/oRr6PouyCCL5RQ3Dc+J3eMR +RMOA3KHGDfwu+lXMKWtk9RWtVs9EjjVl3AmLeV1EqEfrq93GWX5zmC+TGYGpGAUR +QqXQoywoMosJ7J37W0idEBDE6ebU8v3PC9icfctcOQpsErL5iGIMdM2hp4omg381 +klCOkqeFxCz36IX45lXr+dXq8Gw0luVHOJwalmechgszb1erBXMdTx2fhvvOJe+H +TdohMwI/cqcUoVbPSz+/wbEqsHFQFfQspFCciVQHrDkg51IIzhX4AQo7zpjdS18m +zONmYN0UYYFWnMZCgCqaEOe1ZKim4u2niiR5eCRF+ur7UXueipJ3FBoEggeKWSqe +MCFBp1amosxhZleMLUeLjiWW+3+YoXjdMi6l4NfBrbobZpLrxDqhmYTOQg27AAos +oIKDaCFpA7iQQqqGQBGgqjvWdQ1Uce78yEKGO2Zkr8RHsqBBE51C/DxS4bx9yVJp +iQIcBBABAgAGBQJNX8TLAAoJEAMD31IlyOOG3ukQAKa4FeTnlaeN9hH1M2iwq1R6 +p62pHQ+74y4LhbrZ832K6vT1fGJen3l6B4a7XtFZqh9hwfwixOlg9QaOS6ubw463 +ky5gs0F45y9c8Rr1yUjUUoIweXXXVfrX59Pw2cPRZ5mnsvXMjHNcbNcZ93VjuMq1 +Auxjqixp658A9/Qdxux7rDCFLQ/EktN64SwQxNgy5mCKlPDfFWEMh1m4DBw9ui/v ++YckdL7fL8Mxw3REcXbA/EFS59eOVnSiHHwiaNUYzQ0GRFJp+rZKrSbyrCUL6CMA +aB1mUwAt58wfEYVevK14cq3jAoSQ7D7OIWz1OYI6pfABJdZaJJAKb+kZ03YYQj+F +ltQxuouifdmeqZh4S5Y5YHwvLyZ2gUGp3h6pxGl1arnuCXfM9scu0ilB88Si1frh +lsC5CHJ4jhZN7tvJlK7jswEPXQFXPRvJ2KEeO7DRpI0Wtt6pCK1wLrLL8uDhv9xO +G1jCWbPA7Yy2rYoh0fGZIMFw0W3zWTPplFs8gC2HjuE4SyZTag7e3g/pRxkJ7BRq +6rv1mNbi8xB6uu4QRCXj6I0fsmTIU7DNLjIcE2gjDaoaVJiQ8E36ceeatMaefm/F +9m7WeZbgJe6JSvV7V6YMdP087evtlod8zOyzpVQ85yVk/5Vm3QJBccO9Ad97nMHs +80LgBWPTcXD0ct1A/moVtClOaWtvcyBNYXZyb2dpYW5ub3BvdWxvcyA8bm1hdkBn +bnV0bHMub3JnPokBwwQTAQIAKQIbAwUJJZgGAAYLCQgHAwIEFQIIAwQWAgMBAh4B +AheABQJIzrAHAhkBAAoJECnuWLmWhlFx+SIMGwUvNPpxJmKFQf+dz/BMJt6jiDpJ +9DkElx3iLBPpYccXtpwo5dsKLt8ncI3p2BC5O8e1ojbA9kfsdMy5qfkZxzeTH4pO +V+KU8JRP+ddR+FUmxt9jD6fSlJ46qphgd8xCIcmwzwAVAW9mWc0Z+lCvrFsdIRXY +KxXMUEnKCsVdsfwACzUiV7GC2zN17m32+1HPizy4DkKgrdXgw+sBr2JMd5Cfq2G2 +VxN9iIhW8IR/vjLgKTyb/w50p4S5kHcLqi5/i9c+IwCey79rWfbavWRmBJYpdKXc +3pT76IdZ40hhZhvftke7Yhw/2aVsW0T31GfGlXl+41Hi3ztymWzWNJcIDnzK1lpR +6tttfSWm73OZ1b9nadwykAnM9BwLVtr7powUzdZ2vHQ0ll85by817OPgMOF9H0j/ +iukiZVUrHJggy8ViDAvfsq3cVg2nzrEVj4KxSEZNmCHXlOwWoe6gCK6hldffzUTx +5sLjTsFtevVaKO+BH56zAW+kx8bzlXXf06BqLvc2GECIRgQQEQIABgUCSB3m3AAK +CRDhXdhXsVw30QaBAJ91ZK45pKmsH2JmK5Y2D1aMHJMn3wCcD+G95oQguXUGe9Ya +5A7giU3ylvKIRgQQEQIABgUCSH7ayAAKCRBKChvI5PT/5v6lAKCe5soZIh05m3Ci +erCH3lANYVFtAQCeNGGLsoqHHWviJsn9XiKMcvAG8uaJAcAEEwECACYFAkgd5bQC +GwMFCSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRAp7li5loZRcSCYDB9W +3jROns3zcDa1FajxbtLibiTzDOaOoKeIiFTAdjZXmwIkBQ35BDwYa+UhQF2DiywQ +WuJjvUvesg0x5OtlTCBu27PltRvrvPaTxSnKe97X/9VVFkocX/rrt9+hI6NO6b9c +Rm06H5gBJCZarjZNbftg2sTEmV56lTQBQGnsgGOSSI8e6GgaXMIpW6ppZflUc8Ms +P5VZptY6oj4e1Tvca6azsH4YauK9WDXw0rbavr3xKmaM5I3KJLiRByciDJZbEYN6 +HXYuTenjMfE7Hq1Janzo/dXg8j2TV/nRfZD2e1UZi0sTYQBoVDS6DthpWHnO/+sO +bHTj1e2fxS3+Jbw1lbynY7Q6YXZLXJNSk8OnpW6NeHglhCABgS+fgXrEZMzY9wzY +K43bUyomNB5x4j4P0n9U8dDcQ3jivGfW6UHFnZO8e7JuwGdMmrR8JGqh5zOpHfLj +7+43BW6MbobAr/fBq7yMdyCYmFQwmNbXPqAHsDgBnPOut5f7J5xBAcTtayJ7VeZy +N0jTiEYEEBECAAYFAk1OpR0ACgkQaeRidk/FnkSKjACghnZk8PjQB+gXHktY8QQE +69JlrmoAoJwOA08rV36UZ6appMM98u4YvIcNiQIcBBMBAgAGBQJNTvdZAAoJELzb +lbcKo78O14sP/RTLFKoTWKPPo+EVquTsvo+sUVJGLqCPedCThnyBZ9pwjx+cxVPI +f2Y5TlpB7GLpEWHCbZy4w+SvkC57d0EfaYPUMmMLFcm4zrIS8DPcxeEblPyuHUNX +mZZ9YQ/3asFQo9sSaCxGJYF5ihyYctmF3zwkq7Aw41dw9wOhJDfxC8wIe6SHEer6 +3JdyJFGXqRsBOmN9Z27EPqF8K4tM6gFexBd0hOGuJhTolva2truk0Yh+s3M4NhPX +Wr6NmDpBHGurVGQjjcUP9qy/MjWzhhu1U30dIlyaIBlWJe2MuIbnXkMGUZYuf+I2 +bdkjmmZjzFoJo8hmPBt5hEBh994hA+jF265zRYfpYMYMGJ+ZKUW5irxU4sElCfla +akXxkGbkBT9YqyR+oHX0gN7tzaDF/p2N7yIJGZ40MV5iz5goMPmGOA7vMJMWtJjp +O3rUZu7JpfJwCiCjkuH6T/pRB3vuh2gUrwHmZoz4PBHRZDYjhogc4BsHN+QeVlJp +Z651p6+NCPmiCbqFZO+IfHuPwoxwjM+fnC/wyKDdDcSVMnRYijc/2gCI+abE3wSz +cQM2xbMPuqBGwKEPKlhSaSGYzF3NHwXv7V0vHtIqA86hI3DqiCw1URxdXDRoJp1W +eAl8PClP1DAZUSUP+16xheyIowAMDW445Ui8RkUtOqPkZJsTJUFMrYqNiQIcBBMB +CAAGBQJNTx73AAoJEPlBB4h4NHwMRh8QAIWAzdaD4dunF+WS83GTETwZ9J2wf6mW +FZ/C56FOqdI8jGuCvFjrCNSV1MfpXAJnbCuZkfScpFeAmP+G7maYqtencj2q+Qaz +fGB60f3Jz2vHBjCaK9TFKKk8TtarHpwfvc9m62ZShocbf97chi1E4gdJdV179Lgw +voWBQELTrUt2gofOCyKSOB/YMJNmbozztBlfgTIb65m8j07DkCjiaiNrqhjy1aUx +23M4WHgsp6SL0HUAks927oRZ2hfihHS/nbudFZjHp/tcmQ1U4m9BeZP0G2moD6Yb +CYhRSaKcaBrZ7Rjmhl+3yoSA9xeL6ftEeyyUzk+SLp8v/4cp4HPW4hvRVF2mj/nf +IdnCl51faoYhDrWGa9uYq8WHqbyDJ7UEFvf+LHzZx83efyPOO99xsd6U7OMBZsQf +VSGKmIxWW1I2/Aj419gPyoYc8E+xNqeQ/OkXe5u4vsNGw9ozlrt5s6iU1SqtqJVc +YqjQoK1ErdtFvSys7rPR8EnB3u3pc+yg5+VfO+u4iy0OI33jOLB8TqcHIkus4DPY +KOgp/wnSIApkpXJoeTTZcbwyIshv3paNOEJ9w1+JEQeZ3umvc9hmRLUm5io4hsOh +G3r4ioNgZU0Ue9JAy+ML7i030Y1LdCpGTTKJ6R0/EOtPWPn8+Dpvw6Ir6iBodlTf +mumXZsVc5NCuiQGcBBABAgAGBQJNTwf6AAoJEODYD8Y41NWH0yYL/jeGGhIOqQpX +iaWNLfVvUlIAA3lNaxQZ8VJTfypgU10QMWMyUgbkSiq1aI09mmuaOjbOhrZILVSz +gQZcw3b111lnzdfmRR4ONE6gr71oyaJ/EKcf/CmWxiUcC27BIMFciWCYLLYdnXRQ +0qf3q44QmNZVrKbJaInXll4a8JjQKPoFRqXW09nWLxZnLydrZBNxMjuLYzrSdngA +aLaM3a9QLjGIzqwAsHL8afOzn1JXityDZwtSN0EQH6LzDXqcfnq+ws0VFE2GPexB +hhryYUA2+wj/dnTxdDilrbR39JLOjO7h1EgJE6GMjek0kE4jr5bjQ0dh4frWK4im +6Pm9pMtcgUY+3yqbO5HrszY9FmtQrilgXIlpLDYEWPYu/rjKQ+p+uxSAgGDyqeN5 +dnRtX/iPvsIWkTvwMBoBI2/zY2J/+2CMlEAjmhhWG73S0808b3HTOjwu1ZhDK9G7 +RWHeHrnwfpfMD4IR5p14mLCBlJwQ94CgNPU6L0mb0Fqi9U3Qs0Pv5YheBBARCAAG +BQJNT3n4AAoJEAJasBBrF+oedMYA/A0PSAv11mnhYOxYZJgTodrAQc7lZDMjC75V +gIqVJm7OAP9YmZaZyA5fSWhazJb0nTsCWobq1OwO0eXwO8qJK6xHAYh0BBIRAgA0 +BQJNT9FdLRpodHRwOi8vd3d3LmEyeC5jaC9kZS9rb250YWt0L3BncC1wb2xpY3ku +aHRtbAAKCRBxbUQTPYwiLU6/AJ9CMbR4ev+QdqcJksW5/pJfX051SQCfTorfOtL+ +BjIwusl6Ar78uS7147mIdAQSEQIANAUCTU/Rby0aaHR0cDovL3d3dy5hMnguY2gv +ZGUva29udGFrdC9wZ3AtcG9saWN5Lmh0bWwACgkQVtUpPsl6BlTnzgCfXBrYdNSJ +H0ay907U5Hz+r9rQWrsAn1a2atSn8QjSGrQgbLXhM+pYd2JbiQIcBBMBAgAGBQJN +T4UsAAoJEJmTHiXZHgEsKH4P/RdPtZUdilX0Dja0Gc6KNIkx8Js4QwT3Ujg9J7U8 +WIg5pFVVAZs+27E1wUEobJsjk81k8hIWqibeMeQYq76rExVH5XUV9kcOXvCh0ku4 +Lp9PRKwtfOYE0D3nwn0Mu7uhjYPK9YiyegPr6IYuP07Bbru1wjual00lG+5ENonz +xkP2hxjeETqEuR9re/uaWZE08iuND+L37uDrJYsERFEksSsMGsq3IcuJZhgu0mi1 +AwUDd1yo4zcXzci7RIJifalIcKEpxuZ6s0ddW3Li4/LVFFNdn+ReYJvRVQt1UUh3 +yf4NLfB7Jkn2EMKFV1EVJMeuevNXvWnp3RsZoEt26iG7jyJQDd5Ci3LNZfhPMk8d +3+NoBxUBRE1qifsFPn3hjAF97xeyzqcxt4GF2hXrRk4ZPkIglX2a4sL0647Q8ewr +h10SYPQUnqrBh2XDy3Dz/jnRB4950jo9hkxQmYkY+PweN1v8ae717dP+qipss/9a +uZ6ZturqZ8eAt6TP7iU62WT21dGk8o1GE9hOkZ8DNdbLNUt3x+YF81kKzyFZKRiI +mgpaal9T3Sh78yMvgGwaoCigFjZNEOAEiarwk/udQP7kxTk45evqDMW4GbzmxVbq +q+K6zv5ks/Cp5jpBHhC7xywI2qezzzU2bVCVz0qXKeeUKq42BDDX5xbmzuvrpHw5 +D9EoiEYEEBECAAYFAk1P2tkACgkQSTYLOx37oWQ22ACfZnoA2E7hLlyX8vIY3d0F +8HJ4vzoAoMjEZE6De8zBbw/l/8J66vzvWQh6iQIcBBABAgAGBQJNT9s6AAoJEH6X +Ksv+CnrzehgP/1i0OD2V73dncQoYb+kiX3nfcvPQoBTVWrIDR2qlteKvKJOMD5SU +NywSOzv021X6FViHqO4GF2ylwI5foxskXBVGDBEUB+lRZ3vTkcEy5+2S6mfgpXrX ++q36r5s7suoFczfB+pj5hxP3MMjxP43LK9BnIdw0WP9jzGUgG/2zmMHz43UDFE6I +fCWcDT8tewSy5RTHPPbYGCCepXqPy7+PSTYWJqibp8lXX6yVbV/fCmsfdwPaHGSn +OWEUQZatsntucORt/c17J8UZ52L0Z5RTHtjVcw5sTWGrI6EvN3FuFBNde4VytjnR +BYBvXWFJMC+/UtpvKi47ma255o5jjVGINxyRnZcco0ZE5PruR7a6zcN0/kDvgG+t +gWhnA3/rtnf4vDr8SvkiqHnYDXe9477mQQJxB2qVjEjo+/yTlhIqkufXntIg7cY8 +SRqhHXElG8QBje7pdEK0uIgG1r8wR1wTYObXrHUOOHGRIst5XMsMQ0pld8UjpPFf +UXa9zLfi4f45W00FWTs+mxrG9TUq2GXf+f+88R7aZrlUHQcprui3VP8XKNjQasn0 +NWptwtmnPHhttoR/7UJkPAGokudJ8/w73oFEMOeE3lIGVDnR0sb/IfpB9AvXahFx +WB8czvkBJ9XKW+u6iHTeBfOWkLClNW5h7JSFwjc60t1wis1U5xm0QbhLiQIcBBAB +CAAGBQJNT7aCAAoJELWetyIC0bxlbvQP/izNRABnlXd/QvFOoykMu0fU4/Gu/tYy +UdoOgP+33Pp7aUh/TcdF6rC2USiBBTl2TiMhylFvASp7OKEqJ3eMbKWJLYYUKwig +o3VJ2uSLFENOa0ID166/nRSInC0BJ4WLtp7tGeMEev+Fc9FKnZJpPS/Zo9Mwu56L +Gwa+yiu4oD/8nV18paldyUUAzc/run2NRlDwBCsNtUON6gcSTSdafo5d21pbycUA +dS1BMTY3dEjh3IfOo594SYyU7ORSrx1g+7goPjEg7NnW0c1TzHoSM7IVwAGv1Ss9 +ljYxJnJbpSJm4vpEUBZcPV4sycAacqrApSryHz49o7YEQ/jqvmE7V03XtBEe5IwN +KOjz4N/3DZAD4+J9RLVognMEOpusaKk4cVTZfI0jJ9ArAFwHOMg2VG1/wgFIsNDu +H0HFWDM0pNC7Y/vBDpp/pbgVAeMyjNZnT4P0eseM8S/H565iH96DjE4ip5etwbWv +eJd9B/a2F+qeptwdvaLe0xKf8LkMdOOWBLkJXqisP2fQCUgtVJvDZOmIdFbuGiL1 +1UuKB07WjZ+UxEWT2199CMSCqFRNdHpYeaZU3LduVVPxpzQQ1xPs6tGOezaBy6rg +v8I/XiseWsheOrW2XPZOg3breS/mvSuySvJYVstBn/BFl6957qWTokqAjXZLaScM +xk+X9wOLx5/uiEYEERECAAYFAk1P77IACgkQmt2HQVqjIlYD1QCfRFGLjPJgcO+I +4psit9iR13FTKKQAn20JJgouI1sJgi0IJtitX1Kkrn0QiEYEEBECAAYFAk1P5fwA +CgkQ5TEV5bihnGlFrwCdGhn/XG7MwiMsORLg+ZxNRl6oXtgAn1PKRCqk1oc6km2v +e9aYrZwbtu6KiEYEExEKAAYFAk1P92kACgkQ/LC7XF8fv3Br3ACdGU87KUx9HyCj +V1I9021OHMuMYi8Anig7MZw9DBCXRCgsUAX7JP6cCTX3iQIcBBMBCgAGBQJNT/d4 +AAoJEJ7cyZHZq0V+Aq8P/14Nn7Ec3cjsTnkbFzU0JzmZ1qcSUc6u1G5nVB0GNURS +eWqmfjeTuRyAfY2wjg+VyW+knRByP95I7GpQN+WDTdiRy0Mv+Oz1dAYrqTRq8xMQ ++us7BIkzG/nBNwHDEZ9mFvWa9fRr20DHcWIy5xvIxPqgeX6Y5OgXj1I4CyPy98yE +n38FAUKLM6BfwXtThXC1sVQdbIlo9Gepn1wkOhLPmFpNdRyP7rJXYVh+q8qV4qNU +ln6yhwBEVIuJrNXl1+m7xThBtaCYJRpwjyrINgD/zY/oyF4XWcbytzBoRWOBVWJW +AEWUOUTD2l7GhmwpKhnZcfpnKWqC5Z+R80yCHZmAQC4HFoJZocPasyETHZJRBH8g +5iw19H8mM0EptmSKbyKOBG5RhyPHZYygiX03QfynL8vgLO3vEUc0/e1BdTUypMuV +LKS60dfD4bsRC8FO1r2j3Xc6YWtvIOzgF12u8r8KHkKUeUkGiibouzUJnhnQmZ6n +boIDgVSbWI2iihe4t8P/LLrdFMscAmob4P6zGTJlJXdJGPek61YCW1tQSof8QgMu +v8lAVEwec5HGqTgGBu9mQxSSi/W7Dpe3EHUdP1ARughCcXBwVLWQlLyeTSnXjmUU +h0zAj5RUWCoLR+LdS7lBS013+e3VDx8iSz4M31GcYcxF4UJ0trF6EoD7p8Z/NIxA +iEYEEBECAAYFAk1QBP8ACgkQjbzn67sZ6APnqQCffIaneh9hcomE4cvvDkbE+wWi +Ms8AnR+cRrehdcJ5OkfQadS5ATKSHe3BiQIcBBABCAAGBQJNUCDIAAoJEKgvu4Pz +1XAzCP8QAMifbimyKsC81WsrO8oMWctqEM+qHGZyupo9w7O5mfoVgtJQB61uKPAE +KgIrgUnUIii/qgnXbisBxWqMw9ifI7+yc4Q6GMjpa79PtSobqdt50io4cVXw1rdL +OF9WSg4GdQvlM7X/bvBR+xdYkJQA9SITbYgYpNMHM0W8n2/cfO0DquCy0Ks30e5v +RZdJTHhkYsSuls2cfW79sDXtMLVGmbp0G4Ec6tXHGktpLHieRzgFpzEZSOudNL9s +d93/fvq/2IqpIFdkN57mpk66vTxkUI3mzMrBEXaIkdNMgrO6XbGxP4+643RgCNcw +fKkupHHriG0wIniQu+ICWeVvgw52P6Q7/JefLyJkPBuaE7Kz0BeWvKJnel1wH6iX +8mS5v44cX6/HdYGr7aK4lPcdUAZ5JY1kAVffF1nKqEkVb0uQtR9EAiV0GaUFN2Bq +/dDTfwIuoBFIfUQux39UB/yS6KcIrbLobqo9zaR6+jTH35lNX6H7yMNZTAaNqMoM +0C5ev2Q3335eaRrrgCLb5eaNjjuJXxXsBl8iYgtQqQ2zzRc1qDHcz+sy45jcP3Fy +STHnUrKe/7gXVDIVhxJiQaM+ecb74ajffnCwIzTOZJvd+y/n2rljWXB0vJ/l18Vi +sBVY3XnfNR3Fcr0ahIJpJMuNQRg8/Sf7po/zLHPWVkcrqJCNWN8ziQEcBBABAgAG +BQJNUET8AAoJEH3DJtrNcqb92yQIAJsvk6JLoDTkUuJzOd9xFq4vcHtLrYo3ZLMg +AMYzvSrJfpUhfE4Ei1/SBvk7O9nZSvnSAnq5Jp6B1+eXFpMrPDAn+8v3xxhyb0eh +7NqjP0XlTy8T7Pm35zIaFDLZojzt6uERo+4uzXESXrzdTwbGrfmZprDjr3ttt1q6 ++mBTciZsykmVFM7haBKSO0qcKu/570L+qKE5l5YJ9qFQmQ1aO5UlTKeoWVJrcy2T +IP9voYdWs52jOi5gfmfqYleopNgE/2XygsE3sKqSHAzf2qfzqSDOr0iDyr9WnNAQ +GO/sWvI8tF5ZYK/AfUeLiZOnPGYHu5sO1sh9mzl3jqPoa5eMi1yJAhwEEAECAAYF +Ak1QW0AACgkQ52EC4M3+rC8LPRAAlbpDZUUb4CwtSoQDVpR0z61OEbBTR7MkVFnT +w7V9FFQdBaRahw+qcv/0F1yN9X9ZT0BTodvKchFjENpfK9/XijiQevMkKfWdFDly +J+rw2r18RIZ1clyMJY0/ThEr6ZaG6wZlunTUQq22ZTfKTTGMPsrkFV1JBaLJyeRe +riu5S/vY1ddHK1s5kZGjxYwn2PIMRgRhDo0DvyOUTh9eH/fFuTmCky0MaT8bH6Bk +Q1loaOrsq24hNoGie38i7YbAXYjh7OTZ3L88jYlFzKlieIDwfhMxoVANqktkI0+x +Cb/NAXhM304P2fW2St7Ocg/XroUxuAdtqEX8nu2SEqF8AXn40uZNAGtslVsS65N/ +3bty72tcni8i+E6h8gbEdj0sMsID52/Z7NFVCT4vUZzvPgenFOCdSfzXOaU4b1If +OxzNT2f78Vg6ndCKqv9Pae50kcqt4zcLZGzY5wsAgxz/Vmk4NiIG/MavfyjGUjyl +ZNs+j5cBsW39xKKHN8x83T9VQWNCy8u7hEm+SePWYK6smYSdyt8uGHzIcihJzlbz +HMawFKCjoGySF/ziIMbaT4G/3ekVPFfA6mxT6uG2CGTCq3nrrk60sXzw/4cNwYi2 +32GNp25ijfuowJSBInfx6aIDazAwzW4AvaZjA1V2UVFQrSxN2hiSbSM0FMG/DJJK +j/xyrIKJAZwEEwECAAYFAk1QZeAACgkQ4NgPxjjU1Ydn9gv+P6+C/f0RgfgKXI4t +xQifqXdlahAswOz9MZTkcrRYuT4/+WPAmis2Y6nPQP47pKC5+qRL5LKPBPhoBXzM +JpBWJ3m+ZiAhtgDs0DF/RCq95MiB25W0gIYyUxpys0TcOeUxPbl5725fDkSUZLqs +yQhUd0lISuoYmtQYxHtxjwtXkh473nybg7AKO5NLrl+3D19E3fAaZUf0qO50skOR +yKYB16XrOzhFcVW6/j+hh9D9eEzldhKgQasGvHBrO1SO1yVuuqtX/WQ1aGdI+aXy +nqb5eCcRhxjQGDx5YnqI4w6vnfyDWAtM/QMWXS6pibr2IWlj1dPwoIrg0yKLsn9n +kCei9xdZa+L2fnrxp2Ag/xh+5zLEXCQE8ruP7hcKx32X5LAjXoGrWv5i7njmA3e7 +ZzvoRsP0a35PrKVDHbUpW17+rBVUuz52HnSqNeqrH21281Q34Mfi0jja5bcwLKEX +e9t4UYDXBKQ/vvu3DGlszhtbUWmNSpgIG9gWckGkm4T/m+ATiF4EEBEIAAYFAk1P +6jUACgkQnUKBHfuLs3Z3QwEAtklBLDDU4slBNg7aIa4EAZ2K4/Go+F13JS16re/N +5O4BALPgNAB+0qLgDg/UQmDmyFjIO1r5vtp97BeAdSwm1Y64iEYEExECAAYFAk1Q +Z2QACgkQL5UVCKrmAi7qFACgjLJp+SJqhcuWnZzPcUz4wzxq9uEAnR2PIxKzxdCk +CXOsatQI3vIjWk8biQIcBBMBAgAGBQJNUGdsAAoJEKwwh5qrVbMSB8oP/inR4xG/ +WzfRfjQcgVE74fqUcDnhdxgf7rhR0rwBfyR4o1JDTCD6qewgRUaxVeL8og6EBVXN +RbzZMEcILpnp1TkxgyaIwGDF/6DGZFLnu21yr7Ggge8VQcQKzrLalu7fS8q3F56T +QoG6wz9ZDc4FcjVkf1SqyTCRSs8z/X8IlQAafxlJ+6OZixn3XLm0VIugmnyLIb9C +WBc31W9whi6yaPSbRRmK8b682UUaPRX+CNdvGUF9bmSOO+UZ9ZbZFw2/aUM+gbqf +PSipj98L7eTrgkwitnw1dWqo0slwQvwSAReuEShRUYK/AWBTOeV2E6akKA//1JXB +CIyqo/49KrOCItQooC4Lq99vni1/upkrclUX38YbtC43dorys1RuBO6/wTtjmXH/ +jkLosCz/3AdLVFMFbR3VmdwmgB3HMecoqEAN6JVELoWHwYorlICmq89HGfG6mfFW +0j5OUrOcAh9jznGepZqld0teleNGOUxvrn4IBhYXmpjLLU0fQNepnwt993a13p9r +RH8JeKDbpvf1SZSsKmnEtNv7Heo4/Cq4EqCQOzIeGPPx5VLvEgRQRJBYtDpEgRil +NIRlbsAbY8jPP+jqNDWGpEVGgxn2Ur9Am+S726C7xxGH5/wtoOJ+sdGxYz1kOG+2 +DdVqWvD4kYgeKdeBOYRZz7bYJYUW0Wvs65TTiEYEEBEIAAYFAk1QflUACgkQ0YHd +emxCgnJ8agCeMRp8WBYWNCbqUHvwRO/7p99MgJQAn14s6L0GpTJYRDdhwKH8VUMZ +GUHJiEYEEBECAAYFAk1QeywACgkQMAKNJEgTtf7DFgCfXTyuaCVRMaL+y5c7OfkN +NtM5+coAnA5/AtQJuGbXeVJPevmp4CCkEew+iQEcBBABAgAGBQJNURGNAAoJEJyv +zxFWdG+VwOMH+wV3QlGnBhIUC44urq6Cl1TzPrgg4mN8B1A4XRoUZmddH5t7XNWV +6YCZpkZh96PJfi8ldi7BpQsRHpbM5sgXWhMnG/SiYAu8aJelwd25qdTVMJRKc7UI +z90j13t3zgD19Dan+iODz53nMwaYG6sXFGtp/PusU29y5mkzORSlYSdJIVShOPcU +nIdx9x5xK1SfVEQIMUVaVSu2hkbBhO1ItVamjdyEYLpEglGPOK+gHuHfgbsuFmH8 +jkemXfDwCQbmR3LdWaW+OhYRm4A2KcZ8YTn44RHZHN3rdvp87dJPq5ZzNk5RL4p9 +LrxJk7xlPhA+QXtXVCz0DniI2nBxJTOD9f2JAhwEEAECAAYFAk1O6qEACgkQZ2YA +3NpamUNVLg/+IcrO2swBtNcGiKYQByDXAEMFKyUZyy82ItLucVIkKcepILXISBGS +tLuEB/EKl5yl7SvEUJOofJ3ZdsP6WlqUkJtZDZR9IyrojVNCg2r4BsPTPVuc5icB +esl3nILdaGgVmUdzYScizC1RKanD9CytNpExCq1Sol2mbO3/k0uNiw9Mpq/CJfJd +HJIaJ9wOCT3oGVxZb0Jg2+V7TMnNGz/xUkdG0DxVxHuGU9ITzcEyvDGgEJM3868h +yR/R997zU78gOJn8tftAkxI8GuEBaH/jRv9JUxVpIODZ5SHBeozIOX2aoA2sdqoN +f/mKqilB5BQkigdcZah4SS+oy19l4oJW+aRoTsC9Xbk6wBokOnK9xOkwrtTn+/gk +b9Wj+EZGKYu4M97t/L1bWVI+Dj+JaNYua4MbOIRzoZihLjxxtemsScb7dhuzqn7Z +rrOLLxfmXUibr7fYbH9K/P4vhf53vSU38nCa7GrGU5vuVoD8m+cSVWvTgzWeJWqz +NSTQfBJiNuTKUDqglkhZf9Wz+YEXfZxcve4xrniHPKnn1mAmaOaaFg6MmFdM6ods +seyMBeJds1BqfgHKYydcMl3e0UXv1Op/0n4om1wlhu/kAKnDPkhJP2yJzVKEXCna +DG3gmJc0dHtudMHq484S9xLNdmWsJy0wzZzIrtHpbNEISZm7PzsYn3CJARwEEwEC +AAYFAk1Rpt8ACgkQ6VqBuJ5Bvjar5Af+PlVTFRMO2D6MeyY+yLUjTHTahq1HUyyB +9e3vxj+R/vq8eQ7lDQLz2QA5h+ZUMYXNYtWj2cf3DtvmIzgScgz1zsW4/ITPIf5/ +tnQKcwieMCRGpsDwm3say30QJdb6vsjRRJMuIXrtwfri/RdlvFYvqZRxpD+F55K0 +cAM3wFX4FIOLBFo7V/unnXUyuuA7AxAYcGtXFl9H6jjtQEc0KaHgMghUrdTfn16h +XfFrNrHWCAHLh6scC52x9JU1lVsj6Q0nXeqmY8GC0XLs6uN5uXGVoN2fUaxygL6C +tqAR50cgFz6+Xa2kSdPT+xGbdCVdHpdO316nUanGSnEMdbn7GqvcMIkCHAQTAQgA +BgUCTVHGbgAKCRB9FZHGnvryhmQoD/49Tv4Yk2xRfkEZykNYcmeWI+ePuV4RoOkX +ehWyUPn5A5TAdSXKpeSBQ88nE8Q583x+DnbiHCXhUY9G9QSpLa7AXunNWPNgWxCR +sGuMSTAP2Sj9xVD3AD68z7j91DDpOyd4u5OEZPFQyY4orQX4Amt8ifRXz8PC1hDf +80KEMRsaQrgTwRfGx+R3JxmbvXwA428I+ClMPtopfloJdq6Ye7ECewZIwyhiywGx +NKi5jc+zZHKfiz5X6PpxIOgftnc3yepdJ1DOEMyp5PP/4gNOP68qH/Uv4WSPqvia +UFhcNG/GFnD533LHoiZAI2nWQTkYy05zzKa7mX+gOWMSQ48PI3UDOKi9G9NVaSGA +HnPX1qA5/eZJsqfB/uGiFHlNPdsTgcIQD66D/xcVym+9rozixpadGreKNcg52Pno +OV20Sial7ARX6wC2n7vNs9+VjRR5+wmV1Ytkmxi+NKEbR6w7MaaW+Aj/ECxvscrw +xxROPE+N/D8OlVDjBSnVVq/WqmZ6QTkcWqBYl/MiqdY+hv251wfrm+kgdafOqfJn +Z0P8RTDfXbAs8FGS1FE/EWAc6qIdIII8KqyWtGCi2sm7AmDB0f6ifElHWAKlJbZF +nnSHmvFbE9je9WZGZHngSqDz0TGhgmsNB+7E0IpO/dr1MptvL5HCGRsp6mB8B4Ie +kK1uDk8Ni4kCHAQQAQIABgUCTVHgwgAKCRBesT6dQI88P/2QD/49QnP90wa92MiM +wPdRHK6cIuT0/azpdwDDe9DQZIcKmI2U8bmY74z3z6UGXlhVeyyWJjr2wKeMZs8J +XiGx+nGVY4Ghgx3zc/eX1zzapDF5lkPjlXjBQCATFq38z2+rQgMp1hyyHP+xM+j/ +p1+xGn0Oa+xPgFqGdGo0b/qS+kdsWKazU+MILsXzVTiY6y5XqHxJBIw34X6xzjlM +8te9k21DPqp9fV7cWZzDzmC2EoODrDmq1nkk/5Hsy+gUay4V/Ew1E2Xkc2kKPXqY +FL8XblZEnf1zSDSJ5sQnhMZe/pJXAgfMPsKl5cwTxlE1VI8kl72M6LKsLDbWbZRQ +a19eXSIpxI9EksAVXHA2UdMUuWo00MouxIOVLMaW9232JOwdzFE5NNsmnGTiJ6sW +juuXPdkFKrS1x3aef27KtTW2Y+Nesn+xQR3e6UFgK9T8+E4B8Xuj5+Tt8PQ1jWjP +5B6iqOdMXx7JujZRErMuOD7k5QuJWqBjdxK3GXTE88gyFUbh/+kPy1nBpv7M8A+A +1XHbQCXk3GZ5+ep7UVUhu2PJvSr+ZFs+OkpMy10HwUzOpHiRPSFVcf/tqeCnJtal +0PRd2HNjgZ2Mu4CmBCYdbTND3xuY566z+m+/FtIxyAo+G5lVAQ7HihX+IzBlXS0o +TF/EFTUdSaCmrVsXseyRZSktcGBHEIkCHAQQAQIABgUCTVHg8AAKCRARL/dAg4l+ +Eo3aEACv4Yv6GSnYP+Sg/pocai6mId1drOqn6zE5RBK1j7L/s3nlp/brEF9H3Glg +WnhFbpHsXNHuGcNfSGNoitVenx81a/OkMG1A3TvHxtQGg2UjIU0evJ1F/Nb6j3ol +CAiXiyZu2Y6yl2aJfk51zfBYjuIjZ4vyr1XgxCIwNUKdQ5ZacJD9JLLMPQYLe2qW +kjRr3uRR6SoeTZGkSZQYq2cITcXOQsaAA4uW6g55nMpVj6EA4rXo2IU6CvAjyk/5 +Oa2W/EBmWmu17qeHq8vSG/D2qttzy8wLx6YeNfEDkZGo5/mI7pT4Wl1krDZHwUNP +RrL+XEkpKnr16stnPDiWLUqCvebHBd5aWjEmeR9SCuuIxzWbCCDPBqHxS2zqpIX+ +6k6cEuoex1NHAr9C5/+lVh3evjlL4C+yfmSwNFgIMBLNPmthLLj6CZND8tCmeUTN +wALGY6X8KHJ06o1XZa8aK+973FNt6Vb0zwrV+0cLsO3OArhEUWdYQqZ7nE9QuF6L +m455MkpVfblJ5zEVhvCHjWP1B9urRXYHIK1wHrn2qB5F3twK30JlQQRVzJ9h6Bz7 +RsLxOQ2ReMqVOqCMKuYqAGO1XelrW7t+8nq2gYphsNtDkk6/2bGfGNAOtjgwU74y +A8SASxsS7IXTj2KjA4r4P8WfL0pMpngZ84ygGqh3+FIs43R4r4kCHAQQAQIABgUC +TVJv4wAKCRAq6QHlxwIY0swyEAC2Dv3KQdGaNjQvM3nWixGe0Ah+hFkC+h6OrTnk +zt14fZcD+S5EBLJZYQlvnpvyqCvPsLYu5z+rQkjJFNdSCdTjJm9pgZzZHjMbK5ZZ +at3O5KWIgFkv4H0rIhbdC09voSVgrEVPVFIRYGro1e+zXNV+Z4Ickt1DYKMPvAMt +8YaI+rvaJfzCTRGITqeTtQojK/MUp0tLdqGnBIoh+z2R4qTctaEyw5C/RtL4SQ9C +eTDwP6mfkepyj60yldMVQUdDsEXGObpI5pwJ9XsiIymwUjK4qfuvrLinAK8SlAXG +o2nv36S6NQAIjAaSMp3NNhcgubcq0MgLJFcrxLj/1fw70crBYgu1GntB0RUcxRRO +K2OMvWlgG7fqJ4fI/btnGwCkToR/O+ZNIVzHAACk1vjltd3BLJlC3Kn2Zf/m4rgb +g0WIrTZmV7gwlRx9M3OcKyUfSpYcDTlHuvUez+R3E+V2VO1at0opJUuww1stmZT9 +X5xxz+NdaT4tE0BgzeI3zbeic60wI0WfUQtA2B3yYX7ZeSef6Bo/LFX9q+jhMgTD +Wus+q60241RnFXuJcBQE88duJ8i3CMThAPzVnlqcm2x0K/1GZIiV3xZei9Ow/j3P +Cqu+PIuJWUtYD5NZpD55LrmeqBmUbO/YKz0XACeOtu7ELMIK6qW0zbg1rhsv4ocV +CYqf8IkCHAQQAQIABgUCTVKTJwAKCRBkyMnRHl2tmBsqD/9FNgtxKIk6bCw9rZsX +m8+Syiast5xp8878NNoZWHZ8hFJjarAqxxV4YdEi1+jMZD1C9mrJMOtV2dv3dRib +e8KsUpmoet89K4ESvCbFoAmWtq5WhC2cYx446Y0vOXTPRH1JerSUw98QBNnQuJF7 +94oyRx0TKCEHlGeajlJfSbQ2F2v3knT2uMKZOy8HnQVpKSnFgb92+MGvJJzgsC0Y +u/GCBwwBV/YWvtaOL+XpiJ6JQ9XKRBdYaOZ/sFcqC0H05SI8RLerTQEREF/7RpSS +0I4F6sCv+aDzZhnt4ykYQWQCDqVNsZudoalpbMJtBTKGp+c7Ma6LWEFDb9HunweL +/O9i2IKMYwqUD/CjDrlwyJVZh+M4yjSWV0+80vN+9K4TbA9m1DQpJBAk0BL928VX +pRlAi3DKT5VjYAw993EXFKZPh2YZLuBIBd2/hQ0Wd0LVovCcLiMhqYfVWkhCSSc1 +VdIWaf1wB5XgOsZNfxhCt+KjZHoZsmT4lAPnyTNGBCUspgywcJyR0CwBRViI9WXA +57aMkSJ3g34nOGrGnkm6mUvLVXOFYPWYj7Fz9Gz+EPv7T/nDtEtNFC1V7lxfxK1T +y3czH2RzwBJEqjlg8YzNVO5T2X45di2wVk4UKffdvDTcimzUKsxSxRhMJNr8rTME +BNjQ+Ar2C13PkTn9vCGVbIJJD4hGBBARAgAGBQJNUu6lAAoJEHMcr9NTwaMvessA +oOD1bq0krrRVThv6eSMedB6qrWuiAKDOPCcxx4+gapBDTTjsUn1yjcztIohGBBIR +AgAGBQJNUvsOAAoJEOhWYjiwDLUzXysAoI/uVo7N/iKGrkw5ALSdozXlhNXSAKDJ +GMj52BY26/oK46dgonWnx63FZokCHAQQAQIABgUCTVMP4QAKCRCpyGyN066NOlZV +D/9K9casbrPRTky7SlBLL5+w2NkfqbujneW8aZPydRh3uoYtilQVjN/zptBUFQy5 +B0Iyatl5w2FjYgN5O1NCdKfOtDZRM8JItjiK5ciuXt+/wVWNe+1aRLdO5m1RvcMY +taQQ3QKLhCbFbkV77HaVY1ClJiXPh4TcSgCl/dFEUMH0Bch558UaKq/n+DLBPnNW +oXlTeT9VvlzFmVo5aki9koUPGq/QQ1u1G0maDXLdRDGfoIsWg6aRJURra30RzX6a +HGm9zcIV5CDp7OPWVkfqaOe/5QY7644zlEfTujl2U63QN/p1tBvL94VICtsQbw+n +vSuVeoWoJesZseIdzzJ3HONBsrwar3gyY/pOIK/TvoBOJHrtH/5grVGbfPtXOM+D +orjQg1FtqrX9Hrb+d/PNV1Z7lYipEutC/KluifkEIfCY2yipAvLS9rZ77/im5++9 +O+Tx+KOJ5tzS0dVsGSZXHdXZsj0c3nCLQD6tf9h38/VU0kIP9uLZl+zt2d3qjgTo +/cyxREjxjM5t+egVDnRKYpptLJfacWPSH6N+zEefK89/OfUZucm1RSR03J0x6+1F +2/ocdR+mkzp/o0kRW+1Ta8gm/kQWkCWSE5lpPmlOSS1pb8IligXrHtnXkZzk0Ueo +dwN+VPWmPS78c8OApr3gNOoobv3zfAls42osrd3+3AsVrIhGBBARAgAGBQJNUx/o +AAoJEI7gmy3mHN+fnLgAn3cWNv729nu+wpqZ1JMFZPI7zhbNAJ0ac/wB13OLHc4j +r3VXUIThwhMUcIkCHAQTAQIABgUCTVPjhAAKCRAH3n7qVXvODHqwD/0VgIVLE7vS +7WQ0v7T97ErMUnkG4EVBpO01yhVlM2y6qUhf4owH0pIDrWuZxIwGLKH6BM49vnUN +ab90+SpnlqToIaCzXYCTBtFR4RvWk2RAJhQ+kbYMv3bboqISnwN4zuJ8s7XuYFO+ +PoFIYWjpoIMAnmikODcLx5GEEox/Yiti7Tp4UPYSND7XzFXjkbKunFzS94F60xvT +i9zmt6fBDy/zZ8GC9YDhasuQh8iwk6Lf+SIbCEV/L0FXUPswsPGvaW10PLRvzaqj +r2QIPgtJSZUHyiai0W72QfghqBUIIz+WglHjPjZ7q/tVxlJY6Nor4YHUl34zDdb6 +mKq/v57BVroc+noHDN8be8BUXhhZTshu8wd8dqhXb3+s7DfFg1f5jAlMz9L8u/DK +aQOj3sSRa36WQdS/PPv66uvo9v0tumV9fRyiOJdk69Ua3cNnWqSle1CkYndljIeS +lfb/10nFTGs2lK9rYWArpZzLj70zHpwHfdve98ivUGnTBhqt+tFjBYQz0jk9HVoH +ZoNZC7PdybLBlXKxWR98qqVxURVovAcDaQEisEnNpbmWYHVJcU8+WGdyFZk9gtoa +MLNxgVt3eBwUD8UoZQnqOWPq6XUnxaaUD2qhGGHp4CKd38XEySD6XAT5YA7/jWEa +PzOGRF8NCJInqie73ni1crx4Zx0L0eMOO4kCHAQTAQgABgUCTVQKYAAKCRBUonut +qYMuuwmSEACIGWMfdM2bo0k8Urqh1c+2YZVsBh7z/EvUjXs5alBSJbarcjWsImFQ +5hMr6HA+IDiOvSM0elFW/bXvOczAAxiZ7Codsb0URWay5bEQwZNQTWcrmsvtKMr4 +o8kNIt3CQkhqGK3ng80jymTG6fU++aUEksz+K0I1BMyfs4EoQBwaHzuRdysuxj6O +F6ycNiSd8r7KmL2+8vF1Td8YUvfovvCx79P/9W0zFUbDHOjaIPBNTu+qzELXDX/B +Iqrb46HjirgmxZ9mWzFtfOetXod4LHpavrx99qsKe4y2fIGo/dl3DX3zxhrbr0Gc +qUOVchQ4ndB0LDkKXs80Sq8rFU7Ik5DKzEhvuTXD4x5+DcrDN2rrEDOjLiieEOvK +DEmFGUJPZ2ajS/FD7B+lx4Ab/smTUsY2hKTWu3+JtwU2fZurLBWtSr2qX0RHfvdE +wS2YTVqrPnIq457sDVN5aKZ9uS6X4VDFvgnTL2mTB+ANNLjydHM/sU/Pjozc76dd +Oi7VexVz7Ii/emY51twI2UjUP3E+7CLFWljqTfh+MXfVqKx868QA/4UoGJL9PhZh +zPucV2gj0dg9RdVMvmvvriR7ysH58pSGN+4oMe5QzjPRfiw66fSvHtByX2a+uRB/ +jAts9AQKfFfyKhdBGETRtrS4ndP6J/D2FURO6BNvO++PRVyQW55iIIkCHAQSAQIA +BgUCTVQfAwAKCRDBANe1fyoeJnhJEACD1QPzQ/MihbGztc3CFIuXU8CpNCuD43Gl +PF6Ivrc4i9pS5SpAD2wviFaS/1lqP07gExvDvgVoWuNeqNlY6VL5rO/Rta8vESNK +18kD6ktKhMGUhqWSbFPfiI+apnVjSDDOYND/jfh9CHmTmHPnRxACaqKLy8+6xGZn +EOwxcFTmmuFpjGH4XmObw3EB8ue/s1sdj7K19Svk+6Gp6JEA9LnO0AkWYmt443lY +GG1c2Bjz3kDlOJ5hePLjlahPrywepj4RH7VYX+sWkgvzGaLijh11rStOWgkRLDcL +7nxxLLRsF1HO34i3Y5J74llc4rYCJTPY6qCHtBopdj7ExJ5b0MhH4mS1S86SpqJA +F6vGkjWkvHLR7IG/mIyuhPkJP2i/wIsG9ED1SO+8t62EzuVvcetsCILebEe3i1n3 +54BbDSSmW9+RRX6eUnIKOasrxV5uLPEKOa0yyzkwM11/BMnBdNjbFYN03r6qGbdE +GTNYkrwCy6clGhxHiUhzq48+wf8PQ4iLw/YD4lqeBTwKup7Jp9M34UskbffRde4R +hY/oE18+yEi+vBR4fNur20m6qlKPdgqGQrVUFzBUp7W/aZ1cKRqEcO1c/zMQOtzi +avITYrFdG8xl6IHVl1H1v0tysqDV/WTcDk+c8p1Ol1lhZx/1C3bQ6I44/UoeZf6k +hGk3wOBtR4hGBBARAgAGBQJNVHwpAAoJEC8a0HMpPAX9VAEAoJgUn84COn7IOUC6 +GROIpmHS43RkAKCNxGtjgPx8lmOaHLqZa26ZNkdegYheBBARCAAGBQJNVPtSAAoJ +EO6NNj0Wh5c4yn0A/iAELBz/7of/0qQp6P3YFH91ubg+7wh7LWp6u7m8SYmCAP47 +0vlNWaxrfxFT2zKaEpW8MK/IPkdZ1rBfrOraipC4Z4hGBBARAgAGBQJNVS6sAAoJ +EL7hbiwqfYIgmb8An23Q0Ne4LfjzUBIMYW1Xg3jRLKckAKCyZna66/8fPlohQ/uw +WI18csJ23YhlBBMRCAAlBQJNVsS4HhpodHRwOi8vd3d3LmdvdGhnb29zZS5uZXQv +cGdwLwAKCRC0deIHurWCKZe4AJ45G450UupRVWtPVl4Bs19Pit54hACeLMT/6pTj +qB1I804dDGTfcm/0wJqIZQQTEQgAJQUCTVbEux4aaHR0cDovL3d3dy5nb3RoZ29v +c2UubmV0L3BncC8ACgkQlI/WoOEPUC4p7QCeLYrPHgbV8NOat6kUltBhkB3ha08A +n3DR1r34lwi1vEAJUEiAAhhEkVHOiQI7BBMBCAAlBQJNVsS/HhpodHRwOi8vd3d3 +LmdvdGhnb29zZS5uZXQvcGdwLwAKCRB6BoVCHomQQjgED/sEugXl5SPWZ/GEBYB6 +BLJ5laoNs4ud9Pc/Z/MndeFKT5GjClK6LDd0HQQLL4SmSKGRu5gPLFWcVFke3Ueo ++mXpMkWcqCpO/vXXPNp2d/YX6GGj06VbJj+qzJM5+shogEx5Jz+7tlWdSD9YFBlG +iZLn5Gmi1+VOmyYy7BHEELUG0aaEYNdiIZiSu1QZX95FM1SfYfarj64F0sbeGkwH +wG9Xa9R1YjCfbwk9WTj/SN16mg3ZbEuGBlXycRQTZvEq8Q285RxJ5MM/fo6sk9B2 +y5cNyNpxzPPEV1zPuErWyGmK/YwcctWMb/Z18dNbI5XB/CAwrhfhRSExbRUuhMNN +56q/4Loi8mLZfLG3pI+HHMCQvh1sEG3ZBNVasf6x9fg2+gh+tCG06V9VSfTXA5t/ +l4d7GWsdO/RWEPL/F4e//Ni1y+N3qpmCUXJhIxBk/jOspsrIJCo3UjFc8CuPxanU +N0QE2LZdvHDWIQAVSbSFiDbIGA1rjdsFYl3j2sDAQy9etI+7w6+9FVmSbXQNNniz +Mf49kAWrLKkdZZM548izj42UvQhAT31K7+EbCCIN9dondPSNUInuGQpSFwa3L16H +NV3EkQkz5FPfoEfA0ei7YqZyt6qvN3+l+4YKKd1RNKrroAp+WgdwqxAQW3AljIqn +z3W0wmRDi9DyAKbR1RDI1fSMF4hGBBARAgAGBQJNV8OqAAoJEAKQnhqS/RNyTjEA +nRicJHgYxu/OaEkRpiEaBcWken8hAKDdGuqg4R8nYmpkUpAPv8tmOKfffokCHAQQ +AQoABgUCTVfDeAAKCRAm48h1p0Qg7wYMD/0VQEAIB2j/BokS8rrbG97tmxRCJ6rz +qebHpwkvqnXsid8ePXtrYuFe3xnLkg7+ZE0C9UzhO3AdNYup5s/4vcafVFNuf8br +p9iMYO0K5JDL3E1pADyN6EasITDgle4b87Skfx9aduRd4DNJlE1fdrMlSKeYxNU/ +S2PfVB+qO/dDzxqY45c4zae3lcLyIga6lBBK2bMIVXIDVapqKyHHTEGYyq9aMxNb +jIpJeCCgB9r6yigpYvRxX3BS1qryeuR9t10nIb9NYotaSE9eoYRUhfxlb1taDOFV +4edXrJXV9xta2IibyQcAQqUj9npZocHR4QXiAcJQgbmTX30nvulEuYutNSTgkbh9 +dEIUoCa6ZvPMmHkvCjz2/tawcYVfxZwVIg/YgQecn2pL/LJCxRbZKYNx8ovQFQCm +SH1E/+oWRXytdobuX5GvEfvnnmvguZeFDzE4QRUG/CtINEYabgaP1UyznffutbVU +0qK9UbkySmmykRi/YyaBIb+Rb+rEdyQzfepWIgT7GYBQcN2q+rYazzOwny/nBCY/ +Ffe74FFZYbw+WFtlU17uEZlKp/z3FtQxpq5yj4kVib0P7BqikzllG3LejFk+UWH/ +qw/3QI7afecugXOKpbaYtP9w2rsGs75wKF558eZclg1/I+prDU9tFpwQEiPrbtPw +PzHhOMNENx/2iIkCHAQQAQoABgUCTVfsCgAKCRBAv+6GiwVdmrb7D/43OciE3Twc +HJqUCC51JckrxPc/eQyD/UnW0SOEKSWM+3EI3VPv0HfRMrdKl9aRIgzJkG/Lqnds +s4DFAGbgqGFtJgPsM4JnQSJcpLrnIHuS0vSJYZQ/dz6bh6lKltY3GEjnAwjLLrK9 +9TQWG/2iRO+hCDHZynMgHPejSPOr3oLTR45njf/MiARN9A2YV7tAgHBOXEBJxWgI +V9XQfCIUSAQjahkbzmn3gWlna5vrhVi68IXSi3WDNESz+iPXYW7IDBvs53yO9OAn +WcTq6SCzAmCz8eOjeMzw/Lh+YCGf6BKxPszwKAixCbP4bFMx2iIy3RWEWUGv+h88 +ckPFNleWfbJfbl5dHlWHqwvFHKhKIp+IGLXKxcQ4XY8GiC9yIX4dlZxV40wJgwl3 +mIT57NL+HuPvbpJvYFaJ18e1L0K+NaDXIxxNQqmaLuPxDqGDnWIC41UghXYwwKFn +Bkktuv35zXX1MJHIayVkA29wOvhII0jfcnTcXUz9o1r0Wxd5l+NX7gP62AtDkDX5 +k80AZekVH5GsBj3DhT46/lN7JFDlAboM3nVqAp4YesVOruzFLeAMTEiclEMlXVXJ +c/CTFx1mC1lscYg06UlJUgwsUrRvYHQX45MlU9a7eB20a5OQEow9sgyXhYANGJVN +RHpgkiSnls466EAERSrDjccVVZbPA8Q7g4hGBBMRCgAGBQJNWC3RAAoJENxc38QH +jfpB3HUAoL1fISGeRB3Lxm+BtN9PsdZpJvhyAKC25dOAMZxtpeGkLlZiTamYC62r +lohGBBIRAgAGBQJNWFfxAAoJEDh6dpV+unX/QAgAoJIFU1CjOVR1MhlNzb/deGVs +SIqMAJ9zT4K4K4LejzoMP1nxFiu8HTzSnIhGBBMRAgAGBQJNWUurAAoJEO6Bkqbk +Q9bY+/4AoKaL5yrRNWRvGoI7Q+gEQOGgV8lkAJ0Swr96bY1DVGOPFgWEGJfxNh+D +dYkCHAQQAQgABgUCTVmX+wAKCRARb146s2ik66clEACMpv4ciK6+y1+TpwQxz1vp +suzlwy+LyyZ7OXICpgsZb8kayfwJM78eeV+VNsF1DyyIbtp/emqrg+U1mdaWH0+C +U/Vr96gIYMDrMlDjlT7eTYgjlb4+vHgWErvdyBp0sSMZm+IqZqPYJG80FG5SqSUT +m+zNPS/rLCSiUP9eRxt+hn8SanXe9vHZn87+EM2cFoWsN9kITFqEWteYRn1Uh3ru +HncGRifGF75Z3GkpAM04lRL1PUt8f5XXvSX9xJINwmmjH0+wfUxibbKy+vtqHkK+ +27QRQcb4NT9W2mKQAAaUIX1RbajS9rTGSoT8+9KfI9gRpuRM+eCItO6TRONpDUYB +dWr6V+0q/ELEfjwEbDtsT+5JgW9T8aie7X7jTuaogoJxi538zjGTlBtJlXREF0E/ +BjpRI+I8ihVG8HhQo3HeDwB9HqfcWXgUpwvzwEPfCK8ejYcP3NZjyKec7zf7Hvqo +prrl50p6qe93gxdWV9KaW17W4xCTEIMTHzSCrjpCwCeXzRse7uFisTW4HM/9w5oG +O1rB6ivS88D3FfLjj3HANlcsFQgDLCa+bzUOh33/hGKgp+fWO/R9b64A9mPVZ4sJ +/mAixmEukQjkAfIUs9chtLPagijIr1Z6LMaVE27LVhJJK8Y/rDpxCwvYHKNKE4Cs +Ymd+QoiuW4oHziISf0gP2IhGBBARAgAGBQJNWvGjAAoJEIjmuh7+9N0DBfEAnjgu +3f20h6CjxxZEKIDphBygmd8VAKCo55YConyykYeNuxz/f5h0j79YOohGBBARAgAG +BQJNUxPAAAoJEG0LxzpAWBg3dEQAnifAnVUBzTbUbfDlfVbWX6s0dypFAJ9q+LD+ +2pAyG+yYj+WbYQ8tRtehpIhGBBARAgAGBQJNWD6MAAoJEN2qNmcMtzVqL64An3Jn +zuxmO/dmAmg6IZERpx837du1AJ4vensZ/0Jl4ZpP+Ml2cfTRhMXwoohGBBARAgAG +BQJNWD66AAoJEC/oC7N4h/eHQeQAoIr7wk5skdanCaDuLU2jMuFUAvabAJ4xmJHQ +30nt2Fsw/z2wGjxG9+2W4YkCHAQQAQIABgUCTVMk1AAKCRDzudiMuH95qeGlD/4i +urnrFWLyMyzn+jhX5JCkDqD+MYKBNMkHUr2ftV629L08nT7mcDmP0DkxBZ3beeCM +oyEzNJVvChW1jaA5OM65c/630Kdq730IdG/UN0Y+bW+mRjII+IRkKDWi6I7DM/fw ++GNHm/MLDcYXGUZ1I9MKN+VvztMH5yzoLXI87sU3Iiz7aaYoVzPq43E/F2odhBy2 +YZSmb9rWHKiM1KBQnW+Jij5slQwBWSmM4KJLqQFGfrwLJOZoGCRt+qlKvHM99Z3K +9RukB/KvsjsIXGvIevap5xOVP/TOxwFm3nj5edQ0nXt1tpRaJ0uXmFkMFwFUjWqA +00zCQV+Q46G2wz1Jz3LYTSTwY/If9imXEIRzEMrchdbItB2b2skp0FCHrplMRDUx +eGABg551Vdwv0SG2QXtK+F3IDV8WyXH9JLSQ/x/YIoKN+iX3MZkAjcD0ANUuo1RN +zDPobdGAY0tAjierhBeHTvdvXZaK5HzzJFhanDYvECrOlxvNIsMk+T0JUP3EQdwd +ZeuGluC5COfwvx2bGnuS9HmPZsc+gnx6MBbfNdS90jDM3QaFcAXNxeBqyvTCHWxe +dz05pVpfRjWHaYbS4FlRVCu6/Eu6Z3VpvhLFS5aQ3rMAFxGhpTAXE0ZzLc55Rk3t +Rc1lOZgp/7174NYcdx4WM0+jdsF+SIsy0/XJnhxWhIhGBBMRAgAGBQJNXaoAAAoJ +EJA1w39wJAf3LR4AoN3jZqUKorgwIj+9dviDVrmZ10TsAJ4lSjnzCSIuraQuXOMm +7XyukdFNe4hGBBIRAgAGBQJNXbBZAAoJEDx5k7Q3RWus9iYAnAibhSjmM+mrGfhm +BWiVFKq6nSglAJ44Ws20E1qbv47K6dfJJ86CAeVl1YhGBBARAgAGBQJNXrxaAAoJ +EHv7EQjZJ2WvVCAAoL6F2l9y6Pt+WzsnjfExtVxGYk7rAKC4WV0YEK1OHN3qMHcs +s7IEda8neIkCHAQQAQIABgUCTV7/2QAKCRDTcw+zJHgyIHOTEACHGLnraBJsJjSi +wFOpyufc/l0yMvkFET8IiPo2U5RQcm277eYkyerQ0fD1ZzLT1RlwyD/g8Da7zN6P ++0ooUR9o8YWgd2R3VNhQl3liR3uD5a6Tby9E2sGz0/Dtha17fRAkBk7Jbyjkptmd +yP7EPT7kpQfJKoAodGm0Y5hlI0WZJK4sgf+YBP7AqcvFkr3iRZ9p5kcAbH8VVZq6 +BKx3Tovtgd0hafZyh1ZXal7K9iinvz3I9zrHtJJbO+7mduXcXUDrme7SVi1A7wU/ +jZt2XD3qm0KibPf5PBRmqlDy2G5ioahujP4EgfMwqt4aNCT1y8vPyOmqXXkosaW/ +d/EPDsuwm/V/I4qeq2RsycOWwMQnP1WGd2AD++rn+gS7U8jZkzNgZRRUWJccbLT7 +IZ43rb/JBlFvynOtVzr8Sf0Z3bgt2mBbk8qdhH4s7jvouDAixHb5EQOmVkZ/0I0Q +xTMefIZhY6hrZ4ocrZ3SU/sPm4mOaLIls4muTaBrbgam4z2v+KaU1VzmuLZiIS2v +NpKRmMA2jexDEq7OztrsPgYFKzbYp5smKcKTQyc/R8/usD6CwPr96xvNkiXp2zSf +MCDZvQail51NfgB5jjZTVSJ+QZGtBGNQYE3CCzbnNsVTud6TLNxrCwYjE3YEAINM +SjuIb77EiTOF6BJiKWbT7CYtMyOlJYkCHAQQAQIABgUCTV/EywAKCRADA99SJcjj +htUOD/4xW8s6G729X7Jbj2M/fS60IszIhrkzPQ9awgF1+An+m533TbxljG8/HE8c +pdFUKgpSoN2C4B36QXeVi2xKkQIKHbBKl61BTnui9apITcZv3eiRKvYVUZYhcz7h +uHDie6vSXaINBDbONbAhxSIOtc7/mPONOMi/RMUJB5ptpo+J/dXwxpW/yclgVy30 +rY2qGcHnpjATfQYkEbV3+SXCGZ0c4UNAcd7OIsL5xOUoejUWENqgxcCZt8ENEwFI +WPHix1SwEuD7gfkTCHpZmSCCrW3/qxpnR+UZKOI8+NS6iK7833D/kIoQiTpOJ98V +z2CNqp+FgOG5NC03sp7gr/bOrdSh1vn3CHb8yJuforj1VRqbsgJNKhf67yFEDoOP +qqUIUB/ir4SMqG2yupkQX76GyZy9/QPMoMEYtaEUVdnDkawndUUPm1FVZyqu9fim +54bQ6i+hQLTNQPWH33+vvAL00qeX63763CHE++0eZsT6XX0DepLgz5pm/bi4lgdw +HZxG2CifA+EvLK3NehlP2pNrQgRKTe+CDeVq58dygTijGtXlOVhFmD9yIIt0LZ8s +S/dhP/S6rwwK7Zom8B7k72qYmrFrM6y0dPKHV38if/qQUrgLViIHZe1r3m1z6wfB +6cxhQSgV7lZ0peeyJ3qMGVrd/IbdX0t8S3F9DDspiCLV1pErRLkBDQRIHeYtAQgA +v/Z3yLlLUJ6Rt5Xarpkel7GlgWAjvwY0kI799Tb/qv+bvNkT/bzw/0nUNvQ5fFj4 +htym4sB7PL6NYHhoFmjLasLlz/B8TAr12otSQkkTw5tsAyCRFk775XL0ygLDcVzH +zJvRIE8Of16uSRI0O5Eo3ciYBvBVIMfjk4cHlSREK3xjdsy6i/afg+5IXqjGNxIp +3WhOJD4DWBSUAw2ktb3MrnXjXBygidUufrljyUteUKoLjnJfuDzduns1u97j7oOm +18QuiSgnwk1gZSQWuSoyUBc9yQaH277snlPZ/NK3aDopPH5J795v1ueScgQtzpLr +/Le7cqM+4kv30hq6x7TzSwARAQABiQLIBBgBAgAPBQJIHeYtAhsCBQkSzAMAASkJ +ECnuWLmWhlFxwF0gBBkBAgAGBQJIHeYuAAoJEJ1eqvaQE7hCMUgIAIZmiPvPbHm2 +QveJhdRrTrhBbPLaQmwcP0SYTugAAD45c0r2NZtU1h5agkqwj7YSWfh2+E83H/jz +WxndGJ1NpLJRTC+DGO7V9X4xovsVPGdsRxcO40fhOPu0DNXzj1SHBln11sEJL06u ++IR91oUgW4WChEJk282vKEVHMIw+ovah+OAmA18u1QmD1ssvtdpZ8Lq9DRLUmyeU +Vumbob76wbLs9HALh4l3Te8HaSfZWGu7YGVFuhliTDXCaU0UH32FLJSSn38qNmBL +A/VWPUpWM3EmdPmhQsUZv3onvlDcRrkpDifdFJpINUJVbl2nbVbZW05XZu5PNCA7 +4mQEMzpOE4PCxAwggdsEEKz+AIs+uGuH0JK6Di1m7LspnbFOM/rUHnWK8xdVnz6a +OlkcONVBaW17TJf924Uf5kyWd5Ni3JkDzu+4q6+TZwFhLYdIszc58jETXznNrHQ+ +aGIRHaAOsSRc+tD4L2+bnHjCH2UNdaGNlGkFeTfLNE64MsNSA3ZTVkO2cevn88rZ +z1dJEFec977htv4jdwzxQfzz55Yf3+1ATOsQBoO817elClhmpxTu0oZ9uk1lB+3X +3RKbIrTEilY9jkL7JlRbfetQzetxjd3dq04nH/xP8Cb33O/PXq62S5S3t4/JdqUT +J1xQOiLYwvpmsREvvTpCaOPf+tGzv6fOEPChcc0E/+wz/mfmeC/ElhTIBXFamb+A +y/Z6nC3E6r90PxUVmDvaj46dj9JHtab7EmOh9PlFW748dMfWy3+EkkY0fP4YzJcT +/6un9Ki6FqMqQ2bF8+0keb6YKhbeuouotk2kTjBJXe3bqegmxMdlZPg3uUEVFgP5 +NSo1DivzLAQoBBxcnkGm1rkBDQRIHeZpAQgAxwz8BhWUkWGZ3A6TEH3aa/RGJ1Ki +3zfDYsYrrfU3WgCJ/Rg2rZcpI9PMeua/+S6J0cSXG73x8L7wZ0X2uKv+ZCgM07WO +AFBlSGjT9A5K6vTwVMA/RdzfaLj0rQn4OEaE81K7iC0NK0NofPbBnaTuBqeMiajY +49fknyuov5i4BhvIm6QPwdWw3TB7AyVcWxOo09kbmk+RbsazLrOJauDWErj4SBFE +NbkLChf5V9xPQ7cjovSy5Arotvhd+V81/+vyRuDFONGe45j3t2qkdxk9lcZOR51T +dsiP4Z9hT6qBrZ0dhUepNZa3TCnBRtkrXGiVu7pGNmLdP0h6WneYST+5yQARAQAB +iQGpBBgBAgAPBQJIHeZpAhsMBQkSzAMAAAoJECnuWLmWhlFxeCQMIK3qZHjr/R2C +vr69G5aE4Cf5FlHl2b4WxV9HjMQhWpLWmCIJVhOVj6nMn9VNyF2tGMSqBWurepmH +kc1CO5E080C24htio5y1wag8zB2T/7PU9lFLqt0UgZ39mnnW3wLvRw6bbPVR8r9a +CZ6ZDmNjozP9TmDpRN7OOaRPcAWVsUVZ1QW3BN4W+Nsq+ZASixM5Wg6oXMY9sKWb +vgC5qGDrN4JrV6LrdBlTGZcU1hUJXYfRZll4bHf/REPadW3M7dYWqWpYUEioMM0a +ZGbbDP/FhPZwt2heIk5lPw8yLf6whSe/rGgHNyhUDET1hIKSf11sfTmZg3rPFNy7 +3yf0Vs29CTcO2rd2sUM6GhDkuR3MqJ+tFbhtkgfALiKvC9whjh8J67ip2SzwQq6q +PCWr0bASNK+USAfSoOzNkFXNmbNUf1Dca2f9O748wxFeU5r0jlg1SroPsi3JZHg4 ++kNcC9/b5b7YBrvijmLMhxyBSyxYNr+YEZRBvkyb8Jsvpi6GI/Nng6tHX6A= +=rOj+ +-----END PGP PUBLIC KEY BLOCK----- +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.12 (GNU/Linux) + +mKsEPNUHKwEFALqJSBHn6Qk5ex138kwymxA3idCFoTi5Q6mVooEVVaYVfeDG+5uV +T5rhTFDfDcT9SO0eIlfKOraSRnVEHyDDH2PAgJFxyneFELcmLUQ66D+m8z+ziGro +6bcDSBBDMRkHIX6/kH/vnevjqivIld+j8WTcVX+SArcKyzgQ58uMTrfQdLqzh6D9 +sE/838+ZPZkabmKKWMVWccoaUbWGYOcNwO0ABim0JVNpbW9uIEpvc2Vmc3NvbiA8 +c2ltb25Aam9zZWZzc29uLm9yZz6I+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgEC +F4AiGGRuczpzaW1vbi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCTvm3NgUJFLfe +CQAKCRDtoh6UtWVxb7BxBQC3UF6FW9nyukBsGUvz7clNOdAhPyfkvab049xuubjC ++kHGJuS25IzpvvLPIIUik6zZ0cQIWRtzPM2/6rWuktABHFQ0sf0A/o6f7ApEMnna +MXxNhR2ymWjzc2jSF1zjg/KjwPpzk68Irk6fHbT/vuZASrcXT7ORy+vjhoSoU1uO +zemp4tO8tK1ehsGKXQN7pPKhWpsMO5zVzZHxAlNUzUsXiEYEExECAAYFAj1Y8sIA +CgkQV5Mp08AbKiJmNwCgkgjjuS5TcZq4rVBWNYu1VwQlJWYAoJZf+pBNBvzT9xOg +Hcs1cAMwT4FHiEwEExECAAwFAj1esHUFgwFXijYACgkQvLvElXGKklZXlwCfTWSl +L2/3q5Od3zBVMKVHgpTo4asAnAtw7vVEIwp9pPuy1oKjTB/obqltiEYEExECAAYF +AkEAyoIACgkQntdYP8FOsoK0XQCfRN1QBVk7/eu4YbFQBqH463dcHx4AoMp2QurM +RXFDImswJ1Wi9K65dq66iEYEExECAAYFAkD/P4YACgkQlv+ZxCXA7Au9KACfYKMn +MPmlbZDi5/Le4mcLCUlQ+SsAn2qOQ14l/ellraqWXbvacCJkOyNpiEwEEhECAAwF +AkDgVz0FgwCTtOwACgkQyIHdR0rnq0csrwCgtL27/ndpjew28bGVYU9tBmIg2GUA +oKFFKKHvJB2pVjRkRL4DjohSdIrkiEYEExECAAYFAkJJAYsACgkQj8NyXz1o1joW +fwCgtb8mtlI8rg52vT5DRU+Ct3NuDfEAoL7IX823ezbe7HVegheirf3q7zmKiKIE +EAECAAwFAkJG+cEFgwDmsQ4ACgkQv9buWFf3fwmuCwQAtAopBWKTnll1t4lFnR+C +mvXdqui6g/MhMVjGlnGaxzKfdlXIDT3i6VEMQk639rCLUxNB5YiQZZm7aABg1dwt +f10mFQUkm9dt4d852cu6ytmljXLJ4NIQFrhZQUrxvh8s8j41oN/hcwyLaX+FLI0G +6Jehz0m0nPlEQf0sJ/4oCuqITAQTEQIADAUCQklECgWDABPOSgAKCRBmvnH/Z0ho +g9kYAJ0QKz8Gt/kc7Q9Y/Ahh/wZO6vaQ9QCggcgpRYoJ6g1QXYWdTO/Hxve4Lu+I +TAQQEQIADAUCQk2CtQWDAOAoGgAKCRA7jqQfgvYSQDh8AJ43bDTlK1p/aLXxJ2/1 +pFrHWFvncACgvVli4V9P6pVhP9p+H3APtQ+URVSJASIEEwECAAwFAkJhOZ0FgwDM +cTIACgkQC3gy83PWLUFxowf/YLAopAmpU94kKSC4ECFsLXDivJ4LCOxgqZ0u7Fgi +QgwWK1miJJnW9gME5vE/jMHlsjGwUKJDC3SfbgjOJj31ivrGIh4od8+zU0bwlwoJ +ppDF/5cbzBheUiCsz+BVBZs8ii4OahnoELUzXbyVZITkMztmn/2+7DYXqqf1tCTy +wIR/hQzFp6W7GNT/I73Ksz/cKop4jzxE5whkl+5NMBk9VYhfa2X49/S65nwXg4ii +BPQN0UrhN0ZvrF+uKX6oVlOX+30CrPyT8FkcRk1AOhUpqblk2M2DblOebgxfF1ZV +jXNNN/0fZhy4iTbYSggndO5PIybKMkMogVtO07F/8lvtC4hMBBMRAgAMBQJC2LCN +BYMAVPpCAAoJEBhZ0B9ne6Hs7fEAn145gLDePrbxrfwN2dG5+IuvpvtYAJ4oRmRy +hxwpwahGE+5281z2VTrQ9YhMBBMRAgAMBQJC2LCxBYMAVPoeAAoJEIHC9+viE7aS +7sAAnRYuXokAy66xi04YD1ODtssYFw7nAJ4lqshFVn7NR5yznu0tioYLFwyc54hM +BBMRAgAMBQJC2LDRBYMAVPn+AAoJEGtw7Nldw/Rz2iEAoJFrzoYjkR5ANZYbeX/o +zQecQCmAAJwNCoPySmaxrwO6BiUd11bO80bPxYkCIgQTAQIADAUCQtiw8QWDAFT5 +3gAKCRCq4+bOZqFEaF90D/9xV8ua/ezhWOu5ADgHE1yeWMWQsecIx9TA5QVQg8pp +jA3E2REe/lJbCweVhwfvSmuvuymRQw71cIdmqF1dz9R8mb62N1r07DcPxibhtHi4 +poENxIHqvEbtOR17Y6Ql4DW4PjK1ut9y2y58HK6XTiqCtbg43jEcbXk1r9qLJl2L +gopYJQ1KJCwfn+DCVadRA2FgVclMGUGIdiiTwp12+E/70oYoMzLwm+7MUgbJUpRL +ytsc5frhT91iX2lPoeylAHAQ0681WiawvexlqtAPto9Gjbtnw32oSOqIJcbbMhN8 +G87pkvBhk5wXfVM7kyutBFhIHcQFGeuGkZpgeXt40NcUJffn+KOfeXzgdQwmwNlo +9K0arxNpIukgugvVeNtsKj1gtW7IkYcLmvlDyShz/cytguNEU+1W0ZeG73Tjphs8 +mCSlCKVcNWcy2l7z/DvB3VPibac525/Sw1ZIq7DShRHHv8x02/658LEW7gSvvZ4j +3yuZSNgL2lgPzaYoQo+8ysHK9dqViVBXAHIwVZTmXptb5zxQcHtFUnR51IDSAfBG +d7gjU5NJNfKKngLjDJy56nmJGMw/+13F5XFcjGPC9t6ZKoQud712K8TRIczWgGMn +gkahyTl4KIwPxVzWnUN0IkcsO/5yO3JudWzzYB6r1QomCSAAA+uirstJwVtBWsCA +54hGBBARAgAGBQJC8krrAAoJEG74r8KGV0rKoI4An0CQA/3wPCxskfqLhvN69ViN +c9GhAJwMR5Nl4q7Y4c5j9BOG+9Yxaom2OYhMBBMRAgAMBQJC8cBwBYMAO+pfAAoJ +ECmqKFIzPnwjCzsAmgIwd1uJC2Ka3bIgTCJukFjCcdWRAJ47P2tLKEcvatuPnnPT +yWYuXGTBqIhGBBARAgAGBQJD+NOYAAoJEOFd2FexXDfRRVoAnj+kNh2yJiIAI9JE +Vccgdv8cdElgAJ9jZHFa4KIdIsdGQZ5G4qS0YkHwKojYBBMBAgAiAhsDBAsHAwID +FQIDAxYCAQIeAQIXgAUCPr1HRAUJAtWOGQAKCRDtoh6UtWVxb3F2BP9Whe+ArZn6 +WlbpHF+37Rqr+KmXL2fLI0b+phneaieRvACsOmPD3jDpvxz/xVf8s49SJ2+a23Ia +iCA8Boyws9sBxn5N+yWhdYYjfDbH3JUOQz7BKN/9o8EAYuU8pmQtEN0q4+QiNsU0 +a8qLAV3qmEOwLfkB4z4H+aDZxe/p7vIYP4QmzTn3ZQ0mYR5mxpc52pF82KVyNWWJ +vmcirPwKSckEiNgEEwECACICGwMECwcDAgMVAgMDFgIBAh4BAheABQI/pCtUBQkD +vHImAAoJEO2iHpS1ZXFvPREE/j3fX+cLxCCZNTjMhThGFujiT7ty4x1jVc91J6QO +A+Jp+78NIIeyg3JTeR3WIv7/WFNzLKJXJEEcga+0ViPjoLfvGsHMAnwXqPYAxu1c +DY4jId0bCYgoVlnfF9gwOWxebtotLpCiuXGL/168zEAXWJpPg6r2MfPhAKUJ9G8q +52OOWJW3cObxoZ2gyXjuWOFtygZ1vUAqP/8UGeZNdajHD5uI2AQTAQIAIgIbAwQL +BwMCAxUCAwMWAgECHgECF4AFAkCGvikFCQSfBP4ACgkQ7aIelLVlcW9oqwT/a2nW +kFFy1q16WURE8vp+Tqu6i4r5mTdyHjbhQeZh5Pub5DEJiFuWXxE73JVrnNozacQb +Vbsnn54B4Xv6tuEDMxaTXSjreDY6D08urM8A0gnUHCAOwxtmepm9wxk/l3WAXWwz +QoQaqZ2PSPFGW4Epk8+JwWKoLv1O2i9NbycGEccF9rr6I12319Vzk+P4P3FOgCwa +dAQHSGS3Y6hlLm/RGIjYBBMBAgAiAhsDBAsHAwIDFQIDAxYCAQIeAQIXgAUCQW/E +VgUJBYgLKQAKCRDtoh6UtWVxb8gUBP9Oiapzi+7qCcpj8Yy55jQvgpXkhe9g5DuT +lRiHYjP5vTvXJNF7pDOOPj1pSUxumC3viv/pxUaWKp3tSOjsT0ZVgy4ah6rUdjyy +bLAOAiPmAP3ryStzURF5/RnQbbzrSGZJRfeQIxY2871hWg241/wslRtNpsxYSPCI +PHMVB4SSFYzzbKRgUU7SXsVQYBAlRU644UE+dB+b17slv1xvagOUiNgEEwECACIF +Aj0lzz0CGwMFCQHhM4AECwcDAgMVAgMDFgIBAh4BAheAAAoJEO2iHpS1ZXFvt3ME +/ijwFJCSNoY1AfCEm3AX6vRKUbjiy0MdemsqajXF6awcbIaeCwk3wVr9JOs1usu2 +/AQQDvz0sf/hEv6c3sMTYspD6+QzrRMUVbLm0fp+pRZKyaW1tO+/JIoOl8qsOwod +kXPQ7CYFvSZhhkxdUwVOa6UtL6kOdCjQAy7DDQTzdcC/GxHQNVUNF5KcBWC7LMN6 +iAt0dAFEMaQz4t37CHq+DCyI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4Ai +GGRuczpzaW1vbi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCQkBc0AUJBlijpAAK +CRDtoh6UtWVxb9EIBP4pk/ztQF+XV5L4krXEmbjAsGb9C+I+4OoRUY/mWDvNAjGp +pkhFD+8Q3oQvg+1dcPsJ5rQHSXgA2w1bOsTknK9DamyY35LHd9T0ZSllXOUX9q3Q +eKiDBYc2KB35ZtxKNIA4Lt5qDgYbSgtlERxDY94BCSy4YApdwATei3O32t5IoR+B +roeIr+w+zn9mVulkn3pRXByYDX/scxcTtWwRL+UNiPsEEwECAEUCGwMECwcDAgMV +AgMDFgIBAh4BAheAIhhkbnM6c2ltb24uam9zZWZzc29uLm9yZz90eXBlPUNFUlQF +AkMVrNEFCQcvRSYACgkQ7aIelLVlcW+ahgUAnWORH5p6Cdk/zhen4sUwwnzsFyAO +Z7vaVPrQPq58Czl2FymLm5kJgsGXH8b6KLxVMo8hjTZnsm+zO6XTLXsnnK7nXk70 +gBJ0AAM0XGlG53qDvvQmq3RkfFMHuSmxL+zL8pXTmnywIlEpgDHPVKbPKF3c508H +FEPKFnDjuyRwPgq3q2mhC/qYYBRvw9hjjeRCqDTdC5wHuWLzs5MCLeG+3YhGBBAR +AgAGBQJEc4b8AAoJEAixI47drUe278gAn15puEaeLjlpaTndlvxT+LAH/951AJ9b +0Hlo7Py6F9c1liLsMNWNDnyvZ4j7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIX +gCIYZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJD8ykBBQkIC2/U +AAoJEO2iHpS1ZXFvrF0FAJLVqSWQ2fYNGCvBH4xRS4n2LruzdubmzNuCIZrc75M+ +RfTvYeHwCNDY8H+PggYuXMT8armHvFvyL7jln864M9LTX4TwROrqKlkNgOkfxdSg +Oz4QE9RHxxooF1GMl1yhxCoumixYE5w0z0LGYRKy/Xzd3+VMcUaFXvEqY6Q+cnQo +qChCvKRmsIFhF4b4SAqzRePdx6U3PBpC4FbIlkQkpbaIRgQQEQIABgUCRYwLkgAK +CRApqihSMz58I53iAJ47ZGEOrZrMqV6WKmfKa8+5907zeQCeI9LFETr1SK3IHx/7 +S7RlQhoqAzeI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1v +bi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCRObocwUJCP8vSAAKCRDtoh6UtWVx +b9fhBQCRE0dBfP855Vv2fPCzIxnu1I0GM9BjmAC4uMNdW6o7I4yQMXNYpP8RdxDz +PTon1JYQZqQW77EdqtwjFeguScudF8+85I2FtKDmzl0NNubmX6ckxdCbuUmOk2Vu +H0IQ8O0f1htk0h4dQB97YA8zu9AtqyASkdCDbRC7RgoaeUaV7N7v8RM3KpEJm6pc +eQT1DLqOQIFAp/cDa76xXK2Xrd4IiGsEEBECACsFAkXhdvUFgwKHjGMeGmh0dHA6 +Ly93d3cuY2FjZXJ0Lm9yZy9jcHMucGhwAAoJENK7DQFl0P1YbgMAnj34VvAwJhWn +Z79fbgSY9O7CIBJFAKCJEs0DbASutepLJhiysH3J61b5D4hGBBARAgAGBQJF4sLA +AAoJEKrPs4YhG27v90UAoKBHaY3RXOkwk5YL58jSYoOWltJ/AKDTwdKSURBZ3RTe +GkriWGZRy2sfd4kCHAQQAQIABgUCReGU9AAKCRAmSeYoxdNNBWHAD/4+/J4V7cM1 +dMrr6rpaggfgRa7d121f4n+KVn69fmxBr6vMkGP+8Aor4xMGvkL6HYJvOMRK752H +wXij7TM0HdGqU0S6cisOXiS/LOPQOayz6HuvliIhJeyDF4wfI358ZH8gVTKTn+1l +tqWmggd8KVbU2pEvNte+lD0VIxK0wrUT0nFEYoJsDlTUVpnmM4PxP8TwoIRwo/h9 +NnL8zeh+5sj0D5tZW4DsTC1AVPH1WYUN4aY2lv49twDh63oXbzXZQ+xKWJeiByao +DeEOFtouwTb7RbmDBB1i0aeb7gWCryUiHD4p2zf+R+4ikcwcG0LzR7DC3WFdlPnb +NII/G31ZDacpPqkk5S3LL2jIXKhpD15ilbXGjkqsBAkOJpO7rehVbxEGUfGh+2TZ +cCvLHeh9ckgjimFlZywk230H/tkQJpnHaTOmhNbBbowUkIdCjTBLkqyW99sM2heD +kmkYh9jJTj2BLVED4HrgyMp+dXGeDM7nVGDCPfbaFTTz6It+ODndAC2Q0d0N59Sz +x2Xb8LYfngezdhV0q0GgGXl+vh9zvZnpHV7Bef6ABTq0IOQri83IZv3HlyBeK6KP +JTx+ll32ByQ8JcMuAAaVqWXI914J/fD9bvsTzJNQsPEa8yBta22Ww+jcnHBBhAbU +Kfw5FKNDrqYr4VGY9+am80YmnIRQIt7Fu4hGBBARAgAGBQJF4fboAAoJEE1EwCDF +wFuuzREAn11W3gtaynmEAcxw/WxLdndmL0mmAKCsf55yO8kTmKoohRXpfo+jn4HB +XYhGBBARAgAGBQJF4gz4AAoJEFUVYHaRYekRxxwAmwVy1T7YQQtP7xXNdM+EVUxL +nteTAJ9AzaxlVV4dO/OZTG9QDbqztagH54hGBBARAgAGBQJF4grQAAoJEMfZMCWd +/6rUv38An3mkvCWcxGKhN6/PgQ2+W4zpFQPDAKCxweB0Xh/TQDjQ/dSaoj/BccNK +LIhGBBARAgAGBQJF4hFCAAoJEOVE3gebfDKNJ4sAn3owtLwwEWtpw9VQxTc66cmd +oFqPAJ4r2z3VgRa/Ns/uWMxV0Zlee/f2M4hGBBARAgAGBQJF4i3gAAoJEHZJQAVJ +ruv2v54AoJCl4M0ClZrwxyTkOXJs7xeQjtDtAJ485636UH2u71nZdIyGTMqQkszm +BohGBBARAgAGBQJF4sNEAAoJEH5OpU/Qq0B1NE8AoOJY9VXq8PPDDPjRPaJLahjO +ykz+AKDN3jXgHvqD26euQ1ksEBc8Vn6zF4hMBBARAgAMBQJF4sR8BYMChj7cAAoJ +EHMcr9NTwaMv9/EAn35hATWBiY7ra8Z2bjy+GZ4eSLQmAKDX1GfInkT57/rzmpkx +n+IQlikCMIhGBBARAgAGBQJF4s6iAAoJENoZYjcCOz9PA5IAoIZucQg6PaqLETbG +ch/y2UM6BhZ2AJ92fj8dOvoKNxn9Rh4UcTSSiPXNDohGBBARAgAGBQJF4eL3AAoJ +EHhn1Tx0eTXduhcAn2LWbAgZcRRU7PJtIO3zqsIm6keDAKCeZgrQaUd1GSNW4AzZ +LuT/XXiWW4kCHAQQAQIABgUCReLO2gAKCRBSIlPD1yc5gYUMD/0ah8KqI6rjyi7p +WqPPcPKy9ZCnPJv2JJllu1wx4dqRZnUVA3rmHAUpzQp7HsfMXWLgjxOnUEvzjZkP +PamYnczdE65l5M8zah1WNjfR8Vk4/XaeolVXe3a5R8Vxj27QRa+T5yEHprb5hPo4 +uFWkPlJgJd+qcXCIc28135QngN5uRRQK4NnM/oTtv2nv15L4M4qiH6V+We5IW+Tj +t74O0mSEekg1bB/XKlF/XcgyO8rEZgqwufZ4cHbzWYXw3C+CKkhDSDItGUw9HesO +u1FS+Mf/Js4+/kFjW8ZJPFO+A2z3gYTDzaXGq2zlvbqw1gYId5pbukVM6PRqQrlq +tI2Kza7/CY85b+DVU9Zwe/Hr+yYnEJdG+eWkshmB0mIXgQlSaf/sglsAncrmxA/g +m5IxaE3TIRW/mtizuCUwq+gigIUEANAsNwR5a/RAekc8aNaO1cSj8izlGqrl6cuQ +5jyizUJB5AcOV4CUDiazITOasbt4+xx9MTsciqWIkMLYRloVuqXgsoKOTxTT6Zq+ +lPEGRyYds7OEdaXHWPO0OJ2ZPCagb3OvqxJc123Xf7XXySGkGXzZgoA6D4BwIB0b +5WQFq8722b0tJPktH2a5clKJio3SMir1bpPT6b/CM/Mrk3kIFKJpmvEBYrKTCfhJ +nDI2GJ4Z/f6rUDhiyQ5yj5Rop2zot4hGBBARAgAGBQJF4vk5AAoJEItKxIGsHnFe +eYYAnRbZnnFoSrbo5E908zFdUPwfVfUoAJ9Dgo1WuGHPD+89PSqsyMshK1qavIhG +BBARAgAGBQJF4y0kAAoJELOx+BoCeHiA9a0An0E0Zyjequ/iRSSB+YolhRqc87tp +AJ9PeRbv8Ce1TY6qCoyIO76zYScX5YhGBBARAgAGBQJF40D2AAoJEDiaVjzCcqEm +vrkAnimr8D1OTH8O8+E3A2VOoxLhG8PTAJ93AR9hPTBxVBY+TqzapQz12ROtjohG +BBARAgAGBQJF40DdAAoJEB9/MmoS7vYqmnUAnjcrUSIjc8jjfdxLhJES9yDBTP/g +AJ9ZSpKAG4kvVjZqcSBhudGIw2NkQokBHAQQAQIABgUCReM6egAKCRDo4GL2DcsE +MZKUB/9bQd/kyhettf5FPhSPgtVgZanF2kI0WnDWUGXbbn8vLs7GNGsb6eyuUDEM +kL/f6xtVHNPC44HarRbawhph/m0P25KQlaHX4120gdYzPR7mnUMk9g7P2ycNrcND +730oJMS3f8FBhe9fnt4adPU8mp5fgU2zTsdVHpa2zUVZHNh84iuEoxoZJEWEyHHJ +ke/avbbc/G6JmMD+8vOV8nKHbuzNOAfA09kPJWAPcfR/grCpEMZ8SkB9F4FvPEjU +2HxeFKx1vWNTamkr6ygUVlX7bBwLCe9p+7ue1rMeKOMsJF7UnAkOthEC2IeyhPn1 +gyErrjYzQOX+3+YPCSO73fBxSG6liEYEEBECAAYFAkXjS5cACgkQKJz/wOY81tb5 +TwCeLd//hOBTT9hnSkZFuxLso9J3cToAoKnsSW/csdFyRJLh024CqSzu3/QXiEYE +ExECAAYFAkXjRMAACgkQjCXuDw3At9aUHQCglgCi6nNiupwbEfwEsvd4MRYVzGsA +niDj36LSv47TIbmUQJlR/qiNJ+phiEYEEBECAAYFAkXjVQEACgkQmEvTgKxfcAxE +EACgmX4IGrSutcvAs9Pfr6JYEE3hdsYAn1yLt/tyLO9laWWhLKhNH7MPHc0xiEYE +EBECAAYFAkXjT0YACgkQIae1O4AJae8N+ACfXCp09XmUQQ/xvA4LipoTAoyqX+oA +n3aZHFSOKENXaHthrpt0FFaPVNEJiEYEEBECAAYFAkXjfaMACgkQzxI0fJaL1Yct +2gCdEw43ra6oy0cwLX+zwRzTXazKQn0An0FuDnGs6J5+x6hlK3MFjyfRYZc5iEYE +EBECAAYFAkXkGvoACgkQZDZDYQnzQCR0eACfWdtadQLH9Bbi/YPOcheMmavmCrUA +n1fBKs46WOq7jppufBXwcncegfxHiEYEEBECAAYFAkXlgbQACgkQeQ6MlGH/2qvD +yQCffMAMRUHCPKIbbz59BVNmgpyvSmYAnRMspmLYF0gk0xfHoIFaS3nwt3DgiQIc +BBABAgAGBQJF6Vo/AAoJEFeTDasLhrBnakQP/1Z460aR3KyxrCrEcDJ/Vzf7vsbq +1DQnmoRuIgpKmR87N3qRLb2p94ffRYYxlWcFj1jiYT3Wq2bxjHyCZPgcAM2bQuuJ +MFxQo2xgwobyNqesIafgdbMjdUEAVy+NTyJfdmM3I57lkrleGz6lk9ojMLoIDa/t +R1C+uoLuSWMj0Xk/nCT+WnN3/xqZyPIa+i6MN8fuI6Nsa/C1jiNw2FnZy721hl+P +1Bhx+i9aiXCR0qz/3AOAOz25F0OXNKKdzOgdo5mCkelbUaey4gPpvb2oZ30rh6VT +elOOlGU6WbEO3DQBuOGAxJ1Ux801przITs1923bZU8EPyfDZyZWINkpl7M4En4bq +GKQkjTIfE8GrSSCp9rsLg1siK38yMYodegSzSJ7ZWWGlyuKvrim1eQw8svSzRphs +ujaDJG8Oy3Dlc3qBbA/CGx1OtyML5G/w5C5b2Wz/BkMgHnOfOJSVjGlJJrxGyydR +qThibZ88yRcZ8130COubR4Rr2I+TD+FZLhGtzQGia4gDQ9QG5td6LS5yLPc3Y52N +cwWsbMHWzLTQ2k3O7PcsetRPLpduiq1eZUZZveY0MSjH+uH3xzp6qfj9I4FDtK6e +pHQ0F9Dw8kK9qBAhiqrKxsUUbalx5Pup0gIkzNe1vzjByS2P/j2VMhbinhG5FZl0 +O2mPcIXHeHlAJdGCiEYEEBECAAYFAkXt5LkACgkQMGnpIbeahxy4RwCggxD0dEmG +z7ipFrmwbIGTxuxIS+IAoKfxzxjiT2m3AEvfkL/xNuqgenPViEYEEBECAAYFAkXk +wVwACgkQcLIDITr1nRa4rQCfZvrXaoYQ8TeX/lhuJfmsPb7kIRcAniKy+cTGNExR +mZutFX/OcnatDZExiEYEEBECAAYFAkXqoaAACgkQL5UVCKrmAi7oEwCgu/2cheN4 +mU+yFFIG6HmLrbeIc5IAoI2I4eLWJdmLpJleOYgF7CtTGIKxiEYEEBECAAYFAkX/ +bGMACgkQOpD/wRQI1/HBUwCglcM0b6fl1oP8iofWeovuhSk4+5sAmQHrgf2pbqFW +1oTBNS60dNQjA7VdiEYEEBECAAYFAka12CoACgkQXeJJllsDWKIizACgqk7R3Bhn +GgzraKbcP9qSMhbYBr8An2Xah3bURySnK2QBDx4GzNM/vCTqiEYEEBECAAYFAkdZ +tOwACgkQcgQ2cL3l8e4/XACg2opaihfpMLeOKb2bNSD7cLpI3N0An2A2r+PcOgUD +t3qIIZ8i24HAhBnSiEYEEBECAAYFAkdZt8kACgkQ4Q56CecvefrAfgCfU/NbkK4w +CiFMyviXo/F8tOEGyqkAnAgNaSmDzLkYZxHlM0SXosfHfV9diEYEExECAAYFAkda +cyUACgkQaGtW3WCKJJsOKwCeLKhorr01GCKnXR8QaGvImLVOm98AoJpyR9WMJ0cs +X+CuEdzGJDTlD8pxiEYEEBECAAYFAkddIIAACgkQt5wosOl/hW0OtwCgposF7nuk +dTQ1nsQd1AGHb0CkQzYAn06bBOKMXsPcN2VvMiO2hiv9FLhniHoEExECADoFAkdc +k2IzGmh0dHA6Ly93d3cuaGVucmlrbm9yZHN0cm9tLm5ldC9zaWduLXBvbGljeS0y +MDA2LTEwAAoJEOdekMA5zDPbZ9IAnRTxxJl2Rtv1ZbnGsOuPJ6musP+5AJ9b8b3Y +9BL7PRHzWgQjzALVVXRrdIhGBBARAgAGBQJHXR/KAAoJEPG6TB7RyLqP7nYAn048 +cLE/iNKJFxl/RwkY9VcRedkrAJ9+Y6u67OnG6HneUhzqGvMDbaGmAohGBBARAgAG +BQJHXYVBAAoJEIUGW1nVLdGnUJ0AnjF43FY5SwhcW2JmuPVu1YnWfrwwAJ990zkv +mIQtRCrxMzMgThz4jVaoEIhGBBARAgAGBQJHXAvSAAoJEO2/HhEm8iS4g2YAoMWb +nnF/sbeM8+WToKO0nnoJrXVAAJ9iX3wXtSwAqrK+3X5imRfXGTxh8ohGBBMRAgAG +BQJHXuTeAAoJEIXCJ+WlVzjy4fQAoKz8piSTCDPkv0qeNq0bdoDs9mOxAJ4lO8Hp +GDqjYheaAvKG7tFZ1fsZjIj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIY +ZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJF1dVYBQkLk/wtAAoJ +EO2iHpS1ZXFvjEQE/1HviHOOSHv0ZuOd+H6SVlkwnhmx4g6fpyeeOa49lywggMBL +8zddB/928PMYFQQ+pvYmECkOK+O6sVO2NkubopZwE/hUjt5sc0XTYQ9Lvxp40N/K +UR8fSR5FvLQSWYGYRDXkK3t3Cta83ZeJk2IK43DpgVoFWMN6x69DlRGTyRWbB2Vd +RvSZz3ZKp86p5cnwMT++K+pNxq+eY0UJorLRj+SIRgQQEQIABgUCSES5dgAKCRBQ +LE8plp8qHbO7AKCPmi7Ri8FKIY/Wf9Ksa2NFDxUnRwCcCdAwwG67ZmplFNtZlVDW +wFEcvT+IRgQSEQIABgUCSFlvKwAKCRAk0yv5qpXDSUwfAJ0TPD78S3J8UvoziG+b +TCLTlPz1XwCgnWlV3PBKvOxuGSAdm/DOMlY1ogKJAaAEEAECAAYFAkkGvzkACgkQ +Ke5YuZaGUXFYtgwgx9yOo8cCR2a0d/0J8Ux8wAnjLI8m68BCiKW6HmAzXx/mNX2e +zicSEyqcvv4q5XdpvSrcA2kmlREBpu7mmnyerUuWWsTLMbi9clXaKRZ6yQJQBbrR +YwrXtzdFziHqFjw+hC19uVXlPhXYa/8YL6aCO4JUlzWWgVF8xHupfRTIeXuGLkC+ +sWww2VmSm8Fg0FBG9jpIt4wYxNMI77so4szE/hoFQSdRtY1lC18jjluNiygGNQQP +n7r5OKwrK9hX1gGZA2tGYVX0ZoYASRPZcUUzaYPH5cZ86SAg15zzroVD4etmk/2i +I4sdzR9PyKr0zUp5FNSAFRey6avPAhaTNsyVDRiKmK3PnZF9H9HaRLJJnQEcvevN +04Vg10VW/O3zCFMFi8zuxUP6ygoDdWZT9jR4wbzVEyFY7AUwXnStDd39p3oamTb9 +XtlngTJjmVBZIOlap4vmKsm0t2xviaxto6uR+656Ya49+SoXp+u5+dGDT2o0kFlN +aC5r9zovItqdDYUHtn7DsIhGBBARAgAGBQJJZyWPAAoJEEc46iFldJl61+EAn1jp +iTpjqq/l1oKwJQYDB0WsqGd+AKDEiDHvrN46b58gzQKdVbs472bFS4j7BBMBAgBF +AhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/ +dHlwZT1DRVJUBQJIYfmJBQkNGHReAAoJEO2iHpS1ZXFvdAwFAIshSBfY4Zn4BQfa +p1gTIjjcRy/v/bBnNMf8gMXkfm1FLTAaanO+n+lHsTNErPtaEfx8dyjvEg+wmOba +qAJYoR75pXBFbLKdiN/P1Tp5Wd/C0t+cTT2datz2PL5XFKAMRko9rST8C1MWOiri +H8akc6U6M+1Vy/dYcO2Tf3DxrXDLTFyrkfV9oREMsRFZu6W8P7UT578Epin/sTYY +A619IXOI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1vbi5q +b3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCSaEuAAUJDq1aTgAKCRDtoh6UtWVxb4pU +BP9f7+9yeYZCJTvILOWlsYIvl7J2P0em2qYn3NbDUS1yq+BUO8udTYNWwyxX9zGT +5obhX9bhcWgms/UbGMsvlZcOT+e438P0t1q5q8u+FOgZtfkgZvyacCFvT4Fnd00B ++RaaGZ2atnodvhN8qpzHIf8GVrhzULEtdA55BRw+x5f6ORdSD14IFWirQ4WWKaXT +URx5LIRxs6twYJawkumU6m4KiNgEEwECACICGwMECwcDAgMVAgMDFgIBAh4BAheA +BQJAhr4rBQkEnwT+AAoJEO2iHpS1ZXFvkxgE/2ZfCBqYKIe3SDM0tOVNrIeSZuVN +Uyn2xoqRKK4VomvTI1eMShfGa0twPVlBB5xXHt06yRbwjobJykmDc/Hmteel+FVW +OcehnXq8T22gLENlEM0CUZellosNwFwdnWGOHGZs/B4BVCh2pzsCra6di7MKCznZ +DOHX3TBLoqVHjWzCldxtwc6Y7fAsEtrLVos4+0JvjQoYYgHQyril5ywHYs+InAQQ +AQIABgUCSw6cnwAKCRD1TYragIIf6syABACYfsh56PcvpDJ3pGPoylowLFW4DEP1 +4dFlADmaZd+SedFZqXI/Vv+7fT19W1cx/HqG46WwmSQjPYSqI3IMpB4IYMnsDYDn +is9GIXLZyy/s4i8WBiiuRkuG69Q+SOjyF4X7MBh3UB2zkelpHHe1OTknOQ+7qzpZ +rp6YhpAMSmSx8ohGBBARAgAGBQJF6qGjAAoJEC+VFQiq5gIukCUAn2UXazhZrEHL +vZH0c56N2LdNHYI6AJ4zZnN8vY09pgpA6p7+YGQfnjuyBohGBBARAgAGBQJK/ASb +AAoJENG84OKPoRoVuxQAnRhqvmMVRkSQiHLSQEnXu4zO2SiXAJ4l9/uWrMqAKUPe +BcxbT7xrnru0zIhGBBARAgAGBQJK/BdwAAoJEHJZXrGBcEuTMP4AoKtme6FdYL53 +bVxbHklI8QwQEx6jAKCPSXqJmdslSfamkqA0dTncqUAZPohGBBARAgAGBQJLASuc +AAoJEBgFUbrZWjw1PeIAn3GHmjiGSmkJzDAKpovoGEviB4DQAJ4+tap00n1o0q+b ++8YjEN9tCt/VZohGBBARAgAGBQJLDEARAAoJEHfdleLqUuz0LZMAn3fBmDQzpfUX +yhciz6dUirKC0L6aAJ9IbQB4y0s1o8eR2ZxRXy5cYB30FIhGBBARAgAGBQJLDbh7 +AAoJEI53TMap06Pgx1gAnArZ857v7THGYpmTCjbwBz1oh7+4AJ9CNLFSBqnrZ+9p +YKH12RiFHLmuLYhMBBMRAgAMBQI9XrB1BYMBV4o2AAoJELy7xJVxipJWGZ0Anjly +M5hKGecjlTcoKYWJlMDjf0vCAJ99oFg8mkzKasg3CREHi3Y3Fu26EohGBBARAgAG +BQJLHGQ7AAoJEMcaTGXwWbHRLcgAn2h+moRVxidIb1mADTBGcOy0DjFjAJ9JLJMZ +gCvnQEmvyZcIssqTJ8Gx4YhWBBARCwAGBQJLEp4JAAoJEPKthaweQrNnE7UA3jYY +Ov08+w9dAdbxBmwnL+Lev2ZdSP8M+YS1pXIA31NNq1SYUuqb2CVCGUmMo8m/a5uS +Z/0c2Yyr5OSI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1v +bi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCSe3n2gUJDvoUKwAKCRDtoh6UtWVx +b8gaBP0SDiN4gn0EUY2PPLQvFNkvZ96dIpHbMpjfjkmYSJF0zhgcD7bxWXjXDNng +BblX3JMs3yhg1GfQLvLVpQ64FakTT/XLCo9VecyFxILzq4aSQHyxG6OcAKyq9ibp +Y4YtUutwV+jiO1/Zos8cdtsyDdn5RYYe6v27omKYRKrGHNlk8NjAQC2pONY8MfPz +MohWOcGhwdVYatAZXYENCo7hvlruiEYEEBECAAYFAkt731IACgkQchi8veCamme7 +FQCgkuR72TM4Ii1XM3gNK/u1j3B38NwAn3GgZ51dtypPDikroOtv+W3J/bI+iEYE +EBECAAYFAksBnFgACgkQ2yYwJIHdsGU/+gCff51YjGdTyDHizwOHy35NzqcJMVoA +n3olfNMrg1kyD1ALOsJrRzgNyBkhiEYEEBECAAYFAkxL87YACgkQgxIgkKLogl4D +uQCgvZr657F1MuZpnNSIjkwcd2ptvXgAn3eAnUDlROcQMZ0mRLYU9CX2yfdZiEYE +EBECAAYFAkxN8UgACgkQZR3zUj0j8l2XwgCgtRkGwT5aWUYbHugdou4OuCN5LzIA +niyPXGVOll6eMmtikWqz2BvJC5dqiEYEEBECAAYFAkxN99oACgkQv2Bwi0hCbH4U +TQCdGh2w9AKqGWfgM80p2l0bS7kRwIEAn3NoyUgMmxR2RCscRlymHiAO27adiGsE +EBECACsFAk29TNoFgwHihQAeGmh0dHA6Ly93d3cuY2FjZXJ0Lm9yZy9jcHMucGhw +AAoJENK7DQFl0P1YOFcAnjf2t4YAmxXRd3d0H7huUtVBqhtsAJ4uiqVhIskY+of4 +xIMhO5JSw4GRKIj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNp +bW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJLg+AvBQkQvjD/AAoJEO2iHpS1 +ZXFvNrAFAJhV4iJili/lBcZSvLUOTgVd5CO7Av33Cu/zOYT7MUW2bWWY4aB83xRL +lMCIcwGFU8Tyvjow/lZLu82nih/15MMEBcjqi7XmZSszrrB0TULWWP8C6XIpSoap +nVDo+irjiUjxiVnXK+ML7z5zVGeJbqfzSQdKUWBiYuxEJ6x/1E7hXW/WCgCjz9Fc +NbSuXNyMIpE03BlAzpILz9n1AY1ynVWJAhwEEwEIAAYFAk5cm/4ACgkQf9n8ywAL +7u4wtQ/+KG7I4resK0qo10/cWtHmUknVYxMvH6vWIxNfnB7VF84AM+2XuvCUd04Y +QjWO9p7aIQVXIiIHLp4qfkv0DYeEEnvCpmxeWqasmBHj1HOEfHTRSSwWZL25q3Vh +9f5s4fme7K1p5kMJjAEDr+xKa1t7J9KI7pgBIWcg7kWAzlkIusIVBQBv2YUAxRMj +4ilgug9qfMdxDYu8mx+oxzZTo6XLNkmX5Q49sDSO/eGEQEkFkH/8diw2MfMuTYEi +r/cV/5Vlcxd2ZR2ovt4iggRnPp6ngvQqlQZ0rlmu5uAPzIt/6q3FfoH6KBDxQY42 +SLdsGCC07sKScmD6pAHbiS5JGsDzBORjhOvG+LqHLDF4UK5H7bTkBqSOFvPRjt1N +1mnvMkg+UXP11/A98SBOVnHmDpyYbRIn0kdgbrjzAVCiZy/T1wDg/+drtbwPMH7A +vuVGMsTg65NY3UUw3ZnNa50l/iu491FG1JlXiQISVKMe37o2m+qBZ4MfRGebmyMX +EZLClao86RgQZp7spWQHnGhVR7uG0F1OIgv141pu2GNH+lJp5APvSdMiShJDDESd +Ag+reAMPHLL6G8JQzZ7a7ZXXnQ0SstboGQ5G2kvvUlrIeE+EKA9xgdxiuGDQdxOo +0NAlQ9eknsBOat8WrGNKt4i4njthIhJrBbjEbep4pHIxbbyg1J6IRgQQEQIABgUC +TlfF8wAKCRAHka+MwDNj9MQAAJ9d9abp7szIUvqyciUSY5bD9FGv8QCfR7ZbRJHI +tGuMxYmTpEhUA7FbWjWJAhwEEAECAAYFAk5gyAkACgkQUpupYmkKcLEO/RAA2EC0 +eDpMXKoRGVDDP3PPh6tqAft7dWVTiEtFRGOMk/nPLpEi4lgHOb3uul6A623nV4uQ +wM6NiufASRjnx6VJ87I8tCZxBfTooIXpAfaLAnILGwHmgJAH0gGuYr/iuz0KjYdT +DEjWvDr6t9pQCyvhpPpIHKVsNww/9fAG3cwD+SNojneK+tOwwWMffp99FPct95Vp +91jC7HW+1g8MINACrsq5YKjsOS3xtN2jJ6Ceep9eG8xaiTG2jV75+SXh8uaPKla3 +X9bR9H+Nerb+iI2TrNLoSRXHKOrmberTq/sBHoYhFpg3hlA4SYeUuReVCQeLKG+W +/YluMSWvkP+NvhOpSJ38avNSiwMmu/5EF3uCRxwaiR3Mg/DwPnfNPfw76B5P56Tq +I1JUHJ+oKQbZ6a5UaNaxR+Pv2+uxZ7JgjGSzJim3HS44dZrU5FjJGFnzS6iCjSHQ +y+9j3SPi7MlAp90AB8XTVrgyCYEME3ZiqmtGoHeQics/0bEz3OB/aW/eNgF80GOg +tnEqVoUfkhJM0dtbS53xJ9MRBMqRfq9LTOS8cK/hR5oZDSoiAMemzzyfQmqT71ql +vgyzVoqQvQTkAljrdnXwix6F1t6SAUy+DYVmID7on4hS8IKcb6ZZBsNtyzRpoiKI +3nx/eCmZIOrXmI/KsTBLM5IEptaayQx3qJf5+TqI3gQTAQIAKAUCT173WQIbAwUJ +FLfeCQYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ7aIelLVlcW8hQgT/ZmLx +r5flU2r0R/R8kZj5kjo9KYQM8LKmmnECJQonkyevtdRBpEqcq1QS/eP2YlfOpbQD +vHSls6A08zY+ZDOGepx56JfR5epoxKzWoXJq1j3rqg5f0SsevgfFl8gAsvsLE/5f +/+S7UVzIWOY79KN9MYrYc5vNhpzZyDivna8ynvOn2PZV7O4c9sM8IpTVdZmmkPwR +RqupkLfg3YJmTdz0Doj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5z +OnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJNk3g+BQkSSfMGAAoJEO2i +HpS1ZXFvCMUFAIGmNW+nw6RHfmUFa8QUC/bn5nswDmG7G4JChTpbdG1dq5dW1W9z +hQEBaJPkKpSrQkR/L400rctYJ2MxPp3TWeoiHk/sgREzsU5IpZHezhkFjb5kymZB +xQ+pq9NMpHPFhFNR5YmrNibyTGN7+FiLATb6QbYAGfdyLCdjBmwGId3PgBXQf24V +lNmNT8tsUC8Q6uwIZPz7vzXRkEUSBArOQYaJARwEEAECAAYFAk99QkEACgkQTvKT +Tk6qQjL+Twf9HqEK1AGu5fxGauWY5MKC+6gmogPi50b8ff4uXO6AZagmGqX+vvw5 +U0AOTLW1hGhcECOeErOfqd59xgGrg4vETHGiE2CR25RtuHxX1/f09RnjYsoXMjMt +bxm5anIOiyrJrr7jQ19e4kdkj1/nJIo+5gTiHC6yd4c3Yi2JE5q510z0gPLeE6l0 +mBMD1so3OMJ81duyRSjzKNyru4Eroijrgzqi8eUoSpPoWtYFdt55DRK52DTyVzPN +MwIl175CCncRMOH2H6DGFa7SPYdqq1bcw2ur5OLtOz4AZNgYjChcIQQVL/GUMa3P +0kuLl55a2T+gJlJD+d6J2t1Qcoe6LBfITYkBHAQQAQIABgUCT31CQgAKCRApryTq +nRwOeYQ/CACgDU15CLk6GRpHZ2rv+oRVfkOHBI0xiYlRTRW3huzxPnAN4pnJZOdE +VKKaZltr0vIv0NN1Mmo4UpjxF47Y12GyxImYHqxBZX6OmETgqEwuGfdE7d838pk7 +phnWqWbfDYMJrg0FIEZnBvvtIzTpHP2QWhW82FF+lIQY3cyKp7erdw8mxZio+ImQ +MwPTQ8QWdBECDWLsEmnQUrvMdAdzKLKd7SXpQ4dev7XBY4QT2CVHvNf8DkBNlq2a +BR2D9+PeecR2LDYh2noghkLQ6G012V2Iur0RpE9wJETeelYQHjp7QES3i8meaYL/ +z0l0KQbxOtKtDW7/zwGMEQCnlyDqC58RiN4EEwECACgCGwMGCwkIBwMCBhUIAgkK +CwQWAgMBAh4BAheABQJRjZDLBQkWmb0GAAoJEO2iHpS1ZXFvW80E/iYiDDfunjVr +0XZNdgQg3qyxKzD9geaGU4QnGJtDOimmfsEHqkr6aCiatvXQpeZ7GVx73oNr8dM5 +cDV37MnsKu8XLjxmPnVdsBL8iZBsFQj8Recuben/tudX19ZasJlg8eQhCpF+DeCt +z4CqA9S/57n0VOI5i6Ycnn9SeVXuVjAXCxs+3QXl2ZnfsxpdiOtZwKlDJZbPjTDt +JwiQX9MRqyC0IlNpbW9uIEpvc2Vmc3NvbiA8c2ltb25AeXViaWNvLmNvbT6I3gQT +AQIAKAUCT173QAIbAwUJFLfeCQYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ +7aIelLVlcW9RjgUArirRMHZOoxdCaEe2LuxKM3zx78QYrCZXHSNWiB58uydwx6Oc +7siglrn1ECbGUWnZhPZ1BjYEMLUdV4DATJeVw2gLdAqc3lZfT/MkVXY9cuk3zt8S +xJ2I2vkLK17A38whkHLWEHcZmwI6MHEyPRx+bPCbx/rgImWof3NVDcbVdqyPXO/B +DqYp5d9REq3PyRycoAu4szIM0ImYfXY2o9d0EojeBBMBAgAoBQJPXvdZAhsDBQkU +t94JBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDtoh6UtWVxb739BP9Cmqxb +9NVzED185DhdN8bLpnjZaSNtmM3FeEO5Q3dBBbBWrbl/eEwIu8ax5y40q+C0vk+D +xRSF11g8n9TmyziYqeYyWccEgrWapkgPWbSiwGrg7Zyqo5eIQcw+HUMi8eZT3isd +aA7ur1c/gV059yVthIuTBiVX+xtUOvnHf+f+2Jrx9euTmj/O4/w42L0kL1TCaq+0 +unKCc6CHcYh4kcvViEYEExECAAYFAkJJAYsACgkQj8NyXz1o1joWfwCgtb8mtlI8 +rg52vT5DRU+Ct3NuDfEAoL7IX823ezbe7HVegheirf3q7zmKiEwEEBECAAwFAkJN +grUFgwDgKBoACgkQO46kH4L2EkA4fACeN2w05Staf2i18Sdv9aRax1hb53AAoL1Z +YuFfT+qVYT/afh9wD7UPlEVUiEwEExECAAwFAkJJRAoFgwATzkoACgkQZr5x/2dI +aIPZGACdECs/Brf5HO0PWPwIYf8GTur2kPUAoIHIKUWKCeoNUF2FnUzvx8b3uC7v +iEwEExECAAwFAkLYsI0FgwBU+kIACgkQGFnQH2d7oezt8QCfXjmAsN4+tvGt/A3Z +0bn4i6+m+1gAnihGZHKHHCnBqEYT7nbzXPZVOtD1iEwEExECAAwFAkLYsLEFgwBU ++h4ACgkQgcL36+ITtpLuwACdFi5eiQDLrrGLThgPU4O2yxgXDucAniWqyEVWfs1H +nLOe7S2KhgsXDJzniEwEExECAAwFAkLYsNEFgwBU+f4ACgkQa3Ds2V3D9HPaIQCg +kWvOhiORHkA1lht5f+jNB5xAKYAAnA0Kg/JKZrGvA7oGJR3XVs7zRs/FiPsEEwEC +AEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6c2ltb24uam9zZWZzc29uLm9y +Zz90eXBlPUNFUlQFAkJAXNAFCQZYo6QACgkQ7aIelLVlcW/RCAT+KZP87UBfl1eS ++JK1xJm4wLBm/QviPuDqEVGP5lg7zQIxqaZIRQ/vEN6EL4PtXXD7Cea0B0l4ANsN +WzrE5JyvQ2psmN+Sx3fU9GUpZVzlF/at0HiogwWHNigd+WbcSjSAOC7eag4GG0oL +ZREcQ2PeAQksuGAKXcAE3otzt9reSKEfga6HiK/sPs5/ZlbpZJ96UVwcmA1/7HMX +E7VsES/lDYkBHAQQAQIABgUCT31CQQAKCRBO8pNOTqpCMnTvCACSQf9jsr2h+M3A +drvI+qq/7ZPDOFicpVicmiQETcQLfuIXbiedWnio6F4tz6QI2Ht3PYGTQrkXUVnX +h5FV2wxJSuxnOg1j6pBGWHig7avd0GpkphsRUrWetQb1zPWSUILqIuKJAUznPTlU +v9nPkHF2KnDA9ZSaQzsOKYC25Q3bHpIKpPU7u9lYisrrLEtKg+v97WtCPmj2TTxa +MSZ1okAyjFwMV4JtLKPsfTnGKx4fMxqtzEDG1j3lftSaJtkVwacDofcxyp8oR9W8 +tb5lNsxpABUh+H/TuJUz7QwA4QJ+J7Hq+r98mQau81mqoR73JzF2a7cbpM9BED1L +vib20ICEiQEcBBABAgAGBQJPfUJCAAoJECmvJOqdHA553xgH/RznnMpNXcMqDKBt +bR7ux87SeUKREIrzc9S6+NFMN7NCjiLUOSnpc1fUQucQ3DCzhKPU8FPL/WE4zcRS +Bfoagljui1PtC1K1rzRV7+jYejmtbyN5Cyj7MtGbmvXZ1+MUqI5g+NEZh9fYI6+D +XKuckd74e13sKS6Sm301Sx7ymH96pFG/hui9t2bw9d6B7F4112VHB1/ey5KEZtIE +yHjhyfoKRgoQ2T1D0DEAac0UXpCV7E5J5S90Ka2+rNlmZz/wGupWSlXjw9+2QVxg +YQhnef2ozVN7NXcX7kurWquhhj2dAVtTTmvcykLkb25GICFj1MctosATHYVzNLxY +GY5u846JAiIEEwECAAwFAkLYsPEFgwBU+d4ACgkQquPmzmahRGhfdA//cVfLmv3s +4VjruQA4BxNcnljFkLHnCMfUwOUFUIPKaYwNxNkRHv5SWwsHlYcH70prr7spkUMO +9XCHZqhdXc/UfJm+tjda9Ow3D8Ym4bR4uKaBDcSB6rxG7Tkde2OkJeA1uD4ytbrf +ctsufByul04qgrW4ON4xHG15Na/aiyZdi4KKWCUNSiQsH5/gwlWnUQNhYFXJTBlB +iHYok8KddvhP+9KGKDMy8JvuzFIGyVKUS8rbHOX64U/dYl9pT6HspQBwENOvNVom +sL3sZarQD7aPRo27Z8N9qEjqiCXG2zITfBvO6ZLwYZOcF31TO5MrrQRYSB3EBRnr +hpGaYHl7eNDXFCX35/ijn3l84HUMJsDZaPStGq8TaSLpILoL1XjbbCo9YLVuyJGH +C5r5Q8koc/3MrYLjRFPtVtGXhu9046YbPJgkpQilXDVnMtpe8/w7wd1T4m2nOduf +0sNWSKuw0oURx7/MdNv+ufCxFu4Er72eI98rmUjYC9pYD82mKEKPvMrByvXalYlQ +VwByMFWU5l6bW+c8UHB7RVJ0edSA0gHwRne4I1OTSTXyip4C4wycuep5iRjMP/td +xeVxXIxjwvbemSqELne9divE0SHM1oBjJ4JGock5eCiMD8Vc1p1DdCJHLDv+cjty +bnVs82Aeq9UKJgkgAAProq7LScFbQVrAgOeI3gQTAQIAKAIbAwYLCQgHAwIGFQgC +CQoLBBYCAwECHgECF4AFAlGNkM0FCRaZvQYACgkQ7aIelLVlcW8vLgT8C/+0iVDx +moz+bvmODH8bZECjB+jyzdYSDBLEmrOPEjcyRtwFKFMInAZX+L8Zsfm0t6w0LuwG +kK4WIgiMC74JrHgGClLzLr/fjFUy5C57cGkNHA+3ksCfgzsZE4GNAW0UmAGSleWC +KaSg/HBDqO68B+9ge6C14EZ/qGaYtgNxPKEeEb1iHgUct+2aLni1WgijM9fkQZSW +UKChhKjyfph44LkBDQRPXvPYAQgAtBcE7pLVX2QYvdVkY5a69asAe4FYYg9PWTnr +sKF3OEW/C4iWo5KbKdfANPqfpLElb0MkVVGZuZQaa8KqnOZVYewxhGmmCk91aVaW +63+mAw1OFLs7cNU7oSST8+nQLgmwEsxvx37xwV0NlIQ2hdU3/umvv8OBjL9fc32q +5QRkDWmpDLqhkSPdh5y/qQ17ICK8Ltb+VCUPWL6CfGGLKBu0Bf7gxA8lQtor7wAV +Z7rGQngPujPnNT+5PUCprnaL6PFuG1R99BwNSssE5U7w1kdhZq7fjeszIiuoQYBW +RR8Y5n8JyXAgfQY/FPLat6p+uxD0y4+kaFlwq4cVNDbEk+KDLwARAQABiQIWBBgB +AgAPBQJPXvPYAhsCBQkCky4AAVsJEO2iHpS1ZXFvwI8gBBkBAgA4BQJPXvPYMRSA +AAAAABUAE3BrYS1hZGRyZXNzQGdudXBnLm9yZ3NpbW9uQGpvc2Vmc3Nvbi5vcmcA +CgkQYM7nERBeci7Aigf/bgS6UQCKQv8gPUTbI4iYzN7OTpUTjGcfwYqualscJgHZ +DR9zPItTYbJGx+YmqEkRwdHTWx7X9U8DJQDbS243TTcxjfGs+Nkio1Yh6ACb9onJ +MZjTF5v99+ogKwMn4RozJxrvainHsNisdCh3jxXb5zNTG0hhd1Y/E1xNs7ktJaAs +9JD+dZmAya7ImL3AY3OwD7u53NA4dRUH6v75SyXl36Hf1i2d11WoGlkTmy7x049R +X9XvBTodTFb/c9GQTaxIzKkxWKtHPPrcsltBGB8lT7wqQTxRDygM7ip58YKlny8A +OwcD+000x5K8MuiHBN7ghrHm84vcuy+TFjZ9ikA4nDt8BP4pr49m+JgobW9NQgrI +mItU1Sp9jxANtpaY9kf3zzTp3bA5S0LEQdQcPc50xNDN1yU3CcnvBM6XUdkpSy+S +DV8R21rc8APnetlxG0zkPSdGozZ4Yom2c/vHHjS7L8BnZGpOgm7X1RuQ4DTatDZ8 +IKjmDG0u0Byo8rxsaG0vCqBJJwRISLJLJxtQ4jgf9xIQyrQIlZRtiaUsHiAN84DP +PaH4uQENBE9e9DABCAC5ZTl/gBbsTPR2pUidEnboEhQ28AiDG3U1CBOnKVjeeC39 +SJ+zGoNV3qnRBa1jdwiA+z4b4drUfsMFSLlCPoiZs8Zm7QCXZppGdHazy8/Qrk1f +Q/lb0y4EVmYe62CCrqL+0uKQ7XFZdyECIhMiXcofmJFyd+mo0rnDpwRPwEFSRnZo +FBsG2Pf1bVM7LW7HhCv52KVsTFN3GQQRWDLUD6w2eyODj8S4qmVUlUhhjKJYn0hB +wwUsddOEicAByOZUWe/IGChcffcVUspE3SKY24A0OQBNayxPq/QKtRdBunLUPvOU +R8/sfYSUeeF6gia0K/dfVas4pIk6GC+frFwkY8PZABEBAAGIxQQYAQIADwUCT170 +MAIbDAUJApMuAAAKCRDtoh6UtWVxbwGiBPsFzcxVZgwQtKtCjeUN8tg/scADfbJ5 +29Ap3gi0+7qqTnOsRaGK6RBJ7XGciwV0rfg1BUetMbslUJ86tJay9FF5UlsYkhlF +bqMCtzCG3XeRZCOAi6PXha5QzFxZpaZl1NnBxScWtbuHEZfnohUrE60UtFMUXgr9 +w2qo07hhitK+J2rxDF5z3VtnEJb5KWr574YO5cndFxjJznXse6ATfi/9uQENBE9e +9hgBCAC7f94ryf32es/cOXm+zKFa1zbyLckzDU/EiBc7fj3mcYzaqv3E4hodIKJm +ZWs4tiBvkqi8VmLmT7S/NH5CX3rkAS2cd3tAsCUgVLYQK6AfXwOxpAH+HXY24ALY +fQCpmdwpaw2yeYAZ90SKL+slX77PJX9hK0jeEhJv/gb1SllbVRGO9JInFQ0gF89n +sSNVwUbcnhUwWUzU+Ni0F4za7jyjVwT4DNOT59p1puFhEBpSMWah8gRuQ0nQQXjM +zvV2EpKriu7GlW6LMWJkC2Ef6B67rhCaMFrr3BCjGmrqcEQQgFF8hjB/s/48mcrp +mvKrV+s6vrPEiOeL1PzEZD0yxLCjABEBAAGIxQQYAQIADwUCT172GAIbIAUJApMu +AAAKCRDtoh6UtWVxb1gMBP0fg+ae2PR6Edvfg0SCIGggggrVYL6xduKqK29yO6YQ +KF4qrFgEhEMyOaWQr2zN2piSOn7PHUKpxq9s9H4Z4QoaKI6caYwqd7n5NFHjKqHP +opkXXzoRjQEwDVtUtiMjugUzsE7m3AgzthwDk8NCkt/RDWYvS+ovWnUXqAoTE/cF +SOMizBDGEltQ56FI8DutONBhqMUEPTelMh9dM0yWZqI9uKsEPNUHewEFANj02qE/ +ETZBQ5V+1Ajgfb2kRca1/nTe5ekDvjtDIO3VXYyLRJ2mmJCfq+C13nCOOx6ILFBh +MUXQ2Bk9A6u2mfBpAuFCj13N6tilkN4m98I96pwhptyF/yNuPcnWCwM0MlqjFtPc +Cweb8YT4uMo3reBUxlprWFJRsw2+/ulWYpWEU7ctL4RReHFV5Ttkfr4D8RTL1HO6 +PFhg50N4slgIs5EABimIxQQYAQIADwIbDAUCTvm3OwUJFLfdvwAKCRDtoh6UtWVx +bxtQBQCMME1gRLDDO6i/Mg331TkBAKZkrThK8Ugos6dVftPKy8RyIHUpwyVZNvqi +JS19WuWrjvWL1hs07QLBxG4X7BcS93iCvfmnURXvFRIm1BsvVmTVbjlLpaTKo6Ot +qM3tMOwucYazkS+eE+sN8qxcD1G0vwEpDfXKM6XrUE32eFUMI8G/T53qz90hWwO3 +0AYn3TVGm6UkXbeIZEuTh9zbapH2iMUEGAECAA8CGwwFAlGNkNUFCRaZvNgACgkQ +7aIelLVlcW9eoAUAmoqau2N+23ZC77S+bMgp9fmijyP49pmrwaVIZ5JyLhuGjQ4r +z4GD7yoVjKV/8aOBcA5WnuhhJ18okFI+Vy8L6mMKs0TQXi3rjxoza61oSPMimWqT +oj8c9lhGHxihx5hdMqKJnMEv8SnxXx01fqE+TCKmSTOzHpWrO2TPnz9qzZOv4BaD +RKd+AKc8zZkSX14v+TFiB4VkSBVxHDvDG4hDHw== +=4uNW +-----END PGP PUBLIC KEY BLOCK----- diff --git a/libtasn1.spec b/libtasn1.spec new file mode 100644 index 0000000..e54dc06 --- /dev/null +++ b/libtasn1.spec @@ -0,0 +1,99 @@ +# +# spec file for package libtasn1 +# +# Copyright (c) 2022-2023 ZhuningOS +# + + +%define somajor 6 +Name: libtasn1 +Version: 4.13 +Release: 150000.4.8.1 +Summary: ASN.1 parsing library +License: LGPL-2.1-or-later AND GPL-3.0-only +Group: Productivity/Networking/Security +Url: https://www.gnu.org/software/libtasn1/ +Source0: http://ftp.gnu.org/gnu/libtasn1/%{name}-%{version}.tar.gz +Source1: ftp://ftp.gnu.org/gnu/%{name}/%{name}-%{version}.tar.gz.sig +# http://josefsson.org/key.txt +Source2: %{name}.keyring +Source99: baselibs.conf +# PATCH-FIX-UPSTREAM libtasn1-object-id-recursion.patch boo#1105435 mgorse@suse.com -- limit recursion in _asn1_expand_object_id. +Patch0: libtasn1-object-id-recursion.patch +Patch1: libtasn1-CVE-2021-46848.patch +BuildRequires: info +BuildRequires: pkgconfig +Requires(post): %{install_info_prereq} +Requires(preun): %{install_info_prereq} +BuildRoot: %{_tmppath}/%{name}-%{version}-build + +%description +This is the ASN.1 library used by GNUTLS. More up to date information +can be found at http://www.gnu.org/software/gnutls and +http://www.gnutls.org + +%package -n libtasn1-%{somajor} +Summary: ASN.1 parsing library +Group: System/Libraries +Requires: %{name} >= %{version} + +%description -n libtasn1-%{somajor} +This is the ASN.1 library used by GNUTLS. More up to date information +can be found at http://www.gnu.org/software/gnutls and +http://www.gnutls.org + +%package devel +Summary: Development files for the ASN.1 parsing library +Group: Development/Libraries/C and C++ +Requires: libtasn1-%{somajor} = %{version} + +%description devel +This is the ASN.1 library used by GNUTLS. More up to date information +can be found at http://www.gnu.org/software/gnutls and +http://www.gnutls.org + +%prep +%setup -q +%patch0 -p1 +%patch1 -p1 + +%build +%configure --disable-static +make %{?_smp_mflags} V=1 + +%install +%make_install +find %{buildroot} -type f -name "*.la" -delete -print + +%check +make %{?_smp_mflags} check + +%post +%install_info --info-dir=%{_infodir} %{_infodir}/%{name}.info.gz + +%preun +%install_info_delete --info-dir=%{_infodir} %{_infodir}/%{name}.info.gz + +%post -n libtasn1-%{somajor} -p /sbin/ldconfig +%postun -n libtasn1-%{somajor} -p /sbin/ldconfig + +%files +%defattr(-, root, root) +%license COPYING.LIB +%doc NEWS README THANKS +%{_bindir}/* +%{_mandir}/man1/*.1%{ext_man} +%{_infodir}/*.info%{ext_info} + +%files -n libtasn1-%{somajor} +%defattr(-, root, root) +%{_libdir}/*.so.%{somajor}* + +%files devel +%defattr(-, root, root) +%{_includedir}/*.h +%{_libdir}/*.so +%{_libdir}/pkgconfig/libtasn1.pc +%{_mandir}/man3/*.3%{ext_man} + +%changelog