From: Roy Lyseng Date: April 29 2011 2:09pm Subject: bzr commit into mysql-trunk branch (roy.lyseng:3367) Bug#12407753 List-Archive: http://lists.mysql.com/commits/136421 X-Bug: 12407753 Message-Id: <20110429140934.5B62E1F4@tyr67.norway.sun.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============5479251902242864255==" --===============5479251902242864255== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/rl136806/mysql/repo/mysql-work5/ based on revid:tor.didriksen@stripped 3367 Roy Lyseng 2011-04-29 Bug#12407753: Time to compare a row is missing in cost calculation of semi-join Stage 1: Change cost factors to be multiplicative Basically, this patch changes the constant values TIME_FOR_COMPARE and TIME_FOR_COMPARE_ROWID to be the inverse of their previous values and gives them names that are more similar to other cost factors. As a consequence, all cost calculations involving these constants are changed from divisions to multiplications. sql/filesort.cc Replaced cost divisions with multiplications. sql/filesort_utils.cc Replaced cost divisions with multiplications. sql/ha_ndbcluster.cc Replaced cost divisions with multiplications. Removed redundant cast to (double). sql/handler.cc Replaced cost divisions with multiplications. Removed redundant cast to (double). sql/opt_range.cc Replaced cost divisions with multiplications. Removed redundant casts to (double). sql/sql_const.h Replaced definition of TIME_FOR_COMPARE with JOIN_COMPARE_COST. Replaced definition of TIME_FOR_COMPARE_ROWID with ROWID_COMPARE_COST. sql/sql_select.cc Replaced cost divisions with multiplications. Removed redundant casts to (double). sql/uniques.cc Replaced cost divisions with multiplications. modified: sql/filesort.cc sql/filesort_utils.cc sql/ha_ndbcluster.cc sql/handler.cc sql/opt_range.cc sql/sql_const.h sql/sql_select.cc sql/uniques.cc === modified file 'sql/filesort.cc' --- a/sql/filesort.cc 2011-04-04 08:47:25 +0000 +++ b/sql/filesort.cc 2011-04-29 14:09:10 +0000 @@ -1226,7 +1226,7 @@ bool check_if_pq_applicable(Sort_param * row_length); /* PQ has cost: - (insert + qsort) * log(queue size) / TIME_FOR_COMPARE_ROWID + + (insert + qsort) * log(queue size) * ROWID_COMPARE_COST + cost of file lookup afterwards. The lookup cost is a bit pessimistic: we take scan_time and assume that on average we find the row after scanning half of the file. @@ -1235,7 +1235,7 @@ bool check_if_pq_applicable(Sort_param * */ const double pq_cpu_cost= (PQ_slowness * num_rows + param->max_keys_per_buffer) * - log((double) param->max_keys_per_buffer) / TIME_FOR_COMPARE_ROWID; + log((double) param->max_keys_per_buffer) * ROWID_COMPARE_COST; const double pq_io_cost= param->max_rows * table->file->scan_time() / 2.0; const double pq_cost= pq_cpu_cost + pq_io_cost; === modified file 'sql/filesort_utils.cc' --- a/sql/filesort_utils.cc 2010-12-17 09:41:21 +0000 +++ b/sql/filesort_utils.cc 2011-04-29 14:09:10 +0000 @@ -26,8 +26,7 @@ double get_merge_cost(ha_rows num_elemen { return 2.0 * ((double) num_elements * elem_size) / IO_SIZE - + (double) num_elements * log((double) num_buffers) / - (TIME_FOR_COMPARE_ROWID * M_LN2); + + num_elements * log((double) num_buffers) * ROWID_COMPARE_COST / M_LN2; } } @@ -49,8 +48,7 @@ double get_merge_many_buffs_cost_fast(ha // Calculate CPU cost of sorting buffers. total_cost= ( num_buffers * num_keys_per_buffer * log(1.0 + num_keys_per_buffer) + - last_n_elems * log(1.0 + last_n_elems) ) - / TIME_FOR_COMPARE_ROWID; + last_n_elems * log(1.0 + last_n_elems) ) * ROWID_COMPARE_COST; // Simulate behavior of merge_many_buff(). while (num_buffers >= MERGEBUFF2) === modified file 'sql/ha_ndbcluster.cc' --- a/sql/ha_ndbcluster.cc 2011-04-19 03:29:06 +0000 +++ b/sql/ha_ndbcluster.cc 2011-04-29 14:09:10 +0000 @@ -9033,7 +9033,7 @@ ha_ndbcluster::multi_range_read_info_con cost->io_count= index_only_read_time(keyno, total_rows); else cost->io_count= read_time(keyno, n_ranges, total_rows); - cost->cpu_cost= (double) total_rows / TIME_FOR_COMPARE + 0.01; + cost->cpu_cost= total_rows * JOIN_COMPARE_COST + 0.01; } return total_rows; } === modified file 'sql/handler.cc' --- a/sql/handler.cc 2011-04-28 11:55:16 +0000 +++ b/sql/handler.cc 2011-04-29 14:09:10 +0000 @@ -4559,7 +4559,7 @@ handler::multi_range_read_info_const(uin cost->io_count= index_only_read_time(keyno, total_rows); else cost->io_count= read_time(keyno, n_ranges, total_rows); - cost->cpu_cost= (double) total_rows / TIME_FOR_COMPARE + 0.01; + cost->cpu_cost= total_rows * JOIN_COMPARE_COST + 0.01; } return total_rows; } @@ -5305,7 +5305,7 @@ void get_sort_and_sweep_cost(TABLE *tabl { get_sweep_read_cost(table, nrows, FALSE, cost); /* Add cost of qsort call: n * log2(n) * cost(rowid_comparison) */ - double cmp_op= rows2double(nrows) * (1.0 / TIME_FOR_COMPARE_ROWID); + double cmp_op= rows2double(nrows) * ROWID_COMPARE_COST; if (cmp_op < 3) cmp_op= 3; cost->cpu_cost += cmp_op * log2(cmp_op); === modified file 'sql/opt_range.cc' --- a/sql/opt_range.cc 2011-04-23 20:44:45 +0000 +++ b/sql/opt_range.cc 2011-04-29 14:09:10 +0000 @@ -2223,8 +2223,8 @@ int SQL_SELECT::test_quick_select(THD *t records= head->file->stats.records; if (!records) records++; /* purecov: inspected */ - scan_time= (double) records / TIME_FOR_COMPARE + 1; - read_time= (double) head->file->scan_time() + scan_time + 1.1; + scan_time= records * JOIN_COMPARE_COST + 1; + read_time= head->file->scan_time() + scan_time + 1.1; if (head->force_index) scan_time= read_time= DBL_MAX; if (limit < records) @@ -2324,7 +2324,7 @@ int SQL_SELECT::test_quick_select(THD *t double key_read_time= param.table->file->index_only_read_time(key_for_use, rows2double(records)) + - (double) records / TIME_FOR_COMPARE; + records * JOIN_COMPARE_COST; DBUG_PRINT("info", ("'all'+'using index' scan will be using key %d, " "read time %g", key_for_use, key_read_time)); if (key_read_time < read_time) @@ -3877,7 +3877,7 @@ TABLE_READ_PLAN *get_best_disjunct_quick Add one ROWID comparison for each row retrieved on non-CPK scan. (it is done in QUICK_RANGE_SELECT::row_in_ranges) */ - imerge_cost += non_cpk_scan_records / TIME_FOR_COMPARE_ROWID; + imerge_cost += non_cpk_scan_records * ROWID_COMPARE_COST; } /* Calculate cost(rowid_to_row_scan) */ @@ -3966,7 +3966,7 @@ skip_to_ror_scan: cost= param->table->file-> read_time(param->real_keynr[(*cur_child)->key_idx], 1, (*cur_child)->records) + - rows2double((*cur_child)->records) / TIME_FOR_COMPARE; + rows2double((*cur_child)->records) * JOIN_COMPARE_COST; } else cost= read_time; @@ -4013,8 +4013,8 @@ skip_to_ror_scan: get_sweep_read_cost(param->table, roru_total_records, is_interrupted, &sweep_cost); roru_total_cost= roru_index_costs + - rows2double(roru_total_records)*log((double)n_child_scans) / - (TIME_FOR_COMPARE_ROWID * M_LN2) + + rows2double(roru_total_records) * + log((double)n_child_scans) * ROWID_COMPARE_COST / M_LN2 + sweep_cost.total_cost(); } @@ -4469,11 +4469,11 @@ static bool ror_intersect_add(ROR_INTERS { /* CPK scan is used to filter out rows. We apply filtering for - each record of every scan. Assuming 1/TIME_FOR_COMPARE_ROWID + each record of every scan. Assuming ROWID_COMPARE_COST per check this gives us: */ - info->index_scan_costs += rows2double(info->index_records) / - TIME_FOR_COMPARE_ROWID; + info->index_scan_costs += rows2double(info->index_records) * + ROWID_COMPARE_COST; } else { @@ -4856,9 +4856,9 @@ TRP_ROR_INTERSECT *get_best_covering_ror tree->ror_scans, ror_scan_mark);); /* Add priority queue use cost. */ - total_cost += rows2double(records)* - log((double)(ror_scan_mark - tree->ror_scans)) / - (TIME_FOR_COMPARE_ROWID * M_LN2); + total_cost += rows2double(records) * + log((double)(ror_scan_mark - tree->ror_scans)) * + ROWID_COMPARE_COST / M_LN2; DBUG_PRINT("info", ("Covering ROR-intersect full cost: %g", total_cost)); if (total_cost > read_time) @@ -10529,7 +10529,7 @@ void cost_group_min_max(TABLE* table, KE no CPU cost. We leave it here to make this cost comparable to that of index scan as computed in SQL_SELECT::test_quick_select(). */ - cpu_cost= (double) num_groups / TIME_FOR_COMPARE; + cpu_cost= num_groups * JOIN_COMPARE_COST; *read_cost= io_cost + cpu_cost; *records= num_groups; === modified file 'sql/sql_const.h' --- a/sql/sql_const.h 2010-12-17 09:41:21 +0000 +++ b/sql/sql_const.h 2011-04-29 14:09:10 +0000 @@ -158,16 +158,16 @@ /** The following is used to decide if MySQL should use table scanning - instead of reading with keys. The number says how many evaluation of the - WHERE clause is comparable to reading one extra row from a table. + instead of reading with keys. The number says how costly evaluation of the + filter condition for a row is compared to reading one extra row from a table. */ -#define TIME_FOR_COMPARE 5.0 // 5 compares == one read +#define JOIN_COMPARE_COST 0.20 /** - Number of comparisons of table rowids equivalent to reading one row from a - table. + Cost of comparing a rowid compared to reading one row from a table. */ #define TIME_FOR_COMPARE_ROWID (TIME_FOR_COMPARE*2.0) +#define ROWID_COMPARE_COST 0.10 // Half the cost of a general row comparison /* For sequential disk seeks the cost formula is: === modified file 'sql/sql_select.cc' --- a/sql/sql_select.cc 2011-04-28 11:55:16 +0000 +++ b/sql/sql_select.cc 2011-04-29 14:09:10 +0000 @@ -7452,12 +7452,12 @@ best_access_path(JOIN *join, loose_scan_opt.check_ref_access_part2(key, start_key, records, tmp); } /* not ft_key */ - if (tmp < best_time - records/(double) TIME_FOR_COMPARE || + if (tmp < best_time - records * JOIN_COMPARE_COST || (quick_matches_more_parts && quick_records < best_quick_records)) { best_quick_records = quick_records; - best_time= tmp + records/(double) TIME_FOR_COMPARE; + best_time= tmp + records * JOIN_COMPARE_COST; best= tmp; best_records= records; best_key= start_key; @@ -7542,7 +7542,7 @@ best_access_path(JOIN *join, */ tmp= record_count * (s->quick->read_time + - (s->found_records - rnd_records)/(double) TIME_FOR_COMPARE); + (s->found_records - rnd_records) * JOIN_COMPARE_COST); loose_scan_opt.check_range_access(join, idx, s->quick); } @@ -7563,7 +7563,7 @@ best_access_path(JOIN *join, */ tmp= record_count * (tmp + - (s->records - rnd_records)/(double) TIME_FOR_COMPARE); + (s->records - rnd_records) * JOIN_COMPARE_COST); } else { @@ -7582,18 +7582,18 @@ best_access_path(JOIN *join, we read the table (see flush_cached_records for details). Here we take into account cost to read and skip these records. */ - tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE; + tmp+= (s->records - rnd_records) * JOIN_COMPARE_COST; } } /* We estimate the cost of evaluating WHERE clause for found records - as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus + as record_count * rnd_records * JOIN_COMPARE_COST. This cost plus tmp give us total cost of using TABLE SCAN */ if (best == DBL_MAX || - (tmp + record_count/(double) TIME_FOR_COMPARE*rnd_records < - best + record_count/(double) TIME_FOR_COMPARE*records)) + (tmp + (record_count * JOIN_COMPARE_COST * rnd_records) < + best + (record_count * JOIN_COMPARE_COST * records))) { /* If the table has a range (s->quick is set) make_join_select() @@ -7914,7 +7914,7 @@ void Optimize_table_order::optimize_stra /* compute the cost of the new plan extended with 's' */ record_count*= join->positions[idx].records_read; read_time+= join->positions[idx].read_time - + record_count / (double) TIME_FOR_COMPARE; + + record_count * JOIN_COMPARE_COST; advance_sj_state(join_tables, s, idx, &record_count, &read_time, &loose_scan_pos); @@ -8168,7 +8168,7 @@ bool Optimize_table_order::greedy_search /* compute the cost of the new plan extended with 'best_table' */ record_count*= join->positions[idx].records_read; read_time+= join->positions[idx].read_time - + record_count / (double) TIME_FOR_COMPARE; + + record_count * JOIN_COMPARE_COST; remaining_tables&= ~(best_table->table->map); --size_remain; @@ -8214,7 +8214,7 @@ void get_partial_join_cost(JOIN *join, u { record_count *= join->best_positions[i].records_read; read_time += join->best_positions[i].read_time - + record_count / (double) TIME_FOR_COMPARE; + + record_count * JOIN_COMPARE_COST; } } *read_time_arg= read_time; @@ -8393,7 +8393,7 @@ bool Optimize_table_order::best_extensio current_record_count= record_count * position->records_read; current_read_time= read_time + position->read_time - + current_record_count / (double) TIME_FOR_COMPARE; + + current_record_count * JOIN_COMPARE_COST; if (has_sj) { === modified file 'sql/uniques.cc' --- a/sql/uniques.cc 2011-03-09 20:54:55 +0000 +++ b/sql/uniques.cc 2011-04-29 14:09:10 +0000 @@ -122,7 +122,7 @@ inline double log2_n_fact(double x) the same length, so each of total_buf_size elements will be added to a sort heap with (n_buffers-1) elements. This gives the comparison cost: - total_buf_elems* log2(n_buffers) / TIME_FOR_COMPARE_ROWID; + total_buf_elems * log2(n_buffers) * ROWID_COMPARE_COST; */ static double get_merge_buffers_cost(uint *buff_elems, uint elem_size, @@ -137,7 +137,7 @@ static double get_merge_buffers_cost(uin /* Using log2(n)=log(n)/log(2) formula */ return 2*((double)total_buf_elems*elem_size) / IO_SIZE + - total_buf_elems*log((double) n_buffers) / (TIME_FOR_COMPARE_ROWID * M_LN2); + total_buf_elems*log((double) n_buffers) * ROWID_COMPARE_COST / M_LN2; } @@ -267,7 +267,6 @@ double Unique::get_use_cost(uint *buffer ulong max_elements_in_tree; ulong last_tree_elems; int n_full_trees; /* number of trees in unique - 1 */ - double result; max_elements_in_tree= ((ulong) max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size)); @@ -276,10 +275,10 @@ double Unique::get_use_cost(uint *buffer last_tree_elems= nkeys % max_elements_in_tree; /* Calculate cost of creating trees */ - result= 2*log2_n_fact(last_tree_elems + 1.0); + double result= 2 * log2_n_fact(last_tree_elems + 1.0); if (n_full_trees) result+= n_full_trees * log2_n_fact(max_elements_in_tree + 1.0); - result /= TIME_FOR_COMPARE_ROWID; + result*= ROWID_COMPARE_COST; DBUG_PRINT("info",("unique trees sizes: %u=%u*%lu + %lu", nkeys, n_full_trees, n_full_trees?max_elements_in_tree:0, --===============5479251902242864255== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/roy.lyseng@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: roy.lyseng@stripped # target_branch: file:///home/rl136806/mysql/repo/mysql-work5/ # testament_sha1: 48c156edc47e83230aa229ad9cd6205158948e46 # timestamp: 2011-04-29 16:09:34 +0200 # base_revision_id: tor.didriksen@stripped\ # sy51s25lk29u48kg # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWZTxBG8ACH9/gHaUoFBYf/// f3fcgL////RgD07diXbmufayYVa0kpqjbNjI2k1RIUSUSm0mWzS1tgNEmVP1NPRTT0TRo09HqTag PUwTAhphGBqZNNDCSQExE1PCCk9lTR6TTNTaaNT01AbUAAAaaDUwmU0TKaaAHpAZAABkGgAAAAkR CJMMkaDEyNIanpJ7TSaPKT9U9EZNPUPJBoeocaMmRhGIBhNBgE0GgZMmjJkMIDBVJNAJiaCYEZAQ NRqepiGgAAANolIPgiGmHqSiFrR2xUTKk02OEScCCH+YG2m6QcMjAk5O3GcP5fGNOXTk0gdyIaTa P3M7RpzHO6h+aWWJP0tk93ByRHKGPUztJ7X++erQcCLmSEVqaNq1mvweWUyCEpFIjcypZHUzciiq oHWdjk8ypJq8QwAUElqaSXG0CJSS/Xi2yJYsDWGPSe7486P9HOEDTbgGKGMb5MtGRGiSmEaK4XxZ 2hfO4L+8DcBxAMbGxsGwbSbBtIG9BXst8hICrKplakLiMQrK2QmJDMLl1ohCtzhGOLPTAO7TZM8q KAwJTMIQYhKk3MEcIubucSZTCsasLYQTq8XUs03e4dnLiY0MtdGRw8jkpaW7nZ3tDdZ56GuG7Puz 2gCqYIfyQJTgClIHMZLIFTbIbjzyk7pbPsceddGsYg1klnqo/LHu4ufLwgkSme1dYWaoQXIpkoIA LY6ZVKbG34O1pWEzPHeiEdIpO9zpA0wfR0cjMxHD8S2tLAYUhbmma4wU9nrflzBTHBBCSbdrFlRb Ntq7JiwwAB9Jmk0TaDJoSWVaH4A8sQKlVnWJIo6lSI/AHF0xw56eT0eWHnS84FcAI16m6r+OO8Su YEGnWcXIbvcwbQc+M7ctLUI7X5ffS91za4aVzXB1eXNFQtBwkObeRekgvvulB8H9r/gmfc1f9cI4 dJ1AusZ7UkvYGlX6KGzP0WUOzJ4PFJ4o8Xx0emVbVzIWs3pG7WBAeiY40xMlkuLOBzLmdYvBmNuu c+RV73uGonKSZNNJJMFAmTzhD7OMIydZRlVcFBUbPSa2a8eV/dlSRYYqtNh0syMFc0A6TJF1zBEo 2UAyFBq8ZqAYSBBCEoS9xXOD1qgx5XJROhbfJOIRfkkmm96SfQhJuXZPizjavwSRCUzBQLqUNEWS WWLM17ZLn1EgyvcO1cTdSsSEXyVD4ILb1zBERL1YOAYEmJHA1wOiKEto9EO2WJzbi4MNt6HDd+o5 RnhrtrZq7r9LUNDMvh9jFARwEWHwAl8Ol5dyK2RQyNEOsyLNC7QZzxggPNDYTlIbweDo2k7Fw5bp GbY0ZxhcnSNKpuZtoocqmNJGyEnQImb/bW9Fsijws368KDTizh86W9Gcqz1CjJAOjLYqUaV/Rkma 3GuidlSSlnGCSokr1q1KJMkzHQWoXWkr1o1yZCuS1G5TmIcId8w6UBL0sOsOd10Q3xuta9VbTDQm k54tvsc1zaOClfrdhJz4QbfQhEykWQPJbR0CEoKBtcQ4kbqkDfUpYZL3c5+xxv2rnYqUtya7TWwZ pT1SVNS1Nm1uapkmKWt81ThloXMkh2vtdB6PXVmx9hjiXNtRjmY6WjcXZZwKKZuW4q4gJK8uugQG vIbScLznm9AuOJIqcSQrieOIYhFnbIs0XwUHReydFtPGxKdy5bioSZ2ux2QoppalGhsaMpXQYKGD Niq1qpJsMnYNZDq71ui3GWuWrVJRqvom5zouhdF8nzIJeVDZh48yclArrkBY2ECKEPjFiiT5pxWr XYCtodZ3tqwxYValwqXSVNzBXuZN6512uqphDg1PvYKly2hjOVNGlOhOtbpMBSYV1QUpjMlTPxnS ZzfYqWGcpvkpniIoxvpno0rpmlusQvFihSlkyb/dY160PHikxXhowePLBCkZGPJpsx1q7IJzEhpG aCkFxfZ6aVHkMca1FK1m7EbNlcTKkkVtLJ5K4zkzksgta6E1k5ppKK91yG5pXKlK7zYqXV+D3uW8 z9jlqjXp4Vzas57Z1KKLoLJClYcbvJKHJ285G3fAvnEqY8DeQPG1DUzxISNDXDEnjIjrdcXFhlod djLjkWOY0mbl1dOcsj0bzbp6NFo0umgmYpIGOyKqVLaQynFJDwuXt7wW3X4MHYlarSYMFM+yplso UrigVp+G3FKKM1UFehgywwsXLuKXAsHA8AxmamxEaO2Yovc5RbJs9JOlOEIIJyeIcXxcguSLr3eB 7VS+PBy1MQpGiTUeSB/Dh+HNMxHocSmK4bbQzla+wCElDZs94G47GIsXvWxehCP2SQY4tGVppNtj /Dr+ghBU/yg+ayUQPuJKir8IHA+8hMhSStJxEFB95Mh95D7oiD5kogXwNERB84iC8yI/2xf8ZmBo WMJAcf0SAolKA4j5/km00NNpjY2mKDlSQZwZ4Hns3uHIa35qexJ2e+0Q5mOoCEvFpEyev3h3fCiO KzzZICvwoU0ednQC4AuZoM7FkbiTI6zzWEekYDq5dhA7jQ2QfXJJ9bfJvZvs5JafzLGZgxVL7H76 lq9vgv57gAwTydCr0bTGJ9I87S/lZIzGeKR7fu7+MO9T8KDwlIpQ+IshwMPOQRObfv8TUwckh/sx +qxcmI4SslTlKqCbZZS6KSGlu4OGpzTVO144u4dX53NawcWCt53+bFHJc1f5n/jv/c5Bi0dyf1o3 uTel1oQmhHCmOUYzuNxsNp27tRj1oICEFjUIjHz5Ozo3wb+hDm2Nb2Ka78tLko5KqJA3rgtpADCE rwZUQoIQvkQoaB/sfof1OK4Gwfxs6bWedqFEt91CLqPMeSTw7ervd/sY0KV2KGCyahchJR1eCvov gZxE0Z2fTMwWlBNPBof2di2xh4MHQfCCuK7B6KDrPsh/eDe2jPmQNoI8Dq0hjJ3+yT14GQ12zVit AIr2xala9dr6thxNBwzQsoMBHUcJPWWUljnKF++5el76cW1N3uDTFYkMPdjBRfLMURDwm+NfDdKU WNrsfT8NebQtQi0tgxlzKVjg3k4dXt9s9jB2OC3GXC58hjaxPodNHXh3WXyw9aHgfQixwnxfYThM Y7KEQ3IcYzoQsgp6X9O+eiUok7PCj37sL+pC6MptGJbGZDtw0AWwT0lu7AcgtJKAn5G4qaS/kx9w xlVzI4u1Pq+l36vNYK1CtY8lXlVFrt3KnfuWv7vheuXQjXsg0HQeL/o8/aMh/X4e9RRKU9h3Mx7Y pj4X9U49FNQz74PBwphDB4urjTA5KMtKRScsbo2Aa+s34bwJ8PUYMBzKjHOR6xBs2bToJmT8rGVH x48JOxngWLTFvmbOAJFQOEmDgqm7ZaGvGCn17cL+UDiKL/lODt5fHQPi1+TZAeWgok4SPqk2+fF3 xD0Wuf1XY6b9jOVqzRL3dctDBGRIbAYGTvIQbQ6rcrdkg0YdIjG8mq7fUO9jB16vc8HdT0v7/Zc9 rXgth4J2eusbvO59MKk4hYyQv1fKByNMQpoKVJIkWwV+zDvzb2DcvWt8hKIiUm0FASYoWExUPMgi 7ciN+WPM8cPL8//SGYLx8sIMiz4h9e+29CJXI0kro3H1FjnBFsq7d1FHrohEnpObSlnA9xw00030 PJTRf2atQqZ+QqvUm0o7K4YQahXD5XoMhXPcxiyNBcm0W4frWvMnCKoLQrkjLiwYXBJdUIIVoTaT QiUtNgoX+k+oDxMoGFkFRkF3QOSdVKCLxG4ZQe5IvDyEEX7p7ohKhmQybx59U74OkHu6Ux2og0ZR ES99E7jk9APuYU+453dvbkZ6ARPaADkigha9clAyQa3PUxL1MB6Xi05dYBWSV2uAnUZCmbj5npCq GRDvWrKcEo9KBJChRKDdT5jHF1gugtzbPHQKcJ6C+N72mwfY1wR1YDxa2OrUHq8gR2GNT1WiGgkB roHySdLSETX37AjlqBzDEEp6EaBqzT90Qd5SAhk2GGUhBuaE23l9U4PzPJqX9RdGn8TyVkJx1Qvh 3j1ZTVubTRvdoKJXN67Ok6UDAbu7lnomYZAzdA3IaWU6J1ayVqantThV+PYa9UHTVXG+uZpZOJpR RZpl01qUqvL7eIbGZch5oaN52F2ju2m5PqcGbwHhIp+AuRDPtlIcpVjVZhviCikb2kb5L1C123AD eBvbbbbbegDDrApRtuhW/i6Z3gGkZQGoJG5WAU40h1KmimRFyU6mWGSDREt9PPeqVU1JSSTPe9sd r5XVRfleJvAo9gPVg2HE/C4UVM0BFaQswcdhUAhuEOSqx2BdOtZloOiNy+LYhogl8cfPKXrRELRT EODXH2/S2dmpxVXLGBGGjy7zm8UVNQF5sT9xzawD2d32Ho8vTMZHiF9fZ6Dka8DBBwVAQz8cQ83m 8hBKLVMXVUGBDtMhg52Pq29EnOkrJz3tEyJjm+SvmtRa7WhPQhsqTjolDuaWttpdzj12OjRWmQ9V Ke7WlKiEJcofie/yNzS36+TPS/xlCHTt8FSu1xXUpQTmoetMmTc3u5VY/Dp/8XckU4UJCU8QRvA= --===============5479251902242864255==--