214756 2020-07-24 12:50:35 -0700 WebKit::setCrashReportApplicationSpecificInformation() should also log to WTFLogAlways() 2020-07-31 11:42:05 -0700 1 1 1 Unclassified WebKit WebKit2 Other Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=214713 https://bugs.webkit.org/show_bug.cgi?id=214954 https://bugs.webkit.org/show_bug.cgi?id=215026 InRadar P2 Normal --- 214906 1 ddkilzer ddkilzer achristensen cdumez darin simon.fraser webkit-bug-importer oldest_to_newest 1674792 0 ddkilzer 2020-07-24 12:50:35 -0700 WebKit::setCrashReportApplicationSpecificInformation() should also log to WTFLogAlways(). We should log to WTFLogAlways() since "Application Specific Information" doesn't always appear. In the long term, we may simply replace WebKit::setCrashReportApplicationSpecificInformation() with WTFLogAlways(). 1674793 1 405168 ddkilzer 2020-07-24 12:51:44 -0700 Created attachment 405168 Patch v1 1674795 2 webkit-bug-importer 2020-07-24 12:53:57 -0700 <rdar://problem/66069227> 1674819 3 405168 ddkilzer 2020-07-24 14:29:33 -0700 Comment on attachment 405168 Patch v1 Adding cq+ because all ports compiled, and this only adds logging when crashing, so it can't affect ios-wk2 layout test results. 1674822 4 ews-feeder 2020-07-24 14:32:03 -0700 Committed r264858: <https://trac.webkit.org/changeset/264858> All reviewed patches have been landed. Closing bug and clearing flags on attachment 405168. 1674913 5 ryanhaddad 2020-07-24 16:43:00 -0700 Reverted r264858 for reason: Caused spurious CRASHING TEST logging during layout test runs Committed r264870: <https://trac.webkit.org/changeset/264870> 1674915 6 ddkilzer 2020-07-24 16:44:21 -0700 Moving to RESOLVED/WONTFIX. I'll change the way we log in the two methods in Source/WebKit that use CRASH_WITH_INFO() instead. 1674958 7 ddkilzer 2020-07-24 19:13:00 -0700 Actually, I will use this to re-land the patch. I'm going to clean up the different code paths that are used to set Application Specific Information, too. 1674959 8 webkit-bug-importer 2020-07-24 19:13:14 -0700 <rdar://problem/66085705> 1674992 9 405222 ddkilzer 2020-07-24 22:20:11 -0700 Created attachment 405222 Patch v2 1674993 10 405223 ddkilzer 2020-07-24 22:22:08 -0700 Created attachment 405223 Patch v3 1675006 11 405223 ddkilzer 2020-07-25 07:21:06 -0700 Comment on attachment 405223 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=405223&action=review > Source/WebKit/Platform/cocoa/WKCrashReporter.mm:38 > -void setCrashReportApplicationSpecificInformation(CFStringRef infoString) > +void setCrashReportApplicationSpecificInformation(const char* infoString) > { > - WTF::setCrashLogMessage([(__bridge NSString *)infoString UTF8String]); > + WTFLogAlways("%s", infoString); > + WTF::setCrashLogMessage(infoString); > } Thinking about renaming this to WebKit::logAndSetCrashLogMessage(). 1675007 12 405223 darin 2020-07-25 08:57:02 -0700 Comment on attachment 405223 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=405223&action=review Change looks fine. > Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:276 > + WebKit::setCrashReportApplicationSpecificInformation([NSString stringWithFormat:@"Unhandled error code %x, message '%s' (%hu)", kr, description(message->messageName()), message->messageName()].UTF8String); Now that we are trying to make a C string rather than an CFStringRef, we could use WebKit string formatting instead of NSString stuff. It’s easier to use correctly with more type safety. Something like this: auto name = message->messageName(); auto string = makeString("Unhandled error code ", hex(kr, Lowercase) ", message '", description(name), " (", name, ')'); WebKit::setCrashReportApplicationSpecificInformation(string.utf8().data()); > Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:493 > + WebKit::setCrashReportApplicationSpecificInformation([NSString stringWithFormat:@"Unhandled error code %x from mach_msg, receive port is %x", kr, machPort].UTF8String); auto string = makeString("Unhandled error code ", hex(kr, Lowercase) ", from mach_msg, receive port is ", hex(machPort, Lowercase)); WebKit::setCrashReportApplicationSpecificInformation(string.utf8().data()); > Source/WebKit/Shared/Cocoa/AuxiliaryProcessCocoa.mm:37 > + setCrashReportApplicationSpecificInformation([NSString stringWithFormat:@"Received invalid message: '%s' (%hu)", description(messageName), messageName].UTF8String); auto string = makeString("Received invalid message: '", description(messageName), "' (", messageName, ')'); WebKit::setCrashReportApplicationSpecificInformation(string.utf8().data()); > Source/WebKit/Shared/EntryPointUtilities/Cocoa/XPCService/XPCServiceMain.mm:159 > + setCrashReportApplicationSpecificInformation([NSString stringWithFormat:@"WebKit framework version mismatch: %s != %s", webKitBundleVersion.utf8().data(), expectedBundleVersion.utf8().data()].UTF8String); auto string = makeString("WebKit framework version mismatch: ", webKitBundleVersion, " != ", expectedBundleVersion); WebKit::setCrashReportApplicationSpecificInformation(string.utf8().data()); > Tools/WebKitTestRunner/cocoa/CrashReporterInfo.mm:73 > String message("CRASHING TEST: "); > message = message + testPath; auto message = makeString("CRASHING TEST: ", testPath); 1675008 13 405223 darin 2020-07-25 09:00:23 -0700 Comment on attachment 405223 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=405223&action=review >> Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:276 >> + WebKit::setCrashReportApplicationSpecificInformation([NSString stringWithFormat:@"Unhandled error code %x, message '%s' (%hu)", kr, description(message->messageName()), message->messageName()].UTF8String); > > Now that we are trying to make a C string rather than an CFStringRef, we could use WebKit string formatting instead of NSString stuff. It’s easier to use correctly with more type safety. Something like this: > > auto name = message->messageName(); > auto string = makeString("Unhandled error code ", hex(kr, Lowercase) ", message '", description(name), " (", name, ')'); > WebKit::setCrashReportApplicationSpecificInformation(string.utf8().data()); I think I might have left an "0x" out. Also, if we don’t insist on lowercase hex, then we could omit the Lowercase option. Also might have to include the StringConcatenateNumbers.h and HexNumber.h headers. auto string = makeString("Unhandled error code 0x", hex(kr) ", message '", description(name), " (", name, ')'); 1675012 14 405223 simon.fraser 2020-07-25 10:38:34 -0700 Comment on attachment 405223 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=405223&action=review > Source/WebKit/Platform/cocoa/WKCrashReporter.mm:36 > + WTFLogAlways("%s", infoString); This is called for every test, not just tests that crash, so this will log every time. 1675308 15 405223 ddkilzer 2020-07-27 11:00:14 -0700 Comment on attachment 405223 Patch v3 View in context: https://bugs.webkit.org/attachment.cgi?id=405223&action=review >> Source/WebKit/Platform/cocoa/WKCrashReporter.mm:36 >> + WTFLogAlways("%s", infoString); > > This is called for every test, not just tests that crash, so this will log every time. Yep, I found that out in Patch v1 when it caused all internal layout test bots to think every test crashed, but (surprisingly!) external layout tests bots did not fail due to this change. This is no longer an issue as this patch changes DumpRenderTree and WebKitTestRunner to call WTF::setCrashLogMessage() directly now (scroll down to the end of the patch). 1675327 16 darin 2020-07-27 11:27:58 -0700 Seems to be there are two different possible uses of this function: 1) Calling when you know you are about to intentionally crash. 2) Calling to provide background information about context in case you crash, not knowing a crash will happen. For (2), the proposed implementation is not right. For (1), it’s fine. 1675410 17 ddkilzer 2020-07-27 15:24:38 -0700 (In reply to Darin Adler from comment #16) > Seems to be there are two different possible uses of this function: > > 1) Calling when you know you are about to intentionally crash. > > 2) Calling to provide background information about context in case you > crash, not knowing a crash will happen. > > For (2), the proposed implementation is not right. For (1), it’s fine. There are no instances of (2) after I changed DumpRenderTree and WebKitTestRunner to call WTF::setCrashLogMessage() directly. See Comment #15. I'm also renaming setCrashReportApplicationSpecificInformation() to logAndSetCrashLogMessage() as mentioned in Comment #11. 1675413 18 405314 ddkilzer 2020-07-27 15:25:15 -0700 Created attachment 405314 Patch for landing 1675457 19 405314 darin 2020-07-27 16:51:16 -0700 Comment on attachment 405314 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=405314&action=review > Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:278 > + auto messageNameValue = static_cast<std::underlying_type_t<IPC::MessageName>>(messageName); Could add support for this to StringConcatenateNumbers.h so we don’t have to cast. > Source/WebKit/Shared/Cocoa/AuxiliaryProcessCocoa.mm:37 > + auto messageNameValue = static_cast<std::underlying_type_t<IPC::MessageName>>(messageName); Ditto. > Tools/DumpRenderTree/mac/DumpRenderTree.mm:1648 > +static void changeWindowScaleIfNeeded(const char* testPathOrUrl) How about URL instead of Url? 1675466 20 405314 ddkilzer 2020-07-27 16:59:19 -0700 Comment on attachment 405314 Patch for landing Marking cq+ with win bot orange and ios-wk2,mac-debug-wk1 layout tests unfinished because: - The internal bot failures happened due to always logging from DRT and WKTR, and that code path has been fixed. Ran accessibility tests internally and they were not all marked as crashing. - This code path in WebKit2 is only used on crashing or (in one case) on a mach message error code path, which isn't something that is tested by layout tests. 1675467 21 ews-feeder 2020-07-27 17:02:20 -0700 Committed r264957: <https://trac.webkit.org/changeset/264957> All reviewed patches have been landed. Closing bug and clearing flags on attachment 405314. 1675475 22 405314 ddkilzer 2020-07-27 17:16:41 -0700 Comment on attachment 405314 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=405314&action=review >> Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:278 >> + auto messageNameValue = static_cast<std::underlying_type_t<IPC::MessageName>>(messageName); > > Could add support for this to StringConcatenateNumbers.h so we don’t have to cast. Using std::enable_if_t<std::is_enum<E>::value? Honestly, I looked at StringConcatenate.h, but it wasn't obvious to me how POD values (like int, unsigned, etc.) were handled by the template code, let alone how to add support for generic enum values. >> Tools/DumpRenderTree/mac/DumpRenderTree.mm:1648 >> +static void changeWindowScaleIfNeeded(const char* testPathOrUrl) > > How about URL instead of Url? I was going to use URL instead of Url, but then I felt compelled to change `localPathOrUrl` to match the parameter, and I wasn't even sure if anyone had a strong preference, and I didn't want to ask because it could to turn into bike shedding. I can fix this as a follow-up if you feel strongly about it. 1675480 23 darin 2020-07-27 17:38:26 -0700 (In reply to David Kilzer (:ddkilzer) from comment #22) > Using std::enable_if_t<std::is_enum<E>::value? Yes. 1675481 24 darin 2020-07-27 17:40:41 -0700 (In reply to David Kilzer (:ddkilzer) from comment #22) > I was going to use URL instead of Url, but then I felt compelled to change > `localPathOrUrl` to match the parameter, and I wasn't even sure if anyone > had a strong preference, and I didn't want to ask because it could to turn > into bike shedding. I think the WebKit coding style document specifically addresses this. 1675621 25 ddkilzer 2020-07-28 08:57:56 -0700 (In reply to Darin Adler from comment #24) > (In reply to David Kilzer (:ddkilzer) from comment #22) > > I was going to use URL instead of Url, but then I felt compelled to change > > `localPathOrUrl` to match the parameter, and I wasn't even sure if anyone > > had a strong preference, and I didn't want to ask because it could to turn > > into bike shedding. > > I think the WebKit coding style document specifically addresses this. It's kind of covered implicitly (when talking about lowercasing acronyms at the start of a variable name), but not explicitly in the middle or end of the variable. <https://webkit.org/code-style-guidelines/#names> And check-webkit-style doesn't have a check for it (which would be difficult in the general case, but "URL" is a pretty common acronym used in our variables): $ ./Tools/Scripts/check-webkit-style Tools/DumpRenderTree/mac/DumpRenderTree.mm 1675999 26 ddkilzer 2020-07-29 08:43:07 -0700 (In reply to David Kilzer (:ddkilzer) from comment #22) > Comment on attachment 405314 [details] > Patch for landing > > View in context: > https://bugs.webkit.org/attachment.cgi?id=405314&action=review > > >> Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:278 > >> + auto messageNameValue = static_cast<std::underlying_type_t<IPC::MessageName>>(messageName); > > > > Could add support for this to StringConcatenateNumbers.h so we don’t have to cast. > > Using std::enable_if_t<std::is_enum<E>::value? Honestly, I looked at > StringConcatenate.h, but it wasn't obvious to me how POD values (like int, > unsigned, etc.) were handled by the template code, let alone how to add > support for generic enum values. I was missing the existence of Source/WTF/wtf/text/StringConcatenateNumbers.h. Bug 214906: WTF::makeString() should handle enum values <https://bugs.webkit.org/show_bug.cgi?id=214906> 1676025 27 405314 achristensen 2020-07-29 09:41:24 -0700 Comment on attachment 405314 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=405314&action=review >>>> Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm:278 >>>> + auto messageNameValue = static_cast<std::underlying_type_t<IPC::MessageName>>(messageName); >>> >>> Could add support for this to StringConcatenateNumbers.h so we don’t have to cast. >> >> Using std::enable_if_t<std::is_enum<E>::value? Honestly, I looked at StringConcatenate.h, but it wasn't obvious to me how POD values (like int, unsigned, etc.) were handled by the template code, let alone how to add support for generic enum values. > > I was missing the existence of Source/WTF/wtf/text/StringConcatenateNumbers.h. > > Bug 214906: WTF::makeString() should handle enum values > <https://bugs.webkit.org/show_bug.cgi?id=214906> There is a generated function named description(MessageName) for this exact purpose. 1676028 28 darin 2020-07-29 09:43:30 -0700 (In reply to Alex Christensen from comment #27) > There is a generated function named description(MessageName) for this exact > purpose. I think that's a different purpose, involving the *name* of the message. Formatting an enum as an integer when making a string is distinct, and not specific to IPC messages. 1676112 29 achristensen 2020-07-29 13:29:43 -0700 What benefit does printing the invalid number have? If we have a valid number, we will get a valid name, otherwise description will return "<invalid message name>" and I'm not sure knowing the number will help anything. 1676114 30 darin 2020-07-29 13:37:10 -0700 Maybe a good point. Printing the number isn’t new to this patch. Maybe it’s not valuable? I’m generally unclear on how we decided what to log and had assumed the number was valuable. 1676318 31 ddkilzer 2020-07-29 23:23:56 -0700 (In reply to Alex Christensen from comment #29) > What benefit does printing the invalid number have? If we have a valid > number, we will get a valid name, otherwise description will return > "<invalid message name>" and I'm not sure knowing the number will help > anything. In this case, the number is going to both os_log() and to a register via CRASH_WITH_INFO(). So you’re saying there is no value in matching those up, or knowing that a particular generated enum has a given value? I’d actually find it useful in some cases to know the value of the generated enum without having to rebuild the source to regenerate the value. Is the only concern that someone might log an enum value thinking they were getting a string description instead? (Most enums in WebKit aren’t generated, so that isn’t even a common issue.) What’s the worst that could happen? They would have to go change their logging statement later to add the text description? Am I missing some other bad behavior? 1676439 32 achristensen 2020-07-30 10:21:35 -0700 What I'm saying is that the description string is all the information you would need, and it's more useful than an integer value. The only case where printing an integer would give you more information is if you got an invalid value, but I can't imagine needing to know which invalid value you get. If it's invalid, something has gone horribly wrong and that's all you need to know. 1676539 33 ddkilzer 2020-07-30 14:10:08 -0700 (In reply to Alex Christensen from comment #32) > What I'm saying is that the description string is all the information you > would need, and it's more useful than an integer value. The only case where > printing an integer would give you more information is if you got an invalid > value, but I can't imagine needing to know which invalid value you get. If > it's invalid, something has gone horribly wrong and that's all you need to > know. What if the value is so horribly wrong that description() returns nothing? Then I'd want the value, too. 1676612 34 achristensen 2020-07-30 16:13:22 -0700 It will always return a valid value or "<invalid message name>", in which case I don't think there's anything useful to get from the invalid value. 1676643 35 darin 2020-07-30 17:03:06 -0700 Are you going to force me to find the other cases where we already log numeric values of enums? I believe I know how programmers think: I expect I will find them. I think your position that this should never be done is an interesting proposal! 1676893 36 ddkilzer 2020-07-31 11:42:05 -0700 (In reply to Alex Christensen from comment #34) > It will always return a valid value or "<invalid message name>", in which > case I don't think there's anything useful to get from the invalid value. Alex, do you only object to logging IPC::MessageName specifically, or all enum values in general? Because I don't think it's practical to write description() methods for any enum value that someone might want to log in the future. Also, I disagree that an invalid value is not interesting. - When debugging an IPC failure, it's only uninteresting until we understand why we got the invalid value in the first place. - Also, we can't assume every invalid value would be exactly the same if "<invalid message name>" is returned. We could get a group of invalid values that are different (such as with a memory smasher), and just logging "<invalid message name>" would be nearly useless other than to know that an invalid value was passed. Conversely, a group of invalid values that are all the same tells us something different is probably happening other than a memory smasher. 405168 2020-07-24 12:51:44 -0700 2020-07-24 22:20:09 -0700 Patch v1 bug-214756-20200724125241.patch text/plain 1570 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjY0Nzg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDAyYWI4MTFjNmM1OGVkYWRh Y2U3NTQyMzBiYTcyOThhMjE3NmVlZmUuLjU4ZjJmMjE3NDdhZjNhYTQ1ZjE2ZmI3ZTI3YzI2NTg1 M2Q0MWFiZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjAtMDctMjQgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJLaXQ6OnNldENyYXNoUmVw b3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkgc2hvdWxkIGFsc28gbG9nIHRvIFdU RkxvZ0Fsd2F5cygpCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMTQ3NTY+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9j b2NvYS9XS0NyYXNoUmVwb3J0ZXIubW06CisgICAgICAgIChXZWJLaXQ6OnNldENyYXNoUmVwb3J0 QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKToKKyAgICAgICAgLSBBbHNvIG91dHB1dCB0 aGUgbG9nIGluZm9ybWF0aW9uIHZpYSBXVEZMb2dBbHdheXMoKSBpbiBjYXNlCisgICAgICAgICAg QXBwbGljYXRpb24gU3BlY2lmaWMgSW5mb3JtYXRpb24gaXMgb3ZlcndyaXR0ZW4gb3IgaXMgbm90 CisgICAgICAgICAgaW5jbHVkZWQgaW4gdGhlIGNyYXNoIGxvZy4KKwogMjAyMC0wNy0yMyAgRGF2 aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZC9VcGRhdGUgQ1JB U0hfV0lUSF9JTkZPKCkgZm9yIGludmFsaWQgSVBDIG1lc3NhZ2UgbG9nZ2luZwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIubW0gYi9Tb3Vy Y2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5tbQppbmRleCBkZGE0ZTJi OWQxNWEzNTNiNTA3MzkyNDAyYzFiNGZlNjI3NmZiM2I3Li45NTkxZDE1OTkyYWQ1ZTljYzA5ZTdh N2M0YWNjOWVlY2IzZjVjMzA0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2Nv Y29hL1dLQ3Jhc2hSZXBvcnRlci5tbQorKysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29h L1dLQ3Jhc2hSZXBvcnRlci5tbQpAQCAtMzMsNyArMzMsOSBAQCBuYW1lc3BhY2UgV2ViS2l0IHsK IAogdm9pZCBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihDRlN0 cmluZ1JlZiBpbmZvU3RyaW5nKQogewotICAgIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKFsoX19i cmlkZ2UgTlNTdHJpbmcgKilpbmZvU3RyaW5nIFVURjhTdHJpbmddKTsKKyAgICBhdXRvKiBjSW5m b1N0cmluZyA9IFsoX19icmlkZ2UgTlNTdHJpbmcgKilpbmZvU3RyaW5nIFVURjhTdHJpbmddOwor ICAgIFdURkxvZ0Fsd2F5cygiJXMiLCBjSW5mb1N0cmluZyk7CisgICAgV1RGOjpzZXRDcmFzaExv Z01lc3NhZ2UoY0luZm9TdHJpbmcpOwogfQogCiB9Cg== 405222 2020-07-24 22:20:11 -0700 2020-07-24 22:22:07 -0700 Patch v2 bug-214756-20200724222110.patch text/plain 20451 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjY0ODczCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQwMmExMzlkYzBjMDJmZDhi ZTBmNWQ4MGRiNmM0YWUxM2MxMjliZTguLjA0ZjFhNGJjYTc0OGZlZjdmOGQyNGEyNGIzODc5ZDU1 Y2U3Y2FiNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTQgQEAKKzIwMjAtMDctMjQgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJLaXQ6OnNldENyYXNoUmVw b3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkgc2hvdWxkIGFsc28gbG9nIHRvIFdU RkxvZ0Fsd2F5cygpCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMTQ3NTY+CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82NjA4NTcwNT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIGFsc28gbWFrZXMgdGhlIGZvbGxvd2luZyBjaGFu Z2VzOgorICAgICAgICAtIFJlcGxhY2VzIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVj aWZpY0luZm9ybWF0aW9uKCkKKyAgICAgICAgICB3aXRoIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRB cHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKS4KKyAgICAgICAgLSBDYWxscyBXVEY6OnNl dENyYXNoTG9nTWVzc2FnZSgpIGluIER1bXBSZW5kZXJUcmVlIGFuZAorICAgICAgICAgIFdlYktp dFRlc3RSdW5uZXIgdG8gYXZvaWQgbmV3IFdURkxvZ0Fsd2F5cygpIGNhbGxzLCB3aGljaAorICAg ICAgICAgIGJyb2tlIGludGVybmFsIHRlc3RzIGFuZCBjYXVzZWQgdGhlIGZpcnN0IHBhdGNoIHRv IGJlIHJvbGxlZAorICAgICAgICAgIG91dC4KKyAgICAgICAgLSBDaGFuZ2VzIFdlYktpdDo6c2V0 Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKQorICAgICAgICAgIHRv IHRha2UgYSBjb25zdCBjaGFyKiBhcmd1bWVudCBpbnN0ZWFkIG9mIENGU3RyaW5nUmVmLgorCisg ICAgICAgICogUGxhdGZvcm0vSVBDL2NvY29hL0Nvbm5lY3Rpb25Db2NvYS5tbToKKyAgICAgICAg KElQQzo6Q29ubmVjdGlvbjo6c2VuZE1lc3NhZ2UpOgorICAgICAgICAoSVBDOjpyZWFkRnJvbU1h Y2hQb3J0KToKKyAgICAgICAgLSBVcGRhdGUgY2FsbCB0byBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0 aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpCisgICAgICAgICAgdG8gcGFzcyBjb25zdCBjaGFyKiB2 YWx1ZS4KKworICAgICAgICAqIFBsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oOgorICAg ICAgICAoV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlv bik6CisgICAgICAgIC0gVXBkYXRlIGZ1bmN0aW9uIHNpZ25hdHVyZSB0byB1c2UgYGNvbnN0IGNo YXIqYC4KKyAgICAgICAgKiBQbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIubW06CisgICAg ICAgIChXZWJLaXQ6OnNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9u KToKKyAgICAgICAgLSBVcGRhdGUgZnVuY3Rpb24gc2lnbmF0dXJlIHRvIHVzZSBgY29uc3QgY2hh cipgLgorICAgICAgICAtIENhbGwgV1RGTG9nQWx3YXlzKCkgaW4gYWRkaXRpb24gdG8gc2V0dGlu ZyB0aGUgQXBwbGljYXRpb24KKyAgICAgICAgICBTcGVjaWZpYyBJbmZvcm1hdGlvbi4KKworICAg ICAgICAqIFNoYXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW06CisgICAgICAgIChX ZWJLaXQ6OkF1eGlsaWFyeVByb2Nlc3M6OmRpZFJlY2VpdmVJbnZhbGlkTWVzc2FnZSk6CisgICAg ICAgIC0gVXBkYXRlIGNhbGwgdG8gc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oKQorICAgICAgICAgIHRvIHBhc3MgY29uc3QgY2hhciogdmFsdWUuCisKKyAgICAg ICAgKiBTaGFyZWQvRW50cnlQb2ludFV0aWxpdGllcy9Db2NvYS9YUENTZXJ2aWNlL1hQQ1NlcnZp Y2VNYWluLm1tOgorICAgICAgICAoV2ViS2l0OjpYUENTZXJ2aWNlTWFpbik6CisgICAgICAgIC0g VXBkYXRlIGNhbGwgdG8gc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRp b24oKQorICAgICAgICAgIGluc3RlYWQgb2YgYm90aCBXVEZMb2dBbHdheXMoKSBhbmQKKyAgICAg ICAgICBfV0tTZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpLgor CisgICAgICAgICogV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgIC0g UmVtb3ZlIFdlYlByb2Nlc3NDb2NvYS5oIGZyb20gdGhlIHByb2plY3QuCisgICAgICAgICogV2Vi UHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EuaDogUmVtb3ZlLgorCisgICAgICAgICogV2Vi UHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EubW06CisgICAgICAgIChXZWJLaXQ6Ol9XS1Nl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKTogRGVsZXRlLgorCiAy MDIwLTA3LTI0ICBEZXZpbiBSb3Vzc28gIDxkcm91c3NvQGFwcGxlLmNvbT4KIAogICAgICAgICBG b2xsb3d1cCwgYWRvcHQgbW9yZSBkZXNjcmlwdGl2ZSBzeW1ib2wgaW1hZ2UgbmFtZSBmb3Igbm9u LUxUUgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVj dGlvbkNvY29hLm1tIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVjdGlv bkNvY29hLm1tCmluZGV4IGMxNjhkM2U0NGY5ZmQ0NzE4YTExODYxODM2ODkwMzAwMmNiMGI0YzQu LjA3N2FiZjU2MGUzZTc2NTQ4OWNkMDQ4OGU1MDAwZWIxMmZjY2NkOGMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL2NvY29hL0Nvbm5lY3Rpb25Db2NvYS5tbQorKysgYi9T b3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9jb2NvYS9Db25uZWN0aW9uQ29jb2EubW0KQEAgLTI3 Myw3ICsyNzMsNyBAQCBib29sIENvbm5lY3Rpb246OnNlbmRNZXNzYWdlKHN0ZDo6dW5pcXVlX3B0 cjxNYWNoTWVzc2FnZT4gbWVzc2FnZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgZGVm YXVsdDoKLSAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJ bmZvcm1hdGlvbigoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3Jt YXQ6QCJVbmhhbmRsZWQgZXJyb3IgY29kZSAleCwgbWVzc2FnZSAnJXMnICglaHUpIiwga3IsIGRl c2NyaXB0aW9uKG1lc3NhZ2UtPm1lc3NhZ2VOYW1lKCkpLCBtZXNzYWdlLT5tZXNzYWdlTmFtZSgp XSk7CisgICAgICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJVbmhhbmRsZWQgZXJyb3IgY29k ZSAleCwgbWVzc2FnZSAnJXMnICglaHUpIiwga3IsIGRlc2NyaXB0aW9uKG1lc3NhZ2UtPm1lc3Nh Z2VOYW1lKCkpLCBtZXNzYWdlLT5tZXNzYWdlTmFtZSgpXS5VVEY4U3RyaW5nKTsKICAgICAgICAg Q1JBU0hfV0lUSF9JTkZPKGtyLCBzdGF0aWNfY2FzdDxzdGQ6OnVuZGVybHlpbmdfdHlwZV90PElQ Qzo6TWVzc2FnZU5hbWU+PihtZXNzYWdlLT5tZXNzYWdlTmFtZSgpKSk7CiAgICAgfQogfQpAQCAt NDg5LDkgKzQ4OSw3IEBAIHN0YXRpYyBtYWNoX21zZ19oZWFkZXJfdCogcmVhZEZyb21NYWNoUG9y dChtYWNoX3BvcnRfdCBtYWNoUG9ydCwgUmVjZWl2ZUJ1ZmZlciYKICAgICB9CiAKICAgICBpZiAo a3IgIT0gTUFDSF9NU0dfU1VDQ0VTUykgewotI2lmIEFTU0VSVF9FTkFCTEVECi0gICAgICAgIFdl YktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKF9fYnJp ZGdlIENGU3RyaW5nUmVmKVtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiVW5oYW5kbGVkIGVy cm9yIGNvZGUgJXggZnJvbSBtYWNoX21zZywgcmVjZWl2ZSBwb3J0IGlzICV4Iiwga3IsIG1hY2hQ b3J0XSk7Ci0jZW5kaWYKKyAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9u U3BlY2lmaWNJbmZvcm1hdGlvbihbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIlVuaGFuZGxl ZCBlcnJvciBjb2RlICV4IGZyb20gbWFjaF9tc2csIHJlY2VpdmUgcG9ydCBpcyAleCIsIGtyLCBt YWNoUG9ydF0uVVRGOFN0cmluZyk7CiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAg ICAgICByZXR1cm4gbnVsbHB0cjsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1Bs YXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9j b2NvYS9XS0NyYXNoUmVwb3J0ZXIuaAppbmRleCA5NGQ4YzdhNzJhYTg4NjRkZTFiZTVmMWY3Nzdj NDQwODZkMTRmZDllLi40YmQwMmM0MWY3YTY2MGUyOTUwZjc1NTNlZmIxMDMzYmU0N2NlMWFiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5o CisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29jb2EvV0tDcmFzaFJlcG9ydGVyLmgKQEAg LTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNy0yMDIwIEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjks NiArMjksNiBAQAogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAotV0tfRVhQT1JUIHZvaWQgc2V0Q3Jh c2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oQ0ZTdHJpbmdSZWYpOworV0tf RVhQT1JUIHZvaWQgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24o Y29uc3QgY2hhciopOwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2Nv Y29hL1dLQ3Jhc2hSZXBvcnRlci5tbSBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29jb2EvV0tD cmFzaFJlcG9ydGVyLm1tCmluZGV4IGRkYTRlMmI5ZDE1YTM1M2I1MDczOTI0MDJjMWI0ZmU2Mjc2 ZmIzYjcuLmNmZWViMTYyZDBiMzUwMGRhMmVjYWVjZjc1Njc1Zjc1Y2FjMGI0NTggMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29jb2EvV0tDcmFzaFJlcG9ydGVyLm1tCisrKyBi L1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29jb2EvV0tDcmFzaFJlcG9ydGVyLm1tCkBAIC0xLDUg KzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMxLDkgKzMx LDEwIEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCi12b2lkIHNldENyYXNoUmVwb3J0QXBwbGlj YXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKENGU3RyaW5nUmVmIGluZm9TdHJpbmcpCit2b2lkIHNl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKGNvbnN0IGNoYXIqIGlu Zm9TdHJpbmcpCiB7Ci0gICAgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoWyhfX2JyaWRnZSBOU1N0 cmluZyAqKWluZm9TdHJpbmcgVVRGOFN0cmluZ10pOworICAgIFdURkxvZ0Fsd2F5cygiJXMiLCBp bmZvU3RyaW5nKTsKKyAgICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZShpbmZvU3RyaW5nKTsKIH0K IAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvQ29jb2EvQXV4aWxpYXJ5UHJv Y2Vzc0NvY29hLm1tIGIvU291cmNlL1dlYktpdC9TaGFyZWQvQ29jb2EvQXV4aWxpYXJ5UHJvY2Vz c0NvY29hLm1tCmluZGV4IGQ5ZTRiYzY2MDM3MmIxM2Q1MTlkZTQwZWJmOTNhYzRiMzdlM2ZiOGEu LmQzZTNlOWM5ZGVhYTc5NDAyMzIyZmM4MjRmMGQwYzliN2ExODY3MzAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvU2hhcmVkL0NvY29hL0F1eGlsaWFyeVByb2Nlc3NDb2NvYS5tbQorKysgYi9T b3VyY2UvV2ViS2l0L1NoYXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW0KQEAgLTEs NSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChDKSAyMDE3LTIwMTkgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE3LTIwMjAgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0z NCw3ICszNCw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiB2b2lkIEF1eGlsaWFyeVByb2Nlc3M6 OmRpZFJlY2VpdmVJbnZhbGlkTWVzc2FnZShJUEM6OkNvbm5lY3Rpb24mLCBJUEM6Ok1lc3NhZ2VO YW1lIG1lc3NhZ2VOYW1lKQogewotICAgIHNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZp Y0luZm9ybWF0aW9uKChfX2JyaWRnZSBDRlN0cmluZ1JlZilbTlNTdHJpbmcgc3RyaW5nV2l0aEZv cm1hdDpAIlJlY2VpdmVkIGludmFsaWQgbWVzc2FnZTogJyVzJyAoJWh1KSIsIGRlc2NyaXB0aW9u KG1lc3NhZ2VOYW1lKSwgbWVzc2FnZU5hbWVdKTsKKyAgICBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0 aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIlJlY2Vp dmVkIGludmFsaWQgbWVzc2FnZTogJyVzJyAoJWh1KSIsIGRlc2NyaXB0aW9uKG1lc3NhZ2VOYW1l KSwgbWVzc2FnZU5hbWVdLlVURjhTdHJpbmcpOwogICAgIENSQVNIX1dJVEhfSU5GTyhzdGF0aWNf Y2FzdDxzdGQ6OnVuZGVybHlpbmdfdHlwZV90PElQQzo6TWVzc2FnZU5hbWU+PihtZXNzYWdlTmFt ZSkpOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9FbnRyeVBvaW50VXRp bGl0aWVzL0NvY29hL1hQQ1NlcnZpY2UvWFBDU2VydmljZU1haW4ubW0gYi9Tb3VyY2UvV2ViS2l0 L1NoYXJlZC9FbnRyeVBvaW50VXRpbGl0aWVzL0NvY29hL1hQQ1NlcnZpY2UvWFBDU2VydmljZU1h aW4ubW0KaW5kZXggNWEyMmY1ZWIyOWU2OWZmNWIyMzllNzU1ZmVjNmE0ODlmZjgyOWZjZC4uN2E0 NDQ5YjM3NDNhZDk3MDI4N2ExNzlkMzA0NTZkOTk5YzllMGEzNCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9TaGFyZWQvRW50cnlQb2ludFV0aWxpdGllcy9Db2NvYS9YUENTZXJ2aWNlL1hQQ1Nl cnZpY2VNYWluLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0VudHJ5UG9pbnRVdGlsaXRp ZXMvQ29jb2EvWFBDU2VydmljZS9YUENTZXJ2aWNlTWFpbi5tbQpAQCAtMSw1ICsxLDUgQEAKIC8q Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMTMtMjAxOCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMtMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI0LDkgKzI0LDkgQEAK ICAqLwogCiAjaW1wb3J0ICJjb25maWcuaCIKLSNpbXBvcnQgIldlYlByb2Nlc3NDb2NvYS5oIgot I2ltcG9ydCAiWFBDU2VydmljZUVudHJ5UG9pbnQuaCIKIAorI2ltcG9ydCAiV0tDcmFzaFJlcG9y dGVyLmgiCisjaW1wb3J0ICJYUENTZXJ2aWNlRW50cnlQb2ludC5oIgogI2ltcG9ydCA8Q29yZUZv dW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KICNpbXBvcnQgPHBhbC9zcGkvY2YvQ0ZVdGlsaXRp ZXNTUEkuaD4KICNpbXBvcnQgPHBhbC9zcGkvY29jb2EvTGF1bmNoU2VydmljZXNTUEkuaD4KQEAg LTE1Niw4ICsxNTYsNyBAQCBpbnQgWFBDU2VydmljZU1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIq KiBhcmd2KQogICAgICAgICBTdHJpbmcgd2ViS2l0QnVuZGxlVmVyc2lvbiA9IHhwY19kaWN0aW9u YXJ5X2dldF9zdHJpbmcoYm9vdHN0cmFwLmdldCgpLCAiV2ViS2l0QnVuZGxlVmVyc2lvbiIpOwog ICAgICAgICBTdHJpbmcgZXhwZWN0ZWRCdW5kbGVWZXJzaW9uID0gW05TQnVuZGxlIGJ1bmRsZVdp dGhJZGVudGlmaWVyOkAiY29tLmFwcGxlLldlYktpdCJdLmluZm9EaWN0aW9uYXJ5WyhfX2JyaWRn ZSBOU1N0cmluZyAqKWtDRkJ1bmRsZVZlcnNpb25LZXldOwogICAgICAgICBpZiAoIXdlYktpdEJ1 bmRsZVZlcnNpb24uaXNOdWxsKCkgJiYgIWV4cGVjdGVkQnVuZGxlVmVyc2lvbi5pc051bGwoKSAm JiB3ZWJLaXRCdW5kbGVWZXJzaW9uICE9IGV4cGVjdGVkQnVuZGxlVmVyc2lvbikgewotICAgICAg ICAgICAgV1RGTG9nQWx3YXlzKCJXZWJLaXQgZnJhbWV3b3JrIHZlcnNpb24gbWlzbWF0Y2g6ICVz ICE9ICVzIiwgd2ViS2l0QnVuZGxlVmVyc2lvbi51dGY4KCkuZGF0YSgpLCBleHBlY3RlZEJ1bmRs ZVZlcnNpb24udXRmOCgpLmRhdGEoKSk7Ci0gICAgICAgICAgICBfV0tTZXRDcmFzaFJlcG9ydEFw cGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpA IldlYktpdCBmcmFtZXdvcmsgdmVyc2lvbiBtaXNtYXRjaDogJyVzJyIsIHdlYktpdEJ1bmRsZVZl cnNpb24udXRmOCgpLmRhdGEoKV0pOworICAgICAgICAgICAgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNh dGlvblNwZWNpZmljSW5mb3JtYXRpb24oW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJXZWJL aXQgZnJhbWV3b3JrIHZlcnNpb24gbWlzbWF0Y2g6ICVzICE9ICVzIiwgd2ViS2l0QnVuZGxlVmVy c2lvbi51dGY4KCkuZGF0YSgpLCBleHBlY3RlZEJ1bmRsZVZlcnNpb24udXRmOCgpLmRhdGEoKV0u VVRGOFN0cmluZyk7CiAgICAgICAgICAgICBjcmFzaER1ZVdlYktpdEZyYW1ld29ya1ZlcnNpb25N aXNtYXRjaCgpOwogICAgICAgICB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv V2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViS2l0L1dlYktpdC54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGNmNGY5ZDcyMWMxOWQ2OGQxZDBlYWI1ODQx ZTMyYTU5YmZjZWIwYTYuLjQyMjZkYjRkN2YxODZjZTRjYzRmNzc1OGI4YjNlYTM0NjhlYjA0YTEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKKysrIGIvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpA QCAtMTgzNiw3ICsxODM2LDYgQEAKIAkJRTU2OEI5MjIyMEEzQUM2QTAwRTNDODU2IC8qIFdlYkRh dGFMaXN0U3VnZ2VzdGlvbnNEcm9wZG93bk1hYy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gRTU2OEI5MjAyMEEzQUM2QTAwRTNDODU2IC8qIFdlYkRhdGFM aXN0U3VnZ2VzdGlvbnNEcm9wZG93bk1hYy5oICovOyB9OwogCQlFNUJFRjY4MjIxMzBDNDgwMDBG MzExMTEgLyogV2ViRGF0YUxpc3RTdWdnZXN0aW9uc0Ryb3Bkb3duSU9TLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNUJFRjY4MDIxMzBDNDdGMDBGMzEx MTEgLyogV2ViRGF0YUxpc3RTdWdnZXN0aW9uc0Ryb3Bkb3duSU9TLmggKi87IH07CiAJCUU1Q0Iw N0RDMjBFMTY3OEYwMDIyQzE4MyAvKiBXS0Zvcm1Db2xvckNvbnRyb2wuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU1Q0IwN0RBMjBFMTY3OEYwMDIyQzE4 MyAvKiBXS0Zvcm1Db2xvckNvbnRyb2wuaCAqLzsgfTsKLQkJRUNBNjgwRDgxRTY5MEUyNTAwNzMx RDIwIC8qIFdlYlByb2Nlc3NDb2NvYS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gRUNBNjgwRDcxRTY5MERGODAwNzMxRDIwIC8qIFdlYlByb2Nlc3NDb2Nv YS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUVE ODJBN0YyMTI4QzZGQUYwMDQ0NzdCMyAvKiBXS0J1bmRsZVBhZ2VPdmVybGF5LmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAxQTIyRjBGRjEyODlGQ0Q5MDA4 NUU3NEYgLyogV0tCdW5kbGVQYWdlT3ZlcmxheS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVT ID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0MDlCQTE4MUU2RTY0QkMwMDlEQTI4RSAvKiBXS0Ry YWdEZXN0aW5hdGlvbkFjdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gRjQwOUJBMTcxRTZFNjRCMzAwOURBMjhFIC8qIFdLRHJhZ0Rlc3RpbmF0aW9u QWN0aW9uLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsK IAkJRjQyRDYzNDEyMkEwRUZERjAwRDJGQjNBIC8qIFdlYkF1dG9jb3JyZWN0aW9uRGF0YS5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRjQyRDYzM0YyMkEw RUZEMzAwRDJGQjNBIC8qIFdlYkF1dG9jb3JyZWN0aW9uRGF0YS5oICovOyB9OwpAQCAtNTM3MCw3 ICs1MzY5LDYgQEAKIAkJRTVDQjA3REEyMEUxNjc4RjAwMjJDMTgzIC8qIFdLRm9ybUNvbG9yQ29u dHJvbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IG5hbWUgPSBXS0Zvcm1Db2xvckNvbnRyb2wuaDsgcGF0aCA9IGlvcy9m b3Jtcy9XS0Zvcm1Db2xvckNvbnRyb2wuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RTVDQjA3REIyMEUxNjc4RjAwMjJDMTgzIC8qIFdLRm9ybUNvbG9yQ29udHJvbC5tbSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw Lm9iamNwcDsgbmFtZSA9IFdLRm9ybUNvbG9yQ29udHJvbC5tbTsgcGF0aCA9IGlvcy9mb3Jtcy9X S0Zvcm1Db2xvckNvbnRyb2wubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUVDQTY4 MEQzMUU2OTA0QjUwMDczMUQyMCAvKiBFeHRyYVByaXZhdGVTeW1ib2xzRm9yVEFQSS5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFeHRyYVByaXZhdGVTeW1ib2xzRm9yVEFQSS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQlFQ0E2ODBENzFFNjkwREY4MDA3MzFEMjAg LyogV2ViUHJvY2Vzc0NvY29hLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdlYlByb2Nlc3NDb2NvYS5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFQ0JGQzFEQjFFNkE0RDY2MDAwMzAwQzcgLyog RXh0cmFQdWJsaWNTeW1ib2xzRm9yVEFQSS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFeHRyYVB1YmxpY1N5 bWJvbHNGb3JUQVBJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUYwMzY5Nzg3MTVG NEJGMDUwMEMzQTgwRSAvKiBXZWJDb2xvclBpY2tlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBXZWJDb2xvclBpY2tlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUY0MDlCQTE3MUU2RTY0QjMwMDlEQTI4RSAvKiBXS0RyYWdEZXN0aW5hdGlvbkFj dGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXS0RyYWdEZXN0aW5hdGlv bkFjdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtODQxOSw3ICs4NDE3LDYg QEAKIAkJCQk1MkQ1QTFCMjFDNTc0OUYyMDBERTM0QTMgLyogVmlkZW9GdWxsc2NyZWVuTWFuYWdl ci5oICovLAogCQkJCTUyRDVBMUIzMUM1NzQ5RjIwMERFMzRBMyAvKiBWaWRlb0Z1bGxzY3JlZW5N YW5hZ2VyLm1lc3NhZ2VzLmluICovLAogCQkJCTUyRDVBMUI0MUM1NzQ5RjIwMERFMzRBMyAvKiBW aWRlb0Z1bGxzY3JlZW5NYW5hZ2VyLm1tICovLAotCQkJCUVDQTY4MEQ3MUU2OTBERjgwMDczMUQy MCAvKiBXZWJQcm9jZXNzQ29jb2EuaCAqLywKIAkJCQk3QzZFNzBGOTE4QjJENEEwMDBGMjRFMkUg LyogV2ViUHJvY2Vzc0NvY29hLm1tICovLAogCQkJKTsKIAkJCXBhdGggPSBjb2NvYTsKQEAgLTEx Mzk3LDcgKzExMzk0LDYgQEAKIAkJCQlCQ0Q1OThBQzExMkI3RkRGMDBFQzhDMjMgLyogV2ViUHJl ZmVyZW5jZXNTdG9yZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTFDNTEyQzkxOTA2NTZFNTAwNDQ4 OTE0IC8qIFdlYlByZXZpZXdMb2FkZXJDbGllbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUJDMDMy RDk3MTBGNDM3QUYwMDU4QzE1QSAvKiBXZWJQcm9jZXNzLmggaW4gSGVhZGVycyAqLywKLQkJCQlF Q0E2ODBEODFFNjkwRTI1MDA3MzFEMjAgLyogV2ViUHJvY2Vzc0NvY29hLmggaW4gSGVhZGVycyAq LywKIAkJCQkxQTA0M0EwOTEyNEQxMUE5MDBGRkJGQjUgLyogV2ViUHJvY2Vzc0Nvbm5lY3Rpb24u aCBpbiBIZWFkZXJzICovLAogCQkJCTFBMDQzRjZBMTI1MTREOEIwMEZGQkZCNSAvKiBXZWJQcm9j ZXNzQ29ubmVjdGlvbk1lc3NhZ2VzLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzMwNjgyNDEyNUE2 Qjk0MDBFNzEyNzggLyogV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGluIEhlYWRlcnMg Ki8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvY29jb2EvV2ViUHJvY2Vz c0NvY29hLmggYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvY29jb2EvV2ViUHJvY2Vzc0NvY29h LmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGI3ODVkYjZiYTUwOTEwMmFjZWNhMTE2 M2ZlNmEyZTk5ZTFjYTZjMGYuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dlYlByb2Nlc3NDb2NvYS5o CisrKyAvZGV2L251bGwKQEAgLTEsMzIgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAx NyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJwotICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCi0gKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKLSAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKLSAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCi0gKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKLSAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCi0gKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQotICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgotICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNwcmFnbWEgb25j ZQotCi0jaW5jbHVkZSA8V2ViS2l0L1dLRm91bmRhdGlvbi5oPgotCi1uYW1lc3BhY2UgV2ViS2l0 IHsKLVdLX0VYVEVSTiB2b2lkIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0lu Zm9ybWF0aW9uKE5TU3RyaW5nICppbmZvU3RyaW5nKTsKLX0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvV2ViUHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EubW0gYi9Tb3VyY2UvV2ViS2l0 L1dlYlByb2Nlc3MvY29jb2EvV2ViUHJvY2Vzc0NvY29hLm1tCmluZGV4IGI5ZTY4Zjg4ZGJmMjg1 YWNmODJiYTFhMTdlZDI2MjkyOWI2OGRjYmEuLmQ1MmI0ZTE1MWZjYTdjZTg0MjJhZGUzNDBkNDkx N2U3YTA0ZjY2ZmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9jb2NvYS9X ZWJQcm9jZXNzQ29jb2EubW0KKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dl YlByb2Nlc3NDb2NvYS5tbQpAQCAtMjUsNyArMjUsNiBAQAogCiAjaW1wb3J0ICJjb25maWcuaCIK ICNpbXBvcnQgIldlYlByb2Nlc3MuaCIKLSNpbXBvcnQgIldlYlByb2Nlc3NDb2NvYS5oIgogCiAj aW1wb3J0ICJMYXVuY2hTZXJ2aWNlc0RhdGFiYXNlTWFuYWdlci5oIgogI2ltcG9ydCAiTGF1bmNo U2VydmljZXNEYXRhYmFzZVhQQ0NvbnN0YW50cy5oIgpAQCAtMzgsNyArMzcsNiBAQAogI2ltcG9y dCAiU2FuZGJveEluaXRpYWxpemF0aW9uUGFyYW1ldGVycy5oIgogI2ltcG9ydCAiV0tBUElDYXN0 LmgiCiAjaW1wb3J0ICJXS0Jyb3dzaW5nQ29udGV4dEhhbmRsZUludGVybmFsLmgiCi0jaW1wb3J0 ICJXS0NyYXNoUmVwb3J0ZXIuaCIKICNpbXBvcnQgIldLRnVsbEtleWJvYXJkQWNjZXNzV2F0Y2hl ci5oIgogI2ltcG9ydCAiV0tUeXBlUmVmV3JhcHBlci5oIgogI2ltcG9ydCAiV0tXZWJQcm9jZXNz UGx1Z0luQnJvd3NlckNvbnRleHRDb250cm9sbGVySW50ZXJuYWwuaCIKQEAgLTgyMSwxMiArODE5 LDYgQEAgdm9pZCBXZWJQcm9jZXNzOjpkZXN0cm95UmVuZGVyaW5nUmVzb3VyY2VzKCkKICAgICBS RUxFQVNFX0xPR19JRl9BTExPV0VEKFByb2Nlc3NTdXNwZW5zaW9uLCAiZGVzdHJveVJlbmRlcmlu Z1Jlc291cmNlczogdG9vayAlLjJmbXMiLCAoZW5kVGltZSAtIHN0YXJ0VGltZSkubWlsbGlzZWNv bmRzKCkpOwogfQogCi0vLyBGSVhNRTogVGhpcyBzaG91bGQgbGl2ZSBzb21ld2hlcmUgZWxzZSwg YW5kIGl0IHNob3VsZCBoYXZlIHRoZSBpbXBsZW1lbnRhdGlvbiBpbiBsaW5lIGluc3RlYWQgb2Yg Y2FsbGluZyBvdXQgdG8gV0tTSS4KLXZvaWQgX1dLU2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNw ZWNpZmljSW5mb3JtYXRpb24oTlNTdHJpbmcgKmluZm9TdHJpbmcpCi17Ci0gICAgcmV0dXJuIHNl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKChfX2JyaWRnZSBDRlN0 cmluZ1JlZilpbmZvU3RyaW5nKTsKLX0KLQogI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCiB2b2lk IFdlYlByb2Nlc3M6OmFjY2Vzc2liaWxpdHlQcm9jZXNzU3VzcGVuZGVkTm90aWZpY2F0aW9uKGJv b2wgc3VzcGVuZGVkKQogewpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hh bmdlTG9nCmluZGV4IDIwNWFjNDA0NzkwNWE2MjBhMDczZWJmOTJkNmZiODcxNmZmNzZjNDcuLjVk ODMxYzI2MzQwNWI4ZjlmZWM0ZThlZTE2ZGI3NjRhYWQ3ZDU0OTEgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOSBAQAorMjAyMC0w Ny0yNCAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBwbGUuY29tPgorCisgICAgICAgIFdlYktp dDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKSBzaG91bGQg YWxzbyBsb2cgdG8gV1RGTG9nQWx3YXlzKCkKKyAgICAgICAgPGh0dHBzOi8vd2Via2l0Lm9yZy9i LzIxNDc1Nj4KKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzY2MDg1NzA1PgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgYWxzbyBtYWtlcyB0aGUg Zm9sbG93aW5nIGNoYW5nZXM6CisgICAgICAgIC0gUmVwbGFjZXMgX1dLU2V0Q3Jhc2hSZXBvcnRB cHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKQorICAgICAgICAgIHdpdGggV2ViS2l0Ojpz ZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpLgorICAgICAgICAt IENhbGxzIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKCkgaW4gRHVtcFJlbmRlclRyZWUgYW5kCisg ICAgICAgICAgV2ViS2l0VGVzdFJ1bm5lciB0byBhdm9pZCBuZXcgV1RGTG9nQWx3YXlzKCkgY2Fs bHMsIHdoaWNoCisgICAgICAgICAgYnJva2UgaW50ZXJuYWwgdGVzdHMgYW5kIGNhdXNlZCB0aGUg Zmlyc3QgcGF0Y2ggdG8gYmUgcm9sbGVkCisgICAgICAgICAgb3V0LgorICAgICAgICAtIENoYW5n ZXMgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigp CisgICAgICAgICAgdG8gdGFrZSBhIGNvbnN0IGNoYXIqIGFyZ3VtZW50IGluc3RlYWQgb2YgQ0ZT dHJpbmdSZWYuCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUu bW06CisgICAgICAgIChydW5UZXN0KToKKyAgICAgICAgKiBXZWJLaXRUZXN0UnVubmVyL2NvY29h L0NyYXNoUmVwb3J0ZXJJbmZvLm1tOgorICAgICAgICAoV1RSOjpzZXRDcmFzaFJlcG9ydEFwcGxp Y2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvblRvVVJMKToKKyAgICAgICAgLSBTd2l0Y2ggZnJvbSBj YWxsaW5nCisgICAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lm aWNJbmZvcm1hdGlvbigpIHRvCisgICAgICAgICAgY2FsbGluZyBXVEY6OnNldENyYXNoTG9nTWVz c2FnZSgpIGRpcmVjdGx5LgorCiAyMDIwLTA3LTI0ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJk QGFwcGxlLmNvbT4KIAogICAgICAgICBwZXA4LnB5OjExMDogRnV0dXJlV2FybmluZzogUG9zc2li bGUgbmVzdGVkIHNldCBhdCBwb3NpdGlvbiAxIChGb2xsb3ctdXAgZml4KQpkaWZmIC0tZ2l0IGEv VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tIGIvVG9vbHMvRHVtcFJl bmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCmluZGV4IDg3YzA0ZDkyZmE0Y2U0NzIyMTZl OGMzOGZiZWU5YmJmNzFhMzJkOTkuLjE4MzQ1NzdkMTlhN2VmOTljYjU4ZmQ5MmRmYTIwMGI4NDY2 MzE2OTUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZS5tbQorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAg LTY1LDcgKzY1LDYgQEAKICNpbXBvcnQgPFdlYktpdC9ET01FbGVtZW50Lmg+CiAjaW1wb3J0IDxX ZWJLaXQvRE9NRXh0ZW5zaW9ucy5oPgogI2ltcG9ydCA8V2ViS2l0L0RPTVJhbmdlLmg+Ci0jaW1w b3J0IDxXZWJLaXQvV0tDcmFzaFJlcG9ydGVyLmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tSZXRhaW5Q dHIuaD4KICNpbXBvcnQgPFdlYktpdC9XS1N0cmluZy5oPgogI2ltcG9ydCA8V2ViS2l0L1dLU3Ry aW5nQ0YuaD4KQEAgLTk5LDYgKzk4LDcgQEAKICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KICNp bXBvcnQgPHd0Zi9UaHJlYWRpbmcuaD4KICNpbXBvcnQgPHd0Zi9VbmlxdWVBcnJheS5oPgorI2lt cG9ydCA8d3RmL2NvY29hL0NyYXNoUmVwb3J0ZXIuaD4KICNpbXBvcnQgPHd0Zi9jb2NvYS9WZWN0 b3JDb2NvYS5oPgogI2ltcG9ydCA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgogI2ltcG9ydCA8 d3RmL3RleHQvV1RGU3RyaW5nLmg+CkBAIC0yMDMyLDcgKzIwMzIsNyBAQCBzdGF0aWMgdm9pZCBy dW5UZXN0KGNvbnN0IHN0cmluZyYgaW5wdXRMaW5lKQogICAgICAgICB0ZXN0UGF0aCA9IFt1cmwg YWJzb2x1dGVTdHJpbmddOwogCiAgICAgTlNTdHJpbmcgKmluZm9ybWF0aW9uU3RyaW5nID0gW0Ai Q1JBU0hJTkcgVEVTVDogIiBzdHJpbmdCeUFwcGVuZGluZ1N0cmluZzp0ZXN0UGF0aF07Ci0gICAg V2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigoX19i cmlkZ2UgQ0ZTdHJpbmdSZWYpaW5mb3JtYXRpb25TdHJpbmcpOworICAgIFdURjo6c2V0Q3Jhc2hM b2dNZXNzYWdlKGluZm9ybWF0aW9uU3RyaW5nLlVURjhTdHJpbmcpOwogCiAgICAgVGVzdE9wdGlv bnMgb3B0aW9ucyB7IFt1cmwgaXNGaWxlVVJMXSA/IFt1cmwgZmlsZVN5c3RlbVJlcHJlc2VudGF0 aW9uXSA6IHBhdGhPclVSTCwgY29tbWFuZC5hYnNvbHV0ZVBhdGggfTsKIApkaWZmIC0tZ2l0IGEv VG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9jb2NvYS9DcmFzaFJlcG9ydGVySW5mby5tbSBiL1Rvb2xz L1dlYktpdFRlc3RSdW5uZXIvY29jb2EvQ3Jhc2hSZXBvcnRlckluZm8ubW0KaW5kZXggZTIyZDEx ZGE5YWIyZjM2MDRkMGE3OWUxMDM2NDUxMWYzYmE4MzE0My4uMmI1MDVhMThiMzJmNDlmZDQwMDBh Y2JkZGRkN2Y5YTU3YjgzYzY1ZSAxMDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9j b2NvYS9DcmFzaFJlcG9ydGVySW5mby5tbQorKysgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL2Nv Y29hL0NyYXNoUmVwb3J0ZXJJbmZvLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdo dCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQg KEMpIDIwMTQtMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI3LDkgKzI3LDkgQEAKICNpbXBvcnQgIkNyYXNoUmVw b3J0ZXJJbmZvLmgiCiAKICNpbXBvcnQgIlN0cmluZ0Z1bmN0aW9ucy5oIgotI2ltcG9ydCA8V2Vi S2l0L1dLQ3Jhc2hSZXBvcnRlci5oPgogI2ltcG9ydCA8V2ViS2l0L1dLVVJMQ0YuaD4KICNpbXBv cnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgPHd0Zi9jb2NvYS9DcmFzaFJlcG9ydGVyLmg+ CiAKIG5hbWVzcGFjZSBXVFIgewogCkBAIC03MSw3ICs3MSw3IEBAIHZvaWQgc2V0Q3Jhc2hSZXBv cnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb25Ub1VSTChXS1VSTFJlZiB1cmwpCiAgICAg aWYgKCF0ZXN0UGF0aC5pc051bGwoKSkgewogICAgICAgICBTdHJpbmcgbWVzc2FnZSgiQ1JBU0hJ TkcgVEVTVDogIik7CiAgICAgICAgIG1lc3NhZ2UgPSBtZXNzYWdlICsgdGVzdFBhdGg7Ci0gICAg ICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24o bWVzc2FnZS5jcmVhdGVDRlN0cmluZygpLmdldCgpKTsKKyAgICAgICAgV1RGOjpzZXRDcmFzaExv Z01lc3NhZ2UobWVzc2FnZS51dGY4KCkuZGF0YSgpKTsKICAgICB9CiB9CiAK 405223 2020-07-24 22:22:08 -0700 2020-07-25 08:57:02 -0700 Patch v3 bug-214756-20200724222308.patch text/plain 20437 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjY0ODczCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQwMmExMzlkYzBjMDJmZDhi ZTBmNWQ4MGRiNmM0YWUxM2MxMjliZTguLjA0ZjFhNGJjYTc0OGZlZjdmOGQyNGEyNGIzODc5ZDU1 Y2U3Y2FiNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTQgQEAKKzIwMjAtMDctMjQgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJLaXQ6OnNldENyYXNoUmVw b3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkgc2hvdWxkIGFsc28gbG9nIHRvIFdU RkxvZ0Fsd2F5cygpCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMTQ3NTY+CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82NjA4NTcwNT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIGFsc28gbWFrZXMgdGhlIGZvbGxvd2luZyBjaGFu Z2VzOgorICAgICAgICAtIFJlcGxhY2VzIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVj aWZpY0luZm9ybWF0aW9uKCkKKyAgICAgICAgICB3aXRoIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRB cHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKS4KKyAgICAgICAgLSBDYWxscyBXVEY6OnNl dENyYXNoTG9nTWVzc2FnZSgpIGluIER1bXBSZW5kZXJUcmVlIGFuZAorICAgICAgICAgIFdlYktp dFRlc3RSdW5uZXIgdG8gYXZvaWQgbmV3IFdURkxvZ0Fsd2F5cygpIGNhbGxzLCB3aGljaAorICAg ICAgICAgIGJyb2tlIGludGVybmFsIHRlc3RzIGFuZCBjYXVzZWQgdGhlIGZpcnN0IHBhdGNoIHRv IGJlIHJvbGxlZAorICAgICAgICAgIG91dC4KKyAgICAgICAgLSBDaGFuZ2VzIFdlYktpdDo6c2V0 Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKQorICAgICAgICAgIHRv IHRha2UgYSBjb25zdCBjaGFyKiBhcmd1bWVudCBpbnN0ZWFkIG9mIENGU3RyaW5nUmVmLgorCisg ICAgICAgICogUGxhdGZvcm0vSVBDL2NvY29hL0Nvbm5lY3Rpb25Db2NvYS5tbToKKyAgICAgICAg KElQQzo6Q29ubmVjdGlvbjo6c2VuZE1lc3NhZ2UpOgorICAgICAgICAoSVBDOjpyZWFkRnJvbU1h Y2hQb3J0KToKKyAgICAgICAgLSBVcGRhdGUgY2FsbCB0byBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0 aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpCisgICAgICAgICAgdG8gcGFzcyBjb25zdCBjaGFyKiB2 YWx1ZS4KKworICAgICAgICAqIFBsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oOgorICAg ICAgICAoV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlv bik6CisgICAgICAgIC0gVXBkYXRlIGZ1bmN0aW9uIHNpZ25hdHVyZSB0byB1c2UgYGNvbnN0IGNo YXIqYC4KKyAgICAgICAgKiBQbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIubW06CisgICAg ICAgIChXZWJLaXQ6OnNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9u KToKKyAgICAgICAgLSBVcGRhdGUgZnVuY3Rpb24gc2lnbmF0dXJlIHRvIHVzZSBgY29uc3QgY2hh cipgLgorICAgICAgICAtIENhbGwgV1RGTG9nQWx3YXlzKCkgaW4gYWRkaXRpb24gdG8gc2V0dGlu ZyB0aGUgQXBwbGljYXRpb24KKyAgICAgICAgICBTcGVjaWZpYyBJbmZvcm1hdGlvbi4KKworICAg ICAgICAqIFNoYXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW06CisgICAgICAgIChX ZWJLaXQ6OkF1eGlsaWFyeVByb2Nlc3M6OmRpZFJlY2VpdmVJbnZhbGlkTWVzc2FnZSk6CisgICAg ICAgIC0gVXBkYXRlIGNhbGwgdG8gc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oKQorICAgICAgICAgIHRvIHBhc3MgY29uc3QgY2hhciogdmFsdWUuCisKKyAgICAg ICAgKiBTaGFyZWQvRW50cnlQb2ludFV0aWxpdGllcy9Db2NvYS9YUENTZXJ2aWNlL1hQQ1NlcnZp Y2VNYWluLm1tOgorICAgICAgICAoV2ViS2l0OjpYUENTZXJ2aWNlTWFpbik6CisgICAgICAgIC0g VXBkYXRlIGNhbGwgdG8gc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRp b24oKQorICAgICAgICAgIGluc3RlYWQgb2YgYm90aCBXVEZMb2dBbHdheXMoKSBhbmQKKyAgICAg ICAgICBfV0tTZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpLgor CisgICAgICAgICogV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgIC0g UmVtb3ZlIFdlYlByb2Nlc3NDb2NvYS5oIGZyb20gdGhlIHByb2plY3QuCisgICAgICAgICogV2Vi UHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EuaDogUmVtb3ZlLgorCisgICAgICAgICogV2Vi UHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EubW06CisgICAgICAgIChXZWJLaXQ6Ol9XS1Nl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKTogRGVsZXRlLgorCiAy MDIwLTA3LTI0ICBEZXZpbiBSb3Vzc28gIDxkcm91c3NvQGFwcGxlLmNvbT4KIAogICAgICAgICBG b2xsb3d1cCwgYWRvcHQgbW9yZSBkZXNjcmlwdGl2ZSBzeW1ib2wgaW1hZ2UgbmFtZSBmb3Igbm9u LUxUUgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVj dGlvbkNvY29hLm1tIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVjdGlv bkNvY29hLm1tCmluZGV4IGMxNjhkM2U0NGY5ZmQ0NzE4YTExODYxODM2ODkwMzAwMmNiMGI0YzQu LmIwNmFlNTVmMGM2MzZkYzRmN2RhNTNhOTZmMDZkNGY3NDc0NDVkNWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL2NvY29hL0Nvbm5lY3Rpb25Db2NvYS5tbQorKysgYi9T b3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9jb2NvYS9Db25uZWN0aW9uQ29jb2EubW0KQEAgLTI3 Myw3ICsyNzMsNyBAQCBib29sIENvbm5lY3Rpb246OnNlbmRNZXNzYWdlKHN0ZDo6dW5pcXVlX3B0 cjxNYWNoTWVzc2FnZT4gbWVzc2FnZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgZGVm YXVsdDoKLSAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJ bmZvcm1hdGlvbigoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3Jt YXQ6QCJVbmhhbmRsZWQgZXJyb3IgY29kZSAleCwgbWVzc2FnZSAnJXMnICglaHUpIiwga3IsIGRl c2NyaXB0aW9uKG1lc3NhZ2UtPm1lc3NhZ2VOYW1lKCkpLCBtZXNzYWdlLT5tZXNzYWdlTmFtZSgp XSk7CisgICAgICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJVbmhhbmRsZWQgZXJyb3IgY29k ZSAleCwgbWVzc2FnZSAnJXMnICglaHUpIiwga3IsIGRlc2NyaXB0aW9uKG1lc3NhZ2UtPm1lc3Nh Z2VOYW1lKCkpLCBtZXNzYWdlLT5tZXNzYWdlTmFtZSgpXS5VVEY4U3RyaW5nKTsKICAgICAgICAg Q1JBU0hfV0lUSF9JTkZPKGtyLCBzdGF0aWNfY2FzdDxzdGQ6OnVuZGVybHlpbmdfdHlwZV90PElQ Qzo6TWVzc2FnZU5hbWU+PihtZXNzYWdlLT5tZXNzYWdlTmFtZSgpKSk7CiAgICAgfQogfQpAQCAt NDkwLDcgKzQ5MCw3IEBAIHN0YXRpYyBtYWNoX21zZ19oZWFkZXJfdCogcmVhZEZyb21NYWNoUG9y dChtYWNoX3BvcnRfdCBtYWNoUG9ydCwgUmVjZWl2ZUJ1ZmZlciYKIAogICAgIGlmIChrciAhPSBN QUNIX01TR19TVUNDRVNTKSB7CiAjaWYgQVNTRVJUX0VOQUJMRUQKLSAgICAgICAgV2ViS2l0Ojpz ZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigoX19icmlkZ2UgQ0ZT dHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJVbmhhbmRsZWQgZXJyb3IgY29k ZSAleCBmcm9tIG1hY2hfbXNnLCByZWNlaXZlIHBvcnQgaXMgJXgiLCBrciwgbWFjaFBvcnRdKTsK KyAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1h dGlvbihbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIlVuaGFuZGxlZCBlcnJvciBjb2RlICV4 IGZyb20gbWFjaF9tc2csIHJlY2VpdmUgcG9ydCBpcyAleCIsIGtyLCBtYWNoUG9ydF0uVVRGOFN0 cmluZyk7CiAjZW5kaWYKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgICAgIHJl dHVybiBudWxscHRyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9X S0NyYXNoUmVwb3J0ZXIuaCBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29jb2EvV0tDcmFzaFJl cG9ydGVyLmgKaW5kZXggOTRkOGM3YTcyYWE4ODY0ZGUxYmU1ZjFmNzc3YzQ0MDg2ZDE0ZmQ5ZS4u NGJkMDJjNDFmN2E2NjBlMjk1MGY3NTUzZWZiMTAzM2JlNDdjZTFhYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIuaAorKysgYi9Tb3VyY2Uv V2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oCkBAIC0xLDUgKzEsNSBAQAog LyoKLSAqIENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI5LDYgKzI5LDYgQEAKIAog bmFtZXNwYWNlIFdlYktpdCB7CiAKLVdLX0VYUE9SVCB2b2lkIHNldENyYXNoUmVwb3J0QXBwbGlj YXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKENGU3RyaW5nUmVmKTsKK1dLX0VYUE9SVCB2b2lkIHNl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKGNvbnN0IGNoYXIqKTsK IAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVw b3J0ZXIubW0gYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5t bQppbmRleCBkZGE0ZTJiOWQxNWEzNTNiNTA3MzkyNDAyYzFiNGZlNjI3NmZiM2I3Li5jZmVlYjE2 MmQwYjM1MDBkYTJlY2FlY2Y3NTY3NWY3NWNhYzBiNDU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5tbQorKysgYi9Tb3VyY2UvV2ViS2l0 L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5tbQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0g KiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog Q29weXJpZ2h0IChDKSAyMDE3LTIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgog ICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0zMSw5ICszMSwxMCBAQAogCiBuYW1l c3BhY2UgV2ViS2l0IHsKIAotdm9pZCBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJ bmZvcm1hdGlvbihDRlN0cmluZ1JlZiBpbmZvU3RyaW5nKQordm9pZCBzZXRDcmFzaFJlcG9ydEFw cGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihjb25zdCBjaGFyKiBpbmZvU3RyaW5nKQogewot ICAgIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKFsoX19icmlkZ2UgTlNTdHJpbmcgKilpbmZvU3Ry aW5nIFVURjhTdHJpbmddKTsKKyAgICBXVEZMb2dBbHdheXMoIiVzIiwgaW5mb1N0cmluZyk7Cisg ICAgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoaW5mb1N0cmluZyk7CiB9CiAKIH0KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0NvY29hL0F1eGlsaWFyeVByb2Nlc3NDb2NvYS5tbSBi L1NvdXJjZS9XZWJLaXQvU2hhcmVkL0NvY29hL0F1eGlsaWFyeVByb2Nlc3NDb2NvYS5tbQppbmRl eCBkOWU0YmM2NjAzNzJiMTNkNTE5ZGU0MGViZjkzYWM0YjM3ZTNmYjhhLi5kM2UzZTljOWRlYWE3 OTQwMjMyMmZjODI0ZjBkMGM5YjdhMTg2NzMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1No YXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW0KKysrIGIvU291cmNlL1dlYktpdC9T aGFyZWQvQ29jb2EvQXV4aWxpYXJ5UHJvY2Vzc0NvY29hLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoK LSAqIENvcHlyaWdodCAoQykgMjAxNy0yMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqIENvcHlyaWdodCAoQykgMjAxNy0yMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMzQsNyArMzQsNyBAQCBu YW1lc3BhY2UgV2ViS2l0IHsKIAogdm9pZCBBdXhpbGlhcnlQcm9jZXNzOjpkaWRSZWNlaXZlSW52 YWxpZE1lc3NhZ2UoSVBDOjpDb25uZWN0aW9uJiwgSVBDOjpNZXNzYWdlTmFtZSBtZXNzYWdlTmFt ZSkKIHsKLSAgICBzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigo X19icmlkZ2UgQ0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJSZWNlaXZl ZCBpbnZhbGlkIG1lc3NhZ2U6ICclcycgKCVodSkiLCBkZXNjcmlwdGlvbihtZXNzYWdlTmFtZSks IG1lc3NhZ2VOYW1lXSk7CisgICAgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJSZWNlaXZlZCBpbnZhbGlkIG1l c3NhZ2U6ICclcycgKCVodSkiLCBkZXNjcmlwdGlvbihtZXNzYWdlTmFtZSksIG1lc3NhZ2VOYW1l XS5VVEY4U3RyaW5nKTsKICAgICBDUkFTSF9XSVRIX0lORk8oc3RhdGljX2Nhc3Q8c3RkOjp1bmRl cmx5aW5nX3R5cGVfdDxJUEM6Ok1lc3NhZ2VOYW1lPj4obWVzc2FnZU5hbWUpKTsKIH0KIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvRW50cnlQb2ludFV0aWxpdGllcy9Db2NvYS9Y UENTZXJ2aWNlL1hQQ1NlcnZpY2VNYWluLm1tIGIvU291cmNlL1dlYktpdC9TaGFyZWQvRW50cnlQ b2ludFV0aWxpdGllcy9Db2NvYS9YUENTZXJ2aWNlL1hQQ1NlcnZpY2VNYWluLm1tCmluZGV4IDVh MjJmNWViMjllNjlmZjViMjM5ZTc1NWZlYzZhNDg5ZmY4MjlmY2QuLjdhNDQ0OWIzNzQzYWQ5NzAy ODdhMTc5ZDMwNDU2ZDk5OWM5ZTBhMzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU2hhcmVk L0VudHJ5UG9pbnRVdGlsaXRpZXMvQ29jb2EvWFBDU2VydmljZS9YUENTZXJ2aWNlTWFpbi5tbQor KysgYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9FbnRyeVBvaW50VXRpbGl0aWVzL0NvY29hL1hQQ1Nl cnZpY2UvWFBDU2VydmljZU1haW4ubW0KQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0 IChDKSAyMDEzLTIwMTggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDEzLTIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0yNCw5ICsyNCw5IEBACiAgKi8KIAogI2ltcG9y dCAiY29uZmlnLmgiCi0jaW1wb3J0ICJXZWJQcm9jZXNzQ29jb2EuaCIKLSNpbXBvcnQgIlhQQ1Nl cnZpY2VFbnRyeVBvaW50LmgiCiAKKyNpbXBvcnQgIldLQ3Jhc2hSZXBvcnRlci5oIgorI2ltcG9y dCAiWFBDU2VydmljZUVudHJ5UG9pbnQuaCIKICNpbXBvcnQgPENvcmVGb3VuZGF0aW9uL0NvcmVG b3VuZGF0aW9uLmg+CiAjaW1wb3J0IDxwYWwvc3BpL2NmL0NGVXRpbGl0aWVzU1BJLmg+CiAjaW1w b3J0IDxwYWwvc3BpL2NvY29hL0xhdW5jaFNlcnZpY2VzU1BJLmg+CkBAIC0xNTYsOCArMTU2LDcg QEAgaW50IFhQQ1NlcnZpY2VNYWluKGludCBhcmdjLCBjb25zdCBjaGFyKiogYXJndikKICAgICAg ICAgU3RyaW5nIHdlYktpdEJ1bmRsZVZlcnNpb24gPSB4cGNfZGljdGlvbmFyeV9nZXRfc3RyaW5n KGJvb3RzdHJhcC5nZXQoKSwgIldlYktpdEJ1bmRsZVZlcnNpb24iKTsKICAgICAgICAgU3RyaW5n IGV4cGVjdGVkQnVuZGxlVmVyc2lvbiA9IFtOU0J1bmRsZSBidW5kbGVXaXRoSWRlbnRpZmllcjpA ImNvbS5hcHBsZS5XZWJLaXQiXS5pbmZvRGljdGlvbmFyeVsoX19icmlkZ2UgTlNTdHJpbmcgKilr Q0ZCdW5kbGVWZXJzaW9uS2V5XTsKICAgICAgICAgaWYgKCF3ZWJLaXRCdW5kbGVWZXJzaW9uLmlz TnVsbCgpICYmICFleHBlY3RlZEJ1bmRsZVZlcnNpb24uaXNOdWxsKCkgJiYgd2ViS2l0QnVuZGxl VmVyc2lvbiAhPSBleHBlY3RlZEJ1bmRsZVZlcnNpb24pIHsKLSAgICAgICAgICAgIFdURkxvZ0Fs d2F5cygiV2ViS2l0IGZyYW1ld29yayB2ZXJzaW9uIG1pc21hdGNoOiAlcyAhPSAlcyIsIHdlYktp dEJ1bmRsZVZlcnNpb24udXRmOCgpLmRhdGEoKSwgZXhwZWN0ZWRCdW5kbGVWZXJzaW9uLnV0Zjgo KS5kYXRhKCkpOwotICAgICAgICAgICAgX1dLU2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNp ZmljSW5mb3JtYXRpb24oW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJXZWJLaXQgZnJhbWV3 b3JrIHZlcnNpb24gbWlzbWF0Y2g6ICclcyciLCB3ZWJLaXRCdW5kbGVWZXJzaW9uLnV0ZjgoKS5k YXRhKCldKTsKKyAgICAgICAgICAgIHNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0lu Zm9ybWF0aW9uKFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiV2ViS2l0IGZyYW1ld29yayB2 ZXJzaW9uIG1pc21hdGNoOiAlcyAhPSAlcyIsIHdlYktpdEJ1bmRsZVZlcnNpb24udXRmOCgpLmRh dGEoKSwgZXhwZWN0ZWRCdW5kbGVWZXJzaW9uLnV0ZjgoKS5kYXRhKCldLlVURjhTdHJpbmcpOwog ICAgICAgICAgICAgY3Jhc2hEdWVXZWJLaXRGcmFtZXdvcmtWZXJzaW9uTWlzbWF0Y2goKTsKICAg ICAgICAgfQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYktpdC54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagppbmRleCBjZjRmOWQ3MjFjMTlkNjhkMWQwZWFiNTg0MWUzMmE1OWJmY2ViMGE2 Li40MjI2ZGI0ZDdmMTg2Y2U0Y2M0Zjc3NThiOGIzZWEzNDY4ZWIwNGExIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJj ZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE4MzYsNyArMTgz Niw2IEBACiAJCUU1NjhCOTIyMjBBM0FDNkEwMEUzQzg1NiAvKiBXZWJEYXRhTGlzdFN1Z2dlc3Rp b25zRHJvcGRvd25NYWMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEU1NjhCOTIwMjBBM0FDNkEwMEUzQzg1NiAvKiBXZWJEYXRhTGlzdFN1Z2dlc3Rpb25z RHJvcGRvd25NYWMuaCAqLzsgfTsKIAkJRTVCRUY2ODIyMTMwQzQ4MDAwRjMxMTExIC8qIFdlYkRh dGFMaXN0U3VnZ2VzdGlvbnNEcm9wZG93bklPUy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gRTVCRUY2ODAyMTMwQzQ3RjAwRjMxMTExIC8qIFdlYkRhdGFM aXN0U3VnZ2VzdGlvbnNEcm9wZG93bklPUy5oICovOyB9OwogCQlFNUNCMDdEQzIwRTE2NzhGMDAy MkMxODMgLyogV0tGb3JtQ29sb3JDb250cm9sLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBFNUNCMDdEQTIwRTE2NzhGMDAyMkMxODMgLyogV0tGb3JtQ29s b3JDb250cm9sLmggKi87IH07Ci0JCUVDQTY4MEQ4MUU2OTBFMjUwMDczMUQyMCAvKiBXZWJQcm9j ZXNzQ29jb2EuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEVDQTY4MEQ3MUU2OTBERjgwMDczMUQyMCAvKiBXZWJQcm9jZXNzQ29jb2EuaCAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlFRDgyQTdGMjEyOEM2RkFG MDA0NDc3QjMgLyogV0tCdW5kbGVQYWdlT3ZlcmxheS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMUEyMkYwRkYxMjg5RkNEOTAwODVFNzRGIC8qIFdLQnVu ZGxlUGFnZU92ZXJsYXkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCAp OyB9OyB9OwogCQlGNDA5QkExODFFNkU2NEJDMDA5REEyOEUgLyogV0tEcmFnRGVzdGluYXRpb25B Y3Rpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0 MDlCQTE3MUU2RTY0QjMwMDlEQTI4RSAvKiBXS0RyYWdEZXN0aW5hdGlvbkFjdGlvbi5oICovOyBz ZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUY0MkQ2MzQxMjJB MEVGREYwMEQyRkIzQSAvKiBXZWJBdXRvY29ycmVjdGlvbkRhdGEuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEY0MkQ2MzNGMjJBMEVGRDMwMEQyRkIzQSAv KiBXZWJBdXRvY29ycmVjdGlvbkRhdGEuaCAqLzsgfTsKQEAgLTUzNzAsNyArNTM2OSw2IEBACiAJ CUU1Q0IwN0RBMjBFMTY3OEYwMDIyQzE4MyAvKiBXS0Zvcm1Db2xvckNvbnRyb2wuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBuYW1lID0gV0tGb3JtQ29sb3JDb250cm9sLmg7IHBhdGggPSBpb3MvZm9ybXMvV0tGb3JtQ29s b3JDb250cm9sLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUU1Q0IwN0RCMjBFMTY3 OEYwMDIyQzE4MyAvKiBXS0Zvcm1Db2xvckNvbnRyb2wubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUg PSBXS0Zvcm1Db2xvckNvbnRyb2wubW07IHBhdGggPSBpb3MvZm9ybXMvV0tGb3JtQ29sb3JDb250 cm9sLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFQ0E2ODBEMzFFNjkwNEI1MDA3 MzFEMjAgLyogRXh0cmFQcml2YXRlU3ltYm9sc0ZvclRBUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gRXh0cmFQcml2YXRlU3ltYm9sc0ZvclRBUEkuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKLQkJRUNBNjgwRDcxRTY5MERGODAwNzMxRDIwIC8qIFdlYlByb2Nlc3ND b2NvYS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBXZWJQcm9jZXNzQ29jb2EuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJRUNCRkMxREIxRTZBNEQ2NjAwMDMwMEM3IC8qIEV4dHJhUHVibGljU3lt Ym9sc0ZvclRBUEkuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRXh0cmFQdWJsaWNTeW1ib2xzRm9yVEFQSS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGMDM2OTc4NzE1RjRCRjA1MDBDM0E4MEUg LyogV2ViQ29sb3JQaWNrZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gV2ViQ29sb3JQaWNrZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGNDA5 QkExNzFFNkU2NEIzMDA5REEyOEUgLyogV0tEcmFnRGVzdGluYXRpb25BY3Rpb24uaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV0tEcmFnRGVzdGluYXRpb25BY3Rpb24uaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTg0MTksNyArODQxNyw2IEBACiAJCQkJNTJENUEx QjIxQzU3NDlGMjAwREUzNEEzIC8qIFZpZGVvRnVsbHNjcmVlbk1hbmFnZXIuaCAqLywKIAkJCQk1 MkQ1QTFCMzFDNTc0OUYyMDBERTM0QTMgLyogVmlkZW9GdWxsc2NyZWVuTWFuYWdlci5tZXNzYWdl cy5pbiAqLywKIAkJCQk1MkQ1QTFCNDFDNTc0OUYyMDBERTM0QTMgLyogVmlkZW9GdWxsc2NyZWVu TWFuYWdlci5tbSAqLywKLQkJCQlFQ0E2ODBENzFFNjkwREY4MDA3MzFEMjAgLyogV2ViUHJvY2Vz c0NvY29hLmggKi8sCiAJCQkJN0M2RTcwRjkxOEIyRDRBMDAwRjI0RTJFIC8qIFdlYlByb2Nlc3ND b2NvYS5tbSAqLywKIAkJCSk7CiAJCQlwYXRoID0gY29jb2E7CkBAIC0xMTM5Nyw3ICsxMTM5NCw2 IEBACiAJCQkJQkNENTk4QUMxMTJCN0ZERjAwRUM4QzIzIC8qIFdlYlByZWZlcmVuY2VzU3RvcmUu aCBpbiBIZWFkZXJzICovLAogCQkJCUExQzUxMkM5MTkwNjU2RTUwMDQ0ODkxNCAvKiBXZWJQcmV2 aWV3TG9hZGVyQ2xpZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzAzMkQ5NzEwRjQzN0FGMDA1 OEMxNUEgLyogV2ViUHJvY2Vzcy5oIGluIEhlYWRlcnMgKi8sCi0JCQkJRUNBNjgwRDgxRTY5MEUy NTAwNzMxRDIwIC8qIFdlYlByb2Nlc3NDb2NvYS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMUEwNDNB MDkxMjREMTFBOTAwRkZCRkI1IC8qIFdlYlByb2Nlc3NDb25uZWN0aW9uLmggaW4gSGVhZGVycyAq LywKIAkJCQkxQTA0M0Y2QTEyNTE0RDhCMDBGRkJGQjUgLyogV2ViUHJvY2Vzc0Nvbm5lY3Rpb25N ZXNzYWdlcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQkMzMDY4MjQxMjVBNkI5NDAwRTcxMjc4IC8q IFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCBpbiBIZWFkZXJzICovLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dlYlByb2Nlc3NDb2NvYS5oIGIvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dlYlByb2Nlc3NDb2NvYS5oCmRlbGV0ZWQgZmls ZSBtb2RlIDEwMDY0NAppbmRleCBiNzg1ZGI2YmE1MDkxMDJhY2VjYTExNjNmZTZhMmU5OWUxY2E2 YzBmLi4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1NvdXJj ZS9XZWJLaXQvV2ViUHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EuaAorKysgL2Rldi9udWxs CkBAIC0xLDMyICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBh cmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKLSAqIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAotICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCi0gKiBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SCi0gKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgotICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCi0gKiBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTgotICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKLSAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKLSAqIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jcHJhZ21hIG9uY2UKLQotI2luY2x1ZGUg PFdlYktpdC9XS0ZvdW5kYXRpb24uaD4KLQotbmFtZXNwYWNlIFdlYktpdCB7Ci1XS19FWFRFUk4g dm9pZCBfV0tTZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihOU1N0 cmluZyAqaW5mb1N0cmluZyk7Ci19CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvY29jb2EvV2ViUHJvY2Vzc0NvY29hLm1tIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2Nv Y29hL1dlYlByb2Nlc3NDb2NvYS5tbQppbmRleCBiOWU2OGY4OGRiZjI4NWFjZjgyYmExYTE3ZWQy NjI5MjliNjhkY2JhLi5kNTJiNGUxNTFmY2E3Y2U4NDIyYWRlMzQwZDQ5MTdlN2EwNGY2NmZlIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvY29jb2EvV2ViUHJvY2Vzc0NvY29h Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2Eu bW0KQEAgLTI1LDcgKzI1LDYgQEAKIAogI2ltcG9ydCAiY29uZmlnLmgiCiAjaW1wb3J0ICJXZWJQ cm9jZXNzLmgiCi0jaW1wb3J0ICJXZWJQcm9jZXNzQ29jb2EuaCIKIAogI2ltcG9ydCAiTGF1bmNo U2VydmljZXNEYXRhYmFzZU1hbmFnZXIuaCIKICNpbXBvcnQgIkxhdW5jaFNlcnZpY2VzRGF0YWJh c2VYUENDb25zdGFudHMuaCIKQEAgLTM4LDcgKzM3LDYgQEAKICNpbXBvcnQgIlNhbmRib3hJbml0 aWFsaXphdGlvblBhcmFtZXRlcnMuaCIKICNpbXBvcnQgIldLQVBJQ2FzdC5oIgogI2ltcG9ydCAi V0tCcm93c2luZ0NvbnRleHRIYW5kbGVJbnRlcm5hbC5oIgotI2ltcG9ydCAiV0tDcmFzaFJlcG9y dGVyLmgiCiAjaW1wb3J0ICJXS0Z1bGxLZXlib2FyZEFjY2Vzc1dhdGNoZXIuaCIKICNpbXBvcnQg IldLVHlwZVJlZldyYXBwZXIuaCIKICNpbXBvcnQgIldLV2ViUHJvY2Vzc1BsdWdJbkJyb3dzZXJD b250ZXh0Q29udHJvbGxlckludGVybmFsLmgiCkBAIC04MjEsMTIgKzgxOSw2IEBAIHZvaWQgV2Vi UHJvY2Vzczo6ZGVzdHJveVJlbmRlcmluZ1Jlc291cmNlcygpCiAgICAgUkVMRUFTRV9MT0dfSUZf QUxMT1dFRChQcm9jZXNzU3VzcGVuc2lvbiwgImRlc3Ryb3lSZW5kZXJpbmdSZXNvdXJjZXM6IHRv b2sgJS4yZm1zIiwgKGVuZFRpbWUgLSBzdGFydFRpbWUpLm1pbGxpc2Vjb25kcygpKTsKIH0KIAot Ly8gRklYTUU6IFRoaXMgc2hvdWxkIGxpdmUgc29tZXdoZXJlIGVsc2UsIGFuZCBpdCBzaG91bGQg aGF2ZSB0aGUgaW1wbGVtZW50YXRpb24gaW4gbGluZSBpbnN0ZWFkIG9mIGNhbGxpbmcgb3V0IHRv IFdLU0kuCi12b2lkIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0 aW9uKE5TU3RyaW5nICppbmZvU3RyaW5nKQotewotICAgIHJldHVybiBzZXRDcmFzaFJlcG9ydEFw cGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpaW5mb1N0 cmluZyk7Ci19Ci0KICNpZiBQTEFURk9STShJT1NfRkFNSUxZKQogdm9pZCBXZWJQcm9jZXNzOjph Y2Nlc3NpYmlsaXR5UHJvY2Vzc1N1c3BlbmRlZE5vdGlmaWNhdGlvbihib29sIHN1c3BlbmRlZCkK IHsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCAy MDVhYzQwNDc5MDVhNjIwYTA3M2ViZjkyZDZmYjg3MTZmZjc2YzQ3Li41ZDgzMWMyNjM0MDViOGY5 ZmVjNGU4ZWUxNmRiNzY0YWFkN2Q1NDkxIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysr IGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMjAtMDctMjQgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJLaXQ6OnNldENyYXNoUmVw b3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkgc2hvdWxkIGFsc28gbG9nIHRvIFdU RkxvZ0Fsd2F5cygpCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMTQ3NTY+CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82NjA4NTcwNT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIGFsc28gbWFrZXMgdGhlIGZvbGxvd2luZyBjaGFu Z2VzOgorICAgICAgICAtIFJlcGxhY2VzIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVj aWZpY0luZm9ybWF0aW9uKCkKKyAgICAgICAgICB3aXRoIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRB cHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKS4KKyAgICAgICAgLSBDYWxscyBXVEY6OnNl dENyYXNoTG9nTWVzc2FnZSgpIGluIER1bXBSZW5kZXJUcmVlIGFuZAorICAgICAgICAgIFdlYktp dFRlc3RSdW5uZXIgdG8gYXZvaWQgbmV3IFdURkxvZ0Fsd2F5cygpIGNhbGxzLCB3aGljaAorICAg ICAgICAgIGJyb2tlIGludGVybmFsIHRlc3RzIGFuZCBjYXVzZWQgdGhlIGZpcnN0IHBhdGNoIHRv IGJlIHJvbGxlZAorICAgICAgICAgIG91dC4KKyAgICAgICAgLSBDaGFuZ2VzIFdlYktpdDo6c2V0 Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKQorICAgICAgICAgIHRv IHRha2UgYSBjb25zdCBjaGFyKiBhcmd1bWVudCBpbnN0ZWFkIG9mIENGU3RyaW5nUmVmLgorCisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOgorICAgICAgICAo cnVuVGVzdCk6CisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9jb2NvYS9DcmFzaFJlcG9ydGVy SW5mby5tbToKKyAgICAgICAgKFdUUjo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmlj SW5mb3JtYXRpb25Ub1VSTCk6CisgICAgICAgIC0gU3dpdGNoIGZyb20gY2FsbGluZworICAgICAg ICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24o KSB0bworICAgICAgICAgIGNhbGxpbmcgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoKSBkaXJlY3Rs eS4KKwogMjAyMC0wNy0yNCAgSm9uYXRoYW4gQmVkYXJkICA8amJlZGFyZEBhcHBsZS5jb20+CiAK ICAgICAgICAgcGVwOC5weToxMTA6IEZ1dHVyZVdhcm5pbmc6IFBvc3NpYmxlIG5lc3RlZCBzZXQg YXQgcG9zaXRpb24gMSAoRm9sbG93LXVwIGZpeCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9E dW1wUmVuZGVyVHJlZS5tbQppbmRleCA4N2MwNGQ5MmZhNGNlNDcyMjE2ZThjMzhmYmVlOWJiZjcx YTMyZDk5Li4xODM0NTc3ZDE5YTdlZjk5Y2I1OGZkOTJkZmEyMDBiODQ2NjMxNjk1IDEwMDY0NAot LS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIvVG9v bHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC02NSw3ICs2NSw2IEBA CiAjaW1wb3J0IDxXZWJLaXQvRE9NRWxlbWVudC5oPgogI2ltcG9ydCA8V2ViS2l0L0RPTUV4dGVu c2lvbnMuaD4KICNpbXBvcnQgPFdlYktpdC9ET01SYW5nZS5oPgotI2ltcG9ydCA8V2ViS2l0L1dL Q3Jhc2hSZXBvcnRlci5oPgogI2ltcG9ydCA8V2ViS2l0L1dLUmV0YWluUHRyLmg+CiAjaW1wb3J0 IDxXZWJLaXQvV0tTdHJpbmcuaD4KICNpbXBvcnQgPFdlYktpdC9XS1N0cmluZ0NGLmg+CkBAIC05 OSw2ICs5OCw3IEBACiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CiAjaW1wb3J0IDx3dGYvVGhy ZWFkaW5nLmg+CiAjaW1wb3J0IDx3dGYvVW5pcXVlQXJyYXkuaD4KKyNpbXBvcnQgPHd0Zi9jb2Nv YS9DcmFzaFJlcG9ydGVyLmg+CiAjaW1wb3J0IDx3dGYvY29jb2EvVmVjdG9yQ29jb2EuaD4KICNp bXBvcnQgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KICNpbXBvcnQgPHd0Zi90ZXh0L1dURlN0 cmluZy5oPgpAQCAtMjAzMiw3ICsyMDMyLDcgQEAgc3RhdGljIHZvaWQgcnVuVGVzdChjb25zdCBz dHJpbmcmIGlucHV0TGluZSkKICAgICAgICAgdGVzdFBhdGggPSBbdXJsIGFic29sdXRlU3RyaW5n XTsKIAogICAgIE5TU3RyaW5nICppbmZvcm1hdGlvblN0cmluZyA9IFtAIkNSQVNISU5HIFRFU1Q6 ICIgc3RyaW5nQnlBcHBlbmRpbmdTdHJpbmc6dGVzdFBhdGhdOwotICAgIFdlYktpdDo6c2V0Q3Jh c2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKF9fYnJpZGdlIENGU3RyaW5n UmVmKWluZm9ybWF0aW9uU3RyaW5nKTsKKyAgICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZShpbmZv cm1hdGlvblN0cmluZy5VVEY4U3RyaW5nKTsKIAogICAgIFRlc3RPcHRpb25zIG9wdGlvbnMgeyBb dXJsIGlzRmlsZVVSTF0gPyBbdXJsIGZpbGVTeXN0ZW1SZXByZXNlbnRhdGlvbl0gOiBwYXRoT3JV UkwsIGNvbW1hbmQuYWJzb2x1dGVQYXRoIH07CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1dlYktpdFRl c3RSdW5uZXIvY29jb2EvQ3Jhc2hSZXBvcnRlckluZm8ubW0gYi9Ub29scy9XZWJLaXRUZXN0UnVu bmVyL2NvY29hL0NyYXNoUmVwb3J0ZXJJbmZvLm1tCmluZGV4IGUyMmQxMWRhOWFiMmYzNjA0ZDBh NzllMTAzNjQ1MTFmM2JhODMxNDMuLjJiNTA1YTE4YjMyZjQ5ZmQ0MDAwYWNiZGRkZDdmOWE1N2I4 M2M2NWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvY29jb2EvQ3Jhc2hSZXBv cnRlckluZm8ubW0KKysrIGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9jb2NvYS9DcmFzaFJlcG9y dGVySW5mby5tbQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTQgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE0LTIwMjAg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCkBAIC0yNyw5ICsyNyw5IEBACiAjaW1wb3J0ICJDcmFzaFJlcG9ydGVySW5mby5oIgog CiAjaW1wb3J0ICJTdHJpbmdGdW5jdGlvbnMuaCIKLSNpbXBvcnQgPFdlYktpdC9XS0NyYXNoUmVw b3J0ZXIuaD4KICNpbXBvcnQgPFdlYktpdC9XS1VSTENGLmg+CiAjaW1wb3J0IDx3dGYvUmV0YWlu UHRyLmg+CisjaW1wb3J0IDx3dGYvY29jb2EvQ3Jhc2hSZXBvcnRlci5oPgogCiBuYW1lc3BhY2Ug V1RSIHsKIApAQCAtNzEsNyArNzEsNyBAQCB2b2lkIHNldENyYXNoUmVwb3J0QXBwbGljYXRpb25T cGVjaWZpY0luZm9ybWF0aW9uVG9VUkwoV0tVUkxSZWYgdXJsKQogICAgIGlmICghdGVzdFBhdGgu aXNOdWxsKCkpIHsKICAgICAgICAgU3RyaW5nIG1lc3NhZ2UoIkNSQVNISU5HIFRFU1Q6ICIpOwog ICAgICAgICBtZXNzYWdlID0gbWVzc2FnZSArIHRlc3RQYXRoOwotICAgICAgICBXZWJLaXQ6OnNl dENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKG1lc3NhZ2UuY3JlYXRl Q0ZTdHJpbmcoKS5nZXQoKSk7CisgICAgICAgIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKG1lc3Nh Z2UudXRmOCgpLmRhdGEoKSk7CiAgICAgfQogfQogCg== 405314 2020-07-27 15:25:15 -0700 2020-07-27 17:02:20 -0700 Patch for landing bug-214756-20200727152515.patch text/plain 22085 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjY0OTA3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGVmZDUxN2RmYTVhM2Q4NTRl YmU2NWI0ZGY5MGY0YmViNGY4YTc1Y2IuLjdhNzAwYzQxODRjMzMwODZhYzM3YzUxMjhmMzkwOTJi OTU0M2NkYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTggQEAKKzIwMjAtMDctMjcgIERhdmlkIEtp bHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJLaXQ6OnNldENyYXNoUmVw b3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkgc2hvdWxkIGFsc28gbG9nIHRvIFdU RkxvZ0Fsd2F5cygpCisgICAgICAgIDxodHRwczovL3dlYmtpdC5vcmcvYi8yMTQ3NTY+CisgICAg ICAgIDxyZGFyOi8vcHJvYmxlbS82NjA4NTcwNT4KKworICAgICAgICBSZXZpZXdlZCBieSBEYXJp biBBZGxlci4KKworICAgICAgICBUaGlzIGFsc28gbWFrZXMgdGhlIGZvbGxvd2luZyBjaGFuZ2Vz OgorICAgICAgICAtIFJlbmFtZXMgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5m b3JtYXRpb24oKSB0bworICAgICAgICAgIGxvZ0FuZFNldENyYXNoTG9nTWVzc2FnZSgpLgorICAg ICAgICAtIFJlcGxhY2VzIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9y bWF0aW9uKCkKKyAgICAgICAgICB3aXRoIFdlYktpdDo6bG9nQW5kU2V0Q3Jhc2hMb2dNZXNzYWdl KCkuCisgICAgICAgIC0gQ2FsbHMgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoKSBpbiBEdW1wUmVu ZGVyVHJlZSBhbmQKKyAgICAgICAgICBXZWJLaXRUZXN0UnVubmVyIHRvIGF2b2lkIG5ldyBXVEZM b2dBbHdheXMoKSBjYWxscywgd2hpY2gKKyAgICAgICAgICBicm9rZSBpbnRlcm5hbCB0ZXN0cyBh bmQgY2F1c2VkIHRoZSBmaXJzdCBwYXRjaCB0byBiZSByb2xsZWQKKyAgICAgICAgICBvdXQuCisg ICAgICAgIC0gQ2hhbmdlcyBXZWJLaXQ6OmxvZ0FuZFNldENyYXNoTG9nTWVzc2FnZSgpIHRvIHRh a2UgYQorICAgICAgICAgIGNvbnN0IGNoYXIqIGFyZ3VtZW50IGluc3RlYWQgb2YgQ0ZTdHJpbmdS ZWYuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVjdGlvbkNvY29hLm1tOgor ICAgICAgICAoSVBDOjpDb25uZWN0aW9uOjpzZW5kTWVzc2FnZSk6CisgICAgICAgIChJUEM6OnJl YWRGcm9tTWFjaFBvcnQpOgorICAgICAgICAtIFVwZGF0ZSBjYWxsIHRvIGxvZ0FuZFNldENyYXNo TG9nTWVzc2FnZSgpIHRvIHBhc3MgY29uc3QgY2hhcioKKyAgICAgICAgICB2YWx1ZS4KKworICAg ICAgICAqIFBsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oOgorICAgICAgICAoV2ViS2l0 Ojpsb2dBbmRTZXRDcmFzaExvZ01lc3NhZ2UpOgorICAgICAgICAtIFJlbmFtZSBmcm9tIHNldENy YXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkuCisgICAgICAgIC0gVXBk YXRlIGZ1bmN0aW9uIHNpZ25hdHVyZSB0byB1c2UgYGNvbnN0IGNoYXIqYC4KKyAgICAgICAgKiBQ bGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIubW06CisgICAgICAgIChXZWJLaXQ6OmxvZ0Fu ZFNldENyYXNoTG9nTWVzc2FnZSk6CisgICAgICAgIC0gUmVuYW1lIGZyb20gc2V0Q3Jhc2hSZXBv cnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKS4KKyAgICAgICAgLSBVcGRhdGUgZnVu Y3Rpb24gc2lnbmF0dXJlIHRvIHVzZSBgY29uc3QgY2hhcipgLgorICAgICAgICAtIENhbGwgV1RG TG9nQWx3YXlzKCkgaW4gYWRkaXRpb24gdG8gc2V0dGluZyB0aGUgQXBwbGljYXRpb24KKyAgICAg ICAgICBTcGVjaWZpYyBJbmZvcm1hdGlvbi4KKworICAgICAgICAqIFNoYXJlZC9Db2NvYS9BdXhp bGlhcnlQcm9jZXNzQ29jb2EubW06CisgICAgICAgIChXZWJLaXQ6OkF1eGlsaWFyeVByb2Nlc3M6 OmRpZFJlY2VpdmVJbnZhbGlkTWVzc2FnZSk6CisgICAgICAgIC0gVXBkYXRlIGNhbGwgdG8gbG9n QW5kU2V0Q3Jhc2hMb2dNZXNzYWdlKCkgdG8gcGFzcyBjb25zdCBjaGFyKgorICAgICAgICAgIHZh bHVlLgorCisgICAgICAgICogU2hhcmVkL0VudHJ5UG9pbnRVdGlsaXRpZXMvQ29jb2EvWFBDU2Vy dmljZS9YUENTZXJ2aWNlTWFpbi5tbToKKyAgICAgICAgKFdlYktpdDo6WFBDU2VydmljZU1haW4p OgorICAgICAgICAtIFVwZGF0ZSBjYWxsIHRvIGxvZ0FuZFNldENyYXNoTG9nTWVzc2FnZSgpIGlu c3RlYWQgb2YgYm90aAorICAgICAgICAgIFdURkxvZ0Fsd2F5cygpIGFuZAorICAgICAgICAgIF9X S1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKCkuCisKKyAgICAg ICAgKiBXZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgLSBSZW1vdmUg V2ViUHJvY2Vzc0NvY29hLmggZnJvbSB0aGUgcHJvamVjdC4KKyAgICAgICAgKiBXZWJQcm9jZXNz L2NvY29hL1dlYlByb2Nlc3NDb2NvYS5oOiBSZW1vdmUuCisKKyAgICAgICAgKiBXZWJQcm9jZXNz L2NvY29hL1dlYlByb2Nlc3NDb2NvYS5tbToKKyAgICAgICAgKFdlYktpdDo6X1dLU2V0Q3Jhc2hS ZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24pOiBEZWxldGUuCisKIDIwMjAtMDct MjYgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAgICAgUkVH UkVTU0lPTiAocjI2NDY5MCk6IFsgaU9TIHdrMiBdIGVkaXRpbmcvc2VsZWN0aW9uL3NoaWZ0LWNs aWNrLWluY2x1ZGVzLWV4aXN0aW5nLXNlbGVjdGlvbi5odG1sIGlzIGEgZmxha3kgZmFpbHVyZQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVjdGlvbkNv Y29hLm1tIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvY29jb2EvQ29ubmVjdGlvbkNvY29h Lm1tCmluZGV4IGMxNjhkM2U0NGY5ZmQ0NzE4YTExODYxODM2ODkwMzAwMmNiMGI0YzQuLjJlZWM4 NWIzYzRjOWM2ZTA5MjE4YmY3NGQ1MDg1ZWI0ODY3NDI4ZTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvUGxhdGZvcm0vSVBDL2NvY29hL0Nvbm5lY3Rpb25Db2NvYS5tbQorKysgYi9Tb3VyY2Uv V2ViS2l0L1BsYXRmb3JtL0lQQy9jb2NvYS9Db25uZWN0aW9uQ29jb2EubW0KQEAgLTM2LDYgKzM2 LDcgQEAKICNpbXBvcnQgPG1hY2gvbWFjaF9lcnJvci5oPgogI2ltcG9ydCA8bWFjaC92bV9tYXAu aD4KICNpbXBvcnQgPHN5cy9tbWFuLmg+CisjaW1wb3J0IDx3dGYvSGV4TnVtYmVyLmg+CiAjaW1w b3J0IDx3dGYvTWFjaFNlbmRSaWdodC5oPgogI2ltcG9ydCA8d3RmL1J1bkxvb3AuaD4KICNpbXBv cnQgPHd0Zi9zcGkvZGFyd2luL1hQQ1NQSS5oPgpAQCAtMjczLDggKzI3NCwxMSBAQCBib29sIENv bm5lY3Rpb246OnNlbmRNZXNzYWdlKHN0ZDo6dW5pcXVlX3B0cjxNYWNoTWVzc2FnZT4gbWVzc2Fn ZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgZGVmYXVsdDoKLSAgICAgICAgV2ViS2l0 OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigoX19icmlkZ2Ug Q0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJVbmhhbmRsZWQgZXJyb3Ig Y29kZSAleCwgbWVzc2FnZSAnJXMnICglaHUpIiwga3IsIGRlc2NyaXB0aW9uKG1lc3NhZ2UtPm1l c3NhZ2VOYW1lKCkpLCBtZXNzYWdlLT5tZXNzYWdlTmFtZSgpXSk7Ci0gICAgICAgIENSQVNIX1dJ VEhfSU5GTyhrciwgc3RhdGljX2Nhc3Q8c3RkOjp1bmRlcmx5aW5nX3R5cGVfdDxJUEM6Ok1lc3Nh Z2VOYW1lPj4obWVzc2FnZS0+bWVzc2FnZU5hbWUoKSkpOworICAgICAgICBhdXRvIG1lc3NhZ2VO YW1lID0gbWVzc2FnZS0+bWVzc2FnZU5hbWUoKTsKKyAgICAgICAgYXV0byBtZXNzYWdlTmFtZVZh bHVlID0gc3RhdGljX2Nhc3Q8c3RkOjp1bmRlcmx5aW5nX3R5cGVfdDxJUEM6Ok1lc3NhZ2VOYW1l Pj4obWVzc2FnZU5hbWUpOworICAgICAgICBhdXRvIGVycm9yTWVzc2FnZSA9IG1ha2VTdHJpbmco IlVuaGFuZGxlZCBlcnJvciBjb2RlIDB4IiwgaGV4KGtyKSwgIiwgbWVzc2FnZSAnIiwgZGVzY3Jp cHRpb24obWVzc2FnZU5hbWUpLCAiJyAoIiwgbWVzc2FnZU5hbWVWYWx1ZSwgJyknKTsKKyAgICAg ICAgV2ViS2l0Ojpsb2dBbmRTZXRDcmFzaExvZ01lc3NhZ2UoZXJyb3JNZXNzYWdlLnV0ZjgoKS5k YXRhKCkpOworICAgICAgICBDUkFTSF9XSVRIX0lORk8oa3IsIG1lc3NhZ2VOYW1lVmFsdWUpOwog ICAgIH0KIH0KIApAQCAtNDkwLDcgKzQ5NCw4IEBAIHN0YXRpYyBtYWNoX21zZ19oZWFkZXJfdCog cmVhZEZyb21NYWNoUG9ydChtYWNoX3BvcnRfdCBtYWNoUG9ydCwgUmVjZWl2ZUJ1ZmZlciYKIAog ICAgIGlmIChrciAhPSBNQUNIX01TR19TVUNDRVNTKSB7CiAjaWYgQVNTRVJUX0VOQUJMRUQKLSAg ICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlv bigoX19icmlkZ2UgQ0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCJVbmhh bmRsZWQgZXJyb3IgY29kZSAleCBmcm9tIG1hY2hfbXNnLCByZWNlaXZlIHBvcnQgaXMgJXgiLCBr ciwgbWFjaFBvcnRdKTsKKyAgICAgICAgYXV0byBlcnJvck1lc3NhZ2UgPSBtYWtlU3RyaW5nKCJV bmhhbmRsZWQgZXJyb3IgY29kZSAweCIsIGhleChrciksICIgZnJvbSBtYWNoX21zZywgcmVjZWl2 ZSBwb3J0IGlzIDB4IiwgaGV4KG1hY2hQb3J0KSk7CisgICAgICAgIFdlYktpdDo6bG9nQW5kU2V0 Q3Jhc2hMb2dNZXNzYWdlKGVycm9yTWVzc2FnZS51dGY4KCkuZGF0YSgpKTsKICNlbmRpZgogICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0dXJuIG51bGxwdHI7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oIGIv U291cmNlL1dlYktpdC9QbGF0Zm9ybS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIuaAppbmRleCA5NGQ4 YzdhNzJhYTg4NjRkZTFiZTVmMWY3NzdjNDQwODZkMTRmZDllLi43YzZhMmRlZjc2MmI4NTJjMjc2 ZWEzMzNkZDk3M2RkYzNhZWJhMzBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3Jt L2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vY29j b2EvV0tDcmFzaFJlcG9ydGVyLmgKQEAgLTEsNSArMSw1IEBACiAvKgotICogQ29weXJpZ2h0IChD KSAyMDE3IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykg MjAxNy0yMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucwpAQCAtMjksNiArMjksNiBAQAogCiBuYW1lc3BhY2UgV2ViS2l0IHsK IAotV0tfRVhQT1JUIHZvaWQgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3Jt YXRpb24oQ0ZTdHJpbmdSZWYpOworV0tfRVhQT1JUIHZvaWQgbG9nQW5kU2V0Q3Jhc2hMb2dNZXNz YWdlKGNvbnN0IGNoYXIqKTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9QbGF0Zm9y bS9jb2NvYS9XS0NyYXNoUmVwb3J0ZXIubW0gYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29h L1dLQ3Jhc2hSZXBvcnRlci5tbQppbmRleCBkZGE0ZTJiOWQxNWEzNTNiNTA3MzkyNDAyYzFiNGZl NjI3NmZiM2I3Li5iMWVjZTllMWZhY2QyMTFlNTdmMTE2Y2JjOGM4MTM4OTUwNTMxMjcwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5tbQor KysgYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL2NvY29hL1dLQ3Jhc2hSZXBvcnRlci5tbQpAQCAt MSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE3LTIwMjAgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0zMSw5 ICszMSwxMCBAQAogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAotdm9pZCBzZXRDcmFzaFJlcG9ydEFw cGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihDRlN0cmluZ1JlZiBpbmZvU3RyaW5nKQordm9p ZCBsb2dBbmRTZXRDcmFzaExvZ01lc3NhZ2UoY29uc3QgY2hhciogaW5mb1N0cmluZykKIHsKLSAg ICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZShbKF9fYnJpZGdlIE5TU3RyaW5nICopaW5mb1N0cmlu ZyBVVEY4U3RyaW5nXSk7CisgICAgV1RGTG9nQWx3YXlzKCIlcyIsIGluZm9TdHJpbmcpOworICAg IFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKGluZm9TdHJpbmcpOwogfQogCiB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW0gYi9T b3VyY2UvV2ViS2l0L1NoYXJlZC9Db2NvYS9BdXhpbGlhcnlQcm9jZXNzQ29jb2EubW0KaW5kZXgg ZDllNGJjNjYwMzcyYjEzZDUxOWRlNDBlYmY5M2FjNGIzN2UzZmI4YS4uYmNmYjIwZDdkYmViMWZl OTU5NTQ2MzM5MWZhYjVkMWZhMTIyZGI3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFy ZWQvQ29jb2EvQXV4aWxpYXJ5UHJvY2Vzc0NvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hh cmVkL0NvY29hL0F1eGlsaWFyeVByb2Nlc3NDb2NvYS5tbQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0g KiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTM0LDggKzM0LDEwIEBAIG5h bWVzcGFjZSBXZWJLaXQgewogCiB2b2lkIEF1eGlsaWFyeVByb2Nlc3M6OmRpZFJlY2VpdmVJbnZh bGlkTWVzc2FnZShJUEM6OkNvbm5lY3Rpb24mLCBJUEM6Ok1lc3NhZ2VOYW1lIG1lc3NhZ2VOYW1l KQogewotICAgIHNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0luZm9ybWF0aW9uKChf X2JyaWRnZSBDRlN0cmluZ1JlZilbTlNTdHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIlJlY2VpdmVk IGludmFsaWQgbWVzc2FnZTogJyVzJyAoJWh1KSIsIGRlc2NyaXB0aW9uKG1lc3NhZ2VOYW1lKSwg bWVzc2FnZU5hbWVdKTsKLSAgICBDUkFTSF9XSVRIX0lORk8oc3RhdGljX2Nhc3Q8c3RkOjp1bmRl cmx5aW5nX3R5cGVfdDxJUEM6Ok1lc3NhZ2VOYW1lPj4obWVzc2FnZU5hbWUpKTsKKyAgICBhdXRv IG1lc3NhZ2VOYW1lVmFsdWUgPSBzdGF0aWNfY2FzdDxzdGQ6OnVuZGVybHlpbmdfdHlwZV90PElQ Qzo6TWVzc2FnZU5hbWU+PihtZXNzYWdlTmFtZSk7CisgICAgYXV0byBlcnJvck1lc3NhZ2UgPSBt YWtlU3RyaW5nKCJSZWNlaXZlZCBpbnZhbGlkIG1lc3NhZ2U6ICciLCBkZXNjcmlwdGlvbihtZXNz YWdlTmFtZSksICInICgiLCBtZXNzYWdlTmFtZVZhbHVlLCAnKScpOworICAgIGxvZ0FuZFNldENy YXNoTG9nTWVzc2FnZShlcnJvck1lc3NhZ2UudXRmOCgpLmRhdGEoKSk7CisgICAgQ1JBU0hfV0lU SF9JTkZPKG1lc3NhZ2VOYW1lVmFsdWUpOwogfQogCiBib29sIEF1eGlsaWFyeVByb2Nlc3M6OnBh cmVudFByb2Nlc3NIYXNFbnRpdGxlbWVudChjb25zdCBjaGFyKiBlbnRpdGxlbWVudCkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0VudHJ5UG9pbnRVdGlsaXRpZXMvQ29jb2EvWFBD U2VydmljZS9YUENTZXJ2aWNlTWFpbi5tbSBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL0VudHJ5UG9p bnRVdGlsaXRpZXMvQ29jb2EvWFBDU2VydmljZS9YUENTZXJ2aWNlTWFpbi5tbQppbmRleCA1YTIy ZjVlYjI5ZTY5ZmY1YjIzOWU3NTVmZWM2YTQ4OWZmODI5ZmNkLi5hNzZmNGQ5MDcwZDMwMjA1OGE2 YWVlZDMzMGMzN2U1MjQ2NDExOTE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9F bnRyeVBvaW50VXRpbGl0aWVzL0NvY29hL1hQQ1NlcnZpY2UvWFBDU2VydmljZU1haW4ubW0KKysr IGIvU291cmNlL1dlYktpdC9TaGFyZWQvRW50cnlQb2ludFV0aWxpdGllcy9Db2NvYS9YUENTZXJ2 aWNlL1hQQ1NlcnZpY2VNYWluLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAo QykgMjAxMy0yMDE4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdo dCAoQykgMjAxMy0yMDIwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjQsOSArMjQsOSBAQAogICovCiAKICNpbXBvcnQg ImNvbmZpZy5oIgotI2ltcG9ydCAiV2ViUHJvY2Vzc0NvY29hLmgiCi0jaW1wb3J0ICJYUENTZXJ2 aWNlRW50cnlQb2ludC5oIgogCisjaW1wb3J0ICJXS0NyYXNoUmVwb3J0ZXIuaCIKKyNpbXBvcnQg IlhQQ1NlcnZpY2VFbnRyeVBvaW50LmgiCiAjaW1wb3J0IDxDb3JlRm91bmRhdGlvbi9Db3JlRm91 bmRhdGlvbi5oPgogI2ltcG9ydCA8cGFsL3NwaS9jZi9DRlV0aWxpdGllc1NQSS5oPgogI2ltcG9y dCA8cGFsL3NwaS9jb2NvYS9MYXVuY2hTZXJ2aWNlc1NQSS5oPgpAQCAtMTU2LDggKzE1Niw4IEBA IGludCBYUENTZXJ2aWNlTWFpbihpbnQgYXJnYywgY29uc3QgY2hhcioqIGFyZ3YpCiAgICAgICAg IFN0cmluZyB3ZWJLaXRCdW5kbGVWZXJzaW9uID0geHBjX2RpY3Rpb25hcnlfZ2V0X3N0cmluZyhi b290c3RyYXAuZ2V0KCksICJXZWJLaXRCdW5kbGVWZXJzaW9uIik7CiAgICAgICAgIFN0cmluZyBl eHBlY3RlZEJ1bmRsZVZlcnNpb24gPSBbTlNCdW5kbGUgYnVuZGxlV2l0aElkZW50aWZpZXI6QCJj b20uYXBwbGUuV2ViS2l0Il0uaW5mb0RpY3Rpb25hcnlbKF9fYnJpZGdlIE5TU3RyaW5nICopa0NG QnVuZGxlVmVyc2lvbktleV07CiAgICAgICAgIGlmICghd2ViS2l0QnVuZGxlVmVyc2lvbi5pc051 bGwoKSAmJiAhZXhwZWN0ZWRCdW5kbGVWZXJzaW9uLmlzTnVsbCgpICYmIHdlYktpdEJ1bmRsZVZl cnNpb24gIT0gZXhwZWN0ZWRCdW5kbGVWZXJzaW9uKSB7Ci0gICAgICAgICAgICBXVEZMb2dBbHdh eXMoIldlYktpdCBmcmFtZXdvcmsgdmVyc2lvbiBtaXNtYXRjaDogJXMgIT0gJXMiLCB3ZWJLaXRC dW5kbGVWZXJzaW9uLnV0ZjgoKS5kYXRhKCksIGV4cGVjdGVkQnVuZGxlVmVyc2lvbi51dGY4KCku ZGF0YSgpKTsKLSAgICAgICAgICAgIF9XS1NldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZp Y0luZm9ybWF0aW9uKFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiV2ViS2l0IGZyYW1ld29y ayB2ZXJzaW9uIG1pc21hdGNoOiAnJXMnIiwgd2ViS2l0QnVuZGxlVmVyc2lvbi51dGY4KCkuZGF0 YSgpXSk7CisgICAgICAgICAgICBhdXRvIGVycm9yTWVzc2FnZSA9IG1ha2VTdHJpbmcoIldlYktp dCBmcmFtZXdvcmsgdmVyc2lvbiBtaXNtYXRjaDogIiwgd2ViS2l0QnVuZGxlVmVyc2lvbiwgIiAh PSAiLCBleHBlY3RlZEJ1bmRsZVZlcnNpb24pOworICAgICAgICAgICAgbG9nQW5kU2V0Q3Jhc2hM b2dNZXNzYWdlKGVycm9yTWVzc2FnZS51dGY4KCkuZGF0YSgpKTsKICAgICAgICAgICAgIGNyYXNo RHVlV2ViS2l0RnJhbWV3b3JrVmVyc2lvbk1pc21hdGNoKCk7CiAgICAgICAgIH0KICNlbmRpZgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv aiBiL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg Y2Y0ZjlkNzIxYzE5ZDY4ZDFkMGVhYjU4NDFlMzJhNTliZmNlYjBhNi4uNDIyNmRiNGQ3ZjE4NmNl NGNjNGY3NzU4YjhiM2VhMzQ2OGViMDRhMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJL aXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYktpdC54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xODM2LDcgKzE4MzYsNiBAQAogCQlFNTY4Qjky MjIwQTNBQzZBMDBFM0M4NTYgLyogV2ViRGF0YUxpc3RTdWdnZXN0aW9uc0Ryb3Bkb3duTWFjLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNTY4QjkyMDIw QTNBQzZBMDBFM0M4NTYgLyogV2ViRGF0YUxpc3RTdWdnZXN0aW9uc0Ryb3Bkb3duTWFjLmggKi87 IH07CiAJCUU1QkVGNjgyMjEzMEM0ODAwMEYzMTExMSAvKiBXZWJEYXRhTGlzdFN1Z2dlc3Rpb25z RHJvcGRvd25JT1MuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEU1QkVGNjgwMjEzMEM0N0YwMEYzMTExMSAvKiBXZWJEYXRhTGlzdFN1Z2dlc3Rpb25zRHJv cGRvd25JT1MuaCAqLzsgfTsKIAkJRTVDQjA3REMyMEUxNjc4RjAwMjJDMTgzIC8qIFdLRm9ybUNv bG9yQ29udHJvbC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRTVDQjA3REEyMEUxNjc4RjAwMjJDMTgzIC8qIFdLRm9ybUNvbG9yQ29udHJvbC5oICovOyB9 OwotCQlFQ0E2ODBEODFFNjkwRTI1MDA3MzFEMjAgLyogV2ViUHJvY2Vzc0NvY29hLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFQ0E2ODBENzFFNjkwREY4 MDA3MzFEMjAgLyogV2ViUHJvY2Vzc0NvY29hLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMg PSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRUQ4MkE3RjIxMjhDNkZBRjAwNDQ3N0IzIC8qIFdLQnVu ZGxlUGFnZU92ZXJsYXkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDFBMjJGMEZGMTI4OUZDRDkwMDg1RTc0RiAvKiBXS0J1bmRsZVBhZ2VPdmVybGF5Lmgg Ki87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJRjQwOUJB MTgxRTZFNjRCQzAwOURBMjhFIC8qIFdLRHJhZ0Rlc3RpbmF0aW9uQWN0aW9uLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGNDA5QkExNzFFNkU2NEIzMDA5 REEyOEUgLyogV0tEcmFnRGVzdGluYXRpb25BY3Rpb24uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklC VVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGNDJENjM0MTIyQTBFRkRGMDBEMkZCM0EgLyog V2ViQXV0b2NvcnJlY3Rpb25EYXRhLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGNDJENjMzRjIyQTBFRkQzMDBEMkZCM0EgLyogV2ViQXV0b2NvcnJlY3Rp b25EYXRhLmggKi87IH07CkBAIC01MzcwLDcgKzUzNjksNiBAQAogCQlFNUNCMDdEQTIwRTE2NzhG MDAyMkMxODMgLyogV0tGb3JtQ29sb3JDb250cm9sLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdLRm9ybUNv bG9yQ29udHJvbC5oOyBwYXRoID0gaW9zL2Zvcm1zL1dLRm9ybUNvbG9yQ29udHJvbC5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFNUNCMDdEQjIwRTE2NzhGMDAyMkMxODMgLyogV0tG b3JtQ29sb3JDb250cm9sLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1lID0gV0tGb3JtQ29sb3JDb250 cm9sLm1tOyBwYXRoID0gaW9zL2Zvcm1zL1dLRm9ybUNvbG9yQ29udHJvbC5tbTsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRUNBNjgwRDMxRTY5MDRCNTAwNzMxRDIwIC8qIEV4dHJhUHJp dmF0ZVN5bWJvbHNGb3JUQVBJLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEV4 dHJhUHJpdmF0ZVN5bWJvbHNGb3JUQVBJLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0J CUVDQTY4MEQ3MUU2OTBERjgwMDczMUQyMCAvKiBXZWJQcm9jZXNzQ29jb2EuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gV2ViUHJvY2Vzc0NvY29hLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUVD QkZDMURCMUU2QTRENjYwMDAzMDBDNyAvKiBFeHRyYVB1YmxpY1N5bWJvbHNGb3JUQVBJLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IEV4dHJhUHVibGljU3ltYm9sc0ZvclRBUEkuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJRjAzNjk3ODcxNUY0QkYwNTAwQzNBODBFIC8qIFdlYkNvbG9yUGlja2Vy LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdlYkNvbG9yUGlja2Vy LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRjQwOUJBMTcxRTZFNjRCMzAwOURB MjhFIC8qIFdLRHJhZ0Rlc3RpbmF0aW9uQWN0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFdLRHJhZ0Rlc3RpbmF0aW9uQWN0aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CkBAIC04NDE5LDcgKzg0MTcsNiBAQAogCQkJCTUyRDVBMUIyMUM1NzQ5RjIwMERFMzRB MyAvKiBWaWRlb0Z1bGxzY3JlZW5NYW5hZ2VyLmggKi8sCiAJCQkJNTJENUExQjMxQzU3NDlGMjAw REUzNEEzIC8qIFZpZGVvRnVsbHNjcmVlbk1hbmFnZXIubWVzc2FnZXMuaW4gKi8sCiAJCQkJNTJE NUExQjQxQzU3NDlGMjAwREUzNEEzIC8qIFZpZGVvRnVsbHNjcmVlbk1hbmFnZXIubW0gKi8sCi0J CQkJRUNBNjgwRDcxRTY5MERGODAwNzMxRDIwIC8qIFdlYlByb2Nlc3NDb2NvYS5oICovLAogCQkJ CTdDNkU3MEY5MThCMkQ0QTAwMEYyNEUyRSAvKiBXZWJQcm9jZXNzQ29jb2EubW0gKi8sCiAJCQkp OwogCQkJcGF0aCA9IGNvY29hOwpAQCAtMTEzOTcsNyArMTEzOTQsNiBAQAogCQkJCUJDRDU5OEFD MTEyQjdGREYwMEVDOEMyMyAvKiBXZWJQcmVmZXJlbmNlc1N0b3JlLmggaW4gSGVhZGVycyAqLywK IAkJCQlBMUM1MTJDOTE5MDY1NkU1MDA0NDg5MTQgLyogV2ViUHJldmlld0xvYWRlckNsaWVudC5o IGluIEhlYWRlcnMgKi8sCiAJCQkJQkMwMzJEOTcxMEY0MzdBRjAwNThDMTVBIC8qIFdlYlByb2Nl c3MuaCBpbiBIZWFkZXJzICovLAotCQkJCUVDQTY4MEQ4MUU2OTBFMjUwMDczMUQyMCAvKiBXZWJQ cm9jZXNzQ29jb2EuaCBpbiBIZWFkZXJzICovLAogCQkJCTFBMDQzQTA5MTI0RDExQTkwMEZGQkZC NSAvKiBXZWJQcm9jZXNzQ29ubmVjdGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMUEwNDNGNkEx MjUxNEQ4QjAwRkZCRkI1IC8qIFdlYlByb2Nlc3NDb25uZWN0aW9uTWVzc2FnZXMuaCBpbiBIZWFk ZXJzICovLAogCQkJCUJDMzA2ODI0MTI1QTZCOTQwMEU3MTI3OCAvKiBXZWJQcm9jZXNzQ3JlYXRp b25QYXJhbWV0ZXJzLmggaW4gSGVhZGVycyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EuaCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJv Y2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29jb2EuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggYjc4NWRiNmJhNTA5MTAyYWNlY2ExMTYzZmU2YTJlOTllMWNhNmMwZi4uMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvY29jb2EvV2ViUHJvY2Vzc0NvY29hLmgKKysrIC9kZXYvbnVsbApAQCAtMSwzMiArMCwwIEBA Ci0vKgotICogQ29weXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KLSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCi0gKiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKLSAqIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKLSAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUwotICogQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgotICogQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YKLSAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUwotICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KLSAqIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpCi0gKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCi0gKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCi0gKi8KLQotI3ByYWdtYSBvbmNlCi0KLSNpbmNsdWRlIDxXZWJLaXQvV0tGb3VuZGF0 aW9uLmg+Ci0KLW5hbWVzcGFjZSBXZWJLaXQgewotV0tfRVhURVJOIHZvaWQgX1dLU2V0Q3Jhc2hS ZXBvcnRBcHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oTlNTdHJpbmcgKmluZm9TdHJpbmcp OwotfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dlYlByb2Nl c3NDb2NvYS5tbSBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9jb2NvYS9XZWJQcm9jZXNzQ29j b2EubW0KaW5kZXggYjllNjhmODhkYmYyODVhY2Y4MmJhMWExN2VkMjYyOTI5YjY4ZGNiYS4uZDUy YjRlMTUxZmNhN2NlODQyMmFkZTM0MGQ0OTE3ZTdhMDRmNjZmZSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL2NvY29hL1dlYlByb2Nlc3NDb2NvYS5tbQorKysgYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvY29jb2EvV2ViUHJvY2Vzc0NvY29hLm1tCkBAIC0yNSw3ICsyNSw2 IEBACiAKICNpbXBvcnQgImNvbmZpZy5oIgogI2ltcG9ydCAiV2ViUHJvY2Vzcy5oIgotI2ltcG9y dCAiV2ViUHJvY2Vzc0NvY29hLmgiCiAKICNpbXBvcnQgIkxhdW5jaFNlcnZpY2VzRGF0YWJhc2VN YW5hZ2VyLmgiCiAjaW1wb3J0ICJMYXVuY2hTZXJ2aWNlc0RhdGFiYXNlWFBDQ29uc3RhbnRzLmgi CkBAIC0zOCw3ICszNyw2IEBACiAjaW1wb3J0ICJTYW5kYm94SW5pdGlhbGl6YXRpb25QYXJhbWV0 ZXJzLmgiCiAjaW1wb3J0ICJXS0FQSUNhc3QuaCIKICNpbXBvcnQgIldLQnJvd3NpbmdDb250ZXh0 SGFuZGxlSW50ZXJuYWwuaCIKLSNpbXBvcnQgIldLQ3Jhc2hSZXBvcnRlci5oIgogI2ltcG9ydCAi V0tGdWxsS2V5Ym9hcmRBY2Nlc3NXYXRjaGVyLmgiCiAjaW1wb3J0ICJXS1R5cGVSZWZXcmFwcGVy LmgiCiAjaW1wb3J0ICJXS1dlYlByb2Nlc3NQbHVnSW5Ccm93c2VyQ29udGV4dENvbnRyb2xsZXJJ bnRlcm5hbC5oIgpAQCAtODIxLDEyICs4MTksNiBAQCB2b2lkIFdlYlByb2Nlc3M6OmRlc3Ryb3lS ZW5kZXJpbmdSZXNvdXJjZXMoKQogICAgIFJFTEVBU0VfTE9HX0lGX0FMTE9XRUQoUHJvY2Vzc1N1 c3BlbnNpb24sICJkZXN0cm95UmVuZGVyaW5nUmVzb3VyY2VzOiB0b29rICUuMmZtcyIsIChlbmRU aW1lIC0gc3RhcnRUaW1lKS5taWxsaXNlY29uZHMoKSk7CiB9CiAKLS8vIEZJWE1FOiBUaGlzIHNo b3VsZCBsaXZlIHNvbWV3aGVyZSBlbHNlLCBhbmQgaXQgc2hvdWxkIGhhdmUgdGhlIGltcGxlbWVu dGF0aW9uIGluIGxpbmUgaW5zdGVhZCBvZiBjYWxsaW5nIG91dCB0byBXS1NJLgotdm9pZCBfV0tT ZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbihOU1N0cmluZyAqaW5m b1N0cmluZykKLXsKLSAgICByZXR1cm4gc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNpZmlj SW5mb3JtYXRpb24oKF9fYnJpZGdlIENGU3RyaW5nUmVmKWluZm9TdHJpbmcpOwotfQotCiAjaWYg UExBVEZPUk0oSU9TX0ZBTUlMWSkKIHZvaWQgV2ViUHJvY2Vzczo6YWNjZXNzaWJpbGl0eVByb2Nl c3NTdXNwZW5kZWROb3RpZmljYXRpb24oYm9vbCBzdXNwZW5kZWQpCiB7CmRpZmYgLS1naXQgYS9U b29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOWNjY2UyMTU3MWFkMDQ1MDhm NTcwNjFmNThkMWY5YWNlZGNlMGNkOC4uZmI1MjZjNTY1MmY4MzEwNWZiZmZjMWQ4Nzg4M2E0Yzg5 Y2YzN2M1ZSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDMxIEBACisyMDIwLTA3LTI3ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBh cHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3Bl Y2lmaWNJbmZvcm1hdGlvbigpIHNob3VsZCBhbHNvIGxvZyB0byBXVEZMb2dBbHdheXMoKQorICAg ICAgICA8aHR0cHM6Ly93ZWJraXQub3JnL2IvMjE0NzU2PgorICAgICAgICA8cmRhcjovL3Byb2Js ZW0vNjYwODU3MDU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAg ICAgVGhpcyBhbHNvIG1ha2VzIHRoZSBmb2xsb3dpbmcgY2hhbmdlczoKKyAgICAgICAgLSBSZXBs YWNlcyBfV0tTZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvbigpCisg ICAgICAgICAgd2l0aCBXZWJLaXQ6OnNldENyYXNoUmVwb3J0QXBwbGljYXRpb25TcGVjaWZpY0lu Zm9ybWF0aW9uKCkuCisgICAgICAgIC0gQ2FsbHMgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoKSBp biBEdW1wUmVuZGVyVHJlZSBhbmQKKyAgICAgICAgICBXZWJLaXRUZXN0UnVubmVyIHRvIGF2b2lk IG5ldyBXVEZMb2dBbHdheXMoKSBjYWxscywgd2hpY2gKKyAgICAgICAgICBicm9rZSBpbnRlcm5h bCB0ZXN0cyBhbmQgY2F1c2VkIHRoZSBmaXJzdCBwYXRjaCB0byBiZSByb2xsZWQKKyAgICAgICAg ICBvdXQuCisgICAgICAgIC0gQ2hhbmdlcyBXZWJLaXQ6OnNldENyYXNoUmVwb3J0QXBwbGljYXRp b25TcGVjaWZpY0luZm9ybWF0aW9uKCkKKyAgICAgICAgICB0byB0YWtlIGEgY29uc3QgY2hhciog YXJndW1lbnQgaW5zdGVhZCBvZiBDRlN0cmluZ1JlZi4KKworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbToKKyAgICAgICAgKGNoYW5nZVdpbmRvd1NjYWxlSWZO ZWVkZWQpOgorICAgICAgICAtIERyaXZlLWJ5IGZpeCBmb3IgbWlzc3BlbGxpbmcgaW4gcGFyYW1l dGVyIG5hbWUuCisgICAgICAgIChydW5UZXN0KToKKyAgICAgICAgKiBXZWJLaXRUZXN0UnVubmVy L2NvY29hL0NyYXNoUmVwb3J0ZXJJbmZvLm1tOgorICAgICAgICAoV1RSOjpzZXRDcmFzaFJlcG9y dEFwcGxpY2F0aW9uU3BlY2lmaWNJbmZvcm1hdGlvblRvVVJMKToKKyAgICAgICAgLSBTd2l0Y2gg ZnJvbSBjYWxsaW5nCisgICAgICAgICAgV2ViS2l0OjpzZXRDcmFzaFJlcG9ydEFwcGxpY2F0aW9u U3BlY2lmaWNJbmZvcm1hdGlvbigpIHRvCisgICAgICAgICAgY2FsbGluZyBXVEY6OnNldENyYXNo TG9nTWVzc2FnZSgpIGRpcmVjdGx5LgorCiAyMDIwLTA3LTI2ICBXZW5zb24gSHNpZWggIDx3ZW5z b25faHNpZWhAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04gKHIyNjQ2OTApOiBbIGlP UyB3azIgXSBlZGl0aW5nL3NlbGVjdGlvbi9zaGlmdC1jbGljay1pbmNsdWRlcy1leGlzdGluZy1z ZWxlY3Rpb24uaHRtbCBpcyBhIGZsYWt5IGZhaWx1cmUKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCA4N2MwNGQ5MmZhNGNlNDcyMjE2ZThjMzhmYmVlOWJi ZjcxYTMyZDk5Li4xYjhiNjliYzdiOTYwOTJmMTU5NzZhMjkwMjA4MDI3NTE3NmRmNWE2IDEwMDY0 NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC02NSw3ICs2NSw2 IEBACiAjaW1wb3J0IDxXZWJLaXQvRE9NRWxlbWVudC5oPgogI2ltcG9ydCA8V2ViS2l0L0RPTUV4 dGVuc2lvbnMuaD4KICNpbXBvcnQgPFdlYktpdC9ET01SYW5nZS5oPgotI2ltcG9ydCA8V2ViS2l0 L1dLQ3Jhc2hSZXBvcnRlci5oPgogI2ltcG9ydCA8V2ViS2l0L1dLUmV0YWluUHRyLmg+CiAjaW1w b3J0IDxXZWJLaXQvV0tTdHJpbmcuaD4KICNpbXBvcnQgPFdlYktpdC9XS1N0cmluZ0NGLmg+CkBA IC05OSw2ICs5OCw3IEBACiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CiAjaW1wb3J0IDx3dGYv VGhyZWFkaW5nLmg+CiAjaW1wb3J0IDx3dGYvVW5pcXVlQXJyYXkuaD4KKyNpbXBvcnQgPHd0Zi9j b2NvYS9DcmFzaFJlcG9ydGVyLmg+CiAjaW1wb3J0IDx3dGYvY29jb2EvVmVjdG9yQ29jb2EuaD4K ICNpbXBvcnQgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KICNpbXBvcnQgPHd0Zi90ZXh0L1dU RlN0cmluZy5oPgpAQCAtMTY0NSw5ICsxNjQ1LDkgQEAgc3RhdGljIHZvaWQgZHVtcEJhY2tGb3J3 YXJkTGlzdEZvcldlYlZpZXcoV2ViVmlldyAqdmlldykKIH0KIAogI2lmICFQTEFURk9STShJT1Nf RkFNSUxZKQotc3RhdGljIHZvaWQgY2hhbmdlV2luZG93U2NhbGVJZk5lZWRlZChjb25zdCBjaGFy KiB0ZXN0UGF0aE9yVVIpCitzdGF0aWMgdm9pZCBjaGFuZ2VXaW5kb3dTY2FsZUlmTmVlZGVkKGNv bnN0IGNoYXIqIHRlc3RQYXRoT3JVcmwpCiB7Ci0gICAgV1RGOjpTdHJpbmcgbG9jYWxQYXRoT3JV cmwgPSBTdHJpbmcodGVzdFBhdGhPclVSKTsKKyAgICBhdXRvIGxvY2FsUGF0aE9yVXJsID0gU3Ry aW5nKHRlc3RQYXRoT3JVcmwpOwogICAgIGZsb2F0IGN1cnJlbnRTY2FsZUZhY3RvciA9IFtbW21h aW5GcmFtZSB3ZWJWaWV3XSB3aW5kb3ddIGJhY2tpbmdTY2FsZUZhY3Rvcl07CiAgICAgZmxvYXQg cmVxdWlyZWRTY2FsZUZhY3RvciA9IDE7CiAgICAgaWYgKGxvY2FsUGF0aE9yVXJsLmNvbnRhaW5z SWdub3JpbmdBU0NJSUNhc2UoIi9oaWRwaS0zeC0iKSkKQEAgLTIwMzEsOCArMjAzMSw4IEBAIHN0 YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5nJiBpbnB1dExpbmUpCiAgICAgaWYgKCF0ZXN0 UGF0aCkKICAgICAgICAgdGVzdFBhdGggPSBbdXJsIGFic29sdXRlU3RyaW5nXTsKIAotICAgIE5T U3RyaW5nICppbmZvcm1hdGlvblN0cmluZyA9IFtAIkNSQVNISU5HIFRFU1Q6ICIgc3RyaW5nQnlB cHBlbmRpbmdTdHJpbmc6dGVzdFBhdGhdOwotICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRBcHBs aWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24oKF9fYnJpZGdlIENGU3RyaW5nUmVmKWluZm9ybWF0 aW9uU3RyaW5nKTsKKyAgICBhdXRvIG1lc3NhZ2UgPSBtYWtlU3RyaW5nKCJDUkFTSElORyBURVNU OiAiLCB0ZXN0UGF0aC5VVEY4U3RyaW5nKTsKKyAgICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZSht ZXNzYWdlLnV0ZjgoKS5kYXRhKCkpOwogCiAgICAgVGVzdE9wdGlvbnMgb3B0aW9ucyB7IFt1cmwg aXNGaWxlVVJMXSA/IFt1cmwgZmlsZVN5c3RlbVJlcHJlc2VudGF0aW9uXSA6IHBhdGhPclVSTCwg Y29tbWFuZC5hYnNvbHV0ZVBhdGggfTsKIApkaWZmIC0tZ2l0IGEvVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9jb2NvYS9DcmFzaFJlcG9ydGVySW5mby5tbSBiL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIv Y29jb2EvQ3Jhc2hSZXBvcnRlckluZm8ubW0KaW5kZXggZTIyZDExZGE5YWIyZjM2MDRkMGE3OWUx MDM2NDUxMWYzYmE4MzE0My4uNGM3OWFiNWI4NWQ2NDE4OWE3ZTBhMjk2ZWVhOTBjMWQ4MTE4ZGMz ZCAxMDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9jb2NvYS9DcmFzaFJlcG9ydGVy SW5mby5tbQorKysgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL2NvY29hL0NyYXNoUmVwb3J0ZXJJ bmZvLm1tCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTQtMjAyMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKQEAgLTI3LDkgKzI3LDkgQEAKICNpbXBvcnQgIkNyYXNoUmVwb3J0ZXJJbmZvLmgiCiAKICNp bXBvcnQgIlN0cmluZ0Z1bmN0aW9ucy5oIgotI2ltcG9ydCA8V2ViS2l0L1dLQ3Jhc2hSZXBvcnRl ci5oPgogI2ltcG9ydCA8V2ViS2l0L1dLVVJMQ0YuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIu aD4KKyNpbXBvcnQgPHd0Zi9jb2NvYS9DcmFzaFJlcG9ydGVyLmg+CiAKIG5hbWVzcGFjZSBXVFIg ewogCkBAIC02OSw5ICs2OSw4IEBAIHZvaWQgc2V0Q3Jhc2hSZXBvcnRBcHBsaWNhdGlvblNwZWNp ZmljSW5mb3JtYXRpb25Ub1VSTChXS1VSTFJlZiB1cmwpCiB7CiAgICAgU3RyaW5nIHRlc3RQYXRo ID0gdGVzdFBhdGhGcm9tVVJMKHVybCk7CiAgICAgaWYgKCF0ZXN0UGF0aC5pc051bGwoKSkgewot ICAgICAgICBTdHJpbmcgbWVzc2FnZSgiQ1JBU0hJTkcgVEVTVDogIik7Ci0gICAgICAgIG1lc3Nh Z2UgPSBtZXNzYWdlICsgdGVzdFBhdGg7Ci0gICAgICAgIFdlYktpdDo6c2V0Q3Jhc2hSZXBvcnRB cHBsaWNhdGlvblNwZWNpZmljSW5mb3JtYXRpb24obWVzc2FnZS5jcmVhdGVDRlN0cmluZygpLmdl dCgpKTsKKyAgICAgICAgYXV0byBtZXNzYWdlID0gbWFrZVN0cmluZygiQ1JBU0hJTkcgVEVTVDog IiwgdGVzdFBhdGgpOworICAgICAgICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZShtZXNzYWdlLnV0 ZjgoKS5kYXRhKCkpOwogICAgIH0KIH0KIAo=