From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 34326 invoked by alias); 8 Aug 2019 14:11:53 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 34304 invoked by uid 89); 8 Aug 2019 14:11:52 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-9.3 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_2,GIT_PATCH_3,KAM_ASCII_DIVIDERS,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.1 spammy=builtins.c, UD:builtins.c, builtinsc, H*M:COM X-HELO: EUR02-HE1-obe.outbound.protection.outlook.com Received: from mail-oln040092068044.outbound.protection.outlook.com (HELO EUR02-HE1-obe.outbound.protection.outlook.com) (40.92.68.44) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 08 Aug 2019 14:11:49 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=a9fepw5jrA3BrmXxrn12JT7pokII7sDJ6VTOlgNC2I6a0hNaie09aXScpcLgzeLAXMZ4VP1BI9K6tMWwXT3VY94dqAn7FX/bbNDxn3SQTb0W3/DOoxD380QJUnlBHwt4w2pUWp0OtNK7QcqEZBsbqUoobcTL1aRc5Q88lm2WW9JmWAIYSQ9nPcgVRKfWM4scsW7CmyD289k1v02Z2m8ZQP9cp90uWuWcPWED9r2KymFMQnKy5+AaYNdmvHmG7noTFMOjRT0WdTKLR1DPq6mv95AotDu4qUZhK19HwPnqSxrxDI87+0MuyUDwbuveeEPPvAaMxh++ttMdnAmF/Vh91g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Kn9/SRPOIClPg920uhWW0WjiI36TawYXKFIZUUfj5MA=; b=deaoWLpYiDDhL6gAeC2ae+hRWu5CKD0rrRSPEji7uYNhgSWeV+tJrBK1m0IrAsPcYQY1yaorTLCvBQ7oHj3r/t6TXMN1K840TSbWYrfl73rjylfghQagg51rAQI2z1XZ8MF+EgDTRl8lotNA9EW27CIIweTwGQ5iOgNbEMxtl/spkhlOI4WfIvB0oMhCatdpSO5ZOxyavzahLC6rT5Mk+9+yOCbArUqpPMpyEdlZ0snY0Jy7zi7gEOaxDqH9nEzew/PFkZyn8LK8d4WOyin0biV4ckFhQNJX42eXn7xCJ/TPa+gD/5kgzl2V/Em4O7nqh9AdOn7pP8kHC27WWixChw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none Received: from HE1EUR02FT035.eop-EUR02.prod.protection.outlook.com (10.152.10.59) by HE1EUR02HT211.eop-EUR02.prod.protection.outlook.com (10.152.11.162) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.2157.15; Thu, 8 Aug 2019 14:11:45 +0000 Received: from DB8PR10MB2569.EURPRD10.PROD.OUTLOOK.COM (10.152.10.59) by HE1EUR02FT035.mail.protection.outlook.com (10.152.10.127) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2157.15 via Frontend Transport; Thu, 8 Aug 2019 14:11:45 +0000 Received: from DB8PR10MB2569.EURPRD10.PROD.OUTLOOK.COM ([fe80::d568:f5a6:5afc:c60e]) by DB8PR10MB2569.EURPRD10.PROD.OUTLOOK.COM ([fe80::d568:f5a6:5afc:c60e%7]) with mapi id 15.20.2115.005; Thu, 8 Aug 2019 14:11:45 +0000 From: Bernd Edlinger To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , Richard Earnshaw , Ramana Radhakrishnan , Kyrill Tkachov , Eric Botcazou , Jeff Law , Jakub Jelinek Subject: [PATCHv4] Fix not 8-byte aligned ldrd/strd on ARMv5 (PR 89544) Date: Thu, 08 Aug 2019 14:20:00 -0000 Message-ID: References: In-Reply-To: x-microsoft-original-message-id: x-ms-exchange-transport-forked: True Content-Type: multipart/mixed; boundary="_002_DB8PR10MB2569255E3191B5C7FA70D338E4D70DB8PR10MB2569EURP_" MIME-Version: 1.0 X-SW-Source: 2019-08/txt/msg00548.txt.bz2 --_002_DB8PR10MB2569255E3191B5C7FA70D338E4D70DB8PR10MB2569EURP_ Content-Type: text/plain; charset="Windows-1252" Content-ID: <44FBB457B63F7D42A5E0A57FFD68A410@EURPRD10.PROD.OUTLOOK.COM> Content-Transfer-Encoding: quoted-printable Content-length: 8058 On 8/2/19 9:01 PM, Bernd Edlinger wrote: > On 8/2/19 3:11 PM, Richard Biener wrote: >> On Tue, 30 Jul 2019, Bernd Edlinger wrote: >> >>> >>> I have no test coverage for the movmisalign optab though, so I >>> rely on your code review for that part. >> >> It looks OK. I tried to make it trigger on the following on >> i?86 with -msse2: >> >> typedef int v4si __attribute__((vector_size (16))); >> >> struct S { v4si v; } __attribute__((packed)); >> >> v4si foo (struct S s) >> { >> return s.v; >> } >> >=20 > Hmm, the entry_parm need to be a MEM_P and an unaligned one. > So the test case could be made to trigger it this way: >=20 > typedef int v4si __attribute__((vector_size (16))); >=20 > struct S { v4si v; } __attribute__((packed)); >=20 > int t; > v4si foo (struct S a, struct S b, struct S c, struct S d, > struct S e, struct S f, struct S g, struct S h, > int i, int j, int k, int l, int m, int n, > int o, struct S s) > { > t =3D o; > return s.v; > } >=20 Ah, I realized that there are already a couple of very similar test cases: gcc.target/i386/pr35767-1.c, gcc.target/i386/pr35767-1d.c, gcc.target/i386/pr35767-1i.c and gcc.target/i386/pr39445.c, which also manage to execute the movmisalign code with the latest patch version. So I thought that it is not necessary to add another one. > However the code path is still not reached, since targetm.slow_ualigned_a= ccess > is always FALSE, which is probably a flaw in my patch. >=20 > So I think, >=20 > + else if (MEM_P (data->entry_parm) > + && GET_MODE_ALIGNMENT (promoted_nominal_mode) > + > MEM_ALIGN (data->entry_parm) > + && targetm.slow_unaligned_access (promoted_nominal_mode, > + MEM_ALIGN (data->entry_parm)= )) >=20 > should probably better be >=20 > + else if (MEM_P (data->entry_parm) > + && GET_MODE_ALIGNMENT (promoted_nominal_mode) > + > MEM_ALIGN (data->entry_parm) > + && (((icode =3D optab_handler (movmisalign_optab, promoted_nomin= al_mode)) > + !=3D CODE_FOR_nothing) > + || targetm.slow_unaligned_access (promoted_nominal_mode, > + MEM_ALIGN (data->entry_par= m)))) >=20 > Right? >=20 > Then the modified test case would use the movmisalign optab. > However nothing changes in the end, since the i386 back-end is used to wo= rk > around the middle end not using movmisalign optab when it should do so. >=20 I prefer the second form of the check, as it offers more test coverage, and is probably more correct than the former. Note there are more variations of this misalign check in expr.c, some are somehow odd, like expansion of MEM_REF and VIEW_CONVERT_EXPR: && mode !=3D BLKmode && align < GET_MODE_ALIGNMENT (mode)) { if ((icode =3D optab_handler (movmisalign_optab, mode)) !=3D CODE_FOR_nothing) [...] else if (targetm.slow_unaligned_access (mode, align)) temp =3D extract_bit_field (temp, GET_MODE_BITSIZE (mode), 0, TYPE_UNSIGNED (TREE_TYPE (exp)), (modifier =3D=3D EXPAND_STACK_PARM ? NULL_RTX : target), mode, mode, false, alt_rtl); I wonder if they are correct this way, why shouldn't we use the movmisalign optab if it exists, regardless of TARGET_SLOW_UNALIGNED_ACCESSS ? > I wonder if I should try to add a gcc_checking_assert to the mov ex= pand > patterns that the memory is properly aligned ? > Wow, that was a really exciting bug-hunt with those assertions around... >> @@ -3292,6 +3306,23 @@ assign_parm_setup_reg (struct assign_parm_data_all >> >> did_conversion =3D true; >> } >> + else if (MEM_P (data->entry_parm) >> + && GET_MODE_ALIGNMENT (promoted_nominal_mode) >> + > MEM_ALIGN (data->entry_parm) >> >> we arrive here by-passing >> >> else if (need_conversion) >> { >> /* We did not have an insn to convert directly, or the sequence >> generated appeared unsafe. We must first copy the parm to a >> pseudo reg, and save the conversion until after all >> parameters have been moved. */ >> >> int save_tree_used; >> rtx tempreg =3D gen_reg_rtx (GET_MODE (data->entry_parm)); >> >> emit_move_insn (tempreg, validated_mem); >> >> but this move instruction is invalid in the same way as the case >> you fix, no? So wouldn't it be better to do >> >=20 > We could do that, but I supposed that there must be a reason why > assign_parm_setup_stack gets away with that same: >=20 > if (data->promoted_mode !=3D data->nominal_mode) > { > /* Conversion is required. */ > rtx tempreg =3D gen_reg_rtx (GET_MODE (data->entry_parm)); >=20 > emit_move_insn (tempreg, validize_mem (copy_rtx (data->entry_parm))= ); >=20 >=20 > So either some back-ends are too permissive with us, > or there is a reason why promoted_mode !=3D nominal_mode > does not happen together with unaligned entry_parm. > In a way that would be a rather unusual ABI. >=20 To find out if that ever happens I added a couple of checking assertions in the arm mov expand patterns. So far the assertions did (almost) always hold, so it is likely not necessary to fiddle with all those naive move instructions here. So my gut feeling is, leave those places alone until there is a reason for changing them. However the assertion in movsi triggered a couple times in the ada testsuite due to expand_builtin_init_descriptor using a BLKmode MEM rtx, which is only 8-bit aligned. So, I set the ptr_mode alignment there explicitly. Several struct-layout-1.dg testcase tripped over misaligned complex_cst constants, fixed by varasm.c (align_variable). This is likely a wrong code bug, because misaligned complex constants, are expanded to misaligned MEM_REF, but the expansion cannot handle misaligned constants, only packed structure fields. Furthermore gcc.dg/Warray-bounds-33.c was fixed by the change in expr.c (expand_expr_real_1). Certainly is it invalid to read memory at a function address, but it should not ICE. The problem here, is the MEM_REF has no valid MEM_ALIGN, it looks like A32, so the misaligned code execution is not taken, but it is set to A8 below, but then we hit an ICE if the result is used: /* Don't set memory attributes if the base expression is SSA_NAME that got expanded as a MEM. In that case, we should just honor its original memory attributes. */ if (TREE_CODE (tem) !=3D SSA_NAME || !MEM_P (orig_op0)) set_mem_attributes (op0, exp, 0); Finally gcc.dg/torture/pr48493.c required the change in assign_parm_setup_stack. This is just not using the correct MEM_ALIGN attribute value, while the memory is actually aligned. Note that set_mem_attributes does not always preserve the MEM_ALIGN of the ref, since: /* Default values from pre-existing memory attributes if present. */ refattrs =3D MEM_ATTRS (ref); if (refattrs) { /* ??? Can this ever happen? Calling this routine on a MEM that already carries memory attributes should probably be invalid. */ attrs.expr =3D refattrs->expr; attrs.offset_known_p =3D refattrs->offset_known_p; attrs.offset =3D refattrs->offset; attrs.size_known_p =3D refattrs->size_known_p; attrs.size =3D refattrs->size; attrs.align =3D refattrs->align; } but if we happen to set_mem_align to _exactly_ the MODE_ALIGNMENT the MEM_ATTRS are zero, and a smaller alignment may result. Well with those checks in place it should now be a lot harder to generate invalid code on STRICT_ALIGNMENT targets, without running into an ICE. Attached is the latest version of my arm alignment patch. Boot-strapped and reg-tested on x64_64-pc-linux-gnu and arm-linux-gnueabihf. Is it OK for trunk? Thanks Bernd. --_002_DB8PR10MB2569255E3191B5C7FA70D338E4D70DB8PR10MB2569EURP_ Content-Type: text/x-patch; name="patch-arm-align-abi.diff" Content-Description: patch-arm-align-abi.diff Content-Disposition: attachment; filename="patch-arm-align-abi.diff"; size=12166; creation-date="Thu, 08 Aug 2019 14:11:44 GMT"; modification-date="Thu, 08 Aug 2019 14:11:44 GMT" Content-ID: Content-Transfer-Encoding: base64 Content-length: 16495 MjAxOS0wOC0wNSAgQmVybmQgRWRsaW5nZXIgIDxiZXJuZC5lZGxpbmdlckBo b3RtYWlsLmRlPgoKCVBSIG1pZGRsZS1lbmQvODk1NDQKCSogYnVpbHRpbnMu YyAoZXhwYW5kX2J1aWx0aW5faW5pdF9kZXNjcmlwdG9yKTogU2V0IG1lbW9y eSBhbGlnbm1lbnQuCgkqIGV4cHIuYyAoZXhwYW5kX2V4cHJfcmVhbF8xKTog SGFuZGxlIEZVTkNUSU9OX0RFQ0wgYXMgdW5hbGlnbmVkLgoJKiBmdW5jdGlv bi5jIChhc3NpZ25fcGFybV9maW5kX3N0YWNrX3J0bCk6IFVzZSBsYXJnZXIg YWxpZ25tZW50Cgl3aGVuIHBvc3NpYmxlLgoJKGFzc2lnbl9wYXJtX3NldHVw X3JlZyk6IEhhbmRsZSBtaXNhbGlnbmVkIHN0YWNrIGFyZ3VtZW50cy4KCShh c3NpZ25fcGFybV9zZXR1cF9zdGFjayk6IEFsbG9jYXRlIHByb3Blcmx5IGFs aWduZWQgc3RhY2sgc2xvdHMuCgkqIHZhcmFzbS5jIChhbGlnbl92YXJpYWJs ZSk6IEFsaWduIGNvbnN0YW50cyBvZiBtaXNhbGlnbmVkIHR5cGVzLgoJKiBj b25maWcvYXJtL2FybS5tZCAobW92ZGksIG1vdnNpLCBtb3ZoaSwgbW92aGYs IG1vdnNmLCBtb3ZkZik6IENoZWNrCglzdHJpY3QgYWxpZ25tZW50IHJlc3Ry aWN0aW9ucyBvbiBtZW1vcnkgYWRkcmVzc2VzLgoJKiBjb25maWcvYXJtL25l b24ubWQgKG1vdnRpLCBtb3Y8VlNUUlVDVD4sIG1vdjxWSD4pOiBMaWtld2lz ZS4KCSogY29uZmlnL2FybS92ZWMtY29tbW9uLm1kIChtb3Y8VkFMTD4pOiBM aWtld2lzZS4KCnRlc3RzdWl0ZToKMjAxOS0wOC0wNSAgQmVybmQgRWRsaW5n ZXIgIDxiZXJuZC5lZGxpbmdlckBob3RtYWlsLmRlPgoKCVBSIG1pZGRsZS1l bmQvODk1NDQKCSogZ2NjLnRhcmdldC9hcm0vdW5hbGlnbmVkLWFyZ3VtZW50 LTEuYzogTmV3IHRlc3QuCgkqIGdjYy50YXJnZXQvYXJtL3VuYWxpZ25lZC1h cmd1bWVudC0yLmM6IE5ldyB0ZXN0LgoKSW5kZXg6IGdjYy9idWlsdGlucy5j Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGdjYy9idWlsdGlucy5jCShy ZXZpc2lvbiAyNzQxNjgpCisrKyBnY2MvYnVpbHRpbnMuYwkod29ya2luZyBj b3B5KQpAQCAtNTc1Niw2ICs1NzU2LDcgQEAgZXhwYW5kX2J1aWx0aW5faW5p dF9kZXNjcmlwdG9yICh0cmVlIGV4cCkKICAgcl9kZXNjciA9IGV4cGFuZF9u b3JtYWwgKHRfZGVzY3IpOwogICBtX2Rlc2NyID0gZ2VuX3J0eF9NRU0gKEJM S21vZGUsIHJfZGVzY3IpOwogICBNRU1fTk9UUkFQX1AgKG1fZGVzY3IpID0g MTsKKyAgc2V0X21lbV9hbGlnbiAobV9kZXNjciwgR0VUX01PREVfQUxJR05N RU5UIChwdHJfbW9kZSkpOwogCiAgIHJfZnVuYyA9IGV4cGFuZF9ub3JtYWwg KHRfZnVuYyk7CiAgIHJfY2hhaW4gPSBleHBhbmRfbm9ybWFsICh0X2NoYWlu KTsKSW5kZXg6IGdjYy9jb25maWcvYXJtL2FybS5tZAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBnY2MvY29uZmlnL2FybS9hcm0ubWQJKHJldmlzaW9u IDI3NDE2OCkKKysrIGdjYy9jb25maWcvYXJtL2FybS5tZAkod29ya2luZyBj b3B5KQpAQCAtNTgyNCw2ICs1ODI0LDEyIEBACiAJKG1hdGNoX29wZXJhbmQ6 REkgMSAiZ2VuZXJhbF9vcGVyYW5kIikpXQogICAiVEFSR0VUX0VJVEhFUiIK ICAgIgorICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1AgKG9wZXJhbmRz WzBdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5kc1swXSkKKwkJ CSAgPj0gR0VUX01PREVfQUxJR05NRU5UIChESW1vZGUpKTsKKyAgZ2NjX2No ZWNraW5nX2Fzc2VydCAoIU1FTV9QIChvcGVyYW5kc1sxXSkKKwkJICAgICAg IHx8IE1FTV9BTElHTiAob3BlcmFuZHNbMV0pCisJCQkgID49IEdFVF9NT0RF X0FMSUdOTUVOVCAoREltb2RlKSk7CiAgIGlmIChjYW5fY3JlYXRlX3BzZXVk b19wICgpKQogICAgIHsKICAgICAgIGlmICghUkVHX1AgKG9wZXJhbmRzWzBd KSkKQEAgLTYwMDAsNiArNjAwNiwxMiBAQAogICB7CiAgIHJ0eCBiYXNlLCBv ZmZzZXQsIHRtcDsKIAorICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1Ag KG9wZXJhbmRzWzBdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5k c1swXSkKKwkJCSAgPj0gR0VUX01PREVfQUxJR05NRU5UIChTSW1vZGUpKTsK KyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoIU1FTV9QIChvcGVyYW5kc1sxXSkK KwkJICAgICAgIHx8IE1FTV9BTElHTiAob3BlcmFuZHNbMV0pCisJCQkgID49 IEdFVF9NT0RFX0FMSUdOTUVOVCAoU0ltb2RlKSk7CiAgIGlmIChUQVJHRVRf MzJCSVQgfHwgVEFSR0VUX0hBVkVfTU9WVCkKICAgICB7CiAgICAgICAvKiBF dmVyeXRoaW5nIGV4Y2VwdCBtZW0gPSBjb25zdCBvciBtZW0gPSBtZW0gY2Fu IGJlIGRvbmUgZWFzaWx5LiAgKi8KQEAgLTY0ODksNiArNjUwMSwxMiBAQAog CShtYXRjaF9vcGVyYW5kOkhJIDEgImdlbmVyYWxfb3BlcmFuZCIpKV0KICAg IlRBUkdFVF9FSVRIRVIiCiAgICIKKyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAo IU1FTV9QIChvcGVyYW5kc1swXSkKKwkJICAgICAgIHx8IE1FTV9BTElHTiAo b3BlcmFuZHNbMF0pCisJCQkgID49IEdFVF9NT0RFX0FMSUdOTUVOVCAoSElt b2RlKSk7CisgIGdjY19jaGVja2luZ19hc3NlcnQgKCFNRU1fUCAob3BlcmFu ZHNbMV0pCisJCSAgICAgICB8fCBNRU1fQUxJR04gKG9wZXJhbmRzWzFdKQor CQkJICA+PSBHRVRfTU9ERV9BTElHTk1FTlQgKEhJbW9kZSkpOwogICBpZiAo VEFSR0VUX0FSTSkKICAgICB7CiAgICAgICBpZiAoY2FuX2NyZWF0ZV9wc2V1 ZG9fcCAoKSkKQEAgLTY4OTgsNiArNjkxNiwxMiBAQAogCShtYXRjaF9vcGVy YW5kOkhGIDEgImdlbmVyYWxfb3BlcmFuZCIpKV0KICAgIlRBUkdFVF9FSVRI RVIiCiAgICIKKyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoIU1FTV9QIChvcGVy YW5kc1swXSkKKwkJICAgICAgIHx8IE1FTV9BTElHTiAob3BlcmFuZHNbMF0p CisJCQkgID49IEdFVF9NT0RFX0FMSUdOTUVOVCAoSEZtb2RlKSk7CisgIGdj Y19jaGVja2luZ19hc3NlcnQgKCFNRU1fUCAob3BlcmFuZHNbMV0pCisJCSAg ICAgICB8fCBNRU1fQUxJR04gKG9wZXJhbmRzWzFdKQorCQkJICA+PSBHRVRf TU9ERV9BTElHTk1FTlQgKEhGbW9kZSkpOwogICBpZiAoVEFSR0VUXzMyQklU KQogICAgIHsKICAgICAgIGlmIChNRU1fUCAob3BlcmFuZHNbMF0pKQpAQCAt Njk2Miw2ICs2OTg2LDEyIEBACiAJKG1hdGNoX29wZXJhbmQ6U0YgMSAiZ2Vu ZXJhbF9vcGVyYW5kIikpXQogICAiVEFSR0VUX0VJVEhFUiIKICAgIgorICBn Y2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1AgKG9wZXJhbmRzWzBdKQorCQkg ICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5kc1swXSkKKwkJCSAgPj0gR0VU X01PREVfQUxJR05NRU5UIChTRm1vZGUpKTsKKyAgZ2NjX2NoZWNraW5nX2Fz c2VydCAoIU1FTV9QIChvcGVyYW5kc1sxXSkKKwkJICAgICAgIHx8IE1FTV9B TElHTiAob3BlcmFuZHNbMV0pCisJCQkgID49IEdFVF9NT0RFX0FMSUdOTUVO VCAoU0Ztb2RlKSk7CiAgIGlmIChUQVJHRVRfMzJCSVQpCiAgICAgewogICAg ICAgaWYgKE1FTV9QIChvcGVyYW5kc1swXSkpCkBAIC03MDU3LDYgKzcwODcs MTIgQEAKIAkobWF0Y2hfb3BlcmFuZDpERiAxICJnZW5lcmFsX29wZXJhbmQi KSldCiAgICJUQVJHRVRfRUlUSEVSIgogICAiCisgIGdjY19jaGVja2luZ19h c3NlcnQgKCFNRU1fUCAob3BlcmFuZHNbMF0pCisJCSAgICAgICB8fCBNRU1f QUxJR04gKG9wZXJhbmRzWzBdKQorCQkJICA+PSBHRVRfTU9ERV9BTElHTk1F TlQgKERGbW9kZSkpOworICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1Ag KG9wZXJhbmRzWzFdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5k c1sxXSkKKwkJCSAgPj0gR0VUX01PREVfQUxJR05NRU5UIChERm1vZGUpKTsK ICAgaWYgKFRBUkdFVF8zMkJJVCkKICAgICB7CiAgICAgICBpZiAoTUVNX1Ag KG9wZXJhbmRzWzBdKSkKSW5kZXg6IGdjYy9jb25maWcvYXJtL25lb24ubWQK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gZ2NjL2NvbmZpZy9hcm0vbmVv bi5tZAkocmV2aXNpb24gMjc0MTY4KQorKysgZ2NjL2NvbmZpZy9hcm0vbmVv bi5tZAkod29ya2luZyBjb3B5KQpAQCAtMTI3LDYgKzEyNywxMiBAQAogCSht YXRjaF9vcGVyYW5kOlRJIDEgImdlbmVyYWxfb3BlcmFuZCIpKV0KICAgIlRB UkdFVF9ORU9OIgogeworICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1Ag KG9wZXJhbmRzWzBdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5k c1swXSkKKwkJCSAgPj0gR0VUX01PREVfQUxJR05NRU5UIChUSW1vZGUpKTsK KyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoIU1FTV9QIChvcGVyYW5kc1sxXSkK KwkJICAgICAgIHx8IE1FTV9BTElHTiAob3BlcmFuZHNbMV0pCisJCQkgID49 IEdFVF9NT0RFX0FMSUdOTUVOVCAoVEltb2RlKSk7CiAgIGlmIChjYW5fY3Jl YXRlX3BzZXVkb19wICgpKQogICAgIHsKICAgICAgIGlmICghUkVHX1AgKG9w ZXJhbmRzWzBdKSkKQEAgLTEzOSw2ICsxNDUsMTIgQEAKIAkobWF0Y2hfb3Bl cmFuZDpWU1RSVUNUIDEgImdlbmVyYWxfb3BlcmFuZCIpKV0KICAgIlRBUkdF VF9ORU9OIgogeworICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1AgKG9w ZXJhbmRzWzBdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5kc1sw XSkKKwkJCSAgPj0gR0VUX01PREVfQUxJR05NRU5UICg8TU9ERT5tb2RlKSk7 CisgIGdjY19jaGVja2luZ19hc3NlcnQgKCFNRU1fUCAob3BlcmFuZHNbMV0p CisJCSAgICAgICB8fCBNRU1fQUxJR04gKG9wZXJhbmRzWzFdKQorCQkJICA+ PSBHRVRfTU9ERV9BTElHTk1FTlQgKDxNT0RFPm1vZGUpKTsKICAgaWYgKGNh bl9jcmVhdGVfcHNldWRvX3AgKCkpCiAgICAgewogICAgICAgaWYgKCFSRUdf UCAob3BlcmFuZHNbMF0pKQpAQCAtMTUxLDYgKzE2MywxMiBAQAogCShtYXRj aF9vcGVyYW5kOlZIIDEgInNfcmVnaXN0ZXJfb3BlcmFuZCIpKV0KICAgIlRB UkdFVF9ORU9OIgogeworICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1Ag KG9wZXJhbmRzWzBdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5k c1swXSkKKwkJCSAgPj0gR0VUX01PREVfQUxJR05NRU5UICg8TU9ERT5tb2Rl KSk7CisgIGdjY19jaGVja2luZ19hc3NlcnQgKCFNRU1fUCAob3BlcmFuZHNb MV0pCisJCSAgICAgICB8fCBNRU1fQUxJR04gKG9wZXJhbmRzWzFdKQorCQkJ ICA+PSBHRVRfTU9ERV9BTElHTk1FTlQgKDxNT0RFPm1vZGUpKTsKICAgaWYg KGNhbl9jcmVhdGVfcHNldWRvX3AgKCkpCiAgICAgewogICAgICAgaWYgKCFS RUdfUCAob3BlcmFuZHNbMF0pKQpJbmRleDogZ2NjL2NvbmZpZy9hcm0vdmVj LWNvbW1vbi5tZAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBnY2MvY29u ZmlnL2FybS92ZWMtY29tbW9uLm1kCShyZXZpc2lvbiAyNzQxNjgpCisrKyBn Y2MvY29uZmlnL2FybS92ZWMtY29tbW9uLm1kCSh3b3JraW5nIGNvcHkpCkBA IC0yNiw2ICsyNiwxMiBAQAogICAiVEFSR0VUX05FT04KICAgIHx8IChUQVJH RVRfUkVBTExZX0lXTU1YVCAmJiBWQUxJRF9JV01NWFRfUkVHX01PREUgKDxN T0RFPm1vZGUpKSIKIHsKKyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoIU1FTV9Q IChvcGVyYW5kc1swXSkKKwkJICAgICAgIHx8IE1FTV9BTElHTiAob3BlcmFu ZHNbMF0pCisJCQkgID49IEdFVF9NT0RFX0FMSUdOTUVOVCAoPE1PREU+bW9k ZSkpOworICBnY2NfY2hlY2tpbmdfYXNzZXJ0ICghTUVNX1AgKG9wZXJhbmRz WzFdKQorCQkgICAgICAgfHwgTUVNX0FMSUdOIChvcGVyYW5kc1sxXSkKKwkJ CSAgPj0gR0VUX01PREVfQUxJR05NRU5UICg8TU9ERT5tb2RlKSk7CiAgIGlm IChjYW5fY3JlYXRlX3BzZXVkb19wICgpKQogICAgIHsKICAgICAgIGlmICgh UkVHX1AgKG9wZXJhbmRzWzBdKSkKSW5kZXg6IGdjYy9leHByLmMKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gZ2NjL2V4cHIuYwkocmV2aXNpb24gMjc0 MTY4KQorKysgZ2NjL2V4cHIuYwkod29ya2luZyBjb3B5KQpAQCAtMTA3OTYs NiArMTA3OTYsMTQgQEAgZXhwYW5kX2V4cHJfcmVhbF8xICh0cmVlIGV4cCwg cnR4IHRhcmdldCwgbWFjaGluZV8KIAkgICAgTUVNX1ZPTEFUSUxFX1AgKG9w MCkgPSAxOwogCSAgfQogCisJaWYgKE1FTV9QIChvcDApICYmIFRSRUVfQ09E RSAodGVtKSA9PSBGVU5DVElPTl9ERUNMKQorCSAgeworCSAgICBpZiAob3Aw ID09IG9yaWdfb3AwKQorCSAgICAgIG9wMCA9IGNvcHlfcnR4IChvcDApOwor CisJICAgIHNldF9tZW1fYWxpZ24gKG9wMCwgQklUU19QRVJfVU5JVCk7CisJ ICB9CisKIAkvKiBJbiBjYXNlcyB3aGVyZSBhbiBhbGlnbmVkIHVuaW9uIGhh cyBhbiB1bmFsaWduZWQgb2JqZWN0CiAJICAgYXMgYSBmaWVsZCwgd2UgbWln aHQgYmUgZXh0cmFjdGluZyBhIEJMS21vZGUgdmFsdWUgZnJvbQogCSAgIGFu IGludGVnZXItbW9kZSAoZS5nLiwgU0ltb2RlKSBvYmplY3QuICBIYW5kbGUg dGhpcyBjYXNlCkluZGV4OiBnY2MvZnVuY3Rpb24uYwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBnY2MvZnVuY3Rpb24uYwkocmV2aXNpb24gMjc0MTY4 KQorKysgZ2NjL2Z1bmN0aW9uLmMJKHdvcmtpbmcgY29weSkKQEAgLTI2OTcs OCArMjY5NywyMyBAQCBhc3NpZ25fcGFybV9maW5kX3N0YWNrX3J0bCAodHJl ZSBwYXJtLCBzdHJ1Y3QgYXNzaQogICAgICBpbnRlbnRpb25hbGx5IGZvcmNp bmcgdXB3YXJkIHBhZGRpbmcuICBPdGhlcndpc2Ugd2UgaGF2ZSB0byBjb21l CiAgICAgIHVwIHdpdGggYSBndWVzcyBhdCB0aGUgYWxpZ25tZW50IGJhc2Vk IG9uIE9GRlNFVF9SVFguICAqLwogICBwb2x5X2ludDY0IG9mZnNldDsKLSAg aWYgKGRhdGEtPmxvY2F0ZS53aGVyZV9wYWQgIT0gUEFEX0RPV05XQVJEIHx8 IGRhdGEtPmVudHJ5X3Bhcm0pCisgIGlmIChkYXRhLT5sb2NhdGUud2hlcmVf cGFkID09IFBBRF9OT05FIHx8IGRhdGEtPmVudHJ5X3Bhcm0pCiAgICAgYWxp Z24gPSBib3VuZGFyeTsKKyAgZWxzZSBpZiAoZGF0YS0+bG9jYXRlLndoZXJl X3BhZCA9PSBQQURfVVBXQVJEKQorICAgIHsKKyAgICAgIGFsaWduID0gYm91 bmRhcnk7CisgICAgICAvKiBJZiB0aGUgYXJndW1lbnQgb2Zmc2V0IGlzIGFj dHVhbGx5IG1vcmUgYWxpZ25lZCB0aGFuIHRoZSBub21pbmFsCisJIHN0YWNr IHNsb3QgYm91bmRhcnksIHRha2UgYWR2YW50YWdlIG9mIHRoYXQgZXhjZXNz IGFsaWdubWVudC4KKwkgRG9uJ3QgbWFrZSBhbnkgYXNzdW1wdGlvbnMgaWYg U1RBQ0tfUE9JTlRFUl9PRkZTRVQgaXMgaW4gdXNlLiAgKi8KKyAgICAgIGlm IChwb2x5X2ludF9ydHhfcCAob2Zmc2V0X3J0eCwgJm9mZnNldCkKKwkgICYm IFNUQUNLX1BPSU5URVJfT0ZGU0VUID09IDApCisJeworCSAgdW5zaWduZWQg aW50IG9mZnNldF9hbGlnbiA9IGtub3duX2FsaWdubWVudCAob2Zmc2V0KSAq IEJJVFNfUEVSX1VOSVQ7CisJICBpZiAob2Zmc2V0X2FsaWduID09IDAgfHwg b2Zmc2V0X2FsaWduID4gU1RBQ0tfQk9VTkRBUlkpCisJICAgIG9mZnNldF9h bGlnbiA9IFNUQUNLX0JPVU5EQVJZOworCSAgYWxpZ24gPSBNQVggKGFsaWdu LCBvZmZzZXRfYWxpZ24pOworCX0KKyAgICB9CiAgIGVsc2UgaWYgKHBvbHlf aW50X3J0eF9wIChvZmZzZXRfcnR4LCAmb2Zmc2V0KSkKICAgICB7CiAgICAg ICBhbGlnbiA9IGxlYXN0X2JpdF9od2kgKGJvdW5kYXJ5KTsKQEAgLTMxMjcs NiArMzE0Miw3IEBAIGFzc2lnbl9wYXJtX3NldHVwX3JlZyAoc3RydWN0IGFz c2lnbl9wYXJtX2RhdGFfYWxsCiAgIGludCB1bnNpZ25lZHAgPSBUWVBFX1VO U0lHTkVEIChUUkVFX1RZUEUgKHBhcm0pKTsKICAgYm9vbCBkaWRfY29udmVy c2lvbiA9IGZhbHNlOwogICBib29sIG5lZWRfY29udmVyc2lvbiwgbW92ZWQ7 CisgIGVudW0gaW5zbl9jb2RlIGljb2RlOwogICBydHggcnRsOwogCiAgIC8q IFN0b3JlIHRoZSBwYXJtIGluIGEgcHNldWRvcmVnaXN0ZXIgZHVyaW5nIHRo ZSBmdW5jdGlvbiwgYnV0IHdlIG1heQpAQCAtMzE4OCw3ICszMjA0LDYgQEAg YXNzaWduX3Bhcm1fc2V0dXBfcmVnIChzdHJ1Y3QgYXNzaWduX3Bhcm1fZGF0 YV9hbGwKIAkgY29udmVyc2lvbi4gIFdlIHZlcmlmeSB0aGF0IHRoaXMgaW5z biBkb2VzIG5vdCBjbG9iYmVyIGFueQogCSBoYXJkIHJlZ2lzdGVycy4gICov CiAKLSAgICAgIGVudW0gaW5zbl9jb2RlIGljb2RlOwogICAgICAgcnR4IG9w MCwgb3AxOwogCiAgICAgICBpY29kZSA9IGNhbl9leHRlbmRfcCAocHJvbW90 ZWRfbm9taW5hbF9tb2RlLCBkYXRhLT5wYXNzZWRfbW9kZSwKQEAgLTMyOTEs NiArMzMwNiwyMyBAQCBhc3NpZ25fcGFybV9zZXR1cF9yZWcgKHN0cnVjdCBh c3NpZ25fcGFybV9kYXRhX2FsbAogCiAgICAgICBkaWRfY29udmVyc2lvbiA9 IHRydWU7CiAgICAgfQorICBlbHNlIGlmIChNRU1fUCAoZGF0YS0+ZW50cnlf cGFybSkKKwkgICAmJiBHRVRfTU9ERV9BTElHTk1FTlQgKHByb21vdGVkX25v bWluYWxfbW9kZSkKKwkgICAgICA+IE1FTV9BTElHTiAoZGF0YS0+ZW50cnlf cGFybSkKKwkgICAmJiAoKChpY29kZSA9IG9wdGFiX2hhbmRsZXIgKG1vdm1p c2FsaWduX29wdGFiLAorCQkJCQlwcm9tb3RlZF9ub21pbmFsX21vZGUpKQor CQkhPSBDT0RFX0ZPUl9ub3RoaW5nKQorCSAgICAgICB8fCB0YXJnZXRtLnNs b3dfdW5hbGlnbmVkX2FjY2VzcyAocHJvbW90ZWRfbm9taW5hbF9tb2RlLAor CQkJCQkJIE1FTV9BTElHTiAoZGF0YS0+ZW50cnlfcGFybSkpKSkKKyAgICB7 CisgICAgICBpZiAoaWNvZGUgIT0gQ09ERV9GT1Jfbm90aGluZykKKwllbWl0 X2luc24gKEdFTl9GQ04gKGljb2RlKSAocGFybXJlZywgdmFsaWRhdGVkX21l bSkpOworICAgICAgZWxzZQorCXJ0bCA9IHBhcm1yZWcgPSBleHRyYWN0X2Jp dF9maWVsZCAodmFsaWRhdGVkX21lbSwKKwkJCUdFVF9NT0RFX0JJVFNJWkUg KHByb21vdGVkX25vbWluYWxfbW9kZSksIDAsCisJCQl1bnNpZ25lZHAsIHBh cm1yZWcsCisJCQlwcm9tb3RlZF9ub21pbmFsX21vZGUsIFZPSURtb2RlLCBm YWxzZSwgTlVMTCk7CisgICAgfQogICBlbHNlCiAgICAgZW1pdF9tb3ZlX2lu c24gKHBhcm1yZWcsIHZhbGlkYXRlZF9tZW0pOwogCkBAIC0zNDQ5LDExICsz NDgxLDE3IEBAIGFzc2lnbl9wYXJtX3NldHVwX3N0YWNrIChzdHJ1Y3QgYXNz aWduX3Bhcm1fZGF0YV9hCiAJICBpbnQgYWxpZ24gPSBTVEFDS19TTE9UX0FM SUdOTUVOVCAoZGF0YS0+cGFzc2VkX3R5cGUsCiAJCQkJCSAgICBHRVRfTU9E RSAoZGF0YS0+ZW50cnlfcGFybSksCiAJCQkJCSAgICBUWVBFX0FMSUdOIChk YXRhLT5wYXNzZWRfdHlwZSkpOworCSAgaWYgKGFsaWduIDwgKGludClHRVRf TU9ERV9BTElHTk1FTlQgKEdFVF9NT0RFIChkYXRhLT5lbnRyeV9wYXJtKSkK KwkgICAgICAmJiB0YXJnZXRtLnNsb3dfdW5hbGlnbmVkX2FjY2VzcyAoR0VU X01PREUgKGRhdGEtPmVudHJ5X3Bhcm0pLAorCQkJCQkJYWxpZ24pKQorCSAg ICBhbGlnbiA9IEdFVF9NT0RFX0FMSUdOTUVOVCAoR0VUX01PREUgKGRhdGEt PmVudHJ5X3Bhcm0pKTsKIAkgIGRhdGEtPnN0YWNrX3Bhcm0KIAkgICAgPSBh c3NpZ25fc3RhY2tfbG9jYWwgKEdFVF9NT0RFIChkYXRhLT5lbnRyeV9wYXJt KSwKIAkJCQkgIEdFVF9NT0RFX1NJWkUgKEdFVF9NT0RFIChkYXRhLT5lbnRy eV9wYXJtKSksCiAJCQkJICBhbGlnbik7CisJICBhbGlnbiA9IE1FTV9BTElH TiAoZGF0YS0+c3RhY2tfcGFybSk7CiAJICBzZXRfbWVtX2F0dHJpYnV0ZXMg KGRhdGEtPnN0YWNrX3Bhcm0sIHBhcm0sIDEpOworCSAgc2V0X21lbV9hbGln biAoZGF0YS0+c3RhY2tfcGFybSwgYWxpZ24pOwogCX0KIAogICAgICAgZGVz dCA9IHZhbGlkaXplX21lbSAoY29weV9ydHggKGRhdGEtPnN0YWNrX3Bhcm0p KTsKSW5kZXg6IGdjYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vdW5hbGln bmVkLWFyZ3VtZW50LTEuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBn Y2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYXJtL3VuYWxpZ25lZC1hcmd1bWVu dC0xLmMJKHJldmlzaW9uIDApCisrKyBnY2MvdGVzdHN1aXRlL2djYy50YXJn ZXQvYXJtL3VuYWxpZ25lZC1hcmd1bWVudC0xLmMJKHdvcmtpbmcgY29weSkK QEAgLTAsMCArMSwxOSBAQAorLyogeyBkZy1kbyBjb21waWxlIH0gKi8KKy8q IHsgZGctcmVxdWlyZS1lZmZlY3RpdmUtdGFyZ2V0IGFybV9hcm1fb2sgfSAq LworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgYXJtX2xkcmRf c3RyZF9vayB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1tYXJtIC1tbm8tdW5h bGlnbmVkLWFjY2VzcyAtTzMiIH0gKi8KKworc3RydWN0IHMgeworICBpbnQg YSwgYjsKK30gX19hdHRyaWJ1dGVfXygoYWxpZ25lZCg4KSkpOworCitzdHJ1 Y3QgcyBmMDsKKwordm9pZCBmKGludCBhLCBpbnQgYiwgaW50IGMsIGludCBk LCBzdHJ1Y3QgcyBmKQoreworICBmMCA9IGY7Cit9CisKKy8qIHsgZGctZmlu YWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyAibGRyZCIgMSB9IH0gKi8KKy8q IHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyAic3RyZCIgMSB9 IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyAi c3RtIiAwIH0gfSAqLwpJbmRleDogZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0 L2FybS91bmFsaWduZWQtYXJndW1lbnQtMi5jCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIGdjYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vdW5hbGln bmVkLWFyZ3VtZW50LTIuYwkocmV2aXNpb24gMCkKKysrIGdjYy90ZXN0c3Vp dGUvZ2NjLnRhcmdldC9hcm0vdW5hbGlnbmVkLWFyZ3VtZW50LTIuYwkod29y a2luZyBjb3B5KQpAQCAtMCwwICsxLDE5IEBACisvKiB7IGRnLWRvIGNvbXBp bGUgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgYXJt X2FybV9vayB9ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdl dCBhcm1fbGRyZF9zdHJkX29rIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLW1h cm0gLW1uby11bmFsaWduZWQtYWNjZXNzIC1PMyIgfSAqLworCitzdHJ1Y3Qg cyB7CisgIGludCBhLCBiOworfSBfX2F0dHJpYnV0ZV9fKChhbGlnbmVkKDgp KSk7CisKK3N0cnVjdCBzIGYwOworCit2b2lkIGYoaW50IGEsIGludCBiLCBp bnQgYywgaW50IGQsIGludCBlLCBzdHJ1Y3QgcyBmKQoreworICBmMCA9IGY7 Cit9CisKKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyAi bGRyZCIgMCB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxl ci10aW1lcyAic3RyZCIgMCB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2Fu LWFzc2VtYmxlci10aW1lcyAic3RtIiAxIH0gfSAqLwpJbmRleDogZ2NjL3Zh cmFzbS5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGdjYy92YXJhc20u YwkocmV2aXNpb24gMjc0MTY4KQorKysgZ2NjL3ZhcmFzbS5jCSh3b3JraW5n IGNvcHkpCkBAIC0xMDg1LDYgKzEwODUsMTAgQEAgYWxpZ25fdmFyaWFibGUg KHRyZWUgZGVjbCwgYm9vbCBkb250X291dHB1dF9kYXRhKQogCX0KICAgICB9 CiAKKyAgaWYgKGFsaWduIDwgR0VUX01PREVfQUxJR05NRU5UIChERUNMX01P REUgKGRlY2wpKQorICAgICAgJiYgdGFyZ2V0bS5zbG93X3VuYWxpZ25lZF9h Y2Nlc3MgKERFQ0xfTU9ERSAoZGVjbCksIGFsaWduKSkKKyAgICBhbGlnbiA9 IEdFVF9NT0RFX0FMSUdOTUVOVCAoREVDTF9NT0RFIChkZWNsKSk7CisKICAg LyogUmVzZXQgdGhlIGFsaWdubWVudCBpbiBjYXNlIHdlIGhhdmUgbWFkZSBp dCB0aWdodGVyLCBzbyB3ZSBjYW4gYmVuZWZpdAogICAgICBmcm9tIGl0IGlu IGdldF9wb2ludGVyX2FsaWdubWVudC4gICovCiAgIFNFVF9ERUNMX0FMSUdO IChkZWNsLCBhbGlnbik7Cg== --_002_DB8PR10MB2569255E3191B5C7FA70D338E4D70DB8PR10MB2569EURP_--