From mboxrd@z Thu Jan 1 00:00:00 1970 From: zongbox@gmail.com (Zong Li) Date: Tue, 6 Nov 2018 09:55:05 +0800 Subject: SBI extension proposal In-Reply-To: <453c1060-b8d8-3be0-d1cb-586f8b62123c@wdc.com> References: <7f2a546a-6ebb-43c6-83a0-5e712ec2e2c7@wdc.com> <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> <5725574a-60c3-26f4-565b-4498c757a8f8@wdc.com> <453c1060-b8d8-3be0-d1cb-586f8b62123c@wdc.com> Message-ID: To: linux-riscv@lists.infradead.org List-Id: linux-riscv.lists.infradead.org Atish Patra ? 2018?11?6? ?? ??2:52??? > > On 11/5/18 5:51 AM, Nick Kossifidis wrote: > > ???? 2018-11-03 02:00, Atish Patra ??????: > >> On 11/2/18 4:45 PM, Nick Kossifidis wrote: > >>> ???? 2018-11-03 01:12, Atish Patra ??????: > >>>> On 11/2/18 8:25 AM, Nick Kossifidis wrote: > >>>>> Hello Atish and thanks for bringing this up, > >>>>> > >>>>> ???? 2018-10-31 20:23, Atish Patra ??????: > >>>>>> Here is a proposal to make SBI a flexible and extensible interface. > >>>>>> It is based on the foundation policy of RISC-V i.e. modularity and > >>>>>> openness. It is designed in such a way that it introduces very few > >>>>>> new > >>>>>> mandatory SBI APIs that are absolutely required to maintain > >>>>>> backward > >>>>>> compatibility. Everything else is optional so that it remains an > >>>>>> open > >>>>>> standard yet robust. > >>>>>> > >>>>>> 1. Introduction: > >>>>>> ---------------- > >>>>>> The current RISC-V SBI only defines a few mandatory functions such > >>>>>> as > >>>>>> inter-processor interrupts (IPI) interface, reprogramming timer, > >>>>>> serial > >>>>>> console and memory barrier instructions. The existing SBI > >>>>>> documentation > >>>>>> can be found here [1]. Many important functionalities such as power > >>>>>> management/cpu-hotplug are not yet defined due to difficulties in > >>>>>> accommodating modifications without breaking the backward > >>>>>> compatibility > >>>>>> with the current interface. > >>>>>> > >>>>>> Its design is inspired by Power State Coordination Interface (PSCI) > >>>>>> from > >>>>>> ARM world. However, it adds only two new mandatory SBI calls > >>>>>> providing > >>>>>> version information and supported APIs, unlike PSCI where a > >>>>>> significant > >>>>>> number of functions are mandatory. The version of the existing SBI > >>>>>> will > >>>>>> be defined as a minimum version(0.1) which will always be backward > >>>>>> compatible. Similarly, any Linux kernel with newer feature will > >>>>>> fall > >>>>>> back if an older version of SBI does not support the updated > >>>>>> capabilities. Both the operating system and SEE can be implemented > >>>>>> to > >>>>>> be two way backward compatible. > >>>>>> > >>>>>> 2. New functions: > >>>>>> ----------------- > >>>>>> > >>>>>> -- u32 sbi_get_version(void): > >>>>>> > >>>>>> Returns the current SBI version implemented by the firmware. > >>>>>> version: uint32: Bits[31:16] Major Version > >>>>>> Bits[15:0] Minor Version > >>>>>> > >>>>>> The existing SBI version can be 0.1. The proposed version will be > >>>>>> at > >>>>>> 0.2 > >>>>>> A different major version may indicate possible incompatible > >>>>>> functions. > >>>>>> A different minor version must be compatible with each other even > >>>>>> if > >>>>>> they have a higher number of features. > >>>>>> > >>>>>> -- u32 sbi_check_api(unsigned long start_api_id, unsigned long > >>>>>> count): > >>>>>> > >>>>>> Accepts a start_api_id as an argument and returns if start_api_id > >>>>>> to > >>>>>> (start_api_id + count - 1) are supported or not. > >>>>>> The API numbering scheme is described in section 3. > >>>>>> > >>>>>> A count is introduced so that a range of APIs can be checked at one > >>>>>> SBI > >>>>>> call to minimize the M-mode traps. > >>>>>> > >>>>> > >>>>> Is this really needed ? We can determine the SBI version from > >>>>> sbi_get_version, why > >>>>> include an SBI call to perform a check that can easily be performed > >>>>> by > >>>>> the caller > >>>>> instead ? > >>>>> > >>>> > >>>> This API is still in discussion. Probably, an API returning bitmask > >>>> of > >>>> all the features make more sense ? > >>>> > >>>> However, I feel a separate API is required from sbi_get_version as > >>>> there vendors can choose not to implement some of the features that > >>>> is > >>>> specified by a version as most of the API set are optional. > >>>> > >>> > >>> We can always rely on the SBI_NOT_SUPPORTED error code you've already > >>> included ;-) > >> > >> > >> That's what sbi_check_api will return if a single API or set of API is > >> not supported. We potentially can return it from individual function > >> calls but having a separate API helps in avoiding making those calls > >> in first place from supervisor level. > >> > >> If we use a bitmask for capabilities we'll be limited by > >>> the encoding. > >>> > >> That was the reason sbi_check_api was introduced. But looking back, I > >> wonder if we ever have more than 24 SBI APIs to deal with!! > >> > >> > >>>>>> -- int sbi_hart_up(unsigned long hartid, unsigned long start, > >>>>>> unsigned > >>>>>> long priv) > >>>>>> > >>>>>> Brings up "hartid" either during initial boot or after a > >>>>>> sbi_hart_down > >>>>>> SBI call. > >>>>>> > >>>>>> "start" points to a runtime-specified address where a hart can > >>>>>> enter > >>>>>> into supervisor mode. This must be a physical address. > >>>>>> > >>>>>> "priv" is a private data that caller can use to pass information > >>>>>> about > >>>>>> execution context. > >>>>>> > >>>>>> Return the appropriate SBI error code. > >>>>>> > >>>>>> -- int sbi_hart_suspend(u32 state, unsigned long resume_entry, > >>>>>> unsigned > >>>>>> long priv) > >>>>>> > >>>>>> Suspends the calling hart to a particular power state. Suspended > >>>>>> hart > >>>>>> will automatically wake-up based on some wakeup events at > >>>>>> resume_entry > >>>>>> physical address. > >>>>>> > >>>>>> "priv" is a private data that caller can use to pass information > >>>>>> about > >>>>>> execution context. The SBI implementation must save a copy so that > >>>>>> caller can reuse while restoring hart from suspend. > >>>>>> > >>>>>> Return the appropriate SBI error code. > >>>>>> > >>>>>> -- int sbi_hart_down() > >>>>>> > >>>>>> It powers off the hart and will be used in cpu-hotplug. > >>>>>> Only individual hart can remove itself from supervisor mode. It can > >>>>>> be > >>>>>> moved to normal state only by sbi_hart_up function. > >>>>>> > >>>>>> Return the appropriate SBI error code. > >>>>>> > >>>>>> -- u32 sbi_hart_state(unsigned long hartid) > >>>>>> > >>>>>> Returns the RISCV_POWER_STATE for a specific hartid. This will help > >>>>>> make > >>>>>> kexec like functionality more robust. > >>>>>> > >>>>> > >>>>> Instead of the above I believe it would be cleaner and simpler to > >>>>> have > >>>>> an sbi_get_hart_state and an sbi_set_hart_state call. This way we > >>>>> can > >>>>> better handle state transitions and, handle ON/OFF/STANDBY/RETENTION > >>>>> and any other state we come up with, without adding extra sbi calls. > >>>>> > >>>> > >>>> When do you want to use sbi_set_hart_state ? > >>>> The power states will be modified as a part of sbi_hart_down or > >>>> sbi_shutdown/suspend calls anyways. > >>>> > >>> > >>> The idea is to have sbi_set_hart_state instead of > >>> sbi_hart_down/shutdown/suspend/etc. > >>> Instead of having different calls for different states we just have > >>> two > >>> calls, one > >>> to get the state and one to set it. This way we have fewer calls and > >>> if > >>> we add a > >>> new state we can add it without having to add a new call. > >>> > >> Ahh I see it now. IMHO, having explicit names makes more sense. > >> > >> > >>>>>> -- void sbi_system_shutdown() > >>>>>> > >>>>>> Powers off the entire system. > >>>>>> > >>>>> > >>>>> Don't we already have that ? What's the difference between > >>>>> sbi_system_shutdown > >>>>> and sbi_shutdown ? Does it make sense to use sbi_shutdown and leave > >>>>> the > >>>>> system > >>>>> on with all the harts down ? Maybe we can just say that sbi_shutdown > >>>>> also > >>>>> powers down the system and rename it to sbi_system_shutdown with the > >>>>> same > >>>>> function ID. > >>>>> > >>>> > >>>> Yeah. That's a better. > >>>> > >>>> > >>>>>> 3. SBI API ID numbering scheme: > >>>>>> ------------------------------ > >>>>>> An API Set is a set of SBI APIs which collectively implement some > >>>>>> kind of feature/functionality. > >>>>>> > >>>>>> Let's say SBI API ID is u32 then > >>>>>> Bit[31:24] = API Set Number > >>>>>> Bit[23:0] = API Number within API Set > >>>>>> > >>>>>> Here are few API Sets for SBI v0.2: > >>>>>> 1. Base APIs > >>>>>> API Set Number: 0x0 > >>>>>> Description: Base APIs mandatory for any SBI version > >>>>>> > >>>>>> 2. HART PM APIs > >>>>>> API Set Number: 0x1 > >>>>>> Description: Hart UP/Down/Suspend APIs for per-Hart > >>>>>> power management > >>>>>> > >>>>>> 3. System PM APIs > >>>>>> API Set Number; 0x2 > >>>>>> Description: System Shutdown/Reboot/Suspend for system-level > >>>>>> power management > >>>>>> > >>>>>> 4. Vendor APIs > >>>>>> API Set Number: 0xff > >>>>>> Description: Vendor specific APIs. > >>>>>> There is a possibility that different vendors can choose to assign > >>>>>> same API numbers for different functionality. In that case, vendor > >>>>>> specific strings in Device Tree can be used to verify if a specific > >>>>>> API belongs to the intended vendor or not. > >>>>>> > >>>>> > >>>>> I understand the rationale behind this but I believe it's better to > >>>>> call them services or functions instead of APIs, they are not sets > >>>>> of APIs the way I see it. Also since we are moving that path why > >>>>> call > >>>>> it SBI and restrict it only to be used by the supervisor ? I'd love > >>>>> to > >>>>> have another category for the secure monitor calls for example, > >>>>> but on the software architecture that we are discussing on the TEE > >>>>> group, such calls can also originate from U mode or HS/HU modes. > >>>>> The same goes for vendor specific calls, there are lots of use case > >>>>> scenarios where vendors would like to be able to call their stuff > >>>>> from U mode for example (e.g. a user space library talking to a > >>>>> smart card directly). > >>>>> > >>>>> I suggest we rename it from SBI to something more generic that is > >>>>> not > >>>>> defined by who is calling it but by what we are calling, which in > >>>>> this > >>>>> case is the firmware (FBI?). > >>>> > >>>> possible conflict with a very famous law enforcement agency :) :). > >>>> > >>>> Jokes aside, renaming to something more generic is a good idea. But > >>>> it > >>>> will probably break a ton of documentation/spec in RISC-V which I > >>>> don't want to deal with right now. May be in future versions ? > >>>> > >>> > >>> I get that updating the documentation can be a pain, I can help with > >>> that if you want (and I promise I'll stay away from law enforcement > >>> agencies !). I suggest we do the renaming as early as possible > >>> because we are going to carry it for a long time instead and it'll > >>> only get harder to change later on. > >>> > >> Thanks. I guess we need Palmer/Andrew to pitch in first on this before > >> we decide anything. > >> > > > > I just noticed that on privilege spec, SBI stands for System Binary > > Interface, > > not Supervisor Binary Interface as mentioned here: > > https://github.com/riscv/riscv-sbi-doc/blob/master/riscv-sbi.md > > > > "System" is broader than "supervisor" since it doesn't imply the mode > > where > > the calls originate from. On the other hand it doesn't say anything > > about > > who is calling or who it calls, it's very broad, it can be an interface > > between anything. > > > I guess you found a typo in privileged spec. > > It is mentioned as supervisor binary interface (SBI) in chapter 1 > (https://github.com/riscv/riscv-isa-manual/blob/master/src/intro.tex#L126) > while system binary interface (SBI) in Chapter 4. > (https://github.com/riscv/riscv-isa-manual/blob/master/src/supervisor.tex#L9) > > I have filed a bug in github for now. > Which API set is suitable for trigger module use? We need to invoke a SBI call to set trigger module. We can use one SBI call for setting mcontrol, icount, itrigger and etrigger(decide which types inside this SBI), or four SBI calls for them respectively. On the other hand, I saw the perf branch in riscv-pk repository, maybe we should consider it together? But actually, to be exact, one is debugging use, and another one is tracing use. 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=-5.7 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING, 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 A8B2FC0044C for ; Tue, 6 Nov 2018 01:55:37 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 6936F20827 for ; Tue, 6 Nov 2018 01:55:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="clLkGFku"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="QnYBq2Cf" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6936F20827 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:To:Subject:Message-ID:Date:From: In-Reply-To:References:MIME-Version:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Em92JwUAYXYcAfcxgrQqkdSOA2H50xeEd9HfPim4fFo=; b=clLkGFkuTnIh8Q Kluz3VPw5Q7QODpXIy7phbcrMGzBjyX2sHpNKgJABfJCqDDi08fzvR7GXdGETRwRg2vNEemuFAD1Q cxpYlzLyi1rdKGCo+Jucp3gwQ3tTASaYY0VJmrSHOQjBB+KowcSvXYYpsTb0BOosqD8uildtcAJlM +8k9JNdiWJ0ynq0alKADGU1Io+vjfhvVRTTWPl9npUX7SL8dqS6aiNLtmPRqrb+s+IkMIsUyl0sMH MjYfkVV0zKnIf8GT8CNXNssaIq+Xfv/rU15Mozm2ccUkVPUGCy1OJHLz7+MX6kiaf01k6n7t0zk0N JCAbcDnYtT9sCTNJGdew==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gJqad-0000sH-1T; Tue, 06 Nov 2018 01:55:35 +0000 Received: from mail-it1-x142.google.com ([2607:f8b0:4864:20::142]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gJqaX-0000rj-T3 for linux-riscv@lists.infradead.org; Tue, 06 Nov 2018 01:55:32 +0000 Received: by mail-it1-x142.google.com with SMTP id m15so15609453itl.4 for ; Mon, 05 Nov 2018 17:55:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=oatZ+CHUsWjYNNIYeK329OcVPL5As1eUCYT5KIlAJws=; b=QnYBq2CfviBfLDaKTyg74C8R+0llSeep8kv6rFlhgkmoZQw9ALnMQK0CIbE8VKOOfb 0+IrOvAbtZ5Fn5RHEbyJb/sKxaiM7EdpjMVwVxwm6IH9o90pcT/3iq/nTwweWE7aYaaZ nAYNHVeoXGS1A3X9iktz4SmBgnY7WnLIhIgMdg5S4o0A04VDQb526B+Zkn6FPLsjj34L X5NJSNAo1TR5O6AbxzAblxEn8Z4KE5G+p+QnU59+Aaute+2iZhk10Sf10Pixs0xBEUoG FNW1uaJuuEBDJ5EdFeK17U4xsh8VB1x3uk7PADKXz/4JEQpfjjMtK1QPDQBQPJtGa33C hcQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=oatZ+CHUsWjYNNIYeK329OcVPL5As1eUCYT5KIlAJws=; b=pV04I+328QIC24Wfil/5JsasHUDdv+6rZaQvhJHluZJEBdgHTZR7uogQtP8AEZSl1p IZnMYUq3kh5/YhlsXDwtQKQzyG+izFrwMPxM3MP67xI1Q2Chm30zn2VstH+k1gG/m9Hr dkP3N/7RmiSM7zpDu0Ban8vl5b+rEUbPfbN+x7kNT4khV1uqRsjisOjMTLYZAd2OWvAY NVAMj3vTBLNNddBU99EnoL5Gev2JOs/UaTofLPdftPq7Cvgv6Q51oSEw1p3/Skblol8C 2GO5s5FLBC/sAWCMGGpQg2hUwhRVjhQBYNspc0ASbTs2tW3jWu2U1EqnoewNFdzWb0Um uCjg== X-Gm-Message-State: AGRZ1gIdp7kHr1VXeBDQpLsr272H7PVUjZhCIWUfjuzsu/7kxFpAenYh fDGxkVaOy08yvzxg/tkL1ZoDFzzJ7Fe4i/pzM3+ygRmD3z4= X-Google-Smtp-Source: AJdET5cvtDHB06zUQ3YYhfiiBRwABz712Czw+hnGlij+19M54AN98iDCcBKyCw4csqV8tdlQMaAuEocc9uDBphd7vjg= X-Received: by 2002:a02:1e5c:: with SMTP id m89-v6mr21522522jad.124.1541469316613; Mon, 05 Nov 2018 17:55:16 -0800 (PST) MIME-Version: 1.0 References: <7f2a546a-6ebb-43c6-83a0-5e712ec2e2c7@wdc.com> <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> <5725574a-60c3-26f4-565b-4498c757a8f8@wdc.com> <453c1060-b8d8-3be0-d1cb-586f8b62123c@wdc.com> In-Reply-To: <453c1060-b8d8-3be0-d1cb-586f8b62123c@wdc.com> From: Zong Li Date: Tue, 6 Nov 2018 09:55:05 +0800 Message-ID: Subject: Re: SBI extension proposal To: atish.patra@wdc.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181105_175529_968371_247B0DFC X-CRM114-Status: GOOD ( 36.77 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: mark.rutland@arm.com, Zong Li , Damien.LeMoal@wdc.com, olof.johansson@gmail.com, Andrew Waterman , alankao@andestech.com, Anup Patel , Palmer Dabbelt , rjones@redhat.com, hch@infradead.org, Vincent Chen , Michael Clark , Arnd Bergmann , paul.walmsley@sifive.com, mick@ics.forth.gr, linux-riscv@lists.infradead.org, abner.chang@hpe.com, David.Abdurachmanov@cern.ch Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org Message-ID: <20181106015505.HqWOvKFn-J2k4RCnsg9JgFzN2uFIccRr3cSvkAYdTro@z> QXRpc2ggUGF0cmEgPGF0aXNoLnBhdHJhQHdkYy5jb20+IOaWvCAyMDE45bm0MTHmnIg25pelIOmA seS6jCDkuIrljYgyOjUy5a+r6YGT77yaCj4KPiBPbiAxMS81LzE4IDU6NTEgQU0sIE5pY2sgS29z c2lmaWRpcyB3cm90ZToKPiA+IM6jz4TOuc+CIDIwMTgtMTEtMDMgMDI6MDAsIEF0aXNoIFBhdHJh IM6tzrPPgc6xz4jOtToKPiA+PiBPbiAxMS8yLzE4IDQ6NDUgUE0sIE5pY2sgS29zc2lmaWRpcyB3 cm90ZToKPiA+Pj4gzqPPhM65z4IgMjAxOC0xMS0wMyAwMToxMiwgQXRpc2ggUGF0cmEgzq3Os8+B zrHPiM61Ogo+ID4+Pj4gT24gMTEvMi8xOCA4OjI1IEFNLCBOaWNrIEtvc3NpZmlkaXMgd3JvdGU6 Cj4gPj4+Pj4gSGVsbG8gQXRpc2ggYW5kIHRoYW5rcyBmb3IgYnJpbmdpbmcgdGhpcyB1cCwKPiA+ Pj4+Pgo+ID4+Pj4+IM6jz4TOuc+CIDIwMTgtMTAtMzEgMjA6MjMsIEF0aXNoIFBhdHJhIM6tzrPP gc6xz4jOtToKPiA+Pj4+Pj4gSGVyZSBpcyBhIHByb3Bvc2FsIHRvIG1ha2UgU0JJIGEgZmxleGli bGUgYW5kIGV4dGVuc2libGUgaW50ZXJmYWNlLgo+ID4+Pj4+PiBJdCBpcyBiYXNlZCBvbiB0aGUg Zm91bmRhdGlvbiBwb2xpY3kgb2YgUklTQy1WIGkuZS4gbW9kdWxhcml0eSBhbmQKPiA+Pj4+Pj4g b3Blbm5lc3MuIEl0IGlzIGRlc2lnbmVkIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBpbnRyb2R1Y2Vz IHZlcnkgZmV3Cj4gPj4+Pj4+IG5ldwo+ID4+Pj4+PiBtYW5kYXRvcnkgU0JJIEFQSXMgdGhhdCBh cmUgYWJzb2x1dGVseSByZXF1aXJlZCB0byBtYWludGFpbgo+ID4+Pj4+PiBiYWNrd2FyZAo+ID4+ Pj4+PiBjb21wYXRpYmlsaXR5LiBFdmVyeXRoaW5nIGVsc2UgaXMgb3B0aW9uYWwgc28gdGhhdCBp dCByZW1haW5zIGFuCj4gPj4+Pj4+IG9wZW4KPiA+Pj4+Pj4gc3RhbmRhcmQgeWV0IHJvYnVzdC4K PiA+Pj4+Pj4KPiA+Pj4+Pj4gMS4gSW50cm9kdWN0aW9uOgo+ID4+Pj4+PiAtLS0tLS0tLS0tLS0t LS0tCj4gPj4+Pj4+IFRoZSBjdXJyZW50IFJJU0MtViBTQkkgb25seSBkZWZpbmVzIGEgZmV3IG1h bmRhdG9yeSBmdW5jdGlvbnMgc3VjaAo+ID4+Pj4+PiBhcwo+ID4+Pj4+PiBpbnRlci1wcm9jZXNz b3IgaW50ZXJydXB0cyAoSVBJKSBpbnRlcmZhY2UsIHJlcHJvZ3JhbW1pbmcgdGltZXIsCj4gPj4+ Pj4+IHNlcmlhbAo+ID4+Pj4+PiBjb25zb2xlIGFuZCBtZW1vcnkgYmFycmllciBpbnN0cnVjdGlv bnMuIFRoZSBleGlzdGluZyBTQkkKPiA+Pj4+Pj4gZG9jdW1lbnRhdGlvbgo+ID4+Pj4+PiBjYW4g YmUgZm91bmQgaGVyZSBbMV0uIE1hbnkgaW1wb3J0YW50IGZ1bmN0aW9uYWxpdGllcyBzdWNoIGFz IHBvd2VyCj4gPj4+Pj4+IG1hbmFnZW1lbnQvY3B1LWhvdHBsdWcgYXJlIG5vdCB5ZXQgZGVmaW5l ZCBkdWUgdG8gZGlmZmljdWx0aWVzIGluCj4gPj4+Pj4+IGFjY29tbW9kYXRpbmcgbW9kaWZpY2F0 aW9ucyB3aXRob3V0IGJyZWFraW5nIHRoZSBiYWNrd2FyZAo+ID4+Pj4+PiBjb21wYXRpYmlsaXR5 Cj4gPj4+Pj4+IHdpdGggdGhlIGN1cnJlbnQgaW50ZXJmYWNlLgo+ID4+Pj4+Pgo+ID4+Pj4+PiBJ dHMgZGVzaWduIGlzIGluc3BpcmVkIGJ5IFBvd2VyIFN0YXRlIENvb3JkaW5hdGlvbiBJbnRlcmZh Y2UgKFBTQ0kpCj4gPj4+Pj4+IGZyb20KPiA+Pj4+Pj4gQVJNIHdvcmxkLiBIb3dldmVyLCBpdCBh ZGRzIG9ubHkgdHdvIG5ldyBtYW5kYXRvcnkgU0JJIGNhbGxzCj4gPj4+Pj4+IHByb3ZpZGluZwo+ ID4+Pj4+PiB2ZXJzaW9uIGluZm9ybWF0aW9uIGFuZCBzdXBwb3J0ZWQgQVBJcywgdW5saWtlIFBT Q0kgd2hlcmUgYQo+ID4+Pj4+PiBzaWduaWZpY2FudAo+ID4+Pj4+PiBudW1iZXIgb2YgZnVuY3Rp b25zIGFyZSBtYW5kYXRvcnkuIFRoZSB2ZXJzaW9uIG9mIHRoZSBleGlzdGluZyBTQkkKPiA+Pj4+ Pj4gd2lsbAo+ID4+Pj4+PiBiZSBkZWZpbmVkIGFzIGEgbWluaW11bSB2ZXJzaW9uKDAuMSkgd2hp Y2ggd2lsbCBhbHdheXMgYmUgYmFja3dhcmQKPiA+Pj4+Pj4gY29tcGF0aWJsZS4gU2ltaWxhcmx5 LCBhbnkgTGludXgga2VybmVsIHdpdGggbmV3ZXIgZmVhdHVyZSB3aWxsCj4gPj4+Pj4+IGZhbGwK PiA+Pj4+Pj4gYmFjayBpZiBhbiBvbGRlciB2ZXJzaW9uIG9mIFNCSSBkb2VzIG5vdCBzdXBwb3J0 IHRoZSB1cGRhdGVkCj4gPj4+Pj4+IGNhcGFiaWxpdGllcy4gQm90aCB0aGUgb3BlcmF0aW5nIHN5 c3RlbSBhbmQgU0VFIGNhbiBiZSBpbXBsZW1lbnRlZAo+ID4+Pj4+PiB0bwo+ID4+Pj4+PiBiZSB0 d28gd2F5IGJhY2t3YXJkIGNvbXBhdGlibGUuCj4gPj4+Pj4+Cj4gPj4+Pj4+IDIuIE5ldyBmdW5j dGlvbnM6Cj4gPj4+Pj4+IC0tLS0tLS0tLS0tLS0tLS0tCj4gPj4+Pj4+Cj4gPj4+Pj4+IC0tIHUz MiBzYmlfZ2V0X3ZlcnNpb24odm9pZCk6Cj4gPj4+Pj4+Cj4gPj4+Pj4+IFJldHVybnMgdGhlIGN1 cnJlbnQgU0JJIHZlcnNpb24gaW1wbGVtZW50ZWQgYnkgdGhlIGZpcm13YXJlLgo+ID4+Pj4+PiB2 ZXJzaW9uOiB1aW50MzI6IEJpdHNbMzE6MTZdIE1ham9yIFZlcnNpb24KPiA+Pj4+Pj4gICAgICAg ICAgICAgICAgIEJpdHNbMTU6MF0gTWlub3IgVmVyc2lvbgo+ID4+Pj4+Pgo+ID4+Pj4+PiBUaGUg ZXhpc3RpbmcgU0JJIHZlcnNpb24gY2FuIGJlIDAuMS4gVGhlIHByb3Bvc2VkIHZlcnNpb24gd2ls bCBiZQo+ID4+Pj4+PiBhdAo+ID4+Pj4+PiAwLjIKPiA+Pj4+Pj4gQSBkaWZmZXJlbnQgbWFqb3Ig dmVyc2lvbiBtYXkgaW5kaWNhdGUgcG9zc2libGUgaW5jb21wYXRpYmxlCj4gPj4+Pj4+IGZ1bmN0 aW9ucy4KPiA+Pj4+Pj4gQSBkaWZmZXJlbnQgbWlub3IgdmVyc2lvbiBtdXN0IGJlIGNvbXBhdGli bGUgd2l0aCBlYWNoIG90aGVyIGV2ZW4KPiA+Pj4+Pj4gaWYKPiA+Pj4+Pj4gdGhleSBoYXZlIGEg aGlnaGVyIG51bWJlciBvZiBmZWF0dXJlcy4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gLS0gdTMyIHNiaV9j aGVja19hcGkodW5zaWduZWQgbG9uZyBzdGFydF9hcGlfaWQsIHVuc2lnbmVkIGxvbmcKPiA+Pj4+ Pj4gY291bnQpOgo+ID4+Pj4+Pgo+ID4+Pj4+PiBBY2NlcHRzIGEgc3RhcnRfYXBpX2lkIGFzIGFu IGFyZ3VtZW50IGFuZCByZXR1cm5zIGlmIHN0YXJ0X2FwaV9pZAo+ID4+Pj4+PiB0bwo+ID4+Pj4+ PiAoc3RhcnRfYXBpX2lkICsgY291bnQgLSAxKSBhcmUgc3VwcG9ydGVkIG9yIG5vdC4KPiA+Pj4+ Pj4gVGhlIEFQSSBudW1iZXJpbmcgc2NoZW1lIGlzIGRlc2NyaWJlZCBpbiBzZWN0aW9uIDMuCj4g Pj4+Pj4+Cj4gPj4+Pj4+IEEgY291bnQgaXMgaW50cm9kdWNlZCBzbyB0aGF0IGEgcmFuZ2Ugb2Yg QVBJcyBjYW4gYmUgY2hlY2tlZCBhdCBvbmUKPiA+Pj4+Pj4gU0JJCj4gPj4+Pj4+IGNhbGwgdG8g bWluaW1pemUgdGhlIE0tbW9kZSB0cmFwcy4KPiA+Pj4+Pj4KPiA+Pj4+Pgo+ID4+Pj4+IElzIHRo aXMgcmVhbGx5IG5lZWRlZCA/IFdlIGNhbiBkZXRlcm1pbmUgdGhlIFNCSSB2ZXJzaW9uIGZyb20K PiA+Pj4+PiBzYmlfZ2V0X3ZlcnNpb24sIHdoeQo+ID4+Pj4+IGluY2x1ZGUgYW4gU0JJIGNhbGwg dG8gcGVyZm9ybSBhIGNoZWNrIHRoYXQgY2FuIGVhc2lseSBiZSBwZXJmb3JtZWQKPiA+Pj4+PiBi eQo+ID4+Pj4+IHRoZSBjYWxsZXIKPiA+Pj4+PiBpbnN0ZWFkID8KPiA+Pj4+Pgo+ID4+Pj4KPiA+ Pj4+IFRoaXMgQVBJIGlzIHN0aWxsIGluIGRpc2N1c3Npb24uIFByb2JhYmx5LCBhbiBBUEkgcmV0 dXJuaW5nIGJpdG1hc2sKPiA+Pj4+IG9mCj4gPj4+PiBhbGwgdGhlIGZlYXR1cmVzIG1ha2UgbW9y ZSBzZW5zZSA/Cj4gPj4+Pgo+ID4+Pj4gSG93ZXZlciwgSSBmZWVsIGEgc2VwYXJhdGUgQVBJIGlz IHJlcXVpcmVkIGZyb20gc2JpX2dldF92ZXJzaW9uIGFzCj4gPj4+PiB0aGVyZSB2ZW5kb3JzIGNh biBjaG9vc2Ugbm90IHRvIGltcGxlbWVudCBzb21lIG9mIHRoZSBmZWF0dXJlcyB0aGF0Cj4gPj4+ PiBpcwo+ID4+Pj4gc3BlY2lmaWVkIGJ5IGEgdmVyc2lvbiBhcyBtb3N0IG9mIHRoZSBBUEkgc2V0 IGFyZSBvcHRpb25hbC4KPiA+Pj4+Cj4gPj4+Cj4gPj4+IFdlIGNhbiBhbHdheXMgcmVseSBvbiB0 aGUgU0JJX05PVF9TVVBQT1JURUQgZXJyb3IgY29kZSB5b3UndmUgYWxyZWFkeQo+ID4+PiBpbmNs dWRlZCA7LSkKPiA+Pgo+ID4+Cj4gPj4gVGhhdCdzIHdoYXQgc2JpX2NoZWNrX2FwaSB3aWxsIHJl dHVybiBpZiBhIHNpbmdsZSBBUEkgb3Igc2V0IG9mIEFQSSBpcwo+ID4+IG5vdCBzdXBwb3J0ZWQu IFdlIHBvdGVudGlhbGx5IGNhbiByZXR1cm4gaXQgZnJvbSBpbmRpdmlkdWFsIGZ1bmN0aW9uCj4g Pj4gY2FsbHMgYnV0IGhhdmluZyBhIHNlcGFyYXRlIEFQSSBoZWxwcyBpbiBhdm9pZGluZyBtYWtp bmcgdGhvc2UgY2FsbHMKPiA+PiBpbiBmaXJzdCBwbGFjZSBmcm9tIHN1cGVydmlzb3IgbGV2ZWwu Cj4gPj4KPiA+PiBJZiB3ZSB1c2UgYSBiaXRtYXNrIGZvciBjYXBhYmlsaXRpZXMgd2UnbGwgYmUg bGltaXRlZCBieQo+ID4+PiB0aGUgZW5jb2RpbmcuCj4gPj4+Cj4gPj4gVGhhdCB3YXMgdGhlIHJl YXNvbiBzYmlfY2hlY2tfYXBpIHdhcyBpbnRyb2R1Y2VkLiBCdXQgbG9va2luZyBiYWNrLCBJCj4g Pj4gd29uZGVyIGlmIHdlIGV2ZXIgaGF2ZSBtb3JlIHRoYW4gMjQgU0JJIEFQSXMgdG8gZGVhbCB3 aXRoISEKPiA+Pgo+ID4+Cj4gPj4+Pj4+IC0tIGludCBzYmlfaGFydF91cCh1bnNpZ25lZCBsb25n IGhhcnRpZCwgdW5zaWduZWQgbG9uZyBzdGFydCwKPiA+Pj4+Pj4gdW5zaWduZWQKPiA+Pj4+Pj4g bG9uZyBwcml2KQo+ID4+Pj4+Pgo+ID4+Pj4+PiBCcmluZ3MgdXAgImhhcnRpZCIgZWl0aGVyIGR1 cmluZyBpbml0aWFsIGJvb3Qgb3IgYWZ0ZXIgYQo+ID4+Pj4+PiBzYmlfaGFydF9kb3duCj4gPj4+ Pj4+IFNCSSBjYWxsLgo+ID4+Pj4+Pgo+ID4+Pj4+PiAic3RhcnQiIHBvaW50cyB0byBhIHJ1bnRp bWUtc3BlY2lmaWVkIGFkZHJlc3Mgd2hlcmUgYSBoYXJ0IGNhbgo+ID4+Pj4+PiBlbnRlcgo+ID4+ Pj4+PiBpbnRvIHN1cGVydmlzb3IgbW9kZS4gVGhpcyBtdXN0IGJlIGEgcGh5c2ljYWwgYWRkcmVz cy4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gInByaXYiIGlzIGEgcHJpdmF0ZSBkYXRhIHRoYXQgY2FsbGVy IGNhbiB1c2UgdG8gcGFzcyBpbmZvcm1hdGlvbgo+ID4+Pj4+PiBhYm91dAo+ID4+Pj4+PiBleGVj dXRpb24gY29udGV4dC4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gUmV0dXJuIHRoZSBhcHByb3ByaWF0ZSBT QkkgZXJyb3IgY29kZS4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gLS0gaW50IHNiaV9oYXJ0X3N1c3BlbmQo dTMyIHN0YXRlLCB1bnNpZ25lZCBsb25nIHJlc3VtZV9lbnRyeSwKPiA+Pj4+Pj4gdW5zaWduZWQK PiA+Pj4+Pj4gbG9uZyBwcml2KQo+ID4+Pj4+Pgo+ID4+Pj4+PiBTdXNwZW5kcyB0aGUgY2FsbGlu ZyBoYXJ0IHRvIGEgcGFydGljdWxhciBwb3dlciBzdGF0ZS4gU3VzcGVuZGVkCj4gPj4+Pj4+IGhh cnQKPiA+Pj4+Pj4gd2lsbCBhdXRvbWF0aWNhbGx5IHdha2UtdXAgYmFzZWQgb24gc29tZSB3YWtl dXAgZXZlbnRzIGF0Cj4gPj4+Pj4+IHJlc3VtZV9lbnRyeQo+ID4+Pj4+PiBwaHlzaWNhbCBhZGRy ZXNzLgo+ID4+Pj4+Pgo+ID4+Pj4+PiAicHJpdiIgaXMgYSBwcml2YXRlIGRhdGEgdGhhdCBjYWxs ZXIgY2FuIHVzZSB0byBwYXNzIGluZm9ybWF0aW9uCj4gPj4+Pj4+IGFib3V0Cj4gPj4+Pj4+IGV4 ZWN1dGlvbiBjb250ZXh0LiBUaGUgU0JJIGltcGxlbWVudGF0aW9uIG11c3Qgc2F2ZSBhIGNvcHkg c28gdGhhdAo+ID4+Pj4+PiBjYWxsZXIgY2FuIHJldXNlIHdoaWxlIHJlc3RvcmluZyBoYXJ0IGZy b20gc3VzcGVuZC4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gUmV0dXJuIHRoZSBhcHByb3ByaWF0ZSBTQkkg ZXJyb3IgY29kZS4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gLS0gaW50IHNiaV9oYXJ0X2Rvd24oKQo+ID4+ Pj4+Pgo+ID4+Pj4+PiBJdCBwb3dlcnMgb2ZmIHRoZSBoYXJ0IGFuZCB3aWxsIGJlIHVzZWQgaW4g Y3B1LWhvdHBsdWcuCj4gPj4+Pj4+IE9ubHkgaW5kaXZpZHVhbCBoYXJ0IGNhbiByZW1vdmUgaXRz ZWxmIGZyb20gc3VwZXJ2aXNvciBtb2RlLiBJdCBjYW4KPiA+Pj4+Pj4gYmUKPiA+Pj4+Pj4gbW92 ZWQgdG8gbm9ybWFsIHN0YXRlIG9ubHkgYnkgc2JpX2hhcnRfdXAgZnVuY3Rpb24uCj4gPj4+Pj4+ Cj4gPj4+Pj4+IFJldHVybiB0aGUgYXBwcm9wcmlhdGUgU0JJIGVycm9yIGNvZGUuCj4gPj4+Pj4+ Cj4gPj4+Pj4+IC0tIHUzMiBzYmlfaGFydF9zdGF0ZSh1bnNpZ25lZCBsb25nIGhhcnRpZCkKPiA+ Pj4+Pj4KPiA+Pj4+Pj4gUmV0dXJucyB0aGUgUklTQ1ZfUE9XRVJfU1RBVEUgZm9yIGEgc3BlY2lm aWMgaGFydGlkLiBUaGlzIHdpbGwgaGVscAo+ID4+Pj4+PiBtYWtlCj4gPj4+Pj4+IGtleGVjIGxp a2UgZnVuY3Rpb25hbGl0eSBtb3JlIHJvYnVzdC4KPiA+Pj4+Pj4KPiA+Pj4+Pgo+ID4+Pj4+IElu c3RlYWQgb2YgdGhlIGFib3ZlIEkgYmVsaWV2ZSBpdCB3b3VsZCBiZSBjbGVhbmVyIGFuZCBzaW1w bGVyIHRvCj4gPj4+Pj4gaGF2ZQo+ID4+Pj4+IGFuIHNiaV9nZXRfaGFydF9zdGF0ZSBhbmQgYW4g c2JpX3NldF9oYXJ0X3N0YXRlIGNhbGwuIFRoaXMgd2F5IHdlCj4gPj4+Pj4gY2FuCj4gPj4+Pj4g YmV0dGVyIGhhbmRsZSBzdGF0ZSB0cmFuc2l0aW9ucyBhbmQsIGhhbmRsZSBPTi9PRkYvU1RBTkRC WS9SRVRFTlRJT04KPiA+Pj4+PiBhbmQgYW55IG90aGVyIHN0YXRlIHdlIGNvbWUgdXAgd2l0aCwg d2l0aG91dCBhZGRpbmcgZXh0cmEgc2JpIGNhbGxzLgo+ID4+Pj4+Cj4gPj4+Pgo+ID4+Pj4gV2hl biBkbyB5b3Ugd2FudCB0byB1c2Ugc2JpX3NldF9oYXJ0X3N0YXRlID8KPiA+Pj4+IFRoZSBwb3dl ciBzdGF0ZXMgd2lsbCBiZSBtb2RpZmllZCBhcyBhIHBhcnQgb2Ygc2JpX2hhcnRfZG93biBvcgo+ ID4+Pj4gc2JpX3NodXRkb3duL3N1c3BlbmQgY2FsbHMgYW55d2F5cy4KPiA+Pj4+Cj4gPj4+Cj4g Pj4+IFRoZSBpZGVhIGlzIHRvIGhhdmUgc2JpX3NldF9oYXJ0X3N0YXRlIGluc3RlYWQgb2YKPiA+ Pj4gc2JpX2hhcnRfZG93bi9zaHV0ZG93bi9zdXNwZW5kL2V0Yy4KPiA+Pj4gSW5zdGVhZCBvZiBo YXZpbmcgZGlmZmVyZW50IGNhbGxzIGZvciBkaWZmZXJlbnQgc3RhdGVzIHdlIGp1c3QgaGF2ZQo+ ID4+PiB0d28KPiA+Pj4gY2FsbHMsIG9uZQo+ID4+PiB0byBnZXQgdGhlIHN0YXRlIGFuZCBvbmUg dG8gc2V0IGl0LiBUaGlzIHdheSB3ZSBoYXZlIGZld2VyIGNhbGxzIGFuZAo+ID4+PiBpZgo+ID4+ PiB3ZSBhZGQgYQo+ID4+PiBuZXcgc3RhdGUgd2UgY2FuIGFkZCBpdCB3aXRob3V0IGhhdmluZyB0 byBhZGQgYSBuZXcgY2FsbC4KPiA+Pj4KPiA+PiBBaGggSSBzZWUgaXQgbm93LiBJTUhPLCBoYXZp bmcgZXhwbGljaXQgbmFtZXMgbWFrZXMgbW9yZSBzZW5zZS4KPiA+Pgo+ID4+Cj4gPj4+Pj4+IC0t IHZvaWQgc2JpX3N5c3RlbV9zaHV0ZG93bigpCj4gPj4+Pj4+Cj4gPj4+Pj4+IFBvd2VycyBvZmYg dGhlIGVudGlyZSBzeXN0ZW0uCj4gPj4+Pj4+Cj4gPj4+Pj4KPiA+Pj4+PiBEb24ndCB3ZSBhbHJl YWR5IGhhdmUgdGhhdCA/IFdoYXQncyB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuCj4gPj4+Pj4gc2Jp X3N5c3RlbV9zaHV0ZG93bgo+ID4+Pj4+IGFuZCBzYmlfc2h1dGRvd24gPyBEb2VzIGl0IG1ha2Ug c2Vuc2UgdG8gdXNlIHNiaV9zaHV0ZG93biBhbmQgbGVhdmUKPiA+Pj4+PiB0aGUKPiA+Pj4+PiBz eXN0ZW0KPiA+Pj4+PiBvbiB3aXRoIGFsbCB0aGUgaGFydHMgZG93biA/IE1heWJlIHdlIGNhbiBq dXN0IHNheSB0aGF0IHNiaV9zaHV0ZG93bgo+ID4+Pj4+IGFsc28KPiA+Pj4+PiBwb3dlcnMgZG93 biB0aGUgc3lzdGVtIGFuZCByZW5hbWUgaXQgdG8gc2JpX3N5c3RlbV9zaHV0ZG93biB3aXRoIHRo ZQo+ID4+Pj4+IHNhbWUKPiA+Pj4+PiBmdW5jdGlvbiBJRC4KPiA+Pj4+Pgo+ID4+Pj4KPiA+Pj4+ IFllYWguIFRoYXQncyBhIGJldHRlci4KPiA+Pj4+Cj4gPj4+Pgo+ID4+Pj4+PiAzLiBTQkkgQVBJ IElEIG51bWJlcmluZyBzY2hlbWU6Cj4gPj4+Pj4+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQo+ID4+Pj4+PiBBbiBBUEkgU2V0IGlzIGEgc2V0IG9mIFNCSSBBUElzIHdoaWNoIGNvbGxl Y3RpdmVseSBpbXBsZW1lbnQgc29tZQo+ID4+Pj4+PiBraW5kIG9mIGZlYXR1cmUvZnVuY3Rpb25h bGl0eS4KPiA+Pj4+Pj4KPiA+Pj4+Pj4gTGV0J3Mgc2F5IFNCSSBBUEkgSUQgaXMgdTMyICB0aGVu Cj4gPj4+Pj4+IEJpdFszMToyNF0gPSAgQVBJIFNldCBOdW1iZXIKPiA+Pj4+Pj4gQml0WzIzOjBd ID0gQVBJIE51bWJlciB3aXRoaW4gQVBJIFNldAo+ID4+Pj4+Pgo+ID4+Pj4+PiBIZXJlIGFyZSBm ZXcgQVBJIFNldHMgZm9yIFNCSSB2MC4yOgo+ID4+Pj4+PiAxLiBCYXNlIEFQSXMKPiA+Pj4+Pj4g QVBJIFNldCBOdW1iZXI6IDB4MAo+ID4+Pj4+PiBEZXNjcmlwdGlvbjogQmFzZSBBUElzIG1hbmRh dG9yeSBmb3IgYW55IFNCSSB2ZXJzaW9uCj4gPj4+Pj4+Cj4gPj4+Pj4+IDIuIEhBUlQgUE0gQVBJ cwo+ID4+Pj4+PiBBUEkgU2V0IE51bWJlcjogMHgxCj4gPj4+Pj4+IERlc2NyaXB0aW9uOiBIYXJ0 IFVQL0Rvd24vU3VzcGVuZCBBUElzIGZvciBwZXItSGFydAo+ID4+Pj4+PiBwb3dlciBtYW5hZ2Vt ZW50Cj4gPj4+Pj4+Cj4gPj4+Pj4+IDMuIFN5c3RlbSBQTSBBUElzCj4gPj4+Pj4+IEFQSSBTZXQg TnVtYmVyOyAweDIKPiA+Pj4+Pj4gRGVzY3JpcHRpb246IFN5c3RlbSBTaHV0ZG93bi9SZWJvb3Qv U3VzcGVuZCBmb3Igc3lzdGVtLWxldmVsCj4gPj4+Pj4+IHBvd2VyIG1hbmFnZW1lbnQKPiA+Pj4+ Pj4KPiA+Pj4+Pj4gNC4gVmVuZG9yIEFQSXMKPiA+Pj4+Pj4gQVBJIFNldCBOdW1iZXI6IDB4ZmYK PiA+Pj4+Pj4gRGVzY3JpcHRpb246IFZlbmRvciBzcGVjaWZpYyBBUElzLgo+ID4+Pj4+PiBUaGVy ZSBpcyBhIHBvc3NpYmlsaXR5IHRoYXQgZGlmZmVyZW50IHZlbmRvcnMgY2FuIGNob29zZSB0byBh c3NpZ24KPiA+Pj4+Pj4gc2FtZSBBUEkgbnVtYmVycyBmb3IgZGlmZmVyZW50IGZ1bmN0aW9uYWxp dHkuIEluIHRoYXQgY2FzZSwgdmVuZG9yCj4gPj4+Pj4+IHNwZWNpZmljIHN0cmluZ3MgaW4gRGV2 aWNlIFRyZWUgY2FuIGJlIHVzZWQgdG8gdmVyaWZ5IGlmIGEgc3BlY2lmaWMKPiA+Pj4+Pj4gQVBJ IGJlbG9uZ3MgdG8gdGhlIGludGVuZGVkIHZlbmRvciBvciBub3QuCj4gPj4+Pj4+Cj4gPj4+Pj4K PiA+Pj4+PiBJIHVuZGVyc3RhbmQgdGhlIHJhdGlvbmFsZSBiZWhpbmQgdGhpcyBidXQgSSBiZWxp ZXZlIGl0J3MgYmV0dGVyIHRvCj4gPj4+Pj4gY2FsbCB0aGVtIHNlcnZpY2VzIG9yIGZ1bmN0aW9u cyBpbnN0ZWFkIG9mIEFQSXMsIHRoZXkgYXJlIG5vdCBzZXRzCj4gPj4+Pj4gb2YgQVBJcyB0aGUg d2F5IEkgc2VlIGl0LiBBbHNvIHNpbmNlIHdlIGFyZSBtb3ZpbmcgdGhhdCBwYXRoIHdoeQo+ID4+ Pj4+IGNhbGwKPiA+Pj4+PiBpdCBTQkkgYW5kIHJlc3RyaWN0IGl0IG9ubHkgdG8gYmUgdXNlZCBi eSB0aGUgc3VwZXJ2aXNvciA/IEknZCBsb3ZlCj4gPj4+Pj4gdG8KPiA+Pj4+PiBoYXZlIGFub3Ro ZXIgY2F0ZWdvcnkgZm9yIHRoZSBzZWN1cmUgbW9uaXRvciBjYWxscyBmb3IgZXhhbXBsZSwKPiA+ Pj4+PiBidXQgb24gdGhlIHNvZnR3YXJlIGFyY2hpdGVjdHVyZSB0aGF0IHdlIGFyZSBkaXNjdXNz aW5nIG9uIHRoZSBURUUKPiA+Pj4+PiBncm91cCwgc3VjaCBjYWxscyBjYW4gYWxzbyBvcmlnaW5h dGUgZnJvbSBVIG1vZGUgb3IgSFMvSFUgbW9kZXMuCj4gPj4+Pj4gVGhlIHNhbWUgZ29lcyBmb3Ig dmVuZG9yIHNwZWNpZmljIGNhbGxzLCB0aGVyZSBhcmUgbG90cyBvZiB1c2UgY2FzZQo+ID4+Pj4+ IHNjZW5hcmlvcyB3aGVyZSB2ZW5kb3JzIHdvdWxkIGxpa2UgdG8gYmUgYWJsZSB0byBjYWxsIHRo ZWlyIHN0dWZmCj4gPj4+Pj4gZnJvbSBVIG1vZGUgZm9yIGV4YW1wbGUgKGUuZy4gYSB1c2VyIHNw YWNlIGxpYnJhcnkgdGFsa2luZyB0byBhCj4gPj4+Pj4gc21hcnQgY2FyZCBkaXJlY3RseSkuCj4g Pj4+Pj4KPiA+Pj4+PiBJIHN1Z2dlc3Qgd2UgcmVuYW1lIGl0IGZyb20gU0JJIHRvIHNvbWV0aGlu ZyBtb3JlIGdlbmVyaWMgdGhhdCBpcwo+ID4+Pj4+IG5vdAo+ID4+Pj4+IGRlZmluZWQgYnkgd2hv IGlzIGNhbGxpbmcgaXQgYnV0IGJ5IHdoYXQgd2UgYXJlIGNhbGxpbmcsIHdoaWNoIGluCj4gPj4+ Pj4gdGhpcwo+ID4+Pj4+IGNhc2UgaXMgdGhlIGZpcm13YXJlIChGQkk/KS4KPiA+Pj4+Cj4gPj4+ PiBwb3NzaWJsZSBjb25mbGljdCB3aXRoIGEgdmVyeSBmYW1vdXMgbGF3IGVuZm9yY2VtZW50IGFn ZW5jeSA6KSA6KS4KPiA+Pj4+Cj4gPj4+PiBKb2tlcyBhc2lkZSwgcmVuYW1pbmcgdG8gc29tZXRo aW5nIG1vcmUgZ2VuZXJpYyBpcyBhIGdvb2QgaWRlYS4gQnV0Cj4gPj4+PiBpdAo+ID4+Pj4gd2ls bCBwcm9iYWJseSBicmVhayBhIHRvbiBvZiBkb2N1bWVudGF0aW9uL3NwZWMgaW4gUklTQy1WIHdo aWNoIEkKPiA+Pj4+IGRvbid0IHdhbnQgdG8gZGVhbCB3aXRoIHJpZ2h0IG5vdy4gTWF5IGJlIGlu IGZ1dHVyZSB2ZXJzaW9ucyA/Cj4gPj4+Pgo+ID4+Pgo+ID4+PiBJIGdldCB0aGF0IHVwZGF0aW5n IHRoZSBkb2N1bWVudGF0aW9uIGNhbiBiZSBhIHBhaW4sIEkgY2FuIGhlbHAgd2l0aAo+ID4+PiB0 aGF0IGlmIHlvdSB3YW50IChhbmQgSSBwcm9taXNlIEknbGwgc3RheSBhd2F5IGZyb20gbGF3IGVu Zm9yY2VtZW50Cj4gPj4+IGFnZW5jaWVzICEpLiBJIHN1Z2dlc3Qgd2UgZG8gdGhlIHJlbmFtaW5n IGFzIGVhcmx5IGFzIHBvc3NpYmxlCj4gPj4+IGJlY2F1c2Ugd2UgYXJlIGdvaW5nIHRvIGNhcnJ5 IGl0IGZvciBhIGxvbmcgdGltZSBpbnN0ZWFkIGFuZCBpdCdsbAo+ID4+PiBvbmx5IGdldCBoYXJk ZXIgdG8gY2hhbmdlIGxhdGVyIG9uLgo+ID4+Pgo+ID4+IFRoYW5rcy4gSSBndWVzcyB3ZSBuZWVk IFBhbG1lci9BbmRyZXcgdG8gcGl0Y2ggaW4gZmlyc3Qgb24gdGhpcyBiZWZvcmUKPiA+PiB3ZSBk ZWNpZGUgYW55dGhpbmcuCj4gPj4KPiA+Cj4gPiBJIGp1c3Qgbm90aWNlZCB0aGF0IG9uIHByaXZp bGVnZSBzcGVjLCBTQkkgc3RhbmRzIGZvciBTeXN0ZW0gQmluYXJ5Cj4gPiBJbnRlcmZhY2UsCj4g PiBub3QgU3VwZXJ2aXNvciBCaW5hcnkgSW50ZXJmYWNlIGFzIG1lbnRpb25lZCBoZXJlOgo+ID4g aHR0cHM6Ly9naXRodWIuY29tL3Jpc2N2L3Jpc2N2LXNiaS1kb2MvYmxvYi9tYXN0ZXIvcmlzY3Yt c2JpLm1kCj4gPgo+ID4gIlN5c3RlbSIgaXMgYnJvYWRlciB0aGFuICJzdXBlcnZpc29yIiBzaW5j ZSBpdCBkb2Vzbid0IGltcGx5IHRoZSBtb2RlCj4gPiB3aGVyZQo+ID4gdGhlIGNhbGxzIG9yaWdp bmF0ZSBmcm9tLiBPbiB0aGUgb3RoZXIgaGFuZCBpdCBkb2Vzbid0IHNheSBhbnl0aGluZwo+ID4g YWJvdXQKPiA+IHdobyBpcyBjYWxsaW5nIG9yIHdobyBpdCBjYWxscywgaXQncyB2ZXJ5IGJyb2Fk LCBpdCBjYW4gYmUgYW4gaW50ZXJmYWNlCj4gPiBiZXR3ZWVuIGFueXRoaW5nLgo+ID4KPiBJIGd1 ZXNzIHlvdSBmb3VuZCBhIHR5cG8gaW4gcHJpdmlsZWdlZCBzcGVjLgo+Cj4gSXQgaXMgbWVudGlv bmVkIGFzIHN1cGVydmlzb3IgYmluYXJ5IGludGVyZmFjZSAoU0JJKSBpbiBjaGFwdGVyIDEKPiAo aHR0cHM6Ly9naXRodWIuY29tL3Jpc2N2L3Jpc2N2LWlzYS1tYW51YWwvYmxvYi9tYXN0ZXIvc3Jj L2ludHJvLnRleCNMMTI2KQo+IHdoaWxlIHN5c3RlbSBiaW5hcnkgaW50ZXJmYWNlIChTQkkpIGlu IENoYXB0ZXIgNC4KPiAoaHR0cHM6Ly9naXRodWIuY29tL3Jpc2N2L3Jpc2N2LWlzYS1tYW51YWwv YmxvYi9tYXN0ZXIvc3JjL3N1cGVydmlzb3IudGV4I0w5KQo+Cj4gSSBoYXZlIGZpbGVkIGEgYnVn IGluIGdpdGh1YiBmb3Igbm93Lgo+CgpXaGljaCBBUEkgc2V0IGlzIHN1aXRhYmxlIGZvciB0cmln Z2VyIG1vZHVsZSB1c2U/IFdlIG5lZWQgdG8gaW52b2tlIGEKU0JJIGNhbGwgdG8gc2V0IHRyaWdn ZXIgbW9kdWxlLiBXZSBjYW4gdXNlIG9uZSBTQkkgY2FsbCBmb3Igc2V0dGluZwptY29udHJvbCwg aWNvdW50LCBpdHJpZ2dlciBhbmQgZXRyaWdnZXIoZGVjaWRlIHdoaWNoIHR5cGVzIGluc2lkZSB0 aGlzClNCSSksIG9yIGZvdXIgU0JJIGNhbGxzIGZvciB0aGVtIHJlc3BlY3RpdmVseS4gT24gdGhl IG90aGVyIGhhbmQsIEkKc2F3IHRoZSBwZXJmIGJyYW5jaCBpbiByaXNjdi1wayByZXBvc2l0b3J5 LCBtYXliZSB3ZSBzaG91bGQgY29uc2lkZXIKaXQgdG9nZXRoZXI/IEJ1dCBhY3R1YWxseSwgdG8g YmUgZXhhY3QsIG9uZSBpcyBkZWJ1Z2dpbmcgdXNlLCBhbmQKYW5vdGhlciBvbmUgaXMgdHJhY2lu ZyB1c2UuCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwps aW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==