From mboxrd@z Thu Jan 1 00:00:00 1970 From: atish.patra@wdc.com (Atish Patra) Date: Fri, 2 Nov 2018 16:12:11 -0700 Subject: SBI extension proposal In-Reply-To: <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> References: <7f2a546a-6ebb-43c6-83a0-5e712ec2e2c7@wdc.com> <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> Message-ID: <5725574a-60c3-26f4-565b-4498c757a8f8@wdc.com> To: linux-riscv@lists.infradead.org List-Id: linux-riscv.lists.infradead.org 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. >> -- 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. >> -- 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 ? Since you mentioned ARM, in their case > the ABI used for PSCI is the Secure Monitor Call (which is the > alternative > to what is defined on the first paragraph of the SBI document), but it > has the same limitation. According to the documentation if an SMC comes > from a user application, we get an undefined exception. We can do better > ! > > >> 4. Return error code Table: >> --------------------------- >> >> Here are the SBI return error codes defined. >> >> SBI_SUCCESS 0 >> SBI_NOT_SUPPORTED -1 >> SBI_INVALID_PARAM -2 >> SBI_DENIED -3 >> SBI_INVALID_ADDRESS -4 >> >> A mapping function between SBI error code & Linux error code should be >> provided. >> > > I believe it should be up to the OS to translate the SBI error codes to > its > native ones. > Correct. Olof also pointed this out. I will remove it in next version. >> 5. Power State >> -------------- >> >> A RISC-V core can exist in any of the following power states. >> >> enum RISCV_POWER_STATE { >> //Powered up & operational. >> RISCV_HART_ON = 0, >> //Powered up but at reduced energy consumption. WFI instruction >> can be used to achieve this state. >> RISCV_HART_STANDBY = 1, >> //Deeper low power state. No reset required but higher wakeup >> latency. >> RISCV_HART_RETENTION = 2, >> //Powered off. Reset of the core required after power restore. >> RISCV_HART_OFF = 3 >> } >> >> TODO: >> Any other power management related features or state? >> > > How about LOCKSTEP ? We could have a way of declaring a hart as a > "mirror" of another > hart (https://en.wikipedia.org/wiki/Lockstep_(computing)). We can have > an extra argument > on sbi_get/set_state when the LOCKSTEP state is used, that will get/set > the hart that > this hart is mirroring. > Not sure if we need it right now. I want to keep it simple and focus on the bare minimum ones. We can always add exotic ones once we have feature/versioning in place. >> 6. Implementation >> ------------------- >> Currently, SBI is implemented as a part of BBL. There is a different >> SBI implementation available in coreboot as well. >> >> Alternatively, a separate open BSD/MIT licensed SBI project can be >> created which can be used by anybody to avoid these kind of SBI >> fragmentation in future. This project can generate both a firmware >> binary (to executed directly in M mode) or a static library that can >> be used by different boot loaders. It will also help individual boot >> loaders to either work from M or S mode without a separate SBI >> implementation. >> > > Why implement this at the boot loader level ? This is more like a > firmware interface > than something that belongs to the bootloader. The bootloader should use > this interface > not provide it. It depends on the bootloader. For example, there are patches in coreboot that implements SBI. The idea with OpenSBI implementation is to avoid such fragmentation. Also this is something that belongs to the M mode, a > bootloader > should belong to the S mode, running the bootloader in M mode is not > right from > a security point of view. We can provide something like "RISC-V Firmware > Services" > that's code running on M mode after the first stage boot loader/BootROM > and let > bootloaders use it without having to implement it. That's the idea for S mode bootloaders. However, there are folks who are interested in M mode ones and I understand their usecase. Thus, idea is to implement OpenSBI in such a way that, everybody can make use of it. Regards, Atish ARM does the same > with their > ARM Trusted Firmware, their BL31 (Secure Monitor) gets loaded after the > FSBL and > it then loads (on EL2, the equivalent to our S mode) the bootloader. > >> This proposal is far from perfect and absolutely any suggestion is >> welcome. Obviously, there are many other functionalities that can be >> added or removed from this proposal. However, I just wanted to start >> with something that is an incremental change at best to kick off the >> discussion. The aim here is initiate a discussion that can lead to a >> robust SBI specification. >> >> Looking forward to discuss other ideas as well or any feedback on this >> proposal. >> >> Reference: >> ----------- >> [1] >> http://infocenter.arm.com/help/topic/com.arm.doc.den0022d/Power_State_Coordination_Interface_PDD_v1_1_DEN0022D.pdf >> [2] https://github.com/riscv/riscv-sbi-doc/blob/master/riscv-sbi.md >> >> >> Regards, >> Atish >> >> _______________________________________________ >> linux-riscv mailing list >> linux-riscv at lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/linux-riscv > > > _______________________________________________ > linux-riscv mailing list > linux-riscv at lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-riscv > 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=-7.5 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,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 91E36C32789 for ; Fri, 2 Nov 2018 23:12:44 +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 3FB1D20657 for ; Fri, 2 Nov 2018 23:12:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="HO04Six1"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=wdc.com header.i=@wdc.com header.b="oXTAc1BH" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3FB1D20657 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=wdc.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-Type: Content-Transfer-Encoding:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=LyN5P1MEw/3jvREk+ikPMDhaYEJyMcJ71jeErtExA+8=; b=HO04Six1DZBJ2+eWKryB0eQH2 pdcWvPjsvrau7piDyL3jjoeiXv5qEOvMyK9PRXbkAsIowIN4NqCaCfGlljJGtoCXgR0WeWjPvwAzK 5B6aX5fjMIVTnzGXLsxWdvvMlWuJeRzJMsjdpliNqD7Uk6I1GGhSqpjAXdzye8QArzX4NzgIG4JZG 8rGXoNGx0EFp0VXAUmFVaWkxnyDGrhwazaipGjVExCgC8b6b+/pwq2bO/Ayacrj73HoBgMp20Jfiq ftfuDC/jA+5I0CDBt3uWmLlmB59ZvrzuBDPubnllHqx9zpDEXH3OH3bickTTuHvJDY60QtJ1kkIJu fAk8o2oKw==; 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 1gIicL-0007im-Gr; Fri, 02 Nov 2018 23:12:41 +0000 Received: from esa3.hgst.iphmx.com ([216.71.153.141]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gIic4-0007f1-TO for linux-riscv@lists.infradead.org; Fri, 02 Nov 2018 23:12:27 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1541200345; x=1572736345; h=subject:to:cc:references:from:message-id:date: mime-version:in-reply-to:content-transfer-encoding; bh=xjYqaNFwlnB0tntEceOxaQRqK3etikoDvDfUrYh7xPs=; b=oXTAc1BHQJOhnaeKNk9jM3rXyO+mPqFoMN/fVL3aZ8hTbLsugMAMZ4L2 ayh4uMlpRklbnCF+ZGm3L2FHFgGYVd/D5g7MdjEr6Nh+gOFGxKmOQlnde RemWpQVOUlUM7aCv+txLDp/efyZ+H5aivqZgfYrnwylOPTPDyYpCIn0T3 6bSOQzVriL5rxpAzb4fJMKgbVvxJCQa+WtiMG2WqcmSUzSWVNrzQDgocm d5SrUwtvTzbTWXhdspuBY7SvGqi/Q9Y9mvDmBxhIU+wra/AVNAaZKqV5U T6q+S7KhbqqnUTUA6icwcFNcU9sxyCtntpx4ncJrwkLkdErfbeOXe0JWI g==; X-IronPort-AV: E=Sophos;i="5.54,457,1534780800"; d="scan'208";a="98152240" Received: from h199-255-45-14.hgst.com (HELO uls-op-cesaep01.wdc.com) ([199.255.45.14]) by ob1.hgst.iphmx.com with ESMTP; 03 Nov 2018 07:12:12 +0800 Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep01.wdc.com with ESMTP; 02 Nov 2018 15:56:06 -0700 Received: from c02v91rdhtd5.sdcorp.global.sandisk.com (HELO [10.111.69.187]) ([10.111.69.187]) by uls-op-cesaip02.wdc.com with ESMTP; 02 Nov 2018 16:12:12 -0700 Subject: Re: SBI extension proposal To: Nick Kossifidis References: <7f2a546a-6ebb-43c6-83a0-5e712ec2e2c7@wdc.com> <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> From: Atish Patra Message-ID: <5725574a-60c3-26f4-565b-4498c757a8f8@wdc.com> Date: Fri, 2 Nov 2018 16:12:11 -0700 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <3245c74a8dc9f651cb07e382585fa311@mailhost.ics.forth.gr> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181102_161225_093297_79087F71 X-CRM114-Status: GOOD ( 46.55 ) 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 Le Moal , Olof Johansson , Andrew Waterman , Alan Kao , Anup Patel , Palmer Dabbelt , "Rwmjones.fedora" , Christoph Hellwig , "vincentc@andestech.com" , Michael Clark , Arnd Bergmann , Paul Walmsley , "linux-riscv@lists.infradead.org" , "Chang, Abner \(HPS SW/FW Technologist\)" , "David.Abdurachmanov@cern.ch" Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-riscv" Errors-To: linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org Message-ID: <20181102231211.mi04TocMxCac4sE1rJ8JDOizdWoKKOqyE2ZaPC4ABPk@z> T24gMTEvMi8xOCA4OjI1IEFNLCBOaWNrIEtvc3NpZmlkaXMgd3JvdGU6Cj4gSGVsbG8gQXRpc2gg YW5kIHRoYW5rcyBmb3IgYnJpbmdpbmcgdGhpcyB1cCwKPiAKPiDOo8+EzrnPgiAyMDE4LTEwLTMx IDIwOjIzLCBBdGlzaCBQYXRyYSDOrc6zz4HOsc+IzrU6Cj4+IEhlcmUgaXMgYSBwcm9wb3NhbCB0 byBtYWtlIFNCSSBhIGZsZXhpYmxlIGFuZCBleHRlbnNpYmxlIGludGVyZmFjZS4KPj4gSXQgaXMg YmFzZWQgb24gdGhlIGZvdW5kYXRpb24gcG9saWN5IG9mIFJJU0MtViBpLmUuIG1vZHVsYXJpdHkg YW5kCj4+IG9wZW5uZXNzLiBJdCBpcyBkZXNpZ25lZCBpbiBzdWNoIGEgd2F5IHRoYXQgaXQgaW50 cm9kdWNlcyB2ZXJ5IGZldyBuZXcKPj4gbWFuZGF0b3J5IFNCSSBBUElzIHRoYXQgYXJlIGFic29s dXRlbHkgcmVxdWlyZWQgdG8gbWFpbnRhaW4gYmFja3dhcmQKPj4gY29tcGF0aWJpbGl0eS4gRXZl cnl0aGluZyBlbHNlIGlzIG9wdGlvbmFsIHNvIHRoYXQgaXQgcmVtYWlucyBhbiBvcGVuCj4+IHN0 YW5kYXJkIHlldCByb2J1c3QuCj4+Cj4+IDEuIEludHJvZHVjdGlvbjoKPj4gLS0tLS0tLS0tLS0t LS0tLQo+PiBUaGUgY3VycmVudCBSSVNDLVYgU0JJIG9ubHkgZGVmaW5lcyBhIGZldyBtYW5kYXRv cnkgZnVuY3Rpb25zIHN1Y2ggYXMKPj4gaW50ZXItcHJvY2Vzc29yIGludGVycnVwdHMgKElQSSkg aW50ZXJmYWNlLCByZXByb2dyYW1taW5nIHRpbWVyLCBzZXJpYWwKPj4gY29uc29sZSBhbmQgbWVt b3J5IGJhcnJpZXIgaW5zdHJ1Y3Rpb25zLiBUaGUgZXhpc3RpbmcgU0JJIGRvY3VtZW50YXRpb24K Pj4gY2FuIGJlIGZvdW5kIGhlcmUgWzFdLiBNYW55IGltcG9ydGFudCBmdW5jdGlvbmFsaXRpZXMg c3VjaCBhcyBwb3dlcgo+PiBtYW5hZ2VtZW50L2NwdS1ob3RwbHVnIGFyZSBub3QgeWV0IGRlZmlu ZWQgZHVlIHRvIGRpZmZpY3VsdGllcyBpbgo+PiBhY2NvbW1vZGF0aW5nIG1vZGlmaWNhdGlvbnMg d2l0aG91dCBicmVha2luZyB0aGUgYmFja3dhcmQgY29tcGF0aWJpbGl0eQo+PiB3aXRoIHRoZSBj dXJyZW50IGludGVyZmFjZS4KPj4KPj4gSXRzIGRlc2lnbiBpcyBpbnNwaXJlZCBieSBQb3dlciBT dGF0ZSBDb29yZGluYXRpb24gSW50ZXJmYWNlIChQU0NJKQo+PiBmcm9tCj4+IEFSTSB3b3JsZC4g SG93ZXZlciwgaXQgYWRkcyBvbmx5IHR3byBuZXcgbWFuZGF0b3J5IFNCSSBjYWxscyBwcm92aWRp bmcKPj4gdmVyc2lvbiBpbmZvcm1hdGlvbiBhbmQgc3VwcG9ydGVkIEFQSXMsIHVubGlrZSBQU0NJ IHdoZXJlIGEgc2lnbmlmaWNhbnQKPj4gbnVtYmVyIG9mIGZ1bmN0aW9ucyBhcmUgbWFuZGF0b3J5 LiBUaGUgdmVyc2lvbiBvZiB0aGUgZXhpc3RpbmcgU0JJIHdpbGwKPj4gYmUgZGVmaW5lZCBhcyBh IG1pbmltdW0gdmVyc2lvbigwLjEpIHdoaWNoIHdpbGwgYWx3YXlzIGJlIGJhY2t3YXJkCj4+IGNv bXBhdGlibGUuIFNpbWlsYXJseSwgYW55IExpbnV4IGtlcm5lbCB3aXRoIG5ld2VyIGZlYXR1cmUg d2lsbCBmYWxsCj4+IGJhY2sgaWYgYW4gb2xkZXIgdmVyc2lvbiBvZiBTQkkgZG9lcyBub3Qgc3Vw cG9ydCB0aGUgdXBkYXRlZAo+PiBjYXBhYmlsaXRpZXMuIEJvdGggdGhlIG9wZXJhdGluZyBzeXN0 ZW0gYW5kIFNFRSBjYW4gYmUgaW1wbGVtZW50ZWQgdG8KPj4gYmUgdHdvIHdheSBiYWNrd2FyZCBj b21wYXRpYmxlLgo+Pgo+PiAyLiBOZXcgZnVuY3Rpb25zOgo+PiAtLS0tLS0tLS0tLS0tLS0tLQo+ Pgo+PiAtLSB1MzIgc2JpX2dldF92ZXJzaW9uKHZvaWQpOgo+Pgo+PiBSZXR1cm5zIHRoZSBjdXJy ZW50IFNCSSB2ZXJzaW9uIGltcGxlbWVudGVkIGJ5IHRoZSBmaXJtd2FyZS4KPj4gdmVyc2lvbjog dWludDMyOiBCaXRzWzMxOjE2XSBNYWpvciBWZXJzaW9uCj4+ICAgICAgICAgICAgICAgQml0c1sx NTowXSBNaW5vciBWZXJzaW9uCj4+Cj4+IFRoZSBleGlzdGluZyBTQkkgdmVyc2lvbiBjYW4gYmUg MC4xLiBUaGUgcHJvcG9zZWQgdmVyc2lvbiB3aWxsIGJlIGF0Cj4+IDAuMgo+PiBBIGRpZmZlcmVu dCBtYWpvciB2ZXJzaW9uIG1heSBpbmRpY2F0ZSBwb3NzaWJsZSBpbmNvbXBhdGlibGUgZnVuY3Rp b25zLgo+PiBBIGRpZmZlcmVudCBtaW5vciB2ZXJzaW9uIG11c3QgYmUgY29tcGF0aWJsZSB3aXRo IGVhY2ggb3RoZXIgZXZlbiBpZgo+PiB0aGV5IGhhdmUgYSBoaWdoZXIgbnVtYmVyIG9mIGZlYXR1 cmVzLgo+Pgo+PiAtLSB1MzIgc2JpX2NoZWNrX2FwaSh1bnNpZ25lZCBsb25nIHN0YXJ0X2FwaV9p ZCwgdW5zaWduZWQgbG9uZyBjb3VudCk6Cj4+Cj4+IEFjY2VwdHMgYSBzdGFydF9hcGlfaWQgYXMg YW4gYXJndW1lbnQgYW5kIHJldHVybnMgaWYgc3RhcnRfYXBpX2lkIHRvCj4+IChzdGFydF9hcGlf aWQgKyBjb3VudCAtIDEpIGFyZSBzdXBwb3J0ZWQgb3Igbm90Lgo+PiBUaGUgQVBJIG51bWJlcmlu ZyBzY2hlbWUgaXMgZGVzY3JpYmVkIGluIHNlY3Rpb24gMy4KPj4KPj4gQSBjb3VudCBpcyBpbnRy b2R1Y2VkIHNvIHRoYXQgYSByYW5nZSBvZiBBUElzIGNhbiBiZSBjaGVja2VkIGF0IG9uZSBTQkkK Pj4gY2FsbCB0byBtaW5pbWl6ZSB0aGUgTS1tb2RlIHRyYXBzLgo+Pgo+IAo+IElzIHRoaXMgcmVh bGx5IG5lZWRlZCA/IFdlIGNhbiBkZXRlcm1pbmUgdGhlIFNCSSB2ZXJzaW9uIGZyb20KPiBzYmlf Z2V0X3ZlcnNpb24sIHdoeQo+IGluY2x1ZGUgYW4gU0JJIGNhbGwgdG8gcGVyZm9ybSBhIGNoZWNr IHRoYXQgY2FuIGVhc2lseSBiZSBwZXJmb3JtZWQgYnkKPiB0aGUgY2FsbGVyCj4gaW5zdGVhZCA/ Cj4gCgpUaGlzIEFQSSBpcyBzdGlsbCBpbiBkaXNjdXNzaW9uLiBQcm9iYWJseSwgYW4gQVBJIHJl dHVybmluZyBiaXRtYXNrIG9mIAphbGwgdGhlIGZlYXR1cmVzIG1ha2UgbW9yZSBzZW5zZSA/CgpI b3dldmVyLCBJIGZlZWwgYSBzZXBhcmF0ZSBBUEkgaXMgcmVxdWlyZWQgZnJvbSBzYmlfZ2V0X3Zl cnNpb24gYXMgdGhlcmUgCnZlbmRvcnMgY2FuIGNob29zZSBub3QgdG8gaW1wbGVtZW50IHNvbWUg b2YgdGhlIGZlYXR1cmVzIHRoYXQgaXMgCnNwZWNpZmllZCBieSBhIHZlcnNpb24gYXMgbW9zdCBv ZiB0aGUgQVBJIHNldCBhcmUgb3B0aW9uYWwuCgo+PiAtLSBpbnQgc2JpX2hhcnRfdXAodW5zaWdu ZWQgbG9uZyBoYXJ0aWQsIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkCj4+IGxvbmcgcHJp dikKPj4KPj4gQnJpbmdzIHVwICJoYXJ0aWQiIGVpdGhlciBkdXJpbmcgaW5pdGlhbCBib290IG9y IGFmdGVyIGEgc2JpX2hhcnRfZG93bgo+PiBTQkkgY2FsbC4KPj4KPj4gInN0YXJ0IiBwb2ludHMg dG8gYSBydW50aW1lLXNwZWNpZmllZCBhZGRyZXNzIHdoZXJlIGEgaGFydCBjYW4gZW50ZXIKPj4g aW50byBzdXBlcnZpc29yIG1vZGUuIFRoaXMgbXVzdCBiZSBhIHBoeXNpY2FsIGFkZHJlc3MuCj4+ Cj4+ICJwcml2IiBpcyBhIHByaXZhdGUgZGF0YSB0aGF0IGNhbGxlciBjYW4gdXNlIHRvIHBhc3Mg aW5mb3JtYXRpb24gYWJvdXQKPj4gZXhlY3V0aW9uIGNvbnRleHQuCj4+Cj4+IFJldHVybiB0aGUg YXBwcm9wcmlhdGUgU0JJIGVycm9yIGNvZGUuCj4+Cj4+IC0tIGludCBzYmlfaGFydF9zdXNwZW5k KHUzMiBzdGF0ZSwgdW5zaWduZWQgbG9uZyByZXN1bWVfZW50cnksIHVuc2lnbmVkCj4+IGxvbmcg cHJpdikKPj4KPj4gU3VzcGVuZHMgdGhlIGNhbGxpbmcgaGFydCB0byBhIHBhcnRpY3VsYXIgcG93 ZXIgc3RhdGUuIFN1c3BlbmRlZCBoYXJ0Cj4+IHdpbGwgYXV0b21hdGljYWxseSB3YWtlLXVwIGJh c2VkIG9uIHNvbWUgd2FrZXVwIGV2ZW50cyBhdCByZXN1bWVfZW50cnkKPj4gcGh5c2ljYWwgYWRk cmVzcy4KPj4KPj4gInByaXYiIGlzIGEgcHJpdmF0ZSBkYXRhIHRoYXQgY2FsbGVyIGNhbiB1c2Ug dG8gcGFzcyBpbmZvcm1hdGlvbiBhYm91dAo+PiBleGVjdXRpb24gY29udGV4dC4gVGhlIFNCSSBp bXBsZW1lbnRhdGlvbiBtdXN0IHNhdmUgYSBjb3B5IHNvIHRoYXQKPj4gY2FsbGVyIGNhbiByZXVz ZSB3aGlsZSByZXN0b3JpbmcgaGFydCBmcm9tIHN1c3BlbmQuCj4+Cj4+IFJldHVybiB0aGUgYXBw cm9wcmlhdGUgU0JJIGVycm9yIGNvZGUuCj4+Cj4+IC0tIGludCBzYmlfaGFydF9kb3duKCkKPj4K Pj4gSXQgcG93ZXJzIG9mZiB0aGUgaGFydCBhbmQgd2lsbCBiZSB1c2VkIGluIGNwdS1ob3RwbHVn Lgo+PiBPbmx5IGluZGl2aWR1YWwgaGFydCBjYW4gcmVtb3ZlIGl0c2VsZiBmcm9tIHN1cGVydmlz b3IgbW9kZS4gSXQgY2FuIGJlCj4+IG1vdmVkIHRvIG5vcm1hbCBzdGF0ZSBvbmx5IGJ5IHNiaV9o YXJ0X3VwIGZ1bmN0aW9uLgo+Pgo+PiBSZXR1cm4gdGhlIGFwcHJvcHJpYXRlIFNCSSBlcnJvciBj b2RlLgo+Pgo+PiAtLSB1MzIgc2JpX2hhcnRfc3RhdGUodW5zaWduZWQgbG9uZyBoYXJ0aWQpCj4+ Cj4+IFJldHVybnMgdGhlIFJJU0NWX1BPV0VSX1NUQVRFIGZvciBhIHNwZWNpZmljIGhhcnRpZC4g VGhpcyB3aWxsIGhlbHAKPj4gbWFrZQo+PiBrZXhlYyBsaWtlIGZ1bmN0aW9uYWxpdHkgbW9yZSBy b2J1c3QuCj4+Cj4gCj4gSW5zdGVhZCBvZiB0aGUgYWJvdmUgSSBiZWxpZXZlIGl0IHdvdWxkIGJl IGNsZWFuZXIgYW5kIHNpbXBsZXIgdG8gaGF2ZQo+IGFuIHNiaV9nZXRfaGFydF9zdGF0ZSBhbmQg YW4gc2JpX3NldF9oYXJ0X3N0YXRlIGNhbGwuIFRoaXMgd2F5IHdlIGNhbgo+IGJldHRlciBoYW5k bGUgc3RhdGUgdHJhbnNpdGlvbnMgYW5kLCBoYW5kbGUgT04vT0ZGL1NUQU5EQlkvUkVURU5USU9O Cj4gYW5kIGFueSBvdGhlciBzdGF0ZSB3ZSBjb21lIHVwIHdpdGgsIHdpdGhvdXQgYWRkaW5nIGV4 dHJhIHNiaSBjYWxscy4KPiAKCldoZW4gZG8geW91IHdhbnQgdG8gdXNlIHNiaV9zZXRfaGFydF9z dGF0ZSA/ClRoZSBwb3dlciBzdGF0ZXMgd2lsbCBiZSBtb2RpZmllZCBhcyBhIHBhcnQgb2Ygc2Jp X2hhcnRfZG93biBvciAKc2JpX3NodXRkb3duL3N1c3BlbmQgY2FsbHMgYW55d2F5cy4KCj4+IC0t IHZvaWQgc2JpX3N5c3RlbV9zaHV0ZG93bigpCj4+Cj4+IFBvd2VycyBvZmYgdGhlIGVudGlyZSBz eXN0ZW0uCj4+Cj4gCj4gRG9uJ3Qgd2UgYWxyZWFkeSBoYXZlIHRoYXQgPyBXaGF0J3MgdGhlIGRp ZmZlcmVuY2UgYmV0d2Vlbgo+IHNiaV9zeXN0ZW1fc2h1dGRvd24KPiBhbmQgc2JpX3NodXRkb3du ID8gRG9lcyBpdCBtYWtlIHNlbnNlIHRvIHVzZSBzYmlfc2h1dGRvd24gYW5kIGxlYXZlIHRoZQo+ IHN5c3RlbQo+IG9uIHdpdGggYWxsIHRoZSBoYXJ0cyBkb3duID8gTWF5YmUgd2UgY2FuIGp1c3Qg c2F5IHRoYXQgc2JpX3NodXRkb3duCj4gYWxzbwo+IHBvd2VycyBkb3duIHRoZSBzeXN0ZW0gYW5k IHJlbmFtZSBpdCB0byBzYmlfc3lzdGVtX3NodXRkb3duIHdpdGggdGhlCj4gc2FtZQo+IGZ1bmN0 aW9uIElELgo+IAoKWWVhaC4gVGhhdCdzIGEgYmV0dGVyLgoKCj4+IDMuIFNCSSBBUEkgSUQgbnVt YmVyaW5nIHNjaGVtZToKPj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4+IEFuIEFQ SSBTZXQgaXMgYSBzZXQgb2YgU0JJIEFQSXMgd2hpY2ggY29sbGVjdGl2ZWx5IGltcGxlbWVudCBz b21lCj4+IGtpbmQgb2YgZmVhdHVyZS9mdW5jdGlvbmFsaXR5Lgo+Pgo+PiBMZXQncyBzYXkgU0JJ IEFQSSBJRCBpcyB1MzIgIHRoZW4KPj4gQml0WzMxOjI0XSA9ICBBUEkgU2V0IE51bWJlcgo+PiBC aXRbMjM6MF0gPSBBUEkgTnVtYmVyIHdpdGhpbiBBUEkgU2V0Cj4+Cj4+IEhlcmUgYXJlIGZldyBB UEkgU2V0cyBmb3IgU0JJIHYwLjI6Cj4+IDEuIEJhc2UgQVBJcwo+PiBBUEkgU2V0IE51bWJlcjog MHgwCj4+IERlc2NyaXB0aW9uOiBCYXNlIEFQSXMgbWFuZGF0b3J5IGZvciBhbnkgU0JJIHZlcnNp b24KPj4KPj4gMi4gSEFSVCBQTSBBUElzCj4+IEFQSSBTZXQgTnVtYmVyOiAweDEKPj4gRGVzY3Jp cHRpb246IEhhcnQgVVAvRG93bi9TdXNwZW5kIEFQSXMgZm9yIHBlci1IYXJ0Cj4+IHBvd2VyIG1h bmFnZW1lbnQKPj4KPj4gMy4gU3lzdGVtIFBNIEFQSXMKPj4gQVBJIFNldCBOdW1iZXI7IDB4Mgo+ PiBEZXNjcmlwdGlvbjogU3lzdGVtIFNodXRkb3duL1JlYm9vdC9TdXNwZW5kIGZvciBzeXN0ZW0t bGV2ZWwKPj4gcG93ZXIgbWFuYWdlbWVudAo+Pgo+PiA0LiBWZW5kb3IgQVBJcwo+PiBBUEkgU2V0 IE51bWJlcjogMHhmZgo+PiBEZXNjcmlwdGlvbjogVmVuZG9yIHNwZWNpZmljIEFQSXMuCj4+IFRo ZXJlIGlzIGEgcG9zc2liaWxpdHkgdGhhdCBkaWZmZXJlbnQgdmVuZG9ycyBjYW4gY2hvb3NlIHRv IGFzc2lnbgo+PiBzYW1lIEFQSSBudW1iZXJzIGZvciBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0eS4g SW4gdGhhdCBjYXNlLCB2ZW5kb3IKPj4gc3BlY2lmaWMgc3RyaW5ncyBpbiBEZXZpY2UgVHJlZSBj YW4gYmUgdXNlZCB0byB2ZXJpZnkgaWYgYSBzcGVjaWZpYwo+PiBBUEkgYmVsb25ncyB0byB0aGUg aW50ZW5kZWQgdmVuZG9yIG9yIG5vdC4KPj4KPiAKPiBJIHVuZGVyc3RhbmQgdGhlIHJhdGlvbmFs ZSBiZWhpbmQgdGhpcyBidXQgSSBiZWxpZXZlIGl0J3MgYmV0dGVyIHRvCj4gY2FsbCB0aGVtIHNl cnZpY2VzIG9yIGZ1bmN0aW9ucyBpbnN0ZWFkIG9mIEFQSXMsIHRoZXkgYXJlIG5vdCBzZXRzCj4g b2YgQVBJcyB0aGUgd2F5IEkgc2VlIGl0LiBBbHNvIHNpbmNlIHdlIGFyZSBtb3ZpbmcgdGhhdCBw YXRoIHdoeSBjYWxsCj4gaXQgU0JJIGFuZCByZXN0cmljdCBpdCBvbmx5IHRvIGJlIHVzZWQgYnkg dGhlIHN1cGVydmlzb3IgPyBJJ2QgbG92ZSB0bwo+IGhhdmUgYW5vdGhlciBjYXRlZ29yeSBmb3Ig dGhlIHNlY3VyZSBtb25pdG9yIGNhbGxzIGZvciBleGFtcGxlLAo+IGJ1dCBvbiB0aGUgc29mdHdh cmUgYXJjaGl0ZWN0dXJlIHRoYXQgd2UgYXJlIGRpc2N1c3Npbmcgb24gdGhlIFRFRQo+IGdyb3Vw LCBzdWNoIGNhbGxzIGNhbiBhbHNvIG9yaWdpbmF0ZSBmcm9tIFUgbW9kZSBvciBIUy9IVSBtb2Rl cy4KPiBUaGUgc2FtZSBnb2VzIGZvciB2ZW5kb3Igc3BlY2lmaWMgY2FsbHMsIHRoZXJlIGFyZSBs b3RzIG9mIHVzZSBjYXNlCj4gc2NlbmFyaW9zIHdoZXJlIHZlbmRvcnMgd291bGQgbGlrZSB0byBi ZSBhYmxlIHRvIGNhbGwgdGhlaXIgc3R1ZmYKPiBmcm9tIFUgbW9kZSBmb3IgZXhhbXBsZSAoZS5n LiBhIHVzZXIgc3BhY2UgbGlicmFyeSB0YWxraW5nIHRvIGEKPiBzbWFydCBjYXJkIGRpcmVjdGx5 KS4KPiAKPiBJIHN1Z2dlc3Qgd2UgcmVuYW1lIGl0IGZyb20gU0JJIHRvIHNvbWV0aGluZyBtb3Jl IGdlbmVyaWMgdGhhdCBpcyBub3QKPiBkZWZpbmVkIGJ5IHdobyBpcyBjYWxsaW5nIGl0IGJ1dCBi eSB3aGF0IHdlIGFyZSBjYWxsaW5nLCB3aGljaCBpbiB0aGlzCj4gY2FzZSBpcyB0aGUgZmlybXdh cmUgKEZCST8pLgoKcG9zc2libGUgY29uZmxpY3Qgd2l0aCBhIHZlcnkgZmFtb3VzIGxhdyBlbmZv cmNlbWVudCBhZ2VuY3kgOikgOikuCgpKb2tlcyBhc2lkZSwgcmVuYW1pbmcgdG8gc29tZXRoaW5n IG1vcmUgZ2VuZXJpYyBpcyBhIGdvb2QgaWRlYS4gQnV0IGl0IAp3aWxsIHByb2JhYmx5IGJyZWFr IGEgdG9uIG9mIGRvY3VtZW50YXRpb24vc3BlYyBpbiBSSVNDLVYgd2hpY2ggSSBkb24ndCAKd2Fu dCB0byBkZWFsIHdpdGggcmlnaHQgbm93LiBNYXkgYmUgaW4gZnV0dXJlIHZlcnNpb25zID8KCgog IFNpbmNlIHlvdSBtZW50aW9uZWQgQVJNLCBpbiB0aGVpciBjYXNlCj4gdGhlIEFCSSB1c2VkIGZv ciBQU0NJIGlzIHRoZSBTZWN1cmUgTW9uaXRvciBDYWxsICh3aGljaCBpcyB0aGUKPiBhbHRlcm5h dGl2ZQo+IHRvIHdoYXQgaXMgZGVmaW5lZCBvbiB0aGUgZmlyc3QgcGFyYWdyYXBoIG9mIHRoZSBT QkkgZG9jdW1lbnQpLCBidXQgaXQKPiBoYXMgdGhlIHNhbWUgbGltaXRhdGlvbi4gQWNjb3JkaW5n IHRvIHRoZSBkb2N1bWVudGF0aW9uIGlmIGFuIFNNQyBjb21lcwo+IGZyb20gYSB1c2VyIGFwcGxp Y2F0aW9uLCB3ZSBnZXQgYW4gdW5kZWZpbmVkIGV4Y2VwdGlvbi4gV2UgY2FuIGRvIGJldHRlcgo+ ICEKPiAKCgoKPiAKPj4gNC4gUmV0dXJuIGVycm9yIGNvZGUgVGFibGU6Cj4+IC0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQo+Pgo+PiBIZXJlIGFyZSB0aGUgU0JJIHJldHVybiBlcnJvciBjb2Rl cyBkZWZpbmVkLgo+Pgo+PiAgICAgICAgU0JJX1NVQ0NFU1MgICAgICAgICAgIDAKPj4gICAgICAg IFNCSV9OT1RfU1VQUE9SVEVEICAgIC0xCj4+ICAgICAgICBTQklfSU5WQUxJRF9QQVJBTSAgICAt Mgo+PiAgICAgICAgU0JJX0RFTklFRCAgICAgICAgICAgLTMKPj4gICAgICAgIFNCSV9JTlZBTElE X0FERFJFU1MgIC00Cj4+Cj4+IEEgbWFwcGluZyBmdW5jdGlvbiBiZXR3ZWVuIFNCSSBlcnJvciBj b2RlICYgTGludXggZXJyb3IgY29kZSBzaG91bGQgYmUKPj4gcHJvdmlkZWQuCj4+Cj4gCj4gSSBi ZWxpZXZlIGl0IHNob3VsZCBiZSB1cCB0byB0aGUgT1MgdG8gdHJhbnNsYXRlIHRoZSBTQkkgZXJy b3IgY29kZXMgdG8KPiBpdHMKPiBuYXRpdmUgb25lcy4KPiAKCkNvcnJlY3QuIE9sb2YgYWxzbyBw b2ludGVkIHRoaXMgb3V0LiBJIHdpbGwgcmVtb3ZlIGl0IGluIG5leHQgdmVyc2lvbi4KCj4+IDUu IFBvd2VyIFN0YXRlCj4+IC0tLS0tLS0tLS0tLS0tCj4+Cj4+IEEgUklTQy1WIGNvcmUgY2FuIGV4 aXN0IGluIGFueSBvZiB0aGUgZm9sbG93aW5nIHBvd2VyIHN0YXRlcy4KPj4KPj4gZW51bSBSSVND Vl9QT1dFUl9TVEFURSB7Cj4+ICAgICAgICAgLy9Qb3dlcmVkIHVwICYgb3BlcmF0aW9uYWwuCj4+ ICAgICAgICAgUklTQ1ZfSEFSVF9PTiAgICAgICAgICAgICAgPSAgMCwKPj4gICAgICAgICAvL1Bv d2VyZWQgdXAgYnV0IGF0IHJlZHVjZWQgZW5lcmd5IGNvbnN1bXB0aW9uLiBXRkkgaW5zdHJ1Y3Rp b24KPj4gY2FuIGJlIHVzZWQgdG8gYWNoaWV2ZSB0aGlzIHN0YXRlLgo+PiAgICAgICAgIFJJU0NW X0hBUlRfU1RBTkRCWSAgICAgICAgPSAgIDEsCj4+ICAgICAgICAgLy9EZWVwZXIgbG93IHBvd2Vy IHN0YXRlLiBObyByZXNldCByZXF1aXJlZCBidXQgaGlnaGVyIHdha2V1cAo+PiBsYXRlbmN5Lgo+ PiAgICAgICAgIFJJU0NWX0hBUlRfUkVURU5USU9OICAgICAgID0gIDIsCj4+ICAgICAgICAgLy9Q b3dlcmVkIG9mZi4gUmVzZXQgb2YgdGhlIGNvcmUgcmVxdWlyZWQgYWZ0ZXIgcG93ZXIgcmVzdG9y ZS4KPj4gICAgICAgICBSSVNDVl9IQVJUX09GRiAgICAgICAgICAgICA9ICAzCj4+IH0KPj4KPj4g VE9ETzoKPj4gQW55IG90aGVyIHBvd2VyIG1hbmFnZW1lbnQgcmVsYXRlZCBmZWF0dXJlcyBvciBz dGF0ZT8KPj4KPiAKPiBIb3cgYWJvdXQgTE9DS1NURVAgPyBXZSBjb3VsZCBoYXZlIGEgd2F5IG9m IGRlY2xhcmluZyBhIGhhcnQgYXMgYQo+ICJtaXJyb3IiIG9mIGFub3RoZXIKPiBoYXJ0IChodHRw czovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9Mb2Nrc3RlcF8oY29tcHV0aW5nKSkuIFdlIGNhbiBo YXZlCj4gYW4gZXh0cmEgYXJndW1lbnQKPiBvbiBzYmlfZ2V0L3NldF9zdGF0ZSB3aGVuIHRoZSBM T0NLU1RFUCBzdGF0ZSBpcyB1c2VkLCB0aGF0IHdpbGwgZ2V0L3NldAo+IHRoZSBoYXJ0IHRoYXQK PiB0aGlzIGhhcnQgaXMgbWlycm9yaW5nLgo+IAoKTm90IHN1cmUgaWYgd2UgbmVlZCBpdCByaWdo dCBub3cuIEkgd2FudCB0byBrZWVwIGl0IHNpbXBsZSBhbmQgZm9jdXMgb24gCnRoZSBiYXJlIG1p bmltdW0gb25lcy4gV2UgY2FuIGFsd2F5cyBhZGQgZXhvdGljIG9uZXMgb25jZSB3ZSBoYXZlIApm ZWF0dXJlL3ZlcnNpb25pbmcgaW4gcGxhY2UuCgo+PiA2LiBJbXBsZW1lbnRhdGlvbgo+PiAtLS0t LS0tLS0tLS0tLS0tLS0tCj4+IEN1cnJlbnRseSwgU0JJIGlzIGltcGxlbWVudGVkIGFzIGEgcGFy dCBvZiBCQkwuIFRoZXJlIGlzIGEgZGlmZmVyZW50Cj4+IFNCSSBpbXBsZW1lbnRhdGlvbiBhdmFp bGFibGUgaW4gY29yZWJvb3QgYXMgd2VsbC4KPj4KPj4gQWx0ZXJuYXRpdmVseSwgYSBzZXBhcmF0 ZSBvcGVuIEJTRC9NSVQgbGljZW5zZWQgU0JJIHByb2plY3QgY2FuIGJlCj4+IGNyZWF0ZWQgd2hp Y2ggY2FuIGJlIHVzZWQgYnkgYW55Ym9keSB0byBhdm9pZCB0aGVzZSBraW5kIG9mIFNCSQo+PiBm cmFnbWVudGF0aW9uIGluIGZ1dHVyZS4gVGhpcyBwcm9qZWN0IGNhbiBnZW5lcmF0ZSBib3RoIGEg ZmlybXdhcmUKPj4gYmluYXJ5ICh0byBleGVjdXRlZCBkaXJlY3RseSBpbiBNIG1vZGUpIG9yIGEg c3RhdGljIGxpYnJhcnkgdGhhdCBjYW4KPj4gYmUgdXNlZCBieSBkaWZmZXJlbnQgYm9vdCBsb2Fk ZXJzLiBJdCB3aWxsIGFsc28gaGVscCBpbmRpdmlkdWFsIGJvb3QKPj4gbG9hZGVycyB0byBlaXRo ZXIgd29yayBmcm9tIE0gb3IgUyBtb2RlIHdpdGhvdXQgYSBzZXBhcmF0ZSBTQkkKPj4gaW1wbGVt ZW50YXRpb24uCj4+Cj4gCj4gV2h5IGltcGxlbWVudCB0aGlzIGF0IHRoZSBib290IGxvYWRlciBs ZXZlbCA/IFRoaXMgaXMgbW9yZSBsaWtlIGEKPiBmaXJtd2FyZSBpbnRlcmZhY2UKPiB0aGFuIHNv bWV0aGluZyB0aGF0IGJlbG9uZ3MgdG8gdGhlIGJvb3Rsb2FkZXIuIFRoZSBib290bG9hZGVyIHNo b3VsZCB1c2UKPiB0aGlzIGludGVyZmFjZQo+IG5vdCBwcm92aWRlIGl0LgpJdCBkZXBlbmRzIG9u IHRoZSBib290bG9hZGVyLiBGb3IgZXhhbXBsZSwgdGhlcmUgYXJlIHBhdGNoZXMgaW4gY29yZWJv b3QgCnRoYXQgaW1wbGVtZW50cyBTQkkuIFRoZSBpZGVhIHdpdGggT3BlblNCSSBpbXBsZW1lbnRh dGlvbiBpcyB0byBhdm9pZCAKc3VjaCBmcmFnbWVudGF0aW9uLgoKICBBbHNvIHRoaXMgaXMgc29t ZXRoaW5nIHRoYXQgYmVsb25ncyB0byB0aGUgTSBtb2RlLCBhCj4gYm9vdGxvYWRlcgo+IHNob3Vs ZCBiZWxvbmcgdG8gdGhlIFMgbW9kZSwgcnVubmluZyB0aGUgYm9vdGxvYWRlciBpbiBNIG1vZGUg aXMgbm90Cj4gcmlnaHQgZnJvbQo+IGEgc2VjdXJpdHkgcG9pbnQgb2Ygdmlldy4gV2UgY2FuIHBy b3ZpZGUgc29tZXRoaW5nIGxpa2UgIlJJU0MtViBGaXJtd2FyZQo+IFNlcnZpY2VzIgo+IHRoYXQn cyBjb2RlIHJ1bm5pbmcgb24gTSBtb2RlIGFmdGVyIHRoZSBmaXJzdCBzdGFnZSBib290IGxvYWRl ci9Cb290Uk9NCj4gYW5kIGxldAo+IGJvb3Rsb2FkZXJzIHVzZSBpdCB3aXRob3V0IGhhdmluZyB0 byBpbXBsZW1lbnQgaXQuCgpUaGF0J3MgdGhlIGlkZWEgZm9yIFMgbW9kZSBib290bG9hZGVycy4g SG93ZXZlciwgdGhlcmUgYXJlIGZvbGtzIHdobyBhcmUgCmludGVyZXN0ZWQgaW4gTSBtb2RlIG9u ZXMgYW5kIEkgdW5kZXJzdGFuZCB0aGVpciB1c2VjYXNlLiBUaHVzLCBpZGVhIGlzIAp0byBpbXBs ZW1lbnQgT3BlblNCSSBpbiBzdWNoIGEgd2F5IHRoYXQsIGV2ZXJ5Ym9keSBjYW4gbWFrZSB1c2Ug b2YgaXQuCgpSZWdhcmRzLApBdGlzaAogIEFSTSBkb2VzIHRoZSBzYW1lCj4gd2l0aCB0aGVpcgo+ IEFSTSBUcnVzdGVkIEZpcm13YXJlLCB0aGVpciBCTDMxIChTZWN1cmUgTW9uaXRvcikgZ2V0cyBs b2FkZWQgYWZ0ZXIgdGhlCj4gRlNCTCBhbmQKPiBpdCB0aGVuIGxvYWRzIChvbiBFTDIsIHRoZSBl cXVpdmFsZW50IHRvIG91ciBTIG1vZGUpIHRoZSBib290bG9hZGVyLgo+IAoKCgo+PiBUaGlzIHBy b3Bvc2FsIGlzIGZhciBmcm9tIHBlcmZlY3QgYW5kIGFic29sdXRlbHkgYW55IHN1Z2dlc3Rpb24g aXMKPj4gd2VsY29tZS4gT2J2aW91c2x5LCB0aGVyZSBhcmUgbWFueSBvdGhlciBmdW5jdGlvbmFs aXRpZXMgdGhhdCBjYW4gYmUKPj4gYWRkZWQgb3IgcmVtb3ZlZCBmcm9tIHRoaXMgcHJvcG9zYWwu IEhvd2V2ZXIsIEkganVzdCB3YW50ZWQgdG8gc3RhcnQKPj4gd2l0aCBzb21ldGhpbmcgdGhhdCBp cyBhbiBpbmNyZW1lbnRhbCBjaGFuZ2UgYXQgYmVzdCB0byBraWNrIG9mZiB0aGUKPj4gZGlzY3Vz c2lvbi4gVGhlIGFpbSBoZXJlIGlzIGluaXRpYXRlIGEgZGlzY3Vzc2lvbiB0aGF0IGNhbiBsZWFk IHRvIGEKPj4gcm9idXN0IFNCSSBzcGVjaWZpY2F0aW9uLgo+Pgo+PiBMb29raW5nIGZvcndhcmQg dG8gZGlzY3VzcyBvdGhlciBpZGVhcyBhcyB3ZWxsIG9yIGFueSBmZWVkYmFjayBvbiB0aGlzCj4+ IHByb3Bvc2FsLgo+Pgo+PiBSZWZlcmVuY2U6Cj4+IC0tLS0tLS0tLS0tCj4+IFsxXQo+PiBodHRw Oi8vaW5mb2NlbnRlci5hcm0uY29tL2hlbHAvdG9waWMvY29tLmFybS5kb2MuZGVuMDAyMmQvUG93 ZXJfU3RhdGVfQ29vcmRpbmF0aW9uX0ludGVyZmFjZV9QRERfdjFfMV9ERU4wMDIyRC5wZGYKPj4g WzJdIGh0dHBzOi8vZ2l0aHViLmNvbS9yaXNjdi9yaXNjdi1zYmktZG9jL2Jsb2IvbWFzdGVyL3Jp c2N2LXNiaS5tZAo+Pgo+Pgo+PiBSZWdhcmRzLAo+PiBBdGlzaAo+Pgo+PiBfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwo+PiBsaW51eC1yaXNjdiBtYWlsaW5n IGxpc3QKPj4gbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwo+PiBodHRwOi8vbGlzdHMu aW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cj4gCj4gCj4gX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPiBsaW51eC1yaXNjdiBt YWlsaW5nIGxpc3QKPiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCj4gaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo+IAoKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1h aWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5p bmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK