From: Bjorn Munch Date: September 10 2010 9:52am Subject: bzr push into mysql-next-mr-merge branch (bjorn.munch:3205 to 3208) List-Archive: http://lists.mysql.com/commits/117988 Message-Id: <201009100953.o8A9rhwb028388@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============1726680944==" --===============1726680944== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline 3208 Bjorn Munch 2010-09-10 fixed some result files after upmerge of 54190 modified: mysql-test/r/select_none.result mysql-test/r/subquery_none.result 3207 Bjorn Munch 2010-09-10 [merge] upmerge from trunk-merge modified: include/mysql.h include/mysql.h.pp libmysql/libmysql.c mysql-test/include/select.inc mysql-test/r/gis.result mysql-test/r/multi_update.result mysql-test/r/row.result mysql-test/r/select_all.result mysql-test/r/subquery_all.result mysql-test/r/trigger_notembedded.result mysql-test/t/gis.test mysql-test/t/multi_update.test mysql-test/t/row.test mysql-test/t/trigger_notembedded.test sql/item.cc sql/item_cmpfunc.cc sql/item_subselect.cc sql/spatial.cc sql/sql_trigger.cc tests/mysql_client_test.c 3206 Bjorn Munch 2010-09-10 [merge] merge 55178,55413,56383 modified: client/mysqltest.cc mysql-test/lib/mtr_cases.pm mysql-test/mysql-test-run.pl mysql-test/r/mysqltest.result mysql-test/t/mysqltest.test 3205 Alexander Nozdrin 2010-09-06 [merge] Auto-merge from mysql-trunk-merge. === modified file 'client/mysqltest.cc' --- a/client/mysqltest.cc 2010-08-27 13:00:00 +0000 +++ b/client/mysqltest.cc 2010-09-10 09:23:27 +0000 @@ -5257,8 +5257,10 @@ void do_connect(struct st_command *comma } #endif +#ifndef EMBEDDED_LIBRARY if (opt_protocol) mysql_options(&con_slot->mysql, MYSQL_OPT_PROTOCOL, (char*) &opt_protocol); +#endif #ifdef HAVE_SMEM if (con_shm) @@ -5544,6 +5546,8 @@ int read_line(char *buf, int size) char c, UNINIT_VAR(last_quote), last_char= 0; char *p= buf, *buf_end= buf + size - 1; int skip_char= 0; + my_bool have_slash= FALSE; + enum {R_NORMAL, R_Q, R_SLASH_IN_Q, R_COMMENT, R_LINE_START} state= R_LINE_START; DBUG_ENTER("read_line"); @@ -5615,9 +5619,13 @@ int read_line(char *buf, int size) } else if (c == '\'' || c == '"' || c == '`') { - last_quote= c; - state= R_Q; + if (! have_slash) + { + last_quote= c; + state= R_Q; + } } + have_slash= (c == '\\'); break; case R_COMMENT: @@ -7989,8 +7997,10 @@ int main(int argc, char **argv) mysql_options(&con->mysql, MYSQL_SET_CHARSET_DIR, opt_charsets_dir); +#ifndef EMBEDDED_LIBRARY if (opt_protocol) mysql_options(&con->mysql,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol); +#endif #if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) === modified file 'include/mysql.h' --- a/include/mysql.h 2010-07-20 17:54:05 +0000 +++ b/include/mysql.h 2010-09-07 07:49:47 +0000 @@ -208,7 +208,8 @@ struct st_mysql_options { enum mysql_status { - MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,MYSQL_STATUS_USE_RESULT + MYSQL_STATUS_READY, MYSQL_STATUS_GET_RESULT, MYSQL_STATUS_USE_RESULT, + MYSQL_STATUS_STATEMENT_GET_RESULT }; enum mysql_protocol_type === modified file 'include/mysql.h.pp' --- a/include/mysql.h.pp 2010-07-23 14:24:00 +0000 +++ b/include/mysql.h.pp 2010-09-10 08:06:58 +0000 @@ -297,7 +297,8 @@ struct st_mysql_options { }; enum mysql_status { - MYSQL_STATUS_READY,MYSQL_STATUS_GET_RESULT,MYSQL_STATUS_USE_RESULT + MYSQL_STATUS_READY, MYSQL_STATUS_GET_RESULT, MYSQL_STATUS_USE_RESULT, + MYSQL_STATUS_STATEMENT_GET_RESULT }; enum mysql_protocol_type { === modified file 'libmysql/libmysql.c' --- a/libmysql/libmysql.c 2010-07-23 20:13:36 +0000 +++ b/libmysql/libmysql.c 2010-09-09 12:36:57 +0000 @@ -2118,6 +2118,8 @@ static my_bool execute(MYSQL_STMT *stmt, set_stmt_errmsg(stmt, net); DBUG_RETURN(1); } + else if (mysql->status == MYSQL_STATUS_GET_RESULT) + stmt->mysql->status= MYSQL_STATUS_STATEMENT_GET_RESULT; DBUG_RETURN(0); } @@ -2256,7 +2258,7 @@ static int stmt_read_row_unbuffered(MYSQ set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL); return 1; } - if (mysql->status != MYSQL_STATUS_GET_RESULT) + if (mysql->status != MYSQL_STATUS_STATEMENT_GET_RESULT) { set_stmt_error(stmt, stmt->unbuffered_fetch_cancelled ? CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC, @@ -4448,7 +4450,7 @@ int STDCALL mysql_stmt_store_result(MYSQ DBUG_RETURN(1); } } - else if (mysql->status != MYSQL_STATUS_GET_RESULT) + else if (mysql->status != MYSQL_STATUS_STATEMENT_GET_RESULT) { set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate, NULL); DBUG_RETURN(1); @@ -4872,6 +4874,9 @@ int STDCALL mysql_stmt_next_result(MYSQL DBUG_RETURN(rc); } + if (mysql->status == MYSQL_STATUS_GET_RESULT) + mysql->status= MYSQL_STATUS_STATEMENT_GET_RESULT; + stmt->state= MYSQL_STMT_EXECUTE_DONE; stmt->bind_result_done= FALSE; === modified file 'mysql-test/include/select.inc' --- a/mysql-test/include/select.inc 2010-07-23 17:51:11 +0000 +++ b/mysql-test/include/select.inc 2010-09-10 09:23:27 +0000 @@ -3783,11 +3783,6 @@ SELECT 1 FROM t1 WHERE a <> 1 AND NOT ROW(1,a) <=> ROW(1,(SELECT 1 FROM t1)) INTO @var0; -# Query correctly return 2 rows since comparison a <=> fisrt_subquery is -# always false, thus the second query is never executed. -SELECT 1 FROM t1 WHERE a <> 1 AND NOT -ROW(a,a) <=> ROW((SELECT 1 FROM t1 WHERE 1=2),(SELECT 1 FROM t1)); - DROP TABLE t1; --echo # === modified file 'mysql-test/lib/mtr_cases.pm' --- a/mysql-test/lib/mtr_cases.pm 2010-08-16 07:30:40 +0000 +++ b/mysql-test/lib/mtr_cases.pm 2010-09-02 08:06:12 +0000 @@ -701,6 +701,13 @@ sub process_opts_file { next; } + $value= mtr_match_prefix($opt, "--testcase-timeout="); + if ( defined $value ) { + # Overrides test case timeout for this test + $tinfo->{'case-timeout'}= $value; + next; + } + # Ok, this was a real option, add it push(@{$tinfo->{$opt_name}}, $opt); } === modified file 'mysql-test/mysql-test-run.pl' --- a/mysql-test/mysql-test-run.pl 2010-08-25 13:59:17 +0000 +++ b/mysql-test/mysql-test-run.pl 2010-09-02 08:06:12 +0000 @@ -231,7 +231,6 @@ my $opt_suite_timeout = $ENV{MTR_SUITE my $opt_shutdown_timeout= $ENV{MTR_SHUTDOWN_TIMEOUT} || 10; # seconds my $opt_start_timeout = $ENV{MTR_START_TIMEOUT} || 180; # seconds -sub testcase_timeout { return $opt_testcase_timeout * 60; }; sub suite_timeout { return $opt_suite_timeout * 60; }; sub check_timeout { return $opt_testcase_timeout * 6; }; @@ -245,6 +244,7 @@ my $opt_repeat= 1; my $opt_retry= 3; my $opt_retry_failure= env_or_val(MTR_RETRY_FAILURE => 2); my $opt_reorder= 1; +my $opt_force_restart= 0; my $opt_strace_client; @@ -260,6 +260,17 @@ my $opt_callgrind; my %mysqld_logs; my $opt_debug_sync_timeout= 300; # Default timeout for WAIT_FOR actions. +sub testcase_timeout ($) { + my ($tinfo)= @_; + if (exists $tinfo->{'case-timeout'}) { + # Return test specific timeout if *longer* that the general timeout + my $test_to= $tinfo->{'case-timeout'}; + $test_to*= 10 if $opt_valgrind; + return $test_to * 60 if $test_to > $opt_testcase_timeout; + } + return $opt_testcase_timeout * 60; +} + our $opt_warnings= 1; our $opt_skip_ndbcluster= 0; @@ -934,6 +945,7 @@ sub command_line_setup { 'report-features' => \$opt_report_features, 'comment=s' => \$opt_comment, 'fast' => \$opt_fast, + 'force-restart' => \$opt_force_restart, 'reorder!' => \$opt_reorder, 'enable-disabled' => \&collect_option, 'verbose+' => \$opt_verbose, @@ -3552,7 +3564,7 @@ sub run_testcase ($) { } } - my $test_timeout= start_timer(testcase_timeout()); + my $test_timeout= start_timer(testcase_timeout($tinfo)); do_before_run_mysqltest($tinfo); @@ -3752,7 +3764,7 @@ sub run_testcase ($) { { my $log_file_name= $opt_vardir."/log/".$tinfo->{shortname}.".log"; $tinfo->{comment}= - "Test case timeout after ".testcase_timeout(). + "Test case timeout after ".testcase_timeout($tinfo). " seconds\n\n"; # Add 20 last executed commands from test case log file if (-e $log_file_name) @@ -3761,7 +3773,7 @@ sub run_testcase ($) { "== $log_file_name == \n". mtr_lastlinesfromfile($log_file_name, 20)."\n"; } - $tinfo->{'timeout'}= testcase_timeout(); # Mark as timeout + $tinfo->{'timeout'}= testcase_timeout($tinfo); # Mark as timeout run_on_all($tinfo, 'analyze-timeout'); report_failure_and_restart($tinfo); @@ -4567,6 +4579,11 @@ sub server_need_restart { return 1; } + if ( $opt_force_restart ) { + mtr_verbose_restart($server, "forced restart turned on"); + return 1; + } + if ( $tinfo->{template_path} ne $current_config_name) { mtr_verbose_restart($server, "using different config file"); @@ -5601,6 +5618,7 @@ Misc options servers to exit before finishing the process fast Run as fast as possible, dont't wait for servers to shutdown etc. + force-restart Always restart servers between tests parallel=N Run tests in N parallel threads (default=1) Use parallel=auto for auto-setting of N repeat=N Run each test N number of times === modified file 'mysql-test/r/gis.result' --- a/mysql-test/r/gis.result 2010-06-09 14:16:33 +0000 +++ b/mysql-test/r/gis.result 2010-09-10 09:23:27 +0000 @@ -1057,6 +1057,13 @@ NULL SELECT Polygon(12345123,''); Polygon(12345123,'') NULL +# +# BUG#51875: crash when loading data into geometry function polyfromwkb +# +SET @a=0x00000000030000000100000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); +SET @a=0x00000000030000000000000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); End of 5.1 tests CREATE TABLE t1( col0 BINARY NOT NULL, === modified file 'mysql-test/r/multi_update.result' --- a/mysql-test/r/multi_update.result 2010-06-19 09:24:34 +0000 +++ b/mysql-test/r/multi_update.result 2010-09-10 08:06:58 +0000 @@ -649,4 +649,24 @@ SET SESSION sql_safe_updates = 1; UPDATE IGNORE t1, t1 t1a SET t1.a = 1 WHERE t1a.a = 1; ERROR HY000: You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column DROP TABLE t1; +# +# Bug#54543: update ignore with incorrect subquery leads to assertion +# failure: inited==INDEX +# +SET SESSION sql_safe_updates = 0; +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); +CREATE TABLE t2 ( a INT ); +INSERT INTO t2 VALUES (1), (2); +CREATE TABLE t3 ( a INT ); +INSERT INTO t3 VALUES (1), (2); +# Should not crash +UPDATE IGNORE +( SELECT ( SELECT COUNT(*) FROM t1 GROUP BY a, @v ) a FROM t2 ) x, t3 +SET t3.a = 0; +Warnings: +Error 1242 Subquery returns more than 1 row +Error 1242 Subquery returns more than 1 row +DROP TABLE t1, t2, t3; +SET SESSION sql_safe_updates = DEFAULT; end of tests === modified file 'mysql-test/r/mysqltest.result' --- a/mysql-test/r/mysqltest.result 2010-08-16 07:30:40 +0000 +++ b/mysql-test/r/mysqltest.result 2010-09-02 08:06:12 +0000 @@ -262,6 +262,9 @@ a long \$where variable content banana = banana Not a banana: ba\$cat\$cat +with\`some"escaped\'quotes +with\`some"escaped\'quotes +single'tick`backtick mysqltest: At line 1: Missing arguments to let mysqltest: At line 1: Missing variable name in let mysqltest: At line 1: Missing assignment operator in let === modified file 'mysql-test/r/row.result' --- a/mysql-test/r/row.result 2010-06-22 09:52:50 +0000 +++ b/mysql-test/r/row.result 2010-09-10 09:23:27 +0000 @@ -466,3 +466,26 @@ SELECT 1 FROM t1 WHERE ROW(a, b) >= ROW('1', (SELECT 1 FROM t1 WHERE a > 1234)); 1 DROP TABLE t1; +# +# Bug #54190: Comparison to row subquery produces incorrect result +# +SELECT ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0) +NULL +SELECT ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); +ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0) +NULL +CREATE TABLE t1 (i INT); +INSERT INTO t1 () VALUES (1), (2), (3); +SELECT ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0); +ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0) +NULL +SELECT ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0); +ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0) +NULL +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +i +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); +i +DROP TABLE t1; +End of 5.1 tests === modified file 'mysql-test/r/select_all.result' --- a/mysql-test/r/select_all.result 2010-08-26 21:32:48 +0000 +++ b/mysql-test/r/select_all.result 2010-09-10 09:23:27 +0000 @@ -4431,11 +4431,6 @@ SELECT 1 FROM t1 WHERE a <> 1 AND NOT ROW(1,a) <=> ROW(1,(SELECT 1 FROM t1)) INTO @var0; ERROR 21000: Subquery returns more than 1 row -SELECT 1 FROM t1 WHERE a <> 1 AND NOT -ROW(a,a) <=> ROW((SELECT 1 FROM t1 WHERE 1=2),(SELECT 1 FROM t1)); -1 -1 -1 DROP TABLE t1; # # Bug #48458: simple query tries to allocate enormous amount of === modified file 'mysql-test/r/select_none.result' --- a/mysql-test/r/select_none.result 2010-08-27 06:36:54 +0000 +++ b/mysql-test/r/select_none.result 2010-09-10 09:38:40 +0000 @@ -4430,11 +4430,6 @@ SELECT 1 FROM t1 WHERE a <> 1 AND NOT ROW(1,a) <=> ROW(1,(SELECT 1 FROM t1)) INTO @var0; ERROR 21000: Subquery returns more than 1 row -SELECT 1 FROM t1 WHERE a <> 1 AND NOT -ROW(a,a) <=> ROW((SELECT 1 FROM t1 WHERE 1=2),(SELECT 1 FROM t1)); -1 -1 -1 DROP TABLE t1; # # Bug #48458: simple query tries to allocate enormous amount of === modified file 'mysql-test/r/subquery_all.result' --- a/mysql-test/r/subquery_all.result 2010-07-23 17:51:11 +0000 +++ b/mysql-test/r/subquery_all.result 2010-09-10 09:23:27 +0000 @@ -923,7 +923,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a') (select c from t1 where a=t2.a) 1 1 a 2 0 b -NULL 0 NULL +NULL NULL NULL select a, (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b'),(select c from t1 where a=t2.a) from t2; a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b') (select c from t1 where a=t2.a) 1 0 a @@ -933,7 +933,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,4,'c') (select c from t1 where a=t2.a) 1 0 a 2 0 b -NULL 0 NULL +NULL NULL NULL drop table t1,t2; create table t1 (a int, b real, c varchar(10)); insert into t1 values (1, 1, 'a'), (2,2,'b'), (NULL, 2, 'b'); === modified file 'mysql-test/r/subquery_none.result' --- a/mysql-test/r/subquery_none.result 2010-08-27 06:36:54 +0000 +++ b/mysql-test/r/subquery_none.result 2010-09-10 09:38:40 +0000 @@ -922,7 +922,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a') (select c from t1 where a=t2.a) 1 1 a 2 0 b -NULL 0 NULL +NULL NULL NULL select a, (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b'),(select c from t1 where a=t2.a) from t2; a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b') (select c from t1 where a=t2.a) 1 0 a @@ -932,7 +932,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,4,'c') (select c from t1 where a=t2.a) 1 0 a 2 0 b -NULL 0 NULL +NULL NULL NULL drop table t1,t2; create table t1 (a int, b real, c varchar(10)); insert into t1 values (1, 1, 'a'), (2,2,'b'), (NULL, 2, 'b'); === modified file 'mysql-test/r/trigger_notembedded.result' --- a/mysql-test/r/trigger_notembedded.result 2010-04-14 10:33:14 +0000 +++ b/mysql-test/r/trigger_notembedded.result 2010-09-10 08:06:58 +0000 @@ -472,4 +472,25 @@ SHOW CREATE TRIGGER db1.trg; ERROR 42000: Access denied; you need (at least one of) the TRIGGER privilege(s) for this operation DROP USER 'no_rights'@'localhost'; DROP DATABASE db1; +DROP DATABASE IF EXISTS mysqltest_db1; +CREATE DATABASE mysqltest_db1; +USE mysqltest_db1; +GRANT ALL ON mysqltest_db1.* TO mysqltest_u1@localhost; +CREATE TABLE t1 ( +a1 int, +a2 int +); +INSERT INTO t1 VALUES (1, 20); +CREATE TRIGGER mysqltest_db1.upd_t1 +BEFORE UPDATE ON t1 FOR EACH ROW SET new.a2 = 200; +CREATE TABLE t2 ( +a1 int +); +INSERT INTO t2 VALUES (2); +REVOKE ALL PRIVILEGES, GRANT OPTION FROM mysqltest_u1@localhost; +UPDATE IGNORE t1, t2 SET t1.a1 = 2, t2.a1 = 3 WHERE t1.a1 = 1 AND t2.a1 = 2; +ERROR 42000: TRIGGER command denied to user 'mysqltest_u1'@'localhost' for table 't1' +DROP DATABASE mysqltest_db1; +DROP USER mysqltest_u1@localhost; +USE test; End of 5.1 tests. === modified file 'mysql-test/t/gis.test' --- a/mysql-test/t/gis.test 2010-03-01 09:45:36 +0000 +++ b/mysql-test/t/gis.test 2010-09-06 09:54:44 +0000 @@ -725,6 +725,16 @@ SELECT Polygon(123451,''); SELECT Polygon(1234512,''); SELECT Polygon(12345123,''); + +--echo # +--echo # BUG#51875: crash when loading data into geometry function polyfromwkb +--echo # +SET @a=0x00000000030000000100000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); +SET @a=0x00000000030000000000000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); + + --echo End of 5.1 tests # === modified file 'mysql-test/t/multi_update.test' --- a/mysql-test/t/multi_update.test 2010-08-20 08:48:59 +0000 +++ b/mysql-test/t/multi_update.test 2010-09-10 08:06:58 +0000 @@ -650,5 +650,26 @@ SET SESSION sql_safe_updates = 1; UPDATE IGNORE t1, t1 t1a SET t1.a = 1 WHERE t1a.a = 1; DROP TABLE t1; +--echo # +--echo # Bug#54543: update ignore with incorrect subquery leads to assertion +--echo # failure: inited==INDEX +--echo # +SET SESSION sql_safe_updates = 0; +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); + +CREATE TABLE t2 ( a INT ); +INSERT INTO t2 VALUES (1), (2); + +CREATE TABLE t3 ( a INT ); +INSERT INTO t3 VALUES (1), (2); + +--echo # Should not crash +UPDATE IGNORE + ( SELECT ( SELECT COUNT(*) FROM t1 GROUP BY a, @v ) a FROM t2 ) x, t3 +SET t3.a = 0; + +DROP TABLE t1, t2, t3; +SET SESSION sql_safe_updates = DEFAULT; --echo end of tests === modified file 'mysql-test/t/mysqltest.test' --- a/mysql-test/t/mysqltest.test 2010-08-16 07:30:40 +0000 +++ b/mysql-test/t/mysqltest.test 2010-09-02 08:06:12 +0000 @@ -701,6 +701,16 @@ echo banana = $cat; let $cat=ba\\\$cat\\\$cat; echo Not a banana: $cat; +# Bug #55413 would cause this to fail +let $escape= with\`some\"escaped\'quotes; +echo $escape; + +--let $escape= with\`some\"escaped\'quotes +echo $escape; + +# This only works with "--let" syntax +--let $tick= single'tick`backtick +echo $tick; # Test illegal uses of let === modified file 'mysql-test/t/row.test' --- a/mysql-test/t/row.test 2010-04-16 11:42:34 +0000 +++ b/mysql-test/t/row.test 2010-09-09 12:46:13 +0000 @@ -266,3 +266,22 @@ SELECT 1 FROM t1 WHERE ROW(a, b) >= ROW('1', (SELECT 1 FROM t1 WHERE a > 1234)); --enable_warnings DROP TABLE t1; + +--echo # +--echo # Bug #54190: Comparison to row subquery produces incorrect result +--echo # + +SELECT ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +SELECT ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); + +CREATE TABLE t1 (i INT); +INSERT INTO t1 () VALUES (1), (2), (3); + +SELECT ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0); +SELECT ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0); +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); + +DROP TABLE t1; + +--echo End of 5.1 tests === modified file 'mysql-test/t/trigger_notembedded.test' --- a/mysql-test/t/trigger_notembedded.test 2010-08-06 11:29:37 +0000 +++ b/mysql-test/t/trigger_notembedded.test 2010-09-07 09:00:41 +0000 @@ -932,4 +932,52 @@ disconnect con1; DROP USER 'no_rights'@'localhost'; DROP DATABASE db1; +# +# Bug#55421 Protocol::end_statement(): Assertion `0' on multi-table UPDATE IGNORE +# To reproduce a crash we need to provoke a trigger execution with +# the following conditions: +# - active SELECT statement during trigger execution +# (i.e. LEX::current_select != NULL); +# - IGNORE option (i.e. LEX::current_select->no_error == TRUE); +--disable_warnings +DROP DATABASE IF EXISTS mysqltest_db1; +--enable_warnings + +CREATE DATABASE mysqltest_db1; +USE mysqltest_db1; + +GRANT ALL ON mysqltest_db1.* TO mysqltest_u1@localhost; + +--connect(con1,localhost,mysqltest_u1,,mysqltest_db1) + +CREATE TABLE t1 ( + a1 int, + a2 int +); +INSERT INTO t1 VALUES (1, 20); + +CREATE TRIGGER mysqltest_db1.upd_t1 +BEFORE UPDATE ON t1 FOR EACH ROW SET new.a2 = 200; + +CREATE TABLE t2 ( + a1 int +); + +INSERT INTO t2 VALUES (2); + +--connection default + +REVOKE ALL PRIVILEGES, GRANT OPTION FROM mysqltest_u1@localhost; + +--error ER_TABLEACCESS_DENIED_ERROR +UPDATE IGNORE t1, t2 SET t1.a1 = 2, t2.a1 = 3 WHERE t1.a1 = 1 AND t2.a1 = 2; +# Cleanup + +DROP DATABASE mysqltest_db1; +DROP USER mysqltest_u1@localhost; + +--disconnect con1 +--connection default +USE test; + --echo End of 5.1 tests. === modified file 'sql/item.cc' --- a/sql/item.cc 2010-08-25 08:37:49 +0000 +++ b/sql/item.cc 2010-09-10 09:23:27 +0000 @@ -7922,9 +7922,12 @@ bool Item_cache_row::null_inside() void Item_cache_row::bring_value() { + if (!example) + return; + example->bring_value(); + null_value= example->null_value; for (uint i= 0; i < item_count; i++) values[i]->bring_value(); - return; } === modified file 'sql/item_cmpfunc.cc' --- a/sql/item_cmpfunc.cc 2010-08-19 12:54:22 +0000 +++ b/sql/item_cmpfunc.cc 2010-09-10 09:23:27 +0000 @@ -1595,6 +1595,13 @@ int Arg_comparator::compare_row() bool was_null= 0; (*a)->bring_value(); (*b)->bring_value(); + + if ((*a)->null_value || (*b)->null_value) + { + owner->null_value= 1; + return -1; + } + uint n= (*a)->cols(); for (uint i= 0; i [NOT] IN \ + predicates. The implementation works as follows. + + For the current value of the outer expression + + - If it contains only NULL values, the original (before rewrite by the + Item_in_subselect rewrite methods) inner subquery is non-correlated and + was previously executed, there is no need to re-execute it, and the + previous return value is returned. + + - If it contains NULL values, check if there is a partial match for the + inner query block by evaluating it. For clarity we repeat here the + transformation previously performed on the sub-query. The expression + + + ( oc_1, ..., oc_n ) + \ + ( SELECT ic_1, ..., ic_n + FROM \ + WHERE \ + ) + + + was transformed into + + + ( oc_1, ..., oc_n ) + \ + ( SELECT ic_1, ..., ic_n + FROM \ + WHERE \ AND ... ( ic_k = oc_k OR ic_k IS NULL ) + HAVING ... NOT ic_k IS NULL + ) + + + The evaluation will now proceed according to special rules set up + elsewhere. These rules include: + + - The HAVING NOT \ IS NULL conditions added by the + aforementioned rewrite methods will detect whether they evaluated (and + rejected) a NULL value and if so, will cause the subquery to evaluate + to NULL. + + - The added WHERE and HAVING conditions are present only for those inner + columns that correspond to outer column that are not NULL at the moment. + + - If there is an eligible index for executing the subquery, the special + access method "Full scan on NULL key" is employed which ensures that + the inner query will detect if there are NULL values resulting from the + inner query. This access method will quietly resort to table scan if it + needs to find NULL values as well. + + - Under these conditions, the sub-query need only be evaluated in order to + find out whether it produced any rows. + + - If it did, we know that there was a partial match since there are + NULL values in the outer row expression. + + - If it did not, the result is FALSE or UNKNOWN. If at least one of the + HAVING sub-predicates rejected a NULL value corresponding to an outer + non-NULL, and hence the inner query block returns UNKNOWN upon + evaluation, there was a partial match and the result is UNKNOWN. + + - If it contains no NULL values, the call is forwarded to the inner query + block. + + @see Item_in_subselect::val_bool() + @see Item_is_not_null_test::val_int() + */ longlong Item_in_optimizer::val_int() { bool tmp; @@ -1816,7 +1893,7 @@ longlong Item_in_optimizer::val_int() all_left_cols_null= false; } - if (!((Item_in_subselect*)args[1])->is_correlated && + if (!item_subs->is_correlated && all_left_cols_null && result_for_null_param != UNKNOWN) { /* @@ -1830,8 +1907,11 @@ longlong Item_in_optimizer::val_int() else { /* The subquery has to be evaluated */ - (void) args[1]->val_bool_result(); - null_value= !item_subs->engine->no_rows(); + (void) item_subs->val_bool_result(); + if (item_subs->engine->no_rows()) + null_value= item_subs->null_value; + else + null_value= TRUE; if (all_left_cols_null) result_for_null_param= null_value; } === modified file 'sql/item_subselect.cc' --- a/sql/item_subselect.cc 2010-08-04 10:34:01 +0000 +++ b/sql/item_subselect.cc 2010-09-10 09:23:27 +0000 @@ -56,7 +56,7 @@ Item_subselect::Item_subselect(): Item value is NULL if select_result_interceptor didn't change this value (i.e. some rows will be found returned) */ - null_value= 1; + null_value= TRUE; } @@ -506,9 +506,9 @@ void Item_maxmin_subselect::print(String void Item_singlerow_subselect::reset() { - null_value= 1; + null_value= TRUE; if (value) - value->null_value= 1; + value->null_value= TRUE; } @@ -646,7 +646,10 @@ bool Item_singlerow_subselect::null_insi void Item_singlerow_subselect::bring_value() { - exec(); + if (!exec() && assigned()) + null_value= 0; + else + reset(); } double Item_singlerow_subselect::val_real() @@ -654,7 +657,7 @@ double Item_singlerow_subselect::val_rea DBUG_ASSERT(fixed == 1); if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_real(); } else @@ -669,7 +672,7 @@ longlong Item_singlerow_subselect::val_i DBUG_ASSERT(fixed == 1); if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_int(); } else @@ -683,7 +686,7 @@ String *Item_singlerow_subselect::val_st { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_str(str); } else @@ -698,7 +701,7 @@ my_decimal *Item_singlerow_subselect::va { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_decimal(decimal_value); } else @@ -713,7 +716,7 @@ bool Item_singlerow_subselect::val_bool( { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_bool(); } else @@ -732,7 +735,7 @@ Item_exists_subselect::Item_exists_subse bool val_bool(); init(select_lex, new select_exists_subselect(this)); max_columns= UINT_MAX; - null_value= 0; //can't be NULL + null_value= FALSE; //can't be NULL maybe_null= 0; //can't be NULL DBUG_VOID_RETURN; } @@ -894,15 +897,14 @@ double Item_in_subselect::val_real() */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return (double) value; } @@ -915,15 +917,14 @@ longlong Item_in_subselect::val_int() */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return value; } @@ -936,16 +937,15 @@ String *Item_in_subselect::val_str(Strin */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) { - null_value= 1; + null_value= TRUE; return 0; } str->set((ulonglong)value, &my_charset_bin); @@ -956,20 +956,14 @@ String *Item_in_subselect::val_str(Strin bool Item_in_subselect::val_bool() { DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - /* - Must mark the IN predicate as NULL so as to make sure an enclosing NOT - predicate will return FALSE. See the comments in - subselect_uniquesubquery_engine::copy_ref_key for further details. - */ - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return value; } @@ -980,16 +974,15 @@ my_decimal *Item_in_subselect::val_decim method should not be used */ DBUG_ASSERT(0); - null_value= 0; + null_value= was_null= FALSE; DBUG_ASSERT(fixed == 1); if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value); return decimal_value; } === modified file 'sql/spatial.cc' --- a/sql/spatial.cc 2010-07-23 14:24:00 +0000 +++ b/sql/spatial.cc 2010-09-10 08:06:58 +0000 @@ -511,7 +511,7 @@ uint Gis_line_string::init_from_wkb(cons n_points= wkb_get_uint(wkb, bo); proper_length= 4 + n_points * POINT_DATA_SIZE; - if (len < proper_length || res->reserve(proper_length)) + if (!n_points || len < proper_length || res->reserve(proper_length)) return 0; res->q_append(n_points); @@ -729,7 +729,9 @@ uint Gis_polygon::init_from_wkb(const ch if (len < 4) return 0; - n_linear_rings= wkb_get_uint(wkb, bo); + if (!(n_linear_rings= wkb_get_uint(wkb, bo))) + return 0; + if (res->reserve(4, 512)) return 0; wkb+= 4; === modified file 'sql/sql_trigger.cc' --- a/sql/sql_trigger.cc 2010-08-20 08:48:59 +0000 +++ b/sql/sql_trigger.cc 2010-09-10 08:06:58 +0000 @@ -2006,6 +2006,7 @@ bool Table_triggers_list::process_trigge bool err_status; Sub_statement_state statement_state; sp_head *sp_trigger= bodies[event][time_type]; + SELECT_LEX *save_current_select; if (sp_trigger == NULL) return FALSE; @@ -2029,11 +2030,19 @@ bool Table_triggers_list::process_trigge thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER); + /* + Reset current_select before call execute_trigger() and + restore it after return from one. This way error is set + in case of failure during trigger execution. + */ + save_current_select= thd->lex->current_select; + thd->lex->current_select= NULL; err_status= sp_trigger->execute_trigger(thd, &trigger_table->s->db, &trigger_table->s->table_name, &subject_table_grants[event][time_type]); + thd->lex->current_select= save_current_select; thd->restore_sub_statement_state(&statement_state); === modified file 'tests/mysql_client_test.c' --- a/tests/mysql_client_test.c 2010-08-16 07:30:40 +0000 +++ b/tests/mysql_client_test.c 2010-09-10 09:23:27 +0000 @@ -18941,6 +18941,107 @@ static void test_bug54041() } +/** + Bug#47485: mysql_store_result returns a result set for a prepared statement +*/ +static void test_bug47485() +{ + MYSQL_STMT *stmt; + MYSQL_RES *res; + MYSQL_BIND bind[2]; + int rc; + const char* sql_select = "SELECT 1, 'a'"; + int int_data; + char str_data[16]; + my_bool is_null[2]; + my_bool error[2]; + unsigned long length[2]; + + DBUG_ENTER("test_bug47485"); + myheader("test_bug47485"); + + stmt= mysql_stmt_init(mysql); + check_stmt(stmt); + rc= mysql_stmt_prepare(stmt, sql_select, strlen(sql_select)); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + res = mysql_store_result(mysql); + DIE_UNLESS(res == NULL); + + mysql_stmt_reset(stmt); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + res = mysql_use_result(mysql); + DIE_UNLESS(res == NULL); + + mysql_stmt_reset(stmt); + + memset(bind, 0, sizeof(bind)); + bind[0].buffer_type= MYSQL_TYPE_LONG; + bind[0].buffer= (char *)&int_data; + bind[0].is_null= &is_null[0]; + bind[0].length= &length[0]; + bind[0].error= &error[0]; + + bind[1].buffer_type= MYSQL_TYPE_STRING; + bind[1].buffer= (char *)str_data; + bind[1].buffer_length= sizeof(str_data); + bind[1].is_null= &is_null[1]; + bind[1].length= &length[1]; + bind[1].error= &error[1]; + + rc= mysql_stmt_bind_result(stmt, bind); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + rc= mysql_stmt_store_result(stmt); + check_execute(stmt, rc); + + while (!(rc= mysql_stmt_fetch(stmt))) + ; + + DIE_UNLESS(rc == MYSQL_NO_DATA); + + mysql_stmt_reset(stmt); + + memset(bind, 0, sizeof(bind)); + bind[0].buffer_type= MYSQL_TYPE_LONG; + bind[0].buffer= (char *)&int_data; + bind[0].is_null= &is_null[0]; + bind[0].length= &length[0]; + bind[0].error= &error[0]; + + bind[1].buffer_type= MYSQL_TYPE_STRING; + bind[1].buffer= (char *)str_data; + bind[1].buffer_length= sizeof(str_data); + bind[1].is_null= &is_null[1]; + bind[1].length= &length[1]; + bind[1].error= &error[1]; + + rc= mysql_stmt_bind_result(stmt, bind); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + while (!(rc= mysql_stmt_fetch(stmt))) + ; + + DIE_UNLESS(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); + + DBUG_VOID_RETURN; +} + + /* Bug#49972: Crash in prepared statements. @@ -19382,6 +19483,7 @@ static struct my_tests_st my_tests[]= { { "test_bug49972", test_bug49972 }, { "test_bug42373", test_bug42373 }, { "test_bug54041", test_bug54041 }, + { "test_bug47485", test_bug47485 }, { 0, 0 } }; --===============1726680944== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/bjorn.munch@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: bjorn.munch@stripped # target_branch: file:///home/bm136801/my/merge-nx/ # testament_sha1: a88aeb5f209a817a058a4cb6dad2565d25511f0e # timestamp: 2010-09-10 11:53:43 +0200 # source_branch: file:///home/bm136801/my/mtr-nx/ # base_revision_id: alik@stripped # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWYx1Uc4Am5f/gH/yFQF99/// f+//7/////5gqRz7ffPVwZHX24erYD1ews8e3y7oAN8B9FDQAPfcmbbK9dNX1vo02xL3s95Z9Zn2 OvDfC+bDvtXaeyigOHAxz56vsfA9fUlPa+zUpR6ak2toEx99LvvXOfO9urVgNNbd07DKu4xccfPp 3fe33vKNad2cVsaNs2znW+O7taegdHdu2olo1nPDnXQegU0ZaF93vGse7499ffY+7DPtvk32rJD5 sGd3x3utsAVQAAzzxNcUMvVAcgI8PrcPQH0AALu++Fe98L7AAKA5zo7t733D2A1TCNtmotZpmwbZ slJs4fUDd2qd3e2Dae5PHpppVaneHshd4KO3WgtQHjd6g64725zVz1ne6NvbokD2JxceezoTm+93 e+7ddzu7mq08OvbAIcoU9GrJsmiggnvW9U9IpKDIttaaakNu3dKpr2+nvMXp0ubWbKNsbKwCpUpt lmVIrTTVt71Yc+33FsKIlV3wbqelKzbRQU0aaqqU2MKUFUdDCBThKEAhoAQCAJo0gNJoak/VMamT CaNGm1NA0ZPUZpBKBAAhEQQU9EzTRKHog9T1DTQ0AAAAAABpkAkigI2iNPU0GqepiPUMhiM1AANA AAAAEKSEEEEynqemRoTNKe0p4pPZDSRvTSmxqaR5TJ5TynqGnqAZBFEQIAACBoBDQmmk2gpiR4VP aKMyn6p5RoaHkj1AKkkATQCAEyCYChpUe1T9U8RlA/VD9U9IaNpPUPUbUAxPV4l9Rf4fsx/4XhJ2 WATwwIcEIwSOPub/0xoJaL/I4BP9h2es63/tP5juAbrstsmHBHBlkn/6m5svT/Yn+Cf4J/pXkpGy QYj+yt5/maCn7hgiH+jfqYGUVPy5fTJfzFCAn5KCDQ8v0x0EvwtficbImaU7KIf9P9pCxg/9tRIY oqzB/p6m8v2D7PxiI9nr+xz8NIRNVL4orJ9UicGOwmFNIQJZhKZ5Jar1xizTOkUnQxRAWLSRZKYZ z5ltcaXzAL3yeTwYg+aE+yNb/2T+64r+Z5/UTgoglvV4JJBh/nA04lAHz++X7+U/NZLQASCQXLOW n2aAOktoxaTIpDN98E3PDxhrhM9g4HNxy4K9B0RD93m//H2k5fb937/TR7nve5znP8SR/n7KVR37 1VV+JoeeMWJqq4p7YGZ/+PtvrNjciKlqf5Re7/NmKya43IErUhaLAkWZkz5krHH4FTGzHHjxdyIj rhbCXocj2xVYpCQ511LorBYQhB/7yBG4ZkU+g3UyG2OMlXLmcO32KLz7HOkqLaqRFzLupPpYUCa0 kIfc+LnevZHzJ5kQoKeV2cjJmKFj3DPnMDRQpE5kVWQS8uVtFU1F9TuXVLYcZIyduPoHw/dCOXf8 z/dY77pMQKCDuM6JBVIabL7B8fr/X80mKytazzt5PSsLMFqbmjGIsNXEr3VMV8a/q0azBWuONVFo f0QLrJu1b7DEmuXrX5528P7acLftTjc6oaDKdhjrh/UjoCJEgQrbM7+nQpbYTXpQqVMRQvIqFWYS RmH7yXk58FY5OcDYR9PVc/064dTuW39f9JQ5MPRcTnLpQ+79Ook7192QYljD8Uhe+6fRShdbUaOc OSmKn9oqHesq99Tw96y6QtQfAhUdJCKOfx/PLf0joXdUHiF5/GLjsFHjsDfzMx5ezsw9vcZyNvdW vuZk0+zI5y1iccMSzvmw5tF8fhEWqtB8t5NwheuHFWSXOmYx5F3TwYzDQNUrh6pxWlVcBGozadgQ lNQMQd7e9d/bY6/IfAlvaF8Jck1VVVePjP99v+HD8nJz0eXVlX1Xzbcvi5BpGkHt+N+4HnAUsCe6 1/8PEqSuxRRT0SSU8FFFWXj32rcivD+AwYjzn28asg8Bl8Z/33fFHEJPxPjOg4+h+2tlxeKieECe EdvfNISkDSNMdIeZBIj6E1kfSXLR9KagcpMBw2YLcO1Ttqjl2KCPDZDaZJMEBrm3YNoxUWu0NMgj LQwths2QIxcIVqSEQNMOmbRoTNhZiQqQeUSAi1cCDPyHlcdg/CiQBkIAOQTwhA1KwogkEjCwCKIY M4VzdW2acxVGArhFTmgqQdmOAXNjgzbJ5qJVCZTi5MqYQPA81cmKEm9qqrNhKdlxYN/n/d93u83m +D2D0AAiJ8zvhjHtu9wp+ZR6qvOtv77nQhvwVFF0Y3VwiqkB6nYeDsHdMAzj1iJqYpFGkHAgiqhw YLC8RgkKsgVIs2j2aKQHqzxyjnMBgZ73fnw2LX0fdRRVNbFGg6dWnI31AyQSGR1arFUl/kQcM2mL bJ2QvObbctDgNtUUzZBkExG1E1E0LImASAoQxXhIhsBrNGTapXkXiigjuOcWzsnHq/UGZgg4jWch 5HCNCDmqzmXlJ6ChPQfJwyHJ7Bvk9A/Or6vgF+YnohAEksGVsOpmIFo6O5L/ROxEQ+daWuHX5Zft fSrNRgVVVBFa5ymb3i1cjnEMihT8OUh3zFv57eK+uc0l1ddqfP3sbvSpE6nzQ+9CyOqeoeIqiiAB tt6tf+qB9KHgsjXi50G+lQD3iAQKSDV/4g/jAB/bCj8MUL5pe7D6dHMvH82tNL/XB2jI0hQIUgUd SVyQiFsMckPOdOw6jIcP693g2Uf1+4A0kL277wGgZA+nwsOo7ShQYYiRMi4wFMm7fi8Ecplp6/ft 7KuHgSFFFFOXZ8CS1DFk+j8vyvf1o+dSqjFQ2ZLH1unFR3vFgu0f7+ZOZVCqMVl7sD+XY3d232/a +yYlTI8i477Wgh1Y3cdPqkdvyLQFLAVAkoqlVlVX2mx4Dx4cj2yMy7temzW2Gtr1AG++8TLBMxJE xPeXFgoZw9emc/bKYofHZJ48+ez7t/j/0+ANdPT7PsUEPuAAPpA8VExUMQsSKUUFDQRCxCFGKDQx TIUDMpEgVEsS0VMlBVTRBMFURVFRJRNSRUEJVDVEpKUTBUkVQRLURVEVFIRTNKFAVMjRQlAwQFUp QNCRFUlFE0QMMzAQF8AB0LoQ/Ygi+j+v1fl67h1+9cb/XuHu/R2RXeKc3rNK0KQYtVURNExFEQUT DCwFUDVFI0NAUC18whuB3r739RAHVnf5yPkhhHKqTMxzZqxm0EZmWxFnFoosFBVYRyZnBoFuknn8 OKAYeIlXo19d+CtwoLj8ckQcI2eci6VFzFI4FdwHgvx91C7gWyIiE5p3AiRLHJkQYeoaISRBTGIJ iJIRGwnggIkmErIRSxwjJkguqhTKoETqsginRcY7nQYBdUcsbsGKuzlK1DqLUm5T0ghqw5SxLb1x BkhyASKSG1zIgzxDXt8FKBOvaVQgrfd5y75jzC2lM8ccHbynswFr4rWsmZVESLXVeFy5Keb+y5G1 qOZ0zCtnEz3noowkjpEYJTiXRLKehazsVQ0EcvZ5JpDj04iVJrRBdhOKcUgsNOWgKKBq6wRghU6J hTtCBmzmQYJdDUyi+h0z8a+rF9MlDJY4hak8X1rRSFfWqsPRSSxRQac2HWIpkTpWlYXL4qeMQiC1 ooTAUEVqelBASKzDLgnczuLlmHLXcKwHDBMG7MFPYGHWuM7fjpVdVHehRIngcaDZaocOppdyICeC 4giVFbdCpeoJ7pEs8JnODFN1VgciM7MPN9A+O68PZHeJXAMq53qrhR6ZxGcuakRmTIWUiQ56+cyQ iHIeLfRmPP3gU+Vlk+a6NacYOCCEPMzR2l5QxIJG37EQnuItApYRjHjodSE1wXFvEmJXDILxaQco JJAmomTIQkcLmPTo2s9LC/0xy379YtgUbFX25Qu0cQt6PVvyAKIFntwxMRNF2HDlKzTzRiS5Rsov aRcHFcw8KGLUxaZQJsw9vx5MRB06YnX2FDqiILRJTOSQoQWSi7mYx6MnjAjswXBzqWFFsOaAhzAk DRkzKCIk2cIyFgIwEUSgrUOwcrKfDRZERCJiFJanTdFHTJlLcQktc0LgugIgJnutR17zphzRfKT2 cMkYQFCaRK5aRg9aqoU9CFJkwXg29aOMLyWssOh0yVhM+JodQCBzi0i7wRWBUDIGQIILNnMPgnxT 0VOBJrLVpL0AMgB620rRcoo6KLz+y8tMlP2bvR7PgPe32fFs8FE/QZr2F/M/I/xFDD5Kwqpa5RoJ ALSB/3rgOD/AQ/i+R7JGv95x3MDjrVBJJsfr8Oyiqoq/mfrC8+YIX4VVVY8yn8B8VEsPhLVXYLj1 8fe4ru5l1PSP+imte8nOqqSP9vlldOxzaqaKTop0b2Qp4nh8swmnSncRJ9uz01ZDst6+V7Z+qX2n pb0Ih6zfQKYyDCCwrIUO8yqmkeR+pIjxftm6sP244ygeBdm83dIfaFGdA79v0a1Du/SBKSvqJmaG JM79y96fLzmf+TNoqVVU3NHAkdJ54H/8+yyfw9Wbvh1mRD5jAvuNMmfhCGe7A2EpohaEMcHjxC4s KlPTianufhzVWe9mZRT9QwgMA4GOooqKqqoqKB4KPEeZeXy+hY3bEs+X3mm1hx3n/FZ0qeQJgzmx RkY8uckPdTOUYttqTaVrY5DEKZAztiWe195Z1aERr3Dl8GMB35DviWMz1Un8R7oraOjm8V/vOebq fE5yWHkj/3fOKEmUFYfb5qpIn8szsf1dD02kf5fsaV4ImJKsBmm3lda7iujx6/XachELEaGRcoiq ZKX3TnT44WP7DknA9EUkfdt45ZrvDg6eCoKKKoQZlXaP3TJE9JfUaOQI6/dGtx8YP6IxD9K0VP4V hHtYtsOrLOUku0QZ0mOviIv2FS3cceZOfA1ADMHAFGPwLF4q9Rvso60Cs+hZVeROVhPwA3zjonNq hzcXWViXOppekXqv9Na9XiGcYI5US6yijuLCpdc+hEob+aJblD5MPJlkyWiAET/GKCJASIZdQ65n Ix13Y54/WdrtzDSbaItROBt/T96bPw/253yYMHzk8NGZCIhavph1NKc5UyOej2iI4xhkJJv44H/t 1zqbs+z/ycSWuEZL1E7L49D5A9jAWSbC43fyoH5uz16zbB2UJz6yTbFobF6jCqqSsaYqYpNy7ovE SVSCHuvivp8RbjI/NwxbG9cxLBoYVIq9PLLlP/4kXyaWzGjnqa+MvB4qclGipHiRKSWFD04+rz6p iMpM+GA85islt/806xpimPGERI8s1vnPyjtddkJaQWPqvoVx/ZKgPJgZv2Z36PqcGrV/CBaTVEgr Ji1vcxD9H0PI+v7xUP3O/Bla3jtueKICA8GfvnF3sbEUip0i0xR/Vw02enVhn8nD+Ow5bsBTD7d/ aHr+UXW9rbsXTSWliPIpmHKJB+uu9NxN6SqqwsdWtEmPz+/2nVsXpqcxX1zeifxRI+UQECeWxMVJ 5zcwZ19IaKSExnXSaQN4Fk74VePEGx3c+DUST/8Gq4gval4lV2r6agQAjn5lbi5mMsWk+Z6Ql5tK UqpEehrfDP7Rz4UaMnPctf0teZaM6JL5UIRz8EABG5HLVf+hE/tPir4kFauYj6L+XHtDVr9SC6s8 KF1hcfq0hanBix50ftHDEhhdRUlpzG6HYMqTsJ3wJeei8B2msyV9pd97FCUkvRyPFsOELY1ODlXe +SfVes1fU2UwSiF6YKdFcVLyNxTRwOC6NB9JOVG4bAbhBo4IePGGGGLohuoegporGLP6VJD3GTCv Pdz24JUukfgczsR4LuIgIFqFcL1cMQUiv8ByaNnQ155On/L8UO45C8fR8up8gPMRvHHgVH0HyiDb Va0w+0xJ2IrcliatvznI1Qa9zIo7uEGmdcwsv4MSHbf6cyMTD/GYpP3yNutk/vX8Rb0FZFSoaC9b znQf64s1FDz8geVtp7zAY8p+A+9j5PJP06J0dEeDtal7HnVorNSS8VQbexI+FBnfkp+ENQn3IXYl /XDR6VFRlTplO+QkDWy7gKlpM4EuN97o0lRnjQS4MA+WRZTC+4n2PbKWR+CWn8U80uTin5p/JP5p +9OzMZl4KLrtzcFn4oMip/cvRP8PG+/YxVRLEXRhWZ2ZCEVdE0H9KNFlClX8FVkvUrcBhjpBbIig 5kkXMCLvaqJlKGoGmiJcVWWbWESokUk8yJ22bW+6JiNAm3uCwX3v+R/QJDmG9fRfRg7RxOJ0gQaX 2D3i94/+Q/1N+bPEX53MH3hazWHWy550b0nxP2JP4cj5Wqrp3Cr0wCWIUfzdzhAIokLnx+hd5MTM u8xEiIiZMpFTMxMhGZiZEsYiaf40qeIEU/jDRah1V08A3xOPLZIrzIkKNopSX4EhCRSQSSJKCXiG Zh3Hsx6rcu3H2dbV8bfC7CbuD51tFW22az77sO+zW2m5RZRu/b323d3GdwRPpzny3T+cdfK/ryRR XUhRnaXjr7nw54d1POW+szruWqHV5elneLW+O2+q0pR9cjcXs1pD1l9Yff6LQqmXEsLL8JPe/kvf uX4Li61ys55Zm+n75W1yy6wVoPndixbLq8S1lnapZgLkw2uHrsThSXNWbNVuYzmg6zIBdXmrY4rv PdZ2Md/0GP2D6oo4iCAf659/Cfdy4Pfv2M69slzlR3M7c4w7T7u7quHTOvPniy1r3nT0BfxLEUSY BD+B5gjFdQKEQFKiJ7DMV/wTBqKiCmqapn/ifuM0U0VVVHmJgIPtJDAkorQ/r45mwEXSXIeZDgEG x+8wI/UGAfSKBj3GY7laQcn7RP7v8XQA3/D7eX+pUjyCwvAciBvCrEAZCBTYQiyQh+P9JPUuWU/C evHPd9ZtNOK350myafP4WYWkwR+ZoxI/5AFkiH+YQfpAj5LqbmIUB+CDGD9s9n+00aw8/+s34YIJ CZ9sjU+bEe3loeqKpY3cbPe39f8HsDvzXn4sXpoMWfiAfdhz/mJgRUVQAjC+Z/JA8XH8Kma/IsPO Lz+sWYf9RfMwM6EVUgSOh+xLBuGSxEzQ6qguoZ/drW4/0rF4Rqn9lir8xyh/Upcl4dzMqnVzKvVU dZsfyFb7Ub+0kTOmXaETm/N/mulU1x/6yA6FBVAeAZGFjguhZUdh/a9H96n1wRH/Ws5LjBX7q340 FiPIKeWe/DzbbUgej4ReYd8BEFDmKUDY+s/tNmDB41VfurczRMVnx4Pekl7iSnd3Oe/Ra59HAXV6 ljzAoIop8Rg7juPDfhoXWcXQfk2dUAPde0M/X1/b7gfyPnyYT4EAoPESRnUA/R3xfypaWsfySfzd 0wr+we8R6xQ1/on90JQfzO5zQPuPb3SMQs8wXyCkKSEhAksA/OCwAQv1gv1ruGwd8DKEEIIiwLoX vQucXNMmrMshzXFaoexcR+mgL5iyOnUZasIxl9Qb8WcY1VTOpHw9nLlzlNJuc0WbRGsTei8bJUha S9YhnhULGhVG47DDxDMd/eGcs8SLNEzbZqQp0F/PHo7OcyLo5xOQ3YSHul/e6hoM+aTxhp2Tjl3c FkcqJhKShOTkMXC9tCu8MeERijOsO/HW8ao4EySOCGkxqE6KGO5W8WwzipcKmhC1cQBEChgjsScE zbtsF6oSnFEWsjHimWs0GEhRNHVR/Ck5OEuu7sYkzFESoiUHPgbm+JkdJEnd6pIxanWaJM7dZNCc Buh99hnJMVyg6xnM3Ac4Zk1Gjk7JJij6JIvRlF0mAKE4Kh4tI7eyDhMjhDf0LNCYu7YdZJwJwiXp JvdJjOiXp1TYkxQZIYiYEM4tJTSrpLpGQIIWb8Mf9/IzdVzSboo6xxhKHnOxhtSHb6a3UIi1+fu3 zsO+9vs0/n16VKZHi48fLPMe91b4Q1/hc64/2SqIe4ncQv4oIeLs1fu98E8GPCb2eQ8cPgdsNbd1 TuxKgF1qslcJQi69o4osoTm+UX2oWiDigTDY+QbgnsiA+H+InUX3nQQEoPFXkrLWa8t5LVvtsRp2 rcwDFdIbgbLsruu+t9bargDpDkEZgSzYQlDgRhmAEgY4qSQRmBKQy4IyuAIxiOKhihAiShIkhgpg OALKBCqEKoRhURhjUKaETY2Ho528un6ZV3bPTdL+Br0i+xT8cFqDiJFbsjjMyIzuMhGUkkieVCcU PWRqddyPLPjhlWN69TBgxi5KSWkqQxF6Xl97HHYgnc0qtt1pJJcXhYlRhokIFAKj4lbbrdp+IfiG f2+Z/r9K/3QCIfDbsiNaTMkzMzIzMspBJJEpJBkkGSQZJJIJJJBJBkkEkGSSSSSSSSSAYJIABJDj u4SQ949v8XXfP7fDnt5S/TffeDMwMzIzMjM0u+2EFXsDNFGZkZJkkySASTDPqhx8lsHqGSJTZBP3 pzre6/IF+MH+45zsmaYzfbnfFnRhGMbfeNWIydxMJ33SwkK1ttC38nx85+f4bxumDGJygiIiCLfP /HOdfRNlW8uvbx8L6ead8M4okH1sfCOvgSXlAg/2DQGbfDwGfmwzBw7OB9QmD9Y9AkCBQsRkzNn5 MCesuPB0KSi3c6JmjWOyGK4LGsipT6hYHzswDACsTMGBIQ3l6QcSBtdNsTpPEGxZJxc4XUidblK9 JOeuNI5A5CdJDUcrpBl154HKNXEUAdeMOXPfSlKc7Upz4xaOZORqNoOkbZimtYjW9SJyjiXRLvFC c4HULk7WpNbYhxmakoHoQ5Cal3gA5RzhDVQPFaNiTjrZ1w58zblimayKl64yORgXJsqWR/aZUxxE A4sxeYCTAdisi5kJoHS5IdvHdccbBxz7+3tChiSZa43GVZ33S1+sXqJWALbjuLyM2jhF4BYTsRWB 25JuJ1NjIAbYwyhhjfeTWErXLBdJdJL7CYUFHFWSLhKC0sRRIykqScVgsRg/fdhGQO6g4IkSyi6E tEKpikKgwaPUHTZRXsJFNgJQKAUIGgiqJIVUkMCShfvvZHspwzfvrOW/FuRy3ifBjgwjkcua9/b1 ON8OnIh2EDntcZuAwLCgi9igO5pUTAeW6OhcolFBASSoIdGiYliggNgrfq6Ppmy1JA2WaQlI1sgt Iarrmuu9exYBojWyAQkDAxlzGs0xKgIqgQMZMkDLYbJceSKXWikg/5fq9D7gshVVCYY3sWK5znBG pdesmJNFoGURncuHVWmGTXETSWkpFsWDB0VMRM2OiSZLCoamF7G5ZzYuiq+/Zu81XjjA9oWsrrHH dIRo1Ds7pySZrYQHRoTOJizRfEko0cL5npYl5NCaM3YVs90BFqExtRKifkZqFETDsi9GkUzdyD/B 8+R6LmKwc9ECmM1j96Im9zw6IYUV2ShAgxTxGHSL7lmUmLGwXJQlVUoKmSxsyaKC2AqArP6Z1B7w W2IwCS9sr1U4lFNFiKjN0JhS5PRQMVKE8MkMrNhlyNApFCEQyZyMyZxYl6SiXCWY5eyMAvRB2KLw ufa2z8MPYNwjKouCDgvADUwF4ItwHJu1PVYQM9oCVL5FUOFQ3Lh95I1FXQ3GHdXcRqO5tBNxPZ2B Is7gaEVBURBQkGqpRb5WQXBMELUzUnDAS2mXHkRtMR6M64yD/EJcES4DFEQRFXvpHUVLiweTlfs6 NnRVR7d2PsieUVYVVqiXonLoIAMiiCSecEikmEVJhCYLXRkrFh0wYZs0Lg4MiAwIN9PM1IoHZQZk Uxps9BUmegK8ej0lqWcdrNapsxXEvccaXIoMloiMYiiQ2rmbWkGwxWjVraSSXoo4IvYREBGFiEZU ZrLdSYyIGSuyYx45zRo5ZSr75M0DE65DYhSG1R3cYwsRApE9vSghaA2LarnC8EQoDCCjeuKRVIKl okhqwkRdSQyJmtpfoJrnJDCiS5G8ioWmKwCpEGC3s5W1WqKwZS7CDGUS7mXSBdjnH2KYSZQU0vDB udQmnKoIBgpENGlgTfIXJJGPGvTOorEte/3A4aOhLGjRQA6OnF7GcmGekL9VycCSUtJiesgXrifc ok7GjQ3dTQsWmTFmXIJSUWBeViwZNzLDTbRsMkvR6MnWDGxrMTwT0JI7MXNCjBksMSOHWB/yEJEY L9WaGsfcn3j0SKm/AOklI4kzXjYNjRM9DNYKDvgtYsUsh9hRVVTrJBwncQmldiKeyhFSpgN3DUCS LJIwfcMnDDZjtlrjGM2XbUXFMuWwbpZydc82Bt8uZlun10nzXhwe9EeiLcNPnJdywExmYU7SeAnf o/MTcAfocblQs0I+nqakwbrvdmWLUdPVc/0DRvdInVqz/eB5nd2Ze2JSICmUyHaS9RD4ltxs6EHX kET3TloiqRDoi+K8s8IEV5w8gdHCQ9cuBFdbwP0RxpJ4MZuZyA65eEzK58c9GczZ7QaZpjtxQ6QI 5UrSWAmkIXZ2EnC3RARbkIAOSKQZpLwqLCQcVUIzbp4FRXT4ZYXqcqEyLEtWrKVTyzAeUcipOkbx QZbwc5NrUJvvgp2ChsXUiPteXsFy0Y5a1Vckjnz6KoYVl6JW8hCGWHPpXf+MQx/kBhjOYE3APAFA 4XocE0JwQcADZwEsBgbJVJWSiswSt4+e8iReFkjLQVBdEw/oRBS2mtu0Ey455SaUUd+OPYKnQXXP nn5iQ6Qq8wElYSAlFkUQ6SqCGKp8ux3bpuC+QAmQeilx+eNuW9cMAvfa9apCmBOXNKye7gb8r1MR OlrhwWG0kFTBxk6S6CiVSoQat04RYGAVV3gEdGoMg/0sUDCAlvISlvzOjcyUg4AmQS6CRoUdUup5 HQx/QERD46TIBlrtpZ4nRosYJMnP7hEQz0oAMmRY5kMJIoGHdctxmvsoDxKJxpJeLFkO4C3FQLds HzDJNTAVQSRCIpeEmJI/n9PsOYadordSA5JUIuZLSI4dcm2K/RfjWkOM0tnwsycPumETZJWNl2gM ogKoowlRBCzfHTcsmk8xeGTwSRXiki9k4L7jga3WflvScfPt5FbsjHBtm6aqFiJYX6jcYWLQRMRS 2+9wb2IsN4nntdMZNMly8LBZitnC+dbmDRP4Lo41uRMcI0YoJLOEjaXGbSWbaxARcGqepAIFQSYI s3ExdHNny/l9q6p5DxCi6+bzt9PtKs4+fnuWTyZo63uW52sYTm8SWNCTh3iHI3O+L4tWW8NAtrZt um8a2qxJ4rieKba9dnDDV1GpUbaLq1ybkVeWXaTOXXl+O2Z043Gus87tqnDWsceJXldbwvHS9btV VbIiIVfhzZLdzABMqMaOfuE9oIc4Kp6p0M8L5k47xMRrjAyCE83Y1iohhCiIonLjpASQEqiFXHOi 9XAigJnp0vkFNtsQ32bN7s2X7sSMLppJKbFkS8kYAF4SOGPjwuVMXMhcqTXI1bE5IEj3wc0mY2xn cizoS9oh3YLz2lClryJuikIrBbVYFUrgyhgZRXEZzFRHGZ8RlVRcSF+O8bV02x1oqCCqiApoOCsK KMcuk+ToU/uP/h4D2RR14xNM7s35m3bhOE3sZxztOdOi2LQGTYXO4jdfkNxVxxBwxWFBneHgKmB2 Cpn9tZU2OZXIcUyHjzOyemM7NGVctmgUQEVDYEtA2ZPz+CljG/lwKTBGwiWAMMmA2T2BBRJd2dZG NhaIbp3B6r6pwL6XlHmI1eAt0ZpBmSomwyE3itJRUVBTjUDiRNjUNgcVGDY4LzJjuK1cnDPPCmGB OTIMmN61UnKSZN0sNngkX7+3xAVMyc7yTnsEveVLOitMRSCow6kNV017ZGWC1zGyRdUFqCnv/BYi prCRRA/nFsy4uaiqKc8xYESLBZelIUe9ApHpEBTBOxe1pp2UhISLwiA3CX0MFa+z3bdTmAsK6ZYP 8CIqJkpgKMBhQdp68gzOOcMSvI0NyRXMLq4OotlzmbV+QiEhixduzP3FSIqToWOS0B+thgcJkvAC x4o8H1UQQ3qNiKiwKQ6bAW5CG3ZBAoMBGRwOnAX7+NrwLzQzUvuLcVaEGq+/Emww96l+gYSXrJrO x0TFAkl6XM/B9SuhOAmlUW6YQYx1W+2towYZ8C4S62C0r6ZA5XGI5IraSzPeascETVRK71G2Lo5Z tte55VdN7oaseb9Vm7VmpuywcLR3cL7kkXIKspJG1vrNeXWrF1S2khD1T2Qw8TucWPFe4W4q6EGT Z0Wl+LQew8qxXBpMkwGKlC59wqbthTRb2fbo/AmalARsudH8ciQbC9T7ldm8DPzY4mjNvDxxba6J kFiUslFNvBTjbj+r7JQ/J+ipmcJxEr5RJJr3YuZh1dGfV1Y4bmrhw4smExa6DZtbEPqENQK+hIcj Gij2ZV9FRciYUMs8XWpibYcZ31KITPvHvww3ni160VXO8xBCQiABDimQZBI4TzSIpfAUfqcZMk84 bA+U4DBsANwfxQfomvHyV7ngZhMQnmfA9VC8nNkENLwVDJQPwN4dt/W2A8hpsRKN6O094BlQwhd6 dToCOBkfE+YG8+B69zpr345rOPIVpVLSE1LnCw+2SQPTFgc50GJD6oXtmxcA9ol+0iBkmsVltFAU SE1nCwQYq/c4YwU0BwngisGMevGhdc+em2t9dMzYTns41VTE5m74RXro1t5j2YG3MNIl4melFjjQ MdKJjYcG2O0a150UaLsbSTVL4LPuH7AA7BmH9Tg5ddN0CqK2CAXpkZAqiy1puY5xlkAbfcImxqKK E0w0KEu1zwAUVK5rEYmoiUCTDRTVZgGXMKgpflzSNVkeFj1JhMNJxSZf/Mp7BE4oiFxQB9ZA+WUU 5pIDwSph2nSghHoVFVF0NmIsGYymO4K6loAzjPrgIWA1pgJbuWvJeJe+DW2++Gsa5YeNmER7/Vtt qfP6y0L4xvypAKjGfmiiEccNmThB8MbHM0oQeg+CChDlETACVA+mkS7DkhBCpAghyF5dfT5jGj28 Eg/hbCQGTcyep0pjAmC8P5hKyQ5J6zpftCSmgt2dhEy5piTMXhcRcZOKeaInTqglbzbN6std+3Ee JqeiD4GoAjgJX45dE9zSyolg+O5FZIhtD1KRMB2zcMhUUR1VJsTxCJQqNxAlg4x6TBL3U/on9gIk Gi68UzuXHZ8Qs4HS+2DkoMFGbCJfSl9TC5nWF+COXBvkhYEUqFDxyIWKdjpFJWoYToGb6l0LIGsC JGjiatRopW7XW8Sk0xxNQ58h4W/OBsKbWWmJaNB1r3gwe5Gm8f2itlyyX9nUIwywkQlAspEgLMqL R7LlLAhc2HwDlyNVvoa6rt6IncSrwGCgl6DctywlqSiW3ZDTpCvxzll2rC3UCXxLnQcZ2uPFn2cr bmy1MGzfiSeQpJwS2tcN8KCiYUR9kwcJCIvoUSi5/y0L9+1v82x8i0X0k+0Gm6RgREWYhogfGPuB KE69Gtt6sBEsFnqXJhZZULpGdSfAcEHOHkCCkICaxIbfWB9SHuT6hCdlxwYNJPe55DgXlRCLRk2R NbAIgSJEFaCyHaiqrnpQBQPGEJdCKA+1UFuERWNCmfQxYUUy46qkou+j5ksW4TufPtWPqQ3cEp0u SIHz+0ETcR8sr1wVwypi0FZGGfnW2UJvkhwyi5hZNKZaBuVuvh1KSa+6LHf5QBTOFkcQSnh+BkkE wbZx/YtCvgP4iCIv0C3ACBlKz1UUqSIUKXnoogjObSV4dg5c8lWOUhZsIPV+F4vcys31H2pu4Jea IiG7WMLyRQ2qXjiAaGpAsBFMMDQDNjW8zgOnMwkx+XR2d9d0UtV9+oQpOnw7Q9kSpJGEnq8F0S9C zeygnwQZLmEG5qDN3CxQJHwpMVMfFfAeJIpwlr7cNe0INgp2csTOmcDbIDYBf0ET9Ce2t9aVjqcr 5L/CgkmvP4VU/UrTm7xRi5UWwLs95hgGhxxrkLsSdEqpGJwmYhONi2Ey8Jki5coaE60VOowFjecf XqpUXPajAcQSxWBp0sjl4JD1KD2At0LKQtm0UE0YOjIl9tzLkcpdUu0ZDSzevc9RwYtHxSfAk8By ETQujz662FxUMhtiMlFUs1sDRy0q6wQNdTbg0ih7AKKZ1kRm5e7gQGQzqY3a4EIe4YOwUnnsn31I Y+MGRwCRcXw8D5/gIbucGM+Mi2w2YjFnA+SbDuLvn6oeAljIutHa33p62J7kTEvFQsVsRvNKaxsQ 0AXg79rPMKjyB9Z+nK2UJuZfrE3J6xHik4hrCYluEqJ15bR5SBuBfehrM95IaYnXLGntKKH5mwLl N0L3uRK/6pW9qQ0lpOdmaCFf+JPMiYhw84BoU7ImsqhhFUBUsKppbrDbQL6p6iR0AQQBktzMGcW1 FxKlpMyHlzR6MKozIqTCnIysuRci7x+lcbuPCdO848sctGARGl9p+0bhsw0paK3GtpWurWt48Icq qlKG2806IjEUpkzlLfb4hoLwtVtt1AVRKtUGiCQKgJHAB4t0ZsSkf0rTyr3uRU8eGTCl7Gb+83o0 XXyRtURMtsYmi9JDIPZS0EvIEYwTQUW8hUKlA0o6DXWlhoWiWZwqJQlZRXKb/bJNQyBQ2HU0Mthk 26RMduQnPNmqCdII6SLBQ4IgUMSKUyJO25E+ufr1FW3ycoaNznY/UrMElCm85JAkVXZ6sU8yCJin SqrCxL7x7j5qgJITG5cyJuAjammVwpk9kELei3EqQIP6nRJTN0dKPuiYTtBFBaE6oKIKnoEWZTec gLclYop0SzIEksjzqcsjaSxwlLAqiizhpoiBFgLAGaYmCZtHjT9A28ZgscL9p0XLlZPSFyXVjqGG sDgskBGCSXY+HaOSmfqghiEU8ERVCK3wqH7wTouZSxapS/j+jsHe4yFBAKy8LfoHZ0EvXZ9ZFzpa DcVUnfbMqqo003qupT6DVvkL8qbueFWC1SxLhIYgid50dPqRMmf2t7udE9LQ2GIKjogUk9WaMUSc kmswQavscI+0hisIiObPaLg6IESZ+zHuOug1WA6Jn6oJEyil0fRkFDtsZPstiNzoLypVHYZytDEk wGOk3Va8UTfOiwsFFKgTcOrqM8AzbZ5OFIgwTvCqXmfATwRGQ9LVRdPaqHqaBIwBSDmKkL7ivjBP ZVzKC5rqqYyqYM20L11snjc5ZqtWTJs08ITuaFRSpWJe9xaQBPmiJ7JIwNGkkiQ7EdQlcEMeFjtY mVYLUWZQGIwNQFR1VwVkwYqYSC0fgh5y4UhUkZFgon1AKa3wYwMzVERn72MZK0HFF8GIveCXvpah KK27PZh6L2ZaqdEtamiBohEoWcDM0KKyl0lO5TwwbJ5nrlD6p3uiIaUOgtwUSZ0N2S112r4QGa7U dTocoiUmURmgQxHwKwcWoiBSTRObx043Euyc+KJxlepeHDNtszPTehIoSJxWRNMkXBgsHKiIGaJI NU8S0wpT6qWOIJw4a+iYfZL8I/qZuiBSpNOxdmkROOBx30c3fOrQGDBYbM2lzTBy5aBjwtyMbbJk T2gKgnHOHncdyPL5cbsPIK2cvwmEHGDpyhkbArPU+UQMIJBUkTGJmG7exwbZMkTqLKBjhtim7lvP S1uegD+QHXFg9M6WWwCkT6jy8s/F+iqZmhOweZbRKQFIbG7yBMoKPX5FRVReT+pPHjKej1Z3nZ/d MjdBMjkiRB/bXJttntzbGV+6yMl2vCuDH8xfzkny6g+PAn59Sfsw8/cdWI9nuqRe+kWBmhuieEdR tA9sEM6xp4pyBrTaPHuBxgsUxI/E6PNXEPHwV712PNxHzAY0j2juNecvNRZ3TckdhQodPm+oJ68k V6TrOBh8A74ocrSgSSbnPou+bFaOVtBwOU2Ne5YyW3g4yLKxzJJ9I4IfWYPWQEMcdW4lLZflP01x UwHp7xEQHIHKWqcW8DNNh1d5fBVY1ijcMjWuz6RK44FboUoApgu6C0uVBWYKAaDXesFNe51NEkxW ohgCYIKspEEQSQJIiSaWaCBWZJN1We+Z1JGAtEm6MFoZX72FjUUUawpkvsQn/Gl62rYwoAcP2u5R Lk2dTKFDoSiAZpdLr0bTKslAjApnutLCbC6Fsx3ngaC9VFxBORnNf1uYI9fzwmCPJwMoXI5ty/VC FZtwAWFERLK6IqqluEqzkiAophn7ZfWjKVuMEMIg5iA8mXMTsbwepI06NcmaN5cVENATFKkHLmby 8lW4hY0ly5mYiGlBDCvKz6k651bF+j933ELhTwqGSOKYc6P0BJZpIs+DpZzAuaagR8McJ2TuyjqU e/IuLz4nibZ5gblaw2LrS9j6geRw6XF/EIfEW8Hkzq5JijIiNFBi1DCfY/pYoKSK8v8fYmKXVlJ5 IdDy6SuGY2WSPk5fQfoho99Fjcy0FRbNlaSb1qfERzKN3KD+KIlurXaU/1QqJvIWMl1slc6j4s0s wlbIiL1cEYUQqiTYMDdj+vyvUmUHewl7oyfhM0iJvIiPImUQSuc00HQaLp1mU4LMfY+PuiIdCrDK KhwFUF7gVETdUcoqu0IF6ai2F4Qamkr21JNOBszeKPtBpr3CoqIGgmIl0kHtdwIfEfeSb+VUbnI2 OQKglkBOZqewmW9JCfIZoWRMKiKFZGfV3gtqU2BiNFDZjo3mcpwUOq3g65Lid6hdPxfZ8RlnFbxV i8vXUICRQyiAwlADB6EO3lCZvfCCDkXQoXc2a0U+x8ZAR/oulv2XPsEvD566nYUowyiq++/t2eSn T3zfxi52Z177qQR3s9XgpJD5AeaJmhtw2lR27GlqD4CBuS2iTxlhrrfYJkbnv8RFVWzCNlorTRql 2dW3Gx4Cmb9eKYa58XptGZP3Mb4ayKHoMn9aXgPksbAnw45YnL2OmymKKU2OYjCsYMNsgZk4CBCS UAYzBKMfHyNlVGxiNSfP0GyKfRTEwQ0IcTB7HOidmYDo9FUu2vDlDWRflKzBy5pBp5/GpXBoVVVc PUizWYiPChIehqtDtlXoDg3wwxlcyoHuERPJiBvQ+vx379E0tobsXEguRs4JQr1M8l88q+BrDYE5 jHrMu7oKc7xU8DSXXy1L0E4CrIqOCpGMg5vr7581TRR9kHCeVABOE5IE4CcLNyXWOajxSZE15lxK y2W6JEtNFN7nmsuRg9pDhs8fHJl+xm03E+Br7OxieIiBFMe2E9HZ7msXGkVZJweipbBM9/YAwwq0 8FEwXyuyh5w/cIB52q064YkYHHCps/IQMJo4kTP45LQSPDGCAeYFpEVRFsR9E7/YvxypLO/csBE+ V5AIGs5zS3KJiaXheEQNzUhO80bDW+iKHh7CBMiWn7Z/18N1rVDRcNu67K7mzBxyyMcTLe7BSXOw k/APjFTNpJ93Ech6/mPx6Rv3TPYawm5fckzGw6fiNI7In0Z/lHw+EZLw4+EykhkHCOKDJOYtAOnt gibgceTsjwE3vit3dsR4g8gD3A9kRUuLwRLU7/VGgKTz7zvO3bx9wc6DP8lV8RYW9auiNgW8wMiB VHJ0B1cVBy0rvAhJDA/SPqicGdbIR00z8scMWXtC5FwrMxgntb0jU4JqCaqXt42RkzJrIT6w0dDr sw3phzoc6MArmJmX1tOB95S/C71Sam+k2AKqJq2zsR7ioqIShnJHBDB5+EfafWTSZYbadU0rssX1 oP7AskqY3BV4iTSkmGnpRB77KCoCVkTvambwY9uMXPqvXExNWq9oommq/JGwsAx5HMZtcTF9fGbi jUSxMVJTe9NhERhLEJ67+hg57AkGkj4KDuemc5t3dRDwSESXxTzxET2C/5QaxZCxMEra04EE4zzJ 4zSnyd3lOyJuypqscUlYmkZAG/nfgFgoFLFy+PJEkKgLAB5kI4Ln6IiYIuV7O1YT5eyu1yGkc8Mc YESPRHSd/FHPoxvW6E3XryqZTILIi/DKTwuvSEEKrPUiBz6+0EwMRj6DSkTsNFzwaK1HRKCzFkqK XNdWNzKoAqhIUO7nPhEsOKWMFB5j1oIlRDZTqmEh9VZLNuJDVAcRAoEEmOi8AiXBhyUsqfVIPrcs qYRAvoXteil6UGVBMCzBw1+ctTP1VVPQvZ2jB8aud8V9mz6s+Cp8vBzkW8wJr6gBmBoV593XZJrH l2OXC2Tc8B9YNAaHBQHtFjgqCzDPcwBWFgvbI7bIpHewoBNlaGZIiOlwYhPzyU1TAwhc7oBvZHwK k0+LfRSqjo+YoypedFc5LvWi95CAia28GZXvQM3u4PVYba1tNBQ+VzEPQeIryWbbIW3i4sLWwd3U 1BxGbJXd33xHw2Vot90rynK1udlm76swJQVr1Gjn6d+FsCbruHHONtUUVAwU+WCsWKNBgzZkQuPO xc3QgmCqrKiFdx54cjnI8ChnLsRJCjz8nP6jNWp+bSZ5DlgCoEyZYh0LIRJEdCAO6VwtzXmO8K9l PC8vIwfmkwX0DqqvbcE4ocRY3ktrs88YFRdb7XUXvGkZEDQuCJiHdsLIwzSmFTzS6nRB6XiFyJUF gyZaJrFc4eeqt8hkZFk6QDAXZedupF+ynJVSDWKLE0FxuEOIwF/N6+6jlsIegfx4J/gfY0azLBk0 aPbqgn2ZE6jvmVBZDHJioCoJJBMvhSSnbTsefNiagKqXrdMeKYm9hV5c+6y0gmJNMjQO7ji3o9l0 VHS5vg+dDiUNJH1ocNNgkb5isKBrTXfaFWFALEQRJyg9Igbojysi5LVnUQy6UP2s5YRYGGVHMC/c 7LEAQE1M5qkQGjoaawrbN1uOQDnLNDrGRgLn1/P4RO6zUU62dQCrC2xCoiAwoiEESQy401Xzgh64 EE0i5SEkdsh4fEyJsMlb0w4ZcETiR8YmaY915ptQ04fRx73e6XdGbJglHGY5PkHbucemfrbcvKdj bZ8JZ9U0My0UwclpGfvNPYES2ItBe3a7TXEMDQTGwLSRMJqQSME3HDxhnJjOKMfR3Fmfjb7kRkXJ C/UsSkuJkHxXZ33mQrg4QHR1sPqjJ+wC1Al0X2DyF3w64fQJzPdD2ZGPT6JJJpBCdwZKzU/ch+iU Ersg0JuCWHSQjkyLHQYMmR7qSCdxQlMJkHzBgdDbY1aR7v4f2JCAnVVh7cOfO/VfTmVZv8yWl/PK Zbsn4Xo2G/2J7E3ez8sY4xPYk96ffy+j0Ch7JLC9JNULhfADbiTXpVDQsvceQpUF6LiIBqmk5+4E EEFnMqIjidtnh5WqoMvTjL4ZRHPIRfVoRybV0VOCnsG+U1khixaxp2g5m6M6Wk4rmHfYmJjAViNq y9RLjAoZUKcsaCx8pKMU4DbgiFlWLWsLZuZIwWsio4uZTta7MG5ndT1+J78ITcTd2C7dEvXyTZKX tkVECUCIjCISAGCSJuc2XEft9T7j1uLO/i2xCpIa0WJYFiqvirKiipxPh2p4yuzHpZ7KYYLu5jBa oElgdIVeiUl6TpGAkUKCuB8M6EUYQ86uHVFIxVw0Wknc6YPAPIb8nVqyb267ikcRlUgk2dHTa4PI RDREtTB67bXruWrqBmKZAfOSwOYkIl1KkpDGcyBEx4Zw0Ts/w8qLcxCCFURkUESpPSiuIkYQiRki lpUDJu01kWGLi0wMDnvdgL0kfRDNuRT9UlLeZcGhFuxWBmp9lm4KCilUJRuj1PCkCh7ZpYZHA9sc WoIrZpagD9GRQ89cJXk+rhMgxADhnkFpAez1vt62Q/qK6LHDovyc36Gek2l3OFRei1gRpmUEv97F QpA7hoUjC/uQnkugawFrlyVhLgSPQ1obrWw0KUMnojptms8GooujTnHLPZREuAjLZL0lIhvr6oXj tK0wQZoMu4dUehfTjvnZO5MRedTgGtcSRgToQ16InogJ3CASnbdl9X9cWS1WKO8lfT0tLhueLKsh Clbf2ZPisKtxxXqQTccCJderAXwFFTmeWJ0Ly8zvbjQpEttQFqD1dEERi4FLfTZ6NWLmffVvTYn6 5ycLxrOdLXAbjo6PRexjy8dXNdIrSFcgcfvpyJHSeEJxLwsvsIFXPEHQQdN6nTjM0nkOQ24wIooG RfFDAqSyS85KvhN8Jf8Pw3nwM/vQSx7ILD/PuIyP4Bg7yZPSjeE6XP5p8F7Ur6dmkrM7NCu9ZEPO MBMpxLinXJYBmgPrsy58FQYR1HFOxQyoq/Ap1I9UkCzmaUerFTqDg02DJ8mhjzcrZPwbHr0nJ7Zt ycgeXqXRRBSZ5Oi91LOWKli3UiBTvNFhHFKHRYp8PiJFwChcUsXaZhoU8PKlS5hEwYeY6gz6REKq d56l+giIVaFwOgAJ+iIX6SKiqWudEH24ZkRXHo9HmDHn7UPRc3eBK/kega4RkOtBGEI4F5AU8Prr vzeUkEgx1iif4ssGDY2xU9Eh89ns4xqgpMix1YZKz+4hOXtETVvQlNZqdDEG8+1S8HOoFK2MHQ3l 0wVJfkqGTcFXINg3dyhZS/U2GHHslLHEQKxyq15iqCgXgfA2cGVQmVDbdg2vs39rtb9l/DHNfq6c T4yfSQ+oaxO1+I/A9JPgGZlH1TuHcS+T0nWpPMPBOyOPFEwwVovorjbu4GgWgutE2gBe+4H1TIBZ wXvPNLE9R09BapevufESgFQPPfbob50SgQfOPP4M/h7xRvQDHKJYOR6Me7tMWtze1RPXEtN2z6VU 1eU9S6MZwGtqFNQNMZKmtvJmg5sZUh60pxjSHrBszFVCSccYF4wKXUuurIY20jfdPdkyW1tW1ceD cpCoSi4URjKSjIhSzHhbg1MrWtMaK1YLfK4wzOIIlbfJbRFTbbT53OmtlcNWi0iTjZYNakPdYlUL GZdRqzlhJoNPkeXeJ25DKbpkzJmUNNhc7238QCvyWknChIp4TBCaYRMFu7vn6WfuuvdbGzKKmNe0 VUi0hxpfzkAO5PN0gRDoy/1+skTw4SOC7MDkBL2H00SgPxQ6LLddv+aVb7oImZdJkCpjzmIYs2ll yQQtdrr2zYwYWb9F6Dqx89z5H7Kxjaphek0MMHrOKTKFFH+oZ4Lv6nRvQ59AAo/neWXe2uJv6sM8 20OngUEi1JQDs0A9HkL4KGVeiIGLCHmAmkV+x9yyTSuGDsdCQIkpS6S7biDcKzTNF6h+pxprZx7u MfMdKd+11XKcT8SGpfss44PH9Lhs1mAxeO6yoWOF2GG7oh49VcPSSHnubRgzmT0iX7m/Dj8bNK0K UsddVmZOkA8HQ6FJlSg+2ydR+NEN3EBEvIzONUESZiMIXRHCQOdC95kdDqVcmiYsKc/jPfpGx06r d4VXT5hR38IsFE+D5dEuTKa9PGyS7A1owETEprhsTH3UDLS3B5GWUgeUkQN1IPDXxo9FKcNmOEBT 9hE/ICdNi9TLbg5KfWxSc5r49RbSY8CXRlEiapkdjJRTNT6YkKiwXM20i072a9etB6IMbQcgygkW ESSIImk1I0HLXZE+xIl0MSU3UxI6KUOhjlBGNFWmeSK9GpnU55UyfAWTrezIphHubMhPv+Qg9Sui vRVmXRLBkweVmULG5SKgPOW7ki+gD6/DEHZVGHYyuYPB7X65MYY/elyqbIOiqEsb2oWswgc3qhEv 7e7vtsA98+tDRAGER4bKY4Dxx1DTp0KougE38du45Fabr80tbTgFe2S0wNtBSerGdAGStUuu9SN/ ifcuW2PrQTLqLwmVWeJNQmQA5w0WKYU1/DJ+nVQqcOtFAa+TRo1YrBUNlSDou5h0GKlB2BUHPhre jrrBEiyMIuz04F8H8ETrroPYw5n0xIwXKTPDQU1DlyxcswFgyXLCHryqJgwiEpl62nRwn0SKmr0P 1Wupq95IHxingcHHAOufqJHDOjaf0hBNQcOiihcxLOBTu/z82MFK0PRSmDCXET0vuWppW9qlU94G ZDyzhOUeCwdq7lCqHEQNxxxoOlG1epW9D1MEwAO4vXEDwQyyGHch20dAGsHxnwBeCu4HUVDiou3x +Qi/WH93x/ETVSBfy5F3WyMqqCG07qsmPfw0DuDkQjyWtcJuo0cBLYHnDySRcwNJGTCCkGCRU8N3 NOMFwHIyxEZd2IoPSCizy9rJDqGIq1L02xCeC90VPGEVyJDkXdeyp4A42458L1E3eg3Q7ADUosBg MkSoD292HFx1ZEPi4HnbHV+LCQG1MDYDNcAOMUvL6YzEelbJtoXiZQ423YBYrhlRJEViIQTe5CIk hUQRIufZcrMZJCGBcUZixU2fjaYXWBSGyauX/ogzh2Td1VbMkzNwCxekoJPJEo1esrOfOsFMkimZ mqnQ+doiHhOBbwPgpWE4GQjOc7S048lfSkmfWLRGRhThSK3tpAwKwZKKkbm+N0YghUdIEcCaeZ5m sLxCKDSBgEJRY68nsoIYIc4nabLJDk9HWCns656ALkpiGTRrazWe+N1DVW1nLIiAhc6UZEQJ9doF sCiDIraGcSLIgMp6PWz2YGFQz1f0dbHnJQyHUncDs6Fzix0LSw/SJvugJ+SdbmTvviKzxYmwEIF5 plSOBIuSkA+m7mWvxw8MfHlJJ0CEuaJdIkC6kUHFPOidzo7KDhM6Pf5dIT1e3HjrcOPJ3iB8sJMW mhWp3OLJJWlNERi4tzBaQy1hp0U3KaqUxVg10RPKNBYjISFMyCmjwvMtUudbK/y14+UTsxdhV7ea 5rJD0gLa3dwKgPFJNXuOEQ5UF6Kt7meZOzAuTRs2p1/Ug5Av4h5K/B/GTxHkiv58bUl8bLc7tNff m9x1sY2KJM7qrVCFoUyGRSlSsHo6JUOF8D77dOKKMi4XJQnBqjU6J8MHReDJdjWzjY1whbLemjk5 BxAh7jMXOH7IJ2c3VUQTCoGEVRmUbo4xIg0RrZPoslps5VjgdGX8rF5dQVqfeukn88qZ3MAyXEOu pTs0gqEdmOu8GDY5OLfVfBaWGAdMYd5OKQVERB6/RhQLjFxEQzzMM6kuy+k85WeR/nqtI4ZIOvnh 7+DAxMcwIT6sY1sHGuftBQK+BsKU4mB5CnhTs0MEpBM2bA4TPAJTKTOGR4tUmhIp3s6EMEcxFtFi pMkSJNvyshLKZI0M5g7I0KXKiDedahje62LjFfZzrITG5ojHgMxLyQnC0sS4Y2HsQznUC5b0bXM/ D1r9yIDluipwQ04DlS1xyWCBSYx3EOb/NBk4MGbJ2YMd6MJOETnTL7ewfDj8CaiO4kG0A9F0vgWd Djac3LF7ms4Wq5aGTDoj0EOtB/sBy2tVbBSzq3aF7Q5LAd3dHqo+DnTfDxja9ysc+m5z1z55xm+a 2CuoUNEMSzFRQRCCSATZzLfNxWAIG2RYR4JpxrtjEkkliC3FZRloFBRrBxQ4IxQbRgjOVKRnKhSa fYyKrBFKnIWbGnaIp91xJxZtZcGM2SXccYbREHTS6EsWLHrB1weM1Q4ACh2GgDoJKhpwB7Fl269n Piqqq7LoHPetrOqD2ZTCgeMzdnQZmZpBHBYnYYML0RC+SXrMjHNfpU7/rq3msBk3rSSQvVcyYzv7 8zkW4VSO9h7zsyGMuK3FucArZoyU8oz2VZZFZMM/o9M4IiBr2UmiRxTXnTOiCC91CmrSjcLlZTJ9 mS4iYwyAlKlBxEwcZ8DMVNMckUVitgJbHIubkgq9PKozLjMZkVJSATiz4TPHRepIiBU4ejtu9IKo eFOwTw2amJIW2ylBYhHNjNyNb+wByQJkoFzqNVpOMxmgLzbkAnbhWGE3WW1Zzg0LyIKMwxMIAM1S W3RLoeJ0DBF/p8xI/hrB9L9aUkAuekhzjfTuwv155orkcp27Ppc+j1NTg0vQ9hBTFaDsXGhYRE7Y JF+YEOiYVBV0hFnpU7QEqR/L1k5YQMCATevViVzRKLQdKXYJh7OmP0tMUNKdCFWe76jEmkolNeqZ LB5NSvqxdBbDH1JoiXHTiy6MF8lgwngoWbCCImBLDZVSZvzBImcV21zF0Dak4zJXLTALBKsy1qk/ n5gpI2WtEFhichcs3k5w2mSpuy18ZfBwZVL731ntJcwWH45EDcZBESZzsi0TNHDwdTWZ5Jj3HTRM hJpMKDnOTOg2YNTns73sAVh17Qz2Mesk3RmAqczs2MSAkUClvWpoJoxHokEeNU8Li27yPbku23El 8nd+gsXscDARm2+tGBjL8oIJVTgDsCSs516pJY3SaHQMhfMtiivE2ZMqVtgIRIyMTpMqApIhPhSU iz0G0Ro9rlMS0vEiVFKmmjGgENs0L8cnHqIiF2eBT+J3Di0btclhEQZPhMJtRuJfaNoYwZI8mnRI lcwKyGLkggoM8W6YSx84PxaZoYBjsnk0aDXDAUKMXL8BkkfFg6BiYTFJdbz902Fi9m4KMUySNi7K mT4Y8MEh6jzBzVy5BNZ9XyZOzZY+Z5OGylzCFYv5ggyKVKJYjZv5QSDWWBaULEsCyZVX+tWVMkz9 HcCkD+dF/PMlazJwHBStxrgVPQMgxB2bifxOuWvKMhNry7FTq6C21rXKYtMc29ZgNWnzRtCdvYnt sI7UMJDd8h9esdqKfpVUnb+ISQdLh6ps9RIeJ2a1Sx94mS9G9XdsY+JydEBuuGLCZ4tQdMGUVIQX lS2pV6oVAzmqf3p5HP5lxaUQsLi0wREIwGrGUHm6Cue04PUvvk4FSheVL0svuUL6RFUEvIFW661s ITBhsQAbhU7iiBiFSRkWoLVZC0uVCRLChUaIlq3qGJVLBUlqLEMhFrIgJSU4o91oMkiYIMEkAogJ cIbFkoYQFiQmFjMWXZsmWNVnrqkiiqLVQkVJBLZtFSqTCADdfXFZQFQJjmZzFt5tAAMzF2AygAGc MzCQm1qjYKJpU0P8h37L64/sh9owwiiiEx7KuTOHIOFlAUZH6IP0cfnuOzc3NrGTR8p07dhN4+49 J27OBdL10/zKGc8CChJJQgmUNef3fvPa5tcJyElOP0kitIrg2LQrMkCO1g3QJYHMtuuIrZcXEraR oIKwmBZaX1Nl38vp/IhUP0UEIP5pIqSP8KSw1JD7HM9weofELy0AkqEiGzrmJst53DkpdGkZraRx /71Li4u1uXVJNA1HN2175zMO4uSHTD2hhU0YSrQtJMgTMStDFSEwUzTMsFJLTDLRAxRSNDTBA+97 qUVQ2BjkVFQ0NDVFUUNFDVVVUCUAUSuKmGRYaFwXNBkFNNWAmkwkXTk2GOTQUFiDMKwYxNgEAqwB EDDDCwrh2hbjR02v/1a77wvDwwO5RP7hECZfOaIwjtP7g/CaezxaT8oP8kkXEQ/78qfsTEfxCAOJ vG/elpvdKUOoRxIwrC0R+Tjdcj0C6IA9s0CYG1cjcdCoG0gjA6UDAVDCwhT3zY+2+A78yf1TOWo2 waFrQf5sJQqSxD3JFJQXohhIioXiFy50nuSHqn3J/q/2o/mxP/iSf7ki0MD/59ktP1T/IblCoTYG hlGf7v6y1R9Yuf6L1qi9NP9Z1gMKpFFKQzMESlCFSxFAsBS0KlCgQqtAhoP3j4HY+vQr7Q/5vU5E eHl2AOiIiSmrOX4/88N/9ydmPB5oB6KCxQKXiWFB/2A6JJc5GQstG4cUtQwJSLmRv3ydYw8IidXe /wUlylFQlHokNDWAYQRAGOHkpMGqqqe6txwtRd9VBeTl1rZQqTgoLe41KbRpcuzgp+6gw3l+VEDn duutFNI4skinLGZgtCmEhaQq+CmUwMjMnVxZqcy/ClPBKEq702y/EgoQp/mQCp/5hyXBofjemsgO zrNVoNpfUM2ZbJou7Jtae3D/GILjsn/1t3F7vnKw8PivT3kvJHr/Gd2MYu1IxDKkk9XoWSf6DFbu oZU1i6x+2jfHq7DqvdYEIeSbRF0CQgNwOsV2KC8y8OrBh9IHQgUgkBwxXFSFOwP1Cu+Io3DeLuoF VdcC6iCJ7AmhAwqXA6YSGLxtZSipS4d2t+0LJYwqKUs3xMhmiP8PjDkySM6DQ0S2ihakionwAeAI OsFLks4o+qA9RA/XCcRzdRPaeB1ET4xRvZKKXeSryXKei3lLKiqkRevItIvc3UlDenyOT3k942je XkG86CvaNGoYohNnUFjVqAsEKQwRli80KN9LKonEwdowQX6wUe8HYZTGc4KKCjqeiVOqmYMBozzp 91o42VeKSsp0LLZt9Kp42UkzZpD3+AXLhSQopMHkkWLiUU43tx5JJtDsgZ04GiXyGOecRpgj4xaz xf7EcZ9fJwCpImwsvueUkNki69eMCyYVcX0IuvWUXS69YpRSUvov6jWJOXEFyKXcilhQUmWCFIC2 xEtDC1TCxAzXmwjCqj4oz+eOUwUvoE7R8CnrHwinujfEJhOSgpm/tpOZzNrqlT19Li5guiLPd4LJ Hm1jHtaoYCT7KkeJdDcuYSJrVg0mw1hnDAV+wn5n2PzPrUGpUqRSaZA+gL7DcC9w0uz/CfqPsP09 gHf+o+0IiIiIj7sMIIMP2Xr9P6g9h5vX7p6/i9Od5QwVOPulx2lhNilSBsqpUUqWSEhQt27/38M0 GfgNSgdZI/wDsEIoCUlUwT/g2h/GtW4tIIiEeY+9+bQfnAk2/fyUMBdCxgsjOBjMoqwgAQF5DknM FRRXIOMLRm6heA2ha4y5uggyXLAtKX9pRQLlgxy3l1/Gy7d3CciiKBkFDtJQQ3G68G53QJtW3Af4 nbipbCHIldgOMDmDA2MWTcVC//WhhGF6jkVEmN6Onr/h8K4l6Aj8n0AkPX4CfzNhXIOfOn+h+RYg 1NEDKpBGEN6uEf1/yj4Vr8fj8DEQYAtiFsLoxEdADcft4uP2juwDfan/AeUJmbicP22lpZ1APNOI GXBVqflhfhYXsP45jHIr6oiIIjGR/aZgmmoMMWFZF9EQEBYL8bizGhuRqYZem5vvH8LctbSBuZGA YDmDI4G+g8gNIpHVtyCRa695QAVET0ALhMISxmQXMFjBlrgSmTD5Ou9NmpYsOQRWWS+SpkKvt/Px yhoKqzcWOtaBfrc8kTMYyqXgaBCgFADJ69arXwTouSGKlxV/oIGzGIOjVOx8c178HFIWZIoPnp6j B3Q7PCGUVq4hzFw0V66sRI8qF+yW8SoUMpYtBy5F6NziEzrdifH0FAavZSldCmh0TpmLyIJ6HoYO AS1qQwxFzNTFY6F0gMZoLAZqtYEM2J9H2REcPDJPJ200GOwqPEyYxW8XH8sBq4cObNB8gOkr4vRO gEp4ikd8KCVy6zQZyTbOMzajXqduGeljAa55ovSlM1Vi/04osvsnNbR3PHk94paXHE4mDEyZggSx JEXonJUpYsBbDIkdVu1mBjAMlpU+u0YhQv7SUZ64iShn2mNM0lNKjjUxSCgbooTFIuAzGt/JTwVN bj4qfNCuSmVezxMqa8FUQPC7I7RCEnljk3besr1bzXF5dTcsCzRkj0uKodUXgKJ9csL6pohqVIHw EgkR3x85BnGJqNCK8yHccCQ6wmF1+4vcQfdcLdW27Vjsl0bs/0PnRssN4dOvRy2HMj1Lv9kOqIEy Pn86k81ePu0gPQJJ/S9BH1zPrevEfEnZ1VycnzMbsHvA6P/NHJdGQYCAO5Gk+8dOffL/yrT3F12U 8uPB9H4E/MezAwwZMAjGMGWVYUtJSWR+0/ZGTIVLwP+2azvmCj6k50rULgUI2p0DGDC6HsgRQlIT 8nWCm4VOx/BcXMgc8hETMRxcd4qTU3wEwnSBpS5+N9lwf8wsFE1d9Qe3U3Bgw+VnNbBxiHmBaf6I fFX6Zku+6k0nG08A1B2BvMaFQ7YUFGSFv1F3WoNwf451LsvUEsMEJEQcw5iiajye7dodR5xWMOQZ REUdiRzpJGEOCqPv4phjekyjrZsam1G1vFFOhU86h4Mkq7oPIcncNq750ht03EI2Nuu93ZrlNy2u QknI6KG/QVMUhSZSfye6jTlRoDl9weJDdIAj0Kn0QzBEOoLjb4YgNiI+Z3q3vewNqh/YalBoQGpC U8/gPoDXSeAUOe8iD7gdND+2gfHOEJ/ATtEROw47EA8On2/FurXpdT9a2JuI04Fx9A9y0tYLTmeq Ye4h+glcE28yyhOYxImfieccC9Q/FrRFYmkIiB/ddCfybyOOGxxCRUx28quUvyP+CAod87FNb65B GyDFgOiGK0NzPUfvJEtEjB62GNxevmgMEDU+iGyAgOj9kE8+IFkZsGRGBXSftQ6O5OLTNk3rHRiy djqN5V8uXrLy5sOBI4Zu3YpYqYMnq36CU7J1mKdKo0jmFGJcFJxr42WIGC/Ouu00SHNwYgQzkx39 RC6wX2+ry3MyJr2QTIcbGRiGRiOImplrEUCNKi1iwZGkWFmp2SRgnKP7veMyOG/gALoYywcMlSJT JBSpnOD5OiIlPhEaWp4GTXfXBHNcpuXsUqbOdzA1waqhf4r1H1HPmmSBXztIOEkS9DZpPVFLDm13 clwVrEVNHZcUwToYOyoxaG4xOeM5KF8VGJChQWqkxrL2b22E0C9nkX782bd6C5pmyb3BSLNneOgJ m9ac/zf/ELGAmYLe2+Ut3zw0xhvZMKnOFw1hk2YMuZr+B5QvJ2ZYslpKb6K9DlyDv6FuryLULjFv HyfsiXxfwfNkvA5qU/DcMCoYKF6UxG4SCOAyGUcbXi2/WhuiB7IlLxPQbGDY4o7D7Pz85zwb2KYK eyczEjAf5+yZTXUkeaJsAbSmWlAGLOrMvx+Ym+EoFyClTM00DQ32pnMkEyUNJCmlILyLRyLApq8B 44D5Ic0SqPWD8x08CCCBT30PI7HWe7E9gv2PjCcBjGMWMLEIzAwwsSMWHBIxYcUIxYcEjCwCMYwC MLAIxjBjFhxWMYwYxYcGMLEjCxIwsSMLEjCxIxEgTApaCgsUtKW/1SR++Pc7Q3VVIlDAXgwYOZ/j utBM1ytm1Dg6R/H8Mh6p2mPMKfIDWqmSP9daNgb4EXqTBNO2hFquMO4cRyR+N4eiqqdU7kMEmcPt hY0hvJuk+0L/k5Bh+sflGcT8Pk3E5wn4DkNpPyMh+iT907upAfSoJFUSE3I73vWTWYpO+cLAsdCT 7+X3/Pb2YbDZJNBqCQCwKQhC0DGqcezzCCcpuPgzJYGUgpRvYgAo/4MBnM9gzFMjQjSZ8y3UpeQC 1w5rmqmc05Iw9b7q2IhFLBkbGCg9jOLmQ2UBwwiXt9/1uGfDBs0pDEjJLLJIMm6CKdF3FJ/vRIO+ E69FkYybPySxTRw8tmpYcFGJj2RE/O9RdZO30/r14b9eG8D3Bw4CkxbkF0LoN32mfOHk9pNsdkHY fDfnQyeEaNDjeuRkhjQv9QcS+s5oQJbFxbXleRL5Dy5HnAnEe4rg2pXWQbsT7ZwibUb6DnCGtBTU i6a+BE+W6K2OjiniUHFEA+ABRwVPNGeuzJQ1lTkZ7LVobOFj94Hh/hCMGa9XhSN1MlTVgYNnRwcm vzNdF7NTTy7t7bN0cGzoxbOC5+N/s8Se98ygqil0ywvyLQNWxNXG0TYlxw+IKapaUvmYdCALmSPj EiEI/9v9yR/tH2ZgHe+6hnEI4CC8hUVU8WxNRWXHNTkxsPGebERGInbcIDuC95vNm0fmOQ4feQk4 ZezdripTBobMcMuXqdxMkSAv8fG55MjZYaEFLzD6hQehdOp/Q9MUPI8wG4gt5rRxppmXWpXSYhxY uBgGLeI55sbhqiJC++xccTD5zFQt7ky4ZP0xMbkUuiSAiZkIB+gEkTDUNS0V5ciVTkXi3XhpnmHO bUz520MDk4Hqq1/ERDadbU3JIUXUjx4uOOxFSsjhAIF2/TB4sXW85sOy6bnHj9Q7B+Pl2yRXiqqT WouUVWCnT5BHh2ge+9KoweADeaxXvSDUJR68OxHA/YhR7TGbqqyquQl0KPmDuEKVQsHNpFglVEDl PnB8hbEhCDcL1uAFFT8EtcTRJT9/kCCreUHDrFS1hx1CgRz65Kwl4ifG9o1/3lPIgMY4raNTiQno 0Ehg73AJQxB29AOtDBNoivQYTMvFM3aBIhVhPLzNVvood2zTxI+s3EsVqYxQ/ADSBpDSQENoHquP 6r0V96FyhPwDiLv47jiodQDnBdyPsrpUX4Po8jUNTIH5TzZH1Rl8cPtgUKajMhNpORZBEDE6KCAi CksQ0mjR6taTUMURRsQ6tFEUGuM1Oc/B5/kPo+D3OOb2dSgst3msSSXSTDFo/awuebbB8neY+vmd csWSzIqTE5MTVcziioenYREMscrbJW1qsVuMKSKllpMWZNuzsv0JVR9mnPW0tvBvZHgsxMmvYSJm BK7ZEESwcevrUofZhYOGLDMHmwZY1lkI8eei2RA+LuJ8dkp+iovCtbwQWybSp+gntBOFZHR31kDd DXQTivxXYbvB2ui4vdNFDtUTJiBNlu08yG2OuDmO5oIHB+mOhoJHSl1IEncsdFujJzhXI1RDrdRa 6nOcgmKZFTgWGyUGNhhqGg8EAE6yehKetGAydD5HGsP40eHY7O82NR4TYPH6KJoopvOqi+YDzAVn wDZ84yws6fHygUoXlWOAdZOi8jqM+iKHH6sG3ekjc57mruUsyYT9qN3DqH6ZtDR4G6um6mC9d03u e5qswwfBHySTac3kREWlLSRYV5KdKey8eDdTkcOdxvwcNXl1GmZPhbIJiUKNTkaR2W4KnDe6d9/r p5Ih7AbIiJAQ/A7GCUYJYJT7ELuDSbTWYJoM+0oBuNgdMC54Fl9zw3a+R4vBdo1fMTdweLJ7tmbz XJCkzB4K/JqKiq548+yWtBjuAyQ1C6l0TSYTTYISg8H9ae0RJcPKRUguIFYKEG9lldw5xx3tQjCB PEgzpn0VRULkTcZyo5DJkNxVhTwQOrhg3S+HXw2s4q4eKOdnDN7uRbYVcbbfKSKqdaWVKqTwdjly 9p5tm5J7JKSZuDHAxZ01PVB4NaaI256ECKDxEghqbGTFThwOnXhGg8nux6ObMW69+jv8T0bXM2Cm NNHqT9EkxE6pu0Abh+JveSADQexqP0HONo9URY5XG944PBuQ9e/dqF2CJ1gWm4jwT4A9XzAs8DsS AxSMSDFjAnBIwJwYwsD+hfi05QDoZOKhYJrPI7A4283so9Xn6i3ip5J1L4RdI74zkdLxtG6431cH WE8hiPOJtIdYdXa5SfNG8a7/iSycd8pTrVV+exPdW7lGL3ME/hFk5RofRgSh80iUTiYlKcTcjT7E rYTffF5YslhQvDze45ecS3eDK0qrIypJZ0ZLzmsTNla4CQQ4YpQQLqrfelSmdCE+NthZjSRRR4ZB 4rNDMDD6JDrahjEEoorzvJJ6HYZTa4gy1kJz5WAyoKwzKl1mtlQkYRWR12M3FIuMEgJoyiLEMUco gsucWFqwkadFnMdB1FcqDlSBkiZox72bpzVfR/v3G31cH2ahiDGi3Rv1VB1W2E23FvEGzEhxb9sV q4RRbrWNbCEm+YfKaeecKKgbPHo7jgBKICCQ3REAoiiWGYZ5e4n1Dj17dC/Y4nJl5GBShUdAuahZ z+JkuGxRBg/hv4AkzH4pkzw30vOb3bJL4y6+WrEqdunrtGz5L3U52T4v4cJS7ZfCdr16357trdEj OPTqHUZOg+/J/SQzFthG+AoE2ip1AoSBnJQ6j4EUHcA+oTomMKlnv8rx18sAcmYVVjAUMSA2a3Ai fzERdkyGELBnvxrm1AcsYNlZFfvmRVmM7Y/AggofDG9BKmj80RJ1PPftjrWSz6tk0PofA8SFB8jm IwZ5lRk2JGdlLzca4Zpzhj4M/rhfdvDt2sFtfN3hjB0Wtjb28y2a8lk66XK3Y6x4TLKvc+BJ0O0P hCLljG3PvjCNnHHl8dnecWpz8+fTN0cq8M/Dr2beXpSK4cq5dHz44u4Z725WLOetst4cbjgzLgPO Xr0uwlb4Xv46VlV92cOI1vNpZ5u4WMd2t+O8ulu7WWFMdFOcNSnUETA7xO/ADxBNtBaFwenpxLiZ cao8f3L4ZovateYTTwTE0M8bNm1MlmDl22bMT1jc1h0arm2YJGcmTQEeebH51HR8mlLaB4JaopQs jeMUYNOfpE8/J42jn6IkxCTmJ00ajwxp6nobzoUxjFCtgCakmjxzaSkpa6kio9mbCWMG0nMmUb9K 0ODspucWLUas1+O3ynveZSKPNaFKhY+EhD4yEPRHsZCOEiZ1JKoDQnnUzMaVozKoGgQpaCIIaSJm oYpJiCGikKWlwoswHgMON6zwp6nYFE8oArydvfmUtT9FSmSXEz1jQ+yZd/p2u5d5+A4NcjFy4i9Y kCZJz7OpzLiy4eQiKfGWUTDVM0rWgdrvggWAEk6gdGa1EBiJtqYHl5dB5vwc9xmcPA0XlQ5DjHcO MuAqX+LDUSMKZmNoQzKaJeKWG0kuMS4KO6+4MpX0VPcMYh5i+q9u7mmSDgdVSkM+tlUQZZMJOIob XHbdcRdHjaxJj7ypxrB68rS5PJCjq8EWdNwCqWkrKn8dNtXfWqsVjbNm8SgWovrbaPwjGWbrH2K1 pW+F0bUTY4k7zmHEU5dSNoke1gePjhfwUvUFWdw4uN0gkQLQJ+OQ4xms94dGEn0jhdf3i6qHitrT k+Psv0ppabfFfx1LzAAoETyWN7lX/xZ7qgo5W+LOUcaDNB7hVgzPgw5c5JqcpYJ3pUq9xaB4pjIT nq8SRuOvERDauHbw48MfR/c7Pm5xrAbxh58Iwu8Hwuph36SajuccvPzv3ERBX5DG0MWe57x441Q5 xZuriUpSZmMInsc0gncWL2btX/p8mLxSvSfEHcZ09/LqywYLC5c3EjOlint80vMXEcne1fRwJrGC y/rcMmAloHghlH4INvjhROs7hUoh62++joAME8leZyEPgD2K4DsNvlh0z+nl1dmeyK91NMe3Cmls Y5YevfDp7Urrrhj7e3d6cGsirxEQfXHpTjBIQhBWlC8jzFvVh18yj4t024vMrazgZmHh7wzDfNXb 0T8O0X8X66i9xp8iGbEdXwy3plcTxifBpx/hERDpBBDtOoDmijPdq9TqQ1niWf6wfpf7kOiOHann RQDtFkCIw3VRLf2D0LXixSQonSjKngKZjauCqqqUX4YNy/Vfe/L5f5S5ZVXx2mjw4FpJt8IHI285 2Hhio2is8uGRsLgqZ8tgqhRWSyDUIgQ1VRbjOS6wfr7wom10pmQqT8STtE2xOcqPVEbJ912DpC3h A+QHvkpaxJWFctUFVODBrDwBcnyRFFcNiyrZ5YMsL8lMLqw62vkZ6FY8Bjqkj8HmpnJB1DbsN+yO p0YoIKkN+SGxwg/aQBqBYBzpjB9mayocxb7wz1Q0GY5ctsj8w/7B+lPvuMYqZxiD+kOzSkwlkAND z4SbYXqDn46UhQcSGUUb7ko6MpOIxNyy7oowv0EJIOdbg0tchhhe/+xv6/xG5wSRszPuqRwjnACw 8uYvaJ91EkWQCIbipimK9sBLJKjIAh0NCaxjTCG6ChVZGYlXmAT3V7TUW6QyrqyEjfhRTUQLwHBO 8uTWp/xRwiTq275P8b7cqv2gQ/ewGU43zujgLAh/+MD8QmRN3LxBoBMJa3CqSfvIfoA8HW6f5qG/ lJRER9x8o9LKVC0ekUQkj/TyB9g/JCo9TlFSoVqK6k+g83xHMQH5vndgHxhGPDoDUa/x04WWRJYm JMMkTBEJDME2i6xby7JiOsN36luCXgv1FACh6lj8D6mP0/T3GQzjQoUwMEHHeWn6lCbz6KNc7LFr /4nR/uMkx/WVRql3s+iWWRDJIcJmGIyPil6yuYD+onQxgbbAGv7wCZM2rFjYaP3qW4dHLWLVCi9S NhYoG8hwzAzkhIAWHrtECSBhEoineNj1ofyQQ2bCRxj37g0VvKw0moW5S+JdYFvCOjTc03o6tzdo uHrAQSELFOkFLkdHYnDtOJS5ka5qxsmQxeB3IY5yKmgabIcUE2IFmAYumPeryHEOVt2CnFcxmnh0 9RTv7+/cxNfAxcrGu7xcFL2DMo5aeSQbPrd8lfsWHCsslcDDsDuZ/AuXyYMa1goL71s2UnU77VaH 80D7KgeIeU7uYOgBzRxpgn0odqBcqdnXTC9hORsyvm3KU9o/CgNcWtuhhiqTYKGDnrvsWQCyJuSK FSy7sETGjFRDsKo0vnWezqZPZWTiEuyZ6lM675O5+YB2CIe6bCh72Tzi/ocKno2ZzRNz795LzPQN M6m7kQgTDo6Ojh+RTNyxNTOujJ7K8G0REyWy6kf3mgnfzyI+v0NhwIKU9myXZipv43806nnCgzVc aNGmCs74Xq7B12y2a+f9FL3TOZsrndPCAm+OuNsV7k6uc5FOOOA5uN2/SRgpPb8O1e3MU0mY3w7D hgo7ueLJhGj7mjm8YCXu+RZP4c+55wlwL5Pcn2j+1QQjQuIH4qCEqFARCYT7VZg9kGVksk5g/IP5 ti6A+j4gdQLoA6J8V9KReDLrKkmD0HyhPpEfej03dD8xQ76CRAxAPeD75/h6PluWo4iFU5CpvdxS Y1J8FFqBzR0+ABqV9xm8j2PgJkRNw7wzq6jsTWn/GDzRsXs2Dr3Cp3KmUfBC4D6cBO1JQwGeviBR NyEwJy2ptIkegjCEUhVCLJdLguLVXVt3Iv7IflJ8o0zIYLuwUM1qdXxuSbjvFc6hxROHwWxOiD8V 462GAvTOwgptZQu2gafND4nL5WIWAcAvIV0NsJwdiidAU2kwVgCIAFYEyoa6odgna717QNMQQK+N mCcEHvQ5qhpNQljorxDISZE825fvklJvybldai/idy4FIXGBmPmlohtNLzTQPARIVdgPg9o7uxI+ 90/ejCTYmCHDtJsvi+fs1AdTwOMrJMh9DuUNoeeEplAMFebVB7fR+7djzdoN09B6Dgnn4w/ZCeEO EzkPj9mEPV7/3j5MCVLROCZjmU2fCZtS62NGjWh0KmsUg+JeBJHcD1qw97meyLR8h6D4dEcQxdsN g+Bquj3SHfn2vtIcx2I3G4p2RISVEqWQE9X6Cqy7hRLFk7aq/nYVT+pD16kvAzA7TSn6HeKe1x3B 6OPYukfARRQ0EQ1REUFRK0EEpvAG5gde78Gv3wvZ4uXP5PbD/CBKTLivAaiUIGkJIUnJQJfkfeeq i9o7RqnLWbE9PBHG5j1lz5tmiYIgiCEhxLmGfMPgHSP3h6/GT6vCPtjJLYjiM4lTiV6Z13rvB0Pz 9Ev7k4g3mUCDcHgQTrSTy1JgBsAPA6+xVOwHreIiZPFXnp4p1q9YGN4g53inKttu4TaCJl6j3/A4 m4DQDFiVFrvjve0WHYk8zAyGsk+OaI9R3yXsXWKoHUd4fsNYAWNsXGRqXKDa+5taipaJzmU7kyGC eyvsm4DmmBxHO+u42q0OsC7Mi6Efv6tq2J3g6Tb2DuELsaD199WIR8I78B9EamGKB/8CwQ3VDvQt Cvev3mPoRCZrIWusCzK32hQOAqQht7xqYJbuKU8w+vUKqSEi95Gzf2tWjNJHzRh4ZxSOfOpa73Vc Nga9EkfCzadkfq/ktLUWo/uqDuqvJ7ZSQTiVP5Tf8NpIWp8U726eHuD5nxGZB9IaPIXtypWqeKS4 kavAiFUkIvpIRhmW7/D1SlfoxmChsrAgfhDYOo0MDDUJDjAP4EIco7yxUS4cq61gfiNngdZT79r8 o8kLcnzIQy7UwHKAK7SUEgYqCfSOqYIKxRkiwFqgXIlW616fB5ednbbgWrTxUT86/vehDRNiFz9V espI3cIyYwLJ97R3CSJeDCq7PLPYiPP7HHNf5lD81cfqP1hyAUFAzTo8KSXLEEGafCA4/xP96A6i PtYH4AG00Cp3ipyFT75sI0DRKpe3YAKyexgmCIO1PcMidg9/YSyJ+J9lDtQcXeIm6xXyd0vfTAQS EQQUHxKHui/d7fyB6A6dzi1mQo41y+O9FQM9y9Lhwj8CCE4LiFuQ2QDigqH3Bxxtjjt8Q8QIWFf7 PD+FhYtiuF2khtWhxkcnqfpG9JIzUki9w9Owb4dS0xe9B9B7g/6BBENwLKS8B71cigh35okJkqmC uTwOZQklmPuIfY8gDAA/U+yo33SZ8tmekxYh3zGKCm2/9Z8Y/o80ModYxqOdeL+BvDpeOnKVz9pS 37r7eQwDON75riNI3R6yHrJMfJuDyjDKPXNP60f5wZeORResA6rAzn6fbw+f0P6KnJFBZeXF7hd8 fb3nx+w9JDkhmnqOPl3PePm+EkPpNCcQ+pOSfRv95XNVz/gKfJSfZmtOyr8ZmZvIbbiC7+zpuKPu SBYh5g+IFoYLtE5g2mhI8AMZKm9fmaNWtWc6Woe43OrfVcgAEJ28KWI+se7MmE+mCGWtcFKk8HYC xL11nfjF/iPRGB6x9wr4gZvgGNeIhA+FohvE1geK8kg8FewesiBfHcOgAVycbJ3IPBXrekB4Kh2r 2D2IfDvGoeZ2HQzoeILlT6uhIBE8MSHgLd0XWYgDyF3j7BrVsETe7DvQ7QdrkDqzzxOseIJ0UN2Y XIB8axyT4QfLD7mvdefB5jD3tMOi0xRqMJ+HHIi3faA43cBYQHffbNKaUhROBhUoQo5xFTeoe5NF MS+YHkDy2KgZiM6tykoJlFh8oQRNCVUyucVPcDZnO0Fu5F66IFYhDXu9MdRU0iapQH2hWkppiKA6 m6HiBSTofeBLbFIuolQOyL2fnzSkn0av8cNb8Gch0Gnug6Lox5saSkL4rJsXKg7kNRATIksIIFTQ PnoO90oeBVECBELudwdCgkCaH/hYT/Uxoozquj3DehiIfgNuu091L1in8S6/Q4qzdXa/41H+/u3k n556j/hP5I8wFMZ8VD4KEiqUXP4pmoB8AzPRO43ja/iwB+JaV5pg6TsVafDZYAB9DqJfNlwhnSIm z4/S89aiI8hhlkZZo0ekVPq2UHX0CcjzCoqVH4pjXIJ2CZDMv8v9v5DrNQakNiXH/iRvyFhAb5Ot Q1+Sd3soaXdcm4lEU9pCovaQSNySMF6RoSw2SUQdaZFLwOR9FpxEPtd1fiB8w+8hWQWqdqrzfjpq pdKsp9b76WvtcuyFm0S/uxGsh/QjyJ1Q+86KjLTipaVZayd8VCxS9LxcPzpdFtgFqqvUQCqDLeVB kszAH2W00JhrB+w9EznnsB6i515QzzXGsilp9gKrKWJxTqANRlR0IJYi/lAAeHxPkEPyRgkIZX9x +ACVPQG3c7m4KXloQ0EgkJxeZBhpIMRjEgwDR8R4lU4fo/qLXBKup+9OEnsV9IuR2Q6yU9FSELFC 1XvTyUbt0suFDSowWqg4W0EC1SBsRzDzaC0Rkazo6A0GzrbAO5N0AOQqb+KEuHcnWe60VPRO73eK 5SicF+OvADgaVU2Z3nz7v70ZkRZJHNyDxk8w+DkjmDkfYbbxN2dEfRXqQgbplItA8gA0vBQhoYDc vn3IbxUhcYvYgA1VJCraWvgCvZEek5yTGT8xGDSK4oUyvmsKgboRPefeGjG5lIB8xofnhoaeNjaM MD6qsifiTrG8n6w8kevzcx/X8HJPWF4zQZ/JDRpNZCHtB8Y/b5ozcR+51i6WhxggIIA4WFIIMf2q hYhWbUf2AiSckhzMNsn0AbTluG2I7wPAIbAkDDA/j0DiI/k1QaAHu9BgDxHl1fAgsPENx9Stvu1S +URGLhKViICIGgWRVBnnMGRhQksAJAQ5DI6OF/ffj04zs7hp5PLHbYLHeNfiTVvuu829GQscM4MI mQ7vaTB0UEhEw4EUJTsOAdx3J3R1t+/bRtt+LrnSo7CRHwp2iyAKaFE0aVVHQDiic5ucHSPAbcr5 RPPnzkdnMWj5ULje+1mI0TSfvvibP1k/icUPk3jYaXKS02PkAUAqg+30VyBbyy4tYmvUoIZV4Eii WRRGBU9PWh7YLzvIBrcx3PvpEKIfLa7UR8icvQg7YqT0iMVPEKkigulSHWl1GY4H8DMQ7LB9pRfI jiCAcRHL0Nn/XNhdLzpDObaH6wDyKWQwREgJA7uXWeJprFIatKM0qRQuT1+QMW93GaQf5MVtjA9h EQaCUYLKiH8Nho60xQ6qG2D5nIziJ4o9aGCD3RUhSIRIhCIADfLIQ401lFZVjooufyVzCpZqZzZQ uFWjzknyiz0q5snzfoHnD5uIYBiV9EgB1YuRxAtTSUT5EANh9l/5Xcx731Aig3QrUDHNMjJniPq3 AB+KO0DrRNLm9UeYO6TayYFLWqvlRZxLda9H6R9Bggpwb07pgQTxhtUGiNQYxDIrRoHHEUTZjylh HQT+ldG4uwiBykkiIYVRecgF8GpPu4q8Hme0H1iEp/nFKuirqTcoprO04j6zgcEQe55wnqtB8kNw dFxhkcCX8WwF4IbgKnnHMXxMgL38nj0MXfazDWHg8SLgFZJXjkMkyRv1mtBXyR+yDRAc1joHQPZ2 AbF1wwCfus7K7knyHXgP3sPJDjGW6I6frzJ4fPTFGgk61zABN2uuQrqKNFvfP4jY8E6wfyN66UTx 6GRRs1g/rVMaEFhKuN2ucB/V2OdqF0ik1tYL5D4Q1Byjw8snUXx7oVPfZsAOgGPinHimB2vw5pvT e0ALELy/eUhamlb0OpOGVLpKZeSDZiD2tUsql4G1EqoqL2EIJYpx0DvGoAH8GB7kNeA+ZjhPQVdg YYmXzxk5DqEktMGF/ZavMUhLeKySN09haQhekRSE0l4zFw1MYqVETG8ovZbhqHclyOFBLjaLyBjs HCOCWeAPOQ5o7El+MKD1A/t/yU1Bo4gf4ibARPA7MQaGICS9lQ/ugmskxMTFBlRTqHPNuaBnQUn2 qogYALNy+TJ4LL5R8FeksuS4fCYti4hPYhJM6lJPc2brVDwx1RBsPr3PT0xjWaJgDl5JH+VQHUHs TPxEvIcQ8Wv9Mze86pwjdPkPXpJODtpSkrseJ3jfTC1oqoij9n8Jx49Qmd5Dg0ghQTeUG2IThFhM tpEn9ZSkRCpWrlGv7LB9oCyPVQ3g00r8RX4q+i9iHzE7Oh0JMUQHY0QrCkRsov0rUElaiL2IqwEC gB9yoXnjgjyRhNCvQU6j81QwplDP8gNIu8GQqu0S/WsOjk5QHtz76bGICD2FSxQQhVFosj+UKUUN Sms7BIA+/iP1TkouRIQf1hZTIgA3I9X0IRvCgQF47DRlXJYVgC6/dNxojU3LlpCdv4B+B845SRu8 o6TgPhJOkMTuHsT9p0T+ve5QPIH6ghzN6eihkTr6g5U4g5pgjJEe7ZH0nm2cpPR8KekKGuhbe4fS h/anBPrDkjCT0W1Jg8s31Sag98bJ760MBvX/lKfisC44Q7ID0FSAyOzOC69w8OPmHV0+A9TtGGhM ER8x7w8ntJdE0QuA7PJXSBo0riKmJcwXiqQIHx7iGH9TUjxPeAGd1gdduG9wbfRDSbQcu36Hv7wN aP0ho0Q+7wSPwP2uaSfdJgHo1SdPFhCFCg40rlV5GNB+KPNDr3vNQwANI94uxWzOm9DrR0BK4gWF eeAHXsRATUcKGICntDzV9r7x7pMFTER6SMU4VrUqqqq847tobD0j3IdoPpJNXukPjlxM2XtyLqA7 i1e7aDxAw8YhgOEATEETMjHb6n8RpB4IPsJzb1cETtwQzoQB4Kh3hkOnAXR7MY+VqsUWC1WqCxSk UE0cmyDukxdswCpi8tkURMGszJ0wZNHvHoqQ/SG7t8eAeUF1zqUgyyP809wk5BE8GUNdqDIqePTS AdtOid7y15wbl4Adj40RKrkCODCbVSgQQtIMA0qiB8cAK46PKffCfYsZi4YEMj9XrFS0MYPZgcBM mM74ZYPYoBQPVP2/u2Hcjs5HRfGHRMCNHtGYmjPTayDTaiLAyMrJMczltsa+HubZ5AJsbpyD3/s5 iGzGPS2+C+dIGXH0z+BDogfvG0uPLEPs1P5ZyWptkMwFc6ADCkKovwfRMbb4JAXnBn++w/jT8ubL kf0+RctcZbLMnOL6n+sLfBUhD8gAxCRA7NBiS8JJRvAdA5ipoVKAgP2Q4oZ+W0qBInv/waqJ2EIp xf2SJ5P3WPk2Ozh4ML4Ro8HV9l/SK+5TXc3N8nuYyKEy+SvUVFzBsXF4AtRyA/kWJaCDvAD6JQXQ BVUhYRQXeTwMygyVjE+oAMA3E0h2AeVbhwH+hWfBVSeP1L1HYGBv4hcKPIU2s/9TjJC2wMRDH0Pp EUNJyAn2G1mOxNa2IdnaD1gbVD3qh4Sg9ZM4jvLx5EqcX9yiNiXWqX+C6x8laAVIA62A61acgaBc KkCKUWJS1V0nVqMojBP6SY26DhJMfefLBnFTJFMHDsJSIoyHQqTiCmCp+URMlUoB+xR6D6DcW6J3 msrEGDjp0tqO0kxUWdiJNH1u4SKRCRYpkXhIGI+c+WZ7fhewMF2mMMb/BJlVKTZJoq3fcIRpS6j7 ChFZM6sGOLtyfIYG0bJMR39+zyeQhAwEaHCZzqZuI8pDrCrAwwsfjonNLN0TgQ7Jy6hDH8gZaCW0 JrlrUxwX8btQsVEMyhOTz1ivqedh9/MUq3CBlS/9L8er86dp5AZxcQ3vVzXT2aBA7dHHlpZvaTkH rSE3XCEnaIeacUAPDj98m/OkAvh2K1DSIY4Km8WRU3GjWRSO+EqbrKBZAZqcCszAeDnPg333RjTG En5zc7OxXPEnuMzVREBAHyxWySHy2tJrSg8R45fmJU+BT6KHTIxdEw+4R4kIfyqOziKCDkLCFiCO ohndO7E4w4qysAeXmofc+SHqK+u/shi5H1jm2pH6l4WO1HpUlUqilJFERNUUVSVS0hERIUFCUNUR BSU01S0sQBQ0CxNAVQV6FBD4hTlv94f9R9IJHFO3xTBa2KfvvLt//Iu0U2YG5JFVASoFTnOHfjbr 71BCQ94mX5AeaeSdXM+Qh7APySBRStFFDRSJRRQlFNFFBRRS0UU000U00lAUtJSU000UjE0JQUtF LReHtHE8j4E8XvLgHh+AuqJ6BPAybvCx/eBmCqwKJzeJbCvqir7ggO2WWcMMwMCCCCCWXMXFzHHD DCCCGGZmYjMFwWGGGGAgIjMzMMMwwzHHMDAzAwJnMDAzGWZJJ/bLjWuzIPXgHPWJ80S8AIRVMZBD iCiGKo4D+UWBYBVUllbKKCnUlDgT4AvucqchYQA+cBJ9SCeIzwovl1iKY1SNJ2FvCm5BwQKYEiAf IDGmmEdiAA80oPjhgcI+L5h0axqrijCA1YWlQm7aqfb6W1Rxwn7niAK42ib8z+J+vvd+7kcmUMKZ epoQ+30npuQrPpQpLDAww01AFp9gcABD8QVEoho7Vza+d+f6X6j8JEtemoKa6Ibruh77z9RHn8y1 URLgsD3PrJmRirCtLBsXxd3qgzmdMfF8V94Ps2IkVIbQ8IVaFPViG0fgh5GxUWMYNJIWNdDIENL0 PtdOXB0WKjBu0KfLusEJjE4k563FiKDvVWhis/pUuBQEa7ccAYF1YyBjIYOUOiEMsh5ighJhSKs0 qGgADQA2sBasAIhpliJSQpxjsvSRKEkMLcdxzJECQ426jzUhhYCWBlCSAgfbCBkS0XC66tnv5iFw qaGqBZSIjHGUpVUeagWwia0GhlZAxccGSVxM26qpBKSE+n2xHAADZAPWMB87O+gq7kYCsCN4DB9V YHKIZU+b2dSy2BUINAN0kZ0h+6I91g/h4/1Qv3PcTxPSeUhwDqeSuvQkEdRlpYVb6VipEHcKkfsD IkqDWwuGOxlGR6NFBCmSsjBY3TQVgMZapSQhuuXoXyTMsvUMkoZ3t0h5pv8D0JVzCepJhtTwMzUq iu0IFoQDBemsHNoV/YtqucGpBfH3NwMpSEzQSQrMkpDq6pZ2u1JFmDXmG5fMlb6MFJdbO+sEEGNm NV8o/3hWVSUhRyLcJA6zGD1+s8OYQduZGhU57a5DzSiOYvrt4PxgIeXQEBrYNAshC0MkITA6ha6f eUvQP6kUMJcweTJcuWMAuLA+LmSioIVFTWr7A5ke37InINTxiIWPaUJTAOoi+yShPskchKApIjkb osm6klRbJmYGiwZi2T0AChcKl0iHFopad09VvaHIPiF6qbrTIHIIXiNpQSWDiCp4l4imS/DEAVqZ 5GSzsrSbZssM5tojbnozT7xa0Wa8RsYNvG1UbPBAQn5rULUqR64dgdQN6/KDclBE96yIYBxxAXIn U4hU7EZQbkMDFx3nVJJSeuCSFKwJIkK2FhuNhyoZHE/c2D17jqIC1BVyCIHMHIKpejtTuWRj2Nwh j6IBiSH0GlHX/xgmNrsHUhtbORaBuB9H6QReDam18iuAGuVHkToOYgps08FGYeI1ge+UoU6vn4VV Rch7H6A7gerIKmYxlHIlSoBmhSoMDyH3AdNa32LZdQz6sUAfIdw2QHizHA/dHf24tKTrPkNdJ7/Q n2m+Y6D7SYA/zn2feOYAypnAqD2A6RKK2T0T/Hk+o0IOxLE7fg0B/wIAU1q2KfmZk0AcVDTjFjES rdnmjAEFEkV7UoNGTUC9BT/qwJwhyk/F2KQdfMrpH9yzSTEJAfN605+YLsKGy0A8AMqZuXhM3Jm5 J+OpOQP25ZM4PkeJiFU/of36UB3PvFTjpzMQKAQIkJeRT1jFOqnOR7vmPjGQkRUUchPxrB451T/0 VOYudVUaDnuD7sEiX7yOB1q6XU+b3SJP6X88DkhVRrt/EXx1R4klSeopnH3AbENi/XprQeocIIyp 8AWxWEO/f2yXTjDrXOqKo7zvDtzmj3OxcM1Q61UesC+iPwJWxQdADawUXcmaaA1/gWkBaGJPkC+S ePdOCth0H598PzE9xJ4JioVA82903ofcoY2uBPE1lX9xelgUMC0tpN1KTFIpTzESZKtWnT1rxS0+ iOt7zs+9H7wecKiXLI/QNZctCcuOxJqb5JbpFKQB8RyrTz/hHmeZ42AfqS0ipCQsR/CpKJBCUawz ASWWjtPF/UTWBIFHyIM5Px5bIgjf8GaDVY4W6HA5oqNvc1+k7/viIHVy8f+RntX9/H1T5LkPuTjH tT6p7iTsEPvJ7x3bYDC7faoEMBS88SeSYH8Nn0bDMffGHNH3+w7f+X0hz7uEk46I+k9R2wlz6jqN vsAFyv2FNnzENIB1LRbXKodD7hPIT7GMcvz0DSvgD0KK4IPNM6G12xEEcAHrgoFGCUoQlVzQkBHo ndoOgL3CeKJv8c53Lxe14vgqGqwHcmd1I7l3nmHcp7/3SMzKH6PTnDrHv0G+PlSZlYwxXPhXxhqL G1Dog6OdgVALIOfdLSHygN4HmzAG5zhRaruHI7R0PC1TGEJqtHE9o1MpB1jvV1i9IeE8z3ST5yG3 or58foO7yDo5DeOkP1Q0DIHmh29b4XhnR+AGLKuNzI7x3CQPuoocOherUUypRXsR1AvqmsQPEXsE /UUD1DsLz37ksEmVEySsEks2haksUJqQtE8AxicOs0AvoLwVyhkRNmwDtzguvJ1WdJ3gvEF94uYX khQQOscEza0aiL/nUHwhPCfKSdsPdGi84wcA+KYyHVDmOxblQ2gZBr6rG1LEAdedCuKq8h4Rucww PlIeU6RrEyReSom0TaG4GzvogyUiIlDwXGG8QuE6y5Hty5QL6O7SoXlwKifEfeDTzTSYckHYLkFq YDwebnxJonmtpWEiiXcittljFlJKkFKUmh3wWCzAkNALNCQnoy4aSjToXZTsC0zLgOE2JxPQWypZ IgykJCCkCAGd6GJoInuJOnrXqV7kL+pMYE9WvUg0xsgHUJ1urguNAym8TWMSzJRUOKPiOc9nvOoL wcwHEDMoeA6XQ+5M6PQDNuuV65jdPBfGcR+8TL+OBJ4o7pHxJws1kwhueBOfBeK3jtM3SfOw7pKk PEpQoZSd2Y0d8nd4yfIfF5mhJ+nwJVw9h4fBq6DWDtb3f3Q94pNHiknTIhE5+IcQ7iUiOxBMlbF1 AvmjkA1KFeoTJxANaaG7i+Jw3LALmWwDgB1uwxEoTLDEEERoV4mpXtemwEeWsXBxFUePADeL4nDZ z3pkW0Lx9SAL3Erh2Ls4i51kqMMkXxHiKISaFazRdgOVYJSxBohiUXy7wOaGxLUoBqNpgrYWHcIW Ic1DeHg5UgTsTSa+0VKqe8nmXGKCpJNUngKOyWHoNOMnxhsF13N4lQe8QNwlrwDkvMtoouNZHiC4 AdgbQWuoXYNwL3pWx2JoLEO4QzCfgA/kewfXP0gf6OOqL6z5zD+0of/4u5IpwoSEY6qOcA== --===============1726680944==--