diff --git a/Makefile-test.am b/Makefile-test.am index 827c4736e..ca2dcdc85 100644 --- a/Makefile-test.am +++ b/Makefile-test.am @@ -92,7 +92,8 @@ FAPI_TEST_BINS = \ test/data/fapi/eventlog/sml-ima-sig-sha256-invalidated.bin \ test/data/fapi/eventlog/event-uefivar.bin \ test/data/fapi/eventlog/specid-vendordata.bin \ - test/data/fapi/eventlog/sml-ima-ng-sha1.bin + test/data/fapi/eventlog/sml-ima-ng-sha1.bin \ + test/data/fapi/eventlog/binary_measurements_hcrtm.bin CLEANFILES += $(FAPI_TEST_BINS) endif #FAPI diff --git a/Makefile.am b/Makefile.am index 2a743660d..4ddeb3ec7 100644 --- a/Makefile.am +++ b/Makefile.am @@ -760,7 +760,8 @@ EXTRA_DIST += \ test/data/fapi/eventlog/sml-ima-ng-sha1-invalidated.b64 \ test/data/fapi/eventlog/sml-ima-ng-sha1-invalidated.b64 \ test/data/fapi/eventlog/sml-ima-sig-sha256-invalidated.b64 \ - test/data/fapi/eventlog/sml-ima-sha1-invalidated.b64 + test/data/fapi/eventlog/sml-ima-sha1-invalidated.b64 \ + test/data/fapi/eventlog/binary_measurements_hcrtm.b64 src_tss2_fapi_libtss2_fapi_la_LIBADD = $(libtss2_sys) $(libtss2_mu) $(libtss2_esys) \ $(libutil) $(libtss2_tctildr) diff --git a/src/tss2-fapi/efi_event.h b/src/tss2-fapi/efi_event.h index ddbeb4c17..7c6b91842 100644 --- a/src/tss2-fapi/efi_event.h +++ b/src/tss2-fapi/efi_event.h @@ -125,4 +125,19 @@ typedef struct { BYTE DevicePath[]; } PACKED UEFI_IMAGE_LOAD_EVENT; +/* + * EV_NO_ACTION_STRUCT is the structure of an EV_NO_ACTION event. + * Described in TCG PCClient PFP section 9.4.5. + * The Signature identifies which arm of the union applies. + */ +typedef struct { + BYTE Signature[16]; + union { + BYTE StartupLocality; + } Cases; +} PACKED EV_NO_ACTION_STRUCT; + +static const BYTE STARTUP_LOCALITY_SIGNATURE[16] = {0x53, 0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x4C, + 0x6F, 0x63, 0x61, 0x6C, 0x69, 0x74, 0x79, 0}; + #endif diff --git a/src/tss2-fapi/ifapi_eventlog_system.c b/src/tss2-fapi/ifapi_eventlog_system.c index 047a9905c..bfd1d544b 100644 --- a/src/tss2-fapi/ifapi_eventlog_system.c +++ b/src/tss2-fapi/ifapi_eventlog_system.c @@ -99,7 +99,6 @@ bool digest2_accumulator_callback(TCG_DIGEST2 const *digest, size_t size, bool foreach_digest2( tpm2_eventlog_context *ctx, UINT32 event_type, - unsigned pcr_index, TCG_DIGEST2 const *digest, size_t count, size_t size) { @@ -110,7 +109,6 @@ bool foreach_digest2( } bool ret = true; - TSS2_RC r; size_t i, j; for (i = 0; i < count; i++) { @@ -126,29 +124,6 @@ bool foreach_digest2( return false; } - uint8_t *pcr = NULL; - if (pcr_index > TPM2_MAX_PCRS) { - LOG_ERROR("PCR%d > max %d", pcr_index, TPM2_MAX_PCRS); - return false; - } else if (alg == TPM2_ALG_SHA1) { - pcr = ctx->sha1_pcrs[pcr_index]; - ctx->sha1_used |= (1 << pcr_index); - } else if (alg == TPM2_ALG_SHA256) { - pcr = ctx->sha256_pcrs[pcr_index]; - ctx->sha256_used |= (1 << pcr_index); - } else if (alg == TPM2_ALG_SHA384) { - pcr = ctx->sha384_pcrs[pcr_index]; - ctx->sha384_used |= (1 << pcr_index); - } else if (alg == TPM2_ALG_SHA512) { - pcr = ctx->sha512_pcrs[pcr_index]; - ctx->sha512_used |= (1 << pcr_index); - } else if (alg == TPM2_ALG_SM3_256) { - pcr = ctx->sm3_256_pcrs[pcr_index]; - ctx->sm3_256_used |= (1 << pcr_index); - } else { - LOG_WARNING("PCR%d algorithm %d unsupported", pcr_index, alg); - } - if (event_type == EV_NO_ACTION) { /* Digest for EV_NO_ACTION must consist of 0 bytes. */ for (j = 0; j < alg_size; j++) { @@ -157,14 +132,6 @@ bool foreach_digest2( return false; } } - } else { - if (pcr) { - r = ifapi_extend_pcr(alg, pcr, digest->Digest, alg_size); - if (r) { - LOG_ERROR("PCR%d extend failed", pcr_index); - return false; - } - } } if (ctx->digest2_cb != NULL) { @@ -237,6 +204,21 @@ bool parse_event2body(TCG_EVENT2 const *event, UINT32 type) { /* what about the device path? */ } break; + /* TCG PC Client Platform Firmware Profile Specification Level 00 Version 1.05 Revision 23 section 10.4.1 */ + case EV_EFI_HCRTM_EVENT: + { + const char hcrtm_data[] = "HCRTM"; + size_t len = strlen(hcrtm_data); + BYTE *data = (BYTE *)event->Event; + if (event->EventSize != len || + strncmp((const char *)data, hcrtm_data, len)) { + LOG_ERROR("HCRTM Event Data MUST be the string: \"%s\"", hcrtm_data); + return false; + } + } + break; + + } return true; @@ -260,7 +242,7 @@ bool parse_event2(TCG_EVENT_HEADER2 const *eventhdr, size_t buf_size, .data = digests_size, .digest2_cb = digest2_accumulator_callback, }; - ret = foreach_digest2(&ctx, eventhdr->EventType, eventhdr->PCRIndex, + ret = foreach_digest2(&ctx, eventhdr->EventType, eventhdr->Digests, eventhdr->DigestCount, buf_size - sizeof(*eventhdr)); if (ret != true) { @@ -310,9 +292,6 @@ bool parse_sha1_log_event(TCG_EVENT const *event, size_t size, bool foreach_sha1_log_event(tpm2_eventlog_context *ctx, TCG_EVENT const *eventhdr_start, size_t size) { - uint8_t *pcr = NULL; - TSS2_RC r; - if (eventhdr_start == NULL) { LOG_ERROR("invalid parameter"); return false; @@ -350,16 +329,6 @@ bool foreach_sha1_log_event(tpm2_eventlog_context *ctx, TCG_EVENT const *eventhd return ret; } - pcr = ctx->sha1_pcrs[eventhdr->pcrIndex]; - if (pcr && eventhdr->eventType != EV_NO_ACTION ) { - r = ifapi_extend_pcr(TPM2_ALG_SHA1, pcr, &eventhdr->digest[0], 20); - if (r) { - LOG_ERROR("PCR%d extend failed", eventhdr->pcrIndex); - return false; - } - ctx->sha1_used |= (1 << eventhdr->pcrIndex); - } - /* event data callback */ if (ctx->event2_cb != NULL) { ret = ctx->event2_cb(event, eventhdr->eventType, ctx->data); @@ -409,7 +378,7 @@ bool foreach_event2(tpm2_eventlog_context *ctx, TCG_EVENT_HEADER2 const *eventhd } /* digest callback foreach digest */ - ret = foreach_digest2(ctx, eventhdr->EventType, eventhdr->PCRIndex, + ret = foreach_digest2(ctx, eventhdr->EventType, eventhdr->Digests, eventhdr->DigestCount, digests_size); if (ret != true) { return false; @@ -567,6 +536,7 @@ ifapi_json_TCG_EVENT_TYPE_deserialize_txt(json_object *jso, const char *token = json_object_get_string(jso); check_oom(token); + LOG_TRACE("TCG Event: %s", token); if (get_number(token, &i64)) { *out = (IFAPI_EVENT_TYPE) i64; @@ -606,6 +576,7 @@ TSS2_RC ifapi_json_TCG_EVENT_TYPE_deserialize(json_object *jso, IFAPI_EVENT_TYPE *out) { LOG_TRACE("call"); + return ifapi_json_TCG_EVENT_TYPE_deserialize_txt(jso, out); } @@ -633,7 +604,7 @@ check_out_string(const IFAPI_FIRMWARE_EVENT *in, const char *string) { * * @param[in] jso the json object to be deserialized. * @param[out] out the deserialzed binary object. - * @param[out] verify swithc whether the digest can be verified. + * @param[out] verify switch whether the digest can be verified. * @retval TSS2_RC_SUCCESS if the function call was a success. * @retval TSS2_FAPI_RC_BAD_VALUE if the json object can't be deserialized. * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. @@ -661,6 +632,8 @@ ifapi_json_IFAPI_FIRMWARE_EVENT_deserialize( r = ifapi_json_TCG_EVENT_TYPE_deserialize (jso2, &event_type); return_if_error(r,"BAD VALUE"); + out->event_type = event_type; + if (!ifapi_get_sub_object(jso, "event_data", &jso2)) { LOG_ERROR("Bad value"); return TSS2_FAPI_RC_BAD_VALUE; @@ -715,7 +688,10 @@ ifapi_json_IFAPI_FIRMWARE_EVENT_deserialize( event_type == EV_IPL_PARTITION_DATA || event_type == EV_NONHOST_CODE || event_type == EV_NONHOST_CONFIG || - event_type == EV_EFI_RUNTIME_SERVICES_DRIVER) { + event_type == EV_EFI_RUNTIME_SERVICES_DRIVER || + /* Verification not possible. (TODO check) */ + event_type == EV_EFI_HCRTM_EVENT || + event_type == EV_EFI_VARIABLE_BOOT) { *verify = false; } else if ( /* Verification is possible. (TODO check) */ @@ -726,12 +702,10 @@ ifapi_json_IFAPI_FIRMWARE_EVENT_deserialize( event_type == EV_EFI_VARIABLE_AUTHORITY || /* Verification is possible. */ event_type == EV_S_CRTM_VERSION || - event_type == EV_EFI_HCRTM_EVENT || event_type == EV_SEPARATOR || event_type == EV_EFI_VARIABLE_DRIVER_CONFIG || event_type == EV_EFI_GPT_EVENT || event_type == EV_PLATFORM_CONFIG_FLAGS || - event_type == EV_EFI_VARIABLE_BOOT || event_type == EV_EFI_ACTION) { *verify = true; } else { diff --git a/src/tss2-fapi/ifapi_eventlog_system.h b/src/tss2-fapi/ifapi_eventlog_system.h index da4265750..c10e2e3c8 100644 --- a/src/tss2-fapi/ifapi_eventlog_system.h +++ b/src/tss2-fapi/ifapi_eventlog_system.h @@ -34,16 +34,6 @@ typedef struct { EVENT2_CALLBACK event2hdr_cb; DIGEST2_CALLBACK digest2_cb; EVENT2DATA_CALLBACK event2_cb; - uint32_t sha1_used; - uint32_t sha256_used; - uint32_t sha384_used; - uint32_t sha512_used; - uint32_t sm3_256_used; - uint8_t sha1_pcrs[TPM2_MAX_PCRS][TPM2_SHA1_DIGEST_SIZE]; - uint8_t sha256_pcrs[TPM2_MAX_PCRS][TPM2_SHA256_DIGEST_SIZE]; - uint8_t sha384_pcrs[TPM2_MAX_PCRS][TPM2_SHA384_DIGEST_SIZE]; - uint8_t sha512_pcrs[TPM2_MAX_PCRS][TPM2_SHA512_DIGEST_SIZE]; - uint8_t sm3_256_pcrs[TPM2_MAX_PCRS][TPM2_SM3_256_DIGEST_SIZE]; } tpm2_eventlog_context; /** Firmware event information stored in log @@ -58,7 +48,7 @@ bool digest2_accumulator_callback(TCG_DIGEST2 const *digest, size_t size, void *data); bool parse_event2body(TCG_EVENT2 const *event, UINT32 type); -bool foreach_digest2(tpm2_eventlog_context *ctx, UINT32 event_type, unsigned pcr_index, +bool foreach_digest2(tpm2_eventlog_context *ctx, UINT32 event_type, TCG_DIGEST2 const *event_hdr, size_t count, size_t size); bool parse_event2(TCG_EVENT_HEADER2 const *eventhdr, size_t buf_size, size_t *event_size, size_t *digests_size); diff --git a/src/tss2-fapi/ifapi_helpers.c b/src/tss2-fapi/ifapi_helpers.c index 90ecc8f86..84c499259 100644 --- a/src/tss2-fapi/ifapi_helpers.c +++ b/src/tss2-fapi/ifapi_helpers.c @@ -2101,6 +2101,111 @@ ifapi_extend_pcr( return r; } +/** Compute pcr values from event list + * + * The event list is used to compute the PCR values corresponding + * to this event list. + * @param[in] jso_event_list The event list in JSON representation. + * @param[in] pcr_selection The definition of the used pcrs. + * @param[out] pcrs The computed pcr list + * @param[out] n_pcrs The number of used pcrs + * + * @retval TSS2_RC_SUCCESS: If the PCR digest from the event list matches + * the PCR digest passed with the quote_info. + * @retval TSS2_FAPI_RC_BAD_VALUE: If inappropriate values are detected in the + * input data. + * @retval TSS2_FAPI_RC_GENERAL_FAILURE if an internal error occurred. + * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. + * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. + */ +TSS2_RC +ifapi_calculate_pcrs( + json_object *jso_event_list, + const TPML_PCR_SELECTION *pcr_selection, + IFAPI_PCR_REG pcrs[], + size_t *n_pcrs) +{ + TSS2_RC r = TSS2_RC_SUCCESS; + IFAPI_CRYPTO_CONTEXT_BLOB *cryptoContext = NULL; + size_t i, pcr, i_evt, hash_size, n_events = 0; + + json_object *jso; + IFAPI_EVENT event; + bool found_hcrtm = false; + UINT8 locality = 0; + + *n_pcrs = 0; + + /* Initialize used pcrs */ + for (i = 0; i < pcr_selection->count; i++) { + for (pcr = 0; pcr < TPM2_MAX_PCRS; pcr++) { + uint8_t byte_idx = pcr / 8; + uint8_t flag = 1 << (pcr % 8); + if (flag & pcr_selection->pcrSelections[i].pcrSelect[byte_idx]) { + hash_size = ifapi_hash_get_digest_size(pcr_selection->pcrSelections[i].hash); + pcrs[*n_pcrs].pcr = pcr; + pcrs[*n_pcrs].bank = pcr_selection->pcrSelections[i].hash; + pcrs[*n_pcrs].value.size = hash_size; + memset(&pcrs[*n_pcrs].value.buffer[0], 0, hash_size); + *n_pcrs += 1; + } + } + } + + /* Compute pcr values based on event list */ + if (jso_event_list) { + n_events = json_object_array_length(jso_event_list); + for (i_evt = 0; i_evt < n_events; i_evt++) { + jso = json_object_array_get_idx(jso_event_list, i_evt); + r = ifapi_json_IFAPI_EVENT_deserialize(jso, &event, DIGEST_CHECK_WARNING); + goto_if_error(r, "Error serialize policy", error_cleanup); + LOG_TRACE("Deserialized Event for PCR %u", event.pcr); + + if (event.content_type == IFAPI_PC_CLIENT && + event.content.firmware_event.event_type == EV_EFI_HCRTM_EVENT && event.pcr == 0) { + found_hcrtm = true; + } + + /* Handle StartupLocality in replay for PCR0 */ + if (event.content_type == IFAPI_PC_CLIENT && + !found_hcrtm && + event.content.firmware_event.event_type == EV_NO_ACTION && event.pcr == 0) { + if (event.content.firmware_event.data.size < sizeof(EV_NO_ACTION_STRUCT)) { + goto_error(r, TSS2_FAPI_RC_BAD_VALUE, "EventSize is too small.", error_cleanup); + } + EV_NO_ACTION_STRUCT *locality_event = (EV_NO_ACTION_STRUCT*)&event.content.firmware_event.data.buffer[0]; + if (memcmp(locality_event->Signature, STARTUP_LOCALITY_SIGNATURE, + sizeof(STARTUP_LOCALITY_SIGNATURE)) == 0) { + locality = locality_event->Cases.StartupLocality; + } + } + + for (i = 0; i < *n_pcrs; i++) { + if (pcrs[i].pcr == event.pcr) { + if (event.content_type == IFAPI_PC_CLIENT && event.pcr == 0) { + if (event.content.firmware_event.event_type == EV_EFI_HCRTM_EVENT) { + /* Trusted Platform Module Library Part 1 section 34.3 */ + pcrs[i].value.buffer[pcrs[i].value.size - 1] = 0x04; + } else if (event.content.firmware_event.event_type == EV_NO_ACTION && + locality > 0) { + pcrs[i].value.buffer[pcrs[i].value.size - 1] = locality; + } + } + LOG_DEBUG("Extend PCR %uz", pcrs[i].pcr); + r = ifapi_extend_vpcr(&pcrs[i].value, pcrs[i].bank, &event); + goto_if_error2(r, "Extending vpcr %"PRIu32, error_cleanup, pcrs[i].pcr); + } + } + ifapi_cleanup_event(&event); + } + } + +error_cleanup: + if (cryptoContext) + ifapi_crypto_hash_abort(&cryptoContext); + ifapi_cleanup_event(&event); + return r; +} /** Check whether a event list corresponds to a certain quote information. * @@ -2130,15 +2235,9 @@ ifapi_calculate_pcr_digest( { TSS2_RC r; IFAPI_CRYPTO_CONTEXT_BLOB *cryptoContext = NULL; + IFAPI_PCR_REG pcrs[TPM2_MAX_PCRS]; + size_t i, hash_size, n_pcrs = 0; - struct { - TPMI_ALG_HASH bank; - TPM2_HANDLE pcr; - TPM2B_DIGEST value; - } pcrs[TPM2_MAX_PCRS]; - size_t i, pcr, i_evt, hash_size, n_pcrs = 0, n_events = 0; - - json_object *jso; IFAPI_EVENT event; const TPML_PCR_SELECTION *pcr_selection; @@ -2166,41 +2265,8 @@ ifapi_calculate_pcr_digest( return TSS2_FAPI_RC_BAD_VALUE; } - /* Initialize used pcrs */ - for (i = 0; i < pcr_selection->count; i++) { - for (pcr = 0; pcr < TPM2_MAX_PCRS; pcr++) { - uint8_t byte_idx = pcr / 8; - uint8_t flag = 1 << (pcr % 8); - if (flag & pcr_selection->pcrSelections[i].pcrSelect[byte_idx]) { - hash_size = ifapi_hash_get_digest_size(pcr_selection->pcrSelections[i].hash); - pcrs[n_pcrs].pcr = pcr; - pcrs[n_pcrs].bank = pcr_selection->pcrSelections[i].hash; - pcrs[n_pcrs].value.size = hash_size; - memset(&pcrs[n_pcrs].value.buffer[0], 0, hash_size); - n_pcrs += 1; - } - } - } - - /* Compute pcr values based on event list */ - if (jso_event_list) { - n_events = json_object_array_length(jso_event_list); - for (i_evt = 0; i_evt < n_events; i_evt++) { - jso = json_object_array_get_idx(jso_event_list, i_evt); - r = ifapi_json_IFAPI_EVENT_deserialize(jso, &event, DIGEST_CHECK_WARNING); - goto_if_error(r, "Error serialize policy", error_cleanup); - LOG_TRACE("Deserialized Event for PCR %u", event.pcr); - - for (i = 0; i < n_pcrs; i++) { - if (pcrs[i].pcr == event.pcr) { - LOG_DEBUG("Extend PCR %uz", pcrs[i].pcr); - r = ifapi_extend_vpcr(&pcrs[i].value, pcrs[i].bank, &event); - goto_if_error2(r, "Extending vpcr %"PRIu32, error_cleanup, pcrs[i].pcr); - } - } - ifapi_cleanup_event(&event); - } - } + r = ifapi_calculate_pcrs(jso_event_list, pcr_selection, &pcrs[0], &n_pcrs); + goto_if_error(r, "Compute PCRFs", error_cleanup); /* Compute digest for the used pcrs */ r = ifapi_crypto_hash_start(&cryptoContext, pcr_digest_hash_alg); diff --git a/src/tss2-fapi/ifapi_helpers.h b/src/tss2-fapi/ifapi_helpers.h index e1229ffd1..3a9244183 100644 --- a/src/tss2-fapi/ifapi_helpers.h +++ b/src/tss2-fapi/ifapi_helpers.h @@ -17,6 +17,15 @@ #include "tss2_fapi.h" #include "fapi_int.h" +/** Type for representing a external public key + */ +typedef struct { + TPMI_ALG_HASH bank; + TPM2_HANDLE pcr; + TPM2B_DIGEST value; +} IFAPI_PCR_REG; + + TSS2_RC ifapi_create_dirs(const char *supdir, const char *path); @@ -164,6 +173,12 @@ ifapi_filter_pcr_selection_by_index( const TPM2_HANDLE *pcr_index, size_t pcr_count); +TSS2_RC ifapi_calculate_pcrs( + json_object *jso_event_list, + const TPML_PCR_SELECTION *pcr_selection, + IFAPI_PCR_REG pcrs[], + size_t *n_pcrs); + TSS2_RC ifapi_calculate_pcr_digest( json_object *jso_event_list, const FAPI_QUOTE_INFO *quote_info, diff --git a/src/tss2-fapi/ifapi_json_deserialize.c b/src/tss2-fapi/ifapi_json_deserialize.c index aa9b275ab..a995c873b 100644 --- a/src/tss2-fapi/ifapi_json_deserialize.c +++ b/src/tss2-fapi/ifapi_json_deserialize.c @@ -1078,6 +1078,7 @@ ifapi_json_IFAPI_EVENT_deserialize( } else { out->recnum = 0; } + LOG_ERROR("XXX Event num %"PRIu32, out->recnum); if (!ifapi_get_sub_object(jso, "pcr", &jso2)) { LOG_ERROR("Field \"pcr\" not found."); diff --git a/test/data/fapi/eventlog/binary_measurements_hcrtm.b64 b/test/data/fapi/eventlog/binary_measurements_hcrtm.b64 new file mode 100644 index 000000000..706310fc2 --- /dev/null +++ b/test/data/fapi/eventlog/binary_measurements_hcrtm.b64 @@ -0,0 +1,1118 @@ +AAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkAAABTcGVjIElEIEV2ZW50MDMA +AAAAAAACAAIDAAAABAAUAAsAIAASACAAAAAAAAAQAACAAwAAAAQAHyn8eESXsoWL +189pjgqUnINqByALAEz/mXtpDq2jkh3mVbN29BQULQHRmT5sbKtQj1adhBBZEgBb +qD2SvjrAROB7fZTUzJyAabwIg7R+uhFzUAGFzWTGbgUAAABIQ1JUTQAAAAAIAAAA +AwAAAAQABGWsau2OMf/L2N27Cp0b7GhQpd8LAJeu0Hme0isqz42yNTE6VRpNKjxd +9Z7z+Coomz+mdkeAEgD/1wTvjSTbDyNSnSMgrQz/hzbUAhYLEkjDQcPaXCxA+SwA +AABEAGgAeQBhAG4AYQAyAC4AMAA1AC4ANAAzAC4AMgA5AC4AMAAwADAAMwAAAAAA +AAAIAACAAwAAAAQA6GYEgWuhb8ZU1eGgc78tmIGyuU4LAEDoUegRUvbBTIcubFDH +brZzWszF3DgeEac7FeFNNn7tEgA3JeLUDZaOifmn90Yg4OtoB3yZjDIa+IBBWc6W +7dH0vBAAAAAAAOAxAAAAAAAAHAAAAAAAAAAAAAgAAIADAAAABAD/jJ44DJIO+n5c +VL/k0UFHqhlA4gsAu87md94pQOc20G+gNorNlKNz5yCre1tVVUSt+JYfeEASAOK8 +LRU9w7RQj6H42Ihy1oj51o4RAOf9oUj7h6vv7JLmEAAAAAAAmP8AAAAAAABOAAAA +AAAHAAAAAQAAgAMAAAAEAFfNTcGUQkdaqCdDSE87HKqI4UK4CwARWqgn28z7RNIW +rZ7P2la96mILhgqUvtW3onu6HE0C2BIAw+hiCXBLITPV93+6X/o+BO9jNymx6mCG +3GWElW20e201AAAAYd/ki8qT0hGqDQDgmAMrjAoAAAAAAAAAAQAAAAAAAABTAGUA +YwB1AHIAZQBCAG8AbwB0AAAHAAAAAQAAgAMAAAAEAJsThzBuu3/455XnvndWNma7 +9FFuCwDep7gKtTo9qqJNXMRsZOH6n/0Dc5+QqtvYwIZ8SltIkBIAIFcCJYrq7K9o +Uz6QwsbLF83BvDT1yZ4FZLtX9e06DickAAAAYd/ki8qT0hGqDQDgmAMrjAIAAAAA +AAAAAAAAAAAAAABQAEsABwAAAAEAAIADAAAABACa+obFB0GbhXDGIWfLlIbZ/ICX +WAsA5nDhIfzr1HO4vEG7gBMB/B2a+jOQTwb3FJt08SxHpo8SAJf4Qs+L4+8Mmx5f +ttSrSvJrKUPlzjSYg6/fYH6BcH96JgAAAGHf5IvKk9IRqg0A4JgDK4wDAAAAAAAA +AAAAAAAAAAAASwBFAEsABwAAAAEAAIADAAAABABb+PqgeNQP+9AzF8kzmLASKaDh +4AsAuviaPMrOUnUMXwEoNR4EIqQVl6Gt/VCCKqNjudEk6nwSAPeCR5M3WGAqDiuj +jNx++0tV1KF/muwh32r1bWxzibsFJAAAAMuyGdc6PZZFo7za0A5nZW8CAAAAAAAA +AAAAAAAAAAAAZABiAAcAAAABAACAAwAAAAQArDR1MERmdkcIXnsRkQoBERKXA/YL +AMt4LqYi2FgqpxeAISxQAStxHCbuYuMwFT9Gsz6fBsNbEgANY12Kiw7u2VmJWJ80 +FAkN7lfjrBntgDSFAA61IFxCxXIAAADLshnXOj2WRaO82tAOZ2VvAwAAAAAAAABM +AAAAAAAAAGQAYgB4ACYWxMFMUJJArKlB+TaTQyhMAAAAAAAAADAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAABAAA +AAMAAAAEAJBpynjnRQooUXNDGz5SxcJSmeRzCwDfP2GYBKkv20BXGS3EPddI6neK +3FK8SYzoBSTAFLgRGRIAr8yHD6IMUHmVSZeUNx6MJeOnMQ+nIgDBCTeZc64jaEUE +AAAAAAAAAAEAAAAJAACAAwAAAAQAibw5TbjmpxAMk5d2gWviZJNrcKkLAG0/MaDP +Ba8/uKWwgfidAFqy4iivKsf/ifUGqsWqydjvEgA+oNXRQ8hJIdGzk65EID/OFdBF +itkgPlDH3kaZYfBBiiAAAAABAAAAAAAAAEQV/fKUlyxKmS7lu88g45QAUOduAAAA +AAEAAAACAACAAwAAAAQAoz9bX9axyt30pK3uEHo8yR0tFNILAGsec6AJS3uBLTue +Is/7T4I5MZhHUixPoQN1O2lQAg+TEgCMXDpy4+hMcETzbA8x0KpjEkbvbUl4mmCf +L9Rgy5+/vjYAAABh3+SLypPSEaoNAOCYAyuMCQAAAAAAAAAEAAAAAAAAAEIAbwBv +AHQATwByAGQAZQByAAAAAQABAAAAAgAAgAMAAAAEAISbPfuGZWkfp42//EA9jXzb +kaWPCwCl7qB6z1o95ydhWWMVQySMm3/tVNGRlAlAzv8m8jww7RIAMHrnfjK4REYN +WzcvQtKf90RM4xL9lue/PdIFwf91bNgKAQAAYd/ki8qT0hGqDQDgmAMrjAgAAAAA +AAAA2gAAAAAAAABCAG8AbwB0ADAAMAAwADAAAQAAAFAAUwBBAFQAQQAwACAAUABv +AHIAdAA3ACAALQAgAEUARgBJACAASABhAHIAZAAgAEQAcgBpAHYAZQAgACgAVwBN +AEMANgBOADAASwBBAEgANQBSAFIALQBIAEcAUwBUACAASABVAFMANwAyADIAVAAy +AFQAQQBMAEEANgAwADQAKQAAAAIBDADQQQMKAAAAAAEBBgABCAEBBgACAAMSCgAH +AAAAAAAEASoAAQAAAAAIAAAAAAAAAAAQAAAAAABifeGGOoCdT57l9d+7O7xWAgJ/ +/wQAUkMBAAAAAgAAgAMAAAAEAK1w96gJ3YF88VMzVEeZQY/mblyRCwCWBB7I2oyK +6nvV0gUff45LKkGknHjVXBfnZ9X6x/uWShIAXEQGStGm/6+a146j8keuWor2Ufq9 +zBmv3Xrsnr/bxcmSAAAAYd/ki8qT0hGqDQDgmAMrjAgAAAAAAAAAYgAAAAAAAABC +AG8AbwB0ADAAMAAwADEAAQAAADAARQBGAEkAIABJAG4AdABlAHIAbgBhAGwAIABT +AGgAZQBsAGwAAAABAxgACwAAAIAAAFUAAAAAfwCFVgAAAAAEBhQAg6UEfD6eHE+t +ZeBSaNC00X//BABSQ4mBoEQEAAAABwAAgAMAAAAEAM0P20UxpuxBvidTugQmN9bl +9/JWCwA9Z3K0+E7UdZXXKixMX/0V9btyx1B/4m8qruLGnVYzuhIADEWlw8ME1z8a +nXPU/gMZDPGGHom6W5WHUqulHG+1/FooAAAAQ2FsbGluZyBFRkkgQXBwbGljYXRp +b24gZnJvbSBCb290IE9wdGlvbgAAAAAEAAAAAwAAAAQAkGnKeOdFCihRc0MbPlLF +wlKZ5HMLAN8/YZgEqS/bQFcZLcQ910jqd4rcUrxJjOgFJMAUuBEZEgCvzIcPogxQ +eZVJl5Q3Howl46cxD6ciAMEJN5lzriNoRQQAAAAAAAAAAQAAAAQAAAADAAAABACQ +acp450UKKFFzQxs+UsXCUpnkcwsA3z9hmASpL9tAVxktxD3XSOp3itxSvEmM6AUk +wBS4ERkSAK/Mhw+iDFB5lUmXlDcejCXjpzEPpyIAwQk3mXOuI2hFBAAAAAAAAAAC +AAAABAAAAAMAAAAEAJBpynjnRQooUXNDGz5SxcJSmeRzCwDfP2GYBKkv20BXGS3E +PddI6neK3FK8SYzoBSTAFLgRGRIAr8yHD6IMUHmVSZeUNx6MJeOnMQ+nIgDBCTeZ +c64jaEUEAAAAAAAAAAMAAAAEAAAAAwAAAAQAkGnKeOdFCihRc0MbPlLFwlKZ5HML +AN8/YZgEqS/bQFcZLcQ910jqd4rcUrxJjOgFJMAUuBEZEgCvzIcPogxQeZVJl5Q3 +Howl46cxD6ciAMEJN5lzriNoRQQAAAAAAAAABAAAAAQAAAADAAAABACQacp450UK +KFFzQxs+UsXCUpnkcwsA3z9hmASpL9tAVxktxD3XSOp3itxSvEmM6AUkwBS4ERkS +AK/Mhw+iDFB5lUmXlDcejCXjpzEPpyIAwQk3mXOuI2hFBAAAAAAAAAAFAAAABAAA +AAMAAAAEAJBpynjnRQooUXNDGz5SxcJSmeRzCwDfP2GYBKkv20BXGS3EPddI6neK +3FK8SYzoBSTAFLgRGRIAr8yHD6IMUHmVSZeUNx6MJeOnMQ+nIgDBCTeZc64jaEUE +AAAAAAAAAAYAAAAEAAAAAwAAAAQAkGnKeOdFCihRc0MbPlLFwlKZ5HMLAN8/YZgE +qS/bQFcZLcQ910jqd4rcUrxJjOgFJMAUuBEZEgCvzIcPogxQeZVJl5Q3Howl46cx +D6ciAMEJN5lzriNoRQQAAAAAAAAABQAAAAYAAIADAAAABACz8WP/eW8/rw7v4PWs +mFhMmIHJHQsAhQgDGd8yTtXGmoT89b8LljT++4IW2w8pSe13Uee6RNISAPmJ/HNJ +Lox7wOePKnJkAwBvyUmaYl0EE6m4bj53sN60ZAMAAEVGSSBQQVJUAAABAFwAAABL +G/dJAAAAAAEAAAAAAAAAr4jg6AAAAAAiAAAAAAAAAI6I4OgAAAAA+tOm7qDeFEST +poeFSXoHYgIAAAAAAAAAgAAAAIAAAADjlRFDBgAAAAAAAAAocyrBH/jSEbpLAKDJ +Psk7Yn3hhjqAnU+e5fXfuzu8VgAIAAAAAAAA/wcQAAAAAAAAAAAAAAAAAEUARgBJ +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAK89xg+DhHJHjnk9adhHfeQ8+a1ZyQdhQrCDDyGs +nDrqAAgQAAAAAAD/BzAAAAAAAAAAAAAAAAAAYgBvAG8AdAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAArz3GD4OEckeOeT1p2Ed95G6I4DcWFKpFmBMNbAcKpvYACDAAAAAAAP8HsAwA +AAAAAAAAAAAAAABTAFkAUwBSAE8ATwBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvPcYPg4RyR455PWnY +R33kHaafXb/4aUuHSZ6CFpcsnQAIsAwAAAAA/wcwGQAAAAAAAAAAAAAAAGIAYQBj +AGsAdQBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAK89xg+DhHJHjnk9adhHfeRk23vasVFTRbxF5pnK +d9+xAAgwGQAAAAD/P4nmAAAAAAAAAAAAAAAAZABhAHQAYQAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAbf1XBqukxEOE5QkzyEtPT0EZA0OxfOFAuDQmGDaIRdkAQInmAAAAAP+H4OgA +AAAAAAAAAAAAAABzAHcAYQBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAwAAgAMAAAAE +AFj98uw2SVjehVzhHhCj3Zxgv/BYCwAlJZ7JtV6qQtjuMM4bqPtZp81lL9kYc7GE +zCa1O6Pj5RIAB7nLBan42zpTmeFOQgXQ59ElgexWhf9AhFAQ7T5H1JqgAAAAGFCc +XQAAAAAAMAIAAAAAAAAAAAAAAAAAgAAAAAAAAAACAQwA0EEDCgAAAAABAQYAAQgB +AQYAAgADEgoABwAAAAAABAEqAAEAAAAACAAAAAAAAAAAEAAAAAAAYn3hhjqAnU+e +5fXfuzu8VgICBAQwAFwARQBGAEkAXABCAE8ATwBUAFwAQgBPAE8AVABYADYANAAu +AEUARgBJAAAAf/8EAAkAAAANAAAAAwAAAAQAihFT0xYNO9BaMjsx3aPQ2YHuHYkL +ADb92QwSzP/2aAe8NLu6UrrqAOZuLYQeCITd+f0+Av/LEgC2Fpovi+yYGxCW0prK +ohkwgm50jOpyGcc7ZYx1qiiCxSsAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi94ODZf +NjQtZWZpL25vcm1hbC5tb2QACQAAAA0AAAADAAAABADrURRyX+EuADKYY9l0isgP +kSZGugsAq2GMWv6qM9qk81EMF1G5uUs9tmwp/raRP3J3NRaIxHkSADtMTqFqK6dM +5ZqCGwXvFtPiVq3h0FYC+UlvQwimhDXpKwAAAChoZDAsZ3B0MSkvYm9vdC9ncnVi +L3g4Nl82NC1lZmkvZXh0Y21kLm1vZAAJAAAADQAAAAMAAAAEAIRV7YpT0Zeqm9j6 +juzCGf1PBQ4tCwApDgQpJ7QE3ZMNpe0oJ94Me9q428Rv/vEOKFgCzCFVnhIAHSU8 +gtArVpCS4N/jdjxOKmrsVBaAnwPgJS4MPIOnBtQrAAAAKGhkMCxncHQxKS9ib290 +L2dydWIveDg2XzY0LWVmaS9jcnlwdG8ubW9kAAkAAAANAAAAAwAAAAQAhHLPvivc +wNKv0S82nS0iP0sR/n4LAHbd7MyXm1TvkHCVq7Sb0X8gW6IOCp4g83hSDGMaPNcm +EgCDlccYHDHU8yyJOVfdCAZ/fF1couzjrZj3OgsBKHX5IikAAAAoaGQwLGdwdDEp +L2Jvb3QvZ3J1Yi94ODZfNjQtZWZpL2Jvb3QubW9kAAkAAAANAAAAAwAAAAQA3HEe +D2yXzckQ6noWeV3S4cGWD5MLANkD5ZZmovSN3bG4C4Kfa4qxsNTF3kipHKcPd5+C +SqSaEgACW3H92N8TrH81L3DKwHyfXBBAhKMn1pdcRvuglfK3uyoAAAAoaGQwLGdw +dDEpL2Jvb3QvZ3J1Yi94ODZfNjQtZWZpL2J1ZmlvLm1vZAAJAAAADQAAAAMAAAAE +ALuwrhcErOZ6XXvKPkjNK6pFdLIHCwDLwLi3VzvETQeocy6TTqJoEDRbaPPpZVAs +1k2SaxqJHBIA0FB5PFG1AaERWHYhX+RzUlOhmYIwoWMOptQat9V835UsAAAAKGhk +MCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS9nZXR0ZXh0Lm1vZAAJAAAADQAA +AAMAAAAEAM6MxNIAwwkolDUTrF+5xwcaF0FMCwBErhs+GwY2ATZVqea6xdMd4N6B +F5EbcZR9unf6Qe7IhhIAgbMv7vo/KlNdYMSDgjd2pUwkHz48LtlIicwGPSLlbskt +AAAAKGhkMCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS90ZXJtaW5hbC5tb2QA +CQAAAA0AAAADAAAABAAJFlyl200kh2Jfy7ZedLmK/6L3TgsArZ9CsrMS9B0Mf0ob +z4YMXTXlI2PBuAVTMnfWksMaoLUSAGQwchYvEq/JSaoKh4D9VsOiu5Di60QtS5eh +nNqZy3THKQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvZ3ppby5t +b2QACQAAAA0AAAADAAAABABVzEm/bHrFcpt1JZUxKtNyDJ5OpwsAKxqTAI3nhlCN +umSjo+JcXgAadQELSTjY3mE2efxc9wASAAaYT4oFeLTzM6YF/ThO29QZPlunrvgV +KcGXIyeJFJsjLQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvZ2Ny +eV9jcmMubW9kAAkAAAANAAAAAwAAAAQAf36FkJ+zfRUPV4IsCtO2NueFOv8LAFE3 +JXzc7BQLzn4Mg8EADfP37PGN4RveRrjTL0m6ZXeREgBtCZdkct52Ic+JH9dwbjzH +JFWEIYPheKN2EA+8W7hzzCwAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi94ODZfNjQt +ZWZpL2NvbW1hbmQubHN0AAkAAAANAAAAAwAAAAQA8JFlXHrHMU6w3yGTFBXeR2KN +Yh8LADL8f13owKXcCx5+tgnKMad+s0dVOeHZekVD3KG5smxXEgB7wzykn90I3FHJ +nwdma3DuKB3oQ1gAvKMtg875pZY3picAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi94 +ODZfNjQtZWZpL2ZzLmxzdAAJAAAADQAAAAMAAAAEAP8A0oEUOYzxoFIylJTWOs7r +j/KaCwAbdm84qUkn/pt7wegJ8DY+d44UxgHoAPrqJxouddP8QxIAH4xoVH7kzcLm +/HYsZ/6UZf/yslHR00xNCBKx/jue644rAAAAKGhkMCxncHQxKS9ib290L2dydWIv +eDg2XzY0LWVmaS9jcnlwdG8ubHN0AAkAAAANAAAAAwAAAAQAZrcmxtZLwQnTlIqV +KPUC6pSTjvQLAEb4iMUvNrr5ti1gvI0GQmoxSq1aD/hqQ2KpHCUSod+cEgDany7c +2H89Xd8FzR+PjfMhcSWdp5B7bjUsuYCOLoBMhy0AAAAoaGQwLGdwdDEpL2Jvb3Qv +Z3J1Yi94ODZfNjQtZWZpL3Rlcm1pbmFsLmxzdAAJAAAADQAAAAMAAAAEAC0vDCLi +yRh8yohtaKx2jbMrUlygCwD19HF1sbxPcGrZTOkoi7AxFu7rwPhLwNCmTaKelmuG +DRIAxYa5eBVy7TBHkGQDVuyVyQ80mJANKLaBZMYpG/vLq1ceAAAAKGhkMCxncHQx +KS9ib290L2dydWIvZ3J1Yi5jZmcACAAAAA0AAAADAAAABACtqxiREAsKfrRj0QGz +A4bDYLdc/wsA9d9pRjdL/XmiFiKvlD1+dqQ/UpnXBDP0WKuDVxw0S4YSADM7Stgf +EhtZalSnnAMQyoQ1XkZA15I20+l+YtQGUOdpHwAAAGdydWJfY21kOiBzZXQgaXNf +cHJlbG9hZD1mYWxzZQAIAAAADQAAAAMAAAAEAD5c1+oP3C4rL5VtQfkJDuNzL7gz +CwB+KzSTuqP55MaoNigtHma1hVaSFp3uRNRv4g0R28FzgRIAwLTjSnvaBVOvNHfL +1EDDIRY1B/9+zjJZALs8a/VPdm0uAAAAZ3J1Yl9jbWQ6IFsgLXMgKGhkMCxncHQx +KS9ib290L2dydWIvZ3J1YmVudiBdAAkAAAANAAAAAwAAAAQAWfg4e8ElXH2mxyDi +jWKONnJTAG8LAIJP99JllpUsIuyJwNigpMLm7Z+0Vur3KVueRSnbKsVOEgCrtc4I +RDfQBZkOWU7d9Scv8TTM8ZWHHwnkOTQ9KEKqlykAAAAoaGQwLGdwdDEpL2Jvb3Qv +Z3J1Yi94ODZfNjQtZWZpL3Rlc3QubW9kAAkAAAANAAAAAwAAAAQAsn6+VYWPMZeb +ZFpCRLVebvrbTa4LAC5CNMhR3fJRsP/JNe4duWt779Ty34aaVhLigt4Ewj/AEgCi +vVVZREbLFbiqPMCM8LcYuzSBonWuhDfA3DQqixeoIR0AAAAoaGQwLGdwdDEpL2Jv +b3QvZ3J1Yi9ncnViZW52AAgAAAANAAAAAwAAAAQAPE6bEZjswWCv9gIsD5a1si+r +FGkLAA46F+DEjkLXn00Vduf3h8kRI5UQWGUFwyYUO5smi91lEgA/pL5s/kciL06t +aEYuXiyUXE5bTTzsuMd4GhC7yU4fqCAAAABncnViX2NtZDogc2V0IGhhdmVfZ3J1 +YmVudj10cnVlAAgAAAANAAAAAwAAAAQART3ubOgr2A6om9gIVySul4T/DxsLAPi5 +n3eYOZDogEhkyt6R82G1tmAMwoMv6674eKyLRNJ+EgAe1QS803FDdLH1lB/JPtgG +WwZVEcL231bcPkbHYz3TiBMAAABncnViX2NtZDogbG9hZF9lbnYACQAAAA0AAAAD +AAAABACg4o3wyYqQTPm1stESlkF+SwHH4wsAgqAtB4b/rQMCCuu6Yanytfueeibm +2uOPxzYMV4clKz4SABWbLr8ziV5Zwk2wQ5/dM0RDVhUcUlbQJJ0jvWUZdYglLAAA +AChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvbG9hZGVudi5tb2QACQAA +AA0AAAADAAAABAD4zqYYHucVHf9oJwb6nTa85ny/zgsA7kFxqLsQ5IUADu+HU3/H +208K8z8Kq/AAObg9SokCgP8SAOTgE+vGHFhFIGOHlOyRvSIEsGFLkQvD2YH6buHN +qi0cKQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvZGlzay5tb2QA +CQAAAA0AAAADAAAABACyfr5VhY8xl5tkWkJEtV5u+ttNrgsALkI0yFHd8lGw/8k1 +7h25a3vv1PLfhppWEuKC3gTCP8ASAKK9VVlERssVuKo8wIzwtxi7NIGida6EN8Dc +NCqLF6ghHQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL2dydWJlbnYACAAAAA0AAAAD +AAAABAC06ZtA0t3c32joqkOeGN1eusv/yQsA0rkpg+Zq/5mYL+WvVeD5J33A+IeZ +NOF7ABR+H0FWF54SAL+dqBXVCKKonwxBGEpWat3D7IjIPuEJjnSDLg4sQdUhEwAA +AGdydWJfY21kOiBbICA9IDIgXQAIAAAADQAAAAMAAAAEAAW6RSvwC3+IBSizXQLp +B3+JwIU4CwCCpKFOQ6T3YRiuYyhdCvBa8TnyYPrleywgc3ocHfM4KxIA+G23hSZd +akog8u5+vU01f+CkMillEvsIrotKCuM5NloTAAAAZ3J1Yl9jbWQ6IFsgID0gMSBd +AAgAAAANAAAAAwAAAAQAcQy/I3yavQccqRxBBDJIAL7HsPsLAM6BJLwbD7wMtc1H +M4ygx9X1RG15k25EOiAdlrGSp71lEgDK2xBbkVNsfgW4E+0nfEw0jD1FN6PAQdUp +tbA/FqQuQw8AAABncnViX2NtZDogWyAgXQAIAAAADQAAAAMAAAAEAGz7qTy2scB7 +oWvaYz+hh/fWM2l3CwBztL6/cui2aJmzqqm6WiUy3ExRBHch/EdVdUZwIEfbwBIA +pllm9O+kfTjq9cVDciqzMic0ov8bhSCKu/l+3Ciqo+JOAAAAZ3J1Yl9jbWQ6IHNl +dCBkZWZhdWx0PUt5bGluIFYxMCBTUDEg55qE6auY57qn6YCJ6aG5Pkt5bGluIFYx +MCBTUDEsIDUuNC4xOC1jc3YACAAAAA0AAAADAAAABAD1sGflnBY/Z7Gbg2++6eik +h6Gc3QsARWg2H7dYGzGkLWRatTQwL7n3Qq2qN7f94VIhXWniWfsSAEmtoKcNc70p +b/eMg4fJhPQ8A60wk8UkGXb3bmQZ/XlcFgAAAGdydWJfY21kOiBbIHh5ID0geHkg +XQAIAAAADQAAAAMAAAAEAL1SCeUMCWUP/PXC0SqL6Cd+Q4AjCwAJ8X1N+0uX8WJG +YywhsawhJclcFIiZ7uUGn7sbNDZVExIA+yKUBkKzQpYIpI+Z643YoP9S17DVmnaN +Y76oHCjeBH4jAAAAZ3J1Yl9jbWQ6IG1lbnVlbnRyeV9pZF9vcHRpb249LS1pZAAI +AAAADQAAAAMAAAAEAGJIWZuuDXjMvaGF7S/OAYLtQeKXCwBK8Ls3DJ47eYICfQLg +TJNeMtUrUoAHR2v8UNNtG4aBXhIAC+SqF8vcwfxXAh8R1bzDAmeJIHMiCsL8gjmB +nbRYKP4lAAAAZ3J1Yl9jbWQ6IGV4cG9ydCBtZW51ZW50cnlfaWRfb3B0aW9uAAgA +AAANAAAAAwAAAAQAcQy/I3yavQccqRxBBDJIAL7HsPsLAM6BJLwbD7wMtc1HM4yg +x9X1RG15k25EOiAdlrGSp71lEgDK2xBbkVNsfgW4E+0nfEw0jD1FN6PAQdUptbA/ +FqQuQw8AAABncnViX2NtZDogWyAgXQAIAAAADQAAAAMAAAAEAPWwZ+WcFj9nsZuD +b77p6KSHoZzdCwBFaDYft1gbMaQtZFq1NDAvufdCrao3t/3hUiFdaeJZ+xIASa2g +pw1zvSlv94yDh8mE9DwDrTCTxSQZdvduZBn9eVwWAAAAZ3J1Yl9jbWQ6IFsgeHkg +PSB4eSBdAAgAAAANAAAAAwAAAAQAdpbn7Ai6LCSBc4uMNuF4Oojui5cLALc7+Dqj +5fAFDvl+6IDQ/THk9ixBgH5KUQRLoqs5tzO6EgAtRf+ip9uUDXihxLlZMq042LX+ +dtFuEzOhKMXm9QEzhBcAAABncnViX2NtZDogZm9udD11bmljb2RlAAgAAAANAAAA +AwAAAAQA/iavRzwMoDJnbdOKq5CZiI/VxKQLAPv5heqaan49vfNLXu7GoU1p3pRg +qQydiEuabTj8rIR9EgDxR0xCX7ujUiWRIR+3fz9kqvBsjm8rzYjnXQQxq2s99RsA +AABncnViX2NtZDogbG9hZGZvbnQgdW5pY29kZQAJAAAADQAAAAMAAAAEAORMl3W1 +KGCMw0w8Bndj8ABBRVFDCwC+5tRr6XUGzbjAdbVYyxxC+JNxGUbPy/cnoaGvvJCY +nRIAf1fXy8kMzr5eF36HS/g/FjoJ6exI2GS1s6v8egEBUUspAAAAKGhkMCxncHQx +KS9ib290L2dydWIveDg2XzY0LWVmaS9mb250Lm1vZAAJAAAADQAAAAMAAAAEAKuU +HrUonPjhEzFDUxuLZ+Fc113iCwAbIcNzzZs3VNkF7XxJY+Ti6u+zV1QGHptAI8O/ +6J0p4BIAo1a8qqoH1m0E4PvTF8/+OmIjLwOZEXfgNnLilfMbkxEqAAAAKGhkMCxn +cHQxKS9ib290L2dydWIveDg2XzY0LWVmaS92aWRlby5tb2QACQAAAA0AAAADAAAA +BACXcQvk0t5HImMLRMB7wUDYLVDMbQsAZosxVynDmtXwoLWfhwtgd3bt60JUgbcK +HeAbChnBLi0SAMzIlyEtz0nf0JqcXl1Cy6itSZQ4hCiRlNjuO4NBJam3JwAAACho +ZDAsZ3B0MSkvYm9vdC9ncnViL2ZvbnRzL3VuaWNvZGUucGYyAAgAAAANAAAAAwAA +AAQAq0WVYbyeWYJDLAmw5q9VvpZJ//cLAA5n4/jUbbQUSGYNLQco+k9g3yMe6cO1 +VLMdoLW3NgBrEgCoMSc1X9Oe6VMUxgn70Y8hKFb0Wp7LZyD6iA2JR6v0nhsAAABn +cnViX2NtZDogc2V0IGdmeG1vZGU9YXV0bwAIAAAADQAAAAMAAAAEAI/lnmbW7BmE +IEd/JPeR6SnxU+FECwB2JqvYvnRCwuV1Nko+lcs6O1M8WK+7pALSvavf+F0pxxIA +B5ELepGxQoM6gCvMrKe3JYNfwAbSKUdBOu4FWZ81cxYVAAAAZ3J1Yl9jbWQ6IGxv +YWRfdmlkZW8ACAAAAA0AAAADAAAABAD1sGflnBY/Z7Gbg2++6eikh6Gc3QsARWg2 +H7dYGzGkLWRatTQwL7n3Qq2qN7f94VIhXWniWfsSAEmtoKcNc70pb/eMg4fJhPQ8 +A60wk8UkGXb3bmQZ/XlcFgAAAGdydWJfY21kOiBbIHh5ID0geHkgXQAIAAAADQAA +AAMAAAAEAFnO00OwYLffVPp7olHvh3lAYB7kCwDXE1P1No6ywSgFkJKBKJeb2W6o +2x6MgUk/eHg4O3arOxIA8K4p/w0Yph5Ix3O/CPWVoD379Upw7zfM1MfsuA7zZacb +AAAAZ3J1Yl9jbWQ6IGluc21vZCBhbGxfdmlkZW8ACQAAAA0AAAADAAAABADAflkD +G2Nk8/oNdLiaKFXEEt874gsAFBUUArI4Jj7ZA2NsQJaa7OvNhZrrIOPMr2avvcQA +JbwSAMQOjYjFt9tvx4Jzkesz65THPvZ7sbvzkNlfpt682ls5LgAAAChoZDAsZ3B0 +MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvYWxsX3ZpZGVvLm1vZAAJAAAADQAAAAMA +AAAEABd2YAnGXRouySwi0KjNzBqORU0hCwAEyx67yPq4VPj0/O35XXJ5cMegNu+T +6kmy/BeOi+zJYhIA2zxLpc5Xm/vevy10vH9+qZ9t8lDpT+ysQWNObbR3yNUsAAAA +KGhkMCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS9lZmlfZ29wLm1vZAAJAAAA +DQAAAAMAAAAEAHwfz2wZ9FM6c3dtJn5kOOK5ewURCwDC+xoa3ahDLgSHwiOLf4jV +Qz8vQs3RhaQfc59fckGuwBIAHcR/8ygH9SSn6Go/LmNFO8WCekwkrgvR6cfk+Lgf +qsYtAAAAKGhkMCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS92aWRlb19mYi5t +b2QACQAAAA0AAAADAAAABAC1OIpqldWD+PAQRyeo9HtptOxnAgsALCcG3tEKCPPF +leWfGSzLeYYeNirtEZ2iKiVTr5qZbBkSANItLrlOfXhe7wpX97ZCzMom5eH4fqPP +WjCRKXI8Q6ZDLAAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvZWZp +X3VnYS5tb2QACQAAAA0AAAADAAAABADtxHMQBzWKYzmDwFkaxHIs6VSa0wsAF646 +MQj+MhdM6LoZO3hcHf2u8rnEYHIHE0jACQctDZASACy/XZ1zjjpV4nomhAe+hJBC +RWeOzxd7M0GUhRAUbEcNMAAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1l +ZmkvdmlkZW9fYm9jaHMubW9kAAkAAAANAAAAAwAAAAQALJyeOpPKpAopoS1z1b08 +AgdVpToLALMfiyw+Se2QAJkUBkOFr1X3aR9Vrr9vrTlNr+T3eR7UEgDe8y1othR0 +iYpmmkWu7twnwxECizdF+/M5p0bdSYaX1jEAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1 +Yi94ODZfNjQtZWZpL3ZpZGVvX2NpcnJ1cy5tb2QACAAAAA0AAAADAAAABADDf+TO +SpaqzDt+yTOgMD3fHPLOzAsAglhZKbzB9TG4PtsHegmFVljyCYzdkMhty1BscaMX +G04SABnwjQ4+RDkus8p7Fq/YOYKs4nNfTjuj0/QZ65ipG/BDGQAAAGdydWJfY21k +OiBpbnNtb2QgZ2Z4dGVybQAJAAAADQAAAAMAAAAEAE2dMjV8bRuARr9F/eFyvJwm +S6W8CwDDUBbgALp6icj+CGmMNTLWafSVxE47Saw6lNDDKp+fwxIAQGqo5FfHtjsA +8mL6ffgAZZVkY5xrk2kQrDuNsuCE9jMsAAAAKGhkMCxncHQxKS9ib290L2dydWIv +eDg2XzY0LWVmaS9nZnh0ZXJtLm1vZAAIAAAADQAAAAMAAAAEAL1wlfc0orwDVbOB +QSWLY+OuI0N3CwD+8rnXFuI5sLjCR4+2wI/sR7qXOPeaNyoe/z62jPxWoRIAyDnt +n9qJJ7k2PAXO6n9igHZPEDPdGoBlyEOB6Y21+DM1AAAAZ3J1Yl9jbWQ6IHNldCBs +b2NhbGVfZGlyPShoZDAsZ3B0MSkvYm9vdC9ncnViL2xvY2FsZQAIAAAADQAAAAMA +AAAEADDzB333M68fyHmjwLpRrSNiWBHSCwCsqdzuP9FM+6Vd5CxtNNE0C/n4J+I4 +1GpMFyB28PkwZBIAgWjo7Z+B0CmRRKTJAoR9Vw6mvrayZuK32DQ4c8oxX+cZAAAA +Z3J1Yl9jbWQ6IHNldCBsYW5nPXpoX0NOAAkAAAANAAAAAwAAAAQAQNEeBaLnpRGG +OvX00qG/aQSel1ILAKiVb9u6UuebuWJYH2SAZMpUWLbUh7KbajkWDnDFcLL0EgCl +V4fmARi2Xqmvqi26sPPMotMhERE3cjeaqMLQAXT21iUAAAAoaGQwLGdwdDEpL2Jv +b3QvZ3J1Yi9sb2NhbGUvemhfQ04ubW8ACAAAAA0AAAADAAAABADU0VTqdjzwvsyj +mOMtwOiE5tU1XAsArHL19iPUcqMfcBUrKtyzEOC4wXKX/yUpCJujojcUqy8SAJbJ +ei5yjbqEt0Q09Y2irOeUf/3nZn0ybuOCEAV6ya1jGQAAAGdydWJfY21kOiBpbnNt +b2QgZ2V0dGV4dAAIAAAADQAAAAMAAAAEADgcUmeAI0Nif2Npc26OEv03yIWjCwA/ +PcigRA5DayaJTvvEBS90viLAmOwEQUWgWHBdndAsGxIAaI8pTPW1TqkcDJk7TUzq +gqwrsUVy+nJ7msalihU5yd0iAAAAZ3J1Yl9jbWQ6IHRlcm1pbmFsX291dHB1dCBn +Znh0ZXJtAAgAAAANAAAAAwAAAAQABbpFK/ALf4gFKLNdAukHf4nAhTgLAIKkoU5D +pPdhGK5jKF0K8FrxOfJg+uV7LCBzehwd8zgrEgD4bbeFJl1qSiDy7n69TTV/4KQy +KWUS+wiui0oK4zk2WhMAAABncnViX2NtZDogWyAgPSAxIF0ACAAAAA0AAAADAAAA +BAD1sGflnBY/Z7Gbg2++6eikh6Gc3QsARWg2H7dYGzGkLWRatTQwL7n3Qq2qN7f9 +4VIhXWniWfsSAEmtoKcNc70pb/eMg4fJhPQ8A60wk8UkGXb3bmQZ/XlcFgAAAGdy +dWJfY21kOiBbIHh5ID0geHkgXQAIAAAADQAAAAMAAAAEAMUSCSsEgSNMqkFu98GW +q06SuOACCwAcVoOYzy5KnfWIdbvXnf/gWOxFvgt0US+pGaL+fbSmCRIAAEnjfMNq +w7GVLZXvqmAc1V0/3DxeZfRFwNAwKQvPqXAhAAAAZ3J1Yl9jbWQ6IHNldCB0aW1l +b3V0X3N0eWxlPW1lbnUACAAAAA0AAAADAAAABABzLHE6b0w6OI7htGYkt8P+NNWd +UAsAcaWzshrDhi9A+rt0WpZJw6HTQkm5cGUkyQskgMKYvrASADU5Id83sx1BJRi5 +WsPCC6j7oIduN7FhSlCMJCCdhFOAGAAAAGdydWJfY21kOiBzZXQgdGltZW91dD01 +AAgAAAANAAAAAwAAAAQARWnhtm2WlAlOKcPDv//iEpCIOjwLAB3HS05I/fNap/W7 +l69ZWmpNprBif+jU82RgDtR5MB+HEgDL2ydmoGmhWtmPSTUjXYr1iO7cNTL1yE7g +l/ytw8CgYSoAAABncnViX2NtZDogc2V0IG1lbnVfY29sb3Jfbm9ybWFsPWN5YW4v +Ymx1ZQAIAAAADQAAAAMAAAAEAEssGYSzPXGYGB/adFJlODOy+CacCwCo3vwn11Ga +RzLCg7QH5zb9k2brsKyI1xYdbZGMwNNNTBIA17cRx8QmdqEEGsTcnkyeabFyY9P5 +rlkfLr9wWSZsUlMuAAAAZ3J1Yl9jbWQ6IHNldCBtZW51X2NvbG9yX2hpZ2hsaWdo +dD13aGl0ZS9ibHVlAAgAAAANAAAAAwAAAAQApOHG9QV5tHyWQRHR6iFw5vkjyUEL +AGLNdtMco9ENdC5Gxv8XEEbOGd2Q82GoJ/7GVx5ZwkeUEgCQj2JiFB82Zdf73hlV +4Fe2+ZM3za17+s9vdYU9rx2PpBoAAABncnViX2NtZDogaW5zbW9kIHBhcnRfZ3B0 +AAgAAAANAAAAAwAAAAQArz8Hq6yeXFa4LwmrmDKJBaq79u8LALg4pNKGDIEFgQX7 +sZB6H7f2C2VZGwmbOwANmzHY0vsgEgCIG7misbEg9fcfHP3ZYd08L2Vr8OAvcDJy +sP/wLkovMhYAAABncnViX2NtZDogaW5zbW9kIGV4dDIACQAAAA0AAAADAAAABADb +rrsY0z1zLWm8n67wneXdWYT6awsA8j2ng1Yjwg/zvbJGPmBuYkk9WsNLW0Jj2P6C +ZQpuvF8SAM7NB3o0UVU/5ZLpBJUWuw2bg6GAyluIket4heb9/FBbKQAAAChoZDAs +Z3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvZXh0Mi5tb2QACAAAAA0AAAADAAAA +BADfamdAgKAhvedC8g3+pLJozZgVUgsAbeEtJhuxX/bI6VzhWw0hlkicSxOELr5Y +IRuo8/JNkB8SAKYuuWmHW99wAl0NK4Hx2gafDG1voliyc0wvjc8a9i7dHAAAAGdy +dWJfY21kOiBzZXQgcm9vdD1oZDAsZ3B0MwAIAAAADQAAAAMAAAAEAPWwZ+WcFj9n +sZuDb77p6KSHoZzdCwBFaDYft1gbMaQtZFq1NDAvufdCrao3t/3hUiFdaeJZ+xIA +Sa2gpw1zvSlv94yDh8mE9DwDrTCTxSQZdvduZBn9eVwWAAAAZ3J1Yl9jbWQ6IFsg +eHkgPSB4eSBdAAgAAAANAAAAAwAAAAQATMP7kmm/EUVBv7QSd/T33+LJSQgLABuL +vvzDeIcozoQ/m3FzNpJWMi0ikYeNTjy+p12RnZxgEgCIPVwwnDX2fvVP6WWVYRfR +mdlZfMvhA94+ZWRVZGLdeZwAAABncnViX2NtZDogc2VhcmNoIC0tbm8tZmxvcHB5 +IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhkMCxncHQzIC0taGlu +dC1lZmk9aGQwLGdwdDMgLS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQzIDY2ODlj +ZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYQAJAAAADQAAAAMAAAAEAKiR +G5udjT9Sbol5iSD5zsajp7GuCwDGJte2i1luFtEk6PRs+5ZAy1a39f1G1UenN2+6 +PjYXUhIAdr31+T+53Xq3B+T3lidzoE19eqx3IjKx7+8x7r5SLB8rAAAAKGhkMCxn +cHQxKS9ib290L2dydWIveDg2XzY0LWVmaS9zZWFyY2gubW9kAAkAAAANAAAAAwAA +AAQAGQnBVCcHd2wHH7dO401jsgXHXzELAFjY88ApoovEDVFFZsrYH+OBOg57ruyq +pEkJQwDn0XP1EgB2PovmyxcmMIaY4CN1ZL3x0Db7VgXzKGACUr/YBvLWqDMAAAAo +aGQwLGdwdDEpL2Jvb3QvZ3J1Yi94ODZfNjQtZWZpL3NlYXJjaF9mc191dWlkLm1v +ZAAJAAAADQAAAAMAAAAEADZa7PWHq+vcWH6fkpRzZGrFckv1CwBoT2+Sc9y3hIwO +u718cZzYSowZ1OBvc5IJVUGpjMeyMhIALRgq32ePDD+Aa6bTE93cxCozz731YVZ8 +kq7muQnz9MMzAAAAKGhkMCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS9zZWFy +Y2hfZnNfZmlsZS5tb2QACQAAAA0AAAADAAAABABcdSIFtA5Ea6Zpwi3TE0wF5J9I ++wsARXH6UTiGl+GLFj7QnvlszlWjJsHnqm2qDcaTuvMaorQSAFlYN8hTGAFB3q3r +3adRCJEiLxL10ZEG8ELM+xazSQ+BMQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4 +Nl82NC1lZmkvc2VhcmNoX2xhYmVsLm1vZAAIAAAADQAAAAMAAAAEADlomZC6TdSO +K00X0hP2gzhJuDk/CwDVNY5GJbEF7TQksXcmhJZYkYcvSCP6CjfWj6ubanyfjBIA +xOXvTNXyuIYPZFhSKeDqtAhCVMoMjWlhsXjBhFFoVdkZAAAAZ3J1Yl9jbWQ6IGlu +c21vZCBnZnhtZW51AAkAAAANAAAAAwAAAAQAI8mh/qMXg1BcdOk2du+hRrmazCwL +ADiSuWemz1TpMSuXFvj8Ff/0Qlz4YNmAgli238KsyGo4EgCqiZ6FgULdwKuHos5N +UZBN994491kJrptMqVzMt1kCcCwAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi94ODZf +NjQtZWZpL2dmeG1lbnUubW9kAAkAAAANAAAAAwAAAAQAp7P8PkOY+IIVMxrdt0Ug +j8T+xJcLAFYvo+JetRkJFMgZtIvQKqxEqrW/kRgoh2cMw8RyVcnMEgBb/rIlbgrY +o8tbY1sDw7NBqwG6Q1kcSnbtU2zcL3+mASsAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1 +Yi94ODZfNjQtZWZpL2JpdG1hcC5tb2QACQAAAA0AAAADAAAABABFcTnAoIUyM9en +QaB8orW2ao0aQQsA4bMgth022D9TRrLE6zNvgljfOqCYuRlc9asx+oy6UXQSAJZR +WVxzTwtOusha6dXtnANUGSpS4/Ma2ix56VD/kgS+MQAAAChoZDAsZ3B0MSkvYm9v +dC9ncnViL3g4Nl82NC1lZmkvdmlkZW9fY29sb3JzLm1vZAAJAAAADQAAAAMAAAAE +ADpJVozKuVlyGMwnsoCdOgyiNEx7CwDiyVJezM8rmLu+V8nMI51oBo6fcNOaVtM/ +ktE5B9BeWxIA64wkU4p/Rd/soCHAIV07HHYpe86g/FRbe/bn65fprqcxAAAAKGhk +MCxncHQxKS9ib290L2dydWIveDg2XzY0LWVmaS9iaXRtYXBfc2NhbGUubW9kAAkA +AAANAAAAAwAAAAQAY3GrDBD73J+LagQXhdca+bH99rMLAATHxyK/ETQ/6/CXbIh7 +ycO948u0FBXPCplpHyiAoGFWEgDy6bStfIXnTHIhj8cC4MDG1UbqHT+UhBchtvt3 +ySZzgCkAAAAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi94ODZfNjQtZWZpL3RyaWcubW9k +AAgAAAANAAAAAwAAAAQAIN07Bwx4u5LCWgTWl0oChNmV2SQLAGX9g9S0CWDM7Hi5 +DejYE37RAUOtT5CpujvdlbFcCea4EgAZ8MAmluPnC16vm8Q30SG2jdeIb+Vzrd1/ +9rQfK3YIeE0AAABncnViX2NtZDogbG9hZGZvbnQgKGhkMCxncHQzKS91c3Ivc2hh +cmUvZ3J1Yi90aGVtZXMvVUtVSS91bmlmb250LWJvbGQtMTYucGYyAAkAAAANAAAA +AwAAAAQAPEKvzgyWH/Gd8TIjpUbA3Nod6/ILAMgt9Lz95OaZsK9wBY6kKpdF7cUV +LNS6lV/jcwDx8HmoEgBSfO5bQwBG+XE07bxcxyDodvvvQgUoIgFhV2jISd6D5DoA +AAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3VuaWZvbnQt +Ym9sZC0xNi5wZjIACAAAAA0AAAADAAAABAAX1UJxEJ5TrFxwyH7bqJMdssgQpQsA +lBvz9OqzEKsZdreX8EDhBnM5uvmrc7TnKrJEzEgBsr0SAMXNnLqlAntEeKk7g/Yt +sbqgD4Bd6zQ0ulBdOHinOBhmUAAAAGdydWJfY21kOiBsb2FkZm9udCAoaGQwLGdw +dDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3VuaWZvbnQtcmVndWxhci0x +Ni5wZjIACQAAAA0AAAADAAAABADvmZCGE+94vnFr8TQ6J8FYUpbSywsALHZpXG27 +NzahOktltyCqvpWV3OOc9Xla6710umOQGQcSAG/aV6h31O+uJ8qFbLYKKo6w77W4 +KDfpoTW6g543oif7PQAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVz +L1VLVUkvdW5pZm9udC1yZWd1bGFyLTE2LnBmMgAIAAAADQAAAAMAAAAEABddTnMv +mEcDglOytB40SDYkK7F/CwB8+gcXR2lEIexO0zd8Rn2z00/XbDKcOfcK6Faz2drG +AhIATIE2FjESpuTXmQZpuo8qByN0jZGSKu4zgLZ/ihjJAukVAAAAZ3J1Yl9jbWQ6 +IGluc21vZCBwbmcACQAAAA0AAAADAAAABACWSiIGJAfnjARL+fTja8CIc72+YwsA +px7aP7ftAEMi6WFul0j6Ecxz4sGLuWLCCzTZZUGZQVQSAAo+ZTcApbKirdlYRGXK +s5Vv7KzBLBuqf9xCll/a3soMKAAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82 +NC1lZmkvcG5nLm1vZAAIAAAADQAAAAMAAAAEAE37RvubxJV+lYwQquZGIcQZHJ69 +CwAKeDYjNTPZorGpMOlNrqeac46s2TJuqvwB6XALyTjDqxIA6iOYS2TWCfy3/I+0 +fh5nyjhL327GIjpWPf0AdeEox+REAAAAZ3J1Yl9jbWQ6IHNldCB0aGVtZT0oaGQw +LGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3RoZW1lLnR4dAAIAAAA +DQAAAAMAAAAEAIDx46p9OIcEY5l1bhrwGI22/9bvCwAZFYHaxl0cOKY9Bsh8tRiu +BGaO0GqtPgCjPqjSQYAbdhIADqBmx76d4Hine/hrvVNJ7tau16wbLU8CnFuISOhv +saUXAAAAZ3J1Yl9jbWQ6IGV4cG9ydCB0aGVtZQAIAAAADQAAAAMAAAAEAEIyh6QL +kUu1FJfbMvkIZpfR+54SCwDwtLPCMQOCjqL6BQRKLPzl78nRXpn/ucYdc0nBMDdB +rxIAnuWEidCYiUvHs/xxtpWcUfTGduK2UmnxkCRvhm3udIwUAAAAZ3J1Yl9jbWQ6 +IFsgICE9IDEgXQAIAAAADQAAAAMAAAAEACkszpDSjhc2qOkU6FQNm/DjyzaRCwBd +iE5S0OGR2IIbd8eoU6iaLQWER0PI6YGHtHTYAPHH5hIAsTNxYT9ZyrwWUDTUhztO +G1h667IQXhD6MgMOTlqZrjI3AAAAZ3J1Yl9jbWQ6IFsgLWUgKGhkMCxncHQxKS9i +b290L2dydWIvZ2Z4YmxhY2tsaXN0LnR4dCBdAAgAAAANAAAAAwAAAAQAaJd6J9k8 +Xig298VNYk3Uj+7A9n0LAPJJ52Gn43UQ+Kz1kULBF0RMOqG8WnGa5+q2DTtxCRgK +EgA5kv6lJ3EeL9Osr0YNb87mA7h16YwtXVNNsoJmf+r3SCIAAABncnViX2NtZDog +c2V0IGxpbnV4X2dmeF9tb2RlPWtlZXAACAAAAA0AAAADAAAABACd7vD6RE5Z16CO +YV8lYogm5/7d+QsAIuBBJR61TusycCRXWao+i9O3emR9uYi2gbHq/GlgqkUSAMkt +oqQHT+zQtWZQvzbsk8qzjf/UqSQWFbV3qUuq3SpcIAAAAGdydWJfY21kOiBleHBv +cnQgbGludXhfZ2Z4X21vZGUACAAAAA0AAAADAAAABACWg/0LSN2DCf8oL2z9gwfw +DHQ0NAsA+hTAvhWWzwv+y4rfv0x31m/vOP/ebC1fXoHdpGs8Jn0SAB5mf3Q2yXBE +3acMjNb16Vxkbw5tP1JaI4OZQ4bBsvvLkQMAAGdydWJfY21kOiBtZW51ZW50cnkg +S3lsaW4gVjEwIFNQMSA1LjQuMTgtMzUtZ2VuZXJpYyAtLWNsYXNzIGt5bGluIC0t +Y2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgLS1pZCBnbnVs +aW51eC1zaW1wbGUtNjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNh +IHsKCXJlY29yZGZhaWwKCWxvYWRfdmlkZW8KCWdmeG1vZGUgJGxpbnV4X2dmeF9t +b2RlCglpbnNtb2QgZ3ppbwoJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07 +IHRoZW4gaW5zbW9kIHh6aW87IGluc21vZCBsem9waW87IGZpCglpbnNtb2QgcGFy +dF9ncHQKCWluc21vZCBleHQyCglzZXQgcm9vdD0naGQwLGdwdDInCglpZiBbIHgk +ZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4KCSAgc2Vh +cmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9z +PWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1h +aGNpMCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcK +CWVsc2UKCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290 +IGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJZmkKCWxpbnV4 +CS92bWxpbnV6LTUuNC4xOC0zNS1nZW5lcmljIHJvb3Q9VVVJRD02Njg5Y2ZiZS03 +YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBkZWZh +dWx0X2h1Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1f +ZW5jcnlwdD1vZmYgIHJlc3VtZT1VVUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1iMDc4 +LWNlNjk5YjIxN2Y4MCBhdWRpdD0wIHNlY3VyaXR5PWt5c2VjCglpbml0cmQJL2lu +aXRyZC5pbWctNS40LjE4LTM1LWdlbmVyaWMKfQAIAAAADQAAAAMAAAAEAPe2AaP4 +DdXGgOwGRMGZOcZX9mneCwCAeQLw59WxvQu1Q+6Mh67lN/vtVwjR0ixOgFMHIKXV +oRIAoHHUWizsY3KnZ6utFDTrSeby+3KLZEf63Aj9isbcjGu4CAAAZ3J1Yl9jbWQ6 +IHN1Ym1lbnUgS3lsaW4gVjEwIFNQMSAo57O757uf5aSH5Lu96L+Y5Y6f5qih5byP +KSAtLWlkIGdudWxpbnV4LWFkdmFuY2VkLTY2ODljZmJlLTdjM2EtNDM4Yi04NmZk +LTJkMTAzOWQ1ZDljYSB7CgltZW51ZW50cnkgJ0t5bGluIFYxMCBTUDEsIHdpdGgg +NS40LjE4LTM1LWdlbmVyaWMgKGJhY2t1cCBtb2RlKScgLS1jbGFzcyBreWxpbiAt +LWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zICRtZW51ZW50 +cnlfaWRfb3B0aW9uICdnbnVsaW51eC01LjQuMTgtMzUtZ2VuZXJpYy1iYWNrdXAt +NjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJcmVjb3Jk +ZmFpbAoJCWxvYWRfdmlkZW8KCQlnZnhtb2RlICRsaW51eF9nZnhfbW9kZQoJCWlu +c21vZCBnemlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4g +aW5zbW9kIHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0 +CgkJaW5zbW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZl +YXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFy +Y2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9 +aGQwLGdwdDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFo +Y2kwLGdwdDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJ +CWVsc2UKCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9v +dCBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVj +aG8JJ+i9veWFpSBMaW51eCA1LjQuMTgtMzUtZ2VuZXJpYyAuLi4nCgkgICAgICBs +aW51eCAgIC92bWxpbnV6LTUuNC4xOC0zNS1nZW5lcmljIHJvb3Q9VVVJRD02Njg5 +Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2EgcncgIHF1aWV0IHNwbGFz +aCBkZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9 +MSBtZW1fZW5jcnlwdD1vZmYgIHJlc3VtZT1VVUlEPTZhM2ExNmVmLWMwMTEtNDkx +Ni1iMDc4LWNlNjk5YjIxN2Y4MCBhdWRpdD0wIHNlY3VyaXR5PWt5c2VjIHNlbGlu +dXg9MCBiYWNrdXAKCSAgICAgIGluaXRyZCAgL2luaXRyZC5pbWctNS40LjE4LTM1 +LWdlbmVyaWMKCX0KCW1lbnVlbnRyeSAnS3lsaW4gVjEwIFNQMSwgd2l0aCA1LjQu +MTgtMzUtZ2VuZXJpYyAocmVzdG9yZSBtb2RlKScgLS1jbGFzcyBreWxpbiAtLWNs +YXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zICRtZW51ZW50cnlf +aWRfb3B0aW9uICdnbnVsaW51eC01LjQuMTgtMzUtZ2VuZXJpYy1yZXN0b3JlLTY2 +ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYScgewoJCXJlY29yZGZh +aWwKCQlsb2FkX3ZpZGVvCgkJZ2Z4bW9kZSAkbGludXhfZ2Z4X21vZGUKCQlpbnNt +b2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRmb3JtID0geHhlbiBdOyB0aGVuIGlu +c21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBmaQoJCWluc21vZCBwYXJ0X2dwdAoJ +CWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hkMCxncHQyJwoJCWlmIFsgeCRmZWF0 +dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgoJCSAgc2VhcmNo +IC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhk +MCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNp +MCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQll +bHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3Qg +ZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZmkKCQllY2hv +CSfovb3lhaUgTGludXggNS40LjE4LTM1LWdlbmVyaWMgLi4uJwoJICAgICAgbGlu +dXggICAvdm1saW51ei01LjQuMTgtMzUtZ2VuZXJpYyByb290PVVVSUQ9NjY4OWNm +YmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHJ3ICBxdWlldCBzcGxhc2gg +ZGVmYXVsdF9odWdlcGFnZXN6PTFHIGh1Z2VwYWdlc3o9MUcgaHVnZXBhZ2VzPTEg +bWVtX2VuY3J5cHQ9b2ZmICByZXN1bWU9VVVJRD02YTNhMTZlZi1jMDExLTQ5MTYt +YjA3OC1jZTY5OWIyMTdmODAgYXVkaXQ9MCBzZWN1cml0eT1reXNlYyBzZWxpbnV4 +PTAgcmVzdG9yZQoJICAgICAgaW5pdHJkICAvaW5pdHJkLmltZy01LjQuMTgtMzUt +Z2VuZXJpYwoJfQogIH0ACAAAAA0AAAADAAAABAAXYdVqJCChMFeqWTm/nsb3uuDa +8wsAYjFBHsIpkC1hYPlAwOMUcd+Cke4dV5r6TT/cPCOadpUSAK5htSKR5zDJTkbB +MdUwVqoiU/9PrQeQjUbJgQBbvL8/aiYAAGdydWJfY21kOiBzdWJtZW51IEt5bGlu +IFYxMCBTUDEg55qE6auY57qn6YCJ6aG5IC0taWQgZ251bGludXgtYWR2YW5jZWQt +NjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHsKCW1lbnVlbnRy +eSAnS3lsaW4gVjEwIFNQMSwgNS40LjE4LTM1LWdlbmVyaWMnIC0tY2xhc3Mga3ls +aW4gLS1jbGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAkbWVu +dWVudHJ5X2lkX29wdGlvbiAnZ251bGludXgtNS40LjE4LTM1LWdlbmVyaWMtYWR2 +YW5jZWQtNjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJ +cmVjb3JkZmFpbAoJCWxvYWRfdmlkZW8KCQlnZnhtb2RlICRsaW51eF9nZnhfbW9k +ZQoJCWluc21vZCBnemlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07 +IHRoZW4gaW5zbW9kIHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBh +cnRfZ3B0CgkJaW5zbW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYg +WyB4JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJ +ICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50 +LWJpb3M9aGQwLGdwdDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1l +dGFsPWFoY2kwLGdwdDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVm +M2UwNwoJCWVsc2UKCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1z +ZXQ9cm9vdCBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlm +aQoJCWVjaG8JJ+i9veWFpSBMaW51eCA1LjQuMTgtMzUtZ2VuZXJpYyAuLi4nCgkJ +bGludXgJL3ZtbGludXotNS40LjE4LTM1LWdlbmVyaWMgcm9vdD1VVUlEPTY2ODlj +ZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYSBybyAgcXVpZXQgc3BsYXNo +IGRlZmF1bHRfaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXN6PTFHIGh1Z2VwYWdlcz0x +IG1lbV9lbmNyeXB0PW9mZiAgcmVzdW1lPVVVSUQ9NmEzYTE2ZWYtYzAxMS00OTE2 +LWIwNzgtY2U2OTliMjE3ZjgwIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hv +CSfovb3lhaXliJ3lp4vljJblhoXlrZjnm5guLi4nCgkJaW5pdHJkCS9pbml0cmQu +aW1nLTUuNC4xOC0zNS1nZW5lcmljCgl9CgltZW51ZW50cnkgJ0t5bGluIFYxMCBT +UDEsIDUuNC4xOC0zNS1nZW5lcmljIChyZWNvdmVyeSBtb2RlKScgLS1jbGFzcyBr +eWxpbiAtLWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zICRt +ZW51ZW50cnlfaWRfb3B0aW9uICdnbnVsaW51eC01LjQuMTgtMzUtZ2VuZXJpYy1y +ZWNvdmVyeS02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2EnIHsK +CQlyZWNvcmRmYWlsCgkJbG9hZF92aWRlbwoJCWluc21vZCBnemlvCgkJaWYgWyB4 +JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4gaW5zbW9kIHh6aW87IGluc21v +ZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0CgkJaW5zbW9kIGV4dDIKCQlz +ZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZlYXR1cmVfcGxhdGZvcm1fc2Vh +cmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1m +cy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQwLGdwdDIgLS1oaW50LWVm +aT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kwLGdwdDIgIGZjNTFiNTM5 +LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWVsc2UKCQkgIHNlYXJjaCAt +LW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmYzUxYjUzOS1lOGFiLTQw +M2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVjaG8JJ+i9veWFpSBMaW51eCA1 +LjQuMTgtMzUtZ2VuZXJpYyAuLi4nCgkJbGludXgJL3ZtbGludXotNS40LjE4LTM1 +LWdlbmVyaWMgcm9vdD1VVUlEPTY2ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAz +OWQ1ZDljYSBybyBzaW5nbGUgbm9tb2Rlc2V0IGRpc191Y29kZV9sZHIgIGF1ZGl0 +PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hvCSfovb3lhaXliJ3lp4vljJblhoXlrZjn +m5guLi4nCgkJaW5pdHJkCS9pbml0cmQuaW1nLTUuNC4xOC0zNS1nZW5lcmljCgl9 +CgltZW51ZW50cnkgJ0t5bGluIFYxMCBTUDEsIDUuNC4xOC10a21fb3JpJyAtLWNs +YXNzIGt5bGluIC0tY2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mg +b3MgJG1lbnVlbnRyeV9pZF9vcHRpb24gJ2dudWxpbnV4LTUuNC4xOC10a21fb3Jp +LWFkdmFuY2VkLTY2ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYScg +ewoJCXJlY29yZGZhaWwKCQlsb2FkX3ZpZGVvCgkJZ2Z4bW9kZSAkbGludXhfZ2Z4 +X21vZGUKCQlpbnNtb2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRmb3JtID0geHhl +biBdOyB0aGVuIGluc21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBmaQoJCWluc21v +ZCBwYXJ0X2dwdAoJCWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hkMCxncHQyJwoJ +CWlmIFsgeCRmZWF0dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhl +bgoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0t +aGludC1iaW9zPWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50LWJh +cmVtZXRhbD1haGNpMCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02Njcy +ZTRlZjNlMDcKCQllbHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlk +IC0tc2V0PXJvb3QgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3 +CgkJZmkKCQllY2hvCSfovb3lhaUgTGludXggNS40LjE4LXRrbV9vcmkgLi4uJwoJ +CWxpbnV4CS92bWxpbnV6LTUuNC4xOC10a21fb3JpIHJvb3Q9VVVJRD02Njg5Y2Zi +ZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBk +ZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBt +ZW1fZW5jcnlwdD1vZmYgIHJlc3VtZT1VVUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1i +MDc4LWNlNjk5YjIxN2Y4MCBhdWRpdD0wIHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn +6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRyZAkvaW5pdHJkLmlt +Zy01LjQuMTgtdGttX29yaQoJfQoJbWVudWVudHJ5ICdLeWxpbiBWMTAgU1AxLCA1 +LjQuMTgtdGttX29yaSAocmVjb3ZlcnkgbW9kZSknIC0tY2xhc3Mga3lsaW4gLS1j +bGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAkbWVudWVudHJ5 +X2lkX29wdGlvbiAnZ251bGludXgtNS40LjE4LXRrbV9vcmktcmVjb3ZlcnktNjY4 +OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJcmVjb3JkZmFp +bAoJCWxvYWRfdmlkZW8KCQlpbnNtb2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRm +b3JtID0geHhlbiBdOyB0aGVuIGluc21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBm +aQoJCWluc21vZCBwYXJ0X2dwdAoJCWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hk +MCxncHQyJwoJCWlmIFsgeCRmZWF0dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0g +eHkgXTsgdGhlbgoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNl +dD1yb290IC0taGludC1iaW9zPWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIg +LS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2Mt +ODAyZC02NjcyZTRlZjNlMDcKCQllbHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkg +LS1mcy11dWlkIC0tc2V0PXJvb3QgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3 +MmU0ZWYzZTA3CgkJZmkKCQllY2hvCSfovb3lhaUgTGludXggNS40LjE4LXRrbV9v +cmkgLi4uJwoJCWxpbnV4CS92bWxpbnV6LTUuNC4xOC10a21fb3JpIHJvb3Q9VVVJ +RD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gc2luZ2xl +IG5vbW9kZXNldCBkaXNfdWNvZGVfbGRyICBhdWRpdD0wIHNlY3VyaXR5PWt5c2Vj +CgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRyZAkv +aW5pdHJkLmltZy01LjQuMTgtdGttX29yaQoJfQoJbWVudWVudHJ5ICdLeWxpbiBW +MTAgU1AxLCA1LjQuMTgtdGttX29yaS5vbGQnIC0tY2xhc3Mga3lsaW4gLS1jbGFz +cyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAkbWVudWVudHJ5X2lk +X29wdGlvbiAnZ251bGludXgtNS40LjE4LXRrbV9vcmkub2xkLWFkdmFuY2VkLTY2 +ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYScgewoJCXJlY29yZGZh +aWwKCQlsb2FkX3ZpZGVvCgkJZ2Z4bW9kZSAkbGludXhfZ2Z4X21vZGUKCQlpbnNt +b2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRmb3JtID0geHhlbiBdOyB0aGVuIGlu +c21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBmaQoJCWluc21vZCBwYXJ0X2dwdAoJ +CWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hkMCxncHQyJwoJCWlmIFsgeCRmZWF0 +dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgoJCSAgc2VhcmNo +IC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhk +MCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNp +MCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQll +bHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3Qg +ZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZmkKCQllY2hv +CSfovb3lhaUgTGludXggNS40LjE4LXRrbV9vcmkub2xkIC4uLicKCQlsaW51eAkv +dm1saW51ei01LjQuMTgtdGttX29yaS5vbGQgcm9vdD1VVUlEPTY2ODljZmJlLTdj +M2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYSBybyAgcXVpZXQgc3BsYXNoIGRlZmF1 +bHRfaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXN6PTFHIGh1Z2VwYWdlcz0xIG1lbV9l +bmNyeXB0PW9mZiAgcmVzdW1lPVVVSUQ9NmEzYTE2ZWYtYzAxMS00OTE2LWIwNzgt +Y2U2OTliMjE3ZjgwIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hvCSfovb3l +haXliJ3lp4vljJblhoXlrZjnm5guLi4nCgkJaW5pdHJkCS9pbml0cmQuaW1nLTUu +NC4xOC10a21fb3JpCgl9CgltZW51ZW50cnkgJ0t5bGluIFYxMCBTUDEsIDUuNC4x +OC10a21fb3JpLm9sZCAocmVjb3ZlcnkgbW9kZSknIC0tY2xhc3Mga3lsaW4gLS1j +bGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAkbWVudWVudHJ5 +X2lkX29wdGlvbiAnZ251bGludXgtNS40LjE4LXRrbV9vcmkub2xkLXJlY292ZXJ5 +LTY2ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYScgewoJCXJlY29y +ZGZhaWwKCQlsb2FkX3ZpZGVvCgkJaW5zbW9kIGd6aW8KCQlpZiBbIHgkZ3J1Yl9w +bGF0Zm9ybSA9IHh4ZW4gXTsgdGhlbiBpbnNtb2QgeHppbzsgaW5zbW9kIGx6b3Bp +bzsgZmkKCQlpbnNtb2QgcGFydF9ncHQKCQlpbnNtb2QgZXh0MgoJCXNldCByb290 +PSdoZDAsZ3B0MicKCQlpZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGlu +dCA9IHh5IF07IHRoZW4KCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQg +LS1zZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDAsZ3B0MiAtLWhpbnQtZWZpPWhkMCxn +cHQyIC0taGludC1iYXJlbWV0YWw9YWhjaTAsZ3B0MiAgZmM1MWI1MzktZThhYi00 +MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZWxzZQoJCSAgc2VhcmNoIC0tbm8tZmxv +cHB5IC0tZnMtdXVpZCAtLXNldD1yb290IGZjNTFiNTM5LWU4YWItNDAzYy04MDJk +LTY2NzJlNGVmM2UwNwoJCWZpCgkJZWNobwkn6L295YWlIExpbnV4IDUuNC4xOC10 +a21fb3JpLm9sZCAuLi4nCgkJbGludXgJL3ZtbGludXotNS40LjE4LXRrbV9vcmku +b2xkIHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5 +Y2Egcm8gc2luZ2xlIG5vbW9kZXNldCBkaXNfdWNvZGVfbGRyICBhdWRpdD0wIHNl +Y3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4u +JwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtdGttX29yaQoJfQoJbWVudWVu +dHJ5ICdLeWxpbiBWMTAgU1AxLCA1LjQuMTgtdGttJyAtLWNsYXNzIGt5bGluIC0t +Y2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgJG1lbnVlbnRy +eV9pZF9vcHRpb24gJ2dudWxpbnV4LTUuNC4xOC10a20tYWR2YW5jZWQtNjY4OWNm +YmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJcmVjb3JkZmFpbAoJ +CWxvYWRfdmlkZW8KCQlnZnhtb2RlICRsaW51eF9nZnhfbW9kZQoJCWluc21vZCBn +emlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4gaW5zbW9k +IHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0CgkJaW5z +bW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZlYXR1cmVf +cGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFyY2ggLS1u +by1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQwLGdw +dDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kwLGdw +dDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWVsc2UK +CQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmYzUx +YjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVjaG8JJ+i9 +veWFpSBMaW51eCA1LjQuMTgtdGttIC4uLicKCQlsaW51eAkvdm1saW51ei01LjQu +MTgtdGttIHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlk +NWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBkZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVn +ZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1fZW5jcnlwdD1vZmYgIHJlc3VtZT1V +VUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1iMDc4LWNlNjk5YjIxN2Y4MCBhdWRpdD0w +IHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uY +Li4uJwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtdGttCgl9CgltZW51ZW50 +cnkgJ0t5bGluIFYxMCBTUDEsIDUuNC4xOC10a20gKHJlY292ZXJ5IG1vZGUpJyAt +LWNsYXNzIGt5bGluIC0tY2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xh +c3Mgb3MgJG1lbnVlbnRyeV9pZF9vcHRpb24gJ2dudWxpbnV4LTUuNC4xOC10a20t +cmVjb3ZlcnktNjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7 +CgkJcmVjb3JkZmFpbAoJCWxvYWRfdmlkZW8KCQlpbnNtb2QgZ3ppbwoJCWlmIFsg +eCRncnViX3BsYXRmb3JtID0geHhlbiBdOyB0aGVuIGluc21vZCB4emlvOyBpbnNt +b2QgbHpvcGlvOyBmaQoJCWluc21vZCBwYXJ0X2dwdAoJCWluc21vZCBleHQyCgkJ +c2V0IHJvb3Q9J2hkMCxncHQyJwoJCWlmIFsgeCRmZWF0dXJlX3BsYXRmb3JtX3Nl +YXJjaF9oaW50ID0geHkgXTsgdGhlbgoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0t +ZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhkMCxncHQyIC0taGludC1l +Zmk9aGQwLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQyICBmYzUxYjUz +OS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQllbHNlCgkJICBzZWFyY2gg +LS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgZmM1MWI1MzktZThhYi00 +MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZmkKCQllY2hvCSfovb3lhaUgTGludXgg +NS40LjE4LXRrbSAuLi4nCgkJbGludXgJL3ZtbGludXotNS40LjE4LXRrbSByb290 +PVVVSUQ9NjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHJvIHNp +bmdsZSBub21vZGVzZXQgZGlzX3Vjb2RlX2xkciAgYXVkaXQ9MCBzZWN1cml0eT1r +eXNlYwoJCWVjaG8JJ+i9veWFpeWIneWni+WMluWGheWtmOebmC4uLicKCQlpbml0 +cmQJL2luaXRyZC5pbWctNS40LjE4LXRrbQoJfQoJbWVudWVudHJ5ICdLeWxpbiBW +MTAgU1AxLCA1LjQuMTgtY3N2JyAtLWNsYXNzIGt5bGluIC0tY2xhc3MgZ251LWxp +bnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgJG1lbnVlbnRyeV9pZF9vcHRpb24g +J2dudWxpbnV4LTUuNC4xOC1jc3YtYWR2YW5jZWQtNjY4OWNmYmUtN2MzYS00Mzhi +LTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJcmVjb3JkZmFpbAoJCWxvYWRfdmlkZW8K +CQlnZnhtb2RlICRsaW51eF9nZnhfbW9kZQoJCWluc21vZCBnemlvCgkJaWYgWyB4 +JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4gaW5zbW9kIHh6aW87IGluc21v +ZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0CgkJaW5zbW9kIGV4dDIKCQlz +ZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZlYXR1cmVfcGxhdGZvcm1fc2Vh +cmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1m +cy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQwLGdwdDIgLS1oaW50LWVm +aT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kwLGdwdDIgIGZjNTFiNTM5 +LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWVsc2UKCQkgIHNlYXJjaCAt +LW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmYzUxYjUzOS1lOGFiLTQw +M2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVjaG8JJ+i9veWFpSBMaW51eCA1 +LjQuMTgtY3N2IC4uLicKCQlsaW51eAkvdm1saW51ei01LjQuMTgtY3N2IHJvb3Q9 +VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gIHF1 +aWV0IHNwbGFzaCBkZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBo +dWdlcGFnZXM9MSBtZW1fZW5jcnlwdD1vZmYgIHJlc3VtZT1VVUlEPTZhM2ExNmVm +LWMwMTEtNDkxNi1iMDc4LWNlNjk5YjIxN2Y4MCBhdWRpdD0wIHNlY3VyaXR5PWt5 +c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRy +ZAkvaW5pdHJkLmltZy01LjQuMTgtY3N2Cgl9CgltZW51ZW50cnkgJ0t5bGluIFYx +MCBTUDEsIDUuNC4xOC1jc3YgKHJlY292ZXJ5IG1vZGUpJyAtLWNsYXNzIGt5bGlu +IC0tY2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgJG1lbnVl +bnRyeV9pZF9vcHRpb24gJ2dudWxpbnV4LTUuNC4xOC1jc3YtcmVjb3ZlcnktNjY4 +OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhJyB7CgkJcmVjb3JkZmFp +bAoJCWxvYWRfdmlkZW8KCQlpbnNtb2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRm +b3JtID0geHhlbiBdOyB0aGVuIGluc21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBm +aQoJCWluc21vZCBwYXJ0X2dwdAoJCWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hk +MCxncHQyJwoJCWlmIFsgeCRmZWF0dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0g +eHkgXTsgdGhlbgoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNl +dD1yb290IC0taGludC1iaW9zPWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIg +LS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2Mt +ODAyZC02NjcyZTRlZjNlMDcKCQllbHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkg +LS1mcy11dWlkIC0tc2V0PXJvb3QgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3 +MmU0ZWYzZTA3CgkJZmkKCQllY2hvCSfovb3lhaUgTGludXggNS40LjE4LWNzdiAu +Li4nCgkJbGludXgJL3ZtbGludXotNS40LjE4LWNzdiByb290PVVVSUQ9NjY4OWNm +YmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHJvIHNpbmdsZSBub21vZGVz +ZXQgZGlzX3Vjb2RlX2xkciAgYXVkaXQ9MCBzZWN1cml0eT1reXNlYwoJCWVjaG8J +J+i9veWFpeWIneWni+WMluWGheWtmOebmC4uLicKCQlpbml0cmQJL2luaXRyZC5p +bWctNS40LjE4LWNzdgoJfQp9AAgAAAANAAAAAwAAAAQAxRIJKwSBI0yqQW73wZar +TpK44AILABxWg5jPLkqd9Yh1u9ed/+BY7EW+C3RRL6kZov59tKYJEgAASeN8w2rD +sZUtle+qYBzVXT/cPF5l9EXA0DApC8+pcCEAAABncnViX2NtZDogc2V0IHRpbWVv +dXRfc3R5bGU9bWVudQAIAAAADQAAAAMAAAAEAFp1wFVx8R3SRlYx+4xeFcsZYTtV +CwBAQUoUMSCSvaLx0GBVzrn12K82qDIVWpvw0F0ZyJWknRIAqNTd+mZDZlCOIsaS +447vHpb/qieToRlN6WXimBIrl6kUAAAAZ3J1Yl9jbWQ6IFsgNSA9IDAgXQAIAAAA +DQAAAAMAAAAEACc/XIDBLpNcHTfCz+PhYbxC152OCwAeo3QwlQyDcCHrzAL5jBIB +jDHlk+NmQpQ24TU1hMfschIAI7V+jbR093yVQWJWPM/4a4+fb0F2VN3lNAyZUyyj +hmgxAAAAZ3J1Yl9jbWQ6IFsgLWYgKGhkMCxncHQxKS9ib290L2dydWIvY3VzdG9t +LmNmZyBdAAgAAAANAAAAAwAAAAQAozJt8xlCAVdeUcO5ocjV0Xrv8tALANVHjZBX +WAUxv2/zc4OwG7eOEnnCCiNyGqOmetDRyjXbEgAgKK5stp0dg7GLTGQH2BYLqC2r +Im7gyqT60hLorBqpx0wAAABncnViX2NtZDogWyAteiAoaGQwLGdwdDEpL2Jvb3Qv +Z3J1YiAtYSAtZiAoaGQwLGdwdDEpL2Jvb3QvZ3J1Yi9jdXN0b20uY2ZnIF0ACQAA +AA0AAAADAAAABACrF0D1G+oxCLf4sfKkXrnUl+4OfQsA01LVDQHiCPZsuNORBAl1 +hiRmJORHIU5Mtme39xI8cjwSAMUtHhSNQDot11uFrOkP4ULZwoFeVL4qeyK5ZzYS +PQ/7MAAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvdGhl +bWUudHh0AAkAAAANAAAAAwAAAAQAZ6F3K6EKxT5Nqf5BUMV6deb4j8MLANLAVA8G +x+GlUrDTZvFC7nsZC4BlprE3OPXZOLgWw+R9EgC0+1UdnOAohrL1865rfS/SUnCP +x5a29XAs0yLWe8H9+jUAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1l +cy9VS1VJL2JhY2tncm91bmQucG5nAAkAAAANAAAAAwAAAAQAJAprDxRkWG1AmMEN +PqhwHQ4cFVYLAIdeY+6jLFu/e6BbxCho5RLw1nLyRNrTk54XDi9TvN+5EgDdJU74 +WPH1pSFGzrJ6LnqGApMiKmy5ilrBcNi/fnjHfToAAAAoaGQwLGdwdDMpL3Vzci9z +aGFyZS9ncnViL3RoZW1lcy9VS1VJL3Rlcm1pbmFsX2JveF9udy5wbmcACQAAAA0A +AAADAAAABADlAlzEHdQdSXhSP4JiOMTPwjeN6gsAZp1N1g0WEI67biZIoWrDq/yF +agxVdY8GYEyKbbX6klcSANcIaVKm5wut95P3BguQh5QemPIFenAkbtfhl4PP8oum +OgAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvdGVybWlu +YWxfYm94X25lLnBuZwAJAAAADQAAAAMAAAAEAF19Ya81IlTFMgwsV+PxbjXk+Nfk +CwCnPawKUAmGn+fpHJhlg8Jmu+yL9emOabJ+vTjdfSQ74BIAc3PG3FHX8to8YL/e +6z9QKKikFCKlLW0kGiViEAqHvRA6AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1 +Yi90aGVtZXMvVUtVSS90ZXJtaW5hbF9ib3hfc2UucG5nAAkAAAANAAAAAwAAAAQA +18mEjGZNcICR4WhHWEAhpcJI5VMLAD4gCPZBzlDTIgCtlz7xHSliFHrMeNv1wb6E +7RmgkkLoEgCJFWMAuq2yvQMqW6UcAYHaGCqz5ZVsX/l8klP4jNq//DoAAAAoaGQw +LGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3Rlcm1pbmFsX2JveF9z +dy5wbmcACQAAAA0AAAADAAAABAA+kfKMFCgxMCPIwwdc+Xux4TTA4wsAp+EVkvz3 +7JAqQTiW+A5Z4U1tmORE8BeM+H7GN7CqBboSAHDjY6GHPvKNt1FxIoflB7VRqNOq +TON7db8dIC60fqK1OQAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVz +L1VLVUkvdGVybWluYWxfYm94X24ucG5nAAkAAAANAAAAAwAAAAQA0qXoEL1Ppj/a +r8Hxu++K02lHLbQLADDaV3i9+w1VD+O5kWVrJr3sWzELPY+Ev/jjyDAF5oyBEgAf +Khp4txaLctQzF0NOcMGkK4r3n9khSV+i2R2PMcREJzkAAAAoaGQwLGdwdDMpL3Vz +ci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3Rlcm1pbmFsX2JveF9lLnBuZwAJAAAA +DQAAAAMAAAAEAHFlMZHUKag0sRjyjnVEeN+OM9rOCwCpHoYI4lvWXm34BW/Ra6av +8ZiiQDsvjFQOnOWhh4x2txIAIvNnQAZDsnYiCzwMEsRvBO/8uDcOWuoN1EAhXMVP +a5U5AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS90ZXJt +aW5hbF9ib3hfcy5wbmcACQAAAA0AAAADAAAABADfEYW81VVxIs7H4IdfMq4wOKZ3 +ygsA/eLUPi8jUxsKHj12ziEZBR2EqbhOxtToA0Ou8mi44ugSANxQJNtcVuT/J+p6 +YkEzxTJkGcwv6sEDjDIkMdOwxRqKOQAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dy +dWIvdGhlbWVzL1VLVUkvdGVybWluYWxfYm94X3cucG5nAAkAAAANAAAAAwAAAAQA +8sorIwIOiWLgNPjlG7sGdRIoulQLAJgmVD/ZRF/7p0QDDvFqH/nvX6zbRHWIBhj3 +7/mFHab/EgAyUjjvtCr0GULEQ8EbezIPo2c6Y0nCtpuwvU+So3jC9TkAAAAoaGQw +LGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3Rlcm1pbmFsX2JveF9j +LnBuZwAJAAAADQAAAAMAAAAEAEpkWfr76/9hJfR8Lrtbsg//1yEfCwAx2Fee6huf +XAYJ3u3q4ldxqAGjnaZD5/0DUNIPpGrodRIAkhNS25HS6IzSLjIQxd9CdWqJr3/+ +ILTBkoidZZxbuuYvAAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMv +VUtVSS9sb2dvLnBuZwAJAAAADQAAAAMAAAAEAIEqkegJuyQg/X6jZTNtVzxl3lP+ +CwDUqUXzZt4aMAoThaMPxXfH75LxEzS+50hQ9q2cWJT1aRIArxq96+tVeq2YZb38 +TqztGljbgOpG+CbhiyMjcRLq9vY6AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1 +Yi90aGVtZXMvVUtVSS9wcm9ncmVzc19iYXJfbncucG5nAAkAAAANAAAAAwAAAAQA +sYFfeeg7S/rrf4HfIX2YJt5CpjcLAET7eaHFr6KRqoQ8mUranw5BVsdFGzTAqwMt +xyPYKhMNEgAjyb9NlrNLrhAZb53I6XGHgj7pllfUniYOa7yW9ofi1ToAAAAoaGQw +LGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3Byb2dyZXNzX2Jhcl9u +ZS5wbmcACQAAAA0AAAADAAAABAAKOHDV5q/7KZNq/fFEXDlknmr9fgsA+4vC20Kv +QZO5MxGeSxetJq9HFBubZ9kd4NWtR240F3ESAHQp22k+t9fhHEJzJSL8sZJJUvhZ +GlwxQMR2hEtgRoa+OgAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVz +L1VLVUkvcHJvZ3Jlc3NfYmFyX3NlLnBuZwAJAAAADQAAAAMAAAAEAFjjYohj3M6f +EiwNcBLNkiXULfGSCwAx9vSP2lnP2mePWMauJcNbgn4+J21cZ1W3592VhAbTUhIA +i/wHWY26QvZwVhWyeNgovh2PY9rAXWJNmCURvNKCsj86AAAAKGhkMCxncHQzKS91 +c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS9wcm9ncmVzc19iYXJfc3cucG5nAAkA +AAANAAAAAwAAAAQAb/DomhSvITPqoipOTxjlr9fTxTALAAoGj84gj3egrZpTGMnS ++kgVUXAHP52qmOyBN9cBKjY9EgA8ecItHf6o+R6XzxQ0drnntyExNGfubT5dJbLt +BItkhjkAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3By +b2dyZXNzX2Jhcl9uLnBuZwAJAAAADQAAAAMAAAAEAAzeTq2tA9tAf4kOQZavPquP +5diECwBfUrFJRtKWKQCfDi4SEBO9ihDGIrwM/nI/V7aUS3WdJRIAouylHMB7CjCQ +6TSUv9YQTUafUwp2lAtxq5CLRuB+2fg5AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUv +Z3J1Yi90aGVtZXMvVUtVSS9wcm9ncmVzc19iYXJfZS5wbmcACQAAAA0AAAADAAAA +BAD/LR3sjPEhyfJnlNDXJpeLaAaJlAsAh+TKiDJgRqIXeLgWD9nzxYleeD2PVjF1 +K2rtmHAPWcASADSU79BdMa0NMUz2mlZb0rWXaQ5k4AQw4L19migU+mltOQAAACho +ZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvcHJvZ3Jlc3NfYmFy +X3MucG5nAAkAAAANAAAAAwAAAAQA+AGm/ANjXZMINdB2jtG4eSvUuiULAM4KR+t2 +cro3Ez5hxGv2wbyAxsef9tGMlRtaL5p6t/wYEgBOU8ObCxPturt9B1NSynFh51K5 +1I+3K/+Udrmvyb0yfTkAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1l +cy9VS1VJL3Byb2dyZXNzX2Jhcl93LnBuZwAJAAAADQAAAAMAAAAEALsIhCkUY8/e +0NykIexK2zI+5ByiCwAJvuGV8XqaANcY/NsDZW+QjI3XpE5hczNrFQdY6fL1exIA +3RoNVx5xUobPIkKprSmmRMo3HuzIvqmZXV3yPmUfkW85AAAAKGhkMCxncHQzKS91 +c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS9wcm9ncmVzc19iYXJfYy5wbmcACQAA +AA0AAAADAAAABADPqG74hAgs4iTtigf9Bt9te8hrpwsAumYWPqEqdPRzJlYP41Bw +0YPqHbl17BiFvnhEB/Va2cASALPHgKIblYqQinVMi4KzTHeRSKDMMF3rFSPsCK/x +LQKAPwAAAChoZDAsZ3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvcHJv +Z3Jlc3NfaGlnaGxpZ2h0X2UucG5nAAkAAAANAAAAAwAAAAQAz6hu+IQILOIk7YoH +/QbfbXvIa6cLALpmFj6hKnT0cyZWD+NQcNGD6h25dewYhb54RAf1WtnAEgCzx4Ci +G5WKkIp1TIuCs0x3kUigzDBd6xUj7Aiv8S0CgD8AAAAoaGQwLGdwdDMpL3Vzci9z +aGFyZS9ncnViL3RoZW1lcy9VS1VJL3Byb2dyZXNzX2hpZ2hsaWdodF93LnBuZwAJ +AAAADQAAAAMAAAAEAPiwTs7R8O0Ti62woYWtk7a+hnpYCwDorwvieRBFzktFTRDc +L3GLTnEQtOtwqcq6hSBpN0xCHhIAV0hRbwTiNHcZycsI9Z8ld5NodHbX/NyoeE93 +Pup6GX8/AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS9w +cm9ncmVzc19oaWdobGlnaHRfYy5wbmcACQAAAA0AAAADAAAABACng8EoFl5rEVQI +iXLcmGRol5+z8wsAEVsiMTUzd7ogJNd5eu6HzzKiGzj6WpY3Cm2hYF1BL3kSADeJ +8hHhYS7ZVvXOkmsztS76n/LO8A5mfKmFwAxrDYK1NgAAAChoZDAsZ3B0MykvdXNy +L3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvbWVudV9ia2dfbncucG5nAAkAAAANAAAA +AwAAAAQAXjr8UlKweOI/F7W9VEflbYfh5h8LAMv0LxMbTTRAVc787ylb0ou/+grW +giK8B3mom2Kr+/m0EgAASuxBsaDxmjS12RtJyzo9wLMGqn6gyLLHpV5dGsDH9DYA +AAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL21lbnVfYmtn +X25lLnBuZwAJAAAADQAAAAMAAAAEAKVPWyOwpcOSr1keSLLE3SGbAfxrCwAbjXUi +5mhOgkn+k3k5izXEyFIzdGBk+V6xUlAT0mOkpRIALBWqNFAbnGCEAy3YS/N+m52z +85CYaAfChF14x/4OPT82AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVt +ZXMvVUtVSS9tZW51X2JrZ19zZS5wbmcACQAAAA0AAAADAAAABABvV0HJugAIX2sy +YaV875R8dA2qnAsALbcExEiWuqLC9U1EXwuIM/2KIjBRFeX7nj5Wm/HAE0gSAFYm +tYHQzUG7hqqMH9Vgahp5brS60GjHlOACpiVD1HRaNgAAAChoZDAsZ3B0MykvdXNy +L3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvbWVudV9ia2dfc3cucG5nAAkAAAANAAAA +AwAAAAQArSbjNnhXXyjFcRKv/XetFSyp8EYLANXIrifU+Tlk9RjrTcM1b/Gz0py8 +LugsTc8NxZGph5e0EgAk/++Kmu4VOnBoPckAehUWyR0EbTxijywhq4t2WivsuTUA +AAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL21lbnVfYmtn +X24ucG5nAAkAAAANAAAAAwAAAAQA9NZDgt4cSFAf08KYtoPJGBiz+e8LAB1qcWe7 +S6SEnPEr75lZcW02rr4ZGhXUVa5XeD3z2w5QEgB0HJcHT9H2QMwpP4ffkNoFtEtS +mUr+uiD09QMdlgjyszUAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1l +cy9VS1VJL21lbnVfYmtnX2UucG5nAAkAAAANAAAAAwAAAAQAVnZCQFKJdX63Bkg8 +CvQbHNpmFdALANfIeraAC4IwjvbjoLws/QHJcyblYpGt8MxGzuzg4029EgALNuu4 +wMpTgVPERqcQco+yU3uVoeigHYx9oeQP7IWcfjUAAAAoaGQwLGdwdDMpL3Vzci9z +aGFyZS9ncnViL3RoZW1lcy9VS1VJL21lbnVfYmtnX3MucG5nAAkAAAANAAAAAwAA +AAQAk6Lk5PBTURgPWm031yoF/rXq6r0LAFTcpvPIRw7ME0xNTFENpFUEzxQ3Bqtu +60i7adXkHAUzEgAMu5ZTRqLJ2421r3hwJjiNhBzOotMx/LLoyblA0oqkiTUAAAAo +aGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL21lbnVfYmtnX3cu +cG5nAAkAAAANAAAAAwAAAAQAW/7Xnckd1WVvKntElhY1tekNJdgLALzP61RaIsr3 +bY+UoNI0brIhCoTt0y7O8H36CCf1L/WnEgBIgBU0enSB7GrS5oJuA2KcpfuilQ/q +xB0O+tX1QChL9jUAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9V +S1VJL21lbnVfYmtnX2MucG5nAAkAAAANAAAAAwAAAAQAo6/dJVV7ABt4Frqf0q54 +AHEiEScLAFP4eu1AtEVkd4ff09Y0Wo0Qy/grwhnA1WVCTqjTVvUiEgBXkHiVBKrO +yxkxKdQhbvaRKVQIc/zVfTYpURIWaAitdTQAAAAoaGQwLGdwdDMpL3Vzci9zaGFy +ZS9ncnViL3RoZW1lcy9VS1VJL3NlbGVjdF9udy5wbmcACQAAAA0AAAADAAAABACj +r90lVXsAG3gWup/SrngAcSIRJwsAU/h67UC0RWR3h9/T1jRajRDL+CvCGcDVZUJO +qNNW9SISAFeQeJUEqs7LGTEp1CFu9pEpVAhz/NV9NilREhZoCK11NAAAAChoZDAs +Z3B0MykvdXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvc2VsZWN0X25lLnBuZwAJ +AAAADQAAAAMAAAAEAKOv3SVVewAbeBa6n9KueABxIhEnCwBT+HrtQLRFZHeH39PW +NFqNEMv4K8IZwNVlQk6o01b1IhIAV5B4lQSqzssZMSnUIW72kSlUCHP81X02KVES +FmgIrXU0AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS9z +ZWxlY3Rfc2UucG5nAAkAAAANAAAAAwAAAAQAo6/dJVV7ABt4Frqf0q54AHEiEScL +AFP4eu1AtEVkd4ff09Y0Wo0Qy/grwhnA1WVCTqjTVvUiEgBXkHiVBKrOyxkxKdQh +bvaRKVQIc/zVfTYpURIWaAitdTQAAAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnVi +L3RoZW1lcy9VS1VJL3NlbGVjdF9zdy5wbmcACQAAAA0AAAADAAAABAAk11o8Lfvh +WNy0yyFUlqU9dEmj3AsAKdiettNwcyjL1KLtRFg4JeCrUD5eOUAoR15224UelDMS +AMx8LKkaL5bePaX3YGWs0N+dvPd90eCpt9wvRZfPiCYRMwAAAChoZDAsZ3B0Mykv +dXNyL3NoYXJlL2dydWIvdGhlbWVzL1VLVUkvc2VsZWN0X24ucG5nAAkAAAANAAAA +AwAAAAQAHDs3645tuaAPTaiRYQ/gFDDG2SkLAEpFqDJL023+95rTbLX51nZlLAbH +1S+nGxeoP/H565LLEgAWfzOOI8uED2RCgGfNi7TPCITPtpoTO2edgnpY+kK9xjMA +AAAoaGQwLGdwdDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3NlbGVjdF9l +LnBuZwAJAAAADQAAAAMAAAAEACTXWjwt++FY3LTLIVSWpT10SaPcCwAp2J6203Bz +KMvUou1EWDgl4KtQPl45QChHXnbbhR6UMxIAzHwsqRovlt49pfdgZazQ3528933R +4Km33C9Fl8+IJhEzAAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMv +VUtVSS9zZWxlY3Rfcy5wbmcACQAAAA0AAAADAAAABAAcOzfrjm25oA9NqJFhD+AU +MMbZKQsASkWoMkvTbf73mtNstfnWdmUsBsfVL6cbF6g/8fnrkssSABZ/M44jy4QP +ZEKAZ82LtM8IhM+2mhM7Z52Celj6Qr3GMwAAAChoZDAsZ3B0MykvdXNyL3NoYXJl +L2dydWIvdGhlbWVzL1VLVUkvc2VsZWN0X3cucG5nAAkAAAANAAAAAwAAAAQAFsGU +++Ecl6Yhbv5HYekWfJEtIjgLAAq4BNCUFiwAGwA1fyOfEZK37JmvOByoiksQRnUE +SiyYEgAbYc44BgCTFoK4ucSDvX0Y/EcxUOjXEfG1FyNYXj0rJDMAAAAoaGQwLGdw +dDMpL3Vzci9zaGFyZS9ncnViL3RoZW1lcy9VS1VJL3NlbGVjdF9jLnBuZwAJAAAA +DQAAAAMAAAAEANLVvuGzNJB9fNxRl/uI/UkYvi1HCwAbaCPoaiSaVHEhSyLwPx58 +P10ZMk6X98LSBZpUsh9/YBIAGY7i54k9X8ZzzYYtPxninALKV+krZQh8QHiSopkg +hKU2AAAAKGhkMCxncHQzKS91c3Ivc2hhcmUvZ3J1Yi90aGVtZXMvVUtVSS9pY29u +cy9reWxpbi5wbmcACAAAAA0AAAADAAAABAD0ByQn3k5SWYRbVxNeSLGPF7Em7QsA +ai5RlanzQxE/yXApSAQsegVBma918IDTwlSDv4WmKQQSAIRAg7dQf0PXbCiorIuf +TOsHLYqPEXNlU6W4xkhbVnwrMgAAAGdydWJfY21kOiBzZXRwYXJhbXMgS3lsaW4g +VjEwIFNQMSDnmoTpq5jnuqfpgInpobkACAAAAA0AAAADAAAABAD7Cbzj0G1A8U6p +JHlePNz9pw9aIgsAgEBR0hokuL7iavbQD3txxSjqcLLbpOXkc0mvOq1iNtUSALo1 +Khy8vAWYbpgb7K2HZ+bP/fwsFBdOm6zmcU3YHp6FBwQAAGdydWJfY21kOiBtZW51 +ZW50cnkgS3lsaW4gVjEwIFNQMSwgNS40LjE4LTM1LWdlbmVyaWMgLS1jbGFzcyBr +eWxpbiAtLWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zIC0t +aWQgZ251bGludXgtNS40LjE4LTM1LWdlbmVyaWMtYWR2YW5jZWQtNjY4OWNmYmUt +N2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHsKCQlyZWNvcmRmYWlsCgkJbG9h +ZF92aWRlbwoJCWdmeG1vZGUgJGxpbnV4X2dmeF9tb2RlCgkJaW5zbW9kIGd6aW8K +CQlpZiBbIHgkZ3J1Yl9wbGF0Zm9ybSA9IHh4ZW4gXTsgdGhlbiBpbnNtb2QgeHpp +bzsgaW5zbW9kIGx6b3BpbzsgZmkKCQlpbnNtb2QgcGFydF9ncHQKCQlpbnNtb2Qg +ZXh0MgoJCXNldCByb290PSdoZDAsZ3B0MicKCQlpZiBbIHgkZmVhdHVyZV9wbGF0 +Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4KCQkgIHNlYXJjaCAtLW5vLWZs +b3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDAsZ3B0MiAt +LWhpbnQtZWZpPWhkMCxncHQyIC0taGludC1iYXJlbWV0YWw9YWhjaTAsZ3B0MiAg +ZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZWxzZQoJCSAg +c2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IGZjNTFiNTM5 +LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWZpCgkJZWNobwkn6L295YWl +IExpbnV4IDUuNC4xOC0zNS1nZW5lcmljIC4uLicKCQlsaW51eAkvdm1saW51ei01 +LjQuMTgtMzUtZ2VuZXJpYyByb290PVVVSUQ9NjY4OWNmYmUtN2MzYS00MzhiLTg2 +ZmQtMmQxMDM5ZDVkOWNhIHJvICBxdWlldCBzcGxhc2ggZGVmYXVsdF9odWdlcGFn +ZXN6PTFHIGh1Z2VwYWdlc3o9MUcgaHVnZXBhZ2VzPTEgbWVtX2VuY3J5cHQ9b2Zm +ICByZXN1bWU9VVVJRD02YTNhMTZlZi1jMDExLTQ5MTYtYjA3OC1jZTY5OWIyMTdm +ODAgYXVkaXQ9MCBzZWN1cml0eT1reXNlYwoJCWVjaG8JJ+i9veWFpeWIneWni+WM +luWGheWtmOebmC4uLicKCQlpbml0cmQJL2luaXRyZC5pbWctNS40LjE4LTM1LWdl +bmVyaWMKCX0ACAAAAA0AAAADAAAABAAxpAm0ncBC0y1AK4EKP1IxF3bmYgsA6jwz +vThRwgw5OMyyYQHRMMr04WyYB+nqU6SCwHeR7jwSAKSWLplDmjnjbLkeHBZDPdKL +jT55bu7dshwafMTnH1JznQMAAGdydWJfY21kOiBtZW51ZW50cnkgS3lsaW4gVjEw +IFNQMSwgNS40LjE4LTM1LWdlbmVyaWMgKHJlY292ZXJ5IG1vZGUpIC0tY2xhc3Mg +a3lsaW4gLS1jbGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAt +LWlkIGdudWxpbnV4LTUuNC4xOC0zNS1nZW5lcmljLXJlY292ZXJ5LTY2ODljZmJl +LTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYSB7CgkJcmVjb3JkZmFpbAoJCWxv +YWRfdmlkZW8KCQlpbnNtb2QgZ3ppbwoJCWlmIFsgeCRncnViX3BsYXRmb3JtID0g +eHhlbiBdOyB0aGVuIGluc21vZCB4emlvOyBpbnNtb2QgbHpvcGlvOyBmaQoJCWlu +c21vZCBwYXJ0X2dwdAoJCWluc21vZCBleHQyCgkJc2V0IHJvb3Q9J2hkMCxncHQy +JwoJCWlmIFsgeCRmZWF0dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsg +dGhlbgoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290 +IC0taGludC1iaW9zPWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50 +LWJhcmVtZXRhbD1haGNpMCxncHQyICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02 +NjcyZTRlZjNlMDcKCQllbHNlCgkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11 +dWlkIC0tc2V0PXJvb3QgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYz +ZTA3CgkJZmkKCQllY2hvCSfovb3lhaUgTGludXggNS40LjE4LTM1LWdlbmVyaWMg +Li4uJwoJCWxpbnV4CS92bWxpbnV6LTUuNC4xOC0zNS1nZW5lcmljIHJvb3Q9VVVJ +RD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gc2luZ2xl +IG5vbW9kZXNldCBkaXNfdWNvZGVfbGRyICBhdWRpdD0wIHNlY3VyaXR5PWt5c2Vj +CgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRyZAkv +aW5pdHJkLmltZy01LjQuMTgtMzUtZ2VuZXJpYwoJfQAIAAAADQAAAAMAAAAEAH9J +ZWZaKjulL4BR3mlvxlJv1rs9CwBotDUP6cTjfaCn9ybe4peiZgWcWok5y78F7uMT ++spSXxIAY+hvEiz8eV4JygYEqQVu9FbvmZoCpyD6VnHCeKK88q34AwAAZ3J1Yl9j +bWQ6IG1lbnVlbnRyeSBLeWxpbiBWMTAgU1AxLCA1LjQuMTgtdGttX29yaSAtLWNs +YXNzIGt5bGluIC0tY2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mg +b3MgLS1pZCBnbnVsaW51eC01LjQuMTgtdGttX29yaS1hZHZhbmNlZC02Njg5Y2Zi +ZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2EgewoJCXJlY29yZGZhaWwKCQls +b2FkX3ZpZGVvCgkJZ2Z4bW9kZSAkbGludXhfZ2Z4X21vZGUKCQlpbnNtb2QgZ3pp +bwoJCWlmIFsgeCRncnViX3BsYXRmb3JtID0geHhlbiBdOyB0aGVuIGluc21vZCB4 +emlvOyBpbnNtb2QgbHpvcGlvOyBmaQoJCWluc21vZCBwYXJ0X2dwdAoJCWluc21v +ZCBleHQyCgkJc2V0IHJvb3Q9J2hkMCxncHQyJwoJCWlmIFsgeCRmZWF0dXJlX3Bs +YXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgoJCSAgc2VhcmNoIC0tbm8t +ZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhkMCxncHQy +IC0taGludC1lZmk9aGQwLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQy +ICBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQllbHNlCgkJ +ICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgZmM1MWI1 +MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZmkKCQllY2hvCSfovb3l +haUgTGludXggNS40LjE4LXRrbV9vcmkgLi4uJwoJCWxpbnV4CS92bWxpbnV6LTUu +NC4xOC10a21fb3JpIHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0y +ZDEwMzlkNWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBkZWZhdWx0X2h1Z2VwYWdlc3o9 +MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1fZW5jcnlwdD1vZmYgIHJl +c3VtZT1VVUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1iMDc4LWNlNjk5YjIxN2Y4MCBh +dWRpdD0wIHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF +5a2Y55uYLi4uJwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtdGttX29yaQoJ +fQAIAAAADQAAAAMAAAAEAKStKW4Fgo1U+lxZSl9RUb8ldeE4CwATutrn2rzmRRTl +k3cKkOeHT5exxAN0cc11GGWkDolGZhIA0pnNfuf3j2fmcbCAOwij4Fa1NrxgZbvQ +NDl3l8dySg2OAwAAZ3J1Yl9jbWQ6IG1lbnVlbnRyeSBLeWxpbiBWMTAgU1AxLCA1 +LjQuMTgtdGttX29yaSAocmVjb3ZlcnkgbW9kZSkgLS1jbGFzcyBreWxpbiAtLWNs +YXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zIC0taWQgZ251bGlu +dXgtNS40LjE4LXRrbV9vcmktcmVjb3ZlcnktNjY4OWNmYmUtN2MzYS00MzhiLTg2 +ZmQtMmQxMDM5ZDVkOWNhIHsKCQlyZWNvcmRmYWlsCgkJbG9hZF92aWRlbwoJCWlu +c21vZCBnemlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4g +aW5zbW9kIHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0 +CgkJaW5zbW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZl +YXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFy +Y2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9 +aGQwLGdwdDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFo +Y2kwLGdwdDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJ +CWVsc2UKCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9v +dCBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVj +aG8JJ+i9veWFpSBMaW51eCA1LjQuMTgtdGttX29yaSAuLi4nCgkJbGludXgJL3Zt +bGludXotNS40LjE4LXRrbV9vcmkgcm9vdD1VVUlEPTY2ODljZmJlLTdjM2EtNDM4 +Yi04NmZkLTJkMTAzOWQ1ZDljYSBybyBzaW5nbGUgbm9tb2Rlc2V0IGRpc191Y29k +ZV9sZHIgIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hvCSfovb3lhaXliJ3l +p4vljJblhoXlrZjnm5guLi4nCgkJaW5pdHJkCS9pbml0cmQuaW1nLTUuNC4xOC10 +a21fb3JpCgl9AAgAAAANAAAAAwAAAAQAv9g+HaNzzxKOkA189TgJSre0Fi0LAPDY +X32D5QWc4O3oXpRnxkMn5LavQmAp+BUJk/jLVxlyEgCJwEuCcK05hZ6w1nYW+Ujv +Kg+WRPWpI8DFesicvmKKjggEAABncnViX2NtZDogbWVudWVudHJ5IEt5bGluIFYx +MCBTUDEsIDUuNC4xOC10a21fb3JpLm9sZCAtLWNsYXNzIGt5bGluIC0tY2xhc3Mg +Z251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgLS1pZCBnbnVsaW51eC01 +LjQuMTgtdGttX29yaS5vbGQtYWR2YW5jZWQtNjY4OWNmYmUtN2MzYS00MzhiLTg2 +ZmQtMmQxMDM5ZDVkOWNhIHsKCQlyZWNvcmRmYWlsCgkJbG9hZF92aWRlbwoJCWdm +eG1vZGUgJGxpbnV4X2dmeF9tb2RlCgkJaW5zbW9kIGd6aW8KCQlpZiBbIHgkZ3J1 +Yl9wbGF0Zm9ybSA9IHh4ZW4gXTsgdGhlbiBpbnNtb2QgeHppbzsgaW5zbW9kIGx6 +b3BpbzsgZmkKCQlpbnNtb2QgcGFydF9ncHQKCQlpbnNtb2QgZXh0MgoJCXNldCBy +b290PSdoZDAsZ3B0MicKCQlpZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hf +aGludCA9IHh5IF07IHRoZW4KCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1 +aWQgLS1zZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDAsZ3B0MiAtLWhpbnQtZWZpPWhk +MCxncHQyIC0taGludC1iYXJlbWV0YWw9YWhjaTAsZ3B0MiAgZmM1MWI1MzktZThh +Yi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3CgkJZWxzZQoJCSAgc2VhcmNoIC0tbm8t +ZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IGZjNTFiNTM5LWU4YWItNDAzYy04 +MDJkLTY2NzJlNGVmM2UwNwoJCWZpCgkJZWNobwkn6L295YWlIExpbnV4IDUuNC4x +OC10a21fb3JpLm9sZCAuLi4nCgkJbGludXgJL3ZtbGludXotNS40LjE4LXRrbV9v +cmkub2xkIHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlk +NWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBkZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVn +ZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1fZW5jcnlwdD1vZmYgIHJlc3VtZT1V +VUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1iMDc4LWNlNjk5YjIxN2Y4MCBhdWRpdD0w +IHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uY +Li4uJwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtdGttX29yaQoJfQAIAAAA +DQAAAAMAAAAEAJwVVMJ+wxBsMrVABTpaAsE8xzK8CwBWYjxp1xLIacuPtcKYFmi5 +ajbWpIb+8OHOJVbtBkI3DhIAazFyiJiSrFDqj/HYczA338EtLuLH4g72Tw/Xolqr ++JueAwAAZ3J1Yl9jbWQ6IG1lbnVlbnRyeSBLeWxpbiBWMTAgU1AxLCA1LjQuMTgt +dGttX29yaS5vbGQgKHJlY292ZXJ5IG1vZGUpIC0tY2xhc3Mga3lsaW4gLS1jbGFz +cyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWlkIGdudWxpbnV4 +LTUuNC4xOC10a21fb3JpLm9sZC1yZWNvdmVyeS02Njg5Y2ZiZS03YzNhLTQzOGIt +ODZmZC0yZDEwMzlkNWQ5Y2EgewoJCXJlY29yZGZhaWwKCQlsb2FkX3ZpZGVvCgkJ +aW5zbW9kIGd6aW8KCQlpZiBbIHgkZ3J1Yl9wbGF0Zm9ybSA9IHh4ZW4gXTsgdGhl +biBpbnNtb2QgeHppbzsgaW5zbW9kIGx6b3BpbzsgZmkKCQlpbnNtb2QgcGFydF9n +cHQKCQlpbnNtb2QgZXh0MgoJCXNldCByb290PSdoZDAsZ3B0MicKCQlpZiBbIHgk +ZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4KCQkgIHNl +YXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCAtLWhpbnQtYmlv +cz1oZDAsZ3B0MiAtLWhpbnQtZWZpPWhkMCxncHQyIC0taGludC1iYXJlbWV0YWw9 +YWhjaTAsZ3B0MiAgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0ZWYzZTA3 +CgkJZWxzZQoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1y +b290IGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWZpCgkJ +ZWNobwkn6L295YWlIExpbnV4IDUuNC4xOC10a21fb3JpLm9sZCAuLi4nCgkJbGlu +dXgJL3ZtbGludXotNS40LjE4LXRrbV9vcmkub2xkIHJvb3Q9VVVJRD02Njg5Y2Zi +ZS03YzNhLTQzOGItODZmZC0yZDEwMzlkNWQ5Y2Egcm8gc2luZ2xlIG5vbW9kZXNl +dCBkaXNfdWNvZGVfbGRyICBhdWRpdD0wIHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn +6L295YWl5Yid5aeL5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRyZAkvaW5pdHJkLmlt +Zy01LjQuMTgtdGttX29yaQoJfQAIAAAADQAAAAMAAAAEAGbS/zAlDwyKn41Fxs3t +qGCD7e+XCwDmOgMyVwdnAYosPC43OI8UHo276GAPq7qGNgFa9RIEExIALR8mKDCl +MUXC5zmNAePzoVjxJxbcRGm3fyDMiWfIqwbkAwAAZ3J1Yl9jbWQ6IG1lbnVlbnRy +eSBLeWxpbiBWMTAgU1AxLCA1LjQuMTgtdGttIC0tY2xhc3Mga3lsaW4gLS1jbGFz +cyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWlkIGdudWxpbnV4 +LTUuNC4xOC10a20tYWR2YW5jZWQtNjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQx +MDM5ZDVkOWNhIHsKCQlyZWNvcmRmYWlsCgkJbG9hZF92aWRlbwoJCWdmeG1vZGUg +JGxpbnV4X2dmeF9tb2RlCgkJaW5zbW9kIGd6aW8KCQlpZiBbIHgkZ3J1Yl9wbGF0 +Zm9ybSA9IHh4ZW4gXTsgdGhlbiBpbnNtb2QgeHppbzsgaW5zbW9kIGx6b3Bpbzsg +ZmkKCQlpbnNtb2QgcGFydF9ncHQKCQlpbnNtb2QgZXh0MgoJCXNldCByb290PSdo +ZDAsZ3B0MicKCQlpZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGludCA9 +IHh5IF07IHRoZW4KCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1z +ZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDAsZ3B0MiAtLWhpbnQtZWZpPWhkMCxncHQy +IC0taGludC1iYXJlbWV0YWw9YWhjaTAsZ3B0MiAgZmM1MWI1MzktZThhYi00MDNj +LTgwMmQtNjY3MmU0ZWYzZTA3CgkJZWxzZQoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5 +IC0tZnMtdXVpZCAtLXNldD1yb290IGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2 +NzJlNGVmM2UwNwoJCWZpCgkJZWNobwkn6L295YWlIExpbnV4IDUuNC4xOC10a20g +Li4uJwoJCWxpbnV4CS92bWxpbnV6LTUuNC4xOC10a20gcm9vdD1VVUlEPTY2ODlj +ZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYSBybyAgcXVpZXQgc3BsYXNo +IGRlZmF1bHRfaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXN6PTFHIGh1Z2VwYWdlcz0x +IG1lbV9lbmNyeXB0PW9mZiAgcmVzdW1lPVVVSUQ9NmEzYTE2ZWYtYzAxMS00OTE2 +LWIwNzgtY2U2OTliMjE3ZjgwIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hv +CSfovb3lhaXliJ3lp4vljJblhoXlrZjnm5guLi4nCgkJaW5pdHJkCS9pbml0cmQu +aW1nLTUuNC4xOC10a20KCX0ACAAAAA0AAAADAAAABAA9qlGpeTrqANhc+uTBgIx6 +eE2wFgsAcdHD2CnzlCaJUVacu4Yv9x015mT5qjTF+bssNx5GjyUSAK+IoVcIvfJm +spy0xy02/6XSpIQcftr9TpKlU9bYKUaCegMAAGdydWJfY21kOiBtZW51ZW50cnkg +S3lsaW4gVjEwIFNQMSwgNS40LjE4LXRrbSAocmVjb3ZlcnkgbW9kZSkgLS1jbGFz +cyBreWxpbiAtLWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9z +IC0taWQgZ251bGludXgtNS40LjE4LXRrbS1yZWNvdmVyeS02Njg5Y2ZiZS03YzNh +LTQzOGItODZmZC0yZDEwMzlkNWQ5Y2EgewoJCXJlY29yZGZhaWwKCQlsb2FkX3Zp +ZGVvCgkJaW5zbW9kIGd6aW8KCQlpZiBbIHgkZ3J1Yl9wbGF0Zm9ybSA9IHh4ZW4g +XTsgdGhlbiBpbnNtb2QgeHppbzsgaW5zbW9kIGx6b3BpbzsgZmkKCQlpbnNtb2Qg +cGFydF9ncHQKCQlpbnNtb2QgZXh0MgoJCXNldCByb290PSdoZDAsZ3B0MicKCQlp +ZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4K +CQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCAtLWhp +bnQtYmlvcz1oZDAsZ3B0MiAtLWhpbnQtZWZpPWhkMCxncHQyIC0taGludC1iYXJl +bWV0YWw9YWhjaTAsZ3B0MiAgZmM1MWI1MzktZThhYi00MDNjLTgwMmQtNjY3MmU0 +ZWYzZTA3CgkJZWxzZQoJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAt +LXNldD1yb290IGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJ +CWZpCgkJZWNobwkn6L295YWlIExpbnV4IDUuNC4xOC10a20gLi4uJwoJCWxpbnV4 +CS92bWxpbnV6LTUuNC4xOC10a20gcm9vdD1VVUlEPTY2ODljZmJlLTdjM2EtNDM4 +Yi04NmZkLTJkMTAzOWQ1ZDljYSBybyBzaW5nbGUgbm9tb2Rlc2V0IGRpc191Y29k +ZV9sZHIgIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMKCQllY2hvCSfovb3lhaXliJ3l +p4vljJblhoXlrZjnm5guLi4nCgkJaW5pdHJkCS9pbml0cmQuaW1nLTUuNC4xOC10 +a20KCX0ACAAAAA0AAAADAAAABADcgM/1k4C/xovb6FwBkfqd6Zr/NQsA4a9JjIid +zWneHewak7usay2vVrIMMWVZcgxey2PrrDsSAKWmSDLJ7Dl9QbVWbrv4JX8Yv7A5 +57+5fq+A4fRDBqQ25AMAAGdydWJfY21kOiBtZW51ZW50cnkgS3lsaW4gVjEwIFNQ +MSwgNS40LjE4LWNzdiAtLWNsYXNzIGt5bGluIC0tY2xhc3MgZ251LWxpbnV4IC0t +Y2xhc3MgZ251IC0tY2xhc3Mgb3MgLS1pZCBnbnVsaW51eC01LjQuMTgtY3N2LWFk +dmFuY2VkLTY2ODljZmJlLTdjM2EtNDM4Yi04NmZkLTJkMTAzOWQ1ZDljYSB7CgkJ +cmVjb3JkZmFpbAoJCWxvYWRfdmlkZW8KCQlnZnhtb2RlICRsaW51eF9nZnhfbW9k +ZQoJCWluc21vZCBnemlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07 +IHRoZW4gaW5zbW9kIHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBh +cnRfZ3B0CgkJaW5zbW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYg +WyB4JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJ +ICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50 +LWJpb3M9aGQwLGdwdDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1l +dGFsPWFoY2kwLGdwdDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVm +M2UwNwoJCWVsc2UKCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1z +ZXQ9cm9vdCBmYzUxYjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlm +aQoJCWVjaG8JJ+i9veWFpSBMaW51eCA1LjQuMTgtY3N2IC4uLicKCQlsaW51eAkv +dm1saW51ei01LjQuMTgtY3N2IHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGIt +ODZmZC0yZDEwMzlkNWQ5Y2Egcm8gIHF1aWV0IHNwbGFzaCBkZWZhdWx0X2h1Z2Vw +YWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1fZW5jcnlwdD1v +ZmYgIHJlc3VtZT1VVUlEPTZhM2ExNmVmLWMwMTEtNDkxNi1iMDc4LWNlNjk5YjIx +N2Y4MCBhdWRpdD0wIHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL +5YyW5YaF5a2Y55uYLi4uJwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtY3N2 +Cgl9AAgAAAANAAAAAwAAAAQAjWdefpSZqeezEPd634h2CdgowB8LAAyodg73+xWw +Ki2tBRb9Ttcn9XMPdWMZvEY2Ht7R6SSCEgBRQy4alaGkfRJKwgsaHaRtW4vJbMod +aoe6LyF6yEOjQHoDAABncnViX2NtZDogbWVudWVudHJ5IEt5bGluIFYxMCBTUDEs +IDUuNC4xOC1jc3YgKHJlY292ZXJ5IG1vZGUpIC0tY2xhc3Mga3lsaW4gLS1jbGFz +cyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWlkIGdudWxpbnV4 +LTUuNC4xOC1jc3YtcmVjb3ZlcnktNjY4OWNmYmUtN2MzYS00MzhiLTg2ZmQtMmQx +MDM5ZDVkOWNhIHsKCQlyZWNvcmRmYWlsCgkJbG9hZF92aWRlbwoJCWluc21vZCBn +emlvCgkJaWYgWyB4JGdydWJfcGxhdGZvcm0gPSB4eGVuIF07IHRoZW4gaW5zbW9k +IHh6aW87IGluc21vZCBsem9waW87IGZpCgkJaW5zbW9kIHBhcnRfZ3B0CgkJaW5z +bW9kIGV4dDIKCQlzZXQgcm9vdD0naGQwLGdwdDInCgkJaWYgWyB4JGZlYXR1cmVf +cGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJICBzZWFyY2ggLS1u +by1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQwLGdw +dDIgLS1oaW50LWVmaT1oZDAsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kwLGdw +dDIgIGZjNTFiNTM5LWU4YWItNDAzYy04MDJkLTY2NzJlNGVmM2UwNwoJCWVsc2UK +CQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmYzUx +YjUzOS1lOGFiLTQwM2MtODAyZC02NjcyZTRlZjNlMDcKCQlmaQoJCWVjaG8JJ+i9 +veWFpSBMaW51eCA1LjQuMTgtY3N2IC4uLicKCQlsaW51eAkvdm1saW51ei01LjQu +MTgtY3N2IHJvb3Q9VVVJRD02Njg5Y2ZiZS03YzNhLTQzOGItODZmZC0yZDEwMzlk +NWQ5Y2Egcm8gc2luZ2xlIG5vbW9kZXNldCBkaXNfdWNvZGVfbGRyICBhdWRpdD0w +IHNlY3VyaXR5PWt5c2VjCgkJZWNobwkn6L295YWl5Yid5aeL5YyW5YaF5a2Y55uY +Li4uJwoJCWluaXRyZAkvaW5pdHJkLmltZy01LjQuMTgtY3N2Cgl9AAgAAAANAAAA +AwAAAAQA0Cq5PY/APR7cQ92SyQ1zDTAIx7ALAFUiPUUfl1dZ2wGVEXPLy9c3ZKpo +pyssiJxBqvetoVHmEgABRTW15itStuohXZmhnNH315+gUBs3p5KI+WIBjUKVhi4A +AABncnViX2NtZDogc2V0cGFyYW1zIEt5bGluIFYxMCBTUDEsIDUuNC4xOC1jc3YA +CAAAAA0AAAADAAAABACY0Gb4/9BGuss4sQYYjL5/6a2nKQsApX4Gfihu/E7qiWWd +QPE6OMwXkuQne+2CDe1nTJS/Lq0SAGSsqEVdFAzMXwRuLbNPKDdHOYrhS+ZBSMgw +RdMfdyLUFQAAAGdydWJfY21kOiByZWNvcmRmYWlsAAgAAAANAAAAAwAAAAQAusFw +hf71BDZipQzvGL82aETAdP8LAGS9qPZbFYXXhoJIopLESWYMyPdQdcENh65ZpNtA +HOEZEgCJB/N29pmas13OBtEhMWnXxfOc6MI2RCeMoUx1BFYZbhsAAABncnViX2Nt +ZDogc2V0IHJlY29yZGZhaWw9MQAIAAAADQAAAAMAAAAEAHqGAJ3B8jhn2JUbuVRx +YYveLRkYCwAkNq/jyxgUVKuAfWylJu0xMtwXWXh/ntPy8UjoaUjpeBIAXYS7iLk9 +Nz2OHkKjHxSqtSxus74O5o+hDK0MnNQ46tsSAAAAZ3J1Yl9jbWQ6IFsgLW4gIF0A +CAAAAA0AAAADAAAABACP5Z5m1uwZhCBHfyT3kekp8VPhRAsAdiar2L50QsLldTZK +PpXLOjtTPFivu6QC0r2r3/hdKccSAAeRC3qRsUKDOoArzKyntyWDX8AG0ilHQTru +BVmfNXMWFQAAAGdydWJfY21kOiBsb2FkX3ZpZGVvAAgAAAANAAAAAwAAAAQA9bBn +5ZwWP2exm4NvvunopIehnN0LAEVoNh+3WBsxpC1kWrU0MC+590Ktqje3/eFSIV1p +4ln7EgBJraCnDXO9KW/3jIOHyYT0PAOtMJPFJBl2925kGf15XBYAAABncnViX2Nt +ZDogWyB4eSA9IHh5IF0ACAAAAA0AAAADAAAABABZztNDsGC331T6e6JR74d5QGAe +5AsA1xNT9TaOssEoBZCSgSiXm9luqNsejIFJP3h4ODt2qzsSAPCuKf8NGKYeSMdz +vwj1laA9+/VKcO83zNTH7LgO82WnGwAAAGdydWJfY21kOiBpbnNtb2QgYWxsX3Zp +ZGVvAAgAAAANAAAAAwAAAAQAE60ajd9kfIFI8XObYIHXg4gWtZ8LAC+oBl2e4wk4 +TTX41TAYa3dtJuG7VjL4mkbVbpOxQCgrEgBQu039M/+QlP8IgDXDwzjZowStSzbx +CIK3zPps8EzElRcAAABncnViX2NtZDogZ2Z4bW9kZSBrZWVwAAgAAAANAAAAAwAA +AAQALhxnbd2bFvDXIM1cZthXMt57d7YLABWlAYsBd8+cScC5eRHfZ+fywZPTYT4/ +xMnrmKK10G/MEgCniW8dSPi+GohzRJhPnoZv1wOl2dzMr2eP/ZKm7SrP5x4AAABn +cnViX2NtZDogc2V0IGdmeHBheWxvYWQ9a2VlcAAIAAAADQAAAAMAAAAEALpQnKOC +EPBoPEd8ncQOTE9lPh37CwBsRnTUxlLuZ7mKYgbXVBzL8tXcChja4xrWboLHlMSX +hBIAJ6EDTah33TUI664SCsQwLjsbHTLzVY/76CSDN0EU85UWAAAAZ3J1Yl9jbWQ6 +IGluc21vZCBnemlvAAgAAAANAAAAAwAAAAQALehF3OilHI/duqBGhnYAkzJbdWkL +ABiGVGjy5L2fDMT/3aEzX0BdBt+Nb/GDs3P1DgjoH5JNEgA9QTafZvLt2MwVj7ce +xJ23AiBoEaMh2TSp4Azxr/B14BoAAABncnViX2NtZDogWyB4ZWZpID0geHhlbiBd +AAgAAAANAAAAAwAAAAQApOHG9QV5tHyWQRHR6iFw5vkjyUELAGLNdtMco9ENdC5G +xv8XEEbOGd2Q82GoJ/7GVx5ZwkeUEgCQj2JiFB82Zdf73hlV4Fe2+ZM3za17+s9v +dYU9rx2PpBoAAABncnViX2NtZDogaW5zbW9kIHBhcnRfZ3B0AAgAAAANAAAAAwAA +AAQArz8Hq6yeXFa4LwmrmDKJBaq79u8LALg4pNKGDIEFgQX7sZB6H7f2C2VZGwmb +OwANmzHY0vsgEgCIG7misbEg9fcfHP3ZYd08L2Vr8OAvcDJysP/wLkovMhYAAABn +cnViX2NtZDogaW5zbW9kIGV4dDIACAAAAA0AAAADAAAABACsNEEaPnhkwh+GVD3B +Z1X/TSQtegsAF7LDHq/HWkO/Ioee/PguSj0m4hLX1zNhyeB1XDevrPcSAMygGKoo +Lh5m1NBB78MOtt6W80xAPuGJCM2Jk61ydqtBHAAAAGdydWJfY21kOiBzZXQgcm9v +dD1oZDAsZ3B0MgAIAAAADQAAAAMAAAAEAPWwZ+WcFj9nsZuDb77p6KSHoZzdCwBF +aDYft1gbMaQtZFq1NDAvufdCrao3t/3hUiFdaeJZ+xIASa2gpw1zvSlv94yDh8mE +9DwDrTCTxSQZdvduZBn9eVwWAAAAZ3J1Yl9jbWQ6IFsgeHkgPSB4eSBdAAgAAAAN +AAAAAwAAAAQACLDoCKlOzMdChbcLGvQfBMFTuGcLALlL6DFp9VaxzQuEl1iTFSaD +t7ZE2VOM+iSS2xAnpHB1EgDgDEkmSJ/aKaaQEC4CCRWWgGvMfxuV0Ul+c8u/tqF6 +9JwAAABncnViX2NtZDogc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNl +dD1yb290IC0taGludC1iaW9zPWhkMCxncHQyIC0taGludC1lZmk9aGQwLGdwdDIg +LS1oaW50LWJhcmVtZXRhbD1haGNpMCxncHQyIGZjNTFiNTM5LWU4YWItNDAzYy04 +MDJkLTY2NzJlNGVmM2UwNwAIAAAADQAAAAMAAAAEAD3wdZ0Ci8YrCYrPYDt6+8+S +NPy1CwCZSykjPgzTzCU7mfrbvP4PqDVWO4Nx/1XbyFXaqnvgzxIAa85gxulLn7DV +XbCEY8sMP0qChGVmTbvS34NHg1a3+6grAAAAZ3J1Yl9jbWQ6IGVjaG8g6L295YWl +IExpbnV4IDUuNC4xOC1jc3YgLi4uAAkAAAANAAAAAwAAAAQA7/XfuTKUWWPYd8VU +YSRrboUKR4sLACbi7WsibJZGbd4k5vvviX4vbLsuRsDLfY47ZBCu2iy4EgCLqXH9 +u/Ju8cSqfjIHspKxQBNWyB24IkOVXoQgVMHg1ykAAAAoaGQwLGdwdDEpL2Jvb3Qv +Z3J1Yi94ODZfNjQtZWZpL2VjaG8ubW9kAAgAAAANAAAAAwAAAAQA3KkQMCNuaMCO +iqch+wchyyPu3sMLABZIVeZU+/vk1pabOnIjTu2OwuT+EgVjvOggoTFAc+Z+EgCd +I53xddnsHBbfQXq6dMLFxTT7dmB3RWhwQY9VmoC5LesAAABncnViX2NtZDogbGlu +dXggL3ZtbGludXotNS40LjE4LWNzdiByb290PVVVSUQ9NjY4OWNmYmUtN2MzYS00 +MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHJvIHF1aWV0IHNwbGFzaCBkZWZhdWx0X2h1 +Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBtZW1fZW5jcnlw +dD1vZmYgcmVzdW1lPVVVSUQ9NmEzYTE2ZWYtYzAxMS00OTE2LWIwNzgtY2U2OTli +MjE3ZjgwIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMACQAAAA0AAAADAAAABADpzyd8 +7v42M3ohmL7bKueEF948bAsA4qF0YNX45QhsnuRDemLfEhXtw+Lnp/n2BcCgMdpO +evESAJ+sGRic+FZJ32B43G6AU6U16i5wTc5Ht5f4w9InEOVtKgAAAChoZDAsZ3B0 +MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvbGludXgubW9kAAkAAAANAAAAAwAAAAQA +fCRA9WLik3+DurLfyuDhQ1cHWfQLAA8U8MFXVATCwYmIFXnTR8j1nra1bnGO1MLz +CsCfzgDeEgAl+rg5vzpwd2btr9z9PE5LvAQFU+q2wWfZa6QBzEQi/S4AAAAoaGQw +LGdwdDEpL2Jvb3QvZ3J1Yi94ODZfNjQtZWZpL3JlbG9jYXRvci5tb2QACQAAAA0A +AAADAAAABAAuakEHyPWViSFUKpUeb4IpbHXAwgsAyOggXMWzTvunI8BmD+iys12C +c14O2NPCMRWPVmBblzYSAFGwS3HxPTqEMiXB+vnYyEscWsnOLnqB4GwBOWPen6NM +KQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvbW1hcC5tb2QACQAA +AA0AAAADAAAABABgMMQbmD1iMIHuooycxWHeK2dbQwsApCHgjzVzBMUhx1+xtQqT +nbZc4eICf2+yCgyqM45qecQSADCFvMWLjDGRjrgWWRPdFpR+HvtMGUbYoAYIOcnQ +rZ8sLQAAAChoZDAsZ3B0MSkvYm9vdC9ncnViL3g4Nl82NC1lZmkvbGludXhlZmku +bW9kAAkAAAANAAAAAwAAAAQAV0xlAEJz4EyBRwZsIbp1jbPgt6QLAGYflDeDqoOD +C0kYAos3h2iS0gh4snKDz5yGZYW0CRNwEgA3a0J15FztbUN/WvEEGqYJJDGndxE8 +VXhqu6RwmK1wsxQAAAAvdm1saW51ei01LjQuMTgtY3N2AAgAAAANAAAAAwAAAAQA +JjrJrXUFWdCkLT8dlwtVomb/fzwLABHQaJBmPk9AfYu9yULICRkpN+vQE02hFwNq +EBg9QSdNEgAOIPa1D84Q0N99nm+/U2cP6zbIFri8roUi/VRbTGvYUOsAAABrZXJu +ZWxfY21kbGluZTogL3ZtbGludXotNS40LjE4LWNzdiByb290PVVVSUQ9NjY4OWNm +YmUtN2MzYS00MzhiLTg2ZmQtMmQxMDM5ZDVkOWNhIHJvIHF1aWV0IHNwbGFzaCBk +ZWZhdWx0X2h1Z2VwYWdlc3o9MUcgaHVnZXBhZ2Vzej0xRyBodWdlcGFnZXM9MSBt +ZW1fZW5jcnlwdD1vZmYgcmVzdW1lPVVVSUQ9NmEzYTE2ZWYtYzAxMS00OTE2LWIw +NzgtY2U2OTliMjE3ZjgwIGF1ZGl0PTAgc2VjdXJpdHk9a3lzZWMACAAAAA0AAAAD +AAAABAC/hvcdBkhxjl2+ZJiqBuxEKpskRgsAG9EMQ82y5nVDthS7D1yM1d3SCsxj +qfdna8gylS37OGASAG/0sItqAvaP8k/EcDOtqaHIWpKPkbsATWr+eKLQUiw2KwAA +AGdydWJfY21kOiBlY2hvIOi9veWFpeWIneWni+WMluWGheWtmOebmC4uLgAIAAAA +DQAAAAMAAAAEAGcaiXLr+P/uLenWBj5xr6Mwi+y/CwAXOFqmbLowFNuv8htW4pOT +bVTXL8C7T3hrj5TstRyEqRIAqlzkaS6bJfmugPhLMN09TMmUEendFgaZ467R6pep +TDUoAAAAZ3J1Yl9jbWQ6IGluaXRyZCAvaW5pdHJkLmltZy01LjQuMTgtY3N2AAkA +AAANAAAAAwAAAAQAFi6/EDL6ctnKcjgBa+eK7gvr2KoLAGWXykP7KaqH6jnc4Ndk +n7Fy2yWKu4vG2uJ8Huf2Fi5uEgCv4Nvq6VcJlE5XQ22aI/nNaqsrbR9Mqr/UC1Ax +72MrMxcAAAAvaW5pdHJkLmltZy01LjQuMTgtY3N2AAUAAAAHAACAAwAAAAQARDpr +e4K3r1ZPLjk82dWjiLf6SpgLANgEPWt7ha01jrO2rmqHOrfvI6JjUsXcT6pa7trP +XrQbEgB/UC+7//tNhL9tx0P79ZyLyJzPkN3K4iGWtSuaMkfdHx0AAABFeGl0IEJv +b3QgU2VydmljZXMgSW52b2NhdGlvbgUAAAAHAACAAwAAAAQAR1VF3cl417/QNvrM +fi6Yf0gYnw0LALVPdULL2HKoGp2d6oObK410fH69XqZhXED0L0Sm2+ugEgCUlJ4M +fh6D5GCcH1B3sFAPK2ONnKX8fS/9g2KDylEfoygAAABFeGl0IEJvb3QgU2Vydmlj +ZXMgUmV0dXJuZWQgd2l0aCBTdWNjZXNz diff --git a/test/unit/fapi-eventlog.c b/test/unit/fapi-eventlog.c index 86da57b48..1063eecd6 100644 --- a/test/unit/fapi-eventlog.c +++ b/test/unit/fapi-eventlog.c @@ -28,6 +28,7 @@ #include "ifapi_json_serialize.h" #include "ifapi_json_deserialize.h" #include "fapi_policy.h" +#include "ifapi_helpers.h" #include "util/aux_util.h" @@ -130,6 +131,65 @@ check_eventlog(const char *file, uint32_t *pcr_list, size_t pcr_list_size, int n SAFE_FREE(eventlog); } +static void +check_eventlog_pcr0(const char *file, uint32_t *pcr_list, size_t pcr_list_size, int n_events) +{ + TSS2_RC r; + uint8_t *eventlog; + size_t size; + json_object *json_event_list = NULL; + size_t n_pcrs; + IFAPI_PCR_REG pcrs[TPM2_MAX_PCRS]; + + TPML_PCR_SELECTION pcr_selection = + { + .count = 1, + .pcrSelections = + { + { + .hash = TPM2_ALG_SHA1, + .sizeofSelect = 3, + .pcrSelect = { 1, 0, 0 } }, + }}; + + TPM2B_DIGEST expected_pcr0 = + { + .size = 20, + .buffer = { 0x15, 0xf4, 0xe6, 0xca, 0x45, 0x7d, 0x1a, 0xf6, 0xbc, 0x49, + 0x51, 0x1a, 0x93, 0xba, 0x35, 0x00, 0xad, 0x69, 0xac, 0xc5 }, + }; + + /* Read file to get file size for comparison. */ + eventlog = file_to_buffer(file, &size); + assert_non_null(eventlog); + + r = ifapi_get_tcg_firmware_event_list(file, pcr_list, pcr_list_size, &json_event_list); + assert_int_equal (r, TSS2_RC_SUCCESS); + + r = ifapi_calculate_pcrs(json_event_list, &pcr_selection, &pcrs[0], &n_pcrs); + assert_int_equal (r, TSS2_RC_SUCCESS); + + /* Compare with the pcr0 value got from system with HCRTM events */ + assert_true(!memcmp(&expected_pcr0.buffer[0], &pcrs[0].value.buffer[0], 20)); + + json_object_put(json_event_list); + SAFE_FREE(eventlog); +} + +static void +check_bios_hcrtm(void **state) +{ + +#ifdef __FreeBSD__ + /* Free BSD does not support SM3 hashalg */ + skip(); +#endif + check_eventlog_pcr0("test/data/fapi/eventlog/binary_measurements_hcrtm.bin", &pcr_list[0], 9, 111); + check_eventlog("test/data/fapi/eventlog/binary_measurements_hcrtm.bin", &pcr_list[0], 1, 5); + check_eventlog("test/data/fapi/eventlog/binary_measurements_hcrtm.bin", &pcr_list[0], 9, 111); + check_eventlog("test/data/fapi/eventlog/binary_measurements_hcrtm.bin", NULL, 0, 0); +} + static void check_bios_nuc(void **state) { @@ -142,7 +202,7 @@ static void check_bios_pc_client(void **state) { check_eventlog("test/data/fapi/eventlog/binary_measurements_pc_client.bin", &pcr_list[0], 1, 5); - check_eventlog("test/data/fapi/eventlog/binary_measurements_pc_client.bin", &pcr_list[0], 3, 17); + check_eventlog("test/data/fapi/eventlog/binary_measurements_pc_client.bin", &pcr_list[0], 9, 31); check_eventlog("test/data/fapi/eventlog/binary_measurements_pc_client.bin", NULL, 0, 0); } @@ -185,6 +245,7 @@ main(int argc, char *argv[]) } const struct CMUnitTest tests[] = { + cmocka_unit_test(check_bios_hcrtm), cmocka_unit_test(check_bios_nuc), cmocka_unit_test(check_bios_pc_client), cmocka_unit_test(check_event_uefiservices),