From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:53460 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730503AbeGQLZQ (ORCPT ); Tue, 17 Jul 2018 07:25:16 -0400 From: Laurent Pinchart To: kieran.bingham+renesas@ideasonboard.com Cc: linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [PATCH v4 08/11] media: vsp1: Add support for extended display list headers Date: Tue, 17 Jul 2018 13:53:44 +0300 Message-ID: <3014394.qGWeGfuQTI@avalon> In-Reply-To: <9f8d828c-3e44-a62e-a0a7-8631dc3c7baa@ideasonboard.com> References: <4341947.2iR8IN8nZS@avalon> <9f8d828c-3e44-a62e-a0a7-8631dc3c7baa@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Kieran, On Monday, 16 July 2018 20:14:55 EEST Kieran Bingham wrote: > On 24/05/18 12:44, Laurent Pinchart wrote: > > On Thursday, 3 May 2018 16:36:19 EEST Kieran Bingham wrote: > >> Extended display list headers allow pre and post command lists to be > >> executed by the VSP pipeline. This provides the base support for > >> features such as AUTO_FLD (for interlaced support) and AUTO_DISP (for > >> supporting continuous camera preview pipelines. > >> > >> Signed-off-by: Kieran Bingham > >> > >> --- > >> > >> v2: > >> - remove __packed attributes > >> > >> --- > >> > >> drivers/media/platform/vsp1/vsp1.h | 1 +- > >> drivers/media/platform/vsp1/vsp1_dl.c | 83 +++++++++++++++++++++++++- > >> drivers/media/platform/vsp1/vsp1_dl.h | 29 ++++++++- > >> drivers/media/platform/vsp1/vsp1_drv.c | 7 +- > >> drivers/media/platform/vsp1/vsp1_regs.h | 5 +- > >> 5 files changed, 116 insertions(+), 9 deletions(-) [snip] > >> diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > >> b/drivers/media/platform/vsp1/vsp1_dl.c index 56514cd51c51..b64d32535edc > >> 100644 > >> --- a/drivers/media/platform/vsp1/vsp1_dl.c > >> +++ b/drivers/media/platform/vsp1/vsp1_dl.c [snip] > >> +struct vsp1_dl_ext_header { > >> + u32 reserved0; /* alignment padding */ > >> + > >> + u16 pre_ext_cmd_qty; > > > > Should this be called pre_ext_dl_num_cmd to match the datasheet ? > > Yes, renamed. > > >> + u16 flags; > > > > Aren't the flags supposed to come before the pre_ext_dl_num_cmd field ? > > These are out-of-order to account for the fact that they are 16bit values. Ah OK. It makes sense, but is a bit confusing when reading the datasheet. > I felt that keeping them described in the struct was cleaner than shifts > and masks - but clearly this stands out, due to the byte-ordering. > > Would you prefer I re-write this as 32 bit accesses (or even 64bit), > with shifts? Or is a comment sufficient here ? If it doesn't make the code too ugly, using larger accesses would be better I think. Otherwise a comment would do I suppose. > If we rewrite to be 32 bit accesses, would you be happy with the > following naming: > > u32 reserved0; > u32 pre_ext_dl_num_cmd; /* Also stores command flags. */ > u32 pre_ext_dl_plist; > u32 post_ext_dl_num_cmd; > u32 post_ext_dl_plist; > > (Technically the flags are for the whole header, not the just the > pre_ext, which is why I wanted it separated) > > > Actually - now I write that - the 'number of commands' is sort of a flag > or a parameter? so maybe the following is just as appropriate?: > > u32 reserved0; Maybe "u32 zero;" or "u32 padding;" ? The datasheet states this is padding for alignment purpose. > u32 pre_ext_dl_flags; > u32 pre_ext_dl_plist; > u32 post_ext_dl_flags; > u32 post_ext_dl_plist; > > Or they could be named 'options', or parameters? > > Any comments before I hack that in? > > The annoying part is that the 'flags' aren't part of the pre_ext cmds, > they declare whether the pre or post cmd should be executed (or both I > presume, we are yet to see post-cmd usage) I agree with you, having a separate flag field would be nicer, as the flags are shared. I'll chose the easy option of letting you decide what you like best :-) All the above options are equally good to me, provided you add a comment explaining why the flag comes after the num_cmd field if you decide to keep it as a separate field. > >> + u32 pre_ext_cmd_plist; > > > > And pre_ext_dl_plist ? > > > >> + > >> + u32 post_ext_cmd_qty; > >> + u32 post_ext_cmd_plist; > > > > Similar comments for these variables. > > Renamed. > > >> +}; > >> + > >> +struct vsp1_dl_header_extended { > >> + struct vsp1_dl_header header; > >> + struct vsp1_dl_ext_header ext; > >> +}; > >> + > >> struct vsp1_dl_entry { > >> u32 addr; > >> u32 data; > >> }; > >> > >> +struct vsp1_dl_ext_cmd_header { > > > > Isn't this referred to in the datasheet as a body entry, not a header ? > > How about naming it vsp1_dl_ext_cmd_entry ? Or just vsp1_dl_ext_cmd (in > > which case the other structure that goes by the same name would need to be > > renamed) ? > > I think I was getting too creative. The reality is this part is really a > 'header' describing the data in the body, but yes - it should be named > to match a "Pre Extended Display List Body" > > s/vsp1_dl_ext_cmd_header/vsp1_pre_ext_dl_body/ Sounds good to me. > This will then leave "struct vsp1_dl_ext_cmd" which represents the > object instance within the VSP1 driver only. > > >> + u32 cmd; > > This should really have been opcode then too :) Good point. > >> + u32 flags; > >> + u32 data; > >> + u32 reserved; > > > > The datasheet documents this as two 64-bit fields, shouldn't we handle the > > structure the same way ? > > I was trying to separate out the fields for clarity. > > In this instance (unlike the 16bit handling above), the byte ordering of > a 64 bit value works in our favour, and the ordering of the 4 u32s, > follows the order of the datasheet. > > If you'd prefer to handle them as 64bit with mask and shift, I'll > update, and rename this to contain two fields : > u64 ext_dl_cmd; > u64 ext_dl_data; > > But this is working well with the 32 bit definitions. Up to you, I'm OK with both. > >> +}; [snip] -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v4 08/11] media: vsp1: Add support for extended display list headers Date: Tue, 17 Jul 2018 13:53:44 +0300 Message-ID: <3014394.qGWeGfuQTI@avalon> References: <4341947.2iR8IN8nZS@avalon> <9f8d828c-3e44-a62e-a0a7-8631dc3c7baa@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by gabe.freedesktop.org (Postfix) with ESMTPS id 707576E02C for ; Tue, 17 Jul 2018 10:53:14 +0000 (UTC) In-Reply-To: <9f8d828c-3e44-a62e-a0a7-8631dc3c7baa@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: kieran.bingham+renesas@ideasonboard.com Cc: linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gTW9uZGF5LCAxNiBKdWx5IDIwMTggMjA6MTQ6NTUgRUVTVCBLaWVyYW4g QmluZ2hhbSB3cm90ZToKPiBPbiAyNC8wNS8xOCAxMjo0NCwgTGF1cmVudCBQaW5jaGFydCB3cm90 ZToKPiA+IE9uIFRodXJzZGF5LCAzIE1heSAyMDE4IDE2OjM2OjE5IEVFU1QgS2llcmFuIEJpbmdo YW0gd3JvdGU6Cj4gPj4gRXh0ZW5kZWQgZGlzcGxheSBsaXN0IGhlYWRlcnMgYWxsb3cgcHJlIGFu ZCBwb3N0IGNvbW1hbmQgbGlzdHMgdG8gYmUKPiA+PiBleGVjdXRlZCBieSB0aGUgVlNQIHBpcGVs aW5lLiBUaGlzIHByb3ZpZGVzIHRoZSBiYXNlIHN1cHBvcnQgZm9yCj4gPj4gZmVhdHVyZXMgc3Vj aCBhcyBBVVRPX0ZMRCAoZm9yIGludGVybGFjZWQgc3VwcG9ydCkgYW5kIEFVVE9fRElTUCAoZm9y Cj4gPj4gc3VwcG9ydGluZyBjb250aW51b3VzIGNhbWVyYSBwcmV2aWV3IHBpcGVsaW5lcy4KPiA+ PiAKPiA+PiBTaWduZWQtb2ZmLWJ5OiBLaWVyYW4gQmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVu ZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+ID4+IAo+ID4+IC0tLQo+ID4+IAo+ID4+IHYyOgo+ID4+ ICAtIHJlbW92ZSBfX3BhY2tlZCBhdHRyaWJ1dGVzCj4gPj4gCj4gPj4gLS0tCj4gPj4gCj4gPj4g IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxLmggICAgICB8ICAxICstCj4gPj4gIGRy aXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMgICB8IDgzICsrKysrKysrKysrKysr KysrKysrKysrKystCj4gPj4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmgg ICB8IDI5ICsrKysrKysrLQo+ID4+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9k cnYuYyAgfCAgNyArLQo+ID4+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9yZWdz LmggfCAgNSArLQo+ID4+ICA1IGZpbGVzIGNoYW5nZWQsIDExNiBpbnNlcnRpb25zKCspLCA5IGRl bGV0aW9ucygtKQoKW3NuaXBdCgo+ID4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9kbC5jCj4gPj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNw MV9kbC5jIGluZGV4IDU2NTE0Y2Q1MWM1MS4uYjY0ZDMyNTM1ZWRjCj4gPj4gMTAwNjQ0Cj4gPj4g LS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ID4+ICsrKyBiL2Ry aXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKCltzbmlwXQoKPiA+PiArc3RydWN0 IHZzcDFfZGxfZXh0X2hlYWRlciB7Cj4gPj4gKwl1MzIgcmVzZXJ2ZWQwOwkJLyogYWxpZ25tZW50 IHBhZGRpbmcgKi8KPiA+PiArCj4gPj4gKwl1MTYgcHJlX2V4dF9jbWRfcXR5Owo+ID4gCj4gPiBT aG91bGQgdGhpcyBiZSBjYWxsZWQgcHJlX2V4dF9kbF9udW1fY21kIHRvIG1hdGNoIHRoZSBkYXRh c2hlZXQgPwo+IAo+IFllcywgcmVuYW1lZC4KPiAKPiA+PiArCXUxNiBmbGFnczsKPiA+IAo+ID4g QXJlbid0IHRoZSBmbGFncyBzdXBwb3NlZCB0byBjb21lIGJlZm9yZSB0aGUgcHJlX2V4dF9kbF9u dW1fY21kIGZpZWxkID8KPiAKPiBUaGVzZSBhcmUgb3V0LW9mLW9yZGVyIHRvIGFjY291bnQgZm9y IHRoZSBmYWN0IHRoYXQgdGhleSBhcmUgMTZiaXQgdmFsdWVzLgoKQWggT0suIEl0IG1ha2VzIHNl bnNlLCBidXQgaXMgYSBiaXQgY29uZnVzaW5nIHdoZW4gcmVhZGluZyB0aGUgZGF0YXNoZWV0LgoK PiBJIGZlbHQgdGhhdCBrZWVwaW5nIHRoZW0gZGVzY3JpYmVkIGluIHRoZSBzdHJ1Y3Qgd2FzIGNs ZWFuZXIgdGhhbiBzaGlmdHMKPiBhbmQgbWFza3MgLSBidXQgY2xlYXJseSB0aGlzIHN0YW5kcyBv dXQsIGR1ZSB0byB0aGUgYnl0ZS1vcmRlcmluZy4KPiAKPiBXb3VsZCB5b3UgcHJlZmVyIEkgcmUt d3JpdGUgdGhpcyBhcyAzMiBiaXQgYWNjZXNzZXMgKG9yIGV2ZW4gNjRiaXQpLAo+IHdpdGggc2hp ZnRzPyBPciBpcyBhIGNvbW1lbnQgc3VmZmljaWVudCBoZXJlID8KCklmIGl0IGRvZXNuJ3QgbWFr ZSB0aGUgY29kZSB0b28gdWdseSwgdXNpbmcgbGFyZ2VyIGFjY2Vzc2VzIHdvdWxkIGJlIGJldHRl ciBJIAp0aGluay4gT3RoZXJ3aXNlIGEgY29tbWVudCB3b3VsZCBkbyBJIHN1cHBvc2UuCgo+IElm IHdlIHJld3JpdGUgdG8gYmUgMzIgYml0IGFjY2Vzc2VzLCB3b3VsZCB5b3UgYmUgaGFwcHkgd2l0 aCB0aGUKPiBmb2xsb3dpbmcgbmFtaW5nOgo+IAo+IAl1MzIgcmVzZXJ2ZWQwOwo+IAl1MzIgcHJl X2V4dF9kbF9udW1fY21kOyAvKiBBbHNvIHN0b3JlcyBjb21tYW5kIGZsYWdzLiAqLwo+IAl1MzIg cHJlX2V4dF9kbF9wbGlzdDsKPiAJdTMyIHBvc3RfZXh0X2RsX251bV9jbWQ7Cj4gCXUzMiBwb3N0 X2V4dF9kbF9wbGlzdDsKPiAKPiAoVGVjaG5pY2FsbHkgdGhlIGZsYWdzIGFyZSBmb3IgdGhlIHdo b2xlIGhlYWRlciwgbm90IHRoZSBqdXN0IHRoZQo+IHByZV9leHQsIHdoaWNoIGlzIHdoeSBJIHdh bnRlZCBpdCBzZXBhcmF0ZWQpCj4gCj4gCj4gQWN0dWFsbHkgLSBub3cgSSB3cml0ZSB0aGF0IC0g dGhlICdudW1iZXIgb2YgY29tbWFuZHMnIGlzIHNvcnQgb2YgYSBmbGFnCj4gb3IgYSBwYXJhbWV0 ZXI/IHNvIG1heWJlIHRoZSBmb2xsb3dpbmcgaXMganVzdCBhcyBhcHByb3ByaWF0ZT86Cj4gCj4g CXUzMiByZXNlcnZlZDA7CgpNYXliZSAidTMyIHplcm87IiBvciAidTMyIHBhZGRpbmc7IiA/IFRo ZSBkYXRhc2hlZXQgc3RhdGVzIHRoaXMgaXMgcGFkZGluZyBmb3IgCmFsaWdubWVudCBwdXJwb3Nl LgoKPiAJdTMyIHByZV9leHRfZGxfZmxhZ3M7Cj4gCXUzMiBwcmVfZXh0X2RsX3BsaXN0Owo+IAl1 MzIgcG9zdF9leHRfZGxfZmxhZ3M7Cj4gCXUzMiBwb3N0X2V4dF9kbF9wbGlzdDsKPiAKPiBPciB0 aGV5IGNvdWxkIGJlIG5hbWVkICdvcHRpb25zJywgb3IgcGFyYW1ldGVycz8KPiAKPiBBbnkgY29t bWVudHMgYmVmb3JlIEkgaGFjayB0aGF0IGluPwo+IAo+IFRoZSBhbm5veWluZyBwYXJ0IGlzIHRo YXQgdGhlICdmbGFncycgYXJlbid0IHBhcnQgb2YgdGhlIHByZV9leHQgY21kcywKPiB0aGV5IGRl Y2xhcmUgd2hldGhlciB0aGUgcHJlIG9yIHBvc3QgY21kIHNob3VsZCBiZSBleGVjdXRlZCAob3Ig Ym90aCBJCj4gcHJlc3VtZSwgd2UgYXJlIHlldCB0byBzZWUgcG9zdC1jbWQgdXNhZ2UpCgpJIGFn cmVlIHdpdGggeW91LCBoYXZpbmcgYSBzZXBhcmF0ZSBmbGFnIGZpZWxkIHdvdWxkIGJlIG5pY2Vy LCBhcyB0aGUgZmxhZ3MgCmFyZSBzaGFyZWQuIEknbGwgY2hvc2UgdGhlIGVhc3kgb3B0aW9uIG9m IGxldHRpbmcgeW91IGRlY2lkZSB3aGF0IHlvdSBsaWtlIApiZXN0IDotKSBBbGwgdGhlIGFib3Zl IG9wdGlvbnMgYXJlIGVxdWFsbHkgZ29vZCB0byBtZSwgcHJvdmlkZWQgeW91IGFkZCBhIApjb21t ZW50IGV4cGxhaW5pbmcgd2h5IHRoZSBmbGFnIGNvbWVzIGFmdGVyIHRoZSBudW1fY21kIGZpZWxk IGlmIHlvdSBkZWNpZGUgdG8gCmtlZXAgaXQgYXMgYSBzZXBhcmF0ZSBmaWVsZC4KCj4gPj4gKwl1 MzIgcHJlX2V4dF9jbWRfcGxpc3Q7Cj4gPiAKPiA+IEFuZCBwcmVfZXh0X2RsX3BsaXN0ID8KPiA+ IAo+ID4+ICsKPiA+PiArCXUzMiBwb3N0X2V4dF9jbWRfcXR5Owo+ID4+ICsJdTMyIHBvc3RfZXh0 X2NtZF9wbGlzdDsKPiA+IAo+ID4gU2ltaWxhciBjb21tZW50cyBmb3IgdGhlc2UgdmFyaWFibGVz Lgo+IAo+IFJlbmFtZWQuCj4gCj4gPj4gK307Cj4gPj4gKwo+ID4+ICtzdHJ1Y3QgdnNwMV9kbF9o ZWFkZXJfZXh0ZW5kZWQgewo+ID4+ICsJc3RydWN0IHZzcDFfZGxfaGVhZGVyIGhlYWRlcjsKPiA+ PiArCXN0cnVjdCB2c3AxX2RsX2V4dF9oZWFkZXIgZXh0Owo+ID4+ICt9Owo+ID4+ICsKPiA+PiAg c3RydWN0IHZzcDFfZGxfZW50cnkgewo+ID4+ICAJdTMyIGFkZHI7Cj4gPj4gIAl1MzIgZGF0YTsK PiA+PiAgfTsKPiA+PiAKPiA+PiArc3RydWN0IHZzcDFfZGxfZXh0X2NtZF9oZWFkZXIgewo+ID4g Cj4gPiBJc24ndCB0aGlzIHJlZmVycmVkIHRvIGluIHRoZSBkYXRhc2hlZXQgYXMgYSBib2R5IGVu dHJ5LCBub3QgYSBoZWFkZXIgPwo+ID4gSG93IGFib3V0IG5hbWluZyBpdCB2c3AxX2RsX2V4dF9j bWRfZW50cnkgPyBPciBqdXN0IHZzcDFfZGxfZXh0X2NtZCAoaW4KPiA+IHdoaWNoIGNhc2UgdGhl IG90aGVyIHN0cnVjdHVyZSB0aGF0IGdvZXMgYnkgdGhlIHNhbWUgbmFtZSB3b3VsZCBuZWVkIHRv IGJlCj4gPiByZW5hbWVkKSA/Cj4gCj4gSSB0aGluayBJIHdhcyBnZXR0aW5nIHRvbyBjcmVhdGl2 ZS4gVGhlIHJlYWxpdHkgaXMgdGhpcyBwYXJ0IGlzIHJlYWxseSBhCj4gJ2hlYWRlcicgZGVzY3Jp YmluZyB0aGUgZGF0YSBpbiB0aGUgYm9keSwgYnV0IHllcyAtIGl0IHNob3VsZCBiZSBuYW1lZAo+ IHRvIG1hdGNoIGEgIlByZSBFeHRlbmRlZCBEaXNwbGF5IExpc3QgQm9keSIKPiAKPiAgIHMvdnNw MV9kbF9leHRfY21kX2hlYWRlci92c3AxX3ByZV9leHRfZGxfYm9keS8KClNvdW5kcyBnb29kIHRv IG1lLgoKPiBUaGlzIHdpbGwgdGhlbiBsZWF2ZSAic3RydWN0IHZzcDFfZGxfZXh0X2NtZCIgd2hp Y2ggcmVwcmVzZW50cyB0aGUKPiBvYmplY3QgaW5zdGFuY2Ugd2l0aGluIHRoZSBWU1AxIGRyaXZl ciBvbmx5Lgo+IAo+ID4+ICsJdTMyIGNtZDsKPiAKPiBUaGlzIHNob3VsZCByZWFsbHkgaGF2ZSBi ZWVuIG9wY29kZSB0aGVuIHRvbyA6KQoKR29vZCBwb2ludC4KCj4gPj4gKwl1MzIgZmxhZ3M7Cj4g Pj4gKwl1MzIgZGF0YTsKPiA+PiArCXUzMiByZXNlcnZlZDsKPiA+IAo+ID4gVGhlIGRhdGFzaGVl dCBkb2N1bWVudHMgdGhpcyBhcyB0d28gNjQtYml0IGZpZWxkcywgc2hvdWxkbid0IHdlIGhhbmRs ZSB0aGUKPiA+IHN0cnVjdHVyZSB0aGUgc2FtZSB3YXkgPwo+IAo+IEkgd2FzIHRyeWluZyB0byBz ZXBhcmF0ZSBvdXQgdGhlIGZpZWxkcyBmb3IgY2xhcml0eS4KPiAKPiBJbiB0aGlzIGluc3RhbmNl ICh1bmxpa2UgdGhlIDE2Yml0IGhhbmRsaW5nIGFib3ZlKSwgdGhlIGJ5dGUgb3JkZXJpbmcgb2YK PiBhIDY0IGJpdCB2YWx1ZSB3b3JrcyBpbiBvdXIgZmF2b3VyLCBhbmQgdGhlIG9yZGVyaW5nIG9m IHRoZSA0IHUzMnMsCj4gZm9sbG93cyB0aGUgb3JkZXIgb2YgdGhlIGRhdGFzaGVldC4KPiAKPiBJ ZiB5b3UnZCBwcmVmZXIgdG8gaGFuZGxlIHRoZW0gYXMgNjRiaXQgd2l0aCBtYXNrIGFuZCBzaGlm dCwgSSdsbAo+IHVwZGF0ZSwgYW5kIHJlbmFtZSB0aGlzIHRvIGNvbnRhaW4gdHdvIGZpZWxkcyA6 Cj4gICAgICB1NjQgZXh0X2RsX2NtZDsKPiAgICAgIHU2NCBleHRfZGxfZGF0YTsKPiAKPiBCdXQg dGhpcyBpcyB3b3JraW5nIHdlbGwgd2l0aCB0aGUgMzIgYml0IGRlZmluaXRpb25zLgoKVXAgdG8g eW91LCBJJ20gT0sgd2l0aCBib3RoLgoKPiA+PiArfTsKCltzbmlwXQoKLS0gClJlZ2FyZHMsCgpM YXVyZW50IFBpbmNoYXJ0CgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbAo=