From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05on2082.outbound.protection.outlook.com [40.107.22.82]) by sourceware.org (Postfix) with ESMTPS id BB8AE3858C62 for ; Mon, 28 Nov 2022 12:13:45 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org BB8AE3858C62 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=YgKUdh8SHa7NhUaUO/IfDR6kpTyIxUDQ3WbPc8OvPOZLT4jDxkkjbHFCKj232C52Jr/zOu91Okitk7+6FtFH0VAauFCaZPjBqYC3pHHxFBqSz387MNoF9UT7Fj8lZZiCcM9YgpJLApfnVHT+IGE7w/u50TaZ/fnQquZ58xlpgkWhmntTMY7aetk5YQliLthxRHZjKJA4Sef4jaVyLx5cgqd9L8okIvZDL8nSIcDEgehivDE+nHOnMl3lgmx/qmMZxyQn+hgUDqHomuVhxZKnTrtF5O/ox80dsXdaEebV+81LYAKVQsjipmpuCNUnAeFQI/I2whBmIssm5S6IqUbqLg== 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-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=GGApx4xnJgHIqeSe2sBdy/HCOO3uGKsAMuMOgBQErDM=; b=QtdepavnRw0Oq9g2c9Ljjg1XjBjSkGAkKxX1x1TRwM1PG6puFweINYnVbozjdfsNlwb+XWnBQFrJhYDjFUy1TIa7RM3kExkZZwjLVDNO93g+r9c6xlhzVUsIqDQRaBqYFS6ixrxzQrT6rOGFjxLmkfBbqXFjMRMKGqs5JuN3ltt3Af0XezlzlOD2RFA0BPS8d4t91Y+80EDOZRzW5ZyO0GzjaCoDBlyL9lV5y2J8JfwVGIzR4XNlpb4081/lwygutA44DTd+bqaKaB4qCpQWGzBiIoGnzelrisJ753pRRIk7lQFYZ6i1Py+kdv/v9sJkbTdSHZ95dQjLMroCnnm6Hg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=GGApx4xnJgHIqeSe2sBdy/HCOO3uGKsAMuMOgBQErDM=; b=v8c1eYBleIxCPnEcAKGFkT3hoJVZkmRxd+8cBZ71Al5wHjmrz3vYMoeK1DZNJxyl9PPT/FnCpuS1kLsEOIKPm8+ha3GMUxdAdCumKFzXB6rG2Zx7DjmF8oxRUY/7lUVm6iLo+7Ty6i3qzqO05yfMEeCckJF+pLcM6CWDmjC1qxk= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; Received: from DB9PR08MB6507.eurprd08.prod.outlook.com (2603:10a6:10:25a::6) by PA4PR08MB6191.eurprd08.prod.outlook.com (2603:10a6:102:f3::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5880.8; Mon, 28 Nov 2022 12:13:42 +0000 Received: from DB9PR08MB6507.eurprd08.prod.outlook.com ([fe80::a98d:81cd:e426:fd21]) by DB9PR08MB6507.eurprd08.prod.outlook.com ([fe80::a98d:81cd:e426:fd21%8]) with mapi id 15.20.5880.008; Mon, 28 Nov 2022 12:13:41 +0000 Content-Type: multipart/mixed; boundary="------------iBHKydoUu52nOf9uk3gvNMaX" Message-ID: Date: Mon, 28 Nov 2022 12:13:22 +0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.5.0 Subject: [PATCH 2/2] arm: Add support for MVE Tail-Predicated Low Overhead Loops To: "Andre Vieira (lists)" , gcc-patches@gcc.gnu.org References: <212ceca7-21f7-7d99-9543-9e39d9056aba@arm.com> Content-Language: en-US From: Stam Markianos-Wright In-Reply-To: X-ClientProxiedBy: SA0PR11CA0037.namprd11.prod.outlook.com (2603:10b6:806:d0::12) To DB9PR08MB6507.eurprd08.prod.outlook.com (2603:10a6:10:25a::6) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DB9PR08MB6507:EE_|PA4PR08MB6191:EE_ X-MS-Office365-Filtering-Correlation-Id: cbc2606c-815b-4206-8b76-08dad139fc40 NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: yT0B6UEGRWVRxW2d31h3CMhW+9V052wX1Wr0mR46gd3fs7WBcJEam546JXQPyjuaWZ2BTFvl6XfieUpH3QFEGw1FdwRE7ozx9DLybGHkdQXGqOecsRUIHqKgbj9nsjYC+VUlF+KhIQM1rs6XY3xwGejb5ddaZ3eyywKccSx5Upk6qnYEx1pGvialMbiojZwv8nOqRVc+1OQCUl5TGUfu1jCiWRmj0dk6Xh1/GZ7RV4QoWpkD/uu09m+v8D7U0K5bDR+4lHyG/a1jFLnatOKTLK6e585tRgqYX6fcGA+/6M1+MC31eim7MjTT+NptI344Ten23paNgODCv03L7LEG55Ec0PVRQ72ESjafvb1WkQugpjh3S1QP+Ds4er4KZFqr9k7C2DzKoWLcRBXtJw4jikPmnYnz4vuGgvw/zTgTgyGIqL8okmRpNilDvY3oOPd3v2yt5SOHzbFnoWhSnDRjF+kxJeot35qtSrl4c2vmPd1dB9B4VKovBCpdqIfKvsq6u3MxW5IFgZmD1whCgiXBnR15IyB/G/APoWSuXxw9BFldGzZwzDfhkY6R9ZHYPG24zFnIjAVWBetA6joQUtZtMxKLb5025lHnLztLrjuSfjZ9b8TPdR9EsBA1MaN3jTQPursa6o8f5l+x9Z5JGj44aYqrJXxEG9evM/2HWwkWJXKpfUMKaReSxd75fOLxg/Ll+qiuz9zE9+RalQtI7cAFneS35MX+yvczKmSEtrqSZ2uZXHCLsB4TGo/r9t70XKdXGxEZ7Pk49/0BbdgteXpBn3p6ypwwrqvIepGKypux3eY= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:DB9PR08MB6507.eurprd08.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(4636009)(39860400002)(346002)(366004)(136003)(396003)(376002)(451199015)(316002)(84970400001)(38100700002)(6486002)(86362001)(478600001)(31696002)(30864003)(235185007)(5660300002)(41300700001)(36756003)(66476007)(66556008)(66946007)(8676002)(8936002)(186003)(2616005)(31686004)(33964004)(83380400001)(53546011)(26005)(6512007)(6666004)(6506007)(2906002)(45980500001)(43740500002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?R01hZGVLNlF2TUpyUVZCQlBUNkl2dnUzam1mOGpkdjY5dHRzWnhibkNKbTgx?= =?utf-8?B?N3BIb0p0Wm9BN1lkWHFneHFkSHZ0OVBhditTS21xTDRyT1E4dERYcW00R3d6?= =?utf-8?B?NjBzR1lXV0VlZnBSQ0cxQ2RDY05mU1lTNkxCdzhjbXFNaW1DYUF5dlVJRllZ?= =?utf-8?B?a2lsY3BpZDk5bXE5emg1RlIyZEVzOHBIYzQvQnFPQXVSNEhyQndyNXV2U1ZI?= =?utf-8?B?MGMvU0ZZcnhSRFNRQy9nYXNFeTZRMWIxWFJZVXpzaHZZTTRFZm1sTTNJZ3pm?= =?utf-8?B?dVNNVjlaSmtxdlZRdlMxRlJka0lBRE5tT2p4NDRyV1dFM2ZsK3V2bUY3MXhr?= =?utf-8?B?UlVBdEwzVFpJd1JoVXdhMkRHNGpiU1hiS2dHeE9IMVZsajRacGZiK1NlMjF6?= =?utf-8?B?ZkNaNWFzbkVGMTJrelkrNFRtckhHS3RJb1hhT0pXWm9IandQazBqUkp5RnU2?= =?utf-8?B?M1hoYnhKQlJYQVV3Z294Y3BoOVFjMVNqZE9kV3hzRFBjRkJ1TEdkaFF4WkNo?= =?utf-8?B?T3hHYjl0VVAvRTkvenhENWdzemhoQTgyWmloQ1BmUi80TWRuZ2IxQTh2N0Zx?= =?utf-8?B?UXJiUU54TTJvby9TbTlkWEFVbndjZXVpeUxrbysvSUVCcTJHRnBxTkdGajVa?= =?utf-8?B?RFVIV0RyaTFBK1dxNFR1WGZxQjRyU3MrNFNFRXdnandydVJvb2d4TG12c210?= =?utf-8?B?VGpYeHhzOGxucTdpcWJJdXZudjJMK3dob2FURk5LZVF1MVVieHlBRmlCdkVQ?= =?utf-8?B?Wk1IelJuZlFuYlFKSEJuczB3dkdEZHFpanZRRW4zSVdIcXFLZ1ZLdGZqT2hB?= =?utf-8?B?SlB4UDBTbVp1RlIyaXVSMVRTOHFkT3oyWHdUNmxJSitSQ1lhMFFZZ1VmR1pr?= =?utf-8?B?ZXBlSnBWd2grRU41NGYzMWRobDBITmFzSHA0RXFCdE5BbWtVMnRoL3ZCVHE4?= =?utf-8?B?Y3BxRUlReXJqb0RqcWNDdk9nS0F1NzhTaWdSUzJodFFsbnlzQW12aWN3TUE0?= =?utf-8?B?YTdXOTd6b2wzYXBNZlAybmg1eXFGRDltb1V5dStVZ3d2bTdiSWxRY0ZpV2Z4?= =?utf-8?B?WkVQc3NOa0Jlc2duN25WczE0ZHgzNkdhM3FscHF4dHJhZVdEZVlRbUpQNW1o?= =?utf-8?B?dC9qVGFXRHR5SnluZUh1Wi9DT2RTN2xHRGFuMjYwSHc2aXBXUGFUVlVDWlRE?= =?utf-8?B?SGFCaWZUWnl5SzduWGZ3NzBCSXd0ZnJzY0Nndld3K0h3SHRVTjFSdTBCRGNm?= =?utf-8?B?WmlWZW9vR0N1a0ZDUFpTbXRua3ZVWDFQYXd1bHQyUjdBYlFzS1p1WlQycEFX?= =?utf-8?B?bEI3d0ZxSCtpR3Zka0NSSmNBN01TOUhidkM0SThpZDlVUzJTTTREUGFkWmp5?= =?utf-8?B?Q3B1dGx3cFVhZVJ3RkRoVlFOQXJEQUNiNHc0TUVxTWFQaStWUjNOMG5uWEZ4?= =?utf-8?B?T2FadEJJVll0T1J1M2tWVXRuNis3d1AzV1RzanFiSm9aVStWd1dXQmorQTJQ?= =?utf-8?B?UEFNUzgrV3Z4SU9FRXJnQjExaUJKMnFaU0RTdDdwS0FzYnBBRk9XSEljT1dY?= =?utf-8?B?dVJmQjFMbC9HcFBXL2ZZWlU1amtqTkdJT0FScnRFOUJ1dmI0RFZXQ0UvYlpR?= =?utf-8?B?QXFXdTdVNWhEZG1mb3hsZ3JNY2s2ZXpnN2FKTnVlQStUTkdOWTRrZHZHWlQ4?= =?utf-8?B?Wm1EdXRQbVlMUDIzRGRQbmd0L1pLVGVFSzRBTlg3YnFsVElBbVMydjF4T2ZQ?= =?utf-8?B?TWo3N2l5RDhWQm5TT1BRQ2loZXNwdmVaREE4WnBJSFFxWVh4dkMzTzZXU2l5?= =?utf-8?B?M0dudXgxVVFoVTBmUUEyazBlTlEzWVc3N3ZkSXRMaGpFSHFkMDFKZkp1ZVZT?= =?utf-8?B?L2VJWkx6Zy81YUJHdWJtVDFtcVFsdVZoVTV2c0JlMjRmbHNIQUpoVWRVaW9w?= =?utf-8?B?bEVuME5jUzJUYW1LeVVDN1lpNTRRTDNSOXdKU0xVa2cyM1VLaU5tRC9UWmMz?= =?utf-8?B?NXhDbUJVUGxrU0UrSXBFdUZxQzJSTjhIWjJ4MnFya2FJZ2pmZDgzczNkU2hG?= =?utf-8?B?YURpUzNkTUhvcXF2TmZhQXJqR1I2TFU3bktadHNjL2NaRmI4cGFJcjQxVDJp?= =?utf-8?B?VnV6QU9NSDZURzZTWHFOb29hVUdMWDdZVlpNbzFzZEszQzdvWDQ1dk16OXJX?= =?utf-8?B?b1E9PQ==?= X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-Network-Message-Id: cbc2606c-815b-4206-8b76-08dad139fc40 X-MS-Exchange-CrossTenant-AuthSource: DB9PR08MB6507.eurprd08.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 28 Nov 2022 12:13:41.0368 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: +La6b0727QLwOIesOZSfrUPFKm9V/2Lc4ljYhWWeDT+1oEnpJYJXbCGtfocPf7tENjaJme6tlLfPzzMjb1o/S/azsTbz1xScXBp9yuzZaLE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: PA4PR08MB6191 X-Spam-Status: No, score=-10.3 required=5.0 tests=BAYES_00,BODY_8BITS,DKIM_SIGNED,DKIM_VALID,FORGED_SPF_HELO,GIT_PATCH_0,KAM_DMARC_NONE,KAM_LOTSOFHASH,KAM_SHORT,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --------------iBHKydoUu52nOf9uk3gvNMaX Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 11/15/22 15:51, Andre Vieira (lists) wrote: > > On 11/11/2022 17:40, Stam Markianos-Wright via Gcc-patches wrote: >> Hi all, >> >> This is the 2/2 patch that contains the functional changes needed >> for MVE Tail Predicated Low Overhead Loops.  See my previous email >> for a general introduction of MVE LOLs. >> >> This support is added through the already existing loop-doloop >> mechanisms that are used for non-MVE dls/le looping. >> >> Changes are: >> >> 1) Relax the loop-doloop mechanism in the mid-end to allow for >>    decrement numbers other that -1 and for `count` to be an >>    rtx containing the number of elements to be processed, rather >>    than an expression for calculating the number of iterations. >> 2) Add a `allow_elementwise_doloop` target hook. This allows the >>    target backend to manipulate the iteration count as it needs: >>    in our case to change it from a pre-calculation of the number >>    of iterations to the number of elements to be processed. >> 3) The doloop_end target-insn now had an additional parameter: >>    the `count` (note: this is before it gets modified to just be >>    the number of elements), so that the decrement value is >>    extracted from that parameter. >> >> And many things in the backend to implement the above optimisation: >> >> 4)  Appropriate changes to the define_expand of doloop_end and new >>     patterns for dlstp and letp. >> 5) `arm_attempt_dlstp_transform`: (called from the define_expand of >>     doloop_end) this function checks for the loop's suitability for >>     dlstp/letp transformation and then implements it, if possible. >> 6) `arm_mve_get_loop_unique_vctp`: A function that loops through >>     the loop contents and returns the vctp VPR-genereting operation >>     within the loop, if it is unique and there is exclusively one >>     vctp within the loop. >> 7) A couple of utility functions: `arm_mve_get_vctp_lanes` to map >>    from vctp unspecs to number of lanes, and `arm_get_required_vpr_reg` >>    to check an insn to see if it requires the VPR or not. >> >> No regressions on arm-none-eabi with various targets and on >> aarch64-none-elf. Thoughts on getting this into trunk? >> >> Thank you, >> Stam Markianos-Wright >> >> gcc/ChangeLog: >> >>         * config/aarch64/aarch64.md: Add extra doloop_end arg. >>         * config/arm/arm-protos.h (arm_attempt_dlstp_transform): New. >>         * config/arm/arm.cc (TARGET_ALLOW_ELEMENTWISE_DOLOOP): New. >>         (arm_mve_get_vctp_lanes): New. >>         (arm_get_required_vpr_reg): New. >>         (arm_mve_get_loop_unique_vctp): New. >>         (arm_attempt_dlstp_transform): New. >>         (arm_allow_elementwise_doloop): New. >>         * config/arm/iterators.md: >>         * config/arm/mve.md (*predicated_doloop_end_internal): New. >>         (dlstp_insn): New. >>         * config/arm/thumb2.md (doloop_end): Update for MVE LOLs. >>         * config/arm/unspecs.md: New unspecs. >>         * config/ia64/ia64.md: Add extra doloop_end arg. >>         * config/pru/pru.md: Add extra doloop_end arg. >>         * config/rs6000/rs6000.md: Add extra doloop_end arg. >>         * config/s390/s390.md: Add extra doloop_end arg. >>         * config/v850/v850.md: Add extra doloop_end arg. >>         * doc/tm.texi: Document new hook. >>         * doc/tm.texi.in: Likewise. >>         * loop-doloop.cc (doloop_condition_get): Relax conditions. >>         (doloop_optimize): Add support for elementwise LoLs. >>         * target-insns.def (doloop_end): Add extra arg. >>         * target.def (allow_elementwise_doloop): New hook. >>         * targhooks.cc (default_allow_elementwise_doloop): New. >>         * targhooks.h (default_allow_elementwise_doloop): New. >> >> gcc/testsuite/ChangeLog: >> >>         * gcc.target/arm/lob.h: Update framework. >>         * gcc.target/arm/lob1.c: Likewise. >>         * gcc.target/arm/lob6.c: Likewise. >>         * gcc.target/arm/dlstp-int16x8.c: New test. >>         * gcc.target/arm/dlstp-int32x4.c: New test. >>         * gcc.target/arm/dlstp-int64x2.c: New test. >>         * gcc.target/arm/dlstp-int8x16.c: New test. >> >> >> ### Inline copy of patch ### >> >> diff --git a/gcc/config/aarch64/aarch64.md >> b/gcc/config/aarch64/aarch64.md >> index >> f2e3d905dbbeb2949f2947f5cfd68208c94c9272..7a6d24a80060b4a704a481ccd1a32d96e7b0f369 >> 100644 >> --- a/gcc/config/aarch64/aarch64.md >> +++ b/gcc/config/aarch64/aarch64.md >> @@ -7366,7 +7366,8 @@ >>  ;; knows what to generate. >>  (define_expand "doloop_end" >>    [(use (match_operand 0 "" ""))      ; loop pseudo >> -   (use (match_operand 1 "" ""))]     ; label >> +   (use (match_operand 1 "" ""))      ; label >> +   (use (match_operand 2 "" ""))]     ; decrement constant >>    "optimize > 0 && flag_modulo_sched" >>  { >>    rtx s0; >> diff --git a/gcc/config/arm/arm-protos.h b/gcc/config/arm/arm-protos.h >> index >> 550272facd12e60a49bf8a3b20f811cc13765b3a..7684620f0f4d161dd9e9ad2d70308021ec3d3d34 >> 100644 >> --- a/gcc/config/arm/arm-protos.h >> +++ b/gcc/config/arm/arm-protos.h >> @@ -63,7 +63,7 @@ extern void arm_decompose_di_binop (rtx, rtx, rtx >> *, rtx *, rtx *, rtx *); >>  extern bool arm_q_bit_access (void); >>  extern bool arm_ge_bits_access (void); >>  extern bool arm_target_insn_ok_for_lob (rtx); >> - >> +extern rtx arm_attempt_dlstp_transform (rtx, rtx); >>  #ifdef RTX_CODE >>  enum reg_class >>  arm_mode_base_reg_class (machine_mode); >> diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc >> index >> ee8f1babf8a1319e77e0db0fa55851c038048804..99e144d52c26597c64b982b3d4ae9a62a114cf18 >> 100644 >> --- a/gcc/config/arm/arm.cc >> +++ b/gcc/config/arm/arm.cc >> @@ -470,6 +470,9 @@ static const struct attribute_spec >> arm_attribute_table[] = >>  #undef TARGET_SCHED_REORDER >>  #define TARGET_SCHED_REORDER arm_sched_reorder >> >> +#undef TARGET_ALLOW_ELEMENTWISE_DOLOOP >> +#define TARGET_ALLOW_ELEMENTWISE_DOLOOP arm_allow_elementwise_doloop >> + > Just a nit but maybe keep the same naming scheme as the existing hook: > TARGET_CAN_USE_ELEMENTWISE_DOLOOP_P ? Done, Also: Thanks for taking time to review! I've done a second draft as an attachment to this email. Let me know of any further when you get to the second half of the patch. >> + >> +static rtx >> +arm_get_required_vpr_reg (rtx_insn *insn) >> +{ >> +  bool requires_vpr; >> + >> +  extract_constrain_insn (insn); >> +  int n_operands = recog_data.n_operands; >> +  if (recog_data.n_alternatives == 0) >> +    return NULL_RTX; >> + >> +  /* Fill in recog_op_alt with information about the constraints of >> +     this insn.  */ >> +  preprocess_constraints (insn); >> + >> +  for (int use = 0; use < n_operands; use++) >> +    { >> +      requires_vpr = true; >> +      /* Iterate through alternatives of operand "use" in >> recog_op_alt and >> +       * identify if the operand is required to be the VPR.  */ > Remove the * at the start of the new line. Done. >> +      for (int alt1 = 0; alt1 < recog_data.n_alternatives; alt1++) >> +    { >> +      const operand_alternative *op_alt1 >> +          = &recog_op_alt[alt1 * n_operands]; >> +      /* Fetch the reg_class for each entry and check it against the >> +       * VPR_REG reg_class.  */ >> +      if (alternative_class (op_alt1, use) != VPR_REG) >> +        requires_vpr = false; >> +    } >> +      /* If all alternatives of the insn require the VPR reg for >> this operand, >> +     it means that either this is VPR-generating instruction, like a >> vctp, >> +     vcmp, etc., or it is a VPT-predicated insruction.  Return the >> subrtx >> +     of the VPR reg operand.  */ >> +      if (requires_vpr) >> +    return recog_data.operand[use]; >> +    } >> +  return NULL_RTX; >> +} >> + >> +/* Scan the basic block of a loop body for a vctp instruction. If >> there is >> +   exactly one unique vctp instruction, return its rtx_insn *. */ >> + >> +static rtx_insn * >> +arm_mve_get_loop_unique_vctp (basic_block bb) >> +{ >> +  rtx_insn *insn = BB_HEAD (bb); >> +  rtx_insn *vctp_op = NULL; >> + >> +  /* Now scan through all the instruction patterns and >> +     pick out any MVE instructions.  */ >> +  FOR_BB_INSNS (bb, insn) >> +    { >> +      if (INSN_P (insn)) >> +    { >> +      /* First check if this is a vctp instruction.  There needs to be >> +         exactly one vctp instruction within the loop.  */ >> +      if (arm_mve_get_vctp_lanes (PATTERN (insn)) != 0) >> +        { >> +          /* If we already found one vctp instruction, then the >> +         loop is not consistent internally.  */ >> +          if (vctp_op) >> +        return NULL; >> + >> +          vctp_op = insn; >> +        } >> +    } >> +    } >> +  return vctp_op; >> +} >> + >> +rtx >> +arm_attempt_dlstp_transform (rtx label, rtx count) >> +{ >> +  int decrementnum; >> +  basic_block body = BLOCK_FOR_INSN (label)->prev_bb; >> +  rtx initial_compare; >> +  /* Doloop can only be done "elementwise" with predicated dlstp/letp >> +     when the iteration counter gets deprecated by the number of MVE > s/deprecated/decreased/ ? I think "decremented" was what I was going for, so changed it to that :) >> + lanes.  This can be exxtracted from the `count`, which is the >> expression > s/exxtracted/extracted/ Done. >> +     used to calculate the number of iterations that the loop would >> execute >> +     for a standard dls/le loop.  Since we only support cases where >> this is a >> +     power of 2, we can assume that this expression arrives here as: >> +       (lshiftrt: (A) (const_int y)) >> +     Then we can extract the decrementnum from y.  */ >> +  if (GET_CODE (count) == LSHIFTRT && ARITHMETIC_P (XEXP (count, 0)) >> +      && (decrementnum = (1 << (INTVAL (XEXP (count, 1))))) > Why are you calculating decrementnum inside the condition? Ahh ok so this is an artifact from a previous revision, where I also included the: `decrementnum != arm_mve_get_vctp_lanes (PATTERN (vctp_insn))` within that condition, but since that is now done late, I can move this down. >> +      /* There is one final condition that needs to be met for the >> loop to be >> +     transformable: dlstp/letp will continue looping until there are >> +     elements still to process.  This can only work if the looping ends >> +     when the element counter reaches zero and not some other value >> +     (e.g. n > 0 works, not n > 1), or we can incorrectly end up >> running >> +     one additional iteration.  To by-pass any hoisting that the >> compiler >> +     may have done with the `A` in `count` above, we can instead >> look up >> +     to the bb before the loop preheader: this should end with a >> cmp+jump >> +     pair, where the cmp needs to be with (const_int 0).  */ > > I'm wondering whether it would be possible to subtract a non-zero > const from count. But that might be dangerous... > > Do you have an example/test case where you saw this happen? So this can happen in situations like:     while (n > 1)     {         mve_pred16_t p = vctp8q (n);         uint8x16_t va = vldrbq_z_u8 (a, p);         uint8x16_t vb = vldrbq_z_u8 (b, p);         uint8x16_t vc = vaddq_x_u8 (va, vb, p);         vstrbq_p_u8 (c, vc, p);         n-=16;         a+=16;         b+=16;         c+=16;     } IIUC you mean that we'd end up with something like:         sub r3, r3, #1         dlstp.8 lr, r3 to enable loops that aren't terminating at zero. I believe the answer is `No`, because even though we would execute the correct number of iterations, we would use an incorrect predicate value: e.g. if n == r3 == 18: we'd subtract a const 1: r3 == 17 Iteration 1: use all 16 lanes: Correct. Iteration 2: use 1 lane: Incorrect -- from the user code it looks like we should use 2. Because the number of iterations and the predicate value here are tied, I think we can only safely transform loops that terminate with a `>0` On standard dls/le loops we do already subtract the non-zero const. > >> + && loop_preheader_edge (body->loop_father)->src->prev_bb >> +      && BB_END (loop_preheader_edge (body->loop_father)->src->prev_bb) >> +      && PREV_INSN (BB_END (loop_preheader_edge (body->loop_father) >> +                ->src->prev_bb)) >> +      && INSN_P (PREV_INSN (BB_END (loop_preheader_edge >> (body->loop_father) >> +                    ->src->prev_bb))) >> +      && (initial_compare >> +      = PATTERN (PREV_INSN (BB_END (loop_preheader_edge >> (body->loop_father) >> +                        ->src->prev_bb)))) >> +      && GET_CODE (initial_compare) == SET >> +      && cc_register (XEXP (initial_compare, 0), VOIDmode) >> +      && GET_CODE (XEXP (initial_compare, 1)) == COMPARE >> +      && CONST_INT_P (XEXP (XEXP (initial_compare, 1), 1)) >> +      && INTVAL (XEXP (XEXP (initial_compare, 1), 1)) == 0) >> +    { >> +      /* Find the vctp predicate generation inside the loop body >> BB.  */ >> +      rtx_insn *vctp_insn = arm_mve_get_loop_unique_vctp (body); >> + >> +      /* If we have successfully found one exactly vctp >> predicate-generating >> +     instruction within the loop and the number by which we >> deprecate the >> +     loop counter in each iteration matches the number of lanes of the >> +     vctp instruction, we can attempt to turn this into a dlstp/letp >> loop. >> +     */ >> +      if (vctp_insn >> +      && decrementnum == arm_mve_get_vctp_lanes (PATTERN (vctp_insn))) >> +    { > I would exit early here, so you don't need to indent the rest of the > code, by that I mean something like: > > if (!vectp_insn >      || decrementnum != ...) >   return GEN_INT (1); > > .. rest of the code. Done, thanks! > >> + rtx_insn *insn = 0; >> +      rtx_insn *cur_insn = 0; >> +      rtx_insn *seq; >> +      rtx vctp_vpr_generated = NULL_RTX; >> +      rtx insn_vpr_reg_operand = NULL_RTX; >> +      bool transform_worked = true; > Won't need transform_worked. Done >> +      int new_icode; >> + >> +      /* Scan through the insns in the loop bb and emit the >> transformed bb >> +         insns to a sequence.  */ >> +      start_sequence (); >> +      FOR_BB_INSNS (body, insn) >> +        { >> +          if (INSN_P (insn)) > This also captures DEBUG_INSNs, which means passing -g disables this > feature. Fixed: description of this is later on >> +        { >> +          /* When we find the vctp instruction: This may be followed by >> +             a sign-extend insn to SImode.  If it is, then save the >> +             sign-extended REG into vctp_vpr_generated.  If there is no >> +             sign-extend, then store the raw output of the vctp. >> +             For any VPT-predicated instructions we need to ensure that >> +             the VPR they use is the same as the one given here and >> +             they often consume the output of a subreg of the SImode >> +             sign-extended VPR-reg.  As a result, comparing against the >> +             output of the sign-extend is more likely to succeed. >> +             This code also guarantees to us that the vctp comes before >> +             any instructions that use the VPR within the loop, for the >> +             dlstp/letp transform to succeed.  */ >> +          if (insn == vctp_insn) >> +            { >> +              if (GET_CODE (XEXP (PATTERN (NEXT_INSN (insn)), 1)) >> +                  == SIGN_EXTEND >> +              && GET_CODE (XEXP ( >> +                 PATTERN (NEXT_INSN (NEXT_INSN (insn))), 1)) >> +                 == SUBREG) >> +            vctp_vpr_generated >> +                = XEXP (PATTERN (NEXT_INSN (NEXT_INSN (insn))), 0); >> +              else >> +            vctp_vpr_generated = XEXP (PATTERN (insn), 0); >> +              /* Also emit a USE of the source register of the vctp. >> +             This holds the number of elements being processed >> +             by the loop.  This later gets stored into `count`. >> +             */ >> +              emit_use (XVECEXP (XEXP (PATTERN (insn), 1), 0, 0)); > What if we get here but don't end up creating a predicated do-loop? > Will this use break something? Nope, it won't break anything because of the use of start_sequence/end_sequence. The use and all the transform insns get emitted to the sequence, and then only if we have fully succeeded, we will wipe all the contents of the `bb` and put in the sequence (incl. the use). The `use` gets deleted later in `arm_allow_elementwise_doloop_p` and really it's just a dodgy way for me to preserve the REG used in the vctp, so that later I can make it the `count` or the number of elements to be processed by the loop (the `dlstp lr, REG` register) >> +       continue; >> +            } >> +          /* If the insn pattern requires the use of the VPR, then it > Missing an is. Done >> +      a VPT-predicated instruction, so it will need to be >> +             transformed into the non-predicated version of the >> +             instruction.  */ > But this comment seems misplace here. Adjusted this :) >> + else if ((insn_vpr_reg_operand >> +                = arm_get_required_vpr_reg (insn)) >> +               != NULL_RTX) >> +            { >> +              /* If the VPR value is different to the one generated by >> +             the vctp, then fail the conversion.  */ >> +              if (!rtx_equal_p (vctp_vpr_generated, >> +                    insn_vpr_reg_operand)) >> +            { >> +              transform_worked = false; >> +              break; > return GEN_INT (1); Done -- but also needed an end_sequece (); >> +     } >> +              /* Also ensure that it's a valid recog-ed instruction >> with >> +             the mve_unpredicated_insn atrribute.  */ >> +              else if (recog_memoized (insn) >= 0 >> +                   && (new_icode >> +                   = get_attr_mve_unpredicated_insn (insn))) >> +            { >> +              extract_insn (insn); >> +              rtx arr[8]; >> +              int j = 0; >> + >> +              /* When transforming a VPT-predicated instruction >> +                 into its unpredicated equivalent we need to drop >> +                 the VPR operand and we may need to also drop a >> +                 merge "vuninit" input operand, depending on the >> +                 instruction pattern.  Here ensure that we have at >> +                 most a two-operand difference between the two >> +                 instrunctions.  */ >> +              int n_operands_diff >> +                  = recog_data.n_operands >> +                - insn_data[new_icode].n_operands; >> +              gcc_assert (n_operands_diff > 0 >> +                      && n_operands_diff <= 2); >> + >> +              /* Then, loop through the operands of the predicated >> +                 instruction, and retain the ones that map to the >> +                 unpredicated instruction.  */ >> +              for (int i = 0; i < recog_data.n_operands; i++) >> +                { >> +                  /* Ignore the VPR and, if needed, the vuninit >> +                 operand.  */ >> +                  if (insn_vpr_reg_operand == recog_data.operand[i] >> +                  || (n_operands_diff == 2 >> +                      && !strcmp (recog_data.constraints[i], >> +                          "0"))) >> +                continue; >> +                  else >> +                { >> +                  arr[j] = recog_data.operand[i]; >> +                  j++; >> +                } >> +                } >> + >> +              /* Finally, emit the upredicated instruction.  */ >> +              switch (j) >> +                { >> +                  case 2: >> +                emit_insn (GEN_FCN (new_icode) (arr[0], >> +                                arr[1])); >> +                break; >> +                  case 3: >> +                emit_insn (GEN_FCN (new_icode) (arr[0], arr[1], >> +                                arr[2])); >> +                break; >> +                  default: >> +                gcc_unreachable (); >> +                } >> +            } >> +              /* If we can't identify the INSN as either being either >> +             for deletion or to re-map, then we don't know how to >> +             handle it, so fail the whole conversion.  */ >> +              else >> +            { >> +              transform_worked = false; >> +              break; > use > return GEN_INT (1); Done. >> +     } >> +            } >> +          /* Instructions that dont's require the VPR can be carried >> +             over as-is.  */ >> +          else >> +            emit_insn (PATTERN (insn)); >> +        } >> +        } >> +      seq = get_insns (); >> +      end_sequence (); >> + >> +      if (transform_worked) >> +        { > no need to check this, you can only get here if it worked. Done. >> + /* Re-write the entire BB contents with the transformed >> +         sequence.  */ >> +          FOR_BB_INSNS_SAFE (body, insn, cur_insn) >> +        if (INSN_P (insn)) >> +          delete_insn (insn); > This will also delete DEBUG_INSN's! You'd probably want to delete only > NONDEBUG_INSN_P (insn). I'm not an expert in how DEBUG_INSNs work but > I suspect their order compared to non-debug insns are likely to be > important, so really you'd want change how you 'transform' the BB and > do inline insn replacement. You are correct, thanks for spotting this! So I do want to also delete debug_insns, because what I want to do is replace all the bb contents with the previous sequence. Instead, though I need to make sure that DEBUG_INSNs get put into the sequence correctly (which wasn't working). I also found a similar situation with NOTEs (which are !INSN_Ps), if there were any in the bb other than the NOTE_INSN_BASIC_BLOCK, they would get filtered up to the start of the bb. This should also be fixed now. >> + for (insn = seq; NEXT_INSN (insn); insn = NEXT_INSN (insn)) >> +        emit_insn_after (PATTERN (insn), BB_END (body)); >> +          emit_jump_insn_after (PATTERN (insn), BB_END (body)); >> +          return GEN_INT (decrementnum); >> +        } >> +    } >> +    } >> +  /* Bail out: we can't use dlstp/letp, so return 1 to allow >> loop-doloop to try >> +     the standard dls/le pair.  */ >> +  return GEN_INT (1); >> +} >> > Only reviewed until here, will look at the rest later. --------------iBHKydoUu52nOf9uk3gvNMaX Content-Type: text/x-patch; charset=UTF-8; name="rb16111.patch" Content-Disposition: attachment; filename="rb16111.patch" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvYWFyY2g2NC9hYXJjaDY0Lm1kIGIvZ2NjL2NvbmZpZy9h YXJjaDY0L2FhcmNoNjQubWQKaW5kZXggZjJlM2Q5MDVkYmIuLjdhNmQyNGE4MDA2IDEwMDY0NAot LS0gYS9nY2MvY29uZmlnL2FhcmNoNjQvYWFyY2g2NC5tZAorKysgYi9nY2MvY29uZmlnL2FhcmNo NjQvYWFyY2g2NC5tZApAQCAtNzM2Niw3ICs3MzY2LDggQEAKIDs7IGtub3dzIHdoYXQgdG8gZ2Vu ZXJhdGUuCiAoZGVmaW5lX2V4cGFuZCAiZG9sb29wX2VuZCIKICAgWyh1c2UgKG1hdGNoX29wZXJh bmQgMCAiIiAiIikpICAgICAgOyBsb29wIHBzZXVkbwotICAgKHVzZSAobWF0Y2hfb3BlcmFuZCAx ICIiICIiKSldICAgICA7IGxhYmVsCisgICAodXNlIChtYXRjaF9vcGVyYW5kIDEgIiIgIiIpKSAg ICAgIDsgbGFiZWwKKyAgICh1c2UgKG1hdGNoX29wZXJhbmQgMiAiIiAiIikpXSAgICAgOyBkZWNy ZW1lbnQgY29uc3RhbnQKICAgIm9wdGltaXplID4gMCAmJiBmbGFnX21vZHVsb19zY2hlZCIKIHsK ICAgcnR4IHMwOwpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9hcmMvYXJjLm1kIGIvZ2NjL2NvbmZp Zy9hcmMvYXJjLm1kCmluZGV4IDQ1OGQzZWRmNzE2Li5hNGIzZDFhZGRiZiAxMDA2NDQKLS0tIGEv Z2NjL2NvbmZpZy9hcmMvYXJjLm1kCisrKyBiL2djYy9jb25maWcvYXJjL2FyYy5tZApAQCAtNDk4 NSwxMiArNDk4NSwxMyBAQCBhcmNoczR4LCBhcmNoczR4ZCIKIAkJICAgIChwYykpKQogCSAgICAg IChzZXQgKG1hdGNoX2R1cCAwKSAocGx1czpTSSAobWF0Y2hfZHVwIDApIChjb25zdF9pbnQgLTEp KSkKIAkgICAgICAodW5zcGVjOlNJIFsoY29uc3RfaW50IDApXSBVTlNQRUNfQVJDX0xQKQotCSAg ICAgIChjbG9iYmVyIChtYXRjaF9kdXAgMikpXSldCisJICAgICAgKGNsb2JiZXIgKG1hdGNoX2R1 cCAzKSkKKwkgICAgICAobWF0Y2hfb3BlcmFuZCAyICIiICIiKV0pXQogICAiIgogewogIGlmIChH RVRfTU9ERSAob3BlcmFuZHNbMF0pICE9IFNJbW9kZSkKICAgIEZBSUw7Ci0gb3BlcmFuZHNbMl0g PSBnZW5fcnR4X1NDUkFUQ0ggKFNJbW9kZSk7Cisgb3BlcmFuZHNbM10gPSBnZW5fcnR4X1NDUkFU Q0ggKFNJbW9kZSk7CiB9KQogCiAoZGVmaW5lX2luc24gImFyY19scCIKZGlmZiAtLWdpdCBhL2dj Yy9jb25maWcvYXJtL2FybS1wcm90b3MuaCBiL2djYy9jb25maWcvYXJtL2FybS1wcm90b3MuaApp bmRleCA1NTAyNzJmYWNkMS4uNzY4NDYyMGYwZjQgMTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvYXJt L2FybS1wcm90b3MuaAorKysgYi9nY2MvY29uZmlnL2FybS9hcm0tcHJvdG9zLmgKQEAgLTYzLDcg KzYzLDcgQEAgZXh0ZXJuIHZvaWQgYXJtX2RlY29tcG9zZV9kaV9iaW5vcCAocnR4LCBydHgsIHJ0 eCAqLCBydHggKiwgcnR4ICosIHJ0eCAqKTsKIGV4dGVybiBib29sIGFybV9xX2JpdF9hY2Nlc3Mg KHZvaWQpOwogZXh0ZXJuIGJvb2wgYXJtX2dlX2JpdHNfYWNjZXNzICh2b2lkKTsKIGV4dGVybiBi b29sIGFybV90YXJnZXRfaW5zbl9va19mb3JfbG9iIChydHgpOwotCitleHRlcm4gcnR4IGFybV9h dHRlbXB0X2Rsc3RwX3RyYW5zZm9ybSAocnR4LCBydHgpOwogI2lmZGVmIFJUWF9DT0RFCiBlbnVt IHJlZ19jbGFzcwogYXJtX21vZGVfYmFzZV9yZWdfY2xhc3MgKG1hY2hpbmVfbW9kZSk7CmRpZmYg LS1naXQgYS9nY2MvY29uZmlnL2FybS9hcm0uY2MgYi9nY2MvY29uZmlnL2FybS9hcm0uY2MKaW5k ZXggZWU4ZjFiYWJmOGEuLjcyZDAxODdlYjAwIDEwMDY0NAotLS0gYS9nY2MvY29uZmlnL2FybS9h cm0uY2MKKysrIGIvZ2NjL2NvbmZpZy9hcm0vYXJtLmNjCkBAIC00NzAsNiArNDcwLDkgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfc3BlYyBhcm1fYXR0cmlidXRlX3RhYmxlW10gPQog I3VuZGVmIFRBUkdFVF9TQ0hFRF9SRU9SREVSCiAjZGVmaW5lIFRBUkdFVF9TQ0hFRF9SRU9SREVS IGFybV9zY2hlZF9yZW9yZGVyCiAKKyN1bmRlZiBUQVJHRVRfQUxMT1dfRUxFTUVOVFdJU0VfRE9M T09QX1AKKyNkZWZpbmUgVEFSR0VUX0FMTE9XX0VMRU1FTlRXSVNFX0RPTE9PUF9QIGFybV9hbGxv d19lbGVtZW50d2lzZV9kb2xvb3BfcAorCiAjdW5kZWYgVEFSR0VUX1JFR0lTVEVSX01PVkVfQ09T VAogI2RlZmluZSBUQVJHRVRfUkVHSVNURVJfTU9WRV9DT1NUIGFybV9yZWdpc3Rlcl9tb3ZlX2Nv c3QKIApAQCAtMzQxMzgsOCArMzQxNDEsMzcwIEBAIGFybV90YXJnZXRfaW5zbl9va19mb3JfbG9i IChydHggaW5zbikKIAogICByZXR1cm4gc2luZ2xlX3N1Y2NfcCAoYmIpCiAgICAgJiYgc2luZ2xl X3ByZWRfcCAoYmIpCi0gICAgJiYgc2luZ2xlX3N1Y2NfZWRnZSAoYmIpLT5kZXN0ID09IHNpbmds ZV9wcmVkX2VkZ2UgKGJiKS0+c3JjCi0gICAgJiYgY29udGFpbnNfbm9fYWN0aXZlX2luc25fcCAo YmIpOworICAgICYmIHNpbmdsZV9zdWNjX2VkZ2UgKGJiKS0+ZGVzdCA9PSBzaW5nbGVfcHJlZF9l ZGdlIChiYiktPnNyYzsKK30KKworc3RhdGljIGludAorYXJtX212ZV9nZXRfdmN0cF9sYW5lcyAo cnR4IHgpCit7CisgIGlmIChHRVRfQ09ERSAoeCkgPT0gU0VUICYmIEdFVF9DT0RFIChYRVhQICh4 LCAxKSkgPT0gVU5TUEVDKQorICAgIHsKKyAgICAgIHN3aXRjaCAoWElOVCAoWEVYUCAoeCwgMSks IDEpKQorCXsKKwkgIGNhc2UgVkNUUDhROgorCSAgICByZXR1cm4gMTY7CisJICBjYXNlIFZDVFAx NlE6CisJICAgIHJldHVybiA4OworCSAgY2FzZSBWQ1RQMzJROgorCSAgICByZXR1cm4gNDsKKwkg IGNhc2UgVkNUUDY0UToKKwkgICAgcmV0dXJuIDI7CisJICBkZWZhdWx0OgorCSAgICBicmVhazsK Kwl9CisgICAgfQorICByZXR1cm4gMDsKK30KKworLyogQ2hlY2sgaWYgYW4gaW5zbiByZXF1aXJl cyB0aGUgdXNlIG9mIHRoZSBWUFJfUkVHLCBpZiBpdCBkb2VzLCByZXR1cm4gdGhlCisgICBzdWIt cnR4IG9mIHRoZSBtYXRjaGVkIG9wZXJhbmQuICBJZiB0aGVyZSBhcmUgbW9yZSB0aGFuIG9uZSBv cGVyYW5kIChlLmcuIGFuCisgICBpbnB1dCBvcGVyYW5kIGFuZCBhbiBvdXRwdXQgb3BlcmFuZCkg dGhhdCB1c2UgVlBSX1JFRywgcmV0dXJuIHRoZSBmaXJzdAorICAgb2NjdXJhbmNlLCB3aGljaCBp cyB1c3VhbGx5IHRoZSBvdXRwdXQgb3BlcmFuZC4gICovCisKK3N0YXRpYyBydHgKK2FybV9nZXRf cmVxdWlyZWRfdnByX3JlZyAocnR4X2luc24gKmluc24pCit7CisgIGlmICghTk9OSlVNUF9JTlNO X1AgKGluc24pKQorICAgIHJldHVybiBOVUxMX1JUWDsKKworICBib29sIHJlcXVpcmVzX3ZwcjsK KyAgZXh0cmFjdF9jb25zdHJhaW5faW5zbiAoaW5zbik7CisgIGludCBuX29wZXJhbmRzID0gcmVj b2dfZGF0YS5uX29wZXJhbmRzOworICBpZiAocmVjb2dfZGF0YS5uX2FsdGVybmF0aXZlcyA9PSAw KQorICAgIHJldHVybiBOVUxMX1JUWDsKKworICAvKiBGaWxsIGluIHJlY29nX29wX2FsdCB3aXRo IGluZm9ybWF0aW9uIGFib3V0IHRoZSBjb25zdHJhaW50cyBvZgorICAgICB0aGlzIGluc24uICAq LworICBwcmVwcm9jZXNzX2NvbnN0cmFpbnRzIChpbnNuKTsKKworICBmb3IgKGludCB1c2UgPSAw OyB1c2UgPCBuX29wZXJhbmRzOyB1c2UrKykKKyAgICB7CisgICAgICByZXF1aXJlc192cHIgPSB0 cnVlOworICAgICAgLyogSXRlcmF0ZSB0aHJvdWdoIGFsdGVybmF0aXZlcyBvZiBvcGVyYW5kICJ1 c2UiIGluIHJlY29nX29wX2FsdCBhbmQKKwkgaWRlbnRpZnkgaWYgdGhlIG9wZXJhbmQgaXMgcmVx dWlyZWQgdG8gYmUgdGhlIFZQUi4gICovCisgICAgICBmb3IgKGludCBhbHQxID0gMDsgYWx0MSA8 IHJlY29nX2RhdGEubl9hbHRlcm5hdGl2ZXM7IGFsdDErKykKKwl7CisJICBjb25zdCBvcGVyYW5k X2FsdGVybmF0aXZlICpvcF9hbHQxCisJICAgICAgPSAmcmVjb2dfb3BfYWx0W2FsdDEgKiBuX29w ZXJhbmRzXTsKKwkgIC8qIEZldGNoIHRoZSByZWdfY2xhc3MgZm9yIGVhY2ggZW50cnkgYW5kIGNo ZWNrIGl0IGFnYWluc3QgdGhlCisJICAgKiBWUFJfUkVHIHJlZ19jbGFzcy4gICovCisJICBpZiAo YWx0ZXJuYXRpdmVfY2xhc3MgKG9wX2FsdDEsIHVzZSkgIT0gVlBSX1JFRykKKwkgICAgcmVxdWly ZXNfdnByID0gZmFsc2U7CisJfQorICAgICAgLyogSWYgYWxsIGFsdGVybmF0aXZlcyBvZiB0aGUg aW5zbiByZXF1aXJlIHRoZSBWUFIgcmVnIGZvciB0aGlzIG9wZXJhbmQsCisJIGl0IG1lYW5zIHRo YXQgZWl0aGVyIHRoaXMgaXMgVlBSLWdlbmVyYXRpbmcgaW5zdHJ1Y3Rpb24sIGxpa2UgYSB2Y3Rw LAorCSB2Y21wLCBldGMuLCBvciBpdCBpcyBhIFZQVC1wcmVkaWNhdGVkIGluc3J1Y3Rpb24uICBS ZXR1cm4gdGhlIHN1YnJ0eAorCSBvZiB0aGUgVlBSIHJlZyBvcGVyYW5kLiAgKi8KKyAgICAgIGlm IChyZXF1aXJlc192cHIpCisJcmV0dXJuIHJlY29nX2RhdGEub3BlcmFuZFt1c2VdOworICAgIH0K KyAgcmV0dXJuIE5VTExfUlRYOworfQorCisvKiBTY2FuIHRoZSBiYXNpYyBibG9jayBvZiBhIGxv b3AgYm9keSBmb3IgYSB2Y3RwIGluc3RydWN0aW9uLiAgSWYgdGhlcmUgaXMKKyAgIGV4YWN0bHkg b25lIHVuaXF1ZSB2Y3RwIGluc3RydWN0aW9uLCByZXR1cm4gaXRzIHJ0eF9pbnNuICouICAqLwor CitzdGF0aWMgcnR4X2luc24gKgorYXJtX212ZV9nZXRfbG9vcF91bmlxdWVfdmN0cCAoYmFzaWNf YmxvY2sgYmIpCit7CisgIHJ0eF9pbnNuICppbnNuID0gQkJfSEVBRCAoYmIpOworICBydHhfaW5z biAqdmN0cF9vcCA9IE5VTEw7CisKKyAgLyogTm93IHNjYW4gdGhyb3VnaCBhbGwgdGhlIGluc3Ry dWN0aW9uIHBhdHRlcm5zIGFuZAorICAgICBwaWNrIG91dCBhbnkgTVZFIGluc3RydWN0aW9ucy4g ICovCisgIEZPUl9CQl9JTlNOUyAoYmIsIGluc24pCisgICAgeworICAgICAgaWYgKElOU05fUCAo aW5zbikpCisJeworCSAgLyogRmlyc3QgY2hlY2sgaWYgdGhpcyBpcyBhIHZjdHAgaW5zdHJ1Y3Rp b24uICBUaGVyZSBuZWVkcyB0byBiZQorCSAgICAgZXhhY3RseSBvbmUgdmN0cCBpbnN0cnVjdGlv biB3aXRoaW4gdGhlIGxvb3AuICAqLworCSAgaWYgKGFybV9tdmVfZ2V0X3ZjdHBfbGFuZXMgKFBB VFRFUk4gKGluc24pKSAhPSAwKQorCSAgICB7CisJICAgICAgLyogSWYgd2UgYWxyZWFkeSBmb3Vu ZCBvbmUgdmN0cCBpbnN0cnVjdGlvbiwgdGhlbiB0aGUKKwkJIGxvb3AgaXMgbm90IGNvbnNpc3Rl bnQgaW50ZXJuYWxseS4gICovCisJICAgICAgaWYgKHZjdHBfb3ApCisJCXJldHVybiBOVUxMOwor CisJICAgICAgdmN0cF9vcCA9IGluc247CisJICAgIH0KKwl9CisgICAgfQorICByZXR1cm4gdmN0 cF9vcDsKK30KKworcnR4Cithcm1fYXR0ZW1wdF9kbHN0cF90cmFuc2Zvcm0gKHJ0eCBsYWJlbCwg cnR4IGNvdW50KQoreworICBpbnQgZGVjcmVtZW50bnVtOworICBiYXNpY19ibG9jayBib2R5ID0g QkxPQ0tfRk9SX0lOU04gKGxhYmVsKS0+cHJldl9iYjsKKyAgcnR4IGluaXRpYWxfY29tcGFyZTsK KyAgLyogRG9sb29wIGNhbiBvbmx5IGJlIGRvbmUgImVsZW1lbnR3aXNlIiB3aXRoIHByZWRpY2F0 ZWQgZGxzdHAvbGV0cAorICAgICB3aGVuIHRoZSBpdGVyYXRpb24gY291bnRlciBnZXRzIGRlY3Jl bWVudGVkIGJ5IHRoZSBudW1iZXIgb2YgTVZFCisgICAgIGxhbmVzLiAgVGhpcyBjYW4gYmUgZXh0 cmFjdGVkIGZyb20gdGhlIGBjb3VudGAsIHdoaWNoIGlzIHRoZSBleHByZXNzaW9uCisgICAgIHVz ZWQgdG8gY2FsY3VsYXRlIHRoZSBudW1iZXIgb2YgaXRlcmF0aW9ucyB0aGF0IHRoZSBsb29wIHdv dWxkIGV4ZWN1dGUKKyAgICAgZm9yIGEgc3RhbmRhcmQgZGxzL2xlIGxvb3AuICBTaW5jZSB3ZSBv bmx5IHN1cHBvcnQgY2FzZXMgd2hlcmUgdGhpcyBpcyBhCisgICAgIHBvd2VyIG9mIDIsIHdlIGNh biBhc3N1bWUgdGhhdCB0aGlzIGV4cHJlc3Npb24gYXJyaXZlcyBoZXJlIGFzOgorICAgICAgIChs c2hpZnRydDogKEEpIChjb25zdF9pbnQgeSkpCisgICAgIFRoZW4gd2UgY2FuIGV4dHJhY3QgdGhl IGRlY3JlbWVudG51bSBmcm9tIHkuICAqLworICBpZiAoR0VUX0NPREUgKGNvdW50KSA9PSBMU0hJ RlRSVCAmJiBBUklUSE1FVElDX1AgKFhFWFAgKGNvdW50LCAwKSkKKyAgICAgIC8qIFRoZXJlIGlz IG9uZSBmaW5hbCBjb25kaXRpb24gdGhhdCBuZWVkcyB0byBiZSBtZXQgZm9yIHRoZSBsb29wIHRv IGJlCisJIHRyYW5zZm9ybWFibGU6IGRsc3RwL2xldHAgd2lsbCBjb250aW51ZSBsb29waW5nIHVu dGlsIHRoZXJlIGFyZQorCSBlbGVtZW50cyBzdGlsbCB0byBwcm9jZXNzLiAgVGhpcyBjYW4gb25s eSB3b3JrIGlmIHRoZSBsb29waW5nIGVuZHMKKwkgd2hlbiB0aGUgZWxlbWVudCBjb3VudGVyIHJl YWNoZXMgemVybyBhbmQgbm90IHNvbWUgb3RoZXIgdmFsdWUKKwkgKGUuZy4gbiA+IDAgd29ya3Ms IG5vdCBuID4gMSksIG9yIHdlIGNhbiBpbmNvcnJlY3RseSBlbmQgdXAgcnVubmluZworCSBvbmUg YWRkaXRpb25hbCBpdGVyYXRpb24uICBUbyBieS1wYXNzIGFueSBob2lzdGluZyB0aGF0IHRoZSBj b21waWxlcgorCSBtYXkgaGF2ZSBkb25lIHdpdGggdGhlIGBBYCBpbiBgY291bnRgIGFib3ZlLCB3 ZSBjYW4gaW5zdGVhZCBsb29rIHVwCisJIHRvIHRoZSBiYiBiZWZvcmUgdGhlIGxvb3AgcHJlaGVh ZGVyOiB0aGlzIHNob3VsZCBlbmQgd2l0aCBhIGNtcCtqdW1wCisJIHBhaXIsIHdoZXJlIHRoZSBj bXAgbmVlZHMgdG8gYmUgd2l0aCAoY29uc3RfaW50IDApLiAgKi8KKyAgICAgICYmIGxvb3BfcHJl aGVhZGVyX2VkZ2UgKGJvZHktPmxvb3BfZmF0aGVyKS0+c3JjLT5wcmV2X2JiCisgICAgICAmJiBC Ql9FTkQgKGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGJvZHktPmxvb3BfZmF0aGVyKS0+c3JjLT5wcmV2 X2JiKQorICAgICAgJiYgUFJFVl9JTlNOIChCQl9FTkQgKGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGJv ZHktPmxvb3BfZmF0aGVyKQorCQkJCS0+c3JjLT5wcmV2X2JiKSkKKyAgICAgICYmIElOU05fUCAo UFJFVl9JTlNOIChCQl9FTkQgKGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGJvZHktPmxvb3BfZmF0aGVy KQorCQkJCQktPnNyYy0+cHJldl9iYikpKQorICAgICAgJiYgKGluaXRpYWxfY29tcGFyZQorCSAg PSBQQVRURVJOIChQUkVWX0lOU04gKEJCX0VORCAobG9vcF9wcmVoZWFkZXJfZWRnZSAoYm9keS0+ bG9vcF9mYXRoZXIpCisJCQkJCSAgICAtPnNyYy0+cHJldl9iYikpKSkKKyAgICAgICYmIEdFVF9D T0RFIChpbml0aWFsX2NvbXBhcmUpID09IFNFVAorICAgICAgJiYgY2NfcmVnaXN0ZXIgKFhFWFAg KGluaXRpYWxfY29tcGFyZSwgMCksIFZPSURtb2RlKQorICAgICAgJiYgR0VUX0NPREUgKFhFWFAg KGluaXRpYWxfY29tcGFyZSwgMSkpID09IENPTVBBUkUKKyAgICAgICYmIENPTlNUX0lOVF9QIChY RVhQIChYRVhQIChpbml0aWFsX2NvbXBhcmUsIDEpLCAxKSkKKyAgICAgICYmIElOVFZBTCAoWEVY UCAoWEVYUCAoaW5pdGlhbF9jb21wYXJlLCAxKSwgMSkpID09IDApCisgICAgeworICAgICAgLyog RXh0cmFjdCB0aGUgaW50ZWdlciBkZWNyZW1lbnQgZnJvbSB0aGUgTFNISUZUUiBjb25kaXRpb24u ICAqLworICAgICAgZGVjcmVtZW50bnVtID0gKDEgPDwgKElOVFZBTCAoWEVYUCAoY291bnQsIDEp KSkpOworICAgICAgLyogRmluZCB0aGUgdmN0cCBwcmVkaWNhdGUgZ2VuZXJhdGlvbiBpbnNpZGUg dGhlIGxvb3AgYm9keSBCQi4gICovCisgICAgICBydHhfaW5zbiAqdmN0cF9pbnNuID0gYXJtX212 ZV9nZXRfbG9vcF91bmlxdWVfdmN0cCAoYm9keSk7CisgICAgICAvKiBJZiB3ZSBoYXZlIHN1Y2Nl c3NmdWxseSBmb3VuZCBvbmUgZXhhY3RseSB2Y3RwIHByZWRpY2F0ZS1nZW5lcmF0aW5nCisJIGlu c3RydWN0aW9uIHdpdGhpbiB0aGUgbG9vcCBhbmQgdGhlIG51bWJlciBieSB3aGljaCB3ZSBkZXBy ZWNhdGUgdGhlCisJIGxvb3AgY291bnRlciBpbiBlYWNoIGl0ZXJhdGlvbiBtYXRjaGVzIHRoZSBu dW1iZXIgb2YgbGFuZXMgb2YgdGhlCisJIHZjdHAgaW5zdHJ1Y3Rpb24sIHdlIGNhbiBhdHRlbXB0 IHRvIHR1cm4gdGhpcyBpbnRvIGEgZGxzdHAvbGV0cCBsb29wLgorCSAqLworICAgICAgaWYgKCF2 Y3RwX2luc24KKwkgIHx8IGRlY3JlbWVudG51bSAhPSBhcm1fbXZlX2dldF92Y3RwX2xhbmVzIChQ QVRURVJOICh2Y3RwX2luc24pKSkKKwlyZXR1cm4gR0VOX0lOVCAoMSk7CisKKyAgICAgIHJ0eF9p bnNuICppbnNuID0gMDsKKyAgICAgIHJ0eF9pbnNuICpjdXJfaW5zbiA9IDA7CisgICAgICBydHhf aW5zbiAqc2VxOworICAgICAgcnR4IHZjdHBfdnByX2dlbmVyYXRlZCA9IE5VTExfUlRYOworICAg ICAgcnR4IGluc25fdnByX3JlZ19vcGVyYW5kID0gTlVMTF9SVFg7CisgICAgICBpbnQgbmV3X2lj b2RlOworCisgICAgICAvKiBTY2FuIHRocm91Z2ggdGhlIGluc25zIGluIHRoZSBsb29wIGJiIGFu ZCBlbWl0IHRoZSB0cmFuc2Zvcm1lZCBiYgorCSBpbnNucyB0byBhIHNlcXVlbmNlLiAgKi8KKyAg ICAgIHN0YXJ0X3NlcXVlbmNlICgpOworICAgICAgRk9SX0JCX0lOU05TIChib2R5LCBpbnNuKQor CXsKKwkgIGlmIChHRVRfQ09ERSAoaW5zbikgPT0gQ09ERV9MQUJFTCB8fCBOT1RFX0lOU05fQkFT SUNfQkxPQ0tfUCAoaW5zbikpCisJICAgIGNvbnRpbnVlOworCSAgZWxzZSBpZiAoTk9URV9QIChp bnNuKSkKKwkgICAgZW1pdF9ub3RlICgoZW51bSBpbnNuX25vdGUpIE5PVEVfS0lORCAoaW5zbikp OworCSAgZWxzZSBpZiAoIUlOU05fUCAoaW5zbikpCisJICAgIHsKKwkgICAgICBlbmRfc2VxdWVu Y2UgKCk7CisJICAgICAgcmV0dXJuIEdFTl9JTlQgKDEpOworCSAgICB9CisJICAgICAvKiBXaGVu IHdlIGZpbmQgdGhlIHZjdHAgaW5zdHJ1Y3Rpb246IFRoaXMgbWF5IGJlIGZvbGxvd2VkIGJ5CisJ ICAgICBhIHNpZ24tZXh0ZW5kIGluc24gdG8gU0ltb2RlLiAgSWYgaXQgaXMsIHRoZW4gc2F2ZSB0 aGUKKwkgICAgIHNpZ24tZXh0ZW5kZWQgUkVHIGludG8gdmN0cF92cHJfZ2VuZXJhdGVkLiAgSWYg dGhlcmUgaXMgbm8KKwkgICAgIHNpZ24tZXh0ZW5kLCB0aGVuIHN0b3JlIHRoZSByYXcgb3V0cHV0 IG9mIHRoZSB2Y3RwLgorCSAgICAgRm9yIGFueSBWUFQtcHJlZGljYXRlZCBpbnN0cnVjdGlvbnMg d2UgbmVlZCB0byBlbnN1cmUgdGhhdAorCSAgICAgdGhlIFZQUiB0aGV5IHVzZSBpcyB0aGUgc2Ft ZSBhcyB0aGUgb25lIGdpdmVuIGhlcmUgYW5kCisJICAgICB0aGV5IG9mdGVuIGNvbnN1bWUgdGhl IG91dHB1dCBvZiBhIHN1YnJlZyBvZiB0aGUgU0ltb2RlCisJICAgICBzaWduLWV4dGVuZGVkIFZQ Ui1yZWcuICBBcyBhIHJlc3VsdCwgY29tcGFyaW5nIGFnYWluc3QgdGhlCisJICAgICBvdXRwdXQg b2YgdGhlIHNpZ24tZXh0ZW5kIGlzIG1vcmUgbGlrZWx5IHRvIHN1Y2NlZWQuCisJICAgICBUaGlz IGNvZGUgYWxzbyBndWFyYW50ZWVzIHRvIHVzIHRoYXQgdGhlIHZjdHAgY29tZXMgYmVmb3JlCisJ ICAgICBhbnkgaW5zdHJ1Y3Rpb25zIHRoYXQgdXNlIHRoZSBWUFIgd2l0aGluIHRoZSBsb29wLCBm b3IgdGhlCisJICAgICBkbHN0cC9sZXRwIHRyYW5zZm9ybSB0byBzdWNjZWVkLiAgKi8KKwkgIGVs c2UgaWYgKGluc24gPT0gdmN0cF9pbnNuKQorCSAgICB7CisJICAgICAgaWYgKEdFVF9DT0RFICgK KwkJICAgICAgWEVYUCAoUEFUVEVSTiAobmV4dF9ub25ub3RlX25vbmRlYnVnX2luc25fYmIgKGlu c24pKSwgMSkpCisJCSAgICAgID09IFNJR05fRVhURU5ECisJCSAgJiYgR0VUX0NPREUgKAorCQkJ IFhFWFAgKFBBVFRFUk4gKG5leHRfbm9ubm90ZV9ub25kZWJ1Z19pbnNuX2JiICgKKwkJCQkgICBu ZXh0X25vbm5vdGVfbm9uZGVidWdfaW5zbl9iYiAoaW5zbikpKSwKKwkJCSAgICAgICAxKSkKKwkJ CSA9PSBTVUJSRUcpCisJCXZjdHBfdnByX2dlbmVyYXRlZAorCQkgICAgPSBYRVhQIChQQVRURVJO IChuZXh0X25vbm5vdGVfbm9uZGVidWdfaW5zbl9iYiAoCisJCQkJbmV4dF9ub25ub3RlX25vbmRl YnVnX2luc25fYmIgKGluc24pKSksCisJCQkgICAgMCk7CisJICAgICAgZWxzZQorCQl2Y3RwX3Zw cl9nZW5lcmF0ZWQgPSBYRVhQIChQQVRURVJOIChpbnNuKSwgMCk7CisJICAgICAgLyogQWxzbyBl bWl0IGEgVVNFIG9mIHRoZSBzb3VyY2UgcmVnaXN0ZXIgb2YgdGhlIHZjdHAuCisJCSBUaGlzIGhv bGRzIHRoZSBudW1iZXIgb2YgZWxlbWVudHMgYmVpbmcgcHJvY2Vzc2VkCisJCSBieSB0aGUgbG9v cC4gIFRoaXMgbGF0ZXIgZ2V0cyBzdG9yZWQgaW50byBgY291bnRgLgorCQkgKi8KKwkgICAgICBl bWl0X3VzZSAoWFZFQ0VYUCAoWEVYUCAoUEFUVEVSTiAoaW5zbiksIDEpLCAwLCAwKSk7CisJICAg ICAgY29udGludWU7CisJICAgIH0KKwkgIC8qIElmIHRoZSBpbnNuIHBhdHRlcm4gcmVxdWlyZXMg dGhlIHVzZSBvZiB0aGUgVlBSLCB0aGVuIGl0CisJICAgICBpcyBhIFZQVC1wcmVkaWNhdGVkIGlu c3RydWN0aW9uLiAgKi8KKwkgIGVsc2UgaWYgKChpbnNuX3Zwcl9yZWdfb3BlcmFuZCA9IGFybV9n ZXRfcmVxdWlyZWRfdnByX3JlZyAoaW5zbikpCisJCSAgICE9IE5VTExfUlRYKQorCSAgICB7CisJ ICAgICAgLyogSWYgdGhlIFZQUiB2YWx1ZSBpcyBkaWZmZXJlbnQgdG8gdGhlIG9uZSBnZW5lcmF0 ZWQgYnkKKwkJIHRoZSB2Y3RwLCB0aGVuIGZhaWwgdGhlIGNvbnZlcnNpb24uICAqLworCSAgICAg IGlmICghcnR4X2VxdWFsX3AgKHZjdHBfdnByX2dlbmVyYXRlZCwgaW5zbl92cHJfcmVnX29wZXJh bmQpKQorCQl7CisJCSAgZW5kX3NlcXVlbmNlICgpOworCQkgIHJldHVybiBHRU5fSU5UICgxKTsK KwkJfQorCSAgICAgIC8qIElmIHRoZSBpbnNuIGRvZXMgdXNlIHRoZSBzYW1lIFZQUiBhcyB0aGUg b25lIGdlbmVyYXRlZAorCQkgYnkgdGhlIHZjdHAsIGl0IHdpbGwgbmVlZCB0byBiZSB0cmFuc2Zv cm1lZCBpbnRvIGl0cworCQkgbm9uLXByZWRpY2F0ZWQgdmVyc2lvbi4gIEFsc28gZW5zdXJlIHRo YXQgaXQncyBhIHZhbGlkCisJCSByZWNvZy1lZCBpbnN0cnVjdGlvbiB3aXRoIHRoZSBtdmVfdW5w cmVkaWNhdGVkX2luc24KKwkJIGF0cnJpYnV0ZS4gICovCisJICAgICAgZWxzZSBpZiAocmVjb2df bWVtb2l6ZWQgKGluc24pID49IDAKKwkJICAgICAgICYmIChuZXdfaWNvZGUgPSBnZXRfYXR0cl9t dmVfdW5wcmVkaWNhdGVkX2luc24gKGluc24pKSkKKwkJeworCQkgIGV4dHJhY3RfaW5zbiAoaW5z bik7CisJCSAgcnR4IGFycls4XTsKKwkJICBpbnQgaiA9IDA7CisKKwkJICAvKiBXaGVuIHRyYW5z Zm9ybWluZyBhIFZQVC1wcmVkaWNhdGVkIGluc3RydWN0aW9uCisJCSAgICAgaW50byBpdHMgdW5w cmVkaWNhdGVkIGVxdWl2YWxlbnQgd2UgbmVlZCB0byBkcm9wCisJCSAgICAgdGhlIFZQUiBvcGVy YW5kIGFuZCB3ZSBtYXkgbmVlZCB0byBhbHNvIGRyb3AgYQorCQkgICAgIG1lcmdlICJ2dW5pbml0 IiBpbnB1dCBvcGVyYW5kLCBkZXBlbmRpbmcgb24gdGhlCisJCSAgICAgaW5zdHJ1Y3Rpb24gcGF0 dGVybi4gIEhlcmUgZW5zdXJlIHRoYXQgd2UgaGF2ZSBhdAorCQkgICAgIG1vc3QgYSB0d28tb3Bl cmFuZCBkaWZmZXJlbmNlIGJldHdlZW4gdGhlIHR3bworCQkgICAgIGluc3RydW5jdGlvbnMuICAq LworCQkgIGludCBuX29wZXJhbmRzX2RpZmYgPSByZWNvZ19kYXRhLm5fb3BlcmFuZHMKKwkJCQkJ LSBpbnNuX2RhdGFbbmV3X2ljb2RlXS5uX29wZXJhbmRzOworCQkgIGdjY19hc3NlcnQgKG5fb3Bl cmFuZHNfZGlmZiA+IDAgJiYgbl9vcGVyYW5kc19kaWZmIDw9IDIpOworCisJCSAgLyogVGhlbiwg bG9vcCB0aHJvdWdoIHRoZSBvcGVyYW5kcyBvZiB0aGUgcHJlZGljYXRlZAorCQkgICAgIGluc3Ry dWN0aW9uLCBhbmQgcmV0YWluIHRoZSBvbmVzIHRoYXQgbWFwIHRvIHRoZQorCQkgICAgIHVucHJl ZGljYXRlZCBpbnN0cnVjdGlvbi4gICovCisJCSAgZm9yIChpbnQgaSA9IDA7IGkgPCByZWNvZ19k YXRhLm5fb3BlcmFuZHM7IGkrKykKKwkJICAgIHsKKwkJICAgICAgLyogSWdub3JlIHRoZSBWUFIg YW5kLCBpZiBuZWVkZWQsIHRoZSB2dW5pbml0CisJCQkgb3BlcmFuZC4gICovCisJCSAgICAgIGlm IChpbnNuX3Zwcl9yZWdfb3BlcmFuZCA9PSByZWNvZ19kYXRhLm9wZXJhbmRbaV0KKwkJCSAgfHwg KG5fb3BlcmFuZHNfZGlmZiA9PSAyCisJCQkgICAgICAmJiAhc3RyY21wIChyZWNvZ19kYXRhLmNv bnN0cmFpbnRzW2ldLCAiMCIpKSkKKwkJCWNvbnRpbnVlOworCQkgICAgICBlbHNlCisJCQl7CisJ CQkgIGFycltqXSA9IHJlY29nX2RhdGEub3BlcmFuZFtpXTsKKwkJCSAgaisrOworCQkJfQorCQkg ICAgfQorCisJCSAgLyogRmluYWxseSwgZW1pdCB0aGUgdXByZWRpY2F0ZWQgaW5zdHJ1Y3Rpb24u ICAqLworCQkgIHN3aXRjaCAoaikKKwkJICAgIHsKKwkJICAgICAgY2FzZSAxOgorCQkJZW1pdF9p bnNuIChHRU5fRkNOIChuZXdfaWNvZGUpIChhcnJbMF0pKTsKKwkJCWJyZWFrOworCQkgICAgICBj YXNlIDI6CisJCQllbWl0X2luc24gKEdFTl9GQ04gKG5ld19pY29kZSkgKGFyclswXSwgYXJyWzFd KSk7CisJCQlicmVhazsKKwkJICAgICAgY2FzZSAzOgorCQkJZW1pdF9pbnNuIChHRU5fRkNOIChu ZXdfaWNvZGUpIChhcnJbMF0sIGFyclsxXSwKKwkJCQkJCQlhcnJbMl0pKTsKKwkJCWJyZWFrOwor CQkgICAgICBjYXNlIDQ6CisJCQllbWl0X2luc24gKEdFTl9GQ04gKG5ld19pY29kZSkgKGFyclsw XSwgYXJyWzFdLCBhcnJbMl0sCisJCQkJCQkJYXJyWzNdKSk7CisJCQlicmVhazsKKwkJICAgICAg Y2FzZSA1OgorCQkJZW1pdF9pbnNuIChHRU5fRkNOIChuZXdfaWNvZGUpIChhcnJbMF0sIGFyclsx XSwgYXJyWzJdLAorCQkJCQkJCWFyclszXSwgYXJyWzRdKSk7CisJCQlicmVhazsKKwkJICAgICAg Y2FzZSA2OgorCQkJZW1pdF9pbnNuIChHRU5fRkNOIChuZXdfaWNvZGUpIChhcnJbMF0sIGFyclsx XSwgYXJyWzJdLAorCQkJCQkJCWFyclszXSwgYXJyWzRdLAorCQkJCQkJCWFycls1XSkpOworCQkJ YnJlYWs7CisJCSAgICAgIGNhc2UgNzoKKwkJCWVtaXRfaW5zbiAoR0VOX0ZDTiAobmV3X2ljb2Rl KSAoYXJyWzBdLCBhcnJbMV0sIGFyclsyXSwKKwkJCQkJCQlhcnJbM10sIGFycls0XSwgYXJyWzVd LAorCQkJCQkJCWFycls2XSkpOworCQkJYnJlYWs7CisJCSAgICAgIGRlZmF1bHQ6CisJCQlnY2Nf dW5yZWFjaGFibGUgKCk7CisJCSAgICB9CisJCX0KKwkgICAgICAvKiBJZiB3ZSBjYW4ndCBpZGVu dGlmeSB0aGUgSU5TTiBhcyBlaXRoZXIgYmVpbmcgZWl0aGVyCisJCSBmb3IgZGVsZXRpb24gb3Ig dG8gcmUtbWFwLCB0aGVuIHdlIGRvbid0IGtub3cgaG93IHRvCisJCSBoYW5kbGUgaXQsIHNvIGZh aWwgdGhlIHdob2xlIGNvbnZlcnNpb24uICAqLworCSAgICAgIGVsc2UKKwkJeworCQkgIGVuZF9z ZXF1ZW5jZSAoKTsKKwkJICByZXR1cm4gR0VOX0lOVCAoMSk7CisJCX0KKwkgICAgfQorCSAgLyog SW5zdHJ1Y3Rpb25zIHRoYXQgZG9udCdzIHJlcXVpcmUgdGhlIFZQUiBjYW4gYmUgY2FycmllZAor CSAgICAgb3ZlciBhcy1pcy4gICovCisJICBlbHNlIGlmIChERUJVR19JTlNOX1AgKGluc24pKQor CSAgICBlbWl0X2RlYnVnX2luc24gKFBBVFRFUk4gKGluc24pKTsKKwkgIGVsc2UKKwkgICAgZW1p dF9pbnNuIChQQVRURVJOIChpbnNuKSk7CisJfQorICAgICAgc2VxID0gZ2V0X2luc25zICgpOwor ICAgICAgZW5kX3NlcXVlbmNlICgpOworCisgICAgICAvKiBSZS13cml0ZSB0aGUgZW50aXJlIEJC IGNvbnRlbnRzIHdpdGggdGhlIHRyYW5zZm9ybWVkCisJIHNlcXVlbmNlLiAgKi8KKyAgICAgIEZP Ul9CQl9JTlNOU19TQUZFIChib2R5LCBpbnNuLCBjdXJfaW5zbikKKwlpZiAoIShHRVRfQ09ERSAo aW5zbikgPT0gQ09ERV9MQUJFTCB8fCBOT1RFX0lOU05fQkFTSUNfQkxPQ0tfUCAoaW5zbikpKQor CSAgZGVsZXRlX2luc24gKGluc24pOworICAgICAgZm9yIChpbnNuID0gc2VxOyBORVhUX0lOU04g KGluc24pOyBpbnNuID0gTkVYVF9JTlNOIChpbnNuKSkKKwlpZiAoTk9URV9QIChpbnNuKSkKKwkg IGVtaXRfbm90ZV9hZnRlciAoKGVudW0gaW5zbl9ub3RlKSBOT1RFX0tJTkQgKGluc24pLCAgQkJf RU5EIChib2R5KSk7CisJZWxzZSBpZiAoREVCVUdfSU5TTl9QIChpbnNuKSkKKwkgIGVtaXRfZGVi dWdfaW5zbl9hZnRlciAoUEFUVEVSTiAoaW5zbiksIEJCX0VORCAoYm9keSkpOworCWVsc2UKKwkg IGVtaXRfaW5zbl9hZnRlciAoUEFUVEVSTiAoaW5zbiksIEJCX0VORCAoYm9keSkpOworCisgICAg ICBlbWl0X2p1bXBfaW5zbl9hZnRlciAoUEFUVEVSTiAoaW5zbiksIEJCX0VORCAoYm9keSkpOwor ICAgICAgcmV0dXJuIEdFTl9JTlQgKGRlY3JlbWVudG51bSk7CisgICAgfQorICAvKiBCYWlsIG91 dDogd2UgY2FuJ3QgdXNlIGRsc3RwL2xldHAsIHNvIHJldHVybiAxIHRvIGFsbG93IGxvb3AtZG9s b29wIHRvIHRyeQorICAgICB0aGUgc3RhbmRhcmQgZGxzL2xlIHBhaXIuICAqLworICByZXR1cm4g R0VOX0lOVCAoMSk7Cit9CisKKy8qIFRhcmdldCBob29rIHRvIHRoZSBudW1iZXIgb2YgZWxlbWVu dHMgdG8gYmUgcHJvY2Vzc2VkIGJ5IGEgZGxzdHAvbGV0cCBsb29wCisgICBpbnRvIGBjb3VudGAg dG8gaW50aWFsaXNlIHRoZSBjb3VudGVyIHJlZ2lzdGVyLiAgVGhlIG51bWJlciBvZiBlbGVtZW50 cyB3YXMKKyAgIHByZXZpb3VzbHkgZXh0cmFjdGVkIGZyb20gdGhlIHZjdHAgaW5zbiBhbmQgcGxh Y2VkIGludG8gYSBVU0UgcnR4LgorICAgV2Ugb25seSBjaGVjayB0aGF0IHRoZSBkb2xvb3BfZW5k IHBhdHRlcm4gc3VjY2Vzc2Z1bGx5IGRlY3JlbWVudHMgYnkgYQorICAgbnVtYmVyIG90aGVyIHRo YW4gLTEgZm9yIGEgdmFsaWQgZGxzdHAvbGV0cCBsb29wLiAgTm8gb3RoZXIgY2hlY2tpbmcgaXMK KyAgIG5lZWRlZCBhcyB0aGF0IHdhcyBkb25lIHByZXZpb3VzbHkuICAqLworCitydHgKK2FybV9h bGxvd19lbGVtZW50d2lzZV9kb2xvb3BfcCAocnR4IGNvdW50LCBydHggbGFiZWwsIHJ0eCBkb2xv b3ApCit7CisgIGlmIChkb2xvb3AKKyAgICAgICYmIElOVFZBTCAoWEVYUCAoU0VUX1NSQyAoWFZF Q0VYUCAoUEFUVEVSTiAoZG9sb29wKSwgMCwgMSkpLCAxKSkgIT0gLTEKKyAgICAgICYmIEFSSVRI TUVUSUNfUCAoWEVYUCAoY291bnQsIDApKSkKKyAgICB7CisgICAgICBiYXNpY19ibG9jayBib2R5 ID0gQkxPQ0tfRk9SX0lOU04gKGxhYmVsKS0+cHJldl9iYjsKKyAgICAgIHJ0eF9pbnNuKiBpbnNu OworICAgICAgRk9SX0JCX0lOU05TIChib2R5LCBpbnNuKQorCXsKKwkgIGlmIChJTlNOX1AgKGlu c24pICYmIEdFVF9DT0RFIChQQVRURVJOIChpbnNuKSkgPT0gVVNFKQorCSAgICB7CisJICAgICAg cnR4IG51bV9lbGVtX3JlZyA9IGNvcHlfcnR4IChYRVhQIChQQVRURVJOIChpbnNuKSwgMCkpOwor CSAgICAgIGRlbGV0ZV9pbnNuIChpbnNuKTsKKwkgICAgICByZXR1cm4gbnVtX2VsZW1fcmVnOwor CSAgICB9CisJfQorICAgIH0KKyAgcmV0dXJuIGNvdW50OwogfQogCiAjaWYgQ0hFQ0tJTkdfUApk aWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9hcm0vaXRlcmF0b3JzLm1kIGIvZ2NjL2NvbmZpZy9hcm0v aXRlcmF0b3JzLm1kCmluZGV4IDI5MDYyY2Q2ZmIzLi5hYTJmZGFjMjJmMyAxMDA2NDQKLS0tIGEv Z2NjL2NvbmZpZy9hcm0vaXRlcmF0b3JzLm1kCisrKyBiL2djYy9jb25maWcvYXJtL2l0ZXJhdG9y cy5tZApAQCAtMTQ2NCw3ICsxNDY0LDkgQEAKIAogKGRlZmluZV9pbnRfYXR0ciBtb2RlMSBbKFZD VFA4USAiOCIpIChWQ1RQMTZRICIxNiIpIChWQ1RQMzJRICIzMiIpCiAJCQkoVkNUUDY0USAiNjQi KSAoVkNUUDhRX00gIjgiKSAoVkNUUDE2UV9NICIxNiIpCi0JCQkoVkNUUDMyUV9NICIzMiIpIChW Q1RQNjRRX00gIjY0IildKQorCQkJKFZDVFAzMlFfTSAiMzIiKSAoVkNUUDY0UV9NICI2NCIpCisJ CQkoRExTVFA4ICI4IikgKERMU1RQMTYgIjE2IikgKERMU1RQMzIgIjMyIikKKwkJCShETFNUUDY0 ICI2NCIpXSkKIAogOzsgQm90aCBraW5kcyBvZiByZXR1cm4gaW5zbi4KIChkZWZpbmVfY29kZV9p dGVyYXRvciBSRVRVUk5TIFtyZXR1cm4gc2ltcGxlX3JldHVybl0pCkBAIC0xNzczLDYgKzE3NzUs OCBAQAogKGRlZmluZV9pbnRfaXRlcmF0b3IgVVFSU0hMTFEgW1VRUlNITExfNjQgVVFSU0hMTF80 OF0pCiAoZGVmaW5lX2ludF9pdGVyYXRvciBTUVJTSFJMUSBbU1FSU0hSTF82NCBTUVJTSFJMXzQ4 XSkKIChkZWZpbmVfaW50X2l0ZXJhdG9yIFZTSExDUV9NIFtWU0hMQ1FfTV9TIFZTSExDUV9NX1Vd KQorKGRlZmluZV9pbnRfaXRlcmF0b3IgRExTVFAgW0RMU1RQOCBETFNUUDE2IERMU1RQMzIKKwkJ CQkgICBETFNUUDY0XSkKIAogOzsgRGVmaW5lIGl0ZXJhdG9ycyBmb3IgVkNNTEEgb3BlcmF0aW9u cwogKGRlZmluZV9pbnRfaXRlcmF0b3IgVkNNTEFfT1AgW1VOU1BFQ19WQ01MQQpkaWZmIC0tZ2l0 IGEvZ2NjL2NvbmZpZy9hcm0vbXZlLm1kIGIvZ2NjL2NvbmZpZy9hcm0vbXZlLm1kCmluZGV4IGIx YzhjMWM1NjlmLi4zYmFkZGFiNTkwNSAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9hcm0vbXZlLm1k CisrKyBiL2djYy9jb25maWcvYXJtL212ZS5tZApAQCAtMTA4MzcsMyArMTA4MzcsMzggQEAKICAg ICB9CiAgIERPTkU7CiB9KQorCis7OyBPcmlnaW5hbGx5IGV4cGFuZGVkIGJ5ICdwcmVkaWNhdGVk X2RvbG9vcF9lbmQnLgorKGRlZmluZV9pbnNuICIqcHJlZGljYXRlZF9kb2xvb3BfZW5kX2ludGVy bmFsIgorICBbKHNldCAocGMpCisJKGlmX3RoZW5fZWxzZQorCSAgIChnZSAocGx1czpTSSAocmVn OlNJIExSX1JFR05VTSkKKwkJCShtYXRjaF9vcGVyYW5kOlNJIDAgImNvbnN0X2ludF9vcGVyYW5k IiAiIikpCisJCShjb25zdF9pbnQgMCkpCisJIChsYWJlbF9yZWYgKG1hdGNoX29wZXJhbmQgMSAi IiAiIikpCisJIChwYykpKQorICAgKHNldCAocmVnOlNJIExSX1JFR05VTSkKKwkocGx1czpTSSAo cmVnOlNJIExSX1JFR05VTSkgKG1hdGNoX2R1cCAwKSkpCisgICAoY2xvYmJlciAocmVnOkNDIEND X1JFR05VTSkpXQorICAiVEFSR0VUXzMyQklUICYmIFRBUkdFVF9IQVZFX0xPQiAmJiBUQVJHRVRf SEFWRV9NVkUgJiYgVEFSR0VUX1RIVU1CMiIKKyAgeworICAgIGlmIChnZXRfYXR0cl9sZW5ndGgg KGluc24pID09IDQpCisgICAgICByZXR1cm4gImxldHBcdCV8bHIsICVsMSI7CisgICAgZWxzZQor ICAgICAgcmV0dXJuICJzdWJzXHQlfGxyLCAjJTA7Ymd0XHQlbDEiOworICB9CisgIFsoc2V0IChh dHRyICJsZW5ndGgiKQorCShpZl90aGVuX2Vsc2UKKwkgICAobHR1IChtaW51cyAocGMpIChtYXRj aF9kdXAgMSkpIChjb25zdF9pbnQgMTAyNCkpCisJICAgIChjb25zdF9pbnQgNCkKKwkgICAgKGNv bnN0X2ludCA2KSkpCisgICAoc2V0X2F0dHIgInR5cGUiICJicmFuY2giKV0pCisKKyhkZWZpbmVf aW5zbiAiZGxzdHA8bW9kZTE+X2luc24iCisgIFsKKyAgICAoc2V0IChyZWc6U0kgTFJfUkVHTlVN KQorCSAodW5zcGVjOlNJIFsobWF0Y2hfb3BlcmFuZDpTSSAwICJzX3JlZ2lzdGVyX29wZXJhbmQi ICJyIildCisJICBETFNUUCkpCisgIF0KKyAgIlRBUkdFVF8zMkJJVCAmJiBUQVJHRVRfSEFWRV9M T0IgJiYgVEFSR0VUX0hBVkVfTVZFICYmIFRBUkdFVF9USFVNQjIiCisgICJkbHN0cC48bW9kZTE+ XHQlfGxyLCAlMCIpClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvZ2Nj L2NvbmZpZy9hcm0vdGh1bWIyLm1kIGIvZ2NjL2NvbmZpZy9hcm0vdGh1bWIyLm1kCmluZGV4IGIy MzA5YTUyMTY1Li5hMjFlMjkwOTg3MiAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9hcm0vdGh1bWIy Lm1kCisrKyBiL2djYy9jb25maWcvYXJtL3RodW1iMi5tZApAQCAtMTYxMCwxMCArMTYxMCwxMSBA QAogOzsga25vd3Mgd2hhdCB0byBnZW5lcmF0ZS4KIChkZWZpbmVfZXhwYW5kICJkb2xvb3BfZW5k IgogICBbKHVzZSAobWF0Y2hfb3BlcmFuZCAwICIiICIiKSkgICAgICA7IGxvb3AgcHNldWRvCi0g ICAodXNlIChtYXRjaF9vcGVyYW5kIDEgIiIgIiIpKV0gICAgIDsgbGFiZWwKKyAgICh1c2UgKG1h dGNoX29wZXJhbmQgMSAiIiAiIikpICAgICAgOyBsYWJlbAorICAgKHVzZSAobWF0Y2hfb3BlcmFu ZCAyICIiICIiKSldICAgICA7IGRlY3JlbWVudCBjb25zdGFudAogICAiVEFSR0VUXzMyQklUIgog ICAiCi0geworewogICAgLyogQ3VycmVudGx5IFNNUyByZWxpZXMgb24gdGhlIGRvLWxvb3AgcGF0 dGVybiB0byByZWNvZ25pemUgbG9vcHMKICAgICAgIHdoZXJlICgxKSB0aGUgY29udHJvbCBwYXJ0 IGNvbnNpc3RzIG9mIGFsbCBpbnNucyBkZWZpbmluZyBhbmQvb3IKICAgICAgIHVzaW5nIGEgY2Vy dGFpbiAnY291bnQnIHJlZ2lzdGVyIGFuZCAoMikgdGhlIGxvb3AgY291bnQgY2FuIGJlCkBAIC0x NjIzLDQxICsxNjI0LDY4IEBACiAKICAgICAgIEFsc28gdXNlZCB0byBpbXBsZW1lbnQgdGhlIGxv dyBvdmVyIGhlYWQgbG9vcHMgZmVhdHVyZSwgd2hpY2ggaXMgcGFydCBvZgogICAgICAgdGhlIEFy bXY4LjEtTSBNYWlubGluZSBMb3cgT3ZlcmhlYWQgQnJhbmNoIChMT0IpIGV4dGVuc2lvbi4gICov Ci0gICBpZiAob3B0aW1pemUgPiAwICYmIChmbGFnX21vZHVsb19zY2hlZCB8fCBUQVJHRVRfSEFW RV9MT0IpKQotICAgewotICAgICBydHggczA7Ci0gICAgIHJ0eCBiY29tcDsKLSAgICAgcnR4IGxv Y19yZWY7Ci0gICAgIHJ0eCBjY19yZWc7Ci0gICAgIHJ0eCBpbnNuOwotICAgICBydHggY21wOwot Ci0gICAgIGlmIChHRVRfTU9ERSAob3BlcmFuZHNbMF0pICE9IFNJbW9kZSkKLSAgICAgICBGQUlM OwotCi0gICAgIHMwID0gb3BlcmFuZHMgWzBdOwotCi0gICAgIC8qIExvdyBvdmVyIGhlYWQgbG9v cCBpbnN0cnVjdGlvbnMgcmVxdWlyZSB0aGUgZmlyc3Qgb3BlcmFuZCB0byBiZSBMUi4gICovCi0g ICAgIGlmIChUQVJHRVRfSEFWRV9MT0IgJiYgYXJtX3RhcmdldF9pbnNuX29rX2Zvcl9sb2IgKG9w ZXJhbmRzIFsxXSkpCi0gICAgICAgczAgPSBnZW5fcnR4X1JFRyAoU0ltb2RlLCBMUl9SRUdOVU0p OwotCi0gICAgIGlmIChUQVJHRVRfVEhVTUIyKQotICAgICAgIGluc24gPSBlbWl0X2luc24gKGdl bl90aHVtYjJfYWRkc2kzX2NvbXBhcmUwIChzMCwgczAsIEdFTl9JTlQgKC0xKSkpOwotICAgICBl bHNlCi0gICAgICAgaW5zbiA9IGVtaXRfaW5zbiAoZ2VuX2FkZHNpM19jb21wYXJlMCAoczAsIHMw LCBHRU5fSU5UICgtMSkpKTsKLQotICAgICBjbXAgPSBYVkVDRVhQIChQQVRURVJOIChpbnNuKSwg MCwgMCk7Ci0gICAgIGNjX3JlZyA9IFNFVF9ERVNUIChjbXApOwotICAgICBiY29tcCA9IGdlbl9y dHhfTkUgKFZPSURtb2RlLCBjY19yZWcsIGNvbnN0MF9ydHgpOwotICAgICBsb2NfcmVmID0gZ2Vu X3J0eF9MQUJFTF9SRUYgKFZPSURtb2RlLCBvcGVyYW5kcyBbMV0pOwotICAgICBlbWl0X2p1bXBf aW5zbiAoZ2VuX3J0eF9TRVQgKHBjX3J0eCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBnZW5fcnR4X0lGX1RIRU5fRUxTRSAoVk9JRG1vZGUsIGJjb21wLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsb2NfcmVmLCBwY19y dHgpKSk7Ci0gICAgIERPTkU7Ci0gICB9Ci0gZWxzZQotICAgRkFJTDsKLSB9IikKKyAgaWYgKG9w dGltaXplID4gMCAmJiAoZmxhZ19tb2R1bG9fc2NoZWQgfHwgVEFSR0VUX0hBVkVfTE9CKSkKKyAg ICB7CisgICAgICBydHggczA7CisgICAgICBydHggYmNvbXA7CisgICAgICBydHggbG9jX3JlZjsK KyAgICAgIHJ0eCBjY19yZWc7CisgICAgICBydHggaW5zbjsKKyAgICAgIHJ0eCBjbXA7CisgICAg ICBydHggZGVjcmVtZW50X251bTsKKworICAgICAgaWYgKEdFVF9NT0RFIChvcGVyYW5kc1swXSkg IT0gU0ltb2RlKQorCUZBSUw7CisKKyAgICAgIHMwID0gb3BlcmFuZHNbMF07CisKKyAgICAgICBp ZiAoVEFSR0VUX0hBVkVfTE9CICYmIGFybV90YXJnZXRfaW5zbl9va19mb3JfbG9iIChvcGVyYW5k c1sxXSkpCisJeworCSAgczAgPSBnZW5fcnR4X1JFRyAoU0ltb2RlLCBMUl9SRUdOVU0pOworCisJ ICAvKiBJZiB3ZSBoYXZlIGEgY29tcGF0aWJlIE1WRSB0YXJnZXQsIHRyeSBhbmQgYW5hbHlzZSB0 aGUgbG9vcAorCSAgICAgY29udGVudHMgdG8gZGV0ZXJtaW5lIGlmIHdlIGNhbiB1c2UgcHJlZGlj YXRlZCBkbHN0cC9sZXRwCisJICAgICBsb29waW5nLiAgKi8KKwkgIGlmIChUQVJHRVRfSEFWRV9N VkUgJiYgVEFSR0VUX1RIVU1CMgorCSAgICAgICYmIChkZWNyZW1lbnRfbnVtID0gYXJtX2F0dGVt cHRfZGxzdHBfdHJhbnNmb3JtIChvcGVyYW5kc1sxXSwKKwkJCQkJCQkgICAgICAgb3BlcmFuZHNb Ml0pKQorCSAgICAgICYmIChJTlRWQUwgKGRlY3JlbWVudF9udW0pICE9IDEpKQorCSAgICB7CisJ ICAgICAgaW5zbiA9IGVtaXRfaW5zbgorCQkgICAgICAoZ2VuX3RodW1iMl9hZGRzaTNfY29tcGFy ZTAKKwkJCSAgKHMwLCBzMCwgR0VOX0lOVCAoKC0xKSAqIChJTlRWQUwgKGRlY3JlbWVudF9udW0p KSkpKTsKKwkgICAgICBjbXAgPSBYVkVDRVhQIChQQVRURVJOIChpbnNuKSwgMCwgMCk7CisJICAg ICAgY2NfcmVnID0gU0VUX0RFU1QgKGNtcCk7CisJICAgICAgYmNvbXAgPSBnZW5fcnR4X0dFIChW T0lEbW9kZSwgY2NfcmVnLCBjb25zdDBfcnR4KTsKKwkgICAgICBsb2NfcmVmID0gZ2VuX3J0eF9M QUJFTF9SRUYgKFZPSURtb2RlLCBvcGVyYW5kc1sxXSk7CisJICAgICAgZW1pdF9qdW1wX2luc24g KGdlbl9ydHhfU0VUIChwY19ydHgsCisJCQkJICAgICAgIGdlbl9ydHhfSUZfVEhFTl9FTFNFIChW T0lEbW9kZSwgYmNvbXAsCisJCQkJCQkJICAgICBsb2NfcmVmLCBwY19ydHgpKSk7CisJICAgICAg RE9ORTsKKwkgICAgfQorCisJICAvKiBPdGhlcndpc2UsIHRyeSBzdGFuZGFyZCBkZWNyZW1lbnQt Ynktb25lIGRscy9sZSBsb29waW5nLiAgKi8KKwkgIGlmIChUQVJHRVRfVEhVTUIyKQorCSAgICBp bnNuID0gZW1pdF9pbnNuIChnZW5fdGh1bWIyX2FkZHNpM19jb21wYXJlMCAoczAsIHMwLAorCQkJ CQkJCSAgR0VOX0lOVCAoLTEpKSk7CisJICBlbHNlCisJICAgIGluc24gPSBlbWl0X2luc24gKGdl bl9hZGRzaTNfY29tcGFyZTAgKHMwLCBzMCwgR0VOX0lOVCAoLTEpKSk7CisKKwkgIGNtcCA9IFhW RUNFWFAgKFBBVFRFUk4gKGluc24pLCAwLCAwKTsKKwkgIGNjX3JlZyA9IFNFVF9ERVNUIChjbXAp OworCSAgYmNvbXAgPSBnZW5fcnR4X05FIChWT0lEbW9kZSwgY2NfcmVnLCBjb25zdDBfcnR4KTsK KwkgIGxvY19yZWYgPSBnZW5fcnR4X0xBQkVMX1JFRiAoVk9JRG1vZGUsIG9wZXJhbmRzWzFdKTsK KwkgIGVtaXRfanVtcF9pbnNuIChnZW5fcnR4X1NFVCAocGNfcnR4LAorCQkJCSAgICAgICBnZW5f cnR4X0lGX1RIRU5fRUxTRSAoVk9JRG1vZGUsIGJjb21wLAorCQkJCQkJCSAgICAgbG9jX3JlZiwg cGNfcnR4KSkpOworCSAgRE9ORTsKKwl9CisgICAgICBlbHNlCisJRkFJTDsKKyAgICB9CisgIGVs c2UKKyAgICBGQUlMOworfSIpCiAKIChkZWZpbmVfaW5zbiAiKmNsZWFyX2Fwc3IiCiAgIFsodW5z cGVjX3ZvbGF0aWxlOlNJIFsoY29uc3RfaW50IDApXSBWVU5TUEVDX0NMUk1fQVBTUikKQEAgLTE3 NTUsNyArMTc4MywzNyBAQAogICB7CiAgICAgaWYgKFJFR05PIChvcGVyYW5kc1swXSkgPT0gTFJf UkVHTlVNKQogICAgICAgewotCWVtaXRfaW5zbiAoZ2VuX2Rsc19pbnNuIChvcGVyYW5kc1swXSkp OworCS8qIFBpY2sgb3V0IHRoZSBudW1iZXIgYnkgd2hpY2ggd2UgYXJlIGRlY3JlbWVudGluZyB0 aGUgbG9vcCBjb3VudGVyCisJICAgaW4gZXZlcnkgaXRlcmF0aW9uLiAgSWYgaXQncyA+IDEsIHRo ZW4gdXNlIGRsc3RwLiAgKi8KKwlpbnQgY29uc3RfaW50X2RlY19udW0KKwkgICAgID0gYWJzIChJ TlRWQUwgKFhFWFAgKFhFWFAgKFhWRUNFWFAgKFBBVFRFUk4gKG9wZXJhbmRzWzFdKSwgMCwgMSks CisJCQkJICAxKSwKKwkJCSAgICAxKSkpOworCXN3aXRjaCAoY29uc3RfaW50X2RlY19udW0pCisJ ICB7CisJICAgIGNhc2UgMTY6CisJICAgICAgZW1pdF9pbnNuIChnZW5fZGxzdHA4X2luc24gKG9w ZXJhbmRzWzBdKSk7CisJICAgICAgYnJlYWs7CisKKwkgICAgY2FzZSA4OgorCSAgICAgIGVtaXRf aW5zbiAoZ2VuX2Rsc3RwMTZfaW5zbiAob3BlcmFuZHNbMF0pKTsKKwkgICAgICBicmVhazsKKwor CSAgICBjYXNlIDQ6CisJICAgICAgZW1pdF9pbnNuIChnZW5fZGxzdHAzMl9pbnNuIChvcGVyYW5k c1swXSkpOworCSAgICAgIGJyZWFrOworCisJICAgIGNhc2UgMjoKKwkgICAgICBlbWl0X2luc24g KGdlbl9kbHN0cDY0X2luc24gKG9wZXJhbmRzWzBdKSk7CisJICAgICAgYnJlYWs7CisKKwkgICAg Y2FzZSAxOgorCSAgICAgIGVtaXRfaW5zbiAoZ2VuX2Rsc19pbnNuIChvcGVyYW5kc1swXSkpOwor CSAgICAgIGJyZWFrOworCisJICAgIGRlZmF1bHQ6CisJICAgICAgZ2NjX3VucmVhY2hhYmxlICgp OworCSAgfQogCURPTkU7CiAgICAgICB9CiAgICAgZWxzZQpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZp Zy9hcm0vdW5zcGVjcy5tZCBiL2djYy9jb25maWcvYXJtL3Vuc3BlY3MubWQKaW5kZXggNzc0OGU3 ODQzNzkuLjc0NGU3YWI1NzMxIDEwMDY0NAotLS0gYS9nY2MvY29uZmlnL2FybS91bnNwZWNzLm1k CisrKyBiL2djYy9jb25maWcvYXJtL3Vuc3BlY3MubWQKQEAgLTU3OSw2ICs1NzksMTAgQEAKICAg VkNUUDE2UQogICBWQ1RQMzJRCiAgIFZDVFA2NFEKKyAgRExTVFA4CisgIERMU1RQMTYKKyAgRExT VFAzMgorICBETFNUUDY0CiAgIFZQTk9UCiAgIFZDUkVBVEVRX0YKICAgVkNWVFFfTl9UT19GX1MK ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvYmZpbi9iZmluLm1kIGIvZ2NjL2NvbmZpZy9iZmluL2Jm aW4ubWQKaW5kZXggNTZiMjQ3MjZiYzIuLjNiMzFlZTNhMWVlIDEwMDY0NAotLS0gYS9nY2MvY29u ZmlnL2JmaW4vYmZpbi5tZAorKysgYi9nY2MvY29uZmlnL2JmaW4vYmZpbi5tZApAQCAtMTk1OSw3 ICsxOTU5LDggQEAKIAkJICAgKHBsdXM6U0kgKG1hdGNoX2R1cCAwKQogCQkJICAgIChjb25zdF9p bnQgLTEpKSkKIAkgICAgICAodW5zcGVjIFsoY29uc3RfaW50IDApXSBVTlNQRUNfTFNFVFVQX0VO RCkKLQkgICAgICAoY2xvYmJlciAobWF0Y2hfZHVwIDIpKQorCSAgICAgIChjbG9iYmVyIChtYXRj aF9kdXAgMykpCisJICAgICAgKG1hdGNoX29wZXJhbmQgMiAiIiAiIikKIAkgICAgICAoY2xvYmJl ciAocmVnOkJJIFJFR19DQykpXSldIDsgbWF0Y2hfc2NyYXRjaAogICAiIgogewpAQCAtMTk2Nyw3 ICsxOTY4LDcgQEAKICAgaWYgKEdFVF9NT0RFIChvcGVyYW5kc1swXSkgIT0gU0ltb2RlKQogICAg IEZBSUw7CiAgIGJmaW5faGFyZHdhcmVfbG9vcCAoKTsKLSAgb3BlcmFuZHNbMl0gPSBnZW5fcnR4 X1NDUkFUQ0ggKFNJbW9kZSk7CisgIG9wZXJhbmRzWzNdID0gZ2VuX3J0eF9TQ1JBVENIIChTSW1v ZGUpOwogfSkKIAogKGRlZmluZV9pbnNuICJsb29wX2VuZCIKZGlmZiAtLWdpdCBhL2djYy9jb25m aWcvYzZ4L2M2eC5tZCBiL2djYy9jb25maWcvYzZ4L2M2eC5tZAppbmRleCA2MDExMDQxMGQwYi4u ZGU0ZjRhNTZkOTkgMTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvYzZ4L2M2eC5tZAorKysgYi9nY2Mv Y29uZmlnL2M2eC9jNngubWQKQEAgLTE0MjksMTMgKzE0MjksMTQgQEAKIAkgICAgICAoc2V0ICht YXRjaF9kdXAgMCkKIAkJICAgKHBsdXM6U0kgKG1hdGNoX2R1cCAwKQogCQkJICAgIChjb25zdF9p bnQgLTEpKSkKLQkgICAgICAoY2xvYmJlciAobWF0Y2hfZHVwIDIpKV0pXSA7IG1hdGNoX3NjcmF0 Y2gKKwkgICAgICAoY2xvYmJlciAobWF0Y2hfZHVwIDMpKSA7IG1hdGNoX3NjcmF0Y2gKKwkgICAg ICAobWF0Y2hfb3BlcmFuZCAyICIiICIiKV0pXQogICAiVEFSR0VUX0lOU05TXzY0UExVUyAmJiBv cHRpbWl6ZSIKIHsKICAgLyogVGhlIGxvb3Agb3B0aW1pemVyIGRvZXNuJ3QgY2hlY2sgdGhlIHBy ZWRpY2F0ZXMuLi4gKi8KICAgaWYgKEdFVF9NT0RFIChvcGVyYW5kc1swXSkgIT0gU0ltb2RlKQog ICAgIEZBSUw7Ci0gIG9wZXJhbmRzWzJdID0gZ2VuX3J0eF9TQ1JBVENIIChTSW1vZGUpOworICBv cGVyYW5kc1szXSA9IGdlbl9ydHhfU0NSQVRDSCAoU0ltb2RlKTsKIH0pCiAKIChkZWZpbmVfaW5z biAibXZpbGMiCmRpZmYgLS1naXQgYS9nY2MvY29uZmlnL2lhNjQvaWE2NC5tZCBiL2djYy9jb25m aWcvaWE2NC9pYTY0Lm1kCmluZGV4IDVkMWQ0N2RhNTViLi41YjI0YmQ3NmFjZSAxMDA2NDQKLS0t IGEvZ2NjL2NvbmZpZy9pYTY0L2lhNjQubWQKKysrIGIvZ2NjL2NvbmZpZy9pYTY0L2lhNjQubWQK QEAgLTM5NTYsNyArMzk1Niw4IEBACiAKIChkZWZpbmVfZXhwYW5kICJkb2xvb3BfZW5kIgogICBb KHVzZSAobWF0Y2hfb3BlcmFuZCAwICIiICIiKSkJOyBsb29wIHBzZXVkbwotICAgKHVzZSAobWF0 Y2hfb3BlcmFuZCAxICIiICIiKSldCTsgbGFiZWwKKyAgICh1c2UgKG1hdGNoX29wZXJhbmQgMSAi IiAiIikpCTsgbGFiZWwKKyAgICh1c2UgKG1hdGNoX29wZXJhbmQgMiAiIiAiIikpXSAgICAgOyBk ZWNyZW1lbnQgY29uc3RhbnQKICAgIiIKIHsKICAgaWYgKEdFVF9NT0RFIChvcGVyYW5kc1swXSkg IT0gREltb2RlKQpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9wZHAxMS9wZHAxMS5tZCBiL2djYy9j b25maWcvcGRwMTEvcGRwMTEubWQKaW5kZXggYTQ2ZWZjMWVmNzguLmFhMzU5OTU1YzNjIDEwMDY0 NAotLS0gYS9nY2MvY29uZmlnL3BkcDExL3BkcDExLm1kCisrKyBiL2djYy9jb25maWcvcGRwMTEv cGRwMTEubWQKQEAgLTMzMiw3ICszMzIsOCBAQAogCQkgICAgKHBjKSkpCiAJICAgICAgKHNldCAo bWF0Y2hfZHVwIDApCiAJCSAgIChwbHVzOkhJIChtYXRjaF9kdXAgMCkKLQkJCSAoY29uc3RfaW50 IC0xKSkpXSldCisJCQkgKGNvbnN0X2ludCAtMSkpKQorCSAgICAgIChtYXRjaF9vcGVyYW5kIDIg IiIgIiIpXSldCiAgICJUQVJHRVRfNDBfUExVUyIKICAgInsKICAgICBpZiAoR0VUX01PREUgKG9w ZXJhbmRzWzBdKSAhPSBISW1vZGUpCmRpZmYgLS1naXQgYS9nY2MvY29uZmlnL3BydS9wcnUubWQg Yi9nY2MvY29uZmlnL3BydS9wcnUubWQKaW5kZXggYmRjNWFkNzliYTAuLjk5MGNkZmUwOTc0IDEw MDY0NAotLS0gYS9nY2MvY29uZmlnL3BydS9wcnUubWQKKysrIGIvZ2NjL2NvbmZpZy9wcnUvcHJ1 Lm1kCkBAIC0xNjM2LDcgKzE2MzYsOCBAQAogCiAoZGVmaW5lX2V4cGFuZCAiZG9sb29wX2VuZCIK ICAgWyh1c2UgKG1hdGNoX29wZXJhbmQgMCAibm9uaW1tZWRpYXRlX29wZXJhbmQiKSkKLSAgICh1 c2UgKGxhYmVsX3JlZiAobWF0Y2hfb3BlcmFuZCAxICIiKSkpXQorICAgKHVzZSAobGFiZWxfcmVm IChtYXRjaF9vcGVyYW5kIDEgIiIpKSkKKyAgICh1c2UgKG1hdGNoX29wZXJhbmQgMiAiIiAiIikp XSAgICAgOyBkZWNyZW1lbnQgY29uc3RhbnQKICAgIlRBUkdFVF9PUFRfTE9PUCIKIHsKICAgaWYg KEdFVF9DT0RFIChvcGVyYW5kc1swXSkgPT0gUkVHICYmIEdFVF9NT0RFIChvcGVyYW5kc1swXSkg PT0gUUltb2RlKQpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9yczYwMDAvcnM2MDAwLm1kIGIvZ2Nj L2NvbmZpZy9yczYwMDAvcnM2MDAwLm1kCmluZGV4IGFkNWE0Y2YyZWY4Li5mZGFlYjZhMDJjYSAx MDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9yczYwMDAvcnM2MDAwLm1kCisrKyBiL2djYy9jb25maWcv cnM2MDAwL3JzNjAwMC5tZApAQCAtMTM0MjIsNyArMTM0MjIsOCBAQAogCiAoZGVmaW5lX2V4cGFu ZCAiZG9sb29wX2VuZCIKICAgWyh1c2UgKG1hdGNoX29wZXJhbmQgMCkpCTsgbG9vcCBwc2V1ZG8K LSAgICh1c2UgKG1hdGNoX29wZXJhbmQgMSkpXQk7IGxhYmVsCisgICAodXNlIChtYXRjaF9vcGVy YW5kIDEpKQk7IGxhYmVsCisgICAodXNlIChtYXRjaF9vcGVyYW5kIDIgIiIgIiIpKV0gICAgIDsg ZGVjcmVtZW50IGNvbnN0YW50CiAgICIiCiB7CiAgIGlmIChHRVRfTU9ERSAob3BlcmFuZHNbMF0p ICE9IFBtb2RlKQpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9zMzkwL3MzOTAubWQgYi9nY2MvY29u ZmlnL3MzOTAvczM5MC5tZAppbmRleCA5NjI5MjdjMzExMi4uYmFkMzE3ZmRiYTcgMTAwNjQ0Ci0t LSBhL2djYy9jb25maWcvczM5MC9zMzkwLm1kCisrKyBiL2djYy9jb25maWcvczM5MC9zMzkwLm1k CkBAIC05NzgwLDcgKzk3ODAsOCBAQAogCiAoZGVmaW5lX2V4cGFuZCAiZG9sb29wX2VuZCIKICAg Wyh1c2UgKG1hdGNoX29wZXJhbmQgMCAiIiAiIikpICAgICAgICA7IGxvb3AgcHNldWRvCi0gICAo dXNlIChtYXRjaF9vcGVyYW5kIDEgIiIgIiIpKV0gICAgICAgOyBsYWJlbAorICAgKHVzZSAobWF0 Y2hfb3BlcmFuZCAxICIiICIiKSkgICAgICAgIDsgbGFiZWwKKyAgICh1c2UgKG1hdGNoX29wZXJh bmQgMiAiIiAiIikpXSAgICAgICA7IGRlY3JlbWVudCBjb25zdGFudAogICAiIgogewogICBpZiAo R0VUX01PREUgKG9wZXJhbmRzWzBdKSA9PSBTSW1vZGUpCmRpZmYgLS1naXQgYS9nY2MvY29uZmln L3NoL3NoLm1kIGIvZ2NjL2NvbmZpZy9zaC9zaC5tZAppbmRleCA1OWE3YjIxNjQzMy4uNWI4ZDc0 ZDYwMjkgMTAwNjQ0Ci0tLSBhL2djYy9jb25maWcvc2gvc2gubWQKKysrIGIvZ2NjL2NvbmZpZy9z aC9zaC5tZApAQCAtNjQwNCw3ICs2NDA0LDggQEAKIAkJCQkgKHBjKSkpCiAJICAgICAgKHNldCAo bWF0Y2hfZHVwIDApCiAJCSAgIChwbHVzOlNJIChtYXRjaF9kdXAgMCkgKGNvbnN0X2ludCAtMSkp KQotCSAgICAgIChjbG9iYmVyIChyZWc6U0kgVF9SRUcpKV0pXQorCSAgICAgIChjbG9iYmVyIChy ZWc6U0kgVF9SRUcpKQorCSAgICAgIChtYXRjaF9vcGVyYW5kIDIgIiIgIiIpXSldCiAgICJUQVJH RVRfU0gyIgogewogICBpZiAoR0VUX01PREUgKG9wZXJhbmRzWzBdKSAhPSBTSW1vZGUpCmRpZmYg LS1naXQgYS9nY2MvY29uZmlnL3Y4NTAvdjg1MC5tZCBiL2djYy9jb25maWcvdjg1MC92ODUwLm1k CmluZGV4IDZjYTMxZTNmNDNmLi44ZDA4MTJhYmFjNyAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy92 ODUwL3Y4NTAubWQKKysrIGIvZ2NjL2NvbmZpZy92ODUwL3Y4NTAubWQKQEAgLTE0MzQsNyArMTQz NCw4IEBACiAKIChkZWZpbmVfZXhwYW5kICJkb2xvb3BfZW5kIgogIFsodXNlIChtYXRjaF9vcGVy YW5kIDAgIiIgIiIpKSAgICAgICAgOyBsb29wIHBzZXVkbwotICAodXNlIChtYXRjaF9vcGVyYW5k IDEgIiIgIiIpKV0gICAgICAgOyBsYWJlbAorICAodXNlIChtYXRjaF9vcGVyYW5kIDEgIiIgIiIp KSAgICAgICAgOyBsYWJlbAorICAodXNlIChtYXRjaF9vcGVyYW5kIDIgIiIgIiIpKV0gICAgICAg OyBkZWNyZW1lbnQgY29uc3RhbnQKICAgIlRBUkdFVF9WODUwRTNWNV9VUCAmJiBUQVJHRVRfTE9P UCIKICAgewogICAgIHJ0eCBsb29wX2NudCA9IG9wZXJhbmRzWzBdOwpkaWZmIC0tZ2l0IGEvZ2Nj L2NvbmZpZy94dGVuc2EveHRlbnNhLm1kIGIvZ2NjL2NvbmZpZy94dGVuc2EveHRlbnNhLm1kCmlu ZGV4IDYwODExMGMyMGJjLi41N2E0ZTJjYTM1MyAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy94dGVu c2EveHRlbnNhLm1kCisrKyBiL2djYy9jb25maWcveHRlbnNhL3h0ZW5zYS5tZApAQCAtMjAxNiwx MyArMjAxNiwxNCBAQAogICAgICAgICAgICAgICAgICAgIChwbHVzOlNJIChtYXRjaF9kdXAgMCkK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoY29uc3RfaW50IC0xKSkpCiAgICAgICAgICAg ICAgICh1bnNwZWMgWyhjb25zdF9pbnQgMCldIFVOU1BFQ19MU0VUVVBfRU5EKQotICAgICAgICAg ICAgICAoY2xvYmJlciAobWF0Y2hfZHVwIDIpKV0pXSA7IG1hdGNoX3NjcmF0Y2gKKyAgICAgICAg ICAgICAgKGNsb2JiZXIgKG1hdGNoX2R1cCAzKSkgOyBtYXRjaF9zY3JhdGNoCisJICAgICAgKG1h dGNoX29wZXJhbmQgMiAiIiAiIildKV0KICAgIlRBUkdFVF9MT09QUyAmJiBvcHRpbWl6ZSIKIHsK ICAgLyogVGhlIGxvb3Agb3B0aW1pemVyIGRvZXNuJ3QgY2hlY2sgdGhlIHByZWRpY2F0ZXMuLi4g Ki8KICAgaWYgKEdFVF9NT0RFIChvcGVyYW5kc1swXSkgIT0gU0ltb2RlKQogICAgIEZBSUw7Ci0g IG9wZXJhbmRzWzJdID0gZ2VuX3J0eF9TQ1JBVENIIChTSW1vZGUpOworICBvcGVyYW5kc1szXSA9 IGdlbl9ydHhfU0NSQVRDSCAoU0ltb2RlKTsKIH0pCiAKIAwKZGlmZiAtLWdpdCBhL2djYy9kb2Mv dG0udGV4aSBiL2djYy9kb2MvdG0udGV4aQppbmRleCAxMTBmOGRmYTBhOS4uYThjZmNkNzQ5N2Qg MTAwNjQ0Ci0tLSBhL2djYy9kb2MvdG0udGV4aQorKysgYi9nY2MvZG9jL3RtLnRleGkKQEAgLTEx Nzc0LDYgKzExNzc0LDE0IEBAIGxvb3BzLCBhbmQgd2lsbCBoZWxwIGl2b3B0cyB0byBtYWtlIHNv bWUgZGVjaXNpb25zLgogVGhlIGRlZmF1bHQgdmVyc2lvbiBvZiB0aGlzIGhvb2sgcmV0dXJucyBm YWxzZS4KIEBlbmQgZGVmdHlwZWZuCiAKK0BkZWZ0eXBlZm4ge1RhcmdldCBIb29rfSBydHggVEFS R0VUX0FMTE9XX0VMRU1FTlRXSVNFX0RPTE9PUF9QIChydHggQHZhcntjb3VudH0sIHJ0eCBAdmFy e2xhYmVsfSwgcnR4IEB2YXJ7ZG9sb29wfSkKK1RoaXMgdGFyZ2V0IGhvb2sgYWxsb3dzIHRoZSB0 YXJnZXQgdG8gc3VwcG9ydCBsb29wLWRvbG9vcCBvcHRpbWlzYXRpb25zCit3aGVyZSB0aGUgdmFs dWUgdGhhdCBnZXRzIHB1dCBpbnRvIHRoZSBsb29wIGNvdW50ZXIgcmVnaXN0ZXIgaXMgbm90IGEK K3ByZS1jYWxjdWxhdGlvbiBvZiB0aGUgbnVtYmVyIG9mIGl0ZXJhdGlvbiBvZiB0aGUgbG9vcC4g IEZvciBpbnN0YW5jZSwKK3RoZSB2YWx1ZSB1c2VkIGNhbiBiZSB0aGUgbnVtYmVyIG9mIGVsZW1l bnRzIHRoYXQgdGhlIGxvb3Agd2lsbCBwcm9jZXNzLgorVGhlIGRlZmF1bHQgdmVyc2lvbiBvZiB0 aGlzIGhvb2sgcmV0dXJucyB0aGUgc2FtZSBydHggaXQgd2FzIGdpdmVuLgorQGVuZCBkZWZ0eXBl Zm4KKwogQGRlZnR5cGV2ciB7VGFyZ2V0IEhvb2t9IGJvb2wgVEFSR0VUX0hBVkVfQ09VTlRfUkVH X0RFQ1JfUAogUmV0dXJuIHRydWUgaWYgdGhlIHRhcmdldCBzdXBwb3J0cyBoYXJkd2FyZSBjb3Vu dCByZWdpc3RlciBmb3IgZGVjcmVtZW50CiBhbmQgYnJhbmNoLgpkaWZmIC0tZ2l0IGEvZ2NjL2Rv Yy90bS50ZXhpLmluIGIvZ2NjL2RvYy90bS50ZXhpLmluCmluZGV4IDUwMWRkZjE0N2U0Li4wMjQ3 MTFjZmRiOSAxMDA2NDQKLS0tIGEvZ2NjL2RvYy90bS50ZXhpLmluCisrKyBiL2djYy9kb2MvdG0u dGV4aS5pbgpAQCAtNzczMCw2ICs3NzMwLDggQEAgdG8gYnkgQHZhcntjZV9pbmZvfS4KIAogQGhv b2sgVEFSR0VUX1BSRURJQ1RfRE9MT09QX1AKIAorQGhvb2sgVEFSR0VUX0FMTE9XX0VMRU1FTlRX SVNFX0RPTE9PUF9QCisKIEBob29rIFRBUkdFVF9IQVZFX0NPVU5UX1JFR19ERUNSX1AKIAogQGhv b2sgVEFSR0VUX0RPTE9PUF9DT1NUX0ZPUl9HRU5FUklDCmRpZmYgLS1naXQgYS9nY2MvbG9vcC1k b2xvb3AuY2MgYi9nY2MvbG9vcC1kb2xvb3AuY2MKaW5kZXggMzBiNDVjODA3MWEuLmNiYmM2NjJm MTZiIDEwMDY0NAotLS0gYS9nY2MvbG9vcC1kb2xvb3AuY2MKKysrIGIvZ2NjL2xvb3AtZG9sb29w LmNjCkBAIC04NSwyOSArODUsMjkgQEAgZG9sb29wX2NvbmRpdGlvbl9nZXQgKHJ0eF9pbnNuICpk b2xvb3BfcGF0KQogICAgICBmb3JtczoKIAogICAgICAxKSAgKHBhcmFsbGVsIFsoc2V0IChwYykg KGlmX3RoZW5fZWxzZSAoY29uZGl0aW9uKQotCSAgCQkJICAgICAgICAgICAgKGxhYmVsX3JlZiAo bGFiZWwpKQotCQkJCSAgICAgICAgICAgIChwYykpKQotCSAgICAgICAgICAgICAoc2V0IChyZWcp IChwbHVzIChyZWcpIChjb25zdF9pbnQgLTEpKSkKLQkgICAgICAgICAgICAgKGFkZGl0aW9uYWwg Y2xvYmJlcnMgYW5kIHVzZXMpXSkKKwkJCQkJICAgIChsYWJlbF9yZWYgKGxhYmVsKSkKKwkJCQkJ ICAgIChwYykpKQorCQkgICAgIChzZXQgKHJlZykgKHBsdXMgKHJlZykgKGNvbnN0X2ludCAtbikp KQorCQkgICAgIChhZGRpdGlvbmFsIGNsb2JiZXJzIGFuZCB1c2VzKV0pCiAKICAgICAgVGhlIGJy YW5jaCBtdXN0IGJlIHRoZSBmaXJzdCBlbnRyeSBvZiB0aGUgcGFyYWxsZWwgKGFsc28gcmVxdWly ZWQKICAgICAgYnkganVtcC5jYyksIGFuZCB0aGUgc2Vjb25kIGVudHJ5IG9mIHRoZSBwYXJhbGxl bCBtdXN0IGJlIGEgc2V0IG9mCiAgICAgIHRoZSBsb29wIGNvdW50ZXIgcmVnaXN0ZXIuICBTb21l IHRhcmdldHMgKElBLTY0KSB3cmFwIHRoZSBzZXQgb2YKICAgICAgdGhlIGxvb3AgY291bnRlciBp biBhbiBpZl90aGVuX2Vsc2UgdG9vLgogCi0gICAgIDIpICAoc2V0IChyZWcpIChwbHVzIChyZWcp IChjb25zdF9pbnQgLTEpKQotICAgICAgICAgKHNldCAocGMpIChpZl90aGVuX2Vsc2UgKHJlZyAh PSAwKQotCSAgICAgICAgICAgICAgICAgICAgICAgICAobGFiZWxfcmVmIChsYWJlbCkpCi0JCQkg ICAgICAgICAocGMpKSkuICAKKyAgICAgMikgIChzZXQgKHJlZykgKHBsdXMgKHJlZykgKGNvbnN0 X2ludCAtbikpCisJIChzZXQgKHBjKSAoaWZfdGhlbl9lbHNlIChyZWcgIT0gMCkKKwkJCQkgKGxh YmVsX3JlZiAobGFiZWwpKQorCQkJCSAocGMpKSkuCiAKICAgICAgU29tZSB0YXJnZXRzIChBUk0p IGRvIHRoZSBjb21wYXJpc29uIGJlZm9yZSB0aGUgYnJhbmNoLCBhcyBpbiB0aGUKICAgICAgZm9s bG93aW5nIGZvcm06CiAKLSAgICAgMykgKHBhcmFsbGVsIFsoc2V0IChjYykgKGNvbXBhcmUgKChw bHVzIChyZWcpIChjb25zdF9pbnQgLTEpLCAwKSkpCi0gICAgICAgICAgICAgICAgICAgKHNldCAo cmVnKSAocGx1cyAocmVnKSAoY29uc3RfaW50IC0xKSkpXSkKLSAgICAgICAgKHNldCAocGMpIChp Zl90aGVuX2Vsc2UgKGNjID09IE5FKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAo bGFiZWxfcmVmIChsYWJlbCkpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChwYykp KSAqLworICAgICAzKSAocGFyYWxsZWwgWyhzZXQgKGNjKSAoY29tcGFyZSAoKHBsdXMgKHJlZykg KGNvbnN0X2ludCAtbiksIDApKSkKKwkJICAgKHNldCAocmVnKSAocGx1cyAocmVnKSAoY29uc3Rf aW50IC1uKSkpXSkKKwkoc2V0IChwYykgKGlmX3RoZW5fZWxzZSAoY2MgPT0gTkUpCisJCQkJKGxh YmVsX3JlZiAobGFiZWwpKQorCQkJCShwYykpKSAqLwogCiAgIHBhdHRlcm4gPSBQQVRURVJOIChk b2xvb3BfcGF0KTsKIApAQCAtMTQzLDcgKzE0Myw3IEBAIGRvbG9vcF9jb25kaXRpb25fZ2V0IChy dHhfaW5zbiAqZG9sb29wX3BhdCkKIAkgICAgICB8fCBHRVRfQ09ERSAoY21wX2FyZzEpICE9IFBM VVMpCiAJICAgIHJldHVybiAwOwogCSAgcmVnX29yaWcgPSBYRVhQIChjbXBfYXJnMSwgMCk7Ci0J ICBpZiAoWEVYUCAoY21wX2FyZzEsIDEpICE9IEdFTl9JTlQgKC0xKSAKKwkgIGlmICghQ09OU1Rf SU5UX1AgKFhFWFAgKGNtcF9hcmcxLCAxKSkKIAkgICAgICB8fCAhUkVHX1AgKHJlZ19vcmlnKSkK IAkgICAgcmV0dXJuIDA7CiAJICBjY19yZWcgPSBTRVRfREVTVCAoY21wX29yaWcpOwpAQCAtMTU2 LDcgKzE1Niw4IEBAIGRvbG9vcF9jb25kaXRpb25fZ2V0IChydHhfaW5zbiAqZG9sb29wX3BhdCkK IAl7CiAJICAvKiBXZSBleHBlY3QgdGhlIGNvbmRpdGlvbiB0byBiZSBvZiB0aGUgZm9ybSAocmVn ICE9IDApICAqLwogCSAgY29uZCA9IFhFWFAgKFNFVF9TUkMgKGNtcCksIDApOwotCSAgaWYgKEdF VF9DT0RFIChjb25kKSAhPSBORSB8fCBYRVhQIChjb25kLCAxKSAhPSBjb25zdDBfcnR4KQorCSAg aWYgKChHRVRfQ09ERSAoY29uZCkgIT0gTkUgJiYgR0VUX0NPREUgKGNvbmQpICE9IEdFKQorCSAg ICAgIHx8IFhFWFAgKGNvbmQsIDEpICE9IGNvbnN0MF9ydHgpCiAJICAgIHJldHVybiAwOwogCX0K ICAgICB9CkBAIC0xNzMsMTQgKzE3NCwxNCBAQCBkb2xvb3BfY29uZGl0aW9uX2dldCAocnR4X2lu c24gKmRvbG9vcF9wYXQpCiAgIGlmICghIFJFR19QIChyZWcpKQogICAgIHJldHVybiAwOwogCi0g IC8qIENoZWNrIGlmIHNvbWV0aGluZyA9IChwbHVzIChyZWcpIChjb25zdF9pbnQgLTEpKS4KKyAg LyogQ2hlY2sgaWYgc29tZXRoaW5nID0gKHBsdXMgKHJlZykgKGNvbnN0X2ludCAtbikpLgogICAg ICBPbiBJQS02NCwgdGhpcyBkZWNyZW1lbnQgaXMgd3JhcHBlZCBpbiBhbiBpZl90aGVuX2Vsc2Uu ICAqLwogICBpbmNfc3JjID0gU0VUX1NSQyAoaW5jKTsKICAgaWYgKEdFVF9DT0RFIChpbmNfc3Jj KSA9PSBJRl9USEVOX0VMU0UpCiAgICAgaW5jX3NyYyA9IFhFWFAgKGluY19zcmMsIDEpOwogICBp ZiAoR0VUX0NPREUgKGluY19zcmMpICE9IFBMVVMKICAgICAgIHx8IFhFWFAgKGluY19zcmMsIDAp ICE9IHJlZwotICAgICAgfHwgWEVYUCAoaW5jX3NyYywgMSkgIT0gY29uc3RtMV9ydHgpCisgICAg ICB8fCAhQ09OU1RfSU5UX1AgKFhFWFAgKGluY19zcmMsIDEpKSkKICAgICByZXR1cm4gMDsKIAog ICAvKiBDaGVjayBmb3IgKHNldCAocGMpIChpZl90aGVuX2Vsc2UgKGNvbmRpdGlvbikKQEAgLTIx MSw0MiArMjEyLDQ5IEBAIGRvbG9vcF9jb25kaXRpb25fZ2V0IChydHhfaW5zbiAqZG9sb29wX3Bh dCkKICAgICAgIHx8IChHRVRfQ09ERSAoWEVYUCAoY29uZGl0aW9uLCAwKSkgPT0gUExVUwogCSAg JiYgWEVYUCAoWEVYUCAoY29uZGl0aW9uLCAwKSwgMCkgPT0gcmVnKSkKICAgIHsKLSAgICAgaWYg KEdFVF9DT0RFIChwYXR0ZXJuKSAhPSBQQVJBTExFTCkKICAgICAgLyogIEZvciB0aGUgc2Vjb25k IGZvcm0gd2UgZXhwZWN0OgogCi0gICAgICAgICAoc2V0IChyZWcpIChwbHVzIChyZWcpIChjb25z dF9pbnQgLTEpKQotICAgICAgICAgKHNldCAocGMpIChpZl90aGVuX2Vsc2UgKHJlZyAhPSAwKQot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGxhYmVsX3JlZiAobGFiZWwpKQotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHBjKSkpLgorCSAoc2V0IChyZWcpIChwbHVz IChyZWcpIChjb25zdF9pbnQgLW4pKQorCSAoc2V0IChwYykgKGlmX3RoZW5fZWxzZSAocmVnICE9 IDApCisJCQkJIChsYWJlbF9yZWYgKGxhYmVsKSkKKwkJCQkgKHBjKSkpLgogCi0gICAgICAgICBp cyBlcXVpdmFsZW50IHRvIHRoZSBmb2xsb3dpbmc6CisJIElmIG4gPT0gMSwgdGhhdCBpcyBlcXVp dmFsZW50IHRvIHRoZSBmb2xsb3dpbmc6CiAKLSAgICAgICAgIChwYXJhbGxlbCBbKHNldCAocGMp IChpZl90aGVuX2Vsc2UgKHJlZyAhPSAxKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAobGFiZWxfcmVmIChsYWJlbCkpCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIChwYykpKQotICAgICAgICAgICAgICAgICAgICAgKHNldCAo cmVnKSAocGx1cyAocmVnKSAoY29uc3RfaW50IC0xKSkpCi0gICAgICAgICAgICAgICAgICAgICAo YWRkaXRpb25hbCBjbG9iYmVycyBhbmQgdXNlcyldKQorCSAocGFyYWxsZWwgWyhzZXQgKHBjKSAo aWZfdGhlbl9lbHNlIChyZWcgIT0gMSkKKwkJCQkJICAgIChsYWJlbF9yZWYgKGxhYmVsKSkKKwkJ CQkJICAgIChwYykpKQorCQkgICAgIChzZXQgKHJlZykgKHBsdXMgKHJlZykgKGNvbnN0X2ludCAt MSkpKQorCQkgICAgIChhZGRpdGlvbmFsIGNsb2JiZXJzIGFuZCB1c2VzKV0pCiAKLSAgICAgICAg Rm9yIHRoZSB0aGlyZCBmb3JtIHdlIGV4cGVjdDoKKwlGb3IgdGhlIHRoaXJkIGZvcm0gd2UgZXhw ZWN0OgogCi0gICAgICAgIChwYXJhbGxlbCBbKHNldCAoY2MpIChjb21wYXJlICgocGx1cyAocmVn KSAoY29uc3RfaW50IC0xKSksIDApKQotICAgICAgICAgICAgICAgICAgIChzZXQgKHJlZykgKHBs dXMgKHJlZykgKGNvbnN0X2ludCAtMSkpKV0pCi0gICAgICAgIChzZXQgKHBjKSAoaWZfdGhlbl9l bHNlIChjYyA9PSBORSkKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKGxhYmVsX3Jl ZiAobGFiZWwpKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAocGMpKSkgCisJKHBh cmFsbGVsIFsoc2V0IChjYykgKGNvbXBhcmUgKChwbHVzIChyZWcpIChjb25zdF9pbnQgLW4pKSwg MCkpCisJCSAgIChzZXQgKHJlZykgKHBsdXMgKHJlZykgKGNvbnN0X2ludCAtbikpKV0pCisJKHNl dCAocGMpIChpZl90aGVuX2Vsc2UgKGNjID09IE5FKQorCQkJCShsYWJlbF9yZWYgKGxhYmVsKSkK KwkJCQkocGMpKSkKIAotICAgICAgICB3aGljaCBpcyBlcXVpdmFsZW50IHRvIHRoZSBmb2xsb3dp bmc6CisJV2hpY2ggYWxzbyBmb3IgbiA9PSAxIGlzIGVxdWl2YWxlbnQgdG8gdGhlIGZvbGxvd2lu ZzoKIAotICAgICAgICAocGFyYWxsZWwgWyhzZXQgKGNjKSAoY29tcGFyZSAocmVnLCAgMSkpCi0g ICAgICAgICAgICAgICAgICAgKHNldCAocmVnKSAocGx1cyAocmVnKSAoY29uc3RfaW50IC0xKSkp Ci0gICAgICAgICAgICAgICAgICAgKHNldCAocGMpIChpZl90aGVuX2Vsc2UgKE5FID09IGNjKQot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChsYWJlbF9yZWYgKGxh YmVsKSkKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAocGMpKSkp XSkKKwkocGFyYWxsZWwgWyhzZXQgKGNjKSAoY29tcGFyZSAocmVnLCAgMSkpCisJCSAgIChzZXQg KHJlZykgKHBsdXMgKHJlZykgKGNvbnN0X2ludCAtMSkpKQorCQkgICAoc2V0IChwYykgKGlmX3Ro ZW5fZWxzZSAoTkUgPT0gY2MpCisJCQkJCSAgIChsYWJlbF9yZWYgKGxhYmVsKSkKKwkJCQkJICAg KHBjKSkpKV0pCiAKLSAgICAgICAgU28gd2UgcmV0dXJuIHRoZSBzZWNvbmQgZm9ybSBpbnN0ZWFk IGZvciB0aGUgdHdvIGNhc2VzLgorCVNvIHdlIHJldHVybiB0aGUgc2Vjb25kIGZvcm0gaW5zdGVh ZCBmb3IgdGhlIHR3byBjYXNlcy4KIAorCUZvciB0aGUgImVsZW1lbnR3aXNlIiBmb3JtIHdoZXJl IHRoZSBkZWNyZW1lbnQgbnVtYmVyIGlzbid0IC0xLAorCXRoZSBmaW5hbCB2YWx1ZSBtYXkgYmUg ZXhjZWVkZWQsIHNvIHVzZSBHRSBpbnN0ZWFkIG9mIE5FLgogICAgICAqLwotICAgICAgICBjb25k aXRpb24gPSBnZW5fcnR4X2ZtdF9lZSAoTkUsIFZPSURtb2RlLCBpbmNfc3JjLCBjb25zdDFfcnR4 KTsKKyAgICAgaWYgKEdFVF9DT0RFIChwYXR0ZXJuKSAhPSBQQVJBTExFTCkKKyAgICAgICB7CisJ aWYgKElOVFZBTCAoWEVYUCAoaW5jX3NyYywgMSkpICE9IC0xKQorCSAgY29uZGl0aW9uID0gZ2Vu X3J0eF9mbXRfZWUgKEdFLCBWT0lEbW9kZSwgaW5jX3NyYywgY29uc3QwX3J0eCk7CisJZWxzZQor CSAgY29uZGl0aW9uID0gZ2VuX3J0eF9mbXRfZWUgKE5FLCBWT0lEbW9kZSwgaW5jX3NyYywgY29u c3QxX3J0eCk7OworICAgICAgIH0KIAogICAgIHJldHVybiBjb25kaXRpb247CiAgICB9CkBAIC02 ODUsMTcgKzY5Myw2IEBAIGRvbG9vcF9vcHRpbWl6ZSAoY2xhc3MgbG9vcCAqbG9vcCkKICAgICAg IHJldHVybiBmYWxzZTsKICAgICB9CiAKLSAgbWF4X2Nvc3QKLSAgICA9IENPU1RTX05fSU5TTlMg KHBhcmFtX21heF9pdGVyYXRpb25zX2NvbXB1dGF0aW9uX2Nvc3QpOwotICBpZiAoc2V0X3NyY19j b3N0IChkZXNjLT5uaXRlcl9leHByLCBtb2RlLCBvcHRpbWl6ZV9sb29wX2Zvcl9zcGVlZF9wIChs b29wKSkKLSAgICAgID4gbWF4X2Nvc3QpCi0gICAgewotICAgICAgaWYgKGR1bXBfZmlsZSkKLQlm cHJpbnRmIChkdW1wX2ZpbGUsCi0JCSAiRG9sb29wOiBudW1iZXIgb2YgaXRlcmF0aW9ucyB0b28g Y29zdGx5IHRvIGNvbXB1dGUuXG4iKTsKLSAgICAgIHJldHVybiBmYWxzZTsKLSAgICB9Ci0KICAg aWYgKGRlc2MtPmNvbnN0X2l0ZXIpCiAgICAgaXRlcmF0aW9ucyA9IHdpZGVzdF9pbnQ6OmZyb20g KHJ0eF9tb2RlX3QgKGRlc2MtPm5pdGVyX2V4cHIsIG1vZGUpLAogCQkJCSAgIFVOU0lHTkVEKTsK QEAgLTcyMCw3ICs3MTcsMjUgQEAgZG9sb29wX29wdGltaXplIChjbGFzcyBsb29wICpsb29wKQog ICBjb3VudCA9IGNvcHlfcnR4IChkZXNjLT5uaXRlcl9leHByKTsKICAgc3RhcnRfbGFiZWwgPSBi bG9ja19sYWJlbCAoZGVzYy0+aW5fZWRnZS0+ZGVzdCk7CiAgIGRvbG9vcF9yZWcgPSBnZW5fcmVn X3J0eCAobW9kZSk7Ci0gIHJ0eF9pbnNuICpkb2xvb3Bfc2VxID0gdGFyZ2V0bS5nZW5fZG9sb29w X2VuZCAoZG9sb29wX3JlZywgc3RhcnRfbGFiZWwpOworICBydHhfaW5zbiAqZG9sb29wX3NlcSA9 IHRhcmdldG0uZ2VuX2RvbG9vcF9lbmQgKGRvbG9vcF9yZWcsIHN0YXJ0X2xhYmVsLAorCQkJCQkJ IGNvdW50KTsKKworICAvKiBOb3QgYWxsIHRhcmdldHMgbmVlZCB0byBwcmUtY2FsY3VsYXRlIHRo ZSBudW1iZXIgb2YgdGhlIGl0ZXJhdGlvbnMgb2YKKyAgICAgdGhlIGxvb3AsIHRoZXkgaW5zdGVh ZCB3b3JrIGJ5IHN0b3JpbmcgdGhlIG51bWJlciBvZiBlbGVtZW50cyBpbiB0aGUKKyAgICAgY291 bnRlcl9yZWcgYW5kIGRlY3JlbWVudGluZyB0aGF0LiAgQ2FsbCB0aGUgYXBwcm9wcmlhdGUgdGFy Z2V0IGhvb2sgdG8KKyAgICAgY2hhbmdlIHRoZSB2YWx1ZSBvZiBjb3VudC4gICovCisgIGNvdW50 ID0gdGFyZ2V0bS5hbGxvd19lbGVtZW50d2lzZV9kb2xvb3BfcCAoY291bnQsIHN0YXJ0X2xhYmVs LCBkb2xvb3Bfc2VxKTsKKworICBtYXhfY29zdAorICAgID0gQ09TVFNfTl9JTlNOUyAocGFyYW1f bWF4X2l0ZXJhdGlvbnNfY29tcHV0YXRpb25fY29zdCk7CisgIGlmIChzZXRfc3JjX2Nvc3QgKGNv dW50LCBtb2RlLCBvcHRpbWl6ZV9sb29wX2Zvcl9zcGVlZF9wIChsb29wKSkKKyAgICAgID4gbWF4 X2Nvc3QpCisgICAgeworICAgICAgaWYgKGR1bXBfZmlsZSkKKwlmcHJpbnRmIChkdW1wX2ZpbGUs CisJCSAiRG9sb29wOiBudW1iZXIgb2YgaXRlcmF0aW9ucyB0b28gY29zdGx5IHRvIGNvbXB1dGUu XG4iKTsKKyAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CiAKICAgd29yZF9tb2RlX3NpemUgPSBH RVRfTU9ERV9QUkVDSVNJT04gKHdvcmRfbW9kZSk7CiAgIHdvcmRfbW9kZV9tYXggPSAoSE9TVF9X SURFX0lOVF8xVSA8PCAod29yZF9tb2RlX3NpemUgLSAxKSA8PCAxKSAtIDE7CkBAIC03MzcsNyAr NzUyLDcgQEAgZG9sb29wX29wdGltaXplIChjbGFzcyBsb29wICpsb29wKQogICAgICAgZWxzZQog CWNvdW50ID0gbG93cGFydF9zdWJyZWcgKHdvcmRfbW9kZSwgY291bnQsIG1vZGUpOwogICAgICAg UFVUX01PREUgKGRvbG9vcF9yZWcsIHdvcmRfbW9kZSk7Ci0gICAgICBkb2xvb3Bfc2VxID0gdGFy Z2V0bS5nZW5fZG9sb29wX2VuZCAoZG9sb29wX3JlZywgc3RhcnRfbGFiZWwpOworICAgICAgZG9s b29wX3NlcSA9IHRhcmdldG0uZ2VuX2RvbG9vcF9lbmQgKGRvbG9vcF9yZWcsIHN0YXJ0X2xhYmVs LCBjb3VudCk7CiAgICAgfQogICBpZiAoISBkb2xvb3Bfc2VxKQogICAgIHsKZGlmZiAtLWdpdCBh L2djYy90YXJnZXQtaW5zbnMuZGVmIGIvZ2NjL3RhcmdldC1pbnNucy5kZWYKaW5kZXggZGU4YzAw OTJmOTguLmI3N2I3OTcyNDI2IDEwMDY0NAotLS0gYS9nY2MvdGFyZ2V0LWluc25zLmRlZgorKysg Yi9nY2MvdGFyZ2V0LWluc25zLmRlZgpAQCAtNDgsNyArNDgsNyBAQCBERUZfVEFSR0VUX0lOU04g KGNhc2VzaSwgKHJ0eCB4MCwgcnR4IHgxLCBydHggeDIsIHJ0eCB4MywgcnR4IHg0KSkKIERFRl9U QVJHRVRfSU5TTiAoY2hlY2tfc3RhY2ssIChydHggeDApKQogREVGX1RBUkdFVF9JTlNOIChjbGVh cl9jYWNoZSwgKHJ0eCB4MCwgcnR4IHgxKSkKIERFRl9UQVJHRVRfSU5TTiAoZG9sb29wX2JlZ2lu LCAocnR4IHgwLCBydHggeDEpKQotREVGX1RBUkdFVF9JTlNOIChkb2xvb3BfZW5kLCAocnR4IHgw LCBydHggeDEpKQorREVGX1RBUkdFVF9JTlNOIChkb2xvb3BfZW5kLCAocnR4IHgwLCBydHggeDEs IHJ0eCB4MikpCiBERUZfVEFSR0VUX0lOU04gKGVoX3JldHVybiwgKHJ0eCB4MCkpCiBERUZfVEFS R0VUX0lOU04gKGVwaWxvZ3VlLCAodm9pZCkpCiBERUZfVEFSR0VUX0lOU04gKGV4Y2VwdGlvbl9y ZWNlaXZlciwgKHZvaWQpKQpkaWZmIC0tZ2l0IGEvZ2NjL3RhcmdldC5kZWYgYi9nY2MvdGFyZ2V0 LmRlZgppbmRleCBhM2QzYjA0YTE2NS4uZTc0NzI0YzhhMTMgMTAwNjQ0Ci0tLSBhL2djYy90YXJn ZXQuZGVmCisrKyBiL2djYy90YXJnZXQuZGVmCkBAIC00MzkyLDYgKzQzOTIsMTYgQEAgVGhlIGRl ZmF1bHQgdmVyc2lvbiBvZiB0aGlzIGhvb2sgcmV0dXJucyBmYWxzZS4iLAogIGJvb2wsIChjbGFz cyBsb29wICpsb29wKSwKICBkZWZhdWx0X3ByZWRpY3RfZG9sb29wX3ApCiAKK0RFRkhPT0sKKyhh bGxvd19lbGVtZW50d2lzZV9kb2xvb3BfcCwKKyAiVGhpcyB0YXJnZXQgaG9vayBhbGxvd3MgdGhl IHRhcmdldCB0byBzdXBwb3J0IGxvb3AtZG9sb29wIG9wdGltaXNhdGlvbnNcblwKK3doZXJlIHRo ZSB2YWx1ZSB0aGF0IGdldHMgcHV0IGludG8gdGhlIGxvb3AgY291bnRlciByZWdpc3RlciBpcyBu b3QgYVxuXAorcHJlLWNhbGN1bGF0aW9uIG9mIHRoZSBudW1iZXIgb2YgaXRlcmF0aW9uIG9mIHRo ZSBsb29wLiAgRm9yIGluc3RhbmNlLFxuXAordGhlIHZhbHVlIHVzZWQgY2FuIGJlIHRoZSBudW1i ZXIgb2YgZWxlbWVudHMgdGhhdCB0aGUgbG9vcCB3aWxsIHByb2Nlc3MuXG5cCitUaGUgZGVmYXVs dCB2ZXJzaW9uIG9mIHRoaXMgaG9vayByZXR1cm5zIHRoZSBzYW1lIHJ0eCBpdCB3YXMgZ2l2ZW4u IiwKKyBydHgsIChydHggY291bnQsIHJ0eCBsYWJlbCwgcnR4IGRvbG9vcCksCisgZGVmYXVsdF9h bGxvd19lbGVtZW50d2lzZV9kb2xvb3BfcCkKKwogREVGSE9PS1BPRAogKGhhdmVfY291bnRfcmVn X2RlY3JfcCwKICAiUmV0dXJuIHRydWUgaWYgdGhlIHRhcmdldCBzdXBwb3J0cyBoYXJkd2FyZSBj b3VudCByZWdpc3RlciBmb3IgZGVjcmVtZW50XG5cCmRpZmYgLS1naXQgYS9nY2MvdGFyZ2hvb2tz LmNjIGIvZ2NjL3Rhcmdob29rcy5jYwppbmRleCBkMTdkMzkzYmFlZC4uMDRkMDgwNTZkZDcgMTAw NjQ0Ci0tLSBhL2djYy90YXJnaG9va3MuY2MKKysrIGIvZ2NjL3Rhcmdob29rcy5jYwpAQCAtNjYx LDYgKzY2MSwxMiBAQCBkZWZhdWx0X3ByZWRpY3RfZG9sb29wX3AgKGNsYXNzIGxvb3AgKmxvb3Ag QVRUUklCVVRFX1VOVVNFRCkKICAgcmV0dXJuIGZhbHNlOwogfQogCitydHgKK2RlZmF1bHRfYWxs b3dfZWxlbWVudHdpc2VfZG9sb29wX3AgKHJ0eCBjb3VudCwgcnR4LCBydHgpCit7CisgIHJldHVy biBjb3VudDsKK30KKwogLyogQnkgZGVmYXVsdCwganVzdCB1c2UgdGhlIGlucHV0IE1PREUgaXRz ZWxmLiAgKi8KIAogbWFjaGluZV9tb2RlCmRpZmYgLS1naXQgYS9nY2MvdGFyZ2hvb2tzLmggYi9n Y2MvdGFyZ2hvb2tzLmgKaW5kZXggZWNjZTU1ZWJlNzkuLmY5YWJhMmUwODEzIDEwMDY0NAotLS0g YS9nY2MvdGFyZ2hvb2tzLmgKKysrIGIvZ2NjL3Rhcmdob29rcy5oCkBAIC04OCw2ICs4OCw3IEBA IGV4dGVybiBib29sIGRlZmF1bHRfZml4ZWRfcG9pbnRfc3VwcG9ydGVkX3AgKHZvaWQpOwogZXh0 ZXJuIGJvb2wgZGVmYXVsdF9oYXNfaWZ1bmNfcCAodm9pZCk7CiAKIGV4dGVybiBib29sIGRlZmF1 bHRfcHJlZGljdF9kb2xvb3BfcCAoY2xhc3MgbG9vcCAqKTsKK2V4dGVybiBydHggZGVmYXVsdF9h bGxvd19lbGVtZW50d2lzZV9kb2xvb3BfcCAocnR4LCBydHgsIHJ0eCk7CiBleHRlcm4gbWFjaGlu ZV9tb2RlIGRlZmF1bHRfcHJlZmVycmVkX2RvbG9vcF9tb2RlIChtYWNoaW5lX21vZGUpOwogZXh0 ZXJuIGNvbnN0IGNoYXIgKiBkZWZhdWx0X2ludmFsaWRfd2l0aGluX2RvbG9vcCAoY29uc3QgcnR4 X2luc24gKik7CiAKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vZGxz dHAtaW50MTZ4OC5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQxNng4 LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmE2MWYwMmVkM2EyCi0t LSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQx Nng4LmMKQEAgLTAsMCArMSw2OCBAQAorLyogeyBkZy1kbyBydW4geyB0YXJnZXQgeyBhcm0qLSot KiB9IH0gfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgYXJtX3Y4XzFtX212 ZV9vayB9ICovCisvKiB7IGRnLXNraXAtaWYgImF2b2lkIGNvbmZsaWN0aW5nIG11bHRpbGliIG9w dGlvbnMiIHsgKi0qLSogfSB7ICItbWFybSIgIi1tY3B1PSoiIH0gfSAqLworLyogeyBkZy1vcHRp b25zICItbWFyY2g9YXJtdjguMS1tLm1haW4rZnAuZHArbXZlLmZwIC1tZmxvYXQtYWJpPWhhcmQg LW1mcHU9YXV0byAtTzMgLS1zYXZlLXRlbXBzIiB9ICovCisKKyNpbmNsdWRlIDxhcm1fbXZlLmg+ CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlICJsb2Iu aCIKKwordm9pZCAgX19hdHRyaWJ1dGVfXyAoKG5vaW5saW5lKSkgdGVzdCAoaW50MTZfdCAqYSwg aW50MTZfdCAqYiwgaW50MTZfdCAqYywgaW50IG4pCit7CisgIHdoaWxlIChuID4gMCkKKyAgICB7 CisgICAgICBtdmVfcHJlZDE2X3QgcCA9IHZjdHAxNnEgKG4pOworICAgICAgaW50MTZ4OF90IHZh ID0gdmxkcmhxX3pfczE2IChhLCBwKTsKKyAgICAgIGludDE2eDhfdCB2YiA9IHZsZHJocV96X3Mx NiAoYiwgcCk7CisgICAgICBpbnQxNng4X3QgdmMgPSB2YWRkcV94X3MxNiAodmEsIHZiLCBwKTsK KyAgICAgIHZzdHJocV9wX3MxNiAoYywgdmMsIHApOworICAgICAgYys9ODsKKyAgICAgIGErPTg7 CisgICAgICBiKz04OworICAgICAgbi09ODsKKyAgICB9Cit9CisKK2ludCBtYWluICgpCit7Cisg IGludCBpOworICBpbnQxNl90IHRlbXAxW05dOworICBpbnQxNl90IHRlbXAyW05dOworICBpbnQx Nl90IHRlbXAzW05dOworICByZXNldF9kYXRhMTYgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIE4pOwor ICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCAwKTsKKyAgY2hlY2tfcGx1czE2ICh0ZW1wMSwg dGVtcDIsIHRlbXAzLCAwKTsKKworICByZXNldF9kYXRhMTYgKHRlbXAxLCB0ZW1wMiwgdGVtcDMs IE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCAxKTsKKyAgY2hlY2tfcGx1czE2ICh0 ZW1wMSwgdGVtcDIsIHRlbXAzLCAxKTsKKworICByZXNldF9kYXRhMTYgKHRlbXAxLCB0ZW1wMiwg dGVtcDMsIE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA3KTsKKyAgY2hlY2tfcGx1 czE2ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA3KTsKKworICByZXNldF9kYXRhMTYgKHRlbXAxLCB0 ZW1wMiwgdGVtcDMsIE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA4KTsKKyAgY2hl Y2tfcGx1czE2ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA4KTsKKworICByZXNldF9kYXRhMTYgKHRl bXAxLCB0ZW1wMiwgdGVtcDMsIE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA5KTsK KyAgY2hlY2tfcGx1czE2ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCA5KTsKKworICByZXNldF9kYXRh MTYgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRlbXAz LCAxNik7CisgIGNoZWNrX3BsdXMxNiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgMTYpOworCisgIHJl c2V0X2RhdGExNiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRlbXAxLCB0ZW1w MiwgdGVtcDMsIDE3KTsKKyAgY2hlY2tfcGx1czE2ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCAxNyk7 CisKKyAgcmVzZXRfZGF0YTE2ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCBOKTsKK30KKworLyogeyBk Zy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLXRpbWVzIHtcdGRsc3RwLjE2XHR9IDEgfSB9ICovCisv KiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXItdGltZXMge1x0bGV0cFx0fSAxIH0gfSAqLwor LyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAiXHR2Y3RwXHQiIH0gfSAqLworLyog eyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAiXHR2cHN0XHQiIH0gfSAqLworLyogeyBk Zy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAicDAiIH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2Nj L3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQzMng0LmMgYi9nY2MvdGVzdHN1aXRl L2djYy50YXJnZXQvYXJtL2Rsc3RwLWludDMyeDQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMC4uMzFhNzI2NGFlMjYKLS0tIC9kZXYvbnVsbAorKysgYi9nY2MvdGVzdHN1 aXRlL2djYy50YXJnZXQvYXJtL2Rsc3RwLWludDMyeDQuYwpAQCAtMCwwICsxLDY4IEBACisvKiB7 IGRnLWRvIHJ1biB7IHRhcmdldCB7IGFybSotKi0qIH0gfSB9ICovCisvKiB7IGRnLXJlcXVpcmUt ZWZmZWN0aXZlLXRhcmdldCBhcm1fdjhfMW1fbXZlX29rIH0gKi8KKy8qIHsgZGctc2tpcC1pZiAi YXZvaWQgY29uZmxpY3RpbmcgbXVsdGlsaWIgb3B0aW9ucyIgeyAqLSotKiB9IHsgIi1tYXJtIiAi LW1jcHU9KiIgfSB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1tYXJjaD1hcm12OC4xLW0ubWFpbitm cC5kcCttdmUuZnAgLW1mbG9hdC1hYmk9aGFyZCAtbWZwdT1hdXRvIC1PMyAtLXNhdmUtdGVtcHMi IH0gKi8KKworI2luY2x1ZGUgPGFybV9tdmUuaD4KKyNpbmNsdWRlIDxzdGRpby5oPgorI2luY2x1 ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgImxvYi5oIgorCit2b2lkICBfX2F0dHJpYnV0ZV9fICgo bm9pbmxpbmUpKSB0ZXN0IChpbnQzMl90ICphLCBpbnQzMl90ICpiLCBpbnQzMl90ICpjLCBpbnQg bikKK3sKKyAgd2hpbGUgKG4gPiAwKQorICAgIHsKKyAgICAgIG12ZV9wcmVkMTZfdCBwID0gdmN0 cDMycSAobik7CisgICAgICBpbnQzMng0X3QgdmEgPSB2bGRyd3Ffel9zMzIgKGEsIHApOworICAg ICAgaW50MzJ4NF90IHZiID0gdmxkcndxX3pfczMyIChiLCBwKTsKKyAgICAgIGludDMyeDRfdCB2 YyA9IHZhZGRxX3hfczMyICh2YSwgdmIsIHApOworICAgICAgdnN0cndxX3BfczMyIChjLCB2Yywg cCk7CisgICAgICBjKz00OworICAgICAgYSs9NDsKKyAgICAgIGIrPTQ7CisgICAgICBuLT00Owor ICAgIH0KK30KKworaW50IG1haW4gKCkKK3sKKyAgaW50IGk7CisgIGludDMyX3QgdGVtcDFbTl07 CisgIGludDMyX3QgdGVtcDJbTl07CisgIGludDMyX3QgdGVtcDNbTl07CisgIHJlc2V0X2RhdGEz MiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMs IDApOworICBjaGVja19wbHVzMzIgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDApOworCisgIHJlc2V0 X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwg dGVtcDMsIDEpOworICBjaGVja19wbHVzMzIgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDEpOworCisg IHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRlbXAxLCB0 ZW1wMiwgdGVtcDMsIDMpOworICBjaGVja19wbHVzMzIgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDMp OworCisgIHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRl bXAxLCB0ZW1wMiwgdGVtcDMsIDQpOworICBjaGVja19wbHVzMzIgKHRlbXAxLCB0ZW1wMiwgdGVt cDMsIDQpOworCisgIHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRl c3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDUpOworICBjaGVja19wbHVzMzIgKHRlbXAxLCB0ZW1w MiwgdGVtcDMsIDUpOworCisgIHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7 CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDgpOworICBjaGVja19wbHVzMzIgKHRlbXAx LCB0ZW1wMiwgdGVtcDMsIDgpOworCisgIHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAyLCB0ZW1w MywgTik7CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDkpOworICBjaGVja19wbHVzMzIg KHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDkpOworCisgIHJlc2V0X2RhdGEzMiAodGVtcDEsIHRlbXAy LCB0ZW1wMywgTik7Cit9CisKKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyB7 XHRkbHN0cC4zMlx0fSAxIH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLXRp bWVzIHtcdGxldHBcdH0gMSB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci1u b3QgIlx0dmN0cFx0IiB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci1ub3Qg Ilx0dnBzdFx0IiB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci1ub3QgInAw IiB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vZGxzdHAt aW50NjR4Mi5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQ2NHgyLmMK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmEwOWMwMTg4NGRhCi0tLSAv ZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQ2NHgy LmMKQEAgLTAsMCArMSw2OCBAQAorLyogeyBkZy1kbyBydW4geyB0YXJnZXQgeyBhcm0qLSotKiB9 IH0gfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgYXJtX3Y4XzFtX212ZV9v ayB9ICovCisvKiB7IGRnLXNraXAtaWYgImF2b2lkIGNvbmZsaWN0aW5nIG11bHRpbGliIG9wdGlv bnMiIHsgKi0qLSogfSB7ICItbWFybSIgIi1tY3B1PSoiIH0gfSAqLworLyogeyBkZy1vcHRpb25z ICItbWFyY2g9YXJtdjguMS1tLm1haW4rZnAuZHArbXZlLmZwIC1tZmxvYXQtYWJpPWhhcmQgLW1m cHU9YXV0byAtTzMgLS1zYXZlLXRlbXBzIiB9ICovCisKKyNpbmNsdWRlIDxhcm1fbXZlLmg+Cisj aW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlICJsb2IuaCIK Kwordm9pZCAgX19hdHRyaWJ1dGVfXyAoKG5vaW5saW5lKSkgdGVzdCAoaW50NjRfdCAqYSwgaW50 NjRfdCAqYywgaW50IG4pCit7CisgIHdoaWxlIChuID4gMCkKKyAgICB7CisgICAgICBtdmVfcHJl ZDE2X3QgcCA9IHZjdHA2NHEgKG4pOworICAgICAgaW50NjR4Ml90IHZhID0gdmxkcmRxX2dhdGhl cl9vZmZzZXRfel9zNjQgKGEsIHZjcmVhdGVxX3U2NCAoOCwgMCksIHApOworICAgICAgdnN0cmRx X3NjYXR0ZXJfb2Zmc2V0X3BfczY0IChjLCB2Y3JlYXRlcV91NjQgKDgsIDApLCB2YSwgcCk7Cisg ICAgICBjKz0yOworICAgICAgYSs9MjsKKyAgICAgIG4tPTI7CisgICAgfQorfQorCitpbnQgbWFp biAoKQoreworICBpbnQgaTsKKyAgaW50NjRfdCB0ZW1wMVtOXTsKKyAgaW50NjRfdCB0ZW1wM1tO XTsKKyAgcmVzZXRfZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRl bXAzLCAwKTsKKyAgY2hlY2tfbWVtY3B5NjQgKHRlbXAxLCB0ZW1wMywgMCk7CisKKyAgcmVzZXRf ZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAzLCAxKTsKKyAg Y2hlY2tfbWVtY3B5NjQgKHRlbXAxLCB0ZW1wMywgMSk7CisKKyAgcmVzZXRfZGF0YTY0ICAodGVt cDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAzLCAyKTsKKyAgY2hlY2tfbWVtY3B5 NjQgKHRlbXAxLCB0ZW1wMywgMik7CisKKyAgcmVzZXRfZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBO KTsKKyAgdGVzdCAodGVtcDEsIHRlbXAzLCAzKTsKKyAgY2hlY2tfbWVtY3B5NjQgKHRlbXAxLCB0 ZW1wMywgMyk7CisKKyAgcmVzZXRfZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAo dGVtcDEsIHRlbXAzLCA0KTsKKyAgY2hlY2tfbWVtY3B5NjQgKHRlbXAxLCB0ZW1wMywgNCk7CisK KyAgcmVzZXRfZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAz LCA1KTsKKyAgY2hlY2tfbWVtY3B5NjQgKHRlbXAxLCB0ZW1wMywgNSk7CisKKyAgcmVzZXRfZGF0 YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAzLCA2KTsKKyAgY2hl Y2tfbWVtY3B5NjQgKHRlbXAxLCB0ZW1wMywgNik7CisKKyAgcmVzZXRfZGF0YTY0ICAodGVtcDEs IHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAzLCA3KTsKKyAgY2hlY2tfbWVtY3B5NjQg KHRlbXAxLCB0ZW1wMywgNyk7CisKKyAgcmVzZXRfZGF0YTY0ICAodGVtcDEsIHRlbXAzLCBOKTsK K30KKworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLXRpbWVzIHtcdGRsc3RwLjY0XHR9 IDEgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXItdGltZXMge1x0bGV0cFx0 fSAxIH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAiXHR2Y3RwXHQi IH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAiXHR2cHN0XHQiIH0g fSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAicDAiIH0gfSAqLwpkaWZm IC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9kbHN0cC1pbnQ4eDE2LmMgYi9n Y2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYXJtL2Rsc3RwLWludDh4MTYuYwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNDlmYmQ0YzE2YTIKLS0tIC9kZXYvbnVsbAorKysg Yi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYXJtL2Rsc3RwLWludDh4MTYuYwpAQCAtMCwwICsx LDY4IEBACisvKiB7IGRnLWRvIHJ1biB7IHRhcmdldCB7IGFybSotKi0qIH0gfSB9ICovCisvKiB7 IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCBhcm1fdjhfMW1fbXZlX29rIH0gKi8KKy8qIHsg ZGctc2tpcC1pZiAiYXZvaWQgY29uZmxpY3RpbmcgbXVsdGlsaWIgb3B0aW9ucyIgeyAqLSotKiB9 IHsgIi1tYXJtIiAiLW1jcHU9KiIgfSB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1tYXJjaD1hcm12 OC4xLW0ubWFpbitmcC5kcCttdmUuZnAgLW1mbG9hdC1hYmk9aGFyZCAtbWZwdT1hdXRvIC1PMyAt LXNhdmUtdGVtcHMiIH0gKi8KKworI2luY2x1ZGUgPGFybV9tdmUuaD4KKyNpbmNsdWRlIDxzdGRp by5oPgorI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgImxvYi5oIgorCit2b2lkICBfX2F0 dHJpYnV0ZV9fICgobm9pbmxpbmUpKSB0ZXN0IChpbnQ4X3QgKmEsIGludDhfdCAqYiwgaW50OF90 ICpjLCBpbnQgbikKK3sKKyAgd2hpbGUgKG4gPiAwKQorICAgIHsKKyAgICAgIG12ZV9wcmVkMTZf dCBwID0gdmN0cDhxIChuKTsKKyAgICAgIGludDh4MTZfdCB2YSA9IHZsZHJicV96X3M4IChhLCBw KTsKKyAgICAgIGludDh4MTZfdCB2YiA9IHZsZHJicV96X3M4IChiLCBwKTsKKyAgICAgIGludDh4 MTZfdCB2YyA9IHZhZGRxX3hfczggKHZhLCB2YiwgcCk7CisgICAgICB2c3RyYnFfcF9zOCAoYywg dmMsIHApOworICAgICAgYys9MTY7CisgICAgICBhKz0xNjsKKyAgICAgIGIrPTE2OworICAgICAg bi09MTY7CisgICAgfQorfQorCitpbnQgbWFpbiAoKQoreworICBpbnQgaTsKKyAgaW50OF90IHRl bXAxW05dOworICBpbnQ4X3QgdGVtcDJbTl07CisgIGludDhfdCB0ZW1wM1tOXTsKKyAgcmVzZXRf ZGF0YTggKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIE4pOworICB0ZXN0ICh0ZW1wMSwgdGVtcDIsIHRl bXAzLCAwKTsKKyAgY2hlY2tfcGx1czggKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDApOworCisgIHJl c2V0X2RhdGE4ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCBOKTsKKyAgdGVzdCAodGVtcDEsIHRlbXAy LCB0ZW1wMywgMSk7CisgIGNoZWNrX3BsdXM4ICh0ZW1wMSwgdGVtcDIsIHRlbXAzLCAxKTsKKwor ICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRlbXAxLCB0 ZW1wMiwgdGVtcDMsIDE1KTsKKyAgY2hlY2tfcGx1czggKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDE1 KTsKKworICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRlc3QgKHRl bXAxLCB0ZW1wMiwgdGVtcDMsIDE2KTsKKyAgY2hlY2tfcGx1czggKHRlbXAxLCB0ZW1wMiwgdGVt cDMsIDE2KTsKKworICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7CisgIHRl c3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDE3KTsKKyAgY2hlY2tfcGx1czggKHRlbXAxLCB0ZW1w MiwgdGVtcDMsIDE3KTsKKworICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAyLCB0ZW1wMywgTik7 CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDMyKTsKKyAgY2hlY2tfcGx1czggKHRlbXAx LCB0ZW1wMiwgdGVtcDMsIDMyKTsKKworICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAyLCB0ZW1w MywgTik7CisgIHRlc3QgKHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDMzKTsKKyAgY2hlY2tfcGx1czgg KHRlbXAxLCB0ZW1wMiwgdGVtcDMsIDMzKTsKKworICByZXNldF9kYXRhOCAodGVtcDEsIHRlbXAy LCB0ZW1wMywgTik7Cit9CisKKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyB7 XHRkbHN0cC44XHR9IDEgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXItdGlt ZXMge1x0bGV0cFx0fSAxIH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5v dCAiXHR2Y3RwXHQiIH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAi XHR2cHN0XHQiIH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLW5vdCAicDAi IH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9sb2IuaCBi L2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vbG9iLmgKaW5kZXggZmVhYWU3Y2M4OTkuLjM5 NDFmZTdhOGI2IDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYXJtL2xvYi5o CisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vbG9iLmgKQEAgLTEsMTUgKzEsMTMx IEBACiAjaW5jbHVkZSA8c3RyaW5nLmg+Ci0KKyNpbmNsdWRlIDxzdGRpbnQuaD4KIC8qIENvbW1v biBjb2RlIGZvciBsb2IgdGVzdHMuICAqLwogCiAjZGVmaW5lIE5PX0xPQiBhc20gdm9sYXRpbGUg KCJAIGNsb2JiZXIgbHIiIDogOiA6ICJsciIgKQogCi0jZGVmaW5lIE4gMTAwMDAKKyNkZWZpbmUg TiAxMDAKKworc3RhdGljIHZvaWQKK3Jlc2V0X2RhdGEgKGludCAqYSwgaW50ICpiLCBpbnQgKmMs IGludCB4KQoreworICBtZW1zZXQgKGEsIC0xLCB4ICogc2l6ZW9mICgqYSkpOworICBtZW1zZXQg KGIsIC0xLCB4ICogc2l6ZW9mICgqYikpOworICBtZW1zZXQgKGMsIDAsIHggKiBzaXplb2YgKCpj KSk7Cit9CisKK3N0YXRpYyB2b2lkCityZXNldF9kYXRhOCAoaW50OF90ICphLCBpbnQ4X3QgKmIs IGludDhfdCAqYywgaW50IHgpCit7CisgIG1lbXNldCAoYSwgLTEsIHggKiBzaXplb2YgKCphKSk7 CisgIG1lbXNldCAoYiwgLTEsIHggKiBzaXplb2YgKCpiKSk7CisgIG1lbXNldCAoYywgMCwgeCAq IHNpemVvZiAoKmMpKTsKK30KKworc3RhdGljIHZvaWQKK3Jlc2V0X2RhdGExNiAoaW50MTZfdCAq YSwgaW50MTZfdCAqYiwgaW50MTZfdCAqYywgaW50IHgpCit7CisgIG1lbXNldCAoYSwgLTEsIHgg KiBzaXplb2YgKCphKSk7CisgIG1lbXNldCAoYiwgLTEsIHggKiBzaXplb2YgKCpiKSk7CisgIG1l bXNldCAoYywgMCwgeCAqIHNpemVvZiAoKmMpKTsKK30KKworc3RhdGljIHZvaWQKK3Jlc2V0X2Rh dGEzMiAoaW50MzJfdCAqYSwgaW50MzJfdCAqYiwgaW50MzJfdCAqYywgaW50IHgpCit7CisgIG1l bXNldCAoYSwgLTEsIHggKiBzaXplb2YgKCphKSk7CisgIG1lbXNldCAoYiwgLTEsIHggKiBzaXpl b2YgKCpiKSk7CisgIG1lbXNldCAoYywgMCwgeCAqIHNpemVvZiAoKmMpKTsKK30KKworc3RhdGlj IHZvaWQKK3Jlc2V0X2RhdGE2NCAoaW50NjRfdCAqYSwgaW50NjRfdCAqYywgaW50IHgpCit7Cisg IG1lbXNldCAoYSwgLTEsIHggKiBzaXplb2YgKCphKSk7CisgIG1lbXNldCAoYywgMCwgeCAqIHNp emVvZiAoKmMpKTsKK30KKworc3RhdGljIHZvaWQKK2NoZWNrX3BsdXMgKGludCAqYSwgaW50ICpi LCBpbnQgKmMsIGludCB4KQoreworICBmb3IgKGludCBpID0gMDsgaSA8IE47IGkrKykKKyAgICB7 CisgICAgICBOT19MT0I7CisgICAgICBpZiAoaSA8IHgpCisJeworCSAgaWYgKGNbaV0gIT0gKGFb aV0gKyBiW2ldKSkgYWJvcnQgKCk7CisJfQorICAgICAgZWxzZQorCXsKKwkgIGlmIChjW2ldICE9 IDApIGFib3J0ICgpOworCX0KKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkCitjaGVja19wbHVzOCAo aW50OF90ICphLCBpbnQ4X3QgKmIsIGludDhfdCAqYywgaW50IHgpCit7CisgIGZvciAoaW50IGkg PSAwOyBpIDwgTjsgaSsrKQorICAgIHsKKyAgICAgIE5PX0xPQjsKKyAgICAgIGlmIChpIDwgeCkK Kwl7CisJICBpZiAoY1tpXSAhPSAoYVtpXSArIGJbaV0pKSBhYm9ydCAoKTsKKwl9CisgICAgICBl bHNlCisJeworCSAgaWYgKGNbaV0gIT0gMCkgYWJvcnQgKCk7CisJfQorICAgIH0KK30KKworc3Rh dGljIHZvaWQKK2NoZWNrX3BsdXMxNiAoaW50MTZfdCAqYSwgaW50MTZfdCAqYiwgaW50MTZfdCAq YywgaW50IHgpCit7CisgIGZvciAoaW50IGkgPSAwOyBpIDwgTjsgaSsrKQorICAgIHsKKyAgICAg IE5PX0xPQjsKKyAgICAgIGlmIChpIDwgeCkKKwl7CisJICBpZiAoY1tpXSAhPSAoYVtpXSArIGJb aV0pKSBhYm9ydCAoKTsKKwl9CisgICAgICBlbHNlCisJeworCSAgaWYgKGNbaV0gIT0gMCkgYWJv cnQgKCk7CisJfQorICAgIH0KK30KKworc3RhdGljIHZvaWQKK2NoZWNrX3BsdXMzMiAoaW50MzJf dCAqYSwgaW50MzJfdCAqYiwgaW50MzJfdCAqYywgaW50IHgpCit7CisgIGZvciAoaW50IGkgPSAw OyBpIDwgTjsgaSsrKQorICAgIHsKKyAgICAgIE5PX0xPQjsKKyAgICAgIGlmIChpIDwgeCkKKwl7 CisJICBpZiAoY1tpXSAhPSAoYVtpXSArIGJbaV0pKSBhYm9ydCAoKTsKKwl9CisgICAgICBlbHNl CisJeworCSAgaWYgKGNbaV0gIT0gMCkgYWJvcnQgKCk7CisJfQorICAgIH0KK30KIAogc3RhdGlj IHZvaWQKLXJlc2V0X2RhdGEgKGludCAqYSwgaW50ICpiLCBpbnQgKmMpCitjaGVja19tZW1jcHk2 NCAoaW50NjRfdCAqYSwgaW50NjRfdCAqYywgaW50IHgpCiB7Ci0gIG1lbXNldCAoYSwgLTEsIE4g KiBzaXplb2YgKCphKSk7Ci0gIG1lbXNldCAoYiwgLTEsIE4gKiBzaXplb2YgKCpiKSk7Ci0gIG1l bXNldCAoYywgLTEsIE4gKiBzaXplb2YgKCpjKSk7CisgIGZvciAoaW50IGkgPSAwOyBpIDwgTjsg aSsrKQorICAgIHsKKyAgICAgIE5PX0xPQjsKKyAgICAgIGlmIChpIDwgeCkKKwl7CisJICBpZiAo Y1tpXSAhPSBhW2ldKSBhYm9ydCAoKTsKKwl9CisgICAgICBlbHNlCisJeworCSAgaWYgKGNbaV0g IT0gMCkgYWJvcnQgKCk7CisJfQorICAgIH0KIH0KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv Z2NjLnRhcmdldC9hcm0vbG9iMS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9sb2Ix LmMKaW5kZXggYmE1YzgyY2Q1NWMuLmM4Y2U2NTNhNWMzIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1 aXRlL2djYy50YXJnZXQvYXJtL2xvYjEuYworKysgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQv YXJtL2xvYjEuYwpAQCAtNTQsMjkgKzU0LDE4IEBAIGxvb3AzIChpbnQgKmEsIGludCAqYiwgaW50 ICpjKQogICAgIH0gd2hpbGUgKGkgPCBOKTsKIH0KIAotdm9pZAotY2hlY2sgKGludCAqYSwgaW50 ICpiLCBpbnQgKmMpCi17Ci0gIGZvciAoaW50IGkgPSAwOyBpIDwgTjsgaSsrKQotICAgIHsKLSAg ICAgIE5PX0xPQjsKLSAgICAgIGlmIChjW2ldICE9IGFbaV0gKyBiW2ldKQotCWFib3J0ICgpOwot ICAgIH0KLX0KLQogaW50CiBtYWluICh2b2lkKQogewotICByZXNldF9kYXRhIChhLCBiLCBjKTsK KyAgcmVzZXRfZGF0YSAoYSwgYiwgYywgTik7CiAgIGxvb3AxIChhLCBiICxjKTsKLSAgY2hlY2sg KGEsIGIgLGMpOwotICByZXNldF9kYXRhIChhLCBiLCBjKTsKKyAgY2hlY2tfcGx1cyAoYSwgYiwg YywgTik7CisgIHJlc2V0X2RhdGEgKGEsIGIsIGMsIE4pOwogICBsb29wMiAoYSwgYiAsYyk7Ci0g IGNoZWNrIChhLCBiICxjKTsKLSAgcmVzZXRfZGF0YSAoYSwgYiwgYyk7CisgIGNoZWNrX3BsdXMg KGEsIGIsIGMsIE4pOworICByZXNldF9kYXRhIChhLCBiLCBjLCBOKTsKICAgbG9vcDMgKGEsIGIg LGMpOwotICBjaGVjayAoYSwgYiAsYyk7CisgIGNoZWNrX3BsdXMgKGEsIGIsIGMsIE4pOwogCiAg IHJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FybS9s b2I2LmMgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYXJtL2xvYjYuYwppbmRleCAxN2I2MTI0 Mjk1ZS4uNGZlMTE2ZTJjMmIgMTAwNjQ0Ci0tLSBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9h cm0vbG9iNi5jCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hcm0vbG9iNi5jCkBAIC03 OSwxNCArNzksMTQgQEAgY2hlY2sgKHZvaWQpCiBpbnQKIG1haW4gKHZvaWQpCiB7Ci0gIHJlc2V0 X2RhdGEgKGExLCBiMSwgYzEpOwotICByZXNldF9kYXRhIChhMiwgYjIsIGMyKTsKKyAgcmVzZXRf ZGF0YSAoYTEsIGIxLCBjMSwgTik7CisgIHJlc2V0X2RhdGEgKGEyLCBiMiwgYzIsIE4pOwogICBs b29wMSAoYTEsIGIxLCBjMSk7CiAgIHJlZjEgKGEyLCBiMiwgYzIpOwogICBjaGVjayAoKTsKIAot ICByZXNldF9kYXRhIChhMSwgYjEsIGMxKTsKLSAgcmVzZXRfZGF0YSAoYTIsIGIyLCBjMik7Cisg IHJlc2V0X2RhdGEgKGExLCBiMSwgYzEsIE4pOworICByZXNldF9kYXRhIChhMiwgYjIsIGMyLCBO KTsKICAgbG9vcDIgKGExLCBiMSwgYzEpOwogICByZWYyIChhMiwgYjIsIGMyKTsKICAgY2hlY2sg KCk7Cg== --------------iBHKydoUu52nOf9uk3gvNMaX--