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 X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6C43FC47094 for ; Thu, 10 Jun 2021 15:51:14 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 58B8B613D8 for ; Thu, 10 Jun 2021 15:51:14 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231718AbhFJPxJ (ORCPT ); Thu, 10 Jun 2021 11:53:09 -0400 Received: from m43-7.mailgun.net ([69.72.43.7]:43854 "EHLO m43-7.mailgun.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231428AbhFJPxJ (ORCPT ); Thu, 10 Jun 2021 11:53:09 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1623340272; h=Message-ID: References: In-Reply-To: Subject: Cc: To: From: Date: Content-Transfer-Encoding: Content-Type: MIME-Version: Sender; bh=dM+o12MWIVg7M6B6LIPij+pSLwDnUl7N8TYQnX9w0VY=; b=Akba0jrbgWFJbLTAmKXsyslbG6UmAc9C9MuxMnEpvi7qd29LgH9QY+TO0ZkW6TL1AxbTnJhy I1Ypz+xqlMvvCt0qApCApuAuP3oxUYJ4ML37PIek/5cZ1gq8oLcsGaMh2sCJgvPDIiHPE0aM 6QytbiUZqJEv4ohUkqlIiSVxL3c= X-Mailgun-Sending-Ip: 69.72.43.7 X-Mailgun-Sid: WyI1MzIzYiIsICJsaW51eC1hcm0tbXNtQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n05.prod.us-west-2.postgun.com with SMTP id 60c234e9e570c056190030ba (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Thu, 10 Jun 2021 15:51:05 GMT Sender: saiprakash.ranjan=codeaurora.org@mg.codeaurora.org Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 41A4DC43146; Thu, 10 Jun 2021 15:51:05 +0000 (UTC) Received: from mail.codeaurora.org (localhost.localdomain [127.0.0.1]) (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) (Authenticated sender: saiprakash.ranjan) by smtp.codeaurora.org (Postfix) with ESMTPSA id 6F510C433D3; Thu, 10 Jun 2021 15:51:03 +0000 (UTC) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Date: Thu, 10 Jun 2021 21:21:03 +0530 From: Sai Prakash Ranjan To: Robin Murphy Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, iommu@lists.linux-foundation.org, Will Deacon , linux-arm-kernel@lists.infradead.org, Thierry Reding , Krishna Reddy Subject: Re: [PATCH] iommu/io-pgtable-arm: Optimize partial walk flush for large scatter-gather list In-Reply-To: <61c69d23-324a-85d7-2458-dfff8df9280b@arm.com> References: <20210609145315.25750-1-saiprakash.ranjan@codeaurora.org> <35bfd245-45e2-8083-b620-330d6dbd7bd7@arm.com> <12067ffb8243b220cf03e83aaac3e823@codeaurora.org> <266f190e-99ae-9175-cf13-7a77730af389@arm.com> <61c69d23-324a-85d7-2458-dfff8df9280b@arm.com> Message-ID: <3cd4db1104ae673fc58340bc6e9b2a52@codeaurora.org> X-Sender: saiprakash.ranjan@codeaurora.org User-Agent: Roundcube Webmail/1.3.9 Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Hi Robin, On 2021-06-10 20:59, Robin Murphy wrote: > On 2021-06-10 12:54, Sai Prakash Ranjan wrote: >> Hi Robin, >> >> On 2021-06-10 17:03, Robin Murphy wrote: >>> On 2021-06-10 10:36, Sai Prakash Ranjan wrote: >>>> Hi Robin, >>>> >>>> On 2021-06-10 14:38, Robin Murphy wrote: >>>>> On 2021-06-10 06:24, Sai Prakash Ranjan wrote: >>>>>> Hi Robin, >>>>>> >>>>>> On 2021-06-10 00:14, Robin Murphy wrote: >>>>>>> On 2021-06-09 15:53, Sai Prakash Ranjan wrote: >>>>>>>> Currently for iommu_unmap() of large scatter-gather list with >>>>>>>> page size >>>>>>>> elements, the majority of time is spent in flushing of partial >>>>>>>> walks in >>>>>>>> __arm_lpae_unmap() which is a VA based TLB invalidation (TLBIVA >>>>>>>> for >>>>>>>> arm-smmu). >>>>>>>> >>>>>>>> For example: to unmap a 32MB scatter-gather list with page size >>>>>>>> elements >>>>>>>> (8192 entries), there are 16->2MB buffer unmaps based on the >>>>>>>> pgsize (2MB >>>>>>>> for 4K granule) and each of 2MB will further result in 512 >>>>>>>> TLBIVAs (2MB/4K) >>>>>>>> resulting in a total of 8192 TLBIVAs (512*16) for 16->2MB >>>>>>>> causing a huge >>>>>>>> overhead. >>>>>>>> >>>>>>>> So instead use io_pgtable_tlb_flush_all() to invalidate the >>>>>>>> entire context >>>>>>>> if size (pgsize) is greater than the granule size (4K, 16K, >>>>>>>> 64K). For this >>>>>>>> example of 32MB scatter-gather list unmap, this results in just >>>>>>>> 16 ASID >>>>>>>> based TLB invalidations or tlb_flush_all() callback (TLBIASID in >>>>>>>> case of >>>>>>>> arm-smmu) as opposed to 8192 TLBIVAs thereby increasing the >>>>>>>> performance of >>>>>>>> unmaps drastically. >>>>>>>> >>>>>>>> Condition (size > granule size) is chosen for >>>>>>>> io_pgtable_tlb_flush_all() >>>>>>>> because for any granule with supported pgsizes, we will have at >>>>>>>> least 512 >>>>>>>> TLB invalidations for which tlb_flush_all() is already >>>>>>>> recommended. For >>>>>>>> example, take 4K granule with 2MB pgsize, this will result in >>>>>>>> 512 TLBIVA >>>>>>>> in partial walk flush. >>>>>>>> >>>>>>>> Test on QTI SM8150 SoC for 10 iterations of >>>>>>>> iommu_{map_sg}/unmap: >>>>>>>> (average over 10 iterations) >>>>>>>> >>>>>>>> Before this optimization: >>>>>>>> >>>>>>>>      size        iommu_map_sg      iommu_unmap >>>>>>>>        4K            2.067 us         1.854 us >>>>>>>>       64K            9.598 us         8.802 us >>>>>>>>        1M          148.890 us       130.718 us >>>>>>>>        2M          305.864 us        67.291 us >>>>>>>>       12M         1793.604 us       390.838 us >>>>>>>>       16M         2386.848 us       518.187 us >>>>>>>>       24M         3563.296 us       775.989 us >>>>>>>>       32M         4747.171 us      1033.364 us >>>>>>>> >>>>>>>> After this optimization: >>>>>>>> >>>>>>>>      size        iommu_map_sg      iommu_unmap >>>>>>>>        4K            1.723 us         1.765 us >>>>>>>>       64K            9.880 us         8.869 us >>>>>>>>        1M          155.364 us       135.223 us >>>>>>>>        2M          303.906 us         5.385 us >>>>>>>>       12M         1786.557 us        21.250 us >>>>>>>>       16M         2391.890 us        27.437 us >>>>>>>>       24M         3570.895 us        39.937 us >>>>>>>>       32M         4755.234 us        51.797 us >>>>>>>> >>>>>>>> This is further reduced once the map/unmap_pages() support gets >>>>>>>> in which >>>>>>>> will result in just 1 tlb_flush_all() as opposed to 16 >>>>>>>> tlb_flush_all(). >>>>>>>> >>>>>>>> Signed-off-by: Sai Prakash Ranjan >>>>>>>> >>>>>>>> --- >>>>>>>>   drivers/iommu/io-pgtable-arm.c | 7 +++++-- >>>>>>>>   1 file changed, 5 insertions(+), 2 deletions(-) >>>>>>>> >>>>>>>> diff --git a/drivers/iommu/io-pgtable-arm.c >>>>>>>> b/drivers/iommu/io-pgtable-arm.c >>>>>>>> index 87def58e79b5..c3cb9add3179 100644 >>>>>>>> --- a/drivers/iommu/io-pgtable-arm.c >>>>>>>> +++ b/drivers/iommu/io-pgtable-arm.c >>>>>>>> @@ -589,8 +589,11 @@ static size_t __arm_lpae_unmap(struct >>>>>>>> arm_lpae_io_pgtable *data, >>>>>>>>             if (!iopte_leaf(pte, lvl, iop->fmt)) { >>>>>>>>               /* Also flush any partial walks */ >>>>>>>> -            io_pgtable_tlb_flush_walk(iop, iova, size, >>>>>>>> -                          ARM_LPAE_GRANULE(data)); >>>>>>>> +            if (size > ARM_LPAE_GRANULE(data)) >>>>>>>> +                io_pgtable_tlb_flush_all(iop); >>>>>>>> +            else >>>>>>> >>>>>>> Erm, when will the above condition ever not be true? ;) >>>>>>> >>>>>> >>>>>> Ah right, silly me :) >>>>>> >>>>>>> Taking a step back, though, what about the impact to drivers >>>>>>> other >>>>>>> than SMMUv2? >>>>>> >>>>>> Other drivers would be msm_iommu.c, qcom_iommu.c which does the >>>>>> same >>>>>> thing as arm-smmu-v2 (page based invalidations), then there is >>>>>> ipmmu-vmsa.c >>>>>> which does tlb_flush_all() for flush walk. >>>>>> >>>>>>> In particular I'm thinking of SMMUv3.2 where the whole >>>>>>> range can be invalidated by VA in a single command anyway, so the >>>>>>> additional penalties of TLBIALL are undesirable. >>>>>>> >>>>>> >>>>>> Right, so I am thinking we can have a new generic quirk >>>>>> IO_PGTABLE_QUIRK_RANGE_INV >>>>>> to choose between range based invalidations(tlb_flush_walk) and >>>>>> tlb_flush_all(). >>>>>> In this case of arm-smmu-v3.2, we can tie up >>>>>> ARM_SMMU_FEAT_RANGE_INV with this quirk >>>>>> and have something like below, thoughts? >>>>>> >>>>>> if (iop->cfg.quirks & IO_PGTABLE_QUIRK_RANGE_INV) >>>>>>          io_pgtable_tlb_flush_walk(iop, iova, size, >>>>>>                                    ARM_LPAE_GRANULE(data)); >>>>>> else >>>>>>          io_pgtable_tlb_flush_all(iop); >>>>> >>>>> The design here has always been that io-pgtable says *what* needs >>>>> invalidating, and we left it up to the drivers to decide exactly >>>>> *how*. Even though things have evolved a bit I don't think that has >>>>> fundamentally changed - tlb_flush_walk is now only used in this one >>>>> place (technically I suppose it could be renamed tlb_flush_table >>>>> but >>>>> it's not worth the churn), so drivers can implement their own >>>>> preferred table-invalidating behaviour even more easily than >>>>> choosing >>>>> whether to bounce a quirk through the common code or not. Consider >>>>> what you've already seen for the Renesas IPMMU, or SMMUv1 stage >>>>> 2... >>>>> >>>> >>>> Thanks for the explanation, makes sense. If I am not mistaken, I see >>>> that >>>> you are suggesting to move this logic based on size and granule-size >>>> to >>>> arm-smmu-v2 driver and one more thing below.. >>> >>> Simpler than that - following on from my original comment above, >>> tlb_flush_walk already knows it's invalidating at least one full >>> level >>> of table so there's nothing it even needs to check. Adding a >>> size-based heuristic to arm_smmu_inv_range_* for leaf invalidations >>> would be a separate concern (note that changing the non-leaf >>> behaviour >>> might allow cleaning up the "reg" indirection there too). >> >> Right, sorry I didn't mean to mention the size check as it was obvious >> from your first reply, but rather just calling impl->tlb_inv() in >> arm_smmu_tlb_inv_walk_s1(). >> >>> >>>>> I'm instinctively a little twitchy about making this a blanket >>>>> optimisation for SMMUv2 since I still remember the palaver with our >>>>> display and MMU-500 integrations, where it had to implement the >>>>> dodgy >>>>> "prefetch" register to trigger translations before scanning out a >>>>> frame since it couldn't ever afford a TLB miss, thus TLBIALL when >>>>> freeing an old buffer would be a dangerous hammer to swing. However >>>>> IIRC it also had to ensure everything was mapped as 2MB blocks to >>>>> guarantee fitting everything in the TLBs in the first place, so I >>>>> guess it would still work out OK due to never realistically >>>>> unmapping >>>>> a whole table at once anyway. >>>>> >>>> >>>> You are also hinting to not do this for all SMMUv2 implementations >>>> and make >>>> it QCOM specific? >>> >>> No, I'm really just wary that the performance implication is more >>> complex than a simple unmap latency benefit, possibly even for QCOM. >>> Consider the access latency, power and memory bandwidth hit from all >>> the additional pagetable walks incurred by other ongoing traffic >>> fighting against those 16 successive TLBIASIDs. Whether it's an >>> overall win really depends on the specific workload and system >>> conditions as much as the SMMU implementation. >> >> No, the unmap latency is not just in some test case written, the issue >> is very real and we have workloads where camera is reporting frame >> drops >> because of this unmap latency in the order of 100s of milliseconds. >> And hardware team recommends using ASID based invalidations for >> anything >> larger than 128 TLB entries. So yes, we have taken note of impacts >> here >> before going this way and hence feel more inclined to make this qcom >> specific if required. > > OK, that's good to know. I never suggested that CPU unmap latency > wasn't a valid concern in itself - obviously spending millions of > cycles in, say, an interrupt handler doing pointless busy work has > some serious downsides - just that it might not always be the most > important concern for everyone, so I wanted to make sure this > discussion was had in the open. > Right, my mistake that I missed to mention these details of real world data in commit text, will add them in next version. > TBH I *am* inclined to make this a core SMMU driver change provided > nobody pops up with a strong counter-argument. > Ok that's even better in case it helps others as well. >>> Thinking some more, I >>> wonder if the Tegra folks might have an opinion to add here, given >>> that their multiple-SMMU solution was seemingly about trying to get >>> enough TLB and pagetable walk bandwidth in the first place? >>> >> >> Sure but I do not see how that will help with the unmap latency? > > It won't. However it implies a use-case which is already sensitive to > translation bandwidth, and thus is somewhat more likely to be > sensitive to over-invalidation. But even then they also have more to > gain from reducing the number of MMIO writes that have to be > duplicated :) > Ah I see, sorry I misunderstood. It's definitely better if this gets tested on other systems as well. Thanks, Sai -- QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation 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 X-Spam-Level: X-Spam-Status: No, score=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D677C47094 for ; Thu, 10 Jun 2021 15:52:16 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A513E613CB for ; Thu, 10 Jun 2021 15:52:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A513E613CB Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 6E5784010B; Thu, 10 Jun 2021 15:52:15 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id dLHUa0GDAJP1; Thu, 10 Jun 2021 15:52:14 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp2.osuosl.org (Postfix) with ESMTPS id F011440192; Thu, 10 Jun 2021 15:52:13 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id C5DCAC000D; Thu, 10 Jun 2021 15:52:13 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [IPv6:2605:bc80:3010::137]) by lists.linuxfoundation.org (Postfix) with ESMTP id ADFC6C000B for ; Thu, 10 Jun 2021 15:52:12 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with UTF8SMTP id 8E6B940619 for ; Thu, 10 Jun 2021 15:52:12 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp4.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=mg.codeaurora.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with UTF8SMTP id e-y5-iMK-49Y for ; Thu, 10 Jun 2021 15:52:10 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.8.0 Received: from so254-9.mailgun.net (so254-9.mailgun.net [198.61.254.9]) by smtp4.osuosl.org (Postfix) with UTF8SMTPS id C0386405B1 for ; Thu, 10 Jun 2021 15:51:59 +0000 (UTC) DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1623340330; h=Message-ID: References: In-Reply-To: Subject: Cc: To: From: Date: Content-Transfer-Encoding: Content-Type: MIME-Version: Sender; bh=dM+o12MWIVg7M6B6LIPij+pSLwDnUl7N8TYQnX9w0VY=; b=NLw7h/5z0TfkbbtXZ9R4RGzv+gS4Nd2nonmoLZpfXbkApI8JKMX8hSDkwhSciWZzDVzZbUa1 iaWcP1e4d/f1STzaDXlmQ3T6cSUIIOho3NfWdjCujA0LuDTLuGHpBL3Z9ZW47aT66lhn/4ut 7MqP/oVLQYe4UcqMk/C8TGYdJQ0= X-Mailgun-Sending-Ip: 198.61.254.9 X-Mailgun-Sid: WyI3NDkwMCIsICJpb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n04.prod.us-east-1.postgun.com with SMTP id 60c234ebe27c0cc77f55375e (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Thu, 10 Jun 2021 15:51:07 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 3F79AC4338A; Thu, 10 Jun 2021 15:51:06 +0000 (UTC) Received: from mail.codeaurora.org (localhost.localdomain [127.0.0.1]) (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) (Authenticated sender: saiprakash.ranjan) by smtp.codeaurora.org (Postfix) with ESMTPSA id 6F510C433D3; Thu, 10 Jun 2021 15:51:03 +0000 (UTC) MIME-Version: 1.0 Date: Thu, 10 Jun 2021 21:21:03 +0530 From: Sai Prakash Ranjan To: Robin Murphy Subject: Re: [PATCH] iommu/io-pgtable-arm: Optimize partial walk flush for large scatter-gather list In-Reply-To: <61c69d23-324a-85d7-2458-dfff8df9280b@arm.com> References: <20210609145315.25750-1-saiprakash.ranjan@codeaurora.org> <35bfd245-45e2-8083-b620-330d6dbd7bd7@arm.com> <12067ffb8243b220cf03e83aaac3e823@codeaurora.org> <266f190e-99ae-9175-cf13-7a77730af389@arm.com> <61c69d23-324a-85d7-2458-dfff8df9280b@arm.com> Message-ID: <3cd4db1104ae673fc58340bc6e9b2a52@codeaurora.org> X-Sender: saiprakash.ranjan@codeaurora.org User-Agent: Roundcube Webmail/1.3.9 Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, iommu@lists.linux-foundation.org, Thierry Reding , Will Deacon , linux-arm-kernel@lists.infradead.org X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" SGkgUm9iaW4sCgpPbiAyMDIxLTA2LTEwIDIwOjU5LCBSb2JpbiBNdXJwaHkgd3JvdGU6Cj4gT24g MjAyMS0wNi0xMCAxMjo1NCwgU2FpIFByYWthc2ggUmFuamFuIHdyb3RlOgo+PiBIaSBSb2JpbiwK Pj4gCj4+IE9uIDIwMjEtMDYtMTAgMTc6MDMsIFJvYmluIE11cnBoeSB3cm90ZToKPj4+IE9uIDIw MjEtMDYtMTAgMTA6MzYsIFNhaSBQcmFrYXNoIFJhbmphbiB3cm90ZToKPj4+PiBIaSBSb2JpbiwK Pj4+PiAKPj4+PiBPbiAyMDIxLTA2LTEwIDE0OjM4LCBSb2JpbiBNdXJwaHkgd3JvdGU6Cj4+Pj4+ IE9uIDIwMjEtMDYtMTAgMDY6MjQsIFNhaSBQcmFrYXNoIFJhbmphbiB3cm90ZToKPj4+Pj4+IEhp IFJvYmluLAo+Pj4+Pj4gCj4+Pj4+PiBPbiAyMDIxLTA2LTEwIDAwOjE0LCBSb2JpbiBNdXJwaHkg d3JvdGU6Cj4+Pj4+Pj4gT24gMjAyMS0wNi0wOSAxNTo1MywgU2FpIFByYWthc2ggUmFuamFuIHdy b3RlOgo+Pj4+Pj4+PiBDdXJyZW50bHkgZm9yIGlvbW11X3VubWFwKCkgb2YgbGFyZ2Ugc2NhdHRl ci1nYXRoZXIgbGlzdCB3aXRoIAo+Pj4+Pj4+PiBwYWdlIHNpemUKPj4+Pj4+Pj4gZWxlbWVudHMs IHRoZSBtYWpvcml0eSBvZiB0aW1lIGlzIHNwZW50IGluIGZsdXNoaW5nIG9mIHBhcnRpYWwgCj4+ Pj4+Pj4+IHdhbGtzIGluCj4+Pj4+Pj4+IF9fYXJtX2xwYWVfdW5tYXAoKSB3aGljaCBpcyBhIFZB IGJhc2VkIFRMQiBpbnZhbGlkYXRpb24gKFRMQklWQSAKPj4+Pj4+Pj4gZm9yCj4+Pj4+Pj4+IGFy bS1zbW11KS4KPj4+Pj4+Pj4gCj4+Pj4+Pj4+IEZvciBleGFtcGxlOiB0byB1bm1hcCBhIDMyTUIg c2NhdHRlci1nYXRoZXIgbGlzdCB3aXRoIHBhZ2Ugc2l6ZSAKPj4+Pj4+Pj4gZWxlbWVudHMKPj4+ Pj4+Pj4gKDgxOTIgZW50cmllcyksIHRoZXJlIGFyZSAxNi0+Mk1CIGJ1ZmZlciB1bm1hcHMgYmFz ZWQgb24gdGhlIAo+Pj4+Pj4+PiBwZ3NpemUgKDJNQgo+Pj4+Pj4+PiBmb3IgNEsgZ3JhbnVsZSkg YW5kIGVhY2ggb2YgMk1CIHdpbGwgZnVydGhlciByZXN1bHQgaW4gNTEyIAo+Pj4+Pj4+PiBUTEJJ VkFzICgyTUIvNEspCj4+Pj4+Pj4+IHJlc3VsdGluZyBpbiBhIHRvdGFsIG9mIDgxOTIgVExCSVZB cyAoNTEyKjE2KSBmb3IgMTYtPjJNQiAKPj4+Pj4+Pj4gY2F1c2luZyBhIGh1Z2UKPj4+Pj4+Pj4g b3ZlcmhlYWQuCj4+Pj4+Pj4+IAo+Pj4+Pj4+PiBTbyBpbnN0ZWFkIHVzZSBpb19wZ3RhYmxlX3Rs Yl9mbHVzaF9hbGwoKSB0byBpbnZhbGlkYXRlIHRoZSAKPj4+Pj4+Pj4gZW50aXJlIGNvbnRleHQK Pj4+Pj4+Pj4gaWYgc2l6ZSAocGdzaXplKSBpcyBncmVhdGVyIHRoYW4gdGhlIGdyYW51bGUgc2l6 ZSAoNEssIDE2SywgCj4+Pj4+Pj4+IDY0SykuIEZvciB0aGlzCj4+Pj4+Pj4+IGV4YW1wbGUgb2Yg MzJNQiBzY2F0dGVyLWdhdGhlciBsaXN0IHVubWFwLCB0aGlzIHJlc3VsdHMgaW4ganVzdCAKPj4+ Pj4+Pj4gMTYgQVNJRAo+Pj4+Pj4+PiBiYXNlZCBUTEIgaW52YWxpZGF0aW9ucyBvciB0bGJfZmx1 c2hfYWxsKCkgY2FsbGJhY2sgKFRMQklBU0lEIGluIAo+Pj4+Pj4+PiBjYXNlIG9mCj4+Pj4+Pj4+ IGFybS1zbW11KSBhcyBvcHBvc2VkIHRvIDgxOTIgVExCSVZBcyB0aGVyZWJ5IGluY3JlYXNpbmcg dGhlIAo+Pj4+Pj4+PiBwZXJmb3JtYW5jZSBvZgo+Pj4+Pj4+PiB1bm1hcHMgZHJhc3RpY2FsbHku Cj4+Pj4+Pj4+IAo+Pj4+Pj4+PiBDb25kaXRpb24gKHNpemUgPiBncmFudWxlIHNpemUpIGlzIGNo b3NlbiBmb3IgCj4+Pj4+Pj4+IGlvX3BndGFibGVfdGxiX2ZsdXNoX2FsbCgpCj4+Pj4+Pj4+IGJl Y2F1c2UgZm9yIGFueSBncmFudWxlIHdpdGggc3VwcG9ydGVkIHBnc2l6ZXMsIHdlIHdpbGwgaGF2 ZSBhdCAKPj4+Pj4+Pj4gbGVhc3QgNTEyCj4+Pj4+Pj4+IFRMQiBpbnZhbGlkYXRpb25zIGZvciB3 aGljaCB0bGJfZmx1c2hfYWxsKCkgaXMgYWxyZWFkeSAKPj4+Pj4+Pj4gcmVjb21tZW5kZWQuIEZv cgo+Pj4+Pj4+PiBleGFtcGxlLCB0YWtlIDRLIGdyYW51bGUgd2l0aCAyTUIgcGdzaXplLCB0aGlz IHdpbGwgcmVzdWx0IGluIAo+Pj4+Pj4+PiA1MTIgVExCSVZBCj4+Pj4+Pj4+IGluIHBhcnRpYWwg d2FsayBmbHVzaC4KPj4+Pj4+Pj4gCj4+Pj4+Pj4+IFRlc3Qgb24gUVRJIFNNODE1MCBTb0MgZm9y IDEwIGl0ZXJhdGlvbnMgb2YgCj4+Pj4+Pj4+IGlvbW11X3ttYXBfc2d9L3VubWFwOgo+Pj4+Pj4+ PiAoYXZlcmFnZSBvdmVyIDEwIGl0ZXJhdGlvbnMpCj4+Pj4+Pj4+IAo+Pj4+Pj4+PiBCZWZvcmUg dGhpcyBvcHRpbWl6YXRpb246Cj4+Pj4+Pj4+IAo+Pj4+Pj4+PiDCoMKgwqDCoCBzaXplwqDCoMKg wqDCoMKgwqAgaW9tbXVfbWFwX3NnwqDCoMKgwqDCoCBpb21tdV91bm1hcAo+Pj4+Pj4+PiDCoMKg wqDCoMKgwqAgNEvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIDIuMDY3IHVzwqDCoMKgwqDCoMKgwqDC oCAxLjg1NCB1cwo+Pj4+Pj4+PiDCoMKgwqDCoMKgIDY0S8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAg OS41OTggdXPCoMKgwqDCoMKgwqDCoMKgIDguODAyIHVzCj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoCAx TcKgwqDCoMKgwqDCoMKgwqDCoCAxNDguODkwIHVzwqDCoMKgwqDCoMKgIDEzMC43MTggdXMKPj4+ Pj4+Pj4gwqDCoMKgwqDCoMKgIDJNwqDCoMKgwqDCoMKgwqDCoMKgIDMwNS44NjQgdXPCoMKgwqDC oMKgwqDCoCA2Ny4yOTEgdXMKPj4+Pj4+Pj4gwqDCoMKgwqDCoCAxMk3CoMKgwqDCoMKgwqDCoMKg IDE3OTMuNjA0IHVzwqDCoMKgwqDCoMKgIDM5MC44MzggdXMKPj4+Pj4+Pj4gwqDCoMKgwqDCoCAx Nk3CoMKgwqDCoMKgwqDCoMKgIDIzODYuODQ4IHVzwqDCoMKgwqDCoMKgIDUxOC4xODcgdXMKPj4+ Pj4+Pj4gwqDCoMKgwqDCoCAyNE3CoMKgwqDCoMKgwqDCoMKgIDM1NjMuMjk2IHVzwqDCoMKgwqDC oMKgIDc3NS45ODkgdXMKPj4+Pj4+Pj4gwqDCoMKgwqDCoCAzMk3CoMKgwqDCoMKgwqDCoMKgIDQ3 NDcuMTcxIHVzwqDCoMKgwqDCoCAxMDMzLjM2NCB1cwo+Pj4+Pj4+PiAKPj4+Pj4+Pj4gQWZ0ZXIg dGhpcyBvcHRpbWl6YXRpb246Cj4+Pj4+Pj4+IAo+Pj4+Pj4+PiDCoMKgwqDCoCBzaXplwqDCoMKg wqDCoMKgwqAgaW9tbXVfbWFwX3NnwqDCoMKgwqDCoCBpb21tdV91bm1hcAo+Pj4+Pj4+PiDCoMKg wqDCoMKgwqAgNEvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIDEuNzIzIHVzwqDCoMKgwqDCoMKgwqDC oCAxLjc2NSB1cwo+Pj4+Pj4+PiDCoMKgwqDCoMKgIDY0S8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAg OS44ODAgdXPCoMKgwqDCoMKgwqDCoMKgIDguODY5IHVzCj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoCAx TcKgwqDCoMKgwqDCoMKgwqDCoCAxNTUuMzY0IHVzwqDCoMKgwqDCoMKgIDEzNS4yMjMgdXMKPj4+ Pj4+Pj4gwqDCoMKgwqDCoMKgIDJNwqDCoMKgwqDCoMKgwqDCoMKgIDMwMy45MDYgdXPCoMKgwqDC oMKgwqDCoMKgIDUuMzg1IHVzCj4+Pj4+Pj4+IMKgwqDCoMKgwqAgMTJNwqDCoMKgwqDCoMKgwqDC oCAxNzg2LjU1NyB1c8KgwqDCoMKgwqDCoMKgIDIxLjI1MCB1cwo+Pj4+Pj4+PiDCoMKgwqDCoMKg IDE2TcKgwqDCoMKgwqDCoMKgwqAgMjM5MS44OTAgdXPCoMKgwqDCoMKgwqDCoCAyNy40MzcgdXMK Pj4+Pj4+Pj4gwqDCoMKgwqDCoCAyNE3CoMKgwqDCoMKgwqDCoMKgIDM1NzAuODk1IHVzwqDCoMKg wqDCoMKgwqAgMzkuOTM3IHVzCj4+Pj4+Pj4+IMKgwqDCoMKgwqAgMzJNwqDCoMKgwqDCoMKgwqDC oCA0NzU1LjIzNCB1c8KgwqDCoMKgwqDCoMKgIDUxLjc5NyB1cwo+Pj4+Pj4+PiAKPj4+Pj4+Pj4g VGhpcyBpcyBmdXJ0aGVyIHJlZHVjZWQgb25jZSB0aGUgbWFwL3VubWFwX3BhZ2VzKCkgc3VwcG9y dCBnZXRzIAo+Pj4+Pj4+PiBpbiB3aGljaAo+Pj4+Pj4+PiB3aWxsIHJlc3VsdCBpbiBqdXN0IDEg dGxiX2ZsdXNoX2FsbCgpIGFzIG9wcG9zZWQgdG8gMTYgCj4+Pj4+Pj4+IHRsYl9mbHVzaF9hbGwo KS4KPj4+Pj4+Pj4gCj4+Pj4+Pj4+IFNpZ25lZC1vZmYtYnk6IFNhaSBQcmFrYXNoIFJhbmphbiAK Pj4+Pj4+Pj4gPHNhaXByYWthc2gucmFuamFuQGNvZGVhdXJvcmEub3JnPgo+Pj4+Pj4+PiAtLS0K Pj4+Pj4+Pj4gwqAgZHJpdmVycy9pb21tdS9pby1wZ3RhYmxlLWFybS5jIHwgNyArKysrKy0tCj4+ Pj4+Pj4+IMKgIDEgZmlsZSBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0p Cj4+Pj4+Pj4+IAo+Pj4+Pj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9pby1wZ3RhYmxl LWFybS5jIAo+Pj4+Pj4+PiBiL2RyaXZlcnMvaW9tbXUvaW8tcGd0YWJsZS1hcm0uYwo+Pj4+Pj4+ PiBpbmRleCA4N2RlZjU4ZTc5YjUuLmMzY2I5YWRkMzE3OSAxMDA2NDQKPj4+Pj4+Pj4gLS0tIGEv ZHJpdmVycy9pb21tdS9pby1wZ3RhYmxlLWFybS5jCj4+Pj4+Pj4+ICsrKyBiL2RyaXZlcnMvaW9t bXUvaW8tcGd0YWJsZS1hcm0uYwo+Pj4+Pj4+PiBAQCAtNTg5LDggKzU4OSwxMSBAQCBzdGF0aWMg c2l6ZV90IF9fYXJtX2xwYWVfdW5tYXAoc3RydWN0IAo+Pj4+Pj4+PiBhcm1fbHBhZV9pb19wZ3Rh YmxlICpkYXRhLAo+Pj4+Pj4+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmICghaW9wdGVfbGVh ZihwdGUsIGx2bCwgaW9wLT5mbXQpKSB7Cj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIC8qIEFsc28gZmx1c2ggYW55IHBhcnRpYWwgd2Fsa3MgKi8KPj4+Pj4+Pj4gLcKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgaW9fcGd0YWJsZV90bGJfZmx1c2hfd2Fsayhpb3AsIGlvdmEsIHNpemUs Cj4+Pj4+Pj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBBUk1fTFBBRV9HUkFOVUxFKGRhdGEpKTsKPj4+Pj4+Pj4gK8KgwqDCoMKgwqDCoMKgwqDC oMKgwqAgaWYgKHNpemUgPiBBUk1fTFBBRV9HUkFOVUxFKGRhdGEpKQo+Pj4+Pj4+PiArwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlvX3BndGFibGVfdGxiX2ZsdXNoX2FsbChpb3ApOwo+ Pj4+Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBlbHNlCj4+Pj4+Pj4gCj4+Pj4+Pj4gRXJt LCB3aGVuIHdpbGwgdGhlIGFib3ZlIGNvbmRpdGlvbiBldmVyIG5vdCBiZSB0cnVlPyA7KQo+Pj4+ Pj4+IAo+Pj4+Pj4gCj4+Pj4+PiBBaCByaWdodCwgc2lsbHkgbWUgOikKPj4+Pj4+IAo+Pj4+Pj4+ IFRha2luZyBhIHN0ZXAgYmFjaywgdGhvdWdoLCB3aGF0IGFib3V0IHRoZSBpbXBhY3QgdG8gZHJp dmVycyAKPj4+Pj4+PiBvdGhlcgo+Pj4+Pj4+IHRoYW4gU01NVXYyPwo+Pj4+Pj4gCj4+Pj4+PiBP dGhlciBkcml2ZXJzIHdvdWxkIGJlIG1zbV9pb21tdS5jLCBxY29tX2lvbW11LmMgd2hpY2ggZG9l cyB0aGUgCj4+Pj4+PiBzYW1lCj4+Pj4+PiB0aGluZyBhcyBhcm0tc21tdS12MiAocGFnZSBiYXNl ZCBpbnZhbGlkYXRpb25zKSwgdGhlbiB0aGVyZSBpcyAKPj4+Pj4+IGlwbW11LXZtc2EuYwo+Pj4+ Pj4gd2hpY2ggZG9lcyB0bGJfZmx1c2hfYWxsKCkgZm9yIGZsdXNoIHdhbGsuCj4+Pj4+PiAKPj4+ Pj4+PiBJbiBwYXJ0aWN1bGFyIEknbSB0aGlua2luZyBvZiBTTU1VdjMuMiB3aGVyZSB0aGUgd2hv bGUKPj4+Pj4+PiByYW5nZSBjYW4gYmUgaW52YWxpZGF0ZWQgYnkgVkEgaW4gYSBzaW5nbGUgY29t bWFuZCBhbnl3YXksIHNvIHRoZQo+Pj4+Pj4+IGFkZGl0aW9uYWwgcGVuYWx0aWVzIG9mIFRMQklB TEwgYXJlIHVuZGVzaXJhYmxlLgo+Pj4+Pj4+IAo+Pj4+Pj4gCj4+Pj4+PiBSaWdodCwgc28gSSBh bSB0aGlua2luZyB3ZSBjYW4gaGF2ZSBhIG5ldyBnZW5lcmljIHF1aXJrIAo+Pj4+Pj4gSU9fUEdU QUJMRV9RVUlSS19SQU5HRV9JTlYKPj4+Pj4+IHRvIGNob29zZSBiZXR3ZWVuIHJhbmdlIGJhc2Vk IGludmFsaWRhdGlvbnModGxiX2ZsdXNoX3dhbGspIGFuZCAKPj4+Pj4+IHRsYl9mbHVzaF9hbGwo KS4KPj4+Pj4+IEluIHRoaXMgY2FzZSBvZiBhcm0tc21tdS12My4yLCB3ZSBjYW4gdGllIHVwIAo+ Pj4+Pj4gQVJNX1NNTVVfRkVBVF9SQU5HRV9JTlYgd2l0aCB0aGlzIHF1aXJrCj4+Pj4+PiBhbmQg aGF2ZSBzb21ldGhpbmcgbGlrZSBiZWxvdywgdGhvdWdodHM/Cj4+Pj4+PiAKPj4+Pj4+IGlmIChp b3AtPmNmZy5xdWlya3MgJiBJT19QR1RBQkxFX1FVSVJLX1JBTkdFX0lOVikKPj4+Pj4+IMKgwqDC oMKgwqDCoMKgwqAgaW9fcGd0YWJsZV90bGJfZmx1c2hfd2Fsayhpb3AsIGlvdmEsIHNpemUsCj4+ Pj4+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBBUk1fTFBBRV9HUkFOVUxFKGRhdGEpKTsKPj4+Pj4+IGVsc2UKPj4+ Pj4+IMKgwqDCoMKgwqDCoMKgwqAgaW9fcGd0YWJsZV90bGJfZmx1c2hfYWxsKGlvcCk7Cj4+Pj4+ IAo+Pj4+PiBUaGUgZGVzaWduIGhlcmUgaGFzIGFsd2F5cyBiZWVuIHRoYXQgaW8tcGd0YWJsZSBz YXlzICp3aGF0KiBuZWVkcwo+Pj4+PiBpbnZhbGlkYXRpbmcsIGFuZCB3ZSBsZWZ0IGl0IHVwIHRv IHRoZSBkcml2ZXJzIHRvIGRlY2lkZSBleGFjdGx5Cj4+Pj4+ICpob3cqLiBFdmVuIHRob3VnaCB0 aGluZ3MgaGF2ZSBldm9sdmVkIGEgYml0IEkgZG9uJ3QgdGhpbmsgdGhhdCBoYXMKPj4+Pj4gZnVu ZGFtZW50YWxseSBjaGFuZ2VkIC0gdGxiX2ZsdXNoX3dhbGsgaXMgbm93IG9ubHkgdXNlZCBpbiB0 aGlzIG9uZQo+Pj4+PiBwbGFjZSAodGVjaG5pY2FsbHkgSSBzdXBwb3NlIGl0IGNvdWxkIGJlIHJl bmFtZWQgdGxiX2ZsdXNoX3RhYmxlIAo+Pj4+PiBidXQKPj4+Pj4gaXQncyBub3Qgd29ydGggdGhl IGNodXJuKSwgc28gZHJpdmVycyBjYW4gaW1wbGVtZW50IHRoZWlyIG93bgo+Pj4+PiBwcmVmZXJy ZWQgdGFibGUtaW52YWxpZGF0aW5nIGJlaGF2aW91ciBldmVuIG1vcmUgZWFzaWx5IHRoYW4gCj4+ Pj4+IGNob29zaW5nCj4+Pj4+IHdoZXRoZXIgdG8gYm91bmNlIGEgcXVpcmsgdGhyb3VnaCB0aGUg Y29tbW9uIGNvZGUgb3Igbm90LiBDb25zaWRlcgo+Pj4+PiB3aGF0IHlvdSd2ZSBhbHJlYWR5IHNl ZW4gZm9yIHRoZSBSZW5lc2FzIElQTU1VLCBvciBTTU1VdjEgc3RhZ2UgCj4+Pj4+IDIuLi4KPj4+ Pj4gCj4+Pj4gCj4+Pj4gVGhhbmtzIGZvciB0aGUgZXhwbGFuYXRpb24sIG1ha2VzIHNlbnNlLiBJ ZiBJIGFtIG5vdCBtaXN0YWtlbiwgSSBzZWUgCj4+Pj4gdGhhdAo+Pj4+IHlvdSBhcmUgc3VnZ2Vz dGluZyB0byBtb3ZlIHRoaXMgbG9naWMgYmFzZWQgb24gc2l6ZSBhbmQgZ3JhbnVsZS1zaXplIAo+ Pj4+IHRvCj4+Pj4gYXJtLXNtbXUtdjIgZHJpdmVyIGFuZCBvbmUgbW9yZSB0aGluZyBiZWxvdy4u Cj4+PiAKPj4+IFNpbXBsZXIgdGhhbiB0aGF0IC0gZm9sbG93aW5nIG9uIGZyb20gbXkgb3JpZ2lu YWwgY29tbWVudCBhYm92ZSwKPj4+IHRsYl9mbHVzaF93YWxrIGFscmVhZHkga25vd3MgaXQncyBp bnZhbGlkYXRpbmcgYXQgbGVhc3Qgb25lIGZ1bGwgCj4+PiBsZXZlbAo+Pj4gb2YgdGFibGUgc28g dGhlcmUncyBub3RoaW5nIGl0IGV2ZW4gbmVlZHMgdG8gY2hlY2suIEFkZGluZyBhCj4+PiBzaXpl LWJhc2VkIGhldXJpc3RpYyB0byBhcm1fc21tdV9pbnZfcmFuZ2VfKiBmb3IgbGVhZiBpbnZhbGlk YXRpb25zCj4+PiB3b3VsZCBiZSBhIHNlcGFyYXRlIGNvbmNlcm4gKG5vdGUgdGhhdCBjaGFuZ2lu ZyB0aGUgbm9uLWxlYWYgCj4+PiBiZWhhdmlvdXIKPj4+IG1pZ2h0IGFsbG93IGNsZWFuaW5nIHVw IHRoZSAicmVnIiBpbmRpcmVjdGlvbiB0aGVyZSB0b28pLgo+PiAKPj4gUmlnaHQsIHNvcnJ5IEkg ZGlkbid0IG1lYW4gdG8gbWVudGlvbiB0aGUgc2l6ZSBjaGVjayBhcyBpdCB3YXMgb2J2aW91cwo+ PiBmcm9tIHlvdXIgZmlyc3QgcmVwbHksIGJ1dCByYXRoZXIganVzdCBjYWxsaW5nIGltcGwtPnRs Yl9pbnYoKSBpbgo+PiBhcm1fc21tdV90bGJfaW52X3dhbGtfczEoKS4KPj4gCj4+PiAKPj4+Pj4g SSdtIGluc3RpbmN0aXZlbHkgYSBsaXR0bGUgdHdpdGNoeSBhYm91dCBtYWtpbmcgdGhpcyBhIGJs YW5rZXQKPj4+Pj4gb3B0aW1pc2F0aW9uIGZvciBTTU1VdjIgc2luY2UgSSBzdGlsbCByZW1lbWJl ciB0aGUgcGFsYXZlciB3aXRoIG91cgo+Pj4+PiBkaXNwbGF5IGFuZCBNTVUtNTAwIGludGVncmF0 aW9ucywgd2hlcmUgaXQgaGFkIHRvIGltcGxlbWVudCB0aGUgCj4+Pj4+IGRvZGd5Cj4+Pj4+ICJw cmVmZXRjaCIgcmVnaXN0ZXIgdG8gdHJpZ2dlciB0cmFuc2xhdGlvbnMgYmVmb3JlIHNjYW5uaW5n IG91dCBhCj4+Pj4+IGZyYW1lIHNpbmNlIGl0IGNvdWxkbid0IGV2ZXIgYWZmb3JkIGEgVExCIG1p c3MsIHRodXMgVExCSUFMTCB3aGVuCj4+Pj4+IGZyZWVpbmcgYW4gb2xkIGJ1ZmZlciB3b3VsZCBi ZSBhIGRhbmdlcm91cyBoYW1tZXIgdG8gc3dpbmcuIEhvd2V2ZXIKPj4+Pj4gSUlSQyBpdCBhbHNv IGhhZCB0byBlbnN1cmUgZXZlcnl0aGluZyB3YXMgbWFwcGVkIGFzIDJNQiBibG9ja3MgdG8KPj4+ Pj4gZ3VhcmFudGVlIGZpdHRpbmcgZXZlcnl0aGluZyBpbiB0aGUgVExCcyBpbiB0aGUgZmlyc3Qg cGxhY2UsIHNvIEkKPj4+Pj4gZ3Vlc3MgaXQgd291bGQgc3RpbGwgd29yayBvdXQgT0sgZHVlIHRv IG5ldmVyIHJlYWxpc3RpY2FsbHkgCj4+Pj4+IHVubWFwcGluZwo+Pj4+PiBhIHdob2xlIHRhYmxl IGF0IG9uY2UgYW55d2F5Lgo+Pj4+PiAKPj4+PiAKPj4+PiBZb3UgYXJlIGFsc28gaGludGluZyB0 byBub3QgZG8gdGhpcyBmb3IgYWxsIFNNTVV2MiBpbXBsZW1lbnRhdGlvbnMgCj4+Pj4gYW5kIG1h a2UKPj4+PiBpdCBRQ09NIHNwZWNpZmljPwo+Pj4gCj4+PiBObywgSSdtIHJlYWxseSBqdXN0IHdh cnkgdGhhdCB0aGUgcGVyZm9ybWFuY2UgaW1wbGljYXRpb24gaXMgbW9yZQo+Pj4gY29tcGxleCB0 aGFuIGEgc2ltcGxlIHVubWFwIGxhdGVuY3kgYmVuZWZpdCwgcG9zc2libHkgZXZlbiBmb3IgUUNP TS4KPj4+IENvbnNpZGVyIHRoZSBhY2Nlc3MgbGF0ZW5jeSwgcG93ZXIgYW5kIG1lbW9yeSBiYW5k d2lkdGggaGl0IGZyb20gYWxsCj4+PiB0aGUgYWRkaXRpb25hbCBwYWdldGFibGUgd2Fsa3MgaW5j dXJyZWQgYnkgb3RoZXIgb25nb2luZyB0cmFmZmljCj4+PiBmaWdodGluZyBhZ2FpbnN0IHRob3Nl IDE2IHN1Y2Nlc3NpdmUgVExCSUFTSURzLiBXaGV0aGVyIGl0J3MgYW4KPj4+IG92ZXJhbGwgd2lu IHJlYWxseSBkZXBlbmRzIG9uIHRoZSBzcGVjaWZpYyB3b3JrbG9hZCBhbmQgc3lzdGVtCj4+PiBj b25kaXRpb25zIGFzIG11Y2ggYXMgdGhlIFNNTVUgaW1wbGVtZW50YXRpb24uCj4+IAo+PiBObywg dGhlIHVubWFwIGxhdGVuY3kgaXMgbm90IGp1c3QgaW4gc29tZSB0ZXN0IGNhc2Ugd3JpdHRlbiwg dGhlIGlzc3VlCj4+IGlzIHZlcnkgcmVhbCBhbmQgd2UgaGF2ZSB3b3JrbG9hZHMgd2hlcmUgY2Ft ZXJhIGlzIHJlcG9ydGluZyBmcmFtZSAKPj4gZHJvcHMKPj4gYmVjYXVzZSBvZiB0aGlzIHVubWFw IGxhdGVuY3kgaW4gdGhlIG9yZGVyIG9mIDEwMHMgb2YgbWlsbGlzZWNvbmRzLgo+PiBBbmQgaGFy ZHdhcmUgdGVhbSByZWNvbW1lbmRzIHVzaW5nIEFTSUQgYmFzZWQgaW52YWxpZGF0aW9ucyBmb3Ig Cj4+IGFueXRoaW5nCj4+IGxhcmdlciB0aGFuIDEyOCBUTEIgZW50cmllcy4gU28geWVzLCB3ZSBo YXZlIHRha2VuIG5vdGUgb2YgaW1wYWN0cyAKPj4gaGVyZQo+PiBiZWZvcmUgZ29pbmcgdGhpcyB3 YXkgYW5kIGhlbmNlIGZlZWwgbW9yZSBpbmNsaW5lZCB0byBtYWtlIHRoaXMgcWNvbQo+PiBzcGVj aWZpYyBpZiByZXF1aXJlZC4KPiAKPiBPSywgdGhhdCdzIGdvb2QgdG8ga25vdy4gSSBuZXZlciBz dWdnZXN0ZWQgdGhhdCBDUFUgdW5tYXAgbGF0ZW5jeQo+IHdhc24ndCBhIHZhbGlkIGNvbmNlcm4g aW4gaXRzZWxmIC0gb2J2aW91c2x5IHNwZW5kaW5nIG1pbGxpb25zIG9mCj4gY3ljbGVzIGluLCBz YXksIGFuIGludGVycnVwdCBoYW5kbGVyIGRvaW5nIHBvaW50bGVzcyBidXN5IHdvcmsgaGFzCj4g c29tZSBzZXJpb3VzIGRvd25zaWRlcyAtIGp1c3QgdGhhdCBpdCBtaWdodCBub3QgYWx3YXlzIGJl IHRoZSBtb3N0Cj4gaW1wb3J0YW50IGNvbmNlcm4gZm9yIGV2ZXJ5b25lLCBzbyBJIHdhbnRlZCB0 byBtYWtlIHN1cmUgdGhpcwo+IGRpc2N1c3Npb24gd2FzIGhhZCBpbiB0aGUgb3Blbi4KPiAKClJp Z2h0LCBteSBtaXN0YWtlIHRoYXQgSSBtaXNzZWQgdG8gbWVudGlvbiB0aGVzZSBkZXRhaWxzIG9m IHJlYWwgd29ybGQKZGF0YSBpbiBjb21taXQgdGV4dCwgd2lsbCBhZGQgdGhlbSBpbiBuZXh0IHZl cnNpb24uCgo+IFRCSCBJICphbSogaW5jbGluZWQgdG8gbWFrZSB0aGlzIGEgY29yZSBTTU1VIGRy aXZlciBjaGFuZ2UgcHJvdmlkZWQKPiBub2JvZHkgcG9wcyB1cCB3aXRoIGEgc3Ryb25nIGNvdW50 ZXItYXJndW1lbnQuCj4gCgpPayB0aGF0J3MgZXZlbiBiZXR0ZXIgaW4gY2FzZSBpdCBoZWxwcyBv dGhlcnMgYXMgd2VsbC4KCj4+PiBUaGlua2luZyBzb21lIG1vcmUsIEkKPj4+IHdvbmRlciBpZiB0 aGUgVGVncmEgZm9sa3MgbWlnaHQgaGF2ZSBhbiBvcGluaW9uIHRvIGFkZCBoZXJlLCBnaXZlbgo+ Pj4gdGhhdCB0aGVpciBtdWx0aXBsZS1TTU1VIHNvbHV0aW9uIHdhcyBzZWVtaW5nbHkgYWJvdXQg dHJ5aW5nIHRvIGdldAo+Pj4gZW5vdWdoIFRMQiBhbmQgcGFnZXRhYmxlIHdhbGsgYmFuZHdpZHRo IGluIHRoZSBmaXJzdCBwbGFjZT8KPj4+IAo+PiAKPj4gU3VyZSBidXQgSSBkbyBub3Qgc2VlIGhv dyB0aGF0IHdpbGwgaGVscCB3aXRoIHRoZSB1bm1hcCBsYXRlbmN5Pwo+IAo+IEl0IHdvbid0LiBI b3dldmVyIGl0IGltcGxpZXMgYSB1c2UtY2FzZSB3aGljaCBpcyBhbHJlYWR5IHNlbnNpdGl2ZSB0 bwo+IHRyYW5zbGF0aW9uIGJhbmR3aWR0aCwgYW5kIHRodXMgaXMgc29tZXdoYXQgbW9yZSBsaWtl bHkgdG8gYmUKPiBzZW5zaXRpdmUgdG8gb3Zlci1pbnZhbGlkYXRpb24uIEJ1dCBldmVuIHRoZW4g dGhleSBhbHNvIGhhdmUgbW9yZSB0bwo+IGdhaW4gZnJvbSByZWR1Y2luZyB0aGUgbnVtYmVyIG9m IE1NSU8gd3JpdGVzIHRoYXQgaGF2ZSB0byBiZQo+IGR1cGxpY2F0ZWQgOikKPiAKCkFoIEkgc2Vl LCBzb3JyeSBJIG1pc3VuZGVyc3Rvb2QuIEl0J3MgZGVmaW5pdGVseSBiZXR0ZXIgaWYgdGhpcyBn ZXRzCnRlc3RlZCBvbiBvdGhlciBzeXN0ZW1zIGFzIHdlbGwuCgpUaGFua3MsClNhaQoKLS0gClFV QUxDT01NIElORElBLCBvbiBiZWhhbGYgb2YgUXVhbGNvbW0gSW5ub3ZhdGlvbiBDZW50ZXIsIElu Yy4gaXMgYSAKbWVtYmVyCm9mIENvZGUgQXVyb3JhIEZvcnVtLCBob3N0ZWQgYnkgVGhlIExpbnV4 IEZvdW5kYXRpb24KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KaW9tbXUgbWFpbGluZyBsaXN0CmlvbW11QGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0 dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2lvbW11