From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 877 invoked by alias); 4 Jun 2018 08:18:55 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 129483 invoked by uid 89); 4 Jun 2018 08:18:51 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.4 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=ABS, wi, integral, this X-HELO: mail-lf0-f67.google.com Received: from mail-lf0-f67.google.com (HELO mail-lf0-f67.google.com) (209.85.215.67) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 04 Jun 2018 08:18:47 +0000 Received: by mail-lf0-f67.google.com with SMTP id q11-v6so23786589lfc.7 for ; Mon, 04 Jun 2018 01:18:46 -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:in-reply-to:references:from:date :message-id:subject:to:cc; bh=n9l+fJgF/hAOPDnVofRXMDHRwGoUQCNSm1M/vPuuTlE=; b=lcVOfp9zEed+zMJR8/2/7GeLQdTG/LeMJCImPme1v+kyylNEVfXWddJ0+ppewjEY16 dFkkuF4Y1gOMrCgazxGH3FQ2lgZR3zSeKxdV+3c9p2muLyKcTjEZahMlQHH9YpqVc2Vc sPd61VRusuHiLenoTw5/CuVX6nzbJRNjVBx6cKQkpLSZAuLVwLwE7qSQ722GKBrKhvzy dxRKPTEnqGnLS2GKFQW5A7VCwmz89Ar/KFkYUAJdhXD8xNZ1z27nme9IgbGn4MLwzLPC 9soAnVyWAFu06EKWTL0KHY+emK30wjrSD42ccWoeIJx2crSjFzV4vn7LXMiZgdSpuNQK 7uSA== X-Gm-Message-State: ALKqPwcnXr5LsLF5eDTgE1kqcWKUyPNeKPWQA93OYu3sdzJ/03gqCQpL ZEL/Ewq0RaXgU0Ld7ib6KJDrHU1Gnh+fuUDSXeJsPQ== X-Google-Smtp-Source: ADUXVKKo3ZGviu7jNXFUg9PrbxwZSjeJbLCyy0tVdai2kV+p41suByJ9iZUKSz2VBGttunntY0zWVDCKsfcS7UBNwDY= X-Received: by 2002:a19:380a:: with SMTP id f10-v6mr12643398lfa.47.1528100324178; Mon, 04 Jun 2018 01:18:44 -0700 (PDT) MIME-Version: 1.0 Received: by 2002:a2e:5853:0:0:0:0:0 with HTTP; Mon, 4 Jun 2018 01:18:03 -0700 (PDT) In-Reply-To: References: From: Kugan Vivekanandarajah Date: Mon, 04 Jun 2018 08:18:00 -0000 Message-ID: Subject: Re: [RFC][PR64946] "abs" vectorization fails for char/short types To: Richard Biener Cc: Andrew Pinski , GCC Patches Content-Type: multipart/mixed; boundary="00000000000001a87b056dcc954d" X-IsSubscribed: yes X-SW-Source: 2018-06/txt/msg00115.txt.bz2 --00000000000001a87b056dcc954d Content-Type: text/plain; charset="UTF-8" Content-length: 13548 Hi Richard, Thanks for the review. On 1 June 2018 at 22:20, Richard Biener wrote: > On Fri, Jun 1, 2018 at 4:12 AM Kugan Vivekanandarajah > wrote: >> >> Hi Richard, >> >> This is the revised patch based on the review and the discussion in >> https://gcc.gnu.org/ml/gcc/2018-05/msg00179.html. >> >> In summary: >> - I skipped (element_precision (type) < element_precision (TREE_TYPE >> (@0))) in the match.pd pattern as this would prevent transformation >> for the case in PR. >> that is, I am interested in is something like: >> char t = (char) ABS_EXPR <(int) x> >> and I want to generate >> char t = (char) ABSU_EXPR >> >> - I also haven't added all the necessary match.pd changes for >> ABSU_EXPR. I have a patch for that but will submit separately based on >> this reveiw. >> >> - I also tried to add ABSU_EXPRsupport in the places as necessary by >> grepping for ABS_EXPR. >> >> - I also had to add special casing in vectorizer for ABSU_EXP as its >> result is unsigned type. >> >> Is this OK. Patch bootstraps and the regression test is ongoing. > > The c/c-typeck.c:build_unary_op change looks unnecessary - the > C FE should never generate this directly (the c-common one might > be triggered by early folding I guess). The Gimple FE testcase is running into this. > > @@ -1761,6 +1762,9 @@ const_unop (enum tree_code code, tree type, tree arg0) > if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST) > return fold_abs_const (arg0, type); > break; > + case ABSU_EXPR: > + return fold_convert (type, fold_abs_const (arg0, > + signed_type_for (type))); > > case CONJ_EXPR: > > I think this will get you bogus TREE_OVERFLOW flags set on ABSU (-INT_MIN). > > I think you want to change fold_abs_const to properly deal with arg0 being > signed and type unsigned. That is, sth like > > diff --git a/gcc/fold-const.c b/gcc/fold-const.c > index 6f80f1b1d69..f60f9c77e91 100644 > --- a/gcc/fold-const.c > +++ b/gcc/fold-const.c > @@ -13843,18 +13843,19 @@ fold_abs_const (tree arg0, tree type) > { > /* If the value is unsigned or non-negative, then the absolute value > is the same as the ordinary value. */ > - if (!wi::neg_p (wi::to_wide (arg0), TYPE_SIGN (type))) > - t = arg0; > + wide_int val = wi::to_wide (arg0); > + bool overflow = false; > + if (!wi::neg_p (val, TYPE_SIGN (TREE_TYPE (arg0)))) > + ; > > /* If the value is negative, then the absolute value is > its negation. */ > else > - { > - bool overflow; > - wide_int val = wi::neg (wi::to_wide (arg0), &overflow); > - t = force_fit_type (type, val, -1, > - overflow | TREE_OVERFLOW (arg0)); > - } > + wide_int val = wi::neg (val, &overflow); > + > + /* Force to the destination type, set TREE_OVERFLOW for signed > + TYPE only. */ > + t = force_fit_type (type, val, 1, overflow | TREE_OVERFLOW (arg0)); > } > break; > > and then simply share the const_unop code with ABS_EXPR. Done. > diff --git a/gcc/match.pd b/gcc/match.pd > index 14386da..7d7c132 100644 > --- a/gcc/match.pd > +++ b/gcc/match.pd > @@ -102,6 +102,14 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) > (match (nop_convert @0) > @0) > > +(simplify (abs (convert @0)) > + (if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (@0)) > + && !TYPE_UNSIGNED (TREE_TYPE (@0)) > + && !TYPE_UNSIGNED (type)) > + (with { tree utype = unsigned_type_for (TREE_TYPE (@0)); } > + (convert (absu:utype @0))))) > + > + > > please put a comment before the pattern. I believe there's no > need to check for !TYPE_UNSIGNED (type). Note this > also converts abs ((char)int-var) to (char)absu(int-var) which > doesn't make sense. The original issue you want to address > here is the case where TYPE_PRECISION of @0 is less than > the precision of type. That is, you want to remove language > introduced integer promotion of @0 which only is possible > with ABSU. So please do add such precision check > (I simply suggested the bogus direction of the test). Done. > > diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c > index 68f4fd3..9b62583 100644 > --- a/gcc/tree-cfg.c > +++ b/gcc/tree-cfg.c > @@ -3685,6 +3685,12 @@ verify_gimple_assign_unary (gassign *stmt) > case PAREN_EXPR: > case CONJ_EXPR: > break; > + case ABSU_EXPR: > + if (!TYPE_UNSIGNED (lhs_type) > + || !ANY_INTEGRAL_TYPE_P (rhs1_type)) > > if (!ANY_INTEGRAL_TYPE_P (lhs_type) > || !TYPE_UNSIGNED (lhs_type) > || !ANY_INTEGRAL_TYPE_P (rhs1_type) > || TYPE_UNSIGNED (rhs1_type) > || element_precision (lhs_type) != element_precision (rhs1_type)) > { > error ("invalid types for ABSU_EXPR"); > debug_generic_expr (lhs_type); > debug_generic_expr (rhs1_type); > return true; > } > > + return true; > + return false; > + break; > > diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c > index 30c6d9e..44b1399 100644 > --- a/gcc/tree-eh.c > +++ b/gcc/tree-eh.c > @@ -2465,6 +2465,7 @@ operation_could_trap_helper_p (enum tree_code op, > > case NEGATE_EXPR: > case ABS_EXPR: > + case ABSU_EXPR: > case CONJ_EXPR: > /* These operations don't trap with floating point. */ > if (honor_trapv) > > ABSU never traps. Please instead unconditionally return false. Done. > > diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c > index 66c78de..b52d714 100644 > --- a/gcc/tree-vect-stmts.c > +++ b/gcc/tree-vect-stmts.c > @@ -5995,7 +5995,11 @@ vectorizable_operation (gimple *stmt, > gimple_stmt_iterator *gsi, > "transform binary/unary operation.\n"); > > /* Handle def. */ > - vec_dest = vect_create_destination_var (scalar_dest, vectype); > + if (code == ABSU_EXPR) > + vec_dest = vect_create_destination_var (scalar_dest, > + unsigned_type_for (vectype)); > + else > + vec_dest = vect_create_destination_var (scalar_dest, vectype); > > /* POINTER_DIFF_EXPR has pointer arguments which are vectorized as > vectors with unsigned elements, but the result is signed. So, we > > simply use vectype_out for creation of vec_dest. Done. > > diff --git a/gcc/tree.def b/gcc/tree.def > index c660b2c..5fec781 100644 > --- a/gcc/tree.def > +++ b/gcc/tree.def > @@ -760,6 +760,7 @@ DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2) > An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE. The > operand of the ABS_EXPR must have the same type. */ > DEFTREECODE (ABS_EXPR, "abs_expr", tcc_unary, 1) > +DEFTREECODE (ABSU_EXPR, "absu_expr", tcc_unary, 1) > > /* Shift operations for shift and rotate. > Shift means logical shift if done on an > > You can clearly see that the comment before ABS_EXPR doesn't apply to ABSU_EXPR > so please add an appropriate one. I suggest > > /* Represents the unsigned absolute value of the operand. > An ABSU_EXPR must have unsigned INTEGER_TYPE. The operand of the ABSU_EXPR > must have the corresponding signed type. */ Done. Here is the reviesed patch. Is this OK? Thanks, Kugan > > Otherwise looks OK. (I didn't explicitely check for missing ABSU_EXPR > handling this time) > > Thanks, > Richard. > > >> Thanks, >> Kugan >> >> >> On 18 May 2018 at 12:36, Kugan Vivekanandarajah >> wrote: >> > Hi Richard, >> > >> > Thanks for the review. I am revising the patch based on Andrew's comments too. >> > >> > On 17 May 2018 at 20:36, Richard Biener wrote: >> >> On Thu, May 17, 2018 at 4:56 AM Andrew Pinski wrote: >> >> >> >>> On Wed, May 16, 2018 at 7:14 PM, Kugan Vivekanandarajah >> >>> wrote: >> >>> > As mentioned in the PR, I am trying to add ABSU_EXPR to fix this >> >>> > issue. In the attached patch, in fold_cond_expr_with_comparison I am >> >>> > generating ABSU_EXPR for these cases. As I understand, absu_expr is >> >>> > well defined in RTL. So, the issue is generating absu_expr and >> >>> > transferring to RTL in the correct way. I am not sure I am not doing >> >>> > all that is needed. I will clean up and add more test-cases based on >> >>> > the feedback. >> >> >> >> >> >>> diff --git a/gcc/optabs-tree.c b/gcc/optabs-tree.c >> >>> index 71e172c..2b812e5 100644 >> >>> --- a/gcc/optabs-tree.c >> >>> +++ b/gcc/optabs-tree.c >> >>> @@ -235,6 +235,7 @@ optab_for_tree_code (enum tree_code code, const_tree >> >> type, >> >>> return trapv ? negv_optab : neg_optab; >> >> >> >>> case ABS_EXPR: >> >>> + case ABSU_EXPR: >> >>> return trapv ? absv_optab : abs_optab; >> >> >> >> >> >>> This part is not correct, it should something like this: >> >> >> >>> case ABS_EXPR: >> >>> return trapv ? absv_optab : abs_optab; >> >>> + case ABSU_EXPR: >> >>> + return abs_optab ; >> >> >> >>> Because ABSU is not undefined at the TYPE_MAX. >> >> >> >> Also >> >> >> >> /* Unsigned abs is simply the operand. Testing here means we don't >> >> risk generating incorrect code below. */ >> >> - if (TYPE_UNSIGNED (type)) >> >> + if (TYPE_UNSIGNED (type) >> >> + && (code != ABSU_EXPR)) >> >> return op0; >> >> >> >> is wrong. ABSU of an unsigned number is still just that number. >> >> >> >> The change to fold_cond_expr_with_comparison looks odd to me >> >> (premature optimization). It should be done separately - it seems >> >> you are doing >> > >> > FE seems to be using this to generate ABS_EXPR from >> > c_fully_fold_internal to fold_build3_loc and so on. I changed this to >> > generate ABSU_EXPR for the case in the testcase. So the question >> > should be, in what cases do we need ABS_EXPR and in what cases do we >> > need ABSU_EXPR. It is not very clear to me. >> > >> > >> >> >> >> (simplify (abs (convert @0)) (convert (absu @0))) >> >> >> >> here. >> >> >> >> You touch one other place in fold-const.c but there seem to be many >> >> more that need ABSU_EXPR handling (you touched the one needed >> >> for correctness) - esp. you should at least handle constant folding >> >> in const_unop and the nonnegative predicate. >> > >> > OK. >> >> >> >> @@ -3167,6 +3167,9 @@ verify_expr (tree *tp, int *walk_subtrees, void *data >> >> ATTRIBUTE_UNUSED) >> >> CHECK_OP (0, "invalid operand to unary operator"); >> >> break; >> >> >> >> + case ABSU_EXPR: >> >> + break; >> >> + >> >> case REALPART_EXPR: >> >> case IMAGPART_EXPR: >> >> >> >> verify_expr is no more. Did you test this recently against trunk? >> > >> > This patch is against slightly older trunk. I will rebase it. >> > >> >> >> >> @@ -3937,6 +3940,9 @@ verify_gimple_assign_unary (gassign *stmt) >> >> case PAREN_EXPR: >> >> case CONJ_EXPR: >> >> break; >> >> + case ABSU_EXPR: >> >> + /* FIXME. */ >> >> + return false; >> >> >> >> no - please not! Please add verification here - ABSU should be only >> >> called on INTEGRAL, vector or complex INTEGRAL types and the >> >> type of the LHS should be always the unsigned variant of the >> >> argument type. >> > >> > OK. >> >> >> >> if (is_gimple_val (cond_expr)) >> >> return cond_expr; >> >> >> >> - if (TREE_CODE (cond_expr) == ABS_EXPR) >> >> + if (TREE_CODE (cond_expr) == ABS_EXPR >> >> + || TREE_CODE (cond_expr) == ABSU_EXPR) >> >> { >> >> rhs1 = TREE_OPERAND (cond_expr, 1); >> >> STRIP_USELESS_TYPE_CONVERSION (rhs1); >> >> >> >> err, but the next line just builds a ABS_EXPR ... >> >> >> >> How did you identify spots that need adjustment? I would expect that >> >> once folding generates ABSU_EXPR that you need to adjust frontends >> >> (C++ constexpr handling for example). Also I miss adjustments >> >> to gimple-pretty-print.c and the GIMPLE FE parser. >> > >> > I will add this. >> >> >> >> recursively grepping throughout the whole gcc/ tree doesn't reveal too many >> >> cases of ABS_EXPR so I think it's reasonable to audit all of them. >> >> >> >> I also miss some trivial absu simplifications in match.pd. There are not >> >> a lot of abs cases but similar ones would be good to have initially. >> > >> > I will add them in the next version. >> > >> > Thanks, >> > Kugan >> > >> >> >> >> Thanks for tackling this! >> >> Richard. >> >> >> >>> Thanks, >> >>> Andrew >> >> >> >>> > >> >>> > Thanks, >> >>> > Kugan >> >>> > >> >>> > >> >>> > gcc/ChangeLog: >> >>> > >> >>> > 2018-05-13 Kugan Vivekanandarajah >> >>> > >> >>> > * expr.c (expand_expr_real_2): Handle ABSU_EXPR. >> >>> > * fold-const.c (fold_cond_expr_with_comparison): Generate ABSU_EXPR >> >>> > (fold_unary_loc): Handle ABSU_EXPR. >> >>> > * optabs-tree.c (optab_for_tree_code): Likewise. >> >>> > * tree-cfg.c (verify_expr): Likewise. >> >>> > (verify_gimple_assign_unary): Likewise. >> >>> > * tree-if-conv.c (fold_build_cond_expr): Likewise. >> >>> > * tree-inline.c (estimate_operator_cost): Likewise. >> >>> > * tree-pretty-print.c (dump_generic_node): Likewise. >> >>> > * tree.def (ABSU_EXPR): New. >> >>> > >> >>> > gcc/testsuite/ChangeLog: >> >>> > >> >>> > 2018-05-13 Kugan Vivekanandarajah >> >>> > >> >>> > * gcc.dg/absu.c: New test. --00000000000001a87b056dcc954d Content-Type: text/plain; charset="US-ASCII"; name="absu_v3.txt" Content-Disposition: attachment; filename="absu_v3.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_jhzzg2zk0 Content-length: 20960 ZGlmZiAtLWdpdCBhL2djYy9jLWZhbWlseS9jLWNvbW1vbi5jIGIvZ2NjL2Mt ZmFtaWx5L2MtY29tbW9uLmMKaW5kZXggODU5ZWViNC4uMGU4ZWZiNSAxMDA2 NDQKLS0tIGEvZ2NjL2MtZmFtaWx5L2MtY29tbW9uLmMKKysrIGIvZ2NjL2Mt ZmFtaWx5L2MtY29tbW9uLmMKQEAgLTMzMTIsNiArMzMxMiw3IEBAIGNfY29t bW9uX3RydXRodmFsdWVfY29udmVyc2lvbiAobG9jYXRpb25fdCBsb2NhdGlv biwgdHJlZSBleHByKQogCiAgICAgY2FzZSBORUdBVEVfRVhQUjoKICAgICBj YXNlIEFCU19FWFBSOgorICAgIGNhc2UgQUJTVV9FWFBSOgogICAgIGNhc2Ug RkxPQVRfRVhQUjoKICAgICBjYXNlIEVYQ0VTU19QUkVDSVNJT05fRVhQUjoK ICAgICAgIC8qIFRoZXNlIGRvbid0IGNoYW5nZSB3aGV0aGVyIGFuIG9iamVj dCBpcyBub256ZXJvIG9yIHplcm8uICAqLwpkaWZmIC0tZ2l0IGEvZ2NjL2Mv Yy10eXBlY2suYyBiL2djYy9jL2MtdHlwZWNrLmMKaW5kZXggNDVhNDUyOS4u NWJiNjgwNCAxMDA2NDQKLS0tIGEvZ2NjL2MvYy10eXBlY2suYworKysgYi9n Y2MvYy9jLXR5cGVjay5jCkBAIC00MzE0LDYgKzQzMTQsMTYgQEAgYnVpbGRf dW5hcnlfb3AgKGxvY2F0aW9uX3QgbG9jYXRpb24sIGVudW0gdHJlZV9jb2Rl IGNvZGUsIHRyZWUgeGFyZywKIAlhcmcgPSBkZWZhdWx0X2NvbnZlcnNpb24g KGFyZyk7CiAgICAgICBicmVhazsKIAorICAgIGNhc2UgQUJTVV9FWFBSOgor ICAgICAgaWYgKCEodHlwZWNvZGUgPT0gSU5URUdFUl9UWVBFKSkKKwl7CisJ ICBlcnJvcl9hdCAobG9jYXRpb24sICJ3cm9uZyB0eXBlIGFyZ3VtZW50IHRv IGFic3UiKTsKKwkgIHJldHVybiBlcnJvcl9tYXJrX25vZGU7CisJfQorICAg ICAgZWxzZSBpZiAoIW5vY29udmVydCkKKwlhcmcgPSBkZWZhdWx0X2NvbnZl cnNpb24gKGFyZyk7CisgICAgICBicmVhazsKKwogICAgIGNhc2UgQ09OSl9F WFBSOgogICAgICAgLyogQ29uanVnYXRpbmcgYSByZWFsIHZhbHVlIGlzIGEg bm8tb3AsIGJ1dCBhbGxvdyBpdCBhbnl3YXkuICAqLwogICAgICAgaWYgKCEo dHlwZWNvZGUgPT0gSU5URUdFUl9UWVBFIHx8IHR5cGVjb2RlID09IFJFQUxf VFlQRQpkaWZmIC0tZ2l0IGEvZ2NjL2MvZ2ltcGxlLXBhcnNlci5jIGIvZ2Nj L2MvZ2ltcGxlLXBhcnNlci5jCmluZGV4IGM5YWJlMjQuLjExZTc2ZmYgMTAw NjQ0Ci0tLSBhL2djYy9jL2dpbXBsZS1wYXJzZXIuYworKysgYi9nY2MvYy9n aW1wbGUtcGFyc2VyLmMKQEAgLTMyOCw3ICszMjgsOCBAQCBjX3BhcnNlcl9n aW1wbGVfc3RhdGVtZW50IChjX3BhcnNlciAqcGFyc2VyLCBnaW1wbGVfc2Vx ICpzZXEpCiAgICAgY2FzZSBDUFBfTkFNRToKICAgICAgIHsKIAl0cmVlIGlk ID0gY19wYXJzZXJfcGVla190b2tlbiAocGFyc2VyKS0+dmFsdWU7Ci0JaWYg KHN0cmNtcCAoSURFTlRJRklFUl9QT0lOVEVSIChpZCksICJfX0FCUyIpID09 IDApCisJaWYgKHN0cmNtcCAoSURFTlRJRklFUl9QT0lOVEVSIChpZCksICJf X0FCUyIpID09IDAKKwkgICAgfHwgc3RyY21wIChJREVOVElGSUVSX1BPSU5U RVIgKGlkKSwgIl9fQUJTVSIpID09IDApCiAJICBnb3RvIGJ1aWxkX3VuYXJ5 X2V4cHI7CiAJYnJlYWs7CiAgICAgICB9CkBAIC02MzgsNiArNjM5LDEyIEBA IGNfcGFyc2VyX2dpbXBsZV91bmFyeV9leHByZXNzaW9uIChjX3BhcnNlciAq cGFyc2VyKQogCSAgICAgIG9wID0gY19wYXJzZXJfZ2ltcGxlX3Bvc3RmaXhf ZXhwcmVzc2lvbiAocGFyc2VyKTsKIAkgICAgICByZXR1cm4gcGFyc2VyX2J1 aWxkX3VuYXJ5X29wIChvcF9sb2MsIEFCU19FWFBSLCBvcCk7CiAJICAgIH0K KwkgIGVsc2UgaWYgKHN0cmNtcCAoSURFTlRJRklFUl9QT0lOVEVSIChpZCks ICJfX0FCU1UiKSA9PSAwKQorCSAgICB7CisJICAgICAgY19wYXJzZXJfY29u c3VtZV90b2tlbiAocGFyc2VyKTsKKwkgICAgICBvcCA9IGNfcGFyc2VyX2dp bXBsZV9wb3N0Zml4X2V4cHJlc3Npb24gKHBhcnNlcik7CisJICAgICAgcmV0 dXJuIHBhcnNlcl9idWlsZF91bmFyeV9vcCAob3BfbG9jLCBBQlNVX0VYUFIs IG9wKTsKKwkgICAgfQogCSAgZWxzZQogCSAgICByZXR1cm4gY19wYXJzZXJf Z2ltcGxlX3Bvc3RmaXhfZXhwcmVzc2lvbiAocGFyc2VyKTsKIAl9CmRpZmYg LS1naXQgYS9nY2MvY2ZnZXhwYW5kLmMgYi9nY2MvY2ZnZXhwYW5kLmMKaW5k ZXggZWYxNDNhMy4uYmE0NTQzYyAxMDA2NDQKLS0tIGEvZ2NjL2NmZ2V4cGFu ZC5jCisrKyBiL2djYy9jZmdleHBhbmQuYwpAQCAtNDYyMSw2ICs0NjIxLDcg QEAgZXhwYW5kX2RlYnVnX2V4cHIgKHRyZWUgZXhwKQogICAgICAgfQogCiAg ICAgY2FzZSBBQlNfRVhQUjoKKyAgICBjYXNlIEFCU1VfRVhQUjoKICAgICAg IHJldHVybiBzaW1wbGlmeV9nZW5fdW5hcnkgKEFCUywgbW9kZSwgb3AwLCBt b2RlKTsKIAogICAgIGNhc2UgTkVHQVRFX0VYUFI6CmRpZmYgLS1naXQgYS9n Y2MvY29uZmlnL2kzODYvaTM4Ni5jIGIvZ2NjL2NvbmZpZy9pMzg2L2kzODYu YwppbmRleCBlMTk4NjRkLi40ODcxMjdjIDEwMDY0NAotLS0gYS9nY2MvY29u ZmlnL2kzODYvaTM4Ni5jCisrKyBiL2djYy9jb25maWcvaTM4Ni9pMzg2LmMK QEAgLTUxMjI4LDYgKzUxMjI4LDcgQEAgaXg4Nl9hZGRfc3RtdF9jb3N0ICh2 b2lkICpkYXRhLCBpbnQgY291bnQsIGVudW0gdmVjdF9jb3N0X2Zvcl9zdG10 IGtpbmQsCiAKIAljYXNlIEJJVF9JT1JfRVhQUjoKIAljYXNlIEFCU19FWFBS OgorCWNhc2UgQUJTVV9FWFBSOgogCWNhc2UgTUlOX0VYUFI6CiAJY2FzZSBN QVhfRVhQUjoKIAljYXNlIEJJVF9YT1JfRVhQUjoKZGlmZiAtLWdpdCBhL2dj Yy9jcC9jb25zdGV4cHIuYyBiL2djYy9jcC9jb25zdGV4cHIuYwppbmRleCA4 YzZlYzU1Li5iZWE5MTQ3IDEwMDY0NAotLS0gYS9nY2MvY3AvY29uc3RleHBy LmMKKysrIGIvZ2NjL2NwL2NvbnN0ZXhwci5jCkBAIC01NzYwLDYgKzU3NjAs NyBAQCBwb3RlbnRpYWxfY29uc3RhbnRfZXhwcmVzc2lvbl8xICh0cmVlIHQs IGJvb2wgd2FudF9ydmFsLCBib29sIHN0cmljdCwgYm9vbCBub3csCiAgICAg Y2FzZSBGTE9BVF9FWFBSOgogICAgIGNhc2UgTkVHQVRFX0VYUFI6CiAgICAg Y2FzZSBBQlNfRVhQUjoKKyAgICBjYXNlIEFCU1VfRVhQUjoKICAgICBjYXNl IFRSVVRIX05PVF9FWFBSOgogICAgIGNhc2UgRklYRURfQ09OVkVSVF9FWFBS OgogICAgIGNhc2UgVU5BUllfUExVU19FWFBSOgpkaWZmIC0tZ2l0IGEvZ2Nj L2NwL2NwLWdpbXBsaWZ5LmMgYi9nY2MvY3AvY3AtZ2ltcGxpZnkuYwppbmRl eCBlZGE1ZjA1Li5iY2EwYzU5IDEwMDY0NAotLS0gYS9nY2MvY3AvY3AtZ2lt cGxpZnkuYworKysgYi9nY2MvY3AvY3AtZ2ltcGxpZnkuYwpAQCAtMjI3MSw2 ICsyMjcxLDcgQEAgY3BfZm9sZCAodHJlZSB4KQogICAgIGNhc2UgRkxPQVRf RVhQUjoKICAgICBjYXNlIE5FR0FURV9FWFBSOgogICAgIGNhc2UgQUJTX0VY UFI6CisgICAgY2FzZSBBQlNVX0VYUFI6CiAgICAgY2FzZSBCSVRfTk9UX0VY UFI6CiAgICAgY2FzZSBUUlVUSF9OT1RfRVhQUjoKICAgICBjYXNlIEZJWEVE X0NPTlZFUlRfRVhQUjoKZGlmZiAtLWdpdCBhL2djYy9kb2p1bXAuYyBiL2dj Yy9kb2p1bXAuYwppbmRleCA5ZGE4YTBlLi44OGNjOTZhIDEwMDY0NAotLS0g YS9nY2MvZG9qdW1wLmMKKysrIGIvZ2NjL2RvanVtcC5jCkBAIC00NjcsNiAr NDY3LDcgQEAgZG9fanVtcCAodHJlZSBleHAsIHJ0eF9jb2RlX2xhYmVsICpp Zl9mYWxzZV9sYWJlbCwKICAgICAgIC8qIEZBTExUSFJVICovCiAgICAgY2Fz ZSBOT05fTFZBTFVFX0VYUFI6CiAgICAgY2FzZSBBQlNfRVhQUjoKKyAgICBj YXNlIEFCU1VfRVhQUjoKICAgICBjYXNlIE5FR0FURV9FWFBSOgogICAgIGNh c2UgTFJPVEFURV9FWFBSOgogICAgIGNhc2UgUlJPVEFURV9FWFBSOgpkaWZm IC0tZ2l0IGEvZ2NjL2V4cHIuYyBiL2djYy9leHByLmMKaW5kZXggMDBhODAy Yy4uOWVmYTUzNSAxMDA2NDQKLS0tIGEvZ2NjL2V4cHIuYworKysgYi9nY2Mv ZXhwci5jCkBAIC05MDc0LDYgKzkwNzQsNyBAQCBleHBhbmRfZXhwcl9yZWFs XzIgKHNlcG9wcyBvcHMsIHJ0eCB0YXJnZXQsIG1hY2hpbmVfbW9kZSB0bW9k ZSwKICAgICAgIHJldHVybiBSRURVQ0VfQklUX0ZJRUxEICh0ZW1wKTsKIAog ICAgIGNhc2UgQUJTX0VYUFI6CisgICAgY2FzZSBBQlNVX0VYUFI6CiAgICAg ICBvcDAgPSBleHBhbmRfZXhwciAodHJlZW9wMCwgc3VidGFyZ2V0LAogCQkJ IFZPSURtb2RlLCBFWFBBTkRfTk9STUFMKTsKICAgICAgIGlmIChtb2RpZmll ciA9PSBFWFBBTkRfU1RBQ0tfUEFSTSkKQEAgLTkwODUsNyArOTA4Niw3IEBA IGV4cGFuZF9leHByX3JlYWxfMiAoc2Vwb3BzIG9wcywgcnR4IHRhcmdldCwg bWFjaGluZV9tb2RlIHRtb2RlLAogCiAgICAgICAvKiBVbnNpZ25lZCBhYnMg aXMgc2ltcGx5IHRoZSBvcGVyYW5kLiAgVGVzdGluZyBoZXJlIG1lYW5zIHdl IGRvbid0CiAJIHJpc2sgZ2VuZXJhdGluZyBpbmNvcnJlY3QgY29kZSBiZWxv dy4gICovCi0gICAgICBpZiAoVFlQRV9VTlNJR05FRCAodHlwZSkpCisgICAg ICBpZiAoVFlQRV9VTlNJR05FRCAoVFJFRV9UWVBFICh0cmVlb3AwKSkpCiAJ cmV0dXJuIG9wMDsKIAogICAgICAgcmV0dXJuIGV4cGFuZF9hYnMgKG1vZGUs IG9wMCwgdGFyZ2V0LCB1bnNpZ25lZHAsCmRpZmYgLS1naXQgYS9nY2MvZm9s ZC1jb25zdC5jIGIvZ2NjL2ZvbGQtY29uc3QuYwppbmRleCBmYWExODRhLi5j MTk2MTRlIDEwMDY0NAotLS0gYS9nY2MvZm9sZC1jb25zdC5jCisrKyBiL2dj Yy9mb2xkLWNvbnN0LmMKQEAgLTE3MjMsNyArMTcyMyw4IEBAIGNvbnN0X3Vu b3AgKGVudW0gdHJlZV9jb2RlIGNvZGUsIHRyZWUgdHlwZSwgdHJlZSBhcmcw KQogICAgICAgJiYgSE9OT1JfU05BTlMgKFRZUEVfTU9ERSAoVFJFRV9UWVBF IChhcmcwKSkpCiAgICAgICAmJiBSRUFMX1ZBTFVFX0lTU0lHTkFMSU5HX05B TiAoVFJFRV9SRUFMX0NTVCAoYXJnMCkpCiAgICAgICAmJiBjb2RlICE9IE5F R0FURV9FWFBSCi0gICAgICAmJiBjb2RlICE9IEFCU19FWFBSKQorICAgICAg JiYgY29kZSAhPSBBQlNfRVhQUgorICAgICAgJiYgY29kZSAhPSBBQlNVX0VY UFIpCiAgICAgcmV0dXJuIE5VTExfVFJFRTsKIAogICBzd2l0Y2ggKGNvZGUp CkBAIC0xNzU4LDYgKzE3NTksNyBAQCBjb25zdF91bm9wIChlbnVtIHRyZWVf Y29kZSBjb2RlLCB0cmVlIHR5cGUsIHRyZWUgYXJnMCkKICAgICAgIH0KIAog ICAgIGNhc2UgQUJTX0VYUFI6CisgICAgY2FzZSBBQlNVX0VYUFI6CiAgICAg ICBpZiAoVFJFRV9DT0RFIChhcmcwKSA9PSBJTlRFR0VSX0NTVCB8fCBUUkVF X0NPREUgKGFyZzApID09IFJFQUxfQ1NUKQogCXJldHVybiBmb2xkX2Fic19j b25zdCAoYXJnMCwgdHlwZSk7CiAgICAgICBicmVhazsKQEAgLTEzODQ2LDIw ICsxMzg0OCwyMSBAQCBmb2xkX2Fic19jb25zdCAodHJlZSBhcmcwLCB0cmVl IHR5cGUpCiAgICAgICB7CiAgICAgICAgIC8qIElmIHRoZSB2YWx1ZSBpcyB1 bnNpZ25lZCBvciBub24tbmVnYXRpdmUsIHRoZW4gdGhlIGFic29sdXRlIHZh bHVlCiAJICAgaXMgdGhlIHNhbWUgYXMgdGhlIG9yZGluYXJ5IHZhbHVlLiAg Ki8KLQlpZiAoIXdpOjpuZWdfcCAod2k6OnRvX3dpZGUgKGFyZzApLCBUWVBF X1NJR04gKHR5cGUpKSkKLQkgIHQgPSBhcmcwOworCXdpZGVfaW50IHZhbCA9 IHdpOjp0b193aWRlIChhcmcwKTsKKwlib29sIG92ZXJmbG93ID0gZmFsc2U7 CisJaWYgKCF3aTo6bmVnX3AgKHZhbCwgVFlQRV9TSUdOIChUUkVFX1RZUEUg KGFyZzApKSkpCisJICA7CiAKIAkvKiBJZiB0aGUgdmFsdWUgaXMgbmVnYXRp dmUsIHRoZW4gdGhlIGFic29sdXRlIHZhbHVlIGlzCiAJICAgaXRzIG5lZ2F0 aW9uLiAgKi8KIAllbHNlCi0JICB7Ci0JICAgIGJvb2wgb3ZlcmZsb3c7Ci0J ICAgIHdpZGVfaW50IHZhbCA9IHdpOjpuZWcgKHdpOjp0b193aWRlIChhcmcw KSwgJm92ZXJmbG93KTsKLQkgICAgdCA9IGZvcmNlX2ZpdF90eXBlICh0eXBl LCB2YWwsIC0xLAotCQkJCW92ZXJmbG93IHwgVFJFRV9PVkVSRkxPVyAoYXJn MCkpOwotCSAgfQorCSAgdmFsID0gd2k6Om5lZyAodmFsLCAmb3ZlcmZsb3cp OworCisJLyogRm9yY2UgdG8gdGhlIGRlc3RpbmF0aW9uIHR5cGUsIHNldCBU UkVFX09WRVJGTE9XIGZvciBzaWduZWQKKwkgICBUWVBFIG9ubHkuICAqLwor CXQgPSBmb3JjZV9maXRfdHlwZSAodHlwZSwgdmFsLCAxLCBvdmVyZmxvdyB8 IFRSRUVfT1ZFUkZMT1cgKGFyZzApKTsKICAgICAgIH0KLSAgICAgIGJyZWFr OworICAgIGJyZWFrOwogCiAgICAgY2FzZSBSRUFMX0NTVDoKICAgICAgIGlm IChSRUFMX1ZBTFVFX05FR0FUSVZFIChUUkVFX1JFQUxfQ1NUIChhcmcwKSkp CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXByZXR0eS1wcmludC5jIGIvZ2Nj L2dpbXBsZS1wcmV0dHktcHJpbnQuYwppbmRleCBhZmUwMTQ3Li40ZmE5OTJk IDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXByZXR0eS1wcmludC5jCisrKyBi L2djYy9naW1wbGUtcHJldHR5LXByaW50LmMKQEAgLTM1OCwxNCArMzU4LDE3 IEBAIGR1bXBfdW5hcnlfcmhzIChwcmV0dHlfcHJpbnRlciAqYnVmZmVyLCBn YXNzaWduICpncywgaW50IHNwYywKICAgICAgIGJyZWFrOwogCiAgICAgY2Fz ZSBBQlNfRVhQUjoKKyAgICBjYXNlIEFCU1VfRVhQUjoKICAgICAgIGlmIChm bGFncyAmIFRERl9HSU1QTEUpCiAJewotCSAgcHBfc3RyaW5nIChidWZmZXIs ICJfX0FCUyAiKTsKKwkgIHBwX3N0cmluZyAoYnVmZmVyLAorCQkgICAgIHJo c19jb2RlID09IEFCU19FWFBSID8gIl9fQUJTICIgOiAiX19BQlNVICIpOwog CSAgZHVtcF9nZW5lcmljX25vZGUgKGJ1ZmZlciwgcmhzLCBzcGMsIGZsYWdz LCBmYWxzZSk7CiAJfQogICAgICAgZWxzZQogCXsKLQkgIHBwX3N0cmluZyAo YnVmZmVyLCAiQUJTX0VYUFIgPCIpOworCSAgcHBfc3RyaW5nIChidWZmZXIs CisJCSAgICAgcmhzX2NvZGUgPT0gQUJTX0VYUFIgPyAiQUJTX0VYUFIgPCIg OiAiQUJTVV9FWFBSIDwiKTsKIAkgIGR1bXBfZ2VuZXJpY19ub2RlIChidWZm ZXIsIHJocywgc3BjLCBmbGFncywgZmFsc2UpOwogCSAgcHBfZ3JlYXRlciAo YnVmZmVyKTsKIAl9CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXNzYS1iYWNr cHJvcC5jIGIvZ2NjL2dpbXBsZS1zc2EtYmFja3Byb3AuYwppbmRleCAyN2Fh NTc1Li5hMzhiNWViIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXNzYS1iYWNr cHJvcC5jCisrKyBiL2djYy9naW1wbGUtc3NhLWJhY2twcm9wLmMKQEAgLTQw NSw2ICs0MDUsNyBAQCBiYWNrcHJvcDo6cHJvY2Vzc19hc3NpZ25fdXNlIChn YXNzaWduICphc3NpZ24sIHRyZWUgcmhzLCB1c2FnZV9pbmZvICppbmZvKQog ICBzd2l0Y2ggKGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKGFzc2lnbikpCiAg ICAgewogICAgIGNhc2UgQUJTX0VYUFI6CisgICAgY2FzZSBBQlNVX0VYUFI6 CiAgICAgICAvKiBUaGUgc2lnbiBvZiB0aGUgaW5wdXQgZG9lc24ndCBtYXR0 ZXIuICAqLwogICAgICAgaW5mby0+ZmxhZ3MuaWdub3JlX3NpZ24gPSB0cnVl OwogICAgICAgYnJlYWs7CkBAIC02ODEsNiArNjgyLDcgQEAgc3RyaXBfc2ln bl9vcF8xICh0cmVlIHJocykKICAgICBzd2l0Y2ggKGdpbXBsZV9hc3NpZ25f cmhzX2NvZGUgKGFzc2lnbikpCiAgICAgICB7CiAgICAgICBjYXNlIEFCU19F WFBSOgorICAgICAgY2FzZSBBQlNVX0VYUFI6CiAgICAgICBjYXNlIE5FR0FU RV9FWFBSOgogCXJldHVybiBnaW1wbGVfYXNzaWduX3JoczEgKGFzc2lnbik7 CiAKZGlmZiAtLWdpdCBhL2djYy9tYXRjaC5wZCBiL2djYy9tYXRjaC5wZApp bmRleCA3MDMzNzMwLi5iYTUyYmIwIDEwMDY0NAotLS0gYS9nY2MvbWF0Y2gu cGQKKysrIGIvZ2NjL21hdGNoLnBkCkBAIC05MCw2ICs5MCwxNyBAQCBERUZJ TkVfSU5UX0FORF9GTE9BVF9ST1VORF9GTiAoUklOVCkKIChtYXRjaCAobm9w X2NvbnZlcnQgQDApCiAgQDApIAogCisvKiBUcmFuc2Zvcm0gbGlrZXMgb2Yg KGNoYXIpIEFCU19FWFBSIDwoaW50KSB4PiBpbnRvIChjaGFyKSBBQlNVX0VY UFIgPHg+CisgICBBQlNVX0VYUFIgcmV0dXJucyB1bnNpZ25lZCBhYnNvbHV0 ZSB2YWx1ZSBvZiB0aGUgb3BlcmFuZCBhbmQgdGhlIG9wZXJhbmQKKyAgIG9m IHRoZSBBQlNVX0VYUFIgd2lsbCBoYXZlIHRoZSBjb3JyZXNwb25kaW5nIHNp Z25lZCB0eXBlLiAgKi8KKyhzaW1wbGlmeSAoYWJzIChjb252ZXJ0IEAwKSkK KyAoaWYgKEFOWV9JTlRFR1JBTF9UWVBFX1AgKFRSRUVfVFlQRSAoQDApKQor ICAgICAgJiYgIVRZUEVfVU5TSUdORUQgKFRSRUVfVFlQRSAoQDApKQorICAg ICAgJiYgZWxlbWVudF9wcmVjaXNpb24gKHR5cGUpID4gZWxlbWVudF9wcmVj aXNpb24gKFRSRUVfVFlQRSAoQDApKSkKKyAgKHdpdGggeyB0cmVlIHV0eXBl ID0gdW5zaWduZWRfdHlwZV9mb3IgKFRSRUVfVFlQRSAoQDApKTsgfQorICAg KGNvbnZlcnQgKGFic3U6dXR5cGUgQDApKSkpKQorCisKIC8qIFNpbXBsaWZp Y2F0aW9ucyBvZiBvcGVyYXRpb25zIHdpdGggb25lIGNvbnN0YW50IG9wZXJh bmQgYW5kCiAgICBzaW1wbGlmaWNhdGlvbnMgdG8gY29uc3RhbnRzIG9yIHNp bmdsZSB2YWx1ZXMuICAqLwogCmRpZmYgLS1naXQgYS9nY2Mvb3B0YWJzLXRy ZWUuYyBiL2djYy9vcHRhYnMtdHJlZS5jCmluZGV4IDcxZTE3MmMuLmFhMTE5 ZWMgMTAwNjQ0Ci0tLSBhL2djYy9vcHRhYnMtdHJlZS5jCisrKyBiL2djYy9v cHRhYnMtdHJlZS5jCkBAIC0yMzcsNiArMjM3LDggQEAgb3B0YWJfZm9yX3Ry ZWVfY29kZSAoZW51bSB0cmVlX2NvZGUgY29kZSwgY29uc3RfdHJlZSB0eXBl LAogICAgIGNhc2UgQUJTX0VYUFI6CiAgICAgICByZXR1cm4gdHJhcHYgPyBh YnN2X29wdGFiIDogYWJzX29wdGFiOwogCisgICAgY2FzZSBBQlNVX0VYUFI6 CisgICAgICByZXR1cm4gYWJzX29wdGFiOwogICAgIGRlZmF1bHQ6CiAgICAg ICByZXR1cm4gdW5rbm93bl9vcHRhYjsKICAgICB9CmRpZmYgLS1naXQgYS9n Y2MvdGVzdHN1aXRlL2djYy5kZy9hYnN1LmMgYi9nY2MvdGVzdHN1aXRlL2dj Yy5kZy9hYnN1LmMKaW5kZXggZTY5ZGUyOS4uMDYzZGEyOCAxMDA2NDQKLS0t IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvYWJzdS5jCisrKyBiL2djYy90ZXN0 c3VpdGUvZ2NjLmRnL2Fic3UuYwpAQCAtMCwwICsxLDg1IEBACisKKy8qIHsg ZGctZG8gcnVuICB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1PMCIgfSAqLwor CisjaW5jbHVkZSA8bGltaXRzLmg+CisjZGVmaW5lIEFCUyh4KQkoKCh4KSA+ PSAwKSA/ICh4KSA6IC0oeCkpCisKKyNkZWZpbmUgREVGX1RFU1QoVFlQRSkJ XAordm9pZCBmb29fIyNUWVBFIChzaWduZWQgVFlQRSB4LCB1bnNpZ25lZCBU WVBFIHkpewlcCisgICAgVFlQRSB0ID0gQUJTICh4KTsJCQkJXAorICAgIGlm ICh0ICE9IHkpCQkJCQlcCisgCV9fYnVpbHRpbl9hYm9ydCAoKTsJCQlcCit9 CQkJCQkJXAorCitERUZfVEVTVCAoY2hhcik7CitERUZfVEVTVCAoc2hvcnQp OworREVGX1RFU1QgKGludCk7CitERUZfVEVTVCAobG9uZyk7CisKK2ludCBt YWluICgpCit7CisgIGZvb19jaGFyIChTQ0hBUl9NSU4gKyAxLCBTQ0hBUl9N QVgpOworICBmb29fY2hhciAoMCwgMCk7CisgIGZvb19jaGFyICgtMSwgMSk7 CisgIGZvb19jaGFyICgxLCAxKTsKKyAgZm9vX2NoYXIgKFNDSEFSX01BWCwg U0NIQVJfTUFYKTsKKworICBmb29faW50ICgtMSwgMSk7CisgIGZvb19pbnQg KDAsIDApOworICBmb29faW50IChJTlRfTUFYLCBJTlRfTUFYKTsKKyAgZm9v X2ludCAoSU5UX01JTiArIDEsIElOVF9NQVgpOworCisgIGZvb19zaG9ydCAo LTEsIDEpOworICBmb29fc2hvcnQgKDAsIDApOworICBmb29fc2hvcnQgKFNI UlRfTUFYLCBTSFJUX01BWCk7CisgIGZvb19zaG9ydCAoU0hSVF9NSU4gKyAx LCBTSFJUX01BWCk7CisKKyAgZm9vX2xvbmcgKC0xLCAxKTsKKyAgZm9vX2xv bmcgKDAsIDApOworICBmb29fbG9uZyAoTE9OR19NQVgsIExPTkdfTUFYKTsK KyAgZm9vX2xvbmcgKExPTkdfTUlOICsgMSwgTE9OR19NQVgpOworCisgIHJl dHVybiAwOworfQorCisvKiB7IGRnLWRvIHJ1biAgfSAqLworLyogeyBkZy1v cHRpb25zICItTzAiIH0gKi8KKworI2luY2x1ZGUgPGxpbWl0cy5oPgorI2Rl ZmluZSBBQlMoeCkJKCgoeCkgPj0gMCkgPyAoeCkgOiAtKHgpKQorCisjZGVm aW5lIERFRl9URVNUKFRZUEUpCVwKK3ZvaWQgZm9vXyMjVFlQRSAoc2lnbmVk IFRZUEUgeCwgdW5zaWduZWQgVFlQRSB5KXsJXAorICAgIFRZUEUgdCA9IEFC UyAoeCk7CQkJCVwKKyAgICBpZiAodCAhPSB5KQkJCQkJXAorIAlfX2J1aWx0 aW5fYWJvcnQgKCk7CQkJXAorfQkJCQkJCVwKKworREVGX1RFU1QgKGNoYXIp OworREVGX1RFU1QgKHNob3J0KTsKK0RFRl9URVNUIChpbnQpOworREVGX1RF U1QgKGxvbmcpOwordm9pZCBtYWluICgpCit7CisgIGZvb19jaGFyIChTQ0hB Ul9NSU4gKyAxLCBTQ0hBUl9NQVgpOworICBmb29fY2hhciAoMCwgMCk7Cisg IGZvb19jaGFyICgtMSwgMSk7CisgIGZvb19jaGFyICgxLCAxKTsKKyAgZm9v X2NoYXIgKFNDSEFSX01BWCwgU0NIQVJfTUFYKTsKKworICBmb29faW50ICgt MSwgMSk7CisgIGZvb19pbnQgKDAsIDApOworICBmb29faW50IChJTlRfTUFY LCBJTlRfTUFYKTsKKyAgZm9vX2ludCAoSU5UX01JTiArIDEsIElOVF9NQVgp OworCisgIGZvb19zaG9ydCAoLTEsIDEpOworICBmb29fc2hvcnQgKDAsIDAp OworICBmb29fc2hvcnQgKFNIUlRfTUFYLCBTSFJUX01BWCk7CisgIGZvb19z aG9ydCAoU0hSVF9NSU4gKyAxLCBTSFJUX01BWCk7CisKKyAgZm9vX2xvbmcg KC0xLCAxKTsKKyAgZm9vX2xvbmcgKDAsIDApOworICBmb29fbG9uZyAoTE9O R19NQVgsIExPTkdfTUFYKTsKKyAgZm9vX2xvbmcgKExPTkdfTUlOICsgMSwg TE9OR19NQVgpOworfQpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2Mu ZGcvZ2ltcGxlZmUtMjkuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2dpbXBs ZWZlLTI5LmMKaW5kZXggZTY5ZGUyOS4uNTRiODZlZiAxMDA2NDQKLS0tIGEv Z2NjL3Rlc3RzdWl0ZS9nY2MuZGcvZ2ltcGxlZmUtMjkuYworKysgYi9nY2Mv dGVzdHN1aXRlL2djYy5kZy9naW1wbGVmZS0yOS5jCkBAIC0wLDAgKzEsMTEg QEAKKy8qIHsgZGctZG8gY29tcGlsZSB9ICovCisvKiB7IGRnLW9wdGlvbnMg Ii1PIC1mZ2ltcGxlIC1mZHVtcC10cmVlLXNzYS1naW1wbGUiIH0gKi8KKwor dW5zaWduZWQgaW50IF9fR0lNUExFKCkgZihpbnQgYSkKK3sKKyAgdW5zaWdu ZWQgaW50IHQwOworICB0MF8xID0gX19BQlNVIGE7CisgIHJldHVybiB0MF8x OworfQorCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgIl9fQUJT VSBhIiAic3NhIiB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv Z2NjLnRhcmdldC9hYXJjaDY0L3ByNjQ5NDYuYyBiL2djYy90ZXN0c3VpdGUv Z2NjLnRhcmdldC9hYXJjaDY0L3ByNjQ5NDYuYwppbmRleCBlNjlkZTI5Li43 MzY2NTZmIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQv YWFyY2g2NC9wcjY0OTQ2LmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFy Z2V0L2FhcmNoNjQvcHI2NDk0Ni5jCkBAIC0wLDAgKzEsMTMgQEAKKworLyog eyBkZy1kbyBjb21waWxlIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLU8zIiB9 ICovCisKK3NpZ25lZCBjaGFyIGFbMTAwXSxiWzEwMF07Cit2b2lkIGFic29s dXRlX3M4ICh2b2lkKQoreworICBpbnQgaTsKKyAgZm9yIChpPTA7IGk8MTY7 IGkrKykKKyAgICBhW2ldID0gKGJbaV0gPiAwID8gYltpXSA6IC1iW2ldKTsK K307CisKKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyAi YWJzXHR2XFswLTlcXSsuMTZiLCB2XFswLTlcXSsuMTZiIiAxIH0gfSAqLwpk aWZmIC0tZ2l0IGEvZ2NjL3RyZWUtY2ZnLmMgYi9nY2MvdHJlZS1jZmcuYwpp bmRleCA3ZjQ4ZDJkLi42ZGY0MmNjIDEwMDY0NAotLS0gYS9nY2MvdHJlZS1j ZmcuYworKysgYi9nY2MvdHJlZS1jZmcuYwpAQCAtMzY4NSw2ICszNjg1LDEy IEBAIHZlcmlmeV9naW1wbGVfYXNzaWduX3VuYXJ5IChnYXNzaWduICpzdG10 KQogICAgIGNhc2UgUEFSRU5fRVhQUjoKICAgICBjYXNlIENPTkpfRVhQUjoK ICAgICAgIGJyZWFrOworICAgIGNhc2UgQUJTVV9FWFBSOgorICAgICAgaWYg KCFUWVBFX1VOU0lHTkVEIChsaHNfdHlwZSkKKwkgIHx8ICFBTllfSU5URUdS QUxfVFlQRV9QIChyaHMxX3R5cGUpKQorCXJldHVybiB0cnVlOworICAgICAg cmV0dXJuIGZhbHNlOworICAgICAgYnJlYWs7CiAKICAgICBjYXNlIFZFQ19E VVBMSUNBVEVfRVhQUjoKICAgICAgIGlmIChUUkVFX0NPREUgKGxoc190eXBl KSAhPSBWRUNUT1JfVFlQRQpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtZWguYyBi L2djYy90cmVlLWVoLmMKaW5kZXggMzYwOWJjYS4uZGE4NzQ2NiAxMDA2NDQK LS0tIGEvZ2NjL3RyZWUtZWguYworKysgYi9nY2MvdHJlZS1laC5jCkBAIC0y NDcxLDYgKzI0NzEsMTAgQEAgb3BlcmF0aW9uX2NvdWxkX3RyYXBfaGVscGVy X3AgKGVudW0gdHJlZV9jb2RlIG9wLAogCXJldHVybiB0cnVlOwogICAgICAg cmV0dXJuIGZhbHNlOwogCisgICAgY2FzZSBBQlNVX0VYUFI6CisgICAgICAv KiBBQlNVX0VYUFIgbmV2ZXIgdHJhcHMuICAqLworICAgICAgcmV0dXJuIGZh bHNlOworCiAgICAgY2FzZSBQTFVTX0VYUFI6CiAgICAgY2FzZSBNSU5VU19F WFBSOgogICAgIGNhc2UgTVVMVF9FWFBSOgpkaWZmIC0tZ2l0IGEvZ2NjL3Ry ZWUtaW5saW5lLmMgYi9nY2MvdHJlZS1pbmxpbmUuYwppbmRleCA1YTBhMjUy Li5kMjcyOTc0IDEwMDY0NAotLS0gYS9nY2MvdHJlZS1pbmxpbmUuYworKysg Yi9nY2MvdHJlZS1pbmxpbmUuYwpAQCAtMzg2Niw2ICszODY2LDcgQEAgZXN0 aW1hdGVfb3BlcmF0b3JfY29zdCAoZW51bSB0cmVlX2NvZGUgY29kZSwgZW5p X3dlaWdodHMgKndlaWdodHMsCiAgICAgY2FzZSBNSU5fRVhQUjoKICAgICBj YXNlIE1BWF9FWFBSOgogICAgIGNhc2UgQUJTX0VYUFI6CisgICAgY2FzZSBB QlNVX0VYUFI6CiAKICAgICBjYXNlIExTSElGVF9FWFBSOgogICAgIGNhc2Ug UlNISUZUX0VYUFI6CmRpZmYgLS1naXQgYS9nY2MvdHJlZS1wcmV0dHktcHJp bnQuYyBiL2djYy90cmVlLXByZXR0eS1wcmludC5jCmluZGV4IGJjMzZjMjgu LjYxMmExOGYgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXByZXR0eS1wcmludC5j CisrKyBiL2djYy90cmVlLXByZXR0eS1wcmludC5jCkBAIC0yNDYzLDYgKzI0 NjMsMTIgQEAgZHVtcF9nZW5lcmljX25vZGUgKHByZXR0eV9wcmludGVyICpw cCwgdHJlZSBub2RlLCBpbnQgc3BjLCBkdW1wX2ZsYWdzX3QgZmxhZ3MsCiAg ICAgICBwcF9ncmVhdGVyIChwcCk7CiAgICAgICBicmVhazsKIAorICAgIGNh c2UgQUJTVV9FWFBSOgorICAgICAgcHBfc3RyaW5nIChwcCwgIkFCU1VfRVhQ UiA8Iik7CisgICAgICBkdW1wX2dlbmVyaWNfbm9kZSAocHAsIFRSRUVfT1BF UkFORCAobm9kZSwgMCksIHNwYywgZmxhZ3MsIGZhbHNlKTsKKyAgICAgIHBw X2dyZWF0ZXIgKHBwKTsKKyAgICAgIGJyZWFrOworCiAgICAgY2FzZSBSQU5H RV9FWFBSOgogICAgICAgTklZOwogICAgICAgYnJlYWs7CmRpZmYgLS1naXQg YS9nY2MvdHJlZS12ZWN0LXBhdHRlcm5zLmMgYi9nY2MvdHJlZS12ZWN0LXBh dHRlcm5zLmMKaW5kZXggNWMyNTc4Zi4uZTRkZjZjOCAxMDA2NDQKLS0tIGEv Z2NjL3RyZWUtdmVjdC1wYXR0ZXJucy5jCisrKyBiL2djYy90cmVlLXZlY3Qt cGF0dGVybnMuYwpAQCAtNjE0LDcgKzYxNCw4IEBAIHZlY3RfcmVjb2dfc2Fk X3BhdHRlcm4gKHZlYzxnaW1wbGUgKj4gKnN0bXRzLCB0cmVlICp0eXBlX2lu LAogICBnY2NfYXNzZXJ0IChhYnNfc3RtdF92aW5mbyk7CiAgIGlmIChTVE1U X1ZJTkZPX0RFRl9UWVBFIChhYnNfc3RtdF92aW5mbykgIT0gdmVjdF9pbnRl cm5hbF9kZWYpCiAgICAgcmV0dXJuIE5VTEw7Ci0gIGlmIChnaW1wbGVfYXNz aWduX3Joc19jb2RlIChhYnNfc3RtdCkgIT0gQUJTX0VYUFIpCisgIGlmIChn aW1wbGVfYXNzaWduX3Joc19jb2RlIChhYnNfc3RtdCkgIT0gQUJTX0VYUFIK KyAgICAgICYmIGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKGFic19zdG10KSAh PSBBQlNVX0VYUFIpCiAgICAgcmV0dXJuIE5VTEw7CiAKICAgdHJlZSBhYnNf b3BybmQgPSBnaW1wbGVfYXNzaWduX3JoczEgKGFic19zdG10KTsKZGlmZiAt LWdpdCBhL2djYy90cmVlLXZlY3Qtc3RtdHMuYyBiL2djYy90cmVlLXZlY3Qt c3RtdHMuYwppbmRleCA0NTM5ZjZhLi5jNzFiNjg4IDEwMDY0NAotLS0gYS9n Y2MvdHJlZS12ZWN0LXN0bXRzLmMKKysrIGIvZ2NjL3RyZWUtdmVjdC1zdG10 cy5jCkBAIC01OTk1LDcgKzU5OTUsMTAgQEAgdmVjdG9yaXphYmxlX29wZXJh dGlvbiAoZ2ltcGxlICpzdG10LCBnaW1wbGVfc3RtdF9pdGVyYXRvciAqZ3Np LAogICAgICAgICAgICAgICAgICAgICAgInRyYW5zZm9ybSBiaW5hcnkvdW5h cnkgb3BlcmF0aW9uLlxuIik7CiAKICAgLyogSGFuZGxlIGRlZi4gICovCi0g IHZlY19kZXN0ID0gdmVjdF9jcmVhdGVfZGVzdGluYXRpb25fdmFyIChzY2Fs YXJfZGVzdCwgdmVjdHlwZSk7CisgIGlmIChjb2RlID09IEFCU1VfRVhQUikK KyAgICB2ZWNfZGVzdCA9IHZlY3RfY3JlYXRlX2Rlc3RpbmF0aW9uX3ZhciAo c2NhbGFyX2Rlc3QsIHZlY3R5cGVfb3V0KTsKKyAgZWxzZQorICAgIHZlY19k ZXN0ID0gdmVjdF9jcmVhdGVfZGVzdGluYXRpb25fdmFyIChzY2FsYXJfZGVz dCwgdmVjdHlwZSk7CiAKICAgLyogUE9JTlRFUl9ESUZGX0VYUFIgaGFzIHBv aW50ZXIgYXJndW1lbnRzIHdoaWNoIGFyZSB2ZWN0b3JpemVkIGFzCiAgICAg IHZlY3RvcnMgd2l0aCB1bnNpZ25lZCBlbGVtZW50cywgYnV0IHRoZSByZXN1 bHQgaXMgc2lnbmVkLiAgU28sIHdlCmRpZmYgLS1naXQgYS9nY2MvdHJlZS5k ZWYgYi9nY2MvdHJlZS5kZWYKaW5kZXggMzFkZTZjMC4uYTE3NjZlNCAxMDA2 NDQKLS0tIGEvZ2NjL3RyZWUuZGVmCisrKyBiL2djYy90cmVlLmRlZgpAQCAt NzYxLDYgKzc2MSwxMSBAQCBERUZUUkVFQ09ERSAoTUFYX0VYUFIsICJtYXhf ZXhwciIsIHRjY19iaW5hcnksIDIpCiAgICBvcGVyYW5kIG9mIHRoZSBBQlNf RVhQUiBtdXN0IGhhdmUgdGhlIHNhbWUgdHlwZS4gICovCiBERUZUUkVFQ09E RSAoQUJTX0VYUFIsICJhYnNfZXhwciIsIHRjY191bmFyeSwgMSkKIAorLyog UmVwcmVzZW50cyB0aGUgdW5zaWduZWQgYWJzb2x1dGUgdmFsdWUgb2YgdGhl IG9wZXJhbmQuCisgICBBbiBBQlNVX0VYUFIgbXVzdCBoYXZlIHVuc2lnbmVk IElOVEVHRVJfVFlQRS4gIFRoZSBvcGVyYW5kIG9mIHRoZSBBQlNVX0VYUFIK KyAgIG11c3QgaGF2ZSB0aGUgY29ycmVzcG9uZGluZyBzaWduZWQgdHlwZS4g ICovCitERUZUUkVFQ09ERSAoQUJTVV9FWFBSLCAiYWJzdV9leHByIiwgdGNj X3VuYXJ5LCAxKQorCiAvKiBTaGlmdCBvcGVyYXRpb25zIGZvciBzaGlmdCBh bmQgcm90YXRlLgogICAgU2hpZnQgbWVhbnMgbG9naWNhbCBzaGlmdCBpZiBk b25lIG9uIGFuCiAgICB1bnNpZ25lZCB0eXBlLCBhcml0aG1ldGljIHNoaWZ0 IGlmIGRvbmUgb24gYSBzaWduZWQgdHlwZS4K --00000000000001a87b056dcc954d--