209236 2020-03-18 08:55:11 -0700 REGRESSION(r249808): [GTK] Crash in JSC Config::permanentlyFreeze() on architecture ppc64el 2020-04-29 09:04:00 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=201597 https://bugs.webkit.org/show_bug.cgi?id=209360 https://bugzilla.redhat.com/show_bug.cgi?id=1816527 https://bugzilla.redhat.com/show_bug.cgi?id=1817959 https://bugs.webkit.org/show_bug.cgi?id=209670 https://bugs.webkit.org/show_bug.cgi?id=210685 InRadar P2 Normal --- 209670 1 seb128 mcatanzaro adamw benjamin berto bugs-noreply cdumez clopez cmarcelo dkg ews-watchlist fpizlo guijemont keith_miller mark.lam mcatanzaro mike msaboff saam tibor.pacaj2 ticaiolima tpopela tzagallo webkit-bug-importer ysuzuki zan oldest_to_newest 1631176 0 393861 seb128 2020-03-18 08:55:11 -0700 Created attachment 393861 small script testcase Unsure what useful information to provide but the webkit2gtk 2.26 -> 2.28 upgrade is blocked in Ubuntu because some reverse depends tests fail on s390x/ppc64el Trying a simple python webkitgtk script, using 2.26 the webpage loads fine but 2.28 gives an empty view... Any hint on how to debug would be useful since that blocks the new serie to make it to the current Ubuntu serie 1631199 1 seb128 2020-03-18 09:31:09 -0700 The MiniBrowser provided by webkitgtk has the same issue 1631205 2 clopez 2020-03-18 09:46:24 -0700 (In reply to seb128 from comment #1) > The MiniBrowser provided by webkitgtk has the same issue Can you try running the script after exporting the environment variable WEBKIT_DISABLE_COMPOSITING_MODE=1 ? and with the environment variable JavaScriptCoreUseJIT=0 ? does any of it help? 1631269 3 seb128 2020-03-18 11:25:25 -0700 WEBKIT_DISABLE_COMPOSITING_MODE=1 doesn't seem to make a difference 1631272 4 mcatanzaro 2020-03-18 11:33:32 -0700 BTW we know JavaScriptCore tests on both of these architectures started failing sometime between 2.26 and 2.28, so wouldn't surprise me if they're totally busted. I have pending to bisect the issues and then report bugs, but no promises as to when. * ppc64le is special because it uses large page sizes (and different sizes on different distros!) * s390x is special because it's big endian Ideally, we would set up JSCOnly EWS for these architectures, but due to the nature of the architectures, that's not likely going to be easy, especially for s390x. 1631275 5 mcatanzaro 2020-03-18 11:37:51 -0700 (In reply to Michael Catanzaro from comment #4) > BTW we know JavaScriptCore tests on both of these architectures started > failing sometime between 2.26 and 2.28, so wouldn't surprise me if they're > totally busted. (Separate issues, btw, because of course it would be too easy for there to be just one problem for both arches. ;) 1631278 6 mcatanzaro 2020-03-18 11:48:34 -0700 (In reply to Carlos Alberto Lopez Perez from comment #2) > and with the environment variable JavaScriptCoreUseJIT=0 ? does any of it help? Hopefully that should not make any difference, because these arches should both be using cloop. 1631325 7 seb128 2020-03-18 13:18:44 -0700 One of the test failing is ruby-gnome's webkit test unit https://salsa.debian.org/ruby-team/ruby-gnome/-/blob/master/webkit2-gtk/test/run-test.rb The Ubuntu package calls it under xvfb. It makes a bit easier to test for the issue/regression from a command line only environment. I confirmed the issues on a graphical environment by using ssh -X to a porter box 1631326 8 seb128 2020-03-18 13:21:12 -0700 Sorry, I overlooked earlier than you asked also about JavaScriptCoreUseJIT=0 ... that doesn't make a difference either 1631331 9 clopez 2020-03-18 13:25:32 -0700 If your test case, can you see a a process named WebKitWebProcess still alive after several seconds (let's say: 1 minute after loading the test) or does this process dies? 1631333 10 seb128 2020-03-18 13:30:35 -0700 > If your test case, can you see a a process named WebKitWebProcess still alive after several seconds No, that process goes away a few seconds after the view is opened 1631335 11 seb128 2020-03-18 13:31:52 -0700 attaching with gdb, it gives Thread 1 "WebKitWebProces" received signal SIGABRT, Aborted. 0x000078724d300468 in __libc_signal_restore_set (set=0x7ffffda70cb8) at ../sysdeps/unix/sysv/linux/internal-signals.h:86 86 ../sysdeps/unix/sysv/linux/internal-signals.h: No such file or directory. (gdb) bt #0 0x000078724d300468 in __libc_signal_restore_set (set=0x7ffffda70cb8) at ../sysdeps/unix/sysv/linux/internal-signals.h:86 #1 __GI_raise (sig=<optimized out>) at ../sysdeps/unix/sysv/linux/raise.c:48 #2 0x000078724d2d7cd0 in __GI_abort () at abort.c:79 #3 0x000078724b27eed4 in JSC::Config::permanentlyFreeze() () at /lib/powerpc64le-linux-gnu/libjavascriptcoregtk-4.0.so.18 #4 0x000078724b4b0fd0 in JSC::VM::VM(JSC::VM::VMType, JSC::HeapType) () at /lib/powerpc64le-linux-gnu/libjavascriptcoregtk-4.0.so.18 #5 0x000078724b4b2ad4 in JSC::VM::create(JSC::HeapType) () I will try to install debug symbols 1631338 12 clopez 2020-03-18 13:36:26 -0700 (In reply to seb128 from comment #10) > > If your test case, can you see a a process named WebKitWebProcess still alive after several seconds > > No, that process goes away a few seconds after the view is opened great.. we have to know why it dies. Don't attach gdb to it, just enable core generation by running "ulimit -c unlimited", then run your test case and wait until it dies and finishes writting the core file (can take a while). Then generate a backtrace from the core file with this command. gdb --batch -ex "thread apply all bt full" /path/to/WebKitWebProcess core &> core_backtrace.txt and upload here the txt file. btw: install the dbg-sym packages before genearating the backtrace 1631341 13 393897 seb128 2020-03-18 13:42:25 -0700 Created attachment 393897 gdb Using gdb on the process should be the same no? the ulimit/core doesn't work, probably because of apport Anyway, I got one with gdb on the process, attaching the file now, let me know if I should better try your suggested way for some reason 1631343 14 seb128 2020-03-18 13:45:13 -0700 in fact apport collected the dump, using gdb on it gives the same stacktrace that it does on the process 1631350 15 clopez 2020-03-18 13:57:04 -0700 So its crashing here: #3 0x0000705dcc8beed4 in CRASH_WITH_INFO(...) () at DerivedSources/ForwardingHeaders/wtf/Assertions.h:660 #4 JSC::Config::permanentlyFreeze() () at ../Source/JavaScriptCore/runtime/JSCConfig.cpp:78 #5 0x0000705dccaf0fd0 in JSC::VM::VM(JSC::VM::VMType, JSC::HeapType) () at ../Source/JavaScriptCore/runtime/VM.cpp:586 #6 0x0000705dccaf2ad4 in JSC::VM::create(JSC::HeapType) () at ../Source/JavaScriptCore/runtime/VM.cpp:703 #7 0x0000705dd06d0b48 in WebCore::commonVMSlow() () at ../Source/WebCore/bindings/js/CommonVM.cpp:55 #8 0x0000705dd0e9fe74 in WebCore::commonVM() () at ../Source/WebCore/bindings/js/CommonVM.h:52 #9 WebCore::PageScriptDebugServer::PageScriptDebugServer(WebCore::Page&) () at ../Source/WebCore/inspector/PageScriptDebugServer.cpp:58 #10 0x0000705dd0e87548 in WebCore::InspectorController::InspectorController(WebCore::Page&, WebCore::InspectorClient*) () at ../Source/WebCore/inspector/InspectorController.cpp:105 #11 0x0000705dd116e254 in std::make_unique<WebCore::InspectorController, WebCore::Page&, WebCore::InspectorClient*&>(WebCore::Page&, WebCore::InspectorClient*&) () at /usr/include/c++/9/bits/unique_ptr.h:857 #12 WTF::makeUnique<WebCore::InspectorController, WebCore::Page&, WebCore::InspectorClient*&>(WebCore::Page&, WebCore::InspectorClient*&) () at DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:483 #13 WebCore::Page::Page(WebCore::PageConfiguration&&) () at ../Source/WebCore/page/Page.cpp:279 #14 0x0000705dcfbdf4f8 in std::make_unique<WebCore::Page, WebCore::PageConfiguration>(WebCore::PageConfiguration&&) () at /usr/include/c++/9/bits/unique_ptr.h:857 #15 WTF::makeUnique<WebCore::Page, WebCore::PageConfiguration>(WebCore::PageConfiguration&&) () at DerivedSources/ForwardingHeaders/wtf/StdLibExtras.h:483 #16 WebKit::WebPage::WebPage(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&) () at ../Source/WebKit/WebProcess/WebPage/WebPage.cpp:536 #17 0x0000705dcfbe0254 in WebKit::WebPage::create(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&) () at ../Source/WebKit/WebProcess/WebPage/WebPage.cpp:379 #18 0x0000705dcf994ad8 in WebKit::WebProcess::createWebPage(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&) () at ../Source/WebKit/WebProcess/WebProcess.cpp:685 #19 0x0000705dcf434e08 in IPC::callMemberFunctionImpl<WebKit::WebProcess, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&), std::tuple<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters>, 0ul, 1ul>(WebKit::WebProcess*, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&), std::tuple<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters>&&, std::integer_sequence<unsigned long, 0ul, 1ul>) () at ../Source/WebKit/Platform/IPC/HandleMessage.h:41 #20 IPC::callMemberFunction<WebKit::WebProcess, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&), std::tuple<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters>, std::integer_sequence<unsigned long, 0ul, 1ul> >(std::tuple<WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters>&&, WebKit::WebProcess*, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&)) () at ../Source/WebKit/Platform/IPC/HandleMessage.h:47 #21 IPC::handleMessage<Messages::WebProcess::CreateWebPage, WebKit::WebProcess, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&)>(IPC::Decoder&, WebKit::WebProcess*, void (WebKit::WebProcess::*)(WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebKit::WebPageCreationParameters&&)) () at ../Source/WebKit/Platform/IPC/HandleMessage.h:120 #22 0x0000705dcf42ab14 in WebKit::WebProcess::didReceiveWebProcessMessage(IPC::Connection&, IPC::Decoder&) () at DerivedSources/WebKit/WebProcessMessageReceiver.cpp:291 #23 0x0000705dcf99ce1c in WebKit::WebProcess::didReceiveMessage(IPC::Connection&, IPC::Decoder&) () at ../Source/WebKit/WebProcess/WebProcess.cpp:750 #24 WebKit::WebProcess::didReceiveMessage(IPC::Connection&, IPC::Decoder&) () at ../Source/WebKit/WebProcess/WebProcess.cpp:744 #25 0x0000705dcf5f1298 in IPC::Connection::dispatchMessage(IPC::Decoder&) () at ../Source/WebKit/Platform/IPC/Connection.cpp:1008 #26 0x0000705dcf5f3014 in IPC::Connection::dispatchMessage(std::unique_ptr<IPC::Decoder, std::default_delete<IPC::Decoder> >) () at ../Source/WebKit/Platform/IPC/Connection.cpp:1077 #27 0x0000705dcf5f39e4 in IPC::Connection::dispatchOneIncomingMessage() () at ../Source/WebKit/Platform/IPC/Connection.cpp:1146 #28 0x0000705dcf5f3f34 in operator() () at ../Source/WebKit/Platform/IPC/Connection.cpp:985 #29 call() () at DerivedSources/ForwardingHeaders/wtf/Function.h:52 #30 0x0000705dccbc26f8 in WTF::Function<void ()>::operator()() const () at ../Source/WTF/wtf/Function.h:84 #31 WTF::RunLoop::performWork() () at ../Source/WTF/wtf/RunLoop.cpp:124 #32 0x0000705dccc3e5e8 in operator() () at ../Source/WTF/wtf/glib/RunLoopGLib.cpp:68 #33 _FUN() () at ../Source/WTF/wtf/glib/RunLoopGLib.cpp:70 #34 0x0000705dccc3e670 in operator() () at ../Source/WTF/wtf/glib/RunLoopGLib.cpp:45 #35 _FUN() () at ../Source/WTF/wtf/glib/RunLoopGLib.cpp:46 #36 0x0000705dcd4c5d14 in g_main_context_dispatch () at /lib/powerpc64le-linux-gnu/libglib-2.0.so.0 #37 0x0000705dcd4c6258 in () at /lib/powerpc64le-linux-gnu/libglib-2.0.so.0 #38 0x0000705dcd4c67bc in g_main_loop_run () at /lib/powerpc64le-linux-gnu/libglib-2.0.so.0 #39 0x0000705dccc3f8a4 in WTF::RunLoop::run() () at ../Source/WTF/wtf/glib/RunLoopGLib.cpp:96 #40 0x0000705dcfc17d24 in WebKit::AuxiliaryProcessMain<WebKit::WebProcess, WebKit::WebProcessMainGtk>(int, char**) () at ../Source/WebKit/Shared/AuxiliaryProcessMain.h:68 #41 WebKit::WebProcessMain(int, char**) () at ../Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:68 #42 0x000003e4f4b607c0 in main() () at ../Source/WebKit/WebProcess/EntryPoint/unix/WebProcessMain.cpp:45 Which translates to crashing in the RELEASE_ASSERT of line 78: ebkitgtk-2.28.0 $ cat -n Source/JavaScriptCore/runtime/JSCConfig.cpp|tail -30 53 54 void Config::permanentlyFreeze() 55 { 56 #if PLATFORM(COCOA) 57 RELEASE_ASSERT(roundUpToMultipleOf(vmPageSize(), ConfigSizeToProtect) == ConfigSizeToProtect); 58 #endif 59 60 if (!g_jscConfig.isPermanentlyFrozen) 61 g_jscConfig.isPermanentlyFrozen = true; 62 63 int result = 0; 64 #if OS(DARWIN) 65 enum { 66 AllowPermissionChangesAfterThis = false, 67 DisallowPermissionChangesAfterThis = true 68 }; 69 70 // There's no going back now! 71 result = vm_protect(mach_task_self(), reinterpret_cast<vm_address_t>(&g_jscConfig), ConfigSizeToProtect, DisallowPermissionChangesAfterThis, VM_PROT_READ); 72 #elif OS(LINUX) 73 result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); 74 #elif OS(WINDOWS) 75 // FIXME: Implement equivalent, maybe with VirtualProtect. 76 // Also need to fix WebKitTestRunner. 77 #endif 78 RELEASE_ASSERT(!result); // <--- HERE IT CRASHES 79 RELEASE_ASSERT(g_jscConfig.isPermanentlyFrozen); 80 } 81 82 } // namespace JSC 1631351 16 clopez 2020-03-18 14:01:49 -0700 That code crashing was added on r249808 1631354 17 mark.lam 2020-03-18 14:10:48 -0700 (In reply to Carlos Alberto Lopez Perez from comment #16) > That code crashing was added on r249808 This crash means that ppc64el/s390x is lacking this support. If you don't want the feature, you can add an #elif for that platform and make this a no-op for it. Alternatively, you can implement the support. 1631365 18 clopez 2020-03-18 14:38:45 -0700 (In reply to Mark Lam from comment #17) > (In reply to Carlos Alberto Lopez Perez from comment #16) > > That code crashing was added on r249808 > > This crash means that ppc64el/s390x is lacking this support. Do you mean it lacks support for mprotect() with PROT_READ ? >If you don't want the feature, you can add an #elif for that platform and make this a no-op for it. Alternatively, you can implement the support. Making it a no-op for this architectures seems fine to me. @seb128: can you test if this patch fixes the issue? diff --git a/Source/JavaScriptCore/runtime/JSCConfig.cpp b/Source/JavaScriptCore/runtime/JSCConfig.cpp index 01e0e63..9c57da8 100644 --- a/Source/JavaScriptCore/runtime/JSCConfig.cpp +++ b/Source/JavaScriptCore/runtime/JSCConfig.cpp @@ -70,6 +70,7 @@ void Config::permanentlyFreeze() // There's no going back now! result = vm_protect(mach_task_self(), reinterpret_cast<vm_address_t>(&g_jscConfig), ConfigSizeToProtect, DisallowPermissionChangesAfterThis, VM_PROT_READ); #elif OS(LINUX) + return; result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); #elif OS(WINDOWS) // FIXME: Implement equivalent, maybe with VirtualProtect. And if it does can you let me know which one its the value of CMAKE_SYSTEM_PROCESSOR for s390x? you can find this by grepping on the build directory for this string. And other question: does this only affect ppc64el or also ppc64 and ppc? 1631367 19 clopez 2020-03-18 14:42:27 -0700 (In reply to Carlos Alberto Lopez Perez from comment #18) > And if it does can you let me know which one its the value of > CMAKE_SYSTEM_PROCESSOR for s390x? you can find this by grepping on the build > directory for this string. > Also upload here a txt file with the output of the command "echo | gcc -E -dM -" on s390x 1631412 20 mcatanzaro 2020-03-18 16:37:36 -0700 Sebastien, you told me there was no crash. :( A crash makes everything way easier! (In reply to Carlos Alberto Lopez Perez from comment #18) > Do you mean it lacks support for mprotect() with PROT_READ ? errno is set on failure, so WebKit should check errno and print a proper error using strerror(errno) to give us an idea of what's going wrong. But I'm pretty sure it's going to be EINVAL. Look: EINVAL addr is not a valid pointer, or not a multiple of the system page size. And I see we have in JSCConfig.h: #if !OS(WINDOWS) constexpr size_t ConfigSizeToProtect = 16 * KB; #else constexpr size_t ConfigSizeToProtect = 4 * KB; #endif which is definitely incorrect. This is reminiscent of bug #182923, fixed in r232909. Note that in that revision, the task was to find a block size that was *at least as big* as the actual page size, so it was not a precise fix: we just guessed 64 KB was big enough for strange architectures without attempting to be precise about it. Hopefully the same approach would work here? I'm not sure where to find correct pages sizes to assume. Looking at an internal email that doesn't cite any sources, it looks like s390x uses 4 KB pages, ppc64le uses 64 KB pages on RHEL but 4 KB on various other distros (would be too easy otherwise!), aarch64 uses 64 KB pages... though aarch64 is getting 16 KB block sizes in MarkedBlock.h without crashing, because we have CPU(ARM64) so it shouldn't be CPU(UNKNOWN). And afaik all of the above can be changed at kernel compile time, so we just hope by convention that it's the same on all distros, except ppc64le where we know it isn't. So conclusion: ????????? The best solution is to get page size at runtime using sysconf(_SC_PAGESIZE), but it looks like the code really wants a compile-time solution. So maybe just hardcode 64 KB for these CPUs and for CPU(UNKNOWN)? Ideally we would share the value with MarkedBlock.h? clopez, what do you think? Anyway, Sebastien, try changing ConfigSizeToProtect to 64 * KB and see if that works. My guess is that will fix ppc64le, but something somewhere else will be broken for s390x. P.S. You know if Debian and Red Hat can't agree on whether to spell ppc64le or ppc64el, we definitely won't be able to agree on page size. :P It looks like Debian distros are saying ppc64el while Red Hat and SUSE say ppc64le. Whatever.... 1631433 21 mcatanzaro 2020-03-18 17:08:31 -0700 (In reply to Carlos Alberto Lopez Perez from comment #18) > And other question: does this only affect ppc64el or also ppc64 and ppc? (Looks like neither Debian nor Red Hat supports ppc64 or ppc anymore, so it probably doesn't matter much.) 1631449 22 mark.lam 2020-03-18 17:45:37 -0700 (In reply to Michael Catanzaro from comment #20) > Sebastien, you told me there was no crash. :( A crash makes everything way > easier! > > (In reply to Carlos Alberto Lopez Perez from comment #18) > > Do you mean it lacks support for mprotect() with PROT_READ ? > > errno is set on failure, so WebKit should check errno and print a proper > error using strerror(errno) to give us an idea of what's going wrong. But > I'm pretty sure it's going to be EINVAL. Look: > > EINVAL addr is not a valid pointer, or not a multiple of the system > page size. > > And I see we have in JSCConfig.h: > > #if !OS(WINDOWS) > constexpr size_t ConfigSizeToProtect = 16 * KB; > #else > constexpr size_t ConfigSizeToProtect = 4 * KB; > #endif > > which is definitely incorrect. This is reminiscent of bug #182923, fixed in > r232909. Note that in that revision, the task was to find a block size that > was *at least as big* as the actual page size, so it was not a precise fix: > we just guessed 64 KB was big enough for strange architectures without > attempting to be precise about it. Hopefully the same approach would work > here? I was surprised that this could be the issue because there's an assert in Config::permanentlyFreeze() that ensures that ConfigSizeToProtect is an integral multiple of page size. However, checking the code, I see: #if PLATFORM(COCOA) RELEASE_ASSERT(roundUpToMultipleOf(vmPageSize(), ConfigSizeToProtect) == ConfigSizeToProtect); #endif It's a pity that vmPageSize() is not available on non-cocoa ports, or this issue would be more clearly identified. 1631474 23 mcatanzaro 2020-03-18 18:26:47 -0700 (In reply to Mark Lam from comment #22) > It's a pity that vmPageSize() is not available on non-cocoa ports, or this > issue would be more clearly identified. Looks like everything in ResourceUsage.h is guarded by #if PLATFORM(COCOA). At least vmPageSize() would be very easy to implement. The Cocoa impl is: size_t vmPageSize() { #if PLATFORM(IOS_FAMILY) return vm_kernel_page_size; #else static size_t cached = sysconf(_SC_PAGESIZE); return cached; #endif } The Linux impl would be 100% identical to the non-IOS_FAMILY path there. Just needs to return sysconf(_SC_PAGESIZE). There's also _SC_PAGE_SIZE, which is a synonym. Both of these are specified by POSIX.1, so they should work on every Unix, not just Linux. 1631559 24 tpopela 2020-03-19 00:23:54 -0700 (In reply to Michael Catanzaro from comment #20) > I'm not sure where to find correct pages sizes to assume. Looking at an > internal email that doesn't cite any sources, it looks like s390x uses 4 KB > pages, ppc64le uses 64 KB pages on RHEL but 4 KB on various other distros > (would be too easy otherwise!), aarch64 uses 64 KB pages... Some correction: s390x, ppc64(le) in RHEL and Fedora use 64 KB page size aarch64 on RHEL uses 64 KB and on Fedora 4 KB page size 1631563 25 seb128 2020-03-19 01:02:58 -0700 > @seb128: can you test if this patch fixes the issue? @Carlos, your return patch does fix the issue indeed! > And if it does can you let me know which one its the value of > CMAKE_SYSTEM_PROCESSOR for s390x? you can find this by grepping > on the build directory for this string. CMakeFiles/3.16.3/CMakeSystem.cmake:set(CMAKE_SYSTEM_PROCESSOR "s390x") > And other question: does this only affect ppc64el or also ppc64 and ppc? Ubuntu also provides the first variant and Debian doesn't run its tests on those archs so I can't easily say > Sebastien, you told me there was no crash. :( A crash makes everything way easier! @Michael, sorry about that, the small script doesn't print anything on stdout/stderr and neither does MiniBrowser. Since the UI was still open and no eror was printer I assumed there was no crash, I didn't know there was a background rendering process that could crash like this (I should have checked the apport directory but since it's in a remote server I didn't get notified about that either) 1631564 26 seb128 2020-03-19 01:07:43 -0700 I just tested on s390x and the rendering in fact works there, we have some autopkgtest failures but they seem different from the issue described on this bug. I've updated the title now to mention only ppc64el now Sorry if that created confusion or extra work 1631580 27 seb128 2020-03-19 02:18:18 -0700 > Anyway, Sebastien, try changing ConfigSizeToProtect to 64 * KB and see if > that works. My guess is that will fix ppc64le, but something somewhere > else will be broken for s390x. The change seems to resolve the issue on ppc indeed, and as stated in the previous comment we can ignore s390x now 1631670 28 mcatanzaro 2020-03-19 09:06:08 -0700 (In reply to Tomas Popela from comment #24) > Some correction: > > s390x, ppc64(le) in RHEL and Fedora use 64 KB page size > aarch64 on RHEL uses 64 KB and on Fedora 4 KB page size That makes a *lot* more sense than the mail I was looking at. In that case, aarch64 must be broken on RHEL for a while now, because MarkedBlock.h uses 16 KB block size on that architecture. 1631677 29 mcatanzaro 2020-03-19 09:25:49 -0700 (In reply to Michael Catanzaro from comment #28) > In that case, aarch64 must be broken on RHEL for a while now, because > MarkedBlock.h uses 16 KB block size on that architecture. Tomas pointed me to a downstream patch: diff --git a/Source/JavaScriptCore/heap/MarkedBlock.h b/Source/JavaScriptCore/heap/MarkedBlock.h index e240f0ae..6bf88692 100644 --- a/Source/JavaScriptCore/heap/MarkedBlock.h +++ b/Source/JavaScriptCore/heap/MarkedBlock.h @@ -68,7 +68,7 @@ public: static constexpr size_t atomSize = 16; // bytes // Block size must be at least as large as the system page size. -#if CPU(PPC64) || CPU(PPC64LE) || CPU(PPC) || CPU(UNKNOWN) +#if CPU(PPC64) || CPU(PPC64LE) || CPU(PPC) || CPU(ARM64) || CPU(UNKNOWN) static constexpr size_t blockSize = 64 * KB; #else static constexpr size_t blockSize = 16 * KB; 1631703 30 mcatanzaro 2020-03-19 10:07:33 -0700 Hey Mark, how was ConfigSizeToProtect chosen? #if !OS(WINDOWS) constexpr size_t ConfigSizeToProtect = 16 * KB; #else constexpr size_t ConfigSizeToProtect = 4 * KB; #endif Is it supposed to match page size (in which case most Linux architectures should be using 4 KB rather than 16 KB)? Or is it desired to be exactly 16 KB everywhere regardless of page size unless page size is bigger than 16 KB? Why is Windows using 4 KB while everything else uses 16 KB? Same question applies to the blockSize in MarkedBlock.h. In that case, the code is a bit more clear, and I guess the desired block size is min(16 KB, page size)? 1631707 31 mcatanzaro 2020-03-19 10:09:42 -0700 Seb, here's your workaround patch for Ubuntu, which should be safe until we figure out a proper upstream fix. It maintains the current behavior except on architectures that are already likely broken: diff --git a/Source/JavaScriptCore/runtime/JSCConfig.h b/Source/JavaScriptCore/runtime/JSCConfig.h index 1ae53a56431a..ec67610057b8 100644 --- a/Source/JavaScriptCore/runtime/JSCConfig.h +++ b/Source/JavaScriptCore/runtime/JSCConfig.h @@ -34,10 +34,12 @@ class ExecutableAllocator; class FixedVMPoolExecutableAllocator; class VM; -#if !OS(WINDOWS) -constexpr size_t ConfigSizeToProtect = 16 * KB; -#else +#if OS(WINDOWS) constexpr size_t ConfigSizeToProtect = 4 * KB; +#elif CPU(PPC64) || CPU(PPC64LE) || CPU(PPC) || CPU(UNKNOWN) +constexpr size_t ConfigSizeToProtect = 64 * KB; +#else +constexpr size_t ConfigSizeToProtect = 16 * KB; #endif #if ENABLE(SEPARATED_WX_HEAP) 1631710 32 mark.lam 2020-03-19 10:14:58 -0700 (In reply to Michael Catanzaro from comment #30) > Hey Mark, how was ConfigSizeToProtect chosen? > > #if !OS(WINDOWS) > constexpr size_t ConfigSizeToProtect = 16 * KB; > #else > constexpr size_t ConfigSizeToProtect = 4 * KB; > #endif > > Is it supposed to match page size (in which case most Linux architectures > should be using 4 KB rather than 16 KB)? Or is it desired to be exactly 16 > KB everywhere regardless of page size unless page size is bigger than 16 KB? > Why is Windows using 4 KB while everything else uses 16 KB? > > Same question applies to the blockSize in MarkedBlock.h. In that case, the > code is a bit more clear, and I guess the desired block size is min(16 KB, > page size)? Look at JSC::Config::ensureSize. It is padded so that sizeof(JSC::Config) is a multiple of OS page size. ConfigSizeToProtect is shone to be that rounded up multiple of OS page size. 1631714 33 mark.lam 2020-03-19 10:15:56 -0700 (In reply to Mark Lam from comment #32) > Look at JSC::Config::ensureSize. It is padded so that sizeof(JSC::Config) > is a multiple of OS page size. ConfigSizeToProtect is shone to be that > rounded up multiple of OS page size. /shone/set/ 1631747 34 clopez 2020-03-19 11:15:31 -0700 (In reply to Michael Catanzaro from comment #28) > The best solution is to get page size at runtime using > sysconf(_SC_PAGESIZE), but it looks like the code really wants a > compile-time solution. So maybe just hardcode 64 KB for these CPUs and for > CPU(UNKNOWN)? Ideally we would share the value with MarkedBlock.h? clopez, > what do you think? > (In reply to Tomas Popela from comment #24) > > s390x, ppc64(le) in RHEL and Fedora use 64 KB page size > aarch64 on RHEL uses 64 KB and on Fedora 4 KB page size I wonder about doing something like the patch below to avoid future problems in cases where we can't predict the page size. diff --git a/Source/JavaScriptCore/runtime/JSCConfig.cpp b/Source/JavaScriptCore/runtime/JSCConfig.cpp index 79cc2b67ba9..b85393e1def 100644 --- a/Source/JavaScriptCore/runtime/JSCConfig.cpp +++ b/Source/JavaScriptCore/runtime/JSCConfig.cpp @@ -33,6 +33,7 @@ #include <mach/mach.h> #elif OS(LINUX) #include <sys/mman.h> +#include <unistd.h> #endif namespace JSC { @@ -70,7 +71,10 @@ void Config::permanentlyFreeze() // There's no going back now! result = vm_protect(mach_task_self(), reinterpret_cast<vm_address_t>(&g_jscConfig), ConfigSizeToProtect, DisallowPermissionChangesAfterThis, VM_PROT_READ); #elif OS(LINUX) - result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); + // Some architectures on Linux may have non-default page size. + // In that cases, avoid the crash in the RELEASE_ASSERT below due to using mprotect with a wrong page size. + if (sysconf(_SC_PAGESIZE) == ConfigSizeToProtect) + result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); #elif OS(WINDOWS) // FIXME: Implement equivalent, maybe with VirtualProtect. // Also need to fix WebKitTestRunner Does this looks like a good idea? 1631749 35 mark.lam 2020-03-19 11:21:47 -0700 (In reply to Carlos Alberto Lopez Perez from comment #34) > (In reply to Michael Catanzaro from comment #28) > > The best solution is to get page size at runtime using > > sysconf(_SC_PAGESIZE), but it looks like the code really wants a > > compile-time solution. So maybe just hardcode 64 KB for these CPUs and for > > CPU(UNKNOWN)? Ideally we would share the value with MarkedBlock.h? clopez, > > what do you think? > > Hardcoding to 64K is a good approach in addition to the check below. > (In reply to Tomas Popela from comment #24) > > > > s390x, ppc64(le) in RHEL and Fedora use 64 KB page size > > aarch64 on RHEL uses 64 KB and on Fedora 4 KB page size > > > I wonder about doing something like the patch below to avoid future problems > in cases where we can't predict the page size. > > > diff --git a/Source/JavaScriptCore/runtime/JSCConfig.cpp > b/Source/JavaScriptCore/runtime/JSCConfig.cpp > index 79cc2b67ba9..b85393e1def 100644 > --- a/Source/JavaScriptCore/runtime/JSCConfig.cpp > +++ b/Source/JavaScriptCore/runtime/JSCConfig.cpp > @@ -33,6 +33,7 @@ > #include <mach/mach.h> > #elif OS(LINUX) > #include <sys/mman.h> > +#include <unistd.h> > #endif > > namespace JSC { > @@ -70,7 +71,10 @@ void Config::permanentlyFreeze() > // There's no going back now! > result = vm_protect(mach_task_self(), > reinterpret_cast<vm_address_t>(&g_jscConfig), ConfigSizeToProtect, > DisallowPermissionChangesAfterThis, VM_PROT_READ); > #elif OS(LINUX) > - result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); > + // Some architectures on Linux may have non-default page size. > + // In that cases, avoid the crash in the RELEASE_ASSERT below due to > using mprotect with a wrong page size. > + if (sysconf(_SC_PAGESIZE) == ConfigSizeToProtect) > + result = mprotect(&g_jscConfig, ConfigSizeToProtect, PROT_READ); This check is not correct. ConfigSizeToProtect does not need to be strictly equal to sysconf(_SC_PAGESIZE). It needs to be a multiple of sysconf(_SC_PAGESIZE), where the multiple can be 1 or higher. You can use WTF::roundUpToMultipleOf() to compute that. > > > > Does this looks like a good idea? 1631754 36 mark.lam 2020-03-19 11:26:45 -0700 (In reply to Mark Lam from comment #35) > (In reply to Carlos Alberto Lopez Perez from comment #34) > > (In reply to Michael Catanzaro from comment #28) > > > The best solution is to get page size at runtime using > > > sysconf(_SC_PAGESIZE), but it looks like the code really wants a > > > compile-time solution. So maybe just hardcode 64 KB for these CPUs and for > > > CPU(UNKNOWN)? Ideally we would share the value with MarkedBlock.h? clopez, > > > what do you think? > > > > > Hardcoding to 64K is a good approach in addition to the check below. I should qualify this statement: hardcoding to 64K is a better workaround than disabling this feature outright. The feature is a security mitigation. If preventing the crash is a higher priority, the proposed check is good at the price of disabling this mitigation. 1631759 37 clopez 2020-03-19 11:34:43 -0700 (In reply to Mark Lam from comment #36) > (In reply to Mark Lam from comment #35) > > (In reply to Carlos Alberto Lopez Perez from comment #34) > > > (In reply to Michael Catanzaro from comment #28) > > > > The best solution is to get page size at runtime using > > > > sysconf(_SC_PAGESIZE), but it looks like the code really wants a > > > > compile-time solution. So maybe just hardcode 64 KB for these CPUs and for > > > > CPU(UNKNOWN)? Ideally we would share the value with MarkedBlock.h? clopez, > > > > what do you think? > > > > > > > > Hardcoding to 64K is a good approach in addition to the check below. > > I should qualify this statement: hardcoding to 64K is a better workaround > than disabling this feature outright. > > The feature is a security mitigation. If preventing the crash is a higher > priority, the proposed check is good at the price of disabling this > mitigation. I have to admit I don't understand the attack/mitigation scenario, neither what "Harden JSC against the abuse of runtime options." really means (even after reading the changelog of r249808 ). How this options are supposed to be abused? Can that be done by a malicious website? 1631769 38 mcatanzaro 2020-03-19 12:06:56 -0700 I think RELEASE_ASSERT() is the right thing to do if we somehow get the page size wrong. But let's RELEASE_ASSERT() on the sysconf(_SC_PAGESIZE) check instead of later when mprotect() fails. I'll cook a patch. 1631943 39 mcatanzaro 2020-03-19 18:26:36 -0700 Here's an initial patch. Mark, any idea what's up with WTF::pageSize() vs. WTF::vmPageSize()? They do the same thing on all platforms except iOS family, where pageSize() uses the userspace page size (16 KiB, vm_page_size) whereas vmPageSize() uses the kernel page size (4 KiB, vm_kernel_page_size). That's a strange difference. At first I had implemented vmPageSize() for OS(UNIX), but eventually I realized I could just get rid of that because it's really only needed in ResourceUsageCocoa.cpp, and changed JSCConfig to use pageSize() rather than vmPageSize(). Should be fine for iOS family because roundUpToMultipleOf(4 KiB, 16 KiB) == roundUpToMultipleOf(4 KiB, 16 KiB) == 16 KiB. I wound up not touching vmPageSize() at all, but it seems really suspicious to me. There's also bmalloc::vmPageSize(), which is the same as WTF::pageSize(), i.e. on iOS bmalloc::vmPageSize() returns a different value than WTF::vmPageSize() because bmalloc uses the userspace value while WTF uses the kernel value.) Behavior change: I reduced the size of JSCConfig from 16 KiB down to 4 KiB on macOS and most Linux architectures. I assume that makes sense because there's no reason for it to be any bigger than a single page, yes? I can be the hero who saved 12 KiB per web process? Then I made no behavior change in MarkedBlock.h. I used std::max(16 * KiB, CeilingOnPageSize) there, which I assume that makes sense because any changes there would affect object fragmentation, which could have performance impacts. Didn't want to mess with that. Oh, and I changed pageSize() to use sysconf(_SC_PAGESIZE) instead of getpagesize() just because that's deprecated. And added RELEASE_ASSERTs in pageSize(). Let's see if EWS likes it.... 1631944 40 394053 mcatanzaro 2020-03-19 18:28:39 -0700 Created attachment 394053 Patch 1631945 41 mcatanzaro 2020-03-19 18:29:46 -0700 (In reply to Michael Catanzaro from comment #39) > Here's an initial patch. > > Mark, any idea what's up with WTF::pageSize() vs. WTF::vmPageSize()? They do > the same thing on all platforms except iOS family, (Um, well it's only implemented on Cocoa, so they do the same thing on Cocoa platforms, except iOS family.) 1631946 42 mcatanzaro 2020-03-19 18:31:03 -0700 (In reply to Michael Catanzaro from comment #39) > Should be fine for iOS family because roundUpToMultipleOf(4 > KiB, 16 KiB) == roundUpToMultipleOf(4 KiB, 16 KiB) == 16 KiB. I meant to write: roundUpToMultipleOf(4 KiB, 16 KiB) == roundUpToMultipleOf(16 KiB, 16 KiB) == 16 KiB. 1632016 43 394053 tpopela 2020-03-19 23:53:44 -0700 Comment on attachment 394053 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394053&action=review > Source/WTF/wtf/PageBlock.h:47 > +#if CPU(UNKNOWN) || CPU(PPC) || (CPU(ARM64) && !PLATFORM(IOS_FAMILY)) I think that PPC here means the old 32-bit PowerPC architecture no? Also CPU(ARM64) here will be wrong for Fedora and others, but I fail to see, where the 4 KB will be chosen over these 64 KB. 1632018 44 394053 mark.lam 2020-03-20 00:13:04 -0700 Comment on attachment 394053 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394053&action=review > Source/JavaScriptCore/runtime/JSCConfig.h:38 > +constexpr size_t ConfigSizeToProtect = CeilingOnPageSize; We want Mac to match iOS. Please only change this for non-Darwin/Cocoa platforms. 1632060 45 mcatanzaro 2020-03-20 06:07:24 -0700 (In reply to Tomas Popela from comment #43) > I think that PPC here means the old 32-bit PowerPC architecture no? No, it means any variety of PPC. The old condition was redundant. > Also > CPU(ARM64) here will be wrong for Fedora and others, but I fail to see, > where the 4 KB will be chosen over these 64 KB. That's OK because it's just a ceiling. We only need to make sure the value is large enough for everyone. (In reply to Mark Lam from comment #44) > We want Mac to match iOS. Please only change this for non-Darwin/Cocoa > platforms. Sure, but did you read comment #39? The iOS value seems to be wrong. I don't know much about iOS, but surely using the kernel page size for userspace pages isn't right? Seems like it can probably be reduced to 4 KB on iOS as well? (I bet EWS will prove me wrong if I try it... but would be interesting to see.) 1632084 46 394053 saam 2020-03-20 08:12:26 -0700 Comment on attachment 394053 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394053&action=review > Source/WTF/wtf/PageBlock.h:50 > +constexpr size_t CeilingOnPageSize = 16 * KB; This number should be 16k for all Darwin. 1632085 47 saam 2020-03-20 08:17:21 -0700 You probably also need the same thing inside bmalloc unless you’re not using it. 1632093 48 mcatanzaro 2020-03-20 08:39:48 -0700 I'll upload a new patch that always uses 16 KB for all Cocoa builds, so you can have the same value everywhere. (In reply to Saam Barati from comment #47) > You probably also need the same thing inside bmalloc unless you’re not using > it. bmalloc determines page size at runtime, so it always does the right thing. (In reply to Michael Catanzaro from comment #45) > Sure, but did you read comment #39? The iOS value seems to be wrong. I don't > know much about iOS, but surely using the kernel page size for userspace > pages isn't right? Seems like it can probably be reduced to 4 KB on iOS as > well? (I bet EWS will prove me wrong if I try it... but would be interesting > to see.) Sorry, I got this completely backwards. iOS kernel page size is 4 KB, userspace page size is 16 KB. So I think ResourceUsageCocoa.cpp is returning bad results on iOS, by a factor of four. Someone from Apple could confirm and report a separate bug for this? 1632094 49 mcatanzaro 2020-03-20 08:45:04 -0700 (In reply to Michael Catanzaro from comment #48) > bmalloc determines page size at runtime, so it always does the right thing. Actually, we disable bmalloc on architectures that don't use 4 KB pages because it doesn't work. I looked for a place within bmalloc where it assumes page size at compile time and found bmalloc/Sizes.h. I guess if we update this, bmalloc might work on more architectures? We've had bmalloc disabled on these architectures for years. I never realized it might be so simple as changing page size. Anyway, we can address this in a separate bug. 1632095 50 394085 mcatanzaro 2020-03-20 08:48:20 -0700 Created attachment 394085 Patch 1632096 51 mcatanzaro 2020-03-20 08:50:32 -0700 Sebastien, please check that this new version of the patch also works for Ubuntu. Thanks! 1632098 52 mcatanzaro 2020-03-20 08:51:52 -0700 (In reply to Michael Catanzaro from comment #45) > (In reply to Tomas Popela from comment #43) > > I think that PPC here means the old 32-bit PowerPC architecture no? > > No, it means any variety of PPC. The old condition was redundant. Ugh sorry, you're right, it's broken. New version incoming. 1632104 53 mcatanzaro 2020-03-20 08:58:25 -0700 (In reply to Michael Catanzaro from comment #52) > Ugh sorry, you're right, it's broken. New version incoming. CPU(PPC) means 32-bit PPC only. CPU(PPC64) means ppc64 OR ppc64le, so having both in the condition is redundant. 1632105 54 394087 mcatanzaro 2020-03-20 09:00:35 -0700 Created attachment 394087 Patch 1632194 55 tpopela 2020-03-20 12:02:25 -0700 (In reply to Michael Catanzaro from comment #53) > (In reply to Michael Catanzaro from comment #52) > > Ugh sorry, you're right, it's broken. New version incoming. > > CPU(PPC64) means ppc64 OR ppc64le, so having both in the condition is > redundant. Is it? /* CPU(PPC64) - PowerPC 64-bit Big Endian */ #if ( defined(__ppc64__) \ || defined(__PPC64__)) \ && defined(__BYTE_ORDER__) \ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) #define WTF_CPU_PPC64 1 #define WTF_CPU_KNOWN 1 #endif /* CPU(PPC64LE) - PowerPC 64-bit Little Endian */ #if ( defined(__ppc64__) \ || defined(__PPC64__) \ || defined(__ppc64le__) \ || defined(__PPC64LE__)) \ && defined(__BYTE_ORDER__) \ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) #define WTF_CPU_PPC64LE 1 #define WTF_CPU_KNOWN 1 #endif from wtf/PlatformCPU.h 1632218 56 mcatanzaro 2020-03-20 12:34:38 -0700 (In reply to Tomas Popela from comment #55) > && defined(__BYTE_ORDER__) \ > && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) > #define WTF_CPU_PPC64LE 1 > #define WTF_CPU_KNOWN 1 > #endif Apparently I am awful at reading code. 1632219 57 394110 mcatanzaro 2020-03-20 12:35:58 -0700 Created attachment 394110 Patch 1632333 58 seb128 2020-03-20 15:44:55 -0700 @Michael, I will give a try to the patch on monday, the JSCConfig.h code in webkitgtk 3.28 is different so the patch doesn't apply, I tried to adapt it but probably screwed something since it failed to build but it's a bit late to rework that today now 1632821 59 clopez 2020-03-23 06:50:01 -0700 *** Bug 209171 has been marked as a duplicate of this bug. *** 1632847 60 dkg 2020-03-23 08:08:18 -0700 I believe the same crash is happening on mipsel as well, so if these fixes can be tested on that platform, that would be great. Here's a build of geary on the debian mipsel buildd that shows this failure during the test suite: https://buildd.debian.org/status/fetch.php?pkg=geary&arch=mipsel&ver=3.36.0-2&stamp=1584411277&raw=0 1632859 61 clopez 2020-03-23 09:04:04 -0700 (In reply to Daniel Kahn Gillmor from comment #60) > I believe the same crash is happening on mipsel as well, so if these fixes > can be tested on that platform, that would be great. > > Here's a build of geary on the debian mipsel buildd that shows this failure > during the test suite: > > https://buildd.debian.org/status/fetch.php?pkg=geary&arch=mipsel&ver=3.36.0- > 2&stamp=1584411277&raw=0 We do extensive testing of JSC on mipsel (32-bits) and we have not noticed a problem with this (AFAIK) The MIPS board we use for testing (ci20 with buidroot) have a pagesize of 4096 (same than Linux/x86_64) Can you confirm which page size does Debian uses for the mipsel port? You can get that by running the command "getconf PAGESIZE" on that mipsel machine. 1632877 62 394110 mcatanzaro 2020-03-23 09:49:08 -0700 Comment on attachment 394110 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394110&action=review > Source/WTF/wtf/PageBlock.h:50 > +// Use 64 KiB for any unknown CPUs to be conservative. This covers s390x, which doesn't currently > +// have its own CPU() macro and which also uses 64 KiB pages. This is wrong. s390x uses 4 KiB. 1632879 63 394268 mcatanzaro 2020-03-23 09:51:31 -0700 Created attachment 394268 Patch 1632880 64 394269 mcatanzaro 2020-03-23 09:52:07 -0700 Created attachment 394269 Patch 1632887 65 tpopela 2020-03-23 09:58:20 -0700 (In reply to Michael Catanzaro from comment #62) > Comment on attachment 394110 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=394110&action=review > > > Source/WTF/wtf/PageBlock.h:50 > > +// Use 64 KiB for any unknown CPUs to be conservative. This covers s390x, which doesn't currently > > +// have its own CPU() macro and which also uses 64 KiB pages. > > This is wrong. s390x uses 4 KiB. Sorry about that.. I was wrong/mistaken for the last 7 years.. 1632890 66 394269 mark.lam 2020-03-23 10:00:38 -0700 Comment on attachment 394269 Patch r=me if EWS bots are happy. 1632909 67 mcatanzaro 2020-03-23 10:19:30 -0700 Thanks Mark! We've confirmed this fixes ppc64le on Red Hat's CI, so I can be pretty confident it will fix Ubuntu's problem too. I trust Sebastien will let us know when he's tested it. (In reply to Daniel Kahn Gillmor from comment #60) > I believe the same crash is happening on mipsel as well, so if these fixes > can be tested on that platform, that would be great. > > Here's a build of geary on the debian mipsel buildd that shows this failure > during the test suite: > > https://buildd.debian.org/status/fetch.php?pkg=geary&arch=mipsel&ver=3.36.0- > 2&stamp=1584411277&raw=0 How do you know it's this particular crash? This patch is definitely not going to affect anything on MIPS, because it assumes 4 kiB page size on MIPS. We can change that if you have access to an affected MIPS system and report the 'getconf PAGESIZE' you see on that machine. (If it returns 4096, then your bug is something else.) I don't have access to any MIPS systems, so I can't test this for you. 1632919 68 ews-feeder 2020-03-23 10:34:48 -0700 Committed r258857: <https://trac.webkit.org/changeset/258857> All reviewed patches have been landed. Closing bug and clearing flags on attachment 394269. 1632920 69 webkit-bug-importer 2020-03-23 10:35:19 -0700 <rdar://problem/60780778> 1633396 70 saam 2020-03-24 11:26:17 -0700 (In reply to Michael Catanzaro from comment #49) > (In reply to Michael Catanzaro from comment #48) > > bmalloc determines page size at runtime, so it always does the right thing. > > Actually, we disable bmalloc on architectures that don't use 4 KB pages > because it doesn't work. I looked for a place within bmalloc where it > assumes page size at compile time and found bmalloc/Sizes.h. I guess if we > update this, bmalloc might work on more architectures? > > We've had bmalloc disabled on these architectures for years. I never > realized it might be so simple as changing page size. Anyway, we can address > this in a separate bug. I meant the "config size to protect" thing inside Gigacage code. 1633397 71 saam 2020-03-24 11:27:29 -0700 (In reply to Saam Barati from comment #70) > (In reply to Michael Catanzaro from comment #49) > > (In reply to Michael Catanzaro from comment #48) > > > bmalloc determines page size at runtime, so it always does the right thing. > > > > Actually, we disable bmalloc on architectures that don't use 4 KB pages > > because it doesn't work. I looked for a place within bmalloc where it > > assumes page size at compile time and found bmalloc/Sizes.h. I guess if we > > update this, bmalloc might work on more architectures? > > > > We've had bmalloc disabled on these architectures for years. I never > > realized it might be so simple as changing page size. Anyway, we can address > > this in a separate bug. > > I meant the "config size to protect" thing inside Gigacage code. I believe the "smallPageSize" stuff inside bmalloc's Sizes.h isn't required to be what the OS says it is. But I need to read a bit closer on how it's used. 1634908 72 clopez 2020-03-27 11:29:15 -0700 (In reply to EWS from comment #68) > Committed r258857: <https://trac.webkit.org/changeset/258857> > > All reviewed patches have been landed. Closing bug and clearing flags on > attachment 394269 [details]. This has caused a regression on our ARM64 JSCOnly testers (which use 4KB of page size). The tester its crashing all the time. https://build.webkit.org/builders/JSCOnly%20Linux%20AArch64%20Release Its also making the JSCOnly ARM64 EWS queue worthless (since it fails all the time) https://build.webkit.org/buildslaves/jsconly-linux-igalia-bot-2 So I'm reverting this now, and I'll see if we can add here more info about why its crashing in order to rework the patch. 1634910 73 clopez 2020-03-27 11:32:39 -0700 (In reply to Carlos Alberto Lopez Perez from comment #72) > Its also making the JSCOnly ARM64 EWS queue worthless (since it fails all > the time) https://build.webkit.org/buildslaves/jsconly-linux-igalia-bot-2 > Agh! forgot about that, we don't have an EWS for JSCOnly ARM64. That link was just the same than the one for the buildbot, just different view. 1634913 74 394736 zan 2020-03-27 11:36:27 -0700 Created attachment 394736 JSCOnly aarch64 strace log Here's output of strace for the SIGSEGV that occurs immediately after launch. 1639031 75 dkg 2020-04-08 06:52:38 -0700 should this remain RESOLVED FIXED if the patches have been reverted? I'm sorry i haven't followed the changes closely enough upstream. Is there a version where these fixes have landed? 1639041 76 mcatanzaro 2020-04-08 07:19:13 -0700 We wound up not reverting the patches. aarch64 is still broken (bug #209670), but ppc64le is now fine. Solving bug #209670 is basically impossible. We are being expected to provide a value at compile time that cannot be known until runtime. Very frustrating. Oh, and I discovered people are actually using huge pages, so WebKit is guaranteed to be broken for them no matter what. *shrug!* 1639046 77 mark.lam 2020-04-08 07:37:57 -0700 (In reply to Michael Catanzaro from comment #76) > We wound up not reverting the patches. > > aarch64 is still broken (bug #209670), but ppc64le is now fine. > > Solving bug #209670 is basically impossible. We are being expected to > provide a value at compile time that cannot be known until runtime. Very > frustrating. > > Oh, and I discovered people are actually using huge pages, so WebKit is > guaranteed to be broken for them no matter what. *shrug!* One way around this is to disable this mitigation for those platforms that cannot be statically configured: basically, on those platforms, at runtime, check if page size is within acceptable limits (and whatever other criteria you need), and if not, disable the mitigation and don’t do the page freeze. On platforms that can guarantee their page sizes, this option to disable the mitigation should be #if’d out. 1639051 78 mcatanzaro 2020-04-08 07:57:55 -0700 Yeah you're right, that's exactly what we should do. We can check page size at runtime only on Linux platforms and disable config freezing, JIT, and bmalloc when pages are large. Will handle in bug #209670. 1642994 79 394269 mark.lam 2020-04-18 08:25:40 -0700 Comment on attachment 394269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=394269&action=review > Source/WTF/ChangeLog:11 > + will be even easier to detect if we change RELEASE_ASSERT_WITH_MESSAGE() to actually print We should not change RELEASE_ALERT_WITH_MESSAGE() to unconditionally print its message. That message is only meant to be used in debug builds. But if you really want a message in a release build, you can always check the condition first and print your message before doing the RELEASE_ASSERT. I do not recommend doing this in the general case (for performance reasons), but in your implementation here, it’ll only be executed once. So checking and printing that error message won’t hurt much. 1642995 80 mcatanzaro 2020-04-18 08:31:07 -0700 (In reply to Mark Lam from comment #79) > We should not change RELEASE_ALERT_WITH_MESSAGE() to unconditionally print > its message. You probably want to look at bug #204399 ;) 1647010 81 mcatanzaro 2020-04-29 09:04:00 -0700 *** Bug 204017 has been marked as a duplicate of this bug. *** 393861 2020-03-18 08:55:11 -0700 2020-03-18 08:55:11 -0700 small script testcase dbgwebkit.py text/x-python 395 seb128 IyEvdXNyL2Jpbi9weXRob24zCmltcG9ydCBnaQpnaS5yZXF1aXJlX3ZlcnNpb24oIldlYktpdDIi LCAiNC4wIikKCmZyb20gZ2kucmVwb3NpdG9yeSBpbXBvcnQgV2ViS2l0MiwgR3RrLCBHTGliCmZy b20gb3MgaW1wb3J0IHBhdGgKaW1wb3J0IHN5cwoKY3R4ID0gV2ViS2l0Mi5XZWJDb250ZXh0Lmdl dF9kZWZhdWx0KCkKCnduZCA9IEd0ay5XaW5kb3coKQp3ZWIgPSBXZWJLaXQyLldlYlZpZXcubmV3 X3dpdGhfY29udGV4dChjdHgpCnduZC5jb25uZWN0KCJkZXN0cm95IiwgR3RrLm1haW5fcXVpdCkK d25kLmFkZCh3ZWIpCnduZC5zZXRfZGVmYXVsdF9zaXplKDcwMCwgMzAwKQp3bmQuc2hvd19hbGwo KQoKd2ViLmxvYWRfdXJpKCJodHRwOi8vd3d3Lmdvb2dsZS5jb20iKQoKR3RrLm1haW4oKQo= 393897 2020-03-18 13:42:25 -0700 2020-03-18 13:42:25 -0700 gdb gdb.txt text/plain 18087 seb128 ClRocmVhZCA2IChUaHJlYWQgMHg3MDVkYmU3Y2VkYzAgKExXUCAzMDA2MSkpOgojMCAgMHgwMDAw NzA1ZGNlYTJjNDljIGluIF9fR0lfX19wb2xsIChmZHM9MHg3MDVkYTgwMGZjZTAsIG5mZHM9Miwg dGltZW91dD08b3B0aW1pemVkIG91dD4pIGF0IC4uL3N5c2RlcHMvdW5peC9zeXN2L2xpbnV4L3Bv bGwuYzoyOQogICAgICAgIHI0ID0gMgogICAgICAgIHI3ID0gMTIzNTQ3OTMwMTI4MDcyCiAgICAg ICAgcjUgPSAtMQogICAgICAgIHI4ID0gMgogICAgICAgIHIwID0gMTY3CiAgICAgICAgcjMgPSA1 MTYKICAgICAgICByNiA9IDAKICAgICAgICBzY19lcnIgPSA8b3B0aW1pemVkIG91dD4KICAgICAg ICBzY19yZXQgPSA8b3B0aW1pemVkIG91dD4KICAgICAgICBzY19jYW5jZWxfb2xkdHlwZSA9IDAK IzEgIDB4MDAwMDcwNWRjZDRlMTNhOCBpbiBnX3BvbGwgKCkgYXQgL2xpYi9wb3dlcnBjNjRsZS1s aW51eC1nbnUvbGliZ2xpYi0yLjAuc28uMAojMiAgMHgwMDAwNzA1ZGNkNGM2MWE4IGluICAoKSBh dCAvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIuMC5zby4wCiMzICAweDAwMDA3 MDVkY2Q0YzY3YmMgaW4gZ19tYWluX2xvb3BfcnVuICgpIGF0IC9saWIvcG93ZXJwYzY0bGUtbGlu dXgtZ251L2xpYmdsaWItMi4wLnNvLjAKIzQgIDB4MDAwMDcwNWRjY2MzZjhhNCBpbiBXVEY6OlJ1 bkxvb3A6OnJ1bigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dsaWIvUnVuTG9vcEdMaWIuY3Bw Ojk2CiM1ICAweDAwMDA3MDVkY2NjM2EwYzAgaW4gb3BlcmF0b3IoKSAoKSBhdCAuLi9Tb3VyY2Uv V1RGL3d0Zi9nZW5lcmljL1dvcmtRdWV1ZUdlbmVyaWMuY3BwOjQzCiM2ICBjYWxsKCkgKCkgYXQg Li4vU291cmNlL1dURi93dGYvRnVuY3Rpb24uaDo1MgojNyAgMHgwMDAwNzA1ZGNjYmM1MDAwIGlu IFdURjo6RnVuY3Rpb248dm9pZCAoKT46Om9wZXJhdG9yKCkoKSBjb25zdCAoKSBhdCAuLi9Tb3Vy Y2UvV1RGL3d0Zi9GdW5jdGlvbi5oOjg0CiM4ICBXVEY6OlRocmVhZDo6ZW50cnlQb2ludChXVEY6 OlRocmVhZDo6TmV3VGhyZWFkQ29udGV4dCopICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL1RocmVh ZGluZy5jcHA6MTQ4CiM5ICAweDAwMDA3MDVkY2NjNDFiMDggaW4gd3RmVGhyZWFkRW50cnlQb2lu dCgpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL3Bvc2l4L1RocmVhZGluZ1BPU0lYLmNwcDoyMDAK IzEwIDB4MDAwMDcwNWRjYTQ2OTgxOCBpbiBzdGFydF90aHJlYWQgKGFyZz0weDcwNWRiZTdjZWRj MCkgYXQgcHRocmVhZF9jcmVhdGUuYzo0NzcKICAgICAgICByZXQgPSA8b3B0aW1pemVkIG91dD4K ICAgICAgICBwZCA9IDB4NzA1ZGJlN2NlZGMwCiAgICAgICAgdW53aW5kX2J1ZiA9IHtjYW5jZWxf am1wX2J1ZiA9IHt7am1wX2J1ZiA9IHstNTYzNTU1NzQ0NDU3NzI1MTUyMCwgMTIzNTQ4MTI4MTQ5 MjQ4LCAtNTYzNTU1NzQ0NTQ1MTM1OTM3NiwgMTIzNTQ4MTI4MTM0MTYwLCAwLCAxMjM1NDgyNjk3 NDAwMzIsIDEyMzU0ODEyODExNzUzNiwgMTIzNTQ3OTMwMTI4MDAwLCAxMjM1NDgxMjgxMzQxNzYs IDAsIDAsIDEyMzU0Nzc1NDIzMjQ5NiwgMTIzNTQ4MTY5NjczNDU2LCAxNDA3MzczNTAxNjkyNTYs IDEyMzU0NzkzMDEyOTcxMiwgMTIzNTQ3OTMwMTI2MDE2LCAxNDA3MzczNTAxNjkyNjQsIDE0MDcz NzM1MDE2ODk5MSwgMTIzNTQ3OTMwMTI3ODA4LCAxMjM1NDgxMjc4OTMyOTYsIDEyMzU0NzkzMDEy NTI4MCwgMjQ1MDAzMzUzNTMxMDg4ODk1OSwgMCA8cmVwZWF0cyA0MiB0aW1lcz59LCBtYXNrX3dh c19zYXZlZCA9IDB9fSwgcHJpdiA9IHtwYWQgPSB7MHgwLCAweDAsIDB4MCwgMHgwfSwgZGF0YSA9 IHtwcmV2ID0gMHgwLCBjbGVhbnVwID0gMHgwLCBjYW5jZWx0eXBlID0gMH19fQogICAgICAgIG5v dF9maXJzdF9jYWxsID0gPG9wdGltaXplZCBvdXQ+CiMxMSAweDAwMDA3MDVkY2VhM2U4NjQgaW4g Y2xvbmUgKCkgYXQgLi4vc3lzZGVwcy91bml4L3N5c3YvbGludXgvcG93ZXJwYy9wb3dlcnBjNjQv Y2xvbmUuUzo4MgoKVGhyZWFkIDUgKFRocmVhZCAweDcwNWRiZWZkZWRjMCAoTFdQIDMwMDU3KSk6 CiMwICAweDAwMDA3MDVkY2VhMmM0OWMgaW4gX19HSV9fX3BvbGwgKGZkcz0weDcwNWRiNDAwZmNl MCwgbmZkcz0yLCB0aW1lb3V0PTxvcHRpbWl6ZWQgb3V0PikgYXQgLi4vc3lzZGVwcy91bml4L3N5 c3YvbGludXgvcG9sbC5jOjI5CiAgICAgICAgcjQgPSAyCiAgICAgICAgcjcgPSAxMjM1NDc5Mzg1 ODIyMTYKICAgICAgICByNSA9IC0xCiAgICAgICAgcjggPSAyCiAgICAgICAgcjAgPSAxNjcKICAg ICAgICByMyA9IDUxNgogICAgICAgIHI2ID0gMAogICAgICAgIHNjX2VyciA9IDxvcHRpbWl6ZWQg b3V0PgogICAgICAgIHNjX3JldCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHNjX2NhbmNlbF9v bGR0eXBlID0gMAojMSAgMHgwMDAwNzA1ZGNkNGUxM2E4IGluIGdfcG9sbCAoKSBhdCAvbGliL3Bv d2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIuMC5zby4wCiMyICAweDAwMDA3MDVkY2Q0YzYx YTggaW4gICgpIGF0IC9saWIvcG93ZXJwYzY0bGUtbGludXgtZ251L2xpYmdsaWItMi4wLnNvLjAK IzMgIDB4MDAwMDcwNWRjZDRjNjdiYyBpbiBnX21haW5fbG9vcF9ydW4gKCkgYXQgL2xpYi9wb3dl cnBjNjRsZS1saW51eC1nbnUvbGliZ2xpYi0yLjAuc28uMAojNCAgMHgwMDAwNzA1ZGNjYzNmOGE0 IGluIFdURjo6UnVuTG9vcDo6cnVuKCkgKCkgYXQgLi4vU291cmNlL1dURi93dGYvZ2xpYi9SdW5M b29wR0xpYi5jcHA6OTYKIzUgIDB4MDAwMDcwNWRjY2MzYTBjMCBpbiBvcGVyYXRvcigpICgpIGF0 IC4uL1NvdXJjZS9XVEYvd3RmL2dlbmVyaWMvV29ya1F1ZXVlR2VuZXJpYy5jcHA6NDMKIzYgIGNh bGwoKSAoKSBhdCAuLi9Tb3VyY2UvV1RGL3d0Zi9GdW5jdGlvbi5oOjUyCiM3ICAweDAwMDA3MDVk Y2NiYzUwMDAgaW4gV1RGOjpGdW5jdGlvbjx2b2lkICgpPjo6b3BlcmF0b3IoKSgpIGNvbnN0ICgp IGF0IC4uL1NvdXJjZS9XVEYvd3RmL0Z1bmN0aW9uLmg6ODQKIzggIFdURjo6VGhyZWFkOjplbnRy eVBvaW50KFdURjo6VGhyZWFkOjpOZXdUaHJlYWRDb250ZXh0KikgKCkgYXQgLi4vU291cmNlL1dU Ri93dGYvVGhyZWFkaW5nLmNwcDoxNDgKIzkgIDB4MDAwMDcwNWRjY2M0MWIwOCBpbiB3dGZUaHJl YWRFbnRyeVBvaW50KCkgKCkgYXQgLi4vU291cmNlL1dURi93dGYvcG9zaXgvVGhyZWFkaW5nUE9T SVguY3BwOjIwMAojMTAgMHgwMDAwNzA1ZGNhNDY5ODE4IGluIHN0YXJ0X3RocmVhZCAoYXJnPTB4 NzA1ZGJlZmRlZGMwKSBhdCBwdGhyZWFkX2NyZWF0ZS5jOjQ3NwogICAgICAgIHJldCA9IDxvcHRp bWl6ZWQgb3V0PgogICAgICAgIHBkID0gMHg3MDVkYmVmZGVkYzAKICAgICAgICB1bndpbmRfYnVm ID0ge2NhbmNlbF9qbXBfYnVmID0ge3tqbXBfYnVmID0gey01NjM1NTU3NDQ0NTg1NTc0NTkyLCAx MjM1NDgxMjgxNDkyNDgsIC01NjM1NTU3NDQ1NDUxMzU5Mzc2LCAxMjM1NDgxMjgxMzQxNjAsIDAs IDEyMzU0ODI2OTc0MDAzMiwgMTIzNTQ4MTI4MTE3NTM2LCAxMjM1NDc5Mzg1ODIxNDQsIDEyMzU0 ODEyODEzNDE3NiwgMCwgMCwgNDI4MTk1OTk4MzcyOCwgMTIzNTQ4MTY5NjczNDU2LCAxNDA3Mzcz NTAxNzMwOTYsIDEyMzU0NzkzODU4Mzg1NiwgMTIzNTQ3OTM4NTgwMTYwLCAxNDA3MzczNTAxNzMx MDQsIDE0MDczNzM1MDE3MjgzMSwgMTIzNTQ3OTM4NTgxOTUyLCAxMjM1NDgxMjc4OTMyOTYsIDEy MzU0NzkzODU3OTQyNCwgMjQ1MDAzMzUzNTMxMDg4ODk1OSwgMCA8cmVwZWF0cyA0MiB0aW1lcz59 LCBtYXNrX3dhc19zYXZlZCA9IDB9fSwgcHJpdiA9IHtwYWQgPSB7MHgwLCAweDAsIDB4MCwgMHgw fSwgZGF0YSA9IHtwcmV2ID0gMHgwLCBjbGVhbnVwID0gMHgwLCBjYW5jZWx0eXBlID0gMH19fQog ICAgICAgIG5vdF9maXJzdF9jYWxsID0gPG9wdGltaXplZCBvdXQ+CiMxMSAweDAwMDA3MDVkY2Vh M2U4NjQgaW4gY2xvbmUgKCkgYXQgLi4vc3lzZGVwcy91bml4L3N5c3YvbGludXgvcG93ZXJwYy9w b3dlcnBjNjQvY2xvbmUuUzo4MgoKVGhyZWFkIDQgKFRocmVhZCAweDcwNWRiZjdlZWRjMCAoTFdQ IDMwMDU2KSk6CiMwICAweDAwMDA3MDVkY2VhMmM0OWMgaW4gX19HSV9fX3BvbGwgKGZkcz0weDcw NWRiMDAwZDdlMCwgbmZkcz0xLCB0aW1lb3V0PTxvcHRpbWl6ZWQgb3V0PikgYXQgLi4vc3lzZGVw cy91bml4L3N5c3YvbGludXgvcG9sbC5jOjI5CiAgICAgICAgcjQgPSAxCiAgICAgICAgcjcgPSAx MjM1NDc5NDcwMzYzNjAKICAgICAgICByNSA9IC0xCiAgICAgICAgcjggPSAyCiAgICAgICAgcjAg PSAxNjcKICAgICAgICByMyA9IDUxNgogICAgICAgIHI2ID0gMAogICAgICAgIHNjX2VyciA9IDxv cHRpbWl6ZWQgb3V0PgogICAgICAgIHNjX3JldCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHNj X2NhbmNlbF9vbGR0eXBlID0gMAojMSAgMHgwMDAwNzA1ZGNkNGUxM2E4IGluIGdfcG9sbCAoKSBh dCAvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIuMC5zby4wCiMyICAweDAwMDA3 MDVkY2Q0YzYxYTggaW4gICgpIGF0IC9saWIvcG93ZXJwYzY0bGUtbGludXgtZ251L2xpYmdsaWIt Mi4wLnNvLjAKIzMgIDB4MDAwMDcwNWRjZDRjNjdiYyBpbiBnX21haW5fbG9vcF9ydW4gKCkgYXQg L2xpYi9wb3dlcnBjNjRsZS1saW51eC1nbnUvbGliZ2xpYi0yLjAuc28uMAojNCAgMHgwMDAwNzA1 ZGNjYzNmOGE0IGluIFdURjo6UnVuTG9vcDo6cnVuKCkgKCkgYXQgLi4vU291cmNlL1dURi93dGYv Z2xpYi9SdW5Mb29wR0xpYi5jcHA6OTYKIzUgIDB4MDAwMDcwNWRjY2MzYTBjMCBpbiBvcGVyYXRv cigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dlbmVyaWMvV29ya1F1ZXVlR2VuZXJpYy5jcHA6 NDMKIzYgIGNhbGwoKSAoKSBhdCAuLi9Tb3VyY2UvV1RGL3d0Zi9GdW5jdGlvbi5oOjUyCiM3ICAw eDAwMDA3MDVkY2NiYzUwMDAgaW4gV1RGOjpGdW5jdGlvbjx2b2lkICgpPjo6b3BlcmF0b3IoKSgp IGNvbnN0ICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL0Z1bmN0aW9uLmg6ODQKIzggIFdURjo6VGhy ZWFkOjplbnRyeVBvaW50KFdURjo6VGhyZWFkOjpOZXdUaHJlYWRDb250ZXh0KikgKCkgYXQgLi4v U291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcDoxNDgKIzkgIDB4MDAwMDcwNWRjY2M0MWIwOCBp biB3dGZUaHJlYWRFbnRyeVBvaW50KCkgKCkgYXQgLi4vU291cmNlL1dURi93dGYvcG9zaXgvVGhy ZWFkaW5nUE9TSVguY3BwOjIwMAojMTAgMHgwMDAwNzA1ZGNhNDY5ODE4IGluIHN0YXJ0X3RocmVh ZCAoYXJnPTB4NzA1ZGJmN2VlZGMwKSBhdCBwdGhyZWFkX2NyZWF0ZS5jOjQ3NwogICAgICAgIHJl dCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHBkID0gMHg3MDVkYmY3ZWVkYzAKICAgICAgICB1 bndpbmRfYnVmID0ge2NhbmNlbF9qbXBfYnVmID0ge3tqbXBfYnVmID0gey01NjM1NTU3NDQ0NTYw NjA1Mzc2LCAxMjM1NDgxMjgxNDkyNDgsIC01NjM1NTU3NDQ1NDUxMzU5Mzc2LCAxMjM1NDgxMjgx MzQxNjAsIDAsIDEyMzU0ODI2OTc0MDAzMiwgMTIzNTQ4MTI4MTE3NTM2LCAxMjM1NDc5NDcwMzYy ODgsIDEyMzU0ODEyODEzNDE3NiwgMCwgMCwgNDI4MTk1OTk4MjgzMiwgMTIzNTQ4MTY5NjczNDU2 LCAxNDA3MzczNTAxNzMwNjQsIDEyMzU0Nzk0NzAzODAwMCwgMTIzNTQ3OTQ3MDM0MzA0LCAxNDA3 MzczNTAxNzMwNzIsIDE0MDczNzM1MDE3Mjc5OSwgMTIzNTQ3OTQ3MDM2MDk2LCAxMjM1NDgxMjc4 OTMyOTYsIDEyMzU0Nzk0NzAzMzU2OCwgMjQ1MDAzMzUzNTMxMDg4ODk1OSwgMCA8cmVwZWF0cyA0 MiB0aW1lcz59LCBtYXNrX3dhc19zYXZlZCA9IDB9fSwgcHJpdiA9IHtwYWQgPSB7MHgwLCAweDAs IDB4MCwgMHgwfSwgZGF0YSA9IHtwcmV2ID0gMHgwLCBjbGVhbnVwID0gMHgwLCBjYW5jZWx0eXBl ID0gMH19fQogICAgICAgIG5vdF9maXJzdF9jYWxsID0gPG9wdGltaXplZCBvdXQ+CiMxMSAweDAw MDA3MDVkY2VhM2U4NjQgaW4gY2xvbmUgKCkgYXQgLi4vc3lzZGVwcy91bml4L3N5c3YvbGludXgv cG93ZXJwYy9wb3dlcnBjNjQvY2xvbmUuUzo4MgoKVGhyZWFkIDMgKFRocmVhZCAweDcwNWRiZmZm ZWRjMCAoTFdQIDMwMDU1KSk6CiMwICAweDAwMDA3MDVkY2VhMmM0OWMgaW4gX19HSV9fX3BvbGwg KGZkcz0weDcwNWRiODAwZmNlMCwgbmZkcz0xLCB0aW1lb3V0PTxvcHRpbWl6ZWQgb3V0PikgYXQg Li4vc3lzZGVwcy91bml4L3N5c3YvbGludXgvcG9sbC5jOjI5CiAgICAgICAgcjQgPSAxCiAgICAg ICAgcjcgPSAxMjM1NDc5NTU0OTA1MDQKICAgICAgICByNSA9IC0xCiAgICAgICAgcjggPSAyCiAg ICAgICAgcjAgPSAxNjcKICAgICAgICByMyA9IDUxNgogICAgICAgIHI2ID0gMAogICAgICAgIHNj X2VyciA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHNjX3JldCA9IDxvcHRpbWl6ZWQgb3V0Pgog ICAgICAgIHNjX2NhbmNlbF9vbGR0eXBlID0gMAojMSAgMHgwMDAwNzA1ZGNkNGUxM2E4IGluIGdf cG9sbCAoKSBhdCAvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIuMC5zby4wCiMy ICAweDAwMDA3MDVkY2Q0YzYxYTggaW4gICgpIGF0IC9saWIvcG93ZXJwYzY0bGUtbGludXgtZ251 L2xpYmdsaWItMi4wLnNvLjAKIzMgIDB4MDAwMDcwNWRjZDRjNjdiYyBpbiBnX21haW5fbG9vcF9y dW4gKCkgYXQgL2xpYi9wb3dlcnBjNjRsZS1saW51eC1nbnUvbGliZ2xpYi0yLjAuc28uMAojNCAg MHgwMDAwNzA1ZGNjYzNmOGE0IGluIFdURjo6UnVuTG9vcDo6cnVuKCkgKCkgYXQgLi4vU291cmNl L1dURi93dGYvZ2xpYi9SdW5Mb29wR0xpYi5jcHA6OTYKIzUgIDB4MDAwMDcwNWRjY2MzYTBjMCBp biBvcGVyYXRvcigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dlbmVyaWMvV29ya1F1ZXVlR2Vu ZXJpYy5jcHA6NDMKIzYgIGNhbGwoKSAoKSBhdCAuLi9Tb3VyY2UvV1RGL3d0Zi9GdW5jdGlvbi5o OjUyCiM3ICAweDAwMDA3MDVkY2NiYzUwMDAgaW4gV1RGOjpGdW5jdGlvbjx2b2lkICgpPjo6b3Bl cmF0b3IoKSgpIGNvbnN0ICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL0Z1bmN0aW9uLmg6ODQKIzgg IFdURjo6VGhyZWFkOjplbnRyeVBvaW50KFdURjo6VGhyZWFkOjpOZXdUaHJlYWRDb250ZXh0Kikg KCkgYXQgLi4vU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcDoxNDgKIzkgIDB4MDAwMDcwNWRj Y2M0MWIwOCBpbiB3dGZUaHJlYWRFbnRyeVBvaW50KCkgKCkgYXQgLi4vU291cmNlL1dURi93dGYv cG9zaXgvVGhyZWFkaW5nUE9TSVguY3BwOjIwMAojMTAgMHgwMDAwNzA1ZGNhNDY5ODE4IGluIHN0 YXJ0X3RocmVhZCAoYXJnPTB4NzA1ZGJmZmZlZGMwKSBhdCBwdGhyZWFkX2NyZWF0ZS5jOjQ3Nwog ICAgICAgIHJldCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHBkID0gMHg3MDVkYmZmZmVkYzAK ICAgICAgICB1bndpbmRfYnVmID0ge2NhbmNlbF9qbXBfYnVmID0ge3tqbXBfYnVmID0gey01NjM1 NTU3NDQ0NTY4OTI4NDQ4LCAxMjM1NDgxMjgxNDkyNDgsIC01NjM1NTU3NDQ1NDUxMzU5Mzc2LCAx MjM1NDgxMjgxMzQxNjAsIDAsIDEyMzU0ODI2OTc0MDAzMiwgMTIzNTQ4MTI4MTE3NTM2LCAxMjM1 NDc5NTU0OTA0MzIsIDEyMzU0ODEyODEzNDE3NiwgMCwgMCwgNDI4MTk1OTg3NTg1NiwgMTIzNTQ4 MTY5NjczNDU2LCAxNDA3MzczNTAxNzMwODAsIDEyMzU0Nzk1NTQ5MjE0NCwgMTIzNTQ3OTU1NDg4 NDQ4LCAxNDA3MzczNTAxNzMwODgsIDE0MDczNzM1MDE3MjgxNSwgMTIzNTQ3OTU1NDkwMjQwLCAx MjM1NDgxMjc4OTMyOTYsIDEyMzU0Nzk1NTQ4NzcxMiwgMjQ1MDAzMzUzNTMxMDg4ODk1OSwgMCA8 cmVwZWF0cyA0MiB0aW1lcz59LCBtYXNrX3dhc19zYXZlZCA9IDB9fSwgcHJpdiA9IHtwYWQgPSB7 MHgwLCAweDAsIDB4MCwgMHgwfSwgZGF0YSA9IHtwcmV2ID0gMHgwLCBjbGVhbnVwID0gMHgwLCBj YW5jZWx0eXBlID0gMH19fQogICAgICAgIG5vdF9maXJzdF9jYWxsID0gPG9wdGltaXplZCBvdXQ+ CiMxMSAweDAwMDA3MDVkY2VhM2U4NjQgaW4gY2xvbmUgKCkgYXQgLi4vc3lzZGVwcy91bml4L3N5 c3YvbGludXgvcG93ZXJwYy9wb3dlcnBjNjQvY2xvbmUuUzo4MgoKVGhyZWFkIDIgKFRocmVhZCAw eDcwNWRjNGM2ZWRjMCAoTFdQIDMwMDU0KSk6CiMwICAweDAwMDA3MDVkY2VhMmM0OWMgaW4gX19H SV9fX3BvbGwgKGZkcz0weDcwNWRjMDAwZDNlMCwgbmZkcz0xLCB0aW1lb3V0PTxvcHRpbWl6ZWQg b3V0PikgYXQgLi4vc3lzZGVwcy91bml4L3N5c3YvbGludXgvcG9sbC5jOjI5CiAgICAgICAgcjQg PSAxCiAgICAgICAgcjcgPSAxMjM1NDgwMzU2NDEwMzIKICAgICAgICByNSA9IC0xCiAgICAgICAg cjggPSAyCiAgICAgICAgcjAgPSAxNjcKICAgICAgICByMyA9IDUxNgogICAgICAgIHI2ID0gMAog ICAgICAgIHNjX2VyciA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHNjX3JldCA9IDxvcHRpbWl6 ZWQgb3V0PgogICAgICAgIHNjX2NhbmNlbF9vbGR0eXBlID0gMAojMSAgMHgwMDAwNzA1ZGNkNGUx M2E4IGluIGdfcG9sbCAoKSBhdCAvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIu MC5zby4wCiMyICAweDAwMDA3MDVkY2Q0YzYxYTggaW4gICgpIGF0IC9saWIvcG93ZXJwYzY0bGUt bGludXgtZ251L2xpYmdsaWItMi4wLnNvLjAKIzMgIDB4MDAwMDcwNWRjZDRjNjdiYyBpbiBnX21h aW5fbG9vcF9ydW4gKCkgYXQgL2xpYi9wb3dlcnBjNjRsZS1saW51eC1nbnUvbGliZ2xpYi0yLjAu c28uMAojNCAgMHgwMDAwNzA1ZGNjYzNmOGE0IGluIFdURjo6UnVuTG9vcDo6cnVuKCkgKCkgYXQg Li4vU291cmNlL1dURi93dGYvZ2xpYi9SdW5Mb29wR0xpYi5jcHA6OTYKIzUgIDB4MDAwMDcwNWRj Y2MzYTBjMCBpbiBvcGVyYXRvcigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dlbmVyaWMvV29y a1F1ZXVlR2VuZXJpYy5jcHA6NDMKIzYgIGNhbGwoKSAoKSBhdCAuLi9Tb3VyY2UvV1RGL3d0Zi9G dW5jdGlvbi5oOjUyCiM3ICAweDAwMDA3MDVkY2NiYzUwMDAgaW4gV1RGOjpGdW5jdGlvbjx2b2lk ICgpPjo6b3BlcmF0b3IoKSgpIGNvbnN0ICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL0Z1bmN0aW9u Lmg6ODQKIzggIFdURjo6VGhyZWFkOjplbnRyeVBvaW50KFdURjo6VGhyZWFkOjpOZXdUaHJlYWRD b250ZXh0KikgKCkgYXQgLi4vU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmNwcDoxNDgKIzkgIDB4 MDAwMDcwNWRjY2M0MWIwOCBpbiB3dGZUaHJlYWRFbnRyeVBvaW50KCkgKCkgYXQgLi4vU291cmNl L1dURi93dGYvcG9zaXgvVGhyZWFkaW5nUE9TSVguY3BwOjIwMAojMTAgMHgwMDAwNzA1ZGNhNDY5 ODE4IGluIHN0YXJ0X3RocmVhZCAoYXJnPTB4NzA1ZGM0YzZlZGMwKSBhdCBwdGhyZWFkX2NyZWF0 ZS5jOjQ3NwogICAgICAgIHJldCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHBkID0gMHg3MDVk YzRjNmVkYzAKICAgICAgICB1bndpbmRfYnVmID0ge2NhbmNlbF9qbXBfYnVmID0ge3tqbXBfYnVm ID0gey01NjM1NTU3NDQ1MjI0ODc4MjcyLCAxMjM1NDgxMjgxNDkyNDgsIC01NjM1NTU3NDQ1NDUx MzU5Mzc2LCAxMjM1NDgxMjgxMzQxNjAsIDAsIDEyMzU0ODI2OTc0MDAzMiwgMTIzNTQ4MTI4MTE3 NTM2LCAxMjM1NDgwMzU2NDA5NjAsIDEyMzU0ODEyODEzNDE3NiwgMCwgMCwgNDI4MTk1OTg3NTc3 NiwgMTIzNTQ4MTY5NjczNDU2LCAxNDA3MzczNTAxNzMwNjQsIDEyMzU0ODAzNTY0MjY3MiwgMTIz NTQ4MDM1NjM4OTc2LCAxNDA3MzczNTAxNzMwNzIsIDE0MDczNzM1MDE3Mjc5OSwgMTIzNTQ4MDM1 NjQwNzY4LCAxMjM1NDgxMjc4OTMyOTYsIDEyMzU0ODAzNTYzODI0MCwgMjQ1MDAzMzUzNTMxMDg4 ODk1OSwgMCA8cmVwZWF0cyA0MiB0aW1lcz59LCBtYXNrX3dhc19zYXZlZCA9IDB9fSwgcHJpdiA9 IHtwYWQgPSB7MHgwLCAweDAsIDB4MCwgMHgwfSwgZGF0YSA9IHtwcmV2ID0gMHgwLCBjbGVhbnVw ID0gMHgwLCBjYW5jZWx0eXBlID0gMH19fQogICAgICAgIG5vdF9maXJzdF9jYWxsID0gPG9wdGlt aXplZCBvdXQ+CiMxMSAweDAwMDA3MDVkY2VhM2U4NjQgaW4gY2xvbmUgKCkgYXQgLi4vc3lzZGVw cy91bml4L3N5c3YvbGludXgvcG93ZXJwYy9wb3dlcnBjNjQvY2xvbmUuUzo4MgoKVGhyZWFkIDEg KFRocmVhZCAweDcwNWRjNTJjMzJlMCAoTFdQIDMwMDMyKSk6CiMwICAweDAwMDA3MDVkY2U5NDA0 NjggaW4gX19saWJjX3NpZ25hbF9yZXN0b3JlX3NldCAoc2V0PTB4N2ZmZmY3YzM2ZTE4KSBhdCAu Li9zeXNkZXBzL3VuaXgvc3lzdi9saW51eC9pbnRlcm5hbC1zaWduYWxzLmg6ODYKICAgICAgICBy NCA9IDE0MDczNzM1MDE2ODA4OAogICAgICAgIHI3ID0gMTIzNTQ4MjAwMDc2MzUyCiAgICAgICAg YXJnMiA9IDE0MDczNzM1MDE2ODA4OAogICAgICAgIHI1ID0gMAogICAgICAgIHI4ID0gLTkyMjMz NzIwMzY4MTI3NzEyNzcKICAgICAgICBhcmczID0gMAogICAgICAgIHIwID0gMTc0CiAgICAgICAg cjMgPSAwCiAgICAgICAgcjYgPSA4CiAgICAgICAgYXJnNCA9IDgKICAgICAgICBhcmcxID0gMgog ICAgICAgIGVyciA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHNldCA9IHtfX3ZhbCA9IHswLCAx MjM1NDgyMDIwNDQ2NzIsIDE2NDE2LCAxNDA3MzczNTAxNjgzMzYsIDEyMzU0NTMzODI1Nzk4Niwg MTIzNTQ4MjAwNDY4NTQ4LCAzNSwgMTQwNzM3MzUwMTY4MjA4LCAxNjQ0OCwgMTQwNzM3MzUwMTY4 MTkyLCAxMTksIDE0MDczNzM1MDE2ODM4NCwgMTIzNTQ4MTY5Nzg1MDU2LCAxNDA3MzczNTAxNjg0 MTYsIDAsIDB9fQogICAgICAgIGVyciA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHBpZCA9IDxv cHRpbWl6ZWQgb3V0PgogICAgICAgIHRpZCA9IDxvcHRpbWl6ZWQgb3V0PgojMSAgX19HSV9yYWlz ZSAoc2lnPTxvcHRpbWl6ZWQgb3V0PikgYXQgLi4vc3lzZGVwcy91bml4L3N5c3YvbGludXgvcmFp c2UuYzo0OAogICAgICAgIHNldCA9IHtfX3ZhbCA9IHswLCAxMjM1NDgyMDIwNDQ2NzIsIDE2NDE2 LCAxNDA3MzczNTAxNjgzMzYsIDEyMzU0NTMzODI1Nzk4NiwgMTIzNTQ4MjAwNDY4NTQ4LCAzNSwg MTQwNzM3MzUwMTY4MjA4LCAxNjQ0OCwgMTQwNzM3MzUwMTY4MTkyLCAxMTksIDE0MDczNzM1MDE2 ODM4NCwgMTIzNTQ4MTY5Nzg1MDU2LCAxNDA3MzczNTAxNjg0MTYsIDAsIDB9fQogICAgICAgIGVy ciA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAgIHBpZCA9IDxvcHRpbWl6ZWQgb3V0PgogICAgICAg IHRpZCA9IDxvcHRpbWl6ZWQgb3V0PgojMiAgMHgwMDAwNzA1ZGNlOTE3Y2QwIGluIF9fR0lfYWJv cnQgKCkgYXQgYWJvcnQuYzo3OQogICAgICAgIHNhdmVfc3RhZ2UgPSAxCiAgICAgICAgYWN0ID0g e19fc2lnYWN0aW9uX2hhbmRsZXIgPSB7c2FfaGFuZGxlciA9IDB4N2ZmZmY3YzM3MDAwLCBzYV9z aWdhY3Rpb24gPSAweDdmZmZmN2MzNzAwMH0sIHNhX21hc2sgPSB7X192YWwgPSB7MCwgMTIzNTQ4 MTMwODQ4ODY4LCAxMjM1NDgxMzIzOTkzNjAsIDE0MDczNzM1MDE2ODcwNCwgMTQwNzM3MzUwMTY4 NjQ4LCAxMjM1NDgxMjc5NDg0NDgsIDEyMzU0ODEyODE0OTI0OCwgMTQwNzM3MzUwMTY4NzY4LCAx NDA3MzczNTAxNjg2MzIsIDEyMzU0ODE2MDI0NTkwMCwgMTIzNTQ4MTI3OTQ3OTg0LCAxMjM1NDgx NzE4NjI2MzYsIDAsIDAsIDQ1NzEyOTA3ODg2OTc4MDg4OTYsIDE4NDQ2MTgxMTIzNzU2MTMwMzA0 fX0sIHNhX2ZsYWdzID0gLTEyMjY4Njk3Niwgc2FfcmVzdG9yZXIgPSAweDNlNGY4ZGRlODEwfQog ICAgICAgIHNpZ3MgPSB7X192YWwgPSB7MzIsIDAgPHJlcGVhdHMgMTUgdGltZXM+fX0KIzMgIDB4 MDAwMDcwNWRjYzhiZWVkNCBpbiBDUkFTSF9XSVRIX0lORk8oLi4uKSAoKSBhdCBEZXJpdmVkU291 cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvQXNzZXJ0aW9ucy5oOjY2MAojNCAgSlNDOjpDb25m aWc6OnBlcm1hbmVudGx5RnJlZXplKCkgKCkgYXQgLi4vU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSlNDQ29uZmlnLmNwcDo3OAojNSAgMHgwMDAwNzA1ZGNjYWYwZmQwIGluIEpTQzo6Vk06 OlZNKEpTQzo6Vk06OlZNVHlwZSwgSlNDOjpIZWFwVHlwZSkgKCkgYXQgLi4vU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvVk0uY3BwOjU4NgojNiAgMHgwMDAwNzA1ZGNjYWYyYWQ0IGluIEpT Qzo6Vk06OmNyZWF0ZShKU0M6OkhlYXBUeXBlKSAoKSBhdCAuLi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9WTS5jcHA6NzAzCiM3ICAweDAwMDA3MDVkZDA2ZDBiNDggaW4gV2ViQ29yZTo6 Y29tbW9uVk1TbG93KCkgKCkgYXQgLi4vU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvQ29tbW9u Vk0uY3BwOjU1CiM4ICAweDAwMDA3MDVkZDBlOWZlNzQgaW4gV2ViQ29yZTo6Y29tbW9uVk0oKSAo KSBhdCAuLi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9Db21tb25WTS5oOjUyCiM5ICBXZWJD b3JlOjpQYWdlU2NyaXB0RGVidWdTZXJ2ZXI6OlBhZ2VTY3JpcHREZWJ1Z1NlcnZlcihXZWJDb3Jl OjpQYWdlJikgKCkgYXQgLi4vU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL1BhZ2VTY3JpcHREZWJ1 Z1NlcnZlci5jcHA6NTgKIzEwIDB4MDAwMDcwNWRkMGU4NzU0OCBpbiBXZWJDb3JlOjpJbnNwZWN0 b3JDb250cm9sbGVyOjpJbnNwZWN0b3JDb250cm9sbGVyKFdlYkNvcmU6OlBhZ2UmLCBXZWJDb3Jl OjpJbnNwZWN0b3JDbGllbnQqKSAoKSBhdCAuLi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvSW5z cGVjdG9yQ29udHJvbGxlci5jcHA6MTA1CiMxMSAweDAwMDA3MDVkZDExNmUyNTQgaW4gc3RkOjpt YWtlX3VuaXF1ZTxXZWJDb3JlOjpJbnNwZWN0b3JDb250cm9sbGVyLCBXZWJDb3JlOjpQYWdlJiwg V2ViQ29yZTo6SW5zcGVjdG9yQ2xpZW50KiY+KFdlYkNvcmU6OlBhZ2UmLCBXZWJDb3JlOjpJbnNw ZWN0b3JDbGllbnQqJikgKCkgYXQgL3Vzci9pbmNsdWRlL2MrKy85L2JpdHMvdW5pcXVlX3B0ci5o Ojg1NwojMTIgV1RGOjptYWtlVW5pcXVlPFdlYkNvcmU6Okluc3BlY3RvckNvbnRyb2xsZXIsIFdl YkNvcmU6OlBhZ2UmLCBXZWJDb3JlOjpJbnNwZWN0b3JDbGllbnQqJj4oV2ViQ29yZTo6UGFnZSYs IFdlYkNvcmU6Okluc3BlY3RvckNsaWVudComKSAoKSBhdCBEZXJpdmVkU291cmNlcy9Gb3J3YXJk aW5nSGVhZGVycy93dGYvU3RkTGliRXh0cmFzLmg6NDgzCiMxMyBXZWJDb3JlOjpQYWdlOjpQYWdl KFdlYkNvcmU6OlBhZ2VDb25maWd1cmF0aW9uJiYpICgpIGF0IC4uL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGFnZS5jcHA6Mjc5CiMxNCAweDAwMDA3MDVkY2ZiZGY0ZjggaW4gc3RkOjptYWtlX3VuaXF1 ZTxXZWJDb3JlOjpQYWdlLCBXZWJDb3JlOjpQYWdlQ29uZmlndXJhdGlvbj4oV2ViQ29yZTo6UGFn ZUNvbmZpZ3VyYXRpb24mJikgKCkgYXQgL3Vzci9pbmNsdWRlL2MrKy85L2JpdHMvdW5pcXVlX3B0 ci5oOjg1NwojMTUgV1RGOjptYWtlVW5pcXVlPFdlYkNvcmU6OlBhZ2UsIFdlYkNvcmU6OlBhZ2VD b25maWd1cmF0aW9uPihXZWJDb3JlOjpQYWdlQ29uZmlndXJhdGlvbiYmKSAoKSBhdCBEZXJpdmVk U291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvU3RkTGliRXh0cmFzLmg6NDgzCiMxNiBXZWJL aXQ6OldlYlBhZ2U6OldlYlBhZ2UoV1RGOjpPYmplY3RJZGVudGlmaWVyPFdlYkNvcmU6OlBhZ2VJ ZGVudGlmaWVyVHlwZT4sIFdlYktpdDo6V2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycyYmKSAoKSBh dCAuLi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcDo1MzYKIzE3 IDB4MDAwMDcwNWRjZmJlMDI1NCBpbiBXZWJLaXQ6OldlYlBhZ2U6OmNyZWF0ZShXVEY6Ok9iamVj dElkZW50aWZpZXI8V2ViQ29yZTo6UGFnZUlkZW50aWZpZXJUeXBlPiwgV2ViS2l0OjpXZWJQYWdl Q3JlYXRpb25QYXJhbWV0ZXJzJiYpICgpIGF0IC4uL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9X ZWJQYWdlL1dlYlBhZ2UuY3BwOjM3OQojMTggMHgwMDAwNzA1ZGNmOTk0YWQ4IGluIFdlYktpdDo6 V2ViUHJvY2Vzczo6Y3JlYXRlV2ViUGFnZShXVEY6Ok9iamVjdElkZW50aWZpZXI8V2ViQ29yZTo6 UGFnZUlkZW50aWZpZXJUeXBlPiwgV2ViS2l0OjpXZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzJiYp ICgpIGF0IC4uL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcDo2ODUKIzE5 IDB4MDAwMDcwNWRjZjQzNGUwOCBpbiBJUEM6OmNhbGxNZW1iZXJGdW5jdGlvbkltcGw8V2ViS2l0 OjpXZWJQcm9jZXNzLCB2b2lkIChXZWJLaXQ6OldlYlByb2Nlc3M6OiopKFdURjo6T2JqZWN0SWRl bnRpZmllcjxXZWJDb3JlOjpQYWdlSWRlbnRpZmllclR5cGU+LCBXZWJLaXQ6OldlYlBhZ2VDcmVh dGlvblBhcmFtZXRlcnMmJiksIHN0ZDo6dHVwbGU8V1RGOjpPYmplY3RJZGVudGlmaWVyPFdlYkNv cmU6OlBhZ2VJZGVudGlmaWVyVHlwZT4sIFdlYktpdDo6V2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVy cz4sIDB1bCwgMXVsPihXZWJLaXQ6OldlYlByb2Nlc3MqLCB2b2lkIChXZWJLaXQ6OldlYlByb2Nl c3M6OiopKFdURjo6T2JqZWN0SWRlbnRpZmllcjxXZWJDb3JlOjpQYWdlSWRlbnRpZmllclR5cGU+ LCBXZWJLaXQ6OldlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMmJiksIHN0ZDo6dHVwbGU8V1RGOjpP YmplY3RJZGVudGlmaWVyPFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyVHlwZT4sIFdlYktpdDo6V2Vi UGFnZUNyZWF0aW9uUGFyYW1ldGVycz4mJiwgc3RkOjppbnRlZ2VyX3NlcXVlbmNlPHVuc2lnbmVk IGxvbmcsIDB1bCwgMXVsPikgKCkgYXQgLi4vU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvSGFu ZGxlTWVzc2FnZS5oOjQxCiMyMCBJUEM6OmNhbGxNZW1iZXJGdW5jdGlvbjxXZWJLaXQ6OldlYlBy b2Nlc3MsIHZvaWQgKFdlYktpdDo6V2ViUHJvY2Vzczo6KikoV1RGOjpPYmplY3RJZGVudGlmaWVy PFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyVHlwZT4sIFdlYktpdDo6V2ViUGFnZUNyZWF0aW9uUGFy YW1ldGVycyYmKSwgc3RkOjp0dXBsZTxXVEY6Ok9iamVjdElkZW50aWZpZXI8V2ViQ29yZTo6UGFn ZUlkZW50aWZpZXJUeXBlPiwgV2ViS2l0OjpXZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzPiwgc3Rk OjppbnRlZ2VyX3NlcXVlbmNlPHVuc2lnbmVkIGxvbmcsIDB1bCwgMXVsPiA+KHN0ZDo6dHVwbGU8 V1RGOjpPYmplY3RJZGVudGlmaWVyPFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyVHlwZT4sIFdlYktp dDo6V2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycz4mJiwgV2ViS2l0OjpXZWJQcm9jZXNzKiwgdm9p ZCAoV2ViS2l0OjpXZWJQcm9jZXNzOjoqKShXVEY6Ok9iamVjdElkZW50aWZpZXI8V2ViQ29yZTo6 UGFnZUlkZW50aWZpZXJUeXBlPiwgV2ViS2l0OjpXZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzJiYp KSAoKSBhdCAuLi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9IYW5kbGVNZXNzYWdlLmg6NDcK IzIxIElQQzo6aGFuZGxlTWVzc2FnZTxNZXNzYWdlczo6V2ViUHJvY2Vzczo6Q3JlYXRlV2ViUGFn ZSwgV2ViS2l0OjpXZWJQcm9jZXNzLCB2b2lkIChXZWJLaXQ6OldlYlByb2Nlc3M6OiopKFdURjo6 T2JqZWN0SWRlbnRpZmllcjxXZWJDb3JlOjpQYWdlSWRlbnRpZmllclR5cGU+LCBXZWJLaXQ6Oldl YlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMmJik+KElQQzo6RGVjb2RlciYsIFdlYktpdDo6V2ViUHJv Y2VzcyosIHZvaWQgKFdlYktpdDo6V2ViUHJvY2Vzczo6KikoV1RGOjpPYmplY3RJZGVudGlmaWVy PFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyVHlwZT4sIFdlYktpdDo6V2ViUGFnZUNyZWF0aW9uUGFy YW1ldGVycyYmKSkgKCkgYXQgLi4vU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvSGFuZGxlTWVz c2FnZS5oOjEyMAojMjIgMHgwMDAwNzA1ZGNmNDJhYjE0IGluIFdlYktpdDo6V2ViUHJvY2Vzczo6 ZGlkUmVjZWl2ZVdlYlByb2Nlc3NNZXNzYWdlKElQQzo6Q29ubmVjdGlvbiYsIElQQzo6RGVjb2Rl ciYpICgpIGF0IERlcml2ZWRTb3VyY2VzL1dlYktpdC9XZWJQcm9jZXNzTWVzc2FnZVJlY2VpdmVy LmNwcDoyOTEKIzIzIDB4MDAwMDcwNWRjZjk5Y2UxYyBpbiBXZWJLaXQ6OldlYlByb2Nlc3M6OmRp ZFJlY2VpdmVNZXNzYWdlKElQQzo6Q29ubmVjdGlvbiYsIElQQzo6RGVjb2RlciYpICgpIGF0IC4u L1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcDo3NTAKIzI0IFdlYktpdDo6 V2ViUHJvY2Vzczo6ZGlkUmVjZWl2ZU1lc3NhZ2UoSVBDOjpDb25uZWN0aW9uJiwgSVBDOjpEZWNv ZGVyJikgKCkgYXQgLi4vU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwOjc0 NAojMjUgMHgwMDAwNzA1ZGNmNWYxMjk4IGluIElQQzo6Q29ubmVjdGlvbjo6ZGlzcGF0Y2hNZXNz YWdlKElQQzo6RGVjb2RlciYpICgpIGF0IC4uL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL0Nv bm5lY3Rpb24uY3BwOjEwMDgKIzI2IDB4MDAwMDcwNWRjZjVmMzAxNCBpbiBJUEM6OkNvbm5lY3Rp b246OmRpc3BhdGNoTWVzc2FnZShzdGQ6OnVuaXF1ZV9wdHI8SVBDOjpEZWNvZGVyLCBzdGQ6OmRl ZmF1bHRfZGVsZXRlPElQQzo6RGVjb2Rlcj4gPikgKCkgYXQgLi4vU291cmNlL1dlYktpdC9QbGF0 Zm9ybS9JUEMvQ29ubmVjdGlvbi5jcHA6MTA3NwojMjcgMHgwMDAwNzA1ZGNmNWYzOWU0IGluIElQ Qzo6Q29ubmVjdGlvbjo6ZGlzcGF0Y2hPbmVJbmNvbWluZ01lc3NhZ2UoKSAoKSBhdCAuLi9Tb3Vy Y2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9Db25uZWN0aW9uLmNwcDoxMTQ2CiMyOCAweDAwMDA3MDVk Y2Y1ZjNmMzQgaW4gb3BlcmF0b3IoKSAoKSBhdCAuLi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQ Qy9Db25uZWN0aW9uLmNwcDo5ODUKIzI5IGNhbGwoKSAoKSBhdCBEZXJpdmVkU291cmNlcy9Gb3J3 YXJkaW5nSGVhZGVycy93dGYvRnVuY3Rpb24uaDo1MgojMzAgMHgwMDAwNzA1ZGNjYmMyNmY4IGlu IFdURjo6RnVuY3Rpb248dm9pZCAoKT46Om9wZXJhdG9yKCkoKSBjb25zdCAoKSBhdCAuLi9Tb3Vy Y2UvV1RGL3d0Zi9GdW5jdGlvbi5oOjg0CiMzMSBXVEY6OlJ1bkxvb3A6OnBlcmZvcm1Xb3JrKCkg KCkgYXQgLi4vU291cmNlL1dURi93dGYvUnVuTG9vcC5jcHA6MTI0CiMzMiAweDAwMDA3MDVkY2Nj M2U1ZTggaW4gb3BlcmF0b3IoKSAoKSBhdCAuLi9Tb3VyY2UvV1RGL3d0Zi9nbGliL1J1bkxvb3BH TGliLmNwcDo2OAojMzMgX0ZVTigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dsaWIvUnVuTG9v cEdMaWIuY3BwOjcwCiMzNCAweDAwMDA3MDVkY2NjM2U2NzAgaW4gb3BlcmF0b3IoKSAoKSBhdCAu Li9Tb3VyY2UvV1RGL3d0Zi9nbGliL1J1bkxvb3BHTGliLmNwcDo0NQojMzUgX0ZVTigpICgpIGF0 IC4uL1NvdXJjZS9XVEYvd3RmL2dsaWIvUnVuTG9vcEdMaWIuY3BwOjQ2CiMzNiAweDAwMDA3MDVk Y2Q0YzVkMTQgaW4gZ19tYWluX2NvbnRleHRfZGlzcGF0Y2ggKCkgYXQgL2xpYi9wb3dlcnBjNjRs ZS1saW51eC1nbnUvbGliZ2xpYi0yLjAuc28uMAojMzcgMHgwMDAwNzA1ZGNkNGM2MjU4IGluICAo KSBhdCAvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS9saWJnbGliLTIuMC5zby4wCiMzOCAweDAw MDA3MDVkY2Q0YzY3YmMgaW4gZ19tYWluX2xvb3BfcnVuICgpIGF0IC9saWIvcG93ZXJwYzY0bGUt bGludXgtZ251L2xpYmdsaWItMi4wLnNvLjAKIzM5IDB4MDAwMDcwNWRjY2MzZjhhNCBpbiBXVEY6 OlJ1bkxvb3A6OnJ1bigpICgpIGF0IC4uL1NvdXJjZS9XVEYvd3RmL2dsaWIvUnVuTG9vcEdMaWIu Y3BwOjk2CiM0MCAweDAwMDA3MDVkY2ZjMTdkMjQgaW4gV2ViS2l0OjpBdXhpbGlhcnlQcm9jZXNz TWFpbjxXZWJLaXQ6OldlYlByb2Nlc3MsIFdlYktpdDo6V2ViUHJvY2Vzc01haW5HdGs+KGludCwg Y2hhcioqKSAoKSBhdCAuLi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9BdXhpbGlhcnlQcm9jZXNzTWFp bi5oOjY4CiM0MSBXZWJLaXQ6OldlYlByb2Nlc3NNYWluKGludCwgY2hhcioqKSAoKSBhdCAuLi9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvZ3RrL1dlYlByb2Nlc3NNYWluR3RrLmNwcDo2OAojNDIg MHgwMDAwMDNlNGY0YjYwN2MwIGluIG1haW4oKSAoKSBhdCAuLi9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvRW50cnlQb2ludC91bml4L1dlYlByb2Nlc3NNYWluLmNwcDo0NQpxdWl0CkRldGFjaGlu ZyBmcm9tIHByb2dyYW06IC91c3IvbGliL3Bvd2VycGM2NGxlLWxpbnV4LWdudS93ZWJraXQyZ3Rr LTQuMC9XZWJLaXRXZWJQcm9jZXNzLCBwcm9jZXNzIDMwMDMyCltJbmZlcmlvciAxIChwcm9jZXNz IDMwMDMyKSBkZXRhY2hlZF0K 394053 2020-03-19 18:28:39 -0700 2020-03-20 08:48:17 -0700 Patch bug-209236-20200319202838.patch text/plain 7501 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NzAxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA3 YzEwZWU4YTQ2YmVlOTEzZWIxMTI5ZTVhMzNiY2UwYjk3ZGRiYmQ0Li5jMzI0YmVjMDU3NzMzNjY0 YTc1YmYyMjMzYzRjZDI5YTk1ODRlODZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0xOSAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMTkgIENo YXJsaWUgVHVybmVyICA8Y3R1cm5lckBpZ2FsaWEuY29tPgogCiAgICAgICAgIEZpeCBtYW55IHdh cm5pbmdzIHdpdGggQ2xhbmcgNy4wIG9uIEdUSyB4ODYtNjQgaW4gRGVidWcuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDYzMjFm ODhlNjMwOWViNGUzYmU3MjcxY2RhOWE1OTQwNTdhNDEyYjYuLjAxOTUwYzQwNDVmMDExYTZiYTI3 YjJjMGZhNGM3NTkzODg4MTNhYjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDMtMTkgIE1p Y2hhZWwgQ2F0YW56YXJvICA8bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVT U0lPTihyMjQ5ODA4KTogW0dUS10gQ3Jhc2ggaW4gSlNDIENvbmZpZzo6cGVybWFuZW50bHlGcmVl emUoKSBvbiBhcmNoaXRlY3R1cmUgcHBjNjRlbAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA5MjM2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQWRkIG5ldyBDZWlsaW5nT25QYWdlU2l6ZSBjb25zdGFudHMs IGZvciB1c2UgaW4gSlNDLCBpbiBvcmRlciB0byBjZW50cmFsaXplIG91ciBjb21waWxlLXRpbWUK KyAgICAgICAgcGFnZSBzaXplIGd1ZXNzaW5nIGludG8gb25lIHBsYWNlLiBJbXByb3ZlIHRoZSBp bXBsZW1lbnRhdGlvbiBvZiBwYWdlU2l6ZSgpIHRvCisgICAgICAgIFJFTEVBU0VfQVNTRVJUKCkg d2hlbiBDZWlsaW5nT25QYWdlU2l6ZSBpcyB3cm9uZywgc28gd2UgY2FuIGRldGVjdCBhbmQgZml4 IGl0IGlmIHNvLiAoSXQKKyAgICAgICAgd2lsbCBiZSBldmVuIGVhc2llciB0byBkZXRlY3QgaWYg d2UgY2hhbmdlIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIHRvIGFjdHVhbGx5IHByaW50 CisgICAgICAgIGl0cyBtZXNzYWdlIGluIHJlbGVhc2UgYnVpbGRzLikgQ2hhbmdlIHBhZ2VTaXpl KCkgdG8gdXNlIHN5c2NvbmYoX1NDX1BBR0VTSVpFKSwgd2hpY2ggaXMKKyAgICAgICAgc3BlY2lm aWVkIGJ5IFBPU0lYLCBpbnN0ZWFkIG9mIGdldHBhZ2VzaXplKCksIHdoaWNoIGlzIG5vbnN0YW5k YXJkLgorCisgICAgICAgICogd3RmL1BhZ2VCbG9jay5jcHA6CisgICAgICAgIChXVEY6OnN5c3Rl bVBhZ2VTaXplKToKKyAgICAgICAgKFdURjo6cGFnZVNpemUpOgorICAgICAgICAqIHd0Zi9QYWdl QmxvY2suaDoKKwogMjAyMC0wMy0xOSAgQ2hhcmxpZSBUdXJuZXIgIDxjdHVybmVyQGlnYWxpYS5j b20+CiAKICAgICAgICAgRml4IG1hbnkgd2FybmluZ3Mgd2l0aCBDbGFuZyA3LjAgb24gR1RLIHg4 Ni02NCBpbiBEZWJ1Zy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01h cmtlZEJsb2NrLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCmlu ZGV4IGU4MDRlMWJkN2JlZjk5NmJjZGNhYzM2NGNkNTEyOWExMDYxYmQ1ZmYuLmFkMTZhNGJkNmJl N2M1ZTljNmJlMTRmNTI0N2Y4YTQzNDliNzA3NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hl YXAvTWFya2VkQmxvY2suaApAQCAtMjYsMTAgKzI2LDEyIEBACiAjaW5jbHVkZSAiSGVhcENlbGwu aCIKICNpbmNsdWRlICJJdGVyYXRpb25TdGF0dXMuaCIKICNpbmNsdWRlICJXZWFrU2V0LmgiCisj aW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUgPHd0Zi9BdG9taWNzLmg+CiAjaW5jbHVkZSA8 d3RmL0JpdG1hcC5oPgotI2luY2x1ZGUgPHd0Zi9IYXNoRnVuY3Rpb25zLmg+CiAjaW5jbHVkZSA8 d3RmL0NvdW50aW5nTG9jay5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoRnVuY3Rpb25zLmg+CisjaW5j bHVkZSA8d3RmL1BhZ2VCbG9jay5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAog bmFtZXNwYWNlIEpTQyB7CkBAIC03MCwxMSArNzIsNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGNv bnN0ZXhwciBzaXplX3QgYXRvbVNpemUgPSAxNjsgLy8gYnl0ZXMKIAogICAgIC8vIEJsb2NrIHNp emUgbXVzdCBiZSBhdCBsZWFzdCBhcyBsYXJnZSBhcyB0aGUgc3lzdGVtIHBhZ2Ugc2l6ZS4KLSNp ZiBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8fCBDUFUoUFBDKSB8fCBDUFUoVU5LTk9XTikK LSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja1NpemUgPSA2NCAqIEtCOwotI2Vsc2UK LSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja1NpemUgPSAxNiAqIEtCOwotI2VuZGlm CisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gc3RkOjptYXgoMTYgKiBL QiwgQ2VpbGluZ09uUGFnZVNpemUpOwogCiAgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxv Y2tNYXNrID0gfihibG9ja1NpemUgLSAxKTsgLy8gYmxvY2tTaXplIG11c3QgYmUgYSBwb3dlciBv ZiB0d28uCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0Nv bmZpZy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3BwCmlu ZGV4IDc5Y2MyYjY3YmE5MDUwNDFiZTkzM2Q3YTI1M2IxMjc1NDViNzZiYjkuLjZmZGIzZWUwMGU1 OWM1M2Y2ODdmZGY1OTJjYTkyZjQ2N2I5NGQwYTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvSlNDQ29uZmlnLmNwcApAQCAtNTMsOSArNTMsNyBAQCB2b2lkIENvbmZpZzo6ZW5h YmxlUmVzdHJpY3RlZE9wdGlvbnMoKQogICAgIAogdm9pZCBDb25maWc6OnBlcm1hbmVudGx5RnJl ZXplKCkKIHsKLSNpZiBQTEFURk9STShDT0NPQSkKLSAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVw VG9NdWx0aXBsZU9mKHZtUGFnZVNpemUoKSwgQ29uZmlnU2l6ZVRvUHJvdGVjdCkgPT0gQ29uZmln U2l6ZVRvUHJvdGVjdCk7Ci0jZW5kaWYKKyAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0 aXBsZU9mKHBhZ2VTaXplKCksIENvbmZpZ1NpemVUb1Byb3RlY3QpID09IENvbmZpZ1NpemVUb1By b3RlY3QpOwogCiAgICAgaWYgKCFnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuKQogICAg ICAgICBnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuID0gdHJ1ZTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKaW5kZXggMWFlNTNhNTY0MzFhNTk4NGY0OTk1 YmUxODFjYjZkYmMxMmNhZTc2Yi4uYWE5YmZlNmM2MTg0NDIwZTYyYWY2NDdlODJiMzllMTZjMjU5 NWJhZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmln LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKQEAgLTI2 LDYgKzI2LDcgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSAiT3B0aW9uc0xpc3QuaCIKKyNp bmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgog CiBuYW1lc3BhY2UgSlNDIHsKQEAgLTM0LDExICszNSw3IEBAIGNsYXNzIEV4ZWN1dGFibGVBbGxv Y2F0b3I7CiBjbGFzcyBGaXhlZFZNUG9vbEV4ZWN1dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBWTTsK IAotI2lmICFPUyhXSU5ET1dTKQotY29uc3RleHByIHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0 ID0gMTYgKiBLQjsKLSNlbHNlCi1jb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVUb1Byb3RlY3Qg PSA0ICogS0I7Ci0jZW5kaWYKK2NvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6ZVRvUHJvdGVjdCA9 IENlaWxpbmdPblBhZ2VTaXplOwogCiAjaWYgRU5BQkxFKFNFUEFSQVRFRF9XWF9IRUFQKQogdXNp bmcgSklUV3JpdGVTZXBhcmF0ZUhlYXBzRnVuY3Rpb24gPSB2b2lkICgqKShvZmZfdCwgY29uc3Qg dm9pZCosIHNpemVfdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3Bw IGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNwcAppbmRleCAzNzM4MWIyZTUyMjg3NTQ0ZGUy YjNkZDBlMzk4ZWFjZjIxNTE4MzIwLi41ZDBhY2FkZDRiMWYyZTA0NDJkOWEzZjEzYmU2ZDQwN2I1 ZDFjOTNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwCisrKyBiL1Nv dXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKQEAgLTQ0LDcgKzQ0LDcgQEAgc3RhdGljIHNpemVf dCBzX3BhZ2VNYXNrOwogCiBpbmxpbmUgc2l6ZV90IHN5c3RlbVBhZ2VTaXplKCkKIHsKLSAgICBy ZXR1cm4gZ2V0cGFnZXNpemUoKTsKKyAgICByZXR1cm4gc3lzY29uZihfU0NfUEFHRVNJWkUpOwog fQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtNjIsOSArNjIsMTEgQEAgaW5saW5lIHNpemVfdCBz eXN0ZW1QYWdlU2l6ZSgpCiAKIHNpemVfdCBwYWdlU2l6ZSgpCiB7Ci0gICAgaWYgKCFzX3BhZ2VT aXplKQorICAgIGlmICghc19wYWdlU2l6ZSkgewogICAgICAgICBzX3BhZ2VTaXplID0gc3lzdGVt UGFnZVNpemUoKTsKLSAgICBBU1NFUlQoaXNQb3dlck9mVHdvKHNfcGFnZVNpemUpKTsKKyAgICAg ICAgUkVMRUFTRV9BU1NFUlQoaXNQb3dlck9mVHdvKHNfcGFnZVNpemUpKTsKKyAgICAgICAgUkVM RUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKHNfcGFnZVNpemUgPD0gQ2VpbGluZ09uUGFnZVNpemUs ICJDZWlsaW5nT25QYWdlU2l6ZSBpcyB0b28gbG93LCByYWlzZSBpdCBpbiBQYWdlQmxvY2suaCEi KTsKKyAgICB9CiAgICAgcmV0dXJuIHNfcGFnZVNpemU7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKaW5kZXgg YjUyYzM5ZTBiMTAxZDNlNDdlNTkzMDRmYTI4N2ZhM2I3YWE3ZTUxNi4uZDc4NDE4MGRkZDE5MzNk NDUzNjY4NGY2ZGJhZmMxMDExM2YzNzljYyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFn ZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKQEAgLTI1LDggKzI1LDMz IEBACiAKICNwcmFnbWEgb25jZQogCisjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorCiBu YW1lc3BhY2UgV1RGIHsKIAorLy8gV2UgYXR0ZW1wdCB0byBndWVzcyBhIHZhbHVlIHRoYXQgaXMg KkFUIExFQVNUKiBhcyBsYXJnZSBhcyB0aGUgc3lzdGVtJ3MgYWN0dWFsIHBhZ2Ugc2l6ZS4KKy8v IFRoaXMgaXMgaW1wb3NzaWJsZSB0byBkbyBjb3JyZWN0bHkgYXQgYnVpbGQgdGltZSwgYnV0IEpT QyByZWFsbHkgbmVlZHMgaXQgYXQgYnVpbGQgdGltZSwgc28KKy8vIHdlIGhhdmUgYSBSRUxFQVNF X0FTU0VSVCgpIGluc2lkZSBXVEY6OnBhZ2VTaXplIHRvIG1ha2Ugc3VyZSBpdCBpcyBzZXQgcHJv cGVybHkgYXQgcnVudGltZS4KKy8vIEFsbCBvZiB0aGVzZSB2YWx1ZXMgYXJlIGdvaW5nIHRvIGJl IGluY29ycmVjdCBvbiBzeXN0ZW1zIGNvbmZpZ3VyZWQgdG8gdXNlIGxhcmdlciB0aGFuIG5vcm1h bAorLy8gcGFnZSBzaXplLCBzbyBvbiBzdWNoIHN5c3RlbXMgaXQgaXMgZXhwZWN0ZWQgdGhhdCBX ZWJLaXQgd2lsbCBjcmFzaCB1bnRpbCB0aGlzIHZhbHVlIGlzIGNoYW5nZWQKKy8vIGFuZCByZWNv bXBpbGVkLiBTb3JyeS4KKy8vCisvLyBNb3N0IG1hY09TLCBMaW51eCwgYW5kIFdpbmRvd3Mgc3lz dGVtcyB1c2UgYSBwYWdlIHNpemUgb2YgNCBLaUIuCisvLworLy8gT24gTGludXgsIFBvd2VyIHN5 c3RlbXMgbm9ybWFsbHkgdXNlIDY0IEtpQiBwYWdlcy4KKy8vCisvLyBhYXJjaDY0IHN5c3RlbXMg c2VlbSB0byBiZSBhbGwgb3ZlciB0aGUgcGxhY2UuIE1vc3QgTGludXggZGlzdHJvcyB1c2UgNCBL aUIsIGJ1dCBSSEVMIHVzZXMKKy8vIDY0IEtpQi4gaU9TIHVzZXMgMTYgS2lCLgorLy8KKy8vIFVz ZSA2NCBLaUIgZm9yIGFueSB1bmtub3duIENQVXMgdG8gYmUgY29uc2VydmF0aXZlLgorI2lmIENQ VShVTktOT1dOKSB8fCBDUFUoUFBDKSB8fCAoQ1BVKEFSTTY0KSAmJiAhUExBVEZPUk0oSU9TX0ZB TUlMWSkpCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0gNjQgKiBLQjsKKyNl bGlmIFBMQVRGT1JNKElPU19GQU1JTFkpCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VT aXplID0gMTYgKiBLQjsKKyNlbHNlCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXpl ID0gNCAqIEtCOworI2VuZGlmCisKIFdURl9FWFBPUlRfUFJJVkFURSBzaXplX3QgcGFnZVNpemUo KTsKIFdURl9FWFBPUlRfUFJJVkFURSBzaXplX3QgcGFnZU1hc2soKTsKIGlubGluZSBib29sIGlz UGFnZUFsaWduZWQodm9pZCogYWRkcmVzcykgeyByZXR1cm4gIShyZWludGVycHJldF9jYXN0PGlu dHB0cl90PihhZGRyZXNzKSAmIChwYWdlU2l6ZSgpIC0gMSkpOyB9CkBAIC04MCw2ICsxMDUsNyBA QCBpbmxpbmUgUGFnZUJsb2NrOjpQYWdlQmxvY2sodm9pZCogYmFzZSwgc2l6ZV90IHNpemUsIGJv b2wgaGFzR3VhcmRQYWdlcykKIAogfSAvLyBuYW1lc3BhY2UgV1RGCiAKK3VzaW5nIFdURjo6Q2Vp bGluZ09uUGFnZVNpemU7CiB1c2luZyBXVEY6OnBhZ2VTaXplOwogdXNpbmcgV1RGOjppc1BhZ2VB bGlnbmVkOwogdXNpbmcgV1RGOjppc1Bvd2VyT2ZUd287Cg== 394085 2020-03-20 08:48:20 -0700 2020-03-20 09:00:32 -0700 Patch bug-209236-20200320104820.patch text/plain 7725 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NzYyCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA3 NDhlOGM2ZWUyZWQzYmZmOTAzYjJkMDhmNjFmMTRjYmEyMjVhNGMyLi4zMjBmNWE1MjljMDkwYWMz MmI2YzMyOWJkOTEzYTJiN2ZjOTgzOWI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0yMCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMTkgIFRp bSBIb3J0b24gIDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgVXBzdHJlYW0g YSB2YXJpZXR5IG9mIENvY29hLXBsYXRmb3JtIEhBVkUgYW5kIEVOQUJMRSBtYWNyb3MKZGlmZiAt LWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKaW5kZXgg ZTQzNTBiNDgyZDYxNmYwMzlhYWY0MzM1NmZjYTliMTE2ZjdmYjRjNy4uOTJhYWQzMTBkZGQ2NWU5 Y2ViNmY2Y2MzNzQ0NTRkM2Q0NzNiYTkyZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAyMC0wMy0y MCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAgICAgICBS RUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBKU0MgQ29uZmlnOjpwZXJtYW5lbnRs eUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgbmV3IENlaWxpbmdPblBhZ2VTaXplIGNvbnN0 YW50cywgZm9yIHVzZSBpbiBKU0MsIGluIG9yZGVyIHRvIGNlbnRyYWxpemUgb3VyIGNvbXBpbGUt dGltZQorICAgICAgICBwYWdlIHNpemUgZ3Vlc3NpbmcgaW50byBvbmUgcGxhY2UuIEltcHJvdmUg dGhlIGltcGxlbWVudGF0aW9uIG9mIHBhZ2VTaXplKCkgdG8KKyAgICAgICAgUkVMRUFTRV9BU1NF UlQoKSB3aGVuIENlaWxpbmdPblBhZ2VTaXplIGlzIHdyb25nLCBzbyB3ZSBjYW4gZGV0ZWN0IGFu ZCBmaXggaXQgaWYgc28uIChJdAorICAgICAgICB3aWxsIGJlIGV2ZW4gZWFzaWVyIHRvIGRldGVj dCBpZiB3ZSBjaGFuZ2UgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCkgdG8gYWN0dWFsbHkg cHJpbnQKKyAgICAgICAgaXRzIG1lc3NhZ2UgaW4gcmVsZWFzZSBidWlsZHMuKSBDaGFuZ2UgcGFn ZVNpemUoKSB0byB1c2Ugc3lzY29uZihfU0NfUEFHRVNJWkUpLCB3aGljaCBpcworICAgICAgICBz cGVjaWZpZWQgYnkgUE9TSVgsIGluc3RlYWQgb2YgZ2V0cGFnZXNpemUoKSwgd2hpY2ggaXMgbm9u c3RhbmRhcmQuCisKKyAgICAgICAgKiB3dGYvUGFnZUJsb2NrLmNwcDoKKyAgICAgICAgKFdURjo6 c3lzdGVtUGFnZVNpemUpOgorICAgICAgICAoV1RGOjpwYWdlU2l6ZSk6CisgICAgICAgICogd3Rm L1BhZ2VCbG9jay5oOgorCiAyMDIwLTAzLTE5ICBUaW0gSG9ydG9uICA8dGltb3RoeV9ob3J0b25A YXBwbGUuY29tPgogCiAgICAgICAgIFVwc3RyZWFtIGEgdmFyaWV0eSBvZiBDb2NvYS1wbGF0Zm9y bSBIQVZFIGFuZCBFTkFCTEUgbWFjcm9zCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvaGVhcC9NYXJrZWRCbG9jay5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2Vk QmxvY2suaAppbmRleCBlODA0ZTFiZDdiZWY5OTZiY2RjYWMzNjRjZDUxMjlhMTA2MWJkNWZmLi5h ZDE2YTRiZDZiZTdjNWU5YzZiZTE0ZjUyNDdmOGE0MzQ5YjcwNzc3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKQEAgLTI2LDEwICsyNiwxMiBAQAogI2luY2x1ZGUg IkhlYXBDZWxsLmgiCiAjaW5jbHVkZSAiSXRlcmF0aW9uU3RhdHVzLmgiCiAjaW5jbHVkZSAiV2Vh a1NldC5oIgorI2luY2x1ZGUgPGFsZ29yaXRobT4KICNpbmNsdWRlIDx3dGYvQXRvbWljcy5oPgog I2luY2x1ZGUgPHd0Zi9CaXRtYXAuaD4KLSNpbmNsdWRlIDx3dGYvSGFzaEZ1bmN0aW9ucy5oPgog I2luY2x1ZGUgPHd0Zi9Db3VudGluZ0xvY2suaD4KKyNpbmNsdWRlIDx3dGYvSGFzaEZ1bmN0aW9u cy5oPgorI2luY2x1ZGUgPHd0Zi9QYWdlQmxvY2suaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0 cmFzLmg+CiAKIG5hbWVzcGFjZSBKU0MgewpAQCAtNzAsMTEgKzcyLDcgQEAgcHVibGljOgogICAg IHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGF0b21TaXplID0gMTY7IC8vIGJ5dGVzCiAKICAgICAv LyBCbG9jayBzaXplIG11c3QgYmUgYXQgbGVhc3QgYXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSBwYWdl IHNpemUuCi0jaWYgQ1BVKFBQQzY0KSB8fCBDUFUoUFBDNjRMRSkgfHwgQ1BVKFBQQykgfHwgQ1BV KFVOS05PV04pCi0gICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gNjQgKiBL QjsKLSNlbHNlCi0gICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gMTYgKiBL QjsKLSNlbmRpZgorICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IHN0ZDo6 bWF4KDE2ICogS0IsIENlaWxpbmdPblBhZ2VTaXplKTsKIAogICAgIHN0YXRpYyBjb25zdGV4cHIg c2l6ZV90IGJsb2NrTWFzayA9IH4oYmxvY2tTaXplIC0gMSk7IC8vIGJsb2NrU2l6ZSBtdXN0IGJl IGEgcG93ZXIgb2YgdHdvLgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29u ZmlnLmNwcAppbmRleCA3OWNjMmI2N2JhOTA1MDQxYmU5MzNkN2EyNTNiMTI3NTQ1Yjc2YmI5Li42 ZmRiM2VlMDBlNTljNTNmNjg3ZmRmNTkyY2E5MmY0NjdiOTRkMGExIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3BwCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAKQEAgLTUzLDkgKzUzLDcgQEAgdm9pZCBD b25maWc6OmVuYWJsZVJlc3RyaWN0ZWRPcHRpb25zKCkKICAgICAKIHZvaWQgQ29uZmlnOjpwZXJt YW5lbnRseUZyZWV6ZSgpCiB7Ci0jaWYgUExBVEZPUk0oQ09DT0EpCi0gICAgUkVMRUFTRV9BU1NF UlQocm91bmRVcFRvTXVsdGlwbGVPZih2bVBhZ2VTaXplKCksIENvbmZpZ1NpemVUb1Byb3RlY3Qp ID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOwotI2VuZGlmCisgICAgUkVMRUFTRV9BU1NFUlQocm91 bmRVcFRvTXVsdGlwbGVPZihwYWdlU2l6ZSgpLCBDb25maWdTaXplVG9Qcm90ZWN0KSA9PSBDb25m aWdTaXplVG9Qcm90ZWN0KTsKIAogICAgIGlmICghZ19qc2NDb25maWcuaXNQZXJtYW5lbnRseUZy b3plbikKICAgICAgICAgZ19qc2NDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbiA9IHRydWU7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oCmluZGV4IDFhZTUzYTU2NDMx YTU5ODRmNDk5NWJlMTgxY2I2ZGJjMTJjYWU3NmIuLmFhOWJmZTZjNjE4NDQyMGU2MmFmNjQ3ZTgy YjM5ZTE2YzI1OTViYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0pTQ0NvbmZpZy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZp Zy5oCkBAIC0yNiw2ICsyNiw3IEBACiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIk9wdGlvbnNM aXN0LmgiCisjaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJF eHRyYXMuaD4KIAogbmFtZXNwYWNlIEpTQyB7CkBAIC0zNCwxMSArMzUsNyBAQCBjbGFzcyBFeGVj dXRhYmxlQWxsb2NhdG9yOwogY2xhc3MgRml4ZWRWTVBvb2xFeGVjdXRhYmxlQWxsb2NhdG9yOwog Y2xhc3MgVk07CiAKLSNpZiAhT1MoV0lORE9XUykKLWNvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6 ZVRvUHJvdGVjdCA9IDE2ICogS0I7Ci0jZWxzZQotY29uc3RleHByIHNpemVfdCBDb25maWdTaXpl VG9Qcm90ZWN0ID0gNCAqIEtCOwotI2VuZGlmCitjb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVU b1Byb3RlY3QgPSBDZWlsaW5nT25QYWdlU2l6ZTsKIAogI2lmIEVOQUJMRShTRVBBUkFURURfV1hf SEVBUCkKIHVzaW5nIEpJVFdyaXRlU2VwYXJhdGVIZWFwc0Z1bmN0aW9uID0gdm9pZCAoKikob2Zm X3QsIGNvbnN0IHZvaWQqLCBzaXplX3QpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGFn ZUJsb2NrLmNwcCBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKaW5kZXggMzczODFiMmU1 MjI4NzU0NGRlMmIzZGQwZTM5OGVhY2YyMTUxODMyMC4uNWQwYWNhZGQ0YjFmMmUwNDQyZDlhM2Yx M2JlNmQ0MDdiNWQxYzkzZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNw cAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwCkBAIC00NCw3ICs0NCw3IEBAIHN0 YXRpYyBzaXplX3Qgc19wYWdlTWFzazsKIAogaW5saW5lIHNpemVfdCBzeXN0ZW1QYWdlU2l6ZSgp CiB7Ci0gICAgcmV0dXJuIGdldHBhZ2VzaXplKCk7CisgICAgcmV0dXJuIHN5c2NvbmYoX1NDX1BB R0VTSVpFKTsKIH0KIAogI2VsaWYgT1MoV0lORE9XUykKQEAgLTYyLDkgKzYyLDExIEBAIGlubGlu ZSBzaXplX3Qgc3lzdGVtUGFnZVNpemUoKQogCiBzaXplX3QgcGFnZVNpemUoKQogewotICAgIGlm ICghc19wYWdlU2l6ZSkKKyAgICBpZiAoIXNfcGFnZVNpemUpIHsKICAgICAgICAgc19wYWdlU2l6 ZSA9IHN5c3RlbVBhZ2VTaXplKCk7Ci0gICAgQVNTRVJUKGlzUG93ZXJPZlR3byhzX3BhZ2VTaXpl KSk7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGlzUG93ZXJPZlR3byhzX3BhZ2VTaXplKSk7Cisg ICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShzX3BhZ2VTaXplIDw9IENlaWxpbmdP blBhZ2VTaXplLCAiQ2VpbGluZ09uUGFnZVNpemUgaXMgdG9vIGxvdywgcmFpc2UgaXQgaW4gUGFn ZUJsb2NrLmghIik7CisgICAgfQogICAgIHJldHVybiBzX3BhZ2VTaXplOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaCBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9j ay5oCmluZGV4IGI1MmMzOWUwYjEwMWQzZTQ3ZTU5MzA0ZmEyODdmYTNiN2FhN2U1MTYuLjUyZGQx NmNkNTE0NDI3ZmVjY2E1NTFmZWQ1ODczMTZhNWE5MjI0NDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL1BhZ2VCbG9jay5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCkBAIC0y NSw4ICsyNSwzNyBAQAogCiAjcHJhZ21hIG9uY2UKIAorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRy YXMuaD4KKwogbmFtZXNwYWNlIFdURiB7CiAKKy8vIFdlIGF0dGVtcHQgdG8gZ3Vlc3MgYSB2YWx1 ZSB0aGF0IGlzICpBVCBMRUFTVCogYXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSdzIGFjdHVhbCBwYWdl IHNpemUuCisvLyBUaGlzIGlzIGltcG9zc2libGUgdG8gZG8gY29ycmVjdGx5IGF0IGJ1aWxkIHRp bWUsIGJ1dCBKU0MgcmVhbGx5IG5lZWRzIGl0IGF0IGJ1aWxkIHRpbWUsIHNvCisvLyB3ZSBoYXZl IGEgUkVMRUFTRV9BU1NFUlQoKSBpbnNpZGUgV1RGOjpwYWdlU2l6ZSB0byBtYWtlIHN1cmUgaXQg aXMgc2V0IHByb3Blcmx5IGF0IHJ1bnRpbWUuCisvLyBBbGwgb2YgdGhlc2UgdmFsdWVzIGFyZSBn b2luZyB0byBiZSBpbmNvcnJlY3Qgb24gc3lzdGVtcyBjb25maWd1cmVkIHRvIHVzZSBsYXJnZXIg dGhhbiBub3JtYWwKKy8vIHBhZ2Ugc2l6ZSwgc28gb24gc3VjaCBzeXN0ZW1zIGl0IGlzIGV4cGVj dGVkIHRoYXQgV2ViS2l0IHdpbGwgY3Jhc2ggdW50aWwgdGhpcyB2YWx1ZSBpcyBjaGFuZ2VkCisv LyBhbmQgcmVjb21waWxlZC4gU29ycnkuCisvLworLy8gTW9zdCBMaW51eCBhbmQgV2luZG93cyBz eXN0ZW1zIHVzZSBhIHBhZ2Ugc2l6ZSBvZiA0IEtpQi4KKy8vCisvLyBtYWNPUyB4ODZfNjQgdXNl cyA0IEtpQiwgYnV0IEFwcGxlJ3MgYWFyY2g2NCBzeXN0ZW1zIHVzZSAxNiBLaUIuIFVzZSAxNiBL aUIgb24gYWxsIEFwcGxlIHN5c3RlbXMKKy8vIGZvciBjb25zaXN0ZW5jeS4KKy8vCisvLyBPbiBM aW51eCwgUG93ZXIgc3lzdGVtcyBub3JtYWxseSB1c2UgNjQgS2lCIHBhZ2VzLgorLy8KKy8vIGFh cmNoNjQgc3lzdGVtcyBzZWVtIHRvIGJlIGFsbCBvdmVyIHRoZSBwbGFjZS4gTW9zdCBMaW51eCBk aXN0cm9zIHVzZSA0IEtpQiwgYnV0IFJIRUwgdXNlcworLy8gNjQgS2lCLiBpT1MgdXNlcyAxNiBL aUIuCisvLworLy8gVXNlIDY0IEtpQiBmb3IgYW55IHVua25vd24gQ1BVcyB0byBiZSBjb25zZXJ2 YXRpdmUuIFRoaXMgY292ZXJzIHMzOTB4LCB3aGljaCBkb2Vzbid0IGN1cnJlbnRseQorLy8gaGF2 ZSBpdHMgb3duIENQVSgpIG1hY3JvIGFuZCB3aGljaCBhbHNvIHVzZXMgNjQgS2lCIHBhZ2VzLgor I2lmIENQVShVTktOT1dOKSB8fCBDUFUoUFBDKSB8fCAoQ1BVKEFSTTY0KSAmJiAhUExBVEZPUk0o Q09DT0EpKQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7Cisj ZWxpZiBQTEFURk9STShDT0NPQSkKK2NvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUg PSAxNiAqIEtCOworI2Vsc2UKK2NvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA0 ICogS0I7CisjZW5kaWYKKwogV1RGX0VYUE9SVF9QUklWQVRFIHNpemVfdCBwYWdlU2l6ZSgpOwog V1RGX0VYUE9SVF9QUklWQVRFIHNpemVfdCBwYWdlTWFzaygpOwogaW5saW5lIGJvb2wgaXNQYWdl QWxpZ25lZCh2b2lkKiBhZGRyZXNzKSB7IHJldHVybiAhKHJlaW50ZXJwcmV0X2Nhc3Q8aW50cHRy X3Q+KGFkZHJlc3MpICYgKHBhZ2VTaXplKCkgLSAxKSk7IH0KQEAgLTgwLDYgKzEwOSw3IEBAIGlu bGluZSBQYWdlQmxvY2s6OlBhZ2VCbG9jayh2b2lkKiBiYXNlLCBzaXplX3Qgc2l6ZSwgYm9vbCBo YXNHdWFyZFBhZ2VzKQogCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAordXNpbmcgV1RGOjpDZWlsaW5n T25QYWdlU2l6ZTsKIHVzaW5nIFdURjo6cGFnZVNpemU7CiB1c2luZyBXVEY6OmlzUGFnZUFsaWdu ZWQ7CiB1c2luZyBXVEY6OmlzUG93ZXJPZlR3bzsK 394087 2020-03-20 09:00:35 -0700 2020-03-20 12:35:55 -0700 Patch bug-209236-20200320110034.patch text/plain 7923 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NzYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA3 NDhlOGM2ZWUyZWQzYmZmOTAzYjJkMDhmNjFmMTRjYmEyMjVhNGMyLi4zMjBmNWE1MjljMDkwYWMz MmI2YzMyOWJkOTEzYTJiN2ZjOTgzOWI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0yMCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMTkgIFRp bSBIb3J0b24gIDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgVXBzdHJlYW0g YSB2YXJpZXR5IG9mIENvY29hLXBsYXRmb3JtIEhBVkUgYW5kIEVOQUJMRSBtYWNyb3MKZGlmZiAt LWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKaW5kZXgg ZTQzNTBiNDgyZDYxNmYwMzlhYWY0MzM1NmZjYTliMTE2ZjdmYjRjNy4uOTJhYWQzMTBkZGQ2NWU5 Y2ViNmY2Y2MzNzQ0NTRkM2Q0NzNiYTkyZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMiBAQAorMjAyMC0wMy0y MCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAgICAgICBS RUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBKU0MgQ29uZmlnOjpwZXJtYW5lbnRs eUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgbmV3IENlaWxpbmdPblBhZ2VTaXplIGNvbnN0 YW50cywgZm9yIHVzZSBpbiBKU0MsIGluIG9yZGVyIHRvIGNlbnRyYWxpemUgb3VyIGNvbXBpbGUt dGltZQorICAgICAgICBwYWdlIHNpemUgZ3Vlc3NpbmcgaW50byBvbmUgcGxhY2UuIEltcHJvdmUg dGhlIGltcGxlbWVudGF0aW9uIG9mIHBhZ2VTaXplKCkgdG8KKyAgICAgICAgUkVMRUFTRV9BU1NF UlQoKSB3aGVuIENlaWxpbmdPblBhZ2VTaXplIGlzIHdyb25nLCBzbyB3ZSBjYW4gZGV0ZWN0IGFu ZCBmaXggaXQgaWYgc28uIChJdAorICAgICAgICB3aWxsIGJlIGV2ZW4gZWFzaWVyIHRvIGRldGVj dCBpZiB3ZSBjaGFuZ2UgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCkgdG8gYWN0dWFsbHkg cHJpbnQKKyAgICAgICAgaXRzIG1lc3NhZ2UgaW4gcmVsZWFzZSBidWlsZHMuKSBDaGFuZ2UgcGFn ZVNpemUoKSB0byB1c2Ugc3lzY29uZihfU0NfUEFHRVNJWkUpLCB3aGljaCBpcworICAgICAgICBz cGVjaWZpZWQgYnkgUE9TSVgsIGluc3RlYWQgb2YgZ2V0cGFnZXNpemUoKSwgd2hpY2ggaXMgbm9u c3RhbmRhcmQuCisKKyAgICAgICAgKiB3dGYvUGFnZUJsb2NrLmNwcDoKKyAgICAgICAgKFdURjo6 c3lzdGVtUGFnZVNpemUpOgorICAgICAgICAoV1RGOjpwYWdlU2l6ZSk6CisgICAgICAgICogd3Rm L1BhZ2VCbG9jay5oOgorCiAyMDIwLTAzLTE5ICBUaW0gSG9ydG9uICA8dGltb3RoeV9ob3J0b25A YXBwbGUuY29tPgogCiAgICAgICAgIFVwc3RyZWFtIGEgdmFyaWV0eSBvZiBDb2NvYS1wbGF0Zm9y bSBIQVZFIGFuZCBFTkFCTEUgbWFjcm9zCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvaGVhcC9NYXJrZWRCbG9jay5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2Vk QmxvY2suaAppbmRleCBlODA0ZTFiZDdiZWY5OTZiY2RjYWMzNjRjZDUxMjlhMTA2MWJkNWZmLi5h ZDE2YTRiZDZiZTdjNWU5YzZiZTE0ZjUyNDdmOGE0MzQ5YjcwNzc3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKQEAgLTI2LDEwICsyNiwxMiBAQAogI2luY2x1ZGUg IkhlYXBDZWxsLmgiCiAjaW5jbHVkZSAiSXRlcmF0aW9uU3RhdHVzLmgiCiAjaW5jbHVkZSAiV2Vh a1NldC5oIgorI2luY2x1ZGUgPGFsZ29yaXRobT4KICNpbmNsdWRlIDx3dGYvQXRvbWljcy5oPgog I2luY2x1ZGUgPHd0Zi9CaXRtYXAuaD4KLSNpbmNsdWRlIDx3dGYvSGFzaEZ1bmN0aW9ucy5oPgog I2luY2x1ZGUgPHd0Zi9Db3VudGluZ0xvY2suaD4KKyNpbmNsdWRlIDx3dGYvSGFzaEZ1bmN0aW9u cy5oPgorI2luY2x1ZGUgPHd0Zi9QYWdlQmxvY2suaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0 cmFzLmg+CiAKIG5hbWVzcGFjZSBKU0MgewpAQCAtNzAsMTEgKzcyLDcgQEAgcHVibGljOgogICAg IHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGF0b21TaXplID0gMTY7IC8vIGJ5dGVzCiAKICAgICAv LyBCbG9jayBzaXplIG11c3QgYmUgYXQgbGVhc3QgYXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSBwYWdl IHNpemUuCi0jaWYgQ1BVKFBQQzY0KSB8fCBDUFUoUFBDNjRMRSkgfHwgQ1BVKFBQQykgfHwgQ1BV KFVOS05PV04pCi0gICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gNjQgKiBL QjsKLSNlbHNlCi0gICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gMTYgKiBL QjsKLSNlbmRpZgorICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IHN0ZDo6 bWF4KDE2ICogS0IsIENlaWxpbmdPblBhZ2VTaXplKTsKIAogICAgIHN0YXRpYyBjb25zdGV4cHIg c2l6ZV90IGJsb2NrTWFzayA9IH4oYmxvY2tTaXplIC0gMSk7IC8vIGJsb2NrU2l6ZSBtdXN0IGJl IGEgcG93ZXIgb2YgdHdvLgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29u ZmlnLmNwcAppbmRleCA3OWNjMmI2N2JhOTA1MDQxYmU5MzNkN2EyNTNiMTI3NTQ1Yjc2YmI5Li42 ZmRiM2VlMDBlNTljNTNmNjg3ZmRmNTkyY2E5MmY0NjdiOTRkMGExIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3BwCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAKQEAgLTUzLDkgKzUzLDcgQEAgdm9pZCBD b25maWc6OmVuYWJsZVJlc3RyaWN0ZWRPcHRpb25zKCkKICAgICAKIHZvaWQgQ29uZmlnOjpwZXJt YW5lbnRseUZyZWV6ZSgpCiB7Ci0jaWYgUExBVEZPUk0oQ09DT0EpCi0gICAgUkVMRUFTRV9BU1NF UlQocm91bmRVcFRvTXVsdGlwbGVPZih2bVBhZ2VTaXplKCksIENvbmZpZ1NpemVUb1Byb3RlY3Qp ID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOwotI2VuZGlmCisgICAgUkVMRUFTRV9BU1NFUlQocm91 bmRVcFRvTXVsdGlwbGVPZihwYWdlU2l6ZSgpLCBDb25maWdTaXplVG9Qcm90ZWN0KSA9PSBDb25m aWdTaXplVG9Qcm90ZWN0KTsKIAogICAgIGlmICghZ19qc2NDb25maWcuaXNQZXJtYW5lbnRseUZy b3plbikKICAgICAgICAgZ19qc2NDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbiA9IHRydWU7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oCmluZGV4IDFhZTUzYTU2NDMx YTU5ODRmNDk5NWJlMTgxY2I2ZGJjMTJjYWU3NmIuLmFhOWJmZTZjNjE4NDQyMGU2MmFmNjQ3ZTgy YjM5ZTE2YzI1OTViYWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0pTQ0NvbmZpZy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZp Zy5oCkBAIC0yNiw2ICsyNiw3IEBACiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIk9wdGlvbnNM aXN0LmgiCisjaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJF eHRyYXMuaD4KIAogbmFtZXNwYWNlIEpTQyB7CkBAIC0zNCwxMSArMzUsNyBAQCBjbGFzcyBFeGVj dXRhYmxlQWxsb2NhdG9yOwogY2xhc3MgRml4ZWRWTVBvb2xFeGVjdXRhYmxlQWxsb2NhdG9yOwog Y2xhc3MgVk07CiAKLSNpZiAhT1MoV0lORE9XUykKLWNvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6 ZVRvUHJvdGVjdCA9IDE2ICogS0I7Ci0jZWxzZQotY29uc3RleHByIHNpemVfdCBDb25maWdTaXpl VG9Qcm90ZWN0ID0gNCAqIEtCOwotI2VuZGlmCitjb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVU b1Byb3RlY3QgPSBDZWlsaW5nT25QYWdlU2l6ZTsKIAogI2lmIEVOQUJMRShTRVBBUkFURURfV1hf SEVBUCkKIHVzaW5nIEpJVFdyaXRlU2VwYXJhdGVIZWFwc0Z1bmN0aW9uID0gdm9pZCAoKikob2Zm X3QsIGNvbnN0IHZvaWQqLCBzaXplX3QpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGFn ZUJsb2NrLmNwcCBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKaW5kZXggMzczODFiMmU1 MjI4NzU0NGRlMmIzZGQwZTM5OGVhY2YyMTUxODMyMC4uNWQwYWNhZGQ0YjFmMmUwNDQyZDlhM2Yx M2JlNmQ0MDdiNWQxYzkzZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNw cAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwCkBAIC00NCw3ICs0NCw3IEBAIHN0 YXRpYyBzaXplX3Qgc19wYWdlTWFzazsKIAogaW5saW5lIHNpemVfdCBzeXN0ZW1QYWdlU2l6ZSgp CiB7Ci0gICAgcmV0dXJuIGdldHBhZ2VzaXplKCk7CisgICAgcmV0dXJuIHN5c2NvbmYoX1NDX1BB R0VTSVpFKTsKIH0KIAogI2VsaWYgT1MoV0lORE9XUykKQEAgLTYyLDkgKzYyLDExIEBAIGlubGlu ZSBzaXplX3Qgc3lzdGVtUGFnZVNpemUoKQogCiBzaXplX3QgcGFnZVNpemUoKQogewotICAgIGlm ICghc19wYWdlU2l6ZSkKKyAgICBpZiAoIXNfcGFnZVNpemUpIHsKICAgICAgICAgc19wYWdlU2l6 ZSA9IHN5c3RlbVBhZ2VTaXplKCk7Ci0gICAgQVNTRVJUKGlzUG93ZXJPZlR3byhzX3BhZ2VTaXpl KSk7CisgICAgICAgIFJFTEVBU0VfQVNTRVJUKGlzUG93ZXJPZlR3byhzX3BhZ2VTaXplKSk7Cisg ICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShzX3BhZ2VTaXplIDw9IENlaWxpbmdP blBhZ2VTaXplLCAiQ2VpbGluZ09uUGFnZVNpemUgaXMgdG9vIGxvdywgcmFpc2UgaXQgaW4gUGFn ZUJsb2NrLmghIik7CisgICAgfQogICAgIHJldHVybiBzX3BhZ2VTaXplOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaCBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9j ay5oCmluZGV4IGI1MmMzOWUwYjEwMWQzZTQ3ZTU5MzA0ZmEyODdmYTNiN2FhN2U1MTYuLjA3ODEz N2NkMzY1YTMyN2Y0YjcwNjM4N2NiZWM0OWQ5NmM0YTdmM2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvd3RmL1BhZ2VCbG9jay5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCkBAIC0y NSw4ICsyNSw0MSBAQAogCiAjcHJhZ21hIG9uY2UKIAorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRy YXMuaD4KKwogbmFtZXNwYWNlIFdURiB7CiAKKy8vIFdlIGF0dGVtcHQgdG8gZ3Vlc3MgYSB2YWx1 ZSB0aGF0IGlzICpBVCBMRUFTVCogYXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSdzIGFjdHVhbCBwYWdl IHNpemUuCisvLyBUaGlzIGlzIGltcG9zc2libGUgdG8gZG8gY29ycmVjdGx5IGF0IGJ1aWxkIHRp bWUsIGJ1dCBKU0MgcmVhbGx5IG5lZWRzIGl0IGF0IGJ1aWxkIHRpbWUsIHNvCisvLyB3ZSBoYXZl IGEgUkVMRUFTRV9BU1NFUlQoKSBpbnNpZGUgV1RGOjpwYWdlU2l6ZSB0byBtYWtlIHN1cmUgaXQg aXMgc2V0IHByb3Blcmx5IGF0IHJ1bnRpbWUuCisvLyBBbGwgb2YgdGhlc2UgdmFsdWVzIGFyZSBn b2luZyB0byBiZSBpbmNvcnJlY3Qgb24gc3lzdGVtcyBjb25maWd1cmVkIHRvIHVzZSBsYXJnZXIg dGhhbiBub3JtYWwKKy8vIHBhZ2Ugc2l6ZSwgc28gb24gc3VjaCBzeXN0ZW1zIGl0IGlzIGV4cGVj dGVkIHRoYXQgV2ViS2l0IHdpbGwgY3Jhc2ggdW50aWwgdGhpcyB2YWx1ZSBpcyBjaGFuZ2VkCisv LyBhbmQgcmVjb21waWxlZC4gU29ycnkuCisvLworLy8gbWFjT1MgeDg2XzY0IHVzZXMgNCBLaUIs IGJ1dCBBcHBsZSdzIGFhcmNoNjQgc3lzdGVtcyB1c2UgMTYgS2lCLiBVc2UgMTYgS2lCIG9uIGFs bCBBcHBsZSBzeXN0ZW1zCisvLyBmb3IgY29uc2lzdGVuY3kuCisvLworLy8gTW9zdCBMaW51eCBh bmQgV2luZG93cyBzeXN0ZW1zIHVzZSBhIHBhZ2Ugc2l6ZSBvZiA0IEtpQi4KKy8vCisvLyBPbiBM aW51eCwgUG93ZXIgc3lzdGVtcyBub3JtYWxseSB1c2UgNjQgS2lCIHBhZ2VzLgorLy8KKy8vIGFh cmNoNjQgc3lzdGVtcyBzZWVtIHRvIGJlIGFsbCBvdmVyIHRoZSBwbGFjZS4gTW9zdCBMaW51eCBk aXN0cm9zIHVzZSA0IEtpQiwgYnV0IFJIRUwgdXNlcworLy8gNjQgS2lCLiAoQXBwbGUgdXNlcyAx NiBLaUIuKQorLy8KKy8vIFVzZSA2NCBLaUIgZm9yIGFueSB1bmtub3duIENQVXMgdG8gYmUgY29u c2VydmF0aXZlLiBUaGlzIGNvdmVycyBzMzkweCwgd2hpY2ggZG9lc24ndCBjdXJyZW50bHkKKy8v IGhhdmUgaXRzIG93biBDUFUoKSBtYWNybyBhbmQgd2hpY2ggYWxzbyB1c2VzIDY0IEtpQiBwYWdl cy4KKyNpZiBPUyhEQVJXSU4pCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0g MTYgKiBLQjsKKyNlbGlmIE9TKFdJTkRPV1MpCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBh Z2VTaXplID0gNCAqIEtCOworI2VsaWYgQ1BVKFVOS05PV04pIHx8IENQVShQUEMpIHx8IENQVShQ UEM2NCkgfHwgQ1BVKEFSTTY0KQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9 IDY0ICogS0I7CisjZWxpZiBDUFUoTUlQUykgfHwgQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkgfHwg Q1BVKEFSTSkKK2NvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA0ICogS0I7Cisj ZWxzZQorI2Vycm9yIE11c3Qgc2V0IENlaWxpbmdPblBhZ2VTaXplIGluIFBhZ2VCbG9jay5oIHdo ZW4gYWRkaW5nIGEgbmV3IENQVSBhcmNoaXRlY3R1cmUhCisjZW5kaWYKKwogV1RGX0VYUE9SVF9Q UklWQVRFIHNpemVfdCBwYWdlU2l6ZSgpOwogV1RGX0VYUE9SVF9QUklWQVRFIHNpemVfdCBwYWdl TWFzaygpOwogaW5saW5lIGJvb2wgaXNQYWdlQWxpZ25lZCh2b2lkKiBhZGRyZXNzKSB7IHJldHVy biAhKHJlaW50ZXJwcmV0X2Nhc3Q8aW50cHRyX3Q+KGFkZHJlc3MpICYgKHBhZ2VTaXplKCkgLSAx KSk7IH0KQEAgLTgwLDYgKzExMyw3IEBAIGlubGluZSBQYWdlQmxvY2s6OlBhZ2VCbG9jayh2b2lk KiBiYXNlLCBzaXplX3Qgc2l6ZSwgYm9vbCBoYXNHdWFyZFBhZ2VzKQogCiB9IC8vIG5hbWVzcGFj ZSBXVEYKIAordXNpbmcgV1RGOjpDZWlsaW5nT25QYWdlU2l6ZTsKIHVzaW5nIFdURjo6cGFnZVNp emU7CiB1c2luZyBXVEY6OmlzUGFnZUFsaWduZWQ7CiB1c2luZyBXVEY6OmlzUG93ZXJPZlR3bzsK 394110 2020-03-20 12:35:58 -0700 2020-03-23 09:51:28 -0700 Patch bug-209236-20200320143557.patch text/plain 7925 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4Nzc4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA1 MTJhZTlmZTA5ZjM0MWM5Y2JjNTk1YTQwOGVlMzk2OGJmNTE3OGU5Li5jMzJiYjNhZjVlNzI5OTJj MmExNGRhNmRkZThjYjJhZWE2YWJiYWU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0yMCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMjAgIEp1 c3RpbiBNaWNoYXVkICA8anVzdGluQGp1c3Rpbm1pY2hhdWQuY29tPgogCiAgICAgICAgIEZpeCBK U0NPbmx5IGJ1aWxkIHdpdGhvdXQgdW5pZmllZCBzb3VyY2VzCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDRkOTc1ZGQzOGEwMzdm NDViODkyNTIyNGQ4YjdlNTE1YjQyMDNkOTIuLjgzMGViYTVjOTEwMDRjZTQ2ZTlmZjM0NDc3OWFj ZGNiNWRmMWU1NTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDMtMjAgIE1pY2hhZWwgQ2F0 YW56YXJvICA8bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjQ5 ODA4KTogW0dUS10gQ3Jhc2ggaW4gSlNDIENvbmZpZzo6cGVybWFuZW50bHlGcmVlemUoKSBvbiBh cmNoaXRlY3R1cmUgcHBjNjRlbAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjA5MjM2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkIG5ldyBDZWlsaW5nT25QYWdlU2l6ZSBjb25zdGFudHMsIGZvciB1c2Ug aW4gSlNDLCBpbiBvcmRlciB0byBjZW50cmFsaXplIG91ciBjb21waWxlLXRpbWUKKyAgICAgICAg cGFnZSBzaXplIGd1ZXNzaW5nIGludG8gb25lIHBsYWNlLiBJbXByb3ZlIHRoZSBpbXBsZW1lbnRh dGlvbiBvZiBwYWdlU2l6ZSgpIHRvCisgICAgICAgIFJFTEVBU0VfQVNTRVJUKCkgd2hlbiBDZWls aW5nT25QYWdlU2l6ZSBpcyB3cm9uZywgc28gd2UgY2FuIGRldGVjdCBhbmQgZml4IGl0IGlmIHNv LiAoSXQKKyAgICAgICAgd2lsbCBiZSBldmVuIGVhc2llciB0byBkZXRlY3QgaWYgd2UgY2hhbmdl IFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIHRvIGFjdHVhbGx5IHByaW50CisgICAgICAg IGl0cyBtZXNzYWdlIGluIHJlbGVhc2UgYnVpbGRzLikgQ2hhbmdlIHBhZ2VTaXplKCkgdG8gdXNl IHN5c2NvbmYoX1NDX1BBR0VTSVpFKSwgd2hpY2ggaXMKKyAgICAgICAgc3BlY2lmaWVkIGJ5IFBP U0lYLCBpbnN0ZWFkIG9mIGdldHBhZ2VzaXplKCksIHdoaWNoIGlzIG5vbnN0YW5kYXJkLgorCisg ICAgICAgICogd3RmL1BhZ2VCbG9jay5jcHA6CisgICAgICAgIChXVEY6OnN5c3RlbVBhZ2VTaXpl KToKKyAgICAgICAgKFdURjo6cGFnZVNpemUpOgorICAgICAgICAqIHd0Zi9QYWdlQmxvY2suaDoK KwogMjAyMC0wMy0yMCAgVGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAog ICAgICAgICBVcHN0cmVhbSBhIHZhcmlldHkgb2YgQ29jb2EtcGxhdGZvcm0gSEFWRSBhbmQgRU5B QkxFIG1hY3JvcwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2Vk QmxvY2suaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKaW5kZXgg ZTgwNGUxYmQ3YmVmOTk2YmNkY2FjMzY0Y2Q1MTI5YTEwNjFiZDVmZi4uYWQxNmE0YmQ2YmU3YzVl OWM2YmUxNGY1MjQ3ZjhhNDM0OWI3MDc3NyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL2hlYXAvTWFya2VkQmxvY2suaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9N YXJrZWRCbG9jay5oCkBAIC0yNiwxMCArMjYsMTIgQEAKICNpbmNsdWRlICJIZWFwQ2VsbC5oIgog I2luY2x1ZGUgIkl0ZXJhdGlvblN0YXR1cy5oIgogI2luY2x1ZGUgIldlYWtTZXQuaCIKKyNpbmNs dWRlIDxhbGdvcml0aG0+CiAjaW5jbHVkZSA8d3RmL0F0b21pY3MuaD4KICNpbmNsdWRlIDx3dGYv Qml0bWFwLmg+Ci0jaW5jbHVkZSA8d3RmL0hhc2hGdW5jdGlvbnMuaD4KICNpbmNsdWRlIDx3dGYv Q291bnRpbmdMb2NrLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hGdW5jdGlvbnMuaD4KKyNpbmNsdWRl IDx3dGYvUGFnZUJsb2NrLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1l c3BhY2UgSlNDIHsKQEAgLTcwLDExICs3Miw3IEBAIHB1YmxpYzoKICAgICBzdGF0aWMgY29uc3Rl eHByIHNpemVfdCBhdG9tU2l6ZSA9IDE2OyAvLyBieXRlcwogCiAgICAgLy8gQmxvY2sgc2l6ZSBt dXN0IGJlIGF0IGxlYXN0IGFzIGxhcmdlIGFzIHRoZSBzeXN0ZW0gcGFnZSBzaXplLgotI2lmIENQ VShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQVShQUEMpIHx8IENQVShVTktOT1dOKQotICAg IHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IDY0ICogS0I7Ci0jZWxzZQotICAg IHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IDE2ICogS0I7Ci0jZW5kaWYKKyAg ICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja1NpemUgPSBzdGQ6Om1heCgxNiAqIEtCLCBD ZWlsaW5nT25QYWdlU2l6ZSk7CiAKICAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja01h c2sgPSB+KGJsb2NrU2l6ZSAtIDEpOyAvLyBibG9ja1NpemUgbXVzdCBiZSBhIHBvd2VyIG9mIHR3 by4KIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmln LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAKaW5kZXgg NzljYzJiNjdiYTkwNTA0MWJlOTMzZDdhMjUzYjEyNzU0NWI3NmJiOS4uNmZkYjNlZTAwZTU5YzUz ZjY4N2ZkZjU5MmNhOTJmNDY3Yjk0ZDBhMSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvSlNDQ29uZmlnLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwCkBAIC01Myw5ICs1Myw3IEBAIHZvaWQgQ29uZmlnOjplbmFibGVS ZXN0cmljdGVkT3B0aW9ucygpCiAgICAgCiB2b2lkIENvbmZpZzo6cGVybWFuZW50bHlGcmVlemUo KQogewotI2lmIFBMQVRGT1JNKENPQ09BKQotICAgIFJFTEVBU0VfQVNTRVJUKHJvdW5kVXBUb011 bHRpcGxlT2Yodm1QYWdlU2l6ZSgpLCBDb25maWdTaXplVG9Qcm90ZWN0KSA9PSBDb25maWdTaXpl VG9Qcm90ZWN0KTsKLSNlbmRpZgorICAgIFJFTEVBU0VfQVNTRVJUKHJvdW5kVXBUb011bHRpcGxl T2YocGFnZVNpemUoKSwgQ29uZmlnU2l6ZVRvUHJvdGVjdCkgPT0gQ29uZmlnU2l6ZVRvUHJvdGVj dCk7CiAKICAgICBpZiAoIWdfanNjQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4pCiAgICAgICAg IGdfanNjQ29uZmlnLmlzUGVybWFuZW50bHlGcm96ZW4gPSB0cnVlOwpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9KU0NDb25maWcuaAppbmRleCAxYWU1M2E1NjQzMWE1OTg0ZjQ5OTViZTE4 MWNiNmRiYzEyY2FlNzZiLi5hYTliZmU2YzYxODQ0MjBlNjJhZjY0N2U4MmIzOWUxNmMyNTk1YmFm IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuaAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuaApAQCAtMjYsNiAr MjYsNyBAQAogI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRlICJPcHRpb25zTGlzdC5oIgorI2luY2x1 ZGUgPHd0Zi9QYWdlQmxvY2suaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKIG5h bWVzcGFjZSBKU0MgewpAQCAtMzQsMTEgKzM1LDcgQEAgY2xhc3MgRXhlY3V0YWJsZUFsbG9jYXRv cjsKIGNsYXNzIEZpeGVkVk1Qb29sRXhlY3V0YWJsZUFsbG9jYXRvcjsKIGNsYXNzIFZNOwogCi0j aWYgIU9TKFdJTkRPV1MpCi1jb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVUb1Byb3RlY3QgPSAx NiAqIEtCOwotI2Vsc2UKLWNvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6ZVRvUHJvdGVjdCA9IDQg KiBLQjsKLSNlbmRpZgorY29uc3RleHByIHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0ID0gQ2Vp bGluZ09uUGFnZVNpemU7CiAKICNpZiBFTkFCTEUoU0VQQVJBVEVEX1dYX0hFQVApCiB1c2luZyBK SVRXcml0ZVNlcGFyYXRlSGVhcHNGdW5jdGlvbiA9IHZvaWQgKCopKG9mZl90LCBjb25zdCB2b2lk Kiwgc2l6ZV90KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAgYi9T b3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwCmluZGV4IDM3MzgxYjJlNTIyODc1NDRkZTJiM2Rk MGUzOThlYWNmMjE1MTgzMjAuLjVkMGFjYWRkNGIxZjJlMDQ0MmQ5YTNmMTNiZTZkNDA3YjVkMWM5 M2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKKysrIGIvU291cmNl L1dURi93dGYvUGFnZUJsb2NrLmNwcApAQCAtNDQsNyArNDQsNyBAQCBzdGF0aWMgc2l6ZV90IHNf cGFnZU1hc2s7CiAKIGlubGluZSBzaXplX3Qgc3lzdGVtUGFnZVNpemUoKQogewotICAgIHJldHVy biBnZXRwYWdlc2l6ZSgpOworICAgIHJldHVybiBzeXNjb25mKF9TQ19QQUdFU0laRSk7CiB9CiAK ICNlbGlmIE9TKFdJTkRPV1MpCkBAIC02Miw5ICs2MiwxMSBAQCBpbmxpbmUgc2l6ZV90IHN5c3Rl bVBhZ2VTaXplKCkKIAogc2l6ZV90IHBhZ2VTaXplKCkKIHsKLSAgICBpZiAoIXNfcGFnZVNpemUp CisgICAgaWYgKCFzX3BhZ2VTaXplKSB7CiAgICAgICAgIHNfcGFnZVNpemUgPSBzeXN0ZW1QYWdl U2l6ZSgpOwotICAgIEFTU0VSVChpc1Bvd2VyT2ZUd28oc19wYWdlU2l6ZSkpOworICAgICAgICBS RUxFQVNFX0FTU0VSVChpc1Bvd2VyT2ZUd28oc19wYWdlU2l6ZSkpOworICAgICAgICBSRUxFQVNF X0FTU0VSVF9XSVRIX01FU1NBR0Uoc19wYWdlU2l6ZSA8PSBDZWlsaW5nT25QYWdlU2l6ZSwgIkNl aWxpbmdPblBhZ2VTaXplIGlzIHRvbyBsb3csIHJhaXNlIGl0IGluIFBhZ2VCbG9jay5oISIpOwor ICAgIH0KICAgICByZXR1cm4gc19wYWdlU2l6ZTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dU Ri93dGYvUGFnZUJsb2NrLmggYi9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaAppbmRleCBiNTJj MzllMGIxMDFkM2U0N2U1OTMwNGZhMjg3ZmEzYjdhYTdlNTE2Li5iZDdhY2U5MmUzOTM2NDRlZTU5 ZjcwYWU0NjA5ZDMzMmQwZDJkZDNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxv Y2suaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaApAQCAtMjUsOCArMjUsNDEgQEAK IAogI3ByYWdtYSBvbmNlCiAKKyNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CisKIG5hbWVz cGFjZSBXVEYgewogCisvLyBXZSBhdHRlbXB0IHRvIGd1ZXNzIGEgdmFsdWUgdGhhdCBpcyAqQVQg TEVBU1QqIGFzIGxhcmdlIGFzIHRoZSBzeXN0ZW0ncyBhY3R1YWwgcGFnZSBzaXplLgorLy8gVGhp cyBpcyBpbXBvc3NpYmxlIHRvIGRvIGNvcnJlY3RseSBhdCBidWlsZCB0aW1lLCBidXQgSlNDIHJl YWxseSBuZWVkcyBpdCBhdCBidWlsZCB0aW1lLCBzbworLy8gd2UgaGF2ZSBhIFJFTEVBU0VfQVNT RVJUKCkgaW5zaWRlIFdURjo6cGFnZVNpemUgdG8gbWFrZSBzdXJlIGl0IGlzIHNldCBwcm9wZXJs eSBhdCBydW50aW1lLgorLy8gQWxsIG9mIHRoZXNlIHZhbHVlcyBhcmUgZ29pbmcgdG8gYmUgaW5j b3JyZWN0IG9uIHN5c3RlbXMgY29uZmlndXJlZCB0byB1c2UgbGFyZ2VyIHRoYW4gbm9ybWFsCisv LyBwYWdlIHNpemUsIHNvIG9uIHN1Y2ggc3lzdGVtcyBpdCBpcyBleHBlY3RlZCB0aGF0IFdlYktp dCB3aWxsIGNyYXNoIHVudGlsIHRoaXMgdmFsdWUgaXMgY2hhbmdlZAorLy8gYW5kIHJlY29tcGls ZWQuIFNvcnJ5LgorLy8KKy8vIG1hY09TIHg4Nl82NCB1c2VzIDQgS2lCLCBidXQgQXBwbGUncyBh YXJjaDY0IHN5c3RlbXMgdXNlIDE2IEtpQi4gVXNlIDE2IEtpQiBvbiBhbGwgQXBwbGUgc3lzdGVt cworLy8gZm9yIGNvbnNpc3RlbmN5LgorLy8KKy8vIE1vc3QgTGludXggYW5kIFdpbmRvd3Mgc3lz dGVtcyB1c2UgYSBwYWdlIHNpemUgb2YgNCBLaUIuCisvLworLy8gT24gTGludXgsIFBvd2VyIHN5 c3RlbXMgbm9ybWFsbHkgdXNlIDY0IEtpQiBwYWdlcy4KKy8vCisvLyBhYXJjaDY0IHN5c3RlbXMg c2VlbSB0byBiZSBhbGwgb3ZlciB0aGUgcGxhY2UuIE1vc3QgTGludXggZGlzdHJvcyB1c2UgNCBL aUIsIGJ1dCBSSEVMIHVzZXMKKy8vIDY0IEtpQi4gKEFwcGxlIHVzZXMgMTYgS2lCLikKKy8vCisv LyBVc2UgNjQgS2lCIGZvciBhbnkgdW5rbm93biBDUFVzIHRvIGJlIGNvbnNlcnZhdGl2ZS4gVGhp cyBjb3ZlcnMgczM5MHgsIHdoaWNoIGRvZXNuJ3QgY3VycmVudGx5CisvLyBoYXZlIGl0cyBvd24g Q1BVKCkgbWFjcm8gYW5kIHdoaWNoIGFsc28gdXNlcyA2NCBLaUIgcGFnZXMuCisjaWYgT1MoREFS V0lOKQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDE2ICogS0I7CisjZWxp ZiBPUyhXSU5ET1dTKQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDQgKiBL QjsKKyNlbGlmIENQVShVTktOT1dOKSB8fCBDUFUoUFBDKSB8fCBDUFUoUFBDNjQpIHx8IENQVShQ UEM2NExFKSB8fCBDUFUoQVJNNjQpCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXpl ID0gNjQgKiBLQjsKKyNlbGlmIENQVShNSVBTKSB8fCBDUFUoWDg2KSB8fCBDUFUoWDg2XzY0KSB8 fCBDUFUoQVJNKQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDQgKiBLQjsK KyNlbHNlCisjZXJyb3IgTXVzdCBzZXQgQ2VpbGluZ09uUGFnZVNpemUgaW4gUGFnZUJsb2NrLmgg d2hlbiBhZGRpbmcgYSBuZXcgQ1BVIGFyY2hpdGVjdHVyZSEKKyNlbmRpZgorCiBXVEZfRVhQT1JU X1BSSVZBVEUgc2l6ZV90IHBhZ2VTaXplKCk7CiBXVEZfRVhQT1JUX1BSSVZBVEUgc2l6ZV90IHBh Z2VNYXNrKCk7CiBpbmxpbmUgYm9vbCBpc1BhZ2VBbGlnbmVkKHZvaWQqIGFkZHJlc3MpIHsgcmV0 dXJuICEocmVpbnRlcnByZXRfY2FzdDxpbnRwdHJfdD4oYWRkcmVzcykgJiAocGFnZVNpemUoKSAt IDEpKTsgfQpAQCAtODAsNiArMTEzLDcgQEAgaW5saW5lIFBhZ2VCbG9jazo6UGFnZUJsb2NrKHZv aWQqIGJhc2UsIHNpemVfdCBzaXplLCBib29sIGhhc0d1YXJkUGFnZXMpCiAKIH0gLy8gbmFtZXNw YWNlIFdURgogCit1c2luZyBXVEY6OkNlaWxpbmdPblBhZ2VTaXplOwogdXNpbmcgV1RGOjpwYWdl U2l6ZTsKIHVzaW5nIFdURjo6aXNQYWdlQWxpZ25lZDsKIHVzaW5nIFdURjo6aXNQb3dlck9mVHdv Owo= 394268 2020-03-23 09:51:31 -0700 2020-03-23 09:52:04 -0700 Patch bug-209236-20200323115130.patch text/plain 7793 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4ODQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBh ZDFkN2M3NTg0MmNjNzJhMDMwYzQzNGNiMzM1NTY4ODBiMWU5NDVhLi5kYzkyZmFmM2M4OWI2OTA1 ZDMzYjc1ZmNlYjFkODI2NmY1ZWEyMTM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0yMyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMjIgIFl1 c3VrZSBTdXp1a2kgIDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBy ZW5hbWUga2VlcEFsaXZlIHRvIGVuc3VyZVN0aWxsQWxpdmVIZXJlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGI2MjI4ZmI5Yzlj ZGEwMjg4MWU2NWZmYTk2ZDFiYzcwNGVmZDQ1NjQuLjM4ZDgwOWE3N2QwNTlkZjAxODM2MGU1Yzcz MThmOTQ4MDkxNDM5MmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDMtMjMgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVTU0lPTihy MjQ5ODA4KTogW0dUS10gQ3Jhc2ggaW4gSlNDIENvbmZpZzo6cGVybWFuZW50bHlGcmVlemUoKSBv biBhcmNoaXRlY3R1cmUgcHBjNjRlbAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA5MjM2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWRkIG5ldyBDZWlsaW5nT25QYWdlU2l6ZSBjb25zdGFudHMsIGZvciB1 c2UgaW4gSlNDLCBpbiBvcmRlciB0byBjZW50cmFsaXplIG91ciBjb21waWxlLXRpbWUKKyAgICAg ICAgcGFnZSBzaXplIGd1ZXNzaW5nIGludG8gb25lIHBsYWNlLiBJbXByb3ZlIHRoZSBpbXBsZW1l bnRhdGlvbiBvZiBwYWdlU2l6ZSgpIHRvCisgICAgICAgIFJFTEVBU0VfQVNTRVJUKCkgd2hlbiBD ZWlsaW5nT25QYWdlU2l6ZSBpcyB3cm9uZywgc28gd2UgY2FuIGRldGVjdCBhbmQgZml4IGl0IGlm IHNvLiAoSXQKKyAgICAgICAgd2lsbCBiZSBldmVuIGVhc2llciB0byBkZXRlY3QgaWYgd2UgY2hh bmdlIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIHRvIGFjdHVhbGx5IHByaW50CisgICAg ICAgIGl0cyBtZXNzYWdlIGluIHJlbGVhc2UgYnVpbGRzLikgQ2hhbmdlIHBhZ2VTaXplKCkgdG8g dXNlIHN5c2NvbmYoX1NDX1BBR0VTSVpFKSwgd2hpY2ggaXMKKyAgICAgICAgc3BlY2lmaWVkIGJ5 IFBPU0lYLCBpbnN0ZWFkIG9mIGdldHBhZ2VzaXplKCksIHdoaWNoIGlzIG5vbnN0YW5kYXJkLgor CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5jcHA6CisgICAgICAgIChXVEY6OnN5c3RlbVBhZ2VT aXplKToKKyAgICAgICAgKFdURjo6cGFnZVNpemUpOgorICAgICAgICAqIHd0Zi9QYWdlQmxvY2su aDoKKwogMjAyMC0wMy0yMyAgSmFjb2IgVXBob2ZmICA8amFjb2JfdXBob2ZmQGFwcGxlLmNvbT4K IAogICAgICAgICBVbnJldmlld2VkLCByZXZlcnRpbmcgcjI1ODgwMy4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCmluZGV4IGU4MDRlMWJkN2JlZjk5NmJjZGNhYzM2NGNk NTEyOWExMDYxYmQ1ZmYuLmFkMTZhNGJkNmJlN2M1ZTljNmJlMTRmNTI0N2Y4YTQzNDliNzA3Nzcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2VkQmxvY2suaApAQCAtMjYsMTAgKzI2 LDEyIEBACiAjaW5jbHVkZSAiSGVhcENlbGwuaCIKICNpbmNsdWRlICJJdGVyYXRpb25TdGF0dXMu aCIKICNpbmNsdWRlICJXZWFrU2V0LmgiCisjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUg PHd0Zi9BdG9taWNzLmg+CiAjaW5jbHVkZSA8d3RmL0JpdG1hcC5oPgotI2luY2x1ZGUgPHd0Zi9I YXNoRnVuY3Rpb25zLmg+CiAjaW5jbHVkZSA8d3RmL0NvdW50aW5nTG9jay5oPgorI2luY2x1ZGUg PHd0Zi9IYXNoRnVuY3Rpb25zLmg+CisjaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgogI2luY2x1 ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogbmFtZXNwYWNlIEpTQyB7CkBAIC03MCwxMSArNzIs NyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYXRvbVNpemUgPSAxNjsg Ly8gYnl0ZXMKIAogICAgIC8vIEJsb2NrIHNpemUgbXVzdCBiZSBhdCBsZWFzdCBhcyBsYXJnZSBh cyB0aGUgc3lzdGVtIHBhZ2Ugc2l6ZS4KLSNpZiBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8 fCBDUFUoUFBDKSB8fCBDUFUoVU5LTk9XTikKLSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBi bG9ja1NpemUgPSA2NCAqIEtCOwotI2Vsc2UKLSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBi bG9ja1NpemUgPSAxNiAqIEtCOwotI2VuZGlmCisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3Qg YmxvY2tTaXplID0gc3RkOjptYXgoMTYgKiBLQiwgQ2VpbGluZ09uUGFnZVNpemUpOwogCiAgICAg c3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tNYXNrID0gfihibG9ja1NpemUgLSAxKTsgLy8g YmxvY2tTaXplIG11c3QgYmUgYSBwb3dlciBvZiB0d28uCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9KU0NDb25maWcuY3BwCmluZGV4IDc5Y2MyYjY3YmE5MDUwNDFiZTkzM2Q3YTI1 M2IxMjc1NDViNzZiYjkuLjZmZGIzZWUwMGU1OWM1M2Y2ODdmZGY1OTJjYTkyZjQ2N2I5NGQwYTEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmNwcApAQCAtNTMs OSArNTMsNyBAQCB2b2lkIENvbmZpZzo6ZW5hYmxlUmVzdHJpY3RlZE9wdGlvbnMoKQogICAgIAog dm9pZCBDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkKIHsKLSNpZiBQTEFURk9STShDT0NPQSkK LSAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHZtUGFnZVNpemUoKSwgQ29u ZmlnU2l6ZVRvUHJvdGVjdCkgPT0gQ29uZmlnU2l6ZVRvUHJvdGVjdCk7Ci0jZW5kaWYKKyAgICBS RUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHBhZ2VTaXplKCksIENvbmZpZ1NpemVU b1Byb3RlY3QpID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOwogCiAgICAgaWYgKCFnX2pzY0NvbmZp Zy5pc1Blcm1hbmVudGx5RnJvemVuKQogICAgICAgICBnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5 RnJvemVuID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0pTQ0NvbmZpZy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgK aW5kZXggMWFlNTNhNTY0MzFhNTk4NGY0OTk1YmUxODFjYjZkYmMxMmNhZTc2Yi4uYWE5YmZlNmM2 MTg0NDIwZTYyYWY2NDdlODJiMzllMTZjMjU5NWJhZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvSlNDQ29uZmlnLmgKQEAgLTI2LDYgKzI2LDcgQEAKICNwcmFnbWEgb25jZQogCiAj aW5jbHVkZSAiT3B0aW9uc0xpc3QuaCIKKyNpbmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+CiAjaW5j bHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1lc3BhY2UgSlNDIHsKQEAgLTM0LDExICsz NSw3IEBAIGNsYXNzIEV4ZWN1dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBGaXhlZFZNUG9vbEV4ZWN1 dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBWTTsKIAotI2lmICFPUyhXSU5ET1dTKQotY29uc3RleHBy IHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0ID0gMTYgKiBLQjsKLSNlbHNlCi1jb25zdGV4cHIg c2l6ZV90IENvbmZpZ1NpemVUb1Byb3RlY3QgPSA0ICogS0I7Ci0jZW5kaWYKK2NvbnN0ZXhwciBz aXplX3QgQ29uZmlnU2l6ZVRvUHJvdGVjdCA9IENlaWxpbmdPblBhZ2VTaXplOwogCiAjaWYgRU5B QkxFKFNFUEFSQVRFRF9XWF9IRUFQKQogdXNpbmcgSklUV3JpdGVTZXBhcmF0ZUhlYXBzRnVuY3Rp b24gPSB2b2lkICgqKShvZmZfdCwgY29uc3Qgdm9pZCosIHNpemVfdCk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNw cAppbmRleCAzNzM4MWIyZTUyMjg3NTQ0ZGUyYjNkZDBlMzk4ZWFjZjIxNTE4MzIwLi41ZDBhY2Fk ZDRiMWYyZTA0NDJkOWEzZjEzYmU2ZDQwN2I1ZDFjOTNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RG L3d0Zi9QYWdlQmxvY2suY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKQEAg LTQ0LDcgKzQ0LDcgQEAgc3RhdGljIHNpemVfdCBzX3BhZ2VNYXNrOwogCiBpbmxpbmUgc2l6ZV90 IHN5c3RlbVBhZ2VTaXplKCkKIHsKLSAgICByZXR1cm4gZ2V0cGFnZXNpemUoKTsKKyAgICByZXR1 cm4gc3lzY29uZihfU0NfUEFHRVNJWkUpOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtNjIs OSArNjIsMTEgQEAgaW5saW5lIHNpemVfdCBzeXN0ZW1QYWdlU2l6ZSgpCiAKIHNpemVfdCBwYWdl U2l6ZSgpCiB7Ci0gICAgaWYgKCFzX3BhZ2VTaXplKQorICAgIGlmICghc19wYWdlU2l6ZSkgewog ICAgICAgICBzX3BhZ2VTaXplID0gc3lzdGVtUGFnZVNpemUoKTsKLSAgICBBU1NFUlQoaXNQb3dl ck9mVHdvKHNfcGFnZVNpemUpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaXNQb3dlck9mVHdv KHNfcGFnZVNpemUpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKHNfcGFn ZVNpemUgPD0gQ2VpbGluZ09uUGFnZVNpemUsICJDZWlsaW5nT25QYWdlU2l6ZSBpcyB0b28gbG93 LCByYWlzZSBpdCBpbiBQYWdlQmxvY2suaCEiKTsKKyAgICB9CiAgICAgcmV0dXJuIHNfcGFnZVNp emU7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNl L1dURi93dGYvUGFnZUJsb2NrLmgKaW5kZXggYjUyYzM5ZTBiMTAxZDNlNDdlNTkzMDRmYTI4N2Zh M2I3YWE3ZTUxNi4uNjJlNjNkY2M3OWZmMTJlNjAxMWE1OGFiYmY5ZWZiOThhYzdjYmFlMSAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYv UGFnZUJsb2NrLmgKQEAgLTI1LDggKzI1LDQwIEBACiAKICNwcmFnbWEgb25jZQogCisjaW5jbHVk ZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorCiBuYW1lc3BhY2UgV1RGIHsKIAorLy8gV2UgYXR0ZW1w dCB0byBndWVzcyBhIHZhbHVlIHRoYXQgaXMgKkFUIExFQVNUKiBhcyBsYXJnZSBhcyB0aGUgc3lz dGVtJ3MgYWN0dWFsIHBhZ2Ugc2l6ZS4KKy8vIFRoaXMgaXMgaW1wb3NzaWJsZSB0byBkbyBjb3Jy ZWN0bHkgYXQgYnVpbGQgdGltZSwgYnV0IEpTQyByZWFsbHkgbmVlZHMgaXQgYXQgYnVpbGQgdGlt ZSwgc28KKy8vIHdlIGhhdmUgYSBSRUxFQVNFX0FTU0VSVCgpIGluc2lkZSBXVEY6OnBhZ2VTaXpl IHRvIG1ha2Ugc3VyZSBpdCBpcyBzZXQgcHJvcGVybHkgYXQgcnVudGltZS4KKy8vIEFsbCBvZiB0 aGVzZSB2YWx1ZXMgYXJlIGdvaW5nIHRvIGJlIGluY29ycmVjdCBvbiBzeXN0ZW1zIGNvbmZpZ3Vy ZWQgdG8gdXNlIGxhcmdlciB0aGFuIG5vcm1hbAorLy8gcGFnZSBzaXplLCBzbyBvbiBzdWNoIHN5 c3RlbXMgaXQgaXMgZXhwZWN0ZWQgdGhhdCBXZWJLaXQgd2lsbCBjcmFzaCB1bnRpbCB0aGlzIHZh bHVlIGlzIGNoYW5nZWQKKy8vIGFuZCByZWNvbXBpbGVkLiBTb3JyeS4KKy8vCisvLyBtYWNPUyB4 ODZfNjQgdXNlcyA0IEtpQiwgYnV0IEFwcGxlJ3MgYWFyY2g2NCBzeXN0ZW1zIHVzZSAxNiBLaUIu IFVzZSAxNiBLaUIgb24gYWxsIEFwcGxlIHN5c3RlbXMKKy8vIGZvciBjb25zaXN0ZW5jeS4KKy8v CisvLyBNb3N0IExpbnV4IGFuZCBXaW5kb3dzIHN5c3RlbXMgdXNlIGEgcGFnZSBzaXplIG9mIDQg S2lCLgorLy8KKy8vIE9uIExpbnV4LCBQb3dlciBzeXN0ZW1zIG5vcm1hbGx5IHVzZSA2NCBLaUIg cGFnZXMuCisvLworLy8gYWFyY2g2NCBzeXN0ZW1zIHNlZW0gdG8gYmUgYWxsIG92ZXIgdGhlIHBs YWNlLiBNb3N0IExpbnV4IGRpc3Ryb3MgdXNlIDQgS2lCLCBidXQgUkhFTCB1c2VzCisvLyA2NCBL aUIuIChBcHBsZSB1c2VzIDE2IEtpQi4pCisvLworLy8gVXNlIDY0IEtpQiBmb3IgYW55IHVua25v d24gQ1BVcyB0byBiZSBjb25zZXJ2YXRpdmUuCisjaWYgT1MoREFSV0lOKQorY29uc3RleHByIHNp emVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDE2ICogS0I7CisjZWxpZiBPUyhXSU5ET1dTKQorY29u c3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDQgKiBLQjsKKyNlbGlmIENQVShVTktO T1dOKSB8fCBDUFUoUFBDKSB8fCBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8fCBDUFUoQVJN NjQpCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0gNjQgKiBLQjsKKyNlbGlm IENQVShNSVBTKSB8fCBDUFUoWDg2KSB8fCBDUFUoWDg2XzY0KSB8fCBDUFUoQVJNKQorY29uc3Rl eHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDQgKiBLQjsKKyNlbHNlCisjZXJyb3IgTXVz dCBzZXQgQ2VpbGluZ09uUGFnZVNpemUgaW4gUGFnZUJsb2NrLmggd2hlbiBhZGRpbmcgYSBuZXcg Q1BVIGFyY2hpdGVjdHVyZSEKKyNlbmRpZgorCiBXVEZfRVhQT1JUX1BSSVZBVEUgc2l6ZV90IHBh Z2VTaXplKCk7CiBXVEZfRVhQT1JUX1BSSVZBVEUgc2l6ZV90IHBhZ2VNYXNrKCk7CiBpbmxpbmUg Ym9vbCBpc1BhZ2VBbGlnbmVkKHZvaWQqIGFkZHJlc3MpIHsgcmV0dXJuICEocmVpbnRlcnByZXRf Y2FzdDxpbnRwdHJfdD4oYWRkcmVzcykgJiAocGFnZVNpemUoKSAtIDEpKTsgfQpAQCAtODAsNiAr MTEyLDcgQEAgaW5saW5lIFBhZ2VCbG9jazo6UGFnZUJsb2NrKHZvaWQqIGJhc2UsIHNpemVfdCBz aXplLCBib29sIGhhc0d1YXJkUGFnZXMpCiAKIH0gLy8gbmFtZXNwYWNlIFdURgogCit1c2luZyBX VEY6OkNlaWxpbmdPblBhZ2VTaXplOwogdXNpbmcgV1RGOjpwYWdlU2l6ZTsKIHVzaW5nIFdURjo6 aXNQYWdlQWxpZ25lZDsKIHVzaW5nIFdURjo6aXNQb3dlck9mVHdvOwo= 394269 2020-03-23 09:52:07 -0700 2020-03-23 10:34:49 -0700 Patch bug-209236-20200323115206.patch text/plain 7743 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4ODQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBh ZDFkN2M3NTg0MmNjNzJhMDMwYzQzNGNiMzM1NTY4ODBiMWU5NDVhLi5kYzkyZmFmM2M4OWI2OTA1 ZDMzYjc1ZmNlYjFkODI2NmY1ZWEyMTM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNSBAQAorMjAyMC0wMy0yMyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdu b21lLm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBpbiBK U0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVsCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGhlYXAvTWFy a2VkQmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KKyAgICAgICAgKiBydW50aW1l L0pTQ0NvbmZpZy5jcHA6CisgICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUp OiBVc2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgorICAgICAgICAqIHJ1bnRpbWUv SlNDQ29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCisKIDIwMjAtMDMtMjIgIFl1 c3VrZSBTdXp1a2kgIDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCBy ZW5hbWUga2VlcEFsaXZlIHRvIGVuc3VyZVN0aWxsQWxpdmVIZXJlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGI2MjI4ZmI5Yzlj ZGEwMjg4MWU2NWZmYTk2ZDFiYzcwNGVmZDQ1NjQuLjM4ZDgwOWE3N2QwNTlkZjAxODM2MGU1Yzcz MThmOTQ4MDkxNDM5MmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMjAtMDMtMjMgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVTU0lPTihy MjQ5ODA4KTogW0dUS10gQ3Jhc2ggaW4gSlNDIENvbmZpZzo6cGVybWFuZW50bHlGcmVlemUoKSBv biBhcmNoaXRlY3R1cmUgcHBjNjRlbAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA5MjM2CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgQWRkIG5ldyBDZWlsaW5nT25QYWdlU2l6ZSBjb25zdGFudHMsIGZvciB1 c2UgaW4gSlNDLCBpbiBvcmRlciB0byBjZW50cmFsaXplIG91ciBjb21waWxlLXRpbWUKKyAgICAg ICAgcGFnZSBzaXplIGd1ZXNzaW5nIGludG8gb25lIHBsYWNlLiBJbXByb3ZlIHRoZSBpbXBsZW1l bnRhdGlvbiBvZiBwYWdlU2l6ZSgpIHRvCisgICAgICAgIFJFTEVBU0VfQVNTRVJUKCkgd2hlbiBD ZWlsaW5nT25QYWdlU2l6ZSBpcyB3cm9uZywgc28gd2UgY2FuIGRldGVjdCBhbmQgZml4IGl0IGlm IHNvLiAoSXQKKyAgICAgICAgd2lsbCBiZSBldmVuIGVhc2llciB0byBkZXRlY3QgaWYgd2UgY2hh bmdlIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgpIHRvIGFjdHVhbGx5IHByaW50CisgICAg ICAgIGl0cyBtZXNzYWdlIGluIHJlbGVhc2UgYnVpbGRzLikgQ2hhbmdlIHBhZ2VTaXplKCkgdG8g dXNlIHN5c2NvbmYoX1NDX1BBR0VTSVpFKSwgd2hpY2ggaXMKKyAgICAgICAgc3BlY2lmaWVkIGJ5 IFBPU0lYLCBpbnN0ZWFkIG9mIGdldHBhZ2VzaXplKCksIHdoaWNoIGlzIG5vbnN0YW5kYXJkLgor CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5jcHA6CisgICAgICAgIChXVEY6OnN5c3RlbVBhZ2VT aXplKToKKyAgICAgICAgKFdURjo6cGFnZVNpemUpOgorICAgICAgICAqIHd0Zi9QYWdlQmxvY2su aDoKKwogMjAyMC0wMy0yMyAgSmFjb2IgVXBob2ZmICA8amFjb2JfdXBob2ZmQGFwcGxlLmNvbT4K IAogICAgICAgICBVbnJldmlld2VkLCByZXZlcnRpbmcgcjI1ODgwMy4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmggYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCmluZGV4IGU4MDRlMWJkN2JlZjk5NmJjZGNhYzM2NGNk NTEyOWExMDYxYmQ1ZmYuLmFkMTZhNGJkNmJlN2M1ZTljNmJlMTRmNTI0N2Y4YTQzNDliNzA3Nzcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2VkQmxvY2suaApAQCAtMjYsMTAgKzI2 LDEyIEBACiAjaW5jbHVkZSAiSGVhcENlbGwuaCIKICNpbmNsdWRlICJJdGVyYXRpb25TdGF0dXMu aCIKICNpbmNsdWRlICJXZWFrU2V0LmgiCisjaW5jbHVkZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUg PHd0Zi9BdG9taWNzLmg+CiAjaW5jbHVkZSA8d3RmL0JpdG1hcC5oPgotI2luY2x1ZGUgPHd0Zi9I YXNoRnVuY3Rpb25zLmg+CiAjaW5jbHVkZSA8d3RmL0NvdW50aW5nTG9jay5oPgorI2luY2x1ZGUg PHd0Zi9IYXNoRnVuY3Rpb25zLmg+CisjaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgogI2luY2x1 ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogbmFtZXNwYWNlIEpTQyB7CkBAIC03MCwxMSArNzIs NyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYXRvbVNpemUgPSAxNjsg Ly8gYnl0ZXMKIAogICAgIC8vIEJsb2NrIHNpemUgbXVzdCBiZSBhdCBsZWFzdCBhcyBsYXJnZSBh cyB0aGUgc3lzdGVtIHBhZ2Ugc2l6ZS4KLSNpZiBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8 fCBDUFUoUFBDKSB8fCBDUFUoVU5LTk9XTikKLSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBi bG9ja1NpemUgPSA2NCAqIEtCOwotI2Vsc2UKLSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBi bG9ja1NpemUgPSAxNiAqIEtCOwotI2VuZGlmCisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3Qg YmxvY2tTaXplID0gc3RkOjptYXgoMTYgKiBLQiwgQ2VpbGluZ09uUGFnZVNpemUpOwogCiAgICAg c3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tNYXNrID0gfihibG9ja1NpemUgLSAxKTsgLy8g YmxvY2tTaXplIG11c3QgYmUgYSBwb3dlciBvZiB0d28uCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9KU0NDb25maWcuY3BwCmluZGV4IDc5Y2MyYjY3YmE5MDUwNDFiZTkzM2Q3YTI1 M2IxMjc1NDViNzZiYjkuLjZmZGIzZWUwMGU1OWM1M2Y2ODdmZGY1OTJjYTkyZjQ2N2I5NGQwYTEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmNwcApAQCAtNTMs OSArNTMsNyBAQCB2b2lkIENvbmZpZzo6ZW5hYmxlUmVzdHJpY3RlZE9wdGlvbnMoKQogICAgIAog dm9pZCBDb25maWc6OnBlcm1hbmVudGx5RnJlZXplKCkKIHsKLSNpZiBQTEFURk9STShDT0NPQSkK LSAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHZtUGFnZVNpemUoKSwgQ29u ZmlnU2l6ZVRvUHJvdGVjdCkgPT0gQ29uZmlnU2l6ZVRvUHJvdGVjdCk7Ci0jZW5kaWYKKyAgICBS RUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHBhZ2VTaXplKCksIENvbmZpZ1NpemVU b1Byb3RlY3QpID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOwogCiAgICAgaWYgKCFnX2pzY0NvbmZp Zy5pc1Blcm1hbmVudGx5RnJvemVuKQogICAgICAgICBnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5 RnJvemVuID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0pTQ0NvbmZpZy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgK aW5kZXggMWFlNTNhNTY0MzFhNTk4NGY0OTk1YmUxODFjYjZkYmMxMmNhZTc2Yi4uYWE5YmZlNmM2 MTg0NDIwZTYyYWY2NDdlODJiMzllMTZjMjU5NWJhZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvSlNDQ29uZmlnLmgKQEAgLTI2LDYgKzI2LDcgQEAKICNwcmFnbWEgb25jZQogCiAj aW5jbHVkZSAiT3B0aW9uc0xpc3QuaCIKKyNpbmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+CiAjaW5j bHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1lc3BhY2UgSlNDIHsKQEAgLTM0LDExICsz NSw3IEBAIGNsYXNzIEV4ZWN1dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBGaXhlZFZNUG9vbEV4ZWN1 dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBWTTsKIAotI2lmICFPUyhXSU5ET1dTKQotY29uc3RleHBy IHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0ID0gMTYgKiBLQjsKLSNlbHNlCi1jb25zdGV4cHIg c2l6ZV90IENvbmZpZ1NpemVUb1Byb3RlY3QgPSA0ICogS0I7Ci0jZW5kaWYKK2NvbnN0ZXhwciBz aXplX3QgQ29uZmlnU2l6ZVRvUHJvdGVjdCA9IENlaWxpbmdPblBhZ2VTaXplOwogCiAjaWYgRU5B QkxFKFNFUEFSQVRFRF9XWF9IRUFQKQogdXNpbmcgSklUV3JpdGVTZXBhcmF0ZUhlYXBzRnVuY3Rp b24gPSB2b2lkICgqKShvZmZfdCwgY29uc3Qgdm9pZCosIHNpemVfdCk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNw cAppbmRleCAzNzM4MWIyZTUyMjg3NTQ0ZGUyYjNkZDBlMzk4ZWFjZjIxNTE4MzIwLi41ZDBhY2Fk ZDRiMWYyZTA0NDJkOWEzZjEzYmU2ZDQwN2I1ZDFjOTNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RG L3d0Zi9QYWdlQmxvY2suY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKQEAg LTQ0LDcgKzQ0LDcgQEAgc3RhdGljIHNpemVfdCBzX3BhZ2VNYXNrOwogCiBpbmxpbmUgc2l6ZV90 IHN5c3RlbVBhZ2VTaXplKCkKIHsKLSAgICByZXR1cm4gZ2V0cGFnZXNpemUoKTsKKyAgICByZXR1 cm4gc3lzY29uZihfU0NfUEFHRVNJWkUpOwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtNjIs OSArNjIsMTEgQEAgaW5saW5lIHNpemVfdCBzeXN0ZW1QYWdlU2l6ZSgpCiAKIHNpemVfdCBwYWdl U2l6ZSgpCiB7Ci0gICAgaWYgKCFzX3BhZ2VTaXplKQorICAgIGlmICghc19wYWdlU2l6ZSkgewog ICAgICAgICBzX3BhZ2VTaXplID0gc3lzdGVtUGFnZVNpemUoKTsKLSAgICBBU1NFUlQoaXNQb3dl ck9mVHdvKHNfcGFnZVNpemUpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoaXNQb3dlck9mVHdv KHNfcGFnZVNpemUpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKHNfcGFn ZVNpemUgPD0gQ2VpbGluZ09uUGFnZVNpemUsICJDZWlsaW5nT25QYWdlU2l6ZSBpcyB0b28gbG93 LCByYWlzZSBpdCBpbiBQYWdlQmxvY2suaCEiKTsKKyAgICB9CiAgICAgcmV0dXJuIHNfcGFnZVNp emU7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNl L1dURi93dGYvUGFnZUJsb2NrLmgKaW5kZXggYjUyYzM5ZTBiMTAxZDNlNDdlNTkzMDRmYTI4N2Zh M2I3YWE3ZTUxNi4uY2Q4NWVkZjI3ZjM3NjQxNjExMDg4ZWQ5N2ExNzQwODVkYzNjZWNhNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYv UGFnZUJsb2NrLmgKQEAgLTI1LDggKzI1LDM4IEBACiAKICNwcmFnbWEgb25jZQogCisjaW5jbHVk ZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorCiBuYW1lc3BhY2UgV1RGIHsKIAorLy8gV2UgYXR0ZW1w dCB0byBndWVzcyBhIHZhbHVlIHRoYXQgaXMgKkFUIExFQVNUKiBhcyBsYXJnZSBhcyB0aGUgc3lz dGVtJ3MgYWN0dWFsIHBhZ2Ugc2l6ZS4KKy8vIFRoaXMgaXMgaW1wb3NzaWJsZSB0byBkbyBjb3Jy ZWN0bHkgYXQgYnVpbGQgdGltZSwgYnV0IEpTQyByZWFsbHkgbmVlZHMgaXQgYXQgYnVpbGQgdGlt ZSwgc28KKy8vIHdlIGhhdmUgYSBSRUxFQVNFX0FTU0VSVCgpIGluc2lkZSBXVEY6OnBhZ2VTaXpl IHRvIG1ha2Ugc3VyZSBpdCBpcyBzZXQgcHJvcGVybHkgYXQgcnVudGltZS4KKy8vIEFsbCBvZiB0 aGVzZSB2YWx1ZXMgYXJlIGdvaW5nIHRvIGJlIGluY29ycmVjdCBvbiBzeXN0ZW1zIGNvbmZpZ3Vy ZWQgdG8gdXNlIGxhcmdlciB0aGFuIG5vcm1hbAorLy8gcGFnZSBzaXplLCBzbyBvbiBzdWNoIHN5 c3RlbXMgaXQgaXMgZXhwZWN0ZWQgdGhhdCBXZWJLaXQgd2lsbCBjcmFzaCB1bnRpbCB0aGlzIHZh bHVlIGlzIGNoYW5nZWQKKy8vIGFuZCByZWNvbXBpbGVkLiBTb3JyeS4KKy8vCisvLyBtYWNPUyB4 ODZfNjQgdXNlcyA0IEtpQiwgYnV0IEFwcGxlJ3MgYWFyY2g2NCBzeXN0ZW1zIHVzZSAxNiBLaUIu IFVzZSAxNiBLaUIgb24gYWxsIEFwcGxlIHN5c3RlbXMKKy8vIGZvciBjb25zaXN0ZW5jeS4KKy8v CisvLyBNb3N0IExpbnV4IGFuZCBXaW5kb3dzIHN5c3RlbXMgdXNlIGEgcGFnZSBzaXplIG9mIDQg S2lCLgorLy8KKy8vIE9uIExpbnV4LCBQb3dlciBzeXN0ZW1zIG5vcm1hbGx5IHVzZSA2NCBLaUIg cGFnZXMuCisvLworLy8gYWFyY2g2NCBzeXN0ZW1zIHNlZW0gdG8gYmUgYWxsIG92ZXIgdGhlIHBs YWNlLiBNb3N0IExpbnV4IGRpc3Ryb3MgdXNlIDQgS2lCLCBidXQgUkhFTCB1c2VzCisvLyA2NCBL aUIuIChBcHBsZSB1c2VzIDE2IEtpQi4pCisvLworLy8gVXNlIDY0IEtpQiBmb3IgYW55IHVua25v d24gQ1BVcyB0byBiZSBjb25zZXJ2YXRpdmUuCisjaWYgT1MoREFSV0lOKQorY29uc3RleHByIHNp emVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDE2ICogS0I7CisjZWxpZiBPUyhXSU5ET1dTKSB8fCBD UFUoTUlQUykgfHwgQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkgfHwgQ1BVKEFSTSkKK2NvbnN0ZXhw ciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA0ICogS0I7CisjZWxpZiBDUFUoVU5LTk9XTikg fHwgQ1BVKFBQQykgfHwgQ1BVKFBQQzY0KSB8fCBDUFUoUFBDNjRMRSkgfHwgQ1BVKEFSTTY0KQor Y29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7CisjZWxzZQorI2Vy cm9yIE11c3Qgc2V0IENlaWxpbmdPblBhZ2VTaXplIGluIFBhZ2VCbG9jay5oIHdoZW4gYWRkaW5n IGEgbmV3IENQVSBhcmNoaXRlY3R1cmUhCisjZW5kaWYKKwogV1RGX0VYUE9SVF9QUklWQVRFIHNp emVfdCBwYWdlU2l6ZSgpOwogV1RGX0VYUE9SVF9QUklWQVRFIHNpemVfdCBwYWdlTWFzaygpOwog aW5saW5lIGJvb2wgaXNQYWdlQWxpZ25lZCh2b2lkKiBhZGRyZXNzKSB7IHJldHVybiAhKHJlaW50 ZXJwcmV0X2Nhc3Q8aW50cHRyX3Q+KGFkZHJlc3MpICYgKHBhZ2VTaXplKCkgLSAxKSk7IH0KQEAg LTgwLDYgKzExMCw3IEBAIGlubGluZSBQYWdlQmxvY2s6OlBhZ2VCbG9jayh2b2lkKiBiYXNlLCBz aXplX3Qgc2l6ZSwgYm9vbCBoYXNHdWFyZFBhZ2VzKQogCiB9IC8vIG5hbWVzcGFjZSBXVEYKIAor dXNpbmcgV1RGOjpDZWlsaW5nT25QYWdlU2l6ZTsKIHVzaW5nIFdURjo6cGFnZVNpemU7CiB1c2lu ZyBXVEY6OmlzUGFnZUFsaWduZWQ7CiB1c2luZyBXVEY6OmlzUG93ZXJPZlR3bzsK 394736 2020-03-27 11:36:27 -0700 2020-03-27 11:36:27 -0700 JSCOnly aarch64 strace log jsc-aarch64.strace.log text/plain 20127 zan MTk6MzM6MTEuNTg2NDEzIGV4ZWN2ZSgiLi9qc2MiLCBbIi4vanNjIl0sIDB4N2ZkNGI2MjQ2OCAv KiAzMiB2YXJzICovKSA9IDAKMTk6MzM6MTEuNTg5NzkyIGJyayhOVUxMKSAgICAgICAgICAgICAg ID0gMHg1NWEyNGM5MDAwCjE5OjMzOjExLjU5MDEzMiBmYWNjZXNzYXQoQVRfRkRDV0QsICIvZXRj L2xkLnNvLm5vaHdjYXAiLCBGX09LKSA9IC0xIEVOT0VOVCAoTm8gc3VjaCBmaWxlIG9yIGRpcmVj dG9yeSkKMTk6MzM6MTEuNTkwMzkxIGZhY2Nlc3NhdChBVF9GRENXRCwgIi9ldGMvbGQuc28ucHJl bG9hZCIsIFJfT0spID0gLTEgRU5PRU5UIChObyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5KQoxOToz MzoxMS41OTA2Mjggb3BlbmF0KEFUX0ZEQ1dELCAiL2V0Yy9sZC5zby5jYWNoZSIsIE9fUkRPTkxZ fE9fQ0xPRVhFQykgPSAzCjE5OjMzOjExLjU5MTQyNCBmc3RhdCgzLCB7c3RfbW9kZT1TX0lGUkVH fDA2NDQsIHN0X3NpemU9MTQ0NjU3LCAuLi59KSA9IDAKMTk6MzM6MTEuNTkxNjc4IG1tYXAoTlVM TCwgMTQ0NjU3LCBQUk9UX1JFQUQsIE1BUF9QUklWQVRFLCAzLCAwKSA9IDB4N2ZhMzVjYjAwMAox OTozMzoxMS41OTE5MzggY2xvc2UoMykgICAgICAgICAgICAgICAgPSAwCjE5OjMzOjExLjU5MjIx MiBmYWNjZXNzYXQoQVRfRkRDV0QsICIvZXRjL2xkLnNvLm5vaHdjYXAiLCBGX09LKSA9IC0xIEVO T0VOVCAoTm8gc3VjaCBmaWxlIG9yIGRpcmVjdG9yeSkKMTk6MzM6MTEuNTkyNTM5IG9wZW5hdChB VF9GRENXRCwgIi9saWIvYWFyY2g2NC1saW51eC1nbnUvbGliZGwuc28uMiIsIE9fUkRPTkxZfE9f Q0xPRVhFQykgPSAzCjE5OjMzOjExLjU5MjgzOSByZWFkKDMsICJcMTc3RUxGXDJcMVwxXDBcMFww XDBcMFwwXDBcMFwwXDNcMFwyNjdcMFwxXDBcMFwwXDMyMFwxNlwwXDBcMFwwXDBcMCIuLi4sIDgz MikgPSA4MzIKMTk6MzM6MTEuNTkzMzM5IGZzdGF0KDMsIHtzdF9tb2RlPVNfSUZSRUd8MDY0NCwg c3Rfc2l6ZT0xODU0NCwgLi4ufSkgPSAwCjE5OjMzOjExLjU5MzYyNCBtbWFwKE5VTEwsIDgxOTIs IFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTLCAtMSwgMCkg PSAweDdmYTM2MTcwMDAKMTk6MzM6MTEuNTkzOTI3IG1tYXAoTlVMTCwgODIxNzYsIFBST1RfUkVB RHxQUk9UX0VYRUMsIE1BUF9QUklWQVRFfE1BUF9ERU5ZV1JJVEUsIDMsIDApID0gMHg3ZmEzNWI2 MDAwCjE5OjMzOjExLjU5NDQ0NCBtcHJvdGVjdCgweDdmYTM1YjkwMDAsIDY1NTM2LCBQUk9UX05P TkUpID0gMAoxOTozMzoxMS41OTQ3NTIgbW1hcCgweDdmYTM1YzkwMDAsIDgxOTIsIFBST1RfUkVB RHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfRklYRUR8TUFQX0RFTllXUklURSwgMywgMHgz MDAwKSA9IDB4N2ZhMzVjOTAwMAoxOTozMzoxMS41OTUzNTYgY2xvc2UoMykgICAgICAgICAgICAg ICAgPSAwCjE5OjMzOjExLjU5NTU1MSBmYWNjZXNzYXQoQVRfRkRDV0QsICIvZXRjL2xkLnNvLm5v aHdjYXAiLCBGX09LKSA9IC0xIEVOT0VOVCAoTm8gc3VjaCBmaWxlIG9yIGRpcmVjdG9yeSkKMTk6 MzM6MTEuNTk1ODIyIG9wZW5hdChBVF9GRENXRCwgIi91c3IvbGliL2FhcmNoNjQtbGludXgtZ251 L2xpYmljdWkxOG4uc28uNjAiLCBPX1JET05MWXxPX0NMT0VYRUMpID0gMwoxOTozMzoxMS41OTYx MzMgcmVhZCgzLCAiXDE3N0VMRlwyXDFcMVwwXDBcMFwwXDBcMFwwXDBcMFwzXDBcMjY3XDBcMVww XDBcMFwzMjBcMjZcclwwXDBcMFwwXDAiLi4uLCA4MzIpID0gODMyCjE5OjMzOjExLjU5NjUxNSBm c3RhdCgzLCB7c3RfbW9kZT1TX0lGUkVHfDA2NDQsIHN0X3NpemU9MjgwMzkzNiwgLi4ufSkgPSAw CjE5OjMzOjExLjU5Njc1OCBtbWFwKE5VTEwsIDI4NzAyNDgsIFBST1RfUkVBRHxQUk9UX0VYRUMs IE1BUF9QUklWQVRFfE1BUF9ERU5ZV1JJVEUsIDMsIDApID0gMHg3ZmEzMmY5MDAwCjE5OjMzOjEx LjU5NzIyMCBtcHJvdGVjdCgweDdmYTM1OTYwMDAsIDY1NTM2LCBQUk9UX05PTkUpID0gMAoxOToz MzoxMS41OTc1NDIgbW1hcCgweDdmYTM1YTYwMDAsIDY1NTM2LCBQUk9UX1JFQUR8UFJPVF9XUklU RSwgTUFQX1BSSVZBVEV8TUFQX0ZJWEVEfE1BUF9ERU5ZV1JJVEUsIDMsIDB4MjlkMDAwKSA9IDB4 N2ZhMzVhNjAwMAoxOTozMzoxMS41OTgwNDQgY2xvc2UoMykgICAgICAgICAgICAgICAgPSAwCjE5 OjMzOjExLjU5ODQ2OSBmYWNjZXNzYXQoQVRfRkRDV0QsICIvZXRjL2xkLnNvLm5vaHdjYXAiLCBG X09LKSA9IC0xIEVOT0VOVCAoTm8gc3VjaCBmaWxlIG9yIGRpcmVjdG9yeSkKMTk6MzM6MTEuNTk4 ODc4IG9wZW5hdChBVF9GRENXRCwgIi91c3IvbGliL2FhcmNoNjQtbGludXgtZ251L2xpYmljdXVj LnNvLjYwIiwgT19SRE9OTFl8T19DTE9FWEVDKSA9IDMKMTk6MzM6MTEuNTk5Mjg3IHJlYWQoMywg IlwxNzdFTEZcMlwxXDFcMFwwXDBcMFwwXDBcMFwwXDBcM1wwXDI2N1wwXDFcMFwwXDAwMDAgXDZc MFwwXDBcMFwwIi4uLiwgODMyKSA9IDgzMgoxOTozMzoxMS41OTk2NTkgZnN0YXQoMywge3N0X21v ZGU9U19JRlJFR3wwNjQ0LCBzdF9zaXplPTE4NDkzMjgsIC4uLn0pID0gMAoxOTozMzoxMS42MDAw MjcgbW1hcChOVUxMLCAxOTE5NTY4LCBQUk9UX1JFQUR8UFJPVF9FWEVDLCBNQVBfUFJJVkFURXxN QVBfREVOWVdSSVRFLCAzLCAwKSA9IDB4N2ZhMzEyNDAwMAoxOTozMzoxMS42MDAzOTAgbXByb3Rl Y3QoMHg3ZmEzMmQ1MDAwLCA2NTUzNiwgUFJPVF9OT05FKSA9IDAKMTk6MzM6MTEuNjAwNzc0IG1t YXAoMHg3ZmEzMmU1MDAwLCA3NzgyNCwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRF fE1BUF9GSVhFRHxNQVBfREVOWVdSSVRFLCAzLCAweDFiMTAwMCkgPSAweDdmYTMyZTUwMDAKMTk6 MzM6MTEuNjAxMzg4IG1tYXAoMHg3ZmEzMmY4MDAwLCAyNjQwLCBQUk9UX1JFQUR8UFJPVF9XUklU RSwgTUFQX1BSSVZBVEV8TUFQX0ZJWEVEfE1BUF9BTk9OWU1PVVMsIC0xLCAwKSA9IDB4N2ZhMzJm ODAwMAoxOTozMzoxMS42MDE4MTkgY2xvc2UoMykgICAgICAgICAgICAgICAgPSAwCjE5OjMzOjEx LjYwMjIyOSBmYWNjZXNzYXQoQVRfRkRDV0QsICIvZXRjL2xkLnNvLm5vaHdjYXAiLCBGX09LKSA9 IC0xIEVOT0VOVCAoTm8gc3VjaCBmaWxlIG9yIGRpcmVjdG9yeSkKMTk6MzM6MTEuNjAyNzQ5IG9w ZW5hdChBVF9GRENXRCwgIi9saWIvYWFyY2g2NC1saW51eC1nbnUvbGlicHRocmVhZC5zby4wIiwg T19SRE9OTFl8T19DTE9FWEVDKSA9IDMKMTk6MzM6MTEuNjAzMDAzIHJlYWQoMywgIlwxNzdFTEZc MlwxXDFcM1wwXDBcMFwwXDBcMFwwXDBcM1wwXDI2N1wwXDFcMFwwXDBcMzMwXFxcMFwwXDBcMFww XDAiLi4uLCA4MzIpID0gODMyCjE5OjMzOjExLjYwMzI0MyBmc3RhdCgzLCB7c3RfbW9kZT1TX0lG UkVHfDA3NTUsIHN0X3NpemU9MTM3ODQ4LCAuLi59KSA9IDAKMTk6MzM6MTEuNjAzNTQ3IG1tYXAo TlVMTCwgMTc3MTA0LCBQUk9UX1JFQUR8UFJPVF9FWEVDLCBNQVBfUFJJVkFURXxNQVBfREVOWVdS SVRFLCAzLCAwKSA9IDB4N2ZhMzBmODAwMAoxOTozMzoxMS42MDM4NzAgbXByb3RlY3QoMHg3ZmEz MTBmMDAwLCA2MTQ0MCwgUFJPVF9OT05FKSA9IDAKMTk6MzM6MTEuNjA0MTUyIG1tYXAoMHg3ZmEz MTFlMDAwLCA4MTkyLCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8TUFQX0ZJWEVE fE1BUF9ERU5ZV1JJVEUsIDMsIDB4MTYwMDApID0gMHg3ZmEzMTFlMDAwCjE5OjMzOjExLjYwNDQ2 OSBtbWFwKDB4N2ZhMzEyMDAwMCwgMTMyNjQsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJ VkFURXxNQVBfRklYRUR8TUFQX0FOT05ZTU9VUywgLTEsIDApID0gMHg3ZmEzMTIwMDAwCjE5OjMz OjExLjYwNDc4MiBjbG9zZSgzKSAgICAgICAgICAgICAgICA9IDAKMTk6MzM6MTEuNjA1Mjc5IGZh Y2Nlc3NhdChBVF9GRENXRCwgIi9ldGMvbGQuc28ubm9od2NhcCIsIEZfT0spID0gLTEgRU5PRU5U IChObyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5KQoxOTozMzoxMS42MDU2MzAgb3BlbmF0KEFUX0ZE Q1dELCAiL3Vzci9saWIvYWFyY2g2NC1saW51eC1nbnUvbGlic3RkYysrLnNvLjYiLCBPX1JET05M WXxPX0NMT0VYRUMpID0gMwoxOTozMzoxMS42MDYwNDcgcmVhZCgzLCAiXDE3N0VMRlwyXDFcMVwz XDBcMFwwXDBcMFwwXDBcMFwzXDBcMjY3XDBcMVwwXDBcMFwyMFwzMTdcMTBcMFwwXDBcMFwwIi4u LiwgODMyKSA9IDgzMgoxOTozMzoxMS42MDY0OTEgZnN0YXQoMywge3N0X21vZGU9U19JRlJFR3ww NjQ0LCBzdF9zaXplPTE1NzQ1NjAsIC4uLn0pID0gMAoxOTozMzoxMS42MDY4NzggbW1hcChOVUxM LCAxNjUwMzIwLCBQUk9UX1JFQUR8UFJPVF9FWEVDLCBNQVBfUFJJVkFURXxNQVBfREVOWVdSSVRF LCAzLCAwKSA9IDB4N2ZhMmY2NTAwMAoxOTozMzoxMS42MDcyNTEgbXByb3RlY3QoMHg3ZmEzMGQ5 MDAwLCA2NTUzNiwgUFJPVF9OT05FKSA9IDAKMTk6MzM6MTEuNjA3NjE4IG1tYXAoMHg3ZmEzMGU5 MDAwLCA0OTE1MiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRFfE1BUF9GSVhFRHxN QVBfREVOWVdSSVRFLCAzLCAweDE3NDAwMCkgPSAweDdmYTMwZTkwMDAKMTk6MzM6MTEuNjA4MDM4 IG1tYXAoMHg3ZmEzMGY1MDAwLCAxMTkyMCwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklW QVRFfE1BUF9GSVhFRHxNQVBfQU5PTllNT1VTLCAtMSwgMCkgPSAweDdmYTMwZjUwMDAKMTk6MzM6 MTEuNjA4NDY0IGNsb3NlKDMpICAgICAgICAgICAgICAgID0gMAoxOTozMzoxMS42MDg5MzAgZmFj Y2Vzc2F0KEFUX0ZEQ1dELCAiL2V0Yy9sZC5zby5ub2h3Y2FwIiwgRl9PSykgPSAtMSBFTk9FTlQg KE5vIHN1Y2ggZmlsZSBvciBkaXJlY3RvcnkpCjE5OjMzOjExLjYwOTM3NyBvcGVuYXQoQVRfRkRD V0QsICIvbGliL2FhcmNoNjQtbGludXgtZ251L2xpYm0uc28uNiIsIE9fUkRPTkxZfE9fQ0xPRVhF QykgPSAzCjE5OjMzOjExLjYwOTc4NCByZWFkKDMsICJcMTc3RUxGXDJcMVwxXDBcMFwwXDBcMFww XDBcMFwwXDNcMFwyNjdcMFwxXDBcMFwwQFwyNTdcMFwwXDBcMFwwXDAiLi4uLCA4MzIpID0gODMy CjE5OjMzOjExLjYxMDA5OCBmc3RhdCgzLCB7c3RfbW9kZT1TX0lGUkVHfDA2NDQsIHN0X3NpemU9 Njk1NjQwLCAuLi59KSA9IDAKMTk6MzM6MTEuNjEwMzA1IG1tYXAoTlVMTCwgNzU3ODgwLCBQUk9U X1JFQUR8UFJPVF9FWEVDLCBNQVBfUFJJVkFURXxNQVBfREVOWVdSSVRFLCAzLCAwKSA9IDB4N2Zh MmVhYjAwMAoxOTozMzoxMS42MTA1MjggbXByb3RlY3QoMHg3ZmEyZjU0MDAwLCA2MTQ0MCwgUFJP VF9OT05FKSA9IDAKMTk6MzM6MTEuNjEwNzg4IG1tYXAoMHg3ZmEyZjYzMDAwLCA4MTkyLCBQUk9U X1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8TUFQX0ZJWEVEfE1BUF9ERU5ZV1JJVEUsIDMs IDB4YTgwMDApID0gMHg3ZmEyZjYzMDAwCjE5OjMzOjExLjYxMTEyOCBjbG9zZSgzKSAgICAgICAg ICAgICAgICA9IDAKMTk6MzM6MTEuNjExNDI1IGZhY2Nlc3NhdChBVF9GRENXRCwgIi9ldGMvbGQu c28ubm9od2NhcCIsIEZfT0spID0gLTEgRU5PRU5UIChObyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5 KQoxOTozMzoxMS42MTE3MzUgb3BlbmF0KEFUX0ZEQ1dELCAiL2xpYi9hYXJjaDY0LWxpbnV4LWdu dS9saWJnY2Nfcy5zby4xIiwgT19SRE9OTFl8T19DTE9FWEVDKSA9IDMKMTk6MzM6MTEuNjEyMDQ1 IHJlYWQoMywgIlwxNzdFTEZcMlwxXDFcMFwwXDBcMFwwXDBcMFwwXDBcM1wwXDI2N1wwXDFcMFww XDBcMjApXDBcMFwwXDBcMFwwIi4uLiwgODMyKSA9IDgzMgoxOTozMzoxMS42MTIzMzQgZnN0YXQo Mywge3N0X21vZGU9U19JRlJFR3wwNjQ0LCBzdF9zaXplPTgwMTY4LCAuLi59KSA9IDAKMTk6MzM6 MTEuNjEyNjE5IG1tYXAoTlVMTCwgODE5MiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklW QVRFfE1BUF9BTk9OWU1PVVMsIC0xLCAwKSA9IDB4N2ZhMzYxNTAwMAoxOTozMzoxMS42MTI5Mzkg bW1hcChOVUxMLCAxNDQ0NDAsIFBST1RfUkVBRHxQUk9UX0VYRUMsIE1BUF9QUklWQVRFfE1BUF9E RU5ZV1JJVEUsIDMsIDApID0gMHg3ZmEyZTg3MDAwCjE5OjMzOjExLjYxMzIzMSBtcHJvdGVjdCgw eDdmYTJlOWEwMDAsIDYxNDQwLCBQUk9UX05PTkUpID0gMAoxOTozMzoxMS42MTM0MjQgbW1hcCgw eDdmYTJlYTkwMDAsIDgxOTIsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBf RklYRUR8TUFQX0RFTllXUklURSwgMywgMHgxMjAwMCkgPSAweDdmYTJlYTkwMDAKMTk6MzM6MTEu NjEzNjE2IGNsb3NlKDMpICAgICAgICAgICAgICAgID0gMAoxOTozMzoxMS42MTM4MjIgZmFjY2Vz c2F0KEFUX0ZEQ1dELCAiL2V0Yy9sZC5zby5ub2h3Y2FwIiwgRl9PSykgPSAtMSBFTk9FTlQgKE5v IHN1Y2ggZmlsZSBvciBkaXJlY3RvcnkpCjE5OjMzOjExLjYxNDEwOSBvcGVuYXQoQVRfRkRDV0Qs ICIvbGliL2FhcmNoNjQtbGludXgtZ251L2xpYmMuc28uNiIsIE9fUkRPTkxZfE9fQ0xPRVhFQykg PSAzCjE5OjMzOjExLjYxNDQxNCByZWFkKDMsICJcMTc3RUxGXDJcMVwxXDNcMFwwXDBcMFwwXDBc MFwwXDNcMFwyNjdcMFwxXDBcMFwwIFwxMFwyXDBcMFwwXDBcMCIuLi4sIDgzMikgPSA4MzIKMTk6 MzM6MTEuNjE0ODA1IGZzdGF0KDMsIHtzdF9tb2RlPVNfSUZSRUd8MDc1NSwgc3Rfc2l6ZT0xMzQx MDgwLCAuLi59KSA9IDAKMTk6MzM6MTEuNjE1MDEzIG1tYXAoTlVMTCwgMTQwOTg4MCwgUFJPVF9S RUFEfFBST1RfRVhFQywgTUFQX1BSSVZBVEV8TUFQX0RFTllXUklURSwgMywgMCkgPSAweDdmYTJk MmUwMDAKMTk6MzM6MTEuNjE1MjE5IG1wcm90ZWN0KDB4N2ZhMmU2ZTAwMCwgNjE0NDAsIFBST1Rf Tk9ORSkgPSAwCjE5OjMzOjExLjYxNTQ2NCBtbWFwKDB4N2ZhMmU3ZDAwMCwgMjQ1NzYsIFBST1Rf UkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfRklYRUR8TUFQX0RFTllXUklURSwgMywg MHgxM2YwMDApID0gMHg3ZmEyZTdkMDAwCjE5OjMzOjExLjYxNTc4MCBtbWFwKDB4N2ZhMmU4MzAw MCwgMTMxNDQsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfRklYRUR8TUFQ X0FOT05ZTU9VUywgLTEsIDApID0gMHg3ZmEyZTgzMDAwCjE5OjMzOjExLjYxNjA4OSBjbG9zZSgz KSAgICAgICAgICAgICAgICA9IDAKMTk6MzM6MTEuNjE2MzY0IGZhY2Nlc3NhdChBVF9GRENXRCwg Ii9ldGMvbGQuc28ubm9od2NhcCIsIEZfT0spID0gLTEgRU5PRU5UIChObyBzdWNoIGZpbGUgb3Ig ZGlyZWN0b3J5KQoxOTozMzoxMS42MTY1Mjcgb3BlbmF0KEFUX0ZEQ1dELCAiL3Vzci9saWIvYWFy Y2g2NC1saW51eC1nbnUvbGliaWN1ZGF0YS5zby42MCIsIE9fUkRPTkxZfE9fQ0xPRVhFQykgPSAz CjE5OjMzOjExLjYxNjcwNCByZWFkKDMsICJcMTc3RUxGXDJcMVwxXDBcMFwwXDBcMFwwXDBcMFww XDNcMFwyNjdcMFwxXDBcMFwwXDM0MFw1XDBcMFwwXDBcMFwwIi4uLiwgODMyKSA9IDgzMgoxOToz MzoxMS42MTcxOTUgZnN0YXQoMywge3N0X21vZGU9U19JRlJFR3wwNjQ0LCBzdF9zaXplPTI2OTA0 MjY0LCAuLi59KSA9IDAKMTk6MzM6MTEuNjE3NDQ2IG1tYXAoTlVMTCwgMjY5NjgwODAsIFBST1Rf UkVBRHxQUk9UX0VYRUMsIE1BUF9QUklWQVRFfE1BUF9ERU5ZV1JJVEUsIDMsIDApID0gMHg3ZmEx Mzc1MDAwCjE5OjMzOjExLjYxNzY2NSBtcHJvdGVjdCgweDdmYTJkMWQwMDAsIDYxNDQwLCBQUk9U X05PTkUpID0gMAoxOTozMzoxMS42MTc4ODQgbW1hcCgweDdmYTJkMmMwMDAsIDgxOTIsIFBST1Rf UkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfRklYRUR8TUFQX0RFTllXUklURSwgMywg MHgxOWE3MDAwKSA9IDB4N2ZhMmQyYzAwMAoxOTozMzoxMS42MTgxNTIgY2xvc2UoMykgICAgICAg ICAgICAgICAgPSAwCjE5OjMzOjExLjYxODU2NiBtbWFwKE5VTEwsIDgxOTIsIFBST1RfUkVBRHxQ Uk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTLCAtMSwgMCkgPSAweDdmYTM2MTMw MDAKMTk6MzM6MTEuNjE5MDU3IG1wcm90ZWN0KDB4N2ZhMmU3ZDAwMCwgMTYzODQsIFBST1RfUkVB RCkgPSAwCjE5OjMzOjExLjYxOTM0MSBtcHJvdGVjdCgweDdmYTJkMmMwMDAsIDQwOTYsIFBST1Rf UkVBRCkgPSAwCjE5OjMzOjExLjYxOTYyNiBtcHJvdGVjdCgweDdmYTJlYTkwMDAsIDQwOTYsIFBS T1RfUkVBRCkgPSAwCjE5OjMzOjExLjYyMDE1MSBtcHJvdGVjdCgweDdmYTJmNjMwMDAsIDQwOTYs IFBST1RfUkVBRCkgPSAwCjE5OjMzOjExLjYyMTcxMCBtbWFwKE5VTEwsIDgxOTIsIFBST1RfUkVB RHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTLCAtMSwgMCkgPSAweDdmYTM2 MTEwMDAKMTk6MzM6MTEuNjI1MjI1IG1wcm90ZWN0KDB4N2ZhMzBlOTAwMCwgNDA5NjAsIFBST1Rf UkVBRCkgPSAwCjE5OjMzOjExLjYyNTQxNiBtcHJvdGVjdCgweDdmYTMxMWUwMDAsIDQwOTYsIFBS T1RfUkVBRCkgPSAwCjE5OjMzOjExLjYyNTU5NCBtcHJvdGVjdCgweDdmYTM1YzkwMDAsIDQwOTYs IFBST1RfUkVBRCkgPSAwCjE5OjMzOjExLjYyNjMzMyBtcHJvdGVjdCgweDdmYTMyZTUwMDAsIDcz NzI4LCBQUk9UX1JFQUQpID0gMAoxOTozMzoxMS42MjgyMTAgbXByb3RlY3QoMHg3ZmEzNWE2MDAw LCA2MTQ0MCwgUFJPVF9SRUFEKSA9IDAKMTk6MzM6MTEuNjI5NzU5IG1wcm90ZWN0KDB4NTU2ZTM3 MjAwMCwgMjU4MDQ4LCBQUk9UX1JFQUQpID0gMAoxOTozMzoxMS42MzAwMDcgbXByb3RlY3QoMHg3 ZmEzNjFiMDAwLCA0MDk2LCBQUk9UX1JFQUQpID0gMAoxOTozMzoxMS42MzAxMjggbXVubWFwKDB4 N2ZhMzVjYjAwMCwgMTQ0NjU3KSA9IDAKMTk6MzM6MTEuNjMwMjQzIHNldF90aWRfYWRkcmVzcygw eDdmYTM2MTM2ZjApID0gMTA2NTIKMTk6MzM6MTEuNjMwMzMwIHNldF9yb2J1c3RfbGlzdCgweDdm YTM2MTM3MDAsIDI0KSA9IDAKMTk6MzM6MTEuNjMwNDY0IHJ0X3NpZ2FjdGlvbihTSUdSVE1JTiwg e3NhX2hhbmRsZXI9MHg3ZmEzMGZkNzYwLCBzYV9tYXNrPVtdLCBzYV9mbGFncz1TQV9TSUdJTkZP fSwgTlVMTCwgOCkgPSAwCjE5OjMzOjExLjYzMDU5OSBydF9zaWdhY3Rpb24oU0lHUlRfMSwge3Nh X2hhbmRsZXI9MHg3ZmEzMGZkODI4LCBzYV9tYXNrPVtdLCBzYV9mbGFncz1TQV9SRVNUQVJUfFNB X1NJR0lORk99LCBOVUxMLCA4KSA9IDAKMTk6MzM6MTEuNjMwNzIxIHJ0X3NpZ3Byb2NtYXNrKFNJ R19VTkJMT0NLLCBbUlRNSU4gUlRfMV0sIE5VTEwsIDgpID0gMAoxOTozMzoxMS42MzA4NTggcHJs aW1pdDY0KDAsIFJMSU1JVF9TVEFDSywgTlVMTCwge3JsaW1fY3VyPTgxOTIqMTAyNCwgcmxpbV9t YXg9UkxJTTY0X0lORklOSVRZfSkgPSAwCjE5OjMzOjExLjYzMTIyMiBicmsoTlVMTCkgICAgICAg ICAgICAgICA9IDB4NTVhMjRjOTAwMAoxOTozMzoxMS42MzEzMzMgYnJrKDB4NTVhMjRlYTAwMCkg ICAgICAgPSAweDU1YTI0ZWEwMDAKMTk6MzM6MTEuNjMxNTQ5IGZ1dGV4KDB4NTU2ZTNlMTVkOCwg RlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjMxNjc4IG9wZW5h dChBVF9GRENXRCwgIi9kZXYvdXJhbmRvbSIsIE9fUkRPTkxZKSA9IDMKMTk6MzM6MTEuNjMxODQy IGZ1dGV4KDB4NTU2ZTNlMTZkMCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAK MTk6MzM6MTEuNjMxOTQ4IHJlYWQoMywgIm5YXDdcMDA2NlwyNTdcMjI2XDMyMFwxNzdcMjUwXDM0 MF8zXDIyMlg2KHQuamQoXDIyXDI2NmhcMjE2NlwxNlwyMzFAUlwyNzMiLi4uLCAxMjgpID0gMTI4 CjE5OjMzOjExLjYzMjExMyBydF9zaWdhY3Rpb24oU0lHVVNSMSwge3NhX2hhbmRsZXI9MHg1NTZl MjgzODMwLCBzYV9tYXNrPVtVU1IxXSwgc2FfZmxhZ3M9U0FfUkVTVEFSVHxTQV9TSUdJTkZPfSwg TlVMTCwgOCkgPSAwCjE5OjMzOjExLjYzMjIzNCBmdXRleCgweDU1NmUzZTE3ODAsIEZVVEVYX1dB S0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjYzMjM2OCBmdXRleCgweDU1NmUz ZTE2ODAsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjYzMjUz OSBvcGVuYXQoQVRfRkRDV0QsICIvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9vbmxpbmUiLCBPX1JE T05MWXxPX0NMT0VYRUMpID0gNAoxOTozMzoxMS42MzI2ODcgcmVhZCg0LCAiMC0zXG4iLCA4MTky KSAgPSA0CjE5OjMzOjExLjYzMjgyOSBjbG9zZSg0KSAgICAgICAgICAgICAgICA9IDAKMTk6MzM6 MTEuNjMzMTIyIGZ1dGV4KDB4NTU2ZTNlMTEyMCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgz NjQ3KSA9IDAKMTk6MzM6MTEuNjMzMjkxIGZ1dGV4KDB4N2ZhMzVjYTBlOCwgRlVURVhfV0FLRV9Q UklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjMzNDI2IG1tYXAoTlVMTCwgNDUwNTYs IFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTfE1BUF9OT1JF U0VSVkUsIC0xLCAwKSA9IDB4N2ZhMzVlNDAwMAoxOTozMzoxMS42MzM1ODAgbW1hcChOVUxMLCA0 MDk2LCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8TUFQX0FOT05ZTU9VU3xNQVBf Tk9SRVNFUlZFLCAtMSwgMCkgPSAweDdmYTM2MTAwMDAKMTk6MzM6MTEuNjMzNzMzIG1tYXAoTlVM TCwgODE5MiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRFfE1BUF9BTk9OWU1PVVN8 TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3ZmEzNjBlMDAwCjE5OjMzOjExLjYzMzkxNSBmdXRl eCgweDU1NmUzZTUwMDgsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMz OjExLjYzNDA1NyBvcGVuYXQoQVRfRkRDV0QsICIvZGV2L3VyYW5kb20iLCBPX1JET05MWSkgPSA0 CjE5OjMzOjExLjYzNDIzMCBmdXRleCgweDU1NmUzZWQ4MjgsIEZVVEVYX1dBS0VfUFJJVkFURSwg MjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjYzNDM2OCByZWFkKDQsICIsXDIxZVwzNTFhXDMxNFwz NzZcMTdcMzEycEdcMzI2fkRcMjczVlwzNjJcNFwzNjBcMjIxXDMzMVwzNDJcMjU3XDMwMlwyNDVg XDMwZ1wzNjZcMjc3XDJcMzE2Ii4uLiwgMTI4KSA9IDEyOAoxOTozMzoxMS42MzQ1MzQgbW1hcChO VUxMLCAxMzc0Mzg5NTM0NzIsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBf QU5PTllNT1VTfE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9IDB4NWZhMTM3NTAwMAoxOTozMzoxMS42 MzQ2ODIgbXVubWFwKDB4NWZhMTM3NTAwMCwgMTU5MDIxMDU2MCkgPSAwCjE5OjMzOjExLjYzNDgz NCBtdW5tYXAoMHg3ODAwMDAwMDAwLCAzMjc2OTUyNzgwOCkgPSAwCjE5OjMzOjExLjYzNDk4NyBt cHJvdGVjdCgweDcwMDAwMDAwMDAsIDM0MzU5NzM4MzY4LCBQUk9UX05PTkUpID0gMAoxOTozMzox MS42MzUxMzIgbWFkdmlzZSgweDYwMDAwMDAwMDAsIDEwMzA3OTIxNTEwNCwgTUFEVl9ET05UTkVF RCkgPSAwCjE5OjMzOjExLjYzNTI3MyBtYWR2aXNlKDB4NjAwMDAwMDAwMCwgMTAzMDc5MjE1MTA0 LCBNQURWX0RPTlREVU1QKSA9IDAKMTk6MzM6MTEuNjM1NDEwIG1wcm90ZWN0KDB4NTU2ZTNlOTAw MCwgMTYzODQsIFBST1RfUkVBRCkgPSAwCjE5OjMzOjExLjYzNTU1NyBmdXRleCgweDU1NmUzZTUw MDAsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjYzNTY5OCBt bWFwKE5VTEwsIDQwOTYsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5P TllNT1VTfE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9IDB4N2ZhMzYwZDAwMAoxOTozMzoxMS42MzU4 OTUgbW1hcChOVUxMLCA4MzkyNzA0LCBQUk9UX05PTkUsIE1BUF9QUklWQVRFfE1BUF9BTk9OWU1P VVN8TUFQX1NUQUNLLCAtMSwgMCkgPSAweDdmYTBiNzQwMDAKMTk6MzM6MTEuNjM2MDQ4IG1wcm90 ZWN0KDB4N2ZhMGI3NTAwMCwgODM4ODYwOCwgUFJPVF9SRUFEfFBST1RfV1JJVEUpID0gMAoxOToz MzoxMS42MzYyNDUgY2xvbmUoY2hpbGRfc3RhY2s9MHg3ZmExMzczYWUwLCBmbGFncz1DTE9ORV9W TXxDTE9ORV9GU3xDTE9ORV9GSUxFU3xDTE9ORV9TSUdIQU5EfENMT05FX1RIUkVBRHxDTE9ORV9T WVNWU0VNfENMT05FX1NFVFRMU3xDTE9ORV9QQVJFTlRfU0VUVElEfENMT05FX0NISUxEX0NMRUFS VElELCBwYXJlbnRfdGlkcHRyPTB4N2ZhMTM3NDJhMCwgdGxzPTB4N2ZhMTM3NDhjMCwgY2hpbGRf dGlkcHRyPTB4N2ZhMTM3NDJhMCkgPSAxMDY1MwoxOTozMzoxMS42MzY0NzggbW1hcChOVUxMLCA0 MDk2LCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8TUFQX0FOT05ZTU9VU3xNQVBf Tk9SRVNFUlZFLCAtMSwgMCkgPSAweDdmYTM2MGMwMDAKMTk6MzM6MTEuNjM2NzAyIGZ1dGV4KDB4 NTU2ZTNlMWM0OCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEu NjM2ODIzIG1tYXAoTlVMTCwgMjA5NzE1MiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklW QVRFfE1BUF9BTk9OWU1PVVN8TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3ZmEwOTc0MDAwCjE5 OjMzOjExLjYzNjk2NCBtdW5tYXAoMHg3ZmEwOTc0MDAwLCA1NzM0NDApID0gMAoxOTozMzoxMS42 MzcwNjUgbXVubWFwKDB4N2ZhMGIwMDAwMCwgNDc1MTM2KSA9IDAKMTk6MzM6MTEuNjM3MTc1IG1t YXAoTlVMTCwgNDA5NiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRFfE1BUF9BTk9O WU1PVVN8TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3ZmEzNWUzMDAwCjE5OjMzOjExLjYzNzMw NSBtYWR2aXNlKDB4N2ZhMGEwMDAwMCwgMTA0ODU3NiwgTUFEVl9OT1JNQUwpID0gMAoxOTozMzox MS42Mzc0MjEgbWFkdmlzZSgweDdmYTBhMDAwMDAsIDEwNDg1NzYsIE1BRFZfRE9EVU1QKSA9IDAK MTk6MzM6MTEuNjM3NTQxIG1tYXAoTlVMTCwgNDA5NiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1B UF9QUklWQVRFfE1BUF9BTk9OWU1PVVN8TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3ZmEzNWUy MDAwCjE5OjMzOjExLjYzNzY3OCBtbWFwKE5VTEwsIDQwOTYsIFBST1RfUkVBRHxQUk9UX1dSSVRF LCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTfE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9IDB4N2Zh MzVlMTAwMAoxOTozMzoxMS42Mzc4NTUgZnV0ZXgoMHg1NTZlM2VkN2I4LCBGVVRFWF9XQUtFX1BS SVZBVEUsIDIxNDc0ODM2NDcpID0gMQoxOTozMzoxMS42MzgwNDUgbW1hcChOVUxMLCAxMzQyMjU5 MjAsIFBST1RfTk9ORSwgTUFQX1BSSVZBVEV8TUFQX0FOT05ZTU9VU3xNQVBfTk9SRVNFUlZFLCAt MSwgMCkgPSAweDdmOTg5ZmUwMDAKMTk6MzM6MTEuNjM4MTgyIG1hZHZpc2UoMHg3Zjk4OWZlMDAw LCAxMzQyMjU5MjAsIE1BRFZfRE9OVE5FRUQpID0gMAoxOTozMzoxMS42MzgzNDAgZnV0ZXgoMHg1 NTZlM2UxMTg4LCBGVVRFWF9XQUtFX1BSSVZBVEUsIDIxNDc0ODM2NDcpID0gMAoxOTozMzoxMS42 Mzg2MDQgb3BlbmF0KEFUX0ZEQ1dELCAiL3Byb2Mvc2VsZi9tYXBzIiwgT19SRE9OTFl8T19DTE9F WEVDKSA9IDUKMTk6MzM6MTEuNjM4ODA2IHBybGltaXQ2NCgwLCBSTElNSVRfU1RBQ0ssIE5VTEws IHtybGltX2N1cj04MTkyKjEwMjQsIHJsaW1fbWF4PVJMSU02NF9JTkZJTklUWX0pID0gMAoxOToz MzoxMS42Mzg5NzAgZnN0YXQoNSwge3N0X21vZGU9U19JRlJFR3wwNDQ0LCBzdF9zaXplPTAsIC4u Ln0pID0gMAoxOTozMzoxMS42MzkxMTUgcmVhZCg1LCAiNTU2ZDQ4MTAwMC01NTZlMzU3MDAwIHIt eHAgMDAwMDAiLi4uLCAxMDI0KSA9IDEwMjQKMTk6MzM6MTEuNjM5MzYxIHJlYWQoNSwgIjMwNzM3 ICAgICAgICAgICAgICAgICAgICAgICAgIC91Ii4uLiwgMTAyNCkgPSAxMDI0CjE5OjMzOjExLjYz OTU3MSByZWFkKDUsICIwMDAgcnctcCAwMDAxMzAwMCBiMzowMSA1MjU2OTEgICIuLi4sIDEwMjQp ID0gMTAyNAoxOTozMzoxMS42Mzk3NzcgcmVhZCg1LCAiZjgwMDAgcnctcCAwMDAwMDAwMCAwMDow MCAwIFxuN2ZhIi4uLiwgMTAyNCkgPSAxMDI0CjE5OjMzOjExLjYzOTk4MyByZWFkKDUsICJydy1w IDAwMDAwMDAwIDAwOjAwIDAgXG43ZmEzMmY5MDAiLi4uLCAxMDI0KSA9IDEwMjQKMTk6MzM6MTEu NjQwMTg5IHJlYWQoNSwgIjEgNTI1NTg2ICAgICAgICAgICAgICAgICAgICAgICAgIi4uLiwgMTAy NCkgPSA2MTIKMTk6MzM6MTEuNjQwMzc3IGNsb3NlKDUpICAgICAgICAgICAgICAgID0gMAoxOToz MzoxMS42NDA1MTQgc2NoZWRfZ2V0YWZmaW5pdHkoMTA2NTIsIDMyLCBbMCwgMSwgMiwgM10pID0g OAoxOTozMzoxMS42NDA2NjcgcnRfc2lncHJvY21hc2soU0lHX1VOQkxPQ0ssIFtVU1IxXSwgTlVM TCwgOCkgPSAwCjE5OjMzOjExLjY0MDg1NCBmdXRleCgweDU1NmUzYzdkMTAsIEZVVEVYX1dBS0Vf UFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjY0MTE4MSBydF9zaWdhY3Rpb24oU0lH U0VHViwge3NhX2hhbmRsZXI9MHg1NTZlMjdmZTg4LCBzYV9tYXNrPX5bVVNSMSBSVE1JTiBSVF8x XSwgc2FfZmxhZ3M9U0FfU0lHSU5GT30sIHtzYV9oYW5kbGVyPVNJR19ERkwsIHNhX21hc2s9W10s IHNhX2ZsYWdzPTB9LCA4KSA9IDAKMTk6MzM6MTEuNjQxMzk1IHJ0X3NpZ2FjdGlvbihTSUdCVVMs IHtzYV9oYW5kbGVyPTB4NTU2ZTI3ZmU4OCwgc2FfbWFzaz1+W1VTUjEgUlRNSU4gUlRfMV0sIHNh X2ZsYWdzPVNBX1NJR0lORk99LCB7c2FfaGFuZGxlcj1TSUdfREZMLCBzYV9tYXNrPVtdLCBzYV9m bGFncz0wfSwgOCkgPSAwCjE5OjMzOjExLjY0MTYzMyBmdXRleCgweDU1NmUzZTFiYTgsIEZVVEVY X1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjY0MTgwNyBmdXRleCgweDU1 NmUzZTEzMTAsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjExLjY0 MTkyMyBtcHJvdGVjdCgweDU1NmUzZTkwMDAsIDE2Mzg0LCBQUk9UX1JFQUR8UFJPVF9XUklURSkg PSAwCjE5OjMzOjExLjY0MjA1OSBtcHJvdGVjdCgweDU1NmUzZTkwMDAsIDE2Mzg0LCBQUk9UX1JF QUR8UFJPVF9XUklURSkgPSAwCjE5OjMzOjExLjY0MjE5OSBtcHJvdGVjdCgweDU1NmUzZTkwMDAs IDE2Mzg0LCBQUk9UX1JFQUQpID0gMAoxOTozMzoxMS42NDIzNTAgZnV0ZXgoMHg1NTZlM2MxMDI4 LCBGVVRFWF9XQUtFX1BSSVZBVEUsIDIxNDc0ODM2NDcpID0gMAoxOTozMzoxMS42NDI0NzYgZnV0 ZXgoMHg1NTZlM2MxMDMwLCBGVVRFWF9XQUtFX1BSSVZBVEUsIDIxNDc0ODM2NDcpID0gMAoxOToz MzoxMS42NDI2MjIgbW1hcChOVUxMLCAyMDk3MTUyLCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQ X1BSSVZBVEV8TUFQX0FOT05ZTU9VU3xNQVBfTk9SRVNFUlZFLCAtMSwgMCkgPSAweDdmOTg3ZmUw MDAKMTk6MzM6MTEuNjQyNzk2IG11bm1hcCgweDdmOTg3ZmUwMDAsIDgxOTIpID0gMAoxOTozMzox MS42NDI5MTUgbXVubWFwKDB4N2Y5ODkwMDAwMCwgMTA0MDM4NCkgPSAwCjE5OjMzOjExLjY0MzAx MSBtYWR2aXNlKDB4N2Y5ODgwMDAwMCwgMTIyODgwLCBNQURWX05PUk1BTCkgPSAwCjE5OjMzOjEx LjY0MzA5OSBtYWR2aXNlKDB4N2Y5ODgwMDAwMCwgMTIyODgwLCBNQURWX0RPRFVNUCkgPSAwCjE5 OjMzOjExLjY0MzI0NCBzeXNpbmZvKHt1cHRpbWU9MTY2MSwgbG9hZHM9WzE5MDQwLCA5NTY4LCAx MTQ1Nl0sIHRvdGFscmFtPTQxNDg1MjMwMDgsIGZyZWVyYW09MjAyNjA0OTUzNiwgc2hhcmVkcmFt PTQyMTEwOTc2LCBidWZmZXJyYW09NDA3NDcwMDgsIHRvdGFsc3dhcD0yMDc0MjQ3MTY4LCBmcmVl c3dhcD0yMDc0MjQ3MTY4LCBwcm9jcz01MDQsIHRvdGFsaGlnaD0wLCBmcmVlaGlnaD0wLCBtZW1f dW5pdD0xfSkgPSAwCjE5OjMzOjExLjY0MzM4MyBvcGVuYXQoQVRfRkRDV0QsICIvcHJvYy9zZWxm L3N0YXRtIiwgT19SRE9OTFl8T19DTE9FWEVDKSA9IDUKMTk6MzM6MTEuNjQzNTU1IGZ1dGV4KDB4 NTU2ZTNlMWM0MCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEu NjQzNjgwIGZ1dGV4KDB4NTU2ZTNlMWMzOCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3 KSA9IDAKMTk6MzM6MTEuNjQzODA3IGZ1dGV4KDB4NTU2ZTNlMTcyMCwgRlVURVhfV0FLRV9QUklW QVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjQ0MTMxIGZ1dGV4KDB4NTU2ZTNjMTJkMCwg RlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjQ0MjgxIGZ1dGV4 KDB4NTU2ZTNjMTJlMCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6 MTEuNjQ0NTU5IGZ1dGV4KDB4NTU2ZTNjMTJjMCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgz NjQ3KSA9IDAKMTk6MzM6MTEuNjQ1MjU0IGZ1dGV4KDB4NTU2ZTNlMTEwMCwgRlVURVhfV0FLRV9Q UklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjQ1NjAzIGZ1dGV4KDB4NTU2ZTNlMTM0 MCwgRlVURVhfV0FLRV9QUklWQVRFLCAyMTQ3NDgzNjQ3KSA9IDAKMTk6MzM6MTEuNjQ2MTIyIG1h ZHZpc2UoMHg3Zjk4ODFlMDAwLCA2NTUzNiwgTUFEVl9OT1JNQUwpID0gMAoxOTozMzoxMS42NDYz ODkgbWFkdmlzZSgweDdmOTg4MWUwMDAsIDY1NTM2LCBNQURWX0RPRFVNUCkgPSAwCjE5OjMzOjEx LjY0NjU5NiBtbWFwKE5VTEwsIDIwOTcxNTIsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJ VkFURXxNQVBfQU5PTllNT1VTfE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9IDB4N2Y5ODYwMDAwMAox OTozMzoxMS42NDY3NzMgbXVubWFwKDB4N2Y5ODcwMDAwMCwgMTA0ODU3NikgPSAwCjE5OjMzOjEx LjY0Njk2MiBtYWR2aXNlKDB4N2Y5ODYwMDAwMCwgMTA0ODU3NiwgTUFEVl9OT1JNQUwpID0gMAox OTozMzoxMS42NDcxNTQgbWFkdmlzZSgweDdmOTg2MDAwMDAsIDEwNDg1NzYsIE1BRFZfRE9EVU1Q KSA9IDAKMTk6MzM6MTEuNjQ3MzY5IG1hZHZpc2UoMHg3Zjk4NjAzMDAwLCA0MDk2LCBNQURWX0RP TlRORUVEKSA9IDAKMTk6MzM6MTEuNjQ3NTg0IG1hZHZpc2UoMHg3Zjk4NjAzMDAwLCA0MDk2LCBN QURWX0RPTlREVU1QKSA9IDAKMTk6MzM6MTEuNjQ3OTAwIG1tYXAoTlVMTCwgMjA5NzE1MiwgUFJP VF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRFfE1BUF9BTk9OWU1PVVN8TUFQX05PUkVTRVJW RSwgLTEsIDApID0gMHg3Zjk4NDAwMDAwCjE5OjMzOjExLjY0ODE3MiBtdW5tYXAoMHg3Zjk4NTAw MDAwLCAxMDQ4NTc2KSA9IDAKMTk6MzM6MTEuNjQ4NDQ0IG1hZHZpc2UoMHg3Zjk4NDAwMDAwLCAx MDQ4NTc2LCBNQURWX05PUk1BTCkgPSAwCjE5OjMzOjExLjY0ODY4NSBtYWR2aXNlKDB4N2Y5ODQw MDAwMCwgMTA0ODU3NiwgTUFEVl9ET0RVTVApID0gMAoxOTozMzoxMS42NDkwODAgbWFkdmlzZSgw eDdmOTg0ZmYwMDAsIDQwOTYsIE1BRFZfRE9OVE5FRUQpID0gMAoxOTozMzoxMS42NDkzNjQgbWFk dmlzZSgweDdmOTg0ZmYwMDAsIDQwOTYsIE1BRFZfRE9OVERVTVApID0gMAoxOTozMzoxMS42NDk4 ODggbW1hcChOVUxMLCAyMDk3MTUyLCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8 TUFQX0FOT05ZTU9VU3xNQVBfTk9SRVNFUlZFLCAtMSwgMCkgPSAweDdmOTgyMDAwMDAKMTk6MzM6 MTEuNjUwMjc5IG11bm1hcCgweDdmOTgzMDAwMDAsIDEwNDg1NzYpID0gMAoxOTozMzoxMS42NTA1 NjIgbWFkdmlzZSgweDdmOTgyMDAwMDAsIDEwNDg1NzYsIE1BRFZfTk9STUFMKSA9IDAKMTk6MzM6 MTEuNjUwODA3IG1hZHZpc2UoMHg3Zjk4MjAwMDAwLCAxMDQ4NTc2LCBNQURWX0RPRFVNUCkgPSAw CjE5OjMzOjExLjY1MTIxOSBtYWR2aXNlKDB4N2Y5ODIwMzAwMCwgODE5MiwgTUFEVl9ET05UTkVF RCkgPSAwCjE5OjMzOjExLjY1MTQ4MiBtYWR2aXNlKDB4N2Y5ODIwMzAwMCwgODE5MiwgTUFEVl9E T05URFVNUCkgPSAwCjE5OjMzOjExLjY1MTc0NiBtYWR2aXNlKDB4N2Y5ODJmZjAwMCwgNDA5Niwg TUFEVl9ET05UTkVFRCkgPSAwCjE5OjMzOjExLjY1MTk5MiBtYWR2aXNlKDB4N2Y5ODJmZjAwMCwg NDA5NiwgTUFEVl9ET05URFVNUCkgPSAwCjE5OjMzOjExLjY1MzYzNCBtbWFwKE5VTEwsIDIwOTcx NTIsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTfE1BUF9O T1JFU0VSVkUsIC0xLCAwKSA9IDB4N2Y5ODAwMDAwMAoxOTozMzoxMS42NTM5MzMgbXVubWFwKDB4 N2Y5ODEwMDAwMCwgMTA0ODU3NikgPSAwCjE5OjMzOjExLjY1NDIxMyBtYWR2aXNlKDB4N2Y5ODAw MDAwMCwgMTA0ODU3NiwgTUFEVl9OT1JNQUwpID0gMAoxOTozMzoxMS42NTQ0NjEgbWFkdmlzZSgw eDdmOTgwMDAwMDAsIDEwNDg1NzYsIE1BRFZfRE9EVU1QKSA9IDAKMTk6MzM6MTEuNjU0ODgxIG1h ZHZpc2UoMHg3Zjk4MDAzMDAwLCAxNjM4NCwgTUFEVl9ET05UTkVFRCkgPSAwCjE5OjMzOjExLjY1 NTE0MCBtYWR2aXNlKDB4N2Y5ODAwMzAwMCwgMTYzODQsIE1BRFZfRE9OVERVTVApID0gMAoxOToz MzoxMS42NTU0MDQgbWFkdmlzZSgweDdmOTgwZmMwMDAsIDE2Mzg0LCBNQURWX0RPTlRORUVEKSA9 IDAKMTk6MzM6MTEuNjU1NjUzIG1hZHZpc2UoMHg3Zjk4MGZjMDAwLCAxNjM4NCwgTUFEVl9ET05U RFVNUCkgPSAwCjE5OjMzOjExLjY1NjI4NiBtYWR2aXNlKDB4N2Y5ODgyZTAwMCwgNjU1MzYsIE1B RFZfTk9STUFMKSA9IDAKMTk6MzM6MTEuNjU2NTM1IG1hZHZpc2UoMHg3Zjk4ODJlMDAwLCA2NTUz NiwgTUFEVl9ET0RVTVApID0gMAoxOTozMzoxMS42NTcxNDYgbWFkdmlzZSgweDY4MDgxMDAwMDAs IDEwNDg1NzYsIE1BRFZfTk9STUFMKSA9IDAKMTk6MzM6MTEuNjU3NDA5IG1hZHZpc2UoMHg2ODA4 MTAwMDAwLCAxMDQ4NTc2LCBNQURWX0RPRFVNUCkgPSAwCjE5OjMzOjExLjY1NzY2NiBtbWFwKE5V TEwsIDQwOTYsIFBST1RfUkVBRHxQUk9UX1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VT fE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9IDB4N2ZhMzVlMDAwMAoxOTozMzoxMS42NTc5NTQgbW1h cChOVUxMLCA0MDk2LCBQUk9UX1JFQUR8UFJPVF9XUklURSwgTUFQX1BSSVZBVEV8TUFQX0FOT05Z TU9VU3xNQVBfTk9SRVNFUlZFLCAtMSwgMCkgPSAweDdmYTM1ZGYwMDAKMTk6MzM6MTEuNjU4MzMw IG1tYXAoTlVMTCwgNDA5NiwgUFJPVF9SRUFEfFBST1RfV1JJVEUsIE1BUF9QUklWQVRFfE1BUF9B Tk9OWU1PVVN8TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3ZmEzNWRlMDAwCjE5OjMzOjExLjY1 OTE1MSBmdXRleCgweDU1NmUzYzUzNTgsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0Nykg PSAwCjE5OjMzOjExLjY1OTU1NiBtcHJvdGVjdCgweDdmOTg5ZmYwMDAsIDQwOTYsIFBST1RfUkVB RHxQUk9UX1dSSVRFfFBST1RfRVhFQykgPSAwCjE5OjMzOjExLjY1OTgzMCBtYWR2aXNlKDB4N2Y5 ODlmZjAwMCwgNDA5NiwgTUFEVl9XSUxMTkVFRCkgPSAwCjE5OjMzOjExLjY2MDI1OSBmdXRleCgw eDU1NmUzZTEyMzAsIEZVVEVYX1dBS0VfUFJJVkFURSwgMjE0NzQ4MzY0NykgPSAwCjE5OjMzOjEx LjY2MDUxMiBtcHJvdGVjdCgweDU1NmUzZDEwMDAsIDY1NTM2LCBQUk9UX1JFQUQpID0gMAoxOToz MzoxMS42NjEyMDAgbWFkdmlzZSgweDYwNDU5NWQwMDAsIDY1NTM2LCBNQURWX05PUk1BTCkgPSAw CjE5OjMzOjExLjY2MTQ4MSBtYWR2aXNlKDB4NjA0NTk1ZDAwMCwgNjU1MzYsIE1BRFZfRE9EVU1Q KSA9IDAKMTk6MzM6MTEuNjYxODEyIG1tYXAoTlVMTCwgNDA5NiwgUFJPVF9SRUFEfFBST1RfV1JJ VEUsIE1BUF9QUklWQVRFfE1BUF9BTk9OWU1PVVN8TUFQX05PUkVTRVJWRSwgLTEsIDApID0gMHg3 ZmEzNWRkMDAwCjE5OjMzOjExLjY2MjIwNiBtbWFwKE5VTEwsIDQwOTYsIFBST1RfUkVBRHxQUk9U X1dSSVRFLCBNQVBfUFJJVkFURXxNQVBfQU5PTllNT1VTfE1BUF9OT1JFU0VSVkUsIC0xLCAwKSA9 IDB4N2ZhMzVkYzAwMAoxOTozMzoxMS42NjI5MjIgLS0tIFNJR1NFR1Yge3NpX3NpZ25vPVNJR1NF R1YsIHNpX2NvZGU9U0VHVl9NQVBFUlIsIHNpX2FkZHI9MHgzMH0gLS0tCjE5OjMzOjExLjY2MzMy MCBydF9zaWdhY3Rpb24oU0lHU0VHViwge3NhX2hhbmRsZXI9U0lHX0RGTCwgc2FfbWFzaz1+W1JU TUlOIFJUXzFdLCBzYV9mbGFncz0wfSwgTlVMTCwgOCkgPSAwCjE5OjMzOjExLjY2MzcwNiBydF9z aWdyZXR1cm4oe21hc2s9W119KSA9IDU0ODAxOTU2NzU2OAoxOTozMzoxMS42NjQxNjQgLS0tIFNJ R1NFR1Yge3NpX3NpZ25vPVNJR1NFR1YsIHNpX2NvZGU9U0VHVl9NQVBFUlIsIHNpX2FkZHI9MHgz MH0gLS0tCjE5OjMzOjEyLjEyNTI1OCArKysga2lsbGVkIGJ5IFNJR1NFR1YgKGNvcmUgZHVtcGVk KSArKysK