From: Jon Olav Hauglid Date: September 3 2010 7:43am Subject: bzr commit into mysql-5.5-runtime branch (jon.hauglid:3132) List-Archive: http://lists.mysql.com/commits/117488 Message-Id: <201009030745.o82CZNl1024372@acsinet15.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============5794250470135359022==" --===============5794250470135359022== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///export/home/x/mysql-5.5-runtime-test/ based on revid:jon.hauglid@stripped 3132 Jon Olav Hauglid 2010-09-03 [merge] Merge from mysql-5.5-bugfixing to mysql-5.5-runtime. added: include/mysql/service_thd_wait.h include/mysql/service_thread_scheduler.h libservices/my_thread_scheduler_service.c libservices/thd_wait_service.c mysql-test/include/not_blackhole.inc mysql-test/r/partition_not_blackhole.result mysql-test/std_data/parts/t1_blackhole.frm mysql-test/std_data/parts/t1_blackhole.par mysql-test/t/partition_not_blackhole-master.opt mysql-test/t/partition_not_blackhole.test sql/sql_callback.h modified: client/mysqltest.cc configure.in include/Makefile.am include/mysql/plugin.h include/mysql/plugin_audit.h.pp include/mysql/plugin_ftparser.h.pp include/mysql/services.h include/service_versions.h include/thr_lock.h include/violite.h libmysqld/Makefile.am libservices/CMakeLists.txt libservices/Makefile.am mysql-test/CMakeLists.txt mysql-test/r/delete.result mysql-test/r/func_gconcat.result mysql-test/r/func_group.result mysql-test/r/func_misc.result mysql-test/r/func_time.result mysql-test/r/mysqld--help-notwin.result mysql-test/r/mysqld--help-win.result mysql-test/r/range.result mysql-test/suite/innodb/r/innodb_mysql.result mysql-test/suite/innodb/t/innodb_mysql.test mysql-test/suite/rpl/r/rpl_flush_logs.result mysql-test/suite/rpl/t/rpl_drop.test mysql-test/suite/rpl/t/rpl_flush_logs.test mysql-test/t/delete.test mysql-test/t/func_gconcat.test mysql-test/t/func_group.test mysql-test/t/func_misc.test mysql-test/t/func_time.test mysql-test/t/range.test mysys/my_getopt.c mysys/my_init.c mysys/thr_lock.c sql/CMakeLists.txt sql/authors.h sql/ha_partition.cc sql/item_func.cc sql/item_sum.cc sql/item_sum.h sql/log.cc sql/log.h sql/mysqld.cc sql/mysqld.h sql/opt_range.cc sql/scheduler.cc sql/scheduler.h sql/sql_class.cc sql/sql_class.h sql/sql_connect.cc sql/sql_connect.h sql/sql_plugin_services.h sql/sql_select.cc sql/sql_select.h sql/sql_show.cc sql/sql_yacc.yy sql/sys_vars.cc sql/table.h storage/innobase/buf/buf0flu.c storage/innobase/buf/buf0rea.c storage/innobase/srv/srv0srv.c vio/vio.c vio/vio_priv.h vio/viosocket.c vio/viossl.c === modified file 'client/mysqltest.cc' --- a/client/mysqltest.cc 2010-08-16 06:46:21 +0000 +++ b/client/mysqltest.cc 2010-08-27 11:33:32 +0000 @@ -6228,8 +6228,10 @@ get_one_option(int optid, const struct m print_version(); exit(0); case OPT_MYSQL_PROTOCOL: +#ifndef EMBEDDED_LIBRARY opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib, opt->name); +#endif break; case '?': usage(); === modified file 'configure.in' --- a/configure.in 2010-08-18 11:29:04 +0000 +++ b/configure.in 2010-08-25 14:05:33 +0000 @@ -27,7 +27,7 @@ dnl dnl When changing the major version number please also check the switch dnl statement in mysqlbinlog::check_master_version(). You may also need dnl to update version.c in ndb. -AC_INIT([MySQL Server], [5.5.6-m3], [], [mysql]) +AC_INIT([MySQL Server], [5.5.7-m3], [], [mysql]) AC_CONFIG_SRCDIR([sql/mysqld.cc]) AC_CANONICAL_SYSTEM === modified file 'include/Makefile.am' --- a/include/Makefile.am 2010-07-23 20:14:35 +0000 +++ b/include/Makefile.am 2010-08-16 12:50:27 +0000 @@ -26,6 +26,8 @@ HEADERS_ABI = mysql.h mysql_com.h mysql pkginclude_HEADERS = $(HEADERS_ABI) my_dbug.h m_string.h my_sys.h \ my_xml.h mysql_embed.h mysql/services.h \ mysql/service_my_snprintf.h mysql/service_thd_alloc.h \ + mysql/service_thread_scheduler.h \ + mysql/service_thd_wait.h \ my_pthread.h my_no_pthread.h \ decimal.h errmsg.h my_global.h my_net.h \ my_getopt.h sslopt-longopts.h my_dir.h \ === modified file 'include/mysql/plugin.h' --- a/include/mysql/plugin.h 2010-08-18 07:48:38 +0000 +++ b/include/mysql/plugin.h 2010-08-30 14:07:40 +0000 @@ -71,7 +71,7 @@ typedef struct st_mysql_xid MYSQL_XID; Plugin API. Common for all plugin types. */ -#define MYSQL_PLUGIN_INTERFACE_VERSION 0x0101 +#define MYSQL_PLUGIN_INTERFACE_VERSION 0x0102 /* The allowable types of plugins === modified file 'include/mysql/plugin_audit.h.pp' --- a/include/mysql/plugin_audit.h.pp 2010-08-27 06:45:35 +0000 +++ b/include/mysql/plugin_audit.h.pp 2010-08-30 14:07:40 +0000 @@ -31,6 +31,27 @@ void *thd_memdup(void* thd, const void* MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str, const char *str, unsigned int size, int allocate_lex_string); +#include +typedef enum _thd_wait_type_e { + THD_WAIT_MUTEX= 1, + THD_WAIT_DISKIO= 2, + THD_WAIT_ROW_TABLE_LOCK= 3, + THD_WAIT_GLOBAL_LOCK= 4 +} thd_wait_type; +extern struct thd_wait_service_st { + void (*thd_wait_begin_func)(void*, thd_wait_type); + void (*thd_wait_end_func)(void*); +} *thd_wait_service; +void thd_wait_begin(void* thd, thd_wait_type wait_type); +void thd_wait_end(void* thd); +#include +struct scheduler_functions; +extern struct my_thread_scheduler_service { + int (*set)(struct scheduler_functions *scheduler); + int (*reset)(); +} *my_thread_scheduler_service; +int my_thread_scheduler_set(struct scheduler_functions *scheduler); +int my_thread_scheduler_reset(); struct st_mysql_xid { long formatID; long gtrid_length; === modified file 'include/mysql/plugin_ftparser.h.pp' --- a/include/mysql/plugin_ftparser.h.pp 2010-08-27 06:45:35 +0000 +++ b/include/mysql/plugin_ftparser.h.pp 2010-08-30 14:07:40 +0000 @@ -31,6 +31,27 @@ void *thd_memdup(void* thd, const void* MYSQL_LEX_STRING *thd_make_lex_string(void* thd, MYSQL_LEX_STRING *lex_str, const char *str, unsigned int size, int allocate_lex_string); +#include +typedef enum _thd_wait_type_e { + THD_WAIT_MUTEX= 1, + THD_WAIT_DISKIO= 2, + THD_WAIT_ROW_TABLE_LOCK= 3, + THD_WAIT_GLOBAL_LOCK= 4 +} thd_wait_type; +extern struct thd_wait_service_st { + void (*thd_wait_begin_func)(void*, thd_wait_type); + void (*thd_wait_end_func)(void*); +} *thd_wait_service; +void thd_wait_begin(void* thd, thd_wait_type wait_type); +void thd_wait_end(void* thd); +#include +struct scheduler_functions; +extern struct my_thread_scheduler_service { + int (*set)(struct scheduler_functions *scheduler); + int (*reset)(); +} *my_thread_scheduler_service; +int my_thread_scheduler_set(struct scheduler_functions *scheduler); +int my_thread_scheduler_reset(); struct st_mysql_xid { long formatID; long gtrid_length; === added file 'include/mysql/service_thd_wait.h' --- a/include/mysql/service_thd_wait.h 1970-01-01 00:00:00 +0000 +++ b/include/mysql/service_thd_wait.h 2010-06-07 14:01:39 +0000 @@ -0,0 +1,83 @@ +/* Copyright (C) 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef MYSQL_SERVICE_THD_WAIT_INCLUDED +#define MYSQL_SERVICE_THD_WAIT_INCLUDED + +/** + @file include/mysql/service_thd_wait.h + This service provides functions for plugins and storage engines to report + when they are going to sleep/stall. + + SYNOPSIS + thd_wait_begin() - call just before a wait begins + thd Thread object + Use NULL if the thd is NOT known. + wait_type Type of wait + 1 -- short wait (e.g. for mutex) + 2 -- medium wait (e.g. for disk io) + 3 -- large wait (e.g. for locked row/table) + NOTES + This is used by the threadpool to have better knowledge of which + threads that currently are actively running on CPUs. When a thread + reports that it's going to sleep/stall, the threadpool scheduler is + free to start another thread in the pool most likely. The expected wait + time is simply an indication of how long the wait is expected to + become, the real wait time could be very different. + + thd_wait_end() called immediately after the wait is complete + + thd_wait_end() MUST be called if thd_wait_begin() was called. + + Using thd_wait_...() service is optional but recommended. Using it will + improve performance as the thread pool will be more active at managing the + thread workload. +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum _thd_wait_type_e { + THD_WAIT_MUTEX= 1, + THD_WAIT_DISKIO= 2, + THD_WAIT_ROW_TABLE_LOCK= 3, + THD_WAIT_GLOBAL_LOCK= 4 +} thd_wait_type; + +extern struct thd_wait_service_st { + void (*thd_wait_begin_func)(MYSQL_THD, thd_wait_type); + void (*thd_wait_end_func)(MYSQL_THD); +} *thd_wait_service; + +#ifdef MYSQL_DYNAMIC_PLUGIN + +#define thd_wait_begin(_THD, _WAIT_TYPE) \ + thd_wait_service->thd_wait_begin_func(_THD, _WAIT_TYPE) +#define thd_wait_end(_THD) thd_wait_service->thd_wait_end_func(_THD) + +#else + +void thd_wait_begin(MYSQL_THD thd, thd_wait_type wait_type); +void thd_wait_end(MYSQL_THD thd); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif + === added file 'include/mysql/service_thread_scheduler.h' --- a/include/mysql/service_thread_scheduler.h 1970-01-01 00:00:00 +0000 +++ b/include/mysql/service_thread_scheduler.h 2010-06-07 14:01:39 +0000 @@ -0,0 +1,65 @@ +/* + Copyright (C) 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef SERVICE_THREAD_SCHEDULER_INCLUDED +#define SERVICE_THREAD_SCHEDULER_INCLUDED + +#ifdef __cplusplus +extern "C" { +#endif + +struct scheduler_functions; + +extern struct my_thread_scheduler_service { + int (*set)(struct scheduler_functions *scheduler); + int (*reset)(); +} *my_thread_scheduler_service; + +#ifdef MYSQL_DYNAMIC_PLUGIN + +#define my_thread_scheduler_set(F) my_thread_scheduler_service->set((F)) +#define my_thread_scheduler_reset() my_thread_scheduler_service->reset() + +#else + +/** + Set the thread scheduler to use for the server. + + @param scheduler Pointer to scheduler callbacks to use. + @retval 0 Scheduler installed correctly. + @retval 1 Invalid value (NULL) used for scheduler. +*/ +int my_thread_scheduler_set(struct scheduler_functions *scheduler); + +/** + Restore the previous thread scheduler. + + @note If no thread scheduler was installed previously with + thd_set_thread_scheduler, this function will report an error. + + @retval 0 Scheduler installed correctly. + @retval 1 No scheduler installed. +*/ +int my_thread_scheduler_reset(); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* SERVICE_THREAD_SCHEDULER_INCLUDED */ === modified file 'include/mysql/services.h' --- a/include/mysql/services.h 2009-11-02 20:05:42 +0000 +++ b/include/mysql/services.h 2010-06-07 14:01:39 +0000 @@ -20,6 +20,8 @@ extern "C" { #include #include +#include +#include #ifdef __cplusplus } === modified file 'include/service_versions.h' --- a/include/service_versions.h 2009-11-02 20:05:42 +0000 +++ b/include/service_versions.h 2010-06-07 14:01:39 +0000 @@ -21,4 +21,5 @@ #define VERSION_my_snprintf 0x0100 #define VERSION_thd_alloc 0x0100 - +#define VERSION_thd_wait 0x0100 +#define VERSION_my_thread_scheduler 0x0100 === modified file 'include/thr_lock.h' --- a/include/thr_lock.h 2010-07-27 12:42:36 +0000 +++ b/include/thr_lock.h 2010-08-16 12:50:27 +0000 @@ -155,6 +155,8 @@ void thr_downgrade_write_lock(THR_LOC enum thr_lock_type new_lock_type); my_bool thr_reschedule_write_lock(THR_LOCK_DATA *data, ulong lock_wait_timeout); +void thr_set_lock_wait_callback(void (*before_wait)(void), + void (*after_wait)(void)); #ifdef __cplusplus } #endif === modified file 'include/violite.h' --- a/include/violite.h 2010-04-13 15:04:45 +0000 +++ b/include/violite.h 2010-06-07 14:01:39 +0000 @@ -217,6 +217,7 @@ struct st_vio void (*timeout)(Vio*, unsigned int which, unsigned int timeout); my_bool (*poll_read)(Vio *vio, uint timeout); my_bool (*is_connected)(Vio*); + my_bool (*has_data) (Vio*); #ifdef HAVE_OPENSSL void *ssl_arg; #endif === modified file 'libmysqld/Makefile.am' --- a/libmysqld/Makefile.am 2010-08-18 11:29:04 +0000 +++ b/libmysqld/Makefile.am 2010-09-01 03:38:53 +0000 @@ -1,21 +1,17 @@ -# Copyright (C) 2001-2006 MySQL AB +# Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. # -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Library General Public -# License as published by the Free Software Foundation; version 2 -# of the License. +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; version 2 of the License. # -# This library is distributed in the hope that it will be useful, +# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Library General Public License for more details. +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. # -# You should have received a copy of the GNU Library General Public -# License along with this library; if not, write to the Free -# Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, -# MA 02111-1307, USA -# -# This file is public domain and comes with NO WARRANTY of any kind +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA MYSQLDATAdir = $(localstatedir) MYSQLSHAREdir = $(pkgdatadir) === modified file 'libservices/CMakeLists.txt' --- a/libservices/CMakeLists.txt 2010-08-12 15:19:57 +0000 +++ b/libservices/CMakeLists.txt 2010-08-16 12:50:27 +0000 @@ -15,7 +15,11 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) -SET(MYSQLSERVICES_SOURCES my_snprintf_service.c thd_alloc_service.c) +SET(MYSQLSERVICES_SOURCES + my_snprintf_service.c + thd_alloc_service.c + thd_wait_service.c + my_thread_scheduler_service.c) ADD_LIBRARY(mysqlservices ${MYSQLSERVICES_SOURCES}) INSTALL(TARGETS mysqlservices DESTINATION ${INSTALL_LIBDIR}) === modified file 'libservices/Makefile.am' --- a/libservices/Makefile.am 2009-11-02 20:05:42 +0000 +++ b/libservices/Makefile.am 2010-06-07 14:01:39 +0000 @@ -15,5 +15,7 @@ AM_CPPFLAGS = -I$(top_srcdir)/include pkglib_LIBRARIES = libmysqlservices.a -libmysqlservices_a_SOURCES = my_snprintf_service.c thd_alloc_service.c +libmysqlservices_a_SOURCES = my_snprintf_service.c thd_alloc_service.c \ + thd_wait_service.c \ + my_thread_scheduler_service.c EXTRA_DIST = CMakeLists.txt === added file 'libservices/my_thread_scheduler_service.c' --- a/libservices/my_thread_scheduler_service.c 1970-01-01 00:00:00 +0000 +++ b/libservices/my_thread_scheduler_service.c 2010-06-07 14:01:39 +0000 @@ -0,0 +1,21 @@ +/* + Copyright (C) 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA +*/ + +#include +SERVICE_VERSION my_thread_scheduler_service= + (void*)VERSION_my_thread_scheduler; === added file 'libservices/thd_wait_service.c' --- a/libservices/thd_wait_service.c 1970-01-01 00:00:00 +0000 +++ b/libservices/thd_wait_service.c 2010-06-07 14:01:39 +0000 @@ -0,0 +1,19 @@ +/* + Copyright (C) 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include +SERVICE_VERSION *thd_wait_service= (void*)VERSION_thd_wait; === modified file 'mysql-test/CMakeLists.txt' --- a/mysql-test/CMakeLists.txt 2010-08-19 12:11:31 +0000 +++ b/mysql-test/CMakeLists.txt 2010-09-02 22:17:08 +0000 @@ -13,6 +13,7 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +IF(INSTALL_MYSQLTESTDIR) INSTALL( DIRECTORY . DESTINATION ${INSTALL_MYSQLTESTDIR} @@ -28,6 +29,7 @@ INSTALL( PATTERN "*.am" EXCLUDE PATTERN "*.in" EXCLUDE ) +ENDIF() @@ -48,9 +50,11 @@ IF(UNIX) ./mysql-test-run.pl mysql-test-run WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ) - INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/mtr - ${CMAKE_CURRENT_BINARY_DIR}/mysql-test-run - DESTINATION ${INSTALL_MYSQLTESTDIR}) + IF(INSTALL_MYSQLTESTDIR) + INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/mtr + ${CMAKE_CURRENT_BINARY_DIR}/mysql-test-run + DESTINATION ${INSTALL_MYSQLTESTDIR}) + ENDIF() ENDIF() IF(CMAKE_GENERATOR MATCHES "Visual Studio") === added file 'mysql-test/include/not_blackhole.inc' --- a/mysql-test/include/not_blackhole.inc 1970-01-01 00:00:00 +0000 +++ b/mysql-test/include/not_blackhole.inc 2010-07-08 12:36:55 +0000 @@ -0,0 +1,5 @@ +if (`SELECT count(*) FROM information_schema.engines WHERE + (support = 'YES' OR support = 'DEFAULT') AND + engine = 'blackhole'`){ + skip Blackhole engine enabled; +} === modified file 'mysql-test/r/delete.result' --- a/mysql-test/r/delete.result 2010-05-23 20:41:18 +0000 +++ b/mysql-test/r/delete.result 2010-08-30 22:22:01 +0000 @@ -499,4 +499,13 @@ INDEX(a), INDEX(b), INDEX(c)); INSERT INTO t1 VALUES (1,2,3), (4,5,6), (7,8,9); DELETE FROM t1 WHERE a = 10 OR b = 20 ORDER BY c LIMIT 1; DROP TABLE t1; +# +# Bug #53034: Multiple-table DELETE statements not accepting +# "Access compatibility" syntax +# +CREATE TABLE t1 (id INT); +CREATE TABLE t2 LIKE t1; +CREATE TABLE t3 LIKE t1; +DELETE FROM t1.*, test.t2.*, a.* USING t1, t2, t3 AS a; +DROP TABLE t1, t2, t3; End of 5.1 tests === modified file 'mysql-test/r/func_gconcat.result' --- a/mysql-test/r/func_gconcat.result 2010-04-03 17:35:51 +0000 +++ b/mysql-test/r/func_gconcat.result 2010-08-20 11:22:46 +0000 @@ -1003,6 +1003,7 @@ SELECT 1 FROM 1 1 DROP TABLE t1; +End of 5.0 tests # # Bug #52397: another crash with explain extended and group_concat # @@ -1019,6 +1020,25 @@ Warnings: Note 1003 select 1 AS `1` from dual DROP TABLE t1; End of 5.0 tests +# +# Bug #54476: crash when group_concat and 'with rollup' in prepared statements +# +CREATE TABLE t1 (a INT); +INSERT INTO t1 VALUES (1), (2); +PREPARE stmt FROM "SELECT GROUP_CONCAT(t1.a ORDER BY t1.a) FROM t1 JOIN t1 t2 GROUP BY t1.a WITH ROLLUP"; +EXECUTE stmt; +GROUP_CONCAT(t1.a ORDER BY t1.a) +1,1 +2,2 +1,1,2,2 +EXECUTE stmt; +GROUP_CONCAT(t1.a ORDER BY t1.a) +1,1 +2,2 +1,1,2,2 +DEALLOCATE PREPARE stmt; +DROP TABLE t1; +End of 5.1 tests DROP TABLE IF EXISTS t1, t2; CREATE TABLE t1 (a VARCHAR(6), b INT); CREATE TABLE t2 (a VARCHAR(6), b INT); === modified file 'mysql-test/r/func_group.result' --- a/mysql-test/r/func_group.result 2010-08-25 09:21:54 +0000 +++ b/mysql-test/r/func_group.result 2010-08-30 08:36:02 +0000 @@ -1713,6 +1713,17 @@ f1 f2 f3 f4 f1 = f2 NULL NULL NULL NULL NULL drop table t1; # +# Bug #54465: assert: field_types == 0 || field_types[field_pos] == +# MYSQL_TYPE_LONGLONG +# +CREATE TABLE t1 (a INT); +INSERT INTO t1 VALUES (1), (2); +SELECT MAX((SELECT 1 FROM t1 ORDER BY @var LIMIT 1)) m FROM t1 t2, t1 +ORDER BY t1.a; +m +1 +DROP TABLE t1; +# End of 5.1 tests # # Bug#55648: Server crash on MIN/MAX on maximum time value === modified file 'mysql-test/r/func_misc.result' --- a/mysql-test/r/func_misc.result 2010-04-07 09:59:02 +0000 +++ b/mysql-test/r/func_misc.result 2010-08-20 11:22:46 +0000 @@ -337,6 +337,21 @@ select connection_id() > 0; connection_id() > 0 1 # +# Bug #54461: crash with longblob and union or update with subquery +# +CREATE TABLE t1 (a INT, b LONGBLOB); +INSERT INTO t1 VALUES (1, '2'), (2, '3'), (3, '2'); +SELECT DISTINCT LEAST(a, (SELECT b FROM t1 LIMIT 1)) FROM t1 UNION SELECT 1; +LEAST(a, (SELECT b FROM t1 LIMIT 1)) +1 +2 +SELECT DISTINCT GREATEST(a, (SELECT b FROM t1 LIMIT 1)) FROM t1 UNION SELECT 1; +GREATEST(a, (SELECT b FROM t1 LIMIT 1)) +2 +3 +1 +DROP TABLE t1; +# # Bug #52165: Assertion failed: file .\dtoa.c, line 465 # CREATE TABLE t1 (a SET('a'), b INT); === modified file 'mysql-test/r/func_time.result' --- a/mysql-test/r/func_time.result 2010-02-24 13:52:27 +0000 +++ b/mysql-test/r/func_time.result 2010-08-16 07:11:57 +0000 @@ -1305,4 +1305,12 @@ date_sub("0069-01-01 00:00:01",INTERVAL select date_sub("0169-01-01 00:00:01",INTERVAL 2 SECOND); date_sub("0169-01-01 00:00:01",INTERVAL 2 SECOND) 0168-12-31 23:59:59 +CREATE TABLE t1(a DOUBLE NOT NULL); +INSERT INTO t1 VALUES (0),(9.216e-096); +# should not crash +SELECT 1 FROM t1 ORDER BY @x:=makedate(a,a); +1 +1 +1 +DROP TABLE t1; End of 5.1 tests === modified file 'mysql-test/r/mysqld--help-notwin.result' --- a/mysql-test/r/mysqld--help-notwin.result 2010-08-28 16:36:17 +0000 +++ b/mysql-test/r/mysqld--help-notwin.result 2010-08-30 14:07:40 +0000 @@ -688,7 +688,7 @@ The following options may be given as th How many threads we should keep in a cache for reuse --thread-handling=name Define threads usage for handling queries, one of - one-thread-per-connection, no-threads + one-thread-per-connection, no-threads, loaded-dynamically --thread-stack=# The stack size for each thread --time-format=name The TIME format (ignored) --timed-mutexes Specify whether to time mutexes (only InnoDB mutexes are === modified file 'mysql-test/r/mysqld--help-win.result' --- a/mysql-test/r/mysqld--help-win.result 2010-08-28 16:36:17 +0000 +++ b/mysql-test/r/mysqld--help-win.result 2010-08-30 14:07:40 +0000 @@ -692,7 +692,7 @@ The following options may be given as th How many threads we should keep in a cache for reuse --thread-handling=name Define threads usage for handling queries, one of - one-thread-per-connection, no-threads + one-thread-per-connection, no-threads, loaded-dynamically --thread-stack=# The stack size for each thread --time-format=name The TIME format (ignored) --timed-mutexes Specify whether to time mutexes (only InnoDB mutexes are === added file 'mysql-test/r/partition_not_blackhole.result' --- a/mysql-test/r/partition_not_blackhole.result 1970-01-01 00:00:00 +0000 +++ b/mysql-test/r/partition_not_blackhole.result 2010-07-08 12:36:55 +0000 @@ -0,0 +1,16 @@ +DROP TABLE IF EXISTS t1; +# +# Bug#46086: crash when dropping a partitioned table and +# the original engine is disabled +# Copy a .frm and .par file which was created with: +# create table `t1` (`id` int primary key) engine=blackhole +# partition by key () partitions 1; +SHOW TABLES; +Tables_in_test +t1 +SHOW CREATE TABLE t1; +ERROR HY000: Incorrect information in file: './test/t1.frm' +DROP TABLE t1; +ERROR 42S02: Unknown table 't1' +t1.frm +t1.par === modified file 'mysql-test/r/range.result' --- a/mysql-test/r/range.result 2010-08-11 15:55:07 +0000 +++ b/mysql-test/r/range.result 2010-08-26 12:35:38 +0000 @@ -1653,4 +1653,17 @@ a b 0 0 1 1 DROP TABLE t1; +# +# Bug #54802: 'NOT BETWEEN' evaluation is incorrect +# +CREATE TABLE t1 (c_key INT, c_notkey INT, KEY(c_key)); +INSERT INTO t1 VALUES (1, 1), (2, 2), (3, 3); +EXPLAIN SELECT * FROM t1 WHERE 2 NOT BETWEEN c_notkey AND c_key; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL c_key NULL NULL NULL 3 Using where +SELECT * FROM t1 WHERE 2 NOT BETWEEN c_notkey AND c_key; +c_key c_notkey +1 1 +3 3 +DROP TABLE t1; End of 5.1 tests === added file 'mysql-test/std_data/parts/t1_blackhole.frm' Binary files a/mysql-test/std_data/parts/t1_blackhole.frm 1970-01-01 00:00:00 +0000 and b/mysql-test/std_data/parts/t1_blackhole.frm 2010-07-08 12:36:55 +0000 differ === added file 'mysql-test/std_data/parts/t1_blackhole.par' Binary files a/mysql-test/std_data/parts/t1_blackhole.par 1970-01-01 00:00:00 +0000 and b/mysql-test/std_data/parts/t1_blackhole.par 2010-07-08 12:36:55 +0000 differ === modified file 'mysql-test/suite/innodb/r/innodb_mysql.result' --- a/mysql-test/suite/innodb/r/innodb_mysql.result 2010-08-18 09:35:41 +0000 +++ b/mysql-test/suite/innodb/r/innodb_mysql.result 2010-08-30 08:36:02 +0000 @@ -2549,6 +2549,64 @@ LOCK TABLES t1 READ; ALTER TABLE t1 COMMENT 'test'; UNLOCK TABLES; DROP TABLE t1; +# +# Bug#55656: mysqldump can be slower after bug #39653 fix +# +CREATE TABLE t1 (a INT , b INT, c INT, d INT, +KEY (b), PRIMARY KEY (a,b)) ENGINE=INNODB; +INSERT INTO t1 VALUES (1,1,1,1), (2,2,2,2), (3,3,3,3); +EXPLAIN SELECT COUNT(*) FROM t1; +id 1 +select_type SIMPLE +table t1 +type index +possible_keys NULL +key b +key_len 4 +ref NULL +rows 3 +Extra Using index +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b); +EXPLAIN SELECT COUNT(*) FROM t1; +id 1 +select_type SIMPLE +table t1 +type index +possible_keys NULL +key b +key_len 8 +ref NULL +rows 3 +Extra Using index +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b,c); +EXPLAIN SELECT COUNT(*) FROM t1; +id 1 +select_type SIMPLE +table t1 +type index +possible_keys NULL +key b +key_len 13 +ref NULL +rows 3 +Extra Using index +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b,c,d); +EXPLAIN SELECT COUNT(*) FROM t1; +id 1 +select_type SIMPLE +table t1 +type index +possible_keys NULL +key PRIMARY +key_len 8 +ref NULL +rows 3 +Extra Using index +DROP TABLE t1; +# End of 5.1 tests # # Test for bug #39932 "create table fails if column for FK is in different === modified file 'mysql-test/suite/innodb/t/innodb_mysql.test' --- a/mysql-test/suite/innodb/t/innodb_mysql.test 2010-08-16 06:46:21 +0000 +++ b/mysql-test/suite/innodb/t/innodb_mysql.test 2010-08-27 11:33:32 +0000 @@ -746,6 +746,31 @@ UNLOCK TABLES; DROP TABLE t1; +--echo # +--echo # Bug#55656: mysqldump can be slower after bug #39653 fix +--echo # + +CREATE TABLE t1 (a INT , b INT, c INT, d INT, + KEY (b), PRIMARY KEY (a,b)) ENGINE=INNODB; +INSERT INTO t1 VALUES (1,1,1,1), (2,2,2,2), (3,3,3,3); +--query_vertical EXPLAIN SELECT COUNT(*) FROM t1 + +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b); +--query_vertical EXPLAIN SELECT COUNT(*) FROM t1 + +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b,c); +--query_vertical EXPLAIN SELECT COUNT(*) FROM t1 + +DROP INDEX b ON t1; +CREATE INDEX b ON t1(a,b,c,d); +--query_vertical EXPLAIN SELECT COUNT(*) FROM t1 + +DROP TABLE t1; + +--echo # + --echo End of 5.1 tests === modified file 'mysql-test/suite/rpl/r/rpl_flush_logs.result' --- a/mysql-test/suite/rpl/r/rpl_flush_logs.result 2009-12-03 08:59:58 +0000 +++ b/mysql-test/suite/rpl/r/rpl_flush_logs.result 2010-08-30 09:09:28 +0000 @@ -4,12 +4,8 @@ reset master; reset slave; drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9; start slave; -# Make sure the 'master_log.err-old' file does not -# exist before execute 'flush error logs' statement. # Test if support 'flush error logs' statement. flush error logs; -# Check the 'master_log.err-old' file is created -# after executed 'flush error logs' statement. # Make sure binary logs was not be flushed # after execute 'flush error logs' statement. # Make sure relay logs was not be flushed @@ -42,12 +38,8 @@ flush binary logs; # after executed 'flush binary logs' statement. # Make sure the 'slave-relay-bin.000007' file does not exist # exist before execute 'flush error logs, relay logs' statement. -# Make sure the 'master_log.err-old' file does not exist -# before execute 'flush error logs, relay logs' statement. # Test if support to combine all kinds of logs into one statement. flush error logs, relay logs; -# Check the 'master_log.err-old' file is created -# after executed 'flush error logs, relay logs' statement. # Make sure binary logs was not be flushed # after execute 'flush error logs, relay logs' statement. # Check the 'slave-relay-bin.000007' file is created after @@ -55,12 +47,8 @@ flush error logs, relay logs; # Make sure the 'slave-relay-bin.000008' and 'slave-relay-bin.000009' # files do not exist before execute 'flush error logs, relay logs' # statement. -# Make sure the 'master_log.err-old' file does not exist -# before execute 'flush logs' statement. # Test if 'flush logs' statement works fine and flush all the logs. flush logs; -# Check the 'master_log.err-old' file is created -# after executed 'flush logs' statement. # Check 'master-bin.000003' is created # after execute 'flush logs' statement. # Check the 'slave-relay-bin.000008' and 'slave-relay-bin.000009' === modified file 'mysql-test/suite/rpl/t/rpl_drop.test' --- a/mysql-test/suite/rpl/t/rpl_drop.test 2009-11-27 23:34:47 +0000 +++ b/mysql-test/suite/rpl/t/rpl_drop.test 2010-08-20 11:22:46 +0000 @@ -10,3 +10,4 @@ drop table t1, t2; sync_slave_with_master; # End of 4.1 tests + === modified file 'mysql-test/suite/rpl/t/rpl_flush_logs.test' --- a/mysql-test/suite/rpl/t/rpl_flush_logs.test 2009-12-03 08:59:58 +0000 +++ b/mysql-test/suite/rpl/t/rpl_flush_logs.test 2010-08-30 09:09:28 +0000 @@ -9,17 +9,10 @@ connection master; # Test 'flush error logs' statement. ---echo # Make sure the 'master_log.err-old' file does not ---echo # exist before execute 'flush error logs' statement. ---error 1 -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; --echo # Test if support 'flush error logs' statement. flush error logs; ---echo # Check the 'master_log.err-old' file is created ---echo # after executed 'flush error logs' statement. -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; file_exists $MYSQLTEST_VARDIR/tmp/master_log.err; --echo # Make sure binary logs was not be flushed @@ -109,19 +102,10 @@ sync_slave_with_master; file_exists $MYSQLTEST_VARDIR/mysqld.2/data/slave-relay-bin.000007; connection master; -remove_file $MYSQLTEST_VARDIR/tmp/master_log.err-old; - ---echo # Make sure the 'master_log.err-old' file does not exist ---echo # before execute 'flush error logs, relay logs' statement. ---error 1 -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; --echo # Test if support to combine all kinds of logs into one statement. flush error logs, relay logs; ---echo # Check the 'master_log.err-old' file is created ---echo # after executed 'flush error logs, relay logs' statement. -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; file_exists $MYSQLTEST_VARDIR/tmp/master_log.err; --echo # Make sure binary logs was not be flushed @@ -145,19 +129,10 @@ file_exists $MYSQLTEST_VARDIR/mysqld.2/d file_exists $MYSQLTEST_VARDIR/mysqld.2/data/slave-relay-bin.000009; connection master; -remove_file $MYSQLTEST_VARDIR/tmp/master_log.err-old; - ---echo # Make sure the 'master_log.err-old' file does not exist ---echo # before execute 'flush logs' statement. ---error 1 -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; --echo # Test if 'flush logs' statement works fine and flush all the logs. flush logs; ---echo # Check the 'master_log.err-old' file is created ---echo # after executed 'flush logs' statement. -file_exists $MYSQLTEST_VARDIR/tmp/master_log.err-old; file_exists $MYSQLTEST_VARDIR/tmp/master_log.err; --echo # Check 'master-bin.000003' is created === modified file 'mysql-test/t/delete.test' --- a/mysql-test/t/delete.test 2010-05-23 20:41:18 +0000 +++ b/mysql-test/t/delete.test 2010-08-30 22:22:01 +0000 @@ -540,4 +540,17 @@ DELETE FROM t1 WHERE a = 10 OR b = 20 OR DROP TABLE t1; +--echo # +--echo # Bug #53034: Multiple-table DELETE statements not accepting +--echo # "Access compatibility" syntax +--echo # + +CREATE TABLE t1 (id INT); +CREATE TABLE t2 LIKE t1; +CREATE TABLE t3 LIKE t1; + +DELETE FROM t1.*, test.t2.*, a.* USING t1, t2, t3 AS a; + +DROP TABLE t1, t2, t3; + --echo End of 5.1 tests === modified file 'mysql-test/t/func_gconcat.test' --- a/mysql-test/t/func_gconcat.test 2010-04-03 17:35:51 +0000 +++ b/mysql-test/t/func_gconcat.test 2010-08-20 11:22:46 +0000 @@ -708,6 +708,7 @@ SELECT 1 FROM DROP TABLE t1; +--echo End of 5.0 tests --echo # --echo # Bug #52397: another crash with explain extended and group_concat @@ -722,6 +723,26 @@ DROP TABLE t1; --echo End of 5.0 tests + +--echo # +--echo # Bug #54476: crash when group_concat and 'with rollup' in prepared statements +--echo # + +CREATE TABLE t1 (a INT); +INSERT INTO t1 VALUES (1), (2); + +PREPARE stmt FROM "SELECT GROUP_CONCAT(t1.a ORDER BY t1.a) FROM t1 JOIN t1 t2 GROUP BY t1.a WITH ROLLUP"; +EXECUTE stmt; +EXECUTE stmt; + +DEALLOCATE PREPARE stmt; +DROP TABLE t1; + + +--echo End of 5.1 tests + + + # # Bug#36785: Wrong error message when group_concat() exceeds max length # === modified file 'mysql-test/t/func_group.test' --- a/mysql-test/t/func_group.test 2010-08-25 09:21:54 +0000 +++ b/mysql-test/t/func_group.test 2010-08-30 08:36:02 +0000 @@ -1082,6 +1082,20 @@ select a.f1 as a, b.f4 as b, a.f1 > b.f4 from t1 a, t1 b; select *, f1 = f2 from t1; drop table t1; + +--echo # +--echo # Bug #54465: assert: field_types == 0 || field_types[field_pos] == +--echo # MYSQL_TYPE_LONGLONG +--echo # + +CREATE TABLE t1 (a INT); +INSERT INTO t1 VALUES (1), (2); + +SELECT MAX((SELECT 1 FROM t1 ORDER BY @var LIMIT 1)) m FROM t1 t2, t1 + ORDER BY t1.a; + +DROP TABLE t1; + --echo # --echo End of 5.1 tests === modified file 'mysql-test/t/func_misc.test' --- a/mysql-test/t/func_misc.test 2010-04-07 09:59:02 +0000 +++ b/mysql-test/t/func_misc.test 2010-08-20 11:22:46 +0000 @@ -468,6 +468,19 @@ select NAME_CONST('_id',1234) as id; select connection_id() > 0; --echo # +--echo # Bug #54461: crash with longblob and union or update with subquery +--echo # + +CREATE TABLE t1 (a INT, b LONGBLOB); +INSERT INTO t1 VALUES (1, '2'), (2, '3'), (3, '2'); + +SELECT DISTINCT LEAST(a, (SELECT b FROM t1 LIMIT 1)) FROM t1 UNION SELECT 1; +SELECT DISTINCT GREATEST(a, (SELECT b FROM t1 LIMIT 1)) FROM t1 UNION SELECT 1; + +DROP TABLE t1; + + +--echo # --echo # Bug #52165: Assertion failed: file .\dtoa.c, line 465 --echo # @@ -478,4 +491,5 @@ SELECT COALESCE(a) = COALESCE(b) FROM t1 DROP TABLE t1; + --echo End of tests === modified file 'mysql-test/t/func_time.test' --- a/mysql-test/t/func_time.test 2010-02-17 09:18:17 +0000 +++ b/mysql-test/t/func_time.test 2010-08-16 07:11:57 +0000 @@ -821,4 +821,15 @@ select date_sub("0069-01-01 00:00:01",IN select date_sub("0169-01-01 00:00:01",INTERVAL 2 SECOND); +# +# Bug #55565: debug assertion when ordering by expressions with user +# variable assignments +# + +CREATE TABLE t1(a DOUBLE NOT NULL); +INSERT INTO t1 VALUES (0),(9.216e-096); +--echo # should not crash +SELECT 1 FROM t1 ORDER BY @x:=makedate(a,a); +DROP TABLE t1; + --echo End of 5.1 tests === added file 'mysql-test/t/partition_not_blackhole-master.opt' --- a/mysql-test/t/partition_not_blackhole-master.opt 1970-01-01 00:00:00 +0000 +++ b/mysql-test/t/partition_not_blackhole-master.opt 2010-07-08 12:36:55 +0000 @@ -0,0 +1 @@ +--loose-skip-blackhole === added file 'mysql-test/t/partition_not_blackhole.test' --- a/mysql-test/t/partition_not_blackhole.test 1970-01-01 00:00:00 +0000 +++ b/mysql-test/t/partition_not_blackhole.test 2010-08-20 19:17:51 +0000 @@ -0,0 +1,26 @@ +--source include/have_partition.inc +--source include/not_blackhole.inc + +--disable_warnings +DROP TABLE IF EXISTS t1; +--enable_warnings + +let $MYSQLD_DATADIR= `SELECT @@datadir`; + +--echo # +--echo # Bug#46086: crash when dropping a partitioned table and +--echo # the original engine is disabled +--echo # Copy a .frm and .par file which was created with: +--echo # create table `t1` (`id` int primary key) engine=blackhole +--echo # partition by key () partitions 1; +--copy_file std_data/parts/t1_blackhole.frm $MYSQLD_DATADIR/test/t1.frm +--copy_file std_data/parts/t1_blackhole.par $MYSQLD_DATADIR/test/t1.par +SHOW TABLES; +--replace_result $MYSQLD_DATADIR ./ +--error ER_NOT_FORM_FILE +SHOW CREATE TABLE t1; +--error ER_BAD_TABLE_ERROR +DROP TABLE t1; +--list_files $MYSQLD_DATADIR/test t1* +--remove_file $MYSQLD_DATADIR/test/t1.frm +--remove_file $MYSQLD_DATADIR/test/t1.par === modified file 'mysql-test/t/range.test' --- a/mysql-test/t/range.test 2010-08-11 12:13:59 +0000 +++ b/mysql-test/t/range.test 2010-08-24 15:51:32 +0000 @@ -1313,4 +1313,16 @@ SELECT * FROM t1 FORCE INDEX (PRIMARY) DROP TABLE t1; +--echo # +--echo # Bug #54802: 'NOT BETWEEN' evaluation is incorrect +--echo # + +CREATE TABLE t1 (c_key INT, c_notkey INT, KEY(c_key)); +INSERT INTO t1 VALUES (1, 1), (2, 2), (3, 3); + +EXPLAIN SELECT * FROM t1 WHERE 2 NOT BETWEEN c_notkey AND c_key; +SELECT * FROM t1 WHERE 2 NOT BETWEEN c_notkey AND c_key; + +DROP TABLE t1; + --echo End of 5.1 tests === modified file 'mysys/my_getopt.c' --- a/mysys/my_getopt.c 2010-08-26 14:34:18 +0000 +++ b/mysys/my_getopt.c 2010-09-02 01:13:24 +0000 @@ -163,7 +163,6 @@ int handle_options(int *argc, char ***ar int error, i; my_bool is_cmdline_arg= 1; - LINT_INIT(opt_found); /* handle_options() assumes arg0 (program name) always exists */ DBUG_ASSERT(argc && *argc >= 1); DBUG_ASSERT(argv && *argv); @@ -188,6 +187,7 @@ int handle_options(int *argc, char ***ar { char **first= pos; char *cur_arg= *pos; + opt_found= 0; if (!is_cmdline_arg && (cur_arg == args_separator)) { is_cmdline_arg= 1; === modified file 'mysys/my_init.c' --- a/mysys/my_init.c 2010-07-23 20:16:29 +0000 +++ b/mysys/my_init.c 2010-08-16 12:50:27 +0000 @@ -477,7 +477,7 @@ static my_bool win32_init_tcp_ip() { if (win32_have_tcpip()) { - WORD wVersionRequested = MAKEWORD( 2, 0 ); + WORD wVersionRequested = MAKEWORD( 2, 2 ); WSADATA wsaData; /* Be a good citizen: maybe another lib has already initialised sockets, so dont clobber them unless necessary */ === modified file 'mysys/thr_lock.c' --- a/mysys/thr_lock.c 2010-08-06 11:29:37 +0000 +++ b/mysys/thr_lock.c 2010-08-30 14:07:40 +0000 @@ -91,6 +91,16 @@ enum thr_lock_type thr_upgraded_concurre LIST *thr_lock_thread_list; /* List of threads in use */ ulong max_write_lock_count= ~(ulong) 0L; +static void (*before_lock_wait)(void)= 0; +static void (*after_lock_wait)(void)= 0; + +void thr_set_lock_wait_callback(void (*before_wait)(void), + void (*after_wait)(void)) +{ + before_lock_wait= before_wait; + after_lock_wait= after_wait; +} + static inline mysql_cond_t *get_cond(void) { return &my_thread_var->suspend; @@ -431,6 +441,19 @@ wait_for_lock(struct st_lock_list *wait, old_proc_info= proc_info_hook(NULL, "Waiting for table level lock", __func__, __FILE__, __LINE__); + /* + Since before_lock_wait potentially can create more threads to + scheduler work for, we don't want to call the before_lock_wait + callback unless it will really start to wait. + + For similar reasons, we do not want to call before_lock_wait and + after_lock_wait for each lap around the loop, so we restrict + ourselves to call it before_lock_wait once before starting to wait + and once after the thread has exited the wait loop. + */ + if ((!thread_var->abort || in_wait_list) && before_lock_wait) + (*before_lock_wait)(); + set_timespec(wait_timeout, lock_wait_timeout); while (!thread_var->abort || in_wait_list) { @@ -462,6 +485,14 @@ wait_for_lock(struct st_lock_list *wait, /* purecov: end */ } } + + /* + We call the after_lock_wait callback once the wait loop has + finished. + */ + if (after_lock_wait) + (*after_lock_wait)(); + DBUG_PRINT("thr_lock", ("aborted: %d in_wait_list: %d", thread_var->abort, in_wait_list)); === modified file 'sql/CMakeLists.txt' --- a/sql/CMakeLists.txt 2010-08-18 11:29:04 +0000 +++ b/sql/CMakeLists.txt 2010-09-02 22:17:08 +0000 @@ -271,8 +271,7 @@ IF(WIN32 AND MYSQLD_EXECUTABLE) COMMAND ${CMAKE_COMMAND} ${CONFIG_PARAM} -P ${CMAKE_CURRENT_BINARY_DIR}/create_initial_db.cmake WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/data - COMMAND ${CMAKE_COMMAND} -E touch initdb.dep - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/initdb.dep DEPENDS mysqld ) ADD_CUSTOM_TARGET(initial_database === modified file 'sql/authors.h' --- a/sql/authors.h 2010-05-11 16:02:50 +0000 +++ b/sql/authors.h 2010-08-16 12:50:27 +0000 @@ -93,6 +93,7 @@ struct show_table_authors_st show_table_ { "Arjen Lentz", "Brisbane, Australia", "Documentation (2001-2004), Dutch error messages, LOG2()" }, { "Marc Liyanage", "", "Created Mac OS X packages" }, + { "Kelly Long", "Denver, CO, USA", "Pool Of Threads" }, { "Zarko Mocnik", "", "Sorting for Slovenian language" }, { "Per-Erik Martin", "Uppsala, Sweden", "Stored Procedures (5.0)" }, { "Alexis Mikhailov", "", "User-defined functions" }, === modified file 'sql/ha_partition.cc' --- a/sql/ha_partition.cc 2010-07-23 20:09:27 +0000 +++ b/sql/ha_partition.cc 2010-08-19 08:22:23 +0000 @@ -2446,9 +2446,14 @@ bool ha_partition::get_from_handler_file tot_partition_words= (m_tot_parts + 3) / 4; engine_array= (handlerton **) my_alloca(m_tot_parts * sizeof(handlerton*)); for (i= 0; i < m_tot_parts; i++) + { engine_array[i]= ha_resolve_by_legacy_type(ha_thd(), (enum legacy_db_type) - *(uchar *) ((file_buffer) + 12 + i)); + *(uchar *) ((file_buffer) + + 12 + i)); + if (!engine_array[i]) + goto err3; + } address_tot_name_len= file_buffer + 12 + 4 * tot_partition_words; tot_name_words= (uint4korr(address_tot_name_len) + 3) / 4; if (len_words != (tot_partition_words + tot_name_words + 4)) === modified file 'sql/item_func.cc' --- a/sql/item_func.cc 2010-08-19 11:55:35 +0000 +++ b/sql/item_func.cc 2010-08-25 10:22:34 +0000 @@ -2533,6 +2533,8 @@ void Item_func_min_max::fix_length_and_d decimals, unsigned_flag)); } + else if (cmp_type == REAL_RESULT) + fix_char_length(float_length(decimals)); cached_field_type= agg_field_type(args, arg_count); } === modified file 'sql/item_sum.cc' --- a/sql/item_sum.cc 2010-07-19 17:11:47 +0000 +++ b/sql/item_sum.cc 2010-08-30 07:36:04 +0000 @@ -434,26 +434,6 @@ void Item_sum::mark_as_sum_func() } -void Item_sum::make_field(Send_field *tmp_field) -{ - if (args[0]->type() == Item::FIELD_ITEM && keep_field_type()) - { - ((Item_field*) args[0])->field->make_field(tmp_field); - /* For expressions only col_name should be non-empty string. */ - char *empty_string= (char*)""; - tmp_field->db_name= empty_string; - tmp_field->org_table_name= empty_string; - tmp_field->table_name= empty_string; - tmp_field->org_col_name= empty_string; - tmp_field->col_name= name; - if (maybe_null) - tmp_field->flags&= ~NOT_NULL_FLAG; - } - else - init_make_field(tmp_field, field_type()); -} - - void Item_sum::print(String *str, enum_query_type query_type) { /* orig_args is not filled with valid values until fix_fields() */ @@ -984,7 +964,8 @@ bool Aggregator_distinct::add() { int error; copy_fields(tmp_table_param); - copy_funcs(tmp_table_param->items_to_copy); + if (copy_funcs(tmp_table_param->items_to_copy, table->in_use)) + return TRUE; for (Field **field=table->field ; *field ; field++) if ((*field)->is_real_null(0)) @@ -3058,7 +3039,6 @@ Item_func_group_concat::Item_func_group_ tree(item->tree), unique_filter(item->unique_filter), table(item->table), - order(item->order), context(item->context), arg_count_order(item->arg_count_order), arg_count_field(item->arg_count_field), @@ -3071,6 +3051,24 @@ Item_func_group_concat::Item_func_group_ { quick_group= item->quick_group; result.set_charset(collation.collation); + + /* + Since the ORDER structures pointed to by the elements of the 'order' array + may be modified in find_order_in_list() called from + Item_func_group_concat::setup(), create a copy of those structures so that + such modifications done in this object would not have any effect on the + object being copied. + */ + ORDER *tmp; + if (!(order= (ORDER **) thd->alloc(sizeof(ORDER *) * arg_count_order + + sizeof(ORDER) * arg_count_order))) + return; + tmp= (ORDER *)(order + arg_count_order); + for (uint i= 0; i < arg_count_order; i++, tmp++) + { + memcpy(tmp, item->order[i], sizeof(ORDER)); + order[i]= tmp; + } } @@ -3136,7 +3134,8 @@ bool Item_func_group_concat::add() if (always_null) return 0; copy_fields(tmp_table_param); - copy_funcs(tmp_table_param->items_to_copy); + if (copy_funcs(tmp_table_param->items_to_copy, table->in_use)) + return TRUE; for (uint i= 0; i < arg_count_field; i++) { === modified file 'sql/item_sum.h' --- a/sql/item_sum.h 2010-07-19 17:11:47 +0000 +++ b/sql/item_sum.h 2010-08-30 07:36:04 +0000 @@ -427,7 +427,6 @@ public: forced_const= TRUE; } virtual bool const_item() const { return forced_const; } - void make_field(Send_field *field); virtual void print(String *str, enum_query_type query_type); void fix_num_length_and_dec(); === modified file 'sql/log.cc' --- a/sql/log.cc 2010-08-20 02:59:58 +0000 +++ b/sql/log.cc 2010-08-30 08:36:02 +0000 @@ -5447,70 +5447,93 @@ void sql_perror(const char *message) } +#ifdef __WIN__ +extern "C" my_bool reopen_fstreams(const char *filename, + FILE *outstream, FILE *errstream) +{ + int handle_fd; + int stream_fd; + HANDLE osfh; + + DBUG_ASSERT(filename && (outstream || errstream)); + + if ((osfh= CreateFile(filename, GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE | + FILE_SHARE_DELETE, NULL, + OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, + NULL)) == INVALID_HANDLE_VALUE) + return TRUE; + + if ((handle_fd= _open_osfhandle((intptr_t)osfh, + _O_APPEND | _O_TEXT)) == -1) + { + CloseHandle(osfh); + return TRUE; + } + + if (outstream) + { + stream_fd= _fileno(outstream); + if (_dup2(handle_fd, stream_fd) < 0) + { + CloseHandle(osfh); + return TRUE; + } + } + + if (errstream) + { + stream_fd= _fileno(errstream); + if (_dup2(handle_fd, stream_fd) < 0) + { + CloseHandle(osfh); + return TRUE; + } + } + + _close(handle_fd); + return FALSE; +} +#else +extern "C" my_bool reopen_fstreams(const char *filename, + FILE *outstream, FILE *errstream) +{ + if (outstream && !freopen(filename, "a+", outstream)) + return TRUE; + + if (errstream && !freopen(filename, "a+", errstream)) + return TRUE; + + return FALSE; +} +#endif + + /* Unfortunately, there seems to be no good way to restore the original streams upon failure. */ static bool redirect_std_streams(const char *file) { - if (freopen(file, "a+", stdout) && freopen(file, "a+", stderr)) - { - setbuf(stderr, NULL); - return FALSE; - } + if (reopen_fstreams(file, stdout, stderr)) + return TRUE; - return TRUE; + setbuf(stderr, NULL); + return FALSE; } bool flush_error_log() { - bool result=0; + bool result= 0; if (opt_error_log) { - char err_renamed[FN_REFLEN], *end; - end= strmake(err_renamed,log_error_file,FN_REFLEN-5); - strmov(end, "-old"); mysql_mutex_lock(&LOCK_error_log); -#ifdef __WIN__ - char err_temp[FN_REFLEN+5]; - /* - On Windows is necessary a temporary file for to rename - the current error file. - */ - strxmov(err_temp, err_renamed,"-tmp",NullS); - my_delete(err_temp, MYF(0)); - if (freopen(err_temp,"a+",stdout)) - { - int fd; - size_t bytes; - uchar buf[IO_SIZE]; - - freopen(err_temp,"a+",stderr); - setbuf(stderr, NULL); - my_delete(err_renamed, MYF(0)); - my_rename(log_error_file, err_renamed, MYF(0)); - redirect_std_streams(log_error_file); - - if ((fd= my_open(err_temp, O_RDONLY, MYF(0))) >= 0) - { - while ((bytes= mysql_file_read(fd, buf, IO_SIZE, MYF(0))) && - bytes != MY_FILE_ERROR) - my_fwrite(stderr, buf, bytes, MYF(0)); - mysql_file_close(fd, MYF(0)); - } - my_delete(err_temp, MYF(0)); - } - else - result= 1; -#else - my_rename(log_error_file, err_renamed, MYF(0)); - if (redirect_std_streams(log_error_file)) - result= 1; -#endif + if (redirect_std_streams(log_error_file)) + result= 1; mysql_mutex_unlock(&LOCK_error_log); } - return result; + return result; } void MYSQL_BIN_LOG::signal_update() === modified file 'sql/log.h' --- a/sql/log.h 2010-07-23 20:13:36 +0000 +++ b/sql/log.h 2010-08-20 11:22:46 +0000 @@ -394,10 +394,10 @@ public: /* Use this to start writing a new log file */ void new_file(); - bool write(Log_event* event_info); + bool write(Log_event* event_info); // binary log write bool write(THD *thd, IO_CACHE *cache, Log_event *commit_event, bool incident); - bool write_incident(THD *thd, bool lock); + bool write_incident(THD *thd, bool lock); int write_cache(IO_CACHE *cache, bool lock_log, bool flush_and_sync); void set_write_error(THD *thd); bool check_write_error(THD *thd); === modified file 'sql/mysqld.cc' --- a/sql/mysqld.cc 2010-08-25 19:00:38 +0000 +++ b/sql/mysqld.cc 2010-08-30 14:07:40 +0000 @@ -64,7 +64,9 @@ #include "events.h" #include "sql_audit.h" #include "probes_mysql.h" +#include "scheduler.h" #include "debug_sync.h" +#include "sql_callback.h" #ifdef WITH_PERFSCHEMA_STORAGE_ENGINE #include "../storage/perfschema/pfs_server.h" @@ -193,6 +195,9 @@ typedef fp_except fp_except_t; # endif #endif +extern "C" my_bool reopen_fstreams(const char *filename, + FILE *outstream, FILE *errstream); + inline void setup_fpu() { #if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H) @@ -456,7 +461,7 @@ ulong slave_trans_retries; uint slave_net_timeout; ulong slave_exec_mode_options; ulonglong slave_type_conversions_options; -ulong thread_cache_size=0, thread_pool_size= 0; +ulong thread_cache_size=0; ulong binlog_cache_size=0; ulonglong max_binlog_cache_size=0; ulong query_cache_size=0; @@ -898,8 +903,6 @@ my_bool opt_enable_shared_memory; HANDLE smem_event_connect_request= 0; #endif -scheduler_functions thread_scheduler; - my_bool opt_use_ssl = 0; char *opt_ssl_ca= NULL, *opt_ssl_capath= NULL, *opt_ssl_cert= NULL, *opt_ssl_cipher= NULL, *opt_ssl_key= NULL; @@ -1087,7 +1090,8 @@ static void close_connections(void) continue; tmp->killed= THD::KILL_CONNECTION; - thread_scheduler.post_kill_notification(tmp); + MYSQL_CALLBACK(thread_scheduler, post_kill_notification, (tmp)); + mysql_mutex_lock(&tmp->LOCK_thd_data); if (tmp->mysys_var) { tmp->mysys_var->abort=1; @@ -1100,6 +1104,7 @@ static void close_connections(void) } mysql_mutex_unlock(&tmp->mysys_var->mutex); } + mysql_mutex_unlock(&tmp->LOCK_thd_data); } mysql_mutex_unlock(&LOCK_thread_count); // For unlink from list @@ -1479,7 +1484,7 @@ void clean_up(bool print_message) if (print_message && my_default_lc_messages && server_start_time) sql_print_information(ER_DEFAULT(ER_SHUTDOWN_COMPLETE),my_progname); cleanup_errmsgs(); - thread_scheduler.end(); + MYSQL_CALLBACK(thread_scheduler, end, ()); finish_client_errs(); DBUG_PRINT("quit", ("Error messages freed")); /* Tell main we are ready */ @@ -1752,7 +1757,7 @@ static void network_init(void) DBUG_ENTER("network_init"); LINT_INIT(ret); - if (thread_scheduler.init()) + if (MYSQL_CALLBACK_ELSE(thread_scheduler, init, (), 0)) unireg_abort(1); /* purecov: inspected */ set_ports(); @@ -2000,7 +2005,7 @@ extern "C" sig_handler end_thread_signal if (thd && ! thd->bootstrap) { statistic_increment(killed_threads, &LOCK_status); - thread_scheduler.end_thread(thd,0); /* purecov: inspected */ + MYSQL_CALLBACK(thread_scheduler, end_thread, (thd,0)); /* purecov: inspected */ } DBUG_VOID_RETURN; /* purecov: deadcode */ } @@ -2396,7 +2401,7 @@ and this may fail.\n\n"); (ulong) dflt_key_cache->key_cache_mem_size); fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size); fprintf(stderr, "max_used_connections=%lu\n", max_used_connections); - fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads); + fprintf(stderr, "max_threads=%u\n", thread_scheduler->max_threads); fprintf(stderr, "thread_count=%u\n", thread_count); fprintf(stderr, "connection_count=%u\n", connection_count); fprintf(stderr, "It is possible that mysqld could use up to \n\ @@ -2404,7 +2409,7 @@ key_buffer_size + (read_buffer_size + so bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size + (global_system_variables.read_buff_size + global_system_variables.sortbuff_size) * - thread_scheduler.max_threads + + thread_scheduler->max_threads + max_connections * sizeof(THD)) / 1024); fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n"); @@ -2651,7 +2656,7 @@ pthread_handler_t signal_hand(void *arg This should actually be '+ max_number_of_slaves' instead of +10, but the +10 should be quite safe. */ - init_thr_alarm(thread_scheduler.max_threads + + init_thr_alarm(thread_scheduler->max_threads + global_system_variables.max_insert_delayed_threads + 10); if (thd_lib_detected != THD_LIB_LT && (test_flags & TEST_SIGINT)) { @@ -3738,13 +3743,15 @@ static int init_server_components() opt_error_log= 0; // Too long file name else { + my_bool res; #ifndef EMBEDDED_LIBRARY - if (freopen(log_error_file, "a+", stdout)) + res= reopen_fstreams(log_error_file, stdout, stderr); +#else + res= reopen_fstreams(log_error_file, NULL, stderr); #endif - { - if (freopen(log_error_file, "a+", stderr)) - setbuf(stderr, NULL); - } + + if (!res) + setbuf(stderr, NULL); } } @@ -4353,23 +4360,6 @@ int mysqld_main(int argc, char **argv) } #endif -#ifdef __WIN__ - /* - Before performing any socket operation (like retrieving hostname - in init_common_variables we have to call WSAStartup - */ - { - WSADATA WsaData; - if (SOCKET_ERROR == WSAStartup (0x0101, &WsaData)) - { - /* errors are not read yet, so we use english text here */ - my_message(ER_WSAS_FAILED, "WSAStartup Failed", MYF(0)); - /* Not enough initializations for unireg_abort() */ - return 1; - } - } -#endif /* __WIN__ */ - if (init_common_variables()) unireg_abort(1); // Will do exit @@ -4457,8 +4447,8 @@ int mysqld_main(int argc, char **argv) #ifdef __WIN__ if (!opt_console) { - freopen(log_error_file,"a+",stdout); - freopen(log_error_file,"a+",stderr); + if (reopen_fstreams(log_error_file, stdout, stderr)) + unireg_abort(1); setbuf(stderr, NULL); FreeConsole(); // Remove window } @@ -5028,7 +5018,7 @@ static void create_new_thread(THD *thd) thread_count++; - thread_scheduler.add_connection(thd); + MYSQL_CALLBACK(thread_scheduler, add_connection, (thd)); DBUG_VOID_RETURN; } @@ -7344,14 +7334,12 @@ static int get_options(int *argc_ptr, ch return 1; #ifdef EMBEDDED_LIBRARY - one_thread_scheduler(&thread_scheduler); + one_thread_scheduler(); #else if (thread_handling <= SCHEDULER_ONE_THREAD_PER_CONNECTION) - one_thread_per_connection_scheduler(&thread_scheduler); - else if (thread_handling == SCHEDULER_NO_THREADS) - one_thread_scheduler(&thread_scheduler); - else - pool_of_threads_scheduler(&thread_scheduler); /* purecov: tested */ + one_thread_per_connection_scheduler(); + else /* thread_handling == SCHEDULER_NO_THREADS) */ + one_thread_scheduler(); #endif global_system_variables.engine_condition_pushdown= === modified file 'sql/mysqld.h' --- a/sql/mysqld.h 2010-08-18 11:29:04 +0000 +++ b/sql/mysqld.h 2010-08-30 14:07:40 +0000 @@ -28,7 +28,7 @@ class THD; struct handlerton; class Time_zone; -class scheduler_functions; +struct scheduler_functions; typedef struct st_mysql_const_lex_string LEX_CSTRING; typedef struct st_mysql_show_var SHOW_VAR; @@ -175,7 +175,7 @@ extern ulong binlog_cache_size, open_fil extern ulonglong max_binlog_cache_size; extern ulong max_binlog_size, max_relay_log_size; extern ulong opt_binlog_rows_event_max_size; -extern ulong rpl_recovery_rank, thread_cache_size, thread_pool_size; +extern ulong rpl_recovery_rank, thread_cache_size; extern ulong back_log; extern char language[FN_REFLEN]; extern ulong server_id, concurrency; @@ -207,7 +207,7 @@ extern my_bool old_mode; extern LEX_STRING opt_init_connect, opt_init_slave; extern int bootstrap_error; extern I_List threads; -extern scheduler_functions thread_scheduler; +extern char err_shared_dir[]; extern TYPELIB thread_handling_typelib; extern my_decimal decimal_zero; === modified file 'sql/opt_range.cc' --- a/sql/opt_range.cc 2010-07-15 13:47:50 +0000 +++ b/sql/opt_range.cc 2010-08-26 12:35:38 +0000 @@ -5620,7 +5620,11 @@ static SEL_TREE *get_mm_tree(RANGE_OPT_P SEL_TREE *tmp= get_full_func_mm_tree(param, cond_func, field_item, (Item*)(intptr)i, inv); if (inv) + { tree= !tree ? tmp : tree_or(param, tree, tmp); + if (tree == NULL) + break; + } else tree= tree_and(param, tree, tmp); } === modified file 'sql/scheduler.cc' --- a/sql/scheduler.cc 2010-03-31 14:05:33 +0000 +++ b/sql/scheduler.cc 2010-06-15 07:44:26 +0000 @@ -25,55 +25,103 @@ #include "unireg.h" // REQUIRED: for other includes #include "scheduler.h" #include "sql_connect.h" // init_new_connection_handler_thread +#include "scheduler.h" +#include "sql_callback.h" /* - 'Dummy' functions to be used when we don't need any handling for a scheduler - event - */ + End connection, in case when we are using 'no-threads' +*/ -static bool init_dummy(void) {return 0;} -static void post_kill_dummy(THD* thd) {} -static void end_dummy(void) {} -static bool end_thread_dummy(THD *thd, bool cache_thread) { return 0; } +static bool no_threads_end(THD *thd, bool put_in_cache) +{ + unlink_thd(thd); + mysql_mutex_unlock(&LOCK_thread_count); + return 1; // Abort handle_one_connection +} -/* - Initialize default scheduler with dummy functions so that setup functions - only need to declare those that are relvant for their usage +static scheduler_functions one_thread_scheduler_functions= +{ + 1, // max_threads + NULL, // init + init_new_connection_handler_thread, // init_new_connection_thread +#ifndef EMBEDDED_LIBRARY + handle_connection_in_main_thread, // add_connection +#else + NULL, // add_connection +#endif // EMBEDDED_LIBRARY + NULL, // thd_wait_begin + NULL, // thd_wait_end + NULL, // post_kill_notification + no_threads_end, // end_thread + NULL, // end +}; + +#ifndef EMBEDDED_LIBRARY +static scheduler_functions one_thread_per_connection_scheduler_functions= +{ + 0, // max_threads + NULL, // init + init_new_connection_handler_thread, // init_new_connection_thread + create_thread_to_handle_connection, // add_connection + NULL, // thd_wait_begin + NULL, // thd_wait_end + NULL, // post_kill_notification + one_thread_per_connection_end, // end_thread + NULL, // end +}; +#endif // EMBEDDED_LIBRARY + + +scheduler_functions *thread_scheduler= NULL; + +/** @internal + Helper functions to allow mysys to call the thread scheduler when + waiting for locks. */ -scheduler_functions::scheduler_functions() - :init(init_dummy), - init_new_connection_thread(init_new_connection_handler_thread), - add_connection(0), // Must be defined - post_kill_notification(post_kill_dummy), - end_thread(end_thread_dummy), end(end_dummy) -{} +/**@{*/ +static void scheduler_wait_begin(void) { + MYSQL_CALLBACK(thread_scheduler, + thd_wait_begin, (current_thd, THD_WAIT_ROW_TABLE_LOCK)); +} + +static void scheduler_wait_end(void) { + MYSQL_CALLBACK(thread_scheduler, thd_wait_end, (current_thd)); +} +/**@}*/ +/** + Common scheduler init function. + + The scheduler is either initialized by calling + one_thread_scheduler() or one_thread_per_connection_scheduler() in + mysqld.cc, so this init function will always be called. + */ +static void scheduler_init() { + thr_set_lock_wait_callback(scheduler_wait_begin, scheduler_wait_end); +} /* - End connection, in case when we are using 'no-threads' + Initialize scheduler for --thread-handling=one-thread-per-connection */ -static bool no_threads_end(THD *thd, bool put_in_cache) +#ifndef EMBEDDED_LIBRARY +void one_thread_per_connection_scheduler() { - unlink_thd(thd); - mysql_mutex_unlock(&LOCK_thread_count); - return 1; // Abort handle_one_connection + scheduler_init(); + one_thread_per_connection_scheduler_functions.max_threads= max_connections; + thread_scheduler= &one_thread_per_connection_scheduler_functions; } - +#endif /* Initailize scheduler for --thread-handling=no-threads */ -void one_thread_scheduler(scheduler_functions* func) +void one_thread_scheduler() { - func->max_threads= 1; -#ifndef EMBEDDED_LIBRARY - func->add_connection= handle_connection_in_main_thread; -#endif - func->init_new_connection_thread= init_dummy; - func->end_thread= no_threads_end; + scheduler_init(); + thread_scheduler= &one_thread_scheduler_functions; } @@ -81,11 +129,58 @@ void one_thread_scheduler(scheduler_func Initialize scheduler for --thread-handling=one-thread-per-connection */ -#ifndef EMBEDDED_LIBRARY -void one_thread_per_connection_scheduler(scheduler_functions* func) +/* + thd_scheduler keeps the link between THD and events. + It's embedded in the THD class. +*/ + +thd_scheduler::thd_scheduler() + : m_psi(NULL), data(NULL) +{ +#ifndef DBUG_OFF + dbug_explain[0]= '\0'; + set_explain= FALSE; +#endif +} + + +thd_scheduler::~thd_scheduler() +{ +} + +static scheduler_functions *saved_thread_scheduler; +static uint saved_thread_handling; + +extern "C" +int my_thread_scheduler_set(scheduler_functions *scheduler) +{ + DBUG_ASSERT(scheduler != 0); + + if (scheduler == NULL) + return 1; + + saved_thread_scheduler= thread_scheduler; + saved_thread_handling= thread_handling; + thread_scheduler= scheduler; + // Scheduler loaded dynamically + thread_handling= SCHEDULER_TYPES_COUNT; + return 0; +} + + +extern "C" +int my_thread_scheduler_reset() { - func->max_threads= max_connections; - func->add_connection= create_thread_to_handle_connection; - func->end_thread= one_thread_per_connection_end; + DBUG_ASSERT(saved_thread_scheduler != NULL); + + if (saved_thread_scheduler == NULL) + return 1; + + thread_scheduler= saved_thread_scheduler; + thread_handling= saved_thread_handling; + saved_thread_scheduler= 0; + return 0; } -#endif /* EMBEDDED_LIBRARY */ + + + === modified file 'sql/scheduler.h' --- a/sql/scheduler.h 2009-09-23 21:32:31 +0000 +++ b/sql/scheduler.h 2010-06-07 14:01:39 +0000 @@ -28,38 +28,77 @@ class THD; /* Functions used when manipulating threads */ -class scheduler_functions +struct scheduler_functions { -public: uint max_threads; bool (*init)(void); bool (*init_new_connection_thread)(void); void (*add_connection)(THD *thd); + void (*thd_wait_begin)(THD *thd, int wait_type); + void (*thd_wait_end)(THD *thd); void (*post_kill_notification)(THD *thd); bool (*end_thread)(THD *thd, bool cache_thread); void (*end)(void); - scheduler_functions(); }; + +/** + Scheduler types enumeration. + + The default of --thread-handling is the first one in the + thread_handling_names array, this array has to be consistent with + the order in this array, so to change default one has to change the + first entry in this enum and the first entry in the + thread_handling_names array. + + @note The last entry of the enumeration is also used to mark the + thread handling as dynamic. In this case the name of the thread + handling is fetched from the name of the plugin that implements it. +*/ enum scheduler_types { SCHEDULER_ONE_THREAD_PER_CONNECTION=0, SCHEDULER_NO_THREADS, - SCHEDULER_POOL_OF_THREADS + SCHEDULER_TYPES_COUNT }; -void one_thread_per_connection_scheduler(scheduler_functions* func); -void one_thread_scheduler(scheduler_functions* func); +void one_thread_per_connection_scheduler(); +void one_thread_scheduler(); enum pool_command_op { NOT_IN_USE_OP= 0, NORMAL_OP= 1, CONNECT_OP, KILL_OP, DIE_OP }; -#define HAVE_POOL_OF_THREADS 0 /* For easyer tests */ -#define pool_of_threads_scheduler(A) one_thread_per_connection_scheduler(A) - +/* + To be used for pool-of-threads (implemeneted differently on various OSs) +*/ class thd_scheduler -{}; +{ +public: + /* + Thread instrumentation for the user job. + This member holds the instrumentation while the user job is not run + by a thread. + + Note that this member is not conditionally declared + (ifdef HAVE_PSI_INTERFACE), because doing so will change the binary + layout of THD, which is exposed to plugin code that may be compiled + differently. + */ + PSI_thread *m_psi; + + void *data; /* scheduler-specific data structure */ + +# ifndef DBUG_OFF + char dbug_explain[512]; + bool set_explain; +# endif + + thd_scheduler(); + ~thd_scheduler(); +}; + +extern scheduler_functions *thread_scheduler; -#endif /* SCHEDULER_INCLUDED */ +#endif === added file 'sql/sql_callback.h' --- a/sql/sql_callback.h 1970-01-01 00:00:00 +0000 +++ b/sql/sql_callback.h 2010-06-07 14:01:39 +0000 @@ -0,0 +1,43 @@ +/* + Copyright (C) 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef SQL_CALLBACK_INCLUDED +#define SQL_CALLBACK_INCLUDED + +/** + Macro used for an internal callback. + + The macro will check that the object exists and that the function + is defined. If that is the case, it will call the function with the + given parameters. + + If the object or the function is not defined, the callback will be + considered successful (nothing needed to be done) and will + therefore return no error. + */ + +#define MYSQL_CALLBACK(OBJ, FUNC, PARAMS) \ + do { \ + if ((OBJ) && ((OBJ)->FUNC)) \ + (OBJ)->FUNC PARAMS; \ + } while (0) + +#define MYSQL_CALLBACK_ELSE(OBJ, FUNC, PARAMS, ELSE) \ + (((OBJ) && ((OBJ)->FUNC)) ? (OBJ)->FUNC PARAMS : (ELSE)) + + +#endif /* SQL_CALLBACK_INCLUDED */ === modified file 'sql/sql_class.cc' --- a/sql/sql_class.cc 2010-08-20 02:59:58 +0000 +++ b/sql/sql_class.cc 2010-08-30 14:07:40 +0000 @@ -57,6 +57,7 @@ #include "transaction.h" #include "debug_sync.h" #include "sql_parse.h" // is_update_query +#include "sql_callback.h" /* The following is used to initialise Table_ident with a internal @@ -1075,6 +1076,7 @@ THD::~THD() DBUG_ENTER("~THD()"); /* Ensure that no one is using THD */ mysql_mutex_lock(&LOCK_thd_data); + mysys_var=0; // Safety (shouldn't be needed) mysql_mutex_unlock(&LOCK_thd_data); add_to_status(&global_status_var, &status_var); @@ -1100,7 +1102,6 @@ THD::~THD() my_free(db); db= NULL; free_root(&transaction.mem_root,MYF(0)); - mysys_var=0; // Safety (shouldn't be needed) mysql_mutex_destroy(&LOCK_thd_data); #ifndef DBUG_OFF dbug_sentry= THD_SENTRY_GONE; @@ -1189,7 +1190,7 @@ void THD::awake(THD::killed_state state_ { thr_alarm_kill(thread_id); if (!slave_thread) - thread_scheduler.post_kill_notification(this); + MYSQL_CALLBACK(thread_scheduler, post_kill_notification, (this)); #ifdef SIGNAL_WITH_VIO_CLOSE if (this != current_thd) { @@ -1258,6 +1259,15 @@ bool THD::store_globals() if (my_pthread_setspecific_ptr(THR_THD, this) || my_pthread_setspecific_ptr(THR_MALLOC, &mem_root)) return 1; + /* + mysys_var is concurrently readable by a killer thread. + It is protected by LOCK_thd_data, it is not needed to lock while the + pointer is changing from NULL not non-NULL. If the kill thread reads + NULL it doesn't refer to anything, but if it is non-NULL we need to + ensure that the thread doesn't proceed to assign another thread to + have the mysys_var reference (which in fact refers to the worker + threads local storage with key THR_KEY_mysys. + */ mysys_var=my_thread_var; /* Let mysqld define the thread id (not mysys) @@ -3187,6 +3197,60 @@ extern "C" bool thd_sqlcom_can_generate_ { return sqlcom_can_generate_row_events(thd); } + +#ifndef EMBEDDED_LIBRARY +extern "C" void thd_pool_wait_begin(MYSQL_THD thd, int wait_type); +extern "C" void thd_pool_wait_end(MYSQL_THD thd); + +/* + Interface for MySQL Server, plugins and storage engines to report + when they are going to sleep/stall. + + SYNOPSIS + thd_wait_begin() + thd Thread object + wait_type Type of wait + 1 -- short wait (e.g. for mutex) + 2 -- medium wait (e.g. for disk io) + 3 -- large wait (e.g. for locked row/table) + NOTES + This is used by the threadpool to have better knowledge of which + threads that currently are actively running on CPUs. When a thread + reports that it's going to sleep/stall, the threadpool scheduler is + free to start another thread in the pool most likely. The expected wait + time is simply an indication of how long the wait is expected to + become, the real wait time could be very different. + + thd_wait_end MUST be called immediately after waking up again. +*/ +extern "C" void thd_wait_begin(MYSQL_THD thd, thd_wait_type wait_type) +{ + MYSQL_CALLBACK(thread_scheduler, thd_wait_begin, (thd, wait_type)); +} + +/** + Interface for MySQL Server, plugins and storage engines to report + when they waking up from a sleep/stall. + + @param thd Thread handle +*/ +extern "C" void thd_wait_end(MYSQL_THD thd) +{ + MYSQL_CALLBACK(thread_scheduler, thd_wait_end, (thd)); +} +#else +extern "C" void thd_wait_begin(MYSQL_THD thd, thd_wait_type wait_type) +{ + /* do NOTHING for the embedded library */ + return; +} + +extern "C" void thd_wait_end(MYSQL_THD thd) +{ + /* do NOTHING for the embedded library */ + return; +} +#endif #endif // INNODB_COMPATIBILITY_HOOKS */ /**************************************************************************** @@ -3370,6 +3434,13 @@ void THD::set_query_id(query_id_t new_qu mysql_mutex_unlock(&LOCK_thd_data); } +/** Assign a new value to thd->mysys_var. */ +void THD::set_mysys_var(struct st_my_thread_var *new_mysys_var) +{ + mysql_mutex_lock(&LOCK_thd_data); + mysys_var= new_mysys_var; + mysql_mutex_unlock(&LOCK_thd_data); +} /** Leave explicit LOCK TABLES or prelocked mode and restore value of === modified file 'sql/sql_class.h' --- a/sql/sql_class.h 2010-08-18 11:29:04 +0000 +++ b/sql/sql_class.h 2010-08-30 14:07:40 +0000 @@ -1634,6 +1634,10 @@ public: xid_state.xid.null(); free_root(&mem_root,MYF(MY_KEEP_PREALLOC)); } + my_bool is_active() + { + return (all.ha_list != NULL); + } st_transactions() { bzero((char*)this, sizeof(*this)); @@ -2664,7 +2668,7 @@ public: virtual void set_statement(Statement *stmt); /** - Assign a new value to thd->query and thd->query_id. + Assign a new value to thd->query and thd->query_id and mysys_var. Protected with LOCK_thd_data mutex. */ void set_query(char *query_arg, uint32 query_length_arg); @@ -2677,6 +2681,7 @@ public: open_tables= open_tables_arg; mysql_mutex_unlock(&LOCK_thd_data); } + void set_mysys_var(struct st_my_thread_var *new_mysys_var); void enter_locked_tables_mode(enum_locked_tables_mode mode_arg) { DBUG_ASSERT(locked_tables_mode == LTM_NONE); === modified file 'sql/sql_connect.cc' --- a/sql/sql_connect.cc 2010-08-05 12:53:09 +0000 +++ b/sql/sql_connect.cc 2010-08-16 12:50:27 +0000 @@ -35,6 +35,7 @@ #include "hostname.h" // inc_host_errors, ip_to_hostname, // reset_host_errors #include "sql_acl.h" // acl_getroot, NO_ACCESS, SUPER_ACL +#include "sql_callback.h" #if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) /* @@ -966,7 +967,7 @@ bool setup_connection_thread_globals(THD { close_connection(thd, ER_OUT_OF_RESOURCES, 1); statistic_increment(aborted_connects,&LOCK_status); - thread_scheduler.end_thread(thd, 0); + MYSQL_CALLBACK(thread_scheduler, end_thread, (thd, 0)); return 1; // Error } return 0; @@ -989,7 +990,7 @@ bool setup_connection_thread_globals(THD */ -static bool login_connection(THD *thd) +bool login_connection(THD *thd) { NET *net= &thd->net; int error; @@ -1027,7 +1028,7 @@ static bool login_connection(THD *thd) This mainly updates status variables */ -static void end_connection(THD *thd) +void end_connection(THD *thd) { NET *net= &thd->net; plugin_thdvar_cleanup(thd); @@ -1068,7 +1069,7 @@ static void end_connection(THD *thd) Initialize THD to handle queries */ -static void prepare_new_connection_state(THD* thd) +void prepare_new_connection_state(THD* thd) { Security_context *sctx= thd->security_ctx; @@ -1137,11 +1138,11 @@ void do_handle_one_connection(THD *thd_a thd->thr_create_utime= my_micro_time(); - if (thread_scheduler.init_new_connection_thread()) + if (MYSQL_CALLBACK_ELSE(thread_scheduler, init_new_connection_thread, (), 0)) { close_connection(thd, ER_OUT_OF_RESOURCES, 1); statistic_increment(aborted_connects,&LOCK_status); - thread_scheduler.end_thread(thd,0); + MYSQL_CALLBACK(thread_scheduler, end_thread, (thd, 0)); return; } @@ -1195,7 +1196,7 @@ void do_handle_one_connection(THD *thd_a end_thread: close_connection(thd, 0, 1); - if (thread_scheduler.end_thread(thd,1)) + if (MYSQL_CALLBACK_ELSE(thread_scheduler, end_thread, (thd, 1), 0)) return; // Probably no-threads /* === modified file 'sql/sql_connect.h' --- a/sql/sql_connect.h 2010-03-31 14:05:33 +0000 +++ b/sql/sql_connect.h 2010-06-07 14:01:39 +0000 @@ -40,4 +40,8 @@ int check_user(THD *thd, enum enum_serve const char *passwd, uint passwd_len, const char *db, bool check_count); +bool login_connection(THD *thd); +void prepare_new_connection_state(THD* thd); +void end_connection(THD *thd); + #endif /* SQL_CONNECT_INCLUDED */ === modified file 'sql/sql_plugin_services.h' --- a/sql/sql_plugin_services.h 2009-11-02 20:05:42 +0000 +++ b/sql/sql_plugin_services.h 2010-06-07 14:01:39 +0000 @@ -36,9 +36,23 @@ static struct thd_alloc_service_st thd_a thd_make_lex_string }; +static struct thd_wait_service_st thd_wait_handler= { + thd_wait_begin, + thd_wait_end +}; + +static struct my_thread_scheduler_service my_thread_scheduler_handler= { + my_thread_scheduler_set, + my_thread_scheduler_reset, +}; + + static struct st_service_ref list_of_services[]= { { "my_snprintf_service", VERSION_my_snprintf, &my_snprintf_handler }, - { "thd_alloc_service", VERSION_thd_alloc, &thd_alloc_handler } + { "thd_alloc_service", VERSION_thd_alloc, &thd_alloc_handler }, + { "thd_wait_service", VERSION_thd_wait, &thd_wait_handler }, + { "my_thread_scheduler_service", + VERSION_my_thread_scheduler, &my_thread_scheduler_handler }, }; === modified file 'sql/sql_select.cc' --- a/sql/sql_select.cc 2010-08-16 06:46:21 +0000 +++ b/sql/sql_select.cc 2010-08-27 11:33:32 +0000 @@ -12723,7 +12723,9 @@ end_write(JOIN *join, JOIN_TAB *join_tab if (!end_of_records) { copy_fields(&join->tmp_table_param); - copy_funcs(join->tmp_table_param.items_to_copy); + if (copy_funcs(join->tmp_table_param.items_to_copy, join->thd)) + DBUG_RETURN(NESTED_LOOP_ERROR); /* purecov: inspected */ + if (!join->having || join->having->val_int()) { int error; @@ -12813,7 +12815,8 @@ end_update(JOIN *join, JOIN_TAB *join_ta memcpy(table->record[0]+key_part->offset, group->buff, 1); } init_tmptable_sum_functions(join->sum_funcs); - copy_funcs(join->tmp_table_param.items_to_copy); + if (copy_funcs(join->tmp_table_param.items_to_copy, join->thd)) + DBUG_RETURN(NESTED_LOOP_ERROR); /* purecov: inspected */ if ((error=table->file->ha_write_row(table->record[0]))) { if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param, @@ -12848,7 +12851,8 @@ end_unique_update(JOIN *join, JOIN_TAB * init_tmptable_sum_functions(join->sum_funcs); copy_fields(&join->tmp_table_param); // Groups are copied twice. - copy_funcs(join->tmp_table_param.items_to_copy); + if (copy_funcs(join->tmp_table_param.items_to_copy, join->thd)) + DBUG_RETURN(NESTED_LOOP_ERROR); /* purecov: inspected */ if (!(error=table->file->ha_write_row(table->record[0]))) join->send_records++; // New group @@ -12935,7 +12939,8 @@ end_write_group(JOIN *join, JOIN_TAB *jo if (idx < (int) join->send_group_parts) { copy_fields(&join->tmp_table_param); - copy_funcs(join->tmp_table_param.items_to_copy); + if (copy_funcs(join->tmp_table_param.items_to_copy, join->thd)) + DBUG_RETURN(NESTED_LOOP_ERROR); if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1])) DBUG_RETURN(NESTED_LOOP_ERROR); if (join->procedure) @@ -13238,6 +13243,34 @@ ok: } +/** + Find shortest key suitable for full table scan. + + @param table Table to scan + @param usable_keys Allowed keys + + @note + As far as + 1) clustered primary key entry data set is a set of all record + fields (key fields and not key fields) and + 2) secondary index entry data is a union of its key fields and + primary key fields (at least InnoDB and its derivatives don't + duplicate primary key fields there, even if the primary and + the secondary keys have a common subset of key fields), + then secondary index entry data is always a subset of primary key entry. + Unfortunately, key_info[nr].key_length doesn't show the length + of key/pointer pair but a sum of key field lengths only, thus + we can't estimate index IO volume comparing only this key_length + value of secondary keys and clustered PK. + So, try secondary keys first, and choose PK only if there are no + usable secondary covering keys or found best secondary key include + all table fields (i.e. same as PK): + + @return + MAX_KEY no suitable key found + key index otherwise +*/ + uint find_shortest_key(TABLE *table, const key_map *usable_keys) { uint best= MAX_KEY; @@ -13250,23 +13283,6 @@ uint find_shortest_key(TABLE *table, con uint min_length= (uint) ~0; for (uint nr=0; nr < table->s->keys ; nr++) { - /* - As far as - 1) clustered primary key entry data set is a set of all record - fields (key fields and not key fields) and - 2) secondary index entry data is a union of its key fields and - primary key fields (at least InnoDB and its derivatives don't - duplicate primary key fields there, even if the primary and - the secondary keys have a common subset of key fields), - then secondary index entry data is always a subset of primary key - entry, and the PK is always longer. - Unfortunately, key_info[nr].key_length doesn't show the length - of key/pointer pair but a sum of key field lengths only, thus - we can't estimate index IO volume comparing only this key_length - value of seconday keys and clustered PK. - So, try secondary keys first, and choose PK only if there are no - usable secondary covering keys: - */ if (nr == usable_clustered_pk) continue; if (usable_keys->is_set(nr)) @@ -13279,7 +13295,20 @@ uint find_shortest_key(TABLE *table, con } } } - return best != MAX_KEY ? best : usable_clustered_pk; + if (usable_clustered_pk != MAX_KEY) + { + /* + If the primary key is clustered and found shorter key covers all table + fields then primary key scan normally would be faster because amount of + data to scan is the same but PK is clustered. + It's safe to compare key parts with table fields since duplicate key + parts aren't allowed. + */ + if (best == MAX_KEY || + table->key_info[best].key_parts >= table->s->fields) + best= usable_clustered_pk; + } + return best; } /** @@ -15807,14 +15836,39 @@ update_sum_func(Item_sum **func_ptr) return 0; } -/** Copy result of functions to record in tmp_table. */ +/** + Copy result of functions to record in tmp_table. -void -copy_funcs(Item **func_ptr) + Uses the thread pointer to check for errors in + some of the val_xxx() methods called by the + save_in_result_field() function. + TODO: make the Item::val_xxx() return error code + + @param func_ptr array of the function Items to copy to the tmp table + @param thd pointer to the current thread for error checking + @retval + FALSE if OK + @retval + TRUE on error +*/ + +bool +copy_funcs(Item **func_ptr, const THD *thd) { Item *func; for (; (func = *func_ptr) ; func_ptr++) + { func->save_in_result_field(1); + /* + Need to check the THD error state because Item::val_xxx() don't + return error code, but can generate errors + TODO: change it for a real status check when Item::val_xxx() + are extended to return status code. + */ + if (thd->is_error()) + return TRUE; + } + return FALSE; } === modified file 'sql/sql_select.h' --- a/sql/sql_select.h 2010-07-27 12:42:36 +0000 +++ b/sql/sql_select.h 2010-08-17 12:12:52 +0000 @@ -606,7 +606,7 @@ bool setup_copy_fields(THD *thd, TMP_TAB List &new_list1, List &new_list2, uint elements, List &fields); void copy_fields(TMP_TABLE_PARAM *param); -void copy_funcs(Item **func_ptr); +bool copy_funcs(Item **func_ptr, const THD *thd); bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param, int error, bool ignore_last_dupp_error); uint find_shortest_key(TABLE *table, const key_map *usable_keys); === modified file 'sql/sql_show.cc' --- a/sql/sql_show.cc 2010-08-18 11:29:04 +0000 +++ b/sql/sql_show.cc 2010-08-30 14:07:40 +0000 @@ -1815,6 +1815,7 @@ void mysqld_list_processes(THD *thd,cons if ((thd_info->db=tmp->db)) // Safe test thd_info->db=thd->strdup(thd_info->db); thd_info->command=(int) tmp->command; + mysql_mutex_lock(&tmp->LOCK_thd_data); if ((mysys_var= tmp->mysys_var)) mysql_mutex_lock(&mysys_var->mutex); thd_info->proc_info= (char*) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0); @@ -1822,16 +1823,15 @@ void mysqld_list_processes(THD *thd,cons if (mysys_var) mysql_mutex_unlock(&mysys_var->mutex); - thd_info->start_time= tmp->start_time; thd_info->query=0; /* Lock THD mutex that protects its data when looking at it. */ - mysql_mutex_lock(&tmp->LOCK_thd_data); if (tmp->query()) { uint length= min(max_query_length, tmp->query_length()); thd_info->query= (char*) thd->strmake(tmp->query(),length); } mysql_mutex_unlock(&tmp->LOCK_thd_data); + thd_info->start_time= tmp->start_time; thread_infos.append(thd_info); } } @@ -1918,6 +1918,7 @@ int fill_schema_processlist(THD* thd, TA table->field[3]->set_notnull(); } + mysql_mutex_lock(&tmp->LOCK_thd_data); if ((mysys_var= tmp->mysys_var)) mysql_mutex_lock(&mysys_var->mutex); /* COMMAND */ @@ -1938,6 +1939,7 @@ int fill_schema_processlist(THD* thd, TA if (mysys_var) mysql_mutex_unlock(&mysys_var->mutex); + mysql_mutex_unlock(&tmp->LOCK_thd_data); /* INFO */ /* Lock THD mutex that protects its data when looking at it. */ @@ -7490,13 +7492,16 @@ int finalize_schema_table(st_plugin_int ST_SCHEMA_TABLE *schema_table= (ST_SCHEMA_TABLE *)plugin->data; DBUG_ENTER("finalize_schema_table"); - if (schema_table && plugin->plugin->deinit) + if (schema_table) { - DBUG_PRINT("info", ("Deinitializing plugin: '%s'", plugin->name.str)); - if (plugin->plugin->deinit(NULL)) + if (plugin->plugin->deinit) { - DBUG_PRINT("warning", ("Plugin '%s' deinit function returned error.", - plugin->name.str)); + DBUG_PRINT("info", ("Deinitializing plugin: '%s'", plugin->name.str)); + if (plugin->plugin->deinit(NULL)) + { + DBUG_PRINT("warning", ("Plugin '%s' deinit function returned error.", + plugin->name.str)); + } } my_free(schema_table); } === modified file 'sql/sql_yacc.yy' --- a/sql/sql_yacc.yy 2010-08-30 06:03:28 +0000 +++ b/sql/sql_yacc.yy 2010-09-01 13:12:42 +0000 @@ -1425,6 +1425,7 @@ bool my_yyoverflow(short **a, YYSTYPE ** %type table_ident table_ident_nodb references xid + table_ident_opt_wild %type remember_name remember_end opt_db text_or_password @@ -10371,7 +10372,7 @@ table_alias_ref_list: ; table_alias_ref: - table_ident + table_ident_opt_wild { if (!Select->add_table_to_list(YYTHD, $1, NULL, TL_OPTION_UPDATING | TL_OPTION_ALIAS, @@ -12161,6 +12162,21 @@ table_ident: } ; +table_ident_opt_wild: + ident opt_wild + { + $$= new Table_ident($1); + if ($$ == NULL) + MYSQL_YYABORT; + } + | ident '.' ident opt_wild + { + $$= new Table_ident(YYTHD, $1,$3,0); + if ($$ == NULL) + MYSQL_YYABORT; + } + ; + table_ident_nodb: ident { === modified file 'sql/sys_vars.cc' --- a/sql/sys_vars.cc 2010-08-25 00:21:43 +0000 +++ b/sql/sys_vars.cc 2010-08-30 14:07:40 +0000 @@ -1673,19 +1673,13 @@ static Sys_var_ulong Sys_trans_prealloc_ static const char *thread_handling_names[]= { - "one-thread-per-connection", "no-threads", -#if HAVE_POOL_OF_THREADS == 1 - "pool-of-threads", -#endif + "one-thread-per-connection", "no-threads", "loaded-dynamically", 0 }; static Sys_var_enum Sys_thread_handling( "thread_handling", "Define threads usage for handling queries, one of " - "one-thread-per-connection, no-threads" -#if HAVE_POOL_OF_THREADS == 1 - ", pool-of-threads" -#endif + "one-thread-per-connection, no-threads, loaded-dynamically" , READ_ONLY GLOBAL_VAR(thread_handling), CMD_LINE(REQUIRED_ARG), thread_handling_names, DEFAULT(0)); === modified file 'sql/table.h' --- a/sql/table.h 2010-08-31 09:53:49 +0000 +++ b/sql/table.h 2010-09-03 07:42:51 +0000 @@ -192,7 +192,6 @@ typedef struct st_order { struct st_order *next; Item **item; /* Point at item in select fields */ Item *item_ptr; /* Storage for initial item */ - Item **item_copy; /* For SPs; the original item ptr */ int counter; /* position in SELECT list, correct only if counter_used is true*/ bool asc; /* true if ascending */ === modified file 'storage/innobase/buf/buf0flu.c' --- a/storage/innobase/buf/buf0flu.c 2010-07-30 14:39:16 +0000 +++ b/storage/innobase/buf/buf0flu.c 2010-08-30 14:07:40 +0000 @@ -43,6 +43,8 @@ Created 11/11/1995 Heikki Tuuri #include "log0log.h" #include "os0file.h" #include "trx0sys.h" +#include "mysql/plugin.h" +#include "mysql/service_thd_wait.h" /********************************************************************** These statistics are generated for heuristics used in estimating the @@ -1744,10 +1746,14 @@ buf_flush_wait_batch_end( buf_pool = buf_pool_from_array(i); + thd_wait_begin(NULL, THD_WAIT_DISKIO); os_event_wait(buf_pool->no_flush[type]); + thd_wait_end(NULL); } } else { + thd_wait_begin(NULL, THD_WAIT_DISKIO); os_event_wait(buf_pool->no_flush[type]); + thd_wait_end(NULL); } } === modified file 'storage/innobase/buf/buf0rea.c' --- a/storage/innobase/buf/buf0rea.c 2010-06-22 15:58:28 +0000 +++ b/storage/innobase/buf/buf0rea.c 2010-08-16 12:50:27 +0000 @@ -37,6 +37,8 @@ Created 11/5/1995 Heikki Tuuri #include "os0file.h" #include "srv0start.h" #include "srv0srv.h" +#include "mysql/plugin.h" +#include "mysql/service_thd_wait.h" /** The linear read-ahead area size */ #define BUF_READ_AHEAD_LINEAR_AREA BUF_READ_AHEAD_AREA @@ -135,6 +137,7 @@ buf_read_page_low( ut_ad(buf_page_in_file(bpage)); + thd_wait_begin(NULL, THD_WAIT_DISKIO); if (zip_size) { *err = fil_io(OS_FILE_READ | wake_later, sync, space, zip_size, offset, 0, zip_size, @@ -146,6 +149,7 @@ buf_read_page_low( sync, space, 0, offset, 0, UNIV_PAGE_SIZE, ((buf_block_t*) bpage)->frame, bpage); } + thd_wait_end(NULL); ut_a(*err == DB_SUCCESS); if (sync) { === modified file 'storage/innobase/srv/srv0srv.c' --- a/storage/innobase/srv/srv0srv.c 2010-08-17 08:19:24 +0000 +++ b/storage/innobase/srv/srv0srv.c 2010-08-30 14:07:40 +0000 @@ -84,6 +84,8 @@ Created 10/8/1995 Heikki Tuuri #include "ha_prototypes.h" #include "trx0i_s.h" #include "os0sync.h" /* for HAVE_ATOMIC_BUILTINS */ +#include "mysql/plugin.h" +#include "mysql/service_thd_wait.h" /* This is set to TRUE if the MySQL user has set it in MySQL; currently affects only FOREIGN KEY definition parsing */ @@ -1232,7 +1234,9 @@ retry: trx->op_info = "waiting in InnoDB queue"; + thd_wait_begin(trx->mysql_thd, THD_WAIT_ROW_TABLE_LOCK); os_event_wait(slot->event); + thd_wait_end(trx->mysql_thd); trx->op_info = ""; @@ -1597,7 +1601,9 @@ srv_suspend_mysql_thread( /* Suspend this thread and wait for the event. */ + thd_wait_begin(trx->mysql_thd, THD_WAIT_ROW_TABLE_LOCK); os_event_wait(event); + thd_wait_end(trx->mysql_thd); /* After resuming, reacquire the data dictionary latch if necessary. */ === modified file 'vio/vio.c' --- a/vio/vio.c 2010-07-08 21:20:08 +0000 +++ b/vio/vio.c 2010-08-16 12:50:27 +0000 @@ -44,6 +44,11 @@ static my_bool no_poll_read(Vio *vio __a #endif +static my_bool has_no_data(Vio *vio __attribute__((unused))) +{ + return FALSE; +} + /* * Helper to fill most of the Vio* with defaults. */ @@ -83,6 +88,7 @@ static void vio_init(Vio* vio, enum enum vio->poll_read =no_poll_read; vio->is_connected =vio_is_connected_pipe; + vio->has_data =has_no_data; vio->timeout=vio_win32_timeout; /* Set default timeout */ @@ -110,6 +116,7 @@ static void vio_init(Vio* vio, enum enum vio->poll_read =no_poll_read; vio->is_connected =vio_is_connected_shared_memory; + vio->has_data =has_no_data; /* Currently, shared memory is on Windows only, hence the below is ok*/ vio->timeout= vio_win32_timeout; @@ -137,6 +144,7 @@ static void vio_init(Vio* vio, enum enum vio->timeout =vio_timeout; vio->poll_read =vio_poll_read; vio->is_connected =vio_is_connected; + vio->has_data =vio_ssl_has_data; DBUG_VOID_RETURN; } #endif /* HAVE_OPENSSL */ @@ -155,6 +163,8 @@ static void vio_init(Vio* vio, enum enum vio->timeout =vio_timeout; vio->poll_read =vio_poll_read; vio->is_connected =vio_is_connected; + vio->has_data= (flags & VIO_BUFFERED_READ) ? + vio_buff_has_data : has_no_data; DBUG_VOID_RETURN; } === modified file 'vio/vio_priv.h' --- a/vio/vio_priv.h 2009-12-16 08:33:54 +0000 +++ b/vio/vio_priv.h 2010-06-07 14:01:39 +0000 @@ -49,6 +49,7 @@ int vio_close_shared_memory(Vio * vio); #endif void vio_timeout(Vio *vio,uint which, uint timeout); +my_bool vio_buff_has_data(Vio *vio); #ifdef HAVE_OPENSSL #include "my_net.h" /* needed because of struct in_addr */ @@ -62,5 +63,7 @@ void vio_ssl_delete(Vio *vio); int vio_ssl_blocking(Vio *vio, my_bool set_blocking_mode, my_bool *old_mode); +my_bool vio_ssl_has_data(Vio *vio); + #endif /* HAVE_OPENSSL */ #endif /* VIO_PRIV_INCLUDED */ === modified file 'vio/viosocket.c' --- a/vio/viosocket.c 2010-05-21 13:17:01 +0000 +++ b/vio/viosocket.c 2010-08-16 12:50:27 +0000 @@ -98,6 +98,10 @@ size_t vio_read_buff(Vio *vio, uchar* bu #undef VIO_UNBUFFERED_READ_MIN_SIZE } +my_bool vio_buff_has_data(Vio *vio) +{ + return (vio->read_pos != vio->read_end); +} size_t vio_write(Vio * vio, const uchar* buf, size_t size) { === modified file 'vio/viossl.c' --- a/vio/viossl.c 2010-07-15 11:13:30 +0000 +++ b/vio/viossl.c 2010-08-16 12:50:27 +0000 @@ -244,6 +244,9 @@ int vio_ssl_blocking(Vio *vio __attribut return (set_blocking_mode ? 0 : 1); } - +my_bool vio_ssl_has_data(Vio *vio) +{ + return SSL_pending(vio->ssl_arg) > 0 ? TRUE : FALSE; +} #endif /* HAVE_OPENSSL */ --===============5794250470135359022== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/jon.hauglid@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: jon.hauglid@stripped # target_branch: file:///export/home/x/mysql-5.5-runtime-test/ # testament_sha1: a2c1597fe3715edc2108523facc607d298b7ef0d # timestamp: 2010-09-03 09:44:34 +0200 # source_branch: file:///export/home/x/mysql-5.5-bugfixing/ # base_revision_id: jon.hauglid@stripped\ # e1ujugrxfmqir1hr # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWZ3spikBKrl/xf//783///// ////7/////9AAAkAAgAASeFVx49fLU4+G2x3AOIH0fQPSvj4Dae87xRVB4tX2AOveu6ZTgmRsbAA N2GwAB60DTo2w66AAAHuqp9sQmj5Bvnjp9NfXkRsxFOjE1vFuwwy+TRwF7MH17we33t8fC4+kHs4 DFPu9zc2kbMA93a3aPXc0wJdHrqgvZkZ9fdt53r4cTu3Pd1dPoR993uGKA677LZZW9uvAl9aCiEo c2e+9543dzkNALHO8SMVu3q65M7XblVfbLrX1QMh5arTWrsNfRr0M26193cAPbPHt81on3vgd0aB TJrIV3Nyay6Nn3c+zXvu4G2rcL7vgH3n3eOe7vQD3sABVaMqCS21QKlXHR3gHvfd3d7gomx1TXQk B9vua0feY0ATU94B7vt6fQUDEhF6fd9fffORHnYHp7s0HbDB2+B7vvPiUAHoAAAUNAA1ni74D32z exoddB42O9geKlHssaAM+nd8Bu6X0Po7b31jWqBQABRKvHvAJxyADyKACgSAbZ3Xbbzg726+13r7 6bM7wAF1F3c4ixbZC0wxpsaUrW2xRWsQVrTWZg0CbHXWSsurbKWrM2VYzd4CvQAF3c7e9rrZebi8 UxkUrI7c6j28A0K1o1baFhs69gaVXreAJCgFzizrbe7R289apRabAGveAD0N73B7u3J712kyXTYL 2Hb3t9dRE833Y+8O0DAbDLR7eDPXW8Yvpdrr7Y3x1c++c8+1Mj77w70e2ERcbfehWgUCrY0Vm5QU 9tYzJqNpUBsYGIMlQkRkAG7zu9tUDLVAFUth7soK5mpoaxUBps22JTWBZiINFNroB3S21q2KJKJl lMxiqpM2lS1lUhTLp3TABVSkUsBitNUatYTYpJtO9x8trT31dZtVX2wXTA2wE0ZVtgvXwNneKqQh bbWJYLbZjA0zaMsmq1AopVLa2KptmzUUmY1oNYesdEgSlFJ74ShAmgABAQAQEaZTQ0E0xR4kyeSn lPU9J6epNAepoeoAekbyUAlAgAQiIIRiNTCaj1T0SYgNAGgAAAADQAAAAaniAkkhNCaZKfoJPU9P VPKeoHqPUBoA0DQAAAAAAANACTSSCEAiYhlPIJNim0Kn+lT9KB5NlJoNPUaaaabU2oDQABoaADQE SiCAAEYIAI0AEJppommQNNU3kT0mJT2k02UPU0gB6aT1NNlMFSRAEBAI0ATJiJhAE1Jsojan6pvR I3pIG1NNDED9UyADRoCH1//21TyH/6mcWEE+te2FK7/lbJc1SHe2S4qAHyUC9Qi57sj5NXH+LiSo 5UREo1Zylf2sD19n/QxsoXqayw1P3xyE2oEjPtF6Wl33FT8pel4F0UDpYLSSCkn+KkHsiFaU/4QF pFSqAa44+r/P/rgt/6c7f//ZiceYAQo5oMith/1h+AZu61FbPdPPKgon2tkFAE3avS0kE+2gTu8U C0/XE/11aSf2Ya3n/9VQPyigcVUCIITvPMh/8NfZ/9S8yzSDhoDGA2m+rfA/6C3AGskg2saUD0EP 8jlfObVnc2v/q4LM+XN/CxNDcRYQKaEEN1Uyf+L40T+WC2CdGR/x+rf+jNtoftHEXm2KVe65kb/z 2hxPBvczs/upSxPZSdFW+P75aQTlExVYRM9bpUxwz5P8Rr42lssa0v+b/7GjBf/Pj1/8Qnf0j7Kf 7m+jtSbeE9GdzfVb3H+HsHqVEVR9O1Azre2d5bm3quup2Q/cov+xgh+3/e19Fjkxe97z0kW/4shL Om7Tj3+H9xzt7iKoNeXThOcz/2oKjl1T/cPQaptiKzFGU/udeQg3tHEQ/gqOVV0USSvVJPbh5J5F nf/J5wVV8Oxz4wFi371liTtiMDMUzeijRuW5my6B1jUEDMU5i+EGtZNQObagoXWCsEKxEWJwl2qB IzFYNqczKnkAcIEMhUk7e5czTRovkRNzgJqLKF3tZXFQJVJFXLEG1iETD2pHz/RzgAHzP0Pxp7/P XtNOnBjExr6OqXJPY6xQojAVgb/JnLUsF/fTBOx4n/PVbU8tpc5Pi6LprZJqRT4Q9j5/c34v9Hb5 Xwn3DK+uB9n3qY3lEBI+5gI8OGZWu8m2ymxuQz1083HfYpuz9W1NqZ119+qG0OGUd+7O7WvV12kO E2TszfmvSybsBYQ+zqdLnRDxZKyT4Mk5QDIntQx7dr5M1ve5utX6NZa469nb2mZrO7tlJ11tr3YF ywUkJFMb5x1z3d5k/x/iMvn/CHrb8JL/Gc94KL8KTfn/w/+2I/wFuKLDmN+s/yI/jttj7TMuKP41 a4V6prsbfP07ocfxX2/VfWnjeWTUyOzjWQq2rH6Z7daE8eBgQou69F6W2cLI8FkzOK8MKrXS3ZxU qZ8lVr+mGOJCtUdqN+xTm7Qp38z/KnY1MTEs0dn0XG6VMLOXAfpyJnA6OVcLvQ7svBqs1NsSzCWx 3DXm/LPu14Pq54dCiTdMevLGFxCouuMrluXMa9b+yyrGcx3Tceci4YphzktMKo51KtQ99+HZi+D8 zsH7WGwuLxkMjvG5i4GfA78uG3FeJxHPIxbgVM9+QrtHyN8bCZvLPjaQY8GVp96P4f2vPsX5Tz9d 9R/F3N8ECZb+mwkzVA+yLGTcAosMgol5ILqZyEF7CLrJmZyZDydxtQfPAB8f/iA7N+3fT9vVP1ee 0byrrDVTZZh21dKXE6Vab6JKz1nJzNNxNXs6S/Q63lh88GF9PlDN3pFxv8T+TxenznspRi2kY2Un nFodtlCT5tKfKj9hXW36B7fNZrhs74Fzp2JHEjdQ5hzfgexffg973DfjpYg2zqvjqs9OsZ5Tsk+G MH8npZYPsEHkWwsJ0Q9vvHj6ErSaDIfTgZW1Swgjuv8jMWaOOWL+FdPCrNXMeGMYXRoWB/2rnyp0 o3UodJMFah3F9CpAXdSGTcoFN+932c3V3UWPZ+FFMKz2Oer1po8vPJEzovRDx26Nn/5cYnkcfEVW AgYaFdVXUQy/7+9sFTIiCsf4KIfl9q8kpLe7gwOkpX3Hlv7O5m61o7Xh4N0t+HYx74BQc2zF7Tjr QiaLot3/vg5Tl7LaYZVGag60vi+0T/eP351EQt/Bz0CuIqVleh6CmoekxAK0cKaVHYuxGxRx7EfX zs8VR/0yDJIJpgHwpHXWtEn/64r3esfdW05DUlo8aIOK1ZR7z3crB/65oTBys/zBwg7xhjj90SPJ YsN4uV7kyVlvZ0HXnKI7KQ7JoORDw69bW609MSnF6caNAlHiOsYUkpYzXNq0geg/I267jI4yEW/k u5MTFZmeusyrZ0nqvl3r5uflj9LMPv1/q43P48aDCjs9t1uZEkH68PvmSiSX2MJX6/5nXkWChRAr FqUNNpHctoKaiz/TiY+scNNbTT7X78nfaSGTT3NYRmAk8TZYeMMMCy1KJUdQ1ZWUZU/TSkDd52WC In8yhANuNn6wVprFSCpMyoEOS1/j+bi39lPq8AhA5WW/kyJecfTsm+HXpwdazMd1Pb6XP3nguuRv 8aIYo2b/E6DgYuWCoSHuhWB7OdbbNXvse9VV+nvg8HC34cGZoA8gvvUFX3L7OnvsobvVp3vOh0Lt CjlD2fQF8qF+nckD6ovAlLaiWMsZOtqkkmCFEqDSyVGMiIRbVLUZbAEaJJPwaszVwy2SAbggfHAw Ppz8mBfQ2/0qRD8l9uPt/RgrLFllhKWpIqG5eoWNuvo7U3jD7mD+T2phqWsWnKQ8zFbs28sCc63t PVXl2LtVxcuIyhBzojFOHNwTASpid7ovdV90xUjUF2hlZGRk5tppQpSgjdliBGBw+vTqnaU7ZqBO ixLwWbYMwtVYsTebG4siSJqWyWJiLuXqV7tXJMu1qGyZ3ojJla83BtPvy69nwtFr0e4nh/Oawfli 5VTktvB6gDk7lVTdmVVVb33cF/HjKAKxB7+/tizve/e7z3J9jwmuzuapY7P8SrqnGXZfCFC+5RlV VSXNUn7coI+qTq3sgFivVByzDq9VQdgfgYe+KDkQGRy+bWt8uHHx+cx6gBRJxM8vqQxYY+nKZ0cT KnTEsOv9n20mtMV1sa1V+PrPCo8iehJA8vfjusMUMRpppp5liNYhJwLXBz7rbJWgIUho1aPDoJ1H 2cLi6cpiynjUqgKFZJ79fxfp0Zaab+j6Na41me5k/SzZOE0gj+lDog5T4LPTBwjDB71c02XanVyE gSjjQ6QJPMMnBalpWuaSaIkiTh6eCSJIKZUXLKNCtcnetzCkjSLhAZ1cFknpHCeblscx43sq70zK b7UNmTd2SYkrDnbfjRCpwWCGRJ6dKlCDzi3GcCElYgOI4dMkPVJAkEBEkMjVUzlDmnSsFuzySWiQ LOESRpEkS1BHCcvcqIkAEgMjjKc7JnTUOFQ3ZDW2Zs6TlWJlkUxMd06JPSIqGNPKOar1AUeUelmT zWpIoiTzCDq6tOEnVN0FebOGGk6XXXTtxnRBZwznBsT2s6F1qdgpTaq9wTKFXVHLFuSiVYKK5m0T RMg0qwqx2Y73MjtTm7ebsVEPC9ixwT2rQrprX24YHe3tO8EDGonIGxM3OsV1rRtuIvFopm9zlDO0 8zVsCayzO7eGDyz2Zmr2Q+5sB5AvESKspC7GVNiTo3r3Oe+imGdvn5uRwvsv62vtZCj3MnTcop9a 6uMKEERATrz9zu6F4c7T0V50U7HaumrhlLnIyOYKY9q5VuZg/mV6ma7bUlP+XScn/gisxh6KqTLz tO1O1kcrDlXsY7X+hXEvd+gGDwwRCfKGcgCRaFJZEoLiBkZO2uhubhRxUeiaTVKqxdtqGWhSgjcz N0a5gSFxOckCeEGEFiAQgSeOQTm1Epttxm0GalpXbK3Vm4qwRE3Lm4zIpIGUhrTmKotl2n6/b8+V 3irLYwuyESN6acpC1VGC5mjMDL92XGxdFaduNmYmBeXV4cMXyjg1q2e9PRFz0uwZ01wcEwJevk68 iuvSYR3ayVLZ3g3c5mjUteGZmhEWbbm515ggmTuA7MZZIe7RkiOZyI2NctxpRTqpbi6mqjRZoCbd 0EXdJVa1SN0u6kGoZ5R6OcAE5GHeqN7ou2CBLcUEeyttOanR3IbpEW+yztw+rtDtVJTQudBFZ04t ip28cUq2SIKBxGEL7KVQow8NoC1r2EA61bN6DBURVzGRMVQ07UmDFo93vv4J4SFUVSe9vDFPtU3o nhnw/DCjZkZmRcLdMc9FWyL3vRc5MGILqbqRPzkIgEEe8lK0pN5GMgxgLijbm92r7g/W8dnTv2TP SQpHTE5lSJLdFBQMdto9TFWLBYqxfXucnsPQPl6sM/oTNV9mW2kjJwIJiogE0VQe4zHcGS2YtWqT nj2H0I2arzvBg7A2TDm/D7rar+yK0QkdBX8c871Xt4Pe9Fqkw4QXU3UifRCIBBH3yUrSk3kYyDGA uKM+BfmTQsxOP0GRBHDd0XEWGED21OMFhAx7B/ugN8kv0ovt+nyDjdjl3WI3v7/adPhIpfAGi3dm qKiU5o3uq8sPSW7fX1lKzFFlc5eHUd4/cRB75gHnFMcXxgdJEfEMO2sL/t/w/dtBqRn7qfu+6g2Q SERJAEQQ+zv9Fdd27cZfiicIfbQUj4UvZ/gyU0knEVQnUyKA9XUVqAovRUAjAAkeMFV4xdcAsnTF 95EU+TCsOv0oqXYaK83PRQ2EIijykPMYu1vnxsYcobsJZBkR18aeQabEYbscsn7E1F/mtRQRfmtY B7vdT+tBhpJDZkCqwFkUg8hZJJhHcgf37ANlVBYP65V2cRZJAFh86SoKT0ZWBKkCjJIsCH6kkrBQ VhZ+2bsu7+cu/6bf9nSj/6vx2b5Ujl5DpgcquihaX2gVBrl0tRtJ8xV+aCc7r8OvJgMlmfgIcKp3 qiBT+f832VobXLSWjFq3U5i3eviXN8z8iAIpQJ2lWpN7D6qWS9KUmMk+yRmLArQqEUBB1RLbK2t6 oVepQPQyi4yBqnYTZDfobnCP5dwFBMnAAtR1EHbcmjVkcH7MBmDgaZxEqUaJpMo8y27E7VAuECO0 PtINSz83TrsLNGu9a0IhlPbhON9p/Rhs8Dq2npr3Z87jIOtjrJoBH2Pf5xjXC/kZKAKT/KnLtOA0 /T2+4ugn5Kt3iUGZ3UvPGdafG9KbofoB5FNBC8QeHc5Mu5BiWOpN2fB6wFXDZEaiA3Rbl/CPHnoJ jCaclo6OtPzddOnoGBmjIyqn3v87+nmX5nOhmIc0MSfang2HdPKXz4gCB1/yIpJ8oKHvFQWBEZFk WQVZAWCgQFgRQVZAWCiwJZABBBEBGKoqwVGSCiMirEYRYsVRVgosRIpESLIjFGMQYqxYxEZFYqiL IqqpIiKqqKsYqxEUUYqIirERQRQEFYqwWMERFRRURBVFURAFFWDGDFYKKRQVViMYRIIKrFFigxFE YREFBEFFgqILAWAxIoMYKLFgLIqoigsgoKjAEZBiQBRYoRRUZBSAoiCxSQUFRhIpBRQFFYxURQRU EZFWfz9TxPbP/I+mFe3X679yFNoKL08ef9YgiIh43n4fzr+d/6fWGp+J36IxpQaMBkhRTQUtHOVs beToexsq7gRJPbrMwyhO0iAY6Oc/L9JIbHCEUkFkktUZFiqiKoMVBQGJFICEGAsigIigpJUhRkFJ IpFGMIsFFIsVZFFBVIQUWCrBYI/EPZBk+c+YYByf0H2DCBqEGKplNl+Tlwde58pPk9Iq2OND5Mj+ BMV8ykgg+FHAkNaXVclIiqCEtQZ7H0CA8VXbs6aiplyBLUwumK9cmJ87kAg0ez3saenOmMMCyoVS nENFkFOnYMkHJYdlEUlcJEOVZlrrtkjIt01XRfWep3WZ2kKBDkcoGm2WFaFMCblsyQ0FzDTiYbPE bWJWZllhFKnijAo5nIRPUEkqNEPvBkdvve5TE5uvvYwjSEkyOxb0hz1i7y9lHDEw9grh1PoGKiO9 pXmw+mIEQRJRqUiRcB8Jo5VZQUyeMkUqYnOgzddvapWudrruNsZN8PKSthBxFmOLcYk2RCixTkd1 l9OGjRG3kQ4k72eI8BYXJKMggtAGFkU+BGWhhMwCdOSiDVMMNLYLGQgTwkKKdbyVeqSCT028b1BQ rYqYIIIMdF6dytI5BGnSCekMiYVILo1C5lxUHIkKwwtytmY7xTt0rQFglkdUQEDJ2VdbKVekQWdr L+P2D34n92HFRlF4AiUze5fMtxKXuir92Racq/eNVMnFIHBVY6lYZyfiOecP2BjeJmPMQ/ntuwVc L5EGu+MpKYKOQlgjpQGkrloIjW3F8+AEBnkd+OQe6GLyGIMGCHQXMOYvjt0p5dMj8YHqHQOYjndc xPbvzboTSysaVJy7fNFqHWit7KyMAd9cwmekMoo9CQsizaEvTdDBgjlNMiEiLIKFauCyjlVcc02o mZHbVdlg4EFfTcKShElM3VhCZvF0ZMMZm33GUNXCDJu9OX3Zg2ERqbSertKc6vMyIcUMohiuKsWw 9rzd61rVVQpWQDyB3nOfSR6A8w5XATzqj80TC9FHhXXZvkS5ooevbJDlJUKByjEqZJoppEQFZoul SVK7ieGNOmZiw590LDfbZwwbv1ua6NwZKPMImEbexk28hGLyqgUKINB4X75w6ZJ1YfNVxT5YIZG3 NX11wnm6Mu6qzkpkHVIIhonmNRVbFEtCJpwaimr2IEEVSDIV3ZwabNWcyLZGfWQHL1VkB7DmWui1 yTToGoHE5UQRQWycoeEke7Nu/y4NnqnG6gKPCfaZB9iOSRQ0iHUKSzvtjlItI5XnS42OtmJVnjIf jeFT1hhrOYgIxU1y5TaFA1MByLTIKSNniIZZUW9Nkco1SUyQ+QUo2MMSEJBZZ3VdXGzivogzvbzL s8jTXfJ6KYQD2+XjrVkqXZtkt64szKQVB2LnSUylRMYT8yn31x2VWrdjtixEuYFz8xYmmsqeeHTZ cLP2WpWTvV0fSslc4dZ0HTKhDNlVp+TagL5Ws28hGf3t877A+hV3r1iG0KMdC4RdOPF7HCGYJkKj xG2nqSUlNSm9PhHv4GulHXJzzPF290KoBo15UkdNEMnYTJcbMyzM5IJcB0hYSdqrWlumi8KK3WIK hNIrLK4NlB5IccMgiA6acLlGLPWqO0FFqnDC6OiXDPTLVTTE2gtlyZxQSeUU3EYRRzuRHIO1dQW2 A9NMVKipUxLRMGC+alGOiFMMwhKVyFFqTy41gUCNEBmTAOKiS2ZdnqUGsb4UtIR3qDkYJnctLpky 86tMwYzwH7fDy7Xj8fjRBzxNLng8hijxD9YutWeIGyFSjSnC1CyGPY3KnqhhQRQJ1BGCNLMIkG7i NQgsukLIc20lRg40GeLk2gyQ9R2KjiKOkzHHa4gjdISRpqFREm3NQGw2LNY5ybIwzlOUqpuWrBok hAwQJNtNynd6xhEHgnEp2rmzRJnCxF6TTjCGjJsmAuOXBBijkE0RmzRjKSdO7jCSEUYDK4U2nTxp ZkSZEpAkMvY2AaRfkYrWRvbePvRagkew9uXzL4r6xB7KflJkpaDI6roL1F7Ik1orYEkyWlRr1XLg K0zWRIwgHuWIHeRhi87HrgkZxcH4+BEcHYgE8h2rBDm5jjPpGFsUmnfpcoSFgJs+OOHKZMn11bZo MMKEFnaqSYIX4fve3Tb08ejrM+d/qHCwAhyU+YAfgEaVbDFi8htTtAVSg/Xh2iDwPZ1VllSyCn7S 4w8UgrNLIX/aL3YQu3mCh0dr684QPoMHj9Y2BUKC/MPu9g1P1fIK7vvBfvUh5E3gx/Mgwn2fOsSK 4UdyiHE0UUxu/Saw1woQcP5bx1mBTsxUQ/S/oc27BnEofhYpqnUWgegC9mUfZ/AiCDoI/7hbeBAZ EFzUGxOzYT3tr7DsVByJdsDIar7NSbfsxSDbiF6QxDnIKH72EYqMIuMNWktx9JmJmhUPd/oyDb6e 4fuP0l1usegp+aWXLljF6FzyYF6cVnpOIQ6wOGGbIRErUEhjuOESCRo7nkDkTPidzz+lFxEl36g8 vnZ6zYKLTmzCMj+8LB3D/PqPMQ/oCEIQlNfWfacTcn3pRS4gQ6Sh2FrvSw+Bp0BCECBAEnj+zkZ+ hN0OcOsfGw8fP1YCw00eQq0iM/qJUzS71ep7C1kKqIbkKHwasX7UPoggVzNEKz7Q/ISE6gHES8kf bzFUtE+IrKsf8TM7TtNu0QKxJYib9nzEC8Y1Tkp8+8PrvpWuIi2j2GnssOvXvDsDgQD7Dw4hXsPB EEwMBALaDwNHVz+fGzUOyS8kAQMKllbOfS6lN3IH7sufHgDHZlDfQa9+nK5x4eP/KpOY/p5Y8eTJ vNAgYj3tWPZZ8hwx5atIPj13Q/k/ud/9vRuevCcv0K976TNkYVVcMBO4pLwNo3UDmNKBCEhIGr8D 5HnY2/8vqTLfhIwgGA5ZTaEN5J5b3ULmLSztxBk8zwbipLrt/9HWIbD83zJRdIdhT0dTqyg482YM 53J4HMMf7e2BVVRUVVRUVUREoLJ4utKq6tVVEV0W6aNttugzMMgS0LLKAWRbISRCJB8SChTeZMpk ynXlTGDEgZJ0B+3CheQ/uMD+tNYcPniKmalPc0gNCDJQSSh8ykNFhZ+2l9hYdiu8O8OsJiTbd5jm MtrcPnCQY56zgcCn4/jqGvE6k9MYWajqchgNJngcXlaluwfsP4jp/isOH2QMGF4B/zaNUEDSP2Aq UwkFogt+zvj+nkx2r5sfylO4pqL+x9buVmJ6mJmGO9U9hA7lVKDGxboqM8EKeSq+XLCKUtIMf4DQ eziqpUidkNsH9EnglGHJW+gSYqSqQdynMXTWf5/xJUUmbTFS0vKKUOX3AgWCPkfFUcKimBi6mNRi QLaJJHdpKfzwoW+Sbk/y4b9hVPkrGCjKfOy9zH0Vg/X5IgyUi5YGG1fzErYS0czDorwZVpt9+Mv/ no5cEjKQPgfs/bkuyQu2Fa8SDl3Ni7o+j5Mzw79XKvRUpgokVHKNSmuM3gQSTe9JJs4Zfw04KQ9o m4fxBKk9f2ed9MEDdAURUmVOh4iDy2biIMCwIDUP4ORyR690obwD5u85KNtvs09r4pfq6TV2OKrv GEIF6oi+8AHsXkEx+5Vd0vtQDCpEEzXdwMneXjy2KIkFFTJ9C1D5pHF5QprLqqSJeTx0vzrWYI6y XQLsmI9hjP2ne0R9ixBU9wfWDiq8LELTPnc8+/gSdeuGfhtMe0pLGqsrNLVznr0CfaHus2f9sm95 QDl63D00F+op6u7yW6+X1rmtiV0pf+4QD1T7EKyrWqx9ONWbOlZDfs8DtXWpPSGL4yv3UiFXTus9 dHEDpFQIfDEws36veFLCjyGogwqwsZPh/qPJZZUWRuoH8V1G882gXUhWKL3Y3OLhQjxBHFg+Fn3W ch91MrHZffrnCd6ZQeJMqM3PNHM7xdCyQn3B4KoofVB9++mpjriX3oPm/jEcRZ8RPi82pjFBioYV RPrKA81cti2qVj2RV8xGob6TkQy9IzD8HZ9RDnMI7kkUYoHH/1j49YHGC99JRSiaR0xNg/2jdEX7 BOS8KTTAoqKopwhWX61Sv6xXqkqlv9y0OtPqjuiYACthJ2dbtKd8kCvcYXvlFzCin8PuD6gTyOnd 6uscKgk+auPh9CuDusJz5polFCkBmTQxUtZXz+/S4AQBzeGmsDBQ4qN7D4WPk8m99C03eFOd9Eke ru0V1sDb/h+VSFN6SharhqZUUBfPCU3anr/Kp+4KkOIx1ah+/f0MWW1QjTkv9JVyumWRQRAO0Xvz U/XESIGO1QRLdJfAJPMseSqv6nLsfuI6Yhlgk02jo9z53RrV6z48IYwGIjIyX+sK3K0akd1yoL7g qI0oqJa4v61wvJCLEUsYTAXCUe/9pg1Mu3eZmA9REVeyLuAq1Iw2KPWkSDPuIewTX5yT1aiPSyuR lA2ZiEJd/Wk1Va1R8/l+n9oEyCpIq36u6biMk0lucPMVUdAHAVj8ZxhTNoLs6EGAQ73c5ouoOIKJ 51EEs+32E7eew8a900hQOK6E7QqiOUoXeLlkgUiL8mUN5VUHIULQoQmHflCmmy2u4mUq9++6rg/S +548UXxW94yV0QwSihHKOKtpfz8KYSrVMBL3/YxEsqYiJ9bIF4XpzR0lKiqHej3n3NXNh6jMMrmr kQUcPIKbcFDN4jQ9U0TwhzCkQhN6rohdMsLWEnPcoGWFt0JFyassoJhAbVHrtgVO2Yqslq83RVez JFpxCY/qIV+1x8fsStb1c0SuSn2iHnB3nIX1VEko5j+xEw5ntINavMutEVT0Mwe4TMgmpkJRSsRV Mjta6yD2+sc34qiqTfTBEGQlTkoPFHA3ibu9XjbDDiJccjXSJRFUMgMwvcdmsf0X7xx2X1GmMlHl 1/Y0sukCkTAU+tliVp3cqffXNBHqypximgQdLmuURhLABANG1safIgxsOeTTE/ufmmXvYvT5kBYF +ioyosmP0qz5YRknkSW4uavjFDaJuSuuIv4P6uCZ55wL5g39Ppi+BcNBBoavnEw5FgiXAPKhm+YJ A9TyhQODhHP3A5igGEkTIKXLfyPg8iNCaEK/2eC6Ge8bMre3vH9ZsZT+4erf6T5tNWqzKrBV/6s9 OO/7bpwJHuqSRPfz8xOb9l7qj2FUBKiNTqFGAODZZQdExdAvEkPqal/DSAIGc2HrM1shqeNTOyk3 Qz6JlmY0FKmipN6QkCs2f6Exn946/Ox0HhR1RT8GHqnLQPsEG/VhP9cIjoolOC1BDBO6dvqDVmuo mH9brcS86ihMqS9xO8v4u0ULYTRknSlEn9ZsonC1Kaapbyn8QeSjrTuorMYhC+UCFjDdTZ1mpOJc irQRBBDklMahJD0il9RG3MzokS7ZI8uXNlUwSUCmrwg8xa4dAN1ndVX6KBSwyEYinBZoVZUDpQxv fwRSFjNKn5ucZ6RsWsUT9RyLpRXjEWkV+mNK0XYy+/8CVSyqQOCaJC0nH8InYFFm0i9aV+vcwLBs air/LNKmXp86Z9xrheGY1s9MztvuXVHJotrRTIW4ySyoZNOvQ+PmXoSwaOy8+NUkvpdRiXZrTQuW 1AIpHGUSyA3adsAVQy+FfaI5h7fmnkF2cJJOB5xyfwPCEdHaS0UXQsllLHFJR+qmCWTL+xd3KYvy k+9V5DVTRKTEp+SlhShgOQeVgxAVJH6R44iKM5UXhp3Zp7t37j0zO1meMhRxmSgdYD/SxOsiaclN 4V502ohdKCntUTqO2hQ4669DoEynp0u9+0zd3Y6oACBnszYiHicPiEE9OGKJIXqbp1phWkfRm4xg +ZCchVb4fgBQUFSt1l517XVFnGNXrS0BUjj8hxfBLFR04DA5HqjzF81ZBwh+4N9rpnYqbWvHVr4b wwwWMWV0ZKyM5pSsFoJxD/GhQE7GtTZIRXGxhpyBiWsbtyoTKVpKTJ+0mKTCA55lpk5XBrWwT/Sa SNmSdIqw1KP5msTkaWN4zQErO7MbxgxlvwVleY1PT8rxxL5azFndf82OUM3v6J1Gne9SWKy3gfXX +pgxi5jRSSQm5CXEcaiyhXMt5c0SvWd93hmyNC5pO1YsM8Qi2l3CTk2Fqp042VZYresF16EW+NH7 G1/0DWk1hdi0Xrtji893tfLd5/d+MwhmC6ErjS39sBHqLCfotOcwpa2kxMaopeUDKuy8qXj1FUJw Vc1lMuhi5YMd+JHlBn9I/t6H0/UqzR2EsiI56UfAe6o7sEyykpw4lk4E5ztKmGukhWimM/0j+9hk /DN5b3zP+8+sffma9Iw13O6mP4XyJr0on1wZdVmj/VMCZHhw4RSoWUkGleo7RWeqDIomwp1rGred S0Y+/2qtm1E5tuIoV5prnwCDjYUEVF9gn1UHs0rNDgUnAtZCwlWOOURgcSdlwYJpV9KGQeRM6PgW HPiSSTLxPO2u9O1cV6Jqk8G7KJpJ9aU2MkBDEk+DJemiVVFkHak5/utrkfH21UPEpm59g6ComJzm 4lCl2Q59OTsieZxtNE234s1uSlMPjBOONPTDyJnRyP6k6Dn0TEcczQDgUAdo0AwMYh5diVfPs7En JAhNRs/+n2ofoUgk/wtAqrWhJOj8k+vHbmz8rqUEkXR+oGAPr/J+n+mv5v4/5BMD4R8KHuVGJq2C +PHlZUkuDbolJpUKr9Sms0rat0EuO7NzE3W5uLUNt1YpVFRmVexcN2kIloXNyYmgLTkTEM1kZVCB h2jcCESZfJEZV7cRKq1HGjANRDOh7zapIEGFsVLqApDcWzWp3FJ1Dmgs4aJ1Wqw7ELFFerv/fZ9e JY13v/I9yLCrFpIQCQ8C0uDYfoPW6nmXFD4FxgdZ+wD2roeC4zaf8Sepy3dm5/skqP1K5Or15brG Js3tIwelZmeoyfqLONL2WAVolA/dEYO0JTD/WYCcUFEsO6xmP3JTO/if1uE6urqNpkB3gkOznEKB TGkmMixS6NQZIX32BN4qQ1JsxVH8zViwWLbZFGIpESlottVtlioxFFUYgYys9sHJPhfLyG0S0bYj Z+UhiEIPDCHyyJYRhBD3+UH4bJuGiLOewImSIAmCnAXn1NnhgyQcRRCZ44bRaUQVJqqNwha4jaSC XvpcoRrQa5X0N8IaEOU/D8hH63xAM/cmVHgUhfhqYukjQhhzMMLs5q3avnTbzL3iG2u2u7nN6ldz vuOP2EgDw/z6Jtw3oVlN2pIPmt7oPi3Ru+jg6cZTedc6IS7+6cGh4cKqn4UtNWH4VtQvj2OpKJux anJblVl8JMuvOKyhSeEquwjivdwjnK6O0NrG7r734wns/eRVDRxcue9+MMp2RxatiT59LGo/Lj/v 1O93yvw8vwXCld4islvWI8mz4aGkVwjyp5QjPiyUYU26FsKOXBp0NG1ziV0exzPXZ0Xv4V1P07ny 1h0spwrZYGbcrqqI5sr469G58ZcV8KoLLW949Yqd/73+J59/wmSTEYm62rcn9KTCy0rQ3jDy1jUN Stp81l5zvemMV0+L13gzOatLdaSlwqzja5uL45rDyxhiySzQ0tC/NtSFkz0dpMbc2s3bD1dc0biz XbQuFvm8r4td583er6radllumHo1JmNRO+L4bVuLiKrtVlqbaJO1tw2Nzvemqj8yYtWttVxh7KtK 4hf2EkNPk+Z+z6wqVo4u7L5w8v14uHnZ/Efr/Gffdnyk+4UQD9v+gU7NvL16d3r5+zt8oa92FJ7r PKXP48n8/H6vj8Cx7fDTpH460/DlHOdPBfd6S5P1j8fqY6cKsldBnH95/afBBPIFDzVUVgZlRIlC QgjCJEiwBBiySAh/YskowCTEIBWECKCoQYSKP9VCWMgAiQCEQYEgiQMtm0JCEsm0ESCAwFBVWLFB GKqqoqirFFFUUiixRRRRRRRRYsUVQWKKKLFFWD8WM/0Cyf54DAmGFiWKMQpaGiQawFn9xgMRK/Sw oIGKI/22wSgH5prQ9YwfEIPYEHYHwMX+kTAkimMIEn+qiYf4z+Qacvf/GU/H3J+SiHygjTsMZie8 mz9z8TA/h9rd6ezTV/T6U7e0PAmdx6T0GUpKiRBRQWQYIrJJGQYrBytFdYWt6K6a56j/HE6YgcIm aGUIoPYJEPCePEC6U3UPijaoh+uBr6Z/2VL141atlHau1rD4qVHwZypkYt+GjqlP+MVKV/1w/tH/ Z30ye0Xp3M5fwV+A+WmEiPhXB/nK+XaG6OlLvA5YiX7ol0kTX9FQlnu3w3UlvfxTrVodq2rUM385 j1xyM9KUJVtuK2XBTkVwgdmdkd5ATphhgF1BoebAwiJYqDQ9zCRT+Ig784jxyJ/VKVX2QklZWfVd BOIaBkd4esLP1yQkhaQpY/r9npxUo+9QmKh6w1JTfZ0qudqwevN2nSLadi3lvW15EM1PxUfsUnU0 TguySp0oOfWFFwMPgR1MXJm11rX41e4in6YX358Bn+GCmQjQJaoy20g3+Cgweg3D6qUoelyoFyqu /xY4c0fSEe8/2YAvxwM2Kjh5/W4sTPMEDfOxOqQie+vblegreHIPrXohbpLbtoxo0bSMYfW/3fMv bT93trxsfJjRl5RUeS0ee81giWH6qXLnXXWtEUHKUx/RU/5MR+Z3Fd37bD2vX324dC3D/QIBjs/v F/NcWWBL9ZuKqir9SIBA7zFMHernVrgREIaQWRuuXCH+38Tn/8Dn58BN5u7dOWrhH+j4f78dzZ9P lb2++IPUgu9qlFKdI6lQoGW4QIakX7FdHWWc5SJdzoc2IGOYyCffF+ktg5TThLTH/Lcev9lHtnQT qHgV9uWwSwbM90rHGYx0zqg+oV0K+umRRPo3KTtzQUkJTLuC6/jdBldBPuU/L3sTXJuhJHfXMdTU 4nYHcgoKdQg5Z4HB1KCrmwRFUHETxD5kJkTkfefkuK4qmuLHry8VSpcMLMyc5A5UZ2074rxKj+iu 6aru8eQhBVe9VfFO/i7cay0csx1F32ZRnJhrvDF7w0F0tZNBfw3v6V3xCJFvQngq99DWVC5OUNHO ri6pD7W9KIIzpY3+katrRqCUItKwkH9ZibCpFui2LV9QZiqqvXgzlVQzXJFiObGEsIrEGZq2xc5H hryRuqPkPHk7Pc8P7AO9hQQWIJ4X7Ew0AMmFLJ3dYssgev92LhDTpf3aRgaEwsfqXXjcxlsKUqof WUJAjr/D8pYUn54JaE0nQU/22Uu6k/Srpb8Eg8HHkegHnMJTLEtCIJBClgacIQB1wcBQp8vd8flb 8Nv2ynX8e72/P1ltLqHjX316nHwwCB6D6n0LpCYvv+XVp8dujJlg6VNZHs4/jj9imybZr6tIwMDJ yMkSwoyRA6COvFBVU2ejiilBSlq5YJLcw42F0AC8iuXzGgp6ft/LbsSfbt9iN94z0wxE0zdxHidX 1nWNongbloBXBDohND6ffE6nsOCW0dTN6P9DMjdXuL4D/wLCmRQgoDkFO2kpePF+j0KKF2oWjMfR 6vPEmTcircR57TnkhJOaUvhkchS93o3r6ftjGzS6TAv7HgKJRM/U0UF4jCfZ6f6hz6cFRTApYf+X J/s+lpSvjRvW12QlWWInVER5V7II70pRZMT+CDzR6zzZZ6qLNH1f77+b/Wew+p4h9BIT+8pAgsBh QCERQkFJqCUIRAgfDB7mm8yifRRyZBDODoDT59eDXug793d/LerlZWZiFhGMfz+b7OciJIhQWW1J WipIhZTjyZs2R/Oga5AhuqJrc2FKm6cjmviEAPEgQAgLETMJAKCkQipoFir1qeer0WN8PTIdDrUq onLsuuRa/fG4qRHNYlopSTkqDzF5LwaDCQXLqPgy+hGYjzLsW9GD5jWTFgnqTdKS83P4PbGZgKVO CyyilFEYkqT+RUks/3myz4sIBcolS8tOEsLSQ+CUJEjoUBDTwdvjEnj5SSpIvDkWgJvVN+lS/atR N+AlwGcsVOQcy7FTIqdVuRRGZlydmXFWla5VwXBXYD2qOZbBIMnGYxcMmmuCrcG9VKMP22cdbcsn S6LRSA8NEKyCUBRDj+SmVRE7GQFK+CHDgx0MC0SrrQmJivmXFKRQcWaos0VHBImpUMsGkiamjCJr S81mKWitIYyM0ZPkPceMd/k9MtXsiVOr4L2zexpNDa7Tj3y0J0ibAPQ43phMN/nZ7JwGujp4CqK9 T43c/DyPIpCdp4GuR7zAzdgQxqo5dwnSuDJs3rVxQGRd6BbnBypy6Ao0lpYnJ6aKZ7I6IcpEyRjK F5OyTTegIUDKuVsCxL1VIhgCIUdWhaDCybti/HOITbKRwSRdtGS3fHKLGCOKPGQsjCb6Sc5bnHOO OfGV3pBskGCTgnVshrI3gdR0sChzlG4aKkNCLSSmDgnOQqRumEUXa5FuZJNZqk0iYJHO7jbXhIWz y2skkswTi4dEURlEwqxTS5QDFgRMkAiKFLVM9ovEUAvDQUpiEpInO3fIxuuCYW5qWF4ljRA5aG8N TEjnrJOkmRgd6ZJMNu7dOd9DdGCGY3iaxM+WrVmm0tUqpSptrD4pB4NeotWalEcKqOTGhqIjdi1F eGIMCmM2onCw1WiYmo0uDSm9quwyiZwy5sdiNh1aB6DxZQmU0nPwR3ScQ4l0Z9JNEdJeEnn6Wcby YGJdOLpok2R4yRSYCpGbmmIdi0Gc1SFmsPRDVCyNSVGWgJYywUb36vdbx4NvFmGCKEQoFsM2ckOy jpHj2RKT2tJ0Xf6VJlJSOcFVBrby6wguKtiTkpb5eDVr/LTu+q/71iugifB7TtL9hpLds27mqh5a +T7Y/P+KfqzQYKe5RzUZQY3j9ive1dFr/oI7uiJKb+a0qad3s0lhPPNro/cAffeaeFdUNb/SRi08 H7Nf12iSSpXf1YKmpfoWdGCas5D6yqnipVSPtaLXSt+cO4Ia+fmzwRDbbr6Pffu6c2GJEIRhKiT5 NOE4yjGORhvw1V4z97miBdr08IgJg6bnUUdlaBLq05vEO3VOq0wYKwK31x1vxvoAcR/huGjyPiKG AXiL5msW5Awik7QMGNG3qhPdPeUqntlSxoWFSrVde92HqUrfW1VbPG5ilDAxPvLsmjRojwgfjYIX p+5N/d+uPutqYglSLRIINzCPGDed87fcwvhhLdZhhV85NQ0MYVDVJoLIzhNAHEk5kodA0Tjl1eN+ muXjxDYVVEYgiIAooxk3ZJRgWECIMBEFkkRIIUqMZLZABkBhbAoLJQBAglJJZArKDGESSKKQEiKM BRgKUEYCjRBgLBCKRFohRUgBRVopAaIwQEgrECIUYtEGiEUirEpGRVRYiFgLESzQSTykIbhPw0B6 g+Xv5PpzweTU8nXNmk809PbL9kaysDx9ae5BKV8Rx+pmCYlSRPzj2X2SPZO/tAqjFA9V118ZNV5b tJG8Uxkmhuam0NGgyN43WN0ODoJp3IljsWWeWgkOm3Pbu2CgGuuYrCpSBGldti4YJbBJfeFUUPsI IC7kFQ1go3YmkolmuoA0HDmOh2N/9u0onuBOIc02D0Bmh+JpdnkKsvoMTJDTqiqyiqSReS8TKMy8 ZyaQWNDJhfOs8toRrtJITk2JAzdHLHHInGNDiRhYakpNQtGAYll8McbVjEyzTFI/z/yI91QksVGQ PKT+eH8P3QK4W0qf90f8J+VIG0YwUUWNsP1y+v/q//P+ihU/pKD6eqev4SUrpHGAIHl+9/jD+3ht Mny+f4BbZbS1aFtC2wtW20AtW2rbaBbZJaq2FttttLb8jMxmYZmqe752ufb4S9w++XZ390/qo/t8 LJX32jMwzMMzI96rrWraFtLbattpathbQtoW2FttsLbbZAtststs+1P3DrVt2/s6nGHAb77BbZJb QmTbWtS2wgW22khbbaW0ltktttttu+nW2ef7H00rtsnge0JgdlfiEhHUUFUQ9qxWx9SR+W7MzMzM 5EKZUEE0KxwEFBVQUrWEkAZ1Numdtsvdiq6/e4WXVKv2/KDM2D1X82KqLYNC373yto/thDaMYxiN VC2iULbVW2yzLlLK1n4SqpsYsfvnfufXHw+7uCHB9exMfWTZNtJ9UQklX2vfWdayd3WTv69/Ds/m YzWq4n8z8nr67lbu/3jOrszvV4RVOFBQekOp8BGHp78tsMD2CcMPLmEmUs/ofpC0wGLFQ7cnpoVE NwITUflr0V21t4lfzyecH4DEUroUWEGLEX+BDRdZhV5rcEZEoJjG5g482btYDZZStuoosK4UDSIo XMbOtI8CQznOMIAnhAuryDGBUTAJ0CbGhbsQGCYshKcyoQlCQRFfjkjnODnOTkhM2YEDGBu1hUIb m1hskxgYypwzlCpwkr14pIcjCboac1TozlgcoSbIFVkOGBshKwDqyTdDoim6BMiambxASRyTzCBB ABIo53HwQRBAcQ4B1Q26UnLyybodWFEM26YQ0xSApG3ZhWKBxGBwgXKEqKBwyb80CHRJWKY5qgYk nLCYyGrSpFMcZugThIbpRnRIbdLDl4ToMkrwm6FSGMIoBjKwWcoTGG6BskNk6MDhk2TZDZDOemHL JDdkOqByhwzSSBWV2ayGJygVIcoHLJy3eysnQUldkqspMIXUEZbAo/oZBWxiz1tXBjFYezbnTCQD jjVWC2yo1qIKO/1fP0Owb+fS/B2mTHZfb/k/t0lQwiBRI/yxLGpK2KV0Jah80rhOycFjnJ0WYpMz tYkxF7WUtUuXhqTgkDr1PDr4tA1I2OOCIKoEgb9UOVCY0dzyMNjtwl2ZprdZto2HaQNlylVpFw0k iFTSNwha0hN/6Zap+/IW1mG+AZFRGguGJGqiS6ttnrMh6jCXEOE5MPCyOTrhQDuKSC9csKhYAhDy OLJncgUgyAsIgcsoZoxjOStiBVUWCEAL4hVYtRIQgK1iSRZQS8Ftmsq22OF5YKqEiiSVKKki1QIT FFSIihF3euSLRCRUiolVIitFpg3GFLS2xwOEyOXK4Z5vExwviwcGWiknPc3VziqKLKWsV2cUwqAm ZUY3vKYCbnHjycnMpsbn1/vIHN7JFeEZ7TwFwE+Fj3D3wMmolPPSkQsfLtarpeM8MjR6UlVvrUPm taQJQqJERL1VHGWWKiOFCwXJB04cCC2oGqhfjgheGhdy0ZNwtrImebKxLGEiFdpiRMUnsZViPWZ2 pbVNUPThWl2EDAyCAne0kbEQJzYmf7HzQ5FUEoP2iCFTZfffZWwuXmWhBJX1SYdn06LbUlc7g6hk W92mIIqHAsZSpnZd24C6Kjmixi3ZU8FLsXMkyghoGMGu7F92PAZMoJdKLNcAE1crKQ3G00YUVoec 3eSu+AShQREoVRIrWoEkCEhKhMMdMqEY5amDFrphXklpozTCCrSRyZsJNQ1kUkzRdCZzDFTFhbcv k3Z6Xub42Uh5p0XALAyyHYRESdihowUMmanQuYT9MkrP1YwKhCiY6rF8yygkF0hA93iheIPtywet TCSwzk7SbMyTQEpM5OSUEJKD/PzIEgglsWSIm2Gl+iXqTm44jDgi7ubCzd1Y5L/EiB86S4hLT3qK kIBvV3lRBHMuJtEuULkA9/ubPKk0U6HNkhxjE0uqBAhg0kQ28m2lmzVoTT4MMZklSYsWUma5McWh UY1KY76qZxiUESrArUhIhXxewWQgAmWEqgFZTINOYmIwyiG1BLVVrWEcyRnLJRWsVci6AMnBRoNu Nim+GWkvODpMzZRejVInLWVwXv9tmKXY3k4OVXKwb5yCtgR652DnRIbBwXHqx2QYmaFPdLlDo/UE +uNcXtvVkThMZEg48pE0eGI3N4eKEIJMECoMoMdWmBOSGd4LO28pqxrGJoMyLRMyWYs2EtMGUyJh cklDFg2hjqaXRRLxNIWko7HKzuxbGvFIpGpZwmx0du2eWlmMcoN12LUR/sRm6K3cJxvK4Zmy9okw nfvvjVbFV0907OxTsTofhU/OlhQTotUmOVYMlDh0ZRA3yWeQuWcpHJEmibsYeQiCSQTFhTCIgzpC mbZThwymbGSZlM2dG+ENkphjGSc7yEkUcHS5IojokxRH2VuPO97FywhlJQKKREgK1FIhFF8LGThm QrFr2vUuXNmjZU4aJim6bowcIJEFCeCtc2alT4+v+P9g6NrfPNtEJdgV0nNpEEaGlKlGKeIlGcnC IFIi4CCOgtotrcJaVswFrhVmdbqog1BLhug2A3LetpCxNBiwo1VBxiRHawXza4yaxUFY0klYbXxS GBwZkygmTKB2PYELHgNZUEUCoPec60qbCey7FEsM9VFrSCDWSbFcHomWMscMFUoUKEo4EOwPCOjv vL9e3BaDibbfoFUYtu/DlCKFu8G2k34x2632zCnUWQ36PUA0QIeRGTUYCJhFcZRzl9whVHDFwqkx 2URHBkpIKCgSY0ErTO8IMjCoVaE1RW7S0CSlRE0UjLotGJlldIRkKIKoiJjNULDlUqsEI4Bqur5n gWomiRdzbZvBK7pvdKt9vh8kiVLrtC+Opdl9GtaK9EjZUYC8ixgV8yFg4dMSDrqyMuoIzaIhZCFy lGWZVRwkUuIAN6xBsSINAgTg1LuhJ1EgoG5vYTYuTygTkpDOkuBe7dktIypvlpUi0jbJbewdnCOG xUkpRp0BkQLnffB9IlgtatkRBBFGH8KDFPGnZiRZMYxaDhwsWMDHA8KinLHdLnQhBRDAahRaxRAy mRpZidBCoLKUUbYAhbAWqre32lqKBpC+hcf6utkcA4Ggf+7n9Z9B6jXriMc9DGiy1GLVF6cmjkHw OdikxRqkECns0aGKE6jnry4xgcscqVNli41TjUMEjJMgA4ZGyUJMPSYlyUFDYpQpwyVM3PjvZPpi Z2WNC4Kyg2bMS4ZCnDWCxSjnZk6qdXRf2J2fnGVFnB0ZMadnBk7VnQp6NHH++k9+7yNlj2EBolIp S9CmOikHscmdL1gzoY6Yd2qZ5WoyUING4INmzAx/ETCcF9pPZj0xKpoRi5QwWLF/ihjghns7NYPC 2y5kwaNF2KEmKiEzZxytS+yhMfEpmC5hpnIOOVIWrM6jOrIyoimioSRNGNHKyLF+GZsnnRnZu5My 56ryxsRALL0IgGuRmTZnEupRShv9x1SXYV8JSWQXmb2KOSN+C5gc3Y5Bk77zbLF8FzhgmCmYK9ig dUIOjhM+6IlMXa7DJhpvi1Vg4GNjF0/JNIftfm6Qz+Dl4ArtNPyHffZd5iDHi6simziYXEU0FV4H qE3+4vamxS8ejdnNYBrHwQ8VqfIG0e4NXyE1XA7DT4/2SwOhcB7BNx0Z/DB1p+KqB+fnN9okyQ2+ z+Ls3D+L20PGPnFJBEWG2Hv45054a527EOiQO0iIpEIUYTJgULQ74fsP6pAiIByTCWo35dZcdc8Z HmUWjxCvGp8o9lZeLObd+e8EmeEc4CK6Zb2wIzY7fovlbkzGLlWtYiLEusLFGbxsjK9P7hGgWSua CAyJ6gjwkZo3zy90YJtdtIq1V8WnkECJXOIoUV2vBiSTssn4C3UTQKioiCy/9wyIG3xW2leaAgZL siNTThWVXQrNjaqoKoErMgUDhREnnLtSeg3iAZo8GnS8Q6eaViFEncU4Ys1dAcBqXWqSLJBjqRGQ uQOoRCEk6qFW4zt7Iwg6ERBUlHiIggI84yLqkehddKQdsyHCYwFzmmmVOOOmTdMSZbum2/GQm6Kb WkqaQDSbdOc5ZN9qXOuTlnXjWE5eE5YbMDdFel6MrOiGzAwogEy1J4MxR1cGHgRo1SKGGIo8BIN3 DLfKWBt30WHWnzAZSCkDTCT9YIKGZ7NmtbHgbd6tt6VCrPX2JCCogJO1pX+t8VbvIvyXzJourgPT VpBD+c31H0QsB1a1Qbdon+SCfSMoJBP6mWArx5QyGQUpcDXvMjJZZ/LE8jtbp4riPKz0OJbGTFFr RNgqD9BIsmxYZrCTYmBdSS7yXcIwtFyKTEqS5PA4NmmWOek8GuNs4jL/vkw7nXLgMrrVTMmRWjFq rQkTHRxZT/1BEAl2IjCFskZm08zHqpwjDHbhlJPOr1JMjMwiXxqRExU4pVCkFiwUuDEIURVrEVS6 ImWKKCF68vdgQLiy+SQyS9kkTUpc/THHlJMpcX3rhyjkbdjHOlVNStLwWcLHYhL4hj1ZYOHDDaSI mu1oeAomvDZ4fEyaaALtYuybWMEOH5ggdEgKAnfaCTktlTilFE7OzZ6hJCxjQquSWh4NfpJTkKeh ya6ov4gFMMJ+ZDcedid0LmhnFxcp+/7Eg+HzZcFOrBXE1dlursY9iQeLwcgbw9cWfVD0ntdeu15G cpWHXM7+Lc223ybl5gTkqDamDMt4t+G0lpgi0Ybri0LC9Y8eAvF2ieLNrpHLNywizUtk7HGO5juj ZFY+prOZctoqBtCTyQESwhwYQLinsmxDE8iUi/XqsXpo+Gv3jii3FlS1vMLSPPw/D2eYl4NJ0dzg haolrTlIWRiTLta6zDm6ROTgym1mFoIMhhcZRRrZ3eCXgTLCCWA2oiSRZDjxlonGkbbZQa3Xx4SW txWiyovQrIZDwv24mhZqKVIPD1iab4VSoBbBwERJUdaTGMrTNz4AflSqelIPT5u1rInM7M+BA1S4 w1cNPQ3QqHFJJPaGqGKi5klNaGEtUVdqAyrPLfXa9LO/1qQCD5Ucyn96YEgDQI9XpsZ5GCixJKcY jfrlhHPhN40xuY2m5rbt7WnomrHryibM2aJMTaRGy1Sa+nsfOBJJO08XJGAwIUSce0Q4gGxhBkRD uGJN05ChjscEwlRDQ6bqWNAi26tLZiJkFWOVEwRsD6Eu6dvlEVVf3hyuruylBFBYU46MqSdW/c7G iyc12bSrFYSFlSJaKiclSxDrB93daKlLMmYRGQFVDxU34XNFj8/viJF8ujJPpL6hvx+Px32e/Dfn u7PrUizXjv6PbuSZ9lDrdkGM3+kWW2CHaVXXVXM5nmi65fe6T1pdZR2e+2Myvan2rgGNnexHvnUr 9lAjz3Kp9pPfcFEj3jWYldjb0tq09SnEOvKF6c0YJyXenJwuMcvy2bYZ3tI3edWidM4tjeaU3FJb pjeYpTGtVmpfbqtZ2UzrOzWr1m9G1emqND5nLE1u+JS3Sm7kLTF8Wti73s873vSxuZJ7VnzVDbtV 1acO7VqIgGcnnxxmlkgsURuVNGj9EPif0BVEE24Xn7cmqXWS9rlQ1+jbhqUu8XiMRNlb80XEs3hC Cwg99CqLNUPLNdMJnhJZyibpFmVUVikmdtjrk7mUtMco1bY7YYMaQrFikaou4y2PNh2Kxudz9JJ1 JQEuIEk+Ya5YugQigviImsj35inKMk5ICVR0QHwrqly1x2QGvwhi56PMrKohNtoxs2IYTaMCTZB5 lbSsQUsiBhWGYZ/JTgUkKS8OuGSoTVErWrX4V11/kiEyhZEC/NIICONyKCQUt7TAtovMCKqpkXDi RHApMyzE9wgpEsHrTYVd8xAS8wN7HEcmNleoOUS8XRbBx6lSXViTbstrLdlXF0L5AFJJhvpVBARh REd2M2hUmFcEhktfKuZJCbdd5l0TKa7NdBhdi2ak+FCQIFzSjLNKiuiDTpHRU/R5JIjhtgtqmFrv uE3WZ1tf4y+iHNFtF3BHPAfFyZ8KQkqzuOh8ntnmwTUCUjliclqykj6+wRAO8RAOVxcRu0TUxxq2 CREVHlBo0h9w6JxXJCkKg3tkYbDwsIsws9SMx7ZBGiZQMCDl0vNA89C40xepGmeRqUk/PoyBpBOH xKw9Dbq3cqceVsJMLLSF1tuiP0vlWcFc1aFYNsrhk5OodVOqWROxZq4iMyrN0mS4IDogQUFkyCZO ZyiDFaS3prgzYmKIINkxMjFRkRJVFvz3MP8rHyPdEr46HfjDCikvdYpDJg/ggmG4jBVvZTSalkSw ebEjJ5eQzKcqSsoUvIulIMUE/k5HWnEr26h3CKQ+h06T5nDCAQ5PyvCRhuKQtRODF0QCBp7PRQkn KCIgTYX9qkg0HJdSkKqh2KgWQkAU00KY0DmbkzhGFUhk7mMhApjthhexaYGPmOqkLDCcVMUNkyEK 1a9ryNkU3Qwp6ImTcPZ7+BjhCc39OF5WVGn96IJfiGRqWFZWV9lEUHJcubKWwa1VU0e7yIFbqmod BGQEWqH0Aq7JKdCyUGlVlK9vSHtvdIZbybau4TbIQtPI7EOTJF38zrtEoQNg+lEmIeMnBST/QfYq QP2Bwgnej9Bc4b2aCbp8DFVJCwiIxSiwm/qwhs70OUCqsljAt99Tmq09HQ7GCo04RQmyqExhje/p dU0VE3RXZmNd5UmOGzsB+xF5SONTSMHV6Gcx5M7PdeDdTGdhoUUhke+8qQ6pIGu0IrlKjYrd24u7 Qw2exTVJIx7bScVMFRzz45suJlEUUSukRjKoogOlYW6fRTikqse5GT6JIoE20MhcVOjRbv4LlU5y 2EA6On+qp5QxcvpuwL3Oi+O6yG4LbalNAiItlDrKCKV66JVVLFubPndKKE5+PMOjJQhRaXmPDqhH UCN3kkHab1JmDjYRF+LYXDy0yUmNeOMxxDPWRWF9A+fiVheajH1ghllAYncyqqvvbaOiUveLF0tZ Soer20vpnanXpkXRttJ4wbatrba1uxWYxNSoXX62twVBY2WYxt80bSTREMvqCaIjD/EbwRoAZ079 J4zaO3c+g9xDcfmw6M5FGXytfYewwiIc3Waoh3t0kZQbsMjUQVZzyFTZDlBes4aMfTJETpfAzX0r tcWpkG2jtarWcvJ+HnZlMm7nZccyfuCCJETMn8TQMOu7iaX17fVRyttooF4IWQoKBI+a4A3HeSVS sRMbCLcp92Skw0Ux+P0mjIhvtLcC/utvAINryEdxDMudWrCnJhZ3vV1V0TJsiCWxc8YwUD2iJL6z 0wuBCxXB7cyFjGokULn5kwqpCZ+s+GK9E83+nBRzZeQsjZ05jRg1sbJwrol1f/DHdCEBFtw5fdSs GHTJdwL9BvsqYsS0SOu0cuRMyWK2scMYtbLcCtK3MzK1bu4pI/AmdHMmOEcLnRwmXQBRyVym92Ko JweRwunRrkCn5eSkGdSlQtsJdzn+5ECdDooRCIH4IiCCcICXDw2Nvr31QmP0ZOuuH4BcMjUqQeYP iie5ZBpD6QY4HZzlB7HfY5s8xMXeJjHD2cGMV7wSND3KkHRFB1FydmDB/E2FCBhDQ5ipAU65yhg5 U6PDw8yXotKrCMCstKCJAf4PLjuJDiJ4A1ObTdZfCxdthJMvJEhMTVTy4uLvz6ZnacGfh0N1vFhs mfp4NPZJxnNEtGRySXKjHhgsU2fJ9IHyTKDDWGJXDLGDJQmZOywxcYnAp0ULfZB1CX+f1aCZVeo6 HGXOKKbBs8T1hxXt5BoQmRE8dT6sFv08DQJadSPY5NNqptOKak26VS1DOGZQueoTIJHP3ahTYNwj BMIviHPH7HtaPztPg7Slvx8Np8nyA5+FUD3Kh6hOhyWq+WxkiJLPewBdMkKBU/uf3dAR1mphXrd+ npdC67lm5BSteUPB5xRaS6lzBj3yq5RAMNyZpBnzLgWfK18OQ4Fh8w2gDwUwCyzHDGMHybhqDGDM MEqO/LxbzznLAB6gODO87F3Q4rWMuMkQT1BLlECThouLEyQqDkBZpxVfuLMsp/oLPloa+MZxWo1M mqW3sjARHLvURjmpw3qiSk5nJYwGqqFLN0LqlyxUuuVbCcCZe2IsbIs0pbFJmNuhIsGQyNNg2GHG Zu7sCMic4coXhdMs+ksaP4IKJsPGQZ0URiDd9pk0SWTy25uUlp4eirCIbENqIfp32r/qr+Zgttp7 2/SxynNVnK9+0p3r9QmSDj7NA3Kj5AOBUFUiBwICOPg8xg3qG3pEqiQiwV6RoaalohFqFcLEkxSl XIsMUYIbM3fn4999bbX7J1oN888eHRpQqzbbLjWimQ8cNY1/KRW1vSJL1IY4osylBhUFUI3Kkkbv RhvMIDRUjNFIioSglROOHy5HFUiqjBhxjWlE0CQTSJJyhy1JZ5Nm341ybWwkmsJXnqjhBUnE1+2f Z2tvqjhtG1c9tyHTpFxVpYmCXPRQDOARTGsCI+IzxFHQTqWwhJyrAXQ6tVee90kUuuK1coIKqCLX SZFpcWnnxjVbonuO82aiITPjjAptFOH7F0jJ0UPRAp2fBiQx2ZmjKU75jyS00HS4Wm8UhXZ1lJ1W zvXdFntgRCgAoYl3m/lgzXB7KQt66RGXl401OVOeEygLkkvMeFiSYYMVRGO1+FusKNrWm7NTRu/U a5Z9Tr4RvrObPQn06yGCws1QMSVCqoPIxNjhFEkMGQ9HbFLe/pT3SagDpI95NEkQzQMGyWbhhFX1 VAOdkp2PiROxV3REK92wlz49DDHsqRKRjBzyRQkZLdmT/EQ/siIf4oECJPtGqyNvW7+npOiV1KUR aU4HVhrWFW06BZLWgKUSwiTdNDjuemYu2KgE0Q+CknA8q3SdWUJtCzHg4ZttYZ6I5WshPYYDnD5H guThVmmFmgIi/yELkPFMnxBEFrnKSZZeT4VkgiDl+Pach0TckODn9D6mCxU2YmRPMqHGQ8fgQH7m cy/k4xJmlIVheegHwEyBgNDVKZ6UrshlnW5IPgspPe/VYSWDaTyi6tAEogPikKzLJQuFkpWsu5iF giArZagk0QH8JyVATCiGm9lqhotKCm0LHyQarWnFZS9FmanA5ITfLO5WJtUTlWBswtfdUixfI85s AYRUQC16jyWacBSRUgkvvQ/BiwhFATDUtcEy4I38oI4uiRCrDbAul2AGVGZUOIurtMwvtuNAsNU4 j0tSWl1tmxZFthXRFfliR6rKc6r8WSYpr0IUQuAKhlESaBcleS4wMmxarqlD0b+NbrWW2yXc4MIG 6QQIHuwyQFyZb85eS3fViY4gx9cm3hTDKWy6VShPqgwqAiLwnEoJdmfCkCGipjVMnGoYKUmgPc2P IcWpSxxhEoLi0KCRabEHmhXnIv0YgZoiHggCh2h77PazPZ2sKOupepzJjyJK1VY5T1EPSc7Qvu2r cYmymG+xsFWyVEakbyA4M9yNtjJJgqQsru7WkkeMwJZkyLt2HWOmLlvzRkMJO3C0pxxXo3kN1zvp j47PDVbbJduY8RTgpZP3tKaNU8hXSDSQnCNnTVuMTRPg+EZ2LQFpMCWqcrDArJ3mW1BcQN8RZE7b slrLCFllB9A5iMiHtEQNaVCrTNW1utg6Qtw5SG6jSdArWbRWtKyeCJQsnQKHBQB1REhz4FiEckgF 4u04HAKlDwvQKdrRERPVrVyxIQ0vQrnbZG25bfhZfvCm7hj3qz5OrFg9kUwmLiqi/UPQ1RsdHUNw ix6aCOipGhfQKd839s/EzYqEVYsJg60FHxavcQzTpwQRKicV2xMxxuWF+WBg9YiwQEpJ6Vvf4HgT APBDqiYIwF+okKuH09LCp3KSOjvKNMrnT07UfqKQUlJxsECEIzirdeW1w4uJTEcCzIrkDIhRQmsv bcRschC9ECHISW8OSu7FDbuKOozWUQdfw+lZrHKTeJFBRhYFXoZqzRzKIkDTqcLEE2tiGgyktEyY W+1Gml8ZsZvWt2WxfliPbH9kRyq0qfj8QGyAZivuwKC2nfpzNiovMSpzpisFgpuxIkbFZmIYggdH gLmRzouk0x15Z0wwwpWkKldNlajW6ytckJLgtciBWt1/M3opcl5uvHHgpA6vB1+ZhtDR2sMYRGB0 7qTHZN8pjGREuzJ7FRGPTHwTi5qSGL/GaVWc1OHwXlBOpkNGcYRljeSHEjvKcn3lBU1Bu28EqM8Q sGmTLiNg8p5YZyK5kyovYyIKV6IFJPNVtWb43vGFhl7smTyW3SKk4w2MIhEQOCzgEjhAf2vf52ia rVEu3J4xWs1M8Iz14e/krbjZsMqwgiM3BBtvtfIr2KNJVksh3eiP6PY3/e/evspWw2ryGrLJgXF1 KX6FLpiml+1Q8ryMi0YuKIkB5Ce1prgP8sWY+k5j+zhWvA/bZNBM669AEGJZhAS48pCLgKWlby8v RUGvl4w20o0KZaMgViU0v96lVKUUopT/8xI31+z5O5Bx49G7u8PFkZCkRTMzLRx2ByLx4xCagcRr UH1l1Y8YmUMDJQyf3RJuLMoScIKn6d/fstkyQvCQxv+gdHB5CrIr9Py+C4GYivCiVStRtrmDdCeq ml0iFibigx+KFxjJBb0epKKepD/oJpzZceRTd2EcucKlCQr5qT+S5KDRWpc6GKdEyDfZbJS2yQhM qKdFhx1OGRTVdTJlnMmjYps501Cmb1YoOXoWMgr1b4RE4aTR/VBK184cHPmro1Z8cmPzHYw31cer iy9xs+0keaP1Sd+iJftVZmOc/q83uiQQEsNzTJnmyoUrnA0mWGxc0TMUNkD8FJyN+ui0iBzYUCCt ilgqTrJF0ayI6lxffdq92DkPBASBAiMI8Vivp0vI5HVRjh6wbx3/RJEjowkqFIOIox6HGcmxNrl9 TRk3eAWfv9snRCm6O5G4w7PbJ7Uc0c/Wh2ieimpeFvSJtQ0nENiGQU2BbqLAU0A9xF61qqdY4Foj 0FnciDyTQB2mgL1uMhy1KFvQOaGTmoj2gXIcg6X5gGs73j0bV0mZByg7BepN7kVwnMepyiaw2ak8 vE9fOPf6UdZmnRHVyeKg4R7o7gwJ6H6TvD9X7vwPkcH5rUTws9jrVge/5HjgKuVpMKi/qfp/c+hO q2rZ8+bCQosmk/TpiUDrXfFa7ce4vt+oFxXw4PZd853vh0REEnzqqVUwcmJAXrj9SIO1MCpmxCVH cOWHwlyK3QSzR3t50mN7SDG0eDcmXWPBQsOuDGQRxuOoXCn8w7TvaSBAve+Qs1Zc8pVDCcSfIVUs zHtlwNUNzEkjRgVbt8ir7cz3rbxwMBEV3FvSTrq12SIy0gewMHWFWUI3dGbl6ZGsWaMVg3Rcbasb YnlqZT9Dmc/R4LAowFDxC1Fl4ZkrQT5VpRXk5PwH2wPAkASkECCCmRUFRsskVRREfZRPV9c6a4Po 3Hyqqv+ZBAEYyQfh+21WsU74p/HAsxbI5T1KnwJYvCk8YpbuLJc4Qwg6zxRhLLWk8rRM1zCEVtEo nErbWl9d2sdhCQIQPiPDHacC/JuyF+Q16U8pDGKAoMTTgj6czmNicUdzgYGLEhgVcMcnMMKEJCYS 6IoiIH9sl72VVtbTOlREBY+pP+Q6YpBNVRqCIlSJ1KU3dkF0IXcXJsUS4l0T4N/pStxStf88nLcJ DSZJ0BYQTNJHrYbssPYw6MGFZl1Wpg6MZOKMcSWMLtqrPKSTtzY3tLa8Voz5DFtmWkiJ1+q/zVJm Y/HUeFxjqSJlRmMjrHMOKCBiZGg3v+ZskR8/0YftYviWeCSHLX0K6QND24mphwvizFVwfJbFiAuw ScQqISsWRZPMXFQDCJ2eDFVmuAcikxC0jVarVQoVypaSytVDbtvMwZCVDLw+5eb1OUNq/w9aVt/p 6tRaCIXICaAkMhUSQgwqFwH0KkLIuUv5HfyYg0BCPlBJ5xBshlCgMUoQ6rPAgwc3Y6Ojr6nQ9rFD fn0BlJZYp0bZxSRZET7oIfIDe1re/dVkgHeaOif9s//haJzpENd1aRQJRJx0QKgh8AZwwqOpcuqI WYe3cOrk6FkkPpoOjr6/Ms1dT2TLoCQEGt0iWJoEmNi9iEEk+eaCK2FEFGBihBethECVyxpqjF72 z2xqERG58bcpu5a7zi2zZlYmMiyaVzeEOJVc/Pdxbuqts8HkokPJEpQ0lEeZl5A56AhFARUGImWO OL2m6bndiIqqDbnKakqUouuIegmjIAqBK1ZKgyollEayckMCHxmQUumKRjCIEfJCAlFTLVxPsqTu lKogKL6/xCUpqxPSWdwvK0E/asDyiQO8CTFmMP77FJTTex3ODF8jUWyBq/q0iqirpclk+UuHsobP WT6ZL02Guhz2fiiAxYuZ0ezBe1ehZf1D3M5xUDHr4IN0pfa/VqAvAmOICUgZS1CzUWETAxMmpVU9 qFksTnMz+cTQRaiyEFJljovtRDIqeEzOENKF7sDvRVbOz908GT70LQYGwfJcNyPpsoEhUShQtnIP LKsTKnyE+yMi7Bfqh60Ez0Ok7nrBw0ZPDrzqJbo0Hn+gT8Aw/DinPar7XGnEdGZDxdzjRKdB2o6u snW87IgRIhBkBUHFRJHogKl/0XJrRXy9ZQXetcgir3KhLVCvqPzNIh/kgn7qSyfQ9IU8QtMy0iIU ES+aKnKPeguelpkUAjCGZaOtqWCbE9Crr6LBw9jJ5KiYQ4Hy2D3LV5k07KnRczklIyDqWDwkzi4k OHkDGiayYuEoEPMPLDGO7rQ77w7QpFIQ8ZZvFdSig3ukORFRCApCQwbBepg033xKlbV81Nkk1g6b 97FsV6OFXKGPjaEy9gkayMsDHRgoctJ7CLLdzBj5tULEOrdnQog5L3koSREFpn4MZunkGmTtJQC3 MF+/3fgFcUJZN62esVtUOjrrhg80fvFFCPgWld2Ot08y4vXU5A4VjEUiUDpDisNIHyQ6AHifJAiJ hwKeD14ctmszgPc56jOIuMpUyhQNRzpqkIliqWuFwcGgJF5LIU+97+k+8qYsIb7FhEVkQR5yuoaL FxzQEhF5eRwKmS9wTHX2VvCKamPehYxauPoPUWXn3qP9jw4ZPiVqfiHv4uSPbGhfbjHs+T9QDnWq 1KmD4DapVdC2M+nD5Y9Ok4mLKJSd6RKcqeR2AMyISQTRY1SAlrc1odyNnztFuNtDYq9nycJSTiBf hWyyuKVFSqBg7Jx2dn8eyJFiXZCWPE+dEHQpwOMnFyFeWDYHcAV26CdksNSDFZMyLpUji6JQiESJ kU5GA4fDUoOEjakOEbgmFmxTfWqPVdCkQFcUbEN3gpSSfNRys6ztIrKa2UbU0ES6AlkEBGMXMdR2 dGDufOhmWD0YyP0hkkPOqzPDtkEfNrS9RZKqsQJlESJ94VViOzGiTxYzkLvFWyzk8Upx73M4qdMV ir5h3mXdfY5qd2A2QTFxhkZ8lLVqIJN5pHhIsiCfqnFLnat3ZAgGuImWAY4jwhEeZEnEWuHuC4gP vxxKjBc4VGMkh2Jnldly5BstWhU9DFxdL9OqF+6IhaUGsoFxSQMLi8jAmWpIahPrQ6gGKSgtT37L +hi4tKGplh024QTLmykFSp6PRo6RAqVJEhj2meG1NIggjEWJGqHNFg/eiFZGulOYJXHkKQYPWZdD xohsaKnAgA6PxAoGilJW8ODlzGjNy1+ujCkiKGqGhjQVNE0epU/WpdT1DcHLFk8OcKFdHC1AaZws UMqOMxI2MUdOiaIGBCoge0RiZo5M4XGLBTwEvpSEiFta2seaDysuN9dCi8iYA4yHpaKb6JEGyx4Q eyodvImMTPOxUsXyPMV90KDQ3ES6qBDHGuwlLzaQpiVyYeMXbEvmqE1CS+lJsSI4mkCuI2GhUIEb SA42SAF9BKMynBNlGFPCpUNXL1OKSK4+Qw9E9/l0e1mdHA+xL+XuGixwOQWoGYS0gLlYM9LaTIYW qJoY02lCwga6HKly/2wqzg2fSZZKhWtj94cOi5Q+h9zqTmDSpzE+fAYbhO65RHkHbUW+ulfVyDsO hTCJxX1cBOQJ17sKUEgdD0B9Dr6wuXWvbByo7fBXgW7EtFpvQuURuUOYa+8PVlAOpRd5jV5O839T rJ4OvJCecetrGUecjjPsbDCG0A1Ic0fIOKeWBdw6EN6antPBe4vMa81NQdYg9r0ADhyBlDp70DkJ l8K5HuTUgwTqXOvQGx3GAUeoe0eKmVOTXoXkJAzAU4iHeiHOB+KujmeTMLZrgOfmPFI83PgUw3VF 1O/ZwYTi50wZBH4heA9ztYeZ3pyLzs8g9zamTh9FkTKswQvDM+F9qZ8ixXQkWAQeCht5NCA+ecuo AkJQmpiMqIyVRW4KQI/bdsMCe3e6q8mhEVOW/A7CIvKibc24s5U5VRC3OymE4dQOibsxmHRKQbQz XdhCsJmKkiwOC1VilIDGT0adsjINVDM1oue65XNWxF7UkGNqIh4YGd5QoTELrQYEb64L753w8PY8 S2YSEeQHcOeezIZ78/DxcBQAReYfutRD7YwfPOfey0WOPjtETVfkmOHgvERFEULKjUuhLkwi8WIw wuGEhdJgaLApDUCUw/XtrXhsmdb0sOvl1ZJTObn7HnaEbjiYwNxyRzgFcf5NkAcaK+xvg4BzBP5L C+plqHuoC+jRAvUMKk9v/bji+yWEewIMKRgau9fDGJpqc2GjDLbKOqkWukNtNW+jmD1e7eebmB1S 0JstgAB4shIHa+RIqO4Rx+yguKJEjHLQeEiuUaxzEQfv6pYegkKOvjz4yTZuss060nWlXoOKnKwT PpQkCXEmBMavxFUG6P7jzmqpVBG8MkjMIxn8jTtTBwoHx1YnHltWzKv25JlWk8m54JIvCowd+hZm TGfRTGTw7sTY+zndTvK0cEKcFF9FixgXTQe+zNMY0aL5mcr6skKH03QrWqpMKk/P7J+1JHhRyX0K mB5VoXF4iu1vqNiwMUYynlWIgqiJJ1u1Y5XjQnKfkQ4sij25AXLKIFb94NFGY6KbyxnO8qd0elgq nv5m5FyR69WpTwr4amrgnclHOCocs1p50gdogNKpcf6CmLDfwAMaMh5zQfFjmgbQwiMYJU7AcZag HmnwDfIY9nparuavc2Sy5le5kYlwcgyN9o38iZM5IopA47mYh1DhD2odErtx27eWHwEsfa0BwNt7 nHGa2vfqQ45hEed0yQTYxMcuNaYMIUqSdHWKmz5bt60/LK5KZ0MgkeHOBREBpW9nGYJGv3fBI4pg WSzOGbhiZ9KFVfhQvHRg7SpMLk6LNjqOfuLfZLh2Oxauyne7G9na72jQZsHV90nnE+qT0B7EXeze vfXtBlVZdqTllz61rWQiMIOCTEPmQrowT0PRW8S7tWlsqs3zd7V6HFkTRVFVpm3URA+TYxOxUZeN 9/khCE11qLroTQTVEL2IrXc0Jn0vvzSycq3Qtlv+Vju+RVTs7K+iRzJ90+EgeMZ60D2DBVhfqojP VMoOq+xKrlBaorCEIzJtmRH+FHdEW6LMwe/cdi8iLewmQMCss2ao2BwaFptmhWVC1DzqgbtvvbYr t3og48mYdEk/c70gheRU5KBmpNqKASR0ZL3EPPfup77L1LFMpqqk8pNwqVbgK4fAwlcEf1QT8BPL rTtWFu5bvxzU5qUFqIYO+EifyfB0XS1jJ2TFP6gY1mgiCMFnRvqP73lehCmSdQdTGK3cc16yLKzR TQcTMiJ7kFdHQrM+Qh4Br7yWRW/lm9TQFfGEd8nuVpJCNDSjFpK0zg5DCQiFCAiVsv1WSd/3RjVG LA598Pj1kqQJMufQ+N52KISOsaKyfdEvU7PC5vNaqC6Pw/KNET6LHgh2eUKlVwVS23NSn4Rw/hUe 2NUKmDNUqecbVSQMVhkVQ9KdB1s/ERPwM1M/BpjJw9dWLHZckecFKk7/4FQ+qAey2cel9D2kSquW BnblZvFZ0ec6Ud4PTXeqEzrlC7FGMGSinCVowAU+lfjlOEnHUPXzriYDokNYhKGCLdyVu50+pXud BazmM0mjSaIU6M8Dd3FdNK2MjuIzx66vWSSW5zfuNBDcxOHO7iTNdzIrOZIs52mo8kiETkUupqbc dH1RMT9wKaRhcclKDJo78oHA/cI5zhlDOD5sGTM8JSXaQeyVyUxlkog54bHImNypCOdGGLLN6P2c 0cMoiEdHCZkWtlgVUzrZMyUS9aYYFdZKglEsJ1j0zM8IF9Cq01e8wHnGzYzNJGh6K+j0dl9k/gv1 f4OjBMbdJDVQDvSiUlqeHTMGxUfM2FYXwun85furXUmlFne7Ase++IfAT35MJ8MWTkjSloZcGBEk iaG6ydSWtVHOCjmJSsQMT6BJXHZSJHZGCbkA/RNCRkZKuEjDxmXieF9UH9Z6OqFyvr4n07v6PD8q jFmUx8Dk1lp16M1Ozl3NtdVjokFZZ4xeXpvsJMCIxAbhQIKUiwMdHkHpGLJCSSR2Q8v9/jZYkFET KuLBiVgEDQZ2QUFz0aWg58z7Cx3QoehwrcsOOOMMVGLCygc8KhU1MkNW5cYcleXxkkbPrZg1ZyQy ev7BNOEjm9Ei5BYocYgMlCh0aPmpPmhzRfT4ztaSLqGWOramzNbJ7yYGe3M0xkTomcPZIVRz9pFD B4TP7mgIyEeHoxXzQsGz/AMVNhcVtjjaVTGoJBKDw3QU9DEjhIOHrLkkcJnR0GiiadCQhan8UCWi IkMGjJu8hy+XBWDJVQ6KqW6FuWKsTFKE6GRRi5J735QobFPlK3ObsUME8lzsyZgsamWs30/nMuVL HXyw5lEQ8uZ2ei5I2cKFnFMoZc0Wu2Ds8uaLqpqRoShQnI3M54FixT7UGckOIbMFOumIOiRMhyQ6 DyxfV6UtalaaKjkpBKBR65KFRhOzMm5eQwhMs5PApdHcdj9/TixcXPgpySruLsY/GHFZWDt4ujeS PrIiep3fM1PQPXJu17Pxbwes8oj8IfRJ6/kRjEvDGj7EFubxahtD4qm1DCial4DqPkeTc8ozeZNE knGdEk+7HzOh5JNvSznqHHnsE7ui9aC41wh3K5y0LCas6Z8ydfs5pb69ab0LwDGHRpF18Q6s/APJ OZTuM69aZTcB5IJeh6Y9/hQeHQfa8tWXGfbbwCYxQUQrHQGrqeVV0Li/ILkmRDkg1DC2p9ouN724 XZ0XkHF3FEda2sT2TtOYvontT2XCje+0iIA2YgcQIMA8YbEcTYfODuUuq+eeVh5U34yeUR22xBit BHXh6oiJ49SPHD4x4J5JAk6aLBi9nsE7XhVTXlNVdEa2LS7tZAuSrEwHzckoylYjdGOaqS3ROZsY 7jdBBe1JzBJwKhVu7I15j5Ii9wS6mFpVrHDMnb3Mh3FVeh0t1StEvN01VUI3XSjLy1QHgXYCkLtq 3pdWuQ48lzoFLImKfaeJdGQQvlEsATREMhatXMsaGNGLcRLESRS9G+tzF9NB4SMir+iwkr/N27sP H0w3NMQFFCR3smqGpKHSGwQP7JbfJHQdSNPucSnd5XCESwhYM6colKh9D60hn8LD3lBBVXAeFQfB 5Ugil+GNYtNnZuwsdjzEREkP5J6NYUCoJ/Wt6arUriyY18/4jk0NbLFsErul7/DlJoBUogQjSY4p isiygrjhwmeGKtJaMqJ2umzb7c3mmvqrS5c7Z6/2UZ+WR3RUqe7EhxShtTXr19CkvQw1fm08AU9Y PcL1ie1l5McfE8UtaoVoNFWaM3LlrT+4yFkRKzQwCUy0ogZxASfeUrLgIyoGG1VBH77k+K1BDskM gJcUX+Xe5Ln55nHXS/jU+uqYWq/F2SKPFhAlmZXhJEB02RBsx3VAgrRxGZmqNlVWMGPN6WGtNscW TFwchs13YNqUY9++IiGZJq2rHKCS4UG+iCE6sdqIWZvIHL2T75cuMXHOhiifU0VpsuKkH6Wp43xW m7NZWpqUEblKkmW/uPrgEuggqI4lwREUTIVXGKJgEwITRIgE6b7QxNZDAiJq/e52OVL5xoKAl9lS xYpX+9TYszLSLHQyZKJx+kNM/UsGkQM7LlWyLIoJyv+ZATFrQk0DdzV5UTgxX6knHWuEITFcmm2w BQSXyd4clYHUw0eHFj3qjK5B3YwOUz6KGZQVm7iojwJmZEdBUMCnVIKCHEsCLxct22tfChrySuay x9D4UQhOCPQl6IDrd4CDoE8IAoguLWw7LAvf4ib9FgJrSytUbwQkGqZ3TYHSGeYvnQyTHIhWG0CN T0UHsSEB4KDUanCKTqVSSIQI8aCJhWSSi+wLA6iZBCd6o4ImQuJBKkQypLnkaR7OKXYmqXjebPeg qovFkFUwHYlWZMkiCCcQiaHSJLYdiaFpFiKyKK4F6IZoJsifBE2drzrTKgaKUrTIrg+K5szyEXf6 Ktsd0J5REJ4uuQvmh9VKHgQA6CoJhqlSpcuWVTSF/sL98BS+1BMHx8FgQygxrVeRV5mxEPhRDHf4 OExLilL+ziRY2l2IqdFyll0XKzqqSyIiQtKlKgljxAOw9WIqnLxZhzIqjOn2GmnXLLUkQN0oc40C TLCk0QfR3NMxFmvaoElRFRRK1IhU44axei9vE16Vj6TciXgxAfW4i8gogpgeBugngHmD0PLpSl3a 5SlbMVufA6Q79wPK2lQA5W5LVCxD4PviQpGDRHBlbRBAlJAJk+yilS3Z+hQyPdLIW/JS4+dNVTYZ r5Fs16pDsZpdSUk+rze3ce2G2/F16jgxoolT0E6K90khQQ8Pq4jH2/tc0eWxeuT2TMdB3V3Sq21N to1UwcBGPgz2puyYMJqw0PP29Jy5WXdGX3WW9E8/dztl2qvSkFkCRJEJHXCSRlTsRq7LSZqHULnZ EBSv0ROTWwK5oCUIHRwJ4DkQPA5AcxDBDFEQ7bcH2tk2PDm573VRdAdBXvngdEQlCKVlS3Z4XEQR j4UkXpRaF0/OcG9ligxapW2fhSo4m8IghwkR7YEkWELn53NwXZsgYFJSlprli9FuaFT0gph8Mp7k yKyGKbKWyIlhiOCxuCZ6KxlUzqO9FcG0isPQDctKSJtU4uuLik3taL7Jik4biHLyROQhXtVZthBn s+rFnWQaOihSjJ3K8QUclKK0r8xVES6SDFaKvaZ+8zw9ipitcrmgKQnF1qbVQnq5JJzJmKy+6pkC RF9i8GqSHP5zqs+HUWoOt77Jkw6Pu8yRM7+yB+yp6ws+1Z9Fh9haFtBftFb+oraH3Wxfv+BZO71b uc/hti83bHybnrzNmLI9wNDD6qVyaCVpSsXVT00Z9PZaeZ49Z0Ee07jq2kQW1eBU2nqfzaBqzCxk sOLU8PxPy/P87juUy1SUtyRFzudWk5V/3vWTTLRVEEZKIJZGMMJUdi5cwOE5yM3EOEECsVc1ksAg xBo4Q2NOKbLUM0x1gpaonShTJMc4QMn8TqawV/QmOmxIJQiijHjj+fdfFu4fidK7opg2c8PRLljR XZL0XM0L4INMOWPd8677qsrHFHpJ5tE6FnVhkKVadZJNIpIcVQSxUglrZK6NmLF0UVpW2JFPTOOa HOj1dqmSujv1MyfrxLH8k5PCJVRZsmz5HeXF6E7buS9rT3/H4M0BpX6Wz+sCk8VxSLmaYHNXE44X umYYFmLyb5znLUtkOJlsCccy8mtwFNhVLfA0aLL6NbWlwgmDGwGyXkEubMfvyuyCUSelBkwYHCQx JTS8LExWPC9jocyasMaFKgrFhCpmRMfZk+4hBIq2iRo5O4JFfYIcg7kRCmZIaVBjYVksTHCTXDyD 6ccinYpNIL3yXCehgoSg3hJgVMj0KCGXLeUNjFDI3NCmAyfqiBJyho4KjkaSzhBYsacc6ZSydHRc oUOGAw5B9PpwZvP32rwhixHDHfo8M58OjuUyBj+fx+yOZPipy4hhxOjKkImRjhYUkQjHZ4N4asVK lhWzgokz4JEG598ibuThwXbsHImMn3SPXKTnwNEcOWzwcjFjFZOzC8qB5GCdg+i07z0LIEkrUyLz 1Bax9hcoUJ/B6mR2fBqBdWMFlLwWG8lMp6JlZPmdRTdxU/ghn4RJ4fMZFePb4cWhmS4/IP3idgk/ svrZk0nZnOYGbxjhMyQTJAflqEwSlnRUmVrWg70JyOj0YPCZmD8EQ5bvsnskNK5IrkmQ6uLo1eEf CPgk+SlTGNj0I6QmTX1pD4T4FPcfF2dp8JIwbQ1RnDQ4/SM0c3g09iiXh20fANjKJ9HV1bGrjMYd ydslxeJ2I2PF8ohO09Mk4N5DeTxDvi7vPTIdHE+VjpJ6mxoNpPHBGCQwRlES0NynVVUzBlXTuDem f/u+nbmZPC3o6bN1tCubYT1+B4O/Yxkz4a/njZSNPFZUk27VWy0h1dazr+rzvL2BoXcnuLKuyJwV LQcnJp4p0KlHe51rAMGK4eh1s7d6OssaVtxRT28lcGsTm5kWa0zMkz2MjISzZGwoeZTeDRUqheGa pZUCtmu5RzePN2te9NubIkQDSiLauBnKuSzPFEVEqILxssRGu6iQog1ewJiRVyEGp2puEpnh5pU3 uPlZdRydwu4XBdTTvIFRWWmqJeXqgoq3U08bDra6/e+V7n9yz45k7rqbj1LsOVB5q57BR0o2S3Ql WqJRU9W86RvGOwBxAd4EjFHufM6Gat73wPFZHpv0Numhvss53ZyWaPNEnQYec5RFUA8VALV/uf3R zZUbJ7ar/NuzE9mytyCjCIiu6mHT5ojXF4uKsawWTKDXjOjgzYJkqDB4rXYpEzTZSXRSUjDJ77bs nFus3mNaSTWISmy15esLhsphw6Fn4Zs1TJWVLhWm7x6aqjp0fqiJ6POjo2QYDRsvIl0f1/rq5sU+ A2ZsiVrcjbdDjWOuiI8JjEQjvztbWVorFNj1nXvjmNVWBbWQyDSWUisMs7Hf10ziNEkmrX71SK/G llFfXUt7vKGi1elwc45IFRDZCSFPRCMaJum5ljZRpTQFEOpGCbKWSJidYnGKOhImVc56ilDYoTXq h2TMqa6OiZsYkJwcYsdjwKQaFL87xolwKlZMSGPOeZm4pHh+aCfvEPo89fHIMMvvC9NSN0qsbnaK 0rcnCkXspW2/c6rYsTKdm54ENCYxogwe9VD6Q62FzuI+KkHZNSQKxYZlUA6mOfJIaJMjXFKIryrm baDwH6L7OjJXQpPaEzVsd9dGDo6uUuDmTY5OPgYnMY7YkSqVOz9gL75k0sK3TYI1alFpqgtES1ke iJwqaOuzGaExK49vh9J+R4bJgFhJGKLMjJMIkTMkzPHogC9KaNufoIOBJc5CMhXnjgdNcBywJADy mgdYUkeMzWwSokPYJyng4ejHZk+CqmB9HvdCilLnRMwxM/BE/Q/OyH0p70zYX2Lhu2FkuleTvLsW sLMkFqTTyp52jGDFB1QnW2IPZotsyCbJ0cmSLi2rQyej0OEyBT3SY9ifytBC1zRyqz8JlVNiDiEI VjnhHSl1gt1dJoljo0cGHHOhzRkHaQx53wuKSLQKYIkIih2PboytKvdcu3bIO3Y8FhrErCZv/E6L Fr0QwqH7HRkptyWrlRySFBDYGi0GCRMKNYdK/Vyp4ioTdEQWfnZczPqeaun3TgwLOegoVFes4qPS anLmCpz+ZWV2LYn9Csk2ZwVJHHENmdngxtzwnsiWQ/tTZnpV+a+0hZpVL91BSxWlR6700UGmVWnb tvIpIufvab4z6NZsLg8NI5ckqcPXowX2bOzZZltxlwOPqrQbFNEisEncmi01yZq5UrBc7qdSkWNs mRU1Loci9eIfWycOzs+xIjPgv7IgdUO9h8QdWX0qLZIdV8hPasPJYrImNlfVXpRbDjHOeiDPswWP iEskjOXupoWayUz0MewUHUhSxPEUNJS+P5YKbynDoY0qIqKGgvpEEh/g5M6WF2LY6r8ljIwpufwV L6Mz/f/C5wmvhQoQVYbydM/LnQpWmxSvImZBrF5hsIx2kbDzu2Geg8quE5Uk7JmdRzAeHhEihgZa kbiF1OVjsa4ZrXouTCFDizifITik81HTuXCiSrSKnJYuB4oTra0EhU6FS5edlgB5JUkdDGjZ3ESt 9sQUIpYQgRYuIzvPdcMZICe4ElcFWJ255L1KF0rSZkUnSkRSjRuszxkoLXss+2andUKYk6h4Kmr4 ctg0D2zKn1+jwTL3GJ59mxpk9mhjO6FRz7anYs4UKpdiDRns1upLGDdXJ7mYKtfvHsv34dqfToYh SweWDK6CpSxR597KU1RjN5vG6YMVoxwwqI+SQc90Y9pHEQQQpRazDCDB31yQr1TLFShXZ66NJ4iy K8F8OkET5CrEhimzvr+oh0nKGyuQ1Pxhuq0qeFTwYiR7MM/hKpIq+LYm3mSXZWoDqbPUxx7nouck TJinBZD0JDDky0vOoHop/FEHET6j9iopbLno+MSlf00zx7Hu1qeilTwLkhyB4GJ37L5TwmaghEEy NYPTHOZJmyZk4bIOFawXIK5qWLhc9kEjh0UJCjbDmDQxZR2xIrgM+TqMWFjRILwSMVKJMvjEwYU+ JEEyl2Y1sx4TbHnkjB2WK1LFOyPJaPKHCseSMGi5ccyQIjeGf7IXbZgYsEN/UkUOiEBMno6INmHC L0G/gqu2BPJT7OmmSKGCQoop69aoTsaJXKlpjJ3M9SuKUsPmiFfA4RooPHRECGON9GWayqfe17q7 3wT3oniAMUj5mQuUx5NzxpkGcZoN/NE+yEju5M+jr9AqYLnA0VnIp8LMd8ZS3lpdv024tUPS+rhH GP2GrizNDqtpGRge2M1/bHpn1Lo+aHpI+0TK+aTsYvUtepTAxeu1ci5xNQBENaGJMC5e8XfeWA6u sMbyByHaPFAOnlmDImPtOo9BS7cKukHmGcDzDQojza73OQJHahegYw4D4u5Fkeo8T5e2x64PLMLy eg4J3jkBm4296q98MTBUyg22h2C5kVpjTVS6l0KyUvMm6eWSgpv2iGo53VTeJS54yrQiVt2riRDi qasPq6hvaVXWkE6IR4kSNIit6HEbTquudsPkga06zI6pxiaiNoX0AnMzZqCtG3u6aHVukKQ5WXl4 dICzDzbV0WKpVlxAjdM6XM1RmKsOdrBYsG7w5mIEVYupECTG5u1MzIOSkMwXaVOtmVIc0iK2cjUU Zh2ZkQU7mrl7N1cuWNiHl0YQu7jm2RlLStFLRTCZNPfNl+Cv4ssS3r+ozg4Bq4hckJA1HIw1JqBn jNAbBqfdsSSad9QpgO1OTDYn5HhqgWDcLrsOA4GTkW+D2+T71cYARBLnjplHarjluirFw1kLKgjD BUp+YgWvZilKVMkoXa1Y7gtkrQQj5NDOoQYGQsQl1ISl+52hLeh9he7g5kECKdRON70OppnWBFst omTG0hfFh0Oep75gcVKYtM8kaPUbNlDZQmki8Tqf4V5ZfK9tDSi1XdVWT5fqb6gUlerK0xDZOCXB RyeF/q5ZUQPVyWBAoYLhR5LMRCcCoiorX+OcpS2KbifbLWjVKtTmL4HJabXT274QJgkhh2MIcJME dB4K0EMQJwZKDkUWDp4QBuYJ16pKiIsEkc9qbJkIjoZUyOcsWD0Z0P2XF2LQjIutV6pQ0tHd3VRb xbM75PxBBTIBCcfKrWGkIIFWsIelfh3/OhSqjLsU8MEl9AwhNEQfL5GCWLrnBIrvI+I+3GYVaFQD oNj3i5ikT8PJkQTLuTVRhCUhUFzphVVV+9Ds+BRivFpoy3yY5cBgql5EovOjB4XGruaPpIpxYurd vrfBj0lTtEEEpFjvYodCyyP1a4PafoaLSpdqcf6GQkCqjshUUC7r/VB6KWyNhUSpUGTIokwUDS9i odFefBAxMkShE5ApceFiEQLXaUlUGU1SHRMipj6V7nESqYIi0riIjfNyBSxjo+T9gDOlWXsqfJzk EihIsUJeiXnDBAyHC0kCgzGssmUFEdkDkIehagJ6IiFuWa4aYQ22k01g2UGksWV9EmonOMBEBdSh sS/xfVBaXAq0GoyZxeDDES4IEAS4zLCJtgec6aKVRUJ22idGEtI4Wi6oybMW+FLdgbTBlWCKZKH5 fhm6rW9UTqoxtUkpk+/3a0lJEpaf49KMlYpUAjIo3QgyKKgNe/Y8FFRD5HZNCh53SYTMZvbY9Q9U I+DdfR3UqdabsJ4PJH6h/E+Z/Er76j5V7W4ET6Vs3YN/AX8YhCJimRtcIF8HCPQTt0A37ZqyRDEM NSzQzZhsdOMkPT1lK2sw4lTwFjZdfkqU3lEYsfPHNSChiDVwUlWReae1ZSagawMwoxoM+W86+T0e smbsbPR3i58qTJky0qoglzs66PQz3z0cKHvz1MFXs0w12uviq0Sd1fOVxsY2l0cjwuYFt4N0psyF xRvRfIPoOyQ+Lt167ME+i529dXO8yIJZMFiZ2NJTYTr4iyt+9vUMnhIwXSR0QaJHQ0rD0C8xzHk/ BFHlRXmVFIdgceoewPVE9UDejWrFVEZa1HC4uddtwaEYs93H0CiaI8zGlq00hRTWVFEFkmxIo4l0 KZrYXPpqtjGZ1jQP5HTrbZOyxUJLUuyyXun5Eknmez0OR6ehYceBy3Odn4k0TJcpKmKpVmdZtxRN TPDIy0FwHVPpjglCtB98Y80DAVO83zdKzC+aECljBibEAosoqYHL0Y7mVI7HNVSq+jJ8n0rXJbX7 mOtmaGo6nY+SZPMjl7Jheb7uMSolQ+40IMPxFyMzAwssu5bQXOiFeTWyVEZVWUbgjjvDUPg4PYqn pMUPC87UxXBg+aUoKBY2wej2ezs+EBEU66HOs9ZMXJa8WgVOiajlyYykmrQrQU2ldtTSB/REPArA pViUy2mzovbnMGq7t+ET15BnhVTetdGiFSQtIIgMgKWQinl4+1Q6q1PrB5JmkqZrRe3t8mD19cnH goJeqaejFtDe1adtXCULqpt0vcHDvYAyVLF1RNpw2JISkZMI7LPc2d3Jh62T0MHno2z6zFxUtU0Q QUHPRsx+RmlC5QXFYLFjRZqEkmo6Tgf83LC/x/j9EJHDlVO3LmBrW0ZmMIbKno8IIk6hWsEHYZRA 8nO5fRk/oOehS8xz9gyPFwwwLq4QhEADu2BPAowwswFuNNiV5asB8HHsIDZw7Oyp8Gi5KxzkGysx zhzRpPZCSvf5MYKm2rkaeE4bRTJPsUomFqULnd8iqeqxfBc6Oup00VKl/OFE6JjObhALEzw6O7E8 lTJVQbJYuVJB4UqK0CkjOguhBYYWpBJ6NojXYg6J9wn/QQLwWG/pkr0b+5mxU88HHPRFy5kylkai TDJMl4cHM+GPiZKoQVPdRrHLimDdypvQLjVYQT9hERPCpXook8ldbFg4fF24IZNx2Wc2LVOhbEyZ kkGjJUeoOQQMOFAtMj5PRBoUtYcsYLnRsYc1BrTftYvqTSo+419knOSYHqMUc/knORaNuJmTdJ4S OZ8I6JOOkmUTMeOJ1e6T5I4HaYgKp23i9y2mtO5W1eB0qcA8BYulF5PRJO6Fo2eKMo+ETid8PgZR O05w1SJU7ofMLnN2mnxkjCHj7I8EJmd8PUUAHFCAiHMJ+KPTmBchMPA5+lx2VeUPDp2wYg9zyTO1 Zu94naPyP5H4j5sJXBVhsyYabmpYquqWi/Yq9xVrrNVvigdSvO7vXN70q06Y3qq91rc0aCZHTGGc jRfc7S4hF9zvO7c4YvOyRL6XUiJ73vZNfmCTvj6keOHzy6rrqn2jNROY1lN3jDadF4Sb7sjBkGqN OjZvKaZTNaVGbuG23Tu7CjVS8iXe4hdZT7RN0swhqXARkXfZjq2YkUd7uWZ26jTcd6jlyJ73amW7 l6Je67FXi5QW0jejKQIONfMPfcrqiFPTwgZdxRPKFupeAOLErcwjlZEMRDBEExQqUmEjCJcMTEku tdbDPs7MNMeHCvrnQpavursZVM3l6ek3RaLUGBUqNImZr/OaXuqFUjkzyXCpEZZTRuyxZIG7Cdrf AjX6VW3dOWRdlHdrwSJhjsz6YZjjHJsSyiIm0uAhwmfKIJc+opXNbIyhho19MyorASRR4JJmDnJt cdVymaLtDaHYpozed51L4nQhX+kJIXooULHs/WB4xI1JXlt1mliKLMbcnXrpwhAR2QStWLSEYSZN kRNB/MrO9ZuiXYAZEQ2WJRdehTDP3i2KNPeYrTchCiIiZ4MiISNlJm7I0zh84Is6uSQBEZCmRq9e hpKRcpWIlhmM+O+RtVVqR0l9M5aYyywUuiglLmluWJN0f1xg6YkYNnRoUkdnhMPmO7SpBVtE16Vd JJVZkinUumezoCAUJF5iku5hIBBwmOtFnctO8gqeiyA52qdmz+RcyXvqu16IWU6l1sUcbEXYXU7m m+UILszBlNJXDghLr0FvikhUps15rLy5UbiCQFUY6HI7g1M4LNBQyp0w1SpV/FLrQeAiLAi2ZgUO InigT7bLy0feZLMfTDBZOwMFaKoquKM8ifaaEzkBmL8VfJNZvBwcA0N3HAPtEcJSeJFEwsZHIhgz pCDFkCJU8OMWTT1YooY0LxrdjyXvnLEqnlHiiBoREbA1OzZcP4CRS1t3NBih9TR4VMmzHuyF3yfG wzBU8KFCpNjuR0IFJEzJgxU4OlDGeEf0RDJ4iH5J6sTv68U8Hwsgj41Xw99ypJNkXRETVbFqT3gR Ar6OaEBZfD414TPZwytvZIIp6XfZaazJ/FzZJTXG3eKxfVat77SRdfbtbZSUKoB1Ck5lpsiErVuj kb4c5u27EpZn0L+ZbwJCnsv6vd97MiW+TodizOcONTffPPKjcRFRUdPB7p3NOhmmplTojpEISpHl pm+grSuQREsUKHCVlSp3lAWsyLwfSk+E94Pf3vyacREO38P0T4/dSScVUq+dCeHD0hVdjIJMs9jB MfsuSGkObY9zYqTqKeyxrJQX8FmSGGM1bBuxI+atOhSr1brkmKyqwsuRAkmb7Tu9qZJEy50MVJDj 5Pm5gznLDhtxSwS7PCBhzJYxVyOLgupPF52HkpZDliLHCc7bo+RncJUhnYllthAYqwIxKxaqpxFz KNqibjPmnonDHTpvhQ0/bi2RZXfIzN5HSUmyWqTJj2eYeyR9CsBT6EFCUsGSZj4+I3pIzotIPoRL mhx6i1MmjmyxWRIiHg+Urzr4d+GidBSpscJFzopBMxk7JbpbxUPRh3MVtSrxDu1ypek3UseDDVUg YedSfWD2tptkemSmAn0fRs3qMrFxi/wcpOrUdaVLcJuXofBmUl0WK4qV9HBn+PZwyaondZhQ7CVP wN+++vNOjcm6cVmvd5NSTrEPKsFa1tmXXFo7GzFSlivw2qGDOvnBanx5Tmi5m1TPTkyRKcGtfHT0 PaeEGq3JuT0cJS52dmSkhUkS5ctXQo5Ug6LF6mjA1HAFBSSiUethEAz6RArEgPyVKw0yazH/YRAF csc6xeDRMalBiVzhgsX4aLhc89SLGDR2ApQ49iCV9lRzRnO2Z6CmiRMsbnhSQYqCmjQWKHBi5+b7 3YVlxkwbOdGdCyU22KGRbHD2MxUwXkYIu3QxDFShIe+SKFhs+xTBgJAyIWMVlQQKFKSY89evBBKC 2BllY8rIuKTAMhjQ8O09D+yQybT0A5osejeL5wTIHZUwUyXHNilSR7LJM2OXMG9WLTO+8EHP3qZS 3VuyFOeC+EzFqFik5wbF7iox3QjIXJdlZvoW55UWmmJYWhIlAYnWtFkaiseVKG5YZZPD29vlnMJS rL9UoEqNB5ia1mNpg5z5mdJqalpgmr7ikvLrky9qOQWAuTKSOpi4KF/kapgt/X4HX115pOFY9/Db DHK26yrJiNyjiDOsJmsymknkPmOoMtTQoSKBIoRs3j0fTc5lG0WNHJlpmjQpBYyW4r51m0dF9HX7 pxhPp56w0+YfFJPLMnk9r6mkymnV6nW57U3h2wdhHY6NPHsvPo94+8PhHtKR5uUj6HoPXJPRojk1 2iEpF0DkfDYGdHwM9vQcFc67fHbsx9fT08LrLO2tjW6E66hLjOr7QpZVUnDvsjpo1N9A8GhbvZXT ezOZc7BUZsTMxfe9si5ThAbRt9xVeM4MimOnmoaQ+A84ygAUYaial1ObqLd7OaFsd7OGBWuatAgQ qzKEZyXFjaipBZAzRlvZjas1d5UXSSCmTAOSzt1uqcxYleEXkWQeUqBd7SZ2oYoxZyo1Ry2xcJxZ GKAnaW46iHRu7iGbghiLQVVd3VZu7KB1TtOcomhyrSqql7rmqh0rJcs2/Pn/B+H7/Y9p837kw48t 5YGRFvUoJATWo0olsCixSxBipEQYViCW0NChVRLIqUaiUQRB6J/YlDraX8v5HJk8CJ4jMhlUer39 E3tZWX2hToudEymaZFQMoIhGCqlfPYp/OdS1CyIh6UWxJMCpuEkCUGfQsk0Z0OUigkEjBNGWNZDm cebCcPwJvZxaQXa7ObLwykyicVoSySoxcjVqpZhCNHBxU7HBdqz6ZdWauZudouyo5Su/k4aNRo8V 5V9r3AuZjtRV7Z6s3Get9UftUJHR4cwiQCJSdIgf+iowhVWFEIWMzzR/VemnrXhPUuD6QRRTAzqn 5KAkAr7P6HqqnKICUUEUbwcHREe4pJy0kJrn0xM0WK8IO2mYJKpdTBTzxVv69QZoaYoDe4WjC5xL EQQiI7tOB1UsrGqUe+3lrDRh0HRC07BQmWu52VFKinVzo4YcinkmwXL5cRK6GRMjEzHBVPmuMLYk K3gQIgwSyP6xBc6gc54VH4U5EtMKSmeOqnnixNT00oXklw5W9pc8s0Wu5Yc6P60sgFSyYvVlBMH5 ogU/chInQ3Qyfd+S+T669HDKZltDN4JNFil3BdFDDE2KJRBJIiXXvpVrSoxIa1nY6/a6N6IJfMqK TEx2McCyysmTKSgty7grTinagHG2M9GXFKVNWGxUjcw57jM3uUrD0JaaXtPb2DwqUaPVW+N5izM3 DgNuMiEySIEFnP3IyYyZKwkC1MimMDlEYlIZEQqP0Ej4rPg+yQ5+IYPD8EKSCuZi+vq+jRIRCWHe YaYQxpezhCbNqiCssx40mWT3tAqjQrtphD5kwlWllEvcrig6fMqPCC3tUmoDZBJIkD2HyfjNshWg 1foVOvg0x69Kvs7Sp16DYqa1s3vu/hkbvnYWJBw+aoCJGLGmQ6KlIQRJigiIhhU9DLJj6Fyvs6vr Yvu4eq++jQy1964x3CFFPlCsnhqzajrrwZ59uOeifqa3fZ6nEDucF2TmkJY9YLgx5mG6Qgvcqd1S 6jrMyuTIopKLmSHHmRozkte5uSVJFTKhYcuSqXOjh0XL67GOs3T8EqahTry+47fxaID6fC7iYpSl ZVKKzm0lR2sxSe1kiIIJEi5mdyrFfBWFDrROpoe/x8QYLlSg7FA+VG0qc2WO+j4OwoeONpfXD1g6 HINedaPX5IHlitPf4ogPI2ecULiwo9peVOkcpIeYhqXZa15D3sXMREjxV6NuNqrVDBc+02Bz0dxk ct8S8+KEudbv9nuC/Cx8Hb3PVgsWJR2pbRA/WxRiZ9tnaXoWgDah7gsdD6NzMuGlLBw7xJ8EpoiS pPqIJRJWo64ZmnJ+ylKzxB157flSdmwauijmwkSJG6G06mYvvcgFUl1mp37n7MeiilHd3ykmFG5U 6Jp7LkFilxSTkEQOUqOdlwqD1O0gSnl9MH7xEA8Paq2L2qizljwIioUytqIedYiAVluRhZRgIOJx fEUbF46/ayZ7Q6gcYWEtiRyK3kKxStMyLHR+Baw5MZL1KjDW6+3ZoFFPAqavosPlS+SJzHTU8Ez3 gfH5IEjfnmjBiuTh2TGPsmzZ2SK+olwogFSSmDKjGOWMgyBMlQsTTwKro0xOEYgY3pLkkwiFMEig o7eiow5sXJQkbFkSKSKmgsQYJVMHNXcvThBsHikHDKjDmFVnHLQSyKVWRQuFSAqTJ2JD6K8kVIMW LlTh33iCVjo0d1qq8OEyxxLOS2nC9CDtypYpwHKkdJMofetE4NPexjxKmVy5Wu5M7qZ83tV6O5k2 fZGrBg2auEHe0Y/awYlIkGRO4zpHkzIHyoLzQ0Kjxsvsa6dmrNXXnFJx+RPBLhc6MCzLCkibsXPR WQsyhgKpS5slMqMVKmFDdBqbMEYLnha4h6AQ/oV/mJuENBq6ltR6F0kbJ2YutXUaBOgQs9AdyN6O FPbI+iNUevs72KPnT6RJg92Yd5v4CbAi7B4AaACJ0PK5Q0iYTKZHidND+rLbjxazd1zntqyqCBaQ N1wSjz+n/x9Jn6dMwkzcw8Aqw+M7/9nwTBMGHjNvzKz1aGWG7sw1uJvRwSCB0QVTnLZmpQQAzf3v hpycDyCwT+/+koX4DqwDwcyjrygzMT0MLiKA89gkTNXDwUgkmVcVAJqIn5Zmqy7GvdkxzTZIZE2A AePR+VRg5HGGTOxyhRUHssbOB9roIeU6joocHKIoSamkRhCXRE1Y1RL1tQ1lSbZSC2yQZwWiNUgp IvGCShZM9pCwl4lEmMjKSGabJBmkF5EhjEXpGeiQVJhCyRoVZrbJGW2NL7a4465SE1TZFpM9U2Ao 1kLIbEsYYwiVkbaoo4rRREvqtzaUhbchbF0Jjw95wTcpStXoXktFkIgEAiICTEEJ3SC6NdskgqaG 2VzRIiMKwwaZ6WwwG0O2Ko5JDpPl5Q7lWLsRsYFSfL3g5zgEx01qSauUjjI4cEgySDOuDgvImKah 17g7jA1Du/s77d6f6L5fPe1Kjw2Lof9Xpft/vVQug/xfNkCB1BCPQK4yCT/TSP1mbQ/AroGnf9lb fj6P7c6hiBWbWmMHxpiTuHxZy7Idu/MlFNrCo60kKz3ZP+vJjeZvCqqvx/9f+vxnriJTX+tfMowG fIpqi44mYiHyvqfuJYOKXxy4/LBi/tuPnEt6Kub0yP6/42xCkYnP/L4dDv7bd/TYSkOg+GZFVf+Y zAvK1zk/7OLAOUlf9o8ogf9YpHZOXCToTZiKjxiLnimPqZRgusm6jgpMP/QC35PXTC7x0q2reyAR sWOTIyCxGLT/SR9FeQb1raIsViRaMWNi6BFK6uQ4CS9Ecjwlom0QgirDrXPGhCuhPe9i8nFaDr1L y0PefkL+Gc2/OycRQfxvfuOzahJKs01Pye16q+l8FE6eH7b/dCFt+X5p790/xjqnloD8VRE/iEFR SQUSctsv+B1YYoYqn0rF6P2snAP7NoZyX3/0A/9F34Qd+8LlDARnAfK0vvaC3qiKXM4F+qLnCqRM cU+6DVJ+iqu9P3FpUkkAeWvLT33CUssr0X4rDgrUUC0GkJASRSERFkYgoRQZFVAFIqwURIoCgoCd 5AZRFYsFkEjIigkQRRVYsGCrFkSCCkQRGMBIpGAipIiMiDGIIwSCIiLFUVjIgJA5DGKIgoLBFQBF FQFkjGDhkgZiorMijVFYQwgzCUIIQoQQokwxFHAllsAwIZiCioqIwUFBYKsFWQFixY2IlpYSUKyR QiSgNWEBVJBVFIsiqqWLAGAwUEEgirArYkSMYIgooMZERUhIEVJFkigRY1YNjIqpFAKX/O7fZzv+ PmE/5YDaLWx/7DrNBWv8gfJQD2oO6AClGKi11gWG16V2AtZIfKRH8JQlkRKj/zPgo0Q/SAdjEoD/ qkA9FAKbh0j6Hj/PD5tnmyZyZ4BdvfqyBgGcTJJMApar3YTaRnkkiULmImkWXmUqA1WixU0qWEdk UUjGWSDQQztBKI1QwCl7YgjYg0sO28EkFJRiCoJszoElBWFg1SI5FROAVvqa79dVn7B41ttBLOO8 eP6OTrEM3l3KYGFtOTwTyDoXMNIiMowMrIMUsSXSSKhUWhMEMIk2RaIxRZaQqQtHCXgshMJFAEwq Qay0heWl5dnD+4+acEkr8CIVr94Cj8j9Ah/kfnULgwHi3rEsuE/EVwrYWECn/T9+QMH+KhcUDIpc Cf78IW5Q/jX6BiyQc8/4L4FkqLxr0T/Qc8i0lGDqnQwGg1qUQpIU3lbTeg5Q1OUMUOCfpBeQllCS WKit7STXHLBDqInLCScrHuDIfzfFc7FD/gNlCL/jYFP9s/ttR/rt1P6AkPNIQyIyCwGKwBGIMEZA QSAnNACggMYLAGLAgwRCKCgooEEYKQiwkiyRQQkCbhBGkBCCwVLQ3qGu8f8kNSF5zUOJMEyMhaCT /JQkf60p6j/9wwyza1DwTvCb2AfT/lHqzcGAxHhaVFFiH9VCkJWi0g8zejalCsMah20HSaFCIaCG Zayo2rYlgMFiwC0D/yDB+GMKf/J35DdIB7ik2GCAp+//X9VQFx6JmtVAU0mahRIpSjEIWKoERhKa cIGYgLXSUUDYnskJA7xESEiHiFnoTUpDDA2PWPze8vSQQmmBxOjPlaUhZAhGAbsRWmIsslpAa3IY 18rSO4+pAteVOXw7rYNIZGvR6x64bSQnfg7ssIrsJN+0XX4sGWt0QgWFmQqYZFBlco3VohQw9C7L EaS4NoLfuMxA72VDK4PIz5KVSjVEKWZKB9dmtB66BfjGbgEwYSRJtkYqTDIXFGkCTUBdttE0VJYk RRlkgf6TAYwhtPr1gmbgx49+bbGZrMTAOZYbzGI+4SoZhgXsSbTSQR5gMkkj7rSREwV/ejEWcH1h 2pxhjDY2+hNGAiZxDx4iRLo8jt+eD7b8cYWEekm5O7zxp9FknlrOHWZ6rQmc5IboUP+aGEco+y06 DHmWAZRNCiG90GlhNWaUPbjOi+YWwtLuCYMYljp2dzHhIZowTwJb7TxPRqTc7UdUiTtSyxRfQyQl V4FTdgajA8CX160GHjBtmdPgPVX84AGYF9pnAV2w3GA8f/TEhyARweBw2lr/7uKh/4kUOVtBR/oC Dmf1IN/rsXxhtdoQlKU1XiWINSglcausmdSaIN53uVtNaIWi0tNAVS0S6RvSlSVKaMiYkuhwD7wq fB5yzFwGwCqWAAVXxGi2KkSyA49TUpDkhp5gXD2FTGXXcbwqiL6dxire4GjUiwg0NIn3J8TIRgjl HlJD7I0PXPJ0ptOuYCBcDgFmFfMhkBuP2jaag9lAlGUUdShOqZz5UAMJEQwkEXmBMuff02bkNXNZ 2KLUUWoVJj44HoSYPmWRgo/AkjvRS40GjKCYziOEeIrkzki/GdfSUZF8B+8AEPgDDYdmfTaQeH6T CpBQU2tltBekCFZZE6+1PQiMgSAeAZ3ZcKGC1pVFXLXu6QyDCPdQn6hSUnajQw/xxIhSzs0MKHtA SQxkJA0iEe0aKFqHnZmgaQoMVR6oghjPcGmheEiaujqTgm2rJGEXvEo2vDjqk92rJNTGkWWLCqQk VIWU7ZRqnxTg32N0n2j/pXvTItVktDTklI7OMIlHgFQTW5HqK3lypQLArWsBNP7Dq2+wzIPsSoLd 6atrBLKl0vhZyPj8nkIwQvT09w93uwbQ4a3SyVaQao4JC5aMRH3ZGDUr4n+qTfAwjefKrGEpKR0t 2qWcXS+kdJ3h4A2S+BKIUYf5GtUNZiVKECLLSWiyiWkmxeXOeR8WB7ExSxLHchzgRKI0k/QYewno GuIyKCBokYUTORKWUmSaPchvuj8ZUELUUc1aZjMGJVahExwQgEUyQRjSwagrWiRoBiENgYoBHbNX 0oul+MpEiChEhWYMSYshXLKSL06L8YIZCUZFNgoXxQqqjy+ax8CcxThIqRPFPWaPBhP+g3zhJvIj YFyUWTGClqKRYwSJ3bOpeT7kqjSw+Qj6rucqR/q7LFVLtZDR9miY4QiO1zRuj736klg7eys9JH+A U/y7HuKIlT1N5rkXkqTsxPhOmlhie9mQ+InJM7AE0D2ZMEYd0BDvP+WAqh8ZmK0k8XWTArhtjH31 VNwVEO6QO4s2ymMkgH2ek7JOKEoR8iUgUH6R1aTHBLJaL2tgfE7YxhiI3ObRLpJnayVF5QahGg0W jkeIXLpAFNyEHBielbXQTwnbYurZKcDRTnZU0EUSnucpzTLCRnPYkT2JE5B0Rgn3cYaprFTiJFio digd8kwCyVCshAWCsPRA4DxT+3bvMZpVlrQUPd6b+lLtzGQUlUipniZyKrnL6RmCaZTqtAL/tvLb FxBkTE5WZBtY+NGAaxgFoBy1lAke8EglAiQUaQSjEZ+ET+WOEVRIiTRSgf3ogUPgJTQDNIfWkEGB 8RvSk5n1c51kknoOPVhMYjosXLuTkGF3wjKHsR7jvhk3my0/wko84kqUJ6E8il89mBgp0KtKUYXj iZSGAxQrE5Eokk9t8VPXKtI/a6+WTAuCoeU3eTG2H8aJi9VjKofUcZJ8665Lyyl5HhZYUkkXUEXp GiFSJAIhoF2JepUWAo1KBiJMosenEhSQlmBQ0ZLQsUjGxYwqSY1MmB3rDPVgmcxKzykfSpNIojIq YqtlCyeh4uURItSomEmIKRG8qAVUqOKOFyuOF5MTD9dJIXQ2ZsocjU2vLVNZu1qKpUxkWei0vL0k sqJoxi5exOKbxpfkKpbBlgnBEn5aQ4driBrsiN1QVcWoYIQHCNiYlI0QyhBy0KgVV3gh/zxG+AQ4 BCEKMZAVVGPf5YYIapUYRjIrqUk/rIX/5Wh/8m6HB18h3v5lrRLS0h9xKlE8nFsdqfZNxCeIib/s RlJGhxSby5ZNFKh6U+SbyyGMnBM1ofVpGSLHL4456v8G8ntyBhcejkQOoMjcP9TDNruA9BP79RG6 KZokbFJskmGEd/gS0c8bCiYxZxaYNEZAhbbCkW0HIpEFCBkBpJsIKFKKkQ5xZbdLDC6h+mEfF2dv jF/Q82UjhiggkMC3OwLHCN+0+ThYDH+Z6fD+oePUIf37fff/DNP6ak/f/Yfvaw/u/5v0EH/8n5JP Y2IEO7w8j8ocuXYj4KiA/u9ojD4P5z4KvMZP8LPjNob7MTbLaxTDKYTXa8bcWM22xWsr8n8csdZj Z9CYfebQ2hwM8bpgZkgDOb60iYn7e+0i8l/Kr55RiFSBeQSyBQGX9TE42zhDw0H0VSs16ODxzYpg aEnR6ehMOuTp/RePf/Cc7PD+Cf3hb2WW5vg/VtQC1+ANUDCBfaAesYMGJ8VMa0C9tuKuBf84oGe0 zFxYcIzjD/kkluNYwyMqrO2eS9haNf/JvJ1Ohu0TsSKoqcQCwPOcvKHxe6TSoaxMt2NFQUUHrcTY kw5ZXkrsnI7KQwJwgFHwMiotpDz6TuMRnJ5hz6HPgTIJQwZUZJIxxqOBTAo2v+4AusFKCBfpja9r Zsof8bZVbbTMHGZt64yQptLSlEREskKUsoQskLJBGFhaEZAoFskLJCERgyEkFpZLKgQpiXv0wS03 pMmUpLSZ47QlTXgWUmKWDCSBN4PP+/oy5bmjkIlOmE6Enq7g25uwdOJJoRFEV2l2nOwAehEz0Mn9 xwO8Ro4SeUs3kcpCdT24PGXBiOKrOaYqkdg7AyqFBHIGVbtN27AhjDDcuAXYpTSz05SOiZSzkCtR Ut4zxcjGMJ4ZkvEcdM+lduc0WYyzE3g3ImjBkHMBihIEkiiIowAdw9UQhxIHfwR4pRfVlbcEVjFJ xKQ5wAgCcBC9Yc0AgC+KtTm6TGP/GzQmUm7jaNpG9pZVlRHREcbSGENY59b3HNKKtJLHSRdFQeKh ajMlzggSB0e0CGFWdAW5i888xQqt7D11bC70lwEogAp9EnzewJueoib1ge3IiJQnnJ00WR2PYZMh A0j66SxgkHExyNRChaMiUGOBMgWPRCMg5iwpkAuYYT1MJjIsMjAxIYgsDlBDLcOFWBW5R/b8OsQJ EQ+ggWtFBdB/50HhP9Oa4GNH8tEGG8Q5f3LQmdBVSFKhrPjUgqiCkFIKQf5ILFpusCkFJIlZn/JH V/LHD/bXoIxij9E2Pomp1GIxJGdQYCb1YpIKe1JQQ5QPZlCKKLJEEh3Q06zv/x8P8n/P1cfzWbuI 5gNRIadYVHpIc3kWDUgnARjQ1BO+54cjMcmJsJjQf7gj2S8ZcTZ3F4QKj/bY/Mw5JJl9F7Z/GpbJ sloyVLlj/s7PyMcLiHDZnpS1ix0E/5Ild1NBwsZN7/NAtaXLatv7f7UyuvJxflxcTJbd7Vp69ngg J+YIiAkHosYyeLBgY9msh6DhQmSMZAEAzU4dVcW6nZ+yUOpHmyxQ45YudHCxaIMH8RC/RFJK/ZfB 1BlZlWrapIlYoZPj4uZmZOwiiVIODHZBkoj1K1Lb2WUcnn34dFzTVTRnZuxVHOEHDly5WYDHM3DZ LCqwYqsMsi7AhKsfaMYIo5SdxI2CuQXTxEEvVsDFvDZkwH8xOFzhky6MW1YO/v0dOGGGrFqs5lM+ izodUJnDMuIpoU/Edj1oUcc4UDqR4XJHeCpW7EFk9Fi41yZwY6DBWrmRuYG0MfOxyDZIUoQbMkDZ DNERMLU4cI0TNJwuWwVHUqbN/+hA/oiB3KRcDup+jHgpINKUU0cNDFpsXKbMnPA14WMi3NDCCnz8 zwe7B1wxswfyREjXhY3SCBehzejomUBinU6EF6HmpHhI6O9FSW85sY7RmU8PzETdhdHeCZsuaklE 4UQAvYkXKk7eHkEkwUFGU7MbKsSLB1Y6LnRUqWMkj96AiejBT+WnNbNnt9mz2HroUdbAp627mYL3 2aOz7h+aJ9EM/FWA7FM4iUEj57HDoH0eF26GOTb5nDkg1q/gpYwEzKLjQoexxhzZtjgt3c9Yyjkh 3MH5h4whSe+04LbQ8p5GHJGdHNlBjhbmbJs+C1yhzzxznRKyO5UqV1xYmDo0c1cHVSPaHw+fmVZX /eiy1ryksehQd3eHJIxIIFgCQ+fJHAePfoNBrOLsTY2Oh159FZxQUl6Bv1/SHLs6DQKS0vsYZRrC 6hPukyLhssXOqHbmj94+S+CyhSh9+kE/yQ/aiIh7RCjWuM7j6NSOiCZ3gqSjhKx0fpPpzqzbr1ds uzY2ctnbwo5MqU7rvRJubPwiRN4vNihsTMMciscSMnGUXlE/JEzBUvRBV81/CEBIHy95deNkm/vp rOMgcIALMZIsALCFhAKRS0oyKyl8VbN/if9vd7qlm4NIYmnIU57bGhrx49DoIciwYrKCw5olaQqW 8kW3NQZyYpM1t+EtMfwFI8zWlmymbMZA72BDmmooLMajGzG9YJ3Mi/hYfPpBnEimcRJIewD9flh7 UzcoVqoSmgvTKh7oCH6psgJXTzF6F5scaOh16SOUCMRzDTeUE+oo1nUoKTmcyvkTNCTJXg98l3sv 0c3Jrw3ZMXkYqdlDz5vBNubi5Nzdu9Zl06/FdA2PLx8nY3+tVj4KS7UwfsVERs6zgYVVqsZb5kgY nwISTW8UYtKSpyZ1BIg4TMlchkyihsip6JjG5XxTH0Q7fsrpP6jEP+yB3vwwTPZUuMe7kHlZeCwM TlIqYNGqzfViOt1ndpV2JmqntmL9ho30f3YgKGaGE6h8WIH8/y/7ysJ2e+h3BxNSKNEVBovd3pft Q6QEWqdIf+ARLxh7rJeFLCa/99/X7f0nzRVPFgeQYFPIA+anM0E35g+AxJSUh02aJOrN0d8VJ4cL JPWYLMELJDTLQugZ6km+XRcHxA9Wb8nDD0h+vtDoE5CeH8ZJ/SfjBCgJQZYCWJQS2SlghQEsEKT9 xIyUwjCkEtA/wM37slbcJ7pnNWqrSUtBQWkmqkiy9pIUo0glslKNglgIFkEoAySwS0kpaFKRhYZA /l8gO3B7aQof3PCokThRQoQZCR/TmzxLz7Yw93RU644AynTS3NR4H18gwKpaR6EQiYg6eeJZIASl KFAiMAo0IHw5gFVqMTKgmJkgh2QILyKYclpPjcN3M8EgzJ2GmMUkUlUKVKF5Rl01rO6QZQXU7akC QD0gp/4RE3Jg+5TY/cxFy+tPtE+A2GYjFYD5MCiqYdOQai2Dt4R5WJkfJS8TIHtT6uJX6HUjpHSB p15E5j9quELEeanugvHhWv9UneHr5R3/ij/KTp4mx6D9LXl9MbVsESgUYN7Wg1V+OIXGhwgxwf30 S6LWNg1KxcELMzQQVT5dhYHQ3nhX2QHxgMpzNSVY5Z6HikcpJ/2yHfJneKjapx2m6hlJEkRXIMKA pGLPsDedIpadqQWCMGZAyHiknr7d4Mn2Q8KGCaGlAYFlaItKkpFYyhluoBDUkfc9fgIUZCJIwKUx rhRNAHS2WnFU6EEyCVpoOUVRPRzBgql9GrCC1Ipwso2MSkBpBghI2CicSZkANZ0H7I2WayZd+L9R TAPRpBEpw6FByVHcSYpIZRBEIWe5SmYUyYlPlvOD3ckCc78I85nEeCfn7SQ+6cEgsNieWbTfa7GZ 2stW/GWYHF5qvLtUuuyq6Z4tHotke9MUhJjaLRIevR6qPn0ChYAcRQPNUwmNIxMwp9T2B9AqxUp6 z+dm7wpZQoSvXQsWh4ngkWB3Lg6Uv9RgMofDB2ngp1m5YvARw3IUM4n5XnUYEnKMoUnmak0C7xW5 Kj/DuCq6weHBHB32FKQ7j+Do4CnJ6VvLw92Gtvv+Hs5eBturZ1cKP8asb/znvPFhVDAsRBMnoFCn 5QV5UfjMBbxT0vdrCfiswarXaMXWQz28D6vU44vCYubAbM6U2TKuFfpz6k6OYIPqdeEtgx9hsZFJ GiMGDs2ZLULTMSlbylYhW89dYn2LTv16ocJ7oMU8xsh+TGex5VyUhA7YuYmKcOdOS66uXLHEJlix Is5tMHBSJiCh3xMLyUYMnOUK7FsG4c6GgqRM2Z11Qo5BBu45gc6aRkkdwXFLsXC3WimTA5g0Vlrr rmTH6Y/ZEDSB+9AuJJED3jHrojJ6PD1HvWTh2dr6b0e7EHfeTds6NKWGLiS4QdDFGOFzcHDJ/sl/ C/lSxQuTUsjNSWFHgIeqIWB5IkNF00oppHvzIyXMuKFeaDsWwbvMxl1g8Pg2xg0chj2fBMqZqgFu jTnQ1EQOHQHcHRo7JUMWOGScig+UzrRxLED34YJ/ZFGDtq3KB2gI5s0YLCkOIOMx2WJ9Cpy5Mv2K 5gCBzzdexSa+kTJ9QT2SO8+/uaoI94pBbXGIZk3GJIyH3mdBmZ508AsaVJkWXJPLWfno+TqQp0WK 3KzMFK17LkO5guKexquTVznHfbanMmUiJ80zvx4NljBvZ0cVKOGTOiZkpo0xo2YLnPipzoxW4XNo 5rtXNV0lKnK8pKTpBEPVA5BeZm+8acik2xBS8YtU8RDJ7GEHqKV8PZU+SVi+54pm51nI4pw+B9FS pkjKz6LYJyNX0rF1CRsZA/BNxgbtgucNbbROpI2YJrsFFKKpUggqQXL1NgVOjPXdwuY9MbJiv1at ddvKR7TtkOw+NEk9ejh5c4Ym452bFoPI8mT4WPTpk3JMnx6qesOLhI4+Vuc+Lzg5O2cm3YdF27kx /bUjiPQhgkRLFl8HKcNTildpeOKWfkZrEePH7GJG0KRi7FT0fmvX0vg9lpEgkNljn2JGv7Bj7UO+ GKmpYsGHJss6tF/wg6OROUKMeGcSTsU9y+CmagOYGPfYxI4O7MekcbBmXZZ0wTNCukDlRC6SJIgk dnZQ0WKqhoewWL/rhyMDnrRz7Gwx13UZ9lztQ6I1+Xz0Rcwb0dGTSmBsilalgqOVJnVhzBBIX0ej J1U7H2bDMFN2rRxdeubNzkzU2b8l7e7aR5iH8MJHXnxsKy7zqtwJpNRchR5U8jqYR8dajLKZYVl1 hQQIPuLzO1xgQ14PGrKBs1NmosDeyqsqHboPcNuPIGRXsgVG+swIYZ3D0RPyiqL2IAKBmiFE7dZ1 1ShlO0TvE9jj739LIlBiTY1yNLiKl5fedSYQChIkUsdmLg4fUYuhX6FVMFfxKl8aLlhTF3BMFmLl xza4OWZZlB+4+KPKJ9DF90fqwEcz75J8Q/RWrCeEJPnEfRJ9Pc6hjJo2sWxMwAh3PND7JYWKo0sg CQF/moLH4FFFWf2LT/xX+1YZWD+0F7ffRJ7fzj7fQBPMOsk/efqGwSjYJYlglGw7B7ztPBLw80LD 7fIsfe7VOj/Y6zL/Jag68AAMIiJCCPJIIGt6yggWIp6fUaL5noiDfdmE8A9tF8OgNqPyDOoB0JF3 g4X6Ce0Pr7wMN6uwbTb6Hp0ziUPEKlAqQNC7Uzw9gfJQ89aHcpRH27ACoutdanLqX1AHYhutUppX Ux7hQLG7/C04jjV92U6sphSHFNYfB+qYYmJ8O34EoPz2P8Yd38n5LlT8qspasHYHcUood/uCjlMZ FWnAwmElEhRhQYUJQPe2PQjADbrR8gItMZUPyeYOULRXcfY96Q2J/Okk6waGtz7bST5I3Nj1Qycj aCYhOx1w7GhIuQzFGwOCAiGmAwqoEf9ioktSSCfh2PFDg0WK0sLQbKJjIQhSI9YWpQaIARfeqZMr 04J8T3b+WdUKHtKiHP7fNYXpOylBESQcsBcO9wH3D7GFQUtEgKEFIrBgwsXZPKD0CxA8AySOHGdr q7+4rtzkT8+1o7XixWbP5tMXkl+2iCmBaCqZFK6GNC5Kp/dCxdQckZPuTOGRzg4uii/5XGMTPx7P C34Ac7MBs2TNeim08fob13Dw3evVqvue8WN5qTmi7KEL69euy0ClaDjDFNGjfdVWxUyTLFj/uggZ mS7OzTDYcDwkxY7NlRzRpKslDh+QF0vobLlwySMkhyAymjrJmxTu4pw/uiOHRwolCZU4pqXDX+U5 kiR0M5kc2ehAOslRjhehW52XF9XKWFKFzs9CGCCZgbB4MfCSHPRQe5KQQfTMOQeCxULDmzYNQwx2 dpUoTcHLzIFGMGLsIKdy7GdVFPukLtmrm2YLOHY34tM6MGGLm6YNtq4LVB9P2pE75PVGLho5ub0/ VzJ13Oc+z2VIjYVS983GPaeH1M60XPpg4UPgvk02TRI+x7T6iICQTJlcmyDhPom7HD2OOIaKlhGo fQkVU/UTBSbFyRYtfyg2CZII7PVhy2hyxIxBWQkFBnL3JzJFy8DkEV1Ztu1ops2q9mqww3P2vajn dRrtJamTqSyOszweBhxlI2SDpR/r9eE0QSh3QbECh0WN5HJRHo2UuxggsZXlDRMUyULGTAp6IF9a /TSHWzjNaxvG4OixI8bvhsuTJDDnZq1qaINU0acVJEGgtIO0E1QgsXM4PuGw+UD+aEbN2EHuezZ1 mYsz49vW4p6N+pEjssbF1M9ll9G7SHOhTR4aME2LF694KFBkQTZ70dCmxijG6VIwKWm5aCDBAP/V BCdzs8kUNSOox4FiNkuxTUjhB3YrBB3BIqXTsvuzBxWcHD+j4sfJ8vQhHj/m+nzPcYkYWS0ypIoo BlpgYGF+R4oxxfEdmTJnA4m5VxJDTKIBxInUKGCiRzVkoYqcUkyREeHW6wkWmiG/1lObKatBoNBa 2GwsLDgB0ORMkZChEoMB9JlZFgBaug51QLolGIRgLz4Kty4RkIQjCDXoS1PmK5gXKQ4bjAJQ2Fhs IcDt2ftEbcoiOzKx5t4Ak7CoeUVHBKjKLkfAY2cOGvJozYSUy9PRxdGLi3j7Hx7T3RBppaSQWSNJ EzWaVjyYrOTx7l2bmZqmHRmzPR6sdkXGKkyQyWIPdM5M2L49lkwXHHCZs1aT75M1rtFF2y1nNd1J g54R/wnv6OmFmoxoHt80A9AM6C/U3cyWmArC3jJXuQHwHEj5IFLBUofTCkyxlT4guVPDIuSQpQyY Hv93n6lcmGhzWehuvvOTqwdMCz8Ed0flJ+EZj3ez7KIYgjhRkgYTFkyWRIkDofPwXu7HX38EQG4Z ECigUZKMbFKDkQNGGLiq1xIk72HRnQqKgcmeizSY+Oj1y5VcFTjwTHyFKOZSXeEhMccsHaaVVHcW mcCoYSc3W06Voiogj0MTPIVGVmEeCPClbeVtwhqPHVmmIyalJQXw5yIOKYmRtSQhaOaoeUEjQiQM B5dKVZSovW3osdUFTYpQqfYjJ0VSpJIOdHVip4f2BPgujR7h4PHEssXtKqcrrrymCQdGFokmHgvl HEkC2Cp5/VAyBjAsRx+oX+ciSEgCh8xRq3KqWnbmq794UeYZraB3nh4ifpPm/i6eltjBG3RZKCQQ RQS6CSKJUQoQhGqKWJnWlZOChaWuF0O1QVHoNIiSR7bnl5WsUZdUEtJZyj2fgyPqeBJR+Hg5QPM4 8PDN2xM5sRoQ6Tk2Fh7lRCU8pdVoWolPypao6p9EgudkqGE1Rkfwag+8AjXCrZQqxTECuEcANS0z HiXg2lRkGUGMELXgy+GN/LR+yBgYyZjRe9VlJVuB9a2jCJxkRUY0mOhkXJUNz7k1g+AXh2Cb+reJ QAm7IiWnWoetD3DYn3kNONV2P5/4W1/E65WUhSSEpSkbkbAgVIhG+L7E8DInBTOPzSIcqq8fVAbK S3hFjS9wwqMJdKSFJUg/efsR8oYQ3YcXcygwSJEikEgjAMC0kWqSxaJnLEWTBVi8/caao+r2B+8n 1jUjsjwngs5fexTOOiPZ93wjqWgx/eiPxTBsSe4IvgYgOkQ8hN4oWmwlMZk+hJwehur3DudqUTBE Hl2W27BsFKNzbAsfhiFmTcA2wLtnt1tM2y3DC0oynzGGTG7lzaa3QDYYGtpmQlTaBLVkjGQ7hptS shq3alNDR0hpMZZgFILJKPR050y6C7703UoyY4GQdi5kMLLoKYaHEEyFS61homo6wywlkYMjjhIw 2dGG2ZNkIKaTJErNJM2bJtrsHY/bt2/Lx03n8tny7dHsxgpGAHh2YmNnoeJtgXba5EQmzP8sTc0A bdpkUTBF6MlC1Myy0hhUPsdZjiYzCAiRIEjYCkX0YpOibARkjJHpYoJURW9A+wyeYH1/ZJ98u0FJ eA50QvLfqKDWkts1QwaLGjBs3/nKnPtHRU4TKQZLfaxApA50dkCm++6EC5GJDd/08NCva36ggD8J rfZrXVNcek5R0OKKUkdY8JlvRo7MGzXouKWHMkbJlRzQhw4T0XFJmS2tlC/NDH9BFi0KM7NlOHUj Qw5o4TMyJmT96QdmoU6CFFuYNnexx0nbNdlNmSKwUwOLMe2BxiaJizHeiR0XbBswOUJlzBcUvMUz O0sldZ3ZNkixQYxBNJGqGjWqVJZK0LlTH+AgVOy8OVGP1DAB6CglAzjJ0O+jwYmx9z1ocm0AjFiB ixYKg5MKOdnDyhj5kdYMgo5uTlgmVKF7HskW2Vrn6Z4iclsc2ayd6loPux4TICom62ttDDtuLy5c TFrp7006bexi35gdusxFpliuZto9nR5AT7seggahokaKFD4KGsFhiZ336Ke/jISuSvgodHPlThI7 080lxF9nhcLWOBlq78JmZIlT8REtAQekPEKbMbmgxgY8bgpoqST2e+36REEEMdHOXKGC++yRB4FP TFalFLt0yQ4hEwCsxMykWnPFQYkZPLR5jcVzqKYGrt7MHewdXBbeXYt1nB0X7WLzcnlRVQpBYKIq zu94SQJ1D2nd3j4GuTbqXem54QIU+DRIXB7PfXh0h/qiMdGa7HHwpcgySJcOlGl8fHRkmeDmTptl ht/BqLfYRAGsVF2ej2SMinYKSOGzZupclMjcHhwdESmTJQqT88kj054UNky59uiDdDZBvPI0dCij kzaFQ311QkWMCHDJfwOzJlzRNZUStcC9EjBQxWmEsR24ukykptq1VBQsRCB1kRZI4E90YCzN3TRW I9iXMjLOWvGOEKucACghkDg0XUSUVBGBEYBGxuINqFlqlGg2qi2XOOmpw6Cw0mioV6bTvoqeFCxs psvUmQMXCpBQ9E5jGBwwSMOWdy3wxM+lLX+QwWrg3okVLFCgR4nLEz5jBkLTGagEXQkU71r3+xKN JFn39RUsVkLIB9IFRn9P3+gnAi4wcgp7Tr9dox2cThDbzOcOmxiCfcHQo1OgdyA3OmwtJDade1Ij xiNwp+cjHg4u06SoSbOsp2N3PVZpxwe9zzxTg6fcE0ptPEO9ESmF1YxIshcVEtjSPjexpVOkkPKz U8JlJliUHn43Ojcxx1H6MmfdaOTGMn+KIJ8uvNSzDgzYscVnVlW+bHZpm2h4zzJ9Q/sVrkVjJpnP DZImfQ9dFJHR8BQl7jDk5kB8hM0T9EiBj5+cBu4vwkxw1YUx0aNlplyRC6lmrR0yc+yFRVrKV113 5XdZkbSfYLPD61SFKRSvRe5bHa4YkpUiNHRgx6d/KwuMqHLoTDKBAxKTsWpqjiLycEDQQpGLxixu RY84DcC0o5cpEzY2RDfgUlIaDGxgXdyB2HyOq0/NXejjTjUPU88FsIwwpfY3WcXa6etfTz5b3htK lRqW/kTFg2co8oj+hFENbYcj/wBHonofXVZFsuE3uqPJCxhkG954bohld6FqJN1BoNIBbZQnJeos w2DoDAoZ1HPtNJSoagETvEPIfz4mBJ0GFOgOHnaO38LJFhQVFvFxUE50nWJzBSZTAuBbri0rIl3g THimR8RJ+80R9JHRr0wj7xpDdrHVoMH+0juci6h+CnqQPQUROfMPu9gPoEXxAw9MTH40tQUTBZnK epjnCgGQqNsbRg+LgcUCEUODaeK3ngtOKmNdCHMH6B9q5F9QBjS9fWJ2nrVPJDSj5wU0+BmX0Olh chCjCgwowoHh6GtM1d6PnFT7lO4NjndIncBUepujE/j4hwR3tz0RqjxkaeVke1zDpPIk+B5TvFRn y8e006MTB+pLtdzDWQKBwU6xQI+tetPZw6QXedaG3MsmrZVFEzBsLP4vfQOhVyKeKUA4qzGZF4hw 6VDYn5hxIP0AOhPNb1wL7zigm/OmJdOMhDF7hbFphQ58k2AFV+CdXFTtBDCAHUCFInMFXv7ns5Tc PqPAeX6ixIC4UTkw89rmIRb3M94U1Bh2y4mpVTnJrVO5+Q6efzh2QODWCReLkH/FU/kCj4Fk6ZEB XO2Lq6IgfOfWd2K581k10Yo2Hbx3rI1kpslEla7uOAaDUiu8KG8Rjr2j0CYc4XxeQ5jCAbCzknhj VXBEOOQI9N85YgCeAevKwcMWL2IdaMgechM5mAloeaan06zbV58rDba7dCzxejpI1DiQqFYEsJeC 6WzK2NtRBZ0umAkKoYI9nk41hygEAsDbVnHU4Eh3cUngis5gihpTZcahPSxAmZQOyZZCYuUIUQDT 1VwU1MTRJBiipZkpMeVRNOjTiyYo1JMZVBqAxgXI/M6LEwppOWjYoypHZ4XcbJjla+h3nTx8+M8N qQNhPNqsoztvZ3MNETw3ecDoh49KHHB4mQo9R6MiPkkoUl5isDaMUTmgbxJUGlA8dvAna7Xbfc45 m12Vs53BUWc06WVDlIiMZxO5CCSox36oNMbQ5MSdVTPRdVVEHSnk3glwdDsTF2LpWCQmanUUCQSN NJ5hMJaGpmh2Y8GPZ4O1PZ1+S2JTnspwF1U5bkC+IBAiC7KFiLTqw4oKnOIjLwg6BBDCKCbbTZEb eIZdapxdsm2J2vke6BsRwLQ6EarghJCYc9yVRwEC7FkGzfAraZcHB8Xh6DVZ94Gm5/nDFJFBmESy iiKCoVGhBlBgUgskhJClYacdqT9oHnQBHxkj3Agu/jCkpwbmShgZDHCmUwwYUMLkkgaYEDvjkQAo ySAirLElyi6Up2eL0W8Hg+kTxeaMHa+bVhw4vLDc8x5I5ljyalzylgmRIivsKhQcWHSB5Hq92qJM XIc+0vLaSRQhXaPL5W0rVKNd8+GHqu1z+c+yv2b8dK7neXHLy9a67s+Ma++Wyzv609INfDTu7a9I btZx5eOLWXZdnSJHjZDKiy3sVO0ccBzi/tHBAXqp2mAx9Xxm5Pk6YYXwx2G5FzjICVmKujQ6ICnB KnA46GDV8R6JPGQvu6VzXrbD3dW7hhg0ZdZI9oknv3+ozWITNGqXYg7ZcjXqKWsOfrM4YPXVOihs hh8GjBYpewpYW45Zt/ErfUQ/VCe9CSNjERg7azINs2fRASRLSpwcuXLnmk6HM0LXFDu1VNEcKjX2 TJGChaDczg9weCPqq2LDEDWn65VFOH6H0QLB6vxywYJRLnc8FCKGmKltlizClRzKbHOyKGW7ftxy RkH8/edjqzWtsnc75uhPv7uG1y7yd3Wdz66u9pSswc0/B1GGDRdKqOU9Hc39vIzgT6NjvvXr39HZ +C5Zzqzpt4esKrVouafWnts68bGVll4ccOfO7PlrhZmaaawp7LXDTfrjlF8Hc+K8otnKzpZVmdcq 8M664RfvbHmuuOzd3SDu3nPsq4Uydy7ZLfe9nV3cjduN12ltlnHjGboddp40cuznttjHhQuE7sqO tdtXXpjbyqlVBbpacK375xwmZR7q9b5tyffprCyyzpbK17r6cqase2Zwy13tzu07qpUv4Y13Zw0y K7q9ujdLKJYeXfOzDSvLs5djutFtStivZ2ykuORS9D0l1PBpji32fHNykjXJxRk6xw+2zVHr2n4J /EJdnVBj3QyMmyp+Z6KjmyCxg/HFxZHj1SJn0ROpHol8KjjJ0IdVL6Mlig5exk7yIfIBZEkHV76K Bs7lqlFOGSxwnkXGyRIyL4bsGzAoZRVOhvqdFamgSVTkfTvBjH7Sz4E9l4UWoW1DysrcUuNw3DxE NMs6jsoKRxpKUmvrHq4vJRL56FI9qCkpJTIRqOBSYZVmTxja80J1k4WovQpIaRYAfJMcrUwOfDDY 60qKWyNOiT5ngk54MWThu5rmWVNuxe67gpDzVyoY+AmZJEEypIxU9Djkj67PcHlCxFDAuBoqSGMH 2xUXYdmoAyVvWrkj4wK193RYJfShc7KlhyuU3i+PRiRTxbH+H7IBzhs9Hs712bDNpKlcJgGGI57+ zj2eEsITtB3E8u/dZYUaNscA1Hc0kZ6BBQQV7Jf4ZxzkmtRB2UhUoIgrFgxioytERKwLKwWCkiyE iwFICkFEYopBgsFFigoAxiIkGMRBRGAoCqQC0tjERRFALQpGN8J4QvHPhYeAJNgmFkkkDYgKooFi EWg8EVBjiQzKYgK1OVFu0GABMxRKIkVyIQiQYUVKJe3DcGGoO0pOyQpqETRNjjHgPOzsYjzyIhM5 9ZHZUcrLYjinPZfgLspU0VwmQsPZrA2xN0UhBHpim6KElmH/Dcj6USPB41w7XAbMxq0Jv/qlLVUG IRIpAar1JChIgLA6b+jUUDcZDv3lCTQtMGY1wKIlM3GoQFFGrkcSkIG4yFXAgSC+yRg7r9y1qm3P oPOR+HnZg1Z7RskMgn8jjB4ejUIxYucPD4BjpypNyZU8LkiJXQocPC5WZS4p37QmW7Necxg9XlIt yhdCux30QyGgyZMuCZi3YPVmMuwwYzCeSWhFVLXphzR5lNDk7lYfsIvkwmckIUknGZoUhBjGwgkC MgQgLYRMYdUCWCpYjauAE/mJFYRJlaKMrapXJNenHC61Fl/AtVhKFSRxxci7Q/COMILkCqno4Qjq /EelizI0SDvAkQRi/86TVFMUqjqikWecgsomKUvn9qGgs0rNQWtShSP5CkAVCptU+5eajlQhiINs yjVzUA8EL3c1DMkMo57wwO8HtXPdteTRu6b2cBh4I9zm37A1LO/u8Dm4y6QpcpwO8Y7zwGKpqYOv 5v7dlUFBVPoqiifqX0IdT8MnD14VH4HdenMvN0BUoLi8p5i6YGxE1GMzIvGgPEIDJph1hs1HQOkS HSl/ZZvRRMKlEX9IwTeTyIOKhgsKS/nymsjG7MdSVK5wxmV2GgrtlNzxOpuc+07H49kPy/tXHBN6 fjhj9F1iLNkPzOMjJJroUgd9AurRJvAxmuYTuTUb7P332cdYmY0KiaRLUQlAkG6bYeClvVTVTwVz usEELg6BzLzoYyYRAPdphRR9V3P0q8msi5+uDtLJs+/HhvRRrp56Or9fCZxxu9M+k+dWS/DPpVCf SXSN+mqz3sc508qBEAkYoHb7fSRfrLKo35GNzEfi6SeXqx9jt6Q+8Yn9o8E5dz0SkO6EqjnQ/ZzO t2Hx9DEp7rLMs/ezXWfVk9B8HKRE3eZxdrbj41bJzWeTRSn5dcI6bbuNSBm3rEvPVzWcG+/Ru1Yn bAofHyXWLiFtvAkRqbh5jpt+CGJORc1D5Hhsgz+R7uBkxlozh8Pm0fekFRIyNC/Cq+R8tvUPsXtX OneGtQ4GcXMpFfBNCZDQ878cuPKMK6OfT21+3m+7nfHpfZ7fC2N3jK5u/13nlElfvVW+rfpD24eu Xsp876bq/HuvusylXxEQDTo6yvc9ke58JWjnM1xlfVm5J5YMBJTglxERDgOMYvcEHOTrzoiANaV1 N/Fi17PY8zMa/LxSW13rNd43fW5vv9KbiHkZbXFlfOIau9Uds1zP8ERP9URAKYQAD0fxFAhvD4sR HydABZUhQ5gdqV9uLkh+yJnDP+Bk++n830o2FnWjo7jN3FNJA74yMnWaygC/BQTq0/lxkrE/Wtc0 FUKhRVFH4x67iYP8KNX8lKrD+cUkNxULtY4PbVCxqiaslYLPNkP1jKz1IWDJpm0FvvvYQgVq+NQs U+riraQe6h6ve0dpcTNJTDhjAoRYwmJ0pYMnd5/SYgH265HnaP90Q+A4M/l+u9D/d+WjaK4Ycgh9 cNuxbgiJmIO9s77hcsQ2xSEbYtCA6SlCkbCDXow1xxsUrAxSCyllkWCC8VGQLhjkwjBCJpIxkWUU CpH77WoiiFgKg2L4Cr8k/JpQ2809byXHiR3gBcgqHoNh6nV2iYhRwIV7EoB4grF8h/OflCNF/Zdb h5JvFX5usQ0+xfsOQHEvfZxV2+B1h2drPOHAaCijIgzIWB8moRUFewKMeD3kTNnhaDMYE+H84MVz 5BL2+PBwiuC3kAlkpS7tNi6ZsJJq1YHG9WTKWCrNgCB0kZTPRzJJ0iFOsgnDN0IBvsUIooxg6Ysi YUeIFhJQAwLNEQAYhnmQFMQ+BuGhndIfk7w5QsrlUqJcXfe5Qi4RfiQhBArxVKIHtLC2FGE/4JpU 4LV3nCOEQ3HU9Mmf0f0NZPMCyHmMQ+s+RAix/MfzFCU6M2DPR4UpUDVE2opA6RQKNixHpOdGhIAE IRETC9ACheRBZA6O6ErkutMTit5X1hCQ2FhWg6Dchz6PCVH46O6D6EQcdUKWeo48ka6i+BZCq25F M5OhvN+NqYRjlfLFMUvBpnHSYYc57SZJAaviYEHIkDOHMobJ3jkDI7UUacpaH5k0l/3UkIMIRSkB BJEhFBS8UC3XUTBU84VFiqhiAd8AImeDIU4UADg8QoFsSRhGAkHGugaGPn3IYkDjf0a2Jpjg5SYn WYzyOkiTSSMDfxYI8KRzOf/Pichz+MhiX5lk+NJCoKYu10d3CISTSPZkP7adpSdVItPmHZ/naY/Z HdBpNINon8GAnAKWLVT6mwbyoitG+ADBZlDsoFQiXigoR3KkK1DYieJAgzkcwoISSSDUQWcIL4ox S4SIu9JP3E6HtSDZFRpHOJ8v7lSzUpRB/C0kARjD+P4cQMFGaEsP6UsMlPYymAkWggwMv+0kwrNI SpjCRFjKCUi0tWCoMSdA94Q2D7p3B8f0fo6830pPydeK/DiXK8KE1nV2KOADQAlxjUAHSpI1PTzf tcV3KXp0Yv4/N8l2jvRru7rO9tgUMlbkyp/sZu5YaSVPMla/47JIcuXPfJkdYILfgXziSICkzNAq FE9NsBblE9kSwfmFPyRa9ZQpJ+5rXnlmRToyfE/nJou3okYFExAo1Jgx7JSOz4GJEuPZIvcdZ9hx J5eLmSQql+0D/BEQ/mfCdMiBzrjRAIWNEiSTVtmTezhdzsYTBcvYqTqLcgx0T7GJC3KB6UkXPOEj h7JGOccI0UHcgJkBiC/BgMxEYlReCtcZo7KswmeyhwPcy0tFBD0SMudkEzxyXDh6lvBIyZHZOTrn 1dTDgzdGN2e7uu4SImCPmwjrg0dtyhM8OipeoGC5MyOUPPM3Mz04+TmS9s71kwbKlTB6G5jZc7Dm rZRQgbPSVUwTernGNewuWPSlvGxnbZoaHLFiZuo41SOuvxT8v81Ndnh1caD1LolpyTnDqXo92T2X NAjoky58EptHwVYyUKofP+lCZLtuzh9HJXscJBiZM1OpMt2HgwpgsVCRIYYgsFXSCOy50bN1DRWa 7R8UnjrlgsxPdJH0R3Q7XbwOrNd3tmLeQqeHYWLlifimKey/s9lRdH390HNJstOdt3LGcmNoxcyp ThYvI4SG6lcGOhTP+KIlvqB9wb1s31DZycIgYUoQfTKeHnZMap793JFiTOUPYwXMmj0WJCmiD2Wb o4OXKD0LzLGTscwTnImSKW7Ibq1SLHQ0dIopYcbZolCmWx0bGKXA2cmHRoLmS2LbOpmiWyVjQrZ9 2kHzB81iTt00ktz6Nu7nwcXY7F91ux2y+RL3c0KYFTI/g/sUnRaFAmZtg+RDf6JCM4mt3Trd4G7B zayPJTjPRKAy5ZK3F1YroD4Fxp7u8HpqbFF9BsUmJDEhYOCBcTVRcCzpBw9H0+lbqGz5TJcxY6GD 0TMlQRwDnKyLk8RKsi0ThOHQps0XCZ11HQ3SObMki53MmQTMm+z+Jq8iZjY/UxzJgmnaII7WNF3C mi6nXJS7mXYuKnjPUfjHLscGTVu1bFBSUjhM6GPg/eDHBRJErFTvQz60TWhYwaLDEG0KkFjBPsd2 LakL4fSkyFMubPyAcoeB0gbFX4HHluRc34ZOomUmdFQ8JYM04qYM2Ks2rnKbuHRjqu0bNFJER47t 1D9Ey46d1Prble8mi/nDwIgr9v4edFBUFQUT80GOlORtTcTNigp2I0Lag8vKDYyLAICjjTTQiupS UTpNSRU8s4JaxMUpIXDzIRPROAIl9RiG/c1bu/g5rmyREdmzv4yYJtu1c+zRPiTwznctFEcb4I81 7QwPM0DxE4g0t1LuCAcz2T+WPbIpP1UoUP6mrUT+ayifxyxKyhgPeQtdv/mCD/TgwVKquFPjIvzS epP0CCoW3XKhUAQKe9jY17hg4Bf00DBA9CIVwlCBE969faRgQSDJ9ajpRB68gnxE2hh0TBiz7S22 81oU1DPWqe5PaesQ9+BO38L1Efk7JoNSPeXJrRoie9NYA/T4lENSdIJE5QA6iKpIgyJxeApS4106 QhAKSCvWkGBcXfsSZn7oj2ox48R7fQnJFLR0EP1FS79Qu4tFHNxU+K7zaaBMxvE4LgE96n7ILV1B Y/aIZlPllyDn5cRQPj0hDYn6D1Q/r0sLZZLZZLoAwyGUsLp9WDApRSjGRgSUkqlKkbh8I+Lmveau 0PUeX3Kbe/ij9yNgmg8QqJxR80g4HVwRzQ2PKH1euSZH298nKOP1jxT7V/BcdElgQYUsrGBUBGy2 VCsFBgAogIyRSfYhD9CQMEgiSCIMSG6G8naTuOdCEN1nqYGVx9SGjpGhbUUoRCJIqjLfZ9xp2gno XibC+wd5wX7nrQ4Kfcr2KGFLUH3I5UF0hkdxmpHYdJNXH1JoaOvm+/MR534IziVJEmNjdI4KkjMo GKgVUkk5T0p3KC0RL3EYkzD3uM71yoZBqHJJ2HAW8A699oGhdSuJN4WIakuEqjlV0gGbS0RoQ+gs pjJKpGpFsCkO7pSSR0J6jWSJYDoEiBpSGMWKAj2gOGMuayEFiyK9Oc0Z9pPh90A+4/QNgJYIUBLE pEo2CWyUo2CWJSJbIUpGFgCWCFkEsEKCUjCgJRsFZKixKWVYUsRUhYPn3OEjWRpt8+mpQoIcoFh4 idpq7UMbpXKORqBiUcCqnsjvPBHtjUzsZyMBQ83KEiMjXwRouKSKooRdUtFRkG6HbK8tG65ZeBsr lO/IvsQziZWCUHXV1h7+tD1UMckKj9R398h0e01hJtPefANzOSeEczpS8PRRHZwG0fUnI3h5JAwh UTIH8v7tIYROPmbXO8XkofeAnztEOg0eCpGKdInU9YnePHANAQ7zUAnkeZ6gjRYUCNFhQI0T7Hka A9m1HmJz7EOgTSuoB0Cu9MYHqD1puDA7AXvV5rlURuS/LmTQoXj6jzyBjSoYAtPEA9p18j0MS5l9 zjRfBdRmTOd5RLk6PDHPWbqyvE3nrPhCoVoQYVKBSTewFCyKkWSLJpIpKJGUJogcHJo11mIT2pmm qe02urGBOkj9GBgkGVmJKj2fmjBD0OEFonM71kqSXR0Rg9DwMk9gsjusuk5w9ccp1cZ1elIex3h1 GULb0OOigcxMKxHSOaaDVp0e6hvJvEzIrQG1YlKDzYCiJkX13ebyXzvXsDB3B6GXFT7GSgFHDQYQ yof2RTKPcr6gvGwAcdAH5OBPpKV/rk2CH7Yj+sih8YmUULlPt3B0BPb5PZ4IakCqewO86eYofqeh QbkLE0CIuAMYvilUHWQZCQCERZCAwgsFgpFJBSRGCwiKkFJNJKgoDEgsgxkWAsFJFgKQVCIskRIR QiCFhxNmT4kObDJq+dUbljNjRFEhQwkyJ8gvgXG4OgiDeQjKEFp6JYKNEakHOxOuBXKULCPsQX1s RPQTX8A8h8g804JYWIWrkUzpHGpngH2gRXMyQYDFjPgHEOoPSgfVDf6wsTqMZoRuARfem4XIG19w 69SB4oewxbySR3tB7J8Y0VKKRPe+T5qsUtY/e1zTpJqOA9Nse9+cYgwkoGcqCkyoe84Bx6VCnWqf RG1wqHBIhmIEgSQgQiChIDDiU0AHWv0FXsBOcV+fFZO6OgzdPwTuEcOVO2H3B2PrFlDvEynlfqUN L0n9fj7kMIbcIK8vrqMafj8fN/KqoOU6hedZETTB+h7f9x7JJEy0D4pH8S0JIe3mjuahmkFIlYd6 KXj9h8kfD4p6XakZP3Qlw/mHQ5nug0nL3LLuK8er9NUk+vWDkRz/nc2km0jQ/SG7X5T1zn+h15jE JFE3IdAOjYBSMicgiKEyhWFB9gWAZE/MoBYtFfBTCpU7ImwMSTtkuhY4encn44Yri6VYcmS1li6O pY+1gqiqkiY7oVKSxNlKhr/D4JBzi+bcP+X5n4gqp3wY2fNdapnaxhQGQUnNUqSRAjEWIBYQBFCo oUf3vd116sFSn/GYAOOtDGKB/lelBegDZmSe9PNbD+uJIAQIwgIaLlpob6la+zkKBQ75PkHuknoP tkL+P7/4GtaYoltdJUde3DX7N9tGtwqMGKb28Swm7CRQ9wAfT+9dNwCqdOgKAF9oPWu7xLR1rNyb vESwE8SAPi8nrT9ObAr1jC5MHuU600B+cdp81PgiRb09aWOMiKAe5YusDHjTvQwP5HUBPxCoBQJo DyYyLFQ1OaCiBDHR4QkQFQoRAvPNS8Q5xMQH9RVHXgb1M2TmGUDGmDU9ZyFqCiarKQnA3jTqAt7O 4LgapL95zAK9hGEXGpuuqkgBZAMEWhESkTvg0mz7UtSkQaCQfYBZZqAEKWDwgQgukYPRUDfW8yqk KPd4hQSBMTTrCtIy21x/mtAKXqXwhmRH8HdI0t8wWeK5Eov54K7JIWKRdb4aUVB8B8CWQSYx/rKG 1T/cnZmKSiilG/92SOCIKSQ8fEJWjq+v33njp5975khfBnkUj3So9UssoJsxlR/1xFX3ddbT8nMW DGBmqQpewzkP/TlrSSldWT+MSRC6Y121pirfpiznVJ/4SCbqhfZkxkrkLsGWzCXf6ip3Ko3mcSFS CJ4/iUOXSbIQN7S1kqT3+uxljs/I4ONQKqIhrrPYPZAtkoBTCeqBIQwC+YeQg954KrqEYC+0IPzP bWstEo+2tSVnDlVRGEIMF/SrFyyZqbMLP9tIPxSDVIL+j/uR6HxsIFYCVUSIdQHy/KFXsF7hggSK xQyqFJSSSyQUhSQVJUEEYKBEAOtYo0jFgNiumB9EPDtCesP0V8xwBjO7o9Z+osLc9vdSuEFfve/k 3OD9GYMievUL/F7xeVim4OlagJxIyEIsYASDIPVRogSMSEJILIERIwIoTv4++z7fs/YjX//edA/h uUPwNIBQMT1GhOQ79YgK3JqDwSB/Xcp9WEwB8cmBsIDBUtGC/qSgfh0Dvk7xk81kVQiWWxgfOhRw piZJDJLILaSyHSIQhSMgKdYMF3iFYm/1RcbURoDlw/y/P9la/Y+S/ZRaAFFlotZYw9p7p0X84Jai fZ5DkXk7Ido2ejDhSIFKKSQghBSAe9cQqYwYlNUskFTwkpRQeyGctCnlI8lz+YxBoGGiZnL5A+fx EvXKep/EjQYROkCBuTxSxCqxtTYEKVlItFfae0GIUFuXTUcgJo3GR+8TeNSCCBCOWnuJ0pcGXMS0 lJAkkEINEyD6+C+X8Qn4GnzFPsFD5qnBiPV1BQ6XIT6p9OK1vrMLiUu8A2gG3bJ9g4YH2a0OoTmI WqBoU6hLTpM4Wo8LkS0NAo7AvWOvIveHhjM6HevUjlwXeBUqbqcUDpAeC1xhLU4h4oYR7t3cjC1T s6jMCaxz9hoDEO9DYm37R1nSmddLvx9seoE7dTDyD+mv3wnpYxPfFSdDF8y8HYfR2o+K0D7Azo2I nuPckCn5IHvRQ6/wDqRWz2j4h958ecfgfjIxkfWJDyihNIYHoPk73oUNvYvD2r7UfBvNPgp7G4Nx 68J1geYBqneDpDv9BMi0Q6lDzHWhEQdByTAL7FPmPbJPL8Ej8R7d0Zhj4vBa6urwWNOMwPg9zFNx hUPkJxJ06TNy9dZrmQiB9KVQbiy2U9gWCjvDUrxPdYYyNgWpTvR3m5Q7Td3Ju6QtUsKmjYckMAu9 rZtCOV5AF4PSZPb0I4V4nam4A1jnU0KZfA1jr4ibBLV66DpwWZUUA5lECzKh0oL0i+LR1LmTcS8Q d32CFiJcIRQcJIOnSIWgvZvhniz3OefDv0QzUrPHPP2Pu3kRNEnF5nnHwaa7cOzUdFrf1h4Wt7w+ f0Cfjq7IBBqUX4QKEPjAKEgfOl4X095alJBelU5czyUNYdCPrOleO5e075H4Noeg+5ggsc+h3Le0 S8SQnagLcmvgczMvX3BUc/t2nod2Ne4DeeYubYZkSobxRz35V0C7w2mKerWqWmF2IKhh8CgKPgJz MgFfJ8eeMuR9FdHoudd4b3sExhhQvBXgYNZQq8+PTwXuGocw44xOCNwlQtHAoUXCLXUmNQ9ZrYST 2pRgUSkJOQcj3O2S8N2cLl3Qyk2jCnyyeQj1uz8f2PPzkxE1mA4OCSFsnCi8xippsooQtRoyQSBY 1BWbXDUpZNCKNRBgMSxRkY2AgsiNjL44FMhTpOp06j2qsVl7Xz2TSaEWURIxqIuYDyS8SI3hhYkm ik9eq0G01VaGFfsRxQhwQUCy88cPadSHIzCc0eoogFzEhFU29Ysm0oJzqE6lSQ8qgjjQT3Uop2Me aWnQvYFRNgoHIXYDpVOGlV6YqHWDxor1CD0ClBQNvWoUQQ9kBEFAWSKREEZFgfj4e0A+RAI5DHto AvUo1ioVaipcEQKoMBSKWEQlFaMA7CqUFOh5XOoKtMQf3JhAsV+ERdAP28C0MBkTzfX45PBqW0QS nWJIbj4WJ+/d4kADN2I8ewDxCaUDUOIOK7V0r0npinDzuMCfdGHgxU0dzvovLIl7rJWlJElClaFR bFUxYAZ7FLVEuAuQfKBtOq8gdPf9pDgDo9ErA3DaGuSwvpbu0okgKB5wZDzIw21ZsjtTACAPU0Ux xCuD4ZQwKFiHOZOE1ZYVRkYxBilS8KjWQEiuBVFSWDEBhEUZgBAPbToczRntNnhlQctZovJAZDCS JRUUKCBwC9/pIZip/Y/EK7Yot+CHSLSJRHMOXMZh70u8bPS7A6wcbPiBzYBlXZqqQgvfEKYC03Im aJewVCEAAhErYSC7YIb7+49USgkWRWZcwBMwFOfINH0+Zhj/xI1//dKbBf3oPaCjjNyD8g+dtouo oUUToNSMFTSfMOzD6kvO/AHmD+Q+8AitESFEYDQQtTqHiZ49MM49ZGsLnzdNZSQwj2yeDL1sggtJ +5/wtLN/2TQd6UCCYE5/j8QV0jZ1wIO39Q5QPW5FMwGVHCodYBRD1oxMiwUdTyRvJJywYcWkEW/U S4YOIYk7AwXj6UgyxKP5sYLq4qSZ3+MJlhLt4m6T4pEr6JOmSRtytaPqLbJBeOP9P1MZzoypb3bn R935Q7kuyBA6Lt/VxTw8DYOIDctp1/6yoTPqevoqKAVgDCxIgAgiyLLQtvunYk+9ZaLZTYrMRQKk SM4sP3PlVruoTWNajZB/Pir9j3Wm146uMegh9Qj1BDtS1SgG+gHvMBpQSJ9RcbfYUAu2LTktUfZa 7kLYiI1REvFAohmEzoXDtQSoH4/1pJJqfl8I2jA0FGkMG8nCJloMF/wkMov2JymRnXGNY5v5RUQm VUn2reHsQ9iUDsdBpNJNlluiFEtpQuqXFl2Fq2rGGeCY4dWJa7mYEffJL2LPr6ZC5k+cluT263va lNVLgqbT2rlk8S2S1ZG6wmgmpTBMNFmjNYUhzJQ2/KHUu5WBaoVSZClEEvKgSJ+EBURQatkN+FAK JfYe9S4wcdzlU6sIBrsTgngZx+ZTwGpYd/ETMhmTDx0ngGt9ypmEpsoFgbnGG4Ni8lc25arvNoq7 FTMhh6jpW03CGoMrIwbByIhhIC1yKWJQFtbOPysEH6dpTmS393kn3JX220CwSp/WaR+HxxAXn9Pd yK0zHfkcJhJQP0y+DgFy1fUqgfx0vMxQW0InBJIrO0IYtkhUQ1EpZVilpIJIWSJRsEsSkSyJKQ6k QpgDJZEo0BKNDI0waQS2TDgOBfxhsdd+UsLYHmU6l3r7XuE+w/IcELYE957k6yz3ieSJ42FkHCti 94iVYTDwK1oUaQGkoUKRYQZCACBwTqNZVSwfb0lgbITfu91KdmyWltLGBSykLYlGJKDZaKVCjKgw V4VKQVWRy9uho+kJ8NWydEqMIhXJkpI6DuN8hIRIgXLWAfQPiqWCgYUziak+Z8VaZBPYLdXC7BvD IXI81DnVcx4e1OBYgaO4JpNnQLYAWdCQ2fyDyASwFDKFv02D63aHWLvV2Bm6VEd4DtC61HUjRDUc jMQAWDwtO4Ah0mkAwKI8h1p4TqolENxrohpX3WcvUxcosXFmUlKycirVDFIKhPHqiZBREjamA/si lSCSooc1Ea0T80bO0FcoG0N79TzRt6fkh9T1h9XOOWjsBpSLxUNyu1uDQ+a9AOQMaC5kOYe+9Hju TgeV6fUJ9T1w+Bi+EniLyBzg6yO0H6gzPFuTz3rg3F3kukA71znsj/o8k+GApQoFLP5KbHhd/bcj SGGlPuCAXG87ASiloWegSBC0qo1bRK2JBjGMOiEPfJ+8kCMpCZJjxsn7y1H+t/p7N3O973tqfwHm 2KqTf1yTuyDBhqUoiaDHUDAZIBYkjQ5gWTMewPD2HagKh9nma/eFd2Dh75dXTUZFKBDKVBMTVrtC WympaQwmYAWC/mtNQZ/XGZs11C1luWQyOQL/GUKmg/LoG+++EDN7Mm4ioZYNxwZYXRcmtRiGWmRF hhnBSYRE1CWUDbZzIQ0k4psKLNE1ibGUuCl2zZAz7nGObZgsEZKyMGpUY7OZJTGCJcEF1vKZIY9K d53BwB3huv+Jqc9P5OLosdcLEYFBoMBLEpVWQBYfgUCUUQtjSZaW2UQENDkRuUooqhVALJCilKxl sAlC5BtFH8UifzsexA96UfelFwGI481fZ9dphw7w+QBm+C2Cwbb8Lq+Au1BtNSOZSjefYo/NS2AY VIE/lJ6e7qHl6wsbkvhVLJzva0oILSQgSCEaQoFnzIskAsIkBxsBYSEkC9+oXcbPuvD5FmC6XSEa QQojHxAZUK+SqLWSnzXCCzrJ6fXtqS1RsU5hzF5I5MC9Kt6GKJhEi08BqgYU3hsAGSSBsCE8pJOj op35hkZX4uGuS4KCgRFeVlogOIiSxTpVq0BXD1nOMOBgxgLBXUuMhUJ7IJhvYQtQxtbK10kXJukx iSEwwYFRkDBK1WUARb1LQby0nNGXKWDcoVPzoULlC+DBG5QKuQL7Q7SxC4kQixhQaIZEoncUiVlO NCs22vMvC0A4VUXvrwvaOWTPMrVikH84q1fAchMy9n8dJ+9VUHWj9hQuAE4YIqxF/zgI1ZCCMghI gEIyKkGJIkg5kiqMExUEoNUBaMGipRgtVYFBEoK/edKOSPFJJnIe2PQEdknkfUMdvBw8ZCU25RIq TFdakHRU2PD0x/azMc5E06FiKla6+2oWLQ2A8hL/MDvaN4ip/O60fITOeQubEvjce0ii2YjaYwgR Bac1/umw7E/befLkez2nsZmVoDTkfe7MYw/3XxI72HmRVMSP10SeVKjII+f5XpG/HC1TSZehBRLN gVX0Tia0uAiPWU9WtRHyPralFD2Begb38nBCgdqaT0URpXLWgJHQ1avyrWsjfC0up4WUlkLWk+GU SYMB8aB+K8fSHuhgfuMEiZytUpBgipS6XqRYVAUIgwYC21IpIJDoWUBIxMLUQRDLJAlNZKQILCSA IMQspJlJslmKNlKUk+9FF2aksn6A0EEaYAuKJVUDDSjSAijE2HLs6qBakIeooe9Woq3uYylUqpwQ x5IoI4V+I9h5eZnHenh7SaftMTKNoe6uMfX1+J7nIDYvoIdZlFcKd6v4m0PEB0YydxeYw6U0XAlz WiFAXWVqKsNiQWFCmolYFygf0oB7kJ94k1kKaSGO4MDQlD+f+HXNQD+/xSChqRhswhtmnJO+0S68 Ch4jnWblJr0XTFgVUpnGyNDExk+WS0EqanvT72swZ9q2getNIk5zD6T+eh8D1BbLCR4Bo9ZruR+E R2vP1yYviVkfr/BHYnwfcl1ghnze0Vd5bsURjjDWXmwNxg2HVQ3q7MW15YSpUHkxahKDTIugQebg A2peAWC22FhB8SzFUC5X1h+EE90kkC16+Z67NQssazyTyh3LxGtJI6SnF3x707oDaezdipIT90QP 9IAdCCoXmQD7Ddi9meu1fLsq9KPYOyPUUaPxPy5PMJ+dJB8pyZmJ6A0HgrxARoERT94ARVSsQDvB 4LzNDBO93Kk6x2yfUPE8IQuO9idA/zxcTo7uOFQMKPs4GhdeYsf3H02GZfHguAM3kWKvhAkoyEL1 7Tn1faBVBLr5JJhdB/T7FaOB35niW5NiP6nmaJEzSIki8PC0BenRompeqV1LBJ/hUqRUk8o2dJD1 CLJxBoyf9TKRJ7EKoMIIwAWfeqUBjtSG6/GFJ2ZCJGB4iSARivIUIKBbHIB869RG8G1UQMKRNKgW M5SAqSTaUHCg5wq/nTLEJgP6T8bCZij8ofsIlKUyd8DaKBpz/POAJc7yKek1qo+woP2qEyI3orxD KAl8gvJ5x6YkLQejUPAjQuaQ2/B9ZQ0sWESEhAgewsTrnbNYeAJOB8wfBy2LKD0H4fnI98jHJuno fD8KJVjZIPKUdP97Q/w+P3MTVrKlZ6Whb/dpbU5o+9wJShIP1U9YKM+eQOS/kyrrWcAnwpmgVIsC hKSSrEqCMrWz+YlkpSWB46sRm1tEqRGQIhQ6K0tknv/IjQD6KqKWIET6fFId30SqKaz0f3cXrXWq /n67mDNpoOYqcJb6/cvhIvb3QkRoGcYzGhEc4AahmIQ5kBTW4g6AJv2MjVo0okcIZ5ikFFEg3PvB ig8kqUe9/EvJh4Tzpko2Wb3/DbTptyIGlfcVSDpxQrQxFFe8T/FOznQiqSmucsReIl0mDU/zkMKp TBvqJ/V6k6ZpUoznLe8j+UhoPxbv6GLsH/cMD12nuDneBuSDY4KgHWTvgUYMgUpTsC2PYDpLULBQ 6HZ8hE8ap0Yl03HZpbcZZ1sn8z+Ad6OEVuNo7ADtKv6AgawsALUqUZBkAAgQAV7qoo59lom4Wffo NelNGeX9kOiT7Dpi7wclpZbnb4VdhYined5YVbFSAzmlR/21mwKuE8CF6cSWJSVXCDxf0+KlqYVC gfemsOtDZqU5obMQO7J7sHO/p+73OgfJ5jRcRsM4PEOvUNpsm4rx6zgDUOoL2DahvKMjDAaiQSPM 5Tt0A5nkhiFAg9wIqG4rDCS2eC2FAqDuE3Q7zD6Q3QVEPqDZJgbBrt6T+iCAnGsOok8g68iRDMpp Nute5DpbewDGiDiROlV6XXvVpCXkEObarhGig8TFoB0qfar98n5yZbaQxv/oSCggokhMCYpLvuiH 4fZoJ/J+3m20pWqjuBr+FpgWG0kDUfqe0/seuPifkeHvj+qPMP77p5E7+KREbD4N4J60qE/Gf5qL D5xyj5FzDl0toMsRgB0c6J79o87ULgwu+goGNbt2j1iC4u9D0G09o+ImxdhwUKbTPndibgN74PQ+ IYfRTSmRG0Dp6OZxUr2CeY4D5IesT0OqCC6129AeA7RxBFdCN4dg4IWJ24X1P4fgV/+v2HsG4NAE KENo3UrCTCWNi8Q5BkTaaBeSOkFe75ncvzAPRGzEJyE7Dqzvw2U/qg/NeWzZYnoENxUUNb1ECVBT tt3h/V8q1CJAl6pOAGITRxD6A9W5PUp7QYKe194HyR3Oa3ZzEzB2lnvKB0qIw+JwFo+4T93Qh/5Q y7+QVpNcH+qL8evaR2l9qQgh1CgbvXWzibK7s+z6wTGqYuxPki5jly6RLhPyK7h4rADLDrUpYqJc 1nSv3dkPYfbsNYSbo8GqbRhD1+gliZQypfl45kV3oexXeawp9j2J0htXimT9hzjwzeES78lT+c9w bPYYIedSb9S0HUBxoVBIKrdvDhiMUEm0TIbrXOuDFq0ydEV/Bszj3pPyZx+OEYBwkROke2dNvIMC MsUOk7F4+sK+3o7AuiyE9JzkPADart5reuo8OtU4bMwBbzImTQPSHJOYZWdQ4LFb1yq3mhZyPJ3R tJMfIXeMnd6ZDJ6TvR3GMO834j7vVDWR7TvnlJF4nuNa9CZ0DzzHAbFQVkEEbYivaG4oKJyXoTaa A3UCgByU6FexyBpQooeR0mreojpXcda3BrTVpTkrgOSncjkQyESbxMPmayR7E+POTf4hrJOMijuK OBSyBwA9qQ6FO4o5x8/rSiU9RJ6q+33ye2gUhH6WEl0BL3mGLmr2p6ehxG4O0BNJ6kO07zt1cJJu H3pPAOUTk+0T4w+Z+Dzetpo629j6jwD5KPT7Kh+e20ouc0pMKKRgwlEskVijBiMLZWIRcpthWZqh MbKVBFjJKlIxBBhBkRK1ZapQWSCjIoAkcYFEUOTNdpOj0awWQWD1tQWZc7cydh6snJCFSrsOhzLB QU00TQwDH9oG0+AR20QkD9EQ1JBNxmzW0sAOwftgztO5zJFx1oiQlYnsG0Lg4pnVX2+1LHaHoiD2 DksAD2wHNntF6Ubl6EuckRN7dyt60fboMQHtcrcp4JhtOGJWudHCG7BeHvfHS2mzUMPpZI9bCgh8 U9eikEEIBrJJSZhKL1RUsaUQwUAyeZAf9A4EBFIAQXAqBEyI0cCUSkr9HufBVh/j+m6QMWTwHAbg kO5FK/nuF5JowkkRDqRNKNgnqX5qV9ov1CNNitBN6HoImEtcKvtE8/cd5J1jPeCSHi4Tl6pLgFjQ tIkoxpGVIlElclivoZZ5+zOCxKQKyRfGNy7Xx6naT5QsCjOh6hFGakkn6kgLAU4hAkEPcgmlq84b xAhgB/VAQeyomsOfBO8iOjR0pRZISJ0mD4xcp1gxIQ7ANdFacOG/hUtPej9Q+3Xkc8c8Ka6e42Ip 7Wc+V+fPOfHCzvpdU/Jcs4JiVV0gsoICi0koCoOtsHdJM6GAoGqD9Cb98/7a2/Yb6sBg+Hilf3Fv Zj76nZoWmNYLLNFSLyI6WyQBk7eO+aAYfy7XYSlOMApMi0G2tVqlUME6o/VG04JBokGSREerwQPM 7AOkT1iQ5JLU3FLA+gURqsVYQB4kAT7q0OSCiRoK+tMaL9iP3CWPchdTXnRqH2ca+0eq1r3BRaKe A9CmgAxfxwHMpgbwwG6ZqsUhclLtwJQIt6LY3affyOck4tf5LfuNCzy4+l/N0n4DsSaRnNKKU3qY V7jCERbE2RTaREpMz1kfo7sIjAOQSQqICuGQknJcndscEhjIDwURol47SxbQvIBZYl7GHI3BUQtX enaZFR3nI/gTUIYBQIzBtXgoEWu4WBmPi6vqKFhUzjjV8A+NbhOaIP5E+5kYDEBEZBPuhaWFLF5C b6AwNMkgQsEh9A1C2gcE1jRHsIj6gqskdKtFeSq12c0a2esIon0DCKUsgQgKzmIG40krDCTiQ+cD YDRqAlUVLbQAYST3yHbJqRIQNAMSENgiVIsuCUqpYu8AKOSBI+M9YbW0mKiLQodvn5q9aD6C5FUD wVNoBofuQO6qMZ9Ye04uY8JPryXk8D3z977I+bq4yEMqU4CgxIHmOCZKGSQCmEhRgX3XswmCVFEv JBe9SiKEWSDmSS7BUSYYHnJ6DDQ4I8z1/Q0BVA/FJUoYqaZd/IZqnoqpSNW++87cnlds7CRazM5x SqKikL/vlJRc4mIyVwyVRBHoOwY6pQLzErqSKlOd4TIy6DW0Ejhp101o0aMKWFih/dczrQrwRlO1 2EmRnTaG6HMxl8N4UN1pbN7wB4XWHNqHZOqazwDJ0T5ngHllARz0XLUR0gS1yOeyHrs1Ho6ecznO cIiNFZEiabHB2MfCecsyMtAvn3R6deH24wKZPjiMkNjpTCidWbhtTaMXdhdXbNaPMmV1rkdnJo/0 qI+N0mQlmMuiBQTxiSJoYqqFYqukV5IYVE0RH19THhmDshSQr+BpGPF339kFaKEdNXqqbKjCijXS liCVsXZGkQfBlIPhE8z1+bobgf4jXaP51Zydyak0JQoIWzV/1JOb1x1W8JwJlWVmCSSlIjQMh/rl E7E9l0FkMzbl77lKM0YrAl/+CQjlZ1YVVVAnmToQysgouupfK6UKoUjjEhZBJhSekhImiFIwiuCF 9KBkHpse5HrEyFA7S8hOP0R4p0yjsRqmLGMPhyPHzfCcWcOppJnLW0S7p5Z10hmaaBXe6wqvdty4 HcCEOk6J6CBaeujonu2dYG5ZvHW3zyHGawK8bZCaVi2ucWqhU6wgham1Qnn7NSKNwVF0p+WEZrn8 lfzp+LiTuR7oncI/BeSNQ9bSTjK3sqrQqj+NonCFSFz9H4l7KaUDGETdgeQmDBIxJI4y3oHgRA9w BvU7DwNvXyJSJ0yJhsssKSnl1FEELHcjQlIlbsU302XQ3ZLHXZvG2wbmgrRKyVOsWzjekwTo41yc sOB1q7R2BBMtsTGMhWG7KJHNphN5nPXB2CHzZQZGSUPl2GjHZk+mBMef4CrXWZwxGyOAbEMEEYwW cycQPClhVJA/ID6VYKoK/zHpDRivbfSygSapQM2B73AUiKHUGYS56RHI9HuatMj+iy6XENYPp7eh dfyAPWcg2L7h8wDsTmh5oFNg/MwlIlBKBSTyJsqCrEYLFgqKMkWAsBVUVEUGIApIsFIqxQFhFVYC gCgpBZIsIsBYpBUYpARBREiwWEWQUiwEVUUWKKLISMgSE2gCBp6fUoN4l/etHYFw3kVn36Atcj0Q Un/F/UR8GvBXhHlJMLR1GJTP2QsoNJ3jWGkFQZBQKNE8l5JhDkIbTEGkQQNn5q6UyEIQTePJKWYO Q+XqkDzJT70igLIoKRYsWKLFFkUUUIsIKLBQUBYpILAigKAoKCiiwgoooIgoKEWKLJBYKAsWEWKK AsiIsgopFgsWKLFixSKKLFIsFIoKLKHXgOGd4WyShsSUhqjueP7JJ6PcPgVxn9Bu+keKH14177C1 PZOO04LmtofHObgsHcGGhYQbErBRL1UaZ0NdwexEaQtkqBY/dJCE+wZFYMFRPz0paFBEtKWyy2WW lLSlpRERGMtAoFslkpZZbJZKUpaUSJKUpaUVURkZLQoIiCCIqJaUtKIiIqCDIyWlGRkpQoWhQtCh aUSJLYWCRJSwsLZYiMZaUVUREs9k7ofj+HPrD4rXRwCdQvx6BN4X4AgB8kuVcSiMUFDMhFSCRM6a IlgEWK0ylSoSsFgssWhbCS5eF1lyi8L2WKMRpRKCVAoNBalVBCmxUyjzTIegHavtX8Rx+CFAo5J9 DG4xkoURCY3oCxFHiEseghS5Z1p9xVvsCwdfe8g3qKWp+hkPqh9H5tdV8L3c/pTKOgthDJ34ba2m qm4bXBHuzihTJJNoJdiwhMjCQPzEGVhVJSLQO0iUUROSFcG5IFgoEqdsOsgTY9CgZuyUQUkNmEqB QjNlwKB6Mb27FBOugZ5AsiKJnQrddRMqlYayKVSVOySP6BgnHiyPfEkJqW0fcX1fhpqighk/kPy2 SLPAJzsQ7eoBglhqYwsS0EJEgQkJBAhvNQcg9Yp5DsC/CgZtzQ2JoRPblFULKiJT8RRUNxYGmnE1 HoJ2OsT0V9YBeZjyJRYUGJQftO5X2Bep6j4+0VfBMqyxciaEfa3pA1lex6UKreeSJqer8EOoPTNv PKH1w7C68s7KH4EMfeaph0nStSp1S3Yw/AXN0/yPrgsgbQPuJUmI9Sxdgcs33GIVFSy4QetMytFk kMTIbzc1KGjrnQAy6tgJOedQgjOlvBjpnjAxQPXPXHOBDWuUN4gAjhrg0VwyORosjBxkvnWSHVFD jtTlJhf0VzQK5u9HoCsGy+ecjq4AzwriDYPgIAm472U+eAQO96KuCLBhXAYY08B4DwUO9zkdBjTq MAoMVkHNq+xvKpc8rq8FCrCq8jgUDnIXNEji5nnliOM3zvFCa4JaPgLPAZWEIeC3IgfWXir3pUTQ 5AujVpgqaaaoCknVkWCoUux30YA5ZAGEO9MZOh5iTt5I3uKr5TscBuZloedLtpkgS535kMl7njDQ CSn24ZbPwt0XutoBUzfCMwphBLFSCRIESIyg6PGSksuNTTrOMhdIMVocbmtM1YsK5rmasaW0c+zR qo1F5RrM5RRKCilakkxhaFQ111GaQocviVgQZBDZgH5P4fFeYsiMYJCAddKhWELSKPSQqSPoUjZl Sq/KLwZIgpK9EnqoUkpT/cqB4cbxX85gIUT7/yL8fMwHYGSOtNH3lko9kmiMG0njrxvEwfD3Flih C8NieoSz3p4NxoPmFq581pBMC9fgxj3eBU8J532RsjVLEsstoarALCt6BfYKBQD5EZJGGXbUDWYi XLzCKfFgtApEwYa14rmLcIMzGM7FkqbscowUtGUMRgSZphIdgQVQQcGMmmSzOcLiLM9c1pLLZGAK wiTATUYrcIjgAHELroAdod/BDgkBrFxxJA8h7T7P3ZrBC0Px86VIEAPNMamGqtmGX/7aGS1oEWA4 f0FUDYuj83VtQsHpMNRBJFUPdBVqLDYAUXpUud4Yj4AQazge5YPtHsjcb5wtJ/YFTgm6NCG2VrTZ S2kEtZD4kSaEhrCzSkZFBmwAw/X96zvn2UZiSofZqx4nQKBMkFDGiRQYE5z5iZM5jsY2OlL051L/ O2yVNsmK/xq7WzolQ521UUVFNr4JwXeev9pt1ogyCsigqBUKTBCcRPLzkKn96yTLIOkdbhDBLPwG jEthRy6bCljGmSt1yghbEtFAiJYhZRCwXxMo4lSo7PmuJeMU2aM2FGTy+ir7SKDdlgP2LdGEBgn9 ULBGcWtktMk0VAfxREwGLGRtOEnvPXDAEGiQe47En6SZSTr6Hx2hw+MJLp3HBOMaLEIEFYpgEM6M BwjELDSghPE+4ST70hFkn3qI/pDR680ULMMC2LkG5YkRn8v45MGIg8Jf92zj9n7MMAeEPj/+16Fd qwBgflBQZ3P/Y+GBYGoKDKmUO2dmeF+p2hqQOgIQA6pCLDdJKkiMkUBT/AMkC+FkkqEhI+yajaHn +mjSWL0Mp+yUG4DqKyDKoGGKeWJoPSMLyc+s9iUowi5SqhKFoWhRiiEOFhHwuYT0alpbSgQ/sUKX Q1ta1jGgco5/0qI+OsUCv3Z0PE+AgmJH2O4/P+iLpBqX/hEytxdVbVXRIt9xIM1apnLnPjy3YrWc t68r5atJm1/hMlC95kyzJQMjBokvAydcMQxDVvFA1S4w0woiWAJLNZkMWklI0EgIFYVN6EKJGgwl lzNJUk4DocEErYRn1wibE2p+bnjL9i5/0n5QcaN4K5luUNRmhBJDMh9imtaKe7c9UnmlD6HZQ4gS Nr6wwA+86EckkZEk+0TiFqp2rqAxg4xI+WuiIUjZJBCsFqQAoEUDiJ8TwbwTCAfmVwnBXB+huP0L iDpwjkBv1hV4h4hyaigj2hS8QRv6gFcphdmMuyYFPkd0n3D71ovyKj0DQv2j19PlLYIL2o4SbKFx CsgEMwFw+MWvo4V+Fh+Kx6sq0EDIo3GUDKYiNweTBqSiiUvakIxVJIny+kmxMJoNZMz2XHAZANTL BZo9pE2NjRlS5K4ZKhDcgElkAwPrIT3GWRomZlZpgSQnaPvDBMvbLJAoIJSn41+3FiCELhoxEbCD +kUfzoHYryRnD3oYzLA7J0fJ8kvJlDc3GsjY6JP6xO97+ylcqsqu6LLKhXeWDEueJD3H8bE6KCqF ypap88en1h4nnPWjEYn6/TPaX5Gj3nJT6QmxYcHOwrJukolRa3m1vOvP9AxOYG8NKzicNmKKgdCO 9uckf1Q9QVR64dD+qNs/UjeXlVOMpvQyhg1WNVEbs61LK/xOEORDYKcgPViqPsCw8PQ+Yngn814e 5HedilciXELAopzDsDuR6HCPGx/ehgMZD85NyfaO2NS/shraOm/4Y8/09oewHieg2no7kE/Gd0dA ucCSHxOu3a/Agnu2bNky7VwrmZmZmfHafVDjJI/yQhhAVRrJXSSHwnisf40opKIjEZBBEKWQokSr PdCn1GQ94MoWTCSjzNQPV3yQ90yE2MTmjzHibs7egno/cddKGHmYAD5JQR9RxQ73QHpzFerP9BTs k3J5QjOaPdEiMXwSR5B+DERN9FQNnvylzAjEkZGRUWArGRG2B/cHNwJYWdREA2hEPJbTpvV0mtKI 2Dd6kbg1BYr1hswnBwKAoSSJGI4CemwUXSHUjqAGoDhIinSCbh4ZhVoB+3Mi0+LQy1vUqU7PhvU7 xLD4a6a5lj0NSuNU6CK2FqOZtzP94XhbVOapiHzANwfdB29XM5pIrV6pJ2F3wOU9hG8MIiWR0mHu 2BS0lWfm6dhhDYH0QQhWEDoaUkx0CgSC0iudNeVaDKvhkKhnOoCiHwD3idpdFiwMNGjAkyClajgp Rc6HuRtAt1UZv88MFS2YoeUlpPvP1R9jCREv7hiXYnMSKaOwKIWlqN6enQr1gfI9QB5fEcwmIAuf Mga0DckFbx3cZGpPAjQCXWFOLAwoVVj8XqJJZHzmCY0nZhDXT0M6FguhSjuVsT68SocQ0dYG8AOl fWHM7+pxln0h3mB2jwd0aSPCGxy6I9cMQHy3WI6cqDbFURyBf6FjAgB9oecO1qFX2Q9YhEK0P2EE PSwko3gdnU7lChSaHSxx8g54Se9Hu+rsSJ7JPONY0jhR3rFAWBdfnQr9WFHQBoYRNiP2IkyBTkQW 5WS00yJ5s/2ABxEEaILhZfQrlsUkBPd9mxU/e0D6ICX7Dg7XiH3EPoicUfTm54IzkMZJii51MI98 diMUhsm9UuFMYZ+4M6omhuX1fmudbYhh235/xT7XAfIzr+JA/6WFalD+atSBAMb8sj672ggK60Pg g/BXvFwL1LuRBsPUD6j4oAdY/Q5Mi70Q9p9YOntSfAPq+sjaJKft+SE2R2WB0f9SdZFOB0wCiECE H62CkyqBZ7PBOp7TyjkO3kj1k9Z5QfIMLeD8fL1SHnS4lyifRMAmHEnyzdKYRc3YGADqT5D4G3wM G0XN9Q+Z0I73LjegLToN8LvykrXMbAQ2UokkUEE0ahsbnC7fQQ4qjICR17za4dD6ZGCjgeB4+Mkd 0egaviU0k+bSbTaPzRVzmw6uY7V29BsZsNaHJH1CdOVOJ5/J7Awh6wDLTQv0TEDx7XGJpE4nXETo WIEGDT4oIkVjBEZBYEn7/7dJCWmGEQSooUewp2UZh1nihef2fnZpVJRH7FD9nt3v4xrO0+0OROXi in3OkHsj4mvGRQPar4J+TUGhevgdXuA5GQPO29OwwLcntCGn2IeiOh4S8eNJ9IczCEmh6RHFPbUS HOKe1Ag+xDMhsfa+xO5e/zSmBUzdRMBLwzvdjbxDmR/7GKmIGLgTGg4iCezrNgWr7FD1mlh7g/0a lxjcOogeVCwdeJ+CTsOanWTTJGj2QmaN0/46uG0h+AfijwHFOCHQuI4gGo+HNW29EH1fQPiJyDIv 6+NAhCeH7qodCbyMYMHkQ1h2DiNopyUizw9MMT6I1PBv+r8kdpqk/XGT8ZHA2k5vqwbyP1j1OD1P fPVT84/HR4j8v004XOpO48RHJ9uxl/OHU+c+acL+iCgWDF3OOdc815S4mOa0fshyev71UGWQnuAQ 57lpJenXpk6uqw0v0EHir6zrDoDM4h6hPMC8DA9ypyFNS7tpq7nUPRDaG5eAq4zoAuO4mqBUPUqZ tapsFoZAxJ1rnMamFOXALl294NqdwdCeY9kMfY8ngf7TW3YWKnldJcsWkqd5eaUU69iOapoC4MyI PT3+AB2iuYLlqnQPrn2Se/Hv/A9AzCv1Oba1lff5kwkRw23adFbG0RWquQscrt2EQ42jiTcNAC47 OCmrAZVyqAaxTip4ij2LqDe5jUAc0KhyR2GMMYdiahOgOkUcyZw4hFwrkXwHwRybBLVrvQ5O81Bl HGuEOsiHBLjkvRj04kNZlwHgHeuwKCbzU50zeGlHY6gAQNSQE9iP80WmbrHvPgHE8HKJPS3ialo2 mYzodi9Z8U7ldwocE4hfeYlcSqBjVD0PedT5XXu3+jvQQ52xx1fIzMoWTJjkwikM2+DNQhqfMbBo 0IiaC8zHiU2XSbl33NjI70ONjvgQ5lk3NpIBZeOkqmsdCpNszaa1EA2YHORh0RJnFmwcabYphyt4 RUAS4MCOCOSRwQ3YchcQ4LIQe3afAnfPrjAdwpu9OsFCdZpNs66NgbY0cAtgoFa0jSNLhgJkl1QU aCJ4bxoI4oAlkpHSKF+KoK5VKhvsF8DboLkzm9wGTrFtegOjAsTiunUobQxpuOOLULU6DxPXJO6D V3fe7fFUpgf3SePUmDaJSFhLigxaNKUoIkDqFMT7huA8/E8OKhZzMlztXpHsQO6oPePUh61NwBx5 9/Mp20aV46CtlliE2dh3AVFyo6ewE0AZtx3LuOlImJeCQ+MeDjJ90Yh3PpB97nJNDF5nrae7qHCH DxPV3w97vT1R19s9UbHhE5RlkGp4yJ0rzGcDOFQDeBC7mdBxPQegM6rp38ewOwMyqe8gKdnQdgnk HcnaCcS+GlDxR6ld4nYgXZ1oOAbh3zZJGhRi0E6BWguozJxF7ARALIiazN0r0JculDEGjiCucBX0 XtA7wD1BiV4B0ia0fX3r4CcjoNwaekTcKUVvDKD5c1PFLzzBN9wuQqd5Hai8aYh5ne2aqVLUdyHZ Pe8JOwecPvT4PaFiOvvTE39mY5x2mfvh55HwPf94nY1XiDn3mEO8Q4I2r0hlp0jAiQInRGfvecPD p4nJ6IwOEOFNfGPA+R8PukNonvYx6p1NA9rrgipHgjqI1GOXqpVcUrYCIFKWLKZ1dVrzEIeQYger qTWdnAtVOB0Fmr5R3a+/s+Eb9TT5O6O1yk+FJyD47yGuEeybR8HpO3RrHK/dzPS7nM4pJxOraPgk HjD3GJN5JgjpE7JOEbxeHaeILUgYQbe5XaGgE5CbxPEciOy0SiZ+0j4sjzx7bMIy0kjhJlDvDujw HpuaiOw9ZZcemRSvhJMjzTSJ5ZO4PSbiKlqake1O7ah3H9EH8yfafBP8/6X8gl0kgRgRSQf9dAKM T6fgn/p/xs/lI0DLKLe48tAqwVmZVNakarEgpIkURyBAsoP/t6YGR0P90/+z//qoAQ/s/2avP/8X ckU4UJCd7KYp --===============5794250470135359022==--