From c4276dbca6c94c4d4753611be542457322ed35e78b6b80c7eb22ca0008d5049f Mon Sep 17 00:00:00 2001 From: Otto Hollmann Date: Tue, 4 Oct 2022 14:51:03 +0000 Subject: [PATCH 1/5] Accepting request 1007932 from home:ohollmann:branches:security:tls - FIPS: Make XTS key check failure not fatal [bsc#1203779] * Add gnutls-Make-XTS-key-check-failure-not-fatal.patch OBS-URL: https://build.opensuse.org/request/show/1007932 OBS-URL: https://build.opensuse.org/package/show/security:tls/gnutls?expand=0&rev=76 --- ...Make-XTS-key-check-failure-not-fatal.patch | 230 ++++++++++++++++++ gnutls.changes | 6 + gnutls.spec | 2 + 3 files changed, 238 insertions(+) create mode 100644 gnutls-Make-XTS-key-check-failure-not-fatal.patch diff --git a/gnutls-Make-XTS-key-check-failure-not-fatal.patch b/gnutls-Make-XTS-key-check-failure-not-fatal.patch new file mode 100644 index 0000000..c23fb49 --- /dev/null +++ b/gnutls-Make-XTS-key-check-failure-not-fatal.patch @@ -0,0 +1,230 @@ +From 00fff0aad2b606801704046042aa3b2b24f07d63 Mon Sep 17 00:00:00 2001 +From: Zoltan Fridrich +Date: Thu, 29 Sep 2022 15:31:28 +0200 +Subject: [PATCH] Make XTS key check failure not fatal + +Signed-off-by: Zoltan Fridrich +--- + lib/accelerated/x86/aes-xts-x86-aesni.c | 1 + lib/nettle/cipher.c | 73 +++++++++-------------------- + tests/Makefile.am | 2 + tests/xts-key-check.c | 78 ++++++++++++++++++++++++++++++++ + 4 files changed, 102 insertions(+), 52 deletions(-) + create mode 100644 tests/xts-key-check.c + +--- a/lib/accelerated/x86/aes-xts-x86-aesni.c ++++ b/lib/accelerated/x86/aes-xts-x86-aesni.c +@@ -73,7 +73,6 @@ x86_aes_xts_cipher_setkey(void *_ctx, co + /* Check key block according to FIPS-140-2 IG A.9 */ + if (_gnutls_fips_mode_enabled()){ + if (gnutls_memcmp(key, key + (keysize / 2), keysize / 2) == 0) { +- _gnutls_switch_lib_state(LIB_STATE_ERROR); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + } +--- a/lib/nettle/cipher.c ++++ b/lib/nettle/cipher.c +@@ -448,12 +448,14 @@ _gcm_decrypt(struct nettle_cipher_ctx *c + length, dst, src); + } + +-static void _des_set_key(struct des_ctx *ctx, const uint8_t *key) ++static void ++_des_set_key(struct des_ctx *ctx, const uint8_t *key) + { + des_set_key(ctx, key); + } + +-static void _des3_set_key(struct des3_ctx *ctx, const uint8_t *key) ++static void ++_des3_set_key(struct des3_ctx *ctx, const uint8_t *key) + { + des3_set_key(ctx, key); + } +@@ -477,50 +479,6 @@ _cfb8_decrypt(struct nettle_cipher_ctx * + } + + static void +-_xts_aes128_set_encrypt_key(struct xts_aes128_key *xts_key, +- const uint8_t *key) +-{ +- if (_gnutls_fips_mode_enabled() && +- gnutls_memcmp(key, key + AES128_KEY_SIZE, AES128_KEY_SIZE) == 0) +- _gnutls_switch_lib_state(LIB_STATE_ERROR); +- +- xts_aes128_set_encrypt_key(xts_key, key); +-} +- +-static void +-_xts_aes128_set_decrypt_key(struct xts_aes128_key *xts_key, +- const uint8_t *key) +-{ +- if (_gnutls_fips_mode_enabled() && +- gnutls_memcmp(key, key + AES128_KEY_SIZE, AES128_KEY_SIZE) == 0) +- _gnutls_switch_lib_state(LIB_STATE_ERROR); +- +- xts_aes128_set_decrypt_key(xts_key, key); +-} +- +-static void +-_xts_aes256_set_encrypt_key(struct xts_aes256_key *xts_key, +- const uint8_t *key) +-{ +- if (_gnutls_fips_mode_enabled() && +- gnutls_memcmp(key, key + AES256_KEY_SIZE, AES256_KEY_SIZE) == 0) +- _gnutls_switch_lib_state(LIB_STATE_ERROR); +- +- xts_aes256_set_encrypt_key(xts_key, key); +-} +- +-static void +-_xts_aes256_set_decrypt_key(struct xts_aes256_key *xts_key, +- const uint8_t *key) +-{ +- if (_gnutls_fips_mode_enabled() && +- gnutls_memcmp(key, key + AES256_KEY_SIZE, AES256_KEY_SIZE) == 0) +- _gnutls_switch_lib_state(LIB_STATE_ERROR); +- +- xts_aes256_set_decrypt_key(xts_key, key); +-} +- +-static void + _xts_aes128_encrypt(struct nettle_cipher_ctx *ctx, size_t length, uint8_t * dst, + const uint8_t * src) + { +@@ -1041,8 +999,8 @@ static const struct nettle_cipher_st bui + .ctx_size = sizeof(struct xts_aes128_key), + .encrypt = _xts_aes128_encrypt, + .decrypt = _xts_aes128_decrypt, +- .set_encrypt_key = (nettle_set_key_func*)_xts_aes128_set_encrypt_key, +- .set_decrypt_key = (nettle_set_key_func*)_xts_aes128_set_decrypt_key, ++ .set_encrypt_key = (nettle_set_key_func*)xts_aes128_set_encrypt_key, ++ .set_decrypt_key = (nettle_set_key_func*)xts_aes128_set_decrypt_key, + .max_iv_size = AES_BLOCK_SIZE, + }, + { .algo = GNUTLS_CIPHER_AES_256_XTS, +@@ -1052,8 +1010,8 @@ static const struct nettle_cipher_st bui + .ctx_size = sizeof(struct xts_aes256_key), + .encrypt = _xts_aes256_encrypt, + .decrypt = _xts_aes256_decrypt, +- .set_encrypt_key = (nettle_set_key_func*)_xts_aes256_set_encrypt_key, +- .set_decrypt_key = (nettle_set_key_func*)_xts_aes256_set_decrypt_key, ++ .set_encrypt_key = (nettle_set_key_func*)xts_aes256_set_encrypt_key, ++ .set_decrypt_key = (nettle_set_key_func*)xts_aes256_set_decrypt_key, + .max_iv_size = AES_BLOCK_SIZE, + }, + { .algo = GNUTLS_CIPHER_AES_128_SIV, +@@ -1144,6 +1102,21 @@ wrap_nettle_cipher_setkey(void *_ctx, co + return 0; + } + ++ switch (ctx->cipher->algo) { ++ case GNUTLS_CIPHER_AES_128_XTS: ++ if (_gnutls_fips_mode_enabled() && ++ gnutls_memcmp(key, (char *)key + AES128_KEY_SIZE, AES128_KEY_SIZE) == 0) ++ return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); ++ break; ++ case GNUTLS_CIPHER_AES_256_XTS: ++ if (_gnutls_fips_mode_enabled() && ++ gnutls_memcmp(key, (char *)key + AES256_KEY_SIZE, AES256_KEY_SIZE) == 0) ++ return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); ++ break; ++ default: ++ break; ++ } ++ + if (ctx->enc) + ctx->cipher->set_encrypt_key(ctx->ctx_ptr, key); + else +--- a/tests/Makefile.am ++++ b/tests/Makefile.am +@@ -233,7 +233,7 @@ ctests += mini-record-2 simple gnutls_hm + tls13-without-timeout-func buffer status-request-revoked \ + set_x509_ocsp_multi_cli kdf-api keylog-func handshake-write \ + x509cert-dntypes id-on-xmppAddr tls13-compat-mode ciphersuite-name \ +- x509-upnconstraint cipher-padding pkcs7-verify-double-free ++ x509-upnconstraint xts-key-check cipher-padding pkcs7-verify-double-free + + ctests += tls-channel-binding + +--- /dev/null ++++ b/tests/xts-key-check.c +@@ -0,0 +1,78 @@ ++/* ++ * Copyright (C) 2022 Red Hat, Inc. ++ * ++ * Author: Zoltan Fridrich ++ * ++ * This file is part of GnuTLS. ++ * ++ * GnuTLS is free software: you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * GnuTLS is distributed in the hope that it will be useful, but ++ * WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with GnuTLS. If not, see . ++ */ ++ ++#ifdef HAVE_CONFIG_H ++#include ++#endif ++ ++#include ++ ++#include "utils.h" ++ ++static void test_xts_check(gnutls_cipher_algorithm_t alg) ++{ ++ int ret; ++ gnutls_cipher_hd_t ctx; ++ gnutls_datum_t key, iv; ++ ++ iv.size = gnutls_cipher_get_iv_size(alg); ++ iv.data = gnutls_malloc(iv.size); ++ if (iv.data == NULL) ++ fail("Error: %s\n", gnutls_strerror(GNUTLS_E_MEMORY_ERROR)); ++ gnutls_memset(iv.data, 0xf0, iv.size); ++ ++ key.size = gnutls_cipher_get_key_size(alg); ++ key.data = gnutls_malloc(key.size); ++ if (key.data == NULL) { ++ gnutls_free(iv.data); ++ fail("Error: %s\n", gnutls_strerror(GNUTLS_E_MEMORY_ERROR)); ++ } ++ gnutls_memset(key.data, 0xf0, key.size); ++ ++ ret = gnutls_cipher_init(&ctx, alg, &key, &iv); ++ if (ret == GNUTLS_E_SUCCESS) { ++ gnutls_cipher_deinit(ctx); ++ gnutls_free(iv.data); ++ gnutls_free(key.data); ++ fail("cipher initialization should fail for key1 == key2\n"); ++ } ++ ++ key.data[0] = 0xff; ++ ++ ret = gnutls_cipher_init(&ctx, alg, &key, &iv); ++ gnutls_free(iv.data); ++ gnutls_free(key.data); ++ ++ if (ret == GNUTLS_E_SUCCESS) ++ gnutls_cipher_deinit(ctx); ++ else ++ fail("cipher initialization should succeed with key1 != key2" ++ "\n%s\n", gnutls_strerror(ret)); ++} ++ ++void doit(void) ++{ ++ if (!gnutls_fips140_mode_enabled()) ++ exit(77); ++ ++ test_xts_check(GNUTLS_CIPHER_AES_128_XTS); ++ test_xts_check(GNUTLS_CIPHER_AES_256_XTS); ++} diff --git a/gnutls.changes b/gnutls.changes index 63358e8..2722870 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Tue Oct 4 13:05:27 UTC 2022 - Otto Hollmann + +- FIPS: Make XTS key check failure not fatal [bsc#1203779] + * Add gnutls-Make-XTS-key-check-failure-not-fatal.patch + ------------------------------------------------------------------- Wed Sep 14 15:25:46 UTC 2022 - Pedro Monreal diff --git a/gnutls.spec b/gnutls.spec index 8f325f2..ccba96c 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -59,6 +59,8 @@ Patch5: gnutls-FIPS-jitterentropy.patch Patch6: gnutls-FIPS-SLI-pbkdf2-verify-keylengths-only-SHA.patch #PATCH-FIX-SUSE bsc#1203245 FIPS: Run the CFB8 cipher selftests without offset Patch7: gnutls-FIPS-Run-CFB8-without-offset.patch +#PATCH-FIX-UPSTREAM bsc#1203779 Make XTS key check failure not fatal +Patch8: gnutls-Make-XTS-key-check-failure-not-fatal.patch BuildRequires: autogen BuildRequires: automake BuildRequires: datefudge From 443be2c6530347bbee27bd1c62f225d72bc913d4682e87c6e1f1553b4cb4ad85 Mon Sep 17 00:00:00 2001 From: Pedro Monreal Gonzalez Date: Tue, 11 Oct 2022 12:44:03 +0000 Subject: [PATCH 2/5] Accepting request 1009758 from home:pmonrealgonzalez:branches:security:tls - Update to 3.7.8: * libgnutls: In FIPS140 mode, RSA signature verification is an approved operation if the key has modulus with known sizes (1024, 1280, 1536, and 1792 bits), in addition to any modulus sizes larger than 2048 bits, according to SP800-131A rev2. * libgnutls: gnutls_session_channel_binding performs additional checks when GNUTLS_CB_TLS_EXPORTER is requested. According to RFC9622 4.2, the "tls-exporter" channel binding is only usable when the handshake is bound to a unique master secret (i.e., either TLS 1.3 or extended master secret extension is negotiated). Otherwise the function now returns error. * libgnutls: usage of the following functions, which are designed to loosen restrictions imposed by allowlisting mode of configuration, has been additionally restricted. Invoking them is now only allowed if system-wide TLS priority string has not been initialized yet: - gnutls_digest_set_secure - gnutls_sign_set_secure - gnutls_sign_set_secure_for_certs - gnutls_protocol_set_enabled * Delete gnutls-3.6.6-set_guile_site_dir.patch and use the --with-guile-extension-dir configure option to properly handle the guile extension directory. * Rebase gnutls-Make-XTS-key-check-failure-not-fatal.patch * Update gnutls.keyring * Add a build depencency on gtk-doc required by autoreconf OBS-URL: https://build.opensuse.org/request/show/1009758 OBS-URL: https://build.opensuse.org/package/show/security:tls/gnutls?expand=0&rev=77 --- gnutls-3.6.6-set_guile_site_dir.patch | 13 - gnutls-3.7.7.tar.xz | 3 - gnutls-3.7.7.tar.xz.sig | Bin 685 -> 0 bytes gnutls-3.7.8.tar.xz | 3 + gnutls-3.7.8.tar.xz.sig | Bin 0 -> 1250 bytes ...Make-XTS-key-check-failure-not-fatal.patch | 48 +- gnutls.changes | 30 + gnutls.keyring | 2036 +++-------------- gnutls.spec | 10 +- 9 files changed, 422 insertions(+), 1721 deletions(-) delete mode 100644 gnutls-3.6.6-set_guile_site_dir.patch delete mode 100644 gnutls-3.7.7.tar.xz delete mode 100644 gnutls-3.7.7.tar.xz.sig create mode 100644 gnutls-3.7.8.tar.xz create mode 100644 gnutls-3.7.8.tar.xz.sig diff --git a/gnutls-3.6.6-set_guile_site_dir.patch b/gnutls-3.6.6-set_guile_site_dir.patch deleted file mode 100644 index 054b7f9..0000000 --- a/gnutls-3.6.6-set_guile_site_dir.patch +++ /dev/null @@ -1,13 +0,0 @@ -Index: gnutls-3.7.7/configure -=================================================================== ---- gnutls-3.7.7.orig/configure -+++ gnutls-3.7.7/configure -@@ -74223,7 +74223,7 @@ fi - - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Guile site directory" >&5 - printf %s "checking for Guile site directory... " >&6; } -- GUILE_SITE=`$PKG_CONFIG --print-errors --variable=sitedir guile-$GUILE_EFFECTIVE_VERSION` -+ GUILE_SITE=/usr/share/guile - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GUILE_SITE" >&5 - printf "%s\n" "$GUILE_SITE" >&6; } - if test "$GUILE_SITE" = ""; then diff --git a/gnutls-3.7.7.tar.xz b/gnutls-3.7.7.tar.xz deleted file mode 100644 index a9bf40a..0000000 --- a/gnutls-3.7.7.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:be9143d0d58eab64dba9b77114aaafac529b6c0d7e81de6bdf1c9b59027d2106 -size 6351664 diff --git a/gnutls-3.7.7.tar.xz.sig b/gnutls-3.7.7.tar.xz.sig deleted file mode 100644 index 5406f222c7fd3d1f93d1e5bbecee86420124637bada1c4b877080375fdcc4c4f..0000000000000000000000000000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 685 zcmV;e0#f~n0y6{v0SEvc79j*iA|=DLZ#0LW$VqJ01%!^*=9qB>0%GEs`~V6G5Y`2R zj@RaxaZp+h{w0(&Lqs0#=Rr`Yltw6^=~Xpll_pmFJ(@;wkR?#JYkkc~;cUN{tg>e!cdumtUZiZw9Id-cm35L+ zH1GE`Lk5jGZa3H7uNj$CH1wT~#8IIa_5w0R31S{&SbZ|OcDns3sud2R0OS?H`Lb;$FF)6!eIf&o79oY?B4`J7 za^EV}QKHK1W2;|IOGN#3Z+(>8&LX_VRDl#K9>7P&Q>;nYhMZky8MSOP$qMDmWX9mT zz&&~Jf;uSxZMMIA4&B*Qu)ek{k-=PcyT`!+6GL+iHm{D3iMU84N&*xq z+-iI))|KI`Xfw)#dc2@nQ9GOlH;XWb2oFt5NKO*Fn!9^ES_R<3t^OoM|~pFh~#;>9!IXG45!^IPF15x{Z z%>9$1luWy0Fl>TsjLAAoCJ+>G4l#H#>6faS0^Y;D6)r2R4L$@`I@YLf1 z%7S7ItwE2fYrflloNaOjRw-0Tj=8sU3rpk-2e*%^xD|QuDd*7-arm&kfuo4e^<7cr z^Ur@)_v?cm1;+TDpw4#`Dz0cY-J!Z@&OI(2jbgyqLJXZd=8lgl1lPiV!LL|!(TOlF zjTnd_B?7y&eWj?id8RCDS7vX{{rtM6aksH6l?s#KWk9muyI0v;07er&2x@f;nKW>6 z+}8Vbn@f%eHY(N|One3Zi;!(9e_C1z-1>IVA)v`I-q8+9l6)V2^?ClN)-7Bo zHiz^OD<`br{(ypMrt-TQb)@*Y?MG0itV*mbvkM_w_rx7Y-n-e zJBb1^1ONdD038+~1V$ny!?bTSho8tvY}N&Yj@RaxaRmZnGZRMu3JDO_1%!^*=9qDE zhY$83)3ChQHl^|CKPU9>Lm(>d!#gZ(IH%6kih4DDU^-vk&n@&$`B>uj!}LZfcYetU z%$Uu%yqU!Bn6XRM6JD($xMUgAVw$R&d709h&&zOI3~G|GT&K`Lc8lN9#auCwn?B)O z1M618Xn5?sU9!uftSyb4pT3-bLJH>nykGzIT>O0@88rHof-K$?TzRV{s76zMds z-!bm_R;18`(HE|=fI-^kZb{|yvw3*B8)neHeacnW1K-qkXAgv6kQ~lFaEl=xrG9-3 z=nl?HGI-DWU1xs=W8u%D7!=;Yo$-fkZ}Q+xxeyKupD|AeYf{xG5%FWfkc*`?|Hpaz z$JJu)=Ct~|kB23p^)C>&8N-^Uo6KE%JE}Ka9&)8g$FjQ2sZg+a1vb z>tNw^N@Y~Y7 zLM`u~8315bRytW>m%39$@zCO}?b+d>9O^Cr{T}_sk% --- - lib/accelerated/x86/aes-xts-x86-aesni.c | 1 - lib/nettle/cipher.c | 73 +++++++++-------------------- - tests/Makefile.am | 2 - tests/xts-key-check.c | 78 ++++++++++++++++++++++++++++++++ - 4 files changed, 102 insertions(+), 52 deletions(-) + lib/accelerated/x86/aes-xts-x86-aesni.c | 1 - + lib/nettle/cipher.c | 73 ++++++++--------------- + tests/Makefile.am | 2 +- + tests/xts-key-check.c | 78 +++++++++++++++++++++++++ + 5 files changed, 103 insertions(+), 52 deletions(-) create mode 100644 tests/xts-key-check.c +diff --git a/lib/accelerated/x86/aes-xts-x86-aesni.c b/lib/accelerated/x86/aes-xts-x86-aesni.c +index 0588d0bd55..d6936a688d 100644 --- a/lib/accelerated/x86/aes-xts-x86-aesni.c +++ b/lib/accelerated/x86/aes-xts-x86-aesni.c -@@ -73,7 +73,6 @@ x86_aes_xts_cipher_setkey(void *_ctx, co +@@ -73,7 +73,6 @@ x86_aes_xts_cipher_setkey(void *_ctx, const void *userkey, size_t keysize) /* Check key block according to FIPS-140-2 IG A.9 */ if (_gnutls_fips_mode_enabled()){ if (gnutls_memcmp(key, key + (keysize / 2), keysize / 2) == 0) { @@ -22,9 +24,11 @@ Signed-off-by: Zoltan Fridrich return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); } } +diff --git a/lib/nettle/cipher.c b/lib/nettle/cipher.c +index c9c59fb0ba..9c2ce19e7e 100644 --- a/lib/nettle/cipher.c +++ b/lib/nettle/cipher.c -@@ -448,12 +448,14 @@ _gcm_decrypt(struct nettle_cipher_ctx *c +@@ -448,12 +448,14 @@ _gcm_decrypt(struct nettle_cipher_ctx *ctx, size_t length, uint8_t * dst, length, dst, src); } @@ -41,10 +45,11 @@ Signed-off-by: Zoltan Fridrich { des3_set_key(ctx, key); } -@@ -477,50 +479,6 @@ _cfb8_decrypt(struct nettle_cipher_ctx * +@@ -476,50 +478,6 @@ _cfb8_decrypt(struct nettle_cipher_ctx *ctx, size_t length, uint8_t * dst, + length, dst, src); } - static void +-static void -_xts_aes128_set_encrypt_key(struct xts_aes128_key *xts_key, - const uint8_t *key) -{ @@ -88,11 +93,10 @@ Signed-off-by: Zoltan Fridrich - xts_aes256_set_decrypt_key(xts_key, key); -} - --static void + static void _xts_aes128_encrypt(struct nettle_cipher_ctx *ctx, size_t length, uint8_t * dst, const uint8_t * src) - { -@@ -1041,8 +999,8 @@ static const struct nettle_cipher_st bui +@@ -1041,8 +999,8 @@ static const struct nettle_cipher_st builtin_ciphers[] = { .ctx_size = sizeof(struct xts_aes128_key), .encrypt = _xts_aes128_encrypt, .decrypt = _xts_aes128_decrypt, @@ -103,7 +107,7 @@ Signed-off-by: Zoltan Fridrich .max_iv_size = AES_BLOCK_SIZE, }, { .algo = GNUTLS_CIPHER_AES_256_XTS, -@@ -1052,8 +1010,8 @@ static const struct nettle_cipher_st bui +@@ -1052,8 +1010,8 @@ static const struct nettle_cipher_st builtin_ciphers[] = { .ctx_size = sizeof(struct xts_aes256_key), .encrypt = _xts_aes256_encrypt, .decrypt = _xts_aes256_decrypt, @@ -114,7 +118,7 @@ Signed-off-by: Zoltan Fridrich .max_iv_size = AES_BLOCK_SIZE, }, { .algo = GNUTLS_CIPHER_AES_128_SIV, -@@ -1144,6 +1102,21 @@ wrap_nettle_cipher_setkey(void *_ctx, co +@@ -1144,6 +1102,21 @@ wrap_nettle_cipher_setkey(void *_ctx, const void *key, size_t keysize) return 0; } @@ -136,17 +140,22 @@ Signed-off-by: Zoltan Fridrich if (ctx->enc) ctx->cipher->set_encrypt_key(ctx->ctx_ptr, key); else +diff --git a/tests/Makefile.am b/tests/Makefile.am +index 3e126f0046..1122886b31 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am -@@ -233,7 +233,7 @@ ctests += mini-record-2 simple gnutls_hm +@@ -233,7 +233,7 @@ ctests += mini-record-2 simple gnutls_hmac_fast set_pkcs12_cred cert certuniquei tls13-without-timeout-func buffer status-request-revoked \ set_x509_ocsp_multi_cli kdf-api keylog-func handshake-write \ x509cert-dntypes id-on-xmppAddr tls13-compat-mode ciphersuite-name \ -- x509-upnconstraint cipher-padding pkcs7-verify-double-free -+ x509-upnconstraint xts-key-check cipher-padding pkcs7-verify-double-free +- x509-upnconstraint cipher-padding pkcs7-verify-double-free \ ++ x509-upnconstraint xts-key-check cipher-padding pkcs7-verify-double-free \ + fips-rsa-sizes ctests += tls-channel-binding - +diff --git a/tests/xts-key-check.c b/tests/xts-key-check.c +new file mode 100644 +index 0000000000..a3bea5abca --- /dev/null +++ b/tests/xts-key-check.c @@ -0,0 +1,78 @@ @@ -228,3 +237,6 @@ Signed-off-by: Zoltan Fridrich + test_xts_check(GNUTLS_CIPHER_AES_128_XTS); + test_xts_check(GNUTLS_CIPHER_AES_256_XTS); +} +-- +GitLab + diff --git a/gnutls.changes b/gnutls.changes index 2722870..12601c5 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,3 +1,33 @@ +------------------------------------------------------------------- +Sun Oct 9 12:53:27 UTC 2022 - Pedro Monreal + +- Update to 3.7.8: + * libgnutls: In FIPS140 mode, RSA signature verification is an + approved operation if the key has modulus with known sizes + (1024, 1280, 1536, and 1792 bits), in addition to any modulus + sizes larger than 2048 bits, according to SP800-131A rev2. + * libgnutls: gnutls_session_channel_binding performs additional + checks when GNUTLS_CB_TLS_EXPORTER is requested. According to + RFC9622 4.2, the "tls-exporter" channel binding is only usable + when the handshake is bound to a unique master secret (i.e., + either TLS 1.3 or extended master secret extension is + negotiated). Otherwise the function now returns error. + * libgnutls: usage of the following functions, which are designed + to loosen restrictions imposed by allowlisting mode of + configuration, has been additionally restricted. Invoking + them is now only allowed if system-wide TLS priority string + has not been initialized yet: + - gnutls_digest_set_secure + - gnutls_sign_set_secure + - gnutls_sign_set_secure_for_certs + - gnutls_protocol_set_enabled + * Delete gnutls-3.6.6-set_guile_site_dir.patch and use the + --with-guile-extension-dir configure option to properly + handle the guile extension directory. + * Rebase gnutls-Make-XTS-key-check-failure-not-fatal.patch + * Update gnutls.keyring + * Add a build depencency on gtk-doc required by autoreconf + ------------------------------------------------------------------- Tue Oct 4 13:05:27 UTC 2022 - Otto Hollmann diff --git a/gnutls.keyring b/gnutls.keyring index 7e498f6..8194fcd 100644 --- a/gnutls.keyring +++ b/gnutls.keyring @@ -1,1688 +1,358 @@ -----BEGIN PGP PUBLIC KEY BLOCK----- -mQGRBEgd5bQBDCDc8Z7h2Damx3Xm+kMFXMKHqVUdPOqvcFT0c1gnQ9LPw3JiswvB -dM3SBRb2LxtEAnXt0Bw8WBbcCF9s05h8xjCSLDmBwQ1EBEeTvUN18TgeM6t4rNTZ -NrXl5wRmvkAzdO+EOHWx2gDRApLbdkkBK21+M6HPhtqRiMWK6zd5bPmiiAKNRv0G -aC71qUpdNSrWVzB02s8+LUivwH+kUksMX2nXps7b6RPhQyFl6FSv0LsHDd3yxRrB -JIikUAsSnQbDSPws+Srq1VFLhaARiPF2tg7ag1n4qbbZiK3XOSjK3X+b2XkdZrWY -7orBke/J1cMv/9XnqtsE1P1EYcuPk34yxjz/E5+0vf8DlzQ86c2DHRCpr81XV3qD -tNeouQFLDI1kkpG6QTY3S2SPMUht8V8JxhqBzbjWZmKGUf1ISYI2p9FqtXF4rL2D -u1QLPQGLwqYaUvnGCYFxEMpnDcYheF6zOUtow527WgrJcATDXW/HCzidwi2+o/cU -bdCeYOiN28IMCOIBJZjLABEBAAG0N05pa29zIE1hdnJvZ2lhbm5vcG91bG9zIDxu -Lm1hdnJvZ2lhbm5vcG91bG9zQGdtYWlsLmNvbT6JAcAEEwECACYFAkgd5tUCGwMF -CSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRAp7li5loZRcQvjDB4m6HO8 -bbiRSgYRd7UrUuSmRNcoWP3W2metytSq9ugRsFhgl3llHEMkgWTEXzsQTPZXPq7m -7aNXPa8s/ibD+qZAbFSRvJISrp/E+c1gCt4AQm/nD32F5RIsVKpg9J0pK7rCrMyL -lD+PiG++jJrG3inuk4Krc3EHj92LJpfEnVgaJR0ajwuVHNd9/QOrkrxQ7jlLckl9 -ZWmquTym/GClsH7NcPnqwc7YO0nG1X/l9HJmvSyaHGi4UnzjC8Tqh4avs1A2uUfX -o0OCwLO61bqnst1lIyAn7HtidVNBIfQXKDd3jWz+WwyZk0GRgzRBfRWShpiymxVi -3LWUgtXL0FTEK/pFpHvIbhpivNq1RPTeulO1uO+Bb78VYzvQx3cIX96gRoqapdI9 -zO8BlEze9lj1gZsRVBlWVkR58IZnuPYtOmuIoGX3NFaTBk4rIKPeXEzCGC/ieHDH -En29mZoLk89VrCq+7WNKdSYjiPcMLpRYmvBcJSxY6YxnM5rfiBSW5huV3uYuZQ89 -iEYEEBECAAYFAkgd5t4ACgkQ4V3YV7FcN9FGqQCfU1gaFrkGi5abivU9BQkJkr44 -kn0An0VSGMOgEsfzsDzy8sKnJTvdD6e6iEYEEBECAAYFAkh+2sgACgkQSgobyOT0 -/+aasgCghMcsnklu+37Qe9df76p68IGNEU8AnRw7QP8tYJ5Z4GAmc6FfP+3unrN6 -iEYEEBECAAYFAk1OpR0ACgkQaeRidk/FnkRwmACgmwEiVmtLCR2ffl/2MAJi+tNt -KyYAoJL6fLS8xycGA8G7ls4qYewDlr9piQIcBBMBAgAGBQJNTvdcAAoJELzblbcK -o78OfHAP/Rjx9YUKbB8ruIbVwzaOpaoiIpBcK/F/aafqxBBENEO7IajQfRyxozrl -XzzUIQyOC3keQdw7LwyURYvIYxcm0k5x7eVnhavu4TBL8FAnIsA9BTkNbSVCgmKb -rclfUriu7ipFPsaSEJApKDhQU3ijFtwHCUxFg9L/lm5N/PwIL0GQC6BNrbVrOCVd -QflMhX2MRNVAfvAbNcRJYUCAh0hHFigkE8FhAqJZuUGK62/Tbc0/np9ga4q7b3dT -Bg0l+UVVAKc+XcvABcomZeLcgNT7YTYZ5pJMjfx8Nk7R73JNYLLUnB7fFSoOolbw -dBkz2BupNlmRmoD/lvm7Sbnn4HkyLFdnx9CzFZ3Mn1IMkm6Kkcs3Fm3VHQgLgs9K -lewKOWzDBQeSgPbhhiqzjbFXB+e/7MDTJgITLZol+3/OlELvcTcSU4RloJzjJ1mQ -5KdZe1ZrCs9dUwQi5+guiLZJ/MuqeNtXPey+HliwhyG9gy8uGYFW+6eLj3yv4YaE -AmlzTYneHqBNX5kTw73GBWy8PyZz0wiIX/700BEw5IPCeJV6h+xBdpqk8l9PZ2Vi -Piuod2qWJMIw5oldChMTp9Wtk0+EBg8uiUz1q5hgIts12578fkH7EPGbQCF8RITT -ThrK6m/YOjf2n03irT52Umb4c3FbBxn3hQX76QuhK+TrYkDyREtFiQIcBBMBCAAG -BQJNTx73AAoJEPlBB4h4NHwMohAQALY/Gq5yXfWTmBQWqLfeXBXSCZAz7yC1f+r2 -RNNf8dx8xTW/dyI2G1SbMqqHc6rJqW5yPe99aP4AQsr8lAsoLbY1LhJi3Imfpk+h -vAVqInSXyQcOnprceL5iyADpkpLS+/5CM83VGfFQoVUTgLcFWU97k8vT0fQT3pFV -QTQzVu2ZbBkHhaLTkV1Ep1KHWrSEVN7kFZaA6DmnR5W+L2k4aPEKDgpVSflLmd/9 -XbDFYsDzcHlbK8G3fEh7SjMJGyFyA44EeqLA3pRoHj4bF/jVCXqS5LN0LarBmM+6 -Wioi5thj7jZ8NlqSCvuaFbajd5asY5oASZKa9M30sSU6oWSVdOkqkjagQf65teHw -64UyaK57l7NWIenv88mPfEJK8Ce2nt2j4cOZ+OkAimUGBsvFNNMQae2Q+dfb20Eq -XeATKRtBzJDSKVK2RcKUi08PYPK6PTAsubMxJnjIbMohTdUc9QOvCRa0o+f2/VhZ -DrFNTwiF0dxjl3fFxt2NpVsDbKmgJegov9lf50oFrTreRG2kx3iGpiKXyPWqgIN9 -LPFkHdT1uXQbasTRi51zMfcYVmk1Do/CzuTw+PJGnTgmC1Va1NSv2Ck7xl4H7HV5 -eDlWHCb8plE9QE38AlU/pv+34JVSC5mf/HDIxL68IdUENMiXyBWynDeQkuI9roUb -Li0y+9J/iQGcBBABAgAGBQJNTwf+AAoJEODYD8Y41NWHpIUMAImOAT+PyjCec7sM -xfx7XY2I+1vovSt6dKTBpHVq7Wj5575Sl+0Rp2YovC5nGpLNx9Tt3V/qNDHZAokk -F8/XPqwcwmvVFLsXfPDbwcASf+1FEdXAf4AK3qalt7BKVV950oUKw88DJuigc14D -tIgYOIiKHRQ8hot8tFOl6q1iR4tPYslz+gkbkxc7wWQYsPpR/37Shn60QZMkZK7Q -7Rwc9g1/g9IZDA8A3qVIzPAvV15GMYb7MWmji+ys6zPGdd+dfX8AbE1ZFG9xEkVr -fJIwGd8Yuq0nb0p9SKW8kFmnblXVPAE+harUSH1oWhzUcit+O4gYa63rMS3Ai6uc -MDJ9YXXqVT2sQNKAxR1fCcSomVPGx3HD95XIWVbQXBQhPE/FJY/4y172cxlC2KpP -09MRTKD5OrXlsn2nCso1fd8qn43aGxE+9ouC7pWcLSkPhLRPfQQ+1RxGf0tSqghk -A/gY0qLpp/wMnM056aDgQllGjA2G6Ujk3Jh8uRt4CwVzNFbUo4hdBBARCAAGBQJN -T3n4AAoJEAJasBBrF+oevZQA+KcQbKpgCwYqEjc4UyVQ/lL4fNapao8+Yj/N6oT8 -HBcA/2PB62hLyyIQwGSqovcYC3R5QWxcpEg0+FXBq52prCj6iHQEEhECADQFAk1P -0V0tGmh0dHA6Ly93d3cuYTJ4LmNoL2RlL2tvbnRha3QvcGdwLXBvbGljeS5odG1s -AAoJEHFtRBM9jCItc7IAoLU6jf1+Cm8vLmNUawf6VB/uAQe+AJ9N/1vAyeY31req -TYa22XKHrMhnx4h0BBIRAgA0BQJNT9FvLRpodHRwOi8vd3d3LmEyeC5jaC9kZS9r -b250YWt0L3BncC1wb2xpY3kuaHRtbAAKCRBW1Sk+yXoGVJNHAKDX79218zw3Gtex -5PIchhsP3b/hmQCg5k1D9PJbfpbKRotpmp55eokhwnKJAhwEEwECAAYFAk1PhSwA -CgkQmZMeJdkeASziBA/+J235eEuqz2I+P+S1RXWa0SGUDk4CTtsYHeLbr91FpEOj -WMVIYoj1i25Ne+nqjs+goYc0n5oVC72W+jJrT/ayGunMnYwkmLI+OnJ9/FNkwKj9 -phi5Cx9BNe7+ZrjCSxxg8Ar2/UIzUhUXnIII+OIsdAUwz4P8UhVXfCfXeja0pTCn -2XjNoxKOdHLU3DH0YXqJAPsWSJEqyZyVP0SoKru6Uq536/Z6VRNA9hFR9QWIi0ib -F1tngyfzwevIEjN6OBdT4fwZzmdV1cQ+adoiUr9wFeA1JbjJefAXOq15uTxMMMJV -gRVnzHPAWosLHYnKaJzKd8rcxMsftiD92NbU0t24YsDmXMVAo4u3Q2YVgbgGWu2t -PqYPZHk0i57MmAIn6YrL3+TTqDNN35enQMKKJmnBAg84ZZvQ9pGJQDMcMv31Yvau -vt4dkw8u/Jbksuc9RTw6w0Zn4WYPRxZtUwqKYlR5Khr0f9HrKOeiJuvOs37F3+bJ -CYaKYzy0BUfSmujKHPcP1l3IJe3gIT4hrDWc1J4rcZ+dopBkddBVQrMc4L9V0VMX -2bR3fcC5VraEnRQxkkyF3GSYoXNm5ClH9LV22kuS4A5WPheTDbD4wFKqT1UHMush -5rjd/BwyDXTcym+bMH2ZAft5w7VOquFM372GUI6uXNiZS/iMWj1w6MlzlaI9q3SI -RgQQEQIABgUCTU/a2QAKCRBJNgs7HfuhZH1DAJ9IFcqjB0K/310XdIXQPd06Ev34 -oACg7Pe+DW9C6+gJ3foFZo+TrcC5K1eJAhwEEAECAAYFAk1P2zoACgkQfpcqy/4K -evMLmRAAj23Tdm5GO2HxV7IP2x3Aa7kFo/pzVUUuvpn0HFIWBFK+fJEOMeD1SpI9 -nGHfziUrNruwtjqgSMHGy+ZP7IM0ERvmkp8r1La67P4AsH6Qk+jBwwlGPs0bE5y1 -I9vip9rWhVTrnBWUgblAWWvjNaArCRA0XtOLYZcoUNZUf9KGFns7OSVCKjysoLuA -yw05ZIUcHyRe9Jf6Ps372726qDAcDFM5175rL2Mo3khm4riq4ezIa63SWSfUCHfU -g7z2ZTPA+9JfwAyYw1+pOgwM3Sg6NFhWYlG2itewJd71PfAOU7D5jRTjHGGyYkxq -2Xu6Yt3auBIo1M2ZDQVYaxxfBalOyk8HRMo7+IXiMZLfP2cqBghGBjfO7usfKU/2 -WkmBlO+gZ9v4snVynfJszwjqqJaulfzKdOlwfYvoEuA6C+ZtXQsjI6vniWoiuDN3 -zQaDgjvEDMBHuaxDtxJP8ElbSByKNB9ilCe81H0vDWtzHrrntK+yekt2OhfwbJBT -a5Zyu54HF9Ifcpv2AAU1/kquZz5lWDzx8GQc42L4dIs2JtSbnIzZI+vOBkgUaepf -fvM+vmI/z4zAAMwXuPgH7jHZVSXz592Kc8vD0SMryiajdm7+H9m80JZoJGvGa8tL -83wjE3AfkNt4x4jFyEkrqNzFMG4Pf3KCYIgE4EGGXWZh1QE1f7KJAhwEEAEIAAYF -Ak1PtoIACgkQtZ63IgLRvGVFUw/+Oys3yltQUkudCAhmW7Z2hg3sFbymd3KoW8cp -WbblC59p3t8owLgsRDgu0tzQ0OgjdXkjcaGTH2tRlcrJmJ7Zk+QyU+Vb0+nlXpIa -btr8GnGFPT092Et+pFaVOJDNRCFIVYeeVfgspX+RJohUsNAjiTHS4GJGyXTDHpOR -PH5xokbCRtlG7NRV4i9zg8D9osSW7ijsF+g5peaEiSUF1rToJ+yXMldnsJRXHC75 -zrB09ix0VFpOzx4N763WUrobIvDPWKl+25s25zkdw5jfzSX1+cZjXO35zeMRltyD -ECSS0j9v/MtplbnrumErL0BLPUPb5sfn3Akpjk6a+8oo5qL8u2vtAMxUWX2LAdeY -9Mz/S3pRa+gd/s/R8XL+5R4imW9w1GeDO4MIa4afMmpC1bjDH5vEucxWUuYyfZbn -O2XQ/ElneV0VO/c7FKc8xYNC0urX679Fsoq273UVL+psNTkAscwY13wEQw5mT4VR -cWt9Wi6o20gdsFqozAd4J2xstbkXsVk2pijAQc1+PL8nkHi0btBxO/sTCk7/yNtG -cjnXwD4amtZGnELIyiF0lTGbn555KKvuR6OpNLraY5QrkW5tbwA9WGZRQe4dAWv/ -czxRrb41e7LpWIUkXUqww53RsDBzuqtgV1D4ghFY+xzVDY1jkrO3J66sa3vNx3WW -LVTABwOIRgQREQIABgUCTU/vtwAKCRCa3YdBWqMiVjikAKCP/1BUiDupZbAu2nMx -NWdZ7+AkxACcCt/d5WdYlNY6GBsaFCnJzp3tCXKIRgQQEQIABgUCTU/l/AAKCRDl -MRXluKGcafpTAJ9Kwsu8X/d4DiNO4ptCyG7bnc+fCQCfeANjtliTDIiDqlV0CDhI -K9sMo4OIRgQTEQoABgUCTU/3aQAKCRD8sLtcXx+/cMwVAJ0ZizlAxB4E/1cEhY6A -9JdBkljE4QCfQYgsJRznwXVYNG3eO06+KVUz59yJAhwEEwEKAAYFAk1P93gACgkQ -ntzJkdmrRX7MPxAAoUcYn1RG7XjtDOm+ijduz4gnaXXKgFhOMaVqG0HjMA5ve0oe -3VvnFdZsYxObD3us3mkvt63lmMx61JH9aMzBhLd2EEWDQXfKSPJw+Ll6da7gD9Nb -p8KPrlLMAVdQO0PsfBieHIITdrV33wDEmZ5nRfZ49crFWzaIAZ3FS2h0aOj+/DP8 -ovhENdvykCWAcmqzteFJnKGx7IpBl0jGye59FJ4xc8SkSqwzQ2jJDM48FZmE242F -cj/DLWvF8BNMEAouZLR5NpLE7k//40PQMqO6nSOeQtnpfUP4mMiw77kXp+ZLpg3x -pGfWYVnNWsBTyG/jcdx9Pv71p1/I13q6+O0rCbGrjb9Czq+QQu7kfPwWDDyrU5Sv -A6/Yvh3HfDdjpavMDxfBY+KHjHMaAMJ5rm3//EZpBtLyHZXWTiawsv1eraFpxlRZ -mrY/JlB0XMV87Ma01x9NggQfMjj2AwhaTx0JWvLZjiN1fV0GN6gHtYLDJRS6zdUO -mfTFbCFgIwEWAbVKFapVe6jA7sak/X4kdwOupK88FGofUrP4WXWtjStOHeS4irXL -BGTQOAoizeLhDGvXKyoP3RZzdQKRvw4DNkNztXIhWb/ZgRI3R5ULoFUY4d6Za4T3 -Q9iK8oz3o7nEsWaHGE2UTZtdKo0eaXMrJM+rthr6yPER0G6WvTfadssJJYiIRgQQ -EQIABgUCTVAFAAAKCRCNvOfruxnoAyv/AJ46wOFCbVWS73IaeupVygLkNGZDAgCf -ZjPwGvRy9fj4mvxWpBfWbn8WcvaJAhwEEAEIAAYFAk1QIMgACgkQqC+7g/PVcDP9 -3xAAwgm8FfGcF1WbQYUi7K5VaiwPqXCJ1h4cx5YewSGeue9On3ltRSxbXmtpTcdm -mcZULXrFYhF+cwhwgQu2BAHX327tW3AO9NZtLNbdAUFGGPky0g5K4tk26OeyJAMT -9n5t2d7cdD3HiamrdqIHDPjYXCCGHgkycWiWGRBWcrBeYInk2iLMu+hgV31pAiEl -iIZYKEoDAxZKO4eLoFqSlqO9WIAhARlcxk9WmN0q9v+E1+CIuq976BRU2rJ0pWEZ -dwRl4dL62ucJ+Yazlq2Ix4PMliSxTA7i1xYi9Fodr7XQahbVx0/+WFB5GLZwyedl -9u6HWCkwZec3xGJUoas3g6+GTPTD5xpqT5gPgC3jnG8WBSXtifl2iq8baDpd5U86 -WWtNs9bWe9YV2e4vQltyfXJSetbEQTcaObxLwWuvm6mg9da5rQksXf6Ljukx97O3 -02tylc4BQ6cskqGEX8LixO+w+iPhs1NMsIymdi6qScWa/nhtoN3hsA7OCINVDDMb -VGVItOUjNi55ezuaDc7Vhyd9SS949zKfRfamttvUhqYHDrxXDTDPdd6O8aH1Ar38 -rn7AE5IEuaNLHaBdqE+Gs+DeqQX7+BiaQziMs7l3rLhJH9muvbrJAFsmodGKnb4/ -MW9vAVK0HR/P15zti+JCGrykiG1b30qYLXS3aj3dfBCdClGJARwEEAECAAYFAk1Q -RPwACgkQfcMm2s1ypv2BfwgAlgCzrVI1f4bZHN6YfEx+1r3p/EKODTNl4KvRl67w -ztckm2o7awsu3qvfb/TxUTSKzUE6OjE9B7T3MsvvzGhPySSiqZLGjf9zyrxL2NLU -FQiceQ9L5fupWZb+Vps+QFnmZLP+RuZmKAronNq29oL+huSEg5os8GQswovxmlq/ -w7auj9GkEHus/dGX2MRpHqrSx0JjTCj2laXes4x+oEuUUvfbcjGDGijvS8hwEa+b -iphHTwo+PHt22bH9lCzvy0Ca4J6vRF+JrS20hXxKbiT193O6MnlrFvni3m6tcm5I -TeEdCHBc6XyanN2KPBeeiHab3RdSBMWlpMvoQsdq781gPYkCHAQQAQIABgUCTVBb -QAAKCRDnYQLgzf6sLzHrEACDjWJtlpdRV6Fmumo/gAq05dLaV4AiLn59qFLt9qwM -CqhD18GpaUMHtu/arJTEed/c+nYl51uzvoxdkmtwZMjiyLZx5R7wm2LC4DzgZ5Z4 -UCxoASLwvxd1P33wLT3vkYF9ZHAMI+SQn2v5hrY3cgzpEYCDGNhKgO8empzI+na6 -3+su+/OFjaSVKkBiC/Ms5KRDQBDJ7oNbMava5rpdDmLHUzjKi7M6G7pAzEBWrnZc -5WXOIk0UYuo6QBSRb5laSDDnvKW8BFc7EDj4cWbXoolNNXFCrD98FNZ1FuPoZTt6 -kddQ6oW6qJydCgvPD11ILcL0AN9SD29DRdwMeSp1vkVHYA/tw+W3JCyP+gbDt6Wq -Ar3yfzBgJbMTFvDJcZh49YP6LL7vHnym1PZ5QyYJTaiKCXa28tKLDONYrbX59CXO -lwxE2SHZ7EZrjHmwyJM+AE6xL5P9GT8RZL5LxOzRYZvWvmSHY9MpEINI4ILtEk8J -1DnBzclulRSJOU2hEGQwUvHRPAy3Eof46455rdMEzsomd7n9LiMlF8GRg1dX9wTz -A1PYlhCn8Ed66kFPGW9AmryFP7/ysMa1CN3m8QR2RJoQyPjvgwmdVSc5vsOTFNce -5E/OVUDRZqfteaLCS2mXrl+/KGISL5Y+/b4Q7DA01OZZtUiE8ApPbhOez5QUvZ/e -aokBnAQTAQIABgUCTVBl4gAKCRDg2A/GONTVh+1FDACAulggWlQytMfrzaIWpOMd -5NqoURxpWrMcY0fqcMq8mqew0HOIqY2LSI0qxVYNKaECcuUI4kCfhyRDuZErt9zI -QcMNc4FPyTcnt5iBEzah8UXZhK1ICFACX5o75ZX+wRnzj2NgnCzprBHSrL4t1qaW -cIpL8Nje6QZmyswp68M+B/ScLYZ5CPeoABuyK5ayc6pjfXE6EJT96+q/A+DVq91r -F6gwQChYyULGIK3ONljtC4woJiqjIkqQ3wKR8fqFR7HCZjqU/uPuNY59J37mVKyR -E7uVhFSeYNsCVgg0XiU+4KFa2FjJcJHPesAFp7a7y7A0p7CWXIvbmgaHAvyo6z9x -d1+uXPChDPSpq4WPrCcqumrzoBLB4XUey//imTA2+x01qWgkHZFXNg+ytrXzyjZ/ -S0JLzx3hyz519kEEAg19LJPZY0kmLpQP572BdTJ7bXOaTuOz0Q6pcZBFrvFVpy7W -1/0RfT2BeXGFPTBjClzcfZsic0TrFGJHc/KEVnjx1h+IXgQQEQgABgUCTU/qNQAK -CRCdQoEd+4uzdjaLAPoDMLS1M4drh8qKy8ChaU0SOrFuCz/DJ929p7IAwoNmggD/ -c+B8+wXV1iqbZaJRTNLp8TutqX5Qu0DoN9LazoFXbX2IRgQTEQIABgUCTVBnZAAK -CRAvlRUIquYCLqixAJ46LD1vCgy7n6BEjYfpNVlEhkBdAQCdH5dm9o406eTWW1Kt -PFb1KkOXO/iJAhwEEwECAAYFAk1QZ2wACgkQrDCHmqtVsxJ5jQ//fEZfgrWzWAlx -LUnQxJ2xR4XD/rLoTq7iNJIVhfpr8MDNczG6BVq2x8pEit1XbJp+PuvKONDtWSbu -R/GoiNA0IDx1b127Mpz1KfPN7hdsQlTb8uKF+ESgsZYNBCjvCSFydTN5qpxv5xl8 -cQJpiU5RScOzqRpj+bdPv58OBPRCOXKhdQ+F9u+3ayE0PNr7kXGH3dwDtox4b5x1 -qghZPgI1NN6Y+jvERiSBxDsVURdaLpEb7WEYmsQwuO/UqdoATY6nH+C2V85OQZnU -leKKbSwnUyoQ/VIGI+rsAncpJ6j/1z+6FyfTOaItbijzYlJF09v9Mc5VVJz3S5oQ -RhDychO7xDYIWVzW6h2FV8XjyugWyE0x6blcP6Iklsu9Nxb/n0w25G0F/pJa1U+p -aZxfFVh3wUPwOy95ZUiJmWn3xVE983kjvZ3CyE123t2M2qcM0LxDZqkfGSNu8VhW -qhWBg9SKtBrJL2RNZowl44R/RaBW+EWQkD3GrdNgmEjq7Qa4dY3zm6N13kuyfg/q -2l4h8gaOHVsGJ7J+G3A8N718iAhtzxrJtNvGy8z2XneE7v1uH2KbE6BpvWM8BiMe -rrb2H6RJCrx8usGqdorF6ZYPbF0ymN8Prke9gg8hcoaQ4qoGcgW4U+hMLM6BsuPr -hVfVIRwfjnhN64k/M+asgTD1tb8BNFuIRgQQEQgABgUCTVB+VQAKCRDRgd16bEKC -cpWLAKCb6JUL6EMdgZ+2Ys/UM6Od8fhfuQCeP5YaLh91juJocCnTLFmXRjbuhxmI -RgQQEQIABgUCTVB7LAAKCRAwAo0kSBO1/hFsAJ91et50yD4Ui8vsGXqTLwUq5+Kx -TwCgg1Ud6vHGTks2Lxg6b86BzJeyeCSJARwEEAECAAYFAk1REY0ACgkQnK/PEVZ0 -b5VaHQf/RFXlrpB4ArNQwt1HkEc0BfgTcUt2zv+muBn6EtPcukZib06LwI3wWoTy -8hHpQoU20sYWOKtBLV15aw8pwESJkiCeK70LYu3lgn2csPM2EQsB+/AaW7H+TqUy -2orr/RLcgi3ZAVGofygZ/lcSuMpbGhQFBmlpXUI+TQPVayKPs1lvzBIM2EUMwNye -rEnwZE76StfzmzEGeyAMuclOCPHa7eZQW4A0d1Q4KhjfiLZDF7goafkj9UnoLCU3 -MqwiFxyo4OuBEBR0DHqa63cVOGlz/sNH9oG8stdyH9127kOwNhsJJTQlgsxqnZz+ -lgnHVmSrjf3nCG9Hs0JieIy4CkDOTYkCHAQSAQIABgUCTVFfYwAKCRBa+2eD84TR -jSZ5D/9XJj/IZnF70iacp9WWpMggi4C/6vFCYyPInDs9iLiKXNwhR4ymczRCePar -kDV5FLQGtFlJP0afl5aESYqysGIBpB5b9LsNwcd+UJ6Hgy9IGhRDifGZRcWBwZeW -Dqu/K2tALZvaueHb5fDDago0UMemFrgJOrGqQmF+SCcJjxpPyAoamb2Hg6ZaiWje -LDvJQ+xoExcQCAFsdlm9to6O/ieIu3Op3V3rPtn+BEFzQH71QVFwm77nSWQBL2Du -D5keseOnxZ78X2gKSx/ah2I+RR5J1aYMqhZ/GG323Taq80RYKjxFYn5HQ9E1dqQS -JDUtETHhfYPRv0lWmMiL5Xy+OOD+ZdiXwVzxHIq5HSFdgvZ2dzcWGk2ze2+i5zc0 -Gz8oT/CsYRSfWIAhWFu8LKsMJOneW+eFaVhpvu0k1hlyP2n23GKfBM7dr322+hYK -vkEcvF3iVUQwcSrvpay0BbpDb7h/r4M6cONQNuFCrMkWDIxf2Ldr7nw23Irs1agu -R8WETZMIeol5rlk5EfJD6+p3TOGMwpgvS1vj89opcmdgVxfqE+MHkmMUfzeRIyFl -/1P3YI0q5vNEbJacbVU20yWJiUYK129YCTgS+iNwlfM9uPIoBhVkFAE3NaXu06UI -Eo2K4GMCFK7vV2fq+LdlqcFdUtqJ6MWazlf62h7vZcl6EOywV4hGBBIRAgAGBQJN -UV9mAAoJECM7ilfkh1/5zEMAnRg1/BOVICQxes2w2vaOyUx6XfEaAJ997McxjI30 -oMrWudXMoxrpuOcDpYkCHAQQAQIABgUCTU7qoQAKCRBnZgDc2lqZQ2UUD/9VXM1z -paQvzAQplApRAfo0EL5IYkGzlgPfLugr2zrYWod67GXybrOrhmI40rV+S2j9t3cW -wjv6yQu5MrcP1OT4caycGhBGqA5TO66B//45LIf4VqtoypzVbfkciu2b2NawnhHs -FCOoJfPaEytPmUB6DgOk+xR17fQK41Balro82R103eCIKRZ7FvXq5wgdkBMqMtn/ -710BuZdfaSYH7LSp06tpVA/pKTIPEYAjWiw8so6GbwcG2tQlF4BwbcREsueOpbac -giPy5ESnH4C23T+y8qc/gmI5oF2RI8dtplM8RxKudwE2WqtpRi8zHiT2MPygrbCv -F99tgcYG/WzWBFTIp3HTNpmr+NKO/b1xPVmxaG4+Wz7Z2wEHAguR8z+NaVE9mLls -68bfyXM/yqQYKw1ZPKf/TWTBFJZMTvBAWEbBzB/CwZQmArrZTMPqQo4o7nVwf0Ck -CvjYEmbK5wx/HwGZm8QBg3cpTqJ3AtohGtRc96YUmobMLtTnnWMJOlp0f4dh7eUE -fTgk2mDAg/nb07TARh2CFOlE8N1tgJ34uyxfgfarlvhNyAv0+9dpQ6edtrvNrwKL -y4ppoEe7sbY5xDKhfw/EP/Mc5MTfxpSQmm15OtOUbaJYUgQ3oY32qJZC4p+K3wpV -GGxLzwtyDonuHy9ErnzdeFlOwrt4Uy+CV+3gG4kBHAQTAQIABgUCTVGm3wAKCRDp -WoG4nkG+Nha6B/9MQ+qffiBEwLUQ0FZU0wMhxYCcEwW37I5hYBArSUfX/vVM+em5 -2tAJXQ3fhc+2UfAds375B6LuirJQx1QlXWWYj60/a46iebqYMNpkLhLLonC2OKM8 -HIQS48gRzR2yMYNqSCqSiZR+B//mIwaHgTBvxTLjA4z1zvieUnb0W+wODrqKyi6v -kXawBm93XSyiE7bzm+zSnxlWQGN85OMmvm7ZNaNX/Fu7qUFwRXQ6o2HcQ2x9HnHo -8FLGITgRHvyajalvcSkyI3hO7zRiFuRDG7MvHR6q9+FJ9iQ6NSptM61ldOBBwkBK -qA91P2v3knrveHgQA9C2+xV5i7x/85r9NVUIiQIcBBMBCAAGBQJNUcZvAAoJEH0V -kcae+vKGncoQAIDgSadO21sTYSuWtxYTZoxLGzuM05httPShqKJNFp8XN26PTxrs -7FRNha4L6ahpuKlVrk7/jyGF8gj4wb4dgmIV0XnfENs82KtkSM4qJuVHlgxYzgIl -h49kJAvMN4SKN+gRblrc1+6xEeqgyunqhxVI4MOuzr/S3Cs8fGOfQpY9LtKJon8j -STvCHdgsBO9DWTzoPbUvblWa1xm0Xh4VmqaULORGCY/hx3z85WW/N3BGi0fvsjrv -ZgnqJD1c7LsJ+GbJzil+bzVrKiCtMApOyDoC+eRPkavADdLCSqUtP6RnNxO5XbOb -+7sfKIbA/gGkdBdNmL7a50fKTGI2RmxuU//iyh2KsxTTOGohtwAoDdBucFYN+cJy -v5j47+MAIMPN2fTKsPnkKAtiKyYWnY+EakBIv7tCF19UcrsQsP+I2lhDrUAjElb9 -SJZK3vFBNxdQHrj6p0I/YwLcksXAN28KZIPtiNo0nLby2GqQZE3/pvcjB366Aw+R -Sy+puZxmJGS+ETfNN+MAbOVQeme98DIiFjx3V511lBoWOgde4uxiFwLJWf+UPAv+ -gH+7hb2fRYkiFLCIBOA/i493TCO+q/haTjxdcUvy/7ugBioNiBlHPFJUpX0KoeRB -cgAcYRwo+5sh1zko05S6BNIUr/qdHa3hQIBvVkBbRRuQqI2Ncw9Yh8mEiQIcBBAB -AgAGBQJNUeDCAAoJEF6xPp1Ajzw/xmoP/3ylIIY2c077p9t8X2HweWjRt7B+gEaC -OG/s3d88E1sHDga4/PztuWLTukaPHAOthp0K2tJB07CKBN3p2KpG/arxiVWYftfX -lOhtE5WD9G1U97raIARKTj7LSpt1pRmmGIc0c2LAq4HmvRM7faIl+RKuYcqEnuED -cpwVajbZ56mLNvJ0EvWwfQcu5mHRN+Q8ol860OdshDiVeP8ZSfWrUnzrKQCBE6cQ -rHvKlCre/NIXd2d7PLj2KO2Dd8Rrg9KoNbQtYIOgHSWc6u6dgmx90y1xq71XitJ0 -Rpsb0WPd1r+YAqAOxkK0q/ROq00iFIsCu/I0ljS8mDDuWHs0UZkeY8lvzHDdNyr9 -WpWpABQ/O+u49XIi2q0J9KjDgbIuYHGcjFPy0mVgRnJkML4iexFbnntvCXAtgubg -0HDYC1joTRp/Vp7qINm6fcS+dHS1H2+Jtdy0t+T8RiM3s8Zd8U1JjTIMyn5wJjAo -NxHRZRw2q1kFyU/CNLlgcEAndEVk9iCaW0QlSE2g2PmCu9xB7DCDeAdUM/Fy7wuF -z0WvwM9NjwSmnqU9NSi1IQLP/6MSu2tFEj8GbsTGp3IUs6nJHPWjw79OJJ6hc1nr -sHzdwjSguB/m7EEXNCRSN8DLhCjqjGLffLSOH94uKDBng9nuc8zgfIHpUJK+0QqT -L1Il65AMopMEiQIcBBABAgAGBQJNUeDwAAoJEBEv90CDiX4SNYwQAJQ0+QB82tVN -n0kyeCn0R2xgQ8qM4oYliPsJfC/Q0OOYry5Ir72IuFfX+r2wVTiULIHDuIAcHsQf -bXtzxYKHVvajwQibCZcJGeacDEqKD9Qeznxy/Xg6sRBB9rEA6A8QIC7sjLfMxeeQ -SQmuH+8Q00u5+RpjQu3WpdUXMF9Zop3rrPb/uonAGPHn53lfFJ1vdymGa30zLyvE -vKpZsraC6fHDlHY3RsHqIKw+DIjs+syU9JJv+RH/lHj7sa8QcjAnQwJEqBbFjI7B -Dg0/ltyoE48eKmIszD74sb+wHYW8LrGzET93/pM86yN+ZPYWpaAUUo168uyXyfac -LZDjTPEYqmFd9RlTTZW0Plf5JWYovdArJkN9TrlUkK28uKYULdSB8Y4hzp1mLAMa -+4fKbGUs5UHXcA6JuKR3tqGw6NNk1u014bBFqAvLvFYRXMw1XayOzRJq4QBZQyaK -v105hpCbHBKR1QY1p1CYXDfwyZBJVhyp/Mm38eNiT6yCzdPN/Z00NeX5wg+muNe2 -BrJsBjvaRxhM6E68foBB7FCdtW60+FwqbeDqHSS1/yRXq29KcO0DfbTwlZUJJeEI -lCw2l11WmbHMh50k0kqhDW9gwBjxhgZaYRITMeNApkb0EeUWgIkFv0NEnkwG54BR -fFKmuMUGLCxecmA2AmCaKym5/077WQY2iQIcBBABAgAGBQJNUm/jAAoJECrpAeXH -AhjSWCgQAM7FRqBjXbNDM/izLCsqWasAIgxouITqYylPVeNLI6eAypDP8fInmVPl -CYDkf9dxB8tL0w9tjRU+7AtvadVVm6G3ZPo5bkACatCIDWQKjRpBQNo71dc0Y+aP -KyduvhugPeRMoqtDZ6ygw8tG7DvJ1bTOhgZoEmOjFCiLxnAwrznsA89wffCKBHre -ifu6sRL6AoPHz5cCsw7+x9TYzpKU6u/k1J7+K7z0Wd3iHEVyH0Z+HIHypNdyvpPG -GU4jLZf9srdOj7QvUtb2c62KSgSBAMvqQ1kc9mmSZ12ljq8+WjWTS4qr43PYZjDd -Lg15fd11wSP0hZRRF/69Puv/Szz1L8AXXrfCOl9EFIbL1twIcPDaMl2R0xOmrjqL -aIq7A3S0vM/07gGefGJzBLSbMDmsoc59TIpqa8sEuvUvf42+QTh1v5UdlQf1FHzP -k7/9voaxiQgHACOZtm4qldbB2IR6EVTlr1uDi2kO7rlP5JOqeE6tzHimogYH7q5g -Jy4k0Avj25LbuNXtQN60thnsz5Xgr6CUTL7jf5nwCH6sbTXOh1dh3jXm4TPqgKOW -u4ZKxDl82MTwepjXpwOkYISuBGEfXClqGeeyFQLMkYMURSoonA/udKkB9kmVE/Ke -mrypGLGzaGcL3554iHVMyn+X1G4rvPO/dcBCS/vUh97NUIhssyXIiQIcBBABAgAG -BQJNUpMnAAoJEGTIydEeXa2YKYEP/1BSG3z93IVbkLhcFYsIIvgXTSVmjl7n8XX9 -H0DaOyBExUNs+vS3mUqUcj7jYBh1kjc/iY3UleIRwL4BUNY9ZY5mqma2foJQ2khp -b/zmm814jsxCGKtef6kW7getubbUgv4xqlgtCgNtfGwZIKge7kl0IaRM2xHbnUla -Yp1B6RcZx4vQAPM25nkdQbKX/RxjHpek3oDTvY3kXS8yV4LXWRgzmVIinMmz6l3h -eKbqkHFPCRvLLid9QhLEXjor/vyqPIToDjEqlHZduC9/C+zNenEwSiaT0U1+qoLv -+AlF+/gNbGfcSKXqx7la1RDjjj8H2CFxtehF8tWBSNrIbZ5bJ8jla6FkNLbp3oJV -Sjt5S5lVaBJIWIeSJJR/VOzxIEezvXZGhmpk7Yy0E/uzI4kuKZ+CJdl14Bb46R08 -rxkFgP0aeKS2o5+VPue7/wZTbFtnorT2MIHxk9jrOnCa/BnX9wGaRnf7CExrSA1U -qSxgVjM0bXyzL9ykpVzFeoGNSRicdVTaGuocrvwPOo4kjfF7czSiG+DNvmHkBuhD -/c7r0P+iMOkq3hOeHAX8Uotsk+jSK9VXDwMsZZisPBFMkcUqSolJMTe5vMYYgzt/ -KayFxVNDsIqu1consYgmhgPFHOwG/PaYnPGKda0GQcwhTN3mCIAZZnGuCJFM1Mim -kfbg0nPHiEYEEBECAAYFAk1S7qUACgkQcxyv01PBoy9RMACg3L4/IS05NQrxqGs3 -vewff577n14AoJdIuNAkBIw1Pv3on1B0oBO0oqrpiEYEEhECAAYFAk1S+w8ACgkQ -6FZiOLAMtTNecQCeMdRVI3ZsieT0YGsVSE7wQ9o42rsAoM5n6GXoZOzoDNlZ/umv -oDJ2wQZDiQIcBBABAgAGBQJNUw/hAAoJEKnIbI3Tro06B60P+wXAYPsVi5mBxoTe -rH2oesnTaya69uPAjNJnaFkoXDXAOJdotxDWPfA9XL0/k7SaLCb1OQ1UaKcsGe3u -99R3/iElmUlWuhTgV2F7nUmUTjCWXQD7ZnQZRK/ik59cwn6FfNywGruG5oARNUhi -FXDG1q1WCgYYlI9iLIZ+YEPhS2r+BTRF0+IRYS72cKBI76xzuXQT5qOLWyvqAMuM -rkbooZ8que5hztlUevjYjWPpC+zCw4SB7iTfWOGWxQbM0PtLGHNrABUjUyqb59dQ -lHrxdvLX4NoJ69eWurYuPet/xzvZ2RXxusisWSscGet9md5TchyyTf0oEFPBNlKX -gozwJEtdTuAivzUTnWG8WeSXJOEzxJvuwpt/aboNzM5DjpCt9BlfqHrhaGJi7ZFk -xVUC2/+EDBqxPAwLEtBQ12SFFjNcCsR2YEv77mNTCZk+oRbt+n5ez7UXammlTrcA -WKD8lfKm8fi6nH5j8dKuHyGTP4wpUtWVZIQsO3Lsz0GK5bsXuVXh0g3sqX5F+M1z -kPMBPqpdNgVn6hWe/HvUasTAi7c7B3UGL1kjg2SftW/MJpXWcaIYzLbRRB1zFS2z -qjsP5IPasbOXk/SdAV0u1MiZDDMMjiir/sICKl0MCpdGWn936iverXVIoVns9MNJ -d5QJoPGQv4so3CgkNyFnk3r4sE61iEYEEBECAAYFAk1TH+gACgkQjuCbLeYc358j -PACeLqBzec6DTeYCXFpeUgcpmy5MZgAAn1we3oD03k0yBR6Q22rScGXqVVaGiQIc -BBMBAgAGBQJNU+OGAAoJEAfefupVe84MF30P/26+FdlfM+0GyhTjWb6fz99N7vPW -qCUpxYLsiB/lcGr5h5Wn/E/hwDETNWsX7rKwQwavoWSJ8Vj061eM0xy8nBI9Vzzh -rzaMUBFCh7b2vtsokIUt0Z1bQfL+gKESU0hLqjSNC3WE8/fxPwSWBmiczWPixzfW -fHyCHwEwR5OUocRxORA9cVeWvfzb5Hdm5hNpfFNMrdG1LkoMJ63/SE6OTm20zdtT -/PM0zptC39TP7bmoJueYnnncDmCC3Er0mwC6f6VnMQmBh+yPgGV9J9Tta3EcOVk5 -g9SbEAs/c/CZ4okTv6NJLYX5VdKmF60E9BkwAZq4JVAZyrFfNJmB638Zgqa8q5Ya -sfaLV3yoFCMX17sLXMiGc3dOwneFTEz745hAqOw2cwDoaNWR0B880p4buOR4wFcV -nlsiSy+B6iD0zWFISNrrjs5izARYclxVmGGm9KlLSX4keuEXxaSj18PsSn7Muk7b -BTcjuY0+xmdwzXabHBkNZfDr13Lxb+L2OPkAcTlNH4473AK5rH3B3MUfBmOqpfw9 -5AyZ7IILieiFhrk4Fmz9Jjbc4GdsEU1/qtDmc/p9rXiPCZhqeiQi3qA0CLLmFpK7 -ArlFI35wDUXCJnSSh0mzERojiB4Slp96qQ19LmynEh8fCoDBYMnJrBpjNJZyBwSg -Thuv7bHWpQM7efbGiQIcBBMBCAAGBQJNVApjAAoJEFSie62pgy67yTAQALUp2yWR -/2VH7oqyIrMkDBWHjPUEJ1/beSnL0c7rNpLBybtIrkFNjeZIWfS4/jKNmoHqOgnP -b877MENp/UK6jF5Qc3QeyI/OXr/CJC/HWPWZ1o3/o6PIptDNMCuy7c9Uu4KFYnlA -c0EHuVfi1k5eLu1YJnXya2vXyE0MkngnYcPo1I6KQs+vMsW1X+wcgVj2mpcAfECO -F450yomtmwLbrWRxpRCT/vtM7y/sgVmfuBVV4jhd0hGm2jDR25p1tWb15cu1vXPn -FguBBvVZ6cVU41CEJtE9DfVN4esuKaLmA2pwk1wkruiPPCvTUhO13HNwEenG/QVW -fUR8j8d/64Iw9d2t6jRfUKdctvPhnY6iIZ/2DKq+zFEy2cscMd++kqmR9WCCqPht -obafxJ9LYoZ42IMNvTzo5xh4322shcOV/jZtNNvSg/UmhspgpA0mNkqUxMbUmhI9 -vRKTWT9qHbOuYGCt8Kp03v0bk/oEuXF2JcviUOOG+Z/eflPTfht/8baSrTjVmcYf -NXHmaamAfoHzOvaxlbBXMfhxQ9pTCYF/3DWkfbmBSEkqxpcFgj5AWheSUHzGYrsK -1plPLJAP2dOWfHVlHoNKqvUKH6K5H9ruKgAFUphLMJwtugVXFv9gykuDkGJ6+0Jf -fXxBghOl1ZqdeNr0UrvLmxJoPs72VznWcQXJiQIcBBIBAgAGBQJNVB8FAAoJEMEA -17V/Kh4mxZUQAIGalnSZuIg8B9BSgVP5DGBoMgqXcExG/T+Ee7R4Edcf7YfR8evU -tWa8QeA7p9hVZCB53Ijdu4wkA+RFgZg62MjXBFrbfigDm0uXYmEdQosnsFPUwC7o -4PGSaV9gs5UezKkD1ykDajbICxAtLPZhyQ6Gpdnfy+oed9Fg1o3aRZMbuI0bN7Ra -wp+QYXeUhbxfraIGYOtI8nnuBJiO8eSz/KoFEQFnctJwg7CZgVc0woxMyIRT0AfC -ynafLMSwdX5zJPXO1uy3sz5U3+P+YmxTqV02KgIVr1HpOPQrLCdZrsuOO4hNvY5s -wTG26I1SgVraxvOy77MYWcs2ojTVjUopImS9qMjIyPgGl/5++jrAkMhWRxTzUFEK -x1Ib7W696JNJlq6nsYXZg3M1oJm7ayFFck53ldq2U9++1C2gGbSC+k2E00O3uO2F -U3q7yxY+dqtpfDcvQxjaVBZFfz1023vRquf/Odt+JyR2Pi/zVYO195PKV77Tsl8a -1p/FTN4jN6BVn4oe0HKw8ZdxOxMESMhE2wqhat1vBbaK9YWnivJbFhZu3BShKiWk -jvmOz17++aboGT1lLLE0aHbp/ojV6O/5Whc0v8PxbMMJyoZe8T1dDotC0pFvOLnR -xWpfwOin4VGEWnFmEBrLHoY49XCuuZJTKlTC2XQP213Hdc4CTjWjJjs0iEYEEBEC -AAYFAk1UfCkACgkQLxrQcyk8Bf1SlACfZjVrVpMijWXnLlwNZhtebz1DmC4AmwWY -WyaHaLbKjL0D9jspj1W/8+l7iF4EEBEIAAYFAk1U+1IACgkQ7o02PRaHlziNaQD/ -Va8yZU0v/UbrbB7uZ6TSrfzvf6SUx9Wnm0kiOTcOGoQA/3BcTLSDeiEWG/hbI2va -QjuWHCisRdbFx0cxSEFjxeE1iEYEEBECAAYFAk1VLqwACgkQvuFuLCp9giBgkACf -eTdajdfiNr135pdh0+pP3iTss4wAn3pNcbohhLfjowLPb0/yQurg+KKyiGUEExEI -ACUFAk1WxLgeGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5ldC9wZ3AvAAoJELR14ge6 -tYIpBx8AoNRcJvGN+QmiOqxZSBZkFy7zawNAAKCjBJUz1dzYDiDlRDdJEkIIP6R5 -2ohlBBMRCAAlBQJNVsS7HhpodHRwOi8vd3d3LmdvdGhnb29zZS5uZXQvcGdwLwAK -CRCUj9ag4Q9QLp3gAKCIe0+D6ZYXfdISEWMDxWVwuFfliACfVp70kqaGLsOR3duq -U7JNrp9ikVSJAjsEEwEIACUFAk1WxL8eGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5l -dC9wZ3AvAAoJEHoGhUIeiZBCV0UQAI0wf6PX48YGS1SlwxaKZF4UOQdaQkIWXDO9 -1OUwr0YVhYdngtWsj56qg5wpWpPrerT34ZvqVL8Glp0X7DpKBMJuE0RUmOsx70jN -ikCTsgVUyic6AWdtctMOuZhVMqgZSNOFiZ17S5LKisFfh6RNDUuLBjw1v5ntGuGc -zZt1tbT2HyncbrM3otohJNVTUFf6+5M7VPqC19zAm/vvwA9bJpQNabBVK0zdkCKD -b4A41RDwWGZ3bW6YbtYdmT4B4ldEAkSzNlaqD33w8iMOaJVYvYr5EJluDdfolYHb -dPlTZ/zzxlU+SlvJ/tGSFCV6gbSXkwvR0q6921F0WZ6+Cl+woelKRjZ99IbhlhN1 -JqgRyQGKa44/48As8m4RLlSbq8qCb2MNWaROXgduLKIADQgElTtO+RLzesNwagn6 -zt+8aDIlERhk7nwygxCVGv8l2TuBkfzNvIdeBJn5o7opfpDaEFbHUmZDOOWmSxWA -I0m4bQtn+MiXzEEbwyhxYZ+zP9zXf2CcyUn0Bz4nnPybr9XC+9rVQ6qTx1AFCYfV -1BFmKh93dQv97M4mzp9XT/7crtccyxHN8HlaC+bQCz0dJWyZevyPdqkEfdwDxpgo -lFxCztMgl3q8eA2EqN0Oo+RKgFKGyjhxi0jWzykug9yRLBLzQ13s/psuBauPchdg -O+oEADUriEYEEBECAAYFAk1Xw6oACgkQApCeGpL9E3JLwACfXFpGkHzknIPBQUfS -foMGu8W6BlkAn32Xh//Uap7rjTCvYHNLymp4YvlMiQIcBBABCgAGBQJNV8N4AAoJ -ECbjyHWnRCDvzjIP/A53JyzmjaBrgxiTXmFdTSMTzL64CneBd9AS8OAiJ+PPWHZJ -I8LjJzwt+8X6I8iP4GKCrcMM/yn6pbc0JP6HboEgY1JyFAf4Cd1e6DrYNrfGYSkw -W1MuaagjiBZmwFGsAy4dfQvla0/dLhQGdLDAhbpb4evfxMQj9VaGyBAPTgAJL5fJ -JMQiVMyI3g+PEm4SW7Lbt9/ooFREgOorY7GBeRLtoYMxkVcsMOzWcNZjgg1AtMw7 -ewRGx+JIaRPeDL7PWU4dgLvcBTj2YDDnPrpHp76xwncyhky/ipeQj7/+ZBqsaY0p -KvJON90IeDLL5xvJoFjrvSu6pVJnLqQwHNL/9dbaodiGe09st38ylCLZXUbaw+uA -/5fUUb6dpaeQ29RjXMpsz9uPlWnO5nrrFlkU1D/LGCduvw9WdWMFvWFXeNP+8kLR -hOMBhWawLXN7sDiy6R96GON3F4XIgz39UP63KI73VB5o0XwLSkw7GLlBQ/9t6ZT9 -/DuPhE4m2zIhUy9O479PkFlSmswWXzIIcs/6zhzrNugeRaT5yNBdgYaHOrB/vgQd -PzQ0FBZXnQOPzJ3mssV58PZQ9dLAXkYNCN1BauwyYJBACc+sraLWdE41t+oq+ghO -R84sXgT+Hw7TesJ4Ap84Ns8CF3s3u2bLBCNgG+qdPUXyipn5uZgSFw+7uFiEiQIc -BBABCgAGBQJNV+wKAAoJEEC/7oaLBV2aN5QP/jzgJAHp3mJ+j7XfVCj/462XDwHr -3RDZkgAnlNHP/XymQNa3m43bBnLdXy1sF9bMhcrBzDmC80eFXKkaJuOx1Tozu53E -ABDuMJV/ycu5PvHZ7+nJ4vxFCeua/ZiFkTkHKCHgPxwhtAQK9DaGnFaIsod0Ytj8 -XXaZM3eKLhfmsvOuHAbLpRMsEg/f3wlNZ29v52qywNun3j1OokRK9nOeVPqxbvKd -4yY1aGKsnnXsGtY336b8/t6IVhPGJ4oIUegEo13LJqe7xBoGPXfqrXlz+K+ZcLvT -tx6iuYBg8u3rS3hgvo8RASBjsJ+KclCg739FarftHBkrLltueMJVb0+aIKSerIx7 -1zR+1dGgY5KKMBu+ZiQ5zwLdUKdm+07WNYk6x8qCQOu0+1hZY+eOUgIlSa/iCYck -6MpOrsMYazIgTS3pLB1tHWpfVKjX+Q4Jdax6UFsyyPkIePwJDJSudEqOJwgA+tes -gIWlWnsb9itUE/TB06Bm1kNcmwi7NAWAlMMcfzPsla/Ab+sJy7AyUunpfQw5aeZV -6JfbYeSCwgM2vnXFgvbXxwlmUuf8GxV4P84pZmrGZt+xSHdVT09N/kbtOd3n2ZgN -25FpdY4pd+zlrHaVSWa9ByZ+MOenZKoChLc9aWjl/8xrmJw3eYCI+1ZL2k5YeZTv -hQQlEuO54iSNlyVOiEYEExEKAAYFAk1YLdEACgkQ3FzfxAeN+kGH5gCfYBXDJUcS -ROnbaU1eVgTfNKSVE90An30onInYRyuScQ/zr5CfUAxVh9V6iEYEEhECAAYFAk1Y -V/EACgkQOHp2lX66df8JwgCg+f2fBSlYrViPxyKoRbX3x1whp+AAoJaWkbxLYVbB -RQ6P0azqeLidtzA5iEYEExECAAYFAk1ZS6sACgkQ7oGSpuRD1thC0wCeMNgp5YnZ -wNXASkpB8vW7HYXVplwAnRUqQitdpPD0lmMWGJtgpanSi6+UiQIcBBABCAAGBQJN -WZf7AAoJEBFvXjqzaKTrmlAP/1l51fwvmvgN6sibadyub0CSkMjZucsNqK71Cmbp -Rv3PG/za/cyrZHXa3r/Uaphh1pA0FbXzRLQ+npavM4PjgbmEH5n0xEwsUi15xi7T -9JxqBWSzBOvGU6QhoX6Oajc7jnF93fnth/o3q+Q5tAMEyOfEvkXsNYe62oYRHWAI -d3OGklJH3wg8gYBdOJRatM+R8PgS5y376NMYgLGMKL/6UPBqqMsL+aTyVbeYFNLA -cNYUiv9QzYrHrP3UEWv6IKnX0xyXrrneSWPO705hl00Ep8fkGkDBS7zLkiPpPSPR -HYpg36fw2UdooSaQpCXqujuAgBmQP8hcM2I849jrLb4Rqith75lywBYUWPXeYQV/ -dS4WTKMNU2yfVzm4b48nAojrrOml31WmIVYQz9vRj4VOJtB81xuaSufe/vgMqD5M -RARwMz0oNZzUNL3mhvjkLVuDO1DbWKwwNuuVtepC/z04YFWqokQ1URj6EMvGMSIp -wnKeZHZlk+nvnW7DeD+2JWGcU2xJHVZpxfz+q9gtWbVI1lCAqsH7fetlkI774tQg -ocfk76eZtq+RIs266wF3NaGLpeoUD31BKLcgZUYaw5aoT5B9B2i3PAOAhD9uAJOs -2emUO4sT2zJ6dyEnCx4L17fzjXhqLSzzkzNSg38SXOF7/y0MBj3mdRLPpmWDynvr -Qr8JiEYEEBECAAYFAk1a8aYACgkQiOa6Hv703QPxcQCgroAzGRBf7WpiaIDVBsI3 -tigDK50An2SjnZbY0pJGHBBPHJBLgnV1ntv6iEYEEBECAAYFAk1b6HkACgkQCVo/ -7lJLCVh2rACdEa3aMojb0KC/x+B6tMSevdi76KMAoK61Egf13D+VRVYfEJ6EvPoB -QlisiEYEEBECAAYFAk1TE8AACgkQbQvHOkBYGDc+2ACcCsTLQZDeQb42IVCJHg+Q -38J/c74An20zODbkxxaoTHoTxpZVn0ZhiduniEYEEBECAAYFAk1YPpIACgkQ3ao2 -Zwy3NWpjzwCeMbyrhsXn0UANXhMgbFJpUMKT6bwAoIut6V80X8EsmNHClTZo69bR -GKEziEYEEBECAAYFAk1YPr8ACgkQL+gLs3iH94eurQCbBIg3OajOp53mJSmI3Iri -OGEVOSsAn1379k/KEiN/cGDD7y+LRucUmytGiQIcBBABAgAGBQJNUyTUAAoJEPO5 -2Iy4f3mpqh4P/181amy4VxANibc7N5Q0uSq021KcpUQbs9xrvURrSZW+nNPmDHEB -pmL/vuDlNN8SNknF3NBLzCfr426aw2LbNewb5McfajJqv/CWRATqMMdSCUuFV3oy -QKzzB37NBPzyZMrol8HsrNcuUJeguIqVbqY3lZkMi2Mml6mCr/QjK+BGadU3/dIE -wl3HnM33vBNMTVjfvNB4HRQQ08cz01EJzQ0JIYZFG1gmK8gJWi/m+lBsWJ+b+E9H -UEfF32kTUVtqfKcfgmaYMBiL7zszWvj9bN4mivmWDZQNeCitxwLzhZ/70QYNu0tl -sS9NnGop54Fiplqt6cGpD1jQganCiWB6EEM98ziCj5ifrMjN3jhp4F0VYyuZqqYU -H7FUD/G0SXo00c3paoPZWDAfxvHRXZgtmaY3+uCdLp+Uk1basLjjR/TW9tl+OsFO -JatHc2yKMaOdbX8kGAYTI758rYqueJ4oDBpU2x13XBqV4BPxU/Sxwy6zxh8OkFWt -yNb+LTHyVf9/G6FJKIuA7eyxLr0vO1N96ogwY4kGIDp3HZGamWHMOPnJqdLBqdUw -RXc2HYPEhLEf2g6abPdthE5VGrrehpcqOiWkBnlRl9jaMAebbvAvbsLHL0V3sNks -8mR8tCNfih1j7cyXUKaoOPJNqSCWCNHHzUcBnwBOMIOQSZ0V/nccLr0XiQIcBBAB -AgAGBQJNXYFEAAoJEL2ZlXIk5RGerOIP/1D+ptmgkdC0ZY5kTX0A1cGog/COfs1d -fVGHi9Vt8TUcUuG3xS9y4mls4iNAU81mTfj8JNUcdaLc+mafp83vycGv8me40S5v -cBwmFOh2BSs5NeqfOTDPoNfsPfo6QEg2B3Cfl9EEB9+8RuchnrnWJgcQgJC7/bT3 -DSEw12xQcBRFBfoNSfFF46uczHmKCOGuRIruYVCiJXLoGDdP9x+0eS09RxlzIhD+ -7v8TFe8XhS+l2XL0D7UsmbqY+q31Rw2dKpDqZcW92bW1avmnE9cbXnpTQQJ7M1yo -8xqyAYDqtUWRsPUp62xeXHOAqARDqq9581I/IL4v5kWBFSRw4XIaFqnoskBVWWGk -uAXNCWnkahUFYQ/jTAh633hySqX0doa+cVeHbReWp5eIKnDFY5Kn9EdBK3U8bKXi -5AfdmUmdAK8vAMRxy9TDr8Jq2mlgh0GtaHx2t81m7HGUB+dOyRA+97qHCW+6O3o7 -eDUJUgOnRCAbCRX11FR+WkjTO4GKNWMnmYmO3FHExaQZHmjzktv0MCHQVpfWk3RH -YF0VoqJNgxWKG5sOghZAUzoFcKzqt1P7k/dd1cp/sNDWJy5mXAplvk2Lw+0jMXo2 -tZ5xZHBI+t0PdzoAuxGCBEV27iVtzMnN45zmhsS6TpSBhQcbQ1yCDLrw4c72VmWj -htGK56M3ZdBziEYEExECAAYFAk1dqgAACgkQkDXDf3AkB/ephACeMwyih9kdYqbA -Erd81FMlMOP2ymQAnicz+bCi9Np19SqW5+EJ4zy8LifmiEYEEhECAAYFAk1dsFoA -CgkQPHmTtDdFa6xqCwCfVaLc60XqFWb24VqSwrN2t0eOh0wAnjrrTLPOb/S+eCfb -ARgs/bfu6YGjiEYEEBECAAYFAk1evFoACgkQe/sRCNknZa/KgACdGt956d/UCnKM -1fbWi7CqHPUsnKQAn0AcvmyzqzT62HyZnTJD9YmaUW0fiQIcBBABAgAGBQJNXv/Z -AAoJENNzD7MkeDIgx3gQAIPrpEcCdEx8hlawvgoHSi3MKPxLUX3EZ3aa8k1Fxe/z -DkRs08R4EQ3eA950ThwtnCKSP+qQkcCjwqX6YNQlyw9FpqIoCkcUILxvgJk3Crq8 -Dg3Mwssq7/flknroQTV49IuuEzUdLf1C7JtXIJnXqAQrmPocnYq0ZFbcuExq1f22 -0l6FRL4pIT9mEgfIKXbsPJNaukpoV9TEXr+/JdyO/oRr6PouyCCL5RQ3Dc+J3eMR -RMOA3KHGDfwu+lXMKWtk9RWtVs9EjjVl3AmLeV1EqEfrq93GWX5zmC+TGYGpGAUR -QqXQoywoMosJ7J37W0idEBDE6ebU8v3PC9icfctcOQpsErL5iGIMdM2hp4omg381 -klCOkqeFxCz36IX45lXr+dXq8Gw0luVHOJwalmechgszb1erBXMdTx2fhvvOJe+H -TdohMwI/cqcUoVbPSz+/wbEqsHFQFfQspFCciVQHrDkg51IIzhX4AQo7zpjdS18m -zONmYN0UYYFWnMZCgCqaEOe1ZKim4u2niiR5eCRF+ur7UXueipJ3FBoEggeKWSqe -MCFBp1amosxhZleMLUeLjiWW+3+YoXjdMi6l4NfBrbobZpLrxDqhmYTOQg27AAos -oIKDaCFpA7iQQqqGQBGgqjvWdQ1Uce78yEKGO2Zkr8RHsqBBE51C/DxS4bx9yVJp -iQIcBBABAgAGBQJNX8TLAAoJEAMD31IlyOOG3ukQAKa4FeTnlaeN9hH1M2iwq1R6 -p62pHQ+74y4LhbrZ832K6vT1fGJen3l6B4a7XtFZqh9hwfwixOlg9QaOS6ubw463 -ky5gs0F45y9c8Rr1yUjUUoIweXXXVfrX59Pw2cPRZ5mnsvXMjHNcbNcZ93VjuMq1 -Auxjqixp658A9/Qdxux7rDCFLQ/EktN64SwQxNgy5mCKlPDfFWEMh1m4DBw9ui/v -+YckdL7fL8Mxw3REcXbA/EFS59eOVnSiHHwiaNUYzQ0GRFJp+rZKrSbyrCUL6CMA -aB1mUwAt58wfEYVevK14cq3jAoSQ7D7OIWz1OYI6pfABJdZaJJAKb+kZ03YYQj+F -ltQxuouifdmeqZh4S5Y5YHwvLyZ2gUGp3h6pxGl1arnuCXfM9scu0ilB88Si1frh -lsC5CHJ4jhZN7tvJlK7jswEPXQFXPRvJ2KEeO7DRpI0Wtt6pCK1wLrLL8uDhv9xO -G1jCWbPA7Yy2rYoh0fGZIMFw0W3zWTPplFs8gC2HjuE4SyZTag7e3g/pRxkJ7BRq -6rv1mNbi8xB6uu4QRCXj6I0fsmTIU7DNLjIcE2gjDaoaVJiQ8E36ceeatMaefm/F -9m7WeZbgJe6JSvV7V6YMdP087evtlod8zOyzpVQ85yVk/5Vm3QJBccO9Ad97nMHs -80LgBWPTcXD0ct1A/moViEYEEBECAAYFAk2HkrkACgkQxRSvjkukAcOxGQCg5+3N -zIdCLY5Z+oMmyqtKfFcouvYAoPM0CvjFVmXE0PGAy7H101MFIitPiEYEEBECAAYF -Ak3nMpwACgkQt1EUCfwV2+x4VwCgrbc7QmFc5TAIxtSXU/7phobzasYAoJOKqmwN -71Q7I1QrBe3zlEnxc2KpiEYEEBECAAYFAk+FKoQACgkQVuf/iihAxwi1wACffOMq -cQyUOp/d521GlGApHclecxAAoLB0PS+PsIhnbcWYigHFvxoC7hZ1iEYEEBECAAYF -Ak+FKoQACgkQY0Ly7Lxa9rm1wACdGBGl84xk3r7gHcTF+DISEDT8n5gAoIJAk+60 -7fPVPSg9iV1sT5uXI6AhiHUEEBYIAB0WIQQRoWa2WdPoJellL6EbuJwGAjZ0SQUC -WKGRdAAKCRAbuJwGAjZ0SbVjAQDQWoN9CU5VSrF6LstrStqe8R+nl+sUAD1E94XT -MhN0eAEAxQUfE7tjmwB+G2/7y0bpQkHeI/pS1TtjnvAn2UPpdwSIfQQTEQIAPQUC -TWDUXjIaaHR0cDovL3d3dy5uaWMtbmFjLXByb2plY3Qub3JnL35ibGFhcC9wb2xp -Y3kuaHRtbAMFAXgACgkQctTf+NTD8ZcTwgCfUGUn6Q5HYE08gx8KzicukhbLsAUA -nRaRuvpBEPuBHMMwKCPSuXSGMGkoiQEcBBABAgAGBQJPhSqEAAoJEGfncvCDUeCv -6zwH/27WbowgGYoDM9lfVXMXkFb1wuUwSiEYAJYBS+9cMWDGYCQ8bwQTM7hqdQRw -sSqR9fe/S1DVMlzQFXflFdVKnDzS1ECoDLljXHdvnnU2izUFG9zA/UhNG9ZEYBwS -hRvGCAfQG9YtrbPgqM081/4g5+NBC7nbolkrs0GpqVGJCr2HlLfJalrFkqImAghc -SG7bLJkufGRc2tWt1Evk0fVgtdVRZUBVJJ1e8B/XiHznomsFL2NXWFYhOIgCpfWp -7VZmiyPZhsufkMh4Y/y9T7rLUT1YuAIToY8CPCH2nB9Xo1iIEuT7wTnN+irCGD/p -jwMXyh1uEV5/13EQ1HxGodI58mGJARwEEAECAAYFAk+FKoQACgkQqM4opgENbzrr -PAf+Pcj8NnO2RaAsor1FUaGVYpieXYnYiU6V6irNqvwPz+/CdJ4BzJHjmUXHLsqF -mYiHUyjibHWCS6kwX0Ze+lq8eYibJ7Df9/THIamo1h1cCb+zJ6wbXzjl2sNSw4xu -9OI9fqX6nHSUIb02qb5T1fEWiI78VLzDsIIm3lDw19u8igADMjE1/HyaLuUJqY2U -/p/oG9pacbQRWOw2eFUMBiLNRn4IjufnZVdOQg0Iro8CQ7xWS0ywhfOCCAoTlpBq -rUOlsh2eBge15kxJ0BJpOn0zrgMU1V6+P8BJ9QTz2LRDUGEGQ2JyHWqate9P9ulw -qsl3YQVXqCqPznbrjA1m9hXM1IkCHAQQAQIABgUCTVHg8AAKCRARL/dAg4l+EjWM -EACUNPkAfNrVTZ9JMngp9EdsYEPKjOKGJYj7CXwv0NDjmK////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////// -/////////////////////////////////////////////4kCHAQQAQIABgUCTXNw -YgAKCRDJOfmX/xWGuD53EACmW/kZqP+DNElEfOm8e/4hYM3dC5twgOfhSbll08pT -xuVwCTwfp4j5JWr1+T1Oq77kM1FB/NSkzYZlNLDuZptNPYxZ6eH9p8Oe4OpnUaVM -Dypbp00xa9vyym6se7vnX8bPsdJEj7WLvZFiIUya0OKA/n28DNPhCzBklka3YEJM -UE04/MiiLgCHUluM1BzLXfLN+AaouWXM5+OjLUcZ6qI3lfEOpJSuBlM56g23QS7v -fqQuEey5Z5+i/uNe13REn3XYH3mpinDP6lgQC0On8R7wbntH+5UlRQK0gvxWcsnA -NvE1psmnWjdr7fYhK/bronEAbeSb975Bih9qujEr9u2QHX058jfb4/9v4oD1la72 -zLCyfhAa2O5EMOpujoLE+cHZsv0urgQgc8bOspNDWyRLSdOHl6Z6OOdO1G7uPEeQ -DAsH2kIdcQnglmfZkjf6DP42iOax8GDXRVMRd/RXvwUoKs6RPqLC2yc+QAmTI8fO -h8n6DER9RYbBwtr1FdFSvTCqJXCr4mjJyTWNwXvvBT0fuJs0N9Kih9YjGwpBIia/ -8J+cr+83tkC0F3bKUL0pe3Yle9U1sTXHE6gbtF8whCQXG7YGEc11fXkrSJJ9wNo7 -O+LYnCT2M5hDW/zSl4HHQcfugzI7M4O7PC38+wJywzWq7fjEpw08rXoIjLIvrgiY -YYkCHAQQAQIABgUCTYeStQAKCRAAmzN1a5qqVS/GD/9BeH6PjOM65wXSSWZU9LNb -t3BdpALvEZZNl5Gbh+2ANMYGFoc3wAEDZVf9xruQHFR7LLxjYXU7oE64m60/heda -eqbQ8fCiTgq/aBeBHMBIkKkkS8SwTO7yGQl37oxIEctC/S+rYTF3O7/r9pVTbWVU -V7+76N/QEgAwG4jP6ybGR0fKVlCVOKhDDeRBjA9M/LCaxoWUQZDv5g//2fALB6Yx -w0J0Fu5ugopafYqD1bFXAhmr0vIillZEzoWZv/X5Q9i4D5p/81shjS8KkYi1s3SP -qGD3XdKTHEQeZzLZgWYZ08hSa6fLMOmsDau2St1HlqQf5cTzOd8pTa7tXLImh4Nx -ciNGYng166Q9IhkoSw7AkJ6yn7Q9BfneVLdGtONMyg42jNkk8GVnzQcu3bFyET/4 -ZScOa4b9BkifyCvf18WeqqOAx6QQ8dqnuTf2AF4GZAS/2noSYXLKZQyb7xej8ZzM -zSIYY6bF+HU/MpmSl1sPiFxSVxyNTHWGg1r87nOnufpTc73PsWcsoPJo2wQOiMbh -WlwlrSVnx8Jjz6rrn/wTOLnNGvOixazhmje0w7IyPXfN9v1mk8fltrDHCj8oUm5S -zdWk/fSVvIHOmj6tEpH/0S68VJVXBaWkPmbv+jJqY4HaFbBj6v8sxP4AUN2OAtJp -ycjstYlFBV2OZIHmGkiO/4kCHAQQAQIABgUCTeo6/QAKCRA2RfCu65tK+vaXD/47 -MnFmp69J8FwSY4+//rBjZX6LTfjFTnhpcUNx/lWVjSWqylQ0BvLFInU0WV3iGGS/ -dZ/gecv89Ev6wtO0oOFsNDatMGyYAVr7aj0/yXMAy66LsbbmxeMa/Jd0zk7A1kk+ -SQ0hpc1qtfAKtwBNi3pfuJxSsYiYO8jCOxsOkev8IzGXDSUFRSqfF/K7TS/VUMw0 -ixPboQVbb3r2hMQrbtc4h0nB96njBw7iJiBOUc+Zuog50dwEMGTtG4TorVRGVQH1 -IoUSEQOoJdpgy7VEBwEW3KiM6Gq3+zYI2EvMdVQNGI69fM6YSg+WEf//bgxZzVBy -gElvkiWoFmohHZTJ67j2ZxsGja4ALsmsXlUa/N8oE2uCghYq1sswxBHHNo0wNzWW -K6dRFliCCmko7Zj17mtjePbyLTXpGC/R/eqONHfYbXdVjwLT+MhUHX6f9cjpbVcO -lD1v0ZAwOt8nhg+EMm2I/0sXisnqhns8s4EAF/fUxsKteuU7QgRSrMYM64BPzzuX -rspRueGTNiXUBrNagtvahGGNMnEU+vm0PC8zGYsFe26+BRyoQx8QtQbYRPEuCgLX -2S508giVZo3u5hg551O+y2Qa+5xqInx0TDnqI7X7yrdIeoKK+cA7piQBBmQHL1A8 -ud7mMBMGlx4F8cJT3FqyuDHkAZlJdP9x2qilKOJBcYkCHAQQAQgABgUCTXf2DQAK -CRCUjdMAMldVm3tbD/9w2NY6+MVu1hlIp2Cf2b0WHGUwaOddfceUelFezaMZdAki -wuLX0QjzHKRsNZF32UQ4eQfnkNfBG5TZBxbkzjMcUgDmyEoomQ9hjeaCPwKfi4tO -5ohk+r0tBCI4UU7vTmSUYlyxMpG0Skbrr0HNzSGmcBgSbIfwRdUB6n6ZDqIP25W9 -tTf3+k9vdf8UKaLS8eQb1t+XyzvOlmXGq2AuuRneRtCFRzxcXQP2tz6OWxd6DxBF -43l5O3GX1sXP4e6bU2xToyhO5o5vY/ZZdOtlfONpG6wAkRyA/DR9zu0UpxLE7WIS -TR3sO4NCF0k7tCii8pgk187IPvLbDtXl/shxz5EK1oeUVI3DY6eMabDTdBEEajVQ -wmSVIbeSnB4CLHhal58nKH0DEHBQsYZJyWYD7S8Dt8xN4OWpjxYHBCZQCgrAVeUL -7fGEvgGihLYzzhiklBhDrnvmcq8qyHOZPIY1nuLbGlT3BCtWzjB7uttF1RPkf46L -fu63mNMu+9gltMsrX5QB+A/cafBW+3JHuUa/zNjrxc9hNij0X0EjZIbzxooH2Dp/ -sIkOvDV1PBTRB/fYQlDK9vOBB049LquJVSKXOB33lUC7EY29yVQXtnXnUf8u+PLC -kz3F6cjeIiKQHWo3d6oqyN+Ihf4m+FXYFNTT25Lp1Eo3JGqB72SP6uvLYuuW1okC -HAQQAQgABgUCVdbryQAKCRAcJ0I3JQB3JBO2D/wJsiw/ytOyrzh56q0Sz/wReYOi -rpHxzJA1uUYW7Vcveebyb2bcI9Hg3NAi+pX3j3OJWgmWXdBaW2PQ9WorNNoGJuYq -aRAD/Sfh9Ubwa2v1m13uX4Zn5ECnapSTLHAojW6wunRskJTQ4mQEhO6ewPaOSHNz -HVIzHW1Q08+iZl7z3IuCOZXjW2a7Qih/F3M/nG9MNf1iI3NHHMUW+vIS70RfpQCo -Xcwg22kfRxnJrhXkGknkyBNbGbwH9XjyRjtt/TnK6M6VKbfTPdeOJblAAjtuNawX -VY771s2YoAjUFRGEL20Ww9EM11PV5d5htqTN1L9Zg7tWg3nzv/iKzeYJBlBn/HAl -X9YsBPVl4xeDZhKlLTe6mHYsn/8OAaMe9UeViVRCM7RTLEOhrlF4OZorcSUqA8xD -Tx/2yG5DiQDaLG5CS+qSovNTnHy6IJ5UCSI8A8rIIiruRYIPvVlxU5vNGRJmCow0 -vMdTxN6uQBRhoR/Pcylhrg/KNvBzgRPsM0L1dVBOX8J7pO/xyzKttYxF8Txx3qAX -E8gRTkBHvO6V+a3lB5dixtZa5T2EKJX7O7YkBss57L3KU9v+B/6INKV09vV5PGZt -YT4WWtG0i0+LdbRSm8R8900BOKnOcExfY2Fc9jCMgLhwvwKyjFl9ZQpwYcQ/Lmra -TPqDFwH3qC3YALMdYokCHAQQAQoABgUCTekzPgAKCRD6g1oVtK/ywkW1D/9YgJkL -s9LKDtmpQ04xgbHhXU2W5lyeNgDFNf2ACI/rbqjOUv6Abn668Xe1sijWIhaU9TLt -odBZcbA+BItChr04ohomiZxS9N08FmY769KCN+84tg8K1DAkqcNk2M2vikTl8VVI -/lxmiv9Re2+Ekiwwv+bTIFFRR7y+eCcl5mGURkGrEUD9XBFBf26IlSNT43bjvxED -QETncCh7wTNNwZJ10B+pcG2KZ/6hCSeRQDr01D2wfpD+g/KU4N4JkJztMdX6n1Tg -J6uGrhLlrB7Na+dZWHi2TZ4rx8sqnZgWTIW6dCa6bTFFRyg0m1xgOckRAWDJ5tjr -ypWHCP2FZwM9v7F/DRyTemMBndxGLCgrcwxYCye1qZN8WrC1SZcQjy1rC2RgYUZl -IR2pR9cxwBcpnIkF/psFOYlyxS12LKPydavGo7TQ6h2eKIRPgW8ThJn/wHXEm2qF -Jw1oSrCCHwqsib/s8xrBYbHD4v2Pd8LH8GqapzZzZlU5PR1LExjDs/PP1X/u6dXD -S0Mvx2BBBNKwrjP9F71uOsGnhp/8oNsGpukdRYWVml+rh4Kx/Yp/uZA9+HHH13DH -u1BTm0e+IvOOvrdp9RZaJWjajHZgvUADQRs5/gE7XHST33piT8DBjYnO7nmLiesl -rknhxHWQlHqJMOPFEls6VcsU9bDSDIq2OejM3IkCHAQQAQoABgUCVhYrigAKCRDD -vXgyaAwJbJSlD/0UUFZ5xRUQeA7DP6vRAXjUeT8EJCrbkIv+RP3+h/RO+QxEvMTa -lgHKHUfOJVn6UIfUMiUF+4iZ7FnQPRWGLbbqLEJ+AQ3EobQ8pYaR6M4iRKq5HUDS -ac5Izd9kw/k+UzGHEjh0GTMW3SwfJQ6YnfGmhqkhbHt9kdXeNfaf0HUzSeHyWYpG -z8QkVMmoU+ANSV54h+QuWV3qOBl1C0vZ4IzjCk5gH2D42VtWKf4I1aT4dyXeXVY9 -Q8iyU77AeYvpuYwr3zU5U879taLGyBOxhPiAgDqZI0zU8Ylo7lQLrxVKUcFAO042 -GcUlGfaiIraxWEZ+sphRKHKmuNfSzKknMNd47SuKAtyaSwFHg2dfzgzaLtoi4tKI -Ut9lKmHtYITwYr64x/3j7zo8XdrcZ967Z1ZLM6QJZcjLZsTMEsOyFgBPeJ+OglBM -hqyUgZJH3JYj+fgtXmxYtNVQ4fW3wcmEB4FzXoRHhxa22dFgIwirWkwfJFhExs/p -LanxGfP3qCT4sFgDOICHmY26zIbqCCar2iO/GZF7K62on4oi073mqWkQ/8FHI3CE -rWzIC9Eo56SCkDoNGad+ICFgysvzAcXN1o28knmovHy0sSbEZ8fijPDmXoiM8JJw -ml+Y8Rl0zQ4eyjOsqiFUcK178AGhWwfn+Kj4N7WAXsm8kE5cZTGBfgAhIIkCHAQQ -AQoABgUCVhYrkAAKCRCdC15bHuyPDhhUD/9SjhJ9Gt+ZXGsCCOrZ9NUdGQEjQMQA -Vsbs7K491kByvpbtcQC/GlGF6gnLXiH+TLzmMX/plLpfNYamp+CmODigZxwEjqRA -SJYnOXsBuxVHd3PM3rFZpe5kUvIsIVdfBR0mwG7/r+1XqpG4JI23K7VB0E3uk5h4 -gwQLfbWA9KiCXo5URmctF04i0DH6taB1qs9ToCcO+/AsFuI9ZlrS4Qz8MFrB4vgS -GDLBD3teDFHNzyMol0O4UPmi5OPaohdf0NroYi0FXF9UAm1B+bXag7wt4j3ke07T -mkXI3ygcbEP9GiiznqpIy9k5rre2htHHkbLRA/fihosxDfPDLIAkfpEHiY8vjCqK -TQm6bM3O8zhoJ9X7aIHCV8DasUA+S2WYW9x/rEeCCnY0rqyBIFAc6sPKnqiBnkh0 -mXW0BfyAO8/qseyLff2j/e0UIUF10Ac/W5TbY3Taed1aVmuzlzx4YWBwci+VxzJj -gNFTiga5wYR6gltmgA9koFk7KJZewKGaHGpv8nqPGOFFZpTFioxrBXlvTsM62MOM -OqfHQ2rHcQuvnYaTW041hOI2Kl2tRCvpGcPnmU6dCvnBomGIIAKX8/85BZIWMJc+ -jjv/NeWIM6z8g7n2yvYn/A3xnLSvfhTWb8n+gb8oOu8Z7wEg6G4ePIM6Jhj66A6Y -kim2XBK1tpeCYLQpTmlrb3MgTWF2cm9naWFubm9wb3Vsb3MgPG5tYXZAZ251dGxz -Lm9yZz6JAcMEEwECACkCGwMFCSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAUC -SM6wBwIZAQAKCRAp7li5loZRcfkiDBsFLzT6cSZihUH/nc/wTCbeo4g6SfQ5BJcd -4iwT6WHHF7acKOXbCi7fJ3CN6dgQuTvHtaI2wPZH7HTMuan5Gcc3kx+KTlfilPCU -T/nXUfhVJsbfYw+n0pSeOqqYYHfMQiHJsM8AFQFvZlnNGfpQr6xbHSEV2CsVzFBJ -ygrFXbH8AAs1Ilexgtszde5t9vtRz4s8uA5CoK3V4MPrAa9iTHeQn6thtlcTfYiI -VvCEf74y4Ck8m/8OdKeEuZB3C6ouf4vXPiMAnsu/a1n22r1kZgSWKXSl3N6U++iH -WeNIYWYb37ZHu2IcP9mlbFtE99RnxpV5fuNR4t87cpls1jSXCA58ytZaUerbbX0l -pu9zmdW/Z2ncMpAJzPQcC1ba+6aMFM3Wdrx0NJZfOW8vNezj4DDhfR9I/4rpImVV -KxyYIMvFYgwL37Kt3FYNp86xFY+CsUhGTZgh15TsFqHuoAiuoZXX381E8ebC407B -bXr1WijvgR+eswFvpMfG85V139Ogai73NhhAiEYEEBECAAYFAkgd5twACgkQ4V3Y -V7FcN9EGgQCfdWSuOaSprB9iZiuWNg9WjByTJ98AnA/hveaEILl1BnvWGuQO4IlN -8pbyiEYEEBECAAYFAkh+2sgACgkQSgobyOT0/+b+pQCgnubKGSIdOZtwonqwh95Q -DWFRbQEAnjRhi7KKhx1r4ibJ/V4ijHLwBvLmiQHABBMBAgAmBQJIHeW0AhsDBQkl -mAYABgsJCAcDAgQVAggDBBYCAwECHgECF4AACgkQKe5YuZaGUXEgmAwfVt40Tp7N -83A2tRWo8W7S4m4k8wzmjqCniIhUwHY2V5sCJAUN+QQ8GGvlIUBdg4ssEFriY71L -3rINMeTrZUwgbtuz5bUb67z2k8Upynve1//VVRZKHF/667ffoSOjTum/XEZtOh+Y -ASQmWq42TW37YNrExJleepU0AUBp7IBjkkiPHuhoGlzCKVuqaWX5VHPDLD+VWabW -OqI+HtU73Gums7B+GGrivVg18NK22r698SpmjOSNyiS4kQcnIgyWWxGDeh12Lk3p -4zHxOx6tSWp86P3V4PI9k1f50X2Q9ntVGYtLE2EAaFQ0ug7YaVh5zv/rDmx049Xt -n8Ut/iW8NZW8p2O0OmF2S1yTUpPDp6VujXh4JYQgAYEvn4F6xGTM2PcM2CuN21Mq -JjQeceI+D9J/VPHQ3EN44rxn1ulBxZ2TvHuybsBnTJq0fCRqoeczqR3y4+/uNwVu -jG6GwK/3wau8jHcgmJhUMJjW1z6gB7A4AZzzrreX+yecQQHE7Wsie1XmcjdI04hG -BBARAgAGBQJNTqUdAAoJEGnkYnZPxZ5EiowAoIZ2ZPD40AfoFx5LWPEEBOvSZa5q -AKCcDgNPK1d+lGemqaTDPfLuGLyHDYkCHAQTAQIABgUCTU73WQAKCRC825W3CqO/ -DteLD/0UyxSqE1ijz6PhFark7L6PrFFSRi6gj3nQk4Z8gWfacI8fnMVTyH9mOU5a -Qexi6RFhwm2cuMPkr5Aue3dBH2mD1DJjCxXJuM6yEvAz3MXhG5T8rh1DV5mWfWEP -92rBUKPbEmgsRiWBeYocmHLZhd88JKuwMONXcPcDoSQ38QvMCHukhxHq+tyXciRR -l6kbATpjfWduxD6hfCuLTOoBXsQXdIThriYU6Jb2tra7pNGIfrNzODYT11q+jZg6 -QRxrq1RkI43FD/asvzI1s4YbtVN9HSJcmiAZViXtjLiG515DBlGWLn/iNm3ZI5pm -Y8xaCaPIZjwbeYRAYffeIQPoxduuc0WH6WDGDBifmSlFuYq8VOLBJQn5WmpF8ZBm -5AU/WKskfqB19IDe7c2gxf6dje8iCRmeNDFeYs+YKDD5hjgO7zCTFrSY6Tt61Gbu -yaXycAogo5Lh+k/6UQd77odoFK8B5maM+DwR0WQ2I4aIHOAbBzfkHlZSaWeudaev -jQj5ogm6hWTviHx7j8KMcIzPn5wv8Mig3Q3ElTJ0WIo3P9oAiPmmxN8Es3EDNsWz -D7qgRsChDypYUmkhmMxdzR8F7+1dLx7SKgPOoSNw6ogsNVEcXVw0aCadVngJfDwp -T9QwGVElD/tesYXsiKMADA1uOOVIvEZFLTqj5GSbEyVBTK2KjYkCHAQTAQgABgUC -TU8e9wAKCRD5QQeIeDR8DEYfEACFgM3Wg+HbpxflkvNxkxE8GfSdsH+plhWfwueh -TqnSPIxrgrxY6wjUldTH6VwCZ2wrmZH0nKRXgJj/hu5mmKrXp3I9qvkGs3xgetH9 -yc9rxwYwmivUxSipPE7Wqx6cH73PZutmUoaHG3/e3IYtROIHSXVde/S4ML6FgUBC -061LdoKHzgsikjgf2DCTZm6M87QZX4EyG+uZvI9Ow5Ao4moja6oY8tWlMdtzOFh4 -LKeki9B1AJLPdu6EWdoX4oR0v527nRWYx6f7XJkNVOJvQXmT9BtpqA+mGwmIUUmi -nGga2e0Y5oZft8qEgPcXi+n7RHsslM5Pki6fL/+HKeBz1uIb0VRdpo/53yHZwped -X2qGIQ61hmvbmKvFh6m8gye1BBb3/ix82cfN3n8jzjvfcbHelOzjAWbEH1UhipiM -VltSNvwI+NfYD8qGHPBPsTankPzpF3ubuL7DRsPaM5a7ebOolNUqraiVXGKo0KCt -RK3bRb0srO6z0fBJwd7t6XPsoOflXzvruIstDiN94ziwfE6nByJLrOAz2CjoKf8J -0iAKZKVyaHk02XG8MiLIb96WjThCfcNfiREHmd7pr3PYZkS1JuYqOIbDoRt6+IqD -YGVNFHvSQMvjC+4tN9GNS3QqRk0yiekdPxDrT1j5/Pg6b8OiK+ogaHZU35rpl2bF -XOTQrokBnAQQAQIABgUCTU8H+gAKCRDg2A/GONTVh9MmC/43hhoSDqkKV4mljS31 -b1JSAAN5TWsUGfFSU38qYFNdEDFjMlIG5EoqtWiNPZprmjo2zoa2SC1Us4EGXMN2 -9ddZZ83X5kUeDjROoK+9aMmifxCnH/wplsYlHAtuwSDBXIlgmCy2HZ10UNKn96uO -EJjWVaymyWiJ15ZeGvCY0Cj6BUal1tPZ1i8WZy8na2QTcTI7i2M60nZ4AGi2jN2v -UC4xiM6sALBy/Gnzs59SV4rcg2cLUjdBEB+i8w16nH56vsLNFRRNhj3sQYYa8mFA -NvsI/3Z08XQ4pa20d/SSzozu4dRICROhjI3pNJBOI6+W40NHYeH61iuIpuj5vaTL -XIFGPt8qmzuR67M2PRZrUK4pYFyJaSw2BFj2Lv64ykPqfrsUgIBg8qnjeXZ0bV/4 -j77CFpE78DAaASNv82Nif/tgjJRAI5oYVhu90tPNPG9x0zo8LtWYQyvRu0Vh3h65 -8H6XzA+CEeadeJiwgZScEPeAoDT1Oi9Jm9BaovVN0LND7+WIXgQQEQgABgUCTU95 -+AAKCRACWrAQaxfqHnTGAPwND0gL9dZp4WDsWGSYE6HawEHO5WQzIwu+VYCKlSZu -zgD/WJmWmcgOX0loWsyW9J07AlqG6tTsDtHl8DvKiSusRwGIdAQSEQIANAUCTU/R -XS0aaHR0cDovL3d3dy5hMnguY2gvZGUva29udGFrdC9wZ3AtcG9saWN5Lmh0bWwA -CgkQcW1EEz2MIi1OvwCfQjG0eHr/kHanCZLFuf6SX19OdUkAn06K3zrS/gYyMLrJ -egK+/Lku9eO5iHQEEhECADQFAk1P0W8tGmh0dHA6Ly93d3cuYTJ4LmNoL2RlL2tv -bnRha3QvcGdwLXBvbGljeS5odG1sAAoJEFbVKT7JegZU584An1wa2HTUiR9GsvdO -1OR8/q/a0Fq7AJ9WtmrUp/EI0hq0IGy14TPqWHdiW4kCHAQTAQIABgUCTU+FLAAK -CRCZkx4l2R4BLCh+D/0XT7WVHYpV9A42tBnOijSJMfCbOEME91I4PSe1PFiIOaRV -VQGbPtuxNcFBKGybI5PNZPISFqom3jHkGKu+qxMVR+V1FfZHDl7wodJLuC6fT0Ss -LXzmBNA958J9DLu7oY2DyvWIsnoD6+iGLj9OwW67tcI7mpdNJRvuRDaJ88ZD9ocY -3hE6hLkfa3v7mlmRNPIrjQ/i9+7g6yWLBERRJLErDBrKtyHLiWYYLtJotQMFA3dc -qOM3F83Iu0SCYn2pSHChKcbmerNHXVty4uPy1RRTXZ/kXmCb0VULdVFId8n+DS3w -eyZJ9hDChVdRFSTHrnrzV71p6d0bGaBLduohu48iUA3eQotyzWX4TzJPHd/jaAcV -AURNaon7BT594YwBfe8Xss6nMbeBhdoV60ZOGT5CIJV9muLC9OuO0PHsK4ddEmD0 -FJ6qwYdlw8tw8/450QePedI6PYZMUJmJGPj8Hjdb/Gnu9e3T/qoqbLP/Wrmembbq -6mfHgLekz+4lOtlk9tXRpPKNRhPYTpGfAzXWyzVLd8fmBfNZCs8hWSkYiJoKWmpf -U90oe/MjL4BsGqAooBY2TRDgBImq8JP7nUD+5MU5OOXr6gzFuBm85sVW6qvius7+ -ZLPwqeY6QR4Qu8csCNqns881Nm1Qlc9KlynnlCquNgQw1+cW5s7r66R8OQ/RKIhG -BBARAgAGBQJNT9rZAAoJEEk2Czsd+6FkNtgAn2Z6ANhO4S5cl/LyGN3dBfByeL86 -AKDIxGROg3vMwW8P5f/Ceur871kIeokCHAQQAQIABgUCTU/bOgAKCRB+lyrL/gp6 -83oYD/9YtDg9le93Z3EKGG/pIl9533Lz0KAU1VqyA0dqpbXiryiTjA+UlDcsEjs7 -9NtV+hVYh6juBhdspcCOX6MbJFwVRgwRFAfpUWd705HBMuftkupn4KV61/qt+q+b -O7LqBXM3wfqY+YcT9zDI8T+NyyvQZyHcNFj/Y8xlIBv9s5jB8+N1AxROiHwlnA0/ -LXsEsuUUxzz22BggnqV6j8u/j0k2Fiaom6fJV1+slW1f3wprH3cD2hxkpzlhFEGW -rbJ7bnDkbf3NeyfFGedi9GeUUx7Y1XMObE1hqyOhLzdxbhQTXXuFcrY50QWAb11h -STAvv1LabyouO5mtueaOY41RiDcckZ2XHKNGROT67ke2us3DdP5A74BvrYFoZwN/ -67Z3+Lw6/Er5Iqh52A13veO+5kECcQdqlYxI6Pv8k5YSKpLn157SIO3GPEkaoR1x -JRvEAY3u6XRCtLiIBta/MEdcE2Dm16x1DjhxkSLLeVzLDENKZXfFI6TxX1F2vcy3 -4uH+OVtNBVk7PpsaxvU1Kthl3/n/vPEe2ma5VB0HKa7ot1T/FyjY0GrJ9DVqbcLZ -pzx4bbaEf+1CZDwBqJLnSfP8O96BRDDnhN5SBlQ50dLG/yH6QfQL12oRcVgfHM75 -ASfVylvruoh03gXzlpCwpTVuYeyUhcI3OtLdcIrNVOcZtEG4S4kCHAQQAQgABgUC -TU+2ggAKCRC1nrciAtG8ZW70D/4szUQAZ5V3f0LxTqMpDLtH1OPxrv7WMlHaDoD/ -t9z6e2lIf03HReqwtlEogQU5dk4jIcpRbwEqezihKid3jGyliS2GFCsIoKN1Sdrk -ixRDTmtCA9euv50UiJwtASeFi7ae7RnjBHr/hXPRSp2SaT0v2aPTMLueixsGvsor -uKA//J1dfKWpXclFAM3P67p9jUZQ8AQrDbVDjeoHEk0nWn6OXdtaW8nFAHUtQTE2 -N3RI4dyHzqOfeEmMlOzkUq8dYPu4KD4xIOzZ1tHNU8x6EjOyFcABr9UrPZY2MSZy -W6UiZuL6RFAWXD1eLMnAGnKqwKUq8h8+PaO2BEP46r5hO1dN17QRHuSMDSjo8+Df -9w2QA+PifUS1aIJzBDqbrGipOHFU2XyNIyfQKwBcBzjINlRtf8IBSLDQ7h9BxVgz -NKTQu2P7wQ6af6W4FQHjMozWZ0+D9HrHjPEvx+euYh/eg4xOIqeXrcG1r3iXfQf2 -thfqnqbcHb2i3tMSn/C5DHTjlgS5CV6orD9n0AlILVSbw2TpiHRW7hoi9dVLigdO -1o2flMRFk9tffQjEgqhUTXR6WHmmVNy3blVT8ac0ENcT7OrRjns2gcuq4L/CP14r -HlrIXjq1tlz2ToN263kv5r0rskryWFbLQZ/wRZevee6lk6JKgI12S2knDMZPl/cD -i8ef7ohGBBERAgAGBQJNT++yAAoJEJrdh0FaoyJWA9UAn0RRi4zyYHDviOKbIrfY -kddxUyikAJ9tCSYKLiNbCYItCCbYrV9SpK59EIhGBBARAgAGBQJNT+X8AAoJEOUx -FeW4oZxpRa8AnRoZ/1xuzMIjLDkS4PmcTUZeqF7YAJ9TykQqpNaHOpJtr3vWmK2c -G7buiohGBBMRCgAGBQJNT/dpAAoJEPywu1xfH79wa9wAnRlPOylMfR8go1dSPdNt -ThzLjGIvAJ4oOzGcPQwQl0QoLFAF+yT+nAk194kCHAQTAQoABgUCTU/3eAAKCRCe -3MmR2atFfgKvD/9eDZ+xHN3I7E55Gxc1NCc5mdanElHOrtRuZ1QdBjVEUnlqpn43 -k7kcgH2NsI4PlclvpJ0Qcj/eSOxqUDflg03YkctDL/js9XQGK6k0avMTEPrrOwSJ -Mxv5wTcBwxGfZhb1mvX0a9tAx3FiMucbyMT6oHl+mOToF49SOAsj8vfMhJ9/BQFC -izOgX8F7U4VwtbFUHWyJaPRnqZ9cJDoSz5haTXUcj+6yV2FYfqvKleKjVJZ+socA -RFSLiazV5dfpu8U4QbWgmCUacI8qyDYA/82P6MheF1nG8rcwaEVjgVViVgBFlDlE -w9pexoZsKSoZ2XH6ZylqguWfkfNMgh2ZgEAuBxaCWaHD2rMhEx2SUQR/IOYsNfR/ -JjNBKbZkim8ijgRuUYcjx2WMoIl9N0H8py/L4Czt7xFHNP3tQXU1MqTLlSykutHX -w+G7EQvBTta9o913OmFrbyDs4BddrvK/Ch5ClHlJBoom6Ls1CZ4Z0Jmep26CA4FU -m1iNoooXuLfD/yy63RTLHAJqG+D+sxkyZSV3SRj3pOtWAltbUEqH/EIDLr/JQFRM -HnORxqk4BgbvZkMUkov1uw6XtxB1HT9QEboIQnFwcFS1kJS8nk0p145lFIdMwI+U -VFgqC0fi3Uu5QUtNd/nt1Q8fIks+DN9RnGHMReFCdLaxehKA+6fGfzSMQIhGBBAR -AgAGBQJNUAT/AAoJEI285+u7GegD56kAn3yGp3ofYXKJhOHL7w5GxPsFojLPAJ0f -nEa3oXXCeTpH0GnUuQEykh3twYkCHAQQAQgABgUCTVAgyAAKCRCoL7uD89VwMwj/ -EADIn24psirAvNVrKzvKDFnLahDPqhxmcrqaPcOzuZn6FYLSUAetbijwBCoCK4FJ -1CIov6oJ124rAcVqjMPYnyO/snOEOhjI6Wu/T7UqG6nbedIqOHFV8Na3SzhfVkoO -BnUL5TO1/27wUfsXWJCUAPUiE22IGKTTBzNFvJ9v3HztA6rgstCrN9Hub0WXSUx4 -ZGLErpbNnH1u/bA17TC1Rpm6dBuBHOrVxxpLaSx4nkc4BacxGUjrnTS/bHfd/376 -v9iKqSBXZDee5qZOur08ZFCN5szKwRF2iJHTTIKzul2xsT+PuuN0YAjXMHypLqRx -64htMCJ4kLviAlnlb4MOdj+kO/yXny8iZDwbmhOys9AXlryiZ3pdcB+ol/Jkub+O -HF+vx3WBq+2iuJT3HVAGeSWNZAFX3xdZyqhJFW9LkLUfRAIldBmlBTdgav3Q038C -LqARSH1ELsd/VAf8kuinCK2y6G6qPc2kevo0x9+ZTV+h+8jDWUwGjajKDNAuXr9k -N99+Xmka64Ai2+XmjY47iV8V7AZfImILUKkNs80XNagx3M/rMuOY3D9xckkx51Ky -nv+4F1QyFYcSYkGjPnnG++Go335wsCM0zmSb3fsv59q5Y1lwdLyf5dfFYrAVWN15 -3zUdxXK9GoSCaSTLjUEYPP0n+6aP8yxz1lZHK6iQjVjfM4kBHAQQAQIABgUCTVBE -/AAKCRB9wybazXKm/dskCACbL5OiS6A05FLicznfcRauL3B7S62KN2SzIADGM70q -yX6VIXxOBItf0gb5OzvZ2Ur50gJ6uSaegdfnlxaTKzwwJ/vL98cYcm9Hoezaoz9F -5U8vE+z5t+cyGhQy2aI87erhEaPuLs1xEl683U8Gxq35maaw4697bbdauvpgU3Im -bMpJlRTO4WgSkjtKnCrv+e9C/qihOZeWCfahUJkNWjuVJUynqFlSa3MtkyD/b6GH -VrOdozouYH5n6mJXqKTYBP9l8oLBN7CqkhwM39qn86kgzq9Ig8q/VpzQEBjv7Fry -PLReWWCvwH1Hi4mTpzxmB7ubDtbIfZs5d46j6GuXjItciQIcBBABAgAGBQJNUFtA -AAoJEOdhAuDN/qwvCz0QAJW6Q2VFG+AsLUqEA1aUdM+tThGwU0ezJFRZ08O1fRRU -HQWkWocPqnL/9BdcjfV/WU9AU6HbynIRYxDaXyvf14o4kHrzJCn1nRQ5cifq8Nq9 -fESGdXJcjCWNP04RK+mWhusGZbp01EKttmU3yk0xjD7K5BVdSQWiycnkXq4ruUv7 -2NXXRytbOZGRo8WMJ9jyDEYEYQ6NA78jlE4fXh/3xbk5gpMtDGk/Gx+gZENZaGjq -7KtuITaBont/Iu2GwF2I4ezk2dy/PI2JRcypYniA8H4TMaFQDapLZCNPsQm/zQF4 -TN9OD9n1tkreznIP166FMbgHbahF/J7tkhKhfAF5+NLmTQBrbJVbEuuTf927cu9r -XJ4vIvhOofIGxHY9LDLCA+dv2ezRVQk+L1Gc7z4HpxTgnUn81zmlOG9SHzsczU9n -+/FYOp3Qiqr/T2nudJHKreM3C2Rs2OcLAIMc/1ZpODYiBvzGr38oxlI8pWTbPo+X -AbFt/cSihzfMfN0/VUFjQsvLu4RJvknj1mCurJmEncrfLhh8yHIoSc5W8xzGsBSg -o6Bskhf84iDG2k+Bv93pFTxXwOpsU+rhtghkwqt5665OtLF88P+HDcGItt9hjadu -Yo37qMCUgSJ38emiA2swMM1uAL2mYwNVdlFRUK0sTdoYkm0jNBTBvwySSo/8cqyC -iQGcBBMBAgAGBQJNUGXgAAoJEODYD8Y41NWHZ/YL/j+vgv39EYH4ClyOLcUIn6l3 -ZWoQLMDs/TGU5HK0WLk+P/ljwJorNmOpz0D+O6SgufqkS+SyjwT4aAV8zCaQVid5 -vmYgIbYA7NAxf0QqveTIgduVtICGMlMacrNE3DnlMT25ee9uXw5ElGS6rMkIVHdJ -SErqGJrUGMR7cY8LV5IeO958m4OwCjuTS65ftw9fRN3wGmVH9KjudLJDkcimAdel -6zs4RXFVuv4/oYfQ/XhM5XYSoEGrBrxwaztUjtclbrqrV/1kNWhnSPml8p6m+Xgn -EYcY0Bg8eWJ6iOMOr538g1gLTP0DFl0uqYm69iFpY9XT8KCK4NMii7J/Z5AnovcX -WWvi9n568adgIP8YfucyxFwkBPK7j+4XCsd9l+SwI16Bq1r+Yu545gN3u2c76EbD -9Gt+T6ylQx21KVte/qwVVLs+dh50qjXqqx9tdvNUN+DH4tI42uW3MCyhF3vbeFGA -1wSkP777twxpbM4bW1FpjUqYCBvYFnJBpJuE/5vgE4heBBARCAAGBQJNT+o1AAoJ -EJ1CgR37i7N2d0MBALZJQSww1OLJQTYO2iGuBAGdiuPxqPhddyUteq3vzeTuAQCz -4DQAftKi4A4P1EJg5shYyDta+b7afewXgHUsJtWOuIhGBBMRAgAGBQJNUGdkAAoJ -EC+VFQiq5gIu6hQAoIyyafkiaoXLlp2cz3FM+MM8avbhAJ0djyMSs8XQpAlzrGrU -CN7yI1pPG4kCHAQTAQIABgUCTVBnbAAKCRCsMIeaq1WzEgfKD/4p0eMRv1s30X40 -HIFRO+H6lHA54XcYH+64UdK8AX8keKNSQ0wg+qnsIEVGsVXi/KIOhAVVzUW82TBH -CC6Z6dU5MYMmiMBgxf+gxmRS57ttcq+xoIHvFUHECs6y2pbu30vKtxeek0KBusM/ -WQ3OBXI1ZH9UqskwkUrPM/1/CJUAGn8ZSfujmYsZ91y5tFSLoJp8iyG/QlgXN9Vv -cIYusmj0m0UZivG+vNlFGj0V/gjXbxlBfW5kjjvlGfWW2RcNv2lDPoG6nz0oqY/f -C+3k64JMIrZ8NXVqqNLJcEL8EgEXrhEoUVGCvwFgUznldhOmpCgP/9SVwQiMqqP+ -PSqzgiLUKKAuC6vfb54tf7qZK3JVF9/GG7QuN3aK8rNUbgTuv8E7Y5lx/45C6LAs -/9wHS1RTBW0d1ZncJoAdxzHnKKhADeiVRC6Fh8GKK5SApqvPRxnxupnxVtI+TlKz -nAIfY85xnqWapXdLXpXjRjlMb65+CAYWF5qYyy1NH0DXqZ8Lffd2td6fa0R/CXig -26b39UmUrCppxLTb+x3qOPwquBKgkDsyHhjz8eVS7xIEUESQWLQ6RIEYpTSEZW7A -G2PIzz/o6jQ1hqRFRoMZ9lK/QJvku9ugu8cRh+f8LaDifrHRsWM9ZDhvtg3Valrw -+JGIHinXgTmEWc+22CWFFtFr7OuU04hGBBARCAAGBQJNUH5VAAoJENGB3XpsQoJy -fGoAnjEafFgWFjQm6lB78ETv+6ffTICUAJ9eLOi9BqUyWEQ3YcCh/FVDGRlByYhG -BBARAgAGBQJNUHssAAoJEDACjSRIE7X+wxYAn108rmglUTGi/suXOzn5DTbTOfnK -AJwOfwLUCbhm13lST3r5qeAgpBHsPokBHAQQAQIABgUCTVERjQAKCRCcr88RVnRv -lcDjB/sFd0JRpwYSFAuOLq6ugpdU8z64IOJjfAdQOF0aFGZnXR+be1zVlemAmaZG -YfejyX4vJXYuwaULER6WzObIF1oTJxv0omALvGiXpcHduanU1TCUSnO1CM/dI9d7 -d84A9fQ2p/ojg8+d5zMGmBurFxRrafz7rFNvcuZpMzkUpWEnSSFUoTj3FJyHcfce -cStUn1RECDFFWlUrtoZGwYTtSLVWpo3chGC6RIJRjzivoB7h34G7LhZh/I5Hpl3w -8AkG5kdy3VmlvjoWEZuANinGfGE5+OER2Rzd63b6fO3ST6uWczZOUS+KfS68SZO8 -ZT4QPkF7V1Qs9A54iNpwcSUzg/X9iQIcBBABAgAGBQJNTuqhAAoJEGdmANzaWplD -VS4P/iHKztrMAbTXBoimEAcg1wBDBSslGcsvNiLS7nFSJCnHqSC1yEgRkrS7hAfx -Cpecpe0rxFCTqHyd2XbD+lpalJCbWQ2UfSMq6I1TQoNq+AbD0z1bnOYnAXrJd5yC -3WhoFZlHc2EnIswtUSmpw/QsrTaRMQqtUqJdpmzt/5NLjYsPTKavwiXyXRySGifc -Dgk96BlcWW9CYNvle0zJzRs/8VJHRtA8VcR7hlPSE83BMrwxoBCTN/OvIckf0ffe -81O/IDiZ/LX7QJMSPBrhAWh/40b/SVMVaSDg2eUhwXqMyDl9mqANrHaqDX/5iqop -QeQUJIoHXGWoeEkvqMtfZeKCVvmkaE7AvV25OsAaJDpyvcTpMK7U5/v4JG/Vo/hG -RimLuDPe7fy9W1lSPg4/iWjWLmuDGziEc6GYoS48cbXprEnG+3Ybs6p+2a6ziy8X -5l1Im6+32Gx/Svz+L4X+d70lN/JwmuxqxlOb7laA/JvnElVr04M1niVqszUk0HwS -YjbkylA6oJZIWX/Vs/mBF32cXL3uMa54hzyp59ZgJmjmmhYOjJhXTOqHbLHsjAXi -XbNQan4BymMnXDJd3tFF79Tqf9J+KJtcJYbv5ACpwz5IST9sic1ShFwp2gxt4JiX -NHR7bnTB6uPOEvcSzXZlrCctMM2cyK7R6WzRCEmZuz87GJ9wiQEcBBMBAgAGBQJN -UabfAAoJEOlagbieQb42q+QH/j5VUxUTDtg+jHsmPsi1I0x02oatR1MsgfXt78Y/ -kf76vHkO5Q0C89kAOYfmVDGFzWLVo9nH9w7b5iM4EnIM9c7FuPyEzyH+f7Z0CnMI -njAkRqbA8Jt7Gst9ECXW+r7I0USTLiF67cH64v0XZbxWL6mUcaQ/heeStHADN8BV -+BSDiwRaO1f7p511MrrgOwMQGHBrVxZfR+o47UBHNCmh4DIIVK3U359eoV3xazax -1ggBy4erHAudsfSVNZVbI+kNJ13qpmPBgtFy7OrjeblxlaDdn1GscoC+gragEedH -IBc+vl2tpEnT0/sRm3QlXR6XTt9ep1GpxkpxDHW5+xqr3DCJAhwEEwEIAAYFAk1R -xm4ACgkQfRWRxp768oZkKA/+PU7+GJNsUX5BGcpDWHJnliPnj7leEaDpF3oVslD5 -+QOUwHUlyqXkgUPPJxPEOfN8fg524hwl4VGPRvUEqS2uwF7pzVjzYFsQkbBrjEkw -D9ko/cVQ9wA+vM+4/dQw6TsneLuThGTxUMmOKK0F+AJrfIn0V8/DwtYQ3/NChDEb -GkK4E8EXxsfkdycZm718AONvCPgpTD7aKX5aCXaumHuxAnsGSMMoYssBsTSouY3P -s2Ryn4s+V+j6cSDoH7Z3N8nqXSdQzhDMqeTz/+IDTj+vKh/1L+Fkj6r4mlBYXDRv -xhZw+d9yx6ImQCNp1kE5GMtOc8ymu5l/oDljEkOPDyN1AziovRvTVWkhgB5z19ag -Of3mSbKnwf7hohR5TT3bE4HCEA+ug/8XFcpvva6M4saWnRq3ijXIOdj56DldtEom -pewEV+sAtp+7zbPflY0UefsJldWLZJsYvjShG0esOzGmlvgI/xAsb7HK8McUTjxP -jfw/DpVQ4wUp1Vav1qpmekE5HFqgWJfzIqnWPob9udcH65vpIHWnzqnyZ2dD/EUw -312wLPBRktRRPxFgHOqiHSCCPCqslrRgotrJuwJgwdH+onxJR1gCpSW2RZ50h5rx -WxPY3vVmRmR54Eqg89ExoYJrDQfuxNCKTv3a9TKbby+RwhkbKepgfAeCHpCtbg5P -DYuJAhwEEAECAAYFAk1R4MIACgkQXrE+nUCPPD/9kA/+PUJz/dMGvdjIjMD3URyu -nCLk9P2s6XcAw3vQ0GSHCpiNlPG5mO+M98+lBl5YVXssliY69sCnjGbPCV4hsfpx -lWOBoYMd83P3l9c82qQxeZZD45V4wUAgExat/M9vq0IDKdYcshz/sTPo/6dfsRp9 -DmvsT4BahnRqNG/6kvpHbFims1PjCC7F81U4mOsuV6h8SQSMN+F+sc45TPLXvZNt -Qz6qfX1e3Fmcw85gthKDg6w5qtZ5JP+R7MvoFGsuFfxMNRNl5HNpCj16mBS/F25W -RJ39c0g0iebEJ4TGXv6SVwIHzD7CpeXME8ZRNVSPJJe9jOiyrCw21m2UUGtfXl0i -KcSPRJLAFVxwNlHTFLlqNNDKLsSDlSzGlvdt9iTsHcxROTTbJpxk4ierFo7rlz3Z -BSq0tcd2nn9uyrU1tmPjXrJ/sUEd3ulBYCvU/PhOAfF7o+fk7fD0NY1oz+Qeoqjn -TF8eybo2URKzLjg+5OULiVqgY3cStxl0xPPIMhVG4f/pD8tZwab+zPAPgNVx20Al -5Nxmefnqe1FVIbtjyb0q/mRbPjpKTMtdB8FMzqR4kT0hVXH/7angpybWpdD0Xdhz -Y4GdjLuApgQmHW0zQ98bmOeus/pvvxbSMcgKPhuZVQEOx4oV/iMwZV0tKExfxBU1 -HUmgpq1bF7HskWUpLXBgRxCJAhwEEAECAAYFAk1R4PAACgkQES/3QIOJfhKN2hAA -r+GL+hkp2D/koP6aHGoupiHdXazqp+sxOUQStY+y/7N55af26xBfR9xpYFp4RW6R -7FzR7hnDX0hjaIrVXp8fNWvzpDBtQN07x8bUBoNlIyFNHrydRfzW+o96JQgIl4sm -btmOspdmiX5Odc3wWI7iI2eL8q9V4MQiMDVCnUOWWnCQ/SSyzD0GC3tqlpI0a97k -UekqHk2RpEmUGKtnCE3FzkLGgAOLluoOeZzKVY+hAOK16NiFOgrwI8pP+TmtlvxA -Zlprte6nh6vL0hvw9qrbc8vMC8emHjXxA5GRqOf5iO6U+FpdZKw2R8FDT0ay/lxJ -KSp69erLZzw4li1Kgr3mxwXeWloxJnkfUgrriMc1mwggzwah8Uts6qSF/upOnBLq -HsdTRwK/Quf/pVYd3r45S+Avsn5ksDRYCDASzT5rYSy4+gmTQ/LQpnlEzcACxmOl -/ChydOqNV2WvGivve9xTbelW9M8K1ftHC7DtzgK4RFFnWEKme5xPULhei5uOeTJK -VX25SecxFYbwh41j9Qfbq0V2ByCtcB659qgeRd7cCt9CZUEEVcyfYegc+0bC8TkN -kXjKlTqgjCrmKgBjtV3pa1u7fvJ6toGKYbDbQ5JOv9mxnxjQDrY4MFO+MgPEgEsb -EuyF049iowOK+D/Fny9KTKZ4GfOMoBqod/hSLON0eK+JAhwEEAECAAYFAk1Sb+MA -CgkQKukB5ccCGNLMMhAAtg79ykHRmjY0LzN51osRntAIfoRZAvoejq055M7deH2X -A/kuRASyWWEJb56b8qgrz7C2Luc/q0JIyRTXUgnU4yZvaYGc2R4zGyuWWWrdzuSl -iIBZL+B9KyIW3QtPb6ElYKxFT1RSEWBq6NXvs1zVfmeCHJLdQ2CjD7wDLfGGiPq7 -2iX8wk0RiE6nk7UKIyvzFKdLS3ahpwSKIfs9keKk3LWhMsOQv0bS+EkPQnkw8D+p -n5Hqco+tMpXTFUFHQ7BFxjm6SOacCfV7IiMpsFIyuKn7r6y4pwCvEpQFxqNp79+k -ujUACIwGkjKdzTYXILm3KtDICyRXK8S4/9X8O9HKwWILtRp7QdEVHMUUTitjjL1p -YBu36ieHyP27ZxsApE6EfzvmTSFcxwAApNb45bXdwSyZQtyp9mX/5uK4G4NFiK02 -Zle4MJUcfTNznCslH0qWHA05R7r1Hs/kdxPldlTtWrdKKSVLsMNbLZmU/V+ccc/j -XWk+LRNAYM3iN823onOtMCNFn1ELQNgd8mF+2Xknn+gaPyxV/avo4TIEw1rrPqut -NuNUZxV7iXAUBPPHbifItwjE4QD81Z5anJtsdCv9RmSIld8WXovTsP49zwqrvjyL -iVlLWA+TWaQ+eS65nqgZlGzv2Cs9FwAnjrbuxCzCCuqltM24Na4bL+KHFQmKn/CJ -AhwEEAECAAYFAk1SkycACgkQZMjJ0R5drZgbKg//RTYLcSiJOmwsPa2bF5vPksom -rLecafPO/DTaGVh2fIRSY2qwKscVeGHRItfozGQ9QvZqyTDrVdnb93UYm3vCrFKZ -qHrfPSuBErwmxaAJlrauVoQtnGMeOOmNLzl0z0R9SXq0lMPfEATZ0LiRe/eKMkcd -EyghB5Rnmo5SX0m0Nhdr95J09rjCmTsvB50FaSkpxYG/dvjBrySc4LAtGLvxggcM -AVf2Fr7Wji/l6YieiUPVykQXWGjmf7BXKgtB9OUiPES3q00BERBf+0aUktCOBerA -r/mg82YZ7eMpGEFkAg6lTbGbnaGpaWzCbQUyhqfnOzGui1hBQ2/R7p8Hi/zvYtiC -jGMKlA/wow65cMiVWYfjOMo0lldPvNLzfvSuE2wPZtQ0KSQQJNAS/dvFV6UZQItw -yk+VY2AMPfdxFxSmT4dmGS7gSAXdv4UNFndC1aLwnC4jIamH1VpIQkknNVXSFmn9 -cAeV4DrGTX8YQrfio2R6GbJk+JQD58kzRgQlLKYMsHCckdAsAUVYiPVlwOe2jJEi -d4N+Jzhqxp5JuplLy1VzhWD1mI+xc/Rs/hD7+0/5w7RLTRQtVe5cX8StU8t3Mx9k -c8ASRKo5YPGMzVTuU9l+OXYtsFZOFCn33bw03Ips1CrMUsUYTCTa/K0zBATY0PgK -9gtdz5E5/bwhlWyCSQ+IRgQQEQIABgUCTVLupQAKCRBzHK/TU8GjL3rLAKDg9W6t -JK60VU4b+nkjHnQeqq1rogCgzjwnMcePoGqQQ0047FJ9co3M7SKIRgQSEQIABgUC -TVL7DgAKCRDoVmI4sAy1M18rAKCP7laOzf4ihq5MOQC0naM15YTV0gCgyRjI+dgW -Nuv6CuOnYKJ1p8etxWaJAhwEEAECAAYFAk1TD+EACgkQqchsjdOujTpWVQ//SvXG -rG6z0U5Mu0pQSy+fsNjZH6m7o53lvGmT8nUYd7qGLYpUFYzf86bQVBUMuQdCMmrZ -ecNhY2IDeTtTQnSnzrQ2UTPCSLY4iuXIrl7fv8FVjXvtWkS3TuZtUb3DGLWkEN0C -i4QmxW5Fe+x2lWNQpSYlz4eE3EoApf3RRFDB9AXIeefFGiqv5/gywT5zVqF5U3k/ -Vb5cxZlaOWpIvZKFDxqv0ENbtRtJmg1y3UQxn6CLFoOmkSVEa2t9Ec1+mhxpvc3C -FeQg6ezj1lZH6mjnv+UGO+uOM5RH07o5dlOt0Df6dbQby/eFSArbEG8Pp70rlXqF -qCXrGbHiHc8ydxzjQbK8Gq94MmP6TiCv076ATiR67R/+YK1Rm3z7VzjPg6K40INR -baq1/R62/nfzzVdWe5WIqRLrQvypbon5BCHwmNsoqQLy0va2e+/4pufvvTvk8fij -iebc0tHVbBkmVx3V2bI9HN5wi0A+rX/Yd/P1VNJCD/bi2Zfs7dnd6o4E6P3MsURI -8YzObfnoFQ50SmKabSyX2nFj0h+jfsxHnyvPfzn1GbnJtUUkdNydMevtRdv6HHUf -ppM6f6NJEVvtU2vIJv5EFpAlkhOZaT5pTkktaW/CJYoF6x7Z15Gc5NFHqHcDflT1 -pj0u/HPDgKa94DTqKG7983wJbONqLK3d/twLFayIRgQQEQIABgUCTVMf6AAKCRCO -4Jst5hzfn5y4AJ93Fjb+9vZ7vsKamdSTBWTyO84WzQCdGnP8Addzix3OI691V1CE -4cITFHCJAhwEEwECAAYFAk1T44QACgkQB95+6lV7zgx6sA/9FYCFSxO70u1kNL+0 -/exKzFJ5BuBFQaTtNcoVZTNsuqlIX+KMB9KSA61rmcSMBiyh+gTOPb51DWm/dPkq -Z5ak6CGgs12AkwbRUeEb1pNkQCYUPpG2DL9226KiEp8DeM7ifLO17mBTvj6BSGFo -6aCDAJ5opDg3C8eRhBKMf2IrYu06eFD2EjQ+18xV45Gyrpxc0veBetMb04vc5ren -wQ8v82fBgvWA4WrLkIfIsJOi3/kiGwhFfy9BV1D7MLDxr2ltdDy0b82qo69kCD4L -SUmVB8omotFu9kH4IagVCCM/loJR4z42e6v7VcZSWOjaK+GB1Jd+Mw3W+piqv7+e -wVa6HPp6BwzfG3vAVF4YWU7IbvMHfHaoV29/rOw3xYNX+YwJTM/S/LvwymkDo97E -kWt+lkHUvzz7+urr6Pb9LbplfX0cojiXZOvVGt3DZ1qkpXtQpGJ3ZYyHkpX2/9dJ -xUxrNpSva2FgK6Wcy4+9Mx6cB33b3vfIr1Bp0wYarfrRYwWEM9I5PR1aB2aDWQuz -3cmywZVysVkffKqlcVEVaLwHA2kBIrBJzaW5lmB1SXFPPlhnchWZPYLaGjCzcYFb -d3gcFA/FKGUJ6jlj6ul1J8WmlA9qoRhh6eAind/FxMkg+lwE+WAO/41hGj8zhkRf -DQiSJ6onu954tXK8eGcdC9HjDjuJAhwEEwEIAAYFAk1UCmAACgkQVKJ7ramDLrsJ -khAAiBljH3TNm6NJPFK6odXPtmGVbAYe8/xL1I17OWpQUiW2q3I1rCJhUOYTK+hw -PiA4jr0jNHpRVv217znMwAMYmewqHbG9FEVmsuWxEMGTUE1nK5rL7SjK+KPJDSLd -wkJIahit54PNI8pkxun1PvmlBJLM/itCNQTMn7OBKEAcGh87kXcrLsY+jhesnDYk -nfK+ypi9vvLxdU3fGFL36L7wse/T//VtMxVGwxzo2iDwTU7vqsxC1w1/wSKq2+Oh -44q4JsWfZlsxbXznrV6HeCx6Wr68ffarCnuMtnyBqP3Zdw1988Ya269BnKlDlXIU -OJ3QdCw5Cl7PNEqvKxVOyJOQysxIb7k1w+Mefg3Kwzdq6xAzoy4onhDrygxJhRlC -T2dmo0vxQ+wfpceAG/7Jk1LGNoSk1rt/ibcFNn2bqywVrUq9ql9ER373RMEtmE1a -qz5yKuOe7A1TeWimfbkul+FQxb4J0y9pkwfgDTS48nRzP7FPz46M3O+nXTou1XsV -c+yIv3pmOdbcCNlI1D9xPuwixVpY6k34fjF31aisfOvEAP+FKBiS/T4WYcz7nFdo -I9HYPUXVTL5r764ke8rB+fKUhjfuKDHuUM4z0X4sOun0rx7Qcl9mvrkQf4wLbPQE -CnxX8ioXQRhE0ba0uJ3T+ifw9hVETugTbzvvj0VckFueYiCJAhwEEgECAAYFAk1U -HwMACgkQwQDXtX8qHiZ4SRAAg9UD80PzIoWxs7XNwhSLl1PAqTQrg+NxpTxeiL63 -OIvaUuUqQA9sL4hWkv9Zaj9O4BMbw74FaFrjXqjZWOlS+azv0bWvLxEjStfJA+pL -SoTBlIalkmxT34iPmqZ1Y0gwzmDQ/434fQh5k5hz50cQAmqii8vPusRmZxDsMXBU -5prhaYxh+F5jm8NxAfLnv7NbHY+ytfUr5PuhqeiRAPS5ztAJFmJreON5WBhtXNgY -895A5TieYXjy45WoT68sHqY+ER+1WF/rFpIL8xmi4o4dda0rTloJESw3C+58cSy0 -bBdRzt+It2OSe+JZXOK2AiUz2Oqgh7QaKXY+xMSeW9DIR+JktUvOkqaiQBerxpI1 -pLxy0eyBv5iMroT5CT9ov8CLBvRA9UjvvLethM7lb3HrbAiC3mxHt4tZ9+eAWw0k -plvfkUV+nlJyCjmrK8VebizxCjmtMss5MDNdfwTJwXTY2xWDdN6+qhm3RBkzWJK8 -AsunJRocR4lIc6uPPsH/D0OIi8P2A+JangU8CrqeyafTN+FLJG330XXuEYWP6BNf -PshIvrwUeHzbq9tJuqpSj3YKhkK1VBcwVKe1v2mdXCkahHDtXP8zEDrc4mryE2Kx -XRvMZeiB1ZdR9b9LcrKg1f1k3A5PnPKdTpdZYWcf9Qt20OiOOP1KHmX+pIRpN8Dg -bUeIRgQQEQIABgUCTVR8KQAKCRAvGtBzKTwF/VQBAKCYFJ/OAjp+yDlAuhkTiKZh -0uN0ZACgjcRrY4D8fJZjmhy6mWtumTZHXoGIXgQQEQgABgUCTVT7UgAKCRDujTY9 -FoeXOMp9AP4gBCwc/+6H/9KkKej92BR/dbm4Pu8Iey1qeru5vEmJggD+O9L5TVms -a38RU9symhKVvDCvyD5HWdawX6zq2oqQuGeIRgQQEQIABgUCTVUurAAKCRC+4W4s -Kn2CIJm/AJ9t0NDXuC3481ASDGFtV4N40SynJACgsmZ2uuv/Hz5aIUP7sFiNfHLC -dt2IZQQTEQgAJQUCTVbEuB4aaHR0cDovL3d3dy5nb3RoZ29vc2UubmV0L3BncC8A -CgkQtHXiB7q1gimXuACeORuOdFLqUVVrT1ZeAbNfT4reeIQAnizE/+qU46gdSPNO -HQxk33Jv9MCaiGUEExEIACUFAk1WxLseGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5l -dC9wZ3AvAAoJEJSP1qDhD1AuKe0Ani2Kzx4G1fDTmrepFJbQYZAd4WtPAJ9w0da9 -+JcItbxACVBIgAIYRJFRzokCOwQTAQgAJQUCTVbEvx4aaHR0cDovL3d3dy5nb3Ro -Z29vc2UubmV0L3BncC8ACgkQegaFQh6JkEI4BA/7BLoF5eUj1mfxhAWAegSyeZWq -DbOLnfT3P2fzJ3XhSk+RowpSuiw3dB0ECy+EpkihkbuYDyxVnFRZHt1HqPpl6TJF -nKgqTv711zzadnf2F+hho9OlWyY/qsyTOfrIaIBMeSc/u7ZVnUg/WBQZRomS5+Rp -otflTpsmMuwRxBC1BtGmhGDXYiGYkrtUGV/eRTNUn2H2q4+uBdLG3hpMB8BvV2vU -dWIwn28JPVk4/0jdepoN2WxLhgZV8nEUE2bxKvENvOUcSeTDP36OrJPQdsuXDcja -cczzxFdcz7hK1shpiv2MHHLVjG/2dfHTWyOVwfwgMK4X4UUhMW0VLoTDTeeqv+C6 -IvJi2Xyxt6SPhxzAkL4dbBBt2QTVWrH+sfX4NvoIfrQhtOlfVUn01wObf5eHexlr -HTv0VhDy/xeHv/zYtcvjd6qZglFyYSMQZP4zrKbKyCQqN1IxXPArj8Wp1DdEBNi2 -Xbxw1iEAFUm0hYg2yBgNa43bBWJd49rAwEMvXrSPu8OvvRVZkm10DTZ4szH+PZAF -qyypHWWTOePIs4+NlL0IQE99Su/hGwgiDfXaJ3T0jVCJ7hkKUhcGty9ehzVdxJEJ -M+RT36BHwNHou2Kmcreqrzd/pfuGCindUTSq66AKfloHcKsQEFtwJYyKp891tMJk -Q4vQ8gCm0dUQyNX0jBeIRgQQEQIABgUCTVfDqgAKCRACkJ4akv0Tck4xAJ0YnCR4 -GMbvzmhJEaYhGgXFpHp/IQCg3RrqoOEfJ2JqZFKQD7/LZjin336JAhwEEAEKAAYF -Ak1Xw3gACgkQJuPIdadEIO8GDA/9FUBACAdo/waJEvK62xve7ZsUQieq86nmx6cJ -L6p17InfHj17a2LhXt8Zy5IO/mRNAvVM4TtwHTWLqebP+L3Gn1RTbn/G66fYjGDt -CuSQy9xNaQA8jehGrCEw4JXuG/O0pH8fWnbkXeAzSZRNX3azJUinmMTVP0tj31Qf -qjv3Q88amOOXOM2nt5XC8iIGupQQStmzCFVyA1Wqaishx0xBmMqvWjMTW4yKSXgg -oAfa+sooKWL0cV9wUtaq8nrkfbddJyG/TWKLWkhPXqGEVIX8ZW9bWgzhVeHnV6yV -1fcbWtiIm8kHAEKlI/Z6WaHB0eEF4gHCUIG5k199J77pRLmLrTUk4JG4fXRCFKAm -umbzzJh5Lwo89v7WsHGFX8WcFSIP2IEHnJ9qS/yyQsUW2SmDcfKL0BUApkh9RP/q -FkV8rXaG7l+RrxH7555r4LmXhQ8xOEEVBvwrSDRGGm4Gj9VMs5337rW1VNKivVG5 -MkppspEYv2MmgSG/kW/qxHckM33qViIE+xmAUHDdqvq2Gs8zsJ8v5wQmPxX3u+BR -WWG8PlhbZVNe7hGZSqf89xbUMaauco+JFYm9D+waopM5ZRty3oxZPlFh/6sP90CO -2n3nLoFziqW2mLT/cNq7BrO+cCheefHmXJYNfyPqaw1PbRacEBIj627T8D8x4TjD -RDcf9oiJAhwEEAEKAAYFAk1X7AoACgkQQL/uhosFXZq2+w/+NznIhN08HByalAgu -dSXJK8T3P3kMg/1J1tEjhCkljPtxCN1T79B30TK3SpfWkSIMyZBvy6p3bLOAxQBm -4KhhbSYD7DOCZ0EiXKS65yB7ktL0iWGUP3c+m4epSpbWNxhI5wMIyy6yvfU0Fhv9 -okTvoQgx2cpzIBz3o0jzq96C00eOZ43/zIgETfQNmFe7QIBwTlxAScVoCFfV0Hwi -FEgEI2oZG85p94FpZ2ub64VYuvCF0ot1gzREs/oj12FuyAwb7Od8jvTgJ1nE6ukg -swJgs/Hjo3jM8Py4fmAhn+gSsT7M8CgIsQmz+GxTMdoiMt0VhFlBr/ofPHJDxTZX -ln2yX25eXR5Vh6sLxRyoSiKfiBi1ysXEOF2PBogvciF+HZWcVeNMCYMJd5iE+ezS -/h7j726Sb2BWidfHtS9CvjWg1yMcTUKpmi7j8Q6hg51iAuNVIIV2MMChZwZJLbr9 -+c119TCRyGslZANvcDr4SCNI33J03F1M/aNa9FsXeZfjV+4D+tgLQ5A1+ZPNAGXp -FR+RrAY9w4U+Ov5TeyRQ5QG6DN51agKeGHrFTq7sxS3gDExInJRDJV1VyXPwkxcd -ZgtZbHGINOlJSVIMLFK0b2B0F+OTJVPWu3gdtGuTkBKMPbIMl4WADRiVTUR6YJIk -p5bOOuhABEUqw43HFVWWzwPEO4OIRgQTEQoABgUCTVgt0QAKCRDcXN/EB436Qdx1 -AKC9XyEhnkQdy8ZvgbTfT7HWaSb4cgCgtuXTgDGcbaXhpC5WYk2pmAutq5aIRgQS -EQIABgUCTVhX8QAKCRA4enaVfrp1/0AIAKCSBVNQozlUdTIZTc2/3XhlbEiKjACf -c0+CuCuC3o86DD9Z8RYrvB080pyIRgQTEQIABgUCTVlLqwAKCRDugZKm5EPW2Pv+ -AKCmi+cq0TVkbxqCO0PoBEDhoFfJZACdEsK/em2NQ1RjjxYFhBiX8TYfg3WJAhwE -EAEIAAYFAk1Zl/sACgkQEW9eOrNopOunJRAAjKb+HIiuvstfk6cEMc9b6bLs5cMv -i8smezlyAqYLGW/JGsn8CTO/HnlflTbBdQ8siG7af3pqq4PlNZnWlh9PglP1a/eo -CGDA6zJQ45U+3k2II5W+Prx4FhK73cgadLEjGZviKmaj2CRvNBRuUqklE5vszT0v -6ywkolD/XkcbfoZ/Emp13vbx2Z/O/hDNnBaFrDfZCExahFrXmEZ9VId67h53BkYn -xhe+WdxpKQDNOJUS9T1LfH+V170l/cSSDcJpox9PsH1MYm2ysvr7ah5Cvtu0EUHG -+DU/VtpikAAGlCF9UW2o0va0xkqE/PvSnyPYEabkTPngiLTuk0TjaQ1GAXVq+lft -KvxCxH48BGw7bE/uSYFvU/Gonu1+407mqIKCcYud/M4xk5QbSZV0RBdBPwY6USPi -PIoVRvB4UKNx3g8AfR6n3Fl4FKcL88BD3wivHo2HD9zWY8innO83+x76qKa65edK -eqnvd4MXVlfSmlte1uMQkxCDEx80gq46QsAnl80bHu7hYrE1uBzP/cOaBjtaweor -0vPA9xXy449xwDZXLBUIAywmvm81Dod9/4RioKfn1jv0fW+uAPZj1WeLCf5gIsZh -LpEI5AHyFLPXIbSz2oIoyK9WeizGlRNuy1YSSSvGP6w6cQsL2ByjShOArGJnfkKI -rluKB84iEn9ID9iIRgQQEQIABgUCTVrxowAKCRCI5roe/vTdAwXxAJ44Lt39tIeg -o8cWRCiA6YQcoJnfFQCgqOeWAqJ8spGHjbsc/3+YdI+/WDqIRgQQEQIABgUCTVMT -wAAKCRBtC8c6QFgYN3REAJ4nwJ1VAc021G3w5X1W1l+rNHcqRQCfaviw/tqQMhvs -mI/lm2EPLUbXoaSIRgQQEQIABgUCTVg+jAAKCRDdqjZnDLc1ai+uAJ9yZ87sZjv3 -ZgJoOiGREacfN+3btQCeL3p7Gf9CZeGaT/jJdnH00YTF8KKIRgQQEQIABgUCTVg+ -ugAKCRAv6AuzeIf3h0HkAKCK+8JObJHWpwmg7i1NozLhVAL2mwCeMZiR0N9J7dhb -MP89sBo8RvftluGJAhwEEAECAAYFAk1TJNQACgkQ87nYjLh/eanhpQ/+Irq56xVi -8jMs5/o4V+SQpA6g/jGCgTTJB1K9n7VetvS9PJ0+5nA5j9A5MQWd23ngjKMhMzSV -bwoVtY2gOTjOuXP+t9Cnau99CHRv1DdGPm1vpkYyCPiEZCg1ouiOwzP38PhjR5vz -Cw3GFxlGdSPTCjflb87TB+cs6C1yPO7FNyIs+2mmKFcz6uNxPxdqHYQctmGUpm/a -1hyojNSgUJ1viYo+bJUMAVkpjOCiS6kBRn68CyTmaBgkbfqpSrxzPfWdyvUbpAfy -r7I7CFxryHr2qecTlT/0zscBZt54+XnUNJ17dbaUWidLl5hZDBcBVI1qgNNMwkFf -kOOhtsM9Sc9y2E0k8GPyH/YplxCEcxDK3IXWyLQdm9rJKdBQh66ZTEQ1MXhgAYOe -dVXcL9EhtkF7SvhdyA1fFslx/SS0kP8f2CKCjfol9zGZAI3A9ADVLqNUTcwz6G3R -gGNLQI4nq4QXh073b12WiuR88yRYWpw2LxAqzpcbzSLDJPk9CVD9xEHcHWXrhpbg -uQjn8L8dmxp7kvR5j2bHPoJ8ejAW3zXUvdIwzN0GhXAFzcXgasr0wh1sXnc9OaVa -X0Y1h2mG0uBZUVQruvxLumd1ab4SxUuWkN6zABcRoaUwFxNGcy3OeUZN7UXNZTmY -Kf+9e+DWHHceFjNPo3bBfkiLMtP1yZ4cVoSIRgQTEQIABgUCTV2qAAAKCRCQNcN/ -cCQH9y0eAKDd42alCqK4MCI/vXb4g1a5mddE7ACeJUo58wkiLq2kLlzjJu18rpHR -TXuIRgQSEQIABgUCTV2wWQAKCRA8eZO0N0VrrPYmAJwIm4Uo5jPpqxn4ZgVolRSq -up0oJQCeOFrNtBNam7+OyunXySfOggHlZdWIRgQQEQIABgUCTV68WgAKCRB7+xEI -2Sdlr1QgAKC+hdpfcuj7fls7J43xMbVcRmJO6wCguFldGBCtThzd6jB3LLOyBHWv -J3iJAhwEEAECAAYFAk1e/9kACgkQ03MPsyR4MiBzkxAAhxi562gSbCY0osBTqcrn -3P5dMjL5BRE/CIj6NlOUUHJtu+3mJMnq0NHw9Wcy09UZcMg/4PA2u8zej/tKKFEf -aPGFoHdkd1TYUJd5Ykd7g+Wuk28vRNrBs9Pw7YWte30QJAZOyW8o5KbZncj+xD0+ -5KUHySqAKHRptGOYZSNFmSSuLIH/mAT+wKnLxZK94kWfaeZHAGx/FVWaugSsd06L -7YHdIWn2codWV2peyvYop789yPc6x7SSWzvu5nbl3F1A65nu0lYtQO8FP42bdlw9 -6ptComz3+TwUZqpQ8thuYqGoboz+BIHzMKreGjQk9cvLz8jpql15KLGlv3fxDw7L -sJv1fyOKnqtkbMnDlsDEJz9VhndgA/vq5/oEu1PI2ZMzYGUUVFiXHGy0+yGeN62/ -yQZRb8pzrVc6/En9Gd24LdpgW5PKnYR+LO476LgwIsR2+REDplZGf9CNEMUzHnyG -YWOoa2eKHK2d0lP7D5uJjmiyJbOJrk2ga24GpuM9r/imlNVc5ri2YiEtrzaSkZjA -No3sQxKuzs7a7D4GBSs22KebJinCk0MnP0fP7rA+gsD6/esbzZIl6ds0nzAg2b0G -opedTX4AeY42U1UifkGRrQRjUGBNwgs25zbFU7nekyzcawsGIxN2BACDTEo7iG++ -xIkzhegSYilm0+wmLTMjpSWJAhwEEAECAAYFAk1fxMsACgkQAwPfUiXI44bVDg/+ -MVvLOhu9vV+yW49jP30utCLMyIa5Mz0PWsIBdfgJ/pud9028ZYxvPxxPHKXRVCoK -UqDdguAd+kF3lYtsSpECCh2wSpetQU57ovWqSE3Gb93okSr2FVGWIXM+4bhw4nur -0l2iDQQ2zjWwIcUiDrXO/5jzjTjIv0TFCQeabaaPif3V8MaVv8nJYFct9K2NqhnB -56YwE30GJBG1d/klwhmdHOFDQHHeziLC+cTlKHo1FhDaoMXAmbfBDRMBSFjx4sdU -sBLg+4H5Ewh6WZkggq1t/6saZ0flGSjiPPjUuoiu/N9w/5CKEIk6TiffFc9gjaqf -hYDhuTQtN7Ke4K/2zq3Uodb59wh2/Mibn6K49VUam7ICTSoX+u8hRA6Dj6qlCFAf -4q+EjKhtsrqZEF++hsmcvf0DzKDBGLWhFFXZw5GsJ3VFD5tRVWcqrvX4pueG0Oov -oUC0zUD1h99/r7wC9NKnl+t++twhxPvtHmbE+l19A3qS4M+aZv24uJYHcB2cRtgo -nwPhLyytzXoZT9qTa0IESk3vgg3laufHcoE4oxrV5TlYRZg/ciCLdC2fLEv3YT/0 -uq8MCu2aJvAe5O9qmJqxazOstHTyh1d/In/6kFK4C1YiB2Xta95tc+sHwenMYUEo -Fe5WdKXnsid6jBla3fyG3V9LfEtxfQw7KYgi1daRK0SIRgQQEQIABgUCTYeSuQAK -CRDFFK+OS6QBwzwhAKCWjNQYIfEaEELRYYvwlOs6LfMosACg5l87WyULNYrIJrne -ueCgctut1ySIRgQQEQIABgUCTecynAAKCRC3URQJ/BXb7CciAJ96eRPuzs8Xoiqz -JmRG7FZylOJ0XQCfRRgV2jQjEdVC7t+4guDwxtg4Mf6IRgQQEQIABgUCT4UqhAAK -CRBW5/+KKEDHCHDNAJ9an5js0SHhoHTMLM9msh+P7+4H1ACgsg5r9wDdtlBmh6RF -RXvzj4KRQL+IRgQQEQIABgUCT4UqhAAKCRBjQvLsvFr2uXDNAJ9AYvCR44ip+yr/ -bobjZVVeJtY0ogCfauX+eOBczUfKK7NOblL/X832JFWIdQQQFggAHRYhBBGhZrZZ -0+gl6WUvoRu4nAYCNnRJBQJYoZFtAAoJEBu4nAYCNnRJ0h4A/jSr6SpNj8ref0uz -XQ4T9xMDHumtWshhKfXyyHcplx55AP9/AbbfGZ6CPxupvR/qGcv/qjxps/V5d8ip -ddL+okWWAYh9BBMRAgA9BQJNYNReMhpodHRwOi8vd3d3Lm5pYy1uYWMtcHJvamVj -dC5vcmcvfmJsYWFwL3BvbGljeS5odG1sAwUBeAAKCRBy1N/41MPxl+1BAJ9atJyW -uDyldIlwZOorVZ8yumR4uACdE+wXVgQDlvqbwTF2A8JJd3u7xqiJARwEEAECAAYF -Ak+FKoQACgkQZ+dy8INR4K8ZWwf+P8TzulLTK3ABTezpMQokucYvuKBBwSmPDIsD -ka4upt2O8X3C9y1ItDNDtIQur5EmCbbDoldjFTryH5UWSGsyP1KbQjGsukbL1HoV -r8IutTjL4la8v+ELsKR9soT7yrQ+T9GDcyg2K8wV49330pIi733CDn+3pgFOw/2O -sKlOgB7oNDqFAlwiDO9IiPCGNUsRFZ6Pe8e8eFjET2FklGRkj248mA7dMXw5uC8y -5PJhE08fGjhBqAFVViqko7pfmDWE0cDHgrDVUjyqBL6M9CMVUsy2RFVFRVP1YiIu -Dc9/7M+qFK3gPDjQbhbQ8rbC+5dYTyfTfg7c4omN48v1m5OCRokBHAQQAQIABgUC -T4UqhAAKCRCoziimAQ1vOhlbB/9gsHHgfMeU3pZRqRwDXXm3iQoRqXIxHIkoSguh -dqVaLVYmVQP6ozrfLzj9CpS+XzPMxBRnWrBBdHJJI6M5B/WqfzVNrUs8daszDY+/ -SRi9X1ZaUXllGJdYUaa1PrAxAX3tlq5+XKnA68HmrEyk0TP+KU8qTvRxKciVY4mS -ZPfGHEfzqlkPZDeA64v05xZxjZx3SExKDUVd+6GtVTBQoIlfEHsdsdVf+a1DaxeZ -qHiOcZfGdgbinljFhNki/l1iyTqcMKkX8Hq1mXQsPwndxfDzOVqAh6CU+hxPVAJ5 -MVEfnDt7sW2rvIROJJmWKveeeyjLzD4mlst/36Cfu0MEnnAkiQIcBBABAgAGBQJN -c3BiAAoJEMk5+Zf/FYa4E8IP/jPD8FToP6t4tJIS9Whb12tKCIB4GU9K7fCvI6Zd -AgaITIzcYgxWwRt+GfG5WJ360TX61vfaRhjpL8HMtNYpPVVXXcVILezXuhg+e9T5 -ex57jaCPCMi+IcwF71eZesxJk1TrwmWObAL0L7VisGP/1jtfyJoFcmDOu56Hx6q3 -EiT0szdTBX1vX21Ime9eHfN/gX12HBOAX2slb57Xz+BLfQYfmfVxKHSPq8Vmnwud -UXucGPPwy482jd1NNlsGqNuhkiN3IpUkJE6LlRQt5/mTS0EEHf1JwA/w6frqWiIB -hYlELVH83iB/nRlZei1CVhFG6SusGbSZWDIgwsnwjdum3MBE4AQPR9OsYrWtuK3l -jS5i+kUzQkL+U8csyAFm0EWMmU5l1gqZXLMvryI3rM0ZINxEyh72pIn2Wurt6qF+ -ZnMThYS+r7ahwcOyyq5aVGmnAN/bRwq4JTgMP050e1J1ZH3hdfxsm1m0nJcJMFjV -TAEoLn2Wup/SifO8eqxB+q9hqxDnMAH33bEVhFvm4zCVpKE5GSEwlowqLQ669LwS -IkkPTWXwSxLXuhhWrucdedn/ykLnqGkl6FbdweRGvN/KxDIvlFpELkG0scljx927 -M7ivIIXNnQwnwNyJY7aGF4TwaKczaVP9mW3Uakn3CNRGv5J1Yzeo1fXRNUS4H4Uq -YUtdiQIcBBABAgAGBQJNh5K1AAoJEACbM3VrmqpVplYQAIigPnlhx7FOxpzNhtY3 -tZgEC2cXX3VogSFAufiBbXA4uR+7Kf9rphCmM6/PGdGK33BMaJxABod9STPaNDvt -/Dgb02VLEveozfplXcSOqlBvoCxvQi+4xRyuZGHmmAiTIVOgfGHF0CVCzDSoRQLH -XD24ESmWu1ydzX74OL0m+sY3z2deLno8q99U7GvubJpAT8+mlMINtNzJq0ZITf/N -w06n/133zQGHp4g/7o0cvhE557RtSYX0YLQORQsiRYHWD33BWTwK3obtIgl+h21m -ib1z37d9RnaqC6rGYiBRBmUr4X8Wq45xftYeTiNIGOpBZRXI1C/Sym0LKdCwpjZ4 -4G7+gdDCtJjVgfa8GZlqv0qz3NfcCfs68pGrHHlz/XTM7jdhkEjbV42tDEpN5WWf -pEty/I0Gdlf5rxlkV94ahVcpaSKEpsJiJCcws2ue8MjVR//nNCdXsya4sMBmjUiI -v9LsQ+EeCE9cMqtLgFZzZSn1D6PBnEGKsVLkkeTTPGtvSZrHNX54j2hUdqCe+FW0 -ZsndDv+PacLRqdou99+jH7Me1l1vHNeHrsFLCegtoRNZkr9kc23HablrnV6Xoucf -1w+L4d2ieN/jAW2khXK9QFEvWr4PXATI/WBhp/cFEwp19R8lXo3pbTPTM6mLWLRG -9ORGSpEuDmvX7bdrPC3Y/WAniQIcBBABAgAGBQJN6jr9AAoJEDZF8K7rm0r6NOgP -/RH5Qd6XtX3PrTQ0bXH3KWh5G3xtLWV+rcDhWOlIgkJnOuVTms/WLAlGiFvx+v0y -Ko8khtjT4smdDpLVJRouZsTjyesjHQZ0Zdj+Oi/mtT4LlaVY4Uw/a5aa25gNhiAV -3NmikXtUqdllRstO53qgiw0BASoL77fEAE1rJE8XkTTXfGT5AZNl+9xbCNWWE9+M -uuA2qf0awl7jZ/ma7Z8fhWDM6bOQZpsbow+GPcTLqyXF/zmNB6qaGjzv191stvKb -Vsg7KtXn8LM/evj5ulD6NB2qTY8aaRoG1DDPs4C/Fu9N0SyQjY/xyyJQcUGmSnq2 -g2IbF3k2c+oUXO3LVEmGGfcDte0zrOfJxZRmegWMNTKUkvXQ1mEBiOxcVxHCcVoL -gMmh59kTvbdfOSPjJApwikDlDfw+kAUiAE+w2hRmvRJV5zbVuWQf4EHxFrFlRzT5 -XSpMz+6JyNvq7JMCAg/QvKhASHlvxgjvO2+We6qbFjA6jIMZsX1FZmCrWS7TEGCc -HMHUEo7S1MReLJx9GaR4BIkkfpSlCrKuGWEVrA5qMATpDVt6p3PrQfNjBHnlaIGD -tS4HhzWEHMLjsCftVeyS53KCeMavCxCcRF+NCjWkryDAilNEFLkQSNOK7PzhV7+E -XkbLtHhEvsGyneAy2mTdK+uCRVa+D8njXxZlNfBBTpnViQIcBBABCAAGBQJNd/YM -AAoJEJSN0wAyV1WbW2cP/iUOuT4JGGDszqDtBAFWak+ZPRVWMCn71t0HsxoL1hwO -13NiK2kCP5rklqWXFa0SOABvCa9vzgVbvB34PacWEWcaiGqUI1XtBcRgEyB5Y7yO -wO7VFT2DQFHZJSpL0tXg/vSATzgkXEEYQDzid58iRsDJxtc3E2tL+7Y9Pj0nzugu -h2lWOlzEpOvsMyrubXpqHuXwi7aRKu/1O5pSFJvxxAejLGuBo1XXjjTIhVU/cAre -bIYVR3b0sCk0qIXqFTxD4Fq93GHKW7eJ9Bu582EzO236FVonD3qhzhywezor9DNL -ybVOxx9T7Ahx+0Ay1Ex8alDtewulNZ26t8UGGdpL6lpDLAwIBrhdpzgtMRD1jsr9 -Oh92oHPtibW/MMYdVyK94r5MPTU0XYaeoG9NdAZf/Z1K5vKlQ0q3dI2zMt9T7d1o -eVyrzgTYkEtHcZ/tn6AUN+KIxxNF5377aLQKNs4ANX23T/N+32sMYl43u40SQtjM -Rp25HpVFJwa5dydhIkAerUcGvuEQX6v7r+9lLV99hwyl+fR76tjE6VV0zqJP9GbU -eM40MMoA2cbzNH/zR7ASkM5rhrxs6AtywyTnuc7duuH3knEyQv8CX4lWgQoOdNtJ -fGgzFHri6kGWLvvXtW3L2O0rELKCpPMZ7e/tAWnEw5w+m5HbjHlqvHyA7+qSRZNY -iQIcBBABCAAGBQJV1uuwAAoJEBwnQjclAHckLtEQAKGkcxiebMOjwED426SpLKjE -KJkFpI5jWFiRS5d8Jdr65HQSw9MGdt28IWkMgpvmRlPE8SIsgi7RtJcSYTKRYu3w -lmybDuBdtOaQ78PGLTmjPNb5gs9gKdaxQRuM3FXorB9RoCEFG/u+ljYS8D00U2Hu -Ap4GxYIXb3vm0ynxGrY2dd57uSplUVlaM2pDRXfriYsHOiI4X3jWzvL1bXDYtmWV -octRezwQMxTcwGVtg0XW+miI7gExQzv/onMVgjCSdHS9581RSTHXoGWFpbyU3iIX -SOBl9FwnDfoXOYD6Nk0odkcmamHmin7Oyvm4LY9jnOtBIMXNKa6YA7VW4+a4mqWP -iccxbhdYHBz6npYdv9cQkh8CjXZtposoT4jd6/mJqyLeNP3/qhibKOyZJJw0PNp9 -QRv7oN6AWl4V9qn+p2kiaJYb3yBzuge/Gk3Sut6M/gttVTofAklYwOK9KpvCDD3v -5esVTvTKHDlHOUnV3Qj6ZPXcgXgbutiJfDOsPHLNax43fjvchErfR1ZZ4ZdizWhf -vQFPUZzawWGgyrnNpFFENaI4s4oFcRA8u0JLigyv9NMAQNE6L2lx2ZYibQdgRi2k -utorAEWGCLcc2/wbgFXpd5oTVRxZ7mrhYYaPFIJbSRDJ9n6pWsKJFj1kYy8kQpfx -cu22za1vQOpFLOc0bxhXiQIcBBABCAAGBQJV2bNaAAoJEMamgupjyC8cBUEQAIUQ -pA4FERBLgZoKF7HK9cwduTuFC6spmH22enSzkPBb6b+9a8XQ5L97kgMJ7edNnFJ5 -ABQn87Fy/9tCr7o79C6MjYSVHX98hbzAB29JJrh6ZRKHv9SCTuXM7x+a823UjTn2 -V6+BxCdBBMgWKGildNhHGdzB+gaejFyBw4E+lWkqikxM2ZCFv3n1PJjIT89LSqth -iyCdReAVLDtzs6Akdi/wsREEnqww7vkpUJC7M+V2cVNH4Ei+2Que0+eAlHR3Km1L -g46kshJ0fzceUII0HHl16qxLpFY8+fHRnUMNAlmJkY7pIAVsOHzl6S4usmDVkwNc -H9tOeJ1eZnweHJ0aHyBv3HnZfq5J/enaRZXAGNCmpUitGbuDSdG5Su7aNFGczitX -6/1ex4lqKf+IgI+GTwrbA9wmHwSufPAD/nK0S3xvFKEvm3PnVlYA1SqF8kA8DgY+ -RqJmTz2GT3qPcS4noBIsHpt7JWJ4Uf5RxO4EZ1Y/E0DW4qSX+JLeYaxZxbWFk0pW -MO12aq4xqLMMN2FBGIepQ14QhN6wTds3aAtHqIt6aOStsu8tpj+D8qSVlCZLgaYV -hfS/lG+JRWVgT8YLFthrjLGfBiolpKuSu617KxP3K6/dkB1j6EzgxIQQsYd0NDUf -zjt4ZFuDzdPjbJxUQxsYzXGqylYuBYMLEbhtnLS5iQIcBBABCgAGBQJN6TM+AAoJ -EPqDWhW0r/LCCRgP/2PcVccL3M/QIzRtca0MDTQtFQCtWGf+ehjFKDUlNdEHObNd -Y+VsY4k4rCv1mmC0J38vyfmGBklzINHDctPLkvBDgABSlsH8jqZuZNFqBXDeHE+e -rdwOw2KUthkG0N/ib4oypmZ8RnSASDZOcBTGCY+KucAOVLGHTw4hTrVPRm6juqz4 -EQ3EFtBbwn+Idk7eQha0b9GU8kgufXMBFK+ZLT3zwvamZ5g0HC6ztTdEZTK2lpsv -6EAxdvCSy9WoPCiUvx/Ds62ZZy+tFDvAVhaliv36igT0ro9dyNInk3ydU1cejvfk -nXL4q+Ft1bf8axAPNRMVEa/TzAEtDHOx70ad3YYmfB9rGLwjosOjCmElgH7LKXgu -E/Bo3fY3h8wq48yzw5Ch6OmSHDvrbXg7RnsM0DiMn+xq63ZeKporKnSh/TmtkGRq -pN7p6gIG/GQ2vOJ7qpFI9+VFC1xsG4l8yyxG8OhEsCVyS6G+7+08oCamCW6bjtQ0 -Ise5OdpMpUPujHgfnWkUksiIVFUvZQZpUgq09f/19tv8SsI4sAfac+pUP//CCson -dXIrCzkcsl10HCxs9BQiQUDIpEsfvsnzp/LJEIJkidOQR2p8ZOoJBwDEWaHACclf -YIIUbX1MUH/4ZQPhWZ6TTFbFbwsjYgYdAWGd4WvbxxnfvcfrafN6ZOrl1q9/iQIc -BBABCgAGBQJWFiuKAAoJEMO9eDJoDAls5EkQAJXTiv0MM3K81EubZS+7wRMEo7MD -PKKc08OclWjCM57gQ+0vpctuQrhhfO7Neihyl63NsHl6E2sld6oP9VBnur6FvpzR -NCnI8u7m0EyWBfsRz1DEWD7kiPLRgLE6QnO/h6hR/3w/gvfBmI4Uhky0zrS0olTI -tsBQTH3637Q5IrL04n8z7v61bFo6EngCSbT6bTAbuQMOwGsp6LYmiyI2XsdzTVi/ -6k6EpA6bb0czJLlZD27LDIpGsDmWxiWet0m43mX7ncDNXxS5sezr91YiTSKe+0Zm -AKBDhMcJd7sG/m76M9Pt+8v5RoLm3o0Tafipq/8ynBoKi1aQNh/kfValgWAvc1zc -UFuUlKJYuMD54tbhReM6iJS1V2AyQ311pqmSsm/GB6i4tN1Tf7GksUR9A1nF3a1B -4KQYsQwgJEHxMxzEq4H4hmhuyCXi8DmwMM9MNLJPP+EeZkM6k/AJ8+htfhjVY3QE -91pH9mbOSyysCCKhTqcvbnUKGriDfR7/I6JPI1N/eYtPJnSHlTSUq7dCwaHUx9po -6So8MmW+0tXtXjB0KWvxe37IcXYAJP1oUDsF4fa++Qb1FFu1Q38fPtVy5jngdvKW -kTefGq+idXmzEKJZgrkf1ld+g6f5IeMxLCuMzmkJ9onn5uW+OGZrEJzh03og69fB -Z34cA0/RYkmGIkIdiQIcBBABCgAGBQJWFiuQAAoJEJ0LXlse7I8OYuAQAOazw9xL -aBXOVl8CL8Uk9/VPnzOfncMjvMKZ6zm/UZ8s7aqqHwvCDIEyjISS3ffFasiTEhtG -ubZpR9F+pTEejf1gpdYxXrilwksi42KvFISLXXSbHAUZRYI+clzI18zT+ZdKX/Oz -tTjTNGtiIF9ce/UYxT6UBAXODwOKGfR/9pRVqoMl5xWWTBYXzMrt+eN3qzi59dId -uPxGB6Nl/kAT4EUFUtAneQxLmAxaCVX6w/UUzK5j5353goXKXKGE59UZsoCsqORI -Fl5ZVAKXYWYoGI6x3o++O3NpCNUA35Y9Qk0S4861kszPsXt6DvK/Eps2ffRWTQ8m -5WKKn0Ld+Pqu8lINmNMRyFPJiNJhwa81BjdmVQpq7SKPA82YLREJDb3uOGMcfukl -vA1gqErX2fzUwJI6k+Fz9XHaFd8WsoJVQ4gTYlj/gjjH3qFoEYcF8HAUzgKj/iEV -aTneyLlV4B7aKj6PDSZ2q5EoRVKCucEhSlt+Hn6Cb6+DBji3Ruwaty+Zdv3JiQbI -E3w4JP4hTBwGkdqUK4vUYMqslP6L/EEzTqgVXs2D8jx01Inpg2uYGxbtnBgklH9n -TXK7xYhsLfSuG4FpVZ4iy0RMkuF5V/H+1T3mUQTxdZqxQcG7cf2yp4h1VWh57xM9 -Swlnc1o3SofCImMVG4pPdLdIAhwa4mVEeSb0tCtOaWtvcyBNYXZyb2dpYW5ub3Bv -dWxvcyA8bm1hdkBodXNobWFpbC5jb20+iQHCBBMBAgAoBQJRK9QeAhsDBQklmAYA -BgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRAp7li5loZRcYJIDCCOqpwdysID -uKzUMjn9XRNVIrOIiTrg1C3Pc2Ij9ZcQx0Tse7+Bd3eVE5sVC9b9Q/9ZPpZ+K5cq -CYx1CJgmRMxwtQX+65NH8u+BNoDu4pQk2qPY68Z+FUDpooLo6cgEHzdOZsysTaM9 -pyUFq7hk53SKkbPghEoDWpuSmdUjhCHjNyUPoBeVDvSb0UU8S2s13Y2QJwLm0OB4 -cvOJ9E2oOWHmKdXcughezrEgY/6Da8XSyvrwGEe+61/Z6YrPJaQIhUimrARlpPwK -+8RQVVdb2mZtTcF0qfhDx/KuoRVpm061r3yNWjyTlU/YxqrJY41fLjyhsc4tbPuS -M1AE6zqefdgHxgtwBhKlR2h3Qp4B5W6VLKm1yuTjCLTGsf8gQHXbhT1iFzQiF5Qo -/d+dH7LtSgh/bKp9q3fANMD5Y+AFu8NSRRk0uRnBr/+OUBJFEZXtojmUpuiPGZvP -CWlpwaGODNk91TrsIVkopY0Rzt5KSUFp07OtkL+uJEoYTREmk5pwGuDOgQhRiQIc -BBABCAAGBQJV1uvJAAoJEBwnQjclAHckk8oP/1VPCRIGUWfLPFi0ujrGP9cf/H97 -ZAze4LhriJYGA+6pKY1zJi0p8FMNnHQ0EPqRINaVfsdGWZUC1tVgAtguxft9NN9x -DJYCq3mVtRwLrlVGhbMns8m+MxTYvawtSw8aLT7HOXAxloPrbTW/s4+u/NcDDGZG -23y3TYEcL/cZM5R8AgYwv30F8PuUIb2ZynS6Prvz9lOE9CB3UR/XPkFAEQQGeUkN -1KxLLXY4jB26k8S6KyXKpD5Xv7LaiuAuNBislOxc48NKLHWIPU6OZ1fRdn/ogpu7 -25X0nhech4Rnc2CKluzQE0xRHle1fnWuEYD/KUHG/D4r7+d39qJaBQHYAGrd71sl -zt1R7mxU429YvzzJy2yQ2Gz3m7gbx+iU6t6Pr1pN+/tRs0zO+7qDxkwxOwcD1ODn -9wfiAknp8Ti3EZ/wgfIW4DjRdTo+dEAQX5ksFBeHe5KEVn5ueYpxwnvp740LziTv -Strp9sxg9iQejHIAw+LEMgoLBnlVt2YBpfGEQJQyl72TcjVYqujTDFPM3TFCwn1z -OW4H57C10gKkWQMUj79qFyJ8Z+7916JxtUNYbDMbDqtiuH/VonRaH5KDv/N5eJVN -ocGaaTQ/4k+g/dDfwHCMs1Vj1L6Z9DQYCVFYAYrJxsda8z6PApo5ZYpbNshSH7qZ -1Ous6um4LxbnXelOiQIcBBABCAAGBQJV2bNaAAoJEMamgupjyC8ci2oP/2p90EBR -Ib66FJTJOyEpR1s8Iwo2+ZYgrAmdDG3+DA75V5ZId9yyKZJmbyTvuBe8kiHLCYFO -nwB9bj1sApaa+lL5a+R/VO/gR9uVir7454mKoez4nqV8zjy1tZKancQKvo6AaNTv -eQEid3w4sy2m6Sh1JNpUNaF5m5y4eQIpbD6WZD/IT/tSaSb4AJKpEIk+QF778S90 -HxJV1FLnau+RWgU1MZy3usSvI/hZG+/QRyowEwggzqmWKQZRVcul11ymxEFCkvwk -k7XCwPRREm5XPe02R7pkurBKMdZovBOdVLjIo9seGHoxtlR/7ZX2Fdxtzj+MPBkC -ivj8FiOTbOUuVZuf9Axozns4IL4AUkyMzXlsOBYqiE72YP3ejF7LP/xj7NKXUmo0 -yi6wwOSR3Ifiz/zQFmGw/qNKsIB4RFKPB/0GfnTIS1XnGaEWVSVviJBS4fMwxjm1 -rqrjpxqlBLB8qyCN6576pcGcVSt+lCK0zqE01WP0K8uYisSF3h4Cor7dc+OdrJVL -rFJtr6TjDxIilYtjDoBpSRj5wTreExtIr/N81ZePhJAOSj2XR8iWatw24mE82FfT -Lva3gwYMTmLyZqWjB8rcoxcSN//CSntO7RajvnyuE84j4XugbAwoK0BqQQtiz6Xd -fhxlYSisnkkLitYo6Kz0NYjihcNWIshgg8dJiQIcBBABCgAGBQJWFiuKAAoJEMO9 -eDJoDAlsGOsP/0haIolwJRrPgW0jZWtxKrbTn3YtsuFfYhxvih0gJ3tvrb89VNAj -b4ppvLtCRiR+x7pAJgtZRcDOUj29LRyABdO+5JH93RHkLi9Fao2HSGyI5qXRvyAG -J59MANoI69Jez4ahThy68wcwxuGvmC9g0cFnyr+QKUtrndpl9SiD5oXmrA6SraNe -sQAN1Ns2etEkxU1sWjVMab/5pM9An9U2Shjx6wg7qOqmy324nCQFIHKKcoDeM8+s -WLvWg9fv4ZhTTs506PmVbIvK3Fx54J4JtO/TN4mDoQs6Nap3RSa7GCHidcUHe+hr -VICOXRY+96dCkiPi0sGHlm51HY3y7E5BTja5OeHFX8OJzW+/nFHULs8GhKDhSMOa -eSgj/P/Pz8ZZR5xh4yFuKmUfA3uvEL7zxpt5bDmzJM+sALT5aldXv/BS0lQ8lgrX -W3z1uHbe5uIPw1ihRrNEPEq9N7qi6YsZPx/YZ2RDQAfs/Kkjn72fdljKNc5qxjhd -gkMqNPbGaEzTyXFHiDE2WMJhYw0IRh62UmHOJihlp9Nzfc6KshRypFIG3Nnbretc -XzS9gk/Rle4iwmSrPr44UL03SBaMk/7vsbFr96U2wCWTJY2nP4OKXY0y7DGDMgmc -bYuuw4npuCF7+E0ihwJLKfR4BqLAPd2yvc5F59B/u2ghMTEYOG87CPiuiQIcBBAB -CgAGBQJWFiuQAAoJEJ0LXlse7I8OOU8P/AzwAUcrVOvdcB7AwUkwkvYRCW/M+c/z -5Xv9zIKFC6rAWyuRKjt+vIVwDjoiYXH50knLjL6Hd/dRSYvH/Qc9EFUDubDJY8zK -X1XvPQ10eLF7semD6x5AtiMJfXrSLmhXUb32YYaiYXnGLDTeVJuHVC/rXMK+4o/A -kW7/tdeEayYYUS7dPC9DyUINn18TyxH2hFUmFIHO0kCMnh+OJS2VpbDdNMTFc9qz -UuAUNdz5xBWeaOWoJsb6VfHiKNqgSXKC5RGksQb2SyUxfdKDmtTkaTFc0PkltdMX -mTn7ADyFKwp0P3GouZo4L3WjRPZ54+L42ceoFJjMOJyxYnDZ2kTFC87NzEvWRtg2 -A51Cm4MOks/0omMU/Oe7eP8hN6egltU3uL8Dh2jBFA8T0lOm+av2FNRxjzVIsY6s -zSFCUq+oCuXi/OtXBCqPjtgfXMyw9RX4VCutIgyL4CHOUI0Wu+S8hosCVpQV1Mly -pfXISmDFpYJ0OOCfhc8SHhkWEHyPaGeujOTrSj0Nw0vMYfPDJ2a6Z0zMTiCSKx3Z -nOy8ucxOaIJhNjShgU4+VQlHg1GfAEtrbwvy1Y+XLJbxVGJaUlIpKMf90IxgP/5c -aik6oEneFK1q49jhl9CyEMTrqur1braO7wEJdF36OZa8KRvcSrB+8OUayBPigTwC -jvQ+tqZQYNHxuQENBEgd5i0BCAC/9nfIuUtQnpG3ldqumR6XsaWBYCO/BjSQjv31 -Nv+q/5u82RP9vPD/SdQ29Dl8WPiG3KbiwHs8vo1geGgWaMtqwuXP8HxMCvXai1JC -SRPDm2wDIJEWTvvlcvTKAsNxXMfMm9EgTw5/Xq5JEjQ7kSjdyJgG8FUgx+OThweV -JEQrfGN2zLqL9p+D7kheqMY3EindaE4kPgNYFJQDDaS1vcyudeNcHKCJ1S5+uWPJ -S15QqguOcl+4PN26ezW73uPug6bXxC6JKCfCTWBlJBa5KjJQFz3JBofbvuyeU9n8 -0rdoOik8fknv3m/W55JyBC3Okuv8t7tyoz7iS/fSGrrHtPNLABEBAAGJAsgEGAEC -AA8FAkgd5i4CGwIFCRLMAwABKQkQKe5YuZaGUXHAXSAEGQECAAYFAkgd5i4ACgkQ -nV6q9pATuEIxSAgAhmaI+89sebZC94mF1GtOuEFs8tpCbBw/RJhO6AAAPjlzSvY1 -m1TWHlqCSrCPthJZ+Hb4Tzcf+PNbGd0YnU2kslFML4MY7tX1fjGi+xU8Z2xHFw7j -R+E4+7QM1fOPVIcGWfXWwQkvTq74hH3WhSBbhYKEQmTbza8oRUcwjD6i9qH44CYD -Xy7VCYPWyy+12lnwur0NEtSbJ5RW6ZuhvvrBsuz0cAuHiXdN7wdpJ9lYa7tgZUW6 -GWJMNcJpTRQffYUslJKffyo2YEsD9VY9SlYzcSZ0+aFCxRm/eie+UNxGuSkOJ90U -mkg1QlVuXadtVtlbTldm7k80IDviZAQzOk4Tg1RPDB9jXo31FlX0DeogAEksPjx2 -VUk1gQv9vD+x+HVmESsX0tWgh4G2rSkia7d/XclmEmHDws3y+T0YnvymQpPPfsl9 -iRZACTJCXIXSl1f3GOMRn5XkFQQ4BwQ6Tm7OL+65so1cRrJ9Y1NR4+/OlVrEYwFE -Iphipzx7MwMwaUinMMKjv3VS5BMkRbbqVUDgyu5i3pH9U2UjzYNjwn9+HJu6lyrT -8a4MjQakYZ+qDpIofnf6uOqAIOWRR2fyuOMgzF/7UjIIR5N5StpisXwgzfgNAIVT -dqWKly/zT38XJqju2cJ1zYnyLIbsHYfE6A47rfUep9ja3RMBMRA8hm+N5ny3cUCT -FrVNX3S488YbzNRP6X/BRH+8K22oaVdAHoWYrpnblWZB/OzQnL2R89JwdAG0Knil -SRAPEz3UeSus2uGlQJ+TwCshisV3sUS4uyFhHHvtzgInfOwCCAeLZuc16crGYQD2 -h0VXsAdjT2RtAj1iVmUBLHPH8F+WPSJmtSaNlS/Fe9qobJKiuQENBEgd5mkBCADH -DPwGFZSRYZncDpMQfdpr9EYnUqLfN8Nixiut9TdaAIn9GDatlykj08x65r/5LonR -xJcbvfHwvvBnRfa4q/5kKAzTtY4AUGVIaNP0Dkrq9PBUwD9F3N9ouPStCfg4RoTz -UruILQ0rQ2h89sGdpO4Gp4yJqNjj1+SfK6i/mLgGG8ibpA/B1bDdMHsDJVxbE6jT -2RuaT5FuxrMus4lq4NYSuPhIEUQ1uQsKF/lX3E9DtyOi9LLkCui2+F35XzX/6/JG -4MU40Z7jmPe3aqR3GT2Vxk5HnVN2yI/hn2FPqoGtnR2FR6k1lrdMKcFG2StcaJW7 -ukY2Yt0/SHpad5hJP7nJABEBAAGJAakEGAECAA8FAkgd5mkCGwwFCRLMAwAACgkQ -Ke5YuZaGUXF4JAwgrepkeOv9HYK+vr0bloTgJ/kWUeXZvhbFX0eMxCFaktaYIglW -E5WPqcyf1U3IXa0YxKoFa6t6mYeRzUI7kTTzQLbiG2KjnLXBqDzMHZP/s9T2UUuq -3RSBnf2aedbfAu9HDpts9VHyv1oJnpkOY2OjM/1OYOlE3s45pE9wBZWxRVnVBbcE -3hb42yr5kBKLEzlaDqhcxj2wpZu+ALmoYOs3gmtXout0GVMZlxTWFQldh9FmWXhs -d/9EQ9p1bczt1hapalhQSKgwzRpkZtsM/8WE9nC3aF4iTmU/DzIt/rCFJ7+saAc3 -KFQMRPWEgpJ/XWx9OZmDes8U3LvfJ/RWzb0JNw7at3axQzoaEOS5Hcyon60VuG2S -B8AuIq8L3CGOHwnruKnZLPBCrqo8JavRsBI0r5RIB9Kg7M2QVc2Zs1R/UNxrZ/07 -vjzDEV5TmvSOWDVKug+yLclkeDj6Q1wL39vlvtgGu+KOYsyHHIFLLFg2v5gRlEG+ -TJvwmy+mLoYj82eDq0dfoLkBDQRaeUDpAQgAsNl4EliTztpzahvKFW5UGbdFZ0If -umlCCyuIKW6Tl8k5IqCmupVab74CgQarThH6I0zLGj+rFWOsl8ioak+VhoTt5Hfo -TzIveIU5mrLcL+hgSLfmsofNJG/zUNcTDy+oJPFCEMEbFbzArwYTkJbtK7lC9bc0 -nCVZPVwWkFLjK2FB0gObZlfVzrHMh07O3OZnDEmt4DPHuUxy5jttD2XyOQvc5xZF -hQZCMuO81dc+wuoDhu37vGuV0pDHEknLNjQdY0JHgzNJYDRdaeI8q6jF5XH1067f -tyzFuhMoFH2aNe3pm6Ns9IfQo51AYZYvwjYzBfHnK+BA+wRyQoPcA/jMuQARAQAB -iQL2BBgBCAAmFiEEH0JBiQXYIGqnVMzcKe5YuZaGUXEFAlp5QOkCGwIFCRLMAwAB -QAkQKe5YuZaGUXHAdCAEGQEIAB0WIQRZ+7Vcp/OoqwxQN3PYHEiH8WeaZQUCWnlA -6QAKCRDYHEiH8WeaZTZrB/4ofixTAgSc3vlTSDsTu5v9oP3FvHYcJ0KqAr4hS5qx -viulTXdCkqL4/KhvsqVXgKLj64nD1y+VRuR5soVZ1u7JQTVd9jjERlI1NH4cvpuk -Tq+5G5bF/+7iBPAHSGaTcVndZHXxn69Q7bnliz7+rTnkYtuldk5g032W11wnwatC -rKC2Z+QYqbhC/sMGVbxSGP1tkWqXoCJ5Mh8Bdit8+4qafd+wHbOOLNLHGYUKBoeR -UwR07N8YhH7eJxfVV0sBLDLngtO5T06VjQsVeUJuLqhtoU/oz5ellCIvzipRzgRN -WyUNcuIS5Wi1C6tO+Eatw94+eSbLom5M57EyGyJiRo3t2BUMIIW8xNuGy/YTGRFT -7l2c71SWHjY50DbNl+JCjyAOitLtEGLtHJJtxv9AmmlHJ+CLDw0Ctm2j3xgk2Kbk -eHQKpai8d8Fee4rzsVU9WanUX8hg7yv3IXEdFpIJaNMKkeedmCrTMPrhz1TthyJS -BbLN8tKrLdv5IPOvGQIrJdsaVByZFDuxbNSKqonVvVYDxA+xM76E+8AuRlBcYtzy -blXIwIUa+kkGdhBQGp0hBdAqYKq4iFWRVlqy44M7Xt8RUk1yu9u2+c+BcitOnlqY -OImOp2THhjNGeLi7GDqtwizGNSEz1p76vOUErvcwR7DNyVcyuYrD/HVV4Qp16Njy -0hnHA67NB23CB7IN5tyJ8GsRHb/wPd/78tJedeJUJ5LO6FdbvNV2SdFzKYfUVGmW -cAPM5sgB02UG6/Hphag092gfOnqeArAWg3pk6NWysWC6pBZWRNMvExnRf3kHIAn4 -j3suUohuPhr7nKIEoUtIbB6IorGj9shVi91hIcYiM9mFvkUJ5cp81a+5AQ0EWnlB -CgEIALVO9ZzEdre381rsxAr9JLM1uCrb00t1PrYlfrG1uaYCnx1MpRE+kRZsr94W -hZccN6hzjdU50LnKx5ZKZkrqQ9oQf9cl+ZzNIasc8+bopJyXy7cVvOMZlojsqxQL -HDD/w9IZTLnnGtSjpF0jpAg+g9dPimEhG9o9+fhQxxzAzh22aIbqFKW2CwV6NsNb -Q5i6UmIWWkz+CQ0Me5xJXz7G7EdBtNeGEQ6bi1AthaxW1fMGLqujL6dSS4QVYMOd -qXYSgnboI6CZJqJgvDYSuQJrmOWtHziUP7cMHQVirePvsnc/vpZ5lNoGml0kMlEs -Dwwo3nPvxQdXNGSezt3rXlq0Ot0AEQEAAYkBwAQYAQgAJhYhBB9CQYkF2CBqp1TM -3CnuWLmWhlFxBQJaeUEKAhsMBQkSzAMAAAoJECnuWLmWhlFxRecMHix2Ljo9c4ji -nJwyzWXad5EWbI1pck1I9wrq69HXJiW18O1luWWF+fBOHFWCEh/ucceH0V65ES4G -4TdHF0R7QRA8jbSJ25KjKhvWghBou6JLYDvRcY/Aogqt57BBnsFlMIxVsT8OiI5z -WsW6kaDTACVbRTlKWXzcACg68eYVE0oi+Pfdfcmtw0gu6TRDMwFuQ3xHxET+WrxO -qmRY2DFQ8VRSHpGaAieKQiKLU3mVnLD9zXiY8U7ZgO1MWVKtyVFcxgor0kYBakMi -hKw05uBg6ubkGj2l1kmmHrfEjakyG7C4BW3JW9XngEbOGb7P1cICe7lOuZw/BQxv -Ydv/Q6w4cKBXAKFFOu2kWPIQ0xdCQt0ENguDS1W721k2MYJs+u4fNjhqMO+SDMEd -wwMeEx2FwjqXlukICekdhEE8tEzy/0VhsYT3tP2D9K7XDhmdmM+iKZ7Ql6IIHyk8 -Kd+W3EWGQ2clDsYJWHvC6y7KAH2onmxM2h6VDGm82/j5F/jhskwdrGfOLnGYqwQ8 -1QcrAQUAuolIEefpCTl7HXfyTDKbEDeJ0IWhOLlDqZWigRVVphV94Mb7m5VPmuFM -UN8NxP1I7R4iV8o6tpJGdUQfIMMfY8CAkXHKd4UQtyYtRDroP6bzP7OIaujptwNI -EEMxGQchfr+Qf++d6+OqK8iV36PxZNxVf5ICtwrLOBDny4xOt9B0urOHoP2wT/zf -z5k9mRpuYopYxVZxyhpRtYZg5w3A7QAGKbQlU2ltb24gSm9zZWZzc29uIDxzaW1v -bkBqb3NlZnNzb24ub3JnPoj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIY -ZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJO+bc2BQkUt94JAAoJ -EO2iHpS1ZXFvsHEFALdQXoVb2fK6QGwZS/PtyU050CE/J+S9pvTj3G65uML6QcYm -5LbkjOm+8s8ghSKTrNnRxAhZG3M8zb/qta6S0AEcVDSx/QD+jp/sCkQyedoxfE2F -HbKZaPNzaNIXXOOD8qPA+nOTrwiuTp8dtP++5kBKtxdPs5HL6+OGhKhTW47N6ani -07y0rV6GwYpdA3uk8qFamww7nNXNkfECU1TNSxeIRgQTEQIABgUCPVjywgAKCRBX -kynTwBsqImY3AKCSCOO5LlNxmritUFY1i7VXBCUlZgCgll/6kE0G/NP3E6AdyzVw -AzBPgUeITAQTEQIADAUCPV6wdQWDAVeKNgAKCRC8u8SVcYqSVleXAJ9NZKUvb/er -k53fMFUwpUeClOjhqwCcC3Du9UQjCn2k+7LWgqNMH+huqW2IRgQTEQIABgUCQQDK -ggAKCRCe11g/wU6ygrRdAJ9E3VAFWTv967hhsVAGofjrd1wfHgCgynZC6sxFcUMi -azAnVaL0rrl2rrqIRgQTEQIABgUCQP8/hgAKCRCW/5nEJcDsC70oAJ9goycw+aVt -kOLn8t7iZwsJSVD5KwCfao5DXiX96WWtqpZdu9pwImQ7I2mITAQSEQIADAUCQOBX -PQWDAJO07AAKCRDIgd1HSuerRyyvAKC0vbv+d2mN7DbxsZVhT20GYiDYZQCgoUUo -oe8kHalWNGREvgOOiFJ0iuSIRgQTEQIABgUCQkkBiwAKCRCPw3JfPWjWOhZ/AKC1 -vya2UjyuDna9PkNFT4K3c24N8QCgvshfzbd7Nt7sdV6CF6Kt/ervOYqIogQQAQIA -DAUCQkb5wQWDAOaxDgAKCRC/1u5YV/d/Ca4LBAC0CikFYpOeWXW3iUWdH4Ka9d2q -6LqD8yExWMaWcZrHMp92VcgNPeLpUQxCTrf2sItTE0HliJBlmbtoAGDV3C1/XSYV -BSSb123h3znZy7rK2aWNcsng0hAWuFlBSvG+HyzyPjWg3+FzDItpf4UsjQbol6HP -SbSc+URB/Swn/igK6ohMBBMRAgAMBQJCSUQKBYMAE85KAAoJEGa+cf9nSGiD2RgA -nRArPwa3+RztD1j8CGH/Bk7q9pD1AKCByClFignqDVBdhZ1M78fG97gu74hMBBAR -AgAMBQJCTYK1BYMA4CgaAAoJEDuOpB+C9hJAOHwAnjdsNOUrWn9otfEnb/WkWsdY -W+dwAKC9WWLhX0/qlWE/2n4fcA+1D5RFVIkBIgQTAQIADAUCQmE5nQWDAMxxMgAK -CRALeDLzc9YtQXGjB/9gsCikCalT3iQpILgQIWwtcOK8ngsI7GCpnS7sWCJCDBYr -WaIkmdb2AwTm8T+MweWyMbBQokMLdJ9uCM4mPfWK+sYiHih3z7NTRvCXCgmmkMX/ -lxvMGF5SIKzP4FUFmzyKLg5qGegQtTNdvJVkhOQzO2af/b7sNheqp/W0JPLAhH+F -DMWnpbsY1P8jvcqzP9wqiniPPETnCGSX7k0wGT1ViF9rZfj39LrmfBeDiKIE9A3R -SuE3Rm+sX64pfqhWU5f7fQKs/JPwWRxGTUA6FSmpuWTYzYNuU55uDF8XVlWNc003 -/R9mHLiJNthKCCd07k8jJsoyQyiBW07TsX/yW+0LiEwEExECAAwFAkLYsI0FgwBU -+kIACgkQGFnQH2d7oezt8QCfXjmAsN4+tvGt/A3Z0bn4i6+m+1gAnihGZHKHHCnB -qEYT7nbzXPZVOtD1iEwEExECAAwFAkLYsLEFgwBU+h4ACgkQgcL36+ITtpLuwACd -Fi5eiQDLrrGLThgPU4O2yxgXDucAniWqyEVWfs1HnLOe7S2KhgsXDJzniEwEExEC -AAwFAkLYsNEFgwBU+f4ACgkQa3Ds2V3D9HPaIQCgkWvOhiORHkA1lht5f+jNB5xA -KYAAnA0Kg/JKZrGvA7oGJR3XVs7zRs/FiQIiBBMBAgAMBQJC2LDxBYMAVPneAAoJ -EKrj5s5moURoX3QP/3FXy5r97OFY67kAOAcTXJ5YxZCx5wjH1MDlBVCDymmMDcTZ -ER7+UlsLB5WHB+9Ka6+7KZFDDvVwh2aoXV3P1HyZvrY3WvTsNw/GJuG0eLimgQ3E -geq8Ru05HXtjpCXgNbg+MrW633LbLnwcrpdOKoK1uDjeMRxteTWv2osmXYuCilgl -DUokLB+f4MJVp1EDYWBVyUwZQYh2KJPCnXb4T/vShigzMvCb7sxSBslSlEvK2xzl -+uFP3WJfaU+h7KUAcBDTrzVaJrC97GWq0A+2j0aNu2fDfahI6oglxtsyE3wbzumS -8GGTnBd9UzuTK60EWEgdxAUZ64aRmmB5e3jQ1xQl9+f4o595fOB1DCbA2Wj0rRqv -E2ki6SC6C9V422wqPWC1bsiRhwua+UPJKHP9zK2C40RT7VbRl4bvdOOmGzyYJKUI -pVw1ZzLaXvP8O8HdU+Jtpznbn9LDVkirsNKFEce/zHTb/rnwsRbuBK+9niPfK5lI -2AvaWA/NpihCj7zKwcr12pWJUFcAcjBVlOZem1vnPFBwe0VSdHnUgNIB8EZ3uCNT -k0k18oqeAuMMnLnqeYkYzD/7XcXlcVyMY8L23pkqhC53vXYrxNEhzNaAYyeCRqHJ -OXgojA/FXNadQ3QiRyw7/nI7cm51bPNgHqvVCiYJIAAD66Kuy0nBW0FawIDniEYE -EBECAAYFAkLySusACgkQbvivwoZXSsqgjgCfQJAD/fA8LGyR+ouG83r1WI1z0aEA -nAxHk2XirtjhzmP0E4b71jFqibY5iEwEExECAAwFAkLxwHAFgwA76l8ACgkQKaoo -UjM+fCMLOwCaAjB3W4kLYprdsiBMIm6QWMJx1ZEAnjs/a0soRy9q24+ec9PJZi5c -ZMGoiEYEEBECAAYFAkP405gACgkQ4V3YV7FcN9FFWgCeP6Q2HbImIgAj0kRVxyB2 -/xx0SWAAn2NkcVrgoh0ix0ZBnkbipLRiQfAqiNgEEwECACICGwMECwcDAgMVAgMD -FgIBAh4BAheABQI+vUdEBQkC1Y4ZAAoJEO2iHpS1ZXFvcXYE/1aF74CtmfpaVukc -X7ftGqv4qZcvZ8sjRv6mGd5qJ5G8AKw6Y8PeMOm/HP/FV/yzj1Inb5rbchqIIDwG -jLCz2wHGfk37JaF1hiN8NsfclQ5DPsEo3/2jwQBi5TymZC0Q3Srj5CI2xTRryosB -XeqYQ7At+QHjPgf5oNnF7+nu8hg/hCbNOfdlDSZhHmbGlznakXzYpXI1ZYm+ZyKs -/ApJyQSI2AQTAQIAIgIbAwQLBwMCAxUCAwMWAgECHgECF4AFAj+kK1QFCQO8ciYA -CgkQ7aIelLVlcW89EQT+Pd9f5wvEIJk1OMyFOEYW6OJPu3LjHWNVz3UnpA4D4mn7 -vw0gh7KDclN5HdYi/v9YU3MsolckQRyBr7RWI+Ogt+8awcwCfBeo9gDG7VwNjiMh -3RsJiChWWd8X2DA5bF5u2i0ukKK5cYv/XrzMQBdYmk+DqvYx8+EApQn0byrnY45Y -lbdw5vGhnaDJeO5Y4W3KBnW9QCo//xQZ5k11qMcPm4jYBBMBAgAiAhsDBAsHAwID -FQIDAxYCAQIeAQIXgAUCQIa+KQUJBJ8E/gAKCRDtoh6UtWVxb2irBP9radaQUXLW -rXpZRETy+n5Oq7qLivmZN3IeNuFB5mHk+5vkMQmIW5ZfETvclWuc2jNpxBtVuyef -ngHhe/q24QMzFpNdKOt4NjoPTy6szwDSCdQcIA7DG2Z6mb3DGT+XdYBdbDNChBqp -nY9I8UZbgSmTz4nBYqgu/U7aL01vJwYRxwX2uvojXbfX1XOT4/g/cU6ALBp0BAdI -ZLdjqGUub9EYiNgEEwECACICGwMECwcDAgMVAgMDFgIBAh4BAheABQJBb8RWBQkF -iAspAAoJEO2iHpS1ZXFvyBQE/06JqnOL7uoJymPxjLnmNC+CleSF72DkO5OVGIdi -M/m9O9ck0XukM44+PWlJTG6YLe+K/+nFRpYqne1I6OxPRlWDLhqHqtR2PLJssA4C -I+YA/evJK3NREXn9GdBtvOtIZklF95AjFjbzvWFaDbjX/CyVG02mzFhI8Ig8cxUH -hJIVjPNspGBRTtJexVBgECVFTrjhQT50H5vXuyW/XG9qA5SI2AQTAQIAIgUCPSXP -PQIbAwUJAeEzgAQLBwMCAxUCAwMWAgECHgECF4AACgkQ7aIelLVlcW+3cwT+KPAU -kJI2hjUB8ISbcBfq9EpRuOLLQx16aypqNcXprBxshp4LCTfBWv0k6zW6y7b8BBAO -/PSx/+ES/pzewxNiykPr5DOtExRVsubR+n6lFkrJpbW0778kig6Xyqw7Ch2Rc9Ds -JgW9JmGGTF1TBU5rpS0vqQ50KNADLsMNBPN1wL8bEdA1VQ0XkpwFYLssw3qIC3R0 -AUQxpDPi3fsIer4MLIj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5z -OnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJCQFzQBQkGWKOkAAoJEO2i -HpS1ZXFv0QgE/imT/O1AX5dXkviStcSZuMCwZv0L4j7g6hFRj+ZYO80CMammSEUP -7xDehC+D7V1w+wnmtAdJeADbDVs6xOScr0NqbJjfksd31PRlKWVc5Rf2rdB4qIMF -hzYoHflm3Eo0gDgu3moOBhtKC2URHENj3gEJLLhgCl3ABN6Lc7fa3kihH4Guh4iv -7D7Of2ZW6WSfelFcHJgNf+xzFxO1bBEv5Q2I+wQTAQIARQIbAwQLBwMCAxUCAwMW -AgECHgECF4AiGGRuczpzaW1vbi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCQxWs -0QUJBy9FJgAKCRDtoh6UtWVxb5qGBQCdY5EfmnoJ2T/OF6fixTDCfOwXIA5nu9pU -+tA+rnwLOXYXKYubmQmCwZcfxvoovFUyjyGNNmeyb7M7pdMteyecrudeTvSAEnQA -AzRcaUbneoO+9CardGR8Uwe5KbEv7MvyldOafLAiUSmAMc9Ups8oXdznTwcUQ8oW -cOO7JHA+CreraaEL+phgFG/D2GON5EKoNN0LnAe5YvOzkwIt4b7diEYEEBECAAYF -AkRzhvwACgkQCLEjjt2tR7bvyACfXmm4Rp4uOWlpOd2W/FP4sAf/3nUAn1vQeWjs -/LoX1zWWIuww1Y0OfK9niPsEEwECAEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhk -bnM6c2ltb24uam9zZWZzc29uLm9yZz90eXBlPUNFUlQFAkPzKQEFCQgLb9QACgkQ -7aIelLVlcW+sXQUAktWpJZDZ9g0YK8EfjFFLifYuu7N25ubM24Ihmtzvkz5F9O9h -4fAI0Njwf4+CBi5cxPxquYe8W/IvuOWfzrgz0tNfhPBE6uoqWQ2A6R/F1KA7PhAT -1EfHGigXUYyXXKHEKi6aLFgTnDTPQsZhErL9fN3f5UxxRoVe8SpjpD5ydCioKEK8 -pGawgWEXhvhICrNF493HpTc8GkLgVsiWRCSltohGBBARAgAGBQJFjAuSAAoJECmq -KFIzPnwjneIAnjtkYQ6tmsypXpYqZ8prz7n3TvN5AJ4j0sUROvVIrcgfH/tLtGVC -GioDN4j7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNpbW9uLmpv -c2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJE5uhzBQkI/y9IAAoJEO2iHpS1ZXFv1+EF -AJETR0F8/znlW/Z88LMjGe7UjQYz0GOYALi4w11bqjsjjJAxc1ik/xF3EPM9OifU -lhBmpBbvsR2q3CMV6C5Jy50Xz7zkjYW0oObOXQ025uZfpyTF0Ju5SY6TZW4fQhDw -7R/WG2TSHh1AH3tgDzO70C2rIBKR0INtELtGChp5RpXs3u/xEzcqkQmbqlx5BPUM -uo5AgUCn9wNrvrFcrZet3giIawQQEQIAKwUCReF29QWDAoeMYx4aaHR0cDovL3d3 -dy5jYWNlcnQub3JnL2Nwcy5waHAACgkQ0rsNAWXQ/VhuAwCePfhW8DAmFadnv19u -BJj07sIgEkUAoIkSzQNsBK616ksmGLKwfcnrVvkPiEYEEBECAAYFAkXiwsAACgkQ -qs+zhiEbbu/3RQCgoEdpjdFc6TCTlgvnyNJig5aW0n8AoNPB0pJREFndFN4aSuJY -ZlHLax93iQIcBBABAgAGBQJF4ZT0AAoJECZJ5ijF000FYcAP/j78nhXtwzV0yuvq -ulqCB+BFrt3XbV/if4pWfr1+bEGvq8yQY/7wCivjEwa+Qvodgm84xErvnYfBeKPt -MzQd0apTRLpyKw5eJL8s49A5rLPoe6+WIiEl7IMXjB8jfnxkfyBVMpOf7WW2paaC -B3wpVtTakS82176UPRUjErTCtRPScURigmwOVNRWmeYzg/E/xPCghHCj+H02cvzN -6H7myPQPm1lbgOxMLUBU8fVZhQ3hpjaW/j23AOHrehdvNdlD7EpYl6IHJqgN4Q4W -2i7BNvtFuYMEHWLRp5vuBYKvJSIcPinbN/5H7iKRzBwbQvNHsMLdYV2U+ds0gj8b -fVkNpyk+qSTlLcsvaMhcqGkPXmKVtcaOSqwECQ4mk7ut6FVvEQZR8aH7ZNlwK8sd -6H1ySCOKYWVnLCTbfQf+2RAmmcdpM6aE1sFujBSQh0KNMEuSrJb32wzaF4OSaRiH -2MlOPYEtUQPgeuDIyn51cZ4MzudUYMI99toVNPPoi344Od0ALZDR3Q3n1LPHZdvw -th+eB7N2FXSrQaAZeX6+H3O9mekdXsF5/oAFOrQg5CuLzchm/ceXIF4roo8lPH6W -XfYHJDwlwy4ABpWpZcj3Xgn98P1u+xPMk1Cw8RrzIG1rbZbD6NyccEGEBtQp/DkU -o0OupivhUZj35qbzRiachFAi3sW7iEYEEBECAAYFAkXh9ugACgkQTUTAIMXAW67N -EQCfXVbeC1rKeYQBzHD9bEt2d2YvSaYAoKx/nnI7yROYqiiFFel+j6OfgcFdiEYE -EBECAAYFAkXiDPgACgkQVRVgdpFh6RHHHACbBXLVPthBC0/vFc10z4RVTEue15MA -n0DNrGVVXh0785lMb1ANurO1qAfniEYEEBECAAYFAkXiCtAACgkQx9kwJZ3/qtS/ -fwCfeaS8JZzEYqE3r8+BDb5bjOkVA8MAoLHB4HReH9NAOND91JqiP8Fxw0osiEYE -EBECAAYFAkXiEUIACgkQ5UTeB5t8Mo0niwCfejC0vDARa2nD1VDFNzrpyZ2gWo8A -nivbPdWBFr82z+5YzFXRmV579/YziEYEEBECAAYFAkXiLeAACgkQdklABUmu6/a/ -ngCgkKXgzQKVmvDHJOQ5cmzvF5CO0O0AnjznrfpQfa7vWdl0jIZMypCSzOYGiEYE -EBECAAYFAkXiw0QACgkQfk6lT9CrQHU0TwCg4lj1Verw88MM+NE9oktqGM7KTP4A -oM3eNeAe+oPbp65DWSwQFzxWfrMXiEwEEBECAAwFAkXixHwFgwKGPtwACgkQcxyv -01PBoy/38QCffmEBNYGJjutrxnZuPL4Znh5ItCYAoNfUZ8ieRPnv+vOamTGf4hCW -KQIwiEYEEBECAAYFAkXizqIACgkQ2hliNwI7P08DkgCghm5xCDo9qosRNsZyH/LZ -QzoGFnYAn3Z+Px06+go3Gf1GHhRxNJKI9c0OiEYEEBECAAYFAkXh4vcACgkQeGfV -PHR5Nd26FwCfYtZsCBlxFFTs8m0g7fOqwibqR4MAoJ5mCtBpR3UZI1bgDNku5P9d -eJZbiQIcBBABAgAGBQJF4s7aAAoJEFIiU8PXJzmBhQwP/RqHwqojquPKLulao89w -8rL1kKc8m/YkmWW7XDHh2pFmdRUDeuYcBSnNCnsex8xdYuCPE6dQS/ONmQ89qZid -zN0TrmXkzzNqHVY2N9HxWTj9dp6iVVd7drlHxXGPbtBFr5PnIQemtvmE+ji4VaQ+ -UmAl36pxcIhzbzXflCeA3m5FFArg2cz+hO2/ae/XkvgziqIfpX5Z7khb5OO3vg7S -ZIR6SDVsH9cqUX9dyDI7ysRmCrC59nhwdvNZhfDcL4IqSENIMi0ZTD0d6w67UVL4 -x/8mzj7+QWNbxkk8U74DbPeBhMPNpcarbOW9urDWBgh3mlu6RUzo9GpCuWq0jYrN -rv8Jjzlv4NVT1nB78ev7JicQl0b55aSyGYHSYheBCVJp/+yCWwCdyubED+CbkjFo -TdMhFb+a2LO4JTCr6CKAhQQA0Cw3BHlr9EB6Rzxo1o7VxKPyLOUaquXpy5DmPKLN -QkHkBw5XgJQOJrMhM5qxu3j7HH0xOxyKpYiQwthGWhW6peCygo5PFNPpmr6U8QZH -Jh2zs4R1pcdY87Q4nZk8JqBvc6+rElzXbdd/tdfJIaQZfNmCgDoPgHAgHRvlZAWr -zvbZvS0k+S0fZrlyUomKjdIyKvVuk9Ppv8Iz8yuTeQgUomma8QFispMJ+EmcMjYY -nhn9/qtQOGLJDnKPlGinbOi3iEYEEBECAAYFAkXi+TkACgkQi0rEgawecV55hgCd -FtmecWhKtujkT3TzMV1Q/B9V9SgAn0OCjVa4Yc8P7z09KqzIyyErWpq8iEYEEBEC -AAYFAkXjLSQACgkQs7H4GgJ4eID1rQCfQTRnKN6q7+JFJIH5iiWFGpzzu2kAn095 -Fu/wJ7VNjqoKjIg7vrNhJxfliEYEEBECAAYFAkXjQPYACgkQOJpWPMJyoSa+uQCe -KavwPU5Mfw7z4TcDZU6jEuEbw9MAn3cBH2E9MHFUFj5OrNqlDPXZE62OiEYEEBEC -AAYFAkXjQN0ACgkQH38yahLu9iqadQCeNytRIiNzyON93EuEkRL3IMFM/+AAn1lK -koAbiS9WNmpxIGG50YjDY2RCiQEcBBABAgAGBQJF4zp6AAoJEOjgYvYNywQxkpQH -/1tB3+TKF621/kU+FI+C1WBlqcXaQjRacNZQZdtufy8uzsY0axvp7K5QMQyQv9/r -G1Uc08LjgdqtFtrCGmH+bQ/bkpCVodfjXbSB1jM9HuadQyT2Ds/bJw2tw0PvfSgk -xLd/wUGF71+e3hp09Tyanl+BTbNOx1UelrbNRVkc2HziK4SjGhkkRYTIccmR79q9 -ttz8bomYwP7y85Xycodu7M04B8DT2Q8lYA9x9H+CsKkQxnxKQH0XgW88SNTYfF4U -rHW9Y1NqaSvrKBRWVftsHAsJ72n7u57Wsx4o4ywkXtScCQ62EQLYh7KE+fWDISuu -NjNA5f7f5g8JI7vd8HFIbqWIRgQQEQIABgUCReNLlwAKCRAonP/A5jzW1vlPAJ4t -3/+E4FNP2GdKRkW7Euyj0ndxOgCgqexJb9yx0XJEkuHTbgKpLO7f9BeIRgQTEQIA -BgUCReNEwAAKCRCMJe4PDcC31pQdAKCWAKLqc2K6nBsR/ASy93gxFhXMawCeIOPf -otK/jtMhuZRAmVH+qI0n6mGIRgQQEQIABgUCReNVAQAKCRCYS9OArF9wDEQQAKCZ -fggatK61y8Cz09+volgQTeF2xgCfXIu3+3Is72VpZaEsqE0fsw8dzTGIRgQQEQIA -BgUCReNPRgAKCRAhp7U7gAlp7w34AJ9cKnT1eZRBD/G8DguKmhMCjKpf6gCfdpkc -VI4oQ1doe2Gum3QUVo9U0QmIRgQQEQIABgUCReN9owAKCRDPEjR8lovVhy3aAJ0T -DjetrqjLRzAtf7PBHNNdrMpCfQCfQW4Ocazonn7HqGUrcwWPJ9FhlzmIRgQQEQIA -BgUCReQa+gAKCRBkNkNhCfNAJHR4AJ9Z21p1Asf0FuL9g85yF4yZq+YKtQCfV8Eq -zjpY6ruOmm58FfBydx6B/EeIRgQQEQIABgUCReWBtAAKCRB5DoyUYf/aq8PJAJ98 -wAxFQcI8ohtvPn0FU2aCnK9KZgCdEyymYtgXSCTTF8eggVpLefC3cOCJAhwEEAEC -AAYFAkXpWj8ACgkQV5MNqwuGsGdqRA//VnjrRpHcrLGsKsRwMn9XN/u+xurUNCea -hG4iCkqZHzs3epEtvan3h99FhjGVZwWPWOJhPdarZvGMfIJk+BwAzZtC64kwXFCj -bGDChvI2p6whp+B1syN1QQBXL41PIl92YzcjnuWSuV4bPqWT2iMwuggNr+1HUL66 -gu5JYyPReT+cJP5ac3f/GpnI8hr6Low3x+4jo2xr8LWOI3DYWdnLvbWGX4/UGHH6 -L1qJcJHSrP/cA4A7PbkXQ5c0op3M6B2jmYKR6VtRp7LiA+m9vahnfSuHpVN6U46U -ZTpZsQ7cNAG44YDEnVTHzTWmvMhOzX3bdtlTwQ/J8NnJlYg2SmXszgSfhuoYpCSN -Mh8TwatJIKn2uwuDWyIrfzIxih16BLNIntlZYaXK4q+uKbV5DDyy9LNGmGy6NoMk -bw7LcOVzeoFsD8IbHU63Iwvkb/DkLlvZbP8GQyAec584lJWMaUkmvEbLJ1GpOGJt -nzzJFxnzXfQI65tHhGvYj5MP4VkuEa3NAaJriAND1Abm13otLnIs9zdjnY1zBaxs -wdbMtNDaTc7s9yx61E8ul26KrV5lRlm95jQxKMf64ffHOnqp+P0jgUO0rp6kdDQX -0PDyQr2oECGKqsrGxRRtqXHk+6nSAiTM17W/OMHJLY/+PZUyFuKeEbkVmXQ7aY9w -hcd4eUAl0YKIRgQQEQIABgUCRe3kuQAKCRAwaekht5qHHLhHAKCDEPR0SYbPuKkW -ubBsgZPG7EhL4gCgp/HPGOJPabcAS9+Qv/E26qB6c9WIRgQQEQIABgUCReTBXAAK -CRBwsgMhOvWdFritAJ9m+tdqhhDxN5f+WG4l+aw9vuQhFwCeIrL5xMY0TFGZm60V -f85ydq0NkTGIRgQQEQIABgUCReqhoAAKCRAvlRUIquYCLugTAKC7/ZyF43iZT7IU -UgboeYutt4hzkgCgjYjh4tYl2YukmV45iAXsK1MYgrGIRgQQEQIABgUCRf9sYwAK -CRA6kP/BFAjX8cFTAKCVwzRvp+XWg/yKh9Z6i+6FKTj7mwCZAeuB/aluoVbWhME1 -LrR01CMDtV2IRgQQEQIABgUCRrXYKgAKCRBd4kmWWwNYoiLMAKCqTtHcGGcaDOto -ptw/2pIyFtgGvwCfZdqHdtRHJKcrZAEPHgbM0z+8JOqIRgQQEQIABgUCR1m07AAK -CRByBDZwveXx7j9cAKDailqKF+kwt44pvZs1IPtwukjc3QCfYDav49w6BQO3eogh -nyLbgcCEGdKIRgQQEQIABgUCR1m3yQAKCRDhDnoJ5y95+sB+AJ9T81uQrjAKIUzK -+Jej8Xy04QbKqQCcCA1pKYPMuRhnEeUzRJeix8d9X12IRgQTEQIABgUCR1pzJQAK -CRBoa1bdYIokmw4rAJ4sqGiuvTUYIqddHxBoa8iYtU6b3wCgmnJH1YwnRyxf4K4R -3MYkNOUPynGIRgQQEQIABgUCR10ggAAKCRC3nCiw6X+FbQ63AKCmiwXue6R1NDWe -xB3UAYdvQKRDNgCfTpsE4oxew9w3ZW8yI7aGK/0UuGeIegQTEQIAOgUCR1yTYjMa -aHR0cDovL3d3dy5oZW5yaWtub3Jkc3Ryb20ubmV0L3NpZ24tcG9saWN5LTIwMDYt -MTAACgkQ516QwDnMM9tn0gCdFPHEmXZG2/Vlucaw648nqa6w/7kAn1vxvdj0Evs9 -EfNaBCPMAtVVdGt0iEYEEBECAAYFAkddH8oACgkQ8bpMHtHIuo/udgCfTjxwsT+I -0okXGX9HCRj1VxF52SsAn35jq7rs6cboed5SHOoa8wNtoaYCiEYEEBECAAYFAkdd -hUEACgkQhQZbWdUt0adQnQCeMXjcVjlLCFxbYma49W7VidZ+vDAAn33TOS+YhC1E -KvEzMyBOHPiNVqgQiEYEEBECAAYFAkdcC9IACgkQ7b8eESbyJLiDZgCgxZuecX+x -t4zz5ZOgo7SeegmtdUAAn2JffBe1LACqsr7dfmKZF9cZPGHyiEYEExECAAYFAkde -5N4ACgkQhcIn5aVXOPLh9ACgrPymJJMIM+S/Sp42rRt2gOz2Y7EAniU7wekYOqNi -F5oC8obu0VnV+xmMiPsEEwECAEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6 -c2ltb24uam9zZWZzc29uLm9yZz90eXBlPUNFUlQFAkXV1VgFCQuT/C0ACgkQ7aIe -lLVlcW+MRAT/Ue+Ic45Ie/Rm4534fpJWWTCeGbHiDp+nJ545rj2XLCCAwEvzN10H -/3bw8xgVBD6m9iYQKQ4r47qxU7Y2S5uilnAT+FSO3mxzRdNhD0u/GnjQ38pRHx9J -HkW8tBJZgZhENeQre3cK1rzdl4mTYgrjcOmBWgVYw3rHr0OVEZPJFZsHZV1G9JnP -dkqnzqnlyfAxP74r6k3Gr55jRQmistGP5IhGBBARAgAGBQJIRLl2AAoJEFAsTymW -nyods7sAoI+aLtGLwUohj9Z/0qxrY0UPFSdHAJwJ0DDAbrtmamUU21mVUNbAURy9 -P4hGBBIRAgAGBQJIWW8rAAoJECTTK/mqlcNJTB8AnRM8PvxLcnxS+jOIb5tMItOU -/PVfAKCdaVXc8Eq87G4ZIB2b8M4yVjWiAokBoAQQAQIABgUCSQa/OQAKCRAp7li5 -loZRcVi2DCDH3I6jxwJHZrR3/QnxTHzACeMsjybrwEKIpboeYDNfH+Y1fZ7OJxIT -Kpy+/irld2m9KtwDaSaVEQGm7uaafJ6tS5ZaxMsxuL1yVdopFnrJAlAFutFjCte3 -N0XOIeoWPD6ELX25VeU+Fdhr/xgvpoI7glSXNZaBUXzEe6l9FMh5e4YuQL6xbDDZ -WZKbwWDQUEb2Oki3jBjE0wjvuyjizMT+GgVBJ1G1jWULXyOOW42LKAY1BA+fuvk4 -rCsr2FfWAZkDa0ZhVfRmhgBJE9lxRTNpg8flxnzpICDXnPOuhUPh62aT/aIjix3N -H0/IqvTNSnkU1IAVF7Lpq88CFpM2zJUNGIqYrc+dkX0f0dpEskmdARy9683ThWDX -RVb87fMIUwWLzO7FQ/rKCgN1ZlP2NHjBvNUTIVjsBTBedK0N3f2nehqZNv1e2WeB -MmOZUFkg6Vqni+YqybS3bG+JrG2jq5H7rnphrj35Khen67n50YNPajSQWU1oLmv3 -Oi8i2p0NhQe2fsOwiEYEEBECAAYFAklnJY8ACgkQRzjqIWV0mXrX4QCfWOmJOmOq -r+XWgrAlBgMHRayoZ34AoMSIMe+s3jpvnyDNAp1VuzjvZsVLiPsEEwECAEUCGwME -CwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6c2ltb24uam9zZWZzc29uLm9yZz90eXBl -PUNFUlQFAkhh+YkFCQ0YdF4ACgkQ7aIelLVlcW90DAUAiyFIF9jhmfgFB9qnWBMi -ONxHL+/9sGc0x/yAxeR+bUUtMBpqc76f6UexM0Ss+1oR/Hx3KO8SD7CY5tqoAlih -HvmlcEVssp2I38/VOnlZ38LS35xNPZ1q3PY8vlcUoAxGSj2tJPwLUxY6KuIfxqRz -pToz7VXL91hw7ZN/cPGtcMtMXKuR9X2hEQyxEVm7pbw/tRPnvwSmKf+xNhgDrX0h -c4j7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNpbW9uLmpvc2Vm -c3Nvbi5vcmc/dHlwZT1DRVJUBQJJoS4ABQkOrVpOAAoJEO2iHpS1ZXFvilQE/1/v -73J5hkIlO8gs5aWxgi+XsnY/R6bapifc1sNRLXKr4FQ7y51Ng1bDLFf3MZPmhuFf -1uFxaCaz9RsYyy+Vlw5P57jfw/S3Wrmry74U6Bm1+SBm/JpwIW9PgWd3TQH5FpoZ -nZq2eh2+E3yqnMch/wZWuHNQsS10DnkFHD7Hl/o5F1IPXggVaKtDhZYppdNRHHks -hHGzq3BglrCS6ZTqbgqI2AQTAQIAIgIbAwQLBwMCAxUCAwMWAgECHgECF4AFAkCG -visFCQSfBP4ACgkQ7aIelLVlcW+TGAT/Zl8IGpgoh7dIMzS05U2sh5Jm5U1TKfbG -ipEorhWia9MjV4xKF8ZrS3A9WUEHnFce3TrJFvCOhsnKSYNz8ea156X4VVY5x6Gd -erxPbaAsQ2UQzQJRl6WWiw3AXB2dYY4cZmz8HgFUKHanOwKtrp2LswoLOdkM4dfd -MEuipUeNbMKV3G3Bzpjt8CwS2stWizj7Qm+NChhiAdDKuKXnLAdiz4icBBABAgAG -BQJLDpyfAAoJEPVNitqAgh/qzIAEAJh+yHno9y+kMnekY+jKWjAsVbgMQ/Xh0WUA -OZpl35J50Vmpcj9W/7t9PX1bVzH8eobjpbCZJCM9hKojcgykHghgyewNgOeKz0Yh -ctnLL+ziLxYGKK5GS4br1D5I6PIXhfswGHdQHbOR6Wkcd7U5OSc5D7urOlmunpiG -kAxKZLHyiEYEEBECAAYFAkXqoaMACgkQL5UVCKrmAi6QJQCfZRdrOFmsQcu9kfRz -no3Yt00dgjoAnjNmc3y9jT2mCkDqnv5gZB+eO7IGiEYEEBECAAYFAkr8BJsACgkQ -0bzg4o+hGhW7FACdGGq+YxVGRJCIctJASde7jM7ZKJcAniX3+5asyoApQ94FzFtP -vGueu7TMiEYEEBECAAYFAkr8F3AACgkQcllesYFwS5Mw/gCgq2Z7oV1gvndtXFse -SUjxDBATHqMAoI9JeomZ2yVJ9qaSoDR1OdypQBk+iEYEEBECAAYFAksBK5wACgkQ -GAVRutlaPDU94gCfcYeaOIZKaQnMMAqmi+gYS+IHgNAAnj61qnTSfWjSr5v7xiMQ -320K39VmiEYEEBECAAYFAksMQBEACgkQd92V4upS7PQtkwCfd8GYNDOl9RfKFyLP -p1SKsoLQvpoAn0htAHjLSzWjx5HZnFFfLlxgHfQUiEYEEBECAAYFAksNuHsACgkQ -jndMxqnTo+DHWACcCtnznu/tMcZimZMKNvAHPWiHv7gAn0I0sVIGqetn72lgofXZ -GIUcua4tiEwEExECAAwFAj1esHUFgwFXijYACgkQvLvElXGKklYZnQCeOXIzmEoZ -5yOVNygphYmUwON/S8IAn32gWDyaTMpqyDcJEQeLdjcW7boSiEYEEBECAAYFAksc -ZDsACgkQxxpMZfBZsdEtyACfaH6ahFXGJ0hvWYANMEZw7LQOMWMAn0kskxmAK+dA -Sa/JlwiyypMnwbHhiFYEEBELAAYFAksSngkACgkQ8q2FrB5Cs2cTtQDeNhg6/Tz7 -D10B1vEGbCcv4t6/Zl1I/wz5hLWlcgDfU02rVJhS6pvYJUIZSYyjyb9rm5Jn/RzZ -jKvk5Ij7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNpbW9uLmpv -c2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJJ7efaBQkO+hQrAAoJEO2iHpS1ZXFvyBoE -/RIOI3iCfQRRjY88tC8U2S9n3p0ikdsymN+OSZhIkXTOGBwPtvFZeNcM2eAFuVfc -kyzfKGDUZ9Au8tWlDrgVqRNP9csKj1V5zIXEgvOrhpJAfLEbo5wArKr2Juljhi1S -63BX6OI7X9mizxx22zIN2flFhh7q/buiYphEqsYc2WTw2MBALak41jwx8/MyiFY5 -waHB1Vhq0BldgQ0KjuG+Wu6IRgQQEQIABgUCS3vfUgAKCRByGLy94JqaZ7sVAKCS -5HvZMzgiLVczeA0r+7WPcHfw3ACfcaBnnV23Kk8OKSug62/5bcn9sj6IRgQQEQIA -BgUCSwGcWAAKCRDbJjAkgd2wZT/6AJ9/nViMZ1PIMeLPA4fLfk3OpwkxWgCfeiV8 -0yuDWTIPUAs6wmtHOA3IGSGIRgQQEQIABgUCTEvztgAKCRCDEiCQouiCXgO5AKC9 -mvrnsXUy5mmc1IiOTBx3am29eACfd4CdQOVE5xAxnSZEthT0JfbJ91mIRgQQEQIA -BgUCTE3xSAAKCRBlHfNSPSPyXZfCAKC1GQbBPlpZRhse6B2i7g64I3kvMgCeLI9c -ZU6WXp4ya2KRarPYG8kLl2qIRgQQEQIABgUCTE332gAKCRC/YHCLSEJsfhRNAJ0a -HbD0AqoZZ+AzzSnaXRtLuRHAgQCfc2jJSAybFHZEKxxGXKYeIA7btp2IawQQEQIA -KwUCTb1M2gWDAeKFAB4aaHR0cDovL3d3dy5jYWNlcnQub3JnL2Nwcy5waHAACgkQ -0rsNAWXQ/Vg4VwCeN/a3hgCbFdF3d3QfuG5S1UGqG2wAni6KpWEiyRj6h/jEgyE7 -klLDgZEoiPsEEwECAEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6c2ltb24u -am9zZWZzc29uLm9yZz90eXBlPUNFUlQFAkuD4C8FCRC+MP8ACgkQ7aIelLVlcW82 -sAUAmFXiImKWL+UFxlK8tQ5OBV3kI7sC/fcK7/M5hPsxRbZtZZjhoHzfFEuUwIhz -AYVTxPK+OjD+Vku7zaeKH/XkwwQFyOqLteZlKzOusHRNQtZY/wLpcilKhqmdUOj6 -KuOJSPGJWdcr4wvvPnNUZ4lup/NJB0pRYGJi7EQnrH/UTuFdb9YKAKPP0Vw1tK5c -3IwikTTcGUDOkgvP2fUBjXKdVYkCHAQTAQgABgUCTlyb/gAKCRB/2fzLAAvu7jC1 -D/4obsjit6wrSqjXT9xa0eZSSdVjEy8fq9YjE1+cHtUXzgAz7Ze68JR3ThhCNY72 -ntohBVciIgcunip+S/QNh4QSe8KmbF5apqyYEePUc4R8dNFJLBZkvbmrdWH1/mzh -+Z7srWnmQwmMAQOv7EprW3sn0ojumAEhZyDuRYDOWQi6whUFAG/ZhQDFEyPiKWC6 -D2p8x3ENi7ybH6jHNlOjpcs2SZflDj2wNI794YRASQWQf/x2LDYx8y5NgSKv9xX/ -lWVzF3ZlHai+3iKCBGc+nqeC9CqVBnSuWa7m4A/Mi3/qrcV+gfooEPFBjjZIt2wY -ILTuwpJyYPqkAduJLkkawPME5GOE68b4uocsMXhQrkfttOQGpI4W89GO3U3Wae8y -SD5Rc/XX8D3xIE5WceYOnJhtEifSR2BuuPMBUKJnL9PXAOD/52u1vA8wfsC+5UYy -xODrk1jdRTDdmc1rnSX+K7j3UUbUmVeJAhJUox7fujab6oFngx9EZ5ubIxcRksKV -qjzpGBBmnuylZAecaFVHu4bQXU4iC/XjWm7YY0f6UmnkA+9J0yJKEkMMRJ0CD6t4 -Aw8csvobwlDNntrtldedDRKy1ugZDkbaS+9SWsh4T4QoD3GB3GK4YNB3E6jQ0CVD -16SewE5q3xasY0q3iLieO2EiEmsFuMRt6nikcjFtvKDUnohGBBARAgAGBQJOV8Xz -AAoJEAeRr4zAM2P0xAAAn131punuzMhS+rJyJRJjlsP0Ua/xAJ9HtltEkci0a4zF -iZOkSFQDsVtaNYkCHAQQAQIABgUCTmDICQAKCRBSm6liaQpwsQ79EADYQLR4Okxc -qhEZUMM/c8+Hq2oB+3t1ZVOIS0VEY4yT+c8ukSLiWAc5ve66XoDrbedXi5DAzo2K -58BJGOfHpUnzsjy0JnEF9OighekB9osCcgsbAeaAkAfSAa5iv+K7PQqNh1MMSNa8 -Ovq32lALK+Gk+kgcpWw3DD/18AbdzAP5I2iOd4r607DBYx9+n30U9y33lWn3WMLs -db7WDwwg0AKuyrlgqOw5LfG03aMnoJ56n14bzFqJMbaNXvn5JeHy5o8qVrdf1tH0 -f416tv6IjZOs0uhJFcco6uZt6tOr+wEehiEWmDeGUDhJh5S5F5UJB4sob5b9iW4x -Ja+Q/42+E6lInfxq81KLAya7/kQXe4JHHBqJHcyD8PA+d809/DvoHk/npOojUlQc -n6gpBtnprlRo1rFH4+/b67FnsmCMZLMmKbcdLjh1mtTkWMkYWfNLqIKNIdDL72Pd -I+LsyUCn3QAHxdNWuDIJgQwTdmKqa0agd5CJyz/RsTPc4H9pb942AXzQY6C2cSpW -hR+SEkzR21tLnfEn0xEEypF+r0tM5Lxwr+FHmhkNKiIAx6bPPJ9CapPvWqW+DLNW -ipC9BOQCWOt2dfCLHoXW3pIBTL4NhWYgPuifiFLwgpxvplkGw23LNGmiIojefH94 -KZkg6teYj8qxMEszkgSm1prJDHeol/n5OojeBBMBAgAoBQJPXvdZAhsDBQkUt94J -BgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDtoh6UtWVxbyFCBP9mYvGvl+VT -avRH9HyRmPmSOj0phAzwsqaacQIlCieTJ6+11EGkSpyrVBL94/ZiV86ltAO8dKWz -oDTzNj5kM4Z6nHnol9Hl6mjErNahcmrWPeuqDl/RKx6+B8WXyACy+wsT/l//5LtR -XMhY5jv0o30xithzm82GnNnIOK+drzKe86fY9lXs7hz2wzwilNV1maaQ/BFGq6mQ -t+DdgmZN3PQOiPsEEwECAEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6c2lt -b24uam9zZWZzc29uLm9yZz90eXBlPUNFUlQFAk2TeD4FCRJJ8wYACgkQ7aIelLVl -cW8IxQUAgaY1b6fDpEd+ZQVrxBQL9ufmezAOYbsbgkKFOlt0bV2rl1bVb3OFAQFo -k+QqlKtCRH8vjTSty1gnYzE+ndNZ6iIeT+yBETOxTkilkd7OGQWNvmTKZkHFD6mr -00ykc8WEU1Hlias2JvJMY3v4WIsBNvpBtgAZ93IsJ2MGbAYh3c+AFdB/bhWU2Y1P -y2xQLxDq7Ahk/Pu/NdGQRRIECs5BhokBHAQQAQIABgUCT31CQQAKCRBO8pNOTqpC -Mv5PB/0eoQrUAa7l/EZq5ZjkwoL7qCaiA+LnRvx9/i5c7oBlqCYapf6+/DlTQA5M -tbWEaFwQI54Ss5+p3n3GAauDi8RMcaITYJHblG24fFfX9/T1GeNiyhcyMy1vGblq -cg6LKsmuvuNDX17iR2SPX+ckij7mBOIcLrJ3hzdiLYkTmrnXTPSA8t4TqXSYEwPW -yjc4wnzV27JFKPMo3Ku7gSuiKOuDOqLx5ShKk+ha1gV23nkNErnYNPJXM80zAiXX -vkIKdxEw4fYfoMYVrtI9h2qrVtzDa6vk4u07PgBk2BiMKFwhBBUv8ZQxrc/SS4uX -nlrZP6AmUkP53ona3VByh7osF8hNiQEcBBABAgAGBQJPfUJCAAoJECmvJOqdHA55 -hD8IAKANTXkIuToZGkdnau/6hFV+Q4cEjTGJiVFNFbeG7PE+cA3imclk50RUoppm -W2vS8i/Q03UyajhSmPEXjtjXYbLEiZgerEFlfo6YROCoTC4Z90Tt3zfymTumGdap -Zt8NgwmuDQUgRmcG++0jNOkc/ZBaFbzYUX6UhBjdzIqnt6t3DybFmKj4iZAzA9ND -xBZ0EQINYuwSadBSu8x0B3Mosp3tJelDh16/tcFjhBPYJUe81/wOQE2WrZoFHYP3 -4955xHYsNiHaeiCGQtDobTXZXYi6vRGkT3AkRN56VhAeOntARLeLyZ5pgv/PSXQp -BvE60q0Nbv/PAYwRAKeXIOoLnxGI3gQTAQIAKAIbAwYLCQgHAwIGFQgCCQoLBBYC -AwECHgECF4AFAlGNkMsFCRaZvQYACgkQ7aIelLVlcW9bzQT+JiIMN+6eNWvRdk12 -BCDerLErMP2B5oZThCcYm0M6KaZ+wQeqSvpoKJq29dCl5nsZXHveg2vx0zlwNXfs -yewq7xcuPGY+dV2wEvyJkGwVCPxF5y5t6f+251fX1lqwmWDx5CEKkX4N4K3PgKoD -1L/nufRU4jmLphyef1J5Ve5WMBcLGz7dBeXZmd+zGl2I61nAqUMlls+NMO0nCJBf -0xGrILQiU2ltb24gSm9zZWZzc29uIDxzaW1vbkB5dWJpY28uY29tPojeBBMBAgAo -BQJPXvdAAhsDBQkUt94JBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDtoh6U -tWVxb1GOBQCuKtEwdk6jF0JoR7Yu7EozfPHvxBisJlcdI1aIHny7J3DHo5zuyKCW -ufUQJsZRadmE9nUGNgQwtR1XgMBMl5XDaAt0CpzeVl9P8yRVdj1y6TfO3xLEnYja -+QsrXsDfzCGQctYQdxmbAjowcTI9HH5s8JvH+uAiZah/c1UNxtV2rI9c78EOpinl -31ESrc/JHJygC7izMgzQiZh9djaj13QSiN4EEwECACgFAk9e91kCGwMFCRS33gkG -CwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEO2iHpS1ZXFvvf0E/0KarFv01XMQ -PXzkOF03xsumeNlpI22YzcV4Q7lDd0EFsFatuX94TAi7xrHnLjSr4LS+T4PFFIXX -WDyf1ObLOJip5jJZxwSCtZqmSA9ZtKLAauDtnKqjl4hBzD4dQyLx5lPeKx1oDu6v -Vz+BXTn3JW2Ei5MGJVf7G1Q6+cd/5/7YmvH165OaP87j/DjYvSQvVMJqr7S6coJz -oIdxiHiRy9WIRgQTEQIABgUCQkkBiwAKCRCPw3JfPWjWOhZ/AKC1vya2UjyuDna9 -PkNFT4K3c24N8QCgvshfzbd7Nt7sdV6CF6Kt/ervOYqITAQQEQIADAUCQk2CtQWD -AOAoGgAKCRA7jqQfgvYSQDh8AJ43bDTlK1p/aLXxJ2/1pFrHWFvncACgvVli4V9P -6pVhP9p+H3APtQ+URVSITAQTEQIADAUCQklECgWDABPOSgAKCRBmvnH/Z0hog9kY -AJ0QKz8Gt/kc7Q9Y/Ahh/wZO6vaQ9QCggcgpRYoJ6g1QXYWdTO/Hxve4Lu+ITAQT -EQIADAUCQtiwjQWDAFT6QgAKCRAYWdAfZ3uh7O3xAJ9eOYCw3j628a38DdnRufiL -r6b7WACeKEZkcoccKcGoRhPudvNc9lU60PWITAQTEQIADAUCQtiwsQWDAFT6HgAK -CRCBwvfr4hO2ku7AAJ0WLl6JAMuusYtOGA9Tg7bLGBcO5wCeJarIRVZ+zUecs57t -LYqGCxcMnOeITAQTEQIADAUCQtiw0QWDAFT5/gAKCRBrcOzZXcP0c9ohAKCRa86G -I5EeQDWWG3l/6M0HnEApgACcDQqD8kpmsa8DugYlHddWzvNGz8WJARwEEAECAAYF -Ak99QkEACgkQTvKTTk6qQjJ07wgAkkH/Y7K9ofjNwHa7yPqqv+2TwzhYnKVYnJok -BE3EC37iF24nnVp4qOheLc+kCNh7dz2Bk0K5F1FZ14eRVdsMSUrsZzoNY+qQRlh4 -oO2r3dBqZKYbEVK1nrUG9cz1klCC6iLiiQFM5z05VL/Zz5BxdipwwPWUmkM7DimA -tuUN2x6SCqT1O7vZWIrK6yxLSoPr/e1rQj5o9k08WjEmdaJAMoxcDFeCbSyj7H05 -xiseHzMarcxAxtY95X7UmibZFcGnA6H3McqfKEfVvLW+ZTbMaQAVIfh/07iVM+0M -AOECfiex6vq/fJkGrvNZqqEe9ycxdmu3G6TPQRA9S74m9tCAhIkBHAQQAQIABgUC -T31CQgAKCRApryTqnRwOed8YB/0c55zKTV3DKgygbW0e7sfO0nlCkRCK83PUuvjR -TDezQo4i1Dkp6XNX1ELnENwws4Sj1PBTy/1hOM3EUgX6GoJY7otT7QtSta80Ve/o -2Ho5rW8jeQso+zLRm5r12dfjFKiOYPjRGYfX2COvg1yrnJHe+Htd7Ckukpt9NUse -8ph/eqRRv4bovbdm8PXegexeNddlRwdf3suShGbSBMh44cn6CkYKENk9Q9AxAGnN -FF6QlexOSeUvdCmtvqzZZmc/8BrqVkpV48PftkFcYGEIZ3n9qM1TezV3F+5Lq1qr -oYY9nQFbU05r3MpC5G9uRiAhY9THLaLAEx2FczS8WBmObvOOiQIiBBMBAgAMBQJC -2LDxBYMAVPneAAoJEKrj5s5moURoX3QP/3FXy5r97OFY67kAOAcTXJ5YxZCx5wjH -1MDlBVCDymmMDcTZER7+UlsLB5WHB+9Ka6+7KZFDDvVwh2aoXV3P1HyZvrY3WvTs -Nw/GJuG0eLimgQ3Egeq8Ru05HXtjpCXgNbg+MrW633LbLnwcrpdOKoK1uDjeMRxt -eTWv2osmXYuCilglDUokLB+f4MJVp1EDYWBVyUwZQYh2KJPCnXb4T/vShigzMvCb -7sxSBslSlEvK2xzl+uFP3WJfaU+h7KUAcBDTrzVaJrC97GWq0A+2j0aNu2fDfahI -6oglxtsyE3wbzumS8GGTnBd9UzuTK60EWEgdxAUZ64aRmmB5e3jQ1xQl9+f4o595 -fOB1DCbA2Wj0rRqvE2ki6SC6C9V422wqPWC1bsiRhwua+UPJKHP9zK2C40RT7VbR -l4bvdOOmGzyYJKUIpVw1ZzLaXvP8O8HdU+Jtpznbn9LDVkirsNKFEce/zHTb/rnw -sRbuBK+9niPfK5lI2AvaWA/NpihCj7zKwcr12pWJUFcAcjBVlOZem1vnPFBwe0VS -dHnUgNIB8EZ3uCNTk0k18oqeAuMMnLnqeYkYzD/7XcXlcVyMY8L23pkqhC53vXYr -xNEhzNaAYyeCRqHJOXgojA/FXNadQ3QiRyw7/nI7cm51bPNgHqvVCiYJIAAD66Ku -y0nBW0FawIDniN4EEwECACgCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheABQJR -jZDNBQkWmb0GAAoJEO2iHpS1ZXFvLy4E/Av/tIlQ8ZqM/m75jgx/G2RAowfo8s3W -EgwSxJqzjxI3MkbcBShTCJwGV/i/GbH5tLesNC7sBpCuFiIIjAu+Cax4BgpS8y6/ -34xVMuQue3BpDRwPt5LAn4M7GROBjQFtFJgBkpXlgimkoPxwQ6juvAfvYHugteBG -f6hmmLYDcTyhHhG9Yh4FHLftmi54tVoIozPX5EGUllCgoYSo8n6YeOC5AQ0ET17z -2AEIALQXBO6S1V9kGL3VZGOWuvWrAHuBWGIPT1k567ChdzhFvwuIlqOSmynXwDT6 -n6SxJW9DJFVRmbmUGmvCqpzmVWHsMYRppgpPdWlWlut/pgMNThS7O3DVO6Ekk/Pp -0C4JsBLMb8d+8cFdDZSENoXVN/7pr7/DgYy/X3N9quUEZA1pqQy6oZEj3Yecv6kN -eyAivC7W/lQlD1i+gnxhiygbtAX+4MQPJULaK+8AFWe6xkJ4D7oz5zU/uT1Aqa52 -i+jxbhtUffQcDUrLBOVO8NZHYWau343rMyIrqEGAVkUfGOZ/CclwIH0GPxTy2req -frsQ9MuPpGhZcKuHFTQ2xJPigy8AEQEAAYkCFgQYAQIADwUCT17z2AIbAgUJApMu -AAFbCRDtoh6UtWVxb8CPIAQZAQIAOAUCT17z2DEUgAAAAAAVABNwa2EtYWRkcmVz -c0BnbnVwZy5vcmdzaW1vbkBqb3NlZnNzb24ub3JnAAoJEGDO5xEQXnIuwIoH/24E -ulEAikL/ID1E2yOImMzezk6VE4xnH8GKrmpbHCYB2Q0fczyLU2GyRsfmJqhJEcHR -01se1/VPAyUA20tuN003MY3xrPjZIqNWIegAm/aJyTGY0xeb/ffqICsDJ+EaMyca -72opx7DYrHQod48V2+czUxtIYXdWPxNcTbO5LSWgLPSQ/nWZgMmuyJi9wGNzsA+7 -udzQOHUVB+r++Usl5d+h39YtnddVqBpZE5su8dOPUV/V7wU6HUxW/3PRkE2sSMyp -MVirRzz63LJbQRgfJU+8KkE8UQ8oDO4qefGCpZ8vADsHA/tNNMeSvDLohwTe4Iax -5vOL3LsvkxY2fYpAOJw7fAT+Ka+PZviYKG1vTUIKyJiLVNUqfY8QDbaWmPZH9880 -6d2wOUtCxEHUHD3OdMTQzdclNwnJ7wTOl1HZKUsvkg1fEdta3PAD53rZcRtM5D0n -RqM2eGKJtnP7xx40uy/AZ2RqToJu19UbkOA02rQ2fCCo5gxtLtAcqPK8bGhtLwqg -SScESEiySycbUOI4H/cSEMq0CJWUbYmlLB4gDfOAzz2h+LkBDQRPXvQwAQgAuWU5 -f4AW7Ez0dqVInRJ26BIUNvAIgxt1NQgTpylY3ngt/UifsxqDVd6p0QWtY3cIgPs+ -G+Ha1H7DBUi5Qj6ImbPGZu0Al2aaRnR2s8vP0K5NX0P5W9MuBFZmHutggq6i/tLi -kO1xWXchAiITIl3KH5iRcnfpqNK5w6cET8BBUkZ2aBQbBtj39W1TOy1ux4Qr+dil -bExTdxkEEVgy1A+sNnsjg4/EuKplVJVIYYyiWJ9IQcMFLHXThInAAcjmVFnvyBgo -XH33FVLKRN0imNuANDkATWssT6v0CrUXQbpy1D7zlEfP7H2ElHnheoImtCv3X1Wr -OKSJOhgvn6xcJGPD2QARAQABiMUEGAECAA8FAk9e9DACGwwFCQKTLgAACgkQ7aIe -lLVlcW8BogT7Bc3MVWYMELSrQo3lDfLYP7HAA32yedvQKd4ItPu6qk5zrEWhiukQ -Se1xnIsFdK34NQVHrTG7JVCfOrSWsvRReVJbGJIZRW6jArcwht13kWQjgIuj14Wu -UMxcWaWmZdTZwcUnFrW7hxGX56IVKxOtFLRTFF4K/cNqqNO4YYrSvidq8Qxec91b -ZxCW+Slq+e+GDuXJ3RcYyc517HugE34v/bkBDQRPXvYYAQgAu3/eK8n99nrP3Dl5 -vsyhWtc28i3JMw1PxIgXO3495nGM2qr9xOIaHSCiZmVrOLYgb5KovFZi5k+0vzR+ -Ql965AEtnHd7QLAlIFS2ECugH18DsaQB/h12NuAC2H0AqZncKWsNsnmAGfdEii/r -JV++zyV/YStI3hISb/4G9UpZW1URjvSSJxUNIBfPZ7EjVcFG3J4VMFlM1PjYtBeM -2u48o1cE+AzTk+fadabhYRAaUjFmofIEbkNJ0EF4zM71dhKSq4ruxpVuizFiZAth -H+geu64QmjBa69wQoxpq6nBEEIBRfIYwf7P+PJnK6Zryq1frOr6zxIjni9T8xGQ9 -MsSwowARAQABiMUEGAECAA8FAk9e9hgCGyAFCQKTLgAACgkQ7aIelLVlcW9YDAT9 -H4Pmntj0ehHb34NEgiBoIIIK1WC+sXbiqitvcjumECheKqxYBIRDMjmlkK9szdqY -kjp+zx1CqcavbPR+GeEKGiiOnGmMKne5+TRR4yqhz6KZF186EY0BMA1bVLYjI7oF -M7BO5twIM7YcA5PDQpLf0Q1mL0vqL1p1F6gKExP3BUjjIswQxhJbUOehSPA7rTjQ -YajFBD03pTIfXTNMlmaiPbirBDzVB3sBBQDY9NqhPxE2QUOVftQI4H29pEXGtf50 -3uXpA747QyDt1V2Mi0SdppiQn6vgtd5wjjseiCxQYTFF0NgZPQOrtpnwaQLhQo9d -zerYpZDeJvfCPeqcIabchf8jbj3J1gsDNDJaoxbT3AsHm/GE+LjKN63gVMZaa1hS -UbMNvv7pVmKVhFO3LS+EUXhxVeU7ZH6+A/EUy9RzujxYYOdDeLJYCLORAAYpiMUE -GAECAA8CGwwFAlGNkNUFCRaZvNgACgkQ7aIelLVlcW9eoAUAmoqau2N+23ZC77S+ -bMgp9fmijyP49pmrwaVIZ5JyLhuGjQ4rz4GD7yoVjKV/8aOBcA5WnuhhJ18okFI+ -Vy8L6mMKs0TQXi3rjxoza61oSPMimWqToj8c9lhGHxihx5hdMqKJnMEv8SnxXx01 -fqE+TCKmSTOzHpWrO2TPnz9qzZOv4BaDRKd+AKc8zZkSX14v+TFiB4VkSBVxHDvD -G4hDH5kCDQRKZ+4uARAAodMBXtged1JSMVjkN8Kyt0yMh6Zs/c8jApHSD+8dW++G -f0sWQOzfLjpOQUIdxiwZ2E4SZdzEljgIKW6LsiORIfX/smduwKAZEHHfCXh3JGy7 -1wsRvBjzp9XKkgVLLrPurbhvOiyN67nSUirBWdrh9GpkXyUgQZ8m66LMuXU5+eRi -CdwW6lnWkz+7jRVkTM4ugwOPZvPNISdqrp5LgDl/6vJLyqX0biQnZnvZF2XNZfPB -ahlBJXQlWKRvko3QhT/QpmSUWIRelLkR0mV8iU8NVjJqKe4GI9hd0E7KHZ39XvXg -47v8lqc5jweFgAra6zu8Mz5bn7HpRTSKx8MercpL835WmE4Nm65/aKZmUwDO3mF4 -QZPABLzlwoNauFF4khrRaaMAVFbaDhkB5UgttfDp0MmjBLAuwmoG9REKmTW1573D -FczCHF3ChxUgEK5OfiHzU0DqJPBSFl1pvE2FQ6lSKVhCg4B49D8HD1raZIY5YCD9 -NWubr6779MNU6tjXIy6acmMp6BLxGxlqI5LuJcglFnVgC/Z+YdyApcgQqnR/DjLX -S91omxiJZGznFl37EfhVEQr+XrMDEQJWSrsy3+mMg86WVVsjqHvkHPkuA5fCflnm -Oz6rjScBnbS5JUotON+lWCrqeJIKE94gB2FTgbdCtN5w7YJ7JtlMYhEfntfdGFcA -EQEAAbQZRGFpa2kgVWVubyA8dWVub0BnbnUub3JnPokCVQQTAQIAPwIbAwYLCQgH -AwIGFQgCCQoLBBYCAwECHgECF4AWIQRGIiXDtG80h5/ISWzWBYSO1+aYcQUCW6sa -uwUJGqkuDQAKCRDWBYSO1+aYcR8fD/wIQqfDWCjn+MoD7kAXwV/Zp6/jSL3UCgyl -pWB3gOuL50bVEelwSbXtvYmyoAnjUSjGGZVva5VsdB7xFwYjoVknkV0WflzVzAOf -ypbzFzyL6OSYgYYKkbipw286PEPjt9XCH4KdnyDjO9wQKAdK4LvM6JdnCSosng4I -4+MU7hdJUCeqebwqvWcqKsZQZYwgAF+3MIk0lHmEvdqepudH2gWZKbWMORX7Czf8 -eWoDjMKBtQ9nNPbOJpdGU8BSt5MWfaKiFIkci4j00DSJXoqoSlEwW/7mVQYCS0Yx -eQ4d3Q02BbTZwHGoLK8kkbZvbGhMG7OwuhdeQk/0/jIppLoFdMYXY5fomImNZ6aI -PKRMQD/LmqdrAep9+jbz1rhZ2wvDmeyXXUxhHWKS73dYxl6aAFpYg21w7GRbnhFL -yCloRdgaz2OA4nZ4oLJjVg1KuwaWdzbE5bIebIhz3bVRcxtJHQrMOKPPO9tIhkC5 -K0EvtihXvRWtnB+bUgVnTYuqKx13kYi/nTDi04SiaSuY6kkwaeVG42h2RV+4qgZM -Xtit1Q60U/D0jpT8VdLwTLgMY4VYgmwmLb734W6iyvv2SgnD2p7AQ/rW+y+Kjz0Z -izCp8SUyVDJ/1bYWmus4MxtoPGhGjdAZX0yGNszacfER9oBvvbF9NGqLJP2QSYQl -Ti0/QVyG4rQeRGFpa2kgVWVubyA8dWVub0B1bml4dXNlci5vcmc+iQJUBBMBAgA+ -AhsDAh4BAheABQsJCAcDBRUKCQgLBRYCAwEAFiEERiIlw7RvNIefyEls1gWEjtfm -mHEFAlurGrsFCRqpLg0ACgkQ1gWEjtfmmHHupg/9HT+gLA2MzS2t4kQvtTUIBo8P -xUw6vOUW9zgrHmkmrlUugxOmXWKSDKT8sBs2V5Z2DEIS0AZ/g1sj2fHJXomHYTAZ -LAt/8dUqHnHqRbBEyqlJjk1yAmxB4AiiMlPS6LccA3A3G+pwgcKw+UKNJsqJ2ASS -X88aJImP9SI/84nlnQOoqDuGt3b1eBW4EwgpwVBfKyId/L4371RBse1vqqOSuJFk -BnglvpAuvAjMyoo4g2PY00q3EfUBqizEtD6lyyZEDc5A88qTmm1ATvT5H46IZsVt -+QvhS6KCOEwB/2qammIyfGr2CS3+Uu14KlMVlnYV4v2ZIq7143SN7DB5VVxl2CbS -9Wa5viauuRyIkaXwt7d1kbexnUpiKeTqBJthjxskJ9ijfr4mpDH0qbIBAotXxjCB -AaUfLL/q8dl2w9Gy6CZHR1tkRfGvRUT8IjboR3ry7ZnG2xxV26tZ42GwWcmljwOW -NqHxBieQ5tGnsPIQxSoP1wMLsmWaB2rx970gg/FU18OAe5vqCHXl0Dtd1FYHYV3W -u1JDTEz+yjet8wOuywnblFORsDqAs3Lng07U/PbGmy4vcwuVUXTEV0Ih/ssP3m+K -R9xdjpGJonCeINLpubVQ6RpHOAb+jkURFLsRr1yjCzGjHKnJsMd58fRCfvgnoHgG -2AQHdyB+IkeMWNLNNx65Ag0ES2tPvAEQAKNGc0pemIP+1tVKIXduJxml/gLUkUgO -+8kdBkS4rflKp4B7+1SkwDBsF+BbmwTFSgHcLLWUQrYGLWQ7sZT62R0IeGLqOtwt -iIyDtBdq9hn95tgdV+FVja8aE4lXPiqbT9a9BhPc6klKqsPWNP4BtGkPEWT2HYIE -/DWugGuHxOpgrIg4E9KzAvA/TkgqT2HtLBCeX+y1dFyEsxVoysovfdXZullIjg21 -iElAbNfs8dWy/glgEJcJ4VGEAnAsvJJ8YzcNd0AKGw6O0ahv+xbzgq/lgzrmwfGa -GK3g0LmjkjFVCe29ho6xNp8X0o4Lx6Ciy0+wBHFQ02KEZi8nlYvw1LbBBUxayJEw -r79Cwro8QxefLir36Uw8YFmm4aJxRfrxEggnKcBodq12isDSEVINAhXFuENNB2sG -ea19LHfdh30uVpb6gXPeg22xQ/nslAy+fv9FgxKF5Gq2WFI44dBX8N05GjYHW6F3 -YOW5k7OxXPzyj/Z5n12E7wCs2FBGlaBzHt2r6QjsXJQfQh2vDb2oPchP8+cQ5MXz -iuiXQcRqA/WjNUHfaSskgNFCV5OZ1OiC1Pr0Vgsecr19iuTWbc9xzdNZv/U8Jxxw -3QPZEkKXaSvLnAl3HqDZuLvCDi3ClEmyGLmNEQ8kAAY3LkwoD6iifoPqBvDA0/fG -7P//0FTQBQNhABEBAAGJAh8EGAECAAkFAktrT7wCGwwACgkQ1gWEjtfmmHEwrBAA -n6OC3rA4wIvHXOxGLenEZBCrsWZUk0lhnXYkSna4sLWH0TTxX5pBdl7uluiciVe/ -N4iE6XpHVKbP8qbKiXL0L1MiG0yGRmuzGhyuJoszsjEh8K7LSKcW+/1sSiAII1XE -WmNXUM+xwxVREpCCNs1Bwp7PIo5SrjsgKrx43nCZrvaaXFFVHFRMeLndKiR9v1i6 -uFUetxbH8RIxHvMdILCO19Dr1zvv5ohMnChxVrGVRVBgIJq8I4HWBgOOd/kXXuD7 -MYYLDt03y+DgHTjyjKDxGJKcCY3aW3iJ9+o8BVNTyuLENEaSCnFiIyQYJ1qofBK7 -6a4JrzkAz2v1YrpYi5FASOHY82xOT6W1qZMt8VQLSw6kb7wt60PWEjcFZKl+BPmd -ydRFyeZqeyJVPQbLve89d/5MfCdji8BjmjRf3ezazJ8NftlGuEuDQwEq7P94gFEs -MVrCSOl77eYNgxWjVLUOmDti3wi+UMVCVZGUhK6iCAzjzolA1+N1LRmISTWYiNrj -DxFgMnYWTqFyhHvnh+Fm1QuBfMTQREZpN+kWUa7iNpabJaKR1rP6h/kBHT2YuXoq -EIO6onUt+miSB15Qg7DF7/rvFPnDIZYr3t+MkaPlmjpXEUV/psdnytVWFcGxHdY0 -NA+R/e4eeyThgRet5M+0+9Duynj/ACpfWq/dxXbWRfY= -=Q7yu +mQINBFfqNpcBEACljFxfMXOIbNpyPk5erP0E4sNV/IBiQs7bhKS4FVKny/G5kMfd +bdRe26X1QTf8Jq8V3Fg2Qk55WTRSfNRf+QMjK9XfAgQrhWgRzceSiJdDKPesJRZW +LdgDSI7NnbjO9HzYED8dDYFfVGa77l7Vu4R+xvm0BPNzbxIwYPzgteiWiJkSvSFd +xTLL+Fex+UK1MHvXQJDfxJ2ipCOgeI03dgwauCT3yvtBZhI/9PRb/DfRD4FJv00H +j8znnTEYTjfal+703Mx7LJZqg3eQ0l2woGGporiNHt18OPItO0egc+YdP4Jujys0 +u3n3yCqKWSYrReP68uZtv68n/aYr9JKHmgvsoGEwC51pqpUtj3hVG8X6r5Zc9J1J +NsBrB1SHgSgJDHlsr5bqhTy3ss6LnsTZffbPOnzIbzCglG2DTdQr8DCbVwpmm2r4 +jdbGzK1mvFHVuIeUTcbOKLf/TLmTrU0yTbUWxEl4sgfFU0LgWQIfnlE5LkmtgAuD +ujNVBJ3Pmuac0VcvfTBd9+SmrUuNkudExyLIWbwnoY2TS/wR158ndQHKn/VQSWVy +WC7r8N8JR9qmJdhhku30eleIoveHafxBP5Dmcs8eQyUjXenr2C8ICbBUL5BhqrAs +vJsl3w4yuWPoMeZMQYp4pAIoJDnJ8GAZQJVwbNpsZhtKogjtqKDJfP4NKwARAQAB +tCdBbGV4YW5kZXIgU29zZWRraW4gPG1vbmtAdW5ib2lsZWQuaW5mbz6JAjcEEwEI +ACECGwMCHgECF4AFAlfqN3QFCwkIBwMFFQoJCAsFFgIDAQAACgkQsOndILKfFDJ+ +UA//Wji7pC+8GoADhIrx4OAJoON8qW2MOfnaPHgl/EFaV9L/N2fPyo8NNdeISHYk +qmK2Ub5uZGdKeA6o8f6x8VC9TPtzOJ1R8X5OW3SM7dD9m3n86IaHe+CY6t4Hgjlw +5s0ZCZP8xrmyLo19NBTT6iS93ePp9E2zCw0/bpMX6buBJ3bv9LX9aQYt74NSSr59 +heMI2fioKD0q2EBQsmRlaII/auiT+bbEIeYCrQAtXINMT8gpFsMSpzTiqwj9eoY9 +q8t0eYbw6fWDyx6TtC8kqRGA3b0FTN1LooFh9kZIsn0osZJPsE96DIUte8NIzFTH +gqslHGDK0xybMjlJhMDq7pF0DW3kBjonDXtiA/gFr/I89NutPElvuozg04DVz/Fz +6Pf4DptaMtRscwRKWV1xlp7ez1wWOY58Nb2OfRZyZXZ7hbW7aRMXS6bWR9XySuKI +copPREnyJUt+kmmcnT/uGCzJQTg7wEfUn4+GjTNV9MTVMGnUXBFklDeWz1fd/lmm +f8pnLuCOx5BI/HqvumtrtTmBK//RjWoNGs2+1Qu3X7RKhsCbOnziKqfcZF383Jsn +PmMHnbp+bXpYgTcwugQHbKP5P7gBDlVrU0cupFHmhdr9qcjPMWuahR7x1FiV78+E +i8cSPNGszMsWuZdfp5BkfUaV7n0psIUm6zRt9ITQ8vTGYqzRwyvDKQEQAAEBAAAA +AAAAAAAAAAAA/9j/4AAQSkZJRgABAQIAXgBeAAD/2wBDAAMCAgICAgMCAgIDAwMD +BAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8Q +EBD/wAALCACAAIABAREA/8QAHAABAAIDAQEBAAAAAAAAAAAAAAcJAQUGAwgC/8QA +MhAAAQMBBQUHBAIDAAAAAAAAAAECAwYEBQkRMTQ1cXKBBwgSISJBYRMVI6EkURRi +kf/aAAgBAQAAPwCqoAAHtZ7JNaXeGNqqbmz0rapWoqtUxaKVtUTVVGqae0WSazOV +sjFQ8QAAAAD2slndaZmxtTVSSaWpdr2sVY81XL2JGu6jkdGi/S/QvGjkbGv4vb+i +OappdrGvVI8lT4I2tdndZpnRu9lPEAAAAG9paztltaKqe5O1HXcxyM9Kex9f92nu +3O7YJpXSz/QssCep2RjvLd293Y9PE6Kf69lnT0uy8z5ArKwRtR/pT3IJqmBsVrXJ +Pc0YAAAAOjpBV/yk4k/UUq5R/JZ5h77hvFf9kMYhSJ9iu7mUrBrTR5AVWp/KVfk5 +4AAAAHR0jtTeJP1FaM6FnmHtuG8eZDGIVuK7uZSsOtU8nkA1dtS8TnQAAAAdHSO1 +N4k/UXozoWeYe24bx5kMYhW4ru5lKw620f1ICq7ancTnAAAAAdHSO1JxQn6i9I+h +Z5h7bhvHmQxiFbiu7mUrDrXR/UgKrtqdxOcAAAAB0dIbUnFCfqL0jLPMPbcN48yG +MQrcV3cylYlaaP6kA1dtTuJzgAAAAOjpDak4oT9RekZZ5h7bhvHmQxiFbiu7mUrD +rXR/UgKrtqdxOcAAAAB0dI7UnFCfqL0j6FnmHtuG8eZDGIVuK7uZSsOtdJCAqu2p +3E5wAAAAHR0jtTeJP1F6M6FnmHtuG8eZDGIVuK7uZSsOtdJCAqu2p3E5wAAAAHRU +jtScSfqLXJGfGRZ7h7bhvHmQxiFbiu7mUrDrVc0k6kBVdtTuJzgAAAAOhpJf5ScS +faL0jLPsPZzfsV4tzTPxIMQlzfsl3NzTPxL5FYlaZZP6kA1emVqVfk5wAAAAG7pi +0NhtaeJcvMnWjryjajF8SH1R2Bd4u9eyG0PlsKNlgmT1xqo7fu8Xe3a/aGS25Eig +hT0Rop8q1lebHI/1f2QXU1qSa1qiLn5mlAAAAB6Wed1nlSRq6EhUxVSRo1rpMlT5 +JDu+skaxPy/szeFZI6Nfy/sjyqKpSRrkbJmqkeWiZ08qyOXVTzAAAAAP3FPJC7xM +cqGzgqK2Qpl41Mz1HbJky8a/9NZNPLM7xSOVTzAAB//ZiQI3BBMBCAAhAhsDAh4B +AheABQJX6jd0BQsJCAcDBRUKCQgLBRYCAwEAAAoJELDp3SCynxQyKUUP/AmGMljC +QNoVeXeyEAfHmoKyx+aw3CNDhvE5ups4O6CVq3JaF6O9q2t/x5v0pa6mniyHzwKp +/scm+aC/YbSaznffQpHw2r63TRsM1v/wdAFsMh9q2SXfRHlBHelW7zHLsVncRTSY +H9jXuc9rCb0B6x+JNB9L7TOSURKKgZv2nkkeEauq4hYIyYuXhJhV93r29ARxIKGE +Go+xFQ5QoEptFt4CyHrnbL504kr6113ZI/+gGPgX05rsf71ayD9GeHul8LT3yTJr +hXO3DbvigCcHmVR3Cl3h4c4KxRdJylo7cXRXCSgbx296cXzSTS4jH17YrLqvSDN9 +rDSBEcIAAdGobBKUcypSvB8qv26rLMQuuLMSpC6p6UN1zUL4U56dMzYe5Brq8MTw +YffZYUWcfIYLVV8yJB7yeu4sNyZmmCirPfi4XVKW6CAfB9hqWp9yBD0beIU58oTo +MyWXA6eUF3H2E3KRF+1rg2merUofycfoeE/3QbKf06puXRqLx88OOTnYClouO9Yd +ITfMpR44txvFQZO63L3yYV92RPIU3XGzpvCik3JqZD3rjjExWQdej0hJAy2YXwxX +KLYSac0FPQDrAE84fVvup6nfrD1+G7ZmeQFkbytNEA0Re+J7WTqQZW/c0h/lt7SX +5TRSHHVyD9Barbxy+3QRYBZDRGRO6Tfg/v/kuQINBFfqN3kBEAC+xOw1poHNWHVF +d+S1NSQmKrvC0nG8j7Z4pTGI4GDkS3Ng6lyyAVriHT+4UPJZEKLEJp/qIxHyBAac +G1PquX7MsSt9Z0Xl8UEIAxsKG43RrGcpI3+g49SXfctiw7AaWZ76RVYaqWAL925s +mhqSIfvcucci0bAk5aFS9Ufich7jq6JlZZUdufsxcL6BYY36tu1SvUI0xQ2M6oXa +93tLMdSym9A2ogx3PD09iwY5jQ+yjBlCjow8IhWOlMXdXkwemPhZJMHzGm5NSUYB +fqxgPab8tLIyXFpG071vHqwSYYVjTeFe67UhzDEXcxb6s4YFnju6902qyo7O6UAj +PLfq50+2BZtZ9Kxy31uxAlelgb1spNTe2tAuEOXpCfn5bOFPiMttGzpobN70cTQN +F2hnafzR9ZXYuShMWG06UKTUNFyuo9SsBPk3TNuL+7LuqlhoJllCSlhXwprPv88A +FRsqU12u6w4vV//lG2/Jyy5EG3+FuPzq1wVn35GxvuCdhA0cRdVHh6x7uTaZxT/C +e7FmCleOVYd6SuZXts2GwzxfOBnugWNsImL71pzxKoO6Sz2X2kUjCZKsU0C0sJx3 +/Lwb1VxwJqdFqWMDmARPqJxXGV9/7fHdrohCroRJTX8XQtTuFKJWgQRKcxQvYTdS +F1iKU4ES6PhuJHrfBZU7oMHvpdRzfQARAQABiQQ+BBgBCAAJBQJX6jd5AhsCAikJ +ELDp3SCynxQywV0gBBkBCAAGBQJX6jd5AAoJEEEnSKQK/ML7B/4QAJUp81E8zlPs +e/z+Hz8ZfTO3S1nDiCmmhq4zRMc/W1Qhlxpx2Ud3+IEZf26MERYxovvr4Z5Qs9h4 +9fJRUVxtx45UjsHcyWEmumTKnQNgFuNeu5CbUDRF6X1f/wuZl4X3t1OvDt9/mnL6 +lOXBuP/kDb7p/NY/EkJTsmCZbEMFultRB9sMX7r6Ynd0jZ+cg2exhYX2YaMQcMyE +1kYlon3MvK98bnwFaxWSsADL1qxuS0SQ+qYMlv9aDLFlCB9FPkA9L4AaGkQgFv4K +i0X9vN+p+z3mWi7qohzEIGDlLONSifY8uq2Ihy7mbGTyeJbhWxblMpScYylH541b +gKAYZvV6LssCnJBN6F1H9kmudODEJaPqTb7X+CyvEQC6ZE3vI6KuaJRJ1TTSKvlA +cStGRBukmgp3+MLWHC+LlFYC4/0GJvX6G94GpFZXxFWcdkpwqqwdjQLTDkVKNYjp +v/xMAJ2hT+F2qjxEC2WhJyheOeJ9OcRb7dtVBoDPNc9qvQ6wGwKJa6X92PC7QuNk +0EzJRpslZsVM4KslXA3PD449FT/vbcKfM2t9Wz17PPP6NxPrWCDeOqcWFfX1sXZ7 +PnjbqVZvGXmfrG5YZEBm9ssjjzO0hLD+DCsyEzx4XgcUs54mKNA+o61+AJQ82uxo +8OGLDsbrNjZYcwbFsZk6WGrdUElvHBEImeQQAJ3id9IlkhVf+Ma1tH2TA6GdyEAS +Rb2fALHCC6MnG+Q9KqAwtvC0aG8oy6eE45TXQlZZPalnom9hPNFE8nCXyydfA2W/ +0cpr9dSVujtIa6WIDJrQndQrG0Yl337I6PzUHOdCOVkXXzKqMRE/VzJ7Ca4YhQSp +TU4NUTlJVqNlJI6l70SdPRMQ1ndIlyh3C2Dyt3VXimpR5zHlykbTWzOiEO6pcnU1 +u+hEhhdvHDLH1vskrdi6gOFHKUauYLI/mflJvQn7nJ9w4vfcI9UrtIuVp1OWikJx +p6J4ggxKox1RIeksqq86tG3cLPv0Dvvsv0wc0PXJ/Yyb8hCWKH/V3oluU1InbOcP +uF+mjVF5ibNi0bflreboVm3hBPXmAYtDRAL1rizgumpj3M/Fpb2OlA+zKh2iIKT+ +PZmTAcshrnzRXcqHp3GMj4vBeVn/1P5D8LcvkdqznIGKO0J16TKuwPpdV8SfmCD7 +IWQNzpMpgIaGyujTID0n4E4ZEPYcPFVsfeeMKI/nAO/EiA5As3TotAsNf5Cr74xG +cl7h7SLUJAD6jDtE5IZQQ9fuTemqjElxDaLZIIrPU+ihX+KL+I3U99T8grcYAkQ7 +aS2lAz0A8o//+29zTQIBtqueVz0bbbJYDFbdHkk3tJ95f6WoL4yiTVxLtYYJA444 +L4HQR6VNqPplxvvBuQINBFfqNpcBEADEBCMDOLaTNedadfrICSKNNCTSPmtpZvv7 +ZCmuqv4jhluMQWJAWh3DsSLx4W2xjktJK8VZ7xZeXQCG+Z+L7/1M8XCAS0tZM6qC +4KMlA3RWQ5+OEQNYu4AUehrcjNXJKhmEOAgND8tjtxGD5HKLQBoid6xjHRzF1iS3 +3dfW0+1xXirsqJMhZlYGxaUFkXeoeCd4h+rqUE5uN39B8qFoUaV5eLhSEl9zCdWP +TWHp0IpZRI09Gvr+xt1DO2ycNieCGRr6l1QCZWqmP4KlvSmlS7M7vy1bSUibJtFQ +Y6iaGK9BvDb9NxhyDBCZ1SLv4h5N3/wf0yx9/Y/27ni8VuFS3VeU2TgpbI6LZe70 +K+J1eo1yDrCl0A+2EiN5ne1FPcecW303lw+WFpDBXtK4bH15qIyTY6PZ0E+9XgzX +yC7B8D3yLI0ni0GaaIUtqB9oO41oyDK3lxADS05G3l3wBSgXc6thD/B2JOhrognt +E7ZZpKUVpg4cUnMxQMs1JTMptUg5Hs2jtAg68pglHieOccGAgrkB5A27m5wHFsUM +6qea7QTvmkc6tWfyXk464c38SI5IbNFN1KH+JV+1SBkLe+P5eciV6fVEFTrcNGQW +f3uSeVAa2YmCLrIgmFYdiT0u8MatQB20+Csivjzjg7cTlk1MNbRhOZa2R+qeZ+AR +UFR0xaOPWwARAQABiQIfBBgBCAAJBQJX6jaXAhsMAAoJELDp3SCynxQy0eUP/RLp +SjdHZzZxJ0gorRbNkUZ+hJL4eCZC+V+JGBvTgLd58lN8ah/vqQafn3vUXwB43tW/ +if/Oz9ZRrLhfPtfROEQjxroo4xNRY9PPrEO1yQ5O6i81CcZGRKpZ391Q2fPl2+lW +T4VKXpn+XbF33FXAox9Rdfc/H5bXF+EiT00EnuxKWv6yyC48lNgKGBmSdhREiXTz +zRzGxBxN3GWQV+2rIrHMy3Bp2DgKb2kHLhA2sLg8oCoszhWcW1+le34ioqNBYt/H +LvM+nVzxgrD6RMQg0aiFQJvIw68Z48g5oD44xIjJT6YWXLbZA0XaXLn+m1CR6xqx +SeXsXSCnvbF5KQs6MsxKFs07T2GDEMuHJO35IfEfg1JWWgzqJfGe8bKBeQ2UwFaZ +rYlmOYpq4VIdWwgDHlzuXynb/7MLe6NyxJPun57Ex7NsS//sfrR5nPunk43e0W0l +qmT50WJxRhBHhxXmkQ0fH6tzra8GJxo99+MJzaSfENvdRz39BQXM56nv0/1wlRdf +qJJcqYqVav/gKvKaB5eH3dXHKGZK5YSiQbtvqKBOwsOhHxtvsE18lu5LwiYdnTaI +0DmUcl2o4iC0+cpSFSesGSGd2XIIid0E4yre89Cf4kfuCQhvUkBrgYwU3mFM/Mhg +H9hH7MKAmRVfm+pwNOk3owA/vBcSuRRLeeVGDGeq +=Oa/5 +-----END PGP PUBLIC KEY BLOCK----- +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBEpn7i4BEACh0wFe2B53UlIxWOQ3wrK3TIyHpmz9zyMCkdIP7x1b74Z/SxZA +7N8uOk5BQh3GLBnYThJl3MSWOAgpbouyI5Eh9f+yZ27AoBkQcd8JeHckbLvXCxG8 +GPOn1cqSBUsus+6tuG86LI3rudJSKsFZ2uH0amRfJSBBnybrosy5dTn55GIJ3Bbq +WdaTP7uNFWRMzi6DA49m880hJ2qunkuAOX/q8kvKpfRuJCdme9kXZc1l88FqGUEl +dCVYpG+SjdCFP9CmZJRYhF6UuRHSZXyJTw1WMmop7gYj2F3QTsodnf1e9eDju/yW +pzmPB4WACtrrO7wzPlufselFNIrHwx6tykvzflaYTg2brn9opmZTAM7eYXhBk8AE +vOXCg1q4UXiSGtFpowBUVtoOGQHlSC218OnQyaMEsC7Cagb1EQqZNbXnvcMVzMIc +XcKHFSAQrk5+IfNTQOok8FIWXWm8TYVDqVIpWEKDgHj0PwcPWtpkhjlgIP01a5uv +rvv0w1Tq2NcjLppyYynoEvEbGWojku4lyCUWdWAL9n5h3IClyBCqdH8OMtdL3Wib +GIlkbOcWXfsR+FURCv5eswMRAlZKuzLf6YyDzpZVWyOoe+Qc+S4Dl8J+WeY7PquN +JwGdtLklSi0436VYKup4kgoT3iAHYVOBt0K03nDtgnsm2UxiER+e190YVwARAQAB +tBlEYWlraSBVZW5vIDx1ZW5vQGdudS5vcmc+iQJVBBMBAgA/AhsDBgsJCAcDAgYV +CAIJCgsEFgIDAQIeAQIXgBYhBEYiJcO0bzSHn8hJbNYFhI7X5phxBQJbqxq7BQka +qS4NAAoJENYFhI7X5phxHx8P/AhCp8NYKOf4ygPuQBfBX9mnr+NIvdQKDKWlYHeA +64vnRtUR6XBJte29ibKgCeNRKMYZlW9rlWx0HvEXBiOhWSeRXRZ+XNXMA5/KlvMX +PIvo5JiBhgqRuKnDbzo8Q+O31cIfgp2fIOM73BAoB0rgu8zol2cJKiyeDgjj4xTu +F0lQJ6p5vCq9ZyoqxlBljCAAX7cwiTSUeYS92p6m50faBZkptYw5FfsLN/x5agOM +woG1D2c09s4ml0ZTwFK3kxZ9oqIUiRyLiPTQNIleiqhKUTBb/uZVBgJLRjF5Dh3d +DTYFtNnAcagsrySRtm9saEwbs7C6F15CT/T+MimkugV0xhdjl+iYiY1npog8pExA +P8uap2sB6n36NvPWuFnbC8OZ7JddTGEdYpLvd1jGXpoAWliDbXDsZFueEUvIKWhF +2BrPY4DidnigsmNWDUq7BpZ3NsTlsh5siHPdtVFzG0kdCsw4o88720iGQLkrQS+2 +KFe9Fa2cH5tSBWdNi6orHXeRiL+dMOLThKJpK5jqSTBp5UbjaHZFX7iqBkxe2K3V +DrRT8PSOlPxV0vBMuAxjhViCbCYtvvfhbqLK+/ZKCcPansBD+tb7L4qPPRmLMKnx +JTJUMn/Vthaa6zgzG2g8aEaN0BlfTIY2zNpx8RH2gG+9sX00aosk/ZBJhCVOLT9B +XIbiiQIcBBABAgAGBQJSUAfxAAoJECxkZK8qjkwCXMQP/0NRq8TltefmRgn7CwnO +v+4pvKnAH89Tv4Qld7qobmsEyiNp768KtIqddhCaed1xji++KkHfO/vWWiSUxPvH +6W46Pt1KFeJBPfKbpMkWuZFTgyglpZAVbnvWLXwqCGQXOMXotGffnUwpn3VkcWgZ +qABRC1F7Tef0Zp/gir2o+SpW2hwMFmi3l1bZ0yE6a03gKtHPOi7I+yjAdlvqzqj/ +rzlwOC0x38rWusH+HkigxmytC5gdi7O7be0mzjXC+JB8T7QBQ9F7vWL03mYnzWbN +UIu79UYf0vVBQCMhNLI7vp48qvQsghefpbXATL3rtCcWxWUu6/1+WgocMEok+Jfv +SnQNBUvaBsDMYWbeiuZ85D8a7r35ivLSEkDsmyjnqErCbHrSdiTEs/QFsEGmxt1r +OYCE6VcSf51NaGKY0BjT1HdzvoNrjmwKXDNNjcdgQH5STyxlRJkp2kLdtcIEKBSt +bAzH82mIV7/0YNcc4FS+1LJyEn8sitjtVdQBniNSrx7YuoDviUiwgBpCCoM2am3p +vz6u2Uc/APUag9QxQWE+Wcnc0F7ei7sCtb1DFyGxAi5fMz5YAWOnLoFEXhflMLbw +zR9EcB0z77xnd9A3kWQ5Rm20WaXXyMYS6rfjkMgHkbuqCM6TcbrJ+3x2ThsVJ7Eb +gFAVAFrbukm59OgI/e+Rg6BjiQEcBBABCAAGBQJU7pRzAAoJEAC0Xr1Mp7q+/jUH +/jurl0OVNZBDpLahNm7paWjAXIy9WSqTPglfaykl5jnMA/qgMUa2FBq6llg2lwv7 +yH4SODehue8Tkj8d+zyUVUAQByfhVw262Z6vE3FueAnJaoruBT/RMrPl6Sifmk2t +1B8+W8bLbBmfADXx/RwCscUnB5Ml4vnnP5oUpzg+hTuUGok7fu1yhk9pO5qS2g3+ +mRxxeeTphXD6Y8hN9sgaqWPzv5Sn1Jk9GSMqUbbtjAEIcfbyS7VvG/JnhXDrDLcv +dnpVoFX7xo6AXa32LeyrcWIYo7ojVrftKjsCfi+riAiH5c7trOYPMbl3m+xRBbev +2kXht2FF/VJgCwAuhAE/1Dy0HkRhaWtpIFVlbm8gPHVlbm9AdW5peHVzZXIub3Jn +PokCVAQTAQIAPgIbAwIeAQIXgAULCQgHAwUVCgkICwUWAgMBABYhBEYiJcO0bzSH +n8hJbNYFhI7X5phxBQJbqxq7BQkaqS4NAAoJENYFhI7X5phx7qYP/R0/oCwNjM0t +reJEL7U1CAaPD8VMOrzlFvc4Kx5pJq5VLoMTpl1ikgyk/LAbNleWdgxCEtAGf4Nb +I9nxyV6Jh2EwGSwLf/HVKh5x6kWwRMqpSY5NcgJsQeAIojJT0ui3HANwNxvqcIHC +sPlCjSbKidgEkl/PGiSJj/UiP/OJ5Z0DqKg7hrd29XgVuBMIKcFQXysiHfy+N+9U +QbHtb6qjkriRZAZ4Jb6QLrwIzMqKOINj2NNKtxH1AaosxLQ+pcsmRA3OQPPKk5pt +QE70+R+OiGbFbfkL4UuigjhMAf9qmppiMnxq9gkt/lLteCpTFZZ2FeL9mSKu9eN0 +jewweVVcZdgm0vVmub4mrrkciJGl8Le3dZG3sZ1KYink6gSbYY8bJCfYo36+JqQx +9KmyAQKLV8YwgQGlHyy/6vHZdsPRsugmR0dbZEXxr0VE/CI26Ed68u2ZxtscVdur +WeNhsFnJpY8Dljah8QYnkObRp7DyEMUqD9cDC7Jlmgdq8fe9IIPxVNfDgHub6gh1 +5dA7XdRWB2Fd1rtSQ0xM/so3rfMDrssJ25RTkbA6gLNy54NO1Pz2xpsuL3MLlVF0 +xFdCIf7LD95vikfcXY6RiaJwniDS6bm1UOkaRzgG/o5FERS7Ea9cowsxoxypybDH +efH0Qn74J6B4BtgEB3cgfiJHjFjSzTceiEYEEBECAAYFAkpn9FUACgkQBB45r3HV +9DqoTQCgmInt4fLB1QxD0WOTali8DePRASoAoMauAVtMdo771+OsO4LI27d2r37Y +iQI2BBMBAgAgBQJKZ+4uAhsDBgsJCAcDAgQVAggDBBYCAwECHgECF4AACgkQ1gWE +jtfmmHFuwQ//TGZUobX/XWOTJQ4itonkIKn1WmFgDP6jHlg6lwmILkNW9u2LFydu +s5Q4voV5vxG5NKY+Y+5lKpxh3NelwhA1SyEKjaiUlhlbxBculEi0cVaXCw2IWjJf +Em5RVSP7uiW9Wco0mQWnIZ/+SMBfj5sK8EDmIJgKaL4EWGrr1ukuPNsquULCBpiU +Xbr4XY+xq4G/EoSrjzF1pnjU5sILpDICCJutALFBbMYyq7dPLU/4grIJOZ4eVu7F +269iWJ7EjTgqbCEKyv+5fRLqxh63fCVDrzyBhPPDmzvjIkTFfHuxTzElUChdEmKy +cCxKcv3trcAwq8Td5YTSe8hGdJl2jiA5XrEyZrXetTMB4eT1OghvbAmG91HHOZs9 +6gDRZA6yByYwSkVk4FbkgUOFy3rfvkPLdvJK/khPU3re5JAOLRuHsU6qDtuhQjBN +2/q1uJcrteXUwrVgTJC/YAvbfODFh6sUsktTNKNKFXW2Trp3YQkIkGbewgjfgQG5 +rmFkHMQuT/DEoa8ZndWFI6zCkCrhBTmt5oRVDZt8QHQ3qBiNqldv0W55ySHxMfdV +ZbOrCo9dddYUX0Ykl9NNrD6P14+InLRDhb8rwSR9wEsJNE+O+xNrNfpJ8CdwcRhE +/MC+BwFs7OMMx/IrnnCnm5dv7V+PwJXBUFsq+/0Q5at/jD7T/4XItRaIRgQQEQIA +BgUCS3/8mQAKCRBd4kmWWwNYor6KAJ0UM5DXG0f7jXlgksmhlQPfpigpMgCfZFKx ++XLFjZ57umWAnyIToCQiVAOIRgQTEQIABgUCS3kKyAAKCRBbs/UZWBZ5GicOAJwN +CYpa0ML9du6O2MV/HtT63MCI6QCgge9X03BS6QqNiGQg6LZUvu/OUOGIRgQTEQIA +BgUCS3kXJwAKCRByG62+aRFQJEY4AJ9xWZOrc5fCYEC1dGM++Bgb1H77YgCeKWfu +SpkqlFKktRoCYpH9YmRagUmIVgQQEQsABgUCS3/8mQAKCRDyrYWsHkKzZ0SmAN98 +HDYnkXnG623x4iVWEpM1sCgf7jV24w3k41MYAN9B6bNLKsqqtUkQ7Dzz9Gyd37w9 +xhAie4odbqhGiEYEEBEIAAYFAkuhu+QACgkQ1OXtrMAUPS1TZACfe0uTHfMqZYv+ +8rFCz6Cnw9aDVZ4AoL/C9PS0NauwQePAJvJBEIRlQ2Z3iQIcBBABCAAGBQJLobv+ +AAoJEIcvcCxNbiWorEYP/jVH2I+4aKM7dGgpuIS7gcwh0C+5HOSOs5IlfRcmwz37 +Ks341SZ66Nqryjtal4FMeihBkg+qQMPbP0EqPKJZL2bKRvk+bOyoJkZ62F5XnOyO +bVsX7NwFni93OqNpcQgV5KFrQOOmm8MgNlZ16u8EKFuGOiaQBnD7i7f/MXSk/P6q +457m76TOCCzmrV6faVuTryhrj5MtUc6n2bFHglusk8sHSYub2MS+BnNmYo/fAseY +FH9Y4SRQ6EdgR5XuxV/+oJYIDZG96NAqYljuSgBxwf4C3H7/ak8SqQZ61aDml+kD +ZF2jsE+5LoYReSVE1kX5fXM+uhLoc/SLA66fzmQ1+QY3D/NQAfUqFTS6twocvaXN +38qtw899nSPcg7KJf1QKHO9yM0inBr1Pjnu7KxRAjSGqabjIhWRDoHM/vPtCRNFI +Tv7lYJy3s3JbGx70qXNXrpFEDNELxlkiEea3fp/aLs/ak3OXcbr0GzhY9bRvwk2H +rwUOTHJIzcou1q0yWca4Q4th4bX/BhVpDJTmPC97OlDFILU447KVMBJUzwYbT56J +uK7pHd3xaPwqEXgcM7tZ6wdbhEWsnti1z9gJYoOVxLQj3t5uu0jk9ADJlmxGkYqa +H79+dyX2ypbMY9/kYfkdoZ1sNWQUtH3AP/B5ZJiWOjpZ2GRA6oZVi4VZDTsdLOnQ +iEUEEBEKAAYFAkuhu5cACgkQnQYz4bYlCYWS3gCXQErFEZnU5ojvqtQ05bo99RtY +KgCg5uDDDKCJNBmmIJdHysWLHASbyrSIRgQQEQoABgUCS6G7IwAKCRDlJz2Ya+PE +IxxpAKCUNVLNAS0icGYf1pb/K0ixPf/NEACggfCCBEZXJXTDUl5M4pSKNAG3aZ6I +RgQQEQIABgUCS6IH1gAKCRDWTsCv1M79N7oOAKDWMFitUhLS4QeH9cSZP9HYW12w +pACgv2N4zxaSsB+Qj+C81B43uBXndZCJAhwEEAECAAYFAkuiCKAACgkQnQRwvabN +xFeHqA//dOB7hk+pCW8TDSH9HDNrzq8zaM6CrslXwrVAlpkR+LEyFuS//yWslF7T +OYcGGkzIFu/niyLJN4Hjr1qdTzCA+ZWWq4KOwFjcjWCPKClh9Z/PQLlIv+DsAahm ++VJhHkF87DiKyX4Z50aO1mXBAutsZ0ml1wJCOjiYtzXVtVqiQkkMFbD7kWCdsiPl +q0hrgZefTWYrSgQT2rjrLV6O8QkqxgKE86P7hH/5SeqHJUvxFAWQcPCvIXgqwoFu +bJFWOit5U6jXTfyEGW640SK05vkFvv0a8VpVJ/g+J4uRSD391ubUOrNXol70ViC2 +jHZOO2iKWSRkjDGuf5PCKLvNsXJmuiDUpC/D6c5urTIR53mM4v8W/8KY6ifyTfma +W71sswouT2v4AlHwTJ9h7y7bBgG9zxNK8hWCT2Qx+Tcs2TA/8b7HDm8V9aFDIf0I +RrGMkWB7BkQqN6FT2weExHZJqp0KmJYg+Y+RbS+5yXxnETJiZQ0r1j5aERHaMZtF +Bd5vryEuF2K/Z3+ei/sqzMUv/hTjap/lNv9o8YQBsscjr20fnNoIbNWKfNB8v+rp +er1wEDt1hBQ/bpqs3c4svIzjJ1d52OtnZzOyy94jIEVGKcvB769f82omXLOU0sxf +CoO/rZgFuQJg8rdFa/OexWqWWxR49/kEL1BXsYMpHOetlpP/ylyJAhwEEAECAAYF +Akui8CAACgkQrtshZF+DDkpzrA//U5H2pn6Ee1IyeXXruUWw7BKtk6B+CKd0NN/G +OurKhEMk4iGcC4M0Rra5oI44Vm5NqwvB+tLSnY83YJB+eo9xyGHlO2zNuBhcVFTr +Jh4cV7hRpT8mRXUMzPQvw6NL6qR9I7K6pgENaKVqH59ovovjDi7kdt5Gd0wJPge+ +tAB680crDY4K+XrFkYVbUIqCDnVPEjewCQTOB5cj+8Eq1lp3u4n3v+1kuz3SRKC1 +2dAOJjjUtEbwNmL+jcpZ9WdF4nxy71bFph1mWJwmcPyDslPBP/BI3QXzQOaoNFMf +0uomljwwFq/z6f59hIxh0ZjaUnPGNlak1JUQVT1CPBm/iZKobUlkQhpYnpdI1B8i +ICfNfHOEAYhDzAMDcffxaTiAOzISJqYfEY5gw/UP4HVH0VIWNZDz4jY12CM2HMGK +GisHnj7sbegDEUV89lEQR6LQ4lDmaMCP9xBDWBshTysM1TESIdrZRIYbrSC7Vuky +I5mOaiXSJ9h3xzlujoezfSQsThm1sGvlJYhHiV33YoJRwLVx3UP4kSINuTkcMIgv +/5tVze9TRrVsDbIyX7X6SN6Ydfah16RqjLvWXLBsM1LibvL89xjgRfSJhhYm73st +dRJCax6xPNDXXP0Bo0+JRq07bml75Yx/OOXx/JjHslLH6+Gg7jgdxZWCHqfwb55I +3L1Ml0yJAhwEEAECAAYFAkui9n4ACgkQfW+/luxBIEPd9g/+Nx2dSRYMUyDz0LRE +aaRQbBV1jLsIsX66VeWilFZ8/la/xEHLQ72G8x0lTBp9Zj/ISNOkUVjnydVNWc+K +SRmy5+cczyazH23iJBPoNOW86tZ4H4RBtMZIvNbCbyEaxFUSqi2hP6q1eNgfn8NO +YP/b7zRO5xbhgg6cZjrZxqPes9/rR1IqzIOVEmjOxAWnXRKAiq3LmGquwW1AhqxJ +MyDacK7s/1eWlc2VFWEmmeoRaZGpyLOfjwvzT2pMjCl5yIQIB4itJVKNNlioaS6q +rx4HmRUK7oUap5NbCGz/b/m2K8G17DE2gHk4P3kb22fuXvpJVN16pZoEILtTgfum +792WB91BXIipN1yVtmMJ4xsNWC17zM0HCvX7CxzUdsegsgVWJoFmt94lDWCKH8u0 +A4iG9m0VftUuUaWqxw2OVHhsjzObVHXe4pH1umf6jWCxZKoRo+7WFMn8JvHKbH1v +MYWD6a3WwD343TYrtx1NlPG5B5GyIxfaXtlcv4D+6eA8XY8Qac3hvlsyAy+vP2/T +g/0PkbphB1STQnROw1sagZR+Log/XSPVOVRVIivngl8l42xb4W49Jb7cz5HoeiwN +lsNKEht2TElAM9l//szEZ55rcOuYZpzLXyW4EzD9gwp1p7yq2xS9ppX7v7Js14AI +fAqjiDUU3X9U56B3RtswFxqwKBKJAhwEEAECAAYFAkujNSQACgkQWrN2gbYw6SDa +UA//SDAsj/kTNy1xIeJfcfsD4ZxP1K2uijU3oLKYWkJGmFTyQO7LwvYYVvyMftIb +WUmKIS72mrNQq35hDSpbdMIHRzRrsGgcXa/OZv6GHwM5EF1G6mM5WXXpoXObqL7c +N3mpXUf6WsiIQdVnqlaiJfH2YhtDZU+GM2d4J824NjugoXNZbQnLC6qvEtCEOsRz +P2irI0ss2tvG4vv1EpjlbPfJIYEJ06y1LfDrQANddDp8RNaUMbx6e6Zr9cQUCKpJ +Cw/3HW8rwYLhh3fofe4XrYcZkyeORIl1K5ijAAUuz5ZlJNEBmIhk6UYx0HnExHgn ++clBj23jk+yYkAdiwnpNmOHMhMfWFVrfNZM3mXns92JtVj38PmbaidFgGf0xYxqb +ey2ks6Ck+ZUUQxRg1PPLPJPflrQ6HEybQ/+4bzRHhhs9wzaBGVBeS7Hlv2wAT1WF +yX6rF7qHqjsNRtHmdm6rcdCn9/hsjOu0gNoQ7rfd9UzyjLkfFdNAzZI/6Hx83ywW +9Y9a5Rfya8E+lFr4uO7aUc1661iksxAbCFb5Z6/8CNJFaZuSVrfZ+Z7u96hs2/og +M6g0i8uP+1Ucc31rZ1tcuUeGxHzPg75vGv1/8sw3yvsosll0wJF7N7POSJGDQIlm +qUWLEXaPS2HqoAL8xaKY39Dq1R0fmRsKUIlz2wX8ABYxf5CJAhwEEAECAAYFAkuj +OG4ACgkQby5g1n9bZvdTWBAAr08C9wd/S7Y7QujyoVQIdj9RKnoHf7MaFieBoqO2 +N2HPVogQrUV7d+sxzsC5IY3jsw14stAhHtZE47o2YPQNJjcE8rXQ0/jNgeU94zCA +6haSc/OB84DY5kvFKnN+5Dfr992wxLSND3QJGuQj0cQSjrOXdDXn6Kiboj+m0s9n +JGFQ/mq06PKXTJNy6MEJPqDbgy4yvs4ez4lZ6Zc+y7jKD/0/MSlYJz2kv7ie6fD8 +0dgrkAzPj/i/+Xk3re9Nq13T1nFd0nx2klUYYd/0vmBPUyr5+D0UFH24UdVKFrvo +QsFIzWNUcFBdf1rDqSosTraS8XrZpSa7vWU97QQIMVeoBFN9tXPS/Xr/34pfrjja +LbnIZ//kk5tMEZTYw4pAILKffahHki6nL077h390BCljD8R5DBjmisiSEELcKjGo +qXmuQljP13gthH1al3oolBcIADP21KnipIXRxPQRVEWAZEDef7vaAysCxTank65k +e7DXCRcNL9I4PR1GTJgpfOVLkYUhBNRELIatsOELnzN/g8N1xIHmgt58yQn3vEjH +XxlqZ8+duUiEVrJLZBz/mbuMQO999azHI6Y5lh0Jb0P3ODyScDlfgxn9ZenUttgg +AzJMnFD50E7+E/i0YmZwVIApBdis1N/7UVcnVgDw28VHFN/i0RzqrXavjRZVVaEv +WEOJAhwEEAECAAYFAkui/WkACgkQ4VE6mR/O5yS1iBAAjbsS/jkcj4trwoQdZgGV +2nIowCPFmRWiUktxAvKOuOb0Imy61p7i8ulfq2P2BTv7L4ec20eUSQg2T6AseJ7D +dKertdgrWTaM01WWBkupOwJfqSZifSd68tde5ReL+L1qTD8h9pGHOoIbbQDuMDAu +NrCjoBQekUbSS356DJ8KAAaz08K4hOB0S63kkxJuyr5Gw018+WK1vkFmCSioOg/A +GKGqUtUi7jcVSvDDhbaj2bj9CUCV4eD3SaZGlUqOOdjEmCDZxmW71T0HHFa2Wc2p +TPOhKfhmI/vZDesGqieNFW3y3xrnYxZ0C9A0gbKBueck16CgmOUViN5YzmviKgoT +72oxy5teGYwSxeZarh+sMf+U1pvH0WxaQ4kVxdMcr+uh4Fhik5l1qGTSDf+k3QX3 +eh/HXZvQLX5R2jqctZTjx2AObpk0vMg0CHywcjLaBomF0xNlf3WRZ6dZcEwjtpVE +WGB7jDKE6/70HDPBmG0cHo1lUBrvX+gzD2UwMRUyMcDUYkAETnLYKjYBVtcyFnZz +UiUpXBIHvmtiTwKOhoPFhOF5f/0nP52UMY2U4kKTg6Up56amLfLkjcD2zryYxl0E +e4i2nS1n/oPGOfT40B1UAMPzNPDaaVMzxsCzT0O+L7ZcdrEnPTON47jwqRDjOSVb +WNfxD8PU0AqJGxmB8B1+qlaJAhwEEAECAAYFAkujSzwACgkQZN0/1KebxaCqHA/+ +Pi3ckbNxMctejZMwffwmYNGI3wpsVnvA2wI+rXmsA5cd7USt7rRs5Xhxl8g6qFKh +hHpQI2Dl84o6oi7zE+KRgd8Z1aux/lyVvUFILOqFZ3q55JCebiXWE8nUBYyknoYO +niXjN76NRIVA29PLtKAV2rcuZmzvBfJO3cG4ZEGbof4qPuuck9wJkE1CBNa3EQ9Y +Jj4DaObbW54d0hcL+ZZgD+rxnZZCNW3Up5/8IM69k2K54OGHMRVCmoNfGV5+Nn75 +t8+qYJsiWC431JkSvGnwLDS4ytJ/VXKRaolraJ/fpyJ8OkBkCyqODMiyeQa7STh6 +OmHi+YaIzibKHzAMXGiDDmtAWYKsvBaY5im4IkZTGF/N65Wd5dUd/++MP7/ViFcO +XstE9jbvtRSJeV9rXwQE+fCoXzRWCTt+DU0xtfbg5We7O1WsAAPQ1NOKWpMtt71P +mc7UAexUIsyAddsou6Jc3j050zaQWUoVXEmHxcjjbRb2laZX1FqhQO+9xu7mxxaw +GGl+G6zNKgboJeTFbCjscSdESc4N6nmx0pcM/xkoRZdaodXbgkxPVHHB9pecofYG +wT/HpVIJGNViTrYtt2RsH4+azPG6Gld2uNttlCaBmlvshOhyMgGliTUQ6ovw18AX +itaqUMxIvhXN82X1J31kNcoVcBRtrhz7Med15ymC+aCIRgQQEQIABgUCS6XPkQAK +CRCqDNHu0ItH/pQ/AKCijYYkeh9mWCtN6N3V5T5QjS3iCgCeNMbOTvcYsc/kcZG2 +ZXOlhgt4ND2JAhwEEAECAAYFAkul0AgACgkQouuu0bb5AkFJEg/9Hh46rI00YY3M +FlN+sdVa3HB8DFEp5qcZlFlRn0v05io3ls9fA1ZahpFozy1Ggkv6iCwFCaNYz0vF +U1tPNrTP1A2zRhk0zFoDHTBabhyTm0sz8jQpsgFU8iERcBzS6cE10bkx+nnuFCCi +rX/wqtk7q0FFkReuk/ojEGq/cy6BoVLKi730HxXwitXM1AkqCcdO6QNAO2JoPZ+i +nZUYx000B/p8FpmKwyEgSRWFQ+sr8Tvwe9tZA3GGUWjIUuzQ+tk8o9wB4LG66KtP +2CiOJm1iNvCTp2NuAU+99J4juuSNIag5iNKJxcPXXc8gixXYyZirMMEs1HBjILjI +Mceac1wekUyz6hvlib5IxF/O+rpt5WCxHujjlav3nWCOzIGGHMgliRjnqW05jS/q +iYeBscDXgm+6zid4lhWkG7elcnBhyuWOqyPFBJdi5s/xAQ/rUWdel11MX5HfUPOh +G4X19Mt+xirXs8BOzpZsUyunFvS056w4QkA/8ZfbViuAHfKds0wW5jBoVBRrsSgt +72GEgrD4jAMbBzHJ6nQ7WkG3AXtfHS5wy0gEHoPzPBOPei48cjzYEXx6ZRHUudWD +E6/lJQyxCD2AWORFxsM1MPREvAv7piq3RSSwnkxEic6BTyiqJpGorOBr5Ux0p/Uo +6MpLILLKvKk+Z/c0bNPlJbSsGrvivJeJAhwEEAECAAYFAkusJboACgkQaya96q0S +IUp6tBAAurSP/z0rFC4l9m+qP5m4a7iX46g0sgdJfg/KCvyO814Exh3qIiHsCubO +WGtULnKeS71lRuBKh0nl8dRzfl4JvxPD6aVaQ8UYXOTsvaDMUFh1zRBW4g6ICb6U +6RCir0cJBycvj37qtDXrhiuJP2MCbScZlfvVPxmDhLfC39P8Mbxc8CsyAdrGaGJa +6qCVVDKxu1IPle84V4PWtof6h/jlqCqXy/3AAw5VcacGhChFemHehTgqSsQAbYc9 +T3A0x6LsQxn4Z5kCeFSjo89MGQLtkhwSFUnVu40PpcnB8Vxc4LolIR2fHT60RWhm +qerfSo/0C9VTEctnbylYsN53Zf8lA7eu34NFXM+B/T8Vj4uj40YjVDGzmuf02dNX +rnDrSs5akspABFtQwINqpbYTNXHCQoEfmhep0YTpI8//8w8POFLcc2Ue9dA7GhH3 +ntgEXVoVP4C2r0dYaWRIdTmXK2D6dO7SQ7x1TFdCWvmmfigPH5aZyxIlzSJJbyC1 +946j80fXCN5R9sSJZ1FLNrDB2vSEfGXA4bIqma89Sz4JuLThKuDXIu73f3DVmLPF +ThaOGB20r7aVsTVkV1ncfJ5MkTYDOmUKYavhQybM/fbgE92GWA8Igz0Wyh1GkP5y +8JDbkdItGV2HPLbJGLyR2N/XQfKNPThBcB77BL4FqKVwwIQlmqGJAhwEEAECAAYF +AlJQB/EACgkQLGRkryqOTALmeQ/+PbaOG9U1YGtWnpcIp0fffCRXTxHpWQeEYjjp +TmfS6NM+ExChpPQaj3k7qKVFyZaHJJ8pwYPRkDLN7qwvgV9By1xoxBurpxQekt2u +23p0icQqymeFV4ruWXYFqdlQMk8rnIzsUjRvduXhka7H2T72pYd2olDC2GHAGxSE +emG6jR0/XMUynJMBfcigZ6kBYwbmlMpm67iHp8oivQoApcOtoA+W/gkVvG/HHmnb +F+bXO210oi+KWNg8RnmDzJflI1+wiMYcY3ywxbArLOTaNwUVlZJkbwKxUiQ3t/ST +p06iHG5FIC1KifVU8YtCqXL1/b6veY/8CpYZwDz+lfgqRH1vsnfCxoJqBpLIO3yQ +e78OGDfLOai0GdnbZfMmC7Vc1g8CuUkzaZ56NslhFGk5ZMJ+mZdEZuVMg+CuLEfO +WDv4CSKL4I7KP/xReN3mxe/wt4+0DdGeZ2vcc9Lw/j/e9qLh9NZ1WC2/hiJTOjHK +HLKHXF/xRoMLcD+IbXn30jca9TxZay77xJo6swSZRt5P/6rUBSjT4qnovqaAqZiN +4vUpYBwPLEAF4Y+9Gt20r6gaXYWoVpqGrSU9WPQuGNUkiwn35fIQKiAbkU3Wu2C3 +jnrvqNnRnKVFA0vHH6WMOuoF9v0D+kqCGE7yy5SNCqKI4VE32+5kSln7KMrZn8gj +6ZhqTl2JARwEEAEIAAYFAlTulHMACgkQALRevUynur72Tgf6AqqQyYZLvh87v7ms +ZQl+RI9WhriThm1pVBMV//SNIgwXiV79qqRHHU/7INTv5PZZO3Chsy9QXg7Ic/k4 +WZ4EQzpIc3QwVoWKfKXBzz3P7xlNsLlCmhVd0Zk9NI6wFBS/EOhR28RBuMAr+zxS +6zDpIRZ/coR/bQP2fcUC3jhHLNpnmnuxMS8Llcp69lmb2ZfQjZSggslEDE/YuoRE +YLdojzlOZ+ry/z3b4082636M6Ftv/sX0l3JUU6clZEgekoi+56bNLs6sf/+5KVyT +xet/DE3XhvXafrCcZuaSIEDuDKhzp/rAcfJtdPdYagGO7duqM41F5On+2ajkItd+ +i5gLyLkCDQRLa0+8ARAAo0ZzSl6Yg/7W1Uohd24nGaX+AtSRSA77yR0GRLit+Uqn +gHv7VKTAMGwX4FubBMVKAdwstZRCtgYtZDuxlPrZHQh4Yuo63C2IjIO0F2r2Gf3m +2B1X4VWNrxoTiVc+KptP1r0GE9zqSUqqw9Y0/gG0aQ8RZPYdggT8Na6Aa4fE6mCs +iDgT0rMC8D9OSCpPYe0sEJ5f7LV0XISzFWjKyi991dm6WUiODbWISUBs1+zx1bL+ +CWAQlwnhUYQCcCy8knxjNw13QAobDo7RqG/7FvOCr+WDOubB8ZoYreDQuaOSMVUJ +7b2GjrE2nxfSjgvHoKLLT7AEcVDTYoRmLyeVi/DUtsEFTFrIkTCvv0LCujxDF58u +KvfpTDxgWabhonFF+vESCCcpwGh2rXaKwNIRUg0CFcW4Q00HawZ5rX0sd92HfS5W +lvqBc96DbbFD+eyUDL5+/0WDEoXkarZYUjjh0Ffw3TkaNgdboXdg5bmTs7Fc/PKP +9nmfXYTvAKzYUEaVoHMe3avpCOxclB9CHa8Nvag9yE/z5xDkxfOK6JdBxGoD9aM1 +Qd9pKySA0UJXk5nU6ILU+vRWCx5yvX2K5NZtz3HN01m/9TwnHHDdA9kSQpdpK8uc +CXceoNm4u8IOLcKUSbIYuY0RDyQABjcuTCgPqKJ+g+oG8MDT98bs///QVNAFA2EA +EQEAAYkCHwQYAQIACQUCS2tPvAIbDAAKCRDWBYSO1+aYcTCsEACfo4LesDjAi8dc +7EYt6cRkEKuxZlSTSWGddiRKdriwtYfRNPFfmkF2Xu6W6JyJV783iITpekdUps/y +psqJcvQvUyIbTIZGa7MaHK4mizOyMSHwrstIpxb7/WxKIAgjVcRaY1dQz7HDFVES +kII2zUHCns8ijlKuOyAqvHjecJmu9ppcUVUcVEx4ud0qJH2/WLq4VR63FsfxEjEe +8x0gsI7X0OvXO+/miEycKHFWsZVFUGAgmrwjgdYGA453+Rde4PsxhgsO3TfL4OAd +OPKMoPEYkpwJjdpbeIn36jwFU1PK4sQ0RpIKcWIjJBgnWqh8ErvprgmvOQDPa/Vi +uliLkUBI4djzbE5PpbWpky3xVAtLDqRvvC3rQ9YSNwVkqX4E+Z3J1EXJ5mp7IlU9 +Bsu97z13/kx8J2OLwGOaNF/d7NrMnw1+2Ua4S4NDASrs/3iAUSwxWsJI6Xvt5g2D +FaNUtQ6YO2LfCL5QxUJVkZSErqIIDOPOiUDX43UtGYhJNZiI2uMPEWAydhZOoXKE +e+eH4WbVC4F8xNBERmk36RZRruI2lpslopHWs/qH+QEdPZi5eioQg7qidS36aJIH +XlCDsMXv+u8U+cMhlive34yRo+WaOlcRRX+mx2fK1VYVwbEd1jQ0D5H97h57JOGB +F63kz7T70O7KeP8AKl9ar93FdtZF9g== +=Kwtl -----END PGP PUBLIC KEY BLOCK----- -----BEGIN PGP PUBLIC KEY BLOCK----- diff --git a/gnutls.spec b/gnutls.spec index ccba96c..bfb14b7 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -36,7 +36,7 @@ %bcond_with tpm %bcond_without guile Name: gnutls -Version: 3.7.7 +Version: 3.7.8 Release: 0 Summary: The GNU Transport Layer Security Library License: GPL-3.0-or-later AND LGPL-2.1-or-later @@ -44,10 +44,10 @@ Group: Productivity/Networking/Security URL: https://www.gnutls.org/ Source0: https://www.gnupg.org/ftp/gcrypt/gnutls/v3.7/%{name}-%{version}.tar.xz Source1: https://www.gnupg.org/ftp/gcrypt/gnutls/v3.7/%{name}-%{version}.tar.xz.sig +# https://gnutls.org/gnutls-release-keyring.gpg Source2: gnutls.keyring Source3: baselibs.conf Patch0: gnutls-3.5.11-skip-trust-store-tests.patch -Patch1: gnutls-3.6.6-set_guile_site_dir.patch Patch2: gnutls-FIPS-TLS_KDF_selftest.patch Patch3: gnutls-FIPS-disable-failing-tests.patch Patch4: gnutls_ECDSA_signing.patch @@ -67,6 +67,7 @@ BuildRequires: datefudge BuildRequires: fdupes BuildRequires: fipscheck BuildRequires: gcc-c++ +BuildRequires: gtk-doc # The test suite calls /usr/bin/ss from iproute2. It's our own duty to ensure we have it present BuildRequires: iproute2 BuildRequires: libidn2-devel @@ -220,7 +221,7 @@ echo "SYSTEM=NORMAL" >> tests/system.prio export LDFLAGS="-pie -Wl,-z,now -Wl,-z,relro" export CFLAGS="%{optflags} -fPIE" export CXXFLAGS="%{optflags} -fPIE" -#autoreconf -fiv +autoreconf -fiv %configure \ gl_cv_func_printf_directive_n=yes \ gl_cv_func_printf_infinite_long_double=yes \ @@ -243,6 +244,7 @@ export CXXFLAGS="%{optflags} -fPIE" %endif %if %{with guile} --enable-guile \ + --with-guile-extension-dir=%{_libdir}/guile/3.0 \ %else --disable-guile \ %endif @@ -381,7 +383,7 @@ GNUTLS_FORCE_FIPS_MODE=1 make check %{?_smp_mflags} GNUTLS_SYSTEM_PRIORITY_FILE= %files guile %license LICENSE %{_libdir}/guile/* -%{_datadir}/guile/gnutls* +%{_datadir}/guile/site/* %endif %changelog From f914173517fb90a85f880f115724985f0cf25ac0dfd209faa6454e02531036ff Mon Sep 17 00:00:00 2001 From: Pedro Monreal Gonzalez Date: Mon, 17 Oct 2022 10:12:56 +0000 Subject: [PATCH 3/5] Accepting request 1011039 from home:pmonrealgonzalez:branches:security:tls - The FIPS hmac is now calculated with an internal tool since commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed and it has been renamed to .gnutls.hmac. [bsc#1199881, bsc#1203245] * Remove the fipscheck build dependency * Check only the calculated hmac for libgnutls.so.30 since the calculated hmacs for libnettle.so.8, libhogweed.so.6 and libgmp.so.10 in .gnutls.hmac are incorrect. * Add gnutls-FIPS-hmac-check-only-libgnutls.patch * Remove gnutls-FIPS-Run-CFB8-without-offset.patch - FIPS: Set error state when jent init failed in FIPS mode [bsc#1202146] * Add patch gnutls-FIPS-Set-error-state-when-jent-init-failed.patch OBS-URL: https://build.opensuse.org/request/show/1011039 OBS-URL: https://build.opensuse.org/package/show/security:tls/gnutls?expand=0&rev=78 --- gnutls-FIPS-Run-CFB8-without-offset.patch | 29 ------ ...et-error-state-when-jent-init-failed.patch | 91 +++++++++++++++++++ gnutls-FIPS-hmac-check-only-libgnutls.patch | 20 ++++ gnutls.changes | 19 ++++ gnutls.spec | 41 ++++++--- 5 files changed, 159 insertions(+), 41 deletions(-) delete mode 100644 gnutls-FIPS-Run-CFB8-without-offset.patch create mode 100644 gnutls-FIPS-Set-error-state-when-jent-init-failed.patch create mode 100644 gnutls-FIPS-hmac-check-only-libgnutls.patch diff --git a/gnutls-FIPS-Run-CFB8-without-offset.patch b/gnutls-FIPS-Run-CFB8-without-offset.patch deleted file mode 100644 index 4abedb2..0000000 --- a/gnutls-FIPS-Run-CFB8-without-offset.patch +++ /dev/null @@ -1,29 +0,0 @@ -Index: gnutls-3.7.7/lib/crypto-selftests.c -=================================================================== ---- gnutls-3.7.7.orig/lib/crypto-selftests.c -+++ gnutls-3.7.7/lib/crypto-selftests.c -@@ -2735,6 +2735,16 @@ int gnutls_cipher_self_test(unsigned fla - NON_FIPS_CASE(GNUTLS_CIPHER_CHACHA20_POLY1305, test_cipher_aead, - chacha_poly1305_vectors); - FALLTHROUGH; -+ CASE(GNUTLS_CIPHER_AES_128_CFB8, test_cipher, -+ aes128_cfb8_vectors); -+ FALLTHROUGH; -+ CASE(GNUTLS_CIPHER_AES_192_CFB8, test_cipher, -+ aes192_cfb8_vectors); -+ FALLTHROUGH; -+ CASE(GNUTLS_CIPHER_AES_256_CFB8, test_cipher, -+ aes256_cfb8_vectors); -+ FALLTHROUGH; -+#if 0 - CASE2(GNUTLS_CIPHER_AES_128_CFB8, test_cipher, - test_cipher_all_block_sizes, - aes128_cfb8_vectors); -@@ -2747,6 +2757,7 @@ int gnutls_cipher_self_test(unsigned fla - test_cipher_all_block_sizes, - aes256_cfb8_vectors); - FALLTHROUGH; -+#endif - CASE(GNUTLS_CIPHER_AES_128_XTS, test_cipher, - aes128_xts_vectors); - FALLTHROUGH; diff --git a/gnutls-FIPS-Set-error-state-when-jent-init-failed.patch b/gnutls-FIPS-Set-error-state-when-jent-init-failed.patch new file mode 100644 index 0000000..1c969b7 --- /dev/null +++ b/gnutls-FIPS-Set-error-state-when-jent-init-failed.patch @@ -0,0 +1,91 @@ +--- + lib/nettle/sysrng-linux.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +Index: gnutls-3.7.8/lib/nettle/sysrng-linux.c +=================================================================== +--- gnutls-3.7.8.orig/lib/nettle/sysrng-linux.c ++++ gnutls-3.7.8/lib/nettle/sysrng-linux.c +@@ -49,11 +49,13 @@ + get_entropy_func _rnd_get_system_entropy = NULL; + + #if defined(__linux__) +-# ifdef ENABLE_FIPS140 ++# if defined(ENABLE_FIPS140) + # define HAVE_JENT + # include + static int jent_initialized = 0; + static struct rand_data* ec = NULL; ++/* Declare function to fix a missing-prototypes compilation warning */ ++void FIPS_jent_entropy_deinit(void); + # endif + # ifdef HAVE_GETRANDOM + # include +@@ -72,7 +74,8 @@ static ssize_t _getrandom0(void *buf, si + # endif + # endif + +-# if defined(HAVE_JENT) ++# if defined(ENABLE_FIPS140) ++# if defined(HAVE_JENT) + /* check whether the CPU Jitter entropy collector is available. */ + static unsigned FIPS_jent_entropy_init(void) + { +@@ -161,6 +164,7 @@ static int _rnd_get_system_entropy_jent( + + return 0; + } ++# endif + # endif + + static unsigned have_getrandom(void) +@@ -260,7 +264,8 @@ int _rnd_system_entropy_init(void) + int urandom_fd; + + #if defined(__linux__) +-# if defined(HAVE_JENT) ++# if defined(ENABLE_FIPS140) ++# if defined(HAVE_JENT) + /* Enable jitterentropy usage if available */ + if (FIPS_jent_entropy_init()) { + _rnd_get_system_entropy = _rnd_get_system_entropy_jent; +@@ -268,7 +273,14 @@ int _rnd_system_entropy_init(void) + return 0; + } else { + _gnutls_debug_log("jitterentropy is not available\n"); ++ /* Set error state when FIPS_jent_entropy_init failed and FIPS mode is enabled */ ++ if (_gnutls_fips_mode_enabled()) { ++ _gnutls_switch_fips_state(GNUTLS_FIPS140_OP_ERROR); ++ _gnutls_switch_lib_state(LIB_STATE_ERROR); ++ return gnutls_assert_val(GNUTLS_E_RANDOM_DEVICE_ERROR); ++ } + } ++# endif + # endif + /* Enable getrandom() usage if available */ + if (have_getrandom()) { +@@ -300,8 +312,10 @@ void _rnd_system_entropy_deinit(void) + { + /* A no-op now when we open and close /dev/urandom every time */ + #if defined(__linux__) +-# if defined(HAVE_JENT) ++# if defined(ENABLE_FIPS140) ++# if defined(HAVE_JENT) + FIPS_jent_entropy_deinit(); ++# endif + # endif + #endif + return; +Index: gnutls-3.7.8/tests/Makefile.am +=================================================================== +--- gnutls-3.7.8.orig/tests/Makefile.am ++++ gnutls-3.7.8/tests/Makefile.am +@@ -208,7 +208,7 @@ ctests += mini-record-2 simple gnutls_hm + dtls12-cert-key-exchange dtls10-cert-key-exchange x509-cert-callback-legacy \ + keylog-env ssl2-hello tlsfeature-ext dtls-rehandshake-cert-2 dtls-session-ticket-lost \ + tlsfeature-crt dtls-rehandshake-cert-3 resume-with-false-start \ +- set_x509_key_file_ocsp client-fastopen rng-sigint srp rng-pthread \ ++ set_x509_key_file_ocsp client-fastopen srp rng-pthread \ + safe-renegotiation/srn0 safe-renegotiation/srn1 safe-renegotiation/srn2 \ + safe-renegotiation/srn3 safe-renegotiation/srn4 safe-renegotiation/srn5 \ + rsa-illegal-import set_x509_ocsp_multi_invalid set_key set_x509_key_file_ocsp_multi2 \ diff --git a/gnutls-FIPS-hmac-check-only-libgnutls.patch b/gnutls-FIPS-hmac-check-only-libgnutls.patch new file mode 100644 index 0000000..e43418a --- /dev/null +++ b/gnutls-FIPS-hmac-check-only-libgnutls.patch @@ -0,0 +1,20 @@ +Index: gnutls-3.7.8/lib/fips.c +=================================================================== +--- gnutls-3.7.8.orig/lib/fips.c ++++ gnutls-3.7.8/lib/fips.c +@@ -402,6 +402,7 @@ static int check_binary_integrity(void) + ret = check_lib_hmac(&file.gnutls, GNUTLS_LIBRARY_NAME, "gnutls_global_init"); + if (ret < 0) + return ret; ++#if 0 + ret = check_lib_hmac(&file.nettle, NETTLE_LIBRARY_NAME, "nettle_aes_set_encrypt_key"); + if (ret < 0) + return ret; +@@ -411,6 +412,7 @@ static int check_binary_integrity(void) + ret = check_lib_hmac(&file.gmp, GMP_LIBRARY_NAME, "__gmpz_init"); + if (ret < 0) + return ret; ++#endif + + return 0; + } diff --git a/gnutls.changes b/gnutls.changes index 12601c5..822c649 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,3 +1,16 @@ +------------------------------------------------------------------- +Fri Oct 14 11:35:33 UTC 2022 - Pedro Monreal + +- The FIPS hmac is now calculated with an internal tool since + commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed and it has + been renamed to .gnutls.hmac. [bsc#1199881, bsc#1203245] + * Remove the fipscheck build dependency + * Check only the calculated hmac for libgnutls.so.30 since the + calculated hmacs for libnettle.so.8, libhogweed.so.6 and + libgmp.so.10 in .gnutls.hmac are incorrect. + * Add gnutls-FIPS-hmac-check-only-libgnutls.patch + * Remove gnutls-FIPS-Run-CFB8-without-offset.patch + ------------------------------------------------------------------- Sun Oct 9 12:53:27 UTC 2022 - Pedro Monreal @@ -28,6 +41,12 @@ Sun Oct 9 12:53:27 UTC 2022 - Pedro Monreal * Update gnutls.keyring * Add a build depencency on gtk-doc required by autoreconf +------------------------------------------------------------------- +Fri Oct 7 09:30:44 UTC 2022 - Otto Hollmann + +- FIPS: Set error state when jent init failed in FIPS mode [bsc#1202146] + * Add patch gnutls-FIPS-Set-error-state-when-jent-init-failed.patch + ------------------------------------------------------------------- Tue Oct 4 13:05:27 UTC 2022 - Otto Hollmann diff --git a/gnutls.spec b/gnutls.spec index bfb14b7..2db0599 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -48,24 +48,25 @@ Source1: https://www.gnupg.org/ftp/gcrypt/gnutls/v3.7/%{name}-%{version}. Source2: gnutls.keyring Source3: baselibs.conf Patch0: gnutls-3.5.11-skip-trust-store-tests.patch -Patch2: gnutls-FIPS-TLS_KDF_selftest.patch -Patch3: gnutls-FIPS-disable-failing-tests.patch -Patch4: gnutls_ECDSA_signing.patch +Patch1: gnutls-FIPS-TLS_KDF_selftest.patch +Patch2: gnutls-FIPS-disable-failing-tests.patch +Patch3: gnutls_ECDSA_signing.patch %if 0%{?suse_version} >= 1550 || 0%{?sle_version} >= 150400 #PATCH-FIX-SUSE bsc#1202146 FIPS: Port gnutls to use jitterentropy -Patch5: gnutls-FIPS-jitterentropy.patch +Patch4: gnutls-FIPS-jitterentropy.patch +#PATCH-FIX-SUSE bsc#1202146 FIPS: Set error state when jent init failed in FIPS mode +Patch5: gnutls-FIPS-Set-error-state-when-jent-init-failed.patch %endif #PATCH-FIX-SUSE bsc#1190698 FIPS: SLI gnutls_pbkdf2: verify keylengths and allow SHA only Patch6: gnutls-FIPS-SLI-pbkdf2-verify-keylengths-only-SHA.patch -#PATCH-FIX-SUSE bsc#1203245 FIPS: Run the CFB8 cipher selftests without offset -Patch7: gnutls-FIPS-Run-CFB8-without-offset.patch #PATCH-FIX-UPSTREAM bsc#1203779 Make XTS key check failure not fatal -Patch8: gnutls-Make-XTS-key-check-failure-not-fatal.patch +Patch7: gnutls-Make-XTS-key-check-failure-not-fatal.patch +#PATCH-FIX-SUSE bsc#1199881 FIPS: Check only the calculated hmac for libgnutls.so.%%{gnutls_sover} +Patch8: gnutls-FIPS-hmac-check-only-libgnutls.patch BuildRequires: autogen BuildRequires: automake BuildRequires: datefudge BuildRequires: fdupes -BuildRequires: fipscheck BuildRequires: gcc-c++ BuildRequires: gtk-doc # The test suite calls /usr/bin/ss from iproute2. It's our own duty to ensure we have it present @@ -260,9 +261,6 @@ rm -rf %{buildroot}%{_datadir}/locale/en@{,bold}quot # Do not package static libs and libtool files find %{buildroot} -type f -name "*.la" -delete -print -# Compute FIPS hmac using the brp-50-generate-fips-hmac script -export BRP_FIPSHMAC_FILES=%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover} - # install docs mkdir -p %{buildroot}%{_docdir}/libgnutls-devel/ cp doc/gnutls.html doc/*.png %{buildroot}%{_docdir}/libgnutls-devel/ @@ -277,6 +275,25 @@ rm -rf %{buildroot}%{_datadir}/doc/gnutls %find_lang libgnutls --all-name +# the hmac hashes: +# +# this is a hack that re-defines the __os_install_post macro +# for a simple reason: the macro strips the binaries and thereby +# invalidates a HMAC that may have been created earlier. +# solution: create the hashes _after_ the macro runs. +# +# this shows up earlier because otherwise the %%expand of +# the macro is too late. +# remark: This is the same as running +# openssl dgst -sha256 -hmac 'orboDeJITITejsirpADONivirpUkvarP' +# note: The FIPS hmac is now calculated with an internal tool since +# commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed and the file +# has been renamed to .gnutls.hmac +%{expand:%%global __os_install_post {%__os_install_post +./lib/fipshmac "%{buildroot}%{_libdir}/libgnutls.so.30" > %{buildroot}%{_libdir}/.gnutls.hmac +sed -i "s^%{buildroot}/usr^^" %{buildroot}%{_libdir}/.gnutls.hmac +}} + %check %if ! 0%{?qemu_user_space_build} %make_build check GNUTLS_SYSTEM_PRIORITY_FILE=/dev/null || { @@ -326,7 +343,7 @@ GNUTLS_FORCE_FIPS_MODE=1 make check %{?_smp_mflags} GNUTLS_SYSTEM_PRIORITY_FILE= %files -n libgnutls%{gnutls_sover}-hmac %license LICENSE -%{_libdir}/.libgnutls.so.%{gnutls_sover}*.hmac +%{_libdir}/.gnutls.hmac %if %{with dane} %files -n libgnutls-dane%{gnutls_dane_sover} From eccec72a4b5c2749e6fae3bf7058d141dba97ed2a34fe58793cd79a60f9bf148 Mon Sep 17 00:00:00 2001 From: Pedro Monreal Gonzalez Date: Wed, 2 Nov 2022 21:55:38 +0000 Subject: [PATCH 4/5] Accepting request 1032959 from home:pmonrealgonzalez:branches:security:tls - Temporarily revert the jitterentropy patches in s390 and s390x architectures until a fix is provided [bsc#1204937] - Consolidate the FIPS .hmac files [bsc#1199881, bsc#1203245] * Package the FIPS .hmac files * Remove not needed gnutls-FIPS-Run-CFB8-without-offset.patch OBS-URL: https://build.opensuse.org/request/show/1032959 OBS-URL: https://build.opensuse.org/package/show/security:tls/gnutls?expand=0&rev=79 --- gnutls-FIPS-hmac-check-only-libgnutls.patch | 20 ------------- gnutls.changes | 18 ++++++------ gnutls.spec | 32 +++++++-------------- 3 files changed, 20 insertions(+), 50 deletions(-) delete mode 100644 gnutls-FIPS-hmac-check-only-libgnutls.patch diff --git a/gnutls-FIPS-hmac-check-only-libgnutls.patch b/gnutls-FIPS-hmac-check-only-libgnutls.patch deleted file mode 100644 index e43418a..0000000 --- a/gnutls-FIPS-hmac-check-only-libgnutls.patch +++ /dev/null @@ -1,20 +0,0 @@ -Index: gnutls-3.7.8/lib/fips.c -=================================================================== ---- gnutls-3.7.8.orig/lib/fips.c -+++ gnutls-3.7.8/lib/fips.c -@@ -402,6 +402,7 @@ static int check_binary_integrity(void) - ret = check_lib_hmac(&file.gnutls, GNUTLS_LIBRARY_NAME, "gnutls_global_init"); - if (ret < 0) - return ret; -+#if 0 - ret = check_lib_hmac(&file.nettle, NETTLE_LIBRARY_NAME, "nettle_aes_set_encrypt_key"); - if (ret < 0) - return ret; -@@ -411,6 +412,7 @@ static int check_binary_integrity(void) - ret = check_lib_hmac(&file.gmp, GMP_LIBRARY_NAME, "__gmpz_init"); - if (ret < 0) - return ret; -+#endif - - return 0; - } diff --git a/gnutls.changes b/gnutls.changes index 822c649..20d9a0f 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,15 +1,15 @@ +------------------------------------------------------------------- +Wed Nov 2 20:51:43 UTC 2022 - Pedro Monreal + +- Temporarily revert the jitterentropy patches in s390 and s390x + architectures until a fix is provided [bsc#1204937] + ------------------------------------------------------------------- Fri Oct 14 11:35:33 UTC 2022 - Pedro Monreal -- The FIPS hmac is now calculated with an internal tool since - commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed and it has - been renamed to .gnutls.hmac. [bsc#1199881, bsc#1203245] - * Remove the fipscheck build dependency - * Check only the calculated hmac for libgnutls.so.30 since the - calculated hmacs for libnettle.so.8, libhogweed.so.6 and - libgmp.so.10 in .gnutls.hmac are incorrect. - * Add gnutls-FIPS-hmac-check-only-libgnutls.patch - * Remove gnutls-FIPS-Run-CFB8-without-offset.patch +- Consolidate the FIPS .hmac files [bsc#1199881, bsc#1203245] + * Package the FIPS .hmac files + * Remove not needed gnutls-FIPS-Run-CFB8-without-offset.patch ------------------------------------------------------------------- Sun Oct 9 12:53:27 UTC 2022 - Pedro Monreal diff --git a/gnutls.spec b/gnutls.spec index 2db0599..585ab48 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -52,21 +52,22 @@ Patch1: gnutls-FIPS-TLS_KDF_selftest.patch Patch2: gnutls-FIPS-disable-failing-tests.patch Patch3: gnutls_ECDSA_signing.patch %if 0%{?suse_version} >= 1550 || 0%{?sle_version} >= 150400 +%ifnarch s390 s390x #PATCH-FIX-SUSE bsc#1202146 FIPS: Port gnutls to use jitterentropy Patch4: gnutls-FIPS-jitterentropy.patch #PATCH-FIX-SUSE bsc#1202146 FIPS: Set error state when jent init failed in FIPS mode Patch5: gnutls-FIPS-Set-error-state-when-jent-init-failed.patch %endif +%endif #PATCH-FIX-SUSE bsc#1190698 FIPS: SLI gnutls_pbkdf2: verify keylengths and allow SHA only Patch6: gnutls-FIPS-SLI-pbkdf2-verify-keylengths-only-SHA.patch #PATCH-FIX-UPSTREAM bsc#1203779 Make XTS key check failure not fatal Patch7: gnutls-Make-XTS-key-check-failure-not-fatal.patch -#PATCH-FIX-SUSE bsc#1199881 FIPS: Check only the calculated hmac for libgnutls.so.%%{gnutls_sover} -Patch8: gnutls-FIPS-hmac-check-only-libgnutls.patch BuildRequires: autogen BuildRequires: automake BuildRequires: datefudge BuildRequires: fdupes +BuildRequires: fipscheck BuildRequires: gcc-c++ BuildRequires: gtk-doc # The test suite calls /usr/bin/ss from iproute2. It's our own duty to ensure we have it present @@ -257,6 +258,13 @@ autoreconf -fiv %install %make_install + +# Compute FIPS hmac using the brp-50-generate-fips-hmac script +export BRP_FIPSHMAC_FILES=%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover} + +./lib/fipshmac "%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover}" > %{buildroot}%{_libdir}/.gnutls.hmac +sed -i "s^%{buildroot}/usr^^" %{buildroot}%{_libdir}/.gnutls.hmac + rm -rf %{buildroot}%{_datadir}/locale/en@{,bold}quot # Do not package static libs and libtool files find %{buildroot} -type f -name "*.la" -delete -print @@ -275,25 +283,6 @@ rm -rf %{buildroot}%{_datadir}/doc/gnutls %find_lang libgnutls --all-name -# the hmac hashes: -# -# this is a hack that re-defines the __os_install_post macro -# for a simple reason: the macro strips the binaries and thereby -# invalidates a HMAC that may have been created earlier. -# solution: create the hashes _after_ the macro runs. -# -# this shows up earlier because otherwise the %%expand of -# the macro is too late. -# remark: This is the same as running -# openssl dgst -sha256 -hmac 'orboDeJITITejsirpADONivirpUkvarP' -# note: The FIPS hmac is now calculated with an internal tool since -# commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed and the file -# has been renamed to .gnutls.hmac -%{expand:%%global __os_install_post {%__os_install_post -./lib/fipshmac "%{buildroot}%{_libdir}/libgnutls.so.30" > %{buildroot}%{_libdir}/.gnutls.hmac -sed -i "s^%{buildroot}/usr^^" %{buildroot}%{_libdir}/.gnutls.hmac -}} - %check %if ! 0%{?qemu_user_space_build} %make_build check GNUTLS_SYSTEM_PRIORITY_FILE=/dev/null || { @@ -343,6 +332,7 @@ GNUTLS_FORCE_FIPS_MODE=1 make check %{?_smp_mflags} GNUTLS_SYSTEM_PRIORITY_FILE= %files -n libgnutls%{gnutls_sover}-hmac %license LICENSE +%{_libdir}/.libgnutls.so.%{gnutls_sover}*.hmac %{_libdir}/.gnutls.hmac %if %{with dane} From 7d40b4ffcc6ae50a4b257aa7e0f7a1e4be244b6a4402573dc661d5b78a3d87b1 Mon Sep 17 00:00:00 2001 From: Pedro Monreal Gonzalez Date: Tue, 8 Nov 2022 15:56:01 +0000 Subject: [PATCH 5/5] Accepting request 1034572 from home:pmonrealgonzalez:branches:security:tls - Verify only the libgnutls library HMAC [bsc#1199881] * Do not use the brp-50-generate-fips-hmac script as this is now calculated with the internal fipshmac tool. * Add gnutls-verify-library-HMAC.patch - Disable flaky test that fails in s390x architecture: * Add gnutls-disable-flaky-test-dtls-resume.patch - Consolidate the FIPS hmac files [bsc#1203245] * Use the gnutls fipshmac tool instead of the brp-check-suse and rename it to reflect on the library version. - Add a gnutls.rpmlintrc file to remove a hidden-file-or-dir false positive for the FIPS hmac calculation. OBS-URL: https://build.opensuse.org/request/show/1034572 OBS-URL: https://build.opensuse.org/package/show/security:tls/gnutls?expand=0&rev=80 --- gnutls-disable-flaky-test-dtls-resume.patch | 13 ++++++++ gnutls-verify-library-HMAC.patch | 21 +++++++++++++ gnutls.changes | 17 +++++++++-- gnutls.rpmlintrc | 1 + gnutls.spec | 33 +++++++++++++++++---- 5 files changed, 78 insertions(+), 7 deletions(-) create mode 100644 gnutls-disable-flaky-test-dtls-resume.patch create mode 100644 gnutls-verify-library-HMAC.patch create mode 100644 gnutls.rpmlintrc diff --git a/gnutls-disable-flaky-test-dtls-resume.patch b/gnutls-disable-flaky-test-dtls-resume.patch new file mode 100644 index 0000000..6287e1f --- /dev/null +++ b/gnutls-disable-flaky-test-dtls-resume.patch @@ -0,0 +1,13 @@ +Index: gnutls-3.7.8/tests/Makefile.am +=================================================================== +--- gnutls-3.7.8.orig/tests/Makefile.am ++++ gnutls-3.7.8/tests/Makefile.am +@@ -508,7 +508,7 @@ if !WINDOWS + # List of tests not available/functional under windows + # + +-dist_check_SCRIPTS += dtls/dtls.sh dtls/dtls-resume.sh #dtls/dtls-nb ++dist_check_SCRIPTS += dtls/dtls.sh #dtls/dtls-resume.sh #dtls/dtls-nb + + indirect_tests += dtls-stress + diff --git a/gnutls-verify-library-HMAC.patch b/gnutls-verify-library-HMAC.patch new file mode 100644 index 0000000..c706e0f --- /dev/null +++ b/gnutls-verify-library-HMAC.patch @@ -0,0 +1,21 @@ +Index: gnutls-3.7.8/lib/fips.c +=================================================================== +--- gnutls-3.7.8.orig/lib/fips.c ++++ gnutls-3.7.8/lib/fips.c +@@ -402,6 +402,8 @@ static int check_binary_integrity(void) + ret = check_lib_hmac(&file.gnutls, GNUTLS_LIBRARY_NAME, "gnutls_global_init"); + if (ret < 0) + return ret; ++ /* Check only the binary integrity of the libgnutls library */ ++#if 0 + ret = check_lib_hmac(&file.nettle, NETTLE_LIBRARY_NAME, "nettle_aes_set_encrypt_key"); + if (ret < 0) + return ret; +@@ -411,6 +413,7 @@ static int check_binary_integrity(void) + ret = check_lib_hmac(&file.gmp, GMP_LIBRARY_NAME, "__gmpz_init"); + if (ret < 0) + return ret; ++#endif + + return 0; + } diff --git a/gnutls.changes b/gnutls.changes index 20d9a0f..b9d7370 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,15 +1,28 @@ +------------------------------------------------------------------- +Tue Nov 8 12:52:18 UTC 2022 - Pedro Monreal + +- Verify only the libgnutls library HMAC [bsc#1199881] + * Do not use the brp-50-generate-fips-hmac script as this + is now calculated with the internal fipshmac tool. + * Add gnutls-verify-library-HMAC.patch + ------------------------------------------------------------------- Wed Nov 2 20:51:43 UTC 2022 - Pedro Monreal - Temporarily revert the jitterentropy patches in s390 and s390x architectures until a fix is provided [bsc#1204937] +- Disable flaky test that fails in s390x architecture: + * Add gnutls-disable-flaky-test-dtls-resume.patch ------------------------------------------------------------------- Fri Oct 14 11:35:33 UTC 2022 - Pedro Monreal -- Consolidate the FIPS .hmac files [bsc#1199881, bsc#1203245] - * Package the FIPS .hmac files +- Consolidate the FIPS hmac files [bsc#1203245] + * Use the gnutls fipshmac tool instead of the brp-check-suse + and rename it to reflect on the library version. * Remove not needed gnutls-FIPS-Run-CFB8-without-offset.patch +- Add a gnutls.rpmlintrc file to remove a hidden-file-or-dir false + positive for the FIPS hmac calculation. ------------------------------------------------------------------- Sun Oct 9 12:53:27 UTC 2022 - Pedro Monreal diff --git a/gnutls.rpmlintrc b/gnutls.rpmlintrc new file mode 100644 index 0000000..1272ac8 --- /dev/null +++ b/gnutls.rpmlintrc @@ -0,0 +1 @@ +addFilter("hidden-file-or-dir /usr/lib64/.libgnutls.so.30.hmac") diff --git a/gnutls.spec b/gnutls.spec index 585ab48..6ff912a 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -47,6 +47,8 @@ Source1: https://www.gnupg.org/ftp/gcrypt/gnutls/v3.7/%{name}-%{version}. # https://gnutls.org/gnutls-release-keyring.gpg Source2: gnutls.keyring Source3: baselibs.conf +# Suppress a false positive on the .hmac file +Source4: gnutls.rpmlintrc Patch0: gnutls-3.5.11-skip-trust-store-tests.patch Patch1: gnutls-FIPS-TLS_KDF_selftest.patch Patch2: gnutls-FIPS-disable-failing-tests.patch @@ -63,6 +65,9 @@ Patch5: gnutls-FIPS-Set-error-state-when-jent-init-failed.patch Patch6: gnutls-FIPS-SLI-pbkdf2-verify-keylengths-only-SHA.patch #PATCH-FIX-UPSTREAM bsc#1203779 Make XTS key check failure not fatal Patch7: gnutls-Make-XTS-key-check-failure-not-fatal.patch +Patch8: gnutls-disable-flaky-test-dtls-resume.patch +#PATCH-FIX-OPENSUSE bsc#1199881 Verify only the libgnutls library HMAC +Patch9: gnutls-verify-library-HMAC.patch BuildRequires: autogen BuildRequires: automake BuildRequires: datefudge @@ -224,6 +229,10 @@ export LDFLAGS="-pie -Wl,-z,now -Wl,-z,relro" export CFLAGS="%{optflags} -fPIE" export CXXFLAGS="%{optflags} -fPIE" autoreconf -fiv + +# Rename the internal .hmac file to include the so library version +sed -i "s/\.gnutls\.hmac/\.libgnutls\.so\.%{gnutls_sover}\.hmac/g" lib/Makefile.am lib/Makefile.in lib/fips.c + %configure \ gl_cv_func_printf_directive_n=yes \ gl_cv_func_printf_infinite_long_double=yes \ @@ -259,11 +268,26 @@ autoreconf -fiv %install %make_install -# Compute FIPS hmac using the brp-50-generate-fips-hmac script -export BRP_FIPSHMAC_FILES=%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover} +# Compute the FIPS hmac using the brp-50-generate-fips-hmac script +# export BRP_FIPSHMAC_FILES=%%{buildroot}%%{_libdir}/libgnutls.so.%%{gnutls_sover} -./lib/fipshmac "%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover}" > %{buildroot}%{_libdir}/.gnutls.hmac -sed -i "s^%{buildroot}/usr^^" %{buildroot}%{_libdir}/.gnutls.hmac +# the hmac hashes: +# +# this is a hack that re-defines the __os_install_post macro +# for a simple reason: the macro strips the binaries and thereby +# invalidates a HMAC that may have been created earlier. +# solution: create the hashes _after_ the macro runs. +# +# this shows up earlier because otherwise the %%expand of +# the macro is too late. +# remark: This is the same as running +# openssl dgst -sha256 -hmac 'orboDeJITITejsirpADONivirpUkvarP' +# note: The FIPS hmac is now calculated with an internal tool since +# commit a86c8e87189e23920ae622da5e572cb4e1a6e0ed +%{expand:%%global __os_install_post {%__os_install_post +./lib/fipshmac "%{buildroot}%{_libdir}/libgnutls.so.%{gnutls_sover}" > %{buildroot}%{_libdir}/.libgnutls.so.%{gnutls_sover}.hmac +sed -i "s^%{buildroot}/usr^^" %{buildroot}%{_libdir}/.libgnutls.so.%{gnutls_sover}.hmac +}} rm -rf %{buildroot}%{_datadir}/locale/en@{,bold}quot # Do not package static libs and libtool files @@ -333,7 +357,6 @@ GNUTLS_FORCE_FIPS_MODE=1 make check %{?_smp_mflags} GNUTLS_SYSTEM_PRIORITY_FILE= %files -n libgnutls%{gnutls_sover}-hmac %license LICENSE %{_libdir}/.libgnutls.so.%{gnutls_sover}*.hmac -%{_libdir}/.gnutls.hmac %if %{with dane} %files -n libgnutls-dane%{gnutls_dane_sover}