From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A0884C433F5 for ; Tue, 19 Apr 2022 06:37:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241450AbiDSGkV (ORCPT ); Tue, 19 Apr 2022 02:40:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:51908 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239584AbiDSGkS (ORCPT ); Tue, 19 Apr 2022 02:40:18 -0400 Received: from mail-lf1-x129.google.com (mail-lf1-x129.google.com [IPv6:2a00:1450:4864:20::129]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 029662E9E1 for ; Mon, 18 Apr 2022 23:37:36 -0700 (PDT) Received: by mail-lf1-x129.google.com with SMTP id bq30so27674937lfb.3 for ; Mon, 18 Apr 2022 23:37:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=5XKHbxSoKgLV4l6KLfHSllkOSuhO/yQcH7URIe/RXvI=; b=BYPkS0mpRwyVL9+QysC/keXryrD+pxuYOK+l6BJJIivxNikhJ0VtOVqV0+B0uiYhaL DjZ23GRUAgibnxdNIYb+7rrBrziMLsMzetdRhrLEVUeEoQQrNLNYHbscuspqA1h/nqmj 6M48Lcp3KfrE1wn39oOaq5AA0prsFcogF73dVS8jB3fLuFfhoI040zgnqPgm3giiysBx 1yVaxxA5Dic0aV4U5zVVFA/g2Sx6Me5dYB4w5CpojlKhQwWaF2nLmKspLwI7WeV3yXms kHxkI4gz+mi4riP69GlEkJdFijXXH8B+xc8x3GERO8+4CKKcLBqxOHAbnZeJriADnkHn Sn5Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=5XKHbxSoKgLV4l6KLfHSllkOSuhO/yQcH7URIe/RXvI=; b=j2dNRpriv167/AifMV/krzNoHAUwjzL/tadbWWEylHH1KJs5CtXkCRfwhRsh3sHwmp vtftPoeSfrL2VPH7LN0RIv2mppZya9ujTwucmX4HtF9Zba0xf3+OrYFhRGVRO2OV6yAx XTkP3LW3EY4H/cfo+f99kbLUhM29bphzt6zTW/VBLnmF01MqSOvpLBcOqXasLDmDK0DI 1Oi3Q6oH3h1gs9T7ik3EwQfKMsN48M+/fhx6KVt5fRuuNw7OoPf7HM0LC+SzKcBdnwHH clNV+qrZ3VFJHrigEI+IIczOEu/HGqeK8XF/aMJ4FUcfrOwqYP5h/BoJURoNZ5WI8dqP asHA== X-Gm-Message-State: AOAM5306x1yFk8MM2u1ipZX8rJoDqIw1TGcAzFrEWT9XSURuZACePX1i BxwJW1N3k8SCyTy5i53Nwiw= X-Google-Smtp-Source: ABdhPJx0KZwoC2ACm+X1wAjeDTfX3UjujeGdQe8hMMbvoAvvFDS4CUtPuCSHarytJl83njjUXCAAng== X-Received: by 2002:a05:6512:23a8:b0:470:77ac:64b1 with SMTP id c40-20020a05651223a800b0047077ac64b1mr9346732lfv.322.1650350253959; Mon, 18 Apr 2022 23:37:33 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id b15-20020ac2562f000000b004437f2667bfsm1418167lff.308.2022.04.18.23.37.32 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Apr 2022 23:37:33 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: Juergen Gross , Stefano Stabellini Cc: xen-devel@lists.xenproject.org, x86@kernel.org, linux-kernel@vger.kernel.org, Dave Hansen , Andy Lutomirski , Peter Zijlstra , Thomas Gleixner , Ingo Molnar , Borislav Petkov , "H. Peter Anvin" , Boris Ostrovsky , Julien Grall , Oleksandr Tyshchenko , linux-arm-kernel@lists.infradead.org, Christoph Hellwig , "Michael S. Tsirkin" References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> <8a66ad42-a3e7-c29d-7d4e-35766dcccd15@gmail.com> From: Oleksandr Message-ID: <5b6f8f1c-1ffd-9582-89b4-54f73ec4f5c4@gmail.com> Date: Tue, 19 Apr 2022 09:37:32 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hello Stefano, Juergen On 19.04.22 09:21, Juergen Gross wrote: > On 18.04.22 21:11, Stefano Stabellini wrote: >> On Sun, 17 Apr 2022, Oleksandr wrote: >>> On 16.04.22 01:01, Stefano Stabellini wrote: >>>> On Thu, 14 Apr 2022, Oleksandr Tyshchenko wrote: >>>>> From: Juergen Gross >>>>> >>>>> In order to support virtio in Xen guests add a config option enabling >>>>> the user to specify whether in all Xen guests virtio should be >>>>> able to >>>>> access memory via Xen grant mappings only on the host side. >>>>> >>>>> This applies to fully virtualized guests only, as for paravirtualized >>>>> guests this is mandatory. >>>>> >>>>> This requires to switch arch_has_restricted_virtio_memory_access() >>>>> from a pure stub to a real function on x86 systems (Arm systems are >>>>> not covered by now). >>>>> >>>>> Add the needed functionality by providing a special set of DMA ops >>>>> handling the needed grant operations for the I/O pages. >>>>> >>>>> Signed-off-by: Juergen Gross >>>>> --- >>>>>    arch/x86/mm/init.c        |  15 ++++ >>>>>    arch/x86/mm/mem_encrypt.c |   5 -- >>>>>    arch/x86/xen/Kconfig      |   9 +++ >>>>>    drivers/xen/Kconfig       |  20 ++++++ >>>>>    drivers/xen/Makefile      |   1 + >>>>>    drivers/xen/xen-virtio.c  | 177 >>>>> ++++++++++++++++++++++++++++++++++++++++++++++ >>>>>    include/xen/xen-ops.h     |   8 +++ >>>>>    7 files changed, 230 insertions(+), 5 deletions(-) >>>>>    create mode 100644 drivers/xen/xen-virtio.c >>>>> >>>>> diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c >>>>> index d8cfce2..526a3b2 100644 >>>>> --- a/arch/x86/mm/init.c >>>>> +++ b/arch/x86/mm/init.c >>>>> @@ -8,6 +8,8 @@ >>>>>    #include >>>>>    #include >>>>>    +#include >>>>> + >>>>>    #include >>>>>    #include >>>>>    #include >>>>> @@ -1065,3 +1067,16 @@ unsigned long max_swapfile_size(void) >>>>>        return pages; >>>>>    } >>>>>    #endif >>>>> + >>>>> +#ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >>>>> +int arch_has_restricted_virtio_memory_access(void) >>>>> +{ >>>>> +    if (IS_ENABLED(CONFIG_XEN_PV_VIRTIO) && xen_pv_domain()) >>>>> +        return 1; >>>>> +    if (IS_ENABLED(CONFIG_XEN_HVM_VIRTIO_GRANT) && xen_hvm_domain()) >>>>> +        return 1; >>>> I think these two checks could be moved to a separate function in a >>>> Xen >>>> header, e.g. xen_restricted_virtio_memory_access, and here you could >>>> just >>>> >>>> if (xen_restricted_virtio_memory_access()) >>>>       return 1; >>> >>> Agree, will do >>> >>> >>>> >>>> >>>> >>>>> +    return cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT); >>>>> +} >>>>> +EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); >>>>> +#endif >>>>> diff --git a/arch/x86/mm/mem_encrypt.c b/arch/x86/mm/mem_encrypt.c >>>>> index 50d2099..dda020f 100644 >>>>> --- a/arch/x86/mm/mem_encrypt.c >>>>> +++ b/arch/x86/mm/mem_encrypt.c >>>>> @@ -77,8 +77,3 @@ void __init mem_encrypt_init(void) >>>>>        print_mem_encrypt_feature_info(); >>>>>    } >>>>>    -int arch_has_restricted_virtio_memory_access(void) >>>>> -{ >>>>> -    return cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT); >>>>> -} >>>>> -EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); >>>>> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig >>>>> index 85246dd..dffdffd 100644 >>>>> --- a/arch/x86/xen/Kconfig >>>>> +++ b/arch/x86/xen/Kconfig >>>>> @@ -92,3 +92,12 @@ config XEN_DOM0 >>>>>        select X86_X2APIC if XEN_PVH && X86_64 >>>>>        help >>>>>          Support running as a Xen Dom0 guest. >>>>> + >>>>> +config XEN_PV_VIRTIO >>>>> +    bool "Xen virtio support for PV guests" >>>>> +    depends on XEN_VIRTIO && XEN_PV >>>>> +    default y >>>>> +    help >>>>> +      Support virtio for running as a paravirtualized guest. This >>>>> will >>>>> +      need support on the backend side (qemu or kernel, depending >>>>> on the >>>>> +      virtio device types used). >>>>> diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig >>>>> index 120d32f..fc61f7a 100644 >>>>> --- a/drivers/xen/Kconfig >>>>> +++ b/drivers/xen/Kconfig >>>>> @@ -335,4 +335,24 @@ config XEN_UNPOPULATED_ALLOC >>>>>          having to balloon out RAM regions in order to obtain >>>>> physical memory >>>>>          space to create such mappings. >>>>>    +config XEN_VIRTIO >>>>> +    bool "Xen virtio support" >>>>> +    default n >>>>> +    depends on VIRTIO && DMA_OPS >>>>> +    select ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >>>>> +    help >>>>> +      Enable virtio support for running as Xen guest. Depending >>>>> on the >>>>> +      guest type this will require special support on the backend >>>>> side >>>>> +      (qemu or kernel, depending on the virtio device types used). >>>>> + >>>>> +config XEN_HVM_VIRTIO_GRANT >>>>> +    bool "Require virtio for fully virtualized guests to use grant >>>>> mappings" >>>>> +    depends on XEN_VIRTIO && X86_64 >>>>> +    default y >>>>> +    help >>>>> +      Require virtio for fully virtualized guests to use grant >>>>> mappings. >>>>> +      This will avoid the need to give the backend the right to >>>>> map all >>>>> +      of the guest memory. This will need support on the backend >>>>> side >>>>> +      (qemu or kernel, depending on the virtio device types used). >>>> I don't think we need 3 visible kconfig options for this. >>>> >>>> In fact, I would only add one: XEN_VIRTIO. We can have any X86 (or >>>> ARM) >>>> specific dependencies in the "depends" line under XEN_VIRTIO. And I >>>> don't think we need XEN_HVM_VIRTIO_GRANT as a kconfig option >>>> necessarely. It doesn't seem like some we want as build time >>>> option. At >>>> most, it could be a runtime option (like a command line) or a debug >>>> option (like an #define at the top of the source file.) >>> >>> >>> I don't know what was the initial idea of having and extra >>> XEN_HVM_VIRTIO and >>> XEN_PV_VIRTIO options, but taking into the account that >>> they are only used in arch_has_restricted_virtio_memory_access() >>> currently, I >>> share your opinion regarding a single XEN_VIRTIO option. >>> >>> Looking ahead (including changes in the commit #4), we can imagine the >>> resulting option: >>> >>> config XEN_VIRTIO >>>      bool "Xen virtio support" >>>      default n >>>      depends on VIRTIO && DMA_OPS >>>      depends on (X86_64 || ARM || ARM64) >>>      select ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >>>      help >>>        Enable virtio support for running as Xen guest. Depending on the >>>        guest type this will require special support on the backend side >>>        (qemu or kernel, depending on the virtio device types used). >>> >>> >>> and then arch_has_restricted_virtio_memory_access() per arch: >>> >>> >>> 1. x86: >>> >>> int arch_has_restricted_virtio_memory_access(void) >>> { >>>      return (xen_has_restricted_virtio_memory_access() || >>>              cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT)); >>> } >>> >>> >>> 2. Arm: >>> >>> int arch_has_restricted_virtio_memory_access(void) >>> { >>>      return xen_has_restricted_virtio_memory_access(); >>> } >>> >>> >>> 3. xen.h: >>> >>> static inline int xen_has_restricted_virtio_memory_access(void) >>> { >>>      if (IS_ENABLED(CONFIG_XEN_VIRTIO) && (xen_pv_domain() || >>> xen_hvm_domain())) >>>          return 1; >>> >>>      return 0; >>> } >>> >>> >>> Actually, as domain type on Arm is always XEN_HVM_DOMAIN, we could >>> probably >>> have the following on Arm: >>> >>> int arch_has_restricted_virtio_memory_access(void) >>> { >>>      return IS_ENABLED(CONFIG_XEN_VIRTIO); >>> } >>> >>> but I would prefer not to diverge and use common >>> xen_has_restricted_virtio_memory_access(). >>> >>> Any thoughts? >> >> Yes, I would also prefer not to diverge between the x86 and arm versions >> of xen_has_restricted_virtio_memory_access. But what case are we trying >> to catch with (xen_pv_domain() || xen_hvm_domain()) ? Even on x86, it is >> not going to leave much out. Is it really meant only to exclude pvh >> domains? Good question. By leaving (xen_pv_domain() || xen_hvm_domain()) here I tried to retain what the *initial* version of arch_has_restricted_virtio_memory_access() covered. > > It wouldn't exclude pvh domains. ok > >> >> I have the feeling that we could turn this check into: >> >> static inline int xen_has_restricted_virtio_memory_access(void) >> { >>      return IS_ENABLED(CONFIG_XEN_VIRTIO) && xen_domain(); >> } >> >> even on x86, but one of the xen/x86 maintainers should confirm. > > I do confirm this is better and functionally equivalent. Perfect, thank you for confirming. Will use that check. > > > Juergen -- Regards, Oleksandr Tyshchenko From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 26AA2C433F5 for ; Tue, 19 Apr 2022 06:38:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:Cc:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=xvAoIRTe/ZbjeEMJyzB28FGPszcdtzA4kKOewmqtPyo=; b=CdhJ0GsivW6cMCiq0x96/hoY5p /U1TobA47e96fsWsmrPNChpqa/7HUUVLMZo3UiAZWAJ9e+yQfaioactBw9vcchp2LJ7i8CDZ2bMpJ nxdtgVG+Y/jzzIrvdVXmWUble6aCw8GiYIuAIlVQQYKFtgQvrWug9bXOIFovo+7ko/vrWZkNgilW+ 1bdCpTHowVKkNgi+524RTpFvQqQwSqAmI3lsvog5hk+YMZsQVlJu2pUxts94SOHg902soA5xblTQX hYu0Gnp/hINTHFOMQvHOGRHz2u6tAP0opPohvJaJLqodPRysaqmNe6kSZzw1PlY1A21TGkyLiWLtu Aj6uhh8Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nghUg-001j9l-1K; Tue, 19 Apr 2022 06:37:46 +0000 Received: from mail-lf1-x12e.google.com ([2a00:1450:4864:20::12e]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nghUY-001j68-3g for linux-arm-kernel@lists.infradead.org; Tue, 19 Apr 2022 06:37:40 +0000 Received: by mail-lf1-x12e.google.com with SMTP id bu29so27732206lfb.0 for ; Mon, 18 Apr 2022 23:37:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=5XKHbxSoKgLV4l6KLfHSllkOSuhO/yQcH7URIe/RXvI=; b=BYPkS0mpRwyVL9+QysC/keXryrD+pxuYOK+l6BJJIivxNikhJ0VtOVqV0+B0uiYhaL DjZ23GRUAgibnxdNIYb+7rrBrziMLsMzetdRhrLEVUeEoQQrNLNYHbscuspqA1h/nqmj 6M48Lcp3KfrE1wn39oOaq5AA0prsFcogF73dVS8jB3fLuFfhoI040zgnqPgm3giiysBx 1yVaxxA5Dic0aV4U5zVVFA/g2Sx6Me5dYB4w5CpojlKhQwWaF2nLmKspLwI7WeV3yXms kHxkI4gz+mi4riP69GlEkJdFijXXH8B+xc8x3GERO8+4CKKcLBqxOHAbnZeJriADnkHn Sn5Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=5XKHbxSoKgLV4l6KLfHSllkOSuhO/yQcH7URIe/RXvI=; b=SKN9Pwz7si3dP9QYjtJjt2XOR2h1ssbELc4PoVn+TA4U5HAOxw1EbMfv//pqi6z7ol 5TPbdYT66HezhsePu+o7y34RDhmeDTwlhG8yrjpVLPY3Ro9l6T5ly55NHjLMB1qhQpeA JoFqjalkQjqchthfhKfc+BFHo4+SKWFeBTfGylesQyRdA/k6pjos0y+htqSvsGkSwY8v SfkttgednsvjEaUNmWNL5ESYgzKqOxMBh+xwzkbGa+KlGT9wT9mdKQgY3X7E0ujCHE23 GkJzwwp++i/InBoHJJ37m19xVNwq9DNZZFv4Gze9xW2rKBDZHgRkOlkLQTRMPYXS7XGs x4rQ== X-Gm-Message-State: AOAM530E6WJwB3Vs9EMNXhIB4VvK01P5sezun/xsU+UgUB7i0Xf/eQR9 XJCT+jF2w/YTV084v/O+MaI= X-Google-Smtp-Source: ABdhPJx0KZwoC2ACm+X1wAjeDTfX3UjujeGdQe8hMMbvoAvvFDS4CUtPuCSHarytJl83njjUXCAAng== X-Received: by 2002:a05:6512:23a8:b0:470:77ac:64b1 with SMTP id c40-20020a05651223a800b0047077ac64b1mr9346732lfv.322.1650350253959; Mon, 18 Apr 2022 23:37:33 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id b15-20020ac2562f000000b004437f2667bfsm1418167lff.308.2022.04.18.23.37.32 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Apr 2022 23:37:33 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: Juergen Gross , Stefano Stabellini Cc: xen-devel@lists.xenproject.org, x86@kernel.org, linux-kernel@vger.kernel.org, Dave Hansen , Andy Lutomirski , Peter Zijlstra , Thomas Gleixner , Ingo Molnar , Borislav Petkov , "H. Peter Anvin" , Boris Ostrovsky , Julien Grall , Oleksandr Tyshchenko , linux-arm-kernel@lists.infradead.org, Christoph Hellwig , "Michael S. Tsirkin" References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> <8a66ad42-a3e7-c29d-7d4e-35766dcccd15@gmail.com> From: Oleksandr Message-ID: <5b6f8f1c-1ffd-9582-89b4-54f73ec4f5c4@gmail.com> Date: Tue, 19 Apr 2022 09:37:32 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220418_233738_203470_8DFC6B13 X-CRM114-Status: GOOD ( 33.92 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org CkhlbGxvIFN0ZWZhbm8sIEp1ZXJnZW4KCgpPbiAxOS4wNC4yMiAwOToyMSwgSnVlcmdlbiBHcm9z cyB3cm90ZToKPiBPbiAxOC4wNC4yMiAyMToxMSwgU3RlZmFubyBTdGFiZWxsaW5pIHdyb3RlOgo+ PiBPbiBTdW4sIDE3IEFwciAyMDIyLCBPbGVrc2FuZHIgd3JvdGU6Cj4+PiBPbiAxNi4wNC4yMiAw MTowMSwgU3RlZmFubyBTdGFiZWxsaW5pIHdyb3RlOgo+Pj4+IE9uIFRodSwgMTQgQXByIDIwMjIs IE9sZWtzYW5kciBUeXNoY2hlbmtvIHdyb3RlOgo+Pj4+PiBGcm9tOiBKdWVyZ2VuIEdyb3NzIDxq Z3Jvc3NAc3VzZS5jb20+Cj4+Pj4+Cj4+Pj4+IEluIG9yZGVyIHRvIHN1cHBvcnQgdmlydGlvIGlu IFhlbiBndWVzdHMgYWRkIGEgY29uZmlnIG9wdGlvbiBlbmFibGluZwo+Pj4+PiB0aGUgdXNlciB0 byBzcGVjaWZ5IHdoZXRoZXIgaW4gYWxsIFhlbiBndWVzdHMgdmlydGlvIHNob3VsZCBiZSAKPj4+ Pj4gYWJsZSB0bwo+Pj4+PiBhY2Nlc3MgbWVtb3J5IHZpYSBYZW4gZ3JhbnQgbWFwcGluZ3Mgb25s eSBvbiB0aGUgaG9zdCBzaWRlLgo+Pj4+Pgo+Pj4+PiBUaGlzIGFwcGxpZXMgdG8gZnVsbHkgdmly dHVhbGl6ZWQgZ3Vlc3RzIG9ubHksIGFzIGZvciBwYXJhdmlydHVhbGl6ZWQKPj4+Pj4gZ3Vlc3Rz IHRoaXMgaXMgbWFuZGF0b3J5Lgo+Pj4+Pgo+Pj4+PiBUaGlzIHJlcXVpcmVzIHRvIHN3aXRjaCBh cmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKCkKPj4+Pj4gZnJvbSBhIHB1 cmUgc3R1YiB0byBhIHJlYWwgZnVuY3Rpb24gb24geDg2IHN5c3RlbXMgKEFybSBzeXN0ZW1zIGFy ZQo+Pj4+PiBub3QgY292ZXJlZCBieSBub3cpLgo+Pj4+Pgo+Pj4+PiBBZGQgdGhlIG5lZWRlZCBm dW5jdGlvbmFsaXR5IGJ5IHByb3ZpZGluZyBhIHNwZWNpYWwgc2V0IG9mIERNQSBvcHMKPj4+Pj4g aGFuZGxpbmcgdGhlIG5lZWRlZCBncmFudCBvcGVyYXRpb25zIGZvciB0aGUgSS9PIHBhZ2VzLgo+ Pj4+Pgo+Pj4+PiBTaWduZWQtb2ZmLWJ5OiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+ Cj4+Pj4+IC0tLQo+Pj4+PiDCoMKgIGFyY2gveDg2L21tL2luaXQuY8KgwqDCoMKgwqDCoMKgIHzC oCAxNSArKysrCj4+Pj4+IMKgwqAgYXJjaC94ODYvbW0vbWVtX2VuY3J5cHQuYyB8wqDCoCA1IC0t Cj4+Pj4+IMKgwqAgYXJjaC94ODYveGVuL0tjb25maWfCoMKgwqDCoMKgIHzCoMKgIDkgKysrCj4+ Pj4+IMKgwqAgZHJpdmVycy94ZW4vS2NvbmZpZ8KgwqDCoMKgwqDCoCB8wqAgMjAgKysrKysrCj4+ Pj4+IMKgwqAgZHJpdmVycy94ZW4vTWFrZWZpbGXCoMKgwqDCoMKgIHzCoMKgIDEgKwo+Pj4+PiDC oMKgIGRyaXZlcnMveGVuL3hlbi12aXJ0aW8uY8KgIHwgMTc3Cj4+Pj4+ICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPj4+Pj4gwqDCoCBpbmNsdWRlL3hlbi94 ZW4tb3BzLmjCoMKgwqDCoCB8wqDCoCA4ICsrKwo+Pj4+PiDCoMKgIDcgZmlsZXMgY2hhbmdlZCwg MjMwIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4+Pj4+IMKgwqAgY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMveGVuL3hlbi12aXJ0aW8uYwo+Pj4+Pgo+Pj4+PiBkaWZmIC0tZ2l0IGEv YXJjaC94ODYvbW0vaW5pdC5jIGIvYXJjaC94ODYvbW0vaW5pdC5jCj4+Pj4+IGluZGV4IGQ4Y2Zj ZTIuLjUyNmEzYjIgMTAwNjQ0Cj4+Pj4+IC0tLSBhL2FyY2gveDg2L21tL2luaXQuYwo+Pj4+PiAr KysgYi9hcmNoL3g4Ni9tbS9pbml0LmMKPj4+Pj4gQEAgLTgsNiArOCw4IEBACj4+Pj4+IMKgwqAg I2luY2x1ZGUgPGxpbnV4L2ttZW1sZWFrLmg+Cj4+Pj4+IMKgwqAgI2luY2x1ZGUgPGxpbnV4L3Nj aGVkL3Rhc2suaD4KPj4+Pj4gwqDCoCArI2luY2x1ZGUgPHhlbi94ZW4uaD4KPj4+Pj4gKwo+Pj4+ PiDCoMKgICNpbmNsdWRlIDxhc20vc2V0X21lbW9yeS5oPgo+Pj4+PiDCoMKgICNpbmNsdWRlIDxh c20vZTgyMC9hcGkuaD4KPj4+Pj4gwqDCoCAjaW5jbHVkZSA8YXNtL2luaXQuaD4KPj4+Pj4gQEAg LTEwNjUsMyArMTA2NywxNiBAQCB1bnNpZ25lZCBsb25nIG1heF9zd2FwZmlsZV9zaXplKHZvaWQp Cj4+Pj4+IMKgwqDCoMKgwqDCoCByZXR1cm4gcGFnZXM7Cj4+Pj4+IMKgwqAgfQo+Pj4+PiDCoMKg ICNlbmRpZgo+Pj4+PiArCj4+Pj4+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1JFU1RSSUNURURf VklSVElPX01FTU9SWV9BQ0NFU1MKPj4+Pj4gK2ludCBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRp b19tZW1vcnlfYWNjZXNzKHZvaWQpCj4+Pj4+ICt7Cj4+Pj4+ICvCoMKgwqAgaWYgKElTX0VOQUJM RUQoQ09ORklHX1hFTl9QVl9WSVJUSU8pICYmIHhlbl9wdl9kb21haW4oKSkKPj4+Pj4gK8KgwqDC oMKgwqDCoMKgIHJldHVybiAxOwo+Pj4+PiArwqDCoMKgIGlmIChJU19FTkFCTEVEKENPTkZJR19Y RU5fSFZNX1ZJUlRJT19HUkFOVCkgJiYgeGVuX2h2bV9kb21haW4oKSkKPj4+Pj4gK8KgwqDCoMKg wqDCoMKgIHJldHVybiAxOwo+Pj4+IEkgdGhpbmsgdGhlc2UgdHdvIGNoZWNrcyBjb3VsZCBiZSBt b3ZlZCB0byBhIHNlcGFyYXRlIGZ1bmN0aW9uIGluIGEgCj4+Pj4gWGVuCj4+Pj4gaGVhZGVyLCBl LmcuIHhlbl9yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzLCBhbmQgaGVyZSB5b3UgY291 bGQKPj4+PiBqdXN0Cj4+Pj4KPj4+PiBpZiAoeGVuX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9h Y2Nlc3MoKSkKPj4+PiDCoMKgwqDCoMKgIHJldHVybiAxOwo+Pj4KPj4+IEFncmVlLCB3aWxsIGRv Cj4+Pgo+Pj4KPj4+Pgo+Pj4+Cj4+Pj4KPj4+Pj4gK8KgwqDCoCByZXR1cm4gY2NfcGxhdGZvcm1f aGFzKENDX0FUVFJfR1VFU1RfTUVNX0VOQ1JZUFQpOwo+Pj4+PiArfQo+Pj4+PiArRVhQT1JUX1NZ TUJPTF9HUEwoYXJjaF9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyk7Cj4+Pj4+ ICsjZW5kaWYKPj4+Pj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL21lbV9lbmNyeXB0LmMgYi9h cmNoL3g4Ni9tbS9tZW1fZW5jcnlwdC5jCj4+Pj4+IGluZGV4IDUwZDIwOTkuLmRkYTAyMGYgMTAw NjQ0Cj4+Pj4+IC0tLSBhL2FyY2gveDg2L21tL21lbV9lbmNyeXB0LmMKPj4+Pj4gKysrIGIvYXJj aC94ODYvbW0vbWVtX2VuY3J5cHQuYwo+Pj4+PiBAQCAtNzcsOCArNzcsMyBAQCB2b2lkIF9faW5p dCBtZW1fZW5jcnlwdF9pbml0KHZvaWQpCj4+Pj4+IMKgwqDCoMKgwqDCoCBwcmludF9tZW1fZW5j cnlwdF9mZWF0dXJlX2luZm8oKTsKPj4+Pj4gwqDCoCB9Cj4+Pj4+IMKgwqAgLWludCBhcmNoX2hh c19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKHZvaWQpCj4+Pj4+IC17Cj4+Pj4+IC3C oMKgwqAgcmV0dXJuIGNjX3BsYXRmb3JtX2hhcyhDQ19BVFRSX0dVRVNUX01FTV9FTkNSWVBUKTsK Pj4+Pj4gLX0KPj4+Pj4gLUVYUE9SVF9TWU1CT0xfR1BMKGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmly dGlvX21lbW9yeV9hY2Nlc3MpOwo+Pj4+PiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYveGVuL0tjb25m aWcgYi9hcmNoL3g4Ni94ZW4vS2NvbmZpZwo+Pj4+PiBpbmRleCA4NTI0NmRkLi5kZmZkZmZkIDEw MDY0NAo+Pj4+PiAtLS0gYS9hcmNoL3g4Ni94ZW4vS2NvbmZpZwo+Pj4+PiArKysgYi9hcmNoL3g4 Ni94ZW4vS2NvbmZpZwo+Pj4+PiBAQCAtOTIsMyArOTIsMTIgQEAgY29uZmlnIFhFTl9ET00wCj4+ Pj4+IMKgwqDCoMKgwqDCoCBzZWxlY3QgWDg2X1gyQVBJQyBpZiBYRU5fUFZIICYmIFg4Nl82NAo+ Pj4+PiDCoMKgwqDCoMKgwqAgaGVscAo+Pj4+PiDCoMKgwqDCoMKgwqDCoMKgIFN1cHBvcnQgcnVu bmluZyBhcyBhIFhlbiBEb20wIGd1ZXN0Lgo+Pj4+PiArCj4+Pj4+ICtjb25maWcgWEVOX1BWX1ZJ UlRJTwo+Pj4+PiArwqDCoMKgIGJvb2wgIlhlbiB2aXJ0aW8gc3VwcG9ydCBmb3IgUFYgZ3Vlc3Rz Igo+Pj4+PiArwqDCoMKgIGRlcGVuZHMgb24gWEVOX1ZJUlRJTyAmJiBYRU5fUFYKPj4+Pj4gK8Kg wqDCoCBkZWZhdWx0IHkKPj4+Pj4gK8KgwqDCoCBoZWxwCj4+Pj4+ICvCoMKgwqDCoMKgIFN1cHBv cnQgdmlydGlvIGZvciBydW5uaW5nIGFzIGEgcGFyYXZpcnR1YWxpemVkIGd1ZXN0LiBUaGlzIAo+ Pj4+PiB3aWxsCj4+Pj4+ICvCoMKgwqDCoMKgIG5lZWQgc3VwcG9ydCBvbiB0aGUgYmFja2VuZCBz aWRlIChxZW11IG9yIGtlcm5lbCwgZGVwZW5kaW5nIAo+Pj4+PiBvbiB0aGUKPj4+Pj4gK8KgwqDC oMKgwqAgdmlydGlvIGRldmljZSB0eXBlcyB1c2VkKS4KPj4+Pj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMveGVuL0tjb25maWcgYi9kcml2ZXJzL3hlbi9LY29uZmlnCj4+Pj4+IGluZGV4IDEyMGQzMmYu LmZjNjFmN2EgMTAwNjQ0Cj4+Pj4+IC0tLSBhL2RyaXZlcnMveGVuL0tjb25maWcKPj4+Pj4gKysr IGIvZHJpdmVycy94ZW4vS2NvbmZpZwo+Pj4+PiBAQCAtMzM1LDQgKzMzNSwyNCBAQCBjb25maWcg WEVOX1VOUE9QVUxBVEVEX0FMTE9DCj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqAgaGF2aW5nIHRvIGJh bGxvb24gb3V0IFJBTSByZWdpb25zIGluIG9yZGVyIHRvIG9idGFpbiAKPj4+Pj4gcGh5c2ljYWwg bWVtb3J5Cj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqAgc3BhY2UgdG8gY3JlYXRlIHN1Y2ggbWFwcGlu Z3MuCj4+Pj4+IMKgwqAgK2NvbmZpZyBYRU5fVklSVElPCj4+Pj4+ICvCoMKgwqAgYm9vbCAiWGVu IHZpcnRpbyBzdXBwb3J0Igo+Pj4+PiArwqDCoMKgIGRlZmF1bHQgbgo+Pj4+PiArwqDCoMKgIGRl cGVuZHMgb24gVklSVElPICYmIERNQV9PUFMKPj4+Pj4gK8KgwqDCoCBzZWxlY3QgQVJDSF9IQVNf UkVTVFJJQ1RFRF9WSVJUSU9fTUVNT1JZX0FDQ0VTUwo+Pj4+PiArwqDCoMKgIGhlbHAKPj4+Pj4g K8KgwqDCoMKgwqAgRW5hYmxlIHZpcnRpbyBzdXBwb3J0IGZvciBydW5uaW5nIGFzIFhlbiBndWVz dC4gRGVwZW5kaW5nIAo+Pj4+PiBvbiB0aGUKPj4+Pj4gK8KgwqDCoMKgwqAgZ3Vlc3QgdHlwZSB0 aGlzIHdpbGwgcmVxdWlyZSBzcGVjaWFsIHN1cHBvcnQgb24gdGhlIGJhY2tlbmQgCj4+Pj4+IHNp ZGUKPj4+Pj4gK8KgwqDCoMKgwqAgKHFlbXUgb3Iga2VybmVsLCBkZXBlbmRpbmcgb24gdGhlIHZp cnRpbyBkZXZpY2UgdHlwZXMgdXNlZCkuCj4+Pj4+ICsKPj4+Pj4gK2NvbmZpZyBYRU5fSFZNX1ZJ UlRJT19HUkFOVAo+Pj4+PiArwqDCoMKgIGJvb2wgIlJlcXVpcmUgdmlydGlvIGZvciBmdWxseSB2 aXJ0dWFsaXplZCBndWVzdHMgdG8gdXNlIGdyYW50Cj4+Pj4+IG1hcHBpbmdzIgo+Pj4+PiArwqDC oMKgIGRlcGVuZHMgb24gWEVOX1ZJUlRJTyAmJiBYODZfNjQKPj4+Pj4gK8KgwqDCoCBkZWZhdWx0 IHkKPj4+Pj4gK8KgwqDCoCBoZWxwCj4+Pj4+ICvCoMKgwqDCoMKgIFJlcXVpcmUgdmlydGlvIGZv ciBmdWxseSB2aXJ0dWFsaXplZCBndWVzdHMgdG8gdXNlIGdyYW50IAo+Pj4+PiBtYXBwaW5ncy4K Pj4+Pj4gK8KgwqDCoMKgwqAgVGhpcyB3aWxsIGF2b2lkIHRoZSBuZWVkIHRvIGdpdmUgdGhlIGJh Y2tlbmQgdGhlIHJpZ2h0IHRvIAo+Pj4+PiBtYXAgYWxsCj4+Pj4+ICvCoMKgwqDCoMKgIG9mIHRo ZSBndWVzdCBtZW1vcnkuIFRoaXMgd2lsbCBuZWVkIHN1cHBvcnQgb24gdGhlIGJhY2tlbmQgCj4+ Pj4+IHNpZGUKPj4+Pj4gK8KgwqDCoMKgwqAgKHFlbXUgb3Iga2VybmVsLCBkZXBlbmRpbmcgb24g dGhlIHZpcnRpbyBkZXZpY2UgdHlwZXMgdXNlZCkuCj4+Pj4gSSBkb24ndCB0aGluayB3ZSBuZWVk IDMgdmlzaWJsZSBrY29uZmlnIG9wdGlvbnMgZm9yIHRoaXMuCj4+Pj4KPj4+PiBJbiBmYWN0LCBJ IHdvdWxkIG9ubHkgYWRkIG9uZTogWEVOX1ZJUlRJTy4gV2UgY2FuIGhhdmUgYW55IFg4NiAob3Ig Cj4+Pj4gQVJNKQo+Pj4+IHNwZWNpZmljIGRlcGVuZGVuY2llcyBpbiB0aGUgImRlcGVuZHMiIGxp bmUgdW5kZXIgWEVOX1ZJUlRJTy4gQW5kIEkKPj4+PiBkb24ndCB0aGluayB3ZSBuZWVkIFhFTl9I Vk1fVklSVElPX0dSQU5UIGFzIGEga2NvbmZpZyBvcHRpb24KPj4+PiBuZWNlc3NhcmVseS4gSXQg ZG9lc24ndCBzZWVtIGxpa2Ugc29tZSB3ZSB3YW50IGFzIGJ1aWxkIHRpbWUgCj4+Pj4gb3B0aW9u LiBBdAo+Pj4+IG1vc3QsIGl0IGNvdWxkIGJlIGEgcnVudGltZSBvcHRpb24gKGxpa2UgYSBjb21t YW5kIGxpbmUpIG9yIGEgZGVidWcKPj4+PiBvcHRpb24gKGxpa2UgYW4gI2RlZmluZSBhdCB0aGUg dG9wIG9mIHRoZSBzb3VyY2UgZmlsZS4pCj4+Pgo+Pj4KPj4+IEkgZG9uJ3Qga25vdyB3aGF0IHdh cyB0aGUgaW5pdGlhbCBpZGVhIG9mIGhhdmluZyBhbmQgZXh0cmEgCj4+PiBYRU5fSFZNX1ZJUlRJ TyBhbmQKPj4+IFhFTl9QVl9WSVJUSU8gb3B0aW9ucywgYnV0IHRha2luZyBpbnRvIHRoZSBhY2Nv dW50IHRoYXQKPj4+IHRoZXkgYXJlIG9ubHkgdXNlZCBpbiBhcmNoX2hhc19yZXN0cmljdGVkX3Zp cnRpb19tZW1vcnlfYWNjZXNzKCkgCj4+PiBjdXJyZW50bHksIEkKPj4+IHNoYXJlIHlvdXIgb3Bp bmlvbiByZWdhcmRpbmcgYSBzaW5nbGUgWEVOX1ZJUlRJTyBvcHRpb24uCj4+Pgo+Pj4gTG9va2lu ZyBhaGVhZCAoaW5jbHVkaW5nIGNoYW5nZXMgaW4gdGhlIGNvbW1pdCAjNCksIHdlIGNhbiBpbWFn aW5lIHRoZQo+Pj4gcmVzdWx0aW5nIG9wdGlvbjoKPj4+Cj4+PiBjb25maWcgWEVOX1ZJUlRJTwo+ Pj4gwqDCoMKgwqAgYm9vbCAiWGVuIHZpcnRpbyBzdXBwb3J0Igo+Pj4gwqDCoMKgwqAgZGVmYXVs dCBuCj4+PiDCoMKgwqDCoCBkZXBlbmRzIG9uIFZJUlRJTyAmJiBETUFfT1BTCj4+PiDCoMKgwqDC oCBkZXBlbmRzIG9uIChYODZfNjQgfHwgQVJNIHx8IEFSTTY0KQo+Pj4gwqDCoMKgwqAgc2VsZWN0 IEFSQ0hfSEFTX1JFU1RSSUNURURfVklSVElPX01FTU9SWV9BQ0NFU1MKPj4+IMKgwqDCoMKgIGhl bHAKPj4+IMKgwqDCoMKgIMKgIEVuYWJsZSB2aXJ0aW8gc3VwcG9ydCBmb3IgcnVubmluZyBhcyBY ZW4gZ3Vlc3QuIERlcGVuZGluZyBvbiB0aGUKPj4+IMKgwqDCoMKgIMKgIGd1ZXN0IHR5cGUgdGhp cyB3aWxsIHJlcXVpcmUgc3BlY2lhbCBzdXBwb3J0IG9uIHRoZSBiYWNrZW5kIHNpZGUKPj4+IMKg wqDCoMKgIMKgIChxZW11IG9yIGtlcm5lbCwgZGVwZW5kaW5nIG9uIHRoZSB2aXJ0aW8gZGV2aWNl IHR5cGVzIHVzZWQpLgo+Pj4KPj4+Cj4+PiBhbmQgdGhlbiBhcmNoX2hhc19yZXN0cmljdGVkX3Zp cnRpb19tZW1vcnlfYWNjZXNzKCkgcGVyIGFyY2g6Cj4+Pgo+Pj4KPj4+IDEuIHg4NjoKPj4+Cj4+ PiBpbnQgYXJjaF9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQo+Pj4g ewo+Pj4gwqDCoMKgwqAgcmV0dXJuICh4ZW5faGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9h Y2Nlc3MoKSB8fAo+Pj4gwqDCoMKgwqAgwqDCoMKgIMKgwqDCoCBjY19wbGF0Zm9ybV9oYXMoQ0Nf QVRUUl9HVUVTVF9NRU1fRU5DUllQVCkpOwo+Pj4gfQo+Pj4KPj4+Cj4+PiAyLiBBcm06Cj4+Pgo+ Pj4gaW50IGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Modm9pZCkKPj4+ IHsKPj4+IMKgwqDCoMKgIHJldHVybiB4ZW5faGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9h Y2Nlc3MoKTsKPj4+IH0KPj4+Cj4+Pgo+Pj4gMy4geGVuLmg6Cj4+Pgo+Pj4gc3RhdGljIGlubGlu ZSBpbnQgeGVuX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKHZvaWQpCj4+PiB7 Cj4+PiDCoMKgwqDCoCBpZiAoSVNfRU5BQkxFRChDT05GSUdfWEVOX1ZJUlRJTykgJiYgKHhlbl9w dl9kb21haW4oKSB8fAo+Pj4geGVuX2h2bV9kb21haW4oKSkpCj4+PiDCoMKgwqDCoCDCoMKgwqAg cmV0dXJuIDE7Cj4+Pgo+Pj4gwqDCoMKgwqAgcmV0dXJuIDA7Cj4+PiB9Cj4+Pgo+Pj4KPj4+IEFj dHVhbGx5LCBhcyBkb21haW4gdHlwZSBvbiBBcm0gaXMgYWx3YXlzIFhFTl9IVk1fRE9NQUlOLCB3 ZSBjb3VsZCAKPj4+IHByb2JhYmx5Cj4+PiBoYXZlIHRoZSBmb2xsb3dpbmcgb24gQXJtOgo+Pj4K Pj4+IGludCBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKHZvaWQpCj4+ PiB7Cj4+PiDCoMKgwqDCoCByZXR1cm4gSVNfRU5BQkxFRChDT05GSUdfWEVOX1ZJUlRJTyk7Cj4+ PiB9Cj4+Pgo+Pj4gYnV0IEkgd291bGQgcHJlZmVyIG5vdCB0byBkaXZlcmdlIGFuZCB1c2UgY29t bW9uCj4+PiB4ZW5faGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MoKS4KPj4+Cj4+ PiBBbnkgdGhvdWdodHM/Cj4+Cj4+IFllcywgSSB3b3VsZCBhbHNvIHByZWZlciBub3QgdG8gZGl2 ZXJnZSBiZXR3ZWVuIHRoZSB4ODYgYW5kIGFybSB2ZXJzaW9ucwo+PiBvZiB4ZW5faGFzX3Jlc3Ry aWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MuIEJ1dCB3aGF0IGNhc2UgYXJlIHdlIHRyeWluZwo+ PiB0byBjYXRjaCB3aXRoICh4ZW5fcHZfZG9tYWluKCkgfHwgeGVuX2h2bV9kb21haW4oKSkgPyBF dmVuIG9uIHg4NiwgaXQgaXMKPj4gbm90IGdvaW5nIHRvIGxlYXZlIG11Y2ggb3V0LiBJcyBpdCBy ZWFsbHkgbWVhbnQgb25seSB0byBleGNsdWRlIHB2aAo+PiBkb21haW5zPwoKR29vZCBxdWVzdGlv bi4gQnkgbGVhdmluZyAoeGVuX3B2X2RvbWFpbigpIHx8IHhlbl9odm1fZG9tYWluKCkpIGhlcmUg SSAKdHJpZWQgdG8gcmV0YWluIHdoYXQgdGhlICppbml0aWFsKiB2ZXJzaW9uIG9mIAphcmNoX2hh c19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKCkgY292ZXJlZC4KCgo+Cj4gSXQgd291 bGRuJ3QgZXhjbHVkZSBwdmggZG9tYWlucy4KCgpvawoKCj4KPj4KPj4gSSBoYXZlIHRoZSBmZWVs aW5nIHRoYXQgd2UgY291bGQgdHVybiB0aGlzIGNoZWNrIGludG86Cj4+Cj4+IHN0YXRpYyBpbmxp bmUgaW50IHhlbl9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQo+PiB7 Cj4+IMKgwqDCoMKgIHJldHVybiBJU19FTkFCTEVEKENPTkZJR19YRU5fVklSVElPKSAmJiB4ZW5f ZG9tYWluKCk7Cj4+IH0KPj4KPj4gZXZlbiBvbiB4ODYsIGJ1dCBvbmUgb2YgdGhlIHhlbi94ODYg bWFpbnRhaW5lcnMgc2hvdWxkIGNvbmZpcm0uCj4KPiBJIGRvIGNvbmZpcm0gdGhpcyBpcyBiZXR0 ZXIgYW5kIGZ1bmN0aW9uYWxseSBlcXVpdmFsZW50LgoKClBlcmZlY3QsIHRoYW5rIHlvdSBmb3Ig Y29uZmlybWluZy4gV2lsbCB1c2UgdGhhdCBjaGVjay4KCgo+Cj4KPiBKdWVyZ2VuCgotLSAKUmVn YXJkcywKCk9sZWtzYW5kciBUeXNoY2hlbmtvCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgt YXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3Jn L21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=