From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by sourceware.org (Postfix) with ESMTPS id B232C3858C60 for ; Tue, 2 Nov 2021 01:26:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org B232C3858C60 Received: from mail-il1-f198.google.com (mail-il1-f198.google.com [209.85.166.198]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-239-ml2Eyc1oPWC90GjKcyCGow-1; Mon, 01 Nov 2021 21:25:57 -0400 X-MC-Unique: ml2Eyc1oPWC90GjKcyCGow-1 Received: by mail-il1-f198.google.com with SMTP id g11-20020a056e021a2b00b0026ef3cb57beso1500281ile.20 for ; Mon, 01 Nov 2021 18:25:57 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=bKupw4sOdUet4gX2/y4gqfcaGxAjE+U5Qo2a2kl+ddI=; b=iKxe7DDckhqLQQjjMtYkmSqRcPAxFKUZMN+cX3wIrJ1kJwy9NGJiOOEfdOrmJiI9Mw 5FwhDVFbFHOLbSZlpKBHR7KhvnHXyW47tV3IX0N9V13l+GGUMTNJpzto8ZyBouUyQPZP YRLknZh7MBB2bhoQlX2yJgwWJ2M+RPMQDYgTczA9C2r5KeNqNGl7abM5i1JtwFKlKnDT seo5CK+xmra8Cn0hBW5Ce8bNoDSz9XlK3odQ5YXYmMMqehKWDiKXci6TiU/Efsccbw6C hzBvPxdN+R6oaDbXbUCN7mFS4IGISlNxVNDNAuhjKsJNcegUg8tUtRDC9xugctTK2JCI ptSA== X-Gm-Message-State: AOAM5300lKPLHtkHi6aZhb0kc8Jb2/t3uaTl2TxtyklrG+wd8NGMRd6u OzuI02r3U7milUfy+qi3WFarJd6gn42ozgZytG8MiZBaEBPZ7DlMZMzqhhhPBIdKJsrJEIiAk+2 jsU3NE/s96uFnvOH1pTnUSEVqY9sQMag= X-Received: by 2002:a05:6602:2d88:: with SMTP id k8mr14019408iow.18.1635816357158; Mon, 01 Nov 2021 18:25:57 -0700 (PDT) X-Google-Smtp-Source: ABdhPJxiv3oBopSwM7Be9KWEEdL7EgEoDIDZckSRLCP/7DQePNTuPVI4ZiV1eVDJIrXWE2iuhVCwfZLt8kpD6N3NdWU= X-Received: by 2002:a05:6602:2d88:: with SMTP id k8mr14019389iow.18.1635816356903; Mon, 01 Nov 2021 18:25:56 -0700 (PDT) MIME-Version: 1.0 References: <20210923180837.633173-1-rodgert@appliantology.com> <20210927141031.651313-1-rodgert@appliantology.com> In-Reply-To: From: Thomas Rodgers Date: Mon, 1 Nov 2021 18:25:45 -0700 Message-ID: Subject: Re: [PATCH] libstdc++: Clear padding bits in atomic compare_exchange To: Jonathan Wakely Cc: Thomas Rodgers , gcc Patches , "libstdc++" , Thomas Rodgers X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="000000000000df267705cfc42c67" X-Spam-Status: No, score=-13.6 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, HTML_MESSAGE, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, 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-Content-Filtered-By: Mailman/MimeDel 2.1.29 X-BeenThere: libstdc++@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++ mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 02 Nov 2021 01:26:05 -0000 --000000000000df267705cfc42c67 Content-Type: text/plain; charset="UTF-8" This should address Jonathan's feedback and adds support for atomic_ref On Wed, Sep 29, 2021 at 5:14 AM Jonathan Wakely wrote: > On Mon, 27 Sept 2021 at 15:11, Thomas Rodgers > wrote: > > > > From: Thomas Rodgers > > > > Now with checks for __has_builtin(__builtin_clear_padding) > > > > This change implements P0528 which requires that padding bits not > > participate in atomic compare exchange operations. All arguments to the > > generic template are 'sanitized' by the __builtin_clearpadding intrisic > > before they are used in comparisons. This alrequires that any stores > > also sanitize the incoming value. > > > > Signed-off-by: Thomas Rodgers > > > > libstdc++=v3/ChangeLog: > > > > * include/std/atomic (atomic::atomic(_Tp) clear padding for > > __cplusplus > 201703L. > > (atomic::store()) Clear padding. > > (atomic::exchange()) Likewise. > > (atomic::compare_exchange_weak()) Likewise. > > (atomic::compare_exchange_strong()) Likewise. > > Don't we also need this for std::atomic_ref, i.e. for the > __atomic_impl free functions in ? > > There we don't have any distinction between atomic_ref > and atomic_ref, they both use the same > implementations. But I think that's OK, as I think the built-in is > smart enough to be a no-op for types with no padding. > > > * testsuite/29_atomics/atomic/compare_exchange_padding.cc: New > > test. > > --- > > libstdc++-v3/include/std/atomic | 41 +++++++++++++++++- > > .../atomic/compare_exchange_padding.cc | 42 +++++++++++++++++++ > > 2 files changed, 81 insertions(+), 2 deletions(-) > > create mode 100644 > libstdc++-v3/testsuite/29_atomics/atomic/compare_exchange_padding.cc > > > > diff --git a/libstdc++-v3/include/std/atomic > b/libstdc++-v3/include/std/atomic > > index 936dd50ba1c..4ac9ccdc1ab 100644 > > --- a/libstdc++-v3/include/std/atomic > > +++ b/libstdc++-v3/include/std/atomic > > @@ -228,7 +228,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > atomic& operator=(const atomic&) = delete; > > atomic& operator=(const atomic&) volatile = delete; > > > > - constexpr atomic(_Tp __i) noexcept : _M_i(__i) { } > > +#if __cplusplus > 201703L && __has_builtin(__builtin_clear_padding) > > + constexpr atomic(_Tp __i) noexcept : _M_i(__i) > > + { __builtin_clear_padding(std::__addressof(_M_i)); } > > +#else > > + constexpr atomic(_Tp __i) noexcept : _M_i(__i) > > + { } > > +#endif > > Please write this as a single function with the preprocessor > conditions in the body: > > constexpr atomic(_Tp __i) noexcept : _M_i(__i) > { > #if __cplusplus > 201703L && __has_builtin(__builtin_clear_padding) > __builtin_clear_padding(std::__addressof(_M_i)); } > #endif > } > > This not only avoids duplication of the identical parts, but it avoids > warnings from ld.gold if you use --detect-odr-violations. Otherwise, > the linker can see a definition of that constructor on two different > lines (233 and 236), and so warns about possible ODR violations, > something like "warning: while linking foo: symbol > 'std::atomic::atomic(int)' defined in multiple places (possible > ODR violation): ...atomic:233 ... atomic:236" > > Can't we clear the padding for >= 201402L instead of only C++20? Only > C++11 has a problem with the built-in in a constexpr function, right? > So we can DTRT for C++14 upwards. > > > > > > operator _Tp() const noexcept > > { return load(); } > > @@ -268,12 +274,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > void > > store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept > > { > > +#if __has_builtin(__builtin_clear_padding) > > + __builtin_clear_padding(std::__addressof(__i)); > > +#endif > > We repeat this *a lot*. When I started work on this I defined a > non-member function in the __atomic_impl namespace: > > template > _GLIBCXX_ALWAYS_INLINE void > __clear_padding(_Tp& __val) noexcept > { > #if __has_builtin(__builtin_clear_padding) > __builtin_clear_padding(std::__addressof(__val)); > #endif > } > > Then you can just use that everywhere (except the constexpr > constructor), without all the #if checks. > > > > > __atomic_store(std::__addressof(_M_i), std::__addressof(__i), > int(__m)); > > } > > > > void > > store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile > noexcept > > { > > +#if __has_builtin(__builtin_clear_padding) > > + __builtin_clear_padding(std::__addressof(__i)); > > +#endif > > __atomic_store(std::__addressof(_M_i), std::__addressof(__i), > int(__m)); > > } > > > > @@ -300,6 +312,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > { > > alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; > > _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); > > +#if __has_builtin(__builtin_clear_padding) > > + __builtin_clear_padding(std::__addressof(__i)); > > +#endif > > __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), > > __ptr, int(__m)); > > return *__ptr; > > @@ -311,6 +326,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > { > > alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; > > _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); > > +#if __has_builtin(__builtin_clear_padding) > > + __builtin_clear_padding(std::__addressof(__i)); > > +#endif > > __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), > > __ptr, int(__m)); > > return *__ptr; > > @@ -322,6 +340,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > { > > __glibcxx_assert(__is_valid_cmpexch_failure_order(__f)); > > > > +#if __has_builtin(__builtin_clear_padding) > > + __builtin_clear_padding(std::__addressof(__e)); > > This unconditionally clears the padding of __e, which I don't think is > allowed. It potentially introduces a data race if another thread is > doing the CAS at the same time, and the program assumes that only the > CAS that fails will update expected. > > See the thread I started at > https://lists.isocpp.org/parallel/2020/12/3443.php > ("atomic compare_exchange and padding bits", 2020-12-03) > > The conclusion was that writing to __e is not allowed in the failure > case, so you need to make a copy of it (into a buffer, using memcpy), > then clear the padding in the copy, then try the > __atomic_compare_exchange and if it fails, copy back from the buffer > to __e. If all that extra work doesn't get inlined then we want to > only do it for types which might have padding bits, so I had > __atomic_impl::__maybe_has_padding in my unfinished patch: > > template > constexpr bool > __maybe_has_padding() > { > #if __has_builtin(__has_unique_object_representations) > return !__has_unique_object_representations(_Tp); > #else > return true; > #endif > } > > The MSVC implementation uses !__has_unique_object_representations(_Tp) > && !is_floating_point<_Tp>::value here, which is better than mine > above (FP types don't have unique object reps, but also don't have > padding bits). > > And then do something like this in compare_exchange_weak: > > > + { > +#if __has_builtin(__builtin_clear_padding) > + if _GLIBCXX_CONSTEXPR17 (__maybe_has_padding<_Tp>()) > + { > + _Val<_Tp> __expected0 = __expected; // XXX should use memcpy > + auto* __exp = __atomic_impl::__clear_padding(__expected0); > + auto* __des = __atomic_impl::__clear_padding(__desired); > + if (__atomic_compare_exchange(__ptr, __exp, __des, true, > + int(__success), int(__failure))) > + return true; > + __builtin_memcpy(std::__addressof(__expected), __exp, > sizeof(_Tp)); > + return false; > + } > +#endif > return __atomic_compare_exchange(__ptr, > std::__addressof(__expected), > > And similarly for compare_exchange_strong (or refactor them into one > function that takes a bool for weak/strong). > > If you do all that in __atomic_impl::compare_exchange_weak (making it > take a bool for weak/strong) then you can reuse it from > __atomic_impl:compare_exchange_strong, and then change the gneric > atomic::compare_exchange_{weak,strong} to use that as well. > > > > > > diff --git > a/libstdc++-v3/testsuite/29_atomics/atomic/compare_exchange_padding.cc > b/libstdc++-v3/testsuite/29_atomics/atomic/compare_exchange_padding.cc > > new file mode 100644 > > index 00000000000..0875f168097 > > --- /dev/null > > +++ > b/libstdc++-v3/testsuite/29_atomics/atomic/compare_exchange_padding.cc > > @@ -0,0 +1,42 @@ > > +// { dg-options "-std=gnu++2a" } > > +// { dg-do run { target c++2a } } > > We can (and should) use "20" not "2a". > > Does it need to be C++20 though, aren't all the clearings that are > being tested going to happen unconditionally? (well ... as long as the > builtin exists, which is true for GCC). > > > +// { dg-add-options libatomic } > > + > > +#include > > + > > +#include > > + > > +struct S { char c; short s; }; > > + > > +void __attribute__((noinline,noipa)) > > +fill_struct(S& s) > > +{ __builtin_memset(&s, 0xff, sizeof(S)); } > > + > > +bool > > +compare_struct(const S& a, const S& b) > > +{ return __builtin_memcmp(&a, &b, sizeof(S)) == 0; } > > + > > +int > > +main () > > +{ > > + S s; > > + fill_struct(s); > > + s.c = 'a'; > > + s.s = 42; > > + > > + std::atomic as{ s }; > > + auto ts = as.load(); > > + VERIFY( !compare_struct(s, ts) ); // padding cleared on construction > > + as.exchange(s); > > + auto es = as.load(); > > + VERIFY( compare_struct(ts, es) ); // padding cleared on exchange > > + > > + S n; > > + fill_struct(n); > > + n.c = 'b'; > > + n.s = 71; > > + // padding cleared on compexchg > > + VERIFY( as.compare_exchange_weak(s, n) ); > > Is it safe assume this won't fail spuriously? There is only one thread > doing the RMW operation, is that enough to avoid spurious failures? > > > + VERIFY( as.compare_exchange_strong(n, s) ); > > + return 0; > > +} > > -- > > 2.31.1 > > > > --000000000000df267705cfc42c67 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-libstdc-Clear-padding-bits-in-atomic-compare_exchang.patch" Content-Disposition: attachment; filename="0001-libstdc-Clear-padding-bits-in-atomic-compare_exchang.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kvhesy4a0 RnJvbSBiMjk2MDkwMmQxMTRjYjM0NDBjZWQwOWFiMTg3YmNiNzI1YjdmMDZjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBUaG9tYXMgUm9kZ2VycyA8cm9kZ2VydEB0d3JvZGdlcnMuY29t PgpEYXRlOiBUdWUsIDUgT2N0IDIwMjEgMTY6MTc6NDQgLTA3MDAKU3ViamVjdDogW1BBVENIXSBs aWJzdGRjKys6IENsZWFyIHBhZGRpbmcgYml0cyBpbiBhdG9taWMgY29tcGFyZV9leGNoYW5nZQoK VGhpcyBjaGFuZ2UgaW1wbGVtZW50cyBQMDUyOCB3aGljaCByZXF1aXJlcyB0aGF0IHBhZGRpbmcg Yml0cyBub3QKcGFydGljaXBhdGUgaW4gYXRvbWljIGNvbXBhcmUgZXhjaGFuZ2Ugb3BlcmF0aW9u cy4gQWxsIGFyZ3VtZW50cyB0byB0aGUKZ2VuZXJpYyB0ZW1wbGF0ZSBhcmUgJ3Nhbml0aXplZCcg YnkgdGhlIF9fYnVpbHRpbl9jbGVhcnBhZGRpbmcgaW50cmlzaWMKYmVmb3JlIHRoZXkgYXJlIHVz ZWQgaW4gY29tcGFyaXNvbnMuIFRoaXMgYWxyZXF1aXJlcyB0aGF0IGFueSBzdG9yZXMKYWxzbyBz YW5pdGl6ZSB0aGUgaW5jb21pbmcgdmFsdWUuCgpTaWduZWQtb2ZmLWJ5OiBUaG9tYXMgUm9kZ2Vy cyA8dHJvZGdlcnNAcmVkaGF0LmNvbT4KCmxpYnN0ZGMrKz12My9DaGFuZ2VMb2c6CgoJKiBpbmNs dWRlL3N0ZC9hdG9taWMgKGF0b21pYzxUPjo6YXRvbWljKF9UcCk6IGNsZWFyIHBhZGRpbmcgZm9y CglfX2NwbHVzcGx1cyA+IDIwMTcwM0wuCgkoYXRvbWljPFQ+OjpzdG9yZSgpKTogQ2xlYXIgcGFk ZGluZy4KCShhdG9taWM8VD46OmV4Y2hhbmdlKCkpOiBMaWtld2lzZS4KCShhdG9taWM8VD46OmNv bXBhcmVfZXhjaGFuZ2Vfd2VhaygpKTogTGlrZXdpc2UuCgkoYXRvbWljPFQ+Ojpjb21wYXJlX2V4 Y2hhbmdlX3N0cm9uZygpKTogTGlrZXdpc2UuCgkqIGluY2x1ZGUvYml0cy9hdG9taWNfYmFzZS5o IChfX2F0b21pY19pbXBsOjpfX2NsZWFyX3BhZGRpbmcoKSk6CgluZXcgZnVuY3Rpb24uCgkoX19h dG9taWNfaW1wbDo6X19tYXliZV9oYXNfcGFkZGluZygpKTogTGlrZXdpc2UuCgkoX19hdG9taWNf aW1wbDo6X19jb21wYXJlX2V4Y2hhbmdlKCkpOiBMaWtld2lzZS4KCShfX2F0b21pY19pbXBsOjpj b21wYXJlX2V4Y2hhbmdlX3dlYWsoKSk6IERlbGVnYXRlIHRvCglfX2NvbXBhcmVfZXhjaGFuZ2Uo KS4KCShfX2F0b21pY19pbXBsOjpjb21wYXJlX2V4Y2hhbmdlX3N0cm9uZygpKTogTGlrZXdpc2UK CSogdGVzdHN1aXRlLzI5X2F0b21pY3MvYXRvbWljL2NvbXBhcmVfZXhjaGFuZ2VfcGFkZGluZy5j YzogTmV3Cgl0ZXN0LgoJKiB0ZXN0c3VpdGUvMjhfYXRvbWljcy9hdG9taWNfcmVmL2NvbXBhcmVf ZXhjaGFuZ2VfcGFkZGluZy5jYzoKCUxpa2V3aXNlLgotLS0KIGxpYnN0ZGMrKy12My9pbmNsdWRl L2JpdHMvYXRvbWljX2Jhc2UuaCAgICAgICB8IDExMyArKysrKysrKysrKysrKysrLS0KIGxpYnN0 ZGMrKy12My9pbmNsdWRlL3N0ZC9hdG9taWMgICAgICAgICAgICAgICB8ICA3MyArKystLS0tLS0t LQogLi4uL2F0b21pY19yZWYvY29tcGFyZV9leGNoYW5nZV9wYWRkaW5nLmNjICAgIHwgIDQzICsr KysrKysKIDMgZmlsZXMgY2hhbmdlZCwgMTYwIGluc2VydGlvbnMoKyksIDY5IGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYnN0ZGMrKy12My90ZXN0c3VpdGUvMjlfYXRvbWljcy9h dG9taWNfcmVmL2NvbXBhcmVfZXhjaGFuZ2VfcGFkZGluZy5jYwoKZGlmZiAtLWdpdCBhL2xpYnN0 ZGMrKy12My9pbmNsdWRlL2JpdHMvYXRvbWljX2Jhc2UuaCBiL2xpYnN0ZGMrKy12My9pbmNsdWRl L2JpdHMvYXRvbWljX2Jhc2UuaAppbmRleCA3MWUxZGUwNzhiNS4uYmVlYzQxMjc2MWYgMTAwNjQ0 Ci0tLSBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvYXRvbWljX2Jhc2UuaAorKysgYi9saWJz dGRjKystdjMvaW5jbHVkZS9iaXRzL2F0b21pY19iYXNlLmgKQEAgLTkzNiw2ICs5MzYsODkgQEAg X0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX1ZFUlNJT04KICAgICAgIHsgcmV0dXJuIF9fYXRvbWlj X2ZldGNoX3N1YigmX01fcCwgX01fdHlwZV9zaXplKF9fZCksIGludChfX20pKTsgfQogICAgIH07 CiAKKyAgLy8gSW1wbGVtZW50YXRpb24gZGV0YWlscyBvZiBhdG9taWMgcGFkZGluZyBoYW5kbGlu ZworICBuYW1lc3BhY2UgX19hdG9taWNfaW1wbAorICB7CisgICAgdGVtcGxhdGU8dHlwZW5hbWUg X1RwPgorICAgICAgX0dMSUJDWFhfQUxXQVlTX0lOTElORSBfVHAqCisgICAgICBfX2NsZWFyX3Bh ZGRpbmcoX1RwJiBfX3ZhbCkgbm9leGNlcHQKKyAgICAgIHsKKwlhdXRvKiBfX3B0ciA9IHN0ZDo6 X19hZGRyZXNzb2YoX192YWwpOworI2lmIF9faGFzX2J1aWx0aW4oX19idWlsdGluX2NsZWFyX3Bh ZGRpbmcpCisJX19idWlsdGluX2NsZWFyX3BhZGRpbmcoc3RkOjpfX2FkZHJlc3NvZihfX3ZhbCkp OworI2VuZGlmCisJcmV0dXJuIF9fcHRyOworICAgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5h bWUgX1RwPgorICAgICAgY29uc3RleHByIGJvb2wKKyAgICAgIF9fbWF5YmVfaGFzX3BhZGRpbmco KQorICAgICAgeworI2lmIF9faGFzX2J1aWx0aW4oX19oYXNfdW5pcXVlX29iamVjdF9yZXByZXNl bnRhdGlvbnMpCisJcmV0dXJuICFfX2hhc191bmlxdWVfb2JqZWN0X3JlcHJlc2VudGF0aW9ucyhf VHApCisJICAmJiAhaXNfZmxvYXRpbmdfcG9pbnQ8X1RwPjo6dmFsdWU7CisjZWxzZQorCXJldHVy biB0cnVlOworI2VuZGlmCisgICAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBfVHA+Cisg ICAgICBfR0xJQkNYWF9BTFdBWVNfSU5MSU5FIGJvb2wKKyAgICAgIF9fY29tcGFyZV9leGNoYW5n ZShfVHAmIF9fdmFsLCBfVHAmIF9fZSwgX1RwJiBfX2ksIGJvb2wgX193ZWFrLAorCQkJIG1lbW9y eV9vcmRlciBfX3MsIG1lbW9yeV9vcmRlciBfX2YpIG5vZXhjZXB0CisgICAgICB7CisJX19nbGli Y3h4X2Fzc2VydChfX2lzX3ZhbGlkX2NtcGV4Y2hfZmFpbHVyZV9vcmRlcihfX2YpKTsKKworI2lm IF9faGFzX2J1aWx0aW4oX19idWlsdGluX2NsZWFyX3BhZGRpbmcpCisJaWYgX0dMSUJDWFgxNF9D T05TVEVYUFIgKF9fYXRvbWljX2ltcGw6Ol9fbWF5YmVfaGFzX3BhZGRpbmc8X1RwPigpKQorCSAg eworCSAgICBhbGlnbmFzKF9UcCkgdW5zaWduZWQgY2hhciBfX2J1ZltzaXplb2YoX1RwKV07CisJ ICAgIF9fYnVpbHRpbl9tZW1jcHkoX19idWYsIHN0ZDo6X19hZGRyZXNzb2YoX19lKSwgc2l6ZW9m KF9UcCkpOworCSAgICBhdXRvKiBfX2V4cCA9IF9fYXRvbWljX2ltcGw6Ol9fY2xlYXJfcGFkZGlu ZygqcmVpbnRlcnByZXRfY2FzdDxfVHAqPihfX2J1ZikpOworCSAgICBhdXRvKiBfX2RlcyA9IF9f YXRvbWljX2ltcGw6Ol9fY2xlYXJfcGFkZGluZyhfX2kpOworCSAgICBpZiAoX19hdG9taWNfY29t cGFyZV9leGNoYW5nZShzdGQ6Ol9fYWRkcmVzc29mKF9fdmFsKSwgX19leHAsIF9fZGVzLCBfX3dl YWssCisJCQkJCSAgaW50KF9fcyksIGludChfX2YpKSkKKwkgICAgICByZXR1cm4gdHJ1ZTsKKwkg ICAgX19idWlsdGluX21lbWNweShzdGQ6OmFkZHJlc3NvZihfX2UpLCBfX2V4cCwgc2l6ZW9mKF9U cCkpOworCSAgICByZXR1cm4gZmFsc2U7CisJICB9CisJZWxzZQorI2VuZGlmCisJcmV0dXJuIF9f YXRvbWljX2NvbXBhcmVfZXhjaGFuZ2Uoc3RkOjpfX2FkZHJlc3NvZihfX3ZhbCksCisJCQkJCSBz dGQ6Ol9fYWRkcmVzc29mKF9fZSksCisJCQkJCSBzdGQ6Ol9fYWRkcmVzc29mKF9faSksCisJCQkJ CSBfX3dlYWssIGludChfX3MpLCBpbnQoX19mKSk7CisgICAgICB9CisKKyAgICB0ZW1wbGF0ZTx0 eXBlbmFtZSBfVHA+CisgICAgICBfR0xJQkNYWF9BTFdBWVNfSU5MSU5FIGJvb2wKKyAgICAgIF9f Y29tcGFyZV9leGNoYW5nZShfVHAgdm9sYXRpbGUmIF9fdmFsLCBfVHAmIF9fZSwgX1RwJiBfX2ks IGJvb2wgX193ZWFrLAorCQkJIG1lbW9yeV9vcmRlciBfX3MsIG1lbW9yeV9vcmRlciBfX2YpIG5v ZXhjZXB0CisgICAgICB7CisJX19nbGliY3h4X2Fzc2VydChfX2lzX3ZhbGlkX2NtcGV4Y2hfZmFp bHVyZV9vcmRlcihfX2YpKTsKKworI2lmIF9faGFzX2J1aWx0aW4oX19idWlsdGluX2NsZWFyX3Bh ZGRpbmcpCisJaWYgX0dMSUJDWFgxNF9DT05TVEVYUFIgKF9fYXRvbWljX2ltcGw6Ol9fbWF5YmVf aGFzX3BhZGRpbmc8X1RwPigpKQorCSAgeworCSAgICBhbGlnbmFzKF9UcCkgdW5zaWduZWQgY2hh ciBfX2J1ZltzaXplb2YoX1RwKV07CisJICAgIF9fYnVpbHRpbl9tZW1jcHkoX19idWYsIHN0ZDo6 X19hZGRyZXNzb2YoX19lKSwgc2l6ZW9mKF9UcCkpOworCSAgICBhdXRvKiBfX2V4cCA9IF9fYXRv bWljX2ltcGw6Ol9fY2xlYXJfcGFkZGluZygqcmVpbnRlcnByZXRfY2FzdDxfVHAqPihfX2J1Zikp OworCSAgICBhdXRvKiBfX2RlcyA9IF9fYXRvbWljX2ltcGw6Ol9fY2xlYXJfcGFkZGluZyhfX2kp OworCSAgICBpZiAoX19hdG9taWNfY29tcGFyZV9leGNoYW5nZShzdGQ6Ol9fYWRkcmVzc29mKF9f dmFsKSwgX19leHAsIF9fZGVzLCBfX3dlYWssCisJCQkJCSAgaW50KF9fcyksIGludChfX2YpKSkK KwkgICAgICByZXR1cm4gdHJ1ZTsKKwkgICAgX19idWlsdGluX21lbWNweShzdGQ6OmFkZHJlc3Nv ZihfX2UpLCBfX2V4cCwgc2l6ZW9mKF9UcCkpOworCSAgICByZXR1cm4gZmFsc2U7CisJICB9CisJ ZWxzZQorI2VuZGlmCisJcmV0dXJuIF9fYXRvbWljX2NvbXBhcmVfZXhjaGFuZ2Uoc3RkOjpfX2Fk ZHJlc3NvZihfX3ZhbCksCisJCQkJCSBzdGQ6Ol9fYWRkcmVzc29mKF9fZSksCisJCQkJCSBzdGQ6 Ol9fYWRkcmVzc29mKF9faSksCisJCQkJCSBfX3dlYWssIGludChfX3MpLCBpbnQoX19mKSk7Cisg ICAgICB9CisgIH0gLy8gbmFtZXNwYWNlIF9fYXRvbWljX2ltcGwKKwogI2lmIF9fY3BsdXNwbHVz ID4gMjAxNzAzTAogICAvLyBJbXBsZW1lbnRhdGlvbiBkZXRhaWxzIG9mIGF0b21pY19yZWYgYW5k IGF0b21pYzxmbG9hdGluZy1wb2ludD4uCiAgIG5hbWVzcGFjZSBfX2F0b21pY19pbXBsCkBAIC05 NTksNyArMTA0MiwxMyBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfVkVSU0lPTgogICAgIHRl bXBsYXRlPHR5cGVuYW1lIF9UcD4KICAgICAgIF9HTElCQ1hYX0FMV0FZU19JTkxJTkUgdm9pZAog ICAgICAgc3RvcmUoX1RwKiBfX3B0ciwgX1ZhbDxfVHA+IF9fdCwgbWVtb3J5X29yZGVyIF9fbSkg bm9leGNlcHQKLSAgICAgIHsgX19hdG9taWNfc3RvcmUoX19wdHIsIHN0ZDo6X19hZGRyZXNzb2Yo X190KSwgaW50KF9fbSkpOyB9CisgICAgICB7CisjaWYgX19oYXNfYnVpbHRpbihfX2J1aWx0aW5f Y2xlYXJfcGFkZGluZykKKwlpZiBfR0xJQkNYWDE0X0NPTlNURVhQUiAoX19tYXliZV9oYXNfcGFk ZGluZzxfVHA+KCkpCisJICBfX2NsZWFyX3BhZGRpbmcoX190KTsKKyNlbmRpZgorCV9fYXRvbWlj X3N0b3JlKF9fcHRyLCBzdGQ6Ol9fYWRkcmVzc29mKF9fdCksIGludChfX20pKTsKKyAgICAgIH0K IAogICAgIHRlbXBsYXRlPHR5cGVuYW1lIF9UcD4KICAgICAgIF9HTElCQ1hYX0FMV0FZU19JTkxJ TkUgX1ZhbDxfVHA+CkBAIC05NzcsNiArMTA2Niw3IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFD RV9WRVJTSU9OCiAgICAgICB7CiAgICAgICAgIGFsaWduYXMoX1RwKSB1bnNpZ25lZCBjaGFyIF9f YnVmW3NpemVvZihfVHApXTsKIAlhdXRvKiBfX2Rlc3QgPSByZWludGVycHJldF9jYXN0PF9WYWw8 X1RwPio+KF9fYnVmKTsKKwlfX2NsZWFyX3BhZGRpbmcoX19kZXNpcmVkKTsKIAlfX2F0b21pY19l eGNoYW5nZShfX3B0ciwgc3RkOjpfX2FkZHJlc3NvZihfX2Rlc2lyZWQpLCBfX2Rlc3QsIGludChf X20pKTsKIAlyZXR1cm4gKl9fZGVzdDsKICAgICAgIH0KQEAgLTk4NywxMSArMTA3Nyw4IEBAIF9H TElCQ1hYX0JFR0lOX05BTUVTUEFDRV9WRVJTSU9OCiAJCQkgICAgX1ZhbDxfVHA+IF9fZGVzaXJl ZCwgbWVtb3J5X29yZGVyIF9fc3VjY2VzcywKIAkJCSAgICBtZW1vcnlfb3JkZXIgX19mYWlsdXJl KSBub2V4Y2VwdAogICAgICAgewotCV9fZ2xpYmN4eF9hc3NlcnQoX19pc192YWxpZF9jbXBleGNo X2ZhaWx1cmVfb3JkZXIoX19mYWlsdXJlKSk7Ci0KLQlyZXR1cm4gX19hdG9taWNfY29tcGFyZV9l eGNoYW5nZShfX3B0ciwgc3RkOjpfX2FkZHJlc3NvZihfX2V4cGVjdGVkKSwKLQkJCQkJIHN0ZDo6 X19hZGRyZXNzb2YoX19kZXNpcmVkKSwgdHJ1ZSwKLQkJCQkJIGludChfX3N1Y2Nlc3MpLCBpbnQo X19mYWlsdXJlKSk7CisJcmV0dXJuIF9fY29tcGFyZV9leGNoYW5nZSgqX19wdHIsIF9fZXhwZWN0 ZWQsIF9fZGVzaXJlZCwgdHJ1ZSwKKwkJCQkgIF9fc3VjY2VzcywgX19mYWlsdXJlKTsKICAgICAg IH0KIAogICAgIHRlbXBsYXRlPHR5cGVuYW1lIF9UcD4KQEAgLTEwMDAsMTEgKzEwODcsOCBAQCBf R0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfVkVSU0lPTgogCQkJICAgICAgX1ZhbDxfVHA+IF9fZGVz aXJlZCwgbWVtb3J5X29yZGVyIF9fc3VjY2VzcywKIAkJCSAgICAgIG1lbW9yeV9vcmRlciBfX2Zh aWx1cmUpIG5vZXhjZXB0CiAgICAgICB7Ci0JX19nbGliY3h4X2Fzc2VydChfX2lzX3ZhbGlkX2Nt cGV4Y2hfZmFpbHVyZV9vcmRlcihfX2ZhaWx1cmUpKTsKLQotCXJldHVybiBfX2F0b21pY19jb21w YXJlX2V4Y2hhbmdlKF9fcHRyLCBzdGQ6Ol9fYWRkcmVzc29mKF9fZXhwZWN0ZWQpLAotCQkJCQkg c3RkOjpfX2FkZHJlc3NvZihfX2Rlc2lyZWQpLCBmYWxzZSwKLQkJCQkJIGludChfX3N1Y2Nlc3Mp LCBpbnQoX19mYWlsdXJlKSk7CisJcmV0dXJuIF9fY29tcGFyZV9leGNoYW5nZSgqX19wdHIsIF9f ZXhwZWN0ZWQsIF9fZGVzaXJlZCwgZmFsc2UsCisJCQkJICBfX3N1Y2Nlc3MsIF9fZmFpbHVyZSk7 CiAgICAgICB9CiAKICNpZiBfX2NwcF9saWJfYXRvbWljX3dhaXQKQEAgLTEzNzYsNyArMTQ2MCwx MiBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfVkVSU0lPTgogCiAgICAgICBleHBsaWNpdAog ICAgICAgX19hdG9taWNfcmVmKF9UcCYgX190KSA6IF9NX3B0cihzdGQ6Ol9fYWRkcmVzc29mKF9f dCkpCi0gICAgICB7IF9fZ2xpYmN4eF9hc3NlcnQoKCh1aW50cHRyX3QpX01fcHRyICUgcmVxdWly ZWRfYWxpZ25tZW50KSA9PSAwKTsgfQorICAgICAgeworCV9fZ2xpYmN4eF9hc3NlcnQoKCh1aW50 cHRyX3QpX01fcHRyICUgcmVxdWlyZWRfYWxpZ25tZW50KSA9PSAwKTsKKyNpZiBfX2NwbHVzcGx1 cyA+IDIwMTQwMkwgJiYgX19oYXNfYnVpbHRpbihfX2J1aWx0aW5fY2xlYXJfcGFkZGluZykKKwlf X2J1aWx0aW5fY2xlYXJfcGFkZGluZyhfTV9wdHIpOworI2VuZGlmCisgICAgICB9CiAKICAgICAg IF9fYXRvbWljX3JlZihjb25zdCBfX2F0b21pY19yZWYmKSBub2V4Y2VwdCA9IGRlZmF1bHQ7CiAK ZGlmZiAtLWdpdCBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL3N0ZC9hdG9taWMgYi9saWJzdGRjKyst djMvaW5jbHVkZS9zdGQvYXRvbWljCmluZGV4IDRhYzljY2RjMWFiLi45ZmE3Yzk1ZTdlMyAxMDA2 NDQKLS0tIGEvbGlic3RkYysrLXYzL2luY2x1ZGUvc3RkL2F0b21pYworKysgYi9saWJzdGRjKyst djMvaW5jbHVkZS9zdGQvYXRvbWljCkBAIC0yMjgsMTMgKzIyOCwxMiBAQCBfR0xJQkNYWF9CRUdJ Tl9OQU1FU1BBQ0VfVkVSU0lPTgogICAgICAgYXRvbWljJiBvcGVyYXRvcj0oY29uc3QgYXRvbWlj JikgPSBkZWxldGU7CiAgICAgICBhdG9taWMmIG9wZXJhdG9yPShjb25zdCBhdG9taWMmKSB2b2xh dGlsZSA9IGRlbGV0ZTsKIAotI2lmIF9fY3BsdXNwbHVzID4gMjAxNzAzTCAmJiBfX2hhc19idWls dGluKF9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKQogICAgICAgY29uc3RleHByIGF0b21pYyhfVHAg X19pKSBub2V4Y2VwdCA6IF9NX2koX19pKQotICAgICAgeyBfX2J1aWx0aW5fY2xlYXJfcGFkZGlu ZyhzdGQ6Ol9fYWRkcmVzc29mKF9NX2kpKTsgfQotI2Vsc2UKLSAgICAgIGNvbnN0ZXhwciBhdG9t aWMoX1RwIF9faSkgbm9leGNlcHQgOiBfTV9pKF9faSkKLSAgICAgIHsgfQorICAgICAgeworI2lm IF9fY3BsdXNwbHVzID4gMjAxNDAyTCAmJiBfX2hhc19idWlsdGluKF9fYnVpbHRpbl9jbGVhcl9w YWRkaW5nKQorCV9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKHN0ZDo6X19hZGRyZXNzb2YoX01faSkp OwogI2VuZGlmCisgICAgICB9CiAKICAgICAgIG9wZXJhdG9yIF9UcCgpIGNvbnN0IG5vZXhjZXB0 CiAgICAgICB7IHJldHVybiBsb2FkKCk7IH0KQEAgLTI3NCwxOCArMjczLDE0IEBAIF9HTElCQ1hY X0JFR0lOX05BTUVTUEFDRV9WRVJTSU9OCiAgICAgICB2b2lkCiAgICAgICBzdG9yZShfVHAgX19p LCBtZW1vcnlfb3JkZXIgX19tID0gbWVtb3J5X29yZGVyX3NlcV9jc3QpIG5vZXhjZXB0CiAgICAg ICB7Ci0jaWYgX19oYXNfYnVpbHRpbihfX2J1aWx0aW5fY2xlYXJfcGFkZGluZykKLQlfX2J1aWx0 aW5fY2xlYXJfcGFkZGluZyhzdGQ6Ol9fYWRkcmVzc29mKF9faSkpOwotI2VuZGlmCisJX19hdG9t aWNfaW1wbDo6X19jbGVhcl9wYWRkaW5nKF9faSk7CiAJX19hdG9taWNfc3RvcmUoc3RkOjpfX2Fk ZHJlc3NvZihfTV9pKSwgc3RkOjpfX2FkZHJlc3NvZihfX2kpLCBpbnQoX19tKSk7CiAgICAgICB9 CiAKICAgICAgIHZvaWQKICAgICAgIHN0b3JlKF9UcCBfX2ksIG1lbW9yeV9vcmRlciBfX20gPSBt ZW1vcnlfb3JkZXJfc2VxX2NzdCkgdm9sYXRpbGUgbm9leGNlcHQKICAgICAgIHsKLSNpZiBfX2hh c19idWlsdGluKF9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKQotCV9fYnVpbHRpbl9jbGVhcl9wYWRk aW5nKHN0ZDo6X19hZGRyZXNzb2YoX19pKSk7Ci0jZW5kaWYKKwlfX2F0b21pY19pbXBsOjpfX2Ns ZWFyX3BhZGRpbmcoX19pKTsKIAlfX2F0b21pY19zdG9yZShzdGQ6Ol9fYWRkcmVzc29mKF9NX2kp LCBzdGQ6Ol9fYWRkcmVzc29mKF9faSksIGludChfX20pKTsKICAgICAgIH0KIApAQCAtMzEyLDkg KzMwNyw3IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFDRV9WRVJTSU9OCiAgICAgICB7CiAgICAg ICAgIGFsaWduYXMoX1RwKSB1bnNpZ25lZCBjaGFyIF9fYnVmW3NpemVvZihfVHApXTsKIAlfVHAq IF9fcHRyID0gcmVpbnRlcnByZXRfY2FzdDxfVHAqPihfX2J1Zik7Ci0jaWYgX19oYXNfYnVpbHRp bihfX2J1aWx0aW5fY2xlYXJfcGFkZGluZykKLQlfX2J1aWx0aW5fY2xlYXJfcGFkZGluZyhzdGQ6 Ol9fYWRkcmVzc29mKF9faSkpOwotI2VuZGlmCisJX19hdG9taWNfaW1wbDo6X19jbGVhcl9wYWRk aW5nKF9faSk7CiAJX19hdG9taWNfZXhjaGFuZ2Uoc3RkOjpfX2FkZHJlc3NvZihfTV9pKSwgc3Rk OjpfX2FkZHJlc3NvZihfX2kpLAogCQkJICBfX3B0ciwgaW50KF9fbSkpOwogCXJldHVybiAqX19w dHI7CkBAIC0zMjYsOSArMzE5LDcgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX1ZFUlNJT04K ICAgICAgIHsKICAgICAgICAgYWxpZ25hcyhfVHApIHVuc2lnbmVkIGNoYXIgX19idWZbc2l6ZW9m KF9UcCldOwogCV9UcCogX19wdHIgPSByZWludGVycHJldF9jYXN0PF9UcCo+KF9fYnVmKTsKLSNp ZiBfX2hhc19idWlsdGluKF9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKQotCV9fYnVpbHRpbl9jbGVh cl9wYWRkaW5nKHN0ZDo6X19hZGRyZXNzb2YoX19pKSk7Ci0jZW5kaWYKKwlfX2F0b21pY19pbXBs OjpfX2NsZWFyX3BhZGRpbmcoX19pKTsKIAlfX2F0b21pY19leGNoYW5nZShzdGQ6Ol9fYWRkcmVz c29mKF9NX2kpLCBzdGQ6Ol9fYWRkcmVzc29mKF9faSksCiAJCQkgIF9fcHRyLCBpbnQoX19tKSk7 CiAJcmV0dXJuICpfX3B0cjsKQEAgLTMzOCwzMiArMzI5LDE2IEBAIF9HTElCQ1hYX0JFR0lOX05B TUVTUEFDRV9WRVJTSU9OCiAgICAgICBjb21wYXJlX2V4Y2hhbmdlX3dlYWsoX1RwJiBfX2UsIF9U cCBfX2ksIG1lbW9yeV9vcmRlciBfX3MsCiAJCQkgICAgbWVtb3J5X29yZGVyIF9fZikgbm9leGNl cHQKICAgICAgIHsKLQlfX2dsaWJjeHhfYXNzZXJ0KF9faXNfdmFsaWRfY21wZXhjaF9mYWlsdXJl X29yZGVyKF9fZikpOwotCi0jaWYgX19oYXNfYnVpbHRpbihfX2J1aWx0aW5fY2xlYXJfcGFkZGlu ZykKLQlfX2J1aWx0aW5fY2xlYXJfcGFkZGluZyhzdGQ6Ol9fYWRkcmVzc29mKF9fZSkpOwotCV9f YnVpbHRpbl9jbGVhcl9wYWRkaW5nKHN0ZDo6X19hZGRyZXNzb2YoX19pKSk7Ci0jZW5kaWYKLQly ZXR1cm4gX19hdG9taWNfY29tcGFyZV9leGNoYW5nZShzdGQ6Ol9fYWRkcmVzc29mKF9NX2kpLAot CQkJCQkgc3RkOjpfX2FkZHJlc3NvZihfX2UpLAotCQkJCQkgc3RkOjpfX2FkZHJlc3NvZihfX2kp LAotCQkJCQkgdHJ1ZSwgaW50KF9fcyksIGludChfX2YpKTsKKwlyZXR1cm4gX19hdG9taWNfaW1w bDo6X19jb21wYXJlX2V4Y2hhbmdlKF9NX2ksIF9fZSwgX19pLCB0cnVlLAorCSAgICBfX3MsIF9f Zik7CiAgICAgICB9CiAKICAgICAgIGJvb2wKICAgICAgIGNvbXBhcmVfZXhjaGFuZ2Vfd2Vhayhf VHAmIF9fZSwgX1RwIF9faSwgbWVtb3J5X29yZGVyIF9fcywKIAkJCSAgICBtZW1vcnlfb3JkZXIg X19mKSB2b2xhdGlsZSBub2V4Y2VwdAogICAgICAgewotCV9fZ2xpYmN4eF9hc3NlcnQoX19pc192 YWxpZF9jbXBleGNoX2ZhaWx1cmVfb3JkZXIoX19mKSk7Ci0KLSNpZiBfX2hhc19idWlsdGluKF9f YnVpbHRpbl9jbGVhcl9wYWRkaW5nKQotCV9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKHN0ZDo6X19h ZGRyZXNzb2YoX19lKSk7Ci0JX19idWlsdGluX2NsZWFyX3BhZGRpbmcoc3RkOjpfX2FkZHJlc3Nv ZihfX2kpKTsKLSNlbmRpZgotCXJldHVybiBfX2F0b21pY19jb21wYXJlX2V4Y2hhbmdlKHN0ZDo6 X19hZGRyZXNzb2YoX01faSksCi0JCQkJCSBzdGQ6Ol9fYWRkcmVzc29mKF9fZSksCi0JCQkJCSBz dGQ6Ol9fYWRkcmVzc29mKF9faSksCi0JCQkJCSB0cnVlLCBpbnQoX19zKSwgaW50KF9fZikpOwor CXJldHVybiBfX2F0b21pY19pbXBsOjpfX2NvbXBhcmVfZXhjaGFuZ2UoX01faSwgX19lLCBfX2ks IHRydWUsCisJICAgIF9fcywgX19mKTsKICAgICAgIH0KIAogICAgICAgYm9vbApAQCAtMzgyLDMy ICszNTcsMTYgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX1ZFUlNJT04KICAgICAgIGNvbXBh cmVfZXhjaGFuZ2Vfc3Ryb25nKF9UcCYgX19lLCBfVHAgX19pLCBtZW1vcnlfb3JkZXIgX19zLAog CQkJICAgICAgbWVtb3J5X29yZGVyIF9fZikgbm9leGNlcHQKICAgICAgIHsKLQlfX2dsaWJjeHhf YXNzZXJ0KF9faXNfdmFsaWRfY21wZXhjaF9mYWlsdXJlX29yZGVyKF9fZikpOwotCi0jaWYgX19o YXNfYnVpbHRpbihfX2J1aWx0aW5fY2xlYXJfcGFkZGluZykKLQlfX2J1aWx0aW5fY2xlYXJfcGFk ZGluZyhzdGQ6Ol9fYWRkcmVzc29mKF9fZSkpOwotCV9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKHN0 ZDo6X19hZGRyZXNzb2YoX19pKSk7Ci0jZW5kaWYKLQlyZXR1cm4gX19hdG9taWNfY29tcGFyZV9l eGNoYW5nZShzdGQ6Ol9fYWRkcmVzc29mKF9NX2kpLAotCQkJCQkgc3RkOjpfX2FkZHJlc3NvZihf X2UpLAotCQkJCQkgc3RkOjpfX2FkZHJlc3NvZihfX2kpLAotCQkJCQkgZmFsc2UsIGludChfX3Mp LCBpbnQoX19mKSk7CisJcmV0dXJuIF9fYXRvbWljX2ltcGw6Ol9fY29tcGFyZV9leGNoYW5nZShf TV9pLCBfX2UsIF9faSwgZmFsc2UsCisJICAgIF9fcywgX19mKTsKICAgICAgIH0KIAogICAgICAg Ym9vbAogICAgICAgY29tcGFyZV9leGNoYW5nZV9zdHJvbmcoX1RwJiBfX2UsIF9UcCBfX2ksIG1l bW9yeV9vcmRlciBfX3MsCiAJCQkgICAgICBtZW1vcnlfb3JkZXIgX19mKSB2b2xhdGlsZSBub2V4 Y2VwdAogICAgICAgewotCV9fZ2xpYmN4eF9hc3NlcnQoX19pc192YWxpZF9jbXBleGNoX2ZhaWx1 cmVfb3JkZXIoX19mKSk7Ci0KLSNpZiBfX2hhc19idWlsdGluKF9fYnVpbHRpbl9jbGVhcl9wYWRk aW5nKQotCV9fYnVpbHRpbl9jbGVhcl9wYWRkaW5nKHN0ZDo6X19hZGRyZXNzb2YoX19lKSk7Ci0J X19idWlsdGluX2NsZWFyX3BhZGRpbmcoc3RkOjpfX2FkZHJlc3NvZihfX2kpKTsKLSNlbmRpZgot CXJldHVybiBfX2F0b21pY19jb21wYXJlX2V4Y2hhbmdlKHN0ZDo6X19hZGRyZXNzb2YoX01faSks Ci0JCQkJCSBzdGQ6Ol9fYWRkcmVzc29mKF9fZSksCi0JCQkJCSBzdGQ6Ol9fYWRkcmVzc29mKF9f aSksCi0JCQkJCSBmYWxzZSwgaW50KF9fcyksIGludChfX2YpKTsKKwlyZXR1cm4gX19hdG9taWNf aW1wbDo6X19jb21wYXJlX2V4Y2hhbmdlKF9NX2ksIF9fZSwgX19pLCBmYWxzZSwKKwkgICAgX19z LCBfX2YpOwogICAgICAgfQogCiAgICAgICBib29sCmRpZmYgLS1naXQgYS9saWJzdGRjKystdjMv dGVzdHN1aXRlLzI5X2F0b21pY3MvYXRvbWljX3JlZi9jb21wYXJlX2V4Y2hhbmdlX3BhZGRpbmcu Y2MgYi9saWJzdGRjKystdjMvdGVzdHN1aXRlLzI5X2F0b21pY3MvYXRvbWljX3JlZi9jb21wYXJl X2V4Y2hhbmdlX3BhZGRpbmcuY2MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAuLmZmZDg3YmMxNDYxCi0tLSAvZGV2L251bGwKKysrIGIvbGlic3RkYysrLXYzL3Rlc3RzdWl0 ZS8yOV9hdG9taWNzL2F0b21pY19yZWYvY29tcGFyZV9leGNoYW5nZV9wYWRkaW5nLmNjCkBAIC0w LDAgKzEsNDMgQEAKKy8vIHsgZGctb3B0aW9ucyAiLXN0ZD1nbnUrKzJhIiB9CisvLyB7IGRnLWRv IHJ1biB7IHRhcmdldCBjKysyYSB9IH0KKy8vIHsgZGctYWRkLW9wdGlvbnMgbGliYXRvbWljIH0K KworI2luY2x1ZGUgPGF0b21pYz4KKworI2luY2x1ZGUgPHRlc3RzdWl0ZV9ob29rcy5oPgorCitz dHJ1Y3QgUyB7IGNoYXIgYzsgc2hvcnQgczsgfTsKKwordm9pZCBfX2F0dHJpYnV0ZV9fKChub2lu bGluZSxub2lwYSkpCitmaWxsX3N0cnVjdChTJiBzKQoreyBfX2J1aWx0aW5fbWVtc2V0KCZzLCAw eGZmLCBzaXplb2YoUykpOyB9CisKK2Jvb2wKK2NvbXBhcmVfc3RydWN0KGNvbnN0IFMmIGEsIGNv bnN0IFMmIGIpCit7IHJldHVybiBfX2J1aWx0aW5fbWVtY21wKCZhLCAmYiwgc2l6ZW9mKFMpKSA9 PSAwOyB9CisKK2ludAorbWFpbiAoKQoreworICBTIHM7CisgIGZpbGxfc3RydWN0KHMpOworICBz LmMgPSAnYSc7CisgIHMucyA9IDQyOworCisgIFMgc3N7IHMgfTsKKyAgc3RkOjphdG9taWNfcmVm PFM+IGFzeyBzIH07CisgIGF1dG8gdHMgPSBhcy5sb2FkKCk7CisgIFZFUklGWSggIWNvbXBhcmVf c3RydWN0KHNzLCB0cykgKTsgLy8gcGFkZGluZyBjbGVhcmVkIG9uIGNvbnN0cnVjdGlvbgorICBh cy5leGNoYW5nZShzcyk7CisgIGF1dG8gZXMgPSBhcy5sb2FkKCk7CisgIFZFUklGWSggY29tcGFy ZV9zdHJ1Y3QodHMsIGVzKSApOyAvLyBwYWRkaW5nIGNsZWFyZWQgb24gZXhjaGFuZ2UKKworICBT IG47CisgIGZpbGxfc3RydWN0KG4pOworICBuLmMgPSAnYic7CisgIG4ucyA9IDcxOworICAvLyBw YWRkaW5nIGNsZWFyZWQgb24gY29tcGV4Y2hnCisgIFZFUklGWSggYXMuY29tcGFyZV9leGNoYW5n ZV93ZWFrKHMsIG4pICk7CisgIFZFUklGWSggYXMuY29tcGFyZV9leGNoYW5nZV9zdHJvbmcobiwg cykgKTsKKyAgcmV0dXJuIDA7Cit9Ci0tIAoyLjMxLjEKCg== --000000000000df267705cfc42c67--