From: Bjorn Munch Date: September 10 2010 9:23am Subject: bzr commit into mysql-next-mr-merge branch (bjorn.munch:3207) List-Archive: http://lists.mysql.com/commits/117981 Message-Id: <201009100924.o8A9OVO4028133@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============0329837858==" --===============0329837858== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/bm136801/my/merge-nx/ based on revid:bjorn.munch@stripped 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 === 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/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/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/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/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/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 } }; --===============0329837858== 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: e750aee85fdfff2671cff5a509f3aea8490744bc # timestamp: 2010-09-10 11:24:30 +0200 # source_branch: file:///home/bm136801/my/mtr-nx/ # base_revision_id: bjorn.munch@stripped\ # gh9wvb52yw2h2yf4 # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWbY7F0oAbBb/gH/yFQF99/// f+//7v////5gg3495O87a9rjz1lbPcucvjfQa74PpSgDz3sj66+d7nXZiSA7zvvM+3d991ePu+2b 69tXsppqljwe973nz6wffUm3jqjSq3bu2hnzvfXnt7vrb3MAO5hVbrOp18dx2KDbUoU1vdu9efYA fVBQfevnPQAclB7u4bu890O2MvrfTLs3YbfO+99cAAA5vM3D0AH3YL18NwAAB3BzgAADtdnm31XY MLaxpaJJprTTbLK20efA9YWcB49p4HoK73aHvAa2mc6Onl56Xb3e3Nutlu+X270eJ8y+e89pmnp1 vL3s2hrtwegZ5Sgqk829VtKaZsBLbW22HcatNSVXbCt3z3hzWZs1vYd0Ux0NbaK7bMbdupTTq++7 zyTfZkih4Zug1rXbHryKqV2pp1qnd3HLA7GYSSCAEwCAAIamiaak9PRT1T9Qnij2qNNB5QeoGm00 m1AlCaABBEJoIGQIEFP0o9QGg0AAGEAABpk0ESoiZoJk9U8Jij00gPUGgeoAaAAAAAAk0oRBCNGp tMiT0xKbyRG01PKenqmnkh6npNMTQxBoM1AARREBAEYEDSaZNNMkZMiaaTI2SMiN6ap6aTam1BoP KBUkgJkAImEaaaBGp6TKn6NEym9RlGgNHqANAANDS9cJlIfxWEAzQI1IBICFJeNnlBQf5loJ+c7v WYx/7T/wNgNi1WKpIfiJ+RdcP/wchQf5j/Ef4j+JUGBMgoGk/LNnoH9eb5zIfZu+nRH4RDRPwJAr PL7ueAOHHaY8g2+bED/H7KGon7P+AgOFwiP7Pcj2PsH2TPve99kn1fYg6u0/dbuBUoISBKEsmLvJ OThDUoXbwkcJUbdlm5j3hAA6uzwYkPIwPpca+hn6ny+cxsQ/01NcbkMNEFUFZ7LAlYZRYFkMYbg8 AdZ2MxP9/tft9fbs9V/l0YmUf/rMdT+NEXErM1C5fyKz/E+NdUzjiSFK/lI9/+TMZm2D/8Ik7pG4 sSZbkofYnaB/aZP6B/Qp5Ijb9VWnkz6/oovXsbrOq2VJC+h35KdWKlFrMY/f9rZl6eScq6Fj1j73 xFjRwWid13ekPiXJxcci6G1PLDHT37H+yZ/wgSiP56Td4qOGTdw8e/19lMM5nUugcOsFmNuF61Du OGuaX8L/15auVb17P+KBekodt/M2ZXn7df06v6fvnzp91xqfWGA5jgON+r+1PiJSDCCEjunQhFn9 IlSGAqzCSMw17ZpWJN1KTmt7vXGn468vE6YyfL9puggi+0fhM/r/fGnjuiDHi94aUdeOJ+qkyy1m z72bjIgdeXKvZU5eKy6QtXkQAOkhED32cKcctKevo+rnro8kfFVXNzreDuTY6b5aXblcMhlMKThm wprs4RLZJ3eCd3BW7JOcdpWTM1VPmOWjMh2Nm93Jv4c0eD1Ex8AXtGSSSSSSST8+r+Z18dPl3l8v ZhqvyP3M7+vcMQiwO70Y6TrC6gvTeOP8/O3TehrW42VW4y1rWvi1ldCLb0HCYY2n9Uj2cwahzeD+ +KuYkYQ7yeXWmzwfhCO5wJCT1sPW+hPV130vmRc+mh60w5HbNA4uxZGnl3MauZgr5jZAkgDZUDbu YGmSNMdI5ishGLKMDdCiNIAVITSCMZ1T1zS7MGOTVAwgVFRzwu7UUU3SBgu2tb7dz1gw5qwhx8F1 o7zgym10ds0qIfRNXkYSEr4Qklmg5z2J2j8vnz52247C8SSDycrpJOGb5pmO7o5OMePsYj107HDD tPIeTW2s7VrtTAZTbbOBy0UNhdgZq3w5t1NGW5MJjFA6jw+Pn7uzor6nsooqmV4ZX3xwbRyJSCE3 ikqUkNws0pSaHAci3cRrNAlcdDCphTwcvFa5rzU7CPNk6uU+bN57kCIUk9Y0IXWc7eWpM3OvZkrc T35P3n9eyfCrhhFuym3cWcEhAjwgieMYWzL4c2k1TNS4TUuYuhAap6e8jaTfLR3qNZrx4N0vk2uw xPX0ndwVR6o90Twv6BzGYZCBYYdHVfb8ZytnTapmYNYhCE9DDF/ch/gkgHyosk59hTYfD7cYiyfK hyIwiwFCAsIsgsBEIsZhaEuP7uS+73SRtv5JBym0+2gFyx5/52eGbaSDDDFOvqeJJahgxfV83zXv yR7alVGKhio9PfwUXKyf/uBOBVCqPqsvdA/h0aery+H0v0zOTyavLS3GPXZ23PH7cns/JqKaFQyp VKqqqqv4TIaO8S15487cZpjL6ADWtNsS1kiYmgoZQ7+X5oS6Hw1Sb9+vt/l2Bbu8vyUB/BCQ+OTq GIqREkgoIkhYAKIsRYRGAqMiJFFYgoKrFEEYoqiqwVUiqKqDFERWCKoiRRixiwBYKxhEQgqyCyCk ERVFgiEYLEGPvgzVqqP3iQx7u38v24NOlfl8Px1pVb5GBtoRKCqwREURFRIgwRAVVSZhMyTMJHwE EQLEt/4DAFU1XHwi2NRJa32jKWG6Ue2EoiwbBJX4CQ/UMnyZywc3iE4jSNCUJkzc1qHMyZRtzfKY Zc04bSRSbJbohEcalkBEktLAkCWXKqVQIfEMmToLBlYcxF1bWrJTtUcpTaCGrTtrloSY0gEikn25 4a4huLRafVZpoK+c7yw0mq7VUqbKokp3nOcVB63VdFixKvgsQysiB56EgV3lnyvSU1wh6KUipRNe Yt9JVdyeBjsrprWZwudm8QFG8CwEErGEMl2ZI3YTzuWSF0nIlbBQ0hOMrUxi5N1vPMh1hJRYwq7G zp4wkYqVOpnSAk5BPK9Inpjlr0joQkD0QFXS5Iz9KWQSWcE9NkelyKY9CwzRFJ3WciUYSdVwzKqQ doTd4RzOuEOfzP29F9f7kh92OA5x19omS49uwpPtm0h7QOYFPtXPKXPrBWbKwsCR7MeeMdoKMwyL l0XSs0DL1ISUEkgTbqjSFDwyX6uDl76oHPSK4JNITKHV4e3PGBZje+O3UDpw0aYUmijhRnUpC1bT lpwYuDFUsc4+022eHh4eWslWYZJDlVJWmns9gjyAuhugZIw8LaCI0+HwjWtBGgiyUFicwJK2502Y RDaJdKLtR4UeGjSXNQoxlWMZlAPmnm+QO4MtUbPT0pqKpdxIs+cVlhKTZZl5Oc7AzajSB4PISxAK VJjpyrC7C0ujHp4Hzj6R+Kdqzmxku8w1D440rYuUUcVF5/C9abFPt18x5NbPc0euk/FxrxH8J+A+ wTp9rRZzwl1NBzNH7On7ZgP3EPp9pro/1M/YsNMKkiVYn15b2GZhm/E+oWH5AiEWZmcG0KftHuUS w85aq/SLjy7/NwXdrLoeuP7KaV5k5VVSR/b4ZXTq5NFNik5qc25kkfB7/rvRdcjmM4+vH1vqOMnD bMo/iiaQ9ZOgzLgaPB9IxOxEg4HlQrRbD8Rwha199e6b8qGqA5FV0DJ8pCkJ3PiccfuwrDh9QJZW hWK8wLSY4vN3Xapf7yUmGTM0GYFNTxoH/09hI9J7TanSYoe8YF8TRJs3QhZLOYDkamEP0WvWEpQV k/bQwPJ+jYzOhBznMMfxFIFAwFPMIxVRiB6EyTJ1+n2/IcvPaUe32mE5ryl/rn3UnQFWnV0NSm77 nDLm/ePTSSQHSDvFMFhEMBtIoR/hTRb5NGQ2oEF+9jZD/EgfoQJ/oPCNiEuoiv+1JXyp5lKKvCKQ /r6XmRZQViGoYpBYW7ZmknZNuZs/u9JtzAuguy2EzHqyZKb411fPE4DGyWz4taRVMlL7p209MLH5 nBN560Uka65JR+lZdoyGGGizmbST5yEt8nxL3oKcPnJXUesYbU4j+lp2X62jJvoamO5zTSyqrBDn yuN3MTfIrKcx51Jqep4ADDmwFGKFYThMb2UgsgnLYsaQiSj7i2gXRvW11QbXlNUSmmepRezft2Vf OBdJFPZKmedilCKw7Iy8wufba36LTaY0smLJb6Ip+khEcoWZpDJDLI3X5mEe4QQeAosFJON6/imT 4/5a3KlTg6KugiXl00FL6zQ0Qi7SE3HgSf+Sh/6RxCvlntG6uEW3C3tz1m4UjMzTqipw3Kl9OTSo eoM5smZpUygpnD2ZlJO6UZWKV7XpshS1EUeW5N19Bqi0/F44pksa4VA6OqskaC5Xc5v4qSErpcXG D4MY8peMBlow0lJfQkVmsan4+35OfvQRlKH12OipbP+WeJU2nq8RI+3C1vfyi9L8SCVkFT2XsWA7 wkM35tCGz2NDYxDSJoTMlFnK11PFx9pzPh8xkf4v+jmdPpjkc0gFAHQyukf4IqLG2LpRiG546V0B hn6PN2WZRK9BIj9J/oen0JyriYNhIqkUU00YvBWVRf4SzPTtN6LRn+VavH5+/wotZ5rEWGd5wS8z R/REATnyTFSfM4MHOfyj0pMTimOqJE9IlqdRy44g3HpB4tVJv/6tmBFaZEwvj8uwHAjz+JexZmN6 ab0PyjP8Wn0OMHeq8/xIPGjSnB4Ln/UbnvcJE/1qOkD3AAG2+60h+w8vaW1XwjlKQLv6r8twq7Up 7DllZ3Cyl/szi0NjFTrg/TEDYuZ0jnjD/IOaz1H8e19SHjJXFS382KE5ptl0vVseqsam5vr3J8ly zN8jRTBKIXpgTwj1DJuaJDBsSkmDAffGVU0GQNAhg2EyZKUpTnsHjQ9Yniaddz3VPDR+KvdSURNp hv4CQCnRZVgzxxFiRs2ju2F89VD/G9x6B1r1/a/E4p1iab52R7pT+Uz7OReLhc8zypQe9EbyVtc7 2+ZjWsYFIQgDmWguHWP4q2vpuC96viC6D2F1IVlSYXSs6ylIh+zzWTyN2czVp0mtMr0vRNZDnMQm KGMnq10vY5VukaZiVs2Q78qFJwnHP+9j5xxCbgiq0s3asIKsZOZbbprJRRMaKtBlSTGhLrssphbh NXKHhqLNWW6PHKUj5Jifencn5k4J9afgn7E/Yh9NGj1PHp7wt/cjIqf9626yqmuNq9YnCxWEHafM pvFv5MBfOObEmiQ5E3fNt1Scmwbbq73Da1iLoRJnOfGJGdoTElhhyCIey/uPzBwbAyS9EvSU2TZG +fQ+0/zummtVrND8zCWOE0m2b2p7D7gff+EPRVwGSAIQEPxnfgoVq8eQ3u1qfgSuWw7n1uHicq8u WDni9OEi/YRIWcspU45Fpm1tpbarS3zwk7erveb4+3145dGduPTtdd0E7tlr2hX8vQ7Iryr+HLnw fArlrjCmSt+mgqZlujlp5k2drV3q1YygZluDW91spJYeKw++r8e7+VtWFvT77Tvna5uUmQvQoUvB YeI5wUU1Ct9bJPvFGvdbGsYmQWWbRVr7WEKapKpdO0/MEREP8ZfDz6eO/Y0Y788aML+HAx5st+vX hMce/nCIVEhgAVPWTK/nhSKiogsVVWIiqKqqnxDJgGD8BkDgZmG/d/UDwPcYDDvkYPh/g1nn0u+M NihphViAP3kCnMQoyQvx/VL79O3lPDynY8HHb4cXVx8f3dcdio/IeDlCflANUgfoBPsSE8byNFkU n96FiH2M5/QYMU7fmNbRBBgcDzKfwYju5XnVMxO7gYwg78/6O4P/Btn2uLExP9oB8bNn8mQxpVAx w3Zv6MHnc/mpyr7Gj0xvf41Ztz15IMxAibD/RMOy1NIK1G1kNeFvyvr/nVF4RqX9s7N8CCh/wKXT IfJmVT3gyr7qkLXwv8j0HNsuUHzKGs/GttU277vNecFFULry0YWN66FlR+bxfyGPsgJB+o1DgiN7 tVAe8/hln0dheYnWEZODxIYd6mZ1fofyasGDuqq+tbmaJis89zySS9vEx20Ndc4554eBVXvKIGon Ewx6Dg4nE556YFVG+lldU68yAeLlZ/DHpD/Y90wwh2ihej+nLBBEqfmfxdZfX7h5CPXFDT75D+pr Lf1E8W7cUoqZjkkUkVCoURUlA+p+sfJbAqGeAYQFQgNK8kLnHemXXnWQ3s0xkPpkj02AvYsjn0GW jDGDdizjCqqZ0jdNjcjJnjE2JeM0qQtJfhDWiCKfBSn+0n7BzOfMMCPUaOTnSRuQPfC4wgDqgOEh 65x7XIMxlwO6G/nN+XXe7MJE4uIwb722FYbojBGyu3ZsNxMEjcTKYVCcpDC5XOi2ouhCq4AEQKFy O0DOOJjkocCY2RjjsmYvkKJm9yj8aTevhMYBpvMHSovWi5jRbZOINyeN4FqukoQrzLaN0MG5yXo+ ESXowi6TAFCblQ9TWO6GBwYEu65jhJLRxSk7yNUMANATLKxbFFosoZEv592b/DgcKZqTdPRBTHdd X0mocOwI8PpjTOSDV/Dy74UHGx3yw/VhzrJ7jk85dL7yEH12Rjj+T31FQjyLgPr0QjndCD3wXJmH 86fBuuunwZb6ypJUVOOm6WMNTRi58lCKBDycJAxPYMgXdIJ4P1kPRKCAwhpXxrXFx2PjcOs5ExMr ooFkmIGgMyZkmpNY1jOF6gOKSoJaDIxojQpSkZSQRS0QEjJSEQrYShZEgyApKSFCUCRkASSQGEgC UVEtipMBME4zHrzmnh/NsHxqR0EekHYFP20MoBsBEF1MNpQRGdxkIygR7JGZz2Hdjuw5VjcvYMGK UGBZWFtAqNKFtuQETsaVvutJJLi8IogJk9DIeBAT4yRwPuD7g4+/yP4/OH7GBAvPZ418ULaW22kt ttttttoQtoByxjBbT+nuPm1rQW0LbLbLb5O7xa0vaFu0tstsJKEkAkoG/M5Hv5Am3CRKjWS87vur 8IX4af4wmZ+6loS+/9HptTdXd+fi3+cheSvSgVd18bQ6OIrDVMwfS3hGUIUWNGeIvacvxlmbkHX/ rKogleeSn3mBMyH9Q9oTFUJyZ+bME7q+/Kadp8FXdqCOXfgjtjWbw403D3wkkNuFCRZDTDjtZOLO KSjpDggVCHJ3STiw3ZDCGyE2d2V5b3SbDIcdrvy1gFm7hA3ZNmKVMMMcbMYpIZScRDKLCTgzKFxV rBQnESVgYZNMCcU4JJhUNlxDY4pvjOdrVEmaduXS5+bSNaqiabWrNFtLBa1IkiEMluWJCubIN6jf jIWW4SzWhVVxdgUEZLmEMBSNkSSiX3o2LlqCVcstQmQcEHCyiyrSo5BKgwASyCQCWLCuYkAkEznp SxKqsAwQsKLJFZKiRLFzvNl8Q0UkXipBVCQolQRVSIKohhfuvZJtyZPu/HBS/YZ1WUiEu/zB1dHL Wrx3EySHA21oIIDEUQyKoWFFQJBqjJlC2ECsImkyRKTa/FcrmLhYZAoqTGpiuTIhooCEwYLsYtqE gRVIDFio4yzGuWDFSQf839fwKPdVCQZwxVYQYJXL4VEqKgBSkCAHItIyLUlSUjBc4K2Rc2CoY3L9 VmDi158269SiupvWGWdYKuoWvQQICEwTKCSJg6CIjJKdiZkyYPOs4SsF623CeLZiYSZ3WldWkpx1 gOf18woRYxyXFKt96ImLvWAMwgxHfBBi6JEiwBFULEiigtEBeVSFYE8CMAkemWF1Mk1MFR6DNbss WiNaKOys1mW4zj1HRAmZRLqCyDeAyW39QlgBUGkl0bDE34ZjznRgloGxdgGIgLsRWIrKToFuEBLl bCqGTyD6Pg4xLA2mIQWEButIJppaOQIlYQAyioQqQEg1aLhKyC44IWzF9ZwtOYvzxsyXAKSRBEVe WRjjPJsyRUluZ/JE3JVdVXlE1NM4IgEsCNlHUKQLZC1Im4sLalLrhCgBlkQGBBvXi/I/gkUZFLre Q5HDRhFlYxWzdVNGLdjTBFBktIMKJDjXE6Wk2g2LDiMhDqIWgSUejUteLyRkDoMHA62YNTUvpywM buEZYk11KrB3fUJSCICTRtVzheIlAYFEb1gVShAKBRSLUkMCYrZX5CZ5EMKymxeYr85MpjvkURHQ RE2XqpcmMYgKQwKTRyIqZLSC6YkqlSFBvLpUXMAUUW3NHTfARaE/0AMmjgqZMlw5NwF5GgSDHAcT 2EEaI9QJcs0yxkbmxd7SJCyHRSTWImjMWuZCpHs7OCuC9GI2N8CROSpkUwYKjETZYb5iDnNy3FX9 yPNuzBU1tHc0kTHLWFhE7GagSIQnMyZpv0bG5fMeidGDFi2G3RdElRJe/ENL9jTPw1WMCmzhxNks 4umTT4c2GnysG17SeKHUy90nzFYkcXZCOlf3iMAD8DXKCCPsWSqMf/1STSIVev8wssEb/P0A8cd1 AwMytRmN1H28mOU6R8Z5UVV4xSN81NBNTNFsQUtiufIYULskRcXs35YdlXGqXkE3YxYnKkOaAFSG UOWmvJgURGkclACQQOlTUxZ2gtNS5irnErFmnDAwmhUNk2RSCwKgT0Aoal1Ij53l7FctGmVVwRx4 qVpwXXa93fw6f0o3fxLLOGYzuF4UOzOHZv7JJsDk+CSGHJKqsdfArCWJarVX+0K89lEVnbY0IIth 5hJd38QwNkkDgQBSCAyEiSQm6gIsghQo0VQ4EHjwzQBYeuMVCoORg932nLK9Sh6lprJBU4t8nKXR TDJzL91eIA9UYBVXVwRZjh6VJhTqE/mcDkDYCXJwlatu9zfeiTnivOnXJy0X3/uiTfiG9uguoRf1 WraW4yDsKJaLWdIF8t3PJSucLUecgiKWgfn2xac5VgiaQUQxzQxChCK0AqssMSKzJVIyItWWwgqk gZhwpgU7t1rtU5WtJD1lNIk7okvZN6xuNKbUdO/eZda5W0kMc8+TO+SxNi7DLJn2aiem3CTZiGxi tnDnZe2P1rkSIgCopDWyngoiyDv4oIkhYm7JQ2eYdV6VWYv5q/s3r6eeLXOcG84edfTVHV7jXgPm VK54rTV5uVrO8tYeM5UnhsY2Xaen3JdC41ZiE7RwsXgarZ86otsVjrd66g8KLQ2096bCCJgW8iYa MjF+0DWFU6FNquUXgZGQQvZb3qVQkiKJmpBHC6FG5LTqA8wTGoDqYxIAUuYO7j20CEYVQgcGyvjk maK0LhUpJVnQgiFLqUtXqQaskilKJEgMk+KhF6oyBU0hYwWvixwgiIFkCd5jZqnLG8lBEVURTIbF YN7hD/A/+T1A+Ygod6QSl4UOIF0uOmJMhuJMA6IngWp2MlFUtqSTrDki7DoRfdxN5rN5xaar66Cc vPOc2ILIyBb7yQmpweBnFKZTNUPqAeZ5z7pDVOXiM18uHVaFc9xPAtHPKRZEqjAZwtdAEDAvDAHn Awdnlfc9jSrszR6EYgmyRGDIm0kXRgPUcp69w1Bio9LglKUVFnESZwQIKO1IJf4MjLWxfA6JaZ3/ ZchQzcdqXhq8lVTW6AQoFF2o6lLcIgXJ0LSmnBKo493RAyeS5Sfg956ubwFR5U8PmkyVzGoctU5D prC63PUXGJoU3BRTbQzYR4EQiMU8fKD+RUkKlNDHYEO6myRL6AaOYOZsCrqhWJoDiD1WA2hBFjJJ 6UhmbD6bpqi28qV0rQXUNGuGIe1TgFEfvNtGUS00ilZ6MexPA5xbMpjVLrat95YJZfYV7sQ43GBx RWVkw2mi9DTtUc8GDTLseFaMl+99yzNmp443qhtyUoi0ECSUXCfY7s+qQpDTSoD5D2CEfgHk2S25 rcIFzJsp8lgfAOVMIOUPB7hYzVS5TwfDR8SRiLg+uTZ9cDmgme5o1Y3kcS5RNcUWDx5KT0ErEryS p+tWm/lYSFazATdkkIq5Dk0cmzl+TOdEh0iU4G8NaQfuIfWJ45gp9XNgShMYX6n0GOlEfoVVZztW 7sCiJJI3FYZBISVkTXAYhea9blNB0ZGDMNH/blNsSXMzpEZiPofZIZLbfYh2ENLH63U8sryVxsxi cn4hQglZLDbibF2PmBifA9eCthkz3UPc9QGVysGC6wPu7wAkSZl+zxHhP2z5N7R02Y4KokKLODPX IgsqGJClm9HOAbqg6uUpgawEYSqPZERHdiizbcwxtT4q85GCX5KBwbQVwYJNRFnl8j/IBgRD/qgL KNSzUVtomU4CXfk1xHYB4/sSdXNSjJu3yFm3oFzkwuJTZjdkamW3RXKy67rS1Ln3X9BupI3KCeip CYxUhgqSLOu6qKRmvkkSG9helVtbMS/jE39Eogc8iAnYjngJ5yJ3UwQZzQ1uIceBRgef4FgxjljB U8x1lU9HhhV8wlCrjkx4E0SwCUA9NolmIEQSg4Jl17svUMnmOhwmwWIFXfNBKTeHGkzENRhilcvJ Utuh2b/mmzo4wS5Yr+CImzahV2FjSVYDo0HuYRAUuOSU4iQLMSMBFWMYjLWgVCYqQUiyJEkNl05G 7/cBihhU9IXZcQIcNocwFIo6ijqlINAQ1g0CBQEUoKMcipWMYlk0DN6lqIGLCpjGOusRT0O09vY7 C36xPIp15NlhoHOOuoC4bwi92hMp5IIqQSEElNXiBRlRcwrZKghY8gxUhuWBacQkicaBIAkEIu4u nIx+t+l2USzbOxf10t1ZnK8jvFGjTeTZOwYYVDCfWSA9XkrviifIlyyJ4tYi6l+aGqLfwAbXRfDd UJdmJzsFZGvQ6B2MER3c7/gB80eY7w11FAaRfm+BmarBEZLpLAIESYaLSD8XvUBSnwIIEbGFYwKX 6GLiil4EFi2DzBcV0WPPasegoRlkmB/L+gHgR9ZoiqsF0zcVjYEDSCiRcErVMLcjPZOBTPM2SxOB qVRHAaJaDuEQRFlcIDSjXZMkJPh7kkgQqTPWGVgohmsMk5l1eEK3mCYQRMTnZfZFTu5khFIFC5r2 scDRkXU+WC17qs8QfqDPCJGkjKJuJPoyJ0QLmsYL2oQ8KOKniPIYeKKaI49tGPLmQU4PNSRw1jUh y5AuNE7TtJQrYJQ1sJJBRdzZl8wae4lmC3nAcnt4NwKKOVD2m9gcgSLkTyJUmeYXCh7ZiRKaU9hS EfCOUciQyNsrAWeDBU0V2W8HFdUyNGDlqxe7zI7h3pOrT18uTo2uC3Rih1oPF1w1BOjxkZzB0Jcl L4gVCznnnIVOQYhdcWkxcFxaZ/IRRPKNC7A1H2IxORs+fsg6hY6kbrvG32qYLwULFbG40JVDMBcD v4E9AqO8Hynw4ZQn3xNE8u03hjJqXHjtwLe4DiB5QVcC1p2V+HJ64k5JNNW+X0UjS0NRLGdpXG+x C8ibWWwUtAm0ghEJRmlbvebwuFBQKbYpTJkSe5vklzbTvzRmjx29lZPOIbiMhSMF/kBcDCJiiotK FF9k2qqKKJHJxuo2tEbfP0DQXtqttuoCqJVqg0RpnbK6Mt5Wp5XasMCdU0lwguz3fiGYTIUqqZIV uzWo4V7C8lJy0EpzNkeWh4G4dLi8nfiXLvGhgOJZKgiJk9L3BTs90gYv44ArcXSrIE2jmUqaSQ5G bz05He8Qnd4PC0c0JRBHgpeo4JLZMvqwFsikTP1GP3kJu3gBOTNRTuDVyY6OnCHU0eJmUBsVLnEr UQUQUIku5kJGzFnQRzl69jXShCoqirlXBAoBQNWcEl0r9g3UTZvlNFCZmLbNq1RUo6AjA6VY/m+n kfaBU5ERVR+uCZZJErkqc9GwsUbkn94Q66P06NG15GMono1FFStckGUqYRAk5Z1AFUyQIkCNBjk/ o0jJEvciMiBGcOleuElIiCFORiCSYycotTRckKNnJaThk4PqjyKo1kLH1XKRNEhz4GC7FyRadsRk srZ3uFN1jNobJo8pOe+saV1uzPckCJYCbmrUHXincglkpAwhAtYVJIqmIWVg34KaMGrLqObqaL26 7V+iSfGYNznbA0NwUJXB7clDh5FWq5IhYeQKQVYArJkqWSBpD8rGCJ/EDs7dTJydoiM/irYV9LoW HFnI9crUI0r6HZeXJjguyIFyKStERVJlsE/BYyVjiJ+yc6uoaCeTgaGdLtAWE2imhjSJOIquPCyt WpQZ3909vVE9esKenezfpI7JkjrqicIu2GxdUkOSYnm2MG6JtbXV1to8vK/ayU3sZyFwYRE5PbCn wTsmADliRA7mb3QLZbaWLCeEBU8QNHUIHXLaN3OmK5LHW2JHRYg0JnoiBZBHLkSQxIvy1TY2iJQg xM2aYlqpbvux2AfmBxtxmSlXCfZ/E/DluFU4JnPfRNJdniZEoXIUTHoPbbKcSZl5eo2goPmJEc0e XuSjpfKHaklyuADjcC8/CGeo3e7JG47uACUFQs0aQOtD3YIaFjqT6Aac24ewHEEidyto7e1S5pXG tSnzATVi3CwNV8xvI8nSgzh3PwQqcrpMx56gWSJNXnyZYTkUBe8jObg2o2PlI73GT7Y6HofRmjy5 pLlSfBXlYxiYEks10DOg9rKw8ipKCVgjJCjBKqzLlmQWNbsmA4w+O7lx0rLIhYCSICrGBCA6DoiR aN5iBEdMzWO7ftvRQbLrQw1UbBRRshTBSNnvxxnKZZUTQpFJjtBSyRMlkAtVJXRKFBvvtUiNOSJe h9xomgiIFgtEvP8qlh+vzskOWFUODdHNcLlwC5RoCLXRGkk2rcsvcZl0URBi2Cpd6n6wRni0tGDL FxC4SFKDmrGrR5jSwhUylixiQCWVqNh4LeVc/dMPBEKkMKxkhOLm6GlcCh0A/zva1sds2jsyfmfT rns8Q8Fj0Atic5+FVSDGWGpsY4oepOIsuadfMiKiqRsMh60R7WfBRPBn0+iGDZLGyQ82I0auUTks jcQPxRE4nRvyQkJnCYvLHHbZZMTREXiYIwohZEkwL5G7+NZyFoFaoxnKImbiI5Ekgl7xwGjI0Lqe p7CCdKJ7jzTkXY8552RaVDpmRldeoAh5BMuhe67zBXqqqocQGQsMQ4LIJ67Ep0TxLOgEUYBYYRL6 MCwdokG+OtSGtIJMDK4dLfY6JMkDhSAEzLsmqU4QQgPWhW5vBPu4CN6LhaehU9j0GipBhlFXF/bJ B49W7pQyde+xjPrk5rFThD9AOqWYY6ZTuYvoQ+gQZEmMhqswwrmFaZHt6CZmuCW7itRGwc48i7Ru vVNfDfq6XRmT8GL4Ph6Ch0fZKwDya2bJj990m3qmBekHqBkQVMEEE9vPoNdWq2G16jJ6qVoCFxDa bOyBwS4bgmnjPRuhYx6JpixlvlEjbCqtYSedVOiZAmS5yeVIFFsnhiAgX+XHjsfYuhZuHY/gkac6 /I0GwaxPx+ApxtRe45jbdLUzoJuVIRElFglhCYW7H1qqlUqn9FGEcwHXPJM8E66dy/lSxiQgTkks MktDaSjFJbMOInFIKqSB5IknQJPmckQ5BAeXushuSLJlzg6LESnQqx0TtgkYOsKsmJFjISLnuIFi 8In2sU0WkNSBCSIsx+k/UxJ3BD+FDYRj1fRg9OzY0bHRctfJM5DaFKctD88RS5hmXBMoOZlIIhKp yAoQOQR94PbUyZyfbwHh+j6d8bcdRsUYjQcfpGSa3uNHuE9fklxUAz7W4EKjp0PX53Il/Rj2iZLq lJw9QW9JlOUATHVoDG2zhuNmvt7Oe+HN1MZe/y5McY1GRTrgnmOb5iWZqFGAfnH0Ot3zlAVE9vhY XULdtWab9FiqwiZmVOsY3XGuRvhfCFME6XTDxMQzpNhCsZI6l8psAVUS9MGxpiiQoTcDIMjfnHU+ ZDEJMSVo0iGFEgPbOQ/dKxpeBNoOrvZo4UQhXJMVASn2NhQ/Ij3aB+Y5YsMIk7EJiHzK4TRpVlD8 WYcozB6J9/YqrNkVTjf6GYBhOPEoQOWgaZm3yHH8AfmhEEr4pJxBFiRq/nxMS8tQRuDVgCX8b6Au EoTlBRTSQUqgBmWigFUMElcmtsc/FwvPoz84tOGehrK8cgmcpuJzrrqVYgsAIBppXfQqCTWJ7dJQ j59RoF6DcjwlKRYdLEy9CRg9KnPlE6IClS5QhIhSYUCXErG4ZVKtAkAyCRCBVjgq4FQYgRvL2Rz2 sV5RAtkXleCc6GzbiiyOJd4ZmO5U597g9anv9m9XW73Qiy883vTWG4mbwAGBs478Qhr4E2XCo2ZR czzeTj5VzQNIyN0CSCr8rjgyRZESYKfSpi9RRDm55Lo6eceqm1IS9YlZ0HmcYnV+9xfQa12cZdYl 29aVPI74n2rQUG2pDj4fl88YiUhrnriVzKBtT9tqxZRosHLMiGDrQ174xWpmZzJFbzjsMpDgTF0u wkJRiDjcSNta5kGAuYrrPAqwqZ+WDZkZey70z++Y+Z6/bhMTc63XY20mNWrkTyFxAxKQkNRxJCup x4OiBdIgqUIkAopci1FYSVlZCou8WlGae/YU5E21Q0RsFY98k8TKFSoy1QYUrYVAVJtNR1FkX6Ol LLELm7l3LPbodJJs+IfTzhvq7LyqQn6vF6SnyRZaaywzcMBbjjjhFidISe4uSC11JXLERscj2b45 kclKzByHuNyk5aoeUcI8jQlLmcuVKHr8/CJuiT1k04KpVsoiAwoiEh4gwsV42Ic6BqkYHU0OjxCJ MnnAgmgQ/FBIijlAKaWAm1exZxMy59pIQEwalIaTl8elRaMdjY0YuDYpv0Y/T7J8yMXj47jY4ptx NWCWXGhhg2w0SYwpBj39ifgXyMQPUnc1r08iuGzXAfmkQHycg0jOjJ5CI50VGGqeiLAIZiVIzPuQ +iU8EC4mHLOJckQqchcuUgORqoRwSHIFhjLW5nwSQEfMD5amXUU38ARk3rgnplPJARUBXP3PhBFa W4EbxevDuI+G0CCKBMj0Gzjvge6Sz2PgkXj0k2KJfx7/tGFbozvx6SB8nwe/f0euaFWhjpM2KVbc YSIMGLHTtiTlHahnVdNJzzgWybOJzqcLbmwtnZM7zFlIUpSU6oRShMWU3lVq7kdIFycF+f0qDfzA XYo1KqYjBUyiQoWVSRSAquayI/10HSlU5I6WI6ZpRcmSzO++WM+oesfFdb3FUoiyrnHRKBg0aHB6 7jZOdkmB47Fknp7Q8oE8SsvkKSd9Ynpn2W+gkWpSrXerQKhikDOUkDiJpSZIUpADFaQens0o0Kug hNEZFBEiiiDdoQsQjN7EngNOgwXOOaQPKFsrS9fRS70l6rFCApOL6aZGCnT1gjgdYmLL0iX0XFDn JdcVRyJzc6OeG3NDNsl4YyK0YtrcnVF0d1BGkV9aEYDXKD/dGxRAxkpUqRqhlInQ0MZEcqdGVrnJ GobjJZgIyzTLuQZxcpGZApEZVgQ7m802LM7DViJYlMtj2RIzjfWOXk0mZ7Su+S9qKsq/vc5k6rMg adPUYCpBDyYOyxYiRgT2gLsIXgiCIxKfXByToW51Tho+ucxHmxrVgaUOL5K4RYjDjF1GgWOB04Sr x8AlHMoQQQeOlWSjZzGwiigXFKinOWj0ZhY49vbHzQSXk7JkPPl7N2bscAvBGZ+qQfjwzeVaCweE HFtRzKVFGkCsH3eSnkcRlGFNmyBxGEQaLGjDmBlD0Oy5ex9q8+EzFV5eAz8vskgpo4nPVBihQnly qmuJq6QFJmCXhoFAiUFKRK9nUzB0WKQiQaGAOa8fogiUk6sAATwmipwMeuSsR5dHRorvByUJwElo FmGORqBgpTZ7cb4zZON2imVCxkbIqcESvRyXiKTMVKCk/QQ90RJdCUoVGLURjhiJIXtJDnvjg25O CdDlMupAil0Es3VLSFqaocqhcoFnLQY8Hgtc1GZQ5+aJ3KHinrWgeCeA6QKLwE3AGROZEs3K9yuy gGZEzgBY+pLwK6V9x3WJ4Dm4hVL1ei5APAgB15alvmHDDWlruhCMpvnfIi50ZVIXJvbsnvEhd+7w 3V61YU50GttqreS3XObVo5tKuFcGxWjkztWS57Al8eTmNAeR7lr5fRlxratq5LVMAQkDCjGYgQpZ kvZMzjORVeVhfncAhjL2E4kOOXDlQ14yRmBXRgSAYQoNrhySCpMry/UQHFpfzOngR2rqqSC3Murp 7AHoUc0SLHJFECJdEvxTE33LuZQslOhIScgM6qXrRHEQ2ZhBE0aIGCxUYj1YhAPjKfzT0BLomSxS 5wIr8lpqKicp7fmzilae9eeoZf7KxS6pRainjxaUSRJSHoF/B6HJcY9wAeGql70OfmpdPWU0TG+M BbcBi6HwDC6kDwbhmcZfA9yhJPCh6oOCDu+krh4G4qzSwc0D7CxWmyDHpwOWZWFP1RAmEKjGNn5X GAc9KsKgYa8bbED24F+QIHwsECSRPkj1vHxdFZSMzWYljKAMhgUckcJv3dImEuR0el0ESZoYQvIg JEoYgaPge5iCcFvcU39pa6GvxBWgqwOxm6oEk+YyJQePfz/Dia+AaxI2d68Ei8w6rqBqW4FJDmZj nBjxg9yc9GTRL9g+QD5JeZG9x4yKcP00ibHQPwYEeK3IMXJzPWsBRcFimEWXHfdg7NGEGOUEvBEE TCYfASnpPmRI7Yipmg5slI6GIiKXOInUTZI3CylTyF03gqKVTm5z+YhHKywS0VZlwRuWOZxKGXcf jRTImyA05wODfvuWWXNizVvjZn11kMZaoPB40M/L2+7HCT2d5ed2SnZu2T6WXemAXXWoSQWgjPTM 2GUrzWa+jDkzxAmWuEXTOMexMk1A+IWIzpEubNmCKfWh9OIhgyYJBuxc2fKhOZoYpotwgxMZGPLX 3upB7hkgBSp9UTXRsYNlChc2XBlJkjklULlDs68TRLl4yKRoHBAkOfmscDVdA826DIxQN7/MR74O E0gmIGjokoVLRvYU4t5ynKSWQvJJKSlXpeyTy1KVQRDyBUg7Vg6oWiwda7FCqG7O0XoVsQ8C1Owz LzoZOAX9iBysA7N1AzSVjw2JCV2/fJiYwfCDoSPIwHsZ9c/OGDhJ+HIIzfiHATHLfXytohzgVAsk dsaNYki9Dd5mWiCs5VMcmNF4bjXilmcsrsCe5mZXx1vRbvbjogVHIPAvIgRBEAK7GDH5ZDk9CfLH naAiH0RAoX0aPo4bQ0CyLcESQWbqo49dglhCi1uNkYRaS2CbRcTZipQyfCskICkGwZqV/ZocDDl5 FIVHjE1bnCy4sYKEXMcHBDGUQ6JOLVzJOkE0Fwfd9UallJsQqMpod40vbI6iPhv2vG4IZITBIB+J +J1gQdCMmEShqGBxDwMbTBNIPYoR6M55Ch0eb5V1rnTJOQIJQFCGdpIoIMosJoIdnXR4LDCoXxbk 3khKK5B2YDo4LzNkuxuE1oE903l66RZ9EYIFdphSTlR3EgvOyldwDotGCYBCGHyiQFs5IgKYI8Gi JyHJo7+vohLNO4cahAg8IO5C7CSFzkVp8yepFQoCRLG0QJVp0KWFKiikhYlepQKELiQI4OhyZg4y SrzVE4rUZnWMpcNBmzC5CFQ0RcsXNFS50fLGuq72qbIxFhvL2J45nFeN4w9xS4okTc1howGBR4kn ODosbM3ROE1WxE3AzNp6Km61Lim8mmrpJrSXBukTKBUi5UycHHE1ESoWF3piI+B8ZNlUrFoE2Nl2 6m+mOD1jhI5kYcMnmFSIX5K43wKW814FjMglrRhGAo5ZBEhTyJYgWQRL94doKR4LZlY589touUN+ dHkqeSRAjqhsFJn2ieOjigrCnQ/PLBGISMjjQHwZiZQ5J7ygdFZ3JnBsmRItrm+DJMsdEEoLxZS9 9TKDGqBAvUhTgFN6GwU7EJ4OCkNnHzRAYzsmaUnkqMRFNQY38UCY5IoQHqIOiauSeONXcFOkg7pa LwZehjvVLSqrTOQceog4V+oG/1aTn3JXvNn3/WnTHrdfHwkb7PBydy6LYBPQQSQSASEEkB3O7w4H o4EetDUB0x1WUah6n2RfQ9TOIs726SrblUVxWNNLhs8ZqdyY5e8uws5wnsDlkWeGl3Rzg9bGgDg8 CAA0AxEAEAR2IMRPOXgF9rb7QVlqBQPIXJSQEsIMKzZOJRWCwLSy6H2YnELxVtMpKqhUoY4HLllM i3iqRyYeRkMS0p0BTF/yzBV4LqLydMiCAfTwViiPvfXDOiCC80CeXhuC6WJHkuVRECI4wiUFaY1i 7mooo0xtl3E4hGTMtK1oQggJK5M6gjggSODs1xcFUOiewSrhw4Y9E1izA6bOokzYePYBPfzfe2vZ WZOMGAUUUmCrg4Yqh2cDHorEh+bKlMpCBZu/Bvzm5oj6cNfo6NHQsxBSLjMSGIHLk6CGhWgQL/p+ VSogPjnVCpgeFNRFCJ4OmPnTCmFNoK1mtBoefOOkeJJYjHsRRE4H2UKbJnhOhSqCIky5jpxzhbNe aBdR9XakQnJynp6QMnDEzBS64XmTrmhqiz5ZeSAMqnJeQ5fEB3GsyCIkjghiESpcbwVIFBkudGCq yBTrrZosO+ji4YZOELKd2nBGYmb5zkYiRJh13mJkYF4bB0UOLHeuVY6psJxNBMKazzkwMNrSIcDM iTY7qNiPKGwZCGRRWsqWnSoQLFqFE8qQgUkLydwfCnBgiZFMHfbD+eENKfkgieOME/saeAs20tEE Twlk9FGyngXAxUsOw0yorUmXJNCefB0fHBE2YMGA0UCqlCZ4kGRj1OBSwORdrijECwtiRU8McFSJ DBBjnZYqkdYNmiR51Y0YJ1Jw4qQLCki9DRnwkDF2CVSpH8bjk1Fyb3MpKJVwwKcWJnJcNkvEb1ev QCYaIp0LjloCkSszJQ+ohhATx2J+NUOggikE3YD1yEZY+XArlN6+oi9azfekjyHm9G5XjzseZwdM BtuGLCZ6WqmqDKiwCHF8kCC3sAK8xX/hdDb7lRSTooKik1CkrjK+Bmgy1lMjNQ+2GJGhjYFbkQNk lwBA0xEDMtbCEwYsQW5F5FAMUWRlagtVkLS5UJGwoVGgtq3qGKLYiy1FrWSuzYgywxvyu0rK0wYk WMIMoTSYpcEyAXWMxZdmzZY1WemkSXRJC+QtEhAQLuBEOAyAAAM19qQUxT7u91czeWIVCKDfai0R a1xIHmP7cb839tn6iSRggSkL02wo7IClT6kPq1/M8sFcsMHdzwQzwzXjd+JQynIgoSSUIJlDdn8P G1sb5yU5/SSKUiy+akwZtEhOuJ4khoO8233HOtzcsmwzDC8rdq0+f6yBT61AYP5pKLIzDDQntDkH gXBcUh3VErtsi0YRX8I0/rUuLi7rbEhuBhN5nHEdQ36iYhJgohBSLBiALEYKsYgsYsZFgxYKhEUW QUFiDJ9vugoqkaFqqqEFAGFkKVGmAoXAVBYsVpJiFGEmJWNLKxQUGyDEBCxFiVhFEhEhhhYW7iGC maxq6rQtDqxOgF/BVSIOYoQSQfgHuJYT4g/wSAZRf+mKe9P1BrA+vYN+xLTY6ChxEcUYVhYgg+Ft izBJuJBKcIqMhSFIBuUCVEClKTzmT+R/jOq1PmnCVDo0cQth8+owZKTxSKlBeiGEiKheIXLnOeKQ dI94P7/6CfeWh/uj/UUlCwP59g+Q/7AZCAVCbQbDGM/yKqPhFn6Ki5M/9ZzSGAQSCRjEEYLCMWSD JFAigEYBBSQXAfqJg/RSSeInA0J07cZMCwWK7fH/5TP1w5WbnvIE4yBI4DHAhowT9oHYkjSo2DhL ULgYEoX/0yrqSzciOs2H6xJgRBgRDvYGCLQKIIgFlOxYUiqqr053PJtCTyZkCTo8gZ8pkvGQFyKT sHG5efgp+egw3l+ZEDjdtutFNQ47bJHhq3mJdhIWkKvgplMDIzJ0cF5BqCtkEG8aEo7k2S+ZBQhT 8iAVP9A4rg0PqvTmIDn5nElAytYQvLwm4wKc7ll/HP/siBQP98m0KG50SBv9RUeQNQU6/sdlqWnV IxDKkk8niWSf4jFbsoZU0i6x91G6PY6HRe6QqHxjzInFFQTInRJOsQXoLw6cHpAwIFCAhAaEoyqQ KZA/qK2SijcN6m2gVV5oF1kET1hK0JkTlSQxd9rKUVKXDt0v2wsljCopSzdEyGaI/2ekOLJIzoNh sS2xQskgyHqA8AnJFkrIyyE9CB6BCe5IxpydBPbO46CJ6RRuZKKXeCryXKetbwllRVSIvXkWkcnQ lDcnvOLzJyDYOUvIO0V7BloGEQnN0hRoAsEKQ0rbXg4yJldhfEd7OdiUpn0JE9CdW1qzQUUFOR5m SHKQtIwe6H1u2JIdxI7TmWWybqVTvsomjNIefcFy4UkKKTB4JFi4lFOF7U8Ek2w6wM6bzAaqFt96 JhYh6kmTgf7iaH2cTOAQqOULL7nhJDakXXrxgWTCri+hF16yi6XXrFKKSl9F/QaRJx4AuSRl4LtG CQtiMghtqENg47SHHUA6uAIqp3wT/xLMQwEQnQJkHOp4DoFOsMqqljwUFM350nE4m26pU8vXcXMF 0RZ7PUskeDSMerRDASfYqR3F0NVzCSOhKcnOcwaAwFfsE+0+w+0+qoNSpUik0yh0EL9D/CJ8pz+s +kERERET66UQQp+d8v9AeL09x6fg7b0CkQVncbmBxIYEmcyGSQyd9ChQt06/0c2aDPzDUobSR/tS QSZVL0/S2B99avA2EVhOBO/6MB+IBM/p3kCyGASgwjLFpUkRYkijNU223l5CNqalZZg2BkMDLcsC zddKDewYy3Ft3XVa5rUuIgRQjAhOgQgTloydKEMrnQf2HRZINQbiFagW4QpQcgQhX8hCxLE0hCLI nT/DsjOGx+TAeAn3mspoHRmT+B8ixBqZ4GVSCMIb1cI/H/OPZWv7v5fmMSDAFsQthfPEjkGR+/R5 +9f3ECUkLXkkf3zk5PsAMgLMWao++yyYqcPyYzOyEkDGq0GIk0CKQCuPFMh9pzuLrsf7Jsb5MFxs Bydn/YQHJD9ER2pIHRE/AAoJaVYB0SKHi0SJ9TjNyoxAjYnc0n29c8EVVi7VZy/wgSLG5XNhwBc1 wJqhgYiSFX9QTXjw5qXJbWO+SAo6xIkiF+IUGCRs5FgNZS5HWrHEgnspd5FjIxIlR8avMfELBIG5 6Jz0VMEETTMOQwRLE8XcZqFqkoci3QGLSFcLTzQffY4tjhvpwYr2O7Ne3NeonJ6T2x7RaPRIL96o gIPwZOKZNaNvNSIo4v/TQbYsjyevq7jGRUYlessQR1kSEEtbKUgSlpIRuJweOPpgJmSDdwHIdvZn DzeWIYlucVGbBEYqtGm+9jiytoPRj2RssS49iq6ZAAH5z0rAEyHa2MeBjiXNIUS4m5ENk5SjemzG F78KFejQefEUE7rmFw8D4H3Hk8kqEy3fzGsfre3VzY+ibeSxI2LjHpPVzRdwdl3fGMMF3Z5VPFXd 7MwnikkP2vER9mfzvXiOfKJr3T5NJzT3D2z+UmuVapRQtXkOjv2y/wiKBfRTnlsPf2p+k8pCSRhJ AglgkYJIkCCVgZE9A80tAuagP+Ti7Wwg+JOdK1bhQI5k5BkBherUIjKQn2PAFNqL1P1LjxIHRIRE zEcHJeizU3QEwnKBpS5877Lg/zCwUTX21B69bcGDD67OhfMCp/oh5q/DMmPwpNJxadwaw6w3GRCo dkAAhJC329Sg2h+OdTLc9MLzheApzdcZQxG+BbElQrEYdxA62TRD29xNeEk3h4+Ic0K4RGYhJ3SB 1Vgrzew3mgyvQzEDPh0QMmeWnouN2O2XeAw3OMga4wkshrjwOM3tB87ppZ3RHt5CAo5qIKFZ+i4S 3gilTMzBihHwPUre+ptUPuNag1IDWhKeH1DT1Bx2jMWO/s+gfKsGR+sRxElvHkA5a/n6uqol/Bua aMCg/QHkmNDuV/cRr5kPgSkh+k5xrKmD9M4n6lAEH1oQxcmeA+pEoXbmNt2gETjPBnO8w0UA2KSo ZwdP9CJksdaDM5Cl/Nxg2KdxOAuGT+AJsuTkVFDJ2aLgyEyhcyKOOSKHj5iSyRnEUwrXspBHxzgm SGDzntMjF4FcFjfoHmgv7/TwOdFjoLnJA0cGeJCkpk4VDoshoZLN/XnDnqa7ACqGVDRYmPElMtax 4NjvGWh3utDkb+Rks4lTYsvLmCoXepko9w3bkygwjGxzB0nB0ZXEyOxaFTZU6LkaF+ygxd8qSlfG CheZciKExaKSGqOUPjgBKg5SYPmh+oCk5ETJoUQ4pAthj+yQQJnPTeUnfZ23bdkQmbQIVQLjmw+w HsgVDpyImdmTQ5x6lOHKSMjHLYP70SlVuT6LnR4MlxLpHY0Rv2rRfTL6eqQ96aDub1NbNWnDqtxU 3urDAgTD+7BP70TsLuYFJe7Mv1oxRBbGTB6S8cA0DOWbTUS0JLQPchv9BzaiCCBT91D3HB0nhe++ AfOfCNglGwSjYCUbBLCCELBS0FBb/Sn4R7HMNaqkKSjMlGBnf19VqhnuVs5kNIfPE9adJhlUPIDU K4x/4vOykSd0Z7+dyujU9aYjgj47g8FVU5p1Qzh6X2NkNJPSF3vcP1R9UZT8X00JwhNw0k8zeSI9 1ISVURDFH61Jh1Os2WBY3kfH4fPj9t+o1STMbBFCkhkDJPChJG/sGe49zynOIBWRYnd4B90p7hcK cHRO/5n7l/BXREGGLVhqBKGsSyxAyFmqRGmbrcuGiYQD2+0wt0UMFlHYiVKqjhkwbH+5EY3XkkTP mkiNS5zPrRsgCkhqoifKyX77pPuQMFRRyY51rsx0lOBjkPLfy6OzguKY8QuKcm2P5HwgT6MnjGCJ eR7FxzyRIMa02LBT2rVEuo3oQMD0c5gVS48S5dTaeCAqGil8myZW5i2itJGDJQ/sBrkVkWvssXmF DBoyQMV+ma5kpn3c9zJxb2jiwarPpr1J5PeoqlFuCp1wdb7Y94ng3932BTtLFMzNfIUCaML/JRF/ L+Y5Yru5ZCGzGZl8HXDaqzNxaM8gMQNtyvMVz1M3z3j5QibcPWz8eClMGxuY4ZeLxZMXLy4zkpzM B7Fhq9xggieik/bBakcjoA7WNfhffeTqoRryKAYm1jzIzDFJQqqv9ojImrzqfSU2piBwaIckSQeQ 5Kjl0T1LlsBvYeyz37UmZPWAOqrf+8RDqmLp2TQqvRLz5geeySmZjjnfPg9CJQKQ3Hh56BjcREKS KqT1+gR4fUB7+lKowdoDh1APJIDjm0iZg9wh0NrjESRFUWkPeHgha+GDdxSUtAHZb4U+4wioINgu 9wAoqfUlri0SU/s9aCAl5QcOSLaw5KhQI4+klYS8H0vaNf6SnaQGQcbaNTgQkidzB63AJQxDr5Ad SGCbAVcy70r6gOBQTI7eC6TwkHLC3WN+h0o5NCBSJKwPBAQ1A8Fw+C8lfFC5Qn0Dfs385vUOgB4A bEfNXUovk7zUNDIH2GyYPjBMd8O8VpBayTcdIIyTAoICILBsDEMGD38YDCCKKmRJhwKIoY2uGXh1 eX2H3uXTbe5MSICSdoYqiUVst8ys8TLlNgbw1dpU4KkcLwfuih+XyQRN7r7ytfa3OIk6psduD7jH AZFO8JOhzk6HyW8A5EyX8ogiVPr9cFD+XdSAzkXOw5aU7G7RMbJzcHJW1SnXc2sHmnOdTmzi/AGp GNhCnieQpA5Xiw6BQnYtpPSocMXGK7iCHRlTQ0DqshxOTZswaKGRC0Ra4X8bzBUYq2sFmpWrnAM3 ROnJmbFs1L4THhqdOTjzMnSYDr8yjFFFj3Qkgdp6mTuyi3f18IGSjzpvJoq5C3RCR0fzInlBEqaE xgRIKa0O0hKSmtZzMQMR+qkspKBxGJ1RSu6QSVKcBO5TjT2OxwONjaxXO3S5e7t/TaashqN2OT16 eSneBrVbBPidLBKMEsEp9YyV4YG4mRuL8B4GRpAHBpNNsDQyNxOdgFbJE+1yZ7lyJ8C58RdyUVFV jmHxM5C/NAuLcspZEyl0WxBJEMH4p4REjslCZAqJAiYwkWOt+3EKWmqlr8CEyLtJpDRITaRFvJDp uJDaZ479J3DsG1k0pQ8vv9sBmVrDhkzJaGwr2FBOHAUYtrywZZNi+ovLaOUt717CLkl8d3RWrsyN uMdRYW40mYbTdmUESRxMdkRAVqMdYGQtAACB6H3DlHcPCIq9ji8hvehuQ8OWzUHMkesYuxXujw+o v83rii0ilootJSxUsilipZKWVY+Mny47Q82v4SGCOb1nqs4PTR4+vvRe7isqbLVNO1yJjQMsbwLA ODkUFyC4wPVLuIpSzq6AnC1VphjBmbziL3bN7DGoMFPzkyfCX9qhQcmnobJ49TySp/VMWJQzpdVO RwEDrm56JHbdfX1j0HNKhGKN4o7aZVOeAgxzqgACLcRuwHPsgGPyLoV5FDCJagS9tDDjEMkSC1mX u5F5rCVopkaYymlu4tEIx3vkOaDS1nFODDJyjZh6i2Y4FDIGpUQW0OSLgGvT6Szr9Cg3otcNGBJi h7UR7cIfVRtO7/hxMPjnCdXNFstUAWq2I6TEk1go0INFNi0ILCKLdbEFZk9xRumxFAKvNxzFoCQI WIpE6YVBeF/xGO+spvMzQpJZx57wkJXnA2BsHHarECgoqKq2rr8V1kMbd3XBxv80dreGvdT40fZt rsbVAhJfrbW7IiTugPDTaaD4EUPxDiqaPPtWPqjWD1PvYyKmiI3yXyCH6AvBIdioYKEihci57Vfp msp7kCB2KXuDyufRESXffRrFxvjO43J9T7iZCR8BGPTg8kjvB6lcjNSce/oz/HOL+Y/L5WFu9OYP Z+hNBs2i+ap8ZYvHZ93vkhwhvwpx9NT6mx5jpeOGltvWWLXc9JL6o3bJox2bsOsZ8HadtlFM7cyS fE1yaOwrct9mWuS10kad9PVw8WzwI2u5eyOLB7WKzZPDnzZPBed5rTRpTFZsbae1geqNG9TXE1bF enporRyZ03Ug5vhSRYblhQU+M++7GfiiQYpH78F35LYhQ6OErVyUxH2koFPJEkQozVTkyaSUiRMz VamnWmrgxbFtvvnkjuKDykE85BPJ7DEIcpJ6mQUIpDuhWVIKWqsFJAWMRUiDFiCwFgpRRtImsxE5 k62oKvOKoWPKDuIYLsEtDwGzZ07jYP3WEQga9Y0CBE36yTcbymIxG2JXcrVVKT90EwBFbjW506QO JC6otLdfPEzOBbnMZECzAMuJRM/cw1R+DdgrwU5TQpU7mlyQ3iIcH8QEmG8XvXp596YQbThUpDPf ZUQGWTCTcK8zktuT8HFYv9456up+3tIoSsOpBYOPWCacFUrFWVPx22VhnNGKTKOTCqL+Naj6lKfU KvpWuYzHErokqjE6Ge6cUoUT5MUMDMxuL09R48CIxwCw3pdkXZAMzJaDp2LzePkYZU8TK4rKglIn n+Gjjyogxgg0kllZIgKd1mR6XAgsXraju00G4nWiW3hpdT0hVjB43HnblDi+FGGqO6izlchJ1a1I xc52x5bq3s09Mh44KIs3EC8f4guJ6ABzDhXcTk4lKw4p6/gmjc7Gr4txM5Un7uKWbUYDzh9ISPSl 6OaEnC8R93qwAvR1SW48gtx041e3Xbvoi0PD628Yban9+2nOx2FbQQlCrjjPdFRjGLOlhk+6V5Df CaM7IInn8BEOI36eecyxSnvKml3O9pXvLQ0P7UETaIC2mwDaIQnbr+5xQYHIj/gx/TN4QeqFPxR2 ekHrxtDFZ67k1/pXxrerGZKTw2Wqe1Tmt1uAqqGdczHIxue09VEXEOw4Hb0hZJn1AbmfKcjwIqZR b2UqZCwkv22kkJiSU1TlJEUviSGTetPx+ZaOk4h8pJ0E1wDSwnUDiPkU1IRtQ9gHjwgyZKSRTMkw 7pDxH7gXy80RRYDcMpScSburv2zohKoLLQEqxJ9DxUzko0X7WE2M5SqKKqoX4wvYSPzUk5kUThGh Pwlr7SHiZ5m++HB4cdkp6B/wH20+ndkRdAxB/fHPqSYSyETv37LU6Q9/wpQ7JjKKN/RGjRh3KX+K jC/3kkIQbJRox9jFFvKB4EKYplAGJNcyuI/fAQTIgJYi6pCjJIEqi5xywIdXSZzMGC57yRtuoCax uTlamcj486Ggyb1/1rPqiuUVU9C5z0ebOBgEP8sCIOW7tBoBMJY2iqSnmA7XK6fzUNd6pBJ8R5R3 2UqFo74oiJH9nxQkcUX2hSiaE9B7A/R5PFHSEkATBf0YlGtRg2FhWUaiwZUug6w34dPyYxgPvSSR /dfg4+/4NjU/cufNthMl/7WrsoPY2VL/43/UkNdZ1nDFiBcP8RSFZ3qWD5lpFajKF/8ACJEUmZD8 NFNmKUKRm5wGyQWDJaA0B4NwiBFAqiSKXISkfZBC5cImGPHhyq0SoS0OgkGABuZ1NYEOCxMoHHqG CpwhQsV4PJsoWJ0JGCHzQ5gUOzjwhscrYGkQe3TZPRkONdvEBjXrgSYleYZmokIzlJlCclzJITgt AnAr8aHwuWO7XLGDe1WJ+iB7KgbQ3PPZYyEDBzIEkUNGtMLwGDi1jpFwRBqEtCmipJjJ6b9RSA/Z ImUVp1kIchJG9L8GaXJvwdwOuNzPoInYieJdhIyRxWvRM6MDpDdCjiuW7hA5dAkHjJk+RK8zzkqe COSw8JFy6kP8C5G3fbv7epoOwnPo4H5NeccieA+iAoSJnBmBR4Xq566s/H79jpOydwDbGazg3zcp rvYSMFJ5fYuZMJsh02qOzs3MWEZvmZu4Bc5qSPxz6yQAonUPzj+xQHOuAPuUBlQqoDMJ86zBCH6g /8tFzB9L2gbgTOB2J9cnyui8GQX9w9I+yj1bOB9FDnRFVEQhoWBsIFeZF0ugpMZU8VFqBiryOXSe R7RMADQOoMqug2ppP1RVer2cyLwVMg/hDEfh1R87QrtjpD7KR4J64ioVSFQqEAEJoMNYlPNDr27Q b1571D0tTo9ItPcmdQ3om7xWz0XdqYYC5MzCCnMyhbzAaO5DyN/pYhaBcNBLDIo4ItYCRSFYIFUI E9aFEOoDrdq9YGmFXusvTtQ4qhnNYVc9dwZJMiejcvwklJ51dSi/M+iTJdTc/TGBOvGd8bk7URUV 5A9zy68kj2/QJYtAc+4HPR+WoDpdpulZJkPpOxQ2B4bLRtDZJPBfCdfY+7XHi6A1ewbk8O2H1gO1 C1Q8VDq5c57ZgYoQyJMsyET3E1iFpUoTIyi0lT1raJYL3x5QcgOIGcKHwhoGK0eEh0x4/OQ2jiaJ xgRUVqAeD0F8lpzSIwks8b4n7MF53coyHr8PuOgkPFrmHbt7ZMQnSIopFBEiqIiioyRQQZDSAaKH j6fRj9KSc/Dvw+L2B/hAlJlxvAaiUIGkJIUnLQJfM+B3qMtHdyc4+Gc1fG005bbUqlKmcnvPiG+P 0hv5JYo9YpJ0QKkjEBca0sUq18u6Jd5kClKQp0PapbjFnu4xsH3h5vD0kh4TtRGvpEtduiNqS2gV miNdcY4iMAQirz8MzBB6IeJs29j2RYd5eZvdiTrFzwRJHe8z9TiBZaYtC1QbH2NEWwTumU605F/k r5JsA4InNBWL1wSW4CSsFkvpzxSijUYbxYiCTbzemhHujlJbdA/uwEOaodaFoV5Lh1EQmWsL8NIF ni32htRa83IamCW85SnrD4+CLCIrU3hUZEUJdxGq21lwYCcSLLkJc3GC/cx+pg/NkuyI4de0UA6y HL5ZFQmDkOwxdvIC0F70NoFEwuHYFAUuNigMQKLWBRbLg69njFK9GExUOCsCSfajknFxlRUvLHbA P1EAbo7CxUTMvMsD9Q15HEp8Nj6R2oW5PeQhl2JgOYVQhBqZ4B+FmtzpF8FuORcsd9XV5WcH4ZgT Sy7GS+M3N8pB0JHEGp0Z80Yp1sE5U0jO5WKV4RLAcMz8Lr8iQgf8Hm1v2MH4s8+p94bBRQ5z3S1M ZKpTdb30d38X9txOSv2YHRvgvai2ou0qIxCkQQKxviRVCEIgiDpT2DInQPLoIE+Z9ah5cgeequsD NEMAQECwHrUPw3eIbw6+l59JLguX1bBFTNavfcN8fAgh2riFyHNAOMFQ24tXGzkHICFhX7uz+6ws WxWymAGSMAzqaDoDkmYVS8hFqZ9YGVHSuHqHwD/UIIiwCUk2D2K4qA9mWJCZKp7VcnacChJLMB7T 2I3gH5/mwbbpMuGrPZMXZMIoKa7fL1IYJxi+o4V2P2HG4cN0rf4ylv3329QwDlG5+tcRsjWPBQ9i tv1G9LU6bhtUXdgfZ8uzy9D+8dqAJLtxX1DRHjeHHwBmkFoKzHA3gdTgCDsVgFacO4rer7j0HvfF ac688ZmZsMVY/u8vS58aSVTxB+YFody9ANhoSP0AbF+Bo1a1ZzXDzujZTQSodNtLB848cyfG9DL5 1vUqTxBQT0tDrOH6xc0JhcBfkjuBX8A1gusRBmIyA7l4JB6zqXpD17R0CqG3fZPcr1PbAdwI9snk nlD6eiXnyex7m+HwI3R+qcIoiPTRB1l5pdihB4DQXxDBJRBadUGC3V1ZAuiQa8Q3AexYOKa+M9Dd zkHVcwssERMEkPdLLFjZUAStaTRSikKCWDCpQhR7ARdih7Uz0wXwA7gd+tAfWRoVuUkUMwQ+uFVN KVU0ItMx1Alm8tTPABEAa+/DEJOoh4LJJ++igsWIik4moHUEgxm6kVfaRF1EqByi9n3yTN/Zdn8c GUhxGfjD2ycNdJUVJ6SWc5OsOSjfZaVAlFVE2y0hugCiEq4skSUjfP4VJ/eYCIzpuj2DehgQ+0bd Np7KVJCD6wpXAetm5tg+e78D+8juEjF9sh85CySRdGvJONAPQOh9XIsfkwB8iw3cEwdh0olPDnsA fed5Z8Ms4pesJmeLvOGMIidha1K3Bg90I/Gqg07glFkfcmC9QmBlX9//f7x1GgNCGtLnnoaw55OK hr9SdXioaXZcmyRVelQhL2xA1iTBekUNqSkknhG2RkPvfsjTeD87vkB9J71ZBKJ1KnD26cCCjEkH fWsFr7WyF7VF/XEaSHcTkTgwy3KtKstY6RUlilx9cL7heRHdUSQLTFeSzaA+a501A/MepM3q4Gd+ eWKYLIpznzAqspYm/QZHUA1RfrgAO3yPcEPuRgkIZX9B8Qi98CY9Z1mRdmxKlyKWKlpM1Fl0QEow SkBIFDuNIra+cqszB5jmXpCPfHROaneqQTY0q66e2lu7PVRy1WNKi5sqcxZpeVCKXtRkKtKyBkSw AcyLZphLhxRt9pEJd0cPHRKsejNLzjOBoXJJGOoty/5CJSItEnFwD75PNwBuT6JfijrtIfGOKEDd MpFoHcAGh2qENDAbl9fWhzosLkF6QACqpIVbS12ABHUDpVsX21L0jODBbUwQhBuhE8T6QrkdHLve wYYHwQBPcurzQ4CduYD83WZx6ULfNDQnlB7o+7uZwV/POBvlzypRShetSn7/2XwuwifjBHqNyQ52 G2T5gNpdYFZRsgS0CofKgNEA/S94vbqLPX9gx6nYMx8fW5y6szT6ORCEHvIQaJvDG2wWUQy6kyGc GbMTAP5H58SxmZoMRkYobAKiiJ+uBJqoijBok0FsiJBaJxKBKKCQunMOxSmB0D0D0RHD6SFX18Wk kdBIcCSQskRZrAikTOpWdJvXYV9om+e1TbpAlO2AMh7bC998uU9F+sPkJ6GgbDU5SWnOyBRB+lWm /G7SJp1qA4rAolYlGEXv9lDy38ClrHYnYQKD74pkRHXfwQayqQ4QQSOpFhAEoqQNKLSCZZD9RbA5 tJ5ZCTslhCQ2RNx/yuCTAbrAu8cE9RcsRaBDx+k6ah5a3A9+8Ov7ocOJXO8/hrs0ZRJVl2bKpHpu a6Us77nqak7oYoUSCwgsBZJOuyg7w6TBCyR90guPcruRbM67C5CgESdqvJJN8Uyh6jsAOKHqKhgr 3pADrw3G0C1NJRPMgB+tf8rfKfEVZMKieI1tdtlm+qxB+U6D5xG32I7wdZNLJzKWtVe2i28t1rwe cfuGCJGxpZqFBBm1MqhgTCFiJEgClAZZRVqwwQXieS0Ki1VE4SSQEIqHK6hqT37ldrxPbB8IhKfl FIokUgchAQ0nU4D7pukiPF61Q+sPI89hpOi0/ZMBuQ2AVO+OPcZQTtubehgjPFJkpJo1KkhESwXx IFYVkPyGKC+1PzMwIHCROIcQ800RPYeYtn2AwsA+wjtEGpEtKEX/ZcC1zREXiTlACLNWvIVllfMd btTmXN29Zeo/m+6iYIQVJVwdbkAfudLmahcpA80yFVDrQxVeSbd9x5AVTpQh7LADkBk3pv6EwOt9 3Qm5NzQAsG8vnctS5Dpd+VLZKZa3h52KVqXDoF8IIvercnRL5JH8ZSfdDjmnyaVDuFeYUsK/eSsq TCQQxKFfpcPYMC3atEmsqQS5IioGcuGRc0iS4mk7aylsS88oyRncjJ0Sesles2V2sPQndY906Wn3 Ug8CcZv7R/mRzIj2vHM3yqCnAsgfjSoubVCqimEL72pQWH0QBZJIasnayXyjyV4yy5Lh5TFtXIHr khGdSkni2q1h246SRG0e/q8MIuGgFnNCP8YiBwIAsHRP9ZmsbkCxDO+AHHSrlOaAI1m4MtYHx/XO OOwTO7xvaQQoJ2FFtGpDYRtPxlKREKlauUa/GwfGAsjvUMwT+CXlHk7pcEHuI+vQ6DihmDinoIMk M2NF+itQSVqgnWqJAQKqegIXnrweLGlXtFOk/WCGFMwaNO0DzCq7BL+ZYdOUB7M+2nMxAQeSLYoD CKhRZT64UooalNfWJ9PwTeouRIQfthZTIAAXI9H0EKWObhtjW7DHrbFwrlMVyyDp9AfQfGN8iZN/ YByV2IWBtHqT85yT8cgG45k71DBOO8M35AoKQFs6iOy1lJYlsOTGxAwFE4OqO1g/vpvT4Q/qRhJ4 raSMHfm+JoDy2p5Vxobl/ylQxhDpgO9FhyOYE1bB3cXUaewDxDoMLye8e0O55SZwxHs98k3cJM1z aYpJH19qpU/e4o+oNs6Dww2dZnMflDT8HkOsPdDB0J83VI+rdHyLw+TYb+rCKkLjilcquw7UN+s2 qHWGtWmVN7lC4E6Vd3OO/mSIcGMhZA4pnJOPV4KlFVUoidwlkNrUVV+KHOBzA74e+E7AA+eRwOhQ t4GXpxXqKr1bgLe2IYDbAExBEzLHV9qOswkmMR4YQ7oUPIh7BkN+oujuNofarRCyStYBYiQUEU3j WehhZM2gKxFRRFltrBE7wn1hfYCRZEQpjA/sT2iTgDCGiEX6OPKfZm0LrA7ntpoXEI1sJ1JRSkBK 0QADvgVQl1HOEPisEyskhDI/F3otgZAeF53iZcp5VLSvouFx8v6/9F6YKa5OZnGhS50WtFy3vuKh iOERoVKtYWW75yY6JibAQwQRIHH8pRBhQLjJMxM60CqnjYvtFA8zCcfsqHJ7nY1F+0BUiokh856R vmPyijN2S3+2w/XT7N7Llft9xctbYP6wNkFxCH1gMoQiOFxaKjFUVTChkeESXRJdID9cO6DP79hU CRPH/Fqo9JCIcGAeB9UhyMgc2atEEuNJOdI8AguvLzFe9jFQjtVkMhoXDkL0/cvjBA5g/TccJelR UCOa3RtUGawSnwACQLBKIYoWPMD9isOeIiIT1fAvFNYYGzsC5EOSJH8jdMLZAxEMfQfNmeWnoA7y KROb7L0ooOG4DBIPIIM1vSl2BQDeDD+00KEhTbSTzVo1h6GOgpIWosCKSsjERpdRYVCsaAMiurq5 WFyQ3IykpyGQRFKkxCRlgSFhJ7gnPJgD4qPWPeNxb16piC/GndbU5jCVlgsi2NtKEy2paxsrly5z 8D1a1+e7BucbopTp75sdSb7MkkVbQ06D5UspoJkKO0FYRVxZ9LW82VYT/Kj4+NBjARoKOqByJapk sIIF/D6BdxxVIrTNRMO9mLRtoTXJWphBfvu0CxlUI9etPzev7eIj1Uj8Y13fg/idgOwt21Kzjyr2 bbHSp+Qt6GRnKCccgXdGwAXXT6OLEZAjtxgFFxAychLItvGwkwdmcBlC4S22a3erOUsSjD+czy5H hh3xjFVEQEA+JFxBgfE4xDGJAySHkVRL9GDbaan2fMTxQgOtiMPRAYTMNsGTvV2NKoDRJOSYDv3S D5Log9Eb6/ggktDui4qYDAB44Q7xiKKxRYsFgioKCgKKIigpFgsRkkWLBQ8qgPcKW27B+g+AImce feNhM2j6VCmb9JlKGsSVQCqiTwt56TPdlIJY/Qjd9R8IeqHm+6E+5JD2MkUUUiikBRRSCixRRQUU UixYsIjFIKDCxBEJEEZ41udOfsWQM/bGCJxV2eqpkCiwKJwdxZCveqJ4BAdUssySTISEAgggyMls lktllKUQQYxjES0KCJbbSlpS2WWhQtCgxloSEyyzJJP55cVrwyB0YBpPNS4AIVRMSCHAKIYVG8fn FgWAVVJZWyigG+hH1AYpsFgAfSAk+BBPSM7KL6uAKkoKHeOkk0IbCAFBkCWLEJJ2MI6QJI7fcNCk uFl0BpvtKhN3MqfL6Lao5IT7ncKoZGiWXn+h+3O2Zri5hlhJEP7ONgrDwQ4ywwMMNLD5g3Ki/IQU KAZ+pctPH6T4nvIIWIEuGq1Q7G3n1rjAegYB7TLnIs659h1PrMBSp+l27Ks2JDM38gc3Yej9BzQ1 28GwBRIWxljWHFTYPEDQdjMaduxigusSk7n06igrvENVn8y10JhG/EAMHhFRljnlheYZp2EKLVC8 s2NAEdiAEoI4kg5GzF8SappIU32wYGBnO5NpBIkiAkjBAQnlBJSbBttj2dwTUJMKvF5Y4QJvECKg 0ooUSVkCWUnjRIICPnebQAcqD+F/pckk5RKL6RPmJT8pJSaofWdPFZajYqWwD7kTokA+G79SFdwd DuUNPuNO5IIwmWJg6kX4h1lyg1sLRjoZRkZUBnpo2xQEgOwsUgUBy0Kg1VuGQLsVDiOztPAlXMew kv5k7TK1KoJJANyZz4rlBzGz62iTCZoJIVlWBDUa0WShj1AHAzPEPNDQkxtfJlETlK+FhPyhiyQl IUdi2oQOsv2x9kBjMxRFurS5bQPXD8kiWMBUKKh2Qq+fOUvSJgWmB9NaKgNiLoOn5Im4M+0hYM6h Cl4C+yEUD6WEqQUBYL5Tsd7vimSTVtTEkGUtk7gAoXIt0iHBopadU8LbBXVQ1iRH4AxAiBbqZHEI QfwOVSY4JsEPJCmPuAzgbjmZKRmFUxNhASH4JMhqGR+Hj2h2g3r9MGlKA+CyDgHPiBduMRU4Sg3I YGO3dBMb4JIEpAEiQLU1mDc/Q0H1cw2Kgl6olwqlrpTksjGkG+5PUMy5f7oHNyK0G5QyIgdQXVfN hpgUiLlcPluROJzkClpEWkRMmgpIdZShTrlFQxPA2XouJLnFy4i4lJ+A8N8mN6du+5t36UPtTmmF HlJjgc+WA/e8RnlPRdqPSTvB8Z702RtHoD5CSrnnqT/Pe+waEHW2er2FAf8SEQNatin2GlNIG1Q1 ZBYxJRu0TRgCChIj1JQaSawTsFP5MLahdCfTkUgMdqtEfyYFSlIofp+Hh8B1XOuIeY3Rv8PO1st/ hH6tacQflxy6BPUeoxFU/afu1IDtfFF4as7EIxKJUXkU8oxTopykez3RikiFRR478qp/EciAJI5L H6eYiQ5zNMHccFF+R/hYNyFVGen5LzhDqRUnekfMecOcn5eXcmVK1j7SL5JUPLs6SXTdJyrhVFUd h2B0vfvLSXUR3o+VVBzgFjBYvNkmgNf1lpATD2guknbq67RwH09kPtieA7ExkLxueDeB8cgcpngX 3jE+k3hkMHwmiu1Wt9gRKNHr76cLD6UdbyOz7kepCYEvZM2XFDQkEEAnCS+r6n4D4MgMr6RgyL9S QlmGVClbB0nYfnDOBR5EGYnx2aYiNfVNGkRLMWNozQhrP4GbcqJgTGmefcPUSDieAJmAQ7l4A5Xi /jpakkkYCl5cfp8fa949+EN6PcGr9O0c+vKcbwfaBnAw+tO5X6hTT+gHQAeS0XIodJ8hOQnyMRze ekaV6iVdyZkPe9cRBGgkcGHg9MOQ8ZFXbvYcgOIdcuuRyS4mi6AhpqDs0o7F7jxDkp4/okZmUPX0 aENSdmAG2PSkzKxhjc8690NBY20cO6wXU7vZaXQ98BsA97MAbDOFBquwcjzjtsQ1VG96RvaqfFO2 Scj0h4yT4yGngr47vkOfqDi3mQDSh6CZx70Oji3BnR8gMMq4OZ5x7A9tFDb1l6tRTLRXjpA8E7Q5 CfaKB4B1Ht2JkhbIQ52RKWXQahYuRksPhDiQ85YB8M0lqCi/jWBvo3Zc3ZgjYCPIbEG8U1cRI/pU HnCeqekk6Q9cZt20L5DjDvTlHBV1rkGvhGtLEAdWdCuNU3jmTIVDtUNCXo2CUBhxRxQwAbOVEGhC HavMHkIXCWI9fRlAu7tKhdcKC+Yz3poLtU2j707p0cIei6MMGw27TOtajrFMiYxi4PSmoSKTIyZt NcXWCaa7Ypvu3EGa1rAM4zjOwK1LZQCUhIQUhAXtwZBg7POnBXphy7tBbu58oS7WdyOPtk0g2vaO SVVLiHom59Xm9hvHaPKQ9ycZwnzjdPaN2Mk8Xqk9Pza/ZtHadBpTKS+Ge3uXCuAxRykqQuk43jBy k4e0dDIfV3j3etllBvbHDxh4ikz5xvyJIP0cJzJRPFBMV8nEfKJqOMhf6jX2B8ox9T3vTskobpMB 6g8EwzJkzDDNYktZaku1wAa7ZlwIIWmIdzZr4bEyLaHiXOCt/UuvMsFBhki2I7hQZM6tZouK6pSU MFF79yHSmCaDmL1aHUDVDeoc4d5lSBOhNJr7EWqhuCRMBdgo5yw7xlvk849DlmjqjtO6TG0iTOTs IxHgchjzPNMh7Yvwc45sIfBDcR2A8+G/zTJzH/8XckU4UJC2OxdK --===============0329837858==--