From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 87A8E385840B for ; Tue, 5 Oct 2021 13:34:03 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 87A8E385840B Received: from mail-lf1-f72.google.com (mail-lf1-f72.google.com [209.85.167.72]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-426-i5Mqwmj3Oe68BBkAZU2psQ-1; Tue, 05 Oct 2021 09:34:01 -0400 X-MC-Unique: i5Mqwmj3Oe68BBkAZU2psQ-1 Received: by mail-lf1-f72.google.com with SMTP id d22-20020a0565123d1600b003fd0097d747so16902117lfv.2 for ; Tue, 05 Oct 2021 06:34:01 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=ahYYPG6z04U0ayhrPFyeHS7tctip5bJsWnzXs5eZEYI=; b=w+MLLSvHDcwftdrealEV3PIqLUhSA3wDg1tDpMBgr5/rNbOgq9o5TmcjMlHLRoRwyy TzZZZXMeOVYCHLaIw92ZQbxGN5blg0unIO8P1d4K6iV35lKsYhCIq8I2fRLkLk7fDQdP xgYxKhTjnK/CWwKeWaY4labMCOGlzjn5KpnndxRe5G/efU0KxCGjCpg4ZhpLWZ/sDabr gFrWebwGE8ssB10k2sSaoYB0Exx2zdOlIEJZLULEu4L1gEmhsNehzleD0jom1Dwc4TSM GVa84+VIrNDx/jhmCyvVau0gYlSAKEUf9hxaLn+RZu1PRNOhNNIIPc1KTFCRpBJyOrwl FQ+A== X-Gm-Message-State: AOAM530HdmXak0jfM0Xu9Sk8Ui+hJw4FSOD0II+aq10eLlJEjPDWyMHg N2851WdzpTNG5C4QbVhYbjiCy+9caJITpdO0rWZTR1WSW0S6bQtnYDxIUMkBb+KXoRdDcfeQoSB TWiryNgrAuBVzIc/iWCJB5FvhMt0Jh4qQdw== X-Received: by 2002:a05:6512:10d5:: with SMTP id k21mr3442176lfg.315.1633440840163; Tue, 05 Oct 2021 06:34:00 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzJSknaxUqgV9LZnXsNejnLaF1Ot/7nHbSuMIC2m8e2ovEd/Fh671A0ZSdIfQ+913wQmLKz6j7cpuAgl78xZYc= X-Received: by 2002:a05:6512:10d5:: with SMTP id k21mr3442152lfg.315.1633440839840; Tue, 05 Oct 2021 06:33:59 -0700 (PDT) MIME-Version: 1.0 References: <20211004094313.1596556-1-aldyh@redhat.com> In-Reply-To: From: Aldy Hernandez Date: Tue, 5 Oct 2021 15:33:48 +0200 Message-ID: Subject: Re: [RFC] More jump threading restrictions in the presence of loops. To: Michael Matz Cc: Jeff Law , Richard Biener , Andrew MacLeod , GCC patches X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000056bd305cd9b1534" X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 05 Oct 2021 13:34:05 -0000 --000000000000056bd305cd9b1534 Content-Type: text/plain; charset="UTF-8" On Mon, Oct 4, 2021 at 6:29 PM Michael Matz wrote: > > Hello, > > On Mon, 4 Oct 2021, Jeff Law wrote: > > > And just in case it got lost. Here's the analysis on 960218-1 on visium: > > > > We've got this going into ethread: > > > > int f (int x) > > { > > int D.1420; > > int a; > > > > ;; basic block 2, loop depth 0, maybe hot > > ;; prev block 0, next block 3, flags: (NEW, REACHABLE, VISITED) > > ;; pred: ENTRY (FALLTHRU,EXECUTABLE) > > a_4 = ~x_3(D); > > goto ; [INV] > > ;; succ: 4 (FALLTHRU,EXECUTABLE) > > > > ;; basic block 3, loop depth 1, maybe hot > > ;; prev block 2, next block 4, flags: (NEW, REACHABLE, VISITED) > > ;; pred: 4 (TRUE_VALUE,EXECUTABLE) > > gl = a_1; > > ;; succ: 4 (FALLTHRU,DFS_BACK,EXECUTABLE) > > > > ;; basic block 4, loop depth 1, maybe hot > > ;; prev block 3, next block 5, flags: (NEW, REACHABLE, VISITED) > > ;; pred: 2 (FALLTHRU,EXECUTABLE) > > ;; 3 (FALLTHRU,DFS_BACK,EXECUTABLE) > > # a_1 = PHI > > if (a_1 != 0) > > goto ; [INV] > > else > > goto ; [INV] > > ;; succ: 3 (TRUE_VALUE,EXECUTABLE) > > ;; 5 (FALSE_VALUE,EXECUTABLE) > > > > ;; basic block 5, loop depth 0, maybe hot > > ;; prev block 4, next block 1, flags: (NEW, REACHABLE, VISITED) > > ;; pred: 4 (FALSE_VALUE,EXECUTABLE) > > return; > > ;; succ: EXIT > > > > } > > First notice that this doesn't have an empty latch block to start with > (in fact, there is no separate latch block at all), so the loop optimizers > haven't been initialized for simple latches at this point. Still, I would > say that even then we want to be careful with the latch edge, as putting > code onto it will most probably create a problem downstream once we _do_ > want to intialize the loop optimizers for simple latches. So, that we are > careful here is okay, we are just too careful in this specific case. > > > There's a pretty obvious jump thread in there. 3->4->5. > > > > We used to allow this, but it's currently being rejected and I'm not > > sure it should. > > > > In simplest terms we're threading from inside the loop, through the > > latch to a point outside the loop. At first glance, that seems safe. > > Is at least the unrestricted jump threader (the one after loop optimizers) > picking this up? > > Independend of that, I agree, that this specific instance of threading > through the latch block, even though followed by to-be-copied > instructions, is okay. We need to determine precisely when that is okay, > though. In this case there are several reasons I could see why this is > so: > (a) while the thread is through the latch block, it's _not_ through the > latch edge (which is 4->3). That would create the problem, so here > we're fine. It seems we all agree Jeff's finding should be allowed, so let's attack this one first, since it gets almost all of his visium failures. I can submit the rest of the cases separately. The attached patch catches the IL discussed, and adds a relevant gimple FE test others can use for experimenting :). Tested on x86-64 and by visual inspection on visium-elf on the regressions Jeff pointed me at. OK? BTW Jeff, this fixes all the regressions you mention except: 1. pr68911.c The path not being threaded here is 7->10->11->12. It crosses loops multiple times, so I believe the restriction code is correct. 7, 10, 12 are in loop1. 11 is in loop 2. So we have a path going from loop1 -> loop2 -> loop1. I can't conceive any scenario where this is ok, but I can attach the entire IL if I'm missing something. 2. 961125-1.c This one is a bit trickier. Here we're trying to thread the following conditional, which I mentioned when I contributed this work, we don't handle (and happens infrequently enough not to matter): + // Loop 4 + [local count: 114863531]: + # ptr_8 = PHI + if (ptr_8 < &MEM [(void *)":ab" + 3B]) + goto ; [50.00%] + else + goto ; [50.00%] The hybrid threader doesn't handle &MEM in the final conditional. As I mentioned earlier, if this becomes an issue, we can adapt class pointer_equiv_analyzer like we did for evrp. I have a gimple FE test I will contribute as an XFAIL with an associated PR to keep us honest. That being said... in this particular test, this is all irrelevant because the path will be disallowed for two reasons: a) The path crosses loops, and the reason we didn't realize it in the old code was because the ASSERT_EXPR had pulled the SSA outside the loop, so it looks like the entire path is l in the same loop. If you look at the original IL, it's not. b) Now the path actually fits the pattern being discussed in this patch, where there's an early exit out of a loop, so it looks like we should handle it. But...in this case, we would fill a presently empty latch. Interestingly, the old code didn't catch it, because....you guessed it...there was an ASSERT_EXPR in the latch. So I argue that even in the absence of MEM_REF handling, we shouldn't thread this path. --000000000000056bd305cd9b1534 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Loosen-loop-crossing-restriction-in-threader.patch" Content-Disposition: attachment; filename="0001-Loosen-loop-crossing-restriction-in-threader.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kue3o4670 RnJvbSA1YWJlNjU2NjhmNjAyZDUzYjhmM2RjNTE1NTA4ZGM0NjE2YmViMDQ4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogVHVlLCA1IE9jdCAyMDIxIDE1OjAzOjM0ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gTG9vc2Vu IGxvb3AgY3Jvc3NpbmcgcmVzdHJpY3Rpb24gaW4gdGhyZWFkZXIuCgpDcm9zc2luZyBsb29wcyBp cyBnZW5lcmFsbHkgZGlzY291cmFnZWQgZnJvbSB0aGUgdGhyZWFkZXIsIGJ1dCB3ZSBjYW4KbWFr ZSBhbiBleGNlcHRpb24gd2hlbiB3ZSBkb24ndCBjcm9zcyB0aGUgbGF0Y2ggb3IgZW50ZXIgYW5v dGhlciBsb29wLApzaW5jZSB0aGlzIGlzIGp1c3QgYW4gZWFybHkgZXhpdCBvdXQgb2YgdGhlIGxv b3AuCgpJbiBmYWN0LCB0aGUgd2hvbGUgdGhyZWFkZWQgcGF0aCBpcyBsb2dpY2FsbHkgb3V0c2lk ZSB0aGUgbG9vcC4gIFRoaXMKaGFzIG5pY2Ugc2Vjb25kYXJ5IGVmZmVjdHMuICBGb3IgZXhhbXBs ZSwgb2JqZWN0cyBvbiB0aGUgdGhyZWFkZWQgcGF0aAp3aWxsIG5vIGxvbmdlciBuZWNlc3Nhcmls eSBiZSBsaXZlIHRocm91Z2hvdXQgdGhlIGxvb3AsIHNvIHdlIGNhbiBnZXQKcmVnaXN0ZXIgYWxs b2NhdGlvbiBpbXByb3ZlbWVudHMuICBUaGUgdGhyZWFkZWQgcGF0aCBjYW4gcGh5c2ljYWxseQpt b3ZlIG91dHNpZGUgdGhlIGxvb3AgcmVzdWx0aW5nIGluIGJldHRlciBpY2FjaGUgZWZmaWNpZW5j eSwgZXRjLgoKVGVzdGVkIG9uIHg4Ni02NCBMaW51eCwgYW5kIG9uIGEgdmlzaXVtLWVsZiBjcm9z cyBtYWtpbmcgc3VyZSB0aGF0IHRoZQpmb2xsb3dpbmcgdGVzdHMgZG8gbm90IGhhdmUgYW4gYWJv cnQgaW4gdGhlIGZpbmFsIGFzc2VtYmx5OgoKZ2NjLmMtdG9ydHVyZS9leGVjdXRlLzk2MDIxOC0x LmMKZ2NjLmMtdG9ydHVyZS9leGVjdXRlL3Zpc2l1bS1wZW5kaW5nLTQuYwpnY2MuYy10b3J0dXJl L2V4ZWN1dGUvcHI1ODIwOS5jCgpnY2MvQ2hhbmdlTG9nOgoKCSogdHJlZS1zc2EtdGhyZWFkdXBk YXRlLmMgKGp0X3BhdGhfcmVnaXN0cnk6OmNhbmNlbF9pbnZhbGlkX3BhdGhzKToKCmdjYy90ZXN0 c3VpdGUvQ2hhbmdlTG9nOgoKCSogZ2NjLmRnL3RyZWUtc3NhL3NzYS10aHJlYWQtdmFsaWQuYzog TmV3IHRlc3QuCgpDby1hdXRob3JlZC1ieTogSmVmZiBMYXcgPGplZmZyZWFsYXdAZ21haWwuY29t PgotLS0KIC4uLi9nY2MuZGcvdHJlZS1zc2Evc3NhLXRocmVhZC12YWxpZC5jICAgICAgICB8IDM5 ICsrKysrKysrKysrKysrKysrKwogZ2NjL3RyZWUtc3NhLXRocmVhZHVwZGF0ZS5jICAgICAgICAg ICAgICAgICAgIHwgNDAgKysrKysrKysrKysrKystLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCA2OCBp bnNlcnRpb25zKCspLCAxMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBnY2MvdGVz dHN1aXRlL2djYy5kZy90cmVlLXNzYS9zc2EtdGhyZWFkLXZhbGlkLmMKCmRpZmYgLS1naXQgYS9n Y2MvdGVzdHN1aXRlL2djYy5kZy90cmVlLXNzYS9zc2EtdGhyZWFkLXZhbGlkLmMgYi9nY2MvdGVz dHN1aXRlL2djYy5kZy90cmVlLXNzYS9zc2EtdGhyZWFkLXZhbGlkLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjdhZGNhOTdjYzJiCi0tLSAvZGV2L251bGwKKysrIGIv Z2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2Evc3NhLXRocmVhZC12YWxpZC5jCkBAIC0wLDAg KzEsMzkgQEAKKy8vIHsgZGctZG8gY29tcGlsZSB9CisvLyB7IGRnLW9wdGlvbnMgIi1PMiAtZmdp bXBsZSAtZmR1bXAtc3RhdGlzdGljcyIgfQorCisvLyBUaGlzIGlzIGEgY29sbGVjdGlvbiBvZiB0 aHJlYWRhYmxlIHBhdGhzLiAgVG8gc2ltcGxpZnkgbWFpbnRlbmFuY2UsCisvLyB0aGVyZSBzaG91 bGQgb25seSBiZSBvbmUgdGhyZWFkYWJsZSBwYXRoIHBlciBmdW5jdGlvbi4KKworaW50IGdsb2Jh bDsKKworLy8gVGhlIHRocmVhZCBmcm9tIDMtPjQtPjUgY3Jvc3NlcyBsb29wcyBidXQgaXMgYWxs b3dlZCBiZWNhdXNlIGl0CisvLyBuZXZlciBjcm9zc2VzIHRoZSBsYXRjaCAoQkIzKSBhbmQgaXMg anVzdCBhbiBlYXJseSBleGl0IG91dCBvZiB0aGUKKy8vIGxvb3AuCitpbnQgX19HSU1QTEUgKHNz YSkKK2ZvbzEgKGludCB4KQoreworICBpbnQgRF8xNDIwOworICBpbnQgYTsKKworICBfX0JCKDIp OgorICBhXzQgPSB+eF8zKEQpOworICBnb3RvIF9fQkI0OworCisgIC8vIExhdGNoLgorICBfX0JC KDMpOgorICBnbG9iYWwgPSBhXzE7CisgIGdvdG8gX19CQjQ7CisKKyAgX19CQig0LGxvb3BfaGVh ZGVyKDEpKToKKyAgYV8xID0gX19QSEkgKF9fQkIyOiBhXzQsIF9fQkIzOiAwKTsKKyAgaWYgKGFf MSAhPSAwKQorICAgIGdvdG8gX19CQjM7CisgIGVsc2UKKyAgICBnb3RvIF9fQkI1OworCisgIF9f QkIoNSk6CisgIHJldHVybjsKKworfQorCisvLyB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAg Ikp1bXBzIHRocmVhZGVkXCIgXCJmb28xXCIgMSIgInN0YXRpc3RpY3MiIH0gfQpkaWZmIC0tZ2l0 IGEvZ2NjL3RyZWUtc3NhLXRocmVhZHVwZGF0ZS5jIGIvZ2NjL3RyZWUtc3NhLXRocmVhZHVwZGF0 ZS5jCmluZGV4IGRjYWJmZGIzMGQyLi4zMmNlMWUzYWY0MCAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUt c3NhLXRocmVhZHVwZGF0ZS5jCisrKyBiL2djYy90cmVlLXNzYS10aHJlYWR1cGRhdGUuYwpAQCAt Mjc2NiwxMCArMjc2NiwxNyBAQCBib29sCiBqdF9wYXRoX3JlZ2lzdHJ5OjpjYW5jZWxfaW52YWxp ZF9wYXRocyAodmVjPGp1bXBfdGhyZWFkX2VkZ2UgKj4gJnBhdGgpCiB7CiAgIGdjY19jaGVja2lu Z19hc3NlcnQgKCFwYXRoLmlzX2VtcHR5ICgpKTsKLSAgZWRnZSB0YWtlbl9lZGdlID0gcGF0aFtw YXRoLmxlbmd0aCAoKSAtIDFdLT5lOwotICBsb29wX3AgbG9vcCA9IHRha2VuX2VkZ2UtPnNyYy0+ bG9vcF9mYXRoZXI7CisgIGVkZ2UgZW50cnkgPSBwYXRoWzBdLT5lOworICBlZGdlIGV4aXQgPSBw YXRoW3BhdGgubGVuZ3RoICgpIC0gMV0tPmU7CiAgIGJvb2wgc2Vlbl9sYXRjaCA9IGZhbHNlOwot ICBib29sIHBhdGhfY3Jvc3Nlc19sb29wcyA9IGZhbHNlOworICBpbnQgbG9vcHNfY3Jvc3NlZCA9 IDA7CisgIGJvb2wgY3Jvc3NlZF9sYXRjaCA9IGZhbHNlOworICAvLyBVc2UgLT5kZXN0IGhlcmUg aW5zdGVhZCBvZiAtPnNyYyB0byBpZ25vcmUgdGhlIGZpcnN0IGJsb2NrLiAgVGhlCisgIC8vIGZp cnN0IGJsb2NrIGlzIGFsbG93ZWQgdG8gYmUgaW4gYSBkaWZmZXJlbnQgbG9vcCwgc2luY2UgaXQn bGwgYmUKKyAgLy8gcmVkaXJlY3RlZC4gIFNlZSBzaW1pbGFyIGNvbW1lbnQgaW4gcHJvZml0YWJs ZV9wYXRoX3A6ICJ3ZSBkb24ndAorICAvLyBjYXJlIGFib3V0IHRoYXQgYmxvY2suLi4iLgorICBs b29wX3AgbG9vcCA9IGVudHJ5LT5kZXN0LT5sb29wX2ZhdGhlcjsKKyAgbG9vcF9wIGN1cnJfbG9v cCA9IGxvb3A7CiAKICAgZm9yICh1bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCBwYXRoLmxlbmd0aCAo KTsgaSsrKQogICAgIHsKQEAgLTI3ODQsMTkgKzI3OTEsMzAgQEAganRfcGF0aF9yZWdpc3RyeTo6 Y2FuY2VsX2ludmFsaWRfcGF0aHMgKHZlYzxqdW1wX3RocmVhZF9lZGdlICo+ICZwYXRoKQogCX0K IAogICAgICAgaWYgKGxvb3AtPmxhdGNoID09IGUtPnNyYyB8fCBsb29wLT5sYXRjaCA9PSBlLT5k ZXN0KQotCXNlZW5fbGF0Y2ggPSB0cnVlOworCXsKKwkgIHNlZW5fbGF0Y2ggPSB0cnVlOworCSAg Ly8gTGlrZSBzZWVuX2xhdGNoLCBidXQgZXhjbHVkZXMgdGhlIGZpcnN0IGJsb2NrLgorCSAgaWYg KGUtPnNyYyAhPSBlbnRyeS0+c3JjKQorCSAgICBjcm9zc2VkX2xhdGNoID0gdHJ1ZTsKKwl9CiAK LSAgICAgIC8vIFRoZSBmaXJzdCBlbnRyeSByZXByZXNlbnRzIHRoZSBibG9jayB3aXRoIGFuIG91 dGdvaW5nIGVkZ2UKLSAgICAgIC8vIHRoYXQgd2Ugd2lsbCByZWRpcmVjdCB0byB0aGUganVtcCB0 aHJlYWRpbmcgcGF0aC4gIFRodXMgd2UKLSAgICAgIC8vIGRvbid0IGNhcmUgYWJvdXQgdGhhdCBi bG9jaydzIGxvb3AgZmF0aGVyLgotICAgICAgaWYgKChpID4gMCAmJiBlLT5zcmMtPmxvb3BfZmF0 aGVyICE9IGxvb3ApCi0JICB8fCBlLT5kZXN0LT5sb29wX2ZhdGhlciAhPSBsb29wKQotCXBhdGhf Y3Jvc3Nlc19sb29wcyA9IHRydWU7CisgICAgICBpZiAoZS0+ZGVzdC0+bG9vcF9mYXRoZXIgIT0g Y3Vycl9sb29wKQorCXsKKwkgIGN1cnJfbG9vcCA9IGUtPmRlc3QtPmxvb3BfZmF0aGVyOworCSAg Kytsb29wc19jcm9zc2VkOworCX0KIAogICAgICAgaWYgKGZsYWdfY2hlY2tpbmcgJiYgIW1fYmFj a2VkZ2VfdGhyZWFkcykKIAlnY2NfYXNzZXJ0ICgocGF0aFtpXS0+ZS0+ZmxhZ3MgJiBFREdFX0RG U19CQUNLKSA9PSAwKTsKICAgICB9CiAKKyAgLy8gSWYgd2UgY3Jvc3NlZCBhIGxvb3AgaW50byBh biBvdXRlciBsb29wIHdpdGhvdXQgY3Jvc3NpbmcgdGhlCisgIC8vIGxhdGNoLCB0aGlzIGlzIGp1 c3QgYW4gZWFybHkgZXhpdCBmcm9tIHRoZSBsb29wLgorICBpZiAobG9vcHNfY3Jvc3NlZCA9PSAx CisgICAgICAmJiAhY3Jvc3NlZF9sYXRjaAorICAgICAgJiYgZmxvd19sb29wX25lc3RlZF9wIChl eGl0LT5kZXN0LT5sb29wX2ZhdGhlciwgZXhpdC0+c3JjLT5sb29wX2ZhdGhlcikpCisgICAgcmV0 dXJuIGZhbHNlOworCiAgIGlmIChjZnVuLT5jdXJyX3Byb3BlcnRpZXMgJiBQUk9QX2xvb3Bfb3B0 c19kb25lKQogICAgIHJldHVybiBmYWxzZTsKIApAQCAtMjgwNiw3ICsyODI0LDcgQEAganRfcGF0 aF9yZWdpc3RyeTo6Y2FuY2VsX2ludmFsaWRfcGF0aHMgKHZlYzxqdW1wX3RocmVhZF9lZGdlICo+ ICZwYXRoKQogCQkgICAgICJ3b3VsZCBjcmVhdGUgbm9uLWVtcHR5IGxhdGNoIik7CiAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICB9Ci0gIGlmIChwYXRoX2Nyb3NzZXNfbG9vcHMpCisgIGlmIChsb29w c19jcm9zc2VkKQogICAgIHsKICAgICAgIGNhbmNlbF90aHJlYWQgKCZwYXRoLCAiUGF0aCBjcm9z c2VzIGxvb3BzIik7CiAgICAgICByZXR1cm4gdHJ1ZTsKLS0gCjIuMzEuMQoK --000000000000056bd305cd9b1534--