From: Tomas Vondra Date: Sat, 12 Sep 2020 15:07:04 +0200 Subject: [PATCH 1/8] Pass all scan keys to BRIN consistent function at once Passing all scan keys to the BRIN consistent function at once may allow elimination of additional ranges, which would be impossible when only passing individual scan keys. The code continues to support both the original (one scan key at a time) and new (all scan keys at once) approaches, depending on whether the consistent function accepts three or four arguments. This modifies the existing BRIN opclasses (minmax, inclusion) although those don't really benefit from this change. The primary purpose of this is to allow more advanced opclases in the future. Author: Tomas Vondra Reviewed-by: Alvaro Herrera Reviewed-by: Mark Dilger Reviewed-by: Alexander Korotkov Discussion: https://postgr.es/m/c1138ead-7668-f0e1-0638-c3be3237e812@2ndquadrant.com --- src/backend/access/brin/brin.c | 150 +++++++++++++++----- src/backend/access/brin/brin_inclusion.c | 170 +++++++++++++++-------- src/backend/access/brin/brin_minmax.c | 121 +++++++++++----- src/backend/access/brin/brin_validate.c | 4 +- src/include/catalog/pg_proc.dat | 4 +- 5 files changed, 324 insertions(+), 125 deletions(-) diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c index 1f72562c60..ccf609e799 100644 --- a/src/backend/access/brin/brin.c +++ b/src/backend/access/brin/brin.c @@ -389,6 +389,9 @@ bringetbitmap(IndexScanDesc scan, TIDBitmap *tbm) BrinMemTuple *dtup; BrinTuple *btup = NULL; Size btupsz = 0; + ScanKey **keys; + int *nkeys; + int keyno; opaque = (BrinOpaque *) scan->opaque; bdesc = opaque->bo_bdesc; @@ -410,6 +413,61 @@ bringetbitmap(IndexScanDesc scan, TIDBitmap *tbm) */ consistentFn = palloc0(sizeof(FmgrInfo) * bdesc->bd_tupdesc->natts); + /* + * Make room for per-attribute lists of scan keys that we'll pass to the + * consistent support procedure. + */ + keys = palloc0(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts); + nkeys = palloc0(sizeof(int) * bdesc->bd_tupdesc->natts); + + /* + * Preprocess the scan keys - split them into per-attribute arrays. + */ + for (keyno = 0; keyno < scan->numberOfKeys; keyno++) + { + ScanKey key = &scan->keyData[keyno]; + AttrNumber keyattno = key->sk_attno; + + /* + * The collation of the scan key must match the collation + * used in the index column (but only if the search is not + * IS NULL/ IS NOT NULL). Otherwise we shouldn't be using + * this index ... + */ + Assert((key->sk_flags & SK_ISNULL) || + (key->sk_collation == + TupleDescAttr(bdesc->bd_tupdesc, + keyattno - 1)->attcollation)); + + /* First time we see this index attribute, so init as needed. */ + if (!keys[keyattno-1]) + { + FmgrInfo *tmp; + + /* + * This is a bit of an overkill - we don't know how many + * scan keys are there for this attribute, so we simply + * allocate the largest number possible. This may waste + * a bit of memory, but we only expect small number of + * scan keys in general, so this should be negligible, + * and it's cheaper than having to repalloc repeatedly. + */ + keys[keyattno - 1] = palloc0(sizeof(ScanKey) * scan->numberOfKeys); + + /* First time this column, so look up consistent function */ + Assert(consistentFn[keyattno - 1].fn_oid == InvalidOid); + + tmp = index_getprocinfo(idxRel, keyattno, + BRIN_PROCNUM_CONSISTENT); + fmgr_info_copy(&consistentFn[keyattno - 1], tmp, + CurrentMemoryContext); + } + + /* Add key to the per-attribute array. */ + keys[keyattno - 1][nkeys[keyattno - 1]] = key; + nkeys[keyattno - 1]++; + } + /* allocate an initial in-memory tuple, out of the per-range memcxt */ dtup = brin_new_memtuple(bdesc); @@ -470,7 +528,7 @@ bringetbitmap(IndexScanDesc scan, TIDBitmap *tbm) } else { - int keyno; + int attno; /* * Compare scan keys with summary values stored for the range. @@ -480,51 +538,75 @@ bringetbitmap(IndexScanDesc scan, TIDBitmap *tbm) * no keys. */ addrange = true; - for (keyno = 0; keyno < scan->numberOfKeys; keyno++) + for (attno = 1; attno <= bdesc->bd_tupdesc->natts; attno++) { - ScanKey key = &scan->keyData[keyno]; - AttrNumber keyattno = key->sk_attno; - BrinValues *bval = &dtup->bt_columns[keyattno - 1]; + BrinValues *bval; Datum add; - /* - * The collation of the scan key must match the collation - * used in the index column (but only if the search is not - * IS NULL/ IS NOT NULL). Otherwise we shouldn't be using - * this index ... - */ - Assert((key->sk_flags & SK_ISNULL) || - (key->sk_collation == - TupleDescAttr(bdesc->bd_tupdesc, - keyattno - 1)->attcollation)); + /* skip attributes without any san keys */ + if (nkeys[attno - 1] == 0) + continue; - /* First time this column? look up consistent function */ - if (consistentFn[keyattno - 1].fn_oid == InvalidOid) - { - FmgrInfo *tmp; + bval = &dtup->bt_columns[attno - 1]; - tmp = index_getprocinfo(idxRel, keyattno, - BRIN_PROCNUM_CONSISTENT); - fmgr_info_copy(&consistentFn[keyattno - 1], tmp, - CurrentMemoryContext); - } + Assert((nkeys[attno - 1] > 0) && + (nkeys[attno - 1] <= scan->numberOfKeys)); /* * Check whether the scan key is consistent with the page * range values; if so, have the pages in the range added * to the output bitmap. * - * When there are multiple scan keys, failure to meet the - * criteria for a single one of them is enough to discard - * the range as a whole, so break out of the loop as soon - * as a false return value is obtained. + * The opclass may or may not support processing of multiple + * scan keys. We can determine that based on the number of + * arguments - functions with extra parameter (number of scan + * keys) do support this, otherwise we have to simply pass the + * scan keys one by one, */ - add = FunctionCall3Coll(&consistentFn[keyattno - 1], - key->sk_collation, - PointerGetDatum(bdesc), - PointerGetDatum(bval), - PointerGetDatum(key)); - addrange = DatumGetBool(add); + if (consistentFn[attno - 1].fn_nargs >= 4) + { + Oid collation; + + /* + * Collation from the first key (has to be the same for + * all keys for the same attribue). + */ + collation = keys[attno - 1][0]->sk_collation; + + /* Check all keys at once */ + add = FunctionCall4Coll(&consistentFn[attno - 1], + collation, + PointerGetDatum(bdesc), + PointerGetDatum(bval), + PointerGetDatum(keys[attno - 1]), + Int32GetDatum(nkeys[attno - 1])); + addrange = DatumGetBool(add); + } + else + { + /* + * Check keys one by one + * + * When there are multiple scan keys, failure to meet the + * criteria for a single one of them is enough to discard + * the range as a whole, so break out of the loop as soon + * as a false return value is obtained. + */ + int keyno; + + for (keyno = 0; keyno < nkeys[attno - 1]; keyno++) + { + add = FunctionCall3Coll(&consistentFn[attno - 1], + keys[attno - 1][keyno]->sk_collation, + PointerGetDatum(bdesc), + PointerGetDatum(bval), + PointerGetDatum(keys[attno - 1][keyno])); + addrange = DatumGetBool(add); + if (!addrange) + break; + } + } + if (!addrange) break; } diff --git a/src/backend/access/brin/brin_inclusion.c b/src/backend/access/brin/brin_inclusion.c index 986f76bd9b..b1b3ce700d 100644 --- a/src/backend/access/brin/brin_inclusion.c +++ b/src/backend/access/brin/brin_inclusion.c @@ -85,6 +85,8 @@ static FmgrInfo *inclusion_get_procinfo(BrinDesc *bdesc, uint16 attno, uint16 procnum); static FmgrInfo *inclusion_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype, uint16 strategynum); +static bool inclusion_consistent_key(BrinDesc *bdesc, BrinValues *column, + ScanKey key, Oid colloid); /* @@ -258,53 +260,109 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) { BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1); - ScanKey key = (ScanKey) PG_GETARG_POINTER(2); - Oid colloid = PG_GET_COLLATION(), - subtype; - Datum unionval; - AttrNumber attno; - Datum query; - FmgrInfo *finfo; - Datum result; - - Assert(key->sk_attno == column->bv_attno); + ScanKey *keys = (ScanKey *) PG_GETARG_POINTER(2); + int nkeys = PG_GETARG_INT32(3); + Oid colloid = PG_GET_COLLATION(); + int keyno; + bool regular_keys = false; - /* Handle IS NULL/IS NOT NULL tests. */ - if (key->sk_flags & SK_ISNULL) + /* + * First check if there are any IS NULL scan keys, and if we're + * violating them. In that case we can terminate early, without + * inspecting the ranges. + */ + for (keyno = 0; keyno < nkeys; keyno++) { - if (key->sk_flags & SK_SEARCHNULL) + ScanKey key = keys[keyno]; + + Assert(key->sk_attno == column->bv_attno); + + /* handle IS NULL/IS NOT NULL tests */ + if (key->sk_flags & SK_ISNULL) { - if (column->bv_allnulls || column->bv_hasnulls) - PG_RETURN_BOOL(true); - PG_RETURN_BOOL(false); - } + if (key->sk_flags & SK_SEARCHNULL) + { + if (column->bv_allnulls || column->bv_hasnulls) + continue; /* this key is fine, continue */ - /* - * For IS NOT NULL, we can only skip ranges that are known to have - * only nulls. - */ - if (key->sk_flags & SK_SEARCHNOTNULL) - PG_RETURN_BOOL(!column->bv_allnulls); + PG_RETURN_BOOL(false); + } - /* - * Neither IS NULL nor IS NOT NULL was used; assume all indexable - * operators are strict and return false. - */ - PG_RETURN_BOOL(false); + /* + * For IS NOT NULL, we can only skip ranges that are known to have + * only nulls. + */ + if (key->sk_flags & SK_SEARCHNOTNULL) + { + if (column->bv_allnulls) + PG_RETURN_BOOL(false); + + continue; + } + + /* + * Neither IS NULL nor IS NOT NULL was used; assume all indexable + * operators are strict and return false. + */ + PG_RETURN_BOOL(false); + } + else + /* note we have regular (non-NULL) scan keys */ + regular_keys = true; } - /* If it is all nulls, it cannot possibly be consistent. */ - if (column->bv_allnulls) + /* + * If the page range is all nulls, it cannot possibly be consistent if + * there are some regular scan keys. + */ + if (column->bv_allnulls && regular_keys) PG_RETURN_BOOL(false); + /* If there are no regular keys, the page range is considered consistent. */ + if (!regular_keys) + PG_RETURN_BOOL(true); + /* It has to be checked, if it contains elements that are not mergeable. */ if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE])) PG_RETURN_BOOL(true); - attno = key->sk_attno; - subtype = key->sk_subtype; - query = key->sk_argument; - unionval = column->bv_values[INCLUSION_UNION]; + /* Check that the range is consistent with all scan keys. */ + for (keyno = 0; keyno < nkeys; keyno++) + { + ScanKey key = keys[keyno]; + + /* ignore IS NULL/IS NOT NULL tests handled above */ + if (key->sk_flags & SK_ISNULL) + continue; + + /* + * When there are multiple scan keys, failure to meet the + * criteria for a single one of them is enough to discard + * the range as a whole, so break out of the loop as soon + * as a false return value is obtained. + */ + if (!inclusion_consistent_key(bdesc, column, key, colloid)) + PG_RETURN_BOOL(false); + } + + PG_RETURN_BOOL(true); +} + +/* + * inclusion_consistent_key + * Determine if the range is consistent with a single scan key. + */ +static bool +inclusion_consistent_key(BrinDesc *bdesc, BrinValues *column, ScanKey key, + Oid colloid) +{ + FmgrInfo *finfo; + AttrNumber attno = key->sk_attno; + Oid subtype = key->sk_subtype; + Datum query = key->sk_argument; + Datum unionval = column->bv_values[INCLUSION_UNION]; + Datum result; + switch (key->sk_strategy) { /* @@ -324,49 +382,49 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTOverRightStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTOverLeftStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTRightStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTOverRightStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTLeftStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTRightStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTOverLeftStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTBelowStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTOverAboveStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTOverBelowStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTAboveStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTOverAboveStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTBelowStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); case RTAboveStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTOverBelowStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); /* * Overlap and contains strategies @@ -384,7 +442,7 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, key->sk_strategy); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_DATUM(result); + return DatumGetBool(result); /* * Contained by strategies @@ -404,9 +462,9 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) RTOverlapStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); if (DatumGetBool(result)) - PG_RETURN_BOOL(true); + return true; - PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); + return DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]); /* * Adjacent strategy @@ -423,12 +481,12 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) RTOverlapStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); if (DatumGetBool(result)) - PG_RETURN_BOOL(true); + return true; finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, - RTAdjacentStrategyNumber); + RTAdjacentStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_DATUM(result); + return DatumGetBool(result); /* * Basic comparison strategies @@ -458,9 +516,9 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) RTRightStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); if (!DatumGetBool(result)) - PG_RETURN_BOOL(true); + return true; - PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); + return DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]); case RTSameStrategyNumber: case RTEqualStrategyNumber: @@ -468,30 +526,30 @@ brin_inclusion_consistent(PG_FUNCTION_ARGS) RTContainsStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); if (DatumGetBool(result)) - PG_RETURN_BOOL(true); + return true; - PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); + return DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]); case RTGreaterEqualStrategyNumber: finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTLeftStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); if (!DatumGetBool(result)) - PG_RETURN_BOOL(true); + return true; - PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); + return DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY]); case RTGreaterStrategyNumber: /* no need to check for empty elements */ finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, RTLeftStrategyNumber); result = FunctionCall2Coll(finfo, colloid, unionval, query); - PG_RETURN_BOOL(!DatumGetBool(result)); + return !DatumGetBool(result); default: /* shouldn't happen */ elog(ERROR, "invalid strategy number %d", key->sk_strategy); - PG_RETURN_BOOL(false); + return false; } } diff --git a/src/backend/access/brin/brin_minmax.c b/src/backend/access/brin/brin_minmax.c index 4b5d6a7213..b233558310 100644 --- a/src/backend/access/brin/brin_minmax.c +++ b/src/backend/access/brin/brin_minmax.c @@ -30,6 +30,8 @@ typedef struct MinmaxOpaque static FmgrInfo *minmax_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype, uint16 strategynum); +static bool minmax_consistent_key(BrinDesc *bdesc, BrinValues *column, + ScanKey key, Oid colloid); Datum @@ -146,47 +148,104 @@ brin_minmax_consistent(PG_FUNCTION_ARGS) { BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1); - ScanKey key = (ScanKey) PG_GETARG_POINTER(2); - Oid colloid = PG_GET_COLLATION(), - subtype; - AttrNumber attno; - Datum value; - Datum matches; - FmgrInfo *finfo; - - Assert(key->sk_attno == column->bv_attno); + ScanKey *keys = (ScanKey *) PG_GETARG_POINTER(2); + int nkeys = PG_GETARG_INT32(3); + Oid colloid = PG_GET_COLLATION(); + int keyno; + bool regular_keys = false; - /* handle IS NULL/IS NOT NULL tests */ - if (key->sk_flags & SK_ISNULL) + /* + * First check if there are any IS NULL scan keys, and if we're + * violating them. In that case we can terminate early, without + * inspecting the ranges. + */ + for (keyno = 0; keyno < nkeys; keyno++) { - if (key->sk_flags & SK_SEARCHNULL) + ScanKey key = keys[keyno]; + + Assert(key->sk_attno == column->bv_attno); + + /* handle IS NULL/IS NOT NULL tests */ + if (key->sk_flags & SK_ISNULL) { - if (column->bv_allnulls || column->bv_hasnulls) - PG_RETURN_BOOL(true); + if (key->sk_flags & SK_SEARCHNULL) + { + if (column->bv_allnulls || column->bv_hasnulls) + continue; /* this key is fine, continue */ + + PG_RETURN_BOOL(false); + } + + /* + * For IS NOT NULL, we can only skip ranges that are known to have + * only nulls. + */ + if (key->sk_flags & SK_SEARCHNOTNULL) + { + if (column->bv_allnulls) + PG_RETURN_BOOL(false); + + continue; + } + + /* + * Neither IS NULL nor IS NOT NULL was used; assume all indexable + * operators are strict and return false. + */ PG_RETURN_BOOL(false); } + else + /* note we have regular (non-NULL) scan keys */ + regular_keys = true; + } - /* - * For IS NOT NULL, we can only skip ranges that are known to have - * only nulls. - */ - if (key->sk_flags & SK_SEARCHNOTNULL) - PG_RETURN_BOOL(!column->bv_allnulls); + /* + * If the page range is all nulls, it cannot possibly be consistent if + * there are some regular scan keys. + */ + if (column->bv_allnulls && regular_keys) + PG_RETURN_BOOL(false); + + /* If there are no regular keys, the page range is considered consistent. */ + if (!regular_keys) + PG_RETURN_BOOL(true); - /* - * Neither IS NULL nor IS NOT NULL was used; assume all indexable - * operators are strict and return false. + /* Check that the range is consistent with all scan keys. */ + for (keyno = 0; keyno < nkeys; keyno++) + { + ScanKey key = keys[keyno]; + + /* ignore IS NULL/IS NOT NULL tests handled above */ + if (key->sk_flags & SK_ISNULL) + continue; + + /* + * When there are multiple scan keys, failure to meet the + * criteria for a single one of them is enough to discard + * the range as a whole, so break out of the loop as soon + * as a false return value is obtained. */ - PG_RETURN_BOOL(false); + if (!minmax_consistent_key(bdesc, column, key, colloid)) + PG_RETURN_DATUM(false);; } - /* if the range is all empty, it cannot possibly be consistent */ - if (column->bv_allnulls) - PG_RETURN_BOOL(false); + PG_RETURN_DATUM(true); +} + +/* + * minmax_consistent_key + * Determine if the range is consistent with a single scan key. + */ +static bool +minmax_consistent_key(BrinDesc *bdesc, BrinValues *column, ScanKey key, + Oid colloid) +{ + FmgrInfo *finfo; + AttrNumber attno = key->sk_attno; + Oid subtype = key->sk_subtype; + Datum value = key->sk_argument; + Datum matches; - attno = key->sk_attno; - subtype = key->sk_subtype; - value = key->sk_argument; switch (key->sk_strategy) { case BTLessStrategyNumber: @@ -229,7 +288,7 @@ brin_minmax_consistent(PG_FUNCTION_ARGS) break; } - PG_RETURN_DATUM(matches); + return DatumGetBool(matches); } /* diff --git a/src/backend/access/brin/brin_validate.c b/src/backend/access/brin/brin_validate.c index fb0615463e..0c28137c8f 100644 --- a/src/backend/access/brin/brin_validate.c +++ b/src/backend/access/brin/brin_validate.c @@ -97,8 +97,8 @@ brinvalidate(Oid opclassoid) break; case BRIN_PROCNUM_CONSISTENT: ok = check_amproc_signature(procform->amproc, BOOLOID, true, - 3, 3, INTERNALOID, INTERNALOID, - INTERNALOID); + 3, 4, INTERNALOID, INTERNALOID, + INTERNALOID, INT4OID); break; case BRIN_PROCNUM_UNION: ok = check_amproc_signature(procform->amproc, BOOLOID, true, diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index e6c7b070f6..9c11c3af3a 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -8135,7 +8135,7 @@ prosrc => 'brin_minmax_add_value' }, { oid => '3385', descr => 'BRIN minmax support', proname => 'brin_minmax_consistent', prorettype => 'bool', - proargtypes => 'internal internal internal', + proargtypes => 'internal internal internal int4', prosrc => 'brin_minmax_consistent' }, { oid => '3386', descr => 'BRIN minmax support', proname => 'brin_minmax_union', prorettype => 'bool', @@ -8151,7 +8151,7 @@ prosrc => 'brin_inclusion_add_value' }, { oid => '4107', descr => 'BRIN inclusion support', proname => 'brin_inclusion_consistent', prorettype => 'bool', - proargtypes => 'internal internal internal', + proargtypes => 'internal internal internal int4', prosrc => 'brin_inclusion_consistent' }, { oid => '4108', descr => 'BRIN inclusion support', proname => 'brin_inclusion_union', prorettype => 'bool', -- 2.26.2 --------------45196B023835614BDFCBD16D Content-Type: application/vnd.oasis.opendocument.spreadsheet; name="results.ods" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="results.ods" UEsDBBQAAAgAAAW+k1GFbDmKLgAAAC4AAAAIAAAAbWltZXR5cGVhcHBsaWNhdGlvbi92bmQu b2FzaXMub3BlbmRvY3VtZW50LnNwcmVhZHNoZWV0UEsDBBQAAAgAAAW+k1FMwsZq0hEAANIR AAAYAAAAVGh1bWJuYWlscy90aHVtYm5haWwucG5niVBORw0KGgoAAAANSUhEUgAAAO0AAAD/ CAMAAAAqjaEtAAAAWlBMVEUjIyMqKiozMzM8PDxERERLS0tTU1NbW1tjY2Nra2tzc3N7e3uD g4OMjIyTk5Oampqjo6Orq6uzs7O7u7vDw8PLy8vT09PZ2dnl5eXr6+vy8vL+/v4AAAD///83 nqiOAAARM0lEQVR42u1dh4KqOhTcVVJJIaQn//+fL0F37xYLICjuk3tXUUmZ5GSYHFLe8v/p eHuhfaF9oX2hfaF9oX2hfaF9oZ2P1rv/zb+K9v9zvNCeO4yrr9Y9N1r3Zr3by66BkHgAIfMO Ot/vrDfv1kt5vFRC453w/MnRqvfOs3dNKyy79w51rrxCopwEzJPee8eINDvsPNspJjhRVLie tPYZ0TLaWggcgBhbhb0XVEMvWNd6qsrXBRMRrrGNc57zHgMpoN0bYDl7RrTQINIDt7fWesa9 p0K09h1D6KFtBShXFaCNAcWEcc9545i0gDcYyWdEW+qPaGyaihZ1VjQOK9xZu3egWDauaE0P +3oCDO5KIZielAJ5vhZc0Drmme07jTDGjmLMSvM0bUFS8HjPunJW22jflcu5YL3wzKnOtaVd P+sd6HvG3Y/34dR9vr7UxQvtC+0L7QvtC+0L7QvtC+0L7QvtC+0L7QvtC+3Zoy99Zz3Gs+e6 oa/dX7iiP/n74GFlD+6iCz3ksCnZUGPc1dW9UiDTC2illk6eQuvwnvaeatLCzkx0rVGKpKOY OIbb1mAsHCkf6i/V8eM6jLTGtH7RlzeCWocItD0ixBEKJRIOI2beW4WgsTsCHTa4vHaY4iH+ crUpeRI1fnaIDfP+jXUI6Va2GFtL8KGyWlouq1nh5TIlGihb5jpua6bq75Jw1Ze6JUowDd3O aAi0baagbbRpnHCNgp4wqO1eA3t4pCCIh6pxCvEDek686dxeVxdfY/Xe7SzhBtbvSqU2TqsS B+xBBz0we9dVV6e3O8dbrWyjUKnQphRTQWAs8NKKFvWNMY50rhmsH/R2z1tPukZbSztgqShR WdiXBAaDEK6Lg89Rl+JwwCv0TsgUsy65NJBh+s64x30J3HoJ2+EXojwQe0JkORkSK+aDyZ6z Csn1SCNfoFJCSGOQht75VvpGkfraIyeHWIqxMgEpQq10iNXYHGtUjzWge1mLkrgdIYPt1KwA pD1WuhgHsE39E8zVTA2I6u+mWPLOljBe7Qwq5cL6CVWr3zWWTS/2nKo322iuWK/Boda5Ahoa MrTGITG30wzivlRFsQAumWsKwJ2mWGLT9NBC45qCrbzqRu8HImqRbsxOl1bSqrceGmqJYYxz QfqdgqIrhgXV4dGNedOUU94DxU1T/xW8ELhifbw7VIzvUCp1K5TbW89Yq3xpDBPAOtEyWcL0 3LBS1LoVzrbMHiKXzLqu7Z04Xlqabqu5cE66jqFemcIinVXlO8Pqm5fOdp2pr07yg3XCrtVO Ms1tid+X2EocwpWgTCjZOVZCGXZslpRJ53hJVJREpeN9ib6YlSlmceCt8qupd6BSQYUQzHTv 6dFKC1u1mH98aaWQojTCf/eL8vnTYqp3GjLoPj6cOjrU4r4Eks3HBaTF4hDAfYb6DKzrpbT7 Ugv+27mR5Xdz5OQQvA0hlL84/J9w2HJ9DRGDsfHzvJ54d/gcj58/Y67nzhw/nkhtCGLN4cQe A5b43UdEX1IJX16c/0jo+PovuvAZsKBN/5/jhfZvoxXDWSx/1h2/nfA34+jj9zyMjy2qKdgK IBWGUCal0B/Q2lRbMHEp7vk9SrjduZkhI9ldBPerWLGC5Q2qcpsnzQEtSDsG1E4mysWMCvtZ LfnaxRH7s9fmy9HE5pRB/MvBDzMpNYh88ig5EgvMAW2T9klxGHrei1saxdcsXrR77C4Wy5dr fwUHaUp9FKjEJksq4PRRtxEkJWAAFDb+HqaM56cCprUZk1BIASZL07+6LWg5YTGqe7TbyHfU pLGm/+0I7RtzE4zNwpZEliiF1pagg7oolp2q/CkZiemaKS5Ay865cK3xnymoEjROKtkCqv6P KdSgL3Uxvb7ynOCnqzNPJcWz5Liqljp/K5hs+HkMoDnF9A1tvpM9fU8qj9UKE/OXf38+ov1x i/v/9QpW1spprlQee0iE6m2dYpI4gq4DuD2HNqebjOZxlffv3gOSKZJCt4n1PCkm1MN7fPmW MOcM7PDZ4aqhkuxSJ4oytwxiuiTaUTo5TyqDS4CuFJ3HgzjuZJIyIF2FEwgr1G2eVCwXKDnf ZAvAcRm9gx45qEPgyjWfaPMkBfcMh2tldKo03D5SSlXkrf1myXkmI+ebjSDfqZwXs+R8d+bK 00Ovxckr1lK+dp/Od0KbR+mTicUylpTzCJZbvG7HZ3/GJXmZdpsnZOWeZn9jVhQr6jE73iXb tuIsJ99Gynl+C1y04LrWgZhSY1knpA/b4+S85KXEVf9mEZEOM8rMsu02LxQoTzeJ06R88LC6 6mHVvduv6ZdaUIjkUd6g34iZTnDwsOpWhwT8L7R59fodiTyfdj9MOjxCPNb+LfIaovY3Jz+k u5qXax95rJZajJNnMc30/uCGdHJerylcv/Sci+3xnLwA4vGu26VZ6iotj8WWr0nwCb2iz7+7 6+QpN6Q8vSb+XRPix1vwIUYfwmlO3pT3Is/ryiZGoE0pIgoDpbCVkPLznHwXoTyj+Y2t3wjr U+rUs8RVEVWBK7/0c6A79ejHRPzPw6p4UiJxTNEvtHn1bNyuk0eRQB1sgVN1JktZ5WNpxNCf qttFEc9VyTcbBuqJCiYADUIEKXHWN/d/Wn32KeUox8+Em1CQJnmdnHQp9rVj3/kznLwaj95W Oot5apb1XSyAaxX2WNl3kddooHlE4Ly+csz3bf7TbWKZUSbXbyhXspMXykK+/OnenHyDSp6b oBN1QFl2Kl3g5HwXvhnzAODsoJBRXOGBAUU0Otpc4OTJxHyHe9esu1B9Xt3VkyYtqBzzfHvM qzWYcohBKafPUZ0bdF5cfTQ5nghKL4j1Z+r2diWUZ4qrvFbRIopiZwx9I/fWyXk+h81OMMZY /8JZ38XdVOCUa/LtVX6Rk5eh5KUdiLfcGpfi5Lw0KY32RObxJnMvf3JegQCu48tjdXK+scUu g3iySV++629JJ5/MaSBFFTAMQ4egiQiTKal5iFmJtwR3kYB0hZPzArhuvMp7UJ2HPatvUqbv 002uHO2/57feX9XJU4j5dtRnLh+G3joEUgRFFIluglD5NvsJ3EMn32waTc2uJRUtV4n340pz +Oow7sLjwdkKzivHzTgvomtcApb0uJetRQ6ECYmr1hbLKMFbFd3enWWp+bQ897nNmcO0LYuu 1GgUMiXN7MWEfn5W3EeZPFfRtqxdUSfnMSSwhmnk61oq3w/xZUNY1ZN3lZNv1skzntyt1jva ik6+qeeTxwroRTk532zVq5RwvtormM3Jq4+BvUTDX89dK+pQhL7tCx/zaOiPZ/OPpuTxZp1H JAycEAUz8shCx4XoRvgu8uKI70HJ+et8oPI/sY4Rqkfo5E1S8vXLvs71iqJNxvh9WIqTH0XJ Z+cxRVDn8NW/VrNSu70/M9drFcQ3UPK8oBIjb0WimIYdxp1Bpau7NCev4Ite0Qu3SUr+bdoz DeGqTs5pvZpayxDybJ18IymvR8lXos9PpJMn2/t8D+saiG+k5LlZCod1XlwYlkHZlk5efPaT hax6ZEkLrUTlrnuNk5es51FNfRwHjMwWNUcPqyW8c3Fd30VeyQzy2NvIFw+rIAxsQicvMJ7l zA/Vw/q5dtiJMazb0MkLUXLSqIOpS6hDmtMOxLvp5JspeVbsto9Rp6hsQd6HO+rkfA/7uNZm VuLkPLOi1iK2kTr5AZR8Y28+j6vbB+nkW2btXppfnx+nk/NyBDDl6h8LxNzPnzyzVzq7T+z5 MLrRcBMZY71tmdiSTs7LcgU01R3loYWlP9B2Qjp/V508ojjyYsVZBJQ/zAfqZAooccrsKE5e 70lJvsU6Llu/I4OHVQyrabUmafVjlYAxoyeW18k3++dPR/CxUtowghXEVFcJuJ8/Oa/akE+g Fgg6KyLGONa5XhqcWSnt/ojzJJtaXjmu5k/Oq1j0DC11B528DOL5t8cVOfk2Sl5jbuzanPwo Sj6dyL04ed1Jb5eHKR/Xl47prpy8ECVP9FpHRFCsY2Gb+3PyfSj5a2THdQKCB4/h5CUQj6+N g3ZM3+YD5QcgXpGSvyT/ObMNPJ6Tb+brq9eEOmvR+mD25m9w8uW5DFa4ZLwVnMctcHIeBWWE NV0X6hvh5MUpOU9B+whOzssW7IZ08jXX6DoDs7fMycsPEN00JwfqUmTUJk158rQNSVI1qVT4 MH3IUB6rptq2TuZYJy5DE0HgEjqDNQ11E4JLk2K+HZKHug4rCEI4uXmdfJirhXqSHB7mA/WD 5h1NyfhjHVaPR82bf6xOPqwsihQ9omU/0F7LHT6sw4q/7nS1XZ1c6rbVxY5h6jiIDin2sSfY uFRK0RRLrht5se3rZApgFzBWSWISDSpAKZ60F1cgqIskdZgEjfc4bIGT138mf0lLPUPP4Myk mCvJ/TGdfONOVxvWyTOysmWdPOpONckvt2lOvu16O+zoGE0YToMxNj0vJ18LRRjS1U8jyu2a wV5iobbPyZMeFH+91cL6wLoutiQ6U954Z+Kz+5PPLwx6fDZ/WIfVwSApv75W5yb9yWOuq3WL P+q2bpQav4xh3aROvmlQHOZI+z4ACfxOSiOwAE/HyZds+MdhXJ1WEHSIfa9tsifa7fY4+YIg nD7AbiOcPN6nvKRf6mGcvIgwvCrCnlMn59vqdqs6eREW+4zoaTl5VCqR4OrGqr4LBU/Mv30C nTxhW8h/fil+do/UzSEev7rNj1+/7P3EIBZPy8nj0vjiYfUhNeFZx12MO6QIIIYIghTShN97 pG5OJ9+0E1hkRKc2acKip6T/I5w8tmSeg5On6JE8Ae22EefpbrjN6uQ8rUznjGbfEiev0lX4 +s0z6OSZ6ft4WIwoJu99CM77v8PJv9Jq6bDTFWxhaBlkErUy/ZFnfL+PcNjpavDCDTtdde6J OPnMJvVn90g9ri91GMHaySRwC+PTcfLYvYLCYacrddjpKp7f6eoPcHLt/3Sk9zoABUIdcsFb 1aSn0MmzMhCVScEk3/kUdfmou/CnOHnEs6Kn4eSJW2c+uU6+jHhk+JdOfiAn50Ws6OxNa2uc fAstn/bHCTJMkOna5/cn52uIsyWRmKKtuib9TZ38LcLP2U/gyTj53NqAFw1IXkG7eZ086TAk kWH/iuZJOXmaQ5pjnqTRuMHx2Tl52mIwf2Xcxelfrq1euWVOnj8z7jl18mwbys+pk/N8usoP 4uRoZqen0+jhjoN3StclAqJ2aejSP4ST+S5dWx3wNBNG/D7tXotkXSGgvGqPm8dwsm3h3OZZ 19c5UYXnDmLr43mPUhHLETyEkyMOcHaSzVmjPfVDgUrtx3DW5iGc3AH6puYmCSaZER3qtkCt S009RifHYlRxDj3kFPg79xNyYyHDiSfCoLXiTTxkfHKhypnJRWNMnJKBYGti0YY6r8A8TCdf MIQRRJhn5u3haxAt3XmftJrW/VRjXhbkqCEYD9HJeS1fzTXv63Z08pJTKMZa8t0Yanqok0va nw/RYVxvVi1uk8DIfRvDmh+EeBYlj4nyuD9QkRVtz5Jiv8aw3pWTp28+MN5FUQ//Ze+nIlYN e9j45HssxH3c10vKutMV7uvsJ+CfdW71lTttOQNeiBgcCsgiHaLofROfaB7fxAdilvLouqSo ipgSFdofe7Y9nJPHD3bM85J6NCcvT8mb08mroZmqLjbLUPnqPWiE5NgOJ+dlE81jewWP0cmr 3JNqb758V3vz1riN6eSxm3WMjd1AjssbZtBIzLuHcHJO4zGN2pPmbIT008NKeWfjw3TyghNh Lnz7Za6XoOz3bkhb5eQ8izE+69aRcG4M68MQL7ozSx7arURJJiSh4USCDXLyoqxdn3qZw1Mv 28etcfKc4pygmwvafOlIed4xN9yoiNPFby4m/Zb/T8f/C+1/g7g9JaT2Z18AAAAASUVORK5C YIJQSwMEFAAICAgABb6TUQAAAAAAAAAAAAAAAAwAAABzZXR0aW5ncy54bWy1V9ty2jAQfe9X MHpPzCUlwQNkCGkaWppkMEkvb7K9YE1krUeSMfTrK2PIpGDPEIOfwLqcsz462l13r5chry1A KoaiRxrndVID4aHPxLxHnqd3Z1fkuv+pi7MZ88D20YtDEPpMgdZmiaqZ7ULZ2XSPxFLYSBVT tqAhKFt7NkYgttvs96vtNVk2suRMvPZIoHVkW1aSJOdJ6xzl3Gp0Oh1rPbtd6qGYsfmhVNnq 91SI+EaUbsiCWZM16/ULK3smtU2Q76Rpkv5Wh+3r97sbguznjGkIU21qm+E0tB4xlPaCQfKm Gsnb9/+eF6aYy2EggU4xIttJvYrMJBOa9Otdax/kQ8BjmOlqkH8yXwd50J2rTrt5NPw9sHmQ G3qj3urUG/kEOYPpiRx+htlALKk2jvjIYToroenS0dKsn8BsJ3AVoDShX5aTZaRuN5Z3AirB 3wF3ETlQQfozyhWUoxgj9SdAfRR8VQH8gHNMnow2+hu6Qyo84EUsWsYlSZ4jn2q4kxhOIYy4 +X96jpH6DlIMFKPiKRaejtdGqUCxL6EL/h0KrSoAHylH0GiKE6o0yAoIMuAJKORxKtCv3Ivc vCyZhnbhf58W/p4qJwDQU+oWqn+MhbLwB0umTNbwAomC/S2+1eWZnMBcOjqHG5NPXyt4kxT/ q2QVRf6AGqoImi7gJav4j2LIURVmiSP8n6oyRI67d4ujmKfObLeazc/tY8w/UptiWUH060QN 8sE87NaxdX0j1iEuf4y1aerAWYUucuXAbjE/kU3+gMQXyuMqvDI2TWlWVX6gv6dFVtNbx5yi E7s+WzBVmCJLJzDjvjgUE0zuTVU3dj+9OHtvkJ+FSzYMscYh5V5cTRnfONyYMt5tvF2qoH1x wwSVq0OMPogivnpWIG+ppqePdGg6PuqZWIcYRhJUKvTUgOebsaDgFbbF1t7HjlX0Gdj/B1BL BwhdRprFxgIAAEgOAABQSwMEFAAICAgABb6TUQAAAAAAAAAAAAAAAAoAAABzdHlsZXMueG1s 7Vz7b9s4Ev79/grDxS1aYGXJUh62N3Gwt69boA2KTffux4KRKJm7kihQVJz0r78h9X5aVvzs 1S2aihyOZr75OBzKoW7unj139IRZSKh/O55OtPEI+ya1iO/cjv/89KsyG98t/3FDbZuYeGFR M/Kwz5WQv7g4HMFgP1zEnbfjiPkLikISLnzk4XDBzQUNsJ8OWhSlF/JWcYtU1ne4FC6O5viZ 9x0sZEtj0WP/O0vh4miLoXXfwUIWMC0Ot2nfwc+hq9hUMakXIE4qVjy7xP/7drziPFio6nq9 nqyNCWWOOp3P56rszQw2M7kgYq6UskwVu1jcLFSnk6maynqYo772CdmiSX7kPWLWGxrEUS2q AcMhiIC7gpf9FBXHlPj15PRm15PTArO5Qqw3z6RwmSqG1Z8qhlUc6yG+aonvTP0AnfKfD+9z XjGv772EbAkqk5Ggt5uxdHE8pTQzVQyIJ7s0V9e0CzW+LkivO8XXjHDMCuJmp7iJXDNDnHpN oIHcVAUJBT8JyqfSTDjdqvlSZTigjGeG2P2THaCjZ1N1xT23faqK3lTUYZbVKArmGCpMW5g0 yhPB6zelXNaN/1yVQsX81TlgqqlCJpsCAG+ebJmTLQc2jXwrnnYxGPg5wIyILuTKYYuShiJj XDpAZbKGFDSUEivBbjrbMpca1VCqeKFCfCAZDRaF0aWZH4YGbwrFpz9U0aeIVQXyZnKfwmKq j5fpymlTWDVtZGLFwqYbLm/ijJc1j+JrYeTt+EdGEDABklEq4BH3JW1Xuwf/hLxHkGsYnvZs UPCeQPKW0I8ekB82KPoOBTT8oSIXN45HJdVCXnGwD5jD1A3XJAxLEgHhJiS3JwR2CWZuMO1n /Bf6T9RtVkGmj0kvIcfea2x6T/zoeSTB4MTHo986AKtI7sw+tY1lSXtcrqV+WNhGkZsUcanm xFKZIBQTu+44FQ8QQw5DwUoJYJYI26Hyi7tAGrTQQLFIyJEvikDjKuA5ZGJq1IdJM1vIZtOF i3wnQg70Yl82mJAMOAPr/nwYV1UokIORX6WGlEn1pCJfVmlPojDt+Om+rlZUAS5+7lacCa1I VXXW9fu9jFAD9MubuFBK6qVSPGJ07rVxRWiUXHnEl3nLgXEWcQgPIeHIGzXozHRwyHxNt5nq 0/xGoDriEKvkMqnOXeo7Qn+qCQK7XGR3k5dpX4hN6lttCtSaLT3MgyU0lWGRbyKOFeorFHKt 7YoawkZuiHMXVjRiYT9jT9Fb4zDBSNsgVxAPuUrgQuao8qjB8Ha6TvWL3PTQJLDMEkhASpm7 9fuN4jVckLqhs5PyxV5Y3KkvtqeF7lhz1iPX+icEpZWR9kENbGIrHxwSB3IC8AxvnE9mxBhs l18asdBgVn3U0rzwRF1IcwJ7qTk1u5zrUrWFfNdwrxfvkbpqS2Ko4qd1gav1BNdhNArkI4EU liLVRhXmqY3o9AdtADjyxm+bZ8DpAveuYnAMhYeCbC3xLRLvgIGyEX777juH/3CbcQoFgZvA qFRYp746DPo37g4AbRtwmkskWe+4lN2O39i2Bp+qyd9onhP09TQ3jk9zvSsE+inS3DiNFH0A 4PbEXWMn3L34xt0BoJ1dij5fml/0orkltnMt0bocQGUPNvGrioNqc0Qs9NJP8AWjLD4tW7zc jV6eXQ3wrG6u0rKrFRCMCj2R2PI0Rb5FgfB3uG/Xx/NtoMWzoTzbL8itzwjA5PkAk/fyYKSa oJML5CmBN/ARiDY1tFNxb9Bzn/3jM2SbvDN8Btq81fbo5GLa4XRHajGGFMsHXsJ6sHXn1GnI dvGPNhx3We12F1xHfO5QhKAvLscraI8O437qVqNStw4IyuXByHrEHdgQXE6VrGe7yZJUex1Z r3ZB1hi9lC+Fq6THJq6riF+MQibHLJeptJ9Matkh6a8+Tk8O37NK66/CXj9N7JWtCCaTYJuL Q5/GtpR68l6QjDj2+YZJ0S+FbcpgV3EG66HM7aNs2k/ZxsQqqFMs+7MQ9H3WaFzvsAroilj9 weLXlXOHPeoF+HeQdw8H/1mm5MGh2UFaPnBoWjN2CwZdOXvIE9KTytnXu8zZ1zvL2dcbc3Z3 uTA7u1L4vPZ/s6+qFD7CpvFV2J9qKXzgNa/2xGBnpfiQr5FOKq3PdpnWZztL67NXl+Lzr6kU P7vfugD4/09K8SMuCYNDc4al+KmuGAO2AkO+xz+pNWO+yzVjvrM1Y96+ZsTj6vH4OT6ek50G aj8UlTfVjzcxGp9BVpArjxL41MfZDBOSJvAu6XuknFOv/cBU4csOTX5qJ5Wy44Ig2nBasO28 VNOxtVwyOYaWyA49vpaObzvElvZnR9naT2HVnUluVZHIj1ptCPW/MRIvOegIddITIJa98UAp 02SLoKXBCckXUKBfBLzQJpQImjCvGMc1Js6KC4q41tZ+fda1z9mKa5EQ0tyLUpIYTQf5nuI2 2PfpbAvfk/Yh3uvd3utH8l7fo/efwJpXEVpt131POR6kWxrVnTbB70dk/i2qHt9S8i93bds0 8ygih/qQOB9dhbNyUs36OHRnfUIrZZZ4EYU2uYYZNwqpS6zRm5km/vTKuYb81IKo7TGIv1LK /d2A3e5XAkEfvwiHpcrcwdR8ATvit5Hs0TEx5zDeKmAFnUA/aSNOZSRjWkTWxBIv5kARpy0S bUYNhfAB6ooo3NcM/41Sa5DuxKwhc9w05RzvV/5cXTXk031OxXsccVYoOw4ESpL4+oAynx8c lH+hg7NEwNETENNsXHX3Cch/EfOHVpJVUE7KsV8Yo+zwGSH9la6NkNjy8ypItqutfzRN8PQ4 W4a9u9WxY4gFBm4YEtCGcCFB4kBc2HZ65LC1bDUS2IbtNF4B2xb17VFhMzphMw4NmyU/dUfU ykt0kktR93mIE1NJO1KjHKyANzTiJb8/BN503CDU8HocwkJoFiLxs6vbsXicR/wo2xSIF6PB mqN41ALVLlP4Yx7vFWxS82+tSm02bC7gRxkL8cBzlURTn070qyT6HmIOdLnYhg6t3Mhi8Upr /DTrdnw90ebxa4DUdpMSW45gJqdBg41le9RaoHoEWO8X4POIXnEDrU8u5vkGurBCBciK3xWq TS6n6aCGVV0TfzJ0ChLEA6RqRKl5egZMOk28dsBqox+rIVcp4n2SiMuvspIRjECGpozkL/MU b1JkiDTgqE1mFy2UrHfFUbo0JrOrxkhlPUVDpANJjDjMuv4ZNzQRrCScitVR+2dXHi7eEPSI V4GGo+T9r+GIPv6FTWj4ghlV5FcZ4QnO/a8tc6uti3bS4aEwU5Et5Umj0NT1NVFxVjSs9TEy yxtRhi2C5Ge4wjiWXt7d3d2o1cakJajEoYK2QK5cQ6WvQlPLscru/lH4klzkdF9O0/sV2mom pKpKoHeaoNZw3ATtH8mLVjuQ1WvIxlcMO+JLN2HQtmDHDerybfw/TrhbFI2v39UAKd2x1CTZ W7FCHHhMkRJvby2WrfewSciE4rQAU0XTNWWqK9P5eKlpqvyraYkVQnD5/Sg1GLzQtIX8mxnd RKOyfcfjVoq4Whwgv+pezufFAXHbUbgo/HkQ158v7c8Pgi4t++NcsCzVSF+jQt8NGG8bjV5C 2yOlNudJtfnF8Mv/AVBLBwjt72VrmQoAAFheAABQSwMEFAAICAgABb6TUQAAAAAAAAAAAAAA AAgAAABtZXRhLnhtbI2SP0/DMBDFdz5FZFiTS1pSWitJF8RUiQUktsp1rsHg2JHtNP345E9d BdSB0e9+d+/dydn2XMvghMYKrXKSRDEJUHFdClXl5P3tJVyTbXGX6eNRcKSl5m2NyoU1Ohb0 rcrSqZST1iiqmRWWKlajpY5T3aDyLXRO09FoUs5SqO+cfDrXUICu66JuGWlTQbLZbGCserTk V65pjRypkgNKHBwsJFECnh0S/jfUwM4jaa2vRgM+hR7tFnH8CNPb05UpS3lrgZ5dQp+QORae BHb3JLisPzv4ghT+ukOMIhvDXA9tHXPCOsGDUXfsIDHkulWubyaTyFFKr6XpU3qR9eELufOF mMBldoUKDXPaFDtxMPg6mj/jCVZRHKXR4mEnVHvef6xX+9VjMGP2jdHDSMjgz6AMfq0At75L 8QNQSwcIPCatlTkBAABsAgAAUEsDBBQACAgIAAW+k1EAAAAAAAAAAAAAAAAMAAAAbWFuaWZl c3QucmRmzZPNboMwEITvPIVlzthALwUFcijKuWqfwDWGWAUv8poS3r6Ok1ZRpKrqn9TjrkYz 3460m+1hHMiLsqjBVDRjKSXKSGi16Ss6uy65pds62ti2Kx+aHfFqg6WfKrp3bio5X5aFLTcM bM+zoih4mvM8T7wiwdU4cUgMxrSOCAkejUJp9eR8GjnO4glmV1F066CQefcgPYvdOqmgsgph tlK9h7YgkYFAjQlMyoR0gxy6TkvFM5bzUTnBoe3ix2C904OiPGDwK47P2N6IDKblXuC9sO5c g998lWh67mN6ddPF8d8jlGCcMu5P6rs7ef/n/i7P/xnir7R2RGxAzqNn+pDntPIfVUevUEsH CLT3aNIFAQAAgwMAAFBLAwQUAAAIAAAFvpNRAAAAAAAAAAAAAAAAGgAAAENvbmZpZ3VyYXRp b25zMi90b29scGFuZWwvUEsDBBQAAAgAAAW+k1EAAAAAAAAAAAAAAAAaAAAAQ29uZmlndXJh dGlvbnMyL3N0YXR1c2Jhci9QSwMEFAAACAAABb6TUQAAAAAAAAAAAAAAABwAAABDb25maWd1 cmF0aW9uczIvcHJvZ3Jlc3NiYXIvUEsDBBQAAAgAAAW+k1EAAAAAAAAAAAAAAAAYAAAAQ29u ZmlndXJhdGlvbnMyL3Rvb2xiYXIvUEsDBBQAAAgAAAW+k1EAAAAAAAAAAAAAAAAaAAAAQ29u ZmlndXJhdGlvbnMyL3BvcHVwbWVudS9QSwMEFAAACAAABb6TUQAAAAAAAAAAAAAAABgAAABD b25maWd1cmF0aW9uczIvZmxvYXRlci9QSwMEFAAACAAABb6TUQAAAAAAAAAAAAAAABgAAABD b25maWd1cmF0aW9uczIvbWVudWJhci9QSwMEFAAICAgABb6TUQAAAAAAAAAAAAAAABUAAABN RVRBLUlORi9tYW5pZmVzdC54bWytk01uwyAQhfc5hcW2MrRZVShOFpF6gvQAFAYHCQbET5Tc vtiKE1dVpFjKjmGG770ZYLM7O9ucICbjsSMf9J00gNIrg31Hvg9f7SfZbVcbJ9BoSJlPi6ae w3QLO1Iici+SSRyFg8Sz5D4AKi+LA8z8bz0flW7RzMCaXNHWw3nixp5PIO0LKpFr9VUIzgGi GVLCcq+1kcBnhFFpu2ruLWhjoa3l8XI3oIu1bRD52BH20Nd9CKCMaPMlQEdECNbI0RA7oaLj DOi8dZpCBKHSESATtsTK4VjcDwpjE8vTkgbsH1gxTvTAhvwilQQ51+tOtE7tATnXQbIhvQgs Peah/1dzU75YeL1dB1m8Hnrdo1HpJ15QrXpbrLH3qE1f4ohIa/bkS00Fh3ZpMVTOCYP4hv37 8dtfUEsHCO5Mhu4zAQAALAQAAFBLAwQUAAgICAAFvpNRAAAAAAAAAAAAAAAACwAAAGNvbnRl bnQueG1s7L1tc1w3sib4fX+FwxMzsftBEDITSCR8u3tiYmeuRKn1/rYRExMdbImyOVcStSTV du+vX+DgHFki67gTKiirbFW7226LD0lkJfIBkK9/+q+/vH3z3T9Ozi9Oz979+Xtw/vvvTt69 PHt1+u7HP3//7Om/35Dv/+tf/o8/nb1+ffry5IdXZy8/vD15d3nj5dm7y/LP78p3v7v4oX31 z99/OH/3w9nxxenFD++O355c/HD58oez9yfvlu/64VP0D9Pvan9ycfnPN+pvn8CffvflyS+X 2m+u2M++9/jv+t88gT/97lfnxz9rv7liy4f66be/PtN+8y8Xb268Piuf+tv3x5enV1bxy5vT d//x5+9/urx8/8PNmz///LP7mdzZ+Y83Ied8c/rqxwW//Ih7/+H8zYR69fLmyZuT+ssuboKD mwv27cnlsXZ9Ffvpkt59ePv3k3P1R3N8eXxNq+/PTy4KpIhbN6buB336PZ/tr3/8qN5d//hx 5WN++dPxuXqfTeDPtwq90m8VevXp9749vvxpRb9y81754vS3e3/9dV+dv9X+ror97KN6eX76 Xi1mQ3/6/WdnZx+XWr+hGfu0XPQ+3Gz//gn659+E/3x+enly/gn85W/CXx6/efnxEz97u+lD Kzi4WRA3Tv5Rt/xHI6ofxMXKN+DN9uWP4ItXqz/6/7n31ycvfzp5e/wr+PRfg2+cvru4PH73 6ydzXpWwKmm8eX7y/uz88uMH81pPvkVb+HFtP12+fbNOHfWrC/TH81evNkLLcuhmoZFixDf+ cXry83/6jFt/ez/kmxPoUz79zW8Af7NiPppkUfev5H/+48fz6fXZh3evGg20D+Pkl/cn56f1 S8dvpm/74bOf8OkOfnP2BT9yPtM++QmfEf3pyZvF+j+KtPHHnJ3deHtRNkPZ9Gfvf/jkuz8/ N87f/qL7cXWjn716ffUnXjH6lxcXdLlJt08f36xfu1GPzXIwzL/pk+sCfv+X5W7QuODi5sc/ eF3uCDdeH788ufHq5OWbi7/8qXH8xz/+rv17Xfefv/9v56fHZa8V+l0Ab0/f/HP585u//c3/ 9/Hbvxfchm9fvvIvfsBfT8txNSn3uyfH7y42/KD/cvz+7OLfruDaH37/3Wc/uuJv/Hjyrqih kNXFz6cXF58h3p9evix0/o/jsq669//F0v77yf8+fv7ht5f1CUazpH9eXJ683WZNfz199+GX 76YP4/L03cl3t37jA7uCHLa+m2u7bP7z4w+XZ+XgPH15Y/o5H7ff9PfPpHl5Bh9/2bz4iZXK PeDNh7fvvl++89M/vPG+WFOV6eTiu9dnP/z9/OT4P278/aQYVvmB9VcvP3GG/3z6qp7h4h3w +8tp/Z8sZ31t52trOz/7+crCyp98uqr2pfqHP52c/vhTMW+ILtVf/tsL/nBxcuPs/eXp2+M3 Nz797svzDyc968Y9Wffr4zcXHQu/PN78gS9/+LbcVE/Ob7w//vHkRvuOh+X/Pqlf+1t8/bcn P52cXMIVCT+Rrj0hXp1evH9z/M/5Q51/cr3qlAfCjbdnr8pPfXN+4/Lv15fdLtY/lB/3slJ8 WcR1Ee6D//4jsv3ju/nfiolMH1D57S9Pym2nnADtsHp7+u7Ghi/O31a/Wk+QH4vkr05/PL0s X4W6uPnr9Xj4y3/+081P//Xjv11d628Y4smaIZ68ebN85f3xeX2ATv9yY6HI18cf3lxeNdTy TVfN9Pjlf/x4Xg/yasZn5YHyn17l+tfyw+vKbxy/Of3x3Y2Lsw/n9U37j+M3H05uXP7z/UdF lavXyfHHJ/Cyw+rP//n8+P20Cevh+O7sRv335btenZ6fvGxfeXN5/vFnnbXXyo3jdz/Wh6i/ /oW6mvrT3n1cwMVP5+VNd+Py7Mbr019/f/vaP6q05VazfN/fzy4LDy5q/vjV//3h4vL09T9n E/pI9+XDPf6xLPqnTz+46XbQPprPv62K/Pb4/MeyO96cvC4r8dVKN+3mai6//pbpR32umUUd fvrPZ+o4+3BZnrAnV+ScvlT//MblT0WjP/50Y3YifPpBXQdVPX6Omc6Pz+4gZTnTH16c/n/l DwFm6ml/1n7Jabldnb6c/nj6HRc/Hb+qL5lrv7xstZPzaQWfLW/5cT/PJPWuXMiO33y2pPrb b5Tr/PG7ZQ2ffnHa/fNXl8V88vX2cxfAhp9eBZ7euW9Ofvn18nXlt3/8+srv//j19RV8hMxr UPPwy5OVA+TABQcu2CsuWKxrL7hgwzcbc8H6CrbgAjLngtdU/zpwwYELDlywX1wQ9o8LXp/+ 8q2SwLLT55948u7V9wdiOBDDLoghfkVi+IrXgMo5Z+evarj0093w+6WEg/kfzH8H5s/m9wKe /nN4I+wJF7ye/nPgggMXnKT944LDG2Fnb4QDMRyIYSYGsXceXN98B2LYE2I4vB4OxDATQ94/ Yji8Hg5ccOCCHXABeHMyOLgSDmRwIIO9JIOvnZM4+f5vNAO5GgI4/vHsXTGTv7+5cXktPDB/ 7bJ8+XyDyr9amGIxMpfC+8vvLs7enL767orBXCWZX7/3vG203/rmgVz06++9PHv/+TccCOpA UH8QgvraiZKbCEqTQPnHpa9PV3ugqz8OXR3Suj+jq6+S1g1fO5dTT1efP7oOdHWgq0PA6HC7 ukJXXzvddA/oaosI1IGn9i2mdeCuA3ct3PU1M2L7uOvzXXngrgN3/Y6fiQfuMuCur53Ouwfc dXgm/r6fiQe6OtDVQldfO+N4ZJTwKmtc/dOuIN2nNLDJ1FcNqf1pbdvz8+m7siFvTKqYbevT xjjGhvWxmdi3YFr7YDpfOyf3Dxm/+q1SwUO4/Rs96Q/xq39+/fjV184U3gOH8IGuDnR1eJj8 IR4m+LVzmfeArgb6gA88tWsf8CF+deCuhbt2kXr9+41fHbhr19x1uHcduGvhrl1kZR8edIcH 3YFY/uDEsl3+9GKydVrPp19vQwN+i3R+wyoPW/iwha9t4Zurg1jmL/z97NU/f50e9P785PjV RR2f8Zc/tSkZdTbThzdtt12cXFbeXAZovDy+KJ/7ybuLwqb/+HUDtS/++gtfn5Yr/Jvjv5+8 ubiCqWHH85Mfy48/v3HyS50bVycabUL9fPrm1cvj81cXc1ByWV2dS9YmAbV/f3v8y+nbD29v vDp9/fqkmF89dr0rW34alHFzXaTlB05/n39Y27XzMJH5zz611jql5JM5S+dvq6mdv/1U9LOX Hy4+ORnrF9+/f/PPG69OLurNoB1AH4ejfLKEG21kzYbfOg3KmRc4zfaYoRc32m3i5FXZUB7D AnrVOKcxySYyuvKLz89+3vBb6wicKwssP+9frSNek+rXb/pMpto2dJlr9fGW9OfvLy7LDePH 8nyYB4Rt+trGJVy8P373rq6ArwCKdJ98dZKp/uD3f/kv/++Hs8t/KzsltP9XNkv7wrJrfhXg o2mclSvLyasbX+PzqAXPe/KBxK/4gYRfP5DVb77ywST1Z1hv/3vyGfLv9TPcv3343c3vqpX+ /j7K/duOv6OPcvX3ZMmfHO0fj7Ctz7Qra/tS1X387O/9j/9+9N/ul5/y3eXp2xPFR/6vdtO/ vAQEvZFvLV257rz8aXuhtl/I69M3b/72+vjl5dn5kOX8i8+Y9Nav18YX88RBHfoPWQ7W8TtV x8E89ksfB3XsVh07vhr964uI/tXLe7OX/L+UquNA99uLdXqxl5LRQWEGClOvOx8s7Y+uuIPJ /V41dzC5343ifvfepvqn+3CjrrkVF397f3L+t/Pjdz/uxZKmrVb+5G/T2vZhRVP872/vz1oc tXxSl3vxQb17dXpxefru5eX2i0kbF/P6zdnx5edfKY8Fv3l1DfxxcdGbrgq8blkFZ7su5ccF xp/XQYt7q8XaS+2gxt+9Gg/G2BUt23xLPajx96XGgzH+EbS4t8Z4OBoP1vjNaXFvrfGgxoMx fmta3CNj3LEPdPswx+m7S01qo15w3FQE8PKk49IAOoVtv4861uSd1y2rAk1XhsiqhRXc9usS /booOxCOqrXNWNP1xeB8JN36Zqzp+iBFJ16n2xlrrV+UrNZvxZrrF3U226DG2g0uk/LjW8AD 3m6bK4g2LjGQg4yqBTaorXqTy5J06p2gxurNLqegVW8Dm66wqMzHqFvgjLXVrziq/es0+p2g A66Vm6OBKwoWJ1pyrlBb5ULZ8aBUbsPaKpdd0N4NZqyx+SZHrLyHNqy1flm8Wr8Va65fL2r1 erE23uiS1x1tM3bAAml5GNUK5w9vjv/8/dnrH/589O//4/HjB4//z//p/hr/183/6f49/q9/ +64VnrW//18b5Xp/cv7y5N1lbcpxVTgHHhGYMISc48om/uT7fxUV/H82kPPeJOet7eX0CVPy IUfJKa7sto1y+mQh5/1JztsD5ERKZc05SKSwsms3y4kWcj6Y5DwaIGfRZMQoEJLs4b59OMl5 Z8S+zZGBI+ToYeUKu1mfYiHno0nOuyP2LQbw7IP47Feucjvct49H8a1PQBijBM8xh73joSfD +DaU/eozAzGuOU42yxkt5Hw6jG+9SDk7E0sonNsjJ1jI+WwY37KXGHMkES89fOvZQs7nw/g2 hOpdRO9jWvPibpYzWMj5Yhjf+kBRuOxcH9YeL5vl/LLzc/exj3+xDn3pYF8kAHUvrwl5iAXU 92B0Ye2GfvU9OEFNV5eDA9A99hvUdHXI7CIonTkL2Pq175PSFTtBbbVLLgaldieosXaD46R0 hS1g2zhAzC4lJeXNWFsFsyvPC936ZqyxinPZ9KJVcQPbGnB2Qbm+BrXVb3LASanfhrV1JyKL C6QMJS9ga4ZOay/T6wxdoLYKRge6xU1IY+ONhTGUcbIFbB0IVX56E9L67IWojILOWGvTjY5r sbhSuwVrEQngyTPFAzxTKeXEgFz+X5dnysTTeG+S89YAOTEnYmAs/wtdnkYyiQRMct4eIKfP TCDFTCjSylNvh56pB5OcRwPkrPuVYspF1tQlp4ln6uEk550BcpIkrhfS7EPoigSYeKYeTXLe HSAnBMiBhRMCdfGQyb59PIxvMfjsyWOsIYG9i3g8GcO33uVUrjnMIUqKvOaa2CRoNjlXno7h 2yJnLq9ZhmKjUP7qCnmYhCSfDSNckBwL6QqGvHbZ3eHGfT6GcKtCo7AAQi7/SV03BROFvhjG uL7cEAQFmFYTwQ6xgAGxAHUo4BAJqOuS7AIqnTkz1jbzL6LzQanVBWycd19obPXQvZZ438C2 OhbHa/k7V1U8Qc01nJWZxTPWXL+s9SYuYNuIQEZHQevWaVhjFQeXgs4pNmONVRwdZnVtVAOb u2S1CeQz1ljDXK44yk9wAdu6FikHF1htxw1sq+TCHdoFzlhjJUcH2tjoArY1ZClqUxvyDLbW sXqBM9aeqrXxlQVsbMhFb5R0MYIZaxEjSJPPKg3wQSKDsAdmH7t8rSa+83uTnLcGyAkpCYTC stnnFW3u0MVxf5Lz9gg5wYv4IARFpXvna30wyXk0Yt9mwVDoQDiv1Rrt0Hf+cJLzzgA50UP2 5SHMsH8e5UeTlHcHSOlz2bNFlxxx7XG2ywjBMLYFEgSMIBHXivt3KOeTYWxbpEP2hYQEUpd1 muzbp2PY1rssVE6UWi7g4+qTeHeRkGfD2BZ9UWQsB0vyvitSaRMgGMa25dAU5BgjUlcNmo19 vhjDt9O+zalsXUnlutpxrnzhtv1mwwNKV/eEPAQIqglCLlc7rQN+BtumBAK5mJQJxwvYNiUQ oyuHkjKjdwbbahm9K5Sp1PIMNtcyozLtfQEbazm4WvGl1HID2wYKAKn+VqWWJ6yxktlh1oWq ZqyxisURqw25gY0NuWpNGWppWGMNS+VfpYYnrK13MSI7idpeODPYnKuTKHlmAZtzNajNeMLa mrEHJ0oP8ow11jA4Uic9zGBjDaOL2ryRBWxsyEVxtQ+EWssVbBEokMl1JQMcrpR8lpBC4j4X gE2gYJLz1gA5ATnH6FkwUlegwMQFcH+S8/YAOX2EXC4MFDLsnyfywSTm0QAxMURfgyKEq1k1 O/RcPZzkvDNCTkKPECizrLXt3GWkYJLz7pBtS5wkTc3N9s9D93gY3UJImKhGLWX/WOjJGLat GdkCAhMX5cD7l5H9dAzdFkFjKLuWavZ54NSxcbNJ96Rnw/i2MC0wpgARegIiRhv3+Ri+rRs3 FBICiiFk7KqBySaRgjF8W/cto3gK9U7UkzeRv6wU71uNFGinCxyGC0w0w9lhUnZwbVjb92oi V3hB+V6dwbY+CUnlBap8rTassYbF5aB88S9gcx0rt2CDGuu39hlR7sAFbBwdSODWO0leVfEM NlZx2fioa1w2Y22VnL1DbW+cBWxrxmXnl8NBq+MGNtdxEG2Hlxls7FqsVVxrPpoNWi5YYyWX a7+y4mvGmqu4PErUGi5YY67OTpRHyYw11q93rK62mcHGGs4uem0LrhlsbcTgQlQquWEtogN5 clflIYmtGSRggsD71zT53iTnrSFyFs2gzxw6m7fbRAcmOW8PkNNHoiJojjVJcO/kfDDJeTRA ToxUruc51D71XX5Wk6jWw0nOO0P2bYrl9ieJoK/Dh4k+H01y3h2xbwN6KQ+aLNIXvTNxJz8e x7c++pwAIeW1MXe7jA8M5NsiZpDy9PN9rd1M5Hw6jm8DMzBMXtb9C4M8G8a3Pgtknupf9pCH ng/jWwTAjJEhhb6CJpNw7ItxfBsBcg1VpnKn/vr63Pv4AH6N+ECxcvV87QEDtg+Dkb/maz+4 qE0Tm6Cmq0vskujyeRvU1hMh4AiVCeUNa7q+4NWtAhrUOA/VZVFnKE5Y85hPVAcEZrBtzCKK k6R0Fs9Y049QfI2S6HpvTVBjBbMTbVHNAjZdIWVX76bKpj0T1taEo9MGRRvU1smJHh0pnZwz 1vbjS45Ws5Kufn4Na2u+tb5D9/E1qHEWPjv1JKKGtT19wYWOsdfBumtZqIPKlcfbjLU139pg CaK2N+KEtYhRgJ+cZuUfA0avJsm+HMsp9JX32wxEaJLeGiFpqB2OKUfMvi+t1iTd9H6T9PbW kpZrKnqPOUSPPvHapK+NGYo245GbpEcjJBUggMQpcYzSUbNh02zkYZP0zojdKwIgIZU7QujJ lQZvklz7qEl6d4CkZfPWPhwQOaSuNlZoE68YyL0RgL0HoeD7IhYmjPRkHPdWK0XwzCLSNRAa TGKKT0dxL9RKWkkSKy8x9hQdgYmdPhvFvdWfX24MHFgCQV883ESnz0dxr6+JtBwklTNVmHpC FzaFKi9GcW/NkyuiItcch4A9k77zHzR2cRiYvCcxAmbHQecHaFBbN54vj1N1PuAMtvVUCLuo TdxuWGtPPK+1RbzuiC9Q2xhQcmltvNzVGNAEtU/KV2ZDz1jbGEHKNWtFZx0z1tZ8oQ4F0e2+ GWvrg/fkgui8UDPW1njJxagtnWpYY3pGpx0gMmONowSpnllKN/wCtmVA0I+XmLHGJlxji0pH bcMaczQ6VJc/Tlh7T7xyfTPW2IR9OVeVFrKAjY24xt9Z2yBxBptEC6B5rGB774aUF38xn4SU 1y6TO/Ru3GuS3hogaW2Skyil7MNq/souhyM0SW+PkDRmyCEDiojviouYjBZ+0CQ9GiIpp1DE TSGnvoEXNkOUm6R3BkhKUC4IKIQQ8lru2kZJyab1UZP07taSTt1yMEsMXMzV7+H80sfjyLdc qYqZpnL0Bi9d/aySTbhgHPnmVOfWSxE4Qo+hgk0HpFHkW3vJeMLCSMCEPbvXqAXSKO6tgtaY nudUDhsPPZ5lE0mfj+PecnOXSBmiQOIu7rUZqDyQezkDkRTqha6ObPnL+OibDRYcJip3ugLA yZrlXXMFTFjb9SV2ea1y71rvgAlrnDSY6whdZdLghDX35kX1hMQZbLvC6B0pgy0z1lbDnsrv VPLKArYNGYDPbrX8/JqOJ6yxEZNLUbsJZ7CtkgkdiTI1fgHb5nYnh8omNA1qbMTRpbWb6jUj nrC2/kbK7JIyJj5jjc9hdCzaqNqEtV0fl6MhaUfuzGBjp3zhDdLm789gWxNmF9ZSF6+XZxSo MUl7J8q46Yw1NuGQnQ/KU2QBm4QMsHmtcPtHYpJiNoiRaw5ozyvRqMAAm9dqgKQCOWJAzqmv c46NpPebpLe3lrQOvvCUQwD2ifpCBiapnw+apEcDdCrRZ5GizRhCWquC3CSqmLitHjZJ7wzR aZQYMpW3EvRUUhhNj37UJL07xE6JJZd3V6CcewYm2Njp41HcW7MwEjF7SZRhH0cmDORekBRS Kv+TctJ0eF1tSp6ejuPecpamIDlkLtL22CkYhQzGcW8gL7XAIJZDJnZUGIgJIz0fx71AVZkY ialvBjqYSPpiHPfWkB5m9hgBoWf7yiFm0BUzOIxZ7n0rUk3cXmGZq2/FhrVNIOToyrVFm13W wMYp/MGB1p+ygG11jKm88dVDlhvYVssILqBuF85YW49UBvX02BlrHDeIuRyn2smdM9hWxTXk qJ0eu4BtDZlrbF/n1Zuxxo5l7wC0k1BmsK2OfTVNZdOfCrV1O0Ys574yuDZjjUMv5TPRZlIv YFsFU3ZRlG2xFrCtEScs3KasqGtY4yh+diErffMNa6xh78JaXfs1BU9YayOuU7y0Y9InrEnk gJr3igZ4OiJhuWoThdXKlM2vYpN07XtN0ltbS+pdqv28YwDPdcZph6NOTFIG7zdJb4/QKSBT xugTrfZN26xTmyEKTdKjAToVLqzla/49x9X76EadGhUbUPNebS9prqM/InBEpBR74l42gxSa pHcH7F5fnjMSYmIk7JsobaLTx+O41+fM0Rd5U19vF5sE/CfjqLeYaOJCShyCT9ATODAqNRhH vRTEC+Ya9eoqH7HpwfRsIPXWwkriep4yhJ7j1MRMn4+i3trT0GcogubguSc6bRS0fTGQehOz UB1Sxn1d4b6wT+W3Gjg4TF3uesTm6ERblN6wto/YjE6S0hu6gE1XyEQuKv0oM9Y4hRBd1n6C C9hWxyk6v5bGcq2zxIQ1dkQll9TdYWawbdAAIbuUlL6ehjU24+RorZvkNSuesLYqjsllbXOO BWxrxiE7VM9ZmMHGOp4urkodT1hjf2MILmijLgvYVsmSHQRl4V/D2qpYQm3NpTyNZ7DtaQzl fAhKM1nAtjpmdKuJQxtqNgrW+DSurYe0TYBmsK0hcxKXs+60m7EmgYPQnFdhe08HlkNaOKWI cW12w2ZPh0ky6L0m6a0BknqIkHOMtTVIV68Bqy5FoXmvtpW0lub4mDOKQFFrT/MeMUnaftAk PRohKRdaqP2YwGfs2L1WcYPQnFcDNm9M5QiR6mLurCIxkfRRk/TuAJXmgFQ7ImIIXlLPmAoT N93jUdRbU4FikgDMZQdzj5f5C3uCdAcOBlFvrWsDEqrFBuWp4DtiJDaSPh1HvTn5RFRuAeJ5 tYvv7iR9No56M9XRxJkDJ/axp0mRUcXBIO6tNVChdvgPPkiVeN9qoF6M4t5yGSy3QOLa8Q+k p/wU4A8aOPhq45j185gPA5n3O6xRM8vzWuO9DVnoBWu+vtU5QhvWV7Cm6yPOjlj3+c1Y2/VV lSkbh0xQ69UFrQdlxhq7Gb3TDtwuSONQBrJDbVroAjY2XnGi9SMvYNsNKFw7qeg2YMMa00tt 2qxklwo1XV31/Cubx1Wkre8TRBxr+/AvYGPzqJ+KtrJgBtuuMNSMZeXp27C25lFO/HLlVx4g M9h2hdGhcl5Pg9qujlzQXl4mqLEJx1wnZ6oL/ArWJHwRmw8tDnDq51AdhpQ5roVpdujUv9ck vTVCUgKs408jgO/qZWHTR+h+k/T2CElD8rUZPyX2ay3xdjjq9UGT9GiApIA5F31CjJykZ6it TZrxwybpnQGSBqBYyIW8D34tcWOjpMGo7iE2H9qI3cuQxXsiTH0zFkx27+OR3AskPkqx0hi7 AqpGHZPGca/E8q6SolqmtWbUOxwo/nQU99aAam3IV5TqOcW1itiBPWe64xfjuNdTpDojPghQ V4mHSTHL83Hc6znELCkQ0Vp/zx2Gjl+Mot6a91D7JAVERsmxQ6dfmPew9+GLw0TmvQkS1LZ7 yt61C9h2hZGdrBULXV1gwxp7yoK6z8qMtXbEY1C6QSeo9epYH8Rg4yAGplD9Sso00AlrHSiI LmQttUxYY3phR9oPsGFtjZeDE+1Q6wVsayDBsbZyacbaJptnt/ryuJqGPEFt/YyYxJF2zMwC tjWROnxHmQs/Y23Xl6Nb6wdxraKlQm0NuF5JWFm0tICtHfHaMHhFmq4tosPVkvNr3YcmrK35 EogLXhnGaFiTMAE3VxUPmFDsEwVIWH2tXS5lozABN1fVtpLWNzBQIGRPFCL3pMQbDVbg5qoa oNMQGLhOkAi+zylnkoD6oEl6NEBS8DmlyBAppb60TBNH68Mm6Z2tJUUHmersL4qScO202SQp 2sxMf9QkvTti90IQqsOJKeNaNfUOneePR3FvnTpdu7WHKLV9UFfyv4lOn4zi3tqEzyeB7BP4 nhb8RtMGno6i3lqjw768gGIIWTz1NIIymqswjHo9B6rFSL4YaddweBvn+fNR1AuOi42SRE5M 2BXNYxOdvhhHvcDFPkMCyDl35Rd8Ya/MbzZMcJjF/AX97LXl8DPY2I2MznvlS3YB2/rJapK7 toHOArb9DH1tz6z8CBvWNmM/UnkuaxvGz2BjX20qv1SZ092w9uEC0HYGWcDG0b7gSOuSWsC2 PrMQXWZ1B50GNl1hbQ+Gyo9wxtoaciLHyqbsM9ba61jobc2fce0wmbC2RsLBAWqDGjPYlgkT O9G65Rew8QrrTBatZ34G2xKNOJ+17dga1nR9GR2u+sKurG/G2ppxjdeGtZ4kG2K7BWsSPEjN gZUGuOpYvA/sOXZm9BoFD1JzYG0rqXcCERlCIMhJ1pJtNgYPjFokpebBGiApB65OHRbOa9VF u2sc9KAJerS1oFjeN7kO7g2JcuwZVYzBqEVSag6s7c20Vhj4CIGBqGsos81g0EdN0rsjNm+u IyR83b8hc0+eq4lH/fE46oVcbs0pFu7NYa0xxWadGsUOBlEvOPSFccvWBYkIPU5JNIkHPR1H vVEkk8/lZR489lSyRROdPhvFveCyD+WAKcIyCfbsXpt5Gc9Hca93hYy47F5JIeTMHduXTSR9 MYp7wZWzBQMyRow9FySgLztkvtnYwWEmc3cSdXaiTqKesLaegOgdktKbsoBtYwcJaq83Zexg Btu69IiddpDmjLVdn9Qrm7pjSAPb6jgEJ8ppszPWOHZQ20SoO/7MYGOXXm1lrs2Vn8HGQcDg 0uoYzGtBwAa2jR2QS9qx1jPWOBRda/eUc1Ia1tbpGIM4VLttZ7CtmQi5rJxOP2ONU/qrZ1NJ NAvY1ozrxlK2FpuxtusTF/LaYNar62tY4/hVcqztTNmwxkYci10quxPNWJPIgTT3lWzvqKMA iEG45kj09OE3ae9yrwl6a2tB68RBL0gpBaxZvj0hEpO2EfebpLcHqDSHEEOQWP10XaNBbdpe P2iSHg2QNFJRpUD5R9nBawfZRj+diaQPm6R3BuxehIAhlUdxJugK8Nn4Xh81Se+OIKRYE5nr f7HmbncwklFzokHUC47KnT5BbdoOayfMZj+d0WyFYdSLHn0W8hhwtdHk5s1rNJR5HPUico3b +lQjBx1KzSbR6WcDqdd7iilzKDs495TMRKPAwTDqnQIkqXYS83FtaOPmvnBGsxXGUS/HBCnk WtsWe+bafGFnrW81cnAYytznlSfH2srvhjX2omTn1y4q17woE9Z0fcLsIOi8PDPW1geQnXrA 4gQ1Xl35RLQJtg1rmxtaCzBYO455BtvGC+pIDO34kRlra8BQf6e2YmjC2jrxPLi81v/xqhOv YW1Dah7LJUmXXTtjbU3YZ4dJGSloWFsnIwO4pCWZBWxrIiT1uartXtPAtrECL05nIhPS2Atf a3+0XvgJa2vAgV3N6tNZ8Aw2zhwhF5ShtBlrbcJcfql60nYDm0QKcnNX5SFdwzGW9yGmRF3t QEwcc/eapLe2lrS8g+vAaQ71L5KuBkVGNQa5+au2l5RzyJEYU2ZaTSvamBRpkuj6oEl6tLWk hRFyiDnWhiBAa4+hTYJSMJH0YZP0zgCdJs+MddRIjJKgwweZjEIFufmrtmckiASpNuyh1Xyp HTazeTyKer3LkWuEK3LwnHpyerNJhcyTUdRbD5nsM3mq3U+6GhTZHDJPx1FvypATFs36XH2u HWZqVGMwiHqDy5JjEODkM+YOOw023bWej6PejFQZSUAEepjXJvrzYiDzMnrBJEi49ij8Q7Un +gphAN3AvQGj9nrGPutegKZr2t9xz9nrdFhwxpmxrjxctK1dJqxxdnZ5YSnjJRPU1hkSy2Mh Kn0NC9hav6hstN6g1tpNrK2haVhj/aJLSecqnLG24ZKiM4lKV+uMNY53ToOplPHOCWus4OBA lO7WBWxtwGHtcXNdwQVqq9/sopb/Zqytr7WSrmj96QvYVsHkSB3TblhrE/ba9c1YYxOOhTeU HLiAzU3YawMSDWtO0urKngq1NuHgUDvMZgFbhEvQTz678o+tPVk+g0SJ2ZcrTtcwZBM37L0m 6a0hkiYUzBxyzj2udSNJ7zdJbw+RNKTkoTyYMq1t3s2SmiS9PmiSHo3ZvRQkUZG3b5K3zTiH JuidEYKGRKnwn9TB5Xvnb37UBL07xkqJPQf0fS1trKY5DGRe8gEFokCGtaZ/myU1qWl7MpJ5 Y/DsgwTMqWv32nRkGsi8ULZvOWXIS+hLPjCR9NlI5uUsuU7pYN9TvGck6fOB1OtzTIgojLDW FWaHkr4Yyb1ZfD1No4S1dscjJd15vGRHhRX7O/V5X2MFNVVT22R9xpquL6HLrEsdb1BbL0CA Ov1A5wVoWHNf/NpIoA2ueLHde0VhsjZX7LpuC9TYh5ddVJYdzVjbOEHRWHmdqQMtFWurXnIM Si/tjDVXMGo7HC1gezet2olXoLb6DY60Xd9nrK2TEQO5rI2zNKw1O6vjLBPUWr3gdVH6BjU2 3qQfWLyArY235jBqrbdirfWL2nHoM9bYfOunstYu4pqGJ6xJhACanwq2zxZMnFISjJH92kVj Y7agSV+Be03QW1sLWp+/kiMX/QRaTfzZaYAAmptqgEqzF6wOucx5teZ6d4NkHzRJj4bolDnH HGNmv39eqodN0DsjBIUsjEhUiyq6JDVJ6n3UJL07RFIp2pQQMPfNkTUR9PFI4pVIyUsdrxq6 uvSYMO+TgcwLtXJEJAaKa5e5Her06UDmldoCjjDDNKB933T6bCDz1nZanMt5Cl259zYqfT6S eQUxU4hEcW2W5g4lfTGKeeu1gdEHDr5yL3QFCL4sseCbDRDs6bznfQ0PJHCgdCA3qG2aIJED 0GaRzWBbJwBH59XJ0jPYdIWcXdDOa5ix5jpGUfopFrCxjslFUtazNKxtoCCVA2ati8FVI56g xgouu150H9+MNTfhoM1FXsC2JO1d1NZ7zVhzEyZlMvKMtfU0ErNL2oKCBWzO0qQd+9Owxir2 DvVjfxrY2Iyxo6xlBlvruI5s0+q4Yo11XD4U0BZGzmBrQ671cHodD7kqKEIG2DxXOOKhmCv5 CEUPuWuKgUkG+r0m6q2tRa2v/9rwxCdB9HuY23q/SXp7hKQefHnYeR899U2mMKoqwOa6GqHT CILEQj6umekOPToPm6R3hujUEwAxpKLc/dPpoybp3SGSSmbCXHN5ewbImNUVjCPfFAOihFS2 b1e6vVXYYBD3TgGSVBTKklKmnp73NpI+HcW99UAtW9eHFDGzQI+kNl2YRnHvdHVgT2ULxyQ+ d6Xb20xsGEW+VdSAEOvAHCEOPfE9E6W+GEW+VdKyaQEDpByzN1DqNxs42Nthz/saOig7rGxP 5Xt2AduuMEeXsjZ8MINNVxh9crT2zLuywBlrrGNwQdurZgGb65iVDcRmrLGGo4vagd4L2DZ8 AD44Vk/MnsHGSg5O6zmbscZKZlduXUodT1hjMyaXtbnAC9hYw9XprjXjCWvreYxQfdo6DU9Q c55OURkiWsDGCgaX19Irryl4whqbMLogSo5ZwMY6RoesPosb2FjH3lHQVdTNWGMjLrdQXHtF XdPxhDUJH1DzYNGAzhicfKx525z6cplN5uXea5Le2lrSya8Ty9s/CgOuBXZ35wG43wS9PURQ oZxYYoCAPXM4zaIH1DxYA3YvBhCRLLAeC99p9ICaA2uApJ69kMDUfqkrFd9mhEOT9O4QSTNK wuRD4r6OWkbRg3Hc6+ulCoE8eIseIN3Rg3HcK55ykLqFadV7scvowUDy9YRc47cRw9rNZpfR g3Hc61OWAOCZQl/VgVFXokHcW2NfBCApsBBzV5TPZCz7i1HcW+00E4NAksjEXz/29a3GDvZz 3PPexg1CzW1Tunoa1nR9WNsNa6MGC9jWVxHFAeu0O2NtNRxrlEw9YaGBzXWcQRnyW8DmOkZU JtwuYOO4QdVcj5bNlcwuK9PSZ6ytirkOn1B6oxrWnKgJle68hjXWb+0Joh2kMYONHY4xOxHl EhewOVdH7WjqBWys5uCCKHvwNawxU3tHytqSGWus4TogQz1roYHtNawtolzA1oZc4ylKrm5Y k8hBaN6rMKLTNEF5pyWKoSdN0myaQWjeqxGSsviQ0FOOsH9die83SW8PkVSQsQgbZO0tuENB HzRBj7YWdMoHzXV+bvIcUuxog2LjpnvYJL0zQqVQtckpp+ipq+zAKHAQmvNqxObFzFDOI1/e Dfs3iuPxSOqVQkfkow8E+9c97cko6q12mjBOjf6rT3L/qmaejuLe6ntljyn4AEVY6GhuYxU5 GES+NWobA5UbWW1t0zfR22Qax/NR5DsdM8VUPfmi3Bj27ph5MYp8W+QARHIdJRPWkqK+pcgB fo3IQWE1r82e96axg8NM5t43bK6TpnS+sga1XV10HJQZ3jPW1gMQ2InS1ThjjX0oDkk7UrhC TVcX0JXjV7W6BrX97LB8Isr2RDPWNo5R7FG0kZYZa2u8wWVtDc6MtTVeT47VfvgZbLsF2QFo s+Mb1taAyUVURpxnrK37ExhdVjZ4mqDWBpK0owJmrDEDVqvUMuCENTZgdGvz2a6Zb4VaG29i vfFWrOn6qB4JypZEE9TWdBGzk7Uc46vabViTyEVs7rM4wn3GmFIGZNrD6cT3mqS3tpZ0KqBO HmO5XqbYNTrSqughNu/Z9pJKbX5GBBnEQ0+DBzHxKT1okh6N2L0xSYJaxkKhr+aBbUIXsXnP Bkg6FewgSo6pz/drUpv0qEl6d4Ck5H1mTzSNlOgQlIwiF+OoN/hcbgQYos9dnaFMNPpkFPNW jZady55rKQD1dKonoznM45gXskRJHEHE9wzXFpMarGfjmBfqcO2Qy98YewI0AEbtkgYxr3cp JsCi0EApxNiRCZBMzpgX45hXKEg5ZzyW87RrxM0X3hv2Pm5xmMO8J/EBACqMo+1hMoNtV0hR /VCcscbv7Po7tU28Z7CtHwUdKQtbGtR0dcIuKY2jQW13n5CjtavV1d3XsLZRAoBUnqXaZmIz 2DhIhbUtgjJKNWFtDZjZ4VoZ4lX7bVjb9SVHynHlDWq6upQcrlWrXlldgxq7GSk7Jm3V3Ay2 jRIkl9f6F1+9HExQ49OXXNCG6Bew7ekmUExSWU7VsLbmSw7XWhlfNd8Jarq6WO4jSRnFmLHG BszZSVYWAi1gk0gBN3cVD3BXQYL6CAbMa7UcO+2OxM1ftb2kUM7O4CmXWxKGnmoOMPGf32+S 3h4haayjFTFKTGEtQr1ZUhPfxoMm6dEASTkhprqDIUnXRGY26VvxsEl6Z2tJfS1AK6IyRo/k 106cjT5IkzjXoybp3QE6JZ+quypGFA89MREbv/LjUdxbdMpcxCy8VHOnpSNYICa798ko7p0G FVMiYCIKAfZuisTTUdxb7dRHkDqsGP1qIfvu7PTZOO4NwpQ4BAmyOo50o50GE0mfj+PeImQA ZooZ/GpO1SZR2eSO9GIc94aEUM7SVGczpR7uDV/GSN9srOAwkrnTE5BciLp0vBlr7OWW8r5Q 9mNoWNuXtk8ur/aEvfrUnsG2rjwuR6cyX3XG2u7ABA6VU8FnrLGnxztC7RjIGWwcLfB1+KQy Y7phjVUcXDn1lO7GGWybE++jI6WOZ6wtzYgr93wdyUxQ40Ok7PqkDeZOWFt3Y/RQPYhKkp6w th9gYHXFwwS1PYMhlE9EeQY3rK3xpuxQ2Rpuxtpq13P1BmtnKTSw7QoxuqQtOWxYWwMOQrU3 vU7FDWsSLUjNY5W2z5oLgtkTo/fclbCcok20IDWP1QBJmTzl8hKmmMJaIenu8gPvN0lvj5A0 i49C4kMOfm2cz0aPldEshdQ8VgMkjYURMHNgSdjTVcZGpw+bpHeG7F6AyNlLHfXaZacmkj5q kt7dWlJwETLliEwQuxxW0SQ1+/Eo6gXnOZdbi6RaRNE39NQoWDCMenOox0uoA7ZD6GopY+Ju fTqOenOgSIWJAgpG3jtJn42iXihvKSnHjJcAxNLTz4tMAkDPB1IvlZd3rK0UMUDPvcEky+DF OOYNHBEipemQOcQKDlOY9ydaINklbfeSBWzrq0jR6Z6JE9LWT5FrswpdUuiMNfYCkMOgjAU1 rK1uazuItTNuU+sIMdZvTTRmJaksYONIAYuT1R571/pbNLCtkiO5qJ0PvYBNV1jeuOWX6sx4 xpondydQhiQXsPExEpxog6YL2Dpi4F3N81SGDBrY9kOM7DBpz+IZbMzXyeW1x9c1vp6wtkG1 xE45JLpBTVc3lYUo20xNUOOYEDvQ7r4FbGzCxDXSqDThGWwSNZDmupLtcyLLCxGYxEeoL8Z9 y4m81yS9NUDSDDn66BNDQFiLVG106Ji4I+83SW9vLSk4yiGJUIwxSJ9Dx0SnD5qkRwMk9RJy ZPDBx9U56Zsdryauq4dN0jtDdi/ViWkRfM7S5Y40GqQgzXe1vU6BkhQpYw7Q0zMMwMTv+ngg 9SJxjoFqkrb0eOlsWtc8GUe9KRYDJa5p95R7CmRsQtNPx1EvcK4TXYDKObOWbLB595pEgp6N ot4amg4pY0RJTNxTC5SMSgwGUW+N7hV9SkbAlHPXqCmjAczDqBchF0KSiBi4pz8afhkhfatR g8P85a53ImOd9qas856wtuuTOrFYOw1wBtu6GxmctpZ/xprnrq52Td2QvFqwxg5lcOWapnUo N7Cthn1yXulPnqC2MQNEcGsn57UKnAo1/fAo1fZRyuqMhjVdX/Lo4lpry6vlNw1ra745unI9 UrqRZ7CtAZdfmpR+2hlr7GjM5dzSzndfwMZRcXZxdbDhtcB4Axufw7U0Tn0ON7BttKAcDeKV n+ECNj6Jg4tZ6fBewMamXM4HbVenhjU2ZWQnaw0jruq4YU0iBrm5rfL2bquQaoUBce2OsdYe b6PbyqjOIDe31baSTt1OkIGw1ttLV2N0o8nLubmttpfUM5S/BDzFteydHTb1f9AEPRqh0uAD hYwYKHX5csjEu/ywSXpngKSQGClniLE2gu/xRJqERh41Se8OIKRcrmssmZACpp7SEZsGNo9H UW8dvhFDTjV7OWfqmrxsYqdPRlFvHR2TgRNQDiJrF/edDl4eRL3lOCWSOuEr+HJrXhs7uLvR Mc9Gce80pDdAqrEgYemhJJtxQM8Hci8XFuVIyLlnJIVRj78X46hXOGUWpgBcS/e+epe0vY8Y fLW5y/rBy4fJy/sdz0hcZ7noXrAz1nh9NUShTK1dwKYrFIwuKFtjz1hjL4qrqWZKJ8qENU7v dl45vLpBbVfHoTxetL0uZrBtPKM8rVxQehpnrLEJ57KrdP7uGWu7vljHTShVvICNU+PLs1I5 3WOCWhMMaPuJzVhbJyjUFqTawoKGNd6AldeUZ3DDGhtwuVtHZUhtARt/guhI2U5nxlobMKur 1BrW+gxGdaClYY1NGJNjpYnMWIs4BvnJmVb+sf0cZkghSHmjB+zy7tu4mO41SW8NkRQJA3Gd k9kznNhI0vtN0ttbS1qz5MVznZfBUrM1963G40GT9GiETllSJpYomHOXTm2mKzRJ74yQtM7F q+PSc9nFPd40mxqPR03SuwN2r+eck3D0lEI51DuamZvo9PEo7p1cwSQkEpCJoKMgwMYV/GQU 99ZAhg9Fp8iptqzbO6f305HcCzU4JT5nTj3RKZsKpWcDuTdwuTH4VKSU1BWcMsmAeD6Qe7Gw b5HTZ0pr3aE3S2pynr4Yx70ppeCrYgmhrzfUl50yex/JOExi3pt4AerTaxewuTvPi9IftYDN P0PUeswWsLU/ALTNGmas7frKAR+V/dknqOnqshPl4iakdbQgONI6GxvW2Hxrv39d064Za6tc zo6Dzhk/Y61NNyvHqDeo7erQ+aR1hDastaMxuAjaYMEMNjaQOk9EOcu6YW3XF8RldcR+Bht/ gt6RtqHYAjY3YtL74yvWdn3garcIbUStYm3NGJN3vOZHv1YfNGFN4gXQfFYwIl4g4ilQZL+X 8QJoPqshkkbIHCggrj2KdhovgOaz2l5STAgoSdhTTyd+QBOH64Mm6NEIlcZyrgfi5CH3NUqy Ga/QJL0zQFLwCF4EhDOvzbvanHxrsnkfNUnvbi8pOiauDc0TFkrqMVO0mX36eBT31niBBMrl r5Cxp0mdVbhgEPVOgRFMsbbjj2m1ZcMuwwWDqLdKGiixh5B8jnHvqnaejeRe9p5yKM+C1MVI Ntz7fBz3ekqZoBpp6uo76G1mMY+iXkwulNMlcs41PtJBvZgOAxYOw5i/5kOb2aGy1cqMtU3d J3FJ645awLbeRgJtS+cGtXYDoDpM0LDWYYKgXl/DGrt5an8crTt0BluHC1K972pjVQ1sa8SZ HCiz92essZHk6HJUe8tmtLVbXj0t1Y2YldpHMkFJgQ1qHDAIqWwpZSyyYc3jaWntVrghnlaw 5qn7fi1vaUPqfsHa0kuMzq/ltF6ll4a1No+YtKNHGtZ2fWXPB1LW9zWsrQGn2rNDuf8mqEmg AJuzCkek2yNQ9uIh9LQjMQsUYPNWDZCU66ABqK/9vJbgsEPPxv0m6e0BkmJ5i6QcE0FajQRv 9rWaeKseNEmPRug01zR0IUZIuStSYOKBfNgkvTNEUgAK5YnE0ff1mDGR9FGT9O4ASQE8JqJc 7E76GpKYpGY/HsW9U7o9hJy5tpqhHs+cVaRgEPd6J5lr9GeqXpOudHubDkmjuLcWFhTmxTql 2KfY07TNpqjr2UDuxSApQdFrwr6bg4mkz4dxb3C+iBiFQrk+9PSQhGBTQ/FiFPl6FykyJsZi r7Vppl7W+GVRkW82VHCYxdwdLAguiLYNxww2D2eUk1y7wga2DReE7GS1VvOqgmeweQIwKtOT J6jp6mqP5rQ2/Opq2mDDmq4v+uAoKnv9LGDrgAG54NUBgwY2N2N1N44FbBy3InLqnl0z2Hgj urhW/n5tG1aotU/UK0tIGtTW48ihtn5WLa9BjR3y2ZFyeTPW2jjKjlJHdRvYeIU5O6/up7Og rc/h8tRRF+JUrO1NJjtWNlVsUFsTDkj6y+oCNgkcUHNe0QDnlcQp7Z4gouxf4v29JuqtIaJm Bg+UUyxn/f41+L7fRL29tai1f434mFPCLKmvW4TNNOYm6dHWkgaH5V6Ug+ea7NozzzagiU4f NknvDNi+npJgpuTRpyA9nTFMMl0fNUnvDti9mIC9gBf0ID2hA5sSmccj2ZeQmZMA1djB/oUO BpFvvd5SQh9SJsKuwJfNEJSn47gXYoLalqi61PuGiZsEqJ+N4t5yygCkBJ7rMdNlp94kxPd8 HPcW64w1756KxNwzTNxm974Yxb11NEjmiBAkBZ+hI+tADpGDnsjBYR5zb3qjV3c/n8HGKfzo MinTfxewcYpepPKE1uawNrB1Ij+q+yc3rPX6WJvjOEFNV8cxu0jKj28B20cNsrYpUYUaRwyS A1T2JGpY47BfcNEr/Y0L2NZA6gxebf/uhrU1EXTlraW0kIa1dThGqD5EpQ0vYFsjCVyYTRv4 m8HGd4VyX9fmyi9gY6+89261t+k1t3wDW4fWmJSjSCaoLRE6Ft39eUIam3BKrrYX0JnwDDaJ GYTmtQoDig2SgEDEDOx7EtNt3v33mqS3tpa0vIYRkVPZQyJ+lVI2voZNkiPvN0lvD5CUQ04h +shYjpUOQdkkNfJBE/Ro+82bHFIodApUXek9mzehyfDTh03UO1uLGp3kkMpDrl5jQs9giihG xQahea22372piFiHToeIIeQOrX5hJ+3uiMEg7p1a2OQYeGrZk0LPFAMTSZ8M5F4fCAICkQef OiQVo2KDYdwryB6ZRdgXW+0Q1GYa8zDudVCbhxEz+5x6+t0DmLjRn4+i3lo/4sM0FCgliD0T OExuSC/GMa+kWA7Scj3C4DP2bN7f6QyDrxAN0E20GzDLrmNNyuRt0zXt79xnEK9TYgXavuTF ESirVGas6fqInLDOp96gxjGTVH6nUrUNa+xwdVnrEZ6xttoNLmi1O0GNtZudT+qh2Q1sGzGp StPWIs1YcwWLMi47Y21VXMOYoLWQGWxN0F7bR3/G2mo4Oh+VH+CMtXW4QqytMrRWPIPtz2Bl b6sJam3CtJa9dd2CC9T8BM5reekbTuCCNdetskSqQa1vV6Ccj9CgxqYbxIl6ZvsMNomVxOav i9s7AlIOiUCAhHJP0YGNv+5ek/TW1pLWbFAhLFIGTD2ZzEZ9JO43QW+PEJREGImp5r12jUE2 8WI9aJIejZDUlxeD1BGVucuLZRToe9gkvTNk89YWKEQh5tU2hTvcvY+apHeHSFpzRrDOW+G1 XKwd6vTxQOrNuQ63Dp4lQl8TfJMIwpOR3BtjHWqdpNjq/jXxeTqQfGvyQSjvyBBlD2v4ng0k X6TkMyAFH7ra/1k1ZhpEvsVQGXOIiVPGuNo2ZOMdyaRi5sUo8p2qbVPKhUrLYRNDl1K/bPvu PFyyo/KK/R35vL+hgvK6X0uIue4H8MbJ7VIUpXtmN6jp6gpTO1wbh3W1oVDD2moWXdJmxM5Y a+1mbZuFGWus3+y86GxjxtqGCYgdKM2jQW0zstEBaQehN6yxesue8sooxgI2D7MkpR9vgtqa b3Yxa8sqGtbWz1htcrWx9Ab7LVjrGAtE5Qc4Y635ea1h6nV2ZtvwBVLNK1N+eAvY+vQtzxv1 6Vux1uaLa96969ZboNbGS3XAqlbBDWwSJODmqeIBMw2Ay22fs+BqR9kdzjS41yS9NURST0zl wR8w9aSkm01v4OaoGiCp5/LQ91VQXju6d+hnfdAkPRohaQSJAKnwal6bL7VZUpPakYdN0jtD dCo5hKLRcoNeS0XcoU4fNUnvDpEUcy1+Shlzj0fOyM36eCD3EgFDhlhncnRJapJ9/2Qg95YT RlJIEGGtPHGHm/fpKOqtMfcAUmi3SBsT9GTfm/QPezaQegv3RgYiLP9nHzswDaReyqkcL+XW 4HtqZIwI6cUo6p12b3kgcwqBygnZM479MOa5K0Swp2Oe9zdAwFwruJR+noa1zcWrr/ukzBVs WGM3j7igbce8gG01HN3qgXmtg1CFGuu3Tm9WdnxvWFv9sn7/zVjbMAGLQ62fdoIaq5ccq4sd ZrCxgsvxHLRxlglra7518LAyjjFjzQk6aGsdGtbW11hOrDo7S8nQM9iaoeNaV9nrDF2gtgrG squSttxwBhufwanmGymP4Alrq9/gRHf9m5DG2o2Vc5XKnbDG5jsNKtH11ZqxJoGC1JxVaYCz CoNECcSpb1ajia/qXhP01ghBQWoD+IzBY+jynhtVE6TmrBogqedcTpLyt8Q9viqzOEFqzqoB kiIgxxRylNzV/cNGpw+bpHeG6DQFjBGqqD1DKcziBKk5q0bYaY1YSq57eP8EfTyKeWvmLjCU 61SQkHzPjHKrSQ2DqLdmY+dIWOu4YqGmfXOePx3FvFMyNntKMQN4v3bp2mktwSDqrV3DEiaJ GRPVwrV9273PR1HvVEuQckw5RF/HcOxfLcEg6q3bN2QgKTs31inPX12n32ycYG9nPO9vpCCz o7WWfVfW1qC279iMtQuo0ksxg01XGD3pu4IsYFsNB5fW2r1d1fAEtdWwZJe1kyQa1li/oahM V1AwY20jBVkckdKTPGONTXhqzqw14QY2XWEoH4vaGb+AbT9D7x0oB/7MWHMjVrsbG9bW3Vi1 FqOy1fsCtmXp2u5aeX+ZscZmDI7WPJnXrHjCGhtxdFnbzH8BW2sYtB10ZqyxEYvThuwnqLUJ 17uTbgPOWJOIgTS/lQxwunryPggzrV44duh0vdckvbW1pPU9jByD+BCgvIh7Oi2Z+DjuN0lv D5HUQwwkVKtG9s6Z86AJejRi80ZOETJTBO4KjZj4ch42Qe8M0ajE2jAcJSfo8S4buSIfNVHv jhBVshdIWN7VfQEvm937eCD11vilhCRJuK/Xh0lw5MlI6o1Ye7/FUPtn7V+5yNOB3CsxpTrC uiafraWC7W77PhtIvhhzCsSSysWsi5JMkg2ej2TfkCHXLncZcf+msL8YSL51cFfCctZ4Quy5 OvxOpzXsKGawn9Od9zdeUHu7agdzzljT9WEkR0pX2Yy19SdHcKztZL+AzTVcu4iqVVzBtjoO 2ZV9r+wzMIONtYzOZ6U7bwHbxg0gTD4SrZob2NyUkzKHf8YaKzk61Eb+GtbYkIMLynYhM9ZY v1i4Q5fgPWNtXY4xsiPUnSUz1ljB0Wnb1cxYY56uhXHabl0z2NiEy7ZXjk+escYaLjcU0gZP Z7C9EWszNBawsRkXblOfxQ1rEjnIzX2VB2TSQay+q/JiDNgzU9Umk+5ek/TW1pJWRx2kOiUX iQPuX5/w+03S20Mk5dowggPn0NdFwajYIDfv1YDdW9uc1GRtqf0xeqJBJmnMD5ukd0boFCAG lAACvNajdKfFBrl5r0bs3sQxUvSJfE+Az6zaYBz3psQgqWiW67jcr+6n6w4dDOLe6k/3kn2M vtpq1yljIunTkdwb64icHLroyGjvPhvIvEy1wosigOc1h8/u7g3PhzIvAXLhpHKB2L9RKi9G Me9UP+JzhiyTcnuqKv6gtQb4NeIG5T7ptdmY3jRycJi8/AWvbK6cr60ymMHGK5zGX2hX2MCm KySfHXtl1GAB236G4FZHo139BCeo7ecXXQblTI8JavzZgX4wasMaRzOKVYpyNuqMNU6uDdV5 oa1zaWBbR14Sl5XBlglqbbwctN1qGtZ2fVS2lNI+JqitC7TO28W1aYnX3MgT1vbji9mJerb2 DDZeoThmXaHkjLU1X44OgzKY1rDWBoyoLM+Ysabr6xiMsou5KDE6UI78alCLCEbwkxet/GOA xyVkYoqYwO9fa517TdJbAySFkAUZEALD2n1lo6Rg0oL/fpP09taSepc9QJU0egp5LYq+0RNh Eqt50CQ9GrF7Q/AxeZ/raJCu3t4mY6YfNknvDNApCccQkRFqK/MOnZJJ/u2jJundATolJB9j LubqV+c9bdQpmVRjPR7FvVM1ViaQFGrDr/3LqX4yinunzlARfMKUU0prQ/h2J+nTcdxbu9Kj 5xgDFtV2eIHFxLP/bCD3FilFSMoeXr1e7nKuwjjuxaLS5Gvxg/BqStAmUdEkTv5iFPfWbuDl zgDlngSJVztHbJI0HkYvd0UKDqOXv8gTry7jX8C2ngCKLpF2BO6EtfV0Q3JZ6wpYwMZZl668 R7VJlxPWdH2SnQTl+massSuZHCi9jTPWOlpQjlPtGNcFbLsFy8eSozbxdwabrjBQnd6uc4jO WNtPsJ5aWiNuWOPUcxejunpkwtq6HBGy0xbSTVBb9WZ0KWv7EU1Y4/VRIV5luLlhbU9h4XI1 UU5XaFjrgBopwxkNamu8qOa+BjUO9zE69srCmwVsEjGA5rWCAe9+H4izxPJGlK4W9Sbe5XtN 0ltbS+rL/Tzl8hIGjsUGuUPUZOJdvt8kvT1Ap5RSCiKhXKhDl07JJMP4QZP0aIROgTBmX3sJ ZVqbQ7ZRpyZeq4dN0jsDJGUQYhQSDyF2ZN6yiRv9URP07gBBZUoZBwpU/rlW37/R5Wozh3kc 9WI5LDgXG2XyPZ1JAE0kfTKOegWRoNbqAJGnjri0mOzep+Oot8ajk9QIZqK1JoubdWpT9DCO enPI5EP5GyJK19gBkwD883HUG6cBzJiZJEvPIRNNjtMX47g35oihPEIhEXJPuIsPAYOugMFh EHO3Hw9cXpv3fs2NN2FtXbVBytNe56aYsbZexvI41fmgJqTxZ+eCcoZwg5qujutQVl0pUIMa B4HAsaiDQA1sGyRA5HKp13YvmcHGkb7yZlam7E9QWx+ZT47X3gdXnWQNa0st0cna1LSr3DJB bQ8O9LVfj3Y+bwMbBwhyLZPSHbwz1tgFX941QXlnWcDGgdL6qehIesbamnBILqzdp691zpmw tmdcdKzt7DNjTdeXQ61E0hUVTFBbAw5UPhOvC7LMWJMgATZPFW7vUIaM5V6YMMewVr24wyTe e03SW1tL6l0mJAw5ZCHuaeudTTpA32+C3h6gUp+TeM8+RuK1JKfN9RNGVQXYHFXbSyopQCaP ABy7+pCITV+kJumdAZLmmIVFYs6Yutrv2/QhedQkvTvETAsPCZXN63G1nnp3dvp4HPUCIElC lHJxXpsMttlObUYqjKLeykgYCYJP5YXaM4UZvFFVwTDurQGu2l8GA2JPuyAAE4fys1Hci44l UKrGWv7b06kN2UTS5+O4N1IdCQJch590cW80yS54MYp7q/sjxQh1CLMv5tohaTgECbqCBIcp zP2OAM8ur3UPvOoIaFhbXxmwk6gdkTqDbV0BIdeZKTpXQMNaexs5K915M9Y4UBXcavXntUDV hLX9/BDVI2ZnrHG4IAZ9E7EFbEsyUilX6Q9dwOZGDGuFuRuMuGBN15fIUVI2cZqxtkYsycW1 W9y1M27CGnscfXQoSiNZwLZGAlT2vdIl37C2gdPCHKi8Yc1YW54WcNqRDzPW3oSVcecZa2vC EZwEbWnaDDY24nI/SagMGzSsSdiAmu+Ktk+GxISJA3vhlHu6BaOJl+5ek/TW1pJ6xwmqjFQn MaPvSc828THfb5LeHiBpzsK5ZqHnEHzfiGKjwAE159X225d9ZAYSySn1DJ0GNiouoOa82l5S n8qmlanHVOzp5wLeZPs+apLeHbF9a592QipPryw9HcxtQiSPx5GvxxxyqhEhymvJTTscZvtk HPlKVaVkCEXiHiezmCSiPx3HvSkUEkVf3a5h9eKwuwq2Z0OpV6jeHDL2HTI21Pt8FPWWzcvi ieoNqY7X7ukwZdSNaBD1Qm3vwQDEdep0T10X+C+z0281bnCYxNzpqcDoIihjBg1r6wnwycWs 9vU0sHH6IBbrVubIN6ytL4BrLzT1XIoGNnYpR5eVXbFnrHHUhR1p+zovYOO4QQouKGe2zFhb h2PdV6KMXC1gWzP22YW16tyrZtywtmbsyUXlHOsZa7s+RBdWrzbXSg0a2NjlCOXcJ2XkZQHb MiGDw6h0LC9g4whqcLTWP+RaBHXCGnvmxYm2s+ICNjaU8kujdojLDLZdIYgL2vDGArY15ZjK M1l5bZ2xJtGD0BxYYUArhfImrgUHEn1XPigaFR2E5sDaVlJfDDAEBMllE5VrU097DJMsyftN 0tsDJM0UOAQWTH7/srYfNDmPBsjJIYKkolOM1NX2nk18kg+bpHcGSBpQiFI5QSD42DPNNpjo 9FGT9O4IK83CGCVB9sVOe+b2GjUmGsa8ECVkLhrlmNdSODbnp5sESZ6MYt46cQQgIHuGTNA1 z9bEo/50FPMWnVIRsBgoxpjW+kFu1qmJnT4bx73isba+yzEJcddpamKnzwdyLwQCSLncePzq 0LeN3GszjXkU99ZHHtZWU1SnxMeuVml/0NjBV5vGrB/HfJjHvO+RDYjALmrdPR/RtmsMOTrt Q7thjT9Djy6CdmTqgjb2Vujz0Wes6fqyg6xswd+gtv4yJ8p6jQlpG9UoRolOQDvAYEFbm3By tZOp1ogb2tqMp97wajNuaGsz1vYpqkhjE05al3KD2jpDyYtLa+l8V2NrDWttIsEFUY49nsHG K0xly6tnuSxo4zVKvaFoyXBBWxsxaSuHJqixGVNSm3GF2pqxlLu77pY/IU3iGbF51eKAzPkU Q+JMkRjXBsLsdNRCbG61bUWtQyXAC0bJHGXt5rxDSe83SW8PkdSLhAgxiPQ5EI2qIWJzqw2Q NFBt3w6+8Grcx+HMsbnVBkjKQSgGJq7dwHokNWqjFJtbbVtJKVcPYi7ajMIBOrrVU7bxID4e yL5SNVprlxhD1xR1o+nMg8h3krT2sGOfU8o97eqtpjMPIt8qadEmgIj4kHoGxttI+mwg+RZ9 FlPllDx3VVJ6k1yI5wPJFz0SSR3N7Gn/JH0xinyrpBgzCYL4Hj76UkH3PqRxGM68P4GDQjWu XOHVHr2Gtl5jLr9V91xcwNY+R3A5qH23M9rYIRBIGdtoUNPViVPGrirQOGiApHTWNqh12KBs pqger76grc3D185D6jU2tPUaxTHqP8eGNjbh8hrTmnCFGptw1K6uQW09jsklbZOYBrV2ymfH a+Mer/vkJ7D1CqUjPL6grcMG5Nau2NeDBhVr7ZTXxl0a1NiAaS3j6pr9FqS1+YJyrMaENAkY cHNZ8QDfMnEd+Rpz9D1+HLN4ATeX1QhJPQv7lLqqH8yiBdwcViPkDDVWwBIj+v2T9EGT9GiE pJGCp5wo+q5c+S9t9tAdLeDmsBogaZBip+KzwGrZ4g4lfdQkvTtC0uRz2cEIkTD1pJDbdIl6 PIp5J8dyIV+pw1EK93Yo1SpYMIh5q6SMnMvDPghKTwq5VbBgEPdWSWv4PWXEFNc6LewyVjCI emueATBmoOwTSuiI6tlI+nwg9WKotVhFr9xVTmgWKxhEvVWnGGo1bPBeUk9/yS/U6TcbLDgM Zv6SxNqQdHXoC9g6UCAuR3XW4Iy2XSN7dDVdStuiqKGNHQGsbKE0Ia1z+LVO2gY1XV3t16Rs 5d2g5sGC4Ai0BSQL2tqIo0us9jPOaHui0fZBW8DGJpy14fAGtfY0rs2Tuu5phAE+2h5PIwu5 BMqRGg1rvflwGqGn3X0NbR0sACeszI6fwdahAix7S1sxuaCtz2EtVzeo9UnstWMhJqixGTvQ Bqsa1CRkkJrjKo1wpMdYDugEviuh1yxkkJrjaltJp2oKSRHKXa4Oat6/6Mj9JurtEaJSiFKr R7zEhD0OHaO2Sam5rgZsXyxaZe8pJI89jWdsetY/bJLeGSEpowfOUvubr5U87bTGIDXX1daS QnAci7SBiaCnExbU9kM2cYNB9NvcdOVxGWIUSl3j443iBuPoVyBjSlCkxXKKd0hq0rLu6UD2 xZCSj1ybnKWeCdzZxMn8bBT71t1bqLcO4c6ecu4iJaPOSYPot9VipnLYlNsSU4+hGon6Yhj/ 1qx2QUoMWDv0ff0z9ZsNHRzGNX9ZW4SE6uf2jLYOcCRHSZ/F39DG4YNEjlm7xgVt7RjQdm5o UOPVkXIo8oQ0XRu71XYB11wWBWkcPKiVNYLa4RoL2j6LP3t985+GNl4jSTmr1X3GZrSx5xFX rxDXPI8VamzCSfnpTUhbv2Nmx0kXPWhQa8c8OtRO5P6Its/iD/ow/oy2/hwLBQd1J7QZbX0O a8drNKjx6jBom/EVpK0RR4mOo255M9YkfCDNfyUjKg5CeSUC5dqlb+9exfeapLeGSAoeEnOQ QHn/MvHvN0lvby2pdxkkxwwsdcxLj6POxH31oAl6NEKlEX25toWUA2DX5jUqOZDmvRohaQac emzlnhHGZrEDab6rrQWNLgr9+p8OSWM0cTM/HkW91aEecm1jkzkA9DhfbRzqT0ZR7yQpEBDW Yq/c0zPNKnQwjHpFynM8UeEkAlzrFrC7uT7PBnJvuTiEBCkiQU+MxCxyMIh7p4KZJOViBxT6 RLUJ8b0YRb45OMrlJM0JM3ZVHITwZTr9VgMHh3nNX5BmS+q2Ogva2uMIbnWi0Kb2KwVs/Smy g9WSv40tnsTYJ1pHWaub7FSosVueSTnzuiJtPbVEjrQd+RewceAg+uxopWrvuoVUrLEJIzmv 7Zb9EW1txMkh6o24oY2NOGtZpkGNVwfK9joT0tjfWF8Q2rqhCrXefOAwabP5G9g+ZIDqFoEN bL1CdKAMDC1g63CBll8a1PoM1t4QGtTWgMudCXUn3IQ0CRbk5rHKA978iZADZk99EyW9Se/w e03SWyMkhRBy+cvDeoHVDiW93yS9PUSnvlgJeF/+1zVn0apBUW4eqwGSRggpSZCEvGajO40W 5OaxGiBpyoSBav977JPUxAv5qEl6d2tJfWUkH6cW/xHr5Pie2IhNuGAQ+dYE5ogCSZgS5bV5 Qzu01Cej2Hdq3JOpnDSATNgT77JqUTSIfatSfS0z4JCLzNJhqlY9isaxL/kapA2FlqSvc49J odfzgezrc8LkKTPjWvn4Du8OL4ayLwX2AiDl/3LqKT/9fQYMvsYIZmUjnQEtdHpWpVuU6Zr2 dyA0sVKLFWjrbpBaeKr0Fjas6fqozr3UfXQVaeyqCa4O71O6ahrYXLvaZuYz1ly7WefqalBz /Xqv9WZOWOOASXIclMfDBLVVbnQISkfhjDVWLztR97iawbYrTC6qF9iw1ua7lpd23XrziF7r HZ7WSWNrLbU3adebn7yw2kn4OjdXrLVyo7LIrEHNjRfW3DkbtFuwtusrG0rbAnOCWutWlAdb g1qbbnJJ9DUzE9giVBL95K0r/9jasVNb9wIkDtVB2dPBx8QFe69JemtrSWu3ASD26EWAU1ci qEm5wf0m6e0RkhaiIZ+RU+zKjzRy7Dxokh4N2b0eMoTaH77s3p6UV5O+/w+bpHeG6LQIWqeP pkw9Zmqk00dN0rtDJM2Ba/ALY+b9s9PHo7h3mrkiqaYxEwjtX5+4JwO5twZvuba0kbBWj79D SZ+O5N6i1UipnKjSVbxnYqbPBlIvRU8MEWOt3uu5OASTOMlA6q1XBpBQ2EikK55pEycZSL3I mEPM4Iu0Bk0Odx4m2VFdxf4Oft7fAEF927NybRPUNttPavsnZQvuCjVdHRK5qOxAMmPtdatc 34y11q4XbYP1CrXVboCiMaUHbwHbBgiK0jCrw2cFaqve7FjbWH3GGptvcMlrFTyDrQ3Yr71g ruu3QG31O9WW6NQ7QW29jEjRSVa2KVvAtupF/XSOGWut4LDWqvq6ggvU/PRV88sCtjZf0oe/ yTj8XW0yakspGnYHBrzW/X6T/eKA800RJIDmqIIRzcPrkD/ggBzXAv27y/681yS9tbWk1X2D OQpkwrRaxr3Leoom6e0RkvogIFF8irFnuqpVPUWT9GjE7pVQnoMBxXuCrtxlkxDXwybpnSGS JsIYAMv2zT2uKhs7fdQkvTtC0sTRU4oUGVfTBnen08cDuTeCpEK+ocraE7fMJtVAT0Zxb929 PlMKQDHn3DMiyKj70kju9VA3LiekNbfHDrn32UDuLdu3MFLKRat+7Q22y/ZLQ8k3RWEW8QBd s5Bs2i8NJV9ECeU+6GNcc+sMNNRvNkywpyOf9zdIwOiCNl9rxtpm46G4tZFEV9PJJqhxojSX 17M6U7qBrfWb14q/r6u3QG21S+CYlOptWGP9BpfX+s9eU++EtQ0TcNTmcU9Ic9NNyg9vxtoq l4MDpW3MWGvTTWtNnq+bboEaaze59YfkNfU2sK2XsRKuKKdQz1hbBUfHa/3Kr1tvgRoruPxO 0tbIzWDz01c5YKBBbbVLLrFy1M8ENddu9sqOfQ1rbbzktBWaM9YkRIDNTYUDmtaERAlylLCW KbHDnjX3mqC3RgjqQ66Ns6PAWo/NXU5naILeHiEo1kpI9JkhYVfao814hibp0daSTtNFM0jh ++yBZP+Gizxsot4ZISpzipQSxVT+1jNzw6Rg4lGT9O4QO41U9q8w4uq9c4eRvMcjqbcwUbmP 1ikjfTFLowjBIO6dIgSC6FP5G2NPDy2rCME48q197mKRlLBQ0t4x0rNR5DtF3EWKOrmOT92/ Xo3PB3Jv5ADC2cdypsaeSJ7JcJwXo7h3mmFd2MiX85TLddCgsumbjRDs7WTn/Y0R5OjS2gS5 K2trUNuXrJTfqR1luoBNVxg9O698ys5Yc/2KMpt2xtpquI4KZ60nagYba9iXX6rLZ5yxtnGC 3NF+Pu+i/7yIC6SdWTuDjVUcHCgDpTPW2ogDKtc3Y81p2msdjg1r63CsSotZFw6asbYKRrfa mv2qfieouQGD1zZ+mcGmK6yzo0A58HfGWhswJGXS/ow11jA7Rt3nN2NtDTiUbR+UuRgz1iRi QM1tRSNcHJIxAmIG7nr420x0bpLeGiEphCApx5C5syG6UVEBNbfVtpJOnnTi2qRGEtHaDXKn VQXU/FZDRMVM5W7OPqSe/hdmQQNqjqsBopYDRDxSppqw3FNWYOJgftQkvTuEk4pCBTkx+rXL 006DBoPYtwaCpNxZOEjEtOqq2V0g6MlI9sUUA0WKq/O2dqjSpwPJV0LAmFP5h8eeMfM20ZFn I7mXuM7/TZFDz9wYm0z75wOZNwp6QZEIwXeVxBiFDAYxb928FGrjt8S5k48ONQU9EYP9HOm8 v9ECCOJY27m+YU3XhzE61D60F7CtqzGiI+XshBlrrOE6EEGt4gY21vFUBqrVcQPb6pi9E2WD nxlrGzGAEB1HtZIb2FzJ2snxM9bYjMWloNyEC9jYkMnJ2mynayqesLYaLttqzVFwVcET1Dhi wOCUp3CD2iqXskurxdLXiqsa2Fi9dfqA9iSewbYmXKdLKEs0Zqy5Aa+6gjcYcMEaa5jK0arl 6BlsbMQhu9WxhddUPGFNogah+a3CgNrzzCGIsASgtVLaXc4rCM1vNUBS8bk8RmPOIZWX8b5J er9JentrSafe9jHFok5IEPevafaDJunRCJ3mQLXBlCQu1+C9a6T1sEl6Z4idSszlEIkcU+oZ QmGzex81Se+O2L3e195oXsp23MNGWo8Hci9lwXJzoYCe13IPdtfy/clA7o2pqBMlESRPPXZq 4nd9Oop7p8HOgHUCEHCtNdg3Rno2kHslkwCxSGDsOWasogYDuRehkFGQVB5B3MO9JrG9F6O4 d7ojIUXkGDN0DYv5o0YN8KtMfi5HnO5RVoCmcYPDpOUv6DMAvjz7lKXoDWu7Pp8dKbs5z1jb 9ZWHfQRlF52GtfWieKcdBtCgpqtL5QNZG9R2ZXUNahzHcBC0tS0NaxvHKJtdPYpixpobLyur q2as7fq4tt9WEnOFWptuBq2Pu2Gt14fKPucNauv8LB+H88qU6RlrbBxSMwyVxjFhjdcXalqr 8mowg01XWPi2UIayLmMBW5tIBGX14Yw1XV8urKGrepiQtgaM3jte61t+Nb7SsCbRi9g8aHFI zUO5T0ciin1NSYxqHmLzoI2QFDCkTCEj7+Fs0/tN0tsjJOUiYwyM6NcK2jYLauIqfNAEPRoh KGSJvs42JezJRTVqCPWwSXpna0m9A8reE6ZIvii1R1QTR/ejJundrSUlByCQfKiDP1fztzYJ SmA0bHkQ9U6O7nJbYeEsAaEncGzi/n0yinqrU5R97bofJcYUe9y/JpI+HUe9WC4AIQMHTr4n ZxzQxNH9bBT3Vp3W4yWmRBMx7Vs49flI7g2JYjFTgrDq6dio1C+bQdwdvBjGvTGFwDEQEua1 ybYbuTd+2e7d++DFYdryXgUJUJm0P2PNXRWi9HLPWNP1MUWX1kplr6xvxlq7KWCtqet1L0WB 2n56jlj52VWkbRKoRBeVnUtmrHGIwIvLSRvgm8G2xius/ghnrK2XUZLDrPwEF7C1+RJoW4g1 rLEBs7Z7ToMa+xkDFd5QOroXsPH5VqfrKKcBNKzx+tDxWmfPa+ubsMaBXHJJmQY/QY2d8KLt QFmRxhFSJ0k767thjY0X2IGy1nDGmgQJuHmqeMTMRJFYuwWVW3WXW8MqSsDNVbWtqJMDB8rT BiAirlWt7NCBc79JenuAUhPXgbWUfXn101p8cJOoyUTSB03SowE69SB1sDShj7FnXq1ZmICb q2qApCSJqrFiCD3p8OCNwgTcXFXb714p9pm5HOLZ+9Xw+yZRxaQD1OOB5CsJkAMmkZz3b9T9 k1HcOzXR8QFCxFRMNfVUcxiFCYZxrwinaqKCSLKW/bBx9xrVOAzi3pr5nzgFrr3afFyr9N1l mGAQ99a+7EFw/l9Ho7aYjIYtD6PeVA7RkGO5I5UztYd605flF3yzUYLDsOVuH0BycS1wdc0H MGGNkwWDo7VI/7VcwQlr66OQ7Djo1jdjjZ14hS21TrwKtXWBJofKcbcNahsliMGxdkrGAraO EyTnvbIl0gK2JZgM+t5mC9jWRMrWEuUCZ6yxCSdtqVeD2ppwyC5pd+ACNnY2Yna01rP7qhk3 rLkfPirjzDPWdn0RnQQtycxg21MY6vALZclXw1qH0nTlchVoa77RO1De/2asrfFGoPKZqHXb wCaxgtTcVWmAE0dAEonPkKWn1N8sVpCav2qAqHVeRMBEkSn3dPLORhUFqfmrtpUUnA9JChdS efpTn1/ZxNv6oEl6NELScq/0EBC8+LWMn82SmiR7PmyS3tlaUnGcJhckJZCuZl7CRv2QUnNY DbHTJCEH9r5Ya0+qslE/pHHkK1THfxDGDJT2rhfdk3HcK4ABCikBUPlPR52IGA1RGMS9vuYz JAjgGUTiWpLGRkmNSgrGca8PXM7SIqqXvjitiZ0+H8e9yVOdKcBFXvEdp4wkE0lfjOJedB4S ka/FE6knzoVfGHr/ZmMFh7HLX5TRWA5MrbuxgY3TfrNbz825lvbbwLZ5gxgLmekiBv8/e/+W ZEeOawGic7kDoBEPAuAIFFJY6v0YQlv/3I/unr816eTWR0S4NahgwneWorIyVWZnndwOBwE6 1wKBiQ3mKrJ3kMKAxvIVqEnObt0/5SsGNrzsvDobX01ssGJAR9WIM4QnOPYVcknmHfNwA4c+ ofWmH84ORBMbTOpxJ4mdnPwExz6h9M7vvvLpiY2mHSXhaanGM9pxgMP3YhbnTncDx7Lyaql4 5y7dwLF7Xctv6L2DcwPHphpLoE4nT2yw/CctezgDeWBjA5mxl185C4Nu4BD9wAaFZa8nAdQQ UBRFLC/1dAkap2CDwnqtpb1ZXq4iQqUa17pC1gUNYbZBYb3eUtMiRJqpZe3MKxRWiE8/DUvf v9rSdsChtnNW0N6p/Wzw04t8R6GQCvzPw9QPGwIV1YAV2+eC4JJSgkH6gQ0Oa0NKKpYlayVT xqUeaSENtb7uSr6HeEu5HZEKmdnKjIwgCvbbruwLCdo2A4K1T0RaaV8DELJ8v+/Lvm0f1S6B lT403RaSUozQ92NX9gVOXIwqcFZFWrm8xxwSqT/3Zd+Wek2NqC3iunQjE0IU+V+7sm/7eBCk kutxeQ/PCsteFqrfJIQFCeFtDvMis1dLcjbdH9BYuqJCKuilKyY4WDrobXx8Dzix4eR8OZs/ 9AI537Cxz5cpKbsbOw9wLKknkkC81fITHCsgcMZk4CVUJjj4JVpi7xPewMECgqTTT+hnAsKB jX2+mk5vnj59vAMaLB7068DOa0MDG8s5KmBiL/F9A8fuxNS2V++YhRs4djdm7TNFfZvxwMaG CFvCsyq6pzEysLHPR6mi89rQxMYmaWuBeTY99WmOHthg4YAoEXv3uQkOEQ7q4K7qhopQYm0f iu04nM/usF5XEPrPMPTdBkMF0QCyUqfTcaGoTkLa2Xwclj7scKkpZ1Mt1aCsWBrTJuPTsPT9 Bks1YzMyd4VE8kqbjJiC0M/D0g+vtrSdM0tWgV7TvFSKDyWEt/oyDH3cYGjloqW0M0MtlFfu zNSgDkX7Mq+a5nY8ZwDWpdQbdOtgW+qt2AyEYm2DMVkaZBCSer/vS73tE6o3UlQQAV4ZDBRj 6Y99qVeaO2sL1ozWbF2wVII0g02pl5JoFiCT9l9dmSFDEjSFeVvuBSMupWVeNl25MvOn4t7d awb/2hRm/xjmtznM965oIDMlKE5K+Tc6+hkhaXWeZH+jg5+RLGX29aK+gYO1g/Yd7p1LOrCx 2lDqeq+zH3WHxrJ5yV0HnLZwoSuKRlvynMz79n6jo4OY+yDohWfs6Ogg7mKAc6zGBEcHsZFT QJ3Y6Oc7LfZ8/ngNGkuJFj+lXOIZZeQsybxze3+jo5+xpLMq1+dP2LHRzweJxXe/7gaODhH2 svITG7wP69lF/GfbcENGB7A6R/YcyAg1Q/LBqbU/NsxlFoP25Yq13mEh7j/D0nd7LK3cxy1g 7yp8d5Z+HJY+bPIpcaWCYOX+pmh8Gpa+32EpdtYwYwU8nStzZRelYemHHZYCagFSYjBZuq4U Ijt+GZY+7rCUQXLWTJLLymDmoNkSX3fl3t5FqQ8rVlNQqitzxYMmLuzKvYelWJAxU58cstLB Lmbiwq7c2y3lWg2hmvUZt/fWGevHrtzbLa0ZoLRNtUq5v7HiP3fl3uFTylBLLlnOOm9f59Nf G3Nv+wRAoT70hpcuK/3hLnP3esbbYOY7Ug1Kv2PmfHO/0fGMfEFv9/sbOv495rNzwUuvsYHD CT0/WZGjB1wndDe+P6DBmkE+62bwjKxoyGjNoK0m9E4v/42O1gzamhIvHz/A0QEM7b24h/hO dHQIt+8Idwx3bHAQs1NyOZDRhCOwc5sb0ODlB72/npeOH+BoPh4TeMd//EYHPyP2HplOffc3 OpiVN+8gnwGNDmFvv7sBjQ1iTlZ9t60OZIhqAIO5gg39O3qP0iqchfLZtPFLZQMY1NVrTZ1k eq7ARXSpkDxKNoBBXW2xtGRE6hQzLQ1fCJINYFBXGyzFYtR2pV5xvEZzBMkGMKirDZZSO4EQ NSvxLBtdaOiXYejjFpeKlaMdVqGVHmdBln7dmHubnb2EvLIg2/3Nad6Veg9LcxWF3hBrKfdG qQabUu8xe1ul7TCFDGilyVmMpT92pd4+p7matC21Vin5rK3JhXOaN6Ze1IIkUvqA0KUpEyEZ 6deu3HvM3s4kyoDAuazomP+jtyDeBjXfjWZAlvhs63iJjm/gaDKvptO7Q8+5vAMc/YS9RbJb LzjA4UyAtx31AQ1m5PXsWu7z8sEcez+jj/729jM5oNF6AedE3p78v9HB4SGQhN3PONHRz5gT LDzjQAcHsXOyQQcGB3AFH5N3IKNpRuco+A6MZ+HJ3Az3REd/H1Bi97T6Gzr6GdubcYsZAxwc uoWdc8EGNDh8xauVDmh4AGencwc0RCnAwVbhDlJZBdqmbCJn47wvFQpwsFV7LC1ZFDTDXQoF ONiqLZb2FkI1Y/vz/sSfT8PS9zssbQuXVUwpAy/dpAgSCnCwVTssFeFc+5hmObvJdmHV/Zdh 6eMOS/uEZiCpIHzWD/PCGeNfd+XeUXXf45RK+yy4vwrtb7ty71GLjpqbZ5vBtDL4JUop2JR7 D0tZa6na52acEYJXKgX7cm+X3ItS8ymsLN6gG08/d+XeXk0htcWnailV7vAS5q+dyRet9F5J 0hLwkqV/ts38tVLB25zmP6urperuFjLR0dXJlNRWWid1dPQzYlJxX9SY6GhO76xK5DmnV2Ob NZQE4G4Y0qHBkkGfkOPkKzo0WjIomEpxPuFvdHSAlEToLuCf6Ohn5NRS8ELrpI4O5h3Rqw0N aHAYEzl34QGN5h3bid+r/En0ToyQzDvB9zc6+BkhJ3WWeN/A0QJMTXpWj/NcfznAwQGcnV2T DmT0Luwea3VAo8M3fBt2yAY0qCvaQTGzQhElIbu/E/E/w9J3eyzt9wvMCvHZZJRLZQMa1NUe SwsXk3b4Xxk9ECYb0KCuNlhKNVs1Nsqnl10vJNM/D0s/7LC0nd6AM/Yi7ZXKzzDZgAZztcOn BsLNoe0fZy13L21LtCn3HsXotRQrtXeyWRmzECUbbMq93VLpNlKfik4rV56iZINNuXdYamaC Jd9f+6UfGzMvgIgJ9PK1lUE+YaLBvsybifo1trbVUL2/23q/tmXef9+0v1UkeJvE/Aedc07b 173UvcR29KpdqxWUVNHbiXiAo3lFS4ZOYuw3OrpiUNzMXYcGE/DqreQe0OCny+B8dwN6gTyA 3lbYv9HRQdwXvZv9nOj4VJjFO3pkgIODuM8VcwZxhwaHSf+28EVJQ4Zzi867GAcyWhpopxlw i8sTHU2850T+AJ7oaPmidtraK18c4OAA1uyV6BsyOHy9fSgPZHT45rO2EM93YNsxIPr/Wxjg QU7xliY1xdRypcVb9UHCAA9yaoulqmpISOUOWyx9HJY+bPJp7vMKepPw+xN7Pg1L3++wtJ1Z FaAA5dPce6kwwIOe2mBpad/2pXNU7e/7q7L/Mix93GGpIGTC2uux14i4kLmuX3fl3tGlRvtU 13aoFL1DYWBT7h0d37ViyQWp3l+Xmu+7cu/hU9Pe2r4Ko93dDIofG3NvVsJ+oi+LmmyQMrAv 9bYtxoD7DGZeEXsgh4zU/rUx9YL2L4fMbGctNnYaerlO8C+oAOTrgkwbWiCvTHz2NY4Ofab7 nfSs6PRiB77+yerGKeArLcVZkzqHHU/sf9dWsnR2Enpq6gHdwKKL25D677jXEoNvHU/sfbl3 haIB7tdKnOWlN/B9mbvkWkngbHE2sfdl65JrqSRzu3aCQzi4Ms6B5dln1+1xnn7C7CXGyjic XfPzH8fPP7zw8+vniHaGgN4lu67dYA0iq8o4MF3znj+Pn/9w0c9/GT//uMPNpVhlFDbms1tQ l9I6l4bzt2vD+fuucD4aKhSsfVAuGJ3JnlcSIJfG889r4/nXrnjufkZjU2UgLeXfp/QuJwsu Kiq839GG4cfkf+FTWjT1od6+O3MDG1tWQLDQT3GC7/VdS7/46nzXAxv8rinBaQ+gZ+96gEOJ grWXjd4b8RMb/LJLah+Cznd9YO91Wdek3sq4iY2tX0HKCc56RT571Qf2Tl+1tk3OWeY3oOH5 Q4u3Sm2C7/RNt73uTKZ9vivCBnppaUFjTafFSk/f88CGEEIyTpByESEk4wT5/OfXP+1L7wFR LJOcfRtdd4L7OAx9eLWhh97JrO0QYwxntZEXKrufhqXvL1pRn8fPf9jxogsQQlYCAl2q0wqq XpJxLN4RO5prM7O0PzTf3TSxr9cmqW+7ktTR+VAz9whu6f3+Sv++78xSGUpVRgFey1IhlTY/ rs1SPzdmKeg5KgMYLg5hDXnRv3ZmKYF63F2vVQJI2r+WvLvTCWPB1N3KwcOSkbOH1QENfbr2 +dK7Czu16AMb+nxUJJ3VTD+tQDugsb7t92O8g00GNta7WJJ5r8LdwLH+FfCTTTfwBopy4Uaw 5CTedqETGxzCORXy1oId2OAQ1nRaOP4shg9sbBCXxNmrmAxscBDLoUE7g3iAY/krKpTEyWNO bKyLMZXq7FQ7seEu7i213C7u4OAg5gTOJDOxsR4G92XgAQ32LydmZ+nqwEYHMLa04SOgJzaE gNbB7eirz4dm0M7C0I6GlrkscA4Wcl/rn2Hpuw2WVrPKIsTKUvLd3df6OCx9eLWlx63g2sky UiW9vwZnn4al73dYilmgz2qofXzj3dH6n4elH7b4tN/yht6RQ9Zmb4UwVl+GpY874lS1HRWM 23kG11ouhmSkr/tyb81t2bKWWgAIF5xaQ3z6bWPulSwZspphXqogDKkI/r4r9faBVAisQLVo wfu76P1jV+rtLm3n0f7ZQFJ56aJ3iE9/7kq9R50zZLG2cAULr4RpiE9/7Uy9RdpnEkjvO3bW S/Kt0velf9f/yIyx+5ULqqTTPulPnm1AYw+yZgnUe3dtgkOfsOScivMS8MTG+re9EydRMaCx /q2Q2Nnab2JDn4/rMfbT17tsYGPFghaTqE6mcWKDA7gmPa2BexbAAxwcwJjMe0HgBo4NYUx8 NtX8qYsPaLiH2dv/9waOZRu55kTOuU4TG+vg9pPZG8QDG5ylS/tR58fVDRycp3Pq/KPbxR0c HcTi7fI8scFhzO7RbBMbHMQtdfg7eU9wiGhgg7iyDSxHOxEj5VKN6llGvbSXqA3m6rWmdt7V mCsjE9czn17Iu34clj5ssZQLcDaT9u21xDAHqQY2qKsNy5fBqLdObZ8gcCYuv0hzBPUStUFd bbDUKhOUFq5q9f7GF30Zlj5uSUkmJlSbZzmf3Ta8cPl+3Zh9SYGLFajtlLTUeDJk+X7bmHxJ zVru7Uzzmk+DKv83Jd8eqJlRsEo7eLRPvnsTvX7sTL7N0Nz20ubcKne3en9uTL7CVXJuYYo5 44I6HaOQ/NqZfEulrsG3E0tIb/m/VTi4z7lj9ysaALcTqjmP2zdw6BNi77fp7fxyA8fyjqUm Q99NiIkNLvPWtqk4awgHNtjDNbF72v2BjfVv+01wShsTGysd9Lhk8hK3ExzsYklSnOLBDRwc xJQkOxPhDRwfxs59ZGJjfVygF287fTzBscxjKdYvS3udPMDB+3FXvn0Cx8QGB7K1heVUOG7g 2EDGLj16A3mCg33MiZy9cSY2/IuLzwjOFz64GjY4jFt2K+as1BjYEPmgDgKr7uDqEKXXgkIu cn8Duv4Zpr7bYmpRKygix/i1uzP14zD1YYepZlZzn+ZUxM5uTl/HNX8alr7f4tRaUUsvCCWs 97d+Pw9TP7za1C4KSalAos1OW+rZHXTtoA4Oa4OlIO2v5lVuPl2Sv0KuknzdlX47q27tjMmW WfAOWfVvu7LvIWlW6R11supZcdyFcfp9Y/JloZZ3qU+9hLP7ii8m35C2Wz92Jd/eDUoY2h5T VU6POhc2GPu5K/f2bQaaN7lLt+0stLB8o+4dbMq9/d5B+3JoPu3t5E+rWP+mewf+ASsro8Ha J6jvVNaAoQLC24Cw3x1e962MlSYBRO67ARP7n7W1JHYOVDqQG6jui8eDSZbk7Ak9oPfl2qUJ UtKHxnvrfyf4vsxd6ZENmE5v0z5NTwN7X7YuudYoZfU2+5ngCFpM83Eua39c0gt6/Py7i37+ 4/j5hxd+fvkbsCibqKJhXmlwEFMs82kY+v6i9/x5/PyHi37+y/j5x1e7ubdoN+4HGyAFWSAJ sQa1d7g2nr9dG8/fd8UzJECqKNLiGaCu9DKGED7tx7UB/fPagP61K6DbYYByIbYWzkYrXDgR /RlFfPeH97fxYP/2IflfOSVx8lZ3TGyoam1syYqzCOoGvtd3nU77Oj190x0ZXB2QCLyTfQY2 lCJYWtKUTqWsZ0v6wIa+auGuW3gbzE7w3S5pEGdwDmhsSUn7BEtZvKfnCb7TV10qp5bgfBTe wMYu6yzJyPd8E3unb1p6mxDvos5bMuHSomZ2N1ee2BBCCMYBEi4ihGAcIJ///J+UaeWqmNVK pYWzelTt0jD1YYOpWkpufyNyYVk5rWoQ+wTjsHrNmvo8fv7Dq190r7IpSEJSpV8CvLsqmy/D 0sdXW9q2naq5KAGwrTQb5hpzHfnaLPVtY5YybitKsmURWKqSCOETv29MUm0p1WO6XrHTAusX k1TMdLBrk9TPXUmqb3zt85dYcn/jKw20gwpvdiWpkmrb9tB65W7vF+43tPxh2dhfy929TQf7 Az6usHMw8cDGPh+26Dm71P/0+QY29Plqr24g5+SUGzj2DbpHlcueQeVrRULOoR8HMvTZtLYv AecFsIndwFAuzQWjVLylGjdwMPOoicxLbUxwrJM73enjkAY0OHTR3GxnhwYHrzjnSh7IWNKK gVKfb+HrDjjBsa+vatd0nfzqgQ1+PkmcndcjBzY2dAlTZucd4hs4eud1628QrL9BSeYsBh/Q 2PBtm1Vx7hsDGsI44+BycAflS7VP9oAChEv3/WJu5g5T373a1H4LjtvJl6F9nNPa3TCKIbdx 8Eavd6qKVitGlnMmWTBVNYbcxsEbbfApVDMCKtYib2n1xowDG5Z+2GEpmqFYkfaJkJekmZDV +2VY+vhqS0uCetxTbfkIlujdAiFk3NeNydcsd7ENSyaUu5sz9G1X7u213micVSpWBVqxNOQO 5/eNubeYIrQw5UJ49k14nbD4Y2PuzW0rbTHa0m9eqveN+XL4uSv3YmqZ18Sy9RvIK9spxoxM /bUr9+Z2MuFiteUizMB6NtrjRRnzTR5YkQfe5oH9gUAACcBZE30Dxz6h9fHKTgljYGOP2tko GTpf4W90LJmS0Mf0dGCswIIJzrThp/LKAY0tYzZOcvrB8bSOeYKDZQKsyZy9ACc2vI4TnH1l JzY4fGtJ6J1YNsHBRLyRtxvlAQ2u9OcE/qatAxzLNmK2tiv42NCJDabiOdFZZegLpdgNGxvC tbYvJmcp9sCGPp+h9otEzks9ExytpamT7x7Q2PdXE3i7tU5scACLJnW2aJjYEMGABmdFG7px qZXCxL1U7u6acf0zDH33akPbx3nNiNyOXyS54AJlZSHk3Mdh6cMOlzbnaKmVVNCWmluGlJl+ Gpa+3+HTXEqliigFKi0wORZi6edh6YdXW9qnNJqZtAOmMZaVrgsSEqdfhqWPG3yqRC1UmZXb Hys+1RBh5Ouu1HvIBdr2DCrGVFecGiUXbMq9XeyS3iwEAYBWXBokdn3flXu7VNuWrxRCavFK CwpmlFywLfdqM0+z9g6XmM9az71oaQiJ/nNX7u1jwKTPX+ztStsBfGUMWIj8/mtf7q3t+4jb V0PLvi1gF1bvH452+1vlgrcpYOuNEMwWCpI7OLhmsJ3tnUWrExtLdhMmzE6u7AaOZUMVEjqn lE1sMJGSz2YiPONRGjL02UgtleIs+b2Bg8WCzImzt5fJgQ1PMd6a2gMaGxzYfhOyj4e6gUOf kEtyXqY6kLHJubYTiHP3mNhYltGoJnNWxE9seMU+ns35eaFiv2FjHWzQv9KdHp7g2P1X2V/s cAMH728M3ks3DRm8/lJxqgQDGhu+gjnh2XHpmRB+YENEAh5MFW8oDWxfg5mwLUpZqWsNu1TA g6l6raU5GZiKFYVmb10hlEPqzz8OQx82uBRrLtUEJBvCiksxZtjXsPT9BpeicK6Fc+8GUVY6 uWAIJfd5WPrh9T4tqZkHTMKYdWVcPZQSM+xrmPr4alPb8RSMFXvJSeGzz/YXfYoxw7525d6u EihJbYe2nDXLQl12lEqwKfe2XaYLsyXroQAt6ZYhgfp9X/LNzLXfh2lRelqgduEAtx/7km8m EDbsNwraqepsSPmL7aVjVIJdyReSaPt0UJFc4YyJebldugTdKtiUfJuldFwyJezXTFfursn/ qEzwr0378o/7epv3dYmIcdHkIOTStWYnn/Ab/Z+1tyT2XnMY0A3k9sVTv/qN2d4x0O3igb4v Fy9NTU/to8jt47qjjvay6MXjArjXtRN9X/auuZaquwi5Q0PosTKOaOWiNs9lnJuu+fmP4+cf Xvj5PyAHyaxtMYVOL4tcSA5+Gpa+v+hFfx4//+Gin/8yfv5xh5+Beh+HdkK3LEul4iHk0tdr 4/nbtfH8fVc8H4STiTLP1jr3Rjj9uDaef14bz792xXNvFcVGQpQhy5n2vNHNd3+If5v69W8f lf+VT2nSJOC8YTnBodr18aN0Sgm+9Igdfafvu7TtwdtXt0ZfZk3Azj4cAxpKEqxdbO6tW5y3 Dic4elHXZGdXOZ6v6QN8p0ta0mm7o2fNNBsytrSkdPnau6Y79E5fMnLGflL0ZsGJDl7UGRJl Z1/k3+g7feM9/zprHgc0emF7W9iWPS1sHYSQjAOkXEQIyThAPv/5P2Bkaq1EFfJSz6+wsV8y zqo7LIUWgdTOqW0XXOIkgrgnGWfVa5bU5/HzH3a8aKiKFfoNuLNbLpdO/ZJxKt5gKGIzlC23 g/HZbZQLLf16bZL6titJdZqptASFWEmoBPAPy4TapiR1WIoo/T57S1YrDHkUoXZpkvq5MUnl lqAApG16iwVkIbvBr41ZKnPpt8yxnpM4Oy39a8m7t7Fff1K2cHZH4KWiBYm953cQbOCW3gc4 +AnZEp/1hH/O/hzg0CeUBE7q50BGX2NifxUJB3djo8RnDSSe3tLtyA0E5cIV3RaOmNBfcHSA 42lHMqd/f6Ojw7e2pOa8jPgbHRzASP7xXxQ+/quQM0EPaCxzRamcdVV7FsMNGbz4EBKjr2Hm DRxPsqLzqvgNHPyEYKmczTZ/9oQDHL3/glPoGtDoHXihVDc8eNl5j/1AhtDOOhgd3cH79uqs QgXorGnupdd0dZBHWyytfYJSqQC8cP0vjOHWQR5tsbQ0ryqYKt2fTz8NS9/vsBQEEbJgRV25 eh02+0sHT7XDUs1qfZwQrw3aCSLTddBUGwwllVKp+RPLyuivoHuOX3el3qNosk8U4ppF9R5H f21KvYPNZs4MLUjhrGPIlbz9ptR7+FStQjWSnPXu+rP+2JV6eymoUtswtKUjaGv47naZn7ty bzdVkAojKTOtODVMJNiXfbsMIqb9Y7AGfCT9tSLB2/CvP6Phi7e07Tf6CqnAXeR4gOOlAnRP ibqhg+kA8d/9ky13/5aeDs/Oj8/LKzm2npmSN3wPZLRYQLUdZBaY+By88NqPWtvu/Y840PFi AZ3133pJK2jg4AAxZ9fWAxn8bOQOXtoRvGtMI511xX8WvQ0ZT8Lr2Yf+SyR8A8c/YfZuHL/R 8UKBc7rlxEbvvOiWwjs0euf1fjgPaHT4ovOi04EMEQpssFW2hVSuJQuAyhovFyQU2GCrtliq DEIsWc/8ealQYIOt2mJpH/ZNZExnxUOXCgU22KoNlkLNhVhRuC51WosSCmyQVXssbR9VLb8Y rAyqD1MKbHBVGyxtEVp+/71iadDUr025d9S9Z+ntlNsnwUqgRikFm3LvYSlU7DM7le2sX9yV SsGm3DuUgkIqhJWWeqNEKQWbcu9oDmKUuWRukXp3OtfPXbm3CwUkLfnW/qkEK5pIjKW/NuZe KL0NeIX+99I30p/tMn+rTvA29esP+Hdc6pyBWzpnrBF4lMTcxfoHOPotsnt6xg0cXTDonQE+ oMFPl70D3gc0WCPI6KzkHtBwlcCSnX3Qv0TBN3B0AJcEZ99szwP4AEcHsCQp3icc4OiCfeeN rwMZ/GygvkY6BzKaZPT29z2Q8Qy8eK+J/EZHM/CYoLgp+AMc+4RULbF53+INHS2jnVWLP5fR NDq15OJ8eQMaHcCZnU12BjREJ6iDq6o7OGVRqihQy1mUXaoT1MFV7bE0C/djcDn72rtUJ6iD q9piqVm/UcDCK6RcmE5QB1e1wdJ+wS1LO7aCrE3ZCdIJ6uCqNlgKtdbm1KplqVA5TCeog6va YGlbs1YQiuW6VqgcdKNgU+492HPuYUpVFPkOdYJNuffglHOVwmDtA7LeHXv+fVfunYpI1bZ8 c1kaEhWlE2zKvZ09z83IXLJQLivCe5ROsCn3dkuLtMVbQLQKLQw4C7tQsC/5Ziu1Nocy55Wh i386AeByoeBfkAHOZPyn97Y3HFNXZo25HipWmLjf7kvA7HTjgXz9s100p4iE03mJzdPz7QT/ d60tvRuGs2/LDbyBTr94zhhxF1V8/M/E3peLl/gawSTeDkwDe1/GLq1nTOwtsb2B78vaJdcy 9poN5zo+sBFknOXjQNj+uKSp9Pj5dxf9/Mfx8w8v/PzyZzaronHm9p8MC2xOLSG01bD0/UUv +vP4+Q8X/fyX8fOPr/ZzLwSF2jbWdpgqp8M8riwEvTaev10bz983xrOIcRUQyO3cvEKFaAgV cm08/7w2nn/tiufmZ5WcMVcmBLQVcu/PpqJfzhlcVFx4v00I/pbTcsmyMHJlgv+z1rJRMmcf zIn975+VS+ZeoOZ18QDfl4tXjlRcazrtUPbUxwN7X8aurOeakzqL7Cb2vmxdc2zvVeI19sCG nJVhfFvDRWdlGN/W1/z8x/HzDy/8/B9IUmpilfuIV7k/SerTMPX9RW/68/j5Dxf9/Jfx84+v dnQ/LCMqU1VWzUt+DjosXxrQ364N6O8bA1q0GnfZtZgs1Q0EHZYvjeef18bzr43x3KK5OboF dMazxiI74/lvPSzf5028v+agzDUV552MA/oftlRT+xJznhcn+H/gmHzckvIt5Ym9LxcvDbJl SnzWB/mZsQf2voxdcWzhZOidzTLB92XtkmuLJUIvozfBIQdlHN/VeNFBGcd39TU//3H8/MML P79+UIbalmgfQsq4MnMgpkr107D0/UUv+vP4+Q8X/fyX8fOPW/yM7dM69+MywP3V0n+9Np6/ XRvP33fFcy9QrkWMrBrhWmewPytQXj4nXxrPP6+N51+74vm474Qs7XBQ2jE5YILK3Z+T/d8/ K+fRnLPvONqAb6Xhf9UZHjBDqk697Ab+71orNWVzVljcwP/9czy0r+Nk4jvb3sD35eTF2YDe 6bcDel+mLkUvtsNqcR7kf6Pvy97FZuzOmZQHMuQMT+Obny46w9P45r/m5z+On3944efXz3bK lHMvGabTbjqXit00PvqvedOfx89/uOjnv4yff9zg6NzO8AUNVVSr6gJbE9Lk4Ou1Af3t2oD+ viuguwgKVbho9zIutYIO8fOPa+P557Xx/GtjPDc3C5O2UzxplYX75P+jh/i3yvD/2cMytA9o c54tfqP/s/b2ZoU+ff9A/g8clKmdkLKzC/ANfF/uXWxb6R2rNqD3ZeqKY0u2pF4J+Df6vuxd kryrJj3r7fJU8R7YkMMyj29rvuiwzOPb+pqf/zh+/uGFn1/+tq45t62ll4aDLLXECxK8eXxb X/OiP4+f/3DRz38ZP/+4w8/AwJkLIBItCWQhQujXa+P527Xx/H1fPCMZZUJpzrazz48X/Ywh 7RB/XBvPP6+N51/b4tlqahmbtUgFoJXCcKt/2P/ibz0tv5WGX3tSrtk9jeEG/s9a2ztMte3Z 219tgP8HTstackLvaXmC78vJK0cqqZzOW5w87fs4wfdl7lrNQE3Ezvqc3+j7snfFvcrQ4tLX d2xiQ07MZXxhl4tOzGV8YV/z8x/Hzz+88POrX9hURIih37BtR6qFLy+SmBNzGV/Y17zoz+Pn P1z081/Gzz9u8HNtG037nsjIVXChTRHUIHX50nj+dm08f98VzzlVrL0hVSGBTGf9a168ChBy Zf7HtfH889p4/rUrnjFlLi2QuYUnnn5qvqgt5//R8/K/ViLurxF/KxL/u07zyFQSOtWkG/g/ ay21T3ufVw/kf/8cf8yaNOdN/hv4vty7WENcfKXwB/K+DF0bWVgTZOe80Qm+L2sX3QrOruEd GXJ2l/GtLxed3WV861/z8x/Hzz+88PPr10GzFEBpn4C5LqndQZXhMr71r3nRn8fPf7jo57+M n3/c4ufeNqm0Y12tK7f4w9TuS+P527Xx/H1XPI/xaSUT9MJwO7vPc+H4tGvj+ee18fxrVzz3 Kz2kGbBUZQuYknf3R/e3wvD/2QNyF4S8DZV+o/+z9lLK5jR2QP8XDsnMKVef2H0D35eDF0vD 3Ydk+C8fkjlbKsV5peM3+r7sXZx0fzaa93nk1ph24To+q/WiY7KOz+prfv7j+PmHF35+/fgE QCSZ23kI73Ai/LD0/UUv+vP4+Q8X/fyX8fOPO/yM7dQkAmwCZ51bLrxY+/XaeP52bTx/3xXP /ZgsRQsxZsW6ck8+6ph8aTz/vDaef22M50ztYFZRDAsF0Jt/6zn5rST88jNyOZti8tIRuYH/ u9YmE+d8qQH9nzghU8Kz8SXPHXyA78vBKwcpTM4hxR14X2auno/ZeWK8ge/L2jWnetvk4Z4e eY7TsY2vabvodGzja/qan/84fv7hhZ//ExFZQWrV3l/sDk/HNr6mr3nRn8fPf7jo57+Mn3/c 4WekflkaLdfTmYeXno4vjedv18bz913xfJyOuRTDShXKyl3aqNPxpfH889p4/rUxnnuT8Kwo ZLREdv1XD8cvvJ//+//5v/7P////8bLx8//22/D+x1bD8f/34pOuHHF9x9voqnIvH5CDCQF0 VuLjhjr8FdGXUmHfoOgBDX26Agm8ndkmNvT5gCQJOltwD2y0d9lZRzKg4d7NzkFkBzTet+Jt LjbBGwifsuBeTVi8/h3YWAdzeynO55vYWBdzTuhshjixseHbfAbF79+GjfavnTWweu7eBt3w ib7A+wDVVL1zIQY21r2c1Lu7TWysezGp07sdGR66bbk7nTvB4d4FX2XZgEb71sQ7K3Jgo4PX WkD6vkwnNoS4rYPoqa8+AgNkVSidu4QzKv7FMzCE3Iv4Z1j6boOlWSyzVmbMsNQHL4cMSP84 LH3YYSkKN1ul5qy0VKwV0r/g07D0/ZbVC8q5fZO3tHqmdF+4ej8PSz/s8KlSNsFS2hLOS4Uc Iav3y7D0ccvq5RafuX2nsZ6dyy4l2bfl3kzNQGoZGCivFduFdOb8tjH3UjuaSoW21dS1eR0h Gen7ztxbrG+piLQ4mSSod8y23NtXr2LbTgHzmhgWsnp/bsy9xAVVsNYWrEu5N8SnvzbmXhBj xbarZj7r3v9XDU39t67VOSfNHcg3haCfY0vKpxc9nx5kBzb0+bSkQk4iYGJjmYpqqYCzbPAG jvYwiJOpOKDR/s3kZComNti/mnrRgtO/AxysE1hSc94PO6CxDrYkzoE1Axr6dJhzMnaWSg5s bPBacnPIBzTWtzVB8aWWAY0lGfvoayrO7s83cHRuruhsXHZAY92rCZ394Ac0ODOXPoPDmZgP bKxvpTfC9DaYP7DR3tWzyY/PvdugwQpBZf8l7xs4QiOo+eCp2h+vZllzESt9uEjNZwvlSo1g WPpug6WZs4rVXKvhmepzIafxcVj6sMPSdsYvtfmT62l0XdgP69Ow9P2W1csClqvmzp6vrN6Q 4vzPw9IPO3xa2BSMkEtdmgD0h/2MVzWCYenjltVrqtKitTLcYyH+vtybkTOzdHVW1ibXh1j6 bWPuRawkSAXtrHz2QkO/70q9/XYBcdtgBPvV+5XJe9VCJIJ9qbdl3Nz20oJayx0K0T83pt62 cg1IS5G1T6SYD4dfu1JvX71Mks2sW3pWmLVx9f61EsG9Nqa/U4GAIZmzynJAY0kAzEmcE6Am NpZftONTw8dADWy4d2nBvRTu3/757azhHthg/+bE3r6KN3CsPMAlFfRVWg5osIMptROHk+aZ 4GAXc3srzie8gWODuCQ051WWiY33sTp5+Bs4WCowSuIdpzGwsS7GBGcky1MPH9DwLA3oz9IN GxvCvTKgOGfhDGy0d7Nz6MeAhn9jGTuvQQ5scPA2lyE6v2Ju4BCpAAZdBa8/B5vmioWUgHip /DGkc8I/w9J3OyzF0gxVBoXTy3sXchsfh6UPOyyF3jKtVjWSsxKES6UCGHzVjtWLJVdtD262 Vrwbwsx9HpZ+2LJ6kYX78MN8th9eSLZ+GYY+blm8gFWonadzXaOVY+a+bEy9WURQTIqc3vi7 0NJvG1NvF35Kn9tU9Ww3vbDd1vddqbeTrbm03aUZSwVXhK4oqWBf6u3Se7OxX4U5O4Fd6NOf u1Jvn1xjaGC9oXrJeWmXCTH1167k25dv+3Ro34GqZnnl1tqbVvC/MqXnXtUCTRWclzAmNvYs K9wnoTqpqAkOrvjVBM6C6YmN9vDpBbznDm7QcP8qeasGJzjYv21ReSvib+BYxaBAYnQG8cQG O9kSeTsP3cDBTvZ3YJ7Y0OfrXjPnGpzYcA/z2djYFxzcsLGU4+E07720Gzg2T7ffZOe9tIkN drG05Oss3x/Y4BDG5jSnqnYDR3s4ewcWTGywhzUV8wbxgY0OYmi7q7fD3gSH6AY4yCvc0d4E ixVuezSclaFc2N7kn2Hpux2WNgMrtK/hXKjeX53rx2Hpww5LMxXt7TC05rWR2zFd8Yel77es XtMiRVtqtbxUjh6kG+Agr3as3qP5PVYF0yXuKkg4wMFd7Vi9FXsbeC216P2pXl835l5o6xA1 ozGt+TRIONiXewE4iyFkxrN20xda+n1X7u3Mq9a2lVYSITr7trlwgsHG3JsVqJ2rmMvaTaAQ l/7cmHpB0QpZLdhMvrvU+2tX6u0KCSLmlnVzaaG6IAb94eL9W2WDOx1aeKeSgbC7B8KAxpYO ZkuCzhHyAxtcOlgSORsRT2ysd0vKzv4qAxrs3d4339sg5MAGe5cTVOf1ghs4ViwQS21H8T3h xAa7uCZvaegBDXawplKdpfE3cGwAm7tNyIDGehdyclf+Dmwsx9hzLp+1xX4hPzdsdH5WJ0c7 oMHBC4nOjh8vNXCqwRN4ak35tH/AUwZ5gqP9S9mp9E1ssIdzYnGKzTdwcAi3XwVwOvkGDpEJ aFBVtKHDiaCZVRBsp/6VM7DEyAQ0qKoNluZ21Feh5qJydm/4Ql7j47D0YZOlAlaba4styQRB 1wtoUFU7Vq9my+1kaKWc3VO6cPV+HpZ+2GFpW7YKjCBqd9hd6suw9HHL6qVMvVeuKJ3d3LtQ 5Pq6MfcCIRQu0Gu078+n33bl3pza0YVK7XUIpryiiNQQMfr7rtzbLCXDfom55SXClWEbNaRt zY+NuTeTVYVeXlCWlJ+g6wWbUm9fvIrYLzxJH2C9Qp6HLN5fu1Jvs5Sp32KrBEVkpWjkDxfv 3csE+G/IBC0CnHx8A4YKBW9jlpdZPEkVvA04Bjacw3P26R7Q2DrBPj3UXc49wbE0DyZzNpka 0NhibvJPMp7YYP+WZGeswjP3HthYCaPkJGcn5Kfv74CG66M+BvRABpf4QireGuQbODZ0JQn4 trMBjQ3dXjbun9PKW6afrA5ZVm9/vYGNroEH89fAd2x08Kq3v97EBgcwtZfii4+JjQ1fTng2 gPRp+B7Q6PD1ShcDGh287WNOvdl5gkOECx7kGW/oLJORCKS0w2peas4RUiH+z7D03ast7afy giilGudeOb1wKg9pQv9xWPqww6dMSFIlC6osSTQh5NmnYen7DZb22yqiUCz3+zkLlkJI6enn YemHHatXNQsRorZvmBXmNyRMvwxDHzcYalW0VurjPklX+pfVIN1iX+pFqVS1WMtLa1OWQxq1 fduZetuxlKG2DyCGs6/169j87xtTb2krF0hRTXhJiwrZZH7sS71tkynWfGqGp7ekr5yyvDH1 Wi95wPb9IJjP5kRel3t/7cy9ua1a6hJ5kbPuCy9Zam/3G5bkgbcpy3/QNMffMyeWQlFLp1dO nzzcgAbXB1pidTbmHthYggLSaf/LpwTFAY31bUkFfPTJgMaSTyb94rMvYgc2WBiApNUXGgMa +voq9mkSrqcb0NjAZU7Zq+rdwLGha4m8UwkmNpY7VndqGdBYdrHfliH36OwDG03O5rPL6M/J 2QYNfTrDhNUZHRMbG77ESZ33ViY2NngpZfV2ZxrYWP9CguL8Tp7YYHGgcqLsnNkxsCHSQBn8 VNkgDRRAllIL09kF3ktHJpTBT73eUlAUqKjcu8issMghlYkfh6EPWwzNCiJKaqArLo2x9NOw 9P0GSzFjbUet3nFeYWWQAAYNVy6DnnqtpZ20qWCMRRHJVuI0hjD/Mix93LF6sVClLoRgXYvT EML868bUWzMxlPZNVXmteUxI6v22L/VmboZqW8MisDbDJUga2Jd7+x4joKUl07OKjAtX7499 uTeTVMau+dSlhBQmDWzKvb2/HosYKrUvJL2/7pC/9uXezFxa6mU0Vlm6p/I/eqfhbbryXQgD pR9NnTTAxMZStO3srE6ScWJjaYreU8HJQR3QWNkHkpzl1ae6zwGN9W1vB+WdXXwDB3u3/6iP gJ/YYIFAEjqfb0BjHQzWC+59/h3YWA4vWyL2dk+Z4NgApiRnRVxPA/iAxvo31+S9V3NAgwUC q0mqs/fMDRy7+0Kys2mqz/W9Bg3eeyWRdwLBDRybn6WmeloR99TDExwdwOoc6z2gwTswpOq8 eTaxwSEs0JKuUyO9gUNkAhlclbz+ZCiZKhqCgZ7lqktbH8ngql5raU5mgjmXIpBJzqS9jeVx yzqBDK5qg08pVxURaGf9NV4jhKv6NCx9v8NS7uSNiBbgtf4bIQW7n4elH3asXs1EXHvBLsnZ ZfYXV28IV/VlWPq4wdJqWQm0FmlRurJ8Ywp2v+7Kvf1WSLMPyqzXXbksEWLpt125tzd5qlnb Fq7AdS1OQ276fN+Ve5tPMzYTmzelrkRpjJr3Y2fmbbmIuk7beyfeXeb9uS/zVkVjI9Pe4+ns uHRl56NtmdeMVUGocEtHZ7eiX9xj3uYqL6kEb3OVV5mKkrK3xcsBjT3HKrevFmch98AG8/CY srPLwcRG81AAPhVjQGO9W2pvO+/s33NgY2lk4YTZSyNPcKxOoDmhk+cZ0FgHG/TyTifROMHB pfqaAH1dkCY2NoA58Vn7iacBfEBj/SsliTeABzaWZuQMSbNzDssNHOvgmszbRn9iY11cNaG7 EdcEx4ZwzYnRPSphgGO/EjDR2QC4p2vwgMZ6mDWdXmp+6uCBjQ1iUkz1dKzcUwdPcIhWoIOv 0tdXZWsRU2ar5bRp1stV2UHdhnTwVa+3NJMA90bABWitr1JIDeTHYenDqy3trbprc6hWbZ49 bfJ5XXOPT8PS9zt8Ks2foFIIdY2xChqToIOx2rF6DRFKrgSw1lI/xKdfhqWPGyyFjFXaytV+ uWBFvYSgdkPbcm+2wi0baafmzu7VXXqnYFvuBVSifm2tLI6oiam0/74x93LbTCUD9GkJujJN Oajd0Kbcm5P18UrSMqmUAgs3YizEpT93pd7mUizM7R+Vehu0FfEyxNJf+1JvxnZKYSioXNc6 SP2ZpPe3igVv05SX7p1Lyt5xrBMbWzIINVXnhYKJjSUBeGXYH+8a9rfSFqQm9rYFOaCx/kVs m53v8SY21r/9naiXapzgWLHAIElxrsCJjXVxttR2eXdLroYNrvmFdNqR9FnR74GNVvvOvnVf aCoVPHAXzD+R4AYO5hmrJBSfmjGxoa+w9ipoJxM/scEuzqnPVnS6eICDiXhK5J6nNMGxISwJ yNv5f2CDFT9O5B3bMbDRYkHbuLw3R27gELHABmFlG8gNk1xyQRKu9e7IjX+Gpe+2WCoiWVGa ybpUIBg0msAGYbXBUu2FrYZastL9FSx/Gpa+32Cpclu43Hb4ggpnA5ReslSDLhbYYKw2+NQy UeeVu1awonVFzSawwVi93lJr51WB3hfNqq4MyrYQWeTrrtzbpS4AKbml3U6O3ZvS9W1j6i2l qgIzZrWzj+IXF2+Ipd83pt72BUC1ncZN+n2ne7P0x77Ua9kMqFbO1NvzLIRpyEDwn/tSbx93 BoDdp7rU0E9DEtKvfalXK/R7l1mrlnrW8vpFS/9HRxP8azOV/UOV36Yq37eUASLu7vUTG15W m9HZQXdgg6n4XgXo5GkHNrYiFJMU5+iEAxr7dNCHmToJioGNXX1Z24p3Tu4c2FgZAzT35grO kuQJjn2FfeaFd3L2DRwbwi1toDqJxhs4NkwkIfm0lgGNfbqSVLws48DG8qDVEojvXsuAhtPI FZ3tX27g8CcE9l5tObCxAWzaFR5nC6wDGxsg1Ivw3GMUOjb6+cR5sXRAY8MXANpx3bn8BjZE xKiDSKsbitwAq5VcmXip63NM34p/hqXvdlgqZEZsRel04viFnOHHYenDBks7M0qVDQ1OW3td OkWhDiZtg6W5rV2z9k9SWpmiACFM2udh6YcdlqJC6QN5C5azaXkX1ox/GZY+vtrSnCpQC7ki xaiedk5+kQcO8enXXbm3WVozi6Ao5CwrKakG3XjYlHu7pdznJ2jt1P6SihFi6fd9ubcPUdCc oR2ESl7ZZTBIxdiWe9sWo1kNai5y1qH70ikK23Jvbks390nS7RvpbFrkhV8Ov3bl3sOnlSvn 3Laas0PX2xSFDUrB24DlP+DiwV3wdmCDiy41ta9Qb9HlAMc+Yb+RX7zzWic4mpEv6uwBc0Cj ny6jt/vBwAZTyZII3K2cBzhYMRBLJbvpxgEOVwy808gnNnYR9jb/6EuDExvNx7NTkRzQcEnN 2DsQZYKDCUfDJN6G7DdwOCOfyXnB6gaOzYQZkpnzCW/g4L24JjXnZnIDR2v35hwePKChT1fa T3o7EU1sbBgj9h5mzunaAxuhG0DOB3nV/3y9cpAZrZoWpiXuNUg5mLa+e72tvWKzdE6nlipV lgqrQzjJj9PWhx1+BcK2L1crbO0L4u6Y5k/T1vdbbEWqylrbAi4rvSwAQtbw52nrh9fbSu1T VaS3v8aqeNYF7yVbiWOuQUxbH3fEq1ixvop7T5a8cuVDQvjmr/vycOfWiQoZt/Mml6UrSzEq ws48XFGg5K719bG2K1fuYjon7czDfcxC7ToYNQ8v8eshuenHzjycqUeqZGgf4ivyUJSWsC8P 9089ZDLNtZ06VrYcDWno9mtnGrb+KdGlzX7DfEXg/MOuWH+tnPA2lPkPCvud3Z5v4FiCgGqS 4qxcvoFjCQIricFbPz/B0YQ9O308oLFrsGByXn3pyOCi1pLo7GLis6LWA3uFkOC9OXRgg18g peydaz2wwTKCpVydUtvARssI4JzqOqCxoYuYRJw3cwY2mH1kTBl8VdUTG7z/dsrYWQNxA8cG cKFkzhZjExu/+55dqH5p89XgkT3tnCPeawcDG/p8VZOcNY54ei3ngAargFX8CtYNHCMgwCSu YMfVA+idWbJaXukNHScgwCSuXm8rGIBZs7WCrDTbaf9fQQICTOLqtbb2VgiVqhWxTMC60t4i hOH4NG19v8WvUAFKW74MKkut3KMEBJjE1ev9aplNEDM3a3lFGYrx65dp6+MWW9myVJMsCqdl hy/aGtId6+u+PNz7Y0kphKKUYWkeQZiAsC8P51Lb4mWpWuys88SFpdzf9+XhZmvO7dsZhLhy WSpbjxnVvDMP55ZQMWthhqWOSu23gwSEfXlYuHmIKmluX04r4+MlpqnSzjzcvrwrFS7QTwi8 8JH4h0LuX6sgvA1s/oMyyJK93U8mOJzDYGcDmYmN5QiqHd8ezkbfAxxMk7bfdD7fAQ1XEKp3 qO/Axr49pmToJDFu4HgdITsnHUxsbAgLpOodFXEDx1bi9nnl3mkHAxu8CFNBr0o5sLFBTCWJ t4PRDRxLRjJqcpaCD2i4liBOqW1ig6XA9s1Ufa9vYkOfj5UTgdO9AxubYGrKZ92An+aXAxq8 +mpi9m4gBzY4eE2TFmcZxA0coyTgZLBwh5IgGbRY5nqfVxFwMlgbbCVS4JyPZsNLpZIhJbAf p60PO2wlA6beeUFFzuTsF22lmGkM09b3O2wFYMyZoZZyOt7vylZG09YPr7c1JzPpDcGppZq2 5a2w6yGM85dp6+MOvyIjAArDQU2uNISJmcmwLw/3E7DV0nulkFBZKs+PUhL25WHIhbKCmYIu KQkx8fp9Zx5uVratVdrOw3mFcAYI8euPnXm4ZqFcS+ZyVh/3oqUxzcd+7svCfQWrFGv7Tta8 1NYoZgX/2pmFGazfLtE+3mlJC+O3Wc4rOsLbLOflKX7OOtIDGstccEltG3dWkR7YWGYgUzLw FfFNbOjzGSfNTvp7YmNXX639K8ZbZDjAsdxULW0/dkocN3CwgqBtYZFXhZngWAZcetmLs5h+ YGPDGCDp2YX0p2E8sNEKAhZnrfrEBm8i/U6pV4c+sLEUJImm7J3nPLDhCgJVp8h2AwfLgCUV 9rYLmuBwlcPESTPfwLFhDC31esX8gY1dhYxJvJMGBjY4jPs1A2+xRofGqAg02SvaUBvaTof9 vnr7c4WUDKoN/Wfa+m6HraxQ2mm4VEGpK/WSHDIi4OO09WGLX6GoEbNkqmcZ6kJ16NO09f3r bc2JM5O2XV5qKacX3F8ylkNqfj9PWz/ssNWgWaikLVPzWneJEP7qy7T1cYet2huQZy5WezPy BYkzZpDq1315+FAR+mDyTk0WPTu4XKoi7MvD2RDbpwZmbZl46T5CiML5fV8ezqkUZSnZoJ1A VvjmEjMZYWcabmd8U2wbLLY9Z0H0i9Gtf+7Mwm23QeodyESZVuZAaMju+mtnFracseQ+tIVg aW73n22ul4sI/4JE4CuV2lAktSIP+A5doc90v9Ok2XxiSsMFH6BT9fYEnthgiiRl9k56HdjY 95drKt5p1wMb7l+nGjWg4d713nWY2GDvWrKzL8xn3j2wwUJK6fd7nJdZOjTWvTVVb1f+iY11 L0Cq3pZEAxv7fCWZ85bIgEYHb2XnRbkDGsu89mzL1XmJ5QaOdm8u3r13YKMdDP7kDOG5WZKg r9nUxIbvvOq8YXNAY32rqVbvd9XARoevJswLU2c6OEY84Una8euJLEWgTKoVYelWQoie8M80 9d0WU0WtSmUEBlqpEY2x9eO09WGLrdj/0wdB5LzWLyVKO+FJ2u3wKxTKSDlLLUtrOISg/Dxt /bDFVsI+iFetnGrOF14i+jJNfdxiavdrS06lFFvpbhTUGubr1iycK1ntvdbraU3ahbZ+25qG M2fofWGs4NqlvxCp8/u+NJz7N1UhEM6Scz47CLwoiYVsOT+2puG20WTmyl0WW2oLGeLXn/vS cJ/dYoZdUqgksiLrBhn7a18iPvqjQOGKNZeqAUPgL5dPLrqDcb/Dpe9YOjBwDluY2NgSaU54 1kj1aYX0AY19e31WtHnPtxMc7l/ythsf2Gj/UnFeZDmg4f5tRyK3exv2AunAKVwd0GjnKjkb JB3QcOd6qdGJDRcOvGXbExvt3azOuveJDWYflZK6dfEJjnYxONWXAY11MB6nL5+DBzb27UlN 5r2fdANH+5e8HYgmNtbD1LKaM8VMbHAIN68VdwhPcIyAUCZ1VTYICKYGRIUzrnVwDqmZ/Gfa +m6LrdlImFgKrBX9Rk2TLpO5eq2pneEoYKCShXTRr1HTIMqkrjb4VdSQM5VcbO2mSQhN93na +mGPY1mhBZ9yznx3QwO+TFMf94RrLVRVVViXpoSHKQgb0zC2DYTJKnQG9u4Ev2/70nBn1UsV IYSCta5QzTXq8sXGPGxgvVRfKfPpbfHrbP2xNQ0TN38qNptPy2ouVDd/bk3DqhUKdWWo1LMu Ctf59de+PDwEBMpVuGaSlWqENwFhTUC403HS9yofILbTi3PY6wENfboqSZwt7gc09t2Vmuhs mNjTlzewsc8HqZ1bfI93QGN9W5Kys/nQxIZ7V8U7xnyCY8UDpITOQaoDGutgTdlb3DqxsQ6W nNA7vuAGjk7OenoYf56dOzY6PZs6I2RiY9nH7jXyFvffwNEuZnRuIQc0OkeXs3Yyz1N0gwZn 6JJAvfvvgY32rRTnDjex0d5Fb9+riQ0O30KJzibnPXPwgY2RDmRyVrKhcRP3Ejrl3I7BS+f9 kGGt/0xb322xNXMhsQykdDZV5kI6/eO09WGPrX3GJYJJsRXKKk46kMlZbbCVrRgSN7cWWap6 DVnDn6etH7bYCmDYvqSxVlmZ6RnEp3+Ztj7uWcOIJKUaAq90gglaw1+35mEQ6HeFoDCf1WNd qx3sysNHk6pcm6GUserKHJ4Y/ev7vjzcbeWslEuRanmFUA/TDnbmYTRla4mJ9Kwl7MtrOKTR 2s99efiQcCtyF/pKWZp2EbOGf+3Lw4fWh239Qv98opUrb3+4hv9a7eBuB0nfrXqgqRRn84kD Glu8R0fDC+980gEOfUIqlvJZD9snDzix0f4lb3/2iY33sHNM+MQG+7f2a+hO/x7YYAWhOY28 GsfAxjqY2/YH3v72Exzs4pbYnAzuxEaHsKq3f8zAhocwZ6+HJziWhuyTRdh7SewGjnZyPv3k f+7kjg12sraX4nbyAAeHMSY5O0c8C+MDGyxWpuLtwzOx4R42d6OgCQ4O4yLpdFjgMxcf2Bg1 QSeLpRtOxUhIhCos9awy5bpT8T/T1nevt7Uzdn3oMGKuRe6vNcrHaerDHrcaQzv+V7aKfH9M 7Kdp7PtNftUqtX0nIekSExs1TFoni7XDsUKF1DKrAd/fDZMv09jHLY7NYppzwd4O5u78+nVr HjbUzJaxd7xZGgMRwjp/25eHu621QDvZIBazJYY9Sk3YmIiNW1YCBGl+tZWbQ1Fqwq483GwV K1mQjMV45apfTN+mn3vzMGYh7JPfjVc22DA1YVca7rZC+5pQbHlJ1m7TvN1EWFET7nOc9L0q Ceyv9OJNhV4rp1vr6qqzTcvAxrIXVZJ6u0DdwNH+Lc7nG9Bg/2JCr/x3Awd7uCb29vK4gWO1 BOZkZ2eYpy4+oMEu5gTODDOxwQ7WpN4ZKzdwbAiXhN5O/hMbnqSdYy4GNJh+rJaE3BE8wNE5 OjvV8gGNda/24RDOAB7Y4ACGVPwZeoBj/Yvtw8m5yU1scADn3tzbG8IDHB3EfWaZsyLiBo5R EWyyV7ajB4G2Q38VVealIQEhPQj+mba+22IraK4lZ2O1NWY9pO7347T1YYutGYuasAFZXuoF E6Ui2GSvdqzhtn6z9dEP+ayD5YW1sJ+nrR9eb+uhIlTOvXZdK/L9OfbLNPZxj7FqVZEQCU5v F197K2FXJj54SS6FSsmGS3Rz1DTpXYn4oCW7xtkFIpKVWRdhMsKuRNxlBM1o0o6ZRQFXGt+E 2PpjXyLuxettt2HqhevN2BV5KEpG2JiIzbJQLi1H4dK8ljAZYWMeViGAloO1T0b/96Wwu5cR 8N+QEdqm5ePrOzBUSHgb8rx6vBVNVp2VuBMb+nxqyU7vKj95vokNrgWHBGeVI89KwQ9s8PMl Enep+oGNLSG1RMXJT01s7PsDWugGPsGxEodY0rOatKcRfEBDX6BpEi9BP7GxDhZYuMwxwbFP WBK5y9QHNjaESxLwNoQa2Fh+FFpiU2+OHtjYPVhSFWeKmdjYPbgt+jMG5+kWfECDA7gkPhsb +yx+D2z0DlzMPyupY2MlonZsYqdEObGx4auUEHz+HdAYaaNOQq1uoPuxGoEp1aVa1aAi5H+m re922ArQq/yqlKMyd8FWiLohUSejtsFWVrJiZJLzUvsWCGlB9Gna+n7LGlboQzisLWKBJWkj alJDnYzaa21tKTBTvwciyJXPrm69SDJFCRt1Emob3Jq12NG5BerKhNG4+xG70nAnStuHlWGl WstZScelusauLNwvpPfS8l5ybSQrN0FCvPp9axLWFqnQawZYl3qjQdSk541JGAqoUEapeS1a Q+oGfu5Lws3Wfg7HUrjfeVm6kRcla+zKwjkJE/Th7NL7wcmCNCd/Vjdw97LG26Dne5EPShJv j4eJjaUuJImXO5vYWO4s56Ti7YQywcEEePtacFJnDRm7+jjV4uP1BjSYmMoJzkranhFTBzZY OGgL3st8T2zw0iuJnL0xJjY2eLG2A5Kz09zAxr4/TObNLRMbzStnb6v3iQ0WDgRScTLfExud /7za7oCGPl3NCauTWJ7Y4L23zxdyTmoY2NjwpYRnncuf9S7q0NCnY0ng/bKa2ODgLdCHuzhl 0wMbIhxAHoxV+3NDVxoCykCMeDZT61LhYNj6boetJbP2qcfYybmV834JmtMwbH3YYStwFqqY iXlNIwm5JvBpmvp+yxK23JZun0pRwJau9YQ0L/k8bf2wxdZOLTNVwSxr9FzQiOdh6+MWW7PV 3rmYLOezYU2XCgfb0vDRgIeQMXO1lp9WmtIENVbamIZBtWQpJAVpya8QNOJ5YxrObcupFdoW i3zWRPLCSz0/duZhAGoJOBfMRVd6NAbp8j/35eGctP1LugBWNdvpLNKXjNUQW3/ty8O9XMcE FRip9OuzC7npz2oQ/lrp4G3E8xp1YV2ZdXIXAxt8+MZ0usE9O30f2FjyokqPbR95MbDR3GN2 TqEe0FhqCtom4COmOjLWsybpdAt+diPiwIbLBt75JQMaXG5rqR2wvPW2AxxbcNvSRR/B6Ku4 neDo4PXeCRvQ0KfrPVbcN0oGNpZ5RIR0WpPyTBc6sNGivapvaxvQ8J23on/nbdjY8MVeJ+Dt tjPBwcJzAvJmwIGNDWBMBXzhMaDR4Vvbnu8dMDXBMdIBTM4KNtyUZ4RqkDPntYa7IWWR/0xb 373eVkiARMQEpaIstd2BoHZKw9aHLba2jwWxigVqXePnQmz9NG19v8PWrKa94SQK0xo/F6Ud wOSsXh+vpn0NM5KinIrqLxlrIfH6Zdr6uMPW9sWhVJRqRi62ws+F2Pp1ax4WtoydTAdgXeHn JEg72JeH214jJgjYedeFKuYgPv371jycM7RI7bc5y9qeE6Ud7MvDbW/F3I5ZbXellXAFChrx vDMP16rSYpW4W7wSryF+/bUzD1uzsyoZEEhdmd1tf2brX6sdvI14Xi989HYlH9DY83ehxNnH zU9sLIMhmrzzdSc2lgHvgxh9Zf0DGlyVXv39Tm7gYIaqJjvraviMoDqwsQqC1kRnF+Kf1n0f 0GAFAZOiu2fWAMfW3mZLWJxTLQY2OETSKdHy/NJQgwanZ07Fq00ObDABWWs7A3s7Kk1w6CvU Tno6OwId0OAA1tQ+0J3xe2Bj83MfxuTsaDOxwc+XzsqOnz1dQwanFvKPjr+BY8OXc8tpvt1t QGO0A5ycFb76vH/0Oa+ZVDivdI8ADBrFMGx993pbc6rUh2pWQGhfSXWltjfE1o/T1ocdfoX2 L+nNMrhCXqE2gmpAP01b3+/wa+98glK1qtlp/9GXjOUQneTztPXDlnitoEWzELfVvMLPYdS9 A5yc1YZ4zdYpuiJGZanBWExrm69787BS+37JmnGpiw9gCO/6bWseLi0pdZ2kmtHZt9N1Osn3 nXm47ay5z+pue+zKbIKgKTE/9qVhSL3jYakkxgZnd11ftJVD6PSf+9JwX8KA2foIdjY5Oz1t LMVflw52peGWmkDbtsqG1s6nK37FP9te/1bp4G2e89rhMbeV6T48DnAs9Y2csnMg7MTGMo9F U/bWBt/AweRPKm4XD2xwbXVJpE5ydGCDueU+9srr4QmOlQ8ALIGboJ/g2DAmTVKcdzgGNtbJ LAnP5iM99fHAxr6/FpjkVMUnNjaIzd+TfGKDOUjtqddJQg5sbAm4JfYO1Z3YWAdXTJZ9729i YwMYIXkFwAMa/BWT1PnyBjTWt9LHmHs/ESY4OHyRElf3VOwBjpERaNJXtKNlvJbKIKp2Vo1y Ycv4f6at77bYKrlZqYaFz7Lyy6aGsFcfp6kPrzf1mMGIWnv5tuBpmcx13VA+TVvf73Cr1MzE JIQiSzcQJIRZ/zxt/bDDVhbgPiC2ZKWyMs+ZQ9bwl2nr4w5bwapab67GcnrOeFkJC/Hr131p uFf5IpVaEaFgWajK/8Mi33URYVcWbqZKLsagAtaO1gu0pEWJCBvTMPY7JVpZM5SVNVxDBM4f O9NwkXZA6PtrOwjyisBZQvz6c2caJi7Zuj5veNp+8+XLFlEqwr40nEuvnSXG2naepYZ5f+bX u1cR/rVxzv55zm8Dne9b4yjcr8w7q/tv4NgnJEvF28DjBg5+Qk3oPH1PbLTGQafnjecaR8fG Pl9O7ObnBzb0+fqdAmeEDGisvtGjMnsb99/A4SEM2VmhfgOHh3BRXw34xMaGSElEzpHEBzRY KE/gTYATG0uQlt5Wx6e/DGjs4sOa2NuB5wYOfkJ/D6iJDX4+Tka+T7+JDa8yyO4mcwc2egdW dxXEwMYGcE2C3tkgBzRG3eBJq/Hr+ZdaQaj9V7Ed1pcm4oYQa/9MY99tMjZ3ZrgWY1kadRxj 7Mdp7MPrje1tTHIp0os5e3Xj3dn6adr6foutokSsvYs06RIDEzTWedj6YZOt3KLVFCQvXZOI sfXLtPXx9bZKLzFnMzGG9vfCGpaYGvOvWzOxlj6VXA3bWr4/QfLb1kSsAlWIqFQ7q++6ztTv +9LwYaqRiUo7/NLZkLbrbP2xNQ3nCt1UVDjtqn3hNJWfW9MwaoX2wdz+ySuNKSGH3Lj8tS8N d1vb4SVXycK6Eq5/auvdCxxvg53vRkbIiatbRhjgKxg+P0tfoodP9x8ltxQzwbE0QR+94IyN iQ0m6ts5y80SlPBRA70CzPv6JjhYSqDefsVJlA5scIhIqu7nO7DhzwfOixITGx3Alp0ZZmLD lcDi5UkHNpaHtNr2Bd9trAENpsEtgU8lGtBwESE7X97EhosIcka9viAiNGx08KJ4VbaBjX0+ SSbe5DKwscHbjreJ1Ckj3MAxQkKZ9FXZwK1bKaX2mZuw1OUjTEcok77aYqtab1QD2M7E99ci /OM09mGPsWpYM1kvbpSVivowIaFMBuu1xh7k+igzLxnK/ZHrn6etH7bYaqjWvmQqwdnueOFY ii/T1Mcda1gIoXQKlqTfhVkQEkLIuq9bE7EqaIYKwmJnZamX6ggbE7GKMmox5nJaRnWpkLAx D2ufwcF93ojWFaU+TEjYmIYR+9Scrg/p2Qiul3NTyK2QnzvTsLKaUNtbWbGs2KpRNyX25WGF wkfLO9XMK03D9K3f0pKQ8DbmeZE/q31kipcCH+Bwkj6ju5R5gOM5Ui/JdwNHlwvX4m6rdWCD ZYQszsgd0NCnY8rugcoTGy0iWFtTTprlBg4PEWb3Ew5w7BNKbR+a3pLwCQ6XEs4aXL+gJNTg +xKIyXtf4oDGMpHSFj0519/EBlPhmvwXEg5sOFWfT2eMvcDVd3BwAPdORc5LdzdwdACT+a5M DGi0mOBuHDmxsSFMQgnFl2ImNkZKkMlgyQ56HSSrmOWqK70+4rQEmRTWFmMrVtSWa1XXeNgo LUEmh/VaYzu93mlYtsKIZ30nL2ww9Wna+n6LrWpcK1PhLEs1k1FTn2VSWK82lVLJrEosiqwr bqUSsoa/TGMfdwRsS00gaNIyFMASORmyhr9uzcQqzacFMnXa7u4K9b9tTcRaKjYjLUtbyAt+ DdMSNuZhtlxyM7dkW7mTADmEc/6xNQ9TKTUTcDagpT0nauzztkSctG2urAil9pkrK1pCyBr+ tTMPG1OtuU9b0fY5sdIR7s/8+tdqCW9jn/+g7Yh6+4LfwOFqAnuJoBs4lgvPmAx9Fc0TG10x LM7piQMay9XXlM8+TZ8GxwENfTrMOZ2eE5483sTGKwmCvvc3saEvUHNXbp2DbQc2NniJUgtK X/AObLQQKN7Jygc0WAas5CRwBzSYgOSSvArRxAZz9JJIvTr0BIeLbOIcfD+xselFMZXTZrxP 88sER+++9YwYfr77Nmi0jn/WcOW5jI/BI1fap2aqXgnrBo5REHTyVrqj0U9vBlOzEerZiPVr FQSdxNVrjYVE/Qhca58TXPMK00xRAoJO4ur1tmZixvYXG681mAip4/40TX2/xVQzylU5E+al maM5amiDTt7q9fGKGbW0bU4EK6w0q8Io/UAnb/V6vyoy1T6doldxrzQO+cMa2HX9YGMeVs0C YKzAuKKChekH+9JwLtW0CmFbwmucetTUhl1pOCcrRXM1aIm4nT8WtJKYCRU/tuZhbFmpj39q H0JnnN6Fe87PnXm4RSpmoNq+mJmXpudE6Qf78rBpYcuKJHJ6+/plU//M1r9VP3ib/bzesnxh 6kAHxz5hdXZ6qMFtHvhoQO5tBTXA0awF+tsAHNjQ57Mk3iYoAxqrGlhJRZ0XEG7gaN1AkzrH ok9sMPFo7a14a4MPbOwCtF7C4Ex+N3A48SjONTixsR4uycBbnz6wsfRj+5hOKM5mZDdwsH7Q Ugc4R3IMbPA+R6l4e30NbKx6AKU5zRkjN3B0ELv7HU5s8D6szm+sAxkbwKV/mXhrgm7gGP3A Jm9lO/QDQoOevstp37Vr9QObxNUGYwtVYztMtpWq/BpSDPpx2vrwelshCUjttczQpwSvFEhK CPn6adr6foetWURKM7ctYD3bz67tZWSTuHqtrZK4IGimyqq8MthDOGQNf5m2Pm6JV0Iy1lyx GK+MB65RzYw2JmIV6W4lbGFLd1eU/21rHgbMGUTVCtLKtIsa0j3/+848TAClNtcCCfNCHxig EFt/bM3DvdUNU1vGlc9ull74LfFzXx5utkLbW6uR5kxrvQJD9tdf+/IwJDURqABY81rHS/0z gf5yAeFfkAd8RXAbyt9WBk37Doahz3S/A6ar+ISUhos+5Kvz/sCAxpLZnMw59nVAg9+dptP7 2c9e3oGN9m3xspwTG+1dp8xzIIPfnSVwNmuf2FgRpQ/q9XZxmthY55aEzsjtyPjA9Q4svYHD BRT2h27HRnuXvB2IJjaWf+1e88fHBIfT6+adFzCw4XsvOC/YTGzw++NE7hA5sOFlDM5ZOAMa 613qpJHTuwMbHcDcNlW3/DTAMQJKnbxd3dF0QYWRS7a8Ng0ipOnCP9PWd1tshV7e3HsuCJ3F xYVTLz9OWx9eb+shjEn7qxZAqivcc9wwiDqJuw2O5Wy11Fyk8FIXspA1/Hma+mGLqah9umfN prjSSyOoyPnLtPVxzxrOItjykkBZauBUQy7WfN2Xh3sBkikgtPTUctTCPJMaIgF+25eGjzk1 Kr2ouyCeXv+9MDV935qHFY2aX0Watffn2B/70nC3FXoaLoRZl25gxNj6c18ePvwqXcJmNc0r AxJibP21NQ8Ltc/ErMTU/ueK3vlnl4gu108uuoBxv1Ol71Y7gCTuE/jAhj4f99bcvjLzAY19 eyKJzqbiPX17AxvuXee4zQGN9q15Wzcd0GDfai+6d/r2wAarB72pvpcdHdjY6u3cCUVf8ewB DQ9db2eaiY19PuzlxF7nNmi0b7F4L6ANbDD1KJYye6P3wEZn5tNT6vPMrMFzpLkm9jLLExsc vJSEndExsOHezc7cckDD913xqRoDGh26JVX0fpNOcIhqgHmwVe3P11esY20rE4W5/Y+7a6Hx z7T13RZbyQoTGpdiKwROELv8cdr6sMXWDIXZiBAZlmYhBIkGw9b3W2xlrpwrsepiG5gg1WDY +mGLrVjZVNRYT0fSXKoaDFsfN61hyX1UNhU4u+J94Rr+ujUPZ825ZDTgpWnZQYrmt615GACw CwfcVvNSbgq6dbEtD+dUjcQkW8YuCt3dbZofW/NwRmwnLJZ+c+j+OkD+3JqHcy/ywoxSi67c pomx9de+PNzXsFVDICmqVFdUg//orYurVIM7HSF9t5qBpuqu6hrY0OernKh624oPbHDhLSc7 UwGfFd4e2Gj/Fu/7m9hY/0JiJzE/oMHeLe6i0YkN1g0sqVcUOqCxzi2JydlSZWJj3Ss5tbOC t6vPAMeGr6VizqLlAxrr3z5C0SnTT2ws/di+pFNxUvMTG+1eZucLnNhoB5tz+Q1ocHamJOic enwDR+++Bt6xzAMbvfvq2Snz+e7boNHhC4nO6nqf+ffAxmgHMDkr2DHSEggqEuHp6LULR1r+ M219t8VWyJWxauaKsMRFBt04GLY+bLEVs5FJv2JRzj6/L+wo8Wna+n6LrUV6WW8utZw2Yr1Q //o8bf2wx68I1mnXnquX1nCIX79MWx+32JpLNqiQc1vDS/xcSLx+3ZqHsULnmBFzXqvCD9GE vu3Lw/3KAUsfD2Cs7X+sVKaH3CT5vi8Pd1sLkoHUamBnxacXksw/tiZiwH6zu8pxjfHuAvbn 1kTcIlZQsA8D5yURN0o82JWIu3jQlWpjZFI8m0C6UQD7a8WDu50Zfa/yAXILRGfn84mNPYBT TSJefWOCQ5+QSum8rHOw4QTH+pjSqWL5vDNBg4Z72M5abL7g4IYN9q+4KdyJjZUQejeJs2qZ FxpP5ODWQFR6p2dvAA9wsIMxkbPN3cQGs6Spn83drYEweEAKkPaic6eDD2wsC0mF2n7vHR09 wdEZuhanynFAgx1MSauXBZ/g2BDmmpCcT3gDR3s4k5MIP6DhHm5nbL+HOzg6iPvEYec+cgPH iAk4SSzcQXZY6RXcoBWXZipHzX8Yxr7bYqxS77BOzIZ32F/h47T1YY9jMwIX1BY8djZE5zrG 7tO09f3rbe0DpBHArFKVaktrOKTa9/O09cMWvxoBSO/UVKCsDKSNqWz+Mm193LSGgdCq5d5o feGaVFT/oq2J2FrAAkKFeodzeL5tzcNFWxouSpU0r5Ss/2E/lHU1YWMeNiht9eb+hZpXBvGE 3UTYlYcP0hlHuybF0yK+62z9uTUPF6ks7WSuUgRX8nDIGv61NQ9bAVUB6rdVl2x9u4mwIibc 5wDpexUSGPws1cQGV/JZKs5SuYmNpTBq79rupTAmONbDmMTb4mZigz1ck4BzCd7AwT6G5KT5 BjRWSOhheXad+oUIluhS65zYWUs6scHOxXQ6A/CZdw9sdIJmcerjExscvpLaMdobvgMczEHW PtTFd1tnYoOXYHJvICm8kt5/E2tiY9+ddVXAWWhwA0d7txZvncHAhn9hsXNA+MQGh69JUucO MrExAgJN3op23MiH9l824rzWOz5KP6DJW22wtX2+Qe8VomJnutC1txFo8lavtbXzkZQxa21u LXJ/veM/TVvfb7G19902QlVUO+saeJ0u9Hna+mGLrW3lsiq1wxxTXeFeo/QDmrzVjjXc7KSC wlmh3h+p/nVfIj5IdSiY20pWElpZxCGE5Ld9ifgg1UkV+mAWk5US/ZhF/H1rIja2zGSQtYXs 3Ql+P7Ym4rZyayaVgn1Cy4KtIS3lfm5NxJXacZJrRcl1SRgK2WB/bU3EpsKgLQ1jXZp/8D+q H+C/oR+0TctH1HdgqILwNtN5+WQLksg93nSCg5+QkrdH9MQGlz9an7virH88sLHvr6118Rap D2xwgWbXU5zlmR0a+nSVe1thb4uvBo3VNXpEKjjbGN3Ase7FnNph1zs+YoBjAziz+xbMxEYH cHE34hnY0OfTfkpyPd2BjCVGIWPC6n57Axy+v3nFq4kNDmBN4P5CmODYAC6YzkiXZ5eIOjR2 B0lavX3mDmiwd9v7cCrPBzQ2fJu7vN8uAxqjavAk03iDqkGUq7TTeSVdmuocpWrwJNM22FoU C1Uz7n0R7q4Xz8dp68Prbc3JikChXrfZzMUFgslCbP00bX2/xa+spaq2Dw/JZ+NULuwT9nna +mGHX4txzpz7YNxsKwMaSpSqwZNM2+BXU1Uj5oq8QqZBjroVsSsPd2VOsR19qxbIp6WK15Hf 33bmYQA9LqZZMVzpTgMhbcK+70vDfctp8SqFoJSSl5ZwSBr+sS8NH4OOq0K/KdA8u3RhK2io 88Y0XLk0I4HbLitWVoj+kC3n17403LactrliLtQ+msrK3bTyNtN5STl4m+m8zFxwqsV572Bg Y5+v5HR6m/Pp8w1ssHIASXxV1QMa+nSWnLMPOjCasyjOWd0DGvt0XNLZp8bTpzug0YpBSaje WvQJDg5bSqBeTWOCY8uVsyQuzie8gYNJR2A36dihoU/HmODsdufz21YNGqwZGPRiKO/ogwEO 3nk72elVNSY4WNWlvurdXXcaNnbvNUlUvONVJjh6//X2BBrQ0KcrJZ3WQz4l5g9ofAhT9qrO ExyjHZTJWZUdbYa1imo2w5XL8nHaQZmc1QZbwQSpkjSL11plh5BWH6etDztspebNSr07S6+y XrCVouYzlElabfArK5BQ+9CUtVGxUdJBmZzVa02lRAKlMGMWo5XO9kQhXOSXaevjDrdi4bZp 1sptJS9d1sIQv37dl4Y771otc5XCwrzS7j1MOtiVhnMyU9a2fEmkJamFRWxR4xn2pWEkySJk WmhpKi5gyB2BH/vScL8jILWt3ppRiFf49LjZzrsSMSemPipWSm0nozP+7SVbW3QHiQcbE3FL TKgGiiBLa/jP8vBfKx68jXZelg7ISw8MbDDF3AstvXVxBzaWgazte5KcFNUNHExf5LN7dc/Y i4YMXn05FW9Hrxs49gmby8TbUmRgo2UETsLuVzjAwVXBoyemsy54gINlBG2O8wXJxAYrWUnd lekDG5titH23OknwiY1lIamnDqd/D2hwFoReM+QN4QEOzoLm77x4A8eGMJdUz7rZP3XxwEbv wuJkwQc0VqXMSXwawoEMlhCqpFK86W+CYyQE+X/be9smu3IcTey/jD83lwBBANyIcYQ/KZUZ JaWUUspfe6bb641Yzzim2xHef2/yHF7NrPKeNZiXAk+VUl1dWV39hESQBA7x4K1zVzwjhJAT sKgcluitjSBwp65uFRXbFFVCVZWS+Chp6Zqs6DNF9UOX9e52WWObwxZFEgFWxw4HwiXiQkl+ 7LK+n3GFlSi25lGc699HqGZ1YXMeu6z3U861MDBlQGKOMBAvURd9/dRlfZhxrhwpirZBBW2k 9cC5sldLpVlmeAshYKy/uFR9HRmO4xZCmGWH27kmhsRNXhlqleVzrl9m2mFt0S+QrRXaUCM/ 9WqpNM8O1+NsXYYox/r38/UsfJ5phxVKSZracKehWVbqEqD/NtMMR8hQPXtI9f3kkHfxywYQ 3sY7vyKEUG2OmYCsWF/+EbS+12zsT8f6ZvARB2Xb+jrWdX0SWIz5mTvUOUkdAxj7pXesc4o1 Vs/I2hO/g51DCG3g8FGd4pUtrFhnBS6BspE9u4B9D1mwFS4bD7mDnflHOHz3vuAfG9Q5ypsD HHWwfRHl3bDOAQSm0Bx+G7/cwf5BhGJs37ZjnUMIrdmr8TtyAfuGEAQCGVPpO9b5O1yK8Qbu UN8QgoZozCPZoc4KTHVPjnopv4gPbVifEIJ07kpuz1ZPXB1hzYmVaMRDTC78629d1nczZI0x RVBhbiGTkcx8n3jJhy7r3e2yxvrep9a6qH7zJMcRAtatg5F07mrCubbRmgUFJRUYmi3iNZdB Onc14VwROQlyFZZlZAaFD3n1qcv6MOcOtznHJK3TO6WB1HyfO/x5nh1u6UstYV0SYnWUTjdu 42meGW60er2+VF3+kiKNlA2pi7p+mWmGWQoU5cS55egP2Cb2CiFMNMME9fOKJRPDyMQYiF5T GeaZYSbKRShCAUoykJrPXkUIE80wojKnUk0UHTqLEz85v2oQ4W2s8yj7U02NtbHxDvZlIIu0 pEsbAbljfakL5ur+WQdLdrBzfmaIak3PbFDf840QyFhl0rHOQYRSbbdRQy5g5yBC2qblGvuM bFjfIxYJ+cjL+vGId6zzEecAViN4AfuqMAY5euP/qMIb1JlfboX95izhHezNQeZAxv74Hesc QmjhUet3uIOdlRhCsobyd6xzHLC+6YwTTDrW94TbWCFjrHyD+q6OSn2YWKtMOthXhTNKQGuD 0gvYJ5CgncDSCe3GqeS8TT2OQ7Xq0YXp+K3L+u52WVuUsXr9pTrFmhIcnetVts6rGEE7g3X7 uQLHNgi4iAqPjJ8E8AokaGewJpwrI+TGOUdFHenJ5TMb97HLej9F1jb0od7fmDTGoZb5Xv2M tDNYt8uqMbULjAUgFRlhsLyKEWbZ4SpriVAvcI6lvmUGAro+LX6epprh+u2AKmSS1g5m5Aq7 5Kx/mWmGUROJtm9skqEYJ3oFEuaZYSwZMVLV1pwKDQTqk1c3o3lmWAgwxlKfEqp5pMZEvAIJ s8xwvcPI9YVY6icH05G/c/0Ov+7ZdPpAwk+b72wf8Pw24fnkYY7qT9u7gX9He6+xDX41L3ED O68wazD2LO9Yd4rlqPr5CsVCvoEECWTMo9+QrmvjQNb81h3qHOBotx2sE0S/o/2VIxdrlvUF 7b1GDtVftS5xA3ursHmsSXQfa9Kiy2YdLlNmeI8wpNwqC6xa3KDOR5vqfTK+XC5g7xVSyOZA 1gXtv8ZYRtbY0K5rLIGtVXc71Ps7bHvCNKC3AnM0fuR2qE94o3RarUxosazAFJUJUx7p3eLX bKl0Ym2KsARFqKXo4siYXL9KidKZtSnC5tL6JGgGPqpIXyjsxy7s+9uFbTm6qvXt1jino/6u awc2lM6sTRC1tZQCbdUSMtLX36kq5FOX9WGKrCJYGCSxHqYrLQy+fp5qiYUjSYFWtaZnrJSY aIclS071Fgtj0dPNpvgy1QyLQG5tDLj1NDxdE62v86xwizNHrb6+tCkcNDLDwCf2+jzPDLfP q9QPTmllMKkcNSxZ+Hn9NtUOQ3MKqnXC+pYYekq8lUoMRRHepj2/hqPPbOUwdrA/DQlW9/s7 2nuNYh+a3cGuK9TAYFvehnTm6sHI4G5I3yThlIMYu713rHckoV74cvTgvaYdFezP0ZdojyPs aP818kCsY0c7k5Axmac/N6izEnO2hTk2pHOmdXOZjHnWG9SbAa9/Kho7VnWw9wpToKPeKC9X uIH9V1jA2JXsO9r9G2wdbLJBvSPmYCyX2KHeKsxH5QMvNLgiXeIIKe7sVf05g22uv0+G+ovx fO7wb13Yd5OE1dS6LolSOerUtzSOsAt7N0tYIMTWjSiWM8YRdmHf3y7sFkcgFoaozCMttN0C Cbus91NkFRZMmlVHBo84UeufuqQPM65wGydDucScSRDSwB12qWv6PNUQ11Nl1aKClEYO1iuO MNMOS/1S5tZvKebDPJaVcYSZZlhaa7RqhxEZR8ywVxxhmhVun5yimFurP4Ej1mfp2OeZVjgJ p5STJoaRpmFO3aW+zbXDFCkrbaLGo/TWq+Ou3sIII2GEt7nPr0j0P6rIuproT970QNZwWFx0 jSVN7t0UsoTq+5kZyB3tTGCYGUhdwUDGbOPQNqTr2rJ5bXnO2oZDCEJm7qyj/Qn6aB0d8h3t vUYKah1e08HOCpyjeXBsg3qHENgWx9qQ3vxjNrdq2aD+IQQ8ahB8LYRQwQsIerIOpr6gvdeI IZnfMTvYOdW/JNshb0hn9c3WWqId6q3AqMaKwB3qE0KAzlzBlBCCxlIwCeSRfrx+IQTo1NUM YUVBSl16joeftLUhBOjc1SRhM2pqbQbT+YJDH7uw728XFurzt7RxDSQpy1ggzKnZ0i7r/QxZ 6/kUAlbY0n5Hmmg5TX7eZX2Ycq6qJUvMGevZDs0cdelA9HmqKZbWCB5SygXS+RL0n6ZaYuES sX5x2kiDM8YQJtph4cylmuDqfWg8XWzo6zwz3AaPiHJMbXy5jvRaKi7a+jzTCkflVsSZiXP9 +JzOMn2baoUpK1B9R0jEkdE5rw3Q/7IhhLfJz+PsWQmazQRBR/uT9GLvutTR/mus1nugFkF9 WUgJfBi8fMFiNKjv/hEFUGscpoNdV0jB2BQ8TAhhDQYS6oUXayLzDvZWjhzEevu+o33XCG0o iLWtTAc7hxHAHgcE7zhgDsZE9Qb05SBTrubCOPqnY70JcAqsdpJ+R/sHErK1LdR3tH8ggazx ou9o71ACGxe4Q52VWKzFHDvUO5hQv17meL7P9OeEnb/CGaGE1ho9UcZUxhrCeIUSsBNYc4St r/RSn3EtpHA6YT90Ye9uF3YfxlmPNUWWOMJgOaVLfuyyvp8iK5cUIQpISiMdYdzmP++y3s+4 xJGiaMzA2pJ/R/h1l3P91GV9uF1WwTASFhL06XT/ear9lfq9BQJMhIeFq0vjBxPNrzQFjQx8 3CpwafxglvHd+jbVL0w9UCkk6XSxkq9TjS9JrN69av1rJFPdqRLsearxTe19XHWWWEZIda8K hFmmt1VbYP3SKHBCPkpovX6qf9BRDW8zn88SOoBsHfZ3QTuvkdu0HnONxAb2XmEJ9cVh7km/ o51JC2Rz6KBBnUkLRJvmbkjXtaWSwlFF9o/M4wZdEDqoT4WByFpD++f3l6M8rWv5/RXsvcI2 4cC8wg3srMCHTXdf6G9FOqsvW8PPO9SbczTPU87+05T3xvzmecA72J+Uz9keONjRC9Z41A71 6hLZuwIhgTH2t0OdVZjYeMA71FeFCdpkP2P0fsf6hA5Sp67SDDY9JaaIDBLHWsB4hQ5S565m CEuRqqwlQ5vBebYsyQ9d1rspsqomKkCQBMaahbjI+rHL+v52WVvkgFEBU2RCON+MgMcu6/0U WbX6SVVVkbRe5zM2Mkqdvrr9DkdI7a8IOWNV3BFpnWIIEw2xcAJkrE+t1oLsbGTz01Q7LFhQ JLIAxKEiBBd9/TLVDnNuzHosWSEODURwkfXrVDtcDTAXBS2KYzVDLvr6PNUOVyNcPzZUX0/p qMZ3YcDk2zw7vFUhRE1RMKf60fkFqhB+xjxnG40CEziUkVXZFuW6pvNOl4aCxpHcFehMRNQP jbnOYcO6rg8b82FzpHeoNw8b0Dy4ecN6n66QmQjbsL6nC4GNkZQd6rx7GNRKM13AzuEUCIep jC8qCBrU93hTUGP67A51Pl4KbBz50bHeyqvmGpsG9TbMdNRe9aVhrlBfBrZZW7IS2Bewu21G c+XAhvU+YD1qtPrygCvUefegRR2Mu7dh3ZU32r+8Det7ujFwMo5K6VhvBYaAxvvXsT4hFOrM HU2YFliUEIRUSYdYj9e1+R2PoFBn7ibImiVyoQQZ4UhtF3b7+dBlvbtd1i1aRBxTSiVGHOoK 4xVBoc7czbjDIAIolHis9MKFuHvsot5PEZVa3QUwaSpHHRgXltR86rI+TJEVSShqrHap5KHA mItp+jzPDLeggkJhat2qCI8SW5YGUCaaYaD6JS+SYyxjM2pc9PXLVDPMyFkglYRSr/HAubp8 cr5ONcMxZ00IqYo7Fsj2CqDMssOxjVQlKAko53z4Qrx6rl4BlFl2uCVjkMRUbbEWRIeqqeUB lEV1GOcdKH3e0EEJanPPGtB1ZaTVSBiz7zaoLzXAORy9qV4E9RrU+VTzUbLBi2OtSN9zbbMw jKMBOtb5ZDlYR6xvUOdgQQxgTErdod6HK1ZGqmN9D1eq8T9qt/3j9u1Yb8YRzN3gGtT3dEtA 61DcjnXmGzm1cQ5G5d2wzna5uqdGu1yRvoebAxrHoexQZ6vcZkAbqfgd66645lkUDer9lkK2 Wb0d6q22OZC1lHXH+oQJcuen8oxafMrAojnlIebcZSjrb13Ud7eLujXOiLFIhFLaDNqzUXEf uqx3U44VJRWpbn3L3HZosTAeJcidnpogq0TNkSBj/bAPtRnzqrPInZ6aICsRgbYxtAowRLF6 hQlyp6cm6KtCosxZMtbn+OlqDz7PM8NN1oLVa9PECHlkiIdPVO9pqh3GVttHJFo/Pkez2q7K 6hL++TLPDrdobas+iJgBWWkk/ONyrl+n2mHm+oWVeoNHuGQnK/w81QojpQTVLiHxEWO0MID5 baoVboPd66FiLm3G0E+/wb9skOCk46LPGyIADtmchLljfUmV6u0buw/vUN8cvUzmccId6326 INZARoP6ni0EOMqq+/FsN6jz2aaQxagaF7BzuCDXMzMmYG5Q3+PFkIwNkHaou+qqsQlcx3qr roJxdFHHep9uPqrvfnm6FerLOrYjqw6DVXt3sO8B50DRGOvboL7HWx+txrrWHeqrvFTa3HHj 6Xaw9+lma/HDBnVdnZZQjsjbH1a3Q72Vt154tL0MOtYnZMCdq+LbPULQ+lhFrf4v65GZX8ff /NZlfTdFVk0EFBkLZD3qObg0ZsCdq7pV1pbmmVC5vgSF6YQ9tz52Wd9PkTW1Dii59Yw/TOZa yKM/dlnvp8gKmaqqAiDHsT4ZLvr6qcv6MOcOYxvDWg2U5qHOTD53+PNUO5wSoraM+0LpKEPi qm1yifE9TbXD3AYJSyYRwTSSbu/Vm2mWHW7fHBRsEyvrR1aO+j8sHfAwyw63dPvqnBZp4/0y lpH4iEsZxfM8O9zOtb7kcxtQEvUwF3FdLOjbXDssWESICNNYnPp1JSO/bNTgtBOizxs3aM1e 1Nj1Z4P6et+pBLLGDS5g1xXWz1Io1pqWC9j7hLOxfGSHOp8wh2QdM7Jjnc9XQyRjJcQF7Bs9 qKdmboDRsc5HTEGtExR2rLsK41Fe4BUNrlhvBSZrj/2OdT7fdqms57thfWnINvc5HjVifnHA G9b3gKM9RNSxzgccq921NlDqYF8VJg5gnPHQsd4nnIs1zLFj3U/4MAv8ygFn70hCotw6KhgP eMP6RBKkM1gyo7EAgVBBSYfj4hc2Fvity/rudlkbg8UlZmQp2lLzz8Zgfeiy3k2RtaVuAwKo KB+5MmtDCdIprBnCEiStZ8sYYSid2YXWeeyy3s+5xBJjJGEVkKMo57pL/KnL+jBFVtVS9ZVI IR+Vvq471s/z7HBjYVt7/ERQn4F56Aq7sLBPU+1wFROAMaOgDjVkcomafJlqhzW2pG3MVBV2 aKKFVyRhohnOhLEVWyhnHaqg8RoVPdEMZ5Hq8kZoE6NHGh766Ou3qWa4PiBK9a5QMtJQNOx1 sv6qkYRzDos+bxQhaSBjYf0O9fVuhYO1QfAG9d27AiGLNYLQwc4rDGTsd7JD/U935Hjdzxdb CxPr+e5g3whC1Umz8jqrrsYgVubsAnY+XqpX3nq6G9Z1fRTDYb34j11FNqjz+WKAZA3wdrAz 9Vi0BW2NB7xhvb+9bKw/2KHO1plCtrZC27HOu1dN2lEl74vt27Dep1u3xWhedqz/+RpL1zao s/JWk2H9fHSsT9xAO1+lE+IGpeULInLSdL5G0791Wd9NkRUTtb7wkjCPMK5O2dsfuqx3c85V KEnJWh/URxlaC8/1Y5f1/ZxzFUDU3Hprj9AaTh2aHrus91NkbVUWFDlzpJHkbSdZP3VZH6bI CpyqlJmEShqqovEabjDTDhOoVNNUShwb0OES5nuaZ4e3cBC0Se4ZEtFQJZhLPOjLPDu89XwB ZGpfnBaxPpusX+fZ4S0uLwytJWyO5agX5bqQ5vM8O9zusBSgojGlGEdK/NwqEGbZ4a3bI1dR E7dQ30gp2B91uAH+lPnR9R4Zm8vGCfz827zmn5uzh9BSPIxJex3snBjcOtsbybML2HeFUoJm I/d9AfvyFy1b1dwSukJdV5cDGrNaN6Tr2kSCRFtG5g71jWk0jdRinbvZwe7qS+a87w52Vl8K aOx+0rHeypvBGHvpWGf1zdbCnB3qS45KNWhG27xDndVDtkGQRvXYwc4rrFbjKGvuxQI3rG/s IGKIxthfx3qrL1qfLx3rrL4AZvVtUF/1bcWkR2Tpj8vboD6RjdIZtTKBeWlPakYFVR0bZexC qf3WhX03SdhYcsvF1Tan4HTCfujC3k0RVopS1RhuTZbOl4v7scv6/nZZW2wjEkJM9VTlhB2H Hrus91NkpYySEmmGkoaGo7rkHX/qsj5MucMxxySRk2CJOMIfusTnPk+1xNLmE8RczXHSI6dv 6eDmiYa4isrEIKlQPmq6vE7WL/PscJsWUxIJZI4FxoYZe9VEzLLD2/QJTZi4zW6OaWSCigvf /zzPDrc7DEhQr6/mw84L68I432aaYW7VlYxSbzGlkdnj/AcNbbzNbT5PCAE0pKMpXC8Igg3r zkCimFuL7GBnCiO3trPGBL4Odl0hBy62/McN6Zyc2SrGjMmZDeq6upJCImNn9451DiHUTVFr bv8F7KzAOSha42sd7KvAGAOAMQxzAfvGsVrmlpEF36DO5iWLLXt+Q/oykIAYNBoP9wJ2VpAU 7L2zNqxzkgEHUmtnoA72VeAiISVr+cuGdVYQtT5Nd6jr6iiwNQK4Q70VuAQt1s5eHewSRqC4 k1f15+2OfyOvhBO0LtJDDKxTGGEX9t0kYUtsLZUbD3t085aGEXZh724XttHNDJqp1Hd1HEul d6GbP3ZZ30+SNbeQCVLUo3q6hbI+dlnvZ1ziPU9Vc4rK5Shz8Zqwyamz0i7rw4xzTVDfHBoL YcSROeyQnEokZlpiUVCCUgqUNNRGyimMMM0QN30VKKpUvzyHz6eF+vplph3Goq2iKUpWkJGh 88nlm/N1qh0GTtyeExlwhFp3Cuc+z7TDmJkoaQQg1qMS+GvColNrpZl2uA21at2VsgzNJof0 Ntp5KI7wNtr5FYmQdNQk9QoLWbHOFJ+Gkm0zJjvW1wdXDQg2BqNjfRkMG3nhe+dyICtttkF9 V6dU/0zr+jrYP3YA1sklF7DvJnL9Qw9HVv64wg72VVyKgY2jNzrWmXpEY1+gDemcW13CUQbe i9TqBvUlHhNoYONc4o51/uZisA4V36DOqtueR9bAZAf7vgmkfuetPe92rLPqxqNS/heqW5G+ a9P6MTAG1TrWV3kxUd0Ua2VOB/tEDaBzVTCjbX8bO1mdwZwOX7drowbQyarbhVVARG2N7OFQ a6/Jqi6pzB+6qHdTzjXWtwy0LObWGnskbdtpGsMu6/vbZW2thhJ//zXEVTm1Vdplvb9dVgpY KCNoQSlDA7sJXdJ7P3VZH2acK2CbO5GxdfUYyVAH8IoZTLTDoiL1jRVLofoPJ4wZzDPDUmLO EktucZKRIdbi1FZpoh0WYSCt17eNFDnKkb0qq1PpwUw73IZsvMoOu3xfn+fZYQwsGmOJaTNR A6FbfGU+/njMYJYdji2bUmNudRaCQ3UW+jo7/MvGDN4GO78qt1+MqaMd68sQJGmDNo0UQQe7 rrB+lQJa6+sb1Hd1IRn5vQ3pnNUqIScrP9XBvvSoSrXeRm75AvaPIMSj2vhr7U+K7wVsvCIc NZy+wkFWrC+NBhSysTF+xzorcDae7oZ0TltOxnE+G9I5dkA5iDXevGPdYwdgTenfsb7rI64e ibVoqIN9rx+DeaRPx3p/e63Rlx3q+23jVstnrcrpYGcVZgyRbJWJHesTP8DOW+GEduBAqWDr l4F4yvABdt7qVlkblwMS63cgCQHGAWHFaZzzLuvdjHMFTqkxHK35SxniXl1yIj92Wd9PucMk osoxc5GjQt21NQfYeavb73CEAlE1E0SOQw38XTj1T13WhxnnqhSlnmjMVd4ykuuq5BQ/mGWH t/gBY0qljSuIesb4wUQ7jKV+bUTaYBE5+rxetcNO45yn2eEYVCiCtJ55lPLRBKqr3KvLN+fr VDvcOsgxU32slbE2TS5vieeZdlhSqxEq9UlfX1BHvO/VO+xim77NtMMFJUeV6mOxHPkTV8/1 lePXf9X4wds451GGoL5zremPO9aXH4gl4FHB74/8wI715QdYQzQ23ulYZ/4CwUbcbkhf9iJx UOPd61jnu6chH83je3H3Nqxz3ACxOTPW4MsO9jUvJbVOscYVdrBv7CBLSGJs67VjnRWYslWB K9JXgUsOWYzZwRewL/1I7cisKnIBu8cQItqmq3Ssc34/hozWvnwd7PwNrlffOj7iAnZW4lhs J7whfZVYUkA0pt1cwM4xhHrt2Rh/7lifGELq3FW6nbvCmKtzmLG0rLqBpi/FhZP8rcv6boas AhyFEHMWEh2JITiNdt5lvbtd1uovZUFQEsk41FbBL4aQOnd1u6yROMZEOeJYK2q/GELq3NXt slKroSlVTM189G28Kis5jXbeZX2YcoehIOeEOcWhiaJ+NQjz7LBKiQq6tZE7elFcpZq9Qgjz zHCBiJqqaUoKhxTQuqkWX+aZ4Vbil1OVtRonTSec2P11nhluYTAmTJigfmOHhh+4XOHnmVa4 miVi1RyJ5Gi059VjRafpB9OscH018TYyiqS+FGHkXF+ZeXH6CMJPG+xsn+z8Ntr57PGN6rDG wGJN/76gndeIOdg98B3svUIKaM0z7GDfFbYWdtYt3LHODFAz3kYKqEGdk8DBmgMOE2IwIzGO epukRabMd29He6sHBj1K/Xy5xA3svUIIOds4yAvYW4GNifQb0j0J3JwC7hzfCMlaWbdDnfPT SwzJrLwXtPMatR6bebTFBe29RgpW7d2x3soL1jKJjnX+vpViXN4O9VZiPBpn92J1FekT26DO qdGUQQWlMJbW6n0kV9WvQII6qzZDWM2tUwADlTw2BNhrKgN1Wm2KsJRSRk6cTtg462OX9f3t srbOHirchpTHdJhStXS48y7r/RRZ63lCYcBchmi16JKY+6mL+jBF1AwJsmghSTwkq0vQ6vNU Qyxb9jESEqWjhhFLCyQm2mFhTfWTo5xlRF29RjvPtMLChaug9XlfyvkY/6/zrPA22rnNnMdM XKq/MCCr02jnaVa4ysqKqapqzhizDjRY8prtPNMMQ+NFSDUmHWkR9tq+WaePbrzNdj5RDAHb PGTrdN0d7M/PZ7FO97ug/ddoJsG/o32TwQOLkazaoc4sBlkbbe9Q3zzhUKyzQxvSPYqQgljn XHxH+3P0pdgjHTvaf41R7fu4o52VuCRjMvgOdVZitlORvICKBDUGO3aoNw8u4bhW+CUTvqP9 ufoEtkyNC9h7hSmoWYkvaGclFjLGtXao95fY/B32rpWoJs1YKdGQPrGE3CmsPIVeT0wtsxEK DfjEfrGE3DmsOcLGasQ4EehRhsbaWELuLNYUYRFyoUyIMjRa1C2YkDuNdauwjWAXVaUEWAoM 5SO7MOyPXdb7KbJS1nqoEYh4pNrHiWH/1GV9mCIrp8KYOALiWOTEpdzn81RTLIK5lPpG3X6d jXZ+mmqJhbneYaDqLuBIAYFbOGGiIa6yUmxT2euH52gY6dJwwkQ7XD8eKXHJSBmHMhO8xjXM ssNb6CTX89TtATVQ2uQTOfk21QxX+yvAIFSEHPISftlowtuE59fEEuDI1FyLJVSwP0+v5nzI C3pBvONo9tfVcEf0bttSjD09NqR3tr9xIuaGdI4ikHWWaEMuiCIQ2FI1L+AFMQQrc/YdvSCG YO3J8x3tTD8aC2J4SkHM2LwGa8elHepNPzJaJ/1sUG/mm0MxTgq5gP2jB4o283wB+68wmk3M Be2svtE4cXxDen991RzFb1BvBSaxPVw2pE/8gDtpxZMy1klTLqcsROBOWU2RNBEg49Zz+HyR kg9d2Ls5wspWZCICY/ycX/CAO2l1q7CNUE8I1Iwq09HsprXBA+6k1QxZVRPHkgAO68/XBg+4 s1YTZM2KpCAZ2s8zBg8m2uE2RxVj4qqAeaR0yC14MNESC2tV2KqvkcpIEzi34MFEQyycU4lJ 6tsejlJmlwYPJtphyDm12cetO9oQy+xSEfY81Q7XI4UiEbfMi9N9X79NtcMtzMeZS6o/HWZ4 /7LRg7dZz6+LH1gr7Xes9/pSsObQX8ALVkj2PdzRztEDPBrW9SJ6UJHO/EWMZgKyQZ3jB2AM C23IBfGDlEa0o6H92Xk4qoS+Rs5XsPcKY8jmqacXtLMCZ/vY2OzfDgXNIxE2qDcFmYyNDjek fwQhHubPXAshNPQChp4H2gVVsPcK69GBdXLIBe3+DTa3/WpQ7yiC7Xwb0Ft9Qc0hwAb1iSFI 565kCtnMuVDJDOl8XPNvXdZ3c2RVUmEEJjpji58PXdi7ScJCTkRYoP7DyLQGtyiCdPbqVmEb 2xxTLjFhjnA05GzttAbp7NUMWUmotfmpix9j6ryiCNLZqwmyctJYqsKq8khWvl8UYaIllios VDOs9R6fLy3/aaolbl1+2sRn5oRHuYVLowgTDbFwpiooYCpw1PdyaRRhoh2O2xgOYgEcmhDk NvF5oh1O9TFRnQ2A4yL467K6TM35NtUOIyNTiVRSHEu/eJv4PBJFeJv4PEyf5UBHnUlfsmcb 2D+7P5p7lTes9/owiHEq6wXszF1Etc7D3KDOHL2a+T115vfaeEvrrNMN6h5BwIHwHy4I/8XQ 8iHs3HxDO68RSihgXeIOdlbfxMYt3KHeAUAxtz9pUPcEZjBqyA71Zr7rkam1+OWC9mfnM5lr EDaw/wqtKf4XsPcX2FpCuUO9v8BkvII71FuF8XCo6suPME+ZuWKIIGjnrXQKq84kpT7+U8nn GxLwWxf23SRho2jkqCnpWA63VwhBO3M1RdiUYwKVSPVmnk7Yj13Y97cL22h1xpJYQBVHenE7 Uc2PXdb7KbLWh2CLIqjU4x06V5dm3J+6rA9TZOXGWmHGNu5iKFziFUKYaIqlCklKEQrF81HN T1MtcZshi61rE6IeNetdGkKYaIiFSxuBnASijrTicgshzLLDVVbNmOo9TpQlHXV/XDoUYaId rhc41xdFfTMjD4VLXDo2fZtqhwEpqgqmeo0dulMtDyH8hACBtSf5hCTqkfCAzXN1XdN5x0un +nm2nWIF3r6yYr6HAy43YuBk9Lk71pdSidXTz9bpDB184r0++jZc2Wr2LaCAWIJae8BfwBPC DPxTtjq1dEjbVm9Q563mUD+fxp3esGe90ikkazpyx/pydkWCNSt+h551oyEYM+c3pPN1hiDF mjXfwefd53KUT/xyoyvU/TqnZMuR2KE+FHTpvEd54VtclvPjM30yLVw6GfFyAePkYSncUnKz lhN2u/jQZb2bIiuWKKT1Q84y1p3GJe/tY5f1/aqL9dgXcD9lsxOiNP6d0mGUf+Fmf+qyPtwu awyqmiPUF2y9WnFk9Ke6MD+fV1usp3kWK9aPUNZcf6NWEVOt1gDN5mKxvsyzWI1SbPMaCkhs /f3P2MdlrcV6nmextkGvSpxREBnKSAzCa9DrTIvV5jFji7lwHBnM/EqLtZzTXJQWfd5Br85s 3oBPUsJRov6PT/4K9M254+rLWbuG7ljvhKxgz2kLztxmCcnasmSH+p6tBDAy7zvU+WRzUKOj 3rG+KdGlZddbD7dBvRW3OrpmxW1Y5+PFkK1xiQvYWXnz0QiXF8dbkb6nSyFbex10rC+N1TSy HGU/XNHeinU+3MPWxC8Ol72/uRTQSrZ2rLPqtinf5imuO9j5dI1VXMW7hIswENro3R3qrLa5 BDjKqPzxZHesC/+c487m1J+3lz2TFlCmmOVoGs3SDOhd1ne3y9rIFEopx8KUjnMA1pEpH7qs d1NkZYy59TvORDrSa8OHJPvYZX0/5Q5jG/dJKWIpIxP1nJjmxy7r/ZRzJc6CmEtryjAyKrE4 tVDZZX2YY5tigpSRiuZ8vhz+z/PscCtYyK1kAREIAc/X2flpqiFuLGvRggyxDBlil0v8Zaoh llQ/rlCNE/DRM2wdp/x1nh1uokIpUXICrf8dsU0usj5PtcOxpbOX1jWmvilGztWpEfs0O9wC boUVqrpKG2Pz058Sv2yo4KRTXM8bKIAcxMr7dKyv450CFCNptkFdV4cZg7H/zA51P1tzd4gd 67o+VTth27HOpwsBrK19L2DfkAFwiPYWDBvW+4iT1bx0rPMRF/uE6AvYW4lZjOnSHet7wiWg dYxrx/oykJjbvTJr8Q72PWIasNO0xE4fTkq6psO+wQ0kDWysjetY79OtXqv5dBvW/St81DX5 ykdYnQMISFKvlLEuZ8f6BBCgE1cwoTi2tETfnOqvowqkhdPXfuuyvrtd1sZbaRKsB1W/U2XI 6XfhrT50We+mnCtySdsw14JHk7qX5srvsr6fcq6lOjjCmBkhyYCwPoX7j13W+ynnGrXJGTG2 scSnK9z/1GV9mHOHq8sA9RZriUd9Qhfe4c/z7HC9w0liiaCJosjQxE+XacRPs+1wIi7VEnM8 qitdGj+YZYdb0BpFKCK2QQJ0usY4X6fa4frETdhmiLPkI+LsqqxOk1yn2uHqjJd6e3OksVkY XgGEWXZ4a4wDAsqcWWVo8vJbscFQBOG0k1zPG0PAGJSN+9axvh542rr32jzwHeu6vpSpdUmx He6O9T5fIiPBskGdT5cDHtUwvjjdDet7ulSsfRh2qG8EASGItQl2xzofbwpRrexoBzurb2sB YBzVu2N91RcCGAuudqjv+aIEPiIMfjzeHetLQLYjQyuBewH7bmG1GmpsDbRBnRW4lcpaCfAO dlfgkoxBwAvY+wtczDq8Y92VWKxXcMc6KzFxoKMa7Rdf4Q3rE0XAzl7h7d4wpdaJHUQZx6Z0 ubBXv3VZ390u6842F0kCHKsbNtK/woVt/tBlvZsiqxZVTS11g2mo1bGLrB+7rO+n3OGU2kS9 mNo84tORzY9d1Pspx5oktiECBeuPkfb6PmTzpy7rw5RjjURCHJFIRwou/KoQZpnhRqwn0AJc hCGXATvsFkSYaIbbOO1qmOqDrcQRrtmpCftMK1y2vuSZSk58VG+5zgp/nWqFMUXglOo1jmNx a68YwlQzLKVaJwXEaofPpq7f5pnhdodjlbPUNyJlHipofIshjMQQzjnH9bzxg6ShfjSNa2tQ X99WNByWif7o2+5Y390rjTIxEqQXsPf5Hs4Df3m+Fep8vhzqU9x4vhvW+XwpJDLSyzvWN4LQ zszIrDSk8+FSfaVaBzBvWOfDhWrQbMGrjnWmRkNOxuDVBnU/XbQOetixzrSjtk78xv3bsb7H y3VPjJZ5g7pbZj7KEb5imSvW+bvWosn200Xv9Ulo3Vps69uxzucLoYC1tqmDnRVYpCql0T7v WJ+4QeqEVZrRNkMhsiQW0jLUvt6rf1HqjNUEYauf3zxgzCnCSP96t/5FqVNWt8raWFcgTBIz JMXzpUd+7LK+n3KujbGKgpRbycXIuXpFDlKnrGbc4VyEibWUePQ2W8dEfuqiPkxS15gLp1xi PdzTMcyfp9phwowxMQCzjMyqdQscTDTDJW7t8gpIkqOeqOvu8Jd5ZrjdYQWG1KLVOR8lAi6N HEw0w9JGLNR7DHrYyXiduj5PtcKyVUYViZjzSPd/r0kHM81wViSJURO03o9v7YvwZwQO6rvL RtA3oGvo4G2eal/ZT5kfRygBrG7wBezqqNdXdQsKG1fYwSfd7RxSMiaj7lBfyia1+gQjZbNj J5D9P2WeKiGHfPSOfXGrN6zvpU4QjNznDj3thaZszF3eob4MGlD9U8lK8nXwSbeaQIJm44CT Het7pSEHJWMz+B170p3OLYxuttJTvjZDtHD9MljrBTaoDylMnYygRTNV9wW8u7aAcYZABRRS qYc71DHVib380IW9myJsfTPFAoysmc/XzPljl/X9qpv12Bdwf/tmt+zGus2Y05YJd75uS5+6 rA+3y0ohSYIqLsckh4HKa7JSciEpPq82WU9TTZZogrrRXCClkQm2bunQEy0WQIlYn+yEJEcz 1a7K6tIC6etqi/U8z2K1b6GUJCVDlIRHmWprG53MMlkx1DVjidCCluWo7d91Wf+YVOPbUNXT 5Ck37k3JlgzSsc7ryyFbmxlfwL4rLBKIjQ70jnVdH1df0rh/O9SXHAzZOGJwQ/rmckFuA7Ns LM+O9c1SbgpZX/12lr2BndWXAokxkf8Cdl9hOXRQr6ywgb0V2NgrmOd0Ch5SX2uZQZpTZDDC aAkGtY4I7VhnalOrTTPS9TvWeX0cIlip4Q3rur5cP/dktC0d6624RuJ6Q3p/d48KuV9+d8uE cx3qjx6KsbZqQ/oQ0bmzOnkGD8wQSUUT60jfS7/s5NwZpBnCSuZSqFRHOo9ksfqR3rlTSLcL q7m+siSCSoxlpAGGepHeuVNIt8raUrFLmziaIcsQv+/UMfyxy3o/RdbEhVsQVxKONEpw6kP0 qcv6MOMOM2obJVtiQdSjIRrXhGWv7ugTLXGjtwvFBLkleJ6N3n6aaohFWDmnogXKUM6uF5U/ yw63dpQMJdU3laY40hwdosuY669z7XDLwgaEKi+er9TpeaodrgcbIwtGjXy+b863mXY4Yq5/ USrtkcgjhvh1dviXjRq8zVd9Rcygvg7MrGPFuscMDge7XAkZVKwvL4DVp0bjvbuAfZmVcNir 8EWmWkW6s/IKxubKO9Z1fQgtsda2ex3rHTXgINbhkRewOyePxRjNvYB9FaSUUA6fID/qSAc7 q7BkY1RjhzrTj+nIj36Za4rO3dGBYshgHP5xATsz8xJKsQb+Oth3hSIBjIUSG9T3C1xigGJU jwvYW33Bal42qLP6orW4a4c6K7CWeqOMJUcXsE8UgTt3xROI9YISmbQQ61GrwbVRBO7k1Qxh FSNUS8YF8SjktzaKwJ29miAsI6AUKqiQj2YoTSxNHo8icGevbpV1mydbjwiQBOJRsHRte3Tu 7NXt5xpRhRK00X6aeWRApYusn7qsDzNkZc4tlRop1ys80h+dvbL0J1piUS5VVqmuSB7qQewV RZhliNsoJcyimglSHLLD4FJp8mWeHa6yxtZ4KZNgGWotDeBVEDDRDoM2qrnV1NSvzukqiJ7n 2uE28U2lJOL6mhgwTi52+NtMO6wl5zZhlZQxDbU5eas9GIoivM1YfVUcgYy9RjvWfX3WGbAd 68ti5JbTaGOaO9aZw6BsixJtSF+WXkI66pX5I0m/QX35lQhBzAxLB/tHEVDNhTk72D2KICNR BPGOIhCpfYzkBeyswjnZAqkb0pkED3Q03eYFBd6gviQkYQpGCnKHukcQpFivXgc7rzC3uJ65 8Qs6ZxkwxpYZb43i72Dv76/58+vcBV8DmOn5BvVVXUzURrYYZ9N2sE/8QDprJTMS85F5c/ih HH3H18YPpNNWM4RN2DIHtWXBHpU0LR2uKp22ul1WVlLVGKEAHxYgXaVeXejIj13W97fL2mir 3MY0tkGycaT1vRNt9dhlvZ8hawZqFRfEmWWkRzpkFzryU5f1YYasFEljyViyxKNBTFdlJa/p qhMNsQjFdq5SoP7thOGDiXa4hfmySGytw48+sOs6TH+ZaYdbXF5iiZRiy9E/Wwe0r/PscPu+ toBQLq387TCza9339XmeHW6hTarXtwBsog5UXLBLeP7bPDscQ30tYT1Z1pjxMGX0mqzyOtv0 q4YP3sarjjdiVjJzezvYd4WpevxkjR50sC+BwRgOQ4I/8hc71pm+SMYM0g3pS2BwCmgkHzvW N7xRsL0/jAxGB/sHEKzkcsf6hw/sAY4d7LpCQQlZbRRfx7rzj0YTvUNdV6cpiJH/3qG+HGTi emDmOaYb1j+AYC1iu4CdFVhbeqlRfzesr/pyGy1jW1/HOqsvqrUIsCJ9v285KBojCB3rrL7a ciWtU0862CeEoJ250iklCPVhLSWlCOccs6qdupogrDKDxFRKgsOOhktDCNqpq1tlhRBLdegK QWyxhKEsX68xq9qpqwmyYowpKcfYctXPGELQTl3dfodztTKSADSl+twaCIO5hRC0U1e3nytm ylVdJYlAGmmyhi706+ephliUsfWvZ4pw1M15aQhhoh2udolSrjqbYjzqzrt0zuo8OwzUZslG 0URZR76v4BVCmGWHtxC9FEyYY2Y63wzo55l2uP4e0IYfJCTmkax88AohzLPD9WkYQQgBuYzM z4X0B61A+GmDVu2TVt9GrS4JcPyUsXIgrbWxsR/OjvWlygVTqF8x6wI38En3Ogc0CrIhfWsG Ah59NV+2ZEgT1vZzRqzWG4AhZSMz+x3tfaVjIDZy29/Rp73UyVqDsEOdmbSQyBYl2pAn3WRg 5QDFmvR8QTsHNTUFMI6yuYBPut/V/prb5+CM0OfYlUZjA7sN6UMLl85GlFWDVkunCF4uYNyV VFDUlCNGGZuH6dUtpnSOYIqwCWJ1KCkjnW+Q3scu6/tVN+uxL+D+9s3eyOLqtmsqCDDS1cRv 0GrpjvsEWRMVAqSCOMZR+LTm+bzaZD1NNVlSX7IqbUB0jiPNnt26s0+0WML1FyBgvVxlQIt8 ZP262mI9z7NYe+e0kloXpqxphC73G7Q6y2Q1YXNiEIUoHEdKKV4r7OnJxrdRq6fJWd7It/pW M7MGO9qfrINkdJ2+oxcQirbMpI71zasOaC4L36DONGG2esY71DevK4hx1uWG9M1Y3q87G1OC v6P9qcloTVv+jl6wxgGKd0c7K3GyZgfvUGclZmtpyQ715bdaOYGNRdyQ3iQnB2vn/gvYn4al bO0/f0F7r7ENzLVGQC5obxW2NhnZod7fYesR71BvFdaj/MAXKlyRLhQ1x53vqT8neMWUM7bs wHQYlFmaubwL+26SsIgl1ZemyEjSpxsbvst6N0nW2DK0SyKIp6TDd2Hf3y5s635SBUWKSCRD qVVeI1h3We+nyJooATDVQ2U+X6P4T13Whymy5tY8PZNiLjJUVuGSHvh5qiVu04M1cqKY4lHs eWXq8kxDXGWV1kcBgNLIzGQvkn+mIRbOqV5jIox4vtG6X6fa4UiNx4lUvzlyvg/s81Q7HFVK zJoz89j31WkE60w7jK3zv3CbDz32fX1dtPeXjSa8jWB9VdLv0QiZq1m/4tzis9GfORmP9jt6 QbQjG9t4dLDrCnPIR3W1L9LYKtKZwYBsi8JsSOc4AhVbht2GdI8jYJBsTx/e0f4cPQ+o7452 XiOU1lnHusaOdlZgOaygfqHBDepdM2COBbpnyaK5uQ26t7ZpAyODRqt6XNDea2yTkY1TJL6j vdcIobC1kdYOdlZgLsZj3qHe32BrIvmUPPIx9SVjBHWH+sQQoDNXMCWGgKm0hOAscj6q+bcu 7LtJwiZopegYsxwl36wNIkDnrmYIK1JvJEAseNjiam0QATp5dauw2wRWVeIIrep+qIW60wTW Xdb7KbKmnLG5w4niCP8KkZyCCNDJqxmyJoSEmhMcDglbmr4/0xSLxKgJGxGLI3MA3IIIEy2x CCbKUKg+1vh02fNfphpi4VgYlFsL9aNmiEuDCBPtMHBLSMit4xYMpa47TWCdaYcBJFGLIRQ8 4mnWBhEm2mFQrM8mxQLJ41x/2SDC2wTW17B8FNjePGQDe68Qq89vywm/gP1XyNHc32QDO1MY BOYGDw3qTNUrGssldqjz6lIyJtPv0AWhBHOf2e9of5oeorkkoaP918j2uqeO9o4FopHM3aHO ilIO26e+TPrPM9R4jI2kZO0XvUH9wwkyUJWwo/1T/oHt4YQd7b3GFOiI2blaOVG8lTipcX07 1FmJxRw2lxlh8zEVTubFpSmLM4QTsHNYOINhz9XuUMKY41hvEa9wAnYSa4awIlk1SqlaGIcY AK9wAnYWa8rJtrF4IInb1MPTCfuxC/v+dmG3DjmQALAkoaPxEUvbqe+y3k+RlTgKSaN2eKRn S33eOoUTsNNYM2QliFBiTpLyUE2CS+jk81RTLEItlpAgxyHr5BZOmGiJhatlUuWMhUYO1i2c MNEQi2DhrICI6Si3aGk4YZYd3lvh1M8OK5Vqkc/30XmeZ4ibsBgxt8ZsbQztyCV26R3/baoh RgEtMalQGcs6eV1c91eNJ7yNZH1FSUIUe+ugHb0g4R+tBMEF7R9PIGPH/AvYmcOoTwVrb93i G+vAIGgMBO5Q59WhtQX0Dl0QTcjGBkwX8AKe3tw5aAd7r1DrH2ru8tbRbyTkfwwIZmsPsIp0 JyHBHOZoUP+Uf0WrflzQ/nGEZM056GDvFW7PbHtRQgV7f4GNVYsb0ll9mc0a0qDeCoxgrLzb oT5xhNTJqzQljpBZJeeS+ISZ+r91Yd/NEVaKiMb6Ui8sQ03KveIIqdNXU4TV+uoqEEtOYx3Z veIIqfNXtwq7pU3GVFCLMIyliHrFEVKnrybISkJSknB9DY60wPGLI6ROX02QNWbOWRkzlHi+ /iGfp5rirdF9JowtYf90qfpPUy2x1I9NomqEFcoI3+wWR5hoiKX15VKNTKmk08VMvs6zwxu1 roiRUaCNZj0btf48zw5v56otfs1U9HC627pz/TbPDldZq4BK2Ia802Grz6uyvq7H3PIwwk8I ErCNBeUJFOjIKFib3+q6pvOOgK3fK1tApQFvX1mZOB54hNKIuTqzVl6og3/H0sYAxSztDp5A tdsHov6cGZNVkmzlXi7gcx3yCJMDAKGQNR+5g88l7sDhFgkYbZTkDj2XpCMHWzSA1VZ1rA9J R90zpEUjMvcFvFu1gA99AXfXFjD8/sxZhGOW1uV4pGnqK9+f41wWdR9qzWY/9gXcr1rAp76A h9tPG6qOCjIUzDnTSPIouJB5n1er9tNq1f4yVbUxaetNUaozzUeDYK6qtstpf12t2s+rVfvb PNVupEkbQZBEiLPiz0+WXk4kLMpHPO/IRXcX+ic8rwmDtU/nDvXNSMgS2Jp3cgGfdael5eHb dnqDOud+QFAwNnPYsa7EwchGl3A0d+HHfW5I521Ogcx5uB181gvNgY05kzvUN+GlmYN8FFW+ Yjoq9qwbnUOytrPtWOdLTfXLYO3F0cFn3Wtug32tl7pCnS91273DEN21rWavTK7cPcm8iiTK 3ZN8uYBhr7096KF+5rLyUGtQcOFoPnRZ72bIGhMXSDnHqOWoumFhfevHLuv7VRfrsS/g/vbN bj5jKxGv16QVYh5lsl71GcUp4Sl3/3iKrAIsiamUkkYSY1xk/bzaYj3NtFiRlXKhzCg6NiXQ ZbO/TLVYlDghx/oyjmUok87FYn1dbbGep1osrsZKiJiUREY6DLt8Cr/Ns1hbJ9rEkrMopBFC 761j6R9j7Nkfgc/TEtjaT61jfatkMgY+6lT+Yx3Kjj3pThcIyVpy27G+O03teK1Vtx18Vk6v RPNc9h3qfKlLKGitrurgs17r2FoeWXe6Qn0JkPruq58FIxl2AZ90q1WCGE3hDnW2HxzAWnJ+ AZ91p7E+7ow7vUGdLzVpSGBt39DBPqwedx+ZV7F63H3klwsYf94nVc31RxkZqeFUgPWhi3o3 RVRUri5bBi40VljnMgPnY5f1/ap79dgXcH/7ZlcXWXPbZcW62Ueh6nWFQp+6qA9T7hWBUs4p Qjy0p2ubIa61V0/z7NWWYMQMUVK9V5RG0sm8KgtnGawmK0HRUkqmWIaSqVz4y6+rDdbzTIOl LUGxOnt1v+tXYmSzXcrpv82zWK2MkxSlxEgFYSjd+nXW+Zfl9E47heiPwOoBagDrmIkL2NVb TFla61XjUO0OPutuJwx0NLLsx83esb57TSXAUX75j1u9Y8/K67Xti/kgiHdlqyvW+Vpz0Gxk 9i7gs15rLEHFOrq9g32JkJRjQGPyZseedrMxqHW++451vtiNEDmgQV7s9IY9606nFHI2ttXb sc6XmiQwGmNyF7APuyfdW5ZV7J50b/nlAsbz2CLVX/V7FwdnjbhQXh+6rHe3y9qcGm6t3xAp CeQhHsarIZp0d3nNzXrsC7ifstt1r7lUfzm3cq+RpD0XHuZTl/VhihZVNSopRQaqXvPpLtbn 1SbraZ7JaqXgrVulkmSpVmiEh3HJrfoy1WRpY2Ckmqsq7Pkm1X9dbbGe51mspsXKWBU4YhE+ X6jr2zyLtc17Ya5+QCxcDhuFzDRZvyrDd865IH8Ido/VXBrasb6+YsEActC+4kf/Zceedael BLC2wb6A3fdaD/tNXtnsBj4tuycS0DxWY8P6brbm6jfa1texp73YrRjRfLF3sDMNotI6pBhv dgefdrtzyOZRRRvW92LXE87WUScX8Gn3OrYIhvVq72Dvq50CW8nUHevD72l3lnUVv6fdWX65 gPHUowJt4mzMicfmsLr0iv/QZb27XdbmLNe3B1AC2vKtzuYsf+yyvl91sR77Au7nbHZK1VsG 0AKFBxxIN3pPu7M8Q1ahXOVNSTkddXFel6v4ebXFeppqseomR9U25EJPODn6y1SLxREzEAtR LkPd8l2ozK+rLdbzVItFpX4dgGOs/zQ0csLlU/htqsUSJk2Ebf66OoycOD27Z289PNI6P0Yb i9aArvzeWwP9777VvJsxUjlFXHXQ5tp07O9W1hTi0WDxH524hnRl3X5OWRxh+5gYD3fDnutw h5z0AMmYpLxDzyXqULUjBT2agPii3HHDnkvWsYLgcNgF5kU5cIP6MC+l+zFlFfNSuh+zZgEf +gLuri3gFSFebGWbCqnAUabf2nSn0r2LNbv92Bdwv2oBn/oCHm4/7la8GutjGxlS1KMs/IUT MD+vVu6n1cr9ZapyS1Ju5aTttM9Y+LdWtZ9Xq/a3eaqtgQrEDLG0GvyR1m1Kb9V4Qz7zW8/8 n+o2USAydka5gF3jv6plG3RpW2EHn3S3U0jJ2MVqh7ruNAa1xtl36FlzdZSq1xutRM+Gdd3o QlodVVtfqg163uus1iSYDeqbytBIHhvhuiFPuskbqwG2jMWO9bXP9c/M0VYd2LEn3el6R8Fu nWGGdR67zlps+X0b0oUbkri7j/XnGm5oX8C7awsYp2aUIEIRklQf9aejZj50Ye9uF7Y12WYg jpRJytBYAJ8m2x+7rO9X3azHvoD7KZsNqW5za3+kQ53ynWpYPnVZH+bIKooJMtZ7NSSqE+G1 2GI9TbVYwpI1lsSJ0tGkl5VdtaYZrDaQkilHlHq9AEb6tRWXmuivqw3W8zyDtXWairGgZq42 K44wmS65dd+mGqyIuVRBSSSXof6SbzV3QzzeW6f8n8ri5QESL3tzeIKBrB21LuCT7nVqszWs XmKDuu40SD1da6frC/i8PB6Gksz3egf7XmyCkMHIgV3A573YxtZDG9Kb/IjJqHU79KSb3Bgw jPZ8pop1Z/OSsV9gx550p1PrHG69zjiBMx2afRlLYOuFvoB9GD3o/jGsYvSg+8cvF/AKRq86 x7E+7pGOAohrCT3o/vEEWZmoVMMHyJrO14DnY5f1/aqL9dgXcH/7ZjeSi6IWEIYiY+VQXoQe dP/49osVAZi5PhULs45NYHBi9NZarKepFqtxENXUS5s0etRGZSmjN9FiEYlGjRRRRpodFafR l4sN1vNUgxWTAtaLlZBGShqdvoTfZhosRo1ZMEOsF4wG4nj8Oqb4lyX03trk/0xHMWPQaGUW OtiXagKEAEeW+0cfpoNPutstY8Kc+TYj8W3EkWUO6Wic/Y+u7I49M6GXxZhjcwH7puYBBzUu sGNPe6ULGxn3HerMgKQYcrG2Ot+wJ91oiMhBjgY9veBydrBzvilUz8LYduoCPulut8xj87Vu UGeeWiFgtPGOHetD62F3knEVrYfdSX65gGHHUTVChJQ4ZTna63XZCR+6rHczZFVorUKKZESB kS5H6pJP9bHL+n7VxXrsC7i/fbNbtSaljCkBRx4bq+qy2Z+6rA8zLlbKTESthXnjjQeUKLnw xZ9XW6yneRarWfn6KG9bXQ0XjmQWowv98mWqxaKI9VpBAcw4VhjpxOuttVjP8yzWNj2ljSDQ raPAyPhLP2Jvnslq2a4toQbqt7CMJOjL63LWf1Vi7607/s9yXkqkkMG2vx3rnM6UQyIjr3sB n3SvUUOONtZsh7ruNCKGzFbOsYPPTOtxHKD1Gtg9T6+gOZNwB5/1Ygc1ziHYkM60Xn3/GXvJ N+RJt1i1JREaCbML2PlCa2A2J57u4JPudr2maI++4Aw7OHKluVSDRbZuAh3rQ+ml7iCnVZRe 6g7yywUM+zFVfxiJW8XRUCGb08DLXdS7KaKWXHIUEU4qOsQyOXWA24V9v+piPfYF3M/YbYiA SjFVAw35yFxe320nSi91//h2WWNUFMiSctH636F+c06c3lqT9TTVZEkGkkSk8fDJszRTb5bJ 2rLHCiKTQMkjfcudLNbX1RbreabFiqUgs1R3r6UXl6HtdqL0Zpms1GbSRcysoJyPJsxfDULA 6yzW6Sm9n9YS394T/60p/iLCcd7dGCoYxdbMyObeXMC/W2lTiGTMHtmhrpTbT5o5ByXwUdTx xQHv4HMd8Fhr/KjmKlY92QyAsUG7GDLa+q5dwOeSdvBY0TjctCF9CBjq3gytImCoezNrFvCh L+Du2gLGaRHRXFKm+h88ehKspUWoOxlrdvuxL+B+1QI+9QU83H7cWwUltmGFWiId5bYvrKD8 vFq5n1Yr95epyi2cEooiZYahjE0XsuTrat1+Xq3b3+bpdjPlqWAmTlKqdv/8/NzTO/VvnfF/ h7k6u6+LxqyG72jXKPD2p9a3/cAaG/qkO9420DrnfYP6ZuwETcZ0ooY8a65OvQQxEJpn0He0 97WOAbO1Pc4Ffd5rLTY3fUM61yuFEs19tRr0pJsMrClkMRbhdbDvpW5/KKsxufI7+qT73Qyw 3VT7d8oXs6mWCabaQhbl7k/mVWRR7v7kywWMP/A1QQLSKImPKMi1jbVy912nCNuKdgoVIUin zNfJ3Xldc7Ue+wLub9/trVV+YY4ci8SRcfB+nbVy95MnyIo5K9bHVb1bI+MCIbpkvX1ebbOe ptos4ZKIGOprlo/qApbm60w0WcJSWCQqyyFJsJRuW2uxnudZrO37wKREWaA6IacswZtosoAA KGHVoMNJ1TPN8y9L7b01y//JxF62MyA72p/YEx7Iyqngk+431u+RsfJqh/rudChHPQJfFCxV 5HlpPShtbIs9y6fMaBM2ukI5+mhcW2EFn/RKtwb4xoZsDenNfsRo1rcGPekmbxRYNAYELmBv Sg9DJmMV3nf0Sfe77p9NORvQ90pX05uN38KG9CH0uDvHvIrQ4+4cv1zAaziu3NqZJyrlhP2B P3Rh7+YIK9yGfEpps/OGco+8CD3u7vGaq/XYF3B/+243kosFBRRi0qOZ1wtJrk9d1ocpsibg jFGJYh6b8+lF6K21WU9TbZYw132WHDnnEZvlRuhNNFnCUauJZkxlqGbYjdBba7Gep1qsVoym uX4SNclQIrJLF8BvUy1WJE7Y4lv5cCrV2/DLCXzeW6/8n8voYSBrX/HvaG9GDwKgNf3jgj7p jre8CVuuzYZ0ZvTU7CzqDGfxJzJ6aKxlu4C9GT0N6bCrxssl7ujTXulinzBZ5ozjG2usddT+ +eWt5gmU48/i9DBEYwXuBezN6bVh80aauoNPutvN9toE2ZDuF9o4OiZMaWJnYPSke8eyitGT 7h2/XMArGD0gTVG0ujPnq6b80GW9myRrUsXqtCXIR7ZlLaEn3T1ec7Me+wLub9/t5h6XUl/Q gFnS2M3yapIv3T2eIGtkkkIKTEAj7bTcqlTXmqynqSZLOCcQxdzm9o00AfQi9CaarI285JhS lXao4aEXobfWYj3Ps1hbwKe0JNsUU5ajUpy1GXozTVapviAi0uAIk7cEvRFC761H/k8k86D6 13Yyb0f7k3nxKGf/2hIr+KT7XV2/o1kaL51EmOAkDlF5wtbi5g16ajKvFGNn9A72J/OiOd3q gj7vpTa3yPfvkG/UN5ijbz+RyLMOGP2O9qfyaIBt3NEn3XEMUowfxR3qfa0lGasWdqgPpafd P9ZVlJ52//jlAl5BcymXGKW1Yh5pq+PH6Wl3kKcIixkSMiuVMerFi9PT7iGvuVqPfQH3t+92 S9KLyCkyJaKxqlsvTk+7gzxDVuWMpFWLjh47a3P01pqsp6kmq/qZ7UZFSeVwGNdSSm+ixRKm uPVEyFWRztjjbq3Bep5nsNrngZRy4qhIcjSbZ90I6G/zDFYbdw1KqQhwqpr087ni5ZTez+iA j7aR7BXnStgZCQHXNZ23+hiaxtt2rCFnOHL/fzrxU3p7Y27zua0j0Tr49ystQ0hkLMe+gF2J vp/jz9dzA7ZmnHXwuQ55qCqVRwgMnkVhLNNgCNnaIe0CPpe0Q4dLJSjaPmYd60P/lO5LlVX0 T+m+1JoFfOgLuLu2gPE3d0EsEDUTjA2Xc6NkSvdw1uz2Y1/A/aoFfOoLeLj9uFsiQW7FddoK z8aSJrxyn9Yq99Nq5f4yT7n3QjDN9bubC6bzNbH6ulq3n1fr9rd5ul1NeW7jQTUBU0kjJfCF f5+UwqIsofOW/f0qrnT1FYOojfzp2N+vrJlDsQ4suIB//450ojZH1HrEG/ZcRzw0B636ihyN A+527LmEHTnYpCGykYy8gM8l7dDRVgnYOIizY12caI37O7v+XONE7wt4t2oBH/oC7q4tYPyd nbRAihApjkwNd/Ohd1nfr9rsx76A+1UL+NQX8HD7abfQXY6FKZO2jPyR0J1LmPLzat1+Wq3b X+bpdjvtEgtBS3aMJQ90U/E57a+rdft5tW5/m6rbpPWgS6knzWmk1KbkNx/6d19p86v4zxQx QDbSGBfw71baJBroSJd/fILv2D+A/1waIWiTeYOe63iHXCzNobpONll37LmEHTrWFNJhiuuL g93B55J26Gil1AeYcc7ejvXxnqG/sGGV9wz9hb1mAR/6Au6uLWA8xxYhQeb6SS2HrbGuvrnE yXuG/sJes9mPfQH3qxbwqS/g4fbT3hpxomQtKeZ4NApjYVXC59W6/bRat7/M1W0FEmWqDhXF gfQSr/z5xbr9vFq3v03V7diGKZaMEOEonPFLNZ61v4pGvNQYjU5qBb4lmf9Snj2wQqjaZ66O 3tG/X3lDfUlYC5Qb9Pfv2QOLBrVOEevgcx3w4JSYaJ4SE08m6NCxEgYxt7u+oM8l7+DBsrVx 9gb18eyxv/5xlWeP/fW/ZgEf+gLuri3gFfX+XA1QEkHCo9lqawPj2J//a3b7sS/gftUCPvUF PNx+3Nvzn7RUH4Dy4ZTLhaf9ebVyP61W7i9TlbtqdUycJGKsXt8JXfu1uv28Wre/TdXtVKJC ZNbD9Ofrqk1/TM/+Lbf8D+tBlxjgKIvvxTN8B/9+pQ2txbrVf8YZtcrr/WeVAGqf77qjz3XE g70Jj7r0vDziOGXIyCLNzW2ou7F/awefS9rB3nzF7D83qI//nPoTO63yn1N/Yq9ZwIe+gLtr C3iF/4w5VneqlCTpjMXZu7DvV+32Y1/A/aoFfOoLeJhy3Cqs0NrZq8JRH+qlieVrlftptXJ/ marcoli1GpQZ8tHcvaX+81rdfl6t29/m6jYBIictWH2Gn3/av6oD/ZZYvvYJrhDI2v/qO/r3 K29gNvYgbMg/gvMsGiTbMnIv4HMd72hbf3NX/3OJORZ6pmBs9NWx55J10G3OVpWtSB+nmfq7 mlY5zdTf1WsW8KEv4O7aAl7hNCfV6jWjYDz6Eq11mqk/rNfs9mNfwP2qBXzqC3i4/bghRM1Q nahC1JqSj5y2l9O8VrmfViv3l6nKLaKEmlPrEH7GfuyLdft5tW5/m6rbOZXMmqie9xj9+Qet xv5p+eT2hPK3jPJfzKVvgw4ZrZGmC/r3K2/Qo9ETL30++gNUiu9T/9Q8mrOjz3XAg069tffB Dj2XqGO5LDmIsbHcBXwuaYcONgdWo+5uUB/nPvf3f17l3Of+/l+zgA99AXfXFjDu3Ev19JJy QcpH3Nxa5z53B2DNbj/2BdyvWsCnvoCH24+7ZZQrAQlzzjpWUOrUrnyxcj+tVu4vU5W7TYXM iQoLp/LzZ2KNO/drdft5tW5/m6fbGnLLdEGMBHg4FenaYWt+nW6f3rl/Syn/I7vQSsagaQf/ fqUNItZ044r8gzjQ9YM14EA39LkOeDTz2BxCLb/fZmt7foq19/539LnkHTzYo5jKy4Mlp9g4 9xc2r3Kfub+w1yzgQ1/A3bUFvCI2DkkkE0k5bDWw1n3m/sRes9uPfQH3qxbwqS/g4fbjbr3W UkatmprLOad9LVbup9XK/WWqcgtnZKY2sXzIo3Jzn9fq9vNq3f42T7e3KQSJkubMJaWhTIjX 5b38qu7zW0L5Wtc51Ue1cQ7UBfz7lbYuP1l7t+3YP4L7jBrAyBjs2HMd8JCHBSGh8TZv0HOJ OhZ7rg9QsrIiF/S55B082nzUvfrl0Vaoj/ss/YUtq9xn6S/sNQv40Bdwd20Br3GfI1f3GUCA Tuk+S39ir9ntx76A+1UL+NQX8DDnuGMhjhIjlzxy3G712GuV+2m1cn+ZqtzCrCT1EalQjsaJ LHWf1+r282rd/jZPtzdqTOovKJTL2Gj0M0Wf8Ye3TsX9x98bIrVaqGMf+3BVEJFuWdbMP/Fy NP/8r//yl//69//6r//y5//2p3ZF/vz3v/3P/s/vR/r3P//bf/nr3//0b3/+l//y1z/9+S9/ +be//u1v//gPT//nX//6dwj/e/7P/Z/+t6ZZ//Aff8f/9q//9qe/1f/516v/8k/1avzbf/8f L84//sM/xvAfPhT99bff53//19vv8o//8L9k+ad/0j83qe2/P5h/9/9j+zX4uw+s/q8s/ywb 6/Kfru7Zfzo+m//p//m3//ESXK5Su1x/+dNf/9//u51fxf+t/cFdrf9W/+Wf//K3dpD//i// 6V//8t///X/95V//+f/5v6rQ9er9y9/rz//1/wNQSwcIZLvSnUERAQD25xAAUEsBAhQAFAAA CAAABb6TUYVsOYouAAAALgAAAAgAAAAAAAAAAAAAAAAAAAAAAG1pbWV0eXBlUEsBAhQAFAAA CAAABb6TUUzCxmrSEQAA0hEAABgAAAAAAAAAAAAAAAAAVAAAAFRodW1ibmFpbHMvdGh1bWJu YWlsLnBuZ1BLAQIUABQACAgIAAW+k1FdRprFxgIAAEgOAAAMAAAAAAAAAAAAAAAAAFwSAABz ZXR0aW5ncy54bWxQSwECFAAUAAgICAAFvpNR7e9la5kKAABYXgAACgAAAAAAAAAAAAAAAABc FQAAc3R5bGVzLnhtbFBLAQIUABQACAgIAAW+k1E8Jq2VOQEAAGwCAAAIAAAAAAAAAAAAAAAA AC0gAABtZXRhLnhtbFBLAQIUABQACAgIAAW+k1G092jSBQEAAIMDAAAMAAAAAAAAAAAAAAAA AJwhAABtYW5pZmVzdC5yZGZQSwECFAAUAAAIAAAFvpNRAAAAAAAAAAAAAAAAGgAAAAAAAAAA AAAAAADbIgAAQ29uZmlndXJhdGlvbnMyL3Rvb2xwYW5lbC9QSwECFAAUAAAIAAAFvpNRAAAA AAAAAAAAAAAAGgAAAAAAAAAAAAAAAAATIwAAQ29uZmlndXJhdGlvbnMyL3N0YXR1c2Jhci9Q SwECFAAUAAAIAAAFvpNRAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAABLIwAAQ29uZmlndXJh dGlvbnMyL3Byb2dyZXNzYmFyL1BLAQIUABQAAAgAAAW+k1EAAAAAAAAAAAAAAAAYAAAAAAAA AAAAAAAAAIUjAABDb25maWd1cmF0aW9uczIvdG9vbGJhci9QSwECFAAUAAAIAAAFvpNRAAAA AAAAAAAAAAAAGgAAAAAAAAAAAAAAAAC7IwAAQ29uZmlndXJhdGlvbnMyL3BvcHVwbWVudS9Q SwECFAAUAAAIAAAFvpNRAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAADzIwAAQ29uZmlndXJh dGlvbnMyL2Zsb2F0ZXIvUEsBAhQAFAAACAAABb6TUQAAAAAAAAAAAAAAABgAAAAAAAAAAAAA AAAAKSQAAENvbmZpZ3VyYXRpb25zMi9tZW51YmFyL1BLAQIUABQACAgIAAW+k1HuTIbuMwEA ACwEAAAVAAAAAAAAAAAAAAAAAF8kAABNRVRBLUlORi9tYW5pZmVzdC54bWxQSwECFAAUAAgI CAAFvpNRZLvSnUERAQD25xAACwAAAAAAAAAAAAAAAADVJQAAY29udGVudC54bWxQSwUGAAAA AA8ADwDOAwAATzcBAAAA --------------45196B023835614BDFCBD16D Content-Type: application/x-shellscript; name="brin-bloom-test.sh" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="brin-bloom-test.sh" IyEvYmluL2Jhc2gKCiMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiMgUEFSQU1F VEVSUyBGT1IgREFUQSBHRU5FUkFUT1IKIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMKClJVTlM9MTAKCiMgdGFibGUgc2hvdWxkIGJlIDFHQgpOVU1fUEFHRVM9MTMxMDcyCgoj IHRhYmxlIHdpdGggYSBzaW5nbGUgaW50IGNvbHVtbgpST1dTX1BFUl9SQU5HRT0yMjYKCiMg d2hhdCBudW1iZXIgb2YgcGFnZXMgc2hvdWxkIGNvbnRhaW4gdGhlCk1BVENISU5HX1BBR0VT PSIxIDEwMDAgMTAwMDAiCgojIHJlc3VsdCBuYW1lClJFU1VMVD0kMQoKIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMKIyBQQVJBTUVURVJTIEZPUiBJTkRFWCBCVUlMRAojIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIwoKIyBCUklOIHJhbmdlIHNpemUKUEFHRVNfUEVSX1JB TkdFPSIxIDQgOCAxNiAzMiA2NCAxMjggMjU2IgoKIyBibG9vbSBmYWxzZSBwb3NpdGl2ZQpG QUxTRV9QT1NJVElWRVM9IjAuMDEgMC4wMjUgMC4wNSAwLjA3NSAwLjEgMC4xNSIKCkZJTExf RkFDVE9SUz0iMTAwIDUwIDE1MCIKCkRBVEU9JChkYXRlICslWSVtJWQtJUglTSVTKQoKZWNo byAicnVuCXR5cGUJbWF0Y2gJdGFibGVfcGFnZXMJcm93c19wZXJfcmFuZ2UJbWF0Y2hpbmdf cGFnZXMJdG90YWxfcm93cwltb2R1bG9faW50ZXJ2YWwJcGFnZXNfcGVyX3JhbmdlCWZpbGxf ZmFjdG9yCW5kaXN0aW5jdAluZGlzdGluY3RfdGFyZ2V0CWZhbHNlX3Bvc2l0aXZlX3JhdGUJ aW5kZXhfcGFnZXMJcnVuCXNlZWQJdmFsdWUJdGltZQlyZW1vdmVkCXJvd3MiID4gcmVzdWx0 cy0kUkVTVUxULSREQVRFLmNzdgoKcHNxbCB0ZXN0IC1jICJkcm9wIHRhYmxlIGlmIGV4aXN0 cyB0Igpwc3FsIHRlc3QgLWMgImNyZWF0ZSB0YWJsZSB0IChhIGludCkiCgpSVU49MApTRUVE PTAKCmZvciBtcCBpbiAkTUFUQ0hJTkdfUEFHRVM7IGRvCgoJcHNxbCB0ZXN0IC1jICJ0cnVu Y2F0ZSB0IgoJcHNxbCB0ZXN0IC1jICJkcm9wIGluZGV4IGlmIGV4aXN0cyBpZHgiCgoJIyB0 b3RhbCBudW1iZXIgb2Ygcm93cyBpbiB0aGUgdGFibGUKCVRPVEFMX1JPV1M9JCgoTlVNX1BB R0VTICogUk9XU19QRVJfUkFOR0UpKQoKCSMgaG93IG9mdGVuIHdlIG5lZWQgdG8gcmVwZWF0 IHRoZSB2YWx1ZXMsIHRvIGdldCB0aGUgZGVzaXJlZCBudW1iZXIKCSMgb2YgbWF0Y2hpbmcg cGFnZXMKCU1PRFVMT19JTlRFUlZBTD0kKChUT1RBTF9ST1dTIC8gbXApKQoKCSMgZ2VuZXJh dGUgZGF0YQoJcHNxbCB0ZXN0IC1jICJpbnNlcnQgaW50byB0IHNlbGVjdCBtb2QoaSwgJE1P RFVMT19JTlRFUlZBTCkgZnJvbSBnZW5lcmF0ZV9zZXJpZXMoMSwgJFRPVEFMX1JPV1MpIHMo aSkiCgoJZm9yIHBwciBpbiAkUEFHRVNfUEVSX1JBTkdFOyBkbwoKCQlORElTVElOQ1Q9JCgo cHByICogUk9XU19QRVJfUkFOR0UpKQoKCQlmb3IgZmYgaW4gJEZJTExfRkFDVE9SUzsgZG8K CgkJCSMgdXNlZCB0byBzaXplIHRoZSBibG9vbSBmaWx0ZXIgKHRvbyBzbWFsbCAvIHRvbyBs YXJnZSkKCQkJTkRJU1RJTkNUX1RBUkdFVD0kKChORElTVElOQ1QgKiAxMDAgLyBmZikpCgoJ CQlmb3IgZnByIGluICRGQUxTRV9QT1NJVElWRVM7IGRvCgoJCQkJaWYgWyAtZiAic3RvcCIg XTsgdGhlbgoJCQkJCXJtICJzdG9wIgoJCQkJCWV4aXQKCQkJCWZpCgoJCQkJU0VFRD0kKChT RUVEKzEwMDApKQoKCQkJCXBzcWwgdGVzdCAtYyAiZHJvcCBpbmRleCBpZiBleGlzdHMgaWR4 IgoJCQkJcHNxbCB0ZXN0IC1jICJjcmVhdGUgaW5kZXggaWR4IG9uIHQgdXNpbmcgYnJpbiAo YSBpbnQ0X2Jsb29tX29wcyhuX2Rpc3RpbmN0X3Blcl9yYW5nZSA9ICRORElTVElOQ1RfVEFS R0VULCBmYWxzZV9wb3NpdGl2ZV9yYXRlID0gJGZwciwgc29ydF9tb2RlID0gZmFsc2UpKSB3 aXRoIChwYWdlc19wZXJfcmFuZ2UgPSAkcHByKSIKCQkJCXBzcWwgdGVzdCAtYyAidmFjdXVt IGFuYWx5emUgdCIKCgkJCQlpZHhfcGFnZXM9YHBzcWwgdGVzdCAtdCAtQSAtYyAic2VsZWN0 IHJlbHBhZ2VzIGZyb20gcGdfY2xhc3Mgd2hlcmUgcmVsbmFtZSA9ICdpZHgnImAKCgkJCQkj IGluZGV4IG5vdCBidWlsdCAoZmlsdGVyIHRvbyBsYXJnZSkKCQkJCWlmIFsgIiRpZHhfcGFn ZXMiID09ICIiIF07IHRoZW4KCQkJCQljb250aW51ZQoJCQkJZmkKCgkJCQkjIG1hdGNoZXMK CQkJCWZvciBpIGluIGBzZXEgMSAkUlVOU2A7IGRvCgoJCQkJCVJVTj0kKChSVU4rMSkpCgoJ CQkJCXY9YC4vcm5kLnB5ICQoKFNFRUQraSkpIDAgJCgoTU9EVUxPX0lOVEVSVkFMLTEpKWAK CgkJCQkJcHNxbCB0ZXN0ID4gcGxhbi5sb2cgPDxFT0YKc2V0IGVuYWJsZV9zZXFzY2FuID0g b2ZmOwpzZXQgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlciA9IDA7CmV4cGxhaW4g YW5hbHl6ZSBzZWxlY3QgKiBmcm9tIHQgd2hlcmUgYSA9ICR2OwpcdGltaW5nCnNlbGVjdCBj b3VudCgqKSBmcm9tIHQgd2hlcmUgYSA9ICR2OwpFT0YKCgkJCQkJZWNobyAiPT09PT0gUlVO ICRSVU4gPT09PT0iID4+IHBsYW5zLSREQVRFLmxvZwoJCQkJCWNhdCBwbGFuLmxvZyA+PiBw bGFucy0kREFURS5sb2cKCgkJCQkJdGltZT1gY2F0IHBsYW4ubG9nIHwgZ3JlcCAnXlRpbWUn IHwgYXdrICd7cHJpbnQgJDJ9J2AKCQkJCQlyZW1vdmVkPWBjYXQgcGxhbi5sb2cgfCBncmVw ICdSb3dzIFJlbW92ZWQgYnkgSW5kZXggUmVjaGVjaycgfCBhd2sgJ3twcmludCAkNn0nYAoK CQkJCQlpZiBbICIkcmVtb3ZlZCIgPT0gIiIgXTsgdGhlbgoJCQkJCQlyZW1vdmVkPSIwIgoJ CQkJCWZpCgoJCQkJCXJvd3M9YHBzcWwgdGVzdCAtdCAtQSAtYyAic2VsZWN0IGNvdW50KCop IGZyb20gdCB3aGVyZSBhID0gICR2ImAKCgkJCQkJZWNobyAiJFJVTglpbnQ0CW1hdGNoCSRO VU1fUEFHRVMJJFJPV1NfUEVSX1JBTkdFCSRtcAkkVE9UQUxfUk9XUwkkTU9EVUxPX0lOVEVS VkFMCSRwcHIJJGZmCSRORElTVElOQ1QJJE5ESVNUSU5DVF9UQVJHRVQJJGZwcgkkaWR4X3Bh Z2VzCSRpCSRTRUVECSR2CSR0aW1lCSRyZW1vdmVkCSRyb3dzIiA+PiByZXN1bHRzLSRSRVNV TFQtJERBVEUuY3N2CgoJCQkJZG9uZQoKCQkJCSMgbm8gbWF0Y2hlcyAob3V0c2lkZSBtb2R1 bG8gaW50ZXJ2YWwpCgkJCQlmb3IgaSBpbiBgc2VxIDEgJFJVTlNgOyBkbwoKCQkJCQlSVU49 JCgoUlVOKzEpKQoKCQkJCQl2PWAuL3JuZC5weSAkKChTRUVEK2kpKSAkTU9EVUxPX0lOVEVS VkFMICQoKE1PRFVMT19JTlRFUlZBTCoyKSlgCgoJCQkJCXBzcWwgdGVzdCA+IHBsYW4ubG9n IDw8RU9GCnNldCBlbmFibGVfc2Vxc2NhbiA9IG9mZjsKc2V0IG1heF9wYXJhbGxlbF93b3Jr ZXJzX3Blcl9nYXRoZXIgPSAwOwpleHBsYWluIGFuYWx5emUgc2VsZWN0ICogZnJvbSB0IHdo ZXJlIGEgPSAkdjsKXHRpbWluZwpzZWxlY3QgY291bnQoKikgZnJvbSB0IHdoZXJlIGEgPSAk djsKRU9GCgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWNobyAi PT09PT0gUlVOICRSVU4gPT09PT0iID4+IHBsYW5zLSREQVRFLmxvZwogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY2F0IHBsYW4ubG9nID4+IHBsYW5zLSREQVRF LmxvZwoKCQkJCQl0aW1lPWBjYXQgcGxhbi5sb2cgfCBncmVwICdeVGltZScgfCBhd2sgJ3tw cmludCAkMn0nYAoJCQkJCXJlbW92ZWQ9YGNhdCBwbGFuLmxvZyB8IGdyZXAgJ1Jvd3MgUmVt b3ZlZCBieSBJbmRleCBSZWNoZWNrJyB8IGF3ayAne3ByaW50ICQ2fSdgCgogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgWyAiJHJlbW92ZWQiID09ICIiIF07 IHRoZW4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmVtb3ZlZD0iMCIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZp CgoJCQkJCXJvd3M9YHBzcWwgdGVzdCAtdCAtQSAtYyAic2VsZWN0IGNvdW50KCopIGZyb20g dCB3aGVyZSBhID0gICR2ImAKCgkJCQkJZWNobyAiJFJVTglpbnQ0CW1pc21hdGNoCSROVU1f UEFHRVMJJFJPV1NfUEVSX1JBTkdFCSRtcAkkVE9UQUxfUk9XUwkkTU9EVUxPX0lOVEVSVkFM CSRwcHIJJGZmCSRORElTVElOQ1QJJE5ESVNUSU5DVF9UQVJHRVQJJGZwcgkkaWR4X3BhZ2Vz CSRpCSRTRUVECSR2CSR0aW1lCSRyZW1vdmVkCSRyb3dzIiA+PiByZXN1bHRzLSRSRVNVTFQt JERBVEUuY3N2CgoJCQkJZG9uZQoKCQkJZG9uZQoKCQlkb25lCgoJZG9uZQoKZG9uZQoKCgoj IG1kNSBoYXNoZXMgKDMyQiBlYWNoLCBubyB0b2FzdGluZykKClJPV1NfUEVSX1JBTkdFPTEy MAoKcHNxbCB0ZXN0IC1jICJkcm9wIHRhYmxlIGlmIGV4aXN0cyB0Igpwc3FsIHRlc3QgLWMg ImNyZWF0ZSB0YWJsZSB0IChhIHRleHQpIgoKZm9yIG1wIGluICRNQVRDSElOR19QQUdFUzsg ZG8KCglwc3FsIHRlc3QgLWMgInRydW5jYXRlIHQiCglwc3FsIHRlc3QgLWMgImRyb3AgaW5k ZXggaWYgZXhpc3RzIGlkeCIKCgkjIHRvdGFsIG51bWJlciBvZiByb3dzIGluIHRoZSB0YWJs ZQoJVE9UQUxfUk9XUz0kKChOVU1fUEFHRVMgKiBST1dTX1BFUl9SQU5HRSkpCgoJIyBob3cg b2Z0ZW4gd2UgbmVlZCB0byByZXBlYXQgdGhlIHZhbHVlcywgdG8gZ2V0IHRoZSBkZXNpcmVk IG51bWJlcgoJIyBvZiBtYXRjaGluZyBwYWdlcwoJTU9EVUxPX0lOVEVSVkFMPSQoKFRPVEFM X1JPV1MgLyBtcCkpCgoJIyBnZW5lcmF0ZSBkYXRhCglwc3FsIHRlc3QgLWMgImluc2VydCBp bnRvIHQgc2VsZWN0IG1kNShtb2QoaSwgJE1PRFVMT19JTlRFUlZBTCk6OnRleHQpIGZyb20g Z2VuZXJhdGVfc2VyaWVzKDEsICRUT1RBTF9ST1dTKSBzKGkpIgoKCWZvciBwcHIgaW4gJFBB R0VTX1BFUl9SQU5HRTsgZG8KCgkJTkRJU1RJTkNUPSQoKHBwciAqIFJPV1NfUEVSX1JBTkdF KSkKCgkJZm9yIGZmIGluICRGSUxMX0ZBQ1RPUlM7IGRvCgoJCQkjIHVzZWQgdG8gc2l6ZSB0 aGUgYmxvb20gZmlsdGVyICh0b28gc21hbGwgLyB0b28gbGFyZ2UpCgkJCU5ESVNUSU5DVF9U QVJHRVQ9JCgoTkRJU1RJTkNUICogMTAwIC8gZmYpKQoKCQkJZm9yIGZwciBpbiAkRkFMU0Vf UE9TSVRJVkVTOyBkbwoKCQkJCWlmIFsgLWYgInN0b3AiIF07IHRoZW4KCQkJCQlybSAic3Rv cCIKCQkJCQlleGl0CgkJCQlmaQoKCQkJCVNFRUQ9JCgoU0VFRCsxMDAwKSkKCgkJCQlwc3Fs IHRlc3QgLWMgImRyb3AgaW5kZXggaWYgZXhpc3RzIGlkeCIKCQkJCXBzcWwgdGVzdCAtYyAi Y3JlYXRlIGluZGV4IGlkeCBvbiB0IHVzaW5nIGJyaW4gKGEgdGV4dF9ibG9vbV9vcHMobl9k aXN0aW5jdF9wZXJfcmFuZ2UgPSAkTkRJU1RJTkNUX1RBUkdFVCwgZmFsc2VfcG9zaXRpdmVf cmF0ZSA9ICRmcHIsIHNvcnRfbW9kZSA9IGZhbHNlKSkgd2l0aCAocGFnZXNfcGVyX3Jhbmdl ID0gJHBwcikiCgkJCQlwc3FsIHRlc3QgLWMgInZhY3V1bSBhbmFseXplIHQiCgoJCQkJaWR4 X3BhZ2VzPWBwc3FsIHRlc3QgLXQgLUEgLWMgInNlbGVjdCByZWxwYWdlcyBmcm9tIHBnX2Ns YXNzIHdoZXJlIHJlbG5hbWUgPSAnaWR4JyJgCgoJCQkJIyBpbmRleCBub3QgYnVpbHQgKGZp bHRlciB0b28gbGFyZ2UpCgkJCQlpZiBbICIkaWR4X3BhZ2VzIiA9PSAiIiBdOyB0aGVuCgkJ CQkJY29udGludWUKCQkJCWZpCgoJCQkJIyBtYXRjaGVzCgkJCQlmb3IgaSBpbiBgc2VxIDEg JFJVTlNgOyBkbwoKCQkJCQlSVU49JCgoUlVOKzEpKQoKCQkJCQl2PWAuL3JuZC5weSAkKChT RUVEK2kpKSAwICQoKE1PRFVMT19JTlRFUlZBTC0xKSlgCgoJCQkJCXBzcWwgdGVzdCA+IHBs YW4ubG9nIDw8RU9GCnNldCBlbmFibGVfc2Vxc2NhbiA9IG9mZjsKc2V0IG1heF9wYXJhbGxl bF93b3JrZXJzX3Blcl9nYXRoZXIgPSAwOwpleHBsYWluIGFuYWx5emUgc2VsZWN0ICogZnJv bSB0IHdoZXJlIGEgPSBtZDUoJHY6OnRleHQpOwpcdGltaW5nCnNlbGVjdCBjb3VudCgqKSBm cm9tIHQgd2hlcmUgYSA9IG1kNSgkdjo6dGV4dCk7CkVPRgoKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGVjaG8gIj09PT09IFJVTiAkUlVOID09PT09IiA+PiBw bGFucy0kREFURS5sb2cKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGNhdCBwbGFuLmxvZyA+PiBwbGFucy0kREFURS5sb2cKCgkJCQkJdGltZT1gY2F0IHBsYW4u bG9nIHwgZ3JlcCAnXlRpbWUnIHwgYXdrICd7cHJpbnQgJDJ9J2AKCQkJCQlyZW1vdmVkPWBj YXQgcGxhbi5sb2cgfCBncmVwICdSb3dzIFJlbW92ZWQgYnkgSW5kZXggUmVjaGVjaycgfCBh d2sgJ3twcmludCAkNn0nYAoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGlmIFsgIiRyZW1vdmVkIiA9PSAiIiBdOyB0aGVuCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlbW92ZWQ9IjAiCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBmaQoKCQkJCQlyb3dzPWBwc3FsIHRlc3QgLXQg LUEgLWMgInNlbGVjdCBjb3VudCgqKSBmcm9tIHQgd2hlcmUgYSA9ICBtZDUoJHY6OnRleHQp ImAKCgkJCQkJZWNobyAiJFJVTgl0ZXh0CW1hdGNoCSROVU1fUEFHRVMJJFJPV1NfUEVSX1JB TkdFCSRtcAkkVE9UQUxfUk9XUwkkTU9EVUxPX0lOVEVSVkFMCSRwcHIJJGZmCSRORElTVElO Q1QJJE5ESVNUSU5DVF9UQVJHRVQJJGZwcgkkaWR4X3BhZ2VzCSRpCSRTRUVECSR2CSR0aW1l CSRyZW1vdmVkCSRyb3dzIiA+PiByZXN1bHRzLSRSRVNVTFQtJERBVEUuY3N2CgoJCQkJZG9u ZQoKCQkJCSMgbm8gbWF0Y2hlcyAob3V0c2lkZSBtb2R1bG8gaW50ZXJ2YWwpCgkJCQlmb3Ig aSBpbiBgc2VxIDEgJFJVTlNgOyBkbwoKCQkJCQlSVU49JCgoUlVOKzEpKQoKCQkJCQl2PWAu L3JuZC5weSAkKChTRUVEK2kpKSAkTU9EVUxPX0lOVEVSVkFMICQoKE1PRFVMT19JTlRFUlZB TCoyKSlgCgoJCQkJCXBzcWwgdGVzdCA+IHBsYW4ubG9nIDw8RU9GCnNldCBlbmFibGVfc2Vx c2NhbiA9IG9mZjsKc2V0IG1heF9wYXJhbGxlbF93b3JrZXJzX3Blcl9nYXRoZXIgPSAwOwpl eHBsYWluIGFuYWx5emUgc2VsZWN0ICogZnJvbSB0IHdoZXJlIGEgPSBtZDUoJHY6OnRleHQp OwpcdGltaW5nCnNlbGVjdCBjb3VudCgqKSBmcm9tIHQgd2hlcmUgYSA9IG1kNSgkdjo6dGV4 dCk7CkVPRgoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVjaG8g Ij09PT09IFJVTiAkUlVOID09PT09IiA+PiBwbGFucy0kREFURS5sb2cKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNhdCBwbGFuLmxvZyA+PiBwbGFucy0kREFU RS5sb2cKCgkJCQkJdGltZT1gY2F0IHBsYW4ubG9nIHwgZ3JlcCAnXlRpbWUnIHwgYXdrICd7 cHJpbnQgJDJ9J2AKCQkJCQlyZW1vdmVkPWBjYXQgcGxhbi5sb2cgfCBncmVwICdSb3dzIFJl bW92ZWQgYnkgSW5kZXggUmVjaGVjaycgfCBhd2sgJ3twcmludCAkNn0nYAoKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIFsgIiRyZW1vdmVkIiA9PSAiIiBd OyB0aGVuCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlbW92ZWQ9IjAiCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBm aQoKCQkJCQlyb3dzPWBwc3FsIHRlc3QgLXQgLUEgLWMgInNlbGVjdCBjb3VudCgqKSBmcm9t IHQgd2hlcmUgYSA9ICBtZDUoJHY6OnRleHQpImAKCgkJCQkJZWNobyAiJFJVTgl0ZXh0CW1p c21hdGNoCSROVU1fUEFHRVMJJFJPV1NfUEVSX1JBTkdFCSRtcAkkVE9UQUxfUk9XUwkkTU9E VUxPX0lOVEVSVkFMCSRwcHIJJGZmCSRORElTVElOQ1QJJE5ESVNUSU5DVF9UQVJHRVQJJGZw cgkkaWR4X3BhZ2VzCSRpCSRTRUVECSR2CSR0aW1lCSRyZW1vdmVkCSRyb3dzIiA+PiByZXN1 bHRzLSRSRVNVTFQtJERBVEUuY3N2CgoJCQkJZG9uZQoKCQkJZG9uZQoKCQlkb25lCgoJZG9u ZQoKZG9uZQoK --------------45196B023835614BDFCBD16D--