From: Bjorn Munch Date: September 10 2010 8:07am Subject: bzr commit into mysql-trunk-merge branch (bjorn.munch:3193) List-Archive: http://lists.mysql.com/commits/117974 Message-Id: <201009100807.o8A87sHn016853@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============0344069462==" --===============0344069462== 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-10 [merge] upmerge from 5.5-merge modified: include/mysql.h include/mysql.h.pp libmysql/libmysql.c mysql-test/r/gis.result mysql-test/r/multi_update.result mysql-test/r/row.result mysql-test/r/select.result mysql-test/r/subselect.result mysql-test/r/subselect4.result mysql-test/r/trigger_notembedded.result mysql-test/t/gis.test mysql-test/t/multi_update.test mysql-test/t/row.test mysql-test/t/select.test mysql-test/t/subselect4.test mysql-test/t/trigger_notembedded.test sql/item.cc sql/item_cmpfunc.cc sql/item_subselect.cc sql/spatial.cc sql/sql_trigger.cc tests/mysql_client_test.c === 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/r/gis.result' --- a/mysql-test/r/gis.result 2010-04-11 06:52:42 +0000 +++ b/mysql-test/r/gis.result 2010-09-06 09:54:44 +0000 @@ -1057,6 +1057,13 @@ NULL SELECT Polygon(12345123,''); Polygon(12345123,'') NULL +# +# BUG#51875: crash when loading data into geometry function polyfromwkb +# +SET @a=0x00000000030000000100000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); +SET @a=0x00000000030000000000000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); End of 5.1 tests CREATE TABLE t1( col0 BINARY NOT NULL, === modified file 'mysql-test/r/multi_update.result' --- a/mysql-test/r/multi_update.result 2010-06-19 09:24:34 +0000 +++ b/mysql-test/r/multi_update.result 2010-09-10 08:06:58 +0000 @@ -649,4 +649,24 @@ SET SESSION sql_safe_updates = 1; UPDATE IGNORE t1, t1 t1a SET t1.a = 1 WHERE t1a.a = 1; ERROR HY000: You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column DROP TABLE t1; +# +# Bug#54543: update ignore with incorrect subquery leads to assertion +# failure: inited==INDEX +# +SET SESSION sql_safe_updates = 0; +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); +CREATE TABLE t2 ( a INT ); +INSERT INTO t2 VALUES (1), (2); +CREATE TABLE t3 ( a INT ); +INSERT INTO t3 VALUES (1), (2); +# Should not crash +UPDATE IGNORE +( SELECT ( SELECT COUNT(*) FROM t1 GROUP BY a, @v ) a FROM t2 ) x, t3 +SET t3.a = 0; +Warnings: +Error 1242 Subquery returns more than 1 row +Error 1242 Subquery returns more than 1 row +DROP TABLE t1, t2, t3; +SET SESSION sql_safe_updates = DEFAULT; end of tests === modified file 'mysql-test/r/row.result' --- a/mysql-test/r/row.result 2010-04-16 11:42:34 +0000 +++ b/mysql-test/r/row.result 2010-09-09 12:46:13 +0000 @@ -466,3 +466,26 @@ SELECT 1 FROM t1 WHERE ROW(a, b) >= ROW('1', (SELECT 1 FROM t1 WHERE a > 1234)); 1 DROP TABLE t1; +# +# Bug #54190: Comparison to row subquery produces incorrect result +# +SELECT ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0) +NULL +SELECT ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); +ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0) +NULL +CREATE TABLE t1 (i INT); +INSERT INTO t1 () VALUES (1), (2), (3); +SELECT ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0); +ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0) +NULL +SELECT ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0); +ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0) +NULL +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +i +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); +i +DROP TABLE t1; +End of 5.1 tests === modified file 'mysql-test/r/select.result' --- a/mysql-test/r/select.result 2010-08-25 19:00:38 +0000 +++ b/mysql-test/r/select.result 2010-09-09 15:00:33 +0000 @@ -4430,11 +4430,6 @@ SELECT 1 FROM t1 WHERE a <> 1 AND NOT ROW(1,a) <=> ROW(1,(SELECT 1 FROM t1)) INTO @var0; ERROR 21000: Subquery returns more than 1 row -SELECT 1 FROM t1 WHERE a <> 1 AND NOT -ROW(a,a) <=> ROW((SELECT 1 FROM t1 WHERE 1=2),(SELECT 1 FROM t1)); -1 -1 -1 DROP TABLE t1; # # Bug #48458: simple query tries to allocate enormous amount of === modified file 'mysql-test/r/subselect.result' --- a/mysql-test/r/subselect.result 2010-07-16 21:00:50 +0000 +++ b/mysql-test/r/subselect.result 2010-09-10 08:06:58 +0000 @@ -922,7 +922,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a') (select c from t1 where a=t2.a) 1 1 a 2 0 b -NULL 0 NULL +NULL NULL NULL select a, (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b'),(select c from t1 where a=t2.a) from t2; a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,3,'b') (select c from t1 where a=t2.a) 1 0 a @@ -932,7 +932,7 @@ select a, (select a,b,c from t1 where t1 a (select a,b,c from t1 where t1.a=t2.a) = ROW(a,4,'c') (select c from t1 where a=t2.a) 1 0 a 2 0 b -NULL 0 NULL +NULL NULL NULL drop table t1,t2; create table t1 (a int, b real, c varchar(10)); insert into t1 values (1, 1, 'a'), (2,2,'b'), (NULL, 2, 'b'); === modified file 'mysql-test/r/subselect4.result' --- a/mysql-test/r/subselect4.result 2010-08-12 14:08:21 +0000 +++ b/mysql-test/r/subselect4.result 2010-09-10 08:06:58 +0000 @@ -77,6 +77,92 @@ Note 1249 Select 2 was reduced during op CREATE VIEW v1 AS SELECT 1 LIKE ( 1 IN ( SELECT 1 ) ); CREATE VIEW v2 AS SELECT 1 LIKE '%' ESCAPE ( 1 IN ( SELECT 1 ) ); DROP VIEW v1, v2; +# +# Bug#51070: Query with a NOT IN subquery predicate returns a wrong +# result set +# +CREATE TABLE t1 ( a INT, b INT ); +INSERT INTO t1 VALUES ( 1, NULL ), ( 2, NULL ); +CREATE TABLE t2 ( c INT, d INT ); +INSERT INTO t2 VALUES ( NULL, 3 ), ( NULL, 4 ); +CREATE TABLE t3 ( e INT, f INT ); +INSERT INTO t3 VALUES ( NULL, NULL ), ( NULL, NULL ); +CREATE TABLE t4 ( a INT ); +INSERT INTO t4 VALUES (1), (2), (3); +CREATE TABLE t5 ( a INT ); +INSERT INTO t5 VALUES (NULL), (2); +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +a b +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL NULL NULL NULL NULL 2 Using where +2 DEPENDENT SUBQUERY t2 ALL NULL NULL NULL NULL 2 Using where +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE ( a, b ) IN ( SELECT c, d FROM t2 ) IS NULL; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS UNKNOWN; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE (( a, b ) NOT IN ( SELECT c, d FROM t2 )) IS UNKNOWN; +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE 1 = 1 AND ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +a b +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +a b +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +c d +EXPLAIN +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +e f +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +id select_type table type possible_keys key key_len ref rows Extra +x PRIMARY x x x x x x x x +x DEPENDENT SUBQUERY x x x x x x x x +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +c d +SELECT * FROM t1 WHERE ( a, b ) NOT IN +( SELECT c, d FROM t2 WHERE c = 1 AND c <> 1 ); +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE b NOT IN ( SELECT c FROM t2 WHERE c = 1 ); +a b +1 NULL +2 NULL +SELECT * FROM t1 WHERE NULL NOT IN ( SELECT c FROM t2 WHERE c = 1 AND c <> 1 ); +a b +1 NULL +2 NULL +DROP TABLE t1, t2, t3, t4, t5; # # End of 5.1 tests. # === modified file 'mysql-test/r/trigger_notembedded.result' --- a/mysql-test/r/trigger_notembedded.result 2010-04-14 10:33:14 +0000 +++ b/mysql-test/r/trigger_notembedded.result 2010-09-10 08:06:58 +0000 @@ -472,4 +472,25 @@ SHOW CREATE TRIGGER db1.trg; ERROR 42000: Access denied; you need (at least one of) the TRIGGER privilege(s) for this operation DROP USER 'no_rights'@'localhost'; DROP DATABASE db1; +DROP DATABASE IF EXISTS mysqltest_db1; +CREATE DATABASE mysqltest_db1; +USE mysqltest_db1; +GRANT ALL ON mysqltest_db1.* TO mysqltest_u1@localhost; +CREATE TABLE t1 ( +a1 int, +a2 int +); +INSERT INTO t1 VALUES (1, 20); +CREATE TRIGGER mysqltest_db1.upd_t1 +BEFORE UPDATE ON t1 FOR EACH ROW SET new.a2 = 200; +CREATE TABLE t2 ( +a1 int +); +INSERT INTO t2 VALUES (2); +REVOKE ALL PRIVILEGES, GRANT OPTION FROM mysqltest_u1@localhost; +UPDATE IGNORE t1, t2 SET t1.a1 = 2, t2.a1 = 3 WHERE t1.a1 = 1 AND t2.a1 = 2; +ERROR 42000: TRIGGER command denied to user 'mysqltest_u1'@'localhost' for table 't1' +DROP DATABASE mysqltest_db1; +DROP USER mysqltest_u1@localhost; +USE test; End of 5.1 tests. === modified file 'mysql-test/t/gis.test' --- a/mysql-test/t/gis.test 2010-03-01 09:45:36 +0000 +++ b/mysql-test/t/gis.test 2010-09-06 09:54:44 +0000 @@ -725,6 +725,16 @@ SELECT Polygon(123451,''); SELECT Polygon(1234512,''); SELECT Polygon(12345123,''); + +--echo # +--echo # BUG#51875: crash when loading data into geometry function polyfromwkb +--echo # +SET @a=0x00000000030000000100000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); +SET @a=0x00000000030000000000000000000000000000000000144000000000000014400000000000001840000000000000184000000000000014400000000000001440; +SET @a=POLYFROMWKB(@a); + + --echo End of 5.1 tests # === modified file 'mysql-test/t/multi_update.test' --- a/mysql-test/t/multi_update.test 2010-08-20 08:48:59 +0000 +++ b/mysql-test/t/multi_update.test 2010-09-10 08:06:58 +0000 @@ -650,5 +650,26 @@ SET SESSION sql_safe_updates = 1; UPDATE IGNORE t1, t1 t1a SET t1.a = 1 WHERE t1a.a = 1; DROP TABLE t1; +--echo # +--echo # Bug#54543: update ignore with incorrect subquery leads to assertion +--echo # failure: inited==INDEX +--echo # +SET SESSION sql_safe_updates = 0; +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); + +CREATE TABLE t2 ( a INT ); +INSERT INTO t2 VALUES (1), (2); + +CREATE TABLE t3 ( a INT ); +INSERT INTO t3 VALUES (1), (2); + +--echo # Should not crash +UPDATE IGNORE + ( SELECT ( SELECT COUNT(*) FROM t1 GROUP BY a, @v ) a FROM t2 ) x, t3 +SET t3.a = 0; + +DROP TABLE t1, t2, t3; +SET SESSION sql_safe_updates = DEFAULT; --echo end of tests === modified file 'mysql-test/t/row.test' --- a/mysql-test/t/row.test 2010-04-16 11:42:34 +0000 +++ b/mysql-test/t/row.test 2010-09-09 12:46:13 +0000 @@ -266,3 +266,22 @@ SELECT 1 FROM t1 WHERE ROW(a, b) >= ROW('1', (SELECT 1 FROM t1 WHERE a > 1234)); --enable_warnings DROP TABLE t1; + +--echo # +--echo # Bug #54190: Comparison to row subquery produces incorrect result +--echo # + +SELECT ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +SELECT ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); + +CREATE TABLE t1 (i INT); +INSERT INTO t1 () VALUES (1), (2), (3); + +SELECT ROW(1,2) = (SELECT 1,2 FROM t1 WHERE 1 = 0); +SELECT ROW(1,2) = (SELECT 1,3 FROM t1 WHERE 1 = 0); +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,2 FROM DUAL WHERE 1 = 0); +SELECT i FROM t1 WHERE ROW(1,2) = (SELECT 1,3 FROM DUAL WHERE 1 = 0); + +DROP TABLE t1; + +--echo End of 5.1 tests === modified file 'mysql-test/t/select.test' --- a/mysql-test/t/select.test 2010-07-15 13:47:50 +0000 +++ b/mysql-test/t/select.test 2010-09-09 15:00:33 +0000 @@ -3772,11 +3772,6 @@ SELECT 1 FROM t1 WHERE a <> 1 AND NOT ROW(1,a) <=> ROW(1,(SELECT 1 FROM t1)) INTO @var0; -# Query correctly return 2 rows since comparison a <=> fisrt_subquery is -# always false, thus the second query is never executed. -SELECT 1 FROM t1 WHERE a <> 1 AND NOT -ROW(a,a) <=> ROW((SELECT 1 FROM t1 WHERE 1=2),(SELECT 1 FROM t1)); - DROP TABLE t1; --echo # === modified file 'mysql-test/t/subselect4.test' --- a/mysql-test/t/subselect4.test 2010-08-12 14:08:21 +0000 +++ b/mysql-test/t/subselect4.test 2010-09-10 08:06:58 +0000 @@ -74,6 +74,68 @@ CREATE VIEW v1 AS SELECT 1 LIKE ( 1 IN ( CREATE VIEW v2 AS SELECT 1 LIKE '%' ESCAPE ( 1 IN ( SELECT 1 ) ); DROP VIEW v1, v2; +--echo # +--echo # Bug#51070: Query with a NOT IN subquery predicate returns a wrong +--echo # result set +--echo # +CREATE TABLE t1 ( a INT, b INT ); +INSERT INTO t1 VALUES ( 1, NULL ), ( 2, NULL ); + +CREATE TABLE t2 ( c INT, d INT ); +INSERT INTO t2 VALUES ( NULL, 3 ), ( NULL, 4 ); + +CREATE TABLE t3 ( e INT, f INT ); +INSERT INTO t3 VALUES ( NULL, NULL ), ( NULL, NULL ); + +CREATE TABLE t4 ( a INT ); +INSERT INTO t4 VALUES (1), (2), (3); + +CREATE TABLE t5 ( a INT ); +INSERT INTO t5 VALUES (NULL), (2); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ); + +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) IN ( SELECT c, d FROM t2 ) IS NULL; +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT c, d FROM t2 ) IS UNKNOWN; +SELECT * FROM t1 WHERE (( a, b ) NOT IN ( SELECT c, d FROM t2 )) IS UNKNOWN; + +SELECT * FROM t1 WHERE 1 = 1 AND ( a, b ) NOT IN ( SELECT c, d FROM t2 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); +SELECT * FROM t1 WHERE ( a, b ) NOT IN ( SELECT e, f FROM t3 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT a, b FROM t1 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); +SELECT * FROM t3 WHERE ( e, f ) NOT IN ( SELECT c, d FROM t2 ); + +--replace_column 1 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x +EXPLAIN +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); +SELECT * FROM t2 WHERE ( c, d ) NOT IN ( SELECT e, f FROM t3 ); + +SELECT * FROM t1 WHERE ( a, b ) NOT IN + ( SELECT c, d FROM t2 WHERE c = 1 AND c <> 1 ); + +SELECT * FROM t1 WHERE b NOT IN ( SELECT c FROM t2 WHERE c = 1 ); + +SELECT * FROM t1 WHERE NULL NOT IN ( SELECT c FROM t2 WHERE c = 1 AND c <> 1 ); + +DROP TABLE t1, t2, t3, t4, t5; + --echo # --echo # End of 5.1 tests. === modified file 'mysql-test/t/trigger_notembedded.test' --- a/mysql-test/t/trigger_notembedded.test 2010-08-06 11:29:37 +0000 +++ b/mysql-test/t/trigger_notembedded.test 2010-09-07 09:00:41 +0000 @@ -932,4 +932,52 @@ disconnect con1; DROP USER 'no_rights'@'localhost'; DROP DATABASE db1; +# +# Bug#55421 Protocol::end_statement(): Assertion `0' on multi-table UPDATE IGNORE +# To reproduce a crash we need to provoke a trigger execution with +# the following conditions: +# - active SELECT statement during trigger execution +# (i.e. LEX::current_select != NULL); +# - IGNORE option (i.e. LEX::current_select->no_error == TRUE); +--disable_warnings +DROP DATABASE IF EXISTS mysqltest_db1; +--enable_warnings + +CREATE DATABASE mysqltest_db1; +USE mysqltest_db1; + +GRANT ALL ON mysqltest_db1.* TO mysqltest_u1@localhost; + +--connect(con1,localhost,mysqltest_u1,,mysqltest_db1) + +CREATE TABLE t1 ( + a1 int, + a2 int +); +INSERT INTO t1 VALUES (1, 20); + +CREATE TRIGGER mysqltest_db1.upd_t1 +BEFORE UPDATE ON t1 FOR EACH ROW SET new.a2 = 200; + +CREATE TABLE t2 ( + a1 int +); + +INSERT INTO t2 VALUES (2); + +--connection default + +REVOKE ALL PRIVILEGES, GRANT OPTION FROM mysqltest_u1@localhost; + +--error ER_TABLEACCESS_DENIED_ERROR +UPDATE IGNORE t1, t2 SET t1.a1 = 2, t2.a1 = 3 WHERE t1.a1 = 1 AND t2.a1 = 2; +# Cleanup + +DROP DATABASE mysqltest_db1; +DROP USER mysqltest_u1@localhost; + +--disconnect con1 +--connection default +USE test; + --echo End of 5.1 tests. === modified file 'sql/item.cc' --- a/sql/item.cc 2010-08-25 08:36:17 +0000 +++ b/sql/item.cc 2010-09-10 08:06:58 +0000 @@ -7850,9 +7850,12 @@ bool Item_cache_row::null_inside() void Item_cache_row::bring_value() { + if (!example) + return; + example->bring_value(); + null_value= example->null_value; for (uint i= 0; i < item_count; i++) values[i]->bring_value(); - return; } === modified file 'sql/item_cmpfunc.cc' --- a/sql/item_cmpfunc.cc 2010-08-19 12:17:24 +0000 +++ b/sql/item_cmpfunc.cc 2010-09-10 08:06:58 +0000 @@ -1595,6 +1595,13 @@ int Arg_comparator::compare_row() bool was_null= 0; (*a)->bring_value(); (*b)->bring_value(); + + if ((*a)->null_value || (*b)->null_value) + { + owner->null_value= 1; + return -1; + } + uint n= (*a)->cols(); for (uint i= 0; i [NOT] IN \ + predicates. The implementation works as follows. + + For the current value of the outer expression + + - If it contains only NULL values, the original (before rewrite by the + Item_in_subselect rewrite methods) inner subquery is non-correlated and + was previously executed, there is no need to re-execute it, and the + previous return value is returned. + + - If it contains NULL values, check if there is a partial match for the + inner query block by evaluating it. For clarity we repeat here the + transformation previously performed on the sub-query. The expression + + + ( oc_1, ..., oc_n ) + \ + ( SELECT ic_1, ..., ic_n + FROM \ + WHERE \ + ) + + + was transformed into + + + ( oc_1, ..., oc_n ) + \ + ( SELECT ic_1, ..., ic_n + FROM \ + WHERE \ AND ... ( ic_k = oc_k OR ic_k IS NULL ) + HAVING ... NOT ic_k IS NULL + ) + + + The evaluation will now proceed according to special rules set up + elsewhere. These rules include: + + - The HAVING NOT \ IS NULL conditions added by the + aforementioned rewrite methods will detect whether they evaluated (and + rejected) a NULL value and if so, will cause the subquery to evaluate + to NULL. + + - The added WHERE and HAVING conditions are present only for those inner + columns that correspond to outer column that are not NULL at the moment. + + - If there is an eligible index for executing the subquery, the special + access method "Full scan on NULL key" is employed which ensures that + the inner query will detect if there are NULL values resulting from the + inner query. This access method will quietly resort to table scan if it + needs to find NULL values as well. + + - Under these conditions, the sub-query need only be evaluated in order to + find out whether it produced any rows. + + - If it did, we know that there was a partial match since there are + NULL values in the outer row expression. + + - If it did not, the result is FALSE or UNKNOWN. If at least one of the + HAVING sub-predicates rejected a NULL value corresponding to an outer + non-NULL, and hence the inner query block returns UNKNOWN upon + evaluation, there was a partial match and the result is UNKNOWN. + + - If it contains no NULL values, the call is forwarded to the inner query + block. + + @see Item_in_subselect::val_bool() + @see Item_is_not_null_test::val_int() + */ longlong Item_in_optimizer::val_int() { bool tmp; @@ -1816,7 +1893,7 @@ longlong Item_in_optimizer::val_int() all_left_cols_null= false; } - if (!((Item_in_subselect*)args[1])->is_correlated && + if (!item_subs->is_correlated && all_left_cols_null && result_for_null_param != UNKNOWN) { /* @@ -1830,8 +1907,11 @@ longlong Item_in_optimizer::val_int() else { /* The subquery has to be evaluated */ - (void) args[1]->val_bool_result(); - null_value= !item_subs->engine->no_rows(); + (void) item_subs->val_bool_result(); + if (item_subs->engine->no_rows()) + null_value= item_subs->null_value; + else + null_value= TRUE; if (all_left_cols_null) result_for_null_param= null_value; } === modified file 'sql/item_subselect.cc' --- a/sql/item_subselect.cc 2010-07-23 17:08:41 +0000 +++ b/sql/item_subselect.cc 2010-09-10 08:06:58 +0000 @@ -55,7 +55,7 @@ Item_subselect::Item_subselect(): item value is NULL if select_subselect not changed this value (i.e. some rows will be found returned) */ - null_value= 1; + null_value= TRUE; } @@ -435,9 +435,9 @@ void Item_maxmin_subselect::print(String void Item_singlerow_subselect::reset() { - null_value= 1; + null_value= TRUE; if (value) - value->null_value= 1; + value->null_value= TRUE; } @@ -574,7 +574,10 @@ bool Item_singlerow_subselect::null_insi void Item_singlerow_subselect::bring_value() { - exec(); + if (!exec() && assigned()) + null_value= 0; + else + reset(); } double Item_singlerow_subselect::val_real() @@ -582,7 +585,7 @@ double Item_singlerow_subselect::val_rea DBUG_ASSERT(fixed == 1); if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_real(); } else @@ -597,7 +600,7 @@ longlong Item_singlerow_subselect::val_i DBUG_ASSERT(fixed == 1); if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_int(); } else @@ -611,7 +614,7 @@ String *Item_singlerow_subselect::val_st { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_str(str); } else @@ -626,7 +629,7 @@ my_decimal *Item_singlerow_subselect::va { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_decimal(decimal_value); } else @@ -641,7 +644,7 @@ bool Item_singlerow_subselect::val_bool( { if (!exec() && !value->null_value) { - null_value= 0; + null_value= FALSE; return value->val_bool(); } else @@ -659,7 +662,7 @@ Item_exists_subselect::Item_exists_subse bool val_bool(); init(select_lex, new select_exists_subselect(this)); max_columns= UINT_MAX; - null_value= 0; //can't be NULL + null_value= FALSE; //can't be NULL maybe_null= 0; //can't be NULL value= 0; DBUG_VOID_RETURN; @@ -822,15 +825,14 @@ double Item_in_subselect::val_real() */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return (double) value; } @@ -843,15 +845,14 @@ longlong Item_in_subselect::val_int() */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return value; } @@ -864,16 +865,15 @@ String *Item_in_subselect::val_str(Strin */ DBUG_ASSERT(0); DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) { - null_value= 1; + null_value= TRUE; return 0; } str->set((ulonglong)value, &my_charset_bin); @@ -884,20 +884,14 @@ String *Item_in_subselect::val_str(Strin bool Item_in_subselect::val_bool() { DBUG_ASSERT(fixed == 1); - null_value= 0; + null_value= was_null= FALSE; if (exec()) { reset(); - /* - Must mark the IN predicate as NULL so as to make sure an enclosing NOT - predicate will return FALSE. See the comments in - subselect_uniquesubquery_engine::copy_ref_key for further details. - */ - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; return value; } @@ -908,16 +902,15 @@ my_decimal *Item_in_subselect::val_decim method should not be used */ DBUG_ASSERT(0); - null_value= 0; + null_value= was_null= FALSE; DBUG_ASSERT(fixed == 1); if (exec()) { reset(); - null_value= 1; return 0; } if (was_null && !value) - null_value= 1; + null_value= TRUE; int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value); return decimal_value; } === modified file 'sql/spatial.cc' --- a/sql/spatial.cc 2010-07-23 14:24:00 +0000 +++ b/sql/spatial.cc 2010-09-10 08:06:58 +0000 @@ -511,7 +511,7 @@ uint Gis_line_string::init_from_wkb(cons n_points= wkb_get_uint(wkb, bo); proper_length= 4 + n_points * POINT_DATA_SIZE; - if (len < proper_length || res->reserve(proper_length)) + if (!n_points || len < proper_length || res->reserve(proper_length)) return 0; res->q_append(n_points); @@ -729,7 +729,9 @@ uint Gis_polygon::init_from_wkb(const ch if (len < 4) return 0; - n_linear_rings= wkb_get_uint(wkb, bo); + if (!(n_linear_rings= wkb_get_uint(wkb, bo))) + return 0; + if (res->reserve(4, 512)) return 0; wkb+= 4; === modified file 'sql/sql_trigger.cc' --- a/sql/sql_trigger.cc 2010-08-20 08:48:59 +0000 +++ b/sql/sql_trigger.cc 2010-09-10 08:06:58 +0000 @@ -2006,6 +2006,7 @@ bool Table_triggers_list::process_trigge bool err_status; Sub_statement_state statement_state; sp_head *sp_trigger= bodies[event][time_type]; + SELECT_LEX *save_current_select; if (sp_trigger == NULL) return FALSE; @@ -2029,11 +2030,19 @@ bool Table_triggers_list::process_trigge thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER); + /* + Reset current_select before call execute_trigger() and + restore it after return from one. This way error is set + in case of failure during trigger execution. + */ + save_current_select= thd->lex->current_select; + thd->lex->current_select= NULL; err_status= sp_trigger->execute_trigger(thd, &trigger_table->s->db, &trigger_table->s->table_name, &subject_table_grants[event][time_type]); + thd->lex->current_select= save_current_select; thd->restore_sub_statement_state(&statement_state); === modified file 'tests/mysql_client_test.c' --- a/tests/mysql_client_test.c 2010-08-16 07:22:36 +0000 +++ b/tests/mysql_client_test.c 2010-09-10 08:06:58 +0000 @@ -18937,6 +18937,107 @@ static void test_bug54041() } +/** + Bug#47485: mysql_store_result returns a result set for a prepared statement +*/ +static void test_bug47485() +{ + MYSQL_STMT *stmt; + MYSQL_RES *res; + MYSQL_BIND bind[2]; + int rc; + const char* sql_select = "SELECT 1, 'a'"; + int int_data; + char str_data[16]; + my_bool is_null[2]; + my_bool error[2]; + unsigned long length[2]; + + DBUG_ENTER("test_bug47485"); + myheader("test_bug47485"); + + stmt= mysql_stmt_init(mysql); + check_stmt(stmt); + rc= mysql_stmt_prepare(stmt, sql_select, strlen(sql_select)); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + res = mysql_store_result(mysql); + DIE_UNLESS(res == NULL); + + mysql_stmt_reset(stmt); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + res = mysql_use_result(mysql); + DIE_UNLESS(res == NULL); + + mysql_stmt_reset(stmt); + + memset(bind, 0, sizeof(bind)); + bind[0].buffer_type= MYSQL_TYPE_LONG; + bind[0].buffer= (char *)&int_data; + bind[0].is_null= &is_null[0]; + bind[0].length= &length[0]; + bind[0].error= &error[0]; + + bind[1].buffer_type= MYSQL_TYPE_STRING; + bind[1].buffer= (char *)str_data; + bind[1].buffer_length= sizeof(str_data); + bind[1].is_null= &is_null[1]; + bind[1].length= &length[1]; + bind[1].error= &error[1]; + + rc= mysql_stmt_bind_result(stmt, bind); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + rc= mysql_stmt_store_result(stmt); + check_execute(stmt, rc); + + while (!(rc= mysql_stmt_fetch(stmt))) + ; + + DIE_UNLESS(rc == MYSQL_NO_DATA); + + mysql_stmt_reset(stmt); + + memset(bind, 0, sizeof(bind)); + bind[0].buffer_type= MYSQL_TYPE_LONG; + bind[0].buffer= (char *)&int_data; + bind[0].is_null= &is_null[0]; + bind[0].length= &length[0]; + bind[0].error= &error[0]; + + bind[1].buffer_type= MYSQL_TYPE_STRING; + bind[1].buffer= (char *)str_data; + bind[1].buffer_length= sizeof(str_data); + bind[1].is_null= &is_null[1]; + bind[1].length= &length[1]; + bind[1].error= &error[1]; + + rc= mysql_stmt_bind_result(stmt, bind); + check_execute(stmt, rc); + + rc= mysql_stmt_execute(stmt); + check_execute(stmt, rc); + + while (!(rc= mysql_stmt_fetch(stmt))) + ; + + DIE_UNLESS(rc == MYSQL_NO_DATA); + + mysql_stmt_close(stmt); + + DBUG_VOID_RETURN; +} + + /* Bug#49972: Crash in prepared statements. @@ -19378,6 +19479,7 @@ static struct my_tests_st my_tests[]= { { "test_bug49972", test_bug49972 }, { "test_bug42373", test_bug42373 }, { "test_bug54041", test_bug54041 }, + { "test_bug47485", test_bug47485 }, { 0, 0 } }; --===============0344069462== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/bjorn.munch@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: bjorn.munch@stripped # target_branch: file:///home/bm136801/my/merge-tr/ # testament_sha1: 19a84d1c51ec46769bf7856536dd2b663ce71f07 # timestamp: 2010-09-10 10:07:54 +0200 # source_branch: file:///home/bm136801/my/mtr-tr/ # base_revision_id: bjorn.munch@stripped\ # so6cd5gpn1dzzs3p # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWaKGh8MAXsl/gH/yFQF99/// f+//7v////5gd/77ffLfXWuvvOOjbe5c5esoDw9BQLuqD7b7773u5vbdNasG++70vF8vXnueWLu4 vho0ZvD3jPnWG5l65W2pFUQvj31uvt9KqD6e7A17Wdzrxe72AV2wK1Z52QAUOhevO9AU7bVHvu49 7vve26uxnfZ72j7M2+d4qACie5nvUAEhb3jeAAA9x3ngAaE97A+6+gdsiKYdOuqyyy2budcrcfBW wvSl6+574AfW+96HgPDtuA7zvBt3s9Devd76+3ejzsx9853bT6dfZ89svewO58AfeAUHrWbegGl9 3LsUKHotrtu2rWtMV09691XKxIvdyut3bqAdBuyWs7O2bsq++vnPvtaym2zPhx3FbZt3NUVSpdTY bYKNsooCSQmgACZABNAEjJMnhJoIxpqaabU8o09E09RkYQSggAIIhCYjQmEyg1HpAAGgAAAA0ANM gIkQmCU9iDVNlNkhND1Gj1G9UANAaMgADQASaUIghNMU9MRMmJME00j0nqeRTxE9T9Uep6eqaHij BB6gDCKQSaaaaCYTRkyAAiYp4o0xNU/JTTE9TYjSaNNpNAxBFIJkCMgmRJkzKnhJhpM1Sfqj1ND9 UbUaAaeoyADQGmcDIQ/wWEAvgR4kAkBCknor6QTH+ZYCfvPT9hlH/pP+41BqtFiiSD+gT+Jaw/+x zJi/6F+4X7hfWQBMIpEgLj7K7Hh/fH8LnB7tPZa3ziGifakCs8Pu54A4cdpjvG304gf3fyoaif4f +SgaMMiP7e0fMfNdXf3/Nz2fNRNUu53oCHScOnENNW5t7IhyKqbJGghlVCpx3sGbo7elww7yzfN5 /Sz+D4eoxvJ/lqa43Mw0QVQVny2BKwyjMDkh72c8tC/Jk8/lx+/rpFuw/+JSH9D+U0HHVmnOP8xg /8n6Yup8SN0/mi73k1j/4RJVSOViTK7KH2k7Oew/oetesm9RbozTaivTwYbDWWzyztSyiNmY6ia+ gnJjqwh9Xy3zrv4e5gSPIfL2GBgwUib1FVhEDNWtQeRkJpJ5YZZ+nU+qZ/nAlEf20m7ZFJjqbtDu 9Pb4qYZzOu0D4/ZBMxtwvWn7jhrml+y/7+WrlW9ez++5ekn7b+A2Za/vw9eFOf2z50+i41PrDEcx wHG+39afIJRGEEIu6dDOnHt0ZGIZlYUlZn23GWnoxi9O3v+N6/r7OjyN7U/N9Row9Nrk2Sn4flkm yxmQ4yppfYxBrrpdGJShp5XUzZjNWwgdN968aHLyWTnCxORACZyAV99dz+HJ39/j9WvKTpx7Jmnp 8iLG7ehs1rSSl97LsXCm05Gnsk5WhOtCDGtQSTLzMxeoeS0UFF62xry48DmdqzxL53Cqqqqvx6v9 jr8tPzby+Hdhqv879Gd/fuGIRYHj7MdJ5wuoL03jj/H1N03oa1uNlVuMta1r2ayuhF6/aUiJ5H6t ns5gtHN3H3yK9iLCHeR5OuNnce+EkpMJAuxuLHt66eKOPZgPczI6xSe91mzObNr7tcDXvdkMJOSH DVhwYck21csODhhsycUDKXNKzk3e8GGlSRHG101FFOLAMXOePDWuWBDxQIx8sbzQnIjeqgwY0KuZ CUDGX3/we73dXV2+ovQIDyOV8Y8M3zKbZVQ0H34MmGvcZs9g1GZpJHWdq12pgmBcAzVvXm3U0Zbk wmMUDqOvu/9Hx0V9T2UUVTK8MsN8cG0gRKOk4RKUiMRJSxDDQqKDXBklZEiynD9U1qVT0dSFq0bW TGaer7WYMnJ3AwIVN63V0nL0+RjuTwG8PQPzn93ZPhVwwLdlNwgLN0dyPCIJ4xhbMvhl9aYVaXA1 LmL4QGqenvJLib4tHeA1mvLg3TCO12OR4d87uCqPBHoieGHQOYzDIQLHHo6r2eqcrZ01szMEj0Ih PYwxf+6H/NJAPzIsk59xTYev5sYiyfmQ5EYRYChAWEWQWAiEWKT0G+X2cl83okjbhySDlNp7KAXL Ln/WzuZtpEYYYYy0NwLKAKlh7HieJQ+gnGGISwgCwgOztzEBMaU/vaCtBmAZg9Q4gYgH5sSjTj2+ cKJgvOJSevleuHqp34PT8+58P2HMBOQMDdFFWqq/oMho8hLXnj1NxmmMvsANa02xLWjW4EgqDu5+ 9kSsu+9xr14dP4cgjp5/YIEfoQIPWiwYisFhAUESBQkVURZBEBUZEQUVjFFEUQRixRVQVUiqiKKq CKojFGLGQFisYRGAKsikFgxiwRCMWII/CAcB5jD9EIAbeHf9n26OXa/Z8f180XqIaDoSQSiqwREV EVEEYIwVVgsFBYT6CBoDqk9X3CAdHDo9f4oI4E9PSFTodaTCTJJX6wjsHY6UCqvEH4RlGQ6DuXp5 xCq0lOogQYTJJIvZKiSERqE8EBEkwbDoEwYdTKD6Qt3LgpSapGJyFit1Bg3CeUsVnUIUWsgEk7lY YInQStZ4LWtHLRd5KUNk0StoxGqW0UKEq+Co+VkOOOaQK3qjHM8oWiIwSnEuiZ4vA8m6GOsM84L7 MPj1aAk1YsOCVcBW8BEZjLL4G2fhroVvkMHQwua3nLaobrnzgvRBnTwaOHUBInFRwkwdTzD7MnmN JxyYLgOjX2PBBJFLRUiHG1ZeS/PlUC5eoJ5JEs8J3MZww9H3B8u8+n9NH+dsBvfPA8E5kNBeRfCy kM/NYQp+4VpTdrQBzpHHEDchNdvTxJk0YFYQ5kJJAmoeI4LmuzWs7GGuYjA5lB3Q0uDqn4gCi2cI aMmTRRoo8FF8SdZcvEKGLUxaZWQ9xtLR0dHUq3VFoJIh0pUWtseGC1EWXOF3QRGzh4BFAiEEwkxV PwaLIiIRLOWkkgcK3FDhhbijsijhctelq0jB40qMBJzRgvCrNsKuUmqXLk3B3Z1SqzWLxYcJd+8P wQ/ND9wegx0RSfzAKQDuiw048YGC4YIB+aA5TjHlTzA9Zzp7TkepJ9Z1vkP6D7T+QnT8zRZzwl1N BzJD99fePD/sR+PxJKv4mfiWGmNSRKsj28t7DMwzfOe0Oo/SEM6VaHkCfaB7RCUD4pV+oDAevx5l o/MlxDej7mKG5gr2Zkkf12yvWReUDE4wsBjArJRI7Tr6rBF96OYzj28fDCo4x4bZlJ86JonhHoMy 4GjwfSMTsSEHA8qC4Ww+ccIWte6vdN9FDVAciq+BqfKQpCdz5Djl82NYcPaBLK0KxYGJcTHF5u7N ql+8lJhkzMxWCRetrw/oeA4W88jNG8yQ/AYF+Rxkde0IcLYnMknGBJ9nv3CxkamPv9B2nzn1+K3O baifYUgUDAU9IjFVFMByYgKBf08fkKN9xR4+wxnNeqX8k+6k6Aq06uhqU3d0yIeU95NiyyhKwpSr eXCl4ZmqV9bcC7fKtguhw59yHSH+wOPpDi/pEPOw9dcgx8srjmR3VUmHlH/f6XmRZQVh9PiikSXo zOx82llI/2v1aWQRNk8aLX3c+ePB7Mz6eR4khxl4dZzSCm4mcTvT3aofjC0VgbxDCRTrjKP0rL9G Qww0jOZtI+uJLhX3h1uwHHZ+CufIfTMeDIT+qdFv3jNeWzxPijl23LsYJ5sfD6xF/UyX9Bz6FKep 4ADEDYCjFCrzeY3so6yCctixo8SUfeJ7wOY9J72wHvcviJe9cJF1b6dlXrgXxkT2SpnnYe8aDLU1 WIlZnFTWxMyh8jmkk2zBD9hCKXhdKVhJnlky0+Be0yBNKTIIdSUBvX6Jk+H8tblSpwdFYIgl5dM6 l9ZoaHdZCthcKP5pz75Knz6nQokvrhI24W9ues3CizM06oqcNypfjuNsHaCj3Em2LQ2IOSWrSsFu hrc9bHuDXUSI8m5N2d41RcfO8cUxsa8VA6S2si0Fyv5zfyUYSulycYvgxlyl4wGWjDosR4kSeVpJ zs19YHnMJzEx27IIqWz/LPEqbT1hESPtwtb38ovS/AdKyCp7L2K5CD4jnd7nvtNZYOqqhpIaEzJS M5XOp4uPYczz9YyP5v+kitent7h7gwDCAFHd6Kf4CWkjwlWCI8XCtQCM/R5u1ZlEr0EUeEvgZ8SW M9UoOqUjKRMWOkkg9kSD92ud9EK4w4o8taifX4erDq+epBfn08+Qruto7wwIc+SYqT5m7Bzn7Y9K TE4pjqiRPSJanUcwICDcejwi1UnD/s2XIrTImF8fb2BACPP0L2LMxvTThQ+2M/o0+iAwd6rz+g8I 0aU3g65/ntz3t5E/xqQRz3oIgjbhutH/IhL2ltV8JApRy8PVfq29YNSnsQLK0IBZS/3tAWhsYqdc H4Yc2LmdI54xD6g5rPUfp2vqPyrJ6pyj43ExLKqk9QGnNGiyrLG6C7x44mO8MiCowCFBqQbEcCFs VFJmAyFmTD8RlVNBkDQIYNhMmSlKU57B2oe8TpWOWh7mU4YX8mdrlonvO/q+IICFUNY7VxiKij3m fH1Dr1y2/w8kOQ3C8ur16T5AeYjW3HcVHmX6baU2qsHrO8XYhSxG8lbXO9wzMa1jAo7uEDLOuILH 6K2vlt171fDroPYXUhWVJhdKzrKUh/yhNZQodO4GGro3yPWfNjzj3YIwbI7nbpV/QPbzVHCLPeyH fRQo8Jxz/cx65NYTcEVXFm63GCrGTmW2+ayUUhlRVoMqSY0Jddlj54zugqg77yS+qVvGoe3zIoPz o6o96NiPaj9CP0o/SjjYWGhlntfR+BOTL/dqKiu2xpoFpgu/WvRTqvdQwzOGSRDh6rWqiZUOaBqI mqtxRZK2CsqVLa1xzstswObi1PI/6H9LJ3OsfAfBgxuNMH0fN/s5smTI3P4NWTmbm9wMhwfR+Hc8 ZRE2grEMzFv4R4OEAiidbK9Uy/qSp4gRT+UNzokP0VS77bNunHEtM2ttLbVaW+qQno6fJ5vb3rXD znKlOhdyXXSPyaDyY3Pqqdj7Up1hSKv4m8R1OBXEcaWj0WkIuY+/b2Kqe/xV/rnDh/C0bz9c40xq 1Skx5kyVXfHwuTXD0tvUoaxRreLF7yNLLNoq17We+ayelYrvEkg+FezVnljrLKNeDWzzbNmNUuGE zm4d2SWSSMYSSB8ZbJ+EKRUVEFiqqxEVRVVU+cYgIfcMCgqP7/1BMD1IA092o3Tp/pGHn4aPlDVQ zwqxAH8SBTmIUZEL8vxk+/Ps5S3ekrDNjs7pyrKf2etcdhKCPiZrkn7gDVIH9oJ/JITteRosik/5 IWIfyZz+gePcafMSRTAwMgmPKU+5iTdywOxMxO7gZQg79Xy9oP97bPY4sTE/sAPVZs/aSgRYZgAj JXMfkkObz3sXt4lB2RgfUNMVm+UgzECQ2H4ph2q1oiuRtZD2B1/k7On/90awGuif2cV+gwh96c50 h6rVPLFXyY9r4X9T0IG2XKEMyfWfguFUxp/rIBsUFUB4BJKyDAmhIhPwOk/eQe+gofkZiQVI9Yvo Tefdqz6OxwMjshJHg8SGDYMTBkeh+0pJCQ1szepqyYQojjnWcRJQLATHXQ11zjnnc8CqveUQLScT DHeODicTnnpiVUa3yQvdhWgDxKh36KN4fvPSUMIdYoWo/svgghh/A/I1NI+0eoQN6QOXzUP4EfwB 9RpoQQQ2HcQgEhYWACFgF+4+gfRatHWAYQUAh4r7QLOXd034LJ7rlgoYCe66jMwevIcTGqBpUslY iG0CaNzQSxVHEZjYYUJJRDKjNw/zF/MORy5BgSdBpMnOjJcge+F2ME6oCxINyy1F4BcbcXsvDk8L c+B1qo7Gw1JmaxTQEophmJiKZg1aQqbKGSOijVR1AyXEGIACyPUdRyMpBsNZCVrdsBRQgSx7SBLy apUFwxFrtBTeo3laZbgcQeFo2I7kyFeSaDqtTU2KD5qNAqk1qowCakL4Gb2Qq8agz53HiLLYYHuA ZiFQGYJC6YTWazXNv+XbX+fxPGes5Wl6oJ5drU998nDsSTh8mVM5Eavy8XeVBxsd6sf8MedZPecn nLphgQg+uySTL6HvqKhHiLgPr0QjnfCDoLkzEnOnuN198+LLfWVJbr5HX00nmilJTrclwky0LA1H i60O5Qc38hPZLEBANK9q1xcdz2SlmFyUlhMSaJmTMJqTWNYzheoDikLaDIxiCUsEpIKlrIkZKQiV sJQoJEkLCFCUCRkAZCQEAglFRLYqoOI4lUf7YZp4h5tg+FSOgj0hBgU/HQygGwFIwDi2QEtMMAEw RU9alnluHfDVgkblGYwJJIXAaDOZhhmCJ9bOl7YEiRYu1aDDNISY0GdcK8z6B9A9n5/ef1/On80K CfP3dq9kLaW22kttttttCHLGMFtP9njnOQtoW2W2W34PDz60veFu0tstststoJJhf24cd9sHqGSJ TZBMXfb+MH8cfcCXmbB+r38pTzMzv4T9aFI8kCpn8PtjY0F0Zzfo4US72bLwD2JzDjLM3IQX/QVE ErwT/Jx3c6/M4HSA05PKRJ/24j7ytPAI0pwg5LxekLA9bMGYCsQYMSGlDltScWcWFHSHBkqQOTuk OKG7IYZsyGzuyvLe6TYZNbYwKaeSTZJsxSphmOFMYoQyk4CGUJODMsrhhOQkwgYZphDinBCYVmy4 hsN3oSbE70/UboUVVBK2KFxBqsIjMoMBaV1YMXEoIJTKQY4YyZUmUFcjoEwSxMqtRgcVBgGlBxJk oASJkjBZSExVMazWSs6DmGQiAWUAQDUjCdJQChD0H5MahkIJEZEJCkHcSQJTB4hxzCTkMAoMKBEA KEAwKhECoRWmsywaWLHu+VSlhDhJkMCSxfMML7q1lbiIKCltlaiEDCIAGaq1JoLIGikjQMIEpCJw ZIkl4nnEIFBkS6pkamKZMiaKIgTBi7GLaeQIqqWKjjLMaoYgH+P9/2ShVVCwYu1Vd2eJnpC3IUcI HcjC+BjdhYEqTOJF5mIwiSchYYicF+ujKV1N6vloK6rp6zAGEkIZRKk1BhrAOIGpyrYqRUoXVekw qWLbOTHQyds6fyda005BbP2i5z0kQJBTc2MVnCJQczRF5VHk5PAjAh0qtbBJS5Qiq9lCkGpdINEp YyjIlTMmoWNEwmLIG4JIt6xKAExHYkvkqe1Mn6NuqMbF0AXgIuhGIrmURLcIiFypYMnk0MKQuNlh 3V3bnKCZaWTgSNWEMwSAoDQmuMlkC3WuV6TxwOZfSOmdhgwBSI2kyOOuxoUgrwwPvXgYUI3XBzui ASYEaTdhSBeEJQixUwmTtYQmAaSUGBBvTbdkCTIqU5HIYaLxZWLKYVShEuQBQDAkKJxOUhyGAwIA TgJKSo8YxxkKiBYcsc6MGZqduVBjdgziM7qjtlouAklyV4BcQJgwAI2WFFJkKoTFQqJclatgG9LW cSgYFLrZw4FRaKDleDIgzkWasihGhfQMnPBRKEIJctIEcIiOiIJLC/VRQWQN/9AMmjZUyZLnBtxe RnJBjg4nsHRolROVsS5mW1SRIWRBFFsQNGatYoQ7OzgpcttiNjjgTkqZFLkzBEoL8RBzmpXdIQ3X oxtG6Mpcvww0BVkEB3jYuTDS5oTa7jQzLhniXUYUaH5AGNLmN+8BQJsrRi0vkJribviAajgLYIdH qk6UuEhsRHd7hF4B7zOHiSKX+86TQQqM/1BV3CN3l8gHXhsoGGYtRkN3j+N5wnSF4O4vBIWxntyd AtHQK2izF6uFM8l47E244dlXGqXiE3YxYnGwOSRgIIGqUrh2Elm0kG0Rsp5dqMEOk8Y4RizThkw6 VDg7IpFCpIesBA5hhEI74BAiPHIolZrQLrhhqLXvp17LcfyiK/8AcSONwLzAoAQB1uvXh1RxAN6C lCSulY7CBWEshcrlX9Jnsngs7a2hBFsPFITpW/IMgiwAWiBAEApAKKyMTJVdxB47tcDU9MlCgOdT z+Qb3oB2JOaCxtwXdmwWOQPmvDpCgyCqtQTUyAelSYU6efxHGMgJYQ1Yz1OR8xR3qUDn0sccSlP7 ijrgAanICxf14LlgD0smANJbDeTbnInTgGCPMmsGUz4c2tOcquGkFExzQw9CNBKrHDETJ4TCHqRX JxCjmoRBIbjjL1bS4Ymr2wPwsdlHuo0LHAkGQspgDv3aCfjmyIE+SiIolClaTKebgh9MRXHAAqRZ DlIyx+hNaoBDHDiX6FyKhz9SiSFibqlDZ5fqvTMX81h7N6+nni1+cGLvKnpIarVcjfNMbpPNnKUl aPF4RneWWxjYt9bNLdFfWsLGDlrPjJW04Y3vbPWi0NtPeWwiCYFvImZFLdiZLnQppVwi8jDAhbi9 61QkiKGajpBLockZiQiCY05BS1pAClSx3ghbQIReqDnBTzgnI0BQrCbCZheiL6s66bnpqzMaQ4TX 06AfTUiVM2K2vU2AgFUCVpjY6OWN5KCIqiKZDYrBvbv/IfzHqB8RBQ70glLvQYslh0vFkNSFwBgS GROYjwmIwHDsDmkLUbkhem01mBtZYePAlnGh1VIToD9Wx4XykPhQbNsyeY9eszWRsTtP1+idmKaK QMjOWE6Jo5FhPHyAgbDgGNjBx2vqe4yq6GkO4JqDZRNEi6MJ5IFPc2FKHVLiE5KiygJI9Bx1INN0 9lTF7F4IlZHf8Vh5mLEGpZ86NbmI8ya7UhO3SIFidozOCNCBC8EQMnksUn4JZqEixZw/hRFQ4UyM Z+z1DevOjZ6FNlcaqvwjoRCIx19jP2KRFSmTkRvNTySEeIFZe+Bmwq6qxSQHQeVgNoQRYyTwiZnu P4/hTBx0VrpXfT61wz+1ThFEh3m2jKJaaRK69SOQcBaXFtAwspfaVGtCfbcdFlpuUGSyLcgTSU+Y wYQLCiXUbGoJSFh8RMTDG6MRkZ0vekKYrIko45eLtw0SCcM84gnoPEQruDWZizettIuZNlPqVz3B yphIFDwe8LGaqXKe7J8CJf0gENcmy5kJHuMmamnEoS4KMMZJ2qSclifZ4nq9mpgbvUBjzEQxoT3O BucTem5rrUnbYjjPEPMHmNq7C8iF92NE5j3Q+Qpp1TNU7sFIACNpUZBEjUSGkBiF5po5TQdJFgzM 3+zKbWkuRQI1ifE8lCyWTeIWx8zTwmDZBVHMfIAtQshK+4zXYesC88jv2mkMWe5zOHsrisZXRDpx nBmDl3jCenSPpPD1GSdCIJCaTQ14OGMFNAcJ4NYN6GYgcWpTsMgMVLdIZm3jSYNRDjDxMcabHjh0 DYyRTOxEyorwH7gA5BmH9Lg1obvHWorVwRx1FkLADL2CWReMMESqxIHFOABwokSsXmFwp3YVRm8K Mo5+kOhMKIGBQEORCKWJCNSESRzXxAQBaUVEAy1oMR0McApssfnYAlMqCS6EpgkzzMZZ0XwvD2Y+ XxOz8fzKBe/Nih5hjKj3PDRdxyA7noiVASYnp0iVYciJQgJmC9nTecjBFgoOThC/Ak5wfjKYiGYv OmHCuuzX6po6N2OFKfYiJ7vegmMnCyv0NY/M6gCEvCJMQiZ8HpAQv3GIy1oVCYqOpFkSJIbEE8Dd /kIxTCno92XDj8NogYCkUgopBaOziFyQJIycjpCECqZBm9Sk0C1RbcddOnodnt7HYU/CJ5FOPBks M5vHHDmG6H82eZTyOK6MSo8BKMqLl62SoIWPAMWH3gnRoo8dQZgzBJ8Trs4fbTGyMGb1MOkYBxzA PEVSpXM++XFE8KI+ZA5yTb9qFfBPx6FTSFm9FuTeYDq7yeh18xgYxjQTTluZgQqJB74GPmL40eUm 8O+hkdqz8J0PA1EpXeuo0qWIrGBPpS4xfxJrTowrBboYqKKXZ1uedLiujrzgSEcEhP4BOkHxIuq4 m/naRIMEbsJ70PHroTE+0+o0WPcZ8HANwCILK440o12TJBPiFySOPUmej5V1EFwRijtadbAl0QS8 55X1VO7mSKMULmvXgWESynwsVvZZ3ZW6gUgYRNy6MnQ5c1fBatB/CkBU8R5DEIopkjj10Y8wMinJ 5qSOG0tz5fIE+NqrVZWTag07wggZb/XEP4BGO5a4ZddA79DhbmUMTvalggOOeRKETy9gke2IkTNQ aHaexSI2xtFXGjUVEsuQWFrKQJiQunInPkAaxbAWJRvtwMDZ0RQ6yHiy3mdHpgaR0dBcj8BKhap5 5yHJQQvvLiYvLzP1CJ5ojQuxLD4licjZ6/ACCtQo+FPkJZeyhijVscEoug2U8OxLxAh7KPvfTjZB /BHIejqAVX15TGAPqH5Lj5GuMjbf1uPEaFZnJ7+DUb2aya2y94fihtbAtCd7Z5Aqbbh+K4fgDAQB mUJSdw53fCL6qFVibG+HtNJ6UadWV1Iuv6AXAwiYoqLShT0Taoookcn18cThwrh9v3BxLGCNdxmC TbKk0Z6tacc7lKGG17kolsGv9AaDiXoqfthHDXBTWliEdKCMWCNYizJhhVqs6jSmihUVEgiAmDze 4KdHq5i3e0KmlWIhtMmUqaSRAjOE9QI73h5u17QzQjEEg6l6kASWyZfVhLZImPoN+UhN27ATkzUU +t65z0dQB+pJDKi4sXOKWRRBQgR7kPc2YtBBIcwr2NcoVCC5WglDUwSPSv2N1rkwSIl45ytyKOiI Kjpwx+sOYXGKHCAPzskVSRKxKnHJoLFG4J/EH55Pv5NG1UwiKSSapEqiBChNAIKMQGISGNn8DS6I mrERkQItyr1ukbEQQpwMOkmODhFqaLkhRs5LSgZPojxKI1UKn2LhImSRA9RonAgyeQQkMLT1MqYY oVKpo+KJzpUXEdQROywFoGrUILPqKRwTuhVKGaEiNXEmbleY8jqFyhlPI/aj5tTcimo0iFQpwTNT kU4gSI9EJAo6q6tQqjaQ+2pciftE6e5s6REZ/FGH7XIu6uQ3zQI8clobLeCrIgVIksREVSZeXZUn Bz8E4vRQuSsbL6XKAspJtzKJUmsCD2Vq1KDQh709fRE9O8Kee9m/MiRffFWprHBKPZJBciIciBUh UGRkZO4cH0ERjJgNl0E5Lex8E6JogkCpI6ma1QthtJUqJ4RFRg3tsTPDHFjk4yxyVGp6IgWQSI5A 6LF+GqeRtEQ2aoQ1QrQ5APvE1iAzSnAO+j9p+vDbXjZCHRUgUG6LeSFMspqTMu4djZChDESJArMY UkZLG8UOtQuWaQuN4L1ecM7T03JG4ZIUQcbrTMPBfW0ME3vvBlp2D1A3AES2C2Dq5iXJK8iewBNU LaLAs3HGQHOHcu0hwcSXNPLL1kvRt39uOMFZpr1ljJGN7iN7uCfQNiMjYvBwoOoHHD04lQA5IrYv Wsrc1gp9uyYTo1wNMgsZ3Y4TdoX6uXIJWWhCwkkQFWLjuQCAjWVc7CFaOtorrITMXhC0zIC4EBAX WCIoh9IxhEoqaIJJ2MGTCAVqkbIkyY3zvUiNOSJah8jRMBALBa9Refvkj8MKobNagX2uoAFyjg9c EYplarx1GZcURBi2Kl4VPydIRhK5jRcQuEhShA1qsPuhOohQylTJiSIhZWo2IOt65+cg7LBUfDGR pxgb1WAlDoSH1Xta2O20YPvPjzx0d9lz0E9MRp4VVFM1GpsY4oepOIsuadfUhFSwqHrQpa0MFE8G fT4obI7IDxYks7onJxZbTPkjxteXo4Dpm654acectZOlheVgZkCZIkmBfI3fwrOQtCtUbOREzcRI RJII+DRcZ6qep7IB0qHvJ7MjylfJGdTpmRldeHBDyCOhRjj5QWBVTSOIDIWOQcFNUlKiXUV8xSIw Csw38OZwJdlCnYqdlCvLpsW30lQuoSGoBY2oxmlNgg5CtCtzWCfVwQbypOZ6ngaCjswtp9KR8JL5 8Jpiku2YDivVWTQYtXgLolqW3HLRjCgH2EDyS8SN994mJs8n4/sEVV4JasK1Ea5xjyaRedFZst0g qU5y6OpqNmoYMCZwZFdhYRIYYTSu2KkbmomBFTBNBPXx5GurVbDa9Bj0UrQELiG02MbI7bZJO8cm qHZjymmLGW+yMbYVVq8oTqvRMcmS5yeXKLZPDDiB8OPGtGRpdg/giY8H0MhobGWauQpVR7DQarJN C8UNYsKLJRgkxAmr2n0qxRT9aGodcJCdnDeGSdnLvOfXSkSBORlxS1GwiMUhwSCmd55EpRzUbSAO hr3C6FTy5s5KkSZzGVLESxzdVkx0QKnuEChxE+6hnRmozDRRFkU6T9hiUIAH7aGwjHq+jB6dmxo2 Oitskjk2k5q1XTRZmWxI5IGJSIhKhwMEzYA+aj64bF11A6J8rIftGw/FM02eRf6iePqmIoAX8zMf XQ+1QSzn4idb1pX28wdqTExOKY6NAY11azhn18XOhyfy5Q6vTEjoTNLNLJXMldYhJYH6B8InfGQB DbnHB0hMOQ9vymZoh3d2ekB3hRJWLYQlYnVLPAs+dJsIRRlLYTYBELljxOIz1RIUJWBkDIb8B3fu IYhEUIdnJYkM4jfPmB9TRfGxaeDEbU8iBzFAsiE/uNh9CHc3PvIGyowiWaQhPCYysXHMswZLheMz cnJmt7zk4KVble95e55Y5zrbwu9AhfAFXxOMBEFsV8+JIXrp0bgoAR/SuRLBIKFS2x8SkWZcKBVD FIvTX2Ofk4Xj4M/Nomyx4/bQIrJ9iWo70oFQCBnxXvMoNoqd925XpEjKxLiQf1iWHSxIvHB5oceB ORxShYoPIek0jxHJp8qlGckIyCRByjHBmAlQYcjeXsQPWnKIFci8rwS1Q2bYtqPsc/kqqfcYZ+mD 8MO/4r+LcfU0IqvLm96bcSt3JC2cbw1acDHfma8mqebicfKc0DRZDyR7NuoIDlucJSgxwnKqZxhX UmRSoLKrNgdP0AhFuB4F3bnfw9kz26ZS7Kh3GnbySAXMhw7A0nz5acEuqHx2yG58XN5Y1qc1ayHX g9Pm0eJKYxyImYwxoR2uiASgOHMZgzhMTbpyaUJdr+c3rI8A3QjwqddjbOY0WcieI8nCB1OJTRgd p3JSgOIJUcfCScdAw0J5G3v4mPQ7mHjLqmoRI91ykiZooMtAYWlhUBUm01IF+DhSywT3G6CiBPCq 8goq02hw7KndsHNeyfLnCSE0p8SLNCszcKBvx476jQEQdzhEDfgzOAhIsfhR7iLAYZUdPgKJVQ9h WKlRSxnDlCh6/HwiaoT4zqCKtW0gAwogShEYWK8bEOdA0GOpIdHh4kjFwHBQ7EaDTXRuugDPm8jq NhozFSYwYNTbaXydKS01FBIWExXV5+K8ACJu3VhMXBTEgJhxWOHFjh1xKPebdCXIbaONCWkssz1D QCu471AXODkGkb0eQgOdFBhqHoiuPiJQjM+aHySjFg6ccSx4L1OQuXKORqoYIDkSwwteZcEVSl8z ffiLoINwMOF+BbdmJhkHtPSSZF6ADcLd2AeWgvCgRKugE+YAc0Wm86iRAXRKcEBo6vtfFmzBW/bZ IHt9PjXv8XkSaL25ovliyQWInZug5uTAcQ7pW9g1qlah9KGWU9BZNEKKTlOqECRIlWEqNXcugLk3 X6vjUEp2JOyCUohkMFDUSFCtJCkBRda1J/DsSsaVjChK0YD7IXqen1WrjxJvT9m2s5GCw6RFJ6Mh mVKkT85TM7CTMcCYvu7HccampyzMZahNj3inBYHtyaEqKUE9JkggIl1JyKOiXrR4U9mlGZWAJZZM AtWFlumRKtsMjCkyVrkgzN+N+qZZvT0Uve/rSKDik4yfSnrCrwE6xMWXmNrmg5ymKJA5sdG1zVC9 blnuLCDYbYuDugg0SmxRZEfnChJEtgxUqRqhg4G9cg5UxzTOY1CBJBCKNIZnFymJE4xVXH6fRPwG akChGRTn1RIzjrDQ5izQrK2DU1WFPyscyMjGnT1GEqOh5Oyg47EdIC6Hq4IhLrZwRmcY0r+trxIS bGMg0usFLizGFsp05Y4IJwlYR8AlMowIQ0QUxKoiigWFKCnOGjdrb93tf5IJLwcnjtrNmhoFeJ+C b35k3hWd4NAh4pA0VGkCuHzn6jiMowpo0Obi8QaLGS8C4yh6HJ6F7H5159cnLsM/MNlEU0cTnqgx QoTzANcSW6OTMEvDOUJUFKRK9nKxyMS1CWs9B3x2+KjfCkSRRto8DE2JHbUxiQl0dGiu+SZLImgk GORphgnPZ7cb4xZONWjlTIuRdkCnRyWiTL1KCnoHvQSPQlJlBitkY2xEkL2kiBfs05J05IE8QUci WQSrc0tIjE12xcy4ZUMp8zmZZnC1i5t619FD5J+xZh8E+A7DNO4ntAM3mCdkfRHrcdQTgo1exLRz r69tHwHL0NExL4PEZjQezjmN9pIiMxmXmImx5apvRM21ChWVOyRM924m4UvWzGnNVdxE61k0nfVi miQli2wU72qqE3DdtLz5ccopmpc8FIG8mNSBCednA1MZZIj7b8HEhjh9ZLEh0t7czllIjQFeOMgD GFDyhUNGHkcuJQcXmHM6dwjrXXUkF2ZfXT1AJXlZITlxIkEhZEtul56l1IpLkRo3HGgql70SAiGj LuiehowUE44hhQPeG6M/BZiKUqy4VTpYMMi5a+90BjE/fTfL8w+9b1KnVIOWIqP6FvJs8jHvRBPL 5qXnb4MNBeRjIjzdwZmcHibIDRRA3MIFZe495QknhQ9EIADwhpKwY3BWjc5mH3izWmh/OxyzKwp+ KIEweoxjR9thhIHpVhUDDQrsQPbgWYpAc96Q3WNPJHF7F0Amh7hSBg2mvdAiYS5HR5ugiaFELxHE gYY0e3us6cFfcKajjka3Dqzqr9M3EwkfEZEoQjz8I9gtCBgv0RKVa9CNThjJ11Y9SXGTJ0S/JPcJ Dgl4kahc4NwXgkxyHXBgSMbjsXJ+asKLgqTI8d95DsyXQY5QSzgiF05hiU9HvIkVIbNkKIVN85Im adHksmrFBSicWOPvEI4lolsqzLgqKY4bjJcNjDRs8oocOHFxMOKCtE82VKQRTmQGs2MBNu38oyI8 XeTzsZKdm7Nr6WXZTAL77gEBckGemZrNUrz2NfFiBM8OTLXIwTOPYkLMPgFSEZRLGzRYin0ofPcQ wZIhzUsbPqmbmaGKaLcITFc8teYrVuOJKZ+KJjoyMGShcyXBlIGzFQuTOzjxNErCJOEw4HJED9ix uNiCJ5t0ZGKHO/vEhfBcrEKp5YYEWCiFM5dPnnMUEYmBGNpSsEvFJ5stmiU+wdF9NQloPZYPYvVQ ovbgzT1I1XwLHiZV1Lk3NvFZOA9sdg7FZBuBTRv311HbDxCinEwHD+T++AbHhbHPYMBLZMbi5uSI ewpBhtUMyHIrBEXVSiah4GOKE0aZ6RqStMH1dP7YrUxm6GwwkDBwAzDYDKqFjiSFMZUxzxwFMshS phkXPeVxKlcUTEUtRHKaERQRB5HdPkKRELyZihI9pxTIouKJpSpXI0x4QxTdllrBgoRxo9DGQIE8 EZRMhUIarmjUSVh6jKYIQjS9uSCiQw34XuCGRpAjp9n2dYEIBFUEuapggIdjG0wTR4WKEezOeTo8 XyuFrpUlEQEmCg+NpImIyivNBDs66CpbqvBrA8MA82A5NkjRHo2ZyCZu9MIsuCLoFsoRcu4Mu8k6 MHBSDpYEHtC6I4tYEhxS5HRA2GzB9vhCN+G1h3HZncerCRFuLLcYckVSYkSppECWqeRQoRFgU5u5 Qe4OR5HJFy5mkxNTVeFhGO2dmag2LBBypYwULHJ7755rpMkICvxiFTeOJxXjeMQLCiQNyV9FweBG 5wcmzZm6JwlKkDbmJNLJQ1WpYU1gWm0ks48GtxMoFSMCpk4OOJqJUsLvTETA+MmypBWK7H831wek LpDEi8DB5qRLclca2KVpyLCQ6VrF4uKQKogjz8BUc8ogl+8QZ1I8Fsysc+e20XKG/OjyVIjEMzNA pI+6J3I1yKOgzA5YVh6lpFkMk/NkDkrO5M6JECDbrYuSOBkkLqileczMDGaA5eo9NgpzobBTsQng 4KPs96ICmNEjKksFBiIo2vrQJDkSY5CghBExYj23dQUy6pZrtMe4m3UastQ7vEG7vFtwlZoubJ+9 s9yiY8Y9o0M6Mx71UxABOyCSEEkBu7w0+DEdQhaDZqijIwvtxN7yCNwTdw6lTRe3g6lXbjMzVUr1 onbDVGjoyt4NaHjAwNocJmZi4DksLPHGzlO1LEViEoRZXOckAoQY0rGMorBUpbD4dAWALjMhJVQy ky7GceN5kW1RSOMPEyFxYT3E7qdcjPdEaDTIVDfqLaqQ1rlXEEOJhLqL6dcrUoCAxJgSQpyWgZoi jTG0XgJt4yZlpWYzICRuSOnTZ2a0icldAk4G4Bb5Ji/LBBNHiZwePYBPl5tvdsqqcYMAoopIFXBw 1EOzgY9FYkQrylMDuWbvwb85uaI+nDX6OjXQsxBSMBmJDnLk6CGhWYv+z6WKiBDHOqFzBB9QFDwd SJFVNIK2Go7P48W5ISlEYgImR7nSbIogJooX25wuGzJEzWtyUynjw5k2xgxdcLxGC5maos+GVhV4 LRHttyEBqsiAkjY93iVLDdFRygyXOTBWQMc8+posQho4uYbhCyncmRZb5ypCBEOu7xLjAvDcHRux 3nhWJaCUDASCeL7uXFxtA2zCKd1GxDhDYyDplqqlZ0qD5LUKJ4dykheTw8EsOXFLEvXomUHmo7ac i32E5EYSziyjycTpLR5EZkjEsQYaRUVqTNkmeez4WHMlixYMFDqh4ieTYpQ0Qg1hRh0qRLnoxsoN cZjjZoomsGSBIsUNzIvuY4RLzMHSNarRuQ+lhySi4PdxMzKJWBs4sTOS5sn5jesOgExeIp0LjlnF ImNjUue8TRU6cx88fcIVUL+g/HqJ16QDs/H4CbvY2FPjqjUXtux9x4OsBzsMVJS8WinFilITABo+ MCC2MJBcea/guZr8yopJ0UFRSOkCuc28DtYF4VzBF4h3iA4wQMYTlhhjk0FC8C2tg1IDEiqrZR9h NclGQySgLRZBgWVCSVJlCaOC3UMlGqjJoLOJ44gBatqWnlFpNTAEk1QLIORgExUsijOQXAkTuXLY RF8slGYCBRQkoyUMMFGiUhFG16ZVmRKhWmV75Xlja+OCCBE0vgozUaZFR5n65X1/Wv+AkSGCCGFe m2FHZAUqfsQ/Zr+t5YK5YYPHnghCaDltl+seVHEYeOHDxhzkGlnb3xUimdS/L1OGfh1wmpMGbRIT zxOxIaDyNt9xzrc3LJsLOEtKYtGf1/MgE+ogkH80koyGUMMyXWHxB9gYAMAkDwYR76QsNQf64cvw EwGAx3XEhuBhN5nHEdQ36iYkJijCCgxJFEQVYiRFjBYMUFQjILBiT5PGCiqRstVUIMsClRpgpcBU FixWhMBRAmJWNLKxQUGyDEjLEY0GAQEgMYkZN/IMVNatHfAMA9eR6hH+CqERzJkEiD+AfkSYT5A/ ySBJIv91ye9PxDSB9dY66mszTOghOMIkjIon8+2pKlPQUIY8ckQwkQm8gFJIFKUPUZP9D+c6bU/o nCVDo0cQsg+tWAhZL0ihQRCqiQhRECZM0PSKG8e8H+P+wn7SwP8kf9xSSFQ/nxH0H/uBkIAhBvAD GFiW/QIhO5JHrCTG3+4NLJNAgkGDGIIwWERYQSRZIskBhAFJBcB/AmD+2kk7CcDQnTtxhgWCxXb8 v/2mfvhys3PgQJxkCRwGOBDRMf8wOKSGdBqOOTQMQMCTLf9r10JXaiTsPgP4iTAiDAiHkwMEWgUQ RALKdywpFVVXpzud+0JO/MgSdHeGfAySxUFzUl1HKy9PFT98xhuX1RA8reFsBTcctJCnlmcAwCdV CShFECCzULBcHmcS5BuFKwQdxmSR7J1k/aQTIU/iQCp/SHkuLM/O6cyA6c3IkgaNIQuXCVjEn0an L67P3oQDw/jTmDzRWuA19hAXMFAEjj7lqimB0FMAC0CvsPUEhf5wwJdYAtBkk5B98BqnrOYcyhzQ hD3p7QR2EhAbA8xXUoL0lob8bvAxkChAQgMySMlSBTMP7BWskUbDdTwmFFecC8iCJexkzAbhPOkg bHjaIgxMAd/LPRApKGmEEEjVGwFxE/3eaGxYUvABiGIyxIAqSDIe4DzCckWSsjLIT2IHsEJ9sCYQ bnMB+t7hzAR80gNSxAQT8iKAzIN5LoZEJEKJQoCSU0HMDAGUe0M5yB5BrG8tIOsV4jJmGOITm3hN mAsEKQwRpHkbKNp1oieJd6jBBfmCj5g9DQ5nBBRQU5HpZIcpC0jB8Yfe7Ykh4kjtOwKXc6UU8aIT kcCQPi8ADBgBJAgIGp5CkgmDAQcaGYeQroh0QC8GAYxooWW2omOqHYkpG4/yEzPj0GABCo3gSKTO hULxSdCgFQkNYmFIASdCRATZ0JBBAQMFICnMDJF24gBMVLeRjRgkLYjIIbahDYOO0hx1AOrgCLEQ d8Ev/cmUQwEQnSJkHBTwHMKdQXqqVcxABBafhA5wzhfOGHq3zCZUmiSOG0kKeRkmHQyEKgL8iFO4 TQzJlVTmDBeZGIWhOJL3CPge4+B8sAUCBAZ7n1BuGS9c/iz8xz+8/SCIiIiJ99KIIU/B8P9Qdnt8 T2/F6L0CkQVnibmBxIYEmcyGSQyeVCQTLM+nJpMukfvJmwkP5JIAlIEtT9jUP20o+JsIrCcCeX6c B+sBM/v3kCwMCUYRlZMCISRQhuQaS4BRVA0HMItcQqGZiaWWBZWtJEuwZSbGFvZRaa4JYiCCGAgS HQMgQ5aMnShDK50H+86KEHINiAaDhjCkxzCEKfxEKpVNghFkJv/lxjANb82A8BP2ksBwvT+R8yqD QywMlSBpmU31ne76v4e4mGJQSk9PrG5mR9uf2pxEgWPI/s+2cnNYBkBXizUnurrsKnGUDUdQEAxb cDEhNAkECLzupiew5Xl9+X5ZqrbyopHVBeYjh5IP+wfhSRBET6wCglpVc6JFDxaJE+0xYocEbE7m k+71zwRVbLVnMe6RY3G5s4Aua4DVC4xEkKv4gmfHiBqXJbWO+RxSCxIkh78OoRNnIrjVUuR1qpxI J7KbhIsZGJEqQxq8yGHsSBueieipgsiaZiA+CJLFnGaZWhJ+RbIDFZCwDE8zFjBcTltjEg8kqeVE +QCvOi4o4gOR0EhvmqICENGDXRrd5bP8zueBk6JnRT2LIEfJEhBdcOIoYipTKWkz45xiFDp4Eklv iJEy9Lc+8xMmCQYquGm9zHFldQdzHgjSxLd1Kr5gSSP1T0rEEyHa2OZjjNDE3KXZMTo6JtQwvPhQ rlqPUJ6h0yGNDkZG01SlGO8dOT3zFg+DZEpIVDTz6pbXlo+syfoiKUg/Ley2NpumEkbUCA9xtAR4 Td0CgCadCOTne4udI8R6n96ZMUZBhgZR5pm7tkp/FcBwxId1mj8nth+s/HQpSMLIliUiUiQEElgZ Aez6tgGJor+5udjUgjKk5tgoEaXiFyELvzoKSSE/S86ia1He/FnLxEnmoLavhOfCQlyd6FYexJjG 8+fhrcP3hUUTTyoDw0uIMbD216F9Rof3geqPvypd9k5TlcT7A0vUG0yIUD6QAqyIW2zgoNgfw6iH RvPUydwcAJDt9b0ByJwRbElQrEU8RDeFqJ8vEa7KWTniGcBKJwQQzUfGQOqsFeb3G80GV6GYgZ69 EDJnlp6LjdhqDbAFhY0zATpmDJmE6waz4w+ll6Uhz8mga7GoNMp8dAG8AyNsRAakR8DsRtexsUPu NKg0IDSsk/SMusN2siDLL8fi+69hPzE4CS3DyCzJ5Ye9t6aSU/Ad5MYnM6eHAdA+Y/CcIXFLB++g PpP5LIXuSP3h9CJMXd/0kEDnHBe9muTAyKRmX6f5EC5U6wEoilfPIx0dxNhYMH5gmi5ORQUwVDsL B0RPHxEhgjKIqz2o6WtzkmSGDzntMl2K4LHHihybJmwoMWMFcRNTJ2DZZDAyWazHZjaIJNCyhMkP AjI/fxU5HeEcEIHIY4CIxoFSYxAHIioD+C4ofWJzgJoHKMbIGDpODoyuJkdi0Kmyp0XI37JjF75U lK+JlpFiApIWai0HMHuwIFCcwfND9gCkpETJoUQ4o5jDH8MiZz03kls66XsgEjSA9EDBA0H2ifRE qHUCIY0ZHI5j0KbxY/ctu8ZG5kbmhiYtNSXQOGZJKQW8FD3DiPY3FLWK9C6FMHocRHKh/Hgn8UTo vAwKS9zMv0oxMhqCsqNUcbgc8sNReSpiIvFB6CquGGGFD92D+g8J5jynpkP6T3DYJRsBKNglhBBJ fxD7HecwBdEQIQMBaDB4GD+fCxQwxI15rsH8mR6P1GOgh+0dwXKP66IL3TXeRHIxu8cg4CfK8A6C Ih0DzCFq9lJBjW5ewCfaZvk/MTE/I9LgcyplG5eJgAIdcCAxCAtgnzIGup1MKMOAB393j5zxgYxX EBaAEDAJCws3AE8O0NnSep5yoG0rjjvDRI/acinB0SxSVz9gMMUm93O3tG7GTAWaoszVbBksGA9f umW5KFcEKlVGDJg2Q+SJuvJI+pH0cwyaGDIs0E+GU111SfUgYKikCZA5z0Y5psY4Dw3J4NlhS/b2 ODTn6Hq5Pkwd4wX/aXKHggOxrTYqFPWtUSyjeRzRCkDlypchEuXU2nY4qGDZAlQtPJOJUsTP4gax Fa2yZLyCZg4GIj5mOSJ+vWCZg0VFPyt4BPifQUFUY1XFJfaZWYuNkhZx7QYzU5LVmWbhgJU4b1MJ f+/2HLJdXLUIbMZmXk68a2szcXDPIDEDbfgZDzQmKxdqBIphuJdtgxITFRGEu02kpEu4cJzkYDrC 3zGB6JqD6Xq1HE5ivwttwJleGeRoDE2g88A5ozzz3+FSEtp1znlxYOJqS5FDsdQ3Jma9i5gNB7LH PtKx6sDqq1/nCIb7snZJCi8F1OeApkML8TMlHj2UTu9KwbUMzJDgEk7h6gbu+UW5JowewDb0APFg Nt+YS8P0CHO2N0RIiKKM0OwA5xCVFqZcykEgVTVLtg9moQsGoHa4wJgn6EsbmaST8OtVEC0mOPtU bGHJQJhG72kUhLR9rWbT/aSciAyDdZNobiEkJ1sHi4wkhcHEd62pqFRvXal/WMgaMJ2dxns7lDq0 5tpHyliJMUoZBXB+RDDQfBcfxTij5IYlCXuDbr5jaodADzjqR9kdgU+x7GwzMg/Q6Sg/KCUfsh7C s4JShWw6QRkmBQQEQWDYGIYMHqxgMIIoqZEmHAoihja4ZeHV6PkPq9mt5y4iwOHfEE4hA9JSeofs KcjQusLCUhQ1h5pg67UQTNPaNbZWxqJOiZINo+J8+AyKdSmXPtHuU8JAuV8giHg+77sHMygxsHPA d1U8GKhJhOTYtxRTuxA+YnCdEDJrvYmb6Bp9y5CbptkCRGhTKTDXk6GK6iIHRjIrnVZEBODZswaK GQsVg/MECIuCAxcFudCIgn6id8kwoNMYt8082Do5GSh5/SoxRRY+IEA9Ho5nZxRohpglK+MudRkT QHz4D8D4yBqSFMaEpAeqLDrrXhWC5yOGtzMkWoefg91VSGDiA9iDjB6zqYGaQXlhMx36jDA112d2 HJTvAzqtRPkdLBJEw5MOR7RkrwvNZMjcX7R4HEzgOM5ptgZG4mOognqJDuoJTcUGs3G62RhkzOL3 7iusKL5g0LcspZEyl0Ww6SHwfRPCCR2SeY5UHImMJI4w150A+Je+K+QZFKWY57J6ZGYzR5gb5Ryz LJN+k7jF+smlKHmGHjiMyuYcMmZLQqmJTgMUHGBJtJiDIgDpy5O6kCRPEoLTAasy2YQsKy3CgyDY bd5QRY6vEi1GOgGQs0JCYW5egrBZjzxFHi3PIbXocSHHM50DoGhpI5PsBPqNyIWQSwQsiUGUglBl IlGh8cl9wB1GP4KHgJmNwaq7HdN29nco+Swp2VUzdXJMZhnHYaj7X0UNwNzmfFfQM18NPcDIbaxh jFmbyyF6Nm9hxY9wTd0XLZH5GUxAlWZaS1ep5JU/emLEnzpdVKpUULQeT2HLShH91oGFnRWRFpNW m3SgqYfQILa2gAGFQzZjCH6WLffqSN0iTUeDIPCkkMQGHyRHWsy94EYTV5WimS7lTqeeR4Q1rzb5 Dmg0tZxTgwyco2YeoJM+BAQAJZEMYhDTimBnnzMHI5JjWClppGQ9lIXiwTjzo29r/PiY+mcJ1e0j arYArbpB0ciPcGuQHZv0ilHGa2MJykfaTbSqiA0eflqYAIYQSAkE6YVBgGHqGO3WU4GZoUks56Pi S6w1nA61ZAVT1FVbVVd1dZDK7d2YuN/lRbv0n7tW6vZVW1kCEb9G0dAmygPM9g6CM8TgqaPLxrH0 yVg9T7nFQpkiN8PIB+CLEhwVDBQkULkYFOVrE/AccK1B6nyREjotSg3wiuT7j5kh4nsIxo4IlTsn sJdlT1exR4cuPV2T4+OzxGeh43HmH74V8nipcd/vUV4P4Y5d9lOXIjvw0ss7IX9mcl9Ml2yGzdh2 Qlwdn111TcyTE0hm6hlupy01WOjJas9pLsAKDQgRCByJBxKtluwcGsKqUoqkyynzgHlKhWJUoL9P pUWpPZ5bOlIFRtsKCnvl7vbZn3oilI/PBeHJhpnRtKUgSyQ2knKeCJIejNVOTJwkokzNV0eVKmyJ ga/2p8RD6BAB1CCchBOo4BYAlyPZCEQhEIeIVlYClKsFkkWIqwYxYgoCwUoo2kTWVvTD1zMhCdsC AanNjqMmJZ0RDvFJs36GofusJA16xnjyBv1kdxRAYhbAquVq39qUQB63GtzpUgcRMKCzXzyOBdq8 HZAz5Dx8iiY+bDVNmrBs4NCnUEoVG7sHB7AOINoveu/VtTHBvN1CcMu+tARJMjHI1iSxVMZV0gM4 p5kDODHluiTEaCDD2fAhO9WQBlKxVlT6bbKvnNGKTKQJhVF+lakNSlPp6w0rXMVyVRpSjUZHQz3T ilKJ9TFDAzXplDjwOAxwLDel1V+oBmZLQdOxgbx8WGVPE1XlZUQPL7tHeSZiIMTaRWkiICfpXJ+p xIKr7Cg9uMxsS5KPl69MqekKsoPG487ns6a+vjunr5XJCdUrEYuc7Y82Wm+mQ7uCgJ5ed0FxO9IX M4WkpuAi4cb+0U5UZFB3F6FrC/bmGReJUeS+iDW6TxUZD309ZuUAvXQS2HkC2G6nx56+E8jQ7X1N 24a+vZ17udjsa2gkKFXs7deiWmZkq47npP5deTe2YN3eYZh2Tx1xfPnXK/CejM1l2Oy66zAlP4qO ZVOg3AdAKkunT3HUvMcSv+kH2296HiJj6mSK9NZIVJEj8SSWzIo1IHn+Os9gnnL24AVVDOvMY5GN z5j3URcQ7Tgd/SFkmfcTcz6DkeZFTKLe2lTMshL8jYKkwZFYN0BIKAIFjgSfy+ISebsAeCPMA5Kh nYTeNx6E9AEbF8R8t0GTJORE8qVnood2vWD8Gd5EcF66nDfRvnLnPbcyG3EHbqA24yE+gPSJwkQ5 Geg1OJwiKCCsCliFCqH4EA6QCFMyXA/BlSSh0uIMJqtNu3U5HxB/MPg/2aUpCsEzH0tlchzIkYEd uvKLDyA8PPMHYLCIIX6DKcQiBnHiQgfrFMHdcxirXnLlG0mHgQpcl4qRI0yktw/tgIJSAEKqOiQT ZElkAjgN8CG/qMDKGNcLSQ2YpgmkcTyscD46lzGTnX/CkuyKXqgnsYnCblAtCH/G0iDlt6wZgShK tiikk+YDkJP6oA3ZSFVTvA6k3SIIQkm5IQEkP9HyWQ7lHzCc8z7h4v3+j0I5wkQBKCX9k2RFajBs LCso1FgypdTznDt+w1DIflABH4j2F3XtLj4DjwKUkRIe4oNUxC0mLZ6Rp2kg6iUeTnvGJqPhOUBv KIk0wU+0AkIDEp5h0rKbMUnCXBssWDJZxoNDhECKJREssIH3ghYsES7HjxA0tEqSyQQRUQReZ1M4 EOCxMobsUNpMqU2eCZQlMiWH+KcOcHaGRidAbsd1+z2pXwMeu/kIp6+sCXZnyeTZIjUueIVJ+SUK i0CblZnpQ6pUoWNaVYn4InsqJlM9FTBkwbyCSKGjWmF2HFanKLc0DUJaFNFSWTzv0FHJdkiZRp1k IcpFvN+DNLk4cHbnXG5nyETsDxLsMkMVp0SOjBBH3MYz27nMEC5gwe8rE8YJnZHBUg8jyWUf+QwR t32/y9TR2EpbH4M+ccCeA+KJBgWOJpMvRaEb55l/V88Tk9HuijokHE4JjwKKUIHyJGYo4l3XEGBQ m2Hi2G1FGZmUkPy64UZJwH6R+AgnQtqHqIJJQoIJKE+lJQQh+If6M1vfg9YGsAwHqT6rJmo2C7B5 J5QGu3APSANEAkQkQhgsDUgF0qOZ8icozPkClALkeo6uk9DzExq5h0BejmNjnPxii+GlR5wS4fgt R+HMJ3yWNbpQ8IE3D0okIRAhEKhABCYaBJewHDXrBxL25lCqetPK9Q2AngtPVdWDDAWJkwgpsyXD Yfv9EPsPD7qrgNpiVM1TFRpASEIVghBAhDuWa9IHB1LvAzwq9lbU5LzqhgTcs9jBjT3GpPjIkktS ugFPoe9ZYi896VBwdzeOwRISPJR5GjMKef2BRZg6gckn55gOh1GuSyJSD4HUocAth1gFqvOUVNPQ e6uY0qPgcQLx3bAPZU2AbSB8sger2dp81QcDKQtloN9xcrJjJglIZKM5Kdq2CVQPUdoEjsXEAehJ 51Djw+KhkNx1RUhIxEUe57hosniKJVZG6iP1qUDZmTEPZ+oyCmMNXiskchBECkUESKoiKKjJFBBk N0AyUOvn7cfvSTj1b8PxB+1IW2cdwJkhgSYYUJyzmEn7j9x6ApJ4nuTzs5HpJx45ygiCCG69b2gG V94BvX2TwoLKg5ENID03rpW99u1Eu3IFKUgMYBvGHXIccrlOL1gHE5JAa1rES7uR682x3I7hvNib d9a6hOYES/y0L3J5iW5NRwSQ7go7jlYOpmdCoJuOQfoM6jWwuZlig1fRmo1EiE4JxPRH0TUPOnmb RwfHmR6RsvE1vx5cy1TUc28dQhZ0cpsQj2xBWyB/rtENNHgtgU4rbvIhMlIX4Zhr5Ntga1GmniND GlnMTn3Px8FGEBGhtC81lVHtEzZ88O+AMYhhoUeMjmf7YPygP6YV1xHDWoLwIfTGqF8HEdRjdfoB Yod66xmmPEOpmoljoIJECA0hEGtg6eSQRNoQBqRQBfMTMOBgwkNAkHNAPyIA1RwKqiXroYH6DTqO wnpfaOIF3uIQyakxDeggQg0NYB/Gu7okXgw1zXSvjp7Zmp5T5dQL2t3hftz1vYhRSEHjvL5MsuqG TccAry6GtwJHQAgS/ZfhqIkD9rzY352D52ee09y2CZMLBc05iKTMMVu8IDn/I/1mDoI+lQ5jBR61 GxR2FBGIUiCAWOeJIIEIRBEG9O8ZCdI8ukgT5n0SDx5iyghYAVsyYBgYSYO0A/Rp8A1hx3vEhuuf n0UBNMF99h8I/Egh8EybIc4Bygo7LmjdXk8hgYR+7j+VSo1RrPGBkjGGCmY6Q5JlFUtIUaGGkb0c 64+wfAP8AgiKjJJGseKtwgnG+JBKRR80cnWbiZIkygPsPijcA/f9EXSaW45mLU6tEgAgz09nYQqm dKQmEaz6BmmBhlY0dLBKcbBoAZ0vPkTQLW5Nyh4K2fI2pYlg1BTXafT9HV5+x/yDUipJ+7mfudj3 9Lw7x1qGcHDv5jePYdpeAXjhtcsvcHYB2neSdEcbC1trYWfbAB3w7QfoNA617g1NUj+UD4L+4147 Iy1sHwi6sIccoJAHxTUDIQr4xkIIXnUYQmvgdfB/MeKMD0j9/aPl6BtB7KiGsTWPavOncb16Xu2G ZBA2c9ZdiPc9cB1LwHgvIZvf0nEvXsAMj+hypCAnK5eWLqXrLgO11j7BpRqOvkvM7snsDyUOE9BP kkTxh1/LfTPR2ifDvGSxFqUZ77LGrWiCFKTlNSakKIVGAU4go6lDzcJ418B7AdukUO7MLiUmAF7D 3QIpnSimdRnlN4BXaWJhAsQBp75KOAmaSM+lFBYsRFDgdEDqkIMOB3ADmgJOAYQDdKF/EG5/wnf3 1LKGw39QHsXjnkwkL2LI0rqQ0EBhIkwAJARCN7IA1BVIUEiYSRBgTg/rQl/sMQVJbWjwFMgnGXkK N0TwfAcDHtB8Jw3kxgTi76/YH+InOCJYeSh4qEhVJvJOiQHuDpeJR+bAH0KHh3S7zPUgT3or+B3J PmybwS4jR79y+MIidha1K3B90hLIEz8QWQlJ9EOEnQJkX+P+f7RzmAZV9kxPNM0BzSNyhyenwUNj VOfRBH1KEJQuIuSjUoKQBmDAq7k2qYgPefVJ84PzxfID3nsrIAm8FTDEQeLEiD5/KkEqSlYaGaFO mA5KHcHcHiVtqNjS0O2CSgmJnFJgJA9DCQJLNFEJGYB+a6psD9B+pPd3NX6ZxO6yFOZ9Boskq5TG 5hSaD9IReXkeYQ+aMEghkv3n4gJQ9BMPF5tmdzAIZiQSCGS3ICROCFhEsEKBg9x5gk2n0WElqfaT pk9IR7k5jyIO5AgmJlE5v5QS7XzIDfMkGUJMxocyux9cyd2gSCbOklzSoqaqNdoSw6mij2PdxW44 OpfPzA2GYVNOUw5v4iYgRJKOYwAPsTiYKO09BpYJ2XiB3J0IQMQkVHzUczsUIZlo3L3dSGpRhcgu 9FGgJIKOBg9VGPWOyNVmWSNQYK/YYrCDihE8j4ORzcu94jDA+CKnqvsu4TryD7+JcLeB6gLEebHo 34uqdI30LgVp5xYYGGAgSgg/X9aITqj8kENptSHBhskfQQsMVWkkawJYNH5zBmC/Scx8uwde33ke PaGwnXx0SeyCdelMIiHcRBkWweqATIECDLCAIcQmdnB/a/04ljMzQYm83szkGzSY+uGHWpNMdJMh Y4ZwYRNpMHRQSFTDtFCU7DbcuTNo6wSr+WMrxEGRAgcVUQkKJIzRUgBthi2BwJ1jzDnlyU2Zxknb AGQ86lr75N57l/tP0E+84jU3dJM+jIZqn4oz75bCbchBMWBRLokjCj3+Mz059xOxjinEhET3xPIi NvFUgEm3ggkGyjCKk0SBnNZwSsofwLYHJpPAJDtlACGyJuP99wSYDdYF3jgnuLliLQIdntPCoeFb gfLeHn/GF8SOVA/XPHIsoxInctCnnqZ5QSPGZ2Mx7s2IUSCwgsBZJPPZQd4UgyR+4FMfajtUa5V1 mJCYxLrR5MjnjIHYcQDoA7KBjV70gQ0W7DWBYmcmnsQIfVf3WdT3jEhrCPQBklO9kYRFij9HWPiC bxNyjqTjSdgJavrQvSF7nyPZPzk0QkNjSzUKCDNqZVDAmELESMkimAllgQaMMEFonosygtEBN0iR AQAgcsUzOnv2K63oPOD4xCT/ticTSJwOQgILnUGYfc5UBOg6SF9l4NoY3SSfq0HYBqGh3xu7TIAe zc28o9NxaYp1dckKC1gvnQKwrIftHuBm8WP1snjATCYnU68qaJDxHmTePUWNgvjJNohxS2YJy/Dc HveoXElooxXflmUkyX7x5Ox5l6+oxIP6vumlqEFCSNrpbhD7nM3tAxKQOmUgoodS3KvJNnPiPQCj vWHjUA5Dn2Tt5Jiex/DyTsnZmAVS5eXZaFgPU99EwkTvpaFFJzsA0q0VRAobLx0jRFPyYJ9Mm5Px HFh4CvIKWFfqSsqTCQQxKEo/CJxpIVZaySjcwIJMUSFW1mBYJnRRmOT1izLAKB60sJeYlj5g/UDH 1BO2cnUFrcHRMviYANoK1V5i/YIvQCORumDpihTgWQP9aVFzaoVUUwhe7UoRCfygqkkEDMsdSxRg PYR5MiYzA9jYXkxV6UAbYYF6C8jIhrsuQEvHt1G6rYZgV5wj/VEQOMAVOMv7JSpHZAqvB+A+7ZG8 5oAjSbQvpA+X5yuu1iYPONrOCABOJNbBoQ1I2H8JJOIgEpRvGnyqPlAVjvUNgM+C+fmdycF9RPry IMcQHBmic0l+yYJCzVDgIhAQACWHbiedwR4inQYpdoZcNQHoFE5hPz0r77wHjm2T5mICD0UaiCQA gTWSfWFJqGhTqE+KbQUxpCD9sLJMaKOxH3kBmMtyfKdd9TCM7UmSADT6KPoPe5QTiPJHmWYah4J+ s5J/DGOvQneoY058wyfiCgRFp2B1WZSWJaHBjQBgKJwdUdbAP2jgdy/8RKr0krlKm607W5R43j3x ngNq/ukoXQhvgO5RhyOUA1jt6HOZuI+TpArQe0DiAbTqW0CweHajguIkZAqop1HsQ/rMwnso5HiP RXHia+C4/gdQ6QOsCpzg+JzCnsX+DQA8DG4cxVhQmNzS9HUdYGg1KHU7ozzDwcw7gHqR9nQfHkAI HEwUJCLsThCdfceQxBWIieIlgKiqv0znJzHoTgDqUfqjlOlQs3F+NeBNd+wa9cQwGuAJRBEpSI3+ YnM1VsBN1V2rA9IFg5biYnoNQ9VaIWSVrALESCginwxrPWwsmbQFYiooiy21gieIT75fEAisRCl0 D/QnmJLGMIZoUfs4x434JoHsdVuEbEJ70mpOAkswVT3wggSeJyCHyWCUlkSCGSfJ2KNQ7gee07xL 7zhDKP0GAMT5Pw/4ZJoTnudwcIcgTB2lsMF9TioYjhEaFSrWFlu+cmOiYmwEMGYbBw+iUQY0C4Rm YmdcBVTwsPYKB5TCcfnqHJ5g4MgFL0UYUgBA8H0cGzwSAtNbL++p+c/087Jvft9TEtLIP94GsGIh D6qEkIUTHMJJCYEJEFYAsHkozUZgC/Re68OhMD8BHj+tQSRvGADYmBbD5XBzKQxrg9AiUuHWJHgE GK0tLl72LlCOtGTkMy4+Q0T7SiVFXSoyMGYQkIqaCWkyKDKkEk+KjICokwMVq8gf0Rh1iIiE937i 6JuGJ09gbyAeyEH/E76yaSKx+r6lwdZ+Il+Ym0r+TsWq7h0qGp3JzBIDYDD/UZVCQT1TkeqM2kO5 jcTkFijAiklkMRGDmK0CkZRyJOr0/Do3gzeQlJTkMgiKVJiQjLAUko/qHJSY/FB3j2jiLN+iUQW3 T5WUOYxyWUTTs/BjBa2paxsrly5z63q1r8LsG5xuijGfZJGlJyZJIq2fUEIZUspoJj0gzqwiri0d B1xaJe/PI1GoQgWCMBRxMNM8KYJgIILD34JSSrRcg+XQr9qMskJONC8IFVKe09oguABuzDp8NgUo fS247RfGLNKfdvnyzpdKn3C1oZF8oJxvBdEZCSOXw+NxYsgDptgFF5AyckLmXYDhJg7s4DKFwlts 0dWMJYlGH+kzy4nXD2RjFREiAfK4jJ8rjExiQMk+UnmN/qQ8tjjPh9wzGlCW1SCaUIGII8SGXvl0 zcg7IyWB61D9TyXuyeS4B2uYugCYBoBNpDAoqKosFBFQWLIqigoLCIIIEYhiEiHWIJ2CllnMPuPs BE5Dz7DUlLAftoE9f75oTDNRiEUYhR8ZYttMBBJB5CX+gHa8U+0HzBfCCIIhIgiEVFFgKLFFFBRR YLFhEYpBQWRRYKPR1zpnZ+OSk6fieIQ8IHb7clwTWBRNrrKwj3iId7D0yJEpEiUmTEYxiRJaSktl lKUYxjGMRLZYttttttllsstljGWyy2WWlL+euS075h8cQ2PuQsowgCZEEOLNcaJcfnFWo0VJMlrN RZG35DcmtSBU90BI+Al9JL8GJPb4hJCwFDyHSSaGbCElCFEkxDCo9IUdgJEe37RmTk41tAbXwKBK 3NU/P54URzhP3vZBAzZpW5/Sf5eDXWxZhkwEhD76KPQ7l6JMMDDDOp+wHEAj80QQmBhwW+fj7z4H uIIWIExJRKLXm0JjhvvAYB8hxzBn1rnEv4lgnT/GKiiqNBxBevaIeqEYPww8jIqLGMBJIWNdDIEN L0DpAyIoXcKKihaYxNpOcv44igqq0MVH66WwoCNcIAWOCJa6GuKC4svMUEJMKRV0aGMwGwwFsTjb TODhiXzpqmkhTfbBgYGc7htASJBAQjBIkPRElJtNtsfL4BNSEwq8XljhIG8JHJMYJMSyUllhfHEE QfsueAAG8AH6090xV3RgKQI/ABg+gsDkEPZ9OhZNBqqWQD6gkAH02fivDa9LtUPUzbUgi2UmJQcF H5B1a1BqWDHSyRkMhBN8msUAIDiVUgEEvmUBoDcMgLZKHkPX3HwJK6nxJF+b7jRoUVCRANngfJbw cpr+rNJQmWCRCslYENBpUZEy7AA4GZ2DzQ0JMbXvyiJyletIfuDFCFSAHquCEHIv4R+kBlKUTUbU nZcAP2Q/RAZNRhYYXWhFHxYKIDUJNX0kiCUUcxv+YJtcuwhYMqhCloC+MJEAfhCSpBQFgvgdzvd8 UySatqYkToNqe+QZllG0hDxZqYHrl44VBe8zkKP6FBFKiXcaQZCPVDqVA0HoERbhO3iC7gp+BAQY ZxEQTbCAIE/SlGqUI7se12g2r8IM6THwWQOMNVw7S4VN0lSxbTHs2wSjngkQJOAJCQLQ5GLZ+bMf PmNRBC6AllFLHMnJZDmBsTsHHJv/KCUccq9LTUVA7AfN+cEXBwTd3J7piOMkFMCIwIiUjiTk+wnM n1SAQLjwNdqjcSbUmTBJgwPwHowSygbcJl+F0D5jpGsBwSyrp0VA/WdI24nsJ5B7F3KPe9o40vH3 A+gkhcJcE/fzviMyDqa/EkD/nIVXdGin6HFOI9VDbIGMiSNuEpsAQTJCO9mM5GgA6hT/FgbEMUJ8 MikOXVGaP8WAIYIEgDz7+Y8yZQA9gGaX9UbrL/J/RnTcD8+e/ATrOsuFU/qP69CA/J8lHPlYgVSB hJgkHBKjpIM6m/rSxAEISA+XbME/qDNFSQ51fx5RIOZrKDzO4KfM/pqGUQiEtu+lAzIagCF5xTwH iulfpw7jaCM0+wEorCHr681m6rvHGICIDqHUA53f5jAk7keiM1B1AKMFFxiQM/8RUgJL1KM0bTRj G8fLevgjuHSNihQcRhiX7JA5GeBewxP1G8MzB9BortVrfkImJifHfpyfBHQ8Df9yPJAtb8ly4JBC qlqS7PzjqOqgDK+wYMi/sSEswyoUzonWfCdZLPhE6C/L3eZXz+m4mFsrqbEuBmb950d8AhxK+a9v ePqJA5HoAagIfBe470Gm2UoVBKjBQJh7ujgdY9dVwE4gaP2bEw03n32g+Q4Dj+vaL9BTP94OYA81 mmRQ3nzE5CfMuHL65xnThIXamVD3HVEQRtFOEE2bBJJkBf292BxHm6+Y4Jv1uWa6cqmle08g4KeX 3yGUpIdeVczvtHnA2B1JrB6n4QOAFDkh09tAMJ7/GzDPehzH72UDzODMaLzHN9g9aob0HxGZmQeg 60dDxA3K9ihj3Edl/cOjaAajAMg5wPsEwHsXp6HEGCPoBjvTG5XUPlJQ18DEjQEkruzD2pyeIn2i gdzvPDmSgkpKJqksEiTKrVJMRQhZJ2hjE6TAfHWjmDTwyjbuOYA2AHo7QNw2c1RE/EgA6kHU8kc6 G5LmugBRQ+sDsn1Liq7rmNDdoKptqtMdE2De3FA6lDBLUaiTBhuRuAxgPpJUkQBxTSHmIWCVB37r xxdedQsEAfYe1wLNEqjqedyZU4SqThIklnkUrWrFZyKEGMYuD4k1IRSZGTNpri6wTTXbFN924gta 1mEOLi+9pQwkqySEgUSFUfdiyGDjLcr0rntGNmCpK12CZepbUbuoDAYiDrG89jidIYDzDwUOQ53M +De8By2K85xXr/AyfHQeS4wYLMC2fcmMcBwA2WFCacaDU2XDgOlxD6m0ePIsQMMZm3L0AQOLThiU AD0wdIMD0KqWFEzD3o5BzKFLt4B3tdh2HZqSBvSo6x7i0iGGIIIjKLgrgK5avTNHns/eefHw5Pdc A+RZxRv6k21WCYwyjCI80RJGAtJTW5YYW0FO7WvQ2pgaS1GZ0g0XYocz3F7AG5MxwUZqGxkNouoY DQyHvHXgvFOw0WhqE6Q51skClq6wCwegNA2aXiOIeppU0ukqvcIZQ7R8++P9WGUH/8XckU4UJCih ofDA --===============0344069462==--