From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752071AbcDNT7W (ORCPT ); Thu, 14 Apr 2016 15:59:22 -0400 Received: from aserp1040.oracle.com ([141.146.126.69]:38928 "EHLO aserp1040.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751591AbcDNT7U (ORCPT ); Thu, 14 Apr 2016 15:59:20 -0400 Date: Thu, 14 Apr 2016 15:56:53 -0400 From: Konrad Rzeszutek Wilk To: "Luis R. Rodriguez" Cc: Juergen Gross , Matt Fleming , Michael Chang , linux-kernel@vger.kernel.org, Jim Fehlig , Jan Beulich , "H. Peter Anvin" , Daniel Kiper , x86@kernel.org, =?utf-8?Q?Vojt=C4=9Bch_Pavl=C3=ADk?= , Gary Lin , xen-devel@lists.xenproject.org, Jeffrey Cheung , Stefano Stabellini , joeyli , Borislav Petkov , Boris Ostrovsky , Charles Arndol , Andrew Cooper , Julien Grall , Andy Lutomirski , David Vrabel , Linus Torvalds , Roger Pau =?iso-8859-1?Q?Monn=E9?= , Josh Triplett , Kees Cook , Vitaly Kuznetsov Subject: Re: [Xen-devel] HVMLite / PVHv2 - using x86 EFI boot entry Message-ID: <20160414195652.GC20459@localhost.localdomain> References: <5704D978.1050101@citrix.com> <20160408204032.GR1990@wotan.suse.de> <570B3228.90400@suse.com> <20160413182951.GW1990@wotan.suse.de> <20160413185629.GA7501@char.us.oracle.com> <20160413204055.GD1990@wotan.suse.de> <20160413210801.GC5962@char.us.oracle.com> <20160413222317.GH1990@wotan.suse.de> <20160414010131.GA21510@localhost.localdomain> <20160414184048.GM1990@wotan.suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20160414184048.GM1990@wotan.suse.de> User-Agent: Mutt/1.5.24 (2015-08-30) X-Source-IP: userv0022.oracle.com [156.151.31.74] Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Apr 14, 2016 at 08:40:48PM +0200, Luis R. Rodriguez wrote: > On Wed, Apr 13, 2016 at 09:01:32PM -0400, Konrad Rzeszutek Wilk wrote: > > On Thu, Apr 14, 2016 at 12:23:17AM +0200, Luis R. Rodriguez wrote: > > > On Wed, Apr 13, 2016 at 05:08:01PM -0400, Konrad Rzeszutek Wilk wrote: > > > > On Wed, Apr 13, 2016 at 10:40:55PM +0200, Luis R. Rodriguez wrote: > > > > > On Wed, Apr 13, 2016 at 02:56:29PM -0400, Konrad Rzeszutek Wilk wrote: > > > > > > On Wed, Apr 13, 2016 at 08:29:51PM +0200, Luis R. Rodriguez wrote: > > > > > > > > > > and we also want to address dead code issues which pvops simply folded > > > > > under the rug. The dead code concerns may exist still for hvmlite, so > > > > > unless someone is willing to make a bold claim there is none, its > > > > > something to consider. > > > > > > > > What is this dead code you speak of? > > > > > > Kasan is dead code to Xen. If you boot x86 Xen with Kasan enabled > > > > For Xen PV guests, > > That's right. For 5 years this will be a bomb. That went unnoticed > and I feel I have to pull hair now to try to get folks to fix this. Sometimes you have to roll up your sleeves and do the work yourself. > > How many other issues will go in which will explode during this 5 year > time line? How can we proactively address a solution to this now so we > avoid this in future ? > > Do you believe me now its a real issue? I never said otherwise. What I was confused was that you grouped this with HVMLite - which would not have a problem like this. > > Fortunately I have a proactive solution for pvops now in my pipeline that > should help avoid us having to blow more things up on Xen but also that should > cause no headaches on behalf of x86 developers. But, reason I have been so > engaged on HVMLite design review is I want to ensure we take the lessons > learned from pvops and avoid this for an architecture that will be def-facto > Xen on Linux 5 years from now. > > Not bringing this up or addressing this now for HVMLite / PVH2 would simply be > silly, and since it wasn't addressed in pvops I obviously have to ensure I > convince enough people it was a real issue and ensure that we have enough > semantics available to address it. Kasan came after pvops, so of course it was not addressed in pvops. > > Part of the semantics question, which has made my quest hard, was the use of > semantics for virtualization for code on early boot and later in boot has been > rather sloppy, so we have recently needed to address some of these gaps. Some > of these discussions have however been productive, as I'll explain to George > soon regarding his DT questions. The discussion is not over though and we need > to ensure that if we need semantics for HVMLite we'll have them available in > *clean* way. One of the things where early semantics and design to address > these issue help in a proactive manner is to address a clean boot entry -- and > that's also why I've been so pedantic over review of the new HVMlite boot > entry. I must have missed your review of the patches. Sorry! > > > > Xen explodes. Quick question, will Kasan not explode with HVMLite ? > > > > .. but for HVMLite of Xen HVM guest Kasan will run. > > Are you sure? Should that mean that Xen HVM should be fine as well. Does that > work? Are we sure? Yes, and yes. > > > > MTRR used to be dead code concern but since we have vetted most of that code > > > now we are pretty certain that code should never run now. > > > > > > KASLR may be -- not sure as I haven't vetted that, but from > > > what I have loosely heard maybe. > > > > > > VGA code will be dead code for HVMlite for sure as the design doc > > > says it will not run VGA, the ACPI flag will be set but the check > > > for that is not yet on Linux. That means the VGA Linux code will > > > be there but we have no way to ensure it will not run nor that > > > anything will muck with it. > > > > The worst it will do is try to read non-existent registers. > > Really ? > > Is that your position on all other possible dead code that may have been > possible on old Xen PV guests as well ? This is not just with Xen - it with other device drivers that are being invoked on baremetal and are not present in hardware anymore. > > As I hinted, after thinking about this for a while I realized that dead code is > likely present on bare metal as well even without virtualization, specially if Yes! > you build large single kernels to support a wide array of features which only > late at run time can be determined. Virtualization and the pvops design just > makes this issue much more prominent. If there are other areas of code exposed > that actually may run, but we are not sure may run, I figured some other folks > with a bit more security conscience minds might even simply take the position > it may be a security risk to leave that code exposed. So to take a position > that 'the worst it will do is try to read non-existent registers' -- seems > rather shortsighted here. Security conscious people trim their CONFIG. > > Anyway for more details on thoughts on this refer to the this wiki: > > http://kernelnewbies.org/KernelProjects/kernel-sandboxing > > Since this is now getting off topic please send me your feedback on another > thread for the non-virtualization aspects of this if that interests you. My > point here was rather to highlight the importance of clear semantics due to > virtualization in light of possible dead code. Thank you. > > > The VGA code should be able to handle failures like that and > > not initialize itself when the hardware is dead (or non-existent). > > That's right, its through ACPI_FADT_NO_VGA and since its part of the HVMLite > design doc we want HVMlite design to address ACPI_FADT_NO_VGA properly. I've > paved the way for this to be done cleanly and easily now, but that code should > be in place before HVMLite code gets merged. > > Does domU for old Xen PV also set ACPI_FADT_NO_VGA as well ? Should it ? It does not. Not sure - it seems to have worked fine for the last ten years? > > > > To be clear -- dead code concerns still exist even without > > > virtualization solutions, its just that with virtualization > > > this stuff comes up more and there has been no proactive > > > measures to address this. The question of semantics here is > > > to see to what extent we need earlier boot code annotations > > > to ensure we address semantics proactively. > > > > I think what you mean by dead code is another word for > > hardware test coverage? > > No, no, its very different given that with virtualization the scope of possible > dead code is significant and at run time you are certain a huge portion of code > should *never ever* run. So for instance we know once we boot bare metal none > of the Xen stuff should ever run, likewise on Xen dom0 we know none of the KVM > / bare-metal only stuff should never run, when on Xen domU, none of the Xen What is this 'bare metal only stuff' you speak of? On Xen dom0 most of the baremetal code is running. In fact that is how the device drivers work. Or are you talking about low level baremetal code? If so, then PVH/HVMLite does that - it skips pvops so that it can run this 'low-level baremetal code' > domU-only stuff should ever run. You forgot KVM guest support on baremetal. That shouldn't run either. > > > > > The entrace point in Linux "proper" is startup_32 or startup_64 - the same > > > > path that EFI uses. > > > > > > > > If you were to draw this (very simplified): > > > > > > > > a)- GRUB2 ---------------------\ (creates an bootparam structure) > > > > \ > > > > +---- startup_32 or startup_64 > > > > b) EFI -> Linux EFI stub -------/ > > > > (creates bootparm) / > > > > c) GRUB2-EFI -> Linux EFI----/ > > > > stub / > > > > d) HVMLite ----------------/ > > > > (creates bootparm) > > > > > > b) and d) might be able to share paths there... > > > > No idea. You would have to look in the assembler code to > > figure that out. > > And that's a pain, I get it. > > I spotted one place already -- will note to Boris. I think Matt may have more > ideas ;) > > > > d) still has its own entry, it does more than create boot params. > > > > d) purpose is to create boot params. > > OK good to know that's the only thing we acknowledge it *should* do. And b), c) purpose is for that too - amongts providing an mechanism to call in EFI firmware. And I realized that early baremetal boot option also ends up calling C during its startup (see main in arch/x86/boot/main.c) amongst then switching different modes. > > > It may do more as nobody likes to muck in assembler and make bootparams from > > within assembler. > > OK -- it does do more and that's where we'd like to avoid duplication if > possible and yet-another-entry (TM). It does more? EFI stub entry does more than the GRUB2 entry. If you have some patches to trim the code duplication within those boot paths- please post it. > > > > > (I am not sure about the c) - I would have to look in source to > > > > be source). There is also LILO in this, but I am not even sure if > > > > works anymore. > > > > > > > > > > > > What you have is that every entry point creates the bootparams > > > > and ends up calling startup_X. The startup_64 then hit the rest > > > > of the kernel. The startp_X code is the one that would setup > > > > the basic pagetables, segments, etc. > > > > > > Sure.. a full diagram should include both sides and how when using > > > a custom entry one runs the risk of skipping a lot of code setup. > > > > But it does not skip a lot of code setup. It starts exactly > > at the same code startup that _all_ bootstraping code start at. > > Its a fair point. > > > > There is that and as others have pointed out how certain guests types > > > are assumed to not have certain peripherals, and we have no idea > > > to ensure certain old legacy code may not ever run or be accessed > > > by drivers. > > > > Ok, but that is not at code setup. That is later - when device > > drivers are initialized. This no different than booting on > > some hardware with missing functionality. ACPI, PCI and PnP > > PnP are set there to help OSes discover this. > > To a certain extent this is true, but there may things which are missing still. Like? > > We really have no idea what the full list of those things are. Ok, it sounds like you have some homework. > > It may be that things may have been running for ages without notice of an issue > or that only under certain situations will certain issues or bugs trigger a > failure. For instance, just yesterday I was Cc'd on a brand-spanking new legacy > conflict [0], caused by upstream commit 8c058b0b9c34d8c ("x86/irq: Probe for > PIC presence before allocating descs for legacy IRQs") merged on v4.4 where > some new code used nr_legacy_irqs() -- one proposed solution seems to be that > for Xen code NR_IRQS_LEGACY should be used instead is as it lacks PCI [1] and > another was to peg the legacy requirements as a quirk on the new x86 platform > legacy quirk stuff [2]. Are other uses of nr_legacy_irqs() correct ? Are > we sure ? And how is this example related to 'early bootup' path? It is not. It is in fact related to PV codepaths - which PVH/HVMLite and HVM guests do not exercise. > > [0] http://lkml.kernel.org/r/570F90DF.1020508@oracle.com > [1] https://lkml.org/lkml/2016/4/14/532 > [2] http://lkml.kernel.org/r/1460592286-300-1-git-send-email-mcgrof@kernel.org > > > > > > How we address semantics then is *very* important to me. > > > > > > > > Which semantics? How the CPU is going to be at startup_X ? Or > > > > how the CPU is going to be when EFI firmware invokes the EFI stub? > > > > Or when GRUB2 loads Linux? > > > > > > What hypervisor kicked me and what guest type I am. > > > > cpuid software flags have that - and that semantics has been > > there for eons. > > We cannot use cpuid early in asm code, I'm looking for something we ?! Why!? > can even use on asm early in boot code, on x86 the best option we > have is the boot_params, but I've even have had issues with that > early in code, as I can only access it after load_idt() where I > described my effort to unify Xen PV and x86_64 init paths [3]. Well, Xen PV skips x86_64_start_kernel.. > > [3] http://lkml.kernel.org/r/CAB=NE6VTCRCazcNpCdJ7pN1eD3=x_fcGOdH37MzVpxkKEN5esw@mail.gmail.com > > > > Let me elaborate more below. > > > > > > > That (those bootloaders) is clearly defined. The URL I provided > > > > mentions the HVMLite one. The Documentation/x86/boot.c mentions > > > > what the semantics are to expected when providing an bootstrap > > > > (which is what HVMLitel stub code in Linux would write against - > > > > and what EFI stub code had been written against too). > > > > > > > > > > > > I'll elaborate on this but first let's clarify why a new entry is used for > > > > > > > HVMlite to start of with: > > > > > > > > > > > > > > 1) Xen ABI has historically not wanted to set up the boot params for Linux > > > > > > > guests, instead it insists on letting the Linux kernel Xen boot stubs fill > > > > > > > that out for it. This sticking point means it has implicated a boot stub. > > > > > > > > > > > > > > > > > > Which is b/c it has to be OS agnostic. It has nothing to do 'not wanting'. > > > > > > > > > > It can still be OS agnostic and pass on type and custom data pointer. > > > > > > > > Sure. It has that (it MUST otherwise how else would you pass data). > > > > It is documented as well http://xenbits.xen.org/docs/unstable/hypercall/x86_64/include,public,xen.h.html#incontents_startofday > > > > (see " Start of day structure passed to PVH guests in %ebx.") > > > > > > The design doc begs for a custom OS entry point though. > > > > That is what the ELF Note has. > > Right, but I'm saying that its rather silly to be adding entry points if > all we want the code to do is copy the boot params for us. The design > doc requires a new entry, and likewise you'd need yet-another-entry if > HVMLite is thrown out the window and come back 5 years later after new > hardware solutions are in place and need to redesign HVMLite. Kind of Why would you need to redesign HVMLite based on hardware solutions? The entrace point and the CPU state are pretty well known - it is akin to what GRUB2 bootloader path is (protected mode). > where we are with PVH today. Likewise if other paravirtualization > developers want to support Linux and want to copy your strategy they'd > add yet-another-entry-point as well. > > This is dumb. You saying the EFI entry point is dumb? That instead the EFI firmware should understand Linux bootparams and booted that? > > > > If we had a single 'type' and 'custom data' passed to the kernel that > > > should suffice for the default Linux entry point to just pivot off > > > of that and do what it needs without more entry points. Once. > > > > And what about ramdisk? What about multiple ramdisks? > > What about command line? All of that is what bootparams > > tries to unify on Linux. But 'bootparams' is unique to Linux, > > it does not exist on FreeBSD. Hence some stub code to transplant > > OS-agnostic simple data to OS-specific is neccessary. > > If we had a Xen ABI option where *all* that I'm asking is you pass > first: > > a) hypervisor type Why can't you use cpuid. > b) custom data pointer What is this custom data pointer you speak of? > > We'd be able to avoid adding *any* entry point and just address > the requirements as I noted with pre / post stubs for the type. But you need some entry point to call into Linux. Are you suggesting to use the existing ones? No, the existing one wouldn't understand this. > This would require an x86 boot protocol bump, but all the issues > creeping up randomly I think that's worth putting on the table now. Aaaah, so you are saying expand the bootparams. In other words make Xen ABI call into Linux using the bootparams structure, similar to how GRUB2 does it. How is that OS agnostic? > > And maybe we don't want it to be hypervisor specific, perhaps there are other > *needs* for custom pre-post startup_32()/startup_64() stubs. Multiboot? > > To avoid extending boot_params further I figured perhaps we can look > at EFI as another option instead. If we are going to drop all legacy But EFI support is _huge_. > PV support from the kernel (not the hypervisor) and require hardware > virtualization 5 years from now on the Linux kernel, it doesn't seem > to me far fetched to at the very least consider using an EFI entry > instead, specially since all it does is set boot params and we can > make re-use this for HVMLite too. But to make that work you have to emulate EFI firmware in the hypervisor. Is that work you are signing up for? > > Luis From mboxrd@z Thu Jan 1 00:00:00 1970 From: Konrad Rzeszutek Wilk Subject: Re: HVMLite / PVHv2 - using x86 EFI boot entry Date: Thu, 14 Apr 2016 15:56:53 -0400 Message-ID: <20160414195652.GC20459@localhost.localdomain> References: <5704D978.1050101@citrix.com> <20160408204032.GR1990@wotan.suse.de> <570B3228.90400@suse.com> <20160413182951.GW1990@wotan.suse.de> <20160413185629.GA7501@char.us.oracle.com> <20160413204055.GD1990@wotan.suse.de> <20160413210801.GC5962@char.us.oracle.com> <20160413222317.GH1990@wotan.suse.de> <20160414010131.GA21510@localhost.localdomain> <20160414184048.GM1990@wotan.suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1aqnOx-0001VE-8n for xen-devel@lists.xenproject.org; Thu, 14 Apr 2016 19:58:07 +0000 Content-Disposition: inline In-Reply-To: <20160414184048.GM1990@wotan.suse.de> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: "Luis R. Rodriguez" Cc: Matt Fleming , Michael Chang , linux-kernel@vger.kernel.org, Julien Grall , Jan Beulich , "H. Peter Anvin" , Daniel Kiper , x86@kernel.org, =?utf-8?Q?Vojt=C4=9Bch_Pavl=C3=ADk?= , Gary Lin , xen-devel@lists.xenproject.org, Jeffrey Cheung , Charles Arndol , Kees Cook , Stefano Stabellini , Josh Triplett , joeyli , Borislav Petkov , Boris Ostrovsky , Juergen Gross , Andrew Cooper , Jim Fehlig , Andy Lutomirski , David Vrabel List-Id: xen-devel@lists.xenproject.org T24gVGh1LCBBcHIgMTQsIDIwMTYgYXQgMDg6NDA6NDhQTSArMDIwMCwgTHVpcyBSLiBSb2RyaWd1 ZXogd3JvdGU6Cj4gT24gV2VkLCBBcHIgMTMsIDIwMTYgYXQgMDk6MDE6MzJQTSAtMDQwMCwgS29u cmFkIFJ6ZXN6dXRlayBXaWxrIHdyb3RlOgo+ID4gT24gVGh1LCBBcHIgMTQsIDIwMTYgYXQgMTI6 MjM6MTdBTSArMDIwMCwgTHVpcyBSLiBSb2RyaWd1ZXogd3JvdGU6Cj4gPiA+IE9uIFdlZCwgQXBy IDEzLCAyMDE2IGF0IDA1OjA4OjAxUE0gLTA0MDAsIEtvbnJhZCBSemVzenV0ZWsgV2lsayB3cm90 ZToKPiA+ID4gPiBPbiBXZWQsIEFwciAxMywgMjAxNiBhdCAxMDo0MDo1NVBNICswMjAwLCBMdWlz IFIuIFJvZHJpZ3VleiB3cm90ZToKPiA+ID4gPiA+IE9uIFdlZCwgQXByIDEzLCAyMDE2IGF0IDAy OjU2OjI5UE0gLTA0MDAsIEtvbnJhZCBSemVzenV0ZWsgV2lsayB3cm90ZToKPiA+ID4gPiA+ID4g T24gV2VkLCBBcHIgMTMsIDIwMTYgYXQgMDg6Mjk6NTFQTSArMDIwMCwgTHVpcyBSLiBSb2RyaWd1 ZXogd3JvdGU6Cj4gPiA+ID4gPiAKPiA+ID4gPiA+IGFuZCB3ZSBhbHNvIHdhbnQgdG8gYWRkcmVz cyBkZWFkIGNvZGUgaXNzdWVzIHdoaWNoIHB2b3BzIHNpbXBseSBmb2xkZWQKPiA+ID4gPiA+IHVu ZGVyIHRoZSBydWcuIFRoZSBkZWFkIGNvZGUgY29uY2VybnMgbWF5IGV4aXN0IHN0aWxsIGZvciBo dm1saXRlLCBzbwo+ID4gPiA+ID4gdW5sZXNzIHNvbWVvbmUgaXMgd2lsbGluZyB0byBtYWtlIGEg Ym9sZCBjbGFpbSB0aGVyZSBpcyBub25lLCBpdHMKPiA+ID4gPiA+IHNvbWV0aGluZyB0byBjb25z aWRlci4KPiA+ID4gPiAKPiA+ID4gPiBXaGF0IGlzIHRoaXMgZGVhZCBjb2RlIHlvdSBzcGVhayBv Zj8KPiA+ID4gCj4gPiA+IEthc2FuIGlzIGRlYWQgY29kZSB0byBYZW4uIElmIHlvdSBib290IHg4 NiBYZW4gd2l0aCBLYXNhbiBlbmFibGVkCj4gPiAKPiA+IEZvciBYZW4gUFYgZ3Vlc3RzLAo+IAo+ IFRoYXQncyByaWdodC4gRm9yIDUgeWVhcnMgdGhpcyB3aWxsIGJlIGEgYm9tYi4gVGhhdCB3ZW50 IHVubm90aWNlZAo+IGFuZCBJIGZlZWwgSSBoYXZlIHRvIHB1bGwgaGFpciBub3cgdG8gdHJ5IHRv IGdldCBmb2xrcyB0byBmaXggdGhpcy4KClNvbWV0aW1lcyB5b3UgaGF2ZSB0byByb2xsIHVwIHlv dXIgc2xlZXZlcyBhbmQgZG8gdGhlIHdvcmsgeW91cnNlbGYuCj4gCj4gSG93IG1hbnkgb3RoZXIg aXNzdWVzIHdpbGwgZ28gaW4gd2hpY2ggd2lsbCBleHBsb2RlIGR1cmluZyB0aGlzIDUgeWVhcgo+ IHRpbWUgbGluZT8gSG93IGNhbiB3ZSBwcm9hY3RpdmVseSBhZGRyZXNzIGEgc29sdXRpb24gdG8g dGhpcyBub3cgc28gd2UKPiBhdm9pZCB0aGlzIGluIGZ1dHVyZSA/Cj4gCj4gRG8geW91IGJlbGll dmUgbWUgbm93IGl0cyBhIHJlYWwgaXNzdWU/CgpJIG5ldmVyIHNhaWQgb3RoZXJ3aXNlLiBXaGF0 IEkgd2FzIGNvbmZ1c2VkIHdhcyB0aGF0IHlvdSBncm91cGVkCnRoaXMgd2l0aCBIVk1MaXRlIC0g d2hpY2ggd291bGQgbm90IGhhdmUgYSBwcm9ibGVtIGxpa2UgdGhpcy4KCj4gCj4gRm9ydHVuYXRl bHkgSSBoYXZlIGEgcHJvYWN0aXZlIHNvbHV0aW9uIGZvciBwdm9wcyBub3cgaW4gbXkgcGlwZWxp bmUgdGhhdAo+IHNob3VsZCBoZWxwIGF2b2lkIHVzIGhhdmluZyB0byBibG93IG1vcmUgdGhpbmdz IHVwIG9uIFhlbiBidXQgYWxzbyB0aGF0IHNob3VsZAo+IGNhdXNlIG5vIGhlYWRhY2hlcyBvbiBi ZWhhbGYgb2YgeDg2IGRldmVsb3BlcnMuIEJ1dCwgcmVhc29uIEkgaGF2ZSBiZWVuIHNvCj4gZW5n YWdlZCBvbiBIVk1MaXRlIGRlc2lnbiByZXZpZXcgaXMgSSB3YW50IHRvIGVuc3VyZSB3ZSB0YWtl IHRoZSBsZXNzb25zCj4gbGVhcm5lZCBmcm9tIHB2b3BzIGFuZCBhdm9pZCB0aGlzIGZvciBhbiBh cmNoaXRlY3R1cmUgdGhhdCB3aWxsIGJlIGRlZi1mYWN0bwo+IFhlbiBvbiBMaW51eCA1IHllYXJz IGZyb20gbm93Lgo+IAo+IE5vdCBicmluZ2luZyB0aGlzIHVwIG9yIGFkZHJlc3NpbmcgdGhpcyBu b3cgZm9yIEhWTUxpdGUgLyBQVkgyIHdvdWxkIHNpbXBseSBiZQo+IHNpbGx5LCBhbmQgc2luY2Ug aXQgd2Fzbid0IGFkZHJlc3NlZCBpbiBwdm9wcyBJIG9idmlvdXNseSBoYXZlIHRvIGVuc3VyZSBJ Cj4gY29udmluY2UgZW5vdWdoIHBlb3BsZSBpdCB3YXMgYSByZWFsIGlzc3VlIGFuZCBlbnN1cmUg dGhhdCB3ZSBoYXZlIGVub3VnaAo+IHNlbWFudGljcyBhdmFpbGFibGUgdG8gYWRkcmVzcyBpdC4K Ckthc2FuIGNhbWUgYWZ0ZXIgcHZvcHMsIHNvIG9mIGNvdXJzZSBpdCB3YXMgbm90IGFkZHJlc3Nl ZCBpbiBwdm9wcy4KCj4gCj4gUGFydCBvZiB0aGUgc2VtYW50aWNzIHF1ZXN0aW9uLCB3aGljaCBo YXMgbWFkZSBteSBxdWVzdCBoYXJkLCB3YXMgdGhlIHVzZSBvZgo+IHNlbWFudGljcyBmb3Igdmly dHVhbGl6YXRpb24gZm9yIGNvZGUgb24gZWFybHkgYm9vdCBhbmQgbGF0ZXIgaW4gYm9vdCBoYXMg YmVlbgo+IHJhdGhlciBzbG9wcHksIHNvIHdlIGhhdmUgcmVjZW50bHkgbmVlZGVkIHRvIGFkZHJl c3Mgc29tZSBvZiB0aGVzZSBnYXBzLiBTb21lCj4gb2YgdGhlc2UgZGlzY3Vzc2lvbnMgaGF2ZSBo b3dldmVyIGJlZW4gcHJvZHVjdGl2ZSwgYXMgSSdsbCBleHBsYWluIHRvIEdlb3JnZQo+IHNvb24g cmVnYXJkaW5nIGhpcyBEVCBxdWVzdGlvbnMuICBUaGUgZGlzY3Vzc2lvbiBpcyBub3Qgb3ZlciB0 aG91Z2ggYW5kIHdlIG5lZWQKPiB0byBlbnN1cmUgdGhhdCBpZiB3ZSBuZWVkIHNlbWFudGljcyBm b3IgSFZNTGl0ZSB3ZSdsbCBoYXZlIHRoZW0gYXZhaWxhYmxlIGluCj4gKmNsZWFuKiB3YXkuIE9u ZSBvZiB0aGUgdGhpbmdzIHdoZXJlIGVhcmx5IHNlbWFudGljcyBhbmQgZGVzaWduIHRvIGFkZHJl c3MKPiB0aGVzZSBpc3N1ZSBoZWxwIGluIGEgcHJvYWN0aXZlIG1hbm5lciBpcyB0byBhZGRyZXNz IGEgY2xlYW4gYm9vdCBlbnRyeSAtLSBhbmQKPiB0aGF0J3MgYWxzbyB3aHkgSSd2ZSBiZWVuIHNv IHBlZGFudGljIG92ZXIgcmV2aWV3IG9mIHRoZSBuZXcgSFZNbGl0ZSBib290Cj4gZW50cnkuCgpJ IG11c3QgaGF2ZSBtaXNzZWQgeW91ciByZXZpZXcgb2YgdGhlIHBhdGNoZXMuIFNvcnJ5IQo+IAo+ ID4gPiBYZW4gZXhwbG9kZXMuIFF1aWNrIHF1ZXN0aW9uLCB3aWxsIEthc2FuIG5vdCBleHBsb2Rl IHdpdGggSFZNTGl0ZSA/Cj4gPiAKPiA+IC4uIGJ1dCBmb3IgSFZNTGl0ZSBvZiBYZW4gSFZNIGd1 ZXN0IEthc2FuIHdpbGwgcnVuLgo+IAo+IEFyZSB5b3Ugc3VyZT8gU2hvdWxkIHRoYXQgbWVhbiB0 aGF0IFhlbiBIVk0gc2hvdWxkIGJlIGZpbmUgYXMgd2VsbC4gIERvZXMgdGhhdAo+IHdvcms/IEFy ZSB3ZSBzdXJlPwoKWWVzLCBhbmQgeWVzLgo+IAo+ID4gPiBNVFJSIHVzZWQgdG8gYmUgZGVhZCBj b2RlIGNvbmNlcm4gYnV0IHNpbmNlIHdlIGhhdmUgdmV0dGVkIG1vc3Qgb2YgdGhhdCBjb2RlCj4g PiA+IG5vdyB3ZSBhcmUgcHJldHR5IGNlcnRhaW4gdGhhdCBjb2RlIHNob3VsZCBuZXZlciBydW4g bm93Lgo+ID4gPiAKPiA+ID4gS0FTTFIgbWF5IGJlIC0tIG5vdCBzdXJlIGFzIEkgIGhhdmVuJ3Qg dmV0dGVkIHRoYXQsIGJ1dCBmcm9tCj4gPiA+IHdoYXQgSSBoYXZlIGxvb3NlbHkgaGVhcmQgbWF5 YmUuCj4gPiA+IAo+ID4gPiBWR0EgY29kZSB3aWxsIGJlIGRlYWQgY29kZSBmb3IgSFZNbGl0ZSBm b3Igc3VyZSBhcyB0aGUgZGVzaWduIGRvYwo+ID4gPiBzYXlzIGl0IHdpbGwgbm90IHJ1biBWR0Es IHRoZSBBQ1BJIGZsYWcgd2lsbCBiZSBzZXQgYnV0IHRoZSBjaGVjawo+ID4gPiBmb3IgdGhhdCBp cyBub3QgeWV0IG9uIExpbnV4LiBUaGF0IG1lYW5zIHRoZSBWR0EgTGludXggY29kZSB3aWxsCj4g PiA+IGJlIHRoZXJlIGJ1dCB3ZSBoYXZlIG5vIHdheSB0byBlbnN1cmUgaXQgd2lsbCBub3QgcnVu IG5vciB0aGF0Cj4gPiA+IGFueXRoaW5nIHdpbGwgbXVjayB3aXRoIGl0Lgo+ID4gCj4gPiA8c2hy dWdzPiBUaGUgd29yc3QgaXQgd2lsbCBkbyBpcyB0cnkgdG8gcmVhZCBub24tZXhpc3RlbnQgcmVn aXN0ZXJzLgo+IAo+IFJlYWxseSA/Cj4gCj4gSXMgdGhhdCB5b3VyIHBvc2l0aW9uIG9uIGFsbCBv dGhlciBwb3NzaWJsZSBkZWFkIGNvZGUgdGhhdCBtYXkgaGF2ZSBiZWVuCj4gcG9zc2libGUgb24g b2xkIFhlbiBQViBndWVzdHMgYXMgd2VsbCA/CgpUaGlzIGlzIG5vdCBqdXN0IHdpdGggWGVuIC0g aXQgd2l0aCBvdGhlciBkZXZpY2UgZHJpdmVycyB0aGF0IGFyZSBiZWluZwppbnZva2VkIG9uIGJh cmVtZXRhbCBhbmQgYXJlIG5vdCBwcmVzZW50IGluIGhhcmR3YXJlIGFueW1vcmUuCj4gCj4gQXMg SSBoaW50ZWQsIGFmdGVyIHRoaW5raW5nIGFib3V0IHRoaXMgZm9yIGEgd2hpbGUgSSByZWFsaXpl ZCB0aGF0IGRlYWQgY29kZSBpcwo+IGxpa2VseSBwcmVzZW50IG9uIGJhcmUgbWV0YWwgYXMgd2Vs bCBldmVuIHdpdGhvdXQgdmlydHVhbGl6YXRpb24sIHNwZWNpYWxseSBpZgoKWWVzIQo+IHlvdSBi dWlsZCBsYXJnZSBzaW5nbGUga2VybmVscyB0byBzdXBwb3J0IGEgd2lkZSBhcnJheSBvZiBmZWF0 dXJlcyB3aGljaCBvbmx5Cj4gbGF0ZSBhdCBydW4gdGltZSBjYW4gYmUgZGV0ZXJtaW5lZC4gVmly dHVhbGl6YXRpb24gYW5kIHRoZSBwdm9wcyBkZXNpZ24ganVzdAo+IG1ha2VzIHRoaXMgaXNzdWUg bXVjaCBtb3JlIHByb21pbmVudC4gSWYgdGhlcmUgYXJlIG90aGVyIGFyZWFzIG9mIGNvZGUgZXhw b3NlZAo+IHRoYXQgYWN0dWFsbHkgbWF5IHJ1biwgYnV0IHdlIGFyZSBub3Qgc3VyZSBtYXkgcnVu LCBJIGZpZ3VyZWQgc29tZSBvdGhlciBmb2xrcwo+IHdpdGggYSBiaXQgbW9yZSBzZWN1cml0eSBj b25zY2llbmNlIG1pbmRzIG1pZ2h0IGV2ZW4gc2ltcGx5IHRha2UgdGhlIHBvc2l0aW9uCj4gaXQg bWF5IGJlIGEgc2VjdXJpdHkgcmlzayB0byBsZWF2ZSB0aGF0IGNvZGUgZXhwb3NlZC4gU28gdG8g dGFrZSBhIHBvc2l0aW9uCj4gdGhhdCAndGhlIHdvcnN0IGl0IHdpbGwgZG8gaXMgdHJ5IHRvIHJl YWQgbm9uLWV4aXN0ZW50IHJlZ2lzdGVycycgLS0gc2VlbXMKPiByYXRoZXIgc2hvcnRzaWdodGVk IGhlcmUuCgpTZWN1cml0eSBjb25zY2lvdXMgcGVvcGxlIHRyaW0gdGhlaXIgQ09ORklHLgo+ICAK PiBBbnl3YXkgZm9yIG1vcmUgZGV0YWlscyBvbiB0aG91Z2h0cyBvbiB0aGlzIHJlZmVyIHRvIHRo ZSB0aGlzIHdpa2k6Cj4gCj4gaHR0cDovL2tlcm5lbG5ld2JpZXMub3JnL0tlcm5lbFByb2plY3Rz L2tlcm5lbC1zYW5kYm94aW5nCj4gCj4gU2luY2UgdGhpcyBpcyBub3cgZ2V0dGluZyBvZmYgdG9w aWMgcGxlYXNlIHNlbmQgbWUgeW91ciBmZWVkYmFjayBvbiBhbm90aGVyCj4gdGhyZWFkIGZvciB0 aGUgbm9uLXZpcnR1YWxpemF0aW9uIGFzcGVjdHMgb2YgdGhpcyBpZiB0aGF0IGludGVyZXN0cyB5 b3UuIE15Cj4gcG9pbnQgaGVyZSB3YXMgcmF0aGVyIHRvIGhpZ2hsaWdodCB0aGUgaW1wb3J0YW5j ZSBvZiBjbGVhciBzZW1hbnRpY3MgZHVlIHRvCj4gdmlydHVhbGl6YXRpb24gaW4gbGlnaHQgb2Yg cG9zc2libGUgZGVhZCBjb2RlLgoKVGhhbmsgeW91Lgo+IAo+ID4gVGhlIFZHQSBjb2RlIHNob3Vs ZCBiZSBhYmxlIHRvIGhhbmRsZSBmYWlsdXJlcyBsaWtlIHRoYXQgYW5kCj4gPiBub3QgaW5pdGlh bGl6ZSBpdHNlbGYgd2hlbiB0aGUgaGFyZHdhcmUgaXMgZGVhZCAob3Igbm9uLWV4aXN0ZW50KS4K PiAKPiBUaGF0J3MgcmlnaHQsIGl0cyB0aHJvdWdoIEFDUElfRkFEVF9OT19WR0EgYW5kIHNpbmNl IGl0cyBwYXJ0IG9mIHRoZSBIVk1MaXRlCj4gZGVzaWduIGRvYyB3ZSB3YW50IEhWTWxpdGUgZGVz aWduIHRvIGFkZHJlc3MgQUNQSV9GQURUX05PX1ZHQSBwcm9wZXJseS4gIEkndmUKPiBwYXZlZCB0 aGUgd2F5IGZvciB0aGlzIHRvIGJlIGRvbmUgY2xlYW5seSBhbmQgZWFzaWx5IG5vdywgYnV0IHRo YXQgY29kZSBzaG91bGQKPiBiZSBpbiBwbGFjZSBiZWZvcmUgSFZNTGl0ZSBjb2RlIGdldHMgbWVy Z2VkLgo+IAo+IERvZXMgZG9tVSBmb3Igb2xkIFhlbiBQViBhbHNvIHNldCBBQ1BJX0ZBRFRfTk9f VkdBIGFzIHdlbGwgPyAgU2hvdWxkIGl0ID8KCkl0IGRvZXMgbm90LiBOb3Qgc3VyZSAtIGl0IHNl ZW1zIHRvIGhhdmUgd29ya2VkIGZpbmUgZm9yIHRoZSBsYXN0IHRlbgp5ZWFycz8KPiAKPiA+ID4g VG8gYmUgY2xlYXIgLS0gZGVhZCBjb2RlIGNvbmNlcm5zIHN0aWxsIGV4aXN0IGV2ZW4gd2l0aG91 dAo+ID4gPiB2aXJ0dWFsaXphdGlvbiBzb2x1dGlvbnMsIGl0cyBqdXN0IHRoYXQgd2l0aCB2aXJ0 dWFsaXphdGlvbgo+ID4gPiB0aGlzIHN0dWZmIGNvbWVzIHVwIG1vcmUgYW5kIHRoZXJlIGhhcyBi ZWVuIG5vIHByb2FjdGl2ZQo+ID4gPiBtZWFzdXJlcyB0byBhZGRyZXNzIHRoaXMuIFRoZSBxdWVz dGlvbiBvZiBzZW1hbnRpY3MgaGVyZSBpcwo+ID4gPiB0byBzZWUgdG8gd2hhdCBleHRlbnQgd2Ug bmVlZCBlYXJsaWVyIGJvb3QgY29kZSBhbm5vdGF0aW9ucwo+ID4gPiB0byBlbnN1cmUgd2UgYWRk cmVzcyBzZW1hbnRpY3MgcHJvYWN0aXZlbHkuCj4gPiAKPiA+IEkgdGhpbmsgd2hhdCB5b3UgbWVh biBieSBkZWFkIGNvZGUgaXMgYW5vdGhlciB3b3JkIGZvcgo+ID4gaGFyZHdhcmUgdGVzdCBjb3Zl cmFnZT8KPiAKPiBObywgbm8sIGl0cyB2ZXJ5IGRpZmZlcmVudCBnaXZlbiB0aGF0IHdpdGggdmly dHVhbGl6YXRpb24gdGhlIHNjb3BlIG9mIHBvc3NpYmxlCj4gZGVhZCBjb2RlIGlzIHNpZ25pZmlj YW50IGFuZCBhdCBydW4gdGltZSB5b3UgYXJlIGNlcnRhaW4gYSBodWdlIHBvcnRpb24gb2YgY29k ZQo+IHNob3VsZCAqbmV2ZXIgZXZlciogcnVuLiBTbyBmb3IgaW5zdGFuY2Ugd2Uga25vdyBvbmNl IHdlIGJvb3QgYmFyZSBtZXRhbCBub25lCj4gb2YgdGhlIFhlbiBzdHVmZiBzaG91bGQgZXZlciBy dW4sIGxpa2V3aXNlIG9uIFhlbiBkb20wIHdlIGtub3cgbm9uZSBvZiB0aGUgS1ZNCj4gLyBiYXJl LW1ldGFsIG9ubHkgc3R1ZmYgc2hvdWxkIG5ldmVyIHJ1biwgd2hlbiBvbiBYZW4gZG9tVSwgbm9u ZSBvZiB0aGUgWGVuCgpXaGF0IGlzIHRoaXMgJ2JhcmUgbWV0YWwgb25seSBzdHVmZicgeW91IHNw ZWFrIG9mPyBPbiBYZW4gZG9tMCBtb3N0IG9mCnRoZSBiYXJlbWV0YWwgY29kZSBpcyBydW5uaW5n LiBJbiBmYWN0IHRoYXQgaXMgaG93IHRoZSBkZXZpY2UgZHJpdmVycwp3b3JrLiBPciBhcmUgeW91 IHRhbGtpbmcgYWJvdXQgbG93IGxldmVsIGJhcmVtZXRhbCBjb2RlPyBJZiBzbywgdGhlbgpQVkgv SFZNTGl0ZSBkb2VzIHRoYXQgLSBpdCBza2lwcyBwdm9wcyBzbyB0aGF0IGl0IGNhbiBydW4gdGhp cwonbG93LWxldmVsIGJhcmVtZXRhbCBjb2RlJwoKPiBkb21VLW9ubHkgc3R1ZmYgc2hvdWxkIGV2 ZXIgcnVuLgoKWW91IGZvcmdvdCBLVk0gZ3Vlc3Qgc3VwcG9ydCBvbiBiYXJlbWV0YWwuIFRoYXQg c2hvdWxkbid0IHJ1biBlaXRoZXIuCgo+IAo+ID4gPiA+IFRoZSBlbnRyYWNlIHBvaW50IGluIExp bnV4ICJwcm9wZXIiIGlzIHN0YXJ0dXBfMzIgb3Igc3RhcnR1cF82NCAtIHRoZSBzYW1lCj4gPiA+ ID4gcGF0aCB0aGF0IEVGSSB1c2VzLgo+ID4gPiA+IAo+ID4gPiA+IElmIHlvdSB3ZXJlIHRvIGRy YXcgdGhpcyAodmVyeSBzaW1wbGlmaWVkKToKPiA+ID4gPiAKPiA+ID4gPiBhKS0gR1JVQjIgLS0t LS0tLS0tLS0tLS0tLS0tLS0tXCAoY3JlYXRlcyBhbiBib290cGFyYW0gc3RydWN0dXJlKQo+ID4g PiA+ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+ID4gPiA+ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICstLS0tIHN0YXJ0dXBfMzIgb3Igc3RhcnR1cF82NAo+ID4g PiA+IGIpIEVGSSAtPiBMaW51eCBFRkkgc3R1YiAtLS0tLS0tLwo+ID4gPiA+ICAgICAgICAoY3Jl YXRlcyBib290cGFybSkgICAgICAvCj4gPiA+ID4gYykgR1JVQjItRUZJICAtPiBMaW51eCBFRkkt LS0tLwo+ID4gPiA+ICAgICAgICAgICAgICAgIHN0dWIgICAgICAgICAvCj4gPiA+ID4gZCkgSFZN TGl0ZSAtLS0tLS0tLS0tLS0tLS0tLwo+ID4gPiA+ICAgICAgIChjcmVhdGVzIGJvb3RwYXJtKQo+ ID4gPiAKPiA+ID4gYikgYW5kIGQpIG1pZ2h0IGJlIGFibGUgdG8gc2hhcmUgcGF0aHMgdGhlcmUu Li4KPiA+IAo+ID4gTm8gaWRlYS4gWW91IHdvdWxkIGhhdmUgdG8gbG9vayBpbiB0aGUgYXNzZW1i bGVyIGNvZGUgdG8KPiA+IGZpZ3VyZSB0aGF0IG91dC4KPiAKPiBBbmQgdGhhdCdzIGEgcGFpbiwg SSBnZXQgaXQuCj4gCj4gSSBzcG90dGVkIG9uZSBwbGFjZSBhbHJlYWR5IC0tIHdpbGwgbm90ZSB0 byBCb3Jpcy4gSSB0aGluayBNYXR0IG1heSBoYXZlIG1vcmUKPiBpZGVhcyA7KQo+IAo+ID4gPiBk KSBzdGlsbCBoYXMgaXRzIG93biBlbnRyeSwgaXQgZG9lcyBtb3JlIHRoYW4gY3JlYXRlIGJvb3Qg cGFyYW1zLgo+ID4gCj4gPiBkKSBwdXJwb3NlIGlzIHRvIGNyZWF0ZSBib290IHBhcmFtcy4KPiAK PiBPSyBnb29kIHRvIGtub3cgdGhhdCdzIHRoZSBvbmx5IHRoaW5nIHdlIGFja25vd2xlZGdlIGl0 ICpzaG91bGQqIGRvLgoKQW5kIGIpLCBjKSBwdXJwb3NlIGlzIGZvciB0aGF0IHRvbyAtIGFtb25n dHMgcHJvdmlkaW5nIGFuIG1lY2hhbmlzbQp0byBjYWxsIGluIEVGSSBmaXJtd2FyZS4KCkFuZCBJ IHJlYWxpemVkIHRoYXQgZWFybHkgYmFyZW1ldGFsIGJvb3Qgb3B0aW9uIGFsc28gZW5kcyB1cCBj YWxsaW5nIEMgZHVyaW5nCml0cyBzdGFydHVwIChzZWUgbWFpbiBpbiBhcmNoL3g4Ni9ib290L21h aW4uYykgYW1vbmdzdCB0aGVuIHN3aXRjaGluZwpkaWZmZXJlbnQgbW9kZXMuCgo+IAo+ID4gIEl0 IG1heSBkbyBtb3JlIGFzIG5vYm9keSBsaWtlcyB0byBtdWNrIGluIGFzc2VtYmxlciBhbmQgbWFr ZSBib290cGFyYW1zIGZyb20KPiA+ICB3aXRoaW4gYXNzZW1ibGVyLgo+IAo+IE9LIC0tIGl0IGRv ZXMgZG8gbW9yZSBhbmQgdGhhdCdzIHdoZXJlIHdlJ2QgbGlrZSB0byBhdm9pZCBkdXBsaWNhdGlv biBpZgo+IHBvc3NpYmxlIGFuZCB5ZXQtYW5vdGhlci1lbnRyeSAoVE0pLgoKSXQgZG9lcyBtb3Jl PyBFRkkgc3R1YiBlbnRyeSBkb2VzIG1vcmUgdGhhbiB0aGUgR1JVQjIgZW50cnkuCgpJZiB5b3Ug aGF2ZSBzb21lIHBhdGNoZXMgdG8gdHJpbSB0aGUgY29kZSBkdXBsaWNhdGlvbiB3aXRoaW4KdGhv c2UgYm9vdCBwYXRocy0gcGxlYXNlIHBvc3QgaXQuCj4gCj4gPiA+ID4gKEkgYW0gbm90IHN1cmUg YWJvdXQgdGhlIGMpIC0gSSB3b3VsZCBoYXZlIHRvIGxvb2sgaW4gc291cmNlIHRvCj4gPiA+ID4g YmUgc291cmNlKS4gVGhlcmUgaXMgYWxzbyBMSUxPIGluIHRoaXMsIGJ1dCBJIGFtIG5vdCBldmVu IHN1cmUgaWYKPiA+ID4gPiB3b3JrcyBhbnltb3JlLgo+ID4gPiA+IAo+ID4gPiA+IAo+ID4gPiA+ IFdoYXQgeW91IGhhdmUgaXMgdGhhdCBldmVyeSBlbnRyeSBwb2ludCBjcmVhdGVzIHRoZSBib290 cGFyYW1zCj4gPiA+ID4gYW5kIGVuZHMgdXAgY2FsbGluZyBzdGFydHVwX1guIFRoZSBzdGFydHVw XzY0IHRoZW4gaGl0IHRoZSByZXN0Cj4gPiA+ID4gb2YgdGhlIGtlcm5lbC4gVGhlIHN0YXJ0cF9Y IGNvZGUgaXMgdGhlIG9uZSB0aGF0IHdvdWxkIHNldHVwCj4gPiA+ID4gdGhlIGJhc2ljIHBhZ2V0 YWJsZXMsIHNlZ21lbnRzLCBldGMuCj4gPiA+IAo+ID4gPiBTdXJlLi4gYSBmdWxsIGRpYWdyYW0g c2hvdWxkIGluY2x1ZGUgYm90aCBzaWRlcyBhbmQgaG93IHdoZW4gdXNpbmcKPiA+ID4gYSBjdXN0 b20gZW50cnkgb25lIHJ1bnMgdGhlIHJpc2sgb2Ygc2tpcHBpbmcgYSBsb3Qgb2YgY29kZSBzZXR1 cC4KPiA+IAo+ID4gQnV0IGl0IGRvZXMgbm90IHNraXAgYSBsb3Qgb2YgY29kZSBzZXR1cC4gSXQg c3RhcnRzIGV4YWN0bHkKPiA+IGF0IHRoZSBzYW1lIGNvZGUgc3RhcnR1cCB0aGF0IF9hbGxfIGJv b3RzdHJhcGluZyBjb2RlIHN0YXJ0IGF0Lgo+IAo+IEl0cyBhIGZhaXIgcG9pbnQuCj4gCj4gPiA+ IFRoZXJlIGlzIHRoYXQgYW5kIGFzIG90aGVycyBoYXZlIHBvaW50ZWQgb3V0IGhvdyBjZXJ0YWlu IGd1ZXN0cyB0eXBlcwo+ID4gPiBhcmUgYXNzdW1lZCB0byBub3QgaGF2ZSBjZXJ0YWluIHBlcmlw aGVyYWxzLCBhbmQgd2UgaGF2ZSBubyBpZGVhCj4gPiA+IHRvIGVuc3VyZSBjZXJ0YWluIG9sZCBs ZWdhY3kgY29kZSBtYXkgbm90IGV2ZXIgcnVuIG9yIGJlIGFjY2Vzc2VkCj4gPiA+IGJ5IGRyaXZl cnMuCj4gPiAKPiA+IE9rLCBidXQgdGhhdCBpcyBub3QgYXQgY29kZSBzZXR1cC4gVGhhdCBpcyBs YXRlciAtIHdoZW4gZGV2aWNlCj4gPiBkcml2ZXJzIGFyZSBpbml0aWFsaXplZC4gVGhpcyBubyBk aWZmZXJlbnQgdGhhbiBib290aW5nIG9uCj4gPiBzb21lIGhhcmR3YXJlIHdpdGggbWlzc2luZyBm dW5jdGlvbmFsaXR5LiBBQ1BJLCBQQ0kgYW5kIFBuUAo+ID4gUG5QIGFyZSBzZXQgdGhlcmUgdG8g aGVscCBPU2VzIGRpc2NvdmVyIHRoaXMuCj4gCj4gVG8gYSBjZXJ0YWluIGV4dGVudCB0aGlzIGlz IHRydWUsIGJ1dCB0aGVyZSBtYXkgdGhpbmdzIHdoaWNoIGFyZSBtaXNzaW5nIHN0aWxsLgoKTGlr ZT8KPiAKPiBXZSByZWFsbHkgaGF2ZSBubyBpZGVhIHdoYXQgdGhlIGZ1bGwgbGlzdCBvZiB0aG9z ZSB0aGluZ3MgYXJlLgoKT2ssIGl0IHNvdW5kcyBsaWtlIHlvdSBoYXZlIHNvbWUgaG9tZXdvcmsu Cj4gCj4gSXQgbWF5IGJlIHRoYXQgdGhpbmdzIG1heSBoYXZlIGJlZW4gcnVubmluZyBmb3IgYWdl cyB3aXRob3V0IG5vdGljZSBvZiBhbiBpc3N1ZQo+IG9yIHRoYXQgb25seSB1bmRlciBjZXJ0YWlu IHNpdHVhdGlvbnMgd2lsbCBjZXJ0YWluIGlzc3VlcyBvciBidWdzIHRyaWdnZXIgYQo+IGZhaWx1 cmUuIEZvciBpbnN0YW5jZSwganVzdCB5ZXN0ZXJkYXkgSSB3YXMgQ2MnZCBvbiBhIGJyYW5kLXNw YW5raW5nIG5ldyBsZWdhY3kKPiBjb25mbGljdCBbMF0sIGNhdXNlZCBieSB1cHN0cmVhbSBjb21t aXQgOGMwNThiMGI5YzM0ZDhjICgieDg2L2lycTogUHJvYmUgZm9yCj4gUElDIHByZXNlbmNlIGJl Zm9yZSBhbGxvY2F0aW5nIGRlc2NzIGZvciBsZWdhY3kgSVJRcyIpIG1lcmdlZCBvbiB2NC40IHdo ZXJlCj4gc29tZSBuZXcgY29kZSB1c2VkIG5yX2xlZ2FjeV9pcnFzKCkgLS0gb25lIHByb3Bvc2Vk IHNvbHV0aW9uIHNlZW1zIHRvIGJlIHRoYXQKPiBmb3IgWGVuIGNvZGUgTlJfSVJRU19MRUdBQ1kg c2hvdWxkIGJlIHVzZWQgaW5zdGVhZCBpcyBhcyBpdCBsYWNrcyBQQ0kgWzFdIGFuZAo+IGFub3Ro ZXIgd2FzIHRvIHBlZyB0aGUgbGVnYWN5IHJlcXVpcmVtZW50cyBhcyBhIHF1aXJrIG9uIHRoZSBu ZXcgeDg2IHBsYXRmb3JtCj4gbGVnYWN5IHF1aXJrIHN0dWZmIFsyXS4gQXJlIG90aGVyIHVzZXMg b2YgbnJfbGVnYWN5X2lycXMoKSBjb3JyZWN0ID8gQXJlCj4gd2Ugc3VyZSA/CgpBbmQgaG93IGlz IHRoaXMgZXhhbXBsZSByZWxhdGVkIHRvICdlYXJseSBib290dXAnIHBhdGg/CgpJdCBpcyBub3Qu CgpJdCBpcyBpbiBmYWN0IHJlbGF0ZWQgdG8gUFYgY29kZXBhdGhzIC0gd2hpY2ggUFZIL0hWTUxp dGUgYW5kIEhWTSBndWVzdHMKZG8gbm90IGV4ZXJjaXNlLgo+IAo+IFswXSBodHRwOi8vbGttbC5r ZXJuZWwub3JnL3IvNTcwRjkwREYuMTAyMDUwOEBvcmFjbGUuY29tCj4gWzFdIGh0dHBzOi8vbGtt bC5vcmcvbGttbC8yMDE2LzQvMTQvNTMyCj4gWzJdIGh0dHA6Ly9sa21sLmtlcm5lbC5vcmcvci8x NDYwNTkyMjg2LTMwMC0xLWdpdC1zZW5kLWVtYWlsLW1jZ3JvZkBrZXJuZWwub3JnCj4gCj4gPiA+ ID4gPiBIb3cgd2UgYWRkcmVzcyBzZW1hbnRpY3MgdGhlbiBpcyAqdmVyeSogaW1wb3J0YW50IHRv IG1lLgo+ID4gPiA+IAo+ID4gPiA+IFdoaWNoIHNlbWFudGljcz8gSG93IHRoZSBDUFUgaXMgZ29p bmcgdG8gYmUgYXQgc3RhcnR1cF9YID8gT3IKPiA+ID4gPiBob3cgdGhlIENQVSBpcyBnb2luZyB0 byBiZSB3aGVuIEVGSSBmaXJtd2FyZSBpbnZva2VzIHRoZSBFRkkgc3R1Yj8KPiA+ID4gPiBPciB3 aGVuIEdSVUIyIGxvYWRzIExpbnV4Pwo+ID4gPiAKPiA+ID4gV2hhdCBoeXBlcnZpc29yIGtpY2tl ZCBtZSBhbmQgd2hhdCBndWVzdCB0eXBlIEkgYW0uCj4gPiAKPiA+IGNwdWlkIHNvZnR3YXJlIGZs YWdzIGhhdmUgdGhhdCAtIGFuZCB0aGF0IHNlbWFudGljcyBoYXMgYmVlbiAKPiA+IHRoZXJlIGZv ciBlb25zLgo+IAo+IFdlIGNhbm5vdCB1c2UgY3B1aWQgZWFybHkgaW4gYXNtIGNvZGUsIEknbSBs b29raW5nIGZvciBzb21ldGhpbmcgd2UKCj8hIFdoeSE/Cj4gY2FuIGV2ZW4gdXNlIG9uIGFzbSBl YXJseSBpbiBib290IGNvZGUsIG9uIHg4NiB0aGUgYmVzdCBvcHRpb24gd2UKPiBoYXZlIGlzIHRo ZSBib290X3BhcmFtcywgYnV0IEkndmUgZXZlbiBoYXZlIGhhZCBpc3N1ZXMgd2l0aCB0aGF0Cj4g ZWFybHkgaW4gY29kZSwgYXMgSSBjYW4gb25seSBhY2Nlc3MgaXQgYWZ0ZXIgbG9hZF9pZHQoKSB3 aGVyZSBJCj4gZGVzY3JpYmVkIG15IGVmZm9ydCB0byB1bmlmeSBYZW4gUFYgYW5kIHg4Nl82NCBp bml0IHBhdGhzIFszXS4KCldlbGwsIFhlbiBQViBza2lwcyB4ODZfNjRfc3RhcnRfa2VybmVsLi4K PiAKPiBbM10gaHR0cDovL2xrbWwua2VybmVsLm9yZy9yL0NBQj1ORTZWVENSQ2F6Y05wQ2RKN3BO MWVEMz14X2ZjR09kSDM3TXpWcHhrS0VONWVzd0BtYWlsLmdtYWlsLmNvbQo+IAo+ID4gPiBMZXQg bWUgZWxhYm9yYXRlIG1vcmUgYmVsb3cuCj4gPiA+IAo+ID4gPiA+IFRoYXQgKHRob3NlIGJvb3Rs b2FkZXJzKSBpcyBjbGVhcmx5IGRlZmluZWQuIFRoZSBVUkwgSSBwcm92aWRlZAo+ID4gPiA+IG1l bnRpb25zIHRoZSBIVk1MaXRlIG9uZS4gVGhlIERvY3VtZW50YXRpb24veDg2L2Jvb3QuYyBtZW50 aW9ucwo+ID4gPiA+IHdoYXQgdGhlIHNlbWFudGljcyBhcmUgdG8gZXhwZWN0ZWQgd2hlbiBwcm92 aWRpbmcgYW4gYm9vdHN0cmFwCj4gPiA+ID4gKHdoaWNoIGlzIHdoYXQgSFZNTGl0ZWwgc3R1YiBj b2RlIGluIExpbnV4IHdvdWxkIHdyaXRlIGFnYWluc3QgLQo+ID4gPiA+IGFuZCB3aGF0IEVGSSBz dHViIGNvZGUgaGFkIGJlZW4gd3JpdHRlbiBhZ2FpbnN0IHRvbykuCj4gPiA+ID4gPiAKPiA+ID4g PiA+ID4gPiBJJ2xsIGVsYWJvcmF0ZSBvbiB0aGlzIGJ1dCBmaXJzdCBsZXQncyBjbGFyaWZ5IHdo eSBhIG5ldyBlbnRyeSBpcyB1c2VkIGZvcgo+ID4gPiA+ID4gPiA+IEhWTWxpdGUgdG8gc3RhcnQg b2Ygd2l0aDoKPiA+ID4gPiA+ID4gPiAKPiA+ID4gPiA+ID4gPiAgIDEpIFhlbiBBQkkgaGFzIGhp c3RvcmljYWxseSBub3Qgd2FudGVkIHRvIHNldCB1cCB0aGUgYm9vdCBwYXJhbXMgZm9yIExpbnV4 Cj4gPiA+ID4gPiA+ID4gICAgICBndWVzdHMsIGluc3RlYWQgaXQgaW5zaXN0cyBvbiBsZXR0aW5n IHRoZSBMaW51eCBrZXJuZWwgWGVuIGJvb3Qgc3R1YnMgZmlsbAo+ID4gPiA+ID4gPiA+ICAgICAg dGhhdCBvdXQgZm9yIGl0LiBUaGlzIHN0aWNraW5nIHBvaW50IG1lYW5zIGl0IGhhcyBpbXBsaWNh dGVkIGEgYm9vdCBzdHViLgo+ID4gPiA+ID4gPiAKPiA+ID4gPiA+ID4gCj4gPiA+ID4gPiA+IFdo aWNoIGlzIGIvYyBpdCBoYXMgdG8gYmUgT1MgYWdub3N0aWMuIEl0IGhhcyBub3RoaW5nIHRvIGRv ICdub3Qgd2FudGluZycuCj4gPiA+ID4gPiAKPiA+ID4gPiA+IEl0IGNhbiBzdGlsbCBiZSBPUyBh Z25vc3RpYyBhbmQgcGFzcyBvbiB0eXBlIGFuZCBjdXN0b20gZGF0YSBwb2ludGVyLgo+ID4gPiA+ IAo+ID4gPiA+IFN1cmUuIEl0IGhhcyB0aGF0IChpdCBNVVNUIG90aGVyd2lzZSBob3cgZWxzZSB3 b3VsZCB5b3UgcGFzcyBkYXRhKS4KPiA+ID4gPiBJdCBpcyBkb2N1bWVudGVkIGFzIHdlbGwgaHR0 cDovL3hlbmJpdHMueGVuLm9yZy9kb2NzL3Vuc3RhYmxlL2h5cGVyY2FsbC94ODZfNjQvaW5jbHVk ZSxwdWJsaWMseGVuLmguaHRtbCNpbmNvbnRlbnRzX3N0YXJ0b2ZkYXkKPiA+ID4gPiAoc2VlICIg U3RhcnQgb2YgZGF5IHN0cnVjdHVyZSBwYXNzZWQgdG8gUFZIIGd1ZXN0cyBpbiAlZWJ4LiIpCj4g PiA+IAo+ID4gPiBUaGUgZGVzaWduIGRvYyBiZWdzIGZvciBhIGN1c3RvbSBPUyBlbnRyeSBwb2lu dCB0aG91Z2guCj4gPiAKPiA+IFRoYXQgaXMgd2hhdCB0aGUgRUxGIE5vdGUgaGFzLgo+IAo+IFJp Z2h0LCBidXQgSSdtIHNheWluZyB0aGF0IGl0cyByYXRoZXIgc2lsbHkgdG8gYmUgYWRkaW5nIGVu dHJ5IHBvaW50cyBpZgo+IGFsbCB3ZSB3YW50IHRoZSBjb2RlIHRvIGRvIGlzIGNvcHkgdGhlIGJv b3QgcGFyYW1zIGZvciB1cy4gVGhlIGRlc2lnbgo+IGRvYyByZXF1aXJlcyBhIG5ldyBlbnRyeSwg YW5kIGxpa2V3aXNlIHlvdSdkIG5lZWQgeWV0LWFub3RoZXItZW50cnkgaWYKPiBIVk1MaXRlIGlz IHRocm93biBvdXQgdGhlIHdpbmRvdyBhbmQgY29tZSBiYWNrIDUgeWVhcnMgbGF0ZXIgYWZ0ZXIg bmV3Cj4gaGFyZHdhcmUgc29sdXRpb25zIGFyZSBpbiBwbGFjZSBhbmQgbmVlZCB0byByZWRlc2ln biBIVk1MaXRlLiBLaW5kIG9mCgpXaHkgd291bGQgeW91IG5lZWQgdG8gcmVkZXNpZ24gSFZNTGl0 ZSBiYXNlZCBvbiBoYXJkd2FyZSBzb2x1dGlvbnM/ClRoZSBlbnRyYWNlIHBvaW50IGFuZCB0aGUg Q1BVIHN0YXRlIGFyZSBwcmV0dHkgd2VsbCBrbm93biAtIGl0IGlzIGFraW4KdG8gd2hhdCBHUlVC MiBib290bG9hZGVyIHBhdGggaXMgKHByb3RlY3RlZCBtb2RlKS4KPiB3aGVyZSB3ZSBhcmUgd2l0 aCBQVkggdG9kYXkuIExpa2V3aXNlIGlmIG90aGVyIHBhcmF2aXJ0dWFsaXphdGlvbgo+IGRldmVs b3BlcnMgd2FudCB0byBzdXBwb3J0IExpbnV4IGFuZCB3YW50IHRvIGNvcHkgeW91ciBzdHJhdGVn eSB0aGV5J2QKPiBhZGQgeWV0LWFub3RoZXItZW50cnktcG9pbnQgYXMgd2VsbC4KPiAKPiBUaGlz IGlzIGR1bWIuCgpZb3Ugc2F5aW5nIHRoZSBFRkkgZW50cnkgcG9pbnQgaXMgZHVtYj8gVGhhdCBp bnN0ZWFkIHRoZSBFRkkKZmlybXdhcmUgc2hvdWxkIHVuZGVyc3RhbmQgTGludXggYm9vdHBhcmFt cyBhbmQgYm9vdGVkIHRoYXQ/Cgo+IAo+ID4gPiBJZiB3ZSBoYWQgYSBzaW5nbGUgJ3R5cGUnIGFu ZCAnY3VzdG9tIGRhdGEnIHBhc3NlZCB0byB0aGUga2VybmVsIHRoYXQKPiA+ID4gc2hvdWxkIHN1 ZmZpY2UgZm9yIHRoZSBkZWZhdWx0IExpbnV4IGVudHJ5IHBvaW50IHRvIGp1c3QgcGl2b3Qgb2Zm Cj4gPiA+IG9mIHRoYXQgYW5kIGRvIHdoYXQgaXQgbmVlZHMgd2l0aG91dCBtb3JlIGVudHJ5IHBv aW50cy4gT25jZS4KPiA+IAo+ID4gQW5kIHdoYXQgYWJvdXQgcmFtZGlzaz8gV2hhdCBhYm91dCBt dWx0aXBsZSByYW1kaXNrcz8KPiA+IFdoYXQgYWJvdXQgY29tbWFuZCBsaW5lPyBBbGwgb2YgdGhh dCBpcyB3aGF0IGJvb3RwYXJhbXMKPiA+IHRyaWVzIHRvIHVuaWZ5IG9uIExpbnV4LiBCdXQgJ2Jv b3RwYXJhbXMnIGlzIHVuaXF1ZSB0byBMaW51eCwKPiA+IGl0IGRvZXMgbm90IGV4aXN0IG9uIEZy ZWVCU0QuIEhlbmNlIHNvbWUgc3R1YiBjb2RlIHRvIHRyYW5zcGxhbnQKPiA+IE9TLWFnbm9zdGlj IHNpbXBsZSBkYXRhIHRvIE9TLXNwZWNpZmljIGlzIG5lY2Nlc3NhcnkuCj4gCj4gSWYgd2UgaGFk IGEgWGVuIEFCSSBvcHRpb24gd2hlcmUgKmFsbCogdGhhdCBJJ20gYXNraW5nIGlzIHlvdSBwYXNz Cj4gZmlyc3Q6Cj4gCj4gICBhKSBoeXBlcnZpc29yIHR5cGUKCldoeSBjYW4ndCB5b3UgdXNlIGNw dWlkLgo+ICAgYikgY3VzdG9tIGRhdGEgcG9pbnRlcgoKV2hhdCBpcyB0aGlzIGN1c3RvbSBkYXRh IHBvaW50ZXIgeW91IHNwZWFrIG9mPwo+IAo+IFdlJ2QgYmUgYWJsZSB0byBhdm9pZCBhZGRpbmcg KmFueSogZW50cnkgcG9pbnQgYW5kIGp1c3QgYWRkcmVzcwo+IHRoZSByZXF1aXJlbWVudHMgYXMg SSBub3RlZCB3aXRoIHByZSAvIHBvc3Qgc3R1YnMgZm9yIHRoZSB0eXBlLgoKQnV0IHlvdSBuZWVk IHNvbWUgZW50cnkgcG9pbnQgdG8gY2FsbCBpbnRvIExpbnV4LiBBcmUgeW91CnN1Z2dlc3Rpbmcg dG8gdXNlIHRoZSBleGlzdGluZyBvbmVzPyBObywgdGhlIGV4aXN0aW5nIG9uZQp3b3VsZG4ndCB1 bmRlcnN0YW5kIHRoaXMuCgo+IFRoaXMgd291bGQgcmVxdWlyZSBhbiB4ODYgYm9vdCBwcm90b2Nv bCBidW1wLCBidXQgYWxsIHRoZSBpc3N1ZXMKPiBjcmVlcGluZyB1cCByYW5kb21seSBJIHRoaW5r IHRoYXQncyB3b3J0aCBwdXR0aW5nIG9uIHRoZSB0YWJsZSBub3cuCgpBYWFhaCwgc28geW91IGFy ZSBzYXlpbmcgZXhwYW5kIHRoZSBib290cGFyYW1zLiBJbiBvdGhlciB3b3JkcwptYWtlIFhlbiBB QkkgY2FsbCBpbnRvIExpbnV4IHVzaW5nIHRoZSBib290cGFyYW1zIHN0cnVjdHVyZSwgc2ltaWxh cgp0byBob3cgR1JVQjIgZG9lcyBpdC4KCkhvdyBpcyB0aGF0IE9TIGFnbm9zdGljPwo+IAo+IEFu ZCBtYXliZSB3ZSBkb24ndCB3YW50IGl0IHRvIGJlIGh5cGVydmlzb3Igc3BlY2lmaWMsIHBlcmhh cHMgdGhlcmUgYXJlIG90aGVyCj4gKm5lZWRzKiBmb3IgY3VzdG9tIHByZS1wb3N0IHN0YXJ0dXBf MzIoKS9zdGFydHVwXzY0KCkgc3R1YnMuCgpNdWx0aWJvb3Q/Cj4gCj4gVG8gYXZvaWQgZXh0ZW5k aW5nIGJvb3RfcGFyYW1zIGZ1cnRoZXIgSSBmaWd1cmVkIHBlcmhhcHMgd2UgY2FuIGxvb2sKPiBh dCBFRkkgYXMgYW5vdGhlciBvcHRpb24gaW5zdGVhZC4gSWYgd2UgYXJlIGdvaW5nIHRvIGRyb3Ag YWxsIGxlZ2FjeQoKQnV0IEVGSSBzdXBwb3J0IGlzIF9odWdlXy4KPiBQViBzdXBwb3J0IGZyb20g dGhlIGtlcm5lbCAobm90IHRoZSBoeXBlcnZpc29yKSBhbmQgcmVxdWlyZSBoYXJkd2FyZQo+IHZp cnR1YWxpemF0aW9uIDUgeWVhcnMgZnJvbSBub3cgb24gdGhlIExpbnV4IGtlcm5lbCwgaXQgZG9l c24ndCBzZWVtCj4gdG8gbWUgZmFyIGZldGNoZWQgdG8gYXQgdGhlIHZlcnkgbGVhc3QgY29uc2lk ZXIgdXNpbmcgYW4gRUZJIGVudHJ5Cj4gaW5zdGVhZCwgc3BlY2lhbGx5IHNpbmNlIGFsbCBpdCBk b2VzIGlzIHNldCBib290IHBhcmFtcyBhbmQgd2UgY2FuCj4gbWFrZSByZS11c2UgdGhpcyBmb3Ig SFZNTGl0ZSB0b28uCgpCdXQgdG8gbWFrZSB0aGF0IHdvcmsgeW91IGhhdmUgdG8gZW11bGF0ZSBF RkkgZmlybXdhcmUgaW4gdGhlCmh5cGVydmlzb3IuIElzIHRoYXQgd29yayB5b3UgYXJlIHNpZ25p bmcgdXAgZm9yPwo+IAo+ICAgTHVpcwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVu Lm9yZwpodHRwOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK