From: Jon Olav Hauglid Date: August 23 2010 2:49pm Subject: bzr commit into mysql-5.5-bugfixing branch (jon.hauglid:3193) Bug#54332 List-Archive: http://lists.mysql.com/commits/116532 X-Bug: 54332 Message-Id: <201008231449.o7NEnbVn008421@acsinet15.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============7144923728174038089==" --===============7144923728174038089== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///export/home/x/mysql-5.5-bugfixing-bug54332/ based on revid:chris.powers@stripped 3193 Jon Olav Hauglid 2010-08-23 Bug #54332 Deadlock with two connections doing LOCK TABLE+INSERT DELAYED The problem was that deadlocks involving INSERT DELAYED were not detected. The reason for this is that two threads are involved in INSERT DELAYED: the connection thread and the handler thread. The connection thread would wait while the handler thread acquired locks and opened the table. In essence, this adds an edge to the wait-for-graph between the connection thread and the handler thread that the deadlock detector is unaware of. Therefore many deadlocks involving INSERT DELAYED were not detected. This patch fixes the problem by having the connection thread acquire the metadata lock the table before starting the handler thread. This allows the deadlock detector to detect any possible deadlocks resulting from trying to acquire a metadata lock the table. If a metadata lock is successfully acquired, the handler thread is started and given a copy of the ticket representing the metadata lock. When the handler thread then tries to lock and open the table, it will find that it already has the metadata lock and therefore not acquire any new metadata locks. Test cases added to delayed.test. modified: mysql-test/r/delayed.result mysql-test/t/delayed.test sql/sql_insert.cc === modified file 'mysql-test/r/delayed.result' --- a/mysql-test/r/delayed.result 2009-12-11 09:39:38 +0000 +++ b/mysql-test/r/delayed.result 2010-08-23 14:49:15 +0000 @@ -345,3 +345,78 @@ CREATE TABLE t1 LIKE t2; ERROR 42S01: Table 't1' already exists DROP TABLE t2; DROP TABLE t1; +# +# Bug#54332 Deadlock with two connections doing LOCK TABLE+INSERT DELAYED +# +DROP TABLE IF EXISTS t1, t2; +CREATE TABLE t1 (a INT); +CREATE TABLE t2 (a INT); +CREATE TABLE t3 (a INT); +# Test 1: Using LOCK TABLE +# Connection con1 +LOCK TABLE t1 WRITE; +# Connection default +LOCK TABLE t2 WRITE; +# Sending: +INSERT DELAYED INTO t1 VALUES (1); +# Connection con1 +# Wait until INSERT DELAYED is blocked on table 't1'. +INSERT DELAYED INTO t2 VALUES (1); +ERROR 40001: Deadlock found when trying to get lock; try restarting transaction +UNLOCK TABLES; +# Connection default +# Reaping: INSERT DELAYED INTO t1 VALUES (1) +UNLOCK TABLES; +# Test 2: Using ALTER TABLE +START TRANSACTION; +SELECT * FROM t1 WHERE a=0; +a +# Connection con1 +# Sending: +ALTER TABLE t1 COMMENT 'test'; +# Connection default +# Wait until ALTER TABLE is blocked on table 't1'. +INSERT DELAYED INTO t1 VALUES (3); +ERROR 40001: Deadlock found when trying to get lock; try restarting transaction +COMMIT; +# Connection con1 +# Reaping: ALTER TABLE t1 COMMENT 'test' +# Test 3: Using RENAME TABLE +# Connection default +START TRANSACTION; +INSERT INTO t2 VALUES (1); +# Connection con1 +# Sending: +RENAME TABLE t1 to t5, t2 to t4; +# Connection default +# Wait until RENAME TABLE is blocked on table 't1'. +INSERT DELAYED INTO t1 VALUES (4); +ERROR 40001: Deadlock found when trying to get lock; try restarting transaction +COMMIT; +# Connection con1 +# Reaping: RENAME TABLE t1 to t5, t2 to t4 +# Connection default +# Reverting the renames +RENAME TABLE t5 to t1, t4 to t2; +# Test 4: Two INSERT DELAYED on the same table +START TRANSACTION; +INSERT INTO t2 VALUES (1); +# Connection con2 +LOCK TABLE t1 WRITE, t2 WRITE; +# Connection con1 +# Wait until LOCK TABLE is blocked on table 't2'. +INSERT DELAYED INTO t1 VALUES (5); +# Connection default +# Wait until INSERT DELAYED is blocked on table 't1'. +INSERT DELAYED INTO t1 VALUES (6); +ERROR 40001: Deadlock found when trying to get lock; try restarting transaction +COMMIT; +# Connection con2 +# Reaping: LOCK TABLE t1 WRITE, t2 WRITE +UNLOCK TABLES; +# Connection con1 +# Reaping: INSERT DELAYED INTO t1 VALUES (5) +# Connection con2 +# Connection con1 +# Connection default +DROP TABLE t1, t2, t3; === modified file 'mysql-test/t/delayed.test' --- a/mysql-test/t/delayed.test 2010-08-06 11:29:37 +0000 +++ b/mysql-test/t/delayed.test 2010-08-23 14:49:15 +0000 @@ -388,3 +388,162 @@ CREATE TABLE t1 LIKE t2; DROP TABLE t2; DROP TABLE t1; + + +--echo # +--echo # Bug#54332 Deadlock with two connections doing LOCK TABLE+INSERT DELAYED +--echo # + +--disable_warnings +DROP TABLE IF EXISTS t1, t2; +--enable_warnings + +CREATE TABLE t1 (a INT); +CREATE TABLE t2 (a INT); +CREATE TABLE t3 (a INT); + +--echo # Test 1: Using LOCK TABLE + +--echo # Connection con1 +connect (con1, localhost, root); +LOCK TABLE t1 WRITE; + +--echo # Connection default +connection default; +LOCK TABLE t2 WRITE; +--echo # Sending: +--send INSERT DELAYED INTO t1 VALUES (1) + +--echo # Connection con1 +connection con1; +--echo # Wait until INSERT DELAYED is blocked on table 't1'. +let $wait_condition= + SELECT COUNT(*) = 1 FROM information_schema.processlist + WHERE state = "Waiting for table metadata lock" + AND info = "INSERT DELAYED INTO t1 VALUES (1)"; +--source include/wait_condition.inc +--error ER_LOCK_DEADLOCK +INSERT DELAYED INTO t2 VALUES (1); +UNLOCK TABLES; + +--echo # Connection default +connection default; +--echo # Reaping: INSERT DELAYED INTO t1 VALUES (1) +--reap +UNLOCK TABLES; + +--echo # Test 2: Using ALTER TABLE + +START TRANSACTION; +SELECT * FROM t1 WHERE a=0; + +--echo # Connection con1 +connection con1; +--echo # Sending: +--send ALTER TABLE t1 COMMENT 'test' + +--echo # Connection default +connection default; +--echo # Wait until ALTER TABLE is blocked on table 't1'. +let $wait_condition= + SELECT COUNT(*) = 1 FROM information_schema.processlist + WHERE state = "Waiting for table metadata lock" + AND info = "ALTER TABLE t1 COMMENT 'test'"; +--source include/wait_condition.inc +--error ER_LOCK_DEADLOCK +INSERT DELAYED INTO t1 VALUES (3); +COMMIT; + +--echo # Connection con1 +connection con1; +--echo # Reaping: ALTER TABLE t1 COMMENT 'test' +--reap + +--echo # Test 3: Using RENAME TABLE + +--echo # Connection default +connection default; +START TRANSACTION; +INSERT INTO t2 VALUES (1); + +--echo # Connection con1 +connection con1; +--echo # Sending: +--send RENAME TABLE t1 to t5, t2 to t4 + +--echo # Connection default +connection default; +--echo # Wait until RENAME TABLE is blocked on table 't1'. +let $wait_condition= + SELECT COUNT(*) = 1 FROM information_schema.processlist + WHERE state = "Waiting for table metadata lock" + AND info = "RENAME TABLE t1 to t5, t2 to t4"; +--source include/wait_condition.inc +--error ER_LOCK_DEADLOCK +INSERT DELAYED INTO t1 VALUES (4); +COMMIT; + +--echo # Connection con1 +connection con1; +--echo # Reaping: RENAME TABLE t1 to t5, t2 to t4 +--reap + +--echo # Connection default +connection default; +--echo # Reverting the renames +RENAME TABLE t5 to t1, t4 to t2; + +--echo # Test 4: Two INSERT DELAYED on the same table + +START TRANSACTION; +INSERT INTO t2 VALUES (1); + +--echo # Connection con2 +connect (con2, localhost, root); +--send LOCK TABLE t1 WRITE, t2 WRITE + +--echo # Connection con1 +connection con1; +--echo # Wait until LOCK TABLE is blocked on table 't2'. +let $wait_condition= + SELECT COUNT(*) = 1 FROM information_schema.processlist + WHERE state = "Waiting for table metadata lock" + AND info = "LOCK TABLE t1 WRITE, t2 WRITE"; +--source include/wait_condition.inc +--send INSERT DELAYED INTO t1 VALUES (5) + +--echo # Connection default +connection default; +--echo # Wait until INSERT DELAYED is blocked on table 't1'. +let $wait_condition= + SELECT COUNT(*) = 1 FROM information_schema.processlist + WHERE state = "Waiting for table metadata lock" + AND info = "INSERT DELAYED INTO t1 VALUES (5)"; +--source include/wait_condition.inc +--error ER_LOCK_DEADLOCK +INSERT DELAYED INTO t1 VALUES (6); +COMMIT; + +--echo # Connection con2 +connection con2; +--echo # Reaping: LOCK TABLE t1 WRITE, t2 WRITE +--reap +UNLOCK TABLES; + +--echo # Connection con1 +connection con1; +--echo # Reaping: INSERT DELAYED INTO t1 VALUES (5) +--reap + +--echo # Connection con2 +connection con2; +disconnect con2; +--source include/wait_until_disconnected.inc +--echo # Connection con1 +connection con1; +disconnect con1; +--source include/wait_until_disconnected.inc + +--echo # Connection default +connection default; +DROP TABLE t1, t2, t3; === modified file 'sql/sql_insert.cc' --- a/sql/sql_insert.cc 2010-08-20 08:24:32 +0000 +++ b/sql/sql_insert.cc 2010-08-23 14:49:15 +0000 @@ -548,10 +548,34 @@ bool open_and_lock_for_insert_delayed(TH DBUG_RETURN(TRUE); } - if (delayed_get_table(thd, table_list)) + /* + In order for the deadlock detector to be able to find any deadlocks + caused by the handler thread locking this table, we take the metadata + lock inside the connection thread. If this goes ok, the ticket is cloned + and added to the list of granted locks held by the handler thread. + */ + MDL_ticket *mdl_savepoint= thd->mdl_context.mdl_savepoint(); + if (thd->mdl_context.acquire_lock(&table_list->mdl_request, + thd->variables.lock_wait_timeout)) + /* + If a lock can't be acquired, it makes no sense to try normal insert. + Therefore we just abort the statement. + */ DBUG_RETURN(TRUE); - if (table_list->table) + /* + If a lock was acquired above, we should release it after delayed_get_table() + has cloned the ticket for the handler thread. Note that acquire_lock() can + succeed because of a lock already held by the connection. In this case we + should not release it here. + */ + MDL_ticket *table_ticket = mdl_savepoint == thd->mdl_context.mdl_savepoint() ? + NULL: thd->mdl_context.mdl_savepoint(); + + bool error= FALSE; + if (delayed_get_table(thd, table_list)) + error= TRUE; + else if (table_list->table) { /* Open tables used for sub-selects or in stored functions, will also @@ -560,16 +584,25 @@ bool open_and_lock_for_insert_delayed(TH if (open_and_lock_tables(thd, table_list->next_global, TRUE, 0)) { end_delayed_insert(thd); - DBUG_RETURN(TRUE); + error= TRUE; + } + else + { + /* + First table was not processed by open_and_lock_tables(), + we need to set updatability flag "by hand". + */ + if (!table_list->derived && !table_list->view) + table_list->updatable= 1; // usual table } - /* - First table was not processed by open_and_lock_tables(), - we need to set updatability flag "by hand". - */ - if (!table_list->derived && !table_list->view) - table_list->updatable= 1; // usual table - DBUG_RETURN(FALSE); } + + if (table_ticket) + thd->mdl_context.release_lock(table_ticket); + table_list->mdl_request.ticket= NULL; + + if (error || table_list->table) + DBUG_RETURN(error); #endif /* * This is embedded library and we don't have auxiliary @@ -2025,6 +2058,20 @@ bool delayed_get_table(THD *thd, TABLE_L /* Replace volatile strings with local copies */ di->table_list.alias= di->table_list.table_name= di->thd.query(); di->table_list.db= di->thd.db; + + /* + Clone the ticket representing the lock on the target table for + the insert and add it to the list of granted metadata locks held by + the handler thread. This is safe since the handler thread is + not holding nor waiting on any metadata locks. + */ + if (di->thd.mdl_context.clone_ticket(&table_list->mdl_request)) + { + delete di; + my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR)); + goto end_create; + } + di->lock(); mysql_mutex_lock(&di->mutex); if ((error= mysql_thread_create(key_thread_delayed_insert, @@ -2036,6 +2083,7 @@ bool delayed_get_table(THD *thd, TABLE_L error)); mysql_mutex_unlock(&di->mutex); di->unlock(); + di->thd.mdl_context.release_lock(table_list->mdl_request.ticket); delete di; my_error(ER_CANT_CREATE_THREAD, MYF(ME_FATALERROR), error); goto end_create; --===============7144923728174038089== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/jon.hauglid@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: jon.hauglid@stripped # target_branch: file:///export/home/x/mysql-5.5-bugfixing-bug54332/ # testament_sha1: a0422a32ae590e04a6931b701a8c9f147e5e07c9 # timestamp: 2010-08-23 16:49:19 +0200 # source_branch: file:///export/home/x/mysql-5.5-runtime/ # base_revision_id: chris.powers@stripped\ # kz9nw6264sxpm6q4 # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWZ+mC4MACENfgFQQff////// 3+C////+YBDq+6fTr68pJ3O7vc6FPp7Vw+75oA+rtm2nbdvQ77ervcbtqnyxr3Cusve0674SSEE0 yanpo0p4m0EFPao3qJ+0UajNJ6nqepkGQMaT1AlJPUCHknqaaTaRoAGgAAGgAAGgAEkCEI1NJmqe NSNkTTaQ0yDTagAAABoAJNSSamkP0UZPU0DE9QPUAA09ENAAAAAEUSJkxA0TCEaTJ4hNPU9R6gGQ aGTTQAxMgkSEAmQZBNBDFPKeU9JlMnog9QAyDTQA0ggRy/9l0rRPNtgjC5x/DNhhL3RRsRsv7/OG fcxp11dRTMTTwQnpgwd94o0K9bOZlmp3W36MfbcwLAUNLX65blclkiI4lKIv9s8pMX/PtRQXI+SI p2GI9XRjgsbLZyOWdlW0HX2kcObZ3uRIeF7vYHe0ipAwYoC++2+X4ilUMloD3wWmlwUujm02wjL4 97MMw0A+587PbA6tnzjJh4UctWM+6utCvwYDLgPlmKkVmNXa7H2lj4/RRvyr8uy5FuoppTTv1oEV bIECLBCGMNjSk9fMJ3+JBIsTLlE8yfv5xTE2G8tKykOQzExrvXrXFMGmLp+9HPnZVfuRjX7J0iVj 52Fkqi3qlsqKDPsBl0hO+mE65RFmnBG9HYi8fE/wVdhwR3FKMqHAIYSUApW0O0skRuPDpJ7wzFAY Sk6fMXmAawZ4qhWW2kluPHXXfQsLLDMFahi8stqqr3DS2EqFSVCwlCDAykwLwMA1QMw4JtNCvRAQ JtlBFMu8OeA+ett+Ue2cQzSzed3iIcdsTPQ82/ihHFP8sHVnWGM0CdgGbJGa9FzYU9AKuppwqwrb LcIpRGuc9tGmmNLMFLQxw2FVyQyTdpqmyohLqR/JEZYRYVY7iwbGWdVd7y3cp052uJlDIKCh2YeO DEDIn+93iUvnyPCiz5EvNUI1Nr2bl3ZrFZGbXdxiAmg4iKGQyHrQ4hL7gDcQJe0qIJirRA0pDIGQ mMgaK83iIeGKHF7NPwgxE56x7+x1ypv0Z+TTZBGdnmLajWwOXMcr3d34+fGUk1WeUOwyGZmC1wmL tEBnPjPEdSO6idcGA009sOqA6VcF6JacLpGMJaUBKRp0ndZBH27/NH6q5jgcLuF5eEGp1Kbuz1jR j15C+EdKiwGAxiAgKIiIsYqqooiqZRhpeMcQOYZ2C1t4gCOXTEdsHvRQSOj6vvkIbrY3d8l2bxvl 7qFXY/rRcmLnZPO0m6t2lRSxaPS4cJCIi1N4EcZkj5fmIDVUS16eDZ54iRFSHhAYySq0ADJzl4No BcOnRA9BExgJ3Y3nUHmVSs5dXep5W4ynVaJ8cLVcel9h4ULvolEt/mhyhESxZczj6ayxFWliSgFW NF0FFC+pEEkmeKO71nb2kBbvvXemlnlUgGz1twDwB0HKBSSkQOOMDd0HCIG5E+mlyrwXkyfU63aA YERImXoheh7CX01U55XiMZ69oDDKBEpHAaqhEIYkHikUgXXegMGVSs/j1HT3VGnHiqVZ7K1gGrCL fdxd8FC8oYzWeuXAw3okVCJfo2dBsEW6wsr7svy6d9KFYQb6zkglrUslQkc7uB0chcW+xnoKs8uB e7UoBFmH1CWpklg5dru2u3jhJSYWoWkyFyrh8lnTFhZ3cecqK0tOMxbjNtuCoGc/+S29Bw/A28ry sqOsg6tCeo0QmqKzlJcB5FENGBFZUgKcYQnHLVqSrhtKYScfLUoHGPUjcL7zr8oszLcNbNKMwkuB rCtGO/ncTLeBcGExHDOMzh1cMZ7SssyES1l0ngVBt6ims7ONh+OzMgsriKiDEoUTtTQWIZE4jlxk mZjOVEdccDxj/BaMkWSy8oLANaEJOy2MUkQhVqR/1Y1SkeXbrx1tMwqtR5AWsOe7LEGYZVvtY1KS +ERYtdh5KDK9Ft9mThsxFgf51rY1R1L67LTBpWFELCzEF6/oE73EbGI4Yx1YixJGoW+1DkHRbLTL i00hwtEFiElkVBBbpfbOlstjl/Q3iMZsjZxD7NgjTO0mRgtSk57YtgbYSXNR+td4XwMYBgNhcgse fbNOHRaG2qN/QzUuJwi8Ia7UGBVdvMZ9nY2JHjsh8akSzem/chy92ch3jzPtoq7Vyc1ppxNKtsWi F1rRQuQ3gaoayYsToD7g2XIZJVb5mH8HkFKmI10JO2ElPWt/SwBDvl+xhTTwBHcO4J8dq4bPWKcF Kk8g2DZaPMK6zKwEH8gj0lfZcXfgKylgwkDWtg+moCFoQwgwPGf4LiSXh6jGFpMnDQVS4JISAgwK DCQi09ksjsoSGkKx1ZF9wrUK2LWpaliHrW8LcggXh48BT1Vjc1l3sM1NMLxcVx7VqfUw8mlJZlJQ gIBcR9xmHOL6N+QsmeTWK6zjFfGKkLySOo4wtXTekvKO0LQAyG1ayimpOEDUpViSOZTImAwPAQKJ RJBcbDiFNQrmuXFSwZQlOOqzAC9CMo30Wwa1xxbXeLYdpdYZkuVDUODKXgwKSQuwdWBWlBAqoOoq GpNC5QElSoagRy6hoyMKZULByClQs2VlxjIC9sfBkMwVwkby4oLMWQ60hdiReaRXb/AUwC2NntPB 8An2Lzwemaqn32thQnKQeH8IRUiYHjwLAkpQRpzFmSbTaBnmjzbyE4HEp7OJVR3H38TAeo7fxiwI REyEWTO7IHsI/y8itW+PRCZU0gFwtAkQ2lWUq5aZR6xPOq0O3mfZ8RG4+G7BXmaLapvCPgxdfwaR MUtT0eaJsR0S2cEGHxkQJ3MdZqY3fJD7ACytFHMXZGCeWgLVeMuJEeJ4F3eGkgftac01jzbrHwK/ IinagWIFfzIKKQc2s7hV2QmheZG/bBmNZp3F459OsmZHhsMQ2+zUu9eFZ3lvclmTnX9mENE/VVlo jOgnBsXCFSuACAYElXPpLVlAyUEPDCsQ9InAvCBCkQtFi1Cb0JCBQHMZi2dyYQq8oqiquVaosXtS 5IXFNkkREJhDg9gvJQTEyQ0r8LCT2lZ0ki/rIL0zG1vTOVWKEXxt0C9Bh4Smc6cxzlTfyLabTQwV DALZWMw47bZvnAlZYs8j6wssFflM48RsxgHVJIxErlsjPsrESNDV5dcGnYECPWiXYSmk5YHSK6Un tBeFDFIiFLSlHfiNBglsTrjL2NlYT+3CUosgK/SJMEWpexniW94eH2+e8nsxusZ8xPD5Vot/dSFF FYJoNhcRow8ZgG/NfqSYSA+kRUEHHn3IEXGTGNCAafRVLLEspShzEVmFjoUD2pVv18O++7n0Pu9W VhiAuRkbnd5m1vV5QWAcGwJ6sd5Wm3bbTwQkcLjgOX7Rruqr5oZLmU6BIVQgURs0iIMyVpJgkqxz Bp6TH8dmqkqFh5YFxNHv06B6FfLFi+tBvFoNMZSoCxF6PEGPVCIoJQsFbft6SYTqZxK84VXcmTbB Obn1eWwcXfVGPEKXp4CvCR0/9XkuoXJ3m4UIO7AIPfNEBqHBEuqwohbGkA9w61zgDRFmYUwO6I3s ha8b7qqnjXz5OBu7mLGcjWBlB54rT5QZkXngUghXdRsTsnrCbQ0O7DMzeSyBFeE0N9kBSg7gKOAx 1RrNKsyWlYK+roSgFXKqmHymIXhZQF0LzYvLP5hFFkWnFLKErD1CzkImZDPFMtFkybCv3IgOugus RqLjenej0+Tsyor0gDJibQwYHah9dRuIEiICGI43QmseABUnOpfAuU4LhSCN0l7q5cxyKLjoGr/Q 6wZOs5q5TnElmY+AwbmM2I3RALHqFHo0Hz7fBWiL8LjcsggRWKfGfuhlbSxlDb5awOWGAv4K2sDE IaFZZhgSoDLATOpEsTmhPJHAzQWzwIslIKCuS6pSWEsCEjwYCUqhhg/LO7LjQdZgo7CucitvezSm ds2wDxXiaCJTRl2tgdnw0abROF935hGaLLoO6K1zYm1Hbtx8D3W2hrrJ2H00/93FlwVDxZCS2mlI WEWmFQtRykACyRyxLcg1ALX1JUKKYsuBolqSXkKkE2IEBk63EUSLRiQn8xrORWgQVCyZ0elVFgF9 4iCIZKLmBolUJA+RkStOzd27kElN5SGEMYEJjfmNhAwAsaNKd51pOOGxs7ghrD3WSIvflGV7oMDW KECwJmD4ZHoEEBIiAMAujJo4ExxtmoNegEzWlmbUWoclQVwBZjWxqKxxPPHTt35C4Ni8mF7s5E48 iHhOPvMmQ3SUG4N2EjyryGqNuXqrOZzcpUjS1r79Z8VvvOGhpvzAd8fWe8t2h0oKZIkPewISGEmv bJQAujEMFuSn1lsVtxEnKDJAczxRyxoFSkchlqBmIbiAmny84CuvYOLNmKlkg3VGmoCvleXT9Qi5 C1u9hc2xhBahjRp4VRURZ3OumcFOqeQYqWeGCG4PKkaVqaLPtzkHqa+bNiNjRUF/QYnO6K2WzfNF 1hysRXOqZUy9fPTbL8dvYTITUmfWhsY4YYSbk3FVrdKooeKawcthqQwM3BxgCYySBi2DBi0FVpKY eNNp4LjRsANLo74x2qAfmep1OK/6Wcq2Lu8MEUSQnm9OwiWMqFGSbdDmB1QyRbmuZT4XTCc2IQag GITGAug9LgMLccBEK24TpNUEt7TIRRxHA/x/w9cGbjDrgS3xKOdmBTkwoYsL6YDs1G0K+ju9W9Id xYugZ8RoaJjDzRvITqgYheI0JHuy04KYMxb3ZApeoxRrc6NizBASEXJLdcEQgy7xsZokwJZKWbag nt7y16MFoSJZ2+QPxes0o0Q0Gl2FR2i0kAzMAQbrBxiN43PVqSY9eo8k7rzv5fG/MrouV5cOTIth ZW4nOGJkNZhY46fEnuTZJTPQlOaD34NjCHYfcVA/IRY92ARTWPHWKsSgXGiWUn2Q1M0B90HvByYk hoAVBQxS6kMpMF8Q3B1d2QXuX6pgU/xdyRThQkJ+mC4M --===============7144923728174038089==--