commit b81431b8949e095446d1e9d55bbde5e3b4f7578e14f167521f68b14ffb123e8c Author: Adrian Schröter Date: Fri May 3 15:01:18 2024 +0200 Sync from SUSE:SLFO:Main libgsasl revision 7f2a519130867e0da4aff4008fb033eb diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/0001-Fix-build-issues-with-GCC-12-s-Werror-address.patch b/0001-Fix-build-issues-with-GCC-12-s-Werror-address.patch new file mode 100644 index 0000000..d988e96 --- /dev/null +++ b/0001-Fix-build-issues-with-GCC-12-s-Werror-address.patch @@ -0,0 +1,64 @@ +From 27fbb4c1d6315e404b547dd9b50bdecc41a07eb5 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dirk=20M=C3=BCller?= +Date: Fri, 28 Jan 2022 20:47:37 +0100 +Subject: [PATCH] Fix build issues with GCC 12's -Werror=address +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +GCC 12 is able to detect that if(foo) when foo is a char foo[] +is always true, and hence errors out: + + printerc:336:7: error: the comparison will always evaluate as 'true' + for the address of 'response' will never be NULL + 336 | if (r->response) + | ^ + In file included from printer.h:27, + from printer.c:28: + tokens.h:139:8: note: 'response' declared here + 139 | char response[DIGEST_MD5_RESPONSE_LENGTH + 1]; + | ^~~~~~~~ + +We can just remove those conditions. + +Signed-off-by: Dirk Müller +--- + lib/digest-md5/printer.c | 11 +++++------ + lib/digest-md5/validate.c | 3 --- + 2 files changed, 5 insertions(+), 9 deletions(-) + +--- a/digest-md5/printer.c ++++ b/digest-md5/printer.c +@@ -333,12 +333,11 @@ digest_md5_print_response (digest_md5_response * r) + return NULL; + } + +- if (r->response) +- if (comma_append (&out, "response", r->response, 0) < 0) +- { +- free (out); +- return NULL; +- } ++ if (comma_append (&out, "response", r->response, 0) < 0) ++ { ++ free (out); ++ return NULL; ++ } + + if (r->clientmaxbuf) + { +--- a/digest-md5/validate.c ++++ b/digest-md5/validate.c +@@ -102,9 +102,6 @@ digest_md5_validate_response (digest_md5_response * r) + int + digest_md5_validate_finish (digest_md5_finish * f) + { +- if (!f->rspauth) +- return -1; +- + /* A string of 32 hex digits */ + if (strlen (f->rspauth) != DIGEST_MD5_RESPONSE_LENGTH) + return -1; +-- +2.34.1 + diff --git a/boundary-check-CVE-2022-2469.patch b/boundary-check-CVE-2022-2469.patch new file mode 100644 index 0000000..8a226c3 --- /dev/null +++ b/boundary-check-CVE-2022-2469.patch @@ -0,0 +1,26 @@ +From 796e4197f696261c1f872d7576371232330bcc30 Mon Sep 17 00:00:00 2001 +From: Simon Josefsson +Date: Fri, 15 Jul 2022 16:23:58 +0200 +Subject: [PATCH] GSSAPI server: Boundary check gss_wrap token (read OOB). + +--- + lib/gssapi/server.c | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/lib/gssapi/server.c b/lib/gssapi/server.c +index 5410360b..4ebfda47 100644 +--- a/lib/gssapi/server.c ++++ b/lib/gssapi/server.c +@@ -218,6 +218,9 @@ _gsasl_gssapi_server_step (Gsasl_session * sctx, + FALSE, and responds with the generated output_message. The + client can then consider the server authenticated. */ + ++ if (bufdesc2.length < 4) ++ return GSASL_AUTHENTICATION_ERROR; ++ + if ((((char *) bufdesc2.value)[0] & GSASL_QOP_AUTH) == 0) + { + /* Integrity or privacy unsupported */ +-- +GitLab + diff --git a/build-fix-old-gcc.patch b/build-fix-old-gcc.patch new file mode 100644 index 0000000..4ab3d45 --- /dev/null +++ b/build-fix-old-gcc.patch @@ -0,0 +1,39 @@ +From fde722a4036cba8d7bdf72f50e159e543e54a8c4 Mon Sep 17 00:00:00 2001 +From: Simon Josefsson +Date: Sun, 24 Oct 2021 18:31:48 +0200 +Subject: [PATCH] cicd: Fix builds. + +--- + .gitlab-ci.yml | 2 +- + lib/src/mechtools.c | 13 ++++++------- + 2 files changed, 7 insertions(+), 8 deletions(-) + +--- a/src/mechtools.c ++++ b/src/mechtools.c +@@ -225,17 +225,16 @@ _gsasl_gs2_generate_header (bool nonstd, char cbflag, + void + _gsasl_hex_encode (const char *in, size_t inlen, char *out) + { +- size_t i; +- const char *p = in; ++ static const char trans[] = "0123456789abcdef"; + +- for (i = 0; i < 2 * inlen;) ++ while (inlen--) + { +- unsigned char c = *p++; +- out[i++] = "0123456789abcdef"[c >> 4]; +- out[i++] = "0123456789abcdef"[c & 0x0f]; ++ unsigned char c = *in++; ++ *out++ = trans[(c >> 4) & 0xf]; ++ *out++ = trans[c & 0xf]; + } + +- out[i] = '\0'; ++ *out = '\0'; + } + + static char +-- +GitLab + diff --git a/libgsasl-1.10.0.tar.gz b/libgsasl-1.10.0.tar.gz new file mode 100644 index 0000000..db23605 --- /dev/null +++ b/libgsasl-1.10.0.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f1b553384dedbd87478449775546a358d6f5140c15cccc8fb574136fdc77329f +size 1854755 diff --git a/libgsasl-1.10.0.tar.gz.sig b/libgsasl-1.10.0.tar.gz.sig new file mode 100644 index 0000000..8befeef --- /dev/null +++ b/libgsasl-1.10.0.tar.gz.sig @@ -0,0 +1,11 @@ +-----BEGIN PGP SIGNATURE----- + +iQEzBAABCgAdFiEEmUFc4ZBdDlWp+IAmhgt/uzL4EZ0FAl/vVXoACgkQhgt/uzL4 +EZ0JnAf7B8ZYYVpI9ER+LS9TfiD4TCv91YlfwH1oMRUpF4X3/llCj7HpBIXuVKqk +FzGxE9SIluJxAGxQdrwFV6TPM2eUsNmg8YJyKMurCKn/vGkEAAzPxt8Gp6K6eYp7 +NrLaz9SBDXlhyw3Z2A/r8P0LniNA2y2FgXxxGehD66d/C0HGqJkT1MXBwCF5krlS +tKXjFXrXHzzmZcWA9oDmKBgQoqBUoSBnd57zIGvymw8oPkaTZok4b8F8Yi826SVW +AXsqLxdVdFw4ZrBtIv1hxyKWWqERua7wjEaQbRf62qX8niS40OpYSbjxX1W7dep3 +DyGXFAj8ughMZ7auH3P4cvcazeUstA== +=kC/Q +-----END PGP SIGNATURE----- diff --git a/libgsasl.changes b/libgsasl.changes new file mode 100644 index 0000000..15b5549 --- /dev/null +++ b/libgsasl.changes @@ -0,0 +1,268 @@ +------------------------------------------------------------------- +Tue May 30 09:21:12 UTC 2023 - Adam Majer + +- Remove URLs from keyring and generated patch as these can change + at whim of upstream servers. Keep the references in comments so + they are still references for the humans +- uninitialized_x.patch: fixes compilation on s390x + +------------------------------------------------------------------- +Tue Oct 25 08:36:11 UTC 2022 - Dirk Müller + +- refresh keyring + +------------------------------------------------------------------- +Tue Sep 27 14:43:58 UTC 2022 - Dirk Müller + +- add build-fix-old-gcc.patch for older dists + +------------------------------------------------------------------- +Mon Sep 12 09:45:33 UTC 2022 - Dirk Müller + +- add boundary-check-CVE-2022-2469.patch (bsc#1201715) +- avoid duplicate packaging of license + +------------------------------------------------------------------- +Mon Jan 31 18:54:07 UTC 2022 - Dirk Müller + +- add 0001-Fix-build-issues-with-GCC-12-s-Werror-address.patch + +------------------------------------------------------------------- +Sat Jan 2 18:41:56 UTC 2021 - Andreas Stieger + +- update to 1.10.0: + * SCRAM-SHA-256 and SCRAM-SHA-256-PLUS (RFC 7677) + * New SCRAM crypto helper APIs + * SCRAM server: Support for password-less usage + * SCRAM: Sets SCRAM_ITER/SCRAM_SALT/SCRAM_SALTED_PASSWORD + * SCRAM, GS2, and GSSAPI no longer retrieve the TLS channel + binding data (property GSASL_CB_TLS_UNIQUE) during + gsasl_client_start() or gsasl_server_start() + * A number of legacy and less secure interfaces deprecated + * New APIs for hex encoding/decoding +- add upstream signing key and validate source signature +- refresh spec file +- build with all warnings and treat them as errors + +------------------------------------------------------------------- +Fri Mar 13 22:31:19 UTC 2020 - David Mulder + +- Re-enable GSSAPI by explicitly choosing mit kerberos. + +------------------------------------------------------------------- +Tue Feb 4 23:07:18 UTC 2020 - Bjørn Lie + +- Update to version 1.8.1: + * gsasl: IMAP client code now permits empty SASL tokens prefixed + with '+'. Normally servers should send '+ '. Buggy servers + include Microsoft Exchange. + * GSSAPI client: + - Now retrieves GSASL_AUTHZID for authorization identity. + - Can now transmit an empty/missing authorization identity. + - See lib/NEWS for more information. + * Build fixes: Update of gnulib, including how it is + bootstrapped. + * Updated translations. +- Run spec-cleaner, modernize spec. +- No longer recommend -lang: supplements are in use. + +------------------------------------------------------------------- +Mon Apr 4 14:22:22 CEST 2016 - kukuk@suse.de + +- Remove unused buildrequires for libgssglue-devel + +------------------------------------------------------------------- +Tue Oct 27 14:44:53 UTC 2015 - meissner@suse.com + +- run "make check" + +------------------------------------------------------------------- +Sun Feb 8 23:38:09 UTC 2015 - p.drouand@gmail.com + +- Update to version 1.8.0 + * SAML20 support following RFC 6595. + * OPENID20 support following RFC 6616. + * Various cleanups, portability and other bug fixes. + See the NEWS entries during the 1.7.x branch for details +- Use %lang_package macro instead of manually defined -lang package +- Remove libgsasl-stdio.h.patch; fixed +- Remove fix-arm.patch; fixed +- Use download Url as source + +------------------------------------------------------------------- +Thu May 2 04:59:03 UTC 2013 - jengelh@inai.de + +- "Recommends" is not understood by RHEL6ish + +------------------------------------------------------------------- +Thu Mar 21 08:45:52 UTC 2013 - dmueller@suse.com + +- fix build on aarch64 by applying fix-arm.patch + +------------------------------------------------------------------- +Mon Feb 11 13:54:19 UTC 2013 - aj@suse.com + +- Change lang package Requires to Recommends since it is not + mandatory at runtime. + +------------------------------------------------------------------- +Thu Aug 16 21:34:34 UTC 2012 - agraf@suse.com + +- fix-arm.patch: Add hack to fix compiling on ARM + +------------------------------------------------------------------- +Mon Aug 13 08:54:08 UTC 2012 - cfarrell@suse.com + +- license update: LGPL-2.1+ and GPL-3.0+ + contains numerous GPL-3.0+ licensed test files + +------------------------------------------------------------------- +Sat Aug 11 13:44:34 UTC 2012 - jengelh@inai.de + +- Have package compile on RHEL6ish. + +------------------------------------------------------------------- +Fri Jul 27 08:14:09 UTC 2012 - aj@suse.de + +- Fix build with missing gets declaration (glibc 2.16) + +------------------------------------------------------------------- +Sun Mar 25 00:49:09 UTC 2012 - jengelh@medozas.de + +- Enable building against libntlm (now that it exists in factory) + +------------------------------------------------------------------- +Sun Mar 25 00:14:56 UTC 2012 - jengelh@medozas.de + +- Parallel build with %_smp_mflags; strip redundant spec sections + +------------------------------------------------------------------- +Fri Jul 8 01:31:06 CEST 2011 - vuntz@opensuse.org + +- Stop using source service to download the tarball, as Factory + will move away from this. + +------------------------------------------------------------------- +Fri May 27 17:40:04 CEST 2011 - vuntz@opensuse.org + +- Update to version 1.6.1: + + Add a Libs.private to libgsasl.pc. + + Updated translations. + +------------------------------------------------------------------- +Fri Apr 29 18:33:05 UTC 2011 - dimstar@opensuse.org + +- Update to version 1.6.0: + + SCRAM: General fixes and support for SCRAM-SHA-1-PLUS with + channel bindings. + + GS2-KRB5: New mechanism GS2 with support for Kerberos V5. + + GSSAPI/GS2-KRB5: Support for MIT Kerberos for Windows GSS-API + library. + + DIGEST-MD5: The server code now returns GSASL_OK after the + final token. + + Added property for tls-unique channel binding. + + No longer require the same or newer libgcrypt it was built + with. + + Several doc improvements. + + Update gnulib files. +- Use source services: download_url, recompress and set_Version. + +------------------------------------------------------------------- +Thu Mar 25 17:32:27 CET 2010 - vuntz@opensuse.org + +- Update to version 1.4.4: + + SCRAM: Fix build error on platforms without strnlen. +- Changes from version 1.4.3: + + SCRAM: Don't read out of bounds when parsing tokens. + +------------------------------------------------------------------- +Tue Mar 16 15:50:19 CET 2010 - dimstar@opensuse.org + +- Update to version 1.4.2: + + SCRAM: Encode and decode username/authzid properly. Before any + username/authzid that contained '=' or ',' would not work. + + Fix typo in error message for + GSASL_GSSAPI_ACCEPT_SEC_CONTEXT_ERROR. + + Updated translations. + +------------------------------------------------------------------- +Wed Feb 17 11:57:31 CET 2010 - dimstar@opensuse.org + +- Update to version 1.4.1: + + gsasl: Improve application data throughput + + Improve MinGW builds + + Updated translations. + +------------------------------------------------------------------- +Wed Dec 2 01:09:19 CET 2009 - vuntz@opensuse.org + +- Update to version 1.4.0: + + Fix Visual Studio project files to work with SCRAM. + + Properly increment libtool version to reflect newly added ABIs. + This was accidentally forgotten in the last release. + + Export gsasl_sha1 and gsasl_hmac_sha1 in linker version script. + This was accidentally forgotten in the last release. + + Fix crash in SCRAM-SHA-1 client when the application provides a + value for GSASL_SCRAM_SALTED_PASSWORD. + + Fix detection of libgcrypt during builds. + + Updated translations. ++ Add libgcrypt-devel BuildRequires. + +------------------------------------------------------------------- +Fri Nov 13 17:38:06 CET 2009 - vuntz@opensuse.org + +- Update to version 1.3: + + libgsasl: Implement SCRAM-SHA-1. + New properties are GSASL_SCRAM_ITER, GSASL_SCRAM_SALT, + andGSASL_SCRAM_SALTED_PASSWORD. + + libgsasl: Add helper APIs for SHA-1 and HMAC-SHA-1. + New functions are gsasl_sha1 and gsasl_hmac_sha1. + +------------------------------------------------------------------- +Sun Jun 14 04:07:09 CEST 2009 - vuntz@novell.com + +- Update to version 1.2: + + The library needs at most around 250 bytes of stack frame size. + This is useful for embedded platforms with limited amount of + RAM. + + Obsolete gsasl_md5pwd_get_password rewritten to use modern API. + + Include a copy of the GPLv3 license in the archive. Some parts, + such as the gnulib self-tests, are licensed under the GPLv3. + The library remains licensed under LGPLv2.1+ though. +- Package COPYING.LIB instead of COPYING: there's no GPLv3 file in + the built package (the GPLv3 files are only in the tarball). + +------------------------------------------------------------------- +Wed Jun 10 17:21:15 CEST 2009 - dmueller@suse.de + +- Add Requires for lang package to libgsasl7. + +------------------------------------------------------------------- +Thu May 7 03:43:32 CEST 2009 - vuntz@novell.com + +- Review package. +- Update to version 1.1: + + DIGEST-MD5 client: Add support for client integrity layer. + + DIGEST-MD5: Decoding of integrity protected sessions now works + better. + + libgsasl: Add new property GSASL_QOPS. + + libgsasl: Add new property GSASL_QOP. + + DIGEST-MD5 client: Now queries application for QOP value + + DIGEST-MD5 server: Now queries application for QOP values. + + DIGEST-MD5 server: No longer advertises support for integrity + by default. + + libgsasl: Added C pre-processor expressions for version + handling. + + libgsasl: Use a LD version script on platforms where it is + supported. + + libgsasl: Compiled with -fvisibility=hidden by default if + supported. +- Remove unneeded libxml2-devel BuildRequires. +- Add a note about libntlm that doesn't exist in openSUSE. +- Do not make libgsasl7 Provide/Obsolete libgsasl. + +------------------------------------------------------------------- +Mon Mar 16 09:16:40 CET 2009 - novell@mirell.de + +- initial SUSE package + diff --git a/libgsasl.keyring b/libgsasl.keyring new file mode 100644 index 0000000..b2e85fb --- /dev/null +++ b/libgsasl.keyring @@ -0,0 +1,1314 @@ +pub rsa3744 2014-06-22 [SC] [expires: 2023-09-19] + 9AA9 BDB1 1BB1 B99A 2128 5A33 0664 A769 5426 5E8C +uid [ultimate] Simon Josefsson +uid [ultimate] Simon Josefsson +sub rsa2048 2014-06-22 [S] [expires: 2023-09-19] +sub rsa2048 2014-06-22 [E] [expires: 2023-09-19] +sub rsa2048 2014-06-22 [A] [expires: 2023-09-19] + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQHhBFOnKoEBDqCoGZ7KIeZI1cbNFHIVxywetihLsA24nv3bJa/kd7kgkjfxdlcl +JNlJZPbQIttl4HE7M+mxPUVtvlJeIggI2xd6uyv/XrM9Wdy48hskNHX5umZ55yIP +C+T1VYXIJYhFFJgTaahtfCrf6/gQKnC0TNhYiWw4GP33S1UgVTz5IBEr85W/QmN/ +iUtM75wyq12ntRR+LSxSEmnEF5pzoP5SgVUXdAZAJQVvLcu8L9opAdHj4C3IcvvS +HKvp4h2zvnOwRwjjiObKxRTtNaxHO8Sfofxw5aiifL39bxAKuJl6Rrhd09xKIvqb +qu/m8GqWiSyO6N8tTDgxBKGfgba3D1AQ+J+VkFj31Obm3R3GEpFRo1i1mQLgKqbq +Gs0aoZqVMkP3fItzkw+pOuldgL4P94IoXJsWjt0x7F0ojX0CWYbQ9rYHrBCe01Mn +Rgn6j8glZj6hQs7sSMW5eGA0HNew6g0WEYGC2IsDQV2rGpsLnbx7r9P/qIA+q42o +VjxxNMaa6WXfQf6eBiOSYa/9HsophhdK4+eJOoD/n85Vb4qvT0yEjQQurfBnbGte +bIsakyX+eLpfwD6RpDAe7irZaBSOBKWdKOlbCdIezblK8JuSJS/LLMAfPVsasgMA +EQEAAbQlU2ltb24gSm9zZWZzc29uIDxzaW1vbkBqb3NlZnNzb24ub3JnPokCKAQT +AQoAPgIbAwgLCQgHDQwLCgUVCgkICwIeAQIXgAIZARYhBJqpvbEbsbmaIShaMwZk +p2lUJl6MBQJg98BYBQkO3BfXAAoJEAZkp2lUJl6MvOAOnjLtGVPsmM1RgitDvSGd +nzB2m6/rIxgfOMwbV4TZnVTspFV+rsjuQR5rtZvzkRG3ux7eoUpaexGNTzlO1SR/ +I9GVR4/eE5d7NuGXnEHINV3ecEeCYpY0PLivrOHIxkLl8/eMjpWs7qttu6+rNJBg +YxiDnGryjbh5nhh/4fRp/IclNIMUIr+YMrsW4BIVM3xG1/2w/2nGFiic8l1LghIe +ne2CXgM41RmQLQk88cAcGInZWDt1wwdz4maoeg89B59bzQawktT0ttWI4pvbGEoX +qOUw+FU461noFt3u1AXAPS+KzWIhP2sIRCSOtjkKuL0sfPLTWJ88Wfj8KLVCq+wX +Tjf7L85cFkX+FjcpUcU11bD98zCzMfU7s/IQM4ntwGGkBCGZtX5+UlfnJYzgGDTX +hl4/XUUHcCNALbRFV51cZKR8v/Vu/MyVFxbhqKEXq07+NY6Elmj3nwh0Sc+K6Scr +u5HWEcM9aPIwYf77ejDnDqZ7ATr7AxxOQGWQowyQLBvLSGtyat195mFBnL7qUJSR +r9lp9Q9Q/K0DHbAEpRQTwQ7pbO7Y/ZnxCAb1WbgOpai2pohE87HOyBrg0vkIiBSS +IsH7GlBtcqZhCJ/UesxhuRWo2+yzn4kCKAQTAQoAPgIbAwgLCQgHDQwLCgUVCgkI +CwIeAQIXgAIZARYhBJqpvbEbsbmaIShaMwZkp2lUJl6MBQJf4ioPBQkNegqOAAoJ +EAZkp2lUJl6MRC4On0i5uhN+Z8goagxgzvhdEEl7o9uYDBvKSdR6PKbvPAAOWKfs ++/lpMLTp/6e5zTtrTWuIreVRnIaBdMHbBRa1d7v/eUPS1C+S7/hRFEFMlU+FGFxJ +do+G4sLhuWCC4VaJNwJrZ1l8vZ7vdplmsgZSm7y57KA9GbGWQdPD2I4IIzdbLXCB +w6zrgvPJnyXT9l9aePaaiwH/tPx9BiUL7mOWHmz8C+O9UBZ/7rXanibCQxmmwrC4 +4JrdrFQwsq5swYaIuF9JW/IfO4oNf52CjzZEwByKZZhWwpqWEneHZ0IoeDPeSV0X +JDnskN3EnblPc2hP65mNEPAGcN55G3Tuz/6JwX7KgzMZsb0vUYQhEZfbQhgXFxuK +zhT7BGGFKTyPShf/grRva/qBA5iQhEoXbKfUq4w9M3vJpnTQZQWjVaA6Rodj8C6v +f4h/fhISlf0Pjod7hzzE8Eigdkx0PEVSAeg5RkDv05nI1rxFh/IOKNkbIIYqrO4r +KK4MQZO7BvMX3jasZ8hsgPtvAv1RRHALc+askWeqzfk2ixrTTxooFb60BfLd58l4 +LPwmmOhxOOMIGtpfJgrSp8XUo0IcqRpUrgDuFPGVKt65lz3+9+ckrU6fmZnPQuKu +XIkCKAQTAQoAPgIbAwgLCQgHDQwLCgUVCgkICwIeAQIXgAIZARYhBJqpvbEbsbma +IShaMwZkp2lUJl6MBQJeLD+iBQkMZkihAAoJEAZkp2lUJl6MxRUOn0at2D4/9sRA +j3Tr3CPGZVIs5BQNHEQnRO6moycty9IM3zEEnDe44ub3tP6kWS2Ke953RbuFybwZ +6SwxC13Lad97PBqjmF02QzGMjxDSwKYqoTtcKnuzSRPNxdo0GP4zyTbpXPrg5x1w +TUP9m7RI3cUYKmAF0UDkjBra8Kt8oILZJZLsk3PsFLToH28R2UwJC3x0zaYuTHbl +4XqyD0nV1VuJz8Z9xYTFiM5lMSS9RPnHoEJFw89B/zRRT5+Nq5gf1hgz45RymltC +4K4FvFheAwQR1MxvWxCbx0jMCHUfZYpcxW/bLgRy8PhQxF4GY35k2oCOi82Hi2Dm +ti8GYjhE6DkKRZu4fShoJ6hYs8yBaYvYOj8wDiVEscTHFz7eGsosF0qbI9eu09Yi +UUaMcpFnFWM/rE1k45+wuE9pq21nQSIxFPv9cQLyvLgQRb26uC8u7TRnd/NIUj2E +uLXfNLU6STQ/q8LVI7MbJ23WhlbUeHdYo+CpKs2hzNNFXfp82Skt6tn1hH0XCclY +wPoWUp8r2T6SoA7nmnTr136DpCTNtmnL+ZlskQv5B1oFWogVJ2z3RqN0Tt2Mmdld +nUN/uFYpbY5lnu3Hwou7Vb6de2L0ij9qsHY9fYkCKAQTAQoAPgIbAwgLCQgHDQwL +CgUVCgkICwIeAQIXgAIZARYhBJqpvbEbsbmaIShaMwZkp2lUJl6MBQJiOJ8XBQkP +rjiWAAoJEAZkp2lUJl6Mto8On0Og/zvmFiSMyrrPCkgGnnjJMybq48GVprHolY8/ +0dIfjMHVjOdCxXXEm5z2dmSjsbN2LiRc/nwxGwCuo2ghFE6AY6cKuMl6LC+KTsV5 +ltmOeU/LYXmWVuxlRqQ7/pRrrzScxVqQC8u5lFvrcYeT8RvSpUMuLqlenW4waX+y +Ssm5+27FDyWpZLWoiNyZk3L2mCXqHNpNKNIjt2ijmPdis9+/2zyQ8WDTl3GhEJh9 +fXnM5Y/g+saXFipcZnREtT2VoFI95qCJaD7dAmFYOMnFPDgJ/mmvaViAT3JPIkQ9 +TsPaD/viPM5lT7nJevPD0300icoyEllTWBKJe4h0P6rOPVSmoEjuVQclCYn18QL3 +azSi5qZ/CfNdyW51BX9xElmXAbPOwWLEsCUmZG5AKJoyBXDgZHX/TBV1QhuOFvIB +C/btcFjh2thJJQJqWh115hJDGNeC+WyYq9U/Rnf7xnIWKEBNC8Jcz/EyDgzMPPia +/MQ2BlhzH9PC2tz6tOEZEiZ+0IAb5v0WtMYNkLFkTdfyrvssYqjumVtluY3s82tI +ZplpN3BMElIoeV24y54AQwDjsPbp0nDZN1XIKZNSz4Xn0MZLgj0z8ojiQTIucTnz +KHj91I6IIIkCDgQTAQoAJAUCU6cqgQIbAwUJAIPWAAgLCQgHDQwLCgUVCgkICwIe +AQIXgAAKCRAGZKdpVCZejNwxDp0TZSAjEaif4pBT78Vv01AMYBdIxNu7JZ+GZtOW +7XxdgUAbcK8FoehqMMuipIKEuNlfiE8C40KEK/s/ToRd1sqe3cgsy22q4NGyOB8Z +Ocb1OQ0lmN1MSDgTFAmE3v3DMXaEP2e8EH2shT/5o2arZubLQJcmkMHOQ7F1qch/ +cRd2Boql0IyeNfRENoSqrl9cAnNvndcF5LnP12VwDbszm5kJl+sHt57+q1Oumj1Q +FRQ4BKES/JH/pghpu4UdC2IKFcF9k2TkcW5VNJjje7VmZZnhLE2k+L7x9a61V7ZF +cL7TVf8Zc41PkOX8a1z/qwpj2noHTssvb/K/rPL2SxxoDtyntz8sYJAKsfIW3ADT +VIeXcVtd8vdZT9zAqkK9HKzwhdwVoMyN4JO/IR3qiPpVinOrKb+cpLr3MiUrq/Zx +BulWOAFgKDSl/hXhMjqj/DbL10qw0/JkxGbVOefX4rNl8X6S5a0oJw5QcP5LAUSh +cxdVBRmfwyrnC9hVMOiHcNCcVDU9LoXFmckedeMOnh+D1QFgwVDiV7ShlqB7RD3V +HQp3VgV1DXOVurBx5h6wY/Q8afNm59xoWbu9AvcIbOApWOnASHVWkK50kaVqX5hR +gec2U330HPKJAigEEwEKAD4CGwMICwkIBw0MCwoFFQoJCAsCHgECF4ACGQEWIQSa +qb2xG7G5miEoWjMGZKdpVCZejAUCXgx8lgUJCqc9FQAKCRAGZKdpVCZejJvlDp9Q +nazgfQsDg5PJQFXFoapfh3u6NdR12KjXyhUTw1k8Bqpay150tksd2qmZnodbdS2Z +N49OHkVDZUw52V8dDiklHQQ+fidVn+e0aK3ihqNzoo2r9Qsof/KM+BMT3VmwGhpd +7ojA+AbT9v6bcW5ZiPEsybYsG4T0pu1bPrglF/qgyAuZs31V2ZumP4XIxeW7wD9m +yYbskR83ndUSZWnJtTGJnuA5HSHwCFK9mNZ2HnNA6LPA1Pabv6BupQiKpbe7AKI7 +uz8RMTfEH9AY+0zF3bX7wSr14HHGvNDpJr1FJmqDpxP3kOsepC1uZEcKegqPzs+S +sGMyRzEGIm0kA4DQIP5nutrPadnYMSl0BT0uERvHDMcrtFQq3IyxS/4YbJtp/CDE +T0Eyy6GNq17RWGBi3grjxKVt4NC/6egF0kUhGmXGpGfWC/idrKBja8ODhFgAosLx +jTgNxA34laSZztG2BqcBIIIuYaMz8K5ZCta60Vlrz6ok2NNb7acdb7oBD9buw2Z9 +hJVYP0MCee+IS9o16VSxBdmRZjP+0cgK2CQwkKYsd2w0oCusl+r25/vVb/93BJT5 +0pwi+bEcQQems4W6AwT35gshiCqZN4XJljDo1JCmCVoVF1SJAigEEwEKAD4CGwMI +CwkIBw0MCwoFFQoJCAsCHgECF4ACGQEWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUC +XIDUPAUJCfZtuwAKCRAGZKdpVCZejAc8DqCLR/0AOvOPvoBlyc3JsHb6HE8fYY7c +FbRB/2LiQjFDhCHX/CYKbOFGlI0gYnJT+EjjxHxG3EZORCRBN/s8xh8V0NcUFa50 +ifXIRcWKOHV8XYgqJc6b6O/jDemy7rqKdnzeGEiZZHa1GcNnbNwiyRIF7kaaDxhd +n8R921L4qw6SUnYFCPw5YNZUUiB3qXdQnuEHXFZ3Sl+brNK+sRQ4F9ZIOsATrPRn +40e/DxfIUkuReXbWqULWQQibc4vFKAbPTpj/7DpZ7H9ULzuQtIBs9ArDPAAGQoRk +kbuL7Bggj6CawgBMJ3fa6qX40ByGJnvpwZlYwfjHy4UvqGeMCJc2IhlCCBVpGbqz +KV0BSgvfSUKdJYONrqo0gVhC4WSeK5XZFqHeWE88g870bS39/L2oJP4JZtrlqUhp +oKgvRDaIS/6K4t9XUDlftPBV7AF72SGQSjl6CsQwnPxuDuJwIh/xJZwKN8tzGjkC +0EvR5zKF4alfhCV54PT+1gsvYGovQmN4L5OSdBS68touSbvWoTz9IsJdKBqrHh0N +o4DMgAhlBDc2+EoI1s8uK+48l6xvO7MCiyfAwzxOdnJcEHU7Cdqp5aZL1GV2ak5/ +zJyGOina9jZAKNeszXeJAigEEwEKAD4CGwMICwkIBw0MCwoFFQoJCAsCHgECF4AC +GQEWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCW2LVNQUJCNhutAAKCRAGZKdpVCZe +jK9SDqCoAixaNMoB8gmLNsSbrNA2HP7ySg2g/7r4PKq3pHtwlHEB6pG3ghLN0Rjs +pI9Xjnl463ZjMIXmOcFcRoFCumoOJ879vYBIa1pL2rdaNU+msgPPdtViW/UKtuAf +kh1Ys77NvsZWNLzOyLfpL61few8Yu+kwGQvP0G6GX6F1UE0hnf6I+ER/1GZlesa4 +WpTaBtkGIo5I5BL3jJgHMmZGwtXDAvcL0OuxY0NOhQ4TfY6CHYR6A31m581PgPuF +0Xef4XlUhk4gbYX+WdLOXAE0d4D6X+mkHFNiqQU3c+LNDNvW2NdsBZm/qi8LlGT+ +iMKjmFoTkHCDiHGBQxLKqPJO5l1geoz1MLiZRhPamtl8XakBHnTJhi+PnhAYu91n +8NySCCOC1nDv+QztKccj8zOU/K9QpCXcNxHXYnJ3epynkt48zkJtmf451fcGUiHq +9gbjwLCtA7ziTPl+2yigZB9NiqveTl3m3fpIWqQrH2DnO7ygztxjs4VmavA5jQ0O +vgyFDW/RyDdLZ86fxeHthS8viWYq8SXws8r1XxmTZRUz1HPVOLaMD6BFt8gLp+E/ +kHBFTAjvQZXOeBedYmd5G8K+3EfEnzSMymafWq4GFgCFPRjCZToLw4eJAigEEwEK +AD4CGwMICwkIBw0MCwoFFQoJCAsCHgECF4ACGQEWIQSaqb2xG7G5miEoWjMGZKdp +VCZejAUCWpO5XQUJB+cL3AAKCRAGZKdpVCZejOyfDp4yqBY0XU9+3qJ3N2s7x7n9 +/bXAhb3XFJHFoOBUO7zMNAFLTjdWnhfDjmO0oitt+53D/fDOb2aHsVAnkWiUO067 +zAv1kKoDDaLCIZsp/gDUp0ifv5AibLZ0+c6hF9k7diqszIZd4A1dB2ebTxhUFcZ+ +TjrhmuBxTxIUyo5FluJhx51WjPLS3a2zZRLkRajYPlWtoqGCvWKh8XDdSf97Z6ok +ayaZlWiBYG+ssAm/2lE9ioCG8vFqz8iGqvXiLDH/ezl23RoGPQZcdD9cNNHlmK6/ +ChpKuLOMo87IlENxpTChaiVFD8jObGqwgyLmqQEK1wxD95kLyyoFabQtWVdMHiqN +yBf9xPb/J6E2PghJGsxvrwwggS4JSLe5yDGJX2ALyKEhqNdjrqO+OSVs0x2Y7RmJ +hGAtgHTY0Cu0HUvm2ys7h5DeYU2tuZ5xIZ/q11T3rW7BPeidE5XIPIDnnzPVQV8o +hT5Q1RSAmEEEykIBKzYZA03H8i7XN4MonkACnbgXOS3Q4GBv7CsuXzgJ3iORc/2C +SUNaGxqW8KeGJC6O94/oEIuZkiNUPWtOG1/xjWEPMaFVddXZXDXEjNUx+ffx2vIB +MwfaBI93tBxp4O1dC/BgIxhizaSJAiUEEwEKADsCGwMICwkIBw0MCwoFFQoJCAsC +HgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCWaRxfAUJBuqU+wAKCRAGZKdp +VCZejJuZDp9ADBlt8giRkWS/vrILbGBoGtYAnK1nG+P50p3Dyrckhykpi1i/a5UH +76PVq/7h5A4Aj5tI/kUyOxIDINGKfPRzUqxitea+fe/yw62nxcdeDdNHqx/fC4/C +gIUdul9MzC7+pY0zkjInYJvLziw+ySmf04OPkLRWO6x9TY2jFcYGUgjDRHIKWEGJ +LxiNLf/7aDDlSJiavUo0CWur2jK2XniptHm4hlWAJD+pu8qba55jhIMNnle8BtBQ +6evdQ913PAMmXJz3jZZr2Nya7wYddYHzE35TSpV2oz2q05Onmt2jErlAAG8rIOOr +ZpXQaxkdfqCPYhPjnSnBL0SClE22WCbrRlime6rCNk/ZCCSLBLfrmcIcyWkra+RP +0mULS7xW80ER1p1BLk4tPArhEgbJUsTsd5ZW4oED1GMWx9LAZjI2xTEpVVu2vKrI +KN50GXY/ZAVGY0B+MasZgPMwD4CtewXZ4JBJUFE/EXAu0QeCVxxaeMKTRUXXL1uh +9eCKtzgMWh5C08VXZSwkc7dmvQGqpC3YiwBw+WE6SHalMJ6L7mhrhnzXgh0x6gbL +s+cNoysLJk5fCKrXKkhzNjJxfm71w17KHovDjeGAxa1/ejPN08+aECRyYSOJAhEE +EwEKACcCGwMICwkIBw0MCwoFFQoJCAsCHgECF4ACGQEFAliIWvEFCQYF3WkACgkQ +BmSnaVQmXowIrg6fbE4ILfOAyZYqvZgin02HueKgnqh8bqA9yxyY1UqP2gTStdSs +qZUkstus5hLl7TnYHTlbcMXC82QcFOj7dzOehiXoVijJ2XIuXgu/9XZAn1Bljs8a +a92l35cawDG8r9wGePv3bqvuMz3rY73oDUYGXXesOuYLoDDg9eEFYAqRt3z3smxZ +9T+1VAzb0kNffEVjtv5h1pcRFynNKvR+gjXXk6Nr37Jb8cg2WNVn5CuVqUx/5let +6XHFAHmn9ykeq1tGshkaynfx8XtM8J4nfN6m9j1tDWWWCqhis5ZtAMY07+/V60Pb +Fnjz/yf4CHcqScVi3s2KaJX0TXaLlUIxbw+AyRP4CYLVYxJEb/F/dMNYqnY+OJxy +nLY+4JAe+qZzEX1Z7n5oP/p7UAJCeAgmGUW94/W1fZk7da72JeC43E4n2p6B0YOC +HlM96dt+ERaJkF9w2EoZsd6UhXBQDzF2R/X7+QyBtkdocGB5fcgLgzbQ3R3XRHG5 +uOMbF1ulnkGjIO6mw5Lv6absOJrz4pcr2SovgKQZsSaKjGrcaA22WJLGURoKTUfM +PZCrK6APFMGbS6EIoexkD2XCsFrma3jtEaxGT0cQnLBBhGQdJJI4DBAcg0XyWZqd +iQIRBBMBCgAnAhsDCAsJCAcNDAsKBRUKCQgLAh4BAheAAhkBBQJXrBUoBQkFDJan +AAoJEAZkp2lUJl6M9KkOnRCFBoam39kVP5k7fXmo+id99h9O2I/OZMdJw+bYPIyL +GWSIY/5DllVoPL9YiB/YevWxxghsx04PH9PDe06/Q7WKTXUzCwNMgRoA4cCNSoZz +ltU5ud+MD+75NyXMX8PeWW1QnkD0DbKZv80RTtonk4qU/0m5TIq6WDLN3QFe1FHt +uqpQ6goSFg0rm+dZEGLJkz/NnnEGoiNN/KixDA7aBQV89rJF2AQhSBiJya2w7eHV +NxY6gl7aKjkzuXloBRooXcqRNGMbHgjh13AiC6d0Xqb5JP9KexdhEXU60me89BoP +qHvslX+OkiGhmZEimJlOU9D3BVhYg75QVOG14zgeHcxbFkyReNzcRN45DuTYlcph +PqX1e4YaHzPXFyoOl+jRhyaTeuf6dpDQvgNgoAzta2AmZvD2joH1Ykev9k08nMrD +2bUj0W9AbOdg0wS/cFA8FaFryfoz1VqFd8nw/JqCNGQMZ6yf378+d8uUSrxRs8G/ +iEJHu8GaOC5pIOd+5jqvzoNoLAFBwzvr9UHU0HiXAxApLprSBlF3ri7PON+wmBI4 +ZqETufLU7AT0m7yPkI6v9mkEbRTyGWcz0VMnmv/vLKm0t/Lw+1jAwcNxi5nZ62BS +FQHtFYkCEQQTAQoAJwIbAwgLCQgHDQwLCgUVCgkICwIeAQIXgAIZAQUCVwz8egUJ +BFMf9gAKCRAGZKdpVCZejMbWDp4+U/wYHmS86XI+e9iljV4SDfe4ZjmctLWqGOWt +Yui169CSQyYOxRJumElGB5K/Ir5cErfJ4E8g+yP2aa8z8cSkrlekcahCf0zPVsM4 ++3lSrj7wNfQP3BPcAym/OoSVDDbvpVHGPZ3zkQHkb1to1JOW90bS24RaUHCGbLaC +xNG7vRQc0nhWFCgtnPfCbQ7+DOAbJqZ3XyjMnVKENHSJmLsXxaAbR9SMA1LZ4AYs +ulpulR/0lG+ox3+VORygmNJqaatGx2bWZCFS3WgwIAp3dlVmxuwb/FJQ6S4rqwY5 +k5esZzj3/S4OioNzIkATUmEDiI/TvvBu87vQSINCgyZuTUWI4Vu8pET87vcPZJ4J +IwSSWKFshgQx0bkgoPSNTfeK1JkAAuArxyxnxlUstzbQ/UKwXpJ92eamMWRnPZfx +Vv/a2lUVpuXuGoXEnSGr0uRMpsw0uLvW67f1CgEQYTao2V1uevwH1dEh0PveGIaH +dHg8X/SGo5eb3mKMPn2S0TuNrPrMTkd4B2EGG6A1nE4/ajKs1r4zLjwFj6f6muP2 +16Ht7KuLhpXMOahV7gBSsdxRRsyYUdtwzBi5pSTrE6EZahlNWc1NyjFlGKBCgx8w +hUyw9pRAeWaJAhEEEwEKACcCGwMICwkIBw0MCwoFFQoJCAsCHgECF4ACGQEFAlXM +ZL8FCQNkRT4ACgkQBmSnaVQmXozodw6eNQpIo5HT4ovZqKjP7WLbTCzzmR8u3cpr +JKllCG7oF4Y0zzm2De2C5bLIVzyJUtyfjTMyE1SKYXZ5XL02q3s0+l2j4uh6ZY6p +iMorN3aWpOby4x9qZEURQkq+WBSWXJ34VQoKZ735ABunsfM0ffXncOBcqvnrS98W +8T3f1Mz7pZ1GLRR6uBbd2DXqnwWlJ5/wefUOydL4KtHyBBTFAtr+SBBYSVMV02u2 +ve17f5TiiI/9KVjFN55g4E3PrtrDceJpdBKeCG4bK86rgWTa4KQAAk3CPi6RURJY +xd+bray467bT58hG2URElFZPfEzMLkcOFd6X5PNj+LqLPe1QKfZZqfMfJhmd02rZ +Fql5a3Enyg6hc7aGC8vMEZxXC94ksaQL2DGrSKXkjO2idUPaw5LDmZZqlr/xcO9G +XBSlgKmSZCPUJ2Y4vGk3d70kUL9sQ0hFB9KEnxEjqoQaxlO/SRn+r1KGpHNn3FYR +X8Oy7UAoC9dfJ2AFTP5xo9Zk58cQX9MtSInjjcImHHNdOelgyEl2zmv21OuZO735 +GgEcSYOLajWVg414cxJr/MY8o1ynGGqA90pt4XbtuJCvtQMYHIevEd94MzgL5gyO +cSQHO/Mlvgk5hNz4iQIRBBMBCgAnAhsDCAsJCAcNDAsKBRUKCQgLAh4BAheAAhkB +BQJUuCoZBQkCLcOYAAoJEAZkp2lUJl6MYc8On2RCKpEwtaXhcRXEIAbnHTHTMZfJ +r91qDn4vBg/IEYlDgRA/otv8w0+hdUHQEA476Y0Q0Usi/8JNs5rbGsNYYpFeXbaz +qicxZ3864UMF2Vm9Lv/Wrid5F+3igpM1+/kuChLa1GnA4dF978Ig2IXe/XkRXL0m +l8P7v5RP6dQhauWZoi05nFyNeenw3awefZIetvZRrBySfDtMEXeAxkXDd69BDksZ +vJKB1bpTvsH3E5N6fAVOTjpyWtw02KIT5vRubc7bRwO3rSGjfiCfUxo+BU7vXCyH +M2e/ffAB2mbZ3o62+7cXn/UkHAsEdjyiUw/0P3KGF1ZOSot80vsywxgzQzyMC4ti +5u6/a/qnmm69Um+Z2RKeQuvMN1GKRdZY4BxfkQf8ME9IyQCcZ/mjAQNO19LCIin0 +coUlOXJW9QDBR0S1Ci/OenZXXBoyarl/i42K0LLYI5M5+jrkLuEm1G0B7zB8Mcdt +32+TgK2XD57+rMnAVdqFi+A9edk/cSYBiNOJjI+MS9aAYOXYHDepRCQOrju2giMr +saJ6gAtG+5f8BiJT1zzpH0P/xS65GDEO4QaBDvT0RD5XX/SH4MdmIdAoieY+pbkM +8OCvS/1fawC7iYec1zcbXIkCEQQTAQoAJwIbAwgLCQgHDQwLCgUVCgkICwIeAQIX +gAIZAQUCU/yeHgUJARs0kwAKCRAGZKdpVCZejFyyDqCnZgMO3OoQ1N3f+dRMNzxY +KQRt55bNVWQ3l6GoHei0lH6t/361CMwB2XmBimXVWSkGZ2HJofN4uIoRZZ4ajyKU +sCtakSW9mdmIfhF6ANk90dmxZM+EY7d7R49SXLI3SJgfz7vJfNU/YjiqA2yciXse +IYtvDrBL0/J/m6sJMUEnFloSlVbqKO5czzNVjxf+bL1JmmvMDZMdB1/l+k1gn1af +dAz6plJ+gz9WXRpEgjS7pFd/kuN3AbQ6buIdmqOj8yEx3v7dERXRjpEYo7w99y4X +U6825PjMRGNvTRdVQ1AsBaS4KKs9/upqPfn5V2cbVaAeiQoapgkUlVxUCiRzusSM +PqtqDgDeYcB+5ZzvA9a6rbCGGecs1ts4I+yAlbEfQl8G7OFaUw5jS1dBTVpRNbN1 +Aq9INRRy8S2hl+a2V6eaNQ6D8bgjKHegJd4kp5BUtjnHHGB+Nd/cJDEo/sJpXj78 +B4Qdu3B4Oo2u22H6u5posquglEGbzjklE7wA8zV5HPad8WUxCn5woiumLhN/6PPN +EuZogSLTt/qMWZjwkf3wJ/nchOTtQVD4cK/zEhk6TogShcSAiMLMkAIPD7tFKNJ4 +Gj7VLyDTVvpsHtUpibK/KLwD34iJAhEEEwEKACcCGwMFCQCD1gAICwkIBw0MCwoF +FQoJCAsCHgECF4AFAlOnKyoCGQEACgkQBmSnaVQmXoy+jg6fQB4AtOLMVoSNSvOJ +hX0WVa4lVVA1JuCvcMXwg0it+j8jQi9k0QgmGGkKqgWbnCopf7UmycgP6sLpYE9D +/O2Kragg5PXXerypcGrdUIZHjuR0FTJlWM5OG0PezpsVhT1f4QhQhjo+waJfDASI +V5qgGS7llKuKSxI0FCQeSYt1zQcBxWmSRGio/U+2or/BB6TzV8KAsDINyw+9R/T/ +XmgklJlFVE7aVA3yNh5pej0q+AH3gAF8APx6UJkUAyaQ6dtpxF/d8ZB6ZrdwbXgu +yrhtE86K72n//vl6vn3Mj23LvpdwZnI7QzWrmYDNv+w2HgWwl65lBXFt3K8y30t9 +Z6Qo2V3rWBJwzo7tFqa34h2uRz5IDoaT/JqK9XnnIlqIpGbEeTm/DiCyK7Cd/Ir0 +b9IM4epVn/XrjGPN1eXUZqg5mxoqrtJsETI9Whkrz7JDVs9X358ywEfzktS8q+io +kkgUKguuHRDBFNntzu8JerbmV2uo6tXChz0ZH1MA/re+JXG70Cge4u9u6trtyVWb +mo0/p0bvl+SQ39Ph0Tve9AwZJT4arh5lJFTUVoi7WpqZuAA8Zr+4bdC10L1+wsSS +qZ1SFxDmK30cnEfU3+RaOp8SeMiNI0YviLwEEAECAAYFAlOnMqMACgkQ7aIelLVl +cW8otAT+MhlkilL6E84/8SVZDh+UOcTlPkimHsFo18MX/BoXyYlGFU18K6zi24ZS +J4xjRysBCTaMsD2nq3+2MZMf6b7jihiAgrpVzAcwO/0L08Yrxo5aQnbMk4EqBx92 +XFm1Ctak217jaV5RHA7amCyJQQGDRYHta1XKYe8ICVI5y05dTX+DVvcF3JBDzw4d +QpvWqe3G8jHN2sSMr/Ei6+UlCmJhUIhGBBARAgAGBQJVmqGwAAoJEOp785cBdWI+ +zkUAn3gQP3A0v9TNXgHkCZeZ2Gh0LPkVAKC03JDdB2dDxUXMjhkuJoDRw5BW8IhG +BBARCAAGBQJT7K3xAAoJEHgwLEuNv+wvTSYAoPKTz7hrGmH+Z6zSVX4cJYStLgGO +AKC/E2O4e+1qF8oHxRGoywEJd5yVzohGBBARCgAGBQJT2DVuAAoJEHIENnC95fHu +xoIAniSO6nS7dCXllU8GMyLDrF08KbJjAKCRxjEJOBX+9dIpxUZPThhW3R2NEIhG +BBIRAgAGBQJUzpP+AAoJEG7VFfsbKC6aiP4An0nCtgBgyVBcJbgO2/qbg3OMekEj +AKCWLSb2mimkEGDSr9upsezkIPH+moheBBARCAAGBQJU1kkDAAoJEJ8vqp7D6xHX +mqIA/0gnh9ezBKy2+CaI/ADRQzJua/mJ/Tgej+QONzHK2N/nAP9STUu19vhCHNzQ +WSfdcj1I6YES36IfgiHj2R41CF4/LohrBBARAgArBQJUuS67BYMB4oUAHhpodHRw +Oi8vd3d3LmNhY2VydC5vcmcvY3BzLnBocAAKCRDSuw0BZdD9WMReAJ0fV4TGVUb5 +83ZCRhn4ddDbD2UUQwCfXSiGb6+dSzoGkcA/UbdfcyM0FlKJARwEEAECAAYFAlTZ +ndIACgkQd+7fAxf1VpCcSwgAhQ0YgGLqdbxo71MfT+1+Kx6+SEDNvL5UmtSzATdf +ppbYI9h1P4kVxDpjQ/fHDlBsbR30sQ3diXKw3uJtWGi1z5xFtw1c0v5ACcbDQpMd +9yOiPBBWPc8c7dpFrrXRbKz99jtk5jTPIXSEVm41X2oWH+tZQ4IfpG4Z1z0cA5rg +PY9A7ts7dhgAuGMKi+98PzddZESFlUV8Ul0JFoQPNCMFhXoar70qI0PJqSAhNh0s +UzZsggwV6FlrUenY0dEg/2P/vEnwRbQP6ofxUs1KGLMmqWtsz+3mrFdq+oVvYSz8 +pfOtErvY8dtxrSXLrTyriwKw5ag7YZKdiJRzWisljow3BIkBHAQQAQIABgUCVSFL +kQAKCRA3qVBE8c5kRN6XB/9R/Onw9aIfSxuf5U2DeCIKqHr8wsT/m5x3ZvNbCu3N +Upj9f9yUV7K88R2sA0nKZMCoMFgeIKOAxyVjSSKIyzYLagqVSYgbErv6D6J4GN/3 +ndusBohLwD5UruR1V06oRPny1ZSS6t3pBrTXjEiLAINyrortJBRzFR4STjjMnRTq +tw3mk/KczQ/Mto3YtQ6g13mWYGMVZG7AEmahBLUYPoRlFGSZlkprvT8XwKftdjnH +Ig/0jkVwKu37EBY9u9kDU8H1/Y/u1tn8ftgsKhAc/K7tg0cZYbY5JZMg8Ma9EGLT +hS+SD4OY/sTDOE2O3Bo1u6Pd9tMyPKOVNw1R2v7aNHDViQEcBBABAgAGBQJVJyMM +AAoJEIEeL3KkASGTMdcH/0rGi3gNlPM77im9o00R6f2aqUL9Aljv/hocy++1OwlI +XlrK+oyO+SLoIL+HiMNmBCgHZaqHBi/QKCNx/hFgiS/r2Cm8rxkaZGh8HRuriH77 +yT4tGQqLF58Z+0uTfPWaIKJ+dW9qNr+lYJhfQeLcREBToEgVq6Qv/r25ymV/Jlfv +s/vDF1WdRJA0HQSDQsPlO6OterI75PhQB2hvfkXOflCkFdk4qfC3GUuhe96r55eu +fndzPLedKIfLRcpe22MUdunhoh/gG4DRSIWtsnqb6wYx2jhWfgQ6dNs5Gqg/GN/E +vMW0w/PrXtknXclsY5gCH5jj5nUDRiq8Yn4FKseyUHeJARwEEAEIAAYFAlOoLMYA +CgkQvKAP1LIWjAqCSggAlcuCOJQg1XZugzqphMsQ7vTbR7nh3iJh65JmXTPVnMJH +YjCVdZDMt/UBMLGI0SW/oGX+k1ss3DOFLWHxwv7IWHFiStbjcSmZgu7jfPCybZ0n +V7mbbsUwItK+bId0/D5PiPTmnNXlVKkhpRymrVf2bTt/o0wX82Q86tkGLQ0/xjef +C0JL+FqenVpp8+uAJrzry31jVXO3/i6gTTXqbjPVewiGhHGjnwTu325L5BpdsFlk +QWd/+6JZL+X6x7ArbDCR1cbMnU6mHWgQ79ubn4QTaeS258NGaMvThsjdseZFtWiE +rNmABUGf98cYTp313IpXriL+Ivmat1ZKl3HgsD3py4kBHAQQAQgABgUCVK5pMAAK +CRDwQ2cJb7qV6NhoB/0WBGmY26xM3O2P96QvvyPGg1Vi3ZbSAyDTmbnpbJdRxHv5 +Sy+0Ik1oS68I5UuvfMeXi7moSJwP5ayaUuCbLdbPV7Hiu2Ues9DG4sRH/vRmPTpq +zwEruufd60hUwTiDwOi8FsbdYfG9WsZyZKpCTRXhsBBwtwMQT1LmLRDUU2GONbV7 +F384j/k5r445sR4anqD5HEcERBgBMUZp5JvM9SQrgxETr9jzzXrniRzrtXoJhAW/ +RTDhsFuyCi+6bBLbfYkjE+35n1V7QvWpZvgyngWg8WxVKNDvFWMSj9fz3jdzECk1 +px7Ut27rK+YaYTJDKuOt7cquJbsZsgmc/7t//psLiQEcBBMBAgAGBQJUz2y9AAoJ +EHROOs+vPPimkTgIAMJIVDXM1NaJFCw1UxGRBJKoK6dVYHyhmrU9h2UW3ZfDCExl +jHV8s8R5/mgiOdgnONeST/eNSRu3xbPZBpxM5AKseaAtkzn31nAcIAMi7+I5dz8j +LQqWJ1xNZhj8yDZb9vrXDDp248iQIaABg61abSle+7Tv40EosOgEO0QW3JZQLRv7 +RG7B26lvRNZ0EP8K9CpTB3eHE5gGAKIlpoojtkDDBvWgqcCAIO1AL0w2Im/x4M+V +yI1/HDFDp5S89Ea71tu1VaoZ230Z5/vys7UD5kWFGZEyp2wmJMdFbqxrd0lJ5FV2 +VwmFRyPC4773Vof/PgogLLDWqbWnoVGAsNtHI66JARwEEwECAAYFAlTVdc4ACgkQ +a9lgClhUxYWfWQgAnULgJ4G1jluqrcDA/F4BOKTHYlpbYR1Zk2HjhGLANs3iDl4a +NVtiu5jOnRY26QE56AsOmtiVqS236tkXReBCPPiudiDjUPU1RkDym0sNMC7oJOId +8sqdTIzPPFwTLJZNKiCrMl1+w511FrJR/dMdphW33297YgfleORGlxN8g4n+pdcw +3jfS1aXJ2bhPFG1mUD9tzYnhq1CRalZZRLySfXHxGSYHFVkLccvvdsxjczh1aJpU +JCZH6kEDm7MUBbO9Dow3p/3jK1WVsukMWcH53kYQcBnOZzzoM4qiHzOBhnuu8h6K +6eHx4PcFlwxbmVsW0iEEDXTzyBhVIFBVuoVILYkBoAQQAQgABgUCVdgpjwAKCRAp +7li5loZRcS2VDCDTr5JYKM41PiQ1TrHB3A1X51mReinO31YbAOKVZuEu0eyoddJ4 +AyQVdYT3qjdcK+8SOE9IMYVvHrxz+Jql3ep7yZ0F63a5kgbcdonXP7pUuI0vOKd0 ++o7NrBa1aXJEv2/kg7Uy7a9nd+KQ8vHj9Vq4pscDtNSfjvzHktI61qusLqxB/mWk +oyWjmnp8Kj08HPlaF0RpbhCYttdE4cRJFz+A24hQsDQHKfNMMQSxzFK02ZC8f+GT +iuDhgCMxZxg7vHRRMM67YLnyn8Q4HyDwWCCc+NncegxoEjcAUWj091sz9IF1Eui3 +l9NjKl8PJwYGMGMnQEb+iy5cEeeKMXCBP9EbWM+byYxAVblGijNUAyF7op6ZpfTA +JFM0/0Z3XfnRJe8BCwepGboW99/YcIXyylPYi43el78LbNhaVWZOza1sC03uICFy +hZZe3zpZ9qqct47klwuIKlLJRTX9XhLdtZ+/O5w6eFb1i8y5oNFeL9qZ/7+O18/r +ZEqLo4SqyHLamDMBT/fbiQHwBBABAgAGBQJUzqlhAAoJEPQyUZ0nNiLXIUQOn2j3 +jq7rwSQMfXbjoHV8Ej6Q+zerUbG3ly4WdXjUVI9cx5HqvbIH6RYOforKdDtOzqG3 +BdQHcfnlwUcSgvwzEWlXNJuDkRHk+2u0fA3rpeRVfsQiYO6YBjFZ07jYLpu+wGZI +Jtc5nLxCpcTo2Ool8NCZo1dBHBsUOjWD8SlZE9H7WvKjb0SGaUUGjYpFuFiwj51S +8UyvQ8+H9doCO8dWcTcIXlsr+krxQE6c+oJ8vBOO3+GQ1AXwtUQz9Sw0wARcr686 +NXK56yEl3FsQkhPdb6Rhz83iaRl56JOdf6Nf1rYTTr3x3hFmOYND5yHtv+bThWib +kgMk0ErcfeqoYiP0dSKKnfgPM1ntoPIeb2ZxTXl65Tt6FHoYVngJ/f3YU5D/5Fg4 +WGiy8bpvkHzrG0K/eAAxORaZGuJkjW3/TI9VVgEpCUC5QTfPOCV7ZwFmAYZ+ZR9V +bdRXw6gOcXbywi9p/8hzqR5ehQJ5OfIRzkHB432cIIYdfc5PtCSf/SZ0v3xBElHm +qJUb34ch02p0KtOPMsf0BjT2bOIq0Sr1UIhtVnLvUYUTaLW3cSazW7NDsQ+1/84Z +cHtbF94Yn2kOruHIaj7T6GnDYsB+1c6p1DGnCq3TgQAQ64kCEAQQAQoABgUCVVym +/AAKCRBy2nXGEKIVS8saD54qUv1YT8nynX2HFzVODKVW3RLP18sxKnFiRvg+/uuo +gNxXxKn8WJ1AfudTXq2SWvkyT9KW5PZ9CwTcfeFVGdneB9GTOU+Mrwp7+CA+T6z+ +a2XgRKdxSu/sX5zJwFO6tMz2DTDnf3i1Mq3BF6N7IWpbLI1e21uanNgEeWVzTLzf +Iz9Z/IjxoYu6YafZfG+SFG26q1tQIWDX1O0Sw+1IWKdnX1XdDaWR3UReccA5FsTW +RI0qZMXOEEwJ0Hmx3nvJq5+L2xlCA5gfUUDLnFYU2cV701ffhV3wULKGANwliR6N +GLuTz63tnuZ2yUZ17dMIfkxYsFLp+yhebNvkN5RmbQysXWt/rzl574fDEQhJHuse +9KeWM6Au6339L+Pp38MKMzubbPeCXsDf51LAUwJqdppW32+4y4/HHc9Ms1okHSy+ +Pi13v/eE+1fQ4r6hoNFxOeHRYFoMsA32VwvXj6G8bS6Gj+u3ZxkOyX5d92USb86o +dpvA9TQ/HvCLbQNkL4YkOmiAKFfKYrmE7oqeZbjm1rCkRkhjnxvu20tbuWbUzvDs +ST53vvJgxP5sqM8H0U8M9SyTzzv1bC5EFrmiPgtIMxRoMyyqXjsjpOuhZv+Cv4j5 +BuV48m/EbQRLfj+x8ZicdH0nuwhQcJmXezma/9Oq9v5XQyYX54kCHAQQAQIABgUC +VM5YLwAKCRC/vMu1Uld/NInDD/4t0Q2xutYtODLphVoCeK6eP13VelbT4rjdO+xm +xIi5utBEQYdxFZVdrHorO80eKyON6MdmiX31V8zkga7jF8jWL1kcEQNei3+44ImJ +zkDXmhd0BRW7J9VEhM3dUXwLqWcfUswTdYPeKKRan3UbsfiNSHFh9rlp/zv09kOd +8miO8Fo+hBxZ27myi0r9tuNL/XHj+8LBhz4kPoraShb3ZCa7Auh21v+wfyfrVVIs +LXLDj8vpk43iJvCGmdD9Lvz3AGnfpfjgFZCybkw1E+RAD4ZgfG2hZc6wutZGcBam +SaS6nwLvTD0sxvClF9+3i2S9jFhqAdOI/Gs++a2YXmlF34sqVgsLL/f9/4cNxPCj +k0JghIvLBEL6uIkd5DPTMgx3srDZ3JX3dMax2TbpXWcylRxjN4Sgcq/P2aXwctLk +QCEEWo4x5q0I6Vp8Rg7B9w16iQxeo7XB36ZwoSMyE33EBHmRPtXvHrETP0KSbj47 +8wUGGNxZLIg8FCNE6J7eWAB2F7EcBnNBJqpMGy5IJwFkD8Nf1OX6F6o1CvFPAJ1z +gckbO5WJlptauOf9v/CHmZxDl5al7P1OCymxq0UOnks66vbv4WGME1aacgmOY7Hm +4kv4G0FxKsL/yTqp/+yBOcT6CCNscSu3cqA9j0Kz+EJ1FNMa72x5Gteh7PRt1x1A +Y9WwqokCHAQQAQIABgUCVM5/tAAKCRBXSq6EKIKzaQweEADK8k3P4uwStPl63+lj +XkmSHKXisjA5XVXxmIQoS1Nu/01JIyrNRqCOnq6AViIUbrSF/AARHXVSa6WzaQfp +h7q1yEJDgKqS5sYDi/OET/YcOyNVHhI6H1fhC+V2lmtezhY4l6UcGwr2t1MkT1Ta +QawLg4ijtilC9wIBf6zM/Jou9rPXdOuy2XN4brV5qhNNGLlKrLpG+qI8fonPA8Mu +Ik7ZixPbmldwKHrTYq9dMVn1On0cNyB244iJwDIHshPOv6U/epxrY9/EoUuMzzqq +SPBHXStMinNcJTQwyDJhcdOTJVDbDDkzY9fLsvSpK22Pri/P/+VUfOsiOuNClXH8 +QMahnZg23qghloTLkcc5wyyW50MQD1ZL9yAMBnTO0sPEz97t5RYEkm9ZcmzUzkA8 +FGe3/DN4M1HnEuNhG4zDp4goG4rwPEqfv7KlqQeBhMbrhAQZKoUjpxu6nTawE2Ld +UNT/MEB9sujkgkaLOCJ9y7KNlvL+icticQPPQbvJ7plQ+gdMigb3IkbiTSYuXVD/ +d838aMUFqOLqtpZz6vSIzr4h4kK6jQJogwYg1yqfAypjmdSH2XQxH4aPJJfn7vHS +t8i2F+DaEr7FoIuMku0chKkp4giyXkOnSdTiyjjcGWjqfJ92H7fXyzDVIWH9ZRZN +oanUFGvnZW/rkVBtc2FhXsUZDIkCHAQQAQIABgUCVM/gDwAKCRCNKv3dWa+QTPOl +D/9gQGWOLO9V/Eh7MSD8op+MVx4pvKVBvgk5JDb0O3efDKcuqEV/K0P1PsxvKStr +SKpRn/qks6k3fg6Kqc5Ud3PxuLBPjyp0P1nyWlTW0icthhHwcaJETUl8567BX9f/ +I5yynTeNUNdlewJ6mcYuGSpzdRBARSf3dtlAkl6TN6+n6o5oZEgKn3WiOx8U4Wck +eWT3IDQLyWHXFZ4faruMXuMtdNlFxLnvAMIqF7pJ7FenIfOib/pbIjvwtwjR2xzn +arK7QNumniTTaobmo0/tULXxH9+Yww1e2rxwGaO9Y1DfQpNLyd3mlsj1icnIPVcu +1Qylj7rTQVeP6DW/WWxwYY3A1OflOOXGwbmRWkIDPOHNDbjbIK6YBMy0ZvTRY08A +kxJdfJGPq+9HoTd/Ns/s5ixiCtjvBw5j6bXArnI3k7ZJZdcFbZ/DcMBwblmLWukP ++1KRhKbfwBYkEHrHFgDZNMkWHy1KKzDx8e8bt/RyEBRYISbaGV/snKHxuSRKOdp1 +t0bnxZ5P4OyYIuJ8IVF4rioCWHdc5Ia8hdWTX+fMfi2clmI+VYSj2JTgVhGIrT2O +CKVPeNp6EQJwTV70YNuoip+KQKYCw+9PYZ2u6Lu6euWrIhNUDti2YmTmNLmHB09+ +P/uy8qfChuT6xCt0mi/CNDBoBJXE4TaN6HFSgy99iG1rhIkCHAQQAQIABgUCVNDn +nAAKCRD2hVGs7AIRRRBXEACwg0+tOK3/kz0xonhu9tJ0eNkg4Sh+EaFG6mWfgxBK +HVMFTUOi3fpm3tl1GBG6ycfU75wMxtbuwi6VnUVZYHilYcuECdPqTHjE94BB366X +E9pLHyBelNFDiLNdcUAb8UrvUihBn7/DDrQ9M1bH1a1NQGMK11Wbw3b9IoGG55nR +uNASmF4SqsytbYYmkb4UFZ/yObQREPxtT1OE9ReVI0M9BOG78KQAVxoMOVafgzIS +WDK+tB+LkfP1dG1Bsw6iPxXgUlsRfwhnWpvd9WKMoxgf93TU+ejMVYZzTnLl+FBm +cbhoUGV+oMyNe14km0oZ3Fxnz/MeMqS/X3/iStejLwcrHLtYUbnNl2lvcBt0w+cz +MgU3302xU0a7+3TM9WGOS3uAd0K0isk/o2L6llEvjEWiJz3EDTjX0ggRb/RFCODR +wXclAnJC/owYkZWN3nKP2EDa65T9v/kYK4eKW0ofIqIQRE0My1lPjOSZZ/juzvb9 +/ReqPZ6by1G4pFvZF5u0UsbtrL8dFkDcaCvdwHuQEc9YGLZrU9VhbB92PK2f9wBG +0TSJ9Qx1X9lpO1K3Yc8/Eu4uMPhjtFL7h6M8+kY9Ylhba1275S/ktOY0mo8HVcgn +fMrNICU/2+kBw3bLERcUmisMEOijg4exXlxBw0qNOWhWldiWEuNzLs/caY0dIz1y +uIkCHAQQAQIABgUCVNHzVQAKCRAtQWidUZy0AZc2D/sHw35PqmxddnmqQkKstqjQ +BfI+Kh3lPEmmk9G8kTc9Nx1sAGto3hI4sbob9e5xgzN+/3O+MxJVlX8yOnUiSIHj +7/5eSASibSftgtDjFOi33ocFXO54KUp3CXt+G9t9igSRT/iHqmf0byOvQNcYbbOQ +JD6CT+lDPd43X581xtceSWPnMpXUzEE2NbRPulW7PGkc20blewk/8f0WV8MA1MH3 +xr35E6+G6KZwNrg7NM+OE3+IwMOYTwaTsEMuCDMTH0TE8LnfrVM2Mxu1xwWavgai +PaeSd1ZAHrLGJkaRJFo3dAPJhcmUjFE6xKYNSPcNFI24lCWMkCvwQ+Tp6rPkEgKM +tbqZJa+WBUAUxlDVAdFlQ85Y3K0CKb8M3n2ePk9LV6JSnejD25Z/2vwLtUNwecx4 +H8sUJFLLkuaSq6nMimD6n3tUFBi1/lC2T34omdB+80R/RHwhyb6bZSJ/xZvacnaT +HTTABIPsg6KWiN1mdaI+plkkEb1L0G7dm/Ap67nxs2iVavjKMYKTEJOVIdEpcX2Z +guawE6VeOfsTbF51Ps45FqX6NaCeCv/GCi6JwiK0mPDPOHj7dhc4yHyIELMfk5OM +F2+xlyoOoSHNUCmW8HUKJlE7iFWYMkRR1MKEoXomMOXZrQyVediosyZFkmxMYSmO +O+9ml4UCzwy5c16LT2QwXokCHAQQAQIABgUCVN/uvAAKCRDRP/g3Tst7Qh18D/4r +tt44DT5/D7SSSspmcYzeFLnq4jFG+VQVWcvUGzuZuZDbhRAt/ZaGS3+NjH8AIDYU +OeJ7AUflF8xIMTY0nZ8gmjT6f5MWtxa87AcJAdGh0+GCFqPu91vD5zeN+3p3e0Iv +bolK9VU8IXQQENJJ7F37oW33F9Mfh2WpoZwK4bXFJ7MZ+bGIdCC6kDjJ0qj7Yf2G +ePcADrQYPY+xOGHKAgt3zxPzsbtMQmh2CX0AjiKnNy+NrSWh12xlhkd1aW4pKhic +7StcVeHySC+My05Zp17cee61lpfpBs44eFy7++MiSECkSOSS5q0Yr03mXMiA7TSv +GWMcykdVyuHPmIaFO0k8bDoAKO4Ehvp0M2cSs1thHggS/XjJu9PWMRu/Yg4L6MAS +AQODzHlYAOlHGXzCC+jErV21HsEwcCSL7aEJdh4aMutiQO2xWLImzYIqW5lFefnN +vmQDkT/SeAxTx57Zoz6mLSiHGS17xpRIIN7ev3+6YFPUE/SBzx2Nh2avFYO+MDZ+ +erNKts8gb5rUBq2yd8kAWvMhMIWkxt1lHglcrI/7CQZ2epWZKhpVvkJ8vxxq3LRL +B06A/7K2kGKC5FyFj4p6Q+DJ+ROAQSNcKVJORc2tw4QsceVJlVW0prhme6d3fmpV +GENkvz+wKIEHHY2IRqoNkfZc37IgH/o1qcBAdCz5jokCHAQQAQIABgUCVOIPegAK +CRBROIqHgKQfdvMdEACAMpvIRWyeLl/ZmtT3m76uR8N6MNfmYultxG9kn/YoHR7e +t9pGlLGqu7bH3psscRTgPYh7trdpNHe8l7CQf+PpoCg5FvD0elKA/r4Z3WDSjBBx +QfM3SQ2W6BBXTdpHsFV1p9b8igKC3+sDO3akQQCgXPr4CS1pwyadIza8O6tNXAd3 ++sQ2TxEC93Qb0lnpCQvzJ9zNrL1FPE8hvNaCu8XG4B5M0Wohi53098IfFbkn5zJF +fTz95r6vHn1TZHwNVck19VNRMpmEFriGJwo4SHZ5uSwRdzi8+ZSrJfwJ13qZPCOO +jdm8U3EzC6pW/n7hnytbnOrIfPfZfHDr6nlviryW1szR7YjqS0jaeulSaBQycNq8 +Apd2ROpfJPKRXrkt4HDv2GVoZc6AYe1EhE2wLekR37ycYrOON//0HahZ9Otud1aE +njtmJCopg9WcwBs8je7Qe1aUKVhrmUgXe5UGRKFW/JfKMCgjO3haC97h+H+OMIpt +QT5KYsirb2Q8BNT6uWVXn0YGGfRnAdZlBrChYeVtU0ygH9N3Z2cYkLtbaFE6Vmi2 +cdORzpqQOKoQpLVXA3AohdIudj8txf2rcA1GUasoM9wMwm0xGnSEkIoU7t2gXkrT +wtl9xFH8PAAX0Hn37kJ6KB9WCw35igJgBKCqCC9p402w/GnRlMtZ5q5SrRe+qIkC +HAQQAQIABgUCVPtrwAAKCRB+3kLbaVG0+ke8D/0RMiNZzaBE/BDfiR0GWJnHZchj +64NXqb6yHs9BJ04VBxeeVapuJVFpdQP9KMySwLeHiUlhcZWZbF3SX8FjLdSiZOOg +Qvkel5ck+faamKqGZ/hJ4M+yQMaI6mxj3z1F/DQReQrA02v6bzQbR72i54N2lmde +guxiuNDfwW8o8Y3RE11rV6c3NM/XUekQOfXtxdnNTqveEaS50m7OPNuphYAIDzIT +lV7wEdhf9oBrU6OYwmfp2Y1UvyrKOEbIlkXrV7RAxFwVuZNSOXdvonx7NVqdFBFQ +DzMxaFhODr18er0upl+1IxoILtp1sGtu00g7b7JFMNLk+HTOONtNMR0pyYB18BwS +7s7ntzG6cqHA5dU+zEjWZIeSWg/2VjgnpglYxi/l/GwAiTGns+2GwVCX9JRTEHJZ +e8sczhk3gYBEJ5CDOGZmiiv+0sIUbwfopaRr22OJYttaLss2GcotKfYRNvfvn36j +KpYiPYIS+aQAVnqBiIMC3eixfnN6tYQdVcJJh9nUJKxOGRW4F2+519GsWmx2YC8E +H7H/7f1SPMCni4MiQVoYEvLno19ceKWaHA60x/GLd+R4Px0sJ3IMAIPQjve+ohiX +TcC0U+XfCLc6DjNYB2yYwN8mN3bNA8RfjnUswu9Rlnmeu6owGgiBLUmOky0lt2Dg +gjLXkEmIDqH/hKC8w4kCHAQQAQgABgUCU+yudwAKCRDENXD4DMKV5s0cD/9kGJ3c +HogHRg/B4LcG1t/LWBe1qdqDObyTQiDI7n+NlngYRt2i4GkS6KJwldw9GuSUHlQi +Em5kFxLi2iEGTMXa7jB7tlhU8Xb884m204w1jHSXBNJjQECgq14VMyegjyhVzoqJ +7apEb7HwWZTEnxQ0IyXNegadgk6wnHXG8b4ke8s6t2+NSguk4kMdOTh4IsO6DP6X +Zs12vF5bLqnoOqVgOVxkGSeIv5ilZZgYM1XLlondtqP+B3FiM8oPIY2lTo10uEji +XpNh3SGuGeNjSy8DWtt2W7/W8z7Lyl6cWRTnCHiz6G5n8SPyAgSdu7dmHraBMzU9 +GS2PJFrtqvBqyRKpQtNZCB9JpHEAh0/5t/rAGxxGxyOmq2chl8pYOXqJDoMsRwVs +KA42ISlKMmvF3JRfyHXTmBADEkm5VV98UYDI1IT0cMXJwTfT3LmsoI7sFf6pxUh7 +YCSWE8FEUfbGsQk1Ssh9Yu7BAUPu7hftpvubUi7XagkFYI0W2IaKg2WW8pPDiI2O +m1jxmokFmMvkOXLrUCkXNKeAJyOazO/9crTYlxOVINnGBWM3RNDWzeJafIAc/7af +2roKdPpxhkPYiSH/K6WAujZwlEOFHC8wIRI8Ru8/EYA9HJq9BMiC5UOYmCoJpT3M +LMOIe4SsbyV44ARK12Z0fOlrwiKIb3MWQ/lX2YkCHAQQAQgABgUCVODeSQAKCRAi +J8vWTElyGPWcEADADV3tcKft4+Hlkl69NbGgxU7dA1I9RPBLcaxgi4Zu5tgN0wy3 +FmLA13ETILm/yb098T5imP3NtjOyVL9DbIaInHwYUZm6+bplIeUkIDQxizLKMV5n +MLd7pxZoGanGHCi2W7vg8Tj35Rkpj2Mtr3QxHbd/Q6+RfZQIDsA8yIL9TkFBWlHY +bTJK04cHHehj+wBzqSFC1+TjNZkQtgnK6j69716HDHam5yEC3MGy0FOgZxt+Uz5Y +HarIJrJetl5U9vT39fHYFxmM93JoV3x98DQWOLYyd2u9RxBVB0BNyJzwTJzMhj2t +BC5Ta7kmZKx9BjBInfaT+Mniz9+uNlpfAayUzSz9+zIsH3AJLJRgQRnBOYQgdE85 +tSm0w6fZG9ylvkuXV9AE+LSuWZLR37TnRQL2xfMPV6168ebfW2a7+xHBjPvCpjbt +pgBfj0tsIZw8RzN3Io7AWlGGVUZBikXEMSNS5L1p+pcGwl1l4llaJ7i23zoEH0Y9 +WnVGPGlmmoem8COQVvZlUjbqmI+UsdOstLe0gAp9L3kPRef1qoqVB/cLGSBLJphf +C3mSucOOwMWPvdCtyJHpQbIgY7qzyTHN896L6m1uDnnEgMoLjerTtNYoMcGadEQm +XKMLv2ntrU0ODCXxhtN4Bxj1Gw0LCNt7WiO0UsktDEeCKYhSBwRlymCRvokCHAQQ +AQgABgUCVZqhtgAKCRAiCdaQL5aclZOgD/9wxF/nRPqzcdw3ZlUnOoBGpOR8rwak +aj4EGY+DYomkmVKfluAbRmash5xfEn5kqxZ7SeszbWDxO3AxIWbkmPS7nDGaL6Zi +ZH/hfqOTH92wy4EmrDpss95Maw3L8dJLj0bUtL5b0CY8I5aq8Fqz+rsmGWqE+31A +hWy7DLzd3R4vf1h5utVfQebyMLSYFWE9NYbt7TEtkrZ8OEspVjjWRB1v+QWx3ksE +SWdpzXndITE9q9Tp3kVgrrhx3POcoeBSkx+x5UyKUjYVzNmR9LCzx/fIrSxbTuwc +EG2bzlCW77+cTsgYpslCxtcQfyrf6cOkAQ/JKm+aATt1Mnta6QePXr0YGhspafXL +N1R9MqqYUOMZiJxAVAuCBp4WuULbaiQRqg9dpPT4LwcRmJrCWEJwZDHZZvkbij1h +XqT4UYQgkaINAJUaSZ6UTFyjBzKTi5i81CTEtRMZwpdXYGRPWDFUCOMZeb6OJ/8z +/12mZyd2RaBvWlkb41Pnhu9M3tNfdKyVpRj1jI6C6tNeT52yBNiyKRmr+vTNb9fx +ONMhFIWgcNdKiwHEq+2NDJxdTDmYoyBUvHGEZgImstv8/Vs9sPxo+65ATKt0Zd84 +FM1NQsDbbg5VN84RIyBieW3L1Ebm0oc+WOFlEA2EGxQT8f+tFidlFf+IhjGkJtB8 +fVbULzmLWY5/rokCHAQQAQoABgUCU6x18wAKCRB/2fzLAAvu7ufjEACbvLpWJMZz +RHzQgK/gUK4R5QXINnpZnSzZX6g0hF6aqPuzsG6odQxAmjjpgP79d5mv1TnwxhyF +4BPpCf8hRB+nfxEU/qMSrsNwV5px6RnkQuF8VofprZ/oNEu8PTqDM4M9r9d/bvNa +l+Rg+js5I8ieHMjVZE+N5MjjX3ZjFf+ix7npxdsFJ2aVNk6nNDuDxf68WxEyAEi2 +G6PGiS4lQyB5AGyuRzrxjb1fZ5fD8H/XJ7GDCOKMwjVdtgWF870s11BzS6KiN0vL +nhasnig4GQPncAi7FVlK8TDzd4Z81i8m9jQyAFmwbHPwuLCzgkzSpWKTzu2InI+X +Eas73scZdHAUWs/A6/jDxbwvuCZmq90RfrQhVwWUsmpktlMENslRfdQ7ABLC2s/X +2PAdz03b2weOezBOGfFwMLIYqFGvSkU/saJEC+2P9kwesTT+2LPR5iNyj0rHg1PS +cKzkN/Im4Kn1ZfKWE2MZn8+itvZNGAfdKgVtU1tFDvouJnAIbWDhoXB51JG9sbCB +epPMwthzsWHKZudjF3VpQupDkt+J42djDofCRHhki2qs0VUCrissnECD+6UOGNVG +9cE3HdgO8u6Ry5GC8TTdZm+QxgCx39t8LPYiKUmacw9h4etFvOAqRnrvr5gEbZWk +OSwEhzwYGtbCRH0355lWw7Aah+aYwa5QDYkCHAQQAQoABgUCU9g2JAAKCRALxH3G +TRNTBhrwD/0VmlobBOmY1t+saROrJicClqP8mA1eQwDKRZXBBJsrS6NJiKfna5HR +vj9qaYG29RoawY3A/LJuO5k5/dUXZ4pdqIzd5dbdpTQzuK6oD6bv5wIGauYXuGb7 +G65s3YGUM/vySMJW6UAAoCABTxXOnF84WWF2I8omFTqhpdD3CKAQtynFjbmNeixg ++9vH+gFH36xj1cU2f3gD5HBSNaO+Xael5d+sfq94EfbKqi7IsnnckRy3hTd4Dqw8 +/dOZ/T1Cg7jhgg8yR12IExcYDTvUfB8DGVQrG/DzXscFNQA27mCJgiWTFFj2qmFK +TQEnECPvrVWVg1d46mcpTPj0a4gD+pNNMB8nEbpeuM5pkdtKtRkGH/GisClcdwxB +AIAyKDkoNB70OmNtM6m8NTB5NA0LEnASo+1ApCQUw8YWITCYq+4o9z1RZZ7qLTBD +9I+tpjml8CTHo17aUJmQh6iArgJQajiusb5f+tvpCJGFKIBDH0Np1j9J7gjchWGH +bM82LiwHBP+2Kl3QPw7ixepqd+7B/CnoJQKRqUSAxPcJQgOheJKeiZRCTxzt7hWs +U4eJXuR0TKblyGRxQeB6OojTgxUn++R697ZMYV/gy27oSlXQZX+Wm6kKZhgjEUsF +4zt6Fm772ySieYVRNWvSVNJ1tjlQmSCgZtRAe0R2TW1gqa1ESA1oAYkCHAQQAQoA +BgUCVM+P0gAKCRCvJaLChiqjaJjPEACCplMDSkiz9lfD4O5QmoQ+U+iGkvJS7FED +E+mpuBqaCEE/TSvbUGdogkTeEnYbXB+y+4y8RA/5pZf0gmyHbEV3xqA08nl4i1Bl +NTU5HZAnf1k7tpGFgl3S5Kd4Ki1CDSJriH2x5SW9woVuAnbodenbggxd4HOS3KZd +GSwM/wMUXWhCnKL2bt8Up/pQBEqev2NJPndzNat0I3huzTBh5qrhY6avQZfvQCKa +8zSRVCUX7q2y5seWUNiU+v77UlEA2bEIwMOgpmTD1URMA5jc26ShM4JYjMYZXhmP +gJyQubWVpgncaKOIHsVeb9QWQOXwI7zWR7Z3vBjoODI8R3zFpnxNzYhZLruwD6Li +BVCruTEiWfgmzWtvCqSfJ5BbCk5J3+5dqE0OkCItvs0BC/zoOKcV2Dio2wMjym3d +nfi6huKrp/Skdi8rXGjmHfL6lp0ClxccCPG2Qz6Kk3rDv4it5B26PMRXMa3z9H+v +UdZXHbpkneXitfFIaY2K/jo0KzlCGpevrfS9TEFnYvNZ1Mp6eMfhyPctkZJmvqn8 +JR0jpJFjA0UmmKEhRV9rWv3lJra8u87hz+PyLPBxoKAilmru6S27OglQc1tBRCti +sYPKwHOsdPn7w4gDXWjmtKFyVSwl7y/QrtUwrcyK8jN/XtEq23XlZ8MOU2xUduyb +0E+y80kaV4kCHAQQAQoABgUCVOCXAQAKCRBT/nu9pokQ/PELD/4sLKml7HRVraaT +SEA0skfFClrTy7yt2H/8QflPGHkpwfXJdTmvVPPg9BztkQ0zg0EIEhETK+x2kPX9 +Q2soetK5BYUktIVYqtC4w8GMUpTuhviiIJoYFwmEdMtm7l22zQQuf4c3wk0pUDEk +6W8EIdaig/Mg8WhchH8krUmKsvaXwgKRLeme5HFEfLx5fswsAbLV2EK+tRFN4wDD ++EhHutz/G18LobeX7f1cX/GkIRyqmbMY4r1S8WJyzuwb6Vjb7FoKtd+ilhGR4hHA +HB4D1xrmOgiNyu+CXMImscZKR3qGUHdkxkwF3WfJy0zdyXwTuTEXaAnGuAxEtxFy +YHDu7PJiV8dTYDneipdDMQ1+C+Uro92JFyNoP5H7tUSbGijc2yabY+CcOgYVETcm +lqsqd4HDQymYgGF1eCa9tg8z2iCJ9SDVlXq9XMiyMskqgefcpJsYMcFOg5CKH9fk +wd9tx1Ddx2R+CgnUUeLK7xRxvc7l9C93ZNwKiMSKzDf8vdA5FIgiDrfJMjIbwiCb +YLu+I+zv4XMzi/x8sU5ZNXArxWsR1Vy6sGmHF6z7lDTOFeUW9sm+PvNuGE+4TLI5 +f3Hrk8wlsI+kv7+8Q3i26OaEnlsbFMXAX9GGjTkmv4ukAUQR0Q3Iqmr32j1tioJp +TeBYau7ZyBSZHvm6BKmseFy1X87VeokCHAQQAQoABgUCVTbGUgAKCRBeYlM/GXZR +EStHD/9ysuD7+R9pw3i4qM+QBbzIarFMYgPaFzm+YiufE0bPo2tWVmTQP2Of7bXu +pUEdBjcNKaGaIj4F8+nbHOx6UqmQeyIGGqsBhRDwvi3xfQM8EIqdBt19obuBCBMk +D4yAdgtPRkl4kOkB2JLH5Y5v1UkyAuRn+2QNFks4ZBXBafATHCeHt/z9o6h4rIEv +ecIP5KFQFmBeo8xmJzUedbL2Xkk4vL2QORQFVtuTMvH5evfkBBmfocF+adm3Lgv8 +UpCzeG3TU2fCq+ySI6nLIP7Lcqqa+py3anOxlDChFED5zr4Q+N7gRc5B1RHsRciQ +S9XRH8TNm7dXdyP+z+qOzhghmsoNrIDjf4z1m7s613xkH+v0UG5nSmwCSiVajLqa +dQ6XaQdgRyVzG7jZrXZNGfjyjOavWCVlJedvdTPPTJDsotOzZ6ARFMxJ0g3PBoe7 +j6nNqPg4lahG8B2el9ih5TzOSQevZ+79/KF9jHEG2u+/J5v5xSRlEafO7TPvYhgD +SHGjNeCdVfDtoyrR/z84Ml7X6vMliYP+0mdk2tEv7XrqXYRC9p73VX3wfUCOFUV5 ++HkhcR5M9O2tkO3CbxEvLDazaB9SUzbi8fV84uezxw9ugSX4FX3m85NC+kgGn2G+ +bqEwAxnqqJtqhQm2Rkec2wUMYT5WCDgnfHphyKi55MYp1GjKvIkCHAQQAQoABgUC +VT6fNQAKCRDJof5vZlru4xXwD/419+O/HeebyqxflMEQKfU/J0wsEuu5d2G/fI+b +9Lu/jHPehUZQMuVBjAMcBB0jsKCdWcLGHtPfkEmzsHohxnbCwlFQ9mU9iCTM276v +yNIRY2k0gTKPOr7IYpKmxsmoF+ZY8CqdonF3pduRI+Gi4ZdaC00ln2RVaUlMM224 +lTB+qs1UOOIQp0V33YOUVnNCTYMmtPSXMzmLS6ZAudvl4SgjIujL1fIKC7EjPS29 +IQcLOFh5VMb9TiUYvhz2sRR7ZWuwoHQQ/Aj/L7rmdQcc9qa7cnsSX4Y0JMvGmXD3 +6WJT0L9NcnHbhdCTGYKVYPXMs2KBdRTy1Ube+HXxZVvUwRAqG6nbhmf7NPKld5J7 +ITTKo0LQ8a99e3pS8M5c/m6Z0nn3uWhvZ5wohDbs9zzEgZyVglFRlGSuRhuZxI/l +tijW2ltai2s58r1YnCKaV/JungMFaB4H81rhWpBxsRGMnAqYha+RAgJmC1lf2NyJ +wPjqJKOWX7yDMmIR2T4EcuFzgyaYHm3bXLjxAAI6rfYAAYiVVWkMcbyxTn4rsLvU +vqeu0taw4uT7JXL8NvgRsNTvPqF3S1C5l2RA0EzYKbNe+Atwy+kseTBUED6uNnRv +CItC9uvtnNa3ER6Fh1Z40vSgnARYgIzoFCtpfZjzpq7KClBbo7f4HuDl4qVbzeF6 +SaGUHYkCHAQSAQIABgUCVNEIPAAKCRBehk+R3CdR7BQ6EACoPQPXeRWW6v0MzSad +37+hkhA3vRc+OFU3vN5t4U26V5EZC7h298vZfUJ6kOpVkU6zHTeb9farhqKS/Cdc +i8WnpHmf/Bpj4n2453Bd3KIP1ettFGGUeLSEQUBSQfViKgQRNAbhaElmbPQc1umT +PQwaTVhPe6Ho3jmEgBhy+iPVICqaaSWXeNExkL7SDt9jq0lEcRsHZCuOou0jd/y3 +hqkGLri67Rlq5XG4qpmVspLAq1I41Ui/3p0TOyrxwOdR3ZmxR6rjt2gGNabLZWkL +fq/pwcvLz+X9ZGvgGWZ4GnDb2AH9ruKmgyEeRYp3rJnc1pI8TZE3p2+BzJv7C04G +iEXHCcsykPO5fhKTQGm/DAm9GeNwnp0Py1EI3Q2GTvbQ6JMz/jNrIt8s56Ou1qHR +RpqGzDYoQWrnNgOu4TEretKq6J6tW325CEJGMmjj3bFivSSyNmDjr+tFXVfqZZv/ +9VBwdvpbzvHY1po6AXJ3Vv+G0kMuBmn8DhCTocMaHBh+dUfbns/M9VXn+zUKX7Xw +5DHJVe50NfxxTVM3GFmKp57rlycypQ2zAEXtbA/U3dfQ/gTSk7Ejq98LYVxjldf/ +e1P5sDdyzD0EkeyiDJOFjp3xOabpPm+XBHNj7JRNTN3JV1Yd7ZpHhwv1qg795NRs +ZnChFBOToqS6QVspOfRXiSIbd4kCHAQSAQIABgUCVNE5vAAKCRC6AQlt5IaorwU8 +D/4025M4vEyOi8OnXNJRIAAmSDA5SIkn1lEKxujqDc0k/2uPf/e2rGj6T4S/GLdt +vZhN7Rz9n+zk5S5/5Ht28laRjBR8s7t+Z9FGMOyARiLL/Fog8IBzT+krqGYaAAuU +JqXLdKUE+9SERgy+0G9zbop68GojzPyu5oe+YbqVRFXaIbHE4OO9zmj/5jpIyJ7o +burhvypPkm0xRt+/GoSGrtmEWGj1SgdANegGIvqqmp+pRED9q6tx99kIGN/AlZY3 +CEp9CE2XPl2CLBVB2CWsDSonnD+v2vDfPRwRAlFqdm7nmAv00R+dYXy59EuCdj07 +q0gFo5rD3u7F95Y1BxTid3SVKy6utRStbFaAHgDYvhPk77XqkHOkJtpP6lxrESJc +79F5836PffARmWFe7chJgSd8ahk1CmLbspmHGva5Zczq10HPZfWQjAfiL36FtTUU +PBEEr9DxxC9ycM4k48IvP5A6L+ZmO0H8WaIUj7cA29VOIC9u2PjUQKX60qU7+1gF +gaAHnzICqtWxbbdG5nhvxs50R6+spmzupoLIBSua1R4Dov6SMHPhGgAUu89ZgnbU +ltwAL31lPJ/IsfrcoQoZ4BVKJ0W/gzJVnGfy6GAiTjFJL+wE18Sn4cmZz5hWjwXF +8vHD9UCr5ycjM2GnZgNvCl1zBWkhbDvNT32dpDvJxJfCjIkCHAQSAQgABgUCVWtQ +RgAKCRBp8wdj3+/BNMLTD/4teaPFI6Dxfz4aoVkTOfa2g0Kt6Km0n6blvM2vna+t +uz2vFkQarmrNk4oqm73Z1sHCAGVEZ6nLCqyiudAaU3qt1R2EOaD4iy1KTPueaibn +w3mW6YsPxX6fNgnETiqhF3SHr3vEXZI0/NW7qQ47W1CBSuq00Kq/++FYMC54G4u5 +KzpddfrpurXqB4dm5i1gYfaKQnx8X2i3TY9688L3D+eew1QQ5fLozTC0Bd+f4e/v +l+nWsUETxGogMck7OfTAITaFloY7mC7TbjtI6Sga0WpHhMCp9SwarA5tapC4loaX +YViadbGjU9hTSN0punzbeQqJTYBlvNSRl/ZEH5uyZQHHvnH5MtF5mkgQzhWROrbT +mUYm3yRlQVq0Z7s/XIpzxZVOrurK7iOSe2nsz64FonFgMEZ5d34e67VX+YXWJiIO +J+RJkm3BZLtDvUl3zDMUc4q5xVcWOp4KRaDG7uSwsPmw3pSA6NLqa5bQflPYdhod +vdL6pSLdeY1BN8eSYHux3ZDWj8wTV3Rv5UqMEw76OQrIDsFWF22o+VX2/4FX1S+T +kG//8XI5pDgoK+buDbCbbmIrmXqdReu1RBoTyETHzmR86JgQ/apkyYPF37ll90Jz +kEhy5OE2OfKEYFvqkr6E9vDXh+M1CHZUK74Bx9bbRa3rd8eilpIsVoDGcNL34rL3 +CokCHAQSAQoABgUCVM6E8wAKCRA06qYG1zj4XIflD/9orUOYCZ2YCY2dpjaIL9cS +wmKVFp0gLi9Pg6WSv0h8OEhLPya25JEZSO1H5Vqas7G2ViC5ZxOxSutAinKO+SjU +xB161xWcLZnA0HSyBy341GAzxGzndL9xg7XEF3XCSy1BXLiPcHH6++E8HIKLeDmp +a2jOO2Yjb5GMbt0K5MbyLP7lY+CGb9vJDHR+a2zY8egINdDVg6fgilZYcPSjt7OC +qq+6nTIq/qYIbsMuXHzJWSS0uHGNXrduIpV//q7MtGHzUsT2nAvgrjYoSk4mhRdB +SlxBt6+57pp7VweBLDtmi2ww+4SjTOdfOyGs7gy2Fw6/fMPv4bOOvpe/X8qoelWp +J8qn6gfywDd0c/3k2Xe7DJL0E8rin5FwHDME0dijUVdDou2hGZuMMC6awPeKyXBP +sVi8z0c9SPTkqZ110y+C8E2dMaamtZ1RVIh3haFrTHcB+Oxdsd6uKb4eBin7xRIe +pBO2zPSzl3+Iwc+KXvzsWNVqcyrKM0xgzKRsIegv6ZwYn/boPQsuViFXeaZvPuAx +3+qXMZkfSQ+tpxDlCShkbcm22y7iej+2E7aQMjy2nGDneDIecC4/h7SbD9neGV7f +fX30hZFpLLnh0QSLoU7ss7PEaiKZu3Q/Bk3H0ai2SHsM+/4k+O0REXouMrKeUvIV +EEyV4gjbfp3WWIL7scdYOokCHAQSAQoABgUCVNHkEwAKCRDfO5CTwID9B2BREADJ +VWBcogAIhImjJEQtl7rAuum9GOUsg/D1as08NqPMIKg91QpIsqXXLRdVJdv5099y +mszFgEHxo9uSNuudR73SpYc0rSE6TU2xuT+R7WUXe044NCFiti670fN3musher+r +QcEXFB6Guwq+G9hX7yfb5mEC7Uy3wVNETDWwGma4BYGQYuHNyqOFrybqYN/Eetf0 +10fk6Q9qUKdBtgYNEm8AHzaeCJMOd1oSOib3VSto3mn3PJfgqksBLXUlnikNbGlp +ZFiiwnu+jWjMlWmfic0CNpRY6Wk8L/foqpE0qjW8z58laKlt6JIZCKJZi+x+Thmh +d4ovJCeba323bZGlcpv6pXSMQoLHTWhTy+pMBU1g943qmZYfpshYW/+SXjEBybhw +UQzkhe0smQj+HAO4yrWHLGgyjSuQPmpYeoTV+AvHrSwlje/Z87Uoxmnq1zttDlQK +yPjwqt/l90MDAqQKmt9x54/r+tkmSQ2ERTpOoCNCVIkVCEoVGsvNpaKIlS91EewD +0uaFA//xzF971GbLzGzXEqwpoEBlQnOIY+d/U2omfZXYVCORjZMCddCZpyGRmhMb +5HiOpTr97p+YfJt/U543sDeK7jZaJ7Gi9wKG0KG++EzSEA2RojI4vmbWY/GA+bm6 +Z2pTZ/YXWTeAEV37YL/Cv2i/qRtYZ4gGWMk/K5KXVIkCHAQSAQoABgUCVODRGwAK +CRBHL1ifDHWeapUSD/9+FhAJK/Zdwi8wAk6VwivIiBsyCJFUjeD/oPvCN+sDbEbd ++TfcJPm0/2b5O2YUaDVDozCq5MHFsP5xUfOulEeDV13mag61Thv9tog0gS+OTHsM +YzweeUYvFlDByKfn8rdmXYaL1jvzubKCWOwHF8hoqqX+urF59eDGHUPs074IG96s ++bkiBHpKgmDAKuFZtNIGUQOX5FDmwDF9jV9J6LS4Rq5fFG/DiDb4LnSTNqEDD8Ue +TrRwOPSVcUiqsaS+osFcCZuhh5P998//hH9zHIl8GFOQ8ePk6G8uXcYIbrqLtY6J +XJooJj8SaZmGkVDpy24O2jxRCnRa4l6h/HtteAVhzJxyg9lM7ryNCvWbC0UKqrxd +Nl5tvwnnYTBtnK+E+hSw1pkBGiyHc1nFRgyqc65P3V97nL9Ivc4JN3lnDkW4rkMf +aOxTEbMLN/IujXntx5smKWYeUwpwvvCu3vnA1+5sfziD3sqw1kgnHlGCxKpiQXtP +INhuEW1SDFST7UMazNk0CFYkbM4kC5HYkg01pmeJ5yNH7h05hixrk5eD5k3UstzC +rYnVg4FW4lFcmqbdnwSG74GOOFB8NAoR46FuQ9LwNEjZDMr9b+XPvjTh54JB6yQg +xGTq7wo9LWo2BVqGju0a0PAKJohBEelavfz61YJwA5EgAMDdUKaR3qsfAA2XVIkC +HAQTAQIABgUCVNAHkQAKCRDrdJOLXuvHP2ZGD/4tRItl9pGoCQdemF9uMKmtsD8a +i/8RikQjHyf7prqBpS3GBVprak7S7UFJIeaiH3rvfVk9T122o5exMOMLIYGNEq69 +K+4sabif4UAVJAAIpSVDDup7sjRz7ZWWgNfxP51mASQnAic5gtPTPnC2eqwyP8LJ +nU25hz2yWgyeVBfZPbLlr6x7RRfRScgHjmlvLCVA/h13YASo4vya3xwBf7XCVM6Z +DIpMvHz08wzMfMwAu8E8O+vBp5EB2XySAdEWwLkPrlLpCC1UpVxRzWvDoB+lf9ad +yjayMxmZbZnNtaCqWwad3Jm6AiWZ27mmllkIGKjFAQK4RRViRF50vMjNWWr5xNUp +Tn4hmTyWztWIng8RYYsFdRNRjrXes7ou9g5qIvFRn6O52IX80rU5Ib6ZDk+O9XpB +UciDnrsC0HX4vyO7fPWrOCNrnVBJ82OdA302xNkwZkd5gSxPDh49mTmLnCyX+DEj +VoIurObYV1c8eyQnclXxlNBBNPDrQMii3DwWvN/8KUCxeDBT+gHl7pD86PD74LXt +C9RI2SS3maqa7bQur9+MPtWqan9Q2wqeRVWOW4HMIFUnHVIx5zVbbwsyCA1pNj8o +9jF2+gD8ZDdWQJkV4FeGnUh9X+nGOY+SlRw4MzA3q/iEIt5YKzu95XH+xSw3lKye +aP0Znze6gocs99LzL4kCHAQTAQoABgUCVNEzSwAKCRBhTQdnuasTr4fSEACQbHd1 +aKG8PCOVDlNHxo40u7dW8OSNsE7WhZuxJFxX9kRTkufQfVfFtJ71CB95/HU+Mb3G +7DMuV0n1cviKTJ8bspPrt1Jy13MC7tlEsV2SaTjSmzY0zZVF5TBF5hsDF+VLgAlY +FbPv5MfhsxAq4RXzgeJhvoGA6HSpeXvr5wzkoR2l7gMZXiJHyL1P3j1nJ6v+otKh +pOwiWkAkqkRJ6fnJO39WluffoppoOY2Ori/CY2bn/ZeorFJQrFaQ9LX8RAiVaDhS ++H6jaROuLKgaNo5n2UZAjwxtf/iCwV2vP5qaxcsJZU3FLyAgb2nl5kqIRV0keooH +/uXt8OXVuyAIN9YaqDULaGsiJkD3LEMck3ZQUDOvS+EaId+CJsPayU0sDq+n/JyW +7e1LNSt7O6HhaqrPdGi5hacP3HDwqeCr5h/A53MvhnweFnWTMU6vehriBP7x80jb +ngsQZ+Bc7zatoVODRE4R1LuFWS5QonqbaCIF6/01d34aiQabofneDREfYWk8+Hpk +yNFAzW3kTwObVGAAxJlRxai7YYV09chfvXTgxPoMbLVoeXr//4IHRPXfMzy8yQGP +z9RV24KiRblkUA2f5Z50sUCmcPNLDUBWII0PsfAwEjtwJuEdWdmSsSlw+T3W5feG +scnIvJwroE/z0ZOgdlsdtmH8FRVAhiEP1F3OM4kCMwQQAQoAHRYhBLAn2kkFeYFa +QQ1C/aSFoO1RuLfEBQJaS7XAAAoJEKSFoO1RuLfEMPMP/1Fq/deWf39u9sLyCk3G +8xfe6fiB75mJxctme04/n0XF3/I61QCmmoAshp6e5zt7zRt7Ne+yCVPkCdpapH81 +hJZH56HH0ZyWcUZPopD9RxTWgThXFzOzwWDYuyiSVRPPutkUQJLZ8OqxfPLm3b0N +Y5puSFX5erIr5Y4N2MsGzhFY4TkhhKTCecwp74BbTBNtBwPWYBC/YnqNID/xWg10 +ilryhS+4qt41BRaxnTGenP2w+3KL/WeJTeBTcRoMVWD3GIDw2DSXxsdx7UZUo4aj +dBbNXo7Wx2NFHJazKkhxD0BiJNJr/ngwOrx8f55wvnj/P2hwRDLpr5UtHFCsamqv +b/ZuMj0y2IPHaayosxSqsLDhGvSi35QRdzFw3DVbuXX76EoHyNwmuPmyFW2iTeUY +CG+ftAkDkVXeSzEWzFnAcaOriym6Tz30cbB7Z29IogccWRa2VMtGK9SdWyu2tkg4 +S35oJi6wJf9z3w7Fve/G2VkGL+lJWi96/xlMeXYSl2/Fnachp/a45XmdXZ1t6f84 +a4nbPsii+89h2gNKfAF2eU5JhVzxQxFA4dhqxbpEoC6Oxg9YGaFLjCGbUBAqMagM +OjyUNzo8Vqz6cMI/cZ988w16U9coA0tEuS1hRj5H6eAFELPmg2gwXEICLm7LsSpO +jilbF+0cDqXCF6nDCYmIsfjjiQQcBBABAgAGBQJU1j8mAAoJENhO9+cqvq1hKy8f +/1UD0pWyejgDyybZK24634GL4Df9ziFfavdLtydSnn/PFuA2YGwxpi62T5FXWj76 +pDb/Lff5S8a+CqPacAt488Q0HE2o6nQia9RKlegYYuZNZGeIoOWZfiVV8b6SlRHf +KCBSD7cj6HuVaso7OTjKrwMSCd8aoMeB9lBLZKEdz8ociY9VBBWAgfU4UrtC7gal +XnWbUWy6Y/gyfW8qwTHQ3+ubnCilPqBHSxcZYlhfiUpVVum81Xycz6h+k/5moj2d +IeVSqfoWpfvU9uyuY+f+cVGV4LvwlldZoSLWUSdtJjHm5jnD6/b2YOGS+Dw1XSTY +NoAW4ALv+O1Qtaa0Rq7mXkkacBFMqgwi7JwOnnRv9ovJtgoc0qigLUCem7paMNPn +IkoCwaHYzNkm9NmQLbn2p4+xTThcKDndaoM8j1p+b5XMrU9vLDYgqWlvnjuFHLFS +eWKSYealD/ZaJNa4aO6To/C/cACwgPbdowcGLM4wgsGiYmC+gDXNPLNS8mU133+7 +vEpaBj304X2AXY/QeaImSGVAPPQAlgC8gfQTpF6idFDR6aVOkQalo+Jh2ZThEbNf +OXh+KU7eAvWcsG0zRL2rBggRvK0pGCTgJDHu4w2FP2VWC1l8TkRdhib40MGVk9hx +7sBWacP5xqaF8wxt7tWn1Bqh5oM8JFSSqjPhLzROasthbYCCciHJ+d2MaU+KLC81 +mKUVJ8Z3gCYAmwJQjEknnNVcOJnrWCR8TdRvSgPZv23qRmuTgFBrSBW1m6/8v2WK +KURjgUi0N7eSOAONeL7KbWCuQlfcBSpFDr1sjG6aNeRp/boIA9/suUzU+GWFaxI8 +smaogUrtbxNIv4cqUqhH5IAkS8JSP5bTyUk20PBtV6dqdPWpMZTAKWsQZPLRM38i +ywtS9TXd7SGly1Me6uZiO0FcsqhhvkZyvNigrAQQuGcOS9/WTIEFrddRkL6JkGBC +yDPFL//pwSm7eOa/N2GTIV7mxteS0Ju29ddGSpM691r9ALuBl+WfUEWSXqX3/lk7 +a1BG51BIQiMzZkKi0RO/kAejCMETotoGMcvSsEnSSMSsLcANo3OhHDuevyHbq+Ea +b8HzJHLO7Uu8jxWpNG7RUh5YAzbVO77ppi0PdvQULdOcyvzQmux8fq1zpFtUIUPa +5NKTrPAycSh2ccl6OZbn+xEMUaOxzK5psnCCy/fT2+wYs6JUT9r3IVN3Tk2XKsx4 +ceH/iP/R3oGJ35n4axihMLLJ+F/OEV2etXYrO4owGWmaUZxHTOWEfmeItNW8jdp6 +ozx1SXHm1MfsTWLvoll9+xD9x90augvTy1KO0O9rAKUFkqij7lsGlz//fcD1bi8e +G5CjVCtrQcdwK17hPqxr9dCJAigEEwEKAD4CGwMICwkIBw0MCwoFFQoJCAsCHgEC +F4ACGQEWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCYzxUHAUJEWKWmwAKCRAGZKdp +VCZejFJ2DqCQGC+e3RF5uDd2EYPc0c46RFzCuyq/5dAMI3wGX4bBvv69IqL6pfz9 +H7X+Vqf6xWAlu6hJpRiG/LihkLSyU54BYGiUMR+sQKnJ8uKn/RFpFYdPwxMZdS7p +oBosmEK3Kis4RRywnczNTKTSp+i5vSwvWHmWjyns9LoXnuPJElgZbH2FWjTIYu59 +TxPEZ8G0CXxP5oN6teoWiAvb/3px7YsJg2tP8ca9nm9igKijYeVZ50WyJtlsgip1 ++LL51pImPVxvtfDcEVeOdaWImz6p2Zk1XRgsOxHGk2WU0SeH7MXH3gP1WpGq5xt1 +Uk2M7PJucefZJrAJELbqC5aEsfAhDEIBP9Cj0FW+kWKYs7tpafdZuYZGc5fXa4WX +R2VgK3Ni0AcsNgqgwkQWgMpr1Wb2eQxueZh+gdtau/Epfu+TAQ83TTXjrZP74U4P +o6cAEnCAvDwBANy55IcJ3QGRwvS0M+G3FKgkdAxYW0Ntu8AWx+d3gvShXlmP4VdP +PMHH67Pk0KDAB4IFuHgXh46M+6SYQWAasTQLNPAxx7Dl1uE/7pnRMSCxmF2qujwK +hZtEs5rySNzA2zDmj2w04Dfd/yL7Q+jhrtB4WVKcCDSzHrMA56IJ1Xv0Wie0IlNp +bW9uIEpvc2Vmc3NvbiA8c2ltb25AeXViaWNvLmNvbT6JAiUEEwEKADsCGwMICwkI +Bw0MCwoFFQoJCAsCHgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCXiw/pgUJ +DGZIoQAKCRAGZKdpVCZejNnGDp9mZYt1nQLmaQIv/mj0nOU6PyLhhmbcAXQMRhXA +VC14X+85xcRA/77kp5XJQzoQnOW9QDT80dlZUxmIdLhiwQ0ebhcZUDbM0OpYJRaw +Aa8RhiApQ0hs+U9RjdTCE+tDbIDo6YzSwnuZMRk3tuu2qZ9guA1xv+nkLB9kLuf7 +G/VjfSd3xrQOTNbaqwE/7duyvTB7pO6+TF6c38r1wnuIuHT3XitU7b2/inciLrjL +x4utBtgOSLRtsRub4+PHfnUpPN26D8y+mwsHy1KItEttktxkaDWTfgEjDYELXODb +moFVHYHPVX/c96+lpNslQOq61LuB15LDiICGuX9Z20OE7HFw2g+8sMjXpSaclDVe +UnqwD8/dp1vlX9zqpIFgzgR9CeA6mmv1FniD2VnMMA5nH730ZlzDY3LH74ZsYtEZ +S616QRNKBXNEmaC1RDyocDIWCP2j8UtJN7McfINY6WCSriilDfDhfLCehhFcwyZz +Ru1MFegijZX2EoYMadtodeaQOufVYQKTqC3VW9NMJvaeHmTGgdJtgHK7KXhe+DAL +sdRILu4cWMA8Gn//VTQa2cNKLLL+3/szp9MFtOLBI41QVG/V1Pl8It1mU/NCaVfX +R0RwQbf/AJqJAiUEEwEKADsCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AWIQSaqb2x +G7G5miEoWjMGZKdpVCZejAUCYjifGgUJD644lgAKCRAGZKdpVCZejHw/Dp9DmUq3 +hNf0CkHA4PZr6IYEUWk9E1QgUT1T1lqOMs5XuP9J0CfKxvOOgI80lHX80HQcGPTX +O4+6ffg2MvsEJu3CU4fvjblpeua9T/wtMm1tsIS2E6zDt6F7ibDtngOPSzhiEPQy +g13xJqYXN16c/pPs+jmiE5ZSpBmeYDDEPwuHt6dlD+FKukcVDINxrPSaYFkHnac/ +F7/0/i5C9zUlJSo3pZVg2A+IX4BxTeUbD1wgSZACKpsb8BheQPmZJ2AgkumH5cJs +SAyz6e0eJIr6oFI+BLm3PFqQ/9jVn276wHR/gxQ2OtbOO6MvUGmBTge7B6pq6Fl/ +1UNG7C+Xw9eguWeIHxZUIPOtBpsBqeWaKce79oMHdCBKDSP75lv5FcrPXxZsFjtv +LG39I+RcCyf5W1sj2XJpaxyPI/Bm+bF22ODgNK5sDt7zRewbsPd8B9Oy0owygEnw +5TUyRA5NOvksApLGEs1zXUoR67UIWtfLDQusfHYl1ugcEIBq0CKMLo1tZyuV7MTj +vv1XlNLxraG6j1RzrhHBpvVi1CSJQtwfNsqhwlqjsIWRN0NEzbtfW/oC6wIy57WV +b0JcF4ISNTZ+rL7tCt3CB7vnyaek/Yb+cn1ZOo0GL2OJAiUEEwEKADsCGwMICwkI +Bw0MCwoFFQoJCAsCHgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCYPfAZgUJ +DtwX1wAKCRAGZKdpVCZejHqPDp9ksNAQbcsE6KN3U6n7ZRNBF4dO4p+/DxZXJ1rj +6pLUhTtUVqxJBgsGpYHvc2o2rcuEydrR3pV5CkUlOohB36xqjRXXzDmolbwPfm3k +GmsH9WhgqeOa59a397wG0w45/ZeD3mWloU1LN1Z/XDtGGLBYUilPOZBt1q1SpTQ3 +iTvOYGnWhLZh7XLj4vMNzHVD2GDnuJY3ykzzRZ1ImDONrOl3vRJR3tJCK8jhLgM7 +2yogMRsdLMuEMDw+GDKBB6T4OFAVhurxsX9meX+MCoQUgla6mjDjlAyKYhVjW/1L +TkBCdkQsjWRTsmFnpMA9/vHbNulMLvUgs8wQBTHmpKLbgwH7ietXhFazdqExygNo +zvM35P41CM/EiB7uPLGxp5y5mOc3VRMCmNT7keIXFBGTkgjEnKiRy1jdcwIQaqBB +yDYXQ5lTsOZzkHV0ugM7NVYVP96L2/KfAQ2IU/PtrmMjYzU02WPLT3VEuW8a6T7m +OTJZZTrYWxQfgxe2ubea0eL/+G1gJlpgC71BeimCDfNUiUmxRUc6ugfJP2ki7pYE +9u4DdsalXmuEqmQ6rqhVtBcA4DAfxsXTi6KiKAaU6uGFbZYDR7AIDvGZkDrFUEnO +I94qT5GBt0KJAiUEEwEKADsCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AWIQSaqb2x +G7G5miEoWjMGZKdpVCZejAUCX+IqEwUJDXoKjgAKCRAGZKdpVCZejFRSDpwJQTiI +RDUpkf9dqeIiyyjNbccbDLflzTw8p3aRT5gxWtnzvlhxfSaxW7BfjGRGJMJQjplC +zkrIfBjgn9jknwKo7dzuhT4YshG4cec7MrRu1WQmldCbB/TS97QQRMkzcqaFZFTF +6U908VG5TsQhPzXSHOboybKqyo/LL7Tv6NtEACGC+C9P+f2g+VcyNFtJYfQDuCdX +gT9xxo87XktXkb5GiblPiqc7qtZZh5Mw5HlDdz61FRuP7UvbvAbCHb14VLzXcJ6Q +w5YbQ2PNMJbXv9QS+96vxan+eM94XizrgAEzkSjVskmi0N2tb8k5kJsGhZ4SFChd +BcCO01XjCJVJyd9pvScTq8FtBR3LknxhN+RraDMiWcCwGGdSZJuEIzSeHXVxwrIe +EM+l7+pTkE/3mt3Po+xt+h831EFLS7JEg8+PEwwphGTVtT0Qf5knMOStqWZ06nUy +QSfOoAQyejpzQzz7t4OoUfuQqX3AnGRZLPoVv7KQ077cuwAb2skQUoFOKa6BJf4i +lKZPmLTjwFj9G2KNLcX1yllQYeq8PUGU7oDOf703jXuhpXh7NWBQ+RZyc3IWcJ8q +3vz6GoS0lzSh2TBUUYSL9EWKtXjt6iDpBMjL1lcQ9eSJAiUEEwEKADsCGwMICwkI +Bw0MCwoFFQoJCAsCHgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCXgx8mgUJ +Cqc9FQAKCRAGZKdpVCZejHGoDpwPfuaDpUos2GjRmTTa9OiUP1oRg9AAIR5pnDR9 +pGyL1ArEuC9vvt1sV4SyBEfyKYg7LXwVAzLAQN59tW+EMUgdBt+VlAEzWLLyEZHQ +K5I1IrVGjpPT0Ref1QT90FgVdRCJ/eLs+V/plGcTzRGMdtae0PTQLiZujpBDCjMJ +NBKq3KcnZzudnIaSoakII+zxxAnSDeWER4LWAviBLExIL6LAtO57itoRzNcC+VAc +T2Hs4cmGRmb72UV9bj2pLwkXaWn2RnAZvNotFFtSBC/qQY8jAi8QanBMBvJHX2+8 +TP7hMfnxrLY5FnIdI5e/a2k9GOcufs7YKil18KlfTjTv7djdRsMu2NSvFjHNWqPN +DI/KIdiOD7kjaVdw1tJAaz/9Afend1WPOxUbWolUW38WYaTNiE5yCBRYFsyELZHg +BP08zkDLMyfTwS4kk58MP4enlZUM7RtuU/fbA7LxHziaSJq568EdaxHZcGFYyM7j +M7y2itV2SjEWibz6yFYG5ACH2kD1SxdJ9KDhL6aEz+1oKW71jsibJsIk9yTHPUGb +SHKoKLjVCz2kpQexj0SJg5tFcRLojXHsaCPzgEGdeSJsyUd0SPQ2HKXEkcioswmp +m6w4RRCvXCuJAiUEEwEKADsCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AWIQSaqb2x +G7G5miEoWjMGZKdpVCZejAUCXIDUPwUJCfZtuwAKCRAGZKdpVCZejL7/Dp49HD0h +WYiiwuLeW2Y74c80P9aAnidDFBRKV491ViuamHQhe5iVeIx/yQBGNBOIQ36BjY/Y +YXnF5MsB8bTFx71McqW5RCFvGZ9djmMAp+vvbsT0MhT/ipeLtdOFel8MikdxRt4t +zEFSFca66SqZ1TKSEJFqyepH5hsTrH2oMDaVOCZqE/q16vstuoXMW8A7uiSt2b2D +TrlLqKj7botZLUpLAoY3R7PlsmwkbwP+cj7oqA8rZz5lESIqti9NU9u/jmv46WES +XqXH2qDcOAlgNhw/7ma2UTXxRJAgAmcX8C3aHhWDp/pwsevGB/FFQfHzD5TFJCOb +zvo1ShDWzhU4Xxv4v0LiuxXPqT5ltw6Idt5hP+8/9OSAwfsx/zScair4JioGd/wk +RLybxiQOrqjHSGdDqV7teEnwsd2onB0BTBaM9XIRiqHOn5h20sUxPTenMGGzWsvr +Rq190N2G4Z7R5acabPGy63HyOI1gengDy4uoMDgztcfohgbK/+c1IHeSgPHQjkhK +hVYPbBA4BlZL21OXZ6nG+BeFsT/QVzoesfw/aCLRZphtr8U/l+bP0RhAbA2CR1AX +N3RJzrI+onMhjXHwgdyM7sRLlzwxl6kouXRuQk84DIaJAiUEEwEKADsCGwMICwkI +Bw0MCwoFFQoJCAsCHgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCW2LVPAUJ +CNhutAAKCRAGZKdpVCZejFigDp4gmuN+LqVjURzZcw0g271EgNHOrGMFz0sHgWQG +pZS1fRztrfAATFeUQzqU+nMo2n8CMJpT3VJTGDJxe4qGQHvqKPD6u+Xn7HFTYx8r +wvia6t1Or7Prrc8nnQhtSubeAm9g0iFlwpS5Mn0DkgtPkd8BlsJIbzhDDjlEoWIE +0I4psdRr8KiceUu4kkir+lNmSnPuiOS8l1X0rN9Jp+oTj7uftOETJEO+8pJWBoeQ +MM5YFtA/QBuxnypOU7RvQKM3kMDumPnBLP7WMdzC0xKsBgM7V3phfeCZI1rTI5vy +nR8u80MjrBUzwh7Go39cBlFEpwCCieHrMSCoGp5MfGE6/+KZKV1K6ZI3GqK6xxC3 +F3rITJ9F6w28KBcwIEGLUIqQ5FMGohlASBksMlTuRWVQC4eXd9hA0vNtWK6pHE1t +dRqcjIYS32wsiCgBTEQ9dA2qxljIYYaqOYh23fMLnCDgiCejcknPl40oWRUe9Jie +wVnnepe6e9w2FLWsSSvSe2KJLlV7X2zbH+VPKpVYALZrmpgDfkv+bDl43u9VGc3a +R0XURE73m7voOvBPWVamXOTDDismHIqGYGdsFr8fYTFT1P68s8wfFs7si7eaaBQC +3uaYGWBXRwqJAiUEEwEKADsCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AWIQSaqb2x +G7G5miEoWjMGZKdpVCZejAUCWpO5YQUJB+cL3AAKCRAGZKdpVCZejMKMDpoDpyhv +AbeIeEBFW6b8oQRrkZ/g1fuHNxgbZyZDY7irZPd2EUi8fsUDlC5PMTQgmvxK41BY +Xy0fJvqM7jt+yTRM+ekbG1ayyFogdLb8zyfZ2n2i78httQMyGM9cOhTjj8u/MRn7 +7CrrYIesUSQOrMsDF8fCXmSdSRb47gKzBJlbqvcxBLCkvzwS8378eEzb3al+DHbP +aItlXZutMIfWmAytmgj8I59h2VUVCW885Zk1lwoHRxT/K6MYpTrzNQWqQ+r4hVDl +CNZihEAG8809CCSdFv8wofoFyKFK/mUR12u9zy85Xq/poh54YefAzuLaSEqHU9Rv +jlMfa/3gkM1XWluqcmsdMrt8UexQLeOr5i9XeJ/lpXxXGnaSSzTpjqkCugZFQNti +4FrXDauAsr5AS2Sir+FTDdCgcezbZQC9o9yhldMjowOb8M6BJO/jgeqorycH/zA4 +d/wJmgxQB9UlbFawsmyK2VNJK9wDj00fnlRWCZb2Vol+TcbQw03efL+uiKWRyKMn +ntTrS3ySF+IR316/NETJ8Jsqng9o7GMeR58fykipp4lr/TNG2QfGozHDYbwbYLFJ +FwNQTVYvfzDNivcWsHh++mXRW25syRSQtOe4YlkVYhSJAiUEEwEKADsCGwMICwkI +Bw0MCwoFFQoJCAsCHgECF4AWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUCWaRxfAUJ +BuqU+wAKCRAGZKdpVCZejNFfDp94fyXVPZlSE0vNRGoGdCjotAPxZ8pj7OSiY0bR +0bWvsytBpZ5MQP7R8jaDogdX3Iz0tcWVEqZF3wpyPujupSJVxjONNZrWe2J5NWAZ +QOj6Mb1mal7BJqpAWRy92JiyDFIar41GYhVXDZ24Uy+vEfyTJ13rmBeK7OTd1ahP +fcJtIk8AtW/9l4qBu6QxNkseciFxuM9lM8UEF448GLthmyTEZIeED4JUHvUmZ/Mm ++1la/9VDEgAN4jNPS3p8EBf/ByCITEPOvkJmZwklAeYnRAPfaSeOVr6klX6aBC3f +IBMrpe570XosJBJbqpKVgwp2NklEWc1XLIOZ0+3A2GQZptmkRhQUBT/OFKG5IKYx +a0dujkZL4qtgk/XoKVDlEyVTSqnNquydCn0afdi1WyHIXTeW4gTEa2wNRxhU7aAR +3TbIFOPNj9y9VIKs3XlwpVbdEv3BPHz6176teEn/zkMm6HjvEgc50Z/3kOFpB1cq +l9WK4327h48epNZKBYqL0//9u7OLey6HIjkFGw5jX2c7zXN3ZEsLUoPRo4KP+eAG +sNDT0eRSozuuSFsMZQLfK6mmVGfO4PAWETHhyCl6zKepw/c1A9LQpGoVkxIRmdo5 +hYvVzLdA4UmJAg4EEwEKACQCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AFAliIWvQF +CQYF3WkACgkQBmSnaVQmXowxFg6aAnJ42zJj5Est7eDVfmj0u75XNaxN85nwtXGr +0QwzhStytmkEp6E7HsQwDCeIKabf4Fbx/BK6aufT8zwiiEsoVONB3CrZ8SDL8DiP +AMll7ARHuMbmcBkGybD/CxRcOh3MXgW91qcVpYQ0Tn0StPZEZtklvPXWCDhli51H +hfygxfVlxuE+/NJa4lIfSXwTp8DidsHNP349hmdSy7U8WWTBOiI1GFSYhWg7Yt8H +8Z3xBGQ2M6lD3LSl5xTWdQs6GcLVTxD1iJykfVGxPRlg9CHZWZsX02w9uyanhO41 +JtvI2sK8KX2ABKOo9e9WKwspQXYCCpBZJ7pWInITNUvicihBJJ4ulTFJaFzwy6vg +Pg4VTd1PEEWFIwDs31drBgYdIcC3wzSkmRs7PGLpfYScl9YV2jVLlADJx5wMoeHv +yAo3j7U3su4qKk560DCTjobDo5weUjM2YDZTbiGZH/XATiEjbNKUXe20C1/kvCm8 +g3zX+5aR/djDOO5n4WSyCfE/4txMPmON8FQCxb4dClpj3sF4kdPSSMRppi1LEkOY +8Z24DPWAhViOAxy5Gs2GNdBoU4KStSulqRNL9Rky0ZjzmHEzmmnT30fJL3kXLIrD +2EKM5Fyv4mZNiQIOBBMBCgAkAhsDCAsJCAcNDAsKBRUKCQgLAh4BAheABQJXrBUr +BQkFDJanAAoJEAZkp2lUJl6Mv68On1/pmy3K/8lcaslAzA3hte+xESgRvgNTNKWs +T2gsisswRqME2XlgjICPcR4sMe1eXERpqTX3iTrrluJ+gWd1jWuLIiKeKx0haC7b +h5Au0rMdiBVJT196c831vaJXrRipi94s6As0CebBWpQdz3NBLH7oYAFvmHdlUMqU +moisLxRkzYpI/bwhg4B/9bDpvABEILyMSMbHJqIypDGc0AyOdqd9sQkmx1qmVyBD +dHFYYpqgWoLFTA3ZG4a8ZglTkfk3WzHizoxSlirZ4lE762LAY+r64h5s5Dfr+ism +HWbLFz1A5Cqs26slZtraZ/YszjyhurJ/MeiGEf+aLXM85HlIK0APbYuwBK/mp7/t +Dr0wqoeLv3QruIa9lM76Uf9IXp2V4zu1vjazk2M3JpfqHvFgz2lT4+g0LuKIXVBS +4nfExpoAetj5+MkWmQ5VcTr3wU/dZZmQk3yjUAa8uXzRa11wLvnzf2JqT1G4kcuo +nacBe0DHfMDGpRp2Yyx7yHcmqP76orL5C6NiNI9LjTwpAs61om3+dRCdJWiBKzri +rYs+DO+4srq2VWgdxxCqNTX8Nq4uYq+p4aXODuaTWF0qfjThlVSxH+6iVZ/2d7VR +A9MLkFNwExbPaokCDgQTAQoAJAIbAwgLCQgHDQwLCgUVCgkICwIeAQIXgAUCVwz8 +fAUJBFMf9gAKCRAGZKdpVCZejAX0DqCYXk02V4kv5hJkN+EPTuYZnUkzgxdPCkk8 +MPkpUavNijqDrELrqkGCbDnZpCGr6ePrPJowuYz/q05+mLU0bhP8Tsgug+rtRKQs +wnDOQW9XKpo5DNj/s79goO3Yhun1QuQvZGkAwWrrSD40mTTlM396J4fZnScykhDR +WzDOfgUdaQa/LbeiqcG248cHiEm8PR5RTLC22sYzVWZYBxN8+VE+55xBSojfBdkw +G3ma/RuIdpdBpkQVdNcJcElTj9y+Qn/78GanyHMo7F9+GvV1GsqRkz5HgYDHhD7i +FGhaoKZ5YKiTNdNmSWPP4IBWbM8EUECln3/X5mKXqr5hts+fk2cPaQEYWT5ki0+r +8OJfxjKfEBCZPsVlFyN9E6+buPP11rs9CsxbEufb/UkFdUpCvcuXB9boB0Q8yLFl +O7biKHh4wKK0JywmRFrofSxegNwR2zU5LPwerM+GKUGvT5JVmoM+mg4DgLaAFxqX +wsIK711HrmUvlq32C+oAnvX8ZXpy2182SOL6WtHWu2To9VxDq2t5hsbwQ1JzGxE7 +gDRH+4DUPhSLAsFE45RtA5aE9Y4EDiSokPQ6gMJVhdDO/of6AyLYf6CRURvRfCaO +2xby2g/UE3Jn7eWJAg4EEwEKACQCGwMICwkIBw0MCwoFFQoJCAsCHgECF4AFAlXM +ZMAFCQNkRT4ACgkQBmSnaVQmXoxVlQ6fShihzfQruV/7Ze2xThB8erdfqqPS9eA4 +rp6aRx7HdnQLRKBVOtkifbR+cyBQxjt2SwINv5JolLrndqFnf9K2bOk0V58KS8LW +lOfk+So84H7Z5/nv6+QkRB7nEu/2IPwoQcBH8GxFZWn7jsboBB2DPTn5XIEwLiDN +Ujt8Mv0kFJgvipPZfg5EXvYOkX1Erf0Y6NHDM8AfwG0upZ1IZlU+wD02pYoBdrCD +0CLCYwDGme4puxW3ViFJRT1OkveC2JpaXMfdsDS1816I7raRGXE5BR/8u7ylz1bi +wDvoB6yPiPwMaajf3d5SbouLOGvdVqKubNxp0w3Jx+Xk8Qghz0iPiAz1vQyH+w5G +Kp2WQIUNrC+DzWBqoGAhkH/3mjBjM11eHt1ttOYby9G6zlopDLgtG/hqOaUHIQJz +KgnempJtUL5EUXHGzvFhg2Y/EUW7iOHysKg00GPN9mZ90LTv1iHvU6o7FZTcmVZX +92iMZhcfSz80N2nBRDtq7kxlSv/Jg0vBpS5+9c//9useUJCR1SkeajTK7yMWmTgE +13lsCU+2Efn+a/n+krR2esdmEn+fitGVRYFVmfNNxCiz0f/rC175N4oFVoLXa5ka +8uFO/BesbZGKYGhaiQIOBBMBCgAkAhsDCAsJCAcNDAsKBRUKCQgLAh4BAheABQJU +uCoZBQkCLcOYAAoJEAZkp2lUJl6MbagOn02XhOntT/EWZ/d1SCbU7yjEYqeiH6DJ +6QAFOytg7+ICfpX6xrDIu7e0xgtgRh76DSzAPFaZZFzDHZ8wKdyxJvE8QGQYfy6k +JN6zbB4WNeHdwtUr/1927ToztZLjQrxH9dtaImml80GeRZPTaiaSb1ZrF6oknZfR +WVtMxx711Uu30OcGODkn/KCoz50skpYmBpUt2IbwIdEabq5hMtN4kmnUx07zldjR +x9aHmmOmwo/tLVSNdnOtRq9ghvrAQ0ay6ei1e9OeNIgPHuoQ1evgPOYiGwG23fRb +KCcjTngqBJDmNaBFFICrYSy7ijL0usHQa55RHJ8KcdculGB0ZoiTTDb18nGGVFCM +rZ+WufuvkFi8rwXmQBRDd4WDsO+z8n7v2qvCS6+qcGrTlGEuVGxBzFRsOdO3axVf +fpj2n1xv3jV0OX3MoYZWtOVrL4KAL/6Nu25f7hnjnQ884oobQE5hesRNttnC3IDe +pwdMmnnaMiSw5KSFe3JGI5jnnLWcRSU9oaSmiuDGv07Hd1RAhsoU9npvTUfyLRAG +obVFWLql7tenSiA9/90td/TayjD0OzIRvJ5kIGPGrrnRmmoUekBsn6ICc52FDcEj +bqqmicMwa7Upe7hQPokCDgQTAQoAJAIbAwgLCQgHDQwLCgUVCgkICwIeAQIXgAUC +U/yeIAUJARs0kwAKCRAGZKdpVCZejDRmDp44AkgQvOs1erV09iVxZgEoNKSpFQzd +8UQCkjAH01UwHEZi2bQl0c6Vr43H6ZDNXQjBxsXYFqgHnkHlzVOH0Wvh59N8llyo +qmT3RIUl1b7Bm2xIt7rb8yjqiV5SPxSRU+r1lj+7eMm569lwK+o3f4JiV+jZWVKg +pdctlTmUc9UVAJGktcK810LmgwK3XsJkBU2ZGApSkwgA52iokvw1d8CeRl3PtC67 +vrddKzShw6DXrOwbx08YmzIKO6PxZSNXJg3ThbGmi3tcjV7IslWmWJ3xSz3afbNe +9rJIp3eUgdmue7WdcqnvlJfI22oLDoT9fWuquIYT4KEwlVLKvZfnblZKyR8DKaVN +8yf6faEyy7tlWkHtONapBxqDhxT0K3DUMJCJzsa/3Fp4UeBbEkwtncWf4P8P2KUr +A9SYDvze2RFi5dP36uLyhHhNwiS0mAkIFEJnN19iy3DlqTSQUOQ40y3W41BiAYXp +n8g/n+BUzTA9D1Ywege3K1Jjohg0Tz5o+J+l+iga1NeTd/bprSJOSEzR4EAm2dnJ ++1nkm+kqo1iFM2KVZS8Zu4UQ3UZDg23skhT0EH84FBHRPAuXT566+IChMuuQh3DY +ZdYL8SR0L5+yNyCppemJAg4EEwEKACQFAlOnKyECGwMFCQCD1gAICwkIBw0MCwoF +FQoJCAsCHgECF4AACgkQBmSnaVQmXozGHw6ZATNh3Fz/u+Gv6RwBsuxSWWxTDecX +CtYaufNssNwN/1ceDpye4xmh6OclewLNz4Y+FQtbKn7fQ6/2vUvBfzJqDUBygWlP +HwmztFbVs+bted6gJRx0TUwb2/T8xzfiaf/I3P7xftlMtzp9jytYvbWHFbglbetE +IjGfiijO3AfJoYXCUs6eHLsFTZHNhuxADwifFzqPNMqX9jx91XBTkOQGcKe2CqFl +RIiawU1MUpqu9bg9i8JTGp3JQJJmhw7031I0krYpkoq6viMTRwVngYsZdkfcVIwC +OTQkL+O7oOYeUgdog0rAIwDOTYG1/elfZyGMoEImfpPmXYizspyjEaIfqJFzv1uo +6M0Ge7Yr91uo9qQoB386oPG8t/D6N+HxfyCAnxXsdL8dnXrsPite0tQDxZC+qIWX +3guj5s/xm4S9sIC4PNhJufBnaVXmUCZhxuXbG5b3T2idfmkqa2oa7CvyJJGl2NVB +yXoqIWEKs9v467gDxhwE0A5AGu8Yp3Oj8yYcf+1Jm4MDdWBlwX7KNPdEkQ3mtY1K +hVmZsg1FL6lfog4vuSM0vjfJmPTriigZrWjvXUS1v1aZdgYLF81T01YWZ04dh3c4 +lu7OPsy/uomnhfqnqx4IiLwEEAECAAYFAlOnMqMACgkQ7aIelLVlcW+WfAUApqMV +hygX8dXNrb229wnllWqnKmyHGrVw1Rk95fXPVDoYCUsHFxlfG5cILhLJGyqGrV5g +Hm20czmXFZkmLHT5lC2p2r6CM5zH4855+YB1f5gWmJprK9DqhTvuiQSWRl3ZK66n +v4dqW3VXxL6Rsy1wDaISPWDyvVahQU6DEBSYgtHsegOkZPx2odXQlKEUW/IvS4v+ +akolVs4axMo5L5MeMohGBBARAgAGBQJVmqGwAAoJEOp785cBdWI+dG8AoIwE5Vbw +tFoSJpxhKRRIt+iaRMvwAKCxPgbpgoYX2eNqIpHVA3hyxeUFlYhGBBARCAAGBQJT +7K3xAAoJEHgwLEuNv+wv3PsAoLDsmoJ0NKV45c8lSsnhSeuBSlktAKCJbs8JtU/r +KvwO5sJpihacJBg3sohGBBARCgAGBQJT2DVuAAoJEHIENnC95fHuZdgAnjKfvwLD +gfsr3bt4jgavytp6Gy/5AJ0ZoFCsnYdIX4TVzqms0Ve9I3UMPohGBBIRAgAGBQJU +zpQAAAoJEG7VFfsbKC6aIGEAn3lKMYNHc8IqwVgF/rZGTFXihsGbAJsEwbsZnyUx +oKOQgm4a6D3aTVn+R4hrBBARAgArBQJUuS67BYMB4oUAHhpodHRwOi8vd3d3LmNh +Y2VydC5vcmcvY3BzLnBocAAKCRDSuw0BZdD9WKi3AJ9LV/V9gawy3t93yBrnK4rm +GcNCCwCfe/0FMVjZ57i0+0pEIHBADq9c4GeJARsEEAEIAAYFAlOoLMkACgkQvKAP +1LIWjAr58gf4vZp3EyzzC+5b08QKSmEdbPkkjpwIEmuUd22lrXEZmeKitkVl5i66 ++HdSY8DAzqS+LHZkmmWoPVvkxwyRf/em9ba2A/ap1cwOOq6QuDmFj5Wq2MkG01N/ +Nvz/DXOgpUNGkcYG0JK5p0Orlggz2eWkk0tT3S+Ay0tAV++wKko6JpGdCmj42yLG +vXE5slIGmtjDp2s4WBB5z2mjEFl3krzruvbECcfRXQyQXwdWgq83n5j4C2r4vIjz +unjWT9DS3Dqp53nZw4+jD0dIgukMT6JLhZhgc3UlnrKKwF2AywqN1Zg7/PnPHCAv +uk3CsHhza2aL76uKig7NTy+dJR/0w/gbiQEcBBABAgAGBQJU2Z3SAAoJEHfu3wMX +9VaQAWwH/jfg/zBf8Rdvv5rT53sIfXyOo/laByQ16UqrwiliETviV+YT1AKMX+SB +/eIuuCAfYvgmcdu83sK0UPBi9ceFLPFndQU6aUBT+joFwIKMvcNPngk9pEKpw5xe +ecWeAP6lklMuPSTn7F7YWDcgJzWZulHbAXxLXjICJx+tvR7TKYWqgF2ABb4jh3RJ +g/rIMfXZRH1gvm93ezm/mlWSKX2RNA5r94n9apd79Q4dIUfzRfCY7Iho9rLFBFJj +9UNRCpRxvyaO+DCtpV5eZvYfktTcub3dTI6cYFv5/2fKDi3qwdWpR+vPueyK/Zh6 +qvX9A4je0FDLo51mKyvQQHqA9xAzzbWJARwEEAECAAYFAlUhS5EACgkQN6lQRPHO +ZESCwAf9Fk/eOnEghe0FSy4p37z/JzddfRq/j2Zjv8FpV2ThiSyoQ6TIC2CKIyK5 +D0ijM3BDi4Qvb93LWEzQ6pH7x4bglR3gNCUiAdZQkLaYk5eGpo+Wy8IMkFABmp0V +hyiN96Cr7p4UcrpgW23hxCzNrHSh7l2obBWF3MBGKbtKM17SUffpcs1O6g2uOmEd +VXxLhxvCrNdvUDAJY9y3mEN3VzohQmma7voR9jsYwvylJNu+T+syFExthzHWfYHt +fU7apMruiljvfYwTtxl7tVJmVEanxgtr2vAK0gHXQvHOwXRSe9mvOYNncLg1drVy +mYqjodOGLKnzIC9TYMM7J76SLQSwpIkBHAQQAQIABgUCVScjDAAKCRCBHi9ypAEh +k5bOB/4pT0+8up8c2jb8g8PND56X6otf4I+KBi7MM6QCGY/3AhBjb7ElkFew3KOd +ngPfCt4M9BUNdQNu5yW+OIynvjQMZ+Ro84VjejdcTM74WRwiaUUHyDa6i9NMwSfY +YfYs7DP+XEhY1APaYJuMewrnCNopUwqY6NIoZynWWPa3NrhWEYefevkkZhl3W1Jj +VJQ5Bkt3T1q/7DSsyi93x/XYi/9ALS4lRNpqlSJpUnYi/N+cucF49XsHSXVPLaVv +/UkvxaWMgox0ep/RH7Egwy06+VS6GcOdeHtn0YbUUPSzGYeJvYLr/1JUpSVuVSBY +u1xkFTHyVjQjGuOQdp+F5XLLwcxjiQEcBBABCAAGBQJUrmkwAAoJEPBDZwlvupXo +iGsH/RBaSKxGHCpkgtBbubmVs+QQjZVzswtqrzxe9z3XqY3JG3sVUSEJLgjKi6Ph +FN1mAbGUMAeR7hpd8eL/S88EwwtjmUrY0Wm3IIlrjocA5f+J+eRdPfb7IuzQxSRm +1oVxWGS5hG4mo4mWMOqL2goj56598N3Da0HP1Klt1++HNggo5UfksgtEk25clKWz +2VjzKvZtk8YroiKXhHy3RM13AFRmd4OO7X6axFx/BmkQladFyKRAWJ/jGBQPxxzc +jBgGwD/fdDojDMRH4VJMQ/r39WC3hhg+IS96R13x/0s3/CYV7hflgZKi4LkwJSFO +1x9CCDsC6+Cg00IjPnlv4KoUhqCJARwEEwECAAYFAlTPbNwACgkQdE46z688+KaL ++wf9HOn/Uhoy+PJCsUz2svT64hDNSnLH5FnhxkfwMt53Exhqe8eEhfThoXIsiO1b +a+C5rYlIMDud0OeYsnQHgYyFlsAUr5XMCbXCYEzsFUU4hIRVfBogWr0Rbiu52EJ3 +Ev7W9Agy0S+wgRnpdtfZ1XQLDf/9qklbpj83vIVZ5SqMveFir996YPBzOVyUaLXT +VXYYi9qj46/+78E8IXZ+1d2wrrJ/uNxKHvf60AbTGKFSPNyRnvllk+16Cbf3u+4M +Y7F76JSnpbxOgEBbKhzJDeeOnkyYfn2kKYY0lXGL8eZgubkVh+3CXq+oXTIMifAd +iwyeuRfG0fzXyRWMnRRIWxyuG4kBHAQTAQIABgUCVNV10AAKCRBr2WAKWFTFheSu +B/9HPaS0vIrz25grTeyGKTxCaioI3V2B+g7Pww3U/RT6PtbQZbWLVCUfSpCx5J5r +2I8x8jDTCLVscJIlx2yx3/WtJj6BIwGCOvwWPDcCb/sjySCgfiTUcaKExom8Y74l +4PdGL8aYoueBgdhQ6txsOC4AMM1ufZLALKlQN148wy8F1hX6Q1ZDVEmyt38LujRZ +aZMEFrRW9PE0u7TbRGsr2g4AzwgSXt8vwix64gtb3714Il1lw27UCHudqpI+aSSG +J+qdql3uVHYi0nCWp+Xyxhthljn6U6XZtcD25Lz6LMpkjoNLkaT9RgS4HECkCVUu +TiPq6ZDvWeDOGeAf8VlaqMMxiQGgBBABCAAGBQJV2CmPAAoJECnuWLmWhlFxhYAM +HAnyOqy1BSgG1RwgI+oi7ZFlvHhxuifohWCKnL8RQ6HiFD07AyEZP+g2uLJhjqU0 +RaI2uEsXQMRUp6xtswnEy+08IagtpN2b1akDdq1Xi6QnQ2U476XU8sP34h2CVQrm +gELUISnzmFJNe58Z/GfAMrU0yPxWDtA+/fo1W6l+fhWHLgf1LSvLBAlBluojxiSZ +dalI0EQ3DA5iqWoRGEGDzYms2H72+XArNnZoEFA7XOrQKHsnFNdccm2sH38GK8/w +hPFeFWCKTbesgRSLCbFOXipgRLRFWXfAP+TIxDErd6+8jnIUAk6ef0HCagRvy8aD +8RL1ACanh+rcjx4034rZeXDzGJnkKlw1Tu6j07HD3t69ZriZFwMlYU3mibzM6CLE +FLQQhWNTbRkHtM0lMIFvEyeTsciRaCyMpz9G7MNnf0sgSsb92y36H/st+dyz8t3Y +OIscuLuVQzqpyeMefT61WwGPeBU+2YzNoiltwYoqlF8Cn+MZrch6A8PVX9LhnBNu +FBw6OK2JAfAEEAECAAYFAlTOqWEACgkQ9DJRnSc2ItclLA6eMFUWeI/dZ57vD8VU +RlnteIep+nV43VrzSXQS6Q3jL/poqd7pzE5BrujcUHDJXYLxgg4spoqhk9eadhRz +xzBYwQH02toSRQi9KJj3wlLWVzSMUFRjY/XNSQKbk/lSPYzuy96oeZudYc6/hMw4 +dJRdgrIrFCEBUMe3g7JyG4GiOI4eLY/TBdsHaKArELeSHm4mn8MgR6rTU2rC0E3t +3jDvndFeKSnVRNNAHJLRhDJxWFEkm35fczdJZEsa68YsqwcOd7YkvbDIh3tnMToF +vg18wzcmIRFf08+fTa+8HSgoHunH0Cply8UyDQDMu1s2OVtjWaCwyJ/8ZKFQeiFG +tn9VgNe0XMbehH5Yy+zT32w3yAZkNZOZhDPStz1wWqhX4uGutrowC9tVjCWfYjZ+ +orB5IOQJP+LfN8m+33V0WvPLy9qfWl00hk9pS+bvhOg+2Qr2uMGxl+GqaiHSF9+a +SJOuhkPDW5rS/7Kgpoliq69r8VBCI1t8EGHpVmVPyUYya+4pPc6DORsA2TbmMgEf +RI1jHuWD9QzDzNURZk9DsgrbttVAI/XWs4X5Ozgch2QqCYn2KvGoBJMdPO5PM7lR +RE1/Zrv6VhyCPe6vo2wb0FVUOmwXahbXiQIQBBABCgAGBQJVXKcCAAoJEHLadcYQ +ohVLj5QPoIbirS1Uwqo9INdqQZtfXq+xu9cY8YaL/SEh5GZS7Pn/T2uO6ncpKObv +xmiChUPB+E19pSSSU8rQLsrCMPeZzNg78vrNWtY8pGdIdGoyUDgEvzny0p9WltIj +ZHw1SFcTj4x0VMTcwq0IhYXZPHGYRZTxknBFt7lyM87QL8Hf/4jonRGAeUQ3sMUA +2VFEuhYn5Vad+tVVRkeP+JckB5ZZ6C8pqHTsE7Zjc3CDBaYlrmATDICBYzSAx4ML +OnHpvCMFStdYEU/VA8aeos8+s8MXsIl4rSe7b1ccg6FB1HdGaLIzps1omDakArha +3XUjf5MNRt2VqZ0n54sgq/eh9dlfbG82vzg49kwPEvzI4XHw/jdTKx4jkZKlFyVi +9hiZrj+GtBdmSjVixvTObL5qkJnlqauEoDG0VzApq4Q1Ct9C4vDxBgbLbH3ZvAUt +Lhpy/iDsNxXywghBKgHWkYuQrrTUX9sNO/iwozzsBrXoEtkJHXI+p/wYMxXLhiOy +3t54iI6ArLAzwXNTKeIk44BSpVORHXT3Vrg6vrcWO5gzf0U49Omt2PDlanu4Hp0/ +cTqz48qnRdspn6NpXh6KAS2wekf87iDhVybAqdxY/rkZfMDfcDYyOuSt0TCCMvKO +a/uP2CzZtnPIuOGLbPNG4slmU9twSU5SiWQfiQIcBBABAgAGBQJUzlgvAAoJEL+8 +y7VSV380JGAQAKA0aDxI6ljc6y9ybo9twgZlxQtl7z1BI/3mOtjZ3P+YMwTCqYGR +2MtYvAJIFKjCUKC6mq8Fne8nj0oBI8YvcxkZhStINfR1SaZdEXIVOGzNr+oYl1/K +snWk443n6ZmmXiKVkmaQG+SeInvFp77Pq328qIujCPGTnchO7Vf9jpIJLhQ2GWuQ +Ji1aVKZdPYHb2kTQZeUbgKUyQTwOb37V2JmpbeOXyEfcRIoX5NvPhx56pI+JnwXL +NII49oeVQfNNYhv8/kZ0DbyPuzVYONO2uAGa/KeCF0DmH5H7OSgXRlZp/S9vC8u5 +60mzy960d3rBgdP0ZLSpu1dDT+YYKqI2w09uwAp7Lv4kfMCk9eJqxswH87caRPeS +qjHqL8wu0QI428qo9w+r8EZRDtRtiFx2FBE7Z31Wo/UaiBMpLqk0LOVbNEzgKmPg +eejd1l2wJeXyH3xMmc/ViS1sS2yMuuoAxmmSa9tGvnxWe52wMkJsYAOxwCBxDHSw +7KrmSYAGh2tdSxcDt2zXTNi0FWQsPa9B/qmjyp/bjCbg0cUer24BdLhZRTHxda6c +vdUZV2e3x1F9UzXGoeasN73NwnfYloo+8qoALc5rxIxTkyrHm2AZLf2gvkehOBDC +3mXQhqSkqaJk+8KEOgW60/fd0WX1bfrnRCucKApCtpSV1HeqAUxi63cLiQIcBBAB +AgAGBQJUzn+0AAoJEFdKroQogrNpJI4P/2UVeQez/PLSXj6u//E8TOt5KCpzdPVP +ncjYk0iReB+OnqFZZEB0u0HSo2OSpqIaeLPmmtFhmRZ76x94J1kEECunRquP7bZr +mGmA22tjRsqX+abIDPphfpFjVuWeCGUiYztJX2Dklgpi+oa+xZcRiF7EfknhaXl7 +9OmTemGz2onbmpqvoGDjZINwTYbdHw9y6A4wPCIac42YyvOXI8zTXoCs3lFdnjt7 +WOrSQBSCsOQMLaOLkOppAvcm+16U07l1XgkmpJuaUixF8dBI/52LL2XZTQh+3Wrd +HDP7Z80fADDzCC1OELdAY1MCPRffKMnXYeKtSmda0vcxe2zkv4n6v96R3MBTVmE4 +2o6fNMarrv8K97ChR0VAzn1RJQg4Z9AcexHoFsPzvFX/ByyG3+e1oC5GQBPsZ2IF +ItXNLH0+O5iyI3Uo//TkpGl89opUC2a/6UXSe1C4yz9yaUAHny4Tkz2RykAXC6sL +7nE3szQOqX50clIryyZs0sva2wMvY4/Y2UzJcii229QyZawRR/YmIeH3epDK7XfH +IXBKXxZYxYzSEDzOMgtZj0GbqXtK7Y557dWLg2RT/ZvjY0JTxzA/CZoXTLTfhnDV +bV6Vxru1Ob+lys2g22TE8pan4aZrHv8KABr32WXeq54AdpXMB8L7kqYl2ul51SCh +0qi/tJ8LBNFuiQIcBBABAgAGBQJUz1LNAAoJEGbArd6LRaxBafcQAMUi6C//GkU7 +7kDxHh/mC+Dzeexxz+eb2x73C27bmh9XOP734oJNWQ7m5zKlG/2Ifc4fj3CZJONy +NsmYdVhdwo2v1a9UVh2G7hSE960D0jKLgsdL/vZ4g7xcw8QixFDukdm62iwhEljF +3fN0dOP2bgLmPRWwm2ZdOpYV01HjgKR1WU+p8CSfwaAs61/j+m9SNKKW5CPtVV0N +nwN0Im2qChXxumEaiTZk+eIJHmo3d1kSHdDW3tp+DR7pKPIYkRGz7MoePKAEebwj +ruj+Fbhwcv1N29HfWHfv8t9k/PqI9zx5FlfNelAXh5Pc88BYvUQEspiZeosA2h2u +36CyXaIZFqr4jG02M515dtvGh0TEBj0gkKPjEPkOr1K/OGaNIjKBKpokct8kja4u +reyOsc6mchV8179yG4NK2aloFYdoc8vGioKeXSk348EaCxqJCNjq4BYJ2IwhvY8M +KfMwvdDQDW+klMX9zgjfiBvGWskN8XdUbFqC2rkQy/XuWZsNz+p4yMJIw6eF1KdC +oWwUStHPxmzEMSe+a6XqPf3CTOFCL1Jo+/pdeJbLfl1hPq024NchkOIapMI3DvhO +o/p3XTsXZeodsGUy/OTuTNh1HsBw4WLFdseWLNASaS9fjlJwqvFNLgLi/0QQgK0A +LvszFjoAQ3ACECcHMvAIOpha03EuIwu7iQIcBBABAgAGBQJUz+APAAoJEI0q/d1Z +r5BMIBYQAKZylJ37DiehcG/fKINuYYf3D8eBNWF++lgPa0/TGDuYAijewG/2AmKf +0X5M3kV3J+MFEX4C4ebbR19B9WAX84uBq6+C16jVkSH/pJnSqPBYh7h+qlojUNkw +oJUEZIHLaRDrUEVhfF9Q2DIizeoI02Jy/GyEJUEpi13faDvTIF6x4IXBqPCBrec/ +I4xze2RjpjMflVpV5V6Hyoh68AcYN6JF36xXHNfDm2/yj6OoBtd3B6ClaITaqfF8 +m196Eag3PspzCHNFu0rQvnUk36QFp2tYlE+oJQzt98q2NR2LRfKocBDkqqvPKV55 +kq+xStJNlsCf1yc6FHMNmDV7SRsvMO5tE1TuWcn/uPtJS4/HHd8T6gnCLKO7K+Nb +B9x+IaKq+DYslKCNara7RkJ5yAmqkt0HqsMXeVnUJiLBCSCzbAutrdooNtUomL+V +gnKMtE0urx+9t+AkdF/Zepe/6N2rQYUOdavSXUx8CvTeWibtf3uhbbjXlJGIoQ5j +eYfsx35NxEU75H2knHyl6l/0CFhYx0prwWv0KYF55x3TzAM1Bhj8qXEDKOvgjOvm +EtoJ2QKJDbkd5A3Ejq8gUgLF1a+JxCcGE1Xlmdb8wzfK/aZoGnoQ7WdmW5D/NKIW +FxiA85olSXfi/Q+/sdke5/5G8NT8Wa5GIBb967bp/y0gWVi3hSuGiQIcBBABAgAG +BQJU0OecAAoJEPaFUazsAhFFVu8QAJVcplFs6v2h2WxtLvLbcORRYcL681SYZ6Ox +L72tuEOVrGXdnTMfP51yXkLENUI6/hx8hBspBTAjbBNf5EGnweHM1HAfmm9Zpv6c +Y7YOQlRfP2WleQYDPQmo4Fl4upRwXnl4E9nzqqP+s+O8dMIWSstid7h1RCs4QQkV +dxgMV0YpyCzoN2D+nZP6/XVtI7kOCWRRLq7PG731gV3wk5TVK49e1BsZ1Fp/66EG +Ib3p9FCmb1kPxus2SeS5BYOfVyI3JED6SRBr4H5LjwiToAMRHmQ+dZwe7slxMSNW +VNT6sOtgD96UnSbstdWCDojEta4hfxqNrhRMS/EjqOYqimmFKlzt0Wr5IidkpYx/ +zTOZF9dw46fVrvqR2oAytWKVj6RUv4no8wrQgx5ZzWrghHdG5MzXqAP9zO9kDCy/ +9houxIZ6jwFpWbhrMJ+6fVFSfj30uAq4S4vtPouOMGXu37XE+IdS89O7A2UaAE2k +raFLYS7x7XtxbNR0qTq4ac9nawIsVQtfDwllXLbyxz+8K8ShoxOqdWOweZhrZYKu +8BcxfUjCk4tEGcDfMR2ohDuyLUO5VNYm/ZXh6dCGLJ7D1qgVmRo62InaW3kzmg0J +jlkoh4mBDhElCEu7hYF9aS6AKK4xjGQps+xG1MnQ7rSlGxXhFUU5Mp0umeHmWgQ4 +LsrcndOGiQIcBBABAgAGBQJU0fNVAAoJEC1BaJ1RnLQBRkIP/iDGGIa2E4tYAd+F +PTJEhx/11Doisxx/TfI4Ob6A3NYa2Wc2fRyflCKZVxhcXLgxc+r0mXq4EGyg3ckt +dqjIxrUrjaG6CDNueR04Pb+MLovbkcmKojCVDB4IJlydfBS2y6ETe+aBc0QcYqlX +g+s2Wvj2BK0Yjwx6tHFj/pR2ivV5QsQTORsdGUCG2gOHIkbtizjYyDFQhxDodSa+ +S+mPwpPlVuoQvD86i5Rr+rtBRQ/hgp+xcmYF9XXTi5yu6Xu9hkPKV8Ezf2/AT39s +awyOI0vMJsijRW4si0IuOVzLR/WmQryl6T69P++pNoqr+cjUjZzFWMN1t8hrEBoL +qSMByDSjP6Ph+NJ5gsozt1K8gc1fCsQy4I+qLIUQObqoWXj8tjQj3VxXGQBs9odX +p9YzylqhvmCEgjmTpP/Q9pRlubXTbFi5mYC0BLK64dKEojOIKwA1S2EHF2tn+NAq +yXa44YoZ5LYFsMmhVRvXKy3D3U18rAqin/5gBIsr9VEzdyeY00bybrAxeDEWRr5A +2gQuvUGLqc6N1KYcHDtpKHzZdgoFN49CGSRmepD5W32I4egDaMplADzp2x+tE44g +SCM2WfmocJGuziaLMeDt+re9GNCchqZMSzl1O2828GPzc3XrGVL6d3QXSqvL+WJ5 +qIsuNtJBXrVPpaSdMcZetxCe9S/IiQIcBBABAgAGBQJU3+68AAoJENE/+DdOy3tC +8loP/2gx0IHpp66gac6jBSLFcZuoTTsx3A/kGnAZU2jXEMIG7lxQ4yFXbwA6HpJO +knuAE4dBogpH7nkGi/gtmW9keDkdEB7bRYThY2vnA9VRj97suU7QTpXtnuK1yHjS +VWLTyZjr8MhdAs4LMkKiPGLWDSnnOOXmpQ72jdAwfmMD3Z6/2aAfomBsaoHuehnk +KpxZtLnBHKHzfnp1uZxM0dHWJDJ5L1/COHnIIqeyFAWFxTtMWTT8Y1vjepy/AEmk +E31BUt/iTB6RePvfnl9eAdBtyp8RAgTJkQe3LaB8xg/wVbxzxUOzpOM2XXQAJ4B5 +BkHi9aPTyT1jYl7aTRBpqut9pSiCDI0MRMONGLGFBp85qaDY3Q3muV+rOCsle9/C +CzdRyI6wlyO6xJDVygpTCQnpiTaLBXHogNccSQIvmHh83Q6V6p0blklU1rYt+gFb +bgSazbhmD3uf37VHIoZLg4+M3Bz1uc6E2KIzY6MnozDGsTFaRLRy89u/vz/C23Ox +urMRwTziqlJUaZMEBPnv/vwboIbekH/FIaezc3M2mMTpcccs1d4p/fl0/tJC1yqz +x7lZ4uTkBrh8quhe4gpsWxnanCQ6dq1ngfO6ysHuouxIYIrYzllRDAuYw3iaiR1U +E6Eem3mEyfYY52C6p93xtBBAEsOWOd5qbCqU2ueHx48kU5VQiQIcBBABAgAGBQJU +4g96AAoJEFE4ioeApB92ODkP/3qKAuNSH7W3XbPTZIqQ3GlVZbwvkERERjkV+rCo +MYzTMx82OjtWrLBGMPDb/9Y8K7Fte4rhscoE1CwwZKqHvHOnLtP2EC4Ya8zNQMDN +xcbQDyzDqqvUKlSAObNmCPLvQ6+rbcOFOmZqbf7vTfIQ/aI/ureyR7Fh1L14j1wM +XnGo/N6cmCxzNtHcXAcs7+UYBFBz1t/ZV5rts19Avl+f0s6iNwH++xIHm3/aGgaT +oZqPJrzyBv8S/Z5hsdVDIOyVZhgVf4eLxei56bao791ctsw6275R+QWzxqS8po+p +QW1WZTJHZgtlVhurIy2KcsTaGYLPLjoM767CScVbtBeUqp4LUJ/hiGm07HK+hFu9 +h6SBPK+vCz6ye15ZgIQf83TQDvajmEZKl3Cq37VhNIOMNPaDSXCoxGHj+SxFzqDK +UCjie9SIfTzVK2J/hR2zuEkupHNKT/iQpzabEnq2fiAmQOLr1HswL5imM5SyT5R/ +xQGu/BbPiCUrlOoXBY3Bb/aXgaJ54mC2xC3OWt1R6dExY9Q50FRJNaztlKKrG6Q5 +vqNef6x2F6vKP2uGMz7VvCxux8vkkDEYz3Ejm4/WiNv0RHlSSEs1+Y87WrIOoZKC +rdhFTkg4fF8ON+WUpOPfTO7TVWeE/7Gl3cfLPw1TCpD1/TmNZfWEUffrzTi0XCMc +W408iQIcBBABAgAGBQJU+2vAAAoJEH7eQttpUbT6LA0P/jELjjeeC3FdW9+iW9kV +8Qa4c22dJ75Ltx6NVGbeY6Vu9lAARdzZVKWgCy3/ixp8N84g/fJ945eg2ptVn9Bq +k+Sb/BKlqN246FYotYbIkCNvmjyCRpw/4N5tR2QHWmTWfisUlgSvyAKegL9iAaty +pK/6eIm3jFRs6ERLZeVebBo024Y1JzALB14iYcMIbb9UpzeGkRkTF9wcqjrHIIvF +DmGducDAAckMf3DfRvlFIgB141vCfuHixAmtz5E0KdRWiKIuo1ADrUy4TPvTDxgQ +MvZclKIGEBcGbeFLGrz02RBiid1vyI+HvCH73woIkL14pp6HQIzxCXOzoXRF0ssh +I2/8KQJa519JXoJEnSZoc/GKBknf+zRtSruITmUtrWuJeolz9DMsU7m0pzMyVuD2 +9rWghOq1hT0veiGToHNRuKhj9wk3kEdbT/Osrxm0MLtFeM7lcIY5RHGAuThPr3RW +yodfE9Tl7W7G02Aoii4bZW3wx0kb+okio3i2ydERXXYTSGMOtiaHew4tAzvTIp/J +LxyRYLWU2/tDtFnRmKsfWFRJHZd7JJQoWV0YpPoCER6TwVJp3WXsvZriXAHxeVND +AeTVDh5lkMOV9IrToBC5Atq6AW17kd6L78olC2Uh4wVf8kdSuMj6U98f3Fy+NrBJ +/tc3QrGfC4uAjaNsIoZqbrxZiQIcBBABCAAGBQJT7K53AAoJEMQ1cPgMwpXmbvoP ++wZpICh2MVS992iLp2Za40gT3lCOt2W3xm/OKZR1X9kLdKPYGEVOdIdz1OdgSeCq +tKgjNTZcnnqPY/zZWXlNDDQEKYdFAx23p/YTN0Y6AD1cgkPIMBa2XAi4/OjixEmI +uDg7L078pk0mdpH9CDC5Z7cGMYqSgTzgpMbQ7P0NLvn0mNZH40X2SDoeQ40+dDhB +8/Z7CwVTJOJkQJoLWXNU6rGv+9k9z8e9jiE4l1PYeVI3ItgPVC8tiExCCQzMyKvH +JQw1mRkyV/9rT6i2kQJY28xkmz3WJ5QGss7SST78GQ9/nJvBIcJEMY2bsTdC7QjX +nXOXBws5z+dzsP680lcBJThQ/rgymfxf3G8Y99LMzSaGYWykujzSIkBVojRREq1h +THH4tr8Tsi7ikbp8oYd9QLZf/OSRy6S+5QPxSqNIVq4U3Ygfxs1esXE+BFR06qRs +2DZPg2BRF8JsYafk+CQbCTiS+tdUfW9srmYYbsGUU+LULmkalvtc16Depm9FQNkI +1voJPkUTuVgxRPsDB3kLoVv/1zF/wJDk28wRxbJIU6p33Y/V/m5dkQClWgNYngrt +3IsfPFkVPpOzNl/Jzecb3W4Q5GL7lHTy0xrKbsXpbpJTjaefvezSZjBQla/yQIa8 +UoUuziKQhBVwqCQ9jAiM3nI3+x4ksPjodMTqXH5urSNJiQIcBBABCAAGBQJU4N5J +AAoJECIny9ZMSXIYBnEP+wSx1owdC7oW6OTDByAs4ph6coEBT6JNx+5pF/hBgCQb +8jO7iUkOLAZVAHR35+cCD/p8NfGN8QBrD91bYSxYHjZObA/dO5d4MauEeBIvw/h+ +1uv1GNHCDyjCxkk/Lk0XqRrwgDCEdhOQPwPlq2qEqaeP2c80FKZB3DbNh73+TMV6 +RkkwK5/qWzGDWbl8ITkRz9+B7gBasbJRr4qLBtLgEu6eeGDIOtH3z0kpZa7aRuqZ +LOcjS1kLWQyVoza8DLggyHG6qXEgG7U7Hw/XFO5vB3L3wOWWiFtEodTHsazKqZwM +zChXrPV21dSA4ig/Y1YPxVJwLFLTbL3sEI/6kTszT9Hl3Pz0uH+wOIza5ZUvPYwJ +eFVNbo95xUZqfYmtbOoy24rfZFjHSpkMI5tOrkaZ1+LEKmfVo0sK33DPkuKuXVk8 +FlC/nvc7KnljhoLovRegVX9DYXi25lx+ybMuzGSR6DBSIrB/vBqxWFmH08L8PQWu +KqPG2ybjMQiXcYN7beG0US1F3/+AiA8Sku1gMOxtiuJM9J2+9PbAetsRZUwN1nZd +zSchQcuGW18mFD7oQdSNBOhylFp/KS7AYgW/OyJlDvioVijq96jXtd0NbfYZPomq +qlXQs+fouzwIVDqKFR449N0plNcfojyZOHT2ILgwspKG62tfsa/BvYSPKuG7goUD +iQIcBBABCAAGBQJVmqG2AAoJECIJ1pAvlpyVOQsP/is5vTnfNRZw2A2YhFtHyMXj +PnBTtFsYI8plc5/oHmbCQI3fat7D8A/NyT4SZgUSye+51FRQi9iRJ67c9CRZTgh2 +hM2INfFIEBzrAWbrZdW56Og+QzyJGahA+PxkQQl5zvELk/Ko34GRrre8QlUWw+UT +IAwqeG0FnmSG0EpmlnrwWw8gTEX9zvodutdO45dvsOEJi9LvWJhPnYILUpQmA9p3 +8Ky2W39rJefiFEkDsFUXnlJwnOM4iydLRfQGrZW6kOlZ1J2wG0W01u3yX4Jh3wpK +Ic0bl+hETF5fcXtAlZUYSPVwtX6LBxf9NMEUFwP8LcJRHLoUlDULKpbYFHGStbJJ +CI/EyINjS8KIudo13frVXr8H4c8bdEQahvPVQnM1fXQJNyP+bocxsvOTH1g1TEMQ +Ij315FT0g+iEQtMntu3giCfmA2c3Cd8su1Cu/uw9H2Q4id/Ipm1kWOa2jU5E2Hsg +gzB8cQKPbk3FLb9B8Arpv7zdlBydpKhia0HinlKcCBOOVf4B/9QLGJzCezgx1Zas +M72TwN1y91SG+DHaey2AlMFaH5r9QpkQFA457IZs27Tco1uDElugGHZGpAdFwPeY +IC2vvar9MLB5PQ5+JXbFIVh6N15Byq4K/rj8D/gVJmGN7CQFNUulx3XaWF3UGoi0 +nLs6wANpF+3EQw+ADmsOiQIcBBABCgAGBQJTrHX6AAoJEH/Z/MsAC+7u810QAKeJ +1zXyEq+rtS04pZOi/WoJlIcXVaCshE3fMKxYZp5m8g8ojc739nFtCiUZ2Eks9XQ4 +w5FG0LdHREKok86hIO6mNJ6h9u+CHzBSWWvi/aTE1EW20r6m1z68pDCAwwlSKHiO +iKT5aWYB8JDBfQcV3fvAEjPwwKGTDKWurK9o4/6Lq5OW61Oh4ByIbRP/EbssiW5s +rnnAB+Fy5tuANclGdaNB9D2O+BrYm6/CqrrYZzJuy6wHzOIdL5lvujriGmTVejj9 +xLRrcgXH1Dw1tzgIbm7I57zVmDowPDGYG8Kd+zl/8A2XspfSAIoFfugvE8DajHI4 +8+2rRGjNasrQQoPvP71H5JhEIW7r6NmdL6zg79T035XlPlXpjPMzUoqfBvegRQ32 +t6GqCvAyRncyCYdOEH5lFzooFZYOGfaGFXsElFzAxjHwz+1EbmwKPH2yW1QdMn6L +9bEt3RRBUwuc0JQc3gJPa2k10SamhFSLX5q1Mpuw3frzCikW117yCm/K/EtwEpxR +B1AkGY/ozrZUPjSqO3Y5GV8634Zoccg9uJz/U+KRIXqqCkpa/j11k9JbVogH5dP3 +IcnvCfSsUQ0Zb7n95liNOX1JolxaQON0NJOLH8achSjK8BCIBTt02JWUeR5Ux/MO +gQWIVy/zAD6h8c5vuKShYETFwZL3Twoz5Ndx+pYfiQIcBBABCgAGBQJT2DYkAAoJ +EAvEfcZNE1MGebYP/0ThLZI7sJkHV4bk1aWkGo6xe1cOPi0x5M5YJujb9ZiQYN7M +57qAVzKiC+580c0aL2SvaDFvItbPeUXlQ2SIxBJ+LTRsXjkzCPE2Lzj1hTWqWgw+ +48KIWNqJ0rNSOlDbsX6H1BV+2HOt1t3Z0sm8OdtFTbwbpw6wwE5WN7lVSaHOXbo0 +w6ee6zr3BAVpBhPWBgb9ClPgBcWB9UoXO+hg0iW3o/Cr4trvTz15dds1yutiPRlS +e96AQiy3krozviWB5Wp463XssHg5430DheYiFVEtQ7k7nf12ot3zgrerQDjqNaL2 +DYAwyhMFXxpKlP3WFU7AwWFxbYTjyo61WUu81dDdU8Pgytaj6QC+v/fJ4JkO9hBJ +qRE8RbZv1X2T/KnMebV2Cl8VZxl+O++DuldaShbCQVDv+1J3LhNJRx1qTO/xOA/L +MJld4rWp22vMJsrMKynqJSG1wJ3utwTquBqE6U0UiXc24uVj7zAM6pCyrt1+m3rf +asGBlHbGwdnc0zI6sFVp2uEgReonYXW5pjzjR5XsKgZpiEkiacuPS4zCM558JCfU +lF34AuYSdpVblW4VgoYfm8grxFFOKxpR7I1oyh3J9NiGEc64lIUaPjArePjEqumT +GUBW4oldfd3uMh+ajv3/k2+trPbLEHcJKttLb2wG6HWCUQhBtSOUJuD0PdNCiQIc +BBABCgAGBQJUz4/SAAoJEK8losKGKqNoAZkP/1KC9GqkPdibzxX+m+ftgh4OTVDJ +M2iVupVl3PXiUgKTYSvyzk4Z9VAG6NOKsORHEtt4EzusYmshvtn+CeOLCt5VwSE/ +jQx4y4rrD2kbfhWje+fNsBrjQKWQMwl1GhmSZYqdbXevHfWGroF37XdIebUK+S5H +WBvSsgpUYhRkJmsKt/Aa9h2Hkj2rQRaJRgX5Cc6h69h1xISN2aUZ5D+4SUupQ+z6 +f+hsvhc32DqrUKVQFb9x7BkuOG5zFWIuAg+OkGIP45i6IvFcJInX3qPKp0pyspcR +6eBd+XvkJSrAYMW6TuS2JjXJKwZNM+c+aj3sfcFRou4gOYF55ZaXilMKytJhC3HH +M9DR1VzXBj1eqlipedexm3ZmLd3pOsFJ/tb5Armc7b8ENYcnB7E+JuLJykQ/qVgU +HnkQb9tSirGPEfkObDYPj+jFq016i3wDUqpgIpxRD50ky9wOYRb+8GmjzmQpzOfu +Rjv7lto0T3gcWXQQQWZQRzrAP62vz8U0bPsU5kAC+pxUnSx0404BEvLzBEzHMrsq +q7vxhy0w5lGigH+g8fDr5ohr9vRr+l8cgICJZGjIpLTwQWSRXcAgyUfV2FeX3zPP +9XQ9YBa7ca0QEq2OtFL4ueHEkUchL5/bgL9Rh1Li6O+6CN0bRFcbqmTgvc1+3F7S +QcxkSQCX9j4FV3HNiQIcBBABCgAGBQJU4JcBAAoJEFP+e72miRD8tBEP/0QxORNU +qz4jL7TA7jFITJ0RGnRGIlU5iFI4080VZr2ZHASGvRNSfpNSnKDLmO2LgpKWY8A+ +egutpPk328gskLHXWvNTq8Iogc9gEjPPwL/ZNMkgpjt8w0inhypjZaKOiym1gaOu +6Myv0yyvFqBH7to6Ryp9/mJhGCcZo5LqAGEVmRLeybaE5AKAhQOWyAFGgJR/O+OC +pYErq09NCYcfaSgL8Q3a/RSwJ/8yyZRJN+bqOGALHabj0rcLEpWWZBj1TahtNXzz +1JMmTXggzdRtMKyePPF1cI79B2POGjwpgri6OiFpOqHyFuuYp45ctmTkRDkp4Jbk +5gV851Fx4nWJh9X2qxzGbFm0RBLlh15AUw6SaKIPaXoWr9kmcON/XnlEhys4jZMx +S2K1u2SiyJbFDNz3sSwecGT4WaEn3xhxh1FAIis/a2dvKlZGtJYAbb4LeOpfxrgS +7H8YqXsM7XSmmErwNpEQFA90ZGY+8Cdg5GTw27+J5YcrQncGHLAwsV+bTEKNyfyU +HZwVzWQwgQQybE8RmWA+ssxN/+mUbt6dbKy3VBgT5SAUBECqWWYZyGZPMpxu4XIB +OHJlEPJEmzkOVroaxhhOoQJxAnh92RMJR5tnG3C48Wrx/4s2mMOXXQJBwk13B+iP +ay0fMICaDTgtn2nTXIojfrUWCUTa4coRZvOUiQIcBBABCgAGBQJVPp82AAoJEMmh +/m9mWu7j/0UP/3UObEbvFVe6SykbC6bWQytAEX5bLd74QTWWFl6FJjP/GeDGlOC+ +FXkAkbMEK+HCP+o9Vj2xFtdjvmV3ypufxy8rEF8CZcqIK2mw1VkodU1vvVJVqoWA +ouQVb/MQcxv/TlWQziLWXFloI/q8E1KkSznyeCN9jz8KvKwINZjrnK4DCxErfH95 +XlmUeT49UkfKkPF5Pl3/X7xEuXJ3rlRXyGpUeTL4+2ZM8zrt0QfXHka9D1xy8LCd +EutsAbzAmDcz9xhD3bM/xviSNFrM4i36UCWh98wGa3qWcYbqNm5LTHjk1Hzzd1mi +9/lRwjTlV3QFxUlccokJtmhSwJsv+DogDD5M7sziGTnFSmsE2G6JSfHDQSGNiw5B +2Wb7wamJTC8C1I43dvVfgwwWXgzU8pv6r6b2O3eF6g8SxjdArw6OZQwFktOEp1uj +7g/q1caSdnaf5S4vqh81e+j+krTiwyx6sV8njXoBLNYi+4Yp2dNdhKyYRCWoULws +qw1OVQKnFGX69wgvoNcmTSX7qgxFTwtvis6MVh5+TfI7XwU2PNKN6ga5CCCRcAVy +D9tzTfVRol54t1tRXrk905JJf7prm6murDVtUvci4+Dp55N1Bj4OPsvmN3wTVk0O +tHPHLJuWf3x2zriO0D5oHeZK3r2Tr5d047JDULhGk/baP4Zb3F37Pg5qiQIcBBIB +AgAGBQJU0Qg8AAoJEF6GT5HcJ1Hsl2EP+gMbPbGVd0JZQu/3wzJFb+JO16RdmPeI +FBPi+mDkZX5Jr8qLaTfYQC5xz+Pj7X25W/voG6a2IEkpuecK4pDBE4pg929JDjSE +qjJtgkCNqwYPKUsXVarTeYSD7Z3RKxgXkKA8OM9akWDscsJ5JbGmae6Sxz8CsJsL +fjvzU1vfpy2tPSAo5lsheXolhtwSN+7hZmDwbIwYooiZfnQjYbsluv7m//VFcWtx +3W8UK5f1R578oTQQbE8IHjCD8JiQLOOrbOiW6qQuU1J/09wvasD9x4GqPcGL7784 +Z05ZJ3evVaPxWOlUb0qEDswa6FBOnkGnPl1dbBmVsx3nbvIT1o3PUOJHqLhNNGUC +dz+ccMa6cM/rFEz0ybu0yb/Ibx65lYUPZJ1+caHoqWhoaipquYUpSy5Mxk5LhA50 +RWpukXk6n7u9Zmg/ANRNIaVc0q+rN0M6c8njAuzz9lcr+2RXCs5mSjyJcM686f/E +oJoll/Z2wnLJTFhCrMwfl/k+FTPwfYrUkjsu8OSwhqSKOPDh4k/U41H2DYQhGRXZ +6A5lsKvsZzi709WlVHM2+2cj3JJ5BsQJSZVO43oS63YpnLlzRhr517ZcuEHedaJ4 +z6zEivKVlm31f10AgSIqIDgdbyJyM7PE+nZB+s9f1tiA4/b9/Hp0dkuay7QJx/WR +iDRW6znMoT0RiQIcBBIBAgAGBQJU0TnEAAoJELoBCW3khqivpCcP/1avSUOBu/ZC +MGSrNIoS4nvA6+WIgqh8dcTDlBRd0VfUYQxjS6Yf4c5nd3yZEc1H2tQW7WhE93Iv +NUdOCReq3iHJJnuKuFe1pzTJee7MKnP0K8svhWCMzysQFfwO1ys0lPrZ+YN1F2Ml +c4R5gByHxbV17gz/6VcVuUr0sqSBD0ljseQ0SXHAf61wuXtU4UjIMFVQJvAwjBre +ZedPx7tmVy3HoETsxSxD7/vaAhDq0+ltdjz/AC9EsMJgo9o6RvBnGg4zkBv7uah5 +wDvWGEOc0CeoaJ0u+KZXhJ6qFHvneypH01ZVTsZ1mdXxsyBdeyvmOiN8rfp5r9uu +MBeyPrXD620/ZBzmWTnYzHw2sg+aYv4RHFpVUFeVOu4991wKAtrU6qZ+hr0cEvOj +H6OLOIEAOZzyv0cJOKjefOqtsWM0l0ThXnermdCrV8NrXergx3bmQKoSSMu5NapR +CQSnF1JH7p5UxAlZ5ZOqdcpoF6cZf0TmMaHyPrHxt1fhyXaFE0jLUqDxEKn8RqV9 +Q3TBtTdsdaAx5bVZCWtgrubrJ3UrGyLr/bxnUKok7sPdH8xaQA3migFfd2c3hJE1 +aTTtQbl3huKo+VCfvd6jWOO9og/uZ6r50SYsdhI1OIgmRhOHiWetPOZgc7X5OqdU +y2xrR24mISTrpFJ+qkBkSIR06Y31PhoziQIcBBIBCgAGBQJUzoT2AAoJEDTqpgbX +OPhc2X0P/RDOuPYxVbQF+cYzgt4vL5MFVPXpV+8Ck5Z3XLTDIPpcuOFlpNB14AgC +ZCu02Ijh0f3n5sq+cxHHkduiCuHevH88GilivzWc72GKrnGnkfL27dIGXUGC1t5U +h+59No12xwMQZBclzEE0iBw2jyVoicxjX5reIfoke5qcC5rg5PgK9xgv0BLYMzrR +ZL8+PfxKpOZ15LiQBV6eVoIgC9LEjSIKNRSBNyFkrDiThMeoDFl6d3M1WPxNNlD6 +T+Lbk91/fXvlrZU+tP1vGyiOULFAmWWdmPqsfQSwZwJ8ns8dJtm/Fclk1f+/rFK4 +fHhXdQkzFwZNoLRcJfFnCxv8H4mS4Yg9mrmIvOrZ2UeoTgmToX2am3xak1HyzTQf +IoptM1nuAOdm2ZTbUVRwGjvAiGy1/CpHmri+VY9kJXn4Kz6K32c9pUE/aojKRlFW +LNA/SlDNQvv0jVMNGcE5rzqGrzcuDsjD1GXKeBfe9aP6ZGLxEBctm24SIAT/w11X +R+47ZU3KJTabG2P4fIeoTcBH/Urnhbdh+09RH+3M/Wgq9+FzAbgmOya4vXsnurI+ +pJm0sXVNz8kne+f2GY0iJ8lvz83X0Z4cUvYbcM4WTjMfXcR07vctvWXez/rfvoOO +jVMMJ0gHKH52Vh0NsXTkjRpS8/XOXv/jRpEZbSOptnHADeLK52ZmiQIcBBIBCgAG +BQJU0eQUAAoJEN87kJPAgP0H5xwP/1B6Bzko/nY/BYy/titUpGSJUA/e2iNYNZQt +BqzD4gbjHQv4adVK6fceETogdgzzw/qxctgXb9fo/b7BgtsSXf6UqLjRG4sJweiT +ZtGbzd86rAu4i37u02Hjx0DmBds9/+cRfVxPi3hrpQ1r4ntkRxCagMVOZmNnKF43 +I/AepV1akjct80S4UomICfLAEVfOL+1K1noEMqZMXdGRUjRxXcQi1obNbld7Zpf2 +vkWEK29AALGU1rp/AeD8i2Hc0ABLIVj4LuhyZo3db4qGkceIwT6alf4DYUXnF4KK +GMqdME6PcnZR5DYvxzGf6wzRR3jT16AhOsVVcJewSlvhEBCs6EaWvEvZAyCo4IWe +RHswFGswBGHaxy3+Cvlwo582DjwOgx2EeEliDY2jADzS6k52588vba1O6I+7rHDa +tWAqePaA6/48LFSvnh2zooMNF8VKapzlzhh8ZrXryVf0H9X4PCq+eGkUvU1+QcL/ +12znjmaLYp+GJyn3jDKyfu4xBMSL4s+F5vf5hi/F+LB90RAvRwre3RcW44tH4j7x +snflytq1zK6YEK34wqVnZawyxeHizPcCPTmYSTrqYPUBJ/fHgn6p+84mtY7yQi7h +zcJ7l7zucpdeauHgH+qKjQkykkMbw05DDXoxYLYkUYcP5gzyt+oA/nHHVOvRHrQc +U6jjX4psiQIcBBIBCgAGBQJU4NEbAAoJEEcvWJ8MdZ5q6ocP/14RCi/IHNYWmZ1+ +c/xBPMANsifkHX1c+16aYVod8OiER33JSKFIWPpC3gKdRvFCifjBcJcf8sPalAlF +Boaft0B6xlmaluaGAoLDdwCOkokTkM/79s5tzq0uA2CdsAtji04KtiyL1hLVGbH5 +zLsDB5WQvRMzXV8aVIlefgWvMyIcG7e+dwishGFCLEC/DR6hS49r8zcTagSayRmh +g9C5bpw+28RcMnGSGKdgjl6Ltw9fFpFURyPOh7dfccwZQdHkUggpwhRa7g98nqyh +uJWEwlOjwK0m6FfbCJ6PJvV6vYTAsQmEjq1rAOPwEArg7E6tZDvCg0k1sCOZQ6LT +Nd7M4dGcGdENj3Udp6nb7LKVBdalGaSRmakusTaBzs9VG61ERsUH1gF6JUbNWNQp +C7JEPvDgE1YCcOsAcFaY4PUSys9m3cZCIBmZ5Jdk1jsxjUjSRpb9DXYbtBkq6RiP +rznHOinMifvhSH0j/GaoZVGCEzAmBxQ9zvrcyTSLCM3TQsyA/KKd9MHU1JeUs6Ou +PnwkAwYAnsPdHfIB70PElOiH4r9m3hpayT1o3W1EJ2eAkLD1OLeRh0mD358TPYYV +A9aF0K+3HOCDhjgVbGj6uBrP1FYV/c3tC+4U1w6aCi6XNGlTSqkYhdBH+IrWmHwE +wh4W4ATrRhzq77coN+5zZ0/lZJpiiQIcBBMBAgAGBQJU0AeSAAoJEOt0k4te68c/ +ns0P/2YuPhAm9xQBEUR9qujBGbIgD7BWQC/wtKQRvax1QCyVyyOHQL+ml8QiuuKI +8HkfK4zj59XW+e9fOI9TH2eKCKw5/bQr3hEbozQdOxr8VknFXx5R1Q/744SyFiG3 +JGWSGU/waXt72/lXdMc15W9FP5i4sTM5sS91Ctc3lQFq6y50NhITlH7Ec/9MaGYY +RiCYUzwDjTrGaVcVu3ZefToGB0Wwdk+/16TCB3TakS7W1/0iTrZtDDAejMH3Aevp +1EYc899gMK4JEazsEaH40J/nq0V4O2kopp6DZZyzPcztiuC6dCQeo9mCYurwom7t +OfdCegg+ka2c4LVJoJd15uyY73N83QBs43UUJaSWfGusxPO15mbw8CkD0zLmTIin +/xqDzWaqYMoWTgsB9MLaciClIPRRnUe2B6+PL7Dw6YY26c19UalxY6IDApgewETX +JYnIpQEcK1DIfiPGv98DvuqNxZrsu7aoe3QkW72uWnIHuAeMP6bIeA3KM19C4w24 +b6ZRbhb4ADqWA1x/GBliNknvIh0Ab28zVYE25vDA+9dPQ/sTOEihTYaKZa6RIrHK +Gp0wdS42zHqN3A3vgjqO2Omt6jB15mjO+PQnJtselePAWcxrGOC03B0UepWB7FFx +nG/UI+67FBjUlGCIjszzZUi+VDVQbQj6P0Gzje0SYRLVl9g1iQIcBBMBCgAGBQJU +0TNLAAoJEGFNB2e5qxOvImMP/R7zkgzD1eD+f3T5FS0/dxhbGdd6lNFfJjlnnNh1 +R6bxmiRyWWZrozaPCGmvHp0TXQP3evOE0WqOCZmCq+SONWTbQdZIrDTCaTU79ndz +GfCPl9CZTKpe3oGER3q/y79lqVgFArA+ve1sgFZpQux+rChTIiARQgKQcfKCWami +QZ75hLUsOSQ0GJum9yx/ezz7ODaaW97V+4+A/ZCufxC8dSbiZHmIWCpBjebvri6u +3UTtsnZHqG2OgcnnNAkIMaGTUhvKWFmwRlerqxKh49xo+brRUnrIgNgcNG7gTq5t +ZfW90EXxA7SStd/XynOo3CiDyaQMSw10eAFDEEhWXqAisJjZK9fkYKofcvH0/539 +gEjVwH+wTRgQjxF67HgYWHwSjghl/UQqugaxnWz+HVnIzGN8khv7oyoL6Qh+YbzV +6G4PjavRZTUwvurNrO25XUYa7ocFYaRRQjudb/pElcr391TjUUUDGCr3JfPaoo61 +YiLcffoZLOszit1nM+03USN82YkF6W6KjrEDQIPBbS2yKSwsHRmWHKnQeWAMsL3P +qqXAfXcSzNpY/NwtZ2bXkpSD9WNgDMsiz0sv2ZVWoGyS+BSfByIR70ps1dfZZi2Z +IVK/ejT2quIH+yxp7QrSm6klMTYq43SUFUafbpv0XpZmnCcCOUh52ed/NDFQulZT +OfxQiQIlBBMBCgA7AhsDCAsJCAcNDAsKBRUKCQgLAh4BAheAFiEEmqm9sRuxuZoh +KFozBmSnaVQmXowFAmM8VCMFCRFilpsACgkQBmSnaVQmXozBhw6gmIhXPbApQiN3 +JyBq5RrdemtmFhuLOoh4BMGr0+T/JB+e6LWlRoQFhPRSTCaPja7kPhtp7dWOQLn9 +TyZmgWX+zyoHqlyxWloivAgped+VhsUS53FUWjZlYK0dAUf8HRyjgOCL5bD8mY0n +v8LZmw02yon/ymG8C4AoOgc6h5pPy7HMhEVjV31MyXOLQsvGGMXnLmJx2eIz1IQm +rBtyc6VcJBk+gaZUOZ7CtM2Hbjj6spx172bydnDrHEkdiv0dS23IPfobwk8zPVd0 +TXAumag4QjyWHYIWBgCnjHB5Qgsn7HjMtuWWi/n8bTdoHCjsNWrLio2LlkKBEBwE +KR7ickLA/AhTzvCkCgS3i0lQePn+Cpe6a4KIe77pgGiSj6N7FGSoCzq1PdvaGx5O +o3wOE9P+JL9/lX48vvCPVxOgUCvc72U98cI7OYWyZnEVIb3Qy2P1ynCtP6Bb0fPS +hoO/klb9j7BnfhFae+i+6VZoL4lD3SAHIfae0wtAAxL4gMqQAU5NaYPOe/DwWgjP +Xo/WfY5+qP5iQ/2W5rtOo58GU9uPOE9RYKO3Rhf8M7zdnHhTQbJnP+v/nThssx7s +9KZo+4neOVxIG++CuxKW5BQuwWJ3A01Vdh5iuQENBFOnLCgBCAC5d9vt9T8G8Qli +t0a3rPvnTjmEcguQfivT0P3bQjuNRuPbz7t8IAb1epvnuymRSNDS0IUI1sh9wvUp +c6INDa5tE+p4Q07UylaGDD2zaV3tFDJCdryBLakd9M0YSD7l6b7HVK0ICZxIQ5Sn +VwhMHv7QWMEryQuQXW1v89fp0nPxnt7rYFlkJnj9b7PHFAGpinTxc2vimdUTLf2p +vqZg7sSh+E1+wPU83yYaPRCnyMhWHBZrMftsozw7kjlszYC/hS8LDhxg03xqNBYs +i3MdXKkFkXGb3bSxDEbDq8M7fEVcgER552FlrYwaP51gxkNYAIh50b95uQBLosg3 +niNV1whTABEBAAGJAy8EGAEKACYCGwIWIQSaqb2xG7G5miEoWjMGZKdpVCZejAUC +YPfAegUJDtwWUgEpwF0gBBkBCgAGBQJTpywoAAoJEIYLf7sy+BGdltsH/06eRSPf +HU5hntRfcPHAkWpFa2RbzSonftjnVicXYucXcC12ttvrNrPhQK+HGWdhmdeiKvhQ +kvjeprizB3bsp9IqgUfzvBsWIJBNpCu8Y3rGevP9pzpp5IZnueFY6HE8A17uqvE2 ++msNHFWc5c71+IAm/S/hnsYQY7ckofJMR9M136aL0u8NaRvfI9bnKHp+0QV3O/Wj +b0HFwjMGDO8rlzoiIJPHvVbnjz/Ehxj2bchpaBBXh1HbnBH9j3kjkrnsXksrBJtP +ZlYOTCgMuAowr7KnB+0jASY5CUXO695JZJXTsIJcGf79Lfku/kajN8yRglb7utoI +0v5bJzcmlhGOGsQJEAZkp2lUJl6MeyIOnAtKhIZFJ+vYptylNvg4GHvyKBaiiDf2 +mJOekLEkBnB1ifRWE2Kj7hPwYTgaMNL7P5znI2m8nKbtH8x9A1JIb7obXYNgj2O3 +emWkUyk5Q0I+0H7dJr9NZtJRS3H/UzspDWfN31R3x2C5kyj0BsQn15U9j3tzD8qB +Wh8FH/1b+j64Jq5bkC/jU9+/DqRVH7bd6nVN/YW/UQtN+d4/RHIwUT6Dt6aIIzjs +9CKpKTvmzaasS7NoMtnTtBU6sZBw4NMWiP7qnALKPbCdHFFguOvrQZ0yJlVT3hAX +3oV3C30JqC73UKFc2msS0jBSXc/0H8ZFD0AHSKPxXy3RNaww4hj1MBBgA4b7fL8U +zQZGlU3RYEAhzDpVPPzJuN/BHdN9uIPAd+RdE1iyatmToluhWRGxriyd7mcY2uOj +2IVT/AU8BQW+LFRivPugfEoOW25GqaFJzQ3ZcM8Q2m8FWcGu9BbDnfbomQB15s+g ++7li9dj6pmh3qv3w10xoIaue+LumYPGu4jzbNLCt/hYeWSMH2WCFgnSlOiJds9ti +ucZSEnp7oV95TpVjTkxqo1/zQ0LQGdUynkl5FSIE82mfFBRtoC3hrfNwi7N/F9/K +bqpM1VD5XXBERQkgxYkDLwQYAQoAJgIbAhYhBJqpvbEbsbmaIShaMwZkp2lUJl6M +BQJiOJ8gBQkPrjb4ASnAXSAEGQEKAAYFAlOnLCgACgkQhgt/uzL4EZ2W2wf/Tp5F +I98dTmGe1F9w8cCRakVrZFvNKid+2OdWJxdi5xdwLXa22+s2s+FAr4cZZ2GZ16Iq ++FCS+N6muLMHduyn0iqBR/O8GxYgkE2kK7xjesZ68/2nOmnkhme54VjocTwDXu6q +8Tb6aw0cVZzlzvX4gCb9L+GexhBjtySh8kxH0zXfpovS7w1pG98j1ucoen7RBXc7 +9aNvQcXCMwYM7yuXOiIgk8e9VuePP8SHGPZtyGloEFeHUducEf2PeSOSuexeSysE +m09mVg5MKAy4CjCvsqcH7SMBJjkJRc7r3klkldOwglwZ/v0t+S7+RqM3zJGCVvu6 +2gjS/lsnNyaWEY4axAkQBmSnaVQmXowZ3A6gldGf9kdacR+i4yMlqn6p6PxFyJoX +2yWPCL7kuNaHXWWhEno0jxtbuZlIN8KeQU0UpJtQbeC0JWbXagFw19Fg0ACutnju +Dd8sUHipDfsgL/UR8bSAViZc2ski07jj9i4kBPTRoPL3xzn7o4izvVURUucEkJEn +M5qJchUYJtmsFjDi4dqBo1b9Z+9Ak3svvTGhbTAknS8/s0Ln64yL6nGLFZB1nGUq +JTKNP0KiXRyeDZqUFVHt34URzFwNkuOF0w4eyAPKETf6MuuahcPP8xquWV2QYSIL ++ZnD6O95JCBRwD6QPRijpePAjOSadKRMYot36RnhGJrNOmZnYIz+jUaMIlLdopX/ +dr7Zw5CIR5LpJwD5vHYqbnaon7Hmdf+Z0qea12gF300JI4CZwoEea63gIoLaoGOR +J0NHep+xOMUgkwZ77l7GRbJP+kSW7NXIJC2+nTtdR+bF5t3Ke7QXgbdq/TCGsUDm +yme8RZ+CKIHwHkN9D34u2fIZEZ/YN3DZgD/dpJZwTr5kwVLqedOONowDUPMfuy7O +a5jfzCLlUkVMa+oKjaceAEpwM6iwRHOAWQlBWfO1q2ppV1aWSuVpHNhdEyAD5uvT +uOP0g8lO6RN2yl7CYe5GiQMvBBgBCgAmAhsCFiEEmqm9sRuxuZohKFozBmSnaVQm +XowFAmM8VCsFCRFilQMBKcBdIAQZAQoABgUCU6csKAAKCRCGC3+7MvgRnZbbB/9O +nkUj3x1OYZ7UX3DxwJFqRWtkW80qJ37Y51YnF2LnF3Atdrbb6zaz4UCvhxlnYZnX +oir4UJL43qa4swd27KfSKoFH87wbFiCQTaQrvGN6xnrz/ac6aeSGZ7nhWOhxPANe +7qrxNvprDRxVnOXO9fiAJv0v4Z7GEGO3JKHyTEfTNd+mi9LvDWkb3yPW5yh6ftEF +dzv1o29BxcIzBgzvK5c6IiCTx71W548/xIcY9m3IaWgQV4dR25wR/Y95I5K57F5L +KwSbT2ZWDkwoDLgKMK+ypwftIwEmOQlFzuveSWSV07CCXBn+/S35Lv5GozfMkYJW ++7raCNL+Wyc3JpYRjhrECRAGZKdpVCZejJR2DqCXvfu7qq27ZtvNrbaV7AkietaR +FgknxHgKPEb02GEu5xQ8kMUZ8kWLL34FILZtaKZnvNvfG+EzRx0XZbjt4mc8LUfh +y3AzDT0FP7r2Enfj5rBdfJJpT9LrNon07vKw4l2jSGdDP8U57vYloYHHGY7eh4Hk +36Jsaz13Dh09JGWzLUP0XzVacvizkZaKntiP+wY0Eg0R7RQe3Vedp1JwKYM5nwKG +dro1Tu3Zmj7qXErHdz1Fx4vtP3hHVX69nqu5OR52fPI5clQEmnSr5nv4FO2N/vIo +dhpgQXlNbb++exNS0uZRY06ECUxNOtA1RfaKJef9j+CGMNrqE9JZl/NAn+xvfCO3 +uXTD4INh+S49gAe6O9K0QoyLyMUEOoM7QkUJtzizEThSdwKZMWt0aS4idn/VytKh +o5q8E25iaIamU3aDRfG7TOClIRVa/b7PRejVO0syC92GlvEsm1yBLj7EgUF+9DeJ +vl/xCooaVwFEecVy+rj8qKpV2NPsfcgn66YWH54vx8eim4VV5WiM3A2jk77KVlZi +sztkMkg17maCe8ATLAjPn6lui7wm+dyCR+UoxmdFLhmzAhccqe7KHwlXEffruI2r +90iAPVxYp9pVVoMsrJN2Uqi5AQ0EU6csOAEIANSQ8a36jYicdSY0uq3WJUOeaIoa +trI6a/wOmzMdA9hGb/DX59LLG+EUiwgENEQMValvoK0n3dJ4s4ZdVnL/F8OU8gvT +A9hoSI074PuTZoyd+f01+UoGho3z3aAUALOFVoopaWu/svP6ZcdakA76I31WcV9W +s7Zg8iQUBUaxLpUHB/GiWNObxP+joqslOhqctU94YR723TppWUxOpE+r7C/1K/3Z +d2TBPhDuCgWlxaaizyJx3vxyxsy6FvZSAoTUFkNMzfzHCG4W9eNzYREdnpLT+w13 +o3SrYAvl4LQ2v2vkm2VS9rJtMSVCWP7BBPgMtcq0+gxEchAArQoGg9W6Ci8AEQEA +AYkCEAQYAQoAJgIbDBYhBJqpvbEbsbmaIShaMwZkp2lUJl6MBQJg98CABQkO3BZI +AAoJEAZkp2lUJl6MVBUOn1dAdDmIMbnWfzxkodYFxw46HrnnBoy6u/N1I7nCLBQS +0vfE9Hsu30EflISsd0bV0ftsmBs5F/58oXUTAvwzc2z3LzdNaauugPaUJn6VgDPj +rkVJriI1UB1LsU4zRoa8MmxyfLfzk5ya0LLK+mt4SmBAHdOG8qvoszt8OIpkH2Mk +VbtzMe+G0UJ/qGWARHlXNpiEwQkbfCY5kKrOW3NXvR0LnMc9FIKecB8kbsieZiYJ +ltS038q/Nu+OVRWbDGxT5ed5eedFANKMR6JTElaIeEilZMajhuQ7ZXnYeyR5jw3q +g3W4NNKgl5R7dm9p2T3/9xKTx9LNXZrROUlmsUxsagSF9rzYxcg2XrorjX1PoZpj +zIoVS4X5Zt28CAoPaORBTlviD5UMvWeCXPh9TxFKR+SGhnP5WWlptTjGWhVDacZt +A5q2lx4XAMQmbHCnR/cFF88pr9nKfKfwvmE2p2snjt6Tdzvgry0mK4klW0btpidS +tiYp1VTpGhpFP/wNmIYUl4dbOZHXAtfsC/WNxsl2saM70S3HrI7jcNmX4z7cryYG +lLUZZBf0F674lq8Mx5/+l9T86B6keKLTH5ldWTfwY0FGxFRTVE9KvaLpj/M1+lHd +u/uUY4kCEAQYAQoAJgIbDBYhBJqpvbEbsbmaIShaMwZkp2lUJl6MBQJiOJ8kBQkP +rjbsAAoJEAZkp2lUJl6M3UoOn0U9sX7E3g+81geydbsU3mTmLnwlRs4LnkcE/5N4 +zS/Zf3bJrw1ivbdHWiiOdvRRRP4RWqTCtQqAYIP1AjOr4RebhsEOO5eM/mzTM9r8 +Jqcmy9CZV7r77AvsG1uZEz1GyzZJDkjCPNHHBWPPShyeXArOX28fHNjeBE9IFkyM +VP1k81zU7i0566sh5wjebN2lL9BH2dCH9s6O2d+3QC5UP2wuyzhvG10R+sBoKi43 +D3mqTpfWMHBKMa7xZLL5j5CqrIsx8WyOK7nXydPYQ1xuROL/gbOE933V54SF7957 +efv71PzTVvRSqGDD0ymgqEGaa2uDdB7LXwj7pq9JHZvvfN4Crp0kzRZoCMFgmrR6 +pvOTJtnnIVBg5ZMivW0quuFfSP1VXdxuiTP2d/IcNDFx5dcx1VwtziAzEaatkGuj +MX7zcle4nmkPf3RJD+ZqlC2NoVyTotwAJcVLHguVZgeRZ1I1aLryZpDPTEfkndO6 +mPyAhcxnoq1X5HD6RR7dltKYDhvmv5BUpqmAz642g0nT3Hc/ZGRaR0CWaG6Lg6sd +ZMdo8n8StfTgdA4gyRrcHcFJ2WIaV+sp8pAoXlT7o0RkkObbnKJkwkIt1Y9MENBT +TH1fHwkufIkCEAQYAQoAJgIbDBYhBJqpvbEbsbmaIShaMwZkp2lUJl6MBQJjPFQw +BQkRYpT4AAoJEAZkp2lUJl6Ms1oOniYhAhCpCoZxnHGcrrjc4V0ktDxHdxJUCEkS +vQm0oc+wII3Zkra0a7FLuxSgHPkwFF8/XPNyW7jlOwwNOTzZoZJkD/OjKHQxXJa5 +UM/EKjcCw6tfUlzUeT6d/cJFV87OaPXfxt/QP771Uk1nZ3/dOOD58Hhz0KHyLfb/ +ALkxxYaqEgjgbkZXoZyu6XUKYvVZb2Zs+3DMuDW1Ca8Zmw8XFjwAcBzonBBG8kCv +mFIHsNHKKotxeNZK3RghxBNRuN7qEzrtRrtjKHawG4sElpuOPXzIcsLoP7OK2hOk +voLvsrcNAhRfqC461M0IxDpPKGfWQ1ORPXBHv8RqayQA/Jo9GawrlDGswU3M0j0D +BhOrbmf1U8be9UV0QrBDLz6EgH0IMXWzzfJDbV45tlepmFijYN5iHEfqfgqP6HVl +a3hOXf232oMM3F6pWa/aQyVLTIzeLOn9e5pCUFXc2RY+I1e5eGsXkIm0cf5ytZix +njiTomSZqflonfQmAQGJomGXpxACV0AzF5l6vZfvrmkIFFQFh/QvR9gVAO6g132F +DkHouD4lSq47fsBT3EE4iW5otVyXAjUUhu/HRJbKx0DXTSMZAhChZQ2t8mZGvzwa +V2d1aOpvdAJhgbkBDQRTpyxNAQgAxT/lDk2Sfjl8naZmypnRjlaCSc/LHu5TLNd/ +U/kzS68pNxBFhfhqmweFYM8c6xo8ADEo3kJADG+0m5/laWyX9SQzxQR6GCUJoOgl ++JBUWhmU+gx22I4ImufVpHZBGE7Qeyj5GxVpXqP0WU9rt3/Hk3naz+3YUl9GszdJ +Q7rv8Aa8Hnc0lfgIj69dK0Ggk6dVfLCm4c+a8jlx0FtBnKbOia2kczFvqKChV95T +6tKWWu6i/RerBOLAxb7TnW0SaGUtW/PGmaxDRsfCkq3DMwEavVAZ9aZbBBuP9wUb +/wYBx2hfnfe28udkdFVciF6S5ZHadVJOA/XEKbYGh+FAMiNb6wARAQABiQIQBBgB +CgAmAhsgFiEEmqm9sRuxuZohKFozBmSnaVQmXowFAmD3wIQFCQ7cFjcACgkQBmSn +aVQmXoxaaw6fYmJZ37AKLQnPRyAi4/P/vstSl0Yd9FCs68n8A3Hp2wH/DbKl7aT0 +km8FVAZ+7cpdBmJgFYldHvKLw0m7fo/58RrzHEbw/b90b+tRGbuozPMIK6Lrxa6T +1Sp93SUbDK2VSXKI7KMKNa5LuCEZ1JSBg3b0w9Q0EWuEvCAxcTq9BvSDn+1dWc/Q +POuAkU996c9a6Cz92ZfESBvh6xD2dMYV9pgPuowXV0OCD0P2fJr+d/n3ADUMfni2 +Qs4u7dVtnmFgXCw1f/p/ZdH9sFkPlLcqBZQJEQUS1YZCH/Jw4VHH6jRjKU5YGvve +UuWw07pycHrhokKL0iRzzJJ7Rl5ucfBTZZhUq8gcpUfGRONVWm6jTyAXVmjnmjK7 +ZgF8m9fEhTRnNt246MSW6lNXFS0hichYlffPhwcAn2Yx3CvWX6B5kGZ1/joeMMCX +SqNPgC1rGQ2XbC0+EravGWobZpiTIDEqPSVW7TaIYs6nYAL4ekPK9kfukDnQxfej +VWcrhvrkZPXIRn0XM/O6pRQTov17NyLs5oDufkb+6QfQp9JCLBLSeavGmTmbSS1f +thJDfy/9FRqwKW5u1/ZcIudlprcBBCW48N7kIZ55JcszFIDnfiCwkPHIDUPmiQIQ +BBgBCgAmAhsgFiEEmqm9sRuxuZohKFozBmSnaVQmXowFAmI4nykFCQ+uNtwACgkQ +BmSnaVQmXowdfA6fWJe2C3yoGjI0VP4DaXXSwgn473d6SSR3qzJVyS97lBmhzZMV +E5XRDiFzI1+EbKKI6PCNbF/slqEZ/HrJiZrK5/N4lgxS7iGxm5S+J7hIzjfNz16K +hDnMokVZSDOXJBHr4GJq4Mgmkw45nZ2yPndCJ2PS8Hs6YZ/39BAbcOf6WsMOLtCG +axBlBIezpzTXGvvCd9NkJ+/qG2lUWAF++cDN8fIraenxYFHFyNc21bTyiqceYJK2 +NYqK3FCCcid3/86fExhzT1UecbxSg304gdLgYSYnP5L5aWX+YcyrYUFWahlTKpcg +LWSLTdqKrAnQu18HydA5tqEvZsvJJRnCQxzl4AhiBJmA0zxBI2sX7m+yXoWx3dR+ +OrGBu10RFux4F7iAD3xWPqeokOg34h2/lNrI//2nJ9qB4pZUL+G/XrJraeaxozXY +jmpt3oJ6QtktihwU8TvgEzAm7ONVmU80qqXIJuec6bTOkzcb7a8x0q3qHP9ssuR0 +ZY08gFL9mc+ud+pNw61vNx8jFAjuePwMAjRyA0Ouado9Yb0o/4RnjtAIr1+UHZxV +2PH4kJlonxfa3G3ogLfk6MWQ267Ae78J6jMyfhbNJHQul65MV3OF21obRuPTe+Oi +iQIQBBgBCgAmAhsgFiEEmqm9sRuxuZohKFozBmSnaVQmXowFAmM8VDQFCRFilOcA +CgkQBmSnaVQmXoz67Q6faLq6Wct5PGn/rSLmsoVXpiPNvsSd1XgEf+MXFNTGbWke +d3KSe5sL8SCQv/dcF2fUTV4SOEiK6+ikTvWSg3aLtrBZZm4x6O1qkantrqlocAgX +FVB5Mt+Jd7rKzqH1b9/8Qu4Hb/nvS5BlzTq0mk/uaIkFdyCCC93e8N7tIRpJNZwo +YrXO0LSS9K+A81gdyJhT4LxP20FSTAcqr88aUStDz3YacvV1LsTPO/6cDvO7bavz +EmxqSfI2PrGu7TEwjPz8mXoLyGJJXYxDSy55DLThOjGDNHN+09QEKntso4DAsCdW +fJfN+UOnk+TPHkCN13ftnpiLyhJp5hr2NVTbWNzesNpEF+wTK1GXSwGQ/rwiRUdC +qNzL8Z6nqnz2tns9dl5stCBOWn4a45ixJimrRlcqSxhDv++gcUQbN4H+JtLAY7mj +AN9Zs/c7bzKvL1Wyb3XMcb4geSM2N/zkYNYN1ARFD5NmzlkWmlTYdK4RT9X57cQp +lHDvM0lZ7u9IYp61u04irCw2uVtZJQzjsN1yMUMRT4PTITv6YHMUKlYBFn+0TpV/ +OUFF0LZzLjWNkGwJjXvRIPVTyx4xY/VNtsvnipcC42MMc6fLYll2dOSdpT1lmtKc +9+Vm +=Ln7B +-----END PGP PUBLIC KEY BLOCK----- diff --git a/libgsasl.spec b/libgsasl.spec new file mode 100644 index 0000000..1465db4 --- /dev/null +++ b/libgsasl.spec @@ -0,0 +1,120 @@ +# +# spec file for package libgsasl +# +# Copyright (c) 2023 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +Name: libgsasl +Version: 1.10.0 +Release: 0 +Summary: Implementation of the SASL framework and a few common SASL mechanisms +License: GPL-3.0-or-later AND LGPL-2.1-or-later +Group: Development/Libraries/C and C++ +URL: https://www.gnu.org/software/gsasl/ +Source0: https://ftp.gnu.org/gnu/gsasl/%{name}-%{version}.tar.gz +Source1: https://ftp.gnu.org/gnu/gsasl/%{name}-%{version}.tar.gz.sig +# https://josefsson.org/54265e8c.txt#/libgsasl.keyring +Source2: libgsasl.keyring +# https://lists.gnu.org/archive/html/help-gsasl/2022-01/msg00002.html +Patch1: 0001-Fix-build-issues-with-GCC-12-s-Werror-address.patch +# https://gitlab.com/gsasl/gsasl/-/commit/796e4197f696261c1f872d7576371232330bcc30.patch#/boundary-check-CVE-2022-2469.patch +Patch2: boundary-check-CVE-2022-2469.patch +Patch3: build-fix-old-gcc.patch +Patch4: uninitialized_x.patch +BuildRequires: gcc-c++ +BuildRequires: gettext-devel >= 0.19.8 +BuildRequires: pkgconfig +BuildRequires: pkgconfig(krb5-gssapi) +BuildRequires: pkgconfig(libgcrypt) >= 1.4.4 +BuildRequires: pkgconfig(libidn) +BuildRequires: pkgconfig(libntlm) >= 0.3.5 + +# broken on s390x with LTO optimization, so let's disable it to be safe + +%description +GNU SASL is an implementation of the Simple Authentication and +Security Layer framework and a few common SASL mechanisms. SASL is +used by network servers (e.g., IMAP, SMTP) to request authentication +from clients, and in clients to authenticate against servers. + +%package -n libgsasl7 +Summary: Implementation of the SASL framework and a few common SASL mechanisms +# Needed to make lang package installable +Group: Development/Libraries/C and C++ +Provides: %{name} = %{version} + +%description -n libgsasl7 +GNU SASL is an implementation of the Simple Authentication and +Security Layer framework and a few common SASL mechanisms. SASL is +used by network servers (e.g., IMAP, SMTP) to request authentication +from clients, and in clients to authenticate against servers. + +%package devel +Summary: Implementation of the SASL framework and a few common SASL mechanisms +Group: Development/Libraries/C and C++ +Requires: libgsasl7 = %{version} +Requires: pkgconfig(krb5-gssapi) +Requires: pkgconfig(libgcrypt) +Requires: pkgconfig(libidn) +Requires: pkgconfig(libntlm) + +%description devel +GNU SASL is an implementation of the Simple Authentication and +Security Layer framework and a few common SASL mechanisms. SASL is +used by network servers (e.g., IMAP, SMTP) to request authentication +from clients, and in clients to authenticate against servers. + +%lang_package + +%prep +%setup -q +%patch1 -p1 +%patch2 -p2 +%patch3 -p1 +%patch4 -p1 + +%build +%configure \ + --disable-static \ + --with-pic \ + --with-gssapi-impl=mit \ + --enable-gcc-warnings \ +# +%make_build + +%install +%make_install +%find_lang %{name} +find %{buildroot} -type f -name "*.la" -delete -print + +%check +%make_build check + +%post -n libgsasl7 -p /sbin/ldconfig +%postun -n libgsasl7 -p /sbin/ldconfig + +%files -n libgsasl7 +%license COPYING* +%doc AUTHORS NEWS README THANKS +%{_libdir}/*.so.* + +%files devel +%{_includedir}/gsas*.h +%{_libdir}/*.so +%{_libdir}/pkgconfig/*.pc + +%files lang -f %{name}.lang + +%changelog diff --git a/uninitialized_x.patch b/uninitialized_x.patch new file mode 100644 index 0000000..52ff005 --- /dev/null +++ b/uninitialized_x.patch @@ -0,0 +1,132 @@ +Fixes this warning + +make[2]: Entering directory '/home/abuild/rpmbuild/BUILD/libgsasl-1.10.0/digest-md5' +/usr/bin/bash ../libtool --tag=CC --mode=link gcc -Werror -fanalyzer -fno-common -Wall -Warith-conversion -Wbad-function-cast -Wcast-align=strict -Wdate-time -Wdisabled-optimization -Wdouble-promotion -Wduplicated-branches -Wduplicated-cond -Wextra -Wformat-signedness -Winit-self -Winline -Winvalid-pch -Wlogical-op -Wmissing-declarations -Wmissing-include-dirs -Wmissing-prototypes -Wnested-externs -Wnull-dereference -Wold-style-definition -Wopenmp-simd -Woverlength-strings -Wpacked -Wpointer-arith -Wshadow -Wstack-protector -Wstrict-overflow -Wstrict-prototypes -Wsuggest-attribute=cold -Wsuggest-attribute=format -Wsuggest-attribute=malloc -Wsuggest-attribute=noreturn -Wsuggest-final-methods -Wsuggest-final-types -Wsync-nand -Wtrampolines -Wuninitialized -Wunknown-pragmas -Wunsafe-loop-optimizations -Wunused-macros -Wvariadic-macros -Wvector-operation-performance -Wvla -Wwrite-strings -Warray-bounds=2 -Wattribute-alias=2 -Wformat-overflow=2 -Wformat=2 -Wformat-truncation=2 -Wimplicit-fallthrough=5 -Wshift-overflow=2 -Wunused-const-variable=2 -Wvla-larger-than=4031 -Wno-analyzer-double-free -Wno-analyzer-malloc-leak -Wno-analyzer-null-dereference -Wno-analyzer-use-after-free -O2 -Wall -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -fstack-protector-strong -funwind-tables -fasynchronous-unwind-tables -fstack-clash-protection -Werror=return-type -flto=auto -g -flto=auto -o test-parser test_parser-test-parser.o libgsasl-digest_md5.la ../gl/libgl.la +libtool: link: gcc -Werror -fanalyzer -fno-common -Wall -Warith-conversion -Wbad-function-cast -Wcast-align=strict -Wdate-time -Wdisabled-optimization -Wdouble-promotion -Wduplicated-branches -Wduplicated-cond -Wextra -Wformat-signedness -Winit-self -Winline -Winvalid-pch -Wlogical-op -Wmissing-declarations -Wmissing-include-dirs -Wmissing-prototypes -Wnested-externs -Wnull-dereference -Wold-style-definition -Wopenmp-simd -Woverlength-strings -Wpacked -Wpointer-arith -Wshadow -Wstack-protector -Wstrict-overflow -Wstrict-prototypes -Wsuggest-attribute=cold -Wsuggest-attribute=format -Wsuggest-attribute=malloc -Wsuggest-attribute=noreturn -Wsuggest-final-methods -Wsuggest-final-types -Wsync-nand -Wtrampolines -Wuninitialized -Wunknown-pragmas -Wunsafe-loop-optimizations -Wunused-macros -Wvariadic-macros -Wvector-operation-performance -Wvla -Wwrite-strings -Warray-bounds=2 -Wattribute-alias=2 -Wformat-overflow=2 -Wformat=2 -Wformat-truncation=2 -Wimplicit-fallthrough=5 -Wshift-overflow=2 -Wunused-const-variable=2 -Wvla-larger-than=4031 -Wno-analyzer-double-free -Wno-analyzer-malloc-leak -Wno-analyzer-null-dereference -Wno-analyzer-use-after-free -O2 -Wall -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -fstack-protector-strong -funwind-tables -fasynchronous-unwind-tables -fstack-clash-protection -Werror=return-type -flto=auto -g -flto=auto -o test-parser test_parser-test-parser.o ./.libs/libgsasl-digest_md5.a ../gl/.libs/libgl.a -lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err +../gl/sha256.c: In function 'sha256_process_block': +../gl/sha256.c:462:7: error: use of uninitialized value 'x[1]' [CWE-457] [-Werror=analyzer-use-of-uninitialized-value] + 462 | R( h, a, b, c, d, e, f, g, K( 1), x[ 1] ); + | ^ + 'hmac_sha256': events 1-2 + | + |../gl/hmac.c:59:1: + | 59 | GL_HMAC_FN (const void *key, size_t keylen, + | | ^ + | | | + | | (1) entry to 'hmac_sha256' + |...... + | 81 | hmac_hash (key, keylen, in, inlen, IPAD, innerhash); + | | ~ + | | | + | | (2) calling 'hmac_hash' from 'hmac_sha256' + | + +--> 'hmac_hash': events 3-4 + | + | 42 | hmac_hash (const void *key, size_t keylen, + | | ^ + | | | + | | (3) entry to 'hmac_hash' + |...... + | 50 | memxor (block, key, keylen); + | | ~ + | | | + | | (4) calling 'memxor' from 'hmac_hash' + | + +--> 'memxor': events 5-9 + | + |../gl/memxor.c:25:1: + | 25 | memxor (void *restrict dest, const void *restrict src, size_t n) + | | ^ + | | | + | | (5) entry to 'memxor' + |...... + | 30 | for (; n > 0; n--) + | | ~ + | | | + | | (6) following 'true' branch (when 'n_3 != 0')... + | | (8) following 'false' branch (when 'n_3 == 0')... + | 31 | *d++ ^= *s++; + | | ~ + | | | + | | (7) ...to here + | 32 | + | 33 | return dest; + | | ~ + | | | + | | (9) ...to here + | + <------+ + | + 'hmac_hash': events 10-11 + | + |../gl/hmac.c:50:3: + | 50 | memxor (block, key, keylen); + | | ^ + | | | + | | (10) returning to 'hmac_hash' from 'memxor' + |...... + | 53 | GL_HMAC_FN_BLOC (block, sizeof block, &hmac_ctx); + | | ~ + | | | + | | (11) calling 'sha256_process_block' from 'hmac_hash' + | + +--> 'sha256_process_block': events 12-14 + | + |../gl/sha256.c:409:1: + | 409 | sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx) + | | ^ + | | | + | | (12) entry to 'sha256_process_block' + |...... + | 414 | uint32_t x[16]; + | | ~ + | | | + | | (13) region created on stack here + |...... + | 449 | while (words < endp) + | | ~ + | | | + | | (14) following 'true' branch (when 'words_1902 < endp_1916')... + | + 'sha256_process_block': event 15 + | + |lto1: + | (15): ...to here + | + 'sha256_process_block': events 16-20 + | + | 455 | for (t = 0; t < 16; t++) + | | ^ + | | | + | | (16) following 'true' branch (when 't_1911 != 16')... + | | (18) following 'false' branch (when 't_1911 == 16')... + | 456 | { + | 457 | x[t] = SWAP (*words); + | | ~ + | | | + | | (17) ...to here + |...... + | 461 | R( a, b, c, d, e, f, g, h, K( 0), x[ 0] ); + | | ~ + | | | + | | (19) ...to here + | 462 | R( h, a, b, c, d, e, f, g, K( 1), x[ 1] ); + | | ~ + | | | + | | (20) use of uninitialized value 'x[1]' here + | +lto1: all warnings being treated as errors + +Index: libgsasl-1.10.0/gl/sha256.c +=================================================================== +--- libgsasl-1.10.0.orig/gl/sha256.c ++++ libgsasl-1.10.0/gl/sha256.c +@@ -446,6 +446,8 @@ sha256_process_block (const void *buffer + D += t1; H = t0 + t1; \ + } while(0) + ++ memset(x, 0, sizeof(x)); ++ + while (words < endp) + { + uint32_t tm;