From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lj1-x231.google.com (mail-lj1-x231.google.com [IPv6:2a00:1450:4864:20::231]) by sourceware.org (Postfix) with ESMTPS id 290F1393742C for ; Fri, 13 Mar 2020 11:57:34 +0000 (GMT) Received: by mail-lj1-x231.google.com with SMTP id w1so10213528ljh.5 for ; Fri, 13 Mar 2020 04:57:34 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=26KDo0E1ld3Tl2m/fWpluB4tSDCcAfzQwNHgjWL162Y=; b=ORRSmT/SM0coQFp7SKRNOtS7duuKa26sja73wtfe3CFlw44HyqN17sLcuqPqZp3XsT m6G9BJ6jcLBg8MV3kbihHDGJ2EJwkQKpPNyA+Z0ZbRVzlRgtrtJgUn+3u18Y6hyvQuvG iurTf1zxSkVltpxb4WYuUhJb8fWZb6wMQoGMubpesYC8ImiRYC+PR5HKxETu1uJxK8hT 7DUobZAmKxMO+Yc++3EWNTOqkWqiak0WWal4qYLPebotpvgD1ML8EtJe54A0/M6x78yA 8OwIH9VdTTWyxoAAf/nfcLGIhoQNbHpPFlvINZw8VObOq43VnX0KfBpYjsWqQjcSMspv WOaw== X-Gm-Message-State: ANhLgQ2YO+ELPzSTroiEFPa/wNAn9cjI/mEcpI3DSfjU2yTGtN+3hxQv odmlBHRLVb+vx8nNbX3rLVFww7N0IdSdwMOnsos= X-Google-Smtp-Source: ADFU+vuRa/diSUOFM7ZnQq+G1aqWHGngsg2WbGP/iwGe+RZL8NLMmvDKOYg47cE9yMO20citiG3PDLGpS6qXR40hobE= X-Received: by 2002:a2e:920c:: with SMTP id k12mr1619882ljg.209.1584100652768; Fri, 13 Mar 2020 04:57:32 -0700 (PDT) MIME-Version: 1.0 References: <3d1278f2-ecd6-09c1-2179-19b7a1ecd5d4@linux.ibm.com> In-Reply-To: From: Richard Biener Date: Fri, 13 Mar 2020 12:57:20 +0100 Message-ID: Subject: Re: How to extend SLP to support this case To: Tamar Christina Cc: "Kewen.Lin" , GCC Development , Segher Boessenkool Content-Type: multipart/mixed; boundary="000000000000b27b9005a0bb2c1f" X-Spam-Status: No, score=-7.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_2, HTML_MESSAGE, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-Content-Filtered-By: Mailman/MimeDel 2.1.29 X-BeenThere: gcc@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 13 Mar 2020 11:57:36 -0000 --000000000000b27b9005a0bb2c1f Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Tue, Mar 10, 2020 at 12:32 PM Tamar Christina wrote: > > > -----Original Message----- > > From: Gcc On Behalf Of Richard Biener > > Sent: Tuesday, March 10, 2020 11:12 AM > > To: Kewen.Lin > > Cc: GCC Development ; Segher Boessenkool > > > > Subject: Re: How to extend SLP to support this case > > > > On Tue, Mar 10, 2020 at 7:52 AM Kewen.Lin wrote: > > > > > > Hi all, > > > > > > I'm investigating whether GCC can vectorize the below case on ppc64le= . > > > > > > extern void test(unsigned int t[4][4]); > > > > > > void foo(unsigned char *p1, int i1, unsigned char *p2, int i2) > > > { > > > unsigned int tmp[4][4]; > > > unsigned int a0, a1, a2, a3; > > > > > > for (int i =3D 0; i < 4; i++, p1 +=3D i1, p2 +=3D i2) { > > > a0 =3D (p1[0] - p2[0]) + ((p1[4] - p2[4]) << 16); > > > a1 =3D (p1[1] - p2[1]) + ((p1[5] - p2[5]) << 16); > > > a2 =3D (p1[2] - p2[2]) + ((p1[6] - p2[6]) << 16); > > > a3 =3D (p1[3] - p2[3]) + ((p1[7] - p2[7]) << 16); > > > > > > int t0 =3D a0 + a1; > > > int t1 =3D a0 - a1; > > > int t2 =3D a2 + a3; > > > int t3 =3D a2 - a3; > > > > > > tmp[i][0] =3D t0 + t2; > > > tmp[i][2] =3D t0 - t2; > > > tmp[i][1] =3D t1 + t3; > > > tmp[i][3] =3D t1 - t3; > > > } > > > test(tmp); > > > } > > > > > > With unlimited costs, I saw loop aware SLP can vectorize it but with > > > very inefficient codes. It builds the SLP instance from store group > > > {tmp[i][0] tmp[i][1] tmp[i][2] tmp[i][3]}, builds nodes {a0, a0, a0, > > > a0}, {a1, a1, a1, a1}, {a2, a2, a2, a2}, {a3, a3, a3, a3} after > > > parsing operands for tmp* and t*. It means it's unable to make the > > > isomorphic group for a0, a1, a2, a3, although they appears isomorphic > > > to merge. Even if it can recognize over_widening pattern and do some > > > parallel for two a0 from two iterations, but it's still inefficient > (high cost). > > > > > > In this context, it looks better to build first by > > > leveraging isomorphic computation trees constructing them, eg: > > > w1_0123 =3D load_word(p1) > > > V1_0123 =3D construct_vec(w1_0123) > > > w1_4567 =3D load_word(p1 + 4) > > > V1_4567 =3D construct_vec(w1_4567) > > > w2_0123 =3D load_word(p2) > > > V2_0123 =3D construct_vec(w2_0123) > > > w2_4567 =3D load_word(p2 + 4) > > > V2_4567 =3D construct_vec(w2_4567) > > > V_a0123 =3D (V1_0123 - V2_0123) + (V1_4567 - V2_4567)<<16 > > > > > > But how to teach it to be aware of this? Currently the processing > > > starts from bottom to up (from stores), can we do some analysis on th= e > > > SLP instance, detect some pattern and update the whole instance? > > > > In theory yes (Tamar had something like that for AARCH64 complex > rotations > > IIRC). And yes, the issue boils down to how we handle SLP discovery. > I'd like > > to improve SLP discovery but it's on my list only after I managed to ge= t > rid of > > the non-SLP code paths. I have played with some ideas (even produced > > hackish patches) to find "seeds" to form SLP groups from using > multi-level > > hashing of stmts. > > I still have this but missed the stage-1 deadline after doing the > rewriting to C++ =F0=9F=98=8A > > We've also been looking at this and the approach I'm investigating now is > trying to get > the SLP codepath to handle this after it's been fully unrolled. I'm > looking into whether > the build-slp can be improved to work for the group size =3D=3D 16 case t= hat > it tries but fails > on. > > My intention is to see if doing so would make it simpler to recognize thi= s > as just 4 linear > loads and two permutes. I think the loop aware SLP will have a much harde= r > time with this > seeing the load permutations it thinks it needs because of the permutes > caused by the +/- > pattern. > > One Idea I had before was from your comment on the complex number patch, > which is to try > and move up TWO_OPERATORS and undo the permute always when doing +/-. Thi= s > would simplify > the load permute handling and if a target doesn't have an instruction to > support this it would just > fall back to doing an explicit permute after the loads. But I wasn't sur= e > this approach would get me the > results I wanted. > > In the end you don't want a loop here at all. And in order to do the abov= e > with TWO_OPERATORS I would > have to let the SLP pattern matcher be able to reduce the group size and > increase the no# iterations during > the matching otherwise the matching itself becomes quite difficult in > certain cases. > Just to show where I'm heading I'm attaching current work-in-progress that introduces an explicit SLP merge node and implementing SLP_TREE_TWO_OPERATORS that way= : v1 + v2 v1 - v2 \ / merge the SLP merge operation is concatenating operands in order and then applies a lane permutation mask (basically a select from the input lanes). The actual patch depends on earlier cleanups and more preparatory changes are in order to make it "nice". With such SLP merge operation in place it should be straight-forward to represent smaller and larger vectorizations in a single graph (generating optimal code is of course an entirely different problem). I'm working on some of the preparatory refactorings right now after which I'll post the series up to SLP_TREE_TWO_OPERATORS. The next step is then to represent load permutations that way. Richard. Tamar > > > My plan is to rewrite SLP discovery completely, starting from a SLP > graph that > > 1:1 reflects the SSA use-def graph (no groups formed yet) and then form > > groups from seeds and insert "connection" nodes (merging two subgraphs > > with less lanes into one with more lanes, splitting lanes, permuting > lanes, > > etc.). > > > > Currently I'm working on doing exactly this but only for SLP loads > (because > > that's where it's most difficult...). > > > > > Besides, I also tried whether the standalone SLP pass can handle it, > > > it failed to. It stops at a* due to incompatible vector types. > > > > > > The optimal vectorized SLP codes can be: > > > // p1 byte 0 to byte 7 > > > d1_0_7 =3D load_dword(p1) > > > // p1+i1 b0 to b7, rename it as 8 to 15 > > > d1_8_15 =3D load_dword(p1 + i1) > > > d1_16_23 =3D load_dword(p1 + 2*i1) > > > d1_24_31 =3D load_dword(p1 + 3*i1) > > > > > > V_d1_0_15 =3D construct_vec(d1_0_7,d1_8_15) // vector char > > > V_d1_16_31 =3D construct_vec(d1_16_23,d1_24_31) > > > V_d1_0_3_all =3D vperm(V_d1_0_15, V_d1_0_15, > > > {0 8 16 24 1 9 17 25 2 10 18 26 3 11 19 27}) > > > V_d1_4_7_all =3D vperm(V_d1_0_15, V_d1_0_15, > > > {4 12 20 28 5 13 21 29 6 14 22 30 7 15 23 31}) > > > > > > // Do the similar for p2 with i2, get V_d2_0_3_all, V_d2_4_7_all > > > > > > // Do the subtraction together (all 4x4 bytes) > > > V_sub1 =3D V_d1_0_3_all - V_d2_0_3_all > > > V_sub2 =3D V_d1_4_7_all - V_d2_4_7_all > > > > > > // Do some unpack and get the promoted vector int > > > V_a0_tmp =3D vec_promote(V_sub2, {0 1 2 3}) // vector int {b4 b12 b= 20 > b28} > > > V_a0_1 =3D V_a0_tmp << 16 > > > V_a0_0 =3D vec_promote(V_sub1, {0 1 2 3}). // vector int {b0 b8 b1= 6 > b24} > > > // vector int {a0_iter0, a0_iter1, a0_iter2, a0_iter3} > > > V_a0 =3D V_a0_0 + V_a0_1 > > > > > > // Get the similar for V_a1, V_a2, V_a3 > > > > > > // Compute t0/t1/t2/t3 > > > // vector int {t0_iter0, t0_iter1, t0_iter2, t0_iter3} > > > V_t0 =3D V_a0 + V_a1 > > > V_t1 =3D V_a0 - V_a1 > > > V_t2 =3D V_a2 + V_a3 > > > V_t3 =3D V_a2 - V_a3 > > > > > > // Compute tmps > > > // vector int {tmp[0][0], tmp[1][0], tmp[2][0], tmp[3][0]} > > > V_tmp0 =3D V_t0 + V_t2 > > > V_tmp2 =3D V_t0 - V_t2 > > > V_tmp1 =3D V_t1 + V_t3 > > > V_tmp3 =3D V_t1 - V_t3 > > > > > > // Final construct the {tmp[0][0], tmp[0][1], tmp[0][2], tmp[0][3]} > ... > > > // with six further permutation on V_tmp0/V_tmp1/V_tmp2/V_tmp3 > > > > > > From the above, the key thing is to group tmp[i][j] i=3D/0,1,2,3/ > together, eg: > > > tmp[i][0] i=3D/0,1,2,3/ (one group) > > > tmp[i][1] i=3D/0,1,2,3/ (one group) > > > tmp[i][2] i=3D/0,1,2,3/ (one group) > > > tmp[i][3] i=3D/0,1,2,3/ (one group) > > > > > > which tmp[i][j] group have the same isomorphic computations. But > > > currently SLP is unable to divide group like this way. (call it as > > > A-way for now) > > > > > > It's understandable since it has better adjacent store groups like, > > > tmp[0][i] i=3D/0,1,2,3/ (one group) > > > tmp[1][i] i=3D/0,1,2,3/ (one group) > > > tmp[2][i] i=3D/0,1,2,3/ (one group) > > > tmp[3][i] i=3D/0,1,2,3/ (one group) > > > > > > A-way requires some additional vector permutations. However, I > > > thought if the existing scheme can't get any SLP chances, it looks > > > reasonable to extend it to consider this A-way grouping. Does it mak= e > > sense? > > > > > > Another question is that even if we can go with A-way grouping, it ca= n > > > only handle packing one byte (four iteration -> 4), what place is > > > reasonable to extend it to pack more? How about scaning all leaf > > > nodes and consider/transform them together? too hacky? > > > > Well, not sure - in the end it will all be heuristics since otherwise t= he > > exploration space is too big. But surely concentrating on load/store > groups is > > good. > > > > The SLP discovery code is already quite complicated btw., I'd hate to a= dd > > "unstructured" hacks ontop of it right now without future design goals = in > > mind. > > > > Richard. > > > > > Any comments are highly appreciated. Thanks in advance! > > > > > > > > > BR, > > > Kewen > > > > --000000000000b27b9005a0bb2c1f Content-Type: application/octet-stream; name=p Content-Disposition: attachment; filename=p Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_k7q4m2q20 Y29tbWl0IDU5NTNjYWU1NmFhN2VjNGNiZjFmOGZlYmY4NDhjNzI3M2ZmZjM3OTYKQXV0aG9yOiBS aWNoYXJkIEJpZW5lciA8cmd1ZW50aGVyQHN1c2UuZGU+CkRhdGU6ICAgRnJpIE1hciAxMyAxMjoz NzowMyAyMDIwICswMTAwCgogICAgcmVtb3ZlIFNMUF9UUkVFX1RXT19PUEVSQVRPUlMKICAgIAog ICAgVGhpcyByZW1vdmVzIHRoZSBTTFBfVFJFRV9UV09fT1BFUkFUT1JTIGhhY2sgaW4gZmF2b3Ig b2YgaGF2aW5nCiAgICBleHBsaWNpdCBTTFAgbm9kZXMgZm9yIGJvdGggY29tcHV0YXRpb25zIGFu ZCB0aGUgYmxlbmQgb3BlcmF0aW9uCiAgICB0aGVyZWJ5IGludHJvZHVjaW5nIGEgZ2VuZXJpYyBt ZXJnZSArIHNlbGVjdCArIHBlcm11dGUgU0xQIG5vZGUKICAgICh3aXRoIGltcGxlbWVudGF0aW9u IGxpbWl0cykuCiAgICAKICAgIFRPRE8gcmVmYWN0b3Jpbmc6CiAgICAgLSBtYWtlIFNMUCBub2Rl IHNoYXJpbmcgd29yayBvbiAtPm9wc1tdIHJhdGhlciB0aGFuIC0+c3RtdHNbXSwKICAgICAgIG1h a2UgU0xQX1RSRUVfVFdPX09QRVJBVE9SUyBsb3dlcmluZyBub2RlcyBwcm9wZXJseSBzaGFyZWQg dGhlbgogICAgIC0gbWFrZSB1c2Ugb2YgU0xQX1RSRUVfQ09ERSBpbnN0ZWFkIG9mIHJlbHlpbmcg b24gLT5zdG10c1swXQogICAgIC0gYWRkIHN0bXRfdmVjX2luZm9fdHlwZSB0byB0aGUgU0xQIG5v ZGUKICAgICAtIHBvcHVsYXRlIFNMUF9UUkVFX1RZUEUgd2hlcmUgd2Ugb3RoZXJ3aXNlIGNvbXB1 dGUgdGhlIHZlY3R5cGUKICAgICAtIHBhc3MgZG93biB2ZWNfaW5mbyB0byBtb3JlIGZ1bmN0aW9u cywgYXZvaWRpbmcKICAgICAgIFNUTVRfVklORk9fe0xPT1AsQkJ9X1ZJTkZPIChvciBtYWtlIG1v cmUgZnVuY3Rpb25zIG1lbWJlciBvZiB2aW5mbykKICAgIAogICAgMjAyMC0wMy0xMyAgUmljaGFy ZCBCaWVuZXIgIDxyZ3VlbnRoZXJAc3VzZS5kZT4KICAgIAogICAgICAgICAgICAqIHRyZWUtdmVj dG9yaXplci5oIChfc2xwX3RyZWU6Ol9zbHBfdHJlZSk6IEFkZCBDVE9SLgogICAgICAgICAgICAo X3NscF90cmVlOjp+X3NscF90cmVlKTogQWRkIERUT1IuCiAgICAgICAgICAgIChfc2xwX3RyZWU6 OmNsYXNzaWZ5KTogTmV3IG1ldGhvZC4KICAgICAgICAgICAgKF9zbHBfdHJlZTo6bl9sYW5lcyk6 IExpa2V3aXNlLgogICAgICAgICAgICAoX3NscF90cmVlOjpsYW5lX3Blcm11dGF0aW9uKTogTmV3 IG1lbWJlci4KICAgICAgICAgICAgKF9zbHBfdHJlZTo6dmVjdHlwZSk6IExpa2V3aXNlLgogICAg ICAgICAgICAoX3NscF90cmVlOjpjb2RlKTogTGlrZXdpc2UuCiAgICAgICAgICAgIChfc2xwX3Ry ZWU6OnR3b19vcGVyYXRvcnMpOiBSZW1vdmUuCiAgICAgICAgICAgIChTTFBfVFJFRV9UV09fT1BF UkFUT1JTKTogUmVtb3ZlLgogICAgICAgICAgICAoU0xQX1RSRUVfTEFORV9QRVJNVVRBVElPTik6 IE5ldy4KICAgICAgICAgICAgKFNMUF9UUkVFX0NPREUpOiBMaWtld2lzZS4KICAgICAgICAgICAg KFNMUF9UUkVFX1ZFQ1RZUEUpOiBMaWtld2lzZS4KICAgICAgICAgICAgKiB0cmVlLXZlY3Qtc2xw LmMgKF9zbHBfdHJlZTo6X3NscF90cmVlKTogSW1wbGVtZW50LgogICAgICAgICAgICAoX3NscF90 cmVlOjp+X3NscF90cmVlKTogTGlrZXdpc2UuCiAgICAgICAgICAgICh2ZWN0X2ZyZWVfc2xwX3Ry ZWUpOiBVc2UgZGVsZXRlIGluc3RlYWQgb2YgZnJlZS4KICAgICAgICAgICAgKHZlY3RfY3JlYXRl X25ld19zbHBfbm9kZSk6IFVzZSBuZXcgaW5zdGVhZCBvZiBYTkVXLgogICAgICAgICAgICAoX3Ns cF90cmVlOjpjbGFzc2lmeSk6IEltcGxlbWVudC4KICAgICAgICAgICAgKF9zbHBfdHJlZTo6bl9s YW5lcyk6IExpa2V3aXNlLgogICAgICAgICAgICAodmVjdF9idWlsZF9zbHBfdHJlZV8yKTogV2hl biB3ZSBoYXZlIHR3byBkaWZmZXJlbnQgb3BlcmF0b3JzCiAgICAgICAgICAgIGJ1aWxkIHR3byBj b21wdXRhdGlvbiBTTFAgbm9kZXMgYW5kIGEgYmxlbmQuCiAgICAgICAgICAgICguLi4pOiBBZGp1 c3RtZW50cyBmb3IgTlVMTCAtPnN0bXRzW10gaGFjay4KICAgICAgICAgICAgKHZlY3RfZmluZF9s YXN0X3NjYWxhcl9zdG10X2luX3NscCk6IENoZWNrIGNoaWxkcmVuIGZvcgogICAgICAgICAgICBw bGFjZW1lbnQuCiAgICAgICAgICAgICh2ZWN0b3JpemFibGVfc2xwX3Blcm11dGF0aW9uKTogTmV3 IGZ1bmN0aW9uLgoKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Qtc2xwLmMgYi9nY2MvdHJlZS12 ZWN0LXNscC5jCmluZGV4IDMyZTZhMGJlYWVkLi4xMmVhZmYwYTNjYSAxMDA2NDQKLS0tIGEvZ2Nj L3RyZWUtdmVjdC1zbHAuYworKysgYi9nY2MvdHJlZS12ZWN0LXNscC5jCkBAIC00Niw2ICs0Niwz OSBAQCBhbG9uZyB3aXRoIEdDQzsgc2VlIHRoZSBmaWxlIENPUFlJTkczLiAgSWYgbm90IHNlZQog I2luY2x1ZGUgImludGVybmFsLWZuLmgiCiAKIAorc3RhdGljIGJvb2wgdmVjdG9yaXphYmxlX3Ns cF9wZXJtdXRhdGlvbiAodmVjX2luZm8gKiwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKiwKKwkJCQkJ ICBzbHBfdHJlZSwgc3RtdF92ZWN0b3JfZm9yX2Nvc3QgKik7CisKKy8qIEluaXRpYWxpemUgYSBT TFAgbm9kZS4gICovCisKK19zbHBfdHJlZTo6X3NscF90cmVlICgpCit7CisgIFNMUF9UUkVFX1ND QUxBUl9TVE1UUyAodGhpcykgPSB2TlVMTDsKKyAgU0xQX1RSRUVfU0NBTEFSX09QUyAodGhpcykg PSB2TlVMTDsKKyAgU0xQX1RSRUVfVkVDX1NUTVRTICh0aGlzKS5jcmVhdGUgKDApOworICBTTFBf VFJFRV9OVU1CRVJfT0ZfVkVDX1NUTVRTICh0aGlzKSA9IDA7CisgIFNMUF9UUkVFX0NISUxEUkVO ICh0aGlzKSA9IHZOVUxMOworICBTTFBfVFJFRV9MT0FEX1BFUk1VVEFUSU9OICh0aGlzKSA9IHZO VUxMOworICBTTFBfVFJFRV9MQU5FX1BFUk1VVEFUSU9OICh0aGlzKSA9IHZOVUxMOworICBTTFBf VFJFRV9ERUZfVFlQRSAodGhpcykgPSB2ZWN0X2ludGVybmFsX2RlZjsKKyAgU0xQX1RSRUVfQ09E RSAodGhpcykgPSBFUlJPUl9NQVJLOworICBTTFBfVFJFRV9WRUNUWVBFICh0aGlzKSA9IE5VTExf VFJFRTsKKyAgdGhpcy0+cmVmY250ID0gMTsKKyAgdGhpcy0+bWF4X251bml0cyA9IDE7Cit9CisK Ky8qIFRlYXIgZG93biBhIFNMUCBub2RlLiAgKi8KKworX3NscF90cmVlOjp+X3NscF90cmVlICgp Cit7CisgIFNMUF9UUkVFX0NISUxEUkVOICh0aGlzKS5yZWxlYXNlICgpOworICBTTFBfVFJFRV9T Q0FMQVJfU1RNVFMgKHRoaXMpLnJlbGVhc2UgKCk7CisgIFNMUF9UUkVFX1NDQUxBUl9PUFMgKHRo aXMpLnJlbGVhc2UgKCk7CisgIFNMUF9UUkVFX1ZFQ19TVE1UUyAodGhpcykucmVsZWFzZSAoKTsK KyAgU0xQX1RSRUVfTE9BRF9QRVJNVVRBVElPTiAodGhpcykucmVsZWFzZSAoKTsKKyAgU0xQX1RS RUVfTEFORV9QRVJNVVRBVElPTiAodGhpcykucmVsZWFzZSAoKTsKK30KKwogLyogUmVjdXJzaXZl bHkgZnJlZSB0aGUgbWVtb3J5IGFsbG9jYXRlZCBmb3IgdGhlIFNMUCB0cmVlIHJvb3RlZCBhdCBO T0RFLgogICAgRklOQUxfUCBpcyB0cnVlIGlmIHdlIGhhdmUgdmVjdG9yaXplZCB0aGUgaW5zdGFu Y2Ugb3IgaWYgd2UgaGF2ZQogICAgbWFkZSBhIGZpbmFsIGRlY2lzaW9uIG5vdCB0byB2ZWN0b3Jp emUgdGhlIHN0YXRlbWVudHMgaW4gYW55IHdheS4gICovCkBAIC03NiwxMyArMTA5LDcgQEAgdmVj dF9mcmVlX3NscF90cmVlIChzbHBfdHJlZSBub2RlLCBib29sIGZpbmFsX3ApCiAJfQogICAgIH0K IAotICBTTFBfVFJFRV9DSElMRFJFTiAobm9kZSkucmVsZWFzZSAoKTsKLSAgU0xQX1RSRUVfU0NB TEFSX1NUTVRTIChub2RlKS5yZWxlYXNlICgpOwotICBTTFBfVFJFRV9TQ0FMQVJfT1BTIChub2Rl KS5yZWxlYXNlICgpOwotICBTTFBfVFJFRV9WRUNfU1RNVFMgKG5vZGUpLnJlbGVhc2UgKCk7Ci0g IFNMUF9UUkVFX0xPQURfUEVSTVVUQVRJT04gKG5vZGUpLnJlbGVhc2UgKCk7Ci0KLSAgZnJlZSAo bm9kZSk7CisgIGRlbGV0ZSBub2RlOwogfQogCiAvKiBGcmVlIHRoZSBtZW1vcnkgYWxsb2NhdGVk IGZvciB0aGUgU0xQIGluc3RhbmNlLiAgRklOQUxfUCBpcyB0cnVlIGlmIHdlCkBAIC0xMjAsMTcg KzE0NywxMCBAQCB2ZWN0X2NyZWF0ZV9uZXdfc2xwX25vZGUgKHZlYzxzdG10X3ZlY19pbmZvPiBz Y2FsYXJfc3RtdHMpCiAgIGVsc2UKICAgICByZXR1cm4gTlVMTDsKIAotICBub2RlID0gWE5FVyAo c3RydWN0IF9zbHBfdHJlZSk7CisgIG5vZGUgPSBuZXcgX3NscF90cmVlOwogICBTTFBfVFJFRV9T Q0FMQVJfU1RNVFMgKG5vZGUpID0gc2NhbGFyX3N0bXRzOwotICBTTFBfVFJFRV9TQ0FMQVJfT1BT IChub2RlKSA9IHZOVUxMOwotICBTTFBfVFJFRV9WRUNfU1RNVFMgKG5vZGUpLmNyZWF0ZSAoMCk7 Ci0gIFNMUF9UUkVFX05VTUJFUl9PRl9WRUNfU1RNVFMgKG5vZGUpID0gMDsKICAgU0xQX1RSRUVf Q0hJTERSRU4gKG5vZGUpLmNyZWF0ZSAobm9wcyk7Ci0gIFNMUF9UUkVFX0xPQURfUEVSTVVUQVRJ T04gKG5vZGUpID0gdk5VTEw7Ci0gIFNMUF9UUkVFX1RXT19PUEVSQVRPUlMgKG5vZGUpID0gZmFs c2U7CiAgIFNMUF9UUkVFX0RFRl9UWVBFIChub2RlKSA9IHZlY3RfaW50ZXJuYWxfZGVmOwotICBu b2RlLT5yZWZjbnQgPSAxOwotICBub2RlLT5tYXhfbnVuaXRzID0gMTsKIAogICB1bnNpZ25lZCBp OwogICBGT1JfRUFDSF9WRUNfRUxUIChzY2FsYXJfc3RtdHMsIGksIHN0bXRfaW5mbykKQEAgLTE0 NiwyMSArMTY2LDQxIEBAIHZlY3RfY3JlYXRlX25ld19zbHBfbm9kZSAodmVjPHRyZWU+IG9wcykK IHsKICAgc2xwX3RyZWUgbm9kZTsKIAotICBub2RlID0gWE5FVyAoc3RydWN0IF9zbHBfdHJlZSk7 Ci0gIFNMUF9UUkVFX1NDQUxBUl9TVE1UUyAobm9kZSkgPSB2TlVMTDsKKyAgbm9kZSA9IG5ldyBf c2xwX3RyZWU7CiAgIFNMUF9UUkVFX1NDQUxBUl9PUFMgKG5vZGUpID0gb3BzOwotICBTTFBfVFJF RV9WRUNfU1RNVFMgKG5vZGUpLmNyZWF0ZSAoMCk7Ci0gIFNMUF9UUkVFX05VTUJFUl9PRl9WRUNf U1RNVFMgKG5vZGUpID0gMDsKLSAgU0xQX1RSRUVfQ0hJTERSRU4gKG5vZGUpID0gdk5VTEw7Ci0g IFNMUF9UUkVFX0xPQURfUEVSTVVUQVRJT04gKG5vZGUpID0gdk5VTEw7Ci0gIFNMUF9UUkVFX1RX T19PUEVSQVRPUlMgKG5vZGUpID0gZmFsc2U7CiAgIFNMUF9UUkVFX0RFRl9UWVBFIChub2RlKSA9 IHZlY3RfZXh0ZXJuYWxfZGVmOwotICBub2RlLT5yZWZjbnQgPSAxOwotICBub2RlLT5tYXhfbnVu aXRzID0gMTsKIAogICByZXR1cm4gbm9kZTsKIH0KIAorLyogV2hpbGUgaW4gdHJhbnNpZW50IHJl cHJlc2VudGF0aW9uIHN0YXRlIHByb3ZpZGUgYSBoZWxwZXIgdG8KKyAgIGNsYXNzaWZ5IFNMUCBu b2RlIGtpbmRzLiAgKi8KKworX3NscF90cmVlOjpraW5kCitfc2xwX3RyZWU6OmNsYXNzaWZ5ICgp Cit7CisgIGlmIChsYW5lX3Blcm11dGF0aW9uLmV4aXN0cyAoKSkKKyAgICAvKiBjb25jYXQgY2hp bGRyZW4gYW5kIGFwcGx5IHBlcm11dGUgbWFzay4gICovCisgICAgcmV0dXJuIFNMUF9DUEVSTTsK KworICByZXR1cm4gU0xQX09USEVSOworfQorCisvKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgbGFu ZXMgaW4gdGhlIG5vZGUuICAqLworCit1bnNpZ25lZAorX3NscF90cmVlOjpuX2xhbmVzICgpCit7 CisgIGlmIChzdG10cy5leGlzdHMgKCkpCisgICAgcmV0dXJuIHN0bXRzLmxlbmd0aCAoKTsKKyAg aWYgKG9wcy5leGlzdHMgKCkpCisgICAgcmV0dXJuIG9wcy5sZW5ndGggKCk7CisgIGlmIChsYW5l X3Blcm11dGF0aW9uLmV4aXN0cyAoKSkKKyAgICByZXR1cm4gbGFuZV9wZXJtdXRhdGlvbi5sZW5n dGggKCk7CisgIC8qID8/PyAgSWYgd2UgaW50cm9kdWNlICJwdXJlIiBTTFAgbm9uLXBlcm11dGUg b3BzIHdlIG1pZ2h0IHdhbnQgdG8KKyAgICAgaGF2ZSBhbiBleHBsaWNpdCBudW1iZXIgb2YgbGFu ZXMgbWVtYmVyLiAgKi8KKyAgX19idWlsdGluX3VucmVhY2hhYmxlICgpOworfQogCiAvKiBUaGlz IHN0cnVjdHVyZSBpcyB1c2VkIGluIGNyZWF0aW9uIG9mIGFuIFNMUCB0cmVlLiAgRWFjaCBpbnN0 YW5jZQogICAgY29ycmVzcG9uZHMgdG8gdGhlIHNhbWUgb3BlcmFuZCBpbiBhIGdyb3VwIG9mIHNj YWxhciBzdG10cyBpbiBhbiBTTFAKQEAgLTE2MjksOCArMTY2OSw1NiBAQCBmYWlsOgogICAqdHJl ZV9zaXplICs9IHRoaXNfdHJlZV9zaXplICsgMTsKICAgKm1heF9udW5pdHMgPSB0aGlzX21heF9u dW5pdHM7CiAKKyAgaWYgKHR3b19vcGVyYXRvcnMpCisgICAgeworICAgICAgLyogPz8/ICBXZSdk IGxpa2VseSB3YW50IHRvIGVpdGhlciBjYWNoZSBpbiBic3RfbWFwIHN0aCBsaWtlCisJIHsgYSti LCBOVUxMLCBhK2IsIE5VTEwgfSBhbmQgeyBOVUxMLCBhLWIsIE5VTEwsIGEtYiB9IG9yCisJIHRo ZSB0cnVlIHsgYStiLCBhK2IsIGErYiwgYStiIH0gLi4uIGJ1dCB0aGVyZSB3ZSBkb24ndCBoYXZl CisJIGV4cGxpY2l0IHN0bXRzIHRvIHB1dCBpbiBzbyB0aGUga2V5aW5nIG9uICdzdG10cycgZG9l c24ndAorCSB3b3JrIChidXQgd2UgaGF2ZSB0aGUgc2FtZSBpc3N1ZSB3aXRoIG5vZGVzIHRoYXQg dXNlICdvcHMnKS4gICovCisgICAgICBzbHBfdHJlZSBvbmUgPSBuZXcgX3NscF90cmVlOworICAg ICAgc2xwX3RyZWUgdHdvID0gbmV3IF9zbHBfdHJlZTsKKyAgICAgIFNMUF9UUkVFX0NISUxEUkVO IChvbmUpLnNhZmVfc3BsaWNlIChjaGlsZHJlbik7CisgICAgICBTTFBfVFJFRV9DSElMRFJFTiAo dHdvKS5zYWZlX3NwbGljZSAoY2hpbGRyZW4pOworICAgICAgc2xwX3RyZWUgY2hpbGQ7CisgICAg ICBGT1JfRUFDSF9WRUNfRUxUIChTTFBfVFJFRV9DSElMRFJFTiAodHdvKSwgaSwgY2hpbGQpCisJ Y2hpbGQtPnJlZmNudCsrOworCisgICAgICBub2RlID0gbmV3IF9zbHBfdHJlZTsKKyAgICAgIC8q IEhlcmUgd2UgcmVjb3JkIHRoZSBvcmlnaW5hbCBzdG10cyBzaW5jZSB0aGlzCisJIG5vZGUgcmVw cmVzZW50cyB0aGUgZmluYWwgbGFuZSBjb25maWd1cmF0aW9uLiAgKi8KKyAgICAgIFNMUF9UUkVF X1NDQUxBUl9TVE1UUyAobm9kZSkgPSBzdG10czsKKyAgICAgIFNMUF9UUkVFX0RFRl9UWVBFIChu b2RlKSA9IHZlY3RfaW50ZXJuYWxfZGVmOworICAgICAgU0xQX1RSRUVfQ0hJTERSRU4gKG5vZGUp LnNhZmVfcHVzaCAob25lKTsKKyAgICAgIFNMUF9UUkVFX0NISUxEUkVOIChub2RlKS5zYWZlX3B1 c2ggKHR3byk7CisgICAgICBnYXNzaWduICpzdG10ID0gYXNfYSA8Z2Fzc2lnbiAqPiAoc3RtdHNb MF0tPnN0bXQpOworICAgICAgZW51bSB0cmVlX2NvZGUgY29kZTAgPSBnaW1wbGVfYXNzaWduX3Jo c19jb2RlIChzdG10KTsKKyAgICAgIGVudW0gdHJlZV9jb2RlIG9jb2RlID0gRVJST1JfTUFSSzsK KyAgICAgIHN0bXRfdmVjX2luZm8gb3N0bXRfaW5mbzsKKyAgICAgIHVuc2lnbmVkIGo7CisgICAg ICBGT1JfRUFDSF9WRUNfRUxUIChzdG10cywgaSwgb3N0bXRfaW5mbykKKwl7CisJICBnYXNzaWdu ICpvc3RtdCA9IGFzX2EgPGdhc3NpZ24gKj4gKG9zdG10X2luZm8tPnN0bXQpOworCSAgaWYgKGdp bXBsZV9hc3NpZ25fcmhzX2NvZGUgKG9zdG10KSAhPSBjb2RlMCkKKwkgICAgeworCSAgICAgIFNM UF9UUkVFX0xBTkVfUEVSTVVUQVRJT04gKG5vZGUpLnNhZmVfcHVzaCAoc3RkOjptYWtlX3BhaXIg KDEsIGkpKTs7CisJICAgICAgb2NvZGUgPSBnaW1wbGVfYXNzaWduX3Joc19jb2RlIChvc3RtdCk7 CisJICAgICAgaiA9IGk7CisJICAgIH0KKwkgIGVsc2UKKwkgICAgU0xQX1RSRUVfTEFORV9QRVJN VVRBVElPTiAobm9kZSkuc2FmZV9wdXNoIChzdGQ6Om1ha2VfcGFpciAoMCwgaSkpOworCX0KKyAg ICAgIFNMUF9UUkVFX0NPREUgKG9uZSkgPSBjb2RlMDsKKyAgICAgIFNMUF9UUkVFX0NPREUgKHR3 bykgPSBvY29kZTsKKyAgICAgIC8qIEZha2Ugc29tZSBzdG10cyBmb3Igbm93LiAgKi8KKyAgICAg IFNMUF9UUkVFX1NDQUxBUl9TVE1UUyAob25lKS5zYWZlX2dyb3dfY2xlYXJlZCAoc3RtdHMubGVu Z3RoICgpKTsKKyAgICAgIFNMUF9UUkVFX1NDQUxBUl9TVE1UUyAodHdvKS5zYWZlX2dyb3dfY2xl YXJlZCAoc3RtdHMubGVuZ3RoICgpKTsKKyAgICAgIFNMUF9UUkVFX1NDQUxBUl9TVE1UUyAob25l KVswXSA9IHN0bXRzWzBdOworICAgICAgU0xQX1RSRUVfU0NBTEFSX1NUTVRTICh0d28pWzBdID0g c3RtdHNbal07CisgICAgICByZXR1cm4gbm9kZTsKKyAgICB9CisKICAgbm9kZSA9IHZlY3RfY3Jl YXRlX25ld19zbHBfbm9kZSAoc3RtdHMpOwotICBTTFBfVFJFRV9UV09fT1BFUkFUT1JTIChub2Rl KSA9IHR3b19vcGVyYXRvcnM7CiAgIFNMUF9UUkVFX0NISUxEUkVOIChub2RlKS5zcGxpY2UgKGNo aWxkcmVuKTsKICAgcmV0dXJuIG5vZGU7CiB9CkBAIC0xNjYwLDcgKzE3NDgsMTAgQEAgdmVjdF9w cmludF9zbHBfdHJlZSAoZHVtcF9mbGFnc190IGR1bXBfa2luZCwgZHVtcF9sb2NhdGlvbl90IGxv YywKIAkJICAgZXN0aW1hdGVkX3BvbHlfdmFsdWUgKG5vZGUtPm1heF9udW5pdHMpLCBub2RlLT5y ZWZjbnQpOwogICBpZiAoU0xQX1RSRUVfU0NBTEFSX1NUTVRTIChub2RlKS5leGlzdHMgKCkpCiAg ICAgRk9SX0VBQ0hfVkVDX0VMVCAoU0xQX1RSRUVfU0NBTEFSX1NUTVRTIChub2RlKSwgaSwgc3Rt dF9pbmZvKQotICAgICAgZHVtcF9wcmludGZfbG9jIChtZXRhZGF0YSwgdXNlcl9sb2MsICJcdHN0 bXQgJXUgJUciLCBpLCBzdG10X2luZm8tPnN0bXQpOworICAgICAgaWYgKCFzdG10X2luZm8pCisJ ZHVtcF9wcmludGZfbG9jIChtZXRhZGF0YSwgdXNlcl9sb2MsICJcdE5VTExcbiIpOworICAgICAg ZWxzZQorCWR1bXBfcHJpbnRmX2xvYyAobWV0YWRhdGEsIHVzZXJfbG9jLCAiXHRzdG10ICV1ICVH IiwgaSwgc3RtdF9pbmZvLT5zdG10KTsKICAgZWxzZQogICAgIHsKICAgICAgIGR1bXBfcHJpbnRm X2xvYyAobWV0YWRhdGEsIHVzZXJfbG9jLCAiXHR7ICIpOwpAQCAtMTcxMCw3ICsxODAxLDcgQEAg dmVjdF9tYXJrX3NscF9zdG10cyAoc2xwX3RyZWUgbm9kZSwgaGFzaF9zZXQ8c2xwX3RyZWU+ICZ2 aXNpdGVkKQogICAgIHJldHVybjsKIAogICBGT1JfRUFDSF9WRUNfRUxUIChTTFBfVFJFRV9TQ0FM QVJfU1RNVFMgKG5vZGUpLCBpLCBzdG10X2luZm8pCi0gICAgU1RNVF9TTFBfVFlQRSAoc3RtdF9p bmZvKSA9IHB1cmVfc2xwOworICAgIGlmIChzdG10X2luZm8pIFNUTVRfU0xQX1RZUEUgKHN0bXRf aW5mbykgPSBwdXJlX3NscDsKIAogICBGT1JfRUFDSF9WRUNfRUxUIChTTFBfVFJFRV9DSElMRFJF TiAobm9kZSksIGksIGNoaWxkKQogICAgIHZlY3RfbWFya19zbHBfc3RtdHMgKGNoaWxkLCB2aXNp dGVkKTsKQEAgLTE5NjksMTEgKzIwNjAsMjQgQEAgdmVjdF9maW5kX2xhc3Rfc2NhbGFyX3N0bXRf aW5fc2xwIChzbHBfdHJlZSBub2RlKQogICBzdG10X3ZlY19pbmZvIGxhc3QgPSBOVUxMOwogICBz dG10X3ZlY19pbmZvIHN0bXRfdmluZm87CiAKKyAgYm9vbCBjaGVja19vcHMgPSBmYWxzZTsKICAg Zm9yIChpbnQgaSA9IDA7IFNMUF9UUkVFX1NDQUxBUl9TVE1UUyAobm9kZSkuaXRlcmF0ZSAoaSwg JnN0bXRfdmluZm8pOyBpKyspCiAgICAgeworICAgICAgaWYgKCFzdG10X3ZpbmZvKSB7IGNoZWNr X29wcyA9IHRydWU7IGJyZWFrOyB9CiAgICAgICBzdG10X3ZpbmZvID0gdmVjdF9vcmlnX3N0bXQg KHN0bXRfdmluZm8pOwogICAgICAgbGFzdCA9IGxhc3QgPyBnZXRfbGF0ZXJfc3RtdCAoc3RtdF92 aW5mbywgbGFzdCkgOiBzdG10X3ZpbmZvOwogICAgIH0KKyAgaWYgKGNoZWNrX29wcykKKyAgICB7 CisgICAgICBsYXN0ID0gTlVMTDsKKyAgICAgIGludCBpOworICAgICAgc2xwX3RyZWUgY2hpbGQ7 CisgICAgICBGT1JfRUFDSF9WRUNfRUxUIChTTFBfVFJFRV9DSElMRFJFTiAobm9kZSksIGksIGNo aWxkKQorCXsKKwkgIHN0bXRfdmluZm8gPSB2ZWN0X2ZpbmRfbGFzdF9zY2FsYXJfc3RtdF9pbl9z bHAgKGNoaWxkKTsKKwkgIGxhc3QgPSBsYXN0ID8gZ2V0X2xhdGVyX3N0bXQgKHN0bXRfdmluZm8s IGxhc3QpIDogc3RtdF92aW5mbzsKKwl9CisgICAgfQogCiAgIHJldHVybiBsYXN0OwogfQpAQCAt MjU0Nyw5ICsyNjUxLDYgQEAgdmVjdF9kZXRlY3RfaHlicmlkX3NscF9zdG10cyAoc2xwX3RyZWUg bm9kZSwgdW5zaWduZWQgaSwgc2xwX3ZlY3RfdHlwZSBzdHlwZSwKICAgaW1tX3VzZV9pdGVyYXRv ciBpbW1faXRlcjsKICAgZ2ltcGxlICp1c2Vfc3RtdDsKICAgc3RtdF92ZWNfaW5mbyB1c2Vfdmlu Zm87Ci0gIHNscF90cmVlIGNoaWxkOwotICBsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8gPSBTVE1U X1ZJTkZPX0xPT1BfVklORk8gKHN0bXRfdmluZm8pOwotICBpbnQgajsKIAogICAvKiBXZSBuZWVk IHRvIHVuaW9uIHN0eXBlIG92ZXIgdGhlIGluY29taW5nIGdyYXBoIGVkZ2VzIGJ1dCB3ZSBzdGls bAogICAgICB3YW50IHRvIGxpbWl0IHJlY3Vyc2lvbiB0byBzdGF5IE8oTitFKS4gICovCkBAIC0y NTU3LDYgKzI2NTgsOSBAQCB2ZWN0X2RldGVjdF9oeWJyaWRfc2xwX3N0bXRzIChzbHBfdHJlZSBu b2RlLCB1bnNpZ25lZCBpLCBzbHBfdmVjdF90eXBlIHN0eXBlLAogICBnY2NfYXNzZXJ0ICh2aXNp dGVkX2NudCA8PSBub2RlLT5yZWZjbnQpOwogICBib29sIG9ubHlfZWRnZSA9ICh2aXNpdGVkX2Nu dCAhPSBub2RlLT5yZWZjbnQpOwogCisgIGlmIChzdG10X3ZpbmZvKSB7CisgIGxvb3BfdmVjX2lu Zm8gbG9vcF92aW5mbyA9IFNUTVRfVklORk9fTE9PUF9WSU5GTyAoc3RtdF92aW5mbyk7CisKICAg LyogUHJvcGFnYXRlIGh5YnJpZCBkb3duIHRoZSBTTFAgdHJlZS4gICovCiAgIGlmIChzdHlwZSA9 PSBoeWJyaWQpCiAgICAgOwpAQCAtMjYwMyw3ICsyNzA3LDEwIEBAIHZlY3RfZGV0ZWN0X2h5YnJp ZF9zbHBfc3RtdHMgKHNscF90cmVlIG5vZGUsIHVuc2lnbmVkIGksIHNscF92ZWN0X3R5cGUgc3R5 cGUsCiAJCQkgc3RtdF92aW5mby0+c3RtdCk7CiAgICAgICBTVE1UX1NMUF9UWVBFIChzdG10X3Zp bmZvKSA9IGh5YnJpZDsKICAgICB9CisgIH0KIAorICBzbHBfdHJlZSBjaGlsZDsKKyAgaW50IGo7 CiAgIGlmICghb25seV9lZGdlKQogICAgIEZPUl9FQUNIX1ZFQ19FTFQgKFNMUF9UUkVFX0NISUxE UkVOIChub2RlKSwgaiwgY2hpbGQpCiAgICAgICBpZiAoU0xQX1RSRUVfREVGX1RZUEUgKGNoaWxk KSAhPSB2ZWN0X2V4dGVybmFsX2RlZgpAQCAtMjc5MCw4ICsyODk3LDE3IEBAIHZlY3Rfc2xwX2Fu YWx5emVfbm9kZV9vcGVyYXRpb25zXzEgKHZlY19pbmZvICp2aW5mbywgc2xwX3RyZWUgbm9kZSwK IAk9IHZlY3RfZ2V0X251bV92ZWN0b3JzICh2ZiAqIGdyb3VwX3NpemUsIHZlY3R5cGUpOwogICAg IH0KIAorICAvKiBIYW5kbGUgcHVyZWx5IGludGVybmFsIG5vZGVzLiAgKi8KKyAgaWYgKG5vZGUt PmNsYXNzaWZ5ICgpID09IF9zbHBfdHJlZTo6U0xQX0NQRVJNKQorICAgIHJldHVybiB2ZWN0b3Jp emFibGVfc2xwX3Blcm11dGF0aW9uICh2aW5mbywgTlVMTCwgbm9kZSwgY29zdF92ZWMpOworCiAg IGJvb2wgZHVtbXk7Ci0gIHJldHVybiB2ZWN0X2FuYWx5emVfc3RtdCAoc3RtdF9pbmZvLCAmZHVt bXksIG5vZGUsIG5vZGVfaW5zdGFuY2UsIGNvc3RfdmVjKTsKKyAgZHVtbXkgPSB2ZWN0X2FuYWx5 emVfc3RtdCAoc3RtdF9pbmZvLCAmZHVtbXksIG5vZGUsIG5vZGVfaW5zdGFuY2UsIGNvc3RfdmVj KTsKKyAgLyogV2UgZXZlbnR1YWxseSBleHBlY3QgdmVjdG9yaXphYmxlXyogZnVuY3Rpb25zIHRv IGd1ZXNzIGFuZCBzZXQgdGhlCisgICAgIG91dHB1dCB2ZWN0b3IgdHlwZSBmcm9tIHRoZSBpbnB1 dHMuICAqLworICBpZiAoIVNMUF9UUkVFX1ZFQ1RZUEUgKG5vZGUpKQorICAgIFNMUF9UUkVFX1ZF Q1RZUEUgKG5vZGUpID0gU1RNVF9WSU5GT19WRUNUWVBFIChzdG10X2luZm8pOworICByZXR1cm4g ZHVtbXk7CiB9CiAKIC8qIFRyeSB0byBidWlsZCBOT0RFIGZyb20gc2NhbGFycywgcmV0dXJuaW5n IHRydWUgb24gc3VjY2Vzcy4KQEAgLTQxMTQsMTAgKzQyMzAsMTkwIEBAIHZlY3RfdHJhbnNmb3Jt X3NscF9wZXJtX2xvYWQgKHNscF90cmVlIG5vZGUsIHZlYzx0cmVlPiBkcl9jaGFpbiwKICAgcmV0 dXJuIHRydWU7CiB9CiAKKworLyogVmVjdG9yaXplIFNMUCBwZXJtdXRhdGlvbnMuICAqLworCitz dGF0aWMgYm9vbAordmVjdG9yaXphYmxlX3NscF9wZXJtdXRhdGlvbiAodmVjX2luZm8gKnZpbmZv LCBnaW1wbGVfc3RtdF9pdGVyYXRvciAqZ3NpLAorCQkJICAgICAgc2xwX3RyZWUgbm9kZSwgc3Rt dF92ZWN0b3JfZm9yX2Nvc3QgKmNvc3RfdmVjKQoreworICAvKiBBdCBhbmFseXNpcyB0aW1lIGNv bXB1dGUgdGhlIHZlY3RvciB0eXBlLgorICAgICA/Pz8gIFdlIGN1cnJlbnRseSBvbmx5IHN1cHBv cnQgYWxsIHNhbWUgdmVjdG9yIGlucHV0IGFuZCBvdXRwdXQgdHlwZXMKKyAgICAgd2hpbGUgdGhl IFNMUCBJTCBzaG91bGQgcmVhbGx5IGRvIGEgY29uY2F0ICsgc2VsZWN0IGFuZCB0aHVzIGFjY2Vw dAorICAgICBhcmJpdHJhcnkgbWlzbWF0Y2hlcy4KKyAgICAgPz8/ICBWZXJpZmljYXRpb24gb2Yg dGhlIGN1cnJlbnQgbGltaXRhdGlvbiBpcyBtaXNzaW5nIGhlcmUuICAqLworICBpZiAoIWdzaSkK KyAgICBTTFBfVFJFRV9WRUNUWVBFIChub2RlKSA9IFNMUF9UUkVFX1ZFQ1RZUEUgKFNMUF9UUkVF X0NISUxEUkVOIChub2RlKVswXSk7CisgIHRyZWUgdmVjdHlwZSA9IFNMUF9UUkVFX1ZFQ1RZUEUg KG5vZGUpOworCisgIHZlYzxzdGQ6OnBhaXI8dW5zaWduZWQsIHVuc2lnbmVkPiA+ICZwZXJtID0g U0xQX1RSRUVfTEFORV9QRVJNVVRBVElPTiAobm9kZSk7CisKKyAgdW5zaWduZWQgdmYgPSAxOwor ICBpZiAobG9vcF92ZWNfaW5mbyBsaW5mbyA9IGR5bl9jYXN0IDxsb29wX3ZlY19pbmZvPiAodmlu Zm8pKQorICAgIHZmID0gTE9PUF9WSU5GT19WRUNUX0ZBQ1RPUiAobGluZm8pLnRvX2NvbnN0YW50 ICgpOworICB1bnNpZ25lZCBvbGFuZXMgPSB2ZiAqIG5vZGUtPm5fbGFuZXMgKCk7CisgIGdjY19h c3NlcnQgKG9sYW5lcyAlIHBlcm0ubGVuZ3RoICgpID09IDApOworICBnY2NfYXNzZXJ0IChtdWx0 aXBsZV9wIChvbGFuZXMsIFRZUEVfVkVDVE9SX1NVQlBBUlRTICh2ZWN0eXBlKSkpOworCisgIC8q ID8/PyAgIENvbXB1dGUgeyBvcCwgdmVjdG9yLWRlZiwgbGFuZSB9IHBlcm11dGF0aW9uIHNlcXVl bmNlLCBkZWxheWluZworICAgICBmaW5hbCBpbmRleCBjb21wdXRlIGFuZCB0aHVzIGNvbWJpbmlu ZyB2ZWN0b3ItZGVmcyBpbiBhIHBhcnRpY3VsYXIKKyAgICAgb3JkZXIuCisgICAgID8/PyAgIEFz IGludGVybWVkaWF0ZSBzdGVwIHRvIGFjdHVhbGx5IGNvZGUtZ2VuIGluIHRoZSBTTFAgdHJlZQor ICAgICByZXByZXNlbnRhdGlvbj8gICovCisKKyAgYXV0b192ZWM8dW5zaWduZWQ+IGFjdGl2ZV9s YW5lOworICBhdXRvX3ZlYzx1bnNpZ25lZD4gZGVmaTsKKyAgYWN0aXZlX2xhbmUuc2FmZV9ncm93 X2NsZWFyZWQgKFNMUF9UUkVFX0NISUxEUkVOIChub2RlKS5sZW5ndGggKCkpOworICBkZWZpLnNh ZmVfZ3Jvd19jbGVhcmVkIChTTFBfVFJFRV9DSElMRFJFTiAobm9kZSkubGVuZ3RoICgpKTsKKwor ICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisgICAgeworICAgICAgZHVtcF9wcmludGZfbG9jIChN U0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKKwkJICAgICAgICJ2ZWN0b3JpemluZyBwZXJtdXRhdGlv biIpOworICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHBlcm0ubGVuZ3RoICgpOyArK2kp CisJZHVtcF9wcmludGYgKE1TR19OT1RFLCAiIG9wJXVbJXVdIiwgcGVybVtpXS5maXJzdCwgcGVy bVtpXS5zZWNvbmQpOyAKKyAgICAgIGR1bXBfcHJpbnRmIChNU0dfTk9URSwgIlxuIik7CisgICAg fQorCisgIGF1dG9fdmVjPHN0ZDo6cGFpcjxzdGQ6OnBhaXI8dW5zaWduZWQsIHVuc2lnbmVkPiwg dW5zaWduZWQ+ID4gdnBlcm07CisgIHZwZXJtLmNyZWF0ZSAob2xhbmVzKTsKKyAgZm9yICh1bnNp Z25lZCBpID0gMDsgaSA8IG9sYW5lcyAvIHBlcm0ubGVuZ3RoICgpOyArK2kpCisgICAgeworICAg ICAgZm9yICh1bnNpZ25lZCBwaSA9IDA7IHBpIDwgcGVybS5sZW5ndGggKCk7ICsrcGkpCisJewor CSAgc3RkOjpwYWlyPHVuc2lnbmVkLCB1bnNpZ25lZD4gcCA9IHBlcm1bcGldOworCSAgdW5zaWdu ZWQgdm51bml0cyA9IFRZUEVfVkVDVE9SX1NVQlBBUlRTCisJICAoU0xQX1RSRUVfVkVDVFlQRSAo U0xQX1RSRUVfQ0hJTERSRU4gKG5vZGUpW3AuZmlyc3RdKSkudG9fY29uc3RhbnQgKCk7CisJICB1 bnNpZ25lZCB2aSA9IChhY3RpdmVfbGFuZVtwLmZpcnN0XSArIHAuc2Vjb25kKSAvIHZudW5pdHM7 CisJICB1bnNpZ25lZCB2bCA9IChhY3RpdmVfbGFuZVtwLmZpcnN0XSArIHAuc2Vjb25kKSAlIHZu dW5pdHM7CisJICB2cGVybS5xdWlja19wdXNoIChzdGQ6Om1ha2VfcGFpciAoc3RkOjptYWtlX3Bh aXIgKHAuZmlyc3QsIHZpKSwgdmwpKTsKKwl9CisgICAgICAvKiBBZHZhbmNlIHRvIHRoZSBuZXh0 IGdyb3VwLiAgKi8KKyAgICAgIGZvciAodW5zaWduZWQgaiA9IDA7IGogPCBTTFBfVFJFRV9DSElM RFJFTiAobm9kZSkubGVuZ3RoICgpOyArK2opCisJYWN0aXZlX2xhbmVbal0gKz0gU0xQX1RSRUVf Q0hJTERSRU4gKG5vZGUpW2pdLT5uX2xhbmVzICgpOworICAgIH0KKworICBpZiAoZHVtcF9lbmFi bGVkX3AgKCkpCisgICAgeworICAgICAgZHVtcF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9s b2NhdGlvbiwKKwkJICAgICAgICJhcyIpOworICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8 IHZwZXJtLmxlbmd0aCAoKTsgKytpKQorCXsKKwkgIGlmIChpICE9IDAgJiYgbXVsdGlwbGVfcCAo aSwgVFlQRV9WRUNUT1JfU1VCUEFSVFMgKHZlY3R5cGUpKSkKKwkgICAgZHVtcF9wcmludGYgKE1T R19OT1RFLCAiLCIpOworCSAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiIHZvcHMldVsldV1bJXVd IiwKKwkJICAgICAgIHZwZXJtW2ldLmZpcnN0LmZpcnN0LCB2cGVybVtpXS5maXJzdC5zZWNvbmQs CisJCSAgICAgICB2cGVybVtpXS5maXJzdC5zZWNvbmQpOyAKKwl9CisgICAgICBkdW1wX3ByaW50 ZiAoTVNHX05PVEUsICJcbiIpOworICAgIH0KKworICAvKiBXZSBjYW4gb25seSBoYW5kbGUgdHdv LXZlY3RvciBwZXJtdXRlcywgZXZlcnl0aGluZyBlbHNlIHNob3VsZAorICAgICBiZSBsb3dlcmVk IG9uIHRoZSBTTFAgbGV2ZWwuICAqLworICBzdGQ6OnBhaXI8dW5zaWduZWQsIHVuc2lnbmVkPiBm aXJzdF92ZWMgPSBzdGQ6Om1ha2VfcGFpciAoLTFVLCAtMVUpOworICBzdGQ6OnBhaXI8dW5zaWdu ZWQsIHVuc2lnbmVkPiBzZWNvbmRfdmVjID0gc3RkOjptYWtlX3BhaXIgKC0xVSwgLTFVKTsKKyAg dW5zaWduZWQgaW50IGNvbnN0X251bml0cyA9IFRZUEVfVkVDVE9SX1NVQlBBUlRTICh2ZWN0eXBl KS50b19jb25zdGFudCAoKTsKKyAgdW5zaWduZWQgaW50IGluZGV4ID0gMDsKKyAgdW5zaWduZWQg aW50IG1hc2tfZWxlbWVudDsKKyAgdmVjX3Blcm1fYnVpbGRlciBtYXNrOworICBtYXNrLm5ld192 ZWN0b3IgKGNvbnN0X251bml0cywgY29uc3RfbnVuaXRzLCAxKTsKKyAgdW5zaWduZWQgaW50IGNv dW50ID0gbWFzay5lbmNvZGVkX25lbHRzICgpOworICBtYXNrLnF1aWNrX2dyb3cgKGNvdW50KTsK KyAgdmVjX3Blcm1faW5kaWNlcyBpbmRpY2VzOworICB1bnNpZ25lZCBucGVybXMgPSAwOworICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdnBlcm0ubGVuZ3RoICgpOyArK2kpCisgICAgeworICAg ICAgbWFza19lbGVtZW50ID0gdnBlcm1baV0uc2Vjb25kOworICAgICAgaWYgKGZpcnN0X3ZlYy5m aXJzdCA9PSAtMVUKKwkgIHx8IGZpcnN0X3ZlYyA9PSB2cGVybVtpXS5maXJzdCkKKwlmaXJzdF92 ZWMgPSB2cGVybVtpXS5maXJzdDsKKyAgICAgIGVsc2UgaWYgKHNlY29uZF92ZWMuZmlyc3QgPT0g LTFVCisJICAgICAgIHx8IHNlY29uZF92ZWMgPT0gdnBlcm1baV0uZmlyc3QpCisJeworCSAgc2Vj b25kX3ZlYyA9IHZwZXJtW2ldLmZpcnN0OworCSAgbWFza19lbGVtZW50ICs9IGNvbnN0X251bml0 czsKKwl9CisgICAgICBlbHNlCisJeworCSAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCSAgICBk dW1wX3ByaW50Zl9sb2MgKE1TR19NSVNTRURfT1BUSU1JWkFUSU9OLCB2ZWN0X2xvY2F0aW9uLAor CQkJICAgICAicGVybXV0YXRpb24gcmVxdWlyZXMgYXQgIgorCQkJICAgICAibGVhc3QgdGhyZWUg dmVjdG9ycyIpOworCSAgZ2NjX2Fzc2VydCAoIWdzaSk7CisJICByZXR1cm4gZmFsc2U7CisJfQor CisgICAgICBtYXNrW2luZGV4KytdID0gbWFza19lbGVtZW50OworCisgICAgICBpZiAoaW5kZXgg PT0gY291bnQpCisJeworCSAgaW5kaWNlcy5uZXdfdmVjdG9yIChtYXNrLCBzZWNvbmRfdmVjLmZp cnN0ID09IC0xVSA/IDEgOiAyLAorCQkJICAgICAgY29uc3RfbnVuaXRzKTsKKwkgIGlmICghY2Fu X3ZlY19wZXJtX2NvbnN0X3AgKFRZUEVfTU9ERSAodmVjdHlwZSksIGluZGljZXMpKQorCSAgICB7 CisJICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCQl7CisJCSAgZHVtcF9wcmludGZfbG9j IChNU0dfTUlTU0VEX09QVElNSVpBVElPTiwKKwkJCQkgICB2ZWN0X2xvY2F0aW9uLAorCQkJCSAg ICJ1bnN1cHBvcnRlZCB2ZWN0IHBlcm11dGUgeyAiKTsKKwkJICBmb3IgKGkgPSAwOyBpIDwgY291 bnQ7ICsraSkKKwkJICAgIHsKKwkJICAgICAgZHVtcF9kZWMgKE1TR19NSVNTRURfT1BUSU1JWkFU SU9OLCBtYXNrW2ldKTsKKwkJICAgICAgZHVtcF9wcmludGYgKE1TR19NSVNTRURfT1BUSU1JWkFU SU9OLCAiICIpOworCQkgICAgfQorCQkgIGR1bXBfcHJpbnRmIChNU0dfTUlTU0VEX09QVElNSVpB VElPTiwgIn1cbiIpOworCQl9CisJICAgICAgZ2NjX2Fzc2VydCAoIWdzaSk7CisJICAgICAgcmV0 dXJuIGZhbHNlOworCSAgICB9CisJfQorCisgICAgICBpZiAoaW5kZXggPT0gY291bnQpCisJewor CSAgbnBlcm1zKys7CisKKwkgIGlmIChnc2kpCisJICAgIHsKKwkgICAgICB0cmVlIG1hc2tfdmVj ID0gdmVjdF9nZW5fcGVybV9tYXNrX2NoZWNrZWQgKHZlY3R5cGUsIGluZGljZXMpOworCisJICAg ICAgaWYgKHNlY29uZF92ZWMuZmlyc3QgPT0gLTFVKQorCQlzZWNvbmRfdmVjID0gZmlyc3RfdmVj OworCisJICAgICAgLyogR2VuZXJhdGUgdGhlIHBlcm11dGUgc3RhdGVtZW50IGlmIG5lY2Vzc2Fy eS4gICovCisJICAgICAgdHJlZSBmaXJzdF9kZWYgPSBnaW1wbGVfZ2V0X2xocyAoU0xQX1RSRUVf VkVDX1NUTVRTCisJKFNMUF9UUkVFX0NISUxEUkVOIChub2RlKVtmaXJzdF92ZWMuZmlyc3RdKVtm aXJzdF92ZWMuc2Vjb25kXS0+c3RtdCk7CisJICAgICAgdHJlZSBzZWNvbmRfZGVmID0gZ2ltcGxl X2dldF9saHMgKFNMUF9UUkVFX1ZFQ19TVE1UUworCShTTFBfVFJFRV9DSElMRFJFTiAobm9kZSlb c2Vjb25kX3ZlYy5maXJzdF0pW3NlY29uZF92ZWMuc2Vjb25kXS0+c3RtdCk7CisJICAgICAgc3Rt dF92ZWNfaW5mbyBwZXJtX3N0bXRfaW5mbzsKKwkgICAgICB0cmVlIHBlcm1fZGVzdCA9IG1ha2Vf c3NhX25hbWUgKHZlY3R5cGUpOworCSAgICAgIGdhc3NpZ24gKnBlcm1fc3RtdAorCQkgID0gZ2lt cGxlX2J1aWxkX2Fzc2lnbiAocGVybV9kZXN0LCBWRUNfUEVSTV9FWFBSLAorCQkJCQkgZmlyc3Rf ZGVmLCBzZWNvbmRfZGVmLAorCQkJCQkgbWFza192ZWMpOworCSAgICAgIC8qID8/PyAgUmVmYWN0 b3IgdmVjdF9maW5pc2hfc3RtdF9nZW5lcmF0aW9uLiAgKi8KKwkgICAgICBnc2lfaW5zZXJ0X2Jl Zm9yZSAoZ3NpLCBwZXJtX3N0bXQsIEdTSV9TQU1FX1NUTVQpOworCSAgICAgIHBlcm1fc3RtdF9p bmZvID0gdmluZm8tPmFkZF9zdG10IChwZXJtX3N0bXQpOworCSAgICAgIC8qIFN0b3JlIHRoZSB2 ZWN0b3Igc3RhdGVtZW50IGluIE5PREUuICAqLworCSAgICAgIFNMUF9UUkVFX1ZFQ19TVE1UUyAo bm9kZSkucXVpY2tfcHVzaCAocGVybV9zdG10X2luZm8pOworCSAgICB9CisKKwkgIGluZGV4ID0g MDsKKwkgIGZpcnN0X3ZlYyA9IHN0ZDo6bWFrZV9wYWlyICgtMVUsIC0xVSk7CisJICBzZWNvbmRf dmVjID0gc3RkOjptYWtlX3BhaXIgKC0xVSwgLTFVKTsKKwl9CisgICAgfQorCisgIGlmICghZ3Np KQorICAgIHJlY29yZF9zdG10X2Nvc3QgKGNvc3RfdmVjLCBucGVybXMsIHZlY19wZXJtLCBOVUxM LCAwLCB2ZWN0X2JvZHkpOworCisgIHJldHVybiB0cnVlOworfQorCiAvKiBWZWN0b3JpemUgU0xQ IGluc3RhbmNlIHRyZWUgaW4gcG9zdG9yZGVyLiAgKi8KIAogc3RhdGljIHZvaWQKLXZlY3Rfc2No ZWR1bGVfc2xwX2luc3RhbmNlIChzbHBfdHJlZSBub2RlLCBzbHBfaW5zdGFuY2UgaW5zdGFuY2Up Cit2ZWN0X3NjaGVkdWxlX3NscF9pbnN0YW5jZSAodmVjX2luZm8gKnZpbmZvLAorCQkJICAgIHNs cF90cmVlIG5vZGUsIHNscF9pbnN0YW5jZSBpbnN0YW5jZSkKIHsKICAgZ2ltcGxlX3N0bXRfaXRl cmF0b3Igc2k7CiAgIHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvOwpAQCAtNDEzNSw3ICs0NDMxLDcg QEAgdmVjdF9zY2hlZHVsZV9zbHBfaW5zdGFuY2UgKHNscF90cmVlIG5vZGUsIHNscF9pbnN0YW5j ZSBpbnN0YW5jZSkKICAgICByZXR1cm47CiAKICAgRk9SX0VBQ0hfVkVDX0VMVCAoU0xQX1RSRUVf Q0hJTERSRU4gKG5vZGUpLCBpLCBjaGlsZCkKLSAgICB2ZWN0X3NjaGVkdWxlX3NscF9pbnN0YW5j ZSAoY2hpbGQsIGluc3RhbmNlKTsKKyAgICB2ZWN0X3NjaGVkdWxlX3NscF9pbnN0YW5jZSAodmlu Zm8sIGNoaWxkLCBpbnN0YW5jZSk7CiAKICAgLyogUHVzaCBTTFAgbm9kZSBkZWYtdHlwZSB0byBz dG10cy4gICovCiAgIEZPUl9FQUNIX1ZFQ19FTFQgKFNMUF9UUkVFX0NISUxEUkVOIChub2RlKSwg aSwgY2hpbGQpCkBAIC00MTY2LDgxICs0NDYyLDE5IEBAIHZlY3Rfc2NoZWR1bGVfc2xwX2luc3Rh bmNlIChzbHBfdHJlZSBub2RlLCBzbHBfaW5zdGFuY2UgaW5zdGFuY2UpCiAgIHN0bXRfdmVjX2lu Zm8gbGFzdF9zdG10X2luZm8gPSB2ZWN0X2ZpbmRfbGFzdF9zY2FsYXJfc3RtdF9pbl9zbHAgKG5v ZGUpOwogICBzaSA9IGdzaV9mb3Jfc3RtdCAobGFzdF9zdG10X2luZm8tPnN0bXQpOwogCi0gIC8q IEhhbmRsZSB0d28tb3BlcmF0aW9uIFNMUCBub2RlcyBieSB2ZWN0b3JpemluZyB0aGUgZ3JvdXAg d2l0aAotICAgICBib3RoIG9wZXJhdGlvbnMgYW5kIHRoZW4gcGVyZm9ybWluZyBhIG1lcmdlLiAg Ki8KICAgYm9vbCBkb25lX3AgPSBmYWxzZTsKLSAgaWYgKFNMUF9UUkVFX1RXT19PUEVSQVRPUlMg KG5vZGUpKQorCisgIC8qIEhhbmRsZSBwdXJlbHkgaW50ZXJuYWwgbm9kZXMuICAqLworICBpZiAo bm9kZS0+Y2xhc3NpZnkgKCkgPT0gX3NscF90cmVlOjpTTFBfQ1BFUk0pCiAgICAgewotICAgICAg Z2Fzc2lnbiAqc3RtdCA9IGFzX2EgPGdhc3NpZ24gKj4gKHN0bXRfaW5mby0+c3RtdCk7Ci0gICAg ICBlbnVtIHRyZWVfY29kZSBjb2RlMCA9IGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKHN0bXQpOwot ICAgICAgZW51bSB0cmVlX2NvZGUgb2NvZGUgPSBFUlJPUl9NQVJLOwotICAgICAgc3RtdF92ZWNf aW5mbyBvc3RtdF9pbmZvOwotICAgICAgdmVjX3Blcm1fYnVpbGRlciBtYXNrIChncm91cF9zaXpl LCBncm91cF9zaXplLCAxKTsKLSAgICAgIEZPUl9FQUNIX1ZFQ19FTFQgKFNMUF9UUkVFX1NDQUxB Ul9TVE1UUyAobm9kZSksIGksIG9zdG10X2luZm8pCi0JewotCSAgZ2Fzc2lnbiAqb3N0bXQgPSBh c19hIDxnYXNzaWduICo+IChvc3RtdF9pbmZvLT5zdG10KTsKLQkgIGlmIChnaW1wbGVfYXNzaWdu X3Joc19jb2RlIChvc3RtdCkgIT0gY29kZTApCi0JICAgIHsKLQkgICAgICBtYXNrLnF1aWNrX3B1 c2ggKDEpOwotCSAgICAgIG9jb2RlID0gZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAob3N0bXQpOwot CSAgICB9Ci0JICBlbHNlCi0JICAgIG1hc2sucXVpY2tfcHVzaCAoMCk7Ci0JfQotICAgICAgaWYg KG9jb2RlICE9IEVSUk9SX01BUkspCi0JewotCSAgdmVjPHN0bXRfdmVjX2luZm8+IHYwOwotCSAg dmVjPHN0bXRfdmVjX2luZm8+IHYxOwotCSAgdW5zaWduZWQgajsKLQkgIHRyZWUgdG1hc2sgPSBO VUxMX1RSRUU7Ci0JICB2ZWN0X3RyYW5zZm9ybV9zdG10IChzdG10X2luZm8sICZzaSwgbm9kZSwg aW5zdGFuY2UpOwotCSAgdjAgPSBTTFBfVFJFRV9WRUNfU1RNVFMgKG5vZGUpLmNvcHkgKCk7Ci0J ICBTTFBfVFJFRV9WRUNfU1RNVFMgKG5vZGUpLnRydW5jYXRlICgwKTsKLQkgIGdpbXBsZV9hc3Np Z25fc2V0X3Joc19jb2RlIChzdG10LCBvY29kZSk7Ci0JICB2ZWN0X3RyYW5zZm9ybV9zdG10IChz dG10X2luZm8sICZzaSwgbm9kZSwgaW5zdGFuY2UpOwotCSAgZ2ltcGxlX2Fzc2lnbl9zZXRfcmhz X2NvZGUgKHN0bXQsIGNvZGUwKTsKLQkgIHYxID0gU0xQX1RSRUVfVkVDX1NUTVRTIChub2RlKS5j b3B5ICgpOwotCSAgU0xQX1RSRUVfVkVDX1NUTVRTIChub2RlKS50cnVuY2F0ZSAoMCk7Ci0JICB0 cmVlIG1lbHR5cGUgPSBidWlsZF9ub25zdGFuZGFyZF9pbnRlZ2VyX3R5cGUKLQkgICAgICAoR0VU X01PREVfQklUU0laRSAoU0NBTEFSX1RZUEVfTU9ERSAoVFJFRV9UWVBFICh2ZWN0eXBlKSkpLCAx KTsKLQkgIHRyZWUgbXZlY3R5cGUgPSBnZXRfc2FtZV9zaXplZF92ZWN0eXBlIChtZWx0eXBlLCB2 ZWN0eXBlKTsKLQkgIHVuc2lnbmVkIGsgPSAwLCBsOwotCSAgZm9yIChqID0gMDsgaiA8IHYwLmxl bmd0aCAoKTsgKytqKQotCSAgICB7Ci0JICAgICAgLyogRW5mb3JjZWQgYnkgdmVjdF9idWlsZF9z bHBfdHJlZSwgd2hpY2ggcmVqZWN0cyB2YXJpYWJsZS1sZW5ndGgKLQkJIHZlY3RvcnMgZm9yIFNM UF9UUkVFX1RXT19PUEVSQVRPUlMuICAqLwotCSAgICAgIHVuc2lnbmVkIGludCBjb25zdF9udW5p dHMgPSBudW5pdHMudG9fY29uc3RhbnQgKCk7Ci0JICAgICAgdHJlZV92ZWN0b3JfYnVpbGRlciBt ZWx0cyAobXZlY3R5cGUsIGNvbnN0X251bml0cywgMSk7Ci0JICAgICAgZm9yIChsID0gMDsgbCA8 IGNvbnN0X251bml0czsgKytsKQotCQl7Ci0JCSAgaWYgKGsgPj0gZ3JvdXBfc2l6ZSkKLQkJICAg IGsgPSAwOwotCQkgIHRyZWUgdCA9IGJ1aWxkX2ludF9jc3QgKG1lbHR5cGUsCi0JCQkJCSAgbWFz a1trKytdICogY29uc3RfbnVuaXRzICsgbCk7Ci0JCSAgbWVsdHMucXVpY2tfcHVzaCAodCk7Ci0J CX0KLQkgICAgICB0bWFzayA9IG1lbHRzLmJ1aWxkICgpOwotCi0JICAgICAgLyogPz8/ICBOb3Qg YWxsIHRhcmdldHMgc3VwcG9ydCBhIFZFQ19QRVJNX0VYUFIgd2l0aCBhCi0JICAgICAgICAgY29u c3RhbnQgbWFzayB0aGF0IHdvdWxkIHRyYW5zbGF0ZSB0byBhIHZlY19tZXJnZSBSVFgKLQkJICh3 aXRoIHRoZWlyIHZlY19wZXJtX2NvbnN0X29rKS4gIFdlIGNhbiBlaXRoZXIgbm90Ci0JCSB2ZWN0 b3JpemUgaW4gdGhhdCBjYXNlIG9yIGxldCB2ZWNsb3dlciBkbyBpdHMgam9iLgotCQkgVW5mb3J0 dW5hdGVseSB0aGF0IGlzbid0IHRvbyBncmVhdCBhbmQgYXQgbGVhc3QgZm9yCi0JCSBwbHVzL21p bnVzIHdlJ2QgZXZlbnR1YWxseSBsaWtlIHRvIG1hdGNoIHRhcmdldHMKLQkJIHZlY3RvciBhZGRz dWIgaW5zdHJ1Y3Rpb25zLiAgKi8KLQkgICAgICBnaW1wbGUgKnZzdG10OwotCSAgICAgIHZzdG10 ID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAobWFrZV9zc2FfbmFtZSAodmVjdHlwZSksCi0JCQkJCSAg IFZFQ19QRVJNX0VYUFIsCi0JCQkJCSAgIGdpbXBsZV9hc3NpZ25fbGhzICh2MFtqXS0+c3RtdCks Ci0JCQkJCSAgIGdpbXBsZV9hc3NpZ25fbGhzICh2MVtqXS0+c3RtdCksCi0JCQkJCSAgIHRtYXNr KTsKLQkgICAgICBTTFBfVFJFRV9WRUNfU1RNVFMgKG5vZGUpLnF1aWNrX3B1c2gKLQkJKHZlY3Rf ZmluaXNoX3N0bXRfZ2VuZXJhdGlvbiAoc3RtdF9pbmZvLCB2c3RtdCwgJnNpKSk7Ci0JICAgIH0K LQkgIHYwLnJlbGVhc2UgKCk7Ci0JICB2MS5yZWxlYXNlICgpOwotCSAgZG9uZV9wID0gdHJ1ZTsK LQl9CisgICAgICAvKiA/Pz8gIHRoZSB0cmFuc2Zvcm0ga2luZCBpcyBzdG9yZWQgdG8gU1RNVF9W SU5GT19UWVBFIHdoaWNoIG1pZ2h0CisJIGJlIHNoYXJlZCB3aXRoIGRpZmZlcmVudCBTTFAgbm9k ZXMgKGJ1dCB1c3VhbGx5IGl0J3MgdGhlIHNhbWUKKwkgb3BlcmF0aW9uIGFwYXJ0IGZyb20gdGhl IGNhc2UgdGhlIHN0bXQgaXMgb25seSB0aGVyZSBmb3IgZGVub3RpbmcKKwkgdGhlIGFjdHVhbCBz Y2FsYXIgbGFuZSBkZWZzIC4uLikuICBTbyBkbyBub3QgY2FsbCB2ZWN0X3RyYW5zZm9ybV9zdG10 CisJIGJ1dCBvcGVuLWNvZGUgaXQgaGVyZSAocGFydGx5KS4gICovCisgICAgICBib29sIGRvbmUg PSB2ZWN0b3JpemFibGVfc2xwX3Blcm11dGF0aW9uICh2aW5mbywgJnNpLCBub2RlLCBOVUxMKTsK KyAgICAgIGdjY19hc3NlcnQgKGRvbmUpOworICAgICAgZG9uZV9wID0gdHJ1ZTsKICAgICB9CiAg IGlmICghZG9uZV9wKQogICAgIHZlY3RfdHJhbnNmb3JtX3N0bXQgKHN0bXRfaW5mbywgJnNpLCBu b2RlLCBpbnN0YW5jZSk7CkBAIC00MjgxLDYgKzQ1MTUsNyBAQCB2ZWN0X3JlbW92ZV9zbHBfc2Nh bGFyX2NhbGxzIChzbHBfdHJlZSBub2RlLCBoYXNoX3NldDxzbHBfdHJlZT4gJnZpc2l0ZWQpCiAK ICAgRk9SX0VBQ0hfVkVDX0VMVCAoU0xQX1RSRUVfU0NBTEFSX1NUTVRTIChub2RlKSwgaSwgc3Rt dF9pbmZvKQogICAgIHsKKyAgICAgIGlmICghc3RtdF9pbmZvKSBjb250aW51ZTsKICAgICAgIGdj YWxsICpzdG10ID0gZHluX2Nhc3QgPGdjYWxsICo+IChzdG10X2luZm8tPnN0bXQpOwogICAgICAg aWYgKCFzdG10IHx8IGdpbXBsZV9iYiAoc3RtdCkgPT0gTlVMTCkKIAljb250aW51ZTsKQEAgLTQz NjYsNyArNDYwMSw3IEBAIHZlY3Rfc2NoZWR1bGVfc2xwICh2ZWNfaW5mbyAqdmluZm8pCiAgICAg ewogICAgICAgc2xwX3RyZWUgbm9kZSA9IFNMUF9JTlNUQU5DRV9UUkVFIChpbnN0YW5jZSk7CiAg ICAgICAvKiBTY2hlZHVsZSB0aGUgdHJlZSBvZiBJTlNUQU5DRS4gICovCi0gICAgICB2ZWN0X3Nj aGVkdWxlX3NscF9pbnN0YW5jZSAobm9kZSwgaW5zdGFuY2UpOworICAgICAgdmVjdF9zY2hlZHVs ZV9zbHBfaW5zdGFuY2UgKHZpbmZvLCBub2RlLCBpbnN0YW5jZSk7CiAKICAgICAgIGlmIChTTFBf SU5TVEFOQ0VfUk9PVF9TVE1UIChpbnN0YW5jZSkpCiAJdmVjdG9yaXplX3NscF9pbnN0YW5jZV9y b290X3N0bXQgKG5vZGUsIGluc3RhbmNlKTsKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Qtc3Rt dHMuYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuYwppbmRleCBmMzRhYzE1MTY4MS4uMjVkYWQxZDcx MmEgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3RtdHMuYworKysgYi9nY2MvdHJlZS12ZWN0 LXN0bXRzLmMKQEAgLTEwNzMwLDcgKzEwNzMwLDcgQEAgY2FuX3ZlY3Rvcml6ZV9saXZlX3N0bXRz IChzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmdzaSwKICAg ICAgIHVuc2lnbmVkIGludCBpOwogICAgICAgRk9SX0VBQ0hfVkVDX0VMVCAoU0xQX1RSRUVfU0NB TEFSX1NUTVRTIChzbHBfbm9kZSksIGksIHNscF9zdG10X2luZm8pCiAJewotCSAgaWYgKFNUTVRf VklORk9fTElWRV9QIChzbHBfc3RtdF9pbmZvKQorCSAgaWYgKHNscF9zdG10X2luZm8gJiYgU1RN VF9WSU5GT19MSVZFX1AgKHNscF9zdG10X2luZm8pCiAJICAgICAgJiYgIXZlY3Rvcml6YWJsZV9s aXZlX29wZXJhdGlvbiAoc2xwX3N0bXRfaW5mbywgZ3NpLCBzbHBfbm9kZSwKIAkJCQkJICAgICAg IHNscF9ub2RlX2luc3RhbmNlLCBpLAogCQkJCQkgICAgICAgdmVjX3N0bXRfcCwgY29zdF92ZWMp KQpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdG9yaXplci5oIGIvZ2NjL3RyZWUtdmVjdG9yaXpl ci5oCmluZGV4IDllNzUwOThkMWYyLi5hY2E1ZmM2MmRiZSAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUt dmVjdG9yaXplci5oCisrKyBiL2djYy90cmVlLXZlY3Rvcml6ZXIuaApAQCAtMTE3LDYgKzExNywx NSBAQCB0eXBlZGVmIHN0cnVjdCBfc2xwX3RyZWUgKnNscF90cmVlOwogLyogQSBjb21wdXRhdGlv biB0cmVlIG9mIGFuIFNMUCBpbnN0YW5jZS4gIEVhY2ggbm9kZSBjb3JyZXNwb25kcyB0byBhIGdy b3VwIG9mCiAgICBzdG10cyB0byBiZSBwYWNrZWQgaW4gYSBTSU1EIHN0bXQuICAqLwogc3RydWN0 IF9zbHBfdHJlZSB7CisgIF9zbHBfdHJlZSgpOworICB+X3NscF90cmVlKCk7CisKKyAgZW51bSBr aW5kIHsgU0xQX09USEVSLCBTTFBfQ1BFUk0gfTsKKyAga2luZCBjbGFzc2lmeSAoKTsKKworICAv KiBOdW1iZXIgb2YgKHNjYWxhcikgbGFuZXMgcHJvZHVjZWQgYnkgdGhpcyBub2RlLiAgKi8KKyAg dW5zaWduZWQgbl9sYW5lcyAoKTsKKwogICAvKiBOb2RlcyB0aGF0IGNvbnRhaW4gZGVmLXN0bXRz IG9mIHRoaXMgbm9kZSBzdGF0ZW1lbnRzIG9wZXJhbmRzLiAgKi8KICAgdmVjPHNscF90cmVlPiBj aGlsZHJlbjsKIApAQCAtMTI4LDcgKzEzNywxMiBAQCBzdHJ1Y3QgX3NscF90cmVlIHsKICAgLyog TG9hZCBwZXJtdXRhdGlvbiByZWxhdGl2ZSB0byB0aGUgc3RvcmVzLCBOVUxMIGlmIHRoZXJlIGlz IG5vCiAgICAgIHBlcm11dGF0aW9uLiAgKi8KICAgdmVjPHVuc2lnbmVkPiBsb2FkX3Blcm11dGF0 aW9uOworICAvKiBMYW5lIHBlcm11dGF0aW9uIG9mIHRoZSBvcGVyYW5kcyBzY2FsYXIgbGFuZXMg ZW5jb2RlZCBhcyBwYWlycworICAgICBvZiB7IG9wZXJhbmQgbnVtYmVyLCBsYW5lIG51bWJlciB9 LiAgVGhlIG51bWJlciBvZiBlbGVtZW50cworICAgICBkZW5vdGVzIHRoZSBudW1iZXIgb2Ygb3V0 cHV0IGxhbmVzLiAgKi8KKyAgdmVjPHN0ZDo6cGFpcjx1bnNpZ25lZCwgdW5zaWduZWQ+ID4gbGFu ZV9wZXJtdXRhdGlvbjsKIAorICB0cmVlIHZlY3R5cGU7CiAgIC8qIFZlY3Rvcml6ZWQgc3RtdC9z LiAgKi8KICAgdmVjPHN0bXRfdmVjX2luZm8+IHZlY19zdG10czsKICAgLyogTnVtYmVyIG9mIHZl Y3RvciBzdG10cyB0aGF0IGFyZSBjcmVhdGVkIHRvIHJlcGxhY2UgdGhlIGdyb3VwIG9mIHNjYWxh cgpAQCAtMTQyLDEwICsxNTYsMTAgQEAgc3RydWN0IF9zbHBfdHJlZSB7CiAgIC8qIFRoZSBtYXhp bXVtIG51bWJlciBvZiB2ZWN0b3IgZWxlbWVudHMgZm9yIHRoZSBzdWJ0cmVlIHJvb3RlZAogICAg ICBhdCB0aGlzIG5vZGUuICAqLwogICBwb2x5X3VpbnQ2NCBtYXhfbnVuaXRzOwotICAvKiBXaGV0 aGVyIHRoZSBzY2FsYXIgY29tcHV0YXRpb25zIHVzZSB0d28gZGlmZmVyZW50IG9wZXJhdG9ycy4g ICovCi0gIGJvb2wgdHdvX29wZXJhdG9yczsKICAgLyogVGhlIERFRiB0eXBlIG9mIHRoaXMgbm9k ZS4gICovCiAgIGVudW0gdmVjdF9kZWZfdHlwZSBkZWZfdHlwZTsKKyAgLyogVGhlIG9wZXJhdGlv biBvZiB0aGlzIG5vZGUuICAqLworICBlbnVtIHRyZWVfY29kZSBjb2RlOwogfTsKIAogCkBAIC0x ODMsOCArMTk3LDEwIEBAIHB1YmxpYzoKICNkZWZpbmUgU0xQX1RSRUVfVkVDX1NUTVRTKFMpICAg ICAgICAgICAgICAgICAgICAoUyktPnZlY19zdG10cwogI2RlZmluZSBTTFBfVFJFRV9OVU1CRVJf T0ZfVkVDX1NUTVRTKFMpICAgICAgICAgIChTKS0+dmVjX3N0bXRzX3NpemUKICNkZWZpbmUgU0xQ X1RSRUVfTE9BRF9QRVJNVVRBVElPTihTKSAgICAgICAgICAgICAoUyktPmxvYWRfcGVybXV0YXRp b24KLSNkZWZpbmUgU0xQX1RSRUVfVFdPX09QRVJBVE9SUyhTKQkJIChTKS0+dHdvX29wZXJhdG9y cworI2RlZmluZSBTTFBfVFJFRV9MQU5FX1BFUk1VVEFUSU9OKFMpICAgICAgICAgICAgIChTKS0+ bGFuZV9wZXJtdXRhdGlvbgogI2RlZmluZSBTTFBfVFJFRV9ERUZfVFlQRShTKQkJCSAoUyktPmRl Zl90eXBlCisjZGVmaW5lIFNMUF9UUkVFX0NPREUoUykJCQkgKFMpLT5jb2RlCisjZGVmaW5lIFNM UF9UUkVFX1ZFQ1RZUEUoUykJCQkgKFMpLT52ZWN0eXBlCiAKIC8qIEtleSBmb3IgbWFwIHRoYXQg cmVjb3JkcyBhc3NvY2lhdGlvbiBiZXR3ZWVuCiAgICBzY2FsYXIgY29uZGl0aW9ucyBhbmQgY29y cmVzcG9uZGluZyBsb29wIG1hc2ssIGFuZAo= --000000000000b27b9005a0bb2c1f--