From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752038AbeBTN3M (ORCPT ); Tue, 20 Feb 2018 08:29:12 -0500 Received: from mail-lf0-f66.google.com ([209.85.215.66]:34324 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751737AbeBTN3K (ORCPT ); Tue, 20 Feb 2018 08:29:10 -0500 X-Google-Smtp-Source: AH8x2274D+6PE8OAyj53m2w+ROvnfBEcv7oW0dGYphp3stXcIQX3SHZHCzG2to6XuFNM6fU3GMzj/w== Subject: Re: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC From: Oleksandr Andrushchenko To: Oleksandr Andrushchenko , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, airlied@linux.ie, daniel.vetter@intel.com References: <1518511456-28257-1-git-send-email-andr2000@gmail.com> <20180219143002.GC22199@phenom.ffwll.local> <20180220111748.GJ22199@phenom.ffwll.local> <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> <20180220124919.GS22199@phenom.ffwll.local> <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.com> Message-ID: <12b4be99-9003-d566-bda4-2982d5562307@gmail.com> Date: Tue, 20 Feb 2018 15:29:07 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.6.0 MIME-Version: 1.0 In-Reply-To: <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 02/20/2018 02:53 PM, Oleksandr Andrushchenko wrote: > On 02/20/2018 02:49 PM, Daniel Vetter wrote: >> On Tue, Feb 20, 2018 at 02:36:05PM +0200, Oleksandr Andrushchenko wrote: >>> On 02/20/2018 01:17 PM, Daniel Vetter wrote: >>>> On Mon, Feb 19, 2018 at 04:58:43PM +0200, Oleksandr Andrushchenko >>>> wrote: >>>>> On 02/19/2018 04:30 PM, Daniel Vetter wrote: >>>>>> On Tue, Feb 13, 2018 at 10:44:16AM +0200, Oleksandr Andrushchenko >>>>>> wrote: >>>>>>> From: Oleksandr Andrushchenko >>>>>>> >>>>>>> It is possible that drm_simple_kms_plane_atomic_check called >>>>>>> with no CRTC set, e.g. when user-space application sets >>>>>>> CRTC_ID/FB_ID >>>>>>> to 0 before doing any actual drawing. This leads to NULL pointer >>>>>>> dereference because in this case new CRTC state is NULL and must be >>>>>>> checked before accessing. >>>>>>> >>>>>>> Signed-off-by: Oleksandr Andrushchenko >>>>>>> >>>>>>> --- >>>>>>>     drivers/gpu/drm/drm_simple_kms_helper.c | 6 ++++-- >>>>>>>     1 file changed, 4 insertions(+), 2 deletions(-) >>>>>>> >>>>>>> diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c >>>>>>> b/drivers/gpu/drm/drm_simple_kms_helper.c >>>>>>> index 9ca8a4a59b74..a05eca9cec8b 100644 >>>>>>> --- a/drivers/gpu/drm/drm_simple_kms_helper.c >>>>>>> +++ b/drivers/gpu/drm/drm_simple_kms_helper.c >>>>>>> @@ -121,8 +121,10 @@ static int >>>>>>> drm_simple_kms_plane_atomic_check(struct drm_plane *plane, >>>>>>>         pipe = container_of(plane, struct >>>>>>> drm_simple_display_pipe, plane); >>>>>>>         crtc_state = >>>>>>> drm_atomic_get_new_crtc_state(plane_state->state, >>>>>>>                                &pipe->crtc); >>>>>>> -    if (!crtc_state->enable) >>>>>>> -        return 0; /* nothing to check when disabling or >>>>>>> disabled */ >>>>>>> + >>>>>>> +    if (!crtc_state || !crtc_state->enable) >>>>>>> +        /* nothing to check when disabling or disabled or no >>>>>>> CRTC set */ >>>>>>> +        return 0; >>>>>>>         if (crtc_state->enable) >>>>>>> drm_mode_get_hv_timing(&crtc_state->mode, >>>>>> Hm, this is a bit annoying, since the can_position = false >>>>>> parameter to >>>>>> drm_atomic_helper_check_plane_state is supposed to catch all >>>>>> this. Would >>>>>> moving all the checks after the call to that helper, and gating >>>>>> them on >>>>>> plane_state->visible also work? >>>>> Yes, it does work if this is what you mean: >>>> I wasn't sure, thanks for figuring this out! >>>> >>>>> diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c >>>>> b/drivers/gpu/drm/drm_simple_kms_helper.c >>>>> index a05eca9cec8b..c48858bb2823 100644 >>>>> --- a/drivers/gpu/drm/drm_simple_kms_helper.c >>>>> +++ b/drivers/gpu/drm/drm_simple_kms_helper.c >>>>> @@ -122,14 +122,6 @@ static int >>>>> drm_simple_kms_plane_atomic_check(struct >>>>> drm_plane *plane, >>>>>           crtc_state = >>>>> drm_atomic_get_new_crtc_state(plane_state->state, >>>>> &pipe->crtc); >>>>> >>>>> -       if (!crtc_state || !crtc_state->enable) >>>>> -               /* nothing to check when disabling or disabled or >>>>> no CRTC >>>>> set */ >>>>> -               return 0; >>>>> - >>>>> -       if (crtc_state->enable) >>>>> - drm_mode_get_hv_timing(&crtc_state->mode, >>>>> -                                      &clip.x2, &clip.y2); >>>>> - >>>>>           ret = drm_atomic_helper_check_plane_state(plane_state, >>>>> crtc_state, >>>>> &clip, >>>>> DRM_PLANE_HELPER_NO_SCALING, >>>>> @@ -138,6 +130,13 @@ static int >>>>> drm_simple_kms_plane_atomic_check(struct >>>>> drm_plane *plane, >>>>>           if (ret) >>>>>                   return ret; >>>>> >>>>> +       if (!plane_state->visible || !crtc_state->enable) >>>>> +               return 0; /* nothing to check when disabling or >>>>> disabled */ >>>> if (!plane_state->visible) { >>>>     WARN_ON(crtc_state->enabled); >>>>     return 0; >>>> } >>>> >>>> The helper call above should guarantee this. >>> Yes, but I still see cases when crtc_state is NULL, thus >>> making crtc_state->enable to fail >> Right, when the plane is completely off there's no CRTC state. Correct >> check should be >> >>     WARN_ON(crtc_state && crtc_state->enabled); > ok, will update with this additional check huh, this indeed solves the NULL pointer dereference, but floods a lot with every page flip I have, e.g. !plane_state->visible == true and crtc_state is not NULL and crtc_state->enable == true, thus firing WARN_ON. Is this something wrong with my use-case/driver or it is still legal to have such a configuration and leave it without WARN_ON and just return 0? >> >>>>> + >>>>> +       if (plane_state->visible && crtc_state->enable) >>>> Similar here. >>>> >>>>> + drm_mode_get_hv_timing(&crtc_state->mode, >>>>> +                                      &clip.x2, &clip.y2); >>>>> + >>>>>           if (!plane_state->visible) >>>>>                   return -EINVAL; >>>> This can now be removed, the plane helper takes care of checking for >>>> plane_state->visible != crtc_state->enable. Please also remove. >>>> >>>>>> We'd need to add a guarantee to >>>>>> drm_atomic_helper_check_plane_state that >>>>>> it can cope with crtc_state == NULL, but I think that's a good idea >>>>>> anyway. Atm it shouldn't end up looking at the crtc_state pointer >>>>>> in that >>>>>> case. >>>>> It doesn't look at it at the moment >>>>>> Otherwise we'll just go with your fix, but it feels all a bit too >>>>>> fragile, >>>>>> hence why I want to explore more robust options a bit. >>>>> At list with the change above it passes my test which failed >>>>> before. Although I cannot confirm it works for others, but it >>>>> certainly does for me. >>>>>> -Daniel >>>>> Do you want me to send v1 with the code above? >>>> Yes please, with my above cleanup suggestions. >>> Please see the patch under test attached (I believe it is what you >>> mean, >>> with the only change that >>>      if (!plane_state->visible) { >>>          *if (crtc_state)* >>>              WARN_ON(crtc_state->enable); >>>          return 0; >>>      } >>> check is used). >>> >>> Whith this patch + additional logs I have: >>> >>> [   18.939204] [drm:drm_ioctl [drm]] pid=2105, dev=0xe200, auth=1, >>> DRM_IOCTL_MODE_ATOMIC >>> [...] >>> [   18.939681] [drm:drm_atomic_set_crtc_for_plane [drm]] Link plane >>> state >>> 00000000c302cbbf to [NOCRTC] >>> [   18.939822] [drm:drm_atomic_set_fb_for_plane [drm]] Set [NOFB] >>> for plane >>> state 00000000c302cbbf >>> [   18.939963] [drm:drm_atomic_print_state [drm]] checking >>> 000000000bc224e7 >>> [   18.939988] vdispl vdispl.0: [drm] plane[29]: plane-0 >>> [   18.940003] vdispl vdispl.0: [drm]   crtc=(null) >>> [   18.940018] vdispl vdispl.0: [drm]   fb=0 >>> [   18.940032] vdispl vdispl.0: [drm]   crtc-pos=0x0+0+0 >>> [   18.940048] vdispl vdispl.0: [drm] >>> src-pos=0.000000x0.000000+0.000000+0.000000 >>> [   18.940067] vdispl vdispl.0: [drm]   rotation=1 >>> [   18.940199] [drm:drm_atomic_check_only [drm]] checking >>> 000000000bc224e7 >>> [   18.940226] ================================= plane_state->visible 0 >>> crtc_state           (null) >>> [...] >>> [   18.978146] [drm:drm_atomic_set_crtc_for_plane [drm]] Link plane >>> state >>> 000000006bd50580 to [CRTC:30:crtc-0] >>> [   18.978292] [drm:drm_atomic_set_fb_for_plane [drm]] Set [FB:35] >>> for plane >>> state 000000006bd50580 >>> [   18.978993] [drm:drm_atomic_set_mode_prop_for_crtc [drm]] Set >>> [MODE:1024x768] for CRTC state 00000000e5a28f6a >>> [   18.979425] [drm:drm_atomic_check_only [drm]] checking >>> 000000000bc224e7 >>> [   18.979540] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> [CRTC:30:crtc-0] mode changed >>> [   18.979632] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> [CRTC:30:crtc-0] enable changed >>> [   18.979708] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> [CRTC:30:crtc-0] active changed >>> [   18.979792] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> Updating routing for [CONNECTOR:28:Virtual-1] >>> [   18.979877] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> [CONNECTOR:28:Virtual-1] using [ENCODER:31:None-31] on [CRTC:30:crtc-0] >>> [   18.979960] [drm:drm_atomic_helper_check_modeset [drm_kms_helper]] >>> [CRTC:30:crtc-0] needs all connectors, enable: y, active: y >>> [   18.980139] [drm:drm_atomic_add_affected_connectors [drm]] Adding >>> all >>> current connectors for [CRTC:30:crtc-0] to 000000000bc224e7 >>> [   18.980184] ================================= plane_state->visible 0 >>> crtc_state 00000000e5a28f6a >>> [   18.980205] crtc_state->enable 1 >>> >>> *[   19.022608] WARNING: CPU: 1 PID: 2105 at >>> drivers/gpu/drm/drm_simple_kms_helper.c:137 >>> drm_simple_kms_plane_atomic_check+0xdc/0xf8 [drm_kms_helper]* >>> >>> [...] >>> >>> [   19.113601] ================================= plane_state->visible 0 >>> crtc_state 00000000e5a28f6a >>> [   19.113623] crtc_state->enable 1 >>> [   19.113792] WARNING: CPU: 1 PID: 2105 at >>> drivers/gpu/drm/drm_simple_kms_helper.c:137 >>> drm_simple_kms_plane_atomic_check+0xdc/0xf8 [drm_kms_helper] >>> >>> [...] >>> >>> And finally >>> >>> [   19.340249] ================================= plane_state->visible 0 >>> crtc_state 0000000036a1b1f5 >>> [   19.340271] crtc_state->enable 0 >>> >>> So, it seems that crtc_state can still be NULL if >>> "!plane_state->visible" >>> making >>> NULL pointer dereference, so we need a check for that. >>> Yet, !plane_state->visible && crtc_state->enable makes WARN_ON to fire >>> always. So, probably we may want removing it. >>>> Thanks, Daniel >>> Thank you, >>> Oleksandr >>>  From dbcce708b237740158a2c16029c56a579324f269 Mon Sep 17 00:00:00 2001 >>> From: Oleksandr Andrushchenko >>> Date: Tue, 13 Feb 2018 10:32:20 +0200 >>> Subject: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference >>> with no >>>   active CRTC >>> >>> It is possible that drm_simple_kms_plane_atomic_check called >>> with no CRTC set, e.g. when user-space application sets CRTC_ID/FB_ID >>> to 0 before doing any actual drawing. This leads to NULL pointer >>> dereference because in this case new CRTC state is NULL and must be >>> checked before accessing. >>> >>> Signed-off-by: Oleksandr Andrushchenko >>> >>> --- >>>   drivers/gpu/drm/drm_simple_kms_helper.c | 15 +++++++-------- >>>   1 file changed, 7 insertions(+), 8 deletions(-) >>> >>> diff --git a/drivers/gpu/drm/drm_simple_kms_helper.c >>> b/drivers/gpu/drm/drm_simple_kms_helper.c >>> index 9ca8a4a59b74..f54711ff9767 100644 >>> --- a/drivers/gpu/drm/drm_simple_kms_helper.c >>> +++ b/drivers/gpu/drm/drm_simple_kms_helper.c >>> @@ -121,12 +121,6 @@ static int >>> drm_simple_kms_plane_atomic_check(struct drm_plane *plane, >>>       pipe = container_of(plane, struct drm_simple_display_pipe, >>> plane); >>>       crtc_state = drm_atomic_get_new_crtc_state(plane_state->state, >>>                              &pipe->crtc); >>> -    if (!crtc_state->enable) >>> -        return 0; /* nothing to check when disabling or disabled */ >>> - >>> -    if (crtc_state->enable) >>> -        drm_mode_get_hv_timing(&crtc_state->mode, >>> -                       &clip.x2, &clip.y2); >>>         ret = drm_atomic_helper_check_plane_state(plane_state, >>> crtc_state, >>>                             &clip, >>> @@ -136,8 +130,13 @@ static int >>> drm_simple_kms_plane_atomic_check(struct drm_plane *plane, >>>       if (ret) >>>           return ret; >>>   -    if (!plane_state->visible) >>> -        return -EINVAL; >>> +    if (!plane_state->visible) { >>> +        if (crtc_state) >>> +            WARN_ON(crtc_state->enable); >>> +        return 0; >>> +    } >>> + >>> +    drm_mode_get_hv_timing(&crtc_state->mode, &clip.x2, &clip.y2); >> lgtm. With or without the bikeshed to pull the crtc_state check into the >> WARN_ON. >> >> Reviewed-by: Daniel Vetter > Thank you >> >> Please resubmit as a stand-alone patch, patchwork can't pull patches out >> of attachments :-/ > oh, that was for demonstration purpose only, so we > are on the same page and see the patch we are discussing ;) >> -Daniel >> >>>         if (!pipe->funcs || !pipe->funcs->check) >>>           return 0; >>> -- >>> 2.7.4 >>> >>> _______________________________________________ >>> dri-devel mailing list >>> dri-devel@lists.freedesktop.org >>> https://lists.freedesktop.org/mailman/listinfo/dri-devel >> > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: Re: [PATCH] drm/simple_kms_helper: Fix NULL pointer dereference with no active CRTC Date: Tue, 20 Feb 2018 15:29:07 +0200 Message-ID: <12b4be99-9003-d566-bda4-2982d5562307@gmail.com> References: <1518511456-28257-1-git-send-email-andr2000@gmail.com> <20180219143002.GC22199@phenom.ffwll.local> <20180220111748.GJ22199@phenom.ffwll.local> <38f46c4f-3c0d-cf86-3d50-cf0f9313b205@gmail.com> <20180220124919.GS22199@phenom.ffwll.local> <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x243.google.com (mail-lf0-x243.google.com [IPv6:2a00:1450:4010:c07::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id A091F6E417 for ; Tue, 20 Feb 2018 13:29:10 +0000 (UTC) Received: by mail-lf0-x243.google.com with SMTP id r80so4154166lfe.13 for ; Tue, 20 Feb 2018 05:29:10 -0800 (PST) In-Reply-To: <94327c23-af1c-a348-5dd2-dfb963b71c96@gmail.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Oleksandr Andrushchenko , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, airlied@linux.ie, daniel.vetter@intel.com List-Id: dri-devel@lists.freedesktop.org T24gMDIvMjAvMjAxOCAwMjo1MyBQTSwgT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gd3JvdGU6Cj4g T24gMDIvMjAvMjAxOCAwMjo0OSBQTSwgRGFuaWVsIFZldHRlciB3cm90ZToKPj4gT24gVHVlLCBG ZWIgMjAsIDIwMTggYXQgMDI6MzY6MDVQTSArMDIwMCwgT2xla3NhbmRyIEFuZHJ1c2hjaGVua28g d3JvdGU6Cj4+PiBPbiAwMi8yMC8yMDE4IDAxOjE3IFBNLCBEYW5pZWwgVmV0dGVyIHdyb3RlOgo+ Pj4+IE9uIE1vbiwgRmViIDE5LCAyMDE4IGF0IDA0OjU4OjQzUE0gKzAyMDAsIE9sZWtzYW5kciBB bmRydXNoY2hlbmtvIAo+Pj4+IHdyb3RlOgo+Pj4+PiBPbiAwMi8xOS8yMDE4IDA0OjMwIFBNLCBE YW5pZWwgVmV0dGVyIHdyb3RlOgo+Pj4+Pj4gT24gVHVlLCBGZWIgMTMsIDIwMTggYXQgMTA6NDQ6 MTZBTSArMDIwMCwgT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gCj4+Pj4+PiB3cm90ZToKPj4+Pj4+ PiBGcm9tOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29A ZXBhbS5jb20+Cj4+Pj4+Pj4KPj4+Pj4+PiBJdCBpcyBwb3NzaWJsZSB0aGF0IGRybV9zaW1wbGVf a21zX3BsYW5lX2F0b21pY19jaGVjayBjYWxsZWQKPj4+Pj4+PiB3aXRoIG5vIENSVEMgc2V0LCBl LmcuIHdoZW4gdXNlci1zcGFjZSBhcHBsaWNhdGlvbiBzZXRzIAo+Pj4+Pj4+IENSVENfSUQvRkJf SUQKPj4+Pj4+PiB0byAwIGJlZm9yZSBkb2luZyBhbnkgYWN0dWFsIGRyYXdpbmcuIFRoaXMgbGVh ZHMgdG8gTlVMTCBwb2ludGVyCj4+Pj4+Pj4gZGVyZWZlcmVuY2UgYmVjYXVzZSBpbiB0aGlzIGNh c2UgbmV3IENSVEMgc3RhdGUgaXMgTlVMTCBhbmQgbXVzdCBiZQo+Pj4+Pj4+IGNoZWNrZWQgYmVm b3JlIGFjY2Vzc2luZy4KPj4+Pj4+Pgo+Pj4+Pj4+IFNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBB bmRydXNoY2hlbmtvIAo+Pj4+Pj4+IDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4K Pj4+Pj4+PiAtLS0KPj4+Pj4+PiDCoMKgwqAgZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21z X2hlbHBlci5jIHwgNiArKysrLS0KPj4+Pj4+PiDCoMKgwqAgMSBmaWxlIGNoYW5nZWQsIDQgaW5z ZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKPj4+Pj4+Pgo+Pj4+Pj4+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMgCj4+Pj4+Pj4gYi9kcml2ZXJz L2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMKPj4+Pj4+PiBpbmRleCA5Y2E4YTRhNTli NzQuLmEwNWVjYTljZWM4YiAxMDA2NDQKPj4+Pj4+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJt X3NpbXBsZV9rbXNfaGVscGVyLmMKPj4+Pj4+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3Np bXBsZV9rbXNfaGVscGVyLmMKPj4+Pj4+PiBAQCAtMTIxLDggKzEyMSwxMCBAQCBzdGF0aWMgaW50 IAo+Pj4+Pj4+IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3Bs YW5lICpwbGFuZSwKPj4+Pj4+PiDCoMKgwqDCoMKgwqDCoCBwaXBlID0gY29udGFpbmVyX29mKHBs YW5lLCBzdHJ1Y3QgCj4+Pj4+Pj4gZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUsIHBsYW5lKTsKPj4+ Pj4+PiDCoMKgwqDCoMKgwqDCoCBjcnRjX3N0YXRlID0gCj4+Pj4+Pj4gZHJtX2F0b21pY19nZXRf bmV3X2NydGNfc3RhdGUocGxhbmVfc3RhdGUtPnN0YXRlLAo+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAmcGlwZS0+Y3J0 Yyk7Cj4+Pj4+Pj4gLcKgwqDCoCBpZiAoIWNydGNfc3RhdGUtPmVuYWJsZSkKPj4+Pj4+PiAtwqDC oMKgwqDCoMKgwqAgcmV0dXJuIDA7IC8qIG5vdGhpbmcgdG8gY2hlY2sgd2hlbiBkaXNhYmxpbmcg b3IgCj4+Pj4+Pj4gZGlzYWJsZWQgKi8KPj4+Pj4+PiArCj4+Pj4+Pj4gK8KgwqDCoCBpZiAoIWNy dGNfc3RhdGUgfHwgIWNydGNfc3RhdGUtPmVuYWJsZSkKPj4+Pj4+PiArwqDCoMKgwqDCoMKgwqAg Lyogbm90aGluZyB0byBjaGVjayB3aGVuIGRpc2FibGluZyBvciBkaXNhYmxlZCBvciBubyAKPj4+ Pj4+PiBDUlRDIHNldCAqLwo+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4gMDsKPj4+Pj4+ PiDCoMKgwqDCoMKgwqDCoCBpZiAoY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+Pj4+Pj4+IGRybV9tb2Rl X2dldF9odl90aW1pbmcoJmNydGNfc3RhdGUtPm1vZGUsCj4+Pj4+PiBIbSwgdGhpcyBpcyBhIGJp dCBhbm5veWluZywgc2luY2UgdGhlIGNhbl9wb3NpdGlvbiA9IGZhbHNlIAo+Pj4+Pj4gcGFyYW1l dGVyIHRvCj4+Pj4+PiBkcm1fYXRvbWljX2hlbHBlcl9jaGVja19wbGFuZV9zdGF0ZSBpcyBzdXBw b3NlZCB0byBjYXRjaCBhbGwgCj4+Pj4+PiB0aGlzLiBXb3VsZAo+Pj4+Pj4gbW92aW5nIGFsbCB0 aGUgY2hlY2tzIGFmdGVyIHRoZSBjYWxsIHRvIHRoYXQgaGVscGVyLCBhbmQgZ2F0aW5nIAo+Pj4+ Pj4gdGhlbSBvbgo+Pj4+Pj4gcGxhbmVfc3RhdGUtPnZpc2libGUgYWxzbyB3b3JrPwo+Pj4+PiBZ ZXMsIGl0IGRvZXMgd29yayBpZiB0aGlzIGlzIHdoYXQgeW91IG1lYW46Cj4+Pj4gSSB3YXNuJ3Qg c3VyZSwgdGhhbmtzIGZvciBmaWd1cmluZyB0aGlzIG91dCEKPj4+Pgo+Pj4+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jCj4+Pj4+IGIvZHJpdmVy cy9ncHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jCj4+Pj4+IGluZGV4IGEwNWVjYTljZWM4 Yi4uYzQ4ODU4YmIyODIzIDEwMDY0NAo+Pj4+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3Np bXBsZV9rbXNfaGVscGVyLmMKPj4+Pj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9zaW1wbGVf a21zX2hlbHBlci5jCj4+Pj4+IEBAIC0xMjIsMTQgKzEyMiw2IEBAIHN0YXRpYyBpbnQgCj4+Pj4+ IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjayhzdHJ1Y3QKPj4+Pj4gZHJtX3BsYW5l ICpwbGFuZSwKPj4+Pj4gwqAgwqDCoMKgwqDCoMKgwqAgY3J0Y19zdGF0ZSA9IAo+Pj4+PiBkcm1f YXRvbWljX2dldF9uZXdfY3J0Y19zdGF0ZShwbGFuZV9zdGF0ZS0+c3RhdGUsCj4+Pj4+ICZwaXBl LT5jcnRjKTsKPj4+Pj4KPj4+Pj4gLcKgwqDCoMKgwqDCoCBpZiAoIWNydGNfc3RhdGUgfHwgIWNy dGNfc3RhdGUtPmVuYWJsZSkKPj4+Pj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgLyog bm90aGluZyB0byBjaGVjayB3aGVuIGRpc2FibGluZyBvciBkaXNhYmxlZCBvciAKPj4+Pj4gbm8g Q1JUQwo+Pj4+PiBzZXQgKi8KPj4+Pj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0 dXJuIDA7Cj4+Pj4+IC0KPj4+Pj4gLcKgwqDCoMKgwqDCoCBpZiAoY3J0Y19zdGF0ZS0+ZW5hYmxl KQo+Pj4+PiAtIGRybV9tb2RlX2dldF9odl90aW1pbmcoJmNydGNfc3RhdGUtPm1vZGUsCj4+Pj4+ IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAmY2xpcC54MiwgJmNsaXAueTIpOwo+Pj4+PiAtCj4+Pj4+IMKg IMKgwqDCoMKgwqDCoMKgIHJldCA9IGRybV9hdG9taWNfaGVscGVyX2NoZWNrX3BsYW5lX3N0YXRl KHBsYW5lX3N0YXRlLCAKPj4+Pj4gY3J0Y19zdGF0ZSwKPj4+Pj4gJmNsaXAsCj4+Pj4+IERSTV9Q TEFORV9IRUxQRVJfTk9fU0NBTElORywKPj4+Pj4gQEAgLTEzOCw2ICsxMzAsMTMgQEAgc3RhdGlj IGludCAKPj4+Pj4gZHJtX3NpbXBsZV9rbXNfcGxhbmVfYXRvbWljX2NoZWNrKHN0cnVjdAo+Pj4+ PiBkcm1fcGxhbmUgKnBsYW5lLAo+Pj4+PiDCoCDCoMKgwqDCoMKgwqDCoCBpZiAocmV0KQo+Pj4+ PiDCoCDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIHJldDsKPj4+Pj4KPj4+ Pj4gK8KgwqDCoMKgwqDCoCBpZiAoIXBsYW5lX3N0YXRlLT52aXNpYmxlIHx8ICFjcnRjX3N0YXRl LT5lbmFibGUpCj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiAwOyAv KiBub3RoaW5nIHRvIGNoZWNrIHdoZW4gZGlzYWJsaW5nIG9yIAo+Pj4+PiBkaXNhYmxlZCAqLwo+ Pj4+IGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpIHsKPj4+PiDCoMKgwqDCoFdBUk5fT04oY3J0 Y19zdGF0ZS0+ZW5hYmxlZCk7Cj4+Pj4gwqDCoMKgwqByZXR1cm4gMDsKPj4+PiB9Cj4+Pj4KPj4+ PiBUaGUgaGVscGVyIGNhbGwgYWJvdmUgc2hvdWxkIGd1YXJhbnRlZSB0aGlzLgo+Pj4gWWVzLCBi dXQgSSBzdGlsbCBzZWUgY2FzZXMgd2hlbiBjcnRjX3N0YXRlIGlzIE5VTEwsIHRodXMKPj4+IG1h a2luZyBjcnRjX3N0YXRlLT5lbmFibGUgdG8gZmFpbAo+PiBSaWdodCwgd2hlbiB0aGUgcGxhbmUg aXMgY29tcGxldGVseSBvZmYgdGhlcmUncyBubyBDUlRDIHN0YXRlLiBDb3JyZWN0Cj4+IGNoZWNr IHNob3VsZCBiZQo+Pgo+PiDCoMKgwqDCoFdBUk5fT04oY3J0Y19zdGF0ZSAmJiBjcnRjX3N0YXRl LT5lbmFibGVkKTsKPiBvaywgd2lsbCB1cGRhdGUgd2l0aCB0aGlzIGFkZGl0aW9uYWwgY2hlY2sK aHVoLCB0aGlzIGluZGVlZCBzb2x2ZXMgdGhlIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSwgYnV0 IGZsb29kcyBhIGxvdAp3aXRoIGV2ZXJ5IHBhZ2UgZmxpcCBJIGhhdmUsIGUuZy4gIXBsYW5lX3N0 YXRlLT52aXNpYmxlID09IHRydWUKYW5kIGNydGNfc3RhdGUgaXMgbm90IE5VTEwgYW5kIGNydGNf c3RhdGUtPmVuYWJsZSA9PSB0cnVlLAp0aHVzIGZpcmluZyBXQVJOX09OLgpJcyB0aGlzIHNvbWV0 aGluZyB3cm9uZyB3aXRoIG15IHVzZS1jYXNlL2RyaXZlciBvciBpdCBpcyBzdGlsbCBsZWdhbAp0 byBoYXZlIHN1Y2ggYSBjb25maWd1cmF0aW9uIGFuZCBsZWF2ZSBpdCB3aXRob3V0IFdBUk5fT04g YW5kIGp1c3QKcmV0dXJuIDA/Cj4+Cj4+Pj4+ICsKPj4+Pj4gK8KgwqDCoMKgwqDCoCBpZiAocGxh bmVfc3RhdGUtPnZpc2libGUgJiYgY3J0Y19zdGF0ZS0+ZW5hYmxlKQo+Pj4+IFNpbWlsYXIgaGVy ZS4KPj4+Pgo+Pj4+PiArIGRybV9tb2RlX2dldF9odl90aW1pbmcoJmNydGNfc3RhdGUtPm1vZGUs Cj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAmY2xpcC54MiwgJmNsaXAueTIpOwo+Pj4+PiArCj4+ Pj4+IMKgIMKgwqDCoMKgwqDCoMKgIGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpCj4+Pj4+IMKg IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gLUVJTlZBTDsKPj4+PiBUaGlz IGNhbiBub3cgYmUgcmVtb3ZlZCwgdGhlIHBsYW5lIGhlbHBlciB0YWtlcyBjYXJlIG9mIGNoZWNr aW5nIGZvcgo+Pj4+IHBsYW5lX3N0YXRlLT52aXNpYmxlICE9IGNydGNfc3RhdGUtPmVuYWJsZS4g UGxlYXNlIGFsc28gcmVtb3ZlLgo+Pj4+Cj4+Pj4+PiBXZSdkIG5lZWQgdG8gYWRkIGEgZ3VhcmFu dGVlIHRvIAo+Pj4+Pj4gZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfcGxhbmVfc3RhdGUgdGhhdAo+ Pj4+Pj4gaXQgY2FuIGNvcGUgd2l0aCBjcnRjX3N0YXRlID09IE5VTEwsIGJ1dCBJIHRoaW5rIHRo YXQncyBhIGdvb2QgaWRlYQo+Pj4+Pj4gYW55d2F5LiBBdG0gaXQgc2hvdWxkbid0IGVuZCB1cCBs b29raW5nIGF0IHRoZSBjcnRjX3N0YXRlIHBvaW50ZXIgCj4+Pj4+PiBpbiB0aGF0Cj4+Pj4+PiBj YXNlLgo+Pj4+PiBJdCBkb2Vzbid0IGxvb2sgYXQgaXQgYXQgdGhlIG1vbWVudAo+Pj4+Pj4gT3Ro ZXJ3aXNlIHdlJ2xsIGp1c3QgZ28gd2l0aCB5b3VyIGZpeCwgYnV0IGl0IGZlZWxzIGFsbCBhIGJp dCB0b28gCj4+Pj4+PiBmcmFnaWxlLAo+Pj4+Pj4gaGVuY2Ugd2h5IEkgd2FudCB0byBleHBsb3Jl IG1vcmUgcm9idXN0IG9wdGlvbnMgYSBiaXQuCj4+Pj4+IEF0IGxpc3Qgd2l0aCB0aGUgY2hhbmdl IGFib3ZlIGl0IHBhc3NlcyBteSB0ZXN0IHdoaWNoIGZhaWxlZAo+Pj4+PiBiZWZvcmUuIEFsdGhv dWdoIEkgY2Fubm90IGNvbmZpcm0gaXQgd29ya3MgZm9yIG90aGVycywgYnV0IGl0Cj4+Pj4+IGNl cnRhaW5seSBkb2VzIGZvciBtZS4KPj4+Pj4+IC1EYW5pZWwKPj4+Pj4gRG8geW91IHdhbnQgbWUg dG8gc2VuZCB2MSB3aXRoIHRoZSBjb2RlIGFib3ZlPwo+Pj4+IFllcyBwbGVhc2UsIHdpdGggbXkg YWJvdmUgY2xlYW51cCBzdWdnZXN0aW9ucy4KPj4+IFBsZWFzZSBzZWUgdGhlIHBhdGNoIHVuZGVy IHRlc3QgYXR0YWNoZWQgKEkgYmVsaWV2ZSBpdCBpcyB3aGF0IHlvdSAKPj4+IG1lYW4sCj4+PiB3 aXRoIHRoZSBvbmx5IGNoYW5nZSB0aGF0Cj4+PiDCoMKgwqDCoCBpZiAoIXBsYW5lX3N0YXRlLT52 aXNpYmxlKSB7Cj4+PiDCoMKgwqDCoCDCoMKgwqAgKmlmIChjcnRjX3N0YXRlKSoKPj4+IMKgwqDC oMKgIMKgwqDCoCDCoMKgwqAgV0FSTl9PTihjcnRjX3N0YXRlLT5lbmFibGUpOwo+Pj4gwqDCoMKg wqAgwqDCoMKgIHJldHVybiAwOwo+Pj4gwqDCoMKgwqAgfQo+Pj4gY2hlY2sgaXMgdXNlZCkuCj4+ Pgo+Pj4gV2hpdGggdGhpcyBwYXRjaCArIGFkZGl0aW9uYWwgbG9ncyBJIGhhdmU6Cj4+Pgo+Pj4g W8KgwqAgMTguOTM5MjA0XSBbZHJtOmRybV9pb2N0bCBbZHJtXV0gcGlkPTIxMDUsIGRldj0weGUy MDAsIGF1dGg9MSwKPj4+IERSTV9JT0NUTF9NT0RFX0FUT01JQwo+Pj4gWy4uLl0KPj4+IFvCoMKg IDE4LjkzOTY4MV0gW2RybTpkcm1fYXRvbWljX3NldF9jcnRjX2Zvcl9wbGFuZSBbZHJtXV0gTGlu ayBwbGFuZSAKPj4+IHN0YXRlCj4+PiAwMDAwMDAwMGMzMDJjYmJmIHRvIFtOT0NSVENdCj4+PiBb wqDCoCAxOC45Mzk4MjJdIFtkcm06ZHJtX2F0b21pY19zZXRfZmJfZm9yX3BsYW5lIFtkcm1dXSBT ZXQgW05PRkJdIAo+Pj4gZm9yIHBsYW5lCj4+PiBzdGF0ZSAwMDAwMDAwMGMzMDJjYmJmCj4+PiBb wqDCoCAxOC45Mzk5NjNdIFtkcm06ZHJtX2F0b21pY19wcmludF9zdGF0ZSBbZHJtXV0gY2hlY2tp bmcgCj4+PiAwMDAwMDAwMDBiYzIyNGU3Cj4+PiBbwqDCoCAxOC45Mzk5ODhdIHZkaXNwbCB2ZGlz cGwuMDogW2RybV0gcGxhbmVbMjldOiBwbGFuZS0wCj4+PiBbwqDCoCAxOC45NDAwMDNdIHZkaXNw bCB2ZGlzcGwuMDogW2RybV3CoMKgIGNydGM9KG51bGwpCj4+PiBbwqDCoCAxOC45NDAwMThdIHZk aXNwbCB2ZGlzcGwuMDogW2RybV3CoMKgIGZiPTAKPj4+IFvCoMKgIDE4Ljk0MDAzMl0gdmRpc3Bs IHZkaXNwbC4wOiBbZHJtXcKgwqAgY3J0Yy1wb3M9MHgwKzArMAo+Pj4gW8KgwqAgMTguOTQwMDQ4 XSB2ZGlzcGwgdmRpc3BsLjA6IFtkcm1dCj4+PiBzcmMtcG9zPTAuMDAwMDAweDAuMDAwMDAwKzAu MDAwMDAwKzAuMDAwMDAwCj4+PiBbwqDCoCAxOC45NDAwNjddIHZkaXNwbCB2ZGlzcGwuMDogW2Ry bV3CoMKgIHJvdGF0aW9uPTEKPj4+IFvCoMKgIDE4Ljk0MDE5OV0gW2RybTpkcm1fYXRvbWljX2No ZWNrX29ubHkgW2RybV1dIGNoZWNraW5nIAo+Pj4gMDAwMDAwMDAwYmMyMjRlNwo+Pj4gW8KgwqAg MTguOTQwMjI2XSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gcGxhbmVfc3RhdGUt PnZpc2libGUgMAo+Pj4gY3J0Y19zdGF0ZcKgwqDCoMKgwqDCoMKgwqDCoMKgIChudWxsKQo+Pj4g Wy4uLl0KPj4+IFvCoMKgIDE4Ljk3ODE0Nl0gW2RybTpkcm1fYXRvbWljX3NldF9jcnRjX2Zvcl9w bGFuZSBbZHJtXV0gTGluayBwbGFuZSAKPj4+IHN0YXRlCj4+PiAwMDAwMDAwMDZiZDUwNTgwIHRv IFtDUlRDOjMwOmNydGMtMF0KPj4+IFvCoMKgIDE4Ljk3ODI5Ml0gW2RybTpkcm1fYXRvbWljX3Nl dF9mYl9mb3JfcGxhbmUgW2RybV1dIFNldCBbRkI6MzVdIAo+Pj4gZm9yIHBsYW5lCj4+PiBzdGF0 ZSAwMDAwMDAwMDZiZDUwNTgwCj4+PiBbwqDCoCAxOC45Nzg5OTNdIFtkcm06ZHJtX2F0b21pY19z ZXRfbW9kZV9wcm9wX2Zvcl9jcnRjIFtkcm1dXSBTZXQKPj4+IFtNT0RFOjEwMjR4NzY4XSBmb3Ig Q1JUQyBzdGF0ZSAwMDAwMDAwMGU1YTI4ZjZhCj4+PiBbwqDCoCAxOC45Nzk0MjVdIFtkcm06ZHJt X2F0b21pY19jaGVja19vbmx5IFtkcm1dXSBjaGVja2luZyAKPj4+IDAwMDAwMDAwMGJjMjI0ZTcK Pj4+IFvCoMKgIDE4Ljk3OTU0MF0gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9jaGVja19tb2Rlc2V0 IFtkcm1fa21zX2hlbHBlcl1dCj4+PiBbQ1JUQzozMDpjcnRjLTBdIG1vZGUgY2hhbmdlZAo+Pj4g W8KgwqAgMTguOTc5NjMyXSBbZHJtOmRybV9hdG9taWNfaGVscGVyX2NoZWNrX21vZGVzZXQgW2Ry bV9rbXNfaGVscGVyXV0KPj4+IFtDUlRDOjMwOmNydGMtMF0gZW5hYmxlIGNoYW5nZWQKPj4+IFvC oMKgIDE4Ljk3OTcwOF0gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9jaGVja19tb2Rlc2V0IFtkcm1f a21zX2hlbHBlcl1dCj4+PiBbQ1JUQzozMDpjcnRjLTBdIGFjdGl2ZSBjaGFuZ2VkCj4+PiBbwqDC oCAxOC45Nzk3OTJdIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9kZXNldCBbZHJtX2tt c19oZWxwZXJdXQo+Pj4gVXBkYXRpbmcgcm91dGluZyBmb3IgW0NPTk5FQ1RPUjoyODpWaXJ0dWFs LTFdCj4+PiBbwqDCoCAxOC45Nzk4NzddIFtkcm06ZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9k ZXNldCBbZHJtX2ttc19oZWxwZXJdXQo+Pj4gW0NPTk5FQ1RPUjoyODpWaXJ0dWFsLTFdIHVzaW5n IFtFTkNPREVSOjMxOk5vbmUtMzFdIG9uIFtDUlRDOjMwOmNydGMtMF0KPj4+IFvCoMKgIDE4Ljk3 OTk2MF0gW2RybTpkcm1fYXRvbWljX2hlbHBlcl9jaGVja19tb2Rlc2V0IFtkcm1fa21zX2hlbHBl cl1dCj4+PiBbQ1JUQzozMDpjcnRjLTBdIG5lZWRzIGFsbCBjb25uZWN0b3JzLCBlbmFibGU6IHks IGFjdGl2ZTogeQo+Pj4gW8KgwqAgMTguOTgwMTM5XSBbZHJtOmRybV9hdG9taWNfYWRkX2FmZmVj dGVkX2Nvbm5lY3RvcnMgW2RybV1dIEFkZGluZyAKPj4+IGFsbAo+Pj4gY3VycmVudCBjb25uZWN0 b3JzIGZvciBbQ1JUQzozMDpjcnRjLTBdIHRvIDAwMDAwMDAwMGJjMjI0ZTcKPj4+IFvCoMKgIDE4 Ljk4MDE4NF0gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IHBsYW5lX3N0YXRlLT52 aXNpYmxlIDAKPj4+IGNydGNfc3RhdGUgMDAwMDAwMDBlNWEyOGY2YQo+Pj4gW8KgwqAgMTguOTgw MjA1XSBjcnRjX3N0YXRlLT5lbmFibGUgMQo+Pj4KPj4+ICpbwqDCoCAxOS4wMjI2MDhdIFdBUk5J Tkc6IENQVTogMSBQSUQ6IDIxMDUgYXQKPj4+IGRyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2tt c19oZWxwZXIuYzoxMzcKPj4+IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjaysweGRj LzB4ZjggW2RybV9rbXNfaGVscGVyXSoKPj4+Cj4+PiBbLi4uXQo+Pj4KPj4+IFvCoMKgIDE5LjEx MzYwMV0gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IHBsYW5lX3N0YXRlLT52aXNp YmxlIDAKPj4+IGNydGNfc3RhdGUgMDAwMDAwMDBlNWEyOGY2YQo+Pj4gW8KgwqAgMTkuMTEzNjIz XSBjcnRjX3N0YXRlLT5lbmFibGUgMQo+Pj4gW8KgwqAgMTkuMTEzNzkyXSBXQVJOSU5HOiBDUFU6 IDEgUElEOiAyMTA1IGF0Cj4+PiBkcml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVy LmM6MTM3Cj4+PiBkcm1fc2ltcGxlX2ttc19wbGFuZV9hdG9taWNfY2hlY2srMHhkYy8weGY4IFtk cm1fa21zX2hlbHBlcl0KPj4+Cj4+PiBbLi4uXQo+Pj4KPj4+IEFuZCBmaW5hbGx5Cj4+Pgo+Pj4g W8KgwqAgMTkuMzQwMjQ5XSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gcGxhbmVf c3RhdGUtPnZpc2libGUgMAo+Pj4gY3J0Y19zdGF0ZSAwMDAwMDAwMDM2YTFiMWY1Cj4+PiBbwqDC oCAxOS4zNDAyNzFdIGNydGNfc3RhdGUtPmVuYWJsZSAwCj4+Pgo+Pj4gU28sIGl0IHNlZW1zIHRo YXQgY3J0Y19zdGF0ZSBjYW4gc3RpbGwgYmUgTlVMTCBpZiAKPj4+ICIhcGxhbmVfc3RhdGUtPnZp c2libGUiCj4+PiBtYWtpbmcKPj4+IE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSwgc28gd2UgbmVl ZCBhIGNoZWNrIGZvciB0aGF0Lgo+Pj4gWWV0LCAhcGxhbmVfc3RhdGUtPnZpc2libGUgJiYgY3J0 Y19zdGF0ZS0+ZW5hYmxlIG1ha2VzIFdBUk5fT04gdG8gZmlyZQo+Pj4gYWx3YXlzLiBTbywgcHJv YmFibHkgd2UgbWF5IHdhbnQgcmVtb3ZpbmcgaXQuCj4+Pj4gVGhhbmtzLCBEYW5pZWwKPj4+IFRo YW5rIHlvdSwKPj4+IE9sZWtzYW5kcgo+Pj4gwqBGcm9tIGRiY2NlNzA4YjIzNzc0MDE1OGEyYzE2 MDI5YzU2YTU3OTMyNGYyNjkgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCj4+PiBGcm9tOiBPbGVr c2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Cj4+ PiBEYXRlOiBUdWUsIDEzIEZlYiAyMDE4IDEwOjMyOjIwICswMjAwCj4+PiBTdWJqZWN0OiBbUEFU Q0hdIGRybS9zaW1wbGVfa21zX2hlbHBlcjogRml4IE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSAK Pj4+IHdpdGggbm8KPj4+IMKgIGFjdGl2ZSBDUlRDCj4+Pgo+Pj4gSXQgaXMgcG9zc2libGUgdGhh dCBkcm1fc2ltcGxlX2ttc19wbGFuZV9hdG9taWNfY2hlY2sgY2FsbGVkCj4+PiB3aXRoIG5vIENS VEMgc2V0LCBlLmcuIHdoZW4gdXNlci1zcGFjZSBhcHBsaWNhdGlvbiBzZXRzIENSVENfSUQvRkJf SUQKPj4+IHRvIDAgYmVmb3JlIGRvaW5nIGFueSBhY3R1YWwgZHJhd2luZy4gVGhpcyBsZWFkcyB0 byBOVUxMIHBvaW50ZXIKPj4+IGRlcmVmZXJlbmNlIGJlY2F1c2UgaW4gdGhpcyBjYXNlIG5ldyBD UlRDIHN0YXRlIGlzIE5VTEwgYW5kIG11c3QgYmUKPj4+IGNoZWNrZWQgYmVmb3JlIGFjY2Vzc2lu Zy4KPj4+Cj4+PiBTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyAKPj4+IDxv bGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KPj4+IC0tLQo+Pj4gwqAgZHJpdmVycy9n cHUvZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5jIHwgMTUgKysrKysrKy0tLS0tLS0tCj4+PiDC oCAxIGZpbGUgY2hhbmdlZCwgNyBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQo+Pj4KPj4+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMgCj4+ PiBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuYwo+Pj4gaW5kZXggOWNh OGE0YTU5Yjc0Li5mNTQ3MTFmZjk3NjcgMTAwNjQ0Cj4+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v ZHJtX3NpbXBsZV9rbXNfaGVscGVyLmMKPj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2lt cGxlX2ttc19oZWxwZXIuYwo+Pj4gQEAgLTEyMSwxMiArMTIxLDYgQEAgc3RhdGljIGludCAKPj4+ IGRybV9zaW1wbGVfa21zX3BsYW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFu ZSwKPj4+IMKgwqDCoMKgwqAgcGlwZSA9IGNvbnRhaW5lcl9vZihwbGFuZSwgc3RydWN0IGRybV9z aW1wbGVfZGlzcGxheV9waXBlLCAKPj4+IHBsYW5lKTsKPj4+IMKgwqDCoMKgwqAgY3J0Y19zdGF0 ZSA9IGRybV9hdG9taWNfZ2V0X25ld19jcnRjX3N0YXRlKHBsYW5lX3N0YXRlLT5zdGF0ZSwKPj4+ IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg ICZwaXBlLT5jcnRjKTsKPj4+IC3CoMKgwqAgaWYgKCFjcnRjX3N0YXRlLT5lbmFibGUpCj4+PiAt wqDCoMKgwqDCoMKgwqAgcmV0dXJuIDA7IC8qIG5vdGhpbmcgdG8gY2hlY2sgd2hlbiBkaXNhYmxp bmcgb3IgZGlzYWJsZWQgKi8KPj4+IC0KPj4+IC3CoMKgwqAgaWYgKGNydGNfc3RhdGUtPmVuYWJs ZSkKPj4+IC3CoMKgwqDCoMKgwqDCoCBkcm1fbW9kZV9nZXRfaHZfdGltaW5nKCZjcnRjX3N0YXRl LT5tb2RlLAo+Pj4gLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg ICZjbGlwLngyLCAmY2xpcC55Mik7Cj4+PiDCoCDCoMKgwqDCoMKgIHJldCA9IGRybV9hdG9taWNf aGVscGVyX2NoZWNrX3BsYW5lX3N0YXRlKHBsYW5lX3N0YXRlLCAKPj4+IGNydGNfc3RhdGUsCj4+ PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg JmNsaXAsCj4+PiBAQCAtMTM2LDggKzEzMCwxMyBAQCBzdGF0aWMgaW50IAo+Pj4gZHJtX3NpbXBs ZV9rbXNfcGxhbmVfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+Pj4gwqDC oMKgwqDCoCBpZiAocmV0KQo+Pj4gwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiByZXQ7Cj4+PiDC oCAtwqDCoMKgIGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpCj4+PiAtwqDCoMKgwqDCoMKgwqAg cmV0dXJuIC1FSU5WQUw7Cj4+PiArwqDCoMKgIGlmICghcGxhbmVfc3RhdGUtPnZpc2libGUpIHsK Pj4+ICvCoMKgwqDCoMKgwqDCoCBpZiAoY3J0Y19zdGF0ZSkKPj4+ICvCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIFdBUk5fT04oY3J0Y19zdGF0ZS0+ZW5hYmxlKTsKPj4+ICvCoMKgwqDCoMKgwqDCoCBy ZXR1cm4gMDsKPj4+ICvCoMKgwqAgfQo+Pj4gKwo+Pj4gK8KgwqDCoCBkcm1fbW9kZV9nZXRfaHZf dGltaW5nKCZjcnRjX3N0YXRlLT5tb2RlLCAmY2xpcC54MiwgJmNsaXAueTIpOwo+PiBsZ3RtLiBX aXRoIG9yIHdpdGhvdXQgdGhlIGJpa2VzaGVkIHRvIHB1bGwgdGhlIGNydGNfc3RhdGUgY2hlY2sg aW50byB0aGUKPj4gV0FSTl9PTi4KPj4KPj4gUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+Cj4gVGhhbmsgeW91Cj4+Cj4+IFBsZWFzZSByZXN1Ym1pdCBh cyBhIHN0YW5kLWFsb25lIHBhdGNoLCBwYXRjaHdvcmsgY2FuJ3QgcHVsbCBwYXRjaGVzIG91dAo+ PiBvZiBhdHRhY2htZW50cyA6LS8KPiBvaCwgdGhhdCB3YXMgZm9yIGRlbW9uc3RyYXRpb24gcHVy cG9zZSBvbmx5LCBzbyB3ZQo+IGFyZSBvbiB0aGUgc2FtZSBwYWdlIGFuZCBzZWUgdGhlIHBhdGNo IHdlIGFyZSBkaXNjdXNzaW5nIDspCj4+IC1EYW5pZWwKPj4KPj4+IMKgIMKgwqDCoMKgwqAgaWYg KCFwaXBlLT5mdW5jcyB8fCAhcGlwZS0+ZnVuY3MtPmNoZWNrKQo+Pj4gwqDCoMKgwqDCoMKgwqDC oMKgIHJldHVybiAwOwo+Pj4gLS0gCj4+PiAyLjcuNAo+Pj4KPj4+IF9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4+PiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0 Cj4+PiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4+PiBodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo+Pgo+CgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK