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.3 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING, SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT 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 CC246C4360F for ; Wed, 3 Apr 2019 13:14:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 86BCE2147C for ; Wed, 3 Apr 2019 13:14:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="hHPHzh0e" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725959AbfDCNO4 (ORCPT ); Wed, 3 Apr 2019 09:14:56 -0400 Received: from mail-ed1-f66.google.com ([209.85.208.66]:42673 "EHLO mail-ed1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726097AbfDCNOz (ORCPT ); Wed, 3 Apr 2019 09:14:55 -0400 Received: by mail-ed1-f66.google.com with SMTP id x61so14841620edc.9 for ; Wed, 03 Apr 2019 06:14:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=sender:date:from:to:cc:subject:message-id:mail-followup-to :references:mime-version:content-disposition:in-reply-to:user-agent; bh=GIZeFK8W6FB1x1FAPsvd5IR0wfsmq0Ju7AnQ0kolWuc=; b=hHPHzh0eSCktBUBk80KibAbmX6ecsNp53rOeqb1ACLBR3MBnuuTqW3kHFBJu2xg+hE fKNL1xdxszAPzTnXMqoi2eNQ7z3lo0r1HXqeJ+o6ETHTPxfUf9YC+G0d7M4UDgP82Bu0 AKIQa8//0o6h06985hZxFMPJv5hh+lYgM3i1A= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:cc:subject:message-id :mail-followup-to:references:mime-version:content-disposition :in-reply-to:user-agent; bh=GIZeFK8W6FB1x1FAPsvd5IR0wfsmq0Ju7AnQ0kolWuc=; b=qdNCQslIdKbN8ziSp5YmRjL5n2XybwgX0ACxtea4MqOUDg1tDpkk2n5XWFGFYMxjyZ 6m0GtQf3CGqXgTo1r/dJwpJDDdoArh5jdbR8czlBGnuDr+7y6iBWDyIrwn5ijZYDPkPg rp5uEqweQIDqynAjYTCBXzkqD/wzIbPnlYW+QicctQKknyDkFDOT9F5Uf+0y03g6ZeeM G951b3QB8B+/LkU2aLcS2WFowQ2GD7U1KM8Tm0AqacVLYNXgyoJHLuFhgfuebKwTkgJl 0da7JocVHUOcYQ3yzjMV6+BfM57Vzv2rMv0wnNfdL8YpN9UIE7T8X52wjekATYy1qxXb 9wzg== X-Gm-Message-State: APjAAAXZOFdTwWVgmQCkS6XBeMiTjwVoM9kc/1vsB4W3vObdfzns75yp Fn2mA29IuYhVEwWnHS6g9Me/mg== X-Google-Smtp-Source: APXvYqyvC58WYsVJgdxE0haVlRl0yuwK9VY719WEF4fSUZLf+HMPr+k3OgthGz1scrMmEVySLmMc5A== X-Received: by 2002:aa7:cf18:: with SMTP id a24mr49588163edy.215.1554297293355; Wed, 03 Apr 2019 06:14:53 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id q3sm4785440edr.31.2019.04.03.06.14.51 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 03 Apr 2019 06:14:52 -0700 (PDT) Date: Wed, 3 Apr 2019 15:14:49 +0200 From: Daniel Vetter To: Ronan KERYELL Cc: Dave Airlie , Sonal Santan , Daniel Vetter , "dri-devel@lists.freedesktop.org" , "gregkh@linuxfoundation.org" , Cyril Chemparathy , "linux-kernel@vger.kernel.org" , Lizhi Hou , Michal Simek , "airlied@redhat.com" , linux-fpga@vger.kernel.org, Ralph Wittig , Ronan Keryell Subject: Re: [RFC PATCH Xilinx Alveo 0/6] Xilinx PCIe accelerator driver Message-ID: <20190403131449.GB2665@phenom.ffwll.local> Mail-Followup-To: Ronan KERYELL , Dave Airlie , Sonal Santan , "dri-devel@lists.freedesktop.org" , "gregkh@linuxfoundation.org" , Cyril Chemparathy , "linux-kernel@vger.kernel.org" , Lizhi Hou , Michal Simek , "airlied@redhat.com" , linux-fpga@vger.kernel.org, Ralph Wittig , Ronan Keryell References: <20190319215401.6562-1-sonal.santan@xilinx.com> <20190325202810.GG2665@phenom.ffwll.local> <20190327141137.GK2665@phenom.ffwll.local> <871s2pw4ld.fsf@fisel.enstb.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <871s2pw4ld.fsf@fisel.enstb.org> X-Operating-System: Linux phenom 4.19.0-1-amd64 User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Mar 29, 2019 at 06:09:18PM -0700, Ronan KERYELL wrote: > I am adding linux-fpga@vger.kernel.org, since this is why I missed this > thread in the first place... > > >>>>> On Fri, 29 Mar 2019 14:56:17 +1000, Dave Airlie said: > > Hi Dave! > > Dave> On Thu, 28 Mar 2019 at 10:14, Sonal Santan wrote: > > >>> From: Daniel Vetter [mailto:daniel.vetter@ffwll.ch] > > [...] > > >>> Note: There's no expectation for the fully optimizing compiler, > >>> and we're totally ok if there's an optimizing proprietary > >>> compiler and a basic open one (amd, and bunch of other > >>> companies all have such dual stacks running on top of drm > >>> kernel drivers). But a basic compiler that can convert basic > >>> kernels into machine code is expected. > > >> Although the compiler is not open source the compilation flow > >> lets users examine output from various stages. For example if you > >> write your kernel in OpenCL/C/C++ you can view the RTL > >> (Verilog/VHDL) output produced by first stage of compilation. > >> Note that the compiler is really generating a custom circuit > >> given a high level input which in the last phase gets synthesized > >> into bitstream. Expert hardware designers can handcraft a circuit > >> in RTL and feed it to the compiler. Our FPGA tools let you view > >> the generated hardware design, the register map, etc. You can get > >> more information about a compiled design by running XRT tool like > >> xclbinutil on the generated file. > > >> In essence compiling for FPGAs is quite different than compiling > >> for GPU/CPU/DSP. Interestingly FPGA compilers can run anywhere > >> from 30 mins to a few hours to compile a testcase. > > Dave> So is there any open source userspace generator for what this > Dave> interface provides? Is the bitstream format that gets fed into > Dave> the FPGA proprietary and is it signed? > > Short answer: > > - a bitstream is an opaque content similar to various firmware handled > by Linux, EFI capsules, x86 microcode, WiFi modems, etc. > > - there is no open-source generator for what the interface consume; > > - I do not know if it is signed; > > - it is probably similar to what Intel FPGA (not GPU) drivers provide > already inside the Linux kernel and I guess there is no pure > open-source way to generate their bit-stream either. Yeah, drivers/gpu folks wouldn't ever have merged drivers/fpga, and I think there's pretty strong consensus over here that merging fpga stuff without having clear specs (in the form of an executable open source compiler/synthesizer/whatever) was a mistake. We just had a similar huge discussions around the recently merged habanalabs driver in drivers/misc, for neural network accel. There was a proposed drivers/accel for these. gpu folks objected, Greg and Olof were happy with merging. And the exact same arguments has come up tons of times for gpus too, with lots proposals to merge a kernel driver with just the kernel driver being open source, or just the state tracker/runtime, but most definitely not anything looking like the compiler. Because $reasons. Conclusion was that drivers/gpu people will continue to reject these, everyone else will continue to take whatever, but just don't complain to us if it all comes crashing down :-) > Long answer: > > - processors, GPU and other digital circuits are designed from a lot of > elementary transistors, wires, capacitors, resistors... using some > very complex (and expensive) tools from some EDA companies but at the > end, after months of work, they come often with a "simple" public > interface, the... instruction set! So it is rather "easy" at the end > to generate some instructions with a compiler such as LLVM from a > description of this ISA or some reverse engineering. Note that even if > the ISA is public, it is very difficult to make another efficient > processor from scratch just from this ISA, so there is often no > concern about making this ISA public to develop the ecosystem ; > > - FPGA are field-programmable gate arrays, made also from a lot of > elementary transistors, wires, capacitors, resistors... but organized > in billions of very low-level elementary gates, memory elements, DSP > blocks, I/O blocks, clock generators, specific > accelerators... directly exposed to the user and that can be > programmed according to a configuration memory (the bitstream) that > details how to connect each part, routing element, configuring each > elemental piece of hardware. So instead of just writing instructions > like on a CPU or a GPU, you need to configure each bit of the > architecture in such a way it does something interesting for > you. Concretely, you write some programs in RTL languages (Verilog, > VHDL) or higher-level (C/C++, OpenCL, SYCL...) and you use some very > complex (and expensive) tools from some EDA companies to generate the > bitstream implementing an equivalent circuit with the same > semantics. Since the architecture is so low level, there is a direct > mapping between the configuration memory (bitstream) and the hardware > architecture itself, so if it is public then it is easy to duplicate > the FPGA itself and to start a new FPGA company. That is unfortunately > something the existing FPGA companies do not want... ;-) i.e. you have a use case where you absolutely need an offline compiler. Like with gpus (in some use cases), the only difference is that for gpus the latency requirement that's too high is measured in milliseconds, cause that would cause dropped frames, and worst case compiling takes seconds for some big shaders. With FPGAs it's just 1000x higher limits, same problem. > To summarize: > > - on a CPU & GPU, the vendor used the expensive EDA tools once already > for you and provide the simpler ISA interface; > > - on an FPGA, you have access to a pile of low-level hardware and it is > up to you to use the lengthy process of building your own computing > architecture using the heavy expensive very subtle EDA tools that will > run for hours or days to generate some good-enough placement for your > pleasure. > > There is some public documentation on-line: > https://www.xilinx.com/products/silicon-devices/fpga/virtex-ultrascale-plus.html#documentation > > To have an idea of the elementary architecture: > https://www.xilinx.com/support/documentation/user_guides/ug574-ultrascale-clb.pdf > https://www.xilinx.com/support/documentation/user_guides/ug579-ultrascale-dsp.pdf > https://www.xilinx.com/support/documentation/user_guides/ug573-ultrascale-memory-resources.pdf > > Even on the configuration and the file format, but without any detailed semantics: > https://www.xilinx.com/support/documentation/user_guides/ug570-ultrascale-configuration.pdf > > > The Xilinx compiler xocc taking for example some LLVM IR and generating > some bitstream is not open-source and will probably never be for the > reasons above... :-( > > Xilinx is open-sourcing all what can reasonably be open-sourced: > > - the user-level and system run-time, including the OpenCL runtime: > https://github.com/Xilinx/XRT to handle the bitstreams generated by > some close-source tools > > - the kernel device drivers which are already in > https://github.com/Xilinx/XRT but we want to upstream into the Linux > kernel to make life easier (this is the matter of this e-mail thread); > > - to generate some real code in the most (modern and) open-source way, > there is an open-source framework to compile some SYCL C++ including > some Xilinx FPGA-specific extensions down to SPIR LLVM IR using > Clang/LLVM and to feed the close-source xocc tool with it > https://github.com/triSYCL/triSYCL > > You can see starting from > https://github.com/triSYCL/triSYCL/blob/master/tests/Makefile#L322 how > to start from C++ code, generate some SPIR LLVM IR and to feed xocc > and build a fat binary that will use the XRT runtime. > > Some documentation in > https://github.com/triSYCL/triSYCL/blob/master/doc/architecture.rst > > There are other more official ways to generate bitstream (they are > called products instead of research projects like triSYCL :-) ). > > We are also working on an other open-source SYCL compiler with Intel > to have a better common implementation > https://github.com/intel/llvm/wiki and to upstream this into Clang/LLVM. Yeah, there's been plenty of gpu stacks with "everything open sourced that can be open sourced", except the compiler, for gpus. We didn't take those drivers either. And I looked at the entire stack already to see what's there and what's missing. > So for Xilinx FPGA, you can see the LLVM IR as the equivalent of PTX for > nVidia. But xocc is close-source for some more fundamental reasons: it > would expose all the details of the FPGA. I guess this is exactly the > same for Xilinx FPGA. Yeah, neither did we merge a driver with just some IR as the "compiler", and most definitely not PTX (since that's just nv lock-in, spirv is the cross vendor solution that at least seems to have a fighting chance). We want the low level stuff (and if the high level compiler is the dumbest, least optimizing thing ever that can't run any real world workload yet, that's fine, it can be fixed). The low level stuff is what matters from an uapi perspective. > Note that probably most of the tool chains used to generate the > low-level firmware for the various CPU (microcode), GPU, etc. are > also close-source. Yup. None have been successfully used to merge stuff into drivers/gpu. Note that we're perfectly fine with closed source stacks running on top of drivers/gpu, with lots of additional secret sauce/value add/customer lock in/whatever compared to the basic open source stack. There's plenty of vendors doing that. But for the uapi review, and making sure we can at least keep the basic stack working, it needs to be the full open stack. End to end. I guess I need to actually type that article on my blog about why exactly we're so much insisting on this, seems to become a bit an FAQ. Cheers, Daniel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [RFC PATCH Xilinx Alveo 0/6] Xilinx PCIe accelerator driver Date: Wed, 3 Apr 2019 15:14:49 +0200 Message-ID: <20190403131449.GB2665@phenom.ffwll.local> References: <20190319215401.6562-1-sonal.santan@xilinx.com> <20190325202810.GG2665@phenom.ffwll.local> <20190327141137.GK2665@phenom.ffwll.local> <871s2pw4ld.fsf@fisel.enstb.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ed1-x542.google.com (mail-ed1-x542.google.com [IPv6:2a00:1450:4864:20::542]) by gabe.freedesktop.org (Postfix) with ESMTPS id B98E689A86 for ; Wed, 3 Apr 2019 13:14:54 +0000 (UTC) Received: by mail-ed1-x542.google.com with SMTP id d11so5122583edp.11 for ; Wed, 03 Apr 2019 06:14:54 -0700 (PDT) Content-Disposition: inline In-Reply-To: <871s2pw4ld.fsf@fisel.enstb.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Ronan KERYELL Cc: Sonal Santan , "gregkh@linuxfoundation.org" , Cyril Chemparathy , "linux-kernel@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , Ralph Wittig , Michal Simek , Lizhi Hou , "airlied@redhat.com" , Ronan Keryell , linux-fpga@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBNYXIgMjksIDIwMTkgYXQgMDY6MDk6MThQTSAtMDcwMCwgUm9uYW4gS0VSWUVMTCB3 cm90ZToKPiBJIGFtIGFkZGluZyBsaW51eC1mcGdhQHZnZXIua2VybmVsLm9yZywgc2luY2UgdGhp cyBpcyB3aHkgSSBtaXNzZWQgdGhpcwo+IHRocmVhZCBpbiB0aGUgZmlyc3QgcGxhY2UuLi4KPiAK PiA+Pj4+PiBPbiBGcmksIDI5IE1hciAyMDE5IDE0OjU2OjE3ICsxMDAwLCBEYXZlIEFpcmxpZSA8 YWlybGllZEBnbWFpbC5jb20+IHNhaWQ6Cj4gCj4gSGkgRGF2ZSEKPiAKPiAgICAgRGF2ZT4gT24g VGh1LCAyOCBNYXIgMjAxOSBhdCAxMDoxNCwgU29uYWwgU2FudGFuIDxzb25hbHNAeGlsaW54LmNv bT4gd3JvdGU6Cj4gCj4gICAgID4+PiBGcm9tOiBEYW5pZWwgVmV0dGVyIFttYWlsdG86ZGFuaWVs LnZldHRlckBmZndsbC5jaF0KPiAKPiBbLi4uXQo+IAo+ICAgICA+Pj4gTm90ZTogVGhlcmUncyBu byBleHBlY3RhdGlvbiBmb3IgdGhlIGZ1bGx5IG9wdGltaXppbmcgY29tcGlsZXIsCj4gICAgID4+ PiBhbmQgd2UncmUgdG90YWxseSBvayBpZiB0aGVyZSdzIGFuIG9wdGltaXppbmcgcHJvcHJpZXRh cnkKPiAgICAgPj4+IGNvbXBpbGVyIGFuZCBhIGJhc2ljIG9wZW4gb25lIChhbWQsIGFuZCBidW5j aCBvZiBvdGhlcgo+ICAgICA+Pj4gY29tcGFuaWVzIGFsbCBoYXZlIHN1Y2ggZHVhbCBzdGFja3Mg cnVubmluZyBvbiB0b3Agb2YgZHJtCj4gICAgID4+PiBrZXJuZWwgZHJpdmVycykuIEJ1dCBhIGJh c2ljIGNvbXBpbGVyIHRoYXQgY2FuIGNvbnZlcnQgYmFzaWMKPiAgICAgPj4+IGtlcm5lbHMgaW50 byBtYWNoaW5lIGNvZGUgaXMgZXhwZWN0ZWQuCj4gCj4gICAgID4+IEFsdGhvdWdoIHRoZSBjb21w aWxlciBpcyBub3Qgb3BlbiBzb3VyY2UgdGhlIGNvbXBpbGF0aW9uIGZsb3cKPiAgICAgPj4gbGV0 cyB1c2VycyBleGFtaW5lIG91dHB1dCBmcm9tIHZhcmlvdXMgc3RhZ2VzLiBGb3IgZXhhbXBsZSBp ZiB5b3UKPiAgICAgPj4gd3JpdGUgeW91ciBrZXJuZWwgaW4gT3BlbkNML0MvQysrIHlvdSBjYW4g dmlldyB0aGUgUlRMCj4gICAgID4+IChWZXJpbG9nL1ZIREwpIG91dHB1dCBwcm9kdWNlZCBieSBm aXJzdCBzdGFnZSBvZiBjb21waWxhdGlvbi4KPiAgICAgPj4gTm90ZSB0aGF0IHRoZSBjb21waWxl ciBpcyByZWFsbHkgZ2VuZXJhdGluZyBhIGN1c3RvbSBjaXJjdWl0Cj4gICAgID4+IGdpdmVuIGEg aGlnaCBsZXZlbCBpbnB1dCB3aGljaCBpbiB0aGUgbGFzdCBwaGFzZSBnZXRzIHN5bnRoZXNpemVk Cj4gICAgID4+IGludG8gYml0c3RyZWFtLiBFeHBlcnQgaGFyZHdhcmUgZGVzaWduZXJzIGNhbiBo YW5kY3JhZnQgYSBjaXJjdWl0Cj4gICAgID4+IGluIFJUTCBhbmQgZmVlZCBpdCB0byB0aGUgY29t cGlsZXIuIE91ciBGUEdBIHRvb2xzIGxldCB5b3Ugdmlldwo+ICAgICA+PiB0aGUgZ2VuZXJhdGVk IGhhcmR3YXJlIGRlc2lnbiwgdGhlIHJlZ2lzdGVyIG1hcCwgZXRjLiBZb3UgY2FuIGdldAo+ICAg ICA+PiBtb3JlIGluZm9ybWF0aW9uIGFib3V0IGEgY29tcGlsZWQgZGVzaWduIGJ5IHJ1bm5pbmcg WFJUIHRvb2wgbGlrZQo+ICAgICA+PiB4Y2xiaW51dGlsIG9uIHRoZSBnZW5lcmF0ZWQgZmlsZS4K PiAKPiAgICAgPj4gSW4gZXNzZW5jZSBjb21waWxpbmcgZm9yIEZQR0FzIGlzIHF1aXRlIGRpZmZl cmVudCB0aGFuIGNvbXBpbGluZwo+ICAgICA+PiBmb3IgR1BVL0NQVS9EU1AuICBJbnRlcmVzdGlu Z2x5IEZQR0EgY29tcGlsZXJzIGNhbiBydW4gYW55d2hlcmUKPiAgICAgPj4gZnJvbSAzMCBtaW5z IHRvIGEgZmV3IGhvdXJzIHRvIGNvbXBpbGUgYSB0ZXN0Y2FzZS4KPiAKPiAgICAgRGF2ZT4gU28g aXMgdGhlcmUgYW55IG9wZW4gc291cmNlIHVzZXJzcGFjZSBnZW5lcmF0b3IgZm9yIHdoYXQgdGhp cwo+ICAgICBEYXZlPiBpbnRlcmZhY2UgcHJvdmlkZXM/IElzIHRoZSBiaXRzdHJlYW0gZm9ybWF0 IHRoYXQgZ2V0cyBmZWQgaW50bwo+ICAgICBEYXZlPiB0aGUgRlBHQSBwcm9wcmlldGFyeSBhbmQg aXMgaXQgc2lnbmVkPwo+IAo+IFNob3J0IGFuc3dlcjoKPiAKPiAtIGEgYml0c3RyZWFtIGlzIGFu IG9wYXF1ZSBjb250ZW50IHNpbWlsYXIgdG8gdmFyaW91cyBmaXJtd2FyZSBoYW5kbGVkCj4gICBi eSBMaW51eCwgRUZJIGNhcHN1bGVzLCB4ODYgbWljcm9jb2RlLCBXaUZpIG1vZGVtcywgZXRjLgo+ IAo+IC0gdGhlcmUgaXMgbm8gb3Blbi1zb3VyY2UgZ2VuZXJhdG9yIGZvciB3aGF0IHRoZSBpbnRl cmZhY2UgY29uc3VtZTsKPiAKPiAtIEkgZG8gbm90IGtub3cgaWYgaXQgaXMgc2lnbmVkOwo+IAo+ IC0gaXQgaXMgcHJvYmFibHkgc2ltaWxhciB0byB3aGF0IEludGVsIEZQR0EgKG5vdCBHUFUpIGRy aXZlcnMgcHJvdmlkZQo+ICAgYWxyZWFkeSBpbnNpZGUgdGhlIExpbnV4IGtlcm5lbCBhbmQgSSBn dWVzcyB0aGVyZSBpcyBubyBwdXJlCj4gICBvcGVuLXNvdXJjZSB3YXkgdG8gZ2VuZXJhdGUgdGhl aXIgYml0LXN0cmVhbSBlaXRoZXIuCgpZZWFoLCBkcml2ZXJzL2dwdSBmb2xrcyB3b3VsZG4ndCBl dmVyIGhhdmUgbWVyZ2VkIGRyaXZlcnMvZnBnYSwgYW5kIEkKdGhpbmsgdGhlcmUncyBwcmV0dHkg c3Ryb25nIGNvbnNlbnN1cyBvdmVyIGhlcmUgdGhhdCBtZXJnaW5nIGZwZ2Egc3R1ZmYKd2l0aG91 dCBoYXZpbmcgY2xlYXIgc3BlY3MgKGluIHRoZSBmb3JtIG9mIGFuIGV4ZWN1dGFibGUgb3BlbiBz b3VyY2UKY29tcGlsZXIvc3ludGhlc2l6ZXIvd2hhdGV2ZXIpIHdhcyBhIG1pc3Rha2UuCgpXZSBq dXN0IGhhZCBhIHNpbWlsYXIgaHVnZSBkaXNjdXNzaW9ucyBhcm91bmQgdGhlIHJlY2VudGx5IG1l cmdlZApoYWJhbmFsYWJzIGRyaXZlciBpbiBkcml2ZXJzL21pc2MsIGZvciBuZXVyYWwgbmV0d29y ayBhY2NlbC4gVGhlcmUgd2FzIGEKcHJvcG9zZWQgZHJpdmVycy9hY2NlbCBmb3IgdGhlc2UuIGdw dSBmb2xrcyBvYmplY3RlZCwgR3JlZyBhbmQgT2xvZiB3ZXJlCmhhcHB5IHdpdGggbWVyZ2luZy4K CkFuZCB0aGUgZXhhY3Qgc2FtZSBhcmd1bWVudHMgaGFzIGNvbWUgdXAgdG9ucyBvZiB0aW1lcyBm b3IgZ3B1cyB0b28sIHdpdGgKbG90cyBwcm9wb3NhbHMgdG8gbWVyZ2UgYSBrZXJuZWwgZHJpdmVy IHdpdGgganVzdCB0aGUga2VybmVsIGRyaXZlciBiZWluZwpvcGVuIHNvdXJjZSwgb3IganVzdCB0 aGUgc3RhdGUgdHJhY2tlci9ydW50aW1lLCBidXQgbW9zdCBkZWZpbml0ZWx5IG5vdAphbnl0aGlu ZyBsb29raW5nIGxpa2UgdGhlIGNvbXBpbGVyLiBCZWNhdXNlICRyZWFzb25zLgoKQ29uY2x1c2lv biB3YXMgdGhhdCBkcml2ZXJzL2dwdSBwZW9wbGUgd2lsbCBjb250aW51ZSB0byByZWplY3QgdGhl c2UsCmV2ZXJ5b25lIGVsc2Ugd2lsbCBjb250aW51ZSB0byB0YWtlIHdoYXRldmVyLCBidXQganVz dCBkb24ndCBjb21wbGFpbiB0bwp1cyBpZiBpdCBhbGwgY29tZXMgY3Jhc2hpbmcgZG93biA6LSkK Cj4gTG9uZyBhbnN3ZXI6Cj4gCj4gLSBwcm9jZXNzb3JzLCBHUFUgYW5kIG90aGVyIGRpZ2l0YWwg Y2lyY3VpdHMgYXJlIGRlc2lnbmVkIGZyb20gYSBsb3Qgb2YKPiAgIGVsZW1lbnRhcnkgdHJhbnNp c3RvcnMsIHdpcmVzLCBjYXBhY2l0b3JzLCByZXNpc3RvcnMuLi4gdXNpbmcgc29tZQo+ICAgdmVy eSBjb21wbGV4IChhbmQgZXhwZW5zaXZlKSB0b29scyBmcm9tIHNvbWUgRURBIGNvbXBhbmllcyBi dXQgYXQgdGhlCj4gICBlbmQsIGFmdGVyIG1vbnRocyBvZiB3b3JrLCB0aGV5IGNvbWUgb2Z0ZW4g d2l0aCBhICJzaW1wbGUiIHB1YmxpYwo+ICAgaW50ZXJmYWNlLCB0aGUuLi4gaW5zdHJ1Y3Rpb24g c2V0ISBTbyBpdCBpcyByYXRoZXIgImVhc3kiIGF0IHRoZSBlbmQKPiAgIHRvIGdlbmVyYXRlIHNv bWUgaW5zdHJ1Y3Rpb25zIHdpdGggYSBjb21waWxlciBzdWNoIGFzIExMVk0gZnJvbSBhCj4gICBk ZXNjcmlwdGlvbiBvZiB0aGlzIElTQSBvciBzb21lIHJldmVyc2UgZW5naW5lZXJpbmcuIE5vdGUg dGhhdCBldmVuIGlmCj4gICB0aGUgSVNBIGlzIHB1YmxpYywgaXQgaXMgdmVyeSBkaWZmaWN1bHQg dG8gbWFrZSBhbm90aGVyIGVmZmljaWVudAo+ICAgcHJvY2Vzc29yIGZyb20gc2NyYXRjaCBqdXN0 IGZyb20gdGhpcyBJU0EsIHNvIHRoZXJlIGlzIG9mdGVuIG5vCj4gICBjb25jZXJuIGFib3V0IG1h a2luZyB0aGlzIElTQSBwdWJsaWMgdG8gZGV2ZWxvcCB0aGUgZWNvc3lzdGVtIDsKPiAKPiAtIEZQ R0EgYXJlIGZpZWxkLXByb2dyYW1tYWJsZSBnYXRlIGFycmF5cywgbWFkZSBhbHNvIGZyb20gYSBs b3Qgb2YKPiAgIGVsZW1lbnRhcnkgdHJhbnNpc3RvcnMsIHdpcmVzLCBjYXBhY2l0b3JzLCByZXNp c3RvcnMuLi4gYnV0IG9yZ2FuaXplZAo+ICAgaW4gYmlsbGlvbnMgb2YgdmVyeSBsb3ctbGV2ZWwg ZWxlbWVudGFyeSBnYXRlcywgbWVtb3J5IGVsZW1lbnRzLCBEU1AKPiAgIGJsb2NrcywgSS9PIGJs b2NrcywgY2xvY2sgZ2VuZXJhdG9ycywgc3BlY2lmaWMKPiAgIGFjY2VsZXJhdG9ycy4uLiBkaXJl Y3RseSBleHBvc2VkIHRvIHRoZSB1c2VyIGFuZCB0aGF0IGNhbiBiZQo+ICAgcHJvZ3JhbW1lZCBh Y2NvcmRpbmcgdG8gYSBjb25maWd1cmF0aW9uIG1lbW9yeSAodGhlIGJpdHN0cmVhbSkgdGhhdAo+ ICAgZGV0YWlscyBob3cgdG8gY29ubmVjdCBlYWNoIHBhcnQsIHJvdXRpbmcgZWxlbWVudCwgY29u ZmlndXJpbmcgZWFjaAo+ICAgZWxlbWVudGFsIHBpZWNlIG9mIGhhcmR3YXJlLiAgU28gaW5zdGVh ZCBvZiBqdXN0IHdyaXRpbmcgaW5zdHJ1Y3Rpb25zCj4gICBsaWtlIG9uIGEgQ1BVIG9yIGEgR1BV LCB5b3UgbmVlZCB0byBjb25maWd1cmUgZWFjaCBiaXQgb2YgdGhlCj4gICBhcmNoaXRlY3R1cmUg aW4gc3VjaCBhIHdheSBpdCBkb2VzIHNvbWV0aGluZyBpbnRlcmVzdGluZyBmb3IKPiAgIHlvdS4g Q29uY3JldGVseSwgeW91IHdyaXRlIHNvbWUgcHJvZ3JhbXMgaW4gUlRMIGxhbmd1YWdlcyAoVmVy aWxvZywKPiAgIFZIREwpIG9yIGhpZ2hlci1sZXZlbCAoQy9DKyssIE9wZW5DTCwgU1lDTC4uLikg IGFuZCB5b3UgdXNlIHNvbWUgdmVyeQo+ICAgY29tcGxleCAoYW5kIGV4cGVuc2l2ZSkgdG9vbHMg ZnJvbSBzb21lIEVEQSBjb21wYW5pZXMgdG8gZ2VuZXJhdGUgdGhlCj4gICBiaXRzdHJlYW0gaW1w bGVtZW50aW5nIGFuIGVxdWl2YWxlbnQgY2lyY3VpdCB3aXRoIHRoZSBzYW1lCj4gICBzZW1hbnRp Y3MuIFNpbmNlIHRoZSBhcmNoaXRlY3R1cmUgaXMgc28gbG93IGxldmVsLCB0aGVyZSBpcyBhIGRp cmVjdAo+ICAgbWFwcGluZyBiZXR3ZWVuIHRoZSBjb25maWd1cmF0aW9uIG1lbW9yeSAoYml0c3Ry ZWFtKSBhbmQgdGhlIGhhcmR3YXJlCj4gICBhcmNoaXRlY3R1cmUgaXRzZWxmLCBzbyBpZiBpdCBp cyBwdWJsaWMgdGhlbiBpdCBpcyBlYXN5IHRvIGR1cGxpY2F0ZQo+ICAgdGhlIEZQR0EgaXRzZWxm IGFuZCB0byBzdGFydCBhIG5ldyBGUEdBIGNvbXBhbnkuIFRoYXQgaXMgdW5mb3J0dW5hdGVseQo+ ICAgc29tZXRoaW5nIHRoZSBleGlzdGluZyBGUEdBIGNvbXBhbmllcyBkbyBub3Qgd2FudC4uLiA7 LSkKCmkuZS4geW91IGhhdmUgYSB1c2UgY2FzZSB3aGVyZSB5b3UgYWJzb2x1dGVseSBuZWVkIGFu IG9mZmxpbmUgY29tcGlsZXIuCkxpa2Ugd2l0aCBncHVzIChpbiBzb21lIHVzZSBjYXNlcyksIHRo ZSBvbmx5IGRpZmZlcmVuY2UgaXMgdGhhdCBmb3IgZ3B1cwp0aGUgbGF0ZW5jeSByZXF1aXJlbWVu dCB0aGF0J3MgdG9vIGhpZ2ggaXMgbWVhc3VyZWQgaW4gbWlsbGlzZWNvbmRzLCBjYXVzZQp0aGF0 IHdvdWxkIGNhdXNlIGRyb3BwZWQgZnJhbWVzLCBhbmQgd29yc3QgY2FzZSBjb21waWxpbmcgdGFr ZXMgc2Vjb25kcwpmb3Igc29tZSBiaWcgc2hhZGVycy4gV2l0aCBGUEdBcyBpdCdzIGp1c3QgMTAw MHggaGlnaGVyIGxpbWl0cywgc2FtZSBwcm9ibGVtLgoKPiBUbyBzdW1tYXJpemU6Cj4gCj4gLSBv biBhIENQVSAmIEdQVSwgdGhlIHZlbmRvciB1c2VkIHRoZSBleHBlbnNpdmUgRURBIHRvb2xzIG9u Y2UgYWxyZWFkeQo+ICAgZm9yIHlvdSBhbmQgcHJvdmlkZSB0aGUgc2ltcGxlciBJU0EgaW50ZXJm YWNlOwo+IAo+IC0gb24gYW4gRlBHQSwgeW91IGhhdmUgYWNjZXNzIHRvIGEgcGlsZSBvZiBsb3ct bGV2ZWwgaGFyZHdhcmUgYW5kIGl0IGlzCj4gICB1cCB0byB5b3UgdG8gdXNlIHRoZSBsZW5ndGh5 IHByb2Nlc3Mgb2YgYnVpbGRpbmcgeW91ciBvd24gY29tcHV0aW5nCj4gICBhcmNoaXRlY3R1cmUg dXNpbmcgdGhlIGhlYXZ5IGV4cGVuc2l2ZSB2ZXJ5IHN1YnRsZSBFREEgdG9vbHMgdGhhdCB3aWxs Cj4gICBydW4gZm9yIGhvdXJzIG9yIGRheXMgdG8gZ2VuZXJhdGUgc29tZSBnb29kLWVub3VnaCBw bGFjZW1lbnQgZm9yIHlvdXIKPiAgIHBsZWFzdXJlLgo+IAo+IFRoZXJlIGlzIHNvbWUgcHVibGlj IGRvY3VtZW50YXRpb24gb24tbGluZToKPiBodHRwczovL3d3dy54aWxpbnguY29tL3Byb2R1Y3Rz L3NpbGljb24tZGV2aWNlcy9mcGdhL3ZpcnRleC11bHRyYXNjYWxlLXBsdXMuaHRtbCNkb2N1bWVu dGF0aW9uCj4gCj4gVG8gaGF2ZSBhbiBpZGVhIG9mIHRoZSBlbGVtZW50YXJ5IGFyY2hpdGVjdHVy ZToKPiBodHRwczovL3d3dy54aWxpbnguY29tL3N1cHBvcnQvZG9jdW1lbnRhdGlvbi91c2VyX2d1 aWRlcy91ZzU3NC11bHRyYXNjYWxlLWNsYi5wZGYKPiBodHRwczovL3d3dy54aWxpbnguY29tL3N1 cHBvcnQvZG9jdW1lbnRhdGlvbi91c2VyX2d1aWRlcy91ZzU3OS11bHRyYXNjYWxlLWRzcC5wZGYK PiBodHRwczovL3d3dy54aWxpbnguY29tL3N1cHBvcnQvZG9jdW1lbnRhdGlvbi91c2VyX2d1aWRl cy91ZzU3My11bHRyYXNjYWxlLW1lbW9yeS1yZXNvdXJjZXMucGRmCj4gCj4gRXZlbiBvbiB0aGUg Y29uZmlndXJhdGlvbiBhbmQgdGhlIGZpbGUgZm9ybWF0LCBidXQgd2l0aG91dCBhbnkgZGV0YWls ZWQgc2VtYW50aWNzOgo+IGh0dHBzOi8vd3d3LnhpbGlueC5jb20vc3VwcG9ydC9kb2N1bWVudGF0 aW9uL3VzZXJfZ3VpZGVzL3VnNTcwLXVsdHJhc2NhbGUtY29uZmlndXJhdGlvbi5wZGYKPiAKPiAK PiBUaGUgWGlsaW54IGNvbXBpbGVyIHhvY2MgdGFraW5nIGZvciBleGFtcGxlIHNvbWUgTExWTSBJ UiBhbmQgZ2VuZXJhdGluZwo+IHNvbWUgYml0c3RyZWFtIGlzIG5vdCBvcGVuLXNvdXJjZSBhbmQg d2lsbCBwcm9iYWJseSBuZXZlciBiZSBmb3IgdGhlCj4gcmVhc29ucyBhYm92ZS4uLiA6LSgKPiAK PiBYaWxpbnggaXMgb3Blbi1zb3VyY2luZyBhbGwgd2hhdCBjYW4gcmVhc29uYWJseSBiZSBvcGVu LXNvdXJjZWQ6Cj4gCj4gLSB0aGUgdXNlci1sZXZlbCBhbmQgc3lzdGVtIHJ1bi10aW1lLCBpbmNs dWRpbmcgdGhlIE9wZW5DTCBydW50aW1lOgo+ICAgaHR0cHM6Ly9naXRodWIuY29tL1hpbGlueC9Y UlQgdG8gaGFuZGxlIHRoZSBiaXRzdHJlYW1zIGdlbmVyYXRlZCBieQo+ICAgc29tZSBjbG9zZS1z b3VyY2UgdG9vbHMKPiAKPiAtIHRoZSBrZXJuZWwgZGV2aWNlIGRyaXZlcnMgd2hpY2ggYXJlIGFs cmVhZHkgaW4KPiAgIGh0dHBzOi8vZ2l0aHViLmNvbS9YaWxpbngvWFJUIGJ1dCB3ZSB3YW50IHRv IHVwc3RyZWFtIGludG8gdGhlIExpbnV4Cj4gICBrZXJuZWwgdG8gbWFrZSBsaWZlIGVhc2llciAo dGhpcyBpcyB0aGUgbWF0dGVyIG9mIHRoaXMgZS1tYWlsIHRocmVhZCk7Cj4gCj4gLSB0byBnZW5l cmF0ZSBzb21lIHJlYWwgY29kZSBpbiB0aGUgbW9zdCAobW9kZXJuIGFuZCkgb3Blbi1zb3VyY2Ug d2F5LAo+ICAgdGhlcmUgaXMgYW4gb3Blbi1zb3VyY2UgZnJhbWV3b3JrIHRvIGNvbXBpbGUgc29t ZSBTWUNMIEMrKyBpbmNsdWRpbmcKPiAgIHNvbWUgWGlsaW54IEZQR0Etc3BlY2lmaWMgZXh0ZW5z aW9ucyBkb3duIHRvIFNQSVIgTExWTSBJUiB1c2luZwo+ICAgQ2xhbmcvTExWTSBhbmQgdG8gZmVl ZCB0aGUgY2xvc2Utc291cmNlIHhvY2MgdG9vbCB3aXRoIGl0Cj4gICBodHRwczovL2dpdGh1Yi5j b20vdHJpU1lDTC90cmlTWUNMCj4gCj4gICBZb3UgY2FuIHNlZSBzdGFydGluZyBmcm9tCj4gICBo dHRwczovL2dpdGh1Yi5jb20vdHJpU1lDTC90cmlTWUNML2Jsb2IvbWFzdGVyL3Rlc3RzL01ha2Vm aWxlI0wzMjIgaG93Cj4gICB0byBzdGFydCBmcm9tIEMrKyBjb2RlLCBnZW5lcmF0ZSBzb21lIFNQ SVIgTExWTSBJUiBhbmQgdG8gZmVlZCB4b2NjCj4gICBhbmQgYnVpbGQgYSBmYXQgYmluYXJ5IHRo YXQgd2lsbCB1c2UgdGhlIFhSVCBydW50aW1lLgo+IAo+ICAgU29tZSBkb2N1bWVudGF0aW9uIGlu Cj4gICBodHRwczovL2dpdGh1Yi5jb20vdHJpU1lDTC90cmlTWUNML2Jsb2IvbWFzdGVyL2RvYy9h cmNoaXRlY3R1cmUucnN0Cj4gCj4gICBUaGVyZSBhcmUgb3RoZXIgbW9yZSBvZmZpY2lhbCB3YXlz IHRvIGdlbmVyYXRlIGJpdHN0cmVhbSAodGhleSBhcmUKPiAgIGNhbGxlZCBwcm9kdWN0cyBpbnN0 ZWFkIG9mIHJlc2VhcmNoIHByb2plY3RzIGxpa2UgdHJpU1lDTCA6LSkgKS4KPiAKPiAgIFdlIGFy ZSBhbHNvIHdvcmtpbmcgb24gYW4gb3RoZXIgb3Blbi1zb3VyY2UgU1lDTCBjb21waWxlciB3aXRo IEludGVsCj4gICB0byBoYXZlIGEgYmV0dGVyIGNvbW1vbiBpbXBsZW1lbnRhdGlvbgo+ICAgaHR0 cHM6Ly9naXRodWIuY29tL2ludGVsL2xsdm0vd2lraSBhbmQgdG8gdXBzdHJlYW0gdGhpcyBpbnRv IENsYW5nL0xMVk0uCgpZZWFoLCB0aGVyZSdzIGJlZW4gcGxlbnR5IG9mIGdwdSBzdGFja3Mgd2l0 aCAiZXZlcnl0aGluZyBvcGVuIHNvdXJjZWQgdGhhdApjYW4gYmUgb3BlbiBzb3VyY2VkIiwgZXhj ZXB0IHRoZSBjb21waWxlciwgZm9yIGdwdXMuIFdlIGRpZG4ndCB0YWtlIHRob3NlCmRyaXZlcnMg ZWl0aGVyLgoKQW5kIEkgbG9va2VkIGF0IHRoZSBlbnRpcmUgc3RhY2sgYWxyZWFkeSB0byBzZWUg d2hhdCdzIHRoZXJlIGFuZCB3aGF0J3MKbWlzc2luZy4KCj4gU28gZm9yIFhpbGlueCBGUEdBLCB5 b3UgY2FuIHNlZSB0aGUgTExWTSBJUiBhcyB0aGUgZXF1aXZhbGVudCBvZiBQVFggZm9yCj4gblZp ZGlhLiBCdXQgeG9jYyBpcyBjbG9zZS1zb3VyY2UgZm9yIHNvbWUgbW9yZSBmdW5kYW1lbnRhbCBy ZWFzb25zOiBpdAo+IHdvdWxkIGV4cG9zZSBhbGwgdGhlIGRldGFpbHMgb2YgdGhlIEZQR0EuIEkg Z3Vlc3MgdGhpcyBpcyBleGFjdGx5IHRoZQo+IHNhbWUgZm9yIFhpbGlueCBGUEdBLgoKWWVhaCwg bmVpdGhlciBkaWQgd2UgbWVyZ2UgYSBkcml2ZXIgd2l0aCBqdXN0IHNvbWUgSVIgYXMgdGhlICJj b21waWxlciIsCmFuZCBtb3N0IGRlZmluaXRlbHkgbm90IFBUWCAoc2luY2UgdGhhdCdzIGp1c3Qg bnYgbG9jay1pbiwgc3BpcnYgaXMgdGhlCmNyb3NzIHZlbmRvciBzb2x1dGlvbiB0aGF0IGF0IGxl YXN0IHNlZW1zIHRvIGhhdmUgYSBmaWdodGluZyBjaGFuY2UpLiBXZQp3YW50IHRoZSBsb3cgbGV2 ZWwgc3R1ZmYgKGFuZCBpZiB0aGUgaGlnaCBsZXZlbCBjb21waWxlciBpcyB0aGUgZHVtYmVzdCwK bGVhc3Qgb3B0aW1pemluZyB0aGluZyBldmVyIHRoYXQgY2FuJ3QgcnVuIGFueSByZWFsIHdvcmxk IHdvcmtsb2FkIHlldCwKdGhhdCdzIGZpbmUsIGl0IGNhbiBiZSBmaXhlZCkuIFRoZSBsb3cgbGV2 ZWwgc3R1ZmYgaXMgd2hhdCBtYXR0ZXJzIGZyb20gYW4KdWFwaSBwZXJzcGVjdGl2ZS4KCj4gTm90 ZSB0aGF0IHByb2JhYmx5IG1vc3Qgb2YgdGhlIHRvb2wgY2hhaW5zIHVzZWQgdG8gZ2VuZXJhdGUg dGhlCj4gbG93LWxldmVsIGZpcm13YXJlIGZvciB0aGUgdmFyaW91cyBDUFUgKG1pY3JvY29kZSks IEdQVSwgZXRjLiBhcmUKPiBhbHNvIGNsb3NlLXNvdXJjZS4KCll1cC4gTm9uZSBoYXZlIGJlZW4g c3VjY2Vzc2Z1bGx5IHVzZWQgdG8gbWVyZ2Ugc3R1ZmYgaW50byBkcml2ZXJzL2dwdS4KCk5vdGUg dGhhdCB3ZSdyZSBwZXJmZWN0bHkgZmluZSB3aXRoIGNsb3NlZCBzb3VyY2Ugc3RhY2tzIHJ1bm5p bmcgb24gdG9wIG9mCmRyaXZlcnMvZ3B1LCB3aXRoIGxvdHMgb2YgYWRkaXRpb25hbCBzZWNyZXQg c2F1Y2UvdmFsdWUgYWRkL2N1c3RvbWVyIGxvY2sKaW4vd2hhdGV2ZXIgY29tcGFyZWQgdG8gdGhl IGJhc2ljIG9wZW4gc291cmNlIHN0YWNrLiBUaGVyZSdzIHBsZW50eSBvZgp2ZW5kb3JzIGRvaW5n IHRoYXQuIEJ1dCBmb3IgdGhlIHVhcGkgcmV2aWV3LCBhbmQgbWFraW5nIHN1cmUgd2UgY2FuIGF0 CmxlYXN0IGtlZXAgdGhlIGJhc2ljIHN0YWNrIHdvcmtpbmcsIGl0IG5lZWRzIHRvIGJlIHRoZSBm dWxsIG9wZW4gc3RhY2suCkVuZCB0byBlbmQuCgpJIGd1ZXNzIEkgbmVlZCB0byBhY3R1YWxseSB0 eXBlIHRoYXQgYXJ0aWNsZSBvbiBteSBibG9nIGFib3V0IHdoeSBleGFjdGx5CndlJ3JlIHNvIG11 Y2ggaW5zaXN0aW5nIG9uIHRoaXMsIHNlZW1zIHRvIGJlY29tZSBhIGJpdCBhbiBGQVEuCgpDaGVl cnMsIERhbmllbAotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29y cG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVs