diff --git a/automake-1.12.patch b/automake-1.12.patch index 53baf6e..02f1160 100644 --- a/automake-1.12.patch +++ b/automake-1.12.patch @@ -1,20 +1,8 @@ -Index: gnutls-3.0.20/configure.ac +Index: gnutls-3.2.1/aclocal.m4 =================================================================== ---- gnutls-3.0.20.orig/configure.ac 2012-07-01 21:50:17.000000000 +0200 -+++ gnutls-3.0.20/configure.ac 2012-07-01 21:50:17.977499968 +0200 -@@ -37,6 +37,7 @@ dnl Checks for programs. - AC_PROG_CC - AM_PROG_AS - AC_PROG_CXX -+AM_PROG_AR - gl_EARLY - - # For includes/gnutls/gnutls.h.in. -Index: gnutls-3.0.20/aclocal.m4 -=================================================================== ---- gnutls-3.0.20.orig/aclocal.m4 2012-06-05 19:10:14.000000000 +0200 -+++ gnutls-3.0.20/aclocal.m4 2012-07-01 21:53:42.821893323 +0200 -@@ -529,7 +529,7 @@ AM_MISSING_PROG(AUTOHEADER, autoheader) +--- gnutls-3.2.1.orig/aclocal.m4 ++++ gnutls-3.2.1/aclocal.m4 +@@ -517,7 +517,7 @@ AM_MISSING_PROG(AUTOHEADER, autoheader) AM_MISSING_PROG(MAKEINFO, makeinfo) AC_REQUIRE([AM_PROG_INSTALL_SH])dnl AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl @@ -23,7 +11,7 @@ Index: gnutls-3.0.20/aclocal.m4 # We need awk for the "check" target. The system "awk" is bad on # some platforms. AC_REQUIRE([AC_PROG_AWK])dnl -@@ -773,10 +773,10 @@ fi +@@ -761,10 +761,10 @@ fi # serial 1 @@ -36,11 +24,11 @@ Index: gnutls-3.0.20/aclocal.m4 [AC_PREREQ([2.60])dnl AC_REQUIRE([AC_PROG_MKDIR_P])dnl dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P, -Index: gnutls-3.0.20/gl/m4/gnulib-common.m4 +Index: gnutls-3.2.1/gl/m4/gnulib-common.m4 =================================================================== ---- gnutls-3.0.20.orig/gl/m4/gnulib-common.m4 2012-06-05 19:07:51.000000000 +0200 -+++ gnutls-3.0.20/gl/m4/gnulib-common.m4 2012-07-01 21:53:42.821893323 +0200 -@@ -301,7 +301,7 @@ m4_ifdef([AC_PROG_MKDIR_P], [ +--- gnutls-3.2.1.orig/gl/m4/gnulib-common.m4 ++++ gnutls-3.2.1/gl/m4/gnulib-common.m4 +@@ -303,7 +303,7 @@ m4_ifdef([AC_PROG_MKDIR_P], [ AC_SUBST([MKDIR_P])])], [ dnl For autoconf < 2.60: Backport of AC_PROG_MKDIR_P. AC_DEFUN_ONCE([AC_PROG_MKDIR_P], @@ -48,11 +36,11 @@ Index: gnutls-3.0.20/gl/m4/gnulib-common.m4 + [AC_REQUIRE([AC_PROG_MKDIR_P])dnl defined by automake MKDIR_P='$(mkdir_p)' AC_SUBST([MKDIR_P])])]) - -Index: gnutls-3.0.20/m4/po.m4 + ]) +Index: gnutls-3.2.1/m4/po.m4 =================================================================== ---- gnutls-3.0.20.orig/m4/po.m4 2011-11-08 22:07:12.000000000 +0100 -+++ gnutls-3.0.20/m4/po.m4 2012-07-01 21:53:42.822893277 +0200 +--- gnutls-3.2.1.orig/m4/po.m4 ++++ gnutls-3.2.1/m4/po.m4 @@ -24,7 +24,7 @@ AC_DEFUN([AM_PO_SUBDIRS], [ AC_REQUIRE([AC_PROG_MAKE_SET])dnl diff --git a/gnutls-3.0.28.tar.xz b/gnutls-3.0.28.tar.xz deleted file mode 100644 index ef6f599..0000000 --- a/gnutls-3.0.28.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:9ba12ae7a3eb122f1d5ee897ed910abd5a1a84b84dc0333ef977f0b1692d1993 -size 4636572 diff --git a/gnutls-3.2.1-noecc.patch b/gnutls-3.2.1-noecc.patch new file mode 100644 index 0000000..db4835f --- /dev/null +++ b/gnutls-3.2.1-noecc.patch @@ -0,0 +1,711 @@ +Index: gnutls-3.2.1/lib/algorithms/kx.c +=================================================================== +--- gnutls-3.2.1.orig/lib/algorithms/kx.c ++++ gnutls-3.2.1/lib/algorithms/kx.c +@@ -28,9 +28,11 @@ + + extern mod_auth_st rsa_auth_struct; + extern mod_auth_st dhe_rsa_auth_struct; ++#ifdef ENABLE_ECC + extern mod_auth_st ecdhe_rsa_auth_struct; + extern mod_auth_st ecdhe_psk_auth_struct; + extern mod_auth_st ecdhe_ecdsa_auth_struct; ++#endif + extern mod_auth_st dhe_dss_auth_struct; + extern mod_auth_st anon_auth_struct; + extern mod_auth_st anon_ecdh_auth_struct; +@@ -57,8 +59,10 @@ static const gnutls_cred_map cred_mappin + {GNUTLS_KX_ANON_DH, GNUTLS_CRD_ANON, GNUTLS_CRD_ANON}, + {GNUTLS_KX_ANON_ECDH, GNUTLS_CRD_ANON, GNUTLS_CRD_ANON}, + {GNUTLS_KX_RSA, GNUTLS_CRD_CERTIFICATE, GNUTLS_CRD_CERTIFICATE}, ++#ifdef ENABLE_ECC + {GNUTLS_KX_ECDHE_RSA, GNUTLS_CRD_CERTIFICATE, GNUTLS_CRD_CERTIFICATE}, + {GNUTLS_KX_ECDHE_ECDSA, GNUTLS_CRD_CERTIFICATE, GNUTLS_CRD_CERTIFICATE}, ++#endif + {GNUTLS_KX_DHE_DSS, GNUTLS_CRD_CERTIFICATE, GNUTLS_CRD_CERTIFICATE}, + {GNUTLS_KX_DHE_RSA, GNUTLS_CRD_CERTIFICATE, GNUTLS_CRD_CERTIFICATE}, + {GNUTLS_KX_PSK, GNUTLS_CRD_PSK, GNUTLS_CRD_PSK}, +@@ -98,7 +102,7 @@ static const gnutls_kx_algo_entry _gnutl + {"DHE-RSA", GNUTLS_KX_DHE_RSA, &dhe_rsa_auth_struct, 1}, + {"DHE-DSS", GNUTLS_KX_DHE_DSS, &dhe_dss_auth_struct, 1}, + #endif +-#ifdef ENABLE_ECDHE ++#if defined(ENABLE_ECDHE) && defined(ENABLE_ECC) + {"ECDHE-RSA", GNUTLS_KX_ECDHE_RSA, &ecdhe_rsa_auth_struct, 0}, + {"ECDHE-ECDSA", GNUTLS_KX_ECDHE_ECDSA, &ecdhe_ecdsa_auth_struct, 0}, + #endif +@@ -113,7 +117,7 @@ static const gnutls_kx_algo_entry _gnutl + {"DHE-PSK", GNUTLS_KX_DHE_PSK, &dhe_psk_auth_struct, + 1 /* needs DHE params */}, + # endif +-# ifdef ENABLE_ECDHE ++# if defined(ENABLE_ECDHE) && defined(ENABLE_ECC) + {"ECDHE-PSK", GNUTLS_KX_ECDHE_PSK, &ecdhe_psk_auth_struct, 0}, + # endif + #endif +Index: gnutls-3.2.1/lib/algorithms/publickey.c +=================================================================== +--- gnutls-3.2.1.orig/lib/algorithms/publickey.c ++++ gnutls-3.2.1/lib/algorithms/publickey.c +@@ -49,8 +49,10 @@ static const gnutls_pk_map pk_mappings[] + {GNUTLS_KX_RSA, GNUTLS_PK_RSA, CIPHER_ENCRYPT}, + {GNUTLS_KX_DHE_RSA, GNUTLS_PK_RSA, CIPHER_SIGN}, + {GNUTLS_KX_SRP_RSA, GNUTLS_PK_RSA, CIPHER_SIGN}, ++#ifdef ENABLE_ECC + {GNUTLS_KX_ECDHE_RSA, GNUTLS_PK_RSA, CIPHER_SIGN}, + {GNUTLS_KX_ECDHE_ECDSA, GNUTLS_PK_EC, CIPHER_SIGN}, ++#endif + {GNUTLS_KX_DHE_DSS, GNUTLS_PK_DSA, CIPHER_SIGN}, + {GNUTLS_KX_SRP_DSS, GNUTLS_PK_DSA, CIPHER_SIGN}, + {0, 0, 0} +@@ -96,7 +98,9 @@ static const gnutls_pk_entry pk_algorith + {"DSA", PK_DSA_OID, GNUTLS_PK_DSA}, + {"GOST R 34.10-2001", PK_GOST_R3410_2001_OID, GNUTLS_PK_UNKNOWN}, + {"GOST R 34.10-94", PK_GOST_R3410_94_OID, GNUTLS_PK_UNKNOWN}, ++#ifdef ENABLE_ECC + {"EC", "1.2.840.10045.2.1", GNUTLS_PK_EC}, ++#endif + {0, 0, 0} + }; + +Index: gnutls-3.2.1/lib/algorithms/sign.c +=================================================================== +--- gnutls-3.2.1.orig/lib/algorithms/sign.c ++++ gnutls-3.2.1/lib/algorithms/sign.c +@@ -43,6 +43,14 @@ typedef struct gnutls_sign_entry gnutls_ + #define TLS_SIGN_AID_UNKNOWN {255, 255} + static const sign_algorithm_st unknown_tls_aid = TLS_SIGN_AID_UNKNOWN; + ++#ifndef ENABLE_ECC ++#define GNUTLS_SIGN_ECDSA_SHA1 0 ++#define GNUTLS_SIGN_ECDSA_SHA224 0 ++#define GNUTLS_SIGN_ECDSA_SHA256 0 ++#define GNUTLS_SIGN_ECDSA_SHA384 0 ++#define GNUTLS_SIGN_ECDSA_SHA512 0 ++#endif ++ + static const gnutls_sign_entry sign_algorithms[] = { + {"RSA-SHA1", SIG_RSA_SHA1_OID, GNUTLS_SIGN_RSA_SHA1, GNUTLS_PK_RSA, + GNUTLS_DIG_SHA1, {2, 1}}, +Index: gnutls-3.2.1/lib/auth/cert.c +=================================================================== +--- gnutls-3.2.1.orig/lib/auth/cert.c ++++ gnutls-3.2.1/lib/auth/cert.c +@@ -63,7 +63,11 @@ static gnutls_privkey_t alloc_and_load_p + key, int deinit); + #endif + ++#ifdef ENABLE_ECC + #define MAX_CLIENT_SIGN_ALGOS 3 ++#else ++#define MAX_CLIENT_SIGN_ALGOS 2 ++#endif + #define CERTTYPE_SIZE (MAX_CLIENT_SIGN_ALGOS+1) + typedef enum CertificateSigType + { RSA_SIGN = 1, DSA_SIGN = 2, ECDSA_SIGN = 64 +@@ -1438,8 +1442,10 @@ _gnutls_check_supported_sign_algo (Certi + return GNUTLS_PK_RSA; + case DSA_SIGN: + return GNUTLS_PK_DSA; ++#ifdef ENABLE_ECC + case ECDSA_SIGN: + return GNUTLS_PK_EC; ++#endif + } + + return -1; +@@ -1726,7 +1732,9 @@ _gnutls_gen_cert_server_cert_req (gnutls + tmp_data[0] = CERTTYPE_SIZE - 1; + tmp_data[1] = RSA_SIGN; + tmp_data[2] = DSA_SIGN; ++#ifdef ENABLE_ECC + tmp_data[3] = ECDSA_SIGN; /* only these for now */ ++#endif + + ret = _gnutls_buffer_append_data (data, tmp_data, CERTTYPE_SIZE); + if (ret < 0) +Index: gnutls-3.2.1/lib/auth/dhe_psk.c +=================================================================== +--- gnutls-3.2.1.orig/lib/auth/dhe_psk.c ++++ gnutls-3.2.1/lib/auth/dhe_psk.c +@@ -92,6 +92,7 @@ const mod_auth_st ecdhe_psk_auth_struct + }; + #endif + ++#ifdef ENABLE_ECDHE + static int + gen_ecdhe_psk_client_kx (gnutls_session_t session, gnutls_buffer_st* data) + { +@@ -135,6 +136,7 @@ cleanup: + + return ret; + } ++#endif + + static int + gen_dhe_psk_client_kx (gnutls_session_t session, gnutls_buffer_st* data) +@@ -230,6 +232,7 @@ gen_dhe_psk_server_kx (gnutls_session_t + return ret; + } + ++#ifdef ENABLE_ECDHE + static int + gen_ecdhe_psk_server_kx (gnutls_session_t session, gnutls_buffer_st* data) + { +@@ -254,7 +257,7 @@ gen_ecdhe_psk_server_kx (gnutls_session_ + + return ret; + } +- ++#endif + + static int + proc_dhe_psk_client_kx (gnutls_session_t session, uint8_t * data, +@@ -335,6 +338,7 @@ proc_dhe_psk_client_kx (gnutls_session_t + + } + ++#ifdef ENABLE_ECDHE + static int + proc_ecdhe_psk_client_kx (gnutls_session_t session, uint8_t * data, + size_t _data_size) +@@ -399,6 +403,7 @@ proc_ecdhe_psk_client_kx (gnutls_session + + return ret; + } ++#endif + + static int + proc_dhe_psk_server_kx (gnutls_session_t session, uint8_t * data, +@@ -432,6 +437,7 @@ proc_dhe_psk_server_kx (gnutls_session_t + return 0; + } + ++#ifdef ENABLE_ECDHE + static int + proc_ecdhe_psk_server_kx (gnutls_session_t session, uint8_t * data, + size_t _data_size) +@@ -463,5 +469,6 @@ proc_ecdhe_psk_server_kx (gnutls_session + + return 0; + } ++#endif + + #endif /* ENABLE_PSK */ +Index: gnutls-3.2.1/lib/ext/ecc.c +=================================================================== +--- gnutls-3.2.1.orig/lib/ext/ecc.c ++++ gnutls-3.2.1/lib/ext/ecc.c +@@ -35,6 +35,7 @@ + /* Maps record size to numbers according to the + * extensions draft. + */ ++#ifdef ENABLE_ECC + + static int _gnutls_supported_ecc_recv_params (gnutls_session_t session, + const uint8_t * data, +@@ -269,3 +270,5 @@ _gnutls_session_supports_ecc_curve (gnut + + return GNUTLS_E_ECC_UNSUPPORTED_CURVE; + } ++ ++#endif +Index: gnutls-3.2.1/lib/gnutls_extensions.c +=================================================================== +--- gnutls-3.2.1.orig/lib/gnutls_extensions.c ++++ gnutls-3.2.1/lib/gnutls_extensions.c +@@ -351,6 +351,7 @@ _gnutls_ext_init (void) + if (ret != GNUTLS_E_SUCCESS) + return ret; + ++#ifdef ENABLE_ECC + ret = _gnutls_ext_register (&ext_mod_supported_ecc); + if (ret != GNUTLS_E_SUCCESS) + return ret; +@@ -358,6 +359,7 @@ _gnutls_ext_init (void) + ret = _gnutls_ext_register (&ext_mod_supported_ecc_pf); + if (ret != GNUTLS_E_SUCCESS) + return ret; ++#endif + + ret = _gnutls_ext_register (&ext_mod_sig); + if (ret != GNUTLS_E_SUCCESS) +Index: gnutls-3.2.1/lib/gnutls_priority.c +=================================================================== +--- gnutls-3.2.1.orig/lib/gnutls_priority.c ++++ gnutls-3.2.1/lib/gnutls_priority.c +@@ -245,35 +245,45 @@ gnutls_certificate_type_set_priority (gn + } + + static const int supported_ecc_normal[] = { ++#ifdef ENABLE_ECC + GNUTLS_ECC_CURVE_SECP192R1, + GNUTLS_ECC_CURVE_SECP224R1, + GNUTLS_ECC_CURVE_SECP256R1, + GNUTLS_ECC_CURVE_SECP384R1, + GNUTLS_ECC_CURVE_SECP521R1, ++#endif + 0 + }; + + static const int supported_ecc_secure128[] = { ++#ifdef ENABLE_ECC + GNUTLS_ECC_CURVE_SECP256R1, + GNUTLS_ECC_CURVE_SECP384R1, + GNUTLS_ECC_CURVE_SECP521R1, ++#endif + 0 + }; + + static const int supported_ecc_suiteb128[] = { ++#ifdef ENABLE_ECC + GNUTLS_ECC_CURVE_SECP256R1, + GNUTLS_ECC_CURVE_SECP384R1, ++#endif + 0 + }; + + static const int supported_ecc_suiteb192[] = { ++#ifdef ENABLE_ECC + GNUTLS_ECC_CURVE_SECP384R1, ++#endif + 0 + }; + + static const int supported_ecc_secure192[] = { ++#ifdef ENABLE_ECC + GNUTLS_ECC_CURVE_SECP384R1, + GNUTLS_ECC_CURVE_SECP521R1, ++#endif + 0 + }; + +@@ -458,51 +468,75 @@ static const int comp_priority[] = { + static const int sign_priority_default[] = { + GNUTLS_SIGN_RSA_SHA256, + GNUTLS_SIGN_DSA_SHA256, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA256, ++#endif + + GNUTLS_SIGN_RSA_SHA384, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA384, ++#endif + + GNUTLS_SIGN_RSA_SHA512, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA512, ++#endif + + GNUTLS_SIGN_RSA_SHA224, + GNUTLS_SIGN_DSA_SHA224, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA224, ++#endif + + GNUTLS_SIGN_RSA_SHA1, + GNUTLS_SIGN_DSA_SHA1, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA1, ++#endif + 0 + }; + + static const int sign_priority_suiteb128[] = { ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA256, + GNUTLS_SIGN_ECDSA_SHA384, ++#endif + 0 + }; + + static const int sign_priority_suiteb192[] = { ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA384, ++#endif + 0 + }; + + static const int sign_priority_secure128[] = { + GNUTLS_SIGN_RSA_SHA256, + GNUTLS_SIGN_DSA_SHA256, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA256, ++#endif + GNUTLS_SIGN_RSA_SHA384, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA384, ++#endif + GNUTLS_SIGN_RSA_SHA512, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA512, ++#endif + 0 + }; + + static const int sign_priority_secure192[] = { + GNUTLS_SIGN_RSA_SHA384, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA384, ++#endif + GNUTLS_SIGN_RSA_SHA512, ++#ifdef ENABLE_ECC + GNUTLS_SIGN_ECDSA_SHA512, ++#endif + 0 + }; + +Index: gnutls-3.2.1/lib/nettle/pk.c +=================================================================== +--- gnutls-3.2.1.orig/lib/nettle/pk.c ++++ gnutls-3.2.1/lib/nettle/pk.c +@@ -146,6 +146,7 @@ static int _wrap_nettle_pk_derive(gnutls + + switch (algo) + { ++#ifdef ENABLE_ECC + case GNUTLS_PK_EC: + { + struct ecc_scalar ecc_priv; +@@ -186,6 +187,7 @@ ecc_cleanup: + if (ret < 0) goto cleanup; + break; + } ++#endif + default: + gnutls_assert (); + ret = GNUTLS_E_INTERNAL_ERROR; +@@ -330,6 +332,7 @@ _wrap_nettle_pk_sign (gnutls_pk_algorith + + switch (algo) + { ++#ifdef ENABLE_ECC + case GNUTLS_PK_EC: /* we do ECDSA */ + { + struct ecc_scalar priv; +@@ -369,6 +372,7 @@ _wrap_nettle_pk_sign (gnutls_pk_algorith + } + break; + } ++#endif + case GNUTLS_PK_DSA: + { + struct dsa_public_key pub; +@@ -470,6 +474,7 @@ _wrap_nettle_pk_verify (gnutls_pk_algori + + switch (algo) + { ++#ifdef ENABLE_ECC + case GNUTLS_PK_EC: /* ECDSA */ + { + struct ecc_point pub; +@@ -511,6 +516,7 @@ _wrap_nettle_pk_verify (gnutls_pk_algori + ecc_point_clear( &pub); + break; + } ++#endif + case GNUTLS_PK_DSA: + { + struct dsa_public_key pub; +@@ -717,6 +723,7 @@ rsa_fail: + + break; + } ++#ifdef ENABLE_ECC + case GNUTLS_PK_EC: + { + struct ecc_scalar key; +@@ -757,6 +764,7 @@ ecc_cleanup: + + break; + } ++#endif + default: + gnutls_assert (); + return GNUTLS_E_INVALID_REQUEST; +@@ -873,6 +881,7 @@ dsa_cleanup: + } + + break; ++#ifdef ENABLE_ECC + case GNUTLS_PK_EC: + { + struct ecc_point r, pub; +@@ -934,6 +943,7 @@ ecc_cleanup: + ecc_point_clear(&pub); + } + break; ++#endif + default: + ret = gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } +Index: gnutls-3.2.1/tests/cert-tests/dane +=================================================================== +--- gnutls-3.2.1.orig/tests/cert-tests/dane ++++ gnutls-3.2.1/tests/cert-tests/dane +@@ -22,6 +22,8 @@ + + set -e + ++exit 77 ++ + srcdir=${srcdir:-.} + DANETOOL=${DANETOOL:-../../src/danetool$EXEEXT} + +Index: gnutls-3.2.1/tests/dtls/dtls-nb +=================================================================== +--- gnutls-3.2.1.orig/tests/dtls/dtls-nb ++++ gnutls-3.2.1/tests/dtls/dtls-nb +@@ -22,9 +22,7 @@ + + set -e + +-if test "${WINDIR}" != "";then +- exit 77 +-fi ++exit 77 + + ./dtls-stress -nb -shello 021 -sfinished 01 -cfinished 012 SKeyExchange CKeyExchange CFinished + ./dtls-stress -nb -shello 012 -sfinished 10 -cfinished 210 SHello SKeyExchange SHelloDone +Index: gnutls-3.2.1/tests/dtls/dtls +=================================================================== +--- gnutls-3.2.1.orig/tests/dtls/dtls ++++ gnutls-3.2.1/tests/dtls/dtls +@@ -22,9 +22,7 @@ + + set -e + +-if test "${WINDIR}" != "";then +- exit 77 +-fi ++exit 77 + + ./dtls-stress -shello 021 -sfinished 01 -cfinished 012 SKeyExchange CKeyExchange CFinished + ./dtls-stress -shello 012 -sfinished 10 -cfinished 210 SHello SKeyExchange SHelloDone +Index: gnutls-3.2.1/tests/ecdsa/ecdsa +=================================================================== +--- gnutls-3.2.1.orig/tests/ecdsa/ecdsa ++++ gnutls-3.2.1/tests/ecdsa/ecdsa +@@ -22,6 +22,8 @@ + + #set -e + ++exit 77 ++ + srcdir=${srcdir:-.} + CERTTOOL=${CERTTOOL:-../../src/certtool$EXEEXT} + +Index: gnutls-3.2.1/tests/mini-dtls-heartbeat.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-dtls-heartbeat.c ++++ gnutls-3.2.1/tests/mini-dtls-heartbeat.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) || !defined(ENABLE_HEARTBEAT) ++#if defined(_WIN32) || !defined(ENABLE_HEARTBEAT) || !defined(ENABLE_ECC) + + int + main () +Index: gnutls-3.2.1/tests/mini-dtls-record.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-dtls-record.c ++++ gnutls-3.2.1/tests/mini-dtls-record.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int + main () +Index: gnutls-3.2.1/tests/mini-dtls-rehandshake.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-dtls-rehandshake.c ++++ gnutls-3.2.1/tests/mini-dtls-rehandshake.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +Index: gnutls-3.2.1/tests/mini-dtls-srtp.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-dtls-srtp.c ++++ gnutls-3.2.1/tests/mini-dtls-srtp.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) || !defined(ENABLE_DTLS_SRTP) ++#if defined(_WIN32) || !defined(ENABLE_DTLS_SRTP) || !defined(ENABLE_ECC) + + int + main (int argc, char** argv) +Index: gnutls-3.2.1/tests/mini-handshake-timeout.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-handshake-timeout.c ++++ gnutls-3.2.1/tests/mini-handshake-timeout.c +@@ -28,7 +28,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +@@ -142,7 +142,11 @@ initialize_tls_session (gnutls_session_t + /* avoid calling all the priority functions, since the defaults + * are adequate. + */ +- gnutls_priority_set_direct (*session, "NORMAL:+ANON-ECDH", NULL); ++#ifdef ENABLE_ECC ++ gnutls_priority_set_direct (session, "NORMAL:+ANON-ECDH", NULL); ++#else ++ gnutls_priority_set_direct (session, "NORMAL:+ANON-DH", NULL); ++#endif + } + + static void +Index: gnutls-3.2.1/tests/mini-loss-time.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-loss-time.c ++++ gnutls-3.2.1/tests/mini-loss-time.c +@@ -28,7 +28,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +Index: gnutls-3.2.1/tests/mini-record.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-record.c ++++ gnutls-3.2.1/tests/mini-record.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +Index: gnutls-3.2.1/tests/mini-record-range.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-record-range.c ++++ gnutls-3.2.1/tests/mini-record-range.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +Index: gnutls-3.2.1/tests/mini-xssl.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-xssl.c ++++ gnutls-3.2.1/tests/mini-xssl.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECC) + + int main() + { +Index: gnutls-3.2.1/tests/pkcs12_simple.c +=================================================================== +--- gnutls-3.2.1.orig/tests/pkcs12_simple.c ++++ gnutls-3.2.1/tests/pkcs12_simple.c +@@ -50,6 +50,10 @@ doit (void) + gnutls_x509_privkey_t pkey; + int ret; + ++#ifndef ENABLE_ECC ++ exit(77); ++#endif ++ + ret = global_init (); + if (ret < 0) + fail ("global_init failed %d\n", ret); +Index: gnutls-3.2.1/tests/slow/keygen.c +=================================================================== +--- gnutls-3.2.1.orig/tests/slow/keygen.c ++++ gnutls-3.2.1/tests/slow/keygen.c +@@ -65,6 +65,11 @@ doit (void) + if (algorithm == GNUTLS_PK_DH) + continue; + ++#ifndef ENABLE_ECC ++ if (algorithm == GNUTLS_PK_EC) ++ continue; ++#endif ++ + ret = gnutls_x509_privkey_init (&pkey); + if (ret < 0) + { +Index: gnutls-3.2.1/tests/srp/mini-srp.c +=================================================================== +--- gnutls-3.2.1.orig/tests/srp/mini-srp.c ++++ gnutls-3.2.1/tests/srp/mini-srp.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_SRP) + + int main() + { +Index: gnutls-3.2.1/lib/auth/ecdhe.c +=================================================================== +--- gnutls-3.2.1.orig/lib/auth/ecdhe.c ++++ gnutls-3.2.1/lib/auth/ecdhe.c +@@ -50,7 +50,7 @@ static int + proc_ecdhe_client_kx (gnutls_session_t session, + uint8_t * data, size_t _data_size); + +-#if defined(ENABLE_ECDHE) ++#if defined(ENABLE_ECDHE) && defined(ENABLE_ECC) + const mod_auth_st ecdhe_ecdsa_auth_struct = { + "ECDHE_ECDSA", + _gnutls_gen_cert_server_crt, +Index: gnutls-3.2.1/tests/mini-dtls-hello-verify.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-dtls-hello-verify.c ++++ gnutls-3.2.1/tests/mini-dtls-hello-verify.c +@@ -27,7 +27,7 @@ + #include + #include + +-#if defined(_WIN32) ++#if defined(_WIN32) || !defined(ENABLE_ECDH) + + int main() + { +Index: gnutls-3.2.1/tests/mini-alpn.c +=================================================================== +--- gnutls-3.2.1.orig/tests/mini-alpn.c ++++ gnutls-3.2.1/tests/mini-alpn.c +@@ -25,7 +25,7 @@ + #include + #include + +-#if defined(_WIN32) || !defined(ENABLE_ALPN) ++#if defined(_WIN32) || !defined(ENABLE_ALPN) || !defined(ENABLE_ECDH) + + int + main (int argc, char** argv) diff --git a/gnutls-3.2.1.tar.xz b/gnutls-3.2.1.tar.xz new file mode 100644 index 0000000..fb3f89b --- /dev/null +++ b/gnutls-3.2.1.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abfa8165947837ada2363355ada25d913f48e6bb261f0a67f20d2fb6079e22fe +size 5127332 diff --git a/gnutls-3.2.1.tar.xz.sig b/gnutls-3.2.1.tar.xz.sig new file mode 100644 index 0000000..c8ebaca Binary files /dev/null and b/gnutls-3.2.1.tar.xz.sig differ diff --git a/gnutls-32bit.patch b/gnutls-32bit.patch new file mode 100644 index 0000000..19070c5 --- /dev/null +++ b/gnutls-32bit.patch @@ -0,0 +1,35 @@ +From b12040aeab5fbaf02677571db1d8bf1995bd5ee0 Mon Sep 17 00:00:00 2001 +From: Nikos Mavrogiannopoulos +Date: Sun, 2 Jun 2013 12:10:06 +0200 +Subject: [PATCH] Avoid comparing the expiration date to prevent false positive error in 32-bit systems. + +--- + tests/cert-tests/pem-decoding | 6 ++++-- + 1 files changed, 4 insertions(+), 2 deletions(-) + +diff --git a/tests/cert-tests/pem-decoding b/tests/cert-tests/pem-decoding +index fe769ec..f8c6372 100755 +--- a/tests/cert-tests/pem-decoding ++++ b/tests/cert-tests/pem-decoding +@@ -61,7 +61,9 @@ if test "$rc" != "0"; then + exit $rc + fi + +-diff $srcdir/complex-cert.pem tmp-pem.pem ++cat $srcdir/complex-cert.pem |grep -v "Not After:" >tmp1 ++cat $srcdir/tmp-pem.pem |grep -v "Not After:" >tmp2 ++diff tmp1 tmp2 + rc=$? + + if test "$rc" != "0"; then +@@ -69,6 +71,6 @@ if test "$rc" != "0"; then + exit $rc + fi + +-rm -f tmp-pem.pem ++rm -f tmp-pem.pem tmp1 tmp2 + + exit 0 +-- +1.7.1 + diff --git a/gnutls-implement-trust-store-dir.diff b/gnutls-implement-trust-store-dir.diff index ace64d8..e7fb953 100644 --- a/gnutls-implement-trust-store-dir.diff +++ b/gnutls-implement-trust-store-dir.diff @@ -1,33 +1,34 @@ -From a6cef9220ae251e3b8f8d663c5fa7f888e3176d8 Mon Sep 17 00:00:00 2001 -From: Ludwig Nussel -Date: Tue, 8 May 2012 15:47:02 +0200 -Subject: [PATCH gnutls] implement trust store dir - -(since updated as some parts were introduced upstream) - ---- - configure.ac | 18 ++++++++++++- - lib/gnutls_x509.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++- - 2 files changed, 90 insertions(+), 2 deletions(-) - -Index: configure.ac +Index: gnutls-3.2.1/configure.ac =================================================================== ---- configure.ac.orig 2012-11-08 23:05:32.000000000 +0000 -+++ configure.ac 2012-11-16 23:18:51.000000000 +0000 -@@ -301,9 +301,11 @@ AC_ARG_WITH([default-crl-file], +--- gnutls-3.2.1.orig/configure.ac ++++ gnutls-3.2.1/configure.ac +@@ -398,6 +398,25 @@ if test "$with_default_trust_store_file" + with_default_trust_store_file="" + fi + ++AC_ARG_WITH([default-trust-store-dir], ++ [AS_HELP_STRING([--with-default-trust-store-dir=DIRECTORY], ++ [use the given directory as default trust store])], with_default_trust_store_dir="$withval", ++ [if test "$build" = "$host" ; then ++ for i in \ ++ /etc/ssl/certs/ ++ do ++ if test -e $i ; then ++ with_default_trust_store_dir="$i" ++ break ++ fi ++ done ++ fi] ++) ++ ++if test "$with_default_trust_store_dir" = "no";then ++ with_default_trust_store_dir="" ++fi ++ + AC_ARG_WITH([default-crl-file], [AS_HELP_STRING([--with-default-crl-file=FILE], [use the given CRL file as default])]) - --if test "x$with_default_trust_store_pkcs11" = x -a "x$with_default_trust_store_file" = x; then -+if test "x$with_default_trust_store_pkcs11" = x -a "x$with_default_trust_store_file" = x \ -+ -a "x$with_default_trust_store_dir" = x; then - # auto detect http://lists.gnu.org/archive/html/help-gnutls/2012-05/msg00004.html - for i in \ -+ /etc/ssl/certs \ - /etc/ssl/certs/ca-certificates.crt \ - /etc/pki/tls/cert.pem \ - /usr/local/share/certs/ca-root-nss.crt \ -@@ -321,6 +323,11 @@ if test "x$with_default_trust_store_file +@@ -407,6 +426,11 @@ if test "x$with_default_trust_store_file ["$with_default_trust_store_file"], [use the given file default trust store]) fi @@ -39,117 +40,115 @@ Index: configure.ac if test "x$with_default_crl_file" != x; then AC_DEFINE_UNQUOTED([DEFAULT_CRL_FILE], ["$with_default_crl_file"], [use the given CRL file]) -@@ -562,6 +569,7 @@ if features are disabled) +@@ -683,6 +707,7 @@ AC_MSG_NOTICE([System files: - Trust store pkcs: $with_default_trust_store_pkcs11 - Trust store file: $with_default_trust_store_file -+ Trust store dir: $with_default_trust_store_dir - CRL file: $with_default_crl_file + Trust store pkcs: $with_default_trust_store_pkcs11 + Trust store file: $with_default_trust_store_file ++ Trust store dir: $with_default_trust_store_dir + CRL file: $with_default_crl_file + DNSSEC root key file: $unbound_root_key_file ]) - -Index: lib/gnutls_x509.c +Index: gnutls-3.2.1/lib/system.c =================================================================== ---- lib/gnutls_x509.c.orig 2012-09-22 01:01:26.000000000 +0100 -+++ lib/gnutls_x509.c 2012-11-16 23:16:31.000000000 +0000 -@@ -36,6 +36,7 @@ - #include - #include - #include -+#include - #include - #include - #include "x509/common.h" -@@ -1694,6 +1695,72 @@ set_x509_system_trust_file (gnutls_certi +--- gnutls-3.2.1.orig/lib/system.c ++++ gnutls-3.2.1/lib/system.c +@@ -385,7 +385,45 @@ const char *home_dir = getenv ("HOME"); + return 0; } - #endif -+#ifdef DEFAULT_TRUST_STORE_DIR -+static int -+_gnutls_certificate_set_x509_system_trust_dir (gnutls_certificate_credentials_t cred) +-#if defined(DEFAULT_TRUST_STORE_FILE) || (defined(DEFAULT_TRUST_STORE_PKCS11) && defined(ENABLE_PKCS11)) ++/* Used by both Android code and by Linux TRUST_STORE_DIR /etc/ssl/certs code */ ++#if defined(DEFAULT_TRUST_STORE_DIR) || defined(ANDROID) || defined(__ANDROID__) ++# include ++# include ++static int load_dir_certs(const char* dirname, gnutls_x509_trust_list_t list, ++ unsigned int tl_flags, unsigned int tl_vflags, unsigned type) +{ -+ DIR* dir; -+ struct dirent* buf, *de; -+ int ret, r = 0; -+ gnutls_datum_t cas; -+ size_t size; -+ char cafile[PATH_MAX]; ++DIR * dirp; ++struct dirent *d; ++int ret; ++int r = 0; ++char path[GNUTLS_PATH_MAX]; + -+ dir = opendir(DEFAULT_TRUST_STORE_DIR); -+ if (dir == NULL) ++ dirp = opendir(dirname); ++ if (dirp != NULL) + { -+ gnutls_assert (); -+ return GNUTLS_E_FILE_ERROR; ++ do ++ { ++ d = readdir(dirp); ++ if (d != NULL && d->d_type == DT_REG) ++ { ++ snprintf(path, sizeof(path), "%s/%s", dirname, d->d_name); ++ ++ ret = gnutls_x509_trust_list_add_trust_file(list, path, NULL, type, tl_flags, tl_vflags); ++ if (ret >= 0) ++ r += ret; ++ } ++ } ++ while(d != NULL); ++ closedir(dirp); + } -+ -+ buf = alloca(offsetof(struct dirent, d_name) + pathconf(DEFAULT_TRUST_STORE_DIR, _PC_NAME_MAX) + 1); -+ -+ while (1) -+ { -+ if (readdir_r(dir, buf, &de)) -+ { -+ gnutls_assert(); -+ break; -+ } -+ if (de == NULL) -+ { -+ break; -+ } -+ if (strlen(de->d_name) < 4 || strcmp(de->d_name+strlen(de->d_name)-4, ".pem")) -+ { -+ continue; -+ } -+ -+ strcpy(cafile, DEFAULT_TRUST_STORE_DIR "/"); -+ strncat(cafile, de->d_name, sizeof(cafile)-strlen(cafile)-1); -+ cas.data = (void*)read_binary_file (cafile, &size); -+ if (cas.data == NULL) -+ { -+ gnutls_assert (); -+ continue; -+ } -+ -+ cas.size = size; -+ -+ ret = gnutls_certificate_set_x509_trust_mem(cred, &cas, GNUTLS_X509_FMT_PEM); -+ -+ free (cas.data); -+ -+ if (ret < 0) -+ { -+ gnutls_assert (); -+ } -+ else -+ { -+ r += ret; -+ } -+ } -+ closedir(dir); -+ ++ + return r; +} +#endif + - /** - * gnutls_certificate_set_x509_system_trust: - * @cred: is a #gnutls_certificate_credentials_t structure. -@@ -1712,7 +1779,7 @@ set_x509_system_trust_file (gnutls_certi ++ ++#if defined(DEFAULT_TRUST_STORE_FILE) || (defined(DEFAULT_TRUST_STORE_PKCS11) && defined(ENABLE_PKCS11)) || defined(DEFAULT_TRUST_STORE_DIR) ++ + static int - gnutls_certificate_set_x509_system_trust (gnutls_certificate_credentials_t cred) - { --#if !defined(_WIN32) && !defined(DEFAULT_TRUST_STORE_PKCS11) && !defined(DEFAULT_TRUST_STORE_FILE) -+#if !defined(_WIN32) && !defined(DEFAULT_TRUST_STORE_PKCS11) && !defined(DEFAULT_TRUST_STORE_FILE) && !defined(DEFAULT_TRUST_STORE_DIR) - int r = GNUTLS_E_UNIMPLEMENTED_FEATURE; - #else - int ret, r = 0; -@@ -1730,6 +1797,11 @@ gnutls_certificate_set_x509_system_trust + add_system_trust(gnutls_x509_trust_list_t list, +@@ -413,6 +451,12 @@ add_system_trust(gnutls_x509_trust_list_ r += ret; - #endif + # endif -+#ifdef DEFAULT_TRUST_STORE_DIR -+ ret = _gnutls_certificate_set_x509_system_trust_dir(cred); ++# ifdef DEFAULT_TRUST_STORE_DIR ++ ret = load_dir_certs(DEFAULT_TRUST_STORE_DIR, list, tl_flags, tl_vflags, GNUTLS_X509_FMT_PEM); + if (ret > 0) + r += ret; -+#endif ++# endif ++ return r; } - + #elif defined(_WIN32) +@@ -466,39 +510,6 @@ int add_system_trust(gnutls_x509_trust_l + return r; + } + #elif defined(ANDROID) || defined(__ANDROID__) +-# include +-# include +-static int load_dir_certs(const char* dirname, gnutls_x509_trust_list_t list, +- unsigned int tl_flags, unsigned int tl_vflags, unsigned type) +-{ +-DIR * dirp; +-struct dirent *d; +-int ret; +-int r = 0; +-char path[GNUTLS_PATH_MAX]; +- +- dirp = opendir(dirname); +- if (dirp != NULL) +- { +- do +- { +- d = readdir(dirp); +- if (d != NULL && d->d_type == DT_REG) +- { +- snprintf(path, sizeof(path), "%s/%s", dirname, d->d_name); +- +- ret = gnutls_x509_trust_list_add_trust_file(list, path, NULL, type, tl_flags, tl_vflags); +- if (ret >= 0) +- r += ret; +- } +- } +- while(d != NULL); +- closedir(dirp); +- } +- +- return r; +-} +- + static int load_revoked_certs(gnutls_x509_trust_list_t list, unsigned type) + { + DIR * dirp; diff --git a/gnutls.changes b/gnutls.changes index 3d054a3..542714d 100644 --- a/gnutls.changes +++ b/gnutls.changes @@ -1,3 +1,282 @@ +------------------------------------------------------------------- +Thu Jun 27 13:44:12 UTC 2013 - meissner@suse.com + +- Disable all ECC algorithms. + +- gnutls-32bit.patch: upstream patch to make test + work with 32bit time_t. + +- gnutls-implement-trust-store-dir.diff + + currently not yet forward ported. + +- Updated to GnuTLS 3.2.1 + ** libgnutls: Allow ECC when in SSL 3.0 to work-around a bug in certain + openssl versions. + ** libgnutls: Fixes in interrupted function resumption. Report + and patch by Tim Kosse. + ** libgnutls: Corrected issue when receiving client hello verify + requests in DTLS. + ** libgnutls: Fixes in DTLS record overhead size calculations. + ** libgnutls: gnutls_handshake_get_last_in() was fixed. Reported by + Mann Ern Kang. +- Updated to GnuTLS 3.2.0 + ** libgnutls: Use nettle's elliptic curve implementation. + ** libgnutls: Added Salsa20 cipher + ** libgnutls: Added UMAC-96 and UMAC-128 + ** libgnutls: Added ciphersuites involving Salsa20 and UMAC-96. + As they are not standardized they are defined using private ciphersuite numbers. + ** libgnutls: Added support for DTLS 1.2. + ** libgnutls: Added support for the Application Layer Protocol + Negotiation (ALPN) extension. + ** libgnutls: Removed support for the RSA-EXPORT ciphersuites. + ** libgnutls: Avoid linking to librt (that also avoids unnecessary + linking to pthreads if p11-kit isn't used). + +- Updated to GnuTLS 3.1.10 (released 2013-03-22) + ** certtool: When generating PKCS #12 files use by default the + ARCFOUR (RC4) cipher to be compatible with devices that don't + support AES with PKCS #12. + ** libgnutls: Load CA certificates in android 4.x systems. + ** libgnutls: Optimized CA certificate loading. + ** libgnutls: Private keys are overwritten on deinitialization. + ** libgnutls: PKCS #11 slots are scanned only when needed, not + on initialization. This speeds up gnutls initialization when smart + cards are present. + ** libgnutls: Corrected issue in the (deprecated) external key + signing interface, when used with TLS 1.2. Reported by Bjorn H. Christensen. + ** libgnutls: Fixes in openpgp handshake with fingerprints. Reported by + Joke de Buhr. + ** libgnutls-dane: Updated DANE verification options. + ** configure: Trust store file must be explicitly set or unset when + cross compiling. +- Updated to GnuTLS 3.1.9 (released 2013-02-27) + ** certtool: Option --to-p12 will now ask for a password to generate + a PKCS #12 file from an encrypted key file. Reported by Yan Fiz. + ** libgnutls: Corrected issue in gnutls_pubkey_verify_data(). + ** libgnutls: Corrected parsing issue in XMPP within a subject + alternative name. Reported by James Cloos. + ** libgnutls: gnutls_pkcs11_reinit() will reinitialize all PKCS #11 + modules, and not only the ones loaded via p11-kit. + ** libgnutls: Added function to check whether the private key is + still available (inserted). + ** libgnutls: Try to detect fork even during nonce generation. + +- Updated to GnuTLS 3.1.8 (released 2013-02-10) + ** libgnutls: Fixed issue in gnutls_x509_privkey_import2() which didn't return + GNUTLS_E_DECRYPTION_FAILED in all cases, and affect certtool operation + with encrypted keys. Reported by Yan Fiz. + ** libgnutls: The minimum DH bits accepted by priorities NORMAL and + PERFORMANCE was set to previous defaults 727 bits. Reported by Diego + Elio Petteno. + ** libgnutls: Corrected issue which prevented gnutls_pubkey_verify_hash() + to operate with long keys. Reported by Erik A Jensen. + +- Updated to GnuTLS 3.1.7 (released 2013-02-04) + ** certtool: Added option "dn" which allows to directly set the DN + in a template from an RFC4514 string. + ** danetool: Added options: --dlv and --insecure. Suggested by Paul Wouters. + ** libgnutls-xssl: Added a new library to simplify GnuTLS usage. + ** libgnutls-dane: Added function to specify a DLV file. + ** libgnutls: Heartbeat code was made optional. + ** libgnutls: Fixes in server side of DTLS-0.9. + ** libgnutls: DN variable 'T' was expanded to 'title'. + ** libgnutls: Fixes in record padding parsing to prevent a timing attack. + Issue reported by Kenny Paterson and Nadhem Alfardan. + ** libgnutls: Added functions to directly set the DN in a certificate + or request from an RFC4514 string. + ** libgnutls: Optimizations in the random generator. The re-seeding of + it is now explicitly done on every session deinit. + ** libgnutls: Simplified the DTLS sliding window implementation. + ** libgnutls: The minimum DH bits accepted by a client are now set + by the specified priority string. The current values correspond to the + previous defaults (727 bits), except for the SECURE128 and SECURE192 + strings which increase the minimum to 1248 and 1776 respectively. + ** libgnutls: Added the gnutls_record_cork() and uncork API to enable + buffering in sending application data. + ** libgnutls: Removed default random padding, and added a length-hiding interface + instead. Both the server and the client must support this extension. Whether + length-hiding can be used on a given session can be checked using + gnutls_record_can_use_length_hiding(). Contributed by Alfredo Pironti. + ** libgnutls: Added the experimental %NEW_PADDING priority string. It enables + a new padding mechanism in TLS allowing arbitrary padding in TLS records + in all ciphersuites, which makes length-hiding more efficient and solves + the issues with timing attacks on CBC ciphersuites. + ** libgnutls: Corrected gnutls_cipher_decrypt2() when used with AEAD + ciphers (i.e., AES-GCM). Reported by William McGovern. + +- Updated to GnuTLS 3.1.6 (released 2013-01-02) + ** libgnutls: Fixed record padding parsing issue. Reported by Kenny + Patterson and Nadhem Alfardan. + ** libgnutls: Several updates in the ASN.1 string handling subsystem. + ** libgnutls: gnutls_x509_crt_get_policy() allows for a list of zero + policy qualifiers. + ** libgnutls: Ignore heartbeat messages when received out-of-order, + instead of issuing an error. + ** libgnutls: Stricter RSA PKCS #1 1.5 encoding and decoding. Reported + by Kikuchi Masashi. + ** libgnutls: TPM support is disabled by default because GPL programs + cannot link with it. Use --with-tpm to enable it. + ** libgnutls-guile: Fixed parallel compilation issue. + ** gnutls-cli: It will try to connect to all possible returned addresses + before failing. + +- Updated to GnuTLS 3.1.5 (released 2012-11-24) + ** libgnutls: Added functions to parse the certificates policies + extension. + ** libgnutls: Handle BMPString (UCS-2) encoding in the Distinguished + Name by translating it to UTF-8 (works on windows or systems with + iconv). + ** libgnutls: Added PKCS #11 key generation function that returns the + public key on generation. + ** libgnutls: Corrected bug in priority string parsing, that mostly + affected combined levels. Patch by Tim Kosse. + ** certtool: The --pubkey-info option can be combined with the + --load-privkey or --load-request to print the corresponding public keys. + ** certtool: It is able to set certificate policies via a template. + ** certtool: Added --hex-numbers option which prints big numbers in + an easier to parse format. + ** p11tool: After key generation, outputs the public key (useful in + tokens that do not store the public key). + ** danetool: It is being built even without libgnutls-dane (the + --check functionality is disabled though). + +- Updated to GnuTLS 3.1.4 (released 2012-11-10) + ** libgnutls: gnutls_certificate_verify_peers2() will set flags depending on + the available revocation data validity. + ** libgnutls: Added gnutls_certificate_verification_status_print(), + a function to print the verification status code in human readable text. + ** libgnutls: Added priority string %VERIFY_DISABLE_CRL_CHECKS. + ** libgnutls: Simplified certificate verification by adding + gnutls_certificate_verify_peers3(). + ** libgnutls: Added support for extension to establish keys for SRTP. + Contributed by Martin Storsjo. + ** libgnutls: The X.509 verification functions check the key + usage bits and pathlen constraints and on failure output + GNUTLS_CERT_SIGNER_CONSTRAINTS_FAILURE. + ** libgnutls: gnutls_x509_crl_verify() includes the time checks. + ** libgnutls: Added verification flag GNUTLS_VERIFY_DO_NOT_ALLOW_UNSORTED_CHAIN + and made GNUTLS_VERIFY_ALLOW_UNSORTED_CHAIN the default. + ** libgnutls: Always tolerate key usage violation errors from the side + of the peer, but also notify via an audit message. + ** gnutls-cli: Added --local-dns option. + ** danetool: Corrected bug that prevented loading PEM files. + ** danetool: Added --check option to allow querying and verifying + a site's DANE data. + ** libgnutls-dane: Added pkg-config file for the library. + +- Updated to GnuTLS 3.1.3 (released 2012-10-12) + ** libgnutls: Added support for the OCSP Certificate Status + extension. + ** libgnutls: gnutls_certificate_verify_peers2() will use the OCSP + certificate status extension in verification. + ** libgnutls: Bug fixes in gnutls_x509_privkey_import_openssl(). + ** libgnutls: Increased maximum password length in the PKCS #12 + functions. + ** libgnutls: Fixed the receipt of session tickets during session resumption. + Reported by danblack at http://savannah.gnu.org/support/?108146 + ** libgnutls: Added functions to export structures in an allocated buffer. + ** libgnutls: Added gnutls_ocsp_resp_check_crt() to check whether the OCSP + response corresponds to the given certificate. + ** libgnutls: In client side gnutls_init() enables the session ticket and + OCSP certificate status request extensions by default. The flag + GNUTLS_NO_EXTENSIONS can be used to prevent that. + ** libgnutls: Several updates in the OpenPGP code. The generating code + is fully RFC6091 compliant and RFC5081 support is only supported in client + mode. + ** libgnutls-dane: Added. It is a library to provide DANE with DNSSEC + certificate verification. + ** gnutls-cli: Added --dane option to enable DANE certificate verification. + ** danetool: Added tool to generate DANE TLSA Resource Records (RR). + +- Updated to GnuTLS 3.1.2 (released 2012-09-26) + ** libgnutls: Fixed bug in gnutls_x509_trust_list_add_system_trust() + and gnutls_x509_trust_list_add_trust_mem() that prevented the loading + of certificates in the windows platform. + ** libgnutls: Corrected bug in OpenPGP subpacket encoding. + ** libgnutls: Added support for DTLS/TLS heartbeats by Olga Smolenchuk. + (the work was done during Google Summer of Code). + ** libgnutls: Added X.509 certificate verification flag + GNUTLS_VERIFY_ALLOW_UNSORTED_CHAIN. This flag allows the verification + of unsorted certificate chains and is enabled by default for + TLS certificate verification (if gnutls_certificate_set_verify_flags() + does not override it). + ** libgnutls: Prints warning on certificates that contain keys of + an insecure level. If the %COMPAT priority flag is not specified + the TLS connection fails. + ** libgnutls: Correctly restore gnutls_record_recv() in DTLS mode + if interrupted during the retrasmition of handshake data. + ** libgnutls: Better mingw32 support (patch by LRN). + ** libgnutls: The %COMPAT keyword, if specified, will tolerate + key usage violation errors (they are far too common to ignore). + ** libgnutls: Added GNUTLS_STATELESS_COMPRESSION flag to gnutls_init(), + which provides a tool to counter compression-related attacks where + parts of the data are controlled by the attacker _and_ are placed in + separate records (use with care - do not use compression if not sure). + ** libgnutls: Depends on libtasn1 2.14 or later. + ** certtool: Prints the number of bits of the public key algorithm + parameter in a private key. + +- Updated to GnuTLS 3.1.1 (released 2012-09-02) + ** gnutls-serv: Listens on IPv6. Patch by Bernhard R. Link. + ** certtool: Changes in password handling of certtool. + Ask password when required and only if the '--password' option is not + given. If the '--password' option is given during key generation then + assume the PKCS #8 file format, instead of ignoring the password. + ** tpmtool: No longer asks for key password in registered keys. + ** libgnutls: Elliptic curve code was optimized by Ilya Tumaykin. + wmNAF is now used for point multiplication and other optimizations. + (the major part of the work was done during Google Summer of Code). + ** libgnutls: The default pull_timeout_function only uses select + instead of a combination of select() and recv() to prevent issues + when used in stream sockets in some systems. + ** libgnutls: Be tolerant in ECDSA signature violations (e.g. using + SHA256 with a SECP384 curve instead of SHA-384), to interoperate with + openssl. + ** libgnutls: Fixed DSA and ECDSA signature generation in smart + cards. Thanks to Andreas Schwier from cardcontact.de for providing + me with ECDSA capable smart cards. + +- Updated to GnuTLS 3.1.0 (released 2012-08-15) + ** libgnutls: Added direct support for TPM as a cryptographic module + in gnutls/tpm.h. TPM keys can be used in functions accepting files + using URLs of the following types: + tpmkey:file=/path/to/file + tpmkey:uuid=7f468c16-cb7f-11e1-824d-b3a4f4b20343;storage=user + + ** libgnutls: Priority string level keywords can be combined. + For example the string "SECURE256:+SUITEB128" is now allowed. + ** libgnutls: requires libnettle 2.5. + ** libgnutls: Use the PKCS #1 1.5 encoding provided by nettle (2.5) + for encryption and signatures. + ** libgnutls: Added GNUTLS_CERT_SIGNATURE_FAILURE to differentiate between + generic errors and signature verification errors in the verification + functions. + ** libgnutls: Added gnutls_pkcs12_simple_parse() as a helper function + to simplify parsing in most PKCS #12 use cases. + ** libgnutls: gnutls_certificate_set_x509_simple_pkcs12_file() adds + the whole certificate chain (if any) to the credentials structure, instead + of only the end-user certificate. + ** libgnutls: Key import functions such as gnutls_pkcs12_simple_parse() + and gnutls_x509_privkey_import_pkcs8(), return consistently + GNUTLS_E_DECRYPTION_FAILED if the input structure is encrypted but no + password was provided. + ** libgnutls: Added gnutls_handshake_set_timeout() a function that + allows to set the maximum time spent in a handshake. + ** libgnutlsxx: Added session::set_transport_vec_push_function. Patch + by Alexandre Bique. + ** tpmtool: Added. It is a tool to generate private keys in the TPM. + ** gnutls-cli: --benchmark-tls was split to --benchmark-tls-kx + and --benchmark-tls-ciphers + ** certtool: generated PKCS #12 structures may hold more than one + private key. Patch by Lucas Fisher. + ** certtool: Added option --null-password to generate/decrypt keys + that use a NULL password (in schemas that distinguish between NULL + an empty passwords). + ** minitasn1: Upgraded to libtasn1 version 2.13. + +- Library is now LGPL-2.1+, extras and tools are still GPL-3.0 + ------------------------------------------------------------------- Fri Apr 26 08:07:12 UTC 2013 - mmeister@suse.com diff --git a/gnutls.keyring b/gnutls.keyring new file mode 100644 index 0000000..413e9fa --- /dev/null +++ b/gnutls.keyring @@ -0,0 +1,1300 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.10 (GNU/Linux) + +mQGRBEgd5bQBDCDc8Z7h2Damx3Xm+kMFXMKHqVUdPOqvcFT0c1gnQ9LPw3JiswvB +dM3SBRb2LxtEAnXt0Bw8WBbcCF9s05h8xjCSLDmBwQ1EBEeTvUN18TgeM6t4rNTZ +NrXl5wRmvkAzdO+EOHWx2gDRApLbdkkBK21+M6HPhtqRiMWK6zd5bPmiiAKNRv0G +aC71qUpdNSrWVzB02s8+LUivwH+kUksMX2nXps7b6RPhQyFl6FSv0LsHDd3yxRrB +JIikUAsSnQbDSPws+Srq1VFLhaARiPF2tg7ag1n4qbbZiK3XOSjK3X+b2XkdZrWY +7orBke/J1cMv/9XnqtsE1P1EYcuPk34yxjz/E5+0vf8DlzQ86c2DHRCpr81XV3qD +tNeouQFLDI1kkpG6QTY3S2SPMUht8V8JxhqBzbjWZmKGUf1ISYI2p9FqtXF4rL2D +u1QLPQGLwqYaUvnGCYFxEMpnDcYheF6zOUtow527WgrJcATDXW/HCzidwi2+o/cU +bdCeYOiN28IMCOIBJZjLABEBAAG0N05pa29zIE1hdnJvZ2lhbm5vcG91bG9zIDxu +Lm1hdnJvZ2lhbm5vcG91bG9zQGdtYWlsLmNvbT6JAcAEEwECACYFAkgd5tUCGwMF +CSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRAp7li5loZRcQvjDB4m6HO8 +bbiRSgYRd7UrUuSmRNcoWP3W2metytSq9ugRsFhgl3llHEMkgWTEXzsQTPZXPq7m +7aNXPa8s/ibD+qZAbFSRvJISrp/E+c1gCt4AQm/nD32F5RIsVKpg9J0pK7rCrMyL +lD+PiG++jJrG3inuk4Krc3EHj92LJpfEnVgaJR0ajwuVHNd9/QOrkrxQ7jlLckl9 +ZWmquTym/GClsH7NcPnqwc7YO0nG1X/l9HJmvSyaHGi4UnzjC8Tqh4avs1A2uUfX +o0OCwLO61bqnst1lIyAn7HtidVNBIfQXKDd3jWz+WwyZk0GRgzRBfRWShpiymxVi +3LWUgtXL0FTEK/pFpHvIbhpivNq1RPTeulO1uO+Bb78VYzvQx3cIX96gRoqapdI9 +zO8BlEze9lj1gZsRVBlWVkR58IZnuPYtOmuIoGX3NFaTBk4rIKPeXEzCGC/ieHDH +En29mZoLk89VrCq+7WNKdSYjiPcMLpRYmvBcJSxY6YxnM5rfiBSW5huV3uYuZQ89 +iEYEEBECAAYFAkgd5t4ACgkQ4V3YV7FcN9FGqQCfU1gaFrkGi5abivU9BQkJkr44 +kn0An0VSGMOgEsfzsDzy8sKnJTvdD6e6iEYEEBECAAYFAkh+2sgACgkQSgobyOT0 +/+aasgCghMcsnklu+37Qe9df76p68IGNEU8AnRw7QP8tYJ5Z4GAmc6FfP+3unrN6 +iEYEEBECAAYFAk1OpR0ACgkQaeRidk/FnkRwmACgmwEiVmtLCR2ffl/2MAJi+tNt +KyYAoJL6fLS8xycGA8G7ls4qYewDlr9piQIcBBMBAgAGBQJNTvdcAAoJELzblbcK +o78OfHAP/Rjx9YUKbB8ruIbVwzaOpaoiIpBcK/F/aafqxBBENEO7IajQfRyxozrl +XzzUIQyOC3keQdw7LwyURYvIYxcm0k5x7eVnhavu4TBL8FAnIsA9BTkNbSVCgmKb +rclfUriu7ipFPsaSEJApKDhQU3ijFtwHCUxFg9L/lm5N/PwIL0GQC6BNrbVrOCVd +QflMhX2MRNVAfvAbNcRJYUCAh0hHFigkE8FhAqJZuUGK62/Tbc0/np9ga4q7b3dT +Bg0l+UVVAKc+XcvABcomZeLcgNT7YTYZ5pJMjfx8Nk7R73JNYLLUnB7fFSoOolbw +dBkz2BupNlmRmoD/lvm7Sbnn4HkyLFdnx9CzFZ3Mn1IMkm6Kkcs3Fm3VHQgLgs9K +lewKOWzDBQeSgPbhhiqzjbFXB+e/7MDTJgITLZol+3/OlELvcTcSU4RloJzjJ1mQ +5KdZe1ZrCs9dUwQi5+guiLZJ/MuqeNtXPey+HliwhyG9gy8uGYFW+6eLj3yv4YaE +AmlzTYneHqBNX5kTw73GBWy8PyZz0wiIX/700BEw5IPCeJV6h+xBdpqk8l9PZ2Vi +Piuod2qWJMIw5oldChMTp9Wtk0+EBg8uiUz1q5hgIts12578fkH7EPGbQCF8RITT +ThrK6m/YOjf2n03irT52Umb4c3FbBxn3hQX76QuhK+TrYkDyREtFiQIcBBMBCAAG +BQJNTx73AAoJEPlBB4h4NHwMohAQALY/Gq5yXfWTmBQWqLfeXBXSCZAz7yC1f+r2 +RNNf8dx8xTW/dyI2G1SbMqqHc6rJqW5yPe99aP4AQsr8lAsoLbY1LhJi3Imfpk+h +vAVqInSXyQcOnprceL5iyADpkpLS+/5CM83VGfFQoVUTgLcFWU97k8vT0fQT3pFV +QTQzVu2ZbBkHhaLTkV1Ep1KHWrSEVN7kFZaA6DmnR5W+L2k4aPEKDgpVSflLmd/9 +XbDFYsDzcHlbK8G3fEh7SjMJGyFyA44EeqLA3pRoHj4bF/jVCXqS5LN0LarBmM+6 +Wioi5thj7jZ8NlqSCvuaFbajd5asY5oASZKa9M30sSU6oWSVdOkqkjagQf65teHw +64UyaK57l7NWIenv88mPfEJK8Ce2nt2j4cOZ+OkAimUGBsvFNNMQae2Q+dfb20Eq +XeATKRtBzJDSKVK2RcKUi08PYPK6PTAsubMxJnjIbMohTdUc9QOvCRa0o+f2/VhZ +DrFNTwiF0dxjl3fFxt2NpVsDbKmgJegov9lf50oFrTreRG2kx3iGpiKXyPWqgIN9 +LPFkHdT1uXQbasTRi51zMfcYVmk1Do/CzuTw+PJGnTgmC1Va1NSv2Ck7xl4H7HV5 +eDlWHCb8plE9QE38AlU/pv+34JVSC5mf/HDIxL68IdUENMiXyBWynDeQkuI9roUb +Li0y+9J/iQGcBBABAgAGBQJNTwf+AAoJEODYD8Y41NWHpIUMAImOAT+PyjCec7sM +xfx7XY2I+1vovSt6dKTBpHVq7Wj5575Sl+0Rp2YovC5nGpLNx9Tt3V/qNDHZAokk +F8/XPqwcwmvVFLsXfPDbwcASf+1FEdXAf4AK3qalt7BKVV950oUKw88DJuigc14D +tIgYOIiKHRQ8hot8tFOl6q1iR4tPYslz+gkbkxc7wWQYsPpR/37Shn60QZMkZK7Q +7Rwc9g1/g9IZDA8A3qVIzPAvV15GMYb7MWmji+ys6zPGdd+dfX8AbE1ZFG9xEkVr +fJIwGd8Yuq0nb0p9SKW8kFmnblXVPAE+harUSH1oWhzUcit+O4gYa63rMS3Ai6uc +MDJ9YXXqVT2sQNKAxR1fCcSomVPGx3HD95XIWVbQXBQhPE/FJY/4y172cxlC2KpP +09MRTKD5OrXlsn2nCso1fd8qn43aGxE+9ouC7pWcLSkPhLRPfQQ+1RxGf0tSqghk +A/gY0qLpp/wMnM056aDgQllGjA2G6Ujk3Jh8uRt4CwVzNFbUo4hdBBARCAAGBQJN +T3n4AAoJEAJasBBrF+oevZQA+KcQbKpgCwYqEjc4UyVQ/lL4fNapao8+Yj/N6oT8 +HBcA/2PB62hLyyIQwGSqovcYC3R5QWxcpEg0+FXBq52prCj6iHQEEhECADQFAk1P +0V0tGmh0dHA6Ly93d3cuYTJ4LmNoL2RlL2tvbnRha3QvcGdwLXBvbGljeS5odG1s +AAoJEHFtRBM9jCItc7IAoLU6jf1+Cm8vLmNUawf6VB/uAQe+AJ9N/1vAyeY31req +TYa22XKHrMhnx4h0BBIRAgA0BQJNT9FvLRpodHRwOi8vd3d3LmEyeC5jaC9kZS9r +b250YWt0L3BncC1wb2xpY3kuaHRtbAAKCRBW1Sk+yXoGVJNHAKDX79218zw3Gtex +5PIchhsP3b/hmQCg5k1D9PJbfpbKRotpmp55eokhwnKJAhwEEwECAAYFAk1PhSwA +CgkQmZMeJdkeASziBA/+J235eEuqz2I+P+S1RXWa0SGUDk4CTtsYHeLbr91FpEOj +WMVIYoj1i25Ne+nqjs+goYc0n5oVC72W+jJrT/ayGunMnYwkmLI+OnJ9/FNkwKj9 +phi5Cx9BNe7+ZrjCSxxg8Ar2/UIzUhUXnIII+OIsdAUwz4P8UhVXfCfXeja0pTCn +2XjNoxKOdHLU3DH0YXqJAPsWSJEqyZyVP0SoKru6Uq536/Z6VRNA9hFR9QWIi0ib +F1tngyfzwevIEjN6OBdT4fwZzmdV1cQ+adoiUr9wFeA1JbjJefAXOq15uTxMMMJV +gRVnzHPAWosLHYnKaJzKd8rcxMsftiD92NbU0t24YsDmXMVAo4u3Q2YVgbgGWu2t +PqYPZHk0i57MmAIn6YrL3+TTqDNN35enQMKKJmnBAg84ZZvQ9pGJQDMcMv31Yvau +vt4dkw8u/Jbksuc9RTw6w0Zn4WYPRxZtUwqKYlR5Khr0f9HrKOeiJuvOs37F3+bJ +CYaKYzy0BUfSmujKHPcP1l3IJe3gIT4hrDWc1J4rcZ+dopBkddBVQrMc4L9V0VMX +2bR3fcC5VraEnRQxkkyF3GSYoXNm5ClH9LV22kuS4A5WPheTDbD4wFKqT1UHMush +5rjd/BwyDXTcym+bMH2ZAft5w7VOquFM372GUI6uXNiZS/iMWj1w6MlzlaI9q3SI +RgQQEQIABgUCTU/a2QAKCRBJNgs7HfuhZH1DAJ9IFcqjB0K/310XdIXQPd06Ev34 +oACg7Pe+DW9C6+gJ3foFZo+TrcC5K1eJAhwEEAECAAYFAk1P2zoACgkQfpcqy/4K +evMLmRAAj23Tdm5GO2HxV7IP2x3Aa7kFo/pzVUUuvpn0HFIWBFK+fJEOMeD1SpI9 +nGHfziUrNruwtjqgSMHGy+ZP7IM0ERvmkp8r1La67P4AsH6Qk+jBwwlGPs0bE5y1 +I9vip9rWhVTrnBWUgblAWWvjNaArCRA0XtOLYZcoUNZUf9KGFns7OSVCKjysoLuA +yw05ZIUcHyRe9Jf6Ps372726qDAcDFM5175rL2Mo3khm4riq4ezIa63SWSfUCHfU +g7z2ZTPA+9JfwAyYw1+pOgwM3Sg6NFhWYlG2itewJd71PfAOU7D5jRTjHGGyYkxq +2Xu6Yt3auBIo1M2ZDQVYaxxfBalOyk8HRMo7+IXiMZLfP2cqBghGBjfO7usfKU/2 +WkmBlO+gZ9v4snVynfJszwjqqJaulfzKdOlwfYvoEuA6C+ZtXQsjI6vniWoiuDN3 +zQaDgjvEDMBHuaxDtxJP8ElbSByKNB9ilCe81H0vDWtzHrrntK+yekt2OhfwbJBT +a5Zyu54HF9Ifcpv2AAU1/kquZz5lWDzx8GQc42L4dIs2JtSbnIzZI+vOBkgUaepf +fvM+vmI/z4zAAMwXuPgH7jHZVSXz592Kc8vD0SMryiajdm7+H9m80JZoJGvGa8tL +83wjE3AfkNt4x4jFyEkrqNzFMG4Pf3KCYIgE4EGGXWZh1QE1f7KJAhwEEAEIAAYF +Ak1PtoIACgkQtZ63IgLRvGVFUw/+Oys3yltQUkudCAhmW7Z2hg3sFbymd3KoW8cp +WbblC59p3t8owLgsRDgu0tzQ0OgjdXkjcaGTH2tRlcrJmJ7Zk+QyU+Vb0+nlXpIa +btr8GnGFPT092Et+pFaVOJDNRCFIVYeeVfgspX+RJohUsNAjiTHS4GJGyXTDHpOR +PH5xokbCRtlG7NRV4i9zg8D9osSW7ijsF+g5peaEiSUF1rToJ+yXMldnsJRXHC75 +zrB09ix0VFpOzx4N763WUrobIvDPWKl+25s25zkdw5jfzSX1+cZjXO35zeMRltyD +ECSS0j9v/MtplbnrumErL0BLPUPb5sfn3Akpjk6a+8oo5qL8u2vtAMxUWX2LAdeY +9Mz/S3pRa+gd/s/R8XL+5R4imW9w1GeDO4MIa4afMmpC1bjDH5vEucxWUuYyfZbn +O2XQ/ElneV0VO/c7FKc8xYNC0urX679Fsoq273UVL+psNTkAscwY13wEQw5mT4VR +cWt9Wi6o20gdsFqozAd4J2xstbkXsVk2pijAQc1+PL8nkHi0btBxO/sTCk7/yNtG +cjnXwD4amtZGnELIyiF0lTGbn555KKvuR6OpNLraY5QrkW5tbwA9WGZRQe4dAWv/ +czxRrb41e7LpWIUkXUqww53RsDBzuqtgV1D4ghFY+xzVDY1jkrO3J66sa3vNx3WW +LVTABwOIRgQREQIABgUCTU/vtwAKCRCa3YdBWqMiVjikAKCP/1BUiDupZbAu2nMx +NWdZ7+AkxACcCt/d5WdYlNY6GBsaFCnJzp3tCXKIRgQQEQIABgUCTU/l/AAKCRDl +MRXluKGcafpTAJ9Kwsu8X/d4DiNO4ptCyG7bnc+fCQCfeANjtliTDIiDqlV0CDhI +K9sMo4OIRgQTEQoABgUCTU/3aQAKCRD8sLtcXx+/cMwVAJ0ZizlAxB4E/1cEhY6A +9JdBkljE4QCfQYgsJRznwXVYNG3eO06+KVUz59yJAhwEEwEKAAYFAk1P93gACgkQ +ntzJkdmrRX7MPxAAoUcYn1RG7XjtDOm+ijduz4gnaXXKgFhOMaVqG0HjMA5ve0oe +3VvnFdZsYxObD3us3mkvt63lmMx61JH9aMzBhLd2EEWDQXfKSPJw+Ll6da7gD9Nb +p8KPrlLMAVdQO0PsfBieHIITdrV33wDEmZ5nRfZ49crFWzaIAZ3FS2h0aOj+/DP8 +ovhENdvykCWAcmqzteFJnKGx7IpBl0jGye59FJ4xc8SkSqwzQ2jJDM48FZmE242F +cj/DLWvF8BNMEAouZLR5NpLE7k//40PQMqO6nSOeQtnpfUP4mMiw77kXp+ZLpg3x +pGfWYVnNWsBTyG/jcdx9Pv71p1/I13q6+O0rCbGrjb9Czq+QQu7kfPwWDDyrU5Sv +A6/Yvh3HfDdjpavMDxfBY+KHjHMaAMJ5rm3//EZpBtLyHZXWTiawsv1eraFpxlRZ +mrY/JlB0XMV87Ma01x9NggQfMjj2AwhaTx0JWvLZjiN1fV0GN6gHtYLDJRS6zdUO +mfTFbCFgIwEWAbVKFapVe6jA7sak/X4kdwOupK88FGofUrP4WXWtjStOHeS4irXL +BGTQOAoizeLhDGvXKyoP3RZzdQKRvw4DNkNztXIhWb/ZgRI3R5ULoFUY4d6Za4T3 +Q9iK8oz3o7nEsWaHGE2UTZtdKo0eaXMrJM+rthr6yPER0G6WvTfadssJJYiIRgQQ +EQIABgUCTVAFAAAKCRCNvOfruxnoAyv/AJ46wOFCbVWS73IaeupVygLkNGZDAgCf +ZjPwGvRy9fj4mvxWpBfWbn8WcvaJAhwEEAEIAAYFAk1QIMgACgkQqC+7g/PVcDP9 +3xAAwgm8FfGcF1WbQYUi7K5VaiwPqXCJ1h4cx5YewSGeue9On3ltRSxbXmtpTcdm +mcZULXrFYhF+cwhwgQu2BAHX327tW3AO9NZtLNbdAUFGGPky0g5K4tk26OeyJAMT +9n5t2d7cdD3HiamrdqIHDPjYXCCGHgkycWiWGRBWcrBeYInk2iLMu+hgV31pAiEl +iIZYKEoDAxZKO4eLoFqSlqO9WIAhARlcxk9WmN0q9v+E1+CIuq976BRU2rJ0pWEZ +dwRl4dL62ucJ+Yazlq2Ix4PMliSxTA7i1xYi9Fodr7XQahbVx0/+WFB5GLZwyedl +9u6HWCkwZec3xGJUoas3g6+GTPTD5xpqT5gPgC3jnG8WBSXtifl2iq8baDpd5U86 +WWtNs9bWe9YV2e4vQltyfXJSetbEQTcaObxLwWuvm6mg9da5rQksXf6Ljukx97O3 +02tylc4BQ6cskqGEX8LixO+w+iPhs1NMsIymdi6qScWa/nhtoN3hsA7OCINVDDMb +VGVItOUjNi55ezuaDc7Vhyd9SS949zKfRfamttvUhqYHDrxXDTDPdd6O8aH1Ar38 +rn7AE5IEuaNLHaBdqE+Gs+DeqQX7+BiaQziMs7l3rLhJH9muvbrJAFsmodGKnb4/ +MW9vAVK0HR/P15zti+JCGrykiG1b30qYLXS3aj3dfBCdClGJARwEEAECAAYFAk1Q +RPwACgkQfcMm2s1ypv2BfwgAlgCzrVI1f4bZHN6YfEx+1r3p/EKODTNl4KvRl67w +ztckm2o7awsu3qvfb/TxUTSKzUE6OjE9B7T3MsvvzGhPySSiqZLGjf9zyrxL2NLU +FQiceQ9L5fupWZb+Vps+QFnmZLP+RuZmKAronNq29oL+huSEg5os8GQswovxmlq/ +w7auj9GkEHus/dGX2MRpHqrSx0JjTCj2laXes4x+oEuUUvfbcjGDGijvS8hwEa+b +iphHTwo+PHt22bH9lCzvy0Ca4J6vRF+JrS20hXxKbiT193O6MnlrFvni3m6tcm5I +TeEdCHBc6XyanN2KPBeeiHab3RdSBMWlpMvoQsdq781gPYkCHAQQAQIABgUCTVBb +QAAKCRDnYQLgzf6sLzHrEACDjWJtlpdRV6Fmumo/gAq05dLaV4AiLn59qFLt9qwM +CqhD18GpaUMHtu/arJTEed/c+nYl51uzvoxdkmtwZMjiyLZx5R7wm2LC4DzgZ5Z4 +UCxoASLwvxd1P33wLT3vkYF9ZHAMI+SQn2v5hrY3cgzpEYCDGNhKgO8empzI+na6 +3+su+/OFjaSVKkBiC/Ms5KRDQBDJ7oNbMava5rpdDmLHUzjKi7M6G7pAzEBWrnZc +5WXOIk0UYuo6QBSRb5laSDDnvKW8BFc7EDj4cWbXoolNNXFCrD98FNZ1FuPoZTt6 +kddQ6oW6qJydCgvPD11ILcL0AN9SD29DRdwMeSp1vkVHYA/tw+W3JCyP+gbDt6Wq +Ar3yfzBgJbMTFvDJcZh49YP6LL7vHnym1PZ5QyYJTaiKCXa28tKLDONYrbX59CXO +lwxE2SHZ7EZrjHmwyJM+AE6xL5P9GT8RZL5LxOzRYZvWvmSHY9MpEINI4ILtEk8J +1DnBzclulRSJOU2hEGQwUvHRPAy3Eof46455rdMEzsomd7n9LiMlF8GRg1dX9wTz +A1PYlhCn8Ed66kFPGW9AmryFP7/ysMa1CN3m8QR2RJoQyPjvgwmdVSc5vsOTFNce +5E/OVUDRZqfteaLCS2mXrl+/KGISL5Y+/b4Q7DA01OZZtUiE8ApPbhOez5QUvZ/e +aokBnAQTAQIABgUCTVBl4gAKCRDg2A/GONTVh+1FDACAulggWlQytMfrzaIWpOMd +5NqoURxpWrMcY0fqcMq8mqew0HOIqY2LSI0qxVYNKaECcuUI4kCfhyRDuZErt9zI +QcMNc4FPyTcnt5iBEzah8UXZhK1ICFACX5o75ZX+wRnzj2NgnCzprBHSrL4t1qaW +cIpL8Nje6QZmyswp68M+B/ScLYZ5CPeoABuyK5ayc6pjfXE6EJT96+q/A+DVq91r +F6gwQChYyULGIK3ONljtC4woJiqjIkqQ3wKR8fqFR7HCZjqU/uPuNY59J37mVKyR +E7uVhFSeYNsCVgg0XiU+4KFa2FjJcJHPesAFp7a7y7A0p7CWXIvbmgaHAvyo6z9x +d1+uXPChDPSpq4WPrCcqumrzoBLB4XUey//imTA2+x01qWgkHZFXNg+ytrXzyjZ/ +S0JLzx3hyz519kEEAg19LJPZY0kmLpQP572BdTJ7bXOaTuOz0Q6pcZBFrvFVpy7W +1/0RfT2BeXGFPTBjClzcfZsic0TrFGJHc/KEVnjx1h+IXgQQEQgABgUCTU/qNQAK +CRCdQoEd+4uzdjaLAPoDMLS1M4drh8qKy8ChaU0SOrFuCz/DJ929p7IAwoNmggD/ +c+B8+wXV1iqbZaJRTNLp8TutqX5Qu0DoN9LazoFXbX2IRgQTEQIABgUCTVBnZAAK +CRAvlRUIquYCLqixAJ46LD1vCgy7n6BEjYfpNVlEhkBdAQCdH5dm9o406eTWW1Kt +PFb1KkOXO/iJAhwEEwECAAYFAk1QZ2wACgkQrDCHmqtVsxJ5jQ//fEZfgrWzWAlx +LUnQxJ2xR4XD/rLoTq7iNJIVhfpr8MDNczG6BVq2x8pEit1XbJp+PuvKONDtWSbu +R/GoiNA0IDx1b127Mpz1KfPN7hdsQlTb8uKF+ESgsZYNBCjvCSFydTN5qpxv5xl8 +cQJpiU5RScOzqRpj+bdPv58OBPRCOXKhdQ+F9u+3ayE0PNr7kXGH3dwDtox4b5x1 +qghZPgI1NN6Y+jvERiSBxDsVURdaLpEb7WEYmsQwuO/UqdoATY6nH+C2V85OQZnU +leKKbSwnUyoQ/VIGI+rsAncpJ6j/1z+6FyfTOaItbijzYlJF09v9Mc5VVJz3S5oQ +RhDychO7xDYIWVzW6h2FV8XjyugWyE0x6blcP6Iklsu9Nxb/n0w25G0F/pJa1U+p +aZxfFVh3wUPwOy95ZUiJmWn3xVE983kjvZ3CyE123t2M2qcM0LxDZqkfGSNu8VhW +qhWBg9SKtBrJL2RNZowl44R/RaBW+EWQkD3GrdNgmEjq7Qa4dY3zm6N13kuyfg/q +2l4h8gaOHVsGJ7J+G3A8N718iAhtzxrJtNvGy8z2XneE7v1uH2KbE6BpvWM8BiMe +rrb2H6RJCrx8usGqdorF6ZYPbF0ymN8Prke9gg8hcoaQ4qoGcgW4U+hMLM6BsuPr +hVfVIRwfjnhN64k/M+asgTD1tb8BNFuIRgQQEQgABgUCTVB+VQAKCRDRgd16bEKC +cpWLAKCb6JUL6EMdgZ+2Ys/UM6Od8fhfuQCeP5YaLh91juJocCnTLFmXRjbuhxmI +RgQQEQIABgUCTVB7LAAKCRAwAo0kSBO1/hFsAJ91et50yD4Ui8vsGXqTLwUq5+Kx +TwCgg1Ud6vHGTks2Lxg6b86BzJeyeCSJARwEEAECAAYFAk1REY0ACgkQnK/PEVZ0 +b5VaHQf/RFXlrpB4ArNQwt1HkEc0BfgTcUt2zv+muBn6EtPcukZib06LwI3wWoTy +8hHpQoU20sYWOKtBLV15aw8pwESJkiCeK70LYu3lgn2csPM2EQsB+/AaW7H+TqUy +2orr/RLcgi3ZAVGofygZ/lcSuMpbGhQFBmlpXUI+TQPVayKPs1lvzBIM2EUMwNye +rEnwZE76StfzmzEGeyAMuclOCPHa7eZQW4A0d1Q4KhjfiLZDF7goafkj9UnoLCU3 +MqwiFxyo4OuBEBR0DHqa63cVOGlz/sNH9oG8stdyH9127kOwNhsJJTQlgsxqnZz+ +lgnHVmSrjf3nCG9Hs0JieIy4CkDOTYkCHAQSAQIABgUCTVFfYwAKCRBa+2eD84TR +jSZ5D/9XJj/IZnF70iacp9WWpMggi4C/6vFCYyPInDs9iLiKXNwhR4ymczRCePar +kDV5FLQGtFlJP0afl5aESYqysGIBpB5b9LsNwcd+UJ6Hgy9IGhRDifGZRcWBwZeW +Dqu/K2tALZvaueHb5fDDago0UMemFrgJOrGqQmF+SCcJjxpPyAoamb2Hg6ZaiWje +LDvJQ+xoExcQCAFsdlm9to6O/ieIu3Op3V3rPtn+BEFzQH71QVFwm77nSWQBL2Du +D5keseOnxZ78X2gKSx/ah2I+RR5J1aYMqhZ/GG323Taq80RYKjxFYn5HQ9E1dqQS +JDUtETHhfYPRv0lWmMiL5Xy+OOD+ZdiXwVzxHIq5HSFdgvZ2dzcWGk2ze2+i5zc0 +Gz8oT/CsYRSfWIAhWFu8LKsMJOneW+eFaVhpvu0k1hlyP2n23GKfBM7dr322+hYK +vkEcvF3iVUQwcSrvpay0BbpDb7h/r4M6cONQNuFCrMkWDIxf2Ldr7nw23Irs1agu +R8WETZMIeol5rlk5EfJD6+p3TOGMwpgvS1vj89opcmdgVxfqE+MHkmMUfzeRIyFl +/1P3YI0q5vNEbJacbVU20yWJiUYK129YCTgS+iNwlfM9uPIoBhVkFAE3NaXu06UI +Eo2K4GMCFK7vV2fq+LdlqcFdUtqJ6MWazlf62h7vZcl6EOywV4hGBBIRAgAGBQJN +UV9mAAoJECM7ilfkh1/5zEMAnRg1/BOVICQxes2w2vaOyUx6XfEaAJ997McxjI30 +oMrWudXMoxrpuOcDpYkCHAQQAQIABgUCTU7qoQAKCRBnZgDc2lqZQ2UUD/9VXM1z +paQvzAQplApRAfo0EL5IYkGzlgPfLugr2zrYWod67GXybrOrhmI40rV+S2j9t3cW +wjv6yQu5MrcP1OT4caycGhBGqA5TO66B//45LIf4VqtoypzVbfkciu2b2NawnhHs +FCOoJfPaEytPmUB6DgOk+xR17fQK41Balro82R103eCIKRZ7FvXq5wgdkBMqMtn/ +710BuZdfaSYH7LSp06tpVA/pKTIPEYAjWiw8so6GbwcG2tQlF4BwbcREsueOpbac +giPy5ESnH4C23T+y8qc/gmI5oF2RI8dtplM8RxKudwE2WqtpRi8zHiT2MPygrbCv +F99tgcYG/WzWBFTIp3HTNpmr+NKO/b1xPVmxaG4+Wz7Z2wEHAguR8z+NaVE9mLls +68bfyXM/yqQYKw1ZPKf/TWTBFJZMTvBAWEbBzB/CwZQmArrZTMPqQo4o7nVwf0Ck +CvjYEmbK5wx/HwGZm8QBg3cpTqJ3AtohGtRc96YUmobMLtTnnWMJOlp0f4dh7eUE +fTgk2mDAg/nb07TARh2CFOlE8N1tgJ34uyxfgfarlvhNyAv0+9dpQ6edtrvNrwKL +y4ppoEe7sbY5xDKhfw/EP/Mc5MTfxpSQmm15OtOUbaJYUgQ3oY32qJZC4p+K3wpV +GGxLzwtyDonuHy9ErnzdeFlOwrt4Uy+CV+3gG4kBHAQTAQIABgUCTVGm3wAKCRDp +WoG4nkG+Nha6B/9MQ+qffiBEwLUQ0FZU0wMhxYCcEwW37I5hYBArSUfX/vVM+em5 +2tAJXQ3fhc+2UfAds375B6LuirJQx1QlXWWYj60/a46iebqYMNpkLhLLonC2OKM8 +HIQS48gRzR2yMYNqSCqSiZR+B//mIwaHgTBvxTLjA4z1zvieUnb0W+wODrqKyi6v +kXawBm93XSyiE7bzm+zSnxlWQGN85OMmvm7ZNaNX/Fu7qUFwRXQ6o2HcQ2x9HnHo +8FLGITgRHvyajalvcSkyI3hO7zRiFuRDG7MvHR6q9+FJ9iQ6NSptM61ldOBBwkBK +qA91P2v3knrveHgQA9C2+xV5i7x/85r9NVUIiQIcBBMBCAAGBQJNUcZvAAoJEH0V +kcae+vKGncoQAIDgSadO21sTYSuWtxYTZoxLGzuM05httPShqKJNFp8XN26PTxrs +7FRNha4L6ahpuKlVrk7/jyGF8gj4wb4dgmIV0XnfENs82KtkSM4qJuVHlgxYzgIl +h49kJAvMN4SKN+gRblrc1+6xEeqgyunqhxVI4MOuzr/S3Cs8fGOfQpY9LtKJon8j +STvCHdgsBO9DWTzoPbUvblWa1xm0Xh4VmqaULORGCY/hx3z85WW/N3BGi0fvsjrv +ZgnqJD1c7LsJ+GbJzil+bzVrKiCtMApOyDoC+eRPkavADdLCSqUtP6RnNxO5XbOb ++7sfKIbA/gGkdBdNmL7a50fKTGI2RmxuU//iyh2KsxTTOGohtwAoDdBucFYN+cJy +v5j47+MAIMPN2fTKsPnkKAtiKyYWnY+EakBIv7tCF19UcrsQsP+I2lhDrUAjElb9 +SJZK3vFBNxdQHrj6p0I/YwLcksXAN28KZIPtiNo0nLby2GqQZE3/pvcjB366Aw+R +Sy+puZxmJGS+ETfNN+MAbOVQeme98DIiFjx3V511lBoWOgde4uxiFwLJWf+UPAv+ +gH+7hb2fRYkiFLCIBOA/i493TCO+q/haTjxdcUvy/7ugBioNiBlHPFJUpX0KoeRB +cgAcYRwo+5sh1zko05S6BNIUr/qdHa3hQIBvVkBbRRuQqI2Ncw9Yh8mEiQIcBBAB +AgAGBQJNUeDCAAoJEF6xPp1Ajzw/xmoP/3ylIIY2c077p9t8X2HweWjRt7B+gEaC +OG/s3d88E1sHDga4/PztuWLTukaPHAOthp0K2tJB07CKBN3p2KpG/arxiVWYftfX +lOhtE5WD9G1U97raIARKTj7LSpt1pRmmGIc0c2LAq4HmvRM7faIl+RKuYcqEnuED +cpwVajbZ56mLNvJ0EvWwfQcu5mHRN+Q8ol860OdshDiVeP8ZSfWrUnzrKQCBE6cQ +rHvKlCre/NIXd2d7PLj2KO2Dd8Rrg9KoNbQtYIOgHSWc6u6dgmx90y1xq71XitJ0 +Rpsb0WPd1r+YAqAOxkK0q/ROq00iFIsCu/I0ljS8mDDuWHs0UZkeY8lvzHDdNyr9 +WpWpABQ/O+u49XIi2q0J9KjDgbIuYHGcjFPy0mVgRnJkML4iexFbnntvCXAtgubg +0HDYC1joTRp/Vp7qINm6fcS+dHS1H2+Jtdy0t+T8RiM3s8Zd8U1JjTIMyn5wJjAo +NxHRZRw2q1kFyU/CNLlgcEAndEVk9iCaW0QlSE2g2PmCu9xB7DCDeAdUM/Fy7wuF +z0WvwM9NjwSmnqU9NSi1IQLP/6MSu2tFEj8GbsTGp3IUs6nJHPWjw79OJJ6hc1nr +sHzdwjSguB/m7EEXNCRSN8DLhCjqjGLffLSOH94uKDBng9nuc8zgfIHpUJK+0QqT +L1Il65AMopMEiQIcBBABAgAGBQJNUeDwAAoJEBEv90CDiX4SNYwQAJQ0+QB82tVN +n0kyeCn0R2xgQ8qM4oYliPsJfC/Q0OOYry5Ir72IuFfX+r2wVTiULIHDuIAcHsQf +bXtzxYKHVvajwQibCZcJGeacDEqKD9Qeznxy/Xg6sRBB9rEA6A8QIC7sjLfMxeeQ +SQmuH+8Q00u5+RpjQu3WpdUXMF9Zop3rrPb/uonAGPHn53lfFJ1vdymGa30zLyvE +vKpZsraC6fHDlHY3RsHqIKw+DIjs+syU9JJv+RH/lHj7sa8QcjAnQwJEqBbFjI7B +Dg0/ltyoE48eKmIszD74sb+wHYW8LrGzET93/pM86yN+ZPYWpaAUUo168uyXyfac +LZDjTPEYqmFd9RlTTZW0Plf5JWYovdArJkN9TrlUkK28uKYULdSB8Y4hzp1mLAMa ++4fKbGUs5UHXcA6JuKR3tqGw6NNk1u014bBFqAvLvFYRXMw1XayOzRJq4QBZQyaK +v105hpCbHBKR1QY1p1CYXDfwyZBJVhyp/Mm38eNiT6yCzdPN/Z00NeX5wg+muNe2 +BrJsBjvaRxhM6E68foBB7FCdtW60+FwqbeDqHSS1/yRXq29KcO0DfbTwlZUJJeEI +lCw2l11WmbHMh50k0kqhDW9gwBjxhgZaYRITMeNApkb0EeUWgIkFv0NEnkwG54BR +fFKmuMUGLCxecmA2AmCaKym5/077WQY2iQIcBBABAgAGBQJNUm/jAAoJECrpAeXH +AhjSWCgQAM7FRqBjXbNDM/izLCsqWasAIgxouITqYylPVeNLI6eAypDP8fInmVPl +CYDkf9dxB8tL0w9tjRU+7AtvadVVm6G3ZPo5bkACatCIDWQKjRpBQNo71dc0Y+aP +KyduvhugPeRMoqtDZ6ygw8tG7DvJ1bTOhgZoEmOjFCiLxnAwrznsA89wffCKBHre +ifu6sRL6AoPHz5cCsw7+x9TYzpKU6u/k1J7+K7z0Wd3iHEVyH0Z+HIHypNdyvpPG +GU4jLZf9srdOj7QvUtb2c62KSgSBAMvqQ1kc9mmSZ12ljq8+WjWTS4qr43PYZjDd +Lg15fd11wSP0hZRRF/69Puv/Szz1L8AXXrfCOl9EFIbL1twIcPDaMl2R0xOmrjqL +aIq7A3S0vM/07gGefGJzBLSbMDmsoc59TIpqa8sEuvUvf42+QTh1v5UdlQf1FHzP +k7/9voaxiQgHACOZtm4qldbB2IR6EVTlr1uDi2kO7rlP5JOqeE6tzHimogYH7q5g +Jy4k0Avj25LbuNXtQN60thnsz5Xgr6CUTL7jf5nwCH6sbTXOh1dh3jXm4TPqgKOW +u4ZKxDl82MTwepjXpwOkYISuBGEfXClqGeeyFQLMkYMURSoonA/udKkB9kmVE/Ke +mrypGLGzaGcL3554iHVMyn+X1G4rvPO/dcBCS/vUh97NUIhssyXIiQIcBBABAgAG +BQJNUpMnAAoJEGTIydEeXa2YKYEP/1BSG3z93IVbkLhcFYsIIvgXTSVmjl7n8XX9 +H0DaOyBExUNs+vS3mUqUcj7jYBh1kjc/iY3UleIRwL4BUNY9ZY5mqma2foJQ2khp +b/zmm814jsxCGKtef6kW7getubbUgv4xqlgtCgNtfGwZIKge7kl0IaRM2xHbnUla +Yp1B6RcZx4vQAPM25nkdQbKX/RxjHpek3oDTvY3kXS8yV4LXWRgzmVIinMmz6l3h +eKbqkHFPCRvLLid9QhLEXjor/vyqPIToDjEqlHZduC9/C+zNenEwSiaT0U1+qoLv ++AlF+/gNbGfcSKXqx7la1RDjjj8H2CFxtehF8tWBSNrIbZ5bJ8jla6FkNLbp3oJV +Sjt5S5lVaBJIWIeSJJR/VOzxIEezvXZGhmpk7Yy0E/uzI4kuKZ+CJdl14Bb46R08 +rxkFgP0aeKS2o5+VPue7/wZTbFtnorT2MIHxk9jrOnCa/BnX9wGaRnf7CExrSA1U +qSxgVjM0bXyzL9ykpVzFeoGNSRicdVTaGuocrvwPOo4kjfF7czSiG+DNvmHkBuhD +/c7r0P+iMOkq3hOeHAX8Uotsk+jSK9VXDwMsZZisPBFMkcUqSolJMTe5vMYYgzt/ +KayFxVNDsIqu1consYgmhgPFHOwG/PaYnPGKda0GQcwhTN3mCIAZZnGuCJFM1Mim +kfbg0nPHiEYEEBECAAYFAk1S7qUACgkQcxyv01PBoy9RMACg3L4/IS05NQrxqGs3 +vewff577n14AoJdIuNAkBIw1Pv3on1B0oBO0oqrpiEYEEhECAAYFAk1S+w8ACgkQ +6FZiOLAMtTNecQCeMdRVI3ZsieT0YGsVSE7wQ9o42rsAoM5n6GXoZOzoDNlZ/umv +oDJ2wQZDiQIcBBABAgAGBQJNUw/hAAoJEKnIbI3Tro06B60P+wXAYPsVi5mBxoTe +rH2oesnTaya69uPAjNJnaFkoXDXAOJdotxDWPfA9XL0/k7SaLCb1OQ1UaKcsGe3u +99R3/iElmUlWuhTgV2F7nUmUTjCWXQD7ZnQZRK/ik59cwn6FfNywGruG5oARNUhi +FXDG1q1WCgYYlI9iLIZ+YEPhS2r+BTRF0+IRYS72cKBI76xzuXQT5qOLWyvqAMuM +rkbooZ8que5hztlUevjYjWPpC+zCw4SB7iTfWOGWxQbM0PtLGHNrABUjUyqb59dQ +lHrxdvLX4NoJ69eWurYuPet/xzvZ2RXxusisWSscGet9md5TchyyTf0oEFPBNlKX +gozwJEtdTuAivzUTnWG8WeSXJOEzxJvuwpt/aboNzM5DjpCt9BlfqHrhaGJi7ZFk +xVUC2/+EDBqxPAwLEtBQ12SFFjNcCsR2YEv77mNTCZk+oRbt+n5ez7UXammlTrcA +WKD8lfKm8fi6nH5j8dKuHyGTP4wpUtWVZIQsO3Lsz0GK5bsXuVXh0g3sqX5F+M1z +kPMBPqpdNgVn6hWe/HvUasTAi7c7B3UGL1kjg2SftW/MJpXWcaIYzLbRRB1zFS2z +qjsP5IPasbOXk/SdAV0u1MiZDDMMjiir/sICKl0MCpdGWn936iverXVIoVns9MNJ +d5QJoPGQv4so3CgkNyFnk3r4sE61iEYEEBECAAYFAk1TH+gACgkQjuCbLeYc358j +PACeLqBzec6DTeYCXFpeUgcpmy5MZgAAn1we3oD03k0yBR6Q22rScGXqVVaGiQIc +BBMBAgAGBQJNU+OGAAoJEAfefupVe84MF30P/26+FdlfM+0GyhTjWb6fz99N7vPW +qCUpxYLsiB/lcGr5h5Wn/E/hwDETNWsX7rKwQwavoWSJ8Vj061eM0xy8nBI9Vzzh +rzaMUBFCh7b2vtsokIUt0Z1bQfL+gKESU0hLqjSNC3WE8/fxPwSWBmiczWPixzfW +fHyCHwEwR5OUocRxORA9cVeWvfzb5Hdm5hNpfFNMrdG1LkoMJ63/SE6OTm20zdtT +/PM0zptC39TP7bmoJueYnnncDmCC3Er0mwC6f6VnMQmBh+yPgGV9J9Tta3EcOVk5 +g9SbEAs/c/CZ4okTv6NJLYX5VdKmF60E9BkwAZq4JVAZyrFfNJmB638Zgqa8q5Ya +sfaLV3yoFCMX17sLXMiGc3dOwneFTEz745hAqOw2cwDoaNWR0B880p4buOR4wFcV +nlsiSy+B6iD0zWFISNrrjs5izARYclxVmGGm9KlLSX4keuEXxaSj18PsSn7Muk7b +BTcjuY0+xmdwzXabHBkNZfDr13Lxb+L2OPkAcTlNH4473AK5rH3B3MUfBmOqpfw9 +5AyZ7IILieiFhrk4Fmz9Jjbc4GdsEU1/qtDmc/p9rXiPCZhqeiQi3qA0CLLmFpK7 +ArlFI35wDUXCJnSSh0mzERojiB4Slp96qQ19LmynEh8fCoDBYMnJrBpjNJZyBwSg +Thuv7bHWpQM7efbGiQIcBBMBCAAGBQJNVApjAAoJEFSie62pgy67yTAQALUp2yWR +/2VH7oqyIrMkDBWHjPUEJ1/beSnL0c7rNpLBybtIrkFNjeZIWfS4/jKNmoHqOgnP +b877MENp/UK6jF5Qc3QeyI/OXr/CJC/HWPWZ1o3/o6PIptDNMCuy7c9Uu4KFYnlA +c0EHuVfi1k5eLu1YJnXya2vXyE0MkngnYcPo1I6KQs+vMsW1X+wcgVj2mpcAfECO +F450yomtmwLbrWRxpRCT/vtM7y/sgVmfuBVV4jhd0hGm2jDR25p1tWb15cu1vXPn +FguBBvVZ6cVU41CEJtE9DfVN4esuKaLmA2pwk1wkruiPPCvTUhO13HNwEenG/QVW +fUR8j8d/64Iw9d2t6jRfUKdctvPhnY6iIZ/2DKq+zFEy2cscMd++kqmR9WCCqPht +obafxJ9LYoZ42IMNvTzo5xh4322shcOV/jZtNNvSg/UmhspgpA0mNkqUxMbUmhI9 +vRKTWT9qHbOuYGCt8Kp03v0bk/oEuXF2JcviUOOG+Z/eflPTfht/8baSrTjVmcYf +NXHmaamAfoHzOvaxlbBXMfhxQ9pTCYF/3DWkfbmBSEkqxpcFgj5AWheSUHzGYrsK +1plPLJAP2dOWfHVlHoNKqvUKH6K5H9ruKgAFUphLMJwtugVXFv9gykuDkGJ6+0Jf +fXxBghOl1ZqdeNr0UrvLmxJoPs72VznWcQXJiQIcBBIBAgAGBQJNVB8FAAoJEMEA +17V/Kh4mxZUQAIGalnSZuIg8B9BSgVP5DGBoMgqXcExG/T+Ee7R4Edcf7YfR8evU +tWa8QeA7p9hVZCB53Ijdu4wkA+RFgZg62MjXBFrbfigDm0uXYmEdQosnsFPUwC7o +4PGSaV9gs5UezKkD1ykDajbICxAtLPZhyQ6Gpdnfy+oed9Fg1o3aRZMbuI0bN7Ra +wp+QYXeUhbxfraIGYOtI8nnuBJiO8eSz/KoFEQFnctJwg7CZgVc0woxMyIRT0AfC +ynafLMSwdX5zJPXO1uy3sz5U3+P+YmxTqV02KgIVr1HpOPQrLCdZrsuOO4hNvY5s +wTG26I1SgVraxvOy77MYWcs2ojTVjUopImS9qMjIyPgGl/5++jrAkMhWRxTzUFEK +x1Ib7W696JNJlq6nsYXZg3M1oJm7ayFFck53ldq2U9++1C2gGbSC+k2E00O3uO2F +U3q7yxY+dqtpfDcvQxjaVBZFfz1023vRquf/Odt+JyR2Pi/zVYO195PKV77Tsl8a +1p/FTN4jN6BVn4oe0HKw8ZdxOxMESMhE2wqhat1vBbaK9YWnivJbFhZu3BShKiWk +jvmOz17++aboGT1lLLE0aHbp/ojV6O/5Whc0v8PxbMMJyoZe8T1dDotC0pFvOLnR +xWpfwOin4VGEWnFmEBrLHoY49XCuuZJTKlTC2XQP213Hdc4CTjWjJjs0iEYEEBEC +AAYFAk1UfCkACgkQLxrQcyk8Bf1SlACfZjVrVpMijWXnLlwNZhtebz1DmC4AmwWY +WyaHaLbKjL0D9jspj1W/8+l7iF4EEBEIAAYFAk1U+1IACgkQ7o02PRaHlziNaQD/ +Va8yZU0v/UbrbB7uZ6TSrfzvf6SUx9Wnm0kiOTcOGoQA/3BcTLSDeiEWG/hbI2va +QjuWHCisRdbFx0cxSEFjxeE1iEYEEBECAAYFAk1VLqwACgkQvuFuLCp9giBgkACf +eTdajdfiNr135pdh0+pP3iTss4wAn3pNcbohhLfjowLPb0/yQurg+KKyiGUEExEI +ACUFAk1WxLgeGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5ldC9wZ3AvAAoJELR14ge6 +tYIpBx8AoNRcJvGN+QmiOqxZSBZkFy7zawNAAKCjBJUz1dzYDiDlRDdJEkIIP6R5 +2ohlBBMRCAAlBQJNVsS7HhpodHRwOi8vd3d3LmdvdGhnb29zZS5uZXQvcGdwLwAK +CRCUj9ag4Q9QLp3gAKCIe0+D6ZYXfdISEWMDxWVwuFfliACfVp70kqaGLsOR3duq +U7JNrp9ikVSJAjsEEwEIACUFAk1WxL8eGmh0dHA6Ly93d3cuZ290aGdvb3NlLm5l +dC9wZ3AvAAoJEHoGhUIeiZBCV0UQAI0wf6PX48YGS1SlwxaKZF4UOQdaQkIWXDO9 +1OUwr0YVhYdngtWsj56qg5wpWpPrerT34ZvqVL8Glp0X7DpKBMJuE0RUmOsx70jN +ikCTsgVUyic6AWdtctMOuZhVMqgZSNOFiZ17S5LKisFfh6RNDUuLBjw1v5ntGuGc +zZt1tbT2HyncbrM3otohJNVTUFf6+5M7VPqC19zAm/vvwA9bJpQNabBVK0zdkCKD +b4A41RDwWGZ3bW6YbtYdmT4B4ldEAkSzNlaqD33w8iMOaJVYvYr5EJluDdfolYHb +dPlTZ/zzxlU+SlvJ/tGSFCV6gbSXkwvR0q6921F0WZ6+Cl+woelKRjZ99IbhlhN1 +JqgRyQGKa44/48As8m4RLlSbq8qCb2MNWaROXgduLKIADQgElTtO+RLzesNwagn6 +zt+8aDIlERhk7nwygxCVGv8l2TuBkfzNvIdeBJn5o7opfpDaEFbHUmZDOOWmSxWA +I0m4bQtn+MiXzEEbwyhxYZ+zP9zXf2CcyUn0Bz4nnPybr9XC+9rVQ6qTx1AFCYfV +1BFmKh93dQv97M4mzp9XT/7crtccyxHN8HlaC+bQCz0dJWyZevyPdqkEfdwDxpgo +lFxCztMgl3q8eA2EqN0Oo+RKgFKGyjhxi0jWzykug9yRLBLzQ13s/psuBauPchdg +O+oEADUriEYEEBECAAYFAk1Xw6oACgkQApCeGpL9E3JLwACfXFpGkHzknIPBQUfS +foMGu8W6BlkAn32Xh//Uap7rjTCvYHNLymp4YvlMiQIcBBABCgAGBQJNV8N4AAoJ +ECbjyHWnRCDvzjIP/A53JyzmjaBrgxiTXmFdTSMTzL64CneBd9AS8OAiJ+PPWHZJ +I8LjJzwt+8X6I8iP4GKCrcMM/yn6pbc0JP6HboEgY1JyFAf4Cd1e6DrYNrfGYSkw +W1MuaagjiBZmwFGsAy4dfQvla0/dLhQGdLDAhbpb4evfxMQj9VaGyBAPTgAJL5fJ +JMQiVMyI3g+PEm4SW7Lbt9/ooFREgOorY7GBeRLtoYMxkVcsMOzWcNZjgg1AtMw7 +ewRGx+JIaRPeDL7PWU4dgLvcBTj2YDDnPrpHp76xwncyhky/ipeQj7/+ZBqsaY0p +KvJON90IeDLL5xvJoFjrvSu6pVJnLqQwHNL/9dbaodiGe09st38ylCLZXUbaw+uA +/5fUUb6dpaeQ29RjXMpsz9uPlWnO5nrrFlkU1D/LGCduvw9WdWMFvWFXeNP+8kLR +hOMBhWawLXN7sDiy6R96GON3F4XIgz39UP63KI73VB5o0XwLSkw7GLlBQ/9t6ZT9 +/DuPhE4m2zIhUy9O479PkFlSmswWXzIIcs/6zhzrNugeRaT5yNBdgYaHOrB/vgQd +PzQ0FBZXnQOPzJ3mssV58PZQ9dLAXkYNCN1BauwyYJBACc+sraLWdE41t+oq+ghO +R84sXgT+Hw7TesJ4Ap84Ns8CF3s3u2bLBCNgG+qdPUXyipn5uZgSFw+7uFiEiQIc +BBABCgAGBQJNV+wKAAoJEEC/7oaLBV2aN5QP/jzgJAHp3mJ+j7XfVCj/462XDwHr +3RDZkgAnlNHP/XymQNa3m43bBnLdXy1sF9bMhcrBzDmC80eFXKkaJuOx1Tozu53E +ABDuMJV/ycu5PvHZ7+nJ4vxFCeua/ZiFkTkHKCHgPxwhtAQK9DaGnFaIsod0Ytj8 +XXaZM3eKLhfmsvOuHAbLpRMsEg/f3wlNZ29v52qywNun3j1OokRK9nOeVPqxbvKd +4yY1aGKsnnXsGtY336b8/t6IVhPGJ4oIUegEo13LJqe7xBoGPXfqrXlz+K+ZcLvT +tx6iuYBg8u3rS3hgvo8RASBjsJ+KclCg739FarftHBkrLltueMJVb0+aIKSerIx7 +1zR+1dGgY5KKMBu+ZiQ5zwLdUKdm+07WNYk6x8qCQOu0+1hZY+eOUgIlSa/iCYck +6MpOrsMYazIgTS3pLB1tHWpfVKjX+Q4Jdax6UFsyyPkIePwJDJSudEqOJwgA+tes +gIWlWnsb9itUE/TB06Bm1kNcmwi7NAWAlMMcfzPsla/Ab+sJy7AyUunpfQw5aeZV +6JfbYeSCwgM2vnXFgvbXxwlmUuf8GxV4P84pZmrGZt+xSHdVT09N/kbtOd3n2ZgN +25FpdY4pd+zlrHaVSWa9ByZ+MOenZKoChLc9aWjl/8xrmJw3eYCI+1ZL2k5YeZTv +hQQlEuO54iSNlyVOiEYEExEKAAYFAk1YLdEACgkQ3FzfxAeN+kGH5gCfYBXDJUcS +ROnbaU1eVgTfNKSVE90An30onInYRyuScQ/zr5CfUAxVh9V6iEYEEhECAAYFAk1Y +V/EACgkQOHp2lX66df8JwgCg+f2fBSlYrViPxyKoRbX3x1whp+AAoJaWkbxLYVbB +RQ6P0azqeLidtzA5iEYEExECAAYFAk1ZS6sACgkQ7oGSpuRD1thC0wCeMNgp5YnZ +wNXASkpB8vW7HYXVplwAnRUqQitdpPD0lmMWGJtgpanSi6+UiQIcBBABCAAGBQJN +WZf7AAoJEBFvXjqzaKTrmlAP/1l51fwvmvgN6sibadyub0CSkMjZucsNqK71Cmbp +Rv3PG/za/cyrZHXa3r/Uaphh1pA0FbXzRLQ+npavM4PjgbmEH5n0xEwsUi15xi7T +9JxqBWSzBOvGU6QhoX6Oajc7jnF93fnth/o3q+Q5tAMEyOfEvkXsNYe62oYRHWAI +d3OGklJH3wg8gYBdOJRatM+R8PgS5y376NMYgLGMKL/6UPBqqMsL+aTyVbeYFNLA +cNYUiv9QzYrHrP3UEWv6IKnX0xyXrrneSWPO705hl00Ep8fkGkDBS7zLkiPpPSPR +HYpg36fw2UdooSaQpCXqujuAgBmQP8hcM2I849jrLb4Rqith75lywBYUWPXeYQV/ +dS4WTKMNU2yfVzm4b48nAojrrOml31WmIVYQz9vRj4VOJtB81xuaSufe/vgMqD5M +RARwMz0oNZzUNL3mhvjkLVuDO1DbWKwwNuuVtepC/z04YFWqokQ1URj6EMvGMSIp +wnKeZHZlk+nvnW7DeD+2JWGcU2xJHVZpxfz+q9gtWbVI1lCAqsH7fetlkI774tQg +ocfk76eZtq+RIs266wF3NaGLpeoUD31BKLcgZUYaw5aoT5B9B2i3PAOAhD9uAJOs +2emUO4sT2zJ6dyEnCx4L17fzjXhqLSzzkzNSg38SXOF7/y0MBj3mdRLPpmWDynvr +Qr8JiEYEEBECAAYFAk1a8aYACgkQiOa6Hv703QPxcQCgroAzGRBf7WpiaIDVBsI3 +tigDK50An2SjnZbY0pJGHBBPHJBLgnV1ntv6iEYEEBECAAYFAk1b6HkACgkQCVo/ +7lJLCVh2rACdEa3aMojb0KC/x+B6tMSevdi76KMAoK61Egf13D+VRVYfEJ6EvPoB +QlisiEYEEBECAAYFAk1TE8AACgkQbQvHOkBYGDc+2ACcCsTLQZDeQb42IVCJHg+Q +38J/c74An20zODbkxxaoTHoTxpZVn0ZhiduniEYEEBECAAYFAk1YPpIACgkQ3ao2 +Zwy3NWpjzwCeMbyrhsXn0UANXhMgbFJpUMKT6bwAoIut6V80X8EsmNHClTZo69bR +GKEziEYEEBECAAYFAk1YPr8ACgkQL+gLs3iH94eurQCbBIg3OajOp53mJSmI3Iri +OGEVOSsAn1379k/KEiN/cGDD7y+LRucUmytGiQIcBBABAgAGBQJNUyTUAAoJEPO5 +2Iy4f3mpqh4P/181amy4VxANibc7N5Q0uSq021KcpUQbs9xrvURrSZW+nNPmDHEB +pmL/vuDlNN8SNknF3NBLzCfr426aw2LbNewb5McfajJqv/CWRATqMMdSCUuFV3oy +QKzzB37NBPzyZMrol8HsrNcuUJeguIqVbqY3lZkMi2Mml6mCr/QjK+BGadU3/dIE +wl3HnM33vBNMTVjfvNB4HRQQ08cz01EJzQ0JIYZFG1gmK8gJWi/m+lBsWJ+b+E9H +UEfF32kTUVtqfKcfgmaYMBiL7zszWvj9bN4mivmWDZQNeCitxwLzhZ/70QYNu0tl +sS9NnGop54Fiplqt6cGpD1jQganCiWB6EEM98ziCj5ifrMjN3jhp4F0VYyuZqqYU +H7FUD/G0SXo00c3paoPZWDAfxvHRXZgtmaY3+uCdLp+Uk1basLjjR/TW9tl+OsFO +JatHc2yKMaOdbX8kGAYTI758rYqueJ4oDBpU2x13XBqV4BPxU/Sxwy6zxh8OkFWt +yNb+LTHyVf9/G6FJKIuA7eyxLr0vO1N96ogwY4kGIDp3HZGamWHMOPnJqdLBqdUw +RXc2HYPEhLEf2g6abPdthE5VGrrehpcqOiWkBnlRl9jaMAebbvAvbsLHL0V3sNks +8mR8tCNfih1j7cyXUKaoOPJNqSCWCNHHzUcBnwBOMIOQSZ0V/nccLr0XiQIcBBAB +AgAGBQJNXYFEAAoJEL2ZlXIk5RGerOIP/1D+ptmgkdC0ZY5kTX0A1cGog/COfs1d +fVGHi9Vt8TUcUuG3xS9y4mls4iNAU81mTfj8JNUcdaLc+mafp83vycGv8me40S5v +cBwmFOh2BSs5NeqfOTDPoNfsPfo6QEg2B3Cfl9EEB9+8RuchnrnWJgcQgJC7/bT3 +DSEw12xQcBRFBfoNSfFF46uczHmKCOGuRIruYVCiJXLoGDdP9x+0eS09RxlzIhD+ +7v8TFe8XhS+l2XL0D7UsmbqY+q31Rw2dKpDqZcW92bW1avmnE9cbXnpTQQJ7M1yo +8xqyAYDqtUWRsPUp62xeXHOAqARDqq9581I/IL4v5kWBFSRw4XIaFqnoskBVWWGk +uAXNCWnkahUFYQ/jTAh633hySqX0doa+cVeHbReWp5eIKnDFY5Kn9EdBK3U8bKXi +5AfdmUmdAK8vAMRxy9TDr8Jq2mlgh0GtaHx2t81m7HGUB+dOyRA+97qHCW+6O3o7 +eDUJUgOnRCAbCRX11FR+WkjTO4GKNWMnmYmO3FHExaQZHmjzktv0MCHQVpfWk3RH +YF0VoqJNgxWKG5sOghZAUzoFcKzqt1P7k/dd1cp/sNDWJy5mXAplvk2Lw+0jMXo2 +tZ5xZHBI+t0PdzoAuxGCBEV27iVtzMnN45zmhsS6TpSBhQcbQ1yCDLrw4c72VmWj +htGK56M3ZdBziEYEExECAAYFAk1dqgAACgkQkDXDf3AkB/ephACeMwyih9kdYqbA +Erd81FMlMOP2ymQAnicz+bCi9Np19SqW5+EJ4zy8LifmiEYEEhECAAYFAk1dsFoA +CgkQPHmTtDdFa6xqCwCfVaLc60XqFWb24VqSwrN2t0eOh0wAnjrrTLPOb/S+eCfb +ARgs/bfu6YGjiEYEEBECAAYFAk1evFoACgkQe/sRCNknZa/KgACdGt956d/UCnKM +1fbWi7CqHPUsnKQAn0AcvmyzqzT62HyZnTJD9YmaUW0fiQIcBBABAgAGBQJNXv/Z +AAoJENNzD7MkeDIgx3gQAIPrpEcCdEx8hlawvgoHSi3MKPxLUX3EZ3aa8k1Fxe/z +DkRs08R4EQ3eA950ThwtnCKSP+qQkcCjwqX6YNQlyw9FpqIoCkcUILxvgJk3Crq8 +Dg3Mwssq7/flknroQTV49IuuEzUdLf1C7JtXIJnXqAQrmPocnYq0ZFbcuExq1f22 +0l6FRL4pIT9mEgfIKXbsPJNaukpoV9TEXr+/JdyO/oRr6PouyCCL5RQ3Dc+J3eMR +RMOA3KHGDfwu+lXMKWtk9RWtVs9EjjVl3AmLeV1EqEfrq93GWX5zmC+TGYGpGAUR +QqXQoywoMosJ7J37W0idEBDE6ebU8v3PC9icfctcOQpsErL5iGIMdM2hp4omg381 +klCOkqeFxCz36IX45lXr+dXq8Gw0luVHOJwalmechgszb1erBXMdTx2fhvvOJe+H +TdohMwI/cqcUoVbPSz+/wbEqsHFQFfQspFCciVQHrDkg51IIzhX4AQo7zpjdS18m +zONmYN0UYYFWnMZCgCqaEOe1ZKim4u2niiR5eCRF+ur7UXueipJ3FBoEggeKWSqe +MCFBp1amosxhZleMLUeLjiWW+3+YoXjdMi6l4NfBrbobZpLrxDqhmYTOQg27AAos +oIKDaCFpA7iQQqqGQBGgqjvWdQ1Uce78yEKGO2Zkr8RHsqBBE51C/DxS4bx9yVJp +iQIcBBABAgAGBQJNX8TLAAoJEAMD31IlyOOG3ukQAKa4FeTnlaeN9hH1M2iwq1R6 +p62pHQ+74y4LhbrZ832K6vT1fGJen3l6B4a7XtFZqh9hwfwixOlg9QaOS6ubw463 +ky5gs0F45y9c8Rr1yUjUUoIweXXXVfrX59Pw2cPRZ5mnsvXMjHNcbNcZ93VjuMq1 +Auxjqixp658A9/Qdxux7rDCFLQ/EktN64SwQxNgy5mCKlPDfFWEMh1m4DBw9ui/v ++YckdL7fL8Mxw3REcXbA/EFS59eOVnSiHHwiaNUYzQ0GRFJp+rZKrSbyrCUL6CMA +aB1mUwAt58wfEYVevK14cq3jAoSQ7D7OIWz1OYI6pfABJdZaJJAKb+kZ03YYQj+F +ltQxuouifdmeqZh4S5Y5YHwvLyZ2gUGp3h6pxGl1arnuCXfM9scu0ilB88Si1frh +lsC5CHJ4jhZN7tvJlK7jswEPXQFXPRvJ2KEeO7DRpI0Wtt6pCK1wLrLL8uDhv9xO +G1jCWbPA7Yy2rYoh0fGZIMFw0W3zWTPplFs8gC2HjuE4SyZTag7e3g/pRxkJ7BRq +6rv1mNbi8xB6uu4QRCXj6I0fsmTIU7DNLjIcE2gjDaoaVJiQ8E36ceeatMaefm/F +9m7WeZbgJe6JSvV7V6YMdP087evtlod8zOyzpVQ85yVk/5Vm3QJBccO9Ad97nMHs +80LgBWPTcXD0ct1A/moVtClOaWtvcyBNYXZyb2dpYW5ub3BvdWxvcyA8bm1hdkBn +bnV0bHMub3JnPokBwwQTAQIAKQIbAwUJJZgGAAYLCQgHAwIEFQIIAwQWAgMBAh4B +AheABQJIzrAHAhkBAAoJECnuWLmWhlFx+SIMGwUvNPpxJmKFQf+dz/BMJt6jiDpJ +9DkElx3iLBPpYccXtpwo5dsKLt8ncI3p2BC5O8e1ojbA9kfsdMy5qfkZxzeTH4pO +V+KU8JRP+ddR+FUmxt9jD6fSlJ46qphgd8xCIcmwzwAVAW9mWc0Z+lCvrFsdIRXY +KxXMUEnKCsVdsfwACzUiV7GC2zN17m32+1HPizy4DkKgrdXgw+sBr2JMd5Cfq2G2 +VxN9iIhW8IR/vjLgKTyb/w50p4S5kHcLqi5/i9c+IwCey79rWfbavWRmBJYpdKXc +3pT76IdZ40hhZhvftke7Yhw/2aVsW0T31GfGlXl+41Hi3ztymWzWNJcIDnzK1lpR +6tttfSWm73OZ1b9nadwykAnM9BwLVtr7powUzdZ2vHQ0ll85by817OPgMOF9H0j/ +iukiZVUrHJggy8ViDAvfsq3cVg2nzrEVj4KxSEZNmCHXlOwWoe6gCK6hldffzUTx +5sLjTsFtevVaKO+BH56zAW+kx8bzlXXf06BqLvc2GECIRgQQEQIABgUCSB3m3AAK +CRDhXdhXsVw30QaBAJ91ZK45pKmsH2JmK5Y2D1aMHJMn3wCcD+G95oQguXUGe9Ya +5A7giU3ylvKIRgQQEQIABgUCSH7ayAAKCRBKChvI5PT/5v6lAKCe5soZIh05m3Ci +erCH3lANYVFtAQCeNGGLsoqHHWviJsn9XiKMcvAG8uaJAcAEEwECACYFAkgd5bQC +GwMFCSWYBgAGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRAp7li5loZRcSCYDB9W +3jROns3zcDa1FajxbtLibiTzDOaOoKeIiFTAdjZXmwIkBQ35BDwYa+UhQF2DiywQ +WuJjvUvesg0x5OtlTCBu27PltRvrvPaTxSnKe97X/9VVFkocX/rrt9+hI6NO6b9c +Rm06H5gBJCZarjZNbftg2sTEmV56lTQBQGnsgGOSSI8e6GgaXMIpW6ppZflUc8Ms +P5VZptY6oj4e1Tvca6azsH4YauK9WDXw0rbavr3xKmaM5I3KJLiRByciDJZbEYN6 +HXYuTenjMfE7Hq1Janzo/dXg8j2TV/nRfZD2e1UZi0sTYQBoVDS6DthpWHnO/+sO +bHTj1e2fxS3+Jbw1lbynY7Q6YXZLXJNSk8OnpW6NeHglhCABgS+fgXrEZMzY9wzY +K43bUyomNB5x4j4P0n9U8dDcQ3jivGfW6UHFnZO8e7JuwGdMmrR8JGqh5zOpHfLj +7+43BW6MbobAr/fBq7yMdyCYmFQwmNbXPqAHsDgBnPOut5f7J5xBAcTtayJ7VeZy +N0jTiEYEEBECAAYFAk1OpR0ACgkQaeRidk/FnkSKjACghnZk8PjQB+gXHktY8QQE +69JlrmoAoJwOA08rV36UZ6appMM98u4YvIcNiQIcBBMBAgAGBQJNTvdZAAoJELzb +lbcKo78O14sP/RTLFKoTWKPPo+EVquTsvo+sUVJGLqCPedCThnyBZ9pwjx+cxVPI +f2Y5TlpB7GLpEWHCbZy4w+SvkC57d0EfaYPUMmMLFcm4zrIS8DPcxeEblPyuHUNX +mZZ9YQ/3asFQo9sSaCxGJYF5ihyYctmF3zwkq7Aw41dw9wOhJDfxC8wIe6SHEer6 +3JdyJFGXqRsBOmN9Z27EPqF8K4tM6gFexBd0hOGuJhTolva2truk0Yh+s3M4NhPX +Wr6NmDpBHGurVGQjjcUP9qy/MjWzhhu1U30dIlyaIBlWJe2MuIbnXkMGUZYuf+I2 +bdkjmmZjzFoJo8hmPBt5hEBh994hA+jF265zRYfpYMYMGJ+ZKUW5irxU4sElCfla +akXxkGbkBT9YqyR+oHX0gN7tzaDF/p2N7yIJGZ40MV5iz5goMPmGOA7vMJMWtJjp +O3rUZu7JpfJwCiCjkuH6T/pRB3vuh2gUrwHmZoz4PBHRZDYjhogc4BsHN+QeVlJp +Z651p6+NCPmiCbqFZO+IfHuPwoxwjM+fnC/wyKDdDcSVMnRYijc/2gCI+abE3wSz +cQM2xbMPuqBGwKEPKlhSaSGYzF3NHwXv7V0vHtIqA86hI3DqiCw1URxdXDRoJp1W +eAl8PClP1DAZUSUP+16xheyIowAMDW445Ui8RkUtOqPkZJsTJUFMrYqNiQIcBBMB +CAAGBQJNTx73AAoJEPlBB4h4NHwMRh8QAIWAzdaD4dunF+WS83GTETwZ9J2wf6mW +FZ/C56FOqdI8jGuCvFjrCNSV1MfpXAJnbCuZkfScpFeAmP+G7maYqtencj2q+Qaz +fGB60f3Jz2vHBjCaK9TFKKk8TtarHpwfvc9m62ZShocbf97chi1E4gdJdV179Lgw +voWBQELTrUt2gofOCyKSOB/YMJNmbozztBlfgTIb65m8j07DkCjiaiNrqhjy1aUx +23M4WHgsp6SL0HUAks927oRZ2hfihHS/nbudFZjHp/tcmQ1U4m9BeZP0G2moD6Yb +CYhRSaKcaBrZ7Rjmhl+3yoSA9xeL6ftEeyyUzk+SLp8v/4cp4HPW4hvRVF2mj/nf +IdnCl51faoYhDrWGa9uYq8WHqbyDJ7UEFvf+LHzZx83efyPOO99xsd6U7OMBZsQf +VSGKmIxWW1I2/Aj419gPyoYc8E+xNqeQ/OkXe5u4vsNGw9ozlrt5s6iU1SqtqJVc +YqjQoK1ErdtFvSys7rPR8EnB3u3pc+yg5+VfO+u4iy0OI33jOLB8TqcHIkus4DPY +KOgp/wnSIApkpXJoeTTZcbwyIshv3paNOEJ9w1+JEQeZ3umvc9hmRLUm5io4hsOh +G3r4ioNgZU0Ue9JAy+ML7i030Y1LdCpGTTKJ6R0/EOtPWPn8+Dpvw6Ir6iBodlTf +mumXZsVc5NCuiQGcBBABAgAGBQJNTwf6AAoJEODYD8Y41NWH0yYL/jeGGhIOqQpX +iaWNLfVvUlIAA3lNaxQZ8VJTfypgU10QMWMyUgbkSiq1aI09mmuaOjbOhrZILVSz +gQZcw3b111lnzdfmRR4ONE6gr71oyaJ/EKcf/CmWxiUcC27BIMFciWCYLLYdnXRQ +0qf3q44QmNZVrKbJaInXll4a8JjQKPoFRqXW09nWLxZnLydrZBNxMjuLYzrSdngA +aLaM3a9QLjGIzqwAsHL8afOzn1JXityDZwtSN0EQH6LzDXqcfnq+ws0VFE2GPexB +hhryYUA2+wj/dnTxdDilrbR39JLOjO7h1EgJE6GMjek0kE4jr5bjQ0dh4frWK4im +6Pm9pMtcgUY+3yqbO5HrszY9FmtQrilgXIlpLDYEWPYu/rjKQ+p+uxSAgGDyqeN5 +dnRtX/iPvsIWkTvwMBoBI2/zY2J/+2CMlEAjmhhWG73S0808b3HTOjwu1ZhDK9G7 +RWHeHrnwfpfMD4IR5p14mLCBlJwQ94CgNPU6L0mb0Fqi9U3Qs0Pv5YheBBARCAAG +BQJNT3n4AAoJEAJasBBrF+oedMYA/A0PSAv11mnhYOxYZJgTodrAQc7lZDMjC75V +gIqVJm7OAP9YmZaZyA5fSWhazJb0nTsCWobq1OwO0eXwO8qJK6xHAYh0BBIRAgA0 +BQJNT9FdLRpodHRwOi8vd3d3LmEyeC5jaC9kZS9rb250YWt0L3BncC1wb2xpY3ku +aHRtbAAKCRBxbUQTPYwiLU6/AJ9CMbR4ev+QdqcJksW5/pJfX051SQCfTorfOtL+ +BjIwusl6Ar78uS7147mIdAQSEQIANAUCTU/Rby0aaHR0cDovL3d3dy5hMnguY2gv +ZGUva29udGFrdC9wZ3AtcG9saWN5Lmh0bWwACgkQVtUpPsl6BlTnzgCfXBrYdNSJ +H0ay907U5Hz+r9rQWrsAn1a2atSn8QjSGrQgbLXhM+pYd2JbiQIcBBMBAgAGBQJN +T4UsAAoJEJmTHiXZHgEsKH4P/RdPtZUdilX0Dja0Gc6KNIkx8Js4QwT3Ujg9J7U8 +WIg5pFVVAZs+27E1wUEobJsjk81k8hIWqibeMeQYq76rExVH5XUV9kcOXvCh0ku4 +Lp9PRKwtfOYE0D3nwn0Mu7uhjYPK9YiyegPr6IYuP07Bbru1wjual00lG+5ENonz +xkP2hxjeETqEuR9re/uaWZE08iuND+L37uDrJYsERFEksSsMGsq3IcuJZhgu0mi1 +AwUDd1yo4zcXzci7RIJifalIcKEpxuZ6s0ddW3Li4/LVFFNdn+ReYJvRVQt1UUh3 +yf4NLfB7Jkn2EMKFV1EVJMeuevNXvWnp3RsZoEt26iG7jyJQDd5Ci3LNZfhPMk8d +3+NoBxUBRE1qifsFPn3hjAF97xeyzqcxt4GF2hXrRk4ZPkIglX2a4sL0647Q8ewr +h10SYPQUnqrBh2XDy3Dz/jnRB4950jo9hkxQmYkY+PweN1v8ae717dP+qipss/9a +uZ6ZturqZ8eAt6TP7iU62WT21dGk8o1GE9hOkZ8DNdbLNUt3x+YF81kKzyFZKRiI +mgpaal9T3Sh78yMvgGwaoCigFjZNEOAEiarwk/udQP7kxTk45evqDMW4GbzmxVbq +q+K6zv5ks/Cp5jpBHhC7xywI2qezzzU2bVCVz0qXKeeUKq42BDDX5xbmzuvrpHw5 +D9EoiEYEEBECAAYFAk1P2tkACgkQSTYLOx37oWQ22ACfZnoA2E7hLlyX8vIY3d0F +8HJ4vzoAoMjEZE6De8zBbw/l/8J66vzvWQh6iQIcBBABAgAGBQJNT9s6AAoJEH6X +Ksv+CnrzehgP/1i0OD2V73dncQoYb+kiX3nfcvPQoBTVWrIDR2qlteKvKJOMD5SU +NywSOzv021X6FViHqO4GF2ylwI5foxskXBVGDBEUB+lRZ3vTkcEy5+2S6mfgpXrX ++q36r5s7suoFczfB+pj5hxP3MMjxP43LK9BnIdw0WP9jzGUgG/2zmMHz43UDFE6I +fCWcDT8tewSy5RTHPPbYGCCepXqPy7+PSTYWJqibp8lXX6yVbV/fCmsfdwPaHGSn +OWEUQZatsntucORt/c17J8UZ52L0Z5RTHtjVcw5sTWGrI6EvN3FuFBNde4VytjnR +BYBvXWFJMC+/UtpvKi47ma255o5jjVGINxyRnZcco0ZE5PruR7a6zcN0/kDvgG+t +gWhnA3/rtnf4vDr8SvkiqHnYDXe9477mQQJxB2qVjEjo+/yTlhIqkufXntIg7cY8 +SRqhHXElG8QBje7pdEK0uIgG1r8wR1wTYObXrHUOOHGRIst5XMsMQ0pld8UjpPFf +UXa9zLfi4f45W00FWTs+mxrG9TUq2GXf+f+88R7aZrlUHQcprui3VP8XKNjQasn0 +NWptwtmnPHhttoR/7UJkPAGokudJ8/w73oFEMOeE3lIGVDnR0sb/IfpB9AvXahFx +WB8czvkBJ9XKW+u6iHTeBfOWkLClNW5h7JSFwjc60t1wis1U5xm0QbhLiQIcBBAB +CAAGBQJNT7aCAAoJELWetyIC0bxlbvQP/izNRABnlXd/QvFOoykMu0fU4/Gu/tYy +UdoOgP+33Pp7aUh/TcdF6rC2USiBBTl2TiMhylFvASp7OKEqJ3eMbKWJLYYUKwig +o3VJ2uSLFENOa0ID166/nRSInC0BJ4WLtp7tGeMEev+Fc9FKnZJpPS/Zo9Mwu56L +Gwa+yiu4oD/8nV18paldyUUAzc/run2NRlDwBCsNtUON6gcSTSdafo5d21pbycUA +dS1BMTY3dEjh3IfOo594SYyU7ORSrx1g+7goPjEg7NnW0c1TzHoSM7IVwAGv1Ss9 +ljYxJnJbpSJm4vpEUBZcPV4sycAacqrApSryHz49o7YEQ/jqvmE7V03XtBEe5IwN +KOjz4N/3DZAD4+J9RLVognMEOpusaKk4cVTZfI0jJ9ArAFwHOMg2VG1/wgFIsNDu +H0HFWDM0pNC7Y/vBDpp/pbgVAeMyjNZnT4P0eseM8S/H565iH96DjE4ip5etwbWv +eJd9B/a2F+qeptwdvaLe0xKf8LkMdOOWBLkJXqisP2fQCUgtVJvDZOmIdFbuGiL1 +1UuKB07WjZ+UxEWT2199CMSCqFRNdHpYeaZU3LduVVPxpzQQ1xPs6tGOezaBy6rg +v8I/XiseWsheOrW2XPZOg3breS/mvSuySvJYVstBn/BFl6957qWTokqAjXZLaScM +xk+X9wOLx5/uiEYEERECAAYFAk1P77IACgkQmt2HQVqjIlYD1QCfRFGLjPJgcO+I +4psit9iR13FTKKQAn20JJgouI1sJgi0IJtitX1Kkrn0QiEYEEBECAAYFAk1P5fwA +CgkQ5TEV5bihnGlFrwCdGhn/XG7MwiMsORLg+ZxNRl6oXtgAn1PKRCqk1oc6km2v +e9aYrZwbtu6KiEYEExEKAAYFAk1P92kACgkQ/LC7XF8fv3Br3ACdGU87KUx9HyCj +V1I9021OHMuMYi8Anig7MZw9DBCXRCgsUAX7JP6cCTX3iQIcBBMBCgAGBQJNT/d4 +AAoJEJ7cyZHZq0V+Aq8P/14Nn7Ec3cjsTnkbFzU0JzmZ1qcSUc6u1G5nVB0GNURS +eWqmfjeTuRyAfY2wjg+VyW+knRByP95I7GpQN+WDTdiRy0Mv+Oz1dAYrqTRq8xMQ ++us7BIkzG/nBNwHDEZ9mFvWa9fRr20DHcWIy5xvIxPqgeX6Y5OgXj1I4CyPy98yE +n38FAUKLM6BfwXtThXC1sVQdbIlo9Gepn1wkOhLPmFpNdRyP7rJXYVh+q8qV4qNU +ln6yhwBEVIuJrNXl1+m7xThBtaCYJRpwjyrINgD/zY/oyF4XWcbytzBoRWOBVWJW +AEWUOUTD2l7GhmwpKhnZcfpnKWqC5Z+R80yCHZmAQC4HFoJZocPasyETHZJRBH8g +5iw19H8mM0EptmSKbyKOBG5RhyPHZYygiX03QfynL8vgLO3vEUc0/e1BdTUypMuV +LKS60dfD4bsRC8FO1r2j3Xc6YWtvIOzgF12u8r8KHkKUeUkGiibouzUJnhnQmZ6n +boIDgVSbWI2iihe4t8P/LLrdFMscAmob4P6zGTJlJXdJGPek61YCW1tQSof8QgMu +v8lAVEwec5HGqTgGBu9mQxSSi/W7Dpe3EHUdP1ARughCcXBwVLWQlLyeTSnXjmUU +h0zAj5RUWCoLR+LdS7lBS013+e3VDx8iSz4M31GcYcxF4UJ0trF6EoD7p8Z/NIxA +iEYEEBECAAYFAk1QBP8ACgkQjbzn67sZ6APnqQCffIaneh9hcomE4cvvDkbE+wWi +Ms8AnR+cRrehdcJ5OkfQadS5ATKSHe3BiQIcBBABCAAGBQJNUCDIAAoJEKgvu4Pz +1XAzCP8QAMifbimyKsC81WsrO8oMWctqEM+qHGZyupo9w7O5mfoVgtJQB61uKPAE +KgIrgUnUIii/qgnXbisBxWqMw9ifI7+yc4Q6GMjpa79PtSobqdt50io4cVXw1rdL +OF9WSg4GdQvlM7X/bvBR+xdYkJQA9SITbYgYpNMHM0W8n2/cfO0DquCy0Ks30e5v +RZdJTHhkYsSuls2cfW79sDXtMLVGmbp0G4Ec6tXHGktpLHieRzgFpzEZSOudNL9s +d93/fvq/2IqpIFdkN57mpk66vTxkUI3mzMrBEXaIkdNMgrO6XbGxP4+643RgCNcw +fKkupHHriG0wIniQu+ICWeVvgw52P6Q7/JefLyJkPBuaE7Kz0BeWvKJnel1wH6iX +8mS5v44cX6/HdYGr7aK4lPcdUAZ5JY1kAVffF1nKqEkVb0uQtR9EAiV0GaUFN2Bq +/dDTfwIuoBFIfUQux39UB/yS6KcIrbLobqo9zaR6+jTH35lNX6H7yMNZTAaNqMoM +0C5ev2Q3335eaRrrgCLb5eaNjjuJXxXsBl8iYgtQqQ2zzRc1qDHcz+sy45jcP3Fy +STHnUrKe/7gXVDIVhxJiQaM+ecb74ajffnCwIzTOZJvd+y/n2rljWXB0vJ/l18Vi +sBVY3XnfNR3Fcr0ahIJpJMuNQRg8/Sf7po/zLHPWVkcrqJCNWN8ziQEcBBABAgAG +BQJNUET8AAoJEH3DJtrNcqb92yQIAJsvk6JLoDTkUuJzOd9xFq4vcHtLrYo3ZLMg +AMYzvSrJfpUhfE4Ei1/SBvk7O9nZSvnSAnq5Jp6B1+eXFpMrPDAn+8v3xxhyb0eh +7NqjP0XlTy8T7Pm35zIaFDLZojzt6uERo+4uzXESXrzdTwbGrfmZprDjr3ttt1q6 ++mBTciZsykmVFM7haBKSO0qcKu/570L+qKE5l5YJ9qFQmQ1aO5UlTKeoWVJrcy2T +IP9voYdWs52jOi5gfmfqYleopNgE/2XygsE3sKqSHAzf2qfzqSDOr0iDyr9WnNAQ +GO/sWvI8tF5ZYK/AfUeLiZOnPGYHu5sO1sh9mzl3jqPoa5eMi1yJAhwEEAECAAYF +Ak1QW0AACgkQ52EC4M3+rC8LPRAAlbpDZUUb4CwtSoQDVpR0z61OEbBTR7MkVFnT +w7V9FFQdBaRahw+qcv/0F1yN9X9ZT0BTodvKchFjENpfK9/XijiQevMkKfWdFDly +J+rw2r18RIZ1clyMJY0/ThEr6ZaG6wZlunTUQq22ZTfKTTGMPsrkFV1JBaLJyeRe +riu5S/vY1ddHK1s5kZGjxYwn2PIMRgRhDo0DvyOUTh9eH/fFuTmCky0MaT8bH6Bk +Q1loaOrsq24hNoGie38i7YbAXYjh7OTZ3L88jYlFzKlieIDwfhMxoVANqktkI0+x +Cb/NAXhM304P2fW2St7Ocg/XroUxuAdtqEX8nu2SEqF8AXn40uZNAGtslVsS65N/ +3bty72tcni8i+E6h8gbEdj0sMsID52/Z7NFVCT4vUZzvPgenFOCdSfzXOaU4b1If +OxzNT2f78Vg6ndCKqv9Pae50kcqt4zcLZGzY5wsAgxz/Vmk4NiIG/MavfyjGUjyl +ZNs+j5cBsW39xKKHN8x83T9VQWNCy8u7hEm+SePWYK6smYSdyt8uGHzIcihJzlbz +HMawFKCjoGySF/ziIMbaT4G/3ekVPFfA6mxT6uG2CGTCq3nrrk60sXzw/4cNwYi2 +32GNp25ijfuowJSBInfx6aIDazAwzW4AvaZjA1V2UVFQrSxN2hiSbSM0FMG/DJJK +j/xyrIKJAZwEEwECAAYFAk1QZeAACgkQ4NgPxjjU1Ydn9gv+P6+C/f0RgfgKXI4t +xQifqXdlahAswOz9MZTkcrRYuT4/+WPAmis2Y6nPQP47pKC5+qRL5LKPBPhoBXzM +JpBWJ3m+ZiAhtgDs0DF/RCq95MiB25W0gIYyUxpys0TcOeUxPbl5725fDkSUZLqs +yQhUd0lISuoYmtQYxHtxjwtXkh473nybg7AKO5NLrl+3D19E3fAaZUf0qO50skOR +yKYB16XrOzhFcVW6/j+hh9D9eEzldhKgQasGvHBrO1SO1yVuuqtX/WQ1aGdI+aXy +nqb5eCcRhxjQGDx5YnqI4w6vnfyDWAtM/QMWXS6pibr2IWlj1dPwoIrg0yKLsn9n +kCei9xdZa+L2fnrxp2Ag/xh+5zLEXCQE8ruP7hcKx32X5LAjXoGrWv5i7njmA3e7 +ZzvoRsP0a35PrKVDHbUpW17+rBVUuz52HnSqNeqrH21281Q34Mfi0jja5bcwLKEX +e9t4UYDXBKQ/vvu3DGlszhtbUWmNSpgIG9gWckGkm4T/m+ATiF4EEBEIAAYFAk1P +6jUACgkQnUKBHfuLs3Z3QwEAtklBLDDU4slBNg7aIa4EAZ2K4/Go+F13JS16re/N +5O4BALPgNAB+0qLgDg/UQmDmyFjIO1r5vtp97BeAdSwm1Y64iEYEExECAAYFAk1Q +Z2QACgkQL5UVCKrmAi7qFACgjLJp+SJqhcuWnZzPcUz4wzxq9uEAnR2PIxKzxdCk +CXOsatQI3vIjWk8biQIcBBMBAgAGBQJNUGdsAAoJEKwwh5qrVbMSB8oP/inR4xG/ +WzfRfjQcgVE74fqUcDnhdxgf7rhR0rwBfyR4o1JDTCD6qewgRUaxVeL8og6EBVXN +RbzZMEcILpnp1TkxgyaIwGDF/6DGZFLnu21yr7Ggge8VQcQKzrLalu7fS8q3F56T +QoG6wz9ZDc4FcjVkf1SqyTCRSs8z/X8IlQAafxlJ+6OZixn3XLm0VIugmnyLIb9C +WBc31W9whi6yaPSbRRmK8b682UUaPRX+CNdvGUF9bmSOO+UZ9ZbZFw2/aUM+gbqf +PSipj98L7eTrgkwitnw1dWqo0slwQvwSAReuEShRUYK/AWBTOeV2E6akKA//1JXB +CIyqo/49KrOCItQooC4Lq99vni1/upkrclUX38YbtC43dorys1RuBO6/wTtjmXH/ +jkLosCz/3AdLVFMFbR3VmdwmgB3HMecoqEAN6JVELoWHwYorlICmq89HGfG6mfFW +0j5OUrOcAh9jznGepZqld0teleNGOUxvrn4IBhYXmpjLLU0fQNepnwt993a13p9r +RH8JeKDbpvf1SZSsKmnEtNv7Heo4/Cq4EqCQOzIeGPPx5VLvEgRQRJBYtDpEgRil +NIRlbsAbY8jPP+jqNDWGpEVGgxn2Ur9Am+S726C7xxGH5/wtoOJ+sdGxYz1kOG+2 +DdVqWvD4kYgeKdeBOYRZz7bYJYUW0Wvs65TTiEYEEBEIAAYFAk1QflUACgkQ0YHd +emxCgnJ8agCeMRp8WBYWNCbqUHvwRO/7p99MgJQAn14s6L0GpTJYRDdhwKH8VUMZ +GUHJiEYEEBECAAYFAk1QeywACgkQMAKNJEgTtf7DFgCfXTyuaCVRMaL+y5c7OfkN +NtM5+coAnA5/AtQJuGbXeVJPevmp4CCkEew+iQEcBBABAgAGBQJNURGNAAoJEJyv +zxFWdG+VwOMH+wV3QlGnBhIUC44urq6Cl1TzPrgg4mN8B1A4XRoUZmddH5t7XNWV +6YCZpkZh96PJfi8ldi7BpQsRHpbM5sgXWhMnG/SiYAu8aJelwd25qdTVMJRKc7UI +z90j13t3zgD19Dan+iODz53nMwaYG6sXFGtp/PusU29y5mkzORSlYSdJIVShOPcU +nIdx9x5xK1SfVEQIMUVaVSu2hkbBhO1ItVamjdyEYLpEglGPOK+gHuHfgbsuFmH8 +jkemXfDwCQbmR3LdWaW+OhYRm4A2KcZ8YTn44RHZHN3rdvp87dJPq5ZzNk5RL4p9 +LrxJk7xlPhA+QXtXVCz0DniI2nBxJTOD9f2JAhwEEAECAAYFAk1O6qEACgkQZ2YA +3NpamUNVLg/+IcrO2swBtNcGiKYQByDXAEMFKyUZyy82ItLucVIkKcepILXISBGS +tLuEB/EKl5yl7SvEUJOofJ3ZdsP6WlqUkJtZDZR9IyrojVNCg2r4BsPTPVuc5icB +esl3nILdaGgVmUdzYScizC1RKanD9CytNpExCq1Sol2mbO3/k0uNiw9Mpq/CJfJd +HJIaJ9wOCT3oGVxZb0Jg2+V7TMnNGz/xUkdG0DxVxHuGU9ITzcEyvDGgEJM3868h +yR/R997zU78gOJn8tftAkxI8GuEBaH/jRv9JUxVpIODZ5SHBeozIOX2aoA2sdqoN +f/mKqilB5BQkigdcZah4SS+oy19l4oJW+aRoTsC9Xbk6wBokOnK9xOkwrtTn+/gk +b9Wj+EZGKYu4M97t/L1bWVI+Dj+JaNYua4MbOIRzoZihLjxxtemsScb7dhuzqn7Z +rrOLLxfmXUibr7fYbH9K/P4vhf53vSU38nCa7GrGU5vuVoD8m+cSVWvTgzWeJWqz +NSTQfBJiNuTKUDqglkhZf9Wz+YEXfZxcve4xrniHPKnn1mAmaOaaFg6MmFdM6ods +seyMBeJds1BqfgHKYydcMl3e0UXv1Op/0n4om1wlhu/kAKnDPkhJP2yJzVKEXCna +DG3gmJc0dHtudMHq484S9xLNdmWsJy0wzZzIrtHpbNEISZm7PzsYn3CJARwEEwEC +AAYFAk1Rpt8ACgkQ6VqBuJ5Bvjar5Af+PlVTFRMO2D6MeyY+yLUjTHTahq1HUyyB +9e3vxj+R/vq8eQ7lDQLz2QA5h+ZUMYXNYtWj2cf3DtvmIzgScgz1zsW4/ITPIf5/ +tnQKcwieMCRGpsDwm3say30QJdb6vsjRRJMuIXrtwfri/RdlvFYvqZRxpD+F55K0 +cAM3wFX4FIOLBFo7V/unnXUyuuA7AxAYcGtXFl9H6jjtQEc0KaHgMghUrdTfn16h +XfFrNrHWCAHLh6scC52x9JU1lVsj6Q0nXeqmY8GC0XLs6uN5uXGVoN2fUaxygL6C +tqAR50cgFz6+Xa2kSdPT+xGbdCVdHpdO316nUanGSnEMdbn7GqvcMIkCHAQTAQgA +BgUCTVHGbgAKCRB9FZHGnvryhmQoD/49Tv4Yk2xRfkEZykNYcmeWI+ePuV4RoOkX +ehWyUPn5A5TAdSXKpeSBQ88nE8Q583x+DnbiHCXhUY9G9QSpLa7AXunNWPNgWxCR +sGuMSTAP2Sj9xVD3AD68z7j91DDpOyd4u5OEZPFQyY4orQX4Amt8ifRXz8PC1hDf +80KEMRsaQrgTwRfGx+R3JxmbvXwA428I+ClMPtopfloJdq6Ye7ECewZIwyhiywGx +NKi5jc+zZHKfiz5X6PpxIOgftnc3yepdJ1DOEMyp5PP/4gNOP68qH/Uv4WSPqvia +UFhcNG/GFnD533LHoiZAI2nWQTkYy05zzKa7mX+gOWMSQ48PI3UDOKi9G9NVaSGA +HnPX1qA5/eZJsqfB/uGiFHlNPdsTgcIQD66D/xcVym+9rozixpadGreKNcg52Pno +OV20Sial7ARX6wC2n7vNs9+VjRR5+wmV1Ytkmxi+NKEbR6w7MaaW+Aj/ECxvscrw +xxROPE+N/D8OlVDjBSnVVq/WqmZ6QTkcWqBYl/MiqdY+hv251wfrm+kgdafOqfJn +Z0P8RTDfXbAs8FGS1FE/EWAc6qIdIII8KqyWtGCi2sm7AmDB0f6ifElHWAKlJbZF +nnSHmvFbE9je9WZGZHngSqDz0TGhgmsNB+7E0IpO/dr1MptvL5HCGRsp6mB8B4Ie +kK1uDk8Ni4kCHAQQAQIABgUCTVHgwgAKCRBesT6dQI88P/2QD/49QnP90wa92MiM +wPdRHK6cIuT0/azpdwDDe9DQZIcKmI2U8bmY74z3z6UGXlhVeyyWJjr2wKeMZs8J +XiGx+nGVY4Ghgx3zc/eX1zzapDF5lkPjlXjBQCATFq38z2+rQgMp1hyyHP+xM+j/ +p1+xGn0Oa+xPgFqGdGo0b/qS+kdsWKazU+MILsXzVTiY6y5XqHxJBIw34X6xzjlM +8te9k21DPqp9fV7cWZzDzmC2EoODrDmq1nkk/5Hsy+gUay4V/Ew1E2Xkc2kKPXqY +FL8XblZEnf1zSDSJ5sQnhMZe/pJXAgfMPsKl5cwTxlE1VI8kl72M6LKsLDbWbZRQ +a19eXSIpxI9EksAVXHA2UdMUuWo00MouxIOVLMaW9232JOwdzFE5NNsmnGTiJ6sW +juuXPdkFKrS1x3aef27KtTW2Y+Nesn+xQR3e6UFgK9T8+E4B8Xuj5+Tt8PQ1jWjP +5B6iqOdMXx7JujZRErMuOD7k5QuJWqBjdxK3GXTE88gyFUbh/+kPy1nBpv7M8A+A +1XHbQCXk3GZ5+ep7UVUhu2PJvSr+ZFs+OkpMy10HwUzOpHiRPSFVcf/tqeCnJtal +0PRd2HNjgZ2Mu4CmBCYdbTND3xuY566z+m+/FtIxyAo+G5lVAQ7HihX+IzBlXS0o +TF/EFTUdSaCmrVsXseyRZSktcGBHEIkCHAQQAQIABgUCTVHg8AAKCRARL/dAg4l+ +Eo3aEACv4Yv6GSnYP+Sg/pocai6mId1drOqn6zE5RBK1j7L/s3nlp/brEF9H3Glg +WnhFbpHsXNHuGcNfSGNoitVenx81a/OkMG1A3TvHxtQGg2UjIU0evJ1F/Nb6j3ol +CAiXiyZu2Y6yl2aJfk51zfBYjuIjZ4vyr1XgxCIwNUKdQ5ZacJD9JLLMPQYLe2qW +kjRr3uRR6SoeTZGkSZQYq2cITcXOQsaAA4uW6g55nMpVj6EA4rXo2IU6CvAjyk/5 +Oa2W/EBmWmu17qeHq8vSG/D2qttzy8wLx6YeNfEDkZGo5/mI7pT4Wl1krDZHwUNP +RrL+XEkpKnr16stnPDiWLUqCvebHBd5aWjEmeR9SCuuIxzWbCCDPBqHxS2zqpIX+ +6k6cEuoex1NHAr9C5/+lVh3evjlL4C+yfmSwNFgIMBLNPmthLLj6CZND8tCmeUTN +wALGY6X8KHJ06o1XZa8aK+973FNt6Vb0zwrV+0cLsO3OArhEUWdYQqZ7nE9QuF6L +m455MkpVfblJ5zEVhvCHjWP1B9urRXYHIK1wHrn2qB5F3twK30JlQQRVzJ9h6Bz7 +RsLxOQ2ReMqVOqCMKuYqAGO1XelrW7t+8nq2gYphsNtDkk6/2bGfGNAOtjgwU74y +A8SASxsS7IXTj2KjA4r4P8WfL0pMpngZ84ygGqh3+FIs43R4r4kCHAQQAQIABgUC +TVJv4wAKCRAq6QHlxwIY0swyEAC2Dv3KQdGaNjQvM3nWixGe0Ah+hFkC+h6OrTnk +zt14fZcD+S5EBLJZYQlvnpvyqCvPsLYu5z+rQkjJFNdSCdTjJm9pgZzZHjMbK5ZZ +at3O5KWIgFkv4H0rIhbdC09voSVgrEVPVFIRYGro1e+zXNV+Z4Ickt1DYKMPvAMt +8YaI+rvaJfzCTRGITqeTtQojK/MUp0tLdqGnBIoh+z2R4qTctaEyw5C/RtL4SQ9C +eTDwP6mfkepyj60yldMVQUdDsEXGObpI5pwJ9XsiIymwUjK4qfuvrLinAK8SlAXG +o2nv36S6NQAIjAaSMp3NNhcgubcq0MgLJFcrxLj/1fw70crBYgu1GntB0RUcxRRO +K2OMvWlgG7fqJ4fI/btnGwCkToR/O+ZNIVzHAACk1vjltd3BLJlC3Kn2Zf/m4rgb +g0WIrTZmV7gwlRx9M3OcKyUfSpYcDTlHuvUez+R3E+V2VO1at0opJUuww1stmZT9 +X5xxz+NdaT4tE0BgzeI3zbeic60wI0WfUQtA2B3yYX7ZeSef6Bo/LFX9q+jhMgTD +Wus+q60241RnFXuJcBQE88duJ8i3CMThAPzVnlqcm2x0K/1GZIiV3xZei9Ow/j3P +Cqu+PIuJWUtYD5NZpD55LrmeqBmUbO/YKz0XACeOtu7ELMIK6qW0zbg1rhsv4ocV +CYqf8IkCHAQQAQIABgUCTVKTJwAKCRBkyMnRHl2tmBsqD/9FNgtxKIk6bCw9rZsX +m8+Syiast5xp8878NNoZWHZ8hFJjarAqxxV4YdEi1+jMZD1C9mrJMOtV2dv3dRib +e8KsUpmoet89K4ESvCbFoAmWtq5WhC2cYx446Y0vOXTPRH1JerSUw98QBNnQuJF7 +94oyRx0TKCEHlGeajlJfSbQ2F2v3knT2uMKZOy8HnQVpKSnFgb92+MGvJJzgsC0Y +u/GCBwwBV/YWvtaOL+XpiJ6JQ9XKRBdYaOZ/sFcqC0H05SI8RLerTQEREF/7RpSS +0I4F6sCv+aDzZhnt4ykYQWQCDqVNsZudoalpbMJtBTKGp+c7Ma6LWEFDb9HunweL +/O9i2IKMYwqUD/CjDrlwyJVZh+M4yjSWV0+80vN+9K4TbA9m1DQpJBAk0BL928VX +pRlAi3DKT5VjYAw993EXFKZPh2YZLuBIBd2/hQ0Wd0LVovCcLiMhqYfVWkhCSSc1 +VdIWaf1wB5XgOsZNfxhCt+KjZHoZsmT4lAPnyTNGBCUspgywcJyR0CwBRViI9WXA +57aMkSJ3g34nOGrGnkm6mUvLVXOFYPWYj7Fz9Gz+EPv7T/nDtEtNFC1V7lxfxK1T +y3czH2RzwBJEqjlg8YzNVO5T2X45di2wVk4UKffdvDTcimzUKsxSxRhMJNr8rTME +BNjQ+Ar2C13PkTn9vCGVbIJJD4hGBBARAgAGBQJNUu6lAAoJEHMcr9NTwaMvessA +oOD1bq0krrRVThv6eSMedB6qrWuiAKDOPCcxx4+gapBDTTjsUn1yjcztIohGBBIR +AgAGBQJNUvsOAAoJEOhWYjiwDLUzXysAoI/uVo7N/iKGrkw5ALSdozXlhNXSAKDJ +GMj52BY26/oK46dgonWnx63FZokCHAQQAQIABgUCTVMP4QAKCRCpyGyN066NOlZV +D/9K9casbrPRTky7SlBLL5+w2NkfqbujneW8aZPydRh3uoYtilQVjN/zptBUFQy5 +B0Iyatl5w2FjYgN5O1NCdKfOtDZRM8JItjiK5ciuXt+/wVWNe+1aRLdO5m1RvcMY +taQQ3QKLhCbFbkV77HaVY1ClJiXPh4TcSgCl/dFEUMH0Bch558UaKq/n+DLBPnNW +oXlTeT9VvlzFmVo5aki9koUPGq/QQ1u1G0maDXLdRDGfoIsWg6aRJURra30RzX6a +HGm9zcIV5CDp7OPWVkfqaOe/5QY7644zlEfTujl2U63QN/p1tBvL94VICtsQbw+n +vSuVeoWoJesZseIdzzJ3HONBsrwar3gyY/pOIK/TvoBOJHrtH/5grVGbfPtXOM+D +orjQg1FtqrX9Hrb+d/PNV1Z7lYipEutC/KluifkEIfCY2yipAvLS9rZ77/im5++9 +O+Tx+KOJ5tzS0dVsGSZXHdXZsj0c3nCLQD6tf9h38/VU0kIP9uLZl+zt2d3qjgTo +/cyxREjxjM5t+egVDnRKYpptLJfacWPSH6N+zEefK89/OfUZucm1RSR03J0x6+1F +2/ocdR+mkzp/o0kRW+1Ta8gm/kQWkCWSE5lpPmlOSS1pb8IligXrHtnXkZzk0Ueo +dwN+VPWmPS78c8OApr3gNOoobv3zfAls42osrd3+3AsVrIhGBBARAgAGBQJNUx/o +AAoJEI7gmy3mHN+fnLgAn3cWNv729nu+wpqZ1JMFZPI7zhbNAJ0ac/wB13OLHc4j +r3VXUIThwhMUcIkCHAQTAQIABgUCTVPjhAAKCRAH3n7qVXvODHqwD/0VgIVLE7vS +7WQ0v7T97ErMUnkG4EVBpO01yhVlM2y6qUhf4owH0pIDrWuZxIwGLKH6BM49vnUN +ab90+SpnlqToIaCzXYCTBtFR4RvWk2RAJhQ+kbYMv3bboqISnwN4zuJ8s7XuYFO+ +PoFIYWjpoIMAnmikODcLx5GEEox/Yiti7Tp4UPYSND7XzFXjkbKunFzS94F60xvT +i9zmt6fBDy/zZ8GC9YDhasuQh8iwk6Lf+SIbCEV/L0FXUPswsPGvaW10PLRvzaqj +r2QIPgtJSZUHyiai0W72QfghqBUIIz+WglHjPjZ7q/tVxlJY6Nor4YHUl34zDdb6 +mKq/v57BVroc+noHDN8be8BUXhhZTshu8wd8dqhXb3+s7DfFg1f5jAlMz9L8u/DK +aQOj3sSRa36WQdS/PPv66uvo9v0tumV9fRyiOJdk69Ua3cNnWqSle1CkYndljIeS +lfb/10nFTGs2lK9rYWArpZzLj70zHpwHfdve98ivUGnTBhqt+tFjBYQz0jk9HVoH +ZoNZC7PdybLBlXKxWR98qqVxURVovAcDaQEisEnNpbmWYHVJcU8+WGdyFZk9gtoa +MLNxgVt3eBwUD8UoZQnqOWPq6XUnxaaUD2qhGGHp4CKd38XEySD6XAT5YA7/jWEa +PzOGRF8NCJInqie73ni1crx4Zx0L0eMOO4kCHAQTAQgABgUCTVQKYAAKCRBUonut +qYMuuwmSEACIGWMfdM2bo0k8Urqh1c+2YZVsBh7z/EvUjXs5alBSJbarcjWsImFQ +5hMr6HA+IDiOvSM0elFW/bXvOczAAxiZ7Codsb0URWay5bEQwZNQTWcrmsvtKMr4 +o8kNIt3CQkhqGK3ng80jymTG6fU++aUEksz+K0I1BMyfs4EoQBwaHzuRdysuxj6O +F6ycNiSd8r7KmL2+8vF1Td8YUvfovvCx79P/9W0zFUbDHOjaIPBNTu+qzELXDX/B +Iqrb46HjirgmxZ9mWzFtfOetXod4LHpavrx99qsKe4y2fIGo/dl3DX3zxhrbr0Gc +qUOVchQ4ndB0LDkKXs80Sq8rFU7Ik5DKzEhvuTXD4x5+DcrDN2rrEDOjLiieEOvK +DEmFGUJPZ2ajS/FD7B+lx4Ab/smTUsY2hKTWu3+JtwU2fZurLBWtSr2qX0RHfvdE +wS2YTVqrPnIq457sDVN5aKZ9uS6X4VDFvgnTL2mTB+ANNLjydHM/sU/Pjozc76dd +Oi7VexVz7Ii/emY51twI2UjUP3E+7CLFWljqTfh+MXfVqKx868QA/4UoGJL9PhZh +zPucV2gj0dg9RdVMvmvvriR7ysH58pSGN+4oMe5QzjPRfiw66fSvHtByX2a+uRB/ +jAts9AQKfFfyKhdBGETRtrS4ndP6J/D2FURO6BNvO++PRVyQW55iIIkCHAQSAQIA +BgUCTVQfAwAKCRDBANe1fyoeJnhJEACD1QPzQ/MihbGztc3CFIuXU8CpNCuD43Gl +PF6Ivrc4i9pS5SpAD2wviFaS/1lqP07gExvDvgVoWuNeqNlY6VL5rO/Rta8vESNK +18kD6ktKhMGUhqWSbFPfiI+apnVjSDDOYND/jfh9CHmTmHPnRxACaqKLy8+6xGZn +EOwxcFTmmuFpjGH4XmObw3EB8ue/s1sdj7K19Svk+6Gp6JEA9LnO0AkWYmt443lY +GG1c2Bjz3kDlOJ5hePLjlahPrywepj4RH7VYX+sWkgvzGaLijh11rStOWgkRLDcL +7nxxLLRsF1HO34i3Y5J74llc4rYCJTPY6qCHtBopdj7ExJ5b0MhH4mS1S86SpqJA +F6vGkjWkvHLR7IG/mIyuhPkJP2i/wIsG9ED1SO+8t62EzuVvcetsCILebEe3i1n3 +54BbDSSmW9+RRX6eUnIKOasrxV5uLPEKOa0yyzkwM11/BMnBdNjbFYN03r6qGbdE +GTNYkrwCy6clGhxHiUhzq48+wf8PQ4iLw/YD4lqeBTwKup7Jp9M34UskbffRde4R +hY/oE18+yEi+vBR4fNur20m6qlKPdgqGQrVUFzBUp7W/aZ1cKRqEcO1c/zMQOtzi +avITYrFdG8xl6IHVl1H1v0tysqDV/WTcDk+c8p1Ol1lhZx/1C3bQ6I44/UoeZf6k +hGk3wOBtR4hGBBARAgAGBQJNVHwpAAoJEC8a0HMpPAX9VAEAoJgUn84COn7IOUC6 +GROIpmHS43RkAKCNxGtjgPx8lmOaHLqZa26ZNkdegYheBBARCAAGBQJNVPtSAAoJ +EO6NNj0Wh5c4yn0A/iAELBz/7of/0qQp6P3YFH91ubg+7wh7LWp6u7m8SYmCAP47 +0vlNWaxrfxFT2zKaEpW8MK/IPkdZ1rBfrOraipC4Z4hGBBARAgAGBQJNVS6sAAoJ +EL7hbiwqfYIgmb8An23Q0Ne4LfjzUBIMYW1Xg3jRLKckAKCyZna66/8fPlohQ/uw +WI18csJ23YhlBBMRCAAlBQJNVsS4HhpodHRwOi8vd3d3LmdvdGhnb29zZS5uZXQv +cGdwLwAKCRC0deIHurWCKZe4AJ45G450UupRVWtPVl4Bs19Pit54hACeLMT/6pTj +qB1I804dDGTfcm/0wJqIZQQTEQgAJQUCTVbEux4aaHR0cDovL3d3dy5nb3RoZ29v +c2UubmV0L3BncC8ACgkQlI/WoOEPUC4p7QCeLYrPHgbV8NOat6kUltBhkB3ha08A +n3DR1r34lwi1vEAJUEiAAhhEkVHOiQI7BBMBCAAlBQJNVsS/HhpodHRwOi8vd3d3 +LmdvdGhnb29zZS5uZXQvcGdwLwAKCRB6BoVCHomQQjgED/sEugXl5SPWZ/GEBYB6 +BLJ5laoNs4ud9Pc/Z/MndeFKT5GjClK6LDd0HQQLL4SmSKGRu5gPLFWcVFke3Ueo ++mXpMkWcqCpO/vXXPNp2d/YX6GGj06VbJj+qzJM5+shogEx5Jz+7tlWdSD9YFBlG +iZLn5Gmi1+VOmyYy7BHEELUG0aaEYNdiIZiSu1QZX95FM1SfYfarj64F0sbeGkwH +wG9Xa9R1YjCfbwk9WTj/SN16mg3ZbEuGBlXycRQTZvEq8Q285RxJ5MM/fo6sk9B2 +y5cNyNpxzPPEV1zPuErWyGmK/YwcctWMb/Z18dNbI5XB/CAwrhfhRSExbRUuhMNN +56q/4Loi8mLZfLG3pI+HHMCQvh1sEG3ZBNVasf6x9fg2+gh+tCG06V9VSfTXA5t/ +l4d7GWsdO/RWEPL/F4e//Ni1y+N3qpmCUXJhIxBk/jOspsrIJCo3UjFc8CuPxanU +N0QE2LZdvHDWIQAVSbSFiDbIGA1rjdsFYl3j2sDAQy9etI+7w6+9FVmSbXQNNniz +Mf49kAWrLKkdZZM548izj42UvQhAT31K7+EbCCIN9dondPSNUInuGQpSFwa3L16H +NV3EkQkz5FPfoEfA0ei7YqZyt6qvN3+l+4YKKd1RNKrroAp+WgdwqxAQW3AljIqn +z3W0wmRDi9DyAKbR1RDI1fSMF4hGBBARAgAGBQJNV8OqAAoJEAKQnhqS/RNyTjEA +nRicJHgYxu/OaEkRpiEaBcWken8hAKDdGuqg4R8nYmpkUpAPv8tmOKfffokCHAQQ +AQoABgUCTVfDeAAKCRAm48h1p0Qg7wYMD/0VQEAIB2j/BokS8rrbG97tmxRCJ6rz +qebHpwkvqnXsid8ePXtrYuFe3xnLkg7+ZE0C9UzhO3AdNYup5s/4vcafVFNuf8br +p9iMYO0K5JDL3E1pADyN6EasITDgle4b87Skfx9aduRd4DNJlE1fdrMlSKeYxNU/ +S2PfVB+qO/dDzxqY45c4zae3lcLyIga6lBBK2bMIVXIDVapqKyHHTEGYyq9aMxNb +jIpJeCCgB9r6yigpYvRxX3BS1qryeuR9t10nIb9NYotaSE9eoYRUhfxlb1taDOFV +4edXrJXV9xta2IibyQcAQqUj9npZocHR4QXiAcJQgbmTX30nvulEuYutNSTgkbh9 +dEIUoCa6ZvPMmHkvCjz2/tawcYVfxZwVIg/YgQecn2pL/LJCxRbZKYNx8ovQFQCm +SH1E/+oWRXytdobuX5GvEfvnnmvguZeFDzE4QRUG/CtINEYabgaP1UyznffutbVU +0qK9UbkySmmykRi/YyaBIb+Rb+rEdyQzfepWIgT7GYBQcN2q+rYazzOwny/nBCY/ +Ffe74FFZYbw+WFtlU17uEZlKp/z3FtQxpq5yj4kVib0P7BqikzllG3LejFk+UWH/ +qw/3QI7afecugXOKpbaYtP9w2rsGs75wKF558eZclg1/I+prDU9tFpwQEiPrbtPw +PzHhOMNENx/2iIkCHAQQAQoABgUCTVfsCgAKCRBAv+6GiwVdmrb7D/43OciE3Twc +HJqUCC51JckrxPc/eQyD/UnW0SOEKSWM+3EI3VPv0HfRMrdKl9aRIgzJkG/Lqnds +s4DFAGbgqGFtJgPsM4JnQSJcpLrnIHuS0vSJYZQ/dz6bh6lKltY3GEjnAwjLLrK9 +9TQWG/2iRO+hCDHZynMgHPejSPOr3oLTR45njf/MiARN9A2YV7tAgHBOXEBJxWgI +V9XQfCIUSAQjahkbzmn3gWlna5vrhVi68IXSi3WDNESz+iPXYW7IDBvs53yO9OAn +WcTq6SCzAmCz8eOjeMzw/Lh+YCGf6BKxPszwKAixCbP4bFMx2iIy3RWEWUGv+h88 +ckPFNleWfbJfbl5dHlWHqwvFHKhKIp+IGLXKxcQ4XY8GiC9yIX4dlZxV40wJgwl3 +mIT57NL+HuPvbpJvYFaJ18e1L0K+NaDXIxxNQqmaLuPxDqGDnWIC41UghXYwwKFn +Bkktuv35zXX1MJHIayVkA29wOvhII0jfcnTcXUz9o1r0Wxd5l+NX7gP62AtDkDX5 +k80AZekVH5GsBj3DhT46/lN7JFDlAboM3nVqAp4YesVOruzFLeAMTEiclEMlXVXJ +c/CTFx1mC1lscYg06UlJUgwsUrRvYHQX45MlU9a7eB20a5OQEow9sgyXhYANGJVN +RHpgkiSnls466EAERSrDjccVVZbPA8Q7g4hGBBMRCgAGBQJNWC3RAAoJENxc38QH +jfpB3HUAoL1fISGeRB3Lxm+BtN9PsdZpJvhyAKC25dOAMZxtpeGkLlZiTamYC62r +lohGBBIRAgAGBQJNWFfxAAoJEDh6dpV+unX/QAgAoJIFU1CjOVR1MhlNzb/deGVs +SIqMAJ9zT4K4K4LejzoMP1nxFiu8HTzSnIhGBBMRAgAGBQJNWUurAAoJEO6Bkqbk +Q9bY+/4AoKaL5yrRNWRvGoI7Q+gEQOGgV8lkAJ0Swr96bY1DVGOPFgWEGJfxNh+D +dYkCHAQQAQgABgUCTVmX+wAKCRARb146s2ik66clEACMpv4ciK6+y1+TpwQxz1vp +suzlwy+LyyZ7OXICpgsZb8kayfwJM78eeV+VNsF1DyyIbtp/emqrg+U1mdaWH0+C +U/Vr96gIYMDrMlDjlT7eTYgjlb4+vHgWErvdyBp0sSMZm+IqZqPYJG80FG5SqSUT +m+zNPS/rLCSiUP9eRxt+hn8SanXe9vHZn87+EM2cFoWsN9kITFqEWteYRn1Uh3ru +HncGRifGF75Z3GkpAM04lRL1PUt8f5XXvSX9xJINwmmjH0+wfUxibbKy+vtqHkK+ +27QRQcb4NT9W2mKQAAaUIX1RbajS9rTGSoT8+9KfI9gRpuRM+eCItO6TRONpDUYB +dWr6V+0q/ELEfjwEbDtsT+5JgW9T8aie7X7jTuaogoJxi538zjGTlBtJlXREF0E/ +BjpRI+I8ihVG8HhQo3HeDwB9HqfcWXgUpwvzwEPfCK8ejYcP3NZjyKec7zf7Hvqo +prrl50p6qe93gxdWV9KaW17W4xCTEIMTHzSCrjpCwCeXzRse7uFisTW4HM/9w5oG +O1rB6ivS88D3FfLjj3HANlcsFQgDLCa+bzUOh33/hGKgp+fWO/R9b64A9mPVZ4sJ +/mAixmEukQjkAfIUs9chtLPagijIr1Z6LMaVE27LVhJJK8Y/rDpxCwvYHKNKE4Cs +Ymd+QoiuW4oHziISf0gP2IhGBBARAgAGBQJNWvGjAAoJEIjmuh7+9N0DBfEAnjgu +3f20h6CjxxZEKIDphBygmd8VAKCo55YConyykYeNuxz/f5h0j79YOohGBBARAgAG +BQJNUxPAAAoJEG0LxzpAWBg3dEQAnifAnVUBzTbUbfDlfVbWX6s0dypFAJ9q+LD+ +2pAyG+yYj+WbYQ8tRtehpIhGBBARAgAGBQJNWD6MAAoJEN2qNmcMtzVqL64An3Jn +zuxmO/dmAmg6IZERpx837du1AJ4vensZ/0Jl4ZpP+Ml2cfTRhMXwoohGBBARAgAG +BQJNWD66AAoJEC/oC7N4h/eHQeQAoIr7wk5skdanCaDuLU2jMuFUAvabAJ4xmJHQ +30nt2Fsw/z2wGjxG9+2W4YkCHAQQAQIABgUCTVMk1AAKCRDzudiMuH95qeGlD/4i +urnrFWLyMyzn+jhX5JCkDqD+MYKBNMkHUr2ftV629L08nT7mcDmP0DkxBZ3beeCM +oyEzNJVvChW1jaA5OM65c/630Kdq730IdG/UN0Y+bW+mRjII+IRkKDWi6I7DM/fw ++GNHm/MLDcYXGUZ1I9MKN+VvztMH5yzoLXI87sU3Iiz7aaYoVzPq43E/F2odhBy2 +YZSmb9rWHKiM1KBQnW+Jij5slQwBWSmM4KJLqQFGfrwLJOZoGCRt+qlKvHM99Z3K +9RukB/KvsjsIXGvIevap5xOVP/TOxwFm3nj5edQ0nXt1tpRaJ0uXmFkMFwFUjWqA +00zCQV+Q46G2wz1Jz3LYTSTwY/If9imXEIRzEMrchdbItB2b2skp0FCHrplMRDUx +eGABg551Vdwv0SG2QXtK+F3IDV8WyXH9JLSQ/x/YIoKN+iX3MZkAjcD0ANUuo1RN +zDPobdGAY0tAjierhBeHTvdvXZaK5HzzJFhanDYvECrOlxvNIsMk+T0JUP3EQdwd +ZeuGluC5COfwvx2bGnuS9HmPZsc+gnx6MBbfNdS90jDM3QaFcAXNxeBqyvTCHWxe +dz05pVpfRjWHaYbS4FlRVCu6/Eu6Z3VpvhLFS5aQ3rMAFxGhpTAXE0ZzLc55Rk3t +Rc1lOZgp/7174NYcdx4WM0+jdsF+SIsy0/XJnhxWhIhGBBMRAgAGBQJNXaoAAAoJ +EJA1w39wJAf3LR4AoN3jZqUKorgwIj+9dviDVrmZ10TsAJ4lSjnzCSIuraQuXOMm +7XyukdFNe4hGBBIRAgAGBQJNXbBZAAoJEDx5k7Q3RWus9iYAnAibhSjmM+mrGfhm +BWiVFKq6nSglAJ44Ws20E1qbv47K6dfJJ86CAeVl1YhGBBARAgAGBQJNXrxaAAoJ +EHv7EQjZJ2WvVCAAoL6F2l9y6Pt+WzsnjfExtVxGYk7rAKC4WV0YEK1OHN3qMHcs +s7IEda8neIkCHAQQAQIABgUCTV7/2QAKCRDTcw+zJHgyIHOTEACHGLnraBJsJjSi +wFOpyufc/l0yMvkFET8IiPo2U5RQcm277eYkyerQ0fD1ZzLT1RlwyD/g8Da7zN6P ++0ooUR9o8YWgd2R3VNhQl3liR3uD5a6Tby9E2sGz0/Dtha17fRAkBk7Jbyjkptmd +yP7EPT7kpQfJKoAodGm0Y5hlI0WZJK4sgf+YBP7AqcvFkr3iRZ9p5kcAbH8VVZq6 +BKx3Tovtgd0hafZyh1ZXal7K9iinvz3I9zrHtJJbO+7mduXcXUDrme7SVi1A7wU/ +jZt2XD3qm0KibPf5PBRmqlDy2G5ioahujP4EgfMwqt4aNCT1y8vPyOmqXXkosaW/ +d/EPDsuwm/V/I4qeq2RsycOWwMQnP1WGd2AD++rn+gS7U8jZkzNgZRRUWJccbLT7 +IZ43rb/JBlFvynOtVzr8Sf0Z3bgt2mBbk8qdhH4s7jvouDAixHb5EQOmVkZ/0I0Q +xTMefIZhY6hrZ4ocrZ3SU/sPm4mOaLIls4muTaBrbgam4z2v+KaU1VzmuLZiIS2v +NpKRmMA2jexDEq7OztrsPgYFKzbYp5smKcKTQyc/R8/usD6CwPr96xvNkiXp2zSf +MCDZvQail51NfgB5jjZTVSJ+QZGtBGNQYE3CCzbnNsVTud6TLNxrCwYjE3YEAINM +SjuIb77EiTOF6BJiKWbT7CYtMyOlJYkCHAQQAQIABgUCTV/EywAKCRADA99SJcjj +htUOD/4xW8s6G729X7Jbj2M/fS60IszIhrkzPQ9awgF1+An+m533TbxljG8/HE8c +pdFUKgpSoN2C4B36QXeVi2xKkQIKHbBKl61BTnui9apITcZv3eiRKvYVUZYhcz7h +uHDie6vSXaINBDbONbAhxSIOtc7/mPONOMi/RMUJB5ptpo+J/dXwxpW/yclgVy30 +rY2qGcHnpjATfQYkEbV3+SXCGZ0c4UNAcd7OIsL5xOUoejUWENqgxcCZt8ENEwFI +WPHix1SwEuD7gfkTCHpZmSCCrW3/qxpnR+UZKOI8+NS6iK7833D/kIoQiTpOJ98V +z2CNqp+FgOG5NC03sp7gr/bOrdSh1vn3CHb8yJuforj1VRqbsgJNKhf67yFEDoOP +qqUIUB/ir4SMqG2yupkQX76GyZy9/QPMoMEYtaEUVdnDkawndUUPm1FVZyqu9fim +54bQ6i+hQLTNQPWH33+vvAL00qeX63763CHE++0eZsT6XX0DepLgz5pm/bi4lgdw +HZxG2CifA+EvLK3NehlP2pNrQgRKTe+CDeVq58dygTijGtXlOVhFmD9yIIt0LZ8s +S/dhP/S6rwwK7Zom8B7k72qYmrFrM6y0dPKHV38if/qQUrgLViIHZe1r3m1z6wfB +6cxhQSgV7lZ0peeyJ3qMGVrd/IbdX0t8S3F9DDspiCLV1pErRLkBDQRIHeYtAQgA +v/Z3yLlLUJ6Rt5Xarpkel7GlgWAjvwY0kI799Tb/qv+bvNkT/bzw/0nUNvQ5fFj4 +htym4sB7PL6NYHhoFmjLasLlz/B8TAr12otSQkkTw5tsAyCRFk775XL0ygLDcVzH +zJvRIE8Of16uSRI0O5Eo3ciYBvBVIMfjk4cHlSREK3xjdsy6i/afg+5IXqjGNxIp +3WhOJD4DWBSUAw2ktb3MrnXjXBygidUufrljyUteUKoLjnJfuDzduns1u97j7oOm +18QuiSgnwk1gZSQWuSoyUBc9yQaH277snlPZ/NK3aDopPH5J795v1ueScgQtzpLr +/Le7cqM+4kv30hq6x7TzSwARAQABiQLIBBgBAgAPBQJIHeYtAhsCBQkSzAMAASkJ +ECnuWLmWhlFxwF0gBBkBAgAGBQJIHeYuAAoJEJ1eqvaQE7hCMUgIAIZmiPvPbHm2 +QveJhdRrTrhBbPLaQmwcP0SYTugAAD45c0r2NZtU1h5agkqwj7YSWfh2+E83H/jz +WxndGJ1NpLJRTC+DGO7V9X4xovsVPGdsRxcO40fhOPu0DNXzj1SHBln11sEJL06u ++IR91oUgW4WChEJk282vKEVHMIw+ovah+OAmA18u1QmD1ssvtdpZ8Lq9DRLUmyeU +Vumbob76wbLs9HALh4l3Te8HaSfZWGu7YGVFuhliTDXCaU0UH32FLJSSn38qNmBL +A/VWPUpWM3EmdPmhQsUZv3onvlDcRrkpDifdFJpINUJVbl2nbVbZW05XZu5PNCA7 +4mQEMzpOE4PCxAwggdsEEKz+AIs+uGuH0JK6Di1m7LspnbFOM/rUHnWK8xdVnz6a +OlkcONVBaW17TJf924Uf5kyWd5Ni3JkDzu+4q6+TZwFhLYdIszc58jETXznNrHQ+ +aGIRHaAOsSRc+tD4L2+bnHjCH2UNdaGNlGkFeTfLNE64MsNSA3ZTVkO2cevn88rZ +z1dJEFec977htv4jdwzxQfzz55Yf3+1ATOsQBoO817elClhmpxTu0oZ9uk1lB+3X +3RKbIrTEilY9jkL7JlRbfetQzetxjd3dq04nH/xP8Cb33O/PXq62S5S3t4/JdqUT +J1xQOiLYwvpmsREvvTpCaOPf+tGzv6fOEPChcc0E/+wz/mfmeC/ElhTIBXFamb+A +y/Z6nC3E6r90PxUVmDvaj46dj9JHtab7EmOh9PlFW748dMfWy3+EkkY0fP4YzJcT +/6un9Ki6FqMqQ2bF8+0keb6YKhbeuouotk2kTjBJXe3bqegmxMdlZPg3uUEVFgP5 +NSo1DivzLAQoBBxcnkGm1rkBDQRIHeZpAQgAxwz8BhWUkWGZ3A6TEH3aa/RGJ1Ki +3zfDYsYrrfU3WgCJ/Rg2rZcpI9PMeua/+S6J0cSXG73x8L7wZ0X2uKv+ZCgM07WO +AFBlSGjT9A5K6vTwVMA/RdzfaLj0rQn4OEaE81K7iC0NK0NofPbBnaTuBqeMiajY +49fknyuov5i4BhvIm6QPwdWw3TB7AyVcWxOo09kbmk+RbsazLrOJauDWErj4SBFE +NbkLChf5V9xPQ7cjovSy5Arotvhd+V81/+vyRuDFONGe45j3t2qkdxk9lcZOR51T +dsiP4Z9hT6qBrZ0dhUepNZa3TCnBRtkrXGiVu7pGNmLdP0h6WneYST+5yQARAQAB +iQGpBBgBAgAPBQJIHeZpAhsMBQkSzAMAAAoJECnuWLmWhlFxeCQMIK3qZHjr/R2C +vr69G5aE4Cf5FlHl2b4WxV9HjMQhWpLWmCIJVhOVj6nMn9VNyF2tGMSqBWurepmH +kc1CO5E080C24htio5y1wag8zB2T/7PU9lFLqt0UgZ39mnnW3wLvRw6bbPVR8r9a +CZ6ZDmNjozP9TmDpRN7OOaRPcAWVsUVZ1QW3BN4W+Nsq+ZASixM5Wg6oXMY9sKWb +vgC5qGDrN4JrV6LrdBlTGZcU1hUJXYfRZll4bHf/REPadW3M7dYWqWpYUEioMM0a +ZGbbDP/FhPZwt2heIk5lPw8yLf6whSe/rGgHNyhUDET1hIKSf11sfTmZg3rPFNy7 +3yf0Vs29CTcO2rd2sUM6GhDkuR3MqJ+tFbhtkgfALiKvC9whjh8J67ip2SzwQq6q +PCWr0bASNK+USAfSoOzNkFXNmbNUf1Dca2f9O748wxFeU5r0jlg1SroPsi3JZHg4 ++kNcC9/b5b7YBrvijmLMhxyBSyxYNr+YEZRBvkyb8Jsvpi6GI/Nng6tHX6A= +=rOj+ +-----END PGP PUBLIC KEY BLOCK----- +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.12 (GNU/Linux) + +mKsEPNUHKwEFALqJSBHn6Qk5ex138kwymxA3idCFoTi5Q6mVooEVVaYVfeDG+5uV +T5rhTFDfDcT9SO0eIlfKOraSRnVEHyDDH2PAgJFxyneFELcmLUQ66D+m8z+ziGro +6bcDSBBDMRkHIX6/kH/vnevjqivIld+j8WTcVX+SArcKyzgQ58uMTrfQdLqzh6D9 +sE/838+ZPZkabmKKWMVWccoaUbWGYOcNwO0ABim0JVNpbW9uIEpvc2Vmc3NvbiA8 +c2ltb25Aam9zZWZzc29uLm9yZz6I+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgEC +F4AiGGRuczpzaW1vbi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCTvm3NgUJFLfe +CQAKCRDtoh6UtWVxb7BxBQC3UF6FW9nyukBsGUvz7clNOdAhPyfkvab049xuubjC ++kHGJuS25IzpvvLPIIUik6zZ0cQIWRtzPM2/6rWuktABHFQ0sf0A/o6f7ApEMnna +MXxNhR2ymWjzc2jSF1zjg/KjwPpzk68Irk6fHbT/vuZASrcXT7ORy+vjhoSoU1uO +zemp4tO8tK1ehsGKXQN7pPKhWpsMO5zVzZHxAlNUzUsXiEYEExECAAYFAj1Y8sIA +CgkQV5Mp08AbKiJmNwCgkgjjuS5TcZq4rVBWNYu1VwQlJWYAoJZf+pBNBvzT9xOg +Hcs1cAMwT4FHiEwEExECAAwFAj1esHUFgwFXijYACgkQvLvElXGKklZXlwCfTWSl +L2/3q5Od3zBVMKVHgpTo4asAnAtw7vVEIwp9pPuy1oKjTB/obqltiEYEExECAAYF +AkEAyoIACgkQntdYP8FOsoK0XQCfRN1QBVk7/eu4YbFQBqH463dcHx4AoMp2QurM +RXFDImswJ1Wi9K65dq66iEYEExECAAYFAkD/P4YACgkQlv+ZxCXA7Au9KACfYKMn +MPmlbZDi5/Le4mcLCUlQ+SsAn2qOQ14l/ellraqWXbvacCJkOyNpiEwEEhECAAwF +AkDgVz0FgwCTtOwACgkQyIHdR0rnq0csrwCgtL27/ndpjew28bGVYU9tBmIg2GUA +oKFFKKHvJB2pVjRkRL4DjohSdIrkiEYEExECAAYFAkJJAYsACgkQj8NyXz1o1joW +fwCgtb8mtlI8rg52vT5DRU+Ct3NuDfEAoL7IX823ezbe7HVegheirf3q7zmKiKIE +EAECAAwFAkJG+cEFgwDmsQ4ACgkQv9buWFf3fwmuCwQAtAopBWKTnll1t4lFnR+C +mvXdqui6g/MhMVjGlnGaxzKfdlXIDT3i6VEMQk639rCLUxNB5YiQZZm7aABg1dwt +f10mFQUkm9dt4d852cu6ytmljXLJ4NIQFrhZQUrxvh8s8j41oN/hcwyLaX+FLI0G +6Jehz0m0nPlEQf0sJ/4oCuqITAQTEQIADAUCQklECgWDABPOSgAKCRBmvnH/Z0ho +g9kYAJ0QKz8Gt/kc7Q9Y/Ahh/wZO6vaQ9QCggcgpRYoJ6g1QXYWdTO/Hxve4Lu+I +TAQQEQIADAUCQk2CtQWDAOAoGgAKCRA7jqQfgvYSQDh8AJ43bDTlK1p/aLXxJ2/1 +pFrHWFvncACgvVli4V9P6pVhP9p+H3APtQ+URVSJASIEEwECAAwFAkJhOZ0FgwDM +cTIACgkQC3gy83PWLUFxowf/YLAopAmpU94kKSC4ECFsLXDivJ4LCOxgqZ0u7Fgi +QgwWK1miJJnW9gME5vE/jMHlsjGwUKJDC3SfbgjOJj31ivrGIh4od8+zU0bwlwoJ +ppDF/5cbzBheUiCsz+BVBZs8ii4OahnoELUzXbyVZITkMztmn/2+7DYXqqf1tCTy +wIR/hQzFp6W7GNT/I73Ksz/cKop4jzxE5whkl+5NMBk9VYhfa2X49/S65nwXg4ii +BPQN0UrhN0ZvrF+uKX6oVlOX+30CrPyT8FkcRk1AOhUpqblk2M2DblOebgxfF1ZV +jXNNN/0fZhy4iTbYSggndO5PIybKMkMogVtO07F/8lvtC4hMBBMRAgAMBQJC2LCN +BYMAVPpCAAoJEBhZ0B9ne6Hs7fEAn145gLDePrbxrfwN2dG5+IuvpvtYAJ4oRmRy +hxwpwahGE+5281z2VTrQ9YhMBBMRAgAMBQJC2LCxBYMAVPoeAAoJEIHC9+viE7aS +7sAAnRYuXokAy66xi04YD1ODtssYFw7nAJ4lqshFVn7NR5yznu0tioYLFwyc54hM +BBMRAgAMBQJC2LDRBYMAVPn+AAoJEGtw7Nldw/Rz2iEAoJFrzoYjkR5ANZYbeX/o +zQecQCmAAJwNCoPySmaxrwO6BiUd11bO80bPxYkCIgQTAQIADAUCQtiw8QWDAFT5 +3gAKCRCq4+bOZqFEaF90D/9xV8ua/ezhWOu5ADgHE1yeWMWQsecIx9TA5QVQg8pp +jA3E2REe/lJbCweVhwfvSmuvuymRQw71cIdmqF1dz9R8mb62N1r07DcPxibhtHi4 +poENxIHqvEbtOR17Y6Ql4DW4PjK1ut9y2y58HK6XTiqCtbg43jEcbXk1r9qLJl2L +gopYJQ1KJCwfn+DCVadRA2FgVclMGUGIdiiTwp12+E/70oYoMzLwm+7MUgbJUpRL +ytsc5frhT91iX2lPoeylAHAQ0681WiawvexlqtAPto9Gjbtnw32oSOqIJcbbMhN8 +G87pkvBhk5wXfVM7kyutBFhIHcQFGeuGkZpgeXt40NcUJffn+KOfeXzgdQwmwNlo +9K0arxNpIukgugvVeNtsKj1gtW7IkYcLmvlDyShz/cytguNEU+1W0ZeG73Tjphs8 +mCSlCKVcNWcy2l7z/DvB3VPibac525/Sw1ZIq7DShRHHv8x02/658LEW7gSvvZ4j +3yuZSNgL2lgPzaYoQo+8ysHK9dqViVBXAHIwVZTmXptb5zxQcHtFUnR51IDSAfBG +d7gjU5NJNfKKngLjDJy56nmJGMw/+13F5XFcjGPC9t6ZKoQud712K8TRIczWgGMn +gkahyTl4KIwPxVzWnUN0IkcsO/5yO3JudWzzYB6r1QomCSAAA+uirstJwVtBWsCA +54hGBBARAgAGBQJC8krrAAoJEG74r8KGV0rKoI4An0CQA/3wPCxskfqLhvN69ViN +c9GhAJwMR5Nl4q7Y4c5j9BOG+9Yxaom2OYhMBBMRAgAMBQJC8cBwBYMAO+pfAAoJ +ECmqKFIzPnwjCzsAmgIwd1uJC2Ka3bIgTCJukFjCcdWRAJ47P2tLKEcvatuPnnPT +yWYuXGTBqIhGBBARAgAGBQJD+NOYAAoJEOFd2FexXDfRRVoAnj+kNh2yJiIAI9JE +Vccgdv8cdElgAJ9jZHFa4KIdIsdGQZ5G4qS0YkHwKojYBBMBAgAiAhsDBAsHAwID +FQIDAxYCAQIeAQIXgAUCPr1HRAUJAtWOGQAKCRDtoh6UtWVxb3F2BP9Whe+ArZn6 +WlbpHF+37Rqr+KmXL2fLI0b+phneaieRvACsOmPD3jDpvxz/xVf8s49SJ2+a23Ia +iCA8Boyws9sBxn5N+yWhdYYjfDbH3JUOQz7BKN/9o8EAYuU8pmQtEN0q4+QiNsU0 +a8qLAV3qmEOwLfkB4z4H+aDZxe/p7vIYP4QmzTn3ZQ0mYR5mxpc52pF82KVyNWWJ +vmcirPwKSckEiNgEEwECACICGwMECwcDAgMVAgMDFgIBAh4BAheABQI/pCtUBQkD +vHImAAoJEO2iHpS1ZXFvPREE/j3fX+cLxCCZNTjMhThGFujiT7ty4x1jVc91J6QO +A+Jp+78NIIeyg3JTeR3WIv7/WFNzLKJXJEEcga+0ViPjoLfvGsHMAnwXqPYAxu1c +DY4jId0bCYgoVlnfF9gwOWxebtotLpCiuXGL/168zEAXWJpPg6r2MfPhAKUJ9G8q +52OOWJW3cObxoZ2gyXjuWOFtygZ1vUAqP/8UGeZNdajHD5uI2AQTAQIAIgIbAwQL +BwMCAxUCAwMWAgECHgECF4AFAkCGvikFCQSfBP4ACgkQ7aIelLVlcW9oqwT/a2nW +kFFy1q16WURE8vp+Tqu6i4r5mTdyHjbhQeZh5Pub5DEJiFuWXxE73JVrnNozacQb +Vbsnn54B4Xv6tuEDMxaTXSjreDY6D08urM8A0gnUHCAOwxtmepm9wxk/l3WAXWwz +QoQaqZ2PSPFGW4Epk8+JwWKoLv1O2i9NbycGEccF9rr6I12319Vzk+P4P3FOgCwa +dAQHSGS3Y6hlLm/RGIjYBBMBAgAiAhsDBAsHAwIDFQIDAxYCAQIeAQIXgAUCQW/E +VgUJBYgLKQAKCRDtoh6UtWVxb8gUBP9Oiapzi+7qCcpj8Yy55jQvgpXkhe9g5DuT +lRiHYjP5vTvXJNF7pDOOPj1pSUxumC3viv/pxUaWKp3tSOjsT0ZVgy4ah6rUdjyy +bLAOAiPmAP3ryStzURF5/RnQbbzrSGZJRfeQIxY2871hWg241/wslRtNpsxYSPCI +PHMVB4SSFYzzbKRgUU7SXsVQYBAlRU644UE+dB+b17slv1xvagOUiNgEEwECACIF +Aj0lzz0CGwMFCQHhM4AECwcDAgMVAgMDFgIBAh4BAheAAAoJEO2iHpS1ZXFvt3ME +/ijwFJCSNoY1AfCEm3AX6vRKUbjiy0MdemsqajXF6awcbIaeCwk3wVr9JOs1usu2 +/AQQDvz0sf/hEv6c3sMTYspD6+QzrRMUVbLm0fp+pRZKyaW1tO+/JIoOl8qsOwod +kXPQ7CYFvSZhhkxdUwVOa6UtL6kOdCjQAy7DDQTzdcC/GxHQNVUNF5KcBWC7LMN6 +iAt0dAFEMaQz4t37CHq+DCyI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4Ai +GGRuczpzaW1vbi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCQkBc0AUJBlijpAAK +CRDtoh6UtWVxb9EIBP4pk/ztQF+XV5L4krXEmbjAsGb9C+I+4OoRUY/mWDvNAjGp +pkhFD+8Q3oQvg+1dcPsJ5rQHSXgA2w1bOsTknK9DamyY35LHd9T0ZSllXOUX9q3Q +eKiDBYc2KB35ZtxKNIA4Lt5qDgYbSgtlERxDY94BCSy4YApdwATei3O32t5IoR+B +roeIr+w+zn9mVulkn3pRXByYDX/scxcTtWwRL+UNiPsEEwECAEUCGwMECwcDAgMV +AgMDFgIBAh4BAheAIhhkbnM6c2ltb24uam9zZWZzc29uLm9yZz90eXBlPUNFUlQF +AkMVrNEFCQcvRSYACgkQ7aIelLVlcW+ahgUAnWORH5p6Cdk/zhen4sUwwnzsFyAO +Z7vaVPrQPq58Czl2FymLm5kJgsGXH8b6KLxVMo8hjTZnsm+zO6XTLXsnnK7nXk70 +gBJ0AAM0XGlG53qDvvQmq3RkfFMHuSmxL+zL8pXTmnywIlEpgDHPVKbPKF3c508H +FEPKFnDjuyRwPgq3q2mhC/qYYBRvw9hjjeRCqDTdC5wHuWLzs5MCLeG+3YhGBBAR +AgAGBQJEc4b8AAoJEAixI47drUe278gAn15puEaeLjlpaTndlvxT+LAH/951AJ9b +0Hlo7Py6F9c1liLsMNWNDnyvZ4j7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIX +gCIYZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJD8ykBBQkIC2/U +AAoJEO2iHpS1ZXFvrF0FAJLVqSWQ2fYNGCvBH4xRS4n2LruzdubmzNuCIZrc75M+ +RfTvYeHwCNDY8H+PggYuXMT8armHvFvyL7jln864M9LTX4TwROrqKlkNgOkfxdSg +Oz4QE9RHxxooF1GMl1yhxCoumixYE5w0z0LGYRKy/Xzd3+VMcUaFXvEqY6Q+cnQo +qChCvKRmsIFhF4b4SAqzRePdx6U3PBpC4FbIlkQkpbaIRgQQEQIABgUCRYwLkgAK +CRApqihSMz58I53iAJ47ZGEOrZrMqV6WKmfKa8+5907zeQCeI9LFETr1SK3IHx/7 +S7RlQhoqAzeI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1v +bi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCRObocwUJCP8vSAAKCRDtoh6UtWVx +b9fhBQCRE0dBfP855Vv2fPCzIxnu1I0GM9BjmAC4uMNdW6o7I4yQMXNYpP8RdxDz +PTon1JYQZqQW77EdqtwjFeguScudF8+85I2FtKDmzl0NNubmX6ckxdCbuUmOk2Vu +H0IQ8O0f1htk0h4dQB97YA8zu9AtqyASkdCDbRC7RgoaeUaV7N7v8RM3KpEJm6pc +eQT1DLqOQIFAp/cDa76xXK2Xrd4IiGsEEBECACsFAkXhdvUFgwKHjGMeGmh0dHA6 +Ly93d3cuY2FjZXJ0Lm9yZy9jcHMucGhwAAoJENK7DQFl0P1YbgMAnj34VvAwJhWn +Z79fbgSY9O7CIBJFAKCJEs0DbASutepLJhiysH3J61b5D4hGBBARAgAGBQJF4sLA +AAoJEKrPs4YhG27v90UAoKBHaY3RXOkwk5YL58jSYoOWltJ/AKDTwdKSURBZ3RTe +GkriWGZRy2sfd4kCHAQQAQIABgUCReGU9AAKCRAmSeYoxdNNBWHAD/4+/J4V7cM1 +dMrr6rpaggfgRa7d121f4n+KVn69fmxBr6vMkGP+8Aor4xMGvkL6HYJvOMRK752H +wXij7TM0HdGqU0S6cisOXiS/LOPQOayz6HuvliIhJeyDF4wfI358ZH8gVTKTn+1l +tqWmggd8KVbU2pEvNte+lD0VIxK0wrUT0nFEYoJsDlTUVpnmM4PxP8TwoIRwo/h9 +NnL8zeh+5sj0D5tZW4DsTC1AVPH1WYUN4aY2lv49twDh63oXbzXZQ+xKWJeiByao +DeEOFtouwTb7RbmDBB1i0aeb7gWCryUiHD4p2zf+R+4ikcwcG0LzR7DC3WFdlPnb +NII/G31ZDacpPqkk5S3LL2jIXKhpD15ilbXGjkqsBAkOJpO7rehVbxEGUfGh+2TZ +cCvLHeh9ckgjimFlZywk230H/tkQJpnHaTOmhNbBbowUkIdCjTBLkqyW99sM2heD +kmkYh9jJTj2BLVED4HrgyMp+dXGeDM7nVGDCPfbaFTTz6It+ODndAC2Q0d0N59Sz +x2Xb8LYfngezdhV0q0GgGXl+vh9zvZnpHV7Bef6ABTq0IOQri83IZv3HlyBeK6KP +JTx+ll32ByQ8JcMuAAaVqWXI914J/fD9bvsTzJNQsPEa8yBta22Ww+jcnHBBhAbU +Kfw5FKNDrqYr4VGY9+am80YmnIRQIt7Fu4hGBBARAgAGBQJF4fboAAoJEE1EwCDF +wFuuzREAn11W3gtaynmEAcxw/WxLdndmL0mmAKCsf55yO8kTmKoohRXpfo+jn4HB +XYhGBBARAgAGBQJF4gz4AAoJEFUVYHaRYekRxxwAmwVy1T7YQQtP7xXNdM+EVUxL +nteTAJ9AzaxlVV4dO/OZTG9QDbqztagH54hGBBARAgAGBQJF4grQAAoJEMfZMCWd +/6rUv38An3mkvCWcxGKhN6/PgQ2+W4zpFQPDAKCxweB0Xh/TQDjQ/dSaoj/BccNK +LIhGBBARAgAGBQJF4hFCAAoJEOVE3gebfDKNJ4sAn3owtLwwEWtpw9VQxTc66cmd +oFqPAJ4r2z3VgRa/Ns/uWMxV0Zlee/f2M4hGBBARAgAGBQJF4i3gAAoJEHZJQAVJ +ruv2v54AoJCl4M0ClZrwxyTkOXJs7xeQjtDtAJ485636UH2u71nZdIyGTMqQkszm +BohGBBARAgAGBQJF4sNEAAoJEH5OpU/Qq0B1NE8AoOJY9VXq8PPDDPjRPaJLahjO +ykz+AKDN3jXgHvqD26euQ1ksEBc8Vn6zF4hMBBARAgAMBQJF4sR8BYMChj7cAAoJ +EHMcr9NTwaMv9/EAn35hATWBiY7ra8Z2bjy+GZ4eSLQmAKDX1GfInkT57/rzmpkx +n+IQlikCMIhGBBARAgAGBQJF4s6iAAoJENoZYjcCOz9PA5IAoIZucQg6PaqLETbG +ch/y2UM6BhZ2AJ92fj8dOvoKNxn9Rh4UcTSSiPXNDohGBBARAgAGBQJF4eL3AAoJ +EHhn1Tx0eTXduhcAn2LWbAgZcRRU7PJtIO3zqsIm6keDAKCeZgrQaUd1GSNW4AzZ +LuT/XXiWW4kCHAQQAQIABgUCReLO2gAKCRBSIlPD1yc5gYUMD/0ah8KqI6rjyi7p +WqPPcPKy9ZCnPJv2JJllu1wx4dqRZnUVA3rmHAUpzQp7HsfMXWLgjxOnUEvzjZkP +PamYnczdE65l5M8zah1WNjfR8Vk4/XaeolVXe3a5R8Vxj27QRa+T5yEHprb5hPo4 +uFWkPlJgJd+qcXCIc28135QngN5uRRQK4NnM/oTtv2nv15L4M4qiH6V+We5IW+Tj +t74O0mSEekg1bB/XKlF/XcgyO8rEZgqwufZ4cHbzWYXw3C+CKkhDSDItGUw9HesO +u1FS+Mf/Js4+/kFjW8ZJPFO+A2z3gYTDzaXGq2zlvbqw1gYId5pbukVM6PRqQrlq +tI2Kza7/CY85b+DVU9Zwe/Hr+yYnEJdG+eWkshmB0mIXgQlSaf/sglsAncrmxA/g +m5IxaE3TIRW/mtizuCUwq+gigIUEANAsNwR5a/RAekc8aNaO1cSj8izlGqrl6cuQ +5jyizUJB5AcOV4CUDiazITOasbt4+xx9MTsciqWIkMLYRloVuqXgsoKOTxTT6Zq+ +lPEGRyYds7OEdaXHWPO0OJ2ZPCagb3OvqxJc123Xf7XXySGkGXzZgoA6D4BwIB0b +5WQFq8722b0tJPktH2a5clKJio3SMir1bpPT6b/CM/Mrk3kIFKJpmvEBYrKTCfhJ +nDI2GJ4Z/f6rUDhiyQ5yj5Rop2zot4hGBBARAgAGBQJF4vk5AAoJEItKxIGsHnFe +eYYAnRbZnnFoSrbo5E908zFdUPwfVfUoAJ9Dgo1WuGHPD+89PSqsyMshK1qavIhG +BBARAgAGBQJF4y0kAAoJELOx+BoCeHiA9a0An0E0Zyjequ/iRSSB+YolhRqc87tp +AJ9PeRbv8Ce1TY6qCoyIO76zYScX5YhGBBARAgAGBQJF40D2AAoJEDiaVjzCcqEm +vrkAnimr8D1OTH8O8+E3A2VOoxLhG8PTAJ93AR9hPTBxVBY+TqzapQz12ROtjohG +BBARAgAGBQJF40DdAAoJEB9/MmoS7vYqmnUAnjcrUSIjc8jjfdxLhJES9yDBTP/g +AJ9ZSpKAG4kvVjZqcSBhudGIw2NkQokBHAQQAQIABgUCReM6egAKCRDo4GL2DcsE +MZKUB/9bQd/kyhettf5FPhSPgtVgZanF2kI0WnDWUGXbbn8vLs7GNGsb6eyuUDEM +kL/f6xtVHNPC44HarRbawhph/m0P25KQlaHX4120gdYzPR7mnUMk9g7P2ycNrcND +730oJMS3f8FBhe9fnt4adPU8mp5fgU2zTsdVHpa2zUVZHNh84iuEoxoZJEWEyHHJ +ke/avbbc/G6JmMD+8vOV8nKHbuzNOAfA09kPJWAPcfR/grCpEMZ8SkB9F4FvPEjU +2HxeFKx1vWNTamkr6ygUVlX7bBwLCe9p+7ue1rMeKOMsJF7UnAkOthEC2IeyhPn1 +gyErrjYzQOX+3+YPCSO73fBxSG6liEYEEBECAAYFAkXjS5cACgkQKJz/wOY81tb5 +TwCeLd//hOBTT9hnSkZFuxLso9J3cToAoKnsSW/csdFyRJLh024CqSzu3/QXiEYE +ExECAAYFAkXjRMAACgkQjCXuDw3At9aUHQCglgCi6nNiupwbEfwEsvd4MRYVzGsA +niDj36LSv47TIbmUQJlR/qiNJ+phiEYEEBECAAYFAkXjVQEACgkQmEvTgKxfcAxE +EACgmX4IGrSutcvAs9Pfr6JYEE3hdsYAn1yLt/tyLO9laWWhLKhNH7MPHc0xiEYE +EBECAAYFAkXjT0YACgkQIae1O4AJae8N+ACfXCp09XmUQQ/xvA4LipoTAoyqX+oA +n3aZHFSOKENXaHthrpt0FFaPVNEJiEYEEBECAAYFAkXjfaMACgkQzxI0fJaL1Yct +2gCdEw43ra6oy0cwLX+zwRzTXazKQn0An0FuDnGs6J5+x6hlK3MFjyfRYZc5iEYE +EBECAAYFAkXkGvoACgkQZDZDYQnzQCR0eACfWdtadQLH9Bbi/YPOcheMmavmCrUA +n1fBKs46WOq7jppufBXwcncegfxHiEYEEBECAAYFAkXlgbQACgkQeQ6MlGH/2qvD +yQCffMAMRUHCPKIbbz59BVNmgpyvSmYAnRMspmLYF0gk0xfHoIFaS3nwt3DgiQIc +BBABAgAGBQJF6Vo/AAoJEFeTDasLhrBnakQP/1Z460aR3KyxrCrEcDJ/Vzf7vsbq +1DQnmoRuIgpKmR87N3qRLb2p94ffRYYxlWcFj1jiYT3Wq2bxjHyCZPgcAM2bQuuJ +MFxQo2xgwobyNqesIafgdbMjdUEAVy+NTyJfdmM3I57lkrleGz6lk9ojMLoIDa/t +R1C+uoLuSWMj0Xk/nCT+WnN3/xqZyPIa+i6MN8fuI6Nsa/C1jiNw2FnZy721hl+P +1Bhx+i9aiXCR0qz/3AOAOz25F0OXNKKdzOgdo5mCkelbUaey4gPpvb2oZ30rh6VT +elOOlGU6WbEO3DQBuOGAxJ1Ux801przITs1923bZU8EPyfDZyZWINkpl7M4En4bq +GKQkjTIfE8GrSSCp9rsLg1siK38yMYodegSzSJ7ZWWGlyuKvrim1eQw8svSzRphs +ujaDJG8Oy3Dlc3qBbA/CGx1OtyML5G/w5C5b2Wz/BkMgHnOfOJSVjGlJJrxGyydR +qThibZ88yRcZ8130COubR4Rr2I+TD+FZLhGtzQGia4gDQ9QG5td6LS5yLPc3Y52N +cwWsbMHWzLTQ2k3O7PcsetRPLpduiq1eZUZZveY0MSjH+uH3xzp6qfj9I4FDtK6e +pHQ0F9Dw8kK9qBAhiqrKxsUUbalx5Pup0gIkzNe1vzjByS2P/j2VMhbinhG5FZl0 +O2mPcIXHeHlAJdGCiEYEEBECAAYFAkXt5LkACgkQMGnpIbeahxy4RwCggxD0dEmG +z7ipFrmwbIGTxuxIS+IAoKfxzxjiT2m3AEvfkL/xNuqgenPViEYEEBECAAYFAkXk +wVwACgkQcLIDITr1nRa4rQCfZvrXaoYQ8TeX/lhuJfmsPb7kIRcAniKy+cTGNExR +mZutFX/OcnatDZExiEYEEBECAAYFAkXqoaAACgkQL5UVCKrmAi7oEwCgu/2cheN4 +mU+yFFIG6HmLrbeIc5IAoI2I4eLWJdmLpJleOYgF7CtTGIKxiEYEEBECAAYFAkX/ +bGMACgkQOpD/wRQI1/HBUwCglcM0b6fl1oP8iofWeovuhSk4+5sAmQHrgf2pbqFW +1oTBNS60dNQjA7VdiEYEEBECAAYFAka12CoACgkQXeJJllsDWKIizACgqk7R3Bhn +GgzraKbcP9qSMhbYBr8An2Xah3bURySnK2QBDx4GzNM/vCTqiEYEEBECAAYFAkdZ +tOwACgkQcgQ2cL3l8e4/XACg2opaihfpMLeOKb2bNSD7cLpI3N0An2A2r+PcOgUD +t3qIIZ8i24HAhBnSiEYEEBECAAYFAkdZt8kACgkQ4Q56CecvefrAfgCfU/NbkK4w +CiFMyviXo/F8tOEGyqkAnAgNaSmDzLkYZxHlM0SXosfHfV9diEYEExECAAYFAkda +cyUACgkQaGtW3WCKJJsOKwCeLKhorr01GCKnXR8QaGvImLVOm98AoJpyR9WMJ0cs +X+CuEdzGJDTlD8pxiEYEEBECAAYFAkddIIAACgkQt5wosOl/hW0OtwCgposF7nuk +dTQ1nsQd1AGHb0CkQzYAn06bBOKMXsPcN2VvMiO2hiv9FLhniHoEExECADoFAkdc +k2IzGmh0dHA6Ly93d3cuaGVucmlrbm9yZHN0cm9tLm5ldC9zaWduLXBvbGljeS0y +MDA2LTEwAAoJEOdekMA5zDPbZ9IAnRTxxJl2Rtv1ZbnGsOuPJ6musP+5AJ9b8b3Y +9BL7PRHzWgQjzALVVXRrdIhGBBARAgAGBQJHXR/KAAoJEPG6TB7RyLqP7nYAn048 +cLE/iNKJFxl/RwkY9VcRedkrAJ9+Y6u67OnG6HneUhzqGvMDbaGmAohGBBARAgAG +BQJHXYVBAAoJEIUGW1nVLdGnUJ0AnjF43FY5SwhcW2JmuPVu1YnWfrwwAJ990zkv +mIQtRCrxMzMgThz4jVaoEIhGBBARAgAGBQJHXAvSAAoJEO2/HhEm8iS4g2YAoMWb +nnF/sbeM8+WToKO0nnoJrXVAAJ9iX3wXtSwAqrK+3X5imRfXGTxh8ohGBBMRAgAG +BQJHXuTeAAoJEIXCJ+WlVzjy4fQAoKz8piSTCDPkv0qeNq0bdoDs9mOxAJ4lO8Hp +GDqjYheaAvKG7tFZ1fsZjIj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIY +ZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJF1dVYBQkLk/wtAAoJ +EO2iHpS1ZXFvjEQE/1HviHOOSHv0ZuOd+H6SVlkwnhmx4g6fpyeeOa49lywggMBL +8zddB/928PMYFQQ+pvYmECkOK+O6sVO2NkubopZwE/hUjt5sc0XTYQ9Lvxp40N/K +UR8fSR5FvLQSWYGYRDXkK3t3Cta83ZeJk2IK43DpgVoFWMN6x69DlRGTyRWbB2Vd +RvSZz3ZKp86p5cnwMT++K+pNxq+eY0UJorLRj+SIRgQQEQIABgUCSES5dgAKCRBQ +LE8plp8qHbO7AKCPmi7Ri8FKIY/Wf9Ksa2NFDxUnRwCcCdAwwG67ZmplFNtZlVDW +wFEcvT+IRgQSEQIABgUCSFlvKwAKCRAk0yv5qpXDSUwfAJ0TPD78S3J8UvoziG+b +TCLTlPz1XwCgnWlV3PBKvOxuGSAdm/DOMlY1ogKJAaAEEAECAAYFAkkGvzkACgkQ +Ke5YuZaGUXFYtgwgx9yOo8cCR2a0d/0J8Ux8wAnjLI8m68BCiKW6HmAzXx/mNX2e +zicSEyqcvv4q5XdpvSrcA2kmlREBpu7mmnyerUuWWsTLMbi9clXaKRZ6yQJQBbrR +YwrXtzdFziHqFjw+hC19uVXlPhXYa/8YL6aCO4JUlzWWgVF8xHupfRTIeXuGLkC+ +sWww2VmSm8Fg0FBG9jpIt4wYxNMI77so4szE/hoFQSdRtY1lC18jjluNiygGNQQP +n7r5OKwrK9hX1gGZA2tGYVX0ZoYASRPZcUUzaYPH5cZ86SAg15zzroVD4etmk/2i +I4sdzR9PyKr0zUp5FNSAFRey6avPAhaTNsyVDRiKmK3PnZF9H9HaRLJJnQEcvevN +04Vg10VW/O3zCFMFi8zuxUP6ygoDdWZT9jR4wbzVEyFY7AUwXnStDd39p3oamTb9 +XtlngTJjmVBZIOlap4vmKsm0t2xviaxto6uR+656Ya49+SoXp+u5+dGDT2o0kFlN +aC5r9zovItqdDYUHtn7DsIhGBBARAgAGBQJJZyWPAAoJEEc46iFldJl61+EAn1jp +iTpjqq/l1oKwJQYDB0WsqGd+AKDEiDHvrN46b58gzQKdVbs472bFS4j7BBMBAgBF +AhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNpbW9uLmpvc2Vmc3Nvbi5vcmc/ +dHlwZT1DRVJUBQJIYfmJBQkNGHReAAoJEO2iHpS1ZXFvdAwFAIshSBfY4Zn4BQfa +p1gTIjjcRy/v/bBnNMf8gMXkfm1FLTAaanO+n+lHsTNErPtaEfx8dyjvEg+wmOba +qAJYoR75pXBFbLKdiN/P1Tp5Wd/C0t+cTT2datz2PL5XFKAMRko9rST8C1MWOiri +H8akc6U6M+1Vy/dYcO2Tf3DxrXDLTFyrkfV9oREMsRFZu6W8P7UT578Epin/sTYY +A619IXOI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1vbi5q +b3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCSaEuAAUJDq1aTgAKCRDtoh6UtWVxb4pU +BP9f7+9yeYZCJTvILOWlsYIvl7J2P0em2qYn3NbDUS1yq+BUO8udTYNWwyxX9zGT +5obhX9bhcWgms/UbGMsvlZcOT+e438P0t1q5q8u+FOgZtfkgZvyacCFvT4Fnd00B ++RaaGZ2atnodvhN8qpzHIf8GVrhzULEtdA55BRw+x5f6ORdSD14IFWirQ4WWKaXT +URx5LIRxs6twYJawkumU6m4KiNgEEwECACICGwMECwcDAgMVAgMDFgIBAh4BAheA +BQJAhr4rBQkEnwT+AAoJEO2iHpS1ZXFvkxgE/2ZfCBqYKIe3SDM0tOVNrIeSZuVN +Uyn2xoqRKK4VomvTI1eMShfGa0twPVlBB5xXHt06yRbwjobJykmDc/Hmteel+FVW +OcehnXq8T22gLENlEM0CUZellosNwFwdnWGOHGZs/B4BVCh2pzsCra6di7MKCznZ +DOHX3TBLoqVHjWzCldxtwc6Y7fAsEtrLVos4+0JvjQoYYgHQyril5ywHYs+InAQQ +AQIABgUCSw6cnwAKCRD1TYragIIf6syABACYfsh56PcvpDJ3pGPoylowLFW4DEP1 +4dFlADmaZd+SedFZqXI/Vv+7fT19W1cx/HqG46WwmSQjPYSqI3IMpB4IYMnsDYDn +is9GIXLZyy/s4i8WBiiuRkuG69Q+SOjyF4X7MBh3UB2zkelpHHe1OTknOQ+7qzpZ +rp6YhpAMSmSx8ohGBBARAgAGBQJF6qGjAAoJEC+VFQiq5gIukCUAn2UXazhZrEHL +vZH0c56N2LdNHYI6AJ4zZnN8vY09pgpA6p7+YGQfnjuyBohGBBARAgAGBQJK/ASb +AAoJENG84OKPoRoVuxQAnRhqvmMVRkSQiHLSQEnXu4zO2SiXAJ4l9/uWrMqAKUPe +BcxbT7xrnru0zIhGBBARAgAGBQJK/BdwAAoJEHJZXrGBcEuTMP4AoKtme6FdYL53 +bVxbHklI8QwQEx6jAKCPSXqJmdslSfamkqA0dTncqUAZPohGBBARAgAGBQJLASuc +AAoJEBgFUbrZWjw1PeIAn3GHmjiGSmkJzDAKpovoGEviB4DQAJ4+tap00n1o0q+b ++8YjEN9tCt/VZohGBBARAgAGBQJLDEARAAoJEHfdleLqUuz0LZMAn3fBmDQzpfUX +yhciz6dUirKC0L6aAJ9IbQB4y0s1o8eR2ZxRXy5cYB30FIhGBBARAgAGBQJLDbh7 +AAoJEI53TMap06Pgx1gAnArZ857v7THGYpmTCjbwBz1oh7+4AJ9CNLFSBqnrZ+9p +YKH12RiFHLmuLYhMBBMRAgAMBQI9XrB1BYMBV4o2AAoJELy7xJVxipJWGZ0Anjly +M5hKGecjlTcoKYWJlMDjf0vCAJ99oFg8mkzKasg3CREHi3Y3Fu26EohGBBARAgAG +BQJLHGQ7AAoJEMcaTGXwWbHRLcgAn2h+moRVxidIb1mADTBGcOy0DjFjAJ9JLJMZ +gCvnQEmvyZcIssqTJ8Gx4YhWBBARCwAGBQJLEp4JAAoJEPKthaweQrNnE7UA3jYY +Ov08+w9dAdbxBmwnL+Lev2ZdSP8M+YS1pXIA31NNq1SYUuqb2CVCGUmMo8m/a5uS +Z/0c2Yyr5OSI+wQTAQIARQIbAwQLBwMCAxUCAwMWAgECHgECF4AiGGRuczpzaW1v +bi5qb3NlZnNzb24ub3JnP3R5cGU9Q0VSVAUCSe3n2gUJDvoUKwAKCRDtoh6UtWVx +b8gaBP0SDiN4gn0EUY2PPLQvFNkvZ96dIpHbMpjfjkmYSJF0zhgcD7bxWXjXDNng +BblX3JMs3yhg1GfQLvLVpQ64FakTT/XLCo9VecyFxILzq4aSQHyxG6OcAKyq9ibp +Y4YtUutwV+jiO1/Zos8cdtsyDdn5RYYe6v27omKYRKrGHNlk8NjAQC2pONY8MfPz +MohWOcGhwdVYatAZXYENCo7hvlruiEYEEBECAAYFAkt731IACgkQchi8veCamme7 +FQCgkuR72TM4Ii1XM3gNK/u1j3B38NwAn3GgZ51dtypPDikroOtv+W3J/bI+iEYE +EBECAAYFAksBnFgACgkQ2yYwJIHdsGU/+gCff51YjGdTyDHizwOHy35NzqcJMVoA +n3olfNMrg1kyD1ALOsJrRzgNyBkhiEYEEBECAAYFAkxL87YACgkQgxIgkKLogl4D +uQCgvZr657F1MuZpnNSIjkwcd2ptvXgAn3eAnUDlROcQMZ0mRLYU9CX2yfdZiEYE +EBECAAYFAkxN8UgACgkQZR3zUj0j8l2XwgCgtRkGwT5aWUYbHugdou4OuCN5LzIA +niyPXGVOll6eMmtikWqz2BvJC5dqiEYEEBECAAYFAkxN99oACgkQv2Bwi0hCbH4U +TQCdGh2w9AKqGWfgM80p2l0bS7kRwIEAn3NoyUgMmxR2RCscRlymHiAO27adiGsE +EBECACsFAk29TNoFgwHihQAeGmh0dHA6Ly93d3cuY2FjZXJ0Lm9yZy9jcHMucGhw +AAoJENK7DQFl0P1YOFcAnjf2t4YAmxXRd3d0H7huUtVBqhtsAJ4uiqVhIskY+of4 +xIMhO5JSw4GRKIj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5zOnNp +bW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJLg+AvBQkQvjD/AAoJEO2iHpS1 +ZXFvNrAFAJhV4iJili/lBcZSvLUOTgVd5CO7Av33Cu/zOYT7MUW2bWWY4aB83xRL +lMCIcwGFU8Tyvjow/lZLu82nih/15MMEBcjqi7XmZSszrrB0TULWWP8C6XIpSoap +nVDo+irjiUjxiVnXK+ML7z5zVGeJbqfzSQdKUWBiYuxEJ6x/1E7hXW/WCgCjz9Fc +NbSuXNyMIpE03BlAzpILz9n1AY1ynVWJAhwEEwEIAAYFAk5cm/4ACgkQf9n8ywAL +7u4wtQ/+KG7I4resK0qo10/cWtHmUknVYxMvH6vWIxNfnB7VF84AM+2XuvCUd04Y +QjWO9p7aIQVXIiIHLp4qfkv0DYeEEnvCpmxeWqasmBHj1HOEfHTRSSwWZL25q3Vh +9f5s4fme7K1p5kMJjAEDr+xKa1t7J9KI7pgBIWcg7kWAzlkIusIVBQBv2YUAxRMj +4ilgug9qfMdxDYu8mx+oxzZTo6XLNkmX5Q49sDSO/eGEQEkFkH/8diw2MfMuTYEi +r/cV/5Vlcxd2ZR2ovt4iggRnPp6ngvQqlQZ0rlmu5uAPzIt/6q3FfoH6KBDxQY42 +SLdsGCC07sKScmD6pAHbiS5JGsDzBORjhOvG+LqHLDF4UK5H7bTkBqSOFvPRjt1N +1mnvMkg+UXP11/A98SBOVnHmDpyYbRIn0kdgbrjzAVCiZy/T1wDg/+drtbwPMH7A +vuVGMsTg65NY3UUw3ZnNa50l/iu491FG1JlXiQISVKMe37o2m+qBZ4MfRGebmyMX +EZLClao86RgQZp7spWQHnGhVR7uG0F1OIgv141pu2GNH+lJp5APvSdMiShJDDESd +Ag+reAMPHLL6G8JQzZ7a7ZXXnQ0SstboGQ5G2kvvUlrIeE+EKA9xgdxiuGDQdxOo +0NAlQ9eknsBOat8WrGNKt4i4njthIhJrBbjEbep4pHIxbbyg1J6IRgQQEQIABgUC +TlfF8wAKCRAHka+MwDNj9MQAAJ9d9abp7szIUvqyciUSY5bD9FGv8QCfR7ZbRJHI +tGuMxYmTpEhUA7FbWjWJAhwEEAECAAYFAk5gyAkACgkQUpupYmkKcLEO/RAA2EC0 +eDpMXKoRGVDDP3PPh6tqAft7dWVTiEtFRGOMk/nPLpEi4lgHOb3uul6A623nV4uQ +wM6NiufASRjnx6VJ87I8tCZxBfTooIXpAfaLAnILGwHmgJAH0gGuYr/iuz0KjYdT +DEjWvDr6t9pQCyvhpPpIHKVsNww/9fAG3cwD+SNojneK+tOwwWMffp99FPct95Vp +91jC7HW+1g8MINACrsq5YKjsOS3xtN2jJ6Ceep9eG8xaiTG2jV75+SXh8uaPKla3 +X9bR9H+Nerb+iI2TrNLoSRXHKOrmberTq/sBHoYhFpg3hlA4SYeUuReVCQeLKG+W +/YluMSWvkP+NvhOpSJ38avNSiwMmu/5EF3uCRxwaiR3Mg/DwPnfNPfw76B5P56Tq +I1JUHJ+oKQbZ6a5UaNaxR+Pv2+uxZ7JgjGSzJim3HS44dZrU5FjJGFnzS6iCjSHQ +y+9j3SPi7MlAp90AB8XTVrgyCYEME3ZiqmtGoHeQics/0bEz3OB/aW/eNgF80GOg +tnEqVoUfkhJM0dtbS53xJ9MRBMqRfq9LTOS8cK/hR5oZDSoiAMemzzyfQmqT71ql +vgyzVoqQvQTkAljrdnXwix6F1t6SAUy+DYVmID7on4hS8IKcb6ZZBsNtyzRpoiKI +3nx/eCmZIOrXmI/KsTBLM5IEptaayQx3qJf5+TqI3gQTAQIAKAUCT173WQIbAwUJ +FLfeCQYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ7aIelLVlcW8hQgT/ZmLx +r5flU2r0R/R8kZj5kjo9KYQM8LKmmnECJQonkyevtdRBpEqcq1QS/eP2YlfOpbQD +vHSls6A08zY+ZDOGepx56JfR5epoxKzWoXJq1j3rqg5f0SsevgfFl8gAsvsLE/5f +/+S7UVzIWOY79KN9MYrYc5vNhpzZyDivna8ynvOn2PZV7O4c9sM8IpTVdZmmkPwR +RqupkLfg3YJmTdz0Doj7BBMBAgBFAhsDBAsHAwIDFQIDAxYCAQIeAQIXgCIYZG5z +OnNpbW9uLmpvc2Vmc3Nvbi5vcmc/dHlwZT1DRVJUBQJNk3g+BQkSSfMGAAoJEO2i +HpS1ZXFvCMUFAIGmNW+nw6RHfmUFa8QUC/bn5nswDmG7G4JChTpbdG1dq5dW1W9z +hQEBaJPkKpSrQkR/L400rctYJ2MxPp3TWeoiHk/sgREzsU5IpZHezhkFjb5kymZB +xQ+pq9NMpHPFhFNR5YmrNibyTGN7+FiLATb6QbYAGfdyLCdjBmwGId3PgBXQf24V +lNmNT8tsUC8Q6uwIZPz7vzXRkEUSBArOQYaJARwEEAECAAYFAk99QkEACgkQTvKT +Tk6qQjL+Twf9HqEK1AGu5fxGauWY5MKC+6gmogPi50b8ff4uXO6AZagmGqX+vvw5 +U0AOTLW1hGhcECOeErOfqd59xgGrg4vETHGiE2CR25RtuHxX1/f09RnjYsoXMjMt +bxm5anIOiyrJrr7jQ19e4kdkj1/nJIo+5gTiHC6yd4c3Yi2JE5q510z0gPLeE6l0 +mBMD1so3OMJ81duyRSjzKNyru4Eroijrgzqi8eUoSpPoWtYFdt55DRK52DTyVzPN +MwIl175CCncRMOH2H6DGFa7SPYdqq1bcw2ur5OLtOz4AZNgYjChcIQQVL/GUMa3P +0kuLl55a2T+gJlJD+d6J2t1Qcoe6LBfITYkBHAQQAQIABgUCT31CQgAKCRApryTq +nRwOeYQ/CACgDU15CLk6GRpHZ2rv+oRVfkOHBI0xiYlRTRW3huzxPnAN4pnJZOdE +VKKaZltr0vIv0NN1Mmo4UpjxF47Y12GyxImYHqxBZX6OmETgqEwuGfdE7d838pk7 +phnWqWbfDYMJrg0FIEZnBvvtIzTpHP2QWhW82FF+lIQY3cyKp7erdw8mxZio+ImQ +MwPTQ8QWdBECDWLsEmnQUrvMdAdzKLKd7SXpQ4dev7XBY4QT2CVHvNf8DkBNlq2a +BR2D9+PeecR2LDYh2noghkLQ6G012V2Iur0RpE9wJETeelYQHjp7QES3i8meaYL/ +z0l0KQbxOtKtDW7/zwGMEQCnlyDqC58RiN4EEwECACgCGwMGCwkIBwMCBhUIAgkK +CwQWAgMBAh4BAheABQJRjZDLBQkWmb0GAAoJEO2iHpS1ZXFvW80E/iYiDDfunjVr +0XZNdgQg3qyxKzD9geaGU4QnGJtDOimmfsEHqkr6aCiatvXQpeZ7GVx73oNr8dM5 +cDV37MnsKu8XLjxmPnVdsBL8iZBsFQj8Recuben/tudX19ZasJlg8eQhCpF+DeCt +z4CqA9S/57n0VOI5i6Ycnn9SeVXuVjAXCxs+3QXl2ZnfsxpdiOtZwKlDJZbPjTDt +JwiQX9MRqyC0IlNpbW9uIEpvc2Vmc3NvbiA8c2ltb25AeXViaWNvLmNvbT6I3gQT +AQIAKAUCT173QAIbAwUJFLfeCQYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ +7aIelLVlcW9RjgUArirRMHZOoxdCaEe2LuxKM3zx78QYrCZXHSNWiB58uydwx6Oc +7siglrn1ECbGUWnZhPZ1BjYEMLUdV4DATJeVw2gLdAqc3lZfT/MkVXY9cuk3zt8S +xJ2I2vkLK17A38whkHLWEHcZmwI6MHEyPRx+bPCbx/rgImWof3NVDcbVdqyPXO/B +DqYp5d9REq3PyRycoAu4szIM0ImYfXY2o9d0EojeBBMBAgAoBQJPXvdZAhsDBQkU +t94JBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRDtoh6UtWVxb739BP9Cmqxb +9NVzED185DhdN8bLpnjZaSNtmM3FeEO5Q3dBBbBWrbl/eEwIu8ax5y40q+C0vk+D +xRSF11g8n9TmyziYqeYyWccEgrWapkgPWbSiwGrg7Zyqo5eIQcw+HUMi8eZT3isd +aA7ur1c/gV059yVthIuTBiVX+xtUOvnHf+f+2Jrx9euTmj/O4/w42L0kL1TCaq+0 +unKCc6CHcYh4kcvViEYEExECAAYFAkJJAYsACgkQj8NyXz1o1joWfwCgtb8mtlI8 +rg52vT5DRU+Ct3NuDfEAoL7IX823ezbe7HVegheirf3q7zmKiEwEEBECAAwFAkJN +grUFgwDgKBoACgkQO46kH4L2EkA4fACeN2w05Staf2i18Sdv9aRax1hb53AAoL1Z +YuFfT+qVYT/afh9wD7UPlEVUiEwEExECAAwFAkJJRAoFgwATzkoACgkQZr5x/2dI +aIPZGACdECs/Brf5HO0PWPwIYf8GTur2kPUAoIHIKUWKCeoNUF2FnUzvx8b3uC7v +iEwEExECAAwFAkLYsI0FgwBU+kIACgkQGFnQH2d7oezt8QCfXjmAsN4+tvGt/A3Z +0bn4i6+m+1gAnihGZHKHHCnBqEYT7nbzXPZVOtD1iEwEExECAAwFAkLYsLEFgwBU ++h4ACgkQgcL36+ITtpLuwACdFi5eiQDLrrGLThgPU4O2yxgXDucAniWqyEVWfs1H +nLOe7S2KhgsXDJzniEwEExECAAwFAkLYsNEFgwBU+f4ACgkQa3Ds2V3D9HPaIQCg +kWvOhiORHkA1lht5f+jNB5xAKYAAnA0Kg/JKZrGvA7oGJR3XVs7zRs/FiPsEEwEC +AEUCGwMECwcDAgMVAgMDFgIBAh4BAheAIhhkbnM6c2ltb24uam9zZWZzc29uLm9y +Zz90eXBlPUNFUlQFAkJAXNAFCQZYo6QACgkQ7aIelLVlcW/RCAT+KZP87UBfl1eS ++JK1xJm4wLBm/QviPuDqEVGP5lg7zQIxqaZIRQ/vEN6EL4PtXXD7Cea0B0l4ANsN +WzrE5JyvQ2psmN+Sx3fU9GUpZVzlF/at0HiogwWHNigd+WbcSjSAOC7eag4GG0oL +ZREcQ2PeAQksuGAKXcAE3otzt9reSKEfga6HiK/sPs5/ZlbpZJ96UVwcmA1/7HMX +E7VsES/lDYkBHAQQAQIABgUCT31CQQAKCRBO8pNOTqpCMnTvCACSQf9jsr2h+M3A +drvI+qq/7ZPDOFicpVicmiQETcQLfuIXbiedWnio6F4tz6QI2Ht3PYGTQrkXUVnX +h5FV2wxJSuxnOg1j6pBGWHig7avd0GpkphsRUrWetQb1zPWSUILqIuKJAUznPTlU +v9nPkHF2KnDA9ZSaQzsOKYC25Q3bHpIKpPU7u9lYisrrLEtKg+v97WtCPmj2TTxa +MSZ1okAyjFwMV4JtLKPsfTnGKx4fMxqtzEDG1j3lftSaJtkVwacDofcxyp8oR9W8 +tb5lNsxpABUh+H/TuJUz7QwA4QJ+J7Hq+r98mQau81mqoR73JzF2a7cbpM9BED1L +vib20ICEiQEcBBABAgAGBQJPfUJCAAoJECmvJOqdHA553xgH/RznnMpNXcMqDKBt +bR7ux87SeUKREIrzc9S6+NFMN7NCjiLUOSnpc1fUQucQ3DCzhKPU8FPL/WE4zcRS +Bfoagljui1PtC1K1rzRV7+jYejmtbyN5Cyj7MtGbmvXZ1+MUqI5g+NEZh9fYI6+D +XKuckd74e13sKS6Sm301Sx7ymH96pFG/hui9t2bw9d6B7F4112VHB1/ey5KEZtIE +yHjhyfoKRgoQ2T1D0DEAac0UXpCV7E5J5S90Ka2+rNlmZz/wGupWSlXjw9+2QVxg +YQhnef2ozVN7NXcX7kurWquhhj2dAVtTTmvcykLkb25GICFj1MctosATHYVzNLxY +GY5u846JAiIEEwECAAwFAkLYsPEFgwBU+d4ACgkQquPmzmahRGhfdA//cVfLmv3s +4VjruQA4BxNcnljFkLHnCMfUwOUFUIPKaYwNxNkRHv5SWwsHlYcH70prr7spkUMO +9XCHZqhdXc/UfJm+tjda9Ow3D8Ym4bR4uKaBDcSB6rxG7Tkde2OkJeA1uD4ytbrf +ctsufByul04qgrW4ON4xHG15Na/aiyZdi4KKWCUNSiQsH5/gwlWnUQNhYFXJTBlB +iHYok8KddvhP+9KGKDMy8JvuzFIGyVKUS8rbHOX64U/dYl9pT6HspQBwENOvNVom +sL3sZarQD7aPRo27Z8N9qEjqiCXG2zITfBvO6ZLwYZOcF31TO5MrrQRYSB3EBRnr +hpGaYHl7eNDXFCX35/ijn3l84HUMJsDZaPStGq8TaSLpILoL1XjbbCo9YLVuyJGH +C5r5Q8koc/3MrYLjRFPtVtGXhu9046YbPJgkpQilXDVnMtpe8/w7wd1T4m2nOduf +0sNWSKuw0oURx7/MdNv+ufCxFu4Er72eI98rmUjYC9pYD82mKEKPvMrByvXalYlQ +VwByMFWU5l6bW+c8UHB7RVJ0edSA0gHwRne4I1OTSTXyip4C4wycuep5iRjMP/td +xeVxXIxjwvbemSqELne9divE0SHM1oBjJ4JGock5eCiMD8Vc1p1DdCJHLDv+cjty +bnVs82Aeq9UKJgkgAAProq7LScFbQVrAgOeI3gQTAQIAKAIbAwYLCQgHAwIGFQgC +CQoLBBYCAwECHgECF4AFAlGNkM0FCRaZvQYACgkQ7aIelLVlcW8vLgT8C/+0iVDx +moz+bvmODH8bZECjB+jyzdYSDBLEmrOPEjcyRtwFKFMInAZX+L8Zsfm0t6w0LuwG +kK4WIgiMC74JrHgGClLzLr/fjFUy5C57cGkNHA+3ksCfgzsZE4GNAW0UmAGSleWC +KaSg/HBDqO68B+9ge6C14EZ/qGaYtgNxPKEeEb1iHgUct+2aLni1WgijM9fkQZSW +UKChhKjyfph44LkBDQRPXvPYAQgAtBcE7pLVX2QYvdVkY5a69asAe4FYYg9PWTnr +sKF3OEW/C4iWo5KbKdfANPqfpLElb0MkVVGZuZQaa8KqnOZVYewxhGmmCk91aVaW +63+mAw1OFLs7cNU7oSST8+nQLgmwEsxvx37xwV0NlIQ2hdU3/umvv8OBjL9fc32q +5QRkDWmpDLqhkSPdh5y/qQ17ICK8Ltb+VCUPWL6CfGGLKBu0Bf7gxA8lQtor7wAV +Z7rGQngPujPnNT+5PUCprnaL6PFuG1R99BwNSssE5U7w1kdhZq7fjeszIiuoQYBW +RR8Y5n8JyXAgfQY/FPLat6p+uxD0y4+kaFlwq4cVNDbEk+KDLwARAQABiQIWBBgB +AgAPBQJPXvPYAhsCBQkCky4AAVsJEO2iHpS1ZXFvwI8gBBkBAgA4BQJPXvPYMRSA +AAAAABUAE3BrYS1hZGRyZXNzQGdudXBnLm9yZ3NpbW9uQGpvc2Vmc3Nvbi5vcmcA +CgkQYM7nERBeci7Aigf/bgS6UQCKQv8gPUTbI4iYzN7OTpUTjGcfwYqualscJgHZ +DR9zPItTYbJGx+YmqEkRwdHTWx7X9U8DJQDbS243TTcxjfGs+Nkio1Yh6ACb9onJ +MZjTF5v99+ogKwMn4RozJxrvainHsNisdCh3jxXb5zNTG0hhd1Y/E1xNs7ktJaAs +9JD+dZmAya7ImL3AY3OwD7u53NA4dRUH6v75SyXl36Hf1i2d11WoGlkTmy7x049R +X9XvBTodTFb/c9GQTaxIzKkxWKtHPPrcsltBGB8lT7wqQTxRDygM7ip58YKlny8A +OwcD+000x5K8MuiHBN7ghrHm84vcuy+TFjZ9ikA4nDt8BP4pr49m+JgobW9NQgrI +mItU1Sp9jxANtpaY9kf3zzTp3bA5S0LEQdQcPc50xNDN1yU3CcnvBM6XUdkpSy+S +DV8R21rc8APnetlxG0zkPSdGozZ4Yom2c/vHHjS7L8BnZGpOgm7X1RuQ4DTatDZ8 +IKjmDG0u0Byo8rxsaG0vCqBJJwRISLJLJxtQ4jgf9xIQyrQIlZRtiaUsHiAN84DP +PaH4uQENBE9e9DABCAC5ZTl/gBbsTPR2pUidEnboEhQ28AiDG3U1CBOnKVjeeC39 +SJ+zGoNV3qnRBa1jdwiA+z4b4drUfsMFSLlCPoiZs8Zm7QCXZppGdHazy8/Qrk1f +Q/lb0y4EVmYe62CCrqL+0uKQ7XFZdyECIhMiXcofmJFyd+mo0rnDpwRPwEFSRnZo +FBsG2Pf1bVM7LW7HhCv52KVsTFN3GQQRWDLUD6w2eyODj8S4qmVUlUhhjKJYn0hB +wwUsddOEicAByOZUWe/IGChcffcVUspE3SKY24A0OQBNayxPq/QKtRdBunLUPvOU +R8/sfYSUeeF6gia0K/dfVas4pIk6GC+frFwkY8PZABEBAAGIxQQYAQIADwUCT170 +MAIbDAUJApMuAAAKCRDtoh6UtWVxbwGiBPsFzcxVZgwQtKtCjeUN8tg/scADfbJ5 +29Ap3gi0+7qqTnOsRaGK6RBJ7XGciwV0rfg1BUetMbslUJ86tJay9FF5UlsYkhlF +bqMCtzCG3XeRZCOAi6PXha5QzFxZpaZl1NnBxScWtbuHEZfnohUrE60UtFMUXgr9 +w2qo07hhitK+J2rxDF5z3VtnEJb5KWr574YO5cndFxjJznXse6ATfi/9uQENBE9e +9hgBCAC7f94ryf32es/cOXm+zKFa1zbyLckzDU/EiBc7fj3mcYzaqv3E4hodIKJm +ZWs4tiBvkqi8VmLmT7S/NH5CX3rkAS2cd3tAsCUgVLYQK6AfXwOxpAH+HXY24ALY +fQCpmdwpaw2yeYAZ90SKL+slX77PJX9hK0jeEhJv/gb1SllbVRGO9JInFQ0gF89n +sSNVwUbcnhUwWUzU+Ni0F4za7jyjVwT4DNOT59p1puFhEBpSMWah8gRuQ0nQQXjM +zvV2EpKriu7GlW6LMWJkC2Ef6B67rhCaMFrr3BCjGmrqcEQQgFF8hjB/s/48mcrp +mvKrV+s6vrPEiOeL1PzEZD0yxLCjABEBAAGIxQQYAQIADwUCT172GAIbIAUJApMu +AAAKCRDtoh6UtWVxb1gMBP0fg+ae2PR6Edvfg0SCIGggggrVYL6xduKqK29yO6YQ +KF4qrFgEhEMyOaWQr2zN2piSOn7PHUKpxq9s9H4Z4QoaKI6caYwqd7n5NFHjKqHP +opkXXzoRjQEwDVtUtiMjugUzsE7m3AgzthwDk8NCkt/RDWYvS+ovWnUXqAoTE/cF +SOMizBDGEltQ56FI8DutONBhqMUEPTelMh9dM0yWZqI9uKsEPNUHewEFANj02qE/ +ETZBQ5V+1Ajgfb2kRca1/nTe5ekDvjtDIO3VXYyLRJ2mmJCfq+C13nCOOx6ILFBh +MUXQ2Bk9A6u2mfBpAuFCj13N6tilkN4m98I96pwhptyF/yNuPcnWCwM0MlqjFtPc +Cweb8YT4uMo3reBUxlprWFJRsw2+/ulWYpWEU7ctL4RReHFV5Ttkfr4D8RTL1HO6 +PFhg50N4slgIs5EABimIxQQYAQIADwIbDAUCTvm3OwUJFLfdvwAKCRDtoh6UtWVx +bxtQBQCMME1gRLDDO6i/Mg331TkBAKZkrThK8Ugos6dVftPKy8RyIHUpwyVZNvqi +JS19WuWrjvWL1hs07QLBxG4X7BcS93iCvfmnURXvFRIm1BsvVmTVbjlLpaTKo6Ot +qM3tMOwucYazkS+eE+sN8qxcD1G0vwEpDfXKM6XrUE32eFUMI8G/T53qz90hWwO3 +0AYn3TVGm6UkXbeIZEuTh9zbapH2iMUEGAECAA8CGwwFAlGNkNUFCRaZvNgACgkQ +7aIelLVlcW9eoAUAmoqau2N+23ZC77S+bMgp9fmijyP49pmrwaVIZ5JyLhuGjQ4r +z4GD7yoVjKV/8aOBcA5WnuhhJ18okFI+Vy8L6mMKs0TQXi3rjxoza61oSPMimWqT +oj8c9lhGHxihx5hdMqKJnMEv8SnxXx01fqE+TCKmSTOzHpWrO2TPnz9qzZOv4BaD +RKd+AKc8zZkSX14v+TFiB4VkSBVxHDvDG4hDHw== +=4uNW +-----END PGP PUBLIC KEY BLOCK----- diff --git a/gnutls.spec b/gnutls.spec index c5f39a6..533b35f 100644 --- a/gnutls.spec +++ b/gnutls.spec @@ -21,25 +21,38 @@ %define gnutls_ossl_sover 27 Name: gnutls -Version: 3.0.28 +Version: 3.2.1 Release: 0 Summary: The GNU Transport Layer Security Library -License: LGPL-3.0+ and GPL-3.0+ +License: LGPL-2.1+ and GPL-3.0+ Group: Productivity/Networking/Security Url: http://www.gnutls.org/ -Source0: ftp://ftp.gnutls.org/gcrypt/gnutls/v3.0/%{name}-%{version}.tar.xz -Source1: baselibs.conf -# suse specific, add support for certificate directories -- lnussel +Source0: ftp://ftp.gnutls.org/gcrypt/gnutls/v3.2/%{name}-%{version}.tar.xz +# signature is checked by source services. +Source1: ftp://ftp.gnutls.org/gcrypt/gnutls/v3.2/%{name}-%{version}.tar.xz.sig +Source2: %name.keyring +Source3: baselibs.conf +# suse specific, add support for certificate directories -- lnussel/meissner Patch1: gnutls-implement-trust-store-dir.diff + Patch2: automake-1.12.patch # PATCH-FIX-OPENSUSE gnutls-3.0.26-skip-test-fwrite.patch andreas.stieger@gmx.de -- skip a failing test Patch3: gnutls-3.0.26-skip-test-fwrite.patch + +# https://gitorious.org/gnutls/gnutls/commit/b12040aeab5fbaf02677571db1d8bf1995bd5ee0?format=patch +# PATCH-UPSTREAM gnutls-32bit.patch meissner@suse.de -- avoid dates after 2037 with 32bit time_t +Patch4: gnutls-32bit.patch + +# Disable elliptic curves for reasons. - meissner&cfarrell +Patch5: gnutls-3.2.1-noecc.patch + BuildRequires: automake BuildRequires: gcc-c++ BuildRequires: libidn-devel -BuildRequires: libnettle-devel >= 2.2 +BuildRequires: libnettle-devel >= 2.7 BuildRequires: libtasn1-devel >= 2.14 BuildRequires: libtool +BuildRequires: valgrind %if %suse_version >= 1230 BuildRequires: makeinfo %endif @@ -60,7 +73,7 @@ implements the proposed standards of the IETF's TLS working group. %package -n libgnutls%{gnutls_sover} Summary: The GNU Transport Layer Security Library -License: LGPL-3.0+ +License: LGPL-2.1+ Group: Productivity/Networking/Security %description -n libgnutls%{gnutls_sover} @@ -70,7 +83,7 @@ implements the proposed standards of the IETF's TLS working group. %package -n libgnutlsxx%{gnutlsxx_sover} Summary: The GNU Transport Layer Security Library -License: LGPL-3.0+ +License: LGPL-2.1+ Group: Productivity/Networking/Security %description -n libgnutlsxx%{gnutlsxx_sover} @@ -92,7 +105,7 @@ implements the proposed standards of the IETF's TLS working group. %package -n libgnutls-devel Summary: Development package for gnutls -License: LGPL-3.0+ +License: LGPL-2.1+ Group: Development/Libraries/C and C++ PreReq: %install_info_prereq Requires: glibc-devel @@ -104,7 +117,7 @@ Files needed for software development using gnutls. %package -n libgnutlsxx-devel Summary: Development package for gnutls -License: LGPL-3.0+ +License: LGPL-2.1+ Group: Development/Libraries/C and C++ PreReq: %install_info_prereq Requires: libgnutls-devel = %{version} @@ -128,19 +141,22 @@ Files needed for software development using gnutls. %prep %setup -q -%patch1 +%patch1 -p1 %patch2 -p1 %patch3 -echo %{_includedir}/%{name}/abstract.h +%patch4 -p1 +%patch5 -p1 %build autoreconf -if +# echde explicitly disabled - meissner&cfarrell %configure \ --disable-static \ --with-pic \ --disable-rpath \ --disable-silent-rules \ --with-default-trust-store-dir=/etc/ssl/certs \ + --disable-ecdhe \ --with-sysroot=/%{?_sysroot} %__make %{?_smp_mflags} @@ -200,11 +216,13 @@ rm -rf %{buildroot} %{_bindir}/psktool %{_bindir}/p11tool %{_bindir}/srptool +%{_bindir}/danetool %{_mandir}/man1/* %files -n libgnutls%{gnutls_sover} %defattr(-,root,root) %{_libdir}/libgnutls.so.%{gnutls_sover}* +%{_libdir}/libgnutls-xssl.so.* %files -n libgnutls-openssl%{gnutls_ossl_sover} %defattr(-,root,root) @@ -227,7 +245,10 @@ rm -rf %{buildroot} %{_includedir}/%{name}/pkcs11.h %{_includedir}/%{name}/pkcs12.h %{_includedir}/%{name}/x509.h +%{_includedir}/%{name}/tpm.h +%{_includedir}/%{name}/xssl.h %{_libdir}/libgnutls.so +%{_libdir}/libgnutls-xssl.so %{_libdir}/pkgconfig/gnutls.pc %{_mandir}/man3/* %{_infodir}/*.*