From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f67.google.com ([74.125.82.67]:54531 "EHLO mail-wm0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754553AbeD3Oza (ORCPT ); Mon, 30 Apr 2018 10:55:30 -0400 Received: by mail-wm0-f67.google.com with SMTP id f6so13672415wmc.4 for ; Mon, 30 Apr 2018 07:55:29 -0700 (PDT) Date: Mon, 30 Apr 2018 16:55:24 +0200 From: Daniel Vetter To: Laurent Pinchart Cc: Daniel Vetter , dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Kieran Bingham , Ulrich Hecht Subject: Re: igt trouble with planes shared between multiple CRTCs (Re: [PATCH v2 0/8] R-Car DU: Support CRC calculation) Message-ID: <20180430145524.GJ12521@phenom.ffwll.local> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <3482108.jirjkbZynl@avalon> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <3482108.jirjkbZynl@avalon> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: On Sat, Apr 28, 2018 at 12:07:04AM +0300, Laurent Pinchart wrote: > Hi Daniel, > > (Removing the linux-media mailing list from CC as it is out of scope) > > You enquired on IRC whether this patch series passes the igt CRC tests. > > # ./kms_pipe_crc_basic --run-subtest read-crc-pipe-A > IGT-Version: 1.22-gf447f5fc531d (aarch64) (Linux: 4.17.0-rc1-00085-g56e849d93cc9 aarch64) > read-crc-pipe-A: Testing connector LVDS-1 using pipe A > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Test assertion failure function igt_pipe_crc_start, file igt_debugfs.c:764: > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Failed assertion: pipe_crc->crc_fd != -1 > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Last errno: 5, Input/output error > Stack trace: > Subtest read-crc-pipe-A failed. > **** DEBUG **** > (kms_pipe_crc_basic:1638) DEBUG: Test requirement passed: !(pipe >= data->display.n_pipes) > (kms_pipe_crc_basic:1638) INFO: read-crc-pipe-A: Testing connector LVDS-1 using pipe A > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: LVDS-1: set_pipe(A) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: LVDS-1: Selecting pipe A > (kms_pipe_crc_basic:1638) DEBUG: Clearing the fb with color (0.00,1.00,0.00) > (kms_pipe_crc_basic:1638) igt-fb-DEBUG: igt_create_fb_with_bo_size(width=1024, height=768, format=0x34325258, tiling=0x0, size=0) > (kms_pipe_crc_basic:1638) igt-fb-DEBUG: igt_create_fb_with_bo_size(handle=1, pitch=4096) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: Test requirement passed: plane_idx >= 0 && plane_idx < pipe->n_planes > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: A.0: plane_set_fb(140) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: A.0: plane_set_size (1024x768) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: A.0: fb_set_position(0,0) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: A.0: fb_set_size(1024x768) > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: commit { > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: LVDS-1: SetCrtc pipe A, fb 140, src (0, 0), mode 1024x768 > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetCrtc pipe A, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe A, plane 2, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe A, plane 3, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe A, plane 4, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetCrtc pipe B, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe B, plane 1, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe B, plane 2, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe B, plane 3, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe B, plane 4, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetCrtc pipe C, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe C, plane 1, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe C, plane 2, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe C, plane 3, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe C, plane 4, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetCrtc pipe D, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetCrtc pipe D, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe D, plane 2, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe D, plane 3, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: SetPlane pipe D, plane 4, disabling > (kms_pipe_crc_basic:1638) igt-kms-DEBUG: display: } > (kms_pipe_crc_basic:1638) igt-debugfs-DEBUG: Opening debugfs directory '/sys/kernel/debug/dri/0' > (kms_pipe_crc_basic:1638) igt-debugfs-DEBUG: Opening debugfs directory '/sys/kernel/debug/dri/0' > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Test assertion failure function igt_pipe_crc_start, file igt_debugfs.c:764: > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Failed assertion: pipe_crc->crc_fd != -1 > (kms_pipe_crc_basic:1638) igt-debugfs-CRITICAL: Last errno: 5, Input/output error > (kms_pipe_crc_basic:1638) igt-core-INFO: Stack trace: > **** END **** > Subtest read-crc-pipe-A: FAIL (0.061s) > > I think the answer is no, but I don't think it's the fault of this patch > series. Opening the CRC data file returns -EIO because the CRTC is not active, > and I'm trying to find out why that is the case. The debug log shows a commit > that seems strange to me, enabling pipe A and immediately disabling right > afterwards. After some investigation I believe that this is caused by sharing > primary planes between CRTCs. > > The R-Car DU groups CRTCs by two and shares 5 planes between the two CRTCs of > the group. This specific SoC has two groups of two CRTCs, but that's not > relevant here, so we can ignore pipes C and D. > > Pipes A and B thus shared 5 planes that I will number 0 to 4 for simplicity. > The driver sets plane 0 as the primary plane for CRTC A and plane 1 as the > primary plane for CRTC B. Planes 2, 3 and 4 are created as overlay planes. > > When igt iterates over all planes for pipe A, it will first encounter plane 0 > that has a framebuffer, and thus enables the pipe. It then iterates over > plane 1, recognizes it as a primary plane without a framebuffer, and thus > disables the pipe. Planes 2, 3 and 4 are recognized as overlay planes and thus > don't affect the pipe active state. Pipe B is handled the same way, and igt > disables it twice as planes 0 and 1 are primary. > > I don't know if the fault here is with igt that doesn't properly support this > architecture, or with the driver that shouldn't have two primary planes > available for a CRTC. In the former case, I'm not sure how to fix it, as I'm > not familiar enough with igt to rearchitecture the commit helpers. In the > latter case, how would you recommend fixing it on the driver side ? I guess thus far no one did run igt on a chip which did have reassignable primary planes. The problem here is that it's pretty hard to figure out which one is the real primary plane, since with possible CRTCs you could have multiple primary planes on 1 CRTC. There's no property or anything that explicitly tells you this. Two fixes: 1. Change drivers to limit primary planes to 1 crtc. Same for cursor overlays. There's probably other userspace than igt that gets confused by this, but this has the ugly downside that we artifically limit plane usage - if only 1 CRTC is on, we want to use all the available planes on that one. 2. Add some implicit or explicit uapi to allow userspace to figure out which primary plane is the primary plane for this crtc. a) Explicit option: We add a PRIMARY_ID property (and CURSOR_ID prop while at it) on the CRTC which points at the primary/cursor plane. b) Implicit option: We require primary planes are assigned to CRTC in the same order as they're created. So first primary plane you encouter is the one for the first CRTC, 2nd primary plane is the one for the 2nd CRTC and so on. If we go with this we probably should add a bit of code to the kernel to check that invariant (by making sure the primary plane has the corresponding CRTC included in its possible_crtc mask). Either way igt needs to be patched to not treat any primary plane that could work on a CRTC as the primary plane for that CRTC. Personally I'm leaning towards 2b). Cheers, Daniel > > On Monday, 23 April 2018 01:34:22 EEST Laurent Pinchart wrote: > > Hello, > > > > This patch series adds support for CRC calculation to the rcar-du-drm > > driver. > > > > CRC calculation is supported starting at the Renesas R-Car Gen3 SoCs, as > > earlier versions don't have the necessary hardware. On Gen3 SoCs, the CRC is > > computed by the DISCOM module part of the VSP-D and VSP-DL. > > > > The DISCOM is interfaced to the VSP through the UIF glue and appears as a > > VSP entity with a sink pad and a source pad. > > > > The series starts with a switch to SPDX license headers in patch 1/8, > > prompted by a checkpatch.pl warning for a later patch that complained about > > missing SPDX license headers. It then continues with cleanup and > > refactoring. Patches 2/8 and 3/8 prepare for DISCOM and UIF support by > > extending generic code to make it usable for the UIF. Patch 4/8 documents a > > structure that will receive new fields. > > > > Patch 5/8 then extends the API exposed by the VSP driver to the DU driver to > > support CRC computation configuration and reporting. The patch > > unfortunately needs to touch both the VSP and DU drivers, so the whole > > series will need to be merged through a single tree. > > > > Patch 5/8 adds support for the DISCOM and UIF in the VSP driver, patch 7/8 > > integrates it in the DRM pipeline, and patch 8/8 finally implements the CRC > > API in the DU driver to expose CRC computation to userspace. > > > > The hardware supports computing the CRC at any arbitrary point in the > > pipeline on a configurable window of the frame. This patch series supports > > CRC computation on input planes or pipeline output, but on the full frame > > only. Support for CRC window configuration can be added later if needed but > > will require extending the userspace API, as the DRM/KMS CRC API doesn't > > support this feature. > > > > Compared to v1, the CRC source names for plane inputs are now constructed > > from plane IDs instead of plane indices. This allows userspace to match CRC > > sources with planes. > > > > Note that exposing the DISCOM and UIF though the V4L2 API isn't supported as > > the module is only found in VSP-D and VSP-DL instances that are not exposed > > through V4L2. It is possible to expose those instances through V4L2 with a > > small modification to the driver for testing purpose. If the need arises to > > test DISCOM and UIF with such an out-of-tree patch, support for CRC > > reporting through a V4L2 control can be added later without affecting how > > CRC is exposed through the DRM/KMS API. > > > > The patches are based on top of the "[PATCH v2 00/15] R-Car VSP1: > > Dynamically assign blend units to display pipelines" patch series, itself > > based on top of the Linux media master branch and scheduled for merge in > > v4.18. The new base caused heavy conflicts, requiring this series to be > > merged through the V4L2 tree. Once the patches receive the necessary review > > I will ask Dave to ack the merge plan. > > > > For convenience the patches are available at > > > > git://linuxtv.org/pinchartl/media.git vsp1-discom-v2-20180423 > > > > The code has been tested through the kms-test-crc.py script part of the DU > > test suite available at > > > > git://git.ideasonboard.com/renesas/kms-tests.git discom > > > > Laurent Pinchart (8): > > v4l: vsp1: Use SPDX license headers > > v4l: vsp1: Share the CLU, LIF and LUT set_fmt pad operation code > > v4l: vsp1: Reset the crop and compose rectangles in the set_fmt helper > > v4l: vsp1: Document the vsp1_du_atomic_config structure > > v4l: vsp1: Extend the DU API to support CRC computation > > v4l: vsp1: Add support for the DISCOM entity > > v4l: vsp1: Integrate DISCOM in display pipeline > > drm: rcar-du: Add support for CRC computation > > > > drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 156 ++++++++++++++++- > > drivers/gpu/drm/rcar-du/rcar_du_crtc.h | 19 +++ > > drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 13 +- > > drivers/media/platform/vsp1/Makefile | 2 +- > > drivers/media/platform/vsp1/vsp1.h | 10 +- > > drivers/media/platform/vsp1/vsp1_brx.c | 6 +- > > drivers/media/platform/vsp1/vsp1_brx.h | 6 +- > > drivers/media/platform/vsp1/vsp1_clu.c | 71 ++------ > > drivers/media/platform/vsp1/vsp1_clu.h | 6 +- > > drivers/media/platform/vsp1/vsp1_dl.c | 8 +- > > drivers/media/platform/vsp1/vsp1_dl.h | 6 +- > > drivers/media/platform/vsp1/vsp1_drm.c | 127 ++++++++++++-- > > drivers/media/platform/vsp1/vsp1_drm.h | 20 ++- > > drivers/media/platform/vsp1/vsp1_drv.c | 26 ++- > > drivers/media/platform/vsp1/vsp1_entity.c | 103 +++++++++++- > > drivers/media/platform/vsp1/vsp1_entity.h | 13 +- > > drivers/media/platform/vsp1/vsp1_hgo.c | 6 +- > > drivers/media/platform/vsp1/vsp1_hgo.h | 6 +- > > drivers/media/platform/vsp1/vsp1_hgt.c | 6 +- > > drivers/media/platform/vsp1/vsp1_hgt.h | 6 +- > > drivers/media/platform/vsp1/vsp1_histo.c | 65 +------ > > drivers/media/platform/vsp1/vsp1_histo.h | 6 +- > > drivers/media/platform/vsp1/vsp1_hsit.c | 6 +- > > drivers/media/platform/vsp1/vsp1_hsit.h | 6 +- > > drivers/media/platform/vsp1/vsp1_lif.c | 71 ++------ > > drivers/media/platform/vsp1/vsp1_lif.h | 6 +- > > drivers/media/platform/vsp1/vsp1_lut.c | 71 ++------ > > drivers/media/platform/vsp1/vsp1_lut.h | 6 +- > > drivers/media/platform/vsp1/vsp1_pipe.c | 6 +- > > drivers/media/platform/vsp1/vsp1_pipe.h | 6 +- > > drivers/media/platform/vsp1/vsp1_regs.h | 46 ++++- > > drivers/media/platform/vsp1/vsp1_rpf.c | 6 +- > > drivers/media/platform/vsp1/vsp1_rwpf.c | 6 +- > > drivers/media/platform/vsp1/vsp1_rwpf.h | 6 +- > > drivers/media/platform/vsp1/vsp1_sru.c | 6 +- > > drivers/media/platform/vsp1/vsp1_sru.h | 6 +- > > drivers/media/platform/vsp1/vsp1_uds.c | 6 +- > > drivers/media/platform/vsp1/vsp1_uds.h | 6 +- > > drivers/media/platform/vsp1/vsp1_uif.c | 271 +++++++++++++++++++++++++++ > > drivers/media/platform/vsp1/vsp1_uif.h | 32 ++++ > > drivers/media/platform/vsp1/vsp1_video.c | 6 +- > > drivers/media/platform/vsp1/vsp1_video.h | 6 +- > > drivers/media/platform/vsp1/vsp1_wpf.c | 6 +- > > include/media/vsp1.h | 39 ++++- > > 44 files changed, 896 insertions(+), 417 deletions(-) > > create mode 100644 drivers/media/platform/vsp1/vsp1_uif.c > > create mode 100644 drivers/media/platform/vsp1/vsp1_uif.h > > -- > Regards, > > Laurent Pinchart > > > -- 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: igt trouble with planes shared between multiple CRTCs (Re: [PATCH v2 0/8] R-Car DU: Support CRC calculation) Date: Mon, 30 Apr 2018 16:55:24 +0200 Message-ID: <20180430145524.GJ12521@phenom.ffwll.local> References: <20180422223430.16407-1-laurent.pinchart+renesas@ideasonboard.com> <3482108.jirjkbZynl@avalon> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x242.google.com (mail-wm0-x242.google.com [IPv6:2a00:1450:400c:c09::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id BBEA06E35F for ; Mon, 30 Apr 2018 14:55:29 +0000 (UTC) Received: by mail-wm0-x242.google.com with SMTP id a8so13675709wmg.5 for ; Mon, 30 Apr 2018 07:55:29 -0700 (PDT) Content-Disposition: inline In-Reply-To: <3482108.jirjkbZynl@avalon> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Laurent Pinchart Cc: linux-renesas-soc@vger.kernel.org, Ulrich Hecht , dri-devel@lists.freedesktop.org, Kieran Bingham List-Id: dri-devel@lists.freedesktop.org T24gU2F0LCBBcHIgMjgsIDIwMTggYXQgMTI6MDc6MDRBTSArMDMwMCwgTGF1cmVudCBQaW5jaGFy dCB3cm90ZToKPiBIaSBEYW5pZWwsCj4gCj4gKFJlbW92aW5nIHRoZSBsaW51eC1tZWRpYSBtYWls aW5nIGxpc3QgZnJvbSBDQyBhcyBpdCBpcyBvdXQgb2Ygc2NvcGUpCj4gCj4gWW91IGVucXVpcmVk IG9uIElSQyB3aGV0aGVyIHRoaXMgcGF0Y2ggc2VyaWVzIHBhc3NlcyB0aGUgaWd0IENSQyB0ZXN0 cy4KPiAKPiAjIC4va21zX3BpcGVfY3JjX2Jhc2ljIC0tcnVuLXN1YnRlc3QgcmVhZC1jcmMtcGlw ZS1BCj4gSUdULVZlcnNpb246IDEuMjItZ2Y0NDdmNWZjNTMxZCAoYWFyY2g2NCkgKExpbnV4OiA0 LjE3LjAtcmMxLTAwMDg1LWc1NmU4NDlkOTNjYzkgYWFyY2g2NCkKPiByZWFkLWNyYy1waXBlLUE6 IFRlc3RpbmcgY29ubmVjdG9yIExWRFMtMSB1c2luZyBwaXBlIEEKPiAoa21zX3BpcGVfY3JjX2Jh c2ljOjE2MzgpIGlndC1kZWJ1Z2ZzLUNSSVRJQ0FMOiBUZXN0IGFzc2VydGlvbiBmYWlsdXJlIGZ1 bmN0aW9uIGlndF9waXBlX2NyY19zdGFydCwgZmlsZSBpZ3RfZGVidWdmcy5jOjc2NDoKPiAoa21z X3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1kZWJ1Z2ZzLUNSSVRJQ0FMOiBGYWlsZWQgYXNzZXJ0 aW9uOiBwaXBlX2NyYy0+Y3JjX2ZkICE9IC0xCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBp Z3QtZGVidWdmcy1DUklUSUNBTDogTGFzdCBlcnJubzogNSwgSW5wdXQvb3V0cHV0IGVycm9yCj4g U3RhY2sgdHJhY2U6Cj4gU3VidGVzdCByZWFkLWNyYy1waXBlLUEgZmFpbGVkLgo+ICoqKiogREVC VUcgKioqKgo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYzOCkgREVCVUc6IFRlc3QgcmVxdWlyZW1l bnQgcGFzc2VkOiAhKHBpcGUgPj0gZGF0YS0+ZGlzcGxheS5uX3BpcGVzKQo+IChrbXNfcGlwZV9j cmNfYmFzaWM6MTYzOCkgSU5GTzogcmVhZC1jcmMtcGlwZS1BOiBUZXN0aW5nIGNvbm5lY3RvciBM VkRTLTEgdXNpbmcgcGlwZSBBCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21zLURF QlVHOiBkaXNwbGF5OiBMVkRTLTE6IHNldF9waXBlKEEpCj4gKGttc19waXBlX2NyY19iYXNpYzox NjM4KSBpZ3Qta21zLURFQlVHOiBkaXNwbGF5OiBMVkRTLTE6IFNlbGVjdGluZyBwaXBlIEEKPiAo a21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIERFQlVHOiBDbGVhcmluZyB0aGUgZmIgd2l0aCBjb2xv ciAoMC4wMCwxLjAwLDAuMDApCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3QtZmItREVC VUc6IGlndF9jcmVhdGVfZmJfd2l0aF9ib19zaXplKHdpZHRoPTEwMjQsIGhlaWdodD03NjgsIGZv cm1hdD0weDM0MzI1MjU4LCB0aWxpbmc9MHgwLCBzaXplPTApCj4gKGttc19waXBlX2NyY19iYXNp YzoxNjM4KSBpZ3QtZmItREVCVUc6IGlndF9jcmVhdGVfZmJfd2l0aF9ib19zaXplKGhhbmRsZT0x LCBwaXRjaD00MDk2KQo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzog VGVzdCByZXF1aXJlbWVudCBwYXNzZWQ6IHBsYW5lX2lkeCA+PSAwICYmIHBsYW5lX2lkeCA8IHBp cGUtPm5fcGxhbmVzCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21zLURFQlVHOiBk aXNwbGF5OiBBLjA6IHBsYW5lX3NldF9mYigxNDApCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4 KSBpZ3Qta21zLURFQlVHOiBkaXNwbGF5OiBBLjA6IHBsYW5lX3NldF9zaXplICgxMDI0eDc2OCkK PiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6IEEuMDog ZmJfc2V0X3Bvc2l0aW9uKDAsMCkKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMt REVCVUc6IGRpc3BsYXk6IEEuMDogZmJfc2V0X3NpemUoMTAyNHg3NjgpCj4gKGttc19waXBlX2Ny Y19iYXNpYzoxNjM4KSBpZ3Qta21zLURFQlVHOiBkaXNwbGF5OiBjb21taXQgewo+IChrbXNfcGlw ZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIExWRFMtMTogU2V0 Q3J0YyBwaXBlIEEsIGZiIDE0MCwgc3JjICgwLCAwKSwgbW9kZSAxMDI0eDc2OAo+IChrbXNfcGlw ZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIFNldENydGMgcGlw ZSBBLCBkaXNhYmxpbmcKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6 IGRpc3BsYXk6ICAgICBTZXRQbGFuZSBwaXBlIEEsIHBsYW5lIDIsIGRpc2FibGluZwo+IChrbXNf cGlwZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIFNldFBsYW5l IHBpcGUgQSwgcGxhbmUgMywgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBp Z3Qta21zLURFQlVHOiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBBLCBwbGFuZSA0LCBkaXNh YmxpbmcKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6 ICAgICBTZXRDcnRjIHBpcGUgQiwgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4 KSBpZ3Qta21zLURFQlVHOiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBCLCBwbGFuZSAxLCBk aXNhYmxpbmcKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3Bs YXk6ICAgICBTZXRQbGFuZSBwaXBlIEIsIHBsYW5lIDIsIGRpc2FibGluZwo+IChrbXNfcGlwZV9j cmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIFNldFBsYW5lIHBpcGUg QiwgcGxhbmUgMywgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21z LURFQlVHOiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBCLCBwbGFuZSA0LCBkaXNhYmxpbmcK PiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6ICAgICBT ZXRDcnRjIHBpcGUgQywgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qt a21zLURFQlVHOiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBDLCBwbGFuZSAxLCBkaXNhYmxp bmcKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6ICAg ICBTZXRQbGFuZSBwaXBlIEMsIHBsYW5lIDIsIGRpc2FibGluZwo+IChrbXNfcGlwZV9jcmNfYmFz aWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIFNldFBsYW5lIHBpcGUgQywgcGxh bmUgMywgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21zLURFQlVH OiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBDLCBwbGFuZSA0LCBkaXNhYmxpbmcKPiAoa21z X3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6ICAgICBTZXRDcnRj IHBpcGUgRCwgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21zLURF QlVHOiBkaXNwbGF5OiAgICAgU2V0Q3J0YyBwaXBlIEQsIGRpc2FibGluZwo+IChrbXNfcGlwZV9j cmNfYmFzaWM6MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogICAgIFNldFBsYW5lIHBpcGUg RCwgcGxhbmUgMiwgZGlzYWJsaW5nCj4gKGttc19waXBlX2NyY19iYXNpYzoxNjM4KSBpZ3Qta21z LURFQlVHOiBkaXNwbGF5OiAgICAgU2V0UGxhbmUgcGlwZSBELCBwbGFuZSAzLCBkaXNhYmxpbmcK PiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1rbXMtREVCVUc6IGRpc3BsYXk6ICAgICBT ZXRQbGFuZSBwaXBlIEQsIHBsYW5lIDQsIGRpc2FibGluZwo+IChrbXNfcGlwZV9jcmNfYmFzaWM6 MTYzOCkgaWd0LWttcy1ERUJVRzogZGlzcGxheTogfQo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYz OCkgaWd0LWRlYnVnZnMtREVCVUc6IE9wZW5pbmcgZGVidWdmcyBkaXJlY3RvcnkgJy9zeXMva2Vy bmVsL2RlYnVnL2RyaS8wJwo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWRlYnVnZnMt REVCVUc6IE9wZW5pbmcgZGVidWdmcyBkaXJlY3RvcnkgJy9zeXMva2VybmVsL2RlYnVnL2RyaS8w Jwo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWRlYnVnZnMtQ1JJVElDQUw6IFRlc3Qg YXNzZXJ0aW9uIGZhaWx1cmUgZnVuY3Rpb24gaWd0X3BpcGVfY3JjX3N0YXJ0LCBmaWxlIGlndF9k ZWJ1Z2ZzLmM6NzY0Ogo+IChrbXNfcGlwZV9jcmNfYmFzaWM6MTYzOCkgaWd0LWRlYnVnZnMtQ1JJ VElDQUw6IEZhaWxlZCBhc3NlcnRpb246IHBpcGVfY3JjLT5jcmNfZmQgIT0gLTEKPiAoa21zX3Bp cGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1kZWJ1Z2ZzLUNSSVRJQ0FMOiBMYXN0IGVycm5vOiA1LCBJ bnB1dC9vdXRwdXQgZXJyb3IKPiAoa21zX3BpcGVfY3JjX2Jhc2ljOjE2MzgpIGlndC1jb3JlLUlO Rk86IFN0YWNrIHRyYWNlOgo+ICoqKiogIEVORCAgKioqKgo+IFN1YnRlc3QgcmVhZC1jcmMtcGlw ZS1BOiBGQUlMICgwLjA2MXMpCj4gCj4gSSB0aGluayB0aGUgYW5zd2VyIGlzIG5vLCBidXQgSSBk b24ndCB0aGluayBpdCdzIHRoZSBmYXVsdCBvZiB0aGlzIHBhdGNoCj4gc2VyaWVzLiBPcGVuaW5n IHRoZSBDUkMgZGF0YSBmaWxlIHJldHVybnMgLUVJTyBiZWNhdXNlIHRoZSBDUlRDIGlzIG5vdCBh Y3RpdmUsCj4gYW5kIEknbSB0cnlpbmcgdG8gZmluZCBvdXQgd2h5IHRoYXQgaXMgdGhlIGNhc2Uu IFRoZSBkZWJ1ZyBsb2cgc2hvd3MgYSBjb21taXQKPiB0aGF0IHNlZW1zIHN0cmFuZ2UgdG8gbWUs IGVuYWJsaW5nIHBpcGUgQSBhbmQgaW1tZWRpYXRlbHkgZGlzYWJsaW5nIHJpZ2h0Cj4gYWZ0ZXJ3 YXJkcy4gQWZ0ZXIgc29tZSBpbnZlc3RpZ2F0aW9uIEkgYmVsaWV2ZSB0aGF0IHRoaXMgaXMgY2F1 c2VkIGJ5IHNoYXJpbmcKPiBwcmltYXJ5IHBsYW5lcyBiZXR3ZWVuIENSVENzLgo+IAo+IFRoZSBS LUNhciBEVSBncm91cHMgQ1JUQ3MgYnkgdHdvIGFuZCBzaGFyZXMgNSBwbGFuZXMgYmV0d2VlbiB0 aGUgdHdvIENSVENzIG9mCj4gdGhlIGdyb3VwLiBUaGlzIHNwZWNpZmljIFNvQyBoYXMgdHdvIGdy b3VwcyBvZiB0d28gQ1JUQ3MsIGJ1dCB0aGF0J3Mgbm90Cj4gcmVsZXZhbnQgaGVyZSwgc28gd2Ug Y2FuIGlnbm9yZSBwaXBlcyBDIGFuZCBELgo+IAo+IFBpcGVzIEEgYW5kIEIgdGh1cyBzaGFyZWQg NSBwbGFuZXMgdGhhdCBJIHdpbGwgbnVtYmVyIDAgdG8gNCBmb3Igc2ltcGxpY2l0eS4KPiBUaGUg ZHJpdmVyIHNldHMgcGxhbmUgMCBhcyB0aGUgcHJpbWFyeSBwbGFuZSBmb3IgQ1JUQyBBIGFuZCBw bGFuZSAxIGFzIHRoZQo+IHByaW1hcnkgcGxhbmUgZm9yIENSVEMgQi4gUGxhbmVzIDIsIDMgYW5k IDQgYXJlIGNyZWF0ZWQgYXMgb3ZlcmxheSBwbGFuZXMuCj4gCj4gV2hlbiBpZ3QgaXRlcmF0ZXMg b3ZlciBhbGwgcGxhbmVzIGZvciBwaXBlIEEsIGl0IHdpbGwgZmlyc3QgZW5jb3VudGVyIHBsYW5l IDAKPiB0aGF0IGhhcyBhIGZyYW1lYnVmZmVyLCBhbmQgdGh1cyBlbmFibGVzIHRoZSBwaXBlLiBJ dCB0aGVuIGl0ZXJhdGVzIG92ZXIKPiBwbGFuZSAxLCByZWNvZ25pemVzIGl0IGFzIGEgcHJpbWFy eSBwbGFuZSB3aXRob3V0IGEgZnJhbWVidWZmZXIsIGFuZCB0aHVzCj4gZGlzYWJsZXMgdGhlIHBp cGUuIFBsYW5lcyAyLCAzIGFuZCA0IGFyZSByZWNvZ25pemVkIGFzIG92ZXJsYXkgcGxhbmVzIGFu ZCB0aHVzCj4gZG9uJ3QgYWZmZWN0IHRoZSBwaXBlIGFjdGl2ZSBzdGF0ZS4gUGlwZSBCIGlzIGhh bmRsZWQgdGhlIHNhbWUgd2F5LCBhbmQgaWd0Cj4gZGlzYWJsZXMgaXQgdHdpY2UgYXMgcGxhbmVz IDAgYW5kIDEgYXJlIHByaW1hcnkuCj4gCj4gSSBkb24ndCBrbm93IGlmIHRoZSBmYXVsdCBoZXJl IGlzIHdpdGggaWd0IHRoYXQgZG9lc24ndCBwcm9wZXJseSBzdXBwb3J0IHRoaXMKPiBhcmNoaXRl Y3R1cmUsIG9yIHdpdGggdGhlIGRyaXZlciB0aGF0IHNob3VsZG4ndCBoYXZlIHR3byBwcmltYXJ5 IHBsYW5lcwo+IGF2YWlsYWJsZSBmb3IgYSBDUlRDLiBJbiB0aGUgZm9ybWVyIGNhc2UsIEknbSBu b3Qgc3VyZSBob3cgdG8gZml4IGl0LCBhcyBJJ20KPiBub3QgZmFtaWxpYXIgZW5vdWdoIHdpdGgg aWd0IHRvIHJlYXJjaGl0ZWN0dXJlIHRoZSBjb21taXQgaGVscGVycy4gSW4gdGhlCj4gbGF0dGVy IGNhc2UsIGhvdyB3b3VsZCB5b3UgcmVjb21tZW5kIGZpeGluZyBpdCBvbiB0aGUgZHJpdmVyIHNp ZGUgPwoKSSBndWVzcyB0aHVzIGZhciBubyBvbmUgZGlkIHJ1biBpZ3Qgb24gYSBjaGlwIHdoaWNo IGRpZCBoYXZlIHJlYXNzaWduYWJsZQpwcmltYXJ5IHBsYW5lcy4gVGhlIHByb2JsZW0gaGVyZSBp cyB0aGF0IGl0J3MgcHJldHR5IGhhcmQgdG8gZmlndXJlIG91dAp3aGljaCBvbmUgaXMgdGhlIHJl YWwgcHJpbWFyeSBwbGFuZSwgc2luY2Ugd2l0aCBwb3NzaWJsZSBDUlRDcyB5b3UgY291bGQKaGF2 ZSBtdWx0aXBsZSBwcmltYXJ5IHBsYW5lcyBvbiAxIENSVEMuIFRoZXJlJ3Mgbm8gcHJvcGVydHkg b3IgYW55dGhpbmcKdGhhdCBleHBsaWNpdGx5IHRlbGxzIHlvdSB0aGlzLiBUd28gZml4ZXM6Cgox LiBDaGFuZ2UgZHJpdmVycyB0byBsaW1pdCBwcmltYXJ5IHBsYW5lcyB0byAxIGNydGMuIFNhbWUg Zm9yIGN1cnNvcgogICBvdmVybGF5cy4gVGhlcmUncyBwcm9iYWJseSBvdGhlciB1c2Vyc3BhY2Ug dGhhbiBpZ3QgdGhhdCBnZXRzIGNvbmZ1c2VkCiAgIGJ5IHRoaXMsIGJ1dCB0aGlzIGhhcyB0aGUg dWdseSBkb3duc2lkZSB0aGF0IHdlIGFydGlmaWNhbGx5IGxpbWl0IHBsYW5lCiAgIHVzYWdlIC0g aWYgb25seSAxIENSVEMgaXMgb24sIHdlIHdhbnQgdG8gdXNlIGFsbCB0aGUgYXZhaWxhYmxlIHBs YW5lcwogICBvbiB0aGF0IG9uZS4KCjIuIEFkZCBzb21lIGltcGxpY2l0IG9yIGV4cGxpY2l0IHVh cGkgdG8gYWxsb3cgdXNlcnNwYWNlIHRvIGZpZ3VyZSBvdXQKICAgd2hpY2ggcHJpbWFyeSBwbGFu ZSBpcyB0aGUgcHJpbWFyeSBwbGFuZSBmb3IgdGhpcyBjcnRjLgoKICAgYSkgRXhwbGljaXQgb3B0 aW9uOiBXZSBhZGQgYSBQUklNQVJZX0lEIHByb3BlcnR5IChhbmQgQ1VSU09SX0lEIHByb3AKICAg ICAgd2hpbGUgYXQgaXQpIG9uIHRoZSBDUlRDIHdoaWNoIHBvaW50cyBhdCB0aGUgcHJpbWFyeS9j dXJzb3IgcGxhbmUuCgogICBiKSBJbXBsaWNpdCBvcHRpb246IFdlIHJlcXVpcmUgcHJpbWFyeSBw bGFuZXMgYXJlIGFzc2lnbmVkIHRvIENSVEMgaW4gdGhlCiAgICAgIHNhbWUgb3JkZXIgYXMgdGhl eSdyZSBjcmVhdGVkLiBTbyBmaXJzdCBwcmltYXJ5IHBsYW5lIHlvdSBlbmNvdXRlcgogICAgICBp cyB0aGUgb25lIGZvciB0aGUgZmlyc3QgQ1JUQywgMm5kIHByaW1hcnkgcGxhbmUgaXMgdGhlIG9u ZSBmb3IgdGhlCiAgICAgIDJuZCBDUlRDIGFuZCBzbyBvbi4gSWYgd2UgZ28gd2l0aCB0aGlzIHdl IHByb2JhYmx5IHNob3VsZCBhZGQgYSBiaXQKICAgICAgb2YgY29kZSB0byB0aGUga2VybmVsIHRv IGNoZWNrIHRoYXQgaW52YXJpYW50IChieSBtYWtpbmcgc3VyZSB0aGUKICAgICAgcHJpbWFyeSBw bGFuZSBoYXMgdGhlIGNvcnJlc3BvbmRpbmcgQ1JUQyBpbmNsdWRlZCBpbiBpdHMKICAgICAgcG9z c2libGVfY3J0YyBtYXNrKS4KCkVpdGhlciB3YXkgaWd0IG5lZWRzIHRvIGJlIHBhdGNoZWQgdG8g bm90IHRyZWF0IGFueSBwcmltYXJ5IHBsYW5lIHRoYXQKY291bGQgd29yayBvbiBhIENSVEMgYXMg dGhlIHByaW1hcnkgcGxhbmUgZm9yIHRoYXQgQ1JUQy4KClBlcnNvbmFsbHkgSSdtIGxlYW5pbmcg dG93YXJkcyAyYikuCgpDaGVlcnMsIERhbmllbAoKPiAKPiBPbiBNb25kYXksIDIzIEFwcmlsIDIw MTggMDE6MzQ6MjIgRUVTVCBMYXVyZW50IFBpbmNoYXJ0IHdyb3RlOgo+ID4gSGVsbG8sCj4gPiAK PiA+IFRoaXMgcGF0Y2ggc2VyaWVzIGFkZHMgc3VwcG9ydCBmb3IgQ1JDIGNhbGN1bGF0aW9uIHRv IHRoZSByY2FyLWR1LWRybQo+ID4gZHJpdmVyLgo+ID4gCj4gPiBDUkMgY2FsY3VsYXRpb24gaXMg c3VwcG9ydGVkIHN0YXJ0aW5nIGF0IHRoZSBSZW5lc2FzIFItQ2FyIEdlbjMgU29DcywgYXMKPiA+ IGVhcmxpZXIgdmVyc2lvbnMgZG9uJ3QgaGF2ZSB0aGUgbmVjZXNzYXJ5IGhhcmR3YXJlLiBPbiBH ZW4zIFNvQ3MsIHRoZSBDUkMgaXMKPiA+IGNvbXB1dGVkIGJ5IHRoZSBESVNDT00gbW9kdWxlIHBh cnQgb2YgdGhlIFZTUC1EIGFuZCBWU1AtREwuCj4gPiAKPiA+IFRoZSBESVNDT00gaXMgaW50ZXJm YWNlZCB0byB0aGUgVlNQIHRocm91Z2ggdGhlIFVJRiBnbHVlIGFuZCBhcHBlYXJzIGFzIGEKPiA+ IFZTUCBlbnRpdHkgd2l0aCBhIHNpbmsgcGFkIGFuZCBhIHNvdXJjZSBwYWQuCj4gPiAKPiA+IFRo ZSBzZXJpZXMgc3RhcnRzIHdpdGggYSBzd2l0Y2ggdG8gU1BEWCBsaWNlbnNlIGhlYWRlcnMgaW4g cGF0Y2ggMS84LAo+ID4gcHJvbXB0ZWQgYnkgYSBjaGVja3BhdGNoLnBsIHdhcm5pbmcgZm9yIGEg bGF0ZXIgcGF0Y2ggdGhhdCBjb21wbGFpbmVkIGFib3V0Cj4gPiBtaXNzaW5nIFNQRFggbGljZW5z ZSBoZWFkZXJzLiBJdCB0aGVuIGNvbnRpbnVlcyB3aXRoIGNsZWFudXAgYW5kCj4gPiByZWZhY3Rv cmluZy4gUGF0Y2hlcyAyLzggYW5kIDMvOCBwcmVwYXJlIGZvciBESVNDT00gYW5kIFVJRiBzdXBw b3J0IGJ5Cj4gPiBleHRlbmRpbmcgZ2VuZXJpYyBjb2RlIHRvIG1ha2UgaXQgdXNhYmxlIGZvciB0 aGUgVUlGLiBQYXRjaCA0LzggZG9jdW1lbnRzIGEKPiA+IHN0cnVjdHVyZSB0aGF0IHdpbGwgcmVj ZWl2ZSBuZXcgZmllbGRzLgo+ID4gCj4gPiBQYXRjaCA1LzggdGhlbiBleHRlbmRzIHRoZSBBUEkg ZXhwb3NlZCBieSB0aGUgVlNQIGRyaXZlciB0byB0aGUgRFUgZHJpdmVyIHRvCj4gPiBzdXBwb3J0 IENSQyBjb21wdXRhdGlvbiBjb25maWd1cmF0aW9uIGFuZCByZXBvcnRpbmcuIFRoZSBwYXRjaAo+ ID4gdW5mb3J0dW5hdGVseSBuZWVkcyB0byB0b3VjaCBib3RoIHRoZSBWU1AgYW5kIERVIGRyaXZl cnMsIHNvIHRoZSB3aG9sZQo+ID4gc2VyaWVzIHdpbGwgbmVlZCB0byBiZSBtZXJnZWQgdGhyb3Vn aCBhIHNpbmdsZSB0cmVlLgo+ID4gCj4gPiBQYXRjaCA1LzggYWRkcyBzdXBwb3J0IGZvciB0aGUg RElTQ09NIGFuZCBVSUYgaW4gdGhlIFZTUCBkcml2ZXIsIHBhdGNoIDcvOAo+ID4gaW50ZWdyYXRl cyBpdCBpbiB0aGUgRFJNIHBpcGVsaW5lLCBhbmQgcGF0Y2ggOC84IGZpbmFsbHkgaW1wbGVtZW50 cyB0aGUgQ1JDCj4gPiBBUEkgaW4gdGhlIERVIGRyaXZlciB0byBleHBvc2UgQ1JDIGNvbXB1dGF0 aW9uIHRvIHVzZXJzcGFjZS4KPiA+IAo+ID4gVGhlIGhhcmR3YXJlIHN1cHBvcnRzIGNvbXB1dGlu ZyB0aGUgQ1JDIGF0IGFueSBhcmJpdHJhcnkgcG9pbnQgaW4gdGhlCj4gPiBwaXBlbGluZSBvbiBh IGNvbmZpZ3VyYWJsZSB3aW5kb3cgb2YgdGhlIGZyYW1lLiBUaGlzIHBhdGNoIHNlcmllcyBzdXBw b3J0cwo+ID4gQ1JDIGNvbXB1dGF0aW9uIG9uIGlucHV0IHBsYW5lcyBvciBwaXBlbGluZSBvdXRw dXQsIGJ1dCBvbiB0aGUgZnVsbCBmcmFtZQo+ID4gb25seS4gU3VwcG9ydCBmb3IgQ1JDIHdpbmRv dyBjb25maWd1cmF0aW9uIGNhbiBiZSBhZGRlZCBsYXRlciBpZiBuZWVkZWQgYnV0Cj4gPiB3aWxs IHJlcXVpcmUgZXh0ZW5kaW5nIHRoZSB1c2Vyc3BhY2UgQVBJLCBhcyB0aGUgRFJNL0tNUyBDUkMg QVBJIGRvZXNuJ3QKPiA+IHN1cHBvcnQgdGhpcyBmZWF0dXJlLgo+ID4gCj4gPiBDb21wYXJlZCB0 byB2MSwgdGhlIENSQyBzb3VyY2UgbmFtZXMgZm9yIHBsYW5lIGlucHV0cyBhcmUgbm93IGNvbnN0 cnVjdGVkCj4gPiBmcm9tIHBsYW5lIElEcyBpbnN0ZWFkIG9mIHBsYW5lIGluZGljZXMuIFRoaXMg YWxsb3dzIHVzZXJzcGFjZSB0byBtYXRjaCBDUkMKPiA+IHNvdXJjZXMgd2l0aCBwbGFuZXMuCj4g PiAKPiA+IE5vdGUgdGhhdCBleHBvc2luZyB0aGUgRElTQ09NIGFuZCBVSUYgdGhvdWdoIHRoZSBW NEwyIEFQSSBpc24ndCBzdXBwb3J0ZWQgYXMKPiA+IHRoZSBtb2R1bGUgaXMgb25seSBmb3VuZCBp biBWU1AtRCBhbmQgVlNQLURMIGluc3RhbmNlcyB0aGF0IGFyZSBub3QgZXhwb3NlZAo+ID4gdGhy b3VnaCBWNEwyLiBJdCBpcyBwb3NzaWJsZSB0byBleHBvc2UgdGhvc2UgaW5zdGFuY2VzIHRocm91 Z2ggVjRMMiB3aXRoIGEKPiA+IHNtYWxsIG1vZGlmaWNhdGlvbiB0byB0aGUgZHJpdmVyIGZvciB0 ZXN0aW5nIHB1cnBvc2UuIElmIHRoZSBuZWVkIGFyaXNlcyB0bwo+ID4gdGVzdCBESVNDT00gYW5k IFVJRiB3aXRoIHN1Y2ggYW4gb3V0LW9mLXRyZWUgcGF0Y2gsIHN1cHBvcnQgZm9yIENSQwo+ID4g cmVwb3J0aW5nIHRocm91Z2ggYSBWNEwyIGNvbnRyb2wgY2FuIGJlIGFkZGVkIGxhdGVyIHdpdGhv dXQgYWZmZWN0aW5nIGhvdwo+ID4gQ1JDIGlzIGV4cG9zZWQgdGhyb3VnaCB0aGUgRFJNL0tNUyBB UEkuCj4gPiAKPiA+IFRoZSBwYXRjaGVzIGFyZSBiYXNlZCBvbiB0b3Agb2YgdGhlICJbUEFUQ0gg djIgMDAvMTVdIFItQ2FyIFZTUDE6Cj4gPiBEeW5hbWljYWxseSBhc3NpZ24gYmxlbmQgdW5pdHMg dG8gZGlzcGxheSBwaXBlbGluZXMiIHBhdGNoIHNlcmllcywgaXRzZWxmCj4gPiBiYXNlZCBvbiB0 b3Agb2YgdGhlIExpbnV4IG1lZGlhIG1hc3RlciBicmFuY2ggYW5kIHNjaGVkdWxlZCBmb3IgbWVy Z2UgaW4KPiA+IHY0LjE4LiBUaGUgbmV3IGJhc2UgY2F1c2VkIGhlYXZ5IGNvbmZsaWN0cywgcmVx dWlyaW5nIHRoaXMgc2VyaWVzIHRvIGJlCj4gPiBtZXJnZWQgdGhyb3VnaCB0aGUgVjRMMiB0cmVl LiBPbmNlIHRoZSBwYXRjaGVzIHJlY2VpdmUgdGhlIG5lY2Vzc2FyeSByZXZpZXcKPiA+IEkgd2ls bCBhc2sgRGF2ZSB0byBhY2sgdGhlIG1lcmdlIHBsYW4uCj4gPiAKPiA+IEZvciBjb252ZW5pZW5j ZSB0aGUgcGF0Y2hlcyBhcmUgYXZhaWxhYmxlIGF0Cj4gPiAKPiA+ICAgICAgICAgZ2l0Oi8vbGlu dXh0di5vcmcvcGluY2hhcnRsL21lZGlhLmdpdCB2c3AxLWRpc2NvbS12Mi0yMDE4MDQyMwo+ID4g Cj4gPiBUaGUgY29kZSBoYXMgYmVlbiB0ZXN0ZWQgdGhyb3VnaCB0aGUga21zLXRlc3QtY3JjLnB5 IHNjcmlwdCBwYXJ0IG9mIHRoZSBEVQo+ID4gdGVzdCBzdWl0ZSBhdmFpbGFibGUgYXQKPiA+IAo+ ID4gICAgICAgICBnaXQ6Ly9naXQuaWRlYXNvbmJvYXJkLmNvbS9yZW5lc2FzL2ttcy10ZXN0cy5n aXQgZGlzY29tCj4gPiAKPiA+IExhdXJlbnQgUGluY2hhcnQgKDgpOgo+ID4gICB2NGw6IHZzcDE6 IFVzZSBTUERYIGxpY2Vuc2UgaGVhZGVycwo+ID4gICB2NGw6IHZzcDE6IFNoYXJlIHRoZSBDTFUs IExJRiBhbmQgTFVUIHNldF9mbXQgcGFkIG9wZXJhdGlvbiBjb2RlCj4gPiAgIHY0bDogdnNwMTog UmVzZXQgdGhlIGNyb3AgYW5kIGNvbXBvc2UgcmVjdGFuZ2xlcyBpbiB0aGUgc2V0X2ZtdCBoZWxw ZXIKPiA+ICAgdjRsOiB2c3AxOiBEb2N1bWVudCB0aGUgdnNwMV9kdV9hdG9taWNfY29uZmlnIHN0 cnVjdHVyZQo+ID4gICB2NGw6IHZzcDE6IEV4dGVuZCB0aGUgRFUgQVBJIHRvIHN1cHBvcnQgQ1JD IGNvbXB1dGF0aW9uCj4gPiAgIHY0bDogdnNwMTogQWRkIHN1cHBvcnQgZm9yIHRoZSBESVNDT00g ZW50aXR5Cj4gPiAgIHY0bDogdnNwMTogSW50ZWdyYXRlIERJU0NPTSBpbiBkaXNwbGF5IHBpcGVs aW5lCj4gPiAgIGRybTogcmNhci1kdTogQWRkIHN1cHBvcnQgZm9yIENSQyBjb21wdXRhdGlvbgo+ ID4gCj4gPiAgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmMgICAgfCAxNTYg KysrKysrKysrKysrKysrKy0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2Ny dGMuaCAgICB8ICAxOSArKysKPiA+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3Zz cC5jICAgICB8ICAxMyArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS9NYWtlZmls ZSAgICAgIHwgICAyICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDEuaCAg ICAgICAgfCAgMTAgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9icngu YyAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2JyeC5o ICAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfY2x1LmMg ICAgfCAgNzEgKystLS0tLS0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9j bHUuaCAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2Rs LmMgICAgIHwgICA4ICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwu aCAgICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0u YyAgICB8IDEyNyArKysrKysrKysrKystLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2RybS5oICAgIHwgIDIwICsrLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2Rydi5jICAgIHwgIDI2ICsrLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2VudGl0eS5jIHwgMTAzICsrKysrKysrKysrLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2VudGl0eS5oIHwgIDEzICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfaGdvLmMgICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9oZ28uaCAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2hndC5jICAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfaGd0LmggICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3ZzcDEvdnNwMV9oaXN0by5jICB8ICA2NSArLS0tLS0tCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfaGlzdG8uaCAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9oc2l0LmMgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX2hzaXQuaCAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfbGlmLmMgICAgfCAgNzEgKystLS0tLS0KPiA+ICBkcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMV9saWYuaCAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2x1dC5jICAgIHwgIDcxICsrLS0tLS0tCj4gPiAgZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfbHV0LmggICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmMgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaCAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS92c3AxL3ZzcDFfcmVncy5oICAgfCAgNDYgKysrKy0KPiA+ICBkcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9ycGYuYyAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX3J3cGYuYyAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS92c3AxL3ZzcDFfcndwZi5oICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMV9zcnUuYyAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3NydS5oICAgIHwgICA2ICstCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfdWRzLmMgICAgfCAgIDYgKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV91ZHMuaCAgICB8ICAgNiArLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vdnNwMS92c3AxX3VpZi5jICAgIHwgMjcxICsrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3VpZi5oICAgIHwgIDMyICsrKysK PiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV92aWRlby5jICB8ICAgNiArLQo+ ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3ZpZGVvLmggIHwgICA2ICstCj4g PiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfd3BmLmMgICAgfCAgIDYgKy0KPiA+ ICBpbmNsdWRlL21lZGlhL3ZzcDEuaCAgICAgICAgICAgICAgICAgICAgICB8ICAzOSArKysrLQo+ ID4gIDQ0IGZpbGVzIGNoYW5nZWQsIDg5NiBpbnNlcnRpb25zKCspLCA0MTcgZGVsZXRpb25zKC0p Cj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3Ax X3VpZi5jCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX3VpZi5oCj4gCj4gLS0gCj4gUmVnYXJkcywKPiAKPiBMYXVyZW50IFBpbmNoYXJ0Cj4g Cj4gCj4gCgotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9y YXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg==