178485 2017-10-18 14:59:41 -0700 [WPE][GTK] Implement PAL::SleepDisabler 2017-12-04 07:18:02 -0800 1 1 1 Unclassified WebKit WebKitGTK Other PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=180197 P2 Normal --- 1 mcatanzaro mcatanzaro aperez bugs-noreply cgarcia mcatanzaro rishi.is oldest_to_newest 1361906 0 mcatanzaro 2017-10-18 14:59:41 -0700 We should implement PAL::SleepDisabler and PAL::SystemSleepListener for GTK and WPE using the logind D-Bus API: https://www.freedesktop.org/wiki/Software/systemd/inhibit/ If logind is not available, then of course it should gracefully fallback to doing nothing. We should also figure out how we currently block sleep when playing video. I see HTMLMediaElement uses SleepDisabler, but we have not implemented it. Yet I'm also positive that we do somewhere inhibit screen blank when video is playing. 1366368 1 aperez 2017-10-31 06:44:02 -0700 (In reply to Michael Catanzaro from comment #0) > We should implement PAL::SleepDisabler and PAL::SystemSleepListener for GTK > and WPE using the logind D-Bus API: > > https://www.freedesktop.org/wiki/Software/systemd/inhibit/ > > If logind is not available, then of course it should gracefully fallback to > doing nothing. > > We should also figure out how we currently block sleep when playing video. I > see HTMLMediaElement uses SleepDisabler, but we have not implemented it. Yet > I'm also positive that we do somewhere inhibit screen blank when video is > playing. I haven't checked the current code, but I am confident that it uses the X11 Screensaver extension. It could be that GNOME Shell under Wayland also honors it thanks to XWayland, but this one bit is speculation on my side :-) 1366369 2 cgarcia 2017-10-31 06:46:54 -0700 We do that from the UI process when entering fullscreen video. 1366399 3 mcatanzaro 2017-10-31 08:30:33 -0700 (In reply to Carlos Garcia Campos from comment #2) > We do that from the UI process when entering fullscreen video. Yes, I noticed this the other day. We fail to inhibit suspend when the video is not fullscreen. So we need a proper SleepDisabler. :) 1374948 4 mcatanzaro 2017-11-27 08:55:48 -0800 Let's simplify this. We really need PAL::SleepDisabler. The need for PAL::SystemSleepListener is less clear. It's used only for PlatformMediaSessionManager::systemWillSleep and PlatformMediaSessionManager::systemDidWake, which are only used by WebAudio, and it's not clear to me how important those are. Implementing this would also require depending on yet another D-Bus API, which will be problematic for flatpak (bug #180039). But we do need PAL::SleepDisabler. 1375996 5 mcatanzaro 2017-11-29 13:26:47 -0800 Well, I've wasted three days trying to figure out how to run a modified WebKit inside Flatpak. It's too hard and not worth the effort. So I don't know if my code works, and because of that I'm not willing to commit it. But the non-Flatpak codepath works fine, and it's a nice cleanup. So let's land Flatpak support separately. 1376042 6 327908 mcatanzaro 2017-11-29 14:31:22 -0800 Created attachment 327908 Patch 1376065 7 mcatanzaro 2017-11-29 15:23:01 -0800 Flatpak support committed in https://git.gnome.org/browse/gnome-sdk-images/commit/?id=9e50b39d397af2a15dedb99f6dc68825bae4d3c6. It can live there until it is possible to test it. (Might be a long time, because I was not successful in adding perl-File-Copy-Recursive to the SDK.) 1376227 8 327908 cgarcia 2017-11-29 23:24:15 -0800 Comment on attachment 327908 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=327908&action=review > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:54 > + g_dbus_proxy_new_for_bus(G_BUS_TYPE_SESSION, static_cast<GDBusProxyFlags>(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS), > + nullptr, "org.freedesktop.ScreenSaver", "/ScreenSaver", "org.freedesktop.ScreenSaver", m_cancellable.get(), One good thing of the current code is that we connect to the screensaver on demand and only once. Here it happens on demand, because SleepDisabler is only created when needed and then destroyed, but we are connecting to the bus every time it's created. Maybe we can create a private singleton for the proxy. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:57 > + auto* self = static_cast<SleepDisablerGtk*>(userData); > + self->m_screenSaverProxy = adoptGRef(g_dbus_proxy_new_for_bus_finish(result, nullptr)); self might be destroyed here at this point. You need to finish the operation and properly handle the case of cancellation. In case of cancellation just return silently, in case of other error, show a warnings and otherwise then get self and initialize the proxy. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:61 > + GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(self->m_screenSaverProxy.get())); > + if (nameOwner) > + self->acquireInhibitor(); How can happen that you get a valid proxy for ScreenSaver and name_owner is nullptr? > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:87 > + auto* self = static_cast<SleepDisablerGtk*>(userData); > + GUniqueOutPtr<GError> error; > + GRefPtr<GVariant> returnValue = adoptGRef(g_dbus_proxy_call_finish(self->m_screenSaverProxy.get(), result, &error.outPtr())); Same here about self and cancellation. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.h:45 > + GRefPtr<GDBusProxy> m_screenSaverProxy { nullptr }; GRefPtr already initializes the pointer to nullptr. > Source/WebCore/html/HTMLMediaElement.cpp:6614 > + // FIXME: This #if should be removed, because GTK now supports SleepDisabler, and because this > + // code is harmless on ports where SleepDisabler does nothing. However, after brief testing on > + // YouTube, I noticed that sleep is not disabled during normal video playback, but it *is* > + // disabled when a page playing video enters the page cache, until the associated web view is > + // destroyed. Keep it Cocoa-only for now, so that cached pages don't block sleep indefinitely. Why don't you open a bug report to fix whatever is wrong instead of adding a comment in the code? > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:194 > + std::unique_ptr<PAL::SleepDisabler> sleepDisabler { nullptr }; unique_ptr already initializes the pointer to nullptr. > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:1246 > - webkitWebViewBaseInhibitScreenSaver(webkitWebViewBase); > + priv->sleepDisabler = PAL::SleepDisabler::create(_("Website running in fullscreen mode"), PAL::SleepDisabler::Type::Display); So, do we need to inhibit the screensaver from both the UI and Web process? 1376307 9 mcatanzaro 2017-11-30 07:08:45 -0800 (In reply to Carlos Garcia Campos from comment #8) > One good thing of the current code is that we connect to the screensaver on > demand and only once. Here it happens on demand, because SleepDisabler is > only created when needed and then destroyed, but we are connecting to the > bus every time it's created. Maybe we can create a private singleton for the > proxy. OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:57 > > + auto* self = static_cast<SleepDisablerGtk*>(userData); > > + self->m_screenSaverProxy = adoptGRef(g_dbus_proxy_new_for_bus_finish(result, nullptr)); > > self might be destroyed here at this point. You need to finish the operation > and properly handle the case of cancellation. In case of cancellation just > return silently, in case of other error, show a warnings and otherwise then > get self and initialize the proxy. Yes. I should know this by now, but clearly I haven't learned.... > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:61 > > + GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(self->m_screenSaverProxy.get())); > > + if (nameOwner) > > + self->acquireInhibitor(); > > How can happen that you get a valid proxy for ScreenSaver and name_owner is > nullptr? I copied it from GtkApplication, but I think it's correct. Proxy creation does not fail due to the absence of a name owner; it will succeed and you'll have an inert proxy where the method calls all fail. If the name is unowned, then we want to skip over it and try the fallback (flatpak portal) codepath (which I removed from this patch, but which I intend to restore eventually). I found a nice test to demonstrate. Using glib/gio/tests/gdbus-example-watch-proxy.c as test.c: $ gcc `pkg-config --cflags --libs gio-2.0` test.c $ ./a.out -n org.gnome.Contacts -o /org/gnome/Contacts -i org.gtk.Application --no-auto-start Notice that the proxy is created successfully, though there is no name owner because you're not running Contacts. Then launch Contacts and watch it own the name. GDBusProxy hides the messiness of changing name owners and ensures all methods/properties/signals go to/from the current name owner. All that said... I don't pretend to understand D-Bus. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:87 > > + auto* self = static_cast<SleepDisablerGtk*>(userData); > > + GUniqueOutPtr<GError> error; > > + GRefPtr<GVariant> returnValue = adoptGRef(g_dbus_proxy_call_finish(self->m_screenSaverProxy.get(), result, &error.outPtr())); > > Same here about self and cancellation. Yes. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.h:45 > > + GRefPtr<GDBusProxy> m_screenSaverProxy { nullptr }; > > GRefPtr already initializes the pointer to nullptr. OK. > > Source/WebCore/html/HTMLMediaElement.cpp:6614 > > + // FIXME: This #if should be removed, because GTK now supports SleepDisabler, and because this > > + // code is harmless on ports where SleepDisabler does nothing. However, after brief testing on > > + // YouTube, I noticed that sleep is not disabled during normal video playback, but it *is* > > + // disabled when a page playing video enters the page cache, until the associated web view is > > + // destroyed. Keep it Cocoa-only for now, so that cached pages don't block sleep indefinitely. > > Why don't you open a bug report to fix whatever is wrong instead of adding a > comment in the code? I'll report a bug. > > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:194 > > + std::unique_ptr<PAL::SleepDisabler> sleepDisabler { nullptr }; > > unique_ptr already initializes the pointer to nullptr. OK. > > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:1246 > > - webkitWebViewBaseInhibitScreenSaver(webkitWebViewBase); > > + priv->sleepDisabler = PAL::SleepDisabler::create(_("Website running in fullscreen mode"), PAL::SleepDisabler::Type::Display); > > So, do we need to inhibit the screensaver from both the UI and Web process? Currently, PAL::SleepDisabler is only used from the UI process. But it should be used from the web process as well, by HTMLMediaElement. 1376323 10 mcatanzaro 2017-11-30 07:48:32 -0800 (In reply to Carlos Garcia Campos from comment #8) > One good thing of the current code is that we connect to the screensaver on > demand and only once. Here it happens on demand, because SleepDisabler is > only created when needed and then destroyed, but we are connecting to the > bus every time it's created. Maybe we can create a private singleton for the > proxy. There's a disadvantage to using a private singleton: the proxy will stay alive forever, even when no SleepDisabler exists, which seems unnecessary. That is, unless we create a global list of SleepDisablers, and then destroy the global proxy when no more SleepDisablers exist, and recreate it when there is a new SleepDisabler, which seems excessive. So my preference would be to leave this unchanged; SleepDisablers should be created rarely, and the general case will be to have zero. But, after you've considered that, I'll implement what you prefer. 1376328 11 cgarcia 2017-11-30 08:03:25 -0800 (In reply to Michael Catanzaro from comment #10) > (In reply to Carlos Garcia Campos from comment #8) > > One good thing of the current code is that we connect to the screensaver on > > demand and only once. Here it happens on demand, because SleepDisabler is > > only created when needed and then destroyed, but we are connecting to the > > bus every time it's created. Maybe we can create a private singleton for the > > proxy. > > There's a disadvantage to using a private singleton: the proxy will stay > alive forever, even when no SleepDisabler exists, which seems unnecessary. > That is, unless we create a global list of SleepDisablers, and then destroy > the global proxy when no more SleepDisablers exist, and recreate it when > there is a new SleepDisabler, which seems excessive. So my preference would > be to leave this unchanged; SleepDisablers should be created rarely, and the > general case will be to have zero. But, after you've considered that, I'll > implement what you prefer. Ok, it's fine as it is. 1376346 12 327980 mcatanzaro 2017-11-30 09:19:37 -0800 Created attachment 327980 Patch 1376744 13 327980 cgarcia 2017-12-01 00:41:03 -0800 Comment on attachment 327980 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=327980&action=review > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:38 > +SleepDisablerGtk::SleepDisablerGtk(const char* reason, Type type) I'm sorry I didn't notice this before, but this is not specific to GTK at all, I would call this GLib instead or even Fdo since this is the Freedesktop.org implementation. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:58 > + if (error && g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_error_matches() handles null errors > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:62 > + auto* self = static_cast<SleepDisablerGtk*>(userData); > + if (!error) { You could early return here in case of error, just setting m_cancellable to nullptr, and saving an indentation level for the rest of the code. Actually, since it's expected that proxy is nullptr in case of error, I would remove the assret adn check proxy instead of error to return early. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:65 > + GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(proxy.get())); > + if (nameOwner) { if (GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(proxy.get()))) > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:66 > + self->m_screenSaverProxy = proxy; WTFMove(proxy) > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:92 > + if (error && g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_error_matches() handles null errors > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:116 > + GUniqueOutPtr<GError> error; > + GRefPtr<GVariant> returnValue = adoptGRef(g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), result, &error.outPtr())); > + if (error) > + g_warning("Calling %s.UnInhibit failed: %s", g_dbus_proxy_get_interface_name(G_DBUS_PROXY(proxy)), error->message); Is this really useful? I would call g_dbus_proxy_call without a callback. > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.h:30 > +#include <gio/gio.h> I don't think this is needed, but if you need it, try to forward declare GDBusProxy and GCancellable and move the header inclusion to the cpp > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:-503 > - g_cancellable_cancel(webView->priv->screenSaverInhibitCancellable.get()); sleepDisabler = nullptr to cancel it earlier. > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:1246 > + priv->sleepDisabler = PAL::SleepDisabler::create(_("Website running in fullscreen mode"), PAL::SleepDisabler::Type::Display); Does the reason really need to be translated? where is the user going to see this message? 1376867 14 mcatanzaro 2017-12-01 10:09:44 -0800 (In reply to Carlos Garcia Campos from comment #13) > I'm sorry I didn't notice this before, but this is not specific to GTK at > all, I would call this GLib instead or even Fdo since this is the > Freedesktop.org implementation. I'll call it GLib. fdo would work for now, but we don't use that suffix elsewhere in WebKit, and who knows: we might change the D-Bus interfaces that we use in the future. I had considered GLib, but at the time I had been trying to use org.gnome.SessionManager, so the Gtk suffix seemed more appropriate. And half the code had been Flatpak support at the time. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:58 > > + if (error && g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) > > g_error_matches() handles null errors OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:62 > > + auto* self = static_cast<SleepDisablerGtk*>(userData); > > + if (!error) { > > You could early return here in case of error, just setting m_cancellable to > nullptr, and saving an indentation level for the rest of the code. Actually, > since it's expected that proxy is nullptr in case of error, I would remove > the assret adn check proxy instead of error to return early. OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:65 > > + GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(proxy.get())); > > + if (nameOwner) { > > if (GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(proxy.get()))) OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:66 > > + self->m_screenSaverProxy = proxy; > > WTFMove(proxy) OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:92 > > + if (error && g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) > > g_error_matches() handles null errors OK. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:116 > > + GUniqueOutPtr<GError> error; > > + GRefPtr<GVariant> returnValue = adoptGRef(g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), result, &error.outPtr())); > > + if (error) > > + g_warning("Calling %s.UnInhibit failed: %s", g_dbus_proxy_get_interface_name(G_DBUS_PROXY(proxy)), error->message); > > Is this really useful? I would call g_dbus_proxy_call without a callback. I think it's useful, because otherwise there will be no error message if uninhibiting fails, and your screen will never lock. It's unlikely that this call would ever fail, but it seems good to have a warning in this case, because it indicates something has gone wrong. In contrast, the initial inhibit calls are expected to fail and should not cause warnings. > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.h:30 > > +#include <gio/gio.h> > > I don't think this is needed, but if you need it, try to forward declare > GDBusProxy and GCancellable and move the header inclusion to the cpp OK. > > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:-503 > > - g_cancellable_cancel(webView->priv->screenSaverInhibitCancellable.get()); > > sleepDisabler = nullptr to cancel it earlier. > > > Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:1246 > > + priv->sleepDisabler = PAL::SleepDisabler::create(_("Website running in fullscreen mode"), PAL::SleepDisabler::Type::Display); > > Does the reason really need to be translated? where is the user going to see > this message? The reason should be displayed on the inhibitor review dialog that may appear if you try to log out while an inhibitor is in place. There have been GNOME Session bugs in the past, so I'm not sure if that functionality is currently working or not in GNOME. But yes, it's supposed to be translated. This is actually in conflict with Apple's use of this parameter to include a reverse-DNS programmer-visible string. A follow-up patch might split reason into two parameters, one a translated human-readable string for use by SleepDisablerGtk/GLib, and the other the untranslated reverse-DNS string for use by SleepDisablerCocoa. 1376869 15 327980 mcatanzaro 2017-12-01 10:10:08 -0800 Comment on attachment 327980 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=327980&action=review >> Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp:-503 >> - g_cancellable_cancel(webView->priv->screenSaverInhibitCancellable.get()); > > sleepDisabler = nullptr to cancel it earlier. Oops, yes. 1376958 16 mcatanzaro 2017-12-01 11:57:40 -0800 (In reply to Carlos Garcia Campos from comment #13) > > Source/WebCore/PAL/pal/system/gtk/SleepDisablerGtk.cpp:62 > > + auto* self = static_cast<SleepDisablerGtk*>(userData); > > + if (!error) { > > You could early return here in case of error, just setting m_cancellable to > nullptr, and saving an indentation level for the rest of the code. It didn't work out as well as I'd hoped; I'd rather have an extra level of indentation than duplicate the self->m_cancellable = nullptr assignment, which is two lines of code as I'd like to keep the comment above it. And it was fated to be reverted when adding Flatpak portal support anyway. > Actually, > since it's expected that proxy is nullptr in case of error, I would remove > the assret adn check proxy instead of error to return early. Done. 1376964 17 mcatanzaro 2017-12-01 12:27:20 -0800 (In reply to Carlos Garcia Campos from comment #13) > if (GUniquePtr<char> nameOwner(g_dbus_proxy_get_name_owner(proxy.get()))) It doesn't build. I think it has to be an assignment. 1377005 18 328141 mcatanzaro 2017-12-01 13:08:59 -0800 Created attachment 328141 Patch 1377477 19 mcatanzaro 2017-12-03 11:13:05 -0800 Note: I used cq? here since I failed to implement a significant number of your suggestions. Will set cq+ tomorrow. 1377620 20 328141 cgarcia 2017-12-04 00:37:53 -0800 Comment on attachment 328141 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=328141&action=review > Source/WebCore/PAL/pal/system/glib/SleepDisablerGLib.cpp:66 > + self->m_screenSaverProxy = proxy; Why couldn't you use WTFMove here? 1377667 21 mcatanzaro 2017-12-04 05:25:15 -0800 (In reply to Carlos Garcia Campos from comment #20) > Comment on attachment 328141 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=328141&action=review > > > Source/WebCore/PAL/pal/system/glib/SleepDisablerGLib.cpp:66 > > + self->m_screenSaverProxy = proxy; > > Why couldn't you use WTFMove here? I think I added it, then accidentally Ctrl+Zed it away and failed to notice. 1377676 22 mcatanzaro 2017-12-04 07:15:50 -0800 Committed r225477: <https://trac.webkit.org/changeset/225477> 1377677 23 mcatanzaro 2017-12-04 07:17:55 -0800 The commit message got messed up... I think it's because I forgot to rename one of the changelog entries. 327908 2017-11-29 14:31:22 -0800 2017-11-30 09:19:35 -0800 Patch bug-178485-20171129163121.patch text/plain 18685 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI1Mjc0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWUxNWRjNDBkYWRkYWRl OGFlMGZkMjc1MDRmM2EwMDQyNTllODUxMC4uODllZGMzMjFmNWVhYjk3MzZhZDBiYzBiNmRhMjg2 ODg5MDJlNWRkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE3LTExLTI5ICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBJ bXBsZW1lbnQgUEFMOjpTbGVlcERpc2FibGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNzg0ODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgYSBjb21tZW50IHRvIHdhcm4gYWJvdXQgc29tZSBvZGQg dXNlIG9mIFNsZWVwRGlzYWJsZXIgaW4gSFRNTE1lZGlhRWxlbWVudC4KKworICAgICAgICAqIGh0 bWwvSFRNTE1lZGlhRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFFbGVt ZW50OjpzaG91bGREaXNhYmxlU2xlZXAgY29uc3QpOgorCiAyMDE3LTExLTI5ICBZb3Vlbm4gRmFi bGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBMaWJXZWJSVENQZWVyQ29ubmVjdGlv bkJhY2tlbmQgc2hvdWxkIGNsZWFuIGl0cyBzdGF0cyBwcm9taXNlcyB3aGVuIGJlaW5nIGNsZWFu ZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi Q29yZS9QQUwvQ2hhbmdlTG9nCmluZGV4IDUyZmM3MmRjODJlOWVlY2M0ODY4ZDUzZDI5ODE1ZjNk Nzk4NzNjYjEuLmNlZjg3YzNiMjFmYmExOTk5ZTgxZTBkMjg2MDUxZWZiZWUwNTg5NjYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUv UEFML0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDE3LTExLTI5ICBNaWNoYWVsIENhdGFu emFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBJbXBsZW1lbnQg UEFMOjpTbGVlcERpc2FibGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNzg0ODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIHBhbC9QbGF0Zm9ybUdUSy5jbWFrZToKKyAgICAgICAgKiBwYWwvc3lzdGVt L1NsZWVwRGlzYWJsZXIuY3BwOgorICAgICAgICAqIHBhbC9zeXN0ZW0vZ3RrL1NsZWVwRGlzYWJs ZXJHdGsuY3BwOiBBZGRlZC4KKyAgICAgICAgKFBBTDo6U2xlZXBEaXNhYmxlcjo6Y3JlYXRlKToK KyAgICAgICAgKFBBTDo6U2xlZXBEaXNhYmxlckd0azo6U2xlZXBEaXNhYmxlckd0ayk6CisgICAg ICAgIChQQUw6OlNsZWVwRGlzYWJsZXJHdGs6On5TbGVlcERpc2FibGVyR3RrKToKKyAgICAgICAg KFBBTDo6U2xlZXBEaXNhYmxlckd0azo6YWNxdWlyZUluaGliaXRvcik6CisgICAgICAgIChQQUw6 OlNsZWVwRGlzYWJsZXJHdGs6OnJlbGVhc2VJbmhpYml0b3IpOgorICAgICAgICAqIHBhbC9zeXN0 ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuaDogQWRkZWQuCisKIDIwMTctMTEtMjggIEJyZW50IEZ1 bGdoYW0gIDxiZnVsZ2hhbUBhcHBsZS5jb20+CiAKICAgICAgICAgQWRvcHQgdXBkYXRlZCBOU0tl eWVkW1VuXUFyY2hpdmVyIEFQSSB3aGVuIGF2YWlsYWJsZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCBhNzBlODE0ZTMy NzNhZTY4Mjc5MTg4MjY5NGEwODg0MzczYWQ5MzJiLi4wNzU1MTRmOTE4N2Y3YjFiNTNlODliODI5 NDc4ZjFiNDQ0MGIxMjIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDE3LTExLTI5ICBN aWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RL XSBJbXBsZW1lbnQgUEFMOjpTbGVlcERpc2FibGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzg0ODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdC YXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdCYXNlRGlzcG9zZSk6CisgICAgICAgICh3 ZWJraXRXZWJWaWV3QmFzZUVudGVyRnVsbFNjcmVlbik6CisgICAgICAgICh3ZWJraXRXZWJWaWV3 QmFzZUV4aXRGdWxsU2NyZWVuKToKKyAgICAgICAgKHNjcmVlblNhdmVySW5oaWJpdGVkQ2FsbGJh Y2spOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2ViVmlld0Jhc2VTZW5kSW5oaWJpdE1lc3Nh Z2VUb1NjcmVlblNhdmVyKTogRGVsZXRlZC4KKyAgICAgICAgKHNjcmVlblNhdmVyUHJveHlDcmVh dGVkQ2FsbGJhY2spOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2ViVmlld0Jhc2VJbmhpYml0 U2NyZWVuU2F2ZXIpOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2ViVmlld0Jhc2VVbmluaGli aXRTY3JlZW5TYXZlcik6IERlbGV0ZWQuCisKIDIwMTctMTEtMjkgIE1pY2hhZWwgQ2F0YW56YXJv ICA8bWNhdGFuemFyb0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04ocjIxODA2NCk6 IFtHVEtdIEJyb2tlIGVudGVyaW5nIGZ1bGxzY3JlZW4gbW9kZSBpbiBkZWJ1ZyBidWlsZHMKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3Vy Y2UvV2ViQ29yZS9QQUwvcGFsL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4IGI0YWQ0NWNjN2ZiNTUw ZWM0NDdlNGQwODUwNzg5ZDFhZDg3NzUxZTUuLjRkMjZiZjI3YWMxZjA3NmI3NzliM2ViMjc5MzVi ZGVmNWE5ZDI0YzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvUGxhdGZvcm1H VEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9QbGF0Zm9ybUdUSy5jbWFrZQpA QCAtMyw2ICszLDcgQEAgbGlzdChBUFBFTkQgUEFMX1NPVVJDRVMKIAogICAgIHN5c3RlbS9DbG9j a0dlbmVyaWMuY3BwCiAKKyAgICBzeXN0ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuY3BwCiAgICAg c3lzdGVtL2d0ay9Tb3VuZEd0ay5jcHAKIAogICAgIHRleHQvS2lsbFJpbmcuY3BwCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9TbGVlcERpc2FibGVyLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL1NsZWVwRGlzYWJsZXIuY3BwCmluZGV4IDEwMTg4 ZWVkZmY0MTdiMmU2MjFhODAxZGRkNTI2Y2I1NjY2Zjc0ZjUuLjQzOTA4NTBlYTQwM2EyNjdkMjNh NTM0ODY3M2Y0MTdkNGQxNTAyOTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwv c3lzdGVtL1NsZWVwRGlzYWJsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvc3lz dGVtL1NsZWVwRGlzYWJsZXIuY3BwCkBAIC0yOCwxMiArMjgsMTIgQEAKIAogbmFtZXNwYWNlIFBB TCB7CiAKLSNpZiAhUExBVEZPUk0oQ09DT0EpCisjaWYgIVBMQVRGT1JNKENPQ09BKSAmJiAhUExB VEZPUk0oR1RLKQogc3RkOjp1bmlxdWVfcHRyPFNsZWVwRGlzYWJsZXI+IFNsZWVwRGlzYWJsZXI6 OmNyZWF0ZShjb25zdCBjaGFyKiByZWFzb24sIFR5cGUgdHlwZSkKIHsKICAgICByZXR1cm4gc3Rk Ojp1bmlxdWVfcHRyPFNsZWVwRGlzYWJsZXI+KG5ldyBTbGVlcERpc2FibGVyKHJlYXNvbiwgdHlw ZSkpOwogfQotI2VuZGlmIC8vICFQTEFURk9STShDT0NPQSkKKyNlbmRpZiAvLyAhUExBVEZPUk0o Q09DT0EpICYmICFQTEFURk9STShHVEspCiAKIFNsZWVwRGlzYWJsZXI6OlNsZWVwRGlzYWJsZXIo Y29uc3QgY2hhciosIFR5cGUgdHlwZSkKICAgICA6IG1fdHlwZSh0eXBlKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuY3BwIGIv U291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuY3BwCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjA0ZDdlMmFlN2YxOTY3NzU2MWMyY2NhMzI0YTVhNDc5NDUyYWE2OWUKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9ndGsvU2xlZXBEaXNh Ymxlckd0ay5jcHAKQEAgLTAsMCArMSwxMTIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTcg SWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4K KyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlNs ZWVwRGlzYWJsZXJHdGsuaCIKKworI2luY2x1ZGUgPHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KKwor bmFtZXNwYWNlIFBBTCB7CisKK3N0ZDo6dW5pcXVlX3B0cjxTbGVlcERpc2FibGVyPiBTbGVlcERp c2FibGVyOjpjcmVhdGUoY29uc3QgY2hhciogcmVhc29uLCBUeXBlIHR5cGUpCit7CisgICAgcmV0 dXJuIHN0ZDo6dW5pcXVlX3B0cjxTbGVlcERpc2FibGVyPihuZXcgU2xlZXBEaXNhYmxlckd0ayhy ZWFzb24sIHR5cGUpKTsKK30KKworU2xlZXBEaXNhYmxlckd0azo6U2xlZXBEaXNhYmxlckd0ayhj b25zdCBjaGFyKiByZWFzb24sIFR5cGUgdHlwZSkKKyAgICA6IFNsZWVwRGlzYWJsZXIocmVhc29u LCB0eXBlKQorICAgICwgbV9jYW5jZWxsYWJsZShhZG9wdEdSZWYoZ19jYW5jZWxsYWJsZV9uZXco KSkpCisgICAgLCBtX3JlYXNvbihyZWFzb24pCit7CisgICAgLy8gV2UgZG9uJ3Qgc3VwcG9ydCBz dXNwZW5kICgiU3lzdGVtIikgaW5oaWJpdG9ycywgb25seSBpZGxlIGluaGliaXRvcnMuCisgICAg Ly8gVG8gZ2V0IHN1c3BlbmQgaW5oaWJpdG9ycywgd2UnZCBuZWVkIHRvIHVzZSB0aGUgZmFuY3kg R05PTUUKKyAgICAvLyBTZXNzaW9uTWFuYWdlciBBUEksIHdoaWNoIHJlcXVpcmVzIHJlZ2lzdGVy aW5nIGFzIGEgY2xpZW50IGFwcGxpY2F0aW9uLAorICAgIC8vIHdoaWNoIGlzIG5vdCBwcmFjdGlj YWwgZnJvbSB0aGUgd2ViIHByb2Nlc3MuIFNlY29uZGx5LCBiZWNhdXNlIHRoZSBvbmx5CisgICAg Ly8gY3VycmVudCB1c2Ugb2YgYSBzdXNwZW5kIGluaGliaXRvciBpbiBXZWJLaXQsCisgICAgLy8g SFRNTE1lZGlhRWxlbWVudDo6c2hvdWxkRGlzYWJsZVNsZWVwLCBpcyBzdXNwaWNpb3VzLiBUaGVy ZSdzIHJlYWxseSBubworICAgIC8vIHZhbGlkIHJlYXNvbiBmb3IgV2ViS2l0IHRvIGV2ZXIgYmxv Y2sgc3VzcGVuZCwgb25seSBpZGxlLgorICAgIGlmICh0eXBlICE9IFNsZWVwRGlzYWJsZXI6OlR5 cGU6OkRpc3BsYXkpCisgICAgICAgIHJldHVybjsKKworICAgIGdfZGJ1c19wcm94eV9uZXdfZm9y X2J1cyhHX0JVU19UWVBFX1NFU1NJT04sIHN0YXRpY19jYXN0PEdEQnVzUHJveHlGbGFncz4oR19E QlVTX1BST1hZX0ZMQUdTX0RPX05PVF9MT0FEX1BST1BFUlRJRVMgfCBHX0RCVVNfUFJPWFlfRkxB R1NfRE9fTk9UX0NPTk5FQ1RfU0lHTkFMUyksCisgICAgICAgIG51bGxwdHIsICJvcmcuZnJlZWRl c2t0b3AuU2NyZWVuU2F2ZXIiLCAiL1NjcmVlblNhdmVyIiwgIm9yZy5mcmVlZGVza3RvcC5TY3Jl ZW5TYXZlciIsIG1fY2FuY2VsbGFibGUuZ2V0KCksCisgICAgICAgIFtdKEdPYmplY3QqLCBHQXN5 bmNSZXN1bHQqIHJlc3VsdCwgZ3BvaW50ZXIgdXNlckRhdGEpIHsKKyAgICAgICAgICAgIGF1dG8q IHNlbGYgPSBzdGF0aWNfY2FzdDxTbGVlcERpc2FibGVyR3RrKj4odXNlckRhdGEpOworICAgICAg ICAgICAgc2VsZi0+bV9zY3JlZW5TYXZlclByb3h5ID0gYWRvcHRHUmVmKGdfZGJ1c19wcm94eV9u ZXdfZm9yX2J1c19maW5pc2gocmVzdWx0LCBudWxscHRyKSk7CisgICAgICAgICAgICBpZiAoc2Vs Zi0+bV9zY3JlZW5TYXZlclByb3h5KSB7CisgICAgICAgICAgICAgICAgR1VuaXF1ZVB0cjxjaGFy PiBuYW1lT3duZXIoZ19kYnVzX3Byb3h5X2dldF9uYW1lX293bmVyKHNlbGYtPm1fc2NyZWVuU2F2 ZXJQcm94eS5nZXQoKSkpOworICAgICAgICAgICAgICAgIGlmIChuYW1lT3duZXIpCisgICAgICAg ICAgICAgICAgICAgIHNlbGYtPmFjcXVpcmVJbmhpYml0b3IoKTsKKyAgICAgICAgICAgICAgICBl bHNlCisgICAgICAgICAgICAgICAgICAgIHNlbGYtPm1fc2NyZWVuU2F2ZXJQcm94eSA9IG51bGxw dHI7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIC8vIEdpdmUgdXAuIERvbid0IHdhcm4g dGhlIHVzZXI6IHRoaXMgaXMgZXhwZWN0ZWQuCisgICAgICAgICAgICBpZiAoIXNlbGYtPm1fc2Ny ZWVuU2F2ZXJQcm94eSkKKyAgICAgICAgICAgICAgICBzZWxmLT5tX2NhbmNlbGxhYmxlID0gbnVs bHB0cjsKKyAgICAgICAgfSwgdGhpcyk7Cit9CisKK1NsZWVwRGlzYWJsZXJHdGs6On5TbGVlcERp c2FibGVyR3RrKCkKK3sKKyAgICBpZiAobV9jYW5jZWxsYWJsZSkKKyAgICAgICAgZ19jYW5jZWxs YWJsZV9jYW5jZWwobV9jYW5jZWxsYWJsZS5nZXQoKSk7CisgICAgZWxzZSBpZiAobV9zY3JlZW5T YXZlckNvb2tpZSkKKyAgICAgICAgcmVsZWFzZUluaGliaXRvcigpOworfQorCit2b2lkIFNsZWVw RGlzYWJsZXJHdGs6OmFjcXVpcmVJbmhpYml0b3IoKQoreworICAgIEFTU0VSVChtX3NjcmVlblNh dmVyUHJveHkpOworICAgIGdfZGJ1c19wcm94eV9jYWxsKG1fc2NyZWVuU2F2ZXJQcm94eS5nZXQo KSwgIkluaGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIoc3MpIiwgZ19nZXRfcHJnbmFtZSgpLCBtX3Jl YXNvbi5kYXRhKCkpLAorICAgICAgICBHX0RCVVNfQ0FMTF9GTEFHU19OT05FLCAtMSwgbV9jYW5j ZWxsYWJsZS5nZXQoKSwgW10oR09iamVjdCosIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBncG9pbnRl ciB1c2VyRGF0YSkgeworICAgICAgICAgICAgYXV0byogc2VsZiA9IHN0YXRpY19jYXN0PFNsZWVw RGlzYWJsZXJHdGsqPih1c2VyRGF0YSk7CisgICAgICAgICAgICBHVW5pcXVlT3V0UHRyPEdFcnJv cj4gZXJyb3I7CisgICAgICAgICAgICBHUmVmUHRyPEdWYXJpYW50PiByZXR1cm5WYWx1ZSA9IGFk b3B0R1JlZihnX2RidXNfcHJveHlfY2FsbF9maW5pc2goc2VsZi0+bV9zY3JlZW5TYXZlclByb3h5 LmdldCgpLCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSkpOworICAgICAgICAgICAgaWYgKGVycm9y KQorICAgICAgICAgICAgICAgIGdfd2FybmluZygiQ2FsbGluZyAlcy5JbmhpYml0IGZhaWxlZDog JXMiLCBnX2RidXNfcHJveHlfZ2V0X2ludGVyZmFjZV9uYW1lKHNlbGYtPm1fc2NyZWVuU2F2ZXJQ cm94eS5nZXQoKSksIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgICAgIGVsc2UgeworICAgICAg ICAgICAgICAgIEFTU0VSVChyZXR1cm5WYWx1ZSk7CisgICAgICAgICAgICAgICAgZ192YXJpYW50 X2dldChyZXR1cm5WYWx1ZS5nZXQoKSwgIih1KSIsICZzZWxmLT5tX3NjcmVlblNhdmVyQ29va2ll KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHNlbGYtPm1fY2FuY2VsbGFibGUgPSBudWxs cHRyOworICAgICAgICB9LCB0aGlzKTsKK30KKwordm9pZCBTbGVlcERpc2FibGVyR3RrOjpyZWxl YXNlSW5oaWJpdG9yKCkKK3sKKyAgICBBU1NFUlQobV9zY3JlZW5TYXZlckNvb2tpZSk7CisgICAg QVNTRVJUKG1fc2NyZWVuU2F2ZXJQcm94eSk7CisKKyAgICBnX2RidXNfcHJveHlfY2FsbChtX3Nj cmVlblNhdmVyUHJveHkuZ2V0KCksICJVbkluaGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIodSkiLCBt X3NjcmVlblNhdmVyQ29va2llKSwKKyAgICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwgLTEs IG51bGxwdHIsIFtdKEdPYmplY3QqIHByb3h5LCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgZ3BvaW50 ZXIpIHsKKyAgICAgICAgICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKKyAgICAgICAg ICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHJldHVyblZhbHVlID0gYWRvcHRHUmVmKGdfZGJ1c19wcm94 eV9jYWxsX2ZpbmlzaChHX0RCVVNfUFJPWFkocHJveHkpLCByZXN1bHQsICZlcnJvci5vdXRQdHIo KSkpOworICAgICAgICAgICAgaWYgKGVycm9yKQorICAgICAgICAgICAgICAgIGdfd2FybmluZygi Q2FsbGluZyAlcy5VbkluaGliaXQgZmFpbGVkOiAlcyIsIGdfZGJ1c19wcm94eV9nZXRfaW50ZXJm YWNlX25hbWUoR19EQlVTX1BST1hZKHByb3h5KSksIGVycm9yLT5tZXNzYWdlKTsKKyAgICB9LCBu dWxscHRyKTsKK30KKworfSAvLyBuYW1lc3BhY2UgUEFMCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9QQUwvcGFsL3N5c3RlbS9ndGsvU2xlZXBEaXNhYmxlckd0ay5oIGIvU291cmNlL1dlYkNv cmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mMzlm N2M2N2NkMzRhMDNlYjM4ZjQ2YzYzZjFkODUyY2VlMmQ1YTJlCi0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1NsZWVwRGlzYWJsZXJHdGsuaApAQCAt MCwwICsxLDUyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE3IElnYWxpYSBTLkwuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAiU2xlZXBEaXNhYmxlci5oIgorCisjaW5j bHVkZSA8Z2lvL2dpby5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0dSZWZQdHIuaD4KKyNpbmNsdWRl IDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVzcGFjZSBQQUwgeworCitjbGFzcyBTbGVlcERp c2FibGVyR3RrIDogcHVibGljIFNsZWVwRGlzYWJsZXIgeworcHVibGljOgorICAgIFNsZWVwRGlz YWJsZXJHdGsoY29uc3QgY2hhciosIFR5cGUpOworICAgIHZpcnR1YWwgflNsZWVwRGlzYWJsZXJH dGsoKTsKKworcHJpdmF0ZToKKyAgICB2b2lkIGFjcXVpcmVJbmhpYml0b3IoKTsKKyAgICB2b2lk IHJlbGVhc2VJbmhpYml0b3IoKTsKKworICAgIEdSZWZQdHI8R0RCdXNQcm94eT4gbV9zY3JlZW5T YXZlclByb3h5IHsgbnVsbHB0ciB9OworICAgIHVuc2lnbmVkIG1fc2NyZWVuU2F2ZXJDb29raWUg eyAwIH07CisKKyAgICBHUmVmUHRyPEdDYW5jZWxsYWJsZT4gbV9jYW5jZWxsYWJsZSB7IG51bGxw dHIgfTsKKyAgICBDU3RyaW5nIG1fcmVhc29uOworfTsKKworfSAvLyBuYW1lc3BhY2UgUEFMCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcAppbmRleCAwNGY5ZGE5NmM1Yjgz MDNlNzEyYjU4NDcwN2Q4NzE2Y2RmNDBmOTMxLi5iMzdhMTNlYzFlNGNmN2M4NjJhYjZlYmUwZmUz MmIzMGU3YjRkMmZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVs ZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAK QEAgLTY2MDcsNiArNjYwNywxMSBAQCB2b2lkIEhUTUxNZWRpYUVsZW1lbnQ6OnVwZGF0ZVNsZWVw RGlzYWJsaW5nKCkKIAogSFRNTE1lZGlhRWxlbWVudDo6U2xlZXBUeXBlIEhUTUxNZWRpYUVsZW1l bnQ6OnNob3VsZERpc2FibGVTbGVlcCgpIGNvbnN0CiB7CisgICAgLy8gRklYTUU6IFRoaXMgI2lm IHNob3VsZCBiZSByZW1vdmVkLCBiZWNhdXNlIEdUSyBub3cgc3VwcG9ydHMgU2xlZXBEaXNhYmxl ciwgYW5kIGJlY2F1c2UgdGhpcworICAgIC8vIGNvZGUgaXMgaGFybWxlc3Mgb24gcG9ydHMgd2hl cmUgU2xlZXBEaXNhYmxlciBkb2VzIG5vdGhpbmcuIEhvd2V2ZXIsIGFmdGVyIGJyaWVmIHRlc3Rp bmcgb24KKyAgICAvLyBZb3VUdWJlLCBJIG5vdGljZWQgdGhhdCBzbGVlcCBpcyBub3QgZGlzYWJs ZWQgZHVyaW5nIG5vcm1hbCB2aWRlbyBwbGF5YmFjaywgYnV0IGl0ICppcyoKKyAgICAvLyBkaXNh YmxlZCB3aGVuIGEgcGFnZSBwbGF5aW5nIHZpZGVvIGVudGVycyB0aGUgcGFnZSBjYWNoZSwgdW50 aWwgdGhlIGFzc29jaWF0ZWQgd2ViIHZpZXcgaXMKKyAgICAvLyBkZXN0cm95ZWQuIEtlZXAgaXQg Q29jb2Etb25seSBmb3Igbm93LCBzbyB0aGF0IGNhY2hlZCBwYWdlcyBkb24ndCBibG9jayBzbGVl cCBpbmRlZmluaXRlbHkuCiAjaWYgIVBMQVRGT1JNKENPQ09BKQogICAgIHJldHVybiBTbGVlcFR5 cGU6Ok5vbmU7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggZDI3YWI0MDEzMGE5NWM1ODhjZmQ2ZjUx YzIxOWViODFmYjczZmRiYS4uOTVmN2FhMzE3MjcyNDI0NGJjMTAwNDY4ZjQxMDZmMDlmNTM5Yjgz OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJW aWV3QmFzZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJWaWV3QmFzZS5jcHAKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlIDxnZGsvZ2Rra2V5c3lt cy5oPgogI2luY2x1ZGUgPGdsaWIvZ2kxOG4tbGliLmg+CiAjaW5jbHVkZSA8bWVtb3J5PgorI2lu Y2x1ZGUgPHBhbC9zeXN0ZW0vU2xlZXBEaXNhYmxlci5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFw Lmg+CiAjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9nbGliL1dU RkdUeXBlLmg+CkBAIC0xOTAsOSArMTkxLDcgQEAgc3RydWN0IF9XZWJLaXRXZWJWaWV3QmFzZVBy aXZhdGUgewogCiAjaWYgRU5BQkxFKEZVTExTQ1JFRU5fQVBJKQogICAgIGJvb2wgZnVsbFNjcmVl bk1vZGVBY3RpdmUgeyBmYWxzZSB9OwotICAgIEdSZWZQdHI8R0RCdXNQcm94eT4gc2NyZWVuU2F2 ZXJQcm94eTsKLSAgICBHUmVmUHRyPEdDYW5jZWxsYWJsZT4gc2NyZWVuU2F2ZXJJbmhpYml0Q2Fu Y2VsbGFibGU7Ci0gICAgdW5zaWduZWQgc2NyZWVuU2F2ZXJDb29raWUgeyAwIH07CisgICAgc3Rk Ojp1bmlxdWVfcHRyPFBBTDo6U2xlZXBEaXNhYmxlcj4gc2xlZXBEaXNhYmxlciB7IG51bGxwdHIg fTsKICNlbmRpZgogCiAgICAgc3RkOjp1bmlxdWVfcHRyPEFjY2VsZXJhdGVkQmFja2luZ1N0b3Jl PiBhY2NlbGVyYXRlZEJhY2tpbmdTdG9yZTsKQEAgLTUwMCw3ICs0OTksNiBAQCB2b2lkIHdlYmtp dFdlYlZpZXdCYXNlQ2hpbGRNb3ZlUmVzaXplKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJWaWV3LCBH dGtXaWRnZXQqIGNoaQogc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VEaXNwb3NlKEdPYmpl Y3QqIGdvYmplY3QpCiB7CiAgICAgV2ViS2l0V2ViVmlld0Jhc2UqIHdlYlZpZXcgPSBXRUJLSVRf V0VCX1ZJRVdfQkFTRShnb2JqZWN0KTsKLSAgICBnX2NhbmNlbGxhYmxlX2NhbmNlbCh3ZWJWaWV3 LT5wcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZS5nZXQoKSk7CiAgICAgd2Via2l0 V2ViVmlld0Jhc2VTZXRUb3BsZXZlbE9uU2NyZWVuV2luZG93KHdlYlZpZXcsIG51bGxwdHIpOwog ICAgIHdlYlZpZXctPnByaXYtPnBhZ2VQcm94eS0+Y2xvc2UoKTsKICAgICB3ZWJWaWV3LT5wcml2 LT5hY2NlbGVyYXRlZEJhY2tpbmdTdG9yZSA9IG51bGxwdHI7CkBAIC0xMjMxLDc1ICsxMjI5LDYg QEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUZvcndhcmROZXh0V2hlZWxFdmVudChXZWJLaXRXZWJW aWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UKICAgICB3ZWJraXRXZWJWaWV3QmFzZS0+cHJpdi0+ c2hvdWxkRm9yd2FyZE5leHRXaGVlbEV2ZW50ID0gdHJ1ZTsKIH0KIAotI2lmIEVOQUJMRShGVUxM U0NSRUVOX0FQSSkKLXN0YXRpYyB2b2lkIHNjcmVlblNhdmVySW5oaWJpdGVkQ2FsbGJhY2soR0RC dXNQcm94eSogc2NyZWVuU2F2ZXJQcm94eSwgR0FzeW5jUmVzdWx0KiByZXN1bHQsIFdlYktpdFdl YlZpZXdCYXNlKiB3ZWJWaWV3QmFzZSkKLXsKLSAgICBHUmVmUHRyPEdWYXJpYW50PiByZXR1cm5W YWx1ZSA9IGFkb3B0R1JlZihnX2RidXNfcHJveHlfY2FsbF9maW5pc2goc2NyZWVuU2F2ZXJQcm94 eSwgcmVzdWx0LCBudWxscHRyKSk7Ci0gICAgaWYgKHJldHVyblZhbHVlKQotICAgICAgICBnX3Zh cmlhbnRfZ2V0KHJldHVyblZhbHVlLmdldCgpLCAiKHUpIiwgJndlYlZpZXdCYXNlLT5wcml2LT5z Y3JlZW5TYXZlckNvb2tpZSk7Ci0gICAgd2ViVmlld0Jhc2UtPnByaXYtPnNjcmVlblNhdmVySW5o aWJpdENhbmNlbGxhYmxlID0gbnVsbHB0cjsKLX0KLQotc3RhdGljIHZvaWQgd2Via2l0V2ViVmll d0Jhc2VTZW5kSW5oaWJpdE1lc3NhZ2VUb1NjcmVlblNhdmVyKFdlYktpdFdlYlZpZXdCYXNlKiB3 ZWJWaWV3QmFzZSkKLXsKLSAgICBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUqIHByaXYgPSB3ZWJW aWV3QmFzZS0+cHJpdjsKLSAgICBBU1NFUlQocHJpdi0+c2NyZWVuU2F2ZXJQcm94eSk7Ci0gICAg cHJpdi0+c2NyZWVuU2F2ZXJDb29raWUgPSAwOwotICAgIGlmICghcHJpdi0+c2NyZWVuU2F2ZXJJ bmhpYml0Q2FuY2VsbGFibGUpCi0gICAgICAgIHByaXYtPnNjcmVlblNhdmVySW5oaWJpdENhbmNl bGxhYmxlID0gYWRvcHRHUmVmKGdfY2FuY2VsbGFibGVfbmV3KCkpOwotICAgIGdfZGJ1c19wcm94 eV9jYWxsKHByaXYtPnNjcmVlblNhdmVyUHJveHkuZ2V0KCksICJJbmhpYml0IiwgZ192YXJpYW50 X25ldygiKHNzKSIsIGdfZ2V0X3ByZ25hbWUoKSwgXygiV2Vic2l0ZSBydW5uaW5nIGluIGZ1bGxz Y3JlZW4gbW9kZSIpKSwKLSAgICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwgLTEsIHByaXYt PnNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlLmdldCgpLCByZWludGVycHJldF9jYXN0PEdB c3luY1JlYWR5Q2FsbGJhY2s+KHNjcmVlblNhdmVySW5oaWJpdGVkQ2FsbGJhY2spLCB3ZWJWaWV3 QmFzZSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHNjcmVlblNhdmVyUHJveHlDcmVhdGVkQ2FsbGJhY2so R09iamVjdCosIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmll d0Jhc2UpCi17Ci0gICAgLy8gV2ViS2l0V2ViVmlld0Jhc2UgY2FuY2VscyB0aGUgcHJveHkgY3Jl YXRpb24gb24gZGlzcG9zZSwgd2hpY2ggbWVhbnMgdGhpcyBjb3VsZCBiZSBjYWxsZWQKLSAgICAv LyBhZnRlciB0aGUgd2ViIHZpZXcgaGFzIGJlZW4gZGVzdHJveWVkIGFuZCBnX2RidXNfcHJveHlf bmV3X2Zvcl9idXNfZmluaXNoIHdpbGwgcmV0dXJuIG51bGxwdHIuCi0gICAgLy8gU28sIG1ha2Ug c3VyZSB3ZSBkb24ndCB1c2UgdGhlIHdlYiB2aWV3IHVubGVzcyB3ZSBoYXZlIGEgdmFsaWQgcHJv eHkuCi0gICAgLy8gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NTE2NTMuCi0gICAgR1JlZlB0cjxHREJ1c1Byb3h5PiBwcm94eSA9IGFkb3B0R1JlZihnX2RidXNf cHJveHlfbmV3X2Zvcl9idXNfZmluaXNoKHJlc3VsdCwgbnVsbHB0cikpOwotICAgIGlmICghcHJv eHkpCi0gICAgICAgIHJldHVybjsKLQotICAgIHdlYlZpZXdCYXNlLT5wcml2LT5zY3JlZW5TYXZl clByb3h5ID0gcHJveHk7Ci0gICAgd2Via2l0V2ViVmlld0Jhc2VTZW5kSW5oaWJpdE1lc3NhZ2VU b1NjcmVlblNhdmVyKHdlYlZpZXdCYXNlKTsKLX0KLQotc3RhdGljIHZvaWQgd2Via2l0V2ViVmll d0Jhc2VJbmhpYml0U2NyZWVuU2F2ZXIoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYlZpZXdCYXNlKQot ewotICAgIFdlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZSogcHJpdiA9IHdlYlZpZXdCYXNlLT5wcml2 OwotICAgIGlmIChwcml2LT5zY3JlZW5TYXZlckNvb2tpZSkgewotICAgICAgICAvLyBBbHJlYWR5 IGluaGliaXRlZC4KLSAgICAgICAgcmV0dXJuOwotICAgIH0KLQotICAgIGlmIChwcml2LT5zY3Jl ZW5TYXZlclByb3h5KSB7Ci0gICAgICAgIHdlYmtpdFdlYlZpZXdCYXNlU2VuZEluaGliaXRNZXNz YWdlVG9TY3JlZW5TYXZlcih3ZWJWaWV3QmFzZSk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0K LSAgICBwcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZSA9IGFkb3B0R1JlZihnX2Nh bmNlbGxhYmxlX25ldygpKTsKLSAgICBnX2RidXNfcHJveHlfbmV3X2Zvcl9idXMoR19CVVNfVFlQ RV9TRVNTSU9OLCBzdGF0aWNfY2FzdDxHREJ1c1Byb3h5RmxhZ3M+KEdfREJVU19QUk9YWV9GTEFH U19ET19OT1RfTE9BRF9QUk9QRVJUSUVTIHwgR19EQlVTX1BST1hZX0ZMQUdTX0RPX05PVF9DT05O RUNUX1NJR05BTFMpLAotICAgICAgICBudWxscHRyLCAib3JnLmZyZWVkZXNrdG9wLlNjcmVlblNh dmVyIiwgIi9TY3JlZW5TYXZlciIsICJvcmcuZnJlZWRlc2t0b3AuU2NyZWVuU2F2ZXIiLCBwcml2 LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZS5nZXQoKSwKLSAgICAgICAgcmVpbnRlcnBy ZXRfY2FzdDxHQXN5bmNSZWFkeUNhbGxiYWNrPihzY3JlZW5TYXZlclByb3h5Q3JlYXRlZENhbGxi YWNrKSwgd2ViVmlld0Jhc2UpOwotfQotCi1zdGF0aWMgdm9pZCB3ZWJraXRXZWJWaWV3QmFzZVVu aW5oaWJpdFNjcmVlblNhdmVyKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJWaWV3QmFzZSkKLXsKLSAg ICBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUqIHByaXYgPSB3ZWJWaWV3QmFzZS0+cHJpdjsKLSAg ICBpZiAoIXByaXYtPnNjcmVlblNhdmVyQ29va2llKSB7Ci0gICAgICAgIC8vIE5vdCBpbmhpYml0 ZWQgb3IgaXQncyBiZWluZyBpbmhpYml0ZWQuCi0gICAgICAgIGdfY2FuY2VsbGFibGVfY2FuY2Vs KHByaXYtPnNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlLmdldCgpKTsKLSAgICAgICAgcmV0 dXJuOwotICAgIH0KLQotICAgIC8vIElmIHdlIGhhdmUgYSBjb29raWUgd2Ugc2hvdWxkIGhhdmUg YSBwcm94eS4KLSAgICBBU1NFUlQocHJpdi0+c2NyZWVuU2F2ZXJQcm94eSk7Ci0gICAgZ19kYnVz X3Byb3h5X2NhbGwocHJpdi0+c2NyZWVuU2F2ZXJQcm94eS5nZXQoKSwgIlVuSW5oaWJpdCIsIGdf dmFyaWFudF9uZXcoIih1KSIsIHByaXYtPnNjcmVlblNhdmVyQ29va2llKSwgR19EQlVTX0NBTExf RkxBR1NfTk9ORSwgLTEsIG51bGxwdHIsIG51bGxwdHIsIG51bGxwdHIpOwotICAgIHByaXYtPnNj cmVlblNhdmVyQ29va2llID0gMDsKLX0KLSNlbmRpZgotCiB2b2lkIHdlYmtpdFdlYlZpZXdCYXNl RW50ZXJGdWxsU2NyZWVuKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRXZWJWaWV3QmFzZSkKIHsK ICNpZiBFTkFCTEUoRlVMTFNDUkVFTl9BUEkpCkBAIC0xMzE0LDcgKzEyNDMsNyBAQCB2b2lkIHdl YmtpdFdlYlZpZXdCYXNlRW50ZXJGdWxsU2NyZWVuKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRX ZWJWaWV3QmFzZSkKICAgICAgICAgZ3RrX3dpbmRvd19mdWxsc2NyZWVuKEdUS19XSU5ET1codG9w TGV2ZWxXaW5kb3cpKTsKICAgICBmdWxsU2NyZWVuTWFuYWdlclByb3h5LT5kaWRFbnRlckZ1bGxT Y3JlZW4oKTsKICAgICBwcml2LT5mdWxsU2NyZWVuTW9kZUFjdGl2ZSA9IHRydWU7Ci0gICAgd2Vi a2l0V2ViVmlld0Jhc2VJbmhpYml0U2NyZWVuU2F2ZXIod2Via2l0V2ViVmlld0Jhc2UpOworICAg IHByaXYtPnNsZWVwRGlzYWJsZXIgPSBQQUw6OlNsZWVwRGlzYWJsZXI6OmNyZWF0ZShfKCJXZWJz aXRlIHJ1bm5pbmcgaW4gZnVsbHNjcmVlbiBtb2RlIiksIFBBTDo6U2xlZXBEaXNhYmxlcjo6VHlw ZTo6RGlzcGxheSk7CiAjZW5kaWYKIH0KIApAQCAtMTMzMiw3ICsxMjYxLDcgQEAgdm9pZCB3ZWJr aXRXZWJWaWV3QmFzZUV4aXRGdWxsU2NyZWVuKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJraXRXZWJW aWV3QmFzZSkKICAgICAgICAgZ3RrX3dpbmRvd191bmZ1bGxzY3JlZW4oR1RLX1dJTkRPVyh0b3BM ZXZlbFdpbmRvdykpOwogICAgIGZ1bGxTY3JlZW5NYW5hZ2VyUHJveHktPmRpZEV4aXRGdWxsU2Ny ZWVuKCk7CiAgICAgcHJpdi0+ZnVsbFNjcmVlbk1vZGVBY3RpdmUgPSBmYWxzZTsKLSAgICB3ZWJr aXRXZWJWaWV3QmFzZVVuaW5oaWJpdFNjcmVlblNhdmVyKHdlYmtpdFdlYlZpZXdCYXNlKTsKKyAg ICBwcml2LT5zbGVlcERpc2FibGVyID0gbnVsbHB0cjsKICNlbmRpZgogfQogCg== 327980 2017-11-30 09:19:37 -0800 2017-12-01 13:08:57 -0800 Patch bug-178485-20171130111936.patch text/plain 18530 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI1MzI4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDkxYWViMmQ2YzkzMjY1 MGM0NjQwMjFlN2UzMDY5NWFhYjBkMDA1OS4uNzgwMmRhZWJmOGRjNDM0NGUwYzM2MzUzNzBlODdh YWVkNTAzNWQ1MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE3LTExLTMwICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBJ bXBsZW1lbnQgUEFMOjpTbGVlcERpc2FibGVyCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNzg0ODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgYSBjb21tZW50IHRvIHdhcm4gYWJvdXQgc29tZSBvZGQg dXNlIG9mIFNsZWVwRGlzYWJsZXIgaW4gSFRNTE1lZGlhRWxlbWVudC4KKworICAgICAgICAqIGh0 bWwvSFRNTE1lZGlhRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFFbGVt ZW50OjpzaG91bGREaXNhYmxlU2xlZXAgY29uc3QpOgorCiAyMDE3LTExLTMwICBaYW4gRG9iZXJz ZWsgIDx6ZG9iZXJzZWtAaWdhbGlhLmNvbT4KIAogICAgICAgICBbQ29vcmRHcmFwaGljc10gTW92 ZSBDb29yZGluYXRlZEdyYXBoaWNzTGF5ZXIgcGFpbnRpbmcgYmVoaW5kIE5pY29zaWE6OlBhaW50 aW5nRW5naW5lCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwppbmRleCAwOTUwZGZmMDcyM2M4MWZlMmE0M2ZhOTdj ZDViNWFjMDBjNTM4YzAxLi5iZTcwNmI5ZGYyOWM1MmIxZGNmODk3MmUzYjAxYzc2MDc5NDFjYjlj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9X ZWJDb3JlL1BBTC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAxNy0xMS0zMCAgTWljaGFl bCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gSW1w bGVtZW50IFBBTDo6U2xlZXBEaXNhYmxlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTc4NDg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgKiBwYWwvUGxhdGZvcm1HVEsuY21ha2U6CisgICAgICAgICogcGFs L3N5c3RlbS9TbGVlcERpc2FibGVyLmNwcDoKKyAgICAgICAgKiBwYWwvc3lzdGVtL2d0ay9TbGVl cERpc2FibGVyR3RrLmNwcDogQWRkZWQuCisgICAgICAgIChQQUw6OlNsZWVwRGlzYWJsZXI6OmNy ZWF0ZSk6CisgICAgICAgIChQQUw6OlNsZWVwRGlzYWJsZXJHdGs6OlNsZWVwRGlzYWJsZXJHdGsp OgorICAgICAgICAoUEFMOjpTbGVlcERpc2FibGVyR3RrOjp+U2xlZXBEaXNhYmxlckd0ayk6Cisg ICAgICAgIChQQUw6OlNsZWVwRGlzYWJsZXJHdGs6OmFjcXVpcmVJbmhpYml0b3IpOgorICAgICAg ICAoUEFMOjpTbGVlcERpc2FibGVyR3RrOjpyZWxlYXNlSW5oaWJpdG9yKToKKyAgICAgICAgKiBw YWwvc3lzdGVtL2d0ay9TbGVlcERpc2FibGVyR3RrLmg6IEFkZGVkLgorCiAyMDE3LTExLTI5ICBC cmVudCBGdWxnaGFtICA8YmZ1bGdoYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFBhcnQgMjogQWRv cHQgdXBkYXRlZCBOU0tleWVkW1VuXUFyY2hpdmVyIEFQSSB3aGVuIGF2YWlsYWJsZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpp bmRleCA2ZGM3ZTYzODc3Y2I2NzVkYjkzMDhjODgyNzE0MzIyMjViOThhYjhiLi5mOTY5NmE4ZjJk NjNhY2FjZjAxOWRjZWJkY2VhYjI5ZWVhNmI4MTQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBA CisyMDE3LTExLTMwICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4K KworICAgICAgICBbR1RLXSBJbXBsZW1lbnQgUEFMOjpTbGVlcERpc2FibGVyCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzg0ODUKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdCYXNlLmNwcDoKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdCYXNlRGlzcG9z ZSk6CisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZUVudGVyRnVsbFNjcmVlbik6CisgICAgICAg ICh3ZWJraXRXZWJWaWV3QmFzZUV4aXRGdWxsU2NyZWVuKToKKyAgICAgICAgKHNjcmVlblNhdmVy SW5oaWJpdGVkQ2FsbGJhY2spOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2ViVmlld0Jhc2VT ZW5kSW5oaWJpdE1lc3NhZ2VUb1NjcmVlblNhdmVyKTogRGVsZXRlZC4KKyAgICAgICAgKHNjcmVl blNhdmVyUHJveHlDcmVhdGVkQ2FsbGJhY2spOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2Vi Vmlld0Jhc2VJbmhpYml0U2NyZWVuU2F2ZXIpOiBEZWxldGVkLgorICAgICAgICAod2Via2l0V2Vi Vmlld0Jhc2VVbmluaGliaXRTY3JlZW5TYXZlcik6IERlbGV0ZWQuCisKIDIwMTctMTEtMzAgIFph biBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFtDb29yZEdyYXBo aWNzXSBNb3ZlIENvb3JkaW5hdGVkR3JhcGhpY3NMYXllciBwYWludGluZyBiZWhpbmQgTmljb3Np YTo6UGFpbnRpbmdFbmdpbmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvUGxh dGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL1BsYXRmb3JtR1RLLmNtYWtl CmluZGV4IGI0YWQ0NWNjN2ZiNTUwZWM0NDdlNGQwODUwNzg5ZDFhZDg3NzUxZTUuLjRkMjZiZjI3 YWMxZjA3NmI3NzliM2ViMjc5MzViZGVmNWE5ZDI0YzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL1BBTC9wYWwvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML3Bh bC9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMyw2ICszLDcgQEAgbGlzdChBUFBFTkQgUEFMX1NPVVJD RVMKIAogICAgIHN5c3RlbS9DbG9ja0dlbmVyaWMuY3BwCiAKKyAgICBzeXN0ZW0vZ3RrL1NsZWVw RGlzYWJsZXJHdGsuY3BwCiAgICAgc3lzdGVtL2d0ay9Tb3VuZEd0ay5jcHAKIAogICAgIHRleHQv S2lsbFJpbmcuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9T bGVlcERpc2FibGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL1NsZWVwRGlz YWJsZXIuY3BwCmluZGV4IDEwMTg4ZWVkZmY0MTdiMmU2MjFhODAxZGRkNTI2Y2I1NjY2Zjc0ZjUu LjQzOTA4NTBlYTQwM2EyNjdkMjNhNTM0ODY3M2Y0MTdkNGQxNTAyOTkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL1NsZWVwRGlzYWJsZXIuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL1NsZWVwRGlzYWJsZXIuY3BwCkBAIC0yOCwxMiArMjgs MTIgQEAKIAogbmFtZXNwYWNlIFBBTCB7CiAKLSNpZiAhUExBVEZPUk0oQ09DT0EpCisjaWYgIVBM QVRGT1JNKENPQ09BKSAmJiAhUExBVEZPUk0oR1RLKQogc3RkOjp1bmlxdWVfcHRyPFNsZWVwRGlz YWJsZXI+IFNsZWVwRGlzYWJsZXI6OmNyZWF0ZShjb25zdCBjaGFyKiByZWFzb24sIFR5cGUgdHlw ZSkKIHsKICAgICByZXR1cm4gc3RkOjp1bmlxdWVfcHRyPFNsZWVwRGlzYWJsZXI+KG5ldyBTbGVl cERpc2FibGVyKHJlYXNvbiwgdHlwZSkpOwogfQotI2VuZGlmIC8vICFQTEFURk9STShDT0NPQSkK KyNlbmRpZiAvLyAhUExBVEZPUk0oQ09DT0EpICYmICFQTEFURk9STShHVEspCiAKIFNsZWVwRGlz YWJsZXI6OlNsZWVwRGlzYWJsZXIoY29uc3QgY2hhciosIFR5cGUgdHlwZSkKICAgICA6IG1fdHlw ZSh0eXBlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1Ns ZWVwRGlzYWJsZXJHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0vZ3RrL1Ns ZWVwRGlzYWJsZXJHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNjYzc0ZmVmZWIwNWQ0Y2NlN2VjZTQzNDI2 ZDRmMDRlZWNhYmZiNmMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFs L3N5c3RlbS9ndGsvU2xlZXBEaXNhYmxlckd0ay5jcHAKQEAgLTAsMCArMSwxMjAgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTcgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G CisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNv bmZpZy5oIgorI2luY2x1ZGUgIlNsZWVwRGlzYWJsZXJHdGsuaCIKKworI2luY2x1ZGUgPHd0Zi9n bGliL0dVbmlxdWVQdHIuaD4KKworbmFtZXNwYWNlIFBBTCB7CisKK3N0ZDo6dW5pcXVlX3B0cjxT bGVlcERpc2FibGVyPiBTbGVlcERpc2FibGVyOjpjcmVhdGUoY29uc3QgY2hhciogcmVhc29uLCBU eXBlIHR5cGUpCit7CisgICAgcmV0dXJuIHN0ZDo6dW5pcXVlX3B0cjxTbGVlcERpc2FibGVyPihu ZXcgU2xlZXBEaXNhYmxlckd0ayhyZWFzb24sIHR5cGUpKTsKK30KKworU2xlZXBEaXNhYmxlckd0 azo6U2xlZXBEaXNhYmxlckd0ayhjb25zdCBjaGFyKiByZWFzb24sIFR5cGUgdHlwZSkKKyAgICA6 IFNsZWVwRGlzYWJsZXIocmVhc29uLCB0eXBlKQorICAgICwgbV9jYW5jZWxsYWJsZShhZG9wdEdS ZWYoZ19jYW5jZWxsYWJsZV9uZXcoKSkpCisgICAgLCBtX3JlYXNvbihyZWFzb24pCit7CisgICAg Ly8gV2UgZG9uJ3Qgc3VwcG9ydCBzdXNwZW5kICgiU3lzdGVtIikgaW5oaWJpdG9ycywgb25seSBp ZGxlIGluaGliaXRvcnMuCisgICAgLy8gVG8gZ2V0IHN1c3BlbmQgaW5oaWJpdG9ycywgd2UnZCBu ZWVkIHRvIHVzZSB0aGUgZmFuY3kgR05PTUUKKyAgICAvLyBTZXNzaW9uTWFuYWdlciBBUEksIHdo aWNoIHJlcXVpcmVzIHJlZ2lzdGVyaW5nIGFzIGEgY2xpZW50IGFwcGxpY2F0aW9uLAorICAgIC8v IHdoaWNoIGlzIG5vdCBwcmFjdGljYWwgZnJvbSB0aGUgd2ViIHByb2Nlc3MuIFNlY29uZGx5LCBi ZWNhdXNlIHRoZSBvbmx5CisgICAgLy8gY3VycmVudCB1c2Ugb2YgYSBzdXNwZW5kIGluaGliaXRv ciBpbiBXZWJLaXQsCisgICAgLy8gSFRNTE1lZGlhRWxlbWVudDo6c2hvdWxkRGlzYWJsZVNsZWVw LCBpcyBzdXNwaWNpb3VzLiBUaGVyZSdzIHJlYWxseSBubworICAgIC8vIHZhbGlkIHJlYXNvbiBm b3IgV2ViS2l0IHRvIGV2ZXIgYmxvY2sgc3VzcGVuZCwgb25seSBpZGxlLgorICAgIGlmICh0eXBl ICE9IFNsZWVwRGlzYWJsZXI6OlR5cGU6OkRpc3BsYXkpCisgICAgICAgIHJldHVybjsKKworICAg IGdfZGJ1c19wcm94eV9uZXdfZm9yX2J1cyhHX0JVU19UWVBFX1NFU1NJT04sIHN0YXRpY19jYXN0 PEdEQnVzUHJveHlGbGFncz4oR19EQlVTX1BST1hZX0ZMQUdTX0RPX05PVF9MT0FEX1BST1BFUlRJ RVMgfCBHX0RCVVNfUFJPWFlfRkxBR1NfRE9fTk9UX0NPTk5FQ1RfU0lHTkFMUyksCisgICAgICAg IG51bGxwdHIsICJvcmcuZnJlZWRlc2t0b3AuU2NyZWVuU2F2ZXIiLCAiL29yZy9mcmVlZGVza3Rv cC9TY3JlZW5TYXZlciIsICJvcmcuZnJlZWRlc2t0b3AuU2NyZWVuU2F2ZXIiLCBtX2NhbmNlbGxh YmxlLmdldCgpLAorICAgICAgICBbXShHT2JqZWN0KiwgR0FzeW5jUmVzdWx0KiByZXN1bHQsIGdw b2ludGVyIHVzZXJEYXRhKSB7CisgICAgICAgICAgICBHVW5pcXVlT3V0UHRyPEdFcnJvcj4gZXJy b3I7CisgICAgICAgICAgICBHUmVmUHRyPEdEQnVzUHJveHk+IHByb3h5ID0gYWRvcHRHUmVmKGdf ZGJ1c19wcm94eV9uZXdfZm9yX2J1c19maW5pc2gocmVzdWx0LCAmZXJyb3Iub3V0UHRyKCkpKTsK KyAgICAgICAgICAgIGlmIChlcnJvciAmJiBnX2Vycm9yX21hdGNoZXMoZXJyb3IuZ2V0KCksIEdf SU9fRVJST1IsIEdfSU9fRVJST1JfQ0FOQ0VMTEVEKSkKKyAgICAgICAgICAgICAgICByZXR1cm47 CisKKyAgICAgICAgICAgIGF1dG8qIHNlbGYgPSBzdGF0aWNfY2FzdDxTbGVlcERpc2FibGVyR3Rr Kj4odXNlckRhdGEpOworICAgICAgICAgICAgaWYgKCFlcnJvcikgeworICAgICAgICAgICAgICAg IEFTU0VSVChwcm94eSk7CisgICAgICAgICAgICAgICAgR1VuaXF1ZVB0cjxjaGFyPiBuYW1lT3du ZXIoZ19kYnVzX3Byb3h5X2dldF9uYW1lX293bmVyKHByb3h5LmdldCgpKSk7CisgICAgICAgICAg ICAgICAgaWYgKG5hbWVPd25lcikgeworICAgICAgICAgICAgICAgICAgICBzZWxmLT5tX3NjcmVl blNhdmVyUHJveHkgPSBwcm94eTsKKyAgICAgICAgICAgICAgICAgICAgc2VsZi0+YWNxdWlyZUlu aGliaXRvcigpOworICAgICAgICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgfQorCisgICAgICAgICAgICAvLyBHaXZlIHVwLiBEb24ndCB3YXJuIHRo ZSB1c2VyOiB0aGlzIGlzIGV4cGVjdGVkLgorICAgICAgICAgICAgc2VsZi0+bV9jYW5jZWxsYWJs ZSA9IG51bGxwdHI7CisgICAgICAgIH0sIHRoaXMpOworfQorCitTbGVlcERpc2FibGVyR3RrOjp+ U2xlZXBEaXNhYmxlckd0aygpCit7CisgICAgaWYgKG1fY2FuY2VsbGFibGUpCisgICAgICAgIGdf Y2FuY2VsbGFibGVfY2FuY2VsKG1fY2FuY2VsbGFibGUuZ2V0KCkpOworICAgIGVsc2UgaWYgKG1f c2NyZWVuU2F2ZXJDb29raWUpCisgICAgICAgIHJlbGVhc2VJbmhpYml0b3IoKTsKK30KKwordm9p ZCBTbGVlcERpc2FibGVyR3RrOjphY3F1aXJlSW5oaWJpdG9yKCkKK3sKKyAgICBBU1NFUlQobV9z Y3JlZW5TYXZlclByb3h5KTsKKyAgICBnX2RidXNfcHJveHlfY2FsbChtX3NjcmVlblNhdmVyUHJv eHkuZ2V0KCksICJJbmhpYml0IiwgZ192YXJpYW50X25ldygiKHNzKSIsIGdfZ2V0X3ByZ25hbWUo KSwgbV9yZWFzb24uZGF0YSgpKSwKKyAgICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwgLTEs IG1fY2FuY2VsbGFibGUuZ2V0KCksIFtdKEdPYmplY3QqIHByb3h5LCBHQXN5bmNSZXN1bHQqIHJl c3VsdCwgZ3BvaW50ZXIgdXNlckRhdGEpIHsKKyAgICAgICAgICAgIEdVbmlxdWVPdXRQdHI8R0Vy cm9yPiBlcnJvcjsKKyAgICAgICAgICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHJldHVyblZhbHVlID0g YWRvcHRHUmVmKGdfZGJ1c19wcm94eV9jYWxsX2ZpbmlzaChHX0RCVVNfUFJPWFkocHJveHkpLCBy ZXN1bHQsICZlcnJvci5vdXRQdHIoKSkpOworICAgICAgICAgICAgaWYgKGVycm9yICYmIGdfZXJy b3JfbWF0Y2hlcyhlcnJvci5nZXQoKSwgR19JT19FUlJPUiwgR19JT19FUlJPUl9DQU5DRUxMRUQp KQorICAgICAgICAgICAgICAgIHJldHVybjsKKworICAgICAgICAgICAgYXV0byogc2VsZiA9IHN0 YXRpY19jYXN0PFNsZWVwRGlzYWJsZXJHdGsqPih1c2VyRGF0YSk7CisgICAgICAgICAgICBpZiAo ZXJyb3IpCisgICAgICAgICAgICAgICAgZ193YXJuaW5nKCJDYWxsaW5nICVzLkluaGliaXQgZmFp bGVkOiAlcyIsIGdfZGJ1c19wcm94eV9nZXRfaW50ZXJmYWNlX25hbWUoc2VsZi0+bV9zY3JlZW5T YXZlclByb3h5LmdldCgpKSwgZXJyb3ItPm1lc3NhZ2UpOworICAgICAgICAgICAgZWxzZSB7Cisg ICAgICAgICAgICAgICAgQVNTRVJUKHJldHVyblZhbHVlKTsKKyAgICAgICAgICAgICAgICBnX3Zh cmlhbnRfZ2V0KHJldHVyblZhbHVlLmdldCgpLCAiKHUpIiwgJnNlbGYtPm1fc2NyZWVuU2F2ZXJD b29raWUpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgc2VsZi0+bV9jYW5jZWxsYWJsZSA9 IG51bGxwdHI7CisgICAgICAgIH0sIHRoaXMpOworfQorCit2b2lkIFNsZWVwRGlzYWJsZXJHdGs6 OnJlbGVhc2VJbmhpYml0b3IoKQoreworICAgIEFTU0VSVChtX3NjcmVlblNhdmVyQ29va2llKTsK KyAgICBBU1NFUlQobV9zY3JlZW5TYXZlclByb3h5KTsKKworICAgIGdfZGJ1c19wcm94eV9jYWxs KG1fc2NyZWVuU2F2ZXJQcm94eS5nZXQoKSwgIlVuSW5oaWJpdCIsIGdfdmFyaWFudF9uZXcoIih1 KSIsIG1fc2NyZWVuU2F2ZXJDb29raWUpLAorICAgICAgICBHX0RCVVNfQ0FMTF9GTEFHU19OT05F LCAtMSwgbnVsbHB0ciwgW10oR09iamVjdCogcHJveHksIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBn cG9pbnRlcikgeworICAgICAgICAgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAg ICAgICAgICAgR1JlZlB0cjxHVmFyaWFudD4gcmV0dXJuVmFsdWUgPSBhZG9wdEdSZWYoZ19kYnVz X3Byb3h5X2NhbGxfZmluaXNoKEdfREJVU19QUk9YWShwcm94eSksIHJlc3VsdCwgJmVycm9yLm91 dFB0cigpKSk7CisgICAgICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICAgICAgZ193YXJu aW5nKCJDYWxsaW5nICVzLlVuSW5oaWJpdCBmYWlsZWQ6ICVzIiwgZ19kYnVzX3Byb3h5X2dldF9p bnRlcmZhY2VfbmFtZShHX0RCVVNfUFJPWFkocHJveHkpKSwgZXJyb3ItPm1lc3NhZ2UpOworICAg IH0sIG51bGxwdHIpOworfQorCit9IC8vIG5hbWVzcGFjZSBQQUwKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL2d0ay9TbGVlcERpc2FibGVyR3RrLmggYi9Tb3VyY2Uv V2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9ndGsvU2xlZXBEaXNhYmxlckd0ay5oCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjRjZjJiOGE4MjU5ZDY4NGFjMDRjOWExZjUxYTA2OTExOWMxZGNkOGMKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9ndGsvU2xlZXBEaXNhYmxlckd0ay5o CkBAIC0wLDAgKzEsNTIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTcgSWdhbGlhIFMuTC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g QU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJTbGVlcERpc2FibGVyLmgiCisK KyNpbmNsdWRlIDxnaW8vZ2lvLmg+CisjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFBBTCB7CisKK2NsYXNzIFNs ZWVwRGlzYWJsZXJHdGsgOiBwdWJsaWMgU2xlZXBEaXNhYmxlciB7CitwdWJsaWM6CisgICAgU2xl ZXBEaXNhYmxlckd0ayhjb25zdCBjaGFyKiwgVHlwZSk7CisgICAgdmlydHVhbCB+U2xlZXBEaXNh Ymxlckd0aygpOworCitwcml2YXRlOgorICAgIHZvaWQgYWNxdWlyZUluaGliaXRvcigpOworICAg IHZvaWQgcmVsZWFzZUluaGliaXRvcigpOworCisgICAgR1JlZlB0cjxHREJ1c1Byb3h5PiBtX3Nj cmVlblNhdmVyUHJveHk7CisgICAgdW5zaWduZWQgbV9zY3JlZW5TYXZlckNvb2tpZSB7IDAgfTsK KworICAgIEdSZWZQdHI8R0NhbmNlbGxhYmxlPiBtX2NhbmNlbGxhYmxlOworICAgIENTdHJpbmcg bV9yZWFzb247Cit9OworCit9IC8vIG5hbWVzcGFjZSBQQUwKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxNZWRpYUVsZW1lbnQuY3BwCmluZGV4IDA0ZjlkYTk2YzViODMwM2U3MTJiNTg0NzA3ZDg3MTZj ZGY0MGY5MzEuLmRiZDBhMGIxMzUyY2ZiZjhhOTZlMzM1NmFiYWU4NTg1ZjVkYWE3YWIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcApAQCAtNjYwNyw2ICs2NjA3LDcg QEAgdm9pZCBIVE1MTWVkaWFFbGVtZW50Ojp1cGRhdGVTbGVlcERpc2FibGluZygpCiAKIEhUTUxN ZWRpYUVsZW1lbnQ6OlNsZWVwVHlwZSBIVE1MTWVkaWFFbGVtZW50OjpzaG91bGREaXNhYmxlU2xl ZXAoKSBjb25zdAogeworICAgIC8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTgwMTk3IGJlZm9yZSByZW1vdmluZyB0aGlzIGd1YXJkLgogI2lmICFQTEFURk9S TShDT0NPQSkKICAgICByZXR1cm4gU2xlZXBUeXBlOjpOb25lOwogI2VuZGlmCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcCBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCmlu ZGV4IGQyN2FiNDAxMzBhOTVjNTg4Y2ZkNmY1MWMyMTllYjgxZmI3M2ZkYmEuLjUxM2RmNDQ3MTQ1 NzU0YTM5MGZmZjAxOTg2OGI1M2E0MDA0MDc4OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBAIC02Myw2ICs2Myw3 IEBACiAjaW5jbHVkZSA8Z2RrL2dka2tleXN5bXMuaD4KICNpbmNsdWRlIDxnbGliL2dpMThuLWxp Yi5oPgogI2luY2x1ZGUgPG1lbW9yeT4KKyNpbmNsdWRlIDxwYWwvc3lzdGVtL1NsZWVwRGlzYWJs ZXIuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9nbGliL0dSZWZQ dHIuaD4KICNpbmNsdWRlIDx3dGYvZ2xpYi9XVEZHVHlwZS5oPgpAQCAtMTkwLDkgKzE5MSw3IEBA IHN0cnVjdCBfV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlIHsKIAogI2lmIEVOQUJMRShGVUxMU0NS RUVOX0FQSSkKICAgICBib29sIGZ1bGxTY3JlZW5Nb2RlQWN0aXZlIHsgZmFsc2UgfTsKLSAgICBH UmVmUHRyPEdEQnVzUHJveHk+IHNjcmVlblNhdmVyUHJveHk7Ci0gICAgR1JlZlB0cjxHQ2FuY2Vs bGFibGU+IHNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlOwotICAgIHVuc2lnbmVkIHNjcmVl blNhdmVyQ29va2llIHsgMCB9OworICAgIHN0ZDo6dW5pcXVlX3B0cjxQQUw6OlNsZWVwRGlzYWJs ZXI+IHNsZWVwRGlzYWJsZXI7CiAjZW5kaWYKIAogICAgIHN0ZDo6dW5pcXVlX3B0cjxBY2NlbGVy YXRlZEJhY2tpbmdTdG9yZT4gYWNjZWxlcmF0ZWRCYWNraW5nU3RvcmU7CkBAIC01MDAsNyArNDk5 LDYgQEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUNoaWxkTW92ZVJlc2l6ZShXZWJLaXRXZWJWaWV3 QmFzZSogd2ViVmlldywgR3RrV2lkZ2V0KiBjaGkKIHN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdC YXNlRGlzcG9zZShHT2JqZWN0KiBnb2JqZWN0KQogewogICAgIFdlYktpdFdlYlZpZXdCYXNlKiB3 ZWJWaWV3ID0gV0VCS0lUX1dFQl9WSUVXX0JBU0UoZ29iamVjdCk7Ci0gICAgZ19jYW5jZWxsYWJs ZV9jYW5jZWwod2ViVmlldy0+cHJpdi0+c2NyZWVuU2F2ZXJJbmhpYml0Q2FuY2VsbGFibGUuZ2V0 KCkpOwogICAgIHdlYmtpdFdlYlZpZXdCYXNlU2V0VG9wbGV2ZWxPblNjcmVlbldpbmRvdyh3ZWJW aWV3LCBudWxscHRyKTsKICAgICB3ZWJWaWV3LT5wcml2LT5wYWdlUHJveHktPmNsb3NlKCk7CiAg ICAgd2ViVmlldy0+cHJpdi0+YWNjZWxlcmF0ZWRCYWNraW5nU3RvcmUgPSBudWxscHRyOwpAQCAt MTIzMSw3NSArMTIyOSw2IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VGb3J3YXJkTmV4dFdoZWVs RXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZpZXdCYXNlCiAgICAgd2Via2l0V2Vi Vmlld0Jhc2UtPnByaXYtPnNob3VsZEZvcndhcmROZXh0V2hlZWxFdmVudCA9IHRydWU7CiB9CiAK LSNpZiBFTkFCTEUoRlVMTFNDUkVFTl9BUEkpCi1zdGF0aWMgdm9pZCBzY3JlZW5TYXZlckluaGli aXRlZENhbGxiYWNrKEdEQnVzUHJveHkqIHNjcmVlblNhdmVyUHJveHksIEdBc3luY1Jlc3VsdCog cmVzdWx0LCBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UpCi17Ci0gICAgR1JlZlB0cjxH VmFyaWFudD4gcmV0dXJuVmFsdWUgPSBhZG9wdEdSZWYoZ19kYnVzX3Byb3h5X2NhbGxfZmluaXNo KHNjcmVlblNhdmVyUHJveHksIHJlc3VsdCwgbnVsbHB0cikpOwotICAgIGlmIChyZXR1cm5WYWx1 ZSkKLSAgICAgICAgZ192YXJpYW50X2dldChyZXR1cm5WYWx1ZS5nZXQoKSwgIih1KSIsICZ3ZWJW aWV3QmFzZS0+cHJpdi0+c2NyZWVuU2F2ZXJDb29raWUpOwotICAgIHdlYlZpZXdCYXNlLT5wcml2 LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZSA9IG51bGxwdHI7Ci19Ci0KLXN0YXRpYyB2 b2lkIHdlYmtpdFdlYlZpZXdCYXNlU2VuZEluaGliaXRNZXNzYWdlVG9TY3JlZW5TYXZlcihXZWJL aXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UpCi17Ci0gICAgV2ViS2l0V2ViVmlld0Jhc2VQcml2 YXRlKiBwcml2ID0gd2ViVmlld0Jhc2UtPnByaXY7Ci0gICAgQVNTRVJUKHByaXYtPnNjcmVlblNh dmVyUHJveHkpOwotICAgIHByaXYtPnNjcmVlblNhdmVyQ29va2llID0gMDsKLSAgICBpZiAoIXBy aXYtPnNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlKQotICAgICAgICBwcml2LT5zY3JlZW5T YXZlckluaGliaXRDYW5jZWxsYWJsZSA9IGFkb3B0R1JlZihnX2NhbmNlbGxhYmxlX25ldygpKTsK LSAgICBnX2RidXNfcHJveHlfY2FsbChwcml2LT5zY3JlZW5TYXZlclByb3h5LmdldCgpLCAiSW5o aWJpdCIsIGdfdmFyaWFudF9uZXcoIihzcykiLCBnX2dldF9wcmduYW1lKCksIF8oIldlYnNpdGUg cnVubmluZyBpbiBmdWxsc2NyZWVuIG1vZGUiKSksCi0gICAgICAgIEdfREJVU19DQUxMX0ZMQUdT X05PTkUsIC0xLCBwcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZS5nZXQoKSwgcmVp bnRlcnByZXRfY2FzdDxHQXN5bmNSZWFkeUNhbGxiYWNrPihzY3JlZW5TYXZlckluaGliaXRlZENh bGxiYWNrKSwgd2ViVmlld0Jhc2UpOwotfQotCi1zdGF0aWMgdm9pZCBzY3JlZW5TYXZlclByb3h5 Q3JlYXRlZENhbGxiYWNrKEdPYmplY3QqLCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgV2ViS2l0V2Vi Vmlld0Jhc2UqIHdlYlZpZXdCYXNlKQotewotICAgIC8vIFdlYktpdFdlYlZpZXdCYXNlIGNhbmNl bHMgdGhlIHByb3h5IGNyZWF0aW9uIG9uIGRpc3Bvc2UsIHdoaWNoIG1lYW5zIHRoaXMgY291bGQg YmUgY2FsbGVkCi0gICAgLy8gYWZ0ZXIgdGhlIHdlYiB2aWV3IGhhcyBiZWVuIGRlc3Ryb3llZCBh bmQgZ19kYnVzX3Byb3h5X25ld19mb3JfYnVzX2ZpbmlzaCB3aWxsIHJldHVybiBudWxscHRyLgot ICAgIC8vIFNvLCBtYWtlIHN1cmUgd2UgZG9uJ3QgdXNlIHRoZSB3ZWIgdmlldyB1bmxlc3Mgd2Ug aGF2ZSBhIHZhbGlkIHByb3h5LgotICAgIC8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTUxNjUzLgotICAgIEdSZWZQdHI8R0RCdXNQcm94eT4gcHJveHkgPSBh ZG9wdEdSZWYoZ19kYnVzX3Byb3h5X25ld19mb3JfYnVzX2ZpbmlzaChyZXN1bHQsIG51bGxwdHIp KTsKLSAgICBpZiAoIXByb3h5KQotICAgICAgICByZXR1cm47Ci0KLSAgICB3ZWJWaWV3QmFzZS0+ cHJpdi0+c2NyZWVuU2F2ZXJQcm94eSA9IHByb3h5OwotICAgIHdlYmtpdFdlYlZpZXdCYXNlU2Vu ZEluaGliaXRNZXNzYWdlVG9TY3JlZW5TYXZlcih3ZWJWaWV3QmFzZSk7Ci19Ci0KLXN0YXRpYyB2 b2lkIHdlYmtpdFdlYlZpZXdCYXNlSW5oaWJpdFNjcmVlblNhdmVyKFdlYktpdFdlYlZpZXdCYXNl KiB3ZWJWaWV3QmFzZSkKLXsKLSAgICBXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUqIHByaXYgPSB3 ZWJWaWV3QmFzZS0+cHJpdjsKLSAgICBpZiAocHJpdi0+c2NyZWVuU2F2ZXJDb29raWUpIHsKLSAg ICAgICAgLy8gQWxyZWFkeSBpbmhpYml0ZWQuCi0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAg ICBpZiAocHJpdi0+c2NyZWVuU2F2ZXJQcm94eSkgewotICAgICAgICB3ZWJraXRXZWJWaWV3QmFz ZVNlbmRJbmhpYml0TWVzc2FnZVRvU2NyZWVuU2F2ZXIod2ViVmlld0Jhc2UpOwotICAgICAgICBy ZXR1cm47Ci0gICAgfQotCi0gICAgcHJpdi0+c2NyZWVuU2F2ZXJJbmhpYml0Q2FuY2VsbGFibGUg PSBhZG9wdEdSZWYoZ19jYW5jZWxsYWJsZV9uZXcoKSk7Ci0gICAgZ19kYnVzX3Byb3h5X25ld19m b3JfYnVzKEdfQlVTX1RZUEVfU0VTU0lPTiwgc3RhdGljX2Nhc3Q8R0RCdXNQcm94eUZsYWdzPihH X0RCVVNfUFJPWFlfRkxBR1NfRE9fTk9UX0xPQURfUFJPUEVSVElFUyB8IEdfREJVU19QUk9YWV9G TEFHU19ET19OT1RfQ09OTkVDVF9TSUdOQUxTKSwKLSAgICAgICAgbnVsbHB0ciwgIm9yZy5mcmVl ZGVza3RvcC5TY3JlZW5TYXZlciIsICIvU2NyZWVuU2F2ZXIiLCAib3JnLmZyZWVkZXNrdG9wLlNj cmVlblNhdmVyIiwgcHJpdi0+c2NyZWVuU2F2ZXJJbmhpYml0Q2FuY2VsbGFibGUuZ2V0KCksCi0g ICAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8R0FzeW5jUmVhZHlDYWxsYmFjaz4oc2NyZWVuU2F2ZXJQ cm94eUNyZWF0ZWRDYWxsYmFjayksIHdlYlZpZXdCYXNlKTsKLX0KLQotc3RhdGljIHZvaWQgd2Vi a2l0V2ViVmlld0Jhc2VVbmluaGliaXRTY3JlZW5TYXZlcihXZWJLaXRXZWJWaWV3QmFzZSogd2Vi Vmlld0Jhc2UpCi17Ci0gICAgV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlKiBwcml2ID0gd2ViVmll d0Jhc2UtPnByaXY7Ci0gICAgaWYgKCFwcml2LT5zY3JlZW5TYXZlckNvb2tpZSkgewotICAgICAg ICAvLyBOb3QgaW5oaWJpdGVkIG9yIGl0J3MgYmVpbmcgaW5oaWJpdGVkLgotICAgICAgICBnX2Nh bmNlbGxhYmxlX2NhbmNlbChwcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZS5nZXQo KSk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICAvLyBJZiB3ZSBoYXZlIGEgY29va2ll IHdlIHNob3VsZCBoYXZlIGEgcHJveHkuCi0gICAgQVNTRVJUKHByaXYtPnNjcmVlblNhdmVyUHJv eHkpOwotICAgIGdfZGJ1c19wcm94eV9jYWxsKHByaXYtPnNjcmVlblNhdmVyUHJveHkuZ2V0KCks ICJVbkluaGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIodSkiLCBwcml2LT5zY3JlZW5TYXZlckNvb2tp ZSksIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsIC0xLCBudWxscHRyLCBudWxscHRyLCBudWxscHRy KTsKLSAgICBwcml2LT5zY3JlZW5TYXZlckNvb2tpZSA9IDA7Ci19Ci0jZW5kaWYKLQogdm9pZCB3 ZWJraXRXZWJWaWV3QmFzZUVudGVyRnVsbFNjcmVlbihXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0 V2ViVmlld0Jhc2UpCiB7CiAjaWYgRU5BQkxFKEZVTExTQ1JFRU5fQVBJKQpAQCAtMTMxNCw3ICsx MjQzLDcgQEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUVudGVyRnVsbFNjcmVlbihXZWJLaXRXZWJW aWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiAgICAgICAgIGd0a193aW5kb3dfZnVsbHNjcmVl bihHVEtfV0lORE9XKHRvcExldmVsV2luZG93KSk7CiAgICAgZnVsbFNjcmVlbk1hbmFnZXJQcm94 eS0+ZGlkRW50ZXJGdWxsU2NyZWVuKCk7CiAgICAgcHJpdi0+ZnVsbFNjcmVlbk1vZGVBY3RpdmUg PSB0cnVlOwotICAgIHdlYmtpdFdlYlZpZXdCYXNlSW5oaWJpdFNjcmVlblNhdmVyKHdlYmtpdFdl YlZpZXdCYXNlKTsKKyAgICBwcml2LT5zbGVlcERpc2FibGVyID0gUEFMOjpTbGVlcERpc2FibGVy OjpjcmVhdGUoXygiV2Vic2l0ZSBydW5uaW5nIGluIGZ1bGxzY3JlZW4gbW9kZSIpLCBQQUw6OlNs ZWVwRGlzYWJsZXI6OlR5cGU6OkRpc3BsYXkpOwogI2VuZGlmCiB9CiAKQEAgLTEzMzIsNyArMTI2 MSw3IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VFeGl0RnVsbFNjcmVlbihXZWJLaXRXZWJWaWV3 QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiAgICAgICAgIGd0a193aW5kb3dfdW5mdWxsc2NyZWVu KEdUS19XSU5ET1codG9wTGV2ZWxXaW5kb3cpKTsKICAgICBmdWxsU2NyZWVuTWFuYWdlclByb3h5 LT5kaWRFeGl0RnVsbFNjcmVlbigpOwogICAgIHByaXYtPmZ1bGxTY3JlZW5Nb2RlQWN0aXZlID0g ZmFsc2U7Ci0gICAgd2Via2l0V2ViVmlld0Jhc2VVbmluaGliaXRTY3JlZW5TYXZlcih3ZWJraXRX ZWJWaWV3QmFzZSk7CisgICAgcHJpdi0+c2xlZXBEaXNhYmxlciA9IG51bGxwdHI7CiAjZW5kaWYK IH0KIAo= 328141 2017-12-01 13:08:59 -0800 2017-12-04 07:18:02 -0800 Patch bug-178485-20171201150858.patch text/plain 19235 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjI1NDA0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWE4ZjJiMmU3YTAyOTc0 MDllMmRjN2ZlYzZjMjhmNWUyM2I4ODljNS4uNjcwZmY1Nzc4N2Y5ODVkMWUxODg0OWE4MWE3ODQ4 MzAzNzMxYjA4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE3LTEyLTAxICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbV1BFXVtH VEtdIEltcGxlbWVudCBQQUw6OlNsZWVwRGlzYWJsZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3ODQ4NQorCisgICAgICAgIFJldmlld2VkIGJ5IENh cmxvcyBHYXJjaWEgQ2FtcG9zLgorCisgICAgICAgIEFkZCBhIGNvbW1lbnQgdG8gd2FybiBhYm91 dCBzb21lIG9kZCB1c2Ugb2YgU2xlZXBEaXNhYmxlciBpbiBIVE1MTWVkaWFFbGVtZW50LgorCisg ICAgICAgICogaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxNZWRpYUVsZW1lbnQ6OnNob3VsZERpc2FibGVTbGVlcCBjb25zdCk6CisKIDIwMTctMTItMDEg IEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBJbnRlcm5h bHMudGVybWluYXRlU2VydmljZVdvcmtlciwgYW5kIHRoZSBhYmlsaXR5IHRvIHJlc3RhcnQgc2Vy dmljZSB3b3JrZXJzIGZvciBwb3N0TWVzc2FnZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L1BBTC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvQ2hhbmdlTG9nCmluZGV4IDliMmIx MjMyMWJkNmY5Zjk4ZTZlZmU1N2ZmNDNiODE3ZjY5YjA1YjAuLmRmYTdlNWM0M2VkOTQ4NjkyZWFh YjUzOWJiZmQ4M2RkZjMzNmE5NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1BBTC9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvUEFML0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBA CisyMDE3LTEyLTAxICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4K KworICAgICAgICBbV1BFXVtHVEtdIEltcGxlbWVudCBQQUw6OlNsZWVwRGlzYWJsZXIKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3ODQ4NQorCisgICAg ICAgIFJldmlld2VkIGJ5IENhcmxvcyBHYXJjaWEgQ2FtcG9zLgorCisgICAgICAgICogcGFsL1Bs YXRmb3JtR1RLLmNtYWtlOgorICAgICAgICAqIHBhbC9QbGF0Zm9ybVdQRS5jbWFrZToKKyAgICAg ICAgKiBwYWwvc3lzdGVtL1NsZWVwRGlzYWJsZXIuY3BwOgorICAgICAgICAqIHBhbC9zeXN0ZW0v Z2xpYi9TbGVlcERpc2FibGVyR0xpYi5jcHA6IEFkZGVkLgorICAgICAgICAoUEFMOjpTbGVlcERp c2FibGVyOjpjcmVhdGUpOgorICAgICAgICAoUEFMOjpTbGVlcERpc2FibGVyR0xpYjo6U2xlZXBE aXNhYmxlckdMaWIpOgorICAgICAgICAoUEFMOjpTbGVlcERpc2FibGVyR0xpYjo6flNsZWVwRGlz YWJsZXJHTGliKToKKyAgICAgICAgKFBBTDo6U2xlZXBEaXNhYmxlckdMaWI6OmFjcXVpcmVJbmhp Yml0b3IpOgorICAgICAgICAoUEFMOjpTbGVlcERpc2FibGVyR0xpYjo6cmVsZWFzZUluaGliaXRv cik6CisgICAgICAgICogcGFsL3N5c3RlbS9nbGliL1NsZWVwRGlzYWJsZXJHTGliLmg6IEFkZGVk LgorCiAyMDE3LTExLTMwICBTdGVwaGFuIFN6YWJvICA8c3RlcGhhbi5zemFib0Bzb255LmNvbT4K IAogICAgICAgICBNYWtlIExlZ2FjeUN1c3RvbVByb3RvY29sTWFuYWdlciBvcHRpb25hbCBmb3Ig bmV0d29yayBwcm9jZXNzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDMwYjA5ZmRiM2NlMzkwOWExMjI4ZjgzMTY5OWY0 Y2UzZDI0Yzg1OGUuLjhkNmRjNDE0YTNjZTc0NDFkM2ExYTAxYjBhZTVkMTNmMDc3M2Q2YzEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjAgQEAKKzIwMTctMTItMDEgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0BpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIEltcGxlbWVudCBQQUw6OlNs ZWVwRGlzYWJsZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE3ODQ4NQorCisgICAgICAgIFJldmlld2VkIGJ5IENhcmxvcyBHYXJjaWEgQ2FtcG9zLgor CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwOgorICAg ICAgICAod2Via2l0V2ViVmlld0Jhc2VEaXNwb3NlKToKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdC YXNlRW50ZXJGdWxsU2NyZWVuKToKKyAgICAgICAgKHdlYmtpdFdlYlZpZXdCYXNlRXhpdEZ1bGxT Y3JlZW4pOgorICAgICAgICAoc2NyZWVuU2F2ZXJJbmhpYml0ZWRDYWxsYmFjayk6IERlbGV0ZWQu CisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZVNlbmRJbmhpYml0TWVzc2FnZVRvU2NyZWVuU2F2 ZXIpOiBEZWxldGVkLgorICAgICAgICAoc2NyZWVuU2F2ZXJQcm94eUNyZWF0ZWRDYWxsYmFjayk6 IERlbGV0ZWQuCisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZUluaGliaXRTY3JlZW5TYXZlcik6 IERlbGV0ZWQuCisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZVVuaW5oaWJpdFNjcmVlblNhdmVy KTogRGVsZXRlZC4KKwogMjAxNy0xMi0wMSAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5j b20+CiAKICAgICAgICAgQWRkIEludGVybmFscy50ZXJtaW5hdGVTZXJ2aWNlV29ya2VyLCBhbmQg dGhlIGFiaWxpdHkgdG8gcmVzdGFydCBzZXJ2aWNlIHdvcmtlcnMgZm9yIHBvc3RNZXNzYWdlLgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9QbGF0Zm9ybUdUSy5jbWFrZSBiL1Nv dXJjZS9XZWJDb3JlL1BBTC9wYWwvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggYjRhZDQ1Y2M3ZmI1 NTBlYzQ0N2U0ZDA4NTA3ODlkMWFkODc3NTFlNS4uZjExYTcyYzU5MzBjZTQ5ZGUzNzgyMDk5OWMz NDQyZWQ3ZTY1ZDA3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9QbGF0Zm9y bUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL1BsYXRmb3JtR1RLLmNtYWtl CkBAIC0zLDYgKzMsOCBAQCBsaXN0KEFQUEVORCBQQUxfU09VUkNFUwogCiAgICAgc3lzdGVtL0Ns b2NrR2VuZXJpYy5jcHAKIAorICAgIHN5c3RlbS9nbGliL1NsZWVwRGlzYWJsZXJHTGliLmNwcAor CiAgICAgc3lzdGVtL2d0ay9Tb3VuZEd0ay5jcHAKIAogICAgIHRleHQvS2lsbFJpbmcuY3BwCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL1BsYXRmb3JtV1BFLmNtYWtlIGIvU291 cmNlL1dlYkNvcmUvUEFML3BhbC9QbGF0Zm9ybVdQRS5jbWFrZQppbmRleCAyNWY2Njk0ZDk3MmNl YThlMWZjMzY2Y2ExNWE4NmNmNmJjMTkwOWZhLi4xN2MxM2UzNmFlZjQxNDAzODQyNjYxZThkOWVl NDJhZTc1ZDlhZDEwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL1BsYXRmb3Jt V1BFLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvUGxhdGZvcm1XUEUuY21ha2UK QEAgLTQsNiArNCw4IEBAIGxpc3QoQVBQRU5EIFBBTF9TT1VSQ0VTCiAgICAgc3lzdGVtL0Nsb2Nr R2VuZXJpYy5jcHAKICAgICBzeXN0ZW0vU291bmQuY3BwCiAKKyAgICBzeXN0ZW0vZ2xpYi9TbGVl cERpc2FibGVyR0xpYi5jcHAKKwogICAgIHRleHQvS2lsbFJpbmcuY3BwCiAKICAgICB1bml4L0xv Z2dpbmdVbml4LmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvUEFML3BhbC9zeXN0ZW0v U2xlZXBEaXNhYmxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9TbGVlcERp c2FibGVyLmNwcAppbmRleCAxMDE4OGVlZGZmNDE3YjJlNjIxYTgwMWRkZDUyNmNiNTY2NmY3NGY1 Li40NmRiNThmNTY0MDJlYTgyNzgyNjQxMWU5M2Q5MzBlZjhmZWViNDRiIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9TbGVlcERpc2FibGVyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9TbGVlcERpc2FibGVyLmNwcApAQCAtMjgsMTIgKzI4 LDEyIEBACiAKIG5hbWVzcGFjZSBQQUwgewogCi0jaWYgIVBMQVRGT1JNKENPQ09BKQorI2lmICFQ TEFURk9STShDT0NPQSkgJiYgIVVTRShHTElCKQogc3RkOjp1bmlxdWVfcHRyPFNsZWVwRGlzYWJs ZXI+IFNsZWVwRGlzYWJsZXI6OmNyZWF0ZShjb25zdCBjaGFyKiByZWFzb24sIFR5cGUgdHlwZSkK IHsKICAgICByZXR1cm4gc3RkOjp1bmlxdWVfcHRyPFNsZWVwRGlzYWJsZXI+KG5ldyBTbGVlcERp c2FibGVyKHJlYXNvbiwgdHlwZSkpOwogfQotI2VuZGlmIC8vICFQTEFURk9STShDT0NPQSkKKyNl bmRpZiAvLyAhUExBVEZPUk0oQ09DT0EpICYmICFVU0UoR0xJQikKIAogU2xlZXBEaXNhYmxlcjo6 U2xlZXBEaXNhYmxlcihjb25zdCBjaGFyKiwgVHlwZSB0eXBlKQogICAgIDogbV90eXBlKHR5cGUp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5c3RlbS9nbGliL1NsZWVwRGlz YWJsZXJHTGliLmNwcCBiL1NvdXJjZS9XZWJDb3JlL1BBTC9wYWwvc3lzdGVtL2dsaWIvU2xlZXBE aXNhYmxlckdMaWIuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNmNDBhZDM3Y2EwZjliNmEwZTMwN2M3NDkwMTRm MTU3MjJmYmIzY2UKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5 c3RlbS9nbGliL1NsZWVwRGlzYWJsZXJHTGliLmNwcApAQCAtMCwwICsxLDEyMCBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxNyBJZ2FsaWEgUy5MLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFT IElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVU T1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT CisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YK KyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiU2xlZXBEaXNhYmxlckdMaWIuaCIKKworI2luY2x1ZGUgPGdpby9n aW8uaD4KKyNpbmNsdWRlIDx3dGYvZ2xpYi9HVW5pcXVlUHRyLmg+CisKK25hbWVzcGFjZSBQQUwg eworCitzdGQ6OnVuaXF1ZV9wdHI8U2xlZXBEaXNhYmxlcj4gU2xlZXBEaXNhYmxlcjo6Y3JlYXRl KGNvbnN0IGNoYXIqIHJlYXNvbiwgVHlwZSB0eXBlKQoreworICAgIHJldHVybiBzdGQ6OnVuaXF1 ZV9wdHI8U2xlZXBEaXNhYmxlcj4obmV3IFNsZWVwRGlzYWJsZXJHTGliKHJlYXNvbiwgdHlwZSkp OworfQorCitTbGVlcERpc2FibGVyR0xpYjo6U2xlZXBEaXNhYmxlckdMaWIoY29uc3QgY2hhciog cmVhc29uLCBUeXBlIHR5cGUpCisgICAgOiBTbGVlcERpc2FibGVyKHJlYXNvbiwgdHlwZSkKKyAg ICAsIG1fY2FuY2VsbGFibGUoYWRvcHRHUmVmKGdfY2FuY2VsbGFibGVfbmV3KCkpKQorICAgICwg bV9yZWFzb24ocmVhc29uKQoreworICAgIC8vIFdlIGRvbid0IHN1cHBvcnQgc3VzcGVuZCAoIlN5 c3RlbSIpIGluaGliaXRvcnMsIG9ubHkgaWRsZSBpbmhpYml0b3JzLgorICAgIC8vIFRvIGdldCBz dXNwZW5kIGluaGliaXRvcnMsIHdlJ2QgbmVlZCB0byB1c2UgdGhlIGZhbmN5IEdOT01FCisgICAg Ly8gU2Vzc2lvbk1hbmFnZXIgQVBJLCB3aGljaCByZXF1aXJlcyByZWdpc3RlcmluZyBhcyBhIGNs aWVudCBhcHBsaWNhdGlvbiwKKyAgICAvLyB3aGljaCBpcyBub3QgcHJhY3RpY2FsIGZyb20gdGhl IHdlYiBwcm9jZXNzLiBTZWNvbmRseSwgYmVjYXVzZSB0aGUgb25seQorICAgIC8vIGN1cnJlbnQg dXNlIG9mIGEgc3VzcGVuZCBpbmhpYml0b3IgaW4gV2ViS2l0LAorICAgIC8vIEhUTUxNZWRpYUVs ZW1lbnQ6OnNob3VsZERpc2FibGVTbGVlcCwgaXMgc3VzcGljaW91cy4gVGhlcmUncyByZWFsbHkg bm8KKyAgICAvLyB2YWxpZCByZWFzb24gZm9yIFdlYktpdCB0byBldmVyIGJsb2NrIHN1c3BlbmQs IG9ubHkgaWRsZS4KKyAgICBpZiAodHlwZSAhPSBTbGVlcERpc2FibGVyOjpUeXBlOjpEaXNwbGF5 KQorICAgICAgICByZXR1cm47CisKKyAgICBnX2RidXNfcHJveHlfbmV3X2Zvcl9idXMoR19CVVNf VFlQRV9TRVNTSU9OLCBzdGF0aWNfY2FzdDxHREJ1c1Byb3h5RmxhZ3M+KEdfREJVU19QUk9YWV9G TEFHU19ET19OT1RfTE9BRF9QUk9QRVJUSUVTIHwgR19EQlVTX1BST1hZX0ZMQUdTX0RPX05PVF9D T05ORUNUX1NJR05BTFMpLAorICAgICAgICBudWxscHRyLCAib3JnLmZyZWVkZXNrdG9wLlNjcmVl blNhdmVyIiwgIi9vcmcvZnJlZWRlc2t0b3AvU2NyZWVuU2F2ZXIiLCAib3JnLmZyZWVkZXNrdG9w LlNjcmVlblNhdmVyIiwgbV9jYW5jZWxsYWJsZS5nZXQoKSwKKyAgICAgICAgW10oR09iamVjdCos IEdBc3luY1Jlc3VsdCogcmVzdWx0LCBncG9pbnRlciB1c2VyRGF0YSkgeworICAgICAgICAgICAg R1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOworICAgICAgICAgICAgR1JlZlB0cjxHREJ1c1By b3h5PiBwcm94eSA9IGFkb3B0R1JlZihnX2RidXNfcHJveHlfbmV3X2Zvcl9idXNfZmluaXNoKHJl c3VsdCwgJmVycm9yLm91dFB0cigpKSk7CisgICAgICAgICAgICBpZiAoZ19lcnJvcl9tYXRjaGVz KGVycm9yLmdldCgpLCBHX0lPX0VSUk9SLCBHX0lPX0VSUk9SX0NBTkNFTExFRCkpCisgICAgICAg ICAgICAgICAgcmV0dXJuOworCisgICAgICAgICAgICBhdXRvKiBzZWxmID0gc3RhdGljX2Nhc3Q8 U2xlZXBEaXNhYmxlckdMaWIqPih1c2VyRGF0YSk7CisgICAgICAgICAgICBpZiAocHJveHkpIHsK KyAgICAgICAgICAgICAgICBHVW5pcXVlUHRyPGNoYXI+IG5hbWVPd25lcihnX2RidXNfcHJveHlf Z2V0X25hbWVfb3duZXIocHJveHkuZ2V0KCkpKTsKKyAgICAgICAgICAgICAgICBpZiAobmFtZU93 bmVyKSB7CisgICAgICAgICAgICAgICAgICAgIHNlbGYtPm1fc2NyZWVuU2F2ZXJQcm94eSA9IHBy b3h5OworICAgICAgICAgICAgICAgICAgICBzZWxmLT5hY3F1aXJlSW5oaWJpdG9yKCk7CisgICAg ICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9 CisKKyAgICAgICAgICAgIC8vIEdpdmUgdXAuIERvbid0IHdhcm4gdGhlIHVzZXI6IHRoaXMgaXMg ZXhwZWN0ZWQuCisgICAgICAgICAgICBzZWxmLT5tX2NhbmNlbGxhYmxlID0gbnVsbHB0cjsKKyAg ICAgICAgfSwgdGhpcyk7Cit9CisKK1NsZWVwRGlzYWJsZXJHTGliOjp+U2xlZXBEaXNhYmxlckdM aWIoKQoreworICAgIGlmIChtX2NhbmNlbGxhYmxlKQorICAgICAgICBnX2NhbmNlbGxhYmxlX2Nh bmNlbChtX2NhbmNlbGxhYmxlLmdldCgpKTsKKyAgICBlbHNlIGlmIChtX3NjcmVlblNhdmVyQ29v a2llKQorICAgICAgICByZWxlYXNlSW5oaWJpdG9yKCk7Cit9CisKK3ZvaWQgU2xlZXBEaXNhYmxl ckdMaWI6OmFjcXVpcmVJbmhpYml0b3IoKQoreworICAgIEFTU0VSVChtX3NjcmVlblNhdmVyUHJv eHkpOworICAgIGdfZGJ1c19wcm94eV9jYWxsKG1fc2NyZWVuU2F2ZXJQcm94eS5nZXQoKSwgIklu aGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIoc3MpIiwgZ19nZXRfcHJnbmFtZSgpLCBtX3JlYXNvbi5k YXRhKCkpLAorICAgICAgICBHX0RCVVNfQ0FMTF9GTEFHU19OT05FLCAtMSwgbV9jYW5jZWxsYWJs ZS5nZXQoKSwgW10oR09iamVjdCogcHJveHksIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBncG9pbnRl ciB1c2VyRGF0YSkgeworICAgICAgICAgICAgR1VuaXF1ZU91dFB0cjxHRXJyb3I+IGVycm9yOwor ICAgICAgICAgICAgR1JlZlB0cjxHVmFyaWFudD4gcmV0dXJuVmFsdWUgPSBhZG9wdEdSZWYoZ19k YnVzX3Byb3h5X2NhbGxfZmluaXNoKEdfREJVU19QUk9YWShwcm94eSksIHJlc3VsdCwgJmVycm9y Lm91dFB0cigpKSk7CisgICAgICAgICAgICBpZiAoZ19lcnJvcl9tYXRjaGVzKGVycm9yLmdldCgp LCBHX0lPX0VSUk9SLCBHX0lPX0VSUk9SX0NBTkNFTExFRCkpCisgICAgICAgICAgICAgICAgcmV0 dXJuOworCisgICAgICAgICAgICBhdXRvKiBzZWxmID0gc3RhdGljX2Nhc3Q8U2xlZXBEaXNhYmxl ckdMaWIqPih1c2VyRGF0YSk7CisgICAgICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICAg ICAgZ193YXJuaW5nKCJDYWxsaW5nICVzLkluaGliaXQgZmFpbGVkOiAlcyIsIGdfZGJ1c19wcm94 eV9nZXRfaW50ZXJmYWNlX25hbWUoc2VsZi0+bV9zY3JlZW5TYXZlclByb3h5LmdldCgpKSwgZXJy b3ItPm1lc3NhZ2UpOworICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgQVNTRVJU KHJldHVyblZhbHVlKTsKKyAgICAgICAgICAgICAgICBnX3ZhcmlhbnRfZ2V0KHJldHVyblZhbHVl LmdldCgpLCAiKHUpIiwgJnNlbGYtPm1fc2NyZWVuU2F2ZXJDb29raWUpOworICAgICAgICAgICAg fQorICAgICAgICAgICAgc2VsZi0+bV9jYW5jZWxsYWJsZSA9IG51bGxwdHI7CisgICAgICAgIH0s IHRoaXMpOworfQorCit2b2lkIFNsZWVwRGlzYWJsZXJHTGliOjpyZWxlYXNlSW5oaWJpdG9yKCkK K3sKKyAgICBBU1NFUlQobV9zY3JlZW5TYXZlckNvb2tpZSk7CisgICAgQVNTRVJUKG1fc2NyZWVu U2F2ZXJQcm94eSk7CisKKyAgICBnX2RidXNfcHJveHlfY2FsbChtX3NjcmVlblNhdmVyUHJveHku Z2V0KCksICJVbkluaGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIodSkiLCBtX3NjcmVlblNhdmVyQ29v a2llKSwKKyAgICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwgLTEsIG51bGxwdHIsIFtdKEdP YmplY3QqIHByb3h5LCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgZ3BvaW50ZXIpIHsKKyAgICAgICAg ICAgIEdVbmlxdWVPdXRQdHI8R0Vycm9yPiBlcnJvcjsKKyAgICAgICAgICAgIEdSZWZQdHI8R1Zh cmlhbnQ+IHJldHVyblZhbHVlID0gYWRvcHRHUmVmKGdfZGJ1c19wcm94eV9jYWxsX2ZpbmlzaChH X0RCVVNfUFJPWFkocHJveHkpLCByZXN1bHQsICZlcnJvci5vdXRQdHIoKSkpOworICAgICAgICAg ICAgaWYgKGVycm9yKQorICAgICAgICAgICAgICAgIGdfd2FybmluZygiQ2FsbGluZyAlcy5Vbklu aGliaXQgZmFpbGVkOiAlcyIsIGdfZGJ1c19wcm94eV9nZXRfaW50ZXJmYWNlX25hbWUoR19EQlVT X1BST1hZKHByb3h5KSksIGVycm9yLT5tZXNzYWdlKTsKKyAgICB9LCBudWxscHRyKTsKK30KKwor fSAvLyBuYW1lc3BhY2UgUEFMCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5 c3RlbS9nbGliL1NsZWVwRGlzYWJsZXJHTGliLmggYi9Tb3VyY2UvV2ViQ29yZS9QQUwvcGFsL3N5 c3RlbS9nbGliL1NsZWVwRGlzYWJsZXJHTGliLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYThlMDU0YWM4ODhjYTIw MTFlZDA0ODlmN2Y3MDRlYmI3NDI2MTkwOQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJD b3JlL1BBTC9wYWwvc3lzdGVtL2dsaWIvU2xlZXBEaXNhYmxlckdMaWIuaApAQCAtMCwwICsxLDUz IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE3IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNw cmFnbWEgb25jZQorCisjaW5jbHVkZSAiU2xlZXBEaXNhYmxlci5oIgorCisjaW5jbHVkZSA8d3Rm L2dsaWIvR1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKwordHlwZWRl ZiBzdHJ1Y3QgX0dEQnVzUHJveHkgR0RCdXNQcm94eTsKKworbmFtZXNwYWNlIFBBTCB7CisKK2Ns YXNzIFNsZWVwRGlzYWJsZXJHTGliIDogcHVibGljIFNsZWVwRGlzYWJsZXIgeworcHVibGljOgor ICAgIFNsZWVwRGlzYWJsZXJHTGliKGNvbnN0IGNoYXIqLCBUeXBlKTsKKyAgICB2aXJ0dWFsIH5T bGVlcERpc2FibGVyR0xpYigpOworCitwcml2YXRlOgorICAgIHZvaWQgYWNxdWlyZUluaGliaXRv cigpOworICAgIHZvaWQgcmVsZWFzZUluaGliaXRvcigpOworCisgICAgR1JlZlB0cjxHREJ1c1By b3h5PiBtX3NjcmVlblNhdmVyUHJveHk7CisgICAgdW5zaWduZWQgbV9zY3JlZW5TYXZlckNvb2tp ZSB7IDAgfTsKKworICAgIEdSZWZQdHI8R0NhbmNlbGxhYmxlPiBtX2NhbmNlbGxhYmxlOworICAg IENTdHJpbmcgbV9yZWFzb247Cit9OworCit9IC8vIG5hbWVzcGFjZSBQQUwKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCmluZGV4IDA0ZjlkYTk2YzViODMwM2U3MTJiNTg0 NzA3ZDg3MTZjZGY0MGY5MzEuLmRiZDBhMGIxMzUyY2ZiZjhhOTZlMzM1NmFiYWU4NTg1ZjVkYWE3 YWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcApAQCAtNjYwNyw2 ICs2NjA3LDcgQEAgdm9pZCBIVE1MTWVkaWFFbGVtZW50Ojp1cGRhdGVTbGVlcERpc2FibGluZygp CiAKIEhUTUxNZWRpYUVsZW1lbnQ6OlNsZWVwVHlwZSBIVE1MTWVkaWFFbGVtZW50OjpzaG91bGRE aXNhYmxlU2xlZXAoKSBjb25zdAogeworICAgIC8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTgwMTk3IGJlZm9yZSByZW1vdmluZyB0aGlzIGd1YXJkLgogI2lm ICFQTEFURk9STShDT0NPQSkKICAgICByZXR1cm4gU2xlZXBUeXBlOjpOb25lOwogI2VuZGlmCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdC YXNlLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jh c2UuY3BwCmluZGV4IGQyN2FiNDAxMzBhOTVjNTg4Y2ZkNmY1MWMyMTllYjgxZmI3M2ZkYmEuLmNh NmNhODllNjFjN2I4MzRmMzE5MDIzMmI3NDJmNGU4MGQ5YWRlNmIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwCkBAIC02 Myw2ICs2Myw3IEBACiAjaW5jbHVkZSA8Z2RrL2dka2tleXN5bXMuaD4KICNpbmNsdWRlIDxnbGli L2dpMThuLWxpYi5oPgogI2luY2x1ZGUgPG1lbW9yeT4KKyNpbmNsdWRlIDxwYWwvc3lzdGVtL1Ns ZWVwRGlzYWJsZXIuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9n bGliL0dSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvZ2xpYi9XVEZHVHlwZS5oPgpAQCAtMTkwLDkg KzE5MSw3IEBAIHN0cnVjdCBfV2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlIHsKIAogI2lmIEVOQUJM RShGVUxMU0NSRUVOX0FQSSkKICAgICBib29sIGZ1bGxTY3JlZW5Nb2RlQWN0aXZlIHsgZmFsc2Ug fTsKLSAgICBHUmVmUHRyPEdEQnVzUHJveHk+IHNjcmVlblNhdmVyUHJveHk7Ci0gICAgR1JlZlB0 cjxHQ2FuY2VsbGFibGU+IHNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlOwotICAgIHVuc2ln bmVkIHNjcmVlblNhdmVyQ29va2llIHsgMCB9OworICAgIHN0ZDo6dW5pcXVlX3B0cjxQQUw6OlNs ZWVwRGlzYWJsZXI+IHNsZWVwRGlzYWJsZXI7CiAjZW5kaWYKIAogICAgIHN0ZDo6dW5pcXVlX3B0 cjxBY2NlbGVyYXRlZEJhY2tpbmdTdG9yZT4gYWNjZWxlcmF0ZWRCYWNraW5nU3RvcmU7CkBAIC01 MDAsMTAgKzQ5OSwxMCBAQCB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlQ2hpbGRNb3ZlUmVzaXplKFdl YktpdFdlYlZpZXdCYXNlKiB3ZWJWaWV3LCBHdGtXaWRnZXQqIGNoaQogc3RhdGljIHZvaWQgd2Vi a2l0V2ViVmlld0Jhc2VEaXNwb3NlKEdPYmplY3QqIGdvYmplY3QpCiB7CiAgICAgV2ViS2l0V2Vi Vmlld0Jhc2UqIHdlYlZpZXcgPSBXRUJLSVRfV0VCX1ZJRVdfQkFTRShnb2JqZWN0KTsKLSAgICBn X2NhbmNlbGxhYmxlX2NhbmNlbCh3ZWJWaWV3LT5wcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5j ZWxsYWJsZS5nZXQoKSk7CiAgICAgd2Via2l0V2ViVmlld0Jhc2VTZXRUb3BsZXZlbE9uU2NyZWVu V2luZG93KHdlYlZpZXcsIG51bGxwdHIpOwogICAgIHdlYlZpZXctPnByaXYtPnBhZ2VQcm94eS0+ Y2xvc2UoKTsKICAgICB3ZWJWaWV3LT5wcml2LT5hY2NlbGVyYXRlZEJhY2tpbmdTdG9yZSA9IG51 bGxwdHI7CisgICAgd2ViVmlldy0+cHJpdi0+c2xlZXBEaXNhYmxlciA9IG51bGxwdHI7CiAgICAg R19PQkpFQ1RfQ0xBU1Mod2Via2l0X3dlYl92aWV3X2Jhc2VfcGFyZW50X2NsYXNzKS0+ZGlzcG9z ZShnb2JqZWN0KTsKIH0KIApAQCAtMTIzMSw3NSArMTIzMCw2IEBAIHZvaWQgd2Via2l0V2ViVmll d0Jhc2VGb3J3YXJkTmV4dFdoZWVsRXZlbnQoV2ViS2l0V2ViVmlld0Jhc2UqIHdlYmtpdFdlYlZp ZXdCYXNlCiAgICAgd2Via2l0V2ViVmlld0Jhc2UtPnByaXYtPnNob3VsZEZvcndhcmROZXh0V2hl ZWxFdmVudCA9IHRydWU7CiB9CiAKLSNpZiBFTkFCTEUoRlVMTFNDUkVFTl9BUEkpCi1zdGF0aWMg dm9pZCBzY3JlZW5TYXZlckluaGliaXRlZENhbGxiYWNrKEdEQnVzUHJveHkqIHNjcmVlblNhdmVy UHJveHksIEdBc3luY1Jlc3VsdCogcmVzdWx0LCBXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jh c2UpCi17Ci0gICAgR1JlZlB0cjxHVmFyaWFudD4gcmV0dXJuVmFsdWUgPSBhZG9wdEdSZWYoZ19k YnVzX3Byb3h5X2NhbGxfZmluaXNoKHNjcmVlblNhdmVyUHJveHksIHJlc3VsdCwgbnVsbHB0cikp OwotICAgIGlmIChyZXR1cm5WYWx1ZSkKLSAgICAgICAgZ192YXJpYW50X2dldChyZXR1cm5WYWx1 ZS5nZXQoKSwgIih1KSIsICZ3ZWJWaWV3QmFzZS0+cHJpdi0+c2NyZWVuU2F2ZXJDb29raWUpOwot ICAgIHdlYlZpZXdCYXNlLT5wcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZSA9IG51 bGxwdHI7Ci19Ci0KLXN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlU2VuZEluaGliaXRNZXNz YWdlVG9TY3JlZW5TYXZlcihXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UpCi17Ci0gICAg V2ViS2l0V2ViVmlld0Jhc2VQcml2YXRlKiBwcml2ID0gd2ViVmlld0Jhc2UtPnByaXY7Ci0gICAg QVNTRVJUKHByaXYtPnNjcmVlblNhdmVyUHJveHkpOwotICAgIHByaXYtPnNjcmVlblNhdmVyQ29v a2llID0gMDsKLSAgICBpZiAoIXByaXYtPnNjcmVlblNhdmVySW5oaWJpdENhbmNlbGxhYmxlKQot ICAgICAgICBwcml2LT5zY3JlZW5TYXZlckluaGliaXRDYW5jZWxsYWJsZSA9IGFkb3B0R1JlZihn X2NhbmNlbGxhYmxlX25ldygpKTsKLSAgICBnX2RidXNfcHJveHlfY2FsbChwcml2LT5zY3JlZW5T YXZlclByb3h5LmdldCgpLCAiSW5oaWJpdCIsIGdfdmFyaWFudF9uZXcoIihzcykiLCBnX2dldF9w cmduYW1lKCksIF8oIldlYnNpdGUgcnVubmluZyBpbiBmdWxsc2NyZWVuIG1vZGUiKSksCi0gICAg ICAgIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsIC0xLCBwcml2LT5zY3JlZW5TYXZlckluaGliaXRD YW5jZWxsYWJsZS5nZXQoKSwgcmVpbnRlcnByZXRfY2FzdDxHQXN5bmNSZWFkeUNhbGxiYWNrPihz Y3JlZW5TYXZlckluaGliaXRlZENhbGxiYWNrKSwgd2ViVmlld0Jhc2UpOwotfQotCi1zdGF0aWMg dm9pZCBzY3JlZW5TYXZlclByb3h5Q3JlYXRlZENhbGxiYWNrKEdPYmplY3QqLCBHQXN5bmNSZXN1 bHQqIHJlc3VsdCwgV2ViS2l0V2ViVmlld0Jhc2UqIHdlYlZpZXdCYXNlKQotewotICAgIC8vIFdl YktpdFdlYlZpZXdCYXNlIGNhbmNlbHMgdGhlIHByb3h5IGNyZWF0aW9uIG9uIGRpc3Bvc2UsIHdo aWNoIG1lYW5zIHRoaXMgY291bGQgYmUgY2FsbGVkCi0gICAgLy8gYWZ0ZXIgdGhlIHdlYiB2aWV3 IGhhcyBiZWVuIGRlc3Ryb3llZCBhbmQgZ19kYnVzX3Byb3h5X25ld19mb3JfYnVzX2ZpbmlzaCB3 aWxsIHJldHVybiBudWxscHRyLgotICAgIC8vIFNvLCBtYWtlIHN1cmUgd2UgZG9uJ3QgdXNlIHRo ZSB3ZWIgdmlldyB1bmxlc3Mgd2UgaGF2ZSBhIHZhbGlkIHByb3h5LgotICAgIC8vIFNlZSBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUxNjUzLgotICAgIEdSZWZQdHI8 R0RCdXNQcm94eT4gcHJveHkgPSBhZG9wdEdSZWYoZ19kYnVzX3Byb3h5X25ld19mb3JfYnVzX2Zp bmlzaChyZXN1bHQsIG51bGxwdHIpKTsKLSAgICBpZiAoIXByb3h5KQotICAgICAgICByZXR1cm47 Ci0KLSAgICB3ZWJWaWV3QmFzZS0+cHJpdi0+c2NyZWVuU2F2ZXJQcm94eSA9IHByb3h5OwotICAg IHdlYmtpdFdlYlZpZXdCYXNlU2VuZEluaGliaXRNZXNzYWdlVG9TY3JlZW5TYXZlcih3ZWJWaWV3 QmFzZSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdCYXNlSW5oaWJpdFNjcmVlblNh dmVyKFdlYktpdFdlYlZpZXdCYXNlKiB3ZWJWaWV3QmFzZSkKLXsKLSAgICBXZWJLaXRXZWJWaWV3 QmFzZVByaXZhdGUqIHByaXYgPSB3ZWJWaWV3QmFzZS0+cHJpdjsKLSAgICBpZiAocHJpdi0+c2Ny ZWVuU2F2ZXJDb29raWUpIHsKLSAgICAgICAgLy8gQWxyZWFkeSBpbmhpYml0ZWQuCi0gICAgICAg IHJldHVybjsKLSAgICB9Ci0KLSAgICBpZiAocHJpdi0+c2NyZWVuU2F2ZXJQcm94eSkgewotICAg ICAgICB3ZWJraXRXZWJWaWV3QmFzZVNlbmRJbmhpYml0TWVzc2FnZVRvU2NyZWVuU2F2ZXIod2Vi Vmlld0Jhc2UpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotCi0gICAgcHJpdi0+c2NyZWVuU2F2 ZXJJbmhpYml0Q2FuY2VsbGFibGUgPSBhZG9wdEdSZWYoZ19jYW5jZWxsYWJsZV9uZXcoKSk7Ci0g ICAgZ19kYnVzX3Byb3h5X25ld19mb3JfYnVzKEdfQlVTX1RZUEVfU0VTU0lPTiwgc3RhdGljX2Nh c3Q8R0RCdXNQcm94eUZsYWdzPihHX0RCVVNfUFJPWFlfRkxBR1NfRE9fTk9UX0xPQURfUFJPUEVS VElFUyB8IEdfREJVU19QUk9YWV9GTEFHU19ET19OT1RfQ09OTkVDVF9TSUdOQUxTKSwKLSAgICAg ICAgbnVsbHB0ciwgIm9yZy5mcmVlZGVza3RvcC5TY3JlZW5TYXZlciIsICIvU2NyZWVuU2F2ZXIi LCAib3JnLmZyZWVkZXNrdG9wLlNjcmVlblNhdmVyIiwgcHJpdi0+c2NyZWVuU2F2ZXJJbmhpYml0 Q2FuY2VsbGFibGUuZ2V0KCksCi0gICAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8R0FzeW5jUmVhZHlD YWxsYmFjaz4oc2NyZWVuU2F2ZXJQcm94eUNyZWF0ZWRDYWxsYmFjayksIHdlYlZpZXdCYXNlKTsK LX0KLQotc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VVbmluaGliaXRTY3JlZW5TYXZlcihX ZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UpCi17Ci0gICAgV2ViS2l0V2ViVmlld0Jhc2VQ cml2YXRlKiBwcml2ID0gd2ViVmlld0Jhc2UtPnByaXY7Ci0gICAgaWYgKCFwcml2LT5zY3JlZW5T YXZlckNvb2tpZSkgewotICAgICAgICAvLyBOb3QgaW5oaWJpdGVkIG9yIGl0J3MgYmVpbmcgaW5o aWJpdGVkLgotICAgICAgICBnX2NhbmNlbGxhYmxlX2NhbmNlbChwcml2LT5zY3JlZW5TYXZlcklu aGliaXRDYW5jZWxsYWJsZS5nZXQoKSk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICAv LyBJZiB3ZSBoYXZlIGEgY29va2llIHdlIHNob3VsZCBoYXZlIGEgcHJveHkuCi0gICAgQVNTRVJU KHByaXYtPnNjcmVlblNhdmVyUHJveHkpOwotICAgIGdfZGJ1c19wcm94eV9jYWxsKHByaXYtPnNj cmVlblNhdmVyUHJveHkuZ2V0KCksICJVbkluaGliaXQiLCBnX3ZhcmlhbnRfbmV3KCIodSkiLCBw cml2LT5zY3JlZW5TYXZlckNvb2tpZSksIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsIC0xLCBudWxs cHRyLCBudWxscHRyLCBudWxscHRyKTsKLSAgICBwcml2LT5zY3JlZW5TYXZlckNvb2tpZSA9IDA7 Ci19Ci0jZW5kaWYKLQogdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUVudGVyRnVsbFNjcmVlbihXZWJL aXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiB7CiAjaWYgRU5BQkxFKEZVTExTQ1JF RU5fQVBJKQpAQCAtMTMxNCw3ICsxMjQ0LDcgQEAgdm9pZCB3ZWJraXRXZWJWaWV3QmFzZUVudGVy RnVsbFNjcmVlbihXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiAgICAgICAg IGd0a193aW5kb3dfZnVsbHNjcmVlbihHVEtfV0lORE9XKHRvcExldmVsV2luZG93KSk7CiAgICAg ZnVsbFNjcmVlbk1hbmFnZXJQcm94eS0+ZGlkRW50ZXJGdWxsU2NyZWVuKCk7CiAgICAgcHJpdi0+ ZnVsbFNjcmVlbk1vZGVBY3RpdmUgPSB0cnVlOwotICAgIHdlYmtpdFdlYlZpZXdCYXNlSW5oaWJp dFNjcmVlblNhdmVyKHdlYmtpdFdlYlZpZXdCYXNlKTsKKyAgICBwcml2LT5zbGVlcERpc2FibGVy ID0gUEFMOjpTbGVlcERpc2FibGVyOjpjcmVhdGUoXygiV2Vic2l0ZSBydW5uaW5nIGluIGZ1bGxz Y3JlZW4gbW9kZSIpLCBQQUw6OlNsZWVwRGlzYWJsZXI6OlR5cGU6OkRpc3BsYXkpOwogI2VuZGlm CiB9CiAKQEAgLTEzMzIsNyArMTI2Miw3IEBAIHZvaWQgd2Via2l0V2ViVmlld0Jhc2VFeGl0RnVs bFNjcmVlbihXZWJLaXRXZWJWaWV3QmFzZSogd2Via2l0V2ViVmlld0Jhc2UpCiAgICAgICAgIGd0 a193aW5kb3dfdW5mdWxsc2NyZWVuKEdUS19XSU5ET1codG9wTGV2ZWxXaW5kb3cpKTsKICAgICBm dWxsU2NyZWVuTWFuYWdlclByb3h5LT5kaWRFeGl0RnVsbFNjcmVlbigpOwogICAgIHByaXYtPmZ1 bGxTY3JlZW5Nb2RlQWN0aXZlID0gZmFsc2U7Ci0gICAgd2Via2l0V2ViVmlld0Jhc2VVbmluaGli aXRTY3JlZW5TYXZlcih3ZWJraXRXZWJWaWV3QmFzZSk7CisgICAgcHJpdi0+c2xlZXBEaXNhYmxl ciA9IG51bGxwdHI7CiAjZW5kaWYKIH0KIAo=