From: Bjorn Munch Date: September 8 2010 8:48am Subject: bzr commit into mysql-trunk-merge branch (bjorn.munch:3193) List-Archive: http://lists.mysql.com/commits/117760 Message-Id: <201009080848.o888mhfr007392@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============1464463928==" --===============1464463928== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/bm136801/my/merge-tr/ based on revid:bjorn.munch@stripped 3193 Bjorn Munch 2010-09-08 [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/subselect4.result mysql-test/r/trigger_notembedded.result mysql-test/t/gis.test mysql-test/t/multi_update.test mysql-test/t/subselect4.test mysql-test/t/trigger_notembedded.test 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-08 08:47:53 +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-07 07:49:47 +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); === 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-08 08:47:53 +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/subselect4.result' --- a/mysql-test/r/subselect4.result 2010-08-12 14:08:21 +0000 +++ b/mysql-test/r/subselect4.result 2010-09-08 08:47:53 +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-08 08:47:53 +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-08 08:47:53 +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/subselect4.test' --- a/mysql-test/t/subselect4.test 2010-08-12 14:08:21 +0000 +++ b/mysql-test/t/subselect4.test 2010-09-08 08:47:53 +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_cmpfunc.cc' --- a/sql/item_cmpfunc.cc 2010-08-19 12:17:24 +0000 +++ b/sql/item_cmpfunc.cc 2010-09-08 08:47:53 +0000 @@ -1763,6 +1763,76 @@ bool Item_in_optimizer::fix_fields(THD * } +/** + The implementation of optimized \ [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 +1886,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 +1900,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-08 08:47:53 +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; } @@ -582,7 +582,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 +597,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 +611,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 +626,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 +641,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 +659,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 +822,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 +842,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 +862,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 +881,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 +899,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-08 08:47:53 +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-08 08:47:53 +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-08 08:47:53 +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 } }; --===============1464463928== 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: 8966c4ffadfefcea7799a424be9e1aa5ed5ff7fe # timestamp: 2010-09-08 10:48:43 +0200 # source_branch: file:///home/bm136801/my/mtr-tr/ # base_revision_id: bjorn.munch@stripped\ # esulj50q69c19bgn # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWZ59Pt8ATHN/gH+yFQF99/// f+//7v////5gY/983vs+7GsdrbmW5fWfR18fQDX3qRJtvFezT20vLu190+3e96WOvr2qSM3l6Y+Q x96nvu71m0xjO9898Xp9sGbA664z5zd7tBQUWvc+g77Ao+d87oPes0uYt7vXETu3KUe3u7rAATm6 o9A0Xrz3igA7jt1ABero+du4bZbGWylaBRoZp63eeGscdDp2ArnvaODxW9BN7zW93V3Vb4905DfM e9j6XvrW1rVu8ULzwA9toBu2t97j1tnrQKidGrX3aOvb73ly1ZL2ddtkAGmlZu4Ou23m93u0gmjx zukGqNehpXVu4UNcjuwwkkCAAIDRMRkEyITJgkeo0eSaGj1NDE0ZMBAlBAAQgRBDVPATSnkaaQA0 0ABoAAAANMgIiRMoan6TU/SaZJtNI0GhoGgAAAAAAAk0ohCCYmRhBU/Cp+QFNPGmp6j0mp6m2qA9 QPU9RoDQACKQgmTQACaaDQJpoJiaAin6aTNU9J6eSjyamjCNB6BUkQEBNNAE00aJlPJNT2lNtFJp p5T0gaND1M1APSD1GmnEbFT/eVIm2kT1qIopFp34/Kl0/gyCfYdvMuj/dP9RqAqWixRJB+Yn8iyw f/g3kx/zH+g/0H8ygMCXigZj+WGSYf20/KH57fdlj7CAiAmZbKHJSgOM9zgP0f+uUWP1fvcD52/5 xPrPrx+u8b4fqKPiZS+F3podOEoarRlwXEXQ0CDDwPWADcvT3sBPsufez8Xw+IxtJ/lpNHErUFUV nroQ0YZgekOZxcGOCefu/Z4bIt3n8SRD+R+6djvZqDj/A6n7z2rpY4lh/CFUYUn8yklQokCRcSLZ /eu8jgVZM3RvtM1MtSlK/iZNcFSaSgMfj+F8w9vwKDHw/CBMmUie7UVWEZJ0dPkPqX6ve8HlH3sf 0WGFUF4PCfYA83o+bqpxnM7e6Bv9oKuNNrX2vwjW6otbuq+XB1FjO1eJ9ryqeT8vUuLGw+bH341a /vo11ei7632BkOY4Dj+l35U+IlIZAQlzcc4ERkwPAYTmUObnwZw7VX39Wu+TCvfo1f8f9/yo6L6j 7TP3/ujTt1RBjte76WC8ceaE7LWbQ3s3IkLGutLuhy8knF4SRyGEleMIFCh2zzjpDc8g+Z9L146g Tb3JeT7VJy8B30mBjAtPeFaJl8wnNbzCJvap5zFHisa7SW7gkSSSSSSSfPC/Ae33lTHw/Jcok/KP przWLZgSwHd5HDjat/3+MqStta3Gqq3GWta1/cMERPCfZXacVfSf6aTkYkwjzPOHX6HRJIBHJuDH O1xvYZ7gfFyHMufSzTz+bXfp53ZDCQwhhJjdcMNENGTVmGVRZUtkWWDEF5UlEEgkbIZnURmttTyC J3zzlM9BF1M8Is+cohAmmnb2+HXjlf4bTASQusMI6aoTJ2+v8oNyHc7nntB/LKyxZxHFVwVIszru KRIK0B1HdgMm+rdT8HlRRVLr6ZYZ1oykCJR0nCRmSEJFVkGGqqRVxIwp5xJ3k5IV0uqFeXWu0MwV 7jQQuc1qpUnISJ9QN1j3J83YKYdOiJlzc3R3I7EQ6+OFt2eaFaspw5i7o7kdlP08N959HHO67eYd Ue5EYWdwaDMMJJFtjV/F6zlbOm8ujMtMSQCdzDF/1Q/JAA+lFknF5C6jzerGIsn0ocCMIsBQgLIs goCIRYoaybP7+C+X0BG/HQR7T/CgF7suf8rOrNuJDDDDGWs8CS1DFk+b4Pgwfij11KqMlDJR6e7i o8tEWjMAzHvHFJ9mBq4d/nXRsC84HCu8GGN3nA7vqNwCd4GBsiirVVfcZDQ8Ilrwx2txmmMvjANN NG2Ja0a3BIHGHo8ntYbL3dUjbt6v68gq8/V+aAH4oL7UwCFiEWICCAlkgqoiyCMiMVBiiiKIIxRR VYqpFRFFYiiMUYyRYrEBEkVZBYLFgiEYylZvLxUfskkT659/b+Ox+r3/hspVb4YmtQUsVWCKgwRg jBVWLJPjNAOSTxe0deeLyfGYRwJ7esKnQ7SwkySV8+T6nqQKrCFwjCOg6DuXxxEaSrUQIMJkkkX0 SokhEaiIiDbkp0phF7pRhgwblPePo5OnssDlON2qrFSU7Du9ngtpsWg7xUmbuiVcyQIDy7kx8mg4 zaQOSVs8QsIihJTiYC3yLg9LoZCw1UF9mMh6tATchwSqsK3gIjMWcDgLhqkb3yMHUwua3mhKI1PD lSRFqD0PQ6hI5iD6h9GDyLTjhgtF6+g7QaEBDUVJ44mhClyeoowVBi9sPV9PejgG+Rw7c8BOeT4J S5uIv5YKrTrsgBx0HDiZmFAgRRDmAkkCdRD7Nm+t662F8jpgcnay33Akte0MMmTRRoo7KL4k6y5d Gi8rIe4Jw4cLQSRPCovK2OGBy4oubOMUqb3g6OKU4NZxJtmrMM1RQycIaYODsjZwuWvS1aRg8aVH JDuLLmYV7YTUNRVVTlPJ0HwcPCOrYHb0D4w0HGJJJ/hBhpioYKOCjA/Xgs0U+OzyHi9tnm2PVSfT wV/M/J/c+FjxmVL2HQCkgfor6jw+vsQp/UZ/TWatKkiZZH4fpPmNz+dE+o81EsPKWqvyFzw6/JuX 5s+g7o/fTZXiThVVJH/ztzvOTk2KaqHJuZEe17PnYIvvRxGdOa9X4U/6vGR4S4jMbzJ4cSBQ0SDg ebAuFsPqHCFsXz2bp/xUtWBxMHlkn0hO5/Q45/LlYHH8IEn2CxMi8mO55p03qb9ZWCRgt9IfwPeO FwPi6z1OUn2lJPi42daN+WjpWnChfvd3aZtW5r7ux0vvfgq97WtSn1WQsLlk86XS7j7f0fGcd9xT 5/tMaDZnN9lHhUcwVidZS1SbrvBt46EWcqigSKgtUQj602Ub3RUm7uY5/iOPEe6che8f50Y1tnGd GHln9XdCEg/L7sijRjbR7p9zYDNyKgHZ0RU+WTmkYy3azoqmV78q9eFv6DanadyKSMWWJleww0Gc zZXe0jCPoYPQXY+0q6iGtMP+Rp2lsnasPdllWaW4QZ5se3wEX8z+2X7jnzKU8HYAMQNgKMUKvImR CUNCzm8SUfYT2AhyevmHuxa8i1u+Iuq/3vdjiDo6olZozCuqd16ETHiKTyeCsFWDKZ4hf1jCQWhQ 0h5WxDmUq9OCDovH6+arPtzmTNnJOAiFccsOpbOKDMsRNa2JL+Wp/yw1VnXjjx2Ha+XwHdN4vFOH FR8fFji6XaGJnpq7RmJuuFVKh0xapnNgmzFWQR/a3FvbsNUXn0PHFMrMBUkblE44cpftUoUTZ4ve Zd0uMBkNDiQKCE/y6++H3TIcxodtkEVLb//TxKm08wiJH0Ut4TrHwHIhM+a9K5aDyGd4ue+02msd W95rJMAyudR3OPgcz3e8ZH7n/E5nUa8cjmgAgDoZXyf2IqLEh29xGEM4bc0Dw8TLgTx496G2ktLE dFFQ3uzylXfdx6+amfH4u7Dq+mpBfp15wS7zSHhAA57pxj6T5UsJuduaJE8RLU5i46forH7I1Pg1 9YqWyvAeBC7mU0NW6L5HS+vq6bUMvCe/2H7xnKrtn93bUYk/yoQRz3REEG1DVaP+Y49J+V+OGeNP JA4VoQDwp7q8zQ5+NPcwWjC2bV+IatPEfp0vkfjYUTlHwcRiqk8mNbRZVrkK0kdQnGOwmELFMVOL esmbFIuySyS659FS1VTEwGJRdkpgwWWWWbcjnR6KdVWVfv4vk2KHmG/gIAKEZ4uGgxHY6O/aX4VU v66Vjm04K9740IeqfKeqmjhaMPrW5wxyunWtyFq2S00Dac9IM+yrY+eX4uZD0LiDMkglLMYxH/KF 1lCRq0CMpX4b80/lIpK2MphpeB3VOiwamRh+KhcJyZ6+ENZNvRbcWe+vaAqm5YiJCdfAqaJngle7 UjRoJYMkM2l5T+ZC0/angnzT60+tP7k/cn7k4YHuNmvdi+DRj+cYrzHkwh2XV2eCUo75FmZsySEK rOVSkRMTk5OLEoGUrxTrtryGjxajyP4n5Mni9z3EFramD6nybGt+90ODY4nGWnQ+L7eb0yiJlFSE SGy2Ne2rZ+RKuc6RTXHbk5NVMctUu2uraXeWmLW2ltqtLe0Mw7ho9nm4MbmNS5PQH8thQYyYmQ5L kpRhnIjCzisHSbwfdW8k1PE48fPhfnBoUOoECphbeqlW8XyoyslDrbO6nKkqqkWtKymNVL4T2VLR dkJJfTNt16stm43borqiu2Ka8KuPdkYgBIYRADmSkv94SRWIxYqrERVFVVT4mMEPaUJRBH8vvZr5 kAZtO04Tp/rHPN7oZqGSFWIA/QgUzkKMiE9/65Hpk1Rsr7+32+NVZSPeXCSgX+IJ+1gczuNCyKH5 MsZ+1N/6DAnT9BnWIIKCc+Sc/SxHbpedwNuN72+74nfP8TipS86df5iIEWGYAPfGr64HdT8zdSg5 xh+QmKzfMokCJrPpnHZWtIVy2MhsD+fCsPSlflmZvqHsH42KFUDMzG73uN7Kmuv1PBA7MuUIZbWf it1U1p3DQoKoDKhgURP6p7n5hj2gJB/gYjgiN7mpc4/Tnq5Ox7GY+GjhAwbVMjpfN/tasWLrqq+2 trREyWfZueSSYOBKO/WTGxx1eBoMWlwmGPEcHE4nK4m8XbNVrrq/IvJfjdxD/uecoYQ6xAtR+/HB BDD9x+s0tPvHiE74+sh+1X7SeDbtUpUzTkSiKRUlBfQ+QfJamjjgGERRhwXtAsLr8uCydrNcZDuR 7NELspyTRZGmEHUyjGqrGhe2GMtHGNgwoSS6bJq/I7A6jq6g0GOkRSeAznTJnoyuTGob3RpMoto2 YOxcmZyWZ8hRUyEus1krYcenajVI2ov0BsTckYJG8aGhKonNNyatbToTdhozjGQpGTzUMZNUqRMt zwFL5zx2g3vdtGsc5MhXQmC0xmY7BSiZVoIQCYGw2hRzCZqwaacwt4CSzCZxkO9TGgYCkwSFy2zW a4vhsu+7cbq5nx2Rf1lO4dkR4fJRORKfL0d50Vt63Z0ErDbw5XXTQfVXGP2u5lQjyFtH8rOIk+9y e2nHjV4G6gmETMcttaXwrCrcjqjc0Mjk+xzh6Ejr/tR6lpUUAOlOjyxLMLkpKTEmJMEzJcW45ANy TCUjGMSlglkBLWRIyUhErYlixSUkWiLEtJEqQVIhRIDDKjMiqoOI4lD9jz896+CpPAQ5SDAp+OBq DfERWRvZkzuZCMoSPVIznZh6pSzislR0SYpgl8diIftmeOCyzFlLpaM4YJkmNOo9gfUHk+r5z/b8 2f1pADo515rbbbaQN+MYLaX4OMBbQtsts6Orv6aL37dZbZbZbZbQtsNvNnB39jGuZatl116P4hwe kTR8xVS9/ziEcQKmeMgapB7Tw7goHoz7xJYOo/mHmDBtci/jOHf2x1CWcKl1zTzaPeU/oEDFOEHJ xnZXUPCQkmm1hBSb0OGtJvZvYUSTghNzJNU3pDc6srw1uiajDTWmE0eDA0VNUwzelzZJlm5DKENz MoYSHBMoGEw6Mgb03MmEMuIajtwskPbu+w3m44cRq03SVWLZgiYZ2N2Wa2F2CSaPtLkZrsZMU0kF iYUwoirLMZLWgzkml1ybwtLBRMpKJvWD2vttjGMUlKksiSAMEjcGKiLcQgUGFAiFVGBaoYcuHEyZ +qLmWRgUQaP8YZvSC1mKTEQpKMUYGBQRuQSomoEgaKSLxZwoXjkF1TF4QJjIllMDUvg/dJECIMLe fDxBFVRSa3G0OH+L9/2YEJUkqVL6VtF8IgqJNUE5FjAymLMQwgOLQsMWaXEbCHb2DTVirnaguTW+ QiIipIgQSAZJSBQOUJNEgURWhQIiVrbDkcmLJfOyvqFhMRYYLVAhRKxsLSNNtwOJsbF/BguR5KFI NR1XDVLDxwOiBMiyZExSzL1IwC6XsyrsbHbpvffbjTi4BtTcQ0bUHIroS9ylgyclxjRVbszNPGY4 2JRRLwSGYNxNcUlkC2LVdbTC6w1mI3X3DDVZJy49JeVwYepcKToRLMuJvqEAJMCNJ5RVSXpOFRZW bHK6+ecFw25F5C3SwY2Kc0U6IEby9CDzdWLqYVSxEuIEjAhJEFRUKMhLIpCV0OdjamdmdNFINEUJ NcssEJgtIasXLgw3OOZTi0NejHLCGcqQKVLarjCwQJgwig4LCokyKhLSqyqwUnXW2hUXFLVsa8Cs WigZb7yDFZU0b8TdYq3EChZACXiyRS+voshisG/+AGDRsqYMFzg4cWIX2caBkjEoJFeSXFpTgc7n MkbRiJI3rOClT+Q8nJXd8EeBNkwoQHT7QENGJkWaxRSvI3JZNR282hEWYSGlowZTgmrEz2OKRSRg +gXy5bNPzR4WMjXLipwcsWvQ0+GQdjvTwRbL6SZupIrt/NHQAx/oIhmHmSU3/1CTa/yBv093xgd+ 3MrRkN2IcbeE7MG9td7szBh3F36BcxK9a1GifJTVpzRJMkRoBsxixN9A4MAMob9bpaG5k3JvbtxY mrlFud2ANGsMOiu51RQUqHjAQLg6gA4OiViq6A3sUWmnevjzrr+UDP8wMMWAWarF1YakfEXPQUoS VwI0TLgoZnM4fvNm62jtyE5phh4CkrI/WQgqNZWyQTeQeO/VA1FqhMHFQ8fIK5rDaoEY71we6jIz mdwrFHVCa1BMyHCZIN8vL5mGLCIWEMIt4/wgkXQLQwxmxJ3Xxj9IkXxALcQtJ+Mkq5As5gkCQaap Luw/XASQTuOiKWc/BaxIUmGUUS/F2mQpSN2ImDwl0OxFdu6WRAVhJie+i6MdzwSOxIuxUanAdPjt nLfpIZb2clJmz00zaZZC6YRSokARG4sUz/KPEU3E1WU7M0Q3pIeQmmT9vHC+K+KQ9m9eO/Ns8YMX eXisha1aN80xuubNOdodWpGdpZa+NrfdRd4lCzUWN9Uku9LTEKTw0Z1EQqLmJIuKV8iYODoVLmuB i1ZzQkiKGJjpBKpwRmJCIJlh6QAFJlBrIAzSQch4mOdBwTksmQNTJ6pFL0SM5ziONzmqPUkiVMWL XocxImkmOu5u5OizjvaIqpTe4qs48b3+r+LtHklGsya89JxDev1M3JeZMsFlsnsSPFI9dxrMTcO3 a7Sp9d4hhgVuDIenuiLdi8gXr3964I24WcDQw5kT4jEOvkI5oNgwob5XwW+K4GkO4JhcFUUSHZIH EZCEbqiuJE+RMeCzfyqFqjIk4HH7bTKtP0+MmZCRllR5Z7ogVJ0jM9yNCBB0QOw2ypOBGKQJnL/t RFAsbMbx9PJ648cHk4Mx39NiIQcWJJvApEVOyrTxyOQ+YGJvACz1Eg6nYBexBC6ojhPk9j+H4dq+ xxybW+8b32adrmb7cC9baFeOdg3iztiJt8t+4olKE+eYq3qAolidQpqIh4HDiJktTv7SPcIbP1ky IViyR1yJayRx+LoHDjAfJPWhj3OLpZeW/hkaNE3Vz2DYp73iSOxAIWSp7MT7ZD4Y2ZNGA8ZjYa5W hDAYqovKYNDenTFhashI70CUYFhUVDsDhhAjM4JsS2ldCskE1mfVvwE8+qhuYoCQlaUGASJZG4eb CF5nm5TwdGTBsHfFqmsSXEyEfg+MhjbXxQujO34OX3XJnTyfgGsMak6MBHF2T5o9H0HY+b4eK/Or Va0cXBUwPb7syqDl39fwgjs0NysC7jGeOQxwpoDhPBmxrYzBkEXpgVDdYZm3cmKiIuH3guDVUJZy IL78Y2Ih/OwsZlJTbSGjYS8jdftBOjQoobLYRAYrwAaUSLiHMYTC4UjUVRmp0zrA/SHAmFCZqI9i okZRUTFURZybihowkJBWRghmxKJKFyTfLMIjZAi8WQ0Xigd5W9LdHZBy4l57CsLaGqV7Ks0ypOZM oSNa2aBTXmWzFM2TEqQEpBeRQaaSIt3E7wd+rpaIQbHTBPWPfYYE5axKRzSW2kraNFg6iHoYXSFC 9KcRIyM3iF9biMtaFKhQUgsmRJit96no/ITEziprjZowFIJBRSC0dnELEgSRkZHY7Bf0Tr5Ft127 OnR7euifiIZ9jlurb25Zm78Sn3ZRUjNnEWY06JNAKHQMVH7kibQRM3BHBGyd9JRKp2KSCaIehFSx akuMonCiNeIal+YV5JddimV0i+lsTn80aieRia7iuygqLdRiVkYkCfLV5i+CPLZoFJTqg9nh5Hhz DAkNkxYrIfvCgi6HdEXn3Vkr0MUFFLfB6387Xfoxwd2zoGlokJ+wTsg8S6riT8eVSJBgjZhPih49 siXt4Tv0nY2GyFCY0p4JETfgikZkjy/KuoguCMT9awe1rYBMiIYl0odrDopqXyjGVljtlbmBREvD g8mxyx7VuUmN4VPHgLvpNNVGsjlSRLSssdMUHd3Au6edo4j0bICSFRd4MqfsBdkphTt7h78F+3qB Y7POwKdxJjkfFgkSMRIqPykXPOyj3KQFnExPQNmASSpqhI/Z9aIewnB8euDgdDiodcGz1UsbNhYx H6CaC9TrIZlJRaSLi41SlEZ9l5cdxq93YDvEN4iIJZJBWPg5jBKLeNgmjSS2JuEOr2Vqlo6G8Agl voeJgOIvJKfaTsXMbSyHQfg50q6XNzOFMShz4Bbh8ZQBMU29xxfD8AaBAGtUJToLjRfUrGUKlrvV mlSlZKywdbAXRLXSUu2lRRRMHy1MzD8/zMkTQhngQfIwCCvaRU3KQytsMfzhUskPWwmejkkOPOow nFkhTeYTko7Goca72VBpTFCgqJBEAwd43uCnR5ch23TJoQ2mTKVNI5Cby1AjveHm7XfMyDiGARXU vGpEEbZMvqwlskT6C/jeQm7dhEOTPIp836NYRbwTrCrQqbmiDVgdotYtRwR3l2Kmyw92mJySBIc6 7D50XIkC0c4WxFBpKMQ/JYb4uMVNgD8aJFKkSqJT3XlxhUnaBbgeGBcUJRUzKBWkEbUF6aKXyWcM OTB0aqkMMujTWasINKWlObSLUoF7j4LH1I8cI1EKH0W6YIjnpGgbEy6LIYn2MiCkWKE00fJE1pUW 0cwROagagatQgs4JGqE0riQ5yJ0RLlHofeJDAtiJ6CfkoSmYID7NRBx1eZRsh9lSx1I/ATnB/QPS Ik+9Wj3XS8VeHHagR6KvorsoyIEC7gWvIo/Y/BN2QsRqVNJ3XCIsU22ESpLhoVNqRtYVo/rT15Tz 3up404YMHLA2bjJekHIxnraObk8vLnoybmxZvMCer+x59fFGKiBciOUXCQKid0RUYvSj9qClrHJl U8ogKUIpLLFxzY1yOgDuPi1Q5P1fphjGDc0odFaLcwp0/A1wmdu0DBkvGTs2PxQhkHlcIZQE3idN oPnVqyHnvU3ECHmJidSZxxr6sqegOjaPrBtUiWwWodfWLxXKVnuFDdwtBYFvI5RTtHj+o990OOI1 MZp+dE0ObiaiZRok402jrJgnsGCONC82s1CI44inFBQHJrY1q53Nic3uE1bN8AsNzeIeBtPvt2Ni Gmw0AMH6DwRxEq1piBBzFFji6Jl7ChQBQUKIikCB7aTomcpgYGNAstWwqOrHYUKLbyJoo2BO5iAu WVQwXtA1hcwAK0arJejcQKiogTKWoVofnBo3uZfItwkKfa92pGJZJly0QCqzXLutq4+cgjVKD5MT gYpMSZ+AkPl1MyfeZ8cGzg9CUbIVkM/Axz5HIedfFEmKhC07JXn5IWMDkF8c2RPYyja/ITUhXEtY zSMvXsrXdMzETqYI4qbJKMupnjdWM27Uml1tNG5qt1vWHKo7m9eOrKShi29AYgnktW/0heZ01uIG WQcFGtJkZvNLx1G10dnS2Le4MOx2Bhw5Y61ZrIWToASGEHbzJRpSJUL1J9uRGl6LdFYqC27284Iy 9X5kejx0im8jYPxE+iJzxx14WiNRAOiPON7vJDIyPPsk1xLUAhpla8vqzLS92pWbLd0FUnOXR1VZ 9XgUORQwMc838+4b4QKnPb0UdptZrr3UvNALIGE2MQ3bnyYiV7pdvo74ItF791ubHJkt4GKExOgN LL66yodmDsCBqxO8zC0dnzEh4kd5nNV0m9DWLCo1ikEiBSNB6REQffIo5VRK60mOnPGLYbMCwoYX GlbTgYwlxUKpkz60x6HBtV9HAqY+BwVIEyVRjdFWnJc5PZAHPtvgxIiMNFEcx95WDy6RD9GMhzKV +x4iaGhQ5J0ucmfiISSmWoXscETMiBKpsRRzuiH8IgY4LDGuCak8bEO9LkyvK/n5pWTAMWdmPlkd nE9UTdgWpJik9hczi0BinI35c+zcIkN/A6MNF7Vd82dSRhB8o1rduLjSF4hMueDDw7hJFWrzhUuh GpKeEyFJIyl0yAKqJSeTAj2QQULeiLEsm50T5KlqLL2vVUl23Zv3nxmG2K0dXrZyGg1zT6hxDBMY ROJWSFhrifWnw2Kq8HJqPA4WhSuoXOumfiXYK/0CGEAU+TgITzorZWlQBV6SqF1CQTGq4ieJeKJm Bemvqc/NwvXxZ+tpG+t2lIh2xFztkABhP1C0eQFe0dmCnI5taZDZB/OpFyCXJmI5KFOyHI4pMqNE aUknC5jeFKM5ISAIhEHKMeHEoDHBG8vRAnwiBUrwuz2zQ2bYtoj7HPuqqfaYZ+mT8MO/61/FuPk0 IsvPm/Q7CDI1cC/TM14NQ/cUD5iLIcQezbaCA5bXCUuYONKCuqk4VmRWorB91qd26pzGLSenOcDh ZcOAIPudxVlSgPaSAGDv0fE8y3OvIohgEPP14Ojvaul1MlOuahmLHYVdKZY+zNpod1uc/9xoGEax DWaWvu0sMaZ+ZPSPKAgeBxKuowioSk/rRB0MwCEXj3N/doh0ejjAMVI1MERu4KLKqEm9lKRqaUt6 NVkUfGyBg9j3T5/dlvtgy8qjz7QjZMeyN5YZuGRdnnljQIYtSCyBMQdMJnjhnT4CieFDyKxcqWLP M8/LuiZ1Lrboq6bKIgwoJHQop+POQ4h10ezOQLYNADiP3dNVUTevyOJqL7SIPExYomugtLTKcnLC w9O9IttIm3bYGi0RxFGMDDGWPArnrguehaSljHWA1o+43sFgaydwYwWGNopdx6HyQ+IpQOFKDiVK +Q55yTgNFMkDBU84G7Yj2p0Rix97YkXUU9Aw6ah8xO09k0sXgp5j0dq+fQPjW9iW7RPJORyOokQF 4JYDIIX6vRKeclT3TMwcncN0u3KRFiVmTnXYsksRxV7GSXeXfDYNbpWofagKLUThSk6oQJEpVhKj VtLoC8z4/KoJTsJUQnCCA4xNEunIUgJrhSc/KKilUzJf1c+NU8CWISDR1pdbWKog5hOIJ3e6JVIV rBAomHiXXUaxUxJYXvgKYLPbnMY5yLB1VBMW6CuyS3W4p7Kp2UUVFBEkiojEJLE4jdjjWKfAMWn5 UtbZ2zFJQGJzbSlJM4nN5TO9O87aDqeJpA56wdjPlmshe3N3wLBYci3JCC6J42MLIlH640HRLYKF CFELnBzlKF+QEMYhULEkSKNoZtpmQ8lYn0/cJHBIgS8ojxIYZn5dmaE6GB4fqodRPRhk5GEwOh4O ihSAxIyMP26NFmw0/VavOVcBGpIgVFowxtihkwz9hCb4GUtUkKFBTAp11hy3f29r7ThZNSBUYiZ3 GbPy8OKwMi6BWCPcYZiZcfssQWDFHJmA6Oj9N77XGU3V8GkUMmpYmVKFCeIENWTwTMHVCZOvR8g7 EOxptCdU/ERCUXZEQQzcps8S6SxDndhLhANcETZWfnG7b0lRamS5mfc2dpEypj2EfYSqTGKVY0xE kLz0pMiYgZcZODDKULIh1GlBbGeLEww5Z+jkxXGSszdC9gB5J2rN707xzDNOYnUAbR7xqG8Q7EwH Wvj4eA3b2aVryGQzHjeba5PiYBeUR5xkC58QftfdEGPLqJqJVdhxGZuoiRrWpR1QkVOPtgp3Uqm4 5Ik+zxxMewzUzSOAxbOoFgLzKLMzBbYhpEA+uuzMvqGqKkvr7UuLdEETijgC2hyQbmQgrTLLK4gT D8OZ07666kguzL66foATcobHRAcqiV1F+dkscDRsOQS1qJIRCsdYz0thUOoJychEN8dDUInFaKiu UGGRatni0BS855+9qSJHZ2JkFOx2MHY9hAW0jMfdS8NCjXJuwyuDR7kBoogamEDUvJ6KFCZhQ7IR RCMI6GU9Cwwc/aWoZJjCnyANjzGLZPspLvLSyhV98Hlgp5Nji8Zjyw63LZt2wYyhMBD3HIFjaa94 ESqdjxdEDJaownoiYc0e3uydytBTPJsqx0vXEpHcZEeGh+pHJctIkhOjVr8bG6GDnntkwcmvyT3E hiXaRjmJl14IschwWCCwKEe6kxZlpx1zz2DojZBivvxaF8nyIdEIcXGixyxjo8kUlk0KT3UesNmI qtjYprqxUNGGi0CqlTsUGF2ZCtOLohNED0hP6ncT8VPzYDTnrec+by6tCQrEgz1azDHWatZq3uIk 44mKbkPGsxJB7ppZEIykWNj/XI+WtBcgFaGTiJiQpHWD4bQmMOPGQrSHcSR96JXgVJFgUz9S00FT XR2kE1FV+Ccw2MXJTX7WaWOFxfk8Ej7RQuqrKjAqYoxpvv1apiyJgRjmUGtLySeYJPQ/xvbg1rHJ dahlXSJjZpwHpErXmdWC373AezdBZJJwcLuGI6L3uYe7fo7we0jSS1cScZlPCD3owHoGhhoXtOKy IuqlEu744kTch6RqStMH1dP7EVqY3I2GENYwNwGCeRxxRCkvfEBjVIuw2vfhkyRi12xF4jFULsOW HqViCIWizET4OmkhWRpRzSyGfWabNXIj2+spYByVB9KLYKhil8TpCiTsPEZSxCEaqtvvpRALDRBP s+yIPVkEqSqOIKOmeei+jZImsKqkKoTIovnSNsyVmrOQ6TPaybsi2Fh0FDBUuRyVuZQSD2xTCLkg yBatHxk40UjWlSEbIBCELolxCAzAISGGHwaO8TIbPughDjesMywd0SAt1h2d5COTMogRugxglqrj VBiGyJ3KTiJmiq+Whl4MzZJPmwRcexM2fVXrN1uOY6zeVjciPFrQKCiQItnQ5DkiVVDKRsThDRaU jRsQY5npJLPGDjmJQg5QwcG9zUShUXeWInBGGTZQdYx2P32cG55KwO7lOCdsJwbVJ4Z6CkCgiD76 BjuIh1h24KTMHPe4uyRnvg7kiIxC8ywKfdA5iZ0ODA5UUY2RqWmWCfeZSO0uMXahUgLVSAs5KcVT EQsSG7ZN3MFyk+ZNk+CICmDoPXEyYvMSQp9jInipx93kCkvBLYup5ktJ8tuY7yQHDsK6TRbB+9uG jpP2v5Hkvq0q062QSRASQGt1ZrBkuhSYXklGRZ2hN6yCNDV0ZiirmNSqQutalVmE7YZRoxu960EL DYNpmZrDMNMxZnym0q1YLi2ZtpSCzRaSUwaH2eZiJM2xSxJDLcu1gIQQO7uqKkooTceJUUkh5yH0 w6OMKWbDSWSUMZ4Xf2BLrSxvmFRSFhE5Lzm8ZENFoCbeM1adZhhIjSSHK0yLyVQKLgl3KdDlSZVG W0SO6/qfCrqpkFFFNIXOkaiHJsgeISK1I3H4XrwTF70jLg4K3Fg7DFBxiMxCwrMWmSQDw9uNTLHA 29wFCsSlVMCthl5nojGAw4iZHqb4IggTI8craAlpzqSuU89YMxL2W68PCJ1pZbFF6KvpmRANFY0J i9E+CpKwMcceDoyQhk3yYbhCy9pMi75ahAOu1SZZDR0maduVGjkIxLBsM66sXxhDbMgp2W/Bo7SQ hlqqlc2BqyJJ9HcgVVkmUIGhvlain0EQ3uX5M0WaIiHCTOmsnCqUKDqxFGl1sizy0fChMLEBTxc7 xPJsUUNDtnsFxhyJAgUHMkKyJljrg4KmqEn1QciZmZOkaiqW+mTBj39pGYmHODZ2MHHBLnIiH4mD SLIlBedRGeQumPNAWgHeLtjmwK9eXYTM6jIKeFBduUj0L9YZ8wxUS3NAMsF4pCSHQePNrAg/WuRu 8yMjeTWBRCmqBiDPg6D2LYNcyZWUK2q1MUoiapVVUUIcRUq1ikxzSPKWmAmBaMmaCyYrsF0ZGkjY UqFJFBZzxYhGyllJVXNKgSRagWClxWE0AsVEnItGVttLJ3XClEUaKSFJKFKhSjSFRLbKRSLbLqWW XUFRiaV4hTBIZ4GhOc3bcf25/UUpESGFVhymtAWp9zPv0+9/XgqSnCkNPAzr1/qMHGeITBSmBK5B s7QTyTnZerhr3tHBRSeQc5gRemMGRENxXZYRSqwsJLWROEtKWZsvn+JCvzQAg/0SQqyWqVLrfU8z 6li8k6qR2xjFf5T+ttuXDHTcENgMJtM43jpDblDBIYoyRGQUUFBSKxIIKCsBhGMPSz5qqpAZSUqN MFLgKgsWNIYCiSYlY0srFBQbIMSMsRiASWLDDAwtnAMQmFTRz1hWHTcdCJ/cKsRpLqWU/zn8q0o/ lH9pSLJH9mw+79h0jqTqydJTsITaESRkUT6+Yimp4CwDrwRCpEJtIBSEClKHcZP0v2Huvsm4qceT fLWPyxlFSWk8UhhCGMIspynig9Sd4P6fiVB/5R/sCSQoH+fIfUP9QLiAIVL2E3hrDd7PRYWG34hz SE+WMQGCIxFSCKRZBhFkikkSQigGA/EmD+ikJ/8TcaCcm+FBYrp+b/ymfgG+zgdSSG+SIq99EYrp /cPOLJfBMU1tMDNF2n/7cnIy7Yh0ut+9SXVCUeFQulVZLKKUksp0qFIqqq8mdjwayE8GZIQ4/AGe sySxKiXoS1jdYureh9sxhtLcEB4WbLKwTkmzdYjw2uBkXxC0hWCSmcxMzQnNxaKcjBi7kutE7Y67 T7VLq/sUhH/E8DimfG1NJAatLcSFxtIQtLQlYYiepxyf0yf7IS5/Db2F3bONh3ejBPYTAkev8515 Rk6iMgzpE9bxLJP9RktDKtY6/uu3x5OZzYNKwnf1iiVg6RHUqJ0FgcbXiBrIBYKJF1oliKI2n+Ei Y2EjNNIdlxmE77CdAjfJKTAbECaHZaIgxOiTwcMN0LJYxqKUs3yMxoiP3+knQzI0oNTVLaqS1EVD 0GqklCedDzUT86GNOhzSPOdx0kR6FG5mopfwVgi6nqW8JZUVUiMGBaHQ6UUN6e46HsJ7DqTc0U9s ieaWlzWqjn4l5chSpFSlbq73RCZ3xwQ9bSdaUppzEj0R1NzacDuYQ3kLSMHsnwbCHYSOk6ApdTjR XfZRNXFIeyySMHgRYwJRThg2HhIm2HMk0pvNUwDLTRDXEehTufwjhPj3uAVJDcLMLu+SG4i+DEpM KxEJTJEBRnQksDBSGmgC5BzZVGYiWby+K5FrSlIoyxQyNcoa4pOOhVVVfZZb+NpZRVGxN6PgnAjy NoRjOColM5OBwNl6lTx77l2K6FnUojtaRjyasSHxVI6y8mxdjJHIlOLycjgayJ9UfzHtPcfRkJky ZHFxxh2DJ+9PyZ9JxfA94IiIiInwpRBCn4PX94dHl7Dy+Xw3jFgxU7DYmRNCZCUohRQocJBIJleb RfoMNA/cTNhIn3WSWwN0Mh9+MTrNBFYTYnZ+nAe8BM/jtIWGBKIRlljAkoSRm4TivIGQgiYEuCzo IEQuYkiKIlpzYAollSZKfzfMobCiLAYEA35MHIkDK55A4mA4IVkKVXwpIbghD9P+ohUlSpAnR/Pl GAan6pR9iK3Ju/pP3vwYwmDdSWkUo/d9n7v6vxZKSBL3feNyMj8/51Eref51zmw1gGAFepmrKqqy p3vrxkdEJCfeDxxAnzJIAMDwicLy+/KiYtJwsORjgiO2uIn+g+QBQS0qucEhWFPrLzImSMydChn7 PHjRJVqxn1YexwhsLckxixEVfuELf1/7EDEslk4xsGdoERtMoOaSF74NbDpZEDZTTlazIh12JcC7 uiYww2TJnLDNaxbhJwFqGc57dE4tWLkswsbGd+pI6XnPKPIWPNIr+ukBAh3KGeTVo6h0f5fJXtMi diJb0VQIeDwOIScSJEj47xMyQacRyHcGZw/gK3EwrHBAYputJ/nY7mMKjqx4o08Ci+QgSPumoWIh nK9t61wR0TL0xkm3nqJ6tO44FZmWT7JeFuQ/uG0OBSVlVVVsjIYsxLUlS0J9Gp2RvsQDcKj8zcAn jZ30KAJmyqXbHnc7x6R4v8UvLxhgbY9SZeeuQSCySkPJPzPVIPMsAkL/Bs0FCD/tBiVTiFqUnfuE LFR+U65Eckj6Sa9ao3WlVazmXWCkqHvhlCecJOdh67arA/wCpQTpmDlamXtX1jP+YHrG1PS2XiS8 MpvDUXIU+UAIPu4ApUH55BMde+A5hjRE08YwuS2CRAkEJtRzwtQnjyGrMpYGnE3wyicQQTFNyhDd HeSQCBdUdA4gIDj1kt2eaorzQJoTOEQqKQpTFaYvGcrJWV3SqJx6mjVsakKYHvzgdKl5bEQahU7j zG17WtQ+01KpRPmOnsDfriDD9f4F7VpkfjEcRJaDyC1k80DRN1+QiYnI57+x48R5CRT+M/efVHZa TB++wPyn9G6GcEj94aJkuLxBzngrWjVKzAjgt8zyAg5cqXCbqU8aGOeomgqGD8xDJkn2HmZqFg1c 5PiI2B+jihQp4iQ2HfOUwWY71FicmDByCljm+YnaobKot6VJGtCBNCqgsxYn7t8DM9MEIcBXkiMa BRwUgKB3Q+sTtcL6RjZc62cp09CZokdFC8tdigxnJKUrtIrUcUiLJRxqFrnvgQMEgj96ExCgsVBa Mx8HlJfhqJWGF7YkAnKhi8O8XRKYOQK1OKulZn70SPssz2KFShweg71GB1I+Uh7IzTtcVOOxrubX Ypma+qTraXfTvtamMVl1urduLObqYymCcj5pruUpSR/Vd1TpeEj6nlGwSjYCUbBLICQL/WHOdQB9 awIQMBxYOZg/s6K1MLBq0LlD5XcS28HxHKSLQP5I40r6Mp4pomxH04I7lVwTkF9BauJfWBPsNPwE rfceWIbhtXoO5VHlCAkQopUJ8CBq0ukgQh+Cnd42AWCtSVqEDCMLCzNiHb1B6jxkGw7Aw7y7wLed pAeolGLygcc/Yp8DBaQTIScKjBcPX28D05IUK2i1mC5rZn6kSc+iR8k6pwSihcWQnxkY645gEwoM bvbUsDGQ78ncoYLc/lmJ+h7djJ1Y4qULnkgPdzs2gnJEpP0MOxwjEikKDYSp0hYcjEpKxjBYkftR rJS2TJbATMYkQOpWIliRgtyCfI6DAzDGVpSV1lbsDXeok95Sg4mwb3Mg/j/QcsF0csRDZMvN2obV YXGI0B5fgZGwkVi7wSUde0mrsGLCgi9txtNxy4xPQtTkZfa4pRxPiFhbVVMuvIR8HCbEbjpz7ydc NRkqNs+h0GSiJ7HoMHnzMatgPb8AkWY4kESa0uGMEW4XZkhxkxE8Kg93QwMlUZdPoEenwGSPoA2b QHFaHwQNTR7louSQxA84B1QC5k0OHHIJSBIPoT1tGFgzA2ASQ+CVWs0kn3cgEFsJhbzFLp2BGr0k UhLR9LWbT//JOogL26ubTuOICSSYnWweLcEkLziNqahQMa60xwJOOztMtXeoZcesj/7KskxShcK4 34EMNB7V5e9PAa1CPYGrTo1KG0U5j6x7zYYDaHzNEoPhBzg6iSZS1JMiBRQQEQWDYGuO62ZixMiT DiKhrbL0/IfP8uhtsS35Q54EmAXeO2FLaioqIk1QdNgkUy1RnqakeRkYFfscLCcctXotjyl3ozt8 2xvxYOC7oMJzM+TQw1TazcL/ITwnYwZ4kJei8cAqXigdWmbykw1wKU5ggnJdi/aJATg4LGChJr6g hZF2WCx0AiHwFlQEi+dw52SuTygeVhhtZmGZNsQkLt2qManqMWiVvsz+wc6EQ7kTDJ3P4PI9T0X8 zKjH08HaJCpTeJ2Kd9Pe6HFvcLlNeDqt1+/Z7JHeBjUakPgcGCQkEmCSfMgNTnOJanHSSAxeN3GU 02sMjcTHgIHkxAkaGm4qt3FvEKJIX4EkS9EWY5Iex0JDBB2KBzpHz573DokM8wJ0mWLcQNzKoszj haSkTPLavK4ZrGHDJmSxJkj3FKnxgbGYWhpHHETnYvnvw9ixW/DHQdTXVjTzkdob49nWOTykiKTu fNOCdUddRQ8W45Da8GwDI5QdwzzketJcDakBJSCUUWSlipZFLFSyekmzUPW0++Q7DlpdknV1dgp4 rAnVUGHi2yC6JjyexQwA8DOfCTU57PMlk3eCldCfOufyputeZlzBZecm18/Ho6lT+RMWJP92V/iq VSzrUsfxVkYWMWRljabpWTQKmH5BBbW0zMzVAFuusAt8iBHDQAnTDiLZAjHRuRrUCYovWSOArCI6 twDgEx13xIRWlhAjbF35CTPgQEACWRDGGlgevo6qi3NXJ07RZD2UcFivSnd4cDD3el78rXgrYZm0 FtA2LPJ+fUbGV7WfJfPGRJGDp8N7ERSGMiTWUWYY+ox4bTE1mvZOUxIBwOnXDGZiiwpqqmq327+e DtPJ+/SbVs3bvSqhq4Qmt1M8mvqeY7h0Fj4nBU+elZ6wqsB1y3wccUyRG+G0Q/BKN8j50JxBc1mS qdiBSq00MMVqD/UiJDRKl+59p9Y0z2EY0cGjVjsU2L2gdzt9dWMNJrH8Jn8HPofGh8YOZs/Dk+Mp P23YdrLZo5Y1VdLnWOrwflqtl0ul35v7rTGjB0WWujXkQfYt+pImMjYRCCiau8YMxaUNEoYcEgk8 idOhI6GNJYNW5UDk4189XLySYoKLSdii82Ysd9BkOvUHk0iJQPZrXBv3Org6XBq0908pPQqSeqA9 sB5vUZBDohJ5mTtCsqRSlUhFFVgsWMWRQoo2gmmVvJDxzJAh0kkJpPKkp0RDxFC803VGgaxh5ma9 pt0GIXQK+quWnVKQk9abXOmSBwhFBTt5usOJNkF3cSMTI1k4VmJc+RMXzhYeoImDMS7JaZon1OyT nvBC6pwzzBmbsaaZD2UNdyI9PdF3jJAcwASMoot5uUGtKCkAmkYjWhPU3KfwcZvZExg6Pmd5iSKX 6Wql4yhpvNpWbkrcQGZgzHTMXHQetNC4qKTI9P09HHoMxQbXEYORf4VLRWDEA7QBhUmAkcNWPN78 nU387Hs7ZRw8eFFU9gkOqWCJOc7bsmN9kO2hAVx2e8TwEOTgdHYBVaSOHcOIvNRcXoWMLkSO8fRA tBInQTgGglqPIRqNs3bTHdRFodz+HJm4vdZJtBIpu1302RUYwg1cDe58qKBIv6CRw3OsmhPNCrHZ GPFxrx31xL3ClwCbTYBtEX15usxic15HSf77Hu883eSAHZy2BktHWmTJPjU8YneLz4kWqMNy2rtz e98LKrk0dfAtJM/YmTDsbHGlVTK2imJSQvpaEgYkLOYgBiEhNTkJPu7g0GVXvHQA4WBlhOgbjxJ7 QO0SW1e4nq7U4+PFccsKzrodOnjDwZ2kRzzqa4NcbnPS4kZalY8Yy1SPiepTSSjaw3MZrJoqqGFa FCoT7iBNKkLlbgY9qhxbGS9HRrknmP4n5X+7t1SNqVT/RXT0FqjGg+nZ05R6j0zzeLULXVvzm3Ds Sv0GsMY4zdjiJDYofcJDfDigUsmX9NKWtESYJHCy8stHYXENpwgXhxOowblyWkhrsmroHrynbqXM Xbk/xjsidyQMW204jQqZOnw9ZLi1RhMUlj9SQ9pJ+cLuQUOYHHdIghCW1gGQ/tgd4p6wvyk8c/R6 51wOQIpfwxKijBsLCso1mZhzDorcZ4/MRRAPeJCX1HwLuox9Hzn06ZHYjcUNbIjVWMIPIcyWP6Yp +N7B8jVycy/7wCJAUmfkGDZuVNGSpQMDCu+0QKomUSsIFAwp11OESRKplRAlml9FSJI1UuSOjogb KEcsWmCGIgzT8tUpsBx9NRlk8jaZ45iEZlxSY0UHchImRsE3KTM8zqTsa1E/BEtwPMubLC2BJGTB d9mqbONBkjkeh2z4FHI8EjAtdlpdr6OLEnyaHNZkfEE6A79ugwQxPkicmCA8S6sboVPRxM6ickOx Mg8TuDfyFiGuun+PnJ0Sk164FiK8iVlFucEoDPwpNvwoMJMa0kIpRYVhZYRkYKT4rODBnJ27hFOD Bk+DJ1yRGcik+nupCx4p+qv54DuNkPnAWkYQFoT40lBA/eH+zNcb7jqTUpwT61kIVLrHxD1wa7ME MsKRCRA40gaQqZhTB8Scoklg9B0bzyPASwX1DlC4cMGS88gpxQtH2rUPZ7VjIhzgTWm0GEiBCIFY BgMceoDfmEqXsvUKB5U77gDuWfkvHG1BiYFQwK9g+/yNHqqG2hcKWikIwgrCzXYBuM67VQ6aVvNd aoXky+fQwaE8zOnvkSSWhX4novjjPRoJkLx8g2CJII8BDuM+QU8ZrITSDd8NIG90mqSyJSD2HSoc Q7Evh1iwYldxo4HnTQIvedSYx1gawKKHegdHLOR4BExlhbELfMXKyYyYLSUkMWQ88mpDSH6E6os9 smYfyO0N/KPgGxLRom+EiEi0VE1nuGgyMqglSymJMk3pQer5m4kNg5/VJSH1iKosBWKioyRGATMt 3Vd+kA4sLOb+6ALpScVgDRZkJOEkzlfNk+h7zIck1VjhbbBEEEFa8X1gHcAbRNy+xO7ILLGOYE4Y LnXpTODMsAgzhwIMbB3Xj7QDidIrmETF1Dj1jrGBMRsTPupmAyiIXe/IvWleLMb01NHUeFQyNaoB rMYhPwLWZQFPgeBMUqGIDinA8B8E0DvTqNY5HnoHeNeMTU/RoWiaTRvHSIdO7smxCnsqrgbFM82g T4rX3EQmKkL7cB7m2oNIpm6RtqzlvSfh70ikEausuke1HDdTwoZQckjjYY/e32MvtYAx0xQkjQY8 6EkFbHEXGheaIoDmvEZhbWOlmonE1IARAqFIBQqsPCOtV5gpN6sEkfejinBwlFTAs50T3kLqjpKg RMa52B+Q05HYT0cgMXvIG7SlYqhJCZAoFbJHwjeqkNOxKuoK41cnG2/ICUp8JZqlKE57fE9TLJ2L WMXa07AcErwdOrtDj8iHU/ch7nB9c6SMScx3SukiicV9CHV9p/7iQ7x9FQZzAU6RSoU2lBGIUiCF SOyJCowBEBwewZCcB57z3/QodY6ZjnTHEMAQECQ9gB+zZ8w2hx6HAgtW/r0qAGOvnYOuPYUp1xsm Ya0vOvWYTXznmnl/31YTBLaDNukYG8OSXiCWQKUMeYci9Y83/EIMgyZaR6ZJvgAcEHx+onDymx4T JguIRRZhrFUVSfBmH4/SDbeOGTaaTFzYxQU27vHrQKknl+hwkma9j2MZJy1DQAyJce0mLcm1Q7la vaa0yiZEsHTiPo93Hx8z+AcUFJGl+4T6V1uXUWKQWiMzQXPcI5nAApFZrTeocgOh3knLFRWzoU+u BfqBk8l0g0MSR+pOa+4x8x38kZnvrRJUOGylg6o5ktB78ttKk7EEITXn0+p/AeaMDwH7PD1hsEmg aRNI9a+b2nQvB7NRgKjq2VS6x6F6F4DwXpGbz3HEvXqU+gxpAPTiXpr4ryMQHW6h9YZxqHVyXQbr /WJ1AFrsH7VjcnfHebdBBU9KyYZQSh8ZMmKiqig0pOU1mpCCFQwgnUAppUIsXrB1ZQQ7cYtak1HE w9sIAYJRTAYv8njIx62Qb6T30kcKE/TSqKqVUmTYhjUSE0GhWKSFCcAwKZk2g2H9brOdTKQ4p3D1 Sa6Kik9pZyk5w6FFKlSSSiqiVE2ISKQLFEhSNs/Xgt+5yEaIkvnv+xNZxfoTLjk+F8Fin1L4amjk Wj3e8P4G8Wo8FDuAJCCck7agPR4OwofEhP2U1bE7joAJcLxfbuJPaybYMo0zBtLd1CBMlrUrcHuJ CgQ88SQ0+KG6TtIbEOEf0/0/kOYyBWvzSw0zNDpkb1Dh4KGtoGlFDgoQTK1BtFNRREgbgYQTc7FL B9h80ntE+X0J7T0VkpxEyVm5g93jOCU5lwFoHaTijew6FSnXYUpaXpLJEiVOamgB8FyplB+Q9Cdd z8scWLApoPkO9ZJhicpDRH1oPP4v0FT9ESlipaT+h9BGD0Rl1nfmxuNQZSCUGWTcMpiCFkEsEWF3 tcZI0nysJVn5pvk8SvZHNOmncqAFSys6p+5vVLihyoVUKXOxDg+ocehAGHWFxpNAMBSrNCVjMU58 ltM6+X0Jpxipx2NvL9wzRCyRvbw++PL2Idb5Jhkj27ojzdylQ+QhlNihDaN3PihqFIW84KiUQkFZ W6xDoHMOJbExiVnio1Qoev3tzk5c3qGGB70FPWvouIfr6TUPAD1gY08oPkff55dH7J3HrMHjRESZ Kv14C5A+gCB1HUkODDXI+QhXRnYKVjN+MwZonynMfDqHV7zmGwf4WuXJmYHOme8fnE1olIIpzBCI QCEM2YmAf5H2YljMzSYNptZnINmifVCumSZQZJMhIMgXVJMHRQSE5EVCkDhhwW5KN/rnbKmiiTgh EtIRZrCRUmlE0qUuBKqNcdKmrkMn0gC49T7K289i/S+owGjldoXzaaSQ+0ZYsgmZACthQTdEkYFO 3umeHb3L5SvKPJRB86v3JIzRneljgkVCQwQEmMEwlsoKBuaTvRhADKJoP7MElmqwNTHfHDFaBDyH fOl6muB9m0OX4jTXjgfs1YJFatujOpG9s1pZZol5KUiRCRAjhJokwIVjr6x6RSmIalkMaOQxzrU8 3qDrHngaRPSKQ49EYRw5R8lIfFf76972jEgqheQF15MwKxD6HUOwQzpZInMCWr6GXgF6nwntJmSE NMrMwoIM0syzAgxEiQilCWWSEMxEdiHrjMojQQDZJJIo/VIwT2aFdv601fyicTSckxEBBkdAZBvE A1naJC/Su9sbXMfJoOoDoJ83h8vFIdup1nI2zxfOEKVigKSfyiFZf4sBJMSXafVA+cR2gZdu8XkL 2I8EBciWHteDurEsuEIz4oIXiOZyrRD7epKkIJkkanBsEPsuNxQLAgcJSoocVuVOSaNVnvTetTAP JPXHV4xm8J9vbHZHYuGMaNLdkmDMb3brSuRPHazUlWBnFmAgs9eNM40UConnNmHUm4KWFfkYKTCQ QYe9OYSE5qSNZUBnIRSJpLjOX6Ui6bHOs2sKBwSxC2YlZ9w7wd4XRTkDrkHWw+cCTsCcs4/wO8E8 Z17B2iymxSHwSoubVCqqYSwyw95AkKSQm81O+a5jPEPZMQkvErLyYI8EVLYIU3mMi9DTXcIBePXo NviJaMwKtMIf0IUoZpf2lj+lWpcr3j25xxiaOtuX6vwlixajKbxuZg9c62hFRGslInMvGlB8IpHc oaQZ8V8fE5pwX5NkQG5ywvuAkIG5BYCBRaip0t47xTXXLzvzgeT1p9WVey8B6MkjNB5ClEAIRRnL 5QzUyqdAntTUi2KiaUfWQGF9qe2dVL8GhIkI5e4QuQ3DvHIswyjtT7Tgn+HaOnMnYoYjXqDTPQDQ rHzdJixrqN0HrAgC3cErzlgB+A4HUv7BKl4SuUqN1pzbhDpxj2RmgNg/wkhdD0Q9YpDe4Kax273M ch8HQlNA+1OQBtO9bQOnmThJks2mxJ7kfk+SGrurCT4H3PUnEeYxNgniZhTzMvgjQA7zE7wSBvHQ dQGY7lDpcw0EpeGpxBtU4D06ByiousBMpWoYkCeom4nN3ztGIKxET5RlgKxHenSJpEPiNxuUOPRd mXpJr0ax7ArDVCSiCJSlG/OUV2zXWsDvSocdo6ypI4SICQpKIkFBFO6NQEmLQFRGIotUiD1g/sfF SdUA2wP4nqEl2DA5YFOfKPDIuhNpkVxVHvi8i9FpLghU3OJU+MlLWkssVLR985pGJ7Sdmj0Rt2p8 ngLvR/N/TkmgnFsdAbocATB6y0xe1xMRqlilZnMhydNCFacpAIeSRLT8swgypWkp2GvArq6Mh7ho ZBg/G8lOMQE7lRIUhFHm3tXakBpNJL/eo/CethufnUM/wgaiAPkLJYFbJsiGkC1OwUsFJiKaVzHw TtkKbCETUQjUGFkkEoXEsyQ1bys19LGJQ3jDcY1xe0aP1FEqBH1iEjCYQEIKZT8i8FKUi0fpQsMU XGsmLlPqlTfVfh+nQjlNXV+Zai8USP8jZKEq5jEvLIvauRQzOxMoSTSEZ+w6ZAoY58U9RMZTqLZo SDJCFkpFrewuXrvTVO++JUxSLJZmoUpVC6JBMVCQp8xzUmP1oO4eoat2STZdPpmZi2UlEy9BXWtC 2Vy5c57Xk0Mhqct2TpmhxooiAMvmBDDkCRq4TlNjiskJ57/wxkZCEWRgIx26M8KYJgIIO4tS46n5 dhnvMjTCn2k2a6sikYwCOWignT9XFJG/tHzHWtvDnq16JVzzDsQyMLRDjQRzRigDu+j3OM0jv3PK HmeAkcrufFMHTnAZQuEtZocmcNSiH2meG870PIxqUpKhKT3pvY/bR28FtvyOCYYLcMVLxghIjYSe 2NF5cHAZLA8lD6Xs71wDAsgCQB3gDpRiqMFgqwWLBGIxZGBYhiAiGIHSgByFK684+Z6CIcRzaxis fXZTD8iQXCkQqJECmy1rvwQAkF/jDuh7SHpITzIosFFgKKKAooosixSCxZFFgooKPHynN8UnITi6 oc3ixuDDIEOmdBok9sCT2xnXSlpS2WMYxjGIlpRjGMYxEtljGWyy2WMZbLLSl91nCTPVxBuDkPjA 1ICAIYm1mttAsH4RU1DREkyWqYIyPtHEmdTyEkgHnEz3EEqDpkPLWApIIhqhSipipIsUC0qpQTlS RwFleXxi68rarIMltZQJWZ1T4+ldFL4T7HWKjezS0/mfvyNMKy5iRASB+6gu53MDDDKh+oGsFD6E UGYGHQt/f7j4nmQQvuElISxKkt050uh+ACwPmEc9QM96c+MsEV7dv1GqKDlegPFh8HwRQt6qxoCS VjXQxxKFDTzVl7kWHgejA8Yhav31TjR4LNQ2RDZriRxRUS0TW4GBm2zNyDjCLuNcG7EvSmlNEhTd rgwMDOdtSMghGCRIdcSUms11x8/YQ0JDCu+3aQNSFXS8Twu3Ut+rR2ITppJ+zD23QL0ifBEg+IsD gIej58Fk0GpUrgR+WrNpdKh6jdzilZWtKtTwSPoeJIwYpXbLRLJaA8beNYSKMJHkgPK7BGEjYlhn skO46eo9pJXA8CRb1F7OYgSIQwPet6YzV8iYShL4kQLJWBDYZ40CkyhdQW0o6CL4CohJ17KEXNsZ ZUmh+TCOtcSEGcxbI+uAvlKYpZSli1h8UE5tQwsMbQij3sFBEqJVPlJQAoKZjjsceghYMakKWKJ3 QRAHvSQrPD31UsJhUxInEJ7CBTcSGtIG5mDtkKQZQU+ZNUSlNs5lchlTbKKpTPGY0EztguJ2jjA3 HOZKRmFUxNUBIe1KNSUI7cW0Ta7QcS+6DOkx7lkJcGvcXApRayzZEbolCG6BkJClDQWNj7Cadmlq FFtEAsFrcE6lkOoStOwcUnH+EEo14LwmHNiPaT2z7qVoTKOTkvyNUpJDHG1nG8npJEumSKOI7zXa KYiTimTVmhA+0eGCShscVT2C8xYCiwcESisL4gfEaCn9hHePrF3p4CHaNqegPmJgL0/x2vgEyDpa /Akv/MgUMo0D6TzTIOpQy3AxCFeyUiBSOJnU5IH+TCVDXD+3UAl6km7WMxf0BgDt3do6SZQXkmNM OUcK8rtB+NtwHWdRnEErD95+WQUfhPgkb2UQUlLkVgN8jv8zCEJVB56cSH9AxIKSHlVmhz45Qdp8 T99G9Utl8ocEM6kLrFO4cq/j360ri5PFWisAb9Hms8a404Dmcw/HRip7KsSNoXlLiiW/aUIZL1iE x/aZ+Y3j0LtHMNFCY1GP2qG4xsXvGJ+o1zMHxGhXWrW+kiYmJygQ8+Pm0OBvsE4rW3TsXHBCpYku X4xIeCH48RSSFCfQcxyks7BOK+nn5R5myrSuZpcCZvwOXuIDRat9uX6071kbHtkb4D3ydiXTSSBY TggvXTkLlxRb9mSNV1BecRTfJyEvlEiz6xFgB3LNPvUOB95aN+MZboF1pch5HVEQRpUkyYJcDx6+ zGcRz8uCaBN/wMN4mnLpXsO8OKH3wHrlJDGtQ2jMImuWZ8ukDrTFQx6ZIzg3QPZAZx+Y5zBoNFzj cdI7KgM1B3DMvINY6hXriBsSXQAo6HP4Cw6gGZYXAVi6Jb9qiqxPUma9PcYOkYUOJUPksld+Qead b1CfYKB3OZJCeElE0SGCRIlRgJkLzDqMB8dI5A6rh2mXOpqU83WBtGrPUqH/IgA4qnUO1Ky+4Ayq HSBwXYK5guGSBcvZZMNafKSGisD1yG+N6LEqdI0SPnSw84aA80DaJUpxq7MqhRBQ9BvMkTHS7Xov fFoVcB8ZjGJmmDbFuDypoSCkyMmbTTe6YBdE21uBNsUGb5vnqmcjAigyRAB67X0EmMjrlxV4r4Gy L+taI19YGMYiDxHQYHWdTqHQPSodg6W54DfRXYcl6/1HjiHMBRZAVXbCYxsHKtgBNPKg5lx8R0NY +htHu5SQFtF29G8WOMkIEvW1YgmFvEEiCLhUJvkL+IX6nm8+UUmsYpzT3PcqpUqlKrvFwVwBdFTy 05nwO3Lv3LUHkVt42dCZcawTGGUVxHYIBIwFpKY3L46lrTaZ6xmdAlF1qGh5u5MDpFJqGtklgugY dJIe8dWC9Sdpm4BtXcJYupTGO8M43aHkNgzoZia9kB4C6+n8xhzf/i7kinChITz6fb4= --===============1464463928==--