From: Bjorn Munch Date: September 1 2010 2:06pm Subject: bzr commit into mysql-next-mr-mtr branch (bjorn.munch:2975) List-Archive: http://lists.mysql.com/commits/117350 Message-Id: <201009011408.o81E8qsl010540@khepri15.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============2138005986==" --===============2138005986== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/bm136801/my/mtr-nx/ based on revid:bjorn.munch@stripped 2975 Bjorn Munch 2010-09-01 [merge] merge from next-mr 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: 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 libservices/CMakeLists.txt libservices/Makefile.am mysql-test/include/range.inc 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_all.result mysql-test/r/range_none.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 mysys/my_init.c mysys/thr_lock.c sql/authors.h sql/binlog.h sql/ha_partition.cc sql/item_func.cc sql/item_sum.cc sql/item_sum.h sql/log.cc 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 'include/Makefile.am' --- a/include/Makefile.am 2010-07-29 13:37:49 +0000 +++ b/include/Makefile.am 2010-09-01 13:05:01 +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 08:14:49 +0000 +++ b/include/mysql/plugin.h 2010-09-01 13:06:14 +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 '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; === 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/include/range.inc' --- a/mysql-test/include/range.inc 2010-08-16 06:58:42 +0000 +++ b/mysql-test/include/range.inc 2010-08-26 14:32:33 +0000 @@ -1313,6 +1313,18 @@ 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 '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-06-21 16:58:57 +0000 +++ b/mysql-test/r/func_gconcat.result 2010-08-26 14:32:33 +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 08:37:49 +0000 +++ b/mysql-test/r/func_group.result 2010-08-30 08:40:42 +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#52123 Assertion failed: aggregator == aggr->Aggrtype(), === 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-05-14 08:14:09 +0000 +++ b/mysql-test/r/func_time.result 2010-08-18 07:24:32 +0000 @@ -1305,6 +1305,14 @@ 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 # # BUG#43578 "MyISAM&Maria gives wrong rows with range access === modified file 'mysql-test/r/mysqld--help-notwin.result' --- a/mysql-test/r/mysqld--help-notwin.result 2010-08-28 16:41:50 +0000 +++ b/mysql-test/r/mysqld--help-notwin.result 2010-09-01 13:06:14 +0000 @@ -685,7 +685,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:41:50 +0000 +++ b/mysql-test/r/mysqld--help-win.result 2010-09-01 13:06:14 +0000 @@ -689,7 +689,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_all.result' --- a/mysql-test/r/range_all.result 2010-08-16 06:58:42 +0000 +++ b/mysql-test/r/range_all.result 2010-08-26 14:32:33 +0000 @@ -1654,6 +1654,19 @@ 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 CREATE TABLE t1 (c1 DECIMAL(10,0),INDEX(c1)); INSERT INTO t1 VALUES (1),(2),(3); === modified file 'mysql-test/r/range_none.result' --- a/mysql-test/r/range_none.result 2010-08-16 07:21:40 +0000 +++ b/mysql-test/r/range_none.result 2010-08-27 14:15:52 +0000 @@ -1653,6 +1653,19 @@ 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 CREATE TABLE t1 (c1 DECIMAL(10,0),INDEX(c1)); INSERT INTO t1 VALUES (1),(2),(3); === added file 'mysql-test/std_data/parts/t1_blackhole.frm' 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' 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-23 17:43:34 +0000 +++ b/mysql-test/suite/innodb/r/innodb_mysql.result 2010-08-30 08:40:42 +0000 @@ -2576,6 +2576,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 07:30:40 +0000 +++ b/mysql-test/suite/innodb/t/innodb_mysql.test 2010-08-27 13:00:00 +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 08:37:49 +0000 +++ b/mysql-test/t/func_group.test 2010-08-30 08:40:42 +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-05-14 08:14:09 +0000 +++ b/mysql-test/t/func_time.test 2010-08-18 07:24:32 +0000 @@ -821,6 +821,17 @@ 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 --echo # === 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 '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-20 08:48:59 +0000 +++ b/mysys/thr_lock.c 2010-09-01 13:05:01 +0000 @@ -92,6 +92,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; @@ -432,6 +442,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) { @@ -463,6 +486,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/authors.h' --- a/sql/authors.h 2010-07-02 18:15:21 +0000 +++ b/sql/authors.h 2010-09-01 13:05:01 +0000 @@ -94,6 +94,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/binlog.h' --- a/sql/binlog.h 2010-07-02 02:58:51 +0000 +++ b/sql/binlog.h 2010-08-26 14:29:22 +0000 @@ -162,10 +162,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/ha_partition.cc' --- a/sql/ha_partition.cc 2010-08-04 10:34:01 +0000 +++ b/sql/ha_partition.cc 2010-08-26 14:32:33 +0000 @@ -2447,9 +2447,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 12:54:22 +0000 +++ b/sql/item_func.cc 2010-08-30 08:40:42 +0000 @@ -2551,6 +2551,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-23 17:51:11 +0000 +++ b/sql/item_sum.cc 2010-08-30 08:36:38 +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() */ @@ -987,7 +967,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)) @@ -3061,7 +3042,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), @@ -3074,6 +3054,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; + } } @@ -3139,7 +3137,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-28 23:39:52 +0000 +++ b/sql/item_sum.h 2010-08-30 08:36:38 +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 03:51:38 +0000 +++ b/sql/log.cc 2010-08-30 08:40:42 +0000 @@ -1993,70 +1993,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; } #ifdef _WIN32 === modified file 'sql/mysqld.cc' --- a/sql/mysqld.cc 2010-08-26 21:32:48 +0000 +++ b/sql/mysqld.cc 2010-09-01 13:06:14 +0000 @@ -63,7 +63,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" @@ -192,6 +194,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) @@ -455,7 +460,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 */ @@ -1748,7 +1753,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(); @@ -1996,7 +2001,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 */ } @@ -2392,7 +2397,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\ @@ -2400,7 +2405,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"); @@ -2647,7 +2652,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)) { @@ -3886,13 +3891,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); } } @@ -4501,23 +4508,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 @@ -4618,8 +4608,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 } @@ -5189,7 +5179,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; } @@ -7494,14 +7484,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-20 09:15:16 +0000 +++ b/sql/mysqld.h 2010-09-01 13:06:14 +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; @@ -179,7 +179,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 thread_cache_size, thread_pool_size; +extern ulong thread_cache_size; extern ulong back_log; extern char language[FN_REFLEN]; extern ulong server_id, concurrency; @@ -211,7 +211,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-08-04 10:34:01 +0000 +++ b/sql/opt_range.cc 2010-08-26 14:32:33 +0000 @@ -5591,7 +5591,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-07-02 02:58:51 +0000 +++ b/sql/scheduler.cc 2010-09-01 13:05:01 +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 2010-07-02 18:15:21 +0000 +++ b/sql/scheduler.h 2010-09-01 13:05:01 +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 03:51:38 +0000 +++ b/sql/sql_class.cc 2010-09-01 13:06:14 +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) @@ -3188,6 +3198,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 */ /**************************************************************************** @@ -3371,6 +3435,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-20 09:15:16 +0000 +++ b/sql/sql_class.h 2010-09-01 13:06:14 +0000 @@ -1659,6 +1659,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)); @@ -2689,7 +2693,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); @@ -2702,6 +2706,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 13:10:22 +0000 +++ b/sql/sql_connect.cc 2010-09-01 13:05:01 +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-07-02 02:58:51 +0000 +++ b/sql/sql_connect.h 2010-09-01 13:05:01 +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 2010-07-02 02:58:51 +0000 +++ b/sql/sql_plugin_services.h 2010-09-01 13:05:01 +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-26 13:54:59 +0000 +++ b/sql/sql_select.cc 2010-08-30 08:37:21 +0000 @@ -18260,7 +18260,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; @@ -18352,7 +18354,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, @@ -18389,7 +18392,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 @@ -18478,7 +18482,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) @@ -19065,6 +19070,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; @@ -19077,23 +19110,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)) @@ -19106,7 +19122,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; } /** @@ -21451,14 +21480,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-08-04 10:34:01 +0000 +++ b/sql/sql_select.h 2010-08-27 14:15:52 +0000 @@ -1957,7 +1957,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, MI_COLUMNDEF *start_recinfo, MI_COLUMNDEF **recinfo, === modified file 'sql/sql_show.cc' --- a/sql/sql_show.cc 2010-08-20 09:15:16 +0000 +++ b/sql/sql_show.cc 2010-09-01 13:06:14 +0000 @@ -1819,6 +1819,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); @@ -1826,16 +1827,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); } } @@ -1922,6 +1922,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 */ @@ -1942,6 +1943,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. */ @@ -7495,13 +7497,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-24 10:52:32 +0000 +++ b/sql/sql_yacc.yy 2010-08-31 07:54:08 +0000 @@ -1430,6 +1430,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 @@ -10527,7 +10528,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, @@ -12330,6 +12331,21 @@ table_ident: if ($$ == NULL) MYSQL_YYABORT; } + ; + +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: === modified file 'sql/sys_vars.cc' --- a/sql/sys_vars.cc 2010-08-27 22:00:11 +0000 +++ b/sql/sys_vars.cc 2010-09-01 13:06:14 +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-20 09:15:16 +0000 +++ b/sql/table.h 2010-08-30 08:40:42 +0000 @@ -204,7 +204,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 15:45:58 +0000 +++ b/storage/innobase/buf/buf0flu.c 2010-09-01 13:05:01 +0000 @@ -44,6 +44,8 @@ Created 11/11/1995 Heikki Tuuri #include "os0file.h" #include "trx0sys.h" #include "srv0mon.h" +#include "mysql/plugin.h" +#include "mysql/service_thd_wait.h" /********************************************************************** These statistics are generated for heuristics used in estimating the @@ -1749,10 +1751,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-07-23 16:29:41 +0000 +++ b/storage/innobase/buf/buf0rea.c 2010-09-01 13:05:01 +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-18 07:49:26 +0000 +++ b/storage/innobase/srv/srv0srv.c 2010-09-01 13:05:01 +0000 @@ -85,6 +85,8 @@ Created 10/8/1995 Heikki Tuuri #include "trx0i_s.h" #include "os0sync.h" /* for HAVE_ATOMIC_BUILTINS */ #include "srv0mon.h" +#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 */ @@ -1235,7 +1237,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 = ""; @@ -1601,7 +1605,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 */ --===============2138005986== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/bjorn.munch@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: bjorn.munch@stripped # target_branch: file:///home/bm136801/my/mtr-nx/ # testament_sha1: fe8d162fd39433f208e18d10bd379a94bd8aa13c # timestamp: 2010-09-01 16:08:52 +0200 # source_branch: file:///home/bm136801/my/mysql-next-mr/ # base_revision_id: bjorn.munch@stripped\ # kivqfgfiqur2xwet # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWRBMCrsBtTb/xf//783///// ////7/////9AAAkAAgAASeGp/g9fFjl8Dt923e2sAF6sD0+gb7VjeAH3Hnm8FAUAHO3KOwAXue5p lMJn2ak4AAAvmG7gAAAPrQBkAiBoAAAAAPT3QPo0i9I2EFX2x2dFND3Yr0YjWfZ05DL2ajgT2wK6 4B3B8A4d5QEA9kPCKYn20lUgOyjSEPQehPRvZoFzDQcfTr7Pt53Ugu77ePdYh9H33AO94NQoALu+ 9650Ez5ifWUW2lQkSg9h07oz7cThvudO+4cbYvXTvB53xrYxBXvvuquwhpvsvd3VO9Y6ucwA9Krv aJe2lEjbfXu2vXre93Nfcavfbvvt8bt6nmatlZt6j3fGgGfPG99y6725thb7uTn2OogW9jweaWZk ze+r3j7fXa+WFdtrMyuUPu+AFvvHe+3tku2U5aW9uOrX3d22+snXe949rSlhm1rFaa2zUUXxQfAB 777772qnYElna4bt6965art4n1y7B7mCvQ3vvu71o1IKo4O+egH33298mxkq9trUe+8cd7ua5173 uj63aRU3cd8u7vrveE4k1pstt84N8AJ333b53bCmgDGtpa1VFRorQ+7uFaopRLabfUN4AXRSSqFU UontS+29vdtKe33vF2Ggzuyi5bJVOoO+AC7y1lUPXXK+3fe0duzuYoC6wBQdVFRgt9Lw+gHvd7vv GDrok6222ymWGhlQHZxxQbWdzlnywtXu+PgHxWAFAhc29g4nEpC0ZalRJRqmhVKCgLZG1FLWyaq9 vbuPIo9udWtAqtPc8olUoJUbM53djl3O7ErrgeqqQ9ADK873gRna0mtm0xAwtJDazJWuegAB6XHk EmjM21gW65mx23bM7cNuHoFBQvoPrrePlVSF7m4163aj3rct7HRtu4zGNgXsF7tiiJ5mvU970ZWp GABKEzM1zwJkXj1u9e32eH23ofPKjPvnB9UvtTCB973Cknizz2o1pJi1tMxDMxExOAB6IjEMRpIV kAEgAGVGgUGgO9YAOvQCgAKGQAGLQBVjUBoDQa9ucAUqNhVA0ez6Dg9NNNL2a6AGNlN9nSgFOgBQ GhRloaUADQAArBUGg0DbANGgA5iD2y4PTV7G7MCEBNYUgHppQLfFVZ3tg1FQalQIm2djDqgoNA9b sAVoACmgDbAAAaZPrKg49NQAAB0AGhKEAEATQmgmEAgBJhU8U2jTJNkxQaPU09TTQMgaAGQ00AlA IBCERJoITyqe9J6mmp6o0DRoGjQ9QAAD1AAAGgBk0BpiAlJQE1J4SYpvTFTTRo0ekGJoAAAAAAAA A0AAJNKECICSeTQ0ATRppNDSnij9MpB6nqANoj0npPUAAGgPUAaAESSCAAmmgAAgAgEEwhGNT1TY 0g1PU2iTYmU9E00aaekxpogVKCAAhECaAAQkZTNU0xNDQaBk00aA0DQB6gAAAL/p/9cc9xf/8vJh Qj9J3X5pzfqrfOSN/hW+boAH1gGyBha628+taMP+VjGNoq5OWrQ0fhQXT2/9lHGBshy45bH9UdH5 pK5ULAMAqM/FA56uxsfnLKYAXwQOZgtSQUk/1gwe6AWqv+EBaipZAN8c3Z/v/+cl//Prv/+rszn1 ACFOqJIrcf/MP0Bq+vUCTP6X0xUFT7WkFAE2avNpIJ9tAdGuAXn8sT+6zUn+XLbE/9lUD84oHSqg UhCj8z7CH/u0f8t/8y0xZJBvmDBA1m2hsuf+oruDSSQaqmdAfMh/6DlbKaqMrGqz/b3XdOHL/eXT uYqSUUKu4CHLZNH+586T+aC3CcdE/578P32vvT7iWyUVKqlSr3uMRv/PaG88W92dn+7bmH6K+7E3 Z/S6Eh8zDrERh5Y2cHZPLv/xkx5Wlssa0v7P/YyYF/89/i/4hPDmPtp/Ztk7UmvGerO7fZb3P+/s HsVEVVRdbMA6rWdgMzobM+pZD/bUX/Gwf1R/06aOxVNXWe9l+MzJU/0Kkq5cu709f+I78PMiqDZm NIUpQ/9Jljt4p/1mYXtfcbPIlS+RnN/OYNB/jZhX2JN3LN833fsj9g+v5n97P7SSD+v+CHE3QauH /eHP9uO3soR0Sa2plXHV3TVrrTMETF8ZsHQnm2eFs1BgLOHZJcQgRdZJNigSEQN1DZUQ2rwXtVed aGZYjM4IzywEitWAHELN93VlxIEAwBJaAVjG5253A6q2jZYEzWXfdCO3VNmLO7WVUWSGircBFUMu QBQOELWHM0RPXy++1cOKgnCdEeyjqtxLS0sRjC0qbZdRVme1zi1KxiI6Sxb/93D03XtwX/d61D6H Qoa5pzk4WID/NFnleWbAp/dP9rp/ox+170iT1HLV+6D9342x0WQEj9jARAOlRRAp84nJi7JFiwAx 6083Dtopsz9OqGqY6yH5s0mlFN2UGtu7+8QiFKSplUqxd0ClRBVQE/s6ZcO+FTuLUAOqKOSCtpIi SDywG0EM8zwB0GsrZvbo/BzWXy8QwFTsngOHKqj/IZFTxInk94qukKSqJBaf6rQWWrqUpCXJKeMC GlDpQAkJFGnzjyT4YGX/j/yKmz/3v9Nnvxn/LLl4E44XZpY97f7X8oK/16LlzH8P9n/9sXtne37r 3lc5z/yZdoiv9omaPNteNv2//bK59KTpSm3+vD0F+NlKX5fw578UjfSy2tW1rW7h3AdT8ypuevZ5 JiFI8+Mrc1KZ/rhgz+NOUctsxqe7TOc8bz0do/HHPLCWmWeA5U4K+w4erqHwOw6ZkM7v5+PaGScH mYcvMZntLsXP1Zcpa6W0pTEVfdoY0U9Dp5XIW8rkd48Ry446WTQxp39/n5K2mPWyx65tNVH9YP6y Gcx4z46aOjyZxgqc+aq23ltz3IXVAd1G9ym/f3+PhoukjJ3xO/HqdDlQUy5uvku2sqww8e4fx7ih 3HDlXTLzOe3q1t1Oepg4e971dpLmeI2Z2gruvdy8+fcz8e/WpOevh3WqShUvc2iuC7ijYrj46Wwp Md38x53GQxWHaS1haO1lWw9+d9tfHaMnuXv5HiR92ZUXd4yFz0G8BdTl3npv3dOy9jsOeRi3cWZ7 9hXcPkddcCh0l1OXbIix6srV9GX2/JPk32qn+P9q/2ZvjRBMv+sWUZ3IbcBNmIkuRcVeKtEX0gos Mgol5QlyRvCa3aqq1qqC2+1uX1oD5/tsGZtzPMvxZbbM1nm8lLDPBCo3MJa9sdnsVTjWcqc1hPTu FWexpcxxlPD/R+4fQ/PNhfj+MNnfGLjp9x/D7PT86cKT0beMcKnxjD3YTSnZo07p/3i9m/tj2/Na Lp9HeZk6mCR1I5Tcw5v2PYzz0e97hv9irEG5ut93C05eMabUwlDV7uz0wwH4CDyLaYFJw+n2Dx80 xSiDIfp1NsbaPRvH+FmMOTjtq/rTrXdXMeuj9YSV5/mXftTlPopN0kzVpu7nzVIC9FIat2gV6Y/l 32xlfuZ+k6wufNz1etZ+/XWBEzKyQ1c2Zif6nDEbjh1nzV4PKXLhXwzr2f9X130Z7DYGn+JIfu/B +WdHj9XvoY3Tv5nv6fPzZvG6O8E9P069/s3u0+6bH2wCp4twL6Hf0mic15rl/67OU8PpjWG1jhQd iZuxE/0ju6pAMP2eG4ViKmJbc+aj3P50QUzb0Z0jwswGpQ48I+v0q+CkP86IBERATfQPuqOyxZYl P/PVfP5y+y7UkNUxHjRBxdWUe8+zuwH/y0QoDlZ/wBwg5+mnvgQ7liw3o5XuTVWXJnQdkd0R2sh2 rQciHn4eGLeFe/Urq9Os9wlHqOwYUkpgzZN7NIHoP2Ofj0GRxsIufZehQTVaG8jnxByr7fJfgOfr p+lsv13/k67j+vXSXl9MsfIiYh/Lp+s2VEkvzYS/91nqiITUN8/ctgU3W/8eZl8cdt8DX95P22+v Qp2+b6phGPAv2nxZPtTlDOoWGCehMVqVH+XM3nTcdmkV/ogXhy9Gn/xCVlmEL45TfkE6Zf9/83GP +1X4vAIQO2GP8GxL3x+HnR8PHw6uxZmPOvu+GT+p7I75HHzpDNG7n8zidBm6slgkPhC0D3ddr7t3 xuuukV/L6weDhc9OrM0AeQX6qCr+a/PwPsMJt6K1M3ngULqFExQ9vyBfOhfl+rcIRgu4MpbUZZGS yMnVqySEwIIhQZVGRoUJYjEkRICNLFLJYjKWACJCNBFV90qRtdRZtVKiYEDdkLBz5OXecH5f2Py9 /qlNH7Fuzz7IurZqVISp6mP0LHNxnsrvXWcw07R/yDXxJc9w76R83Fjw5uUdtSpwrSvYJUzkC6lV SVcGC3K+UoB1V73Zhm62q9uYaWPZFT6/ULyfBZU+lpOl7bqnkTZ5ZkgbjFUsfnnbLPsmVTnOG1Ob 3TMyQWFuDt04Ucv1DWF7VOg08SXNnw3Ky50Uy7C3SXM0WSyDkqdtHfMyllzskUk3cMOS7ImxW1gT Mp1c8529QS42blmTNaJSfPaPVT0r2eDVqjuVVRtem/JtdYK0nFiW4rw4afveqcn04U9yvKyZe2RR Iz1gvOJpsvgaHvb5Q98LRERtdez+P/OIf36dVT9r4e/KAYn1KnutVF88+Pxv83pvoFYg+Hh2ws8H w2u09yfY7p75ru7mqWOz+VVzT5OPo9Na4f0JVWb/MM5/D4tTPbfHdgHg4SaeQ8crDHofy0y+IOBB kcvwbFvx6+nt+dB6gBOTinv+YIEB8O6KSUMAipnAGA0/d9JpQUgOGgtBfs+Z7OE7xfoLIHp8s+Fx mhmNtba9S5G0Qk6C9ydfhfdLUCFQ2btnlxJ2H39GBhOqZtL52LCALaSdV3JPT4XwlpK6b9/yZzwc acueEn4s2ThNIL+KHSbunWZXZQZjTRo4RRc2HCqa8fE5gHpt0R42JU6u63FU2SGdaHagTHdzhkWa D2qqOpWapAgjCCeSAoii+XiBZizBx7TeV21vVTnhUdMK16sEzYqRc2R7ChNoBaPTK8gO8iblQCY4 gZxUBmrQksm9YqUMxA2ZN3TDoXNWTCCyLOtt+MybjMIBwCJIs+B8VSEmBJD9wZ0IWDpwy/MRJbQ0 ogJqjsy5GLDhD5RKSdMIiiQRRiSeUaJu7uxxANLi9EvDHrtqgjiAWrjZ0EeIulcqIo3u45nl1KMt DjqXiijxjjEZiBJ9zvOasqSjAwxZWIRRgmDfTWXZFSkYMqIJEkMyR4k+Ik36mzFygEdMXqHjAsiL IeqSLBi9l4Yk0Y0jSJ4divDwhOd6HDIbopMs5ZjemEwkqChEAYQBxAnyRFkaZm2cSO9jVIE2W92T ePkgqVECThEQIF5PkZ4X73pGl5tF9smcBxNPZ32dl+6RQ1HqeYjanGa9YVKdFZm+73LFZBmwntTg 0Ng+IuWRhbvOllpWGklninyL7mg8Ej0VXve7KE3W93Ja9TrnVZeas54dgQl6/Idhevd9Z2/Fjpqb eOp678rItX7juva8xrv0VjleR9QySL9Wc8mReO+4IbdV7qeT59WOfU/Sdrw27m62gbqpoa1jPPrw 5e2jd37lJjDvM+uyN7durbavr6xbG8edgqgo2FhDoiJsqtQRCI7O6XowY2rGT636qwWMoe9n5D7f 3fucOF+efjo/RkJ/Vk8OhOvyvbuhMEREQPHv+rvOGYd7zFEeysveqN4qxyVlCb/JdauZg/vq9TZe OMCv+vxpJ/7IzKUXMjldZ0nc91NpRaTto7rd2DVau8sRl0yX8KDM8gGOIJBIkWRpZZ5whii2kSCU GpW654mTRiOKOdrkqKV5V1HFHWrk0rji5WcUKiCgyQ2DBmm9u2NaDEXdsIWmQwQJIkigQSLHZVaL FgIFqjumUzSqsXWqGLQpQrvrWt9nacFpvQsRzS70KcG7NGXjVEprW+NQZmWldYrc2bCrBETYuNi2 JoKmbztsKoqogpinn08cpYVmy4llxHgPxwaMGYk0Yq9XPsobf23c9O2VxPZPTU1IzcvNOmcizo5r GfePokThPkzmF32CIi5FPnFXrV7dVPnhMwiu7ZDBFYpZ6B2mdWwFMbpNuTUijB0uqHDap5LU31aM GreebXE4MJZL7gYVhWuEvHoJA4TpVkBEEDIubC7hdSzebYms4trZpV0xQu7nQxKRKxPASSbWCBWX NmBiARiRnAXs6QQLuuVjIjjrsg2BZ1SQMPhECBdae9jXe4ZjBgWG5wI+pdiDq64e2W7RGP1M9kvy 9Y9d0U1lcCL3xZ18n25szL1ROmdWdmICiJDCxFoV6krlTpg4oxc+lAO+XVnAyVM3la5d0OWkYPZ8 mWtK5CQRVFUVSnTHrqn7ynSdNN+v7YT5sjMyL66+/f19qvKiGVIFVRHX6syqhBCs9TaJJ+1KgieS 27u+N6jjYcZ3UfH9Pr/IH88+X4vj9/xPjVKzzYfAwMHXlSQh21onzsVYsFiqyb8DIcptD58LFv8U LXVOW1VVEjJ0EEzUgC5uQE8zE+AXgtdTXwtufmKmuZ6AweQc00736fuxrn5RWcJHgK/u33zVfd1e 9lR4qqI5bSZVQePVnRhLOjXdKgifStu7vjeo42HGd1HsHn7jtDw1O79BkQRw3nFxFhhA+lXGiwga +Q/6wG/FN+U88f0/EO7LXbzwRvs9PoeH2yKvgDRbz3VFArujfW3vp0IHL5+RVpmiy2sxDsPEfxIg +MyD1xTPF84HMRHzDLwtDH8P7/6eANiM/pr+n8aG6CQiJIqgn5enxV2XWH+w859IjOk5p+jJShJx FUJ+jAgAnh4DrKoLy2AIxVkeiAq9EXdFunGKD9GVDr9lCl+Slel1UobyDCQmSCbCMl9vnvowcIbM JZBkRz8KeQZbEYbMcWT9SZiqigi+y1JD2+2n7gYZSQ0kCqgLIpB3CySTEHYgf4bANKqCwfxlXThF kkAWHuZKgpPRlYEqIUQVkQT3wWokgKwu/fOGnh/OYf8+T/RxR/9H48nNLEdPSO2B02dlF5jehYG2 na2G8nzFET7xBDvjKm15l35dwgdzkPcqIE0N7rEqMVW19Bb/we4u33n7kARSYngW2KPYfarJmlQo MlO+R/sKYN42Sgi2zL39c2khWfWQfs3SaqHmdhOSHHW4OUfx5QKE0frQLxdpF5ME4btDk/dkNQdB tn3CWKaTaaR6y/DM8FAwECPAPuII4f+7ps8fnEBthUDAYSMHp/M46LIV7Mxq/o7rLRSXXmZbgOqi uM1bscdN+3qOSCEMv8T1dwdBVPj9P5DKCfv26vEmcj0q89qXT7s0rlD+4DyKchDMEeHo5NvRBiWv BR2/V6wFXTmiNOA3isEMm/YQIHxE1hi9MyddtR+zs6/YGw3tNSP3f4buPWY6XUhpIdaGZPvTzbjw nrMZj9FUF7P8AqKdqSJ0yRIwYqgoiiLIiAjIKsikRFBEgioMREgKsgsWIrEQiwUFAFikFgxigLCA iRYEVSKRRQEYIwWAsVREURFFIsFBGCyCyWQIIIMYRQVRFQGCIxGQFRkVYorBAFixQUWLFRigDEVi IpGEYgKQRgqDFBgigijEZGIxIILARURiRRFRFZIsUGIgggrGIiCAgiiMUBFWMURFEQYxRRSKirAY RiKkEYkRBVFFkVYwVYqIiAKKrEGJBIrCMEikRBVWCMYQQBkFUYoiCIMEURkjGRGREFILCLEYLCIw isQUUGMFGIKQWAiojFgsIxBiiCgopFBjCDEhEQESCqsFJFFWQUIIiKKwVBkAWCoJEZIAsihBZBGQ YyKDEYrBiIqArERFiKIIxZFYqH7uxrOV/8joSpozd/ssFF4QnV49X+REEDx2SeP7f5f4+GH8tOv6 mV/g+A0Vl9dNc4Qn1YPJny8Bjfs2veEz4+taktEzRO1uM4CkN42AZ8AB/P/TAgQNTdICgApJGqIo kiwVURRYKMYooCkWRSDGQWSLCRhIwBYCkiIoLJCpJRkigKChCLARkkUUIoChFFiqgJIEgkkgEiwk j3BypF5zgUBYP8B+YwgcBBi1Cphns57Dl2XbZ+r5UdRyUizp7XqrER/fMKs+OSQQZOyvhoJcxXpZ UybUxMHb1v0jDIQlJnWwbhTu9dEnen84kO1fY8PEXRuqu0YpIUZPFkyb+ouvnbbPtrseIIHq32UP QR4HeM6Zij7UJDm5VoNc3dNFkFPWORVEYsuRMkoi0slIh03hqVrx3bYG3r1rfDPMHyd5mtevFIwE KgMIOFFQrWHDd3Dc1fndGyKQQJM805qQzZWLb41EmUpbYkhQOL5KVqosFFHmXynJ1jW1M1UdDRB5 BJQtNkMeEen27fu9WBVN765NvVfpx56eI8QkmRxnFzbBBCOGL83MpOWwQeOPnzu8qapW8cUMTaJi QVWAsZVM3jsNAyc6RwfVVQavlPahfgJnDxsLypPdnrnWLImZQko5luZRJKaWkFQiyM9jGSgMwS7M MkYsem5LmvB1OH2HfDcHq9U2esyPZRiUBbWMIF1OFVFT7JkxVlTKJFW5lWcpCYnxD42V1G/HxJfI UQ80zKunat6bfvCRJAJBdwWyOMKyKWzJQIKUJBQiDyhmsU0FMnQ4EkXZl8SeI6kEcwSN8kKRBjsg sMJLZcbISIR5IA8UJrZEjR6LYY4mtDkHioJgI6+btSQ0suqCupJBBBrwQnTxG+mt8oWBDPN2Q1ez hswokrSMBiUgjIINkL2oKtbNGe5vaZyZBuqIfPROm+eDKo5Vd6LG3R4MSTvvIWCPEyC/OQ7l2RZj MjHGpSEtNu2JIjmEO5Vy/l/pA/L8Y/s2HFRlF7QEDHXOGep3ERUcs1dXva14s94aqdb9w2kJrKLZ vbJxVAiFVzeVQyt0E7tfiIsi/ITXNDcemofz45gqrhpjk92lCUIq+MVJKfahpCuQRf4OZSjYIcoc KRJtsPDfo/ACokj4dMMv8ZYG98ZlMj3W5M8VRE6KdGEe1fCI9t+VnFcjkEY/nAbLGg9yJGj4eyrv 86GfVuh30p2/SksavFdPLpEeFq3XC8+UMZM6WA90MVK8Y8QyEkSbQMFCVc1M4RZsxgOGZDfHcGh3 aG0rlDQQFiZFJEZpCLGa3XKDajizM1sxp0jVTuyo9rLFkeMCyHtGTKsS1Jt17ydEajuBC53kK7bF ONriBntkocoINHM43pkUGSUB5De25SsqqRd4hmtd5rF8NiYucEPFDYhrGDbWwxndandnu0LnOc4d 0usCNmgMwaRE/YqcDd6oe/yZhkmPpKH9PP5K2VhASQjDkoHJP2G5qsKi/t3xNvRSaN894SDPHao3 eXTJZTSPFdb0KbrU51skUnM4SaO0Gw5KGuZlrHA39MBQLuywwVnk5GlMGIVqNPoN2mtya8F18zcs yhnK7mokWggmHv3VrXGieCxoHhPpCRSxAncxxoMBkb7bza4ZFUoPLeUcReJ1rrBO9NAWcqmJy3Ea brnQIlolkXKe68LumpQmbcnZtreUyEDF2gywqU8Q2JB5ZjFrYurFX2M81zYEkYVkAfI+lhx7rpzB G2d3LpkIETAYVRFBQVQVFZAuonSIivyJ16kSVQzHOEvMGC7yNZ+KlQL9iwGT2LSiASEOIl5lMBn3 2U9RKLSI2/eBcjhPmzNYycIkgT8bkqvJghrYt7Iu0K5jppqOKxJocDdTDFRyZBSCOagOlCx2Nk2h hEz10a0jD2QO0LqiOKaTzCJiitWHjWhVusUCDa5nm8xh51iR1FIlqeQRk6lqzpyk6TSItsZN9ItY uajnRi6rUWcKzdKdD4HHPrs9FNIJ9Pe/24sY76O1ML8yZ/A/jTaLIX5kBaUUpenCB+SG7d3JPK7j npJd8g+1Ppve4YKt3PUkRR/LQqMZ1y3lR41i4+az8heTV49Ju7kP682lh359bNkrgxpZswzT+nxP 6J+jVAZK5n47lGv7vI9Xz7A1Zyg2x9TwoKQmxZfxRTLGKZwIZ9iRDMk0ERahHGn9NtqimhSbE8EP nIX+UCndBM88OdNfPfFay+xckDvvcHx9V0SYWlbOMInbTMEOeqDVIqq5wS5HpUkcDrCia1zq4FzO SjPFFeXjJBCMpKDhDMYR60K2g5ighLGOXYaBw+YWHlYeumdWNWQvDwpyzrp27dmDQkTMp7MAUmHJ 3VJJZQNGNLIF4g985HGmThss0cNZSMzDO51ySEk2gSHpti6W1lq6tsOjxo0bNlgkUFG1zk1OOjZb q7w3KtjijJHYE8VGNnHQIHTuyJEhnDINLdQlIKTbo5eb670G8UypUsJIWQiS88xN0izt32X4plmi UNvz43KJoYTal78Bf6IUdq4/J1/D9fXncaW0R9IymMMIfy/jLwtEIEHEETaE+czyGEPxkz5YwpIs E8gjJHFmUDmTPISWXaGEOsaVhydaDMKCKxhwSHyPKbUJpcpIREMjWz2OK5QhZDI7UM3WG9qYwizI 1Cx11JtQ3GsceN5IdumMKxDTjx2kRaOt1lvaNOSSBUwFFDrcBShJ6k3ifbrnUKmXArE56ps0SZ0z eE070gtVLAbwMlF0UHTdnSGqYY1CQYlSJkEnlDRTSBRxOG8dJWaIopqLtAjkLuE66hLpDObErGgS LSvmlbq0LjjM7NbqjdGbeXJJFNBrSxJB5CmqKitc3QcH71eJTz8/IbMepOV7Sg+WYrzB1UDtsWwo osgg13JgJoMC5MyJtrspkJlBkGUJagUbubmCLQkiRs7vV9c059Kq6nN8Tbt+WuSR9o+2Mj17DbY8 QzHqTB+D5kv4KZEl3tX8RFq1Zd3NSOV4YkooL6nrviNpDSDx9ikeNI2q2oHYjJpKjk7cknUFKZuZ zUwzBMHtGCZI3fRiNr2959Wd4cGZYfohUhznI1s4NZt4Exo31md3L3pPx4mHrtxooaGaO/E5rVxc FE6yXaX1zlS/I2wyCZbZXl5x7JiyaV0on9n8X9l+Nfp/f/P/Ebdj/WOVgBDrBfqAH4JGrPoNJ2gS F6Z+Qg5A+XgrLHNkFP6TAy9UgrNLQX/IL6UCPQmxy9z7NYQPsGD0fbG4LBQv2B9/uSx/H9A0a/vH ZzZ09DLcFH9CUP1zpfNmPbEec5IQ26v2G4N0KIOX8sUxB7ctIfsf1OnDSJyH57lNs6yZC5AnZuw8 //cwBLXt35iauJeUpN8DcdnKPwbn4HaqDoTDkDQbsbtycPtzSDmF5gzDsIKH9TCMVGEXOG7aX5uY 0k0wsHv/x6Ev9vwTwD4titqc4Q/20qsWKpg+ax8ly1HCr6PoYfdh9iXkle+YsDcwo6DSfE7rj+tH Fw/kDzt6mwUXobZBkf6guHcP8+48xD+gIQhCV0n3nE5E/MlKXkCHzaOsveKXP7TZrCEIECIJPH93 QdPFOWHvU8UPV56/D4zHmk/UVaiM/xEszS81ep8jFkLTh0L8l19aCfen2ohoyvBNB94foMR7ADoH YYn39RIah+BKkw/4nIdx3HcrnTDanHt+wQ1lHBPs8A+WNFtERfAew0+Fh4eHoHih0IB+J69RL8Dw RBNDQQDGZ6m7r0/DufqJuqyFUBAKIg9z+/1TUETjvBP3sMrTCz8A6sI71umKHd7/9DhfBD+131ra 3UyEAzHybMe676JlTjlMiB47c6v4H7Ds/VsM4ddzq+gTvPzTc2DKvfgfrK7gfkJtQ+BLQRFFD1/O /U9bm//j9xNOOUjCAZDq0nAIc5J6c7uF1F5d35g0ep5OBYmGHP/R2iHIfo+wlDtDuK9zud2kTVqD yPrh9p8A6/X1gKqqKiqqKiqiIlBZPFzlVXNqqoiuS3LRtttyGMYMEJoM5smWBlFYDBJ9wkgX3hvg XwPLBCwIqChdeYfz0QJCn9ZNP40Ng7vyqWNVV8WoDRBlKQ+wqGy4u/fWNxcdyvOHiHaGZOGHqOo0 3uI+sJFjrtOg6Cv07RroTrT25hu2nW5zIbDVA6DpvTeP3H6zj+u45/ugY5HnD/1abIIG0PgAEYXK BSIFfDgn5cxfmnmX/FhsClAX26VcTiJtFC72NMJbg8c4mpIYxFqioznj1NYTddxQRSVIBb3jPNzJ VUmPjRDFg+SRsQfZyXfNCgqSsg7tSgvLin8X7ksVN2oKmJmTqh+0EC4jon2qjhUUzNHUjU0IGE5J Hm0lP54TXKScyn8GfPxLU7lY0UZT8sM3MfmrB/e96IMlRdtDTnf8h0Ul6amHG3OyzXC3xzmP89Om +RlQPkfu/fow0Qw3HO7Cjl6HMy8Hz/BmeHnw5V8FSsFEio5RqpxrR43uNe9xeNip+WbbC/2jzB/y Bzvr/P6bM16HMhBiYNPOmUVLOtoiFgsEDs3jQhBvqWMIH1lEgyyc348vm+KZ8Ok18HFsvaEIGaif RW+oAQY0Io235pLuzbrQN2dR4TnslPibS41YK3wjbGZi2Rv3XGMOMwsJImJPTa/Za0yR3EwgYaMx 8DOfvPJpH4LEj8B+Y2c+wNKajf1a7j8NpjbZNvJ5duUurHF27dzuZWrjjrkJ9wfHZp/rhteEA4er j1yF+sY2dfNcs3/qxRt1xTCyZ/1CAfNPzQwL8WxfXa2LOlhDp5ep7l4smwWra69yj3quDnLHDMyQ M0VAa0CIUb/E+YUwKPI1kGFWFjZ9v+gPKztRZOron8l5GOC4MgUUfYUXz1xcYihHuBHFx8L27h2F I3dp+9akKZJpB4lCxq82ZoeroYSE/YHoqih98H59N+Rry1M80H0f1iOIs+KH3POcIIVLDCqh+BMP epguKmymRfeo5LfmpIZfEZh+x2fkQ53pHclFGsHbvoctrDhgrXBJKSTBHJaLB/KYyReoRguRKKWF FRVFMh6svSaT83zzlCZT9jPcsugOch0UuAFOodPFw3Up4yQK+BgvjKLjBRT/L+8PpBNCl96oriwS fRXH2fmXg7xhSngnCTmpAZk4NVMWV9P3quQAPZUEQBHu9uOkDVQ71G+R9mL5PKPeV9p8s4xR6u9B XXgXd3+Ux6l7pIpNwcokxQF21IRc0t/wme4Jj3IMZ0keePQtRaTB+DiH5E3E8GWBJIjxKePPGPrp L3VeKRJp3Ndokx3w284P0daVf1EeMQywS22r7h4x3W1hcfs/WfcjFDIyeRplaco7x1kZYhUjVFRM HGXjeGRJCLGDIZi5yj6f0mjVl7udDcB6iIq+MXdBVsjDao9aoQZ+RD5icflJPm049+F5G0DmzD0I adJRVVkl+/3fWIlgVIEm83ORzqkiRvqHoVUeQdE6I94rOLSv5eZYBD+x/3YBfwDiCifCxBMP1fQp j38x42bqEJji809wQGUl0gyxQyjPoyjnLKg5yi8KITLz6ArbdfblJpLPr1i5J/2n5PHii+y5vGS8 4aJOaOUcW5y/m61hK6pohm9SBerEEPvZAyDIOyOkpUrDzR7z9rXow9RmGVzXkQUcPIKcdFDZ6DQ+ Kbp6Q8QqIQo9V3QubOMhM8mBlhb+IRgpWWYKCA4qPfjAqemYusrd6dFV8MkYqITX9ohf9Mj6/kTj HvJwnJNeIh6cpCFKMf0IkOZ7SDWc0ZWyKp7GZD7hPhBODQSdViLZGNDybLGL2/Ac37rl5N+VkQZC VdlB4o4G9Tq5wvAx8SJkdxucK9FiTcqGwG4ZuPz4j/BLqhZ8nINYVk7eX4oz4qoMqExvze9Bzene 35W1QGQXoweAY2x6pvwKHSqgvCuXTWXpL6OI57gwaqXl3HuTB1rFZcQAoC81RlRYMek2ddkGK2hP cZWrI5RilW0q2XiLen/VCZTSDfQ7/s25ZBkoUdjDeyYeSwpLhTytkuSG5SihbwDA/uIGqQZSRNAp Rj/BwPkzwZErP6Gi7G/cUhBqaOq/6RYun3htT+E4pFWmzKrBN30Z0snO9+MsggbzSSJ296HZ3C+6 p8isBKkaumowB0bXWDomjoGscR9Wxjz7VUF1m89hqvkNz0WNbKnCGvZNK4mZKZgTIuk9His1/kRG dvbPyoZhqScqKdzDpplR47FAG82Q/WD35kklkLMELEapo7B5hRqqhp/nV8oZq4oUXJ+orM/xdosY 0nDZVrWSv0plQ7MWtxrmPdv4g8qOtvVxWY1CGdoELGm8pnWKkXy7FuSCAgHZKxshIekUzsRx3N5y JeUh5ku7KpokoFbekHmrZDoB0WmVr/BQKsMhGIp1WiFtpjpQ1zf1RSGDNKv5ucb8o4LcUT+Q7GUo r3RFqK/lrVZ5ay+pGqxqgdE3SGBOP7UPEJ34kZLVfu5mZgVtzln/BNqmnj9a18DfDENRvZ7dTwxw HdHQGyopyukv0El9nTu5Nr5ehihLhp4YnzskmNYUxMNUDREwggEUjibTkYxG8jygCqG32YeQjmHt /apuHfvhlNMH6xy/znxhHb2JWKRZCqVUVOFYP0IXDQ4fmLHIQvPivoSwJlIZBg3hD4kKDMm0slxo Ci8jifyFxYwIVaM6OHhyJ9Oj+g9NzzZnjIT7qEoHlAf44J4yKJ2U6QvvXFEMrsT2xOweFFHTvtxd gmk9vM8795q8O5AEXVbTlFPed32hBPj10EkL4nNPGsLpH4s3WMH0IUkKrfZ+sFBQVLuwzPH3OsYd Y2+VWgKkdfwHGcEwVHUgMDkeqPNX0VkHCH9QefPKh5KnPF5d/r0hposYsroyVkZzWtwWyHaFFCHg 164SgrjZy1SDE7zzHVwote0yyfyli1BAdettRU5BsY0V/XSSdGyrRdhrWf1u8VJxY61uyIXrLMda 0a236qyvQ1vb937cTO2wxh3X/NruxvOfhVxqzm5Orz1ofnn+ro1rJrhaUhOpEyg41lmFc23vJwnN 6z1mGbY0Lu1YvGBniEXE+oSpbS3U8cbbNF83gyviC51w/kdL/uhqQaguIslz0YyXLetK3bS54dog 9mCqEKjQx+6wP+QsKfFa70CrY1NTW0UzJjKvNe1Xj1RVCkFX8jlU7GqMBn34kUEf6pkfo/SrygDs pOZmPKfuG6jzYUYUmodDCcCqrE2018pQrzfW3/vwMn7N0hbBc8r/v8R6ZYUzRhrONJlvOpdDbITl Yu5Vijs0sJcdDnzilhZSQaWajuSs9QZFQ4FO+413neYjH6/FVw5zpRuiChfdON+oQccxQRUX4ifd M+PK5yOpU6mLIYErjjtEYHEnbdWSiRsg4gbS+hc7dSSSZep64XyTyXRe9OSU0bxnRJPulcGSAhqS fBkzTdLWMBuRSn9ON7H1+NpvErRz8B0FE1O1HEoVdsOfXZ3wT0WlIEmrMkUgww5/BBSnXF7L4h1O VhF/yqWHPrZBx2OQHUmB5DQDU2iH2+KW/Hy8kpJAhSFa/7Pch+tSCT++8CytqJJ1/h08mb7LatfZ aqEiomf8w4Dy+n8nyP5Hf0O/vKrzN+MTEeys98Ve6bNIn/M4wkuhVSw7rt66JqaMGRM6L2ZSJCcz OISLy6a3OKIT7NkSQcHS4rrPVNbeb2ojb68q0bma1UtVZ1ZIbfdMibaGVtNTVga7FOmc6duxI2sa 4E7SIpVPJsrdGCTot4rvamzk7NCgd63hF1VTRtadDmRmiZC3cmdlMXnTlX2u8eHLey8EzeNS+6jj E0s6gRxoW65kEGeYyw9Z2VdCrFvOtLNK59kGt7KZrrY4zTm5OgwLlTeYEhtNXuzlVZ7UszeI/v6P 2fx8Thf/BGCyKo9oRCEERTAvfYhvf1HsQ2IcTAo+bg5E2n8FelHoQ6Ec4cj/cD1BmN2YD/qVi/VZ pDY9OGYobwzZmEoBuOcoxfY0/zOk6M11S8dCuRuOYWkO5DEyof6E2i9AkR0vdpSZ/iJWsP0H8EMp 19fWcDQgc6LDu6oAUtGdJM5GRkLrhgMM/RYENlFRRGQTMmmKo/O1YqiVsS0qpFWREUBrYjBRGsLW xYojUrGjVYixEgoxFIiUttqtssVGIoqjEIsWe6QdQnwvn5jaJaNsru+xMGaZY5p7BMMNasClrmXG 9hszT8jU8Gbas3R1nFaWlc0opi0XHFxdYNJlttatuU0msXTJq0R1m4usGkc1LcppNYumHn4aH9h0 nZcIETSFEVVsCj95sxSsuO8CKNIiQPSU5C+vpswZNEHUUQmYctotKZKo3dnJQxQjiSCUha0Gon87 cENCXSY8R+vUAz+/91KfgVBfx3U5aRsSw6qWCaLlKkfvRPg3BQmNRu70yjLRxnV3YdWdx6X+QiCE h/d3Trw3Orm8faLzq2BXuhddnVrOMr1f5Nh29ZYr3xy6VvnDGe0n+53XHCuWHh55RaEcK9+cOVzL N3XWpxdb6ThpBo0n65mp1Tlod9M+X3zPu9r14v6XfdvRzufy3V/aquMfrPJV65ZxlDeGMufEX4WX F+l185cZZbZ+RauLS7b2XK9pXrLurvo+GHdthGUuXdnaGF2czp+1jLqxsvPtvaFrbV0mtKnPadJy x4WMYzj3Oy1zdLajO2vyfDu3x10dfCd9odJUquueDiuWca8othn04xnLnVnaM9rxN7VnTZ++fbZn 0rj2Y30aeHWelbdBt9p41lHAe/DCDrZ6Su52kJWXLnQx2w8XM+c3d3V0ed5u32rLezduH772192c su3LOU/DHjPHHDTaCwhtrYxjG0K6OvPubPudCVXtw71aXhR62esOmyDx6wU802d0j6Cpv8uUcIHW kvu1t1wlmMjJu362gL5zm50fxN8lVWarfdEvZ9VPdzmjrnV9avzNtXcfS7zfvRndrK2y3ecVXQZZ xjKMYNtnW7mUHqkzLHaVu5xbEqZ76ZZ2MWtRi66LrktK5qKfDZXqObZlzGu8BN+rIbhVsz26tEkN ZdjStuXaMaxnUMbJ5jvudHNzjvmeb1uWtfUElsoWmsrZ8Sc63NuudW5oec4XUY6ZgZp5Bgs7xkqx XRGRNbI76g7705aGdTt7nXLWGz2cva/W0ovg1rrRayqkZ1eZprWQ8xuhu9H1P3fdCxanTx2+yHh/ Hm6PZd+o/j/TPzYa9JP1oggiCf0/zCny69Nu3x+vn7fT4/X7Z+kTr6/ZLlcw+3Pw+3677ypjB53e X3q+vy/DjUs/7+to571+3WPLu+y2LR7O5ff+Ezw+ddVdDyc8/3H9p8kfQgesjKCqkIMKFEGEVIMB kRYEEkQFgfvoRoiqtoopUURkZIiQEZCf3UrTEUYRQFSBFBSEQbVV6KI0t6QikASCiqsWKCMVVUUV RViiiqoKKKKKKKKKKKsUVRYooqxRVB+hjP5yyf5wCQlGJiKMQpbMkhMISP9ZwdDj+LJSAZoj/nvg lJvV9wkQ8hiHaMQ5B+Zl/sEyJIpmCBJ/mpMv8Z/gGur5/xlfp+CflSH2QRrtM5mfEnJ/jD5mR/R9 zh92yn9ntrNyhpG2c2u0jRQ1BIgooLIMEVVWKRkiTvLJPUL3FFdltVh/bE4wQ54mqGkIoPYJAPCe PQBhK+NH0RvUQ/lgBl6H+UhacZUzEDeOKK/1FFQ9CSKkQgWvN1lP8IqVX+yDvx86Re0Hp7mcv67e g+W+ciPpeD/fLKXkGMnJKrnjig+Hg+GaPivuVCF9KbtnBa11Uzwo9zTpNwY/yltlS6L82YVyQiOf EK6S2UDt1sjzEBP7YZYBhQ0erEyiJcqDR8GEgP7CLz6xuLL/DHHPdg5g5P6Nd7zhwHp+J++G/+xl GUcMNav977fpgoofsoJgoOgoCKWqZquTK875GoZoNPUbiy1ciCBIU+oofAg7QyDoLGAx2QOrsChy Mfkx3MXRq32s773J5iiH9tSUspmX3Ta5GYmKjLjUG/zqDB8Buv3VSb0yVAyVV6fax170fUFTzP7J hKyhjVkp4fnEehrmSBzw7k7JCJ8bd+l4lsQ6g+23GF+0vw4DGmm8jGH24/D6mLef010WtDkOi+Fj ksfkcLl0H82m032tZZxQcpWP8dn/gxH8z3F8rnycv0wz7GGf98QDTk/3C/s1GnSH7DiSQk+KgXHc bnbb0tbPNpgJfyXzE4zbpD/J+5z//o7e3UTnR36p40Lof3f8CGxQ+Ps3h7kEA7CAWOshAhDWmwsF BowECG1F+5XX3F3VKiYdVHUxAzzOQT88X7JfB0m3KXmf/Bgev9FPdOIvgJ8x31weIPEfv0S443GP De0H2FdC/jy2J08G7Sd0OQpISsvMMs+7KDK6CftU/g9GKLs3gkkd99B1bOKYB5oKgp4oQctNDq6q CruwRFUHET2D8iFCJ2P0fsuq6qnGrHy7eypZdNMNylJA5UZ3OmcV7ix/PfKir0ePIQgqveqvijz0 7n9BsMRyxHTy/HaNJMNl66veHIXliychf2Zv8L5xCJFviU0VfSbYWF2cocnOvF1kP1N8ZwRnS1z+ Mbc8RpkiEWlgSD/dNU5ipFvBcFt94fEKuX33CofE+yOxi+ut/TZ2C29764xMh7flldjd1ZC8vM3R r994f5QNcSggSMCGyvGFi4Qi2KKMImrOyNKB2fbgaUMu62vIlwZAbqH8AYMSdw1LlEWH+w0UGfF+ z/KMlf3JDQTccxX+m6sO1P2q7XHJITEx2G4Da2Gi1MCqBgQSBRSl0sJAHfByFFfX4/T63/PgTt+f h8Pr7S+sKPO3lbrfw6Mggc4e0PYFhQbz089pk8c2ZEi8zVKIh44fZD6ApUo26/JpGhobORkiYE9k E6xtsIEkONzYyZkjV66YJL9Q5wggYsV0+qUKe79/5+RMPw4/Y195w17E5N1uhuTsuznZhpT1ODAA vBDwQoh+n6xPE+Z0TGfgeL0f8TcjlfoL6j/2LCsiaCgOQVPOoVePF/R6E5rzms9x83HqTJuRVxId uJ/LZCSd6VfC44epWrpNtz99rYmC4JYX3moKJJL9DAkLkjCdXp/WOfXRUU0KsP/h2f8/0xKr7T5t Fa96Z9+4exW4z+28TgMIFDeH3iB0idYdJhjlIFGQ9p/jPyP7D3n3HmH2iQn9pUCKEBhQEIihIKTc BKIRAgaH55fi1zmoT7RE06UDYwQgOUDr/qkmb9pIcnt79HP432y4vhXVlZhgVSCeDVX+t/jjn7rF BYJuc6jSJtEi4mGnNn0atWlP1CO+QIcthcd7EoOWbOo61DzGAvmQCCsEGIhqFIgUKEUIgOwFiK9q h05jnoNF3QC7A2xGRHXusWFatwUzixVCAxE0kRekQspZRxBuUWw2CD4G32IuIi9QWLzPC79pJpEw XR9UmySiS02P8T5RkXkbqKIBCAQEvEIv4hFaP3GYo8S4WiCi4MEuCKxs06GgKVDwGIIK7AiAKhu4 ovLzCEAMy8yC86pz7UcOAHhheJ0ZyZFbAvWOBfhVjOqdn6AG4WF9yIlM5E5kM2/48b2ra3ETfJM7 +0R+SI1kSXkwRQRxMY7XJM2rbBSrlxSkQz+unl1fTY9uCFgyBjNzlshuCQ9MezWxnB2rCjPpGfSx E6Rd2WKxKWVhMUwWzFiKKIzqScM1IqspGiRNCkLM0RoZM4mlMkWit5TSY3SJSLxLxLCYCF64iYmB 6Ad4cU4cx0NTtRjtPUc0jyJpMINBJd6MwJRFIALQlFhwjiPVU4mRfSl6ZFVCn3quvXxPilISej0M 8TAfimBgykeAhqIN7/BHyk119fFabUJIvMq1fYNYhqUvOC4sbAOo5oELjJlI7kOERkjGUQtJzJtR JGpVvJpUvDKSSKSGZSQytPHUiqZiG0wS+IiXySbEhZpItgt6S7aFiqOkaSPcFkYS2eOkjmX5TmHG OfSQb7bSnskRwkRnBmMm8RsTiRJ2h3VJJRJ0JxKm4aKSGkSsklF3CNpzCZyVFvSBYzYJfiF7fZUT K5RcqtwprszDPIBdtdUgBknc7+YE/TT1rS22y2KMBthbSo0W223xJJv2klORA9JA1PEL32gnhJJO 5L0kg5YSN5NvGh9iSiPsSIy50PgUVc7JuayGvn9fdzn4GkjpueE3zJL1viT7Pg3mhgRzXMkpNOpG RinhJgiX29bpOrZmki6RkTaJpEyyWwJlLQJGEcmKh5iicTVtL1m0ERygCTbn44VHl5hWJnvZbx9N zaI4e8R9L+2BNpZK4nqO/pLyGiHuo6IwOdrRJZ9/hPinhiiYzKdfEPhJwHCWRp3JmjuapB7SRLJP v+hpHEhiZCyTR4zJNkfEkUhcSUMKSZJ2YySbtBYTSVQkZvJiHeIiiFBUJUACesdFG683ux7ubdIs wwRQiExczdnJDyn4R7vKJU+rSdF39ClCpUc4LTOMe3i/WI2pSSmPw9Wuv8Vej7Z+UiNRSFjCFPto qzfJyyeVdy9xfh+gf3P7p/Wb/f7wNlSyKRZ/IzSUpfJ+yf7dB3pFCXZ/ev6Kcen04lpTlybKPYAd jpeWpPCRhj6QLUjY4au2iJBJk8ejBMwh5lDMehQJIgfNFVOYpIp76SrDM+tDkAEN2fP6+lYApxrs 9bXExyWnNhiRAhGEn9ZQkNSNIzjCOxp068K9637qjsBRcl8eBATZ43a+RaGWXkTLj92m1Tma8pqa +IaFS12S62THO+4A6R/yco09R9RQ0C9IvqbwcEDKAzvAyZ0S/sIQnyr5lSSyfCU3JTc2MKGJiYxg yfMj25q3fWA0AkmQ0H3hscFy5q6J/RxRtv0zuQyKrMsLyf4ULUzNPE/vmWoOcuVSVXZqhM05Kmq/ hNoU3+yW0LZNYNRIIO1KLBzHi0S5mF0TJBJeRAHARGgLlCKGURyA0CYotwriq5FKHKTJDfhzd9uc 8O/h5BsKqiMQREAUYRi4xWgiFAIwIJCmlKirCEGFKgxktkAGQGiRpFhQQYLKAIEEpJLCwYQqVlIx gMFYwUijBCIEVBiijIrFEpRgKBSDAAihFKClWCUqQAoSoIxSCgEIUjEUaIqKtIBSUqgQRiFRkEkk AkEpCRkKb1RNgo4qOe4TcHNvvyIdOG+JpNJ5vm+jPoMU0ns9sv1xrKgZ89u1OyCMrehH3aYVUiWl Sfss385K/DjvJItTMO7OypFDxNocXM6CtywfLL1wySX+9nwdAgfICjKSTQ2TORtIaMyYppDYqbJM jQUklqEUZFoZGT1CAhianW2oHEAnLuqhCxUCNW91y3wS+CTHELCofgQRF5RUE5EFcMzUZSXb7hVo cuo4vI4/9PApPiDrHWaazm9XRidRpKkuuuLoSSSah3YSX8SmxoptwVgVqKahiQMSBtJuGIbyGckl RmMYvS2VMsdUkaaiDJgkLYuGFtjhwIyJvhobwjCwzIFCZhUuBbwotdffUvHDEb1E/X+QJ3RBaCMB Ni/an7fvQqWKqiof+DP/E+yhC9jEkJBY3w/lmNv/S0P+/+ii4/xFD7tvtle36ctVVrr946FUJP6Z /mh/TmWfRv8wW2W0tWhbQtsLVttALVsJbYS2kC2wC22rQtttAtsIW0LaSFthC2whaq2SW222qttt thC2kOsYxbbaW22z930mc5tozNd/55M7Knt7fWvt51cYfZ634i734Y/hP+u+kr4bDMwzMNbM5Vc5 zbQtpbbVttLVsLaFtC2wttthbbbIFtltltn3p/GOmG1MhttqSW0JgNUzmwgW22khbbaW0lSiEkkk kk3IX3zX9B/hM2228wj7B+YQGB4n+8LCPm5mg/yqUuo194YbvH+5rn7KqqmqqqqaqIsiE62IJyMh wEFBVQUyW2MqIA98M+VeuUdNOWGt4bqvE+X6usbXjvjmy/1wlGX6/ywtKUpSlKU+dVXx5r+bKrc8 9x7bZ5aYaW5fqpplpCG0s50xc6ta1vPHF8aU1Zq1bfLLKNHbqrp7v20000x25xw057ye+NeLqo+N IXu070jTlhhPg8YeWXTPKeWOBScpTc50tFXWXkzNWzM1nuZ0oR6aw3s0taWszM0K1xxvC9788sMs qUpS8pYTZnznOc59ZzluuPSVXTnOcK0y54O2vs7XPKT7W12utuedKUp33HctqznCePGVp46a1xc6 773nLHHKlVFVVMVqwMzCeDpWQceQow/Jvi2wtsLaS2mA9onDDz5RfQz/oz9aXmQ6dHu3CinSCE5A qfmrpsHPa+dhb8L4oYeCqrVXAFyJCEjBdsaL2Qw5rdMQ81NjbVNo3KnNX6sh1EhghXSbmVuWhs0R u49BKQmVpl8JkTwq5RBiaM91ObZOkZho0DcVvYRxnRLIgsiREMIAmCBub0mei2eGPZzCjYDsURwb CHSgwTOEJbtNAjcTGtvwrJIQJxtos6yQkNZpDdlSViYiB0i2I0xAZgBmERa5gm8UQGd1RxEDlIda puJCdMnT0hNOuacpNmAbsJNtUNubJNJpgHDA5YcsgOKSdMhlywFgZYdPDDZOk2YcshuKnE40c41t g2nXFDhCcMnLOGGmApMOU4eL1ccskkbWsCumhdACyAIwwJNmI7EKtCIwgeYVIiGN+cBMqb0rIHDJ yhlhnV4YVigajIpsyFQw8sIYZFDDFJygb6oboAdIAshy654wTdizI64pDCAcMAwyYSGcUrDlJ0zD hldkKmhhlADpnDyyHK3dwHKQ46oGnlnAkCu7NnO1DKQrp0kOEDCQMJUMoPVDCBo2oYZCs2EDhhMM 3QNIboThIbcU3YGN+cHLA3YTZkOmTDA3Q41SKQkwlZsyTD08qgcMk4QMoaYRYEKhpDZknKQ07pMM OGGUOHKB0IcdXLOm6sA24skw8AmfQsG4e3PYF96+98Wy+p7VV17F3URAgTtImASlCILKyigsGGl6 c/AfQ8UmG1qRhcoxgYRphP/oT+fUcGgQKSP+CJc2Ja5S2lLwPUW7S3Cob3hY3HhVmkxPZljExQvW VYSqtqzAtDMhohJx1h8es+VwBiRscOBEHm1khIF+Ma194cechCIoosHhYZJobpCoxVC8Zc7bbadH GbrbcZJ8SYNAi9QcdMkSQiY42MkLAOFymgAQupFS/82A/1WqJeZJBdAqg4g2gxvEuVQrRpvx5DD3 Gov1laviujTZe6mNpKbsUpZlWyHa5iikkWeJC62e1KxFiZggFEXeY0GU1hSX62qEIJEWREgmiJQW wLRgaC5VoQQgLFS2alecxLlsLeAQhAVviANEBWwDWo0s321GF9qAJBQYqJEgREKiiiwiqKmADAFA UEogpERFkbKdF5EkqgLpKSIUgrJiV38NoxY3mMq7nCX2vV0d3toydjbyIJJ6b9vIYnctgoIUS0Hs 4VkcFQExiyKRiCbG/leeTg4ODRwfT938rgf0t7tpkTCGfJQV5dXZFcn0eSRerTTPbqB1klyzo+D2 6D2vZAAxg/egDIzVrSgf5BiskRKJKJAQzJETRe6SQmq5NKJ8Ke2zRIMZPepbm8iJoUFXVmbBuFdE Rngx2wRW5Li0khpxMaMWLHVUXtK/Dmazh7Vnja5n8YzEnwU3rjIiJ1lUHAQSukoyICWpiiTMj0gl EVKR2iIgOGiM8Mij5jMdXsOFoyCQr+uVZCTDQ1sJmXxUkYGkP4uHRjnGsiJ7FRBkT0HhsVMmezWt THQL0arOTZykHO9zk8tWLMq28F1m7tq2RqZCyhod+dmvWJiXotP9mcRP6SbTTiuq6XroEOM6PJy/ kuzUzRdaWR5wsNK2tMyU1lmOOSS7KEYM5L55s0NC95oYmGmdBF2GORgxaYr0+2KzNlJ5U6XmMhbC SPDReb01UJobwNAtCTSb5vCrFsxc3oRoMCmNuw5QpRu2lPC8ZshhODZdFgETAVCKzHsIAVsMWJkS 5K0RxqMxdQ/jmkjbQ7s8GTdHv778NMsb7NWJ32mch7/pHlGHX18hdMJP2zjUi4YqmII4xVPQXpnb 21sYXCYJahbz5ssv2okkJlfO2iLUk7cYIX4JZw7baUJdy8sttF/5Qnw3RfXmiqK7aKR0RCDrEwkA 5OyRITSIpga5gYkMF1NmTDmkxkVaWcrOmSyr2ccxpOKRMUcsC8XOdFHT1zLYpSk0dh2p1BSYLC0R m5Y7mw6KXODudTTj9aRdHHkK3aqsXils69TL0JVLNRarZYg1oNIhABnRgLAI9CgYIM3H7LCOOog6 gJhQsMNjCBse8m23CXVsmTTZImDGjRnJJVN1DIcUKMLbK46TE4fx3LGxQvQ6SJQ42Vpnw10Nvn23 074dMhIdSChKJnx5OVgEkne8g56KHfw7F+c9DKGTgkmAOcMCin1iQsejw/Oup12r0/RhE6LjIkFp hFFJKRmhyOFDw71NhSkEcIZlrEkqWdaYIY4RnaIpPLVMKaMWMhoTMisRYlVJMWa61JayzFMpQRbA lQiIIMQrlCiUUMZQPpJWtBliRBolYmER5dVntfqk1NuEiiNSrJzNhm9XyxzqwjqSTE2Xf78yawkq jN4U2b8WlONDxNGzCqIwkicVZSzV78ZUpZdVRWdW3nlHlYq8PLGUOG9mXhg1VfntViqTttqqyVKL cu3SzNwu/H+6cknszplx5vnRXjq172uuaxteYTHCrpa6wo4I6cIaEBTEgLHUYmpSlzAIlg9jFxJB EqRDIiKhpRjWy1WkRKoVwyQCiyfwS6OiWEFESPC+NZzTY1aSDAhxJgUVIjXCwiKdSShkcW8QiiyZ N5yeh3FsWGg1NBm5cwUbOhC4wZPhssKVLZRowYkiAoTmXCQ4sGOJJIF62dU6evpuHWF7VjfXjQbq k1AKSkcm15iEKAp/aqr1Ty9i8nrGES+XkvigAdUFBQEYUQSwSyTCZIwWveNFJqhTSQxzuIlyMkyp JeDiuRS8hcm7aZ85cRGOKowRDNGBSRNm5K3JGMZFkjysw2b4Q0Gx6a2oXEpnRJNK5830QlzdhEwz co9L3Izm5XOkSiScFtccc2WajlKUY9NWdll0wYKUUka/ZiJVTu2A4YYgzo0GjQGRzbHYt0yXLlip udkwRajamTJ2r77QWykc1rMpU25Bx4Um847sTgt08FWLaE1go2y1t9Jcmq1YZYqahdCOkUkteSqS RyisdYHScDDERL0KCDlihmVJovpUcunAx3F14q3gsFBTJARmfAvxl6CJkAsGFCSyLrEmGFAKpCAq 5CETHRWHJljaQiGNBFlEgypCRVzVJDONGDMxxrikTFiYBlcdV4424zsV6HyJYsac9N1zElaDaEJs jrBdM+vUBPCInopKzxeAq1ywH+kc5dwr2N0R333kgMyHZ8MgaDglHbmCBRuu7CydKQHl8I6vtswT O8TEqO0uU6wKBCIOjII02BERMFi4OiGSCsUIiN6RBoIriX5IWyQF2iSKE3N7CaNUmMzxgTopDHEu Qp2OCyMaL4FGVEm0k0y0ottUMm6ucG8i+xSSaZ5lLZVWLSGzvvZLbSaGmW2iSQlRzsk+EHMDHE7N BAIvr5MLSgwWYG9mU9eOu29TBw3dNDw3bsVmpi1UVeXXndt41nlGsaNEgmVIkJ04lOZbDaYKLIKV qgl8RFvgCWRcXG9vRRNAY0YH+bwIqTEmjB/rTLa9A2DaG2RYyMthiqGxChAeVkYG1Aw59mT2KRRg cjGTIXOFz4I5YMHCjoY0UHBRy/vAaHLh0SZJfga0OGzQrFZB2NFjgbLHVIImB+zosTIvRk6LuXMF acQudhaTEaFkYTeUrCne+HDRwNnTHv44as9bMnbw6OHh4eGBvnixeDts0dZ7uTd235a9czhRKLqF 7M3ajw6W/FJ8t/8IyoVTh5mTCidcJi9lXhR7OVZZ+W893u0xcNDcF2IBgRxCRSmG9EsE6w0HnIYJ FlwNEocutndEnthR3UeRNHVUQasHrexgcuJ8PBPGDBo8NlX3Q/Z96dzA5ey2ntMPTdyTpnTjti1s slWzQ9jtw0cPbg4y1Y+kc8ZuFdnssactXBu4dcrtWDSzRlVqjJ00s4NND7ydBbBUd1Z99Vkg4JLW MgQm6NBJ2GRDId7ns4wVtw3Epiyoqp2cFDkxJ3O3DN1DVBgyb7OG2S59dShk0+Ty4nPvGTzJkRBC lW0EQQw4fnHSWrnzVYPe6dJE/U9QMKSNwz9EzLKCcSjvZcoHJGPnwXkHWwk72SfQSOHRZw+vrvXW ++jUArksfCAU7cjYoHLF1nh+DwyfeiKMjy9DJrviwbKd8lzB4+aGVHvNqGHg6edUT2CgaDb1i93V wFHNhl7EFj2u/sF7EF4we4B1IFG5TS2fjsMcOBgvabxN2QyNjlFxQ58AWyo83Dea9YB5twGWdiNl 3duB9QcovQGk+gl4PbzHJ6f5ZeB0r0nuEzG3o3ZOD+lVA/iO0hzXqNlL/Pj6zRLXJ9/xnnjQ0YMH 1JFCRERFhtvk+fbGXHOeNdiHKAdpERSMIUYTEwFC0PCH+B/3CURAETuWRKX+HjDq/bDKvcs8dORR 0dvaazU1f2sSgk7U9ysVm177QSaIiAY7CMZJTG7H3GyzHCfk/LnkTJNkPp0xVPpwiUpoaHX1luPZ lCaAyh3r9kbiIJPuqYFF5T+ZlJyG64nAwwmerKxTfnkLDB2ROe2YzfeTWjF2sygVarIXiJMRNIQj AwtbI1KVgVuwXKonAUFARY/+QwgINzWusv0zWQJDwMWGmGGcD4s0gpwd+cEztZwqCwyya5pFIbNT cZwlE3YXFmc0MJywym3N09Drmw4TKLy8M3ZnNk6Q1zQ6YGAwFyGVzZjSfHWN5dedI05Wg3iu4EQd tOTnlGel+Iskip25ZAflmKLBiUmRZpemaILrZfe2RxA0nhbQooWUZIZFEKyYYdJxxSbsvRVx1YR1 jBOUwkmc2ZQy4cM6YcO6Z6bN02Q11YZZhJszLcXZDrfdwSPVhxxa72kNMJyzdhhhWcMOUhnFhcax N04Tnq6VJl3ThDTCbIrzTlUKgcu6E22py4RYHLwkqOZYn1PjAkjwIBIHW2rLcQT4hmSAj46771py 4MvDIo8UwcWZcecsDbwosE/IFaopRCf5ShQz45cnHHK6led868stK6UNJ4KpJ6U3EJIioggOTKsL FetbOf8iWElw+Osn35Tt06TcCH8x0XD70Lgd/IqDfyifcEeojQJBP9tlgK7+yGIYgstwGfgbBsUp /LoNSnIZc42QWuexSi850FDVlC8SI21Uyg/KSLIhkYaAgZ1kIYJMBtMaVtdIFy2wBiUpcCRC4Itu IaDMZMJrfie3ldt4Q2/wBDHpx34MThgZYpXGKd9Ua4U+e+ulldGDKWVospfHK7/BIjLyiMBdDIud 6gM1+4hpS/DTer0zTFcFxS6JjGxFGalKQqCxDGhHAOnOIlkUC+KIOMRdcBBFbQRXWvX1uVAtiTCM kkzS2IKI5RhcB9cMNYLg2sbWqyFFQYvvWvNu4p0dnHpnooUUblDK0hU2FTzCS0wJMK8MGNopRvfR JITC+mp8TiYvtxj2YvZ8WbBHCG1VXbe3WHC9xX8CHhgTomDDOr1EpjSaUmDros0onl5dPe8wOfDy GhfOGTZ4OS99Qks3Kiep8XM0dkXX9wXWk96TopMFMjJHMbeMB2eTw1n9f6EiNv3UMuVE+D2XOnqi bOZw93kphise5l4CicnKaZch4KfHM8yPivM65dpzWLQog2UVcqjqHHf16u3qbWtbEpeyhfKJ/BEQ EpB1JkMYndMtsGtch9tUq+zJilzSSPio10JeOkfYzTXSYO7Rksolfis5ijdhqGHDHGfQ24963Ksd aXhkElCh4EQBsiC9jgaFOY9h/A4lgE7aJGc6ywHdK62YybFWjYalHPnXW8vMuG7fmN7u3lqvzAm8 uUpRckBb9uJKsEWtOiTuwZoaR6bZy/bKSbN2mWVrVUym4DobXbpdh8b5qCZOvQKxoQTQHo8YRLIs hv1KxOqI23oxQ6UbXXx6krXLJZLLVJCMwDWGIVOGfUhAFKKgxcg4fNFkLcXlQzDrdzJEYZPFK+al VJjIyrM1x3wEfCilH2PsSI+yr01RHY9ZfPl7snc5WxMeW/Q6THcGVDpIMx5Y+odUEwVBF6JWUnJk ome1KmEhXwuV77MyPpxvxvi304IU3CDddnoqvGS/3VNAwUiCUBNigWxU8qIWoA8VGRIijtE682h4 7HMUMqF9FM5E5FLe2p7NHU1Y9cxGzJliUSDGMtpJDZakhb7PaXY8/tBLZ7VZ02UbmaMZgsv7BpWg ODiDIiHuGKY9OKMmF8kTKweJ7pkGGCDz4nF9mleEClaLol+R3cpsy7vvxJWlLPlP1yTPZteKfRIy poFUVD2ojWU46MolzoKPLnQ+pyXDB9DJyYh016yFNlIqgjApEAKRgT0KSeCbny2GE4Zv1ZzmFEFV E2UMtipgMUNfPteOqzGRWLK/FnqmLN0LT21ppk+t0OJMRDClHOWi35YPSqczK5crExUkXyH6qYp7 RnrFzotO9q4xIrZm53nqRtBXLqWd++jpuu8szP0scvZeru9lwKdWaq71k5OTk9z3xdd7XA6yZq3N 1vK6ju/fayq4t1ldbHGe/GbeH1m/dnWbsLaM8bW2jk5Zr37dO2rq7X61Z84utce3Y00ayOsSuNjG LznnNWp2moFmHWx3a3LtuI3Xd1dYHNTq7SzFnzzlGbL1vT67iZnfWOmd4rvDdYvlovjres6fdrdz M8trOur75rG9zOM8zZznXJZbHfWbYu50+lXKtzHL0qy62q76jS8xFlflp6xe76xXL13m/bWunM9d Zti6vjD1vS6tg6ol6wXzfuurYMt3UadWzDu19CIIcYuZDHz8dM15IMmLip2xpzF4UaDE8E5a5gZF AJBSkww32L5aI2Wclg9LG2BOf4mieqiDGGV8kr71LRTISfvSDNGMx4slhCOq2wqisqGQEYEPili8 peESjWjQK6RSxQLpqBC8VySsgbsTgXohd0q2FBYzQ7IjknTjBIiFmMiCodphhtMmJsLZSY2Ap3n0 V2logmTIoYNzywKyZHQdaBTvQyfARFTip034kI5crkP6ZLujGoE5mAkx2cCTbuU5Z0NgIXrB6GTB 2VlDy+K2KUoYV7nFlpssGtpRhVwlLoGYFVUIgx1OCCyGEQNKxI6Djx5VQKSUmHpXuKdN2ctSM85n XE91OPF2DKQz52ESy3hMZJWjes+T73bnTp23aVpR6dLM2mfhw93Xl/RFDd0vm9Gd14U47c4n47wk 9PYfsLagv9MOokQxDsgehXy2yZRfqqt+TzA5UxZlxdzD5mLTC6NIkgibRE2qlJFtx+V0AgiqJHwy m6L1hyhPLJa+DUztyv3IkkIa4hPE0ApuKY1LqFQym2AwywRCz86T3NSRYEJUA6pfS9LiWoLoiAbG hELjw0GxUWImr8LWYI63urol+Vrz9CRuqzptbH8p9ATkQI+CFRkk/AP54IN9KT3zogYvg1ZJa2h0 GVBw+Hx5pgkUT2KlUP9hktSrhRRadV908P0SI/JIj6+mbN6a28+jyYvO7z9vv7+PsU+xjhk7aig4 1yPot48xKwrC9qnUskQxHjQQkPLQCjtNEqU2puLe9Xvi8KeZcpBIzi4xmwaEHLpVhD77F5xjVyDT PJYwa5e6edLY58pwvdC0Tp4zyND6Nt2rujrut5L18Si0hdpbfxI/rndatdJJO6vKmpTR4rTe5yy4 5dsp3kv6t3vKonsXCyImHdVZ0wTlEB0QJZEFYFwyCfHZ/buIQMevExxOz9nWPDysyr7IREQHHYNf ZcmytpmECzK52DA4vfHHUPv15YFziOCJOTkCy4G7Jo8ZMgYZJu4uryqrBidPf6RPb5JU98zzi2sq 2PPPlMy5gxdPk8Gh0NWPZb4RbZoupb0Wi8FyCxh+BS+2VKlBtRWn9G2N+sH16kTrD2cnE430LLYB EMQlvqM4Whe1IUyJ2O5SIIqogDDc12L9FykxuSSG1Gm/2s0YbtSyj4Bjz448/UN9lVOCnlSJtGQV XpWlNruRReGtNCxqzeB7N2VVCW2KiRgRgMgoUvDWh4FG9sMIdMPjPZx3ycCumIz0YVTwuDx8zsGd xiGVMrGOzdHhN89cyHZM2Le5Ps+vwjHo6vRQu+nETYxMDl/mEENdxOD8k6HI6TxDENcvdejgFDo9 jp9L+jfBk+XawvXbuNI5EJYdFks17tNPMKsbEwI/CAIKgSIjGoq/0jYHo0K+KQ78GghZmgBuXKlp ELopUCCXRjhoQyOgKp6oxsSuSRKkRGsaTRJAlGJrkVGJQ4HJkKg94Hbtdlxlam0km7u5Tvn4HjCi 90twyXmLM5Q3M1kmivDYePvsk5HuJtAOGzgOhWxzxjwLd0WHVsfCRxj2XGsgIEAogUyqmSyHIjFz LpgqchRE6orsjXC5waD8E225u2H0DmTgXK8wgKazi5Ex4OVR5UNjlMwGIMUc5Yx31RPShRM68u6J TKm3qJhB4u0zc8UZmFVr0cYnKJOgW4FCyhvuxgiIgjlEEE1kbEF26bOYyYawMRYG6gy7FKNUYoWc +Eq2kLp+WE9qloY74IeA+1ScWHHuDN2duiKpBwZPRgXnv6OGU9X2BjisiDOn2okkBi3l1RA7sYOh u6gfAcJ5CiQoybREEIa6oY2QTZimm5EqIKli2UtDfKc1ESUsx5E20CTg8Jo0duUiimeejBEwqQCh LmZQAf2vZSJJFzhqULPOEVUQX7mma5mZkb1LGWhmRNSRj7fDR4j3YFWNNOWrPk54/R2eHCr+8j7r SQH59tR8+4ofk0Fyh2/ymB92/nj0yDj3szZMrXGyZYRVtzWYOEK0qidBAm5azWpZIIJQQUQrsb9k GRKXLlEOiCtXQqa6J1ZuJSIhh+QUiSmD258exDPhJDksF4HwdU8psZS2bPd9gmQTEquNBWFOQSQi VsqpwOJnVNerJhED105JpBvQZYU2NcBVswW3dUwdFSQnl0EzYfRJITzbxhStYZ7r8Keng6bmaR1z sbzZU8LPHzk+zyceHp23ojg7YGHK7Zuo8k0cI+8yZMt3luwWM7OTZ+rYqvTzymcx3Wz0aRvvFExQ G6imCiSPquQOJ4kcQwkTDYRbin5sSkwZKYfp+UyYiG2pa2K/41r8pJCTW0hHsQyLE8PkasKOmUXH B01F1FgwghaAWNsS5cOSIlQSOMsGFejVnGpu25wcDTZxxzjk2aZrPxZm7arKddJvKGFKEr155iiu MR/wwwcLgZGtwxJREZgcKQDMdgTNQSmgYkn2+V6a0IICeLsh8GNcyV3Pgu5JY3KdEOBczgO/adit 8ENnovsrhRPtHNkUdFr3Tw10BrGHbovaC/Ddi8t1kk4fpk7Rbdt0v06NXbto1dGr7RMKsWmLWWZd 6qNIngutq7daTw4m6QdO+8FHr12wJjPQIxmW1CKYRjl5IgLKZIsKFyc3E5Igd6ESR5S74alWmp5d KvJbx51erHrRmv6dPOsNTvC4GA00oPMbG9JpE5SwCJqD6FCNEGPAo77uPs9nscOzJHsg8Kmwvcm1 GOHoSRO2b0eFnSxzvwxYM88nXLJddZqyM27HFnqwoimDpMTY8tXD8XDwUbMEdLoULwQdOSF9eq8u bLAOXOHw+GDzBcfBz3rFsctNDFo1zzaMSzJfP54Ok2PxaLs35l3cltaOStpE580RBDch1QQQRDgx MBOThxY3NZ02WQaAqTGQbMTnmQJRNQxI0I2JnnUaORLjIOcJ2cPhBUKaOBk/Q/QkudGzXh6LQW1b jTRy13VcGMaMnLJi4Y65PKasGyKMtxCjcWNBnMnoh0I5xMnT9zf9qjcJtV7jMTl1pPdJ/P2fu/g5 feXKT9F3x9vwPdFPCJ68MbvuCp7zeJec3ej4vCGQ1Yqm47U3pz7VTD0xE7Q2gvUHeJ3gR2CZKE5O g9OIp0i4m0RoTSgewO3W9IRxppnVKTxl7RRU2W12NRPsllinsgHHsqqB8ioe0Tsc9D26z3uqlTVP VuugBaYhQLn+B/g6IIUppfKbSmDVrwKi1f1QYs39ZW1qrcoEeqp3qWqQ94fQ+onjJ8j8agEx3H0v 5d6ZOEReuZk5oSMMr6Q2dwi3y+i7lSFkeEwyvU6gtQmozQ5w8UNxEFWnSGQxksw4MMYOW4zAwYBh hghEMZxxLtdGQD3nAiNQk+o5eEBjygeMaLNv0mZz1iidQSjCBZs2WZVigYEhgkmBB9bE6f5gLHEf yDn8S2p731hXzZQ3DoVZ9CqrhgZvheW6smOq1IoSModVBXwN6qN6C3vTeZpFbeqhpCnNpurFWiwj O4kMPIWLntjekPdwXuXthHdJDGbV5NFrRZTRG4JF1Mza6cJsEyeg2JBPIjm+HCQrBrc2snRwvoF8 KGJigtOSGlSMTgZjGFhotd3ZzxMnD9iCidCe2QZ0VBiDotjaP1w6LM02pWpZspYqpdackHt0tqkV xBNTZFqqIiZCGSiHtpZeJebRhtjAkSze8lnk7R+c88Zyk2j6GU65r+AmyDj8+SHQwPyAcCoKqRA5 y8bHyuOZ0A5AXhxEsIwsC0tAJcNEUXcpcBcxQi33oF19ANlqlRL1sihQS4EoGWEWsxiYct2M4mS7 hLnfMe09KAbvbLY8AwpCn0omomE0zbVplTBd6ehNEDfTzDr98kerzoz8kCSd+McENTqbEKxesSbK 1IMikSG753yuSRkNHNZSwkUEiDAFihnv9mcNRBJEuLtSTNRFMiKioZBENWQHnMpl+L8StZmqjCSa QlProjeIpJwY7G22nn2exnnx+SK7obVq1Y4oJ5CTWhTtnbQz2BPoOClwGCeeCUWHHWzdJhthxhKv heIp9yja+EkTt3X1PQ77xZ1q19x7r6c19h+rnIzVhn4jzcdUIVgi3TLAMDI0NTCeCpkSayJwxW02 gSRBS+ubg6VdSj9m0tw7ZMksu0s7fB3ylWajGY74ci4QssdGc69SuegyoaUOdc5Fx5aJllirEZcw 8RAuFp8u1pwt+ezaQgAXELgICiI7gUnpe8tbgY0xNyb3NbBEVc7IToGeY2cEkgBi5wkiKsKc1kiM LvBk5siZ52vzvlxRXrvtl936vc1FTFbrxpfvT4m/sjrzreHsdBbwokDItmYRINoWFcMMg0m6IHPB 7LJNA/A+FO4wNRe4X+px8vZQByT5c4ZSQRLBjRwrdAbC6Ky+3RA+BsM+i18mijn1czw27pI9G+zw eeeZdv1R6WWaPLI2efhnro77eVbkxjMvmXPtEPvREPtEHoBHcabI2GhjXh0otJBv2B0JnJ691ZNJ JdVESOv9DF8GuA0TL+6XVEdEQDQWTGs0GcpGhELRmBhOzUufnLuX48mi2G5lQNj4KQdGVHKRUwg2 Rst65Xc5ttUX0DutYSfA3PHbMfB2YUoKX0YoVU8DKcW4iALr+YhwMgbtVtck9seqKKTqez20ssre 5b0YCUAQc+A4xvjzaURyIEE1FBRTQcfQ6lsBcbFTMqaqci+w45EB4+RQiQM9qlw06vIGiFhjljcI sOUyND1B9wcg0LwOJJnjlz8pxcCcvCuXjS3y2JMmQHfMX6mqytpyzFrZn7vepQBLiD6MCkK0sGQy lsXnXz8hcEyFUhkwIEogc39FqUQSJZFFENPrRo1y4KLq0GOkPo2SFH0MWM5oROGWrum+ipfNRX66 2UatE8Qk512sZGSoJ6Vz0MjEaGZ8mxgC/5o88JtdserAOA6lqkwpJGvOK16Z2ODoyXTJsyZ0xbHh V0tdjCevk6seXbwZW+vLGbYMmRv368O/P4Enfs5YKGs9LnCjC068NWZ56t2+Aq+M+whOk/BdU7Tp Off56syPSssOS7+ntb6iGQp1TyJtRhff40JYU6vIhdEyCIqG0RFtJLYzOhlc0Dp0LheWPg+bfjTq vOurZL2bhdHOxkQO0s0H0mSklOgXZcylV6mwIh6Dno9c0bnYMasLQhkhD76PHlQuwpWXSM8QuZCI i44wwiAQ7nh0F3t7xYx0TcvCIdHH3o5ReDxqINGWWS2ZgLMGrmXq+b6Y+c2rF23NV3R5PiODecB1 5eEN3Ci8dQKeKrF6nQvKbjhMeU3tSYk/aZoUKH5RcV+dPrTJ/DaH73VdOrlmOvhXhLpBg2S+dstd MZigYUskllJkoTLu7G1biGzWL51rcjCnv7IvjhSRPlMSXXKuWHmOHjE7c8oyFye16yUc4LMam8gX JwEOFJeUzc58p3IYW0CyJAFDNFHCnVOuKeD7E1UaxA4oWkjopIyg4RSAyaM2wpmHcDWOhI4fjKJR 4qJYcD0c84Z4gtzkSsnhAxNC5TENCZExtyGkaTLNIBwcd17i4Z03QV48oLOcz7xPEBkBPoICY87K JfjhW545rB75PVsyA9WK8+fQ5DGLl8rTTnLXhgeAviJWsyIYPYoBCoiS91ZYhPwUiIlBu1be9DgG TAifZixvM/amcQ99dcdN7MUdUelJEks7rI23KlOMnGZH0CJAyr0bOW9i12N36KEcv+qGdBB7MJk8 F2v5DRh2PZeEY9w3o6DI1MO0ENwu8HOrCdrRXwUVw76+fvi6RRMPFaWdNS65gDMLqDXVykqOx7k6 iGc1dcJ9UETEwovPpuOGJHHLWxtyixMUkgJYrTjnjGZL0KgieiHgiB7T+4RBHETP7ES+/z+z7Xm2 IFHl0dB3mKaKelKOvVpr2pEziC8zUD6JEJRnEAMXsVGc19o+z2aYtmUk3KwrIU1emi6mN2/uspVR gSWpIll5hzvhILz3Mk2w4LMDl8jN8cJ5zEkDDKjN0og6/raxmFlgFza0Tco8GcWRVT2KyhmgsIQe gRJRreyhwlt1EHhkWtSRqChJK0vpMtBoqYGU2yLjGXrWtWWpIs7WiMc2OaIHIeVWlRO9nBk8VwZC 810DKJlX27zq1dvLTJe+buy1DdRbZZo+bN81F2pVz7hexHYi/LcaIPJmSS1ZZXNVoVdRvta+Wvbt 1+yYMpLrV1mZzdtjxyaorch4gR3Hb5T5YAkL0zHHBdGTJbkFGy1NGiVnNHLEMHCNwOhAygHDRgdv GgYdMKlQSewGkTvp3Q4UMA5r8EaDR2pVkRuvxYL9WHyFBo+lFMHnBhFIKIqhSgXYTWwupGemhqOK GgEi56i0UdGw8qXdgWOtXp10JpkY7GYoo1yxoR0HnflyiKWmTKmzEdw9b80RMM8DOExeSraTNci5 jzRBv+V9/CqMU/bVJNOz5h+UhHAacsKIXXASCg/58tzdksq4RA02FFWW+w9XxutZx4UkgyX2OnXr 2fHJMGvetdjjdaqtcEQVRR9ohAwY6npfle/iKNkKYVVpSCjMzLusDEQdicjYd/k810K2uDYXgNOF TE2NTSwT2zbdtmO7wq8zD5cusGfUiTNdwWWVZ4t0xaESVueRM41IbPKsOHj3VMj4esNEPhkSRAMO QBKJnsCGJa7OgphV5Vt5iYgqoW9eqHGqaK0UyBaJXUn8zGESMGMGMf/YUC9PqfI3EAy6mWTi/AKw 3baQpuEyJckOHm7lZsfiYVNX1aNm6zBRrjQXVvF/oxcLumTNumdWd1mz++TJgzUNVjFq/Tx91nDl M3Nl+Xw+7IvnTD06as8+WJ1/Ucm70cGzZkpm5qb7+7kd5GDBn20mCOymlXlc1Upeea51MkJwI71F FyQQoYqOiCuBx3oGtyq7wxW1cfn5yoo2ec2mGo3RmnV0Yu2K9GA3BRo+dMI5J0UYJFuET2ZHydhe 5k9DFSA4w0Llp7bUCRsZlBCMYFioZER5+SbGfTNhR29OXNnhZneneRgTKre7Tl5dKM3rSnLl9xdB hNlyDVzJsc9MO+W/AgeHaYDs/GJ4119+cmA89uTVnzkwY/yhfb058uWqhRjDzCYXMSMT7ARDvEII fkiIkOceWO49z4eMC2UjaRyBZoCZBgWI7NBPoqHCoHwW2TJxMtY0Cw/BBTh4WIOpPRJkh8DEmfnY 3s1sUccydCimCjMBsv72cFDRiQ6HyXPP82CR+P+e+ebXt5tHpCffJixZOjhqwZtFVVNUxyb9ff9v pp7t/W7q7V72c78HPT+6YmSjk40YrHBJOjFGtlzaKdBX4INBJi5WR0wcDRY7P4B583fh7yPMhR9E 5kfEjgmHj8Bk/Ajwi7+4TwEsCnxROChfzicwm06wMwp2gVyBfqUXccV70Ygu5TtZ4kfbAlypsK7y Fkmwp7v5/URPwj8ic/q9kzGS58OUFuv5wDP4giO8QwUOwOl+ILyZuL19HIrtOZBsjqROQXtTi6FQ NIh2i9TrE5F4ak3oc3MHZtTz5RNziJtE3GsANC948AXmBOJ6Gk+R958DuMTsKCuNNOulLQuupXSh Ph9JjEDNq5ttoIJOyEXIwh9h9X2H5L4syNgbfvoNIqy0v46QON1t+3z3WNvUM24UX23dZu++8R9i 76GEjsPhK+qdIloV5TZsk1cnaFUD9NGsekTWmzg+uG97Oivaxhjq04TLl4RfHdDgl0M9pLN0urwl vfalwr2oBOBcZICh4hHunDcTvOhYwO4GsgiG55Bmf5AfVdjcaBHiOoxk/NtqVuVF/HkoVQcmzJuU 815ScxoPdTfCiLDci1VZVUMOHUAjuYqCk92gTp8RuGn5Y/JyKYKRmzftme8SdVjNz2l3NaReUQsl nR6Qr7tk1J5t8NGcOyuXDJGVGEXPE8MHLL0ulvDOCG9Y0UkY1CVlS/oRsfzoGwGLl/EBjRZXusit OhXbTVZ2ck0hLWefD9A0MqsKqCltG0Wlo0oiNsYMqvs9kUSI/Cs+Huuk63nKDX6TFjTTIxx0/Mkg CMbIB9n5MLVBDKkfwuCi8zibU6iJ4iFCakhdyhVgRiQXQJcq0bhOankLkusoXUjbEuG9ILfBLhLJ 0mFXY242w3jyEJAhA+rdURNWPzjO7ZmW+4V1pSpZ9tSWYMOUDzU07iiP0V2AbNzFLMY9t1vMOBwi IAQGv5mBhSmdVqCbZZF7oqUiXn8bSakkif24bNsqq5LMmTRgQEd1/QLM6VaEhVRqQA6IqxKWNWQX EEq4W5cUT7w+8LiXRDg09aVuKNVg2bXuaaqXq/yKZZlMInFJEnVME8iZ2SH8C/RUf1EXIIVQRFwC jjWHYyUcD2XKVBwRlB2SYZruADH3cmGT2+vsYS3pBCjXb2al0khPWR/LfD+Jy+LE11592L0oy8Lb MC7Zwse7S7BSnXGFLLo2YmbRV6e6v6/5XxAsfj86w35XCh6UsqQqqhZSpXtfdql5eZLOrYOh4syh IQd1EL8cdCgPIDLkQOEC+hVCwvip5UG+GhG6DTFftY7LTVHEFNwgyoyIyIDdIhsVxvv7owHBJo3w ic/Sva3np+/M2zaXfu/PuM4zr/T9yGrMIhshKdmQEU2KWpTQUR1bIpS5W8cNlZR55Q7yw8KwzpHA 2YOd7zKod4Mdl5sBWnfsRLI9Qx0iI4Z61BJ4SyhgGJx+Cx+qIgFqVayIOOBtU2awrBiamvVDUdWh QzecswwewxLQcacpTgZBo6QpNLoie8QReaIi8LOa0F3yUiuNZghvSFHoIf6D/bMxFrl71WtOsK/t bi20F2SrwQCJZEJpkNZC0lG5MyRxffLBSY0my+VZFIvHI18l3JsawpJCabhR6T1O7fM4iHU2CCfR c2gJISdd3cWJ4PKMYF6ELJSfjp4OA2MZFJRYqwYOxRjMGmqExW4M6N2zmuKqKXUrjoxk8ERs+WTi WWYalzoXtOLKzYZjVHhAqpcEMyljPHdKlxkOIjsU3dXJpOQozm06aqYmnhVVivzt71Mo8WZLtnRd c1OD9iogOgIqDHz53n4KvWofQruzKTGIYB/N9NNqi7j5wYxh8yQhcEEwDiDF0hEQFEMxlqi0IQqH pS6iPZLnjpgqRBPwpvlBM/jCRujYTBEfwPQEoqYNGcdQ2HxqjpoIm4afUIxwnkfMm/EJ7ciMOHqL vxyuKxKkctUhFihFFkRtqLGAom2mJoTSGgSY1GYXCQ1VIRa283FFM6K1q57q4az4zg6ZnT24e2nC nR58Oj6yBcqF8DcqJSes2NBrEvAOVaRWm+eaoGKuePTx8sVdzrmdDoqR0BkxAk3Kb6MpxzLLwWUQ a6wiSMURPQOHy7BhNmCDBfROP6zZjpEpspkjtVoo2aKb80RqpPZOGcN1aQNMvscA8vauUBH2UWeh 5MQUkY9zpscyA65DYfh8Nh7osY6LiioUKhogs5gwKYXYPi8FVm6r4GXsx4YlbJ8jDqh7qzwYePWy 8aFjAuaGWukY1yryiJhhI9wHYR3aGpmtV5cKi7M932/Y/vm4gwkAT+8bycildZFPGXSLPsnR0QBF xBBhUHCogReK45BASmotvNcuLmRne/GVmU8E1xdX7473shfG973JjjtZlzf8XSH+ETvWZ41eXqRw beCuH1OOnbtqjFs32fGt58ikcOXY8qcj8UBpO560MyCIERyQFEKGZDOi3WCUYymshWVsps0EudjQ 5j08J1KKKhmHJnmAc8bew1cujmD2WZ089dmD6CT7Oygx2PB6KHJNyQtMkDBpsVPgCIKJUQ+IHx3w N51aRbeA4KSD+ary4A/UUtZofh9234Gnd5DrmsgT1GAaJQNtSBopzmQNEvbtqcNj0+QmQIZmglI7 ptxw8ns0cFLMHW2rX3s7jFeb4NQcIO2ZVBVS4iAUfpkIKJMHq2qjIi1cO8GzcoBvOAyS6tw6FEJF g+uFiERDbXz9m5760Uvpyx2hhISyJ7JEsW2cLwFbD9P3CZmZGI4vgm9XzkGhjgaFkPcho3sYHGWr YSlsYGK7vrFHajHZsrsph3NVmhwe2T/CPuD9UtI/FECIhx0LX6KiqvdyHOw4Z6q5z1Hun1iFYnN9 FrFYS8QzQqjHtcEohdMaC4ODYTQChQv4MhRpLIUwveRJKB2lQL4gIFxDnyIGRJww1BnCCETtpJpM YExO9ASUlgaZpqUxEx1HMqeEFSwMbFNU3mog0CseWH9GuZNmustsbrMYGfYWL449aEOpgRNMDlHD EpgveHLWoJqRGxMcxt3gxuOOD1BE2nSYYoSYoOBLmhyPRTRU1lG14qr3+WoYlKp/xAsLFFFP7a3a We6xa83zzl8tMLYQN9F4LyTJZ1YvzZg7UefefHJ2t1Kcq9R0pT0+Dh8WOPCSFHcNd6dtGzG7wVbP Db1edqpX0yZH5dMGzSzBjo0PZ6NJds7cTz1jSkuoyM3C01pPShg6Vp5fkGOXAnu15D2LmYcwqZnI 1xwHGtCBASJfc2HD4cyReRwoZkuWIOO6mYEQy5l5g57DKvMoICuqqNuEaT3k7u9cUXBFLYnDRiM0 ZzRYuz0V4yiTaE1ESrfZv3fw7bNz2855eO1q0yewsc6JnKHCh5nFxnEYPWnREnLZeBhfFFmqoZs4 gWKzJH6hVXKQ+m5oD6GG8XDUMzIGfy76T7MQN2MYPyIp6+z4HoUNycc7UexWAPBp7+Lzg6Ulvg0O GDJTfesrblrlkDC3hjL4WVZoj854o0eqV/L0QeR66PPlc9vhbjNi92mZd6GV/DGxZ4YsPk9Z+zVF 2Z5YZjmyh2CxyvDJgMknRkwhf7FyMZHMaG5SzvvR38JI7aPOWDw2YPPbw8ssTfBg2PBzUdPMkOun 4oHkCJd6yNdigpMWMTDAZM2BxIxexqeFF+cWrV28OXiQ1ZsGCracVbOeFShESyyrD5GrJ26zVOWp ifhE0y+z7MHnxTB6MmJkMJ7cUk6P567rJRFT2Nzh8MmbyYkmWCfaTY5jZRpMMfd4WapxtupWqFRR W00LKQMpmMzEYxCZjFHTJie1yhagxzIQMSH4vUHgoQWNpwuXCuyQwNGjs1zMGrEzUb0bK1bNHKzN pdr20kOEbSHxM1JYzbOHXRk0VXWUKFj9RgYhGiY1FICyyuuZnxygfFDUJmIxGPIyCmpI2NlF15yo 6yXRdizel2eZ7KHjy5cstGpipPbQVMCJjsWtGosG0sahQ5HsidgROWUiK4YY5EpfH476ELCnBpVk eIMayEqFaqKoqojKwpJejm+C2ELG5oFci48cXyOlDnpIdXoaIgS1YFkYPmxHWbPLlq3o6so4ouos zZm2qszJRiBjTAMOgVfMmlTlcuB7oaBtybUTYmHAkY6kOQsZWNuwmoE+IEeFHPTGpwMLa4uxtM5B eJRbMcpmcyBUuX6GAq2JBnEzL4hm1ROJuN9+3L8TRy3baPgizvDddR5kfaR93zLwo1iYAiPQGTv7 xHLduUPXpDtPA51M4nflXlE61Ht6NYDQnO8wfYdnaPtwV4L4RMoqE6Fa07lXqMAXlTBArpUMQRHA AX+49vzP46JPtKFn2k1fN9TfxJ8X3o8cwj1p2mVcU4C6Q4nAyhyAG5Q7EfMDpTzyKHKBsQB503u8 7F7wxM67Q6DsQX7XirlgozQOkObxAekTTsPK7uetR70vQYJShsXmAzjweHEzCj5AcFDUnU1xUOkT qIgcAO8BzieCPXuMCv06s3WedUM18xvS4l2A/A0EMT/gSsfK/U6mzTn382BpOoByj8Q/cM0MOZY9 iivK+pNu6ps0OaD3ztUOWap9OjRR+igR7OblaNQGgxJhVmOh2bgzxuXyeZ1acPydzxUkAImQCDAw dimhIkOx0HOsAYEGQ+ujs1Vy55Kyt0WgR/R9gYFezktfBTaJAPwXdDbub2np+B7CLO9mXkkJ1i2g tSusF2qkvfPmFch0pZOWxtap2iHPhUyxwIEo2L9vgu0enc1Ei4OkHrCNXl4GxsCIXng3Vvu9x68v fCLja9Yw+WoBVlyzXrzWHb8+Lt0RwmqanOs0lvMyazKqc4YHdYMqpGbZsd6LG8Ky7XiFFck2hjC6 1pxlYRjU6bLrOaqIHe9NbTLCsU8PvjbYtwr4bJsPZiKHtgywaBQ2xBUVE61ihWpywXHs4lN2Dxu1 Bz3XvoiJpbgkOEyNVeYKIoSVUjYtCSyGFVC0iqwl1WALlCwtxLi8Fqyl6rRcfPDJfftwhtZY2KKi GKNtpES6ulSz/4Syas6k671E1assL3rKXGMkSuclP68N5kSMmFs9ZZh/OFhBNGP8txfujrlxriAv 0cIFoOd1AqbwhCRgSJ/azr3Y6y99iLKJMBs+DV5aY5ZxNcS4PSJOSbToqyHsUQeBATc5HC6Etle+ rJcikOsFaRwYm1FtKSwmlOOF5CE2oIkxrQ8NXLt+SNTBi/5u7E2X0aPXt7JswFC2KhSoa04MyWoY GAFOvzS58hEh0rxn0Y2XEUsox9c7+lhYvl7YtfEXKmZWEe9Fi5Rgb7TBdBCAM4RMrkjD5A9F90f6 RLWVUlBGkwJtHSjc2ICwfDZRZ7BGjouH47uuC7kSe31i/Imqvy/7GZrX74dAtrpSL0UGBw/P0LY4 b7638MJ057LnWS31ZzEmD1dbuOzIgMiHD8leCi/Rs1C9C9s0n2oHs1eec7OzXJCx4Vj6aSVIXOQ0 5wVHBMyqbfafDakhTMsFXEuZYwNCBLgxNQYUiOfxrcylzMjUFIG4KPQx3kqZIIKoBONz46M5b4PM UPa5emtAzi6oVy6mUcU9MkholDAiCZut9aX3RoNGTUOeiOuDEau00WZjQLsatAUrEcJVM+eDh/PE WIm++gXnsYa09O8aecaKvRSPOh3ZXntHmBW+5m8OWFUUbV0W/Mk5nJp1ue+bndWeG/i2S7Ps311w sqBWwvN/KAZPXQR+Qc28or3QfZLSSTGVOxbmamAdwaHSpvz6FOfQYgHHVMBSXU0DvEPEcdHvXrDV E2dfDDTvsXECmb5QEs1L8KlrsmN2FdPHaiF8IIqLi6o7Fguw54csSbJMw2sA4hGNGmAgvdhV2CIZ UKeBEEueM0Xpv3cgZTBZtFhwRyeiNhZEBqsVj2dN2OFzn8Ps9WDtS52N0Lg8POB5w6Pzelys+hYR +Lw2HCTMwkGeeJSq0Ye/TxLdUuFyQPcOXRS5qWZ6e7NmMll3h8fpJP6QfD5h9qLyHu65rT1n19oP +GZflihmL2h0U/SnbFyHh3kEGEJCbSGeeaW5mAkPf4uYTB8RZdmnTuR9gcnvSxoo5C2ETT0OqGaJ 2YRA/B0Mdl8jZR1SpXDUHRRcl7oW/Q0R0zK4Z43iaQxg4HUUlyxGQsa5SQkdJW0R+ZNtBaLXCZle qirZSug4y7Q3kNeo6HggGVickA5SKMiNs/vrGq+H33pOeCR5oB+npEeud+jpMaOeCRYP20Rk+OYs 0flbPx+pLD8PF+GvuxzsCelsKiW1rUoBkSQBkX1RkUqgJHuapkev01TvpaEHEYS10FqzO+1F5otU WYKoLhNV3b5cK/D4Ql0CZVw7oWsBtOv09OFxhgltvXR08KwwHTKjMoZA8Q+DDHw+EfeL36Qhr3He KFQoSPY4HBtk7E8wLBDIbOtc5nJnLjtE9K9OfTnlmbLlKbX1RUspPk/StbV4IXvEqWmCmtbD4lgC hCUYQyiMxEQua5771N9S9zO4TzcKLPJiUWDkUCg5+uSd3xM2azxRO+WP4RJ9yTZlGWtLKVc+2tLO mHNGSnSN3jZgx1Tt6ezw3NvTd049NWGjkou/RJq57xo2SJpbJeMe1eT5PE8mOm1mjMIUTEjU2k0V zpPGtpKG3Xkvh3m2Qbhc20HsxYYwOZE96AqDo4hE4GOfeIegYeST5cI9uaGX5y/0MEA1lq/vvfzZ RRkM1mctzSot6S6fow3yIoE5CIQEQCkyrdVfFNjDX70bcgaOk7AHH7e5F8nzskcTZ+TrzxOCEnD0 vOGKf4TdFyp3kk8OgrL2NhYK5BkVBaa5+7+D+B0dlYkxRc1ENCCa0GSKZlKFMo2W8igOlUPnUdYf hMszht5bazWPXNfLPVZiWaWrKUTs25fbJPdv0FzmQ+zjjknXeDB4b0UmD12VwHNGICT8oiJ7THPf bcdfY/VE5XnboPDYxZ7zizUUtr3ckecvYdRjADWPIKtwXfZudBwc2a5xw2yH4PCT3qbroA5ff3g1 y7lOP4KMbFF68SBNgvokZ8EpcaNGDZaKDd1cT1Zsfkx6hLC3pqtJtNNtpywty7IGz0LbatcwjykZ 7eyz2Ekl+0NNnDdeAeIdDc69u4JnFjYsJ2OAwme9TDmGeYwxzLAEEqdgdlO+L27Odn2aT4CvWEau Iq+COrs61LWZtVYgQwoh4UCJaNRiSwmT9vCxWi63t5wUpPsLFlKsNAN4FMISfDAjkXGRrCox4P7E Nkest7wLcqDhLHso9qeHgnaIhOxDBY4LnKrAoqc77MHAuRwvhO2ww05D0c9HRjJfB2ZTpSE+z79j h18sO+FV84kT0EOJSJkiQcztkxuZhgGlTkbiZF5huUMC9SRe4eiM/Z4Y39hwuSRew2QE99KIWnNe fITuTo/AaqtNnJ0Or2cr7aVfbfsmvBo6w6qKXVfBJ2p6Iv6sat9tBhNnd0OKG17VChMlhEfobzot haDYdGSRTebWUgVySB6FPARU2eBwmwEjFsD+hSApyA64WsptUGRSx0dhMErnlgwPGyPadHaUdemC PieZNljRj94G/EdtjYTclQYyLOUwzHExWJjGshJmgMZpn6a6v5SJwbpEUkyzxi0tTjeILyQiIAGx IQZJK5SUPCWfGH4sSKqKyQNUPT/s9brkiIIGlc+TMoME2mxkFBNxwS5DdcnVHpGKstApApz2C5rI LEjgcDzbRsqqs9ma7ou4fJytGmLBWrNzwcLh3e1zsi+04dD/kkvYrpQYg8U0xnMuHec7xmi09/5T OeGDx30wmjdzi2d5tXF2Rk1aqtCxlMfnANsjYyJGRSdmPZKDIg4UCLE53LUbtycNV6OzpkNt35RG qeF/GZliiPLJou96LP39jFq0OW7N/e5JkswPZTot5eXOuXSl2jt+6dmjijIxNlKFo6VVjh0ymuRJ QYLSfDvApsYkTsJDh6Q6cn7PsqwMs3by4LN9XbeaHerSM0c4ZfrDLHtkm1lDRo3uAsQY44KwYEuU wejCnsJUXw0ZMMFhQuWcLnBRzRIcAje7UYDw5DV0o+Ux3b9dnSSGrFw6V5cOWKOKrtXWLrSvuRPu 0ZM3bHkwKYfGzsyHJI9ZuNXbJ2xOnbNrZRw5UikpOaXUaanFPLywu6XdbN3TilGjrJ0jhts2UNMl /h8OmrzucOGuXJ02XYsW6aaMUdOWXfnzwuxTtkzR77EgJLlIZtOuZ528PN1rMNT+hfxIQ9xht+GT RRSo5Rq4mOpfqVxVRkwWU2M3Y5fSVJDHz5Jso4cNnpEUlEZgg6II9lfxRDRoWaLSeDR3youwZEj+ hET6SJP3/cYjj+n8D7ULiGUnD47/L+jmST708onu/sk4g+/9yOEZyfnzE8JBlM0SyW1+Q+CpziZx HqOK9AbAOIeg2OIoGsOlTKZBANjvATyu6x3j0COXxMXrA27LhPLoxUoFzqGUdAI7FdZgF5N148Nm tO6HWl8Pbp3p3JlQgHY5AXSN20V3+Z2Ac/duzidQ4J2FehvUNa6ziL3q71HahvO/jXhl0Q8Osx13 ZJFZu+Pu7GYoUGJk4XHQGvZ6WQv9IvVaDzBowVcRJbuRNhE3rk148VvqdNU/bIeyRmLJOlJ3Urin LFPWizY7R7nt+y7m59XRzwUyS+YwUMSsZ5JEBlUUVFJWIEcUWBUcbEwmw4gfOtfFgHx1hhsCbjzP KKWJiQZvQY4vT8TkTUPkjDUIfBMSQKPGyzKzq9XjLXt1V8Qk+6a1tLm1nbik31mRUaS+qVu8KoXc p5pyrEkVZjt4McxIPJczO4CnRvbliz3dk9gkTxveDQdzVC53ZOMWbhVmQuDm9J0irqtkWSJrmNFT dzj4sYrclqzxVDs23lmszCLfQV1Tq4U93ibqBUjqPZR1cOpoZedudLOcR8E7iqx56OMu2+250lvV zhwmaOcunnv4EZ0TsOegv21ltvRPzx8uCONQykjleSyOlJg0SC5nRopLwW9apC9HG1zFC73bTYsW ST77CSv7e3r4ZPTGDbLGIxQAdqbasOQ84dAgf3If5Cu0TyhvQnFb0zupuLFl6svcTMtZziuizWwB bolLiD7j1GtWpO7F1/Q/BHkuPtcZBI8hxFVWj1uiCJERQ+2BBBMWNddqPrJnMxOYfDJ8JuIAf3Fy Kp8NoUQMAk2kvq/IwY1lNNv82D9RYkshyXMnRos5bThrX454si4ughk5Iakvc4weacUhUFALQx4T fBoeupcIZKCbGlz7ASMwZTVDvEr4LRxY3Z2v2/JmVXaeZ8BxU5KFjqYjkeMVF3YT0RDfu7qnYr4z XuHI5xbneRgBQ+lewYnaPJsR8alHul1kjh14EpTfRYPcZYW8jSVeHv3brJev6y4aQyiJeyGL81Uw ZchARKL4PvPEW7UCXFEhUEhufMoiRYf5X79VJYWBC2xMcgJcUC4ou1YeK5yQ3cWrBwsJeLGs8cl2 zXzjU10lgpLCT5aojn2IogSwmUmQRAdOEKQdDORhvHuIWQyGKS8iDJ2uSGExkZVkiIj6sEg6nEZq WnMSRMHx4gRdiZgYBdutyKaxd8LlD8IM8oiJYUaiBd455YSM54eGjD7kHO1XmiN6q+ros40nRPhZ XVRqs8jUHBoKKU2U6GRmF32kg8nSa7ra4qjmbJhnwuJO2yrNF6zF+8YL4isQz2w9sQ2p9r+eAnBE pJYZyMxOJIiyOEwwrhrXfHjSYk3QsiRAJdj8QyqqWs6oiCHHO+pud5M71wLCJXHIoVKmJRfvoMiq VMHUEqXugqq+JJNQ0RMYKr0/q8eHaIHXhYw3YslwuKX/agJqcYlKRDOphKGc1FLDij06EciBDLQI IhMuK9OOYBMivyd49VYHUhd4hr1XDGDl+1fp82g5pRGmh7CcvNyJX1+36vClA2DA9Hh2NRSB4d7j kS8ipEqUYB7sKS85TPuM95QrkBSC9xqXovwhJWjttr7JfnIx+ehk79zP3J3VVXpBIuKUA/tEQ/u/ ioQL9Ek1i1kWnGuuNq8VwU8/knXsajOJlWutdEaYxib155wzPx6SeI47535zVUFMS0velUrzE1tz Vp7mjDZlE4UhgKJbU+sfj+eccdUomJMkYZZvJGumhRK6aqGgHuE3B5XZUcESwvU1NCSYAEOVzRxA XEe4ld0KHRNBvq0HoaaucnxRm8lQX3Mch8TI5mxgbkioIIJzPcFRGIZBlM3OXcTmEwMKDCYmTVeP BTWjvX5KHG3Ht0Bb6X6exCppdXOFRkth3kviZgvFfshba89XLaRIy32ptwyo8n0562awvVVwdbsZ GEjGsSoxjB2ApYqYkolbMoyEiFOwvhMH2yUQxFFMD5Z8FgQyE9xi2ltZajo2xB0xdREOaiGefu3e FImhS/Ps0hGzR6DbE4PYfRsxj3Z1a0b2UIkMyykgjl3gHxPRiKp4Y+znD2qq/ZFznsIvP7jWvKXX vbunt9ZdaXxB4SjwjQSckKiScsX5OxrkIOnzpM+51FuPpkJa61LoYO+BnDPA2XHX3Y3+x9Sqpaw/ b7l/v2eGG7Eso93CiWYsL4C4zngZMTTcZbCQ4nOdyPuHzG5Pa9mkN3naZptxBM/YfxYs/acMCXpB ib5RcINACL7NrKeFyHQ+igoxFj6lEwUhm97XEQKpEAsFrfRMJlaUVELu2NzEaKWQt5qXL4Qu5zqK TCRwBZx6iqcOCmQtdJkb1sL57JpvMyS/AMa03chMerCiUNgeqSZXWSCDxDU6OEY6od8ChibUtDIo puRLcGoaryRVtVCFrIVFIGCAiRiSSwwkLqpBNipAqGCOJ53Jinbz1wbr3wpjSXjCPNfh+f4advyZ z75ylkPwTOfuxpBYLAWYRVrPNGxyRNzwNTEQ6B7gi98jmODx0BwqH0RFllQv087ZBzi2RLn0LAB5 HYL3Ca0N6pY7v3NHOoVtd1+8j+qqdh5tjF2teGKLytWs2h0RCIR7E2nLM58+C4iCPOcWJDlL0xWK ymYI1pwJEslxxMYL1vB2xggTKIiB2ck9k+Kq/XciBBwQ6Pz10edURfnIRFDss5JJwZJPRXuCSMuT NZek0fEZLEvi7e3Usg9ZjFMULNsRNRgXuQ34VjOjO19kVwnlu3SxxYxRwLY+YJ1MzqPKFMnFOoal iebReYTDnNLDiTGYgd/yRO8Ql1v1y1g5oeN/GfuW937HxhMPh0tZ3IyTgiWsmP0m4gaSAOtaSrql e1JnJCkwfgX1B0geDEEyXHueGWHc7CU76JoUsZCrH1rhb7xYU8Aa6WaBfY3vJRB/SwWOgW99itu5 aG1qii6OLw1690vsypMxqNxgGcrnQ9ZDKFPdI9FJ5lUFVQSegrfuK2h9tsX8PnLJ389nHH4awvF1 h9G49uMaZ8dBzkTeJZn5AsAmejDK5dhXMzlROmvCsvhD6W9oeXHT2f7PpZZnwuchB4wkA7zA9jHu FEQCaIEBxoHcHU4nMR/neI58xLGBBxahYSjdE9xXL1XH+weBVzuYwTbykRe5NrOHqEteZqM09sPY onBEVmcTEtJEsptbOkU5NMbUu2bNG65pkxU53R2tLqVVm1OGcJPC7dTp4d48d1UHhXh1zuNqh3J1 0JiTWMhgZDihI3RIRFynmYEs+477po+00WdE7GsiiJTrWZkuR4oZGWveuq3cG5qrnJ8GLGhIxDWx c1J4CbGvTw1YHFmXs5cvGJoxOemSmXJW7J77c9+u+Py8WEo7fwH2WZNKfYOsi2d8NaXNbnXIIRph GGLS8JNIoSGqhrSQKikFjWUhCbJCTlkk1rmc9AmHJ5HRuYPQxTrk24X7NOVGPdS54dmxQg9H3lsp 0O2znZr70DBQxD36UFKmp8kliiWUReUuT01NN0ORGFyu66ib5DqyUWd/jEnhQkCPlNFjZdFHG8bj DSnewssg41Oyw8m5KzdDDU33dsZENzMmBySBsDoKEFB3QQyYkaPJGoRCoxuLdKDO4HoRjg6TI8IN IgiFZRQSFsiiFJGfx3fhAmKmosIKZLstg0QdhR2cBhMCOScUgk6gI3Rwssztdfc1ZGWzpd0mOKrp Q0KdFn47o7bOs3K11X1RswZVaU6b2as3B07JoUxcUPBRfbb8UfVPyJFpqwZrTxpq9sjwqdHCOx/W Lt4QSIRS60Hr6MJSUVJfo1w0GNDBfeizcLGKspcDJsfJkQuSckv3BsYucK9aKNk/WQvVi3dqSy+8 uZ3MGboX6c5YsU7utVywycqtFDtuy5NWzV23NzUJBjImDHPnAZqedoysQcUIXNcFmGhqYYZB+Xh5 x2wWzVXUbyfrLy7Fis5zRXW6dLUXkGT04wx4YFKPRKOegHKH3gsXFMC4B9+k3ZYdSrg8qMszJ7W0 RHDVxwWbruiYSPpE+6UTvcc8tUc9duFmLtZ1azltp143HA8jAeL3kIpgFcjD1UVfVVfbGhuXTJRi Z8wWxHhosWPQW9ih89XIBilPs6UtQ8HWxlk4YuJkJJsZG+vAL9G0IOixitBrfQbNDsBgZPZCG6JH N2VyDsGzW7hZmUGbvDyAzBH9accKN54808vTi2CnJjy6Zzw5XYN2jQuPr3SUVPs8MBRojGHMXIjw v0WLDH0RBc6LGER52QQynhoSiQGhUgTucSIGpiaFTyPdNA9EMntBfEhHIpoHmU3OxFiDBfWZTV19 wg63xCHgG0neKBy5h8gU0i5xMihxzE8dJkjy+T8DUS0h8aJySdkT68JnE/j+U9m8mzqaIwkPkPjI XT5yULxPdG4+rcROkfA+CSfZKcOQcyH2JJ8o8rvkZknp0KJ4kPtapkk1k+V0XQn8kTBGUUhiX0dh 8sJI6OJHnpPpJ3y/4P4/LlF8xvfLo7qprBh3Y5kcvAbkK7Yu4wpu5wzGPIy+az94SVrXqkqDn32H NLpUvEmOVYzMrRW+Ob7OmTD94UtnsWzeYYsbZGC5Qdk4iKksbvvLw67l07XFu8O3vr6SBIUAKCdt 4HfVzd4ejj50cuWPFewepFP2bSgdt9utXzNDl5X26Tt1ylG+lrtxC8VpkZ2bL6+Uw5eQS80jmtG9 avNXDJjHld7sO56JHdcdne1ap7tF4xBwNTsimqEnnL6wY3NsibvZtSBTvZtYseZnK02ZmMoc7ozg UydCw6aTFcUDg3AgwllZsqLR1ZtvumXKVdGIda4i2rHVhwztRuabkYCJA7S8piUFlB4Qk+UZPakE sXMToBmZqGisKudrVO2J5ZOz7l0nN9Iea16IeJxMtnpphoepO+aAnzBE1eiIO1Uul5pQsHMNyJZU 9tNhcBZQBgQ0SAWKRnZ9Tgxm3u+B5eVsj1+HHY3nbx+UXZbVzjwPwtD3gl7Iii2uMQXhmdusiAZt f7z70vAgdTCxAhRusmqQsYkpnAOJxFR4CEG3LnGalMe+89F8nji6YY6OQJolO0knVnmbs5dNmSsk lMHK0WaVySJok3USYEokoi9IyfK27Fy4VcNlJSmmVaoaiJSAVTQ0wELMAiaIJfoHTnu8UxzAyXFg UcAfVrYnPTAVHGoCtie8ETtNd9iKYmxmakibAo8Kt/H9c2WWbDDm7VmY0bLOjlxE2k9N7jv0Md5P XZ8WZtCZa5A9KzUSsx57Wbdtpay+JHxfHrxwldMyyF0bIAXBEdMuLAw4gs3xr0QGmul0QTIgBpt+ kMW1SUuPvi7vVW+eW7vqcS+K23i8PDxyDsGRCiUahj4Omg7CJoo6zJKMZIK0SJ3dq9sq+WOSKqyL 7dR2Hs8KZTiTgRPZ5m0937MSiWMIZc9jDI9j2KDr1Rw0eYwdQb4UXNHKE6GNnYzikFhjIcW32NcE 0I4AUKQYgMSy0wi4Ufoe5BPIQufmOffZ2LByHZV97VqeHw9rLd+qYtN7z0VCkXIfJfHX1d8S6XLk kej6O+XxduCHQiSuOTySKOGs2DJA9mVWUUyNeYj6LkFvMXZLAqKMOK4stlhXBE7uS4p9mC5Taqmw s7GEQBhzSeGIVIVFN2rEd6D0FOE30nhgvjorXTcOy+9A4bFYtbm/r37sRQbNjHNE0OdngijlRosD lqGFCAY7D1BYoHKsYPDssbT+YgedLOiVhVXp/T3hZ5m91q/Q1zxnQbCJrRa1GERrHrJ2N6L75dlU wXEzz4wcDCMlrAVrpPyelzpmZt0k0SemjbOmkw2Zm+tdRlxo1ctWWfi+kSU8+PjoXcN9GT8kXNqD HC0tqSkc+N/L7fDPSl+aF8l1YNA+LLV03nfoWOMLgq2Zasri5nYnyHhlW+RsXDDlczLFFOnDAwmZ 0z6mDSjk3d22aUYvskPyPxxj5Zfa3FXp56Nv9nxnt6lpphsU8FThovNoi1sGFPY1aLA0JiMBe8nq byKGhhQ3eQ3hBMzGFyShnlrUToOjwqVpjw2IHhiHPx/YGCwcFznCdnh0OU4sCkB+bHFonJ+lxDOj swHq88F4BuMMVY6eyZWtsIUEMwsiPCipIVTgeXUgOK4sTw5nmbzSTw1ZOWaq7cu4XMXBasTjaZU4 BiAwQvaRJjQsMFyJWIgiibl9cMU5bDJlzWrdxE3tGIEWqPZMqlhrmIlMCMLkCv95UxLEidlmllZc FQ+BcgYE5LglYk8cA0WhS7KFkMCG9CJotcogsWS6iktkdJ/RxMTZJMiqhMJwARXBamWpIwnUxCfP ztZTDDVkksXHDsUGvqoPAY8C5pH11lZPrO0LG6M8tgZjyxPUPoVgY5tQUMlwUpI4LUShjglQ2Ny5 nQdEQ1MoGgxSYPIXKk7mLdOmg8zuZkw6fLHDOst7Ky24vApq0hXJODYI6b5UQcWeqzg7BLaTPz01 UNgwZXGXjMLsUo0fow8tZp2bDHBegsiJyMEeVIgqLkNiccDg0FMDHIgQMQ7MXhBTNAyaBe+xhlLk FFkh+/OohEXAw3ZRaTsOqlUkwzZ2HPV6vsb2LpxiDp9x0eMaPcuKvYL6UGHGTS+lfQw2Um/iH34G iBbdJi9OXp8GKzDfyo0eH7g49NmlXoxTBLHXvemuoyqjbvHxlZYS0Tiqs1Yv6FwO+Fb5iLF1bDOg q6EgY9eskFujRgtZpurKth0sQeje5upwWlTKjmGuChCl1Cs2LET4MOKquTPXb7N2nOmko6Vc0RSZ 0l60WHJS/CIWCFj4eMJ5NH1CYFL1SpVE3Mjim/WC1xhzYoVXEMSWRX3e2JoSWJIkPKsQBKKRFldM SvtnsFGIGMP0KQE+ToLmpE6CdeJHQb179aezxzBMrcziUTFx80XmVe8vLGGhcZJF2ez2WkoQrBBe GwT30NEqLx7KrBd9nobAOcDrOfRRYIUNrUVKrrYUhbcwhEK6nnduTjH3cOjD4HPpRG/igNeZ1CwY rwQjhw8NHMqkzUN3F9JqzdoqxYvyYuL8csiplOuE2TmQKOIkrZn1zMgcbICfQEngGyGMp7JAWOsn rxWlmRSrXvMoXu0dRij3hXT0CyLkGPYjptb+5uQqFmYXfG0kWVB0NCoRrDmYrTLDcBo1wPZzWP0/ Tcmcrs4M4rBZ8ng1rZXs7OGTTVgyOn7V5Nsl8pIYHpIN7YU4UXC1mFkXEXk4daJMXLTLcppzNjVR pGZB4xQMzWVhkUdgCQXyR7OsVHuC4Mfx0IWTacDgQtxRJiHWsJ+yRHVXMjHkl4hB8M86aZHMVjT0 h92Pny5A0oSPptsXk0ZNehMR8MSCn0isUeyjTw2V2wcRJ8U2qyVa+O+ytfzRi7c5uzGzoUX1aQ9+ pPU1m2RgsYLDEufZqvAn2WowWLwGsEYLE5NsVwIuvvoyXyayCOSDGD4WBYIIUyeGjrQcsFi5I4x4 LYfBRViXenpo541a1S3nBfaj4RLInult5SUm/Xf0IcO+5qt/TfDB9RojObey1zYZJHIHgwOWYz7T W0+Gi5WC9iwghsbASZ+oPKIUydF27Q3XbuTrXHBuwc6NW5lkq7RixUcJ4QXG7DGTsYwpYjPR0lye B57Uzkc0QynZIbgnK8wdqYLm+uWMgo4pJRawasRAh3k0x6LD4DVyRywdly90g67I9TcMkB31Ojtk ZNble8nCxy64XX6YJLcOO32iHiZyJP7RTBZw0s2LYWf0nrZ35YQmPD0u7a3gD2FWuUPr+SszSo6o H1XMdGTZ8jhk7NhjuRJGYpqMcs72K4FiFSZAUuVbGo7OhXbQy5UGajjFgvvhtFW+48zw2bL/rcH0 x9/HnprtyWdX5No7DR8E+xED2ALojixCpYexuK8Dew4cKQlA2dIiY4YyG+SIHLdEImtiRzwDmGsW Dgxs8N9nZg4p4c1Qp/FialNkI5jDG4Pe3b+X8ycRzH9yaNEyPZXOGBdPgPxh+MfB9o4CdAJqRv9m lAOtQrtmdTIxdHbioaZDpHgKI8pPh7xwjaR7I8foifLVMITV1DqQXrEL1O7Ycg9KgadamhNGJ1nu FN3EQDaib17Q2iw9g7gRHrbuh2ECR5FDFV0A6RO44CUp1Acy+nbSl/Yq89AtlDoDfpE5QuRKrUTv qWtduNsd99HIHGORT4VenznWp1P7i1v5s+b2dRrPOVrMVVlUvU3LyXdVce8FbflLLNJQysksL1je rVvpFjrmr7zCvDlYwsFD1A8PdbOV7yEoIEqCARMEEEECCESSPETfeDmet3fev2ZoIs5Rj1QECAZ3 Ona2UExVzO9g3wBxdzmmVwvs1ih0LdtB8Ep3KW5ZxaiR204woEdNopRxbI3hOdqGChiWb3TgtZiD QWcc6C3NQ1mUTNuqzhWdx3hw0HdGHUL3ZEobpG7atVTt10917c68xSsKlHs2Q+E0lTrqpUHRPbi6 84TaBWLLmTXapwYcM9m3uhKkOdHDbOHNzd7cvWM2pquqZQSri1pSGqyzdpYgirva8VpA2cyRX29G swbdl9framOXH7tLFpDWzZGyqQvKWlIvJeQ/aQIkhCf2yIAOsLUqoMOCxTysOw4s+iLrCVxWkk9P izWI2SrzgpioWqM2xEYXMhS3vP9WTJUKK1CIiAnQrbPGTQO27JBCc8N4Wa6G43FORvRIqqbPc2/C Q4z5xxb5lGGsndGhiuBTYOm0wkyaMmLCEZOH8w/Qm1bLjMKgaNhTDPKIqgI411pBGY0fxO1s80TS jhQxpquOHpw0vTEiuRdvxE0ZVkLZKF/b2Myx0otMssFWHLfDZQ5cpsdGjBhPYXJvc8xfwvlNtDTa RsLWrVFK6Nt2IHZ8reLOKKZqysxSCcJkig6GILbX+ll2VCT1qx2iM2zk0bmmGVM5EtImdFJAVF8D s6DxVX7VTcYvrqtX5u2lXWGbJly2DC1qZiZLeHTK2VMthEsokZyLqLIzo7UIFBamg6Cv2OrXJQL3 KE9C9D5HJpSCG5EoA2uE48s5NkQWR0wSEn1Ax8gdEdDipOyD1kSwmRQU+fF67I8OC+AqGCgmcJ8A 2EY/eB69eRhvnOPuzMPpbR8VrTNtspFFrGFLzPvSu7ps+EhVUOG7KWkiV9ujHHwmFc3HHXYCBgQQ NsgyoMV8d8Hw3/O5nWmNLelBTt71UXYlPRUmMiW5tyuo0LmOC9AjLRo0OgCYUHSvo/M4XDNhiggX Ithzss0UyrvU+iKOoct9syiuIW2WGEoG68YVVVf1owfAUMOi4Og3jhVqAgUFcQQUyKOfRi8MnVhu av3iKPdco3dcc9KvWLwCCCWjfzJ76dg7Fs9lizGMntSqW0yYhZvlrdv+TGwoRVSGQ0KjgKZFPoXY QHDj3W/9JGW/u3WzpJq0u1rImEmussZTdRMsadFgutvgyFj2X9SeBssQYMFoHXTMHGFTg8/c1GHs II51094VQZS4LoXOaXBCIxQ2hRN/nXzIZ5SUmgv7GIi09CIjbfeynGNEa4ez+Iccyn6CvOfls+LV 469zzkzeXDRZ0w9kwyPGho6ZLTlzsyWe7dbrrVs1y6PT9Ufs8wTcEQ002ymvD92XaVOT1ZXtJ7RX kUcsKvFm6aTpXMYsICZEZToVGU93DwZf5RylSnBxpe50Mm0dnQB5IuYJIqLLPo2gikTM5++E4RmF 3CQFUklxUOuO50gnsZMOgmLwiVQyBtYNlhg+dypDgEInEkRlgQVNFj9/m8qL1jWED2qeKI9hjA69 WpFUIblhiUmyVOWqjFVV9KoIj8BL6kLBEhWPXXiGcE8Q9h676OnyiAdMPCWAuKHCC9sOFcpmOx6C T66DRXs78k0oJM0nXF+gbjymBs49QPY4jxCW645pDN28YkXQ2sGWRZ+1p7ug7+Q3FMtnNy/DsB90 GPuB+QIp7FEm2DQD6iWREUhhjOD0DytDGl5BHzXavj1vk6zUiUNik+Huq34zyhZeYqNizBjkCyqW XIsTzuiMJUVMpKraKZRCZZ6GWgUnyTdIqkqHAgXYpDBsNfKfl0btvyeN7KPW7jRV6ZJ432fGjFix ZFzTGkpOER04ej058H3zR2UfXxbV0iqontVbjjRl1hvaq0qxArvrirroZLCpno8FbYuTO7ETgz7I SwpZdbPy/hbzTXOKdFaqqyOD2a1ZKMtVGMnYLKgdgvswM9p9JaWVGX0C9gqR7OhwvZhPYoZFxLHe h8cWeQNQqEhkYoTAxYXh7yYE3LOSnGPESZQ9kZ0hhDoM2dk+jIV8UMaSeXgqwXcSj0YI0bMXlXTJ 0/cxbTkzibzAz+bC81Goz8DUaQ8Bu6u1edTyUPVQ0Otu1zocr9WRA1pB09WZZCw5PfSdKwHSmOab txfx/MNcEcFIJTjl12ZSUKW0oaXgvDpWsoaNacNBKvEaBT92Rv1OF8m55c/edPAdnTL13B3TaP4N Vhuz9wnEOIUb760/Sol1yFmWV8D1PwIpLElmbj82kYFR4PgasPMAvppEM7mHeWSFXLhyYdXda+Gj VX4/SQ+DZx5e3r3V2Ul+n3xaxcaIxQpUs8E1UL6s37kDKez8RCQfFNr1tMUG+s2NqhQqOqWBVNnD mGlFNgxlRxQx7GsoHWRSSTq+YLISLcXBKUOEkmXwqmF4bPs/OMGccFQ10jfwcYhZXs5cdE6kaypY 5kSN4mVaUUyEsc2NemY8uGpiWvEI1DkRYlySX+H0exdc53+D6p/m+njDdoCAyjKCHjMzK0WtLNNo am8liCrQpYZg6r4iWFHJ9GjSSJLezlCGLWrlrRwwN93a57BgUUTRc8dD4dnCx4QfQiAMe7Gz0NJd oVLHrg+im6X21wfY5k9DXYoZzZczLHzWI1dljIpc2cSg28Wzd1w6Mf4kZ8+zjtR34Nzvd55mChw8 HTu1sDZpd4/OScvrmGmFKTim2rSQpCKgpSENl+D5+HtgdcqZvZfYxqsYcmTdY9vnQez2b7eEBDNU Dj4sGM2+i158OE+WrVXmvTw1cHf8mQDkoZayfJxWTWRJIVRitH2vaz8GBs+GLpjVk+i5Pro0y8Rg nDNnmTThguzWXb+zDlvxaryEJs6hQmLQpOBMPIwMre6pJKSDAHHxGSsR2ox8F3Slx+21/lGxM3p4 tR09LtWPK3DFriqjyeWna698OzCp33i3MGz0Udtx3Ielc9dauGmzpm/lxgt4cK2U5zaLP3TNgLKe pnSG0Y2CaAiHr1QQ94lYbbZai6GHBKehlEUmmID7CQOzw9nsPswPY88g4co5mTsdhYJ2Uh2bC6Nr WrBclguXj8YyO9J0dIp0ZEyamZQKFSZKrxhhKlhlNvHKJbEuaaa6Eme/KzVq49ZsJ2xVsZ3JPRsZ rbOdWE8nvYlujRgMY6CMMGjRYyQZUcPhjQrSCkGDYdJ2Jy4pKhY2SDjZ2CzJeZaxGINHKMJD6i+2 q7VVb+asu18nh3X6ONnHlVm9d0zMeHDp1NDnxc38uZajmbN6MihNmGRJzyTNzrd0ifhB7LqWNHoq i55PCR9inR64YMXjU6rxXS8T9kDt82rX0zd6pXTpt4abHXoXaXNCjWYtclTwQwbn2acyYGybF0WM myh4MWbN5dmpdoxVL4qsHCjE30YfB7LslGum6l2qzy7brOruObuTpw3fVBminkPm9q7VW4OI3gm6 YDtTvAgFybuRnEbEnyDyn1jsktOfFNJDKJmT55Bgdy+YmgO8zA2Q78UDwW85E8FW9Q5jnAOoPIWK Gvai6zoVeChScRME8kcNQcFDxDYi7+QL1R2i7A0CjTwUPQAsGXtetfPgHMF/mqYodPep0oLiGpQ0 9hlBelMBSD2hpaZyC8iBkSGUDzOz11nfn4QyX28vCLQV8VePgzmnFzqvjR4eJ8TxHWvUS5OqNCkF bH19m4RdAr6H2TDkhSWa72VleVOzOyVpw0e8pqwdzfd1+014Xluj6UFVI82RvlQeX3tHvChgR25R NabqexD2+FkwECKz2V6PdsMWaVZg9ABnvUqvBV5vh6gf5AcDyH5Iw1HzNu347ZyfE1bnrIWCXNt5 ezOdcy6ozXCSjZ7N2KD4ZPVUtIHFk2dOUbHEuQpKZPaS9rOcHVjEzNzmCwEVL42vkz24SNzwmppi 5zi9qdwmcx68Cs27Mib9ym1oersl069ovd1bsmb1+TfsntNDZyeOTtojMrDfHsOXYRFRRmZ41JtK RcvuB7RmcOG0hRwPDm9iPYgX1YrfX24C0pUm7qZZK6pCfs8w0e2Gx6ESttnS5mSADjFLOYSWpVDy jyiMEK2tLIrJKhgXJWgRJQIHQERWtz3FFVW9r/kwopa1sfRuGNuoU6SPUj/IVqs6M0NcHBUuNRy7 h/kPYUmtLFKI6b5ZrhSSQzymrdlK7zFkgeVnMeSDkWkgJGhyv87M2GaRGpoDFQJwEQSugwx3Z+b5 jqNUiikkRpNYSXfFEZt3RhyxjWXUGUJZSN/D3EWG4iCCOii3ERHdFfBLDpCuysy5BpJFIpIBOzoc 0US4mJuelirlf0qjr8bzBTfHD+GizZg6SJ+f5CJ/UWKsd3PaMKmFZkGSE3Qq29ReLjcd/VVMNb2s MJCU0pEqaNr0ubYJWMcu1pCg7LXtzFnRAXSgDIiGzJMaX4Oxt2pV+bxt91H01/L9RxzKEiFwA68E GASTglqO8MotB4fpOYVTQ60thXy6TeCeimHkERAuNCB2HQ6lgjHpzg5SyqZVsohCiCUSGTzzrBOi 1nICq4Ecu02FWhtKNpiZTVheqZYo0KuYMLwyUzcP6ak0HZxMBg9B0Sh4HRYYyIZpINDUoFzomz5j YOq8bHV+o8VpNBVomSzc45ZYp7z6RnoikwKFICCFyDNxTYe9XT5oM4SULGhZauzeuvDTjTLEaO2q O12foerTMs7Nn7Mpyx3603tSEVaFMpoYTDZFxDqEBHkvAp9GsWREEBy5TZ6PhM3UXHIDKiQLq1Os G9/Xta+UrkgrWqSRsJBw2RZFfUcHknJo32yeO5u7QEO7OgX04jYMG8x8VDdz0EZChhTAo5RhPZCj zc7i0CZzEL+figmuZrIWO/NU5bXIthKC0dyIKrIHJzuIm4U15xYqxcHqREmn8IH5RNbESGkkIM1j ApfPBBeY2GpiHrhWkEYVENmR/MqIOLrwUKI5E3ixL5MaUu7mPKaszi+Va+eyZsHjxq3X3eq60vrC vQi1BDVRDLDb05bn5o014zpqIbJRyXsS25kezJOXb2ZJIaMnDpxo+XZnF9mpj1Rj1oOrXNh8DBg0 WY3YKPSIF6KLGzhw5owEHJoVMcZkMz5ohkeSU5VNZ3KOF0kYLHQe6LgoWT9+fdKso5KRmiKdVqmX p9ARA/KOGCAXEQR8P7Oc2Z9GTB8OzrfwqFRQuhzXts3CKKvK9ms6NZx9e2OHeGPODT57FePQe+2V znsr0aML+e/j4YaymJmH4Gr7XL5Blyp1nl7qjKxlljWNCELwCOYvHdXYJClTcvxhhgD8sjkHiIiB qGomLxxoPcXZ+Ba0pEhjodetHacVUfwolCIqKl5W2d2LNUpX3yZmxLsOKZYMTrS3Uoq+NR6D2Q9z O2YS2ByaOQeZJxjCIghgsJY8JCxopSDI8Y1RR+l7cKMmNu59/tiU6RENHanonLoHkTiGSqlFdgJv qZi8AT0bkOQR48xGTh8uOBH2QbPwEj2IPbGs4cRilDIxo0ZIHU3hTowN+5cFxhjQcw9zvJJ3hqsf RjGRpMsOIesesPdSLJlhavCJB6yzODBYu94+Nl9Zz0UWMGhjBI57eGLH45skbanA8k6GNBWEyfCR gcg4UXEi8E9rc0WuxegnwGty5y6iSGuzzQ+C24XFjFt+Yfob4Fth9dJrnCShzMuC5Nfrfo8ND6Bv 3IgidFb/Sg05t7IkvFPinXlzvsuT25FyL0E0XCQ+b8oyi+Tmi54ownkg6WA9JmjRDv8Qi8sBxyFC w+dx+8KEnB0F6dUeSHM+5gEAkXqGAdOknPR8COWQmRnWA6Kxbo8gjYuSjR3tfOig4WM5NkhkrGVx 1msn0aJMnYR166xz8TPZog2YLjBgKOHD3iKMXN9li3l8L7VE+FbIg91ym1psxVExAy064NXtMLC5 MHQaP2SapLns9kESvE10bvo+1tVPTHRI1y+wt8OmN6uMzN9nwINkm8/Z8zZQ12NiFx9nDpvY9lDl zs6JJXxRckgpflwiA+i57Hid+zssOCnLigLY9rYSj2E82GP3nNHz13c9k6kER5s6HgrMs52sRT3h 1IWHlsSYxfPDIqvFc7W7+Hsg7HJ7TOlFLFWMleGtkomJlYz4xKyCRMkbXrHIhIu+qUFxM2NUwWCl vJ336u+NNc9p0aOy5a+pLwXydET4y69H2RzduisUKjiXMnZXnRzlgkODjkmjvhImDBc2ejoaS5r0 r7DcgDsKKMW2wmqJXYiCE+wQvMqB+qpeGopaH/gIggu4Mnn1tgmDotZV0Q9DCG9kHhw0b8MmLGT5 8osKzatTdy66R5FG69uF2Rlfrtqu2ddZ1rRFjsGOxSxc0T1bilGAURbh0DmAIJcmmKsYKuqu1G78 eTl33wp90kS1fDjZ327NHvY+zvJ6DTPP2FgcmLYFEXJ7FotJolZfKu55WYRVm9GbJfrdVm5b8vE8 SzpyYslDujpu2LmLmjRw4Yv49fOJfZti770x4xcOjS7B4PY9llXbzQozW9mCs6noWcMHR1rO9Fix JqXyDJhgY2Joko64rGjB7NHTBY3mrRLNXLrZjtkyXzXct/w3kgwcume8sDk+EmiHN9kg3gxbNjA4 WnQvYFGhfEMBnA5WDM0UScBzl+HZrXgUVw7yL0G7nXRgk4GDFGgcv0uc9X4dEnFE/Q7Ntnhb6efw zOVgpTEhqTELmZsTJiiKJsPOMDfI2c59itjg4MzRNsCpoGTipArN7h5MChElA1iLsXJk5BMtwbm5 KBiS+lhy8td88gUyL5lAzKhSnXXnybfk7Wmy5YsRxUm8IsGb4ZGhQLmmMcCCXscII+w+xy5mgYlC JMLOkSBtDSkQ9H59WZvAyYOHduySuHu5R4eCjmDsx4PZbGx0xdsPJqph+s5hPz+zPSfsH5iPnkTG /zU7T2htebK4idkTRwOw22A7RdYnEB4AnAy5Pb9rT+H7lvzFAv+UeSiPtfwJ1IoPkPvQ+miOX9PG 3AiY1RvIyhJxKx+3ufjYb0ec4qLj6KQUYnQTUqB1gvItevlzavL+D+D+Fv8cmHZP62IpyN9UOAeH 6gn2ZOTW7g8aNb4D4OG6zZu0/RuGtHDQxR9dyu9Went60QV2b7137t3K8hhjOb1osHIbIlsOr71P 1jcWiyuJ4e450jxgx4Q0YQRiECYgxIwko2tUiqSlMQoCA1wFSJmX7KYuu97WFEjXwI6xHPVS962Z F8HV4gQSTAgzbG7YudAvqutxUprEDcqGXwOjge6ZuquXtTc3mhTNIKanTlujelVbNdXZJHK8vW0q zSFqnAQYVuxPVO5Sp8zK1VO32DT19qutN06h6akbTmTNalR7ts6DJoWxNz2083XdVq53tOpO0QxW oW7wHd3Jt8xo0OeeIwQRau+KubzCaAGWiENAzMp9Tq7lu5qwlJF4aTyqNP5+f+P9v8e4c58NRbO7 pxXuN/B6ffXdig7QRMICMIKAcIitYwwVHa4rEYwlJJFBEo0wWQgJkDTIYhCoSTLAJiZIWowRS2L8 DNffdM2Ht5TG2BhnV2tUE0bLFrjCS4NpihYXGFdfpDPo0eFFy9VbQqB7NogiJGRWIMVjsKUPpOpj RQoWTZRdx5ckmIqaRTRSvbQrhO3VWWuZ2wcPcyllJNZDyd2nH4k43y5USTHTZ23vbCQzknCjo4Xi JaQpGbo2bKKq5mCSYqJMnLNh6cMFXLhsIOFz2nV/Z1m4pBcO+jXtG7CRzGaua2eHQPPLqufTCPNu 4TwguzXqxURdVu9QzldraabHOx+lsiohRB6DqZ2iBQIjUWggWP6QeOSIlKygiqUzVy1W6gyydTHt ljPp8dwtu+9b2ttYkPCO0EsMeOdjy8XM3HpITsP3uIWEUWBmrLtPcac5oMiDjDaBBKLirRllZtms UZKg71ZD2Y9Sh8k9mzBs0Ie2o4OSymlEMCWmKrXDI2eEBjXXDIxkLcTOZEgCfN/SK4MLfx/KmQkR CHaoR1wpp+leFus+3xCGCqhZCVK9al1u6Dohi9ixRfLnouKXFPlrBmURALN7+D+jcmN87+W7Q2fD o3sXHqvChE6wcLE5mhMHjypZ5k+zP6dIZ4LIkCtmD0ETZxjrjTOpEdiU4JZhA9dDCpInEvuRCw/Y paJEoPCUKJ69DDF8HhuLux9T19urmFJah0eGtdlYvJRWsW9WvBUNjLjHvOg7P543IoApkTa7XMdY K8XrwqjNRVyswPzkPwjKWyzcvlxrs2x8mEPzjo7IROJynRDDkM/0QVmAVzFE6N7kIFVaKIlERM9I RFGmWNiGDFz1flzylmIIUzqWbPD18Wp58MuebOUXatmjOOqvW/6Cn0n5BP3crK/D4mo/DiCuNxSH +/IFmLXaEku7zSuOSm6VB8yOaqY8iN4zem7qhM7BfHAZb0J72bcOPGvePNb2snbArPF+JGTCQuq/ CVnTecPDhoQSpsoySHBjYwpWyBHREMkhODDhkxxnEzH4kRxoJM7IUlAKXiC7dKCaQwKlQqIJ8bS+ BrpprFbj83PALs3NEFZakoE0VSWL4Ri6xI9YYaBU0h9T04jY4ia0X3I6H4nhCEZ1nBJQOIA9CYJJ EaKLUdieEWwCvMmUsULdBMWOfNV4N8RSYUENNwyFTPHIlIMkNYV2MBsMk8GzAxar/GyQbJju1ns5 slPDZdpVODZmZSRNFIRIvRqa6HJRhTSr2cNnGINzHLA1QkO3xDHcyCTXgmQ5aS1yk7JXLhrGQGVP whqz3l760uYadGmeoz3gfQW0ew9EmRdGPgVdcRsmo5JEGhYOD1ZUZPo+HDro4DHzv7kx1cr2hcoO n6KPi6TGWHXBC0SfDw6FFLxbJDOK+sGBt+y4QZ3o6cX5rKaEk0cwbHKN2aeOtOHKzl7t22/sq54G p9ZmrzhR49a9R8+Rt+MPhBJisz1OMIxWMS1rYssQ2JokLWdpYtXV7jqthERASvu4p8NlXDrPpzbk /RsuDwKFBbsZ90MdEEzzkmyCih/gvZskcoPD7uOTs9Mnno4e34LgPswFx2cd9jfXafVzMYcQIFct l30oIVlHfvRAdEqZobBMSxPSf0HmRoYS0O1UOwhwa70tu8zgI4cauJCS6E2gj3/Kwsfl8fdTUyWJ py3D6SX5oezFwsOcr3Zx5hTkFARbT24qT0uaYVqYZm7iScpE6kSUSxtENFBkLWr4plk6I9iz1wUc c5J0ek3cxAG7aBw1M+7GieiOjvBsHAYpjAeFwv61bRb0esoIV3afFnJSXossvaDarZmGs9WmibXr zqT17/R/mfoChNF6Mldeq52WJskUFihoVS52nxy62MPrugFUuV8zvR64X+HKLKlj4WJmTxa7S7Cj eP6MGCyfRs80Gy4auKZvJI4TowWNOQZI4Jw8E0xshSdmQun87CP1rpkQ7RRPTxk8dtd8ZiZp0reu bDXnLsucUTOauQ3hrIMKaiDx8nkhRtg1mRIKadGO4M7n0DyA75VKWzJlTBIF3iiEjBDkSY0IB1JU JQHh2cvsUU1btllvN/Wb06KKLGbbWvXKzpLdGPVHHTHVnbMaKzTPA3M3votv9yOJEl2Lv168tnD0 MnPhx24aZNFlnpTlodvTJkaw5QmywXASxtRziwXG4EnPJOBcnAx2wT8C/QNgGO3KhiCTWgTHHFIE 0MJZEuiGNljsiAyWL+xBTJ2ZEktEnoUzokJZq+Hhq7UcM8mSMG2Lc58PLy5ZPLPd0JgY9HpeuQej x87MkhJia2+C/hYHIOKreA6yMdSWfRcwUeqNrYyaOCJskKNnC6igpJcuYwbKMlGNFGksevV9BJJU EA56OF7qvR0SZOkYjBxOjhHq50dweiTYYkPAUMkNId9wQQXQ/Vkx4eh0ei8HBzntPYujtaZuIlqR EFEmewvXcgVNz5CFRxAeYGhIwOl4MF7H9OVy7HXFkdKlmvb24bGSjXgIVqZnBI5FLlTcrl71c/TI e7C0WbHG0YO0yIljwYsxksdmjsGsFGC+nCg2bINUJsG3k0MFKYYcJ4Gbl+imMjFjJZS9hsX4MUbd BDXmE5jegvaZNHsE2bNp2HJ2LkVrWu8jVD8OPvJLPbJui+HwRehrR4kj90Zo+vj3YI/Wj94ku8JB 9/w0D3Pu5+CPY9z6D0DvGQyMAvoIgk0QNhDA0M034+R4jz+rXbn2bNtXI5urlUEDIh9V2D4/p/7f pM/j49gkzdQ7BV/vTf/F7CXS6/wmvzKZaMzG+zxpVJNqSbpEUSRH3x0wVU0/2vx2ZuY9gXCf2/uK Mch15C4LVC2oyG83nebNZgI+4cCzurEvQhdcOJTLSb4kl101+aqu9zl2yZjTZIZFcAAYfD+fObET FCQZvqjBhUn1MerYG34EXSp+FRERxjwUCADMplQbwQsqCOYwkBLQwimVIhmxgldUiMkKoNEiKELJ eSUhWDLUSsklhKCMCYwjJNUiMkiLBIwEwXrGTNIikmEKySZmCtmlbSMa64UXz0xw0xJDRNUViZaJ qIUGUEoQzA05YwiWkaVVzXCggY2YqMFWBCgYDEeGjbmVsjJG5uPB7VEIWdmAolyiqGIKY2FEsJdl zUKJDNOA9jA6BAEACTMjt5TI9Y7BdnaIdouMvRm9rFrEYi41MrpbAIiIgTfCogJg6RDiRvukRikR lTZvSlkRgmiNdzdeN/+5hfwT+h8/jvalR3bFyP+rzfr/wVRxsY+74uMmTqlM9xswiv9Vr+V1vT6r nW643/suf1er+rHQYQKzVphg+VMCTuJN3KHbvjE2Twcsw+WhuOmT/hgxjeLn3ZlV+Tv1/nywnkiS w/ereD5mV0Q1VEsqGIqB+cnH9IrxKrJUwt8J1/4In5qhDnNxjgyO2/lxEJPtGP48nIadcXO2aySe 5B1mZFVf6GYF7Yucn+XuYByks/1jycD/pFI807dZOhRmIqPGIuOYkO8iI8cMJYVC4oj/8oAN9x4K Pcc5q1C2EAjgsdmRkFiMYn9BH5K8g3yu0RYrEi0YsczIgRS9uw4CS+COR4SOSc4hBFWHjems0LzT 7HsZlIrIcucNaPdWOr17XvT3UTJFB2rb7v0MVCCTZoqeDmcqum54oJny/ZbyAkQArPq+ad+dP4Jt TmyAB8CKgfgqgsYKJAXVmw/rNpdeoXkfZLz1u46ct4f5rt+E+H/QF38mr8wW/vDVA2DVgPrpNeur 5riw11YJ98XOFUiaeKfug1k/2bXzT+oxLJJAHmLzE+6Igz3u445rjoBLCiXo1BkUCQAhCEQkhBGE YMEZIsGQWKyRZBQWLBYLFESLCCkFBZHwCRJLEFVVBUBEBiAoCDEkQUQUEIigxQVUgjFUiEVSMRYD IsYLBYgIiCEZIxIJBIoIJBAYyDEYIiDEQQZBgRGMURYxFiisUjASJIcBhiiIKCwRUARhFhFICwBU QVQFhBQUkFhBYQYyRVYqsIKQcTEkjcKoqkaCRlSEkFbIkLA0qERaRYFBCYMIo4CFloSYkAxhBRUV EYKCgsFWCrICxYsbBGQkskqESUAbCAqkgqikWRVVKLJIyRAWRBCIqgFaAyRJGRgIgopGMBEVISEg qQiIAIwhFBqwWCkUbBgySRSQB/Rn8cl3x2g/7YDeLa5/6DtNha38ofVQT4CJyxREKYAhVihBoDNa E3ABVCh5gr97FShFLD/6nzESkP2gHcxKB/zSAe4VCuUdo85x/K70NRnMHpIGRicOQBk749E2khQS GQDiE2kAW4m0jLBCSn4lJSULmAmkVWmcpAbNLJYpK1rKCPUUKBlRjLQhoSGdVGkbLeqYgUBcAMGC gXINr4XTncIKEqQaFhL7rscINFO0ljJ7w3GW8/z45/nIG66uWe3Qtv+bcyig9I1DDg4zMZDVDYGU q1i6MBMFuCYBBXRBwGmyq3KowVGI2Qb1C9VziUI3igFFKEEUpCgGIgDYWKAtRbJC8uLzWH9p9gdA SW+ZALW/Mgo/U/WIf7D9ShgGQ83FYl2Cn8Qrlbi4gV/z/qNAf61C9vIwiP/BmX4P+RJ/mNIdU/0L FIpFYz6j/ZOMSslC7tPBeTMeKShCiQpNJrQOYZnMMENk/vgtISqkJJUpFNaxbr7CG0BHTcrpoPiG c+a6WCB/wGFh/13BZt/pn+eyj/C/Y/qCQ8xAGwQgMgkEFYCICMYxGQEgyRRnFJJSIDGCwBihIJAR kAikBSRYLAIIkiyQEZJAUAVYkgIYBFGoCkFgqXhxUN2I/7ENqGJ1KBpVuTDACkBf+4gin9gw6A/+ ELsMTlh4p4BNrAPf/IezG0EjEd1pUUUEP7qKivacyNyUWhnUO6h2mxQiGwhqW0sl63JcDBYsAvAy mT+5y71A4FDcSCAp+7/W86gLh4TGc1AUymMwokUpRiELFWBEYSmXBAxhAWuUooGieyEkDoREhIh3 CzygkKUNHoPr8heZBgMZlA3nDPgiEqkRiBvzFqzF10vIDbBDOvjeR3n1IF7qhq/hyVcZEYmnb6D6 Q1khPe72xvFPJJ6J6kveFBYtmLGMgIy2ccLUhRjyrvuRqYByAuPA0EDuZYNJkPI8tFWSmyIUU2aA 7abrh30BXUxwAGxEVg32YyQbFkq0hKUJMwF1rJMlSWJEUZQIf0JBjCGpiiXQMdvlxrRjGcYTEm8s NphiPtEqFrFgrMLe3QSEyIQAB76QUbifzCwFWz94eU4hhDU1/aSZriJlEPhwRRsJxDd4XHsz6b0K ATnVzg8nQeZgLxyu+ObxCZTlDZCg/8NGkcD+cHxbcyUHCOyQ+c7eJRTzzSr+mz45QUtWXbxdhCpu 5C7OoYCXDyq1+x4hz8oOcN4m0UXeNNShbMxkJT4GypeUhylfa9yzqKVrLZeomaSeQAFrBRxNYovD lMh4//3Mh1AI5PE6OBe//DD/tIgdV1AL/OEHW/yAJr9tw+cODwCEk3Yq3AlilbZ1d5Nak2QcTxdL eb1DBJXB2WjBC0G1FFJKSjNiTAlpJuH7BSfk+yX1+kXFougWk/UVkvFIl0Bz7m1Q6kNvWBgnaWM5 hh04hZEX23uDZykWEDEMQfJPAMAEuE0jxVD2sZn1nxdUcDswJkkpnJ+6jYmL/oJg8H9KCUylHcCR AwIqGBFF6AJm3cvC7kQ6FdRA2QIFQCLfwuD1W48woS4ge4FXlRTA2GzSCZznTKnOK6NZIv0nXwKZ JPzAAh7wYZHLPrtIOz8AwVIKCmqqX0LxAhaD19qe0iMgSAeAanfgKGNoKC2nlA2AMw+dAn6gBIk9 STgYf82DAooIFFBygREtEVDQi9yUoXoedxqgbAoYqj1xRDOfANtGIik0dvBN0zYItGtolDW0ONEn 36MY0kwQSigoRUihRDe5R8B0GfMGcX2p/4FrQwCpQ0hl1DBN2lBHlAsib3Q9ZbExVKCqqAm3+g7O HtNQJ7TsuAC3KOYz0INEbJa6jw5gEoQqHRyAZey4yIZvKyUMpRojYhYqmAj88S7Qp+Z/tSbWjaf2 pULMGCa63EKNJstzniHkLaDhQlMP9ZuWHlokVlCkkrCsVUJUNC0sd4n5nYNw3g0G9TJYGiihfUo4 JtC7FiyBALhYlA4qMKIOA5DuEM+cH3hEEK0KHSmfLk1AsbVQoKSN6EkauSyK2pKAzK71zQCPJN33 0u1+cqJEFCJC0yZUzaC2mVIvHZjnBDQSmQF5BQxgJJE4+hQeIOsCGhSKPEeoMhylz/3hnxUXOgmZ VsDAob0CFQIJQXKjyZjaFl8kkDJQHmAntLGtin791BSks0kM39GcYXJEenSNkfu/vJKh68zHIh/i AIf8Nx3BERj1Gdy4BZYO68PB2ZKAvDAQ+inSOpgCa07c+MYd8BDxP+OQsh9JpLUPKbFuCaM16esk M4AQQN6q7wozYN6qB4bnPBxpSgZsShCgnQSQajFuS1VcHgG9L0LwEzhrMiWFcaoYtmhsEaGlp0PQ GC7UBT0Qg5OZbnYTld9BYmUYZwxIa6I5AEgMO40uocLlZT7hJ90kTyHaLp+nENI0jiEihSHYsnhJ MAWSoVkICisPVA3DyQ/bmucZwKpAgHd0W6EsZwvUCDIJHXE1kVXWY1GZJtldl4Bj9+JfcOYNCZnS zQN7H7rED2QQNAHzewoLPsCCQoMEUaQSjEZ+MT9kcEUREiJMlKB/VECh8BKZAZlD60ggwPoG80nE +rjHoAPmceF5hEdqlizlyF7PyTGH3I/A4IYGdzFP7lgdKDGAPOnMELY5i4LiGwpWUUL8GMhYuhc5 JQkk+++Cj7ZShPsNvNglwWACIcznOYlvwglx1U3xD2gaVfSbcCzRCynLRQEFUsQQi8w0hYiQCIbB eRMRbCwFGxQXoLglT6YEKJCVXKDNirCpRGFSpeit8cC4OBQGOUuHFvCY4KeyLkSCmARvJWCFJznE 1KilQiNy3qkETOwQUpKRwjexTi9pMC/+GckLIasmMMw5srOJ0cMRFGakKe+zEwklGE3NRYtUm8al eBSjS7G8bSJP8mcfT8ZqS3tRHCwKubaMEIrlS5MylIaQg6aLgMST4wgf/HR70BPkBESxigqqMfDz wYEM0qMIxkVzKE/ahf/ksD+07STubegDgfkFUjTQJ5AxgPMaTMG9PcOdRB4gI5/iJgqZA0i52wUO QhEOgfNIhdN0xVh/LKOEVOfzwy0f+mv63r9hVR5+2wTsCmuf+2iq5eYC4H/t5Rod6plCDlFeu5e/ wklZOsKihMIq4Z3ZoxIYYUVomA6FIIoQNANSchBQqkgiGtKKzqovZSH994/N59fGLfN9jGRvhBMP Dn244tFf6D8XCwGP43p9v+4PHqEP8vP9b/9W6f02T+z/Cf2Ngf4v8f9wg//D/BJ9HEvL+/x8z9Qd PTa6KHf7hvDwPye8l6/4rzyQzZSAxOGBSKSEvh0MbJTOZGZV/vP97U4SmP7QSP5hVAqgXCUHCPCQ IrQ/BImh/R54kXkv4lfTaMRtDthOMGZ6/3atMeZvD3zH7qUUyWobv65MBuDIC7Do2A3bcDZ/RiPj /Cddx5f5k/tC/uuv1fN+5vQC9+YNkDKBjeAe0YMGJ9FM60GLfg2ci/7ogBrvNRgXGhMUu/0q1pl6 uAYSY1vsYoFhz/Z2k9A8w7GSdiAKpFTeSFhD0nDwh9D3kyqGcJi4JqAIIB8DwDoFu1YWWbnUG6KF wLjAWiaizJCSqE25XQWhHIbQybjJqGyJk0oySRjnRTIjkUcX/UoYXCFCgW2X1aqxMEP9BmJM2ZxA Dwm52fCBBOoWDGMYxlCAsKUppFpVpUhCkqlIg0rVChSIqRikFESSkpGlQIF4WtsuApzwcDBg0uN+ YVI5dC0RC9aCAqoUIt/9EDs7M8FwRRjDiYQRPmwm7SGLCBAiKIrqXU40AHqRMepif33AeAQ4O8ny lW0TlEjwffd8ZYGEOFKukYLKT2T2LRxIWSJucSL+MfhnDY0xkziT2grJR0YKbBwGjUAEygRri8TU N6XPLiiWEm1evEnv07vsvrMkMZB3nunI1opQpSRRISEQCYBvYqmKhpxGY0USb7U24EVjFJuSkOMS SBIm4SF6hwWKgsmsmUNZsb0/6jEQcFzmmkzKZ6aJSkg7QOKguk0jrxaxOklClUkqdilhYgcVC9Ga MHJAkDj8AIZVZxC/UYnrqKLLipyVJSVhQ1YIUQAJDoXhyiGBvQhhURONmEIUDtXLcUsvOUs2FC6E 5KGmIkHMx0NhCi8ZEoSJkTQFzxhGQdRcUWQKtYsO+I2iyJZiFoJaBIhkgIacByqwLYAD+/59ogpS If5kGErILIP+BB8J/tZLAYUPxyCBdnRDV+wpBxgBIoQiGV8YoEoQUQUQUQf6EFSs2VBRBBUZiH+k TafjfcftKykIxkJ0N50NzmIwYkjOgYCbVRZIe5JQQ4QPbihGEhIrAgmgT/tOQfJ/1+f+x/3Df7aO nq/iw/383YOwDkJDfwCw9BDtewuGxBOkCjicwh5bLg6zmOT3AcG0zYORJBZe+QMT6EQ5x7oBEQkd p7LvwRvg+rOaOOXG/PGeBo1s5OWXLhq0Y8M3+/0+10cnPOblHarB13RtmbNmxl+8mveGh0EB6MCd HX9aBBOJx78z1qcSSXtKQKL0Lh980uKm+1ctExl4q/fr2ekBE/qRBERAkk0bvy7Bus6dN478HTQy UeEcySEmTwcmRUF2VTB/JPC0nu5wsdOYEMnZ0EGDGpFOw2n8RD657NXyPbBg5s9UYoGuPh83ICSc DnCT93/L3Rs4G/DCZEcJGPY5xywoLFyaHNOffIqcumm9mS3Pp4XycOs3FnRbh1Z1ioxlk7Xbdu8G Lds5ZKvq+RoPlL76OGFmx6+HaeiwWvgno9Il4Gh3MsdkFzoRZKKkKLPKI1vdbdgu08uHRwyNz+B2 4bnZDo7CQ3soUc+/tj11EWDRIUYMkHQKTCrV4PMJM5Dykholxj412Ube59WOOD28JRdy9Nil2Tdg 9cNWeu/guxbTLo3bqDbLFxggOzalzGPIGO+xuC3NDnXQdkmGThjkq0cMmjlgnS2D16wYpdHi3t8k g3kT1Th6cHjC521KYHn1RRHg14VxYtHpHr/Qk/kGbnc0Z5tx62fjV7KMEuU621dXdNqsHaXVM/fS zhno1dKU9PR1Vo4U1cqo6q+HOW7zqaunBWjZx+8knhj101XZlXTSe6Bth6LUaBu67IC55oRyUwep ydXOvQJ2eqPZYgQ9Zz2aLbmcCZCTe3CKq1QeH9YiZaKcLnbxo4LumXK+M83nhnIN6mzRRY2ZGCZw aPdFk2cMDevTapj2dr6GIOgUMtnls5dM2jpdMH2pB23Z7fvxc35nLxlu6ew3eqPB2swpumRV6z4e muDrFxx4dvT6n4SHxjbjposKqNbXsu59LHR6PJhy8DGoztRjRXsw4IGOMXGN7ilh4TMEXdNzfPEP Q2VVQosMQejpjoZTHOpBU4EmhxMkGRf6w+MIZtxjztHFXnZt7Lb4eHYQSKIXH8d6MpmXXdt027r0 2lHhtooZO/XqzvQ3r4ZbUKLWaPGyvnBoa8LMXldu2eWTaiPwB4enSEon+VKKqzBueYUeJ3KdSRgw ULkUh9nUoZDz8tvYTecDlOU44YTgUc5zkLjm6uuQc8JFihc1RAl4/xhj5TG8AuZGeTEQc1wfkaU6 BTHrYmsEuFGTZPSljyDgdH9Qlgnhtk0a0K5vo8RP8I/XKSOImVdNVbcXb4csXaxIsSGkTHBoOFpI zE8656EyJFXFBHEiDGNU2wcDBkYSGkCsY7xOomAXPqgiJ0jnA5lWwLBrsYDhgeSJ6kU2nAWgx70T URU0BFX4L+0EIId3UVdrpXDqoutjZDGApI2grIoNxC4gNRS8pkFZWMVbubq8z/V4fGxwDDgTQNgf 4C9RTx6ckIz6HToUkWDv7+x4iEyAxkd5OH70TSV64xQUEEBcweqDNybmzsalXrLaNnH+WRFOOHl6 jb2rod8mTk/OUKPujZ7PguXaGlYzqztTBOC+hfOsP20gziRQyAig+8H+X0y+CbOqFrABK3GKaUPj FA/uLxqwIP7chfA0OY8O1KeBIJsd54+LQPCRSvebmqrHBahwLb0M3DnBR3w+ujlLbszBjISYtEry cvykwfdsZsN3bVV1juyZMXxMVHmgt0avCr2TxY5YdNirNRs+pn4/RKoAagbcGhX5qr7A5kwkJyMo 6gnBziITNoBBYDjO91WMSScXtDYqhAlzORslXhZwmgwQFNnr1w04PLhl62d5DNgwemTw47PDSUPK +ZAUlpMjSpOOZwhvCGpXE30G+g8i6SKHwENph7wdFz7Mmz45o+1KEoDKi4qwsDGr1QLJIqRH0FA1 cTBxNzwUvGZuyKUGUy8EofaBmHRkM37NINjZto0HUnm3lIH8/1/2FoT193zseIdYQ4KqwFVCl8fY mTr6BOkAVuTrD/aETIkPldMgVcTdh3fD9huRVO9geg4onmAfVE7DWM59IfIgsCC6+oDOZRHaZD7n ccUi82qhewLii5WhS6NUtXBHhBxtVxVibQOFshhE5EPnoQyA4omz3C/5j4pAoBKDKQSxLAS2Slgh QEsELB+8WAFFhiUJCqE/6zE+3AmbQ+DiuUyjZEsAQCkhyJIFMWQhSkjCURhQsRpQhShBCgAhQhEC mRKNkiWwhSwQsIlGwSwECokKFIiUgwpIFDClSClIMKSDCFgAlJBhCwEtkpaFKAMksASjQEo0EtCl oUo2CUSkhQpEShYUpBKSwj+jeufEgkD+uhNKdWiyhYgyEj+y2qJifhGH05bHfHIGg41f209B93sD IKl5HiKETMHXlWSCyQ5wiMApogfYdYLZbJE0iJmYofjSSQktIovyrJ+tg2dD4JEZE8meCQUgyAQj FswMDZlmNhRMECxDfFCQD4QU/2xQ7zimX8QXgfixF1e4ftE9o3OsjBQiJmYFIL0Zt2kbhbxv5Xqu T3On1RP+DlE1D8R/F0K/gdyO8N4G/hpTtH7wXKFyPaieCBZNfNXyBeIB2604/ITlA2cQyh0B9Ks2 yX1a4RKCmDilqEsrlFzAaYkcf7aS+LaNyWLRcYXaWgARD69xcHBxK98B8oDIaQyAyg04YhyAOlH+ cEN4GNkiZo6MyZxA9CRJEV0DChBjF+8OJxRLzuSEiQiRsJZNcF5M+kJJ9kPGhgTI0oDAsrRGiksF Yyhi3JAh1qSX3T4faQLFQURQt7ydQTYJzN150KnFUDSJatp0xVE5F1Bksm9mIiSYEh782ZjCoSpG EFmSQE/UXpERE+j8H+dUiPgvOva9C6B7NIRNQ6FhybO4lCkjKCAELVDDDuMOjqMfvpLH6XEJnjlR TO1spTKPz2hH5TdIio1J8cme2tkEkzDLbAGHhgdBXI4og4cRVyEoEzo0Q943iot9JQqHVkOmnOh7 QOKgfeouAr0oA+oKZzSkYmwB+9yj9wfhcHRidgflRqOaFEGAM7IBQUhzhzgNweChk5Ex/OZB1h9m TwPJHvOZYvwOsR3pWKhY2gmh7bJAk7Iyip6m9NqO2dICXYpdzYAf2eQF6HVejlS486mQqoeR/Y9I p1vOuDgh8crljd64/L7/0Y+B5fHmRFk+Xw9O+wMe+ErY5ct/4j7SjCqG5mIIcPAoFFGM8foMjb6Q cJQzJGoRJHzCYpCYpschySF4cUJEx0SpIubgiVw5hIJTD6Hed5rzlmuMmbOZzluz1fy5VbfTvwz0 s5XeX0eO6LMfDFweVdi6xi7N5IlR9jDezrsp1wwVoydn0eiTMljNpPNGvPTjenv33jnmuL296tWt 7uvJ5YRrUsBiYhLfepczJFrWNEcZC6Nvwi8elfRF1C8GKEDTGiqFNnfjk+IeI1LGrR1rSOWCpPG5 zw0YljjBnNHahSLiH+MGEzdN2by06GDgvOHnmgv7ND2F54cCei1Gg9k8sUHQwW0eit+6LOYOFFHU G67hdvY1M8M2b9ZEmLnyxZmSKuLPgOXSjKrEna+nbVo2Ys1uEWWZ5c9vzx9ySyIHmgREIABvxxpi Psbmxo/jCBcyNjdWDa3p7b18PDhk1L35bZOOWVGirYngoy7YPB3LueGj0XDdHPRJIf8MTXD3cMFz ZocMmyaiRRnjpFgjTKvsIcvoImQfBEpxPja2A5z0hHkYmSvOByaN4G7t+MZkwerZYHBMODNxIyFD R+Jd8XDJonGgmvFXayzDwykNnZPPDJ2dHoq5rZc0VJZ7nE31w32neyieQcPLfuSgZzgUwtjp64am TzCYPDw3bsFWGn8jFHZk1amjPE8o5b0PSs9aMWeBc2W0MXION9a7ikF5IhgZEBIB0BHDBpnfl4nR BIPDdiS5o83DVEs42IKSNykx4YG+9OwnItCEKVNzItcdDDfpIwI5xFAkGZc3HWGKyELk6pTU3Xs8 XlTlu2U8eNnhua1Udcbb0eEMiIn8IYrZZFlnXJq7PC7NdxZ5bsF1nhU3dbHDRoz6XdWOnluydMm7 uh77PHLw07cajjksvKO9Dmt3WLrFvR9uypg1bMlw3P6SH1G2PaVqxPZ8PhqnGA2Y5PXmPRSVZqu3 dXqR0uqi2rFV16Xc7Pdlls2ciPPC/Vu/DeEOMHRApb1rRwOvC7HDh2RddGy6jOGTos53qwdM5pQo 4fqmaCNmCE9sCigpo5Mh3wg6NnC4U2wUUtsHKAcyUXN7JGMwdAWD0dF8dFE5OUF/LsI4Jc6w8t2D bBtxpc0KbPik+x+Z5kPB+NJBL3FDQ2cXMYOHGRmLoTImwfTR1DlMyK7Fy+OtGE6Xyyjp8fhfNo1b nEHOh+lnl5KVPB+77YOGs3atB4TwjRdw6ZfV/hWI7H1Q2QkJnOB9rlO/wwCOp1HjhF4gDJntssx5 jzB0eY6bSIECHU4I6g8xHFoDiZzPRca0OCmgQGajZkvzvZ32yduDo/uFfObnhy5pq6xzNmLDsxZr PLRb6ySbP37iOklEx0ziSdrFCrZ+TCMKONRZwq6eyrB2v3fws9pZXl05Uz63tOVmXovMF2iOG9Mn DJEUY7NGCCwMd9myNDIHZwclhuBwf+WQ11JXRiChn2KBDTHOZJ8GMipYEwmOChKB5c8iJC5M9kG+ j4IcJNkmA6k6OurHqpFOujAcHOFMu03XXYKapy9KjvJmtw4TbLBV4aNHDvvIydSGTczs3W5Wr+e0 R95/YfckH+OMQzywMPpb5Zbm+wpWgxq7gRSRhAp7Wnz7mp8u6eZ06FyBqZHYO3G+xImT5EOBiJTt rBOZJReXg8RpmivF3Dwu6w1wLuds26i30i9lfo/ckYOcnCNPnD5nB9Pl8+Bl8vl5Xkn+upRT9YFB lnp3Xrey36R7rZieAn2uP0/qZE8uZUyLMduCGY8UkGhp4fFTEfUZGb5mTJk3412cPZhdLG6riMl/ 1DYo92FCSxjWwgwKZyaIBQUYk6db4M3DrfNotiWZySf2kfwj5xPtMH8R/C8Bdoe4Q5QDsJ13PXzi gewR2ge4F9BPdk5EXFQ38WLcmwAQ8XtQ+6FxcAgVdAIMh+a/uuIB/RkKH7wIINP2Fn9eP0udqAfs AC1e+Avl9g/HsAd4ZlTWayUkKJSQphSQolCQphWdOwPJ80MRsfX1PeBc/N4Kcf+p3mn+W9BxQB3k QAIRV6hiA72CBYQfl4ifcNl0e0+ACOTJcJ6DtpfHlHgi/IT2hsFQ5lJzomZ9gp8A+75A5teRV5Rc D3+8ff0Q6yj0CxQWIEypqh8AMv0UPZuF8kaR6fjyAtwD3LDkXkR7O5faC4Iab0a3LuY+Qolxh/ov Okc6r8tI/TvmozJDr605RwA4Hn6DjkAxDz5fNEgL9Mw/1q8fxPmfO5kaCpQRqXPEPIqlDz+4KdJn II9ZlMpKSFMKGFEpPo4PQiQA5d6kX2A0oVnLB+XwQNIXgJyj8A8hBzKflBXaq5A9M1wducQ9RNA5 w606x5UXKJ4vJCjxCzIpnNRQXh0qoI7YALIqg/yQFqKAg7DirnMSgmNAVBuoDMRjGoIdq3jQ0oAR fAFNIuiaYSBOZMoofgfXsHP37mEfrWDqwmvx+P4DYJslcs7oIiVDtuLuwH5y2qiIqXAwEQgjFSDB IXLyz2RPoLBQ5gDBRNGiKaWIfQ0htObgIu1BBCKalCZ1IDHM4JwOpYj8MCBO4qfiUG5OX0ZqsF1H Cxs44dGKYKaDZw0SnP2MnSso5od65KOXRdsbtHDBZW7hVTppS+xVvi+vT00/kd+Gxy5YnHp4M+vF GpfDwIN8PhlT5U03y9WrWM13nPc8jvrBaybZS5C3+fIPRiRSwXkgYx/dHou3Z2OeetqrmySxB2f9 8h1yx6OHlzVXSw9MatTw9O2ii6bLMzmU6mjw85fp+/4jqdZFeju7ot21dsXRdiOnc8Pfy5+HvwjX 35UcP75CycOnlnM2Bk2eaO8esT+NTFgq8q43YruXyQbM3l0yaHTnVfFsN3pwp54XNMlGbhs9480j gwLC3PsbhbtRyEoc+Dv5XDhPouGyf1WZJMYJyGiTw8EbRdj2liiZICgkxYWhhiTJb0QVdLrzwoUf 0kLPJ01YO2yYqsW7LChLNuXTjvF23ZuGhZOKCfL/SSJ7/IUTyRBkQTMkXsam5tqC9x1IGhtreUpc jkZVMMPuk0nO+XdEWNl3VNNLOX0cdzrpybMHx4eGjRtk7zLbupi+x7z6JCfPBkya8q1drvDHdkY3 s7fBZiuirNknObZ7kya1Vfz+w9uS+x9PB0G8HBr3sNwouFBPVY+FvujXhQwQZ4EkhpSwoUMM5vBV EmRLMCZkccuRIv8kSZhwUFOh0MEfUe9wEMQsKfkeohsaoF8ERkM2KDE9jUexI5jtDSRYgUJkyDbF VmpqzL2at2dWaI0Z4q63UO2TPZZcTM7Nk5YuaJGPXVjhQpwOHAwJo2OeiBd2dj78kK4zFkC5PadY GLYvMx4VFJaOYLGBkogJEHII7PDmczguQSc1n10cDqjTGgpRk2Ls2+mpu6piwbHUTjhmuyOWpo6q 0faOT4yH5fOPWWB6eqPLhGGPLtj7uXeN3e5q9Ftny9+F6ZpRwae2DB7uHfG7wlNnc1bstnZbvIob tuNFPC7B7SQbs1WzhpVsca8cMmSpI6b8u1HLpYzyWNGyrq+zPuNGTRn1vZw5Yn9USi5lm0WYurtb 5ZNtKDBPgdFmFLSdEFB5gaC5JTiimzyxMqKWTMvKxJ5IUwFMP2lBEA+BDw7juQEROP3z3nsHwG8E uKQpPdBwYKbOZ3lbjdu2nseu6RCIdxM51Op0Owh3GPYoWB1xi0QoSDyEUYvt0mVnJxF2ZsozZOmB yff4uvdm6fCPn/hMNu93Lb08O2Jd4XXfYPlOY5pKUVUipgPxmtkWAF66ztsgYRKYBGKPb0iBguUZ CEIwg22penmAm41qJqJecgPcvdwVEGQ2FeQOA4JHM7PfbpOY+46Q7kSHLB8q/qhvtTllw3Ztuo9Y VnV1XDnHnIs3RVkvIUY/Srwjg4WatGsP7J+n+Ue6fiiD1r1aQgtIjZEaMN2Jvje27J4XeF/oyQZP YYFJyXLmvhrJ7LFaHMFihhwVSnHlypnkXsXyMDFTgxGFyNBwZEDQiXBSxys3P6yHWhSjhfhiXYK2 WaumJ6Ji5vT+wPDMZ7qOco4h8vYq+4Q2GR5IlZQ4jxsQe5MRtS4desIi6jJIip3EyFJCPLA46ECX 3Czly3bPpVerNdu7o+exi3aOHKnD7GKrRy5W8+fuU0eGegzq9H2MXrdyWO2Kzm6mJuxIFx7hOVPi mUOfj5UQLRhLFEVCw2kWzSwYIZTo554Zy3OGrbv5FDcYhfuoLchgrTf37HHS3nQxo/aScYYT0MOO c6u4lzwwYPjjqeVKCkUgeGljViXMzWXLYavlY8UeCrgdWxFM7iSwO/s4y92RtY9+BYTlxybqh1vI 4NDnAqKMh1rWGVi6J1BDGCHB05ioyswkERHhdc/DPQQ7h47A57jbkiQ4qPDr1ibTpYHMHMSLFEiQ LTOC+gKR7tCpNw8KlyhkUJyIOusZDNjXTRJx2nu/hRfAqSSYHPAuUGCzV2yycMnDt83M27Yr6zNu 8aMvDkzeX3oOBoQ45juB4l6ROYLUyO6xYswuFE5S6lBLvMD1g51IF8FT2fcq/IBDUGhC9HR7hf5i JISCqHuQW2Cql51vu2XNntCU9iGu+kPQ9egTeegp8Tj0Z+SqpiQlVcWSgwiCKCXMJAWBggURGYgp cm1atJ1KF5e53c8yAETpDICKD4WeialgYWAdwoNlsalO74H3HqZX6eLpB8zVuE89wDr8YmwsjRDl OluLj3iqihDi2JSFQGHzi7R9wolwbmIXTdGR/Q2B+ahG2VW6izFMyomUHIA2LzUehiIXlhkGUMYI XvRMYGd/PT7YGRguIGQxhZtI3uH4PRMhPAkIw0k1wGwYHAcHo/FN6J4hkDvE9e7nEpAnLpRLzvUP cofFC4PzEN2dUeD+r+y+38R2y0qFSQlVUcEC4INiIkcYvvT0NA+KJ1I+jQhtFg/YkWlCKHTeq9fu iNEGuZKDNawBdEubIRUCIQEPuH4ieCWEwiY4FWCIkSJFIJBGAYCyQrJQoTeWAFDcSqY2fkGTKJzn WJrO0VzAp9wPuSgTgnO85Rs9heuKbhO7z8U3jSrwFQ2jj79gqH3CjSZuKdSoGmB8gpfQ1i6jpUPU TWqGBxJWs2v2kOQgZDgYyTWTTDIQsIg8ultug0FKNxrAWPlhCzE2ANMBU/zTUNGmGEgjCH8oMOGV YTqLqIigYDOpjEJU1AlqkjGQ8BpqltkM4uqUyNHKGUwyzElIKSU5uXHOLkLttTZSjJhwGIOi4xDF lyFMGRwgmIVLnODJMxzgxYSyMGRw4JGGnJg1jE0wgplxIlYF02TOu0DuQ7qkP17d/o/h9IVm56ue d/48UufYVgX5Y5wzZFQVRFQA2iqKOVp2PYawF1q4iJJpn8omxkA15zEUQyQtAwIBUMQKKULoh8V4 NwXNlBCCyEhGwFgvtYpOU3AIkkSQee6IKIXVVQM0m43QOB7zY/D8npIhylwCk/gO3NTDMqoyXfHR xxx22cNHDLd8+nX4NXf0oXjd4bO2Sjt21xZG2+669WZUu5bvDFRttlNS7tr3435Mbn9MyqyrW2WL a/oiL9MGS3M9cn00R3F8R2PfyvmrYf3nFOYLDCloNz6DRY1w62cOhgUKguUTRg0fC5I5GOi50Gr9 eWy5M1MSdI0U0w4cKsHbLrtu0ZGu5GeyST+giLZ1hhnZuhRfRiRhhOG+iiDoo6cvynbyp1ejPMvp VU3c1/hInK7t58LLHYdA0mXcgMXNGNl+irpI4YcvIWItkdVnIbaVcruVGtNnbVZl4as1HG7hVis3 cUm5HC97m+sHQZCncsZRD8fjJw6FOHhcfBxKMpoMHMWuTwv1c0ayb/tRAyIew3DmVX5JwSfAyGR+ adccvdmdphh0weFmlmR9v0JT4Pg+PlqzKm1MoZyKJFnwdMVmz49uzowfR8Wry+Jw5oweMHuajyzY c8K+ejry9ZaKPOL0lF3ONm5TFuycW4eVXR29mjfo2Ho55a3tC0lh07OuJzfRXA/e3YfDRgKAzibL YuFDoyYGJguhi2z6gPRNu3DxYuTYiHKZsQMVREwizGJyNDeAQ1uSNTciTAdYFCIopIxKEzkRJTLj CRNddyXJdbhDGxoPjfhgkt+xTsk9cemDwYrzIKMn0ezhwN7IDo0tp1u5YN2icj0w0k3b/eiXLz2j 1GnWzrtTxczjm7tZjWcldF509vFbYu0hBvu66qscMU7ao5bt8cV3oa92WZ5PVHfmPuiEDUJ2MDYq LVd9VBxMy1CguJIiaOKYLct6bOzM2YYYVT09GDFlwU9LFl93hg5mR6HRg8jzMdjY955nuEFgLBYK Iqzy++RJIamfnz7ufCmJ2pe/DetWL2d0wRn5eCIuRsU3z3NkP0AoONDCRmMpaojgcQGkpYk76KKs elGr589HR6Cxo6CR+iYME/Db22OHySIvqyaK4tXh7Mk0KOO+83bt5ZOeHhVhyPTHsocQOvDTli5X OdHY7tGfKCx4Yt33ZcMF3Oaq6ceDwnBuePG6rBVRVnLHUbGQ8eMTBo3Rw3asfJ5bt7OGWpXHSa6c vC2DJZrgz0YRPe3ycKVrKxEkkskEDwIo8pVB4pcBqcTa4kvA7BsGAYYtYhrMBwOAAoIYgbmS5iSi oIwGEQGXOBBvQuvUpob1RbsHPW5yw2Iu8O7Fvh47ZLnlizcvW3Tf1s1o4aqqpsOZDJwTVhyYIE4U fkOoMw5o1+JOiijBjG4DnYn4DojR2E1sHHCi5gYTowYUf5NHeBZ4vnuwUZmrd5CSeUpI/CS/6/2i pSz83YWLlZC6AfbAsP7vze8TpIucTQA8nyPrARU45nY7lOngUQ75eHY1BP3B4livMwJiOBj8JC/3 bdLGbJb36+2hRkuVUY9G6rU/vDAyFHD73XKnJy9jzKAnbqUenh1205WeMGG+GDlxpgtROmv6Gs8d v0PxQ2w8RssOWOP6NJb8n1/Hy443zWPrRRJHCTgeyC9jBUPP2aN9m7U3c31YL0R2zc+22Nmire/T +yI+DrFo8LNTcxZ+HLM4aNHDh0W1YO21NNWHDazJzoz0erofGfZEfyknukh/quedFKqlmdiamo7U 1Ny5Y0HbBLAsbhIqUJcRxmPFuQBRR112X+ySzFV0Gjgdn3YOBODthTo5ueHa7Xxg3eGTFdVu2c5M vIpFK1UTLkz69u280hucoaVD3AtHL7ZBCEEhOegWGG7wCAiKKiCFTaxCKyf59syIanFHq8Ohkwcc yRI4LlAW/lIwO5j5s5x3wSQ4E6CFDAebmYjhNHd5pAgRNw35CEXXNh5Ht2hIXEjgHV84n06ZG5Pm q0dem33n6nJ60eVDCf4KfCHVHVIbvrd9tsIwwovfg5bLOxw8fFbX7MqwZWMTIFfio3FxkMprTnFf zIsRa06TpOR/7gb19T6eOrZkrhl1Z77tJ5propK+Bx8uhTb6msFkSD0wC66iei95dluTaGRQ1iJQ c5s5jcYA6IbAHYJnkIanEW8VLlSmpYg95gDj28AoRPQd3Q0qYEzMYtk8uFw0mFrXGGJkFDvEUsSm TNAXPMywFLyJmOfsXIFRRjc+4QT/FN0ffE9NfV48ET9w0Rw1h7NBd/ryPK6w8rlD9CnsQPciCB29 ofl7wfcEHKJl6Ymfzq8VFLazL7GOtChDQWQuSJ6ORzQIRQ6W89FzD6KFdSJnXYL2A+L9q/kppUPY C6EyL7QTxPUFOJ7FDeD7IKb/Q2KeoCHuOlhihCmFAQphS4vp7jlHqB4wU/FTxDlchuE8RCwbQyil 4fhXOC8Eap9kfU2jVH2/Qk2+tUfi7DxMyT4z7w9Z5Coz6/TvMuTCYH4JdXYMGcQKB8sJ4GwUTcBZ 5O9O/ijxIq/U2qLx2LJyctlBTYHKXfs+dBzohpRN6UobFWZzwXYPH5J+Q5UHcC8E9QMVD4L8jpQT 560zKbc5CGbIC3LY7m7Mh2dScgrZelOzpB7wQzgB4ghUHrCEPd4XVaHMFvmcpebGiYFxNmHG9Mn6 MU1tftuchTMGHSZmFTjE0Zp2foGFv/JNKgWIcUjMZIP9dT+YKPoWXTYgK54xrS0kPffzvzozy6VT TOYI1h+/G1MTSSjWKAnPY8MSTgGpFdoUNojHPuHkhg4wXyW4XRUEAkst5VFjDUhEPCQRt3EsckKQ ObwheLl8xCxA6B6RBHujgozB6UhP3NKut1QdXuMnby6Sbh0Q46FxMQZTcW101ILu2U7hocUER7PB vnBwkkCSwNZs36NxIbsyHSirVIIihxToyNYrkQhuZHZNshQu0IUQDj3VwU5QnCUGLKmGS1DzdDjo 1RgJdjaoNIMZLo2iO9bMlBfad4jgoypHo9nT3O3hWvqeBz5em+PHVIGhPRqsozw2s7sMwTx2eMBy h5c0NjyLCj0PDIj5pKFhd4rA1GKJvQNokqFGTy14w6urrbYtdOui+IPUFxapPFmx5aIjW9VkhBJs x6+WGrYK/CCyE2XDJzw0qqgOl/dPBNh0PQmssZRw8S9nSkJBK1qfAKBLkHAfPt8z8V373kPe45ve N6Exq086EGwTfmp1F4U7dCBpCIBEYF5qGKLz7aYOD5sYNivyaxo1DBFBNamkRt3hi5zTe6xNYTtf yHvgaITgCnxwmJOEVHny2EcRL0isDbEf9VDcnL9j6zD2a7PlDpWpz+8O2+tl3MYCcsSJGGS5jVaq qxKBFCgSRVEGgSQq6w/au2lWE1oA9w3oVvlCkp0psYyzBMgZhmZtyYl1SFxYiUNhqyIAZYihpbi5 so2IqhAlFAt0CyhDdxOcOm207BQOY5j2RKvm0RpZPd+yy9WG7bYpPtfa+1xpdutndgeGYPIEAqNM jYuKVBmIEHni/3nyfPmEgVNC+ETJ69Hmy5gVSLKNsvHox6Fwil6q/bLvM6YWs7tp8l7Zv8a+7D59 O3Gbe/p3cu/5Xv8Plt06dfXwvfz7fB13PdLGmzZ68+fp2fFpQ7V9ce0PBsfHy342di7nl1fDw747 b45eip6DgzH+BDWJCPoQD3Djzcehucx33/dZwPQUuLUfuzLG/llR1VgndYT85tkilLq9OlZCjwmj xpSHNV2b9Y+2T5SHe2G7su82WXvhbydkMc6anORroayJRMSlagiHoiOBKkk44VbGI8odaWzb14Ks HveVOnS3nPlus2VfDrrV4ejIhn5nhRk8JYiuHh0ZL5yqKZFuOYkf2FHnjOmvykfmmfXKMHPrtZdj jodsrbVkV6cvYO0ER6q6p6OgvJskTGg+dI45qixZg0MJnrHTGxyezJx2DmgTswWOjJuDujhgjIX6 xXxjypFGzZVgrtn60szlrI8Pu+0+UhqNe6sxqoWvz5oX2TFby5q9tHbRpVRms+1zKex5aGLzdlQ7 YlvbV7O12BgyR0Xt5Fw2HxDI6Lybw9PLDTLD3ZUs+nnLw2yXjKj+/H4a9VlLPvzb1WxZdeGbO3s+ m/HPpPaLq5Rvz01llfGFIS9ekX5Qd8JdIPWW/t1hln5uw61+HjO64dXX5V7dNI8yld3+vblthDrO Pl0btleeu97ePdpz35y1ZadWrn11FWlcL+u3f4wk7bI74RXFvLr3ZV6wrr5duUujLy6ePdCnLx5b e7WV1dH05yhzh3uf16nm/GPWe2dPLTS+XUvzfy61xr7udOsWtZWpxhv7p587t6x84v774eUvTG02 8d699loraxY2eaeFoX3bCXk7hp5creE9nbdcttvDXTPRda2lT3d2FZ5a9PPx6dIS74Ubv4Xrbl15 +eWuPnpy08OkoWi/Z22OkszrlDul177Uph14br1r67dsOO2L7x47Pjmy22mZeU4O7eGnO78O7p6Z xvLtpKGlcl5Nz59+3PHHp68YP08a1wtWHPW219euvI77ZpORhplCvu47Thhlrc248cu71y2u91tO 7Xrtt58+IZ49++iuiM9y+fpOe/gO6bHiZEBgsCPGDmIVjuEjLAxfpkzR4JHqrTbVujV7xzwzRg+e yfmb4+GfPOpdjnkzKH38MI5YM/d5VWVOHg3bPh4NjcWxIdVGH9SIh3IgYG0zc0J81R4yOENPY9e7 mel/DfdqwW6bqvDRr7NXUj5pJWTMvvvy6Zmjp2u8Z+NctavCzZOmrLlxmbu2xuatWpTF1mu3OWTl dYw2KK71eFt3B2q42XcKNCcZ8Osfllwx4bnavP7Z4eTPh5GJTJC+BAxMHFnHUT4B8EQwlbly2wPS xgOM6VpSjV0mBQTgzJrIkTHGsuDAg0CxQlKZGVjE7ijJ33w+lPPChvs4DmkPOw2aFnIogxRa4wRo AbsuOYrZw+1J66sYOq3KbolKkY4eCT7D4QZYMWTng3bMGAyyuYFmTfd0ywLuUyJWQ/NTfZvR7NlH DRfy5WZs2hC5AnKZsUCBAmHTIq82mWHyEFocCuH6EAYuN1vEXMNDB4FylZzmPIyLo22uoppiSdCs eiSTe3hZVbHgY9c6Pfh6A9Ehk8JOUmubw0MIEr0wWxnno88PeAkjWgolDYmGu2eGDypmGzQQzBoI WKDr6ujw6vAsQngDoJ6eU43XFNN8cUicDIpkyKoLFUFquxrPimpUywJCHrIFpRiJBiwWDGKjLaoi VgUlYLBQBZJIKAKSCyCiIKAMWKRVgsBYCgDBiRiSIwRIqMkWAoEWAW1SxgiCoBaFIxvhPuLv8vPl iHkCTYJgoAAGxAFVVVRQlYDJZNgVUI5kNSOZC1i5Ouy4bDIKOppKUYroQhEgwpQKTI4DgGawh2HA 0FduQUbmEhxE706BLsdRTt2eDyXfuJcaZQcxcHeMzyqdr4wKyIF8lJhIjSZPEcNjEiYGZEcx794H CJyxSQR5opfARau/ssCeyAp2uA5YGnhNWvUBeZQc5mB0/vYVIjEIkUgNk7UhRIIoQObHmzFEhqOJ 4YXYVdpOO1zibw79DumQrsdiB1BJCjF3DXMrDBIUIH0V0KOm7cWdbNToqas26pXZpjZm5eaWNn2G OmbizlbwZduWb6+fDlu54u4wwHhisfuyPNjwcO3cwYlJZus0bO3umxyIFPUmicQYNHsOUdDE9WVD BouFSV796PpdSOWvhHRzGUavXjizjjLHfJv3os4jZ3mLzCQ2Y0sxTMzM8833YouZYJ7oeWJkQ2KW GCGY9ELwiqlzzQ7Eewrc6fFWH7iL6MXzFEqvyvilRIxmWIkgkYooSBBW4g5w7IEuFS4G9coKZQT2 LluRLGLKMrcq2yl8ccNLcX+RhUJKLCPe0lrMfcTBSzJttrqCV5v2vTg3dHJoeYGjJnt1/NyzBHzN hmCJ53QHGBd99ftsfQGqtWA7owWj+YpAFwucVP2maUvAoQxEHGZR7TTioS3Ewxe5I6st+hwyhyk6 xWpLVLvjEjEIgjPcvqGw1/T18hiGneHjGcQn6kowOo8Y9T3DHuUnRQwM/k7dzKoKCqcKKKJXEQvb 2PYnuYmZtqVLD6mgX1x48DU7ICpUsHsX4PEZxbaIL1GJDCGZsQNTQfIjEVAkO6qmynmEQ5U3O4Ta FGkaflf7JCRsSqJ/sRRHl4PZtq+jkr4Lm5Awezo8L5WjGfofBlVD6EomST4cEwXFHclOZkXLASKU uL+R9wq/4FTJQHKR6MORRV/efj1xg0oMQ+FhX7r1ij4UrvvbixfeIXSAinshLU9n/0yf37CECQdQ 4OpzslDMErEqE06be9TDhTmp6q4d4wRAMw8ANDgNBj3+/yKKIgh9em1Z/fp5fGPz7fJs60fDu5O6 43Z+nE/l4+FO3d9v05X6Zs76/Kx7r05U3205+j6ee0l1348T2xldfCnfLc2n2xc7507c6CIJynQh p9vFCTyKakJXmWlWtCPhrKvgBMmuTo3J1EYf4w5RwwOp8qUDigyIa4Icg+D5Oit2HzXGJ9arMfif myWYFnzfRZi0UWdEROWDEXbs1G5n6bce9K7MVXTZoKKPT0vc5DTm0WNJsgqmUvmARbQIYh1R3iu5 b725cNVmJ6hZqf3/vIexMkmOYkRsbuVOtDbvx+ahpTsMWweqmXOIGPb6B6ah9mQxcLkyqHlkymQU SALiG1fnZcp9eHYnqod6608fEN4AdQ+5BbkNichV3pr28nR0a+ru5fLpe2j7tj2fxp7a+PlHl9Pn WHl6xfTfrr66Z65xxbrrxTSP0nn33wffnzhPP46/Ovwzrlfv9M8sNpX6iIIcvBxhfmzHQ81l85CV fc7zOm1KV60rmr3siwZCSpZUuZmXI8Wcte5C3ScPfIiCDYzSX6+85hWue9w3e3wq2n/Fabdzzvo5 VprB2d6W1u+3fF7T1D0cbULWH1bVYa9WGGGrRl1dKr9womOkAE3niKBDnD6MQE9HaAXWIUdYazuS 74Z+pA/fEOAbP0Gn81fzfZTcXdqO3wNXgVuInjGRk7jeUpsIqnvIohRk/HSsvD6zLiIEgEQgSBA9 6HZZQPref4oGY/EhJf+SQUNCxCxmHSd8gVGqJmyVgs9WQ/UMrPiQsGTLNQZvjiwhAtZ+J7PC8M2K mx0XZCD5UfJjyl5MklcYMMChFjCYTilgyeHr8xhAPuzwPGo5n+xXYOXVry/y5UP9X56cBXP0jR9+ a/5rgEVzETnbvHAXTEOWKQjfFogMhujcQbcctr76CO2pNiQhgSlA5TEkgSZ1CwoBYMcl4ugGkjCR VQoCkj/PWtAkhcoqhcvkIB9ifltUOHWvtetTKjzgwSQj+g4fxPxRpCTKHr7YqP1kiEX0QP1H5wjS /uwvy9Cc4gH2u9Q2+8D8DqB6TF9/SC8PE7L+3uq45+cq+EKBapNIfWsjEmaCU+zOTZ1uxSueC4j/ IOdT0NY53mOIJtDfHGRcKlLs00XLNCSZtWBvtVkxSwVZoAgckZTHq4xCHMQp1CRN2bIQhtooRVjG DliyJgo7wLCSgBYKbhgARgW2qyFoHWYBcR0KfZMEyQKamlSwmBh+Z0hFyi/QhIIEiiW6QUpV+CXF 1guf9rkjoKnBdA6EQzg7Q6FDH2H5hyr0gF0PUYh90+pAix/SfzFErjqya6eiqsu6JwEAgcwolNyw HmOumiQAIQgCmV4gKGJEFkDj4QltGECqVh3ycooqm48dM8Buw58/WU5e57qJNEHngFWlRz+SN1ju Tk/6uu0Ut/gonoNpvplIQqz1KEoLQaZR4l79zBIjzsyE2kUOSjzT801GZ3qq10S8PzprMfxqQgwh FKiKjIkICC4iiX7bIZLHrCyMFVcwDxgBE1QCuahQ5nnQoL4kjCMBIJnXYlGfpyoHNhwyUDjfrE1L sbnlHYouKpcNrSPaiRyYCc/+P+R8/knSTz+MhlFuxU95FQiBC84G45dYIimRTqwA/XDgEBI+gByY ZhL/cKagXggQ1guAn+Rig/cVvJYk/zNpPMma8QKzOgSiJTg/H5iFi5SOJDUiSSVnuJRex7QHiM7E 7QoQkkkWyqs54gb16EWgcRIJcdCJ9gPIGsUTOCe4pDKO5Hz/YJKdAiQfz2kgCMYfhtAorMCWH+0l hiU+NlMAkWggyYv9TDBWZQlTCQiLGUEpFpasFQYk4k+OEmkPVM4d36v1Hf7PX8S1VO8zY5cyml6a JvO7wETII7RJi3QkRnSQV0PssyOnzcMHKtLUdsH+P6OU/Bdm90btqPar3Zm+DNm4UybNH68GLSKm RgSllieuYyE8z+3kfboGGtB0rKYkChpQzcxQNb1KkxS5ugmIqBt8enIWuzCNlMqZFTgI6F58vMXV /dM2KifPmGyKMejh9/Dh9IlDHTh1it27cqE40MFWC/R1vy2MF2ebw2MST6fiRv7A3cX2FOPiwdBS USKK80bMjBr4R+skbPadVkOsur3I0cMns5Gbho1pbwuwuaGi54ZbZOnssl3lo5cuUccu/LbuOOnp flmxy5ctGKnbFMmDJMyzS1lyhtqSJFTckRDXWcTVYUGlQ8kBN0EIAsjvi5PST+zXHy9KMC1/ZNJu vry85tTNbd7LC+gmwz1QWEPQUc4QcJHOjB7ktBQp2eset3bZweZ4e0w1ZuSyx4eTKzR0wszPOfDa rB2REqj9F5OLtTg03mawwas0K17PDIaOMBcwUdGSC5w9+27nrg/D1wTOLHIN82SdElzR8G710ZMm j0HbZ4inoUkuZHOTxMDDFZwrnemt3eKzrBLPYf5hDqJ9o7cHTOyr2ptV4HwJHu9Oc6G+ZXLxsjqG BsUMLRLjJQhQ5cu9PD7aBSXM1N2sOeHTEIbkcnFdCcDVSaitFpdCdU2LGII5ECItjE5HIJTdhOBV jEoVRDr+SESEypMH6jzVxGFamTExYuMM2DweWzUq2WNWhisqqu1Pj+dPKUV7OHs+E+GwyJ4Mc5Vz BY0f4hE6tVpKsTThd/dJ/CPgj2e3Y4arM13UcGWz09CUKhiHInKd6UKhyFKHIqLgKGoct5mBEgHm lFLWz5YrRk6gNJ0OHQxZi3YYMweEhFxpFahYGMcdBxj9URE8ceoJ2DqgHwOEzMt9ODUgKYnIwkMa AwVInOSUOQc1IjJDjihAe2stRRv8DY+LgxN1LrYsnaZs2rNRywdNlZ4drOHOa+x41Yxzw1csWxxd kyWUL3ZbnRY1fshl681kkJ0UbHQrfgKMKaILiPR0VNhhuLY7G7MBBkM6A7PMGBTZq4dDDnRr8oYM F9YPXeimFoPChj12MZc4n+d+20HuST91STHhttC6/n0+Hj4ctHZo9vD3Y/JJDJ7L4HwfGOcO066u y8MbKKTpb4vFr4lkyzpmxRk41xYt0+aO/1nbKWdHSzr26e7AUdMGsj2SjufWUkSMMp1sLN1NmLDN QjI1OPs94lIJzNzS+tTmXKEIkMBwQMyiqLAsM0phAzFDc56wLQUS62C5icIxcwuQMzoID4XHJEQr mQ77uAdcPL5HHM4l9SbjBaUwdhw8GOzYWO+48G0jnZwkyeqObC5TNw6xfc5uwZHS3eCzZq4PJ1PK Iwrdq43aLKOsVFnYryXYqqLPjPmd/3Rs9KMmrDNo1eJRnlkdsWTyseX4pV2ojBhm85CZHxv4QdrB fvLqfDhljQeGBij0hoyScOi04GIYI0MLBHfYfmCKJsYcQ6MdWPD94DmTZ8D2iB2Kvh0aJJvFHDBw 7OjubF9F2g8t2H6TpVgZsmKlmjA8SrZww2Yspw0mzVSIQfLdi5ZqWdmNDNG7S7lTzZ1vtS2xgW0N Ac6IhiT7t567LoWFQVBRPQRjwjTIkbkSfBHBcgeaExRSJgcGhgCXJExxAkb70KLyLmBmW5BkpMwc MWtmnVNQs4uKYFK9MHySfzPmSe7Jxm9kN8GrZ6zPBY1iEHrV3xJdNdmjr1nH6JH69Pyk5fZFyIn6 8sAOtfPP4Dodwh1CdYhV3IvEIB2Hwn+GPhIpP5Koo/rbNhP5rqT+OXJaUZD4ghVj9KqC/vsWIyTP DyBtrB7EPqqgtgvwwQSyqC182NzbySDkF/b80sGWB8CIXZiiBG88PKBJISRIxIIQWT7+9DyvF6QE fDUKd/1U5g0b5n07uZL78TlRrgM9wKfJPiezEfHXgCI7vrrNqPkYKbkWhE5UNwg/b8ykPYbk5kid cAO0gqSIMidL0ClYnJXMEIAQUSdgolwWA+AjiH2iPcKXatIHb0KdQC+4wTaQ/kLjH+QXmL1QNvWL 81DpOU2iazpExE51P3QXDrDeN7X4K9utE+urImzs6xRMcyoXoex3r/HRSVSFKFsCyBcgGDEMUsLx +AZMgxIxJqDcowWQhFM4L9/N5IeZ2qeA3ge09n4KcOPl1I4o3gmw81LCYA+qwchsNekTUoZw4i9K rgHu7l1KafZnhJAhISEfaR+BgDlJSEGFLKxgVARstlQrBQYAKICMkUn1pIFEgiSCIMYCwMknUn8Z vu6GwDZZ6sDNcetmT1Wi+wCUQEgyAIEwwnuy/gbeAJ1GgzCchmz4DznQB8VF/B7FDpR0H4qu4ANC bTFB9vTD4160i9fAUDs5wOD1HHr03DzBuU2Ht/dsmxu3aD7pPp08bQk6t2NYlIIYVOpI0UkjIoDB QFKSSTxPA+agVCZTVqng/SbPeTiQwfI4TCR3FPxfcQyqHfjeLeOxdwhnTpC8XcOIpxuR1qu4A1m5 oVoh1FNAWipUIDCiMiEgVIoUjqzUChLiHIXWBS4XWpBDckNALByQFVCJ4AMjMG0hAkVgCx5473J9 xPp/PAPzn5hsBLBCgJYlIlGwS2SlGwSxKRLZClIwsASwQsglghZEpGFhEo2CUMSgYUSgIUCRQpF9 eBpRdIJk+3noooQ69CegJ4m/nEzvkm41C6W5XMo5UWPchxHmBO5DKGPNYMgl4MXWKisUpGnxIzXF EilCiSLKSsUGAZxDkZz5DDBZiIcLaTz6F+ChrE0sEoOGkueA+ncoQzqBE+wDk5AA2dqmQUDK94fx 1I/MKjOSTxPjHl8oaH1Iie/2D64jPmSJ/EXfQt+0KmyXRyMyT/Z/3OPu1GBNHqcXB7HlAD7UF6z7 MFec3eaixinQJw7hO8erINAh4nHkQX1PYe0I0sKCNLCgjQH3uc2DwV6wT3gIconAB1CvMnQ+1RzA 9Qe5OI6ygRzPIC+SAdineCKYRn+niHgkyH8v44NpLJmmDQT9kk3/s8OwzgYAfFzovBQyGlTUeRSn fip0850efw90tMe/Lk+4+B+B+oTAJcELShV+aIKFkVIskWTKRYUSMoTJA3nM4OTkNKCeA5xyEkWS RmYdDfM9xLCgm5SwWFEvouBwSpISLCEXt7xL054LoAYjdrCtWlpOjiC4im0ExOzMPMGRe0GgTh6L cLtLQaPoh7O08Ev4MeY3NHMdwg7CHAfA6to4ZVDu4UOoE6MyUi8o61R3VynHdnw4T40dhOwTYoJQ N6xKoe9giCBqUPdh7k2qe7FfEcnoHv05q+9koCnLQwhpR/yxA0j6q/AMRuAHPQD9XIn2yrfwk5BD 98B/lIoe6JpUDBD8OUOIT5ex8PNQrcqxPkHmePP2CD8AP5HnFHIoXjlAQyO4FFoNIj7ELAPAgyEg EIgyECAkYLBSLJBSRGCwiKkFhMpKgoDEgsgxkWAsFJFgKQWAwkVhEGQGBApMjfF71Pfmvdf20jgM ZxaUFIFB4GY+NtaFAc8A9DIdIdREHIQjKILWpbkFpGxB2sTxgWhYjzfAD2igfB+IKUI+8TmvH3Dz vAdfvX4dymJmAyqGxTvMilOTYib4B3iEF3skGCQYz5h3BlX6c9h+onX8QuTx8TeLgN8ERfohyChp Di8RzcvBV1AeAcFVOJlA8HzTEjAgj5phcmpQwUyLzVfoO9L1W5YAGLEQJy/Yfa6VD6mwDp5lCvDs AQ7gUxR5EzI6hToSIbyBIEkIEIIoSAw6yuALlXsEA7VTpSfSJzJpUdwOJu9w8yKaNUNnAB3GZQ8A Wx7Uoz0ngKbQPXX08+ngocHqP4eXwE0DwXHQqJ91J/F9fce1D86iKml7QCyGwERvFz3n0D+M7xBj mH6if6ZVJCNIn2fJIO0en6hokRQkXrh7oovH0/uPyRXkfaPp7kcoKZDUg3AvtANwFh97Nw96rmfD yQvPzUXYPDbCH9ffgRv7SSfy7kPP9+zBN5JKUyvIE0Gba9j2freXUZhPIUChR51DoR29I1GRNYQV CagtCk9/SnzA+pxUyAbR/SKhkpV9iOlGy8QNKmZQsrQatGYJ4Z0YAwRoHibFpQwQ9SUPxoAoLFHz BIrmIkQy/Z5iia1LZzOKR6xUP9ftD4gBCPKgQ9pRUDJVBjAGQUncAliQgBGIsEC4goqtlAp/qfLw t35LFf+cyAdXIhs0Cif7MntkiWQOcNcDlpJ96X+1QxwP4RJACBGEBDdkErc5bFrfLsFEoda+AbFd 5OZSvp+z9pdddGQhVVLoVHPx4M/r21kzsFRgxTa3eWE2QkUPqOgFev+pd2KoCHNtCgDJeD6hh6Xp vWcqctx6gl6IURU9Xre5P2aciAdwEMEyeaPYp6hD3DsPuRPqI71pQyJzqXuggAgBvBz5t0DvUMj+ d3iT71sAUE2h5MEgCb3VARFhop84SKCq0RS4iYnrIxyg+tI1H+6tE92szRzt7mqG0Z+p9z0LZQR3 XVCc5zDXWJf294YA2SY851Ctu0jCDnBeXCwJdFyQSiAlRPCJU5PxUvSog0KQfeBdduAEKuHogwgh tGDxsAd1sTSCEKe/yChIEzNdwWqDL73P+kvAKxBxhDUKP6Xlkav9AWeYGgaX9cFeSSFyMA3vntBV Q8x8xoRFvT+wIBmj+w3YgQYECHNQaP24qaQYZE8vJDHIdh4/ree3Hw9H0JC+rPIpHSU/kmGEyjMX Ud6WfN2NV50n73NYDWhmuQpnAzkP/TvGJS1+YT+USiGU1z01IirXNijjOUXhBlQpgWKliyBCV5n+ +fE9AEDWJiCnn9hR1cxyQgc7CqGL1RtkPiOY0RAJEFDwMkexXsVapGgWiw7hUUsIV2cA2kCaTVJJ LxBgj8Ag/U+FrS8Sn4WsS06euyiMIQYJ+UoLBQ4kM11H+AUT4CiZRRLdH9KdJ5XEC0BLCjEO0Q/T +cLPej4pBAkAIQDCIQYitCiQBgomWhoARYwUSIAdywRqMWA3q7YH2i+fgE6Q/Zb1FyB4cfabD+M9 U3G3CZlRPC7pfFrUBnXLtQP2/AR6blOAcV4XAJ0EZCEWMFkGROqihCRiQhJBZAghGBFCd/R8Lvu+ 39yNv+XnQ/3vgg/1HkKms+rwn2R8/aCJGJ5Puig/hgp9jCZD5aMjcQSCpeMEf4yg9uVdK6Rk9FIq hEstjA96FHBTCYhDElUkqhpTKwEShihIZkiLzntWCvREnTF0NgEoHVm/w/T91rfah6KH20jQLRQU hVNDd3B3uwt1ADUB9hziGoLLyLyBw97DpqIFUgSQghBSAfFQzKDnUgwyjQokeVYQIAdqh05XK3Cw 50ecPeXB/gNIbkhumtNjPYD7ewTFQ2Htf0EaGEToFgcyeilyFlhenEIVaqKVfgiYgNC4KGzR/MLp BNnOZH8hOcbEEEkWeN3/eL74bh4+SxEWLEYOi1BRIIERpNIvu1vSvV+sT85p9gp9wg/yIL0sF7Ow KM72aTvBG32gj9wzsULZey6ujS6kTJ5jzgHPzyfeOaB58RNii94l6KO5E71LzpHWF6PXgI3gbBRw UOTOvKPnmPNe5HPMcMJzF5ccK6gHiA9C2zhjWCHUPBQuHo5O9FheidvUagTWOvtNgZh2m9On8B3n cprULna82fuj5AnfuUOYV25fzZ/VB7B6d28zI8wnemYcp6DegHguQPYcwllCg+8N6Nyge8VDso/Q nYoJW3ep0+0e8A4B3609i8TJ7QDFEzeiKHOkUc4nE7EPHIOI+TzgBx8F1+xXLyPWnu4bPNE7w6A3 HaB6CvCcwm8PDoFMy0J2qHobheChAEetTIgeoL5A9yr0e4U9wh35hMRW9bEoms5CgwzuT6HphsMK h9Ymd4TiY2LzcaIQQPmSiEFhBby4ml2B0+wB7cQNoEFXtE6A5Fbuo7cDsI3jDO4p3I1pHpIod48n gnRqCxybOwXER6m9v4hHX2CuhcgNukc/t6Fepew9wZpzAvIJvAMqi5/I1C7esTn5BMF76HnW/UIB +CsF+Ye/2JB8J9CT9pafCQ8RiPKLfpyj70ieEjGLJMi/3+Dop+xQO7q5pySWz3XVfy2yC4kJjYx7 A9M4IjiDpOsetPMyZc+rIGs63HoX0vcXo+p9gQ/iN2ogEQs0vwgUQ+MApkH51iGJXyLxqQXiqZen SvsADcHkjblXB7ejgp0dxyqfE71DoHxPNvED3p4nehgvLxDpK8HeQALgVUOgRFzJ0cp4HIocE4bf IfYYDy8mPtOTSvmDj1nsEeJrEdUPWJcOxA5RRmXWvw3iOwOY4T36eUFMDO714ioJo9pSCvtU1A11 vZ07GI/BVr4Aa1DqXS94plHaLiqJ1mTcUWdvXzApnR6+lfTkid9w+gc9dWwSyLkBLDcLnACl0i24 Ia1DzOVhJNz2IWYPwuC0kJOQOtfE4qbBLlCghuC9Q0JdDL7M5xQXiZu71PiR7JCGcnIWyG9ySQwk 6qXtGKm66gCaCWKiQKDUFTVwZlLJkSy0aiDAYliiRjYCCkRsZfPAUxCzqByHPQ9l0Uxcb9Q4nEJK ISCF8QSwXAc42UFM6l1KyCiZCD9+isGs0UrIvTyjhAM6JEc4zHN+3P67+07VDqNonWr3IHcWVAxY ouEoioPTEBNnYDQ6mILsgIcqwBOmCqbYIPhBVPBidqF5yKHeFhOYUTtEeVEwA3gp1HZuFDrgA+CJ 20q96C9IpkOcVC4UTjzqFIKfCBCBIBIgSDCDCMgsgns284B3iIuo08aBU7xQaaEEwCKBYBIqpFLi CyhWmAbiyUom968HkCzWYP7UygXK/OIvQWDAzIZz2Pu9M/m2MKVArtEkOQ+VyeRyAOfvifL6ofoU 8Qfh6THU+o7h8z5xRv9LAXA+KXcA5jkOECzQjaxSWqpElFWqxJmkhrnEU/qTAkYjGE/WQw1pTMNP MIbAcPCVgaD5SZ4LC+y3ZpRJAUD1gyHpBAzmlzTBJAkejJTDhCuB8cUMBQsQ4xicJmywqisYwgIS xiFhtIiQVyKogy4YAERjIyYkkCT3X6U6DmaMfGbNzxgw5c2xwWpu7GQkRkMxIlAKrSodAZX9xrLH +V9o25YqJjkh0C1EoF1jq1a3Wvghjdd5YZHeDnZ8kOxgGleTdYhBfCIVccqJqiYMBEhAAIRLZiQX lghz4956RKEiyKzTqAJqFrpU1/X6GSP/mRt/5VW9F/pATuQVzHBB+Y/W4XaYFCjynduRaUHyPop3 9Bn9iZ8xmzB6g/ifiARWkSFIwGlE8wOgZRtHz+rOPug1h+0ZTzILJ+CPkz/zbsiIAFl+x/vwLuk1 nklBBMU7Pz/NUTal3dAg8/8Y6A9zoU0rpRcoL3CtIe5WAaFyFCjtcnWi9wl1kc0SBlqhISV4JVix agtByBEkMnUKJheED8S9AsTUQXG3kg4XNjQi50DyFGe1A24CmbVVJ7hCswolk0/l9RvdcDCLlEyO nl1o/LtAo8Eyahgc2pHo/LqTz8zYOYDit53f3FgbeEzckkJFCsAYWJEAEEWRGVAvbsE9hCe1q+Ms hC2DmCWASABFFMUofwfoc3svb7UQ5EtYboOavubPhDmevd1x4kPeEe0CHgl6hQhz6AGwPmeJmO0U dyCUv2gupzXFLk5VrsWyPvveKF8VQSwqBiKJSGO0E3I4prFBiAfD8oqBmD5bEzq5mKGcLt5HETnL RDBf+oMpFv1/1HuO5yBlmxNC3roPxSAI/AdgKVkH3qGfmEcP8Sez4fBfxEunGHQVSqJIchlysoFo Em/pgVs7Kl49SSflVKvH9fqC6Yv3iV7fjb0idgTAAM7z6jAUnvC7FdjZZDMJMymBMGSmTGcFIcQl DX8JOi7DkKwJBwAhARGzEEAD3xBjEFgCEERALN0OnKgtDjmW8+SIGfIZuXj1x7ujQC+CoFyHWnob hekT7DC70FvMDtE2mwTYuft3noPK/JU1iVloLh53OPOHBQ7AXV0KFlDoOQQDeqdwLrEzdJs513Bq ZGDSaQFykQbOlS5KFS9u6/rcih9vkV2kv9U80r33UFwlj+s5B+Xzyhid3SVWg8c4t0G8XPZ9VUD+ Ks5oKFvCDmFRmNIKXmgUIiGVRhRKSFKkFKUIUSkhYlIlkSUh/ORCmAGSyJRoCUlJZlFiUJCqWxiG Iv6IbndjpLi+PmV1LxU9j3ifafLnQvgT8/y8k7C/5CeYj8Li77BNl5kneQsn2SEMRHv8xjFGUUJW lrASIfD2wLSxSqC9ieBxLKXIezqLg54OGzqpTwbJaW0sYFLKQtiUYkoNlopUKMqDBXdUpBVZF4Kf QE+rytnLAVRQKJYlhEAwyYtHEoSXN2N5JJKJEYyWoPR8pI7E9CGIomdDaJwH4qvAK1CnuBcLZ28D rwA+o6ysiPOodvxvXt+pyHs7E7TBA5PMJwOjqEbgC7rSHN/GPQilwKmkL+GvmH3POHigc6vEdfSC I9Sgb+tA4jvy5EXgi7rKHA7jeUAYoqnrJ+ocfYs+j4EmxET8B6+UPSeFJQF20oDOvxo19hzmxKAs JTgsJgdFK0hgkRSYqIPs9ojiIQcqzKNT/JFLEElhQ6ARG1B+eN3kqJnA4j1HMjdcAeQDH6CfYe9T 1TUmik5AaqL0gB1cVXlcQ4qOh0qFA6Q0CgakMo8cUefkHQHLaHtFXgp7A6Re4NoLid6+KBzg+ryY iocirwVPXiD3ifcHB2uRTDqAs5gv5zwAutyiuZdx74/v9E+RiFXfsri/XD/PgjUMtv+QCBsfA+aE lhNBn6gUEtKqNRtQiEIxiVEKIqVKGLGHav8QKJeIpeOfTQ/cFQP4H9G7Oa7WtasofgBlVL96rnLL FiwIECBYOqXC2WAK0wYzcwLJmPqH1PIQ+rCfkHuP0+p0eK49ByPf9fc6yliciGKSmEV1CWymJaQx DGAAsF+lMwZ/cGZ01yRsuGQo4gX94oVMh/baBd2xADtQ4sEEkBqAUywYUBSE4mYxDFpiIsMG4ksi JiEsoGtOMQhlJvTQoszDOE0YpcCl1qZUDH53DHGsYFgjJUjBqVGOnGJKYQRLgQXJtKYkMPNPCd4G 5J4zxRVU3tv9tuE56/Hi5LHPCxGBQaDASxKVVgBInvKBClFL41NVX3UgIbXSiYIFAqKllQpQIEIS 9qFwq0AWBTPAQjJM5RCElD8hR/Kn6T5KtJQfRChOtYpmMpoLu0B+VKgfjymXoD6AGvA2CF0vQP0U Lry53f9iL8lHKpxQcTgjoYrNdXSQf4knuigf55GfFRzIf4o2ktYIBPxUOvn2AHT3AHNLAWukNyaL VTFUFoEIA1EAKBlCUBTzwkVEsIkBw2AkRRUOJ9gbfOZP5Nw+MmeNnCQjUEKRj6gBhEJ6kgVQw9hZ VBaNy9vdmyo1EzAPQHLyI84E6kXVmW5WZw2omqKSV/aLJDWR9gwBYSTAghtEDLLitVrFmNTqli7I YJQokUE1XXgo5rkeZVs0ouXvMlomJEjEJEVzLhkKhPbBMG1hCsDVu2CSFIdhG8FVCixAiYABYbWW UAK4qYiYl5OxGYAtyYKFj9IlGChjBgjgQDqZO4cbBiBssBkYjA1Bh9nsdTNwoPb1c/sxBYeBMHgH c5AAbqzIYQIBIk6AonelquneDpRMAtR+OR+8kgdiB+BRvYEQkMVRPUCIJ0ZoqxV/3xBbMhCEUgLA BGIyQYMBQWHmRAQIJooChqwiBZg2VSoqWVgdiyIskn+qfMTwkfj9EDSQ/jSOQT5h7RW/PzmnoQGG sBc60ZaoANpDoHn6UOqs2ccMiiZoobggRUtw8KGy8qJh1gmPqIeTTiKqf2vIj6I++bjpEc/L7jSB 65T4EQAw0mbnNQwIADpEu71/tnE8h+yztDu3B0mAX0IjjrU9pvvS7+MxTzBOJf1jAUuR+7XJ7asM go+787zjjnhertDTxFRS7kCy/BOod6mAh4Ui95b28gIj6n3XpSIfAMVXofR51/LqULg8h08h7wRG 61UCR3tmx6WtaRtdTYhz0QaEKpfHAUuLgPOIjTpUKD4gWVG9mIwELgIwsgQBgKEQYMBcWpFCCQ3L KAkYmC1EEQxZIEplxGECKSSEiDCBRJPGTkKaIciIkn3kEMAJEgFMS6paSDOtZWiEIpHLyrMfs+/r oNuRKIehR71WwgGTUbCyWROZQ0Lq1xQAL5e+gn2dgPYOvpU4i83aiZsg4YIfPeQ++nEcdGCTyP4B 85IPq/LgRpH5RX+I5AvRTX4E+Zi6B4pswBMG1IUC85awqw4JBYUV4EtAwYB/niB0QH2EG60KZYGN goGRJZ/c/v9YzAP8O9IKGZGGlBCXhXA4zCjR0jCdh2tjoR1x4QJBALGGI5gHIF4Xry4FArHKG/7T wF9hncDgTKC9gGVF2t3sfy1BbvHrBdC3Y4I8wLlN77i414I/qiYPt+6QwfomNfFU/w+CLD8jyXkc dOvD8RAOcv5QRGOgeQyHAMio8TLwO2jkR6Fd4Do5XrzliwPWxbBKGtS7kF+6ajqMguiYXXUT9WtR myQ/k/1qI/ukkgYPNydZ7da4cgCWHQ84HOodSoHEuRNF++yAxhsOZPAd4COd58jFSQn+OAH8AA2i oJiaAPvOgzT010nFQ9O+z1CdwO4OwIHwH5ajqVT5xADzdJqD2ioYB7hLJ0qvUKAc9gpP6YAkACKq XRAPQQ5rORW4eJu5RpaQ4KHuBfYdCnOIhcBzGAdA/zRc7lBHb59mZFHMj8Os2qHJrP6U+3gawPZ1 qYhq9pcAHpAkKZDWUbzyO7v/ALQjLOhSilGs8P9z6xWOE/lInOZ8yvTZP0D1jlVAxRRRCwnGkBLQ 2mQcoWgQ4BFVd/7qYpFecc5uE4EJByJKEgwSe5CqCSCMAFn2qlAY5ol8nclDngjEiGsgokYidagQ ES+JnSRrsI2REXIKOEQCgvYIIQQMrADPADShLOeITE/cfpuJZPmWfsh/QRKqs++BvFE16vt1Iq63 F4kU903AIHvKH4KE0o5FAOdTUqGMQLJ/wTmFQpQ9uVUDogLygn4ZhuHMoaPifBicjFhEhIQJI/Eu Tu8K4B6JOs8xDzdNxRADqBD4/RHyUvwM6dJ8PjAZQZhROhgbP3egUBgYMZdfSFfywzBpE8TMpCCM T7lPcgrPs0KfloUNihOIT6VrgWIsCkoklWJUEZWtn80LJSwoHjmxGa1UsRGQIhRUukk/JGgPuVUB sIAJ69oobfQZAhkeX9ec/xFipbm+tguMTJkA+1Y6Gvd4lrlLVqOwVFMoBkDBwgCDeApuCZhDpIqO 9zByqT05GRsU1SRyhrbxRIEBRM4+oAXiBxQjB7n3jZcvhPWtFN13O/38K5vvXDSgbl+ZYYO7OELU ZylfJT+tN+yChIkMuLSWQEsI5Q/UCFqUUWbaSD/iPtHjJKShlOdbSToGZP7Nj84Xh3J/1pBuPiF4 HIkGzhYA7CeECmJIFVXaF87BNZehcIhwd31ETysnDMuvA7NjfnLutk/mf0j3o5QEwPEeQApu/YNA bguAL0sUyDIABEiqBIKL22EV59YSPdEp/q9NOqM4y/fL/WR2ifyPGL3B0q0Vsrvli6gUh4HgXFm5 UghOtLD/ptO/lAufwUznkQyj1y9CpZc4h1v5vMUx/M57ZEpQoCycFO8Xl5AX2g75y83kfgdewl2v Pf0y4H2PsjZhGwxuegY6FA6YoCWs0m0d/abgZh0C9gNUNoFGQGGAGohIjMkgZSKVGoZU885m1Pch 2KaRRKHIkhB4fNejdShT95CypyM7P0H2R9f1TVii86RHO6XszjtdIhzhx5sQ+/e7/uAR6dgdwk9Q 79SQXcpyj0cyh4i62/wAzgI5hHUq9Lv5lahMSCvY3quUaFHrM2xE2on4qfcvzXDNkQvt/hFEiqCx RVC4JqEmD88Q/R9uSB/H+vi20pWqjsBn/MtMBSXoJlA8gPAB/IfYdilg+QdtdoCHN3p+gTz7AD+e 4elE5tiIIGkQzqD2pEJ2/GpZP5kqIhNXIH3wzDyDAXPpfHHId1GAHN2Uny5RuQvDF56FEzrfw2e5 UFy+Sh7wvPiBiC+gnS7lDnACcxr1u9OINz5vBz+gTL70dqaEcuIhx5eYAruE9gvwUPcKe81QRE3L ydoeQ8ByhFdSLiHaOSFrk92V9r+j9Bb/8fefAcB2AwohyDhVoSZS4bl6Q6g0Olh7eU3AvWjvVE8P sPauJ9gBo8kcPcGoSeIned69+9+nNX98H7QO7VxuT3hDoLChyvQQJYFPK/qD+s+y1giQJiIE6wcw ps7APuB0d/FPcifFEgp8X5iH1Rbf43i+m27P3ibAt8z1XoBEYfYdQLT3if086H/3hp6ewLVOEH+u L9vfxI8pjekIr3CicvG13UcltW/1gmYFMveP2ouk6+riJgJ+dV4HQsBNMO5GFChLDSOqf3eB9qf1 8ppCTYj3aRrF4f094lyaQ46kyUaujWAp8FXnOUB5At+D4CdyXgcoHUPyDYl4cqNHzJrh+T3AuU7R wLwCE6ouyycgWV3gdN1i4EgiBjzj0ZjOsiBHU8omo44Ny2DNu3LtEmQwQ9AX5GCfC5bgDToBEdSm iz2NqNc8QR/DnALwTLiobnE3XJ0qE93HfXAAuEuQXwA3qG0DKC8pHtAxA5C3n2Ch08NQL5Y9pE07 gOlexOo7R2KG8A1FLkvtpm21W7AAo2KdJypoEPgmHUhcdK6AEO0FxOwOIJwHoUOBxXVsBtXpvUMy PgGlBaR0+JzKa1X2ajpELkURJFAB4wQHyU7Q4llUDtU5l2D36uYbAvAAxA5lXxdQ7xItAB5HMcnQ CI71DvN69piPBNO9OwQynYj5I6RNIdSUi6Ub/EMyp3DzzaoeQBkVdQsDlCYx0DCyr1A/EYc6JwKd Q+z76pK9pJ7bfH5yfGgqEfuuJMICYvYGbOnYr4Ke73PdMk/KEmT+Yfi/U/DR9eCTZ/UicCfyR5gX YjeeKPioeodXwIdpkyE7jUag75CZPGkF+2lFx7qUmCikYISiUAFYowYjC2ViEXFNYKzKErZSoIsS SpYMQQZAZEStWWqUFkgokUASOWBRFD4uTXeTp6awWQWD2tQWYuO/EncemTghCpV0ORxipIEjCFgi BdPuVvexEl9yChoR9XGAxoJCm4zZraWA5oBO4fxQZ3ng4xCLotSJCWifAXPgGIdSm1UT43h8UvOt N7XEPgAj3i6+ZL0B+MB3ZgwEehHFehMDXETqFHDsv1ovx3GYD4ulmCPmmW8ygtb16UfMzKZMQNfz eTCz0HLvFOyKzPSUMDRDwuKEgQEC6whQ2sJS9EVLmqhnWHH8KE/3IzgglAokuUQEYIGQ0CQGJPqd 55koD+H1M4ombR6A5A4gQgwyzLXiAt+IvUmvMQUOtE2I3CexQ+wW3wBfeMa3i0JzKHSImUvfcA5l fgJycxqFzseoICbyG2XJmJoiWAjLBVJBoY1GWIlJLarkA9z6+/btFChswyr5ppD8WZ1R9Ox3J9ML Aoz8naMYjI3AAfGCEiCnWECQQ9yCbmz2w6RAhkU/lgqB22Q5A7OA+JAdmzmSlkhInMZPnB0n7BIk IdK76XtiFujo6OqxgYH0RfuD8Tk0uyOyFclfI4AL8V2a7bNmL5XUcsLEfmWCjQN4SWFEoiqC0tSU oqhyNw8ZJrQyFBug/aTo6J/qtf95nyly3HjxGftCu2/wk85lZhS6qrNSRYI7rUBSTbrG14Uh+3V0 JSm+AKTEWg21rFAyT0kP4RTM6BRMgomCIIHA6gPYdwPMJ7lIdQy9eUq4D7gpGywUYQFOkiiHSRIK in4JRcK+5c6L1n4I6MRMHvEyVv1qWD7+m3wHsvbaBpaRfFOUTaAac/8kBoFyOIZDlmqzFIYJWHKi UEXEQLnDd8tx8zYG1V15/xK+0cy0c+vifkbn3i8iBRkHFyQIQzxvncNyCDV4ZhIfHOCI0mQNwL2I v1ON6MQMyQUqEAkJYsoJmKs8YMxLUgn2kRKxkfJcYJkoi94ykYdhzhZW9Q6k8DQAh1Haf5CcghkF EjMnFQ6lAi25hGBya/q7/uEQvLGwdCJ5h9S27ETtAR/BD8VixEiwAhCKQ/PC0sKWLzCG+QmCZVUE zJE+gPiBbwekfAEeUCyPgRH7gsskd6tK12CITj2o2u9wRRPuDKKeKo2vgQgSRypFMSeAoFkW0S5H Kp2AexDEC8vQjRJCqqkRiK+AuqzcsEUuAjABwCJYizEJZTG9ewALOuBI+svHmbyQQCGnVuV70Q94 L1ZVR0ICHmqePYJzAG1/FVpQwfaLeHKbQOKhrKXiH3mgTzMyghdJC8KYwQ0ksQs0FlRKLClEErXa i5uGJAbKiWtGAkRShRNColi4iL7L7x6F5hv3DvE6FO1yvEyddgzABCAB8VzaE98Mubi95B5brppH Z4RVTQ3Ueuz+v6g530UdszacyqKikL/xFJjJ2mo2X0yXRBHsOwa9WsGaEvyUVGL0gjoqNAZ1BI4M uec5MmTBSwsUP2uMdUK7wZTtdCTEZzqGyHEwy+O0KGy0tm13A8bnBxah2TpM48QxOU9ruDwygkue 9znpkuyQnGN5mo2uFEuiIixGCrxJNMIZe7oqgWWi9mFdP4G3rS8Rwp108PcRJMMOMKZVKCWJRUVa VCFmIg9IOyxFx2cpH/S4j66tRCYY24BZD2xInBi6oXi64UrUjjUq0pH+XLOaWYXEjSo1vFpljTZ7 zIq2UI8a/l06LjCijVSVB5ClqsjQHj+RdCAckRNE4Q5KBqqDaLcZJ/aa5jsrODumZMglCghbM3/T p487dVzCdhkuyswSkzJGOAKOh/vy6ehPo0gsir1P16mY5Zi8Ia/1iEcL1dlVVFVVQSuS4C5Qa2AC TBgTG2CICgJDxJIFERboPQQSRNsGowgGwMtFOSCWlg0oc1/lDxR7wHvE1lgPAyoLs9gmgXdgnIJl Eu9OSkxIn2ETHT1u8Om87DzdpZQ5RyqHryF4mPXn3rwDY1yAJ1vELL6dGjInSCEOs6ZuIBVHCiXD 13y6wYFODLr+hTG11gqY4WieJKSYToLAs/MpAwj5Ap/H9vMirgFmww+lyYlg/In5ofEd3x4CeSNk F82wKZQDsMi6WZ6JKQkD8aR0IRQsH1ncmKKUKBhhE2YHkJgYJGJJHEarKHQinKCJAGHeC10I9xw7 OolROaIc5zkrfzfOWBAy7QaEsEroTbDZRgrIrrLKEAkRBzIOHFUER7Ht2mIrFFE7Ox6XXQL6o8+u suZ5FeUeAQTXfE0kUqJhCiDLY4NyYtrsua4mCqctqCLFaD7TvN2jxv1fblPGOnd9RALcTcGg5o5R uQyRVIwY5BxgedLCqSB+sD51YKoK/tPihkMJm/N8uM00pM1a+X+Sw1Sh+JWpOrzFaXl7V3jeH67s JgQ3onv6udd/2gvMdYci+/yPn8gPcAeQ9yh7hKMgd8RoYUEKTasfvVG5XkA3VkVQRIsioyKiiQUk WQWQiwWLAWIkWDGSCJILIoLAUiwFkiKKwFhBGAsiyCwAUgLEQFirAUFRigRYKoLFUWCwEZBYRYRQ iwFkEVUirAUUgLFAWPvkkBeHV8BRyCY+0aKJmDBMSCvvyABVgU60CD/d+lFOhcugnQPSq+lJvEzq a/KF1DUPVLQ3KKoSCiU0nvXuHKaRDneUzhuEEXh/FbcPxNRRCCfXKB4JZwzeA3/H5gB7CU+xIoCy AoCkWQUBQUFCLJFJFgLIooooLFJBYsCKRYsiiixYsIoLIosIKLBQUIsgCwIpIpAUFFiwgoooIgoK EFiixQkUBYLCLFFAWREUAUUiwWLFFixYpFFFikWCkUFFhQYhjHWFUrQXC0PvwAoMwJxOjUq9OvxE PUJlfziGk0JzKHx1TwoCodrq5TpXXxws/y/EtHzNKvKgvFqSRGYgr3IX4PlCEoSqWoBTN6KfBEVP JgsUiion5aUtgWAxlpS2BYFsCwLSlpS0oxjGMGFskskthLCUsCwLYSwlKFC2WIRCUoULZYiMkZJb JZEEEiRBBjES0pbKYxjGEIMGKxWqaYLBaKQpC2BYFsCwLYWFpJSS0hSDCMJSkKQtCgiMBgWlFVER LLLzOlOv43AOXlCj3qF23qDxrrBfs6BOocwGUA+1TARNAIjEAB2LyQlKlDUSk3Jvi3gxWKtayzYY WIAUK0UhShVy2QsoWaCwRCyhakpSihaRaoSgSwFI0C2LICuYC3KqeesdyXnuF8lD5L+pDR3I6bDY KkwPvNDnGSilAJnegLlVesJc9BCsFneP5yzjcFw8nm9odIKl6fVU8U6u+7NJqrRk+EC1EuCqRB04 5MSkAylBLOKLt7MDDiAkoKNIyAlmIic8O4SNolySoBQdpEpRR61LcUzBcKJLHjDOoN5vKAthBogK SGmEqBQjNLgKH4xm5t0wPpp5qF0RRNiFsMKTSDZDKpCQY71T8QC5NOkwHwBVQyhWQ9CuT4XSpCQI Fn8T7b0izxIcaIdvYAwSw9YxMw0EBYIQJFQh0G4esD3inQPIGOVA1Q3prUDOiq2oQCv4lRFTkLg1 10Gw9wlIdqj0NoFO4U9yr7RXIaj0JSwoYlKwoYlCwpYNIQphQfineq+o4i+p7+PvEA8U1KE+IKYL qTcj8HKkDxQ4l3e0uIeiJyJ2/eL3L7tfUaIfdl4GJbqo/QQtOsuoscROKlTlLdGD8BcbJ/B9kFkD UD5IcGxHuYMsDmG/UYhUFTC6Qe9tziMJIyDoUlEQgJHnwADUpQARG7MCAQY5LA3bMMDVI+o+odaE Oaix0IAI6bgcLg0InhhGiGS48yQ7soQ8VbaYX+io4DoyD3h9AXo6nGkjLIDqisjDuLoVEm0ZzLPo IM5yVaFLCyskMMcYBgGBY97YnwM8eRkFBi9G9WejCVTJqsNooqw1WvCDQIkMmCRGS+dWICyehNNQ JaPwFmAaWkIfBjoSP4S/mv2bA+wMgXnMUCpxqUBRpZFguFsseeh0RHVAASAeDJOZ6CB280b3Kr5z sbhsYxaHpS6yyQJceGMQxL2d8GQElPuzkzp15anrLJg0/KMyKZBQuQSAxIESKjAXlR8FVpDSTPub gskRjIVSb2NKMlM2XxMBwOkvJ47nAhxCHBsixYgggMFYMJkVEuQoUiEMmTIpiKEA0+IWgRZBDf1Z EPo/nPmvWLIjGCQgHZVgsihSkDoBCKnsCCZzCEnxSwhgJBSW4yeyipKr/rVA1+OIr+oyEKT2eZeb AW4TXDA8wKGBzeK92YTA/Dv7k16ef8Fcn1/PIvdsD/TEKtz5xZF9f8kf4JzM390PLpAfsAyrw3Yl ihPH1Yx4+pY9Z7cLo3Rsl0XvhVtcXWygyukRUH8RiJfH40gaTASxaXij911YFEiXX0pUu1kkJMS6 Y2sWSk1YYxdRWMIYC8E+pLlDcqgsiqC6C9cmBRi6LKAUY5cSslVcS4KLxJck0GEmKImckjVB5KV8 w9TtQ5kgNoueJIHtHzPv/p1XCt4fp99WIEVfeJnRMtgDhL80yf6aNN60EWA5v1FkDgu3u7OVS5Oc y2ERORYn64KtwsLCtLzi4PQOY+oMG0+i9Qe9OxM4F0X7j84LToDOJkBDLm02s5SFWSFVBOdITIkM 4LMrBkRBmgBh+P5pH7XwseoYH792fM7BRJogq51AiIEB1nuAcDF10GqHmmE8mY/LeoM62NGPscHN OUqHGs1FEUU1fF3LtP4gzzRBkFYSIAwFiEQsIOhQObpUI/zlC4YAcR3OUyOf2EsYaSzv55LmMvfG 20gQNMNEhBglyF1IXC+ZpTMA2Hf9q5l6IJv2asqMnp9wg/EiAmCJ+C3xhAYJ/XDWiYpVYFOC5CIC /iIjcBfeJmdC9wHUiFwqguQUTtDcL9FwVdvOZfGC6PAUDQXJ3nQBFiECIsUyKFyMRyARC4ukCA6j 2EF9sQZFfbIQnwC432uKCksYC2LiDcWJEZ/N+nEwMRB3S/7lm/7/7+DADuh8//7XkrqsAYH8MFBn d/xPjgLAzBQZUxQ7Y7M8b9LqGZA5BCSTyTskJImMFqIwisgEh/9iKhWulWookj75uOAen7aaly8W V+6UOAh1lpBlgDLBcYGY+ki9pOvB9oooXixRSkJQVgUlGKIQ3WEfG4wT1alpbSgQ/noUYQ3trWjG g6o6/2giPlvFEtqXxPkoJcCewN4fH8wlhRMgW+1HCtBsIa1WeIIghQtxKRw631kkZjnS/l6wXSxj /TShUR3R5izEoGIwaMl3GTrBhDCGbd6BmlwwywoiWAMLM4xDC0IWDQSAgVhU2oQokaDCWYuUqSbh sASrEZ9+RTenIn6dL1ZynJA5FP05H9Z+dE0I58yomRcgAbw1CSGpDSu1QpT38r1yeiUfU7aOkAkW 99gcijlB/BOZH8x+FSMiSfiKdQYKn6F7OUHUDqEj7ONChUbpIAWpBZQKlJB8BPsf6T9pmRsH+uhq xVcn63Ayh0ZEv5Bp9A62UqAJ5BbWIAPwiBtGU9e/6seMMwXT1J9CUTO25SLfL9oWM6GcMNwHXu8W rhAtUOeTkowIWkQhtBwT1g2+CGVQ+tx+pY9x2ahsIGGkRMtEihqA1FiOAejBsSgBrFsQjFkFYd/U N6WG4LrNrc9WlgigXNqSRuOtIXl5cWqFWKlizUBMBEWgEsGlBe0xMZmmRjVneRJIeh/BJdMf4lUi KqCVVdH45swQ7qxAsxEcCD1Cj+pV7UsqZFDvVvcLg3u0L/2BZevFQzhnBwRMw7RX9I8p375NUok4 JRREJyhQBePmXDzgh3h+JSO4gBIBYI1Hl5sN2g5xLx6XrBMBt7KIG+3OV3Fz1mQo6hLyhMTJeSRm ySiVFreLW8Z9k/gGCcQm0MqzebtbSEkAyiaTlUdA6xJhjs/SodYBEIG0P0iYdQmlpkdTXQoaxx33 NgRHDQti7Jd9jQZIcgptB7s17cPuC88fafYJ5D/NiHwR5TiiW0p0OJReBSJ0p2BwBPFRerUMD+dW 5bwX5LoB+ieHBMo3ZkIm3r99307gDw7wA6B8TsHr5RQfg5DgmwVuDQQU8TPfhXuUI/VRVEEhqikm f1hSXLbbf7Lj74/bA6QIgf9IghegBIGdZtE3Ij5u1DtLB/CECESIxEIgiFLAowSrPeTIGD8rmTCP vSZpKpgofam8IffpIPZiJsXhm2ingOs5djkATQT3P4nbVGfvMor9UoBNIZQR2KL0qHsD39Y+yudA 69AKfRdB7uVQuB6QEzOcPBQUvPJQdYrkMxE6aVErlPlpMGBGJIyMiIjFRIyC4QP7Q5HFLi7uIgvK EQ9VLznxV2m9KRuHD2ouAbguVe4MnS4oiikkiRgLiTo3iKmxOxE2irZB4kRTmAOVOnUIBS/v1CAV 9GjTbFSd3050fETUXnu30aY3PF5DOotjifIKbK3mCOxu1v/SGQL7J2Apun5hkfpJJ7eTpOT+kf5a oi2z74HuWZzzHY94JqFvRGkeUzefKFXksz9PTymUOUP1wICYRD3y1e1CgsJUk8ye3wkpFLProLg1 neBSH0H6CnkYRYsDLTTAnqA1pAbst6SqHYiHUdSOCmGcgZDFf1Kl5G1gYB0qUoe0PsE+A3AiNvAc ynKncJETdo7hsoYGCORJ8OdXvFzIfM94L7fqLrEzgGLzIHuKDgocUzqNAJlF3dayBYnoRoUitjW3 BdAJKHrOtFM8RkRbC9beOEG1cPqWR9OOfu0AcuT4nAS7KC8qJZ6RC9Pb2lg7Q4dAOwB5nrVJENan AZ7gawY9HEchrbFKG4bgOUQ5TghkRMw6tgnchpzC9y8/HBHdXDWg4xQRdQZvcXMCAH4B6w0Nks++ HtEIh13WP3EFPdeSUmQTv7XmBaKcgG+g1dALsuUNKo7vITv9xyCj3KdaZ0zJqgcSihkQ777oH3sM OE+xzm3NK6AMDCJtB8UYYgbY1BGKsl5ukS5j/oADpEACkFyMxoqWqmQUIc3leVD9kpehCFeRiZ6x T2CnQpOEj+enVyMgYSSYIsnZeR+Uj9UXiDmU5wUwAc4GvxHWIpsHBer9ODvblDLwxNf8Sfg5D6mt f4iB/zuLWKP5rWIEAzv2aH24tICKb1D5oP1VfEXIodi8oCO689gPsMiPzBQ7RfqdSpY5xO0Paq9o Lp8BX2KZUWH2eSC5RGynH/5J2kU6DjEKQgQg/dcKTOijxL/dQ9SnYP4vOmoDfrE50T3J7QR7B6FX p9QXm+Blv6D7u0AO2Leal3CXpiKXZkPs29SZRfABxgQHvT7APQ5/Qx6nnF1bz0AfvD7SyPa6hN+z W/YOJzdsXiVRz9I4x7D3BA91sFVBBMzMho33OLbt8pGdaUUkRRFL/iwxtdsKj6pMFDg7Pv6VTim8 X25zs9gZ7GdQvMzc2zr4CXOo5e4Zyry8xvZcO5Q7UfBD2iTOp1ncJ4+T5BmDEA01zL9qnh3g9Xk6 RN4nUd8RPBYqQYNsbvpAhBkjEhCKSIL+z+qhRqixYYECJAIHeEN8coBuedWz+f55LQYCfIgHy789 uZMryD7UL9QOrmE8zYq9yeY5uwUdSlh7fiq+iflyBvXa+GrqhaHstbwzg9pY2BhWGVO0zAYp4IQ9 BOldo8X3p0YUPN7BNo4Cq3gdaC5V1D3xFO2KfBVg+9QyI+qj3KHM/B3p5L54JWUUyd5MhJJMQNj5 Z3EQ7iP/QwUzAxciZ0HIpmoT395wXBQ7vRQ1gZAobGUoPTYJYwHwW3DK/NCdBk6lDlAdqhbIKZzs QfnlFNg/3y4F6hUNKh1KgbwX3Ccy7U6hecDQbhXifLMIYgI8dofJToA0L/JPrAhCeH+OyHLseYeg hGCQDeHaOc4CnMPUrSrxzKGA+onN3BzHaavicx8RTmA0AvtwX3C6w0qHVyETyLzUj80PMF5w8nZD 4oc+J0C/D5ZM5ZTaIci9CC5D0+wtR7A6jlcJNySAUkZL3C2Exxq0xFxcH6obn5vnVVRFAZLIQ94C G3ZaRayZMpYkkra9D3jegvUr3HeHOGp4C9onsBxFyO/xQDsFORQ0uxwYJyw5AOC9CBo90mTJ9j81 fFDA/IkeSR6g6cpvH4D6HjeJrH2/YPzGch49PqhlI/I9QnUD2KF+zvekyh+kzVyBQR6bC2CgpY8U TsSgXu4o67G0MAB1gI9HJ5At1+C94CGIPRIIUE9U8gN6Lh9C+oPfAVy+Cue9Xq98oXW6ta3Iwlxd hnqxa4vRAOKrwTz2Dg24EkPrc2h8RVJPZckfjokh9kT30cuZJD4JH1iMkiVTwcOyT6w9RMzE++Gw TgpxFHOmgegfOlOIGRU0KHkLzYJJecUeiMhfCQ+b6z5Pp9qdjmQ3iI+kMA6V5urTlUOU1ZDyU8F5 QoTpN73KavLaO1Q08rQqgu5IgL3CnT+gbOUxHnHgK6h5+JsReo5jUj4bk0henlvLkPNQ8D4p5qvQ IPKmkDBZj6oWNOhV7VUDUJA5TsO45SaCbCJh1ZOzZAgZr24tvLWtQUti0s2EMZ+lmYQyTsaDJkRE yF4mN4mkHKbF22NGI7UN9HlAhxLJsakhCy78yrnDkVJrGNTOYgGkhxiMOUYY3s0G+W3O2A6XQRcg U5MiYExRECW8DoKEIGEIH0B4QnsCflBgM0GPGeSt6uMWgisFlEooisOMYzl7QUJ2mzN8dsmgbY2c AtwolrVGo1gMBNMwsgrXbBU3dQ55gJDvvjAQGb3MwPZBSrUKjK1q1IWTeIN2yyomZzhzHT2eRkBb PidPAzpyGHW7AHcG7KB4IGR6w6s6kTtUM4ceZQ6A1Jl2i+QdIbA4AuwByHJ2nPydBEheH615toNx nVihgWGAU1VUIkDvUTO5wPiOIFGfUHOC3cDRzCex4KHEfBV6vABuB8xcVDuAOc5wXp8dXX12bSSq q1V3XVai6rPZRa661yE367vP6955C7xd6BfvV7eXoS8Dfh0HIeKnSdScwI0lwDqA7RByHmmxQ9F9 uALzFKvtNqriBeHoveHSZeXkAdHS6+oe7nE9DnE7070OTcvi+CHiHSjuTZqM2UF16h61DhAOxdYz IN62XP0i0HOqB1EMx705xxQTdp5g7gHtDLqQH5kQeMUPDmO8T0HyUv7wTqK2UbxPBF7VXYJ3oGO5 aHKmC80zSRopi0JuASgDx5DWnf1gvgogphETgbOhd/OmK9nAXUHJZUTciAe5ehV8gDIeY5hDqDQJ yI+vkoeYnYdPOcQ326ROIpZVyBrdYh0diPmmQ6T2IwYCxMcQWk1EW4h4gHATMhepmxBesc/EnIR0 ESUSSWlQhCcqhicHqPAwFHnUOAhcJ6i+JvFaBN/MBeOnsz53KLtXgOW47xbzqyD4h6idrSnUibOB lXm50b15g1VzCUPnBWKlI8oz8NEnw/L5H3dPMPsjEdI68/OnMHkPioZke05lL063epkFeU33AkBf ITeguYC/DqhJpJa4QRcrLWvUJy22qu/B61CHoGg0d/bzKeRj39ZkSGsd4N5N/mmXxtoUuM20Mnmc F3mhfKDqFejQAGW5O1zJ4nSO7IZV6FQO67hsDmNCj1jt2jYBNY7jQPiKJziaVNCrYE2o9jyLqQ0L YvL1DgPQC4qQcohjvBeUNyL5d3aJ1ieImxHmxE7LJv8BMA6LuejyTDKCmtcFDnBeKHP0C9dw5kF5 V7gKLAHVwVeYxHrFyq9OJSjxFesNCCy4uQ5EfFNHKoeJ/PB/Qn3H0T/f+5/ATCSQIwIpIP91AUxP u/8//5b/PGUO7ZNp13oYiSW1Tv30d+M6DfRo3mC4UrPApPzV+j/6wQC//L/fyXH//F3JFOFCQEEw Kuw= --===============2138005986==--