From: Dmitry Shulga Date: May 20 2011 7:11pm Subject: bzr commit into mysql-trunk branch (Dmitry.Shulga:3377) Bug#38813 Bug#11749345 List-Archive: http://lists.mysql.com/commits/137817 X-Bug: 38813,11749345 Message-Id: <201105201911.p4KJBx8N032032@acsmt357.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4645308769012410347==" --===============4645308769012410347== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///Users/shulga/projects/mysql/mysql-trunk/ based on revid:mayank.prasad@stripped 3377 Dmitry Shulga 2011-05-21 [merge] Manual merge of patch for Bug#11749345 (formerly known as bug#38813) from 5.5->trunk. modified: sql/sql_show.cc === modified file 'sql/sql_show.cc' --- a/sql/sql_show.cc 2011-05-04 07:51:15 +0000 +++ b/sql/sql_show.cc 2011-05-20 19:09:31 +0000 @@ -2408,12 +2408,11 @@ bool schema_table_store_record(THD *thd, } -int make_table_list(THD *thd, SELECT_LEX *sel, - LEX_STRING *db_name, LEX_STRING *table_name) +static int make_table_list(THD *thd, SELECT_LEX *sel, + LEX_STRING *db_name, LEX_STRING *table_name) { Table_ident *table_ident; table_ident= new Table_ident(thd, *db_name, *table_name, 1); - sel->init_query(); if (!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, MDL_SHARED_READ)) return 1; return 0; @@ -2983,98 +2982,196 @@ make_table_name_list(THD *thd, Listmem_root, + Query_arena::STMT_CONVENTIONAL_EXECUTION), + backup_arena, *old_arena; + LEX *old_lex= thd->lex, temp_lex, *lex; + LEX_STRING db_name, table_name; + TABLE_LIST *table_list; + bool result= true; -static int -fill_schema_show_cols_or_idxs(THD *thd, TABLE_LIST *tables, - ST_SCHEMA_TABLE *schema_table, - bool can_deadlock, - Open_tables_backup *open_tables_state_backup) -{ - LEX *lex= thd->lex; - bool res; - LEX_STRING tmp_lex_string, tmp_lex_string1, *db_name, *table_name; - enum_sql_command save_sql_command= lex->sql_command; - TABLE_LIST *show_table_list= tables->schema_select_lex->table_list.first; - TABLE *table= tables->table; - int error= 1; - DBUG_ENTER("fill_schema_show"); + DBUG_ENTER("fill_schema_table_by_open"); + /* + When a view is opened its structures are allocated on a permanent + statement arena and linked into the LEX tree for the current statement + (this happens even in cases when view is handled through TEMPTABLE + algorithm). + + To prevent this process from unnecessary hogging of memory in the permanent + arena of our I_S query and to avoid damaging its LEX we use temporary + arena and LEX for table/view opening. + + Use temporary arena instead of statement permanent arena. Also make + it active arena and save original one for successive restoring. + */ + old_arena= thd->stmt_arena; + thd->stmt_arena= &i_s_arena; + thd->set_n_backup_active_arena(&i_s_arena, &backup_arena); + + /* Prepare temporary LEX. */ + thd->lex= lex= &temp_lex; + lex_start(thd); + + /* Disable constant subquery evaluation as we won't be locking tables. */ + lex->context_analysis_only= CONTEXT_ANALYSIS_ONLY_VIEW; + + /* + Some of process_table() functions rely on wildcard being passed from + old LEX (or at least being initialized). + */ + lex->wild= old_lex->wild; - lex->all_selects_list= tables->schema_select_lex; /* - Restore thd->temporary_tables to be able to process - temporary tables(only for 'show index' & 'show columns'). - This should be changed when processing of temporary tables for - I_S tables will be done. + Since make_table_list() might change database and table name passed + to it we create copies of orig_db_name and orig_table_name here. + These copies are used for make_table_list() while unaltered values + are passed to process_table() functions. */ - thd->temporary_tables= open_tables_state_backup->temporary_tables; + if (!thd->make_lex_string(&db_name, orig_db_name->str, + orig_db_name->length, FALSE) || + !thd->make_lex_string(&table_name, orig_table_name->str, + orig_table_name->length, FALSE)) + goto end; + + /* + Create table list element for table to be open. Link it with the + temporary LEX. The latter is required to correctly open views and + produce table describing their structure. + */ + if (make_table_list(thd, &lex->select_lex, &db_name, &table_name)) + goto end; + + table_list= lex->select_lex.table_list.first; + + if (is_show_fields_or_keys) + { + /* + Restore thd->temporary_tables to be able to process + temporary tables (only for 'show index' & 'show columns'). + This should be changed when processing of temporary tables for + I_S tables will be done. + */ + thd->temporary_tables= open_tables_state_backup->temporary_tables; + } + else + { + /* + Apply optimization flags for table opening which are relevant for + this I_S table. We can't do this for SHOW COLUMNS/KEYS because of + backward compatibility. + */ + table_list->i_s_requested_object= schema_table->i_s_requested_object; + } + /* Let us set fake sql_command so views won't try to merge themselves into main statement. If we don't do this, SELECT * from information_schema.xxxx will cause problems. - SQLCOM_SHOW_FIELDS is used because it satisfies 'only_view_structure()' + SQLCOM_SHOW_FIELDS is used because it satisfies + 'only_view_structure()'. */ lex->sql_command= SQLCOM_SHOW_FIELDS; - res= open_temporary_tables(thd, show_table_list); + result= open_temporary_tables(thd, table_list); - if (!res) + if (!result) { - res= open_normal_and_derived_tables(thd, show_table_list, - (MYSQL_OPEN_IGNORE_FLUSH | - MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL | - (can_deadlock ? - MYSQL_OPEN_FAIL_ON_MDL_CONFLICT : 0))); + result= open_normal_and_derived_tables(thd, table_list, + (MYSQL_OPEN_IGNORE_FLUSH | + MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL | + (can_deadlock ? + MYSQL_OPEN_FAIL_ON_MDL_CONFLICT : 0))); } - - lex->sql_command= save_sql_command; + /* + Restore old value of sql_command back as it is being looked at in + process_table() function. + */ + lex->sql_command= old_lex->sql_command; DEBUG_SYNC(thd, "after_open_table_ignore_flush"); /* - get_all_tables() returns 1 on failure and 0 on success thus - return only these and not the result code of ::process_table() + XXX: show_table_list has a flag i_is_requested, + and when it's set, open_normal_and_derived_tables() + can return an error without setting an error message + in THD, which is a hack. This is why we have to + check for res, then for thd->is_error() and only then + for thd->main_da.sql_errno(). - We should use show_table_list->alias instead of - show_table_list->table_name because table_name - could be changed during opening of I_S tables. It's safe - to use alias because alias contains original table name - in this case(this part of code is used only for - 'show columns' & 'show statistics' commands). + Again we don't do this for SHOW COLUMNS/KEYS because + of backward compatibility. */ - table_name= thd->make_lex_string(&tmp_lex_string1, show_table_list->alias, - strlen(show_table_list->alias), FALSE); - if (!show_table_list->view) - db_name= thd->make_lex_string(&tmp_lex_string, show_table_list->db, - show_table_list->db_length, FALSE); - else - db_name= &show_table_list->view_db; - - - error= test(schema_table->process_table(thd, show_table_list, - table, res, db_name, - table_name)); - thd->temporary_tables= 0; - close_tables_for_reopen(thd, &show_table_list, - open_tables_state_backup->mdl_system_tables_svp); - DBUG_RETURN(error); + if (!is_show_fields_or_keys && result && thd->is_error() && + thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE) + { + /* + Hide error for a non-existing table. + For example, this error can occur when we use a where condition + with a db name and table, but the table does not exist. + */ + result= false; + thd->clear_error(); + } + else + { + result= schema_table->process_table(thd, table_list, + table, result, + orig_db_name, + orig_table_name); + } + + +end: + lex->unit.cleanup(); + + /* Restore original LEX value, statement's arena and THD arena values. */ + lex_end(thd->lex); + + if (i_s_arena.free_list) + i_s_arena.free_items(); + + /* + For safety reset list of open temporary tables before closing + all tables open within this Open_tables_state. + */ + thd->temporary_tables= NULL; + close_thread_tables(thd); + thd->mdl_context.rollback_to_savepoint(open_tables_state_backup->mdl_system_tables_svp); + + thd->lex= old_lex; + + thd->stmt_arena= old_arena; + thd->restore_active_arena(&i_s_arena, &backup_arena); + + DBUG_RETURN(result); } @@ -3485,10 +3582,8 @@ int get_all_tables(THD *thd, TABLE_LIST { LEX *lex= thd->lex; TABLE *table= tables->table; - SELECT_LEX *old_all_select_lex= lex->all_selects_list; SELECT_LEX *lsel= tables->schema_select_lex; ST_SCHEMA_TABLE *schema_table= tables->schema_table; - SELECT_LEX sel; LOOKUP_FIELD_VALUES lookup_field_vals; LEX_STRING *db_name, *table_name; bool with_i_schema; @@ -3496,11 +3591,8 @@ int get_all_tables(THD *thd, TABLE_LIST List db_names; List_iterator_fast it(db_names); Item *partial_cond= 0; - uint derived_tables= lex->derived_tables; int error= 1; Open_tables_backup open_tables_state_backup; - uint8 save_context_analysis_only= lex->context_analysis_only; - Query_tables_list query_tables_list_backup; #ifndef NO_EMBEDDED_ACCESS_CHECKS Security_context *sctx= thd->security_ctx; #endif @@ -3519,15 +3611,6 @@ int get_all_tables(THD *thd, TABLE_LIST */ can_deadlock= thd->mdl_context.has_locks(); - lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VIEW; - lex->reset_n_backup_query_tables_list(&query_tables_list_backup); - /* - Restore Query_tables_list::sql_command value, which was reset - above, as ST_SCHEMA_TABLE::process_table() functions often rely - that this value reflects which SHOW statement is executed. - */ - lex->sql_command= query_tables_list_backup.sql_command; - /* We should not introduce deadlocks even if we already have some tables open and locked, since we won't lock tables which we will @@ -3547,9 +3630,19 @@ int get_all_tables(THD *thd, TABLE_LIST */ if (lsel && lsel->table_list.first) { - error= fill_schema_show_cols_or_idxs(thd, tables, schema_table, - can_deadlock, - &open_tables_state_backup); + LEX_STRING db_name, table_name; + + db_name.str= lsel->table_list.first->db; + db_name.length= lsel->table_list.first->db_length; + + table_name.str= lsel->table_list.first->table_name; + table_name.length= lsel->table_list.first->table_name_length; + + error= fill_schema_table_by_open(thd, TRUE, + table, schema_table, + &db_name, &table_name, + &open_tables_state_backup, + can_deadlock); goto err; } @@ -3603,12 +3696,6 @@ int get_all_tables(THD *thd, TABLE_LIST it.rewind(); /* To get access to new elements in basis list */ while ((db_name= it++)) { - LEX_STRING orig_db_name; - - /* db_name can be changed in make_table_list() func */ - if (!thd->make_lex_string(&orig_db_name, db_name->str, - db_name->length, FALSE)) - goto err; #ifndef NO_EMBEDDED_ACCESS_CHECKS if (!(check_access(thd, SELECT_ACL, db_name->str, &thd->col_access, NULL, 0, 1) || @@ -3686,66 +3773,11 @@ int get_all_tables(THD *thd, TABLE_LIST continue; } - int res; - LEX_STRING tmp_lex_string; - /* - Set the parent lex of 'sel' because it is needed by - sel.init_query() which is called inside make_table_list. - */ - sel.parent_lex= lex; - if (make_table_list(thd, &sel, db_name, table_name)) - goto err; - TABLE_LIST *show_table_list= sel.table_list.first; - lex->all_selects_list= &sel; - lex->derived_tables= 0; - lex->sql_command= SQLCOM_SHOW_FIELDS; - show_table_list->i_s_requested_object= - schema_table->i_s_requested_object; - DEBUG_SYNC(thd, "before_open_in_get_all_tables"); - res= open_normal_and_derived_tables(thd, show_table_list, - (MYSQL_OPEN_IGNORE_FLUSH | - MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL | - (can_deadlock ? MYSQL_OPEN_FAIL_ON_MDL_CONFLICT : 0))); - lex->sql_command= query_tables_list_backup.sql_command; - /* - XXX: show_table_list has a flag i_is_requested, - and when it's set, open_normal_and_derived_tables() - can return an error without setting an error message - in THD, which is a hack. This is why we have to - check for res, then for thd->is_error() only then - for thd->stmt_da->sql_errno(). - */ - if (res && thd->is_error() && - thd->stmt_da->sql_errno() == ER_NO_SUCH_TABLE) - { - /* - Hide error for not existing table. - This error can occur for example when we use - where condition with db name and table name and this - table does not exist. - */ - res= 0; - thd->clear_error(); - } - else - { - /* - We should use show_table_list->alias instead of - show_table_list->table_name because table_name - could be changed during opening of I_S tables. It's safe - to use alias because alias contains original table name - in this case. - */ - thd->make_lex_string(&tmp_lex_string, show_table_list->alias, - strlen(show_table_list->alias), FALSE); - res= schema_table->process_table(thd, show_table_list, table, - res, &orig_db_name, - &tmp_lex_string); - close_tables_for_reopen(thd, &show_table_list, - open_tables_state_backup.mdl_system_tables_svp); - } - DBUG_ASSERT(!lex->query_tables_own_last); - if (res) + if (fill_schema_table_by_open(thd, FALSE, + table, schema_table, + db_name, table_name, + &open_tables_state_backup, + can_deadlock)) goto err; } } @@ -3761,10 +3793,7 @@ int get_all_tables(THD *thd, TABLE_LIST error= 0; err: thd->restore_backup_open_tables_state(&open_tables_state_backup); - lex->restore_backup_query_tables_list(&query_tables_list_backup); - lex->derived_tables= derived_tables; - lex->all_selects_list= old_all_select_lex; - lex->context_analysis_only= save_context_analysis_only; + DBUG_RETURN(error); } --===============4645308769012410347== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/dmitry.shulga@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: dmitry.shulga@stripped\ # imdp7k2jt9wi83or # target_branch: file:///Users/shulga/projects/mysql/mysql-trunk/ # testament_sha1: 1288edb6e0fb687d28a3c6869f03d9e34ab0d7d1 # timestamp: 2011-05-21 02:11:56 +0700 # source_branch: file:///Users/shulga/projects/mysql/mysql-5.5/ # base_revision_id: mayank.prasad@stripped\ # 7sr3ixi04rnoqxwl # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWWr8YXIACwj/gFDQLcB/9/// /+//4L////5gF/0+vPnucHyjQLu+7tlne7rEpNsoBq7570Hvs0eQetLmX3u77T5utSslNaY2ba1t 27rFst9N9MnoaZoZE0EJlPTBE9FI9NM0IxNqhjQaQwCDMgBomQZCaAECamianlIZ6QjTIDEYgZND IMgwgxBpoEQVPJqNkhtT1G0npNMh6hoABo0AAAAASEhEajFT8qnvKMmU8lP1E3qeVNH6p+qAekAG gADQA9QRJQRoamTTTTQU8p+qbaqeZTyBI09T1D1Bpp6QPUPUAaAEiQTQCaQ0aMhMg1NTMqeo3qh5 Hqj1NGgPTU9QNA9Q9TQSA93rXw9Ka7WIgymoHZa3eum7w+eU1KksWbqPCo8L7fYP8HwHQat48Fe/ 8flWfudjfEERAzgo5fZdN/091184+TH3HM73cmjTdkaiidXS/FtyaEXTbx7EK6bwyDOgPrv3aETK NHJkakB9sD1SxEVgUDxOroP0teB1USIQ8qB6OZArqULnV4hGAgD2+4vLTGfUfz0ZagIdSHO4Sw8u 1RoIwlA2QuXdsK5FxBkrVmSMVhaClIWhAWKs0KiC1x98uoJinCa9XYXQbUvvMzCy1SCDWrjK9Z/z ZhkMSZdf9NV3ZmOe9UTfFFTFTRAFtkP81WWlQuAWL3QEqJ9sfNLCAVFiafY42BSYDEfL6tOqwfAN v8MjJD4t29UPkUxSZEm2r1EQOqgRETz0iGFzC9k9rvOJNaoI5j8ztlCgREIIGIrzdIAGrDqjcWbd xhnY5CSIFoxjBZm3ld20OgrA5kvRbL2mhFLVDGLFeVdqzEw1pFlVLQzUUKSAIZ4iJha0ECw1JKKa yiRR1akzEwgkgKGoUcrWrtLibHckRFotte0xAh65xS24mt02Coi52llpLNK6w2kxjQMgQZtgL0Bk dhpYbedOCMmgb1y7StVnv3t2w7dKUkX0wxyjXDDalWWrYE2GZLcVP+aS0nIDaNzaUkVAMjR8LOBh NotyeYqgn87gTQUd/Uag62XXHshV7GbVZpbLph0by46bu6DZ27krlJ4toC+CFF1dJDObxRRQiNVc G4JDAguRWXCigusukwZsIJL5omSqyb9EzWlK4CsKUGK8s8fwVgHqXnNEea9pvCDxUIwkZRbUGMfX n2ML6VtHv45dc9uJUsyTTp4txzJ5b9rsOmZ7trLO4hpnbHVCiCURGixWIF4ZhfALjSHxzdMx4Tkt NXE9rVeEFSKtSv0PGeKiZZRRrOEMTzv4Nuej1oPQoKoOrhHSPcuZUotlmYB+vJ1dEvEJduOlG3kK z23irK7SpCW34Y970RDHCsPY2twNHZtweDvZFw9ByJ3klYrHOd4SsbwlTbSe8ZDFHHNnTNbIiJKc YIgbmzQwBNDmCDNGm9TDKbV3B1E78PwwVCqCqcU5jatW4We2nmvataxgKvHokFkwWSKEsioll7dI DMAomEV05lxdgFqz4mu0IJtdbX2WMxDSlcjZYSD5kpZ0ztgDo9aJJwA9IRObg16++d08Z4jVmxv1 0cPWgxjKhbWg9IveR1tjSPz3jGVQ4qf/n0cZ39cKMABT7XZgWrgzg5ksBZ92J9PZrfixSEDlB81t MkZM467T0u3/H4RmycsPG3IubSr7ZyueGEp95ibi7n07RnfuNY7QuxQkauBpTzYcxBwKkAwgk8Th Rw6AwdfByB06rabtdyV4FrNsdxo1ugaxU8+dfCLiJBsX2r2wfYvsyyzMnIgaDZw5jZugJFgqSqy+ 5PlHa7wBCGYsC6NhpMP01nIewDk4weCrELM74yZm28oocZLi6DRdpQzSj2kGrPCedodZ941Ic2dK zgQKoggitpIzPjQ2KCpYQtyuKnb9qF4peaYvkdV90RERD3+3r277+HoGw8OYXJqvlZLMTaR6e6Ai 7Kd006Fcsgq5l6r5iuLAkDogIbbE8nGsah9mbFlwirmBDGCFslmItNR18qQiIBsiEpdXDKIH3BUL AIs3gbg0B4EJAyiAHSoQzJ11mHxV/kslZT9oj5YK2cIWcoC5jaHaE2opCFq0WY7uGH7TmFitpnHD L5FgguEgtWhSYIH9AuHUsShcJBUk1wtBJ/eum9ezFRXB6xrF6RixdRriFO49RJDTYzBEppe4j2kD 5nRPE6mRjCSiZkIYfzZh6+wYENlIgIwIUCbQtaPbcrdYeO8o0QG594G185PKAcG0ODC3cwPf9wEQ fQi6uwRFQbJvCdW6TzldFAW4RFJz2og2EgYIqxT2KjMdrETXG4s6U2WM9IU6urEuVKDKiN6oRnNS 8Oy8PDbfRbhFgYpyG7Jgi1avAXJ2BY2BGpy+uFSGMaK7S6+6VDFjWRFkBZzaa2Ik5i7sBSBXDuEN UYVa7GRmVUpY5CLTFm87lhIBloxBCIIaFBcIKIAd++NBUuAyYs7LBSOYYZPA2xKlUNdPtzmQ4PYe 4xBFQftNTqMBMpqsbLnaU3ZIRXDm5XwnwqqzWSNiYTR3LwZNL1x14LjMdChYxmX3xjlE2p+AolS5 rhW+re7tjYGXisuIuJXhUuN7jcfYep2Mj4ANTqDxsmqr0ZQmrGnSGFZn4aDxrL0UpdP4rCtbynvc OUBCAoUBBivcmAQ3OQa6cOJ1/mrLFmq8lBTLQgophjiM9j5X8WQMWlbjx4UOu4YhbjtJxkuqejSU M0iJv2CnPXh00ATIWNLoJv1WYmwDgchNhmwrmVbRnoIGuBCkmURChQQ2H6tJJRSEhw3hriYjXQ4g SNTyoKA4otg2r2YWEDZrRlEazYJFLs4Ta4SYQHVZphQRrvm1VgMnDaQ90xQEZedQGbRtNjXYIIql hjWeVcSFhZG0ex1IE9RlBgb9EGZW9MHzg+gbby2TjdaZlFtnmG6KYjIiKleuo3HNjx5AwvVwyZSO fYiIpUVVzbr2GvU9Au8/OCK3jATF9fA02lZEXRmrCpKhgVd1CzgsKxTvSZiqFYGdMiXLjUzS36LX ryfExcMt63Q25GkqFhoKcg8fi7R7No8FQNR4qBmzMBk5PBIoa4LhNYmKJixh4VkDUTuLQRlhNeW/ qN7A+J1YDVK9JUYgPlN/Elp32pCOuM5E4AkTOnfFW3JdWqTJpLbi+NW0GLyvqySSLY4nmfa+VPFi KWnoymLgOhFuE+lf7D7n/35D7fbk+vo5EgRJCf3S+4/oqftP5//T/ya89SH9X5F6nrsEGwWoazsv +lTJmbKBU2b8g1GXx2ZA1+wfwBhoKUsQZB1B+suV+sOJAfEaIN/HhQWKOg2RmGGBJH+JIvyO7boL LuNhYgy7HYXYxYxt5k9ORb/7l+sTqtXgwbPy/IjJ3dJdwfQHipqOOpBpxGLDW8IDBS4fj9f4fj+K qG7wOUGrDUT8FqeStNm6CBM7e4LAy5pmAMXA4K4PBFxI7TE8KisZzmAz8jSpuLoXWLzOMwkVOrV2 39w117pTQQfEMa1RAd5nEt/puK7Ki+ZQXbVVt2RYBZNh9VEhWNIUVhwnJcLt7Zpf0wrQVjN9mqd5 7DPiu5rIumb+AbPTSs0LZpxCC/ZJ4sfjBifOqg5jPfdOuZQ2N8wPUY5BzEsMCWosTxseP7PH7XzL 7xR53GNlHmTCl6YH12GQXo/UJiwvbRXHz/AKqyvX7nQGkfsnniQ4cwRJzGDY2wbBtttouUy/MGB8 /uxA/DQMU0FQhawCZrE/nANBLMNhZZjY1ohaOn3z9tyoiEyYyVQSJAMsYe/6tYPwP13Gj7PgcxfR mQxRdQnxzHw1JywfJE1kVXogj+38UMbtPybKEOtBEz6zbqVfv1FLORAG37jjXwYZCOEvuwymR4QB /f2v8SCS6z5cS3VJre+btgh6gUEeEhdrQBevXYmg42Ulp/HADziRRXHaSTXmLLTL6TWp7Y8AJbuB oaso2EQtRw4AbSJJL3LLKW9HcwMbBgDkLxyG8yye+yuHC2XyqjK5tpFlzISILi4YZh3p5LrOLlro MCoNvczyPvCmnpvL+0vGYYJ5fKfP1vKnvPokgLzbqfNI/aefznuNsPdrlUTGizVV7l5BMFhJAQKg AfDqE8w78v1R38ThYmWBrDNIAyOaD4cePvUznKkHd33dPVyOJrJ+jP2D5/v5SXBdAyyy/rQdB3na V8jbvmz1RRXMMHFT3ZNMG7J4tuvyiVlZhKCXniJKskIgun44DSCdjvVAS0XMPQ0S12WoK2pbcqLX mGHj8G+5ZyWaqF6WBha9UqGmwY2yMjKcTebmQ2kl9ag5Hnmr7ddCOeSxSw7MEHpNeIzVp3IMhQpJ hopM6V4nRWkLluOBcHgfvZUkczfeZ8tWd5cLM2V0QzurlL4xZTxGYS/efyH2IZBxDIOZhJCaRgAw JaI1iN7rbGeqjauDDVho18aMx00ngpSTFJ/mndy07MVVR2aUVo2gM1cU8lD3Q0uKepmVEXVHTFtR Gs8NMc7Z0s3MuwWTJu8iCGoeN+ENyY2m0xjWIoMbLmt3dnVo6SEVAizeldmzjqZqlWGPFub0g5hv igSF4nsvUaShzmFqFAgW64MQdKU8RF3YTRNoSgMM7yz6+kDYRYmNnZ8PTgcLwMaPgBOZ+QViDhlc 17w4aFelhiCklRYXWvwzwokoUvG7wlTaZtnHZY4DLEFDgKbCpwtIoolacnJwuLpj4NDecAzPbZCa ccdtCQbIliW0AWvmknNGiSQBtRe7xwbQwGJWGwjmlQKy5rCnPELzmghByrCJVgJZ8cmuU15UI0yL 7lCkty1BrwpG0W97NgypufTbvvZbN821BYepqJiW0yW6ZURfB4gbA1NQr1/SUbAMVO0SDn0Z5RMS oXG0Bth66ZNCnOPGFOhymqQiwUh8wnzPT23rU8Sh6uB6Hp76ZbXUKmIQZrAxFBnLCQuT1hu/k+R4 g89fRYvem8aPua3wGrFDhMs5yBuczv7BNBcZCDex4xMw9sTbEShg9bW8e98t67AUwA2+eGGxCFGj 8llfVr3XM/R1+Cz7DvV2Qt7hw4EgEkI9InnGwLN4PSFMCw9ErYJQkHtaL8XBiH45ONDeWIld2QqB tqyzIwCoaflVhCax2JJXV/JQPWri1HmejunkdWbhMQo856Bt3PTtNz86Hup608xnc3eLmNYf7jQH EPED3x04croc8HvJ7raE8mocgGKbolswk0GdK6lY8BDzC/X6txZvVwj36dTtMjK00zviqOHsy5rS 6sLMfrvNtj1Q7PS8HW8YmpZCMIhHq0a/DoTcOhkgSSEYSSMbHeYb7fbpr3Y4g8gPBtpXkd/OyXH6 Vrp6g6XTj4ABYGsszUhll5foVbm85h694WD1+l/B4jzeC64EWH0jAd3qg4XGlVyDNiLZHoPOAGwT NUzbGQcWupXs+dDCqoHY9DELXc2g3t70RuCIVzFxjdzZ+kmJFl4bgKYLIL4xNSCWNJGCBRhc4xg6 T8zpOguoAFKUHX4uTG2frcTIgZvMxagBG3r0Rcrm0BuKkxcRSJNlvcpB0MVBURRVRsr2m2dBv+HQ WoFo+UAovUQj3rPN8eTMO70Oyz2GUAawwdHx0JBLCNtCuCrkbmNbZodjBNI3GkchIYSQFzsWFuV5 ZnBhgzBwajqat7h2iOLfudA7B0jODiOphacQy9YiaFfmrHwnb07AwU7UbhkJuAt5k5jxHRSFDq9p V4XBlSRj+i70ohsbFY62WFTaKljotudkkBIRYztG5tYXNAyBfYIZGwqQr8xnQ6bT6r01SsnSSCKh etcBEBag6CiHUI0WXbCzUgr8T1nYL2K5ZYnawzbZQc7SbKajI0FLnJQ0DaCyiDfq2rsiyB9EXqLO V0PWJda6zkNVfMkoChO15ZGJQD6WAetbCPqM/LrRdd7mh4ZawBAkHNMu1qALKZIEQhECbVd7FEJE HhvAXb7Yc8T/VwiDn5Q1njmHMEHZ4khjYnbHI5iuN4HYZINslVf6qqm2VREFXGm9A9yBHIR7yFqy oG0Zd1jX8/zkolKQVPTVXpG7H1lU0xQcBlQ9RY28zsyXRVgy0oAhrtD4lva7mlkvYg7BUFGnIDJH ztjEIHVAuOODFfsCA8kSWpwsfldwlGS9drQmfSUjbrM1necg+vXa+A3qd0PXK2Nab+iHjaZ3SidG p9I67/koM6mqI0Q12UmMColpBdZSjNE1yFVjKJITAzUQtBUEZiG1AMdsBzZOXeeC9OylmmtL7Zdq /iFdyoFkJYRX46Q8rdqCXNtP6OqUezvo6ySSB2mQ7HtbR2PHorm02q8DVUNpV0ve9jTGKfK3nK+x 9jqEw9ncBoTVwHfsb3PEzeiFzR0QnPMRdIIU4mRhGNNUhJqgpFQ7Zj2FiFNXYeVl5vybiAq476O4 3LlRgRQFTNoaDEIFqzGxQ5kK5u7FQjp97DmOaW1QwsQXATpdAOjXAshYCaxbqQ1h/IwgYRs7x5Uy N7xn8b1qsmarB6zC/XwxlOjzovaxt6KZ0kIUchCzxHrkRkIzuAee8VjY8DogRAiGlBHBQftPnKFx sbl+DIRLi9FchblsQQ9htsRsNjE2b5J7LJiGHs74Qxzotbib1DgIoiaugmbjBUQTQry5zGG9rnez SHHie/MWhLYt3OWs6yCaVYZbohUmLYylnhThNHTmTgamiwN4iPHq+2KsnrhGozFVqFlQvmKga7IX a4S5x/D7/00Jg0DDu4hxtOhFYHJwVJVbYpNobQGWnw3oA0R0pjNTSFkSBFMueGfpr3wxxjmwd4bc 53CZXSMU1JXL2imH1B0NsNZENaPqHJokybQum0bUgCrUzaP6lquVIDmtj1C9/iFOrvOu+tArEOhJ yaLVDKGLEa3sDaca4XIRNAwmyGlHZ7MwAkzjtA7kGkl1PVKCTP1OZsqlt+f2P6DJKkc8184URdp+ kYemrLOjvAD6ocrIXEWIcbrLPr0KD+JG+AMGF9l2dGTFjRwZlKy7MWYQE9mFTyXsCVjjcDfH1vFs ZOsKDZBPdsKyOfpCjvoyo5DZWciEQmNBUuwIp6omEQkP0juKOEDW5WsBXKw4wjQHhQPncnW7MOq2 O6POzkyONJonCUn1xUMAKYWBonEXWIrfxCXeLz2OT3iTZpIlryh/2If/F3JFOFCQavxhcg== --===============4645308769012410347==--