Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1tfYwL-003L9T-LS for pgsql-hackers@arkaria.postgresql.org; Wed, 05 Feb 2025 06:31:14 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1tfYwK-00C9d7-Ny for pgsql-hackers@arkaria.postgresql.org; Wed, 05 Feb 2025 06:31:12 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1tfYwK-00C9cU-2A for pgsql-hackers@lists.postgresql.org; Wed, 05 Feb 2025 06:31:12 +0000 Received: from oss.nttdata.com ([49.212.34.109]) by makus.postgresql.org with esmtps (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1tfYwF-003GMe-2y for pgsql-hackers@postgresql.org; Wed, 05 Feb 2025 06:31:11 +0000 Received: from oss.nttdata.com (localhost [127.0.0.1]) by oss.nttdata.com (Postfix) with ESMTPA id B097961271 for ; Wed, 5 Feb 2025 15:31:04 +0900 (JST) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.11 at oss.nttdata.com MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=_09ebd24f94ff269eb6963e917454b32f" Content-Transfer-Encoding: 8bit Date: Wed, 05 Feb 2025 15:31:04 +0900 From: Masahiro Ikeda To: pgsql-hackers@postgresql.org Subject: Recheck if ANALYZE is needed after VACUUM finishes by autovacuum User-Agent: Roundcube Webmail/1.4.11 Message-ID: <580ab0777864e3a09951824ffed1ad21@oss.nttdata.com> X-Sender: ikedamsh@oss.nttdata.com List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --=_09ebd24f94ff269eb6963e917454b32f Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8; format=flowed Hi, I would like to propose adding logic to recheck whether an ANALYZE is necessary at the end of VACUUM. I believe this could be a viable idea to mitigate a problem encountered by my customer. The customer’s issue occurred as follows: 1. Every 5 minutes, a large amount of data (2 million records) was updated via DELETE/COPY operations. 2. Autovacuum executed VACUUM/ANALYZE, and the VACUUM process took 2 hours to complete. 3. Before the next autovacuum run (autovacuum_naptime=1min), no further DELETE/COPY operations occurred, leaving mod_since_analyze=0. 4. Autovacuum then ran VACUUM without ANALYZE, taking another 2 hours to complete. 5. At the end of this VACUUM, pg_class.reltuples was updated to a very small value (150), far lower than the actual row count (2 million). 6. The execution plan changed, resulting in a significant degradation in query performance (500ms → 1000s). The bitmap index scan node was estimated to return 30 rows but actually returned 50 million rows. 7. Query performance remained degraded until the next autovacuum run, which finally executed ANALYZE. However, since the next VACUUM would also take 2 hours, performance degradation persisted during that period. As you may already be thinking, there are ways to address or mitigate this issue depending on the application requirements and hardware configuration. For example, using TRUNCATE or adjusting parameters like cost_delay to speed up VACUUM can prevent table bloat and avoid significant query performance degradation. However, certain system requirements may make these solutions impractical. Even in such cases, if there is a way to mitigate the problem, it would be worth adopting. Therefore, I decided to propose $SUBJECT. VACUUM updates pg_class.reltuples based on the state of tuples it observes during processing. However, it cannot observe tuples stored in pages that have already been vacuumed, which causes an issue. For example, in cases like this, there is a possibility that pg_class.reltuples may be updated to a value significantly smaller than the actual row count. To address such situations, I am considering introducing a mechanism to recheck whether an ANALYZE is necessary, particularly when a VACUUM process takes a long time. This would ensure that ANALYZE is executed promptly in such cases. What do you think about this approach? This approach cannot completely prevent the issue. At the very least, between the completion of VACUUM and the subsequent execution of ANALYZE, pg_class.reltuples will contain highly inaccurate values. However, it can significantly reduce the time during which the problem occurs, thereby mitigating the impact of incorrect statistics. As a potential complete solution, we could consider skipping the update of statistics by VACUUM when an immediate ANALYZE is expected. However, I see this as a next step after adding the logic to recheck the necessity of ANALYZE. Attached are two files: * reproduce_small_reltuples.tar.gz: Steps to reproduce the issue where reltuples is updated to a small value at the end of VACUUM. * v1-0001-Add-logic-to-recheck-if-ANALYZE-is-needed-after-V.patch: A patch implementing the proposed logic to recheck the necessity of ANALYZE after VACUUM. Concerns about the v1 patch: There may be other issues or better ideas, but here are my current concerns: * The number of accesses to pg_class increases, which could lead to performance issues, although I haven’t conducted performance tests. * When checking the necessity of ANALYZE, should the latest parameter values be referenced? The current implementation uses the parameter values at the time of VACUUM execution, except for pg_class.reltuples. I welcome your feedback. I’m open to alternative ideas and not stick to this particular approach. Regards, -- Masahiro Ikeda NTT DATA CORPORATION --=_09ebd24f94ff269eb6963e917454b32f Content-Transfer-Encoding: base64 Content-Type: text/x-diff; name=v1-0001-Add-logic-to-recheck-if-ANALYZE-is-needed-after-V.patch Content-Disposition: attachment; filename=v1-0001-Add-logic-to-recheck-if-ANALYZE-is-needed-after-V.patch; size=16279 RnJvbSAzMTlmNGMzMDRmNWU5ZWNiMDkzM2M2MzY5NmZiMzYyMDU0NDIyNzZiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXNhaGlybyBJa2VkYSA8aWtlZGFtc2hAb3NzLm50dGRhdGEu Y29tPgpEYXRlOiBGcmksIDE3IEphbiAyMDI1IDE3OjQ2OjE5ICswOTAwClN1YmplY3Q6IFtQQVRD SCB2MV0gQWRkIGxvZ2ljIHRvIHJlY2hlY2sgaWYgQU5BTFlaRSBpcyBuZWVkZWQgYWZ0ZXIgVkFD VVVNCiBmaW5pc2hlcyBieSBhdXRvdmFjdXVtCgpJbiBjYXNlcyB3aGVyZSBWQUNVVU0gcnVucyBm b3IgYSBsb25nIHRpbWUgYW5kIGZyZXF1ZW50IGRhdGEgdXBkYXRlcwpvY2N1ciwgdGhlIHJlcG9y dGVkIHBnX2NsYXNzLnJlbHR1cGxlcyB2YWx1ZSBieSBWQUNVVU0gbWF5IGJlY29tZQpleHRyZW1l bHkgc21hbGwsIHBvdGVudGlhbGx5IGxlYWRpbmcgdG8gcXVlcnkgcGVyZm9ybWFuY2UgZGVncmFk YXRpb24uCgpUaGlzIHVwZGF0ZSBpbnRyb2R1Y2VzIGEgbWVjaGFuaXNtIHRvIGRldGVjdCBpZiBz dGF0aXN0aWNhbCBpbmZvcm1hdGlvbgpoYXMgYmVlbiB1cGRhdGVkIGR1cmluZyBhIHByb2xvbmdl ZCBWQUNVVU0gcHJvY2VzcywgYWxsb3dpbmcgQU5BTFlaRSB0bwpiZSBleGVjdXRlZCBpbW1lZGlh dGVseSB0byBtaXRpZ2F0ZSB0aGUgaXNzdWUuCgpOb3RlIHRoYXQgcXVlcnkgcGVyZm9ybWFuY2Ug ZGVncmFkYXRpb24gbWF5IHN0aWxsIG9jY3VyIGZvciBhIHNob3J0CnBlcmlvZCBiZWZvcmUgQU5B TFlaRSBpcyBleGVjdXRlZC4gVG8gZnVsbHkgcHJldmVudCB0aGlzLCBmdXJ0aGVyCmNoYW5nZXMs IHN1Y2ggYXMgc2tpcHBpbmcgdGhlIHVwZGF0ZSBvZiBwZ19jbGFzcy5yZWx0dXBsZXMgYnkgVkFD VVVNLAp3b3VsZCBiZSBuZWNlc3NhcnkuCi0tLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRv dmFjdXVtLmMgICAgICAgICAgIHwgMjEzICsrKysrKysrKysrKysrKystLQogLi4uL3Rlc3RfbWlz Yy90LzAwOF9yZWNoZWNrX2F1dG9hbmFseXplLnBsICAgIHwgIDkxICsrKysrKysrCiAyIGZpbGVz IGNoYW5nZWQsIDI4OSBpbnNlcnRpb25zKCspLCAxNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfbWlzYy90LzAwOF9yZWNoZWNrX2F1dG9hbmFs eXplLnBsCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMg Yi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCAwYWI5MjFhMTY5Yi4u NDg2YzM1NGNlYTMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1 bS5jCisrKyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0yMDEsNiAr MjAxLDggQEAgdHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogCVZhY3V1bVBhcmFtcyBhdF9w YXJhbXM7CiAJZG91YmxlCQlhdF9zdG9yYWdlX3BhcmFtX3ZhY19jb3N0X2RlbGF5OwogCWludAkJ CWF0X3N0b3JhZ2VfcGFyYW1fdmFjX2Nvc3RfbGltaXQ7CisJZmxvYXQ0CQlhbmxfc2NhbGVfZmFj dG9yOworCWludAkJCWFubF9iYXNlX3RocmVzaDsKIAlib29sCQlhdF9kb2JhbGFuY2U7CiAJYm9v bAkJYXRfc2hhcmVkcmVsOwogCWNoYXIJICAgKmF0X3JlbG5hbWU7CkBAIC0zMzQsMTIgKzMzNiwx OCBAQCBzdGF0aWMgYXV0b3ZhY190YWJsZSAqdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxp ZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogc3RhdGljIHZvaWQgcmVjaGVja19yZWxhdGlvbl9u ZWVkc192YWNhbmFseXplKE9pZCByZWxpZCwgQXV0b1ZhY09wdHMgKmF2b3B0cywKIAkJCQkJCQkJ CQkJICBGb3JtX3BnX2NsYXNzIGNsYXNzRm9ybSwKIAkJCQkJCQkJCQkJICBpbnQgZWZmZWN0aXZl X211bHRpeGFjdF9mcmVlemVfbWF4X2FnZSwKLQkJCQkJCQkJCQkJICBib29sICpkb3ZhY3V1bSwg Ym9vbCAqZG9hbmFseXplLCBib29sICp3cmFwYXJvdW5kKTsKKwkJCQkJCQkJCQkJICBib29sICpk b3ZhY3V1bSwgYm9vbCAqZG9hbmFseXplLCBib29sICp3cmFwYXJvdW5kLAorCQkJCQkJCQkJCQkg IGZsb2F0NCAqYW5sX3NjYWxlX2ZhY3RvciwgaW50ICphbmxfYmFzZV90aHJlc2gpOworc3RhdGlj IHZvaWQgcmVjaGVja19yZWxhdGlvbl9uZWVkc19hbmFseXplKFR1cGxlRGVzYyBwZ19jbGFzc19k ZXNjLCBhdXRvdmFjX3RhYmxlICp0YWIpOworCiBzdGF0aWMgdm9pZCByZWxhdGlvbl9uZWVkc192 YWNhbmFseXplKE9pZCByZWxpZCwgQXV0b1ZhY09wdHMgKnJlbG9wdHMsCiAJCQkJCQkJCQkgIEZv cm1fcGdfY2xhc3MgY2xhc3NGb3JtLAogCQkJCQkJCQkJICBQZ1N0YXRfU3RhdFRhYkVudHJ5ICp0 YWJlbnRyeSwKIAkJCQkJCQkJCSAgaW50IGVmZmVjdGl2ZV9tdWx0aXhhY3RfZnJlZXplX21heF9h Z2UsCi0JCQkJCQkJCQkgIGJvb2wgKmRvdmFjdXVtLCBib29sICpkb2FuYWx5emUsIGJvb2wgKndy YXBhcm91bmQpOworCQkJCQkJCQkJICBib29sICpkb3ZhY3V1bSwgYm9vbCAqZG9hbmFseXplLCBi b29sICp3cmFwYXJvdW5kLAorCQkJCQkJCQkJICBmbG9hdDQgKmFubF9zY2FsZV9mYWN0b3IsIGlu dCAqYW5sX2Jhc2VfdGhyZXNoKTsKK3N0YXRpYyB2b2lkIHJlbGF0aW9uX25lZWRzX2FuYWx5emUo YXV0b3ZhY190YWJsZSAqdGFiLCBGb3JtX3BnX2NsYXNzIGNsYXNzRm9ybSwKKwkJCQkJCQkJICAg UGdTdGF0X1N0YXRUYWJFbnRyeSAqdGFiZW50cnksIGJvb2wgKmRvYW5hbHl6ZSk7CiAKIHN0YXRp YyB2b2lkIGF1dG92YWN1dW1fZG9fdmFjX2FuYWx5emUoYXV0b3ZhY190YWJsZSAqdGFiLAogCQkJ CQkJCQkJICBCdWZmZXJBY2Nlc3NTdHJhdGVneSBic3RyYXRlZ3kpOwpAQCAtMTk5Nyw2ICsyMDA1 LDggQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQlib29sCQlkb3ZhY3V1bTsKIAkJYm9vbAkJZG9h bmFseXplOwogCQlib29sCQl3cmFwYXJvdW5kOworCQlmbG9hdDQgYW5sX3NjYWxlX2ZhY3RvcjsK KwkJaW50IGFubF9iYXNlX3RocmVzaDsKIAogCQlpZiAoY2xhc3NGb3JtLT5yZWxraW5kICE9IFJF TEtJTkRfUkVMQVRJT04gJiYKIAkJCWNsYXNzRm9ybS0+cmVsa2luZCAhPSBSRUxLSU5EX01BVFZJ RVcpCkBAIC0yMDM3LDcgKzIwNDcsOCBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCS8qIENoZWNr IGlmIGl0IG5lZWRzIHZhY3V1bSBvciBhbmFseXplICovCiAJCXJlbGF0aW9uX25lZWRzX3ZhY2Fu YWx5emUocmVsaWQsIHJlbG9wdHMsIGNsYXNzRm9ybSwgdGFiZW50cnksCiAJCQkJCQkJCSAgZWZm ZWN0aXZlX211bHRpeGFjdF9mcmVlemVfbWF4X2FnZSwKLQkJCQkJCQkJICAmZG92YWN1dW0sICZk b2FuYWx5emUsICZ3cmFwYXJvdW5kKTsKKwkJCQkJCQkJICAmZG92YWN1dW0sICZkb2FuYWx5emUs ICZ3cmFwYXJvdW5kLAorCQkJCQkJCQkgICZhbmxfc2NhbGVfZmFjdG9yLCAmYW5sX2Jhc2VfdGhy ZXNoKTsKIAogCQkvKiBSZWxhdGlvbnMgdGhhdCBuZWVkIHdvcmsgYXJlIGFkZGVkIHRvIHRhYmxl X29pZHMgKi8KIAkJaWYgKGRvdmFjdXVtIHx8IGRvYW5hbHl6ZSkKQEAgLTIwOTAsNiArMjEwMSw4 IEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJYm9vbAkJZG92YWN1dW07CiAJCWJvb2wJCWRvYW5h bHl6ZTsKIAkJYm9vbAkJd3JhcGFyb3VuZDsKKwkJZmxvYXQ0CQlhbmxfc2NhbGVfZmFjdG9yOwor CQlpbnQJCQlhbmxfYmFzZV90aHJlc2g7CiAKIAkJLyoKIAkJICogV2UgY2Fubm90IHNhZmVseSBw cm9jZXNzIG90aGVyIGJhY2tlbmRzJyB0ZW1wIHRhYmxlcywgc28gc2tpcCAnZW0uCkBAIC0yMTIw LDcgKzIxMzMsOCBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAKIAkJcmVsYXRpb25fbmVlZHNfdmFj YW5hbHl6ZShyZWxpZCwgcmVsb3B0cywgY2xhc3NGb3JtLCB0YWJlbnRyeSwKIAkJCQkJCQkJICBl ZmZlY3RpdmVfbXVsdGl4YWN0X2ZyZWV6ZV9tYXhfYWdlLAotCQkJCQkJCQkgICZkb3ZhY3V1bSwg JmRvYW5hbHl6ZSwgJndyYXBhcm91bmQpOworCQkJCQkJCQkgICZkb3ZhY3V1bSwgJmRvYW5hbHl6 ZSwgJndyYXBhcm91bmQsCisJCQkJCQkJCSAgJmFubF9zY2FsZV9mYWN0b3IsICZhbmxfYmFzZV90 aHJlc2gpOwogCiAJCS8qIGlnbm9yZSBhbmFseXplIGZvciB0b2FzdCB0YWJsZXMgKi8KIAkJaWYg KGRvdmFjdXVtKQpAQCAtMjQ3MCw2ICsyNDg0LDgwIEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAog CQlkaWRfdmFjdXVtID0gdHJ1ZTsKIAorCQkvKgorCQkgKiBJZiBvbmx5IFZBQ1VVTSB3YXMgZXhl Y3V0ZWQsIHJlY2hlY2sgd2hldGhlciB0aGUgcGdzdGF0IGRhdGEKKwkJICogaW5kaWNhdGVzIHRo YXQgQU5BTFlaRSBpcyBuZWVkZWQgZm9yIHRoaXMgdGFibGUuCisJCSAqCisJCSAqIElmIFZBQ1VV TSBydW5zIGZvciBhIGxvbmcgdGltZSBhbmQgZnJlcXVlbnQgZGF0YSB1cGRhdGVzIG9jY3VyLAor CQkgKiB0aGUgcmVwb3J0ZWQgcGdfY2xhc3MucmVsdHVwbGVzIHZhbHVlIG1heSBiZWNvbWUgZXh0 cmVtZWx5IHNtYWxsLAorCQkgKiBwb3RlbnRpYWxseSBsZWFkaW5nIHRvIHF1ZXJ5IHBlcmZvcm1h bmNlIGRlZ3JhZGF0aW9uLiBBbHRob3VnaAorCQkgKiB0aGUgbmV4dCBBTkFMWVpFIHdpbGwgY29y cmVjdCB0aGlzLCB0aGUgbmV4dCBWQUNVVU0gbWlnaHQgcnVuCisJCSAqIGZvciBhIGxvbmcgdGlt ZSBhZ2FpbiwgYW5kIHRoZSBkZWdyYWRhdGlvbiBjb3VsZCBwZXJzaXN0IGZvciBhbgorCQkgKiBl eHRlbmRlZCBwZXJpb2QuIFRoaXMgYWxsb3dzIEFOQUxZWkUgdG8gYmUgZXhlY3V0ZWQgaW1tZWRp YXRlbHkuCisJCSAqLworCQlpZiAoKHRhYi0+YXRfcGFyYW1zLm9wdGlvbnMgJiBWQUNPUFRfVkFD VVVNKSAmJgorCQkJISh0YWItPmF0X3BhcmFtcy5vcHRpb25zICYgVkFDT1BUX0FOQUxZWkUpKQor CQl7CisjaWZkZWYgVVNFX0lOSkVDVElPTl9QT0lOVFMKKwkJCWNoYXIgKnJlbF9uc3BuYW1lID0g Z2V0X25hbWVzcGFjZV9uYW1lKGdldF9yZWxfbmFtZXNwYWNlKHJlbGlkKSk7CisJCQlpZiAoc3Ry Y21wKHJlbF9uc3BuYW1lLCAicGdfY2F0YWxvZyIpICE9IDAgJiYKKwkJCQlzdHJjbXAocmVsX25z cG5hbWUsICJpbmZvcm1hdGlvbl9zY2hlbWEiKSAhPSAwICYmCisJCQkJc3RyY21wKHJlbF9uc3Bu YW1lLCAicGdfdG9hc3QiKSAhPSAwKQorCQkJCUlOSkVDVElPTl9QT0lOVCgiYmVmb3JlLXJlY2hl Y2stYXV0b2FuYWx5emUiKTsKKyNlbmRpZgorCQkJLyogc3RhcnQgdHJhbnNhY3Rpb24gdG8gZmV0 Y2ggbGF0ZXN0IHJlbGF0aW9uJ3MgcmVsY2FjaGUgZW50cnkgKi8KKwkJCUNvbW1pdFRyYW5zYWN0 aW9uQ29tbWFuZCgpOworCQkJU3RhcnRUcmFuc2FjdGlvbkNvbW1hbmQoKTsKKworCQkJcmVjaGVj a19yZWxhdGlvbl9uZWVkc19hbmFseXplKHBnX2NsYXNzX2Rlc2MsIHRhYik7CisKKwkJCWlmICh0 YWItPmF0X3BhcmFtcy5vcHRpb25zICYgVkFDT1BUX0FOQUxZWkUpCisJCQl7CisJCQkJLyoKKwkJ CQkgKiBXZSB3aWxsIGFib3J0IHZhY3V1bWluZyB0aGUgY3VycmVudCB0YWJsZSBpZiBzb21ldGhp bmcgZXJyb3JzIG91dCwKKwkJCQkgKiBhbmQgY29udGludWUgd2l0aCB0aGUgbmV4dCBvbmUgaW4g c2NoZWR1bGU7IGluIHBhcnRpY3VsYXIsIHRoaXMKKwkJCQkgKiBoYXBwZW5zIGlmIHdlIGFyZSBp bnRlcnJ1cHRlZCB3aXRoIFNJR0lOVC4KKwkJCQkgKi8KKwkJCQlQR19UUlkoKTsKKwkJCQl7CisJ CQkJCS8qIFVzZSBQb3J0YWxDb250ZXh0IGZvciBhbnkgcGVyLXRhYmxlIGFsbG9jYXRpb25zICov CisJCQkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhQb3J0YWxDb250ZXh0KTsKKworCQkJCQkvKiBo YXZlIGF0IGl0ICovCisJCQkJCWF1dG92YWN1dW1fZG9fdmFjX2FuYWx5emUodGFiLCBic3RyYXRl Z3kpOworCisJCQkJCS8qCisJCQkJCSAqIENsZWFyIGEgcG9zc2libGUgcXVlcnktY2FuY2VsIHNp Z25hbCwgdG8gYXZvaWQgYSBsYXRlIHJlYWN0aW9uCisJCQkJCSAqIHRvIGFuIGF1dG9tYXRpY2Fs bHktc2VudCBzaWduYWwgYmVjYXVzZSBvZiB2YWN1dW1pbmcgdGhlCisJCQkJCSAqIGN1cnJlbnQg dGFibGUgKHdlJ3JlIGRvbmUgd2l0aCBpdCwgc28gaXQgd291bGQgbWFrZSBubyBzZW5zZSB0bwor CQkJCQkgKiBjYW5jZWwgYXQgdGhpcyBwb2ludC4pCisJCQkJCSAqLworCQkJCQlRdWVyeUNhbmNl bFBlbmRpbmcgPSBmYWxzZTsKKwkJCQl9CisJCQkJUEdfQ0FUQ0goKTsKKwkJCQl7CisJCQkJCS8q CisJCQkJCSAqIEFib3J0IHRoZSB0cmFuc2FjdGlvbiwgc3RhcnQgYSBuZXcgb25lLCBhbmQgcHJv Y2VlZCB3aXRoIHRoZQorCQkJCQkgKiBuZXh0IHRhYmxlIGluIG91ciBsaXN0LgorCQkJCQkgKi8K KwkJCQkJSE9MRF9JTlRFUlJVUFRTKCk7CisJCQkJCWVycmNvbnRleHQoImF1dG9tYXRpYyBhbmFs eXplIG9mIHRhYmxlIFwiJXMuJXMuJXNcIiIsCisJCQkJCQkJICAgdGFiLT5hdF9kYXRuYW1lLCB0 YWItPmF0X25zcG5hbWUsIHRhYi0+YXRfcmVsbmFtZSk7CisJCQkJCUVtaXRFcnJvclJlcG9ydCgp OworCisJCQkJCS8qIHRoaXMgcmVzZXRzIFByb2NHbG9iYWwtPnN0YXR1c0ZsYWdzW2ldIHRvbyAq LworCQkJCQlBYm9ydE91dE9mQW55VHJhbnNhY3Rpb24oKTsKKwkJCQkJRmx1c2hFcnJvclN0YXRl KCk7CisJCQkJCU1lbW9yeUNvbnRleHRSZXNldChQb3J0YWxDb250ZXh0KTsKKworCQkJCQkvKiBy ZXN0YXJ0IG91ciB0cmFuc2FjdGlvbiBmb3IgdGhlIGZvbGxvd2luZyBvcGVyYXRpb25zICovCisJ CQkJCVN0YXJ0VHJhbnNhY3Rpb25Db21tYW5kKCk7CisJCQkJCVJFU1VNRV9JTlRFUlJVUFRTKCk7 CisJCQkJfQorCQkJCVBHX0VORF9UUlkoKTsKKwkJCX0KKwkJfQorCiAJCS8qIFByb2NHbG9iYWwt PnN0YXR1c0ZsYWdzW2ldIGFyZSByZXNldCBhdCB0aGUgbmV4dCBlbmQgb2YgeGFjdCAqLwogCiAJ CS8qIGJlIHRpZHkgKi8KQEAgLTI3MDYsNiArMjc5NCw0OSBAQCBleHRyYWN0X2F1dG92YWNfb3B0 cyhIZWFwVHVwbGUgdHVwLCBUdXBsZURlc2MgcGdfY2xhc3NfZGVzYykKIAlyZXR1cm4gYXY7CiB9 CiAKKy8qCisgKiB0YWJsZV9yZWNoZWNrX2F1dG9hbmFseXplCisgKgorICogUmVjaGVjayB3aGV0 aGVyIGEgdGFibGUgbmVlZHMgYW5hbHl6ZSBhZnRlciB2YWN1dW0gY29tcGxldGVzLAorICogYW5k IHVwZGF0ZSB0YWItPmF0X3BhcmFtcy5vcHRpb25zLgorICovCitzdGF0aWMgdm9pZAorcmVjaGVj a19yZWxhdGlvbl9uZWVkc19hbmFseXplKFR1cGxlRGVzYyBwZ19jbGFzc19kZXNjLCBhdXRvdmFj X3RhYmxlICp0YWIpCit7CisJSGVhcFR1cGxlCWNsYXNzVHVwOworCUZvcm1fcGdfY2xhc3MJY2xh c3NGb3JtOworCVBnU3RhdF9TdGF0VGFiRW50cnkJKnRhYmVudHJ5OworCWJvb2wgZG9hbmFseXpl ID0gZmFsc2U7CisKKwkvKiBBTkFMWVpFIHJlZnVzZXMgdG8gd29yayB3aXRoIHBnX3N0YXRpc3Rp YyAqLworCWlmICh0YWItPmF0X3JlbGlkID09IFN0YXRpc3RpY1JlbGF0aW9uSWQpCisJCXJldHVy bjsKKworCS8qIGZldGNoIHRoZSByZWxhdGlvbidzIHJlbGNhY2hlIGVudHJ5ICovCisJY2xhc3NU dXAgPSBTZWFyY2hTeXNDYWNoZUNvcHkxKFJFTE9JRCwgT2JqZWN0SWRHZXREYXR1bSh0YWItPmF0 X3JlbGlkKSk7CisJaWYgKCFIZWFwVHVwbGVJc1ZhbGlkKGNsYXNzVHVwKSkKKwkJcmV0dXJuOwor CWNsYXNzRm9ybSA9IChGb3JtX3BnX2NsYXNzKSBHRVRTVFJVQ1QoY2xhc3NUdXApOworCisJLyog aWdub3JlIEFOQUxZWkUgZm9yIHRvYXN0IHRhYmxlcyAqLworCWlmIChjbGFzc0Zvcm0tPnJlbGtp bmQgPT0gUkVMS0lORF9UT0FTVFZBTFVFKQorCXsKKwkJaGVhcF9mcmVldHVwbGUoY2xhc3NUdXAp OworCQlyZXR1cm47CisJfQorCisJLyogZmV0Y2ggdGhlIHBnc3RhdCB0YWJsZSBlbnRyeSAqLwor CXRhYmVudHJ5ID0gcGdzdGF0X2ZldGNoX3N0YXRfdGFiZW50cnlfZXh0KGNsYXNzRm9ybS0+cmVs aXNzaGFyZWQsCisJCQkJCQkJCQkJCSAgdGFiLT5hdF9yZWxpZCk7CisKKwlyZWxhdGlvbl9uZWVk c19hbmFseXplKHRhYiwgY2xhc3NGb3JtLCB0YWJlbnRyeSwgJmRvYW5hbHl6ZSk7CisKKwkvKiB1 cGRhdGUgb3B0aW9ucyAqLworCWlmIChkb2FuYWx5emUpCisJCXRhYi0+YXRfcGFyYW1zLm9wdGlv bnMgPSBWQUNPUFRfQU5BTFlaRTsKKworCWhlYXBfZnJlZXR1cGxlKGNsYXNzVHVwKTsKK30KIAog LyoKICAqIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYwpAQCAtMjcyNyw2ICsyODU4LDggQEAgdGFibGVf cmVjaGVja19hdXRvdmFjKE9pZCByZWxpZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCWF1dG92 YWNfdGFibGUgKnRhYiA9IE5VTEw7CiAJYm9vbAkJd3JhcGFyb3VuZDsKIAlBdXRvVmFjT3B0cyAq YXZvcHRzOworCWZsb2F0NCBhbmxfc2NhbGVfZmFjdG9yOworCWludCBhbmxfYmFzZV90aHJlc2g7 CiAKIAkvKiBmZXRjaCB0aGUgcmVsYXRpb24ncyByZWxjYWNoZSBlbnRyeSAqLwogCWNsYXNzVHVw ID0gU2VhcmNoU3lzQ2FjaGVDb3B5MShSRUxPSUQsIE9iamVjdElkR2V0RGF0dW0ocmVsaWQpKTsK QEAgLTI3NTIsNyArMjg4NSw4IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhU QUIgKnRhYmxlX3RvYXN0X21hcCwKIAogCXJlY2hlY2tfcmVsYXRpb25fbmVlZHNfdmFjYW5hbHl6 ZShyZWxpZCwgYXZvcHRzLCBjbGFzc0Zvcm0sCiAJCQkJCQkJCQkgIGVmZmVjdGl2ZV9tdWx0aXhh Y3RfZnJlZXplX21heF9hZ2UsCi0JCQkJCQkJCQkgICZkb3ZhY3V1bSwgJmRvYW5hbHl6ZSwgJndy YXBhcm91bmQpOworCQkJCQkJCQkJICAmZG92YWN1dW0sICZkb2FuYWx5emUsICZ3cmFwYXJvdW5k LAorCQkJCQkJCQkJICAmYW5sX3NjYWxlX2ZhY3RvciwgJmFubF9iYXNlX3RocmVzaCk7CiAKIAkv KiBPSywgaXQgbmVlZHMgc29tZXRoaW5nIGRvbmUgKi8KIAlpZiAoZG9hbmFseXplIHx8IGRvdmFj dXVtKQpAQCAtMjgzMCw2ICsyOTY0LDggQEAgdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxp ZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQkJYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdCA6 IDA7CiAJCXRhYi0+YXRfc3RvcmFnZV9wYXJhbV92YWNfY29zdF9kZWxheSA9IGF2b3B0cyA/CiAJ CQlhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5IDogLTE7CisJCXRhYi0+YW5sX3NjYWxlX2ZhY3Rv ciA9IGFubF9zY2FsZV9mYWN0b3I7CisJCXRhYi0+YW5sX2Jhc2VfdGhyZXNoID0gYW5sX2Jhc2Vf dGhyZXNoOwogCQl0YWItPmF0X3JlbG5hbWUgPSBOVUxMOwogCQl0YWItPmF0X25zcG5hbWUgPSBO VUxMOwogCQl0YWItPmF0X2RhdG5hbWUgPSBOVUxMOwpAQCAtMjg2Miw3ICsyOTk4LDkgQEAgcmVj aGVja19yZWxhdGlvbl9uZWVkc192YWNhbmFseXplKE9pZCByZWxpZCwKIAkJCQkJCQkJICBpbnQg ZWZmZWN0aXZlX211bHRpeGFjdF9mcmVlemVfbWF4X2FnZSwKIAkJCQkJCQkJICBib29sICpkb3Zh Y3V1bSwKIAkJCQkJCQkJICBib29sICpkb2FuYWx5emUsCi0JCQkJCQkJCSAgYm9vbCAqd3JhcGFy b3VuZCkKKwkJCQkJCQkJICBib29sICp3cmFwYXJvdW5kLAorCQkJCQkJCQkgIGZsb2F0NCAqYW5s X3NjYWxlX2ZhY3RvciwKKwkJCQkJCQkJICBpbnQgKmFubF9iYXNlX3RocmVzaCkKIHsKIAlQZ1N0 YXRfU3RhdFRhYkVudHJ5ICp0YWJlbnRyeTsKIApAQCAtMjg3Miw3ICszMDEwLDggQEAgcmVjaGVj a19yZWxhdGlvbl9uZWVkc192YWNhbmFseXplKE9pZCByZWxpZCwKIAogCXJlbGF0aW9uX25lZWRz X3ZhY2FuYWx5emUocmVsaWQsIGF2b3B0cywgY2xhc3NGb3JtLCB0YWJlbnRyeSwKIAkJCQkJCQkg IGVmZmVjdGl2ZV9tdWx0aXhhY3RfZnJlZXplX21heF9hZ2UsCi0JCQkJCQkJICBkb3ZhY3V1bSwg ZG9hbmFseXplLCB3cmFwYXJvdW5kKTsKKwkJCQkJCQkgIGRvdmFjdXVtLCBkb2FuYWx5emUsIHdy YXBhcm91bmQsCisJCQkJCQkJICBhbmxfc2NhbGVfZmFjdG9yLCBhbmxfYmFzZV90aHJlc2gpOwog CiAJLyogaWdub3JlIEFOQUxZWkUgZm9yIHRvYXN0IHRhYmxlcyAqLwogCWlmIChjbGFzc0Zvcm0t PnJlbGtpbmQgPT0gUkVMS0lORF9UT0FTVFZBTFVFKQpAQCAtMjkyNSw3ICszMDY0LDkgQEAgcmVs YXRpb25fbmVlZHNfdmFjYW5hbHl6ZShPaWQgcmVsaWQsCiAgLyogb3V0cHV0IHBhcmFtcyBiZWxv dyAqLwogCQkJCQkJICBib29sICpkb3ZhY3V1bSwKIAkJCQkJCSAgYm9vbCAqZG9hbmFseXplLAot CQkJCQkJICBib29sICp3cmFwYXJvdW5kKQorCQkJCQkJICBib29sICp3cmFwYXJvdW5kLAorCQkJ CQkJICBmbG9hdDQgKmFubF9zY2FsZV9mYWN0b3IsCisJCQkJCQkgIGludCAqYW5sX2Jhc2VfdGhy ZXNoKQogewogCWJvb2wJCWZvcmNlX3ZhY3V1bTsKIAlib29sCQlhdl9lbmFibGVkOwpAQCAtMjkz MywxMSArMzA3NCw5IEBAIHJlbGF0aW9uX25lZWRzX3ZhY2FuYWx5emUoT2lkIHJlbGlkLAogCiAJ LyogY29uc3RhbnRzIGZyb20gcmVsb3B0aW9ucyBvciBHVUMgdmFyaWFibGVzICovCiAJaW50CQkJ dmFjX2Jhc2VfdGhyZXNoLAotCQkJCXZhY19pbnNfYmFzZV90aHJlc2gsCi0JCQkJYW5sX2Jhc2Vf dGhyZXNoOworCQkJCXZhY19pbnNfYmFzZV90aHJlc2g7CiAJZmxvYXQ0CQl2YWNfc2NhbGVfZmFj dG9yLAotCQkJCXZhY19pbnNfc2NhbGVfZmFjdG9yLAotCQkJCWFubF9zY2FsZV9mYWN0b3I7CisJ CQkJdmFjX2luc19zY2FsZV9mYWN0b3I7CiAKIAkvKiB0aHJlc2hvbGRzIGNhbGN1bGF0ZWQgZnJv bSBhYm92ZSBjb25zdGFudHMgKi8KIAlmbG9hdDQJCXZhY3RocmVzaCwKQEAgLTI5ODMsMTEgKzMx MjIsMTEgQEAgcmVsYXRpb25fbmVlZHNfdmFjYW5hbHl6ZShPaWQgcmVsaWQsCiAJCT8gcmVsb3B0 cy0+dmFjdXVtX2luc190aHJlc2hvbGQKIAkJOiBhdXRvdmFjdXVtX3ZhY19pbnNfdGhyZXNoOwog Ci0JYW5sX3NjYWxlX2ZhY3RvciA9IChyZWxvcHRzICYmIHJlbG9wdHMtPmFuYWx5emVfc2NhbGVf ZmFjdG9yID49IDApCisJKmFubF9zY2FsZV9mYWN0b3IgPSAocmVsb3B0cyAmJiByZWxvcHRzLT5h bmFseXplX3NjYWxlX2ZhY3RvciA+PSAwKQogCQk/IHJlbG9wdHMtPmFuYWx5emVfc2NhbGVfZmFj dG9yCiAJCTogYXV0b3ZhY3V1bV9hbmxfc2NhbGU7CiAKLQlhbmxfYmFzZV90aHJlc2ggPSAocmVs b3B0cyAmJiByZWxvcHRzLT5hbmFseXplX3RocmVzaG9sZCA+PSAwKQorCSphbmxfYmFzZV90aHJl c2ggPSAocmVsb3B0cyAmJiByZWxvcHRzLT5hbmFseXplX3RocmVzaG9sZCA+PSAwKQogCQk/IHJl bG9wdHMtPmFuYWx5emVfdGhyZXNob2xkCiAJCTogYXV0b3ZhY3V1bV9hbmxfdGhyZXNoOwogCkBA IC0zMDQ4LDcgKzMxODcsNyBAQCByZWxhdGlvbl9uZWVkc192YWNhbmFseXplKE9pZCByZWxpZCwK IAogCQl2YWN0aHJlc2ggPSAoZmxvYXQ0KSB2YWNfYmFzZV90aHJlc2ggKyB2YWNfc2NhbGVfZmFj dG9yICogcmVsdHVwbGVzOwogCQl2YWNpbnN0aHJlc2ggPSAoZmxvYXQ0KSB2YWNfaW5zX2Jhc2Vf dGhyZXNoICsgdmFjX2luc19zY2FsZV9mYWN0b3IgKiByZWx0dXBsZXM7Ci0JCWFubHRocmVzaCA9 IChmbG9hdDQpIGFubF9iYXNlX3RocmVzaCArIGFubF9zY2FsZV9mYWN0b3IgKiByZWx0dXBsZXM7 CisJCWFubHRocmVzaCA9IChmbG9hdDQpICphbmxfYmFzZV90aHJlc2ggKyAqYW5sX3NjYWxlX2Zh Y3RvciAqIHJlbHR1cGxlczsKIAogCQkvKgogCQkgKiBOb3RlIHRoYXQgd2UgZG9uJ3QgbmVlZCB0 byB0YWtlIHNwZWNpYWwgY29uc2lkZXJhdGlvbiBmb3Igc3RhdApAQCAtMzA4NSw2ICszMjI0LDUw IEBAIHJlbGF0aW9uX25lZWRzX3ZhY2FuYWx5emUoT2lkIHJlbGlkLAogCQkqZG9hbmFseXplID0g ZmFsc2U7CiB9CiAKKy8qCisgKiByZWxhdGlvbl9uZWVkc19hbmFseXplCisgKgorICogQ2hlY2sg d2hldGhlciBhIHJlbGF0aW9uIG5lZWRzIHRvIGJlIGFuYWx5emVkLiBJdCByZXVzZXMgYW5hbHl6 ZSBlcXVhdGlvbgorICogcGFyYW1ldGVycyB3aGVuIGNhbGxlZCBmcm9tIHJlbGF0aW9uX25lZWRz X3ZhY2FuYWx5emUoKS4KKyAqLworc3RhdGljIHZvaWQKK3JlbGF0aW9uX25lZWRzX2FuYWx5emUo YXV0b3ZhY190YWJsZSAqdGFiLAorCQkJCQkgICBGb3JtX3BnX2NsYXNzIGNsYXNzRm9ybSwKKwkJ CQkJICAgUGdTdGF0X1N0YXRUYWJFbnRyeSAqdGFiZW50cnksCisgLyogb3V0cHV0IHBhcmFtcyBi ZWxvdyAqLworCQkJCQkgICBib29sICpkb2FuYWx5emUpCit7CisJLyoKKwkgKiBJZiB3ZSBmb3Vu ZCBzdGF0cyBmb3IgdGhlIHRhYmxlLCBhbmQgYXV0b3ZhY3V1bSBpcyBjdXJyZW50bHkgZW5hYmxl ZCwKKwkgKiBtYWtlIGEgdGhyZXNob2xkLWJhc2VkIGRlY2lzaW9uIHdoZXRoZXIgdG8gYW5hbHl6 ZS4KKwkgKi8KKwlpZiAoUG9pbnRlcklzVmFsaWQodGFiZW50cnkpICYmIEF1dG9WYWN1dW1pbmdB Y3RpdmUoKSkKKwl7CisJCWZsb2F0NAkJcmVsdHVwbGVzOworCQlmbG9hdDQJCWFubHRocmVzaDsK KwkJZmxvYXQ0CQlhbmx0dXBsZXM7CisKKwkJQXNzZXJ0KGNsYXNzRm9ybSAhPSBOVUxMKTsKKwkJ QXNzZXJ0KE9pZElzVmFsaWQodGFiLT5hdF9yZWxpZCkpOworCisJCXJlbHR1cGxlcyA9IGNsYXNz Rm9ybS0+cmVsdHVwbGVzOworCQlhbmx0dXBsZXMgPSB0YWJlbnRyeS0+bW9kX3NpbmNlX2FuYWx5 emU7CisKKwkJLyogVmFjdXVtIGNvdWxkIHVwZGF0ZSB0aGUgdmFsdWUgdG8gLTEgKi8KKwkJaWYg KHJlbHR1cGxlcyA8IDApCisJCQlyZWx0dXBsZXMgPSAwOworCisJCS8qIERldGVybWluZSBpZiB0 aGlzIHRhYmxlIG5lZWRzIGFuYWx5emUuICovCisJCWFubHRocmVzaCA9IChmbG9hdDQpIHRhYi0+ YW5sX2Jhc2VfdGhyZXNoICsgdGFiLT5hbmxfc2NhbGVfZmFjdG9yICogcmVsdHVwbGVzOworCQkq ZG9hbmFseXplID0gKGFubHR1cGxlcyA+IGFubHRocmVzaCk7CisKKwkJZWxvZyhERUJVRzMsICIl czogYW5sOiAlLjBmICh0aHJlc2hvbGQgJS4wZikiLAorCQkJIE5hbWVTdHIoY2xhc3NGb3JtLT5y ZWxuYW1lKSwgYW5sdHVwbGVzLCBhbmx0aHJlc2gpOworCX0KKwllbHNlCisJCSpkb2FuYWx5emUg PSBmYWxzZTsKK30KKwogLyoKICAqIGF1dG92YWN1dW1fZG9fdmFjX2FuYWx5emUKICAqCQlWYWN1 dW0gYW5kL29yIGFuYWx5emUgdGhlIHNwZWNpZmllZCB0YWJsZQpkaWZmIC0tZ2l0IGEvc3JjL3Rl c3QvbW9kdWxlcy90ZXN0X21pc2MvdC8wMDhfcmVjaGVja19hdXRvYW5hbHl6ZS5wbCBiL3NyYy90 ZXN0L21vZHVsZXMvdGVzdF9taXNjL3QvMDA4X3JlY2hlY2tfYXV0b2FuYWx5emUucGwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmJkNjRlYzdiYzM2Ci0tLSAvZGV2L251 bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X21pc2MvdC8wMDhfcmVjaGVja19hdXRvYW5h bHl6ZS5wbApAQCAtMCwwICsxLDkxIEBACisjIENvcHlyaWdodCAoYykgMjAyNSwgUG9zdGdyZVNR TCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAKKworIyBUZXN0cyByZWNoZWNraW5nIHdoZXRoZXIg YW4gQU5BTFlaRSBpcyByZXF1aXJlZCBhZnRlciBhbiBhdXRvdmFjdXVtCisjIHBlcmZvcm1zIG9u bHkgYSBWQUNVVU0gb24gYSB0YWJsZSwgZXZlbiBpZiB0aGUgdGFibGUgZGlkbid0IGluaXRpYWxs eQorIyByZXF1aXJlIGFuIEFOQUxZWkUgd2hlbiB0aGUgVkFDVVVNIHN0YXJ0ZWQuCisKK3VzZSBz dHJpY3Q7Cit1c2Ugd2FybmluZ3MgRkFUQUwgPT4gJ2FsbCc7Cit1c2UgUG9zdGdyZVNRTDo6VGVz dDo6Q2x1c3RlcjsKK3VzZSBUZXN0OjpNb3JlOworCitpZiAoJEVOVntlbmFibGVfaW5qZWN0aW9u X3BvaW50c30gbmUgJ3llcycpCit7CisJcGxhbiBza2lwX2FsbCA9PiAnSW5qZWN0aW9uIHBvaW50 cyBub3Qgc3VwcG9ydGVkIGJ5IHRoaXMgYnVpbGQnOworfQorCisjIEluaXRpYWxpemUgcG9zdGdy ZXMKK215ICRwc3FsX2VyciA9ICcnOworbXkgJHBzcWxfb3V0ID0gJyc7CitteSAkbm9kZSA9IFBv c3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXItPm5ldygnbm9kZScpOworJG5vZGUtPmluaXQ7CisKKyRu b2RlLT5hcHBlbmRfY29uZigKKwkncG9zdGdyZXNxbC5jb25mJywgcXFbCisjIFRoaXMgZW5zdXJl cyBhIHF1aWNrIHdvcmtlciBzcGF3bi4KK2F1dG92YWN1dW1fbmFwdGltZSA9IDFzCitsb2dfYXV0 b3ZhY3V1bV9taW5fZHVyYXRpb24gPSAwCitdKTsKKyRub2RlLT5zdGFydDsKKworIyBDaGVjayBp ZiB0aGUgZXh0ZW5zaW9uIGluamVjdGlvbl9wb2ludHMgaXMgYXZhaWxhYmxlLCBhcyBpdCBtYXkg YmUKKyMgcG9zc2libGUgdGhhdCB0aGlzIHNjcmlwdCBpcyBydW4gd2l0aCBpbnN0YWxsY2hlY2ss IHdoZXJlIHRoZSBtb2R1bGUKKyMgd291bGQgbm90IGJlIGluc3RhbGxlZCBieSBkZWZhdWx0Lgor aWYgKCEkbm9kZS0+Y2hlY2tfZXh0ZW5zaW9uKCdpbmplY3Rpb25fcG9pbnRzJykpCit7CisJcGxh biBza2lwX2FsbCA9PiAnRXh0ZW5zaW9uIGluamVjdGlvbl9wb2ludHMgbm90IGluc3RhbGxlZCc7 Cit9CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgJ0NSRUFURSBFWFRFTlNJT04gaW5q ZWN0aW9uX3BvaW50czsnKTsKKworIyBGcm9tIHRoaXMgcG9pbnQsIGF1dG92YWN1dW0gd29ya2Vy IHdpbGwgd2FpdCBhZnRlciB2YWN1dW1pbmcgb25lIGhlYXAgcmVsYXRpb24uCiskbm9kZS0+c2Fm ZV9wc3FsKCdwb3N0Z3JlcycsCisJIlNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYmVm b3JlLXJlY2hlY2stYXV0b2FuYWx5emUnLCAnd2FpdCcpOyIpOworCisjIEdyYWIgbG9jYXRpb24g aW4gbG9ncyBvZiBwcmltYXJ5CitteSAkb2Zmc2V0ID0gLXMgJG5vZGUtPmxvZ2ZpbGU7CisKKyMg Q3JlYXRlIGEgdGFibGUgYW5kIGluc2VydCA3MCByb3dzIG9mIGRhdGEsIHdoaWNoIGV4Y2VlZHMg dGhlIHZhbHVlIG9mCisjIGF1dG92YWN1dW1fdmFjdXVtX2luc2VydF90aHJlc2hvbGQgYW5kIGRv ZXNuJ3QgZXhjZWVkcyB0aGUgdmFsdWUgb2YKKyMgYXV0b3ZhY3V1bV9hbmFseXplX3RocmVzaG9s ZC4KKyRub2RlLT5zYWZlX3BzcWwoCisJJ3Bvc3RncmVzJywgcXFbCisgICAgQ1JFQVRFIFRBQkxF IHB1YmxpYy50ZXN0IChpZCBpbnQpIFdJVEgKKyAgICAoYXV0b3ZhY3V1bV92YWN1dW1faW5zZXJ0 X3RocmVzaG9sZCA9IDUwLCBhdXRvdmFjdXVtX2FuYWx5emVfdGhyZXNob2xkID0gMTAwKTsKKyAg ICBJTlNFUlQgSU5UTyBwdWJsaWMudGVzdCBTRUxFQ1QgZ2VuZXJhdGVfc2VyaWVzKDEsIDcwKTsK K10pOworCisjIFdhaXQgdW50aWwgYW4gYXV0b3ZhY3V1bSB3b3JrZXIgc3RhcnRzLgorJG5vZGUt PndhaXRfZm9yX2V2ZW50KCdhdXRvdmFjdXVtIHdvcmtlcicsICdiZWZvcmUtcmVjaGVjay1hdXRv YW5hbHl6ZScpOworCisjIEFuZCBncmFiIG9uZSBvZiB0aGVtLgorbXkgJGF2X3BpZCA9ICRub2Rl LT5zYWZlX3BzcWwoCisJJ3Bvc3RncmVzJywKKyAgICAiU0VMRUNUIHBpZCBGUk9NIHBnX3N0YXRf YWN0aXZpdHkgIgorICAuICJXSEVSRSBiYWNrZW5kX3R5cGUgPSAnYXV0b3ZhY3V1bSB3b3JrZXIn IEFORCB3YWl0X2V2ZW50ID0gJ2JlZm9yZS1yZWNoZWNrLWF1dG9hbmFseXplJzsiKTsKKworIyBp bnNlcnQgZGF0YSB0byBleGNlZWRzIHRoZSB2YWx1ZSBvZiBhdXRvdmFjdXVtX2FuYWx5emVfdGhy ZXNob2xkCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisgICAgIklOU0VSVCBJTlRPIHB1 YmxpYy50ZXN0IFNFTEVDVCBnZW5lcmF0ZV9zZXJpZXMoMSwgNzApOyIpOworCisjIFdha2V1cCB0 aGUgaW5qZWN0aW9uIHBvaW50LgorJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJTRUxF Q1QgaW5qZWN0aW9uX3BvaW50c193YWtldXAoJ2JlZm9yZS1yZWNoZWNrLWF1dG9hbmFseXplJyk7 Iik7CisKKyMgV2FpdCBmb3IgdGhlIGF1dG92YWN1dW0gd29ya2VyIHRvIGV4aXQgYmVmb3JlIHNj YW5uaW5nIHRoZSBsb2dzLgorJG5vZGUtPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywKKwkJ IlNFTEVDVCBjb3VudCgqKSA9IDAgRlJPTSBwZ19zdGF0X2FjdGl2aXR5ICIKKwkgIC4gIldIRVJF IHBpZCA9ICckYXZfcGlkJyBBTkQgYmFja2VuZF90eXBlID0gJ2F1dG92YWN1dW0gd29ya2VyJzsi KTsKKworIyBDaGVjayB0aGF0IEFOQUxZWkUgaXMgZXhlY3V0ZWQuCitvaygkbm9kZS0+bG9nX2Nv bnRhaW5zKAorCQlxci9cWyRhdl9waWRcXSBMT0c6ICBhdXRvbWF0aWMgYW5hbHl6ZSBvZiB0YWJs ZSAicG9zdGdyZXMucHVibGljLnRlc3QiLywKKwkJJG9mZnNldCksCisJCSJBTkFMWVpFIHRyaWdn ZXJlZCBieSByZWNoZWNrIGFmdGVyIHZhY3V1bSIpOworCisjIFJlbGVhc2UgaW5qZWN0aW9uIHBv aW50LgorJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJTRUxFQ1QgaW5qZWN0aW9uX3Bv aW50c19kZXRhY2goJ2JlZm9yZS1yZWNoZWNrLWF1dG9hbmFseXplJyk7Iik7CisKKyRub2RlLT5z dG9wOworZG9uZV90ZXN0aW5nKCk7Ci0tIAoyLjM0LjEKCg== --=_09ebd24f94ff269eb6963e917454b32f Content-Transfer-Encoding: base64 Content-Type: application/gzip; name=reproduce_small_reltuples.tar.gz Content-Disposition: attachment; filename=reproduce_small_reltuples.tar.gz; size=2983 H4sIAAAAAAAAA+1aW3PbxhXWq/ArTu2JSUogBPAuOXZMS0ysRJJVUk7rJhkEBJYkKhBAsIBoZZKX PnTy3JdOZ/ra6R/oS39Q0r/RcxYACfEiyaFsJS3OaERyL2fP9duzCwTMDzwrMpnOx4bj6AFzwsh3 GN/ZuDNSkZrNOn1qzbqa/UxpQ6s1a1Uk/LehavVKo7IB9bsTYTVFPDQCgA37nFnGNeNu6v+VUrDS /91O++C4o4yttdcgBzcatVX+R9c3Z/6vaOj/Rr3W3AD1DvS7kf7P/f8QPrbR25J0NmIw8BzHm9ju EAbUCEbAAMPjwraYBaEH02CBEEfbnEcMvAF4FyxwLkEEEPhD3XQMzpVpJMGF4USMK5K0BRdamTxe bltW2Xb/yMzQ9tyy79luyMsDLygLJuVFJopvhOYIOXB7jL/1kPFQ4d84cy1eFErSQ+iFzOckcTeV WJI0Bdq+j3KS7GvKQayJjRkFAXNDeIG5okgVBZ5HtmPBxA5Hor9cZq7Rd9jCGuD59EuRqgoKawSh GH7q8XAYsN5vj4CzAK2qSDUFupEreklB4GZg+6Eiff3115KP+uMSrlemb4EJ5cG8eeDpgnlopvTa i8A0XPD6YiHkb4TLXGdznD907YGNo8PUySygCS5OwOQJxVBF/NdNL3JROrFIuVzOjsDo4ZGDqmO7 BJnh8B1YzLD0TBPNndF2eYEkEKQJAEEGM4qbpKIGgTcpSYkUsWJguBb9IJn0CDXXQ/IOvyraVHtp cUGA5ow3Knnf6bs2rcb/uUhaY40b8L+hNqop/leaNWyvqFX8yPH/PdCXzBx5UEBwPMVQMAICf3I5 34NDFzMkhF2ZUixgphdYXCnAl19KhhMiBPBLHrIxIlUIRhR6F4YZRWPdNRDZxgzOXkKhzguPMYkW hjveUM9MGduubkWBQYgo5qk4jTMHEZOyFUPSQ3gwPXdQLD2WzIAZIQP2JmQupxlTbNVjbF0yJAND 016R+jGoFm0LuYQy8BCRDafJcNo9PG53X8NnndfYW8J17dgcOM5LZvU6R539M7BlKIwY7pww8QLH KsDH3ZfHMGQuQ5Uwr1hgM17UZIImHW1ZAl60iaOUGB/3jVMW4K4zhrHhRoYDn7f3X706hvZJ++j1 Hzq020S+RUIv2ZCER2JLIr4ZzuW3sVaPU/bX4HABaHJi6gz+yguIDIPAG2fZFAu0SKE0t8ztgbaQ WXq24STLJGwmIxaQwI5rYEg9gXjNaXC4umNfMBJTxu+pyPR97Fk6t12EtcQkMiDDMBN1mYbUauna C1JHKwVJlcdt/Cywh0OM89kSe3CAcqLXqC5KEkhYJgklTc2mFoQTGyurych24voKo+kc+dlUQBE7 TM3Y2Wjonj2OHAoIjgXbrD81zHxK6Og0wxwVCwR2oT5ihq8nyYc6FTCAJ4YtnHkTA/aGmVGIS+mO 8e2lzrEsEOzeiodrXScCqrdoS6nPhrb7GONSWFS4SkQ53HlegumNx3YoBDmIYkSk4tgOkLl5aToY TDPBwI9Tl6dJSw5OEje1hJbEj+uFCEo2oisUp11Xos5Ag13Y4SV8E7HgMplGhtHZBRWaGHnLXUh5 OBGlKaEplif8iZZJsJjdzUvF3x3c7KDwAVnzgwIqcwA+IuSHT2lu3zDPyYHYUoydtR/jKaUfJFks ykkMDVK4T3kzxjOCBf24+BYxG1vrHtwKcI3ME88tXBHZptobU1D4XVkZ2hPjnEX+qvxCO92vngST V/QkN2RiOIGaWHvmCsQn6Hk75VdiQxwnv8MwxiNmkCYKKjywXZuP3kmaLAOZO0qSmxeabQx4ftsf MfN8yc69B71xvDOkmx+dyBwRkh74HloqXtV3DDfZ5xOuh6ljDI5glJYJExu59anuIT9kgjfxcopd 8d48f9RLZ8eVhgXcw/NpdtEX3gSVDuSYrdifeFgmEfBUiufcwPbkFYE1toejMPGrkG0q83IR0QgX hLuZsyemzoUtSkQugghNJeo7uppACLY964qw1xY9ec2zTs1z30eWnO6QVp//17wiy6xxw/m/rlVr 0/vfitrcUKtqo1nJz//vgz6m/G9Z9V1Tq7ZaNbVe01q7jRrbVZtWvdVUW5o5MKp1yzAqqgbHeJbu MR+0JqjqnviDCnpTIjZ7cGxwY2QHHhySseBDYbMxHz3zMD7cMMSNxVCwPHkqHeAWs0fsZJwPnyKY V9RKHTRtr1rfq1RhW91VVakX9Snu9uCL0/bZ/gu40L4CDMdZBQLJbSptCCuvn8V1hrgIlIAH5k5S we4Ypsk436G9eyfGRypbFBO+g6oK29eQRPUIHdPMkeEOmSXThLiQo/2puF2SJMseDBDyh1jzGDu3 WrZ/q2GSjVveG6j3VdbcVZlWUZRWq9+oa02jX6FasFGriUvP260qoTq3XfnZMyhraktuwDZ9NOHZ Mwke4o7jRBaDBzz0AmPIdvrRYDwMlNGDZZ2DgDHuGyZb0e8kU7dnXVhSOnxnruqcmx6PcfglFp3m aJ553EtXSRHHRZb20qUVQsHYp17StFbRSNNapSJrVVQV5oq8Ypc58ZUV/pDhc9FxagQY8LDli09Z gk0WBCYGJhlX8QOsYbyI42aKzV5Ad1p03US7r3n+OB4934yDH2WY4CgyzsBiA3jV6+iHJ5/iaeHw 5Yl++vLw5KwnbW/aA6ybw8Ac+0UUF6UrP012cWF5GR5QlmAuOt7wQQl+8wRUePQIJ25eP8t26aAr dMbifsTGxtvMxjWx7OBhMqdEM+aELz5Yen56gAXX9kMMTXsgYe5t7mwhCIVYqMII60osFi+YAzyM MOGMvheJ0iq+Z0FoEOmCKLC1gzMzoqFZ8f/juFH3fObqydCsAjJ0vUnnDUYKx6rryDPPZXiU9rvJ BFnES6tRpXhpNbW14kV4D7EkDKIxnjBK1LTpU9pgqyUM+oX9VYkE/x6t8b8bCkvOVdlAgO8xEWBn S9h+typQabdelSsa2f7qAbR49DkavxfSUXgrlqlEszenAUFDXWbpPsID394WSbaJgUb/YSs9Rhvu /NZDJzWe3sUZ2ds4JZ6aMHgeY2t8xEsuoF02efszecLv6skcDum2Bat3voIJSongZo/FvTeOcKNx H5u9QcIuez9w9XkfoqQXBKiyc5lotHNTzK0RdGtG3duFXTppaQzAkyeUhmEJstySvi1QlXpJhO2S uF1xCzKPYgRjXeZ7ARYIHPoOYgskIsjpdb/YDiAMUH7CfsgYIAa0zfh0qmMRP8RzJtfjibrAk+Jp 9+Un3U6vp8c3LvqLTvtUf370WU/v7bdPTjoHMq577noCTTaTqUm6xTsRLZgYQIaTV0dHcnJ7o3e6 3f3n+umLNgYBcRPMZbrnkSpKtaZoUn5Q/BXQ7Z7/4qa6xho3nf/qqjY9/6k1TTz/rebv/7wXuvWD X6l9dNbpQu9176xzLM09l4WrL2zEb3jM3sHY73baZx3o/P6sc9JDqFzZcNZ+ftSRDk96ne4ZAnTy Lsd6z0el5EnDGq+jwBrvowi6m/dRYOGFlPmXXTK3gyjE7HpQ/Fi4H8TWuQvCbEs66Iru2yt/XNO6 0l6L5lpiuxWt38FM7ff19FVa9UxzMf4zmmbcc6/Tn3c+OTyRDjpHHcy0JHLmU23/5fHx4ZkEH5me E43dj7Ksp69AaTOedGvz47//pWo//f2HivrTX/8BmvbT3/5Urf74w5/ru//551+gSM8MLqHCSYF1 2daQraq9G7bV27EtqsSM+qX5kEwe1yzQavcseCsbvnMg50d9xzYVwuif59MVz+3eQfSst9LduLP5 bqLkljH9y4qSu3sIKb23J4/SL/5x431VFHf4hutiRUHUXKeiSGi+sJju2u+gvrixf5aDzdSUyyu1 RtpKGFBWtXJFFc8kantqU2nVmmqlta3uXqk97ruAzymnnHLKKaeccsopp5xyyimnnHLKKaeccsop p5xyyimnnHJK6L+TjFk/AFAAAA== --=_09ebd24f94ff269eb6963e917454b32f--