agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v6 2/2] Add a --outdated option to reindexdb 2+ messages / 2 participants [nested] [flat]
* [PATCH v6 2/2] Add a --outdated option to reindexdb @ 2021-02-24 17:33 Julien Rouhaud <[email protected]> 0 siblings, 0 replies; 2+ messages in thread From: Julien Rouhaud @ 2021-02-24 17:33 UTC (permalink / raw) This uses the new OUTDATED option for REINDEX. If user asks for multiple job, the list of tables to process will be sorted by the total size of underlying indexes that have outdated dependency. Author: Julien Rouhaud <[email protected]> Reviewed-by: Discussion: https://postgr.es/m/20201203093143.GA64934%40nol --- src/bin/scripts/reindexdb.c | 143 ++++++++++++++++++++++++----- src/bin/scripts/t/090_reindexdb.pl | 34 ++++++- 2 files changed, 151 insertions(+), 26 deletions(-) diff --git a/src/bin/scripts/reindexdb.c b/src/bin/scripts/reindexdb.c index fc0681538a..addea5c1ed 100644 --- a/src/bin/scripts/reindexdb.c +++ b/src/bin/scripts/reindexdb.c @@ -35,20 +35,23 @@ typedef enum ReindexType static SimpleStringList *get_parallel_object_list(PGconn *conn, ReindexType type, SimpleStringList *user_list, + bool outdated, bool echo); static void reindex_one_database(ConnParams *cparams, ReindexType type, SimpleStringList *user_list, const char *progname, bool echo, bool verbose, bool concurrently, - int concurrentCons, const char *tablespace); + int concurrentCons, const char *tablespace, + bool outdated); static void reindex_all_databases(ConnParams *cparams, const char *progname, bool echo, bool quiet, bool verbose, bool concurrently, - int concurrentCons, const char *tablespace); + int concurrentCons, const char *tablespace, + bool outdated); static void run_reindex_command(PGconn *conn, ReindexType type, const char *name, bool echo, bool verbose, bool concurrently, bool async, - const char *tablespace); + const char *tablespace, bool outdated); static void help(const char *progname); @@ -74,6 +77,7 @@ main(int argc, char *argv[]) {"concurrently", no_argument, NULL, 1}, {"maintenance-db", required_argument, NULL, 2}, {"tablespace", required_argument, NULL, 3}, + {"outdated", no_argument, NULL, 4}, {NULL, 0, NULL, 0} }; @@ -95,6 +99,7 @@ main(int argc, char *argv[]) bool quiet = false; bool verbose = false; bool concurrently = false; + bool outdated = false; SimpleStringList indexes = {NULL, NULL}; SimpleStringList tables = {NULL, NULL}; SimpleStringList schemas = {NULL, NULL}; @@ -170,6 +175,9 @@ main(int argc, char *argv[]) case 3: tablespace = pg_strdup(optarg); break; + case 4: + outdated = true; + break; default: fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname); exit(1); @@ -234,7 +242,8 @@ main(int argc, char *argv[]) cparams.dbname = maintenance_db; reindex_all_databases(&cparams, progname, echo, quiet, verbose, - concurrently, concurrentCons, tablespace); + concurrently, concurrentCons, tablespace, + outdated); } else if (syscatalog) { @@ -253,12 +262,17 @@ main(int argc, char *argv[]) pg_log_error("cannot reindex specific index(es) and system catalogs at the same time"); exit(1); } - if (concurrentCons > 1) { pg_log_error("cannot use multiple jobs to reindex system catalogs"); exit(1); } + if (outdated) + { + pg_log_error("cannot filter indexes having outdated dependencies " + "and reindex system catalogs at the same time"); + exit(1); + } if (dbname == NULL) { @@ -274,7 +288,7 @@ main(int argc, char *argv[]) reindex_one_database(&cparams, REINDEX_SYSTEM, NULL, progname, echo, verbose, - concurrently, 1, tablespace); + concurrently, 1, tablespace, outdated); } else { @@ -304,17 +318,20 @@ main(int argc, char *argv[]) if (schemas.head != NULL) reindex_one_database(&cparams, REINDEX_SCHEMA, &schemas, progname, echo, verbose, - concurrently, concurrentCons, tablespace); + concurrently, concurrentCons, tablespace, + outdated); if (indexes.head != NULL) reindex_one_database(&cparams, REINDEX_INDEX, &indexes, progname, echo, verbose, - concurrently, 1, tablespace); + concurrently, 1, tablespace, + outdated); if (tables.head != NULL) reindex_one_database(&cparams, REINDEX_TABLE, &tables, progname, echo, verbose, - concurrently, concurrentCons, tablespace); + concurrently, concurrentCons, tablespace, + outdated); /* * reindex database only if neither index nor table nor schema is @@ -323,7 +340,8 @@ main(int argc, char *argv[]) if (indexes.head == NULL && tables.head == NULL && schemas.head == NULL) reindex_one_database(&cparams, REINDEX_DATABASE, NULL, progname, echo, verbose, - concurrently, concurrentCons, tablespace); + concurrently, concurrentCons, tablespace, + outdated); } exit(0); @@ -334,7 +352,7 @@ reindex_one_database(ConnParams *cparams, ReindexType type, SimpleStringList *user_list, const char *progname, bool echo, bool verbose, bool concurrently, int concurrentCons, - const char *tablespace) + const char *tablespace, bool outdated) { PGconn *conn; SimpleStringListCell *cell; @@ -363,6 +381,14 @@ reindex_one_database(ConnParams *cparams, ReindexType type, exit(1); } + if (outdated && PQserverVersion(conn) < 140000) + { + PQfinish(conn); + pg_log_error("cannot use the \"%s\" option on server versions older than PostgreSQL %s", + "outdated", "14"); + exit(1); + } + if (!parallel) { switch (process_type) @@ -399,14 +425,24 @@ reindex_one_database(ConnParams *cparams, ReindexType type, */ if (concurrently) pg_log_warning("cannot reindex system catalogs concurrently, skipping all"); + else if (outdated) + { + /* + * The only supported kind of object that can be outdated + * is collation. No system catalog has any index that can + * depend on an outdated collation, so skip system + * catalogs. + */ + } else run_reindex_command(conn, REINDEX_SYSTEM, PQdb(conn), echo, verbose, concurrently, false, - tablespace); + tablespace, outdated); /* Build a list of relations from the database */ process_list = get_parallel_object_list(conn, process_type, - user_list, echo); + user_list, outdated, + echo); process_type = REINDEX_TABLE; /* Bail out if nothing to process */ @@ -419,7 +455,8 @@ reindex_one_database(ConnParams *cparams, ReindexType type, /* Build a list of relations from all the schemas */ process_list = get_parallel_object_list(conn, process_type, - user_list, echo); + user_list, outdated, + echo); process_type = REINDEX_TABLE; /* Bail out if nothing to process */ @@ -485,7 +522,8 @@ reindex_one_database(ConnParams *cparams, ReindexType type, ParallelSlotSetHandler(free_slot, TableCommandResultHandler, NULL); run_reindex_command(free_slot->connection, process_type, objname, - echo, verbose, concurrently, true, tablespace); + echo, verbose, concurrently, true, tablespace, + outdated); cell = cell->next; } while (cell != NULL); @@ -510,7 +548,7 @@ finish: static void run_reindex_command(PGconn *conn, ReindexType type, const char *name, bool echo, bool verbose, bool concurrently, bool async, - const char *tablespace) + const char *tablespace, bool outdated) { const char *paren = "("; const char *comma = ", "; @@ -537,6 +575,12 @@ run_reindex_command(PGconn *conn, ReindexType type, const char *name, sep = comma; } + if (outdated) + { + appendPQExpBuffer(&sql, "%sOUTDATED", sep); + sep = comma; + } + if (sep != paren) appendPQExpBufferStr(&sql, ") "); @@ -642,7 +686,7 @@ run_reindex_command(PGconn *conn, ReindexType type, const char *name, */ static SimpleStringList * get_parallel_object_list(PGconn *conn, ReindexType type, - SimpleStringList *user_list, bool echo) + SimpleStringList *user_list, bool outdated, bool echo) { PQExpBufferData catalog_query; PQExpBufferData buf; @@ -661,16 +705,41 @@ get_parallel_object_list(PGconn *conn, ReindexType type, { case REINDEX_DATABASE: Assert(user_list == NULL); + appendPQExpBufferStr(&catalog_query, "SELECT c.relname, ns.nspname\n" " FROM pg_catalog.pg_class c\n" " JOIN pg_catalog.pg_namespace ns" - " ON c.relnamespace = ns.oid\n" + " ON c.relnamespace = ns.oid\n"); + + if (outdated) + { + appendPQExpBufferStr(&catalog_query, + " JOIN pg_catalog.pg_index i" + " ON c.oid = i.indrelid\n" + " JOIN pg_catalog.pg_class ci" + " ON i.indexrelid = ci.oid\n"); + } + + appendPQExpBufferStr(&catalog_query, " WHERE ns.nspname != 'pg_catalog'\n" " AND c.relkind IN (" CppAsString2(RELKIND_RELATION) ", " - CppAsString2(RELKIND_MATVIEW) ")\n" - " ORDER BY c.relpages DESC;"); + CppAsString2(RELKIND_MATVIEW) ")\n"); + + if (outdated) + { + appendPQExpBufferStr(&catalog_query, + " GROUP BY c.relname, ns.nspname\n" + " ORDER BY sum(ci.relpages)" + " FILTER (WHERE pg_catalog.pg_index_has_outdated_dependency(ci.oid)) DESC;"); + } + else + { + appendPQExpBufferStr(&catalog_query, + " ORDER BY c.relpages DESC;"); + } + break; case REINDEX_SCHEMA: @@ -688,7 +757,18 @@ get_parallel_object_list(PGconn *conn, ReindexType type, "SELECT c.relname, ns.nspname\n" " FROM pg_catalog.pg_class c\n" " JOIN pg_catalog.pg_namespace ns" - " ON c.relnamespace = ns.oid\n" + " ON c.relnamespace = ns.oid\n"); + + if (outdated) + { + appendPQExpBufferStr(&catalog_query, + " JOIN pg_catalog.pg_index i" + " ON c.oid = i.indrelid\n" + " JOIN pg_catalog.pg_class ci" + " ON i.indexrelid = ci.oid\n"); + } + + appendPQExpBufferStr(&catalog_query, " WHERE c.relkind IN (" CppAsString2(RELKIND_RELATION) ", " CppAsString2(RELKIND_MATVIEW) ")\n" @@ -706,8 +786,20 @@ get_parallel_object_list(PGconn *conn, ReindexType type, appendStringLiteralConn(&catalog_query, nspname, conn); } - appendPQExpBufferStr(&catalog_query, ")\n" - " ORDER BY c.relpages DESC;"); + appendPQExpBufferStr(&catalog_query, ")\n"); + + if (outdated) + { + appendPQExpBufferStr(&catalog_query, + " GROUP BY c.relname, ns.nspname\n" + " ORDER BY sum(ci.relpages)" + " FILTER (WHERE pg_catalog.pg_index_has_outdated_dependency(ci.oid)) DESC;"); + } + else + { + appendPQExpBufferStr(&catalog_query, + " ORDER BY c.relpages DESC;"); + } } break; @@ -755,7 +847,7 @@ static void reindex_all_databases(ConnParams *cparams, const char *progname, bool echo, bool quiet, bool verbose, bool concurrently, int concurrentCons, - const char *tablespace) + const char *tablespace, bool outdated) { PGconn *conn; PGresult *result; @@ -779,7 +871,7 @@ reindex_all_databases(ConnParams *cparams, reindex_one_database(cparams, REINDEX_DATABASE, NULL, progname, echo, verbose, concurrently, - concurrentCons, tablespace); + concurrentCons, tablespace, outdated); } PQclear(result); @@ -798,6 +890,7 @@ help(const char *progname) printf(_(" -e, --echo show the commands being sent to the server\n")); printf(_(" -i, --index=INDEX recreate specific index(es) only\n")); printf(_(" -j, --jobs=NUM use this many concurrent connections to reindex\n")); + printf(_(" --outdated only process indexes having outdated depencies\n")); printf(_(" -q, --quiet don't write any messages\n")); printf(_(" -s, --system reindex system catalogs\n")); printf(_(" -S, --schema=SCHEMA reindex specific schema(s) only\n")); diff --git a/src/bin/scripts/t/090_reindexdb.pl b/src/bin/scripts/t/090_reindexdb.pl index 159b637230..b60cac6081 100644 --- a/src/bin/scripts/t/090_reindexdb.pl +++ b/src/bin/scripts/t/090_reindexdb.pl @@ -3,7 +3,7 @@ use warnings; use PostgresNode; use TestLib; -use Test::More tests => 58; +use Test::More tests => 70; program_help_ok('reindexdb'); program_version_ok('reindexdb'); @@ -174,6 +174,9 @@ $node->command_fails( $node->command_fails( [ 'reindexdb', '-j', '2', '-i', 'i1', 'postgres' ], 'parallel reindexdb cannot process indexes'); +$node->command_fails( + [ 'reindexdb', '-s', '--outdated' ], + 'cannot reindex system catalog and filter indexes having outdated dependencies'); $node->issues_sql_like( [ 'reindexdb', '-j', '2', 'postgres' ], qr/statement:\ REINDEX SYSTEM postgres; @@ -196,3 +199,32 @@ $node->command_checks_all( qr/^reindexdb: warning: cannot reindex system catalogs concurrently, skipping all/s ], 'parallel reindexdb for system with --concurrently skips catalogs'); + +# Temporarily downgrade client-min-message to get the no-op report +$ENV{PGOPTIONS} = '--client-min-messages=NOTICE'; +$node->command_checks_all( + [ 'reindexdb', '--outdated', '-v', '-t', 's1.t1', 'postgres' ], + 0, + [qr/^$/], + [qr/table "t1" has no indexes to reindex/], + 'verbose reindexdb for outdated dependencies on a specific table reports no-op tables'); + +$node->command_checks_all( + [ 'reindexdb', '--outdated', '-v', '-d', 'postgres' ], + 0, + [qr/^$/], + [qr/^$/], + 'verbose reindexdb for outdated dependencies database wide silently ignore all tables'); +$node->command_checks_all( + [ 'reindexdb', '--outdated', '-v', '-j', '2', '-d', 'postgres' ], + 0, + [qr/^$/], + [qr/table "t1" has no indexes to reindex/], + 'parallel verbose reindexdb for outdated dependencies database wide reports no-op tables'); + +# Switch back to WARNING client-min-message +$ENV{PGOPTIONS} = '--client-min-messages=WARNING'; +$node->issues_sql_like( + [ 'reindexdb', '--outdated', '-t', 's1.t1', 'postgres' ], + qr/.*statement: REINDEX \(OUTDATED\) TABLE s1\.t1;/, + 'reindexdb for outdated dependencies specify the OUTDATED keyword'); -- 2.30.1 --mzh3msf6semlblkg-- ^ permalink raw reply [nested|flat] 2+ messages in thread
* [PATCH v2] Update PQparameterStatus and ParameterStatus docs @ 2024-01-30 14:27 Alvaro Herrera <[email protected]> 0 siblings, 0 replies; 2+ messages in thread From: Alvaro Herrera @ 2024-01-30 14:27 UTC (permalink / raw) Cover scram_iterations, which were missed in 16. Also turn the list into a <simplelist> with 2 columns, which is much nicer to read. --- doc/src/sgml/libpq.sgml | 43 ++++++++++++++++++-------------------- doc/src/sgml/protocol.sgml | 43 ++++++++++++++++++-------------------- 2 files changed, 40 insertions(+), 46 deletions(-) diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index d0d5aefadc..1d8998efb2 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -2509,30 +2509,27 @@ const char *PQparameterStatus(const PGconn *conn, const char *paramName); </para> <para> - Parameters reported as of the current release include - <varname>server_version</varname>, - <varname>server_encoding</varname>, - <varname>client_encoding</varname>, - <varname>application_name</varname>, - <varname>default_transaction_read_only</varname>, - <varname>in_hot_standby</varname>, - <varname>is_superuser</varname>, - <varname>session_authorization</varname>, - <varname>DateStyle</varname>, - <varname>IntervalStyle</varname>, - <varname>TimeZone</varname>, - <varname>integer_datetimes</varname>, and - <varname>standard_conforming_strings</varname>. - (<varname>server_encoding</varname>, <varname>TimeZone</varname>, and - <varname>integer_datetimes</varname> were not reported by releases before 8.0; - <varname>standard_conforming_strings</varname> was not reported by releases - before 8.1; - <varname>IntervalStyle</varname> was not reported by releases before 8.4; - <varname>application_name</varname> was not reported by releases before - 9.0; - <varname>default_transaction_read_only</varname> and + Parameters reported as of the current release include: + <simplelist type="vert" columns="2"> + <member><varname>application_name</varname></member> + <member><varname>client_encoding</varname></member> + <member><varname>DateStyle</varname></member> + <member><varname>default_transaction_read_only</varname></member> + <member><varname>in_hot_standby</varname></member> + <member><varname>integer_datetimes</varname></member> + <member><varname>IntervalStyle</varname></member> + <member><varname>is_superuser</varname></member> + <member><varname>scram_iterations</varname></member> + <member><varname>server_encoding</varname></member> + <member><varname>server_version</varname></member> + <member><varname>session_authorization</varname></member> + <member><varname>standard_conforming_strings</varname></member> + <member><varname>TimeZone</varname></member> + </simplelist> + (<varname>default_transaction_read_only</varname> and <varname>in_hot_standby</varname> were not reported by releases before - 14.) + 14; <varname>scram_iterations</varname> was not reported by releases + before 16.) Note that <varname>server_version</varname>, <varname>server_encoding</varname> and diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml index bb4fef1f51..ed1d62f5f8 100644 --- a/doc/src/sgml/protocol.sgml +++ b/doc/src/sgml/protocol.sgml @@ -1314,30 +1314,27 @@ SELCT 1/0;<!-- this typo is intentional --> <para> At present there is a hard-wired set of parameters for which - ParameterStatus will be generated: they are - <varname>server_version</varname>, - <varname>server_encoding</varname>, - <varname>client_encoding</varname>, - <varname>application_name</varname>, - <varname>default_transaction_read_only</varname>, - <varname>in_hot_standby</varname>, - <varname>is_superuser</varname>, - <varname>session_authorization</varname>, - <varname>DateStyle</varname>, - <varname>IntervalStyle</varname>, - <varname>TimeZone</varname>, - <varname>integer_datetimes</varname>, and - <varname>standard_conforming_strings</varname>. - (<varname>server_encoding</varname>, <varname>TimeZone</varname>, and - <varname>integer_datetimes</varname> were not reported by releases before 8.0; - <varname>standard_conforming_strings</varname> was not reported by releases - before 8.1; - <varname>IntervalStyle</varname> was not reported by releases before 8.4; - <varname>application_name</varname> was not reported by releases before - 9.0; - <varname>default_transaction_read_only</varname> and + ParameterStatus will be generated. They are: + <simplelist type="vert" columns="2"> + <member><varname>application_name</varname></member> + <member><varname>client_encoding</varname></member> + <member><varname>DateStyle</varname></member> + <member><varname>default_transaction_read_only</varname></member> + <member><varname>in_hot_standby</varname></member> + <member><varname>integer_datetimes</varname></member> + <member><varname>IntervalStyle</varname></member> + <member><varname>is_superuser</varname></member> + <member><varname>scram_iterations</varname></member> + <member><varname>server_encoding</varname></member> + <member><varname>server_version</varname></member> + <member><varname>session_authorization</varname></member> + <member><varname>standard_conforming_strings</varname></member> + <member><varname>TimeZone</varname></member> + </simplelist> + (<varname>default_transaction_read_only</varname> and <varname>in_hot_standby</varname> were not reported by releases before - 14.) + 14; <varname>scram_iterations</varname> was not reported by releases + before 16.) Note that <varname>server_version</varname>, <varname>server_encoding</varname> and -- 2.39.2 --nsrsbbtvuxugaayv Content-Type: image/png Content-Disposition: attachment; filename="params.png" Content-Transfer-Encoding: base64 iVBORw0KGgoAAAANSUhEUgAAAs8AAAF8CAIAAAC/psGmAAAAA3NCSVQICAjb4U/gAAAAGXRF WHRTb2Z0d2FyZQBnbm9tZS1zY3JlZW5zaG907wO/PgAAIABJREFUeJzsnXlUFMfWwGtAcGEV BERRUFAgCgKiElQ0ojFRYxAVNzQ+MSqouOKahLiCGj73p4CASwSiiYqiyKIgm0gUJBECBAw7 iOyLLDNDf3/0S79+Pd09PQMDYu7veDzd1VV1l7p1u+iumeFhGIYAAAAAAABkhlxPKwAAAAAA wAcOrDYAAAAAAJAtsNoAAAAAAEC2wGoDAAAAAADZAqsNAAAAAABkC6w2AAAAAACQLbDaAAAA AABAtsBqAwAAAAAA2QKrDQAAAAAAZAusNgAAAAAAkC2w2gAAAAAAQLbAagMAAAAAANkCqw0A AAAAAGSLDFcbjY2N58+fd3FxWbBgwfbt2wMCAuLi4k6ePCkLWSEhITNmzODz+bLo/J9Afn7+ uXPn5s6dm5ub29O69HrevXt38+bNr7766vbt25RL8fHxO3bs2LNnT1fJev78+f79+zdu3NhV HQJi6Uy2IU80mHRkIId3Ce9zQpDVaiMsLMzExCQlJWX79u2//PLLnj17KioqPvvssydPnkja FYZhYusIhUIMw7jU7C10sy1KSkoFBQUPHjyA2c6ERCMiEAiuXr3a0NBAKVdVVb169WphYWFX KaOkpBQcHPxPvl11z0whS+lMtiFPNFlMut6VA7vKq1ILlXWr7ud9TggyWW2kp6c7OTk5ODhc u3ZtzJgxcnJy2tra+/fvv3Tp0rt37yTqqq2t7cCBA2KrOTs7x8bGKioqSqvy+wVHq7uQwYMH T58+vTsl9i4kGpEBAwbMmjWL9pKFhYW+vn4XKmNqampoaNjJDnsv3TNTKFI6k23IE63LJ133 543O0IVelVqoTFv1CO9zQujT5T0KBIIVK1YoKiqKDo+zs/OjR4+4dyUUCl1cXJqbm7tUwfed nrKax+N1s8TeghQjwuLMTvpZVJl/7MB1z0zpcink8erCsetd2bJHtJVOaO9yLHqPE0LXP9vI zs7+448/pkyZMmjQINGr//d//4cfNDQ0HD58eNu2bTY2Nhs3bmxpaUEIpaenb9u2zcHBITw8 3NDQsF+/fuHh4a9evfLw8EhISEAIZWRkrF279vTp00uXLvX09MSfbpWWlvr4+IwfP760tBQh lJCQsHbt2s8//zw5OdnW1lZdXd3Dw0NUk+TkZFdXVwcHh/v371tZWWlqaq5ZswZ/9EIrhaLb hg0bmGqmpKS4urpOmDAhOzvb0dFRS0tr4cKFAoEgKCho8uTJGhoaP/zwA4sTLl++TLFatBqt MmSioqKsra3HjRsXExODEGpra9uxY8f8+fMrKipodaYQFhZmYWGBv/zLzs52dXU1MzNLSUlh UfvBgwfu7u6XLl1ycXG5ceOGaJ/cvUrbPxmOrViGGCEkEAgOHz586NChnTt3zp49Ozw8nKlz yogwqYdhmLe39/79+w8cOODt7S3qATIXL14cM2bM0KFD9+/fLxQKEULXr18fN26cjY0NPmR8 Pv/QoUPz58+vqqoiNxQND5yIiIiJEyeqqam5urqyDBMF2lHjMjc3bNjAEmMce+ASISyhSHEF 04Byn4+0OlCkULINHkg+Pj6enp7u7u729va///47izkscAwApp6ZAoNdSSanMWVR9uzKFHKi 0rl4VSLFRBGNbYpQjhmJ0oopINmzDWUsOGYecquHDx+amZnZ29v/8ccfubm5c+bMMTMz8/b2 bm9vFwgEHh4eCxcuJL+S45gQuPuzC8C6mmvXriGENm7cyF5tyZIlr1+/xjDszZs3/fv337Rp E4ZhmZmZpqamQ4YM8fX1vXr16qlTp2xsbBwcHIhWw4YN8/LywjAMf/P95MkTDMOKioo2b96M ECopKcEwrKWlZfr06YMGDbpw4UJzc/PBgwcRQi9fvqQokJOTY2Jioq2t7e/vX1xcfP78eTk5 uXXr1jFJEdWNqWZbW9vy5cv79+/v5+fX1tb24sULhNDs2bNTUlKEQuGRI0cUFRWrq6uZnIBh GMVq0Wq0ylDYu3cvj8crLy/HT8+cOXPv3j0mnTEMw4P+1atX+KmlpeW8efPw47i4OIRQTEwM kz58Pl9NTa2mpgbDsKysLB8fH1F9uHuVyS0EHFuxDDGGYcuXL9+3bx9+HB8fz+Pxrl+/ztQ5 eUSY1Nu2bZuHhwd+fOvWLYTQ5cuXRf1gbW1taGjo6+ublpa2fv16hNDBgwfxS6tWrVJSUmpu bsZPT506dePGDdEeKOExc+ZMPT29oKCglpaWo0eP4hmEixuZRo3j3MSYY4x7D2SYIpMlFMmu YBpQ7vORSQeyFEq2wTBs06ZNly5dwo8nTZpkYWHBbg55olEmHccAYOqZEhhkmJRkchpTFmXP rkwhRyud3auSKkaxlym2yUK5ZySKY2kDkj3bkJEo85CZPn06MXD4DvSMjAz89NSpU7dv38aP JUoIHP3ZJXT9agP/q27r1q0sdRITEw0MDC7/zYgRI3R0dPBLCxcuNDExIWpShnnPnj3p6ekY hnV0dCCEAgIC8PKQkBBypLq4uBgZGeHHr1+/RggFBweLqvHll1/a2toSp46OjgoKCu3t7UxS KLqx6OPp6amsrExU09XVXb16NX6MJ7unT5+yOIFsNVM1UWUovHnzpm/fvt7e3vjp4sWL8X1Y TDpTEt+UKVOIGfX8+XMixdPq09DQwOPx8KmLYRgxB7j4imIIi1vIcGzFNMRpaWkIoczMTOKS vb29rq4ubecYaUSYBOXn5/fp0wefzBiGVVZWsqw2HB0d8WOhUGhmZqahoYGfvnr1isfjnT17 Fj+dM2dOW1ubaA+iqw17e3v8GP/T8OLFi1zcSDtq3OcmxhBjEvVAhilCmEKR7Ar2AeUyH1l0 oDicnG3S09M1NTWJHY4ZGRl37txhN4dltcExAJh6ZlptMCnJ7jSmLMpUzjTuTNJZvCqdYmSY MhJZKPc8T1GVKSCZsg25K0kzDxn8CQ3etr29vW/fvrt378YvLV++XCAQ4MeSJgSOt8vO0/X7 NoyNjRFC7Hti09LSdHV1ra2t8dN79+4hhDAM4/F4PB5PXV2dqaGXl1dNTU1AQIBAIEAIEQ+O KG+qyKeqqqoIofb2dtHeeDyenNx/3yXZ29vfunWrsLCQRQpFN476qKmpEcd9+/ZFCNXX1+fm 5jI5gaOvWByFENLW1nZycvL399+1a1dWVta4ceNwY5l05gitPsrKylu2bNm7d294ePj58+fH jRsn2pCjV1nsJffGvRXtEKempqK/YwPH1tb20aNHpaWlQ4cOZfEtk6D4+PiOjg5iByhZqCjE Vjg5OblPP/3Ux8ensrJSW1t7zJgxc+fOPXnypKura0FBgZGREcdNc4RzNDU1EUKtra1c3Kii oiI6ahLNTdoY6/LZzQWxA0quTDsfuetA7i05OVlPT48YbnNzc3Nzc6nN4RgAkvbMpCR3p5Gz KFM507izuIgMuVvpFCNDG9sUuOd5jjBlGyMjI+6msYj+8ssvtbS0goKCTpw4ERkZOWLEiGvX rh05cuTPP/80NDSUl5cna4IfcEkITP7Mycm5c+cOXq6goLB9+3YpfEKm61cbeCTh6y+m7SoV FRXV1dVjxoyRtPPQ0NDQ0NDAwEANDQ3R976dRENDAyGkpaXFXUpn9OHoBKl9hRByc3O7du3a 48ePo6Oj3d3dO68ziz4nT54cO3bs7t27J02aFBQUtGzZMkoFjnKls5djK2KI8cxSVlamp6eH X9LR0UGkdYCkgoqKijo6Opqamsh5hAv6+vp9+vQhUsyuXbvs7Oxu376dnZ29evVqibrioicF 0VGT1P+iMdYjs1vqAe2kDmVlZcRWg052hcMlALpKya5yGg7TuLO4iIkuUayrMpLUENmGXNgZ 0xQVFb/66qurV68ePXr0ypUrYWFhpqam0dHR5PTOhBSzsrGxMTs7Gz/GF+WdpOt3iY4cOXLV qlWFhYUBAQGiV9++fYsQGjFiRG5ubmJiIlGekZFBGEYBf8yFEMrJyXF2dt6xYwc+il1OcXGx sbFxRUUFRymd1IfdCYTVEvmKgo2NjZWV1blz5+rq6oYMGSKpzoQO+DZGFn2ePXv222+/ubi4 5OXlffLJJ1u3biXa4nCXK529HFvhQ6ympmZpaYkQItd/+/atvr4+JTWQwS1iEoQ/1Xj69Cm7 nqJUV1dPmDCByDVTp061tbU9ceJEZmYmriSLMixwcUh9fb3oqEnqf9EYk24E2SOENhTJl6QY UIl0YHL4qFGjqqqqHj58SJQkJSW1trZKnRzEBgBHR3FRskucRsA07kzSmbRFXTGatLGNX8IP JB0giqosAUlAZBtyYSdN+/rrrysrKz09PceNGzd69OjZs2dfuHChoqJC7OfqpZiV1tbWQX9z 8eJFLuqxI5Pv2/Dx8TEyMtq1axdla/Tt27fv3r2LEFqwYIGqqurixYsfPHhQVlYWEhLi5+dn YmKCEGptbSU/GFRRUcnPz0cIlZSU5OTkCIVC/E1bREQEQqixsbGtrQ0hhP9PPE8TCARENFAu UaitrSWaBAcHHzx4kEUKRTeWmi0tLeToFAgEZN3w/1mcQLaaqRpFGSY2btx4584dBwcHsTrj 26eJyaOrq/vs2bOamhqBQHD//n2EUEVFBdPYGRgY4ItLdXX1PXv2CIVCymMt7l5lcQsZ7q1E hxghNHny5FmzZgUEBODjgmHYvXv3vLy8aDsnj8iECRNoBc2fP3/gwIH79+/Hn8njuwHy8vJo B4VwskAguHXrlo+PD/mqp6dnamqqjY0NbVv0v+GBEOLz+UR04S5ljy6yD0VHjfvcJKDEmBQ9 INYIYQpFsiv09fVZBpTLfGTRgeJwckpxdHTU1tZeuXLljRs38vLyAgMD4+Pj+/Xrx3GiUSYd lwBg6ZmiJwGTkuyzgCmLMpUzjTuTdBavSqcYGdrYJrvo0aNHHDOSqGNZApI225CRNPNQGD16 9LRp086ePevm5oYQcnFxuXv37qJFi8h1JE0I3G+XnUUWm0EwDGtubt66dauGhoadnd2mTZuW Ll06b9686OhookJUVJSuri5CSE5ObtWqVfg27J9++kldXV1RUdHPzw/fJe7v748Qmjhx4pMn T+rr601NTRFCVlZWUVFRNjY2KioqAQEBKSkp9vb2CCF3d/fCwsJHjx7p6+vLyclduHChoaEB 3/Y/derU3NxcipIODg7Dhg1zdnb29vZetGiRr68vhmFMUkR1Y6r5+PFjfBSPHz/e1NR05coV BQUFXV3d0NDQ8vJyPEocHR3z8vJonUCxmtZXosow8e7dO0tLS2KLFpPOL168wH3o5uaWn5+P YVhqaqqGhoaSkpKdnV1MTIyKisqKFSuKi4tp9amoqNDW1j59+nRkZKSTkxOxO5qAu1eZYoMM 91a0Q4xTW1u7bNmyOXPmBAYGurm5ETs6aTsnjwiTerGxsXp6eqqqqnZ2didOnFBWVnZ2dn7x 4gVFeV9fX2NjY3d3dx8fnzVr1sTGxoqOmoGBwdu3b5nGlKxMWFiYmpqasrLyjRs36urq9u7d ixCytbXNzs4W60amUeM4NwkoMSZFDxhzhGCsoUh2BdOAcp+PTDqQpVCyDa4e/mJeXl5+y5Yt +GY9LhPt5s2blEnHJQBYHEXJG2RolcSYZwFTFr148SJLdmUKOVrp7F6VVDFKemeKbULovXv3 uGckimOZApIl25CRKPOIEhISsn37dvy4vb3d0tKSz+cTVyVNCNxvl51HVqsNguLi4pSUFDw1 iFJYWNjY2MjeQ2lpKbGtl8/nFxUV4cft7e0sGZkLDg4OU6ZMaW9vLygo6OjoIMq5S+kSfWid QLaapRoXamtryafcdW5pacFnPp/Pb21tZVG7o6NDKBS2tLTk5+eL1pRUrmj/3KG0YhpigtbW VkIrdigjwqRecXFxW1ubQCAQvbuTqa6urqyspL1UVVW1bNkyiZRhgcWN7KMmkf8pMSZFDxhr hLCEIsUV3AdUIh3EOrykpIQy4lInB7EBwNIzu56iSuJ00mkUmMZdVLpYr0qtGEtsE0IlGiCK qrQBKTbbkJHaNIFAQHYv7dRjQer7SOfhYb3k699lwYIFC6qqqkS/CQf4YOiNQ/zdd999+umn U6ZM6WlFgJ4BAqCX0huzTXfyj/7F+dra2l70fbSAFPSiIQ4LC9PR0bGzs8vKyoI7zT8QCIDe Ti/KNj2C/Pfff9/TOvQMISEhv/76q5ycXFtb27Bhw5SVlXtaI6CL6V1D3K9fv1evXhkYGJw/ f75LPm8G9C4gAHo1vSvb9Aj/6DcpAAAAAAB0A//oNykAAAAAAHQDsNoAAAAAAEC2wGoDAAAA AADZAqsNAAAAAABkS9f/KlsP8vz589u3b9fV1Z0/f55jk5CQEH9//8jISAUFBVmolJ+fHxER ERERcfLkydGjR8tCBBNSeKPbSK5o62kVgPcO28Hd9EGM+Pj4sLAwBQUFb2/v7pEolnfv3t2/ fz88PNzBwWHBggVd2LOsU9x7zvucBtnp/oGLi4tLTEzEv7xcTU3t888/l+7XQJn4EFYb2N8/ NqukpBQcHEz+eV+xEF+3LCPdlJSUCgoKHjx4cPz4cRmJYBEtqTfeQzAM8dvbFftK86OU/3A6 OjABnw+uE0VVVfXq1aszZ87saUX+B4FAcPXq1RkzZjBVwJh/VZsFiVKcdCJkinQqdeam0J1Q rCOfyvreJMr06dMHDx5samqqra1dUFDQv39/WiWlpte/SWlraztw4AB+bGpqamhoKFFzZ2fn 2NhY6X5hmQuDBw+ePn26jDpnRwpvdCdnz5zd/jceHrsOHjwYfi+8o+O/U6umptbb+9iaNf9y 3+Lu7r4lOVnin1d9nzly5KjsOq+trTtx4sTXX3/tscvDw2NX/JP4ffv2d6F0mSrfDVhYWIj9 zcxuZsCAAbNmzWKpQE50EsE9xUktQnZIp1InbwrdBsU6yqms7020GBsbI4QMDAyIpUYXRkXv frYhFApdXFzIX9/2vi3MUY+q9B56g2Djpo1xcU9KS0tWrFgh4Atq6+ru3r177txZd3d3hFBt bd3OHTu+Wv3Vrl0ecnJyb9++PXbsWFVV1fz5X/S04l1DYWGhjHru6Og4fPjw559/5uHhgRBq bGj0/P57TU3NLpQuO+W7jfdwarCoJJroupxuECEp0qnUK24KSETP98T/uK/k5P7zGKJrtZLJ aqOhoeHMmTPV1dVPnz4dP378Dz/80L9//6ioqH379vH5fB8fn5kzZ7a1te3bt+/PP//08/Mb PHiwaJPs7OyrV6/+9ddfa9eu3bJly6xZsy5evEgRdPny5fDwcC0tLQ8Pj/nz50+dOhUvj4iI 8PT0zMnJWb58+YULF5hUKi0tDQ0NDQ4Ovnv37tChQ9PT09klspuQkZFx9uxZMzOzp0+fGhsb f//996JRHhYW5unpOXny5PPnz2dnZ58+fToxMdHf39/GxoZWQ4TQgwcPHj58aG5u/vTp09mz Zzs5OYk6XCAQnD59uqGhoba2NjMz89SpU2ZmZsRVUW8ghGi1TUhIuHLlSmlp6bfffrtz586s rKyvv/76xIkTCCEMw7y9vSsqKhoaGkpLS21tbQcOHLhixYpBgwYxac6OnJycnJwcjycnJyen 2FdRR0f766/Xum5wraurU1dXDwoKXLR48bRp0/DKWlpaBw8e2rx585QpUzQ0BiYnJ5eUlBgY GIwcaRgREVFSUjJ48ODJkyePHj2KcMivvz5PS3tRVlbW2to2evSolStXDRjwH61epr/M/TMX IWRra6urOyQuLjYtLU1ZWXnOnLn6+sPZm9+4cQMhnqmpaUJCgr7+8Dlz5sbGxmZmZn788cfW 1uPJBqanp6empla+qRyqN9TObpqR0X/+wGpra3ud/7q9vf2PrD+IyqNGj+7TR55Lc7HKFxQU 9uvXj3hNoKKqsn7duqvXrnKRzu439ua5uX++fJmurKQ8Z+4chFBra9vdu2EIoWnTpuvoaBOV 6+sbIiIi/vrrL2UlJQtLy/Ly8o8+Mh07dixtkDAFtmj0JiYmMoUuCxcvXjx79mxdXd3q1asP HjwoLy/PMZhZJjLthGXqFsOwY8eONTY2KioqNjU1MekpmugEAoG3tzeGYfX19b///vvmzZvn zZsn2pCS4lgmuKgIWp0pSXLQoEG2traUnMmiG0saER1TjiqJ9RVeTpsGJcq6HGODY9vg4GCy nrm5ueTTkSNHchw4Fq+mpqaKvXeww+RMKZHFT70tWbLk9evXGIa9efOmf//+mzZtwsv37t3L 4/HKy8vx0zNnzty7d4+pSWZmpqmp6ZAhQ3x9fa9evXrq1ClaWTY2Ng4ODsTpzJkz9fT0goKC Wlpajh49ihBKSEhgUqmoqGjz5s0IoZKSEgzDuEhkMWHYsGFeXl4YhuF/+RE/+hweHo4QevXq FX5qaWk5b948/DguLg4hFBMTw6Qhn89XU1OrqanBMCwrK8vHx4fWCZs2bbp06RJ+PGnSJAsL C3ZvMGnb0tIyffr0QYMGXbhwobm5+eDBgwihly9fYhh24cKFcePG4W1nzJgxcuTIuLi4pqYm luFmIam8Nam89UhIpOuJAPwY/zdz3Z6gJ78nlL4z+nRJXFET+VJSeev6Y/77L91KKm8NjM1w P3V10rKNZl+u3uv/S9CT34/dfDRxqds3gXfwmpF/Vq/87tSFyNSovOoH2ZW7Lt6YuW4P0c+P yX+c+OXxnE3feV65O3PdnrVHLwbEvvS48NO2sz+KbX7il8emc51nrttzJjzJafcxq0VfO+0+ 9u+HzyY4bQhOySVE/OvQ+Znr9py9//TntL/+7078hCWu3waF4ZfuZZav+v70sGkOq74/TfyL eV1LtpSluVjl774qHfPFqifFzURviWWtJ36J5SKd3W/szX9O++vYzZgxX3yF14wrajrxy+NP XDz+/fAZ0fzRX/UWji6bT17xi0nzjX7u9kOA1qTPL0Y9x69yD2zR6GUJXVqsra0NDQ19fX3T 0tLwX9k+ePCgRMFMO5GZJixTt9u2bfPw8MCPb926hed3WnGURLd8+fJ9+/bhx/Hx8Twe7/r1 66KtKCmO3UsUEbQ6U5LkunXrRHMmi24saYQ2I3FRSayvWNKgRFmXi3SJ2lL0JJ9KNHC0Xq2r q+Ny7xAFIWRjY8PkzM7Q9auNxMREAwODy38zYsQIHR0d/NKbN2/69u2LL3sxDFu8eDG+EYap ycKFC01MTNjFiQaWvb09flxaWooQunjxIotKISEhxIhykchkAoZhe/bsSU9PxzCso6MDIRQQ EICXU1YbU6ZMIZLU8+fP8STFpGFDQwOPx8MnIYZhGRkZoiqlp6dramoSamRkZNy5c4fFG+za uri4GBkZ4cevX79GCAUHB2MY9umnnzo6OuLlfn5+CgoKfD4fYx1uFmhXGyHPcj+at+pJcfON 56+nrNxCWWoklbceuxmz6vvT+PGlR+mDbeeGpuaR72Rj56++9bJItGFSeavJHOeE0nfkknXe fiNnOvlGv6Ctz9Lc2ml9VF5NUnnrlYTMCUtcE8tak8pb3X4IIBYE5yOeTV+zEy/H/0XlVZvO XXn/jzdECXFXFv3HpTm78v86dN7aaf3mk1fOhCf9nFYgWoFFuli/sTRPKH1HubR03w/k1cbl +FfT1+wkV/jq+zNMqw2WwKaNXqbQpcXa2pqIZ6FQaGZmpqGhIVEw005k2gnL1G1+fn6fPn3w mxCGYZWVlRxXG2lpaQihzMxM4qq9vb2uri5tQ0qKY/ESWQSLKyhJknLKrhtTGsEYxpSjSiy+ wpjToERZl6N0idqyrDYwSQaO1qtc7h20yG610fVvUtLS0nR1da2trfHTe/fuob83tWprazs5 Ofn7++/atSsrK2vcuHH4+yGWJurq6pIqQLy/wN9Vt7a2svRPedkhViKTCQghLy+vmpqagIAA gUCAEOLz+dx1ZtJQRUVly5Yte/fuDQ8PP3/+/Lhx40TbJicn6+npEWqYm5ubm5uzeINdW7JD VFVVEULt7e0IIT09vfj4eLxcXV1dXV29T58+LJpzfFealJRUXFwsFArq6uoEAuGePbv79JFv bW2R70MTmQp9FMhvEK0srYYN0yNO+/XrO2XK5JcvX86e/SlC6Nmz1IT4+JLSUoRhWlpazc1N QmEH4SWclSudx46l/4gXe3N5eXmEkIqKyoABA3BDlZVVcEchhJ49SzEyNEx99ozc4aBBg3Jz cyZOnCjWJxybsyi/dq1LQUFhenpaclJydk62vHyf/fv36ejoiBUt1vBOYmg4sqam5scfr5ub m2tqaKioqqxbv46pMktg00YvU+gyQey/k5OT+/TTT318fB4+fNiZYEYI0U5YpjkSHx/f0dFB 7Ffl7uTU1FTCRhxbW9tHjx6VlpYOHTqUUlk0xRHHLF5iz5nkJEk5ZdeNKY0gDvmzM6mGNg1K lHU5SpeoLUedRU8pA0frVS73jm6m61cbFRUV1dXVTJ/TdXNzu3bt2uPHj6Ojo/H9gGKbyFol SaE1ASEUGhoaGhoaGBiooaGxYcOGrtLw5MmTY8eO3b1796RJk4KCgpYtW0apUFZWhi/YJUJS bT08PBISEry8vJYtWxYcHHz27FmxmnPBzMzsy/nzeXJySkpKamr/yVA6OoNLS0swDFHSSHFJ sbb2f2+Z/URemvbt26+5uQkh9Msvt9LS0laudB42bLiCgkJjY8Pu3btFpTP9TiPH5uT5Tz6u q6tTUFB4/ddrcuVx48wHDx5MKmDMNdyaMyrf0dHR0dFhYKBvYPCf21hMTIyfr9+3330rVjpH w1mUZ0dOTs7HxycyMvLhw4e1tTXV1dX9+vbbvmMHoSoZlsDuzFyjRV9fv0+fPq2trZ1PFKIT lmmOFBUVdXR0NDU1ke/NXMDvxGVlZXp6/1lt40vJLvz8gtTzml03pjSCOIxpl98mJMq63KV3 pq10MHlV7L2jm+n6T8COGDEiNzc3MTFiFnJVAAAgAElEQVSRKMnIyMjOzsaPbWxsrKyszp07 V1dXN2TIEC5NxII/eZNaJUmhNSEnJ8fZ2XnHjh0aGhrcFRYKhewa1tfX//bbby4uLnl5eZ98 8snWrVtFjR01alRVVdXDhw+JkqSkJOIZBi0SaYtjYmKyYcMGXV3dxMTE06dPL1myhF1zjt2q qqoO1Rs6ZIgusdRACCkrKw0fPvzp0//5yKtQ2BEVFWVjY0OUZL561d72P3+WvXz5cvRoY4TQ vXv39u3bZ2JioqQ0QFFRQVlZmc8XcFSp8831h+sP0R2yTIThw4cTdVpaGAeIS3MWcnNzT508 RS6ZNMmm5H9v20zSORrO1FxOTo6yEOn4O8JxCgoKU1NTFyxw2LXLw8vLy8/Pz2nJkp9v3qTt jSmwpYhesVRXV0+YMMHY2FiiYBadyLQTlmmO4E81KHHOAiHO0tISIUTu8O3bt/r6+lpaWhy7 EitC6nnNrhtTGmEZU+lUEntTYOlQokGk9ClpW4qeXNQWhdarXO4dHJG6IYWuX20sWLBAVVV1 8eLFDx48KCsrCwkJ8fPzMzExISps3Ljxzp07Dg4OYpu0traKfR+hoqKSn5+PECopKUEI8fl8 4vkS/p1oAoGARSW8DtGEi0RaE3JycoRCIf7eMSIiAiHU2NiId/7u3TtEyke6urrPnj2rqakR CAT3799HCFVUVLB4ICAgACGkrq6+Z88eoVAo+tjQ0dFRW1t75cqVN27cyMvLCwwMjI+P79ev H5M32LUVCAREbJGd4+XllZ+fP3Xq1Dlz5pCfybP49vbt21u3bhXrTFqcnVcGBgb89ddf+KlQ 2HHu7NmRIw2Jj2YghNr5/B98fBobGhFCHR0d169fVxowAH+5oKGhUfT3pzQrK996en7f2NjI XXonm8+dO/fR48evXr36r6rt/EePHj969IgoGThwYHl5OWFdSkpKQ0MD9+YsqKqqJSUn45MC JyoqytzcjFyHSTpHw1mUV1NTLygowI8fPnwY9ySO3LDl3bugoKDKyrdESUVFubKKCq0hTIHN FL1MocsEMSUFAsGtW7d8fHzE5i4ytBOZdsIydTt//vyBAwfu37+/vr4eIfTixQuEUF5eHq04 cqKbPHnyrFmzAgICcAMxDLt3756XlxdtQ4orWLxEFsHiCkqSpJyy68aURpjGlKNKLL5CzGlQ oqzLUbpEbSl6Uk65DxytV5nuHexpuaWlBSFEfmFN0apTdMnuDwpRUVG6uroIITk5uVWrVjU3 N5Ovvnv3ztLSktj8xdTkp59+UldXV1RU9PPzq66uZpLl7++PEJo4ceKTJ0/CwsLU1NSUlZVv 3LhRV1e3d+9ehJCtrW12djatSikpKfb29gghd3f3wsJCjhJpTaivrzc1NUUIWVlZ4X+Cq6io BAQEvHjxAhfh5uaWn5+PYVhqaqqGhoaSkpKdnV1MTIyKisqKFSuKi4tpNayoqNDW1j59+nRk ZKSTk9Pt27dp9UlNTcW/LE9eXn7Lli0CgQDDMBZvMGn76NEjfX19OTm5CxcuNDQ04Hv1p06d mpube/LkSXyzAs748eNv3brFPtzOzs4DBgxoaGgQVTipvNVp9zHjz1eMnOlk7bTe2ml9VF41 Zcvh2ftPxy1wsVu9/ctth8Z8sWql5+n4kv9uV7z0KN1p97FD1yPGzl89camb6Vzn1QfPPfqr Hr96LTHro3mrZq3fM33NzglLXC89fmnusGb8onX4BzfwTZQjZy42neuMS99w3J8smqW5tdN6 Xdt5Vou+vpb0x+2M4qFT589z/z6pvHW3781Rs5d534hJ+nvH6+SV7pOWuTnuPDpp2caP5q36 16Hzt14WkreCmn/5r3nunjPX7RnzxaqV352696qMuMrSXKzywSm5E5e62Tq726/dtXi398Sl bp9v/CbmdR1lIyqtdHa/cVE+IPal6dyVn7l9Y+6wZp7793M2fTfmi1Vrj1z4z6g9fjl+0bop K7fMWOvx5bZDVou+nrHW42HOW9pdokyBTRu9K1asYApd2inj6+trbGzs7u7u4+OzZs2a2NhY 9mCm1U10Ij9//px2wjJ1Gxsbq6enp6qqamdnd+LECWVlZWdn5xcvXoiKIyc6DMNqa2uXLVs2 Z86cwMBANzc3pr2llBTHMsFFRdDqTEmStDmTRTemNMKUkbioxO4rljTI1CFT1uUiXaK2FOvI pxINHK1XmTRhSctxcXFr1qxBCPF4vAMHDuCfbKAo2Rl4mMy+GLWoqEhDQ4P27TL+nQoSNWGh rKxMS0uLy5fJS9c/LaImCASC8vLyYcOGIYT4fH59ff2gQYNo27a2tlZWVg4fPlwgEAiFwr59 //vzEBQN8UFqb28vKysbOnQouaYopaWlAwcOHDBgABf9uWuLc+rUqfHjx+vo6FRXVzc1NVVV Vfn6+sbGxhLPWkR9KxAIGhsbBw4cKNobx99JiYh4GBx8fenSpTNmzOjfv39Hx3+3K/6R9UdU VNSWrVswDOGf9ZKT+5+nPgKBsLi4SFFBcagedd8cFzrZHKexsamiomLw4MEqKjQhJxAIioqK lZSUtLW1aTe6sTdnoq6uvq6u1sDAoKLiTWVlpa7uYNoH7EzSORrOojx+SVd3sOi3ETQ3N7e2 tmpqatbW1lVUVAwapEnWjel3UkQDW9LoZaKmpkYoFIr6h2OiEJ3I7BOWqduSkhJtbW15efm2 tjaW+Sua6Nra2iorK3E/dAmiIqTOmbS6saQRpjGVTiXuNwXRDqUbROnaUvSUSG0CWq8+fvwY ISSqCUtaZkI6rUSR4WoD+GCIiYn59ttvKS+Yvby88D8UpIDLauPX1F8DAwMnTJzQ1NSUk5Mz WGdw/uvXu3Z5fPTRRy0tLa9eZcbFxW5YvwEhNEBJSV6+138HP9Btv8oG9AhdnkYA1Ku82ru/ uRzoHt6+ffvrr7/u3Llz9uzZSkpKZWVlz58/X7x4sUyFWlpZnrc+TzzMKCsrV1VVVVZWQgiF 3QnLzMpECB0/cRwhtG7devJHYQEAeA/pkTTywdOLvArPNgBO3L9/Pzo6OiMjY/jw4R9//PG/ /vUv9tc67MAvzgOiwLOND56uTSMATm/xKqw2AAAAAACQLfC2GwAAAAAA2QKrDQAAAAAAZAus NgAAAAAAkC2w2gAAAAAAQLb801cbz58/379//8aNG3takfeF/Pz8c+fOzZ07Nzc3V9ay+Hy+ j4/P7t27Z86ciX8XDUAQEhIyY8YM8ndCM7krNTX14MGD5O/RB2QH93GhAKmGHVHHdhswg7qH nl9t9MiHYgihSkpKwcHB3XBnlTVd5UYlJaWCgoIHDx50w7R3c3PT0tI6duzY8OHD09PTZS2u O+n8cBDfi0+UMLlLU1MzMjIS/5UNQNZwHxecDy/V0CKLgJcFtP3DDOomOvnN552ktbXV09Oz Z4Xa29vPnDmzm3XoWrrWjffu3UMI4V+SLzuampr69u2bkJAgUyk9giyimt1dGzdu1NPT61qJ 7w///ve/ra2tra2td+/ejZccPXrU+m8WLFhAHMfFxWEY5uDgQJS8e/cOwzBbW1uiZPXq1ZT+ 2a+ywz4uH16qoaVH0rgUsOj5Yc+g94Se/C5RoVDo4uJC/rm5HhEq+quqvYsud2P3OKSsrKyt ra23O18UGUU1u7s+PDeSWb9+vZ2d3ZEjR2JiYvLz8w0NDXfv3r1r165Vq1bt27fPxMTkl19+ efbs2fHjx/Fvnv3555+rqqrmzp377Nkz/Neq4uPjExMT/fz8rl69Kto/+1V2WMblw0s1tPRI GpcCdj0/yKF53+j6Nynp6enbtm1zcHAIDw83NDTcsGEDQqihoeHw4cPbtm2zsbHZuHEj/rO2 ly9fDg8Pf/XqlYeHR0JCQlhYmIWFBf5eMzs729XV1czMLCUlRbTDhISEtWvXfv7558nJyba2 turq6h4eHoQCDx48cHd3v3TpkouLy40bNyjqUYQS5RERERMnTlRTU3N1dcVLaHWmIBAIfHx8 PD093d3d7e3tf//9d4QQkyG0zhEtoZXLYjKTRQihqKgoa2vrcePGxcTEIITa2tp27Ngxf/78 iooKhFBGRsbatWtPnz69dOlSfMlPsY7FEO7+OXz48KFDh/Av1g0PD8fLQ0JCDh48iBA6e/as h4fH8+fPKQ3F6pacnOzq6urg4HD//n0rKytNTc01a9a8e/eOpbmoq2mrpaSkuLq6TpgwITs7 29HRUUtLa+HChQKBICgoaPLkyRoaGj/88AOhhqgTRIeD1lG004SgtLTUx8dn/PjxpaWlXNxF 0NTU9M0330ydOvXy5csVFRUsYcM0NA8fPjQzM7O3t//jjz9yc3PnzJljZmbm7e3d3t4uEAg8 PDwWLlzI5/PZ5yATTELZvSEnJ9enTx95eflvv/320KFDeIm8vDxRjh/Ly8vj9wx5efk+ffrw eDzihzHxErwO+dcyuVyVely4pxrEYTaxBDzHaGeqyT3guaRx2mrs4yvqWPYcjljzIVOMseRJ MtxnEJMsmc6g3k2XPy3JzMw0NTUdMmSIr6/v1atXT506hWHYkiVLXr9+jWHYmzdv+vfvv2nT JryyjY2Ng4MD0dbS0nLevHn4cVxcHEIoJiZGtMOWlpbp06cPGjTowoULzc3N+IR/+fIlhmF8 Pl9NTa2mpgbDsKysLB8fH1ENKUJnzpypp6cXFBTU0tJy9OhRhBD+XJRJZzKbNm26dOkSfjxp 0iQLCwsWQ2idI1pCK5fFZFGLyOzdu5fH45WXl+OnZ86cuXfvHn48bNgwLy8vDMMKCwsRQsQP CuNzBn+TwmQIR/8sX7583759+HF8fDyPx7t+/Tp+iqdm/NG3KEy6EeTk5JiYmGhra/v7+xcX F58/f15OTm7dunUszUVdTVutra1t+fLl/fv39/Pza2trw9/mzp49OyUlRSgUHjlyRFFRkfhx bVonUIaDtg7tNCEoKiravHkzQqikpISLuzZt2oQ/By4rK1u1alVRURFezhI2LEMzffp0IpJv 376NEMrIyMBPT506hf90NXtAMsEklN0bGIZlZ2c7OztjGDZx4kTiR+SdnZ3x3w3/+eefd+7c Sa5fVVVlbW1NLklMTMR7oIX9KoGk48Ix1WAcZhNLwHOMdqaa3AOeYxoXrSZ2fMmO5ZLDpQts ljwpxQxikSW7GdSrkcm+jYULF5qYmBCniYmJBgYGl/9mxIgROjo6+CXK8E+ZMoW4t+HTGL+3 UTrEMMzFxcXIyAg/fv36NUIoODgYw7CGhgYej4fPKAzDiDEmI5oC7O3t8WN8ZX3x4kUWnQnS 09M1NTWJzU0ZGRl37txhN4TWFnIJi1wmk0UtIvPmzZu+fft6e3vjp4sXLyYU3rNnT3p6OoZh HR0dCKGAgAC8nLzaYDKEi3/S0tIQQpmZmUSJvb29rq4uuTemNM2kG5kvv/zS1taWOHV0dFRQ UGhvb2dpTnE+UzVPT09lZWWimq6uLvE6H8/FT58+ZXECeThYHCUaCWRCQkIkXW388ccfmzZt am5uJl+iDRv2ocH/msSvtre39+3bl9gwsXz5coFAwNIzkzmYuHhg9wax2ggPDyeWBd2/2sAk HBcuqQbjNpsw5oDnGO1Y5wKeYxpnqsY+vmTHcsnhmFSBLXa1wX0GYazxLKMZ1NuRyb4NHo+n rq5OnKalpenq6lpbW+On+CZEDMO4vyqjdIj+9zWbqqoqQqi9vR0hpKKismXLlr1794aHh58/ f37cuHEc+8cPNDU1EUKtra1cdE5OTtbT0yN+pNTc3Nzc3Fw6W4gSFrlMJrOjra3t5OTk7++/ a9eurKyscePGEQp7eXnV1NQEBAQIBAKEkEQfQuHin9TUVEJVHFtb20ePHpWWlg4dOpS9fy66 8Xg8whaEkL29/a1btwoLC42MjJiaU5zPUo0sSE1NjTjGf+6ovr6exQkcHSUaCRTr2BwkAv6n 0rfffjtgwACmfoiwYR+aL7/8UktLKygo6MSJE5GRkSNGjLh27dqRI0f+/PNPQ0ND4l2DpAHJ LpTdGwRz5849cuRITk6OsbGx2Mrs1NXV5efnjx8/XqKrnXzBL5pqEOcMyRTwHKMddS7gc3Nz uSjJYgv7+BL9cMzhUgQ2i3Qk4QxCrPEsoxnU2+mOXaIVFRXV1dVjxozpBlkIoZMnT44dO3b3 7t2TJk0KCgpatmyZFJ1w0bmsrAz/A6ULkYWv3Nzcrl279vjx4+joaHd3d6I8NDQ0NDQ0MDBQ Q0ND9E1q5/XEc1lZWZme3n9+Dl5HRwchpKioKLZ/KXTT0NBACGlpaXFv3hkPIG5O6Lbg79+/ v7u7+/bt262srD7++GP2yuxDo6io+NVXX129evXo0aNXrlwJCwszNTWNjo6mxI+kdCYeyHh6 eh48ePD69etEiaKiImU9yufz+/QRk9wyMjJ++uknptUG+9WuRbogIQKeexjLespzr8aO1Dm8 MzEm0QxilyWjGdTb6Y7v2xgxYkRubm5iYiJRkpGRkZ2djR/jz/QIiFOhUCiFrPr6+t9++83F xSUvL++TTz7ZunUrpX9aoZLqjDNq1KiqqqqHDx8SJUlJSfgfK1IbwkUuLSwW2djYWFlZnTt3 rq6ubsiQIXhhTk6Os7Pzjh078JzFpWeyIVz0tLS0RAiR67x9+1ZfXx9fELDAXTcyxcXFxsbG ampqHJtLJ4UMixMIp0k9oFKwc+fOmTNnLl68+M2bN+w1xQ7N119/XVlZ6enpOW7cuNGjR8+e PfvChQsVFRX6+vpSqyd1PFCYPXt2UVHRH3/8QZQMGTIEfxBNUF5eLrbbmpoaJSUl6a5yR2yq QdIGCR7wFRUVHMO4kwHPMY13PuA55nBaxMYYe1fcZ5BYWbKYQb0dmaw2WltbyX9qLFiwQFVV dfHixQ8ePCgrKwsJCfHz8zMxMUEIqaio5OfnI4RKSkoQQrq6us+ePaupqREIBPfv30cI4Z+e oHSIEBIIBETctLW1ob+fQbW2tgYEBCCE1NXV9+zZIxQKRZ98UoTy+Xzi+RXelUAgYNGZwNHR UVtbe+XKlTdu3MjLywsMDIyPj+/Xrx+LIbS2kEtY5DKZLGqRKBs3brxz5w75y/JycnKEQiH+ EjciIgIh1NjYiHeLb3TH1xZMhnDxz+TJk2fNmhUQEIDriWHYvXv3vLy8CKsRw5NDFt0o1NbW 4gcCgSA4OBjfacXSnOxqlmotLS3krCQQCAg98UfQ+P9MTiAPB4ujRCOBDGWIWdyFEOro6Ojo 6ODxeFevXuXxeAsXLiQ+6UcbNuxDgxAaPXr0tGnTzp496+bmhhBycXG5e/fuokWLyEKZAnLv 3r07duwQXWSLjQfu7/K+//77AwcOEKdWVlZ//vkn/h4d7/nUqVPz5s1j70S61YZE48Il1SBu swlHNOA5RjvqdMBzTONM1cSOL+FYLjkcSRXYLHlS0hmExMVzZ2YQQuj27dtbt25lcVevpMt3 gvz000/q6uqKiop+fn7E1v2oqChdXV2EkJyc3KpVq4htOP7+/gihiRMn4rujU1NTNTQ0lJSU 7OzsYmJiVFRUVqxY4ePjQ+nw0aNH+vr6cnJyFy5caGhoWL9+PUJo6tSpubm5FRUV2trap0+f joyMdHJywnf/UiALDQsLU1NTU1ZWvnHjRl1d3d69exFCtra22dnZTDqTSU1NNTIyQgjJy8tv 2bKF2P5Da0hxcbGoc0RLaOWymCzqRlHevXtnaWlJ7A/FMKy+vt7U1BQhZGVlFRUVZWNjo6Ki EhAQ8OLFC3t7e4SQm5tbfn4+kyEsY0qmtrZ22bJlc+bMCQwMdHNzu3z5Ml6elpbm5OSEEJo/ f350dDSlFZNulGoODg7Dhg1zdnb29vZetGiRr68ve3OKq5mqPX78GM+hx48fb2pqunLlioKC gq6ubmhoaHl5OZ47HB0d8/LymJxAGQ7aOrTThCAlJQUfBXd398LCQnZ33b1719jYmMfj+fn5 NTY2rlu3DiE0fvz4sLAwlrBhGhqCkJCQ7du348ft7e2WlpZ8Pp+4ytLziBEjEEKRkZHc44Hd G+fOnTMxMRk4cKCFhcWBAwfwwunTp+vo6OC7RDEMS0pKMjY2njlz5ooVK8zNzbdt20ZMRgzD Jk6caGRkhPdAMHTo0OPHj4u9KvW4YJxTDcZtNtEGPMdoZ6nJPeA5pnHRauzjS3Fsamqq2Bwu XWAz5UnpZhDGHM84Us8gDMOcnZ0HDBjQ0NAganvvpVu/S7SwsLCxsZFSWFpain+OAKelpaWw sBDDMD6f39raKqmIjo4OoVDY0tKSn5/P0pwiVFKdKZSUlIhmh04awkUuGbEW1dbWUkr4fD7x Qa/29va3b9/SNmQ3hIuera2thCCOcNHNwcFhypQp7e3tBQUFHR0dkjbnXk0sok4QHQ5JB7R7 YBkagUBAVlg0fphob28/duxYcnKyFEK5U1ZWlpKS0tLSQpTw+fzff/89OTmZXNjjcE81mLgg YQp47mHcJQHPJY0zVeMCxxzODlOMSTQcnZQl9QzCMIzP5+OfAf6Q4GE98TMlANB5FixYUFVV xfJFPUCPkJubGx4evn379p5W5EMDAh7o1fT8r7IBgHTU1ta+/9+X/A9EKBTCUkMWQMADvRpY bQC9kpCQkI6Ojn79+v373/8mduAC7wP45gCga4GAB3o78CYFAAAAAADZAs82AAAAAACQLbDa AAAAAABAtsBqAwAAAAAA2QKrDQAAAAAAZAusNgAAAAAAkC2w2gAAAAAAQLbAagMAAAAAANkC qw0AAAAAAGQLrDYAAAAAAJAtsNoAAAAAAEC2wGoDAAAAAADZAqsNAAAAAABkC6w2AAAAAACQ LbDaAAAAAABAtsBqAwAAAAAA2QKrDQAAAAAAZAusNgAAAAAAkC2w2gAAAAAAQLbAagMAAAAA ANkCqw0AAAAAAGQLrDYAAAAAAJAtfbq8x8jIyKSkJAzD8NPBgwePHj16woQJ6urqXS4L4Mi7 d+/u378fHh7u4OCwYMGC7hHK5/PPnDlTWVn54sWLffv2zZgxg7ba8+fPb9++XVdXd/78+e5R 7P0kPz8/IiIiIiLi5MmTo0eP7ja5ISEh/v7+kZGRCgoKkraVTuceiUYAAHqWrn+2MXv2bB0d ncOHD79+/Xrp0qUjRow4c+aMnp7ehQsXulyWdBArod6ORIYIBIKrV682NDTITh8Kbm5uWlpa x44dGz58eHp6OuUqobySklJwcHBubm63KSYjOhlXSkpKBQUFDx484PP5XaUSF4RCIYZh0ikv tc7dH40AAPQsMnmTgv+VM3LkyDFjxsyZMycsLMzc3HzTpk2ZmZmyECcRbW1tBw4c6GktugCJ DBkwYMCsWbNkqg+F5ubma9eujRw5EiEUGBi4Y8cO8lWy8qampoaGht2pmyzofFwNHjx4+vTp XaSOBDg7O8fGxioqKkrRVjqduz8aAQDocbr+TQpCSE5OjnI6ffr0p0+fpqamjhkzRhYSOSIU Cl1cXJqbm3tQhy5BCkN4PJ7s9BGlrKysra2NVqio8t2sW5fTVXHVG/0gnc690VIAADpDN+0S ffv2LULIwsICIZSRkbF27drTp08vXbrU09MTf4Sbnp6+bds2BweH8PBwQ0PDDRs20FZLSUlx dXWdMGFCdna2o6OjlpbWwoULBQJBUFDQ5MmTNTQ0fvjhB0JoQ0PD4cOHt23bZmNjs3HjxpaW lsuXL4eHh7969crDwyMhIYG2Dq0yCKEHDx64u7tfunTJxcXlxo0bFANpm4h2npyc7Orq6uDg cP/+fSsrK01NzTVr1rx79w7vRCAQHD58+NChQzt37pw9e3Z4eDhT5xRDaK1ACGEY5u3tvX// /gMHDnh7ezONDq2rxZrMonBISMjBgwcRQmfPnvXw8Hj+/Dm5lego4EREREycOFFNTc3V1ZVp BGn1FwgEPj4+np6e7u7u9vb2v//+e1hYmIWFxcaNGxFC2dnZrq6uZmZmKSkptM7kOHYJCQlr 1679/PPPk5OTbW1t1dXVPTw82C3iHhi0dtFWk2iwxAoqLS318fEZP358aWkpQojFRlEniyrM 4nbEHI1MSt68eXPkyJH5+fm0zgEAoJeByYCYmBiE0DfffIOfJiQk9O/f38HBoaOjA8OwYcOG eXl5YRhWWFiIEHry5AmGYZmZmaampkOGDPH19b169eqpU6doq7W1tS1fvrx///5+fn5tbW0v XrxACM2ePTslJUUoFB45ckRRUbG6uhqXu2TJktevX2MY9ubNm/79+2/atAnDMBsbGwcHB0JV 2jqiyvD5fDU1tZqaGgzDsrKyfHx8KCaLNqHtPCcnx8TERFtb29/fv7i4+Pz583JycuvWrcM7 Wb58+b59+/Dj+Ph4Ho93/fp1ps7JhtBagWHYtm3bPDw88ONbt24hhC5fviw6XrSuFmsyi8IY huErjLi4ONoIoYzCzJkz9fT0goKCWlpajh49ihBKSEhgsYvCpk2bLl26hB9PmjTJwsICwzBL S8t58+bhhXFxcQihmJgYWmdyHLuWlpbp06cPGjTowoULzc3N+HLq5cuXtBYRcOwcr4wv1169 eoWf0laTaLDEOrCoqGjz5s0IoZKSEgzDWGykdbKozkxux5ijkUnJW7dujRkzBr8EAEBvR4ar jVGjRn3xxRd2dnaWlpZeXl4CgQC/umfPnvT0dAzDOjo6EEIBAQF4+cKFC01MTIhOmKp5enoq KysT1XR1dVevXo0f44uPp0+fYhiWmJhoYGBw+W9GjBiho6OD/e9dgamOqDINDQ08Hg/P8hiG ZWRkiFpNacLU+Zdffmlra0tUc3R0VFBQaG9vT0tLQwhlZmYSl+zt7XV1dWk7JxvCJCg/P79P nz5Esq6srGRabdC6WqzJ7ApLutqwt7fHj/E/si9evMgyOmTS09M1NTWJrY4ZGRl37tzBMGzK lCnEbQ9XhrjtiTqT49i5uLgYGWgSluIAACAASURBVBnhdV6/fo0QCg4OprVIis6x/71zM1Xj PlgcHRgSEkKsNphsZHIyJrLaYHI7UzRyVBIAgN6OTPZt4CxZsuTQoUOi5V5eXjU1NQEBAQKB ACFE7Gbn8XjkT8myVCP3pqamRhz37dsXIVRfX48QSktL09XVtba2xi/du3cPiXxqgKkOj8ej KKOiorJly5a9e/eGh4efP39+3LhxonZRmrB0Tt7XYm9vf+vWrcLCwtTUVISQqqoqccnW1vbR o0elpaVDhw6ldM7Fivj4+I6ODn19fbycspmGDK2rxZrMrjCTLCaIYdXU1EQItba2sjiQ3DA5 OVlPT4+wztzc3NzcXKwsijO5jx1RBze8vb2di2mSds5SjftgcRTEckrYKIWTKTBFI0clAQDo 7chwtcFEaGhoaGhoYGCghoYG/hq7M9WYqKioqK6uZt+UyqUOwcmTJ8eOHbt79+5JkyYFBQUt W7as8woghDQ0NBBCWlpa+G2jrKxMT08Pv6Sjo4MQEvthASZBRUVFHR0dTU1N5AUBLUyuZjdZ aoU5wtGBZWVl+OOQLkSiwJBR50zVuA9WF1rReSczRaNMXQ0AwPuDTHaJYsyf3c/JyXF2dt6x Ywd+l+1kNRZGjBiRm5ubmJhIlGRkZGRnZyOE8EfQ7HUo1NfX//bbby4uLnl5eZ988snWrVuJ TqRQgExxcbGxsbGampqlpSVCiFz/7du3+vr6WlpaTCJwHZgE4X9HPn36lF1PJleLNVkKhUWV Z4GjA0eNGlVVVfXw4UOiJCkpqbW1lSxCKBRyUUlS0RTEWiRR57TVwsLCuA+WdFbQwuJkUWjd zhSNXagkAADvMzJZbeAfsiA+akEmJydHKBTiL54jIiIQQo2NjW1tbQih1tZW4nUJS7WWlhZy WhcIBMTTbPzZMv7/ggULVFVVFy9e/ODBg7KyspCQED8/PxMTExUVFXyXe0lJCVMdijL4aUBA AEJIXV19z549QqFQ9EkvpQlL57W1tYTCwcHB+F68yZMnz5o1KyAgADcHw7B79+55eXnRdo4Q IgyZMGECraD58+cPHDhw//79+KslfFNLXl4exxERa7JYhRHziwbyKCCE+Hw+URMfZYFAwOJA Mo6Ojtra2itXrrxx40ZeXl5gYGB8fHy/fv10dXWfPXtWU1MjEAju37+PEKqoqGByJsexEwgE ROzhehJqUyySonP095TBb9K01Xg8HvfB4uhAiiG0NjI5maIzQojJ7UzRyKLkixcv1qxZU1dX RxNAAAD0Orp8J0hkZOSUKVMQQkOGDLl48WJDQwP5an19vampKULIysoqKirKxsZGRUUlICDg p59+UldXV1RU9PPzq66uZqr2+PFjPBMdP368qanpypUrCgoKurq6oaGh5eXlbm5uCCFHR8e8 vDwMw6KionR1dRFCcnJyq1atam5uxjDM398fITRx4kR8Mz9tHYoyGIZVVFRoa2ufPn06MjLS ycnp9u3bFKtFmzB17uDgMGzYMGdnZ29v70WLFvn6+hKd1NbWLlu2bM6cOYGBgW5ubsSOTtrO yYbQCsIwLDY2Vk9PT1VV1c7O7sSJE8rKys7Ozi9evOAyImJNZlE4LS3NyckJITR//vzo6GjR hmTlw8LC1NTUlJWVb9y4UVdXt3fvXoSQra1tdnY2k10UUlNTjYyMEELy8vJbtmzB9yOnpqZq aGgoKSnZ2dnFxMSoqKisWLGiuLhY1Jkcx+7Ro0f6+vpycnIXLlxoaGhYv349Qmjq1Km5ubmi cSVFYLx48cLe3h4h5Obmlp+fT1tN0sES68CUlBRcqLu7e2FhIYuNtE4W1ZnJ7SzRyKTkDz/8 wOPxfv31V9pBBwCgd8HDuv1rvAUCQXl5+bBhwxBCfD6/vr5+0KBBUlcTS1FRkYaGhrKyMlFS VlampaVF/lUI0ToUcGe1t7eXlZUNHToU344qnQILFiyoqqp6/PhxWVnZ8OHDRZ+RtLW1VVZW 4oazQzGEyYqSkhJtbW15efm2trYBAwaI9kPrau4mc1eYRXkWxI4OTmlp6cCBA8kGtra2VlZW Dh8+XCAQCIVCiUZNItE43C2SqHNKNSkGSyIr2BF1sijsbmeKRlol3759y/HFHAAA7zk9sNr4 h4OvNijfAQUAAAAAHzDwi/PdTW1t7Qfw1ekAAAAAwB1YbXQrISEhHR0d/fr1+/e//01sWgQA AACADxt4kwIAAAAAgGyBZxsAAAAAAMgWWG0AAAAAACBbYLUBAAAAAIBsgdUGAAAAAACyBVYb AAAAAADIFlhtAAAAAAAgW2C1AQAAAACAbIHVBgAAAAAAsgVWGwAAAAAAyBZYbQAAAAAAIFtg tQEAAAAAgGyB1QYAAAAAALIFVhsAAAAAAMgWWG0AAAAAACBbYLUBAAAAAIBsgdUGAAAAAACy BVYbAAAAAADIFlhtAAAAAAAgW2C1AQAAAACAbIHVBgAAAAAAsgVWGwAAAAAAyJYPebWRmJj4 4MGDf6Z0AOhmIOABAGChT08rIDFNTU2BgYG1tbV1dXUmJibr169nqvnLL78UFBTMmTOnO9V7 T6QDQDcDAQ8AAAu979mGgoKCurq6tbW1qalpXFwcS01LS8spU6bIQocFCxaIrSM76QDwHgIB DwAACzwMw3paByl59uzZqVOnQkJCul/0qFGj/vzzz+6XCwAAAAC9EZm8SWlvb79///7Dhw// /PPP5ubmiRMnHjlyRFVVFb/6yy+/ZGdnm5ubW1paXrx4MTs7e+TIkYsWLZo4caLYqxy5fv16 QUEBQmj06NGLFy8WrRAeHh4VFZWfnz969OgdO3ZcuHBh//79AwYMEKv8u3fv0tPTW1pakpKS iN4mTpyooKDAUXpjY+Pp06d//fXXmpoaMzOzlStXfvzxx/iltLS0iIgIFRWVdevWXbt2LTY2 VlFRcceOHWZmZmJN5tKWxbQjR47weDxbW9uffvpp7Nixbm5u165dS0hIWLBgAeXZeFRU1L17 9woKCoyNjZctWzZ+/HixugEfNmKn29u3by9evJiRkaGurj5r1qz8/PzJkydPmzaNY/9MzVNT U6OjowcOHOjm5oYQam5uPnXqFEJoxYoVBgYGiHMyYQnp6Ojo1NRUhNDChQuNjIx+/PHHyMhI XOK7d+/YpXM0nEk6i+ixY8dydB0AvD/I5E1Kc3NzTEzMkiVLbt26FR4ebmho6OTkRFwdOnQo hmGHDh2yt7cfPHjwrl27JkyY4ObmdvHiRbFXOTJ8+HATE5MBAwYEBweLXl23bp2Pj4+9vf3x 48ft7e1Xrlx58uRJfKkhVvn6+vrQ0NCmpqZQEq2trRylFxcXW1tbYxjm5eX1888/z5s3z9XV 9cyZM/hVdXV1ExOT77777uOPPy4tLd26devixYu/+OKLyspKsSZzactimomJib+/v7e39/z5 858/fz5u3LjY2NilS5d+8803r169InrYvn37//3f/82bN+/kyZN2dnbr1q3z8/MTqxvwYcM+ 3Zqbm6dPn44Q2rJly8qVKzMzMz09Pbk/UmVprqGhMWrUqJMnT+I1+/TpY2JiEhsbm5+fj5dw SSbsIa2trW1iYvL8+fPExMR58+ZlZWW5u7sbGRmFh4eLlc7FcBbpLKI5ug4A3i+wbkFfX18g EBCniYmJ/fr1y8rKIkqamppGjRr1119/ib1KkJKSsnTpUhahr169cnBwoBTevn17xowZHR0d RElVVZWamhp35TEMMzIyYqnPIt3R0fHSpUvkkvr6+hEjRuTn5xMlGhoaeXl5xKmLi0tgYKBY cdK1JZtmYWFRV1eHYdjz58+trKxwF3377be+vr54hejoaIrramtrR4wY8ebNG47qAR8wtAGP Ydivv/46Y8YMcsnmzZtjY2M5dsveXCAQUCbj2rVrY2JiiFP2ZMIxpPfs2aOjo/PkyROKbuzS xRrORTqTaADodcjqMyl3794NDQ3NycnBMGz48OF1dXUCgUBeXp6oMHv2bFNTU+JUSUlp8eLF 0dHRX3/9tdirneHWrVtbt27l8XhEiaamZkpKikTKS0dHR0d8fPzNmzfJhaqqqosXL46JiVm3 bh1RYmhoSFSYNGlSWVkZRxFi27Kb1qdPH4SQpqamqqoq7iINDY2Wlhb8alhYmJWV1d27d8kd 6unpPXv27IsvvuCoIfBPw9LSsqys7Ntvv50xY8aQIUM0NTWJh3nd0ByxJhPuIX348GE7OzuJ 5IrVnKN0KUQDwHuITFYbx48fj4yMPHz48EcffdS3b9/q6mrRzerKysqUEiUlpbq6Oi5XO0NN Tc2gQYMohSYmJhIpj0m1tba1tVVRUVFOjvr2auDAgTU1NUytROtzh9KWi2kIIfJSjHz85s2b vn37vnz5klzZ3t5+5MiRUmsIfPDIy8s/e/bM39/f19e3vLy8tLRUSUnpxx9/5LIbqfPNEWsy 4R7SAwcO5CiOu+YcpUshGgDeQ2Sy2jhz5kxmZqaamhp+OnDgwPb2dkqd+Pj4lpaW/v37EyXR 0dEHDhzgcrUzWFhYxMXFERszCYRCIf4nPhflm5qapBA9YMAAVVXVrKysjz76iFz++PHjnTt3 StGhpHAxjQV8b9p3330nE+WAD5Tff//9t99+27FjB1Fy8+ZNLy8v2k0ekjaXl5enLP0FAgGl B5Zk0smQZpcu1nCYUMA/CpnsEh0yZAixtbCwsPCzzz6rrq6m1GltbV2xYgVeLhQKv/vuOzU1 NeKBIfvVzuDu7n7p0qUnT54QJenp6dOmTQsLC+Ou/ODBg/Py8vBjgUBw586dqqoqLtKPHDmy cuXKoqIi/BTDMG9v77a2tk8//bQzRnGEi2ksbNy48cqVK2TXtba2Xrly5fLly12rJ/Ah0dDQ sGvXrsLCQqIkPz9fQ0Ojq5pra2v/9ttv+LGvr+/169cpPbAkk86HNIt0sZrDhAL+WchiM0ha WtrIkSM/++yzGTNmWFlZJSUlmZiYmJube3l54RUSExNXr1595cqVUaNGjR8/3sDAYMuWLU1N TVyupqenW1hYWFhYjBo1Sl1dHT/etm0bIZ2oYGxsrKamhh9v3ryZqJCRkTFhwoTx48c7Ojoa GhpOnTqVvK1MrPIYhkVHRxsbGzs6Os6ePdvQ0NDNza20tJSj9NDQ0JEjR06bNs3BwcHIyGjl ypW1tbX4pZs3b1pYWCgqKlpYWDx8+BDDsE8//XTYsGGDBw+eM2cOu8+5tGUxzcLCon///mZm Zunp6QUFBcrKygsXLsQw7NSpU0OHDg0NDcV7ePXqla2trbW19YoVKyZMmDBy5Mht27a9fv2a S1QAHyRiAz4pKcnc3Hzy5MkzZ85csmSJmZnZzJkzq6qqOPYvtnlycvKIESO++OILExOThQsX Ojg4GBoa7ty5E7/KnkwwcSG9bds2CwsLbW1tAwMD3LR9+/aR1WORzsVwFuliRQNA70JW3+7F 5/OzsrL69etnbGwsejUpKenSpUtBQUEYhr1580ZbW5u8w4D9aldRUVFRXFxsYGCgpaUlkfI4 7e3tWVlZ6urq+vr65M0NHCkqKqqpqTExMenXr5/EqncCLqaJpaam5vXr1yNHjuT+Fyrwj6Wu rq65uXno0KEVFRWvX7/W09MbPnx41zbHJ6OhoaGKigrlEsdk0pmQZpLO3XCYUMA/gR74LtHG xsb4+Pgff/zx3LlzCCE1NTX8oxBcrv5j2bJlC/H+hYnvvvvO0tKye/QBgE7SDSENyQQA3h96 YLVx8ODBhIQE4vTMmTPkz6exX/3HkpeX19bWxl5HX19fdPs9ALyfdENIQzIBgPeHXvw7KQAA AAAA9Ap632/AAgAAAADQu4DVBgAAAAAAsgVWGwAAAAAAyBZYbQAAAAAAIFtgtQEAAAAAgGx5 r1cbiYmJDx486Gkteh/gNwCQiF49ZXq18sA/h575rpumpqbAwMDa2tq6ujoTE5P169fTVvvl l18KCgrmzJnTzeq9/zQ3N2/cuPHNmzeVlZV2dnYnT54kXwW/AYBE9Oop06uVB/459MyzDQUF BfX/Z+/c45q40sY/gFzVkICC5U4CJFLBcLWIghvkUgVF/CBajdjXLt2iqIi61gpWCwulFpC6 H6Ww1CvSRREQLTEoglBBWKJyeWslLBdBUAigRC4G5vfH/Hbe2UAmA0mA4vn+Nef2nOc5c56H h8xJhkx2dHRcvHjxvXv3JHWzs7Mb95XosrNhwwZFiJ0yNDU1Dx48mJaWFhsbO/aFcIpbNwBg VoLvMtMYLohMDfwd8Idgmn/dq6KiIikp6cqVK1M8r6Wl5bNnz6Z4UkVQVlZ29uzZixcvTrci AMCsZRrDxayJVACAAp+k5Ofn3759m8/nW1lZRUREnDlz5quvvtLS0iIy9vLly01NTRAEWVlZ BQYGju1w+/btGzduNDU10en0LVu2ODg4IPXV1dW//PLL/PnzQ0JCLl68WFRUpKamFhERYWNj g3R4+/Ytj8cbGBgoKytDpTk7O6uqqhI3bdKzE1mZN2/enDp1qrKyUiAQ2NjYsNlsFxcX7HAu l/vw4UMTExNPT0/i60ZEt+Hh4dzc3JqaGjMzs02bNnG53Pr6eltbWz8/P+KLA3jfePXq1dmz Zx8/fkwmkz09Pfl8vqurq7u7O7aPpD2PbGYIgjZu3GhhYXHp0iUOh0OhUEJDQ5csWQJB0PDw 8M2bNwsKCp49eyYUCp2dnWNiYkgkEgRBMTExSkpKy5cv//nnn5csWRIaGnrx4sX79+9v2LCB +GMF/FBDJFxIigaymEZwanzlcSIJkWhA5LYCAMRR1JOUkJCQ77//3sPDIz4+3sPDg81mJyYm Ekw1IAgyMTFhMBhaWloZGRljW/fv35+QkODr65uYmOjm5hYSEvLjjz8iTWQymcFgREVFubi4 tLW17du3LzAw0M/P7+XLl0iHvr6+zMzM/v7+TAyDg4PETZNldqkr09ra6ujoCMNwbGzs1atX fX19v/jii+TkZKR1YGDA29s7NTXV0NCwra1t7dq1XC6X4LpJ1a21tdXZ2bmoqMjS0rKhocHF xeW7775TVlb+4IMPiC8O4H1DKBSuWrUKgqC9e/ey2ey6urpjx46JfWKKs+f19PQYDEZVVVVp aamvr299ff2ePXssLCzy8/NR+YWFhUFBQdnZ2fn5+TQabdOmTUgTg8FITU2Ni4tbt25dVVXV 0qVLi4qKNm/efPTo0draWoL644caqeECJxrIYhqRqfGVx48kUqMBkdsKAEwMRbzG/vr16ywW a3R0FK3p6urS1tYe27O8vHzz5s2S5NTW1vr7+4tVcrlcMeE9PT3m5uadnZ1ojY6OTkNDA1rc uXNneno6VoiFhQVha+Q5u9SVCQgISEtLw87Y19dnbm7O5/NhGA4LC0N8HkEgEJiamm7btk1M yXHXTapuq1evzsjIQJtKS0uVlZXLy8vHXwgAAIZhGK6srGSxWNiasLCwoqIitEgkGhw+fFhf X7+4uJjIjKampiKRCLlmMpm9vb0wDFdVVdnb2yOzREZGpqSkTMgKHJeBJYcLItFg0qbhT41l XOXxIwkCTjSQelsBgImikCcp2dnZ+/btU1JSQmt0dXXLy8vlIjw3N9fe3j4vLw9baWRkVFFR gX7gTyKRaDQa2rps2bL29vaZMDv+yoyOjpaUlGRlZWGFk0ikwMDAwsLCkJCQ7OzshoYGtIlC oYSHh1dVVRHXX5JufX19T58+3bJlC9rk6urq6OhIXDLg/cTOzq69vT0yMpLFYhkYGOjq6qL/ QCMQjAbR0dFubm7jTpGXl5eZmfn06VMYhk1MTHp7e0UikYqKCtKKvEReV1eXRCIhs+jo6AwM DMjRRkkQiQaQDKZNGqmRBK2RFKmk3lYAYKIoJNsQCAQLFiwQq2QwGHIR3tnZqa6u/ujRI2yl h4cHlUqVNERZWfyBETzZjwRlnB1/ZQYHB9XU1MZqS6FQBALB0NDQyMiIhoYGtsnY2HhC2YYk 3V6/fj137lyxVm1t7UlLBrwnqKioVFRUpKampqSkvHjxoq2tbe7cuZcuXUJPABCMBhQKZVz5 8fHxHA4nOjra2tpaXV29u7t73O9fYLMZ7LVckBQuCEYDWUybXKTCjySSRmH7S72tAMBEUUi2 wWQy7927J3a2EYKgkZER2dN25IBVVFSULEL6+/unZXb8ldHS0iKRSPX19dbW1tjWu3fvHjhw QF1dXUdH5/fff7eyskKbsCfIZMHY2FgkEj1+/Hjp0qVITXt7+4MHD+QiHDCLqampefLkSURE BFqTlZUVGxuLniSQMRokJyfX1dWhiS+FQhkeHpaT7kSRFC5kjAZETJtcpMKPJEQkSL2tAMBE Ucgp0T179qSlpRUXF6M1PB7P3d09NzdXduG7du06f/48Vvjg4OD58+fPnTtHXMiiRYvQRxIi kSgnJ2fsr1YoYnapKxMTE8Nms1taWpAiDMNxcXFDQ0NeXl4QBEVHR2/fvr2jowNpzcnJmZDV +Jw5cyYwMPD69esvXry4e/eun5/f2H9JAQAxXr9+fejQoebmZrSGz+fr6OigRRmjgYGBAXrk s7m52cfHp7u7W066E0VSuJAxGhAxbdKRCj+SSEXqbQUAJoyCzoM8fvzYycnJwcEhICCARqOt XLmysLAQbeXxeEwmk8lkWlpakslk5Do8PFyslU6na2trI9dhYWHo8Nra2uXLlzs6Om7dutXJ yYlKpYaHhzc2NsIwnJWVxWQy1dTUmExmQUEBDMNeXl7GxsaLFi1as2YNKoHL5dLp9ICAAG9v bxqNFhoa2tbWRtA0GWfHXxkYhjMzM6lUqru7u7+/v4WFBZvN7unpQVuvXLliaWnp6urKYDA8 PDyysrIoFAqTyezs7MRfNyK61dTUfPrpp8uWLQsKCqqoqNiwYUNVVRXBZQG8n5SVldna2rq6 uq5evTooKMjGxmb16tVdXV3YPjh7Pjw8nMlk6unpmZmZITv2yJEj2LHV1dVUKtXHx4fFYtnb 25eVlTEYDFtb29jYWCaTqampaWNjw+Pxmpqa5s2bt3HjRhiGk5KSDA0NMzMzpSovNdQg4IQL nGggi2lEppaqPE4kkRoNiNxWAGBCKPbXvTo6OlpbW83MzBYuXCh34QKBoLGxkUqlTi7jHh4e rq+vJ5PJpqamk3jQK+PsUlempaVFIBAwGAyxgxoIz58/V1VV1dfXn8TUxGEwGKWlpeATDgAO vb29QqHQ0NCwo6OjsbHRyMjIxMRk3J6Tjgbv3r2rr6/X0NCg0+nyUHky4IeLSUcDIqbJGKnw I4kkiN9WAIAg0/xbojOKvXv3oh88SiIqKsrOzm5q9JkWuru7BwcHW1pa0tPTh4aGLly4MN0a AQCTAbgzADCjANnG/9HQ0DA0NITfx9TUdN68eVOjz7QQHBwsEAgMDQ3d3d2DgoLGHmsHAP4Q AHcGAGYUINsAAAAAAACgWMB/rgAAAAAAABQLyDYAAAAAAAAoFpBtAAAAAAAAUCwg2wAAAAAA AKBYQLYBAAAAAABAsYBsAwAAAP7AlJaW3rp1a7q1AACkoJC3ss0QRkdHh4aGNDU15Sizv78/ PT29p6ent7eXwWB8/vnnchQOAAAAYgiFwl27dnV2dr58+dLNzS0xMVGsw7Vr15qamtasWTMt 6gEABJH/ZxvZ2dlOGFavXh0cHHzjxo2JytmwYcOkdejo6NiyZQuVSl2+fPny5cuvXLnypz/9 SS7CVVVVyWSyo6Pj4sWL7927N2kNAQAAgAiampoHDx5MS0uLjY0d95VsdnZ2Y19VDwDMNOT/ 2caGDRu8vb0dHBzq6upgGO7t7X327NmBAweePn1K8GXHCOjbESfKyMjI+vXr//KXv1y5cgWC oO7u7o8//tjQ0FAuwtXV1bdv3w5BUEVFRVFR0eSEAAAAAEGUlZU//PBDCIKamprG7YBEJABg hiP/bENJSWnOnDlKSkoqKioQBC1YsGDBggX5+fnW1tZbtmxB/uoPDw/fvHmzoKDg2bNnQqHQ 2dk5JiaGRCIhEt6+fcvj8QYGBsrKylCxzs7OqqqqaPH27ds3btxoamqi0+lbtmxxcHBAm2pq aubNm/fpp58iRV1d3eTk5CNHjhARzuFwqqqqIAhiMBgbN25EWk+ePIn8BDKbzSb4aiIc9QCA WcarV6/Onj37+PFjMpns6enJ5/NdXV3d3d2xfSR5BJfLffjwIQRBGzdutLCwuHTpEofDoVAo oaGhS5Ysyc3NRf8x2L9/v6amZnl5+Z07d7A1OMKlyido4Ljyq6urf/nll/nz54eEhFy8eLGo qEhNTS0iIsLGxgY7Nj8///bt23w+38rKKiIi4syZM1999ZWWlhbS+ubNm1OnTlVWVgoEAhsb Gzab7eLigh2O6G9iYuLp6TlWscuXLyMpiJWVVWBgIFpPULfh4eHc3NyamhozM7NNmzZxudz6 +npbW1s/Pz+CKwMAEGeKTolSKJSAgICcnBykKBQKCwsLg4KCsrOz8/PzaTTapk2b0M59fX2Z mZn9/f2ZGAYHB9EO+/fvT0hI8PX1TUxMdHNzCwkJ+fHHH9HWhQsXNjc3v3v3Dq1ZtmzZ7t27 iQjX19fv7u7mcDjYz0KoVGpCQoKBgQEaI/DBVw8AmE0IhcJVq1ZBELR37142m11XV3fs2DGx 9yHgeISenh6DwaiqqiotLfX19a2vr9+zZ4+FhUV+fj4EQQYGBhoaGmlpaQwGA/nvRUdHB4bh 27dvozX47oYvnwiS5JPJZAaDERUV5eLi0tbWtm/fvsDAQD8/v5cvX6JjQ0JCvv/+ew8Pj/j4 eA8PDzabnZiYiIaR1tZWR0dHGIZjY2OvXr3q6+v7xRdfJCcnI60DAwPe3t6pqamGhoZtbW1r 167lcrliupmYmDAYDC0trYyMDGw9Ed1aW1udnZ2LioosLS0bGhpcXFy+++47ZWXlDz74gODK AAATQxGvsR8cHGQwGGKVePNWxgAAIABJREFUf//73/fs2SNpiKmpqUgkwtZYWFiM25PL5bJY rNHRUbSmp6fH3Ny8s7MTrQkPD2cymSdOnLh161ZDQ8NYIZKEwzA8NDREp9OfP3+O1pw+fXr3 7t1i3crLyzdv3jw59QCAWUNlZSWLxcLWhIWFFRUVoUUiHnH48GF9ff3i4uJxp3B2dq6qqkKL wcHBJSUlxIVLlY+DVPk6OjrYCLNz58709HTk+vr162Jju7q6tLW10WJAQEBaWhp2ur6+PnNz cz6fD8NwWFgYkrchCAQCU1PTbdu2jVWytrbW399/bD2ObjAMr169OiMjAy2WlpYqKyuXl5eP vxAAgMxM3XdS3r17p66ujhbz8vIyMzOfPn0Kw7CJiUlvb69IJEL+WcEnNzfX3t4+Ly8PW2lk ZFRRUYF+AJiQkFBTU8PhcK5du/bgwQNVVdXr16+bm5sT0VNNTe3QoUPffPPN2bNnIQjq6elJ SkqqqKggaCYR9QCAWYOdnV17e3tkZCSLxTIwMEAeXGI7EPSI6OhoNze3cac4cuRIfHz8zz// DEFQa2trc3PzypUrJyQcXz4OUuWTSCQajYY2LVu2rL29HbnOzs7et2+fkpIS2qqrq1teXo5c j46OlpSUZGVlYSWTSKTAwMDCwsKQkJDs7OyGhga0iUKhhIeHI895CYKjW19f39OnT7ds2YK2 urq6Ojo6EhcOAEyUqcs26urq7O3tkev4+HgOhxMdHW1tba2urt7d3T32TDUs4eW0nZ2d6urq jx49wlZ6eHhQqVTkemRkZGRkxMbGBn1I+dNPP+3Zswf7vRhJwhGCg4MTExMbGxupVOrx48fD wsJ0dHQImilVPQBgNqGiolJRUZGampqSkvLixYu2tra5c+deunQJ9T6CHkGhUCRNsW7duqio KD6fT6PREhISsIfNibsbjnwcJurOysr/92xaIBAsWLBArAODwUAuBgcH1dTUsP1RPQUCwdDQ 0MjIiIaGBrbJ2Nh4QtkGjm6vX7+eO3euWAdtbe1JCwcApDJF2UZPTw+Hw4mMjESKycnJdXV1 6OamUCjDw8NiQ/r7+8cVhZztioqKkjTXw4cPf/jhB+yDzPXr18fGxhIRjqCionL06NHjx49/ +eWXd+/ePXnyJE7niaoHAMwmampqnjx5EhERgdZkZWXFxsaiDii7RygpKR08ePDkyZMxMTEV FRXYH5xQtLvJIp/JZN67d0/s1CcEQSMjIyoqKlpaWiQSqb6+3traGtt69+7dAwcOqKur6+jo /P7771ZWVmgT9mC7jBgbG4tEosePHy9duhSpaW9vf/DggbzkAwBjmYpTol1dXdu3b9+9e7ex sTFSY2BggB41b25u9vHx6e7uFhu1aNEi9INEkUiUk5ODfNd8165d58+fLy4uRnsODg6eP3/+ 3LlzSHHBggXXrl2rrq5GO6SlpYn93oYk4SibNm2qra3dtm3bt99+O2fOBHIyqeoBALOJ169f Hzp0qLm5Ga3h8/nYzwLl4hGbN28uLi6OjIwMCwvD1iva3WSRv2fPnrS0NOxYHo/n7u6em5uL FGNiYthsdktLC1KEYTguLm5oaMjLywuCoOjo6O3bt3d0dCCtOTk58o0hZ86cCQwMvH79+osX L+7evevn5zf2kxgAQJ7I/SRIVlaWra2turo68z84OjqeOXMGe1qqurqaSqX6+PiwWCx7e/uy sjIGg2FraxsbG4v24XK5dDo9ICDA29ubRqOFhoa2tbUhTbW1tcuXL3d0dNy6dauTkxOVSg0P D29sbERaa2pqHBwcXFxcPD09g4ODHRwc1q1b9+bNG6ySOMJRTp8+7ePjI1bJ4/EQoywtLclk MnIdHh6O7YOvHgAwmygrK7O1tXV1dV29enVQUJCNjc3q1au7urqwfXA8AjnQraenZ2ZmhnjT kSNHxp3ozJkzVCpV7Cw5vvAJyZeEJPlZWVlMJlNNTY3JZBYUFMAw7OXlZWxsvGjRojVr1iBj Hz9+7OTk5ODgEBAQQKPRVq5cWVhYiBWemZlJpVLd3d39/f0tLCzYbHZPTw/aeuXKFUtLS1dX VwaD4eHhkZWVRaFQmEwmckYVjUV0Ol1bWxu5DgsLg2GYiG4wDNfU1Hz66afLli0LCgqqqKjY sGED9jQuACBflGDcEwyK4927d/X19RoaGnQ6XVKf4eHh+vp6MplsamqKPWyFIBAIkKMVYocq Xr582dHRYWtr29jY2NzcTKPRxv2RDHzhIpHIyckpIyNj8eLFkzNQknoAwGyit7dXKBQaGhp2 dHQ0NjYaGRlJ+k0ahXqEot1NFvkdHR2tra1mZmYLFy4ct0NLS4tAIGAwGGIHNRCeP3+uqqqq r68/YaUnCIPBKC0tBZ9wABTEtGUbMxOhUPj8+XMIgpBnMXFxcRYWFtOtFAAAkDN79+5FH2FI Iioqys7Obmr0mS66u7sHBwdbWlrS09OHhoYuXLgw3RoBZi0g2/gveDxefHw8Wpw/fz74YS4A YPbR0NCA/EAwDqampvPmzZsafaaL4OBggUBgaGjo7u4eFBQ09jsyAIC8ANkGAAAAAAAAxQIy WQAAAAAAAIoFZBsAAAAAAAAUC8g2AAAAAAAAKBaQbQAAAAAAAFAsINsAAAAAAACgWEC2AZAz paWlt27dmm4tAIBZAnAowOxAsW9lEwqFu3bt6uzsfPnypZubG/Z1SlIZHR399ttvb968iXwd fO3atfv27ZNdpf7+/vT09J6ent7eXgaD8fnnn8suE4Dl2rVrTU1Na9asmW5F5I8s+3nSgB37 njOLHQrwXqHYbENTU/PgwYNkMrmuru7ixYsTGpubm3v//v0bN26oqam1trZqaWnJRSVVVVUy mUyj0dra2oqKiiTF7g0bNly/fn3Ss8g4fCYj1TQ7OzsjI6Mp02cqkWU/TxqCOxYwW5nFDgV4 r1BstqGsrPzhhx9CENTU1DTRsfX19WvWrKFQKBAEMRgMeamkrq6+fft2CIIqKiqKiookdUNf UTs5ZBw+k5FqGrK8sxJZ9vOkIbhjAbOVWexQgPcKBWYbXC734cOHJiYmnp6e43a4ffv2jRs3 mpqa6HT6li1bHBwckPqXL1/yeLzffvtNX1+fw+EglSwWS1VVFYKg4eHhmzdvFhQUPHv2TCgU Ojs7x8TEkEgkpNvDhw+5XC6FQgkNDYUgSCgUJiUlQRC0detWMzMzImq/ffuWx+MNDAyUlZWh lc7OzsjsMg5H1gSCoI0bN1pYWFy6dInD4SDaLlmyBN+66urqX375Zf78+SEhIRcvXiwqKlJT U4uIiLCxsUEnevXq1dmzZx8/fkwmkz09Pfl8vqurq7u7O9KKv3QI+fn5t2/f5vP5VlZWERER Z86c+eqrr5APlqSuzOXLl5E/w1ZWVoGBgWMX582bN6dOnaqsrBQIBDY2Nmw228XFhaBp+Ehd WEjyfiO4MlL3Mw6SDJfddg6HU1VVBUEQg8HYuHEjUnny5EnkZ7nZbLakd6TJEfxdhyBp8fFv XG5uLprd7t+/X1NTs7y8/M6dO9gaHOFS5ePbJePsRKbGX7ppdCgAQO4o5JTowMCAt7d3amqq oaFhW1vb2rVruVyuWJ/9+/cnJCT4+vomJia6ubmFhISgbyR59epVYWFhY2NjXV1d4X949+4d 0ioUCgsLC4OCgrKzs/Pz82k02qZNm1CxOjo6lpaW6AP1OXPmMBiMoqIiPp9PUPm+vr7MzMz+ /v5MDIODg3IZrqenx2AwqqqqSktLfX196+vr9+zZY2FhkZ+fL9U6MpnMYDCioqJcXFza2tr2 7dsXGBjo5+f38uVLdOyqVasgCNq7dy+bza6rqzt27Bj2l+nxlw6CoJCQkO+//97DwyM+Pt7D w4PNZicmJqLPsKSujImJCYPB0NLSysjIGLsyra2tjo6OMAzHxsZevXrV19f3iy++SE5OJmKa VKQuLM5+k7oyRPYzDjiGy267vr5+d3c3h8MxNDREK6lUakJCgoGBgbyeP+IgdddBuIuPf+MM DAw0NDTS0tIYDIaKigoEQTo6OjAM3759G63Bv7NSNwYOMs5OxNnxl24aHQoAkD+KeI19WFgY 4jYIAoHA1NR027ZtaA2Xy2WxWKOjo2hNT0+Publ5Z2cnWvP111+fO3eOyHSmpqYikQgtikQi CwsLbIfPPvussLBQbFR5efnmzZslyRSTMFHwhx8+fFhfX7+4uJiIKDHrdHR0Ghoa0OLOnTvT 09OR68rKShaLhR0bFhZWVFREUPj169fFbkpXV5e2trbYEKkrU1tb6+/vP7Y+ICAgLS0NW9PX 12dubs7n85EijmkEkbSwRPabGNiVkbqf8ZFqOEzMdkk7dmhoiE6nP3/+HK05ffr07t27Caon I1J3HZHFx/cIZ2fnqqoqtBgcHFxSUkJcuFT5+Mg4O87UBB12Gh0KAJAjCnmSkp2d3dDQgBYp FEp4eDjyeS9Cbm6uvb19Xl4edpSRkVFFRYWfn59U+Xl5eZmZmU+fPoVh2MTEpLe3VyQSIf9q /FGIjo52c3MbtwnfOhKJRKPR0M7Lli1rb29Hru3s7Nrb2yMjI1ksloGBga6uLvoPNBHh2dnZ +/btU1JSQjvr6uqWl5fLxd7R0dGSkpKsrCxsJYlECgwMLCwsDAkJwTeNOOMuLJH9hr8y+PsZ ByKGQ7LZrqamdujQoW+++ebs2bMQBPX09CQlJVVUVBAcLiNSdx1BZ8fxiCNHjsTHx//8888Q BLW2tjY3N69cuXJCwvHl4yP77JKmJuKwkpgyhwIA5IX8s42hoaGRkRENDQ1spbGxMTY6d3Z2 qqurP3r0CNvHw8ODSqVKlR8fH8/hcKKjo62trdXV1bu7u1esWCEv5VFg2V6NK3U4cvp1LBO1 DvuGaBUVlYqKitTU1JSUlBcvXrS1tc2dO/fSpUvow1p84QKBYMGCBWLyx57PndzKDA4Oqqmp jX2fNYVCEQgEUk0jzrgLK3W/4awMkf2MwyQMhyZue3BwcGJiYmNjI5VKPX78eFhYmI6OzoQk TBqpu46gs0vyCAiC1q1bFxUVxefzaTRaQkLCgQMH0CbikQRHPj6yzy5paqlLh8OUORQAIC/k n22oq6vr6Oj8/vvvVlZWaCX2XCEEQcghqaioqEnIT05Orqur09bWRooUCmV4eBjbQUVFRewv okgkmugs/f39k9BN9uFSrcOhpqbmyZMnERERaE1WVlZsbCz60BdfOJPJvHfvHnp6EWVkZAT7 udHkTNPS0iKRSPX19dbW1tj6u3fvYsO3gpC633BWhsh+xmFqDFdRUTl69Ojx48e//PLLu3fv njx5Ul6SpSJ118ni7AhKSkoHDx48efJkTExMRUUF9mdOZBc+jbNLXTocptehAIBJoJBsNzo6 evv27R0dHUgxJyfn3Llz2A67du06f/58cXExWjM4OHj+/HmxbuNiYGCAHhRvbm728fHp7u4W 66Onp/fkyRPkOiUl5fLlyxM1YdGiReiH5yKRKCcnp6urawqGE7FOEq9fvz506FBzczNaw+fz sf/j4gvfs2dPWloa9qbweDx3d/fc3Fy5mBYTE8Nms1taWpAiDMNxcXFDQ0NeXl4EDZw0Uvcb /spI3c/4TI3hmzZtqq2t3bZt27fffjtnjmK/2Y5F6q6TxdlRNm/eXFxcHBkZGRYWhq2Xi/Dp ml3q0uEzjQ4FAEwGBZ0HuXLliqWlpaurK4PB8PDwyMrKolAoTCYTPT9VW1u7fPlyR0fHrVu3 Ojk5UanU8PDwxsZGGIaLioqYTOaiRYtMTEyY/6GnpwcZWF1dTaVSfXx8WCyWvb19WVkZg8Gw tbWNjY1FZ//111/Nzc39/PyQrwX6+/vTaLQDBw7AMMzj8RCBlpaWZDIZuQ4PDxfTn8vl0un0 gIAAb29vGo0WGhra1tZG3HxJw8PDw5lMpp6enpmZGTL1kSNHsANxrMvKymIymWpqakwms6Cg AIZhLy8vY2PjRYsWrVmzBobhsrIyW1tbV1fX1atXBwUF2djYrF69uquri4hwpMPjx4+dnJwc HBwCAgJoNNrKlSvHnq6VZBq6sHQ6XVtbG7kOCwvDjs3MzKRSqe7u7v7+/hYWFmw2G7mtUk2T itSFxdlvRFZG6n7GR5LhRGwnuGNhGD59+rSPjw8RfeSI1F0H4y6+1BuHcubMGSqVij0xLVX4 hOTjM4nZpU6Nv3TT61AAgNxRgmU7oIDP8+fPVVVV9fX1JXUQCATIw+YJPWZ+9+5dfX29hoYG nU6X1Gd4eLi+vp5Go82fP39iSv+3BDKZbGpqij07qejhRKwbl97eXqFQaGho2NHR0djYaGRk NPa3FogI7+joaG1tNTMzW7hw4bgdZFyZlpYWgUDAYDDEDkNMATj7jcjKSN3P+CjUcJFI5OTk lJGRsXjxYrkLx4HIrkOYnLMTRKHCFTQ78aXDZxodCgAgjmKzjdnE3r170Q8tJREVFWVnZzc1 +rw/zOSVn3bdhELh8+fPIQi6du1adXV1XFychYWFguaaTUz7jQMA3jdAtkGUhoYG5PcZcTA1 NZ03b97U6PP+MJNXftp14/F48fHxaHH+/PnY37YCSGLabxwA8L4Bsg0AAAAAAACKBXwDGwAA AAAAgGIB2QYAAAAAAADFArINAAAAAAAAigVkGwAAAAAAABQLyDYAAAAAAAAoFsVmG6Wlpbdu 3VLoFAAAAABCzaSZxqUDd+29QrHZxrVr11JTU+UoMCUlxc7OzsDAQI4y/4gIhcIdO3Z8/PHH Dg4O4eHhEASxWCwrK6sjR45Mt2oAwDQg91AzvUxloJvGpZtldw2Aj2KzDTs7O/m+Dn7Hjh3V 1dXq6uoyytmwYYNc9Jku+ZqamgcPHkxLS4uNjUVeilZYWPjdd98NDAwodF4AYGYi91AzZYwb K+QV6IiguKWTGgb/uHcNMAkU+67I7du3y1egvNwPfeGnglC0fGVl5Q8//BCCoKamJrRGoTMC ADMZuYeaKWPcWDE1eQaC4pZOahj84941wCRQVLZx+fJl5A+hlZVVYGAgtqm6uvqXX36ZP39+ SEjIxYsXi4qK1NTUIiIibGxsiMsXiUQZGRl37twZHR3dvXv3smXLsK1v3rw5depUZWWlQCCw sbFhs9kuLi5I09u3b3k83sDAQFlZGdrf2dlZVVWV4NSvXr06e/bs48ePyWSyp6cnn893dXV1 d3cnIn94ePjmzZsFBQXPnj0TCoXOzs4xMTEkEmlCK8Plch8+fGhiYuLp6TlWvaGhobt371ZV VVGp1LVr15LJZKSew+FUVVVBEIS8FxepPHnyJPL7zWw2e3JvhAIA8D0C4fbt2zdu3GhqaqLT 6Vu2bHFwcCA+HL8DTqhBkBQNZA9EOO788OFDLpdLoVBCQ0MhCBIKhUlJSRAEbd261czMDBlO JBZNOtAhUQKCoI0bN1pYWFy6dInD4SD6LFmyROrSwTD8t7/9TczeJUuWrF+/XqrtREybxrsG mC4U9Q+xiYkJg8HQ0tLKyMgQayKTyQwGIyoqysXFpa2tbd++fYGBgX5+fi9fviQu38XFpbKy ks1mf/rpp5988sm///1vtKm1tdXR0RGG4djY2KtXr/r6+n7xxRfJyclIa19fX2ZmZn9/fyaG wcFBgvMKhcJVq1ZBELR37142m11XV3fs2DHsr7/jyxcKhYWFhUFBQdnZ2fn5+TQabdOmTcRX ZmBgwNvbOzU11dDQsK2tbe3atVwuF6veq1evvLy8bt68aWpq+ttvv7m4uPz6669Ik76+fnd3 N4fDMTQ0RPtTqdSEhAQDAwMtLS2CKwAAYJHqERAE7d+/PyEhwdfXNzEx0c3NLSQkBH2Zi9Th UjvghBoINxrIHohw3FlHR8fS0jIxMREpzpkzh8FgFBUV8fl8dDiRWDTpQKenp8dgMKqqqkpL S319fevr6/fs2WNhYZGfn09k6UZHR9PT0xn/wdTU9NSpU93d3URsJ2LaNN41wLSh0PfZ19bW +vv7j9uko6PT0NCAFnfu3Jmenk5QrJmZ2b/+9S+0eOjQoYSEBLQYEBCQlpaG7d/X12dubs7n 89EaCwsLgnOJUVlZyWKxsDVhYWFFRUVi3YjLNzU1FYlE2BqclQkLC0NCLYJAIDA1Nd22bRtS zMnJUVJSKigoQDvU1dVZWlq+fv0aKQ4NDdHp9OfPn6MdTp8+vXv3boKqAgBjkeoRXC6XxWKN jo6iNT09Pebm5p2dnUSGE/Q4SaFGajSQJRCNBevOIpFILA589tlnhYWFYkNwYoXsge7w4cP6 +vrFxcU4Oo+7dCKRyM/PD7keHh5eu3btt99+iyMEHi+USQ2DM+SuAaYGxZ7bwIFEItFoNLS4 bNmy9vZ24sPt7e3Ra0dHR+QzQwiCRkdHS0pKsrKyxOYKDAwsLCwMCQmRTWvIzs6uvb09MjKS xWIZGBjo6uqi/0wQJC8vLzMz8+nTpzAMm5iY9Pb2ikQiFRUVrLaSViY7O7uhoQFtolAo4eHh yPMRhFWrVnl7e6NFa2vrjz76qKSkZO3atRAEqampHTp06Jtvvjl79iwEQT09PUlJSRUVFRNb AgAAg1SPyM3Ntbe3z8vLw1YaGRlVVFT4+flJHS6LxxGJBjIGIqnuLCOyB7ro6Gg3N7eJzqui ooLcspGRka1bt9rb2x86dEisj4Jsn4K7BpgWpi3bEEOWQ47YsYODg2pqamOlUSgUgUCAFuHJ vvlWRUWloqIiNTU1JSXlxYsXbW1tc+fOvXTpkthTQ0ny4+PjORxOdHS0tbW1urp6d3e31CPZ qC1DQ0MjIyMaGhrYVmNjY2y2YWRkJDbcyMiopaUFLQYHBycmJjY2NlKp1OPHj4eFheno6Egz GgCQiFSP6OzsVFdXf/ToEXaUh4cHlUolMpygx40LwWiAZUKBaBLuPBbisWgSgQ6pmahKWN0+ ++wzQ0PDEydOiDURsX1yYVbRdw0wXcyUbENeaGlpkUik+vp6a2trbP3du3cPHDiAFvv7+ycn v6am5smTJxEREWhNVlZWbGys2NNHSfKTk5Pr6uq0tbWRIoVCGR4eJji1urq6jo7O77//bmVl hVZiD2EhxXfv3mFPmZWWlsbHx6NFFRWVo0ePHj9+/Msvv7x79+7JkycJzg4AjItUj0DOJEZF RU1uOEGPGxeC0WDS4LuzioqK2J9bkUg0VsjkYpGiTUMICwtTVVVFTp90dXXxeDz0ZDqRUDaT TQNMPbMwJYyJiWGz2eg/9DAMx8XFDQ0NeXl5oX0WLVqEPpIQiUQ5OTnIr1ZI5fXr14cOHWpu bkZr+Hz+2I8HJMk3MDBAvxXW3Nzs4+ODPXgllejo6O3bt3d0dCDFnJycc+fOYTt0d3d//vnn yK9uwDD8t7/9jUQiffTRR9g+mzZtqq2t3bZt27fffjtnzmxLNwFTjFSP2LVr1/nz54uLi9Ga wcHB8+fPI1tX6nCCHicJItFg0kh1Zz09vSdPniDXKSkply9fHitk0rFIoaZBEHT48OGenh7k qSsEQW1tbRcuXEBbiYSyGWsaYHpQxGEQHo/HZDKZTCadTtfW1kauw8LCkNasrCwmk6mmpsZk MpEjjV5eXsbGxosWLVqzZg2+5IKCAnRsXl4eDMOffPKJmZnZwoULmUwmekYpMzOTSqW6u7v7 +/tbWFiw2eyenh6sHC6XS6fTAwICvL29aTRaaGhoW1sbEdPKyspsbW1dXV1Xr14dFBRkY2Oz evXqrq4usW6S5FdXV1OpVB8fHxaLZW9vX1ZWxmAwbG1tY2NjCa7MlStXLC0tXV1dGQyGh4dH VlYWhUJhMplBQUHm5uZ79+49fvy4kZGRm5ubhYXF//zP/7x582asFadPn/bx8SFiLwCADxGP qK2tXb58uaOj49atW52cnKhUanh4eGNjI5Hh+B3wQw2CpGggSyBCwHdnGIZ//fVXc3NzPz8/ 5Gvn/v7+NBrtwIEDWCHjxgrZA114eDiTydTT0zMzM0OW5ciRI9h58ZcOySQ+/PBD5n+g0+no gXQitksybdrvGmC6UIIne4Jh5tPS0iIQCBgMhthZB4Th4eH6+noymWxqaqqkpERQZm9vr1Ao NDQ07OjoaGxsNDIykvQzFZLkv3v3rr6+XkNDg06nT8IohOfPn6uqqurr60uauq2tzcjIaNwf ERGJRE5OThkZGYsXL560AgAAAnGPEAgEyIEh7CcTUocTl48PfjSYNFLdGYkDNBpt/vz5koRM LhahKMg0qRAJZX9Q0wCKYGZlG3v37sUeaRyXqKgoOzu72Te7ohEKhc+fP4cg6Nq1a9XV1XFx cRYWFtOtFAAwQ5nd0QAAmHpmVrbR0NCA/LQlDqampvPmzZt9sysaHo+HPS46f/589BeWAACA GLM7GgAAU8/MyjYAAAAAAADMPmbhd1IAAAAAAADMKEC2AQAAAAAAQLGAbAMAAAAAAIBiAdkG AAAAAAAAxQKyDQAAAAAAAIpFsdlGaWnprVu3FDoFYBKA+wIAAOTCLA4ms9i0aUGx2ca1a9dS U1MVOsWMRSgU7tix4+OPP3ZwcAgPD59udf6L9/m+AGYlina3GevOo6OjsbGxK1assLa29vT0 TEpKmmIFZnEwmcWmTQuKfSmXnZ3d2HegE2TDhg3Xr1+Xrz5Tiaam5sGDB8lkcl1d3cWLFyc0 VhbbiYyV5b4AAJNA0e4si7vNBPmTJjc39/79+zdu3FBTU2ttbdXS0ppiBWZsMJF9y81Y0/6g KDbb2L59+6THoi8Y/IOirKz84YcfQhDU1NQ00bGy2E5krCz3BQCYBIp2Z1ncbSbInzT19fVr 1qyhUCgQBDEYjKlXYMYGE9m33Iw17Q+KorKNy5cvI25pZWUVGBiIbaqurv7ll1/mz58fEhJy 8eLFoqIiNTW1iIgIGxsbpMPbt295PN7AwEBZWRk6ytnZGfuOsdu3b9+4caOpqYlOp2/ZssXB wQE7xfDwcG5ubk35QkhyAAAgAElEQVRNjZmZ2aZNm7hcbn19va2trZ+fn9ThXC734cOHEARt 3LjRwsLi0qVLHA6HQqGEhoYuWbKEoPmIEBMTE09PTzHFbt68WVBQ8OzZM6FQ6OzsHBMTQyKR 0A6y2E5krKT7EhMTo6SktHz58p9//nnJkiWhoaEXL168f//+hg0b1qxZgzUBZ+levXp19uzZ x48fk8lkT09PPp/v6urq7u5OcNEAf1Dw7zv+tsT3CKmxAkGSu0mVT9DZceRLJT8///bt23w+ 38rKKiIi4syZM1999RX6CcSbN29OnTpVWVkpEAhsbGzYbLaLiwtBw1++fMnj8X777Td9fX0O h4NUslgs1N8lCZdqe25uLpFoICmYEFFeaojGR5YtR+SmK9S09zZOqnz99deKkNvX16epqfn2 7dv8/PzNmzdjmwYGBkQiUXh4+LVr1wwMDNhstpmZ2bZt2z755JO5c+dCENTV1XXmzJmqqioV FZXa/+Du7q6uro5I2L9/f15eXnBw8JYtW7S0tA4cOKCkpIT+2WttbWWxWCMjI0uXLv39998P HTpUVVXFYDCWLl1qYGAgdXh/f7+ysnJBQYGGhsbRo0eVlZV37Njx9u3b//3f/12xYoVUwwcG Bnx9fevq6hwcHF68ePHVV1/NmTOnp6cnICAAgqDXr1+npaUFBgbu27dv8+bNz58/j42N3bZt GzpcFtuljsW5L69evYqLi/vtt9+Cg4O5XG5UVNTQ0NAnn3zy5Zdfurq66unpSZ1dKBS6urou WbJk8+bNtra2FRUV33zzDXJziW8bwB8Oqfcdf1vie4TUWIHvblLlS3V2qfLxCQkJyc/P/+ST T4KCgigUysGDB69evYqG3NbW1hUrVtja2oaFhe3YsWP+/Pn79+8fHh5etmyZVMMhCGpqasrO zn7y5Mnr16/7+/sbGxsbGxvd3NyQv6k4wqXaTqfTiUQDScFEqvJSQ7RCtxyRCK84097rOKnQ 99nX1tb6+/uP26Sjo9PQ0IAWd+7cmZ6eju1gYWEx7kAul8tisUZHR9Ganp4ec3Pzzs5OpLh6 9eqMjAy0tbS0VFlZuby8nOBwhMOHD+vr6xcXFxMxE0tYWNixY8fQokAgMDU13bZtm6T+pqam IpFIrHLStuOMxTLufWEymb29vTAMV1VV2dvbI7NERkampKQQmb2yspLFYmEFhoWFFRUVSVUG 8IeG4H0nsi0RxnoETqyYqLuNKx/H2SchH+X69eti/tLV1aWtrY0WAwIC0tLSsEP6+vrMzc35 fD5SlBokYRj++uuvz507N3Z2qcIRJNkuNRqgSAryOMrjh2ipyGXLEYnwijDtfY6Tij23gQOJ RKLRaGhx2bJl7e3tRAbm5uba29vn5eVhK42MjCoqKvz8/Pr6+p4+fbplyxa0ydXV1dHRkeBw bGV0dLSbm9uEjIIgKDs7u6GhAS1SKJTw8PCqqiq0Ji8vLzMz8+nTpzAMm5iY9Pb2ikQiFRUV IsKJKz855syZA0GQrq4uiURSUlKCIEhHR2dgYIDI7HZ2du3t7ZGRkSwWy8DAQFdXNzk5WXaV ADMc2e+7VI/AiRVS3Y2IfEiysxORL4ns7Ox9+/YhfoSgq6tbXl6OXI+OjpaUlGRlZWGHkEik wMDAwsLCkJAQfMPxISIcRZLt+NFAKpKUlxqipSKvUDO5CA/JZtr7HCenLdsQQ1lZ/Lu4sISX 03Z2dqqrqz969Ahb6eHhQaVSIQh6/fo1+kkjira2NsHhWJCDVxNiaGhoZGREQ0MDW2lsbIyG p/j4eA6HEx0dbW1tra6u3t3dPe7TmcnZjj+WONj4iL3Gn11FRaWioiI1NTUlJeXFixdtbW1z 5869dOmS2CN2wCyD4H2XtC0JegQWNFZIdTfi8sd1diLycRAIBAsWLBCrRA9yDg4OqqmpjY17 FApFIBCMK3BsZ0lMSDh+oJMUDSYKqozUEC0VGbccyiQi/LhMyLT3OU7OlGxjLP39/ePWIwd5 oqKixm01NjYWiUSPHz9eunQpUtPe3v7gwQOCw2VEXV1dR0fn999/t7KyQiuxJ5WSk5Pr6urQ /UehUIaHh8fKmZzt+GNlB3/2mpqaJ0+eREREoDVZWVmxsbEZGRkK0gcwEyB43yVtS4IeMS5S 3W0K5OPAZDLv3buHPZiJMDIyoqKioqWlRSKR6uvrra2tsa137949cOAAwSkkoVDhMiI1REtF xi2nOIiY9j7HyZn7y+WLFi1CP8MUiUQ5OTldXV0QBO3atev8+fPFxcVoz8HBwfPnz587dw4p njlzJjAw8Pr16y9evLh7966fnx/2Pwypw2UkOjp6+/btHR0dSDEnJwcr2cDAAP1eVnNzs4+P T3d391ghk7YdZ6zs4M/++vXrQ4cONTc3o618Pl9HR0cuUwNmLATvu6RtSdAjJIHvblMgH4c9 e/akpaVh/YXH47m7u+fm5iLFmJgYNpvd0tKCFGEYjouLGxoa8vLyIq6hJBQqXEbwQ7RUZNxy CkWqae91nFTEYRAej8dkMplMJp1O19bWRq7DwsKQ1qysLCaTqaamxmQyCwoKYBj28vIyNjZe tGjRmjVrUCFcLpdOpwcEBHh7e9NotNDQ0La2NqSptrZ2+fLljo6OW7dudXJyolKp4eHhjY2N 6NiamppPP/102bJlQUFBFRUVGzZsqKqqQlvxh4eHhzOZTD09PTMzM0TzI0eOTMj8K1euWFpa urq6MhgMDw+PrKwsCoXCZDI7Ozurq6upVKqPjw+LxbK3ty8rK2MwGLa2trGxsVgJstiOMxbn vjCZTE1NTRsbGx6P19TUNG/evI0bN8IwnJSUZGhomJmZKXX2srIyW1tbV1fX1atXBwUF2djY rF69uqura0JLB/jDQfC+S9qW+B5BJFbguJtU+UScHV8+Po8fP3ZycnJwcAgICKDRaCtXriws LMR2yMzMpFKp7u7u/v7+FhYWbDa7p6eHoOFFRUVMJnPRokUmJibM/4AMxxeOgGM7kWiAE0yI KI8fovGRcctJvekKNe19jpNKsMyP+RXH8PBwfX09mUw2NTUd+8hQIBA0NjZSqVSpiSGDwSgt LRXLMYkPnxzPnz9XVVXV19cXq3/37l19fb2GhgadTscZLovt+GNlZ9zZe3t7hUKhoaFhR0dH Y2OjkZGRiYmJ3KcGzDSI33dJ25KgR+Ajyd2mQL5UOjo6WltbzczMFi5cOG6HlpYWgUDAYDDE zojIBYUKlxfjhmhJyL7lphIx097nODmjsw1Z6O7uHhwcbGlpSU9PHxoaunDhgowC9+7di34s KYmoqCg7OzsZJwIAADMcEA1kZ9wQPTsWVu5/fWYHszbbCA4OFggEhoaG7u7uQUFBxI9zS6Kh oWFoaAi/j6mp6bx582ScCAAAzHBANJCdcUP07FhYuf/1mR3M2mwDAAAAAADADAHkXAAAAAAA ABQLyDYAAAAAAAAoFpBtAAAAAAAAUCwg2wAAAAAAAKBYQLYBAAAAAABAsYBsAwAATAWlpaW3 bt2abi0AAMD0MHPfyjYz6e/vT09P7+np6e3tZTAYn3/+uaSeo6OjQ0NDmpqa0zI7ADDTuHbt WlNT05o1a6ZbEQAAMA0oJNt4+PDhrl27xCpXrFiRmJhIXMiGDRuuX78uV73kgKqqKplMptFo bW1tRUVF4/697+joCA8Pf/DgAYVC0dTUDAsL+/HHH4uKitAOkzaNyOwAwFTy0UcfjYyMjK2P iIjYvHkztsbOzs7IyEi+s//zn//87rvvxCo3bdp08OBB+U4EAABkRCHZhpOTU3l5OQRB5eXl ycnJyLt0J/oz9eibG2cU6urq27dvhyCooqICm0CgjIyMrF+//i9/+cuVK1cgCOru7v74448N DQ2xfSZtmtTZAYCppL+/f2RkZKyzZ2RkPHv2TKwzsnXly6tXrz799FM07e7v73d3d/fx8ZH7 RAAAQEYUkm0oKSmpqKhAEDRnzhxlZWXkGqW6uvqXX36ZP39+SEjIxYsXi4qK1NTUIiIibGxs kA5v377l8XgDAwNlZWXoKGdnZ1VVVbR4+/btGzduNDU10en0LVu2ODg4oE1cLvfhw4cQBG3c uNHCwuLSpUscDodCoYSGhvL5fPQv/f79+zU1NcvLy+/cuYOtGR4evnnzZkFBwbNnz4RCobOz c0xMDIlEImh7TU3NvHnzPv30U6Soq6ubnJx85MgRIqZxOJyqqioIghgMxsaNG5HWkydPIj/l y2aziby/B2dlAAD5IhAIFixYMNbZFy5cWF1djXa7fPlyU1MTBEFWVlaBgYFofUxMjJKS0vLl y3/++eclS5aEhoZevHjx/v37GzZsEHvggrOrVVRU0Aizb9++L774Ao0kCG/evDl16lRlZaVA ILCxsWGz2S4uLhCBQERkdgAAQJBpOCVKJpMZDEZUVJSLi0tbW9u+ffsCAwP9/PxevnyJdOjr 68vMzOzv78/EMDg4iErYv39/QkKCr69vYmKim5tbSEjIjz/+iLbq6ekxGIyqqqrS0lJfX9/6 +vo9e/ZYWFjk5+cbGBhoaGikpaUxGAwkQuno6MAwfPv2bbRGKBQWFhYGBQVlZ2fn5+fTaLRN mzYRt27hwoXNzc3v3r1Da5YtW7Z7924ipunr63d3d3M4HOxnIVQqNSEhwcDAQEtLS+rs+CsD AMiX7u5uXV3dsfW6uroCgQAtmpiYMBgMLS0t5JMPFAaDkZqaGhcXt27duqqqqqVLlxYVFW3e vPno0aPYz/9wdvXSpUvR5CAjI+PNmzdijxdbW1sdHR1hGI6Njb169aqvr+8XX3yRnJwMEQhE UmcHAAATQKHvsy8vL9+8efO4TTo6Og0NDWhx586d6enp2A4WFhbjDuRyuSwWa3R0FK3p6ekx Nzfv7OzEdjt8+LC+vn5xcfFYCc7OzlVVVWgxODi4pKQExwpTU1ORSCRWiWNaeHg4k8k8ceLE rVu3sDaiSDINhuGhoSE6nf78+XO05vTp07t37yYyO8GVAQDkxatXrx48eIBcY/dkb2/v/fv3 xTrX1tb6+/uLVTKZzN7eXhiGq6qq7O3tkd0bGRmZkpKCdCC4q589e2ZjY9PT0yMmPyAgIC0t DVvT19dnbm7O5/ORIn4gAj4FAMiLaftOColEotFoaHHZsmXt7e1EBubm5trb2+fl5WErjYyM Kioq/Pz8sJXR0dFubm5jJRw5ciQ+Pv7nn3+GIKi1tbW5uXnlypXYDnl5eZmZmU+fPoVh2MTE pLe3VyQSiT0PwiEhIaGmpobD4Vy7du3BgweqqqrXr183NzcnMlZNTe3QoUPffPPN2bNnIQjq 6elJSkqqqKggMpb4ygAAcmHBggULFiwYW6+trb1ixQqCQubMmQNBkK6uLolEQk536ejoDAwM IK1EdvXw8DCbzU5JSSGTydhuo6OjJSUlWVlZ2EoSiRQYGFhYWBgSEgJJC0TApwAAeTFTvgE7 9p28sISX03Z2dqqrqz969Ahb6eHhQaVSxXpSKJRxJaxbty4qKorP59NotISEhAMHDmBb4+Pj ORxOdHS0tbW1urp6d3c38bgJQdDIyMjIyIiNjQ36Ae9PP/20Z8+eGzduSDUNITg4ODExsbGx kUqlHj9+PCwsTEdHh8jUxFcGAJhpYE+RY6+J7OrDhw+vX78eOY0BQdCXX34ZGxsLQdDg4KCa mtrY2EKhULAPerCIdQY+BQDIi5mSbYylv79/3PolS5ZAEBQVFTVpyUpKSgcPHjx58mRMTExF RYXY93KTk5Pr6uq0tbWRIoVCGR4eJi784cOHP/zwA/b59Pr165HYhyLJNAQVFZWjR48eP378 yy+/vHv37smTJwlOLfvKAAAzDam7+ubNm7W1tRwOB63Jz89HPE5LS4tEItXX11tbW2OH3L17 V+x/jEnPDgAACDJzf0t00aJFDQ0NyLVIJMrJyenq6oIgaNeuXefPny8uLkZ7Dg4Onj9//ty5 c8SFb968ubi4ODIyMiwsTKzJwMAAPaHW3Nzs4+PT3d1NXPKCBQuuXbuGPZCflpb2pz/9iYhp KJs2baqtrd22bdu3336LfM5MBLmsDAAwo8Df1W1tbX/9618vXLgg6Qv2MTExbDa7paUFKcIw HBcXNzQ05OXlJfvsAABgAijiMEh5eTmTyWQymZaWlmQyGbkOCwtDWrOysphMppqaGpPJLCgo gGHYy8vL2Nh40aJFa9asQYVwuVw6nR4QEODt7U2j0UJDQ9va2pCm2tra5cuXOzo6bt261cnJ iUqlhoeHNzY2Iq3IIU09PT0zMzNk6iNHjoxV8syZM1Qqdezxz+rqaiqV6uPjw2Kx7O3ty8rK GAyGra1tbGwsDMM8Hm+saeHh4ejwmpoaBwcHFxcXT0/P4OBgBweHdevWvXnzBjsFjmkop0+f 9vHxEauUOjv+ygAAiqCoqAi7J3fs2IFtRTctnU7X1tbGRgMmk6mpqWljY8Pj8ZqamubNm7dx 40YYhpOSkgwNDTMzMxEJOLv6q6++WrBgAfO/mTt3LlaBzMxMKpXq7u7u7+9vYWHBZrORw6QE AxHwKQBALijBuGcIppfh4eH6+noymWxqajr2fxeBQIAcbiB4rIE47969q6+v19DQoNPpEx37 8uXLjo4OW1vbxsbG5uZmGo027o9k4JsmEomcnJwyMjIWL148Cf0VtzIAwHQh465uaWkRCAQM BkNDQ2PqZwcAADM623jfEAqFz58/hyAIeRYTFxdnYWEx3UoBAAAAACArINuYQfB4vPj4eLQ4 f/588DtCAAAAAJgFgGwDAAAAAACAYpm530kBAAAAAAAwOwDZBgAAAAAAAMUCsg0AAAAAAACK BWQbAAAAAAAAFAvINgAAAAAAACgWkG0AAAAAAABQLCDbAAAAAAAAoFhAtgEAAAAAAECxgGwD AAAAAACAYgHZBgAAAAAAAMUCsg0AAAAAAACKBWQbAAAAAAAAFAvINgAAAAAAACgWkG0AAAAA AABQLCDbAAAAAAAAoFhAtgEAAAAAAECxgGwDAAAAAACAYgHZBgAAAAAAAMUCsg0AAAAAAACK BWQbAAAAAAAAFAvINgAAAAAAACgWkG0AAAAAAABQLIrNNjgcTkdHh0KnAMx8SktLb926Nd1a AOTP27dvs7KygoODr1+/jt8T7AEAQCr4DlVSUhIREXH48OGpV0wuKDDbiIuLU1JSWrRoEbZS KBTu2LHj448/dnBwCA8Pn5DA0dHR2NjYFStWWFtbe3p6JiUlyUXP/v7+5OTk48ePh4eHp6Sk yEUmAMu1a9dSU1OnWwuFIMt+njQzaseKRKILFy68fv0av5si9kBKSoqdnZ2BgYF8xf6xGHcH slgsKyurI0eOTK9u0wUMw9Otwv8xUWVwHIpEIl24cKG5uVlOqk01iso2/vGPf0AQ5OXlJVav qal58ODBtLS02NjYrq6uCcnMzc29f//+jRs3Kisrf/jhh4CAALmoqqqqSiaTHR0dFy9efO/e PUndNmzYIMssMg6fyUg1zc7ObsWKFVOjzBQjy36eNAR37BSgpaXl6elJpKci9sCOHTuqq6vV 1dVllKNQ31S044+7AwsLC7/77ruBgQGFTj0zGRoaOn78+HRr8f+ZqDL4DsVkMk1NTeWh1/Qw RxFCe3t74+Li6urqxjYpKyt/+OGHEAQ1NTVNVGx9ff2aNWsoFAoEQQwGQ2Y1/z/q6urbt2+H IKiioqKoqEhSt9raWllmkXH4TEaqacjyzkpk2c+ThuCOnRqUlJSIdFPEHpA9z0BQqG8q2vHH 3YHKyu/pgbyRkZGdO3cKhcLpVgSCJqsMvkMRdLeZiUKyjZiYGCaTqaamJlbP5XIfPnxoYmIy bvp2+/btGzduNDU10en0LVu2ODg4oE0vX77k8Xi//fabvr4+h8NBKlkslqqqKgRBw8PDN2/e LCgoePbsmVAodHZ2jomJIZFISLeHDx9yuVwKhRIaGgpBkFAoRB7BbN261czMjIg5b9++5fF4 AwMDZWVlaKWzszMyu4zDkTWBIGjjxo0WFhaXLl3icDiItkuWLME3rbq6+pdffpk/f35ISMjF ixeLiorU1NQiIiJsbGzQiV69enX27NnHjx+TyWRPT08+n+/q6uru7o604stHyM/Pv337Np/P t7KyioiIOHPmzFdffaWlpUVkZS5fvowEQSsrq8DAQLGVefPmzalTpyorKwUCgY2NDZvNdnFx IW4aPvgLi/TB2XJEVgZ/P+MjyXYZDedwOFVVVRAEMRiMjRs3IpUnT54cGhqCIIjNZpuYmIgN efz48Q8//GBjY/PgwQM6nf71118rKSndv3///PnzbW1tkZGRBw4cqK+v//Of//zdd98hQ2AY /vbbb9+8eaOmptbf34+vEs4ekP0uI4hEooyMjDt37oyOju7evXvZsmVoE84eg2R2bXznwhcu u2tDBHbg0NDQ3bt3q6qqqFTq2rVryWQyNPFNUlBQcPDgQT09vdOnT6uoqOzbt6+1tXXr1q37 9+9XVlb+8ssvGxsbMzMzVVVVX79+nZyc3N3d/eDBAwcHh5MnT/72228XLlz497///dlnn+3d u9fT0/Ps2bNju2lqao5VHmcTikSiuLg4GIb7+vpqamrCwsJ8fX0hCDp37lx+fv7ChQsPHjy4 bt26lStXisnk8Xhi+sTHx49V5tdff7148eKLFy/+/Oc/R0ZGNjc3r1+//vTp00jckzS7mPCW lpa5c+dilZFk+IQcCoKgs2fP/vDDD729vTt27Dhx4oSKisrly5fj4+M1NTWjo6NXr1797t27 uLi4ysrK9PT0BQsW4K8A8TsiK7AC+PDDD//2t79ha96+fevl5RUYGPjTTz/Fxsba29sfO3Zs 27ZtaIfw8HBvb2/E93Jzc+3t7VNSUtDW2traAwcOLF++3MfH58B/EAqFSKtAIAgNDb1z505P T8/Lly8TExO9vb3Rsc+ePfv5558tLCyQ4uDg4NWrVz08PAoLC8XULi8v37x581hz2tvbd+/e ra2tvRvD69evCa4G/vBHjx5dvXrV398/NTXV29v74MGDv/766/fffx8bGyvVND6ff/XqVW1t bSaTeezYsYqKivz8fFNT087OTqRDf3+/tbX1iRMnSkpK7t27FxkZOWfOnKKiIlQCvnwYhv/8 5z+vWrUqJyentrb2xo0bq1at0tTUJL4yJSUlV69eTUhI8Pf3F1uWlpYWKyurEydO1NXVdXR0 3Lx5c+nSpadOnSJomlTwFxaWtuXwV0bqfsYHx/YJGT52x/J4vPDw8JUrVz548ACtvHbtmo6O Tnp6+qtXr8YKMTY2RtYEeR5cXFwMw/DAwMCqVasWLFhw5swZoVB44sQJCIIePXqELt3BgweR 6+zsbAiCzp07J8lYnD0g+12GYdjMzMzR0XH37t1cLvfOnTtUKrWxsRFpwt9jsGyuLdW58IXL 6NpSd2BOTs7WrVvd3Nx27dp1/vz5o0ePMhiMsrIyeFKbZNWqVUwmE7lGDjA+fvwYKSYlJV2/ fh25DgoKQha/s7NTU1Nz9+7ddXV1ixcvNjAwSElJuXDhQlJS0rjdxl1hnE34ySefHDlyBOlW UlKipKR0+fJlpPjRRx+N3WkoY/UZV5mnT58yGAw9Pb3U1NTW1ta///3vysrKISEhiBBJs48V LqaMJMOJO5SjoyONRktJSamurv78888hCDpx4gTStH379rlz56J/FpOSkv75z38SWQHid0RG 5J9tvHv3Tk1NDRu4YRgOCws7duwYWhQIBKampqhvcLlcFos1OjqKdujp6TE3NxcLOl9//TVO UMNiamoqEonQokgkQrMNhM8++4x4toEgJmGi4A8/fPiwvr4+EujxETMNhmEdHZ2Ghga0uHPn zvT0dOS6srKSxWJhO4eFhWEDIr7869evi92Xrq4ubW1tsSFSV6a2tnas/wcEBKSlpWFr+vr6 zM3N+Xw+WoNjGkEkLSzBLYcFuzL4+1kqUm0naPi4O3ZoaIhOpz9//hytOX36NE74OHz4MI/H g2F4dHQUgqB//OMf6KTonW1sbIQgKCMjA4ZhPp8/Z84c9C/6y5cv8bMNhHH3wISMlYSZmdm/ /vUvtHjo0KGEhATkmsgegyfr2gSdi7jwCbm21B2Yk5OjpKRUUFCA1tTV1VlaWiLpzkQ3yT// +U8Igurq6mAYHh4eVldX/+tf/4o0ffLJJ4japaWlZmZm5/6Dubm5vr4+DMMbN25kMBioKEnd xmXcTVhdXY0qg+Dh4fHBBx8g1/jZhpg+OMqsX79++fLl6KiAgABVVdXh4WH82cWMxSojaa4J OZSjo2NAQAByPTIyYmNjo6OjgxRra2uVlJR++OEHpLhmzZqhoSGpK4C/CPJF/k9Smpubh4eH xT5zzs7ObmhoQIsUCiU8PBz5NA+CIOQ/y7y8POwQIyOjiooKPz8/IpPm5eVlZmY+ffoUhmET E5Pe3l6RSKSioiKzNVNHdHS0m5vb2HqpppFIJBqNhhaXLVvW3t6OXNvZ2bW3t0dGRrJYLAMD A11d3eTkZOLys7Oz9+3bh31SqKurW15eLruxo6OjJSUlWVlZ2EoSiRQYGFhYWBgSEiLVNOKM u7BEthz+yuDsZ3yI2C6L4WpqaocOHfrmm2/Onj0LQVBPT09SUlJFRYWk/rGxsQKB4B//+IdI JIIg6N27d0g99r4j7jw8PAxBUElJyejoKHpaTfYjArLfZXt7e/Ta0dEReYJGcI9NGiLOhY8s rk1kB65atcrb2xstWltbf/TRRyUlJWvXrp3oJlm/fv3ChQt/+umn7777jsPhmJubX7x4MSYm 5tmzZzQaDdG5urr6gw8+cHR0RIbcuHEDgiAYhpWUlJAnOAg43cbOO+4mRO4v9k/M8uXL79y5 09bWZmhoKMkErExUHxxllJSUsHvbw8MjOzu7ubkZf3YxY7FImmuiDoUeUVBWVvby8vr++//X 3rkHUpW1j8wXBN8AACAASURBVH8hVO4KXdzJbaKDrowYRG/vTINuo6jeTE0pSdLUNDL5VnQx lGmkoqhQ5FJK0dUl6ULG5RtD4xJJDrnVOZxj//5Yv3f/9u9c9tnOcUoz6/PX3muv9aznedaz 1lln77X3imhvb1dXV//iiy/+/e9/R0ZGbtq0qaGhwdDQkHsxA7cHSBSrra3NzMyEidLS0tu3 bydXTCAjP9uAz3vev3+PpzCZTDabPXbsWGI2LS0tvG+8efNGVlb2+fPnxAxOTk76+vpUajx8 +PCtW7f2799vZmYmKytLp9PF8QYEJtpbVQKLw9WvHAhhGjFYpaSkSkpKTp8+HRsb+/r165aW Fjk5uQsXLuBPf8nld3Z2cjzzA7zW5wrhGQaDISMjw92vVFRUOjs7qZhGHZ6OFRhyJJ4RGM/k CGH7cA1fs2ZNZGTky5cv9fX19+3b5+fnp6qqyi9zSkpKSkpKfHy8qqrqxo0bBQpvamoaGhrq 6+vj+EcxUog4fcGLU/ezcF1bYOciFy5K16YYgZqamhwSNDU1m5qa4PGwgkRGRmbNmjWJiYkH Dx5MSEjIysoyNTXNy8vLy8vbunUrzNPW1kan0+GSVRIoZiMBTohbW1txAzU0NADhZ5g61JWB zlFTUxO6dn51idKhdHR0xowZg08ddu7cOX/+/IyMjBcvXqxdu5aiEH6K9fb2vnjxAh6PyIrs kZ9taGhoKCgoEPuzrKysqqpqbW2tkZERnkhcOQVX7e3du1e4Go8fP15VVaWkpARPVVRU4J8w HCkpKY4+D//GDQsqi3dGvLhA08ipqKj4448/AgMD8ZTU1NSwsLCkpCQq8mk02v3794mr6iBs Npv4D0wI08aPH6+oqFhdXW1mZkZMv3v37o4dO4YrTQgEhhyJZwTGMzkfwXYpKamff/553759 u3fvvnv37tGjR/nlrKmp8fLyunfvHskvDQfwT1hxcTHxf/MohLqfheubAjsXuXBRujbFCCwq KhocHCSueC0sLDx8+DA8ph4kkPXr1x89ejQkJGTGjBlGRkaurq4xMTHy8vL4n3I9Pb3a2trC wkJ82lReXs79K8UvG/XXDC0tLaEts2fPhilv377V0dFRU1ODp/CZIBWoK9Pc3GxsbKykpCSw dg5wZfjVJUqHotPps2bNwic6dnZ2NjY2R44c0dfX//nnnykK4afYzJkzz549O1yVSBj5F6Wk pKRcXFw4Xn/dv3//6tWr8e+KZmZmnjt3Dr8K1zE9ePAAT2EwGAkJCcQ8JEyZMgV/zayxsXHh woV0Op0jj7q6+h9//AGPY2NjL168OCyjAACTJk3Cb12yWKzMzMxhfV9BuOJUTCOhp6dn586d xK/B1NfXE39XyOVv3br1zJkzxHYpKyuzt7fPysoS3bQDBw54e3vj/7QwDAsPD2cymdzfaBEH AkOO3DPk8SyQj2D78uXLKysrvby8Dh06NGYM3z8VNTU1bDYbrtvIyckBAPT29sJ3E1gsFj5Q whT4c7h48WIVFZU9e/Z0d3cDAJ49ewYAIN7VHz1Q9LNwASywc5ELF7FrU4lAOp3+ww8/wK9u YBh28OBBRUXFuXPn4hkoBgnEyMjI3t4+Ojoavtzn4+Nz9erVpUuX4hnc3d3hg6obN260trYm JyefOnXKxMSEwWDgj+dIsvGslGcQ2traLliwIC4uDgYkhmHXrl0LCwuD2RQUFOrr6wEAr169 4imTqA+5Ml1dXbgaSUlJcJkqee0cxhKV4VfXcDsUm83GtUpPT4+IiCBeDQkJefz4MbGVyT0g 0AkjiTgWgxQXF+vp6XEkJicnT5s2zdbW1sTExMnJKTU1VUVFhUajwXV5lZWVNjY2M2fOXLVq 1axZs/T19QMCAvCFM/fu3aPRaJMmTdLW1qb9l66uLni1tLRUX19/4cKFjo6OVlZWRUVFJiYm FhYW+NsHGIY9fPhQT0/vm2++gS99ubm5GRgY7NixA8OwsrIyKHDatGnKysrwOCAggEP/vLw8 Y2NjDw8PV1dXAwMDX1/flpYW6j7hVzwgIIBGo6mrq+vq6sKq8dXOAk1LTU2FbxrTaDS4HMzF xUVLS2vSpEmLFi3CMKyoqMjCwsLW1tbZ2XnFihXm5ubOzs4dHR0U5WMYVl5ePmvWLGtraw8P DwMDAzs7O+7VtfxMwx0L/xPAYz8/P7xgSkqKvr6+vb29m5uboaGht7c33qYCTRMIuWMxQSEn 0DPk8SwQfrZTMZxixP72228LFy4kV6O7u9vU1BQAYGVllZubO3fuXAUFhbi4uDt37ujo6EhK SsbExPT09MDV73Z2drW1tRiG3bt3T1NTU1FRcf78+UeOHJGXl/fy8iIu1cQhjwERW/nmzZt4 8atXr2IYtnLlSl1dXTU1NRqNBpcuksQYjnBdW2DnIhcuYtfGSCPQz89PT0/P399/3759mpqa 8+fPNzQ0XLduXW9vL4d6VIIEJzk5efv27fB4YGDA0tJycHCQmCE3N3fy5MkAAElJydWrV/f3 91+6dElZWVlGRubUqVN0Op1fNp7VkQRhV1eXp6fnokWL4uPjfX19iWsq4SdrZ8+ezXPRPbc+ /JRxc3PT0tLy8vIKDw9funQp8b0HfrVzC+dQhl9d1DtUbGyssbHx1q1bIyIi1q1bx3PJv66u Ls8Xi/gpSb1FREQssw0MwzZu3JiVlcWd3tzc3NbWxq8UnU5/8uQJ7gLqDAwMPH/+/MWLFyR5 mExmWVkZ9TdX+Un466+/iO8yiLs4FdP40dXVBZedv379uqioqLGxUTj5r1+/fvz4cXt7O78M onimsbERfpZguAVHBJKQo+IZ8ngWiPhsHxwcpNFo1dXVVHI2NTXB44GBAZJxioPm5mYmk8li scQ0No0gAv0sRABT6VzkwkXp2jgCI5DJZL58+XJgYID7EvUggbBYLOJ8hXveBmlsbOSe1gid jQQGg4GHLpGWlhae9g5LGTc3ty+//HJgYKChoYFnVPCrXaAy/Ayn3qHodDq/0bijo8PT01Og VjwRvUXIkcDE80l5BoOxefPmo0eP8lyj9/cAfr+FPM/evXvhcz7ESDHK3f5p1evv74c3kK9c uVJaWhoeHm5oaCiOisTNp3XjKI8xEfnbBIlYcXd37+joKCgo+NSKDI+9e/e6uLiMzp0ixDXb AAD09vZGRkb6+vpyv9fw96Curg4+SiRBR0dHXl7+4+jzD2GUu/3TqldWVoYvAwQAKCgonDp1 ShwViZtP68ZRHmMi8rcJErHi4ODQ09MDv64x+snKytqwYYOxsbG6unpaWtqnVoc3YpxtQDA+ L1IjEAgEAjEKSU5OjomJYbFYXl5eHh4eHDuZj0IaGhr8/f01NDSOHj0qplfTRUfssw0EAoFA IBD/cP6hWwUiEAgEAoH4aKDZBgKBQCAQCPGCZhsIBAKBQCDEC5ptIBAIBAKBEC8jv09KfX19 Tk5OTk5OZGQk8TP+n5D8/PysrCxpaenw8HDqpQYHB48fP97e3v7s2bOffvrJ0dFRfBr29vZG R0cvXbqUn8eOHDmiq6u7bNky8ekwCiksLOzp6Vm0aNGnVkQYPmvlEVR4//799evXs7Oz3dzc 3N3duTMIN/KIAhp+hYB8+O3o6IiJiWEwGHZ2dgsXLiReev78OYPBIP9MOADgypUrcANINzc3 a2trPD07O/vx48cYhsnLy69atYp7F72R5enTpxkZGe/evTtx4oRYK+LHyN/bkJOTa2houHHj BvFL7J8WRUXFxMRE4o4GVPD19VVTUzt06JC2tnZZWZmYdGOz2ampqa6urnv27Ont7eWZp6io aPfu3UJstv65c+XKFfjp38+Rz1r5j8ZoeyduuPqwWKzExMSenh6eV4UbeUQBDb/DQuDwe+jQ IXt7e1tb2wMHDnBMNQAA8EuscIt2EpYsWTJ58uT9+/cvXrwY39oGAPD1119ramqePXt206ZN AqcaovQUWFZOTi4pKam2tla44qIz8rONSZMmOTg4jLhYUaDRaPhGhRTp7+8/f/483H88Pj6e uNPjyCIlJbVs2TKSzT97enoSEhLwvSL/UVhaWvL7KB7Pv5IfDSq1kyiPgDCZzH379n1qLf4f w9Vn/PjxCxYsIMkgxMgjImj4HRbkw++mTZsiIiLy8vJI7qysW7cuJSWloqKCvKJvv/1WUVGx tbV16dKlxImgvb29tbW1wC9kiNJT8LKmpqYGBgZCFxedkX+SAgAYhZ/zGq5Kra2tTCbzoxnC vS8zzt69e0NCQjIyMj6OJqOK1atX87uE75/5SaBSO4nyCAAAm8328fHp7+//1Ir8X4TTR+AQ 8fEHQzT8Dheew29SUtLJkyczMjKmTJlCXnznzp2rVq16/vy5pCTZv/d//etf0tLSFy5c2LZt G/4sQ05Obvz48eTyRekpHGWH69KR7aRimW1w0NPTc/z4cTqdXlxcbG1tffTo0XHjxgEAysvL o6Ojzc3Ni4uLjY2Nf/nlFwkJiRs3bty8edPCwqK4uNjV1XX58uUkEnhmJuHkyZPR0dHv3r1b u3ZtaGiolJQUT8nJyck3btwAAERHR2dmZq5YsWLmzJksFis8PBzDsO7u7oqKCj8/v6+//hoA UFZWlpiY+Ndff33//ff+/v4LFiw4fPgwT22F4PLly/PmzZs6dSoxMTU19ccff8zLyyOfqL59 +/bkyZPl5eXKysoLFiyor6+3tbW1t7cn5snOzs7Nza2vrzcyMgoMDIyJidmzZ8/48ePz8vIe P34MAFiyZImhoeGFCxdu3bqloqLi6+s7ffp0AMDAwMD169dv3rz5559/9vf3z549+8CBA3CG fuDAAQkJCRsbm0uXLk2fPt3X1/f8+fMFBQXu7u7UFzFcvHixoaEBAGBkZMSxWuX9+/dwh62i oiI8cfbs2dLS0sRsubm5165da2hoMDY29vT0xB+XimIaxdpJlAcA9Pb2Hjt27MmTJ52dnebm 5t7e3vPmzQMAlJaW5uTkKCgobNiw4fz58/fu3ZORkQkMDDQ3NycWp9KsODdv3gwKClJXV//t t9+kpKS2bdvW3Ny8atWq7du3S0pK7t69++XLlykpKdLS0jw7I6DWxQoKChISElpaWoKDg3fs 2FFdXb1+/fojR47Aq/w6zrlz57Kzs9XU1IKCghYvXmxnZ8ctmWLnevjw4fnz51+/fr1+/frg 4ODGxsZvv/32t99+g+M4TwW4Jc+aNYtDH37DDoZhhw4d6u3tlZGR6evr4+l5DrhHnosXLx4+ fHjcuHH79+93dnYeHBwMDw9/8uRJfHw8z60euBU+efIkPw2JDGv45dni4ht+eaqXmZkpyvBL 0S0C2bt3r4aGxvTp00+fPq2iovLVV19NmDCBZ84ZM2a8ffs2LS2N3AMSEhKnTp2qrq7+/fff ra2t161bB/7/n3/qPYW6gRxlYWJOTk5ISEhNTc3KlStjYmJgIs94oNJJh4E4tnrLzs4GAFRW VsLTFStWwI2837x5M27cuC1btsB0LS0tuL0yfKT34MGDwcFBJSWlzs5ODMOqq6sjIiJIJPDL zJOZM2caGBjExsaWlpbCnYtDQ0NJdHv69CkA4P79+7iElStX4luW5+fnS0hIXLx4EcOwqqoq U1PTKVOmxMbGJiYmRkVF8ZMp0GNPnz4lJjY3N+N7c0+cODEqKgoep6enT58+/a+//iIR2NfX Z2ZmFhoamp+ff//+/eDg4DFjxnBsT7x+/XoHB4fMzMzKyspr1645ODiMGzcOXnr+/HlaWpqb m9vp06ddXV2DgoIePnwYERGB77fe2dnp6+t7586drq6u9vb2yMhIV1dXeCktLU1XV9fV1fXG jRtr1641Nzdfu3bt7du3LS0tKyoqBLoCkp+fn5aW9uuvv7q5uXFcam1t3bJli5KS0hYCHFv7 BgQEuLq6whlDVlaWlZUVvmG0KKZRrJ1E+aamJiMjo9DQ0Kqqqra2tuvXr8+YMePYsWMYhtXX 16elpcFt2UNCQkpKSrKzs3V0dIhb2FNpVg4cHBxoNBo8hnfIysvL4WlUVFRGRgY85u6MGOUu 9uHDBwcHh4kTJ8bExPT394eGhgIAnj9/Dq/y6zgYhs2dO5fbRUQodq6amhoTExN1dfXTp083 NzefOHFCUlJyw4YNJApwS+bWh19HDggICAoKgsfp6elwTOdnAr+RB8Ow1atXy8nJ4Rt+RkVF Xb58mbor+Gko9PCL8Wlx8Q2//ISLMvySmMwP7uH32bNnAAATE5Mff/wxOjrayspKTU2tpKSE n4TFixevWLGCpIpXr1599913GIY1NTWpq6vLysrC9aF4OomNGOXI5AmxrLOzM1wp8uHDh4MH DwIACgoK4CWe8cBdtSiIfbZRWFioq6t77r/o6elpaGjAbLt27SorK8MwbGhoCAAQFxfX09Mj ISGBj/twWOQngWdmfsycOdPDwwMes9lsc3NzVVVVEt04wh3uzVNVVYULdHJymjx5MjxesmSJ iYkJPCaRKdBjxHAfGhpas2bNu3fv4ClxtkGFJ0+eODo6ElP8/PyIP0sZGRmOjo7EnZQ7OjqU lJSIRXbt2qWhoYGHHTk6OjosFgse02g0qPnTp0+trKxgLcHBwfhPPkUqKyv5BbqhoSG/UvA5 K9G0rq4uPT094s+20KYJrB2Hp/IeHh5nzpwhpnR3d+vp6dXX18NTVVXVuro6/KqPj098fDx+ KrBZubl8+TIeugMDA7Kysj/++CO8tHLlStwu7s6IDaeL+fj44D55+fIlACApKQkT1HGoDGQU O9e3335rY2ODl/Lw8JCWlh4YGCBRgCiZWx9+ddXX148ZMwaO9RiGtbe3C5xtcI888LSyslJC QiI6OhqeLlq0iMlkUnQFiYZCD78YrxYX3/BLop7Qwy+5yfzgHn5hr7l06RI87evr09DQmDVr Fj8J69atmzZtGkkVxFnFgwcPpKWlNTU137x5g6dT7ynDNZBjtuHk5ASPW1paAAAnT56Epzzj ARvR2YbYn6SUlpZOnjx55syZ8BQu38UwDEZqZ2dnXFwci8UCAAwODiooKPj7++/evTs7O/vE iRMzZswgkcAzMwkyMjLwQFJS0sXFJSIi4ubNm/x04ygL770T1/LY2NjcuXOnpaVl6tSpEhIS ysrKAu0dlt9+/fVXLy8veXl5NpsNJbDZbDabDW8/CsTS0rK1tTU4ONjR0XHKlCkTJkw4fvw4 MUN6evq2bduIWk2YMOHRo0cccvbv3z9//nyeVVy9ejUlJaWmpgbDMG1t7Xfv3rFYLFy9MWPG QJmKioqwFlVV1Q8fPlC1XwTgzYyrV68SEzU1NUtKSr755hs8RWjThGZoaCg/Pz81NZWYqKio uGzZstu3b2/YsAGeEh+QzZkzh/guksBm5ebbb79VU1M7e/bskSNHbt26paend/78+QMHDvz5 558GBga4UdydEQBAvYsRAwl2k4GBASCo4why2P+VTKVzSUhIEJ+aOzk5paenNzY2kihAlMwN v7ry8/OHhobwZY/kj+oh3CNPe3u7urr6F1988e9//zsyMnLTpk0NDQ2GhoZ4ToGuINGQihU8 h1/Aq8Wjo6PFNPy2t7dTMQEMZ/glN5lcQyLQJ/h7InJycsuWLTtx4sT79+95LrNQVlbu7Oyk KHz+/PlRUVGbN29evnz5uXPnqNhILC6igXg2+GCIwWDAU57xMLKIfbbR1tZGp9O/+OIL7ksp KSkpKSnx8fGqqqobN26EiZGRkdOnT//xxx/nzJlz9uxZT09PEgncmSlqpaOjM2bMGAaDwU8y B9D1ra2tePxpaGgAQheiYu+wSElJ4VgpHRgYGBgY+OjRozlz5ggsLiUlVVJScvr06djY2Nev X7e0tMjJyV24cAFfBNDZ2cn9eNjExIQjRUVFhaf8w4cP37p1a//+/WZmZrKysnQ6nef7F8QO MLJrvriHJJw3b97IysrCF9xxnJyc4BJ3HFFMI6mdBAaDISMjw/37pKKiwm+o4sgssFm5kZGR WbNmTWJi4sGDBxMSErKyskxNTfPy8vLy8rZu3Ypn49kZgQhdDEK941CBeudSVVUFAKipqQmt AL+6mpqahoaG+vr6hNtpE448+K/jzp0758+fn5GR8eLFi7Vr1w5LFBVvDHf4BVwtLr7hV1lZ mWKDDqsRR2QEnjZtGgCATqfjKdra2hiG9ff385xtMBgMgYtJifj6+paWlsbFxe3YsQMu+fr4 PzEc8IuHEUTs3xLV09Orra0tLCzEU8rLy1+8eFFTU+Pl5RUYGAjHBUh3d/cff/zh4+NTV1f3 1Vdfbdu2bWhoiJ8EnpkpakWn02fNmmVsbMxTMnd+S0tLAAAx59u3b3V0dNTU1CjaS1ExnJs3 b7YRUFNTCw0NbWtrs7KyolK8oqLi2rVrgYGBKSkpDx48qKur+/nnn8PCwvAMNBrt/v373AXh rRSBHD9+PD09fd68eUpKSmPHjlVRUYH/ZT8aJKvzpk+fPm3atBAuKPZPKqZRXBvIwfjx4xUV FaurqznS7969O1LNypP169e3t7eHhITMmDHDyMjI1dU1Jiamra0N/4POszMCPv2RsrkAUOg4 wxJIvXM1NzcbGxsrKSlR77kc+vCrCzqtuLiYutpE4MiD/4TY2dnZ2NgcOXKkqqoKqkodKt4Y 1vALeLW4jo6OmIZfGRkZig06rEYckRHYzMxMWVmZ+OrZhw8fJk6cyC9s6HS6mZkZiUAWiwXv GeCcOHFi7ty5V65cgafUe4oQBgpsGn7xQLE4RcQy23j//j347++Wu7s7vFd848aN1tbW5OTk U6dOmZiY1NTUsNls+KAoJycHANDb29vd3R0XFwcAUFZW3rVrF5vNlpCQ4CeBwWBwZybRCv8d ZbFY6enpERER/CSD/95fwn9mbG1tFyxYEBcXB1MwDLt27Ro+yjMYDPy+E4lMEphMJvjv7TvI hAkTNAhISUkpKipqaGhIS0sXFBQsXbqU/Is3PT09O3fuJH5Rp76+nhhJW7duPXPmzIMHD/CU srIye3v7rKwsclUhU6ZMwbtiY2PjwoULif8DPgKTJk2qq6uDxywWKzMzs6OjA55u3rw5ISGB aBqDwUhISMBvWpJDxTSS2sk5cOCAt7d3U1MTPMUwLDw8nMlkuri4UCkusFl5YmRkZG9vHx0d 7evrCwDw8fG5evXq0qVL8Qw8OyOTyaTexVgsFj4kwWCGPYW84ygoKNTX1wMAXr16xU956p2r q6sLVyYpKQkuViVRgCiZWx9+dS1evFhFRWXPnj3d3d0AALicEA8GnnCPPMSrISEhjx8/Fvg9 Sm6F+Wko9PDLs8U9PDzENPySqCf08Esik0Q37uF3/PjxQUFBCQkJ8BIAoKioyN/fHx5nZGRs 27aNKKGurg5/tMGTN2/ecHyeUVZW9sqVK5MnT6ZiI5XI5Fc1sezg4CDuVaLV/OIBUOukVBmR 1R9Enj175uTkBADw9fWFa99yc3OhTyUlJVevXg3XYHd3d5uamgIArKyscnNz586dq6CgcPDg QXV19WPHjt26dWv58uX4gnmeEtra2nhm5klsbKyxsfHWrVsjIiLWrVuHL6zjKbm0tBS+y7R4 8eK8vDyYs6ury9PTc9GiRfHx8b6+vvi6sEuXLikrK8vIyJw6dYpOp/OTScL169fh12O+++47 fusWJ02ahK8SPXr0KADgm2++IZFZVFRkYWFha2vr7Oy8YsUKc3NzZ2fnjo4OYp7y8vJZs2ZZ W1t7eHgYGBjY2dndvn0bXgoICKDRaOrq6rq6ujQajUaj4YulIaWlpfr6+gsXLnR0dLSysioq KjIxMbGwsAgLC6PRaOPGjTM3Ny8rK2toaJCXl1+yZAmGYVFRUVOnTk1JSSH3BoZhZWVlsFL4 9xQe46/nQPLy8oyNjT08PFxdXQ0MDHx9fVtaWvCrlZWVNjY2M2fOXLVq1axZs/T19QMCAuDK PlFMo1K7QOVTUlL09fXt7e3d3NwMDQ29vb27urowDEtNTaXRaDIyMjQa7ebNmxiGubi4aGlp TZo0adGiRdSblSfJycnbt2+HxwMDA5aWloODg/hVnp0xLi6OYhe7c+eOjo6OpKRkTExMT08P fOnAzs6utrYW499xMAyD31qdPXs2v7Cn3rnc3Ny0tLS8vLzCw8OXLl1KXI/MUwFuydz68Kvr 3r17mpqaioqK8+fPP3LkiLy8vJeX17Nnz3iawG/kIaKrq/v27VuexUlcwVNDUYZffi0uvuGX p3ARh1+ShuMJv+GXyWRu3rzZ1dU1LS1t165dfn5++BpeLy+v8ePH42+itbe3T506tbe3l18V WVlZX375paSk5M8//0wcpjAMKy4uXr16NbmNGOXI5AleNjAwUElJSV5e/vLly+/evdu9ezcA wMbGBt6p4hkP3FWLgljeSeFJY2MjR3sMDg42NTXB44GBgbdv3w4NDbHZ7A8fPtTX1zMYDHIJ 5Jl5QqfT29vbqejGDwaDgetMDnWZQvD69et169aRZOjq6nr16hXMWVRU1NjYSCLq8ePHPN1C zsDAwPPnz1+8eDHcgiMFk8ksKyv766+/iK+fEKHT6U+ePMHHIOpQMU1g7eQ0NjbC73YMqxT1 ZuWAxWIRoxHOb4hwd0ZMqC7GD34dp6WlZWBgYLjSuDuXm5vbl19+OTAw0NDQwLNFKPZcbn34 deTm5mYmk8lisQT+ncD4jzwYhnV0dHh6egqUQAKVoYbK8IuRtrj4hl+KJmDDGX6pyySnu7v7 6dOn3d3dxMTBwUH46i/kl19+Ib44NlyIorDh9BTqBlLpZTzjgXpxKkhgo2yfAoRAhoaGfv31 Vw8PD45lj58F/v7++HMEfuzdu3e4z7AR/3Dc3d07OjoKCgo+tSLDZu/evS4uLugj958ppaWl 8fHx0dHRo/ATrqMNNNv4/Hjz5o2MjAy/VypGOXV1dfijUH7o6OjIy8t/HH0Qfw8cHBx6enrg Rws+XxNFswAAF01JREFUC7KysjZs2GBsbKyurp6Wlvap1UEIQ3l5eVFR0caNG6m8CI1Asw0E AvF5k5ycHBMTw2KxvLy8PDw8Jk2a9Kk1EkxDQ4O/v7+GhsbRo0eFe5kW8cnBhv8hpX8yaLaB QCAQCARCvKD7PwgEAoFAIMQLmm0gEAgEAoEQL2i2gUAgEAgEQryg2QYCgUAgEAjxgmYbnyWF hYU3btz41FogPiqjvNHfv3+fmpq6Zs2ajIwM8pyj3JB/LKhdhODp06d79uzZvHnzp1ZEMIOD gxERET/++KOzs/Pdu3c/vgJotvFZcuXKFfhBWcTfhv7+/rVr1/7rX/+ytrYOCAjgzjD6G53F YiUmJvb09JBnG/2GiA+BrfwJ+Se3C85wX9KUk5NLSkqqra0Vkz4jiK+vr5qa2qFDh7S1teGW KB9ZATTb+CyxtLREHx/8mzFu3LigoKAzZ86EhYXx3ONtlDf6+PHjFyxYQCWnKIa4u7sLV3CU ILCV+SGi4VSKj/IA+wgwmcx9+/YNq4ipqamBgYGY9BlB+vv7z58/Dz8/HR8fv2XLluFaKjpj PnJ9iBFh9erVn1oFxAgjKSn5xRdfAAAaGhp4Zhj9jU7xS0eiGELcBPxzRGAr80NEw6kUH/0B JlbYbLaPj09/f/9wC34WH/hqbW1lMplQVaEtFRFxzTbevn178uTJ8vJyZWXlBQsW1NfX29ra 2tvbE/Pk5uZeu3atoaHB2NjY09PT2toapufl5T1+/BgAsGTJEkNDwwsXLty6dUtFRQXuaoh3 m+3bt48bN+7Ro0d37twhpggtfPr06eRGZWVlfYTayV138eJFOE4ZGRktW7aMQ8Pe3t5jx449 efKks7PT3Nzc29t73rx58FJpaWlOTo6CgsKGDRvOnz9/7949GRmZwMBAc3NzcqtxxNSm06dP p+hYcbSpQM0p+i07Ozs3N7e+vt7IyCgwMDAmJmbPnj3jx48X2C5EE7S1tXneHuDX6FR0GxgY yMrKqqio0NXVXb58eV5eXnV1tYWFxTfffMNdUXl5eXR0tLm5eXFxsbGx8S+//CIhIVFQUJCQ kNDS0hIcHLxjx47q6ur169cfOXIEFsEw7NChQ729vTIyMn19feROFsWQ9+/fw33sioqK8MTZ s2dLS0vjp/wakaIrSIqPSIzxa+WBgYHr16/fvHnzzz//7O/vnz179oEDB/APjFIxnER5KsX5 tcuBAwckJCRsbGwuXbo0ffp0X1/f8+fPFxQUuLu7L1q0iErtgNq4gcNisY4dO9bT09PV1VVV VRUVFQVjYFiRSR6xLBYrPDwcw7Du7u6Kigo/P7+vv/4aAHDu3Lns7Gw1NbWgoKDFixfb2dlR 1A2Sk5MTEhJSU1OzcuXKmJiY4eoMhWAYFh4e3tbW1tPT09LSYmNjo6KismrVqokTJ/b09Bw/ fpxOpxcXF1tbWx89ehT/uSHCs9Lk5GS4Iic6OjozM7Ovr4/DUp7Cy8rKEhMT//rrr++//97f 33/BggUnT57k2WpUEX1jN276+vrMzMxCQ0Pz8/Pv378fHBw8ZswYjq2WAwICXF1dYQfLysqy srLCN4l+/vx5Wlqam5vb6dOnXV1dg4KCHj58GBERERYW9vjx46NHj+rq6qalpcH9f2tqav7n f/5n/vz5eIrQwgXa9RFqF+i6/Pz8tLS0X3/91c3NjUO9pqYmIyOj0NDQqqqqtra269evz5gx 49ixY/BqfX19Wloa3AM9JCSkpKQkOztbR0fnzZs3n7ZNKTpWTG0qUHMqflu/fr2Dg0NmZmZl ZeW1a9ccHBzGjRtHsV3ev3/v4uKybNmys2fPhoWFWVlZhYSEeHl5EdXj1+gCdWtqapoxY8am TZsSExN37949ffr0efPmHTx48MmTJzz9oKWlBZ3W2NgIAIB7TH/48MHBwWHixIkxMTH9/f2h oaEAgOfPn+OuCwoKgsfp6elw1ObnZ6ENwTCstbV1y5YtSkpKWwjgu36TNyIVV5AXFzHGyFu5 s7PT19f3zp07XV1d7e3tkZGRrq6u1A0nV55KcX7tkpaWpqur6+rqeuPGjbVr15qbm69du/b2 7duWlpYVFRVUaqcybhDZsmXLmTNn4PGcOXNoNBo8HlZkkkfsypUrf/rpJ9xwCQmJixcvwtO5 c+dyj6sCdXN2dtbU1Dx79uyHDx8OHjwIACgoKBiuzlBUTEzMjBkz4LGjo6O+vv79+/f7+vow DFuxYsXLly8xDHvz5s24ceO2bNnCU0melWIY9vTpUwDA/fv3eVrKU3hVVZWpqemUKVNiY2MT ExOjoqL4eYYiYpltPHnyxNHRkZji5+dHjLC8vDxHR0fixtBdXV16enrEwWXXrl0aGhq4s4jM nj376dOn+OmaNWvy8/NHSrhAxFq7QNdBKisruXuFh4cH3hkg3d3denp69fX1eIqqqmpdXR1+ 6uPjQ3GvZHG3KUbqWLG2KRXhJH7LyMjgKN7R0aGkpISfkreLn59fSEgIfqmzs1NHR4djtgHh 2ejkujk7OyclJeGXCgsLJSUlHz16xNsRGLZr1y64fGxoaAgAEBcXh8s0NDSExy9fvgQAQLH1 9fVjxoyB4xSGYe3t7eSzDaENwcHV4EBgI5K7gkoMYCLEGPVWhujo6LBYLGIKP8MpKk9SHIdn u9BotHfv3mEY9vTpUysrK1hLcHAwPp8gr53igAYpKyubMGECm82Gp+Xl5ZmZmfB4uJHJLx3u 21dVVYVX6uTkNHnyZHhMMtsg0c3Z2dnJyQket7S0AABOnjwphM4Yhrm4uHh4eMDjU6dOSUtL Dw4OYhhWWFioq6t77r/o6elpaGjw1JNfpSSzDRLhS5YsMTEx4VmREIjlSYqlpWVra2twcLCj o+OUKVMmTJhw/PhxYgY4/7169SoxUVNTs6SkhHiDd//+/fPnz+eW/9NPPx0+fPjSpUsAgObm 5sbGRuJdLxGFC0SstQt0HT+Ghoby8/NTU1OJiYqKisuWLbt9+/aGDRvwFOKapjlz5rS2tlKR L+42BaSOFWubUhFO4rf09PRt27YRn91OmDDh0aNH8Fhgu6Snp9fV1eGXVFRUAgIC4NBAEX66 dXd319TUeHp64pdsbW1nzpxJIiosLKyzszMuLo7FYgEABgcHYTrROniHf2BgAACQn58/NDSk o6MDL4m4E6bQwQkENaJAV1AMMCBsjAls5atXr6akpNTU1GAYpq2t/e7dOxaLJSUlRUU4deWF Y8yYMQCACRMmKCoqwkhQVVX98OEDldqHNaA9fPhQU1MTjyILCwsLCwt4PNzI5JcOH4cRt8Gz sbG5c+dOS0vL1KlTSZxAohuxugkTJgAAGAyGEDpDv+Xn58NjZWVlZWVl6PzS0tLJkyfjEXvt 2jXAZ084fpWSQCJcQkJCWVlZoASKiGW2ISUlVVJScvr06djY2NevX7e0tMjJyV24cAF/yvXm zRtZWdnnz58TSzk5OcEVszj8NlVfvHjx3r176+vrDQwMfv311x07dhCviihcIGKtXaDr+MFg MGRkZLiHexUVlc7OTn6lqP88iLtNAaljxdqmFIUTIfqts7Nz4sSJHBlMTEzgAXm7MJlMNps9 duxY4iUtLa1hzTb46dbT0yMnJ8dxVUlJiaRsSkpKSkpKfHy8qqrqxo0bBdbV1NQ0NDTU19cn jl1MeQYnxue1PfJGFOgK6jEgRIwJbOXDhw/funVr//79ZmZmsrKydDqd+90QfoZTVJ6kOEWI P2zEY/LahzWgtba2wnsD3Aw3MvkBf31bW1s1NTVhioaGBgBARkaGvCCJbvwQQuegoKCCgoKw sDBPT8+kpKTo6GiY3tbWRqfT4friEa+UunAREctso6Ki4o8//ggMDMRTUlNTw8LCkpKS4Clc V7V3717h5EtISAQFBR09evTAgQMlJSWRkZHEqyIK/7S1C3QdP8aPH6+oqFhdXW1mZkZMv3v3 Lsd8SEyKie52EseKtU1FFE6j0e7fv8+x6hMAwGazpaSkyNtFVlZWVVW1trbWyMgIv0RczScK WlpaLBarvLx8xowZMKW1tbW4uJhf/pqaGi8vr3v37qmqqlKsAt7VKC4udnV1FV1hKvBbiEre iAJdIdYAE9jKx48fr6qqwmc/Kioq+J9dHJIVuFSUF7iAV2jIax/WgDZt2rSOjo6bN28uXLgQ phQVFVlbWzc2Ng43MvlhaWkJACgsLJw9ezZMefv2rY6OjpqaGjyFDyCo68YxicQRojcBAExM TDZu3KiqqlpYWHjs2DFtbW2YrqenV1tbW1hYiE9Dy8vLZWVl8X81QlSKW0pRuOiI5XsbPT09 O3fuhKtUIPX19UT7N2/enJCQ8ODBAzyFwWAkJCScO3eOYhXffffdgwcPgoOD/fz8OC6JLvwT 1i7QdSQcOHDA29u7qakJnmIYFh4ezmQyXVxcqBTfvXt3YGAgm80WTrERcTs/x4q1TUUUvnXr 1jNnzhCLl5WV2dvbZ2VlwVPydtm/f//q1avb2trg1czMzBEM1JiYmGXLlmVkZLx+/fru3bvf fPMN920YnJqaGjabDR/65uTkAAB6e3uZTCYAgMVi4WMTTIE/h4sXL1ZRUdmzZ093dzcA4Nmz ZwAA4iODEWfSpEm4fBaLlZmZCb9aIbARyV0h7kGDvJWnTJmCv5PV2Ni4cOFCOp1O0XCKypMU FxHy2oc1oHl4eKirq3t7e1++fLmuri4+Pj4/P3/s2LFCRCa/dFtb2wULFsTFxcFTDMOuXbsW FhYGcyooKNTX1wMAXr16RVE3AMDg4CA+O8S1EkJnAEBYWFh9fb2dnd2iRYvgTReIu7s7fPx6 48aN1tbW5OTkU6dOcc8GSCqFD3fwioiWkghnMBhUnsVQZaQWgBApKiqysLCwtbV1dnZesWKF ubm5s7NzR0cHMU9lZaWNjc3MmTNXrVo1a9YsfX39gIAAuNwsICCARqOpq6vr6urSaDQajYYv ISYSExOjr6/PsZZqpIQLREy1k7uurKwMljI2NoYL+Gk0mp+fH148JSVFX1/f3t7ezc3N0NDQ 29u7q6sLXkpNTaXRaDIyMjQa7ebNmxiGubi4aGlpTZo0adGiRRiG6enpAQBu3brF096P06Yk jhVrm5IIF+g3DMPKy8tnzZplbW3t4eFhYGBgZ2d3+/ZtonySdsEwLDk5edq0aba2tiYmJk5O TqmpqSoqKjQaDa6zI2l0KrpVVFT85z//mTNnzooVK0pKStzd3YlLcYl0d3ebmpoCAKysrHJz c+fOnaugoBAXF3fnzh0dHR1JScmYmJienp4ffvgBAGBnZ1dbW4th2L179zQ1NRUVFefPn3/k yBF5eXkvL69nz55xyxfREEheXp6xsbGHh4erq6uBgYGvr29LS4vARqTiCvLioscYSSuXlpbq 6+svXLjQ0dHRysqqqKjIxMTEwsKC+MILieFUbCcpTtIuNBpt3Lhx5ubmZWVlDQ0N8vLyS5Ys wTAsKipq6tSpKSkpAmunMm4Qefz4saGhIQBASkrK398fjgPDjcyTJ0+SRGxXV5enp+eiRYvi 4+N9fX2Ji5rhp1Rnz57NcyEwT92ysrKUlJTk5eUvX7787t273bt3AwBsbGweP34sRG+KjIwk LtaxtrZOT0+Htefm5k6ePBkAICkpuXr16v7+fm4N+TmqtLR0+fLlAIDFixfn5eVxW8pT+KVL l5SVlWVkZE6dOkWn0/mHNlUkMDF8vvTdu3f9/f1Tp05ta2t7+fKlpqYmfkeIg87OzpcvX+rr 64t+i+wjCxdT7dRdR0JTU1NnZ6eJiQm/u3w8GRwcjIyMtLOz434oMCzFPt82FVF4W1tbc3Oz rq4ufleWA/J2efXqlbS0NPEPjTgwMTEpLCzkd4eDxWK9fv1aS0sLADA4ONjd3U1yL4TIq1ev 1NXVpaSkmEwm/pURMTEwMFBdXa2srKyjo8O9So56I/J0hbgHDX6tPDg4WF1dPXbsWGNjY35l yQ0HgpQXWFxEeNYu3IDW0tKioqJCDCShI5MfTCazvb0dCiTS2tqqpqbG8S0Tct34IYTOUVFR 1tbWGhoadDq9r6+vo6MjNjb23r17eHs1NTWpqqrKy8uLXim3pQKFi4hYZhufKf7+/vjtbn7s 3bsXPvn7+1FbW5udnb19+/ZPrchI8g9vUwidTmcwGE1NTfHx8UwmMzEx8VNr9MkYcVegAEOM FLdv3w4ODuZYWRUWFgbvl/wNQLON/0ddXR18xEWCjo6O+KZ+n5b//d//hXfh/k78w9sUsmbN ms7OzqlTp9rb269YsULE91Q/a0bcFSjAECNFcnKyt7f3tm3bXF1d5eTkWltbnz59umzZMo5P 4n6+oNkGAoFAIBCfnuvXr+fl5ZWXl2tra8+bN+8///mPrKzsp1ZqxECzDQQCgUAgEOLln3tP FYFAIBAIxMcBzTYQCAQCgUCIFzTbQCAQCAQCIV7QbAOBQCAQCIR4QbMNBAKBQCAQ4uWjzjaE e/8FvTWDQCAQCMRnzcebbTCZzH379n2cUggEAoFAIEYPYtlxnhs2m+3j49Pf3/8RSiEQCAQC gRhViOXexo0bN+A23D4+PpcvXwYAnDt3Ljs7u7KyMigoqKCgAABQXl7+/fffHzt27LvvvgsJ CYGPS8rKygICAtzc3LKzsw0MDMaOHUsslZWVRaPRNm/eDAB48eLFpk2bzM3NHz16BAB4+PDh pk2b3Nzcrl+/bmVlNWHChHXr1r1//14c1iEQCAQCgRgeom8jy8Hg4KCSklJnZyeGYdXV1RER ETB97ty5bm5ueDYtLS24n3JjYyMAAO57W1VVZWpqOmXKlNjY2MTExKioKI5SlpaWX3/9NTy+ f/8+AABu7V1TU2NiYqKurn769Onm5uYTJ05ISkpu2LBhxK1DIBAIBAIxXEb+3saHDx96enpi Y2MBAKamps7OzjyzrVq1auHChQAAuDduXV0dAMDMzMzMzExRUXHDhg3e3t7+/v4cpeTk5PBj 4kZHRkZGxsbGhoaG33//vaampq+vr5ub29mzZwcHB0faPgQCgUAgEMNj5GcbCgoK/v7+u3fv /vLLL8vLyy0sLHhmCwsL09bWjouLO3XqFAAAnxZISEgoKysLUa+EhARxR0cnJ6fBwUF44wSB QCAQCMQnRCzrNiIjI8+cOfPixYs5c+YkJyfzzJOSkrJu3Tp3d/cffvhBHDqoqqoCANTU1MQh HIFAIBAIBHVGfrbR3d39xx9/+Pj41NXVffXVV9u2bRsaGoKX8IOamhovL6/AwEA4JyAHL8Vx ymazSUo1NzcbGxsrKSkJYwMCgUAgEIiRY+RnGwwGIy4uDgCgrKy8a9cuNpstISEBAFBQUKiv rwcAvHr1qqamhs1ml5WVYRiWk5MDAOjt7WUymbA4cbEFsRQAYPLkySUlJZ2dnSwW6/r16wCA trY2PHNXVxc8YLFYSUlJoaGh8DQjI2Pbtm0jbikCgUAgEAgqiOVJSkpKyvHjx3Nzc3///fcz Z87A2cby5curqqrmzJnz8uVLBwcHU1NTf3//mTNnjhkzZu7cuaGhoRcvXrx8+XJhYWFFRcXp 06c7Ozs5SgEAgoKCMAzT1tZ2cnKaP3++goJCTk4OnIgAAHp6ery9vQ8dOuTp6blp06bly5fD 9PT09NOnT/f29orDWAQCgUAgEORIYCP9XXD4rsvAwEBra+vUqVNlZWXxS62trWpqatLS0gAA Fov1+vVr+ELK4OBgd3f3xIkTeQoklgIAMBiM9vZ2bW1tFovFZrNx+e7u7h0dHXfv3m1tbdXW 1oZTHAiLxert7VVRURlZSxEIBAKBQFBh5Gcbnwo424CfDkMgEAgEAjF6+PvsAdvV1YW+cY5A IBAIxCjkbzLbSE5OHhoaGjt27O+//05cN4pAIBAIBOKT8/d5koJAIBAIBGJ08je5t4FAIBAI BGLUgmYbCAQCgUAgxAuabSAQCAQCgRAvaLaBQCAQCARCvPwfDXaiy0mPmDgAAAAASUVORK5C YII= --nsrsbbtvuxugaayv-- ^ permalink raw reply [nested|flat] 2+ messages in thread
end of thread, other threads:[~2024-01-30 14:27 UTC | newest] Thread overview: 2+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-02-24 17:33 [PATCH v6 2/2] Add a --outdated option to reindexdb Julien Rouhaud <[email protected]> 2024-01-30 14:27 [PATCH v2] Update PQparameterStatus and ParameterStatus docs Alvaro Herrera <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox