From: Bjorn Munch Date: September 10 2010 9:54am Subject: bzr push into mysql-trunk-merge branch (bjorn.munch:3191 to 3193) List-Archive: http://lists.mysql.com/commits/117987 Message-Id: <201009100955.o8A9tZP3028434@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============2145766943==" --===============2145766943== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline 3193 Bjorn Munch 2010-09-10 [merge] upmerge from 5.5-merge modified: include/mysql.h include/mysql.h.pp libmysql/libmysql.c mysql-test/r/gis.result mysql-test/r/multi_update.result mysql-test/r/row.result mysql-test/r/select.result mysql-test/r/subselect.result mysql-test/r/subselect4.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/select.test mysql-test/t/subselect4.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 3192 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 3191 Alexander Nozdrin 2010-09-06 [merge] Auto-merge from mysql-5.5-merge. === modified file 'client/mysqltest.cc' --- a/client/mysqltest.cc 2010-08-27 12:17:32 +0000 +++ b/client/mysqltest.cc 2010-09-10 08:06:58 +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/lib/mtr_cases.pm' --- a/mysql-test/lib/mtr_cases.pm 2010-08-16 07:22:36 +0000 +++ b/mysql-test/lib/mtr_cases.pm 2010-09-01 14:02:56 +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:57:51 +0000 +++ b/mysql-test/mysql-test-run.pl 2010-09-01 14:02:56 +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-04-11 06:52:42 +0000 +++ b/mysql-test/r/gis.result 2010-09-06 09:54:44 +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:22:36 +0000 +++ b/mysql-test/r/mysqltest.result 2010-09-01 14:02:56 +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-04-16 11:42:34 +0000 +++ b/mysql-test/r/row.result 2010-09-09 12:46:13 +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.result' --- a/mysql-test/r/select.result 2010-08-25 19:00:38 +0000 +++ b/mysql-test/r/select.result 2010-09-09 15:00:33 +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/subselect.result' --- a/mysql-test/r/subselect.result 2010-07-16 21:00:50 +0000 +++ b/mysql-test/r/subselect.result 2010-09-10 08:06:58 +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/subselect4.result' --- a/mysql-test/r/subselect4.result 2010-08-12 14:08:21 +0000 +++ b/mysql-test/r/subselect4.result 2010-09-10 08:06:58 +0000 @@ -77,6 +77,92 @@ Note 1249 Select 2 was reduced during op CREATE VIEW v1 AS SELECT 1 LIKE ( 1 IN ( SELECT 1 ) ); CREATE VIEW v2 AS SELECT 1 LIKE '%' ESCAPE ( 1 IN ( SELECT 1 ) ); DROP VIEW v1, v2; +# +# Bug#51070: Query with a NOT IN subquery predicate returns a wrong +# result set +# +CREATE TABLE t1 ( a INT, b INT ); +INSERT INTO t1 VALUES ( 1, NULL ), ( 2, NULL ); +CREATE TABLE t2 ( c INT, d INT ); +INSERT INTO t2 VALUES ( NULL, 3 ), ( NULL, 4 ); +CREATE TABLE t3 ( e INT, f INT ); +INSERT INTO t3 VALUES ( NULL, NULL ), ( NULL, NULL ); +CREATE TABLE t4 ( a INT ); +INSERT INTO t4 VALUES (1), (2), (3); +CREATE TABLE t5 ( a INT ); +INSERT INTO t5 VALUES (NULL), (2); +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +a b +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL NULL NULL NULL NULL 2 Using where +2 DEPENDENT SUBQUERY t2 ALL NULL NULL NULL NULL 2 Using where +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE ( a, b ) IN ( SELECT c, d FROM t2 ) IS NULL; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS UNKNOWN; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE (( a, b ) NOT IN ( SELECT c, d FROM t2 )) IS UNKNOWN; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE 1 = 1 AND ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +a b +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +a b +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +c d +EXPLAIN +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +e f +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +c d +SELECT * FROM t1 WHERE ( a, b ) NOT IN +( SELECT c, d FROM t2 WHERE c = 1 AND c <> 1 ); +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE b NOT IN ( SELECT c FROM t2 WHERE c = 1 ); +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE NULL NOT IN ( SELECT c FROM t2 WHERE c = 1 AND c <> 1 ); +a b +1 NULL +2 NULL +DROP TABLE t1, t2, t3, t4, t5; # # End of 5.1 tests. # === 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:22:36 +0000 +++ b/mysql-test/t/mysqltest.test 2010-09-01 14:02:56 +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/select.test' --- a/mysql-test/t/select.test 2010-07-15 13:47:50 +0000 +++ b/mysql-test/t/select.test 2010-09-09 15:00:33 +0000 @@ -3772,11 +3772,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/t/subselect4.test' --- a/mysql-test/t/subselect4.test 2010-08-12 14:08:21 +0000 +++ b/mysql-test/t/subselect4.test 2010-09-10 08:06:58 +0000 @@ -74,6 +74,68 @@ CREATE VIEW v1 AS SELECT 1 LIKE ( 1 IN ( CREATE VIEW v2 AS SELECT 1 LIKE '%' ESCAPE ( 1 IN ( SELECT 1 ) ); DROP VIEW v1, v2; +--echo # +--echo # Bug#51070: Query with a NOT IN subquery predicate returns a wrong +--echo # result set +--echo # +CREATE TABLE t1 ( a INT, b INT ); +INSERT INTO t1 VALUES ( 1, NULL ), ( 2, NULL ); + +CREATE TABLE t2 ( c INT, d INT ); +INSERT INTO t2 VALUES ( NULL, 3 ), ( NULL, 4 ); + +CREATE TABLE t3 ( e INT, f INT ); +INSERT INTO t3 VALUES ( NULL, NULL ), ( NULL, NULL ); + +CREATE TABLE t4 ( a INT ); +INSERT INTO t4 VALUES (1), (2), (3); + +CREATE TABLE t5 ( a INT ); +INSERT INTO t5 VALUES (NULL), (2); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); + +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS UNKNOWN; +SELECT * FROM t1 WHERE (( a, b ) NOT IN ( SELECT c, d FROM t2 )) IS UNKNOWN; + +SELECT * FROM t1 WHERE 1 = 1 AND ( a, b ) NOT IN ( SELECT c, d FROM t2 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); + +SELECT * FROM t1 WHERE ( a, b ) NOT IN + ( SELECT c, d FROM t2 WHERE c = 1 AND c <> 1 ); + +SELECT * FROM t1 WHERE b NOT IN ( SELECT c FROM t2 WHERE c = 1 ); + +SELECT * FROM t1 WHERE NULL NOT IN ( SELECT c FROM t2 WHERE c = 1 AND c <> 1 ); + +DROP TABLE t1, t2, t3, t4, t5; + --echo # --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:36:17 +0000 +++ b/sql/item.cc 2010-09-10 08:06:58 +0000 @@ -7850,9 +7850,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:17:24 +0000 +++ b/sql/item_cmpfunc.cc 2010-09-10 08:06:58 +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-07-23 17:08:41 +0000 +++ b/sql/item_subselect.cc 2010-09-10 08:06:58 +0000 @@ -55,7 +55,7 @@ Item_subselect::Item_subselect(): item value is NULL if select_subselect not changed this value (i.e. some rows will be found returned) */ - null_value= 1; + null_value= TRUE; } @@ -435,9 +435,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; } @@ -574,7 +574,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() @@ -582,7 +585,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 @@ -597,7 +600,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 @@ -611,7 +614,7 @@ String *Item_singlerow_subselect::val_st { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_str(str); } else @@ -626,7 +629,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 @@ -641,7 +644,7 @@ bool Item_singlerow_subselect::val_bool( { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_bool(); } else @@ -659,7 +662,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 value= 0; DBUG_VOID_RETURN; @@ -822,15 +825,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; } @@ -843,15 +845,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; } @@ -864,16 +865,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); @@ -884,20 +884,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; } @@ -908,16 +902,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:22:36 +0000 +++ b/tests/mysql_client_test.c 2010-09-10 08:06:58 +0000 @@ -18937,6 +18937,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. @@ -19378,6 +19479,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 } }; --===============2145766943== 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-tr/ # testament_sha1: 19a84d1c51ec46769bf7856536dd2b663ce71f07 # timestamp: 2010-09-10 11:55:35 +0200 # source_branch: file:///home/bm136801/my/mtr-tr/ # base_revision_id: alik@stripped # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWf+QIs8Af7N/gH/yFQF99/// f+//7/////5glZ96t73ODo133jx6w22i9fefbq50CnvgkqvQA+NfbU+x9dG9N6NPrUX3s57H3dnt e8XuPt3QdSjjZoljcHMx977ODPvofXUqqU6rbWtoTO++r3esfW7ldBRuM6NDuu4m7fC93rHQoKOm TppxeO3fYH1oNB60Z4+OD09BppEN9wd31fO10PQlfL04obajHztdoBoUFDG53JQ+gDPYGbxz0ADo APbwd0XYAADG83pvvRkCdaKpZqqrasbAprba2zV89Azo08h2PuPvgAfVnw8Hd5QXRtpyB5eA1zr3 LV0m76NewyCM+XH16PTvW++776y1nW7SzcUAPt4ClB61sagBS5tUKVQHbNtE01E2YC1vut0XPdrr EWwNFmWwaVKmqlq2K1LTbe+rPeZs2xkSg8HbtiTbaWdwNBSVOktSABWRqgDCUICaABACZBMEJoJi U3opsmp4U0eo0A0yB+qG1AlAgAgiaIU9ACZCNU/VNPKaDQAAyDJkBgRkDTJoIlFNNTU8mptMp5Jk 2oaeoAeoAAB6gAAAACTSiEJpDTBMiYGkGgmhM0yDFPTQCaYTIaNNANAikIJkyAAIaACaEZGhNTCp 7Ik/Sg9E/VNlPKND0GmgVJEBATIJgQ0E00U/UyMjRpNNTTamnqPUaZPap6jQ2moMR6uRNyp/bJQj fRD1qRKKiWnhj9FLlSKP8zUIfMb+44P/UP6E0CaSZkcwofsIfuNs0/+ptbmCf4J/BP4J/yYEpG5I Mj+7fwf5ukn/JQ1D/6/JQqM+Xs+1zP4BDQnyoQrO35uTBCdUU+T96qzm6PQP7/zYIIp/hkMFFejK f8th+s/X+p2W/d+rJ9+06u6nU9fwN4MkCmrMsQ1IuL3kjVvFlZSbqVZ4Gq1lUoMla1hpuHugiG1Q 88MIHWyfixp+Fn73Vf6HZ5jTeaop1da0n88m93W5np9emOXvvo2WZBRQdrtiezABvYOCyLCooNCD CEMIs6Kaht4a73BAT8/B3/nzi5fP8/6eOT3Pe/sS/yLBv6KvmdroMeireedpif/D6rbFNSClaf/Y PdXFqGZAjUkLVgSKsCZ7EqOPsP8jCmGGzY7cNYLQj4G4vgj4jnUrrj/QgRrG+wdwNsFW7ea8fmou /kbqpVLWqRFvOHEnvoVE1qkMe26lsdz/mznkHK91irN8CJ1JdleYNFonOO71kzyiqhkyeLFxyNob XMf2h7/5QY3fH3P9NHfSTECoQdunUkFUhnqvmHp8vx90mKytWzzn2elsKXrabDNjAWGjiVzrTBe1 v4ZtS9WsN1qi1H8YFlJu0b5mBNcfjb75V7f99W2v6k3WOtDMZTmMcr/7UdARNRIGdbev0egxroXP owZMnAwbhyGZWFJWfYS73PgrG9zga+Pj5Ll9+l/I6LX+P8io3sPRcDhLjUfT7/Ik7182QYljD8KQ vXVPdShdbUaOODiUxU/mKh1hgvdQ7/ZZOgK0DvIBTQQqJm8P0wtMOlkc5fGPjpv5n6D5EeSOfey5 qdLMm5t517m9XOOrdZIlnuKYlxuq6GcU2qIsg4FdEmTzmSxpO7Bulby3N6cs8d2OIS+TiC5zOTX2 cHn1H65M8helwqqqqr4db+p0+1T5NpfH04ar/Y/Dnb17BiEWB5PHjlOYLpBeW78fy8rdG8WtbjVV bjLWta+HTK6CL4PUUiJ2n0a4ah3yvuH+0ExUiog3yPk2Bv8z9T4SJiAgeK9OzOUBsGDeouPVZonq cIaDrmk7nTNmc2bXb1a7zUr3OyRw0SWRAzFAHCzFUhw8IiiyyBlrpC1URGltRHeKI0xBIshUiQEY 6QFi4YHLRIiOEIGtWFEEgkdMQijAAlbVWN4czj0FB1o1dB5T6HfRnLJ7qJV1U5TLaPBciECSudAj GZRYfT7OvXDDTeZAAJ7ndfGPPY5wp+Rvy73t5c/144006epiPPTxOCNQ6sQ63ABTsM6XTtFG0JES CZAMUl9ZpVFBlMSRMoAeox1r/LZoVU3nBRRVLbhRnmDlaMC7B4yPIDI5Wmhor9lSAOPA+UEKGXxD hsW7EYzRLezSljCLZITWrBrGnfbNZSybOUFzEcW095N58ERACl8EkTQ6RwISbve7m2psJqbE7WmA 5VsE55H1R89CWCrWoyKKgNWylj3iycjnEPwOkRA9a0tcOvpl+V9Ks1GRRUBssp3EC6dHcliVFX27 5DvcW7hr2XyymS5Os0Pf2o3clpE5Huh9aFI6J7zzVSkB19fvtw+7F+TVxq1L8tKoxvJA9ZAgCwQw /7of4oAfUkhO5FJOtk5afbwbh8Pw4xFk+ZDiRhFgKEBYApwFWUIQQLEiTKEOBk6zmZTf/Tp3tUz9 fuANBEnq9Gglzcfj+nF4vUuussyZOTc4qcreX5cBHKY5+X16+arf1JCiiim/mdgRGUCJI+B7nuPP vR76lVGShuZrHwvOKj0O5ivq//cicilAVQiMPNAD92hXss9Pk+kxLTE7yw7q2ghyY2YPH8Gx7Xyn IAnAGBsiirVVfoMnfPDTY7RLXlx5G4zTGXzAGmmjbEtaNb6TY0JAzB6duY/bJLofDXI8OXLX927w /z7gnk5+37kBf9yIP1JzDEVgsIpICwUEYRYSkILFRgLIsBGEVGREFFYxRRFEGIKoiIqMUYqCKxIL BRIyKKKgiqCIIiiKiwEWMIKRWMIosBQEGRVAUgsGJFFFRCMRjIg+kAyEZCB/cAA/s7P067qi7bFl f51PX874IjEW1uhhkkQsFRRGDERUQVEEBAVQFUUgsFgpAX4SBoB3pPP8YgF0rv8aH7IS7ylDsXvq BXZbJDI6zB2QdZKnUpr9DEwXLdLNHvSl0bhwLk8kkPqJ4XSNikJkzs5iFyLRBPVEiYPWwy1CSSIK E4S5ohEcalkBEks4RJS2QjRogyraq0KE8RkbMmQUsO2MkzV8pcWymWbamkuLDx5Iw8IkgEk9tcLI tdEoTnS6PK5sSrN7xJ4izlTPC3QMYmTVQGqW4KlSU8Y8lyNrUcztmFbOJrF10sMzLZSKkmck7KqN LBTRNDQaxztIbNyHSo36BmYrqrVQMDh3EBZQN5ejRNXKJarlhjjzBJJGzC5ng8iepTFCmGKGSxwh ak8X1mbrrWqsPRZLFFBpKMs3PC8KsyZtcnCJknELbkXqm0yUt0qjatdFJCTXRMYRwMoNkdlnj+9D S1N4IVSrYVaErpehDClmQzPry2MqbZPqkTEtCTpdviEY2IYeB6bF2+aO7FdwX3Y3DhXpjEZy4rFm MllgwS/aiQjPBlt/lgqbvZp8uBIIIkeyA/KmkOpBI5PhDU43iJ0jQeSh2wonJyXRo9LF5SDKCSQJ tyG+mTfvc5vvQL/OHbn18OyKNjz07Qu0cQubPmTxgWQMPoGvHcjp21poo2UcKM2lK3KltODFwYqk CdLnJ7Mzw8Mvk8acqyGYdFRJJCaC4amtV9gL0gLsgcMWeAjaCQ1NoIjw0cBFghoImBRd3PhswiG0 TEmKJIHiyQQYW80XnkDmiuXOESRhEmKHV3Eiz5xXYVCUyyzLKvewLyosx4PBkhaocpmOeLhGZod6 FYNABAUpj1eB9MfKPgHoWdLKS9nmG4PnypWq6ijmowP1YFpmp/Nt8HqeY9bfZ7G56qT7XOvJX879 D+Sjj8asqptvS2MxNrF/fv4rn+KP1/F6pG3/E3bC83aWoJJNT8evNRVUVfyPxC49wQfBVVbHgU+0 exRLDzlqrqFz093rcV+xn0njH8YLo6A6IiFT/XjZN1mguIMhA6SDSYFgp4Hh87hDHFDqKx+HTzys OkefCaQ/qQnE849hVTmbXA6sprTFhYu9jeHJO9+lZE7p93Dx1/VtrePW3c8DY6Q+sKmdA7tfu0tD p94EpK+0TIzMCZ3bB5y8OKafxaNVSqqm1q4EjnPDE/yfOsn2+lo9EeTdD6kpJ8XKzj21Djnq6lo6 KkuqV2zu7jNsb2vd4joPYfb7Vuc21E+QpAoGAp5BGKqKKB1UeI8x7/X7Cjc8Cnr9ZnrQ3bJ/56cb TvBL0a6i2IvlxYVOrrxyLGLxoj3wSwoIhYF6QQh8Z3FOTQiNc4cvVi8d+kd6FGYeT9B7orWOjk8V /tONlFNYzksPJH/t9YoSZQVh9vmqkifpmdj7eR6bSf/R/W1NgiYErYDNNu+yt25c3j1+VZvEQojQ xLFEFUkKwvOVPZjY/UdCcDxRSR8W7uz0X7eDn21FKKoQZlXWP0mSJ5y+Jm5Ajp9I22HpB/FGIfet Sp+tYR50WuHJlnKSWZoM6THLsIvzLSvYOPAnPaaABY8vAUY4lRR83TG3qOWQTjgLCboEYVCcQNmU c0+baD5uZvqZl7eNpOFX/t1r90AdzkjqiZvZR3FiG6MuoWwx22OTNYbS+dUoqk5KUET9xCAQMKIl wuzUGR9Mjd/oZSLA6EOKK6k4G37/gmz6f9M75MGD1k7NGZIiBavhh1NccVMjyIaYjnMsRJN/XA/7 usdVsZ9P8DcS0vjJeQnNe3E9Q3oElVZDUnL36Po4418TtDEubh8Su0Zmbr1OVZtwu4Z4JNy7EXcJ K0gh7L2Xx9BbDE/JwxXG5chKDQvtIq9O/HfP/0kXyaWrGbnqadpdXipvUaKkdxEqksKjx3eTz4zE ZSZ8Lx5wFZK7v3ztjVgmG6ERI78lpZZsRzUW4elpBY+F8CuP5JUB5MDN+rO/J8HA2tR7yMFVRIKy YNX0Yh932HefL6xUPzd9rK1e7XYdkARHgz9mUXeZBIKcYNIUfycNJnpyYZ+9w/boUk5Aih7S9Tb3 DL56YAvSKMVBHuKqclEg/RfrnuO5ytJZfx844MdOG+M2rpK2MRXW33WkdZI/YgCJPHUmKk8puYO9 flLwpQTmuvFUkepF67lqCBBufTxJrJSP8zackvOq4S1dbfHQCAEcvAtsLGYxwaT5njCXg0pStSI8 PO5d/zHiVmnR4ddf2ts68M8yn7WIRz6AIgNxHFqv/Aifynwq9pBWrmI91+vD2hq1+CC6s8KF1hcf o0hanAxY75P1jgxIYXUVlpznMvqHVq3K7kU/Hwu0dnpMldWWfWxUSklyOR4tDbBoqlxgu08BPMeM bHwNymKUQwTFTmriqTNikXZJZJcwH2xlVNAyBoCGDUTJkpSlOOodSHiKZqxgz+NpIe4xYV57Oe21 LSyR9pwOZHauwQBErQtvuVwxBSK/5je0acTSl1bvToxaUe3TLuqZ04HlEWu57q0fivBC0SdGssPa mJOxFbksTVt98cRqg17mRR3cINM65hZfkxIdt/dxkYmH/EYpPzw/ck8j6T9kHuAqDGgeoHd7d2J+ h4bdj29Y9g5cynMV966L5Itz/GY+ZRTa5MGl5nha0VmpJdyoNsoketQzv0qfbDQJ9ELMC7lfm9LR UZU44zukJA0pZtFSsmbSW6650apVM8aCWBeHriQdVOQ3xPjaQX7kIn7k8ksTgn6J/Yn9qfvTrxMV 3QRr2cZhd+KSYf8I5H+bX379uQui+BeyT0V5SG8MslaGo3mjtO0yBkq81pokbTDzOXbqknFg3DdX e4bWkUnQ2qslVKiu0lnA2dGoD2P+B/Nk8ncPmPmwdgXNzoGDQ+77Cdwf/If03Zs2Zxfo1MnU5XM6 TADufcT8PBPVVxOomQ0JAwSRn5jqwUK1S8PHz3PLnSqmabqikVVU6pEFzVz8SVy2Hc/I49lkifdq l211bdHG8tM2ttLbVaW+WSBxOzweRsXXc1LHQp3V3TdsfOwpSSy6QfmPX/hzue9oTFHXx5xhaV+s 3IVrK7K1f4892i/VfEjeJmuaTntfC3k18viK1ash/2l5jJMomHT7flD1rHb/C1JWXxqfy/CVccWz grQehQnZ33nDezVLMFyZtcPXYcUlxuzUzcziZlYjxbaRVq71c6N1VePsMegbEUcgIgn6r+W2fLft e/ZyNGHLZGmzJxOFJ8+ZvzZN26+UZMnTfvY/xIkKLDCpP4nOCUkwhAFIpJAD2FsJ+yFIqKiCxVir GfuP3lwLFFVVT3xiAh9AwKDBRcE/PruMgI72SpNwksKMH4LFP6yw+xQ6Poc1/XtY3n4J/D+V8Qbf r8+H6w18AuMQJqG2FWIAykCmshFkKgff/JjzJIjIfc3Otuv2tExpH5uaDO+frCqIyi/pMKQn7QDS kD+AJ8yQnQ8DQsBQPUhYh+tUr/aOHMb/6iEUUFBUCZ9UjQ92I8+/M8kVSjdDV72/n+nzB35Lw7MX JmMU/QAfS/h+8mBFRVACMLpn9kDs4/WpkvqUPCLz+Ysw/5i+BeZVEVUgSOJ+xKDbcViJkhyVBdAy +mlth/+ti8I2p/dRV9xyh/apYlwdGZVOTmVeSo6mp+0turRvqIETBluQfGLr7ui2qrfxv7WB0KKo XwLRjY4LwsqOo/Y8X7ynnAQQ/gMYDggL81tjULEeQU78tm3wbXQgeL4RwcfVikUd6mp1vk/e3MWL uqq/FW1oiZLPZwetJMHElOzsct+q13zXG7f4tmDi1SlPnWOh0OuzbmWU3Og/FsrUAPZCxG/lT+fM P7z5sqKId6AVRyVFLbIn7OFKVKn9Q/a65hX86epB5RSa/kn++EoP2t0tcnjN2+pKUKmhHShRFSVJ QVJQfIiiSh9wfdJjMJjAMAiqQJnXtAsbuLl04rJ4rdWoVid1qjNrdGkchkSpnCBlqLEriIbIU7Oo zZs7BkbzOJIyI4CTG8YUJJRDGjjRGzmVd4XHXqF5DvFhgzRhkgOyAfjHI0xSSOQvAo+Q8Zz7HSGq ackdsmvVOOfXwdFxjKShOh0Jku2yV6Ax3kYyMNNyNUjcGUwqSNChejaLgqFaoYgXrcDEABajuCOC bW2xyExsjHgmWs0GMhSNHSpHB9lsITJKIUIonHcatsTkSPKSGDFJhx5ybCck1PhsTSJkuoOUaTRu TjJaBcOQxNKtY+CoUEsSa1KMAmJC7jI6t6uLY4oYcAkZAazblHULiBijRE0zmlk6TaR0QmSGomIK k0a3kvJeJBKbNuH+reZOtc0m4qOo4vlDtOjDaEOf16WVERbfX0b1od1zfHP9+nG0qxOzjt35ZD3u tuhDT9TnWH7JWiHqJ0IXbkEO2T3s9OrHVyuI9rvgc7s6aqnS4tALK1ZLeUoRuivMRZZbOuqd6XiT LQsDYejtQ81Bz/4iXKeeYiAwgaq9C1xcdL0SlmFyUlhMSaEzJmE0k0xpjOF1A3pC2gyMSRBKWgCE pZIMQS1gJGSkIwLCEEsJSShEkkYEsIUJQJGQBkJASQglFRKWKyTAEwTfLx26O46tm547ZjwMecYW KfHgtQcRIrI4zOCM7mQjKEg76Q4E9MjWdPMd+nGUszYMxgSSQrWNBnMrrygidGdEtsrJEiwtamgw zSEZjQfApXZXsPxD8Qzfh8j/T7qf7oEF9/p6F54W0tttJbZbS22rSW0lttpbbaW0ltttttttCHDG MFtPWfp8f2PPzY3btwW0LbLbLb2eTo00XtC3WW2W2W2W0ElAz8JyPv8gTbhIlRrJeZ36gfqfzhL3 DgP433fSmdCEIU9IfcxFtSNj7YCtOcjyb8NlO+uqZNzDMxDX/W/kgo+u38ctEnei0V4F909R7dsz eghf8ZYQS3sU/qkRImJA+4PhZ+ge0UA7GBvay8BTqff1C0vnSPLe4ENVswd23U8QwD5hECBF6oEA ExApJvQ1SGd+cQ3s1Zkaw1dyQwkDg7JDehuxriErIVA3sDDs70K8N1myYdUUJo64pFk1dmTbWkU2 ZUwmWbnNpMYsIpoyBsmrJgZNEkKwm5mXCYQNdKScBJlAwzRITZNzCYVA1XBkYcKEx5WaqoiBREwL iSfRyF/5DKF1VQS2ipYQa6IjIgjMog4DoGJ5WcoCes5BVCQgk7bbmdaYXlsNkwUKxSS211mBGi7K IyIQN6gwDSxqG4oSgBIoSLFqnMS5UrZlaS0kvYMKJR4KyRcigtLBSSZSVE4rBYjF9d8YzGMQsJSp KJF0VdUEWkokhS70muESRsURglSCqEhRKSQqiIrEkw33Zh0LZkz6foiSgoqXsjCKiAykphdZQjBi chSYJJfTK2KFEUCSNsSGK8IWJCIMZRJqiIBCoIcmiQkwFnTmr6bKzkBdbSEpNtoS0hvXu2a72DAm qcGkhgWDDGb7eYIqoimC44y0GsGUgP/L/d/InFlULhnDWV3d02YyqJICoyIJRROhaVoWoAWRpKRb JixcVTINGWsRmslSbDHBldZici077NWNsM06xZY27pJGjMO7JuSYsAMJUjSRivITM33mdE1JoNHu ZZ6ayRWhkZiVE/caoVRMOyL5NJm8f1+3U7z32Fo+8RMvpgPKyLMcORfms2SY0FkqCpRM1GKccxKg reFZQi0FdCMCEvLK9dFFMliSrwBUjJcL0zPDJDKzYZcjQpQdEChVEKgUQYGCSiXIsy9KMAuJezKu DV26cHfvvqbhGVRXOBeADMhF4EWwOTXftWYmekRCpcyHBU3LghFJ5G2w7q7o03fSCaiejkSVmEyw EAkBQGhNbZLIFtWrJbaNVL7rTUXX4Mg/mEqCCkwRBV52jg51iLdHRsopxbqx/NHQWUItWtxyIgEm BGk3SKQLlSEoRYPInBFCggOAaZEBgQb11h5hyTGZFL5tt4nSydJpxvnfOWpZxprVNrFccVIoKySg ugLpCtwwFZjIBZjiJSaKhSEa1mJDIgXNEjB25vRo3ZSr8SMgxKmA2OaMLK5zJMpEFWMq6ANFyq5g tEBmDCkTOTZaRIpgtERsYpIZo2La5aiXUtBbEbSKBWXTKoMi2ssCsWigwV2wXE0s5h0gXZwyWSCZ htmdhCbmgIkCoCJUztEhuguEZcK8dKisi2D/QOLodCat5ooBycOL0M5MM8hzTgHSjzJYuJSOndsD dZMC7rMmLMsQSRyjVC5mxUabYLkeDwclcl+GJXOdCdFjQpgoZJHNhvqIQRYtxWF6Jc37NdB0j0Np kz0w0CrMIHepPBopUPcUVarhdwY6pjM96ZL72w36NZIVJDB9gZN2OrZrhGyxia9XAU4uWLabOJrP hmHW8hOAkq+9ZbrS4UjYJ4/oJpAP2G+mVHy9Cxyet6xRHDh/MMdT5CctGH0A7zr45eUSIgnpMpyJ PAjyIyO41Olggh5ta4EEBVMFmo/rezLHEaBWs1IvuSK84vCNhk7Yjc1g57oSJ2tkLQx4BCxixOSh ODCQqE0QNNaZvHENN1gb8KBJNIAeGWrMCgTVTnLti5vyQxWqSuoVizXddzoza2Bq6qw3uiKV0Zsz OKTTGwnUKG4vSI+bAwYrrRlntqq6EnLlzFUYVl5pbdCEMb+HG3Z/WIYf2AwxlMCbgHgCgb7V3pnT eqZADXQDeMCkLUTVlU4Yj9kSJcFUTHMVBc0v/iIpPSmr0w3Y4SaUUSMPREQ1SXzzt+tUNKSRqklS KRQokUSSIs27IuRzCoSeClz5+HZSYBg+bfIYk49CZvH4m/XBiHO904LDdCSseMnNHQFJVKhGrcuk WRkFVbgjJugyHvYoFe3THP0sF7nATYjhEw2qXqaU54cFn1JIfLnoQDTXCrscWzvSUvoiIGcQDNMS bmAmOCzrJEawHdYkoKwYpDsG2TZmkbKVaAsRoTWDJRqEkft6+Y+Gnat1HQOBFQEHJjIIa7sZmRYn YThLNTbEzg+Euhskuy8QmEQFUYSoCWbzzLHI4PCs32G9UI4KhQsMSkwwC6cjKJjq45gaRZTzPCIF ej2KojAJcva1UollkZBD55ecmtlyZhkrSHOzHV9q8m2TIjbUS6VowlDfJHmFVFmHX0RECYCzmJay ObPZ+7adl7h4XPteVvXxKs49eupa7no1qNVrc3UbCSeUD51bN60jV4HrXFub4yq3h4pe89NamjgX GeDa5so0btl2kzlV4zwup0XfBnd9S4M54Z41i63Nsl7zZWyiIDbND6oVAkKXPuE8ohxlVPArLzYy 7xsRu1pYjLlrv36RtjOSjjsXmBjCZo5srphiCZ5dIEEUveYApYueckX2CEnSyIimQYQSCRgA4JF/ UFqFwoTLrcao6A55YuXfDF+pGHTyic2TmWkne8EropCKyW6kD2SSJY0iXGS4xyGVVUyIV3WEsusx kZ8C0EiFYLQvFYUUvokb4Q+8/M3AdBBQzvQSdrplej0tSwgl0mTBTEaJUAZkTUoaDgqNsoDhG1Ds iIG05IiBb75GBmWYDE8B480qldLfkyrgrySIgqHkEsH18EvVsMJmSBZE4BLsXDRLQlUjiDdSwnhP x/FPBquCsGhvfyLJ1yJ4LIOUaaiioV1+oYuRzLOSxzdddruX4LVxZXpe5OLESTm1UTgQoYRhPcgt yyWUqeK4EKRKborSEg9xx1Iajp4VM4uYgsqCzFPH+1cihm6RQHreNboLvioIPUqvCkPXHaIGCLzn Q5JwQkYhEBriGpQnPQnbUERZpRg+iIqGClowluPftDA4jZj3OT3L8hjeq4X6T4EQmMW8fe8eRSYq W4LvgSPVz0e9Sn2AWO1Hg+FATetiSRYFhzYC3IQ27IIWGQoe58z+nvb4DZ4O1NYxysPy++aMM97F +UYSXjJrOx0TFEkXuex8E8icAmFUWbKgxkomaulY4ZshYNlZPwynGu44qDJZFuAVUg1VCvQo24uP Bt17HfV25yNWXQ+Tr2NFNtlhCbcJzVCYrEiFQvl4uTNqiQThloQFPYTuECG8NheRvLrxsgkWFxgV Q5M80DJSVZrIpQwXPmFDdcKaLfLg+hIz6gI5ucmBNBah8jRq421EsT6OsC4gY4LSuTcnttx7pwfT 7OCp2nACL+CIAloOQjs5KdnROXZrUh69k+rTD2EKeEDRMXPY8HLeTDLHSytMDTDyndbUhM+g999+ yeFzhm8AEiICCcUxDEIm2WSRLYCj9DdJknlDYFLLaiQbAN1OCD9ybr+KvRwEvE+89FCstu2IcZrY +10npuTsTS0yicn5A2QzqTphwTMongfUBmex58je/u2M9rBzOSChkheKJk6Ib7OiCROpr4aWA541 R8pvbtcFRRIUWcMBQCufFIgsqGJClkXo2D25AG6gZK5ScAa4UEmCQlUewREd4ORZo826YamfKfg7 DGl1xoHI5R3k8FkXBwmnOiz8Q/YAHoIgf1SDsrErFnU16IXJgEc56l8LwDT6CJoZCihFLb0QGTwm lAIywCQDlmegYCvmhcZQZ1fvtjlbG6mT5ZdJHCkNVCPNSOqpIM4pVrIRJF5jEBChkKCCqZqrioZR gX2GHKS4W2vs1DEYUxIt1rYDAjB7WxtQiXS9JfDH2fUz5P2/iWDUuN9ZLncb5XysRvCrKIhBxyQ7 npEuAlRPWUSzDkgEqQAm4XZ22fCjBKiOFSD8LSnPPAli0P1tKyQ3J6V15gL4OL/mlxmXvCgxgxPv RE4cUEstMFnKzPNBz0yHHkaYA4IU3VEhKKiUPHHk9SRDSHcpDLm5kKCiOq2YniEShUbaEk9iw/mZ /AEHL7XS5jStZ1lA8Nk2KCSFCpJBIUUhZOVWUSEMlASYSMDNLskk4pQsmgZvcshVAxcQnZ1s3OeV olsUzM03bjMKecDUU0pWXFYzzK3OsrM4Fra+SGy9kv5OYGaEcpZXkJZlRZvZcpYELmw9gcuRq+i9 1VponTxsEqOJNEmiKhJBgQlPB10kfy2Sp1boAdBGNJ7FvK1FU2VL7BD5CKIYJYr14gUTaiPuYOkh EXsVCi5/khf28rf2tj0KeEl0hKMIILokNb+AEPz4MZbxsJlxfJynNqrSuwsJbTMg55Ae94mkTX2E +pD1JcglSw2sZxfDwS9zYhLc6N0VXYkwoUJK0loP5SEsIofc8U+hNEjCoLkRFYMeBiooplnVHs2T 1wsW4J+PWSPZgnTCSE/mCHlB5cYbSptlSXOLzmmbIxDDbXaDcRdUhoCBMOabN8xsuoZkbOBcUMQ0 b+Y/sdg3YIgvoLcAQMpSetClSQUvLRNBGc3K8OwcWO5VjikLNhB24LvaySbWvim9gkBEC6cyi7lD WwuHQTM0IFALrjMMmNMXjRkXKcrzEuvrUnKzJyGMFbWpEmKJOBNEnJdS4NSDJkug3GoMXcLFAl5U mKmPNeweJIpslr44NeUINgp2cWJnLbVDBL7RE+0E+y8LZZ3DmBMO6gJs5euqn1Fa8noKNNTbz7Mj gduvFXWxe/sdTPepsK3pcqbCZIkaEySPT1CZj44mTF5uMHLES0lS0hqFB6hs3KQtW0UE0ZEu/kL0 oqOiRC1iseYWEzsInUENwm8EyKR5Y2mZk5PBNDxUO8LTNQOz1oahM7EMXEXVa/QSAwHtqY3S7Eh7 h0GSeejrmBj2wZHAknZ6/kJfaRfaRVqtLcwHxdR0L/n5gUYFzI1+c09ECxdyhkRqRsMyaBqXEbVN u5lwAh3qPk9+eViDX8kbh2iYgFi9V8xgDmCeq577Rk23Li9fV0P3HIlyky1tRb80pS2IeS0JWo0I 35F+mC108A0PWHWdvSLsC6i7jwUEK8yeOh4AQQBtR3dHTtcl5UUaoTUkeGVWbrui1WvEHoqtnxa7 KWqZeTUZySyHxqPvADwAehCpRkFrKMi0oUtE2ImCoookZnTBVoOsvaPv8Q5KJNBJdiOCDpREQdBH 2ASi3OLEpFJ9UfJkKWEp6AsP6BlGstoqe0KpXdWphRRbBjCcckKcA036DDY2Dijvdt5ddpvoIyZR ATJ6wrhgHOz4czfxwheS7kzTEOEEdNGQobQShiRSmRJ23Inxxw9G3ELvU5VJyBIdTN7kgSKLk+yx TnAIYpsUma/Ak5+yoCUE5yvRM8gI3g8dZFOoxzbhKwgP4rRJbUk25JhE6ldFEFTwAsie8FSMnJGI BKrLvmcsDZLEXCQsts9hLAcTsCZq/bS8DaviCvSbKlScnwYsrG6Vq0MZIqYzos+m9sOWOTZeU5IX z1j0ji0LpUrQpbp+zkHuKlEBKx0W+0ODgJd9n5yLnK95ZHVQ22qncTY5JAzqm7wCAaJTBoOPKs2T 0PIkf1t4tsmdBfRQdECbUs0Yok5BIEJ18DhEClHREfs7RbnBAhM/RjuOOAzWDg/JBHlNbo+jIKHL Xye6yQSiclSCEE8DsWQLs04SPcEPm3UiSCKZCrj5+ZAB1DlXIDJlOzr3D7URkO1RdTQ7hE9zAGIN 4qQr05ZJb2e2GphKpi2wutbus4qrYxdbPtQ7HW3lMGZmocwSA/ggn5pQ7FnMmO1CVwt0VOFrMrzR ZlAYn4GoCo6q6K16F0e5HCH4e9YyTOiwon8RPOpbOzyiIz+rsK55UXsYrZyN+aBKPHku0l5LtyRj EkQMEITK5mIqlh8U6MEXlmR8JzJEsoaKYFEkbG8GNcLXhAZpqpy5NEwTSjQIOscxQER6xOFQ7CMe acNyJujapaG3LXEx2zJlfCzTlF4YKDqiIHQkw8H3FjNCptBMmzPovfwt6rW4M1M3E3t0Te3m3vOh 3Tm1kTFi2tC1oOOLAS03BdblxPKIqCMdedud93c4OXKMdbJBc2wcOZFuLb0iBhBJDkFC5huXseBt kyRMhzg3BPdivdLHYB+gnGlg7Z7XkFpn8T5d+PZ+SxYvxIu0Kx5EGyNEVS2G0jVgymJjNzotlHUa 8ID7oEB5ApSl5QLqlEiUqtX1QbBBO/co9uAPv1AfCrjoKh49SnUQo2AFyO1M43r8LUMUjPufkDSe 4d3YDeCRO5H4nR4C3Dv7he1dbxbj7gGNA9Q7TVpOupJSJHb5Eu2q+lK/aeuN+CblsvhR37V9ydzn O2JHb2M5uDaHOjsIhYO7RPtHQ54BeyENkeJnjZ8HjcieTeohiKOKTvQA+zd7nKzRgs4xfXEx0h7o XWBTBd0FpYqrMlBOU4xcnnuhkhL0oIXEmCCrJx3ICBEk0sUECUJqiy1dxDCIJsVEnPJhguAoKF0R Sgoh+U7zlMwqIhsvJKwxdDYkkAvZJQYRKDgtB/wxMkNIoqJK9T7zgqiIiIXCeLC9frNJkdTgZQ4I 3dzfFCFZtwBqpI1vFjXexxwJSm22vRauW2Z6rSkiy7pqxeVSx+sJKcVMGdmBDIExSpBvNo/SKWEK mksaMzEQ0oBhXlZ9Sdc6xbg++oS8GgwPuYvOoDqRgTdfSAlRlmJDrddZSdl8cx2JceZ2NO+w9i3s Z8nhj3E7jinaNbMV7Hkzq4p1NERooMWoYT4P4WoLXzf2+wLLNTI7Id2LZDMbLJHo4voPtQ88lYKO TFow6+LxpEc5RunP4IJjdrtK/6JUTWQsZupaueY9rNLMJWwieLgjiiFUSbBgbofx9b1mLYvdG+mD QibyIjymUQSNHIZKHNpTwU7nX3ob1VU3FUUjrqWpXFm3cmrcY2rxTLclLSPLMjYRoXuFRUQOhEsQ HhdQJ5j5STPsqjb3GhyBUE3M8BBT7EtvSJdURQn6OOvvBCKDswtMM62SZeO3IgQ2mTERtqIEWnYV ZsNyq2frVUBIoYRAYSgBc6E5k5m98Ag5F0LF3NGtFPg8ZBB/SlqnwdHncTFJMwu88fHBzCMs7dKV F5XlhmOL8bjKkFJJ6id6JknDSM9uxjOsHwEDYS1iTwlppbUJgbD29BFVWxI1UFaaNYY2bC/aKYuz 3JdnjuelqMydmtuLbBQyCw8Eo8NS4IXnDlSUvDnh7K7/NNCvYLCaT4QEVGKgC6BkEj29DZVWu+of HuNgX3UvMEMiHCcDHBKrcHkolmz0bsZ8i+krMHLmkG/CZO5kVVu8yKNdojsoSHoZrQ6G0L7KYXqY eXRE6kIGm/djztKcnQvr1F97imTjuX7O/2uRzLbmuzs80jKSHtcnXtZk2JA6oEEIQLJASxgS6Y6j 4VUVRVP1qEUMwEQNZyRHia00I8bMXjEyJuKyNVI7USJQmKWGCjCdyIFtm7dE+JQurA7JVkQBoZKJ ccHrzFzFR7jIkXUImfYErGkialVdpE1uOyAmOCrO+4rgKSLTmIFEsNEieVZSZAyMHAzDRRFkT2pj 5l0oY16kwQ9LCAQMpzmlV0S4xgPY6HnkwXxseZydhAmErNW0YlJDgqGXddzPVzYuGebLIz2uSUu5 EfGRPOKmjWTgmcDYlb62jWgzkJ8ByD6JlTSj4FnwE6upM2Ab+uZE5RwhMk+lJcfzZkdI12eHrR3v clnvuA3g/AHksF5gCXPV3MqiC3P1dR2cunsAl8yoG/seiRCHruOt4Eq5QzUsvQhRgA/gj7rro81x pqO2OTZVoXUkTnQ/SrNvFRqnOTFZDvJrJTBjKFKpgsMKt3gu+tpwHzlNHUxpM4BELfdnM4zxIYUI UJWIyFkNuYdL5CoqoMrEOjqqKqI7LF9aD+IWJUxuCrxEmlKbbZb6Rs4M1SRpgOxsPax6sYu+ZguM TUsQIl2kIOFcpntdrSPwUcSEOHZD0n3eBVWjIqp1x6Pt8BAZTn2KDueGc427v2JCJLzTvtETyC/y C1UIBJ0pKBEOGexfHrq0TE1hTl+FIoSSLgDftjgTIUCli5juCEoIuRIOhHMx4RDhFyuZ2jCenmrt cRpHC/B4/ihklohfgQ2jYoFT3oUSgAwCRRE+GcgBKrXEiBz48IJgYjCxBKo1jknHuMExZCwqlzXF TdUEoqSFD1c49hLDiljBQeY9aCGifM8JD6oyVbcSGqI6CUCCTHBuAQuDDkpZU+CD4rdMIgX0L0vJ SM0RLy9il0NTH1VVPEsZ2TB6WOd6L5thyZ8FT16uci8SS+SIJTf0xSC67eZntXltHVq8qeKHE4FC D1QPuQFoqDmKOQy0wTGTH0oZkIjpcGIT65KapgYShhdcO0FSCaT2KDQ8BRlSw4K5yXS8ukIIhpl5 7XOYHhzjryumcYyxSdMtgPP38tHGQ5NxhDVLmC8fUmE3NzPLaDedKYgaJ72WnBGgwTZkQkdrFo6E ErVVZUQ1cctIHIkbo7yJqQUkciurbOJWAFYFChOScEnRZpQeckrr30Kpg/c7tMmLUn1AyzcHJ6JE FqVJr0Wp2Gd8CsXOyjql6jSHlAedA6arbGzM8UG8kRCABAEHAgpf3dDpBDQfnzFWDgtSsGRfC26J P2vpVFsovZtCfGPl8nJ1Q6B2cjyclqli5c9n91RHxVUVxscioCoJtBMPhSRLrzQ5VE2uKJ8jzYzB W+6semBJMjgHPvubxey5qjpcHwfOo4FRpI+SG3KJyezCgd19e3mWQCwIhEHaIGpvZPRWkqCDJI/f RzAiwMMqOnzOjIOElMYoRAZORpwujnYxY4s7LPIwXPj7PZE6rNVOeOYRYa2IVABhRAiJIwslXvgQ 8bCCaRNyDpkOz2yRMlQyNWGADiodyNY1baNuWALcfQ3G005yomMGKPgeAJuqLs59GtHhmdktPMJm JQucQv9pJ5ghQsL9frjzwGjsN2PJIRhy52452wzisVPTOLE5bxrBbB3ImQgtHGtVpjjhAVw4eF9p uRk9BFoJ3waBoF54PcIgg8FRjp7HlFgH3MuSqfeh9yUEq5kPLkXkIx7D2PYMGTI9lJ3FCJBIg9QY HQ22NWl5v2OiIT4c+zXHEWIU5BWM8QZNM9jZfYTEvHqA6gOo9iiYKdQJ1ju7zgDA8xZD5olwlgna BpuTeCGKaHrO8UoCdi3EA0TQcPRbbTAWy+7r6XRAS4c7PDRNA2qTm6ypVZgm+ULJBgi/Q7Yk1lmo YqZSybGrFZszjqeBOFYuJsLa0YKRBy8pqkIhSkCZN0J1NSbEawKyTlOfU7oICUBKaDO5GhRG8YKG IkKFVESQpUDIKlxjFlrf8NxwHToLHKdHKkRqCwKgqVV6qyooqbTx+tp46HS35qdbX2dkoiQ7ptV4 IkvCcIwkihQVw1ymlITRmyDpGFrMchMXYd1RvA4DhYai7Aw3BLkZVklGewfgIh0iVMx48YX20vYn ApwJ5yWC8hEupWhnMImOc4ieJeHlRbGIBCqIyKCJLSisiPhDI060ybpJYNDFxb4GBzxu/uhnif5J q2+GyLpqQvyvNxQUUqhOj0FD5M0WZxPLGloArWp5oD4OA78bJXk+ro5hwoGfEHk1y0poZwW0Lstq c3VpSaG2LorUQaRX45KDjMJOy/ehK5VExo1cuSsJcTos750GSZgbfV77aai4MOZcZESyCFE09h2+ fcy0cpe5icl20EIant0ylWmAu0M6XECwjIhnwRPZATmgJKdU8KsMnydE3eT5pWWzUvayrSv8MnmZ UY18yE9hwQuYhD5n3fMwXkScrRAXoebgiHQU49dngzW5nxx2sd74lC8NR+V5uD9lJlfd++TGxWwK 43G2JwbTkhO0vCy+ACvSMCDJvVOCIGN1wIooGRelDAqQsM73ze1k+HCrEKdkEmZjzZm1Kx11Chko 2EJn6p4p321W8qzOsNWRKb4JE+S5uLAzQHxdj4OwYR1HFOhQwoq+wpB4nAspGFHoxycQbGUOz0aG O9yrk+jX8eN6XiGHHjxLkuikzudF6qWcsVLFuZEKdZosI5Q5LFPZ8RIuBW4pYu0zEdndTAly0DKG H0AUU6vz9iIgVpC8DgIgeCJS9HkyqhePN95ZAfOvMzMqyvL3zKE6hMgoFw3geqGgrAV6PfrnrWEk SNbxTCmhdC8kD36OxS8yRqxuwxP4EJR9UE6r2JTWKijmdeFLQb4gUqXOBurJcoSQuZco5BkG4sUK qW3NRyyUsaQCsTn1eiChaB7jYxhJlQxeRfTLqNRhlKWWE8hoxDovioeQB6p6jxXsBrCpPEdY6wKJ yE7gDaGh1bgSxGS+SNXYBcCaATUo2PoB5peO1e08Uo+Y5+wSiSRPRPEBwjxPLwwO01VhVwMNiO8i CxmC7aRDKcMwxkYM5deE6buJPXV5c3OdL5JuxwzzVV8zatY8FccjIocwTJovsAza6rtqPI4D8GL7 mcziaJNExZKIgwIWZBF0MgjCA+LSslTRFJ3oj45MW4hjL3krhIclnjeabpEZQVzZJAGSFDnCoZWc nSacxUSNBp8Tx7hOvKYG2UjHFQ6kXOtt+YBWsJsmQT6JogTS6Jc9dXfPvbquvNbGzN/IjVgcaP1k CO5xu6QIhyZf4+JInZwcGJeSJhTWG7AqoHNM5kjCMZ9bHEUxXQTKx4d4QUVB/Kd+Wkimpe+rc+I7 j965ubTAoeLSgyTUf4MZ9zo35HPSIJ0/fWWXdte7DRJsjp2HIkWpKAdmgHg7ITKvNEDFRO7hMivy PmWJpXTB0OhIEIlLlLtDmnVpGS1A/Q21Vs4/Cnp+VPRuvV1PjIal9qzh0PH3XNzBMXdssqFjh4v2 IHy8C6qWRyZI+iCRyYle3gnrW8m0A5LofQUmcFB9to5j6UGIETRKh75QROBRDEhxIPlpzk+Z9DDp 2l6im5Z6Rr8urOqv5ZuTFQoeDy6JcmU7+JeQWwwkGymvBQe3OHjXJkrk4Y5PHjR2T1wbL8EBT9RD 5CT6K8zGOHjJyczmraKw50HfJlEnJMjsZKZ9sOKK5YzUn1ox48cB4INIMOXQTFhEkCIZTqRpOLXZ D5kiSkW5OSVkLkn7lovBq3R7BRN85LilkfBkwE+f0EHrXgryVZl0YLjDmuleurlTIHlTkmkDsWXC hLPbjhUSJHRyGlwKGYtSq/HFQrZQgcHjCBbz6uldQ+svKZnhckR3a53wHdfQNGjOqqZ1Dbu12G8f sncyOgbgfzYiVGrhSMyuwCMQurtLd5UpgfjAfQupsmVWeJtQmMbNEsKa/DB9vVA2cHMwW2DJkzU4 gqGypByXcw6ExagsHs1vBYZ6Iwi5PDiVsfqib0Hk4HM9MSMEHJoJahyZQ0wXDJYqJ1zVEshEi1K3 o4T5JFTMz9FpqSvaSJ7Xp2HA44HW/zEjZnR0joJlzZwTULxixzb16qXJ1odlKcGEuInaJ+qJByiV SEKJ6jivfmCWA7lg612KFF3oO+5Bzo1JyRsXyLW0HsLV4gb1wk5OxeubnHUB3y7gQ3IibAHBvBEN enNSO47t498E7o8nzlGqJOMotVYvj+2wdwcZ44tU54NBMaJrD2oymNJG00FQLJD4bt1I3XJG4G9z MdiScdbVsSnBFWlcZOScsquQHksK38NVwCnvbgdECosi2MAiI4jAKiIj0elBymKKPNbxLF/sSAKs i1BExAGBEKlXwXPzks5mg+JVC6IW0giwjZhE4XhiokX1du3iqYo2ZWs0ZPDPFDgUds1RTl3HXDFy 9QDRaHIpJKV4ws5buTwQTxnZwa2AQVxcnSZsMBF76rKOZWSMvm9ojAwpspFb2yh0akyWVJ5b9+ZA hoaYI4h+H4eNCEBKbAiSwcdS0TEPIx0miqO5GTi5Twca8ASE7ONbXa34Xp2otauVERALHCjCJPjo C2BRGFbIzoRZBDweNhdDHi3ZxoeMhxFXA5ODzU5FnU5Q31wCfROdzJ24RWepKEDHCEthBqEG03Ui tmDst1KE0CEZwS0iQLiRQcU0SsaJDByaPp6QljStvMOOzO49mEkLgWfEo6JKVWoCTNlyQyIFN28C hYkLBaqJ1loLEZJCmZBTotImWPbRx+ee3wJ0XVOmkvNJIeK162DPOG6fgezlAo3mR3g5Li4NGg+q GxxeAYY0vHKYIz0V2lmpDW00vxqiumV12EC0USBjJaELM4yEplMng5JUOC+B9sm1FOkw2ShODVGp LZc4tBgsxnRtr52llvTk4tIOECLiwXOD9EE6ON1URMKJgVWZRueGJGh9bJcliSsW4DkzLvV+a1Pn PSS3UtqQFywnEenKBTovxzcuacnFjkWdRgdL3d5OKQUREB6ehLDnwiIGfGYZ1JdF9J3xXI3qcn2Y IOPWzz7FyYx4EnxYxrkHGsfpBQK6DdyvYpJBmBzJo6B4JaMD0qQhYpxkQud4rkqQTIIbqcCWUuRg ZzY+BSpQRuN4Uz1WxsYpvq4SG3gi/QMxLqQmy0ry2Y0HgQznUGezay6O8/aiA5TkobEy4OVLcjks ECkxjqI3+SBQcoSPEEsiEkTSDogs8vUAy9AcjpAPNdb3m7oc2+K3Lw3XK4TLKuqCdRA5IeYm7StV oKU4vt5P3LEdz4PHwdN3Z7MfBvK2c4rVSwCeiCQYgggkhBJAKN7t5zVgGC+DEe1cjkxsEmCR1YUa DsJ8gSLGdxmOsk5jarkrJrJ4qg7ytOilvJ06t5ezj3lEzI7A5ZZ4bXgqDBg+aPOj46ux0QUPSYiI HABHkQYie5ZJJJJPdjyuPOBWTAoWyImXZABIFLTJUpkdyaIkDFCb2VPf9+gtUXKYElVDKRMy3nb2 4uVbFFI7Ye0vLiY8zYDxxh/yWHInDM/Z24IIfb5KSRI2pvpWEEOaBPuT6dcre5ZBLKiIPBUcEqKM dGGNXRSj4GH2akgq8PKgzLa7lB3QElskdui5sxqM8s66C7MDeXVFBas85ixCOW44o0t6wErXNwST A1WhkGu8BOe2mV06rrGZMy0gCjMMUBV0R26WQ7OQYi3v6iR+OcHvfPCZ4Hc4b36qL8cd5K6HKdOz 6XPg8TU4aXgewgpitB2LkQiJ1IJF+MCHJMKgq6SLPTpASg/7/GTiogXQEm9ebGzRD2g5UuweTmpV MKcIE2ezvaGhRLa71gsHRXu6F6jEhEqMmlixROSS0RASgnA1lUmZ5zM2rNu9UTbSvoCoRSsyPPmU Gim3IMwLlm6liG0yVN2WvTKwq21rlH1Um+nIgbLIgJMzwRuJmTR0Op1meSY9x00TIJzBjjj3DZc1 KWzrWgFd+kMdDHjJN0Zgr1nakBBMJ18ZmgZH8EA/TUPCc4Gpq/LZiS1XYVLUNBYI3jXGTBlt0QCq mwdkCTHHicLG5zQ5GQtCbZ1VL0rcHSNjE7zqA6eYctExsnl5JU2JBgUwHQP920L505+SIgX34Lfk Ows22uCqIgMeEuabac7RtDGDJHMzkkSsYFZDFyQUFZ7csJc/dBk9gY6N6NGg1wYJ3L8Aye1QgIFM /NMB0Tm2hRixCYJmz3Y6LDUGkDnOTggms+MmiZUuXOaFUJxvmxAUJpUvk9kEczhicy5JT8VwQfdX Ljc8F/p3krWZODsrge4VPAMQdG3n6pXN5UATLhKQp4OwbLM4pMyWmBaVBb5CZVTZrHsvRNghUoXd 4+epNgkHhEQOuAcz5pp8xId5oFKNuCNYurQx7m1wgNVgxUSlwaA5oMqoQim6ddCjwgUS49k/xTsb vYsKypChYVl4BGA1sZQeaIK57Tg+mmlnYwXaMGkY6ZhpeqwSGioRnnlMVGqsRJM5IelcmySFksjA kwksZFioSAqJlCahWtqhcqFSoSaCziJ5wCIGVjyenAooWBAUVAAyAI7DWDIFCLJVQqkFoEidpYWV xFt1yoTVVKKElQkoVyrVCiSgBQstpdVMiVCql1tuzS2uemuQEq8mmUIvJCmrHYyTp3ul/kv9Pe4+ D6dPoKUiJDcZq81wYhgdkBSp+ND90f2LGuBAerIqDj2KrHiEFP4HIselRJk5u/4ji89AmClMCWwO fv+5857NprN94lMdnx0c4c75pJgzaJCdMTqSGgeM122HOmxsWTUfAJlhvNNTdk6Nvr+P6xAD5oBI n5IWSBSfVixmSz8zwfE+c+80ZBZgWQ6vK0Tct4XHQpeNY0W1jj/YpcuX2XXqSai9NJhfzaLN52gb 6c5GSBijABQYkjERkFBFZESIsRGLBgogwUQjCLIxgefywUVSNllRUSKRVFUUiqqqEGBZJSo0wBQL gKgsWK0gYCiBMSsaWVigoNhBjCDLEY0GQAiQGMSMJv8wZbYnLKfyyno0ND26vXEP2yIlKO5dSym5 +0+9ebeV4/QT++KSLRD/hvj8sbH7Ch3PQO6o3GhmcxHIjAsLEEH5V1LKDkpMgB3rkWMKwSkEvSSS iZyCxEWVRknoMn0PpOW1Plm6VDjobwtCff0iRkskeSRUoMEQxkRUMIguu5TySHpT4k/5/5o/ayP8 ZJ/okWhify9SWn1J/EbVCoTcDUzjT8X3lqj4Rd+7BaowTX8DpSQ0WAgyDBjEEZBSAyKBEFUlVElV ISkhKoFz8E4zB+e6SdKf1nA2E8G3JAMCIjBYrdvu/1pp+mHJZqdaJrISVcvojFdP/Y84szm6WMck zTZaYGpKRdmb98nTGPbETpeh/BSXUoqCIeNgYItAogiAWU6FhSKqsRDhSw31ou6igvFw1LVMoSyK C2t6k9gzsXXvU/dMYbS3BEDlZtsrFNA3ZZCnG8xGRfGQtIVhBTOYmZoTpcWinIwxpBvGZJXcmyT7 kEyFP+JAKn+IcVyMz7Wp0qOrpmxaDdMKho0LZtV+qbrT1cP+8QXNb/pl2hQ3OeQG/uKD0BoCnX9n bWlZsFKwGdJJ6XiWSfuMluyhnTZF7Hyo3x6XUdJQ1IQh4psBHOJCA2A6hXWoLyLR46yp4jVSQoqC WWklpIpI2n9aRqkijYNou2YUV1QLpIIl1spkDABYE5kkDU7LREGJgDq4Z4wKShowRK3xMxoiP4ey HQzSNKDU1S2qhakgyHpA74nBFkrIyyE8yB5hCfIkNVydInqnadIieyKN7NRS/erAl1PFbiyISIUS hQEkpQ0GoGAMB7wznQHoGwbS0g3HaK9gzaBdEJr5hU0aALBCkMEYRaZ1G2dVETgZHYMEFuoFHuB1 mByG5BRQU4HjZIcJC0iBgvZD8rg1zJHckrOcyy2jfSqd1lJNGiQ9faF1xSQopMXekWLkopxwbTvS TdDqgaU4GqYSGWmkRrij2Razuf4I4z4d7gFSRNwswu75Ibki+DAYlkxq5hQi+Cyi8vgsUopKYUYd I2RJ0cQXSRn3r4rpFrSlSKMsYjI1yka4wcNHQJRVT1pf6WVYgsnjIcSd+Q9sngJDym+SSMZ0KCmj +ik5HI3XqVPT43LsV4izy7VkjwbIy62xDESfOqR3F4bV2MU1KwaDWagzBkFfyE/Q/I/Q+tAaFChE 5Tyn1Ff0MRXkvJhP4VPtfqf7No4f1v1lKUpSiJ+WlEEKfrfb8n5A9h1+35T2/X5L3hSIKyzylh2F RKpShA1UUoKUKpBIJlezdl3GO4f3lzyWT+o9JKuF7Eax/TMj9mGEzZKVVRNxPP8+A+kBhn/DaQLC GAEoDCMssZBLJCVNFN1uBgkE3JtMi2d2iGQVl5YZa1gWVtvYTUbFgvk2lltdFphWlhCIsBkhJxGA SaEeGpocqEMrnUP2nGxFYBmomCZWNCUSrSLJtKhh+CGMY4KOgqJMsEc/T/DzriYKK/PPgLH0k/tJ XDhgn+B+ZUg0MYGSpBFsNv9D1l8Ph6lpDMkx+X9yvMdb8PR+C3iW+qXaMnRdp/x/Da2vAPa7gM+2 Iyn6Y4Y5zGRu0lZvMPFVUkaD+hpA1awUuaoVQBE3Jf1tzU9Esn4+j16j+5bfNiXsbNBodg8nuMOS KR03RLxjUFgFRE/EAwJuVMZkXKyorLGoEIkQ2l5SJIkPI0J1l4q/D+HC6GQqrTLXaDfy6qVOJ6Og mBIEwcdBssYGJFBV/gAaPbzBzmnQ+ONeexxSFmSKD56dQ6mdHZDKK13YoGifPOCJHdAt0S55lQoZ SxaDi5F6NtCRzqpLb5CgNz0UpXQpodE5ZiByWh5j5u4wxxUvQo/IuEBi8xYDVNwJUlyfJERw7MGD rmaDFBnkSKN0GqBs3guHoBOSPxT7kOgEk7xSO2FBKaDOYkjTK7DUadVLLaBUNB0kUP79YzgbDYTb jIcDaZZHA4GKFmYsK6Lwh1YK1YvGTHm1GzF9nUlVIZ+paRbyqrLujhDLfp1G1nA7WArIM2gi79IO kOq884PZOEsF6vAypqtUAHvsvdgBCS46ZG3Z2lOe2+zaacjdyuMqc2NxA++F7pdRlPIaOcr7qwpx JnAr6jYVE7S7VtPqRFy/q/jBySmvosXJjbNOuTNeHOR6ns/whzYtZTZ1QPEjfzyCLyAAfzOQCeVo eVCgCdoGvUrl4viXuse0ej/ehlsjKMMDKPVM+O2T/BcTiO/Mh0WanxemHznvUKUjCyJYlIlGgJZE lA+Ce/NjYBmZCH6pwnVNBHvQnMKwUI1PYFyELmOcAKySE/N0qJsVDm/RbuBA5pBESlEb2+1UJUNs BKE7IGc7H4W1WB/eFQomnpQHq0tgZGHvq4rUN4h4DWf4AfBH54pZ8pynK8n3BpesNxehQPtAikWV JpzZ+UhMz+3ijPf4lpUpUVSjQ0SEMJ0eV4hwJuRbElQqiIw6CQ5kCGkDvCh7vYTTXMhtDnpvDkQw 5RRZiSB2SB36wV4odBtNAyvKzEDPf0ICZM9o+qnDBxnBAMDByIArkRACiBXNHN+dzxbZklUTj1aD VtagaJgfemkR5gl7bDEBrRHyO5G17mBrUP6jSoMyA0rJPzHyAnnO4OO0iD7gM8z+E344sJ/ETrFe ZM5lTwN/llbrPzWafEGnQ+wPUSo3Hgnj6iXVAvYwkRU+4/Qd78y5Q/ssDsYT+26Es4GP7A0OJIoc tFHMcVCZ1rkUxneoI0asBsdiszXb/eQaLnew09LXCo42PSGyAgODwOWoFhGDafyAOTwJotUqXGOC h0ciaC45Aw5sPAcGLMli55+wSOSWJG2UaRntRiSSv57KlBg1vfSYNGnMOJnJ1ex+fg4PGSR0ZMBk YkcGeJCh1SotbBghIU2OjBd7XcyZ5RBKIVswWKDxIyFKn9nWDsd4lsiDoLnXGTkKjkhFSxw5INSL CoEexAofiJ44CiBXwjmiES0zRk7op2ObXdyXArWIqaPBcUwTx0UGK2bhic8ZmWvQYgUmLRRajmT5 5ECoFKA+ql/2AYpQmaNiiDGjq/ITOONOf0/+QsYDBby3or12Y5u3kmFTpAcC8M3Fiz5Hzp75LnVl iyWko39Dguy4Z5bVOi1z9USvx0NfI4w/RosGbpPY3v7hLIyElK+UQ90mOw5FGqymzY2cea3Qpqx7 GWTPFqfZuTKryJ3ImQEIlRIGJ8GZfL0DG2UCtBSwwMcQxNk9ZEQg/KIppsKiKLmwMTE90DiB8hL9 goiSH6cHunjnOeSe1IfIdwMoRLEsiUbAS0KWRJSCWRJSCUaAliUBKNASxKRLIkpEo2CUbBKNglGw SwghC/uAPinjOoA4KgRJAWgweri/y21gmNiNWtd7oH7fXKeT1l+Ih8h1AJlj/TUhUgvJM+uRFFcj 2DeOYT8MoBzIiHSOwQqUtXzqkGRcAL18wKehnBq+T+IlqPsd5eDoVPYHOOVax7gPk6EUHxgBQiEF DIJsOskNruE2sKMOgE9PP26L6jVJMxoCiKIqSpLzkR8/vKb+Z8T3aAbyFS+ZIFH/DKZ5hkKYmZOq kbCgVOHMXmWtPMjw+Z3veEUsGBsYGsbxkNGQyGESvy/OxjouY2RgwowYNTEU5LOT+9E64I6Kpo5I +8yhPAkOC8WaCc75i4GLNnnkV54lmQ6oHBsFJi3ILpdOeUz1s63LHI52HlpFzowYGG71GDs5/IIJ /1HwhIt5NmNfy2bYylT0QOxrhs2CvIfF7omFG9DnBFoKZgumfAieW4K2ODhTpKDioCeQRRwVL8li C9lM25KSMGShwf0B8F6enfNDRQzUGDR0MSHoG6kFCvx7ZMVMnBQtGPazmbgToeQoKopvmWluBsW/ NxrAv23egQbm4tw3GbiQBYyI+MSEIR/6f6kh/gPuygHcnm4vBF3CC7xUVU6tgaCsuWJvY1HjPNSI jETnsIDto84nEmVF4nwABLIdCqd4pAmFZF8r+ZzJki3r1oVVGQ64v+IoOQqrP4uS9Dsd4lhlhhz2 YumfFBD0x7gwMX9yD0HhBH1qy9Gv1oKhbqc23GmjHSwX1hQzlKB+AFZwNYa2ZlXB4GJgGeWQcJNP HhVab2Byqtn6BEM7KJsIoTXIrU0yCvbWbdczgWEycNZ5AHp3YgEbiIgdsJNRBIJ9PgEd3UNiTRg+ QDYchXtYMRIDfhnFvPxIUd0ym2qsqryIvCj3B3IXwkxTh0SKWkBOu3vp8kYlSU6yds1FyH4JW3M0 kn7+5EQG0mOTyVCthvoEwjjykUhLQH3tZtP9ZJ0IC8bq5tDgQkhO1g9XIEkLg6DzW1NaCP0GEwXe mHWMgCjCd/iaK/FQ7NWfeR9ZWEmKULwQzOYhhoPkuT6J2I+iFihL2DcLs1G5Q4gO8E1o/BHOCnq+ LvNA0Lw/Q2Sg+sEo8YHeBECk4JSSGWGw1BEIjMCggIgsGwMQwYPaxiGEiKKmRJhwKIoY1uGXdm3+ Z8ulVjdkIgJEviGRQGatVp7lOJfsOfA0WkjgwWE92KKvJ6RQ/H6IiBxxe075yv25N2oaL4SRJuTk tyJRTZpjvaW1g2fiRIS5jykjZPHsCIdDn5flo3UsMWOgg8hxvPAjnZXAh5s4nmPBcXZOdoIKZSh9 onhBNFJGzjxgTWdhJ6eadhu0JUxzOSBYroTJXhOsBljfY5jmYiJs44Fcg7UupAlyxycmTjg1gagh kw78wgcBMbgkMbDDbMh2gIgc/1CeMlwwNYYZu07c4yZMJgPD41GKKLHskkkOsOsNteIcTp4clFnT vyiUvFH2HeT2LSOYx2Rwf1kGfZEQLnPosZMJv38h7e2OWVNWx0cdG5Zng9kRznF2wgWlLSRYV2qd FPJgdhwONjZubtXbnm69chqjcZ9OS82W4XeGfop4gaVWoT6nNgkjBJgtH3Kk6zg5uhrHi6fBcdbq OeJ4F8Ho27O82jSKjwEClpuJHlWTOJQImJxvgoqKrGToYkNaC/UBshqF1LomkwmWwQlB4PwTygku DukVILiFYKEG9lldx3Pj1gJykV5JM9T+iqKhlE2DOVHJiyGwVYVdQOThk2F0OXXdRhwpjsg28pU3 XdfX8+cqpzpZUqpO1v3+qbGo9QobmGBlyKh6oPBqGKNoeBAijxEgnHQwbA2ctHyORSGJ0OfXm7+0 8Wy7cyp6R7YjBI5x19I60652goSHqfgP3BoGseURU4N73Dkd7Yh25xNAjwTB0q9k+gfIYebwii0i lootJSxUsilipZKWVY+Em/aHqbOuQ9qOh3myrc8Zu/w8xfFUPVdqSU8EsU0UAvS6YZYmDpQeA1j3 I+KhqA1Gwzr4CYLdh3AyEvtFFM1VfbQTmuxyjFzmCflFk3xqPrZAqPrIlSfByWt8Honb+1NXJvvh eLFksKF4eb3HLziW7wehzSoRijeKO2mUqb4ACDHOqAIEY4jdggfgRUP6pyJYSRRR4ZB4rNDMDD6J DrahjEEoorzvJNDUGU2uIMtZCc+KwGVBWGZUupZUIMIrI67GbhSLDBICaMoixDF3KILLi9XrNhH2 uRYzHQdUrlQcqQMRMkY9qcDxd7dDT32Pt4DgGO1ovrqATqchp0J/AJK4HwlfKxCWdEo5yoZsLWfS vNLZEgmEy797IRSGMiCVIolDIMsfYT4jjy5cC7U3G9l3l5VaWOiT8iQXCiWB426gQZi0paW3Lbbb bWP0w49+bHfz4+WvrTpwwjVrCF3w31dF5YY6tnZEjOPHkHEY4D7uT+K1D7nCgr+QRIjPKDoIctof ETil8LCr29bx1srwcmIWqxcKnBIbrIIfsILIjYlgyVMqHZUuaKSO8RRmxpj6EEBnAPg+xESVzlM2 sUf1S43J+h95UeJvEYMMCwyJFhmVZDNOML16v422Z6Q5cqLW+buucHRauPLwI74NS7fTWMqTdwi3 bd8HwhKvHnOEd2/008L58fDhg1Nb+vDm2mnjC3bZfHW6OnTS+ayy4Q1fVrtuH7vLhhTZbjU6eFuw ae5sMG1qY5Y3XaS34ZtShVgm7UnwBC45ic7hOwGmItRWHj41kisyR3Jb06V17+iPCQRgxSiqPLlP xID6pYrcYvQCC9z6A/POR/jiNmPRZoxNSRVG6YmwdOfbE8ejvo4+1EmIxilNGo7NNQ8DdJa1plNg Tksd5R5HV1KFR7M2EsYOUnIoasuzspq4sW5kvjt9k9T2lIo8FoUqFjzgk9kEniPUZiN6RpUiqSVU O4WtaKEUpVILIRSCIIKCKKwRYxQSKKApFhRRtkNQprot4x6pgiDpAmbDzpnLU9ypTNLk02RqHoJL fy1Ng7jwC4iG/cLyePIjqt5UTqHwFPSOEC3NMEx5/BEkAPTiBwZpogMRNKzv7+BoraGncaLu2m0c X7g2y6ipb2YapIwqxL6whiVZFwppFLDOVhN2WYhgeap6jFw8hfRezbxS+DqOdCcMvSDwQQZGKmN4 IGqVxlIWS+MUVivvHm96npwiXJ5IUdXgizpuAVS0lZU/PTbV31qrFY2zWkTCiL5UoPvjGWTqn3q1 ZbdCyNaJuNxO44BuFN/IjWJHnQ63W7FLVBVlqjI8CYR64Di+4Y7gMSCJ8EsdsAZVRNw1FNDt0HzU VLOxdt0Ly8CB2WF/k+zfBK1rTmpnNF91tpXPMdB2buWeWcTjnBNE6kROGThIjbERAzt5d3Dbb4P6 Ov3udjAbr36QfY59evTLq03V4d/fqiIFz7xjS9XOcOM0N0GbucRjFVugeZ2tB2NCw1nl3lhwGOT3 KPQs6ZtJMoWBIwImliz1e9MDFxOh2NXzOENkYrSfpzSzVCse9cB+CDXbJ5nYqE0PSr2m5gC18BeJ wAPcDmiJUGnj3XfDx487YK/udgvw2VYwhfdzf8I9MfL4efhos+sXEQA++nw89+oqqorGvvprFgWf L9jdueU+VzsIgfH5CIY+J57l5tT5vzzed58MsYi3OL0zieMT4GpH9FQzqgdRxA4AqS69Pmdy6jvK v9IP2W+iHsJv80sJJ5NLA0KWfSWG7A5mgk7PcrPOJzF6biqqqUYY8V9i+b6Xt/jLrKrCOo1ejgWk me4mxnxHIeBFTKLeilTJCyQL77QkjMGRVBpRFhoqqWGYk6gPr7BN2OhC0EIX2R2AOWsNDCdQDlPU nUaQJb19R9uZOSmzRw8sFnXQ6NPMDzZ2kRwXwVN22htnDNTG9Y9NsJGepWXAZbJIfQeCmklGww2m nInA3xFBBWBptAyakD6BhPCEGQzJeD7sqSUOQlgZprnMTjx2SH5h/0D9k/pYXqhiMQfzh150lCVQ CTPHfI1wvMOPbbS01FgyijfzSzzpRycz0Xz9FGF/2wKIO7bLM4JKUH/MDDV9gLzFUMpaHqQpimgR YkbJSXKJ+VRgjWSQk0kgWQsk4oWUpIUIk4xzSuioddLqSq7wr039bk6DdJy2rJZbNTQQLuG17ix0 n4JgiaTLtX/OkvCKZREZ9TFM5xwm8YFT+Oj8paw6+/3EuLVGUzkSLP1qn5xN60/TQ8uJUIHxHtjx spSEk5pCAkh/n4ge4fmtB6lQmE5omh+yTtndDlGHz/FMgTmBKazAGEx+3Eo1qMGwsKyjUWDKl1Ie EDcceHkOn75puhsH2IRLvnfS+xt+Hzub71mbdJGTB+ltZvRSOipyqWVMDdXVpjTwRdkSxA4SFH/4 T+N6Zi5gPtJTL3NqBr+6ATJGlYsaDZ+CluDk4tWgTXQULhrAbMQNIRwV452iBJEuiUU601JvgRvb zFws6urByreY6zYLdExiVIlcmmxXIh2XLVLHbkCVJ8IpYjg5E5TSTsXGsYqZI24fYnUjo8odDE7g 3gd1yeg+LXgUyOXPXP2CKePFiQV9j2OGOcejZBIqUctkgNntd8lKDBSJ1MDsDuXqerFswV8XwYJz oc8qtD9kT4VE4TinFzBwA5o4mCTObFDk44YXkLa6y5KXaPsoDVK34GGKpOhs9eOuhZAsisihUsu7 BFhoxUQ6Sre2s9HEi+ysnE6PDwc9cWsfYAdCCeabDzwSzi3gcKHg2YxRJdU7BXOfLuRCBoNmz5lq kyL97LHkrowQ8yOyykf3TYTv10/2e5s4Cc9D8lte2eROw+qIoFBwqVMwVhEgXwGVkbCnH7VHmc4s apuARAtEUvL0K2C8rqqkkYqT6HNdyYppMzbJ0HdipgxXmb4zN2hQmalJD+HbCjJeofyj+CAscltQ +KAslCaAsoT8qMoIWCDaB8g/taLg/e9wG4EzD0T3WTNRr0MI7h6kHuRPSA3XaA9mANcAkQMQDzA9 Zfx7Xz2LQbiAE4qhtfYnKNr7ApQDkjo8gDSj5GPcfA9RMohtHcGZHSdbqT+uPdGpdQadiodATKP3 rWP37hOtJLkCUOpDdAm/UED0EYQiBCICLFgtHQ6UW5D6EntjPsDST29EhjD3p3ImChuBPZaJ0Qfd dudhgLEvYQU0sls0j4eSHub/lUtYJYiSGYlRegGQkMaLJFBSgJUN8l5PFHpnVJ5BniCBXvqtTtXe qGYm4T2sGRPI1p9JEkldrV0Ap9jrWVq6BxPmlYBneDiO0RISPRR6GrQKevk/cJUt4FQBuBvJpN/H QBydxvksiUg+87FDrC2HaAWq8Wipr5HyqzmtR83kBlHjvA91TcBlbFD0UOrpqPWQQAOBlIWy1Y31 FysmMmDBjBMSQMWQ7lrEhGoXKw9g7gOq8Gh3LcAexJ4KGnk+EhwTQ0KdBCFRKlgkO97Ewkk6RRKl kcqK/pUUT+hDwzpaOAGk/YYCl4dfuyWE5RFFIoIkVREUFRklUUVI0oMFjTb7L/hSTXjnp8x+6kWt aa5iYIupL1Fi9tty0+T8j3kjxOZhOT2x7tZue+037uXC1KpVKiprJuR7A8g6J9QOtfgnlQWVBwQw FeeC6l6AYvx8Et6naDa3CnUepS3KLPZymqfWHm8ZIfWPCehEL/JHwz73mjzHseAGZ4JxpXXtE2Ai Ye2ocAI60+AmTKm07EkOoXkFTYPJXutAesdyUKzqEFeZ3B+JqUamuLDK0LFBrfdraKhWJEJ0S890 fdNg8U6zgOZ9NaMjqGvKKYo/TnqWpO4DYa+sdghZeg9XdRiEe+LQkWWwP/sUENVHotYU7F+hk6yI TLVC00DV6ttYTDcqEIa+g0MiV7Cc/J+vgqEKKBQ4BlMNhcWKh4CU3WJAGjRDKfOJgXoOTSqHSRnd afM/kSZQEoD+6EDbEddYqhiEP8npcqGEHaO0ud3MHwD4AWqp5LwGZeQxkHeReRGr0ISVUAwogY5n o8kpV5ggDMRQUX2E0jnMWBhoEg2wD+BCG6OhUqJYGVdDA/Eau08Cel+Md4F/yIQy60sHcBOpaExc aJ+PLpm+Ks1tMrDhQ3Sb7b7d3i8uODtNQKpyyVE4z7nSHs+LD1s2q6cII2L0ZK6xYOuuRzggiXAw quyxy1Ijz+5xvX96h+SuPwPxTgMMDpejvnIsWIIMZekBw/kf6zB0kfaoPqAdbokh7JIZyQ7WCJVE qlCK76sAYT0YCUEQdieYyE6x7usgT8T7KGTuAdmETp3VJvqpQoqFKKKo94eST/b3fecQ6djoMpJu XDw2iguNi9LBzx9SCE3JcJYhrgG6CjuuaN1Xc9wwMI/1dv8aioakap5FC+MgYqZjmHcmAqlpCoUM dI5Uc68rvAfMP8ggiGsEkkjaPRW9AXphEglIo+yTd7HeustLUfQ9sTQP0vzQN14z47WsxYjtakgA gvy/F6J+vEQsXSlcJnjefUMADRQDRnY1dbBKcbxoAWJlPxJoFrcnNQ5q1/a2h3RjnGafzk26kjvJ 3YG5+j83n8vqf7g7AQQk/Ta9Qmt8+p7PMeChnALQ5Dm89p1j4PfNBwD5hxT3N3lOi131lPWpPg0W nTWGTRt7grsIs/WEDzh4A+g0CxeANRgkdoEL5r8jDNnRlglY6XlJciiQhovgkCeSVg0ZiFXpF5BC 6jgoyQovkdvWJ/IeiMDyH9qJ3j6fAN4B31CG0TUPgvBO9XqHmRAnhtMwADt4VS3o+D2wHWvUPUvQ ZvicjsMq9wJe/VwSEBOly9BbOte0uV7xNg/ANKNQDsei9QGtvDjHIPcA6KFwnAfJYOSd4HOh7mPL O3U6innxEmBxEUwlGd1lRHSc0yxliKIjHHC15F5FRIZJRI4iobVD1c87l8h8AeGtUcTMLYpMQMok PjAiBnSimDnVD1AqzHWCWcC1c8KiwOfq9zEkDmIeGkIfAhFBYsRFhvcIcpEVGrsCsLCL0SoHVGDT w5JCnkXH+dV1Ki1Q0jk6gOi578b0kkL4LI1rvhOyHNRawtKhEqqlUTuqjhLhxkBKQkrfMUXIFI6J /Tit+9tJItzzr4ppDYqfSmXTk+N8Fin5i+GpxaOl1vuUP9tuAJ7aMg/QP5CcgRLz3UPgoSFUmngm EgPgGD2G0Kn7MAfYqKcUtcx1AM9FFE+ydpZ65ZuZe+BMzt7ZuxhETwlK1K3B2yISUGm07gmqEx9k yLxEyr/Z/z/sHQZgxX5pYf/BGzUVEBskclDuer1UN7Ums2KgHUpUYNEgbJIYsEjUWG0lEHhG9S0D 6H3JPgAfazn+AH3nyVkCUexUz2kHKVZT6/jhS2Frr5pZukYdmSbJDuJzD4OSmWnBS0qy1jsihYpg YTMyxumISd6pARaZsIWbg/LJwjkT8yeqPdzHe4T8MsTyLIUqPsNFklTyAMS5HOIFEH8oRe74HuEP ujBIIZL+4+gCUPISvm62xnaVgzBBKDLJuEKYghYRLBCgYO50CMp8vxLXhFXp+hOEnkV7o6h0pTvV BJY1bawwn20t3abVHPasbKi6thDZTF1Feh7SIYmQTyMkkE2dJLlSoRbFQqzwlg7GioeL6dq3HY61 +PsBtMwqacDhm2f0EtBEkqGczAHmnEHoZ1Hge41WCeGIqeSvNCBiEiofgo53eoQzLRuXy6IbVQhb xesBQoCSCjWVu5RjsAc6NSzLEjAAgq+DkWEGyET2Po5uwxWAPIJn6Z2XhRqGGB9EFA9lvA+a8ROr wMw/s6GoesDBNIT8Q49DmqH81PlX6vfEtmr+iesdEu7qUEQPFoYROT5Mk0gZusJ9yQgU7YM70ZrX 40MmeMwtExomSJgkoUUPzXJYJ+U5jMH18wgfAeHL7iKvANp9Slfrpk+MRF2+SUbYDYTBobAU3YCh AgUXAAYDkNRMSB/Q/dxLGZmgYm02szkGzRMfchh00k0Y6KaC2REgtE0JmcSgSigkHTkB2KUwOx64 JhBdFWNJlKfjdLJEQXkCpnTKpCoCTGIuvCQXQsQ0qVpRrTiwzr6Ud1vdE16BknnAEwwPSRWOQMj9 1Ecp81+zmE+TaNRocJM9b4gzGip96NOF+kTToQFuYFEviSMKh5ecz4Wrw4kAUsY7DokEAi+0TyxE y75Ioi80pSwdEkKIQvEUmMSYS2UP4lsDg0nYEhzwlgSE1RNu2N/0uSTEm5YF3RwT7wTuMaMRaBDp 8h6ji5XKnFzkZzxXEkM+QMT0oM0A/bXOqg00RAaZSlxbCnfiGUz5ZEznM+RxMQHmtiD2RMhRYQWA oAdNlBm+FkjJH7ISHH1wnJUKs65ixCYxIOKPcyOUXj4HeAcwPAzExNkk+EUhy17XoGUcl4/EpD7p P7MvOfAxIaoV5AXynlZGaI+rYo/ZHcPMEzvUJykJ1Q5KTIJavoQp3gvS+Q9M9ZNCEhqaLNIUEGa0 yqGBMIWIkSBFMBLKBAMxOgaJvIfBJg0JMwhJ20orIVVOUgC2DQn3b1dzyPhB9YhJ/8YnE0icDeQE FzsDMPzcQxRF5nFB6iS/JdrcF7aSfs0BNwGwaHlHEXwLwTCwr4sYSnKRORjnhJQFrBeZgVhWEfzm MAvvJ/chgQ0Sms1n0bRgrZZYVPis6q+KT2p08E+tj3kMyWXgmn5aAd/jkrEyCS1Lioys1UylNJNm tr5fMane9QG1e/oXIP56QP1olyEFRJG52OIh+rqcWgWKQN0pA0UO1blXMm/jYaQKPUsPSTUAdo37 0370yHY/Pim5NzMAqW0tluWhoW0Dkm/BLJE8OKDVcFSlJtgGsQoiIDQTdiOwaIL/FgetbB8TJCcC F4BSwr8SVlSYSDBxEKP4XD0DIQluJKhc9QyQFoKJCiZGgFoTNyoTAb3fFjJrGgdaWI2zEsPmDwBj qHJG5q7weMg4ow/GAU5A/t/4KaAzcB/3iakBPSeXgHfihTdLIH5kuaVrVQqoswkt2WGMuVUf6pAS wE2sJM3oWYSjzV5Sy6XHnMm4ukR6SJDSpSTxbm21QN1dyIuUfLacuVbc5BqAs1wj/lEQBcBey/Eh bCSGif+0pVRwRK1ve4fDSjibIIIGNZwPQN9MbWiqiKPp/qtt280cZ3prL0oI9Bgmqw8ToWzUafvs MKhDOZykz9zQnvoaPoobgZ6F90T3V8061+QnX2naSLogOtmhSFIjXNfvpQEktFB61AYCBBGw77Ue COZHoKciyV4Ye45hdgMgomoT9NKw/dxcAHsz7p62ICD3VCpAWFVSayH84UmoaVOsTeP1TgClyQg/ rCyS4BQ7Yn1syxRmnNw2yfbiwoZ9flm6K5zNdYkNnso+w+LnBNDgPajoWgbB60/adqf07m8fED6i PE2J5qGVOfIN89wNoVDYA88onk8G50Sd7107xQ2alt7h81D+hOD4SdCMZPFa4Go42nkJco9yZR84 zsBuX/3kn2WBb4Q9NHwkhRunVxI7E7eHgHNy809M6hj2jET3j1h3vVJeJqM09Pvick5SartZN5mo pCD2HxIf1NAnA9lHF0j1V5Nrka/NdYG7q/G+j2JzHuGjxD4u1I+ToiPnRgHg1Jo3lTChMbmmVHgf FHiBseChYDmDtE0o1YBsQ5I4hJeoEhHjkHnqQBDQVqFJADwk3Qnh6T2hiCsRE8YlgKjEREcXblXK PJOYBsUfFHE5qHbZwMcL10D5jSTy9AHiJu9SxDrQKo20fL7h+MmE98h2NitoJ1WrisD2AVjnyjN5 lSdJRIICQBWsAoIkFBinojUPSwsmbQFYj6moojGYtrMCFYp5wn1zMwhzgkq4iFL4H+1PQSVwDCGe FQ78AeUupNnHcMo6U7peTUrmqOUFylSXosLyAB8oAAZMzOagh9VglJZEghkn1dypke8ndq+ZG7a9 NS0p9K4vPhH9n78ExU25tZOgN8KCYOcthgvtOKhiOERoVKthJMpWUoT6YMUbAEoVJYHZ+60Q13j2 V2wWy0AYX9mZzQP3jUVntkH1aH9mJJoa5BgBTEBQhSFVT0fg3tfckBabmX91R/Kf58WTlf2e5Yue Q1stO13ZP+Em5MjA+SSFgMgTkwFgrWkJEFUAZAtVCaoTUUPxXgubWTDvR8f3TCB5KId0onc+2x5t p07/QxwhC00HkTzpHmEGS4uMq+bF6hKT3o8SgmAaZNnsIwjcPvYxkkR1yJYcRcKkohDqW62+QlmF LR+SRLDFFxsTqkqtkD+aMOMREQnd9C0B1BkNvaFiqcBTW3+Z4qMmqRWP2PsLg5jsJfYTWV9qHPJp J5QOQ61Da+gPNNoTA4Aw4n9xAJcBOUNNxOR7ozAoQBzYDmrPgBMLFQgRSa1ZLVXKc2xMwxT7hlbk nCJl6jzxaRUzkgUlOQZBEUqTEkBlgSFkgfKA5aTH6oPQfEbCvPLaaikQZG+fSug7CRdNZsCjZ+vM hIpEJGCoRZYLfzH2VXp9M4Bo6rCGN/NJlVKTZJoq3fcIRpS6j7ChFZM6sItW9O17hY5Zwkt+v2+V 2utBjQRwSFEniiOxNUHWFWBhhY+uic0s3JOAOicuYQx+YMtEJuNGFKF8FvCzSpFAcQCWXx1InhQ+ 7iIfo2IOCW2XR1HoOUWwd64c8qD1Zdm7BlazlcPFITTYCzyD3R1ok8+v6rOvjKI8++SYHJDbTB0k lkgeg8HOOHzsMnVpgNELhlBbaE1h385zCJiJRh9JocnCSXmh54xioiRAPWKML6xObOahQfUc5b84 DjnM06jH4jQaqv5QT0VkCzSohYgjkQy2S2XN4b0ZLA96h989knviNvzycD3zi2Ui4Uc0dtCqKVBF FGIqqkUUiIsigpFgqILBQVYKRGQWCwgsUBiIDagL3ildWofmfeCJ2jq3DUSlWPxoE9/619VNzE2y QqhIVUkO62uyZZ5wSWD3SHH3wO6eeH3wD2SB7jILCKKLBRZIoosBRYoooKKLIosWLFFiwWRYLFiw iMUgoLIwRCRBGFw6HBx91kOPQi4E3iYMJq7aj94GAUWBRN7tK4R81AfNh5yJEpEiUmTEYxiRJaSk tllKUYxBBjGMRLSFIIIIIJEi222222WWyy2WMZbLLZZaUv4LOSTPPxJ728OznA+KSWqMKIl5BDcz W6iZB/KKmoaKkmS1TAQJHH8AT1cqcFIEX5wEj6EEt4y3TXv8hCQsVYRYe0OiENBmohAoIQHyAgmx DCpQgUd0AppgYBkQd/xGZOTRW6MkBpyVlAlZsVPt99dEb4T9rwAAb2aVWn+J/PFqwsLGFZEQwNxM Q/fUo83kvOTDAwwz0g1n8AcgIv2EASaGfsXGfu+/3P0PuIIWIEtWiUXtbHdsS+BLgyB7HxO0x91A rPlXuu5/AMBSp0O3Z/Ep4cDoXQjgloXiFzeBxwfS5ocdvBsCKJC2Msaw4qbH4a8kHgwW9HOWLncy 9DUF1qUnzmrUUJm7xDVh/NtdCYRv07IA0LzBrGwho7Y8IQ3CJp2EKLVC8NqxyIgcgQODFgAREVUE UkhcjS8t00xsxpGd29s0xYKhlhsNIUlIoQkAQrCQMCcWBkNYmSyylXtyALFQxCZqvB4mMgQ2hI5A mMTAMgyFkssVKkWi3jeKUV8Pu1doHTRPJKPqx9lyrsRgKQI2gMH4iwOUQ+b181k0HMBWqWQAfIEg A+279F7OYHB5PBQ4gHirpxSCOhfPYUbZ0ihEHRUI/EMrJQaiwY620SyecvBJuvgUyqyRRtYyKQSb bsAwJmWYKG1KGmDbIeCdntfBaScA9CRk1veYtCgIEiAYLHSBhmV/Fa1cQaEG2PubAJJOExgkQrJW BDUahkbDYsCmhw5gDkMzYeVDQSY1vXlETklfCkP0F7EWihN0mSKdLYNfzui1lG21qvJBbSdg2pEE FovlFUB9kV2TGBnRmCQsEFBiEYgYgXE96JmEJ8pBA0mDQ4lhMmSCoGYVPxZKAs1Q0q+4GCPZ+QJx dDwiIWDSoQpIC4RfaEiBP3QjJIKAsF8Z0ul2xTJJpbUmJE7xrT25CXZyQzsh3S8jJ67eOXqO4+Ro I8sm47ypO5Ml0WlO5JD3NESN2muwMMHGyWV8jlWqoewOQQ9kKY+UGZBU+0MIQaIZJIo1kAQJ+iUa 0oR55Ot5g2r8oNqTAfVZAGQOFw824VOtCSpWtpk4bjnIkTl1QSIUpAkhIVqKjaazjMytz9zUPVtG pBBvRF4gXqKWI6k6LIdQB0FLUh8hvm6P64JRqNI511NW4rA1g+T98EWg1prdSsgZlhqTIMpIKUYh rIglI0E5PYTmT4/Ltoqsbn0vvHYPDdJDg2rzdGDAOFSMCUneHoPZqS2pKrJmbTdA/Edo1QHaldT8 U3bKwNT2jktfnzA83K14j5rUo/1B7vqOIBgmYaAdYOgSYtUu1P9/F9BmQdaVJ7Mgf/QhRDSjRT9D BMw71DPcDFxJWzGU2AIJpIV62YzZGgE6Cn/Jga0LIT8L1IbtqM0f6MqVUVKUih7o7vcR0rsA8xtj d513ZQy+L9s6cAfy35cQfA7y4VT+Z/doQH732VDPgxAiMAMJMEg6kqHSQZ1OfiPclgqwqKOKH0cx 28CP+wd8jjCQXTjmfXqVY7HhI5Xp7XgSPzv24nFCqjXb+eMDmJvBIXmKfiHoOtda/XpzG2CMqfAF orEPP0dUl5whzroqiqOw7A6tJ5KGSocqiPKBfFGFooOIpUwTW6JAz/iVEBJdYHco0R1N5Fw4j69i +iPIE1jWoUH1bZ4N0nxyByGd5ekxPxG0MzBuNCutWt9YETDN85fFKH3o6HsOv6I/QDesIwJ2g3MI OOGUEuDBWWdIIVU7QwSfj/GO87zuqA/UkzcjBkX6slhBGGJllQppqTpPROolnoE7xfg7OdXq81xM LZXSBqS4GZv1nHqhCTfLGf/kS0U2Y8x6EwDxAxTqg8A5AmoBD2XrHr3YpjffakRJilMD0D9Rifbu e5uTRPhlJoE8/IDZ/DmujbirmyCeLB5DoG7zRKhfzFOf1BxDwkvGU2yHrfkR7kfc2pv+XQl8PYPW uk1hO6OMPqedVSu0TypeXlLRdRhHGEgI806ZztBNnfgdadTtcZiaUvcVNK6jyDqU9v3SGUpIdpiu d52jlQrCKlqJnOOsC0CQXQGGuQBODw4yZw98BrHwZQOpxZrRdQ3vWO2pS4ITRUOR4jQykHaOxHQJ 1Ad7yV71C/iR34+A694BoMwGUdAH0EzDIe9efJ7bQzI/AC7BL3FHaJ6SUN3YWI0BJK80NAJ4ppQe 4TqE/UUDyeotPPWlQkpKJtksEiTKtrSTEyVCFmniF4m7mZwT0F3I4Br1j14gl3I2gm8E9hLxeAE0 HkNibNCNBE/rIAOxB2vajqQ5JkKBmRxAOgVqHUBxTYtiIa1yjQ1tBVNOK0yUXeODcZwag6KG90Jc jYJQGEcqm4bRPbaSLKHnG07EMkYk8t25M7zXnUKxUA+I+oHg5i3SLcLMsHY8HDFOyXZJqZYOIbe8 Z100jpimRMYxcHoTSSApMjJm005HTBNGuuKbbNxBmmmmAwWcJwntkKqFUlEkkJAokKK9pkZAMHSX JXqXTaMb8VSVrIHeJxcexciN+sTMMRB3Dge70N4VgYDrHBQ7RzuZ83BHrHHXYrvlGyXRnstsfrG/ 5+BHXD0jfZrJgNj1jo3sErcmsLTQwOtYUNwFaa7BtNi69y9g+xwcgJ7PUKunino9jSDqbnZ1yekU mbtiOWYImbeDgAbQYAdKqlitSZwTxRyjnUKX7gDxat73m3YkAmVKh2jzNJkJDKTDEEERiLmVzApi LU1k0dWkdAnxO/Pt1O9awtD0IG1uRyck0bRcyyKDDKLYjwBFkZxaSmukDBZNSDJbgU8dy6mpOg6T YZEaio5gFS71Dc9rgwByTQdaoTUOoDkzCpBgUyC7xgNTIfEd+ZeiawNVjaJQDog7RK3eHFapApcs g3glo9YawSmgTUNgJ0aVOpzFS+AhgJ3j/kew+UP1A/2bMKP3j4in1Ck//F3JFOFCQ/5Aizw= --===============2145766943==--