From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp-3.sys.kth.se (smtp-3.sys.kth.se [IPv6:2001:6b0:1:1300:250:56ff:fea6:2de2]) by sourceware.org (Postfix) with ESMTPS id 907B03858C3A; Tue, 31 Aug 2021 00:13:56 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 907B03858C3A Received: from smtp-3.sys.kth.se (localhost.localdomain [127.0.0.1]) by smtp-3.sys.kth.se (Postfix) with ESMTP id B6D8D35A5; Tue, 31 Aug 2021 02:13:54 +0200 (CEST) X-Virus-Scanned: by amavisd-new at kth.se Received: from smtp-3.sys.kth.se ([127.0.0.1]) by smtp-3.sys.kth.se (smtp-3.sys.kth.se [127.0.0.1]) (amavisd-new, port 10024) with LMTP id OUEjdcnQbgJd; Tue, 31 Aug 2021 02:13:50 +0200 (CEST) Received: from exdb5.ug.kth.se (exdb5.ug.kth.se [192.168.32.60]) by smtp-3.sys.kth.se (Postfix) with ESMTPS id 879CD3308; Tue, 31 Aug 2021 02:13:50 +0200 (CEST) Received: from exdb6.ug.kth.se (192.168.32.61) by exdb5.ug.kth.se (192.168.32.60) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.858.15; Tue, 31 Aug 2021 02:13:49 +0200 Received: from exdb6.ug.kth.se ([192.168.32.61]) by exdb6.ug.kth.se ([192.168.32.61]) with mapi id 15.02.0858.015; Tue, 31 Aug 2021 02:13:49 +0200 From: Petter Tomner To: "gcc-patches@gcc.gnu.org" , "jit@gcc.gnu.org" Subject: [PATCH] jit : Generate debug info for variables Thread-Topic: [PATCH] jit : Generate debug info for variables Thread-Index: Aded81/JZTEbZr3kQEGb7a1Uc9O/Ow== Date: Tue, 31 Aug 2021 00:13:49 +0000 Message-ID: <005bad3cb21745d591cea63567d08d08@kth.se> Accept-Language: sv-SE, en-US Content-Language: sv-SE X-MS-Has-Attach: yes X-MS-TNEF-Correlator: x-originating-ip: [192.168.32.250] Content-Type: multipart/mixed; boundary="_002_005bad3cb21745d591cea63567d08d08kthse_" MIME-Version: 1.0 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: jit@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Jit mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 31 Aug 2021 00:14:07 -0000 --_002_005bad3cb21745d591cea63567d08d08kthse_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Hi, This is a patch to generate debug info for local variables as well as globa= ls.=20 With this, "ptype foo", "info variables", "info locals" etc works when debu= gging in GDB. Finalizing of global variable declares are moved to after locations are han= dled and done as Fortran, C, Go etc do it. Also, primitive types have their TYPE_NAME set= for debug info on types to work. Below are the patch, and I attached a testcase. Since it requires GDB to ru= n it might not be suitable? Make check-jit runs fine on Debian x64. Regards, >From d77e77104024c7ae9ce31b419dad1f0a5801fda7 Mon Sep 17 00:00:00 2001 From: Petter Tomner Date: Mon, 30 Aug 2021 01:44:07 +0200 Subject: [PATCH 1/2] libgccjit: Generate debug info for variables Finalize declares via available helpers after location is set. Set TYPE_NAME of primitives and friends to "int" etc. Debug info is now set properly for variables. 2021-08-31 Petter Tomner gcc/jit jit-playback.c jit-playback.h gcc/testsuite/jit.dg/ test-error-array-bounds.c: Array is not unsigned --- gcc/jit/jit-playback.c | 76 ++++++++++++++----- gcc/jit/jit-playback.h | 5 ++ .../jit.dg/test-error-array-bounds.c | 2 +- 3 files changed, 65 insertions(+), 18 deletions(-) diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c index 79ac525e5df..74321b0946a 100644 --- a/gcc/jit/jit-playback.c +++ b/gcc/jit/jit-playback.c @@ -165,7 +165,8 @@ gt_ggc_mx () =20 /* Given an enum gcc_jit_types value, get a "tree" type. */ =20 -static tree +tree +playback::context:: get_tree_node_for_type (enum gcc_jit_types type_) { switch (type_) @@ -192,11 +193,7 @@ get_tree_node_for_type (enum gcc_jit_types type_) return short_unsigned_type_node; =20 case GCC_JIT_TYPE_CONST_CHAR_PTR: - { - tree const_char =3D build_qualified_type (char_type_node, - TYPE_QUAL_CONST); - return build_pointer_type (const_char); - } + return m_const_char_ptr; =20 case GCC_JIT_TYPE_INT: return integer_type_node; @@ -579,10 +576,6 @@ playback::lvalue * playback::context:: global_finalize_lvalue (tree inner) { - varpool_node::get_create (inner); - - varpool_node::finalize_decl (inner); - m_globals.safe_push (inner); =20 return new lvalue (this, inner); @@ -2952,9 +2945,7 @@ replay () { JIT_LOG_SCOPE (get_logger ()); =20 - m_const_char_ptr - =3D build_pointer_type (build_qualified_type (char_type_node, - TYPE_QUAL_CONST)); + init_types (); =20 /* Replay the recorded events: */ timevar_push (TV_JIT_REPLAY); @@ -2984,15 +2975,22 @@ replay () { int i; function *func; - + tree global; /* No GC can happen yet; process the cached source locations. */ handle_locations (); =20 + /* Finalize globals. See how FORTRAN 95 does it in gfc_be_parse_file= () + for a simple reference. */ + FOR_EACH_VEC_ELT (m_globals, i, global) + rest_of_decl_compilation (global, true, true); + + wrapup_global_declarations (m_globals.address(), m_globals.length())= ; + /* We've now created tree nodes for the stmts in the various blocks - in each function, but we haven't built each function's single stmt - list yet. Do so now. */ + in each function, but we haven't built each function's single stmt + list yet. Do so now. */ FOR_EACH_VEC_ELT (m_functions, i, func) - func->build_stmt_list (); + func->build_stmt_list (); =20 /* No GC can have happened yet. */ =20 @@ -3081,6 +3079,50 @@ location_comparator (const void *lhs, const void *rh= s) return loc_lhs->get_column_num () - loc_rhs->get_column_num (); } =20 +/* Initialize the NAME_TYPE of the primitive types as well as some + others. */ +void +playback::context:: +init_types () +{ + /* See lto_init() in lto-lang.c or void visit (TypeBasic *t) in D's type= s.cc=20 + for reference. If TYPE_NAME is not set, debug info will not contain t= ypes */ +#define NAME_TYPE(t,n) \ +if (t) \ + TYPE_NAME (t) =3D build_decl (UNKNOWN_LOCATION, TYPE_DECL, \ + get_identifier (n), t) + + NAME_TYPE (integer_type_node, "int"); + NAME_TYPE (char_type_node, "char"); + NAME_TYPE (long_integer_type_node, "long int"); + NAME_TYPE (unsigned_type_node, "unsigned int"); + NAME_TYPE (long_unsigned_type_node, "long unsigned int"); + NAME_TYPE (long_long_integer_type_node, "long long int"); + NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int"); + NAME_TYPE (short_integer_type_node, "short int"); + NAME_TYPE (short_unsigned_type_node, "short unsigned int"); + if (signed_char_type_node !=3D char_type_node) + NAME_TYPE (signed_char_type_node, "signed char"); + if (unsigned_char_type_node !=3D char_type_node) + NAME_TYPE (unsigned_char_type_node, "unsigned char"); + NAME_TYPE (float_type_node, "float"); + NAME_TYPE (double_type_node, "double"); + NAME_TYPE (long_double_type_node, "long double"); + NAME_TYPE (void_type_node, "void"); + NAME_TYPE (boolean_type_node, "bool"); + NAME_TYPE (complex_float_type_node, "complex float"); + NAME_TYPE (complex_double_type_node, "complex double"); + NAME_TYPE (complex_long_double_type_node, "complex long double"); + + m_const_char_ptr =3D build_pointer_type( + build_qualified_type (char_type_node, TYPE_QUAL_CONST)); + + NAME_TYPE (m_const_char_ptr, "char"); + NAME_TYPE (size_type_node, "size_t"); + NAME_TYPE (fileptr_type_node, "FILE"); +#undef NAME_TYPE +} + /* Our API allows locations to be created in arbitrary orders, but the linemap API requires locations to be created in ascending order as if we were tokenizing files. diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h index 825a3e172e9..f670c9e81df 100644 --- a/gcc/jit/jit-playback.h +++ b/gcc/jit/jit-playback.h @@ -271,8 +271,13 @@ private: source_file * get_source_file (const char *filename); =20 + tree + get_tree_node_for_type (enum gcc_jit_types type_); + void handle_locations (); =20 + void init_types (); + const char * get_path_c_file () const; const char * get_path_s_file () const; const char * get_path_so_file () const; diff --git a/gcc/testsuite/jit.dg/test-error-array-bounds.c b/gcc/testsuite= /jit.dg/test-error-array-bounds.c index cd9361fba1d..b6c0ee526d4 100644 --- a/gcc/testsuite/jit.dg/test-error-array-bounds.c +++ b/gcc/testsuite/jit.dg/test-error-array-bounds.c @@ -70,5 +70,5 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *resul= t) /* ...and that the message was captured by the API. */ CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt), "array subscript 10 is above array bounds of" - " 'unsigned char[10]' [-Warray-bounds]"); + " 'char[10]' [-Warray-bounds]"); } --=20 2.20.1 --_002_005bad3cb21745d591cea63567d08d08kthse_ Content-Type: application/octet-stream; name="0002-Adding-unit-test-for-weak-linkage.patch" Content-Description: 0002-Adding-unit-test-for-weak-linkage.patch Content-Disposition: attachment; filename="0002-Adding-unit-test-for-weak-linkage.patch"; size=13006; creation-date="Sun, 08 Aug 2021 00:20:36 GMT"; modification-date="Sun, 08 Aug 2021 00:20:36 GMT" Content-Transfer-Encoding: base64 RnJvbSBiYTA1ODc3MmI5M2RjYjc4ZGI1YjA0YTQ2YzhkM2ZiZDllMzE5ZTgwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQZXR0ZXIgVG9tbmVyIDx0b21uZXJAa3RoLnNlPgpEYXRlOiBT dW4sIDggQXVnIDIwMjEgMDI6MDI6MDIgKzAyMDAKU3ViamVjdDogW1BBVENIIDIvM10gQWRkaW5n IHVuaXQgdGVzdCBmb3Igd2VhayBsaW5rYWdlCgotLS0KIGdjYy90ZXN0c3VpdGUvaml0LmRnL2Fs bC1ub24tZmFpbGluZy10ZXN0cy5oICB8ICAxMiArLQogZ2NjL3Rlc3RzdWl0ZS9qaXQuZGcvaGFy bmVzcy5oICAgICAgICAgICAgICAgIHwgICA1ICsKIGdjYy90ZXN0c3VpdGUvaml0LmRnL2ppdC5l eHAgICAgICAgICAgICAgICAgICB8ICA2OSArKysrKysKIC4uLi9qaXQuZGcvdGVzdC1jb21waWxl LXdlYWstc3ltYm9scy5jICAgICAgICB8IDIwNyArKysrKysrKysrKysrKysrKysKIGdjYy90ZXN0 c3VpdGUvaml0LmRnL3ZlcmlmeS13ZWFrLWxpbmthZ2UuYyAgICB8ICAyMSArKwogNSBmaWxlcyBj aGFuZ2VkLCAzMTMgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAw NjQ0IGdjYy90ZXN0c3VpdGUvaml0LmRnL3Rlc3QtY29tcGlsZS13ZWFrLXN5bWJvbHMuYwogY3Jl YXRlIG1vZGUgMTAwNjQ0IGdjYy90ZXN0c3VpdGUvaml0LmRnL3ZlcmlmeS13ZWFrLWxpbmthZ2Uu YwoKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvaml0LmRnL2FsbC1ub24tZmFpbGluZy10ZXN0 cy5oIGIvZ2NjL3Rlc3RzdWl0ZS9qaXQuZGcvYWxsLW5vbi1mYWlsaW5nLXRlc3RzLmgKaW5kZXgg ODRlZjU0YTAzODYuLjRkYTM0OTA1YTNkIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2ppdC5k Zy9hbGwtbm9uLWZhaWxpbmctdGVzdHMuaAorKysgYi9nY2MvdGVzdHN1aXRlL2ppdC5kZy9hbGwt bm9uLWZhaWxpbmctdGVzdHMuaApAQCAtMTA1LDYgKzEwNSwxMyBAQAogI3VuZGVmIGNyZWF0ZV9j b2RlCiAjdW5kZWYgdmVyaWZ5X2NvZGUKIAorLyogdGVzdC1jb21waWxlLXdlYWstc3ltYm9scy5j ICovCisjZGVmaW5lIGNyZWF0ZV9jb2RlIGNyZWF0ZV9jb2RlX3dlYWtfc3ltYm9scworI2RlZmlu ZSB2ZXJpZnlfY29kZSB2ZXJpZnlfY29kZV93ZWFrX3N5bWJvbHMKKyNpbmNsdWRlICJ0ZXN0LWNv bXBpbGUtd2Vhay1zeW1ib2xzLmMiCisjdW5kZWYgY3JlYXRlX2NvZGUKKyN1bmRlZiB2ZXJpZnlf Y29kZQorCiAvKiB0ZXN0LWNvbXBvdW5kLWFzc2lnbm1lbnQuYyAqLwogI2RlZmluZSBjcmVhdGVf Y29kZSBjcmVhdGVfY29kZV9jb21wb3VuZF9hc3NpZ25tZW50CiAjZGVmaW5lIHZlcmlmeV9jb2Rl IHZlcmlmeV9jb2RlX2NvbXBvdW5kX2Fzc2lnbm1lbnQKQEAgLTQ1NCw3ICs0NjEsMTAgQEAgY29u c3Qgc3RydWN0IHRlc3RjYXNlIHRlc3RjYXNlc1tdID0gewogICAgdmVyaWZ5X2NvZGVfdmVyc2lv bn0sCiAgIHsidm9sYXRpbGUiLAogICAgY3JlYXRlX2NvZGVfdm9sYXRpbGUsCi0gICB2ZXJpZnlf Y29kZV92b2xhdGlsZX0KKyAgIHZlcmlmeV9jb2RlX3ZvbGF0aWxlfSwKKyAgeyJ3ZWFrX3N5bWJv bHMiLAorICAgY3JlYXRlX2NvZGVfd2Vha19zeW1ib2xzLAorICAgdmVyaWZ5X2NvZGVfd2Vha19z eW1ib2xzfQogfTsKIAogY29uc3QgaW50IG51bV90ZXN0Y2FzZXMgPSAoc2l6ZW9mICh0ZXN0Y2Fz ZXMpIC8gc2l6ZW9mICh0ZXN0Y2FzZXNbMF0pKTsKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv aml0LmRnL2hhcm5lc3MuaCBiL2djYy90ZXN0c3VpdGUvaml0LmRnL2hhcm5lc3MuaAppbmRleCA2 YjU5ZmI1N2FhZS4uODRjMjQ4MzAzZjQgMTAwNjQ0Ci0tLSBhL2djYy90ZXN0c3VpdGUvaml0LmRn L2hhcm5lc3MuaAorKysgYi9nY2MvdGVzdHN1aXRlL2ppdC5kZy9oYXJuZXNzLmgKQEAgLTMzMSw2 ICszMzEsMTAgQEAgZHVtcF9yZXByb2R1Y2VyIChnY2Nfaml0X2NvbnRleHQgKmN0eHQsIGNvbnN0 IGNoYXIgKmFyZ3YwKQogICBmcmVlIChyZXByb2R1Y2VyX25hbWUpOwogfQogCitzdGF0aWMgdm9p ZAordGVzdF9qaXQgKGNvbnN0IGNoYXIgKmFyZ3YwLCB2b2lkICp1c2VyX2RhdGEpOworCisjaWZu ZGVmIFRFU1RfUFJPVklERVNfVEVTVF9KSVQKIC8qIFJ1biBvbmUgaXRlcmF0aW9uIG9mIHRoZSB0 ZXN0LiAgKi8KIHN0YXRpYyB2b2lkCiB0ZXN0X2ppdCAoY29uc3QgY2hhciAqYXJndjAsIHZvaWQg KnVzZXJfZGF0YSkKQEAgLTM4Myw2ICszODcsNyBAQCB0ZXN0X2ppdCAoY29uc3QgY2hhciAqYXJn djAsIHZvaWQgKnVzZXJfZGF0YSkKICAgaWYgKGxvZ2ZpbGUpCiAgICAgZmNsb3NlIChsb2dmaWxl KTsKIH0KKyNlbmRpZiAvKiAjaWZuZGVmIFRFU1RfUFJPVklERVNfVEVTVF9KSVQgKi8KICNlbmRp ZiAvKiAjaWZuZGVmIFRFU1RfRVNDSEVXU19URVNUX0pJVCAqLwogCiAvKiBXZSB3YW50IHRvIHBy ZWZpeCBhbGwgdW5pdCB0ZXN0IHJlc3VsdHMgd2l0aCB0aGUgdGVzdCwgYnV0IGRlamFnbnUuZXhw J3MKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvaml0LmRnL2ppdC5leHAgYi9nY2MvdGVzdHN1 aXRlL2ppdC5kZy9qaXQuZXhwCmluZGV4IDlhZjg3ZjljNmFkLi5mMjY5NzBhNDFlNiAxMDA2NDQK LS0tIGEvZ2NjL3Rlc3RzdWl0ZS9qaXQuZGcvaml0LmV4cAorKysgYi9nY2MvdGVzdHN1aXRlL2pp dC5kZy9qaXQuZXhwCkBAIC02OTIsNiArNjkyLDE5IEBAIHByb2Mgaml0LXZlcmlmeS1vdXRwdXQt ZmlsZS13YXMtY3JlYXRlZCB7IGFyZ3MgfSB7CiAgICAgfQogfQogCitwcm9jIGppdC12ZXJpZnkt b3V0cHV0LWZpbGVzLXdlcmUtY3JlYXRlZCB7IGFyZ3MgfSB7CisgICAgdmVyYm9zZSAiaml0LXZl cmlmeS1vdXRwdXQtZmlsZXMtd2VyZS1jcmVhdGVkOiAkYXJncyIKKworICAgIGZvcmVhY2ggb3V0 cHV0X2ZpbGVuYW1lICRhcmdzIHsKKyAgICAgICAgIyBWZXJpZnkgdGhhdCB0aGUgZXhwZWN0ZWQg ZmlsZXMgd2FzIHdyaXR0ZW4gb3V0CisgICAgICAgIGlmIHsgW2ZpbGUgZXhpc3RzICRvdXRwdXRf ZmlsZW5hbWVdID09IDF9IHsKKyAgICAgICAgcGFzcyAiJG91dHB1dF9maWxlbmFtZSBleGlzdHMi CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgIGZhaWwgIiRvdXRwdXRfZmlsZW5hbWUgZG9lcyBu b3QgZXhpc3QiCisgICAgICAgIH0KKyAgICB9Cit9CisKICMgVmVyaWZ5IHRoYXQgdGhlIGdpdmVu IGZpbGUgZXhpc3RzLCBhbmQgaXMgZXhlY3V0YWJsZS4KICMgQXR0ZW1wdCB0byBleGVjdXRlIGl0 LCBhbmQgdmVyaWZ5IHRoYXQgaXRzIHN0ZG91dCBtYXRjaGVzCiAjIHRoZSBnaXZlbiByZWdleC4K QEAgLTg0MCw2ICs4NTMsNjIgQEAgcHJvYyBqaXQtdmVyaWZ5LW9iamVjdCB7IGFyZ3MgfSB7CiAg ICAgaml0LXJ1bi1leGVjdXRhYmxlICR7ZXhlY3V0YWJsZV9mcm9tX29ian0gJHtkZy1vdXRwdXQt dGV4dH0KIH0KIAorIyBDb21waWxlICdzb3VyY2VzJyBhbmQgbGluayBpbiAnb2JqZWN0cycgYW5k IGV4ZWN1dGUgdGhlIHByb2dyYW0gCisjIGFuZCBjaGVjayB0aGF0IGl0cyBvdXRwdXQgbWF0Y2hl cyAnZXhwZWN0ZWRfb3V0cHV0Jy4KKyMKKyMgVGhlIHBhdGggdG8gdGhlIEpJVCB0ZXN0IHNvdXJj ZSBmb2xkZXIgaXMgcHJlcGVuZGVkIHRvIGVhY2gKKyMgd29yZCBpbiAnc291cmNlJy4KKyMKKyMg Rm9yIHVzZSB3aXRoIHRlc3QtY29tcGlsZS13ZWFrLXN5bWJvbHMuYyB0ZXN0Y2FzZS4KK3Byb2Mg aml0LXZlcmlmeS1zb3VyY2VzLW9iamVjdHMgeyBleHBlY3RlZF9vdXRwdXQgc291cmNlcyBvYmpl Y3RzIH0geworICAgIGdsb2JhbCBzcmNkaXIKKyAgICBnbG9iYWwgc3ViZGlyCisKKyAgICB2ZXJi b3NlICJqaXQtdmVyaWZ5LW9iamVjdHM6ICRleHBlY3RlZF9vdXRwdXQgJHNvdXJjZXMgJG9iamVj dHMiCisgICAgc2V0IGRnLW91dHB1dC10ZXh0ICRleHBlY3RlZF9vdXRwdXQKKworICAgICMgcHJl cGVuZCB0aGUgcGF0aCB0byB0aGUgZm9sZGVyIHdpdGggdGhlIEpJVCB0ZXN0cworICAgICMgdG8g ZWFjaCBzb3VyY2UKKyAgICBzZXQgcmVsX3BhdGggIiRzcmNkaXIvJHN1YmRpci8iCisgICAgc2V0 IHNyY3MgW2xtYXAgaSAkc291cmNlcyB7IHN0cmluZyBjYXQgJHJlbF9wYXRoICRpIH1dCisgICAg dmVyYm9zZSAic291cmNlcyBmdWxsIHBhdGg6ICR7c3Jjc30iCisKKyAgICB1cHZhciAyIG5hbWUg bmFtZQorICAgIHZlcmJvc2UgIm5hbWU6ICRuYW1lIgorCisgICAgdXB2YXIgMiBwcm9nIHByb2cK KyAgICB2ZXJib3NlICJwcm9nOiAkcHJvZyIKKworICAgICMgTmFtZSB0aGUgbGlua2VkIGV4ZWN1 dGFibGUgYXMgdGhlIGZpcnN0IHNvdXJjZQorICAgICMgd2l0aCAiLmV4ZSIgYXBwZW5kZWQuCisg ICAgc2V0IGV4ZWN1dGFibGVfZnJvbV9vYmogW2xpbmRleCAkc291cmNlcyAwXS5leGUKKyAgICB2 ZXJib3NlICIgIGV4ZWN1dGFibGVfZnJvbV9vYmo6ICR7ZXhlY3V0YWJsZV9mcm9tX29ian0iCisK KyAgICAjIEludm9rZSB0aGUgZHJpdmVyIHRvIGxpbmsgdGhlIC5vIGZpbGUgdG8gdGhlIC5leGUK KyAgICBzZXQgY29tcF9vdXRwdXQgW2djY190YXJnZXRfY29tcGlsZSBcCisgICAgICAgICAgICAi JHtzcmNzfSAke29iamVjdHN9IiBcCisgICAgICAgICAgICAgJHtleGVjdXRhYmxlX2Zyb21fb2Jq fSBcCisgICAgICAgICAgICAgImV4ZWN1dGFibGUiIFwKKyAgICAgICAgICAgICAie30iXQorICAg IGlmICFbaml0X2NoZWNrX2NvbXBpbGUgXAorICAgICAgICAgIiRuYW1lIiBcCisgICAgICAgICAi bGluayBvZiAke2V4ZWN1dGFibGVfZnJvbV9vYmp9IiBcCisgICAgICAgICAke2V4ZWN1dGFibGVf ZnJvbV9vYmp9IFwKKyAgICAgICAgICRjb21wX291dHB1dF0gdGhlbiB7CisgICAgICByZXR1cm4K KyAgICB9CisKKyAgICAjIFZlcmlmeSB0aGF0IHRoZSBleGVjdXRhYmxlIHdhcyBjcmVhdGVkLgor ICAgIGlmIHsgW2ZpbGUgZXhpc3RzICRleGVjdXRhYmxlX2Zyb21fb2JqXSA9PSAxfSB7CisgICAg cGFzcyAiJGV4ZWN1dGFibGVfZnJvbV9vYmogZXhpc3RzIgorICAgIH0gZWxzZSB7CisgICAgZmFp bCAiJGV4ZWN1dGFibGVfZnJvbV9vYmogZG9lcyBub3QgZXhpc3QiCisgICAgfQorCisgICAgIyBS dW4gaXQgYW5kIHZlcmlmeSB0aGF0IHRoZSBvdXRwdXQgbWF0Y2hlcyB0aGUgcmVnZXguCisgICAg aml0LXJ1bi1leGVjdXRhYmxlICR7ZXhlY3V0YWJsZV9mcm9tX29ian0gJHtkZy1vdXRwdXQtdGV4 dH0KK30KKwogIyBBc3N1bWluZyB0aGF0IGEgLnNvIGZpbGUgaGFzIGJlZW4gd3JpdHRlbiBvdXQg bmFtZWQKICMgT1VUUFVUX0ZJTEVOQU1FLCBidWlsZCBhIHRlc3QgZXhlY3V0YWJsZSB0byB1c2Ug aXQsCiAjIGFuZCB0cnkgdG8gcnVuIHRoZSByZXN1bHQuCmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1 aXRlL2ppdC5kZy90ZXN0LWNvbXBpbGUtd2Vhay1zeW1ib2xzLmMgYi9nY2MvdGVzdHN1aXRlL2pp dC5kZy90ZXN0LWNvbXBpbGUtd2Vhay1zeW1ib2xzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLjVhNzQ2ODUwMzQxCi0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3Rz dWl0ZS9qaXQuZGcvdGVzdC1jb21waWxlLXdlYWstc3ltYm9scy5jCkBAIC0wLDAgKzEsMjA3IEBA CisvKiBFc3NlbnRpYWxseSB0aGUgZ29hbCBvZiB0aGUgdGVzdCBpcyB0byBjcmVhdGUgYSB0d28g b2JqZWN0IGZpbGVzOgorCisgICB3ZWFrc3ltdGVzdF9mb29iYXJfd2Vhay5vOgorICAgIGludCBf X2F0dHJpYnV0ZV9fKCh3ZWFrKSkgd2Vha3N5bXRlc3RfZm9vKCkge3JldHVybiAxO30KKyAgICBp bnQgX19hdHRyaWJ1dGVfXygod2VhaykpIHdlYWtzeW10ZXN0X2JhcltdID0gezF9OworCisgICB3 ZWFrc3ltdGVzdF9mb29iYXIubzogICAKKyAgICBpbnQgd2Vha3N5bXRlc3RfZm9vKCkge3JldHVy biAyO30KKyAgICBpbnQgd2Vha3N5bXRlc3RfYmFyW10gPSB7Mn07CisKKyAgIGFuZCB0aGVuIGxp bmsgdGhlbSB0b2dldGhlciBhbmQgdmVyaWZ5IHRoYXQgdGhlIHdlYWsgc3ltYm9sIGlzIGFjdHVh bGx5IAorICAgd2VhayBhbmQgbm90IHRoZSBvbmUgdXNlZCBhZnRlciBsaW5raW5nLgorCisgICBT aW5jZSBtdWx0aXBsZSBvdXRmaWxlcyBhcmUgbmVlZGVkIHRoaXMgdGVzdCB1c2VzIFRFU1RfQ09N UElMSU5HX1RPX0ZJTEUKKyAgIGluIGEgc2xpZ2h0bHkgZGlmZmVyZW50IHdheSB0aGVuIHRoZSBv dGhlciB0ZXN0cy4gSXQgcHJvdmlkZXMgaXRzIG93bgorICAgdGVzdF9qaXQoKSB2aWEgVEVTVF9Q Uk9WSURFU19URVNUX0pJVC4KKyAgIAorICAgVGhpcyB0ZXN0IGlzIGRlcGVuZGVudCBvbiB2ZXJp Znktd2Vhay1saW5rYWdlLmMgd2hpY2ggaXMgYSBtYWluIGZ1bmN0aW9uCisgICB3aXRoIGRlY2xh cmF0aW9ucyBvZiBmb28gYW5kIGJhciBhbmQgdGhhdCBvdXRwdXRzIGZvbygpIGFuZCBiYXJbMF0g dG8gCisgICBzdGRvdXQuICovCisKKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdGRp by5oPgorCisjaW5jbHVkZSAibGliZ2Njaml0LmgiCisKKy8qIFdoZW4gaW5jbHVkZWQgaW4gYWxs LW5vbi1mYWlsaW5nLXRlc3RzLmggd2l0aCBDT01CSU5FRF9URVNUIGRlZmluZWQgCisgICB0aGlz IHRlc3RmaWxlIGRvZXMgbm90IHByb2R1Y2UgYW55IG91dHB1dCBmaWxlcy4gKi8KKyNpZm5kZWYg Q09NQklORURfVEVTVAorI2RlZmluZSBURVNUX0NPTVBJTElOR19UT19GSUxFCisjZGVmaW5lIFRF U1RfUFJPVklERVNfVEVTVF9KSVQKKyNpbmNsdWRlICJoYXJuZXNzLmgiCisjdW5kZWYgVEVTVF9Q Uk9WSURFU19URVNUX0pJVAorI2Vsc2UKKyNpbmNsdWRlICJoYXJuZXNzLmgiCisjZW5kaWYKKwor ZXh0ZXJuIHZvaWQKK2NyZWF0ZV9jb2RlX3dlYWtfb3Jfbm9ybWFsIChnY2Nfaml0X2NvbnRleHQg KmN0eHQsIGludCBjcmVhdGVfd2Vhayk7CisKK3R5cGVkZWYgaW50ICgqZm9vcHRyKSh2b2lkKTsK Kwordm9pZAordmVyaWZ5X2NvZGUgKGdjY19qaXRfY29udGV4dCAqY3R4dCwgZ2NjX2ppdF9yZXN1 bHQgKnJlc3VsdCkKK3sKKyAgKHZvaWQpIGN0eHQ7IC8qIE5vdCB1c2VkICovCisKKyAgZm9vcHRy IGZvbyA9IGdjY19qaXRfcmVzdWx0X2dldF9jb2RlIChyZXN1bHQsICJ3ZWFrc3ltdGVzdF9mb28i KTsKKyAgaW50ICpiYXIgPSBnY2Nfaml0X3Jlc3VsdF9nZXRfZ2xvYmFsIChyZXN1bHQsICJ3ZWFr c3ltdGVzdF9iYXIiKTsKKworICAvKiBKdXN0IGRvIGEgc2ltcGxlIHRlc3QgYWNjZXNzaW5nIHRo ZSB3ZWFrIHN5bWJvbHMgZnJvbSB0aGUKKyAgICAgSklUIGNvbnRleHQgKi8KKyAgQ0hFQ0tfVkFM VUUgKCpiYXIsIDEpOworICBDSEVDS19WQUxVRSAoZm9vKCksIDEpOworfQorCisvKiBEbyBub3Qg cHJvdmlkZSB0ZXN0X2ppdCgpIHdoZW4gaW5jbHVkZWQgaW4gYWxsLW5vbi1mYWlsaW5nLXRlc3Qu aCAqLworI2lmbmRlZiBDT01CSU5FRF9URVNUCisvKiBSdW5zIG9uZSBpdGVyYXRpb24gb2YgdGhl IHRlc3QuICovCitzdGF0aWMgdm9pZAordGVzdF9qaXQgKGNvbnN0IGNoYXIgKmFyZ3YwLCB2b2lk ICp1c2VyX2RhdGEpCit7CisgIGdjY19qaXRfY29udGV4dCAqY3R4dF9ub3JtYWwsICpjdHh0X3dl YWs7CisgIEZJTEUgKmxvZ2ZpbGVfbm9ybWFsLCAqbG9nZmlsZV93ZWFrOworICBjaGFyICphcmd2 MF93ZWFrLCAqYXJndjBfbm9ybWFsOworCisgICh2b2lkKSB1c2VyX2RhdGE7IC8qIE5vdCB1c2Vk ICovCisKKyAgYXJndjBfd2VhayA9IGNvbmNhdF9zdHJpbmdzIChhcmd2MCwgIi53ZWFrIik7Cisg IGFyZ3YwX25vcm1hbCA9IGNvbmNhdF9zdHJpbmdzIChhcmd2MCwgIi5ub3JtYWwiKTsKKworICB1 bmxpbmsgKCJ3ZWFrc3ltdGVzdF9mb29iYXJfd2Vhay5vIik7CisgIHVubGluayAoIndlYWtzeW10 ZXN0X2Zvb2Jhci5vIik7CisgIAorICBjdHh0X3dlYWsgPSBnY2Nfaml0X2NvbnRleHRfYWNxdWly ZSAoKTsKKyAgY3R4dF9ub3JtYWwgPSBnY2Nfaml0X2NvbnRleHRfYWNxdWlyZSAoKTsKKyAgaWYg KCFjdHh0X25vcm1hbCB8fCAhY3R4dF93ZWFrKQorICAgIHsKKyAgICAgIGZhaWwgKCJnY2Nfaml0 X2NvbnRleHRfYWNxdWlyZSBmYWlsZWQiKTsKKyAgICAgIHJldHVybjsKKyAgICB9CisgIAorICBs b2dmaWxlX3dlYWsgPSBzZXRfdXBfbG9nZ2luZyAoY3R4dF93ZWFrLCBhcmd2MF93ZWFrKTsKKyAg bG9nZmlsZV9ub3JtYWwgPSBzZXRfdXBfbG9nZ2luZyAoY3R4dF9ub3JtYWwsIGFyZ3YwX25vcm1h bCk7CisKKyAgc2V0X29wdGlvbnMgKGN0eHRfbm9ybWFsLCBhcmd2MF9ub3JtYWwpOworICBzZXRf b3B0aW9ucyAoY3R4dF93ZWFrLCBhcmd2MF93ZWFrKTsKKworICBmcmVlIChhcmd2MF93ZWFrKTsg YXJndjBfd2VhayA9IDA7CisgIGZyZWUgKGFyZ3YwX25vcm1hbCk7IGFyZ3YwX25vcm1hbCA9IDA7 CisKKyAgY3JlYXRlX2NvZGVfd2Vha19vcl9ub3JtYWwgKGN0eHRfbm9ybWFsLCAwKTsKKyAgY3Jl YXRlX2NvZGVfd2Vha19vcl9ub3JtYWwgKGN0eHRfd2VhaywgMSk7CisKKyAgLyogTm90ZSB0aGF0 IGFyZ3YwIGlzIHVzZWQgaW5zdGVhZCBvZiBhcmd2MF93ZWFrIHNpbmNlIAorICAgICBqaXQtZGct dGVzdCBleHBlY3RzIGEgY2VydGFpbiBuYW1lIG9mIHRoZSBkdW1wZmlsZS4gKi8KKyAgZHVtcF9y ZXByb2R1Y2VyIChjdHh0X3dlYWssIGFyZ3YwKTsKKworICBnY2Nfaml0X2NvbnRleHRfY29tcGls ZV90b19maWxlIChjdHh0X25vcm1hbCwKKyAgICAgICAgICAgR0NDX0pJVF9PVVRQVVRfS0lORF9P QkpFQ1RfRklMRSwKKyAgICAgICAgICAgIndlYWtzeW10ZXN0X2Zvb2Jhcl9uLm8iKTsKKyAgZ2Nj X2ppdF9jb250ZXh0X2NvbXBpbGVfdG9fZmlsZSAoY3R4dF93ZWFrLAorICAgICAgICAgICBHQ0Nf SklUX09VVFBVVF9LSU5EX09CSkVDVF9GSUxFLAorICAgICAgICAgICAid2Vha3N5bXRlc3RfZm9v YmFyX3cubyIpOworCisgIC8qIGxkIHRyZWF0cyB3ZWFrIHN5bWJvbHMgaW4gc2hhcmVkIGxpYnJh cmllcyBsaWtlCisgICAgIG5vcm1hbCBzeW1ib2xzIHVubGVzcyBlbnYudmFyLiBMRF9EWU5BTUlD X1dFQUsgaXMgc2V0LAorICAgICBzbyBkeW5hbWljIGxpYnJhcmllcyBhcmUgYSBiaXQgYXdrd2Fy ZCB0byB0ZXN0IGluCisgICAgIGEgdW5pdCB0ZXN0IGxpa2Ugd2UgZG8gaGVyZS4gSG93ZXZlciBp dCBpcyBlYXN5IAorICAgICB0byBjaGVjayBtYW51YWxseSB0aGF0IHRoZSBzeW1ib2xzIGFyZSB3 ZWFrIHdpdGggCisgICAgIG9iamR1bXAgZXRjLiAqLworI2lmIDAKKyAgdW5saW5rICgid2Vha3N5 bXRlc3RfZm9vYmFyX3dlYWsuc28iKTsKKyAgdW5saW5rICgid2Vha3N5bXRlc3RfZm9vYmFyLnNv Iik7CisgIGdjY19qaXRfY29udGV4dF9jb21waWxlX3RvX2ZpbGUgKGN0eHRfd2VhaywKKyAgICAg ICAgICAgICAgICAgIEdDQ19KSVRfT1VUUFVUX0tJTkRfRFlOQU1JQ19MSUJSQVJZLAorICAgICAg ICAgICAgICAgICAgImxpYndlYWtzeW10ZXN0X2Zvb2Jhcl93LnNvIik7CisgIGdjY19qaXRfY29u dGV4dF9jb21waWxlX3RvX2ZpbGUgKGN0eHRfbm9ybWFsLAorICAgICAgICAgICAgICAgICAgR0ND X0pJVF9PVVRQVVRfS0lORF9EWU5BTUlDX0xJQlJBUlksCisgICAgICAgICAgICAgICAgICAibGli d2Vha3N5bXRlc3RfZm9vYmFyX24uc28iKTsKKyNlbmRpZgorCisgIC8qIEZvciBjaGVja2luZyB3 ZXRoZXIgdGhlIGMtbGlrZSBkdW1wIGxvb2tzIG9rICovCisjaWYgMAorICB1bmxpbmsoImxpYndl YWtzeW10ZXN0X2Zvb2Jhcl93LmMiKTsKKyAgZ2NjX2ppdF9jb250ZXh0X2R1bXBfdG9fZmlsZSAo Y3R4dF93ZWFrLCAibGlid2Vha3N5bXRlc3RfZm9vYmFyX3cuYyIsIDApOworI2VuZGlmCisKKyAg Q0hFQ0tfTk9fRVJST1JTIChjdHh0X25vcm1hbCk7CisgIENIRUNLX05PX0VSUk9SUyAoY3R4dF93 ZWFrKTsKKworICBnY2Nfaml0X3Jlc3VsdCAqcmVzdWx0X3dlYWsgPSBnY2Nfaml0X2NvbnRleHRf Y29tcGlsZSAoY3R4dF93ZWFrKTsKKyAgQ0hFQ0tfTk9OX05VTEwgKHJlc3VsdF93ZWFrKTsKKyAg LyogSnVzdCBkb2VzIHNvbWUgc2ltcGxlIGFjY2VzcyBhbmQgdmFsdWUgY2hlY2sgb2YgdGhlIHdl YWsgc3ltYm9scyAqLworICBDSEVDS19OT19FUlJPUlMgKGN0eHRfd2Vhayk7CisgIHZlcmlmeV9j b2RlIChjdHh0X3dlYWssIHJlc3VsdF93ZWFrKTsKKworICBnY2Nfaml0X3Jlc3VsdF9yZWxlYXNl IChyZXN1bHRfd2Vhayk7CisKKyAgZ2NjX2ppdF9jb250ZXh0X3JlbGVhc2UgKGN0eHRfbm9ybWFs KTsKKyAgZ2NjX2ppdF9jb250ZXh0X3JlbGVhc2UgKGN0eHRfd2Vhayk7CisKKyAgaWYgKGxvZ2Zp bGVfbm9ybWFsKQorICAgIGZjbG9zZSAobG9nZmlsZV9ub3JtYWwpOworICBpZiAobG9nZmlsZV93 ZWFrKQorICAgIGZjbG9zZSAobG9nZmlsZV93ZWFrKTsKK30KKyNlbmRpZiAvKiAjaWZuZGVmIENP TUJJTkVEX1RFU1QgKi8KKworZXh0ZXJuIHZvaWQKK2NyZWF0ZV9jb2RlX3dlYWtfb3Jfbm9ybWFs IChnY2Nfaml0X2NvbnRleHQgKmN0eHQsIGludCBjcmVhdGVfd2VhaykKK3sKKyAgZW51bSBnY2Nf aml0X2Z1bmN0aW9uX2tpbmQgZm5fa2luZDsKKyAgZW51bSBnY2Nfaml0X2dsb2JhbF9raW5kIHZh cl9raW5kOworICBpbnQgdmFsdWU7CisgIGludCBhcnJbMV07CisKKyAgaWYgKGNyZWF0ZV93ZWFr KSAKKyAgICB7CisgICAgICBmbl9raW5kID0gR0NDX0pJVF9GVU5DVElPTl9FWFBPUlRFRF9XRUFL OworICAgICAgdmFyX2tpbmQgPSBHQ0NfSklUX0dMT0JBTF9FWFBPUlRFRF9XRUFLOworICAgICAg dmFsdWUgPSAxOworICAgIH0gCisgIGVsc2UgCisgICAgeworICAgICAgZm5fa2luZCA9IEdDQ19K SVRfRlVOQ1RJT05fRVhQT1JURUQ7CisgICAgICB2YXJfa2luZCA9IEdDQ19KSVRfR0xPQkFMX0VY UE9SVEVEOworICAgICAgdmFsdWUgPSAyOworICAgIH0KKworICAvKiBpbnQgX19hdHRyaWJ1dGVf Xygod2VhaykpIGZvbygpIHsgcmV0dXJuIDE7fQorICAgICBpbnQgZm9vKCkgeyByZXR1cm4gMjt9 ICovCisgIGdjY19qaXRfdHlwZSAqaW50X3R5cGUgPSAKKyAgICBnY2Nfaml0X2NvbnRleHRfZ2V0 X3R5cGUgKGN0eHQsIEdDQ19KSVRfVFlQRV9JTlQpOworICBnY2Nfaml0X2Z1bmN0aW9uICpmb28g PSAKKyAgICBnY2Nfaml0X2NvbnRleHRfbmV3X2Z1bmN0aW9uIChjdHh0LCAwLCBmbl9raW5kLCBp bnRfdHlwZSwgCisgICAgIndlYWtzeW10ZXN0X2ZvbyIsIDAsMCwwKTsKKyAgZ2NjX2ppdF9ibG9j ayAqYmxvY2sxID0KKyAgICBnY2Nfaml0X2Z1bmN0aW9uX25ld19ibG9jayAoZm9vLCAiYmxvY2sx Iik7CisgIGdjY19qaXRfYmxvY2tfZW5kX3dpdGhfcmV0dXJuIChibG9jazEsIDAsIAorICAgIGdj Y19qaXRfY29udGV4dF9uZXdfcnZhbHVlX2Zyb21faW50IChjdHh0LCBpbnRfdHlwZSwgdmFsdWUp KTsKKyAgCisgIC8qIGludCBfX2F0dHJpYnV0ZV9fKCh3ZWFrKSkgYmFyW10gPSB7MX07CisgICAg IGludCBiYXJbXSA9IHsyfTsgKi8KKyAgZ2NjX2ppdF9sdmFsdWUgKmJhciA9IGdjY19qaXRfY29u dGV4dF9uZXdfZ2xvYmFsIChjdHh0LCAwLCB2YXJfa2luZCwgCisgICAgZ2NjX2ppdF9jb250ZXh0 X25ld19hcnJheV90eXBlIChjdHh0LCAwLCBpbnRfdHlwZSwgMSksICJ3ZWFrc3ltdGVzdF9iYXIi KTsKKyAgCisgIGFyclswXSA9IHZhbHVlOworICBnY2Nfaml0X2dsb2JhbF9zZXRfaW5pdGlhbGl6 ZXIgKGJhciwgKGNvbnN0IHZvaWQgKilhcnIsIHNpemVvZihpbnQpKTsKK30KKworLyogVGhpcyBm dW5jdGlvbiBpcyB1c2VkIGluIGFsbC1ub24tZmFpbGluZy10ZXN0LmggYW5kIGp1c3QgY3JlYXRl cyB0aGUKKyAgIHdlYWsgY29udGV4dCAqLwordm9pZAorY3JlYXRlX2NvZGUgKGdjY19qaXRfY29u dGV4dCAqY3R4dCwgdm9pZCAqdXNlcl9kYXRhKQoreworICAodm9pZCkgdXNlcl9kYXRhOworICBj cmVhdGVfY29kZV93ZWFrX29yX25vcm1hbCAoY3R4dCwgMSk7Cit9CisKKy8qIHsgZGctZmluYWwg eyBqaXQtdmVyaWZ5LW91dHB1dC1maWxlcy13ZXJlLWNyZWF0ZWQgIndlYWtzeW10ZXN0X2Zvb2Jh cl93Lm8iICJ3ZWFrc3ltdGVzdF9mb29iYXJfbi5vIn0gfSAqLworCisvKiBqaXQtdmVyaWZ5LXNv dXJjZXMtb2JqZWN0cyBjb21waWxlcyAidmVyaWZ5LXdlYWstbGlua2FnZS5jIiB3aXRoIHRoZSBv YmplY3QgZmlsZXMKKyAgIGFuZCBjaGVja3MgdGhhdCB0aGUgc3Rkb3V0IG9mIHRoZSByZXN1bHRp bmcgZXhlY3V0YWJsZSBtYXRjaGVzICIyXG4yXG4iIHdoaWNoIAorICAgaW5kaWNhdGVzIHRoYXQg dGhlIHdlYWsgc3ltYm9scyBhcmUgbm90IHVzZWQuICovCisKKy8qIHsgZGctZmluYWwgeyBqaXQt dmVyaWZ5LXNvdXJjZXMtb2JqZWN0cyAiMlxcbjJcXG4iICJ2ZXJpZnktd2Vhay1saW5rYWdlLmMi ICJ3ZWFrc3ltdGVzdF9mb29iYXJfdy5vIHdlYWtzeW10ZXN0X2Zvb2Jhcl9uLm8ifSB9ICovCmRp ZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2ppdC5kZy92ZXJpZnktd2Vhay1saW5rYWdlLmMgYi9n Y2MvdGVzdHN1aXRlL2ppdC5kZy92ZXJpZnktd2Vhay1saW5rYWdlLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmMzYWMxYjlhNTBkCi0tLSAvZGV2L251bGwKKysrIGIv Z2NjL3Rlc3RzdWl0ZS9qaXQuZGcvdmVyaWZ5LXdlYWstbGlua2FnZS5jCkBAIC0wLDAgKzEsMjEg QEAKKy8qIEZvciB1c2Ugd2l0aCBqaXQtdmVyaWZ5LXNvdXJjZXMtb2JqZWN0cworICAgdXNlZCBi eSB0ZXN0LWNvbXBpbGUtd2Vhay1zeW1ib2xzLmMKKworICAgVGhpcyBmaWxlIGlzIGxpbmtlZCB0 byB0d28gb2JqZWN0IGZpbGVzIC4gT25lIHdpdGgKKyAgIHdlYWsgc3ltYm9scywgb25lIHdpdGgg bm9ybWFsLiBJdCBwcmludHMgdGhlIHZhbHVlIAorICAgb2YgYmFyWzBdIGFuZCBmb28oKSBhbmQg c2hvdWxkIHByaW50IDJcbjJcbiBpZiB0aGUKKyAgIHdlYWsgc3ltYm9scyBhcmUgbm90IGxpbmtl ZCBpbi4gKi8KKworI2luY2x1ZGUgPHN0ZGlvLmg+CisKK2V4dGVybiBpbnQgd2Vha3N5bXRlc3Rf YmFyWzFdOworaW50IHdlYWtzeW10ZXN0X2ZvbygpOworCitpbnQKK21haW4gKGludCBhcmdjLCBj aGFyICoqYXJndikKK3sKKyAgcHJpbnRmICgiJWRcbiIsIHdlYWtzeW10ZXN0X2ZvbygpKTsKKyAg cHJpbnRmICgiJWRcbiIsIHdlYWtzeW10ZXN0X2JhclswXSk7CisgIHJldHVybiAwOworfQorCi0t IAoyLjIwLjEKCg== --_002_005bad3cb21745d591cea63567d08d08kthse_--