From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x136.google.com (mail-lf1-x136.google.com [IPv6:2a00:1450:4864:20::136]) by sourceware.org (Postfix) with ESMTPS id D906D3858417 for ; Mon, 21 Nov 2022 09:07:48 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org D906D3858417 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=linaro.org Received: by mail-lf1-x136.google.com with SMTP id s8so17835473lfc.8 for ; Mon, 21 Nov 2022 01:07:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=to:subject:message-id:date:from:in-reply-to:references:mime-version :from:to:cc:subject:date:message-id:reply-to; bh=OB7qvVpT5dx1D1Px958eUK3d84WYv+Yeo8fptcDB7+o=; b=DntCGoB/a39REFgexUR4ww4KtxA5TkkI+xw0sgS4+rKzizF1+UbvdeiXXW0UrN+RDz /OYSvJNPq3nBWQu0dBhqXu5XtzqmcmS50yE0dOyTRIpGfCp5QfQUGliFFFqHF8IfF3CR EWvH8qM0ZEUCK7taWOa+PVVQ302VxaNgfrtCLOLxapu2n/kUuzYj1MNwbKMx6lbco661 LCPbYHois737cllXRQoT5x+5wMwNC05iji5TlnN3MjJW/iume/zo7tP8InFioaUgZeMx 9ZNjMqEYwsMqkTg+APSwV0q7xK+OGs8ZzXIZrNu4TCHa42JHhXFWKLMfZxj7SoSuk9Ro SPaA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=to:subject:message-id:date:from:in-reply-to:references:mime-version :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=OB7qvVpT5dx1D1Px958eUK3d84WYv+Yeo8fptcDB7+o=; b=Q7q4gc4eR60ZdALCK/RXyuIvR74CONExcXvxtrcY+L/oATRbtIo8Pllhi5mqAXMQtn ygCD1VYkxP3rOLw1/ppUdlgrhUbn/CHA0yzcfleYBKXU+TcrFtwjYrzGuOQtVHU8BpUI Dptu6gfk9jyp7YdMO7KRkeYjM8g6aq5I0uGVp48/dzLD8ug/PjX5oZ0UHv4HeCVjwVqE vWFeAGKYKBXzzw0I5UETRN6CQW1ic4U/EcYnAKaD5C06w/oAwfd0GC4Rqi2AhytjvGI4 5EJzky3gZpykjs/aaeT5s8jYvBL3bHSPl9T82Uu04JSDQzyH/sNcGWYhiUGaX/FWKwkh VtIw== X-Gm-Message-State: ANoB5plfk4TZPSYEPIs9gnUZrMYREC4N0qE6MRGT9H5Ikc+j2TAZwO5D rVXqAToNmNdqZqVB5Ko4P1hrzMMxzQNB84IpDE7YPQ== X-Google-Smtp-Source: AA0mqf4g2wegNqUjICV8PALNiHmny2qWfRzmT7sTxg4qChepLwgGI2E8POVIkQoTmHpV9aOUSSLHs9E4vObEmQ0SW6Q= X-Received: by 2002:a19:6a0c:0:b0:4b4:c67:1e8a with SMTP id u12-20020a196a0c000000b004b40c671e8amr5282088lfu.126.1669021667251; Mon, 21 Nov 2022 01:07:47 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Prathamesh Kulkarni Date: Mon, 21 Nov 2022 14:37:10 +0530 Message-ID: Subject: Re: Extend fold_vec_perm to fold VEC_PERM_EXPR in VLA manner To: Prathamesh Kulkarni , gcc Patches , Richard Biener , richard.sandiford@arm.com Content-Type: multipart/mixed; boundary="0000000000009996e805edf7634d" X-Spam-Status: No, score=-7.3 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,SCC_10_SHORT_WORD_LINES,SCC_5_SHORT_WORD_LINES,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --0000000000009996e805edf7634d Content-Type: text/plain; charset="UTF-8" On Fri, 4 Nov 2022 at 14:00, Prathamesh Kulkarni wrote: > > On Mon, 31 Oct 2022 at 15:27, Richard Sandiford > wrote: > > > > Prathamesh Kulkarni writes: > > > On Wed, 26 Oct 2022 at 21:07, Richard Sandiford > > > wrote: > > >> > > >> Sorry for the slow response. I wanted to find some time to think > > >> about this a bit more. > > >> > > >> Prathamesh Kulkarni writes: > > >> > On Fri, 30 Sept 2022 at 21:38, Richard Sandiford > > >> > wrote: > > >> >> > > >> >> Richard Sandiford via Gcc-patches writes: > > >> >> > Prathamesh Kulkarni writes: > > >> >> >> Sorry to ask a silly question but in which case shall we select 2nd vector ? > > >> >> >> For num_poly_int_coeffs == 2, > > >> >> >> a1 /trunc n1 == (a1 + 0x) / (n1.coeffs[0] + n1.coeffs[1]*x) > > >> >> >> If a1/trunc n1 succeeds, > > >> >> >> 0 / n1.coeffs[1] == a1/n1.coeffs[0] == 0. > > >> >> >> So, a1 has to be < n1.coeffs[0] ? > > >> >> > > > >> >> > Remember that a1 is itself a poly_int. It's not necessarily a constant. > > >> >> > > > >> >> > E.g. the TRN1 .D instruction maps to a VEC_PERM_EXPR with the selector: > > >> >> > > > >> >> > { 0, 2 + 2x, 1, 4 + 2x, 2, 6 + 2x, ... } > > >> >> > > >> >> Sorry, should have been: > > >> >> > > >> >> { 0, 2 + 2x, 2, 4 + 2x, 4, 6 + 2x, ... } > > >> > Hi Richard, > > >> > Thanks for the clarifications, and sorry for late reply. > > >> > I have attached POC patch that tries to implement the above approach. > > >> > Passes bootstrap+test on x86_64-linux-gnu and aarch64-linux-gnu for VLS vectors. > > >> > > > >> > For VLA vectors, I have only done limited testing so far. > > >> > It seems to pass couple of tests written in the patch for > > >> > nelts_per_pattern == 3, > > >> > and folds the following svld1rq test: > > >> > int32x4_t v = {1, 2, 3, 4}; > > >> > return svld1rq_s32 (svptrue_b8 (), &v[0]) > > >> > into: > > >> > return {1, 2, 3, 4, ...}; > > >> > I will try to bootstrap+test it on SVE machine to test further for VLA folding. > > >> > > > >> > I have a couple of questions: > > >> > 1] When mask selects elements from same vector but from different patterns: > > >> > For eg: > > >> > arg0 = {1, 11, 2, 12, 3, 13, ...}, > > >> > arg1 = {21, 31, 22, 32, 23, 33, ...}, > > >> > mask = {0, 0, 0, 1, 0, 2, ... }, > > >> > All have npatterns = 2, nelts_per_pattern = 3. > > >> > > > >> > With above mask, > > >> > Pattern {0, ...} selects arg0[0], ie {1, ...} > > >> > Pattern {0, 1, 2, ...} selects arg0[0], arg0[1], arg0[2], ie {1, 11, 2, ...} > > >> > While arg0[0] and arg0[2] belong to same pattern, arg0[1] belongs to different > > >> > pattern in arg0. > > >> > The result is: > > >> > res = {1, 1, 1, 11, 1, 2, ...} > > >> > In this case, res's 2nd pattern {1, 11, 2, ...} is encoded with: > > >> > with a0 = 1, a1 = 11, S = -9. > > >> > Is that expected tho ? It seems to create a new encoding which > > >> > wasn't present in the input vector. For instance, the next elem in > > >> > sequence would be -7, > > >> > which is not present originally in arg0. > > >> > > >> Yeah, you're right, sorry. Going back to: > > >> > > >> (2) The explicit encoding can be used to produce a sequence of N*Ex*Px > > >> elements for any integer N. This extended sequence can be reencoded > > >> as having N*Px patterns, with Ex staying the same. > > >> > > >> I guess we need to pick an N for the selector such that each new > > >> selector pattern (each one out of the N*Px patterns) selects from > > >> the *same pattern* of the same data input. > > >> > > >> So if a particular pattern in the selector has a step S, and the data > > >> input it selects from has Pi patterns, N*S must be a multiple of Pi. > > >> N must be a multiple of least_common_multiple(S,Pi)/S. > > >> > > >> I think that means that the total number of patterns in the result > > >> (Pr from previous messages) can safely be: > > >> > > >> Ps * least_common_multiple( > > >> least_common_multiple(S[1], P[input(1)]) / S[1], > > >> ... > > >> least_common_multiple(S[Ps], P[input(Ps)]) / S[Ps] > > >> ) > > >> > > >> where: > > >> > > >> Ps = the number of patterns in the selector > > >> S[I] = the step for selector pattern I (I being 1-based) > > >> input(I) = the data input selected by selector pattern I (I being 1-based) > > >> P[I] = the number of patterns in data input I > > >> > > >> That's getting quite complicated :-) If we allow arbitrary P[...] > > >> and S[...] then it could also get large. Perhaps we should finally > > >> give up on the general case and limit this to power-of-2 patterns and > > >> power-of-2 steps, so that least_common_multiple becomes MAX. Maybe that > > >> simplifies other things as well. > > >> > > >> What do you think? > > > Hi Richard, > > > Thanks for the suggestions. Yeah I suppose we can initially add support for > > > power-of-2 patterns and power-of-2 steps and try to generalize it in > > > follow up patches if possible. > > > > > > Sorry if this sounds like a silly ques -- if we are going to have > > > pattern in selector, select *same pattern from same input vector*, > > > instead of re-encoding the selector to have N * Ps patterns, would it > > > make sense for elements in selector to denote pattern number itself > > > instead of element index > > > if input vectors are VLA ? > > > > > > For eg: > > > op0 = {1, 2, 3, 4, 1, 2, 3, 5, 1, 2, 3, 6, ...} > > > op1 = {...} > > > with npatterns == 4, nelts_per_pattern == 3, > > > sel = {0, 3} should pick pattern 0 and pattern 3 from op0, > > > so, res = {1, 4, 1, 5, 1, 6, ...} > > > Not sure if this is correct tho. > > > > This wouldn't allow us to represent things like a "duplicate one > > element", or "copy the leading N elements from the first input and > > the other elements from elements N+ of the second input", which we > > can with the current scheme. > > > > The restriction about each (unwound) selector pattern selecting from the > > same input pattern only applies to case where the selector pattern is > > stepped (and only applies to the stepped part of the pattern, not the > > leading element). The restriction is also local to this code; it > > doesn't make other VEC_PERM_EXPRs invalid. > Hi Richard, > Thanks for the clarifications. > Just to clarify your approach with an eg: > Let selected input vector be: > arg0: {a0, b0, c0, d0, > a0 + S, b0 + S, c0 + S, d0 + S, > a0 + 2S, b0 + 2S, c0 + 2S, dd + 2S, ...} > where arg0 has npatterns = 4, and nelts_per_pattern = 3. > > Let sel = {0, 0, 1, 2, 2, 4, ...} > where sel_npatterns = 2 and sel_nelts_per_pattern = 3 > > So, the first pattern in sel: > p1: {0, 1, 2, ...} which will select {a0, b0, c0, ...} > which would be incorrect, since they belong to different patterns in arg0. > So to select elements from same pattern in arg0, we need to divide p1 > into at least N1 = P_arg0 / S0 = 4 distinct patterns. > > Similarly for second pattern in sel: > p2: {0, 2, 4, ...}, we need to divide it into > at least N2 = P_arg0 / S1 = 2 distinct patterns. > > Select N = max(N1, N2) = 4 > So, the selector will be extended to N * Ps * Es = 4 * 2 * 3 == 24 elements, > and will be re-encoded with N*Ps = 8 patterns: > > re-encoded sel: > {a0, b0, c0, d0, a0 + S, b0 + S, c0 + S, d0 + S, > a0 + 2S, b0 + 2S, c0 + 2S, d0 + 2S, a0 + 3S, b0 + 3S, c0 + 3S, d0 + 3S, > a0 + 4S, b0 + 4S, c0 + 4s, d0 + 4S, a0 + 5S, b0 + 5S, c0 + 5S, d0 + 5S, > ...} > > with 8 patterns, > p1: {a0, a0 + 2S, a0 + 4S, ...} > p2: {b0, b0 + 2S, b0 + 4S, ...} > ... > which select elements from same pattern from same input vector. > Does this look correct ? > > For feasibility, we can check initially that sel_npatterns, arg0_npatterns, > arg1_npatterns are powers of 2 and for each stepped pattern, > it's stepped size S is a power of 2. I suppose this will be sufficient > to ensure that sel can be re-encoded with N*Ps npatterns > such that each new pattern selects elements from same pattern > of the input vector ? > > Then compute N: > N = 1; > for (every pattern p in sel) > { > op = corresponding input vector for pattern; > S = step_size (p); > N_pattern = max (S, npatterns (op)) / S; > N = max(N, N_pattern) > } > > and re-encode selector with N*Ps patterns. > I guess rest of the patch will mostly stay the same. Hi, I have attached a POC patch based on the above approach. For the above eg: arg0 = {1, 11, 2, 12, 3, 13, ...} // npatterns = 2, nelts_per_pattern = 3, and sel = {0, 0, 0, 1, 0, 2, ...} with sel_npatterns == 2 and sel_nelts_per_pattern == 3. For pattern, {0, 1, 2, ...} it will select elements from different patterns from arg0, which is incorrect. So we choose N = P1/S = 2/1 = 2, where P1 is number of elements in arg0. So re-encoded sel = { 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, ...} with following patterns: p1 = { 0, ... } p2 = { 0, 2, 4, ... } p3 = { 0, ... } p4 = { 1, 3, 5, ... } which should be correct since each element from the respective patterns in sel chooses elements from same pattern from arg0. So, res = { 1, 1, 1, 11, 1, 2, 1, 12, 1, 3, 1, 13, ... } Does this look correct ? Thanks, Prathamesh > > Thanks, > Prathamesh > > > > > Thanks, > > Richard > > > > > > > > Thanks, > > > Prathamesh > > >> > > >> > I suppose it's fine since if the user defines mask to have pattern {0, > > >> > 1, 2, ...} > > >> > they intended result to have pattern with above encoding. > > >> > Just wanted to confirm if this is correct ? > > >> > > > >> > 2] Could you please suggest a test-case for S < 0 ? > > >> > I am not able to come up with one :/ > > >> > > >> svrev is one way of creating negative steps. > > >> > > >> Thanks, > > >> Richard > > >> > > >> > > > >> > Thanks, > > >> > Prathamesh > > >> >> > > >> >> > which is an interleaving of the two patterns: > > >> >> > > > >> >> > { 0, 2, 4, ... } a0 = 0, a1 = 2, S = 2 > > >> >> > { 2 + 2x, 4 + 2x, 6 + 2x } a0 = 2 + 2x, a1 = 4 + 2x, S = 2 --0000000000009996e805edf7634d Content-Type: text/plain; charset="US-ASCII"; name="gnu-790-5.txt" Content-Disposition: attachment; filename="gnu-790-5.txt" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_laqk6xsx0 ZGlmZiAtLWdpdCBhL2djYy9mb2xkLWNvbnN0LmNjIGIvZ2NjL2ZvbGQtY29uc3QuY2MKaW5kZXgg OWY3YmVhZTE0ZTUuLjJmNDU5NzlkNGFjIDEwMDY0NAotLS0gYS9nY2MvZm9sZC1jb25zdC5jYwor KysgYi9nY2MvZm9sZC1jb25zdC5jYwpAQCAtODUsNiArODUsOSBAQCBhbG9uZyB3aXRoIEdDQzsg c2VlIHRoZSBmaWxlIENPUFlJTkczLiAgSWYgbm90IHNlZQogI2luY2x1ZGUgInZlYy1wZXJtLWlu ZGljZXMuaCIKICNpbmNsdWRlICJhc2FuLmgiCiAjaW5jbHVkZSAiZ2ltcGxlLXJhbmdlLmgiCisj aW5jbHVkZSA8YWxnb3JpdGhtPgorI2luY2x1ZGUgInRyZWUtcHJldHR5LXByaW50LmgiCisjaW5j bHVkZSAicHJpbnQtdHJlZS5oIgogCiAvKiBOb256ZXJvIGlmIHdlIGFyZSBmb2xkaW5nIGNvbnN0 YW50cyBpbnNpZGUgYW4gaW5pdGlhbGl6ZXIgb3IgYSBDKysKICAgIG1hbmlmZXN0bHktY29uc3Rh bnQtZXZhbHVhdGVkIGNvbnRleHQ7IHplcm8gb3RoZXJ3aXNlLgpAQCAtMTA0OTQsMzggKzEwNDk3 LDU1IEBAIGZvbGRfbXVsdF96Y29uanogKGxvY2F0aW9uX3QgbG9jLCB0cmVlIHR5cGUsIHRyZWUg ZXhwcikKIAkJCSAgYnVpbGRfemVyb19jc3QgKGl0eXBlKSk7CiB9CiAKKy8qIENoZWNrIGlmIFBB VFRFUk4gaW4gU0VMIHNlbGVjdHMgZWl0aGVyIEFSRzAgb3IgQVJHMSwKKyAgIGFuZCByZXR1cm4g dGhlIHNlbGVjdGVkIGFyZywgb3RoZXJ3aXNlIHJldHVybiBOVUxMX1RSRUUuICAqLwogCi0vKiBI ZWxwZXIgZnVuY3Rpb24gZm9yIGZvbGRfdmVjX3Blcm0uICBTdG9yZSBlbGVtZW50cyBvZiBWRUNU T1JfQ1NUIG9yCi0gICBDT05TVFJVQ1RPUiBBUkcgaW50byBhcnJheSBFTFRTLCB3aGljaCBoYXMg TkVMVFMgZWxlbWVudHMsIGFuZCByZXR1cm4KLSAgIHRydWUgaWYgc3VjY2Vzc2Z1bC4gICovCi0K LXN0YXRpYyBib29sCi12ZWNfY3N0X2N0b3JfdG9fYXJyYXkgKHRyZWUgYXJnLCB1bnNpZ25lZCBp bnQgbmVsdHMsIHRyZWUgKmVsdHMpCitzdGF0aWMgdHJlZQorZ2V0X3ZlY3Rvcl9mb3JfcGF0dGVy biAodHJlZSBhcmcwLCB0cmVlIGFyZzEsCisJCQljb25zdCB2ZWNfcGVybV9pbmRpY2VzICZzZWws IHVuc2lnbmVkIHBhdHRlcm4sCisJCQl1bnNpZ25lZCBzZWxfbnBhdHRlcm5zLCBpbnQgJlMpCiB7 Ci0gIHVuc2lnbmVkIEhPU1RfV0lERV9JTlQgaSwgbnVuaXRzOworICB1bnNpZ25lZCBzZWxfbmVs dHNfcGVyX3BhdHRlcm4gPSBzZWwuZW5jb2RpbmcgKCkubmVsdHNfcGVyX3BhdHRlcm4gKCk7CiAK LSAgaWYgKFRSRUVfQ09ERSAoYXJnKSA9PSBWRUNUT1JfQ1NUCi0gICAgICAmJiBWRUNUT1JfQ1NU X05FTFRTIChhcmcpLmlzX2NvbnN0YW50ICgmbnVuaXRzKSkKKyAgcG9seV91aW50NjQgbjEgPSBU WVBFX1ZFQ1RPUl9TVUJQQVJUUyAoVFJFRV9UWVBFIChhcmcwKSk7CisgIHBvbHlfdWludDY0IG5z ZWwgPSBzZWwubGVuZ3RoICgpOworICBwb2x5X3VpbnQ2NCBlc2VsOworCisgIGlmICghbXVsdGlw bGVfcCAobnNlbCwgc2VsX25wYXR0ZXJucywgJmVzZWwpKQorICAgIHJldHVybiBOVUxMX1RSRUU7 CisKKyAgcG9seV91aW50NjQgYTEgPSBzZWxbcGF0dGVybiArIHNlbF9ucGF0dGVybnNdOworICBT ID0gMDsKKyAgaWYgKHNlbF9uZWx0c19wZXJfcGF0dGVybiA9PSAzKQogICAgIHsKLSAgICAgIGZv ciAoaSA9IDA7IGkgPCBudW5pdHM7ICsraSkKLQllbHRzW2ldID0gVkVDVE9SX0NTVF9FTFQgKGFy ZywgaSk7CisgICAgICBwb2x5X3VpbnQ2NCBhMiA9IHNlbFtwYXR0ZXJuICsgMiAqIHNlbF9ucGF0 dGVybnNdOworICAgICAgUyA9IChhMiAtIGExKS50b19jb25zdGFudCAoKTsKKyAgICAgIGlmIChT ICE9IDAgJiYgIXBvdzJwX2h3aSAoUykpCisJcmV0dXJuIE5VTExfVFJFRTsKICAgICB9Ci0gIGVs c2UgaWYgKFRSRUVfQ09ERSAoYXJnKSA9PSBDT05TVFJVQ1RPUikKKworICBwb2x5X3VpbnQ2NCBh ZSA9IGExICsgKGVzZWwgLSAyKSAqIFM7CisgIHVpbnQ2NF90IHExLCBxZTsKKyAgcG9seV91aW50 NjQgcjEsIHJlOworCisgIGlmICghY2FuX2Rpdl90cnVuY19wIChhMSwgbjEsICZxMSwgJnIxKQor ICAgICAgfHwgIWNhbl9kaXZfdHJ1bmNfcCAoYWUsIG4xLCAmcWUsICZyZSkKKyAgICAgIHx8IChx MSAhPSBxZSkpCisgICAgcmV0dXJuIE5VTExfVFJFRTsKKworICB0cmVlIGFyZyA9ICgocTEgJiAx KSA9PSAwKSA/IGFyZzAgOiBhcmcxOworCisgIGlmIChTIDwgMCkKICAgICB7Ci0gICAgICBjb25z dHJ1Y3Rvcl9lbHQgKmVsdDsKKyAgICAgIHBvbHlfdWludDY0IGEwID0gc2VsW3BhdHRlcm5dOwor ICAgICAgaWYgKCFrbm93bl9lcSAoUywgYTEgLSBhMCkpCisgICAgICAgIHJldHVybiBOVUxMX1RS RUU7CiAKLSAgICAgIEZPUl9FQUNIX1ZFQ19TQUZFX0VMVCAoQ09OU1RSVUNUT1JfRUxUUyAoYXJn KSwgaSwgZWx0KQotCWlmIChpID49IG5lbHRzIHx8IFRSRUVfQ09ERSAoVFJFRV9UWVBFIChlbHQt PnZhbHVlKSkgPT0gVkVDVE9SX1RZUEUpCi0JICByZXR1cm4gZmFsc2U7Ci0JZWxzZQotCSAgZWx0 c1tpXSA9IGVsdC0+dmFsdWU7CisgICAgICBpZiAoIWtub3duX2d0IChyZSwgVkVDVE9SX0NTVF9O UEFUVEVSTlMgKGFyZykpKQorICAgICAgICByZXR1cm4gTlVMTF9UUkVFOwogICAgIH0KLSAgZWxz ZQotICAgIHJldHVybiBmYWxzZTsKLSAgZm9yICg7IGkgPCBuZWx0czsgaSsrKQotICAgIGVsdHNb aV0KLSAgICAgID0gZm9sZF9jb252ZXJ0IChUUkVFX1RZUEUgKFRSRUVfVFlQRSAoYXJnKSksIGlu dGVnZXJfemVyb19ub2RlKTsKLSAgcmV0dXJuIHRydWU7CisgIAorICByZXR1cm4gYXJnOwogfQog CiAvKiBBdHRlbXB0IHRvIGZvbGQgdmVjdG9yIHBlcm11dGF0aW9uIG9mIEFSRzAgYW5kIEFSRzEg dmVjdG9ycyB1c2luZyBTRUwKQEAgLTEwNTM5LDQxICsxMDU1OSwxMzUgQEAgZm9sZF92ZWNfcGVy bSAodHJlZSB0eXBlLCB0cmVlIGFyZzAsIHRyZWUgYXJnMSwgY29uc3QgdmVjX3Blcm1faW5kaWNl cyAmc2VsKQogICB1bnNpZ25lZCBIT1NUX1dJREVfSU5UIG5lbHRzOwogICBib29sIG5lZWRfY3Rv ciA9IGZhbHNlOwogCi0gIGlmICghc2VsLmxlbmd0aCAoKS5pc19jb25zdGFudCAoJm5lbHRzKSkK LSAgICByZXR1cm4gTlVMTF9UUkVFOwotICBnY2NfYXNzZXJ0IChrbm93bl9lcSAoVFlQRV9WRUNU T1JfU1VCUEFSVFMgKHR5cGUpLCBuZWx0cykKLQkgICAgICAmJiBrbm93bl9lcSAoVFlQRV9WRUNU T1JfU1VCUEFSVFMgKFRSRUVfVFlQRSAoYXJnMCkpLCBuZWx0cykKLQkgICAgICAmJiBrbm93bl9l cSAoVFlQRV9WRUNUT1JfU1VCUEFSVFMgKFRSRUVfVFlQRSAoYXJnMSkpLCBuZWx0cykpOworICBn Y2NfYXNzZXJ0IChrbm93bl9lcSAoVFlQRV9WRUNUT1JfU1VCUEFSVFMgKHR5cGUpLCBzZWwubGVu Z3RoICgpKQorCSAgICAgICYmIGtub3duX2VxIChUWVBFX1ZFQ1RPUl9TVUJQQVJUUyAoVFJFRV9U WVBFIChhcmcwKSksCisJCQkgICBUWVBFX1ZFQ1RPUl9TVUJQQVJUUyAoVFJFRV9UWVBFIChhcmcx KSkpKTsKICAgaWYgKFRSRUVfVFlQRSAoVFJFRV9UWVBFIChhcmcwKSkgIT0gVFJFRV9UWVBFICh0 eXBlKQogICAgICAgfHwgVFJFRV9UWVBFIChUUkVFX1RZUEUgKGFyZzEpKSAhPSBUUkVFX1RZUEUg KHR5cGUpKQogICAgIHJldHVybiBOVUxMX1RSRUU7CiAKLSAgdHJlZSAqaW5fZWx0cyA9IFhBTExP Q0FWRUMgKHRyZWUsIG5lbHRzICogMik7Ci0gIGlmICghdmVjX2NzdF9jdG9yX3RvX2FycmF5IChh cmcwLCBuZWx0cywgaW5fZWx0cykKLSAgICAgIHx8ICF2ZWNfY3N0X2N0b3JfdG9fYXJyYXkgKGFy ZzEsIG5lbHRzLCBpbl9lbHRzICsgbmVsdHMpKQorICB1bnNpZ25lZCByZXNfbnBhdHRlcm5zID0g MDsKKyAgdW5zaWduZWQgcmVzX25lbHRzX3Blcl9wYXR0ZXJuID0gMDsKKyAgdW5zaWduZWQgc2Vs X25wYXR0ZXJucyA9IDA7CisgIHRyZWUgKnZlY3Rvcl9mb3JfcGF0dGVybiA9IE5VTEw7CisKKyAg aWYgKFRSRUVfQ09ERSAoYXJnMCkgPT0gVkVDVE9SX0NTVAorICAgICAgJiYgVFJFRV9DT0RFIChh cmcxKSA9PSBWRUNUT1JfQ1NUCisgICAgICAmJiAhc2VsLmxlbmd0aCAoKS5pc19jb25zdGFudCAo KSkKKyAgICB7CisgICAgICB1bnNpZ25lZCBhcmcwX25wYXR0ZXJucyA9IFZFQ1RPUl9DU1RfTlBB VFRFUk5TIChhcmcwKTsKKyAgICAgIHVuc2lnbmVkIGFyZzFfbnBhdHRlcm5zID0gVkVDVE9SX0NT VF9OUEFUVEVSTlMgKGFyZzEpOworICAgICAgc2VsX25wYXR0ZXJucyA9IHNlbC5lbmNvZGluZyAo KS5ucGF0dGVybnMgKCk7CisKKyAgICAgIGlmICghcG93MnBfaHdpIChhcmcwX25wYXR0ZXJucykK KwkgIHx8ICFwb3cycF9od2kgKGFyZzFfbnBhdHRlcm5zKQorCSAgfHwgIXBvdzJwX2h3aSAoc2Vs X25wYXR0ZXJucykpCisgICAgICAgIHJldHVybiBOVUxMX1RSRUU7CisKKyAgICAgIHVuc2lnbmVk IE4gPSAxOworICAgICAgdmVjdG9yX2Zvcl9wYXR0ZXJuID0gWEFMTE9DQVZFQyAodHJlZSwgc2Vs X25wYXR0ZXJucyk7CisgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgc2VsX25wYXR0ZXJu czsgaSsrKQorCXsKKwkgIGludCBTID0gMDsKKwkgIHRyZWUgb3AgPSBnZXRfdmVjdG9yX2Zvcl9w YXR0ZXJuIChhcmcwLCBhcmcxLCBzZWwsIGksIHNlbF9ucGF0dGVybnMsIFMpOworCSAgaWYgKCFv cCkKKwkgICAgcmV0dXJuIE5VTExfVFJFRTsKKwkgIHZlY3Rvcl9mb3JfcGF0dGVybltpXSA9IG9w OworCSAgdW5zaWduZWQgTl9wYXR0ZXJuID0KKwkgICAgKFMgPiAwKSA/IHN0ZDo6bWF4PGludD4o UywgVkVDVE9SX0NTVF9OUEFUVEVSTlMgKG9wKSkgLyBTIDogMTsKKwkgIE4gPSBzdGQ6Om1heCAo TiwgTl9wYXR0ZXJuKTsKKwl9CisgICAgICAKKyAgICAgIHJlc19ucGF0dGVybnMKKyAgICAgICAg PSBzdGQ6Om1heCAoc2VsX25wYXR0ZXJucyAqIE4sIHN0ZDo6bWF4IChhcmcwX25wYXR0ZXJucywg YXJnMV9ucGF0dGVybnMpKTsKKworICAgICAgcmVzX25lbHRzX3Blcl9wYXR0ZXJuCisJPSBzdGQ6 Om1heChzZWwuZW5jb2RpbmcgKCkubmVsdHNfcGVyX3BhdHRlcm4gKCksCisJCSAgIHN0ZDo6bWF4 IChWRUNUT1JfQ1NUX05FTFRTX1BFUl9QQVRURVJOIChhcmcwKSwKKwkJCSAgICAgVkVDVE9SX0NT VF9ORUxUU19QRVJfUEFUVEVSTiAoYXJnMSkpKTsKKyAgICB9CisgIGVsc2UgaWYgKHNlbC5sZW5n dGggKCkuaXNfY29uc3RhbnQgKCZuZWx0cykKKwkgICAmJiBUWVBFX1ZFQ1RPUl9TVUJQQVJUUyAo VFJFRV9UWVBFIChhcmcwKSkuaXNfY29uc3RhbnQgKCkKKwkgICAmJiBUWVBFX1ZFQ1RPUl9TVUJQ QVJUUyAoVFJFRV9UWVBFIChhcmcwKSkudG9fY29uc3RhbnQgKCkgPT0gbmVsdHMpCisgICAgewor ICAgICAgLyogRm9yIFZMUyB2ZWN0b3JzLCB0cmVhdCBhbGwgdmVjdG9ycyB3aXRoCisJIG5wYXR0 ZXJucyA9IG5lbHRzLCBuZWx0c19wZXJfcGF0dGVybiA9IDEuICovCisgICAgICByZXNfbnBhdHRl cm5zID0gc2VsX25wYXR0ZXJucyA9IG5lbHRzOworICAgICAgcmVzX25lbHRzX3Blcl9wYXR0ZXJu ID0gMTsKKyAgICAgIHZlY3Rvcl9mb3JfcGF0dGVybiA9IFhBTExPQ0FWRUMgKHRyZWUsIG5lbHRz KTsKKyAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBuZWx0czsgaSsrKQorICAgICAgICB7 CisJICBIT1NUX1dJREVfSU5UIGluZGV4OworCSAgaWYgKCFzZWxbaV0uaXNfY29uc3RhbnQgKCZp bmRleCkpCisJICAgIHJldHVybiBOVUxMX1RSRUU7CisJICB2ZWN0b3JfZm9yX3BhdHRlcm5baV0g PSAoaW5kZXggPCBuZWx0cykgPyBhcmcwIDogYXJnMTsJCisJfQorICAgIH0KKyAgZWxzZQogICAg IHJldHVybiBOVUxMX1RSRUU7CiAKLSAgdHJlZV92ZWN0b3JfYnVpbGRlciBvdXRfZWx0cyAodHlw ZSwgbmVsdHMsIDEpOwotICBmb3IgKGkgPSAwOyBpIDwgbmVsdHM7IGkrKykKKyAgdHJlZV92ZWN0 b3JfYnVpbGRlciBvdXRfZWx0cyAodHlwZSwgcmVzX25wYXR0ZXJucywKKwkJCQlyZXNfbmVsdHNf cGVyX3BhdHRlcm4pOworICB1bnNpZ25lZCByZXNfbmVsdHMgPSByZXNfbnBhdHRlcm5zICogcmVz X25lbHRzX3Blcl9wYXR0ZXJuOworICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcmVzX25lbHRz OyBpKyspCiAgICAgewotICAgICAgSE9TVF9XSURFX0lOVCBpbmRleDsKLSAgICAgIGlmICghc2Vs W2ldLmlzX2NvbnN0YW50ICgmaW5kZXgpKQotCXJldHVybiBOVUxMX1RSRUU7Ci0gICAgICBpZiAo IUNPTlNUQU5UX0NMQVNTX1AgKGluX2VsdHNbaW5kZXhdKSkKLQluZWVkX2N0b3IgPSB0cnVlOwot ICAgICAgb3V0X2VsdHMucXVpY2tfcHVzaCAodW5zaGFyZV9leHByIChpbl9lbHRzW2luZGV4XSkp OworICAgICAgLyogRm9yIFZMQSB2ZWN0b3JzLCBpICUgc2VsX25wYXR0ZXJucyB3b3VsZCBnaXZl IHRoZSBvcmlnaW5hbAorICAgICAgICAgcGF0dGVybiB0aGUgZWxlbWVudCBiZWxvbmdzIHRvLCB3 aGljaCBpcyBzdWZmaWNpZW50IHRvIGdldCB0aGUgYXJnLgorCSBFdmVuIGlmIHNlbF9ucGF0dGVy bnMgaGFzIGJlZW4gbXVsdGlwbGllZCBieSBOLAorCSB0aGV5IHdpbGwgYWx3YXlzIGNvbWUgZnJv bSB0aGUgc2FtZSBpbnB1dCB2ZWN0b3IuCisJIEZvciBWTFMgdmVjdG9ycywgc2VsX25wYXR0ZXJu cyA9PSByZXNfbmVsdHMgPT0gbmVsdHMsCisJIHNvIGkgJSBzZWxfbnBhdHRlcm5zID09IGkgc2lu Y2UgaSA8IG5lbHRzICovCisgICAgICAgCisgICAgICB0cmVlIGFyZyA9IHZlY3Rvcl9mb3JfcGF0 dGVybltpICUgc2VsX25wYXR0ZXJuc107CisgICAgICB1bnNpZ25lZCBIT1NUX1dJREVfSU5UIGlu ZGV4OworCisgICAgICBpZiAoYXJnID09IGFyZzApCisJeworCSAgaWYgKCFzZWxbaV0uaXNfY29u c3RhbnQgKCkpCisJICAgIHJldHVybiBOVUxMX1RSRUU7CisJICBpbmRleCA9IHNlbFtpXS50b19j b25zdGFudCAoKTsKKwl9CisgICAgICBlbHNlCisgICAgICAgIHsKKwkgIGdjY19hc3NlcnQgKGFy ZyA9PSBhcmcxKTsKKwkgIHBvbHlfdWludDY0IG4xID0gVFlQRV9WRUNUT1JfU1VCUEFSVFMgKFRS RUVfVFlQRSAoYXJnMCkpOworCSAgdWludDY0X3QgcTsKKwkgIHBvbHlfdWludDY0IHI7CisKKwkg IC8qIERpdmlkZSBzZWxbaV0gYnkgaW5wdXQgdmVjdG9yIGxlbmd0aCwgdG8gb2J0YWluIHJlbWFp bmRlciwKKwkgICAgIHdoaWNoIHdvdWxkIGJlIHRoZSBpbmRleCBmb3IgZWl0aGVyIGlucHV0IHZl Y3Rvci4gICovCisJICBpZiAoIWNhbl9kaXZfdHJ1bmNfcCAoc2VsW2ldLCBuMSwgJnEsICZyKSkK KwkgICAgcmV0dXJuIE5VTExfVFJFRTsKKworCSAgaWYgKCFyLmlzX2NvbnN0YW50ICgmaW5kZXgp KQorCSAgICByZXR1cm4gTlVMTF9UUkVFOworCX0KKworICAgICAgdHJlZSBlbGVtOworICAgICAg aWYgKFRSRUVfQ09ERSAoYXJnKSA9PSBDT05TVFJVQ1RPUikKKyAgICAgICAgeworCSAgZ2NjX2Fz c2VydCAoaW5kZXggPCBuZWx0cyk7CisJICBpZiAoaW5kZXggPj0gdmVjX3NhZmVfbGVuZ3RoIChD T05TVFJVQ1RPUl9FTFRTIChhcmcpKSkKKwkgICAgcmV0dXJuIE5VTExfVFJFRTsKKwkgIGVsZW0g PSBDT05TVFJVQ1RPUl9FTFQgKGFyZywgaW5kZXgpLT52YWx1ZTsKKwkgIGlmIChWRUNUT1JfVFlQ RV9QIChUUkVFX1RZUEUgKGVsZW0pKSkKKwkgICAgcmV0dXJuIE5VTExfVFJFRTsKKwkgIG5lZWRf Y3RvciA9IHRydWU7CisJfQorICAgICAgZWxzZQorICAgICAgICBlbGVtID0gdmVjdG9yX2NzdF9l bHQgKGFyZywgaW5kZXgpOworICAgICAgb3V0X2VsdHMucXVpY2tfcHVzaCAoZWxlbSk7CiAgICAg fQogCiAgIGlmIChuZWVkX2N0b3IpCiAgICAgewogICAgICAgdmVjPGNvbnN0cnVjdG9yX2VsdCwg dmFfZ2M+ICp2OwotICAgICAgdmVjX2FsbG9jICh2LCBuZWx0cyk7Ci0gICAgICBmb3IgKGkgPSAw OyBpIDwgbmVsdHM7IGkrKykKKyAgICAgIHZlY19hbGxvYyAodiwgcmVzX25lbHRzKTsKKyAgICAg IGZvciAoaSA9IDA7IGkgPCByZXNfbmVsdHM7IGkrKykKIAlDT05TVFJVQ1RPUl9BUFBFTkRfRUxU ICh2LCBOVUxMX1RSRUUsIG91dF9lbHRzW2ldKTsKICAgICAgIHJldHVybiBidWlsZF9jb25zdHJ1 Y3RvciAodHlwZSwgdik7CiAgICAgfQotICBlbHNlCi0gICAgcmV0dXJuIG91dF9lbHRzLmJ1aWxk ICgpOworICByZXR1cm4gb3V0X2VsdHMuYnVpbGQgKCk7CiB9CiAKIC8qIFRyeSB0byBmb2xkIGEg cG9pbnRlciBkaWZmZXJlbmNlIG9mIHR5cGUgVFlQRSB0d28gYWRkcmVzcyBleHByZXNzaW9ucyBv ZgpAQCAtMTY5MTAsNiArMTcwMjQsOTcgQEAgdGVzdF92ZWNfZHVwbGljYXRlX2ZvbGRpbmcgKCkK ICAgQVNTRVJUX1RSVUUgKG9wZXJhbmRfZXF1YWxfcCAoZHVwNV9leHByLCBkdXA1X2NzdCwgMCkp OwogfQogCitzdGF0aWMgdHJlZQorYnVpbGRfdmVjX2ludF9jc3QgKHVuc2lnbmVkIG5wYXR0ZXJu cywgdW5zaWduZWQgbmVsdHNfcGVyX3BhdHRlcm4sCisJCSAgIGludCAqZW5jb2RlZF9lbGVtcykK K3sKKyAgc2NhbGFyX2ludF9tb2RlIGludF9tb2RlID0gU0NBTEFSX0lOVF9UWVBFX01PREUgKGlu dGVnZXJfdHlwZV9ub2RlKTsKKyAgbWFjaGluZV9tb2RlIHZtb2RlID0gdGFyZ2V0bS52ZWN0b3Jp emUucHJlZmVycmVkX3NpbWRfbW9kZSAoaW50X21vZGUpOworICAvL21hY2hpbmVfbW9kZSB2bW9k ZSA9IFZOeDRTSW1vZGU7CisgIHBvbHlfdWludDY0IG51bml0cyA9IEdFVF9NT0RFX05VTklUUyAo dm1vZGUpOworICB0cmVlIHZlY3R5cGUgPSBidWlsZF92ZWN0b3JfdHlwZSAoaW50ZWdlcl90eXBl X25vZGUsIG51bml0cyk7CisKKyAgdHJlZV92ZWN0b3JfYnVpbGRlciBidWlsZGVyICh2ZWN0eXBl LCBucGF0dGVybnMsIG5lbHRzX3Blcl9wYXR0ZXJuKTsKKyAgZm9yICh1bnNpZ25lZCBpID0gMDsg aSA8IG5wYXR0ZXJucyAqIG5lbHRzX3Blcl9wYXR0ZXJuOyBpKyspCisgICAgYnVpbGRlci5xdWlj a19wdXNoIChidWlsZF9pbnRfY3N0IChpbnRlZ2VyX3R5cGVfbm9kZSwgZW5jb2RlZF9lbGVtc1tp XSkpOworICByZXR1cm4gYnVpbGRlci5idWlsZCAoKTsKK30KKworc3RhdGljIHZvaWQKK3Rlc3Rf dmVjX3Blcm1fdmxhX2ZvbGRpbmcgKCkKK3sKKyAgaW50IGFyZzBfZWxlbXNbXSA9IHsgMSwgMTEs IDIsIDEyLCAzLCAxMyB9OworICB0cmVlIGFyZzAgPSBidWlsZF92ZWNfaW50X2NzdCAoMiwgMywg YXJnMF9lbGVtcyk7CisKKyAgaW50IGFyZzFfZWxlbXNbXSA9IHsgMjEsIDMxLCAyMiwgMzIsIDIz LCAzMyB9OworICB0cmVlIGFyZzEgPSBidWlsZF92ZWNfaW50X2NzdCAoMiwgMywgYXJnMV9lbGVt cyk7CisKKyAgaWYgKFRZUEVfVkVDVE9SX1NVQlBBUlRTIChUUkVFX1RZUEUgKGFyZzApKS5pc19j b25zdGFudCAoKQorICAgICAgfHwgVFlQRV9WRUNUT1JfU1VCUEFSVFMgKFRSRUVfVFlQRSAoYXJn MSkpLmlzX2NvbnN0YW50ICgpKQorICAgIHJldHVybjsKKworICAvKiBDYXNlIDE6IEZvciBtYXNr OiB7MCwgMSwgMiwgLi4ufSwgbnBhdHRlcm5zID09IDEsIG5lbHRzX3Blcl9wYXR0ZXJuID09IDMs CisgICAgIHNob3VsZCBzZWxlY3QgYXJnMC4gICovCisgIHsKKyAgICBpbnQgbWFza19lbGVtc1td ID0gezAsIDEsIDJ9OworICAgIHRyZWUgbWFzayA9IGJ1aWxkX3ZlY19pbnRfY3N0ICgxLCAzLCBt YXNrX2VsZW1zKTsKKyAgICB0cmVlIHJlcyA9IGZvbGRfdGVybmFyeSAoVkVDX1BFUk1fRVhQUiwg VFJFRV9UWVBFIChhcmcwKSwgYXJnMCwgYXJnMSwgbWFzayk7CisgICAgQVNTRVJUX1RSVUUgKHJl cyAhPSBOVUxMX1RSRUUpOworICAgIEFTU0VSVF9UUlVFIChWRUNUT1JfQ1NUX05QQVRURVJOUyAo cmVzKSA9PSAyKTsKKyAgICBBU1NFUlRfVFJVRSAoVkVDVE9SX0NTVF9ORUxUU19QRVJfUEFUVEVS TiAocmVzKSA9PSAzKTsKKworICAgIHVuc2lnbmVkIHJlc19uZWx0cyA9IHZlY3Rvcl9jc3RfZW5j b2RlZF9uZWx0cyAocmVzKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcmVzX25lbHRz OyBpKyspCisgICAgICBBU1NFUlRfVFJVRSAob3BlcmFuZF9lcXVhbF9wIChWRUNUT1JfQ1NUX0VM VCAocmVzLCBpKSwKKwkJCQkgICAgVkVDVE9SX0NTVF9FTFQgKGFyZzAsIGkpLCAwKSk7CisgIH0K KworICAvKiBDYXNlIDI6IEZvciBtYXNrOiB7NCwgNSwgNiwgLi4ufSwgbnBhdHRlcm5zID09IDEs IG5lbHRzX3Blcl9wYXR0ZXJuID09IDMsCisgICAgIHNob3VsZCByZXR1cm4gTlVMTCBiZWNhdXNl IGZvciBsZW4gPSA0ICsgNHgsCisgICAgIGlmIHggPT0gMCwgd2Ugc2VsZWN0IGZyb20gYXJnMQor ICAgICBpZiB4ID4gMCwgd2Ugc2VsZWN0IGZyb20gYXJnMAorICAgICBhbmQgdGh1cyBjYW5ub3Qg ZGV0ZXJtaW5lIHJlc3VsdCBhdCBjb21waWxlIHRpbWUuICAqLworICB7CisgICAgaW50IG1hc2tf ZWxlbXNbXSA9IHs0LCA1LCA2fTsKKyAgICB0cmVlIG1hc2sgPSBidWlsZF92ZWNfaW50X2NzdCAo MSwgMywgbWFza19lbGVtcyk7CisgICAgdHJlZSByZXMgPSBmb2xkX3Rlcm5hcnkgKFZFQ19QRVJN X0VYUFIsIFRSRUVfVFlQRSAoYXJnMCksIGFyZzAsIGFyZzEsIG1hc2spOworICAgIGdjY19hc3Nl cnQgKHJlcyA9PSBOVUxMX1RSRUUpOworICB9CisKKyAgLyogQ2FzZSAzOgorICAgICBtYXNrOiB7 MCwgMCwgMCwgMSwgMCwgMiwgLi4ufSAKKyAgICAgbnBhdHRlcm5zID09IDIsIG5lbHRzX3Blcl9w YXR0ZXJuID09IDMKKyAgICAgUGF0dGVybiB7MCwgLi4ufSBzaG91bGQgc2VsZWN0IGFyZzBbMF0s IGllLCAxLgorICAgICBQYXR0ZXJuIHswLCAxLCAyLCAuLi59IHNob3VsZCBzZWxlY3QgYXJnMDog ezEsIDExLCAyLCAuLi59LAorICAgICBzbyByZXMgPSB7MSwgMSwgMSwgMTEsIDEsIDIsIC4uLn0u ICAqLworICB7CisgICAgaW50IG1hc2tfZWxlbXNbXSA9IHswLCAwLCAwLCAxLCAwLCAyfTsKKyAg ICB0cmVlIG1hc2sgPSBidWlsZF92ZWNfaW50X2NzdCAoMiwgMywgbWFza19lbGVtcyk7CisgICAg dHJlZSByZXMgPSBmb2xkX3Rlcm5hcnkgKFZFQ19QRVJNX0VYUFIsIFRSRUVfVFlQRSAoYXJnMCks IGFyZzAsIGFyZzEsIG1hc2spOworICAgIEFTU0VSVF9UUlVFIChWRUNUT1JfQ1NUX05QQVRURVJO UyAocmVzKSA9PSA0KTsKKyAgICBBU1NFUlRfVFJVRSAoVkVDVE9SX0NTVF9ORUxUU19QRVJfUEFU VEVSTiAocmVzKSA9PSAzKTsKKworICAgIC8qIENoZWNrIGVuY29kaW5nOiB7MSwgMSwgMSwgMTEs IDEsIDIsIDEsIDEyLCAxLCAzLCAxLCAxMywgLi4ufSAgKi8KKyAgICBpbnQgcmVzX2VuY29kZWRf ZWxlbXNbXSA9IHsxLCAxLCAxLCAxMSwgMSwgMiwgMSwgMTIsIDEsIDMsIDEsIDEzfTsKKyAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdmVjdG9yX2NzdF9lbmNvZGVkX25lbHRzIChyZXMpOyBp KyspCisgICAgICBBU1NFUlRfVFJVRSAod2k6OnRvX3dpZGUoVkVDVE9SX0NTVF9FTFQgKHJlcywg aSkpID09IHJlc19lbmNvZGVkX2VsZW1zW2ldKTsKKyAgfQorCisgIC8qIENhc2UgNDoKKyAgICAg bWFzazogezAsIDQgKyA0eCwgMCwgNSArIDR4LCAwLCA2ICsgNHgsIC4uLn0KKyAgICAgbnBhdHRl cm5zID09IDIsIG5lbHRzX3Blcl9wYXR0ZXJuID09IDMKKyAgICAgUGF0dGVybiB7MCwgLi4ufSBz aG91bGQgc2VsZWN0IGFyZzBbMV0KKyAgICAgUGF0dGVybiB7NCArIDR4LCA1ICsgNHgsIDYgKyA0 eCwgLi4ufSBzaG91bGQgc2VsZWN0IGZyb20gYXJnMSwgc2luY2U6CisgICAgIGExID0gNSArIDR4 CisgICAgIGFlID0gKDUgKyA0eCkgKyAoKDQgKyA0eCkgLyAyIC0gMikgKiAxCisgICAgICAgID0g NSArIDZ4CisgICAgIFNpbmNlIGExLzQrNHggPT0gYWUvNCs0eCA9PSAxLCB3ZSBzZWxlY3QgYXJn MVswXSwgYXJnMVsxXSwgYXJnMVsyXSwgLi4uCisgICAgIHJlczogezEsIDIxLCAxLCAzMSwgMSwg MjIsIC4uLiB9CisgICAgIEZJWE1FOiBIb3cgdG8gYnVpbGQgdmVjdG9yIHdpdGggcG9seV9pbnQg ZWxlbXMgPyAgKi8KKworICAvKiBDYXNlIDU6IFMgPCAwLiAgKi8KK30KKwogLyogUnVuIGFsbCBv ZiB0aGUgc2VsZnRlc3RzIHdpdGhpbiB0aGlzIGZpbGUuICAqLwogCiB2b2lkCkBAIC0xNjkxOCw2 ICsxNzEyMyw3IEBAIGZvbGRfY29uc3RfY2NfdGVzdHMgKCkKICAgdGVzdF9hcml0aG1ldGljX2Zv bGRpbmcgKCk7CiAgIHRlc3RfdmVjdG9yX2ZvbGRpbmcgKCk7CiAgIHRlc3RfdmVjX2R1cGxpY2F0 ZV9mb2xkaW5nICgpOworICB0ZXN0X3ZlY19wZXJtX3ZsYV9mb2xkaW5nICgpOwogfQogCiB9IC8v IG5hbWVzcGFjZSBzZWxmdGVzdAo= --0000000000009996e805edf7634d--