233949 2021-12-07 13:07:49 -0800 [WTF] RELEASE_ASSERT_WITH_MESSAGE() should always print the message 2022-03-21 06:23:34 -0700 1 1 1 Unclassified WebKit Web Template Framework WebKit Local Build Unspecified Unspecified ASSIGNED InRadar P2 Normal --- 235573 1 aperez aperez aperez benjamin calvaris cdumez cgarcia cmarcelo darin ews-watchlist gustavo keith_miller mark.lam mcatanzaro menard msaboff pnormand saam tzagallo vjaquez webkit-bug-importer ysuzuki oldest_to_newest 1821193 0 aperez 2021-12-07 13:07:49 -0800 While sending a message to journald is all fine and dandy, in this particular case we want to make sure people know why WebKit crashed or didn't work correctly due to a missing GStreamer element. 1821199 1 446228 aperez 2021-12-07 13:12:33 -0800 Created attachment 446228 Patch 1821219 2 446228 mcatanzaro 2021-12-07 14:18:07 -0800 Comment on attachment 446228 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=446228&action=review > Source/WebCore/platform/graphics/gstreamer/GStreamerCommon.cpp:512 > - RELEASE_ASSERT_WITH_MESSAGE(element, "GStreamer element %s not found. Please install it", factoryName); > + if (!element) { > + RELEASE_ASSERT_WITH_MESSAGE(false, "GStreamer element %s (factory %s) not found. Please install it", name, factoryName); > + WTFLogAlways("Required GStreamer element %s (factory %s) not found. Please install it", name, factoryName); > + WTFCrash(); > + } Adrian your new code is unreachable. RELEASE_ASSERT() does not return! 1821590 3 mcatanzaro 2021-12-08 09:19:40 -0800 > RELEASE_ASSERT() does not return! Well... not quite, but it really doesn't return when you pass false to it like you're doing here. :P And this really looks like a workaround for broken RELEASE_ASSERT_WITH_MESSAGE(), right? Does that not currently call WTFLogAlways()? Seems better to fix that instead? 1833645 4 aperez 2022-01-25 03:44:29 -0800 (In reply to Michael Catanzaro from comment #3) > > RELEASE_ASSERT() does not return! > > Well... not quite, but it really doesn't return when you pass false to it > like you're doing here. :P > > And this really looks like a workaround for broken > RELEASE_ASSERT_WITH_MESSAGE(), right? Does that not currently call > WTFLogAlways()? Seems better to fix that instead? Finally got round to check this, here's the relevant bit from wtf/Assertions.h: #if !ASSERT_ENABLED #define RELEASE_ASSERT(assertion, ...) do { \ if (UNLIKELY(!(assertion))) \ CRASH_WITH_INFO(__VA_ARGS__); \ } while (0) #define RELEASE_ASSERT_WITH_MESSAGE(assertion, ...) RELEASE_ASSERT(assertion) /* ... */ #else /* ... */ #endif Then CRASH_WITH_INFO() is only properly defined for Clang/MSVC: #if COMPILER(CLANG) || COMPILER(MSVC) /* ... */ #else // GCC does not allow ##__VA_ARGS__ unless GNU extensions are enabled (--std=gnu++NN instead of // --std=c++NN) and I think we don't want that, so we'll have a fallback path for GCC. Obviously // this will not actually succeed at getting the desired info into registers before crashing, but // it's just a fallback anyway. // // FIXME: When we enable C++20, we should replace ##__VA_ARGS__ with format __VA_OPT__(,) __VA_ARGS__ // so that we can remove this fallback. inline NO_RETURN_DUE_TO_CRASH void CRASH_WITH_INFO(...) { CRASH(); } /* ... */ And finally CRASH() expands to WTFBreakpointTrap(), neither print anything. I'll see if I can come up with a definition for CRASH_WITH_INFO() that would do for GCC. 1833662 5 aperez 2022-01-25 04:24:03 -0800 I'm splitting a patch for the FIXME in bug #235573 1833668 6 aperez 2022-01-25 04:33:32 -0800 (In reply to Adrian Perez from comment #5) > I'm splitting a patch for the FIXME in bug #235573 Do we want to print a more descriptive message for missing GStreamer elements with a call to WTFLogAlways() or shall we only rely on the fix for CRASH_WITH_INFO()? If we think a working CRASH_WITH_INFO() is enough, then we can close this bug. 1836573 7 aperez 2022-02-02 12:04:28 -0800 (In reply to Adrian Perez from comment #6) > (In reply to Adrian Perez from comment #5) > > I'm splitting a patch for the FIXME in bug #235573 > > Do we want to print a more descriptive message for missing GStreamer > elements with a call to WTFLogAlways() or shall we only rely on the > fix for CRASH_WITH_INFO()? > > If we think a working CRASH_WITH_INFO() is enough, then we can close > this bug. The fix from bug #235573 is not enough: messages are being discarded in release builds. In release builds ASSERT_ENABLED==0, which means the following definitions are picked from wtf/Assertions.h:640: #if !ASSERT_ENABLED #define RELEASE_ASSERT(assertion, ...) do { \ if (UNLIKELY(!(assertion))) \ CRASH_WITH_INFO(__VA_ARGS__); \ } while (0) #define RELEASE_ASSERT_WITH_MESSAGE(assertion, ...) RELEASE_ASSERT(assertion) // ... Note how the expansion of RELEASE_ASSERT_WITH_MESSAGE() passes “assertion” down to RELEASE_ASSERT(), but more importantly it does not pass __VA_ARGS__ along. This means that RELEASE_ASSERT() never gets to see the additional macro arguments with the message format string and its parameters 🤦️ I think this should planly be: #define RELEASE_ASSERT_WITH_MESSAGE(...) RELEASE_ASSERT(__VA_ARGS__) I'll try to read on the commit log for Assertions.h to try to understand what's the rationale for the current definitions, but the fact is that we are missing on printing important messages here. 1836583 8 aperez 2022-02-02 12:21:36 -0800 (In reply to Adrian Perez from comment #7) > [...] > > I think this should planly be: > > #define RELEASE_ASSERT_WITH_MESSAGE(...) RELEASE_ASSERT(__VA_ARGS__) > > I'll try to read on the commit log for Assertions.h to try to understand > what's the rationale for the current definitions, but the fact is that we > are missing on printing important messages here. The fact that there is an ASSERT_MSG_DISABLED macro, but that it does NOT participate in the definition of RELEASE_ASSERT_WITH_MESSAGE() nor RELEASE_ASSERT() makes me lean towards thinking that indeed using RELEASE_ASSERT_WITH_MESSAGE() should not be discarding the message... otherwise it should discard it or not depending on ASSERT_MSG_DISABLED, right? 1836586 9 aperez 2022-02-02 12:32:06 -0800 (In reply to Adrian Perez from comment #8) > (In reply to Adrian Perez from comment #7) > > > [...] > > > > I think this should planly be: > > > > #define RELEASE_ASSERT_WITH_MESSAGE(...) RELEASE_ASSERT(__VA_ARGS__) > > > > I'll try to read on the commit log for Assertions.h to try to understand > > what's the rationale for the current definitions, but the fact is that we > > are missing on printing important messages here. > > The fact that there is an ASSERT_MSG_DISABLED macro, but that it does > NOT participate in the definition of RELEASE_ASSERT_WITH_MESSAGE() nor > RELEASE_ASSERT() makes me lean towards thinking that indeed using > RELEASE_ASSERT_WITH_MESSAGE() should not be discarding the message... > otherwise it should discard it or not depending on ASSERT_MSG_DISABLED, > right? Also in bug #204445 a new RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE() macro got added, which DOES forward __VA_ARGS__ down to RELEASE_ASSERT_WITH_MESSAGE(), hinting that the intention is for the messages in such macros to trickle down all the way to where the printing is actually done. Also, when CRASH_WITH_INFO() was introduced in bug #188123 the added RELEASE_ASSERT_NOT_REACHED() macros (both versions) do forward __VA_ARGS__, yet another hint that the extra arguments should trickle down! 1836610 10 aperez 2022-02-02 13:25:40 -0800 (In reply to Adrian Perez from comment #9) > (In reply to Adrian Perez from comment #8) > > (In reply to Adrian Perez from comment #7) > > > > > [...] > > > > > > I think this should planly be: > > > > > > #define RELEASE_ASSERT_WITH_MESSAGE(...) RELEASE_ASSERT(__VA_ARGS__) > > > > > > I'll try to read on the commit log for Assertions.h to try to understand > > > what's the rationale for the current definitions, but the fact is that we > > > are missing on printing important messages here. > > > > The fact that there is an ASSERT_MSG_DISABLED macro, but that it does > > NOT participate in the definition of RELEASE_ASSERT_WITH_MESSAGE() nor > > RELEASE_ASSERT() makes me lean towards thinking that indeed using > > RELEASE_ASSERT_WITH_MESSAGE() should not be discarding the message... > > otherwise it should discard it or not depending on ASSERT_MSG_DISABLED, > > right? > > Also in bug #204445 a new RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE() macro got > added, which DOES forward __VA_ARGS__ down to RELEASE_ASSERT_WITH_MESSAGE(), > hinting that the intention is for the messages in such macros to trickle down > all the way to where the printing is actually done. > > Also, when CRASH_WITH_INFO() was introduced in bug #188123 the added > RELEASE_ASSERT_NOT_REACHED() macros (both versions) do forward __VA_ARGS__, > yet another hint that the extra arguments should trickle down! Got all the way to the end of the repository history: the macro RELEASE_ASSERT_WITH_MESSAGE() was added with bug #107725 (nine years ago!) and it did already skip passing the message down in release builds. There is no rationale I can find about why it's like that, so I am going to send a patch and try to get a couple of people to review it :] 1836675 11 aperez 2022-02-02 15:56:19 -0800 (In reply to Adrian Perez from comment #10) > (In reply to Adrian Perez from comment #9) > > (In reply to Adrian Perez from comment #8) > > > (In reply to Adrian Perez from comment #7) > > > > > > > [...] > > > > > > > > I think this should planly be: > > > > > > > > #define RELEASE_ASSERT_WITH_MESSAGE(...) RELEASE_ASSERT(__VA_ARGS__) > > > > > > > > I'll try to read on the commit log for Assertions.h to try to understand > > > > what's the rationale for the current definitions, but the fact is that we > > > > are missing on printing important messages here. > > > > > > The fact that there is an ASSERT_MSG_DISABLED macro, but that it does > > > NOT participate in the definition of RELEASE_ASSERT_WITH_MESSAGE() nor > > > RELEASE_ASSERT() makes me lean towards thinking that indeed using > > > RELEASE_ASSERT_WITH_MESSAGE() should not be discarding the message... > > > otherwise it should discard it or not depending on ASSERT_MSG_DISABLED, > > > right? > > > > Also in bug #204445 a new RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE() macro got > > added, which DOES forward __VA_ARGS__ down to RELEASE_ASSERT_WITH_MESSAGE(), > > hinting that the intention is for the messages in such macros to trickle down > > all the way to where the printing is actually done. > > > > Also, when CRASH_WITH_INFO() was introduced in bug #188123 the added > > RELEASE_ASSERT_NOT_REACHED() macros (both versions) do forward __VA_ARGS__, > > yet another hint that the extra arguments should trickle down! > > Got all the way to the end of the repository history: the macro > RELEASE_ASSERT_WITH_MESSAGE() was added with bug #107725 (nine years ago!) > and it did already skip passing the message down in release builds. There > is no rationale I can find about why it's like that, so I am going to send > a patch and try to get a couple of people to review it :] Gah, even if we changed RELEASE_ASSERT_WITH_MESSAGE() to pass down the message, it would go to RELEASE_ASSERT(), then CRASH_WITH_INFO(), then WTFCrashWithInfo(), WTFCrashWithInfoImpl() and finally there either a debug interrupt (e.g. int3 on x86_64) or CRASH() — but printing does not ever happen. We still need to insert a call to WTFLogAlways() somewhere. 1836683 12 450711 aperez 2022-02-02 16:10:31 -0800 Created attachment 450711 RFC Patch 1836788 13 aperez 2022-02-03 00:28:57 -0800 (In reply to Adrian Perez from comment #12) > Created attachment 450711 [details] > RFC Patch With this patch a release build will print messages like the following on the standard error stream: % epiphany -p ../Source/WebCore/platform/graphics/gstreamer/GStreamerCommon.cpp:547: GStreamer element appsink not found. Please install it (epiphany:54959): epiphany-WARNING **: 10:21:40.474: Web process crashed % When launched from a desktop environment, the messages will end up in the session log, for example as part of user journal log in a GNOME session: % journalctl --user -b0 --grep=GStreamer feb 03 10:22:51 momiji gnome-shell[55384]: ../Source/WebCore/platform/graphics/gstreamer/GStreamerCommon.cpp:547: GStreamer element appsink not found. Please install it Now, I reckon the proposed patch might be a bit too heavy-handed to address the issue from this bug; so maybe it makes sense to call WTFLogAlways() from inside makeGStreamerElement(), and leave the discussion about changing the definition of RELEASE_ASSERT_WITH_MESSAGE() for a separate bug — at least doing it that way will make it easier to have a relevant message emitted for missing GStreamer elements landed sooner. 1836789 14 aperez 2022-02-03 00:29:07 -0800 (In reply to Adrian Perez from comment #12) > Created attachment 450711 [details] > RFC Patch With this patch a release build will print messages like the following on the standard error stream: % epiphany -p ../Source/WebCore/platform/graphics/gstreamer/GStreamerCommon.cpp:547: GStreamer element appsink not found. Please install it (epiphany:54959): epiphany-WARNING **: 10:21:40.474: Web process crashed % When launched from a desktop environment, the messages will end up in the session log, for example as part of user journal log in a GNOME session: % journalctl --user -b0 --grep=GStreamer feb 03 10:22:51 momiji gnome-shell[55384]: ../Source/WebCore/platform/graphics/gstreamer/GStreamerCommon.cpp:547: GStreamer element appsink not found. Please install it Now, I reckon the proposed patch might be a bit too heavy-handed to address the issue from this bug; so maybe it makes sense to call WTFLogAlways() from inside makeGStreamerElement(), and leave the discussion about changing the definition of RELEASE_ASSERT_WITH_MESSAGE() for a separate bug — at least doing it that way will make it easier to have a relevant message emitted for missing GStreamer elements landed sooner. 1836939 15 450711 mcatanzaro 2022-02-03 07:54:18 -0800 Comment on attachment 450711 RFC Patch View in context: https://bugs.webkit.org/attachment.cgi?id=450711&action=review OK, I like how you fixed RELEASE_ASSERT_WITH_MESSAGE. This is clearly the way to go IMO. The original RELEASE_ASSERT_WITH_MESSAGE() was just broken. But I'm not sure what you're doing with this VERBOSE_RELEASE_ASSERT(). P.S. I removed [WTF] from the title of this bug because I've never seen that tag used before. > Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp:57 > -#undef RELEASE_ASSERT > -#define RELEASE_ASSERT(assertion) do { \ > - if (!(assertion)) { \ > +#define VERBOSE_RELEASE_ASSERT(assertion, ...) do { \ > + if (UNLIKELY(!(assertion))) { \ > WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion); \ > - CRASH(); \ > + CRASH_WITH_INFO(__VA_ARGS__); \ > } \ > -} while (0) > +} while (false) I don't understand: why not get rid of this, and change the callers to use your fixed RELEASE_ASSERT_WITH_MESSAGE()? 1836983 16 450711 darin 2022-02-03 09:42:54 -0800 Comment on attachment 450711 RFC Patch View in context: https://bugs.webkit.org/attachment.cgi?id=450711&action=review >> Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp:57 >> +} while (false) > > I don't understand: why not get rid of this, and change the callers to use your fixed RELEASE_ASSERT_WITH_MESSAGE()? I agree. We don’t want to add even more flavors of assertion, especially not in individual source files. These should be in Assertions.h. And we have too many already. 1837123 17 aperez 2022-02-03 14:50:01 -0800 (In reply to Michael Catanzaro from comment #15) > Comment on attachment 450711 [details] > RFC Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=450711&action=review > > OK, I like how you fixed RELEASE_ASSERT_WITH_MESSAGE. This is clearly the > way to go IMO. The original RELEASE_ASSERT_WITH_MESSAGE() was just broken. Thanks :) > But I'm not sure what you're doing with this VERBOSE_RELEASE_ASSERT(). > > P.S. I removed [WTF] from the title of this bug because I've never seen that > tag used before. > > > Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp:57 > > -#undef RELEASE_ASSERT > > -#define RELEASE_ASSERT(assertion) do { \ > > - if (!(assertion)) { \ > > +#define VERBOSE_RELEASE_ASSERT(assertion, ...) do { \ > > + if (UNLIKELY(!(assertion))) { \ > > WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion); \ > > - CRASH(); \ > > + CRASH_WITH_INFO(__VA_ARGS__); \ > > } \ > > -} while (0) > > +} while (false) > > I don't understand: why not get rid of this, and change the callers to use > your fixed RELEASE_ASSERT_WITH_MESSAGE()? Note how the way I changed RELEASE_ASSERT_WITH_MESSAGE() does not print the condition of the assertion, only the file + line + message; but the local redefinition of the RELEASE_ASSERT() in these files was printing the failed assertion condition, and that seemed quite intentional. But I did not want the local definition to clash with macros from wtf/Assertions.h so I gave it a different name. 1837128 18 mcatanzaro 2022-02-03 14:58:29 -0800 (In reply to Adrian Perez from comment #17) > Note how the way I changed RELEASE_ASSERT_WITH_MESSAGE() does not print the > condition of the assertion, only the file + line + message; but the local > redefinition of the RELEASE_ASSERT() in these files was printing the failed > assertion condition, and that seemed quite intentional. But I did not want > the local definition to clash with macros from wtf/Assertions.h so I gave > it a different name. Ah, that's the difference. I would just pick one behavior or the other for RELEASE_ASSERT_WITH_MESSAGE() and convert everything to use that. No need to have both behaviors. Printing the failing assert seems useful. It's a WebKit bug if it ever prints, after all, so shouldn't matter much either way. 1837132 19 aperez 2022-02-03 15:05:10 -0800 (In reply to Darin Adler from comment #16) > Comment on attachment 450711 [details] > RFC Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=450711&action=review > > >> Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp:57 > >> +} while (false) > > > > I don't understand: why not get rid of this, and change the callers to use your fixed RELEASE_ASSERT_WITH_MESSAGE()? > > I agree. We don’t want to add even more flavors of assertion, especially not > in individual source files. These should be in Assertions.h. And we have too > many already. I very much agree, but wasn't completely sure how to go about these macro definitions local to only some files (see my previous comment on this, too). I'll look into simplifying and removing the local definitions. 1837133 20 aperez 2022-02-03 15:05:40 -0800 (In reply to Michael Catanzaro from comment #18) > (In reply to Adrian Perez from comment #17) > > Note how the way I changed RELEASE_ASSERT_WITH_MESSAGE() does not print the > > condition of the assertion, only the file + line + message; but the local > > redefinition of the RELEASE_ASSERT() in these files was printing the failed > > assertion condition, and that seemed quite intentional. But I did not want > > the local definition to clash with macros from wtf/Assertions.h so I gave > > it a different name. > > Ah, that's the difference. > > I would just pick one behavior or the other for > RELEASE_ASSERT_WITH_MESSAGE() and convert everything to use that. No need to > have both behaviors. Printing the failing assert seems useful. It's a WebKit > bug if it ever prints, after all, so shouldn't matter much either way. Yes, I am going to give it a spin and try that 👍️ 1837441 21 450903 aperez 2022-02-04 08:39:07 -0800 Created attachment 450903 Patch Here goes one more iteration. This makes it possible to use RELEASE_ASSERT_WITH_MESSAGE() without format strings (and in that case it prints only the failed condition of the assertion) and that way it can be used to replace the local redefinitions of RELEASE_ASSERT from the JSC files that had them—where the intention seemed to be that a message of some kind is always desired even in release builds. Let me know what do you think of this approach. If you think we can further simplify, I will be happy to massage the patch a bit more =) 1837449 22 mcatanzaro 2022-02-04 09:00:30 -0800 EWS are sad. 1850885 23 webkit-bug-importer 2022-03-14 08:55:00 -0700 <rdar://problem/90248537> 1853166 24 455237 aperez 2022-03-21 06:01:12 -0700 Created attachment 455237 Patch Slightly different, in an attempt at making EWS builders happy 446228 2021-12-07 13:12:33 -0800 2022-02-02 16:09:53 -0800 Patch bug-233949-20211207231232.patch text/plain 3027 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjg2NjA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODliNmU1ZGYyYWNlMzcy NDEyMzhjODYxNzVlNjg0MjJlYWE2MWVjYy4uOTJlNDRhZDk3ZjNhNDY0NTE1YjMzY2MzMDNjZWFh ODc2ZGE5ZmQyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDIxLTEyLTA3ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dTdHJl YW1lcl0gQmUgbm9pc3kgb24gc3RkZXJyIGFuZCBiYWlsIG91dCBlYXJseSBvbiBtaXNzaW5nIHJl cXVpcmVkIGVsZW1lbnRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMzM5NDkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBVc2UgV1RGTG9nQWx3YXlzKCkgdG8gYWxzbyByZXBvcnQgbWlzc2luZyByZXF1aXJl ZCBHU3RyZWFtZXIgZWxlbWVudHMsIHRvIG1ha2UgaXQKKyAgICAgICAgZWFzaWVyIGZvciBkaXN0 cmlidXRvcnMgdG8gZmluZCBvdXQgdGhlaXIgcGFja2FnaW5nIGlzIG1pc3NpbmcgcnVudGltZSBk ZXBlbmRlbmNpZXMuCisgICAgICAgIFdoaWxlIGF0IGl0LCBiZSBub3Qgb25seSBub2lzaWVyIGJ1 dCBhbHNvIGNhbGwgV1RGQ3Jhc2goKSB0byBhdm9pZCByZXR1cm5pbmcgbnVsbHB0cgorICAgICAg ICBmcm9tIHRoZSB1dGlsaXR5IGZ1bmN0aW9ucyBhbmQgY3Jhc2hpbmcgbGF0ZXIgZG93biB0aGUg bGluZSBpbiBzZWVtaW5nbHkgdW5yZWxhdGVkCisgICAgICAgIHdheXMuCisKKyAgICAgICAgTm8g bmV3IHRlc3RzIG5lZWRlZC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1l ci9HU3RyZWFtZXJDb21tb24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6bWFrZUdTdHJlYW1lckVs ZW1lbnQpOiBCZSBub2lzaWVyIG9uIGZhaWx1cmUsIHJlcG9ydCBib3RoIGZhY3RvcnkgYW5kCisg ICAgICAgIGVsZW1lbnQgbmFtZXMuCisgICAgICAgIChXZWJDb3JlOjptYWtlR1N0cmVhbWVyQmlu KTogQmUgbm9pc2llciBvbiBmYWlsdXJlLgorCiAyMDIxLTEyLTA3ICBLeWxlIFBpZGRpbmd0b24g IDxrcGlkZGluZ3RvbkBhcHBsZS5jb20+CiAgICAgICAgIFJvbGwgQU5HTEUgdG8gaW5jbHVkZSB1 cHN0cmVhbWVkIE1ldGFsIGJhY2tlbmQKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyMDg5NgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL0dTdHJlYW1lckNvbW1vbi5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyQ29tbW9uLmNwcAppbmRleCAw MTYwNWZjOTE0OTdlNDYyYmEwNzczMDQ3OGU4NGE4NTUxZTY3MjNmLi4zMTJkMmQ3NGI2ZmU3MDEy YzJhOGE2YmZmZWIzNTkyNGM5ZDljN2RkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyQ29tbW9uLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvR1N0cmVhbWVyQ29tbW9uLmNwcApA QCAtNTA1LDcgKzUwNSwxMSBAQCBHc3RCdWZmZXIqIGdzdEJ1ZmZlck5ld1dyYXBwZWRGYXN0KHZv aWQqIGRhdGEsIHNpemVfdCBsZW5ndGgpCiBHc3RFbGVtZW50KiBtYWtlR1N0cmVhbWVyRWxlbWVu dChjb25zdCBjaGFyKiBmYWN0b3J5TmFtZSwgY29uc3QgY2hhciogbmFtZSkKIHsKICAgICBhdXRv KiBlbGVtZW50ID0gZ3N0X2VsZW1lbnRfZmFjdG9yeV9tYWtlKGZhY3RvcnlOYW1lLCBuYW1lKTsK LSAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoZWxlbWVudCwgIkdTdHJlYW1lciBlbGVt ZW50ICVzIG5vdCBmb3VuZC4gUGxlYXNlIGluc3RhbGwgaXQiLCBmYWN0b3J5TmFtZSk7CisgICAg aWYgKCFlbGVtZW50KSB7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShmYWxz ZSwgIkdTdHJlYW1lciBlbGVtZW50ICVzIChmYWN0b3J5ICVzKSBub3QgZm91bmQuIFBsZWFzZSBp bnN0YWxsIGl0IiwgbmFtZSwgZmFjdG9yeU5hbWUpOworICAgICAgICBXVEZMb2dBbHdheXMoIlJl cXVpcmVkIEdTdHJlYW1lciBlbGVtZW50ICVzIChmYWN0b3J5ICVzKSBub3QgZm91bmQuIFBsZWFz ZSBpbnN0YWxsIGl0IiwgbmFtZSwgZmFjdG9yeU5hbWUpOworICAgICAgICBXVEZDcmFzaCgpOwor ICAgIH0KICAgICByZXR1cm4gZWxlbWVudDsKIH0KIApAQCAtNTEzLDcgKzUxNywxMSBAQCBHc3RF bGVtZW50KiBtYWtlR1N0cmVhbWVyQmluKGNvbnN0IGNoYXIqIGRlc2NyaXB0aW9uLCBib29sIGdo b3N0VW5saW5rZWRQYWRzKQogewogICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKICAg ICBhdXRvKiBiaW4gPSBnc3RfcGFyc2VfYmluX2Zyb21fZGVzY3JpcHRpb24oZGVzY3JpcHRpb24s IGdob3N0VW5saW5rZWRQYWRzLCAmZXJyb3Iub3V0UHRyKCkpOwotICAgIFJFTEVBU0VfQVNTRVJU X1dJVEhfTUVTU0FHRShiaW4sICJVbmFibGUgdG8gY3JlYXRlIGJpbiBmb3IgZGVzY3JpcHRpb246 IFwiJXNcIi4gRXJyb3I6ICVzIiwgZGVzY3JpcHRpb24sIGVycm9yLT5tZXNzYWdlKTsKKyAgICBp ZiAoIWJpbikgeworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoZmFsc2UsICJV bmFibGUgdG8gY3JlYXRlIGJpbiBmb3IgZGVzY3JpcHRpb246IFwiJXNcIi4gRXJyb3I6ICVzIiwg ZGVzY3JpcHRpb24sIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgV1RGTG9nQWx3YXlzKCJVbmFi bGUgdG8gY3JlYXRlIEdTdHJlYW1lciBiaW4gXCIlc1wiOiAlcyIsIGRlc2NyaXB0aW9uLCBlcnJv ci0+bWVzc2FnZSk7CisgICAgICAgIFdURkNyYXNoKCk7CisgICAgfQogICAgIHJldHVybiBiaW47 CiB9CiAK 450711 2022-02-02 16:10:31 -0800 2022-02-04 08:39:00 -0800 RFC Patch bug-233949-20220203021030.patch text/plain 12471 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjg4OTUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw ZGIzMGQxZWUyZmMyZjZiNjE0YWU5YjU3ZDdmMTk1Nzc5MzM3ZjE0Li4wYmM3MDZjODdmMDU5NDdm MjRmNmU3MjFjNDBlZDhhYWUxZmE2N2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNyBAQAorMjAyMi0wMi0wMiAgQWRyaWFuIFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBp Z2FsaWEuY29tPgorCisgICAgICAgIFtXVEZdIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgp IHNob3VsZCBhbHdheXMgcHJpbnQgdGhlIG1lc3NhZ2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMzk0OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFNvbWUgSlNDIHNvdXJjZXMgaW5jbHVkZWQgcmVkZWZp bml0aW9ucyBvZiBSRUxFQVNFX0FTU0VSVCgpIHRvIG1ha2UgaXQgYWx3YXlzIHByaW50IHRoZSBm YWlsZWQKKyAgICAgICAgYXNzZXJ0aW9uLCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgYXNzZXJ0aW9u cyBhcmUgZW5hYmxlZCBhdCBidWlsZCB0aW1lIG9yIG5vdC4gU2FkbHksIHJlZGVmaW5pbmcKKyAg ICAgICAgdGhlIG1hY3JvIGluIG9uZSBmaWxlIHJlc3VsdHMgaW4gdGhhdCBkZWZpbml0aW9uIGxl YWtpbmcgdG8gb3RoZXIgcGFydHMgb2YgdGhlIHNvdXJjZSB3aGljaCBlbmQKKyAgICAgICAgdXAg c3Rhc2hlZCBpbiB0aGUgc2FtZSB1bmlmaWVkIGJ1aWxkIHRyYW5zbGF0aW9uIHVuaXQuCisKKyAg ICAgICAgQXMgdGhlIGludGVudGlvbiBpcyB0byBoYXZlIGEgUkVMRUFTRV9BU1NFUlQoKSB0aGF0 IGlzIG1vcmUgdmVyYm9zZSwgcmVuYW1lIHRob3NlIGFzCisgICAgICAgIFZFUkJPU0VfUkVMRUFT RV9BU1NFUlQoKSBhbmQgbWFrZSB1c2Ugb2YgdGhlbSBpbiB0aGUgY29ycmVzcG9uZGluZyBzb3Vy Y2UgZmlsZXMuIFdoaWxlIGF0IGl0LAorICAgICAgICBtYWtlIHRoZSBtYWNybyBib2R5IG1vcmUg c2ltaWxhciB0byB0aGUgb3RoZXIgZGVmaW5pdGlvbnMgaW4gd3RmL0Fzc2VydGlvbnMuaAorCisg ICAgICAgICogYjMvYWlyL0FpckFsbG9jYXRlUmVnaXN0ZXJzQW5kU3RhY2tCeUxpbmVhclNjYW4u Y3BwOgorICAgICAgICAqIGRmZy9ERkdTU0FDb252ZXJzaW9uUGhhc2UuY3BwOgorICAgICAgICAo SlNDOjpERkc6OlNTQUNvbnZlcnNpb25QaGFzZTo6cnVuKToKKyAgICAgICAgKiBmdGwvRlRMTG93 ZXJERkdUb0IzLmNwcDoKKyAgICAgICAgKEpTQzo6RlRMOjpERkc6Okxvd2VyREZHVG9CMzo6bG93 ZXIpOgorICAgICAgICAoSlNDOjpGVEw6OkRGRzo6TG93ZXJERkdUb0IzOjp2YWxpZGF0ZUFJU3Rh dGUpOgorICAgICAgICAoSlNDOjpGVEw6OkRGRzo6TG93ZXJERkdUb0IzOjpjb21waWxlQ29tcGFy ZVN0cmljdEVxKToKKwogMjAyMi0wMi0wMiAgWXVzdWtlIFN1enVraSAgPHlzdXp1a2lAYXBwbGUu Y29tPgogCiAgICAgICAgIFtKU0NdIHdhc20gYXRvbWljIG9wY29kZXMgc2hvdWxkIGJlIHJlamVj dGVkIGlmIGFsaWdubWVudCBpcyBub3QgZXF1YWwgdG8gbmF0dXJhbCB3aWR0aApkaWZmIC0tZ2l0 IGEvU291cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCA3NGVh MWViOTU3MDIzOGIzNjVjZDM4MDAwZmRlYzc1ZTFhMTRkYWZjLi41NDkzYWNjNjRkYTlhYTExN2Qz ZmZhNDI1MjBmMjM5NGMyNjFiYTY0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIyLTAyLTAyICBB ZHJpYW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW1dU Rl0gUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCkgc2hvdWxkIGFsd2F5cyBwcmludCB0aGUg bWVzc2FnZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjMzOTQ5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg UmVkZWZpbmUgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCkgdG8gaXNzdWUgYSBXVEZMb2dB bHdheXMoKSBjYWxsIHRvIHByaW50IHRoZSBmb3JtYXR0ZWQgbWVzc2FnZQorICAgICAgICBkZWNv cmF0ZWQgd2l0aCBmaWxlIGFuZCBsaW5lIG51bWJlciBidXQgd2l0aG91dCBhbGwgdGhlIGRldGFp bHMgYWJvdXQgdGhlIGZhaWxlZCBhc3NlcnRpb24gd2hlbgorICAgICAgICBhc3NlcnRpb25zIGFy ZSBkaXNhYmxlZC4KKworICAgICAgICAqIHd0Zi9Bc3NlcnRpb25zLmg6IE1ha2UgUkVMRUFTRV9B U1NFUlRfV0lUSF9NRVNTQUdFKCkgcHJpbnQgdGhlIG1lc3NhZ2UuCisKIDIwMjItMDItMDIgIFlv dWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIENsYXJpZnkgdGhhdCBz b21lIFVVSUQgcm91dGluZXMgYXJlIGRlZGljYXRlZCB0byBVVUlEIHY0CmRpZmYgLS1naXQgYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFsbG9jYXRlUmVnaXN0ZXJzQW5kU3RhY2tC eUxpbmVhclNjYW4uY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0 ZVJlZ2lzdGVyc0FuZFN0YWNrQnlMaW5lYXJTY2FuLmNwcAppbmRleCBmNzk3OWFhZjM0ODkwOWY4 NzVlZTAyM2NmNmIwYTFlNzliNzNlODNiLi5lODBmMzliYmZkNjg3MjcxYTgyMzgxYWY1N2Q3NDE2 YjcyNDBmNzQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFs bG9jYXRlUmVnaXN0ZXJzQW5kU3RhY2tCeUxpbmVhclNjYW4uY3BwCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9iMy9haXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNBbmRTdGFja0J5TGluZWFyU2Nh bi5jcHAKQEAgLTQ5LDEzICs0OSwxMiBAQCBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIEIzIHsg bmFtZXNwYWNlIEFpciB7CiAKIG5hbWVzcGFjZSB7CiAKLSN1bmRlZiBSRUxFQVNFX0FTU0VSVAot I2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pIGRvIHsgXAotICAgIGlmICghKGFzc2Vy dGlvbikpIHsgXAorI2RlZmluZSBWRVJCT1NFX1JFTEVBU0VfQVNTRVJUKGFzc2VydGlvbiwgLi4u KSBkbyB7IFwKKyAgICBpZiAoVU5MSUtFTFkoIShhc3NlcnRpb24pKSkgeyBcCiAgICAgICAgIFdU RlJlcG9ydEFzc2VydGlvbkZhaWx1cmUoX19GSUxFX18sIF9fTElORV9fLCBXVEZfUFJFVFRZX0ZV TkNUSU9OLCAjYXNzZXJ0aW9uKTsgXAotICAgICAgICBDUkFTSCgpOyBcCisgICAgICAgIENSQVNI X1dJVEhfSU5GTyhfX1ZBX0FSR1NfXyk7IFwKICAgICB9IFwKLX0gd2hpbGUgKDApCit9IHdoaWxl IChmYWxzZSkKIAogYm9vbCB2ZXJib3NlKCkgeyByZXR1cm4gT3B0aW9uczo6YWlyTGluZWFyU2Nh blZlcmJvc2UoKTsgfQogCkBAIC03Myw3ICs3Miw3IEBAIHN0cnVjdCBUbXBEYXRhIHsKICAgICAK ICAgICB2b2lkIHZhbGlkYXRlKCkKICAgICB7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKCEoc3Bp bGxlZCAmJiBhc3NpZ25lZCkpOworICAgICAgICBWRVJCT1NFX1JFTEVBU0VfQVNTRVJUKCEoc3Bp bGxlZCAmJiBhc3NpZ25lZCkpOwogICAgIH0KICAgICAKICAgICBJbnRlcnZhbCBpbnRlcnZhbDsK QEAgLTQ5OCw3ICs0OTcsNyBAQCBwcml2YXRlOgogICAgICAgICAgICAgICAgIGNvbnRpbnVlOwog ICAgICAgICAgICAgfQogICAgICAgICAgICAgVG1wRGF0YSYgc3BpbGxFbnRyeSA9IG1fbWFwW3Nw aWxsVG1wXTsKLSAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKHNwaWxsRW50cnkuYXNzaWduZWQp OworICAgICAgICAgICAgVkVSQk9TRV9SRUxFQVNFX0FTU0VSVChzcGlsbEVudHJ5LmFzc2lnbmVk KTsKICAgICAgICAgICAgIGlmIChzcGlsbEVudHJ5LmlzVW5zcGlsbGFibGUgfHwKICAgICAgICAg ICAgICAgICAoIWVudHJ5LmlzVW5zcGlsbGFibGUgJiYgc3BpbGxFbnRyeS5pbnRlcnZhbC5lbmQo KSA8PSBlbnRyeS5pbnRlcnZhbC5lbmQoKSkpIHsKICAgICAgICAgICAgICAgICBzcGlsbCh0bXAp OwpAQCAtNTMxLDcgKzUzMCw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCBhc3NpZ24oVG1wIHRtcCwg UmVnIHJlZykKICAgICB7CiAgICAgICAgIFRtcERhdGEmIGVudHJ5ID0gbV9tYXBbdG1wXTsKLSAg ICAgICAgUkVMRUFTRV9BU1NFUlQoIWVudHJ5LnNwaWxsZWQpOworICAgICAgICBWRVJCT1NFX1JF TEVBU0VfQVNTRVJUKCFlbnRyeS5zcGlsbGVkKTsKICAgICAgICAgZW50cnkuYXNzaWduZWQgPSBy ZWc7CiAgICAgICAgIG1fYWN0aXZlUmVncy5hZGQocmVnKTsKICAgICAgICAgYWRkVG9BY3RpdmUo dG1wKTsKQEAgLTU0MCw3ICs1MzksNyBAQCBwcml2YXRlOgogICAgIHZvaWQgc3BpbGwoVG1wIHRt cCkKICAgICB7CiAgICAgICAgIFRtcERhdGEmIGVudHJ5ID0gbV9tYXBbdG1wXTsKLSAgICAgICAg UkVMRUFTRV9BU1NFUlQoIWVudHJ5LmlzVW5zcGlsbGFibGUpOworICAgICAgICBWRVJCT1NFX1JF TEVBU0VfQVNTRVJUKCFlbnRyeS5pc1Vuc3BpbGxhYmxlKTsKICAgICAgICAgZW50cnkuc3BpbGxl ZCA9IG1fY29kZS5hZGRTdGFja1Nsb3QoOCwgU3RhY2tTbG90S2luZDo6U3BpbGwpOwogICAgICAg ICBlbnRyeS5hc3NpZ25lZCA9IFJlZygpOwogICAgICAgICBtX2RpZFNwaWxsID0gdHJ1ZTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU1NBQ29udmVyc2lvblBoYXNl LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU1NBQ29udmVyc2lvblBoYXNlLmNw cAppbmRleCBhOTNhNmIzZDMzZmJmMjZmYTljZGY1NjkzNGM5Mjg5NTBiMDk5M2RiLi5lOWNmOTUx YWM4NGQ5YjMxMDllOTk5NTQwMjQ0YWIxZmZhYTZlNDkxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvZGZnL0RGR1NTQUNvbnZlcnNpb25QaGFzZS5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL2RmZy9ERkdTU0FDb252ZXJzaW9uUGhhc2UuY3BwCkBAIC0zOCwxMyArMzgs MTIgQEAKICNpbmNsdWRlICJKU0NKU1ZhbHVlSW5saW5lcy5oIgogI2luY2x1ZGUgIk9wZXJhbmRz SW5saW5lcy5oIgogCi0jdW5kZWYgUkVMRUFTRV9BU1NFUlQKLSNkZWZpbmUgUkVMRUFTRV9BU1NF UlQoYXNzZXJ0aW9uKSBkbyB7IFwKLSAgICBpZiAoIShhc3NlcnRpb24pKSB7IFwKKyNkZWZpbmUg VkVSQk9TRV9SRUxFQVNFX0FTU0VSVChhc3NlcnRpb24sIC4uLikgZG8geyBcCisgICAgaWYgKFVO TElLRUxZKCEoYXNzZXJ0aW9uKSkpIHsgXAogICAgICAgICBXVEZSZXBvcnRBc3NlcnRpb25GYWls dXJlKF9fRklMRV9fLCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElPTiwgI2Fzc2VydGlvbik7 IFwKLSAgICAgICAgQ1JBU0goKTsgXAorICAgICAgICBDUkFTSF9XSVRIX0lORk8oX19WQV9BUkdT X18pOyBcCiAgICAgfSBcCi19IHdoaWxlICgwKQorfSB3aGlsZSAoZmFsc2UpCiAKIG5hbWVzcGFj ZSBKU0MgeyBuYW1lc3BhY2UgREZHIHsKIApAQCAtNjAsOCArNTksOCBAQCBwdWJsaWM6CiAgICAg CiAgICAgYm9vbCBydW4oKQogICAgIHsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQobV9ncmFwaC5t X2Zvcm0gPT0gVGhyZWFkZWRDUFMpOwotICAgICAgICBSRUxFQVNFX0FTU0VSVCghbV9ncmFwaC5t X2lzSW5TU0FDb252ZXJzaW9uKTsKKyAgICAgICAgVkVSQk9TRV9SRUxFQVNFX0FTU0VSVChtX2dy YXBoLm1fZm9ybSA9PSBUaHJlYWRlZENQUyk7CisgICAgICAgIFZFUkJPU0VfUkVMRUFTRV9BU1NF UlQoIW1fZ3JhcGgubV9pc0luU1NBQ29udmVyc2lvbik7CiAgICAgICAgIG1fZ3JhcGgubV9pc0lu U1NBQ29udmVyc2lvbiA9IHRydWU7CiAgICAgICAgIAogICAgICAgICBtX2dyYXBoLmNsZWFyUmVw bGFjZW1lbnRzKCk7CkBAIC0xMDIsNyArMTAxLDcgQEAgcHVibGljOgogICAgICAgICAgICAgICAg IH0KICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoZW50cnlTd2l0 Y2hEYXRhLT5jYXNlc1swXSA9PSBtX2dyYXBoLmJsb2NrKDApKTsgLy8gV2Ugc3Ryb25nbHkgYXNz dW1lIHRoZSBub3JtYWwgY2FsbCBlbnRyeXBvaW50IGlzIHRoZSBmaXJzdCBpdGVtIGluIHRoZSBs aXN0LgorICAgICAgICAgICAgVkVSQk9TRV9SRUxFQVNFX0FTU0VSVChlbnRyeVN3aXRjaERhdGEt PmNhc2VzWzBdID09IG1fZ3JhcGguYmxvY2soMCkpOyAvLyBXZSBzdHJvbmdseSBhc3N1bWUgdGhl IG5vcm1hbCBjYWxsIGVudHJ5cG9pbnQgaXMgdGhlIGZpcnN0IGl0ZW0gaW4gdGhlIGxpc3QuCiAK ICAgICAgICAgICAgIGNvbnN0IGJvb2wgZXhpdE9LID0gZmFsc2U7CiAgICAgICAgICAgICBOb2Rl T3JpZ2luIG9yaWdpbiB7IENvZGVPcmlnaW4oQnl0ZWNvZGVJbmRleCgwKSksIENvZGVPcmlnaW4o Qnl0ZWNvZGVJbmRleCgwKSksIGV4aXRPSyB9OwpAQCAtNDYyLDcgKzQ2MSw3IEBAIHB1YmxpYzoK ICAgICAgICAgICAgIGFyZ3VtZW50Rm9ybWF0cy5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGFyZ3Vt ZW50cy5zaXplKCkpOwogICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGFyZ3Vt ZW50cy5zaXplKCk7ICsraSkgewogICAgICAgICAgICAgICAgIE5vZGUqIG5vZGUgPSBtX2FyZ3Vt ZW50TWFwcGluZy5nZXQoYXJndW1lbnRzW2ldKTsKLSAgICAgICAgICAgICAgICBSRUxFQVNFX0FT U0VSVChub2RlKTsKKyAgICAgICAgICAgICAgICBWRVJCT1NFX1JFTEVBU0VfQVNTRVJUKG5vZGUp OwogICAgICAgICAgICAgICAgIGFyZ3VtZW50Rm9ybWF0cy51bmNoZWNrZWRBcHBlbmQobm9kZS0+ c3RhY2tBY2Nlc3NEYXRhKCktPmZvcm1hdCk7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICBt X2dyYXBoLm1fYXJndW1lbnRGb3JtYXRzW2VudHJ5cG9pbnRJbmRleF0gPSBXVEZNb3ZlKGFyZ3Vt ZW50Rm9ybWF0cyk7CkBAIC00NzAsNyArNDY5LDcgQEAgcHVibGljOgogCiAgICAgICAgIG1fZ3Jh cGgubV9yb290VG9Bcmd1bWVudHMuY2xlYXIoKTsKIAotICAgICAgICBSRUxFQVNFX0FTU0VSVCht X2dyYXBoLm1faXNJblNTQUNvbnZlcnNpb24pOworICAgICAgICBWRVJCT1NFX1JFTEVBU0VfQVNT RVJUKG1fZ3JhcGgubV9pc0luU1NBQ29udmVyc2lvbik7CiAgICAgICAgIG1fZ3JhcGgubV9pc0lu U1NBQ29udmVyc2lvbiA9IGZhbHNlOwogCiAgICAgICAgIG1fZ3JhcGgubV9mb3JtID0gU1NBOwpk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExMb3dlckRGR1RvQjMuY3Bw IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExMb3dlckRGR1RvQjMuY3BwCmluZGV4IDdh Y2ZjYmNkYTdiNWQxODIzM2E1NzIwMzk1MzU1OWU1NTYxMzdmZDIuLmI0ODBkNmMwMjBkNTc1MDRj YjFhYmI0NmVlZTFhMmYwOTdmZWYwNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9mdGwvRlRMTG93ZXJERkdUb0IzLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRs L0ZUTExvd2VyREZHVG9CMy5jcHAKQEAgLTEwNCwxMyArMTA0LDEyIEBACiAjaW5jbHVkZSA8d3Rm L0dlbmVyaWNIYXNoS2V5Lmg+CiAjaW5jbHVkZSA8d3RmL1JlY3Vyc2FibGVMYW1iZGEuaD4KIAot I3VuZGVmIFJFTEVBU0VfQVNTRVJUCi0jZGVmaW5lIFJFTEVBU0VfQVNTRVJUKGFzc2VydGlvbikg ZG8geyBcCi0gICAgaWYgKCEoYXNzZXJ0aW9uKSkgeyBcCisjZGVmaW5lIFZFUkJPU0VfUkVMRUFT RV9BU1NFUlQoYXNzZXJ0aW9uLCAuLi4pIGRvIHsgXAorICAgIGlmIChVTkxJS0VMWSghKGFzc2Vy dGlvbikpKSB7IFwKICAgICAgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZShfX0ZJTEVfXywg X19MSU5FX18sIFdURl9QUkVUVFlfRlVOQ1RJT04sICNhc3NlcnRpb24pOyBcCi0gICAgICAgIENS QVNIKCk7IFwKKyAgICAgICAgQ1JBU0hfV0lUSF9JTkZPKF9fVkFfQVJHU19fKTsgXAogICAgIH0g XAotfSB3aGlsZSAoMCkKK30gd2hpbGUgKGZhbHNlKQogCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNw YWNlIEZUTCB7CiAKQEAgLTIxMCw3ICsyMDksNyBAQCBwdWJsaWM6CiAgICAgICAgICAgICAgICAg fSk7CiAKICAgICAgICAgICAgIGZvciAodW5zaWduZWQgY2F0Y2hFbnRyeXBvaW50SW5kZXggOiBt X2dyYXBoLm1fZW50cnlwb2ludEluZGV4VG9DYXRjaEJ5dGVjb2RlSW5kZXgua2V5cygpKSB7Ci0g ICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoY2F0Y2hFbnRyeXBvaW50SW5kZXggIT0gMCk7 CisgICAgICAgICAgICAgICAgVkVSQk9TRV9SRUxFQVNFX0FTU0VSVChjYXRjaEVudHJ5cG9pbnRJ bmRleCk7CiAgICAgICAgICAgICAgICAgbV9wcm9jLmNvZGUoKS5zZXRQcm9sb2d1ZUZvckVudHJ5 cG9pbnQoY2F0Y2hFbnRyeXBvaW50SW5kZXgsIGNhdGNoUHJvbG9ndWVHZW5lcmF0b3IuY29weVJl ZigpKTsKICAgICAgICAgICAgIH0KIApAQCAtNjg1LDcgKzY4NCw3IEBAIHByaXZhdGU6CiAgICAg ICAgICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgICAgICBpbnB1dCA9 IEpTVmFsdWU6OmRlY29kZShjb250ZXh0LmdwcihyZWcpKTsgCiAgICAgICAgICAgICAgICAgICAg ICAgICBpZiAoZmx1c2hGb3JtYXQgPT0gRmx1c2hlZEludDUyKSB7Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoaW5wdXQuaXNBbnlJbnQoKSk7CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgVkVSQk9TRV9SRUxFQVNFX0FTU0VSVChpbnB1dC5pc0FueUludCgp KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnB1dCA9IGpzRG91YmxlTnVtYmVyKGlu cHV0LmFzQW55SW50KCkpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg ICAgICAgICAgICAgaWYgKCF2YWx1ZS52YWxpZGF0ZU9TUkVudHJ5VmFsdWUoaW5wdXQsIGZsdXNo Rm9ybWF0KSkKQEAgLTE2OTE5LDcgKzE2OTE4LDcgQEAgSUdOT1JFX0NMQU5HX1dBUk5JTkdTX0VO RAogICAgICAgICBMVmFsdWUgc2l6ZSwgUmVnaXN0ZXJlZFN0cnVjdHVyZSBzdHJ1Y3R1cmUsIExW YWx1ZSBidXR0ZXJmbHksIExCYXNpY0Jsb2NrIHNsb3dQYXRoKQogICAgIHsKICAgICAgICAgQ29t cGxldGVTdWJzcGFjZSogc3Vic3BhY2UgPSBzdWJzcGFjZUZvckNvbmN1cnJlbnRseTxDbGFzc1R5 cGU+KHZtKCkpOwotICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uoc3Vic3BhY2Us ICJDb21wbGV0ZVN1YnNwYWNlIGlzIGFsd2F5cyBhbGxvY2F0ZWQiKTsKKyAgICAgICAgVkVSQk9T RV9SRUxFQVNFX0FTU0VSVChzdWJzcGFjZSwgIkNvbXBsZXRlU3Vic3BhY2UgaXMgYWx3YXlzIGFs bG9jYXRlZCIpOwogICAgICAgICBMVmFsdWUgYWxsb2NhdG9yID0gYWxsb2NhdG9yRm9yU2l6ZSgq c3Vic3BhY2UsIHNpemUsIHNsb3dQYXRoKTsKICAgICAgICAgcmV0dXJuIGFsbG9jYXRlT2JqZWN0 KGFsbG9jYXRvciwgc3RydWN0dXJlLCBidXR0ZXJmbHksIHNsb3dQYXRoKTsKICAgICB9CkBAIC0x NjkyOSw3ICsxNjkyOCw3IEBAIElHTk9SRV9DTEFOR19XQVJOSU5HU19FTkQKICAgICAgICAgTFZh bHVlIHNpemUsIFN0cnVjdHVyZSogc3RydWN0dXJlLCBMQmFzaWNCbG9jayBzbG93UGF0aCkKICAg ICB7CiAgICAgICAgIENvbXBsZXRlU3Vic3BhY2UqIHN1YnNwYWNlID0gc3Vic3BhY2VGb3JDb25j dXJyZW50bHk8Q2xhc3NUeXBlPih2bSgpKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9N RVNTQUdFKHN1YnNwYWNlLCAiQ29tcGxldGVTdWJzcGFjZSBpcyBhbHdheXMgYWxsb2NhdGVkIik7 CisgICAgICAgIFZFUkJPU0VfUkVMRUFTRV9BU1NFUlQoc3Vic3BhY2UsICJDb21wbGV0ZVN1YnNw YWNlIGlzIGFsd2F5cyBhbGxvY2F0ZWQiKTsKICAgICAgICAgTFZhbHVlIGFsbG9jYXRvciA9IGFs bG9jYXRvckZvclNpemUoKnN1YnNwYWNlLCBzaXplLCBzbG93UGF0aCk7CiAgICAgICAgIHJldHVy biBhbGxvY2F0ZUNlbGwoYWxsb2NhdG9yLCBzdHJ1Y3R1cmUsIHNsb3dQYXRoKTsKICAgICB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25zLmggYi9Tb3VyY2UvV1RGL3d0Zi9B c3NlcnRpb25zLmgKaW5kZXggMGFmZGZlNGQ4ZDZhMjFhYjg1OTM2MzM4NmMxMmJkZDZiMzExYzVh OS4uMDg2MGM2MjE1ZmEwOTI0N2ZmNWNkYTlhMzlhMmY3ZDlmMGJlM2JhNCAxMDA2NDQKLS0tIGEv U291cmNlL1dURi93dGYvQXNzZXJ0aW9ucy5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0Fzc2VydGlv bnMuaApAQCAtNjM3LDEzICs2MzcsMzUgQEAgY29uc3RleHByIGJvb2wgYXNzZXJ0aW9uRmFpbHVy ZUR1ZVRvVW5yZWFjaGFibGVDb2RlID0gZmFsc2U7CiAKIC8qIFJFTEVBU0VfQVNTRVJUICovCiAK Ky8vIEZJWE1FOiBSZS1jaGVjayB3aGV0aGVyIE1TVkMgMjAyMCBzdXBwb3J0cyBfX1ZBX09QVF9f IGFuZCByZW1vdmUgdGhlIHNwZWNpYWwKKy8vICAgICAgICBjYXNpbmcgb25jZSBvbGRlciB2ZXJz aW9ucyBvZiB0aGUgY29tcGlsZXIgYXJlIG5vIGxvbmdlciBzdXBwb3J0ZWQuCisjZGVmaW5lIFBQ X1RISVJEX0FSRyhhLGIsYywuLi4pIGMKKyNkZWZpbmUgVkFfT1BUX1NVUFBPUlRFRF9JKC4uLikg UFBfVEhJUkRfQVJHKF9fVkFfT1BUX18oLCksdHJ1ZSxmYWxzZSwpCisjZGVmaW5lIFZBX09QVF9T VVBQT1JURUQgVkFfT1BUX1NVUFBPUlRFRF9JKD8pCisKICNpZiAhQVNTRVJUX0VOQUJMRUQKIAog I2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24sIC4uLikgZG8geyBcCiAgICAgaWYgKFVO TElLRUxZKCEoYXNzZXJ0aW9uKSkpIFwKICAgICAgICAgQ1JBU0hfV0lUSF9JTkZPKF9fVkFfQVJH U19fKTsgXAogfSB3aGlsZSAoMCkKLSNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdF KGFzc2VydGlvbiwgLi4uKSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pCisKKyNpZiBDT01QSUxF UihNU1ZDKSB8fCAhVkFfT1BUX1NVUFBPUlRFRAorI2RlZmluZSBSRUxFQVNFX0FTU0VSVF9XSVRI X01FU1NBR0UoYXNzZXJ0aW9uLCBmb3JtYXQsIC4uLikgZG8geyBcCisgICAgaWYgKFVOTElLRUxZ KCEoYXNzZXJ0aW9uKSkpIHsgXAorICAgICAgICBXVEZMb2dBbHdheXMoIiVzOiV1OiAiIGZvcm1h dCwgX19GSUxFX18sIF9fTElORV9fLCAjI19fVkFfQVJHU19fKTsgXAorICAgICAgICBDUkFTSF9X SVRIX0lORk8oX19WQV9BUkdTX18pOyBcCisgICAgfSBcCit9IHdoaWxlICgwKQorI2Vsc2UKKyNk ZWZpbmUgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKGFzc2VydGlvbiwgZm9ybWF0LCAuLi4p IGRvIHsgXAorICAgIGlmIChVTkxJS0VMWSghKGFzc2VydGlvbikpKSB7IFwKKyAgICAgICAgV1RG TG9nQWx3YXlzKCIlczoldTogIiBmb3JtYXQsIF9fRklMRV9fLCBfX0xJTkVfXyBfX1ZBX09QVF9f KCwpIF9fVkFfQVJHU19fKTsgXAorICAgICAgICBDUkFTSF9XSVRIX0lORk8oX19WQV9BUkdTX18p OyBcCisgICAgfSBcCit9IHdoaWxlICgwKQorI2VuZGlmCisKICNkZWZpbmUgUkVMRUFTRV9BU1NF UlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihhc3NlcnRpb24pIFJFTEVBU0VfQVNTRVJUKGFz c2VydGlvbikKICNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoLi4uKSBDUkFTSF9X SVRIX0lORk8oX19WQV9BUkdTX18pCiAjZGVmaW5lIFJFTEVBU0VfQVNTRVJUX1VOREVSX0NPTlNU RVhQUl9DT05URVhUKGFzc2VydGlvbikgZG8geyBcCkBAIC03NTksMTUgKzc4MSw5IEBAIGlubGlu ZSB2b2lkIGNvbXBpbGVyRmVuY2VGb3JDcmFzaCgpCiAKICNpZm5kZWYgQ1JBU0hfV0lUSF9JTkZP CiAKLSNkZWZpbmUgUFBfVEhJUkRfQVJHKGEsYixjLC4uLikgYwotI2RlZmluZSBWQV9PUFRfU1VQ UE9SVEVEX0koLi4uKSBQUF9USElSRF9BUkcoX19WQV9PUFRfXygsKSx0cnVlLGZhbHNlLCkKLSNk ZWZpbmUgVkFfT1BUX1NVUFBPUlRFRCBWQV9PUFRfU1VQUE9SVEVEX0koPykKLQogLy8gVGhpcyBp cyB1c2VmdWwgaWYgeW91IGFyZSBnb2luZyB0byBzdHVmZiBkYXRhIGludG8gcmVnaXN0ZXJzIGJl Zm9yZSBjcmFzaGluZywgbGlrZSB0aGUKIC8vIGNyYXNoV2l0aEluZm8gZnVuY3Rpb25zIGJlbG93 LgogI2lmIENPTVBJTEVSKE1TVkMpIHx8ICFWQV9PUFRfU1VQUE9SVEVECi0vLyBGSVhNRTogUmUt Y2hlY2sgd2hldGhlciBNU1ZDIDIwMjAgc3VwcG9ydHMgX19WQV9PUFRfXyBhbmQgcmVtb3ZlIHRo ZSBzcGVjaWFsCi0vLyAgICAgICAgY2FzaW5nIG9uY2Ugb2xkZXIgdmVyc2lvbnMgb2YgdGhlIGNv bXBpbGVyIGFyZSBubyBsb25nZXIgc3VwcG9ydGVkLgogI2RlZmluZSBDUkFTSF9XSVRIX0lORk8o Li4uKSBkbyB7IFwKICAgICAgICAgV1RGOjppc0ludGVncmFsT3JQb2ludGVyVHlwZShfX1ZBX0FS R1NfXyk7IFwKICAgICAgICAgY29tcGlsZXJGZW5jZUZvckNyYXNoKCk7IFwK 450903 2022-02-04 08:39:07 -0800 2022-03-21 06:01:05 -0700 Patch bug-233949-20220204183906.patch text/plain 13278 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjg5MDc4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz YTZlZmJjMjUxZDFiNGNlMmM5MTA1NjU1OWJmMDU3MTFhNDliYTFlLi4zMmUzZDk1MjMwMjE4MzNk OGVhYzZiYmU1ODNhZTRiNzg5YmQ2OTA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNiBAQAorMjAyMi0wMi0wNCAgQWRyaWFuIFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBp Z2FsaWEuY29tPgorCisgICAgICAgIFtXVEZdIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgp IHNob3VsZCBhbHdheXMgcHJpbnQgdGhlIG1lc3NhZ2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMzk0OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlbW92ZSBsb2NhbCBkZWZpbml0aW9ucyBvZiBSRUxF QVNFX0FTU0VSVCgpIGluIHNvbWUgc291cmNlIGZpbGVzLCBhbmQgcmVwbGFjZSB0aGVtIHdpdGgK KyAgICAgICAgdGhlIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIG1hY3JvIGZyb20gV1RG LgorCisgICAgICAgIFNvbWUgSlNDIHNvdXJjZXMgaW5jbHVkZWQgcmVkZWZpbml0aW9ucyBvZiBS RUxFQVNFX0FTU0VSVCgpIHRvIG1ha2UgaXQgYWx3YXlzIHByaW50IHRoZSBmYWlsZWQKKyAgICAg ICAgYXNzZXJ0aW9uLCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgYXNzZXJ0aW9ucyBhcmUgZW5hYmxl ZCBhdCBidWlsZCB0aW1lIG9yIG5vdC4gU2FkbHksIHJlZGVmaW5pbmcKKyAgICAgICAgdGhlIG1h Y3JvIGluIG9uZSBmaWxlIHJlc3VsdHMgaW4gdGhhdCBkZWZpbml0aW9uIGxlYWtpbmcgdG8gb3Ro ZXIgcGFydHMgb2YgdGhlIHNvdXJjZSB3aGljaCBlbmQKKyAgICAgICAgdXAgc3Rhc2hlZCBpbiB0 aGUgc2FtZSB1bmlmaWVkIGJ1aWxkIHRyYW5zbGF0aW9uIHVuaXQuCisKKyAgICAgICAgKiBiMy9h aXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNBbmRTdGFja0J5TGluZWFyU2Nhbi5jcHA6CisgICAgICAg ICogZGZnL0RGR1NTQUNvbnZlcnNpb25QaGFzZS5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6U1NB Q29udmVyc2lvblBoYXNlOjpydW4pOgorICAgICAgICAqIGZ0bC9GVExMb3dlckRGR1RvQjMuY3Bw OgorICAgICAgICAoSlNDOjpGVEw6OkRGRzo6TG93ZXJERkdUb0IzOjpsb3dlcik6CisgICAgICAg IChKU0M6OkZUTDo6REZHOjpMb3dlckRGR1RvQjM6OnZhbGlkYXRlQUlTdGF0ZSk6CisgICAgICAg IChKU0M6OkZUTDo6REZHOjpMb3dlckRGR1RvQjM6OmNvbXBpbGVDb21wYXJlU3RyaWN0RXEpOgor CiAyMDIyLTAyLTAzICBZdXN1a2UgU3V6dWtpICA8eXN1enVraUBhcHBsZS5jb20+CiAKICAgICAg ICAgVW5yZXZpZXdlZCwgcmVtb3ZlIFVubGlua2VkTWV0YWRhdGFUYWJsZTo6b2Zmc2V0SW5NZXRh ZGF0YVRhYmxlIHNpbmNlIGl0IGlzIG5vIGxvbmdlciB1c2VkCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDljMjQxMmNmODI0YjRi NTY1YTVlNWRiYWQxNWFjZDRhY2RkZDA0MzMuLjhkMWMxMDExMDI2YjY1MDIwYTQ5OWZjOWQ3OGYz NzdiZmQ0MWQyYTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMjItMDItMDQgIEFkcmlhbiBQZXJl eiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBbV1RGXSBSRUxFQVNF X0FTU0VSVF9XSVRIX01FU1NBR0UoKSBzaG91bGQgYWx3YXlzIHByaW50IHRoZSBtZXNzYWdlCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzM5NDkKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWRlZmluZSBS RUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoKSB0byBjYWxsIFdURlJlcG9ydEFzc2VydGlvbkZh aWx1cmVXaXRoTWVzc2FnZSgpIGluIHJlbGVhc2UKKyAgICAgICAgYnVpbGRzLCBpbiBvcmRlciB0 byBnZXQgbWVzc2FnZXMgcHJpbnRlZC4gRnVuY3Rpb24gV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVy ZVdpdGhNZXNzYWdlKCkgaXMKKyAgICAgICAgbW9kaWZpZWQgdG8gYWxsb3cgcGFzc2luZyBvbmx5 IGFuIGFzc2VydGlvbiB3aXRob3V0IGEgbWVzc2FnZSBmb3JtYXQgc3RyaW5nLCBhbmQgYW4gb3Zl cmxvYWQKKyAgICAgICAgYWRkZWQgd2hpY2ggbWFrZXMgaXQgcG9zc2libGUgdG8gdXNlIHRoZSBS RUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoKSBtYWNybyB3aXRob3V0IGEgY3VzdG9taXplZAor ICAgICAgICBtZXNzYWdlLCBhbmQgaW4gdGhhdCBjYXNlIHRoZSBmYWlsZWQgYXNzZXJ0aW9uIGNv bmRpdGlvbiB3aWxsIGJlIG9ubHkgbWVzc2FnZS4KKworICAgICAgICAqIHd0Zi9Bc3NlcnRpb25z Lmg6CisgICAgICAgICogd3RmL0Fzc2VydGlvbnMuY3BwOgorICAgICAgICAoV1RGUmVwb3J0QXNz ZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdlKTogQWxsb3cgcGFzc2luZyBhIG51bGwgZm9ybWF0IHN0 cmluZ2FuZCBtb3ZlIHNvbWUgY29kZSBoZXJlCisgICAgICAgIGZyb20gV1RGUmVwb3J0QXNzZXJ0 aW9uRmFpbHVyZSgpLCB3aGljaCByZXN1bHRzIGluIHRoZSBmdW5jdGlvbiBiZWluZyBlcXVpdmFs ZW50IHRvIHRoZSBsYXR0ZXIKKyAgICAgICAgd2hlbiBpbnZva2VkIHdpdGggYSBudWxsIGZvcm1h dCBzdHJpbmcuCisgICAgICAgIChXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlKTogUmVpbXBsZW1l bnQgaW4gdGVybXMgb2YgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdlKCkuCisK IDIwMjItMDItMDMgIFJvYmVydCBKZW5uZXIgIDxKZW5uZXJAYXBwbGUuY29tPgogCiAgICAgICAg IFVucmV2aWV3ZWQsIHJldmVydGluZyByMjg4OTAyLgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lzdGVyc0FuZFN0YWNrQnlMaW5lYXJTY2Fu LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9iMy9haXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNB bmRTdGFja0J5TGluZWFyU2Nhbi5jcHAKaW5kZXggZjc5NzlhYWYzNDg5MDlmODc1ZWUwMjNjZjZi MGExZTc5YjczZTgzYi4uMzJlMDhmMmUyYWM1OTAzYWQ5MTY3ZjI4ZWY2MzNkOGRmYmJkOTNiOSAx MDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lz dGVyc0FuZFN0YWNrQnlMaW5lYXJTY2FuLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv YjMvYWlyL0FpckFsbG9jYXRlUmVnaXN0ZXJzQW5kU3RhY2tCeUxpbmVhclNjYW4uY3BwCkBAIC00 OSwxNCArNDksNiBAQCBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIEIzIHsgbmFtZXNwYWNlIEFp ciB7CiAKIG5hbWVzcGFjZSB7CiAKLSN1bmRlZiBSRUxFQVNFX0FTU0VSVAotI2RlZmluZSBSRUxF QVNFX0FTU0VSVChhc3NlcnRpb24pIGRvIHsgXAotICAgIGlmICghKGFzc2VydGlvbikpIHsgXAot ICAgICAgICBXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlKF9fRklMRV9fLCBfX0xJTkVfXywgV1RG X1BSRVRUWV9GVU5DVElPTiwgI2Fzc2VydGlvbik7IFwKLSAgICAgICAgQ1JBU0goKTsgXAotICAg IH0gXAotfSB3aGlsZSAoMCkKLQogYm9vbCB2ZXJib3NlKCkgeyByZXR1cm4gT3B0aW9uczo6YWly TGluZWFyU2NhblZlcmJvc2UoKTsgfQogCiAvLyBQaGFzZSBjb25zdGFudHMgd2UgdXNlIGZvciB0 aGUgUGhhc2VJbnNlcnRpb25TZXQuCkBAIC03Myw3ICs2NSw3IEBAIHN0cnVjdCBUbXBEYXRhIHsK ICAgICAKICAgICB2b2lkIHZhbGlkYXRlKCkKICAgICB7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJU KCEoc3BpbGxlZCAmJiBhc3NpZ25lZCkpOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01F U1NBR0UoIShzcGlsbGVkICYmIGFzc2lnbmVkKSk7CiAgICAgfQogICAgIAogICAgIEludGVydmFs IGludGVydmFsOwpAQCAtNDk4LDcgKzQ5MCw3IEBAIHByaXZhdGU6CiAgICAgICAgICAgICAgICAg Y29udGludWU7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICBUbXBEYXRhJiBzcGlsbEVudHJ5 ID0gbV9tYXBbc3BpbGxUbXBdOwotICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3BpbGxFbnRy eS5hc3NpZ25lZCk7CisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uoc3Bp bGxFbnRyeS5hc3NpZ25lZCk7CiAgICAgICAgICAgICBpZiAoc3BpbGxFbnRyeS5pc1Vuc3BpbGxh YmxlIHx8CiAgICAgICAgICAgICAgICAgKCFlbnRyeS5pc1Vuc3BpbGxhYmxlICYmIHNwaWxsRW50 cnkuaW50ZXJ2YWwuZW5kKCkgPD0gZW50cnkuaW50ZXJ2YWwuZW5kKCkpKSB7CiAgICAgICAgICAg ICAgICAgc3BpbGwodG1wKTsKQEAgLTUzMSw3ICs1MjMsNyBAQCBwcml2YXRlOgogICAgIHZvaWQg YXNzaWduKFRtcCB0bXAsIFJlZyByZWcpCiAgICAgewogICAgICAgICBUbXBEYXRhJiBlbnRyeSA9 IG1fbWFwW3RtcF07Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKCFlbnRyeS5zcGlsbGVkKTsKKyAg ICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCFlbnRyeS5zcGlsbGVkKTsKICAgICAg ICAgZW50cnkuYXNzaWduZWQgPSByZWc7CiAgICAgICAgIG1fYWN0aXZlUmVncy5hZGQocmVnKTsK ICAgICAgICAgYWRkVG9BY3RpdmUodG1wKTsKQEAgLTU0MCw3ICs1MzIsNyBAQCBwcml2YXRlOgog ICAgIHZvaWQgc3BpbGwoVG1wIHRtcCkKICAgICB7CiAgICAgICAgIFRtcERhdGEmIGVudHJ5ID0g bV9tYXBbdG1wXTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoIWVudHJ5LmlzVW5zcGlsbGFibGUp OworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoIWVudHJ5LmlzVW5zcGlsbGFi bGUpOwogICAgICAgICBlbnRyeS5zcGlsbGVkID0gbV9jb2RlLmFkZFN0YWNrU2xvdCg4LCBTdGFj a1Nsb3RLaW5kOjpTcGlsbCk7CiAgICAgICAgIGVudHJ5LmFzc2lnbmVkID0gUmVnKCk7CiAgICAg ICAgIG1fZGlkU3BpbGwgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L2RmZy9ERkdTU0FDb252ZXJzaW9uUGhhc2UuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2Rm Zy9ERkdTU0FDb252ZXJzaW9uUGhhc2UuY3BwCmluZGV4IGE5M2E2YjNkMzNmYmYyNmZhOWNkZjU2 OTM0YzkyODk1MGIwOTkzZGIuLjBkOTUwYjgzOThlNWFlZjZmNjY0OTgwY2UwNWFkMzhmM2RlN2Rl ZmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU1NBQ29udmVyc2lv blBoYXNlLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1NTQUNvbnZlcnNp b25QaGFzZS5jcHAKQEAgLTM4LDE0ICszOCw2IEBACiAjaW5jbHVkZSAiSlNDSlNWYWx1ZUlubGlu ZXMuaCIKICNpbmNsdWRlICJPcGVyYW5kc0lubGluZXMuaCIKIAotI3VuZGVmIFJFTEVBU0VfQVNT RVJUCi0jZGVmaW5lIFJFTEVBU0VfQVNTRVJUKGFzc2VydGlvbikgZG8geyBcCi0gICAgaWYgKCEo YXNzZXJ0aW9uKSkgeyBcCi0gICAgICAgIFdURlJlcG9ydEFzc2VydGlvbkZhaWx1cmUoX19GSUxF X18sIF9fTElORV9fLCBXVEZfUFJFVFRZX0ZVTkNUSU9OLCAjYXNzZXJ0aW9uKTsgXAotICAgICAg ICBDUkFTSCgpOyBcCi0gICAgfSBcCi19IHdoaWxlICgwKQotCiBuYW1lc3BhY2UgSlNDIHsgbmFt ZXNwYWNlIERGRyB7CiAKIGNsYXNzIFNTQUNvbnZlcnNpb25QaGFzZSA6IHB1YmxpYyBQaGFzZSB7 CkBAIC02MCw4ICs1Miw4IEBAIHB1YmxpYzoKICAgICAKICAgICBib29sIHJ1bigpCiAgICAgewot ICAgICAgICBSRUxFQVNFX0FTU0VSVChtX2dyYXBoLm1fZm9ybSA9PSBUaHJlYWRlZENQUyk7Ci0g ICAgICAgIFJFTEVBU0VfQVNTRVJUKCFtX2dyYXBoLm1faXNJblNTQUNvbnZlcnNpb24pOworICAg ICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UobV9ncmFwaC5tX2Zvcm0gPT0gVGhyZWFk ZWRDUFMpOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoIW1fZ3JhcGgubV9p c0luU1NBQ29udmVyc2lvbik7CiAgICAgICAgIG1fZ3JhcGgubV9pc0luU1NBQ29udmVyc2lvbiA9 IHRydWU7CiAgICAgICAgIAogICAgICAgICBtX2dyYXBoLmNsZWFyUmVwbGFjZW1lbnRzKCk7CkBA IC0xMDIsNyArOTQsNyBAQCBwdWJsaWM6CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg fQogCi0gICAgICAgICAgICBSRUxFQVNFX0FTU0VSVChlbnRyeVN3aXRjaERhdGEtPmNhc2VzWzBd ID09IG1fZ3JhcGguYmxvY2soMCkpOyAvLyBXZSBzdHJvbmdseSBhc3N1bWUgdGhlIG5vcm1hbCBj YWxsIGVudHJ5cG9pbnQgaXMgdGhlIGZpcnN0IGl0ZW0gaW4gdGhlIGxpc3QuCisgICAgICAgICAg ICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoZW50cnlTd2l0Y2hEYXRhLT5jYXNlc1swXSA9 PSBtX2dyYXBoLmJsb2NrKDApKTsgLy8gV2Ugc3Ryb25nbHkgYXNzdW1lIHRoZSBub3JtYWwgY2Fs bCBlbnRyeXBvaW50IGlzIHRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0LgogCiAgICAgICAgICAg ICBjb25zdCBib29sIGV4aXRPSyA9IGZhbHNlOwogICAgICAgICAgICAgTm9kZU9yaWdpbiBvcmln aW4geyBDb2RlT3JpZ2luKEJ5dGVjb2RlSW5kZXgoMCkpLCBDb2RlT3JpZ2luKEJ5dGVjb2RlSW5k ZXgoMCkpLCBleGl0T0sgfTsKQEAgLTQ2Miw3ICs0NTQsNyBAQCBwdWJsaWM6CiAgICAgICAgICAg ICBhcmd1bWVudEZvcm1hdHMucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShhcmd1bWVudHMuc2l6ZSgp KTsKICAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBhcmd1bWVudHMuc2l6ZSgp OyArK2kpIHsKICAgICAgICAgICAgICAgICBOb2RlKiBub2RlID0gbV9hcmd1bWVudE1hcHBpbmcu Z2V0KGFyZ3VtZW50c1tpXSk7Ci0gICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQobm9kZSk7 CisgICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKG5vZGUpOwogICAg ICAgICAgICAgICAgIGFyZ3VtZW50Rm9ybWF0cy51bmNoZWNrZWRBcHBlbmQobm9kZS0+c3RhY2tB Y2Nlc3NEYXRhKCktPmZvcm1hdCk7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICBtX2dyYXBo Lm1fYXJndW1lbnRGb3JtYXRzW2VudHJ5cG9pbnRJbmRleF0gPSBXVEZNb3ZlKGFyZ3VtZW50Rm9y bWF0cyk7CkBAIC00NzAsNyArNDYyLDcgQEAgcHVibGljOgogCiAgICAgICAgIG1fZ3JhcGgubV9y b290VG9Bcmd1bWVudHMuY2xlYXIoKTsKIAotICAgICAgICBSRUxFQVNFX0FTU0VSVChtX2dyYXBo Lm1faXNJblNTQUNvbnZlcnNpb24pOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NB R0UobV9ncmFwaC5tX2lzSW5TU0FDb252ZXJzaW9uKTsKICAgICAgICAgbV9ncmFwaC5tX2lzSW5T U0FDb252ZXJzaW9uID0gZmFsc2U7CiAKICAgICAgICAgbV9ncmFwaC5tX2Zvcm0gPSBTU0E7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAKaW5kZXggN2Fj ZmNiY2RhN2I1ZDE4MjMzYTU3MjAzOTUzNTU5ZTU1NjEzN2ZkMi4uNjY5MTdjZTgwOWZjMjlhZTlh MjZlYWM3NDJkZjMyYjViODgwNTk0YyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L2Z0bC9GVExMb3dlckRGR1RvQjMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9mdGwv RlRMTG93ZXJERkdUb0IzLmNwcApAQCAtMTA0LDE0ICsxMDQsNiBAQAogI2luY2x1ZGUgPHd0Zi9H ZW5lcmljSGFzaEtleS5oPgogI2luY2x1ZGUgPHd0Zi9SZWN1cnNhYmxlTGFtYmRhLmg+CiAKLSN1 bmRlZiBSRUxFQVNFX0FTU0VSVAotI2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pIGRv IHsgXAotICAgIGlmICghKGFzc2VydGlvbikpIHsgXAotICAgICAgICBXVEZSZXBvcnRBc3NlcnRp b25GYWlsdXJlKF9fRklMRV9fLCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElPTiwgI2Fzc2Vy dGlvbik7IFwKLSAgICAgICAgQ1JBU0goKTsgXAotICAgIH0gXAotfSB3aGlsZSAoMCkKLQogbmFt ZXNwYWNlIEpTQyB7IG5hbWVzcGFjZSBGVEwgewogCiB1c2luZyBuYW1lc3BhY2UgQjM7CkBAIC0y MTAsNyArMjAyLDcgQEAgcHVibGljOgogICAgICAgICAgICAgICAgIH0pOwogCiAgICAgICAgICAg ICBmb3IgKHVuc2lnbmVkIGNhdGNoRW50cnlwb2ludEluZGV4IDogbV9ncmFwaC5tX2VudHJ5cG9p bnRJbmRleFRvQ2F0Y2hCeXRlY29kZUluZGV4LmtleXMoKSkgewotICAgICAgICAgICAgICAgIFJF TEVBU0VfQVNTRVJUKGNhdGNoRW50cnlwb2ludEluZGV4ICE9IDApOworICAgICAgICAgICAgICAg IFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShjYXRjaEVudHJ5cG9pbnRJbmRleCk7CiAgICAg ICAgICAgICAgICAgbV9wcm9jLmNvZGUoKS5zZXRQcm9sb2d1ZUZvckVudHJ5cG9pbnQoY2F0Y2hF bnRyeXBvaW50SW5kZXgsIGNhdGNoUHJvbG9ndWVHZW5lcmF0b3IuY29weVJlZigpKTsKICAgICAg ICAgICAgIH0KIApAQCAtNjg1LDcgKzY3Nyw3IEBAIHByaXZhdGU6CiAgICAgICAgICAgICAgICAg ICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgICAgICBpbnB1dCA9IEpTVmFsdWU6OmRl Y29kZShjb250ZXh0LmdwcihyZWcpKTsgCiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoZmx1 c2hGb3JtYXQgPT0gRmx1c2hlZEludDUyKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg UkVMRUFTRV9BU1NFUlQoaW5wdXQuaXNBbnlJbnQoKSk7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKGlucHV0LmlzQW55SW50KCkpOwogICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGlucHV0ID0ganNEb3VibGVOdW1iZXIoaW5wdXQuYXNB bnlJbnQoKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAg ICAgICBpZiAoIXZhbHVlLnZhbGlkYXRlT1NSRW50cnlWYWx1ZShpbnB1dCwgZmx1c2hGb3JtYXQp KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvQXNzZXJ0aW9ucy5jcHAgYi9Tb3VyY2UvV1RG L3d0Zi9Bc3NlcnRpb25zLmNwcAppbmRleCA5ZjNmYmE0YzQxMDA3M2VhM2UxYzNmZTY3MzI3MTBm ZWQ3MDlhYjZlLi40OTg4MDY3NjIwZmM2OTk0MzU0MTZlMTUzNzVmZDMyNzBmMzRhOGY3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25zLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9Bc3NlcnRpb25zLmNwcApAQCAtMjQ2LDIwICsyNDYsMjEgQEAgdm9pZCBXVEZSZXBvcnROb3RJ bXBsZW1lbnRlZFlldChjb25zdCBjaGFyKiBmaWxlLCBpbnQgbGluZSwgY29uc3QgY2hhciogZnVu Y3Rpb24KIAogdm9pZCBXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlKGNvbnN0IGNoYXIqIGZpbGUs IGludCBsaW5lLCBjb25zdCBjaGFyKiBmdW5jdGlvbiwgY29uc3QgY2hhciogYXNzZXJ0aW9uKQog ewotICAgIGlmIChhc3NlcnRpb24pCi0gICAgICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJBU1NF UlRJT04gRkFJTEVEOiAlc1xuIiwgYXNzZXJ0aW9uKTsKLSAgICBlbHNlCi0gICAgICAgIHByaW50 Zl9zdGRlcnJfY29tbW9uKCJTSE9VTEQgTkVWRVIgQkUgUkVBQ0hFRFxuIik7Ci0gICAgcHJpbnRD YWxsU2l0ZShmaWxlLCBsaW5lLCBmdW5jdGlvbik7CisgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFp bHVyZVdpdGhNZXNzYWdlKGZpbGUsIGxpbmUsIGZ1bmN0aW9uLCBhc3NlcnRpb24sIG51bGxwdHIp OwogfQogCiB2b2lkIFdURlJlcG9ydEFzc2VydGlvbkZhaWx1cmVXaXRoTWVzc2FnZShjb25zdCBj aGFyKiBmaWxlLCBpbnQgbGluZSwgY29uc3QgY2hhciogZnVuY3Rpb24sIGNvbnN0IGNoYXIqIGFz c2VydGlvbiwgY29uc3QgY2hhciogZm9ybWF0LCAuLi4pCiB7CiAgICAgdmFfbGlzdCBhcmdzOwog ICAgIHZhX3N0YXJ0KGFyZ3MsIGZvcm1hdCk7Ci0gICAgdnByaW50Zl9zdGRlcnJfd2l0aF9wcmVm aXgoIkFTU0VSVElPTiBGQUlMRUQ6ICIsIGZvcm1hdCwgYXJncyk7CisgICAgaWYgKGZvcm1hdCkg eworICAgICAgICB2cHJpbnRmX3N0ZGVycl93aXRoX3ByZWZpeCgiQVNTRVJUSU9OIEZBSUxFRDog IiwgZm9ybWF0LCBhcmdzKTsKKyAgICAgICAgcHJpbnRmX3N0ZGVycl9jb21tb24oIlxuJXNcbiIs IGFzc2VydGlvbik7CisgICAgfSBlbHNlIGlmIChhc3NlcnRpb24pCisgICAgICAgIHByaW50Zl9z dGRlcnJfY29tbW9uKCJBU1NFUlRJT04gRkFJTEVEOiAlc1xuIiwgYXNzZXJ0aW9uKTsKKyAgICBl bHNlCisgICAgICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJTSE9VTEQgTkVWRVIgQkUgUkVBQ0hF RFxuIik7CiAgICAgdmFfZW5kKGFyZ3MpOwotICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJcbiVz XG4iLCBhc3NlcnRpb24pOwogICAgIHByaW50Q2FsbFNpdGUoZmlsZSwgbGluZSwgZnVuY3Rpb24p OwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25zLmggYi9Tb3VyY2Uv V1RGL3d0Zi9Bc3NlcnRpb25zLmgKaW5kZXggMGFmZGZlNGQ4ZDZhMjFhYjg1OTM2MzM4NmMxMmJk ZDZiMzExYzVhOS4uNDhiNDAwZDVmZjZhNzQxZWFlZjdkMWY5ZmM3MDM2Y2I1ZTE2ODIwYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvQXNzZXJ0aW9ucy5oCisrKyBiL1NvdXJjZS9XVEYvd3Rm L0Fzc2VydGlvbnMuaApAQCAtNjM3LDEzICs2MzcsNDAgQEAgY29uc3RleHByIGJvb2wgYXNzZXJ0 aW9uRmFpbHVyZUR1ZVRvVW5yZWFjaGFibGVDb2RlID0gZmFsc2U7CiAKIC8qIFJFTEVBU0VfQVNT RVJUICovCiAKKy8vIEZJWE1FOiBSZS1jaGVjayB3aGV0aGVyIE1TVkMgMjAyMCBzdXBwb3J0cyBf X1ZBX09QVF9fIGFuZCByZW1vdmUgdGhlIHNwZWNpYWwKKy8vICAgICAgICBjYXNpbmcgb25jZSBv bGRlciB2ZXJzaW9ucyBvZiB0aGUgY29tcGlsZXIgYXJlIG5vIGxvbmdlciBzdXBwb3J0ZWQuCisj ZGVmaW5lIFBQX1RISVJEX0FSRyhhLGIsYywuLi4pIGMKKyNkZWZpbmUgVkFfT1BUX1NVUFBPUlRF RF9JKC4uLikgUFBfVEhJUkRfQVJHKF9fVkFfT1BUX18oLCksdHJ1ZSxmYWxzZSwpCisjZGVmaW5l IFZBX09QVF9TVVBQT1JURUQgVkFfT1BUX1NVUFBPUlRFRF9JKD8pCisKICNpZiAhQVNTRVJUX0VO QUJMRUQKIAogI2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24sIC4uLikgZG8geyBcCiAg ICAgaWYgKFVOTElLRUxZKCEoYXNzZXJ0aW9uKSkpIFwKICAgICAgICAgQ1JBU0hfV0lUSF9JTkZP KF9fVkFfQVJHU19fKTsgXAogfSB3aGlsZSAoMCkKLSNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfV0lU SF9NRVNTQUdFKGFzc2VydGlvbiwgLi4uKSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pCisKK3N0 YXRpYyBpbmxpbmUgdm9pZCBXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlV2l0aE1lc3NhZ2UoY29u c3QgY2hhciogZmlsZSwgaW50IGxpbmUsIGNvbnN0IGNoYXIqIGZ1bmN0aW9uLCBjb25zdCBjaGFy KiBhc3NlcnRpb24pCit7CisgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdl KGZpbGUsIGxpbmUsIGZ1bmN0aW9uLCBhc3NlcnRpb24sIG51bGxwdHIpOworfQorCisjaWYgQ09N UElMRVIoTVNWQykgfHwgIVZBX09QVF9TVVBQT1JURUQKKyNkZWZpbmUgUkVMRUFTRV9BU1NFUlRf V0lUSF9NRVNTQUdFKGFzc2VydGlvbiwgLi4uKSBkbyB7IFwKKyAgICBpZiAoVU5MSUtFTFkoIShh c3NlcnRpb24pKSkgeyBcCisgICAgICAgIFdURlJlcG9ydEFzc2VydGlvbkZhaWx1cmVXaXRoTWVz c2FnZShfX0ZJTEVfXywgX19MSU5FX18sIFdURl9QUkVUVFlfRlVOQ1RJT04sICNhc3NlcnRpb24s ICMjX19WQV9BUkdTX18pOyBcCisgICAgICAgIENSQVNIX1dJVEhfSU5GTyhfX1ZBX0FSR1NfXyk7 IFwKKyAgICB9IFwKK30gd2hpbGUgKDApCisjZWxzZQorI2RlZmluZSBSRUxFQVNFX0FTU0VSVF9X SVRIX01FU1NBR0UoYXNzZXJ0aW9uLCAuLi4pIGRvIHsgXAorICAgIGlmIChVTkxJS0VMWSghKGFz c2VydGlvbikpKSB7IFwKKyAgICAgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNz YWdlKF9fRklMRV9fLCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElPTiwgI2Fzc2VydGlvbiBf X1ZBX09QVF9fKCwpIF9fVkFfQVJHU19fKTsgXAorICAgICAgICBDUkFTSF9XSVRIX0lORk8oX19W QV9BUkdTX18pOyBcCisgICAgfSBcCit9IHdoaWxlICgwKQorI2VuZGlmCisKICNkZWZpbmUgUkVM RUFTRV9BU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTihhc3NlcnRpb24pIFJFTEVBU0Vf QVNTRVJUKGFzc2VydGlvbikKICNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoLi4u KSBDUkFTSF9XSVRIX0lORk8oX19WQV9BUkdTX18pCiAjZGVmaW5lIFJFTEVBU0VfQVNTRVJUX1VO REVSX0NPTlNURVhQUl9DT05URVhUKGFzc2VydGlvbikgZG8geyBcCkBAIC03NTksMTUgKzc4Niw5 IEBAIGlubGluZSB2b2lkIGNvbXBpbGVyRmVuY2VGb3JDcmFzaCgpCiAKICNpZm5kZWYgQ1JBU0hf V0lUSF9JTkZPCiAKLSNkZWZpbmUgUFBfVEhJUkRfQVJHKGEsYixjLC4uLikgYwotI2RlZmluZSBW QV9PUFRfU1VQUE9SVEVEX0koLi4uKSBQUF9USElSRF9BUkcoX19WQV9PUFRfXygsKSx0cnVlLGZh bHNlLCkKLSNkZWZpbmUgVkFfT1BUX1NVUFBPUlRFRCBWQV9PUFRfU1VQUE9SVEVEX0koPykKLQog Ly8gVGhpcyBpcyB1c2VmdWwgaWYgeW91IGFyZSBnb2luZyB0byBzdHVmZiBkYXRhIGludG8gcmVn aXN0ZXJzIGJlZm9yZSBjcmFzaGluZywgbGlrZSB0aGUKIC8vIGNyYXNoV2l0aEluZm8gZnVuY3Rp b25zIGJlbG93LgogI2lmIENPTVBJTEVSKE1TVkMpIHx8ICFWQV9PUFRfU1VQUE9SVEVECi0vLyBG SVhNRTogUmUtY2hlY2sgd2hldGhlciBNU1ZDIDIwMjAgc3VwcG9ydHMgX19WQV9PUFRfXyBhbmQg cmVtb3ZlIHRoZSBzcGVjaWFsCi0vLyAgICAgICAgY2FzaW5nIG9uY2Ugb2xkZXIgdmVyc2lvbnMg b2YgdGhlIGNvbXBpbGVyIGFyZSBubyBsb25nZXIgc3VwcG9ydGVkLgogI2RlZmluZSBDUkFTSF9X SVRIX0lORk8oLi4uKSBkbyB7IFwKICAgICAgICAgV1RGOjppc0ludGVncmFsT3JQb2ludGVyVHlw ZShfX1ZBX0FSR1NfXyk7IFwKICAgICAgICAgY29tcGlsZXJGZW5jZUZvckNyYXNoKCk7IFwK 455237 2022-03-21 06:01:12 -0700 2022-03-21 06:23:34 -0700 Patch bug-233949-20220321150111.patch text/plain 13408 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMjkxNTUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 ZWFkNTY5YTZiZDY2NDQ2ZmY5MTAwMmM1MWQyMjg0ODhiM2Q1YWRlLi5iNmY0NmFlZmFmZjQzMmJi NGM4ZjI1NzkyODM0ZDkwODIwODlhOWRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNiBAQAorMjAyMi0wMy0yMSAgQWRyaWFuIFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBp Z2FsaWEuY29tPgorCisgICAgICAgIFtXVEZdIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgp IHNob3VsZCBhbHdheXMgcHJpbnQgdGhlIG1lc3NhZ2UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzMzk0OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFJlbW92ZSBsb2NhbCBkZWZpbml0aW9ucyBvZiBSRUxF QVNFX0FTU0VSVCgpIGluIHNvbWUgc291cmNlIGZpbGVzLCBhbmQgcmVwbGFjZSB0aGVtIHdpdGgK KyAgICAgICAgdGhlIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIG1hY3JvIGZyb20gV1RG LgorCisgICAgICAgIFNvbWUgSlNDIHNvdXJjZXMgaW5jbHVkZWQgcmVkZWZpbml0aW9ucyBvZiBS RUxFQVNFX0FTU0VSVCgpIHRvIG1ha2UgaXQgYWx3YXlzIHByaW50IHRoZSBmYWlsZWQKKyAgICAg ICAgYXNzZXJ0aW9uLCByZWdhcmRsZXNzIG9mIHdoZXRoZXIgYXNzZXJ0aW9ucyBhcmUgZW5hYmxl ZCBhdCBidWlsZCB0aW1lIG9yIG5vdC4gU2FkbHksIHJlZGVmaW5pbmcKKyAgICAgICAgdGhlIG1h Y3JvIGluIG9uZSBmaWxlIHJlc3VsdHMgaW4gdGhhdCBkZWZpbml0aW9uIGxlYWtpbmcgdG8gb3Ro ZXIgcGFydHMgb2YgdGhlIHNvdXJjZSB3aGljaCBlbmQKKyAgICAgICAgdXAgc3Rhc2hlZCBpbiB0 aGUgc2FtZSB1bmlmaWVkIGJ1aWxkIHRyYW5zbGF0aW9uIHVuaXQuCisKKyAgICAgICAgKiBiMy9h aXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNBbmRTdGFja0J5TGluZWFyU2Nhbi5jcHA6CisgICAgICAg ICogZGZnL0RGR1NTQUNvbnZlcnNpb25QaGFzZS5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6U1NB Q29udmVyc2lvblBoYXNlOjpydW4pOgorICAgICAgICAqIGZ0bC9GVExMb3dlckRGR1RvQjMuY3Bw OgorICAgICAgICAoSlNDOjpGVEw6OkRGRzo6TG93ZXJERkdUb0IzOjpsb3dlcik6CisgICAgICAg IChKU0M6OkZUTDo6REZHOjpMb3dlckRGR1RvQjM6OnZhbGlkYXRlQUlTdGF0ZSk6CisgICAgICAg IChKU0M6OkZUTDo6REZHOjpMb3dlckRGR1RvQjM6OmNvbXBpbGVDb21wYXJlU3RyaWN0RXEpOgor CiAyMDIyLTAzLTE4ICBZdXN1a2UgU3V6dWtpICA8eXN1enVraUBhcHBsZS5jb20+CiAKICAgICAg ICAgW0pTQ10gRnVydGhlciByZWR1Y2UgIyBvZiByZWdpc3RlcnMgdXNlZCBpbiBSZWdFeHBUZXN0 SW5saW5lCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCmluZGV4IDQ0YmJkYjg5MjJhZWIxYjRhZDVmZDMzYTEwYjBkYmFhZDg2NTQwNzQuLmUx MmJmMmQzNjQxYTg5YjAwOWFlOTQyNDQ2MzY0M2Y4MjZhY2IxZGQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMg QEAKKzIwMjItMDMtMjEgIEFkcmlhbiBQZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNv bT4KKworICAgICAgICBbV1RGXSBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoKSBzaG91bGQg YWx3YXlzIHByaW50IHRoZSBtZXNzYWdlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMzM5NDkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBSZWRlZmluZSBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoKSB0 byBjYWxsIFdURlJlcG9ydEFzc2VydGlvbkZhaWx1cmVXaXRoTWVzc2FnZSgpIGluIHJlbGVhc2UK KyAgICAgICAgYnVpbGRzLCBpbiBvcmRlciB0byBnZXQgbWVzc2FnZXMgcHJpbnRlZC4gRnVuY3Rp b24gV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdlKCkgaXMKKyAgICAgICAgbW9k aWZpZWQgdG8gYWxsb3cgcGFzc2luZyBvbmx5IGFuIGFzc2VydGlvbiB3aXRob3V0IGEgbWVzc2Fn ZSBmb3JtYXQgc3RyaW5nLCBhbmQgYW4gb3ZlcmxvYWQKKyAgICAgICAgYWRkZWQgd2hpY2ggbWFr ZXMgaXQgcG9zc2libGUgdG8gdXNlIHRoZSBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoKSBt YWNybyB3aXRob3V0IGEgY3VzdG9taXplZAorICAgICAgICBtZXNzYWdlLCBhbmQgaW4gdGhhdCBj YXNlIHRoZSBmYWlsZWQgYXNzZXJ0aW9uIGNvbmRpdGlvbiB3aWxsIGJlIG9ubHkgbWVzc2FnZS4K KworICAgICAgICAqIHd0Zi9Bc3NlcnRpb25zLmg6CisgICAgICAgICogd3RmL0Fzc2VydGlvbnMu Y3BwOgorICAgICAgICAoV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdlKTogQWxs b3cgcGFzc2luZyBhIG51bGwgZm9ybWF0IHN0cmluZ2FuZCBtb3ZlIHNvbWUgY29kZSBoZXJlCisg ICAgICAgIGZyb20gV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZSgpLCB3aGljaCByZXN1bHRzIGlu IHRoZSBmdW5jdGlvbiBiZWluZyBlcXVpdmFsZW50IHRvIHRoZSBsYXR0ZXIKKyAgICAgICAgd2hl biBpbnZva2VkIHdpdGggYSBudWxsIGZvcm1hdCBzdHJpbmcuCisgICAgICAgIChXVEZSZXBvcnRB c3NlcnRpb25GYWlsdXJlKTogUmVpbXBsZW1lbnQgaW4gdGVybXMgb2YgV1RGUmVwb3J0QXNzZXJ0 aW9uRmFpbHVyZVdpdGhNZXNzYWdlKCkuCisKIDIwMjItMDMtMTkgIENocmlzIER1bWV6ICA8Y2R1 bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBWZWN0b3IgbW92ZSBjb25zdHJ1Y3RvciBhbmQgbW92 ZSBhc3NpZ25tZW50IG9wZXJhdG9yIGFyZSBzdWJvcHRpbWFsIHdoZW4gdGhlIHZlY3RvciBoYXMg YW4gaW5saW5lIGJ1ZmZlcgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fp ci9BaXJBbGxvY2F0ZVJlZ2lzdGVyc0FuZFN0YWNrQnlMaW5lYXJTY2FuLmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9iMy9haXIvQWlyQWxsb2NhdGVSZWdpc3RlcnNBbmRTdGFja0J5TGluZWFy U2Nhbi5jcHAKaW5kZXggMzA0YWRmYzQwNmE0OGEyMGI3MmVhMWUwNGE0M2M2MDAxMzFkOWNlNC4u NTM3NjdlNTljNDZhY2YwODgxZDRmYzc2NmVlN2U1YWY4ODUyOTRhNCAxMDA2NDQKLS0tIGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL2IzL2Fpci9BaXJBbGxvY2F0ZVJlZ2lzdGVyc0FuZFN0YWNrQnlM aW5lYXJTY2FuLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvYjMvYWlyL0FpckFsbG9j YXRlUmVnaXN0ZXJzQW5kU3RhY2tCeUxpbmVhclNjYW4uY3BwCkBAIC00OSwxNCArNDksNiBAQCBu YW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIEIzIHsgbmFtZXNwYWNlIEFpciB7CiAKIG5hbWVzcGFj ZSB7CiAKLSN1bmRlZiBSRUxFQVNFX0FTU0VSVAotI2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3Nl cnRpb24pIGRvIHsgXAotICAgIGlmICghKGFzc2VydGlvbikpIHsgXAotICAgICAgICBXVEZSZXBv cnRBc3NlcnRpb25GYWlsdXJlKF9fRklMRV9fLCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElP TiwgI2Fzc2VydGlvbik7IFwKLSAgICAgICAgQ1JBU0goKTsgXAotICAgIH0gXAotfSB3aGlsZSAo MCkKLQogYm9vbCB2ZXJib3NlKCkgeyByZXR1cm4gT3B0aW9uczo6YWlyTGluZWFyU2NhblZlcmJv c2UoKTsgfQogCiAvLyBQaGFzZSBjb25zdGFudHMgd2UgdXNlIGZvciB0aGUgUGhhc2VJbnNlcnRp b25TZXQuCkBAIC03Myw3ICs2NSw3IEBAIHN0cnVjdCBUbXBEYXRhIHsKICAgICAKICAgICB2b2lk IHZhbGlkYXRlKCkKICAgICB7Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKCEoc3BpbGxlZCAmJiBh c3NpZ25lZCkpOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoIShzcGlsbGVk ICYmIGFzc2lnbmVkKSk7CiAgICAgfQogICAgIAogICAgIEludGVydmFsIGludGVydmFsOwpAQCAt NDk4LDcgKzQ5MCw3IEBAIHByaXZhdGU6CiAgICAgICAgICAgICAgICAgY29udGludWU7CiAgICAg ICAgICAgICB9CiAgICAgICAgICAgICBUbXBEYXRhJiBzcGlsbEVudHJ5ID0gbV9tYXBbc3BpbGxU bXBdOwotICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3BpbGxFbnRyeS5hc3NpZ25lZCk7Cisg ICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uoc3BpbGxFbnRyeS5hc3NpZ25l ZCk7CiAgICAgICAgICAgICBpZiAoc3BpbGxFbnRyeS5pc1Vuc3BpbGxhYmxlIHx8CiAgICAgICAg ICAgICAgICAgKCFlbnRyeS5pc1Vuc3BpbGxhYmxlICYmIHNwaWxsRW50cnkuaW50ZXJ2YWwuZW5k KCkgPD0gZW50cnkuaW50ZXJ2YWwuZW5kKCkpKSB7CiAgICAgICAgICAgICAgICAgc3BpbGwodG1w KTsKQEAgLTUzMSw3ICs1MjMsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgYXNzaWduKFRtcCB0bXAs IFJlZyByZWcpCiAgICAgewogICAgICAgICBUbXBEYXRhJiBlbnRyeSA9IG1fbWFwW3RtcF07Ci0g ICAgICAgIFJFTEVBU0VfQVNTRVJUKCFlbnRyeS5zcGlsbGVkKTsKKyAgICAgICAgUkVMRUFTRV9B U1NFUlRfV0lUSF9NRVNTQUdFKCFlbnRyeS5zcGlsbGVkKTsKICAgICAgICAgZW50cnkuYXNzaWdu ZWQgPSByZWc7CiAgICAgICAgIG1fYWN0aXZlUmVncy5hZGQocmVnKTsKICAgICAgICAgYWRkVG9B Y3RpdmUodG1wKTsKQEAgLTU0MCw3ICs1MzIsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgc3BpbGwo VG1wIHRtcCkKICAgICB7CiAgICAgICAgIFRtcERhdGEmIGVudHJ5ID0gbV9tYXBbdG1wXTsKLSAg ICAgICAgUkVMRUFTRV9BU1NFUlQoIWVudHJ5LmlzVW5zcGlsbGFibGUpOworICAgICAgICBSRUxF QVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoIWVudHJ5LmlzVW5zcGlsbGFibGUpOwogICAgICAgICBl bnRyeS5zcGlsbGVkID0gbV9jb2RlLmFkZFN0YWNrU2xvdCg4LCBTdGFja1Nsb3RLaW5kOjpTcGls bCk7CiAgICAgICAgIGVudHJ5LmFzc2lnbmVkID0gUmVnKCk7CiAgICAgICAgIG1fZGlkU3BpbGwg PSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdTU0FDb252 ZXJzaW9uUGhhc2UuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdTU0FDb252ZXJz aW9uUGhhc2UuY3BwCmluZGV4IGE5M2E2YjNkMzNmYmYyNmZhOWNkZjU2OTM0YzkyODk1MGIwOTkz ZGIuLjBkOTUwYjgzOThlNWFlZjZmNjY0OTgwY2UwNWFkMzhmM2RlN2RlZmIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU1NBQ29udmVyc2lvblBoYXNlLmNwcAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1NTQUNvbnZlcnNpb25QaGFzZS5jcHAKQEAg LTM4LDE0ICszOCw2IEBACiAjaW5jbHVkZSAiSlNDSlNWYWx1ZUlubGluZXMuaCIKICNpbmNsdWRl ICJPcGVyYW5kc0lubGluZXMuaCIKIAotI3VuZGVmIFJFTEVBU0VfQVNTRVJUCi0jZGVmaW5lIFJF TEVBU0VfQVNTRVJUKGFzc2VydGlvbikgZG8geyBcCi0gICAgaWYgKCEoYXNzZXJ0aW9uKSkgeyBc Ci0gICAgICAgIFdURlJlcG9ydEFzc2VydGlvbkZhaWx1cmUoX19GSUxFX18sIF9fTElORV9fLCBX VEZfUFJFVFRZX0ZVTkNUSU9OLCAjYXNzZXJ0aW9uKTsgXAotICAgICAgICBDUkFTSCgpOyBcCi0g ICAgfSBcCi19IHdoaWxlICgwKQotCiBuYW1lc3BhY2UgSlNDIHsgbmFtZXNwYWNlIERGRyB7CiAK IGNsYXNzIFNTQUNvbnZlcnNpb25QaGFzZSA6IHB1YmxpYyBQaGFzZSB7CkBAIC02MCw4ICs1Miw4 IEBAIHB1YmxpYzoKICAgICAKICAgICBib29sIHJ1bigpCiAgICAgewotICAgICAgICBSRUxFQVNF X0FTU0VSVChtX2dyYXBoLm1fZm9ybSA9PSBUaHJlYWRlZENQUyk7Ci0gICAgICAgIFJFTEVBU0Vf QVNTRVJUKCFtX2dyYXBoLm1faXNJblNTQUNvbnZlcnNpb24pOworICAgICAgICBSRUxFQVNFX0FT U0VSVF9XSVRIX01FU1NBR0UobV9ncmFwaC5tX2Zvcm0gPT0gVGhyZWFkZWRDUFMpOworICAgICAg ICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UoIW1fZ3JhcGgubV9pc0luU1NBQ29udmVyc2lv bik7CiAgICAgICAgIG1fZ3JhcGgubV9pc0luU1NBQ29udmVyc2lvbiA9IHRydWU7CiAgICAgICAg IAogICAgICAgICBtX2dyYXBoLmNsZWFyUmVwbGFjZW1lbnRzKCk7CkBAIC0xMDIsNyArOTQsNyBA QCBwdWJsaWM6CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogCi0gICAgICAgICAg ICBSRUxFQVNFX0FTU0VSVChlbnRyeVN3aXRjaERhdGEtPmNhc2VzWzBdID09IG1fZ3JhcGguYmxv Y2soMCkpOyAvLyBXZSBzdHJvbmdseSBhc3N1bWUgdGhlIG5vcm1hbCBjYWxsIGVudHJ5cG9pbnQg aXMgdGhlIGZpcnN0IGl0ZW0gaW4gdGhlIGxpc3QuCisgICAgICAgICAgICBSRUxFQVNFX0FTU0VS VF9XSVRIX01FU1NBR0UoZW50cnlTd2l0Y2hEYXRhLT5jYXNlc1swXSA9PSBtX2dyYXBoLmJsb2Nr KDApKTsgLy8gV2Ugc3Ryb25nbHkgYXNzdW1lIHRoZSBub3JtYWwgY2FsbCBlbnRyeXBvaW50IGlz IHRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0LgogCiAgICAgICAgICAgICBjb25zdCBib29sIGV4 aXRPSyA9IGZhbHNlOwogICAgICAgICAgICAgTm9kZU9yaWdpbiBvcmlnaW4geyBDb2RlT3JpZ2lu KEJ5dGVjb2RlSW5kZXgoMCkpLCBDb2RlT3JpZ2luKEJ5dGVjb2RlSW5kZXgoMCkpLCBleGl0T0sg fTsKQEAgLTQ2Miw3ICs0NTQsNyBAQCBwdWJsaWM6CiAgICAgICAgICAgICBhcmd1bWVudEZvcm1h dHMucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eShhcmd1bWVudHMuc2l6ZSgpKTsKICAgICAgICAgICAg IGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBhcmd1bWVudHMuc2l6ZSgpOyArK2kpIHsKICAgICAg ICAgICAgICAgICBOb2RlKiBub2RlID0gbV9hcmd1bWVudE1hcHBpbmcuZ2V0KGFyZ3VtZW50c1tp XSk7Ci0gICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQobm9kZSk7CisgICAgICAgICAgICAg ICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKG5vZGUpOwogICAgICAgICAgICAgICAgIGFy Z3VtZW50Rm9ybWF0cy51bmNoZWNrZWRBcHBlbmQobm9kZS0+c3RhY2tBY2Nlc3NEYXRhKCktPmZv cm1hdCk7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICBtX2dyYXBoLm1fYXJndW1lbnRGb3Jt YXRzW2VudHJ5cG9pbnRJbmRleF0gPSBXVEZNb3ZlKGFyZ3VtZW50Rm9ybWF0cyk7CkBAIC00NzAs NyArNDYyLDcgQEAgcHVibGljOgogCiAgICAgICAgIG1fZ3JhcGgubV9yb290VG9Bcmd1bWVudHMu Y2xlYXIoKTsKIAotICAgICAgICBSRUxFQVNFX0FTU0VSVChtX2dyYXBoLm1faXNJblNTQUNvbnZl cnNpb24pOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UobV9ncmFwaC5tX2lz SW5TU0FDb252ZXJzaW9uKTsKICAgICAgICAgbV9ncmFwaC5tX2lzSW5TU0FDb252ZXJzaW9uID0g ZmFsc2U7CiAKICAgICAgICAgbV9ncmFwaC5tX2Zvcm0gPSBTU0E7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvZnRsL0ZUTExvd2VyREZHVG9CMy5jcHAKaW5kZXggYzQwN2IwMGM0ZGFiN2Q2NzZh MDVmOWUzZDUwZGRkMWE3MjEwMDJhYi4uODlmMWRhMTI5NWMzODUxOTA3MDQ4MWYyNTRkNmU5MTJj MjAyZmM0YSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2Z0bC9GVExMb3dlckRG R1RvQjMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9mdGwvRlRMTG93ZXJERkdUb0Iz LmNwcApAQCAtMTA0LDE0ICsxMDQsNiBAQAogI2luY2x1ZGUgPHd0Zi9HZW5lcmljSGFzaEtleS5o PgogI2luY2x1ZGUgPHd0Zi9SZWN1cnNhYmxlTGFtYmRhLmg+CiAKLSN1bmRlZiBSRUxFQVNFX0FT U0VSVAotI2RlZmluZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pIGRvIHsgXAotICAgIGlmICgh KGFzc2VydGlvbikpIHsgXAotICAgICAgICBXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlKF9fRklM RV9fLCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElPTiwgI2Fzc2VydGlvbik7IFwKLSAgICAg ICAgQ1JBU0goKTsgXAotICAgIH0gXAotfSB3aGlsZSAoMCkKLQogbmFtZXNwYWNlIEpTQyB7IG5h bWVzcGFjZSBGVEwgewogCiB1c2luZyBuYW1lc3BhY2UgQjM7CkBAIC0yMTAsNyArMjAyLDcgQEAg cHVibGljOgogICAgICAgICAgICAgICAgIH0pOwogCiAgICAgICAgICAgICBmb3IgKHVuc2lnbmVk IGNhdGNoRW50cnlwb2ludEluZGV4IDogbV9ncmFwaC5tX2VudHJ5cG9pbnRJbmRleFRvQ2F0Y2hC eXRlY29kZUluZGV4LmtleXMoKSkgewotICAgICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUKGNh dGNoRW50cnlwb2ludEluZGV4ICE9IDApOworICAgICAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJU X1dJVEhfTUVTU0FHRShjYXRjaEVudHJ5cG9pbnRJbmRleCk7CiAgICAgICAgICAgICAgICAgbV9w cm9jLmNvZGUoKS5zZXRQcm9sb2d1ZUZvckVudHJ5cG9pbnQoY2F0Y2hFbnRyeXBvaW50SW5kZXgs IGNhdGNoUHJvbG9ndWVHZW5lcmF0b3IuY29weVJlZigpKTsKICAgICAgICAgICAgIH0KIApAQCAt Njg1LDcgKzY3Nyw3IEBAIHByaXZhdGU6CiAgICAgICAgICAgICAgICAgICAgIH0gZWxzZSB7CiAg ICAgICAgICAgICAgICAgICAgICAgICBpbnB1dCA9IEpTVmFsdWU6OmRlY29kZShjb250ZXh0Lmdw cihyZWcpKTsgCiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoZmx1c2hGb3JtYXQgPT0gRmx1 c2hlZEludDUyKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgUkVMRUFTRV9BU1NFUlQo aW5wdXQuaXNBbnlJbnQoKSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgUkVMRUFTRV9B U1NFUlRfV0lUSF9NRVNTQUdFKGlucHV0LmlzQW55SW50KCkpOwogICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGlucHV0ID0ganNEb3VibGVOdW1iZXIoaW5wdXQuYXNBbnlJbnQoKSk7CiAgICAg ICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIXZhbHVl LnZhbGlkYXRlT1NSRW50cnlWYWx1ZShpbnB1dCwgZmx1c2hGb3JtYXQpKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dURi93dGYvQXNzZXJ0aW9ucy5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25z LmNwcAppbmRleCA5ZjNmYmE0YzQxMDA3M2VhM2UxYzNmZTY3MzI3MTBmZWQ3MDlhYjZlLi40OTg4 MDY3NjIwZmM2OTk0MzU0MTZlMTUzNzVmZDMyNzBmMzRhOGY3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V1RGL3d0Zi9Bc3NlcnRpb25zLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25zLmNw cApAQCAtMjQ2LDIwICsyNDYsMjEgQEAgdm9pZCBXVEZSZXBvcnROb3RJbXBsZW1lbnRlZFlldChj b25zdCBjaGFyKiBmaWxlLCBpbnQgbGluZSwgY29uc3QgY2hhciogZnVuY3Rpb24KIAogdm9pZCBX VEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlKGNvbnN0IGNoYXIqIGZpbGUsIGludCBsaW5lLCBjb25z dCBjaGFyKiBmdW5jdGlvbiwgY29uc3QgY2hhciogYXNzZXJ0aW9uKQogewotICAgIGlmIChhc3Nl cnRpb24pCi0gICAgICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJBU1NFUlRJT04gRkFJTEVEOiAl c1xuIiwgYXNzZXJ0aW9uKTsKLSAgICBlbHNlCi0gICAgICAgIHByaW50Zl9zdGRlcnJfY29tbW9u KCJTSE9VTEQgTkVWRVIgQkUgUkVBQ0hFRFxuIik7Ci0gICAgcHJpbnRDYWxsU2l0ZShmaWxlLCBs aW5lLCBmdW5jdGlvbik7CisgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdl KGZpbGUsIGxpbmUsIGZ1bmN0aW9uLCBhc3NlcnRpb24sIG51bGxwdHIpOwogfQogCiB2b2lkIFdU RlJlcG9ydEFzc2VydGlvbkZhaWx1cmVXaXRoTWVzc2FnZShjb25zdCBjaGFyKiBmaWxlLCBpbnQg bGluZSwgY29uc3QgY2hhciogZnVuY3Rpb24sIGNvbnN0IGNoYXIqIGFzc2VydGlvbiwgY29uc3Qg Y2hhciogZm9ybWF0LCAuLi4pCiB7CiAgICAgdmFfbGlzdCBhcmdzOwogICAgIHZhX3N0YXJ0KGFy Z3MsIGZvcm1hdCk7Ci0gICAgdnByaW50Zl9zdGRlcnJfd2l0aF9wcmVmaXgoIkFTU0VSVElPTiBG QUlMRUQ6ICIsIGZvcm1hdCwgYXJncyk7CisgICAgaWYgKGZvcm1hdCkgeworICAgICAgICB2cHJp bnRmX3N0ZGVycl93aXRoX3ByZWZpeCgiQVNTRVJUSU9OIEZBSUxFRDogIiwgZm9ybWF0LCBhcmdz KTsKKyAgICAgICAgcHJpbnRmX3N0ZGVycl9jb21tb24oIlxuJXNcbiIsIGFzc2VydGlvbik7Cisg ICAgfSBlbHNlIGlmIChhc3NlcnRpb24pCisgICAgICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJB U1NFUlRJT04gRkFJTEVEOiAlc1xuIiwgYXNzZXJ0aW9uKTsKKyAgICBlbHNlCisgICAgICAgIHBy aW50Zl9zdGRlcnJfY29tbW9uKCJTSE9VTEQgTkVWRVIgQkUgUkVBQ0hFRFxuIik7CiAgICAgdmFf ZW5kKGFyZ3MpOwotICAgIHByaW50Zl9zdGRlcnJfY29tbW9uKCJcbiVzXG4iLCBhc3NlcnRpb24p OwogICAgIHByaW50Q2FsbFNpdGUoZmlsZSwgbGluZSwgZnVuY3Rpb24pOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRpb25zLmggYi9Tb3VyY2UvV1RGL3d0Zi9Bc3NlcnRp b25zLmgKaW5kZXggOTQ0M2U2NDJhZTNkOTQ4YTUzNzVhMjhiMzZlYzM0MmY1NzI3ZmFiNC4uMTFh YmI5MjJkZGQyZTg5NmZlYjhhN2QxYzhkNmY3ZWM3ODE0ZGY4ZCAxMDA2NDQKLS0tIGEvU291cmNl L1dURi93dGYvQXNzZXJ0aW9ucy5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL0Fzc2VydGlvbnMuaApA QCAtNjUxLDEzICs2NTEsNDEgQEAgY29uc3RleHByIGJvb2wgYXNzZXJ0aW9uRmFpbHVyZUR1ZVRv VW5yZWFjaGFibGVDb2RlID0gZmFsc2U7CiAKIC8qIFJFTEVBU0VfQVNTRVJUICovCiAKKy8vIEZJ WE1FOiBSZS1jaGVjayB3aGV0aGVyIE1TVkMgMjAyMCBzdXBwb3J0cyBfX1ZBX09QVF9fIGFuZCBy ZW1vdmUgdGhlIHNwZWNpYWwKKy8vICAgICAgICBjYXNpbmcgb25jZSBvbGRlciB2ZXJzaW9ucyBv ZiB0aGUgY29tcGlsZXIgYXJlIG5vIGxvbmdlciBzdXBwb3J0ZWQuCisjZGVmaW5lIFBQX1RISVJE X0FSRyhhLGIsYywuLi4pIGMKKyNkZWZpbmUgVkFfT1BUX1NVUFBPUlRFRF9JKC4uLikgUFBfVEhJ UkRfQVJHKF9fVkFfT1BUX18oLCksdHJ1ZSxmYWxzZSwpCisjZGVmaW5lIFZBX09QVF9TVVBQT1JU RUQgVkFfT1BUX1NVUFBPUlRFRF9JKD8pCisKICNpZiAhQVNTRVJUX0VOQUJMRUQKIAogI2RlZmlu ZSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24sIC4uLikgZG8geyBcCiAgICAgaWYgKFVOTElLRUxZ KCEoYXNzZXJ0aW9uKSkpIFwKICAgICAgICAgQ1JBU0hfV0lUSF9JTkZPKF9fVkFfQVJHU19fKTsg XAogfSB3aGlsZSAoMCkKLSNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKGFzc2Vy dGlvbiwgLi4uKSBSRUxFQVNFX0FTU0VSVChhc3NlcnRpb24pCisKK3RlbXBsYXRlIDx0eXBlbmFt ZSBUID0gc3RkOjpudWxscHRyX3Q+CitBTFdBWVNfSU5MSU5FIHZvaWQgV1RGUmVwb3J0QXNzZXJ0 aW9uRmFpbHVyZVdpdGhNZXNzYWdlKGNvbnN0IGNoYXIqIGZpbGUsIGludCBsaW5lLCBjb25zdCBj aGFyKiBmdW5jdGlvbiwgY29uc3QgY2hhciogYXNzZXJ0aW9uLCBUIGV4dHJhID0gbnVsbHB0cikK K3sKKyAgICA6OldURlJlcG9ydEFzc2VydGlvbkZhaWx1cmVXaXRoTWVzc2FnZShmaWxlLCBsaW5l LCBmdW5jdGlvbiwgYXNzZXJ0aW9uLCBleHRyYSk7Cit9CisKKyNpZiBDT01QSUxFUihNU1ZDKSB8 fCAhVkFfT1BUX1NVUFBPUlRFRAorI2RlZmluZSBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uo YXNzZXJ0aW9uLCAuLi4pIGRvIHsgXAorICAgIGlmIChVTkxJS0VMWSghKGFzc2VydGlvbikpKSB7 IFwKKyAgICAgICAgV1RGUmVwb3J0QXNzZXJ0aW9uRmFpbHVyZVdpdGhNZXNzYWdlKF9fRklMRV9f LCBfX0xJTkVfXywgV1RGX1BSRVRUWV9GVU5DVElPTiwgI2Fzc2VydGlvbiwgIyNfX1ZBX0FSR1Nf Xyk7IFwKKyAgICAgICAgQ1JBU0hfV0lUSF9JTkZPKF9fVkFfQVJHU19fKTsgXAorICAgIH0gXAor fSB3aGlsZSAoMCkKKyNlbHNlCisjZGVmaW5lIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShh c3NlcnRpb24sIC4uLikgZG8geyBcCisgICAgaWYgKFVOTElLRUxZKCEoYXNzZXJ0aW9uKSkpIHsg XAorICAgICAgICBXVEZSZXBvcnRBc3NlcnRpb25GYWlsdXJlV2l0aE1lc3NhZ2UoX19GSUxFX18s IF9fTElORV9fLCBXVEZfUFJFVFRZX0ZVTkNUSU9OLCAjYXNzZXJ0aW9uIF9fVkFfT1BUX18oLCkg X19WQV9BUkdTX18pOyBcCisgICAgICAgIENSQVNIX1dJVEhfSU5GTyhfX1ZBX0FSR1NfXyk7IFwK KyAgICB9IFwKK30gd2hpbGUgKDApCisjZW5kaWYKKwogI2RlZmluZSBSRUxFQVNFX0FTU0VSVF9X SVRIX1NFQ1VSSVRZX0lNUExJQ0FUSU9OKGFzc2VydGlvbikgUkVMRUFTRV9BU1NFUlQoYXNzZXJ0 aW9uKQogI2RlZmluZSBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCguLi4pIENSQVNIX1dJVEhf SU5GTyhfX1ZBX0FSR1NfXykKICNkZWZpbmUgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRURfVU5E RVJfQ09OU1RFWFBSX0NPTlRFWFQoKSBDUkFTSF9VTkRFUl9DT05TVEVYUFJfQ09OVEVYVCgpOwpA QCAtNzc1LDE1ICs4MDMsOSBAQCBpbmxpbmUgdm9pZCBjb21waWxlckZlbmNlRm9yQ3Jhc2goKQog CiAjaWZuZGVmIENSQVNIX1dJVEhfSU5GTwogCi0jZGVmaW5lIFBQX1RISVJEX0FSRyhhLGIsYywu Li4pIGMKLSNkZWZpbmUgVkFfT1BUX1NVUFBPUlRFRF9JKC4uLikgUFBfVEhJUkRfQVJHKF9fVkFf T1BUX18oLCksdHJ1ZSxmYWxzZSwpCi0jZGVmaW5lIFZBX09QVF9TVVBQT1JURUQgVkFfT1BUX1NV UFBPUlRFRF9JKD8pCi0KIC8vIFRoaXMgaXMgdXNlZnVsIGlmIHlvdSBhcmUgZ29pbmcgdG8gc3R1 ZmYgZGF0YSBpbnRvIHJlZ2lzdGVycyBiZWZvcmUgY3Jhc2hpbmcsIGxpa2UgdGhlCiAvLyBjcmFz aFdpdGhJbmZvIGZ1bmN0aW9ucyBiZWxvdy4KICNpZiBDT01QSUxFUihNU1ZDKSB8fCAhVkFfT1BU X1NVUFBPUlRFRAotLy8gRklYTUU6IFJlLWNoZWNrIHdoZXRoZXIgTVNWQyAyMDIwIHN1cHBvcnRz IF9fVkFfT1BUX18gYW5kIHJlbW92ZSB0aGUgc3BlY2lhbAotLy8gICAgICAgIGNhc2luZyBvbmNl IG9sZGVyIHZlcnNpb25zIG9mIHRoZSBjb21waWxlciBhcmUgbm8gbG9uZ2VyIHN1cHBvcnRlZC4K ICNkZWZpbmUgQ1JBU0hfV0lUSF9JTkZPKC4uLikgZG8geyBcCiAgICAgICAgIFdURjo6aXNJbnRl Z3JhbE9yUG9pbnRlclR5cGUoX19WQV9BUkdTX18pOyBcCiAgICAgICAgIGNvbXBpbGVyRmVuY2VG b3JDcmFzaCgpOyBcCg==