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=-4.9 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=no 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 AE048C4708F for ; Wed, 2 Jun 2021 12:04:12 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 4CFA5613B1 for ; Wed, 2 Jun 2021 12:04:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4CFA5613B1 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 9A4976EC4F; Wed, 2 Jun 2021 12:04:10 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 78BE26EC4F; Wed, 2 Jun 2021 12:04:09 +0000 (UTC) IronPort-SDR: 29OnZzDyKtYQFSY68Ocm0DdmQCfBEYtVyp43++KksM935pDQZ+DNVJy9ap/lTNM3LTUqjPYr2s WdoX03HK/mVw== X-IronPort-AV: E=McAfee;i="6200,9189,10002"; a="225058770" X-IronPort-AV: E=Sophos;i="5.83,242,1616482800"; d="scan'208";a="225058770" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 05:04:08 -0700 IronPort-SDR: wud9J/A+CUY8PZ8O4D+jOG/JT6Qtin81Dt3DNRSE22NXFNFByWZsEDZLYpjvR2MyButHtrfBmK W3XzIFWAIXoA== X-IronPort-AV: E=Sophos;i="5.83,242,1616482800"; d="scan'208";a="447378562" Received: from tstaplex-mobl1.ger.corp.intel.com (HELO [10.213.195.193]) ([10.213.195.193]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 05:04:06 -0700 Subject: Re: [Intel-gfx] [RFC PATCH 60/97] drm/i915: Track 'serial' counts for virtual engines To: John Harrison , Matthew Brost References: <20210506191451.77768-1-matthew.brost@intel.com> <20210506191451.77768-61-matthew.brost@intel.com> <20210525175239.GA21324@sdutt-i7> <6f6a1266-fe48-9cf1-beba-0b4463000ca7@linux.intel.com> <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> <018044c0-d238-2060-99a4-a477d225781e@linux.intel.com> <87dd027f-6690-19f9-55c3-40115254fa1c@intel.com> <4dfcfd97-c83e-8483-cec0-d62f0da708b8@linux.intel.com> <1b4044c4-2962-049e-f327-ea7394c95eb7@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <18b178a9-5fc9-b88c-4aae-a6448562659c@linux.intel.com> Date: Wed, 2 Jun 2021 13:04:04 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <1b4044c4-2962-049e-f327-ea7394c95eb7@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jason.ekstrand@intel.com, daniel.vetter@intel.com, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On 02/06/2021 02:20, John Harrison wrote: > On 6/1/2021 02:31, Tvrtko Ursulin wrote: >> On 27/05/2021 18:01, John Harrison wrote: >>> On 5/27/2021 01:53, Tvrtko Ursulin wrote: >>>> On 26/05/2021 19:45, John Harrison wrote: >>>>> On 5/26/2021 01:40, Tvrtko Ursulin wrote: >>>>>> On 25/05/2021 18:52, Matthew Brost wrote: >>>>>>> On Tue, May 25, 2021 at 11:16:12AM +0100, Tvrtko Ursulin wrote: >>>>>>>> >>>>>>>> On 06/05/2021 20:14, Matthew Brost wrote: >>>>>>>>> From: John Harrison >>>>>>>>> >>>>>>>>> The serial number tracking of engines happens at the backend of >>>>>>>>> request submission and was expecting to only be given physical >>>>>>>>> engines. However, in GuC submission mode, the decomposition of >>>>>>>>> virtual >>>>>>>>> to physical engines does not happen in i915. Instead, requests are >>>>>>>>> submitted to their virtual engine mask all the way through to the >>>>>>>>> hardware (i.e. to GuC). This would mean that the heart beat code >>>>>>>>> thinks the physical engines are idle due to the serial number not >>>>>>>>> incrementing. >>>>>>>>> >>>>>>>>> This patch updates the tracking to decompose virtual engines into >>>>>>>>> their physical constituents and tracks the request against >>>>>>>>> each. This >>>>>>>>> is not entirely accurate as the GuC will only be issuing the >>>>>>>>> request >>>>>>>>> to one physical engine. However, it is the best that i915 can >>>>>>>>> do given >>>>>>>>> that it has no knowledge of the GuC's scheduling decisions. >>>>>>>> >>>>>>>> Commit text sounds a bit defeatist. I think instead of making up >>>>>>>> the serial >>>>>>>> counts, which has downsides (could you please document in the >>>>>>>> commit what >>>>>>>> they are), we should think how to design things properly. >>>>>>>> >>>>>>> >>>>>>> IMO, I don't think fixing serial counts is the scope of this >>>>>>> series. We >>>>>>> should focus on getting GuC submission in not cleaning up all the >>>>>>> crap >>>>>>> that is in the i915. Let's make a note of this though so we can >>>>>>> revisit >>>>>>> later. >>>>>> >>>>>> I will say again - commit message implies it is introducing an >>>>>> unspecified downside by not fully fixing an also unspecified >>>>>> issue. It is completely reasonable, and customary even, to ask for >>>>>> both to be documented in the commit message. >>>>> Not sure what exactly is 'unspecified'. I thought the commit >>>>> message described both the problem (heartbeat not running when >>>>> using virtual engines) and the result (heartbeat running on more >>>>> engines than strictly necessary). But in greater detail... >>>>> >>>>> The serial number tracking is a hack for the heartbeat code to know >>>>> whether an engine is busy or idle, and therefore whether it should >>>>> be pinged for aliveness. Whenever a submission is made to an >>>>> engine, the serial number is incremented. The heartbeat code keeps >>>>> a copy of the value. If the value has changed, the engine is busy >>>>> and needs to be pinged. >>>>> >>>>> This works fine for execlist mode where virtual engine >>>>> decomposition is done inside i915. It fails miserably for GuC mode >>>>> where the decomposition is done by the hardware. The reason being >>>>> that the heartbeat code only looks at physical engines but the >>>>> serial count is only incremented on the virtual engine. Thus, the >>>>> heartbeat sees everything as idle and does not ping. >>>> >>>> So hangcheck does not work. Or it works because GuC does it anyway. >>>> Either way, that's one thing to explicitly state in the commit message. >>>> >>>>> This patch decomposes the virtual engines for the sake of >>>>> incrementing the serial count on each sub-engine in order to keep >>>>> the heartbeat code happy. The downside is that now the heartbeat >>>>> sees all sub-engines as busy rather than only the one the >>>>> submission actually ends up on. There really isn't much that can be >>>>> done about that. The heartbeat code is in i915 not GuC, the >>>>> scheduler is in GuC not i915. The only way to improve it is to >>>>> either move the heartbeat code into GuC as well and completely >>>>> disable the i915 side, or add some way for i915 to interrogate GuC >>>>> as to which engines are or are not active. Technically, we do have >>>>> both. GuC has (or at least had) an option to force a context switch >>>>> on every execution quantum pre-emption. However, that is much, >>>>> much, more heavy weight than the heartbeat. For the latter, we do >>>>> (almost) have the engine usage statistics for PMU and such like. >>>>> I'm not sure how much effort it would be to wire that up to the >>>>> heartbeat code instead of using the serial count. >>>>> >>>>> In short, the serial count is ever so slightly inefficient in that >>>>> it causes heartbeat pings on engines which are idle. On the other >>>>> hand, it is way more efficient and simpler than the current >>>>> alternatives. >>>> >>>> And the hack to make hangcheck work creates this inefficiency where >>>> heartbeats are sent to idle engines. Which is probably fine just >>>> needs to be explained. >>>> >>>>> Does that answer the questions? >>>> >>>> With the two points I re-raise clearly explained, possibly even >>>> patch title changed, yeah. I am just wanting for it to be more >>>> easily obvious to patch reader what it is functionally about - not >>>> just what implementation details have been change but why as well. >>>> >>> My understanding is that we don't explain every piece of code in >>> minute detail in every checkin email that touches it. I thought my >>> description was already pretty verbose. I've certainly seen way less >>> informative checkins that apparently made it through review without >>> issue. >>> >>> Regarding the problem statement, I thought this was fairly clear that >>> the heartbeat was broken for virtual engines: >>> >>>     This would mean that the heart beat code >>>     thinks the physical engines are idle due to the serial number not >>>     incrementing. >>> >>> >>> Regarding the inefficiency about heartbeating all physical engines in >>> a virtual engine, again, this seems clear to me: >>> >>>     decompose virtual engines into >>>     their physical constituents and tracks the request against each. >>> This >>>     is not entirely accurate as the GuC will only be issuing the request >>>     to one physical engine. >>> >>> >>> For the subject, I guess you could say "Track 'heartbeat serial' >>> counts for virtual engines". However, the serial tracking count is >>> not explicitly named for heartbeats so it seems inaccurate to rename >>> it for a checkin email subject. >>> >>> If you have a suggestion for better wording then feel free to propose >>> something. >> >> Sigh, I am not asking for more low level detail but for more up to >> point high level naming and high level description. >> >> "drm/i915: Fix hangchek for guc virtual engines" > I would argue that the bug is not a with hangcheck bug and only > tangentially a GuC bug. It is really a bug with the serial number > tracking of virtual engines in general and the lack of support for You argue it is a bug in general but nothing is currently broken apart from hangcheck with GuC virtual engines? :) That could mean, say, that it is not actually broken but designed for the current code base. Maybe "drm/i915: Make hangcheck work with GuC virtual engines" then if you object on the word fix? Would that make it immediately clear why is this patch must have/desirable? > non-execlist backends in the serial number implementation. Hangcheck > makes use of the serial number. It is not clear from the code whether > anything else does currently or used to previously use them. Certainly, Engine pm clearly uses it to know when it is safe to park the engine. I think I asked earlier in the series have the interactions in that area been looked at. I don't know myself, since I think that GuC changes how engine parking is done, but not really familiar. Now that I think of it, there possibly is a patch which keeps all engines unparked for virtual engines, so that's looking okay. > there is no documentation on the serial number declaration in the engine > structure to explain its purpose. Likewise, there is nothing GuC > specific about delaying the decomposition of virtual engines. Any > externally scheduled backed end would do similar. E.g. once the execlist > backend moves to using the DRM scheduler then maybe it will have delayed > decomposition as well, and therefore also fall foul of the missing > serial number updates. I don't think we know yet how drm/scheduler will be used to go that far. >> "..Blah blah, but hack because it is not ideal due xyz which >> needlessly wakes up all engines which has an effect on power yes/no? >> Latency? Throughput when high prio pulse triggers pointless preemption?" > Yes to all the above but that is already true of the heartbeat mechanism > in general and I do not see any documentation in the code as to what the > effect of the heartbeat mechanism is on power, latency, throughput, etc. Difference is current code does not emit heartbeats on idle engines. So if we have a virtual engine built of say four some class engines, then the proposal here is to keep pinging all four in parallel. Even if only single context is executing. I am not saying that cost is big but honestly I don't understand why it is difficult to mention this in the commit message using clear and direct language. > My assumption is that the heartbeat is considered slow enough > periodicity that any performance impact is negligible. And if the system > is loaded to the point where the heartbeat is having an impact then all > engines within the virtual set are going to be in use (because if they > aren't then the system is obviously not heavily loaded), in which case > the heartbeat would be pinging all engines anyway. > >> >> Also, can we fix it properly without introducing inefficiencies? Do we >> even need heartbeats when GuC is in charge of engine resets? And if we >> do can we make them work better? > In short, no, not easily. > > The GuC's internal hang detection and recovery mechanism relies on > pre-emption timeouts for the detection part. However, if only one > context is active on a given engine, there will be no pre-emptions and > thus the GuC will not be able to detect if that context is making > forward progress or not. That's where the heartbeat comes in. It sends a > dummy request on a different context and thus causes a pre-emption to > occur. So the architecture level decision was to keep the heartbeat > enabled even with the GuC submission backend. Unless you are running > OpenCL of course, in which case we turn everything off :(. > > As for doing something better, not easily. GuC is not able to generate > requests itself, so it can't replicate the heartbeat's operation > internally. There is an option to force a context switch to idle on > every quantum expiration. However, that is deemed too intrusive and > costly from a performance viewpoint. It might be possible to add an > independent heartbeat timer to the GuC firmware and use that to trigger > less frequent forced pre-emptions. That would be more efficient and more > targetted. Whether it is worth the effort required is another matter > given how small an impact the heartbeat itself currently is. Well GuC could obviously do it in many ways and not all are expensive. If it can force a context switch on quantum expiration, it could force it on hearbeat expiration as you say. That would actually be more proper design than this kludge which leaves a bad taste regardless how little cost it has. Or it could perhaps track some sort of serials in a shared memory page. But anyway, all I am asking here is that patch subject and commit message are made clear and direct. Here, I add two sentences as what I think is minimum: drm/i915/guc: Make hangcheck work with GuC virtual engines The serial number tracking of engines happens at the backend of request submission and was expecting to only be given physical engines. However, in GuC submission mode, the decomposition of virtual to physical engines does not happen in i915. Instead, requests are submitted to their virtual engine mask all the way through to the hardware (i.e. to GuC). This would mean that the heart beat code thinks the physical engines are idle due to the serial number not incrementing. Which in turns means hangcheck does not work for GuC virtual engines. This patch updates the tracking to decompose virtual engines into their physical constituents and tracks the request against each. This is not entirely accurate as the GuC will only be issuing the request to one physical engine. However, it is the best that i915 can do given that it has no knowledge of the GuC's scheduling decisions. Downside of this is that all physical engines constituting a GuC virtual engine will be periodically unparked (even during just a single context executing) in order to be pinged with a heartbeat request. However the power and performance cost of this is not expected to be measurable (due low frequency of heartbeat pulses) and it is considered an easier option than trying to make changes to GuC firmware. > I would still be my view that the serial count should be fixed anyway. > It is broken for virtual engines. End of story. Whether that actually > affects the users of the count is a separate issue that is dependent > upon those users. But that just changes the severity of the bug, not its > validity. It is clearly not broken for the current codebase, otherwise this patch would come with virtual_execlists_bump_serial and would be called like "drm/i915: Fix hangcheck on virtual engines". :) Regards, Tvrtko 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=-4.9 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=no 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 4D6E4C47083 for ; Wed, 2 Jun 2021 12:04:15 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 0F349613DC for ; Wed, 2 Jun 2021 12:04:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0F349613DC Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id D2ACE6EC50; Wed, 2 Jun 2021 12:04:10 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 78BE26EC4F; Wed, 2 Jun 2021 12:04:09 +0000 (UTC) IronPort-SDR: 29OnZzDyKtYQFSY68Ocm0DdmQCfBEYtVyp43++KksM935pDQZ+DNVJy9ap/lTNM3LTUqjPYr2s WdoX03HK/mVw== X-IronPort-AV: E=McAfee;i="6200,9189,10002"; a="225058770" X-IronPort-AV: E=Sophos;i="5.83,242,1616482800"; d="scan'208";a="225058770" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 05:04:08 -0700 IronPort-SDR: wud9J/A+CUY8PZ8O4D+jOG/JT6Qtin81Dt3DNRSE22NXFNFByWZsEDZLYpjvR2MyButHtrfBmK W3XzIFWAIXoA== X-IronPort-AV: E=Sophos;i="5.83,242,1616482800"; d="scan'208";a="447378562" Received: from tstaplex-mobl1.ger.corp.intel.com (HELO [10.213.195.193]) ([10.213.195.193]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 05:04:06 -0700 To: John Harrison , Matthew Brost References: <20210506191451.77768-1-matthew.brost@intel.com> <20210506191451.77768-61-matthew.brost@intel.com> <20210525175239.GA21324@sdutt-i7> <6f6a1266-fe48-9cf1-beba-0b4463000ca7@linux.intel.com> <15643bd8-a270-a84d-3bd7-5376af7e378c@intel.com> <018044c0-d238-2060-99a4-a477d225781e@linux.intel.com> <87dd027f-6690-19f9-55c3-40115254fa1c@intel.com> <4dfcfd97-c83e-8483-cec0-d62f0da708b8@linux.intel.com> <1b4044c4-2962-049e-f327-ea7394c95eb7@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <18b178a9-5fc9-b88c-4aae-a6448562659c@linux.intel.com> Date: Wed, 2 Jun 2021 13:04:04 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <1b4044c4-2962-049e-f327-ea7394c95eb7@intel.com> Content-Language: en-US Subject: Re: [Intel-gfx] [RFC PATCH 60/97] drm/i915: Track 'serial' counts for virtual engines X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jason.ekstrand@intel.com, daniel.vetter@intel.com, intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Ck9uIDAyLzA2LzIwMjEgMDI6MjAsIEpvaG4gSGFycmlzb24gd3JvdGU6Cj4gT24gNi8xLzIwMjEg MDI6MzEsIFR2cnRrbyBVcnN1bGluIHdyb3RlOgo+PiBPbiAyNy8wNS8yMDIxIDE4OjAxLCBKb2hu IEhhcnJpc29uIHdyb3RlOgo+Pj4gT24gNS8yNy8yMDIxIDAxOjUzLCBUdnJ0a28gVXJzdWxpbiB3 cm90ZToKPj4+PiBPbiAyNi8wNS8yMDIxIDE5OjQ1LCBKb2huIEhhcnJpc29uIHdyb3RlOgo+Pj4+ PiBPbiA1LzI2LzIwMjEgMDE6NDAsIFR2cnRrbyBVcnN1bGluIHdyb3RlOgo+Pj4+Pj4gT24gMjUv MDUvMjAyMSAxODo1MiwgTWF0dGhldyBCcm9zdCB3cm90ZToKPj4+Pj4+PiBPbiBUdWUsIE1heSAy NSwgMjAyMSBhdCAxMToxNjoxMkFNICswMTAwLCBUdnJ0a28gVXJzdWxpbiB3cm90ZToKPj4+Pj4+ Pj4KPj4+Pj4+Pj4gT24gMDYvMDUvMjAyMSAyMDoxNCwgTWF0dGhldyBCcm9zdCB3cm90ZToKPj4+ Pj4+Pj4+IEZyb206IEpvaG4gSGFycmlzb24gPEpvaG4uQy5IYXJyaXNvbkBJbnRlbC5jb20+Cj4+ Pj4+Pj4+Pgo+Pj4+Pj4+Pj4gVGhlIHNlcmlhbCBudW1iZXIgdHJhY2tpbmcgb2YgZW5naW5lcyBo YXBwZW5zIGF0IHRoZSBiYWNrZW5kIG9mCj4+Pj4+Pj4+PiByZXF1ZXN0IHN1Ym1pc3Npb24gYW5k IHdhcyBleHBlY3RpbmcgdG8gb25seSBiZSBnaXZlbiBwaHlzaWNhbAo+Pj4+Pj4+Pj4gZW5naW5l cy4gSG93ZXZlciwgaW4gR3VDIHN1Ym1pc3Npb24gbW9kZSwgdGhlIGRlY29tcG9zaXRpb24gb2Yg Cj4+Pj4+Pj4+PiB2aXJ0dWFsCj4+Pj4+Pj4+PiB0byBwaHlzaWNhbCBlbmdpbmVzIGRvZXMgbm90 IGhhcHBlbiBpbiBpOTE1LiBJbnN0ZWFkLCByZXF1ZXN0cyBhcmUKPj4+Pj4+Pj4+IHN1Ym1pdHRl ZCB0byB0aGVpciB2aXJ0dWFsIGVuZ2luZSBtYXNrIGFsbCB0aGUgd2F5IHRocm91Z2ggdG8gdGhl Cj4+Pj4+Pj4+PiBoYXJkd2FyZSAoaS5lLiB0byBHdUMpLiBUaGlzIHdvdWxkIG1lYW4gdGhhdCB0 aGUgaGVhcnQgYmVhdCBjb2RlCj4+Pj4+Pj4+PiB0aGlua3MgdGhlIHBoeXNpY2FsIGVuZ2luZXMg YXJlIGlkbGUgZHVlIHRvIHRoZSBzZXJpYWwgbnVtYmVyIG5vdAo+Pj4+Pj4+Pj4gaW5jcmVtZW50 aW5nLgo+Pj4+Pj4+Pj4KPj4+Pj4+Pj4+IFRoaXMgcGF0Y2ggdXBkYXRlcyB0aGUgdHJhY2tpbmcg dG8gZGVjb21wb3NlIHZpcnR1YWwgZW5naW5lcyBpbnRvCj4+Pj4+Pj4+PiB0aGVpciBwaHlzaWNh bCBjb25zdGl0dWVudHMgYW5kIHRyYWNrcyB0aGUgcmVxdWVzdCBhZ2FpbnN0IAo+Pj4+Pj4+Pj4g ZWFjaC4gVGhpcwo+Pj4+Pj4+Pj4gaXMgbm90IGVudGlyZWx5IGFjY3VyYXRlIGFzIHRoZSBHdUMg d2lsbCBvbmx5IGJlIGlzc3VpbmcgdGhlIAo+Pj4+Pj4+Pj4gcmVxdWVzdAo+Pj4+Pj4+Pj4gdG8g b25lIHBoeXNpY2FsIGVuZ2luZS4gSG93ZXZlciwgaXQgaXMgdGhlIGJlc3QgdGhhdCBpOTE1IGNh biAKPj4+Pj4+Pj4+IGRvIGdpdmVuCj4+Pj4+Pj4+PiB0aGF0IGl0IGhhcyBubyBrbm93bGVkZ2Ug b2YgdGhlIEd1QydzIHNjaGVkdWxpbmcgZGVjaXNpb25zLgo+Pj4+Pj4+Pgo+Pj4+Pj4+PiBDb21t aXQgdGV4dCBzb3VuZHMgYSBiaXQgZGVmZWF0aXN0LiBJIHRoaW5rIGluc3RlYWQgb2YgbWFraW5n IHVwIAo+Pj4+Pj4+PiB0aGUgc2VyaWFsCj4+Pj4+Pj4+IGNvdW50cywgd2hpY2ggaGFzIGRvd25z aWRlcyAoY291bGQgeW91IHBsZWFzZSBkb2N1bWVudCBpbiB0aGUgCj4+Pj4+Pj4+IGNvbW1pdCB3 aGF0Cj4+Pj4+Pj4+IHRoZXkgYXJlKSwgd2Ugc2hvdWxkIHRoaW5rIGhvdyB0byBkZXNpZ24gdGhp bmdzIHByb3Blcmx5Lgo+Pj4+Pj4+Pgo+Pj4+Pj4+Cj4+Pj4+Pj4gSU1PLCBJIGRvbid0IHRoaW5r IGZpeGluZyBzZXJpYWwgY291bnRzIGlzIHRoZSBzY29wZSBvZiB0aGlzIAo+Pj4+Pj4+IHNlcmll cy4gV2UKPj4+Pj4+PiBzaG91bGQgZm9jdXMgb24gZ2V0dGluZyBHdUMgc3VibWlzc2lvbiBpbiBu b3QgY2xlYW5pbmcgdXAgYWxsIHRoZSAKPj4+Pj4+PiBjcmFwCj4+Pj4+Pj4gdGhhdCBpcyBpbiB0 aGUgaTkxNS4gTGV0J3MgbWFrZSBhIG5vdGUgb2YgdGhpcyB0aG91Z2ggc28gd2UgY2FuIAo+Pj4+ Pj4+IHJldmlzaXQKPj4+Pj4+PiBsYXRlci4KPj4+Pj4+Cj4+Pj4+PiBJIHdpbGwgc2F5IGFnYWlu IC0gY29tbWl0IG1lc3NhZ2UgaW1wbGllcyBpdCBpcyBpbnRyb2R1Y2luZyBhbiAKPj4+Pj4+IHVu c3BlY2lmaWVkIGRvd25zaWRlIGJ5IG5vdCBmdWxseSBmaXhpbmcgYW4gYWxzbyB1bnNwZWNpZmll ZCAKPj4+Pj4+IGlzc3VlLiBJdCBpcyBjb21wbGV0ZWx5IHJlYXNvbmFibGUsIGFuZCBjdXN0b21h cnkgZXZlbiwgdG8gYXNrIGZvciAKPj4+Pj4+IGJvdGggdG8gYmUgZG9jdW1lbnRlZCBpbiB0aGUg Y29tbWl0IG1lc3NhZ2UuCj4+Pj4+IE5vdCBzdXJlIHdoYXQgZXhhY3RseSBpcyAndW5zcGVjaWZp ZWQnLiBJIHRob3VnaHQgdGhlIGNvbW1pdCAKPj4+Pj4gbWVzc2FnZSBkZXNjcmliZWQgYm90aCB0 aGUgcHJvYmxlbSAoaGVhcnRiZWF0IG5vdCBydW5uaW5nIHdoZW4gCj4+Pj4+IHVzaW5nIHZpcnR1 YWwgZW5naW5lcykgYW5kIHRoZSByZXN1bHQgKGhlYXJ0YmVhdCBydW5uaW5nIG9uIG1vcmUgCj4+ Pj4+IGVuZ2luZXMgdGhhbiBzdHJpY3RseSBuZWNlc3NhcnkpLiBCdXQgaW4gZ3JlYXRlciBkZXRh aWwuLi4KPj4+Pj4KPj4+Pj4gVGhlIHNlcmlhbCBudW1iZXIgdHJhY2tpbmcgaXMgYSBoYWNrIGZv ciB0aGUgaGVhcnRiZWF0IGNvZGUgdG8ga25vdyAKPj4+Pj4gd2hldGhlciBhbiBlbmdpbmUgaXMg YnVzeSBvciBpZGxlLCBhbmQgdGhlcmVmb3JlIHdoZXRoZXIgaXQgc2hvdWxkIAo+Pj4+PiBiZSBw aW5nZWQgZm9yIGFsaXZlbmVzcy4gV2hlbmV2ZXIgYSBzdWJtaXNzaW9uIGlzIG1hZGUgdG8gYW4g Cj4+Pj4+IGVuZ2luZSwgdGhlIHNlcmlhbCBudW1iZXIgaXMgaW5jcmVtZW50ZWQuIFRoZSBoZWFy dGJlYXQgY29kZSBrZWVwcyAKPj4+Pj4gYSBjb3B5IG9mIHRoZSB2YWx1ZS4gSWYgdGhlIHZhbHVl IGhhcyBjaGFuZ2VkLCB0aGUgZW5naW5lIGlzIGJ1c3kgCj4+Pj4+IGFuZCBuZWVkcyB0byBiZSBw aW5nZWQuCj4+Pj4+Cj4+Pj4+IFRoaXMgd29ya3MgZmluZSBmb3IgZXhlY2xpc3QgbW9kZSB3aGVy ZSB2aXJ0dWFsIGVuZ2luZSAKPj4+Pj4gZGVjb21wb3NpdGlvbiBpcyBkb25lIGluc2lkZSBpOTE1 LiBJdCBmYWlscyBtaXNlcmFibHkgZm9yIEd1QyBtb2RlIAo+Pj4+PiB3aGVyZSB0aGUgZGVjb21w b3NpdGlvbiBpcyBkb25lIGJ5IHRoZSBoYXJkd2FyZS4gVGhlIHJlYXNvbiBiZWluZyAKPj4+Pj4g dGhhdCB0aGUgaGVhcnRiZWF0IGNvZGUgb25seSBsb29rcyBhdCBwaHlzaWNhbCBlbmdpbmVzIGJ1 dCB0aGUgCj4+Pj4+IHNlcmlhbCBjb3VudCBpcyBvbmx5IGluY3JlbWVudGVkIG9uIHRoZSB2aXJ0 dWFsIGVuZ2luZS4gVGh1cywgdGhlIAo+Pj4+PiBoZWFydGJlYXQgc2VlcyBldmVyeXRoaW5nIGFz IGlkbGUgYW5kIGRvZXMgbm90IHBpbmcuCj4+Pj4KPj4+PiBTbyBoYW5nY2hlY2sgZG9lcyBub3Qg d29yay4gT3IgaXQgd29ya3MgYmVjYXVzZSBHdUMgZG9lcyBpdCBhbnl3YXkuIAo+Pj4+IEVpdGhl ciB3YXksIHRoYXQncyBvbmUgdGhpbmcgdG8gZXhwbGljaXRseSBzdGF0ZSBpbiB0aGUgY29tbWl0 IG1lc3NhZ2UuCj4+Pj4KPj4+Pj4gVGhpcyBwYXRjaCBkZWNvbXBvc2VzIHRoZSB2aXJ0dWFsIGVu Z2luZXMgZm9yIHRoZSBzYWtlIG9mIAo+Pj4+PiBpbmNyZW1lbnRpbmcgdGhlIHNlcmlhbCBjb3Vu dCBvbiBlYWNoIHN1Yi1lbmdpbmUgaW4gb3JkZXIgdG8ga2VlcCAKPj4+Pj4gdGhlIGhlYXJ0YmVh dCBjb2RlIGhhcHB5LiBUaGUgZG93bnNpZGUgaXMgdGhhdCBub3cgdGhlIGhlYXJ0YmVhdCAKPj4+ Pj4gc2VlcyBhbGwgc3ViLWVuZ2luZXMgYXMgYnVzeSByYXRoZXIgdGhhbiBvbmx5IHRoZSBvbmUg dGhlIAo+Pj4+PiBzdWJtaXNzaW9uIGFjdHVhbGx5IGVuZHMgdXAgb24uIFRoZXJlIHJlYWxseSBp c24ndCBtdWNoIHRoYXQgY2FuIGJlIAo+Pj4+PiBkb25lIGFib3V0IHRoYXQuIFRoZSBoZWFydGJl YXQgY29kZSBpcyBpbiBpOTE1IG5vdCBHdUMsIHRoZSAKPj4+Pj4gc2NoZWR1bGVyIGlzIGluIEd1 QyBub3QgaTkxNS4gVGhlIG9ubHkgd2F5IHRvIGltcHJvdmUgaXQgaXMgdG8gCj4+Pj4+IGVpdGhl ciBtb3ZlIHRoZSBoZWFydGJlYXQgY29kZSBpbnRvIEd1QyBhcyB3ZWxsIGFuZCBjb21wbGV0ZWx5 IAo+Pj4+PiBkaXNhYmxlIHRoZSBpOTE1IHNpZGUsIG9yIGFkZCBzb21lIHdheSBmb3IgaTkxNSB0 byBpbnRlcnJvZ2F0ZSBHdUMgCj4+Pj4+IGFzIHRvIHdoaWNoIGVuZ2luZXMgYXJlIG9yIGFyZSBu b3QgYWN0aXZlLiBUZWNobmljYWxseSwgd2UgZG8gaGF2ZSAKPj4+Pj4gYm90aC4gR3VDIGhhcyAo b3IgYXQgbGVhc3QgaGFkKSBhbiBvcHRpb24gdG8gZm9yY2UgYSBjb250ZXh0IHN3aXRjaCAKPj4+ Pj4gb24gZXZlcnkgZXhlY3V0aW9uIHF1YW50dW0gcHJlLWVtcHRpb24uIEhvd2V2ZXIsIHRoYXQg aXMgbXVjaCwgCj4+Pj4+IG11Y2gsIG1vcmUgaGVhdnkgd2VpZ2h0IHRoYW4gdGhlIGhlYXJ0YmVh dC4gRm9yIHRoZSBsYXR0ZXIsIHdlIGRvIAo+Pj4+PiAoYWxtb3N0KSBoYXZlIHRoZSBlbmdpbmUg dXNhZ2Ugc3RhdGlzdGljcyBmb3IgUE1VIGFuZCBzdWNoIGxpa2UuIAo+Pj4+PiBJJ20gbm90IHN1 cmUgaG93IG11Y2ggZWZmb3J0IGl0IHdvdWxkIGJlIHRvIHdpcmUgdGhhdCB1cCB0byB0aGUgCj4+ Pj4+IGhlYXJ0YmVhdCBjb2RlIGluc3RlYWQgb2YgdXNpbmcgdGhlIHNlcmlhbCBjb3VudC4KPj4+ Pj4KPj4+Pj4gSW4gc2hvcnQsIHRoZSBzZXJpYWwgY291bnQgaXMgZXZlciBzbyBzbGlnaHRseSBp bmVmZmljaWVudCBpbiB0aGF0IAo+Pj4+PiBpdCBjYXVzZXMgaGVhcnRiZWF0IHBpbmdzIG9uIGVu Z2luZXMgd2hpY2ggYXJlIGlkbGUuIE9uIHRoZSBvdGhlciAKPj4+Pj4gaGFuZCwgaXQgaXMgd2F5 IG1vcmUgZWZmaWNpZW50IGFuZCBzaW1wbGVyIHRoYW4gdGhlIGN1cnJlbnQgCj4+Pj4+IGFsdGVy bmF0aXZlcy4KPj4+Pgo+Pj4+IEFuZCB0aGUgaGFjayB0byBtYWtlIGhhbmdjaGVjayB3b3JrIGNy ZWF0ZXMgdGhpcyBpbmVmZmljaWVuY3kgd2hlcmUgCj4+Pj4gaGVhcnRiZWF0cyBhcmUgc2VudCB0 byBpZGxlIGVuZ2luZXMuIFdoaWNoIGlzIHByb2JhYmx5IGZpbmUganVzdCAKPj4+PiBuZWVkcyB0 byBiZSBleHBsYWluZWQuCj4+Pj4KPj4+Pj4gRG9lcyB0aGF0IGFuc3dlciB0aGUgcXVlc3Rpb25z Pwo+Pj4+Cj4+Pj4gV2l0aCB0aGUgdHdvIHBvaW50cyBJIHJlLXJhaXNlIGNsZWFybHkgZXhwbGFp bmVkLCBwb3NzaWJseSBldmVuIAo+Pj4+IHBhdGNoIHRpdGxlIGNoYW5nZWQsIHllYWguIEkgYW0g anVzdCB3YW50aW5nIGZvciBpdCB0byBiZSBtb3JlIAo+Pj4+IGVhc2lseSBvYnZpb3VzIHRvIHBh dGNoIHJlYWRlciB3aGF0IGl0IGlzIGZ1bmN0aW9uYWxseSBhYm91dCAtIG5vdCAKPj4+PiBqdXN0 IHdoYXQgaW1wbGVtZW50YXRpb24gZGV0YWlscyBoYXZlIGJlZW4gY2hhbmdlIGJ1dCB3aHkgYXMg d2VsbC4KPj4+Pgo+Pj4gTXkgdW5kZXJzdGFuZGluZyBpcyB0aGF0IHdlIGRvbid0IGV4cGxhaW4g ZXZlcnkgcGllY2Ugb2YgY29kZSBpbiAKPj4+IG1pbnV0ZSBkZXRhaWwgaW4gZXZlcnkgY2hlY2tp biBlbWFpbCB0aGF0IHRvdWNoZXMgaXQuIEkgdGhvdWdodCBteSAKPj4+IGRlc2NyaXB0aW9uIHdh cyBhbHJlYWR5IHByZXR0eSB2ZXJib3NlLiBJJ3ZlIGNlcnRhaW5seSBzZWVuIHdheSBsZXNzIAo+ Pj4gaW5mb3JtYXRpdmUgY2hlY2tpbnMgdGhhdCBhcHBhcmVudGx5IG1hZGUgaXQgdGhyb3VnaCBy ZXZpZXcgd2l0aG91dCAKPj4+IGlzc3VlLgo+Pj4KPj4+IFJlZ2FyZGluZyB0aGUgcHJvYmxlbSBz dGF0ZW1lbnQsIEkgdGhvdWdodCB0aGlzIHdhcyBmYWlybHkgY2xlYXIgdGhhdCAKPj4+IHRoZSBo ZWFydGJlYXQgd2FzIGJyb2tlbiBmb3IgdmlydHVhbCBlbmdpbmVzOgo+Pj4KPj4+IMKgwqDCoCBU aGlzIHdvdWxkIG1lYW4gdGhhdCB0aGUgaGVhcnQgYmVhdCBjb2RlCj4+PiDCoMKgwqAgdGhpbmtz IHRoZSBwaHlzaWNhbCBlbmdpbmVzIGFyZSBpZGxlIGR1ZSB0byB0aGUgc2VyaWFsIG51bWJlciBu b3QKPj4+IMKgwqDCoCBpbmNyZW1lbnRpbmcuCj4+Pgo+Pj4KPj4+IFJlZ2FyZGluZyB0aGUgaW5l ZmZpY2llbmN5IGFib3V0IGhlYXJ0YmVhdGluZyBhbGwgcGh5c2ljYWwgZW5naW5lcyBpbiAKPj4+ IGEgdmlydHVhbCBlbmdpbmUsIGFnYWluLCB0aGlzIHNlZW1zIGNsZWFyIHRvIG1lOgo+Pj4KPj4+ IMKgwqDCoCBkZWNvbXBvc2UgdmlydHVhbCBlbmdpbmVzIGludG8KPj4+IMKgwqDCoCB0aGVpciBw aHlzaWNhbCBjb25zdGl0dWVudHMgYW5kIHRyYWNrcyB0aGUgcmVxdWVzdCBhZ2FpbnN0IGVhY2gu IAo+Pj4gVGhpcwo+Pj4gwqDCoMKgIGlzIG5vdCBlbnRpcmVseSBhY2N1cmF0ZSBhcyB0aGUgR3VD IHdpbGwgb25seSBiZSBpc3N1aW5nIHRoZSByZXF1ZXN0Cj4+PiDCoMKgwqAgdG8gb25lIHBoeXNp Y2FsIGVuZ2luZS4KPj4+Cj4+Pgo+Pj4gRm9yIHRoZSBzdWJqZWN0LCBJIGd1ZXNzIHlvdSBjb3Vs ZCBzYXkgIlRyYWNrICdoZWFydGJlYXQgc2VyaWFsJyAKPj4+IGNvdW50cyBmb3IgdmlydHVhbCBl bmdpbmVzIi4gSG93ZXZlciwgdGhlIHNlcmlhbCB0cmFja2luZyBjb3VudCBpcyAKPj4+IG5vdCBl eHBsaWNpdGx5IG5hbWVkIGZvciBoZWFydGJlYXRzIHNvIGl0IHNlZW1zIGluYWNjdXJhdGUgdG8g cmVuYW1lIAo+Pj4gaXQgZm9yIGEgY2hlY2tpbiBlbWFpbCBzdWJqZWN0Lgo+Pj4KPj4+IElmIHlv dSBoYXZlIGEgc3VnZ2VzdGlvbiBmb3IgYmV0dGVyIHdvcmRpbmcgdGhlbiBmZWVsIGZyZWUgdG8g cHJvcG9zZSAKPj4+IHNvbWV0aGluZy4KPj4KPj4gU2lnaCwgSSBhbSBub3QgYXNraW5nIGZvciBt b3JlIGxvdyBsZXZlbCBkZXRhaWwgYnV0IGZvciBtb3JlIHVwIHRvIAo+PiBwb2ludCBoaWdoIGxl dmVsIG5hbWluZyBhbmQgaGlnaCBsZXZlbCBkZXNjcmlwdGlvbi4KPj4KPj4gImRybS9pOTE1OiBG aXggaGFuZ2NoZWsgZm9yIGd1YyB2aXJ0dWFsIGVuZ2luZXMiCj4gSSB3b3VsZCBhcmd1ZSB0aGF0 IHRoZSBidWcgaXMgbm90IGEgd2l0aCBoYW5nY2hlY2sgYnVnIGFuZCBvbmx5IAo+IHRhbmdlbnRp YWxseSBhIEd1QyBidWcuIEl0IGlzIHJlYWxseSBhIGJ1ZyB3aXRoIHRoZSBzZXJpYWwgbnVtYmVy IAo+IHRyYWNraW5nIG9mIHZpcnR1YWwgZW5naW5lcyBpbiBnZW5lcmFsIGFuZCB0aGUgbGFjayBv ZiBzdXBwb3J0IGZvciAKCllvdSBhcmd1ZSBpdCBpcyBhIGJ1ZyBpbiBnZW5lcmFsIGJ1dCBub3Ro aW5nIGlzIGN1cnJlbnRseSBicm9rZW4gYXBhcnQgCmZyb20gaGFuZ2NoZWNrIHdpdGggR3VDIHZp cnR1YWwgZW5naW5lcz8gOikgVGhhdCBjb3VsZCBtZWFuLCBzYXksIHRoYXQgCml0IGlzIG5vdCBh Y3R1YWxseSBicm9rZW4gYnV0IGRlc2lnbmVkIGZvciB0aGUgY3VycmVudCBjb2RlIGJhc2UuCgpN YXliZSAiZHJtL2k5MTU6IE1ha2UgaGFuZ2NoZWNrIHdvcmsgd2l0aCBHdUMgdmlydHVhbCBlbmdp bmVzIiB0aGVuIGlmIAp5b3Ugb2JqZWN0IG9uIHRoZSB3b3JkIGZpeD8gV291bGQgdGhhdCBtYWtl IGl0IGltbWVkaWF0ZWx5IGNsZWFyIHdoeSBpcyAKdGhpcyBwYXRjaCBtdXN0IGhhdmUvZGVzaXJh YmxlPwoKPiBub24tZXhlY2xpc3QgYmFja2VuZHMgaW4gdGhlIHNlcmlhbCBudW1iZXIgaW1wbGVt ZW50YXRpb24uIEhhbmdjaGVjayAKPiBtYWtlcyB1c2Ugb2YgdGhlIHNlcmlhbCBudW1iZXIuIEl0 IGlzIG5vdCBjbGVhciBmcm9tIHRoZSBjb2RlIHdoZXRoZXIgCj4gYW55dGhpbmcgZWxzZSBkb2Vz IGN1cnJlbnRseSBvciB1c2VkIHRvIHByZXZpb3VzbHkgdXNlIHRoZW0uIENlcnRhaW5seSwgCgpF bmdpbmUgcG0gY2xlYXJseSB1c2VzIGl0IHRvIGtub3cgd2hlbiBpdCBpcyBzYWZlIHRvIHBhcmsg dGhlIGVuZ2luZS4gSSAKdGhpbmsgSSBhc2tlZCBlYXJsaWVyIGluIHRoZSBzZXJpZXMgaGF2ZSB0 aGUgaW50ZXJhY3Rpb25zIGluIHRoYXQgYXJlYSAKYmVlbiBsb29rZWQgYXQuIEkgZG9uJ3Qga25v dyBteXNlbGYsIHNpbmNlIEkgdGhpbmsgdGhhdCBHdUMgY2hhbmdlcyBob3cgCmVuZ2luZSBwYXJr aW5nIGlzIGRvbmUsIGJ1dCBub3QgcmVhbGx5IGZhbWlsaWFyLiBOb3cgdGhhdCBJIHRoaW5rIG9m IGl0LCAKdGhlcmUgcG9zc2libHkgaXMgYSBwYXRjaCB3aGljaCBrZWVwcyBhbGwgZW5naW5lcyB1 bnBhcmtlZCBmb3IgdmlydHVhbCAKZW5naW5lcywgc28gdGhhdCdzIGxvb2tpbmcgb2theS4KCj4g dGhlcmUgaXMgbm8gZG9jdW1lbnRhdGlvbiBvbiB0aGUgc2VyaWFsIG51bWJlciBkZWNsYXJhdGlv biBpbiB0aGUgZW5naW5lIAo+IHN0cnVjdHVyZSB0byBleHBsYWluIGl0cyBwdXJwb3NlLiBMaWtl d2lzZSwgdGhlcmUgaXMgbm90aGluZyBHdUMgCj4gc3BlY2lmaWMgYWJvdXQgZGVsYXlpbmcgdGhl IGRlY29tcG9zaXRpb24gb2YgdmlydHVhbCBlbmdpbmVzLiBBbnkgCj4gZXh0ZXJuYWxseSBzY2hl ZHVsZWQgYmFja2VkIGVuZCB3b3VsZCBkbyBzaW1pbGFyLiBFLmcuIG9uY2UgdGhlIGV4ZWNsaXN0 IAo+IGJhY2tlbmQgbW92ZXMgdG8gdXNpbmcgdGhlIERSTSBzY2hlZHVsZXIgdGhlbiBtYXliZSBp dCB3aWxsIGhhdmUgZGVsYXllZCAKPiBkZWNvbXBvc2l0aW9uIGFzIHdlbGwsIGFuZCB0aGVyZWZv cmUgYWxzbyBmYWxsIGZvdWwgb2YgdGhlIG1pc3NpbmcgCj4gc2VyaWFsIG51bWJlciB1cGRhdGVz LgoKSSBkb24ndCB0aGluayB3ZSBrbm93IHlldCBob3cgZHJtL3NjaGVkdWxlciB3aWxsIGJlIHVz ZWQgdG8gZ28gdGhhdCBmYXIuCgo+PiAiLi5CbGFoIGJsYWgsIGJ1dCBoYWNrIGJlY2F1c2UgaXQg aXMgbm90IGlkZWFsIGR1ZSB4eXogd2hpY2ggCj4+IG5lZWRsZXNzbHkgd2FrZXMgdXAgYWxsIGVu Z2luZXMgd2hpY2ggaGFzIGFuIGVmZmVjdCBvbiBwb3dlciB5ZXMvbm8/IAo+PiBMYXRlbmN5PyBU aHJvdWdocHV0IHdoZW4gaGlnaCBwcmlvIHB1bHNlIHRyaWdnZXJzIHBvaW50bGVzcyBwcmVlbXB0 aW9uPyIKPiBZZXMgdG8gYWxsIHRoZSBhYm92ZSBidXQgdGhhdCBpcyBhbHJlYWR5IHRydWUgb2Yg dGhlIGhlYXJ0YmVhdCBtZWNoYW5pc20gCj4gaW4gZ2VuZXJhbCBhbmQgSSBkbyBub3Qgc2VlIGFu eSBkb2N1bWVudGF0aW9uIGluIHRoZSBjb2RlIGFzIHRvIHdoYXQgdGhlIAo+IGVmZmVjdCBvZiB0 aGUgaGVhcnRiZWF0IG1lY2hhbmlzbSBpcyBvbiBwb3dlciwgbGF0ZW5jeSwgdGhyb3VnaHB1dCwg ZXRjLiAKCkRpZmZlcmVuY2UgaXMgY3VycmVudCBjb2RlIGRvZXMgbm90IGVtaXQgaGVhcnRiZWF0 cyBvbiBpZGxlIGVuZ2luZXMuIFNvIAppZiB3ZSBoYXZlIGEgdmlydHVhbCBlbmdpbmUgYnVpbHQg b2Ygc2F5IGZvdXIgc29tZSBjbGFzcyBlbmdpbmVzLCB0aGVuIAp0aGUgcHJvcG9zYWwgaGVyZSBp cyB0byBrZWVwIHBpbmdpbmcgYWxsIGZvdXIgaW4gcGFyYWxsZWwuIEV2ZW4gaWYgb25seSAKc2lu Z2xlIGNvbnRleHQgaXMgZXhlY3V0aW5nLiBJIGFtIG5vdCBzYXlpbmcgdGhhdCBjb3N0IGlzIGJp ZyBidXQgCmhvbmVzdGx5IEkgZG9uJ3QgdW5kZXJzdGFuZCB3aHkgaXQgaXMgZGlmZmljdWx0IHRv IG1lbnRpb24gdGhpcyBpbiB0aGUgCmNvbW1pdCBtZXNzYWdlIHVzaW5nIGNsZWFyIGFuZCBkaXJl Y3QgbGFuZ3VhZ2UuCgo+IE15IGFzc3VtcHRpb24gaXMgdGhhdCB0aGUgaGVhcnRiZWF0IGlzIGNv bnNpZGVyZWQgc2xvdyBlbm91Z2ggCj4gcGVyaW9kaWNpdHkgdGhhdCBhbnkgcGVyZm9ybWFuY2Ug aW1wYWN0IGlzIG5lZ2xpZ2libGUuIEFuZCBpZiB0aGUgc3lzdGVtIAo+IGlzIGxvYWRlZCB0byB0 aGUgcG9pbnQgd2hlcmUgdGhlIGhlYXJ0YmVhdCBpcyBoYXZpbmcgYW4gaW1wYWN0IHRoZW4gYWxs IAo+IGVuZ2luZXMgd2l0aGluIHRoZSB2aXJ0dWFsIHNldCBhcmUgZ29pbmcgdG8gYmUgaW4gdXNl IChiZWNhdXNlIGlmIHRoZXkgCj4gYXJlbid0IHRoZW4gdGhlIHN5c3RlbSBpcyBvYnZpb3VzbHkg bm90IGhlYXZpbHkgbG9hZGVkKSwgaW4gd2hpY2ggY2FzZSAKPiB0aGUgaGVhcnRiZWF0IHdvdWxk IGJlIHBpbmdpbmcgYWxsIGVuZ2luZXMgYW55d2F5Lgo+IAo+Pgo+PiBBbHNvLCBjYW4gd2UgZml4 IGl0IHByb3Blcmx5IHdpdGhvdXQgaW50cm9kdWNpbmcgaW5lZmZpY2llbmNpZXM/IERvIHdlIAo+ PiBldmVuIG5lZWQgaGVhcnRiZWF0cyB3aGVuIEd1QyBpcyBpbiBjaGFyZ2Ugb2YgZW5naW5lIHJl c2V0cz8gQW5kIGlmIHdlIAo+PiBkbyBjYW4gd2UgbWFrZSB0aGVtIHdvcmsgYmV0dGVyPwo+IElu IHNob3J0LCBubywgbm90IGVhc2lseS4KPiAKPiBUaGUgR3VDJ3MgaW50ZXJuYWwgaGFuZyBkZXRl Y3Rpb24gYW5kIHJlY292ZXJ5IG1lY2hhbmlzbSByZWxpZXMgb24gCj4gcHJlLWVtcHRpb24gdGlt ZW91dHMgZm9yIHRoZSBkZXRlY3Rpb24gcGFydC4gSG93ZXZlciwgaWYgb25seSBvbmUgCj4gY29u dGV4dCBpcyBhY3RpdmUgb24gYSBnaXZlbiBlbmdpbmUsIHRoZXJlIHdpbGwgYmUgbm8gcHJlLWVt cHRpb25zIGFuZCAKPiB0aHVzIHRoZSBHdUMgd2lsbCBub3QgYmUgYWJsZSB0byBkZXRlY3QgaWYg dGhhdCBjb250ZXh0IGlzIG1ha2luZyAKPiBmb3J3YXJkIHByb2dyZXNzIG9yIG5vdC4gVGhhdCdz IHdoZXJlIHRoZSBoZWFydGJlYXQgY29tZXMgaW4uIEl0IHNlbmRzIGEgCj4gZHVtbXkgcmVxdWVz dCBvbiBhIGRpZmZlcmVudCBjb250ZXh0IGFuZCB0aHVzIGNhdXNlcyBhIHByZS1lbXB0aW9uIHRv IAo+IG9jY3VyLiBTbyB0aGUgYXJjaGl0ZWN0dXJlIGxldmVsIGRlY2lzaW9uIHdhcyB0byBrZWVw IHRoZSBoZWFydGJlYXQgCj4gZW5hYmxlZCBldmVuIHdpdGggdGhlIEd1QyBzdWJtaXNzaW9uIGJh Y2tlbmQuIFVubGVzcyB5b3UgYXJlIHJ1bm5pbmcgCj4gT3BlbkNMIG9mIGNvdXJzZSwgaW4gd2hp Y2ggY2FzZSB3ZSB0dXJuIGV2ZXJ5dGhpbmcgb2ZmIDooLgo+IAo+IEFzIGZvciBkb2luZyBzb21l dGhpbmcgYmV0dGVyLCBub3QgZWFzaWx5LiBHdUMgaXMgbm90IGFibGUgdG8gZ2VuZXJhdGUgCj4g cmVxdWVzdHMgaXRzZWxmLCBzbyBpdCBjYW4ndCByZXBsaWNhdGUgdGhlIGhlYXJ0YmVhdCdzIG9w ZXJhdGlvbiAKPiBpbnRlcm5hbGx5LiBUaGVyZSBpcyBhbiBvcHRpb24gdG8gZm9yY2UgYSBjb250 ZXh0IHN3aXRjaCB0byBpZGxlIG9uIAo+IGV2ZXJ5IHF1YW50dW0gZXhwaXJhdGlvbi4gSG93ZXZl ciwgdGhhdCBpcyBkZWVtZWQgdG9vIGludHJ1c2l2ZSBhbmQgCj4gY29zdGx5IGZyb20gYSBwZXJm b3JtYW5jZSB2aWV3cG9pbnQuIEl0IG1pZ2h0IGJlIHBvc3NpYmxlIHRvIGFkZCBhbiAKPiBpbmRl cGVuZGVudCBoZWFydGJlYXQgdGltZXIgdG8gdGhlIEd1QyBmaXJtd2FyZSBhbmQgdXNlIHRoYXQg dG8gdHJpZ2dlciAKPiBsZXNzIGZyZXF1ZW50IGZvcmNlZCBwcmUtZW1wdGlvbnMuIFRoYXQgd291 bGQgYmUgbW9yZSBlZmZpY2llbnQgYW5kIG1vcmUgCj4gdGFyZ2V0dGVkLiBXaGV0aGVyIGl0IGlz IHdvcnRoIHRoZSBlZmZvcnQgcmVxdWlyZWQgaXMgYW5vdGhlciBtYXR0ZXIgCj4gZ2l2ZW4gaG93 IHNtYWxsIGFuIGltcGFjdCB0aGUgaGVhcnRiZWF0IGl0c2VsZiBjdXJyZW50bHkgaXMuCgpXZWxs IEd1QyBjb3VsZCBvYnZpb3VzbHkgZG8gaXQgaW4gbWFueSB3YXlzIGFuZCBub3QgYWxsIGFyZSBl eHBlbnNpdmUuIApJZiBpdCBjYW4gZm9yY2UgYSBjb250ZXh0IHN3aXRjaCBvbiBxdWFudHVtIGV4 cGlyYXRpb24sIGl0IGNvdWxkIGZvcmNlIAppdCBvbiBoZWFyYmVhdCBleHBpcmF0aW9uIGFzIHlv dSBzYXkuIFRoYXQgd291bGQgYWN0dWFsbHkgYmUgbW9yZSBwcm9wZXIgCmRlc2lnbiB0aGFuIHRo aXMga2x1ZGdlIHdoaWNoIGxlYXZlcyBhIGJhZCB0YXN0ZSByZWdhcmRsZXNzIGhvdyBsaXR0bGUg CmNvc3QgaXQgaGFzLiBPciBpdCBjb3VsZCBwZXJoYXBzIHRyYWNrIHNvbWUgc29ydCBvZiBzZXJp YWxzIGluIGEgc2hhcmVkIAptZW1vcnkgcGFnZS4KCkJ1dCBhbnl3YXksIGFsbCBJIGFtIGFza2lu ZyBoZXJlIGlzIHRoYXQgcGF0Y2ggc3ViamVjdCBhbmQgY29tbWl0IAptZXNzYWdlIGFyZSBtYWRl IGNsZWFyIGFuZCBkaXJlY3QuIEhlcmUsIEkgYWRkIHR3byBzZW50ZW5jZXMgYXMgd2hhdCBJIAp0 aGluayBpcyBtaW5pbXVtOgoKZHJtL2k5MTUvZ3VjOiBNYWtlIGhhbmdjaGVjayB3b3JrIHdpdGgg R3VDIHZpcnR1YWwgZW5naW5lcwoKVGhlIHNlcmlhbCBudW1iZXIgdHJhY2tpbmcgb2YgZW5naW5l cyBoYXBwZW5zIGF0IHRoZSBiYWNrZW5kIG9mCnJlcXVlc3Qgc3VibWlzc2lvbiBhbmQgd2FzIGV4 cGVjdGluZyB0byBvbmx5IGJlIGdpdmVuIHBoeXNpY2FsCmVuZ2luZXMuIEhvd2V2ZXIsIGluIEd1 QyBzdWJtaXNzaW9uIG1vZGUsIHRoZSBkZWNvbXBvc2l0aW9uIG9mIHZpcnR1YWwKdG8gcGh5c2lj YWwgZW5naW5lcyBkb2VzIG5vdCBoYXBwZW4gaW4gaTkxNS4gSW5zdGVhZCwgcmVxdWVzdHMgYXJl CnN1Ym1pdHRlZCB0byB0aGVpciB2aXJ0dWFsIGVuZ2luZSBtYXNrIGFsbCB0aGUgd2F5IHRocm91 Z2ggdG8gdGhlCmhhcmR3YXJlIChpLmUuIHRvIEd1QykuIFRoaXMgd291bGQgbWVhbiB0aGF0IHRo ZSBoZWFydCBiZWF0IGNvZGUKdGhpbmtzIHRoZSBwaHlzaWNhbCBlbmdpbmVzIGFyZSBpZGxlIGR1 ZSB0byB0aGUgc2VyaWFsIG51bWJlciBub3QKaW5jcmVtZW50aW5nLiA8YWRkZWQ+V2hpY2ggaW4g dHVybnMgbWVhbnMgaGFuZ2NoZWNrIGRvZXMgbm90IHdvcmsgZm9yIApHdUMgdmlydHVhbCBlbmdp bmVzLjwvYWRkZWQ+CgpUaGlzIHBhdGNoIHVwZGF0ZXMgdGhlIHRyYWNraW5nIHRvIGRlY29tcG9z ZSB2aXJ0dWFsIGVuZ2luZXMgaW50bwp0aGVpciBwaHlzaWNhbCBjb25zdGl0dWVudHMgYW5kIHRy YWNrcyB0aGUgcmVxdWVzdCBhZ2FpbnN0IGVhY2guIFRoaXMKaXMgbm90IGVudGlyZWx5IGFjY3Vy YXRlIGFzIHRoZSBHdUMgd2lsbCBvbmx5IGJlIGlzc3VpbmcgdGhlIHJlcXVlc3QKdG8gb25lIHBo eXNpY2FsIGVuZ2luZS4gSG93ZXZlciwgaXQgaXMgdGhlIGJlc3QgdGhhdCBpOTE1IGNhbiBkbyBn aXZlbgp0aGF0IGl0IGhhcyBubyBrbm93bGVkZ2Ugb2YgdGhlIEd1QydzIHNjaGVkdWxpbmcgZGVj aXNpb25zLgoKPGFkZGVkPkRvd25zaWRlIG9mIHRoaXMgaXMgdGhhdCBhbGwgcGh5c2ljYWwgZW5n aW5lcyBjb25zdGl0dXRpbmcgYSBHdUMgCnZpcnR1YWwgZW5naW5lIHdpbGwgYmUgcGVyaW9kaWNh bGx5IHVucGFya2VkIChldmVuIGR1cmluZyBqdXN0IGEgc2luZ2xlIApjb250ZXh0IGV4ZWN1dGlu ZykgaW4gb3JkZXIgdG8gYmUgcGluZ2VkIHdpdGggYSBoZWFydGJlYXQgcmVxdWVzdC4gCkhvd2V2 ZXIgdGhlIHBvd2VyIGFuZCBwZXJmb3JtYW5jZSBjb3N0IG9mIHRoaXMgaXMgbm90IGV4cGVjdGVk IHRvIGJlIAptZWFzdXJhYmxlIChkdWUgbG93IGZyZXF1ZW5jeSBvZiBoZWFydGJlYXQgcHVsc2Vz KSBhbmQgaXQgaXMgY29uc2lkZXJlZCAKYW4gZWFzaWVyIG9wdGlvbiB0aGFuIHRyeWluZyB0byBt YWtlIGNoYW5nZXMgdG8gR3VDIGZpcm13YXJlLjwvYWRkZWQ+Cgo+IEkgd291bGQgc3RpbGwgYmUg bXkgdmlldyB0aGF0IHRoZSBzZXJpYWwgY291bnQgc2hvdWxkIGJlIGZpeGVkIGFueXdheS4gCj4g SXQgaXMgYnJva2VuIGZvciB2aXJ0dWFsIGVuZ2luZXMuIEVuZCBvZiBzdG9yeS4gV2hldGhlciB0 aGF0IGFjdHVhbGx5IAo+IGFmZmVjdHMgdGhlIHVzZXJzIG9mIHRoZSBjb3VudCBpcyBhIHNlcGFy YXRlIGlzc3VlIHRoYXQgaXMgZGVwZW5kZW50IAo+IHVwb24gdGhvc2UgdXNlcnMuIEJ1dCB0aGF0 IGp1c3QgY2hhbmdlcyB0aGUgc2V2ZXJpdHkgb2YgdGhlIGJ1Zywgbm90IGl0cyAKPiB2YWxpZGl0 eS4KCkl0IGlzIGNsZWFybHkgbm90IGJyb2tlbiBmb3IgdGhlIGN1cnJlbnQgY29kZWJhc2UsIG90 aGVyd2lzZSB0aGlzIHBhdGNoIAp3b3VsZCBjb21lIHdpdGggdmlydHVhbF9leGVjbGlzdHNfYnVt cF9zZXJpYWwgYW5kIHdvdWxkIGJlIGNhbGxlZCBsaWtlIAoiZHJtL2k5MTU6IEZpeCBoYW5nY2hl Y2sgb24gdmlydHVhbCBlbmdpbmVzIi4gOikKClJlZ2FyZHMsCgpUdnJ0a28KX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlz dApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==