125990 2013-12-19 03:03:37 -0800 [GTK] Allow passing extra initialization data to web extensions 2014-01-21 06:53:27 -0800 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 127246 1 aperez webkit-unassigned bunhere cdumez cgarcia commit-queue gustavo gyuyoung.kim ltilve+ews mrobinson ossy pnormand rakuco xan.lopez zan oldest_to_newest 961331 0 aperez 2013-12-19 03:03:37 -0800 Right now in the GTK port the injected bundles get only the path to the directory where to search for web extensions, but there is no way of passing data to the web extensions from the UI process. This leads to a situation where the UI process has to set environment variables to pass some configurations to the web process. Ideally, the WebKitGTK port should provide API to set which data is to be passed to the web extensions, pass it along with the web extensions directory when injected bundle initialization is done, and provide an API for web extensions to retrieve the data. 961332 1 219636 aperez 2013-12-19 03:10:59 -0800 Created attachment 219636 Patch 961333 2 commit-queue 2013-12-19 03:12:53 -0800 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 961344 3 219636 cgarcia 2013-12-19 04:36:16 -0800 Comment on attachment 219636 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=219636&action=review Thanks for the patch, it looks great and I'm looking forward to removing the env variables hack we currently have in ephy. One of the problems we have with our API is that it's not that easy to know when it's a good moment to call methods like webkit_web_context_set_web_extensions_directory(), and it has caused problems already. We encourage to call it asap, but if we had a signal emitted everytime a new web process is going to be launched, we would have a perfect place for the user to place those calls. So instead of a specific signal to initialize the web extensions user data, we could add a method webkit_web_context_set_web_extensions_user_data() and a generic signal to notify when a new web process is about to be launched, that could also be used to call other methods that affect the new web process. The only think I don't like about this approach is that we would be using a injected bundle client callback as a generic signal for new web processes launched, only because there's no other client callback in WebContext::createNewWebProcess(). The other method that needs to be called before the web process is started is the onse setting the disk cache directory, so this won't be required once we have the network process. So, I think we could limit the signal to the web extensions in the end, but instead of returning a GVariant, both set_extensions_dir and set_extensions_user_data is expected to be called there. What do you think? > Source/WebKit2/ChangeLog:4 > + Move the bug URL here , please. That's how all other commits are formatted. > Source/WebKit2/ChangeLog:10 > + Allow passing additional information to the injected bundle. On top of the > + string containing the path to the web extensions directory, a GVariant can > + be returned by a callback connected to the web-extensions-loaded signal. > + The GVariant is serialized, passed to the injected bundle, and the > + injected bundle deserializes back the data, which can then be retrieved > + using the webkit_web_extension_get_extra_data() method. And the description after the Reviewed by line. > Source/WebKit2/UIProcess/API/gtk/WebKitInjectedBundleClient.cpp:125 > + GVariant* extraData = webkitWebContextWebExtensionsLoaded(WEBKIT_WEB_CONTEXT(clientInfo)); > + if (extraData) > + g_variant_ref_sink(extraData); You can use GRefPtr here. > Source/WebKit2/UIProcess/API/gtk/WebKitInjectedBundleClient.cpp:128 > + GVariant* data = g_variant_new("(msmv)", > + webkitWebContextGetWebExtensionsDirectory(WEBKIT_WEB_CONTEXT(clientInfo)), extraData); And here with adoptGRef > Source/WebKit2/UIProcess/API/gtk/WebKitInjectedBundleClient.cpp:133 > + gchar* dataString = g_variant_print(data, TRUE); GOwnPtr here. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:159 > + gchar* webExtensionsDirectory; Use CString for this. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:187 > + * WebKitWebContext::web-extensions-loaded: Since this signal is not a notification, but an action required to complete the initialization of the web extensions, I think we could use a name like "initialize-web-extensions" > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:191 > + * This signal is emitted when the web extensions have been loaded and > + * before they are initialized. It is possible to return a #GVariant This is not very accurate, and that's also why I don't like the name of the signal. This signal is emitted when a new web process is about to be launched, because the user data is passed as part of the web process initialization data. When the new web process is launched, it's initialized and the injected bundle is loaded with the user data. So this is emitted even before the web process has been created, and then web extensions aren't yet loaded. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:196 > + * Returns: (allow-none): a #GVariant with arbitrary data. , or %NULL. We should probably use the transfer none annotation since we are going to consume the gvariant weak ref. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:197 > + */ Since: 2.4 > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:202 > + 0, 0, 0, You need to use an accumulator here, to make sure the signal is not propagated once a handler has returned an non NULL pointer. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:810 > + g_free(context->priv->webExtensionsDirectory); > + context->priv->webExtensionsDirectory = g_strdup(directory); Using a CString you don't need the g_free() > Source/WebKit2/UIProcess/API/gtk/tests/TestWebExtensions.cpp:221 > + g_signal_connect(webkit_web_context_get_default(), "web-extensions-loaded", > + G_CALLBACK(webExtensionsLoadedCallback), nullptr); We can probably move the whole test into its own class and connect the signal in the constructor and disconnect it in the destructor to make sure it won't affect other tests. > Source/WebKit2/UIProcess/API/gtk/tests/TestWebExtensions.cpp:233 > + WebViewTest::add("WebKitWebView", "web-extensions-loaded-signal", testWebExtensionsLoadedSignal); > + WebViewTest::add("WebKitWebView", "web-extensions-extra-data", testWebExtensionsExtraData); We can probably merge both into a single test case, because they depend on each other. It's impossible to get the extra data if the signal hasn't been emitted. > Source/WebKit2/UIProcess/API/gtk/tests/WebExtensionTest.cpp:174 > + GVariant* extraData = webkit_web_extension_get_extra_data(WEBKIT_WEB_EXTENSION(userData)); > + if (extraData) { if (GVariant* extraData = webkit_web_extension_get_extra_data(WEBKIT_WEB_EXTENSION(userData))) > Source/WebKit2/UIProcess/API/gtk/tests/WebExtensionTest.cpp:175 > + gchar* extraDataString = g_variant_print(extraData, TRUE); Use GOwnPtr > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.cpp:46 > + GVariant* extraData; Use GrefPtr here > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.cpp:162 > + * webkit_web_extension_get_extra_data: Instead of extra data (the use of the injected bundle user data for the web extensions directory is actually something internal) I would use user_data which is quite common in GNOME APIs. > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.cpp:165 > + * Obtains the extra data returned from a #WebKitWebContext::web-extensions-loaded Obtains the initialization user data returned form the #WebKitWebContext::web-extensions-loaded signal. > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.cpp:171 > + */ Since: 2.4 > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.h:71 > +WEBKIT_API GVariant * > +webkit_web_extension_get_extra_data (WebKitWebExtension *extension); Please line up arguments, like we do in other headers. > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:66 > + GVariant* variant = > + g_variant_parse(nullptr, dataString.data(), dataString.data() + dataString.length(), nullptr, nullptr); > + > + if (variant) { Can this really fail? We created that variant in the ui process with g_variant_print(). > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:69 > + gchar* directory = nullptr; This should be const char* > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:75 > + if (extraData) > + g_variant_ref_sink(extraData); I think we should pass the weak ref of the variant to the web extension to be consumed there. > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:76 > + g_variant_unref(variant); Use GRefPtr 961355 4 219636 gustavo 2013-12-19 05:37:36 -0800 Comment on attachment 219636 Patch So, what I understand from reading the API and the changelog is we are passing a GVariant with arbitrary initialization parameters for all extensions when we get a signal emission. I have a question and a suggestion: Why do we need the signal for that, is it because of some architectural constraint/implementation difficulty? Can't we just set the data along with the path before the extensions are even loaded? I think it would be better to call this "initialization parameters" instead of extra data, so it's clearer what they are for. I thought at first that they would be something that can be sent at any point rather than just for initialization. 961356 5 cgarcia 2013-12-19 05:44:32 -0800 (In reply to comment #4) > (From update of attachment 219636 [details]) > So, what I understand from reading the API and the changelog is we are passing a GVariant with arbitrary initialization parameters for all extensions when we get a signal emission. I have a question and a suggestion: > > Why do we need the signal for that, is it because of some architectural constraint/implementation difficulty? Can't we just set the data along with the path before the extensions are even loaded? Being this a signal fixes two problems: - It allows you to set dynamic data, in case of multiple web processes you might want to set different data for each web process, like a unique id, for example. We might use that to make sure that the dbus names used by the web extensions are different. - It sets a place to initialize the web extensions directory (and this user_data). > I think it would be better to call this "initialization parameters" instead of extra data, so it's clearer what they are for. I thought at first that they would be something that can be sent at any point rather than just for initialization. what about initialization_user_data? which is what wk2 uses internally? 961376 6 aperez 2013-12-19 07:05:51 -0800 (In reply to comment #5) > (In reply to comment #4) > > (From update of attachment 219636 [details] [details]) > > So, what I understand from reading the API and the changelog is we are passing a GVariant with arbitrary initialization parameters for all extensions when we get a signal emission. I have a question and a suggestion: > > > > Why do we need the signal for that, is it because of some architectural constraint/implementation difficulty? Can't we just set the data along with the path before the extensions are even loaded? > > Being this a signal fixes two problems: > > - It allows you to set dynamic data, in case of multiple web processes you might want to set different data for each web process, like a unique id, for example. We might use that to make sure that the dbus names used by the web extensions are different. > > - It sets a place to initialize the web extensions directory (and this user_data). Exactly. IMHO not having to warn in the documentation “do this before $FOO happens” is a good thing: having the warning in the docs makes it easy for developers to skip it, ot to have to do guesswork when they have to decide when to call a certain function. If we provide a signal there is an event that clearly points when. > > I think it would be better to call this "initialization parameters" instead of extra data, so it's clearer what they are for. I thought at first that they would be something that can be sent at any point rather than just for initialization. > > what about initialization_user_data? which is what wk2 uses internally? I wasn't sure whether to let the name permeate to the public WebKitGTK API, but it is also true that “extra data“ or ”user data“ lacks clarity... Let's go with “initialization user data” then. 961818 7 cgarcia 2013-12-20 04:00:34 -0800 (In reply to comment #6) > (In reply to comment #5) > > (In reply to comment #4) > > > (From update of attachment 219636 [details] [details] [details]) > > > So, what I understand from reading the API and the changelog is we are passing a GVariant with arbitrary initialization parameters for all extensions when we get a signal emission. I have a question and a suggestion: > > > > > > Why do we need the signal for that, is it because of some architectural constraint/implementation difficulty? Can't we just set the data along with the path before the extensions are even loaded? > > > > Being this a signal fixes two problems: > > > > - It allows you to set dynamic data, in case of multiple web processes you might want to set different data for each web process, like a unique id, for example. We might use that to make sure that the dbus names used by the web extensions are different. > > > > - It sets a place to initialize the web extensions directory (and this user_data). > > Exactly. IMHO not having to warn in the documentation “do this before > $FOO happens” is a good thing: having the warning in the docs makes it > easy for developers to skip it, ot to have to do guesswork when they > have to decide when to call a certain function. If we provide a signal > there is an event that clearly points when. > > > > I think it would be better to call this "initialization parameters" instead of extra data, so it's clearer what they are for. I thought at first that they would be something that can be sent at any point rather than just for initialization. > > > > what about initialization_user_data? which is what wk2 uses internally? > > I wasn't sure whether to let the name permeate to the public WebKitGTK API, > but it is also true that “extra data“ or ”user data“ lacks clarity... Let's > go with “initialization user data” then. After thining about it a bit more, I think I prefer just user_data, at least in the way it's currently implemented. Ideally, this should actually be initialization data, passed as parameter to webkit_web_extension_initialize, instead of getting it from the WebExtension object. That way we wouldn't need to keep the data in memory all the time. The problem is that we can't change the initialization symbol (unless we deprecate the current one and add a new one receiving the initialization user data, not sure it's worth it). The thing is that the way we are currently implementing, it's data associated to the web extension passed by the user from the ui process. You can get that data from the web extension object at any time. So, in my opinion we could: a) Deprecate webkit_web_extension_initialize() and add a new symbol receiving the init user data. We would check the new symbol first always falling back to the deprecated one when not found. b) Use just user_data always available from the web extension and avoid the initialization word to avoid confusion. I think a) is the ideal solution from the API point of view, but requires to deprecate current init symbol. 961824 8 gustavo 2013-12-20 04:07:37 -0800 (In reply to comment #6) > > - It allows you to set dynamic data, in case of multiple web processes you might want to set different data for each web process, like a unique id, for example. We might use that to make sure that the dbus names used by the web extensions are different. > > > > - It sets a place to initialize the web extensions directory (and this user_data). > > Exactly. IMHO not having to warn in the documentation “do this before > $FOO happens” is a good thing: having the warning in the docs makes it > easy for developers to skip it, ot to have to do guesswork when they > have to decide when to call a certain function. If we provide a signal > there is an event that clearly points when. Sounds like this bug should depend no bug 123292 then =) (In reply to comment #7) > After thining about it a bit more, I think I prefer just user_data, at least in the way it's currently implemented. Ideally, this should actually be initialization data, passed as parameter to webkit_web_extension_initialize, instead of getting it from the WebExtension object. That way we wouldn't need to keep the data in memory all the time. The problem is that we can't change the initialization symbol (unless we deprecate the current one and add a new one receiving the initialization user data, not sure it's worth it). The thing is that the way we are currently implementing, it's data associated to the web extension passed by the user from the ui process. You can get that data from the web extension object at any time. So, in my opinion we could: > > a) Deprecate webkit_web_extension_initialize() and add a new symbol receiving the init user data. We would check the new symbol first always falling back to the deprecated one when not found. > > b) Use just user_data always available from the web extension and avoid the initialization word to avoid confusion. > > I think a) is the ideal solution from the API point of view, but requires to deprecate current init symbol. I think going with a and calling it 'initialization user data' would be the best from an API perspective. We can ditch the data once the extension is initialized - if the extension really wants to keep it they can store it themselves, how about that? We don't really need to deprecate the initialize function, actually, it's kind of a _new() and _new_with_text() kind of thing from my perspective. 961827 9 cgarcia 2013-12-20 04:15:09 -0800 (In reply to comment #8) > (In reply to comment #6) > > > - It allows you to set dynamic data, in case of multiple web processes you might want to set different data for each web process, like a unique id, for example. We might use that to make sure that the dbus names used by the web extensions are different. > > > > > > - It sets a place to initialize the web extensions directory (and this user_data). > > > > Exactly. IMHO not having to warn in the documentation “do this before > > $FOO happens” is a good thing: having the warning in the docs makes it > > easy for developers to skip it, ot to have to do guesswork when they > > have to decide when to call a certain function. If we provide a signal > > there is an event that clearly points when. > > Sounds like this bug should depend no bug 123292 then =) It's not the same, this happens before the new web process is launched, and the other one is emitted when the web process has been launched and the connection has been established, which is too late to set user data and web extensions dir. > (In reply to comment #7) > > After thining about it a bit more, I think I prefer just user_data, at least in the way it's currently implemented. Ideally, this should actually be initialization data, passed as parameter to webkit_web_extension_initialize, instead of getting it from the WebExtension object. That way we wouldn't need to keep the data in memory all the time. The problem is that we can't change the initialization symbol (unless we deprecate the current one and add a new one receiving the initialization user data, not sure it's worth it). The thing is that the way we are currently implementing, it's data associated to the web extension passed by the user from the ui process. You can get that data from the web extension object at any time. So, in my opinion we could: > > > > a) Deprecate webkit_web_extension_initialize() and add a new symbol receiving the init user data. We would check the new symbol first always falling back to the deprecated one when not found. > > > > b) Use just user_data always available from the web extension and avoid the initialization word to avoid confusion. > > > > I think a) is the ideal solution from the API point of view, but requires to deprecate current init symbol. > > I think going with a and calling it 'initialization user data' would be the best from an API perspective. We can ditch the data once the extension is initialized - if the extension really wants to keep it they can store it themselves, how about that? We don't really need to deprecate the initialize function, actually, it's kind of a _new() and _new_with_text() kind of thing from my perspective. It's a bit weird having two entry points, but I don't see any problem. We can add webkit_web_extension_inisitalize_with_user_data() then and document that if this is present the other one is ignored. 961831 10 gustavo 2013-12-20 04:57:31 -0800 (In reply to comment #9) > > Sounds like this bug should depend no bug 123292 then =) > > It's not the same, this happens before the new web process is launched, and the other one is emitted when the web process has been launched and the connection has been established, which is too late to set user data and web extensions dir. Oh, I see, though I guess the use cases are pretty much the same, the only reason why the other patch relies on the connection is because it's a convenient place to store the process identifier, AFAIK. If we could think of a better way of having that identifier managed we could fuse these two signals. 961834 11 cgarcia 2013-12-20 05:27:37 -0800 (In reply to comment #10) > (In reply to comment #9) > > > Sounds like this bug should depend no bug 123292 then =) > > > > It's not the same, this happens before the new web process is launched, and the other one is emitted when the web process has been launched and the connection has been established, which is too late to set user data and web extensions dir. > > Oh, I see, though I guess the use cases are pretty much the same, the only reason why the other patch relies on the connection is because it's a convenient place to store the process identifier, AFAIK. If we could think of a better way of having that identifier managed we could fuse these two signals. I'm not sure, I think it might be useful to know when the web process has been launched, so I think we could have initialize-web-extensions emitted for getInjectedBundleInitializationUserData as the perfect place to call set_web_extensions_dir + set_web_extensions_initialization_user_data, and web-process-started emitted when the web process has been launched as two different signals. 961849 12 gustavo 2013-12-20 06:25:09 -0800 OK, makes sense to me, I'll unlink the bugs then 964423 13 220378 aperez 2014-01-04 12:37:18 -0800 Created attachment 220378 Patch 964497 14 220378 cgarcia 2014-01-05 06:05:14 -0800 Comment on attachment 220378 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=220378&action=review Thanks for the new patch. I think we already agreed on having a signal WebKitWebContext::initialize-web-extensions and a method to set the init user data webkit_web_context_set_web_extensions_initialization_user_data(). Then we document that the best place to call both set_web_extensions_directory and set_web_extensions_initialization_user_data is in the initialize-web-extensions callback. If we want to avoid having to keep the user data around in the context all the time, we could clear the data after the signal is emitted, and document that set_web_extensions_initialization_user_data() should always be called when initialize-web-extensions is emitted. This way we also avoid the accumulator and the signal having to return a GVariant. Also in the web extensions api, we agreed on adding a new initialization function instead of webkit_web_extension_get_initialization_user_data(), something like webkit_web_extension_initialize_with_user_data() that receives the GVariant as a parameter. If this symbol is not present in the extension, we just fallback to webkit_web_extension_initialize(). See comment #11. > Source/WebKit2/UIProcess/API/gtk/WebKitInjectedBundleClient.cpp:123 > + GRefPtr<GVariant> extraData = webkitWebContextWebExtensionsLoaded(WEBKIT_WEB_CONTEXT(clientInfo)); WebExtensionsLoaded is not accurate, this is called even before the web process has been launched. Use the name of the signal that is going to be emitted: webkitWebContextInitializeWebExtensions() We could make that method build the final GVariant, so that we don't need more private api here. It emits the signal and then builds the GVariant with the extensions dir and user_data. GRefPtr<GVariant> data = webkitWebContextInitializeWebExtensions(WEBKIT_WEB_CONTEXT(clientInfo)); GOwnPtr<gchar> dataString(g_variant_print(data.get(), TRUE)); return static_cast<WKTypeRef>(WKStringCreateWithUTF8CString(dataString.get())); The function would return a float reference, so you don't need to use adoptGRef in this case. > Source/WebKit2/UIProcess/API/gtk/tests/TestWebExtensionsInitialization.cpp:45 > + GRefPtr<GDBusProxy> proxy = adoptGRef(bus->createProxy("org.webkit.gtk.WebExtensionTest", > + "/org/webkit/gtk/WebExtensionTest" , "org.webkit.gtk.WebExtensionTest", test->m_mainLoop)); > + GRefPtr<GVariant> result = adoptGRef(g_dbus_proxy_call_sync( > + proxy.get(), > + "GetExtraDataAsString", > + nullptr, > + G_DBUS_CALL_FLAGS_NONE, > + -1, 0, 0)); > + g_assert(result); I think it would be a lot easier if you simply check the user data in the web extension. Here you simply pass "'extra data'" and in the web extension you assert if the user data is not "'extra data'" > Source/WebKit2/UIProcess/API/gtk/tests/TestWebExtensionsInitialization.cpp:65 > + webkit_web_context_set_web_extensions_directory(webkit_web_context_get_default(), WEBKIT_TEST_WEB_EXTENSIONS_DIR); > + initializeWebExtensionsSignalHandlerId = g_signal_connect(webkit_web_context_get_default(), > + "initialize-web-extensions", G_CALLBACK(initializeWebExtensionsCallback), nullptr); Create a class instead of adding this in beforeAll. Call webkit_web_context_set_web_extensions_directory in the signal hanlder too. You don't need to keep the handler id, you can use g_signal_handlers_disconnect_matched in the class destructor. > Source/WebKit2/UIProcess/API/gtk/tests/TestWebExtensionsInitialization.cpp:71 > + WebViewTest::add("WebKitWebView", "web-extensions-initialization-user-data", testWebExtensionsInitializationUserData); Would it be possible to reuse the existing web extensions test file? "WebKitWebView" -> "WebKitWebContext" 968775 15 221381 aperez 2014-01-16 08:56:43 -0800 Created attachment 221381 Patch 968799 16 aperez 2014-01-16 09:58:23 -0800 (In reply to comment #15) > Created an attachment (id=221381) [details] > Patch Regarding this version of the patch, note that I still have to update the tests. And talking about tests: the intialization user data being passed correctly is a must for web extensions to work at all, because the web extensions directory is now passed as part of the serialized GVariant. As the mechanism must always work, I am thinking of keeping the test case in “TestWebExtensions.cpp”, WDYT? 969157 17 cgarcia 2014-01-17 09:49:35 -0800 (In reply to comment #16) > (In reply to comment #15) > > Created an attachment (id=221381) [details] [details] > > Patch > > Regarding this version of the patch, note that I still have to update the > tests. And talking about tests: the intialization user data being passed > correctly is a must for web extensions to work at all, because the web > extensions directory is now passed as part of the serialized GVariant. > As the mechanism must always work, I am thinking of keeping the test case > in “TestWebExtensions.cpp”, WDYT? Sounds good to me. 969423 18 221540 aperez 2014-01-18 01:12:33 -0800 Created attachment 221540 Patch 969425 19 221541 aperez 2014-01-18 01:44:06 -0800 Created attachment 221541 Patch 969582 20 221541 cgarcia 2014-01-19 01:08:55 -0800 Comment on attachment 221541 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=221541&action=review Looks good, I still have a few comments. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:809 > - // We pass the additional web extensions directory to the injected bundle as initialization user data. > - context->priv->context->setInjectedBundleInitializationUserData(API::String::create(WebCore::filenameToString(directory))); > + context->priv->webExtensionsDirectory = directory; Update also the documentation of this method to mention that initialize-web-extensions signal is the perfect place to call it. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:815 > + * webkit_web_context_set_web_extensions_initialization_user_data: > + * @context: a #WebKitWebContext > + * userData parameter is missing in documentation. You should also explain briefly what this function is for and how to use it, liking to the initialize-web-extensions signal. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:821 > + g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context)); > + What about userData, do we allow passing NULL?, what happen in that case? We should also document this behaviour. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:910 > +GRefPtr<GVariant> webkitWebContextInitializeWebExtensions(WebKitWebContext* context) We don't need to use GRefPtr here, we can return the pointer with the weak reference that will be consumed by the caller. > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.h:62 > + * Add a tag See also: WebKitWebExtensionInitializeFunction and mention they are mutually exclusive but this one takes precedence. > Source/WebKit2/WebProcess/InjectedBundle/API/gtk/WebKitWebExtension.h:63 > + * Since: 0.26 0.26? :-) > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:68 > + ASSERT(userDataString); > + ASSERT(WKGetTypeID(userDataString) == WKStringGetTypeID()); > + > + CString dataString = toImpl(static_cast<WKStringRef>(userDataString))->string().utf8(); > + GRefPtr<GVariant> variant = > + g_variant_parse(nullptr, dataString.data(), dataString.data() + dataString.length(), nullptr, nullptr); > + > + ASSERT(variant); > + ASSERT(g_variant_check_format_string(variant.get(), "(m&smv)", FALSE)); > + > + const char* directory = nullptr; > + GVariant* data = nullptr; > + g_variant_get(variant.get(), "(m&smv)", &directory, &data); This could probably be moved to a helper function parseUserData or something like that. > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:72 > + if (directory) > + webExtensionsDirectory = String::fromUTF8(directory); Note that this was created in the UI process with WebCore::filenameToString(), but now the utf8 string passed by the user is sent to the web process, so here you should use WebCore::filenameToString() instead of String::fromUTF8() > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:79 > + GRefPtr<GVariant> userData; > + if (data) > + userData = data; This is wrong. The data returned by g_variant_get() is a full reference that you should adopt, but not here, right after g_variant_get() so that it's also released by any previous early return. It's safe to set nullptr to a GrefPtr, so you don't need the if either, you can simply: GRefPtr<GVariant> userData = adoptGRef(data); > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:96 > + WebKitWebExtensionInitializeWithUserDataFunction initializeWithUserDataFunction = > + module->functionPointer<WebKitWebExtensionInitializeWithUserDataFunction>("webkit_web_extension_initialize_with_user_data"); > WebKitWebExtensionInitializeFunction initializeFunction = > module->functionPointer<WebKitWebExtensionInitializeFunction>("webkit_web_extension_initialize"); > - if (!initializeFunction) > + if (!initializeWithUserDataFunction && !initializeFunction) > continue; I think we can avoid looking for both symbols every time. Try to get the new one, if not present fallback to the previous one. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebExtensions.cpp:184 > + GRefPtr<GVariant> userData = adoptGRef(g_variant_new("s", webExtensionsUserData)); You should not adopt this one, since nobody is going to consume the floating ref. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/WebExtensionTest.cpp:231 > + g_dbus_method_invocation_return_value(invocation, > + g_variant_new("(b)", g_str_equal(checkString, initializationUserDataString.get()))); I think we should move this logic to the UI process instead. Rename the method to GetInitializationUserData and check the string in the UI process like we do with GetTitle, for example. 969585 21 cgarcia 2014-01-19 01:42:17 -0800 I've noticed that GVariant floating references are not correctly handled by GRefPtr, and my review comments assumed they were correctly handled. See https://bugs.webkit.org/show_bug.cgi?id=127246 969593 22 221586 aperez 2014-01-19 08:52:24 -0800 Created attachment 221586 Patch 970200 23 221586 cgarcia 2014-01-21 01:23:20 -0800 Comment on attachment 221586 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=221586&action=review Looks great! I have just a few more nits. This would be r+ with nits if you were a committer. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:805 > + * It is recommended to use this method in a handler for the > + * WebKitWebContext::initialize-web-extensions signal. In GTK+ we usually use callback instead of handler, so maybe "in the callback of the". WebKitWebContext::initialize-web-extensions -> #WebKitWebContext::initialize-web-extensions I think we should merge this with the previous paragraph, because we are giving two different messages, cal this before loading anything and call this in initialize-web-extensions signal. So what about something like: This method must be called before loading anything in this context, otherwise it will not have any effect. You can connect to #WebKitWebContext::initialize-web-extensions signal to call this method before anything is loaded. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:820 > + * Set arbitrary user data to be passed to Web Extensions on initialization. s/arbitrary// > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:822 > + * %webkit_web_context_set_web_extensions_initialization_user_data() of type %? The function name is webkit_web_extension_initialize_with_user_data(). I would just mention that this data is passed to the #WebKitWebExtensionInitializeWithUserDataFunction defined in the web extension. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:826 > + * Passing %NULL will cause no data being passed to Web Extensions, which > + * will receive a %NULL as second parameter to the initialization function. What's the difference between calling this with NULL and not calling it at all? I think we should say that passing NULL resets any data previously set with this function. this makes clear that there's no point on calling this with NULL the first time. I'm still not sure we should allow passing null, though. > Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp:829 > + * It is recommended to use this method in a handler for the > + * WebKitWebContext::initialize-web-extensions signal. We should say something similar to the other method, it's important to say here too that this doesn't have any effect if it's called late. We can use the same sentence. > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:56 > +static void parseUserData(WKTypeRef userData, String& webExtensionsDirectory, > + GRefPtr<GVariant>& initializationUserData) Use a single line > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:73 > + if (directory) > + webExtensionsDirectory = WebCore::filenameToString(directory); filenameToString returns String() in case the passed filename is NULL, so you don't need the if you do: webExtensionsDirectory = WebCore::filenameToString(directory); > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:75 > + if (data) > + initializationUserData = adoptGRef(data); Same here, adoptGRef accepts NULL > Source/WebKit2/WebProcess/gtk/WebGtkExtensionManager.cpp:111 > + WebKitWebExtensionInitializeWithUserDataFunction initializeWithUserDataFunction = > + module->functionPointer<WebKitWebExtensionInitializeWithUserDataFunction>("webkit_web_extension_initialize_with_user_data"); > + > + if (initializeWithUserDataFunction) { > + initializeWithUserDataFunction(m_extension.get(), userData.get()); > + m_extensionModules.append(module.leakPtr()); > + } else { > + WebKitWebExtensionInitializeFunction initializeFunction = > + module->functionPointer<WebKitWebExtensionInitializeFunction>("webkit_web_extension_initialize"); > + if (initializeFunction) { > + initializeFunction(m_extension.get()); > + m_extensionModules.append(module.leakPtr()); > + } > + } What do you think about moving this to a helper function too? This way we avoid duplicating the m_extensionModules.append(module.leakPtr()); Something like: if (initializeWebExtension(module.get(), userData.get())) m_extensionModules.append(module.leakPtr()); > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebExtensions.cpp:187 > + GRefPtr<GVariant> result = g_dbus_proxy_call_sync( I think g_dbus_proxy_call_sync returns a full reference, so it should be adopted. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebExtensions.cpp:195 > + const gchar* str = nullptr; Use something like userData instead of str. > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebExtensions.cpp:196 > + g_variant_get(result.get(), "(s)", &str); You need to use "(&s)" to get a const char * > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestWebExtensions.cpp:197 > + g_assert(g_str_equal(str, webExtensionsUserData)); Use g_assert_cmpstr instead > Tools/TestWebKitAPI/Tests/WebKit2Gtk/WebExtensionTest.cpp:225 > + g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", > + initializationUserData && g_variant_is_of_type(initializationUserData.get(), G_VARIANT_TYPE_STRING) > + ? g_variant_get_string(initializationUserData.get(), nullptr) > + : "")); We are always passing the data, since this is not a generic extension, I think we can simply assert if the user data is NULL at this point. That would make this easier to read. g_assert(initializationUserData); g_assert(g_variant_is_of_type(initializationUserData.get(), G_VARIANT_TYPE_STRING)); g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", g_variant_get_string(initializationUserData.get(), nullptr)); 970215 24 221731 aperez 2014-01-21 03:23:20 -0800 Created attachment 221731 Patch 970231 25 221731 cgarcia 2014-01-21 06:22:25 -0800 Comment on attachment 221731 Patch Excellent! Thank you very much. This is new API, and we already discussed this with Gustavo, but not setting cq+ yet until Gustavo confirms he is happy with the final patch. 970239 26 221731 commit-queue 2014-01-21 06:53:22 -0800 Comment on attachment 221731 Patch Clearing flags on attachment: 221731 Committed r162441: <http://trac.webkit.org/changeset/162441> 970240 27 commit-queue 2014-01-21 06:53:27 -0800 All reviewed patches have been landed. Closing bug. 219636 2013-12-19 03:10:59 -0800 2014-01-04 12:37:04 -0800 Patch bug-125990-20131219121103.patch text/plain 20366 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYwODI3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNTdkZDM1MzI2ZTJhZmVj Yzk3ZDRhY2FkNWFlNDgwMWU0NDg2YmFiYy4uZmNlOTdiOTA2ZjA2NGU3YWIzMzdlMTc5Yjc3ZGU5 NzgyOTNkODg4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU5IEBACisyMDEzLTEyLTE5ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisKKyAgICAgICAgQWxs b3cgcGFzc2luZyBhZGRpdGlvbmFsIGluZm9ybWF0aW9uIHRvIHRoZSBpbmplY3RlZCBidW5kbGUu IE9uIHRvcCBvZiB0aGUKKyAgICAgICAgc3RyaW5nIGNvbnRhaW5pbmcgdGhlIHBhdGggdG8gdGhl IHdlYiBleHRlbnNpb25zIGRpcmVjdG9yeSwgYSBHVmFyaWFudCBjYW4KKyAgICAgICAgYmUgcmV0 dXJuZWQgYnkgYSBjYWxsYmFjayBjb25uZWN0ZWQgdG8gdGhlIHdlYi1leHRlbnNpb25zLWxvYWRl ZCBzaWduYWwuCisgICAgICAgIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkLCBwYXNzZWQgdG8g dGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRoZQorICAgICAgICBpbmplY3RlZCBidW5kbGUgZGVz ZXJpYWxpemVzIGJhY2sgdGhlIGRhdGEsIHdoaWNoIGNhbiB0aGVuIGJlIHJldHJpZXZlZAorICAg ICAgICB1c2luZyB0aGUgd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEoKSBtZXRo b2QuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEy NTk5MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVDbGllbnQuY3BwOgorICAgICAg ICAoZ2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhKToKKyAgICAgICAgRGVm aW5lIG5ldyBjYWxsYmFjayBmdW5jdGlvbiB3aGljaCBzZXJpYWxpemVzIHRoZSBkYXRhIHRvIGJl IHBhc3NlZAorICAgICAgICB0byB0aGUgd2ViIHByb2Nlc3MuCisgICAgICAgIChhdHRhY2hJbmpl Y3RlZEJ1bmRsZUNsaWVudFRvQ29udGV4dCk6CisgICAgICAgIERlZmluZSB0aGUgZ2V0SW5qZWN0 ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhKCkgY2FsbGJhY2ssIHdoaWNoCisgICAgICAg IGlzIHVzZWQgdG8gZW1pdCB0aGUgd2ViLWV4dGVuc2lvbnMtbG9hZGVkIHNpZ25hbCwgYW5kIHBh c3MgdGhlCisgICAgICAgIEdWYXJpYW50IHJldHVybmVkIGJ5IHRoZSBzaWduYWwgY2FsbGJhY2su CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHA6CisgICAg ICAgICh3ZWJraXRfd2ViX2NvbnRleHRfY2xhc3NfaW5pdCk6CisgICAgICAgIERlZmluZSB0aGUg d2ViLWV4dGVuc2lvbnMtbG9hZGVkIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4 dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVuc2lvbnMg ZGlyZWN0b3J5IGFzIGEgbWVtYmVyIG9mIFdlYktpdFdlYkNvbnRleHRQcml2YXRlLCB0bworICAg ICAgICBiZSBhYmxlIHRvIHJldHJpZXZlIGl0IGxhdGVyLgorICAgICAgICAod2Via2l0V2ViQ29u dGV4dFdlYkV4dGVuc2lvbnNMb2FkZWQpOgorICAgICAgICBQcml2YXRlIGZ1bmN0aW9uIHVzZWQg dG8gdHJpZ2dlciBlbWlzc2lvbiBvZiB0aGUKKyAgICAgICAgd2ViLWV4dGVuc2lvbnMtbG9hZGVk IHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdFdlYkNvbnRleHRHZXRXZWJFeHRlbnNpb25zRGlyZWN0 b3J5KToKKyAgICAgICAgUHJpdmF0ZSBmdW5jdGlvbiB0byBvYnRhaW4gdGhlIHdlYiBleHRlbnNp b25zIGRpcmVjdG9yeSBpbiBvcmRlciB0bworICAgICAgICBzZXJpYWxpemUgaXQsIHNvIGl0IGNh biBiZSBwYXNzZWQgdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4KKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oOgorICAgICAgICBQcm90b3R5cGVzIG9m IHRoZSBuZXcgcHJpdmF0ZSBmdW5jdGlvbnMuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsv ZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dDoKKyAgICAgICAgQWRkIHdlYmtpdF93ZWJfZXh0 ZW5zaW9uX2dldF9leHRyYV9kYXRhKCkgdG8gdGhlIEFQSSBkb2NzLgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL3dlYmtpdDJtYXJzaGFsLmxpc3Q6CisgICAgICAgIERlZmluZSBhIG1hcnNo YWxsZXIgZm9yIHRoZSB3ZWItZXh0ZW5zaW5zLWxvYWRlZCBzaWduYWwuCisgICAgICAgICogV2Vi UHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5jcHA6Cisg ICAgICAgICh3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUpOgorICAgICAgICBBZGQgYWRkaXRpb25h bCBhcmd1bWVudCB0byBwYXNzIHRoZSBkZXNlcmlhbGl6ZWQgZXh0cmEgZGF0YS4KKyAgICAgICAg KHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9leHRyYV9kYXRhKToKKyAgICAgICAgTmV3IG1ldGhv ZCB0byByZXRyaWV2ZSB0aGUgZXh0cmEgZGF0YSBwYXNzZWQgdG8gdGhlIHdlYiBleHRlbnNpb25z CisgICAgICAgIGZyb20gdGhlIFVJIHByb2Nlc3MuCisgICAgICAgICogV2ViUHJvY2Vzcy9Jbmpl Y3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5oOgorICAgICAgICBBZGQgd2Vi a2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEoKSB0byB0aGUgQVBJLgorICAgICAgICAq IFdlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb25Qcml2 YXRlLmg6CisgICAgICAgIENoYW5nZWQgcHJvdG90eXBlIG9mIHdlYmtpdFdlYkV4dGVuc2lvbkNy ZWF0ZSgpLgorICAgICAgICAqIFdlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIu Y3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXpl KToKKyAgICAgICAgRGVzZXJpYWxpemUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJv Y2VzcyBhbmQgcGFzcyBpdCB0bworICAgICAgICB3ZWJraXRXZWJJbnNwZWN0b3JDcmVhdGUoKS4K KwogMjAxMy0xMi0xOCAgVGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAog ICAgICAgICBXZWJLaXQyIFZpZXcgR2VzdHVyZXM6IE1vdmUgV2ViUHJvY2Vzcy1zaWRlIGdlb21l dHJ5IGNvbGxlY3Rpb24gaW50byBpdHMgb3duIGNsYXNzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVu dC5jcHAKaW5kZXggNGRiM2RmYTdiMmJiOGUwODdlM2FlYjhiZjdkNTU1ZWVlYzQ0MjUxOS4uN2Fm MGJhZmIyYjEyNDUwZDQ5OTRiY2FkZTVjZGVhOWVkYzA2MmQ0YiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVDbGllbnQuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVu ZGxlQ2xpZW50LmNwcApAQCAtMTE4LDE2ICsxMTgsMzUgQEAgc3RhdGljIHZvaWQgZGlkUmVjZWl2 ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250ZXh0UmVmLCBXS1N0cmluZ1JlZiBtZXNz YWcKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiB9CiAKK3N0YXRpYyBXS1R5cGVSZWYg Z2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhKFdLQ29udGV4dFJlZiwgY29u c3Qgdm9pZCogY2xpZW50SW5mbykKK3sKKyAgICBHVmFyaWFudCogZXh0cmFEYXRhID0gd2Via2l0 V2ViQ29udGV4dFdlYkV4dGVuc2lvbnNMb2FkZWQoV0VCS0lUX1dFQl9DT05URVhUKGNsaWVudElu Zm8pKTsKKyAgICBpZiAoZXh0cmFEYXRhKQorICAgICAgICBnX3ZhcmlhbnRfcmVmX3NpbmsoZXh0 cmFEYXRhKTsKKworICAgIEdWYXJpYW50KiBkYXRhID0gZ192YXJpYW50X25ldygiKG1zbXYpIiwK KyAgICAgICAgd2Via2l0V2ViQ29udGV4dEdldFdlYkV4dGVuc2lvbnNEaXJlY3RvcnkoV0VCS0lU X1dFQl9DT05URVhUKGNsaWVudEluZm8pKSwgZXh0cmFEYXRhKTsKKworICAgIGlmIChleHRyYURh dGEpCisgICAgICAgIGdfdmFyaWFudF91bnJlZihleHRyYURhdGEpOworCisgICAgZ2NoYXIqIGRh dGFTdHJpbmcgPSBnX3ZhcmlhbnRfcHJpbnQoZGF0YSwgVFJVRSk7CisgICAgZ192YXJpYW50X3Vu cmVmKGRhdGEpOworICAgIFdLU3RyaW5nUmVmIHJlc3VsdCA9IFdLU3RyaW5nQ3JlYXRlV2l0aFVU RjhDU3RyaW5nKGRhdGFTdHJpbmcpOworICAgIGdfZnJlZShkYXRhU3RyaW5nKTsKKyAgICByZXR1 cm4gc3RhdGljX2Nhc3Q8V0tUeXBlUmVmPihyZXN1bHQpOworfQorCiB2b2lkIGF0dGFjaEluamVj dGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KFdlYktpdFdlYkNvbnRleHQqIHdlYkNvbnRleHQpCiB7 CiAgICAgV0tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGllbnRWMSB3a0luamVjdGVkQnVuZGxlQ2xp ZW50ID0gewogICAgICAgICB7Ci0gICAgICAgICAgICAwLCAvLyB2ZXJzaW9uCisgICAgICAgICAg ICAxLCAvLyB2ZXJzaW9uCiAgICAgICAgICAgICB3ZWJDb250ZXh0LCAvLyBjbGllbnRJbmZvCiAg ICAgICAgIH0sCiAgICAgICAgIGRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlLAog ICAgICAgICAwLCAvLyBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJvbUluamVjdGVkQnVu ZGxlCi0gICAgICAgIDAgLy8gZ2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRh CisgICAgICAgIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YQogICAgIH07 CiAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGllbnQodG9BUEkod2Via2l0V2ViQ29u dGV4dEdldENvbnRleHQod2ViQ29udGV4dCkpLCAmd2tJbmplY3RlZEJ1bmRsZUNsaWVudC5iYXNl KTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYkNvbnRleHQuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 V2ViQ29udGV4dC5jcHAKaW5kZXggZGQ3ZGY1N2NjNDBlNGU3MzUxOTQ4YjEyZWU2MDU4ZTllNzBi ZThkOS4uOTk5ZWNkOTM1MDliNTkyNTU4ODNmZWY1NDRhZDgxNTFhNTZjM2IxNiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5j cHAKQEAgLTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlICJXZWJLaXRGYXZpY29uRGF0YWJhc2VQcml2 YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0R2VvbG9jYXRpb25Qcm92aWRlci5oIgogI2luY2x1ZGUg IldlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViS2l0TWFyc2hhbC5o IgogI2luY2x1ZGUgIldlYktpdFBsdWdpblByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRQcml2 YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0UmVxdWVzdE1hbmFnZXJDbGllbnQuaCIKQEAgLTg0LDYg Kzg1LDcgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIAogZW51bSB7CiAgICAgRE9XTkxPQURf U1RBUlRFRCwKKyAgICBXRUJfRVhURU5TSU9OU19MT0FERUQsCiAKICAgICBMQVNUX1NJR05BTAog fTsKQEAgLTE1Myw2ICsxNTUsOCBAQCBzdHJ1Y3QgX1dlYktpdFdlYkNvbnRleHRQcml2YXRlIHsK IAogICAgIEhhc2hNYXA8dWludDY0X3QsIFdlYktpdFdlYlZpZXcqPiB3ZWJWaWV3czsKICAgICBH UmVmUHRyPFdlYktpdFdlYlZpZXdHcm91cD4gZGVmYXVsdFdlYlZpZXdHcm91cDsKKworICAgIGdj aGFyKiB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5OwogfTsKIAogc3RhdGljIGd1aW50IHNpZ25hbHNb TEFTVF9TSUdOQUxdID0geyAwLCB9OwpAQCAtMTc4LDYgKzE4MiwyNiBAQCBzdGF0aWMgdm9pZCB3 ZWJraXRfd2ViX2NvbnRleHRfY2xhc3NfaW5pdChXZWJLaXRXZWJDb250ZXh0Q2xhc3MqIHdlYkNv bnRleHRDbGFzcwogICAgICAgICAgICAgICAgICAgICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURf X09CSkVDVCwKICAgICAgICAgICAgICAgICAgICAgIEdfVFlQRV9OT05FLCAxLAogICAgICAgICAg ICAgICAgICAgICAgV0VCS0lUX1RZUEVfRE9XTkxPQUQpOworCisgICAgLyoqCisgICAgICogV2Vi S2l0V2ViQ29udGV4dDo6d2ViLWV4dGVuc2lvbnMtbG9hZGVkOgorICAgICAqIEBjb250ZXh0OiB0 aGUgI1dlYktpdFdlYkNvbnRleHQKKyAgICAgKgorICAgICAqIFRoaXMgc2lnbmFsIGlzIGVtaXR0 ZWQgd2hlbiB0aGUgd2ViIGV4dGVuc2lvbnMgaGF2ZSBiZWVuIGxvYWRlZCBhbmQKKyAgICAgKiBi ZWZvcmUgdGhleSBhcmUgaW5pdGlhbGl6ZWQuIEl0IGlzIHBvc3NpYmxlIHRvIHJldHVybiBhICNH VmFyaWFudAorICAgICAqIHdpdGggYXJiaXRyYXJ5IGRhdGEsIHdoaWNoIHdpbGwgYmUgcGFzc2Vk IHRvIHRoZSB3ZWIgcHJvY2VzcyBpbiB3aGljaAorICAgICAqIHRoZSB3ZWIgZXh0ZW5zaW9ucyBo YXZlIGJlZW4gbG9hZGVkLiBXZWIgZXh0ZW5zaW9ucyBjYW4gcmV0cmlldmUgdGhpcworICAgICAq IGRhdGEgdXNpbmcgd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEoKQorICAgICAq CisgICAgICogUmV0dXJuczogKGFsbG93LW5vbmUpOiBhICNHVmFyaWFudCB3aXRoIGFyYml0cmFy eSBkYXRhLgorICAgICAqLworICAgIHNpZ25hbHNbV0VCX0VYVEVOU0lPTlNfTE9BREVEXSA9Cisg ICAgICAgIGdfc2lnbmFsX25ldygid2ViLWV4dGVuc2lvbnMtbG9hZGVkIiwKKyAgICAgICAgICAg IEdfVFlQRV9GUk9NX0NMQVNTKGdPYmplY3RDbGFzcyksCisgICAgICAgICAgICBHX1NJR05BTF9S VU5fTEFTVCwKKyAgICAgICAgICAgIDAsIDAsIDAsCisgICAgICAgICAgICB3ZWJraXRfbWFyc2hh bF9WQVJJQU5UX19WT0lELAorICAgICAgICAgICAgR19UWVBFX1ZBUklBTlQsIDApOwogfQogCiBz dGF0aWMgQ1N0cmluZyBpbmplY3RlZEJ1bmRsZURpcmVjdG9yeSgpCkBAIC03ODIsOCArODA2LDgg QEAgdm9pZCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeShX ZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LAogICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lT X1dFQl9DT05URVhUKGNvbnRleHQpKTsKICAgICBnX3JldHVybl9pZl9mYWlsKGRpcmVjdG9yeSk7 CiAKLSAgICAvLyBXZSBwYXNzIHRoZSBhZGRpdGlvbmFsIHdlYiBleHRlbnNpb25zIGRpcmVjdG9y eSB0byB0aGUgaW5qZWN0ZWQgYnVuZGxlIGFzIGluaXRpYWxpemF0aW9uIHVzZXIgZGF0YS4KLSAg ICBjb250ZXh0LT5wcml2LT5jb250ZXh0LT5zZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9u VXNlckRhdGEoQVBJOjpTdHJpbmc6OmNyZWF0ZShXZWJDb3JlOjpmaWxlbmFtZVRvU3RyaW5nKGRp cmVjdG9yeSkpKTsKKyAgICBnX2ZyZWUoY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVj dG9yeSk7CisgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IGdfc3Ry ZHVwKGRpcmVjdG9yeSk7CiB9CiAKIC8qKgpAQCAtODcxLDYgKzg5NSwxMyBAQCB2b2lkIHdlYmtp dFdlYkNvbnRleHREb3dubG9hZFN0YXJ0ZWQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgV2Vi S2l0RG93bmxvYWQqCiAgICAgZ19zaWduYWxfZW1pdChjb250ZXh0LCBzaWduYWxzW0RPV05MT0FE X1NUQVJURURdLCAwLCBkb3dubG9hZCk7CiB9CiAKK0dWYXJpYW50KiB3ZWJraXRXZWJDb250ZXh0 V2ViRXh0ZW5zaW9uc0xvYWRlZChXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0KQoreworICAgIEdW YXJpYW50KiByZXR1cm5fdmFsdWU7CisgICAgZ19zaWduYWxfZW1pdChjb250ZXh0LCBzaWduYWxz W1dFQl9FWFRFTlNJT05TX0xPQURFRF0sIDAsICZyZXR1cm5fdmFsdWUpOworICAgIHJldHVybiBy ZXR1cm5fdmFsdWU7Cit9CisKIFdlYkNvbnRleHQqIHdlYmtpdFdlYkNvbnRleHRHZXRDb250ZXh0 KFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQpCiB7CiAgICAgZ19hc3NlcnQoV0VCS0lUX0lTX1dF Ql9DT05URVhUKGNvbnRleHQpKTsKQEAgLTkzNiwzICs5NjcsOCBAQCBXZWJLaXRXZWJWaWV3R3Jv dXAqIHdlYmtpdFdlYkNvbnRleHRHZXREZWZhdWx0V2ViVmlld0dyb3VwKFdlYktpdFdlYkNvbnRl eHQqIGNvbgogewogICAgIHJldHVybiBjb250ZXh0LT5wcml2LT5kZWZhdWx0V2ViVmlld0dyb3Vw LmdldCgpOwogfQorCitjb25zdCBnY2hhciogd2Via2l0V2ViQ29udGV4dEdldFdlYkV4dGVuc2lv bnNEaXJlY3RvcnkoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKK3sKKyAgICByZXR1cm4gY29u dGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVjdG9yeTsKK30KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRlLmggYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5o CmluZGV4IDgxYzQ3M2M1NjFkOGMzY2MyZjM1NWFiMjQxZTgwOWIwZDg3ZmFjMDIuLjMxODgxNWI0 MDhjN2Q4OGExZTVkMmE0MmY4ZGZmNjRiNWIwOTczNDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRlLmgKKysrIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaApA QCAtNDcsNSArNDcsNyBAQCB2b2lkIHdlYmtpdFdlYkNvbnRleHRDcmVhdGVQYWdlRm9yV2ViVmll dyhXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0V2ViVmlldyosIFdlYgogdm9pZCB3ZWJraXRXZWJD b250ZXh0V2ViVmlld0Rlc3Ryb3llZChXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0V2ViVmlldyop OwogV2ViS2l0V2ViVmlldyogd2Via2l0V2ViQ29udGV4dEdldFdlYlZpZXdGb3JQYWdlKFdlYktp dFdlYkNvbnRleHQqLCBXZWJLaXQ6OldlYlBhZ2VQcm94eSopOwogV2ViS2l0V2ViVmlld0dyb3Vw KiB3ZWJraXRXZWJDb250ZXh0R2V0RGVmYXVsdFdlYlZpZXdHcm91cChXZWJLaXRXZWJDb250ZXh0 Kik7Citjb25zdCBjaGFyKiB3ZWJraXRXZWJDb250ZXh0R2V0V2ViRXh0ZW5zaW9uc0RpcmVjdG9y eShXZWJLaXRXZWJDb250ZXh0Kik7CitHVmFyaWFudCogd2Via2l0V2ViQ29udGV4dFdlYkV4dGVu c2lvbnNMb2FkZWQoV2ViS2l0V2ViQ29udGV4dCopOwogCiAjZW5kaWYgLy8gV2ViS2l0V2ViQ29u dGV4dFByaXZhdGVfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKaW5kZXggM2M0OWE2NzA3Njhj NTY1MDQyYjhmODNlOWM3NjlmMTA0MDViNzNhNC4uMWJjYWNjNjNiNWU0MGUxYTQ5ZGQ3YTk4Mzg3 NmJjMWRkMjM1NDQ1NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0CkBAIC0xMDI2LDYgKzEw MjYsNyBAQCB3ZWJraXRfd2ViX3ZpZXdfZ3JvdXBfZ2V0X3R5cGUKIFdlYktpdFdlYkV4dGVuc2lv bgogV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uCiB3ZWJraXRfd2ViX2V4dGVu c2lvbl9nZXRfcGFnZQord2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEKIAogPFNV QlNFQ1RJT04gU3RhbmRhcmQ+CiBXZWJLaXRXZWJFeHRlbnNpb25DbGFzcwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYkV4dGVuc2lvbnMu Y3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYkV4dGVu c2lvbnMuY3BwCmluZGV4IDkxY2I3YWFkYTFkY2U0M2RlOGI3ODI2Yzc1NTljYTFlNjUzOTE4ODAu LjNiYmVmZmE4YjRhNWMzYjMxZGRkZmNhMjhiZjhjY2U2N2Y0MTlmNWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJFeHRlbnNpb25zLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViRXh0 ZW5zaW9ucy5jcHAKQEAgLTE3NSw5ICsxNzUsNTEgQEAgc3RhdGljIHZvaWQgdGVzdFdlYkV4dGVu c2lvbklzb2xhdGVkV29ybGQoV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiAgICAg Z19zaWduYWxfaGFuZGxlcl9kaXNjb25uZWN0KHRlc3QtPm1fd2ViVmlldywgc2NyaXB0RGlhbG9n SUQpOwogfQogCitzdGF0aWMgYm9vbCB3ZWJFeHRlbnNpb25zTG9hZGVkU2lnbmFsVHJpZ2dlcmVk ID0gZmFsc2U7CisKK3N0YXRpYyB2b2lkIHRlc3RXZWJFeHRlbnNpb25zTG9hZGVkU2lnbmFsKFdl YlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQoreworICAgIHRlc3QtPmxvYWRIdG1sKCI8 aHRtbD48L2h0bWw+IiwgbnVsbHB0cik7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVk KCk7CisKKyAgICBnX2Fzc2VydCh3ZWJFeHRlbnNpb25zTG9hZGVkU2lnbmFsVHJpZ2dlcmVkKTsK K30KKworc3RhdGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbnNFeHRyYURhdGEoV2ViVmlld1Rlc3Qq IHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgdGVzdC0+bG9hZEh0bWwoIjxodG1sPjwvaHRt bD4iLCBudWxscHRyKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAg IEdSZWZQdHI8R0RCdXNQcm94eT4gcHJveHkgPSBhZG9wdEdSZWYoYnVzLT5jcmVhdGVQcm94eSgi b3JnLndlYmtpdC5ndGsuV2ViRXh0ZW5zaW9uVGVzdCIsCisgICAgICAgICIvb3JnL3dlYmtpdC9n dGsvV2ViRXh0ZW5zaW9uVGVzdCIgLCAib3JnLndlYmtpdC5ndGsuV2ViRXh0ZW5zaW9uVGVzdCIs IHRlc3QtPm1fbWFpbkxvb3ApKTsKKyAgICBHUmVmUHRyPEdWYXJpYW50PiByZXN1bHQgPSBhZG9w dEdSZWYoZ19kYnVzX3Byb3h5X2NhbGxfc3luYygKKyAgICAgICAgcHJveHkuZ2V0KCksCisgICAg ICAgICJHZXRFeHRyYURhdGFBc1N0cmluZyIsCisgICAgICAgIG51bGxwdHIsCisgICAgICAgIEdf REJVU19DQUxMX0ZMQUdTX05PTkUsCisgICAgICAgIC0xLCAwLCAwKSk7CisgICAgZ19hc3NlcnQo cmVzdWx0KTsKKworICAgIC8vIFRoZSB3ZWIgZXh0ZW5zaW9uIHNlcmlhbGl6ZXMgdGhlIGRhdGEg dGhhdCB3YXMgcGFzc2VkIHRvIGl0IGZyb20gdGhlCisgICAgLy8gd2ViLWV4dGVuc2lvbnMtbG9h ZGVkIHNpZ25hbCBjYWxsYmFjayB1c2luZyBnX3ZhcmlhbnRfcHJpbnQoKSBhbmQKKyAgICAvLyBz ZW5kIGl0IGJhY2sgYXMgYSBzdHJpbmcgd2hlbiBjYWxsaW5nIEdldEV4dHJhRGF0YUFzU3RyaW5n LgorICAgIGNvbnN0IGNoYXIqIGV4dHJhRGF0YVN0cmluZzsKKyAgICBnX3ZhcmlhbnRfZ2V0KHJl c3VsdC5nZXQoKSwgIigmcykiLCAmZXh0cmFEYXRhU3RyaW5nKTsKKyAgICBnX2Fzc2VydF9jbXBz dHIoZXh0cmFEYXRhU3RyaW5nLCA9PSwgIidleHRyYSBkYXRhJyIpOworfQorCitzdGF0aWMgR1Zh cmlhbnQqIHdlYkV4dGVuc2lvbnNMb2FkZWRDYWxsYmFjayhXZWJLaXRXZWJDb250ZXh0KiBjb250 ZXh0LCBncG9pbnRlcikKK3sKKyAgICB3ZWJFeHRlbnNpb25zTG9hZGVkU2lnbmFsVHJpZ2dlcmVk ID0gdHJ1ZTsKKyAgICByZXR1cm4gZ192YXJpYW50X25ldygicyIsICJleHRyYSBkYXRhIik7Cit9 CisKIHZvaWQgYmVmb3JlQWxsKCkKIHsKICAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9l eHRlbnNpb25zX2RpcmVjdG9yeSh3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwgV0VC S0lUX1RFU1RfV0VCX0VYVEVOU0lPTlNfRElSKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYmtp dF93ZWJfY29udGV4dF9nZXRfZGVmYXVsdCgpLCAid2ViLWV4dGVuc2lvbnMtbG9hZGVkIiwKKyAg ICAgICAgR19DQUxMQkFDSyh3ZWJFeHRlbnNpb25zTG9hZGVkQ2FsbGJhY2spLCBudWxscHRyKTsK KwogICAgIGJ1cyA9IG5ldyBXZWJLaXRUZXN0QnVzKCk7CiAgICAgaWYgKCFidXMtPnJ1bigpKQog ICAgICAgICByZXR1cm47CkBAIC0xODcsNiArMjI5LDggQEAgdm9pZCBiZWZvcmVBbGwoKQogICAg IFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAid2ViLXByb2Nlc3MtY3Jhc2hlZCIs IHRlc3RXZWJLaXRXZWJWaWV3UHJvY2Vzc0NyYXNoZWQpOwogICAgIFdlYlZpZXdUZXN0OjphZGQo IldlYktpdFdlYkV4dGVuc2lvbiIsICJ3aW5kb3ctb2JqZWN0LWNsZWFyZWQiLCB0ZXN0V2ViRXh0 ZW5zaW9uV2luZG93T2JqZWN0Q2xlYXJlZCk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0 V2ViRXh0ZW5zaW9uIiwgImlzb2xhdGVkLXdvcmxkIiwgdGVzdFdlYkV4dGVuc2lvbklzb2xhdGVk V29ybGQpOworICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAid2ViLWV4dGVu c2lvbnMtbG9hZGVkLXNpZ25hbCIsIHRlc3RXZWJFeHRlbnNpb25zTG9hZGVkU2lnbmFsKTsKKyAg ICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgIndlYi1leHRlbnNpb25zLWV4dHJh LWRhdGEiLCB0ZXN0V2ViRXh0ZW5zaW9uc0V4dHJhRGF0YSk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwo KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvV2Vi RXh0ZW5zaW9uVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0 cy9XZWJFeHRlbnNpb25UZXN0LmNwcAppbmRleCBhY2ZmYjRmN2E4N2Q0NTBiMWJkZDQ0NTY4NjEy YTZhNDhlYjBlZjY2Li44ZjBmNWY5ZThhMDZhNGIyOWJhY2IwMDgyNWUyNWEzZTA5ZGIwNTIwIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJFeHRl bnNpb25UZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0 cy9XZWJFeHRlbnNpb25UZXN0LmNwcApAQCAtNDEsNiArNDEsOSBAQCBzdGF0aWMgY29uc3QgY2hh ciBpbnRyb3NwZWN0aW9uWE1MW10gPQogICAgICIgICA8YXJnIHR5cGU9J3QnIG5hbWU9J3BhZ2VJ RCcgZGlyZWN0aW9uPSdpbicvPiIKICAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSdzY3JpcHQn IGRpcmVjdGlvbj0naW4nLz4iCiAgICAgIiAgPC9tZXRob2Q+IgorICAgICIgIDxtZXRob2QgbmFt ZT0nR2V0RXh0cmFEYXRhQXNTdHJpbmcnPiIKKyAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSdk YXRhJyBkaXJlY3Rpb249J291dCcvPiIKKyAgICAiICA8L21ldGhvZD4iCiAgICAgIiAgPHNpZ25h bCBuYW1lPSdEb2N1bWVudExvYWRlZCcvPiIKICAgICAiICA8c2lnbmFsIG5hbWU9J1VSSUNoYW5n ZWQnPiIKICAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSd1cmknIGRpcmVjdGlvbj0nb3V0Jy8+ IgpAQCAtMTY2LDYgKzE2OSwxNCBAQCBzdGF0aWMgdm9pZCBtZXRob2RDYWxsQ2FsbGJhY2soR0RC dXNDb25uZWN0aW9uKiBjb25uZWN0aW9uLCBjb25zdCBjaGFyKiBzZW5kZXIsCiAgICAgICAgIGdf ZGJ1c19tZXRob2RfaW52b2NhdGlvbl9yZXR1cm5fdmFsdWUoaW52b2NhdGlvbiwgMCk7CiAgICAg fSBlbHNlIGlmICghZ19zdHJjbXAwKG1ldGhvZE5hbWUsICJBYm9ydFByb2Nlc3MiKSkgewogICAg ICAgICBhYm9ydCgpOworICAgIH0gZWxzZSBpZiAoIWdfc3RyY21wMChtZXRob2ROYW1lLCAiR2V0 RXh0cmFEYXRhQXNTdHJpbmciKSkgeworICAgICAgICBHVmFyaWFudCogZXh0cmFEYXRhID0gd2Vi a2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEoV0VCS0lUX1dFQl9FWFRFTlNJT04odXNl ckRhdGEpKTsKKyAgICAgICAgaWYgKGV4dHJhRGF0YSkgeworICAgICAgICAgICAgZ2NoYXIqIGV4 dHJhRGF0YVN0cmluZyA9IGdfdmFyaWFudF9wcmludChleHRyYURhdGEsIFRSVUUpOworICAgICAg ICAgICAgZ19kYnVzX21ldGhvZF9pbnZvY2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCBn X3ZhcmlhbnRfbmV3KCIocykiLCBleHRyYURhdGFTdHJpbmcpKTsKKyAgICAgICAgICAgIGdfZnJl ZShleHRyYURhdGFTdHJpbmcpOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGdfZGJ1c19t ZXRob2RfaW52b2NhdGlvbl9yZXR1cm5fdmFsdWUoaW52b2NhdGlvbiwgZ192YXJpYW50X25ldygi KHMpIiwgIiIpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL3dlYmtpdDJtYXJzaGFsLmxpc3QgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay93ZWJraXQybWFyc2hhbC5saXN0CmluZGV4IGUxY2ZlMDcyMTZkMzliMGU5OGQ2 MDQ3NzFiZTA2Mjk2NWQyNjg3ZjIuLjNlY2Q3YmJjYWEwOTk0NzgzMzNiMmM1ZmNlMTZjMzBiNDM3 ZmRhNWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtp dDJtYXJzaGFsLmxpc3QKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvd2Vi a2l0Mm1hcnNoYWwubGlzdApAQCAtOCw2ICs4LDcgQEAgQk9PTEVBTjpPQkpFQ1QsT0JKRUNUCiBC T09MRUFOOlNUUklORwogQk9PTEVBTjpWT0lECiBPQkpFQ1Q6Vk9JRAorVkFSSUFOVDpWT0lECiBW T0lEOk9CSkVDVCxVSU5UCiBWT0lEOk9CSkVDVCxPQkpFQ1QKIFZPSUQ6T0JKRUNULFBPSU5URVIK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJ L2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9J bmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5jcHAKaW5kZXggYThkYmI1 NWRjMDNlNDA0ZDBmN2M3YTlkMGJmMGU4NTFhZTcyNzgwZS4uMzMzNTQyNTQzYjMzODIzYTk1MmEx YTAzZTZlYTMxYTk4MzQ1OWJiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5jcHAKKysrIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4 dGVuc2lvbi5jcHAKQEAgLTQzLDYgKzQzLDcgQEAgdHlwZWRlZiBIYXNoTWFwPFdlYlBhZ2UqLCBH UmVmUHRyPFdlYktpdFdlYlBhZ2U+ID4gV2ViUGFnZU1hcDsKIAogc3RydWN0IF9XZWJLaXRXZWJF eHRlbnNpb25Qcml2YXRlIHsKICAgICBXZWJQYWdlTWFwIHBhZ2VzOworICAgIEdWYXJpYW50KiBl eHRyYURhdGE7CiB9OwogCiBzdGF0aWMgZ3VpbnQgc2lnbmFsc1tMQVNUX1NJR05BTF0gPSB7IDAs IH07CkBAIC0xMTMsOSArMTE0LDEwIEBAIHN0YXRpYyB2b2lkIGRpZFJlY2VpdmVNZXNzYWdlVG9Q YWdlKFdLQnVuZGxlUmVmIGJ1bmRsZSwgV0tCdW5kbGVQYWdlUmVmIHBhZ2UsIFdLCiAgICAgICAg IHdlYmtpdFdlYlBhZ2VEaWRSZWNlaXZlTWVzc2FnZSh3ZWJQYWdlLCB0b0ltcGwobmFtZSktPnN0 cmluZygpLCAqdG9JbXBsKHN0YXRpY19jYXN0PFdLRGljdGlvbmFyeVJlZj4obWVzc2FnZUJvZHkp KSk7CiB9CiAKLVdlYktpdFdlYkV4dGVuc2lvbiogd2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKElu amVjdGVkQnVuZGxlKiBidW5kbGUpCitXZWJLaXRXZWJFeHRlbnNpb24qIHdlYmtpdFdlYkV4dGVu c2lvbkNyZWF0ZShJbmplY3RlZEJ1bmRsZSogYnVuZGxlLCBHVmFyaWFudCogZXh0cmFEYXRhKQog ewogICAgIFdlYktpdFdlYkV4dGVuc2lvbiogZXh0ZW5zaW9uID0gV0VCS0lUX1dFQl9FWFRFTlNJ T04oZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9FWFRFTlNJT04sIE5VTEwpKTsKKyAgICBl eHRlbnNpb24tPnByaXYtPmV4dHJhRGF0YSA9IGV4dHJhRGF0YTsKIAogICAgIFdLQnVuZGxlQ2xp ZW50VjEgd2tCdW5kbGVDbGllbnQgPSB7CiAgICAgICAgIHsKQEAgLTE1NSwzICsxNTcsMjAgQEAg V2ViS2l0V2ViUGFnZSogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X3BhZ2UoV2ViS2l0V2ViRXh0 ZW5zaW9uKiBleHRlbnNpb24sIGd1aW4KIAogICAgIHJldHVybiAwOwogfQorCisvKioKKyAqIHdl YmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9leHRyYV9kYXRhOgorICogQGV4dGVuc2lvbjogYSAjV2Vi S2l0V2ViRXh0ZW5zaW9uCisgKgorICogT2J0YWlucyB0aGUgZXh0cmEgZGF0YSByZXR1cm5lZCBm cm9tIGEgI1dlYktpdFdlYkNvbnRleHQ6OndlYi1leHRlbnNpb25zLWxvYWRlZAorICogc2lnbmFs IGNhbGxiYWNrLiBUaGlzIGNhbiBiZSBhbnkgYXJiaXRyYXJ5IGRhdGEgdGhhdCBjYW4gYmUgc3Rv cmVkIGluIGEKKyAqICNHVmFyaWFudC4KKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgbm9uZSk6 IGEgI0dWYXJpYW50LCBvciAlTlVMTCBpZiB0aGVyZSBpcyBubyBleHRyYQorICogICAgIGRhdGEu CisgKi8KK0dWYXJpYW50KiB3ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfZXh0cmFfZGF0YShXZWJL aXRXZWJFeHRlbnNpb24qIGV4dGVuc2lvbikKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChX RUJLSVRfSVNfV0VCX0VYVEVOU0lPTihleHRlbnNpb24pLCBudWxscHRyKTsKKyAgICByZXR1cm4g ZXh0ZW5zaW9uLT5wcml2LT5leHRyYURhdGE7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmgg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0 V2ViRXh0ZW5zaW9uLmgKaW5kZXggNjdhNGNkNTRjYTgyOGY5YmM5NzEzMjRkNGVlODgwMTVmOTJm OTA1Zi4uY2Y5MTg2YmZjZDUyNmZlOWQwZWQ3ZTcwZTA3MDczMmI3ZWY1YmNhMCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktp dFdlYkV4dGVuc2lvbi5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRC dW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaApAQCAtNjcsNiArNjcsOSBAQCBXRUJL SVRfQVBJIFdlYktpdFdlYlBhZ2UgKgogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X3BhZ2UgKFdl YktpdFdlYkV4dGVuc2lvbiAqZXh0ZW5zaW9uLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGd1aW50NjQgICAgICAgICAgICAgcGFnZV9pZCk7CiAKK1dFQktJVF9BUEkgR1ZhcmlhbnQg Kgord2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2V4dHJhX2RhdGEgKFdlYktpdFdlYkV4dGVuc2lv biAqZXh0ZW5zaW9uKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0 ZW5zaW9uUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRs ZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvblByaXZhdGUuaAppbmRleCBmZjdkMTNjYTMyN2Zk NWM3NmU2YzQ0ZDBmOGNkYzkzZTE1NjE3YTM4Li5jMDA2MDBhMmY1MDE1MDJlNTA1ZGIzYWUyMWZm YTc5MGExOTc5MGQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVj dGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZS5oCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRl bnNpb25Qcml2YXRlLmgKQEAgLTIzLDYgKzIzLDYgQEAKICNpbmNsdWRlICJJbmplY3RlZEJ1bmRs ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYkV4dGVuc2lvbi5oIgogCi1XZWJLaXRXZWJFeHRlbnNp b24qIHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZShXZWJLaXQ6OkluamVjdGVkQnVuZGxlKik7CitX ZWJLaXRXZWJFeHRlbnNpb24qIHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZShXZWJLaXQ6OkluamVj dGVkQnVuZGxlKiwgR1ZhcmlhbnQqKTsKIAogI2VuZGlmIC8vIFdlYktpdFdlYkV4dGVuc2lvblBy aXZhdGVfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2ViR3Rr RXh0ZW5zaW9uTWFuYWdlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJH dGtFeHRlbnNpb25NYW5hZ2VyLmNwcAppbmRleCBhZDdiYTk5ZmI5YTJmYzU0ZmY2ZjY5YjI5MmZh NmJlN2U0MDYxMzIwLi5jYjc4YjVhMzk4ZDkyNjQyZWFiY2I2NGVjOGJiODcyOGI3YWJjMmRmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25N YW5hZ2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRl bnNpb25NYW5hZ2VyLmNwcApAQCAtMjIsMTEgKzIyLDEzIEBACiAKICNpbmNsdWRlICJJbmplY3Rl ZEJ1bmRsZS5oIgogI2luY2x1ZGUgIldLQnVuZGxlQVBJQ2FzdC5oIgorI2luY2x1ZGUgIldLRGlj dGlvbmFyeS5oIgogI2luY2x1ZGUgIldLU3RyaW5nLmgiCiAjaW5jbHVkZSAiV0tUeXBlLmgiCiAj aW5jbHVkZSAiV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZS5oIgogI2luY2x1ZGUgPFdlYkNvcmUv RmlsZVN5c3RlbS5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4 dC9DU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCkBAIC01MSwxNCArNTMsMzIgQEAg dm9pZCBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjpzY2FuTW9kdWxlcyhjb25zdCBTdHJpbmcmIHdl YkV4dGVuc2lvbnNEaXJlY3RvcnksIFYKIAogdm9pZCBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjpp bml0aWFsaXplKFdLQnVuZGxlUmVmIGJ1bmRsZSwgV0tUeXBlUmVmIHVzZXJEYXRhKQogewotICAg IG1fZXh0ZW5zaW9uID0gYWRvcHRHUmVmKHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSh0b0ltcGwo YnVuZGxlKSkpOwotCisgICAgR1ZhcmlhbnQqIGV4dHJhRGF0YSA9IG51bGxwdHI7CiAgICAgU3Ry aW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7CisKICAgICBpZiAodXNlckRhdGEpIHsKICAgICAg ICAgQVNTRVJUKFdLR2V0VHlwZUlEKHVzZXJEYXRhKSA9PSBXS1N0cmluZ0dldFR5cGVJRCgpKTsK LSAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IHRvSW1wbChzdGF0aWNfY2FzdDxXS1N0 cmluZ1JlZj4odXNlckRhdGEpKS0+c3RyaW5nKCk7CisKKyAgICAgICAgQ1N0cmluZyBkYXRhU3Ry aW5nID0gdG9JbXBsKHN0YXRpY19jYXN0PFdLU3RyaW5nUmVmPih1c2VyRGF0YSkpLT5zdHJpbmco KS51dGY4KCk7CisgICAgICAgIEdWYXJpYW50KiB2YXJpYW50ID0KKyAgICAgICAgICAgIGdfdmFy aWFudF9wYXJzZShudWxscHRyLCBkYXRhU3RyaW5nLmRhdGEoKSwgZGF0YVN0cmluZy5kYXRhKCkg KyBkYXRhU3RyaW5nLmxlbmd0aCgpLCBudWxscHRyLCBudWxscHRyKTsKKworICAgICAgICBpZiAo dmFyaWFudCkgeworICAgICAgICAgICAgQVNTRVJUKGdfdmFyaWFudF9jaGVja19mb3JtYXRfc3Ry aW5nKHZhcmlhbnQsICIobSZzbXYpIiwgRkFMU0UpKTsKKworICAgICAgICAgICAgZ2NoYXIqIGRp cmVjdG9yeSA9IG51bGxwdHI7CisgICAgICAgICAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlhbnQsICIo bSZzbXYpIiwgJmRpcmVjdG9yeSwgJmV4dHJhRGF0YSk7CisKKyAgICAgICAgICAgIGlmIChkaXJl Y3RvcnkpCisgICAgICAgICAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IFN0cmluZzo6 ZnJvbVVURjgoZGlyZWN0b3J5KTsKKyAgICAgICAgICAgIGlmIChleHRyYURhdGEpCisgICAgICAg ICAgICAgICAgZ192YXJpYW50X3JlZl9zaW5rKGV4dHJhRGF0YSk7CisgICAgICAgICAgICBnX3Zh cmlhbnRfdW5yZWYodmFyaWFudCk7CisgICAgICAgIH0KICAgICB9CiAKKyAgICBtX2V4dGVuc2lv biA9IGFkb3B0R1JlZih3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUodG9JbXBsKGJ1bmRsZSksIGV4 dHJhRGF0YSkpOworCiAgICAgaWYgKHdlYkV4dGVuc2lvbnNEaXJlY3RvcnkuaXNOdWxsKCkpCiAg ICAgICAgIHJldHVybjsKIAo= 220378 2014-01-04 12:37:18 -0800 2014-01-16 08:55:26 -0800 Patch bug-125990-20140104223734.patch text/plain 25008 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYxMzExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZmI2NTZjYTgwZTE1MmYy YWNmNDJmMzAyOWM4YzljN2NhNTY3YmNlMy4uNTkzM2YyMWUyNWM4N2M2ZmE0OWYyZTE0ZmQxNTcx MTlhNDNlMzJjYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYzIEBACisyMDE0LTAxLTA0ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wIG9mIHRoZQorICAg ICAgICBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LCBhIEdWYXJpYW50IGNhbgorICAgICAgICBiZSByZXR1cm5lZCBieSBhIGNhbGxiYWNr IGNvbm5lY3RlZCB0byB0aGUgd2ViLWV4dGVuc2lvbnMtbG9hZGVkIHNpZ25hbC4KKyAgICAgICAg VGhlIEdWYXJpYW50IGlzIHNlcmlhbGl6ZWQsIHBhc3NlZCB0byB0aGUgaW5qZWN0ZWQgYnVuZGxl LCBhbmQgdGhlCisgICAgICAgIGluamVjdGVkIGJ1bmRsZSBkZXNlcmlhbGl6ZXMgYmFjayB0aGUg ZGF0YSwgd2hpY2ggY2FuIHRoZW4gYmUgcmV0cmlldmVkCisgICAgICAgIHVzaW5nIHRoZSB3ZWJr aXRfd2ViX2V4dGVuc2lvbl9nZXRfZXh0cmFfZGF0YSgpIG1ldGhvZC4KKworICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoKKyAgICAgICAg KGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6CisgICAgICAgIERlZmlu ZSBuZXcgY2FsbGJhY2sgZnVuY3Rpb24gd2hpY2ggc2VyaWFsaXplcyB0aGUgZGF0YSB0byBiZSBw YXNzZWQKKyAgICAgICAgdG8gdGhlIHdlYiBwcm9jZXNzLgorICAgICAgICAoYXR0YWNoSW5qZWN0 ZWRCdW5kbGVDbGllbnRUb0NvbnRleHQpOgorICAgICAgICBEZWZpbmUgdGhlIGdldEluamVjdGVk QnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSgpIGNhbGxiYWNrLCB3aGljaAorICAgICAgICBp cyB1c2VkIHRvIGVtaXQgdGhlIGluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnMgc2lnbmFsLCBhbmQg cGFzcyB0aGUKKyAgICAgICAgR1ZhcmlhbnQgcmV0dXJuZWQgYnkgdGhlIHNpZ25hbCBjYWxsYmFj ay4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAg ICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KToKKyAgICAgICAgRGVmaW5lIHRo ZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJf Y29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVu c2lvbnMgZGlyZWN0b3J5IGFzIGEgbWVtYmVyIG9mIFdlYktpdFdlYkNvbnRleHRQcml2YXRlLCB0 bworICAgICAgICBiZSBhYmxlIHRvIHJldHJpZXZlIGl0IGxhdGVyLgorICAgICAgICAod2Via2l0 V2ViQ29udGV4dFdlYkV4dGVuc2lvbnNMb2FkZWQpOgorICAgICAgICBQcml2YXRlIGZ1bmN0aW9u IHVzZWQgdG8gdHJpZ2dlciBlbWlzc2lvbiBvZiB0aGUKKyAgICAgICAgaW5pdGlhbGl6ZS13ZWIt ZXh0ZW5zaW9ucyBzaWduYWwuCisgICAgICAgICh3ZWJraXRXZWJDb250ZXh0R2V0V2ViRXh0ZW5z aW9uc0RpcmVjdG9yeSk6CisgICAgICAgIFByaXZhdGUgZnVuY3Rpb24gdG8gb2J0YWluIHRoZSB3 ZWIgZXh0ZW5zaW9ucyBkaXJlY3RvcnkgaW4gb3JkZXIgdG8KKyAgICAgICAgc2VyaWFsaXplIGl0 LCBzbyBpdCBjYW4gYmUgcGFzc2VkIHRvIHRoZSBpbmplY3RlZCBidW5kbGUuCisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaDoKKyAgICAgICAgUHJv dG90eXBlcyBvZiB0aGUgbmV3IHByaXZhdGUgZnVuY3Rpb25zLgorICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6CisgICAgICAgIEFkZCB3ZWJr aXRfd2ViX2V4dGVuc2lvbl9nZXRfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhKCkgdG8gdGhlIEFQ SSBkb2NzLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJFeHRlbnNp b25zSW5pdGlhbGl6YXRpb24uY3BwOiBBZGRlZC4KKyAgICAgICAgKHRlc3RXZWJFeHRlbnNpb25z SW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6CisgICAgICAgIChpbml0aWFsaXplV2ViRXh0ZW5zaW9u c0NhbGxiYWNrKToKKyAgICAgICAgKGJlZm9yZUFsbCk6CisgICAgICAgIChhZnRlckFsbCk6Cisg ICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mm1hcnNoYWwubGlzdDoKKyAgICAgICAg RGVmaW5lIGEgbWFyc2hhbGxlciBmb3IgdGhlIGluaXRpYWxpemUtd2ViLWV4dGVuc2lvbiBzaWdu YWwuCisgICAgICAgICogV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdl YkV4dGVuc2lvbi5jcHA6CisgICAgICAgICh3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUpOgorICAg ICAgICBBZGQgYWRkaXRpb25hbCBhcmd1bWVudCB0byBwYXNzIHRoZSBkZXNlcmlhbGl6ZWQgZXh0 cmEgZGF0YS4KKyAgICAgICAgKHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9pbml0aWFsaXphdGlv bl91c2VyX2RhdGEpOgorICAgICAgICBOZXcgbWV0aG9kIHRvIHJldHJpZXZlIHRoZSBleHRyYSBk YXRhIHBhc3NlZCB0byB0aGUgd2ViIGV4dGVuc2lvbnMKKyAgICAgICAgZnJvbSB0aGUgVUkgcHJv Y2Vzcy4KKyAgICAgICAgKiBXZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0 V2ViRXh0ZW5zaW9uLmg6CisgICAgICAgIEFkZCB3ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfaW5p dGlhbGl6YXRpb25fdXNlcl9kYXRhKCkgdG8gdGhlIEFQSS4KKyAgICAgICAgKiBXZWJQcm9jZXNz L0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZS5oOgorICAg ICAgICBDaGFuZ2VkIHByb3RvdHlwZSBvZiB3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUoKS4KKyAg ICAgICAgKiBXZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcDoKKyAgICAg ICAgKFdlYktpdDo6V2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5pdGlhbGl6ZSk6CisgICAgICAg IERlc2VyaWFsaXplIHRoZSBkYXRhIHJlY2VpdmVkIGZyb20gdGhlIFVJIHByb2Nlc3MgYW5kIHBh c3MgaXQgdG8KKyAgICAgICAgd2Via2l0V2ViSW5zcGVjdG9yQ3JlYXRlKCkuCisKIDIwMTQtMDEt MDQgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtH VEtdIFtDTWFrZV0gSW1wcm92ZSB0aGUgd2F5IHdlIGxvY2F0ZSBnb2JqZWN0LWludHJvc3BlY3Rp b24KQEAgLTMwNTksNiArMzExOSw3IEBACiAgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OnBhZ2VE aWRSZXF1ZXN0U2Nyb2xsKToKICAgICAgICAgKiBVSVByb2Nlc3MvZWZsL1BhZ2VWaWV3cG9ydENv bnRyb2xsZXJDbGllbnRFZmwuY3BwOgogICAgICAgICAoV2ViS2l0OjpQYWdlVmlld3BvcnRDb250 cm9sbGVyQ2xpZW50RWZsOjpzZXRWaWV3cG9ydFBvc2l0aW9uKToKKwogMjAxMy0xMi0xOCAgVGlt IEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJLaXQyIFZp ZXcgR2VzdHVyZXM6IE1vdmUgV2ViUHJvY2Vzcy1zaWRlIGdlb21ldHJ5IGNvbGxlY3Rpb24gaW50 byBpdHMgb3duIGNsYXNzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKaW5kZXggNWQ5ZTEw NjhmOTdkNmNkZmQyNTdhYTFmNDk5NDI2NjRjNmU2YzNkMC4uOWY0YzgwNDM0NzgwZDM5MmExYWRl MGE5MmQ4OWY3ZGY3NmEwZGRmYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcApAQCAt MTE4LDE2ICsxMTgsMjYgQEAgc3RhdGljIHZvaWQgZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0 ZWRCdW5kbGUoV0tDb250ZXh0UmVmLCBXS1N0cmluZ1JlZiBtZXNzYWcKICAgICAgICAgQVNTRVJU X05PVF9SRUFDSEVEKCk7CiB9CiAKK3N0YXRpYyBXS1R5cGVSZWYgZ2V0SW5qZWN0ZWRCdW5kbGVJ bml0aWFsaXphdGlvblVzZXJEYXRhKFdLQ29udGV4dFJlZiwgY29uc3Qgdm9pZCogY2xpZW50SW5m bykKK3sKKyAgICBHUmVmUHRyPEdWYXJpYW50PiBleHRyYURhdGEgPSB3ZWJraXRXZWJDb250ZXh0 V2ViRXh0ZW5zaW9uc0xvYWRlZChXRUJLSVRfV0VCX0NPTlRFWFQoY2xpZW50SW5mbykpOworICAg IEdSZWZQdHI8R1ZhcmlhbnQ+IGRhdGEgPSBhZG9wdEdSZWYoZ192YXJpYW50X25ldygiKG1zbXYp IiwKKyAgICAgICAgd2Via2l0V2ViQ29udGV4dEdldFdlYkV4dGVuc2lvbnNEaXJlY3RvcnkoV0VC S0lUX1dFQl9DT05URVhUKGNsaWVudEluZm8pKSwKKyAgICAgICAgZXh0cmFEYXRhLmdldCgpKSk7 CisgICAgR093blB0cjxnY2hhcj4gZGF0YVN0cmluZyhnX3ZhcmlhbnRfcHJpbnQoZGF0YS5nZXQo KSwgVFJVRSkpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxXS1R5cGVSZWY+KFdLU3RyaW5nQ3Jl YXRlV2l0aFVURjhDU3RyaW5nKGRhdGFTdHJpbmcuZ2V0KCkpKTsKK30KKwogdm9pZCBhdHRhY2hJ bmplY3RlZEJ1bmRsZUNsaWVudFRvQ29udGV4dChXZWJLaXRXZWJDb250ZXh0KiB3ZWJDb250ZXh0 KQogewogICAgIFdLQ29udGV4dEluamVjdGVkQnVuZGxlQ2xpZW50VjEgd2tJbmplY3RlZEJ1bmRs ZUNsaWVudCA9IHsKICAgICAgICAgewotICAgICAgICAgICAgMCwgLy8gdmVyc2lvbgorICAgICAg ICAgICAgMSwgLy8gdmVyc2lvbgogICAgICAgICAgICAgd2ViQ29udGV4dCwgLy8gY2xpZW50SW5m bwogICAgICAgICB9LAogICAgICAgICBkaWRSZWNlaXZlTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRs ZSwKICAgICAgICAgMCwgLy8gZGlkUmVjZWl2ZVN5bmNocm9ub3VzTWVzc2FnZUZyb21JbmplY3Rl ZEJ1bmRsZQotICAgICAgICAwIC8vIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2Vy RGF0YQorICAgICAgICBnZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEKICAg ICB9OwogICAgIFdLQ29udGV4dFNldEluamVjdGVkQnVuZGxlQ2xpZW50KHRvQVBJKHdlYmtpdFdl YkNvbnRleHRHZXRDb250ZXh0KHdlYkNvbnRleHQpKSwgJndrSW5qZWN0ZWRCdW5kbGVDbGllbnQu YmFzZSk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHQuY3BwCmluZGV4IDJiMWE1ZjM1YTgyZjRhMGY4NzkxN2U0YTBjOGFhYThi NDVhM2ZhYWYuLjg2ZDlhNWI5NjRmNTBlMDE1YjMwYzFhOWQwZTUwMDQwZmU3YWEyY2QgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRl eHQuY3BwCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiV2ViS2l0RmF2aWNvbkRhdGFiYXNl UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdEdlb2xvY2F0aW9uUHJvdmlkZXIuaCIKICNpbmNs dWRlICJXZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5oIgorI2luY2x1ZGUgIldlYktpdE1hcnNo YWwuaCIKICNpbmNsdWRlICJXZWJLaXRQbHVnaW5Qcml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0 UHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFJlcXVlc3RNYW5hZ2VyQ2xpZW50LmgiCkBAIC04 NCw2ICs4NSw3IEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIGVudW0gewogICAgIERPV05M T0FEX1NUQVJURUQsCisgICAgSU5JVElBTElaRV9XRUJfRVhURU5TSU9OUywKIAogICAgIExBU1Rf U0lHTkFMCiB9OwpAQCAtMTUzLDEyICsxNTUsMjQgQEAgc3RydWN0IF9XZWJLaXRXZWJDb250ZXh0 UHJpdmF0ZSB7CiAKICAgICBIYXNoTWFwPHVpbnQ2NF90LCBXZWJLaXRXZWJWaWV3Kj4gd2ViVmll d3M7CiAgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3R3JvdXA+IGRlZmF1bHRXZWJWaWV3R3JvdXA7 CisKKyAgICBDU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7CiB9OwogCiBzdGF0aWMgZ3Vp bnQgc2lnbmFsc1tMQVNUX1NJR05BTF0gPSB7IDAsIH07CiAKIFdFQktJVF9ERUZJTkVfVFlQRShX ZWJLaXRXZWJDb250ZXh0LCB3ZWJraXRfd2ViX2NvbnRleHQsIEdfVFlQRV9PQkpFQ1QpCiAKK3N0 YXRpYyBnYm9vbGVhbiBpbml0aWFsaXplV2ViRXh0ZW5zaW9uc1NpZ25hbEFjY3VtdWxhdG9yKEdT aWduYWxJbnZvY2F0aW9uSGludCosCisgICAgR1ZhbHVlKiByZXR1cm5BY2N1bXVsYXRvciwgY29u c3QgR1ZhbHVlKiBoYW5kbGVyUmV0dXJuLCBncG9pbnRlcikKK3sKKyAgICBpZiAoaGFuZGxlclJl dHVybikgeworICAgICAgICBnX3ZhbHVlX2NvcHkoaGFuZGxlclJldHVybiwgcmV0dXJuQWNjdW11 bGF0b3IpOworICAgICAgICByZXR1cm4gRkFMU0U7CisgICAgfQorICAgIHJldHVybiBUUlVFOwor fQorCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX2NvbnRleHRfY2xhc3NfaW5pdChXZWJLaXRXZWJD b250ZXh0Q2xhc3MqIHdlYkNvbnRleHRDbGFzcykKIHsKICAgICBHT2JqZWN0Q2xhc3MqIGdPYmpl Y3RDbGFzcyA9IEdfT0JKRUNUX0NMQVNTKHdlYkNvbnRleHRDbGFzcyk7CkBAIC0xNzgsNiArMTky LDM2IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KFdlYktpdFdl YkNvbnRleHRDbGFzcyogd2ViQ29udGV4dENsYXNzCiAgICAgICAgICAgICAgICAgICAgICBnX2Nj bG9zdXJlX21hcnNoYWxfVk9JRF9fT0JKRUNULAogICAgICAgICAgICAgICAgICAgICAgR19UWVBF X05PTkUsIDEsCiAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfVFlQRV9ET1dOTE9BRCk7CisK KyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0Ojppbml0aWFsaXplLXdlYi1leHRlbnNp b25zOgorICAgICAqIEBjb250ZXh0OiB0aGUgI1dlYktpdFdlYkNvbnRleHQKKyAgICAgKgorICAg ICAqIFRoaXMgc2lnbmFsIGlzIGVtaXR0ZWQgd2hlbiBhIG5ldyB3ZWIgcHJvY2VzcyBpcyBhYm91 dCB0byBiZSBsYXVuY2hlZAorICAgICAqIGFuZCBhbGxvd3MgdG8gcmV0dXJuIGEgI0dWYXJpYW50 IHdpdGggYXJiaXRyYXJ5IGRhdGEsIHdoaWNoIHdpbGwgYmUKKyAgICAgKiBwYXNzZWQgdG8gdGhl IHdlYiBleHRlbnNpb25zIHdoZW4gdGhleSBhcmUgaW5pdGlhbGl6ZWQgaW4gdGhlIG5ldworICAg ICAqIHdlYiBwcm9jZXNzLiBXZWIgZXh0ZW5zaW9ucyBjYW4gcmV0cmlldmUgdGhpcyBkYXRhIHVz aW5nCisgICAgICogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2luaXRpYWxpemF0aW9uX3VzZXJf ZGF0YSgpLgorICAgICAqCisgICAgICogRW1pc3Npb24gb2YgdGhlIHNpZ25hbCBpcyBzdG9wcGVk IGFmdGVyIGEgc2lnbmFsIGhhbmRsZXIgcmV0dXJucyBhCisgICAgICogbm9uICVOVUxMIHZhbHVl LCBhbmQgdGhhdCB2YWx1ZSBpcyB0aGUgb25lIHdoaWNoIHdpbGwgYmUgcGFzc2VkIHRvCisgICAg ICogdGhlIHdlYiBleHRlbnNpb25zLgorICAgICAqCisgICAgICogUmV0dXJuczogKGFsbG93LW5v bmUpICh0cmFuc2ZlciBub25lKTogYSAjR1ZhcmlhbnQgd2l0aCBhcmJpdHJhcnkKKyAgICAgKiAg ICAgZGF0YSwgb3IgJU5VTEwuCisgICAgICoKKyAgICAgKiBTaW5jZTogMi40CisgICAgICovCisg ICAgc2lnbmFsc1tJTklUSUFMSVpFX1dFQl9FWFRFTlNJT05TXSA9CisgICAgICAgIGdfc2lnbmFs X25ldygiaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9ucyIsCisgICAgICAgICAgICBHX1RZUEVfRlJP TV9DTEFTUyhnT2JqZWN0Q2xhc3MpLAorICAgICAgICAgICAgR19TSUdOQUxfUlVOX0xBU1QsCisg ICAgICAgICAgICAwLAorICAgICAgICAgICAgaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxB Y2N1bXVsYXRvciwKKyAgICAgICAgICAgIG51bGxwdHIsCisgICAgICAgICAgICB3ZWJraXRfbWFy c2hhbF9WQVJJQU5UX19WT0lELAorICAgICAgICAgICAgR19UWVBFX1ZBUklBTlQsCisgICAgICAg ICAgICAwKTsKIH0KIAogc3RhdGljIENTdHJpbmcgaW5qZWN0ZWRCdW5kbGVEaXJlY3RvcnkoKQpA QCAtNzgzLDggKzgyNyw3IEBAIHZvaWQgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5z aW9uc19kaXJlY3RvcnkoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwKICAgICBnX3JldHVybl9p Zl9mYWlsKFdFQktJVF9JU19XRUJfQ09OVEVYVChjb250ZXh0KSk7CiAgICAgZ19yZXR1cm5faWZf ZmFpbChkaXJlY3RvcnkpOwogCi0gICAgLy8gV2UgcGFzcyB0aGUgYWRkaXRpb25hbCB3ZWIgZXh0 ZW5zaW9ucyBkaXJlY3RvcnkgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSBhcyBpbml0aWFsaXphdGlv biB1c2VyIGRhdGEuCi0gICAgY29udGV4dC0+cHJpdi0+Y29udGV4dC0+c2V0SW5qZWN0ZWRCdW5k bGVJbml0aWFsaXphdGlvblVzZXJEYXRhKEFQSTo6U3RyaW5nOjpjcmVhdGUoV2ViQ29yZTo6Zmls ZW5hbWVUb1N0cmluZyhkaXJlY3RvcnkpKSk7CisgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5z aW9uc0RpcmVjdG9yeSA9IGRpcmVjdG9yeTsKIH0KIAogLyoqCkBAIC04NzIsNiArOTE1LDEzIEBA IHZvaWQgd2Via2l0V2ViQ29udGV4dERvd25sb2FkU3RhcnRlZChXZWJLaXRXZWJDb250ZXh0KiBj b250ZXh0LCBXZWJLaXREb3dubG9hZCoKICAgICBnX3NpZ25hbF9lbWl0KGNvbnRleHQsIHNpZ25h bHNbRE9XTkxPQURfU1RBUlRFRF0sIDAsIGRvd25sb2FkKTsKIH0KIAorR1ZhcmlhbnQqIHdlYmtp dFdlYkNvbnRleHRXZWJFeHRlbnNpb25zTG9hZGVkKFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQp Cit7CisgICAgR1ZhcmlhbnQqIHJldHVybl92YWx1ZTsKKyAgICBnX3NpZ25hbF9lbWl0KGNvbnRl eHQsIHNpZ25hbHNbSU5JVElBTElaRV9XRUJfRVhURU5TSU9OU10sIDAsICZyZXR1cm5fdmFsdWUp OworICAgIHJldHVybiByZXR1cm5fdmFsdWU7Cit9CisKIFdlYkNvbnRleHQqIHdlYmtpdFdlYkNv bnRleHRHZXRDb250ZXh0KFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQpCiB7CiAgICAgZ19hc3Nl cnQoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKQEAgLTkzNywzICs5ODcsOCBAQCBX ZWJLaXRXZWJWaWV3R3JvdXAqIHdlYmtpdFdlYkNvbnRleHRHZXREZWZhdWx0V2ViVmlld0dyb3Vw KFdlYktpdFdlYkNvbnRleHQqIGNvbgogewogICAgIHJldHVybiBjb250ZXh0LT5wcml2LT5kZWZh dWx0V2ViVmlld0dyb3VwLmdldCgpOwogfQorCitjb25zdCBnY2hhciogd2Via2l0V2ViQ29udGV4 dEdldFdlYkV4dGVuc2lvbnNEaXJlY3RvcnkoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKK3sK KyAgICByZXR1cm4gY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVjdG9yeS5kYXRhKCk7 Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJDb250ZXh0UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViQ29udGV4dFByaXZhdGUuaAppbmRleCA4MWM0NzNjNTYxZDhjM2NjMmYzNTVhYjI0MWU4 MDliMGQ4N2ZhYzAyLi4zMTg4MTViNDA4YzdkODhhMWU1ZDJhNDJmOGRmZjY0YjViMDk3MzQ3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250 ZXh0UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYkNvbnRleHRQcml2YXRlLmgKQEAgLTQ3LDUgKzQ3LDcgQEAgdm9pZCB3ZWJraXRXZWJDb250 ZXh0Q3JlYXRlUGFnZUZvcldlYlZpZXcoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZpZXcq LCBXZWIKIHZvaWQgd2Via2l0V2ViQ29udGV4dFdlYlZpZXdEZXN0cm95ZWQoV2ViS2l0V2ViQ29u dGV4dCosIFdlYktpdFdlYlZpZXcqKTsKIFdlYktpdFdlYlZpZXcqIHdlYmtpdFdlYkNvbnRleHRH ZXRXZWJWaWV3Rm9yUGFnZShXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0OjpXZWJQYWdlUHJveHkq KTsKIFdlYktpdFdlYlZpZXdHcm91cCogd2Via2l0V2ViQ29udGV4dEdldERlZmF1bHRXZWJWaWV3 R3JvdXAoV2ViS2l0V2ViQ29udGV4dCopOworY29uc3QgY2hhciogd2Via2l0V2ViQ29udGV4dEdl dFdlYkV4dGVuc2lvbnNEaXJlY3RvcnkoV2ViS2l0V2ViQ29udGV4dCopOworR1ZhcmlhbnQqIHdl YmtpdFdlYkNvbnRleHRXZWJFeHRlbnNpb25zTG9hZGVkKFdlYktpdFdlYkNvbnRleHQqKTsKIAog I2VuZGlmIC8vIFdlYktpdFdlYkNvbnRleHRQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMu dHh0CmluZGV4IDA5MGU5MWU2ZGU2MWM0NmYzM2I4OGMxYzhkNDVmYmI3YzE3MjZiMjguLjgwMWM5 ZGVlZGYzZWI5Zjk2YjRmY2RhMDgxZDU4MDk1YTRkNThlNjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rp b25zLnR4dApAQCAtMTAyNyw2ICsxMDI3LDcgQEAgd2Via2l0X3dlYl92aWV3X2dyb3VwX2dldF90 eXBlCiBXZWJLaXRXZWJFeHRlbnNpb24KIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVGdW5j dGlvbgogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X3BhZ2UKK3dlYmtpdF93ZWJfZXh0ZW5zaW9u X2dldF9pbml0aWFsaXphdGlvbl91c2VyX2RhdGEKIAogPFNVQlNFQ1RJT04gU3RhbmRhcmQ+CiBX ZWJLaXRXZWJFeHRlbnNpb25DbGFzcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvdGVzdHMvR05VbWFrZWZpbGUuYW0gYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay90ZXN0cy9HTlVtYWtlZmlsZS5hbQppbmRleCAxNWVjN2QxODdmYTg0YmY5ZGMx MjNhMmFmNDczNWJmNDY4MWVmM2EwLi5hMjIxZWNjNmFiOGNlMzAzMjI5NjM1Y2YyMTM1NmIzMzlk NzA1ODM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0 cy9HTlVtYWtlZmlsZS5hbQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90 ZXN0cy9HTlVtYWtlZmlsZS5hbQpAQCAtMTcsNiArMTcsNyBAQCBURVNUX1BST0dTICs9IFwKIAlQ cm9ncmFtcy9XZWJLaXQyR09iamVjdEFQSVRlc3RzL1Rlc3RTU0wgXAogCVByb2dyYW1zL1dlYktp dDJHT2JqZWN0QVBJVGVzdHMvVGVzdFVJQ2xpZW50IFwKIAlQcm9ncmFtcy9XZWJLaXQyR09iamVj dEFQSVRlc3RzL1Rlc3RXZWJFeHRlbnNpb25zIFwKKwlQcm9ncmFtcy9XZWJLaXQyR09iamVjdEFQ SVRlc3RzL1Rlc3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb24gXAogCVByb2dyYW1zL1dlYktp dDJHT2JqZWN0QVBJVGVzdHMvVGVzdFdlYktpdFZlcnNpb24gXAogCVByb2dyYW1zL1dlYktpdDJH T2JqZWN0QVBJVGVzdHMvVGVzdFdlYktpdEZhdmljb25EYXRhYmFzZSBcCiAJUHJvZ3JhbXMvV2Vi S2l0MkdPYmplY3RBUElUZXN0cy9UZXN0V2ViS2l0RmluZENvbnRyb2xsZXIgXApAQCAtMjkzLDYg KzI5NCwxMiBAQCBQcm9ncmFtc19XZWJLaXQyR09iamVjdEFQSVRlc3RzX1Rlc3RXZWJFeHRlbnNp b25zX0NQUEZMQUdTID0gJCh3ZWJraXQyX3Rlc3RzX2NwcAogUHJvZ3JhbXNfV2ViS2l0MkdPYmpl Y3RBUElUZXN0c19UZXN0V2ViRXh0ZW5zaW9uc19MREFERCA9ICQod2Via2l0Ml90ZXN0c19sZGFk ZCkKIFByb2dyYW1zX1dlYktpdDJHT2JqZWN0QVBJVGVzdHNfVGVzdFdlYkV4dGVuc2lvbnNfTERG TEFHUyA9ICQod2Via2l0Ml90ZXN0c19sZGZsYWdzKQogCitQcm9ncmFtc19XZWJLaXQyR09iamVj dEFQSVRlc3RzX1Rlc3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb25fU09VUkNFUyA9IFwKKyAg ICAgICAgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYkV4dGVu c2lvbnNJbml0aWFsaXphdGlvbi5jcHAKK1Byb2dyYW1zX1dlYktpdDJHT2JqZWN0QVBJVGVzdHNf VGVzdFdlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlvbl9DUFBGTEFHUyA9ICQod2Via2l0Ml90ZXN0 c19jcHBmbGFncykKK1Byb2dyYW1zX1dlYktpdDJHT2JqZWN0QVBJVGVzdHNfVGVzdFdlYkV4dGVu c2lvbnNJbml0aWFsaXphdGlvbl9MREFERCA9ICQod2Via2l0Ml90ZXN0c19sZGFkZCkKK1Byb2dy YW1zX1dlYktpdDJHT2JqZWN0QVBJVGVzdHNfVGVzdFdlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlv bl9MREZMQUdTID0gJCh3ZWJraXQyX3Rlc3RzX2xkZmxhZ3MpCisKIFByb2dyYW1zX1dlYktpdDJH T2JqZWN0QVBJVGVzdHNfVGVzdFdlYktpdFdlYlZpZXdHcm91cF9TT1VSQ0VTID0gXAogICAgICAg ICBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViS2l0V2ViVmll d0dyb3VwLmNwcAogUHJvZ3JhbXNfV2ViS2l0MkdPYmplY3RBUElUZXN0c19UZXN0V2ViS2l0V2Vi Vmlld0dyb3VwX0NQUEZMQUdTID0gJCh3ZWJraXQyX3Rlc3RzX2NwcGZsYWdzKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYkV4dGVuc2lv bnMuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYkV4 dGVuc2lvbnMuY3BwCmluZGV4IDkxY2I3YWFkYTFkY2U0M2RlOGI3ODI2Yzc1NTljYTFlNjUzOTE4 ODAuLmM4MzUzNjJmYTlkN2E4MzYwNTAzNzM2YmJjZjI2ZDFhOGQwNjIwZjggMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJFeHRlbnNpb25z LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2Vi RXh0ZW5zaW9ucy5jcHAKQEAgLTE3OCw2ICsxNzgsNyBAQCBzdGF0aWMgdm9pZCB0ZXN0V2ViRXh0 ZW5zaW9uSXNvbGF0ZWRXb3JsZChXZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKIHZv aWQgYmVmb3JlQWxsKCkKIHsKICAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNp b25zX2RpcmVjdG9yeSh3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwgV0VCS0lUX1RF U1RfV0VCX0VYVEVOU0lPTlNfRElSKTsKKwogICAgIGJ1cyA9IG5ldyBXZWJLaXRUZXN0QnVzKCk7 CiAgICAgaWYgKCFidXMtPnJ1bigpKQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViRXh0ZW5zaW9uc0luaXRp YWxpemF0aW9uLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rl c3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb24uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVkM2YyMGQ4MWI5 MTZhYzBiYzg4NzcyZTU5NmI1Mzg1MmZlZTdlMmEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViRXh0ZW5zaW9uc0luaXRpYWxp emF0aW9uLmNwcApAQCAtMCwwICsxLDc5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE0IEln YWxpYSBTLkwuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIsMSBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICog YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5v dCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJXZWJLaXRUZXN0QnVz LmgiCisjaW5jbHVkZSAiV2ViVmlld1Rlc3QuaCIKKyNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVm UHRyLmg+CisKK3N0YXRpYyBXZWJLaXRUZXN0QnVzKiBidXM7CitzdGF0aWMgYm9vbCBpbml0aWFs aXplV2ViRXh0ZW5zaW9uc1NpZ25hbFRyaWdnZXJlZCA9IGZhbHNlOworc3RhdGljIGdpbnQgaW5p dGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxIYW5kbGVySWQgPSAtMTsKKworc3RhdGljIHZvaWQg dGVzdFdlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlvblVzZXJEYXRhKFdlYlZpZXdUZXN0KiB0ZXN0 LCBnY29uc3Rwb2ludGVyKQoreworICAgIHRlc3QtPmxvYWRIdG1sKCI8aHRtbD48L2h0bWw+Iiwg bnVsbHB0cik7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisKKyAgICBnX2Fz c2VydChpbml0aWFsaXplV2ViRXh0ZW5zaW9uc1NpZ25hbFRyaWdnZXJlZCk7CisKKyAgICBHUmVm UHRyPEdEQnVzUHJveHk+IHByb3h5ID0gYWRvcHRHUmVmKGJ1cy0+Y3JlYXRlUHJveHkoIm9yZy53 ZWJraXQuZ3RrLldlYkV4dGVuc2lvblRlc3QiLAorICAgICAgICAiL29yZy93ZWJraXQvZ3RrL1dl YkV4dGVuc2lvblRlc3QiICwgIm9yZy53ZWJraXQuZ3RrLldlYkV4dGVuc2lvblRlc3QiLCB0ZXN0 LT5tX21haW5Mb29wKSk7CisgICAgR1JlZlB0cjxHVmFyaWFudD4gcmVzdWx0ID0gYWRvcHRHUmVm KGdfZGJ1c19wcm94eV9jYWxsX3N5bmMoCisgICAgICAgIHByb3h5LmdldCgpLAorICAgICAgICAi R2V0RXh0cmFEYXRhQXNTdHJpbmciLAorICAgICAgICBudWxscHRyLAorICAgICAgICBHX0RCVVNf Q0FMTF9GTEFHU19OT05FLAorICAgICAgICAtMSwgMCwgMCkpOworICAgIGdfYXNzZXJ0KHJlc3Vs dCk7CisKKyAgICAvLyBUaGUgd2ViIGV4dGVuc2lvbiBzZXJpYWxpemVzIHRoZSBkYXRhIHRoYXQg d2FzIHBhc3NlZCB0byBpdCBmcm9tIHRoZQorICAgIC8vIHdlYi1leHRlbnNpb25zLWxvYWRlZCBz aWduYWwgY2FsbGJhY2sgdXNpbmcgZ192YXJpYW50X3ByaW50KCkgYW5kCisgICAgLy8gc2VuZCBp dCBiYWNrIGFzIGEgc3RyaW5nIHdoZW4gY2FsbGluZyBHZXRFeHRyYURhdGFBc1N0cmluZy4KKyAg ICBjb25zdCBjaGFyKiBleHRyYURhdGFTdHJpbmc7CisgICAgZ192YXJpYW50X2dldChyZXN1bHQu Z2V0KCksICIoJnMpIiwgJmV4dHJhRGF0YVN0cmluZyk7CisgICAgZ19hc3NlcnRfY21wc3RyKGV4 dHJhRGF0YVN0cmluZywgPT0sICInZXh0cmEgZGF0YSciKTsKK30KKworc3RhdGljIEdWYXJpYW50 KiBpbml0aWFsaXplV2ViRXh0ZW5zaW9uc0NhbGxiYWNrKFdlYktpdFdlYkNvbnRleHQqIGNvbnRl eHQsIGdwb2ludGVyKQoreworICAgIGluaXRpYWxpemVXZWJFeHRlbnNpb25zU2lnbmFsVHJpZ2dl cmVkID0gdHJ1ZTsKKyAgICByZXR1cm4gZ192YXJpYW50X25ldygicyIsICJleHRyYSBkYXRhIik7 Cit9CisKK3ZvaWQgYmVmb3JlQWxsKCkKK3sKKyAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dl Yl9leHRlbnNpb25zX2RpcmVjdG9yeSh3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwg V0VCS0lUX1RFU1RfV0VCX0VYVEVOU0lPTlNfRElSKTsKKyAgICBpbml0aWFsaXplV2ViRXh0ZW5z aW9uc1NpZ25hbEhhbmRsZXJJZCA9IGdfc2lnbmFsX2Nvbm5lY3Qod2Via2l0X3dlYl9jb250ZXh0 X2dldF9kZWZhdWx0KCksCisgICAgICAgICJpbml0aWFsaXplLXdlYi1leHRlbnNpb25zIiwgR19D QUxMQkFDSyhpbml0aWFsaXplV2ViRXh0ZW5zaW9uc0NhbGxiYWNrKSwgbnVsbHB0cik7CisKKyAg ICBidXMgPSBuZXcgV2ViS2l0VGVzdEJ1cygpOworICAgIGlmICghYnVzLT5ydW4oKSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJ3ZWIt ZXh0ZW5zaW9ucy1pbml0aWFsaXphdGlvbi11c2VyLWRhdGEiLCB0ZXN0V2ViRXh0ZW5zaW9uc0lu aXRpYWxpemF0aW9uVXNlckRhdGEpOworfQorCit2b2lkIGFmdGVyQWxsKCkKK3sKKyAgICBpZiAo aW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxIYW5kbGVySWQgIT0gLTEpCisgICAgICAgIGdf c2lnbmFsX2hhbmRsZXJfZGlzY29ubmVjdCh3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQo KSwgaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxIYW5kbGVySWQpOworICAgIGRlbGV0ZSBi dXM7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0 cy9XZWJFeHRlbnNpb25UZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L3Rlc3RzL1dlYkV4dGVuc2lvblRlc3QuY3BwCmluZGV4IDAyMTJlMmIyN2NlMTBiMjI5NTQ3MjNk YzA1MjZlZjczMzhhNTNlOTguLmFlOTg3OWQxNTZmNmU4Y2M2YWI5ZjNhYWQ1YTNhYzFmNWMyMDM4 ZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dl YkV4dGVuc2lvblRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L3Rlc3RzL1dlYkV4dGVuc2lvblRlc3QuY3BwCkBAIC00NSw2ICs0NSw5IEBAIHN0YXRpYyBjb25z dCBjaGFyIGludHJvc3BlY3Rpb25YTUxbXSA9CiAgICAgIiAgIDxhcmcgdHlwZT0ndCcgbmFtZT0n cGFnZUlEJyBkaXJlY3Rpb249J2luJy8+IgogICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9J3Nj cmlwdCcgZGlyZWN0aW9uPSdpbicvPiIKICAgICAiICA8L21ldGhvZD4iCisgICAgIiAgPG1ldGhv ZCBuYW1lPSdHZXRFeHRyYURhdGFBc1N0cmluZyc+IgorICAgICIgICA8YXJnIHR5cGU9J3MnIG5h bWU9J2RhdGEnIGRpcmVjdGlvbj0nb3V0Jy8+IgorICAgICIgIDwvbWV0aG9kPiIKICAgICAiICA8 c2lnbmFsIG5hbWU9J0RvY3VtZW50TG9hZGVkJy8+IgogICAgICIgIDxzaWduYWwgbmFtZT0nVVJJ Q2hhbmdlZCc+IgogICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9J3VyaScgZGlyZWN0aW9uPSdv dXQnLz4iCkBAIC0yMTIsNiArMjE1LDEzIEBAIHN0YXRpYyB2b2lkIG1ldGhvZENhbGxDYWxsYmFj ayhHREJ1c0Nvbm5lY3Rpb24qIGNvbm5lY3Rpb24sIGNvbnN0IGNoYXIqIHNlbmRlciwKICAgICAg ICAgZ19kYnVzX21ldGhvZF9pbnZvY2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCAwKTsK ICAgICB9IGVsc2UgaWYgKCFnX3N0cmNtcDAobWV0aG9kTmFtZSwgIkFib3J0UHJvY2VzcyIpKSB7 CiAgICAgICAgIGFib3J0KCk7CisgICAgfSBlbHNlIGlmICghZ19zdHJjbXAwKG1ldGhvZE5hbWUs ICJHZXRFeHRyYURhdGFBc1N0cmluZyIpKSB7CisgICAgICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IGlu aXRpYWxpemF0aW9uVXNlckRhdGEgPSBhZG9wdEdSZWYod2Via2l0X3dlYl9leHRlbnNpb25fZ2V0 X2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YShXRUJLSVRfV0VCX0VYVEVOU0lPTih1c2VyRGF0YSkp KTsKKyAgICAgICAgaWYgKHVzZXJEYXRhKSB7CisgICAgICAgICAgICBHT3duUHRyPGdjaGFyPiBp bml0aWFsaXphdGlvblVzZXJEYXRhU3RyaW5nKGdfdmFyaWFudF9wcmludChpbml0aWFsaXphdGlv blVzZXJEYXRhLmdldCgpLCBUUlVFKSk7CisgICAgICAgICAgICBnX2RidXNfbWV0aG9kX2ludm9j YXRpb25fcmV0dXJuX3ZhbHVlKGludm9jYXRpb24sIGdfdmFyaWFudF9uZXcoIihzKSIsIGluaXRp YWxpemF0aW9uVXNlckRhdGFTdHJpbmcuZ2V0KCkpKTsKKyAgICAgICAgfSBlbHNlCisgICAgICAg ICAgICBnX2RidXNfbWV0aG9kX2ludm9jYXRpb25fcmV0dXJuX3ZhbHVlKGludm9jYXRpb24sIGdf dmFyaWFudF9uZXcoIihzKSIsICIiKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay93ZWJraXQybWFyc2hhbC5saXN0IGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mm1hcnNoYWwubGlzdAppbmRleCBlMWNmZTA3 MjE2ZDM5YjBlOThkNjA0NzcxYmUwNjI5NjVkMjY4N2YyLi4zZWNkN2JiY2FhMDk5NDc4MzMzYjJj NWZjZTE2YzMwYjQzN2ZkYTVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay93ZWJraXQybWFyc2hhbC5saXN0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL3dlYmtpdDJtYXJzaGFsLmxpc3QKQEAgLTgsNiArOCw3IEBAIEJPT0xFQU46T0JK RUNULE9CSkVDVAogQk9PTEVBTjpTVFJJTkcKIEJPT0xFQU46Vk9JRAogT0JKRUNUOlZPSUQKK1ZB UklBTlQ6Vk9JRAogVk9JRDpPQkpFQ1QsVUlOVAogVk9JRDpPQkpFQ1QsT0JKRUNUCiBWT0lEOk9C SkVDVCxQT0lOVEVSCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVj dGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmNwcCBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uY3Bw CmluZGV4IGE4ZGJiNTVkYzAzZTQwNGQwZjdjN2E5ZDBiZjBlODUxYWU3Mjc4MGUuLmIwYThhMTU5 ZWIwZDE3NmRiNGE3ODA4MGNmYjMyYjBiYzA5ZGJkYTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24u Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0 ay9XZWJLaXRXZWJFeHRlbnNpb24uY3BwCkBAIC00Myw2ICs0Myw3IEBAIHR5cGVkZWYgSGFzaE1h cDxXZWJQYWdlKiwgR1JlZlB0cjxXZWJLaXRXZWJQYWdlPiA+IFdlYlBhZ2VNYXA7CiAKIHN0cnVj dCBfV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZSB7CiAgICAgV2ViUGFnZU1hcCBwYWdlczsKKyAg ICBHUmVmUHRyPEdWYXJpYW50PiBleHRyYURhdGE7CiB9OwogCiBzdGF0aWMgZ3VpbnQgc2lnbmFs c1tMQVNUX1NJR05BTF0gPSB7IDAsIH07CkBAIC0xMTMsOSArMTE0LDEwIEBAIHN0YXRpYyB2b2lk IGRpZFJlY2VpdmVNZXNzYWdlVG9QYWdlKFdLQnVuZGxlUmVmIGJ1bmRsZSwgV0tCdW5kbGVQYWdl UmVmIHBhZ2UsIFdLCiAgICAgICAgIHdlYmtpdFdlYlBhZ2VEaWRSZWNlaXZlTWVzc2FnZSh3ZWJQ YWdlLCB0b0ltcGwobmFtZSktPnN0cmluZygpLCAqdG9JbXBsKHN0YXRpY19jYXN0PFdLRGljdGlv bmFyeVJlZj4obWVzc2FnZUJvZHkpKSk7CiB9CiAKLVdlYktpdFdlYkV4dGVuc2lvbiogd2Via2l0 V2ViRXh0ZW5zaW9uQ3JlYXRlKEluamVjdGVkQnVuZGxlKiBidW5kbGUpCitXZWJLaXRXZWJFeHRl bnNpb24qIHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZShJbmplY3RlZEJ1bmRsZSogYnVuZGxlLCBH UmVmUHRyPEdWYXJpYW50PiYgZXh0cmFEYXRhKQogewogICAgIFdlYktpdFdlYkV4dGVuc2lvbiog ZXh0ZW5zaW9uID0gV0VCS0lUX1dFQl9FWFRFTlNJT04oZ19vYmplY3RfbmV3KFdFQktJVF9UWVBF X1dFQl9FWFRFTlNJT04sIE5VTEwpKTsKKyAgICBleHRlbnNpb24tPnByaXYtPmV4dHJhRGF0YSA9 IGV4dHJhRGF0YTsKIAogICAgIFdLQnVuZGxlQ2xpZW50VjEgd2tCdW5kbGVDbGllbnQgPSB7CiAg ICAgICAgIHsKQEAgLTE1NSwzICsxNTcsMjIgQEAgV2ViS2l0V2ViUGFnZSogd2Via2l0X3dlYl9l eHRlbnNpb25fZ2V0X3BhZ2UoV2ViS2l0V2ViRXh0ZW5zaW9uKiBleHRlbnNpb24sIGd1aW4KIAog ICAgIHJldHVybiAwOwogfQorCisvKioKKyAqIHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9pbml0 aWFsaXphdGlvbl91c2VyX2RhdGE6CisgKiBAZXh0ZW5zaW9uOiBhICNXZWJLaXRXZWJFeHRlbnNp b24KKyAqCisgKiBPYnRhaW5zIHRoZSBpbml0aWFsaXphdGlvbiB1c2VyIGRhdGEgcmV0dXJuZWQg Zm9yIHRoZQorICogI1dlYktpdFdlYkNvbnRleHQ6OndlYi1leHRlbnNpb25zLWxvYWRlZCBzaWdu YWwuIFRoaXMgY2FuIGJlIGFueQorICogYXJiaXRyYXJ5IGRhdGEgdGhhdCBjYW4gYmUgc3RvcmVk IGluIGEgI0dWYXJpYW50LgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBub25lKTogYSAjR1Zh cmlhbnQsIG9yICVOVUxMIGlmIHRoZXJlIGlzIG5vIGV4dHJhCisgKiAgICAgZGF0YS4KKyAqCisg KiBTaW5jZTogMC4yNAorICovCitHVmFyaWFudCogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X2lu aXRpYWxpemF0aW9uX3VzZXJfZGF0YShXZWJLaXRXZWJFeHRlbnNpb24qIGV4dGVuc2lvbikKK3sK KyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX0VYVEVOU0lPTihleHRlbnNp b24pLCBudWxscHRyKTsKKyAgICByZXR1cm4gZXh0ZW5zaW9uLT5wcml2LT5leHRyYURhdGEuZ2V0 KCk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVu ZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmgKaW5kZXggNjdh NGNkNTRjYTgyOGY5YmM5NzEzMjRkNGVlODgwMTVmOTJmOTA1Zi4uMTM3YmMxMTBiODAyZjdiYzdi MTkwODNiOWZkMWZkODEwYzMxOTMxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5oCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJF eHRlbnNpb24uaApAQCAtNjEsMTEgKzYxLDE0IEBAIHN0cnVjdCBfV2ViS2l0V2ViRXh0ZW5zaW9u Q2xhc3MgewogfTsKIAogV0VCS0lUX0FQSSBHVHlwZQotd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0 X3R5cGUgKHZvaWQpOword2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X3R5cGUgICAgICAgICAgICAg ICAgICAgICAodm9pZCk7CiAKIFdFQktJVF9BUEkgV2ViS2l0V2ViUGFnZSAqCi13ZWJraXRfd2Vi X2V4dGVuc2lvbl9nZXRfcGFnZSAoV2ViS2l0V2ViRXh0ZW5zaW9uICpleHRlbnNpb24sCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3VpbnQ2NCAgICAgICAgICAgICBwYWdlX2lkKTsK K3dlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9wYWdlICAgICAgICAgICAgICAgICAgICAgKFdlYktp dFdlYkV4dGVuc2lvbiAqZXh0ZW5zaW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZ3VpbnQ2NCAgICAgICAgICAgICBwYWdlX2lkKTsKKworV0VC S0lUX0FQSSBHVmFyaWFudCAqCit3ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfaW5pdGlhbGl6YXRp b25fdXNlcl9kYXRhIChXZWJLaXRXZWJFeHRlbnNpb24gKmV4dGVuc2lvbik7CiAKIEdfRU5EX0RF Q0xTCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5k bGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0 ZS5oCmluZGV4IGZmN2QxM2NhMzI3ZmQ1Yzc2ZTZjNDRkMGY4Y2RjOTNlMTU2MTdhMzguLjhiOTVk YTg1Y2ZmY2RmMDI2ZmYxNTBhYzJkZDRjYzY0MmIyMWEzOGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNp b25Qcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRs ZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvblByaXZhdGUuaApAQCAtMjMsNiArMjMsNiBAQAog I2luY2x1ZGUgIkluamVjdGVkQnVuZGxlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViRXh0ZW5zaW9u LmgiCiAKLVdlYktpdFdlYkV4dGVuc2lvbiogd2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKFdlYktp dDo6SW5qZWN0ZWRCdW5kbGUqKTsKK1dlYktpdFdlYkV4dGVuc2lvbiogd2Via2l0V2ViRXh0ZW5z aW9uQ3JlYXRlKFdlYktpdDo6SW5qZWN0ZWRCdW5kbGUqLCBHUmVmUHRyPEdWYXJpYW50PiYpOwog CiAjZW5kaWYgLy8gV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZV9oCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcCBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCmlu ZGV4IGFkN2JhOTlmYjlhMmZjNTRmZjZmNjliMjkyZmE2YmU3ZTQwNjEzMjAuLjc3OTYyMGIwNmVl MmM5Njg4NzllZGFiYThlZmE3NzQyNTY5NDk4MjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCkBAIC0yMiwx MSArMjIsMTMgQEAKIAogI2luY2x1ZGUgIkluamVjdGVkQnVuZGxlLmgiCiAjaW5jbHVkZSAiV0tC dW5kbGVBUElDYXN0LmgiCisjaW5jbHVkZSAiV0tEaWN0aW9uYXJ5LmgiCiAjaW5jbHVkZSAiV0tT dHJpbmcuaCIKICNpbmNsdWRlICJXS1R5cGUuaCIKICNpbmNsdWRlICJXZWJLaXRXZWJFeHRlbnNp b25Qcml2YXRlLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9GaWxlU3lzdGVtLmg+CiAjaW5jbHVkZSA8 d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KIAogbmFtZXNwYWNl IFdlYktpdCB7CiAKQEAgLTUxLDE0ICs1MywyOCBAQCB2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFn ZXI6OnNjYW5Nb2R1bGVzKGNvbnN0IFN0cmluZyYgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSwgVgog CiB2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5kbGVSZWYgYnVu ZGxlLCBXS1R5cGVSZWYgdXNlckRhdGEpCiB7Ci0gICAgbV9leHRlbnNpb24gPSBhZG9wdEdSZWYo d2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKHRvSW1wbChidW5kbGUpKSk7Ci0KKyAgICBHUmVmUHRy PEdWYXJpYW50PiBleHRyYURhdGE7CiAgICAgU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7 CisKICAgICBpZiAodXNlckRhdGEpIHsKICAgICAgICAgQVNTRVJUKFdLR2V0VHlwZUlEKHVzZXJE YXRhKSA9PSBXS1N0cmluZ0dldFR5cGVJRCgpKTsKLSAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVj dG9yeSA9IHRvSW1wbChzdGF0aWNfY2FzdDxXS1N0cmluZ1JlZj4odXNlckRhdGEpKS0+c3RyaW5n KCk7CisKKyAgICAgICAgQ1N0cmluZyBkYXRhU3RyaW5nID0gdG9JbXBsKHN0YXRpY19jYXN0PFdL U3RyaW5nUmVmPih1c2VyRGF0YSkpLT5zdHJpbmcoKS51dGY4KCk7CisgICAgICAgIEdSZWZQdHI8 R1ZhcmlhbnQ+IHZhcmlhbnQgPQorICAgICAgICAgICAgZ192YXJpYW50X3BhcnNlKG51bGxwdHIs IGRhdGFTdHJpbmcuZGF0YSgpLCBkYXRhU3RyaW5nLmRhdGEoKSArIGRhdGFTdHJpbmcubGVuZ3Ro KCksIG51bGxwdHIsIG51bGxwdHIpOworCisgICAgICAgIEFTU0VSVCh2YXJpYW50KTsKKyAgICAg ICAgQVNTRVJUKGdfdmFyaWFudF9jaGVja19mb3JtYXRfc3RyaW5nKHZhcmlhbnQuZ2V0KCksICIo bSZzbXYpIiwgRkFMU0UpKTsKKworICAgICAgICBjb25zdCBjaGFyKiBkaXJlY3RvcnkgPSBudWxs cHRyOworICAgICAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlhbnQuZ2V0KCksICIobSZzbXYpIiwgJmRp cmVjdG9yeSwgJmV4dHJhRGF0YSk7CisKKyAgICAgICAgaWYgKGRpcmVjdG9yeSkKKyAgICAgICAg ICAgIHdlYkV4dGVuc2lvbnNEaXJlY3RvcnkgPSBTdHJpbmc6OmZyb21VVEY4KGRpcmVjdG9yeSk7 CiAgICAgfQogCisgICAgbV9leHRlbnNpb24gPSBhZG9wdEdSZWYod2Via2l0V2ViRXh0ZW5zaW9u Q3JlYXRlKHRvSW1wbChidW5kbGUpLCBleHRyYURhdGEpKTsKKwogICAgIGlmICh3ZWJFeHRlbnNp b25zRGlyZWN0b3J5LmlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAK 221381 2014-01-16 08:56:43 -0800 2014-01-18 01:11:40 -0800 Patch bug-125990-20140116185708.patch text/plain 23856 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYxNjI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYzQwMzAyMGUxY2NkZjgw ZGYwY2U0NjI3ZTNhODk3NmMzZmY3ZDUxMS4uMjBjZDhkNTY4YjFhZjcyMzgyNmY2YjgyNmQ3YmE5 MmM0ZDg3OWNkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDcwIEBACisyMDE0LTAxLTE1ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9m IHRoZSBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LAorICAgICAgICBhIEdWYXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRh dGEgdXNpbmcKKyAgICAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19p bml0aWFsaXphdGlvbl91c2VyX2RhdGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6 ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNo aW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRh CisgICAgICAgIGZvciBlYWNoIHByb2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFz IGEgc3RyaW5nLCBwYXNzZWQKKyAgICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRo ZSBpbmplY3RlZCBidW5kbGUgZGVzZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdo aWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAg IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlv biAoZm9yCisgICAgICAgIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVu c2lvbl9pbml0aWFsaXplKCkgaXMKKyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoK KyAgICAgICAgKGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6CisgICAg ICAgIERlZmluZSBuZXcgY2FsbGJhY2sgZnVuY3Rpb24gd2hpY2ggY2F1c2VzIGVtaXNzaW9uIG9m IHRoZQorICAgICAgICBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zIHNpZ25hbCwgYW5kIHNlcmlh bGl6ZXMgdGhlIGRhdGEgdG8gYmUKKyAgICAgICAgcGFzc2VkIHRvIHRoZSB3ZWIgcHJvY2Vzcy4K KyAgICAgICAgKGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KToKKyAgICAgICAg RGVmaW5lIHRoZSBnZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoKSBjYWxs YmFjay4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoK KyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KToKKyAgICAgICAgRGVmaW5l IHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93 ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4 dGVuc2lvbnMgZGlyZWN0b3J5IGFzIGEgbWVtYmVyIG9mIFdlYktpdFdlYkNvbnRleHRQcml2YXRl LCB0bworICAgICAgICBiZSBhYmxlIHRvIHJldHJpZXZlIGl0IGxhdGVyLgorICAgICAgICAod2Vi a2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2Rh dGEpOgorICAgICAgICBEZWZpbmUgbmV3IEFQSSBmdW5jdGlvbiB0byBzZXQgdGhlIHVzZXIgZGF0 YSBwYXNzZWQgdG8gdGhlIHdlYgorICAgICAgICBleHRlbnNpb25zIHdoZW4gaW5pdGlhbGl6ZWQu CisgICAgICAgICh3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMpOgorICAg ICAgICBQcml2YXRlIGZ1bmN0aW9uIHVzZWQgdG8gdHJpZ2dlciBlbWlzc2lvbiBvZiB0aGUKKyAg ICAgICAgaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwuCisgICAgICAgICh3ZWJraXRX ZWJDb250ZXh0R2V0V2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSk6CisgICAgICAgIFByaXZhdGUgZnVu Y3Rpb24gdG8gb2J0YWluIHRoZSB3ZWIgZXh0ZW5zaW9ucyBkaXJlY3RvcnkgaW4gb3JkZXIgdG8K KyAgICAgICAgc2VyaWFsaXplIGl0LCBzbyBpdCBjYW4gYmUgcGFzc2VkIHRvIHRoZSBpbmplY3Rl ZCBidW5kbGUuCisgICAgICAgICh3ZWJraXRXZWJDb250ZXh0R2V0V2ViRXh0ZW5zaW9uc0luaXRp YWxpemF0aW9uVXNlckRhdGEpOgorICAgICAgICBQcml2YXRlIGZ1bmN0aW9uIHRvIG9idGFpbiB0 aGUgd2ViIGV4dGVuc2lvbnMgaW5pdGlhbGl6YXRpb24gdXNlcgorICAgICAgICBkYXRhIGluIG9y ZGVyIHRvIHNlcmlhbGl6ZSBpdCwgc28gaXQgY2FuIGJlIHBhc3NlZCB0byB0aGUgaW5qZWN0ZWQK KyAgICAgICAgYnVuZGxlLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNv bnRleHQuaDoKKyAgICAgICAgQWRkZWQgcHJvdG90eXBlIGZvciBuZXcgQVBJIG1ldGhvZAorICAg ICAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9u X3VzZXJfZGF0YSgpLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRl eHRQcml2YXRlLmg6CisgICAgICAgIFByb3RvdHlwZXMgb2YgdGhlIG5ldyBwcml2YXRlIGZ1bmN0 aW9ucy4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlv bnMudHh0OgorICAgICAgICBBZGQgbmV3IHB1YmxpYyBBUEkgYml0cyB0byB0aGUgZG9jdW1lbnRh dGlvbi4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViRXh0ZW5zaW9u c0luaXRpYWxpemF0aW9uLmNwcDogQWRkZWQuCisgICAgICAgICh0ZXN0V2ViRXh0ZW5zaW9uc0lu aXRpYWxpemF0aW9uVXNlckRhdGEpOgorICAgICAgICAoaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnND YWxsYmFjayk6CisgICAgICAgIChiZWZvcmVBbGwpOgorICAgICAgICAoYWZ0ZXJBbGwpOgorICAg ICAgICAqIFdlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNp b24uaDoKKyAgICAgICAgQWRkIHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9pbml0aWFsaXphdGlv bl91c2VyX2RhdGEoKSB0byB0aGUgQVBJLgorICAgICAgICAqIFdlYlByb2Nlc3MvSW5qZWN0ZWRC dW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlLmg6CisgICAgICAgIENoYW5n ZWQgcHJvdG90eXBlIG9mIHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSgpLgorICAgICAgICAqIFdl YlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwOgorICAgICAgICAoV2ViS2l0 OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKToKKyAgICAgICAgRGVzZXJpYWxp emUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJvY2VzcyBhbmQgcGFzcyBpdCB0bwor ICAgICAgICB3ZWJraXRXZWJJbnNwZWN0b3JDcmVhdGUoKS4KKwogMjAxNC0wMS0xMCAgQ2FybG9z IEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgSW1wbGVtZW50 IE5ldHdvcmtSZXNvdXJjZUxvYWRlcjo6cmVjZWl2ZWRDYW5jZWxsYXRpb24KQEAgLTQxNTQsNiAr NDIyMSw3IEBACiAgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OnBhZ2VEaWRSZXF1ZXN0U2Nyb2xs KToKICAgICAgICAgKiBVSVByb2Nlc3MvZWZsL1BhZ2VWaWV3cG9ydENvbnRyb2xsZXJDbGllbnRF ZmwuY3BwOgogICAgICAgICAoV2ViS2l0OjpQYWdlVmlld3BvcnRDb250cm9sbGVyQ2xpZW50RWZs OjpzZXRWaWV3cG9ydFBvc2l0aW9uKToKKwogMjAxMy0xMi0xOCAgVGltIEhvcnRvbiAgPHRpbW90 aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJLaXQyIFZpZXcgR2VzdHVyZXM6IE1v dmUgV2ViUHJvY2Vzcy1zaWRlIGdlb21ldHJ5IGNvbGxlY3Rpb24gaW50byBpdHMgb3duIGNsYXNz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmpl Y3RlZEJ1bmRsZUNsaWVudC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKaW5kZXggNWQ5ZTEwNjhmOTdkNmNkZmQyNTdh YTFmNDk5NDI2NjRjNmU2YzNkMC4uYWViNzgyYzQxOTFhYzI4YWExMTRkZDcwOTA5MWRjMjhhN2Ex MzEzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 SW5qZWN0ZWRCdW5kbGVDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcApAQCAtMTE4LDE2ICsxMTgsMjYg QEAgc3RhdGljIHZvaWQgZGlkUmVjZWl2ZU1lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUoV0tDb250 ZXh0UmVmLCBXS1N0cmluZ1JlZiBtZXNzYWcKICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7 CiB9CiAKK3N0YXRpYyBXS1R5cGVSZWYgZ2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVz ZXJEYXRhKFdLQ29udGV4dFJlZiwgY29uc3Qgdm9pZCogY2xpZW50SW5mbykKK3sKKyAgICB3ZWJr aXRXZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV0VCS0lUX1dFQl9DT05URVhUKGNs aWVudEluZm8pKTsKKyAgICBHUmVmUHRyPEdWYXJpYW50PiBkYXRhID0gYWRvcHRHUmVmKGdfdmFy aWFudF9uZXcoIihtc212KSIsCisgICAgICAgIHdlYmtpdFdlYkNvbnRleHRHZXRXZWJFeHRlbnNp b25zRGlyZWN0b3J5KFdFQktJVF9XRUJfQ09OVEVYVChjbGllbnRJbmZvKSksCisgICAgICAgIHdl YmtpdFdlYkNvbnRleHRHZXRXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXRUJL SVRfV0VCX0NPTlRFWFQoY2xpZW50SW5mbykpKSk7CisgICAgR093blB0cjxnY2hhcj4gZGF0YVN0 cmluZyhnX3ZhcmlhbnRfcHJpbnQoZGF0YS5nZXQoKSwgVFJVRSkpOworICAgIHJldHVybiBzdGF0 aWNfY2FzdDxXS1R5cGVSZWY+KFdLU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKGRhdGFTdHJp bmcuZ2V0KCkpKTsKK30KKwogdm9pZCBhdHRhY2hJbmplY3RlZEJ1bmRsZUNsaWVudFRvQ29udGV4 dChXZWJLaXRXZWJDb250ZXh0KiB3ZWJDb250ZXh0KQogewogICAgIFdLQ29udGV4dEluamVjdGVk QnVuZGxlQ2xpZW50VjEgd2tJbmplY3RlZEJ1bmRsZUNsaWVudCA9IHsKICAgICAgICAgewotICAg ICAgICAgICAgMCwgLy8gdmVyc2lvbgorICAgICAgICAgICAgMSwgLy8gdmVyc2lvbgogICAgICAg ICAgICAgd2ViQ29udGV4dCwgLy8gY2xpZW50SW5mbwogICAgICAgICB9LAogICAgICAgICBkaWRS ZWNlaXZlTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZSwKICAgICAgICAgMCwgLy8gZGlkUmVjZWl2 ZVN5bmNocm9ub3VzTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZQotICAgICAgICAwIC8vIGdldElu amVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YQorICAgICAgICBnZXRJbmplY3RlZEJ1 bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEKICAgICB9OwogICAgIFdLQ29udGV4dFNldEluamVj dGVkQnVuZGxlQ2xpZW50KHRvQVBJKHdlYmtpdFdlYkNvbnRleHRHZXRDb250ZXh0KHdlYkNvbnRl eHQpKSwgJndrSW5qZWN0ZWRCdW5kbGVDbGllbnQuYmFzZSk7CiB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwCmluZGV4IDJi MWE1ZjM1YTgyZjRhMGY4NzkxN2U0YTBjOGFhYThiNDVhM2ZhYWYuLmFjMDZhYTFjMDFkYTk0NWNj OTc3ZjllMzI5NmIxZDRlZjlhMmZmYzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwCkBAIC04NCw2ICs4NCw3IEBAIHVz aW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIGVudW0gewogICAgIERPV05MT0FEX1NUQVJURUQsCisg ICAgSU5JVElBTElaRV9XRUJfRVhURU5TSU9OUywKIAogICAgIExBU1RfU0lHTkFMCiB9OwpAQCAt MTUzLDYgKzE1NCw5IEBAIHN0cnVjdCBfV2ViS2l0V2ViQ29udGV4dFByaXZhdGUgewogCiAgICAg SGFzaE1hcDx1aW50NjRfdCwgV2ViS2l0V2ViVmlldyo+IHdlYlZpZXdzOwogICAgIEdSZWZQdHI8 V2ViS2l0V2ViVmlld0dyb3VwPiBkZWZhdWx0V2ViVmlld0dyb3VwOworCisgICAgQ1N0cmluZyB3 ZWJFeHRlbnNpb25zRGlyZWN0b3J5OworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHdlYkV4dGVuc2lv bnNJbml0aWFsaXphdGlvblVzZXJEYXRhOwogfTsKIAogc3RhdGljIGd1aW50IHNpZ25hbHNbTEFT VF9TSUdOQUxdID0geyAwLCB9OwpAQCAtMTc4LDYgKzE4MiwyNSBAQCBzdGF0aWMgdm9pZCB3ZWJr aXRfd2ViX2NvbnRleHRfY2xhc3NfaW5pdChXZWJLaXRXZWJDb250ZXh0Q2xhc3MqIHdlYkNvbnRl eHRDbGFzcwogICAgICAgICAgICAgICAgICAgICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX09C SkVDVCwKICAgICAgICAgICAgICAgICAgICAgIEdfVFlQRV9OT05FLCAxLAogICAgICAgICAgICAg ICAgICAgICAgV0VCS0lUX1RZUEVfRE9XTkxPQUQpOworCisgICAgLyoqCisgICAgICogV2ViS2l0 V2ViQ29udGV4dDo6aW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9uczoKKyAgICAgKiBAY29udGV4dDog dGhlICNXZWJLaXRXZWJDb250ZXh0CisgICAgICoKKyAgICAgKiBUaGlzIHNpZ25hbCBpcyBlbWl0 dGVkIHdoZW4gYSBuZXcgd2ViIHByb2Nlc3MgaXMgYWJvdXQgdG8gYmUKKyAgICAgKiBsYXVuY2hl ZC4gSXQgc2lnbmFscyB0aGUgbW9zdCBhcHByb3ByaWF0ZSBtb21lbnQgdG8gdXNlCisgICAgICog d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2Vy X2RhdGEoKQorICAgICAqIGFuZCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25z X2RpcmVjdG9yeSgpLgorICAgICAqCisgICAgICogU2luY2U6IDIuNAorICAgICAqLworICAgIHNp Z25hbHNbSU5JVElBTElaRV9XRUJfRVhURU5TSU9OU10gPQorICAgICAgICBnX3NpZ25hbF9uZXco ImluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnMiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xB U1MoZ09iamVjdENsYXNzKSwKKyAgICAgICAgICAgIEdfU0lHTkFMX1JVTl9MQVNULAorICAgICAg ICAgICAgMCwgbnVsbHB0ciwgbnVsbHB0ciwKKyAgICAgICAgICAgIGdfY2Nsb3N1cmVfbWFyc2hh bF9WT0lEX19WT0lELAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDApOwogfQogCiBzdGF0aWMg Q1N0cmluZyBpbmplY3RlZEJ1bmRsZURpcmVjdG9yeSgpCkBAIC03ODMsOCArODA2LDIwIEBAIHZv aWQgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3RvcnkoV2ViS2l0 V2ViQ29udGV4dCogY29udGV4dCwKICAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJf Q09OVEVYVChjb250ZXh0KSk7CiAgICAgZ19yZXR1cm5faWZfZmFpbChkaXJlY3RvcnkpOwogCi0g ICAgLy8gV2UgcGFzcyB0aGUgYWRkaXRpb25hbCB3ZWIgZXh0ZW5zaW9ucyBkaXJlY3RvcnkgdG8g dGhlIGluamVjdGVkIGJ1bmRsZSBhcyBpbml0aWFsaXphdGlvbiB1c2VyIGRhdGEuCi0gICAgY29u dGV4dC0+cHJpdi0+Y29udGV4dC0+c2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJE YXRhKEFQSTo6U3RyaW5nOjpjcmVhdGUoV2ViQ29yZTo6ZmlsZW5hbWVUb1N0cmluZyhkaXJlY3Rv cnkpKSk7CisgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IGRpcmVj dG9yeTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25z X2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YToKKyAqIEBjb250ZXh0OiBhICNXZWJLaXRXZWJDb250 ZXh0CisgKgorICogU2luY2U6IDIuNAorICovCit2b2lkIHdlYmtpdF93ZWJfY29udGV4dF9zZXRf d2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhKFdlYktpdFdlYkNvbnRleHQq IGNvbnRleHQsIEdWYXJpYW50KiB1c2VyRGF0YSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdF QktJVF9JU19XRUJfQ09OVEVYVChjb250ZXh0KSk7CisKKyAgICBjb250ZXh0LT5wcml2LT53ZWJF eHRlbnNpb25zSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSA9IHVzZXJEYXRhOwogfQogCiAvKioKQEAg LTg3Miw2ICs5MDcsMTEgQEAgdm9pZCB3ZWJraXRXZWJDb250ZXh0RG93bmxvYWRTdGFydGVkKFdl YktpdFdlYkNvbnRleHQqIGNvbnRleHQsIFdlYktpdERvd25sb2FkKgogICAgIGdfc2lnbmFsX2Vt aXQoY29udGV4dCwgc2lnbmFsc1tET1dOTE9BRF9TVEFSVEVEXSwgMCwgZG93bmxvYWQpOwogfQog Cit2b2lkIHdlYmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXZWJLaXRXZWJD b250ZXh0KiBjb250ZXh0KQoreworICAgIGdfc2lnbmFsX2VtaXQoY29udGV4dCwgc2lnbmFsc1tJ TklUSUFMSVpFX1dFQl9FWFRFTlNJT05TXSwgMCk7Cit9CisKIFdlYkNvbnRleHQqIHdlYmtpdFdl YkNvbnRleHRHZXRDb250ZXh0KFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQpCiB7CiAgICAgZ19h c3NlcnQoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKQEAgLTkzNywzICs5NzcsMTMg QEAgV2ViS2l0V2ViVmlld0dyb3VwKiB3ZWJraXRXZWJDb250ZXh0R2V0RGVmYXVsdFdlYlZpZXdH cm91cChXZWJLaXRXZWJDb250ZXh0KiBjb24KIHsKICAgICByZXR1cm4gY29udGV4dC0+cHJpdi0+ ZGVmYXVsdFdlYlZpZXdHcm91cC5nZXQoKTsKIH0KKworY29uc3QgZ2NoYXIqIHdlYmtpdFdlYkNv bnRleHRHZXRXZWJFeHRlbnNpb25zRGlyZWN0b3J5KFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQp Cit7CisgICAgcmV0dXJuIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNEaXJlY3RvcnkuZGF0 YSgpOworfQorCitHVmFyaWFudCogd2Via2l0V2ViQ29udGV4dEdldFdlYkV4dGVuc2lvbnNJbml0 aWFsaXphdGlvblVzZXJEYXRhKFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQpCit7CisgICAgcmV0 dXJuIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlvblVzZXJEYXRhLmdl dCgpOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViQ29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 V2ViQ29udGV4dC5oCmluZGV4IDllN2JjMTQ0NzZkYjAyMjNhNzhiY2RmNzM4YzJmNjBiOTA2NTNk N2UuLjFlM2I5YjU4OGQ2NWE4NTQ5OWE4NmJiNzE2Y2I2N2JlMjNkOTIyYWEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmgKQEAg LTE5Niw2ICsxOTYsMTEgQEAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19k aXJlY3RvcnkgICAgIChXZWJLaXRXZWJDb250ZXh0CiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdjaGFyICAgICAgICAgICAgICAgICAg ICpkaXJlY3RvcnkpOwogCiBXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfY29udGV4dF9zZXRf d2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgICAg ICAgICAgICAgICpjb250ZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBHVmFyaWFudCAgICAgICAgICAgICAgICAgICAgICAqdXNlcl9kYXRh KTsKKworV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX2NvbnRleHRfcHJlZmV0Y2hfZG5zICAg ICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpjb250ZXh0 LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBnY2hhciAgICAgICAgICAgICAgICAgICAqaG9zdG5hbWUpOwogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5o IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dFByaXZh dGUuaAppbmRleCA4MWM0NzNjNTYxZDhjM2NjMmYzNTVhYjI0MWU4MDliMGQ4N2ZhYzAyLi5jN2M2 YzMxOWZlMDNhNmRlZDNjZDIwMjNlNjhkY2ViNWRkYjY1MjA4IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oCisrKyBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRl LmgKQEAgLTQ3LDUgKzQ3LDggQEAgdm9pZCB3ZWJraXRXZWJDb250ZXh0Q3JlYXRlUGFnZUZvcldl YlZpZXcoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZpZXcqLCBXZWIKIHZvaWQgd2Via2l0 V2ViQ29udGV4dFdlYlZpZXdEZXN0cm95ZWQoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZp ZXcqKTsKIFdlYktpdFdlYlZpZXcqIHdlYmtpdFdlYkNvbnRleHRHZXRXZWJWaWV3Rm9yUGFnZShX ZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0OjpXZWJQYWdlUHJveHkqKTsKIFdlYktpdFdlYlZpZXdH cm91cCogd2Via2l0V2ViQ29udGV4dEdldERlZmF1bHRXZWJWaWV3R3JvdXAoV2ViS2l0V2ViQ29u dGV4dCopOworY29uc3QgY2hhciogd2Via2l0V2ViQ29udGV4dEdldFdlYkV4dGVuc2lvbnNEaXJl Y3RvcnkoV2ViS2l0V2ViQ29udGV4dCopOworR1ZhcmlhbnQqIHdlYmtpdFdlYkNvbnRleHRHZXRX ZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXZWJLaXRXZWJDb250ZXh0Kik7Cit2 b2lkIHdlYmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXZWJLaXRXZWJDb250 ZXh0Kik7CiAKICNlbmRpZiAvLyBXZWJLaXRXZWJDb250ZXh0UHJpdmF0ZV9oCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlv bnMudHh0IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3Rr LXNlY3Rpb25zLnR4dAppbmRleCAwOTBlOTFlNmRlNjFjNDZmMzNiODhjMWM4ZDQ1ZmJiN2MxNzI2 YjI4Li4xYzEzYzZjMDczYTc1ZDE5N2Q3MDU2MmMwMjk3OTIxZjdiNjM4MmY0IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlv bnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0 Mmd0ay1zZWN0aW9ucy50eHQKQEAgLTQ2LDYgKzQ2LDcgQEAgd2Via2l0X3dlYl9jb250ZXh0X3Nl dF9wcmVmZXJyZWRfbGFuZ3VhZ2VzCiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3Rsc19lcnJvcnNf cG9saWN5CiB3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X3Rsc19lcnJvcnNfcG9saWN5CiB3ZWJraXRf d2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeQord2Via2l0X3dlYl9jb250 ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEKIHdlYmtpdF93 ZWJfY29udGV4dF9wcmVmZXRjaF9kbnMKIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfZGlza19jYWNo ZV9kaXJlY3RvcnkKIHdlYmtpdF93ZWJfY29udGV4dF9hbGxvd190bHNfY2VydGlmaWNhdGVfZm9y X2hvc3QKQEAgLTEwMjYsNiArMTAyNyw3IEBAIHdlYmtpdF93ZWJfdmlld19ncm91cF9nZXRfdHlw ZQogPEZJTEU+V2ViS2l0V2ViRXh0ZW5zaW9uPC9GSUxFPgogV2ViS2l0V2ViRXh0ZW5zaW9uCiBX ZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplRnVuY3Rpb24KK1dlYktpdFdlYkV4dGVuc2lvbklu aXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbgogd2Via2l0X3dlYl9leHRlbnNpb25fZ2V0X3Bh Z2UKIAogPFNVQlNFQ1RJT04gU3RhbmRhcmQ+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmggYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2Vi RXh0ZW5zaW9uLmgKaW5kZXggNjdhNGNkNTRjYTgyOGY5YmM5NzEzMjRkNGVlODgwMTVmOTJmOTA1 Zi4uODAxNGE4Y2Q0YzNjYjEwY2QwNmVmMWNjMTMwNzY5NjlkNGZjNDIyZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdl YkV4dGVuc2lvbi5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5k bGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaApAQCAtNTAsNiArNTAsMjEgQEAgdHlwZWRl ZiBzdHJ1Y3QgX1dlYktpdFdlYkV4dGVuc2lvblByaXZhdGUgV2ViS2l0V2ViRXh0ZW5zaW9uUHJp dmF0ZTsKICAqLwogdHlwZWRlZiB2b2lkICgqIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVG dW5jdGlvbikgKFdlYktpdFdlYkV4dGVuc2lvbiAqZXh0ZW5zaW9uKTsKIAorLyoqCisgKiBXZWJL aXRXZWJFeHRlbnNpb25Jbml0aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb246CisgKiBAZXh0ZW5z aW9uOiBhICNXZWJLaXRXZWJFeHRlbnNpb24KKyAqIEBleHRyYV9kYXRhOiBhICNHVmFyaWFudAor ICoKKyAqIFR5cGUgZGVmaW5pdGlvbiBmb3IgYSBmdW5jdGlvbiB0aGF0IHdpbGwgYmUgY2FsbGVk IHRvIGluaXRpYWxpemUKKyAqIHRoZSB3ZWIgZXh0ZW5zaW9ucyB3aGVuIHRoZSB3ZWIgcHJvY2Vz cyBzdGFydHMsIGFuZCB3aGljaCByZWNlaXZlcworICogYXMgYWRkaXRpb25hbCBhcmd1bWVudCB0 aGUgdXNlciBkYXRhIHNldCB3aXRoCisgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRl bnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSgpLgorICoKKyAqIFNpbmNlOiAwLjI2Cisg Ki8KK3R5cGVkZWYgdm9pZCAoKiBXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplV2l0aFVzZXJE YXRhRnVuY3Rpb24pIChXZWJLaXRXZWJFeHRlbnNpb24gKmV4dGVuc2lvbiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBHVmFyaWFudCAgICAgKnVzZXJfZGF0YSk7CisKIHN0cnVjdCBfV2ViS2l0V2ViRXh0ZW5z aW9uIHsKICAgICBHT2JqZWN0IHBhcmVudDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9ndGsvV2ViR3RrRXh0ZW5zaW9uTWFuYWdlci5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcAppbmRleCBhZDdiYTk5 ZmI5YTJmYzU0ZmY2ZjY5YjI5MmZhNmJlN2U0MDYxMzIwLi5iYzJkMmRjYTAzZGZkMjJjZTUwZjJj NmI3NDUwNGIyNzA3MzYwZDU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcApAQCAtMjIsMTEgKzIyLDEzIEBA CiAKICNpbmNsdWRlICJJbmplY3RlZEJ1bmRsZS5oIgogI2luY2x1ZGUgIldLQnVuZGxlQVBJQ2Fz dC5oIgorI2luY2x1ZGUgIldLRGljdGlvbmFyeS5oIgogI2luY2x1ZGUgIldLU3RyaW5nLmgiCiAj aW5jbHVkZSAiV0tUeXBlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZS5o IgogI2luY2x1ZGUgPFdlYkNvcmUvRmlsZVN5c3RlbS5oPgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIu aD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJLaXQgewog CkBAIC00OSwxOSArNTEsMzUgQEAgdm9pZCBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjpzY2FuTW9k dWxlcyhjb25zdCBTdHJpbmcmIHdlYkV4dGVuc2lvbnNEaXJlY3RvcnksIFYKICAgICB9CiB9CiAK LXZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5pdGlhbGl6ZShXS0J1bmRsZVJlZiBidW5k bGUsIFdLVHlwZVJlZiB1c2VyRGF0YSkKK3ZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5p dGlhbGl6ZShXS0J1bmRsZVJlZiBidW5kbGUsIFdLVHlwZVJlZiB1c2VyRGF0YVN0cmluZykKIHsK LSAgICBtX2V4dGVuc2lvbiA9IGFkb3B0R1JlZih3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUodG9J bXBsKGJ1bmRsZSkpKTsKKyAgICBBU1NFUlQodXNlckRhdGFTdHJpbmcpOworICAgIEFTU0VSVChX S0dldFR5cGVJRCh1c2VyRGF0YVN0cmluZykgPT0gV0tTdHJpbmdHZXRUeXBlSUQoKSk7CisKKyAg ICBDU3RyaW5nIGRhdGFTdHJpbmcgPSB0b0ltcGwoc3RhdGljX2Nhc3Q8V0tTdHJpbmdSZWY+KHVz ZXJEYXRhU3RyaW5nKSktPnN0cmluZygpLnV0ZjgoKTsKKyAgICBHUmVmUHRyPEdWYXJpYW50PiB2 YXJpYW50ID0KKyAgICAgICAgZ192YXJpYW50X3BhcnNlKG51bGxwdHIsIGRhdGFTdHJpbmcuZGF0 YSgpLCBkYXRhU3RyaW5nLmRhdGEoKSArIGRhdGFTdHJpbmcubGVuZ3RoKCksIG51bGxwdHIsIG51 bGxwdHIpOworCisgICAgQVNTRVJUKHZhcmlhbnQpOworICAgIEFTU0VSVChnX3ZhcmlhbnRfY2hl Y2tfZm9ybWF0X3N0cmluZyh2YXJpYW50LmdldCgpLCAiKG0mc212KSIsIEZBTFNFKSk7CisKKyAg ICBjb25zdCBjaGFyKiBkaXJlY3RvcnkgPSBudWxscHRyOworICAgIEdWYXJpYW50KiBkYXRhID0g bnVsbHB0cjsKKyAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlhbnQuZ2V0KCksICIobSZzbXYpIiwgJmRp cmVjdG9yeSwgJmRhdGEpOwogCiAgICAgU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7Ci0g ICAgaWYgKHVzZXJEYXRhKSB7Ci0gICAgICAgIEFTU0VSVChXS0dldFR5cGVJRCh1c2VyRGF0YSkg PT0gV0tTdHJpbmdHZXRUeXBlSUQoKSk7Ci0gICAgICAgIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnkg PSB0b0ltcGwoc3RhdGljX2Nhc3Q8V0tTdHJpbmdSZWY+KHVzZXJEYXRhKSktPnN0cmluZygpOwot ICAgIH0KKyAgICBpZiAoZGlyZWN0b3J5KQorICAgICAgICB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5 ID0gU3RyaW5nOjpmcm9tVVRGOChkaXJlY3RvcnkpOwogCiAgICAgaWYgKHdlYkV4dGVuc2lvbnNE aXJlY3RvcnkuaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKIAorICAgIEdSZWZQdHI8R1Zhcmlh bnQ+IHVzZXJEYXRhOworICAgIGlmIChkYXRhKQorICAgICAgICB1c2VyRGF0YSA9IGRhdGE7CisK KyAgICBtX2V4dGVuc2lvbiA9IGFkb3B0R1JlZih3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUodG9J bXBsKGJ1bmRsZSkpKTsKKwogICAgIFZlY3RvcjxTdHJpbmc+IG1vZHVsZVBhdGhzOwogICAgIHNj YW5Nb2R1bGVzKHdlYkV4dGVuc2lvbnNEaXJlY3RvcnksIG1vZHVsZVBhdGhzKTsKIApAQCAtNzAs MTMgKzg4LDE4IEBAIHZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5pdGlhbGl6ZShXS0J1 bmRsZVJlZiBidW5kbGUsIFdLVHlwZVJlZiB1c2VyRGF0YSkKICAgICAgICAgaWYgKCFtb2R1bGUt PmxvYWQoKSkKICAgICAgICAgICAgIGNvbnRpbnVlOwogCisgICAgICAgIFdlYktpdFdlYkV4dGVu c2lvbkluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbiBpbml0aWFsaXplV2l0aFVzZXJEYXRh RnVuY3Rpb24gPQorICAgICAgICAgICAgbW9kdWxlLT5mdW5jdGlvblBvaW50ZXI8V2ViS2l0V2Vi RXh0ZW5zaW9uSW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uPigid2Via2l0X3dlYl9leHRl bnNpb25faW5pdGlhbGl6ZV93aXRoX3VzZXJfZGF0YSIpOwogICAgICAgICBXZWJLaXRXZWJFeHRl bnNpb25Jbml0aWFsaXplRnVuY3Rpb24gaW5pdGlhbGl6ZUZ1bmN0aW9uID0KICAgICAgICAgICAg IG1vZHVsZS0+ZnVuY3Rpb25Qb2ludGVyPFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVGdW5j dGlvbj4oIndlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemUiKTsKLSAgICAgICAgaWYgKCFp bml0aWFsaXplRnVuY3Rpb24pCisgICAgICAgIGlmICghaW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1 bmN0aW9uICYmICFpbml0aWFsaXplRnVuY3Rpb24pCiAgICAgICAgICAgICBjb250aW51ZTsKIAog ICAgICAgICBtX2V4dGVuc2lvbk1vZHVsZXMuYXBwZW5kKG1vZHVsZS5sZWFrUHRyKCkpOwotICAg ICAgICBpbml0aWFsaXplRnVuY3Rpb24obV9leHRlbnNpb24uZ2V0KCkpOworICAgICAgICBpZiAo aW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uKQorICAgICAgICAgICAgaW5pdGlhbGl6ZVdp dGhVc2VyRGF0YUZ1bmN0aW9uKG1fZXh0ZW5zaW9uLmdldCgpLCB1c2VyRGF0YS5nZXQoKSk7Cisg ICAgICAgIGVsc2UKKyAgICAgICAgICAgIGluaXRpYWxpemVGdW5jdGlvbihtX2V4dGVuc2lvbi5n ZXQoKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDJHdGsvQ01ha2VMaXN0cy50eHQgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDJHdGsvQ01ha2VMaXN0cy50eHQKaW5kZXggYjg4M2NmMWU2ZDQ5MmUyZDNkODNlNTRhOTll OWUyYjcxZmVhMGMxYS4uMTQ1ZGZjMTFjMDY2OTY3NjA4NjgzOWIwMzQ0ZjkyZDYwOGUzYzM4MCAx MDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL0NNYWtlTGlz dHMudHh0CisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9DTWFrZUxp c3RzLnR4dApAQCAtOTUsNiArOTUsNyBAQCBBRERfV0syX1RFU1QoVGVzdExvYWRlckNsaWVudCBU ZXN0TG9hZGVyQ2xpZW50LmNwcCkKIEFERF9XSzJfVEVTVChUZXN0UHJpbnRpbmcgVGVzdFByaW50 aW5nLmNwcCkKIEFERF9XSzJfVEVTVChUZXN0U1NMIFRlc3RTU0wuY3BwKQogQUREX1dLMl9URVNU KFRlc3RXZWJFeHRlbnNpb25zIFRlc3RXZWJFeHRlbnNpb25zLmNwcCkKK0FERF9XSzJfVEVTVChU ZXN0V2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0aW9uIFRlc3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6 YXRpb24uY3BwKQogQUREX1dLMl9URVNUKFRlc3RXZWJLaXRQb2xpY3lDbGllbnQgVGVzdFdlYktp dFBvbGljeUNsaWVudC5jcHApCiBBRERfV0syX1RFU1QoVGVzdFdlYktpdFNldHRpbmdzIFRlc3RX ZWJLaXRTZXR0aW5ncy5jcHApCiBBRERfV0syX1RFU1QoVGVzdFdlYktpdFZlcnNpb24gVGVzdFdl YktpdFZlcnNpb24uY3BwKQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyR3RrL1Rlc3RXZWJFeHRlbnNpb25zLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHAKaW5kZXggYjAzYzlkY2FkNWEzN2Rh ZWE0MGI3YmFkMjM5YmMzYTc1ZWE3MWI4OS4uYTllYjE2YjdmNGRmN2QxZDYzMjE2NjhkMWM0ZjJl YzMzYzQ2NGZmNSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy R3RrL1Rlc3RXZWJFeHRlbnNpb25zLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDJHdGsvVGVzdFdlYkV4dGVuc2lvbnMuY3BwCkBAIC0xNzgsNiArMTc4LDcgQEAgc3Rh dGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbklzb2xhdGVkV29ybGQoV2ViVmlld1Rlc3QqIHRlc3Qs IGdjb25zdHBvaW50ZXIpCiB2b2lkIGJlZm9yZUFsbCgpCiB7CiAgICAgd2Via2l0X3dlYl9jb250 ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3Rvcnkod2Via2l0X3dlYl9jb250ZXh0X2dldF9k ZWZhdWx0KCksIFdFQktJVF9URVNUX1dFQl9FWFRFTlNJT05TX0RJUik7CisKICAgICBidXMgPSBu ZXcgV2ViS2l0VGVzdEJ1cygpOwogICAgIGlmICghYnVzLT5ydW4oKSkKICAgICAgICAgcmV0dXJu OwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RX ZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb24uY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXQyR3RrL1Rlc3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb24uY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmVkM2YyMGQ4MWI5MTZhYzBiYzg4NzcyZTU5NmI1Mzg1MmZlZTdlMmEKLS0tIC9kZXYvbnVs bAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYkV4dGVu c2lvbnNJbml0aWFsaXphdGlvbi5jcHAKQEAgLTAsMCArMSw3OSBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxNCBJZ2FsaWEgUy5MLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyLDEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlO Ry5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAw MjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAi V2ViS2l0VGVzdEJ1cy5oIgorI2luY2x1ZGUgIldlYlZpZXdUZXN0LmgiCisjaW5jbHVkZSA8d3Rm L2dvYmplY3QvR1JlZlB0ci5oPgorCitzdGF0aWMgV2ViS2l0VGVzdEJ1cyogYnVzOworc3RhdGlj IGJvb2wgaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxUcmlnZ2VyZWQgPSBmYWxzZTsKK3N0 YXRpYyBnaW50IGluaXRpYWxpemVXZWJFeHRlbnNpb25zU2lnbmFsSGFuZGxlcklkID0gLTE7CisK K3N0YXRpYyB2b2lkIHRlc3RXZWJFeHRlbnNpb25zSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXZWJW aWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICB0ZXN0LT5sb2FkSHRtbCgiPGh0 bWw+PC9odG1sPiIsIG51bGxwdHIpOworICAgIHRlc3QtPndhaXRVbnRpbExvYWRGaW5pc2hlZCgp OworCisgICAgZ19hc3NlcnQoaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxUcmlnZ2VyZWQp OworCisgICAgR1JlZlB0cjxHREJ1c1Byb3h5PiBwcm94eSA9IGFkb3B0R1JlZihidXMtPmNyZWF0 ZVByb3h5KCJvcmcud2Via2l0Lmd0ay5XZWJFeHRlbnNpb25UZXN0IiwKKyAgICAgICAgIi9vcmcv d2Via2l0L2d0ay9XZWJFeHRlbnNpb25UZXN0IiAsICJvcmcud2Via2l0Lmd0ay5XZWJFeHRlbnNp b25UZXN0IiwgdGVzdC0+bV9tYWluTG9vcCkpOworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHJlc3Vs dCA9IGFkb3B0R1JlZihnX2RidXNfcHJveHlfY2FsbF9zeW5jKAorICAgICAgICBwcm94eS5nZXQo KSwKKyAgICAgICAgIkdldEV4dHJhRGF0YUFzU3RyaW5nIiwKKyAgICAgICAgbnVsbHB0ciwKKyAg ICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwKKyAgICAgICAgLTEsIDAsIDApKTsKKyAgICBn X2Fzc2VydChyZXN1bHQpOworCisgICAgLy8gVGhlIHdlYiBleHRlbnNpb24gc2VyaWFsaXplcyB0 aGUgZGF0YSB0aGF0IHdhcyBwYXNzZWQgdG8gaXQgZnJvbSB0aGUKKyAgICAvLyB3ZWItZXh0ZW5z aW9ucy1sb2FkZWQgc2lnbmFsIGNhbGxiYWNrIHVzaW5nIGdfdmFyaWFudF9wcmludCgpIGFuZAor ICAgIC8vIHNlbmQgaXQgYmFjayBhcyBhIHN0cmluZyB3aGVuIGNhbGxpbmcgR2V0RXh0cmFEYXRh QXNTdHJpbmcuCisgICAgY29uc3QgY2hhciogZXh0cmFEYXRhU3RyaW5nOworICAgIGdfdmFyaWFu dF9nZXQocmVzdWx0LmdldCgpLCAiKCZzKSIsICZleHRyYURhdGFTdHJpbmcpOworICAgIGdfYXNz ZXJ0X2NtcHN0cihleHRyYURhdGFTdHJpbmcsID09LCAiJ2V4dHJhIGRhdGEnIik7Cit9CisKK3N0 YXRpYyBHVmFyaWFudCogaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNDYWxsYmFjayhXZWJLaXRXZWJD b250ZXh0KiBjb250ZXh0LCBncG9pbnRlcikKK3sKKyAgICBpbml0aWFsaXplV2ViRXh0ZW5zaW9u c1NpZ25hbFRyaWdnZXJlZCA9IHRydWU7CisgICAgcmV0dXJuIGdfdmFyaWFudF9uZXcoInMiLCAi ZXh0cmEgZGF0YSIpOworfQorCit2b2lkIGJlZm9yZUFsbCgpCit7CisgICAgd2Via2l0X3dlYl9j b250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3Rvcnkod2Via2l0X3dlYl9jb250ZXh0X2dl dF9kZWZhdWx0KCksIFdFQktJVF9URVNUX1dFQl9FWFRFTlNJT05TX0RJUik7CisgICAgaW5pdGlh bGl6ZVdlYkV4dGVuc2lvbnNTaWduYWxIYW5kbGVySWQgPSBnX3NpZ25hbF9jb25uZWN0KHdlYmtp dF93ZWJfY29udGV4dF9nZXRfZGVmYXVsdCgpLAorICAgICAgICAiaW5pdGlhbGl6ZS13ZWItZXh0 ZW5zaW9ucyIsIEdfQ0FMTEJBQ0soaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnNDYWxsYmFjayksIG51 bGxwdHIpOworCisgICAgYnVzID0gbmV3IFdlYktpdFRlc3RCdXMoKTsKKyAgICBpZiAoIWJ1cy0+ cnVuKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdl YlZpZXciLCAid2ViLWV4dGVuc2lvbnMtaW5pdGlhbGl6YXRpb24tdXNlci1kYXRhIiwgdGVzdFdl YkV4dGVuc2lvbnNJbml0aWFsaXphdGlvblVzZXJEYXRhKTsKK30KKwordm9pZCBhZnRlckFsbCgp Cit7CisgICAgaWYgKGluaXRpYWxpemVXZWJFeHRlbnNpb25zU2lnbmFsSGFuZGxlcklkICE9IC0x KQorICAgICAgICBnX3NpZ25hbF9oYW5kbGVyX2Rpc2Nvbm5lY3Qod2Via2l0X3dlYl9jb250ZXh0 X2dldF9kZWZhdWx0KCksIGluaXRpYWxpemVXZWJFeHRlbnNpb25zU2lnbmFsSGFuZGxlcklkKTsK KyAgICBkZWxldGUgYnVzOworfQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwCmluZGV4IDQwY2I2Y2FmOTE1ZTE0 YmM4MTQ5ZjNjZDNiM2MwZWYzODI5MjgxNTcuLjc0ZGEyZjI0OWZlMTQ3OGQwNmQ4OWY1MTQ5ODU5 ZDYwNzA1NDc1YzQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mkd0ay9XZWJFeHRlbnNpb25UZXN0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDJHdGsvV2ViRXh0ZW5zaW9uVGVzdC5jcHAKQEAgLTQ1LDYgKzQ1LDkgQEAgc3RhdGlj IGNvbnN0IGNoYXIgaW50cm9zcGVjdGlvblhNTFtdID0KICAgICAiICAgPGFyZyB0eXBlPSd0JyBu YW1lPSdwYWdlSUQnIGRpcmVjdGlvbj0naW4nLz4iCiAgICAgIiAgIDxhcmcgdHlwZT0ncycgbmFt ZT0nc2NyaXB0JyBkaXJlY3Rpb249J2luJy8+IgogICAgICIgIDwvbWV0aG9kPiIKKyAgICAiICA8 bWV0aG9kIG5hbWU9J0dldEV4dHJhRGF0YUFzU3RyaW5nJz4iCisgICAgIiAgIDxhcmcgdHlwZT0n cycgbmFtZT0nZGF0YScgZGlyZWN0aW9uPSdvdXQnLz4iCisgICAgIiAgPC9tZXRob2Q+IgogICAg ICIgIDxzaWduYWwgbmFtZT0nRG9jdW1lbnRMb2FkZWQnLz4iCiAgICAgIiAgPHNpZ25hbCBuYW1l PSdVUklDaGFuZ2VkJz4iCiAgICAgIiAgIDxhcmcgdHlwZT0ncycgbmFtZT0ndXJpJyBkaXJlY3Rp b249J291dCcvPiIKQEAgLTIxMCw4ICsyMTMsMTYgQEAgc3RhdGljIHZvaWQgbWV0aG9kQ2FsbENh bGxiYWNrKEdEQnVzQ29ubmVjdGlvbiogY29ubmVjdGlvbiwgY29uc3QgY2hhciogc2VuZGVyLAog ICAgICAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ganNTY3JpcHQoQWRvcHQsIEpTU3RyaW5n Q3JlYXRlV2l0aFVURjhDU3RyaW5nKHNjcmlwdCkpOwogICAgICAgICBKU0V2YWx1YXRlU2NyaXB0 KGpzQ29udGV4dCwganNTY3JpcHQuZ2V0KCksIDAsIDAsIDAsIDApOwogICAgICAgICBnX2RidXNf bWV0aG9kX2ludm9jYXRpb25fcmV0dXJuX3ZhbHVlKGludm9jYXRpb24sIDApOwotICAgIH0gZWxz ZSBpZiAoIWdfc3RyY21wMChtZXRob2ROYW1lLCAiQWJvcnRQcm9jZXNzIikpCisgICAgfSBlbHNl IGlmICghZ19zdHJjbXAwKG1ldGhvZE5hbWUsICJBYm9ydFByb2Nlc3MiKSkgewogICAgICAgICBh Ym9ydCgpOworICAgIH0gZWxzZSBpZiAoIWdfc3RyY21wMChtZXRob2ROYW1lLCAiR2V0RXh0cmFE YXRhQXNTdHJpbmciKSkgeworICAgICAgICBHUmVmUHRyPEdWYXJpYW50PiBpbml0aWFsaXphdGlv blVzZXJEYXRhID0gYWRvcHRHUmVmKHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9pbml0aWFsaXph dGlvbl91c2VyX2RhdGEoV0VCS0lUX1dFQl9FWFRFTlNJT04odXNlckRhdGEpKSk7CisgICAgICAg IGlmICh1c2VyRGF0YSkgeworICAgICAgICAgICAgR093blB0cjxnY2hhcj4gaW5pdGlhbGl6YXRp b25Vc2VyRGF0YVN0cmluZyhnX3ZhcmlhbnRfcHJpbnQoaW5pdGlhbGl6YXRpb25Vc2VyRGF0YS5n ZXQoKSwgVFJVRSkpOworICAgICAgICAgICAgZ19kYnVzX21ldGhvZF9pbnZvY2F0aW9uX3JldHVy bl92YWx1ZShpbnZvY2F0aW9uLCBnX3ZhcmlhbnRfbmV3KCIocykiLCBpbml0aWFsaXphdGlvblVz ZXJEYXRhU3RyaW5nLmdldCgpKSk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgZ19kYnVz X21ldGhvZF9pbnZvY2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCBnX3ZhcmlhbnRfbmV3 KCIocykiLCAiIikpOworICAgIH0KIH0KIAogc3RhdGljIGNvbnN0IEdEQnVzSW50ZXJmYWNlVlRh YmxlIGludGVyZmFjZVZpcnR1YWxUYWJsZSA9IHsK 221540 2014-01-18 01:12:33 -0800 2014-01-18 01:43:28 -0800 Patch bug-125990-20140118111300.patch text/plain 22763 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyMjQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNzZmZWQ1MGI0NmFjYmE5 MGFhYzM5MzVhNWQzNjRhYWI2NTdkNjEzYS4uMWJiMDFjMWM2NzdhY2MzOTgyNWNjMzJiNGExNzYy NWZlZDYxYWQ2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE0LTAxLTE5ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9m IHRoZSBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LAorICAgICAgICBhIEdWYXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRh dGEgdXNpbmcKKyAgICAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19p bml0aWFsaXphdGlvbl91c2VyX2RhdGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6 ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNo aW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRh CisgICAgICAgIGZvciBlYWNoIHByb2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFz IGEgc3RyaW5nLCBwYXNzZWQKKyAgICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRo ZSBpbmplY3RlZCBidW5kbGUgZGVzZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdo aWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAg IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlv biAoZm9yCisgICAgICAgIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVu c2lvbl9pbml0aWFsaXplKCkgaXMKKyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoK KyAgICAgICAgKGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6IERlZmlu ZSBuZXcgY2FsbGJhY2sKKyAgICAgICAgZnVuY3Rpb24gd2hpY2ggY2F1c2VzIGVtaXNzaW9uIG9m IHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zCisgICAgICAgIHNpZ25hbCwgYW5kIHNlcmlh bGl6ZXMgdGhlIGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAg KGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KTogU2V0IHRoZQorICAgICAgICBn ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoKSBjYWxsYmFjay4KKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKHdl YmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFs aXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5IGFzIG5vdyBtZW1iZXIgb2YgV2ViS2l0V2ViQ29udGV4dFByaXZhdGUsCisgICAgICAg IHRvIGJlIGFibGUgdG8gcmV0cmlldmUgaXQgbGF0ZXIuCisgICAgICAgICh3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSk6CisgICAg ICAgIE5ldyBBUEkgbWV0aG9kIHRvIHNldCB0aGUgdXNlciBkYXRhIHBhc3NlZCB0byB0aGUgd2Vi IGV4dGVuc2lvbnMKKyAgICAgICAgd2hlbiBpbml0aWFsaXplZC4KKyAgICAgICAgKHdlYmtpdFdl YkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyk6IFByaXZhdGUgZnVuY3Rpb24gdXNlZAor ICAgICAgICB0byB0cmlnZ2VyIGVtaXNzaW9uIG9mIHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNp b25zIHNpZ25hbC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 Lmg6CisgICAgICAgIEFkZGVkIHByb3RvdHlwZSBmb3IgbmV3IEFQSSBtZXRob2QKKyAgICAgICAg d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2Vy X2RhdGEoKS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJp dmF0ZS5oOgorICAgICAgICBQcm90b3R5cGUgb2YgdGhlIG5ldyBwcml2YXRlIGZ1bmN0aW9uLgor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6 CisgICAgICAgIEFkZCBuZXcgcHVibGljIEFQSSBiaXRzIHRvIHRoZSBkb2N1bWVudGF0aW9uLgor ICAgICAgICAqIFdlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKToKKyAgICAg ICAgRGVzZXJpYWxpemUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJvY2VzcyBhbmQg cGFzcyBpdCB0bworICAgICAgICB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhf dXNlcl9kYXRhKCkgaWYgYXZhaWxhYmxlLAorICAgICAgICBrZWVwaW5nIHdlYmtpdF93ZWJfZXh0 ZW5zaW9uX2luaXRpYWxpemUoKSBhcyBmYWxsYmFjay4KKwogMjAxNC0wMS0xNyAgQ29tbWl0IFF1 ZXVlICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9s bGluZyBvdXQgcjE2MjIzNyBhbmQgcjE2MjI0MS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNw cAppbmRleCA1ZDllMTA2OGY5N2Q2Y2RmZDI1N2FhMWY0OTk0MjY2NGM2ZTZjM2QwLi5mMjcxMjIy MzNiMzc1ZGNhZjQwYjc3YjZkMGVjMWJkNGI5ZDAxMzRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVD bGllbnQuY3BwCkBAIC0xMTgsMTYgKzExOCwyMyBAQCBzdGF0aWMgdm9pZCBkaWRSZWNlaXZlTWVz c2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5nUmVmIG1lc3NhZwog ICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIAorc3RhdGljIFdLVHlwZVJlZiBnZXRJ bmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoV0tDb250ZXh0UmVmLCBjb25zdCB2 b2lkKiBjbGllbnRJbmZvKQoreworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IGRhdGEgPSB3ZWJraXRX ZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV0VCS0lUX1dFQl9DT05URVhUKGNsaWVu dEluZm8pKTsKKyAgICBHT3duUHRyPGdjaGFyPiBkYXRhU3RyaW5nKGdfdmFyaWFudF9wcmludChk YXRhLmdldCgpLCBUUlVFKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PFdLVHlwZVJlZj4oV0tT dHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoZGF0YVN0cmluZy5nZXQoKSkpOworfQorCiB2b2lk IGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KFdlYktpdFdlYkNvbnRleHQqIHdl YkNvbnRleHQpCiB7CiAgICAgV0tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGllbnRWMSB3a0luamVj dGVkQnVuZGxlQ2xpZW50ID0gewogICAgICAgICB7Ci0gICAgICAgICAgICAwLCAvLyB2ZXJzaW9u CisgICAgICAgICAgICAxLCAvLyB2ZXJzaW9uCiAgICAgICAgICAgICB3ZWJDb250ZXh0LCAvLyBj bGllbnRJbmZvCiAgICAgICAgIH0sCiAgICAgICAgIGRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVj dGVkQnVuZGxlLAogICAgICAgICAwLCAvLyBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJv bUluamVjdGVkQnVuZGxlCi0gICAgICAgIDAgLy8gZ2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXph dGlvblVzZXJEYXRhCisgICAgICAgIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2Vy RGF0YQogICAgIH07CiAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGllbnQodG9BUEko d2Via2l0V2ViQ29udGV4dEdldENvbnRleHQod2ViQ29udGV4dCkpLCAmd2tJbmplY3RlZEJ1bmRs ZUNsaWVudC5iYXNlKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAKaW5kZXggMmIxYTVmMzVhODJmNGEwZjg3OTE3ZTRh MGM4YWFhOGI0NWEzZmFhZi4uYzhlNDVhNmQxYzQ4ZGVkODI2NGQxYTNmYTZiMzIwNTQwYmMwNTUz MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Q29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 V2ViQ29udGV4dC5jcHAKQEAgLTg0LDYgKzg0LDcgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsK IAogZW51bSB7CiAgICAgRE9XTkxPQURfU1RBUlRFRCwKKyAgICBJTklUSUFMSVpFX1dFQl9FWFRF TlNJT05TLAogCiAgICAgTEFTVF9TSUdOQUwKIH07CkBAIC0xNTMsNiArMTU0LDkgQEAgc3RydWN0 IF9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZSB7CiAKICAgICBIYXNoTWFwPHVpbnQ2NF90LCBXZWJL aXRXZWJWaWV3Kj4gd2ViVmlld3M7CiAgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3R3JvdXA+IGRl ZmF1bHRXZWJWaWV3R3JvdXA7CisKKyAgICBDU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7 CisgICAgR1JlZlB0cjxHVmFyaWFudD4gd2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0aW9uVXNlckRh dGE7CiB9OwogCiBzdGF0aWMgZ3VpbnQgc2lnbmFsc1tMQVNUX1NJR05BTF0gPSB7IDAsIH07CkBA IC0xNzgsNiArMTgyLDI1IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19p bml0KFdlYktpdFdlYkNvbnRleHRDbGFzcyogd2ViQ29udGV4dENsYXNzCiAgICAgICAgICAgICAg ICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fT0JKRUNULAogICAgICAgICAgICAgICAg ICAgICAgR19UWVBFX05PTkUsIDEsCiAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfVFlQRV9E T1dOTE9BRCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0Ojppbml0aWFsaXpl LXdlYi1leHRlbnNpb25zOgorICAgICAqIEBjb250ZXh0OiB0aGUgI1dlYktpdFdlYkNvbnRleHQK KyAgICAgKgorICAgICAqIFRoaXMgc2lnbmFsIGlzIGVtaXR0ZWQgd2hlbiBhIG5ldyB3ZWIgcHJv Y2VzcyBpcyBhYm91dCB0byBiZQorICAgICAqIGxhdW5jaGVkLiBJdCBzaWduYWxzIHRoZSBtb3N0 IGFwcHJvcHJpYXRlIG1vbWVudCB0byB1c2UKKyAgICAgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0 X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSgpCisgICAgICogYW5kIHdl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KCkuCisgICAgICoK KyAgICAgKiBTaW5jZTogMi40CisgICAgICovCisgICAgc2lnbmFsc1tJTklUSUFMSVpFX1dFQl9F WFRFTlNJT05TXSA9CisgICAgICAgIGdfc2lnbmFsX25ldygiaW5pdGlhbGl6ZS13ZWItZXh0ZW5z aW9ucyIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyhnT2JqZWN0Q2xhc3MpLAorICAg ICAgICAgICAgR19TSUdOQUxfUlVOX0xBU1QsCisgICAgICAgICAgICAwLCBudWxscHRyLCBudWxs cHRyLAorICAgICAgICAgICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX1ZPSUQsCisgICAgICAg ICAgICBHX1RZUEVfTk9ORSwgMCk7CiB9CiAKIHN0YXRpYyBDU3RyaW5nIGluamVjdGVkQnVuZGxl RGlyZWN0b3J5KCkKQEAgLTc4Myw4ICs4MDYsMjAgQEAgdm9pZCB3ZWJraXRfd2ViX2NvbnRleHRf c2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeShXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LAog ICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKICAg ICBnX3JldHVybl9pZl9mYWlsKGRpcmVjdG9yeSk7CiAKLSAgICAvLyBXZSBwYXNzIHRoZSBhZGRp dGlvbmFsIHdlYiBleHRlbnNpb25zIGRpcmVjdG9yeSB0byB0aGUgaW5qZWN0ZWQgYnVuZGxlIGFz IGluaXRpYWxpemF0aW9uIHVzZXIgZGF0YS4KLSAgICBjb250ZXh0LT5wcml2LT5jb250ZXh0LT5z ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoQVBJOjpTdHJpbmc6OmNyZWF0 ZShXZWJDb3JlOjpmaWxlbmFtZVRvU3RyaW5nKGRpcmVjdG9yeSkpKTsKKyAgICBjb250ZXh0LT5w cml2LT53ZWJFeHRlbnNpb25zRGlyZWN0b3J5ID0gZGlyZWN0b3J5OworfQorCisvKioKKyAqIHdl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9k YXRhOgorICogQGNvbnRleHQ6IGEgI1dlYktpdFdlYkNvbnRleHQKKyAqCisgKiBTaW5jZTogMi40 CisgKi8KK3ZvaWQgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFs aXphdGlvbl91c2VyX2RhdGEoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgR1ZhcmlhbnQqIHVz ZXJEYXRhKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNv bnRleHQpKTsKKworICAgIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlv blVzZXJEYXRhID0gdXNlckRhdGE7CiB9CiAKIC8qKgpAQCAtODcyLDYgKzkwNywxNCBAQCB2b2lk IHdlYmtpdFdlYkNvbnRleHREb3dubG9hZFN0YXJ0ZWQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4 dCwgV2ViS2l0RG93bmxvYWQqCiAgICAgZ19zaWduYWxfZW1pdChjb250ZXh0LCBzaWduYWxzW0RP V05MT0FEX1NUQVJURURdLCAwLCBkb3dubG9hZCk7CiB9CiAKK0dSZWZQdHI8R1ZhcmlhbnQ+IHdl YmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXZWJLaXRXZWJDb250ZXh0KiBj b250ZXh0KQoreworICAgIGdfc2lnbmFsX2VtaXQoY29udGV4dCwgc2lnbmFsc1tJTklUSUFMSVpF X1dFQl9FWFRFTlNJT05TXSwgMCk7CisgICAgcmV0dXJuIGFkb3B0R1JlZihnX3ZhcmlhbnRfbmV3 KCIobXNtdikiLAorICAgICAgICBjb250ZXh0LT5wcml2LT53ZWJFeHRlbnNpb25zRGlyZWN0b3J5 LmRhdGEoKSwKKyAgICAgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0 aW9uVXNlckRhdGEuZ2V0KCkpKTsKK30KKwogV2ViQ29udGV4dCogd2Via2l0V2ViQ29udGV4dEdl dENvbnRleHQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKIHsKICAgICBnX2Fzc2VydChXRUJL SVRfSVNfV0VCX0NPTlRFWFQoY29udGV4dCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oCmluZGV4IDllN2JjMTQ0NzZkYjAyMjNh NzhiY2RmNzM4YzJmNjBiOTA2NTNkN2UuLjFlM2I5YjU4OGQ2NWE4NTQ5OWE4NmJiNzE2Y2I2N2Jl MjNkOTIyYWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0LmgKQEAgLTE5Niw2ICsxOTYsMTEgQEAgd2Via2l0X3dlYl9jb250ZXh0 X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3RvcnkgICAgIChXZWJLaXRXZWJDb250ZXh0CiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdj aGFyICAgICAgICAgICAgICAgICAgICpkaXJlY3RvcnkpOwogCiBXRUJLSVRfQVBJIHZvaWQKK3dl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9k YXRhCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg KFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpjb250ZXh0LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVmFyaWFudCAgICAgICAgICAg ICAgICAgICAgICAqdXNlcl9kYXRhKTsKKworV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX2Nv bnRleHRfcHJlZmV0Y2hfZG5zICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQg ICAgICAgICAgICAgICpjb250ZXh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAgICAgICAgICAgICAgICAgICAqaG9zdG5h bWUpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJDb250ZXh0UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaAppbmRleCA4MWM0NzNjNTYxZDhjM2NjMmYzNTVhYjI0 MWU4MDliMGQ4N2ZhYzAyLi4yNjFiNGY2NTU5NDExN2RlZDYyOWVmYWUzZDYzOTMzN2EyOWI2MDY2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJD b250ZXh0UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHRQcml2YXRlLmgKQEAgLTQ3LDUgKzQ3LDYgQEAgdm9pZCB3ZWJraXRXZWJD b250ZXh0Q3JlYXRlUGFnZUZvcldlYlZpZXcoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZp ZXcqLCBXZWIKIHZvaWQgd2Via2l0V2ViQ29udGV4dFdlYlZpZXdEZXN0cm95ZWQoV2ViS2l0V2Vi Q29udGV4dCosIFdlYktpdFdlYlZpZXcqKTsKIFdlYktpdFdlYlZpZXcqIHdlYmtpdFdlYkNvbnRl eHRHZXRXZWJWaWV3Rm9yUGFnZShXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0OjpXZWJQYWdlUHJv eHkqKTsKIFdlYktpdFdlYlZpZXdHcm91cCogd2Via2l0V2ViQ29udGV4dEdldERlZmF1bHRXZWJW aWV3R3JvdXAoV2ViS2l0V2ViQ29udGV4dCopOworR1JlZlB0cjxHVmFyaWFudD4gd2Via2l0V2Vi Q29udGV4dEluaXRpYWxpemVXZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqKTsKIAogI2Vu ZGlmIC8vIFdlYktpdFdlYkNvbnRleHRQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0 CmluZGV4IDA5MGU5MWU2ZGU2MWM0NmYzM2I4OGMxYzhkNDVmYmI3YzE3MjZiMjguLjFjMTNjNmMw NzNhNzVkMTk3ZDcwNTYyYzAyOTc5MjFmN2I2MzgyZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25z LnR4dApAQCAtNDYsNiArNDYsNyBAQCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3ByZWZlcnJlZF9s YW5ndWFnZXMKIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfdGxzX2Vycm9yc19wb2xpY3kKIHdlYmtp dF93ZWJfY29udGV4dF9nZXRfdGxzX2Vycm9yc19wb2xpY3kKIHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5Cit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9l eHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YQogd2Via2l0X3dlYl9jb250ZXh0X3By ZWZldGNoX2Rucwogd2Via2l0X3dlYl9jb250ZXh0X3NldF9kaXNrX2NhY2hlX2RpcmVjdG9yeQog d2Via2l0X3dlYl9jb250ZXh0X2FsbG93X3Rsc19jZXJ0aWZpY2F0ZV9mb3JfaG9zdApAQCAtMTAy Niw2ICsxMDI3LDcgQEAgd2Via2l0X3dlYl92aWV3X2dyb3VwX2dldF90eXBlCiA8RklMRT5XZWJL aXRXZWJFeHRlbnNpb248L0ZJTEU+CiBXZWJLaXRXZWJFeHRlbnNpb24KIFdlYktpdFdlYkV4dGVu c2lvbkluaXRpYWxpemVGdW5jdGlvbgorV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZVdpdGhV c2VyRGF0YUZ1bmN0aW9uCiB3ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfcGFnZQogCiA8U1VCU0VD VElPTiBTdGFuZGFyZD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5q ZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaCBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaApp bmRleCA2N2E0Y2Q1NGNhODI4ZjliYzk3MTMyNGQ0ZWU4ODAxNWY5MmY5MDVmLi44MDE0YThjZDRj M2NiMTBjZDA2ZWYxY2MxMzA3Njk2OWQ0ZmM0MjJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmgK KysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dl YktpdFdlYkV4dGVuc2lvbi5oCkBAIC01MCw2ICs1MCwyMSBAQCB0eXBlZGVmIHN0cnVjdCBfV2Vi S2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZSBXZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlOwogICovCiB0 eXBlZGVmIHZvaWQgKCogV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uKSAoV2Vi S2l0V2ViRXh0ZW5zaW9uICpleHRlbnNpb24pOwogCisvKioKKyAqIFdlYktpdFdlYkV4dGVuc2lv bkluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbjoKKyAqIEBleHRlbnNpb246IGEgI1dlYktp dFdlYkV4dGVuc2lvbgorICogQGV4dHJhX2RhdGE6IGEgI0dWYXJpYW50CisgKgorICogVHlwZSBk ZWZpbml0aW9uIGZvciBhIGZ1bmN0aW9uIHRoYXQgd2lsbCBiZSBjYWxsZWQgdG8gaW5pdGlhbGl6 ZQorICogdGhlIHdlYiBleHRlbnNpb25zIHdoZW4gdGhlIHdlYiBwcm9jZXNzIHN0YXJ0cywgYW5k IHdoaWNoIHJlY2VpdmVzCisgKiBhcyBhZGRpdGlvbmFsIGFyZ3VtZW50IHRoZSB1c2VyIGRhdGEg c2V0IHdpdGgKKyAqIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlh bGl6YXRpb25fdXNlcl9kYXRhKCkuCisgKgorICogU2luY2U6IDAuMjYKKyAqLwordHlwZWRlZiB2 b2lkICgqIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbikg KFdlYktpdFdlYkV4dGVuc2lvbiAqZXh0ZW5zaW9uLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEdWYXJpYW50 ICAgICAqdXNlcl9kYXRhKTsKKwogc3RydWN0IF9XZWJLaXRXZWJFeHRlbnNpb24gewogICAgIEdP YmplY3QgcGFyZW50OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0 ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv Z3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCmluZGV4IGFkN2JhOTlmYjlhMmZjNTRmZjZm NjliMjkyZmE2YmU3ZTQwNjEzMjAuLmJjMmQyZGNhMDNkZmQyMmNlNTBmMmM2Yjc0NTA0YjI3MDcz NjBkNTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4 dGVuc2lvbk1hbmFnZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dl Ykd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCkBAIC0yMiwxMSArMjIsMTMgQEAKIAogI2luY2x1ZGUg IkluamVjdGVkQnVuZGxlLmgiCiAjaW5jbHVkZSAiV0tCdW5kbGVBUElDYXN0LmgiCisjaW5jbHVk ZSAiV0tEaWN0aW9uYXJ5LmgiCiAjaW5jbHVkZSAiV0tTdHJpbmcuaCIKICNpbmNsdWRlICJXS1R5 cGUuaCIKICNpbmNsdWRlICJXZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlLmgiCiAjaW5jbHVkZSA8 V2ViQ29yZS9GaWxlU3lzdGVtLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUg PHd0Zi90ZXh0L0NTdHJpbmcuaD4KIAogbmFtZXNwYWNlIFdlYktpdCB7CiAKQEAgLTQ5LDE5ICs1 MSwzNSBAQCB2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OnNjYW5Nb2R1bGVzKGNvbnN0IFN0 cmluZyYgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSwgVgogICAgIH0KIH0KIAotdm9pZCBXZWJHdGtF eHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKFdLQnVuZGxlUmVmIGJ1bmRsZSwgV0tUeXBlUmVm IHVzZXJEYXRhKQordm9pZCBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKFdLQnVu ZGxlUmVmIGJ1bmRsZSwgV0tUeXBlUmVmIHVzZXJEYXRhU3RyaW5nKQogewotICAgIG1fZXh0ZW5z aW9uID0gYWRvcHRHUmVmKHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSh0b0ltcGwoYnVuZGxlKSkp OworICAgIEFTU0VSVCh1c2VyRGF0YVN0cmluZyk7CisgICAgQVNTRVJUKFdLR2V0VHlwZUlEKHVz ZXJEYXRhU3RyaW5nKSA9PSBXS1N0cmluZ0dldFR5cGVJRCgpKTsKKworICAgIENTdHJpbmcgZGF0 YVN0cmluZyA9IHRvSW1wbChzdGF0aWNfY2FzdDxXS1N0cmluZ1JlZj4odXNlckRhdGFTdHJpbmcp KS0+c3RyaW5nKCkudXRmOCgpOworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHZhcmlhbnQgPQorICAg ICAgICBnX3ZhcmlhbnRfcGFyc2UobnVsbHB0ciwgZGF0YVN0cmluZy5kYXRhKCksIGRhdGFTdHJp bmcuZGF0YSgpICsgZGF0YVN0cmluZy5sZW5ndGgoKSwgbnVsbHB0ciwgbnVsbHB0cik7CisKKyAg ICBBU1NFUlQodmFyaWFudCk7CisgICAgQVNTRVJUKGdfdmFyaWFudF9jaGVja19mb3JtYXRfc3Ry aW5nKHZhcmlhbnQuZ2V0KCksICIobSZzbXYpIiwgRkFMU0UpKTsKKworICAgIGNvbnN0IGNoYXIq IGRpcmVjdG9yeSA9IG51bGxwdHI7CisgICAgR1ZhcmlhbnQqIGRhdGEgPSBudWxscHRyOworICAg IGdfdmFyaWFudF9nZXQodmFyaWFudC5nZXQoKSwgIihtJnNtdikiLCAmZGlyZWN0b3J5LCAmZGF0 YSk7CiAKICAgICBTdHJpbmcgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeTsKLSAgICBpZiAodXNlckRh dGEpIHsKLSAgICAgICAgQVNTRVJUKFdLR2V0VHlwZUlEKHVzZXJEYXRhKSA9PSBXS1N0cmluZ0dl dFR5cGVJRCgpKTsKLSAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IHRvSW1wbChzdGF0 aWNfY2FzdDxXS1N0cmluZ1JlZj4odXNlckRhdGEpKS0+c3RyaW5nKCk7Ci0gICAgfQorICAgIGlm IChkaXJlY3RvcnkpCisgICAgICAgIHdlYkV4dGVuc2lvbnNEaXJlY3RvcnkgPSBTdHJpbmc6OmZy b21VVEY4KGRpcmVjdG9yeSk7CiAKICAgICBpZiAod2ViRXh0ZW5zaW9uc0RpcmVjdG9yeS5pc051 bGwoKSkKICAgICAgICAgcmV0dXJuOwogCisgICAgR1JlZlB0cjxHVmFyaWFudD4gdXNlckRhdGE7 CisgICAgaWYgKGRhdGEpCisgICAgICAgIHVzZXJEYXRhID0gZGF0YTsKKworICAgIG1fZXh0ZW5z aW9uID0gYWRvcHRHUmVmKHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSh0b0ltcGwoYnVuZGxlKSkp OworCiAgICAgVmVjdG9yPFN0cmluZz4gbW9kdWxlUGF0aHM7CiAgICAgc2Nhbk1vZHVsZXMod2Vi RXh0ZW5zaW9uc0RpcmVjdG9yeSwgbW9kdWxlUGF0aHMpOwogCkBAIC03MCwxMyArODgsMTggQEAg dm9pZCBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKFdLQnVuZGxlUmVmIGJ1bmRs ZSwgV0tUeXBlUmVmIHVzZXJEYXRhKQogICAgICAgICBpZiAoIW1vZHVsZS0+bG9hZCgpKQogICAg ICAgICAgICAgY29udGludWU7CiAKKyAgICAgICAgV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6 ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uIGluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbiA9Cisg ICAgICAgICAgICBtb2R1bGUtPmZ1bmN0aW9uUG9pbnRlcjxXZWJLaXRXZWJFeHRlbnNpb25Jbml0 aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb24+KCJ3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFs aXplX3dpdGhfdXNlcl9kYXRhIik7CiAgICAgICAgIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxp emVGdW5jdGlvbiBpbml0aWFsaXplRnVuY3Rpb24gPQogICAgICAgICAgICAgbW9kdWxlLT5mdW5j dGlvblBvaW50ZXI8V2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uPigid2Via2l0 X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZSIpOwotICAgICAgICBpZiAoIWluaXRpYWxpemVGdW5j dGlvbikKKyAgICAgICAgaWYgKCFpbml0aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb24gJiYgIWlu aXRpYWxpemVGdW5jdGlvbikKICAgICAgICAgICAgIGNvbnRpbnVlOwogCiAgICAgICAgIG1fZXh0 ZW5zaW9uTW9kdWxlcy5hcHBlbmQobW9kdWxlLmxlYWtQdHIoKSk7Ci0gICAgICAgIGluaXRpYWxp emVGdW5jdGlvbihtX2V4dGVuc2lvbi5nZXQoKSk7CisgICAgICAgIGlmIChpbml0aWFsaXplV2l0 aFVzZXJEYXRhRnVuY3Rpb24pCisgICAgICAgICAgICBpbml0aWFsaXplV2l0aFVzZXJEYXRhRnVu Y3Rpb24obV9leHRlbnNpb24uZ2V0KCksIHVzZXJEYXRhLmdldCgpKTsKKyAgICAgICAgZWxzZQor ICAgICAgICAgICAgaW5pdGlhbGl6ZUZ1bmN0aW9uKG1fZXh0ZW5zaW9uLmdldCgpKTsKICAgICB9 CiB9CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCAyNjNmZTc4YTZlYTdhYmE0ZTFlOTY0MjFjNWI4MmU2Y2Y2NWUwNGFjLi41NDc5YjRkMmFlNjk2 MDU2NmNmZGIzNmZjNmMxMTEwNWE4YjRjZmY0IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cK KysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTQtMDEtMTkgIEFkcmlh biBQZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBB bGxvdyBwYXNzaW5nIGV4dHJhIGRhdGEgdG8gd2ViIGV4dGVuc2lvbnMKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyNTk5MAorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFsbG93IHBhc3NpbmcgYWRkaXRpb25h bCBpbmZvcm1hdGlvbiB0byB0aGUgaW5qZWN0ZWQgYnVuZGxlLiBPbiB0b3AKKyAgICAgICAgb2Yg dGhlIHN0cmluZyBjb250YWluaW5nIHRoZSBwYXRoIHRvIHRoZSB3ZWIgZXh0ZW5zaW9ucyBkaXJl Y3RvcnksCisgICAgICAgIGEgR1ZhcmlhbnQgY2FuIGJlIHNldCB3aXRoIGFkZGl0aW9uYWwgZGF0 YSB1c2luZworICAgICAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2lu aXRpYWxpemF0aW9uX3VzZXJfZGF0YSgpLgorICAgICAgICBBbHNvLCBhIG5ldyBpbml0aWFsaXpl LXdlYi1leHRlbnNpb25zIHNpZ25hbCBpcyBlbWl0dGVkIGJlZm9yZQorICAgICAgICBsYXVuY2hp bmcgYSBuZXcgV2ViUHJvY2VzcyB0byBhbGxvdyBzZXR0aW5nIGRpZmZlcmVudCB1c2VyIGRhdGEK KyAgICAgICAgZm9yIGVhY2ggcHJvY2Vzcy4gVGhlIEdWYXJpYW50IGlzIHNlcmlhbGl6ZWQgYXMg YSBzdHJpbmcsIHBhc3NlZAorICAgICAgICB0byB0aGUgaW5qZWN0ZWQgYnVuZGxlLCBhbmQgdGhl IGluamVjdGVkIGJ1bmRsZSBkZXNlcmlhbGl6ZXMgYmFjaworICAgICAgICB0aGUgZGF0YSwgd2hp Y2ggaXMgcGFzc2VkIHRvIHdlYiBleHRlbnNpb25zIHdoaWNoIGRlZmluZSB0aGUKKyAgICAgICAg d2Via2l0X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZV93aXRoX3VzZXJfZGF0YSgpIGZ1bmN0aW9u IChmb3IKKyAgICAgICAgYmFja3dhcmRzIGNvbXBhdGliaWxpdHksIHdlYmtpdF93ZWJfZXh0ZW5z aW9uX2luaXRpYWxpemUoKSBpcworICAgICAgICB1c2VkIGFzIGEgZmFsbGJhY2suKQorCisgICAg ICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJFeHRlbnNpb25zLmNw cDoKKyAgICAgICAgKGluaXRpYWxpemVXZWJFeHRlbnNpb25zKTogSGFuZGxlcyB0aGUgaW5pdGlh bGl6ZS13ZWItZXh0ZW5zaW9ucworICAgICAgICBzaWduYWwsIGFuZCBzZXRzIHRoZSB3ZWIgZXh0 ZW5zaW9ucyBkaXJlY3RvcnkgYW5kIHRoZSBpbml0aWFsaXphdGlvbgorICAgICAgICB1c2VyIGRh dGEuCisgICAgICAgICh0ZXN0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6IE5l dyB0ZXN0IGNhc2UgZm9yIGNoZWNraW5nCisgICAgICAgIHRoZSB1c2VyIGRhdGEgcGFzc2VkIG9u IGluaXRpYWxpemF0aW9uIHRvIHdlYiBleHRlbnNpb25zLgorICAgICAgICAqIFRlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0Mkd0ay9XZWJFeHRlbnNpb25UZXN0LmNwcDoKKyAgICAgICAgKG1ldGhv ZENhbGxDYWxsYmFjayk6IEFkZGVkIGltcGxlbWVudGF0aW9uIGZvciB0aGUgQ2hlY2tVc2VyRGF0 YQorICAgICAgICBELUJ1cyBtZXRob2QsIHVzZWQgYnkgdGVzdFdlYkV4dGVuc2lvbkluaXRpYWxp emF0aW9uVXNlckRhdGEoKS4KKyAgICAgICAgKHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxp emVfd2l0aF91c2VyX2RhdGEpOiBEZWZpbmUgdGhlCisgICAgICAgIGluaXRpYWxpemF0aW9uIGZ1 bmN0aW9uIHdpdGggdGhlIGFkZGl0aW9uYWwgdXNlciBkYXRhIHBhcmFtZXRlci4KKwogMjAxNC0w MS0xNyAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBidWls ZC53ZWJraXQub3JnL2Rhc2hib2FyZCBzaG91bGQgaGF2ZSBkaWZmIGxpbmtzIGluIHRlc3QgcmVz dWx0cyBwb3BvdmVycwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyR3RrL1Rlc3RXZWJFeHRlbnNpb25zLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHAKaW5kZXggYjAzYzlkY2FkNWEzN2RhZWE0 MGI3YmFkMjM5YmMzYTc1ZWE3MWI4OS4uYzhiNTc5MWEzZmVlN2IxMDAxY2NiMGY0MTZhYWZmYzJk NDgyMjQ1MSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3Rr L1Rlc3RXZWJFeHRlbnNpb25zLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDJHdGsvVGVzdFdlYkV4dGVuc2lvbnMuY3BwCkBAIC0yMyw2ICsyMyw3IEBACiAjaW5jbHVk ZSAiV2ViVmlld1Rlc3QuaCIKICNpbmNsdWRlIDx3dGYvZ29iamVjdC9HUmVmUHRyLmg+CiAKK3N0 YXRpYyBjb25zdCBjaGFyKiB3ZWJFeHRlbnNpb25zVXNlckRhdGEgPSAiV2ViIEV4dGVuc2lvbnMg dXNlciBkYXRhIjsKIHN0YXRpYyBXZWJLaXRUZXN0QnVzKiBidXM7CiAKIHN0YXRpYyB2b2lkIHRl c3RXZWJFeHRlbnNpb25HZXRUaXRsZShXZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikK QEAgLTE3NSwxMyArMTc2LDQ3IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJFeHRlbnNpb25Jc29sYXRl ZFdvcmxkKFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQogICAgIGdfc2lnbmFsX2hh bmRsZXJfZGlzY29ubmVjdCh0ZXN0LT5tX3dlYlZpZXcsIHNjcmlwdERpYWxvZ0lEKTsKIH0KIAor c3RhdGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbkluaXRpYWxpemF0aW9uVXNlckRhdGEoV2ViVmll d1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgdGVzdC0+bG9hZEh0bWwoIjxodG1s PjwvaHRtbD4iLCAwKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAg IEdSZWZQdHI8R1ZhcmlhbnQ+IHVzZXJEYXRhID0gYWRvcHRHUmVmKGdfdmFyaWFudF9uZXcoInMi LCB3ZWJFeHRlbnNpb25zVXNlckRhdGEpKTsKKyAgICBHT3duUHRyPGdjaGFyPiB1c2VyRGF0YVN0 cmluZyhnX3ZhcmlhbnRfcHJpbnQodXNlckRhdGEuZ2V0KCksIFRSVUUpKTsKKworICAgIEdSZWZQ dHI8R0RCdXNQcm94eT4gcHJveHkgPSBhZG9wdEdSZWYoYnVzLT5jcmVhdGVQcm94eSgib3JnLndl YmtpdC5ndGsuV2ViRXh0ZW5zaW9uVGVzdCIsCisgICAgICAgICIvb3JnL3dlYmtpdC9ndGsvV2Vi RXh0ZW5zaW9uVGVzdCIsICJvcmcud2Via2l0Lmd0ay5XZWJFeHRlbnNpb25UZXN0IiwgdGVzdC0+ bV9tYWluTG9vcCkpOworCisgICAgR1JlZlB0cjxHVmFyaWFudD4gcmVzdWx0ID0gYWRvcHRHUmVm KGdfZGJ1c19wcm94eV9jYWxsX3N5bmMoCisgICAgICAgIHByb3h5LmdldCgpLAorICAgICAgICAi Q2hlY2tVc2VyRGF0YSIsCisgICAgICAgIGdfdmFyaWFudF9uZXcoIigmcykiLCB1c2VyRGF0YVN0 cmluZy5nZXQoKSksCisgICAgICAgIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsCisgICAgICAgIC0x LCAwLCAwKSk7CisgICAgZ19hc3NlcnQocmVzdWx0KTsKKworICAgIGdib29sZWFuIHN1Y2Nlc3Mg PSBGQUxTRTsKKyAgICBnX3ZhcmlhbnRfZ2V0KHJlc3VsdC5nZXQoKSwgIihiKSIsICZzdWNjZXNz KTsKKyAgICBnX2Fzc2VydChzdWNjZXNzKTsKK30KKworc3RhdGljIHZvaWQgaW5pdGlhbGl6ZVdl YkV4dGVuc2lvbnMoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgZ3BvaW50ZXIpCit7CisgICAg d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3RvcnkoY29udGV4dCwg V0VCS0lUX1RFU1RfV0VCX0VYVEVOU0lPTlNfRElSKTsKKyAgICB3ZWJraXRfd2ViX2NvbnRleHRf c2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YShjb250ZXh0LAorICAg ICAgICBnX3ZhcmlhbnRfbmV3KCImcyIsIHdlYkV4dGVuc2lvbnNVc2VyRGF0YSkpOworfQorCiB2 b2lkIGJlZm9yZUFsbCgpCiB7Ci0gICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5z aW9uc19kaXJlY3Rvcnkod2Via2l0X3dlYl9jb250ZXh0X2dldF9kZWZhdWx0KCksIFdFQktJVF9U RVNUX1dFQl9FWFRFTlNJT05TX0RJUik7CisgICAgZ19zaWduYWxfY29ubmVjdCh3ZWJraXRfd2Vi X2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwKKyAgICAgICAgImluaXRpYWxpemUtd2ViLWV4dGVuc2lv bnMiLCBHX0NBTExCQUNLKGluaXRpYWxpemVXZWJFeHRlbnNpb25zKSwgbnVsbHB0cik7CisKICAg ICBidXMgPSBuZXcgV2ViS2l0VGVzdEJ1cygpOwogICAgIGlmICghYnVzLT5ydW4oKSkKICAgICAg ICAgcmV0dXJuOwogCisgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViQ29udGV4dCIsICJp bml0aWFsaXphdGlvbi11c2VyLWRhdGEiLCB0ZXN0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6YXRpb25V c2VyRGF0YSk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViRXh0ZW5zaW9uIiwgImRv bS1kb2N1bWVudC10aXRsZSIsIHRlc3RXZWJFeHRlbnNpb25HZXRUaXRsZSk7CiAgICAgV2ViVmll d1Rlc3Q6OmFkZCgiV2ViS2l0V2ViRXh0ZW5zaW9uIiwgImRvY3VtZW50LWxvYWRlZC1zaWduYWwi LCB0ZXN0RG9jdW1lbnRMb2FkZWRTaWduYWwpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktp dFdlYlZpZXciLCAid2ViLXByb2Nlc3MtY3Jhc2hlZCIsIHRlc3RXZWJLaXRXZWJWaWV3UHJvY2Vz c0NyYXNoZWQpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy R3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwCmluZGV4IDQwY2I2Y2FmOTE1ZTE0YmM4MTQ5ZjNj ZDNiM2MwZWYzODI5MjgxNTcuLmJhMTBmNzFiZGZhZmEwZWE4NGFjNzIzYzExYWY1YTMyYTczNmYz MWYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9XZWJF eHRlbnNpb25UZXN0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJH dGsvV2ViRXh0ZW5zaW9uVGVzdC5jcHAKQEAgLTQ1LDYgKzQ1LDEwIEBAIHN0YXRpYyBjb25zdCBj aGFyIGludHJvc3BlY3Rpb25YTUxbXSA9CiAgICAgIiAgIDxhcmcgdHlwZT0ndCcgbmFtZT0ncGFn ZUlEJyBkaXJlY3Rpb249J2luJy8+IgogICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9J3Njcmlw dCcgZGlyZWN0aW9uPSdpbicvPiIKICAgICAiICA8L21ldGhvZD4iCisgICAgIiAgPG1ldGhvZCBu YW1lPSdDaGVja1VzZXJEYXRhJz4iCisgICAgIiAgIDxhcmcgdHlwZT0ncycgbmFtZT0ndXNlcmRh dGEnIGRpcmVjdGlvbj0naW4nLz4iCisgICAgIiAgIDxhcmcgdHlwZT0nYicgbmFtZT0nc3VjY2Vz cycgZGlyZWN0aW9uPSdvdXQnLz4iCisgICAgIiAgPC9tZXRob2Q+IgogICAgICIgIDxzaWduYWwg bmFtZT0nRG9jdW1lbnRMb2FkZWQnLz4iCiAgICAgIiAgPHNpZ25hbCBuYW1lPSdVUklDaGFuZ2Vk Jz4iCiAgICAgIiAgIDxhcmcgdHlwZT0ncycgbmFtZT0ndXJpJyBkaXJlY3Rpb249J291dCcvPiIK QEAgLTUyLDYgKzU2LDkgQEAgc3RhdGljIGNvbnN0IGNoYXIgaW50cm9zcGVjdGlvblhNTFtdID0K ICAgICAiIDwvaW50ZXJmYWNlPiIKICAgICAiPC9ub2RlPiI7CiAKK3N0YXRpYyBHUmVmUHRyPEdW YXJpYW50PiBpbml0aWFsaXphdGlvblVzZXJEYXRhOworCisKIHR5cGVkZWYgZW51bSB7CiAgICAg RG9jdW1lbnRMb2FkZWRTaWduYWwsCiAgICAgVVJJQ2hhbmdlZFNpZ25hbCwKQEAgLTIxMCw4ICsy MTcsMTkgQEAgc3RhdGljIHZvaWQgbWV0aG9kQ2FsbENhbGxiYWNrKEdEQnVzQ29ubmVjdGlvbiog Y29ubmVjdGlvbiwgY29uc3QgY2hhciogc2VuZGVyLAogICAgICAgICBKU1JldGFpblB0cjxKU1N0 cmluZ1JlZj4ganNTY3JpcHQoQWRvcHQsIEpTU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKHNj cmlwdCkpOwogICAgICAgICBKU0V2YWx1YXRlU2NyaXB0KGpzQ29udGV4dCwganNTY3JpcHQuZ2V0 KCksIDAsIDAsIDAsIDApOwogICAgICAgICBnX2RidXNfbWV0aG9kX2ludm9jYXRpb25fcmV0dXJu X3ZhbHVlKGludm9jYXRpb24sIDApOwotICAgIH0gZWxzZSBpZiAoIWdfc3RyY21wMChtZXRob2RO YW1lLCAiQWJvcnRQcm9jZXNzIikpCisgICAgfSBlbHNlIGlmICghZ19zdHJjbXAwKG1ldGhvZE5h bWUsICJBYm9ydFByb2Nlc3MiKSkgewogICAgICAgICBhYm9ydCgpOworICAgIH0gZWxzZSBpZiAo IWdfc3RyY21wMChtZXRob2ROYW1lLCAiQ2hlY2tVc2VyRGF0YSIpKSB7CisgICAgICAgIGlmICgh aW5pdGlhbGl6YXRpb25Vc2VyRGF0YSkgeworICAgICAgICAgICAgZ19kYnVzX21ldGhvZF9pbnZv Y2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCBnX3ZhcmlhbnRfbmV3KCIoYikiLCBGQUxT RSkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgICAgIEdPd25QdHI8Z2No YXI+IGluaXRpYWxpemF0aW9uVXNlckRhdGFTdHJpbmcoZ192YXJpYW50X3ByaW50KGluaXRpYWxp emF0aW9uVXNlckRhdGEuZ2V0KCksIFRSVUUpKTsKKyAgICAgICAgY29uc3QgZ2NoYXIqIGNoZWNr U3RyaW5nID0gbnVsbHB0cjsKKyAgICAgICAgZ192YXJpYW50X2dldChwYXJhbWV0ZXJzLCAiKCZz KSIsICZjaGVja1N0cmluZyk7CisgICAgICAgIGdfZGJ1c19tZXRob2RfaW52b2NhdGlvbl9yZXR1 cm5fdmFsdWUoaW52b2NhdGlvbiwKKyAgICAgICAgICAgIGdfdmFyaWFudF9uZXcoIihiKSIsIGdf c3RyX2VxdWFsKGNoZWNrU3RyaW5nLCBpbml0aWFsaXphdGlvblVzZXJEYXRhU3RyaW5nLmdldCgp KSkpOworICAgIH0KIH0KIAogc3RhdGljIGNvbnN0IEdEQnVzSW50ZXJmYWNlVlRhYmxlIGludGVy ZmFjZVZpcnR1YWxUYWJsZSA9IHsKQEAgLTI1MCw4ICsyNjgsMTAgQEAgc3RhdGljIHZvaWQgYnVz QWNxdWlyZWRDYWxsYmFjayhHREJ1c0Nvbm5lY3Rpb24qIGNvbm5lY3Rpb24sIGNvbnN0IGNoYXIq IG5hbWUsIGcKICAgICB9CiB9CiAKLWV4dGVybiAiQyIgdm9pZCB3ZWJraXRfd2ViX2V4dGVuc2lv bl9pbml0aWFsaXplKFdlYktpdFdlYkV4dGVuc2lvbiogZXh0ZW5zaW9uKQorZXh0ZXJuICJDIiB2 b2lkIHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoV2ViS2l0 V2ViRXh0ZW5zaW9uKiBleHRlbnNpb24sIEdWYXJpYW50KiB1c2VyRGF0YSkKIHsKKyAgICBpbml0 aWFsaXphdGlvblVzZXJEYXRhID0gdXNlckRhdGE7CisKICAgICBnX3NpZ25hbF9jb25uZWN0KGV4 dGVuc2lvbiwgInBhZ2UtY3JlYXRlZCIsIEdfQ0FMTEJBQ0socGFnZUNyZWF0ZWRDYWxsYmFjayks IGV4dGVuc2lvbik7CiAgICAgZ19zaWduYWxfY29ubmVjdCh3ZWJraXRfc2NyaXB0X3dvcmxkX2dl dF9kZWZhdWx0KCksICJ3aW5kb3ctb2JqZWN0LWNsZWFyZWQiLCBHX0NBTExCQUNLKHdpbmRvd09i amVjdENsZWFyZWQpLCAwKTsKIAo= 221541 2014-01-18 01:44:06 -0800 2014-01-19 08:49:08 -0800 Patch bug-125990-20140118114433.patch text/plain 22762 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyMjQ1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNzZmZWQ1MGI0NmFjYmE5 MGFhYzM5MzVhNWQzNjRhYWI2NTdkNjEzYS4uMWJiMDFjMWM2NzdhY2MzOTgyNWNjMzJiNGExNzYy NWZlZDYxYWQ2ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE0LTAxLTE5ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9m IHRoZSBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LAorICAgICAgICBhIEdWYXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRh dGEgdXNpbmcKKyAgICAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19p bml0aWFsaXphdGlvbl91c2VyX2RhdGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6 ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNo aW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRh CisgICAgICAgIGZvciBlYWNoIHByb2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFz IGEgc3RyaW5nLCBwYXNzZWQKKyAgICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRo ZSBpbmplY3RlZCBidW5kbGUgZGVzZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdo aWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAg IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlv biAoZm9yCisgICAgICAgIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVu c2lvbl9pbml0aWFsaXplKCkgaXMKKyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoK KyAgICAgICAgKGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6IERlZmlu ZSBuZXcgY2FsbGJhY2sKKyAgICAgICAgZnVuY3Rpb24gd2hpY2ggY2F1c2VzIGVtaXNzaW9uIG9m IHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zCisgICAgICAgIHNpZ25hbCwgYW5kIHNlcmlh bGl6ZXMgdGhlIGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAg KGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KTogU2V0IHRoZQorICAgICAgICBn ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoKSBjYWxsYmFjay4KKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKHdl YmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFs aXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5IGFzIG5vdyBtZW1iZXIgb2YgV2ViS2l0V2ViQ29udGV4dFByaXZhdGUsCisgICAgICAg IHRvIGJlIGFibGUgdG8gcmV0cmlldmUgaXQgbGF0ZXIuCisgICAgICAgICh3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSk6CisgICAg ICAgIE5ldyBBUEkgbWV0aG9kIHRvIHNldCB0aGUgdXNlciBkYXRhIHBhc3NlZCB0byB0aGUgd2Vi IGV4dGVuc2lvbnMKKyAgICAgICAgd2hlbiBpbml0aWFsaXplZC4KKyAgICAgICAgKHdlYmtpdFdl YkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyk6IFByaXZhdGUgZnVuY3Rpb24gdXNlZAor ICAgICAgICB0byB0cmlnZ2VyIGVtaXNzaW9uIG9mIHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNp b25zIHNpZ25hbC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 Lmg6CisgICAgICAgIEFkZGVkIHByb3RvdHlwZSBmb3IgbmV3IEFQSSBtZXRob2QKKyAgICAgICAg d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2Vy X2RhdGEoKS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJp dmF0ZS5oOgorICAgICAgICBQcm90b3R5cGUgb2YgdGhlIG5ldyBwcml2YXRlIGZ1bmN0aW9uLgor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6 CisgICAgICAgIEFkZCBuZXcgcHVibGljIEFQSSBiaXRzIHRvIHRoZSBkb2N1bWVudGF0aW9uLgor ICAgICAgICAqIFdlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKToKKyAgICAg ICAgRGVzZXJpYWxpemUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJvY2VzcyBhbmQg cGFzcyBpdCB0bworICAgICAgICB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhf dXNlcl9kYXRhKCkgaWYgYXZhaWxhYmxlLAorICAgICAgICBrZWVwaW5nIHdlYmtpdF93ZWJfZXh0 ZW5zaW9uX2luaXRpYWxpemUoKSBhcyBmYWxsYmFjay4KKwogMjAxNC0wMS0xNyAgQ29tbWl0IFF1 ZXVlICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9s bGluZyBvdXQgcjE2MjIzNyBhbmQgcjE2MjI0MS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNw cAppbmRleCA1ZDllMTA2OGY5N2Q2Y2RmZDI1N2FhMWY0OTk0MjY2NGM2ZTZjM2QwLi5mMjcxMjIy MzNiMzc1ZGNhZjQwYjc3YjZkMGVjMWJkNGI5ZDAxMzRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVD bGllbnQuY3BwCkBAIC0xMTgsMTYgKzExOCwyMyBAQCBzdGF0aWMgdm9pZCBkaWRSZWNlaXZlTWVz c2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5nUmVmIG1lc3NhZwog ICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIAorc3RhdGljIFdLVHlwZVJlZiBnZXRJ bmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoV0tDb250ZXh0UmVmLCBjb25zdCB2 b2lkKiBjbGllbnRJbmZvKQoreworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IGRhdGEgPSB3ZWJraXRX ZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV0VCS0lUX1dFQl9DT05URVhUKGNsaWVu dEluZm8pKTsKKyAgICBHT3duUHRyPGdjaGFyPiBkYXRhU3RyaW5nKGdfdmFyaWFudF9wcmludChk YXRhLmdldCgpLCBUUlVFKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PFdLVHlwZVJlZj4oV0tT dHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoZGF0YVN0cmluZy5nZXQoKSkpOworfQorCiB2b2lk IGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KFdlYktpdFdlYkNvbnRleHQqIHdl YkNvbnRleHQpCiB7CiAgICAgV0tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGllbnRWMSB3a0luamVj dGVkQnVuZGxlQ2xpZW50ID0gewogICAgICAgICB7Ci0gICAgICAgICAgICAwLCAvLyB2ZXJzaW9u CisgICAgICAgICAgICAxLCAvLyB2ZXJzaW9uCiAgICAgICAgICAgICB3ZWJDb250ZXh0LCAvLyBj bGllbnRJbmZvCiAgICAgICAgIH0sCiAgICAgICAgIGRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVj dGVkQnVuZGxlLAogICAgICAgICAwLCAvLyBkaWRSZWNlaXZlU3luY2hyb25vdXNNZXNzYWdlRnJv bUluamVjdGVkQnVuZGxlCi0gICAgICAgIDAgLy8gZ2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXph dGlvblVzZXJEYXRhCisgICAgICAgIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2Vy RGF0YQogICAgIH07CiAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGllbnQodG9BUEko d2Via2l0V2ViQ29udGV4dEdldENvbnRleHQod2ViQ29udGV4dCkpLCAmd2tJbmplY3RlZEJ1bmRs ZUNsaWVudC5iYXNlKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAKaW5kZXggMmIxYTVmMzVhODJmNGEwZjg3OTE3ZTRh MGM4YWFhOGI0NWEzZmFhZi4uYzhlNDVhNmQxYzQ4ZGVkODI2NGQxYTNmYTZiMzIwNTQwYmMwNTUz MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Q29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 V2ViQ29udGV4dC5jcHAKQEAgLTg0LDYgKzg0LDcgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsK IAogZW51bSB7CiAgICAgRE9XTkxPQURfU1RBUlRFRCwKKyAgICBJTklUSUFMSVpFX1dFQl9FWFRF TlNJT05TLAogCiAgICAgTEFTVF9TSUdOQUwKIH07CkBAIC0xNTMsNiArMTU0LDkgQEAgc3RydWN0 IF9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZSB7CiAKICAgICBIYXNoTWFwPHVpbnQ2NF90LCBXZWJL aXRXZWJWaWV3Kj4gd2ViVmlld3M7CiAgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3R3JvdXA+IGRl ZmF1bHRXZWJWaWV3R3JvdXA7CisKKyAgICBDU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7 CisgICAgR1JlZlB0cjxHVmFyaWFudD4gd2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0aW9uVXNlckRh dGE7CiB9OwogCiBzdGF0aWMgZ3VpbnQgc2lnbmFsc1tMQVNUX1NJR05BTF0gPSB7IDAsIH07CkBA IC0xNzgsNiArMTgyLDI1IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfY29udGV4dF9jbGFzc19p bml0KFdlYktpdFdlYkNvbnRleHRDbGFzcyogd2ViQ29udGV4dENsYXNzCiAgICAgICAgICAgICAg ICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fT0JKRUNULAogICAgICAgICAgICAgICAg ICAgICAgR19UWVBFX05PTkUsIDEsCiAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfVFlQRV9E T1dOTE9BRCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0Ojppbml0aWFsaXpl LXdlYi1leHRlbnNpb25zOgorICAgICAqIEBjb250ZXh0OiB0aGUgI1dlYktpdFdlYkNvbnRleHQK KyAgICAgKgorICAgICAqIFRoaXMgc2lnbmFsIGlzIGVtaXR0ZWQgd2hlbiBhIG5ldyB3ZWIgcHJv Y2VzcyBpcyBhYm91dCB0byBiZQorICAgICAqIGxhdW5jaGVkLiBJdCBzaWduYWxzIHRoZSBtb3N0 IGFwcHJvcHJpYXRlIG1vbWVudCB0byB1c2UKKyAgICAgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0 X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSgpCisgICAgICogYW5kIHdl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KCkuCisgICAgICoK KyAgICAgKiBTaW5jZTogMi40CisgICAgICovCisgICAgc2lnbmFsc1tJTklUSUFMSVpFX1dFQl9F WFRFTlNJT05TXSA9CisgICAgICAgIGdfc2lnbmFsX25ldygiaW5pdGlhbGl6ZS13ZWItZXh0ZW5z aW9ucyIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyhnT2JqZWN0Q2xhc3MpLAorICAg ICAgICAgICAgR19TSUdOQUxfUlVOX0xBU1QsCisgICAgICAgICAgICAwLCBudWxscHRyLCBudWxs cHRyLAorICAgICAgICAgICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX1ZPSUQsCisgICAgICAg ICAgICBHX1RZUEVfTk9ORSwgMCk7CiB9CiAKIHN0YXRpYyBDU3RyaW5nIGluamVjdGVkQnVuZGxl RGlyZWN0b3J5KCkKQEAgLTc4Myw4ICs4MDYsMjAgQEAgdm9pZCB3ZWJraXRfd2ViX2NvbnRleHRf c2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeShXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LAog ICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKICAg ICBnX3JldHVybl9pZl9mYWlsKGRpcmVjdG9yeSk7CiAKLSAgICAvLyBXZSBwYXNzIHRoZSBhZGRp dGlvbmFsIHdlYiBleHRlbnNpb25zIGRpcmVjdG9yeSB0byB0aGUgaW5qZWN0ZWQgYnVuZGxlIGFz IGluaXRpYWxpemF0aW9uIHVzZXIgZGF0YS4KLSAgICBjb250ZXh0LT5wcml2LT5jb250ZXh0LT5z ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoQVBJOjpTdHJpbmc6OmNyZWF0 ZShXZWJDb3JlOjpmaWxlbmFtZVRvU3RyaW5nKGRpcmVjdG9yeSkpKTsKKyAgICBjb250ZXh0LT5w cml2LT53ZWJFeHRlbnNpb25zRGlyZWN0b3J5ID0gZGlyZWN0b3J5OworfQorCisvKioKKyAqIHdl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9k YXRhOgorICogQGNvbnRleHQ6IGEgI1dlYktpdFdlYkNvbnRleHQKKyAqCisgKiBTaW5jZTogMi40 CisgKi8KK3ZvaWQgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFs aXphdGlvbl91c2VyX2RhdGEoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCwgR1ZhcmlhbnQqIHVz ZXJEYXRhKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNv bnRleHQpKTsKKworICAgIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNJbml0aWFsaXphdGlv blVzZXJEYXRhID0gdXNlckRhdGE7CiB9CiAKIC8qKgpAQCAtODcyLDYgKzkwNywxNCBAQCB2b2lk IHdlYmtpdFdlYkNvbnRleHREb3dubG9hZFN0YXJ0ZWQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4 dCwgV2ViS2l0RG93bmxvYWQqCiAgICAgZ19zaWduYWxfZW1pdChjb250ZXh0LCBzaWduYWxzW0RP V05MT0FEX1NUQVJURURdLCAwLCBkb3dubG9hZCk7CiB9CiAKK0dSZWZQdHI8R1ZhcmlhbnQ+IHdl YmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXZWJLaXRXZWJDb250ZXh0KiBj b250ZXh0KQoreworICAgIGdfc2lnbmFsX2VtaXQoY29udGV4dCwgc2lnbmFsc1tJTklUSUFMSVpF X1dFQl9FWFRFTlNJT05TXSwgMCk7CisgICAgcmV0dXJuIGFkb3B0R1JlZihnX3ZhcmlhbnRfbmV3 KCIobXNtdikiLAorICAgICAgICBjb250ZXh0LT5wcml2LT53ZWJFeHRlbnNpb25zRGlyZWN0b3J5 LmRhdGEoKSwKKyAgICAgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0 aW9uVXNlckRhdGEuZ2V0KCkpKTsKK30KKwogV2ViQ29udGV4dCogd2Via2l0V2ViQ29udGV4dEdl dENvbnRleHQoV2ViS2l0V2ViQ29udGV4dCogY29udGV4dCkKIHsKICAgICBnX2Fzc2VydChXRUJL SVRfSVNfV0VCX0NPTlRFWFQoY29udGV4dCkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oCmluZGV4IDllN2JjMTQ0NzZkYjAyMjNh NzhiY2RmNzM4YzJmNjBiOTA2NTNkN2UuLjFlM2I5YjU4OGQ2NWE4NTQ5OWE4NmJiNzE2Y2I2N2Jl MjNkOTIyYWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJDb250ZXh0LmgKQEAgLTE5Niw2ICsxOTYsMTEgQEAgd2Via2l0X3dlYl9jb250ZXh0 X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3RvcnkgICAgIChXZWJLaXRXZWJDb250ZXh0CiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGdj aGFyICAgICAgICAgICAgICAgICAgICpkaXJlY3RvcnkpOwogCiBXRUJLSVRfQVBJIHZvaWQKK3dl YmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9k YXRhCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg KFdlYktpdFdlYkNvbnRleHQgICAgICAgICAgICAgICpjb250ZXh0LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVmFyaWFudCAgICAgICAgICAg ICAgICAgICAgICAqdXNlcl9kYXRhKTsKKworV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX2Nv bnRleHRfcHJlZmV0Y2hfZG5zICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYkNvbnRleHQg ICAgICAgICAgICAgICpjb250ZXh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAgICAgICAgICAgICAgICAgICAqaG9zdG5h bWUpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJDb250ZXh0UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaAppbmRleCA4MWM0NzNjNTYxZDhjM2NjMmYzNTVhYjI0 MWU4MDliMGQ4N2ZhYzAyLi4yNjFiNGY2NTU5NDExN2RlZDYyOWVmYWUzZDYzOTMzN2EyOWI2MDY2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJD b250ZXh0UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYkNvbnRleHRQcml2YXRlLmgKQEAgLTQ3LDUgKzQ3LDYgQEAgdm9pZCB3ZWJraXRXZWJD b250ZXh0Q3JlYXRlUGFnZUZvcldlYlZpZXcoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdFdlYlZp ZXcqLCBXZWIKIHZvaWQgd2Via2l0V2ViQ29udGV4dFdlYlZpZXdEZXN0cm95ZWQoV2ViS2l0V2Vi Q29udGV4dCosIFdlYktpdFdlYlZpZXcqKTsKIFdlYktpdFdlYlZpZXcqIHdlYmtpdFdlYkNvbnRl eHRHZXRXZWJWaWV3Rm9yUGFnZShXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0OjpXZWJQYWdlUHJv eHkqKTsKIFdlYktpdFdlYlZpZXdHcm91cCogd2Via2l0V2ViQ29udGV4dEdldERlZmF1bHRXZWJW aWV3R3JvdXAoV2ViS2l0V2ViQ29udGV4dCopOworR1JlZlB0cjxHVmFyaWFudD4gd2Via2l0V2Vi Q29udGV4dEluaXRpYWxpemVXZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqKTsKIAogI2Vu ZGlmIC8vIFdlYktpdFdlYkNvbnRleHRQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0 CmluZGV4IDA5MGU5MWU2ZGU2MWM0NmYzM2I4OGMxYzhkNDVmYmI3YzE3MjZiMjguLjFjMTNjNmMw NzNhNzVkMTk3ZDcwNTYyYzAyOTc5MjFmN2I2MzgyZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25z LnR4dApAQCAtNDYsNiArNDYsNyBAQCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3ByZWZlcnJlZF9s YW5ndWFnZXMKIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfdGxzX2Vycm9yc19wb2xpY3kKIHdlYmtp dF93ZWJfY29udGV4dF9nZXRfdGxzX2Vycm9yc19wb2xpY3kKIHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5Cit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9l eHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YQogd2Via2l0X3dlYl9jb250ZXh0X3By ZWZldGNoX2Rucwogd2Via2l0X3dlYl9jb250ZXh0X3NldF9kaXNrX2NhY2hlX2RpcmVjdG9yeQog d2Via2l0X3dlYl9jb250ZXh0X2FsbG93X3Rsc19jZXJ0aWZpY2F0ZV9mb3JfaG9zdApAQCAtMTAy Niw2ICsxMDI3LDcgQEAgd2Via2l0X3dlYl92aWV3X2dyb3VwX2dldF90eXBlCiA8RklMRT5XZWJL aXRXZWJFeHRlbnNpb248L0ZJTEU+CiBXZWJLaXRXZWJFeHRlbnNpb24KIFdlYktpdFdlYkV4dGVu c2lvbkluaXRpYWxpemVGdW5jdGlvbgorV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZVdpdGhV c2VyRGF0YUZ1bmN0aW9uCiB3ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfcGFnZQogCiA8U1VCU0VD VElPTiBTdGFuZGFyZD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5q ZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaCBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaApp bmRleCA2N2E0Y2Q1NGNhODI4ZjliYzk3MTMyNGQ0ZWU4ODAxNWY5MmY5MDVmLi5mZmY2NzA1ZWE4 MzY2ZDQzMmEwZWUwMWRjNTE2ZThhYTVhZjBhZjc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmgK KysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dl YktpdFdlYkV4dGVuc2lvbi5oCkBAIC01MCw2ICs1MCwyMSBAQCB0eXBlZGVmIHN0cnVjdCBfV2Vi S2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZSBXZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlOwogICovCiB0 eXBlZGVmIHZvaWQgKCogV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uKSAoV2Vi S2l0V2ViRXh0ZW5zaW9uICpleHRlbnNpb24pOwogCisvKioKKyAqIFdlYktpdFdlYkV4dGVuc2lv bkluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbjoKKyAqIEBleHRlbnNpb246IGEgI1dlYktp dFdlYkV4dGVuc2lvbgorICogQHVzZXJfZGF0YTogYSAjR1ZhcmlhbnQKKyAqCisgKiBUeXBlIGRl ZmluaXRpb24gZm9yIGEgZnVuY3Rpb24gdGhhdCB3aWxsIGJlIGNhbGxlZCB0byBpbml0aWFsaXpl CisgKiB0aGUgd2ViIGV4dGVuc2lvbnMgd2hlbiB0aGUgd2ViIHByb2Nlc3Mgc3RhcnRzLCBhbmQg d2hpY2ggcmVjZWl2ZXMKKyAqIGFzIGFkZGl0aW9uYWwgYXJndW1lbnQgdGhlIHVzZXIgZGF0YSBz ZXQgd2l0aAorICogd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFs aXphdGlvbl91c2VyX2RhdGEoKS4KKyAqCisgKiBTaW5jZTogMC4yNgorICovCit0eXBlZGVmIHZv aWQgKCogV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uKSAo V2ViS2l0V2ViRXh0ZW5zaW9uICpleHRlbnNpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgR1ZhcmlhbnQg ICAgICp1c2VyX2RhdGEpOworCiBzdHJ1Y3QgX1dlYktpdFdlYkV4dGVuc2lvbiB7CiAgICAgR09i amVjdCBwYXJlbnQ7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3Rr L1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9n dGsvV2ViR3RrRXh0ZW5zaW9uTWFuYWdlci5jcHAKaW5kZXggYWQ3YmE5OWZiOWEyZmM1NGZmNmY2 OWIyOTJmYTZiZTdlNDA2MTMyMC4uYmMyZDJkY2EwM2RmZDIyY2U1MGYyYzZiNzQ1MDRiMjcwNzM2 MGQ1OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2ViR3RrRXh0 ZW5zaW9uTWFuYWdlci5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2Vi R3RrRXh0ZW5zaW9uTWFuYWdlci5jcHAKQEAgLTIyLDExICsyMiwxMyBAQAogCiAjaW5jbHVkZSAi SW5qZWN0ZWRCdW5kbGUuaCIKICNpbmNsdWRlICJXS0J1bmRsZUFQSUNhc3QuaCIKKyNpbmNsdWRl ICJXS0RpY3Rpb25hcnkuaCIKICNpbmNsdWRlICJXS1N0cmluZy5oIgogI2luY2x1ZGUgIldLVHlw ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYkV4dGVuc2lvblByaXZhdGUuaCIKICNpbmNsdWRlIDxX ZWJDb3JlL0ZpbGVTeXN0ZW0uaD4KICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisjaW5jbHVkZSA8 d3RmL3RleHQvQ1N0cmluZy5oPgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIApAQCAtNDksMTkgKzUx LDM1IEBAIHZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6c2Nhbk1vZHVsZXMoY29uc3QgU3Ry aW5nJiB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5LCBWCiAgICAgfQogfQogCi12b2lkIFdlYkd0a0V4 dGVuc2lvbk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5kbGVSZWYgYnVuZGxlLCBXS1R5cGVSZWYg dXNlckRhdGEpCit2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5k bGVSZWYgYnVuZGxlLCBXS1R5cGVSZWYgdXNlckRhdGFTdHJpbmcpCiB7Ci0gICAgbV9leHRlbnNp b24gPSBhZG9wdEdSZWYod2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKHRvSW1wbChidW5kbGUpKSk7 CisgICAgQVNTRVJUKHVzZXJEYXRhU3RyaW5nKTsKKyAgICBBU1NFUlQoV0tHZXRUeXBlSUQodXNl ckRhdGFTdHJpbmcpID09IFdLU3RyaW5nR2V0VHlwZUlEKCkpOworCisgICAgQ1N0cmluZyBkYXRh U3RyaW5nID0gdG9JbXBsKHN0YXRpY19jYXN0PFdLU3RyaW5nUmVmPih1c2VyRGF0YVN0cmluZykp LT5zdHJpbmcoKS51dGY4KCk7CisgICAgR1JlZlB0cjxHVmFyaWFudD4gdmFyaWFudCA9CisgICAg ICAgIGdfdmFyaWFudF9wYXJzZShudWxscHRyLCBkYXRhU3RyaW5nLmRhdGEoKSwgZGF0YVN0cmlu Zy5kYXRhKCkgKyBkYXRhU3RyaW5nLmxlbmd0aCgpLCBudWxscHRyLCBudWxscHRyKTsKKworICAg IEFTU0VSVCh2YXJpYW50KTsKKyAgICBBU1NFUlQoZ192YXJpYW50X2NoZWNrX2Zvcm1hdF9zdHJp bmcodmFyaWFudC5nZXQoKSwgIihtJnNtdikiLCBGQUxTRSkpOworCisgICAgY29uc3QgY2hhciog ZGlyZWN0b3J5ID0gbnVsbHB0cjsKKyAgICBHVmFyaWFudCogZGF0YSA9IG51bGxwdHI7CisgICAg Z192YXJpYW50X2dldCh2YXJpYW50LmdldCgpLCAiKG0mc212KSIsICZkaXJlY3RvcnksICZkYXRh KTsKIAogICAgIFN0cmluZyB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5OwotICAgIGlmICh1c2VyRGF0 YSkgewotICAgICAgICBBU1NFUlQoV0tHZXRUeXBlSUQodXNlckRhdGEpID09IFdLU3RyaW5nR2V0 VHlwZUlEKCkpOwotICAgICAgICB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5ID0gdG9JbXBsKHN0YXRp Y19jYXN0PFdLU3RyaW5nUmVmPih1c2VyRGF0YSkpLT5zdHJpbmcoKTsKLSAgICB9CisgICAgaWYg KGRpcmVjdG9yeSkKKyAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IFN0cmluZzo6ZnJv bVVURjgoZGlyZWN0b3J5KTsKIAogICAgIGlmICh3ZWJFeHRlbnNpb25zRGlyZWN0b3J5LmlzTnVs bCgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBHUmVmUHRyPEdWYXJpYW50PiB1c2VyRGF0YTsK KyAgICBpZiAoZGF0YSkKKyAgICAgICAgdXNlckRhdGEgPSBkYXRhOworCisgICAgbV9leHRlbnNp b24gPSBhZG9wdEdSZWYod2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKHRvSW1wbChidW5kbGUpKSk7 CisKICAgICBWZWN0b3I8U3RyaW5nPiBtb2R1bGVQYXRoczsKICAgICBzY2FuTW9kdWxlcyh3ZWJF eHRlbnNpb25zRGlyZWN0b3J5LCBtb2R1bGVQYXRocyk7CiAKQEAgLTcwLDEzICs4OCwxOCBAQCB2 b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5kbGVSZWYgYnVuZGxl LCBXS1R5cGVSZWYgdXNlckRhdGEpCiAgICAgICAgIGlmICghbW9kdWxlLT5sb2FkKCkpCiAgICAg ICAgICAgICBjb250aW51ZTsKIAorICAgICAgICBXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXpl V2l0aFVzZXJEYXRhRnVuY3Rpb24gaW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uID0KKyAg ICAgICAgICAgIG1vZHVsZS0+ZnVuY3Rpb25Qb2ludGVyPFdlYktpdFdlYkV4dGVuc2lvbkluaXRp YWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbj4oIndlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxp emVfd2l0aF91c2VyX2RhdGEiKTsKICAgICAgICAgV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6 ZUZ1bmN0aW9uIGluaXRpYWxpemVGdW5jdGlvbiA9CiAgICAgICAgICAgICBtb2R1bGUtPmZ1bmN0 aW9uUG9pbnRlcjxXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplRnVuY3Rpb24+KCJ3ZWJraXRf d2ViX2V4dGVuc2lvbl9pbml0aWFsaXplIik7Ci0gICAgICAgIGlmICghaW5pdGlhbGl6ZUZ1bmN0 aW9uKQorICAgICAgICBpZiAoIWluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbiAmJiAhaW5p dGlhbGl6ZUZ1bmN0aW9uKQogICAgICAgICAgICAgY29udGludWU7CiAKICAgICAgICAgbV9leHRl bnNpb25Nb2R1bGVzLmFwcGVuZChtb2R1bGUubGVha1B0cigpKTsKLSAgICAgICAgaW5pdGlhbGl6 ZUZ1bmN0aW9uKG1fZXh0ZW5zaW9uLmdldCgpKTsKKyAgICAgICAgaWYgKGluaXRpYWxpemVXaXRo VXNlckRhdGFGdW5jdGlvbikKKyAgICAgICAgICAgIGluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5j dGlvbihtX2V4dGVuc2lvbi5nZXQoKSwgdXNlckRhdGEuZ2V0KCkpOworICAgICAgICBlbHNlCisg ICAgICAgICAgICBpbml0aWFsaXplRnVuY3Rpb24obV9leHRlbnNpb24uZ2V0KCkpOwogICAgIH0K IH0KIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4 IDI2M2ZlNzhhNmVhN2FiYTRlMWU5NjQyMWM1YjgyZTZjZjY1ZTA0YWMuLjU0NzliNGQyYWU2OTYw NTY2Y2ZkYjM2ZmM2YzExMTA1YThiNGNmZjQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZwor KysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxNC0wMS0xOSAgQWRyaWFu IFBlcmV6IGRlIENhc3RybyAgPGFwZXJlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIEFs bG93IHBhc3NpbmcgZXh0cmEgZGF0YSB0byB3ZWIgZXh0ZW5zaW9ucworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI1OTkwCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cgcGFzc2luZyBhZGRpdGlvbmFs IGluZm9ybWF0aW9uIHRvIHRoZSBpbmplY3RlZCBidW5kbGUuIE9uIHRvcAorICAgICAgICBvZiB0 aGUgc3RyaW5nIGNvbnRhaW5pbmcgdGhlIHBhdGggdG8gdGhlIHdlYiBleHRlbnNpb25zIGRpcmVj dG9yeSwKKyAgICAgICAgYSBHVmFyaWFudCBjYW4gYmUgc2V0IHdpdGggYWRkaXRpb25hbCBkYXRh IHVzaW5nCisgICAgICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5p dGlhbGl6YXRpb25fdXNlcl9kYXRhKCkuCisgICAgICAgIEFsc28sIGEgbmV3IGluaXRpYWxpemUt d2ViLWV4dGVuc2lvbnMgc2lnbmFsIGlzIGVtaXR0ZWQgYmVmb3JlCisgICAgICAgIGxhdW5jaGlu ZyBhIG5ldyBXZWJQcm9jZXNzIHRvIGFsbG93IHNldHRpbmcgZGlmZmVyZW50IHVzZXIgZGF0YQor ICAgICAgICBmb3IgZWFjaCBwcm9jZXNzLiBUaGUgR1ZhcmlhbnQgaXMgc2VyaWFsaXplZCBhcyBh IHN0cmluZywgcGFzc2VkCisgICAgICAgIHRvIHRoZSBpbmplY3RlZCBidW5kbGUsIGFuZCB0aGUg aW5qZWN0ZWQgYnVuZGxlIGRlc2VyaWFsaXplcyBiYWNrCisgICAgICAgIHRoZSBkYXRhLCB3aGlj aCBpcyBwYXNzZWQgdG8gd2ViIGV4dGVuc2lvbnMgd2hpY2ggZGVmaW5lIHRoZQorICAgICAgICB3 ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhfdXNlcl9kYXRhKCkgZnVuY3Rpb24g KGZvcgorICAgICAgICBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSwgd2Via2l0X3dlYl9leHRlbnNp b25faW5pdGlhbGl6ZSgpIGlzCisgICAgICAgIHVzZWQgYXMgYSBmYWxsYmFjay4pCisKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYkV4dGVuc2lvbnMuY3Bw OgorICAgICAgICAoaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMpOiBIYW5kbGVzIHRoZSBpbml0aWFs aXplLXdlYi1leHRlbnNpb25zCisgICAgICAgIHNpZ25hbCwgYW5kIHNldHMgdGhlIHdlYiBleHRl bnNpb25zIGRpcmVjdG9yeSBhbmQgdGhlIGluaXRpYWxpemF0aW9uCisgICAgICAgIHVzZXIgZGF0 YS4KKyAgICAgICAgKHRlc3RXZWJFeHRlbnNpb25Jbml0aWFsaXphdGlvblVzZXJEYXRhKTogTmV3 IHRlc3QgY2FzZSBmb3IgY2hlY2tpbmcKKyAgICAgICAgdGhlIHVzZXIgZGF0YSBwYXNzZWQgb24g aW5pdGlhbGl6YXRpb24gdG8gd2ViIGV4dGVuc2lvbnMuCisgICAgICAgICogVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJLaXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwOgorICAgICAgICAobWV0aG9k Q2FsbENhbGxiYWNrKTogQWRkZWQgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBDaGVja1VzZXJEYXRh CisgICAgICAgIEQtQnVzIG1ldGhvZCwgdXNlZCBieSB0ZXN0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6 YXRpb25Vc2VyRGF0YSgpLgorICAgICAgICAod2Via2l0X3dlYl9leHRlbnNpb25faW5pdGlhbGl6 ZV93aXRoX3VzZXJfZGF0YSk6IERlZmluZSB0aGUKKyAgICAgICAgaW5pdGlhbGl6YXRpb24gZnVu Y3Rpb24gd2l0aCB0aGUgYWRkaXRpb25hbCB1c2VyIGRhdGEgcGFyYW1ldGVyLgorCiAyMDE0LTAx LTE3ICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBAYXBwbGUuY29tPgogCiAgICAgICAgIGJ1aWxk LndlYmtpdC5vcmcvZGFzaGJvYXJkIHNob3VsZCBoYXZlIGRpZmYgbGlua3MgaW4gdGVzdCByZXN1 bHRzIHBvcG92ZXJzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dDJHdGsvVGVzdFdlYkV4dGVuc2lvbnMuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyR3RrL1Rlc3RXZWJFeHRlbnNpb25zLmNwcAppbmRleCBiMDNjOWRjYWQ1YTM3ZGFlYTQw YjdiYWQyMzliYzNhNzVlYTcxYjg5Li5jOGI1NzkxYTNmZWU3YjEwMDFjY2IwZjQxNmFhZmZjMmQ0 ODIyNDUxIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsv VGVzdFdlYkV4dGVuc2lvbnMuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHAKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRl ICJXZWJWaWV3VGVzdC5oIgogI2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KIAorc3Rh dGljIGNvbnN0IGNoYXIqIHdlYkV4dGVuc2lvbnNVc2VyRGF0YSA9ICJXZWIgRXh0ZW5zaW9ucyB1 c2VyIGRhdGEiOwogc3RhdGljIFdlYktpdFRlc3RCdXMqIGJ1czsKIAogc3RhdGljIHZvaWQgdGVz dFdlYkV4dGVuc2lvbkdldFRpdGxlKFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQpA QCAtMTc1LDEzICsxNzYsNDcgQEAgc3RhdGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbklzb2xhdGVk V29ybGQoV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCiAgICAgZ19zaWduYWxfaGFu ZGxlcl9kaXNjb25uZWN0KHRlc3QtPm1fd2ViVmlldywgc2NyaXB0RGlhbG9nSUQpOwogfQogCitz dGF0aWMgdm9pZCB0ZXN0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXZWJWaWV3 VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICB0ZXN0LT5sb2FkSHRtbCgiPGh0bWw+ PC9odG1sPiIsIDApOworICAgIHRlc3QtPndhaXRVbnRpbExvYWRGaW5pc2hlZCgpOworCisgICAg R1JlZlB0cjxHVmFyaWFudD4gdXNlckRhdGEgPSBhZG9wdEdSZWYoZ192YXJpYW50X25ldygicyIs IHdlYkV4dGVuc2lvbnNVc2VyRGF0YSkpOworICAgIEdPd25QdHI8Z2NoYXI+IHVzZXJEYXRhU3Ry aW5nKGdfdmFyaWFudF9wcmludCh1c2VyRGF0YS5nZXQoKSwgVFJVRSkpOworCisgICAgR1JlZlB0 cjxHREJ1c1Byb3h5PiBwcm94eSA9IGFkb3B0R1JlZihidXMtPmNyZWF0ZVByb3h5KCJvcmcud2Vi a2l0Lmd0ay5XZWJFeHRlbnNpb25UZXN0IiwKKyAgICAgICAgIi9vcmcvd2Via2l0L2d0ay9XZWJF eHRlbnNpb25UZXN0IiwgIm9yZy53ZWJraXQuZ3RrLldlYkV4dGVuc2lvblRlc3QiLCB0ZXN0LT5t X21haW5Mb29wKSk7CisKKyAgICBHUmVmUHRyPEdWYXJpYW50PiByZXN1bHQgPSBhZG9wdEdSZWYo Z19kYnVzX3Byb3h5X2NhbGxfc3luYygKKyAgICAgICAgcHJveHkuZ2V0KCksCisgICAgICAgICJD aGVja1VzZXJEYXRhIiwKKyAgICAgICAgZ192YXJpYW50X25ldygiKCZzKSIsIHVzZXJEYXRhU3Ry aW5nLmdldCgpKSwKKyAgICAgICAgR19EQlVTX0NBTExfRkxBR1NfTk9ORSwKKyAgICAgICAgLTEs IDAsIDApKTsKKyAgICBnX2Fzc2VydChyZXN1bHQpOworCisgICAgZ2Jvb2xlYW4gc3VjY2VzcyA9 IEZBTFNFOworICAgIGdfdmFyaWFudF9nZXQocmVzdWx0LmdldCgpLCAiKGIpIiwgJnN1Y2Nlc3Mp OworICAgIGdfYXNzZXJ0KHN1Y2Nlc3MpOworfQorCitzdGF0aWMgdm9pZCBpbml0aWFsaXplV2Vi RXh0ZW5zaW9ucyhXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlcikKK3sKKyAgICB3 ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeShjb250ZXh0LCBX RUJLSVRfVEVTVF9XRUJfRVhURU5TSU9OU19ESVIpOworICAgIHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhKGNvbnRleHQsCisgICAg ICAgIGdfdmFyaWFudF9uZXcoIiZzIiwgd2ViRXh0ZW5zaW9uc1VzZXJEYXRhKSk7Cit9CisKIHZv aWQgYmVmb3JlQWxsKCkKIHsKLSAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNp b25zX2RpcmVjdG9yeSh3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwgV0VCS0lUX1RF U1RfV0VCX0VYVEVOU0lPTlNfRElSKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYmtpdF93ZWJf Y29udGV4dF9nZXRfZGVmYXVsdCgpLAorICAgICAgICAiaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9u cyIsIEdfQ0FMTEJBQ0soaW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMpLCBudWxscHRyKTsKKwogICAg IGJ1cyA9IG5ldyBXZWJLaXRUZXN0QnVzKCk7CiAgICAgaWYgKCFidXMtPnJ1bigpKQogICAgICAg ICByZXR1cm47CiAKKyAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJDb250ZXh0IiwgImlu aXRpYWxpemF0aW9uLXVzZXItZGF0YSIsIHRlc3RXZWJFeHRlbnNpb25Jbml0aWFsaXphdGlvblVz ZXJEYXRhKTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJFeHRlbnNpb24iLCAiZG9t LWRvY3VtZW50LXRpdGxlIiwgdGVzdFdlYkV4dGVuc2lvbkdldFRpdGxlKTsKICAgICBXZWJWaWV3 VGVzdDo6YWRkKCJXZWJLaXRXZWJFeHRlbnNpb24iLCAiZG9jdW1lbnQtbG9hZGVkLXNpZ25hbCIs IHRlc3REb2N1bWVudExvYWRlZFNpZ25hbCk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0 V2ViVmlldyIsICJ3ZWItcHJvY2Vzcy1jcmFzaGVkIiwgdGVzdFdlYktpdFdlYlZpZXdQcm9jZXNz Q3Jhc2hlZCk7CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJH dGsvV2ViRXh0ZW5zaW9uVGVzdC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dDJHdGsvV2ViRXh0ZW5zaW9uVGVzdC5jcHAKaW5kZXggNDBjYjZjYWY5MTVlMTRiYzgxNDlmM2Nk M2IzYzBlZjM4MjkyODE1Ny4uYmExMGY3MWJkZmFmYTBlYTg0YWM3MjNjMTFhZjVhMzJhNzM2ZjMx ZiAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1dlYkV4 dGVuc2lvblRlc3QuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0 ay9XZWJFeHRlbnNpb25UZXN0LmNwcApAQCAtNDUsNiArNDUsMTAgQEAgc3RhdGljIGNvbnN0IGNo YXIgaW50cm9zcGVjdGlvblhNTFtdID0KICAgICAiICAgPGFyZyB0eXBlPSd0JyBuYW1lPSdwYWdl SUQnIGRpcmVjdGlvbj0naW4nLz4iCiAgICAgIiAgIDxhcmcgdHlwZT0ncycgbmFtZT0nc2NyaXB0 JyBkaXJlY3Rpb249J2luJy8+IgogICAgICIgIDwvbWV0aG9kPiIKKyAgICAiICA8bWV0aG9kIG5h bWU9J0NoZWNrVXNlckRhdGEnPiIKKyAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSd1c2VyZGF0 YScgZGlyZWN0aW9uPSdpbicvPiIKKyAgICAiICAgPGFyZyB0eXBlPSdiJyBuYW1lPSdzdWNjZXNz JyBkaXJlY3Rpb249J291dCcvPiIKKyAgICAiICA8L21ldGhvZD4iCiAgICAgIiAgPHNpZ25hbCBu YW1lPSdEb2N1bWVudExvYWRlZCcvPiIKICAgICAiICA8c2lnbmFsIG5hbWU9J1VSSUNoYW5nZWQn PiIKICAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSd1cmknIGRpcmVjdGlvbj0nb3V0Jy8+IgpA QCAtNTIsNiArNTYsOSBAQCBzdGF0aWMgY29uc3QgY2hhciBpbnRyb3NwZWN0aW9uWE1MW10gPQog ICAgICIgPC9pbnRlcmZhY2U+IgogICAgICI8L25vZGU+IjsKIAorc3RhdGljIEdSZWZQdHI8R1Zh cmlhbnQ+IGluaXRpYWxpemF0aW9uVXNlckRhdGE7CisKKwogdHlwZWRlZiBlbnVtIHsKICAgICBE b2N1bWVudExvYWRlZFNpZ25hbCwKICAgICBVUklDaGFuZ2VkU2lnbmFsLApAQCAtMjEwLDggKzIx NywxOSBAQCBzdGF0aWMgdm9pZCBtZXRob2RDYWxsQ2FsbGJhY2soR0RCdXNDb25uZWN0aW9uKiBj b25uZWN0aW9uLCBjb25zdCBjaGFyKiBzZW5kZXIsCiAgICAgICAgIEpTUmV0YWluUHRyPEpTU3Ry aW5nUmVmPiBqc1NjcmlwdChBZG9wdCwgSlNTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoc2Ny aXB0KSk7CiAgICAgICAgIEpTRXZhbHVhdGVTY3JpcHQoanNDb250ZXh0LCBqc1NjcmlwdC5nZXQo KSwgMCwgMCwgMCwgMCk7CiAgICAgICAgIGdfZGJ1c19tZXRob2RfaW52b2NhdGlvbl9yZXR1cm5f dmFsdWUoaW52b2NhdGlvbiwgMCk7Ci0gICAgfSBlbHNlIGlmICghZ19zdHJjbXAwKG1ldGhvZE5h bWUsICJBYm9ydFByb2Nlc3MiKSkKKyAgICB9IGVsc2UgaWYgKCFnX3N0cmNtcDAobWV0aG9kTmFt ZSwgIkFib3J0UHJvY2VzcyIpKSB7CiAgICAgICAgIGFib3J0KCk7CisgICAgfSBlbHNlIGlmICgh Z19zdHJjbXAwKG1ldGhvZE5hbWUsICJDaGVja1VzZXJEYXRhIikpIHsKKyAgICAgICAgaWYgKCFp bml0aWFsaXphdGlvblVzZXJEYXRhKSB7CisgICAgICAgICAgICBnX2RidXNfbWV0aG9kX2ludm9j YXRpb25fcmV0dXJuX3ZhbHVlKGludm9jYXRpb24sIGdfdmFyaWFudF9uZXcoIihiKSIsIEZBTFNF KSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgR093blB0cjxnY2hh cj4gaW5pdGlhbGl6YXRpb25Vc2VyRGF0YVN0cmluZyhnX3ZhcmlhbnRfcHJpbnQoaW5pdGlhbGl6 YXRpb25Vc2VyRGF0YS5nZXQoKSwgVFJVRSkpOworICAgICAgICBjb25zdCBnY2hhciogY2hlY2tT dHJpbmcgPSBudWxscHRyOworICAgICAgICBnX3ZhcmlhbnRfZ2V0KHBhcmFtZXRlcnMsICIoJnMp IiwgJmNoZWNrU3RyaW5nKTsKKyAgICAgICAgZ19kYnVzX21ldGhvZF9pbnZvY2F0aW9uX3JldHVy bl92YWx1ZShpbnZvY2F0aW9uLAorICAgICAgICAgICAgZ192YXJpYW50X25ldygiKGIpIiwgZ19z dHJfZXF1YWwoY2hlY2tTdHJpbmcsIGluaXRpYWxpemF0aW9uVXNlckRhdGFTdHJpbmcuZ2V0KCkp KSk7CisgICAgfQogfQogCiBzdGF0aWMgY29uc3QgR0RCdXNJbnRlcmZhY2VWVGFibGUgaW50ZXJm YWNlVmlydHVhbFRhYmxlID0gewpAQCAtMjUwLDggKzI2OCwxMCBAQCBzdGF0aWMgdm9pZCBidXNB Y3F1aXJlZENhbGxiYWNrKEdEQnVzQ29ubmVjdGlvbiogY29ubmVjdGlvbiwgY29uc3QgY2hhciog bmFtZSwgZwogICAgIH0KIH0KIAotZXh0ZXJuICJDIiB2b2lkIHdlYmtpdF93ZWJfZXh0ZW5zaW9u X2luaXRpYWxpemUoV2ViS2l0V2ViRXh0ZW5zaW9uKiBleHRlbnNpb24pCitleHRlcm4gIkMiIHZv aWQgd2Via2l0X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZV93aXRoX3VzZXJfZGF0YShXZWJLaXRX ZWJFeHRlbnNpb24qIGV4dGVuc2lvbiwgR1ZhcmlhbnQqIHVzZXJEYXRhKQogeworICAgIGluaXRp YWxpemF0aW9uVXNlckRhdGEgPSB1c2VyRGF0YTsKKwogICAgIGdfc2lnbmFsX2Nvbm5lY3QoZXh0 ZW5zaW9uLCAicGFnZS1jcmVhdGVkIiwgR19DQUxMQkFDSyhwYWdlQ3JlYXRlZENhbGxiYWNrKSwg ZXh0ZW5zaW9uKTsKICAgICBnX3NpZ25hbF9jb25uZWN0KHdlYmtpdF9zY3JpcHRfd29ybGRfZ2V0 X2RlZmF1bHQoKSwgIndpbmRvdy1vYmplY3QtY2xlYXJlZCIsIEdfQ0FMTEJBQ0sod2luZG93T2Jq ZWN0Q2xlYXJlZCksIDApOwogCg== 221586 2014-01-19 08:52:24 -0800 2014-01-21 03:22:42 -0800 Patch bug-125990-20140119185252.patch text/plain 23898 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyMjkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMmMyZDdhYTYzZGNlNmRk ZWQwOTg3NDA0YjMyZGY1MzNiMmQ2OTIwMy4uNmU4Mzk2YmIwZjdmNDg2ZmJjYTNiMWIyNjVjNGYz ODA5MGY5ODcxYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE0LTAxLTE5ICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9m IHRoZSBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LAorICAgICAgICBhIEdWYXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRh dGEgdXNpbmcKKyAgICAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19p bml0aWFsaXphdGlvbl91c2VyX2RhdGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6 ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNo aW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRh CisgICAgICAgIGZvciBlYWNoIHByb2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFz IGEgc3RyaW5nLCBwYXNzZWQKKyAgICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRo ZSBpbmplY3RlZCBidW5kbGUgZGVzZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdo aWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAg IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlv biAoZm9yCisgICAgICAgIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVu c2lvbl9pbml0aWFsaXplKCkgaXMKKyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoK KyAgICAgICAgKGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6IERlZmlu ZSBuZXcgY2FsbGJhY2sKKyAgICAgICAgZnVuY3Rpb24gd2hpY2ggY2F1c2VzIGVtaXNzaW9uIG9m IHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zCisgICAgICAgIHNpZ25hbCwgYW5kIHNlcmlh bGl6ZXMgdGhlIGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAg KGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KTogU2V0IHRoZQorICAgICAgICBn ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoKSBjYWxsYmFjay4KKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKHdl YmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFs aXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5IGFzIG5vdyBtZW1iZXIgb2YgV2ViS2l0V2ViQ29udGV4dFByaXZhdGUsCisgICAgICAg IHRvIGJlIGFibGUgdG8gcmV0cmlldmUgaXQgbGF0ZXIuCisgICAgICAgICh3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSk6CisgICAg ICAgIE5ldyBBUEkgbWV0aG9kIHRvIHNldCB0aGUgdXNlciBkYXRhIHBhc3NlZCB0byB0aGUgd2Vi IGV4dGVuc2lvbnMKKyAgICAgICAgd2hlbiBpbml0aWFsaXplZC4KKyAgICAgICAgKHdlYmtpdFdl YkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyk6IFByaXZhdGUgZnVuY3Rpb24gdXNlZAor ICAgICAgICB0byB0cmlnZ2VyIGVtaXNzaW9uIG9mIHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNp b25zIHNpZ25hbC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 Lmg6CisgICAgICAgIEFkZGVkIHByb3RvdHlwZSBmb3IgbmV3IEFQSSBtZXRob2QKKyAgICAgICAg d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2Vy X2RhdGEoKS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJp dmF0ZS5oOgorICAgICAgICBQcm90b3R5cGUgb2YgdGhlIG5ldyBwcml2YXRlIGZ1bmN0aW9uLgor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6 CisgICAgICAgIEFkZCBuZXcgcHVibGljIEFQSSBiaXRzIHRvIHRoZSBkb2N1bWVudGF0aW9uLgor ICAgICAgICAqIFdlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKToKKyAgICAg ICAgRGVzZXJpYWxpemUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJvY2VzcyBhbmQg cGFzcyBpdCB0bworICAgICAgICB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhf dXNlcl9kYXRhKCkgaWYgYXZhaWxhYmxlLAorICAgICAgICBrZWVwaW5nIHdlYmtpdF93ZWJfZXh0 ZW5zaW9uX2luaXRpYWxpemUoKSBhcyBmYWxsYmFjay4KKwogMjAxNC0wMS0xOCAgQW5kZXJzIENh cmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJlcGxhY2UgYSBjb3VwbGUg b2YgdXNlcyBvZiBXVEY6OkZ1bmN0aW9uIHdpdGggc3RkOjpmdW5jdGlvbgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRCdW5kbGVDbGll bnQuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0ZWRC dW5kbGVDbGllbnQuY3BwCmluZGV4IDVkOWUxMDY4Zjk3ZDZjZGZkMjU3YWExZjQ5OTQyNjY0YzZl NmMzZDAuLmYyNzEyMjIzM2IzNzVkY2FmNDBiNzdiNmQwZWMxYmQ0YjlkMDEzNGUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxl Q2xpZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJ bmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKQEAgLTExOCwxNiArMTE4LDIzIEBAIHN0YXRpYyB2b2lk IGRpZFJlY2VpdmVNZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlKFdLQ29udGV4dFJlZiwgV0tTdHJp bmdSZWYgbWVzc2FnCiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogfQogCitzdGF0aWMg V0tUeXBlUmVmIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXS0NvbnRl eHRSZWYsIGNvbnN0IHZvaWQqIGNsaWVudEluZm8pCit7CisgICAgR1JlZlB0cjxHVmFyaWFudD4g ZGF0YSA9IHdlYmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXRUJLSVRfV0VC X0NPTlRFWFQoY2xpZW50SW5mbykpOworICAgIEdPd25QdHI8Z2NoYXI+IGRhdGFTdHJpbmcoZ192 YXJpYW50X3ByaW50KGRhdGEuZ2V0KCksIFRSVUUpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8 V0tUeXBlUmVmPihXS1N0cmluZ0NyZWF0ZVdpdGhVVEY4Q1N0cmluZyhkYXRhU3RyaW5nLmdldCgp KSk7Cit9CisKIHZvaWQgYXR0YWNoSW5qZWN0ZWRCdW5kbGVDbGllbnRUb0NvbnRleHQoV2ViS2l0 V2ViQ29udGV4dCogd2ViQ29udGV4dCkKIHsKICAgICBXS0NvbnRleHRJbmplY3RlZEJ1bmRsZUNs aWVudFYxIHdrSW5qZWN0ZWRCdW5kbGVDbGllbnQgPSB7CiAgICAgICAgIHsKLSAgICAgICAgICAg IDAsIC8vIHZlcnNpb24KKyAgICAgICAgICAgIDEsIC8vIHZlcnNpb24KICAgICAgICAgICAgIHdl YkNvbnRleHQsIC8vIGNsaWVudEluZm8KICAgICAgICAgfSwKICAgICAgICAgZGlkUmVjZWl2ZU1l c3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUsCiAgICAgICAgIDAsIC8vIGRpZFJlY2VpdmVTeW5jaHJv bm91c01lc3NhZ2VGcm9tSW5qZWN0ZWRCdW5kbGUKLSAgICAgICAgMCAvLyBnZXRJbmplY3RlZEJ1 bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEKKyAgICAgICAgZ2V0SW5qZWN0ZWRCdW5kbGVJbml0 aWFsaXphdGlvblVzZXJEYXRhCiAgICAgfTsKICAgICBXS0NvbnRleHRTZXRJbmplY3RlZEJ1bmRs ZUNsaWVudCh0b0FQSSh3ZWJraXRXZWJDb250ZXh0R2V0Q29udGV4dCh3ZWJDb250ZXh0KSksICZ3 a0luamVjdGVkQnVuZGxlQ2xpZW50LmJhc2UpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAppbmRleCAyYjFhNWYzNWE4 MmY0YTBmODc5MTdlNGEwYzhhYWE4YjQ1YTNmYWFmLi4xYmVjM2YxMGVmZjUzYmZiOWY4YWJiMDYy NjI1YzJjNTc4MzlmZmFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcApAQCAtODQsNiArODQsNyBAQCB1c2luZyBuYW1l c3BhY2UgV2ViS2l0OwogCiBlbnVtIHsKICAgICBET1dOTE9BRF9TVEFSVEVELAorICAgIElOSVRJ QUxJWkVfV0VCX0VYVEVOU0lPTlMsCiAKICAgICBMQVNUX1NJR05BTAogfTsKQEAgLTE1Myw2ICsx NTQsOSBAQCBzdHJ1Y3QgX1dlYktpdFdlYkNvbnRleHRQcml2YXRlIHsKIAogICAgIEhhc2hNYXA8 dWludDY0X3QsIFdlYktpdFdlYlZpZXcqPiB3ZWJWaWV3czsKICAgICBHUmVmUHRyPFdlYktpdFdl YlZpZXdHcm91cD4gZGVmYXVsdFdlYlZpZXdHcm91cDsKKworICAgIENTdHJpbmcgd2ViRXh0ZW5z aW9uc0RpcmVjdG9yeTsKKyAgICBHUmVmUHRyPEdWYXJpYW50PiB3ZWJFeHRlbnNpb25zSW5pdGlh bGl6YXRpb25Vc2VyRGF0YTsKIH07CiAKIHN0YXRpYyBndWludCBzaWduYWxzW0xBU1RfU0lHTkFM XSA9IHsgMCwgfTsKQEAgLTE3OCw2ICsxODIsMjUgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl9j b250ZXh0X2NsYXNzX2luaXQoV2ViS2l0V2ViQ29udGV4dENsYXNzKiB3ZWJDb250ZXh0Q2xhc3MK ICAgICAgICAgICAgICAgICAgICAgIGdfY2Nsb3N1cmVfbWFyc2hhbF9WT0lEX19PQkpFQ1QsCiAg ICAgICAgICAgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMSwKICAgICAgICAgICAgICAgICAgICAg IFdFQktJVF9UWVBFX0RPV05MT0FEKTsKKworICAgIC8qKgorICAgICAqIFdlYktpdFdlYkNvbnRl eHQ6OmluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnM6CisgICAgICogQGNvbnRleHQ6IHRoZSAjV2Vi S2l0V2ViQ29udGV4dAorICAgICAqCisgICAgICogVGhpcyBzaWduYWwgaXMgZW1pdHRlZCB3aGVu IGEgbmV3IHdlYiBwcm9jZXNzIGlzIGFib3V0IHRvIGJlCisgICAgICogbGF1bmNoZWQuIEl0IHNp Z25hbHMgdGhlIG1vc3QgYXBwcm9wcmlhdGUgbW9tZW50IHRvIHVzZQorICAgICAqIHdlYmtpdF93 ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhKCkK KyAgICAgKiBhbmQgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19kaXJlY3Rv cnkoKS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAyLjQKKyAgICAgKi8KKyAgICBzaWduYWxzW0lO SVRJQUxJWkVfV0VCX0VYVEVOU0lPTlNdID0KKyAgICAgICAgZ19zaWduYWxfbmV3KCJpbml0aWFs aXplLXdlYi1leHRlbnNpb25zIiwKKyAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKGdPYmpl Y3RDbGFzcyksCisgICAgICAgICAgICBHX1NJR05BTF9SVU5fTEFTVCwKKyAgICAgICAgICAgIDAs IG51bGxwdHIsIG51bGxwdHIsCisgICAgICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9f Vk9JRCwKKyAgICAgICAgICAgIEdfVFlQRV9OT05FLCAwKTsKIH0KIAogc3RhdGljIENTdHJpbmcg aW5qZWN0ZWRCdW5kbGVEaXJlY3RvcnkoKQpAQCAtNzc3LDE0ICs4MDAsNDEgQEAgV2ViS2l0VExT RXJyb3JzUG9saWN5IHdlYmtpdF93ZWJfY29udGV4dF9nZXRfdGxzX2Vycm9yc19wb2xpY3koV2Vi S2l0V2ViQ29udGV4dCoKICAqIFNldCB0aGUgZGlyZWN0b3J5IHdoZXJlIFdlYktpdCB3aWxsIGxv b2sgZm9yIFdlYiBFeHRlbnNpb25zLgogICogVGhpcyBtZXRob2QgbXVzdCBiZSBjYWxsZWQgYmVm b3JlIGxvYWRpbmcgYW55dGhpbmcgaW4gdGhpcyBjb250ZXh0LCBvdGhlcndpc2UKICAqIGl0IHdp bGwgbm90IGhhdmUgYW55IGVmZmVjdC4KKyAqCisgKiBJdCBpcyByZWNvbW1lbmRlZCB0byB1c2Ug dGhpcyBtZXRob2QgaW4gYSBoYW5kbGVyIGZvciB0aGUKKyAqIFdlYktpdFdlYkNvbnRleHQ6Omlu aXRpYWxpemUtd2ViLWV4dGVuc2lvbnMgc2lnbmFsLgogICovCiB2b2lkIHdlYmtpdF93ZWJfY29u dGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KFdlYktpdFdlYkNvbnRleHQqIGNvbnRl eHQsIGNvbnN0IGNoYXIqIGRpcmVjdG9yeSkKIHsKICAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJ VF9JU19XRUJfQ09OVEVYVChjb250ZXh0KSk7CiAgICAgZ19yZXR1cm5faWZfZmFpbChkaXJlY3Rv cnkpOwogCi0gICAgLy8gV2UgcGFzcyB0aGUgYWRkaXRpb25hbCB3ZWIgZXh0ZW5zaW9ucyBkaXJl Y3RvcnkgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSBhcyBpbml0aWFsaXphdGlvbiB1c2VyIGRhdGEu Ci0gICAgY29udGV4dC0+cHJpdi0+Y29udGV4dC0+c2V0SW5qZWN0ZWRCdW5kbGVJbml0aWFsaXph dGlvblVzZXJEYXRhKEFQSTo6U3RyaW5nOjpjcmVhdGUoV2ViQ29yZTo6ZmlsZW5hbWVUb1N0cmlu ZyhkaXJlY3RvcnkpKSk7CisgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0RpcmVjdG9y eSA9IGRpcmVjdG9yeTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9l eHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YToKKyAqIEBjb250ZXh0OiBhICNXZWJL aXRXZWJDb250ZXh0CisgKiBAdXNlcl9kYXRhOiAoYWxsb3ctbm9uZSk6IGEgI0dWYXJpYW50LCBv ciAlTlVMTAorICoKKyAqIFNldCBhcmJpdHJhcnkgdXNlciBkYXRhIHRvIGJlIHBhc3NlZCB0byBX ZWIgRXh0ZW5zaW9ucyBvbiBpbml0aWFsaXphdGlvbi4KKyAqIFRvIHJlY2VpdmUgdGhlIGRhdGEg aW4gV2ViIEV4dGVuc2lvbnMsIHRoZXkgbXVzdCBkZWZpbmUgYSBmdW5jdGlvbiBuYW1lZAorICog JXdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNl cl9kYXRhKCkgb2YgdHlwZQorICogI1dlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVXaXRoVXNl ckRhdGFGdW5jdGlvbi4KKyAqCisgKiBQYXNzaW5nICVOVUxMIHdpbGwgY2F1c2Ugbm8gZGF0YSBi ZWluZyBwYXNzZWQgdG8gV2ViIEV4dGVuc2lvbnMsIHdoaWNoCisgKiB3aWxsIHJlY2VpdmUgYSAl TlVMTCBhcyBzZWNvbmQgcGFyYW1ldGVyIHRvIHRoZSBpbml0aWFsaXphdGlvbiBmdW5jdGlvbi4K KyAqCisgKiBJdCBpcyByZWNvbW1lbmRlZCB0byB1c2UgdGhpcyBtZXRob2QgaW4gYSBoYW5kbGVy IGZvciB0aGUKKyAqIFdlYktpdFdlYkNvbnRleHQ6OmluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnMg c2lnbmFsLgorICoKKyAqIFNpbmNlOiAyLjQKKyAqLwordm9pZCB3ZWJraXRfd2ViX2NvbnRleHRf c2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YShXZWJLaXRXZWJDb250 ZXh0KiBjb250ZXh0LCBHVmFyaWFudCogdXNlckRhdGEpCit7CisgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfV0VCX0NPTlRFWFQoY29udGV4dCkpOworCisgICAgY29udGV4dC0+cHJpdi0+ d2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0aW9uVXNlckRhdGEgPSB1c2VyRGF0YTsKIH0KIAogLyoq CkBAIC04NzIsNiArOTIyLDE0IEBAIHZvaWQgd2Via2l0V2ViQ29udGV4dERvd25sb2FkU3RhcnRl ZChXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LCBXZWJLaXREb3dubG9hZCoKICAgICBnX3NpZ25h bF9lbWl0KGNvbnRleHQsIHNpZ25hbHNbRE9XTkxPQURfU1RBUlRFRF0sIDAsIGRvd25sb2FkKTsK IH0KIAorR1ZhcmlhbnQqIHdlYmtpdFdlYkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhX ZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0KQoreworICAgIGdfc2lnbmFsX2VtaXQoY29udGV4dCwg c2lnbmFsc1tJTklUSUFMSVpFX1dFQl9FWFRFTlNJT05TXSwgMCk7CisgICAgcmV0dXJuIGdfdmFy aWFudF9uZXcoIihtc212KSIsCisgICAgICAgIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNE aXJlY3RvcnkuZGF0YSgpLAorICAgICAgICBjb250ZXh0LT5wcml2LT53ZWJFeHRlbnNpb25zSW5p dGlhbGl6YXRpb25Vc2VyRGF0YS5nZXQoKSk7Cit9CisKIFdlYkNvbnRleHQqIHdlYmtpdFdlYkNv bnRleHRHZXRDb250ZXh0KFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQpCiB7CiAgICAgZ19hc3Nl cnQoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuaAppbmRleCA5ZTdiYzE0NDc2 ZGIwMjIzYTc4YmNkZjczOGMyZjYwYjkwNjUzZDdlLi4xZTNiOWI1ODhkNjVhODU0OTlhODZiYjcx NmNiNjdiZTIzZDkyMmFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViQ29udGV4dC5oCkBAIC0xOTYsNiArMTk2LDExIEBAIHdlYmtpdF93ZWJf Y29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5ICAgICAoV2ViS2l0V2ViQ29udGV4 dAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBnY2hhciAgICAgICAgICAgICAgICAgICAqZGlyZWN0b3J5KTsKIAogV0VCS0lUX0FQSSB2 b2lkCit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9u X3VzZXJfZGF0YQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIChXZWJLaXRXZWJDb250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1ZhcmlhbnQgICAg ICAgICAgICAgICAgICAgICAgKnVzZXJfZGF0YSk7CisKK1dFQktJVF9BUEkgdm9pZAogd2Via2l0 X3dlYl9jb250ZXh0X3ByZWZldGNoX2RucyAgICAgICAgICAgICAgICAgICAgIChXZWJLaXRXZWJD b250ZXh0ICAgICAgICAgICAgICAqY29udGV4dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgZ2NoYXIgICAgICAgICAgICAgICAgICAg Kmhvc3RuYW1lKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViQ29udGV4dFByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2YXRlLmgKaW5kZXggODFjNDczYzU2MWQ4YzNjYzJm MzU1YWIyNDFlODA5YjBkODdmYWMwMi4uOTgwZWI3OWQ1NDU4MjAwMTRhZDg0YWZhOWFhYzU2NWU1 MjU2ZWQzZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViQ29udGV4dFByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZS5oCkBAIC00Nyw1ICs0Nyw2IEBAIHZvaWQgd2Vi a2l0V2ViQ29udGV4dENyZWF0ZVBhZ2VGb3JXZWJWaWV3KFdlYktpdFdlYkNvbnRleHQqLCBXZWJL aXRXZWJWaWV3KiwgV2ViCiB2b2lkIHdlYmtpdFdlYkNvbnRleHRXZWJWaWV3RGVzdHJveWVkKFdl YktpdFdlYkNvbnRleHQqLCBXZWJLaXRXZWJWaWV3Kik7CiBXZWJLaXRXZWJWaWV3KiB3ZWJraXRX ZWJDb250ZXh0R2V0V2ViVmlld0ZvclBhZ2UoV2ViS2l0V2ViQ29udGV4dCosIFdlYktpdDo6V2Vi UGFnZVByb3h5Kik7CiBXZWJLaXRXZWJWaWV3R3JvdXAqIHdlYmtpdFdlYkNvbnRleHRHZXREZWZh dWx0V2ViVmlld0dyb3VwKFdlYktpdFdlYkNvbnRleHQqKTsKK0dWYXJpYW50KiB3ZWJraXRXZWJD b250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV2ViS2l0V2ViQ29udGV4dCopOwogCiAjZW5k aWYgLy8gV2ViS2l0V2ViQ29udGV4dFByaXZhdGVfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQK aW5kZXggMDkwZTkxZTZkZTYxYzQ2ZjMzYjg4YzFjOGQ0NWZiYjdjMTcyNmIyOC4uMWMxM2M2YzA3 M2E3NWQxOTdkNzA1NjJjMDI5NzkyMWY3YjYzODJmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dAorKysgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMu dHh0CkBAIC00Niw2ICs0Niw3IEBAIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfcHJlZmVycmVkX2xh bmd1YWdlcwogd2Via2l0X3dlYl9jb250ZXh0X3NldF90bHNfZXJyb3JzX3BvbGljeQogd2Via2l0 X3dlYl9jb250ZXh0X2dldF90bHNfZXJyb3JzX3BvbGljeQogd2Via2l0X3dlYl9jb250ZXh0X3Nl dF93ZWJfZXh0ZW5zaW9uc19kaXJlY3RvcnkKK3dlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4 dGVuc2lvbnNfaW5pdGlhbGl6YXRpb25fdXNlcl9kYXRhCiB3ZWJraXRfd2ViX2NvbnRleHRfcHJl ZmV0Y2hfZG5zCiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X2Rpc2tfY2FjaGVfZGlyZWN0b3J5CiB3 ZWJraXRfd2ViX2NvbnRleHRfYWxsb3dfdGxzX2NlcnRpZmljYXRlX2Zvcl9ob3N0CkBAIC0xMDI2 LDYgKzEwMjcsNyBAQCB3ZWJraXRfd2ViX3ZpZXdfZ3JvdXBfZ2V0X3R5cGUKIDxGSUxFPldlYktp dFdlYkV4dGVuc2lvbjwvRklMRT4KIFdlYktpdFdlYkV4dGVuc2lvbgogV2ViS2l0V2ViRXh0ZW5z aW9uSW5pdGlhbGl6ZUZ1bmN0aW9uCitXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplV2l0aFVz ZXJEYXRhRnVuY3Rpb24KIHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2dldF9wYWdlCiAKIDxTVUJTRUNU SU9OIFN0YW5kYXJkPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9Jbmpl Y3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5oIGIvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5oCmlu ZGV4IDY3YTRjZDU0Y2E4MjhmOWJjOTcxMzI0ZDRlZTg4MDE1ZjkyZjkwNWYuLjM0MTM2YTM3ZDI1 NmNlMDkyNTlhMzk1ZTQ0ODg1NzI3ODJiOWM2YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsvV2Vi S2l0V2ViRXh0ZW5zaW9uLmgKQEAgLTUwLDYgKzUwLDIxIEBAIHR5cGVkZWYgc3RydWN0IF9XZWJL aXRXZWJFeHRlbnNpb25Qcml2YXRlIFdlYktpdFdlYkV4dGVuc2lvblByaXZhdGU7CiAgKi8KIHR5 cGVkZWYgdm9pZCAoKiBXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplRnVuY3Rpb24pIChXZWJL aXRXZWJFeHRlbnNpb24gKmV4dGVuc2lvbik7CiAKKy8qKgorICogV2ViS2l0V2ViRXh0ZW5zaW9u SW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uOgorICogQGV4dGVuc2lvbjogYSAjV2ViS2l0 V2ViRXh0ZW5zaW9uCisgKiBAdXNlcl9kYXRhOiBhICNHVmFyaWFudAorICoKKyAqIFR5cGUgZGVm aW5pdGlvbiBmb3IgYSBmdW5jdGlvbiB0aGF0IHdpbGwgYmUgY2FsbGVkIHRvIGluaXRpYWxpemUK KyAqIHRoZSB3ZWIgZXh0ZW5zaW9ucyB3aGVuIHRoZSB3ZWIgcHJvY2VzcyBzdGFydHMsIGFuZCB3 aGljaCByZWNlaXZlcworICogYXMgYWRkaXRpb25hbCBhcmd1bWVudCB0aGUgdXNlciBkYXRhIHNl dCB3aXRoCisgKiB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxp emF0aW9uX3VzZXJfZGF0YSgpLgorICoKKyAqIFNpbmNlOiAyLjQKKyAqLwordHlwZWRlZiB2b2lk ICgqIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbikgKFdl YktpdFdlYkV4dGVuc2lvbiAqZXh0ZW5zaW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEdWYXJpYW50ICAg ICAqdXNlcl9kYXRhKTsKKwogc3RydWN0IF9XZWJLaXRXZWJFeHRlbnNpb24gewogICAgIEdPYmpl Y3QgcGFyZW50OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9X ZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3Rr L1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwCmluZGV4IGFkN2JhOTlmYjlhMmZjNTRmZjZmNjli MjkyZmE2YmU3ZTQwNjEzMjAuLjdiMjg1NmZiYmVjZTg1MDQ4N2MyYzRhZTU1M2MzNDczYjA3ZGM3 MGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVu c2lvbk1hbmFnZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvZ3RrL1dlYkd0 a0V4dGVuc2lvbk1hbmFnZXIuY3BwCkBAIC0yMiwxMSArMjIsMTMgQEAKIAogI2luY2x1ZGUgIklu amVjdGVkQnVuZGxlLmgiCiAjaW5jbHVkZSAiV0tCdW5kbGVBUElDYXN0LmgiCisjaW5jbHVkZSAi V0tEaWN0aW9uYXJ5LmgiCiAjaW5jbHVkZSAiV0tTdHJpbmcuaCIKICNpbmNsdWRlICJXS1R5cGUu aCIKICNpbmNsdWRlICJXZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlLmgiCiAjaW5jbHVkZSA8V2Vi Q29yZS9GaWxlU3lzdGVtLmg+CiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2luY2x1ZGUgPHd0 Zi90ZXh0L0NTdHJpbmcuaD4KIAogbmFtZXNwYWNlIFdlYktpdCB7CiAKQEAgLTQ5LDE5ICs1MSw0 MiBAQCB2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OnNjYW5Nb2R1bGVzKGNvbnN0IFN0cmlu ZyYgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSwgVgogICAgIH0KIH0KIAotdm9pZCBXZWJHdGtFeHRl bnNpb25NYW5hZ2VyOjppbml0aWFsaXplKFdLQnVuZGxlUmVmIGJ1bmRsZSwgV0tUeXBlUmVmIHVz ZXJEYXRhKQorCitzdGF0aWMgdm9pZCBwYXJzZVVzZXJEYXRhKFdLVHlwZVJlZiB1c2VyRGF0YSwg U3RyaW5nJiB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5LAorICAgIEdSZWZQdHI8R1ZhcmlhbnQ+JiBp bml0aWFsaXphdGlvblVzZXJEYXRhKQogewotICAgIG1fZXh0ZW5zaW9uID0gYWRvcHRHUmVmKHdl YmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSh0b0ltcGwoYnVuZGxlKSkpOworICAgIEFTU0VSVCh1c2Vy RGF0YSk7CisgICAgQVNTRVJUKFdLR2V0VHlwZUlEKHVzZXJEYXRhKSA9PSBXS1N0cmluZ0dldFR5 cGVJRCgpKTsKKworICAgIENTdHJpbmcgdXNlckRhdGFTdHJpbmcgPSB0b0ltcGwoc3RhdGljX2Nh c3Q8V0tTdHJpbmdSZWY+KHVzZXJEYXRhKSktPnN0cmluZygpLnV0ZjgoKTsKKyAgICBHUmVmUHRy PEdWYXJpYW50PiB2YXJpYW50ID0gZ192YXJpYW50X3BhcnNlKG51bGxwdHIsIHVzZXJEYXRhU3Ry aW5nLmRhdGEoKSwKKyAgICAgICAgdXNlckRhdGFTdHJpbmcuZGF0YSgpICsgdXNlckRhdGFTdHJp bmcubGVuZ3RoKCksIG51bGxwdHIsIG51bGxwdHIpOworCisgICAgQVNTRVJUKHZhcmlhbnQpOwor ICAgIEFTU0VSVChnX3ZhcmlhbnRfY2hlY2tfZm9ybWF0X3N0cmluZyh2YXJpYW50LmdldCgpLCAi KG0mc212KSIsIEZBTFNFKSk7CisKKyAgICBjb25zdCBjaGFyKiBkaXJlY3RvcnkgPSBudWxscHRy OworICAgIEdWYXJpYW50KiBkYXRhID0gbnVsbHB0cjsKKyAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlh bnQuZ2V0KCksICIobSZzbXYpIiwgJmRpcmVjdG9yeSwgJmRhdGEpOwogCisgICAgaWYgKGRpcmVj dG9yeSkKKyAgICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IFdlYkNvcmU6OmZpbGVuYW1l VG9TdHJpbmcoZGlyZWN0b3J5KTsKKyAgICBpZiAoZGF0YSkKKyAgICAgICAgaW5pdGlhbGl6YXRp b25Vc2VyRGF0YSA9IGFkb3B0R1JlZihkYXRhKTsKK30KKworCit2b2lkIFdlYkd0a0V4dGVuc2lv bk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5kbGVSZWYgYnVuZGxlLCBXS1R5cGVSZWYgdXNlckRh dGFTdHJpbmcpCit7CiAgICAgU3RyaW5nIHdlYkV4dGVuc2lvbnNEaXJlY3Rvcnk7Ci0gICAgaWYg KHVzZXJEYXRhKSB7Ci0gICAgICAgIEFTU0VSVChXS0dldFR5cGVJRCh1c2VyRGF0YSkgPT0gV0tT dHJpbmdHZXRUeXBlSUQoKSk7Ci0gICAgICAgIHdlYkV4dGVuc2lvbnNEaXJlY3RvcnkgPSB0b0lt cGwoc3RhdGljX2Nhc3Q8V0tTdHJpbmdSZWY+KHVzZXJEYXRhKSktPnN0cmluZygpOwotICAgIH0K KyAgICBHUmVmUHRyPEdWYXJpYW50PiB1c2VyRGF0YTsKKyAgICBwYXJzZVVzZXJEYXRhKHVzZXJE YXRhU3RyaW5nLCB3ZWJFeHRlbnNpb25zRGlyZWN0b3J5LCB1c2VyRGF0YSk7CiAKICAgICBpZiAo d2ViRXh0ZW5zaW9uc0RpcmVjdG9yeS5pc051bGwoKSkKICAgICAgICAgcmV0dXJuOwogCisgICAg bV9leHRlbnNpb24gPSBhZG9wdEdSZWYod2Via2l0V2ViRXh0ZW5zaW9uQ3JlYXRlKHRvSW1wbChi dW5kbGUpKSk7CisKICAgICBWZWN0b3I8U3RyaW5nPiBtb2R1bGVQYXRoczsKICAgICBzY2FuTW9k dWxlcyh3ZWJFeHRlbnNpb25zRGlyZWN0b3J5LCBtb2R1bGVQYXRocyk7CiAKQEAgLTcwLDEzICs5 NSwyMSBAQCB2b2lkIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6OmluaXRpYWxpemUoV0tCdW5kbGVS ZWYgYnVuZGxlLCBXS1R5cGVSZWYgdXNlckRhdGEpCiAgICAgICAgIGlmICghbW9kdWxlLT5sb2Fk KCkpCiAgICAgICAgICAgICBjb250aW51ZTsKIAotICAgICAgICBXZWJLaXRXZWJFeHRlbnNpb25J bml0aWFsaXplRnVuY3Rpb24gaW5pdGlhbGl6ZUZ1bmN0aW9uID0KLSAgICAgICAgICAgIG1vZHVs ZS0+ZnVuY3Rpb25Qb2ludGVyPFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVGdW5jdGlvbj4o IndlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemUiKTsKLSAgICAgICAgaWYgKCFpbml0aWFs aXplRnVuY3Rpb24pCi0gICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgV2ViS2l0V2ViRXh0 ZW5zaW9uSW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uIGluaXRpYWxpemVXaXRoVXNlckRh dGFGdW5jdGlvbiA9CisgICAgICAgICAgICBtb2R1bGUtPmZ1bmN0aW9uUG9pbnRlcjxXZWJLaXRX ZWJFeHRlbnNpb25Jbml0aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb24+KCJ3ZWJraXRfd2ViX2V4 dGVuc2lvbl9pbml0aWFsaXplX3dpdGhfdXNlcl9kYXRhIik7CisKKyAgICAgICAgaWYgKGluaXRp YWxpemVXaXRoVXNlckRhdGFGdW5jdGlvbikgeworICAgICAgICAgICAgaW5pdGlhbGl6ZVdpdGhV c2VyRGF0YUZ1bmN0aW9uKG1fZXh0ZW5zaW9uLmdldCgpLCB1c2VyRGF0YS5nZXQoKSk7CisgICAg ICAgICAgICBtX2V4dGVuc2lvbk1vZHVsZXMuYXBwZW5kKG1vZHVsZS5sZWFrUHRyKCkpOworICAg ICAgICB9IGVsc2UgeworICAgICAgICAgICAgV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1 bmN0aW9uIGluaXRpYWxpemVGdW5jdGlvbiA9CisgICAgICAgICAgICAgICAgbW9kdWxlLT5mdW5j dGlvblBvaW50ZXI8V2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uPigid2Via2l0 X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZSIpOworICAgICAgICAgICAgaWYgKGluaXRpYWxpemVG dW5jdGlvbikgeworICAgICAgICAgICAgICAgIGluaXRpYWxpemVGdW5jdGlvbihtX2V4dGVuc2lv bi5nZXQoKSk7CisgICAgICAgICAgICAgICAgbV9leHRlbnNpb25Nb2R1bGVzLmFwcGVuZChtb2R1 bGUubGVha1B0cigpKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQogCi0gICAgICAgIG1fZXh0 ZW5zaW9uTW9kdWxlcy5hcHBlbmQobW9kdWxlLmxlYWtQdHIoKSk7Ci0gICAgICAgIGluaXRpYWxp emVGdW5jdGlvbihtX2V4dGVuc2lvbi5nZXQoKSk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9U b29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZWQ0MzFmNTQ0YzcwZGRlNGQx NmY2YmQ4NGMwOTk3ZWRkYTliMjExZC4uNjE4NjA1MGQ1NTYwYTQ1NjI4NGFjNTBlMzFjOTEyMzZj ZmU1YjNmZiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDM2IEBACisyMDE0LTAxLTE5ICBBZHJpYW4gUGVyZXogZGUgQ2FzdHJvICA8 YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gQWxsb3cgcGFzc2luZyBleHRyYSBk YXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gdG8gdGhl IGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9mIHRoZSBzdHJpbmcgY29udGFpbmlu ZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGlyZWN0b3J5LAorICAgICAgICBhIEdW YXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRhdGEgdXNpbmcKKyAgICAgICAgd2Vi a2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2Rh dGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9ucyBzaWdu YWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNoaW5nIGEgbmV3IFdlYlByb2Nlc3Mg dG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRhCisgICAgICAgIGZvciBlYWNoIHBy b2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFzIGEgc3RyaW5nLCBwYXNzZWQKKyAg ICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRoZSBpbmplY3RlZCBidW5kbGUgZGVz ZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdoaWNoIGlzIHBhc3NlZCB0byB3ZWIg ZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAgIHdlYmtpdF93ZWJfZXh0ZW5zaW9u X2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlvbiAoZm9yCisgICAgICAgIGJhY2t3 YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplKCkgaXMK KyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHA6CisgICAgICAgIChpbml0aWFs aXplV2ViRXh0ZW5zaW9ucyk6IEhhbmRsZXMgdGhlIGluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnMK KyAgICAgICAgc2lnbmFsLCBhbmQgc2V0cyB0aGUgd2ViIGV4dGVuc2lvbnMgZGlyZWN0b3J5IGFu ZCB0aGUgaW5pdGlhbGl6YXRpb24KKyAgICAgICAgdXNlciBkYXRhLgorICAgICAgICAodGVzdFdl YkV4dGVuc2lvbkluaXRpYWxpemF0aW9uVXNlckRhdGEpOiBOZXcgdGVzdCBjYXNlIGZvciBjaGVj a2luZworICAgICAgICB0aGUgdXNlciBkYXRhIHBhc3NlZCBvbiBpbml0aWFsaXphdGlvbiB0byB3 ZWIgZXh0ZW5zaW9ucy4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsv V2ViRXh0ZW5zaW9uVGVzdC5jcHA6CisgICAgICAgIChtZXRob2RDYWxsQ2FsbGJhY2spOiBBZGRl ZCBpbXBsZW1lbnRhdGlvbiBmb3IgdGhlCisgICAgICAgIEdldEluaXRpYWxpemF0aW9uVXNlckRh dGEgRC1CdXMgbWV0aG9kLCB1c2VkIGJ5CisgICAgICAgIHRlc3RXZWJFeHRlbnNpb25Jbml0aWFs aXphdGlvblVzZXJEYXRhKCkuCisgICAgICAgICh3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFs aXplX3dpdGhfdXNlcl9kYXRhKTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFsaXphdGlvbiBm dW5jdGlvbiB3aXRoIHRoZSBhZGRpdGlvbmFsIHVzZXIgZGF0YSBwYXJhbWV0ZXIuCisKIDIwMTQt MDEtMTggIEFsZXhleSBQcm9za3VyeWFrb3YgIDxhcEBhcHBsZS5jb20+CiAKICAgICAgICAgQWRk IHJvYm90cy50eHQgdG8gaHR0cDovL3dlYmtpdC1xdWV1ZXMuYXBwc3BvdC5jb20KZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9u cy5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYkV4dGVu c2lvbnMuY3BwCmluZGV4IGIwM2M5ZGNhZDVhMzdkYWVhNDBiN2JhZDIzOWJjM2E3NWVhNzFiODku LmM3YzZjNTdjMWU1ZjY0NzMxOTFmZDQzZmY2NTQ3ZGE5NjRhMDlkMzIgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHAK KysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJFeHRlbnNp b25zLmNwcApAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgIldlYlZpZXdUZXN0LmgiCiAjaW5j bHVkZSA8d3RmL2dvYmplY3QvR1JlZlB0ci5oPgogCitzdGF0aWMgY29uc3QgY2hhciogd2ViRXh0 ZW5zaW9uc1VzZXJEYXRhID0gIldlYiBFeHRlbnNpb25zIHVzZXIgZGF0YSI7CiBzdGF0aWMgV2Vi S2l0VGVzdEJ1cyogYnVzOwogCiBzdGF0aWMgdm9pZCB0ZXN0V2ViRXh0ZW5zaW9uR2V0VGl0bGUo V2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCkBAIC0xNzUsMTMgKzE3Niw0NCBAQCBz dGF0aWMgdm9pZCB0ZXN0V2ViRXh0ZW5zaW9uSXNvbGF0ZWRXb3JsZChXZWJWaWV3VGVzdCogdGVz dCwgZ2NvbnN0cG9pbnRlcikKICAgICBnX3NpZ25hbF9oYW5kbGVyX2Rpc2Nvbm5lY3QodGVzdC0+ bV93ZWJWaWV3LCBzY3JpcHREaWFsb2dJRCk7CiB9CiAKK3N0YXRpYyB2b2lkIHRlc3RXZWJFeHRl bnNpb25Jbml0aWFsaXphdGlvblVzZXJEYXRhKFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2lu dGVyKQoreworICAgIHRlc3QtPmxvYWRIdG1sKCI8aHRtbD48L2h0bWw+IiwgMCk7CisgICAgdGVz dC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisKKyAgICBHUmVmUHRyPEdEQnVzUHJveHk+IHBy b3h5ID0gYWRvcHRHUmVmKGJ1cy0+Y3JlYXRlUHJveHkoIm9yZy53ZWJraXQuZ3RrLldlYkV4dGVu c2lvblRlc3QiLAorICAgICAgICAiL29yZy93ZWJraXQvZ3RrL1dlYkV4dGVuc2lvblRlc3QiLCAi b3JnLndlYmtpdC5ndGsuV2ViRXh0ZW5zaW9uVGVzdCIsIHRlc3QtPm1fbWFpbkxvb3ApKTsKKwor ICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHJlc3VsdCA9IGdfZGJ1c19wcm94eV9jYWxsX3N5bmMoCisg ICAgICAgIHByb3h5LmdldCgpLAorICAgICAgICAiR2V0SW5pdGlhbGl6YXRpb25Vc2VyRGF0YSIs CisgICAgICAgIG51bGxwdHIsCisgICAgICAgIEdfREJVU19DQUxMX0ZMQUdTX05PTkUsCisgICAg ICAgIC0xLCAwLCAwKTsKKyAgICBnX2Fzc2VydChyZXN1bHQpOworCisgICAgY29uc3QgZ2NoYXIq IHN0ciA9IG51bGxwdHI7CisgICAgZ192YXJpYW50X2dldChyZXN1bHQuZ2V0KCksICIocykiLCAm c3RyKTsKKyAgICBnX2Fzc2VydChnX3N0cl9lcXVhbChzdHIsIHdlYkV4dGVuc2lvbnNVc2VyRGF0 YSkpOworfQorCitzdGF0aWMgdm9pZCBpbml0aWFsaXplV2ViRXh0ZW5zaW9ucyhXZWJLaXRXZWJD b250ZXh0KiBjb250ZXh0LCBncG9pbnRlcikKK3sKKyAgICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0 X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeShjb250ZXh0LCBXRUJLSVRfVEVTVF9XRUJfRVhURU5T SU9OU19ESVIpOworICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfaW5p dGlhbGl6YXRpb25fdXNlcl9kYXRhKGNvbnRleHQsCisgICAgICAgIGdfdmFyaWFudF9uZXcoIiZz Iiwgd2ViRXh0ZW5zaW9uc1VzZXJEYXRhKSk7Cit9CisKIHZvaWQgYmVmb3JlQWxsKCkKIHsKLSAg ICB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2RpcmVjdG9yeSh3ZWJraXRf d2ViX2NvbnRleHRfZ2V0X2RlZmF1bHQoKSwgV0VCS0lUX1RFU1RfV0VCX0VYVEVOU0lPTlNfRElS KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYmtpdF93ZWJfY29udGV4dF9nZXRfZGVmYXVsdCgp LAorICAgICAgICAiaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9ucyIsIEdfQ0FMTEJBQ0soaW5pdGlh bGl6ZVdlYkV4dGVuc2lvbnMpLCBudWxscHRyKTsKKwogICAgIGJ1cyA9IG5ldyBXZWJLaXRUZXN0 QnVzKCk7CiAgICAgaWYgKCFidXMtPnJ1bigpKQogICAgICAgICByZXR1cm47CiAKKyAgICBXZWJW aWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJDb250ZXh0IiwgImluaXRpYWxpemF0aW9uLXVzZXItZGF0 YSIsIHRlc3RXZWJFeHRlbnNpb25Jbml0aWFsaXphdGlvblVzZXJEYXRhKTsKICAgICBXZWJWaWV3 VGVzdDo6YWRkKCJXZWJLaXRXZWJFeHRlbnNpb24iLCAiZG9tLWRvY3VtZW50LXRpdGxlIiwgdGVz dFdlYkV4dGVuc2lvbkdldFRpdGxlKTsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJF eHRlbnNpb24iLCAiZG9jdW1lbnQtbG9hZGVkLXNpZ25hbCIsIHRlc3REb2N1bWVudExvYWRlZFNp Z25hbCk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJ3ZWItcHJvY2Vz cy1jcmFzaGVkIiwgdGVzdFdlYktpdFdlYlZpZXdQcm9jZXNzQ3Jhc2hlZCk7CmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvV2ViRXh0ZW5zaW9uVGVzdC5j cHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvV2ViRXh0ZW5zaW9uVGVz dC5jcHAKaW5kZXggNDBjYjZjYWY5MTVlMTRiYzgxNDlmM2NkM2IzYzBlZjM4MjkyODE1Ny4uOWI4 N2IzYmEzMDAyMzc2YmY3MDA3OGVlZjQ3ZWI5MjQzNmY2ZWFkNyAxMDA2NDQKLS0tIGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwCisrKyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9XZWJFeHRlbnNpb25UZXN0LmNw cApAQCAtNDUsNiArNDUsOSBAQCBzdGF0aWMgY29uc3QgY2hhciBpbnRyb3NwZWN0aW9uWE1MW10g PQogICAgICIgICA8YXJnIHR5cGU9J3QnIG5hbWU9J3BhZ2VJRCcgZGlyZWN0aW9uPSdpbicvPiIK ICAgICAiICAgPGFyZyB0eXBlPSdzJyBuYW1lPSdzY3JpcHQnIGRpcmVjdGlvbj0naW4nLz4iCiAg ICAgIiAgPC9tZXRob2Q+IgorICAgICIgIDxtZXRob2QgbmFtZT0nR2V0SW5pdGlhbGl6YXRpb25V c2VyRGF0YSc+IgorICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9J3VzZXJEYXRhJyBkaXJlY3Rp b249J291dCcvPiIKKyAgICAiICA8L21ldGhvZD4iCiAgICAgIiAgPHNpZ25hbCBuYW1lPSdEb2N1 bWVudExvYWRlZCcvPiIKICAgICAiICA8c2lnbmFsIG5hbWU9J1VSSUNoYW5nZWQnPiIKICAgICAi ICAgPGFyZyB0eXBlPSdzJyBuYW1lPSd1cmknIGRpcmVjdGlvbj0nb3V0Jy8+IgpAQCAtNTIsNiAr NTUsOSBAQCBzdGF0aWMgY29uc3QgY2hhciBpbnRyb3NwZWN0aW9uWE1MW10gPQogICAgICIgPC9p bnRlcmZhY2U+IgogICAgICI8L25vZGU+IjsKIAorc3RhdGljIEdSZWZQdHI8R1ZhcmlhbnQ+IGlu aXRpYWxpemF0aW9uVXNlckRhdGE7CisKKwogdHlwZWRlZiBlbnVtIHsKICAgICBEb2N1bWVudExv YWRlZFNpZ25hbCwKICAgICBVUklDaGFuZ2VkU2lnbmFsLApAQCAtMjEwLDggKzIxNiwxNCBAQCBz dGF0aWMgdm9pZCBtZXRob2RDYWxsQ2FsbGJhY2soR0RCdXNDb25uZWN0aW9uKiBjb25uZWN0aW9u LCBjb25zdCBjaGFyKiBzZW5kZXIsCiAgICAgICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBq c1NjcmlwdChBZG9wdCwgSlNTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoc2NyaXB0KSk7CiAg ICAgICAgIEpTRXZhbHVhdGVTY3JpcHQoanNDb250ZXh0LCBqc1NjcmlwdC5nZXQoKSwgMCwgMCwg MCwgMCk7CiAgICAgICAgIGdfZGJ1c19tZXRob2RfaW52b2NhdGlvbl9yZXR1cm5fdmFsdWUoaW52 b2NhdGlvbiwgMCk7Ci0gICAgfSBlbHNlIGlmICghZ19zdHJjbXAwKG1ldGhvZE5hbWUsICJBYm9y dFByb2Nlc3MiKSkKKyAgICB9IGVsc2UgaWYgKCFnX3N0cmNtcDAobWV0aG9kTmFtZSwgIkFib3J0 UHJvY2VzcyIpKSB7CiAgICAgICAgIGFib3J0KCk7CisgICAgfSBlbHNlIGlmICghZ19zdHJjbXAw KG1ldGhvZE5hbWUsICJHZXRJbml0aWFsaXphdGlvblVzZXJEYXRhIikpIHsKKyAgICAgICAgZ19k YnVzX21ldGhvZF9pbnZvY2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCBnX3ZhcmlhbnRf bmV3KCIocykiLAorICAgICAgICAgICAgaW5pdGlhbGl6YXRpb25Vc2VyRGF0YSAmJiBnX3Zhcmlh bnRfaXNfb2ZfdHlwZShpbml0aWFsaXphdGlvblVzZXJEYXRhLmdldCgpLCBHX1ZBUklBTlRfVFlQ RV9TVFJJTkcpCisgICAgICAgICAgICAgICAgPyBnX3ZhcmlhbnRfZ2V0X3N0cmluZyhpbml0aWFs aXphdGlvblVzZXJEYXRhLmdldCgpLCBudWxscHRyKQorICAgICAgICAgICAgICAgIDogIiIpKTsK KyAgICB9CiB9CiAKIHN0YXRpYyBjb25zdCBHREJ1c0ludGVyZmFjZVZUYWJsZSBpbnRlcmZhY2VW aXJ0dWFsVGFibGUgPSB7CkBAIC0yNTAsOCArMjYyLDEwIEBAIHN0YXRpYyB2b2lkIGJ1c0FjcXVp cmVkQ2FsbGJhY2soR0RCdXNDb25uZWN0aW9uKiBjb25uZWN0aW9uLCBjb25zdCBjaGFyKiBuYW1l LCBnCiAgICAgfQogfQogCi1leHRlcm4gIkMiIHZvaWQgd2Via2l0X3dlYl9leHRlbnNpb25faW5p dGlhbGl6ZShXZWJLaXRXZWJFeHRlbnNpb24qIGV4dGVuc2lvbikKK2V4dGVybiAiQyIgdm9pZCB3 ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhfdXNlcl9kYXRhKFdlYktpdFdlYkV4 dGVuc2lvbiogZXh0ZW5zaW9uLCBHVmFyaWFudCogdXNlckRhdGEpCiB7CisgICAgaW5pdGlhbGl6 YXRpb25Vc2VyRGF0YSA9IHVzZXJEYXRhOworCiAgICAgZ19zaWduYWxfY29ubmVjdChleHRlbnNp b24sICJwYWdlLWNyZWF0ZWQiLCBHX0NBTExCQUNLKHBhZ2VDcmVhdGVkQ2FsbGJhY2spLCBleHRl bnNpb24pOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2Via2l0X3NjcmlwdF93b3JsZF9nZXRfZGVm YXVsdCgpLCAid2luZG93LW9iamVjdC1jbGVhcmVkIiwgR19DQUxMQkFDSyh3aW5kb3dPYmplY3RD bGVhcmVkKSwgMCk7CiAK 221731 2014-01-21 03:23:20 -0800 2014-01-21 06:53:22 -0800 Patch bug-125990-20140121132350.patch text/plain 24664 aperez U3VidmVyc2lvbiBSZXZpc2lvbjogMTYyNDI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggY2EwNjExYjdhZWJjNTkx MGU1YTA3YzE2YjVlNjQ4MjQxZDI0ZTA2Zi4uMWJlOWQxMzM3YjRkNDMwZTk0MGRmYTNmZWViZGE4 ODMyYzk5MTQzYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUzIEBACisyMDE0LTAxLTIxICBBZHJp YW4gUGVyZXogZGUgQ2FzdHJvICA8YXBlcmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10g QWxsb3cgcGFzc2luZyBleHRyYSBkYXRhIHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9u YWwgaW5mb3JtYXRpb24gdG8gdGhlIGluamVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9m IHRoZSBzdHJpbmcgY29udGFpbmluZyB0aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5LAorICAgICAgICBhIEdWYXJpYW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRh dGEgdXNpbmcKKyAgICAgICAgd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19p bml0aWFsaXphdGlvbl91c2VyX2RhdGEoKS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6 ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwgaXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNo aW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8gYWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRh CisgICAgICAgIGZvciBlYWNoIHByb2Nlc3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFz IGEgc3RyaW5nLCBwYXNzZWQKKyAgICAgICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRo ZSBpbmplY3RlZCBidW5kbGUgZGVzZXJpYWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdo aWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAg IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlv biAoZm9yCisgICAgICAgIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVu c2lvbl9pbml0aWFsaXplKCkgaXMKKyAgICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAg ICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNwcDoK KyAgICAgICAgKGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YSk6IERlZmlu ZSBuZXcgY2FsbGJhY2sKKyAgICAgICAgZnVuY3Rpb24gd2hpY2ggY2F1c2VzIGVtaXNzaW9uIG9m IHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNpb25zCisgICAgICAgIHNpZ25hbCwgYW5kIHNlcmlh bGl6ZXMgdGhlIGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAg KGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KTogU2V0IHRoZQorICAgICAgICBn ZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoKSBjYWxsYmFjay4KKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmNwcDoKKyAgICAgICAgKHdl YmtpdF93ZWJfY29udGV4dF9jbGFzc19pbml0KTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFs aXplLXdlYi1leHRlbnNpb25zIHNpZ25hbC4KKyAgICAgICAgKHdlYmtpdF93ZWJfY29udGV4dF9z ZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KToKKyAgICAgICAgV2ViIGV4dGVuc2lvbnMgZGly ZWN0b3J5IGFzIG5vdyBtZW1iZXIgb2YgV2ViS2l0V2ViQ29udGV4dFByaXZhdGUsCisgICAgICAg IHRvIGJlIGFibGUgdG8gcmV0cmlldmUgaXQgbGF0ZXIuCisgICAgICAgICh3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSk6CisgICAg ICAgIE5ldyBBUEkgbWV0aG9kIHRvIHNldCB0aGUgdXNlciBkYXRhIHBhc3NlZCB0byB0aGUgd2Vi IGV4dGVuc2lvbnMKKyAgICAgICAgd2hlbiBpbml0aWFsaXplZC4KKyAgICAgICAgKHdlYmtpdFdl YkNvbnRleHRJbml0aWFsaXplV2ViRXh0ZW5zaW9ucyk6IFByaXZhdGUgZnVuY3Rpb24gdXNlZAor ICAgICAgICB0byB0cmlnZ2VyIGVtaXNzaW9uIG9mIHRoZSBpbml0aWFsaXplLXdlYi1leHRlbnNp b25zIHNpZ25hbC4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0 Lmg6CisgICAgICAgIEFkZGVkIHByb3RvdHlwZSBmb3IgbmV3IEFQSSBtZXRob2QKKyAgICAgICAg d2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2Vy X2RhdGEoKS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0UHJp dmF0ZS5oOgorICAgICAgICBQcm90b3R5cGUgb2YgdGhlIG5ldyBwcml2YXRlIGZ1bmN0aW9uLgor ICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6 CisgICAgICAgIEFkZCBuZXcgcHVibGljIEFQSSBiaXRzIHRvIHRoZSBkb2N1bWVudGF0aW9uLgor ICAgICAgICAqIFdlYlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJHdGtFeHRlbnNpb25NYW5hZ2VyOjppbml0aWFsaXplKToKKyAgICAg ICAgRGVzZXJpYWxpemUgdGhlIGRhdGEgcmVjZWl2ZWQgZnJvbSB0aGUgVUkgcHJvY2VzcyBhbmQg cGFzcyBpdCB0bworICAgICAgICB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplX3dpdGhf dXNlcl9kYXRhKCkgaWYgYXZhaWxhYmxlLAorICAgICAgICBrZWVwaW5nIHdlYmtpdF93ZWJfZXh0 ZW5zaW9uX2luaXRpYWxpemUoKSBhcyBmYWxsYmFjay4KKwogMjAxNC0wMS0yMCAgUnl1YW4gQ2hv aSAgPHJ5dWFuLmNob2lAc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF1bV0syXSBNb3ZlIGlz RXdrVmlld0V2YXNPYmplY3QgYmFjayB0byBld2tfdmlldy5jcHAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxlQ2xpZW50LmNw cCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEluamVjdGVkQnVuZGxl Q2xpZW50LmNwcAppbmRleCA1ZDllMTA2OGY5N2Q2Y2RmZDI1N2FhMWY0OTk0MjY2NGM2ZTZjM2Qw Li5mMjcxMjIyMzNiMzc1ZGNhZjQwYjc3YjZkMGVjMWJkNGI5ZDAxMzRlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRJbmplY3RlZEJ1bmRsZUNsaWVu dC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0SW5qZWN0 ZWRCdW5kbGVDbGllbnQuY3BwCkBAIC0xMTgsMTYgKzExOCwyMyBAQCBzdGF0aWMgdm9pZCBkaWRS ZWNlaXZlTWVzc2FnZUZyb21JbmplY3RlZEJ1bmRsZShXS0NvbnRleHRSZWYsIFdLU3RyaW5nUmVm IG1lc3NhZwogICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKIH0KIAorc3RhdGljIFdLVHlw ZVJlZiBnZXRJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGEoV0tDb250ZXh0UmVm LCBjb25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IGRhdGEg PSB3ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV0VCS0lUX1dFQl9DT05U RVhUKGNsaWVudEluZm8pKTsKKyAgICBHT3duUHRyPGdjaGFyPiBkYXRhU3RyaW5nKGdfdmFyaWFu dF9wcmludChkYXRhLmdldCgpLCBUUlVFKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PFdLVHlw ZVJlZj4oV0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoZGF0YVN0cmluZy5nZXQoKSkpOwor fQorCiB2b2lkIGF0dGFjaEluamVjdGVkQnVuZGxlQ2xpZW50VG9Db250ZXh0KFdlYktpdFdlYkNv bnRleHQqIHdlYkNvbnRleHQpCiB7CiAgICAgV0tDb250ZXh0SW5qZWN0ZWRCdW5kbGVDbGllbnRW MSB3a0luamVjdGVkQnVuZGxlQ2xpZW50ID0gewogICAgICAgICB7Ci0gICAgICAgICAgICAwLCAv LyB2ZXJzaW9uCisgICAgICAgICAgICAxLCAvLyB2ZXJzaW9uCiAgICAgICAgICAgICB3ZWJDb250 ZXh0LCAvLyBjbGllbnRJbmZvCiAgICAgICAgIH0sCiAgICAgICAgIGRpZFJlY2VpdmVNZXNzYWdl RnJvbUluamVjdGVkQnVuZGxlLAogICAgICAgICAwLCAvLyBkaWRSZWNlaXZlU3luY2hyb25vdXNN ZXNzYWdlRnJvbUluamVjdGVkQnVuZGxlCi0gICAgICAgIDAgLy8gZ2V0SW5qZWN0ZWRCdW5kbGVJ bml0aWFsaXphdGlvblVzZXJEYXRhCisgICAgICAgIGdldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6 YXRpb25Vc2VyRGF0YQogICAgIH07CiAgICAgV0tDb250ZXh0U2V0SW5qZWN0ZWRCdW5kbGVDbGll bnQodG9BUEkod2Via2l0V2ViQ29udGV4dEdldENvbnRleHQod2ViQ29udGV4dCkpLCAmd2tJbmpl Y3RlZEJ1bmRsZUNsaWVudC5iYXNlKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHQuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29udGV4dC5jcHAKaW5kZXggMmIxYTVmMzVhODJmNGEw Zjg3OTE3ZTRhMGM4YWFhOGI0NWEzZmFhZi4uZDU2ZjVlNTQzZTIzNDNjZDE1NGY5M2ExMDhlOTQ4 YWFmZjgyYTkwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViQ29udGV4dC5jcHAKQEAgLTg0LDYgKzg0LDcgQEAgdXNpbmcgbmFtZXNwYWNl IFdlYktpdDsKIAogZW51bSB7CiAgICAgRE9XTkxPQURfU1RBUlRFRCwKKyAgICBJTklUSUFMSVpF X1dFQl9FWFRFTlNJT05TLAogCiAgICAgTEFTVF9TSUdOQUwKIH07CkBAIC0xNTMsNiArMTU0LDkg QEAgc3RydWN0IF9XZWJLaXRXZWJDb250ZXh0UHJpdmF0ZSB7CiAKICAgICBIYXNoTWFwPHVpbnQ2 NF90LCBXZWJLaXRXZWJWaWV3Kj4gd2ViVmlld3M7CiAgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3 R3JvdXA+IGRlZmF1bHRXZWJWaWV3R3JvdXA7CisKKyAgICBDU3RyaW5nIHdlYkV4dGVuc2lvbnNE aXJlY3Rvcnk7CisgICAgR1JlZlB0cjxHVmFyaWFudD4gd2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0 aW9uVXNlckRhdGE7CiB9OwogCiBzdGF0aWMgZ3VpbnQgc2lnbmFsc1tMQVNUX1NJR05BTF0gPSB7 IDAsIH07CkBAIC0xNzgsNiArMTgyLDI1IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfY29udGV4 dF9jbGFzc19pbml0KFdlYktpdFdlYkNvbnRleHRDbGFzcyogd2ViQ29udGV4dENsYXNzCiAgICAg ICAgICAgICAgICAgICAgICBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fT0JKRUNULAogICAgICAg ICAgICAgICAgICAgICAgR19UWVBFX05PTkUsIDEsCiAgICAgICAgICAgICAgICAgICAgICBXRUJL SVRfVFlQRV9ET1dOTE9BRCk7CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJDb250ZXh0Ojpp bml0aWFsaXplLXdlYi1leHRlbnNpb25zOgorICAgICAqIEBjb250ZXh0OiB0aGUgI1dlYktpdFdl YkNvbnRleHQKKyAgICAgKgorICAgICAqIFRoaXMgc2lnbmFsIGlzIGVtaXR0ZWQgd2hlbiBhIG5l dyB3ZWIgcHJvY2VzcyBpcyBhYm91dCB0byBiZQorICAgICAqIGxhdW5jaGVkLiBJdCBzaWduYWxz IHRoZSBtb3N0IGFwcHJvcHJpYXRlIG1vbWVudCB0byB1c2UKKyAgICAgKiB3ZWJraXRfd2ViX2Nv bnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxpemF0aW9uX3VzZXJfZGF0YSgpCisgICAg ICogYW5kIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KCku CisgICAgICoKKyAgICAgKiBTaW5jZTogMi40CisgICAgICovCisgICAgc2lnbmFsc1tJTklUSUFM SVpFX1dFQl9FWFRFTlNJT05TXSA9CisgICAgICAgIGdfc2lnbmFsX25ldygiaW5pdGlhbGl6ZS13 ZWItZXh0ZW5zaW9ucyIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyhnT2JqZWN0Q2xh c3MpLAorICAgICAgICAgICAgR19TSUdOQUxfUlVOX0xBU1QsCisgICAgICAgICAgICAwLCBudWxs cHRyLCBudWxscHRyLAorICAgICAgICAgICAgZ19jY2xvc3VyZV9tYXJzaGFsX1ZPSURfX1ZPSUQs CisgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMCk7CiB9CiAKIHN0YXRpYyBDU3RyaW5nIGluamVj dGVkQnVuZGxlRGlyZWN0b3J5KCkKQEAgLTc3NSwxNiArNzk4LDQwIEBAIFdlYktpdFRMU0Vycm9y c1BvbGljeSB3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X3Rsc19lcnJvcnNfcG9saWN5KFdlYktpdFdl YkNvbnRleHQqCiAgKiBAZGlyZWN0b3J5OiB0aGUgZGlyZWN0b3J5IHRvIGFkZAogICoKICAqIFNl dCB0aGUgZGlyZWN0b3J5IHdoZXJlIFdlYktpdCB3aWxsIGxvb2sgZm9yIFdlYiBFeHRlbnNpb25z LgotICogVGhpcyBtZXRob2QgbXVzdCBiZSBjYWxsZWQgYmVmb3JlIGxvYWRpbmcgYW55dGhpbmcg aW4gdGhpcyBjb250ZXh0LCBvdGhlcndpc2UKLSAqIGl0IHdpbGwgbm90IGhhdmUgYW55IGVmZmVj dC4KKyAqIFRoaXMgbWV0aG9kIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBsb2FkaW5nIGFueXRoaW5n IGluIHRoaXMgY29udGV4dCwKKyAqIG90aGVyd2lzZSBpdCB3aWxsIG5vdCBoYXZlIGFueSBlZmZl Y3QuIFlvdSBjYW4gY29ubmVjdCB0bworICogI1dlYktpdFdlYkNvbnRleHQ6OmluaXRpYWxpemUt d2ViLWV4dGVuc2lvbnMgdG8gY2FsbCB0aGlzIG1ldGhvZAorICogYmVmb3JlIGFueXRoaW5nIGlz IGxvYWRlZC4KICAqLwogdm9pZCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25z X2RpcmVjdG9yeShXZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0LCBjb25zdCBjaGFyKiBkaXJlY3Rv cnkpCiB7CiAgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VCX0NPTlRFWFQoY29udGV4 dCkpOwogICAgIGdfcmV0dXJuX2lmX2ZhaWwoZGlyZWN0b3J5KTsKIAotICAgIC8vIFdlIHBhc3Mg dGhlIGFkZGl0aW9uYWwgd2ViIGV4dGVuc2lvbnMgZGlyZWN0b3J5IHRvIHRoZSBpbmplY3RlZCBi dW5kbGUgYXMgaW5pdGlhbGl6YXRpb24gdXNlciBkYXRhLgotICAgIGNvbnRleHQtPnByaXYtPmNv bnRleHQtPnNldEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShBUEk6OlN0cmlu Zzo6Y3JlYXRlKFdlYkNvcmU6OmZpbGVuYW1lVG9TdHJpbmcoZGlyZWN0b3J5KSkpOworICAgIGNv bnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNEaXJlY3RvcnkgPSBkaXJlY3Rvcnk7Cit9CisKKy8q KgorICogd2Via2l0X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlv bl91c2VyX2RhdGE6CisgKiBAY29udGV4dDogYSAjV2ViS2l0V2ViQ29udGV4dAorICogQHVzZXJf ZGF0YTogYSAjR1ZhcmlhbnQKKyAqCisgKiBTZXQgdXNlciBkYXRhIHRvIGJlIHBhc3NlZCB0byBX ZWIgRXh0ZW5zaW9ucyBvbiBpbml0aWFsaXphdGlvbi4KKyAqIFRoZSBkYXRhIHdpbGwgYmUgcGFz c2VkIHRvIHRoZQorICogI1dlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVXaXRoVXNlckRhdGFG dW5jdGlvbi4KKyAqIFRoaXMgbWV0aG9kIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBsb2FkaW5nIGFu eXRoaW5nIGluIHRoaXMgY29udGV4dCwKKyAqIG90aGVyd2lzZSBpdCB3aWxsIG5vdCBoYXZlIGFu eSBlZmZlY3QuIFlvdSBjYW4gY29ubmVjdCB0bworICogI1dlYktpdFdlYkNvbnRleHQ6OmluaXRp YWxpemUtd2ViLWV4dGVuc2lvbnMgdG8gY2FsbCB0aGlzIG1ldGhvZAorICogYmVmb3JlIGFueXRo aW5nIGlzIGxvYWRlZC4KKyAqCisgKiBTaW5jZTogMi40CisgKi8KK3ZvaWQgd2Via2l0X3dlYl9j b250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEoV2ViS2l0 V2ViQ29udGV4dCogY29udGV4dCwgR1ZhcmlhbnQqIHVzZXJEYXRhKQoreworICAgIGdfcmV0dXJu X2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9DT05URVhUKGNvbnRleHQpKTsKKyAgICBnX3JldHVybl9p Zl9mYWlsKHVzZXJEYXRhKTsKKworICAgIGNvbnRleHQtPnByaXYtPndlYkV4dGVuc2lvbnNJbml0 aWFsaXphdGlvblVzZXJEYXRhID0gdXNlckRhdGE7CiB9CiAKIC8qKgpAQCAtODcyLDYgKzkxOSwx NCBAQCB2b2lkIHdlYmtpdFdlYkNvbnRleHREb3dubG9hZFN0YXJ0ZWQoV2ViS2l0V2ViQ29udGV4 dCogY29udGV4dCwgV2ViS2l0RG93bmxvYWQqCiAgICAgZ19zaWduYWxfZW1pdChjb250ZXh0LCBz aWduYWxzW0RPV05MT0FEX1NUQVJURURdLCAwLCBkb3dubG9hZCk7CiB9CiAKK0dWYXJpYW50KiB3 ZWJraXRXZWJDb250ZXh0SW5pdGlhbGl6ZVdlYkV4dGVuc2lvbnMoV2ViS2l0V2ViQ29udGV4dCog Y29udGV4dCkKK3sKKyAgICBnX3NpZ25hbF9lbWl0KGNvbnRleHQsIHNpZ25hbHNbSU5JVElBTEla RV9XRUJfRVhURU5TSU9OU10sIDApOworICAgIHJldHVybiBnX3ZhcmlhbnRfbmV3KCIobXNtdiki LAorICAgICAgICBjb250ZXh0LT5wcml2LT53ZWJFeHRlbnNpb25zRGlyZWN0b3J5LmRhdGEoKSwK KyAgICAgICAgY29udGV4dC0+cHJpdi0+d2ViRXh0ZW5zaW9uc0luaXRpYWxpemF0aW9uVXNlckRh dGEuZ2V0KCkpOworfQorCiBXZWJDb250ZXh0KiB3ZWJraXRXZWJDb250ZXh0R2V0Q29udGV4dChX ZWJLaXRXZWJDb250ZXh0KiBjb250ZXh0KQogewogICAgIGdfYXNzZXJ0KFdFQktJVF9JU19XRUJf Q09OVEVYVChjb250ZXh0KSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJDb250ZXh0LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJDb250ZXh0LmgKaW5kZXggOWU3YmMxNDQ3NmRiMDIyM2E3OGJjZGY3Mzhj MmY2MGI5MDY1M2Q3ZS4uMWUzYjliNTg4ZDY1YTg1NDk5YTg2YmI3MTZjYjY3YmUyM2Q5MjJhYSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29u dGV4dC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNv bnRleHQuaApAQCAtMTk2LDYgKzE5NiwxMSBAQCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9l eHRlbnNpb25zX2RpcmVjdG9yeSAgICAgKFdlYktpdFdlYkNvbnRleHQKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgZ2NoYXIgICAgICAg ICAgICAgICAgICAgKmRpcmVjdG9yeSk7CiAKIFdFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl9j b250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2Vi Q29udGV4dCAgICAgICAgICAgICAgKmNvbnRleHQsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdWYXJpYW50ICAgICAgICAgICAgICAgICAgICAg ICp1c2VyX2RhdGEpOworCitXRUJLSVRfQVBJIHZvaWQKIHdlYmtpdF93ZWJfY29udGV4dF9wcmVm ZXRjaF9kbnMgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViQ29udGV4dCAgICAgICAgICAg ICAgKmNvbnRleHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IGdjaGFyICAgICAgICAgICAgICAgICAgICpob3N0bmFtZSk7CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRl eHRQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJD b250ZXh0UHJpdmF0ZS5oCmluZGV4IDgxYzQ3M2M1NjFkOGMzY2MyZjM1NWFiMjQxZTgwOWIwZDg3 ZmFjMDIuLjk4MGViNzlkNTQ1ODIwMDE0YWQ4NGFmYTlhYWM1NjVlNTI1NmVkM2UgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYkNvbnRleHRQcml2 YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViQ29u dGV4dFByaXZhdGUuaApAQCAtNDcsNSArNDcsNiBAQCB2b2lkIHdlYmtpdFdlYkNvbnRleHRDcmVh dGVQYWdlRm9yV2ViVmlldyhXZWJLaXRXZWJDb250ZXh0KiwgV2ViS2l0V2ViVmlldyosIFdlYgog dm9pZCB3ZWJraXRXZWJDb250ZXh0V2ViVmlld0Rlc3Ryb3llZChXZWJLaXRXZWJDb250ZXh0Kiwg V2ViS2l0V2ViVmlldyopOwogV2ViS2l0V2ViVmlldyogd2Via2l0V2ViQ29udGV4dEdldFdlYlZp ZXdGb3JQYWdlKFdlYktpdFdlYkNvbnRleHQqLCBXZWJLaXQ6OldlYlBhZ2VQcm94eSopOwogV2Vi S2l0V2ViVmlld0dyb3VwKiB3ZWJraXRXZWJDb250ZXh0R2V0RGVmYXVsdFdlYlZpZXdHcm91cChX ZWJLaXRXZWJDb250ZXh0Kik7CitHVmFyaWFudCogd2Via2l0V2ViQ29udGV4dEluaXRpYWxpemVX ZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqKTsKIAogI2VuZGlmIC8vIFdlYktpdFdlYkNv bnRleHRQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0CmluZGV4IDA5MGU5MWU2ZGU2 MWM0NmYzM2I4OGMxYzhkNDVmYmI3YzE3MjZiMjguLjFjMTNjNmMwNzNhNzVkMTk3ZDcwNTYyYzAy OTc5MjFmN2I2MzgyZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dApAQCAtNDYsNiArNDYs NyBAQCB3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3ByZWZlcnJlZF9sYW5ndWFnZXMKIHdlYmtpdF93 ZWJfY29udGV4dF9zZXRfdGxzX2Vycm9yc19wb2xpY3kKIHdlYmtpdF93ZWJfY29udGV4dF9nZXRf dGxzX2Vycm9yc19wb2xpY3kKIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNf ZGlyZWN0b3J5Cit3ZWJraXRfd2ViX2NvbnRleHRfc2V0X3dlYl9leHRlbnNpb25zX2luaXRpYWxp emF0aW9uX3VzZXJfZGF0YQogd2Via2l0X3dlYl9jb250ZXh0X3ByZWZldGNoX2Rucwogd2Via2l0 X3dlYl9jb250ZXh0X3NldF9kaXNrX2NhY2hlX2RpcmVjdG9yeQogd2Via2l0X3dlYl9jb250ZXh0 X2FsbG93X3Rsc19jZXJ0aWZpY2F0ZV9mb3JfaG9zdApAQCAtMTAyNiw2ICsxMDI3LDcgQEAgd2Vi a2l0X3dlYl92aWV3X2dyb3VwX2dldF90eXBlCiA8RklMRT5XZWJLaXRXZWJFeHRlbnNpb248L0ZJ TEU+CiBXZWJLaXRXZWJFeHRlbnNpb24KIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVGdW5j dGlvbgorV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uCiB3 ZWJraXRfd2ViX2V4dGVuc2lvbl9nZXRfcGFnZQogCiA8U1VCU0VDVElPTiBTdGFuZGFyZD4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0 ay9XZWJLaXRXZWJFeHRlbnNpb24uaCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvSW5qZWN0 ZWRCdW5kbGUvQVBJL2d0ay9XZWJLaXRXZWJFeHRlbnNpb24uaAppbmRleCA2N2E0Y2Q1NGNhODI4 ZjliYzk3MTMyNGQ0ZWU4ODAxNWY5MmY5MDVmLi4zNDEzNmEzN2QyNTZjZTA5MjU5YTM5NWU0NDg4 NTcyNzgyYjljNmM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0luamVj dGVkQnVuZGxlL0FQSS9ndGsvV2ViS2l0V2ViRXh0ZW5zaW9uLmgKKysrIGIvU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9JbmplY3RlZEJ1bmRsZS9BUEkvZ3RrL1dlYktpdFdlYkV4dGVuc2lvbi5o CkBAIC01MCw2ICs1MCwyMSBAQCB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViRXh0ZW5zaW9uUHJp dmF0ZSBXZWJLaXRXZWJFeHRlbnNpb25Qcml2YXRlOwogICovCiB0eXBlZGVmIHZvaWQgKCogV2Vi S2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZUZ1bmN0aW9uKSAoV2ViS2l0V2ViRXh0ZW5zaW9uICpl eHRlbnNpb24pOwogCisvKioKKyAqIFdlYktpdFdlYkV4dGVuc2lvbkluaXRpYWxpemVXaXRoVXNl ckRhdGFGdW5jdGlvbjoKKyAqIEBleHRlbnNpb246IGEgI1dlYktpdFdlYkV4dGVuc2lvbgorICog QHVzZXJfZGF0YTogYSAjR1ZhcmlhbnQKKyAqCisgKiBUeXBlIGRlZmluaXRpb24gZm9yIGEgZnVu Y3Rpb24gdGhhdCB3aWxsIGJlIGNhbGxlZCB0byBpbml0aWFsaXplCisgKiB0aGUgd2ViIGV4dGVu c2lvbnMgd2hlbiB0aGUgd2ViIHByb2Nlc3Mgc3RhcnRzLCBhbmQgd2hpY2ggcmVjZWl2ZXMKKyAq IGFzIGFkZGl0aW9uYWwgYXJndW1lbnQgdGhlIHVzZXIgZGF0YSBzZXQgd2l0aAorICogd2Via2l0 X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEo KS4KKyAqCisgKiBTaW5jZTogMi40CisgKi8KK3R5cGVkZWYgdm9pZCAoKiBXZWJLaXRXZWJFeHRl bnNpb25Jbml0aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb24pIChXZWJLaXRXZWJFeHRlbnNpb24g KmV4dGVuc2lvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBHVmFyaWFudCAgICAgKnVzZXJfZGF0YSk7CisK IHN0cnVjdCBfV2ViS2l0V2ViRXh0ZW5zaW9uIHsKICAgICBHT2JqZWN0IHBhcmVudDsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2ViR3RrRXh0ZW5zaW9uTWFu YWdlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25N YW5hZ2VyLmNwcAppbmRleCBhZDdiYTk5ZmI5YTJmYzU0ZmY2ZjY5YjI5MmZhNmJlN2U0MDYxMzIw Li5mYjYyZjVkNmE3Y2ZjZGRmYjhhOWNlOTQwMzFmY2IxNmE5NmQyNWNjIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2Vy LmNwcApAQCAtMjIsMTEgKzIyLDEzIEBACiAKICNpbmNsdWRlICJJbmplY3RlZEJ1bmRsZS5oIgog I2luY2x1ZGUgIldLQnVuZGxlQVBJQ2FzdC5oIgorI2luY2x1ZGUgIldLRGljdGlvbmFyeS5oIgog I2luY2x1ZGUgIldLU3RyaW5nLmgiCiAjaW5jbHVkZSAiV0tUeXBlLmgiCiAjaW5jbHVkZSAiV2Vi S2l0V2ViRXh0ZW5zaW9uUHJpdmF0ZS5oIgogI2luY2x1ZGUgPFdlYkNvcmUvRmlsZVN5c3RlbS5o PgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+ CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCkBAIC00OSwxOSArNTEsNTYgQEAgdm9pZCBXZWJHdGtF eHRlbnNpb25NYW5hZ2VyOjpzY2FuTW9kdWxlcyhjb25zdCBTdHJpbmcmIHdlYkV4dGVuc2lvbnNE aXJlY3RvcnksIFYKICAgICB9CiB9CiAKLXZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5p dGlhbGl6ZShXS0J1bmRsZVJlZiBidW5kbGUsIFdLVHlwZVJlZiB1c2VyRGF0YSkKK3N0YXRpYyB2 b2lkIHBhcnNlVXNlckRhdGEoV0tUeXBlUmVmIHVzZXJEYXRhLCBTdHJpbmcmIHdlYkV4dGVuc2lv bnNEaXJlY3RvcnksIEdSZWZQdHI8R1ZhcmlhbnQ+JiBpbml0aWFsaXphdGlvblVzZXJEYXRhKQog ewotICAgIG1fZXh0ZW5zaW9uID0gYWRvcHRHUmVmKHdlYmtpdFdlYkV4dGVuc2lvbkNyZWF0ZSh0 b0ltcGwoYnVuZGxlKSkpOworICAgIEFTU0VSVCh1c2VyRGF0YSk7CisgICAgQVNTRVJUKFdLR2V0 VHlwZUlEKHVzZXJEYXRhKSA9PSBXS1N0cmluZ0dldFR5cGVJRCgpKTsKIAorICAgIENTdHJpbmcg dXNlckRhdGFTdHJpbmcgPSB0b0ltcGwoc3RhdGljX2Nhc3Q8V0tTdHJpbmdSZWY+KHVzZXJEYXRh KSktPnN0cmluZygpLnV0ZjgoKTsKKyAgICBHUmVmUHRyPEdWYXJpYW50PiB2YXJpYW50ID0gZ192 YXJpYW50X3BhcnNlKG51bGxwdHIsIHVzZXJEYXRhU3RyaW5nLmRhdGEoKSwKKyAgICAgICAgdXNl ckRhdGFTdHJpbmcuZGF0YSgpICsgdXNlckRhdGFTdHJpbmcubGVuZ3RoKCksIG51bGxwdHIsIG51 bGxwdHIpOworCisgICAgQVNTRVJUKHZhcmlhbnQpOworICAgIEFTU0VSVChnX3ZhcmlhbnRfY2hl Y2tfZm9ybWF0X3N0cmluZyh2YXJpYW50LmdldCgpLCAiKG0mc212KSIsIEZBTFNFKSk7CisKKyAg ICBjb25zdCBjaGFyKiBkaXJlY3RvcnkgPSBudWxscHRyOworICAgIEdWYXJpYW50KiBkYXRhID0g bnVsbHB0cjsKKyAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlhbnQuZ2V0KCksICIobSZzbXYpIiwgJmRp cmVjdG9yeSwgJmRhdGEpOworCisgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IFdlYkNvcmU6 OmZpbGVuYW1lVG9TdHJpbmcoZGlyZWN0b3J5KTsKKyAgICBpbml0aWFsaXphdGlvblVzZXJEYXRh ID0gYWRvcHRHUmVmKGRhdGEpOworfQorCitib29sIFdlYkd0a0V4dGVuc2lvbk1hbmFnZXI6Omlu aXRpYWxpemVXZWJFeHRlbnNpb24oTW9kdWxlKiBleHRlbnNpb25Nb2R1bGUsIEdWYXJpYW50KiB1 c2VyRGF0YSkKK3sKKyAgICBXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplV2l0aFVzZXJEYXRh RnVuY3Rpb24gaW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uID0KKyAgICAgICAgZXh0ZW5z aW9uTW9kdWxlLT5mdW5jdGlvblBvaW50ZXI8V2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6ZVdp dGhVc2VyRGF0YUZ1bmN0aW9uPigid2Via2l0X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZV93aXRo X3VzZXJfZGF0YSIpOworICAgIGlmIChpbml0aWFsaXplV2l0aFVzZXJEYXRhRnVuY3Rpb24pIHsK KyAgICAgICAgaW5pdGlhbGl6ZVdpdGhVc2VyRGF0YUZ1bmN0aW9uKG1fZXh0ZW5zaW9uLmdldCgp LCB1c2VyRGF0YSk7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAgIFdlYktpdFdl YkV4dGVuc2lvbkluaXRpYWxpemVGdW5jdGlvbiBpbml0aWFsaXplRnVuY3Rpb24gPQorICAgICAg ICBleHRlbnNpb25Nb2R1bGUtPmZ1bmN0aW9uUG9pbnRlcjxXZWJLaXRXZWJFeHRlbnNpb25Jbml0 aWFsaXplRnVuY3Rpb24+KCJ3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplIik7CisgICAg aWYgKGluaXRpYWxpemVGdW5jdGlvbikgeworICAgICAgICBpbml0aWFsaXplRnVuY3Rpb24obV9l eHRlbnNpb24uZ2V0KCkpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1 cm4gZmFsc2U7Cit9CisKK3ZvaWQgV2ViR3RrRXh0ZW5zaW9uTWFuYWdlcjo6aW5pdGlhbGl6ZShX S0J1bmRsZVJlZiBidW5kbGUsIFdLVHlwZVJlZiB1c2VyRGF0YVN0cmluZykKK3sKICAgICBTdHJp bmcgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeTsKLSAgICBpZiAodXNlckRhdGEpIHsKLSAgICAgICAg QVNTRVJUKFdLR2V0VHlwZUlEKHVzZXJEYXRhKSA9PSBXS1N0cmluZ0dldFR5cGVJRCgpKTsKLSAg ICAgICAgd2ViRXh0ZW5zaW9uc0RpcmVjdG9yeSA9IHRvSW1wbChzdGF0aWNfY2FzdDxXS1N0cmlu Z1JlZj4odXNlckRhdGEpKS0+c3RyaW5nKCk7Ci0gICAgfQorICAgIEdSZWZQdHI8R1ZhcmlhbnQ+ IHVzZXJEYXRhOworICAgIHBhcnNlVXNlckRhdGEodXNlckRhdGFTdHJpbmcsIHdlYkV4dGVuc2lv bnNEaXJlY3RvcnksIHVzZXJEYXRhKTsKIAogICAgIGlmICh3ZWJFeHRlbnNpb25zRGlyZWN0b3J5 LmlzTnVsbCgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBtX2V4dGVuc2lvbiA9IGFkb3B0R1Jl Zih3ZWJraXRXZWJFeHRlbnNpb25DcmVhdGUodG9JbXBsKGJ1bmRsZSkpKTsKKwogICAgIFZlY3Rv cjxTdHJpbmc+IG1vZHVsZVBhdGhzOwogICAgIHNjYW5Nb2R1bGVzKHdlYkV4dGVuc2lvbnNEaXJl Y3RvcnksIG1vZHVsZVBhdGhzKTsKIApAQCAtNjksMTQgKzEwOCw4IEBAIHZvaWQgV2ViR3RrRXh0 ZW5zaW9uTWFuYWdlcjo6aW5pdGlhbGl6ZShXS0J1bmRsZVJlZiBidW5kbGUsIFdLVHlwZVJlZiB1 c2VyRGF0YSkKICAgICAgICAgT3duUHRyPE1vZHVsZT4gbW9kdWxlID0gYWRvcHRQdHIobmV3IE1v ZHVsZShtb2R1bGVQYXRoc1tpXSkpOwogICAgICAgICBpZiAoIW1vZHVsZS0+bG9hZCgpKQogICAg ICAgICAgICAgY29udGludWU7Ci0KLSAgICAgICAgV2ViS2l0V2ViRXh0ZW5zaW9uSW5pdGlhbGl6 ZUZ1bmN0aW9uIGluaXRpYWxpemVGdW5jdGlvbiA9Ci0gICAgICAgICAgICBtb2R1bGUtPmZ1bmN0 aW9uUG9pbnRlcjxXZWJLaXRXZWJFeHRlbnNpb25Jbml0aWFsaXplRnVuY3Rpb24+KCJ3ZWJraXRf d2ViX2V4dGVuc2lvbl9pbml0aWFsaXplIik7Ci0gICAgICAgIGlmICghaW5pdGlhbGl6ZUZ1bmN0 aW9uKQotICAgICAgICAgICAgY29udGludWU7Ci0KLSAgICAgICAgbV9leHRlbnNpb25Nb2R1bGVz LmFwcGVuZChtb2R1bGUubGVha1B0cigpKTsKLSAgICAgICAgaW5pdGlhbGl6ZUZ1bmN0aW9uKG1f ZXh0ZW5zaW9uLmdldCgpKTsKKyAgICAgICAgaWYgKGluaXRpYWxpemVXZWJFeHRlbnNpb24obW9k dWxlLmdldCgpLCB1c2VyRGF0YS5nZXQoKSkpCisgICAgICAgICAgICBtX2V4dGVuc2lvbk1vZHVs ZXMuYXBwZW5kKG1vZHVsZS5sZWFrUHRyKCkpOwogICAgIH0KIH0KIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2ViR3RrRXh0ZW5zaW9uTWFuYWdlci5oIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9ndGsvV2ViR3RrRXh0ZW5zaW9uTWFuYWdlci5oCmluZGV4 IGQ3MmQ0NWEyMzkzYTYwYzA2MDNmNWM0ZGI1NWNlZmQ5MjIzNjQ5ZGIuLmVjMGJkYzVkZmFiZTcz MTBiMTFlOGE3MDVmZTEwMmNkMWFlNDk1MzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvZ3RrL1dlYkd0a0V4dGVuc2lvbk1hbmFnZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL2d0ay9XZWJHdGtFeHRlbnNpb25NYW5hZ2VyLmgKQEAgLTQ2LDYgKzQ2LDcg QEAgcHJpdmF0ZToKICAgICBXZWJHdGtFeHRlbnNpb25NYW5hZ2VyKCk7CiAKICAgICB2b2lkIHNj YW5Nb2R1bGVzKGNvbnN0IFN0cmluZyYsIFZlY3RvcjxTdHJpbmc+Jik7CisgICAgYm9vbCBpbml0 aWFsaXplV2ViRXh0ZW5zaW9uKE1vZHVsZSogZXh0ZW5zaW9uTW9kdWxlLCBHVmFyaWFudCogdXNl ckRhdGEpOwogCiAgICAgVmVjdG9yPE1vZHVsZSo+IG1fZXh0ZW5zaW9uTW9kdWxlczsKICAgICBH UmVmUHRyPFdlYktpdFdlYkV4dGVuc2lvbj4gbV9leHRlbnNpb247CmRpZmYgLS1naXQgYS9Ub29s cy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggN2E3M2MyOWNhZmU3MjI1NjUwNDVm MTVhZTcxMWJmZGNlYTY1YWJjZC4uODJkYWIyNmJmZDQxNWFlMGZkYzI5ZDAyODIzYTZlMzk2ODUz N2JhMSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDM2IEBACisyMDE0LTAxLTIxICBBZHJpYW4gUGVyZXogZGUgQ2FzdHJvICA8YXBl cmV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gQWxsb3cgcGFzc2luZyBleHRyYSBkYXRh IHRvIHdlYiBleHRlbnNpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xMjU5OTAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBBbGxvdyBwYXNzaW5nIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gdG8gdGhlIGlu amVjdGVkIGJ1bmRsZS4gT24gdG9wCisgICAgICAgIG9mIHRoZSBzdHJpbmcgY29udGFpbmluZyB0 aGUgcGF0aCB0byB0aGUgd2ViIGV4dGVuc2lvbnMgZGlyZWN0b3J5LAorICAgICAgICBhIEdWYXJp YW50IGNhbiBiZSBzZXQgd2l0aCBhZGRpdGlvbmFsIGRhdGEgdXNpbmcKKyAgICAgICAgd2Via2l0 X3dlYl9jb250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEo KS4KKyAgICAgICAgQWxzbywgYSBuZXcgaW5pdGlhbGl6ZS13ZWItZXh0ZW5zaW9ucyBzaWduYWwg aXMgZW1pdHRlZCBiZWZvcmUKKyAgICAgICAgbGF1bmNoaW5nIGEgbmV3IFdlYlByb2Nlc3MgdG8g YWxsb3cgc2V0dGluZyBkaWZmZXJlbnQgdXNlciBkYXRhCisgICAgICAgIGZvciBlYWNoIHByb2Nl c3MuIFRoZSBHVmFyaWFudCBpcyBzZXJpYWxpemVkIGFzIGEgc3RyaW5nLCBwYXNzZWQKKyAgICAg ICAgdG8gdGhlIGluamVjdGVkIGJ1bmRsZSwgYW5kIHRoZSBpbmplY3RlZCBidW5kbGUgZGVzZXJp YWxpemVzIGJhY2sKKyAgICAgICAgdGhlIGRhdGEsIHdoaWNoIGlzIHBhc3NlZCB0byB3ZWIgZXh0 ZW5zaW9ucyB3aGljaCBkZWZpbmUgdGhlCisgICAgICAgIHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2lu aXRpYWxpemVfd2l0aF91c2VyX2RhdGEoKSBmdW5jdGlvbiAoZm9yCisgICAgICAgIGJhY2t3YXJk cyBjb21wYXRpYmlsaXR5LCB3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXplKCkgaXMKKyAg ICAgICAgdXNlZCBhcyBhIGZhbGxiYWNrLikKKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0ZW5zaW9ucy5jcHA6CisgICAgICAgIChpbml0aWFsaXpl V2ViRXh0ZW5zaW9ucyk6IEhhbmRsZXMgdGhlIGluaXRpYWxpemUtd2ViLWV4dGVuc2lvbnMKKyAg ICAgICAgc2lnbmFsLCBhbmQgc2V0cyB0aGUgd2ViIGV4dGVuc2lvbnMgZGlyZWN0b3J5IGFuZCB0 aGUgaW5pdGlhbGl6YXRpb24KKyAgICAgICAgdXNlciBkYXRhLgorICAgICAgICAodGVzdFdlYkV4 dGVuc2lvbkluaXRpYWxpemF0aW9uVXNlckRhdGEpOiBOZXcgdGVzdCBjYXNlIGZvciBjaGVja2lu ZworICAgICAgICB0aGUgdXNlciBkYXRhIHBhc3NlZCBvbiBpbml0aWFsaXphdGlvbiB0byB3ZWIg ZXh0ZW5zaW9ucy4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvV2Vi RXh0ZW5zaW9uVGVzdC5jcHA6CisgICAgICAgIChtZXRob2RDYWxsQ2FsbGJhY2spOiBBZGRlZCBp bXBsZW1lbnRhdGlvbiBmb3IgdGhlCisgICAgICAgIEdldEluaXRpYWxpemF0aW9uVXNlckRhdGEg RC1CdXMgbWV0aG9kLCB1c2VkIGJ5CisgICAgICAgIHRlc3RXZWJFeHRlbnNpb25Jbml0aWFsaXph dGlvblVzZXJEYXRhKCkuCisgICAgICAgICh3ZWJraXRfd2ViX2V4dGVuc2lvbl9pbml0aWFsaXpl X3dpdGhfdXNlcl9kYXRhKTogRGVmaW5lIHRoZQorICAgICAgICBpbml0aWFsaXphdGlvbiBmdW5j dGlvbiB3aXRoIHRoZSBhZGRpdGlvbmFsIHVzZXIgZGF0YSBwYXJhbWV0ZXIuCisKIDIwMTQtMDEt MjEgIEtyenlzenRvZiBDemVjaCAgPGsuY3plY2hAc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0FU S10gRXhwb3NlIGFyaWEtZmxvd3RvIHRocm91Z2ggQVRLX1JFTEFUSU9OX0ZMT1dTX1RPCmRpZmYg LS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYkV4dGVu c2lvbnMuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RXZWJF eHRlbnNpb25zLmNwcAppbmRleCBiMDNjOWRjYWQ1YTM3ZGFlYTQwYjdiYWQyMzliYzNhNzVlYTcx Yjg5Li5lOWVmMTkyMjQ5NDljOTc5NzRiMTFhZjJkYTU0MjgxN2U4ODM4ZDk3IDEwMDY0NAotLS0g YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdFdlYkV4dGVuc2lvbnMu Y3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0V2ViRXh0 ZW5zaW9ucy5jcHAKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlICJXZWJWaWV3VGVzdC5oIgog I2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KIAorc3RhdGljIGNvbnN0IGNoYXIqIHdl YkV4dGVuc2lvbnNVc2VyRGF0YSA9ICJXZWIgRXh0ZW5zaW9ucyB1c2VyIGRhdGEiOwogc3RhdGlj IFdlYktpdFRlc3RCdXMqIGJ1czsKIAogc3RhdGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbkdldFRp dGxlKFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2ludGVyKQpAQCAtMTc1LDEzICsxNzYsNDQg QEAgc3RhdGljIHZvaWQgdGVzdFdlYkV4dGVuc2lvbklzb2xhdGVkV29ybGQoV2ViVmlld1Rlc3Qq IHRlc3QsIGdjb25zdHBvaW50ZXIpCiAgICAgZ19zaWduYWxfaGFuZGxlcl9kaXNjb25uZWN0KHRl c3QtPm1fd2ViVmlldywgc2NyaXB0RGlhbG9nSUQpOwogfQogCitzdGF0aWMgdm9pZCB0ZXN0V2Vi RXh0ZW5zaW9uSW5pdGlhbGl6YXRpb25Vc2VyRGF0YShXZWJWaWV3VGVzdCogdGVzdCwgZ2NvbnN0 cG9pbnRlcikKK3sKKyAgICB0ZXN0LT5sb2FkSHRtbCgiPGh0bWw+PC9odG1sPiIsIDApOworICAg IHRlc3QtPndhaXRVbnRpbExvYWRGaW5pc2hlZCgpOworCisgICAgR1JlZlB0cjxHREJ1c1Byb3h5 PiBwcm94eSA9IGFkb3B0R1JlZihidXMtPmNyZWF0ZVByb3h5KCJvcmcud2Via2l0Lmd0ay5XZWJF eHRlbnNpb25UZXN0IiwKKyAgICAgICAgIi9vcmcvd2Via2l0L2d0ay9XZWJFeHRlbnNpb25UZXN0 IiwgIm9yZy53ZWJraXQuZ3RrLldlYkV4dGVuc2lvblRlc3QiLCB0ZXN0LT5tX21haW5Mb29wKSk7 CisKKyAgICBHUmVmUHRyPEdWYXJpYW50PiByZXN1bHQgPSBhZG9wdEdSZWYoZ19kYnVzX3Byb3h5 X2NhbGxfc3luYygKKyAgICAgICAgcHJveHkuZ2V0KCksCisgICAgICAgICJHZXRJbml0aWFsaXph dGlvblVzZXJEYXRhIiwKKyAgICAgICAgbnVsbHB0ciwKKyAgICAgICAgR19EQlVTX0NBTExfRkxB R1NfTk9ORSwKKyAgICAgICAgLTEsIDAsIDApKTsKKyAgICBnX2Fzc2VydChyZXN1bHQpOworCisg ICAgY29uc3QgZ2NoYXIqIHVzZXJEYXRhID0gbnVsbHB0cjsKKyAgICBnX3ZhcmlhbnRfZ2V0KHJl c3VsdC5nZXQoKSwgIigmcykiLCAmdXNlckRhdGEpOworICAgIGdfYXNzZXJ0X2NtcHN0cih1c2Vy RGF0YSwgPT0sIHdlYkV4dGVuc2lvbnNVc2VyRGF0YSk7Cit9CisKK3N0YXRpYyB2b2lkIGluaXRp YWxpemVXZWJFeHRlbnNpb25zKFdlYktpdFdlYkNvbnRleHQqIGNvbnRleHQsIGdwb2ludGVyKQor eworICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2ViX2V4dGVuc2lvbnNfZGlyZWN0b3J5KGNv bnRleHQsIFdFQktJVF9URVNUX1dFQl9FWFRFTlNJT05TX0RJUik7CisgICAgd2Via2l0X3dlYl9j b250ZXh0X3NldF93ZWJfZXh0ZW5zaW9uc19pbml0aWFsaXphdGlvbl91c2VyX2RhdGEoY29udGV4 dCwKKyAgICAgICAgZ192YXJpYW50X25ldygiJnMiLCB3ZWJFeHRlbnNpb25zVXNlckRhdGEpKTsK K30KKwogdm9pZCBiZWZvcmVBbGwoKQogewotICAgIHdlYmtpdF93ZWJfY29udGV4dF9zZXRfd2Vi X2V4dGVuc2lvbnNfZGlyZWN0b3J5KHdlYmtpdF93ZWJfY29udGV4dF9nZXRfZGVmYXVsdCgpLCBX RUJLSVRfVEVTVF9XRUJfRVhURU5TSU9OU19ESVIpOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2Vi a2l0X3dlYl9jb250ZXh0X2dldF9kZWZhdWx0KCksCisgICAgICAgICJpbml0aWFsaXplLXdlYi1l eHRlbnNpb25zIiwgR19DQUxMQkFDSyhpbml0aWFsaXplV2ViRXh0ZW5zaW9ucyksIG51bGxwdHIp OworCiAgICAgYnVzID0gbmV3IFdlYktpdFRlc3RCdXMoKTsKICAgICBpZiAoIWJ1cy0+cnVuKCkp CiAgICAgICAgIHJldHVybjsKIAorICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYkNvbnRl eHQiLCAiaW5pdGlhbGl6YXRpb24tdXNlci1kYXRhIiwgdGVzdFdlYkV4dGVuc2lvbkluaXRpYWxp emF0aW9uVXNlckRhdGEpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYkV4dGVuc2lv biIsICJkb20tZG9jdW1lbnQtdGl0bGUiLCB0ZXN0V2ViRXh0ZW5zaW9uR2V0VGl0bGUpOwogICAg IFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYkV4dGVuc2lvbiIsICJkb2N1bWVudC1sb2FkZWQt c2lnbmFsIiwgdGVzdERvY3VtZW50TG9hZGVkU2lnbmFsKTsKICAgICBXZWJWaWV3VGVzdDo6YWRk KCJXZWJLaXRXZWJWaWV3IiwgIndlYi1wcm9jZXNzLWNyYXNoZWQiLCB0ZXN0V2ViS2l0V2ViVmll d1Byb2Nlc3NDcmFzaGVkKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mkd0ay9XZWJFeHRlbnNpb25UZXN0LmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mkd0ay9XZWJFeHRlbnNpb25UZXN0LmNwcAppbmRleCA0MGNiNmNhZjkxNWUxNGJj ODE0OWYzY2QzYjNjMGVmMzgyOTI4MTU3Li5lOGEyYjlmNjUzNGFjN2UzMWZkNjkzMWQ3NWU4MzNi ZmY4ZjM0YmU5IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJH dGsvV2ViRXh0ZW5zaW9uVGVzdC5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyR3RrL1dlYkV4dGVuc2lvblRlc3QuY3BwCkBAIC00NSw2ICs0NSw5IEBAIHN0YXRpYyBj b25zdCBjaGFyIGludHJvc3BlY3Rpb25YTUxbXSA9CiAgICAgIiAgIDxhcmcgdHlwZT0ndCcgbmFt ZT0ncGFnZUlEJyBkaXJlY3Rpb249J2luJy8+IgogICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9 J3NjcmlwdCcgZGlyZWN0aW9uPSdpbicvPiIKICAgICAiICA8L21ldGhvZD4iCisgICAgIiAgPG1l dGhvZCBuYW1lPSdHZXRJbml0aWFsaXphdGlvblVzZXJEYXRhJz4iCisgICAgIiAgIDxhcmcgdHlw ZT0ncycgbmFtZT0ndXNlckRhdGEnIGRpcmVjdGlvbj0nb3V0Jy8+IgorICAgICIgIDwvbWV0aG9k PiIKICAgICAiICA8c2lnbmFsIG5hbWU9J0RvY3VtZW50TG9hZGVkJy8+IgogICAgICIgIDxzaWdu YWwgbmFtZT0nVVJJQ2hhbmdlZCc+IgogICAgICIgICA8YXJnIHR5cGU9J3MnIG5hbWU9J3VyaScg ZGlyZWN0aW9uPSdvdXQnLz4iCkBAIC01Miw2ICs1NSw5IEBAIHN0YXRpYyBjb25zdCBjaGFyIGlu dHJvc3BlY3Rpb25YTUxbXSA9CiAgICAgIiA8L2ludGVyZmFjZT4iCiAgICAgIjwvbm9kZT4iOwog CitzdGF0aWMgR1JlZlB0cjxHVmFyaWFudD4gaW5pdGlhbGl6YXRpb25Vc2VyRGF0YTsKKworCiB0 eXBlZGVmIGVudW0gewogICAgIERvY3VtZW50TG9hZGVkU2lnbmFsLAogICAgIFVSSUNoYW5nZWRT aWduYWwsCkBAIC0yMTAsOCArMjE2LDE0IEBAIHN0YXRpYyB2b2lkIG1ldGhvZENhbGxDYWxsYmFj ayhHREJ1c0Nvbm5lY3Rpb24qIGNvbm5lY3Rpb24sIGNvbnN0IGNoYXIqIHNlbmRlciwKICAgICAg ICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGpzU2NyaXB0KEFkb3B0LCBKU1N0cmluZ0NyZWF0 ZVdpdGhVVEY4Q1N0cmluZyhzY3JpcHQpKTsKICAgICAgICAgSlNFdmFsdWF0ZVNjcmlwdChqc0Nv bnRleHQsIGpzU2NyaXB0LmdldCgpLCAwLCAwLCAwLCAwKTsKICAgICAgICAgZ19kYnVzX21ldGhv ZF9pbnZvY2F0aW9uX3JldHVybl92YWx1ZShpbnZvY2F0aW9uLCAwKTsKLSAgICB9IGVsc2UgaWYg KCFnX3N0cmNtcDAobWV0aG9kTmFtZSwgIkFib3J0UHJvY2VzcyIpKQorICAgIH0gZWxzZSBpZiAo IWdfc3RyY21wMChtZXRob2ROYW1lLCAiQWJvcnRQcm9jZXNzIikpIHsKICAgICAgICAgYWJvcnQo KTsKKyAgICB9IGVsc2UgaWYgKCFnX3N0cmNtcDAobWV0aG9kTmFtZSwgIkdldEluaXRpYWxpemF0 aW9uVXNlckRhdGEiKSkgeworICAgICAgICBnX2Fzc2VydChpbml0aWFsaXphdGlvblVzZXJEYXRh KTsKKyAgICAgICAgZ19hc3NlcnQoZ192YXJpYW50X2lzX29mX3R5cGUoaW5pdGlhbGl6YXRpb25V c2VyRGF0YS5nZXQoKSwgR19WQVJJQU5UX1RZUEVfU1RSSU5HKSk7CisgICAgICAgIGdfZGJ1c19t ZXRob2RfaW52b2NhdGlvbl9yZXR1cm5fdmFsdWUoaW52b2NhdGlvbiwgZ192YXJpYW50X25ldygi KHMpIiwKKyAgICAgICAgICAgIGdfdmFyaWFudF9nZXRfc3RyaW5nKGluaXRpYWxpemF0aW9uVXNl ckRhdGEuZ2V0KCksIG51bGxwdHIpKSk7CisgICAgfQogfQogCiBzdGF0aWMgY29uc3QgR0RCdXNJ bnRlcmZhY2VWVGFibGUgaW50ZXJmYWNlVmlydHVhbFRhYmxlID0gewpAQCAtMjUwLDggKzI2Miwx MCBAQCBzdGF0aWMgdm9pZCBidXNBY3F1aXJlZENhbGxiYWNrKEdEQnVzQ29ubmVjdGlvbiogY29u bmVjdGlvbiwgY29uc3QgY2hhciogbmFtZSwgZwogICAgIH0KIH0KIAotZXh0ZXJuICJDIiB2b2lk IHdlYmtpdF93ZWJfZXh0ZW5zaW9uX2luaXRpYWxpemUoV2ViS2l0V2ViRXh0ZW5zaW9uKiBleHRl bnNpb24pCitleHRlcm4gIkMiIHZvaWQgd2Via2l0X3dlYl9leHRlbnNpb25faW5pdGlhbGl6ZV93 aXRoX3VzZXJfZGF0YShXZWJLaXRXZWJFeHRlbnNpb24qIGV4dGVuc2lvbiwgR1ZhcmlhbnQqIHVz ZXJEYXRhKQogeworICAgIGluaXRpYWxpemF0aW9uVXNlckRhdGEgPSB1c2VyRGF0YTsKKwogICAg IGdfc2lnbmFsX2Nvbm5lY3QoZXh0ZW5zaW9uLCAicGFnZS1jcmVhdGVkIiwgR19DQUxMQkFDSyhw YWdlQ3JlYXRlZENhbGxiYWNrKSwgZXh0ZW5zaW9uKTsKICAgICBnX3NpZ25hbF9jb25uZWN0KHdl YmtpdF9zY3JpcHRfd29ybGRfZ2V0X2RlZmF1bHQoKSwgIndpbmRvdy1vYmplY3QtY2xlYXJlZCIs IEdfQ0FMTEJBQ0sod2luZG93T2JqZWN0Q2xlYXJlZCksIDApOwogCg==