From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 105943 invoked by alias); 18 Jun 2015 14:33:00 -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 105925 invoked by uid 89); 18 Jun 2015 14:32:58 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.0 required=5.0 tests=AWL,BAYES_05,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-oi0-f46.google.com Received: from mail-oi0-f46.google.com (HELO mail-oi0-f46.google.com) (209.85.218.46) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Thu, 18 Jun 2015 14:32:57 +0000 Received: by oiax193 with SMTP id x193so58723559oia.2 for ; Thu, 18 Jun 2015 07:32:55 -0700 (PDT) MIME-Version: 1.0 X-Received: by 10.60.39.65 with SMTP id n1mr9290673oek.31.1434637975211; Thu, 18 Jun 2015 07:32:55 -0700 (PDT) Received: by 10.202.106.145 with HTTP; Thu, 18 Jun 2015 07:32:55 -0700 (PDT) In-Reply-To: References: Date: Thu, 18 Jun 2015 15:41:00 -0000 Message-ID: Subject: Re: [PATCH] Simple optimization for MASK_STORE. From: Yuri Rumyantsev To: Richard Biener Cc: gcc-patches , Igor Zamyatin Content-Type: multipart/mixed; boundary=089e013d085ae505e90518cbaec8 X-SW-Source: 2015-06/txt/msg01281.txt.bz2 --089e013d085ae505e90518cbaec8 Content-Type: text/plain; charset=UTF-8 Content-length: 6531 Richard, Here is updated patch which does not include your proposal related to the target hook deletion. You wrote: > I still don't understand why you need the new target hook. If we have a masked > load/store then the mask is computed by an assignment with a VEC_COND_EXPR > (in your example) and thus a test for a zero mask is expressible as just > > if (vect__ifc__41.17_167 == { 0, 0, 0, 0... }) > > or am I missing something? Such vector compare produces vector and does not set up cc flags required for conditional branch (GIMPLE_COND). If we use such comparison for GIMPLE_COND we got error message, so I used target hook which does set up cc flags aka ptest instruction and I left this part. I moved new routines to loop-vectorizer.c file and both they are static. I re-wrote is_valid_sink function to use def-use chain as you proposed. I also add new parameter to control such transformation. Few redundant tests have also been deleted. Any comments will be appreciated. Thanks. Yuri. 2015-06-18 Yuri Rumyantsev * config/i386/i386.c: Include files stringpool.h and tree-ssanames.h. (ix86_vectorize_build_zero_vector_test): New function. (TARGET_VECTORIZE_BUILD_ZERO_VECTOR_TEST): New target macro * doc/tm.texi.in: Add @hook TARGET_VECTORIZE_BUILD_ZERO_VECTOR_TEST. * doc/tm.texi: Updated. * params.def (PARAM_ZERO_TEST_FOR_STORE_MASK): New DEFPARAM. * params.h (ENABLE_ZERO_TEST_FOR_STORE_MASK): new macros. * target.def (build_zero_vector_test): New DEFHOOK. * tree-vect-stmts.c (vectorizable_mask_load_store): Initialize has_mask_store field of vect_info. * tree-vectorizer.c: Include files stringpool.h and tree-ssanames.h. (is_valid_sink): New function. (optimize_mask_stores): New function. (vectorize_loops): Invoke optimaze_mask_stores for loops having masked stores. * tree-vectorizer.h (loop_vec_info): Add new has_mask_store field and correspondent macros. gcc/testsuite/ChangeLog: * gcc.target/i386/avx2-vect-mask-store-move1.c: New test. 2015-06-09 15:13 GMT+03:00 Richard Biener : > On Wed, May 20, 2015 at 4:00 PM, Yuri Rumyantsev wrote: >> Hi All, >> >> Here is updated patch to optimize mask stores. The main goal of it is >> to avoid execution of mask store if its mask is zero vector since >> loads that follow it can be blocked. >> The following changes were done: >> 1. A test on sink legality was added - it simply prohibits to cross >> statements with non-null vdef or vuse. >> 2. New phi node is created in join block for moved MASK_STORE statements. >> 3. Test was changed to check that 2 MASK_STORE statements are not >> moved to the same block. >> 4. New field was added to loop_vec_info structure to mark loops >> having MASK_STORE's. >> >> Any comments will be appreciated. >> Yuri. > > I still don't understand why you need the new target hook. If we have a masked > load/store then the mask is computed by an assignment with a VEC_COND_EXPR > (in your example) and thus a test for a zero mask is expressible as just > > if (vect__ifc__41.17_167 == { 0, 0, 0, 0... }) > > or am I missing something? As we dont' want this transform on all targets > (or always) we can control it by either a --param or a new flag which default > targets can adjust. [Is the hazard still present with Skylake or other > AVX512 implementations for example?] > > +/* Helper for optimize_mask_stores: returns true if STMT sinking to end > + of BB is valid and false otherwise. */ > + > +static bool > +is_valid_sink (gimple stmt) > +{ > > so STMT is either a masked store or a masked load? You shouldn't > walk all stmts here but instead rely on the factored use-def def-use > chains of virtual operands. > > +void > +optimize_mask_stores (struct loop *loop) > +{ > + basic_block bb = loop->header; > + gimple_stmt_iterator gsi; > + gimple stmt; > + auto_vec worklist; > + > + if (loop->dont_vectorize > + || loop->num_nodes > 2) > + return; > > looks like no longer needed given the place this is called from now > (or does it guard against outer loop vectorization as well?) > Also put it into tree-vect-loop.c and make it static. > > + /* Loop was not vectorized if mask does not have vector type. */ > + if (!VECTOR_TYPE_P (TREE_TYPE (mask))) > + return; > > this should be always false > > + store_bb->frequency = bb->frequency / 2; > + efalse->probability = REG_BR_PROB_BASE / 2; > > I think the == 0 case should end up as unlikely. > > + if (dom_info_available_p (CDI_POST_DOMINATORS)) > + set_immediate_dominator (CDI_POST_DOMINATORS, bb, store_bb); > > post dominators are not available in the vectorizer. > > + /* Put definition statement of stored value in STORE_BB > + if possible. */ > + arg3 = gimple_call_arg (last, 3); > + if (TREE_CODE (arg3) == SSA_NAME && has_single_use (arg3)) > + { > + def_stmt = SSA_NAME_DEF_STMT (arg3); > + /* Move def_stmt to STORE_BB if it is in the same bb and > + it is legal. */ > + if (gimple_bb (def_stmt) == bb > + && is_valid_sink (def_stmt)) > > ok, so you move arbitrary statements. You can always move non-memory > statements and if you keep track of the last store you moved you > can check if gimple_vuse () is the same as on that last store and be > done with that, or if you sink another store (under the same condition) > then just update the last store. > > Otherwise this looks better now. > > Thus - get rid of the target hook and of is_valid_sink. > > Thanks, > Richard. > >> 2015-05-20 Yuri Rumyantsev >> >> * config/i386/i386.c: Include files stringpool.h and tree-ssanames.h. >> (ix86_vectorize_is_zero_vector): New function. >> (TARGET_VECTORIZE_IS_ZERO_VECTOR): New target macro >> * doc/tm.texi.in: Add @hook TARGET_VECTORIZE_IS_ZERO_VECTOR. >> * doc/tm.texi: Updated. >> * target.def (is_zero_vector): New DEFHOOK. >> * tree-vect-stmts.c : Include tree-into-ssa.h. >> (vectorizable_mask_load_store): Initialize has_mask_store field. >> (is_valid_sink): New function. >> (optimize_mask_stores): New function. >> * tree-vectorizer.c (vectorize_loops): Invoke optimaze_mask_stores for >> loops having masked stores. >> * tree-vectorizer.h (loop_vec_info): Add new has_mask_store field and >> correspondent macros. >> (optimize_mask_stores): Update prototype. >> >> gcc/testsuite/ChangeLog: >> * gcc.target/i386/avx2-vect-mask-store-move1.c: New test. --089e013d085ae505e90518cbaec8 Content-Type: application/octet-stream; name="patch.3" Content-Disposition: attachment; filename="patch.3" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ib2aeivg0 Content-length: 18341 ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvaTM4Ni9pMzg2LmMgYi9nY2MvY29u ZmlnL2kzODYvaTM4Ni5jCmluZGV4IDQ0YTg2MjQuLmU5MGRlMzIgMTAwNjQ0 Ci0tLSBhL2djYy9jb25maWcvaTM4Ni9pMzg2LmMKKysrIGIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYuYwpAQCAtMTAwLDYgKzEwMCw4IEBAIGFsb25nIHdpdGgg R0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiAjaW5j bHVkZSAidHJlZS1pdGVyYXRvci5oIgogI2luY2x1ZGUgInRyZWUtY2hrcC5o IgogI2luY2x1ZGUgInJ0bC1jaGtwLmgiCisjaW5jbHVkZSAic3RyaW5ncG9v bC5oIgorI2luY2x1ZGUgInRyZWUtc3NhbmFtZXMuaCIKIAogc3RhdGljIHJ0 eCBsZWdpdGltaXplX2RsbGltcG9ydF9zeW1ib2wgKHJ0eCwgYm9vbCk7CiBz dGF0aWMgcnR4IGxlZ2l0aW1pemVfcGVfY29mZl9leHRlcm5fZGVjbCAocnR4 LCBib29sKTsKQEAgLTQxMTAwLDYgKzQxMTAyLDQ3IEBAIGl4ODZfdmVjdG9y aXplX2J1aWx0aW5fZ2F0aGVyIChjb25zdF90cmVlIG1lbV92ZWN0eXBlLAog ICByZXR1cm4gaXg4Nl9nZXRfYnVpbHRpbiAoY29kZSk7CiB9CiAKKy8qIFJl dHVybnMgdHJ1ZSBpZiBTT1VSQ0UgdHlwZSBpcyBzdXBwb3J0ZWQgYnkgYnVp bHRpbiBwdGVzdC4KKyAgIE5BTUUgaXMgbGhzIG9mIGNyZWF0ZWQgcHRlc3Qg Y2FsbC4gIEFsbCBjcmVhdGVkIHN0YXRlbWVudHMgYXJlIGFkZGVkCisgICB0 byBHUy4gICovCisKK3N0YXRpYyBib29sCitpeDg2X3ZlY3Rvcml6ZV9idWls ZF96ZXJvX3ZlY3Rvcl90ZXN0ICh0cmVlIHNvdXJjZSwgdHJlZSBuYW1lLCBn aW1wbGVfc2VxICpncykKK3sKKyAgdHJlZSB0eXBlID0gVFJFRV9UWVBFIChz b3VyY2UpOworICBnaW1wbGUgc3RtdDsKKyAgZW51bSBpeDg2X2J1aWx0aW5z IGNvZGU7CisgIHRyZWUgZGVjbCwgbmV3X3R5cGUsIGNvbnZfZXhwciwgdmVj X3RtcDsKKworICBnY2NfYXNzZXJ0IChWRUNUT1JfVFlQRV9QICh0eXBlKSk7 CisgIGlmICghVEFSR0VUX0FWWCkKKyAgICByZXR1cm4gZmFsc2U7CisKKyAg c3dpdGNoICh0cmVlX3RvX3Vod2kgKFRZUEVfU0laRSAodHlwZSkpKQorICAg IHsKKyAgICBjYXNlIDEyODoKKyAgICAgIGNvZGUgPSBJWDg2X0JVSUxUSU5f UFRFU1RaOworICAgICAgYnJlYWs7CisgICAgY2FzZSAyNTY6CisgICAgICBp ZiAoIVRBUkdFVF9BVlgyKQorCXJldHVybiBmYWxzZTsKKyAgICAgIGNvZGUg PSBJWDg2X0JVSUxUSU5fUFRFU1RaMjU2OworICAgICAgYnJlYWs7CisgICAg ZGVmYXVsdDoKKyAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgIGRlY2wg PSBpeDg2X2J1aWx0aW5fZGVjbCAoY29kZSwgdHJ1ZSk7CisgIG5ld190eXBl ID0gZ2V0X3NhbWVfc2l6ZWRfdmVjdHlwZSAobG9uZ19sb25nX2ludGVnZXJf dHlwZV9ub2RlLCB0eXBlKTsKKyAgY29udl9leHByID0gYnVpbGQxIChWSUVX X0NPTlZFUlRfRVhQUiwgbmV3X3R5cGUsIHNvdXJjZSk7CisgIHZlY190bXAg PSBtYWtlX3NzYV9uYW1lIChuZXdfdHlwZSk7CisgIHN0bXQgPSBnaW1wbGVf YnVpbGRfYXNzaWduICh2ZWNfdG1wLCBjb252X2V4cHIpOworICBnaW1wbGVf c2VxX2FkZF9zdG10IChncywgc3RtdCk7CisgIHN0bXQgPSBnaW1wbGVfYnVp bGRfY2FsbCAoZGVjbCwgMiwgdmVjX3RtcCwgdmVjX3RtcCk7CisgIGdpbXBs ZV9jYWxsX3NldF9saHMgKHN0bXQsIG5hbWUpOworICBnaW1wbGVfc2VxX2Fk ZF9zdG10IChncywgc3RtdCk7CisgIHJldHVybiB0cnVlOworfQorCiAvKiBS ZXR1cm5zIGEgY29kZSBmb3IgYSB0YXJnZXQtc3BlY2lmaWMgYnVpbHRpbiB0 aGF0IGltcGxlbWVudHMKICAgIHJlY2lwcm9jYWwgb2YgdGhlIGZ1bmN0aW9u LCBvciBOVUxMX1RSRUUgaWYgbm90IGF2YWlsYWJsZS4gICovCiAKQEAgLTUx OTQ3LDYgKzUxOTkwLDEwIEBAIGl4ODZfb3BlcmFuZHNfb2tfZm9yX21vdmVf bXVsdGlwbGUgKHJ0eCAqb3BlcmFuZHMsIGJvb2wgbG9hZCwKICN1bmRlZiBU QVJHRVRfVkVDVE9SSVpFX0JVSUxUSU5fR0FUSEVSCiAjZGVmaW5lIFRBUkdF VF9WRUNUT1JJWkVfQlVJTFRJTl9HQVRIRVIgaXg4Nl92ZWN0b3JpemVfYnVp bHRpbl9nYXRoZXIKIAorI3VuZGVmIFRBUkdFVF9WRUNUT1JJWkVfQlVJTERf WkVST19WRUNUT1JfVEVTVAorI2RlZmluZSBUQVJHRVRfVkVDVE9SSVpFX0JV SUxEX1pFUk9fVkVDVE9SX1RFU1QgXAorICBpeDg2X3ZlY3Rvcml6ZV9idWls ZF96ZXJvX3ZlY3Rvcl90ZXN0CisKICN1bmRlZiBUQVJHRVRfQlVJTFRJTl9S RUNJUFJPQ0FMCiAjZGVmaW5lIFRBUkdFVF9CVUlMVElOX1JFQ0lQUk9DQUwg aXg4Nl9idWlsdGluX3JlY2lwcm9jYWwKIApkaWZmIC0tZ2l0IGEvZ2NjL2Rv Yy90bS50ZXhpLmluIGIvZ2NjL2RvYy90bS50ZXhpLmluCmluZGV4IDkzZmI0 MWMuLjcwZDA0ZWUgMTAwNjQ0Ci0tLSBhL2djYy9kb2MvdG0udGV4aS5pbgor KysgYi9nY2MvZG9jL3RtLnRleGkuaW4KQEAgLTQyMzksNiArNDIzOSw4IEBA IGFkZHJlc3M7ICBidXQgb2Z0ZW4gYSBtYWNoaW5lLWRlcGVuZGVudCBzdHJh dGVneSBjYW4gZ2VuZXJhdGUgYmV0dGVyIGNvZGUuCiAKIEBob29rIFRBUkdF VF9WRUNUT1JJWkVfQlVJTFRJTl9HQVRIRVIKIAorQGhvb2sgVEFSR0VUX1ZF Q1RPUklaRV9CVUlMRF9aRVJPX1ZFQ1RPUl9URVNUCisKIEBob29rIFRBUkdF VF9TSU1EX0NMT05FX0NPTVBVVEVfVkVDU0laRV9BTkRfU0lNRExFTgogCiBA aG9vayBUQVJHRVRfU0lNRF9DTE9ORV9BREpVU1QKZGlmZiAtLWdpdCBhL2dj Yy9wYXJhbXMuZGVmIGIvZ2NjL3BhcmFtcy5kZWYKaW5kZXggM2U0YmEzYS4u OWU4ZGUxMSAxMDA2NDQKLS0tIGEvZ2NjL3BhcmFtcy5kZWYKKysrIGIvZ2Nj L3BhcmFtcy5kZWYKQEAgLTEwNjksNiArMTA2OSwxMiBAQCBERUZQQVJBTSAo UEFSQU1fTUFYX1NUT1JFU19UT19TSU5LLAogICAgICAgICAgICJNYXhpbXVt IG51bWJlciBvZiBjb25kaXRpb25hbCBzdG9yZSBwYWlycyB0aGF0IGNhbiBi ZSBzdW5rIiwKICAgICAgICAgICAyLCAwLCAwKQogCisvKiBFbmFibGUgaW5z ZXJpb24gdGVzdCBvbiB6ZXJvIG1hc2sgZm9yIG1hc2tlZCBzdG9yZXMgaWYg bm9uLXplcm8uICAqLworREVGUEFSQU0gKFBBUkFNX1pFUk9fVEVTVF9GT1Jf U1RPUkVfTUFTSywKKwkgICJ6ZXJvLXRlc3QtZm9yLXN0b3JlLW1hc2siLAor CSAgIkVuYWJsZSBpbnNlcnRpb24gb2YgdGVzdCBvbiB6ZXJvIG1hc2sgZm9y IG1hc2tlZCBzdG9yZXMiLAorCSAgMSwgMCwgMSkKKwogLyogT3ZlcnJpZGUg Q0FTRV9WQUxVRVNfVEhSRVNIT0xEIG9mIHdoZW4gdG8gc3dpdGNoIGZyb20g ZG9pbmcgc3dpdGNoCiAgICBzdGF0ZW1lbnRzIHZpYSBpZiBzdGF0ZW1lbnRz IHRvIHVzaW5nIGEgdGFibGUganVtcCBvcGVyYXRpb24uICBJZiB0aGUgdmFs dWUKICAgIGlzIDAsIHRoZSBkZWZhdWx0IENBU0VfVkFMVUVTX1RIUkVTSE9M RCB3aWxsIGJlIHVzZWQuICAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3BhcmFtcy5o IGIvZ2NjL3BhcmFtcy5oCmluZGV4IGY1MzQyNmQuLmEzZWEwODEgMTAwNjQ0 Ci0tLSBhL2djYy9wYXJhbXMuaAorKysgYi9nY2MvcGFyYW1zLmgKQEAgLTIx OCw2ICsyMTgsOCBAQCBleHRlcm4gdm9pZCBpbml0X3BhcmFtX3ZhbHVlcyAo aW50ICpwYXJhbXMpOwogICBQQVJBTV9WQUxVRSAoUEFSQU1fTUlOX05PTkRF QlVHX0lOU05fVUlEKQogI2RlZmluZSBNQVhfU1RPUkVTX1RPX1NJTksgXAog ICBQQVJBTV9WQUxVRSAoUEFSQU1fTUFYX1NUT1JFU19UT19TSU5LKQorI2Rl ZmluZSBFTkFCTEVfWkVST19URVNUX0ZPUl9TVE9SRV9NQVNLIFwKKyAgUEFS QU1fVkFMVUUgKFBBUkFNX1pFUk9fVEVTVF9GT1JfU1RPUkVfTUFTSykKICNk ZWZpbmUgQUxMT1dfTE9BRF9EQVRBX1JBQ0VTIFwKICAgUEFSQU1fVkFMVUUg KFBBUkFNX0FMTE9XX0xPQURfREFUQV9SQUNFUykKICNkZWZpbmUgQUxMT1df U1RPUkVfREFUQV9SQUNFUyBcCmRpZmYgLS1naXQgYS9nY2MvdGFyZ2V0LmRl ZiBiL2djYy90YXJnZXQuZGVmCmluZGV4IGI2MDZiODEuLjQzYjQ1ODYgMTAw NjQ0Ci0tLSBhL2djYy90YXJnZXQuZGVmCisrKyBiL2djYy90YXJnZXQuZGVm CkBAIC0xODAxLDYgKzE4MDEsMTkgQEAgbG9hZHMuIiwKICAoY29uc3RfdHJl ZSBtZW1fdmVjdHlwZSwgY29uc3RfdHJlZSBpbmRleF90eXBlLCBpbnQgc2Nh bGUpLAogIE5VTEwpCiAKKy8qIFJldHVybnMgdHJ1ZSBpZiB0YXJnZXQgc3Vw cG9ydCB6ZXJvIHZlY3RvciBwcmVkaWNhdGUgZm9yIGdpdmVuIHZlY3Rvcgor ICAgdHlwZS4gICovCitERUZIT09LCisoYnVpbGRfemVyb192ZWN0b3JfdGVz dCwKKyAiVGhpcyBob29rIHNob3VsZCByZXR1cm4gYm9vbGVhbiB0cnVlIGlm IHRhcmdldCBzdXBwb3J0cyB6ZXJvIHZlY3RvclxuXAorcHJlZGljYXRlLiAg QHZhcntzb3VyY2V9IGlzIHRoZSBjb21wYXJlZCB2ZWN0b3IsIEB2YXJ7bmFt ZX0gaXMgc3NhX25hbWVcblwKK2NvbnRhaW5pbmcgYm9vbGVhbiB2YWx1ZSB0 cnVlIGlmIGFsbCB2ZWN0b3IgZWxlbWVudHMgYXJlIHplcm8gYW5kIHByb2R1 Y2VkXG5cCitzdGF0ZW1lbnRzIGFyZSBzYXZlZCBpbiBAdmFye2dzfS5cblwK K1RoZSBkZWZhdWx0IGlzIEBjb2Rle2ZhbHNlfSB3aGljaCBtZWFucyB0aGF0 IHRhcmdldCBkb2VzIG5vdCBzdXBwb3J0IGl0LiIsCisgYm9vbCwKKyAodHJl ZSBzb3VyY2UsIHRyZWUgbmFtZSwgZ2ltcGxlX3NlcSAqZ3MpLAorIGhvb2tf Ym9vbF9ydHhfZmFsc2UpCisKIC8qIFRhcmdldCBmdW5jdGlvbiB0byBpbml0 aWFsaXplIHRoZSBjb3N0IG1vZGVsIGZvciBhIGxvb3Agb3IgYmxvY2suICAq LwogREVGSE9PSwogKGluaXRfY29zdCwKZGlmZiAtLWdpdCBhL2djYy90ZXN0 c3VpdGUvZ2NjLnRhcmdldC9pMzg2L2F2eDItdmVjdC1tYXNrLXN0b3JlLW1v dmUxLmMgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvaTM4Ni9hdngyLXZl Y3QtbWFzay1zdG9yZS1tb3ZlMS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmYwYzM2MzgKLS0tIC9kZXYvbnVsbAorKysgYi9nY2Mv dGVzdHN1aXRlL2djYy50YXJnZXQvaTM4Ni9hdngyLXZlY3QtbWFzay1zdG9y ZS1tb3ZlMS5jCkBAIC0wLDAgKzEsMjAgQEAKKy8qIHsgZGctZG8gY29tcGls ZSB9ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCBhdngy IH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLW1hdngyIC1PMyAtZm9wZW5tcC1z aW1kIC1mZHVtcC10cmVlLXZlY3QtZGV0YWlscyIgfSAqLworCitleHRlcm4g aW50ICpwMSwgKnAyLCAqcDM7CitpbnQgY1syNTZdOworCit2b2lkIGZvbyAo aW50IG4pCit7CisgIGludCBpOworICBmb3IgKGk9MDsgaTxuOyBpKyspCisg ICAgaWYgKGNbaV0pCisgICAgICB7CisJcDFbaV0gKz0gMTsKKwlwMltpXSA9 IHAzW2ldICsyOworICAgICAgfQorfQorCisvKiB7IGRnLWZpbmFsIHsgc2Nh bi10cmVlLWR1bXAtdGltZXMgIk1vdmUgTUFTS19TVE9SRSB0byBuZXcgYmIi IDIgInZlY3QiIH0gfSAqLworLyogeyBkZy1maW5hbCB7IGNsZWFudXAtdHJl ZS1kdW1wICJ2ZWN0IiB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90cmVlLXZl Y3Qtc3RtdHMuYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuYwppbmRleCA3YmEw ZDhmLi5lMzE0NzliIDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LXN0bXRz LmMKKysrIGIvZ2NjL3RyZWUtdmVjdC1zdG10cy5jCkBAIC0yMDcyLDYgKzIw NzIsNyBAQCB2ZWN0b3JpemFibGVfbWFza19sb2FkX3N0b3JlIChnaW1wbGUg c3RtdCwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmdzaSwKICAgICB7CiAgICAg ICB0cmVlIHZlY19yaHMgPSBOVUxMX1RSRUUsIHZlY19tYXNrID0gTlVMTF9U UkVFOwogICAgICAgcHJldl9zdG10X2luZm8gPSBOVUxMOworICAgICAgTE9P UF9WSU5GT19IQVNfTUFTS19TVE9SRSAobG9vcF92aW5mbykgPSB0cnVlOwog ICAgICAgZm9yIChpID0gMDsgaSA8IG5jb3BpZXM7IGkrKykKIAl7CiAJICB1 bnNpZ25lZCBhbGlnbiwgbWlzYWxpZ247CmRpZmYgLS1naXQgYS9nY2MvdHJl ZS12ZWN0b3JpemVyLmMgYi9nY2MvdHJlZS12ZWN0b3JpemVyLmMKaW5kZXgg ZmY0NmE1Mi4uZGViYjM1MSAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdG9y aXplci5jCisrKyBiL2djYy90cmVlLXZlY3Rvcml6ZXIuYwpAQCAtOTIsNyAr OTIsOCBAQCBhbG9uZyB3aXRoIEdDQzsgc2VlIHRoZSBmaWxlIENPUFlJTkcz LiAgSWYgbm90IHNlZQogI2luY2x1ZGUgImRiZ2NudC5oIgogI2luY2x1ZGUg ImdpbXBsZS1mb2xkLmgiCiAjaW5jbHVkZSAidHJlZS1zY2FsYXItZXZvbHV0 aW9uLmgiCi0KKyNpbmNsdWRlICJzdHJpbmdwb29sLmgiCisjaW5jbHVkZSAi dHJlZS1zc2FuYW1lcy5oIgogCiAvKiBMb29wIG9yIGJiIGxvY2F0aW9uLiAg Ki8KIHNvdXJjZV9sb2NhdGlvbiB2ZWN0X2xvY2F0aW9uOwpAQCAtNDIyLDYg KzQyMywxODQgQEAgc2V0X3VpZF9sb29wX2JicyAobG9vcF92ZWNfaW5mbyBs b29wX3ZpbmZvLCBnaW1wbGUgbG9vcF92ZWN0b3JpemVkX2NhbGwpCiAgIGZy ZWUgKGJicyk7CiB9CiAKKy8qIEhlbHBlciBmb3Igb3B0aW1pemVfbWFza19z dG9yZXM6IHJldHVybnMgdHJ1ZSBpZiBTVE1UIHNpbmtpbmcgdG8gZW5kCisg ICBvZiBCQiBpcyB2YWxpZCBhbmQgZmFsc2Ugb3RoZXJ3aXNlLiAgKi8KKwor c3RhdGljIGJvb2wKK2lzX3ZhbGlkX3NpbmsgKGdpbXBsZSBzdG10LCBnaW1w bGUgbGFzdF9zdG9yZSkKK3sKKyAgdHJlZSB2ZGVmOworICBpbW1fdXNlX2l0 ZXJhdG9yIGltbV9pdDsKKyAgZ2ltcGxlIHVzZV9zdG10OworICBiYXNpY19i bG9jayBiYiA9IGdpbXBsZV9iYiAoc3RtdCk7CisKKyAgaWYgKCh2ZGVmID0g Z2ltcGxlX3ZkZWYgKHN0bXQpKSkKKyAgICB7CisgICAgICBpbnQgY3Jvc3Mg PSAwOworICAgICAgLyogQ2hlY2sgdGhhdCB0aGVyIGFyZSBubyBzdG9yZSB2 dXNlcyBpbiBjdXJyZW50IGJiLiAgKi8KKyAgICAgIEZPUl9FQUNIX0lNTV9V U0VfU1RNVCAodXNlX3N0bXQsIGltbV9pdCwgdmRlZikKKwlpZiAoZ2ltcGxl X2JiICh1c2Vfc3RtdCkgPT0gYmIpCisJICBjcm9zcysrOworCisgICAgICBp ZiAoY3Jvc3MgPT0gMCkKKwlyZXR1cm4gdHJ1ZTsKKyAgICB9CisgIGVsc2Ug aWYgKGdpbXBsZV92dXNlIChzdG10KSA9PSBOVUxMX1RSRUUpCisgICAgcmV0 dXJuIHRydWU7CisgIGVsc2UgaWYgKGdpbXBsZV92dXNlIChzdG10KSA9PSBn aW1wbGVfdnVzZSAobGFzdF9zdG9yZSkpCisgICAgcmV0dXJuIHRydWU7Cisg IHJldHVybiBmYWxzZTsKK30KKworLyogVGhlIGNvZGUgYmVsb3cgaXMgdHJ5 aW5nIHRvIHBlcmZvcm0gc2ltcGxlIG9wdGltaXphdGlvbiAtIGRvIG5vdCBl eGVjdXRlCisgICBtYXNrZWQgc3RvcmUgc3RhdGVtZW50IGlmIGl0cyBtYXNr IGlzIHplcm8gbWFzayBzaW5jZSBsb2FkcyB0aGF0IGZvbGxvdworICAgYSBt YXNrZWQgc3RvcmUgY2FuIGJlIGJsb2NrZWQuCisgICBJdCBwdXQgYWxsIG1h c2tlZCBzdG9yZXMgc3RhdGVtZW50cyB3aXRoIHRoZSBzYW1lIG1hc2sgaW50 byB0aGUgbmV3IGJiCisgICB3aXRoIGEgY2hlY2sgb24gemVybyBtYXNrLiAg Ki8KKworc3RhdGljIHZvaWQKK29wdGltaXplX21hc2tfc3RvcmVzIChzdHJ1 Y3QgbG9vcCAqbG9vcCkKK3sKKyAgYmFzaWNfYmxvY2sgYmIgPSBsb29wLT5o ZWFkZXI7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGdzaTsKKyAgZ2ltcGxl IHN0bXQ7CisgIGF1dG9fdmVjPGdpbXBsZT4gd29ya2xpc3Q7CisKKyAgaWYg KEVOQUJMRV9aRVJPX1RFU1RfRk9SX1NUT1JFX01BU0sgPT0gMCkKKyAgICBy ZXR1cm47CisKKyAgLyogUGljayB1cCBhbGwgbWFza2VkIHN0b3JlcyBpbiBs b29wIGlmIGFueS4gICovCisgIGZvciAoZ3NpID0gZ3NpX3N0YXJ0X2JiIChi Yik7ICFnc2lfZW5kX3AgKGdzaSk7IGdzaV9uZXh0ICgmZ3NpKSkKKyAgICB7 CisgICAgICBzdG10ID0gZ3NpX3N0bXQgKGdzaSk7CisgICAgICBpZiAoaXNf Z2ltcGxlX2NhbGwgKHN0bXQpCisJICAmJiBnaW1wbGVfY2FsbF9pbnRlcm5h bF9wIChzdG10KQorCSAgJiYgZ2ltcGxlX2NhbGxfaW50ZXJuYWxfZm4gKHN0 bXQpID09IElGTl9NQVNLX1NUT1JFKQorCXdvcmtsaXN0LnNhZmVfcHVzaCAo c3RtdCk7CisgICAgfQorCisgIGlmICh3b3JrbGlzdC5pc19lbXB0eSAoKSkK KyAgICByZXR1cm47CisKKyAgLyogTG9vcCBoYXMgbWFza2VkIHN0b3Jlcy4g ICovCisgIHdoaWxlICghd29ya2xpc3QuaXNfZW1wdHkgKCkpCisgICAgewor ICAgICAgZ2ltcGxlIGxhc3QsIGRlZl9zdG10LCBsYXN0X3N0b3JlOworICAg ICAgZWRnZSBlLCBlZmFsc2U7CisgICAgICB0cmVlIG1hc2ssIHZhbDsKKyAg ICAgIGJhc2ljX2Jsb2NrIHN0b3JlX2JiLCBqb2luX2JiOworICAgICAgZ2lt cGxlX3N0bXRfaXRlcmF0b3IgZ3NpX3RvOworICAgICAgZ2ltcGxlX3NlcSBn czsKKyAgICAgIHRyZWUgYXJnMzsKKyAgICAgIHRyZWUgdmRlZiwgbmV3X3Zk ZWY7CisgICAgICBncGhpICpwaGk7CisgICAgICBib29sIGZpcnN0X2R1bXA7 CisKKyAgICAgIGxhc3QgPSB3b3JrbGlzdC5wb3AgKCk7CisgICAgICBtYXNr ID0gZ2ltcGxlX2NhbGxfYXJnIChsYXN0LCAyKTsKKyAgICAgIHZhbCA9IG1h a2Vfc3NhX25hbWUgKGludGVnZXJfdHlwZV9ub2RlKTsKKyAgICAgIGdzID0g TlVMTDsKKyAgICAgIC8qIEVzY2FwZSBpZiB0YXJnZXQgZG9lcyBub3Qgc3Vw cG9ydCB0ZXN0IG9uIHplcm8gbWFzay4gICovCisKKyAgICAgIGlmICghdGFy Z2V0bS52ZWN0b3JpemUuYnVpbGRfemVyb192ZWN0b3JfdGVzdCAobWFzaywg dmFsLCAmZ3MpKQorCXsKKwkgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkg ICAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiVGFyZ2V0IGRvZXMgbm90IHN1 cHBvcnQgcHRlc3QhXG4iKTsKKwkgIHJldHVybjsKKwl9CisgICAgICBnY2Nf YXNzZXJ0IChncyAhPSBOVUxMKTsKKworICAgICAgLyogQ3JlYXRlIG5ldyBi Yi4gICovCisgICAgICBlID0gc3BsaXRfYmxvY2sgKGJiLCBsYXN0KTsKKyAg ICAgIGpvaW5fYmIgPSBlLT5kZXN0OworICAgICAgc3RvcmVfYmIgPSBjcmVh dGVfZW1wdHlfYmIgKGJiKTsKKyAgICAgIGFkZF9iYl90b19sb29wIChzdG9y ZV9iYiwgbG9vcCk7CisgICAgICBlLT5mbGFncyA9IEVER0VfVFJVRV9WQUxV RTsKKyAgICAgIGVmYWxzZSA9IG1ha2VfZWRnZSAoYmIsIHN0b3JlX2JiLCBF REdFX0ZBTFNFX1ZBTFVFKTsKKyAgICAgIC8qIERvbid0IHdhbnQgdG8gcHV0 IFNUT1JFX0JCIHRvIHVubGlrZWx5IHBhcnQgYW5kIHVzZQorCSA1MCUgcHJv YmFiaWxpdHkuICAqLworICAgICAgc3RvcmVfYmItPmZyZXF1ZW5jeSA9IGJi LT5mcmVxdWVuY3kgLyAyOworICAgICAgZWZhbHNlLT5wcm9iYWJpbGl0eSA9 IFJFR19CUl9QUk9CX0JBU0UgLyAyOworICAgICAgbWFrZV9lZGdlIChzdG9y ZV9iYiwgam9pbl9iYiwgRURHRV9GQUxMVEhSVSk7CisgICAgICBpZiAoZG9t X2luZm9fYXZhaWxhYmxlX3AgKENESV9ET01JTkFUT1JTKSkKKwlzZXRfaW1t ZWRpYXRlX2RvbWluYXRvciAoQ0RJX0RPTUlOQVRPUlMsIHN0b3JlX2JiLCBi Yik7CisKKyAgICAgIC8qIENyZWF0ZSB6ZXJvIHRlc3QgY29uZGl0aW9uLiAg Ki8KKyAgICAgIHN0bXQgPSBnaW1wbGVfYnVpbGRfY29uZCAoTkVfRVhQUiwg dmFsLCBpbnRlZ2VyX3plcm9fbm9kZSwKKwkJCQlOVUxMX1RSRUUsIE5VTExf VFJFRSk7CisgICAgICBnaW1wbGVfc2VxX2FkZF9zdG10ICgmZ3MsIHN0bXQp OworICAgICAgZ3NpID0gZ3NpX2xhc3RfYmIgKGJiKTsKKyAgICAgIGdzaV9p bnNlcnRfc2VxX2FmdGVyICgmZ3NpLCBncywgR1NJX1NBTUVfU1RNVCk7Cisg ICAgICAvKiBDcmVhdGUgbmV3IFBISSBub2RlIGZvciB2ZGVmIG9mIHRoZSBs YXN0IG1hc2tlZCBzdG9yZToKKwkgLk1FTV8yID0gVkRFRiA8Lk1FTV8xPgor CSB3aWxsIGJlIGNvbnZlcnRlZCB0bworCSAuTUVNLjMgPSBWREVGIDwuTUVN XzE+CisJIGFuZCBuZXcgUEhJIG5vZGUgd2lsbCBiZSBjcmVhdGVkIGluIGpv aW4gYmIKKwkgLk1FTV8yID0gUEhJIDwuTUVNXzEsIC5NRU1fMz4KKyAgICAg ICovCisgICAgICB2ZGVmID0gZ2ltcGxlX3ZkZWYgKGxhc3QpOworICAgICAg Z2NjX2Fzc2VydCAodmRlZiAmJiBUUkVFX0NPREUgKHZkZWYpID09IFNTQV9O QU1FKTsKKyAgICAgIG5ld192ZGVmID0gbWFrZV9zc2FfbmFtZSAoZ2ltcGxl X3ZvcCAoY2Z1biksIGxhc3QpOworICAgICAgcGhpID0gY3JlYXRlX3BoaV9u b2RlICh2ZGVmLCBqb2luX2JiKTsKKyAgICAgIGFkZF9waGlfYXJnIChwaGks IG5ld192ZGVmLCBFREdFX1NVQ0MgKHN0b3JlX2JiLCAwKSwgVU5LTk9XTl9M T0NBVElPTik7CisgICAgICBnaW1wbGVfc2V0X3ZkZWYgKGxhc3QsIG5ld192 ZGVmKTsKKyAgICAgIGZpcnN0X2R1bXAgPSB0cnVlOworCisgICAgICAvKiBQ dXQgYWxsIG1hc2tlZCBzdG9yZXMgd2l0aCB0aGUgc2FtZSBtYXNrIHRvIFNU T1JFX0JCIGlmIHBvc3NpYmxlLiAgKi8KKyAgICAgIHdoaWxlICh0cnVlKQor CXsKKwkgIC8qIE1vdmUgbWFza2VkIHN0b3JlIHRvIFNUT1JFX0JCLiAgKi8K KwkgIGxhc3Rfc3RvcmUgPSBsYXN0OworCSAgZ3NpID0gZ3NpX2Zvcl9zdG10 IChsYXN0KTsKKwkgIGdzaV90byA9IGdzaV9zdGFydF9iYiAoc3RvcmVfYmIp OworCSAgZ3NpX21vdmVfYmVmb3JlICgmZ3NpLCAmZ3NpX3RvKTsKKwkgIHVw ZGF0ZV9zdG10IChsYXN0KTsKKwkgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkK KwkgICAgeworCSAgICAgIC8qIElzc3VlIGRpZmZlcmVudCBtZXNzYWdlcyBk ZXBlbmRpbmcgb24gRklSU1RfRFVNUC4gICovCisJICAgICAgaWYgKGZpcnN0 X2R1bXApCisJCXsKKwkJICBkdW1wX3ByaW50ZiAoTVNHX05PVEUsICJNb3Zl IE1BU0tfU1RPUkUgdG8gbmV3IGJiIyVkXG4iLAorCQkJICAgICAgIHN0b3Jl X2JiLT5pbmRleCk7CisJCSAgZmlyc3RfZHVtcCA9IGZhbHNlOworCQl9CisJ ICAgICAgZWxzZQorCQlkdW1wX3ByaW50ZiAoTVNHX05PVEUsICJNb3ZlIE1B U0tfU1RPUkUgdG8gY3JlYXRlZCBiYlxuIik7CisJICAgICAgZHVtcF9naW1w bGVfc3RtdCAoTVNHX05PVEUsIFRERl9TTElNLCBsYXN0LCAwKTsKKwkgICAg fQorCSAgLyogUHV0IGRlZmluaXRpb24gc3RhdGVtZW50IG9mIHN0b3JlZCB2 YWx1ZSBpbiBTVE9SRV9CQgorCSAgICAgaWYgcG9zc2libGUuICAqLworCSAg YXJnMyA9IGdpbXBsZV9jYWxsX2FyZyAobGFzdCwgMyk7CisJICBpZiAoVFJF RV9DT0RFIChhcmczKSA9PSBTU0FfTkFNRSAmJiBoYXNfc2luZ2xlX3VzZSAo YXJnMykpCisJICAgIHsKKwkgICAgICBkZWZfc3RtdCA9IFNTQV9OQU1FX0RF Rl9TVE1UIChhcmczKTsKKwkgICAgICAvKiBNb3ZlIGRlZl9zdG10IHRvIFNU T1JFX0JCIGlmIGl0IGlzIGluIHRoZSBzYW1lIGJiIGFuZAorCQkgaXQgaXMg bGVnYWwuICAqLworCSAgICAgIGlmIChnaW1wbGVfYmIgKGRlZl9zdG10KSA9 PSBiYgorCQkgICYmIGlzX3ZhbGlkX3NpbmsgKGRlZl9zdG10LCBsYXN0X3N0 b3JlKSkKKwkJeworCQkgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJICAg IHsKKwkJICAgICAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiTW92ZSBzdG10 IHRvIGNyZWF0ZWQgYmJcbiIpOworCQkgICAgICBkdW1wX2dpbXBsZV9zdG10 IChNU0dfTk9URSwgVERGX1NMSU0sIGRlZl9zdG10LCAwKTsKKwkJICAgIH0K KwkJICBnc2kgPSBnc2lfZm9yX3N0bXQgKGRlZl9zdG10KTsKKwkJICBnc2lf dG8gPSBnc2lfc3RhcnRfYmIgKHN0b3JlX2JiKTsKKwkJICBnc2lfbW92ZV9i ZWZvcmUgKCZnc2ksICZnc2lfdG8pOworCQkgIHVwZGF0ZV9zdG10IChkZWZf c3RtdCk7CisJCX0KKwkgICAgfQorCSAgICAvKiBQdXQgb3RoZXIgbWFza2Vk IHN0b3JlcyB3aXRoIHRoZSBzYW1lIG1hc2sgdG8gU1RPUkVfQkIuICAqLwor CSAgICBpZiAod29ya2xpc3QuaXNfZW1wdHkgKCkKKwkJfHwgZ2ltcGxlX2Nh bGxfYXJnICh3b3JrbGlzdC5sYXN0ICgpLCAyKSAhPSBtYXNrCisJCXx8ICFp c192YWxpZF9zaW5rICh3b3JrbGlzdC5sYXN0ICgpLCBsYXN0X3N0b3JlKSkK KwkgICAgICBicmVhazsKKwkgICAgbGFzdCA9IHdvcmtsaXN0LnBvcCAoKTsK Kwl9CisgICAgICBhZGRfcGhpX2FyZyAocGhpLCBnaW1wbGVfdnVzZSAobGFz dF9zdG9yZSksIGUsIFVOS05PV05fTE9DQVRJT04pOworICAgIH0KK30KKwog LyogRnVuY3Rpb24gdmVjdG9yaXplX2xvb3BzLgogCiAgICBFbnRyeSBwb2lu dCB0byBsb29wIHZlY3Rvcml6YXRpb24gcGhhc2UuICAqLwpAQCAtNTQyLDEz ICs3MjEsMTkgQEAgdmVjdG9yaXplX2xvb3BzICh2b2lkKQogICBmb3IgKGkg PSAxOyBpIDwgdmVjdF9sb29wc19udW07IGkrKykKICAgICB7CiAgICAgICBs b29wX3ZlY19pbmZvIGxvb3BfdmluZm87CisgICAgICBib29sIGhhc19tYXNr X3N0b3JlOwogCiAgICAgICBsb29wID0gZ2V0X2xvb3AgKGNmdW4sIGkpOwog ICAgICAgaWYgKCFsb29wKQogCWNvbnRpbnVlOwogICAgICAgbG9vcF92aW5m byA9IChsb29wX3ZlY19pbmZvKSBsb29wLT5hdXg7CisgICAgICBoYXNfbWFz a19zdG9yZSA9IGZhbHNlOworICAgICAgaWYgKGxvb3BfdmluZm8pCisJaGFz X21hc2tfc3RvcmUgPSBMT09QX1ZJTkZPX0hBU19NQVNLX1NUT1JFIChsb29w X3ZpbmZvKTsKICAgICAgIGRlc3Ryb3lfbG9vcF92ZWNfaW5mbyAobG9vcF92 aW5mbywgdHJ1ZSk7CiAgICAgICBsb29wLT5hdXggPSBOVUxMOworICAgICAg aWYgKGhhc19tYXNrX3N0b3JlKQorCW9wdGltaXplX21hc2tfc3RvcmVzIChs b29wKTsKICAgICB9CiAKICAgZnJlZV9zdG10X3ZlY19pbmZvX3ZlYyAoKTsK ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Rvcml6ZXIuaCBiL2djYy90cmVl LXZlY3Rvcml6ZXIuaAppbmRleCBiN2NlOTQxLi5lYjhlMTljIDEwMDY0NAot LS0gYS9nY2MvdHJlZS12ZWN0b3JpemVyLmgKKysrIGIvZ2NjL3RyZWUtdmVj dG9yaXplci5oCkBAIC0zNjksNiArMzY5LDkgQEAgdHlwZWRlZiBzdHJ1Y3Qg X2xvb3BfdmVjX2luZm8gewogICAgICBsb29wIHZlcnNpb24gd2l0aG91dCBp Zi1jb252ZXJzaW9uLiAgKi8KICAgc3RydWN0IGxvb3AgKnNjYWxhcl9sb29w OwogCisgIC8qIE1hcmsgbG9vcHMgaGF2aW5nIG1hc2tlZCBzdG9yZXMuICAq LworICBib29sIGhhc19tYXNrX3N0b3JlOworCiB9ICpsb29wX3ZlY19pbmZv OwogCiAvKiBBY2Nlc3MgRnVuY3Rpb25zLiAgKi8KQEAgLTQwNiw2ICs0MDks NyBAQCB0eXBlZGVmIHN0cnVjdCBfbG9vcF92ZWNfaW5mbyB7CiAjZGVmaW5l IExPT1BfVklORk9fUEVFTElOR19GT1JfTklURVIoTCkgICAgKEwpLT5wZWVs aW5nX2Zvcl9uaXRlcgogI2RlZmluZSBMT09QX1ZJTkZPX05PX0RBVEFfREVQ RU5ERU5DSUVTKEwpIChMKS0+bm9fZGF0YV9kZXBlbmRlbmNpZXMKICNkZWZp bmUgTE9PUF9WSU5GT19TQ0FMQVJfTE9PUChMKQkgICAoTCktPnNjYWxhcl9s b29wCisjZGVmaW5lIExPT1BfVklORk9fSEFTX01BU0tfU1RPUkUoTCkJICAg KEwpLT5oYXNfbWFza19zdG9yZQogCiAjZGVmaW5lIExPT1BfUkVRVUlSRVNf VkVSU0lPTklOR19GT1JfQUxJR05NRU5UKEwpIFwKICAgKChMKS0+bWF5X21p c2FsaWduX3N0bXRzLmxlbmd0aCAoKSA+IDApCg== --089e013d085ae505e90518cbaec8--