75543 2012-01-04 06:52:11 -0800 [GTK] Add webkit_web_view_run_javascript() to WebKit2 GTK+ 2012-03-21 01:44:43 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 79918 81331 1 cgarcia webkit-unassigned alex andersca gustavo mrobinson pnormand sam webkit.review.bot xan.lopez oldest_to_newest 529505 0 cgarcia 2012-01-04 06:52:11 -0800 C API provides: typedef void (*WKPageRunJavaScriptFunction)(WKSerializedScriptValueRef, WKErrorRef, void*); WK_EXPORT void WKPageRunJavaScriptInMainFrame(WKPageRef page, WKStringRef script, void* context, WKPageRunJavaScriptFunction function); So we need to decide how to expose it in the wk2 GTK+ API. I have a couple of questions: - how to handle the callback? do we use gio async pattern? or do we just provide our own custom callback? - What does the callback return? libwebkitgtk+ depends on javascriptcore, can use expose JSValueRef in the API? or should we wrap it somehow? 555137 1 126740 cgarcia 2012-02-13 02:46:30 -0800 Created attachment 126740 Patch 555141 2 webkit.review.bot 2012-02-13 02:52:04 -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 559031 3 126740 pnormand 2012-02-17 01:33:57 -0800 Comment on attachment 126740 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126740&action=review LGTM! I was a bit worried by the JSValue exposure in the API but after talking with Carlos it seems we don't have much choice. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1432 > + * Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command(). Hum copy/paste error? Not sure this has anything to do with webkit_web_view_can_execute_editing_command() ;) > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1433 > + * The returned JSValueRef is a temporary value that should be consumed inmediately. immediately 559033 4 cgarcia 2012-02-17 01:37:00 -0800 (In reply to comment #3) > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1432 > > + * Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command(). > > Hum copy/paste error? Not sure this has anything to do with webkit_web_view_can_execute_editing_command() ;) oops > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1433 > > + * The returned JSValueRef is a temporary value that should be consumed inmediately. > > immediately oh! 559419 5 126740 mrobinson 2012-02-17 12:07:32 -0800 Comment on attachment 126740 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126740&action=review Looks pretty good, but it's an error to access JavaScript values with a different global context. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1399 > + JSGlobalContextRef scriptContext = JSGlobalContextCreate(0); > + JSValueRef scriptValue = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, scriptContext, 0); > + g_simple_async_result_set_op_res_gpointer(result.get(), const_cast<OpaqueJSValue*>(scriptValue), 0); > + g_simple_async_result_complete(result.get()); > + JSGlobalContextRelease(scriptContext); Instead of creating a temporary JSGlobalContext, it would probably be better to create one with the WebView, so that JavaScriptCore values can stay alive longer. > Source/WebKit2/UIProcess/API/gtk/tests/ScriptContext.cpp:45 > + JSRetainPtr<JSStringRef> stringValue(Adopt, JSValueToStringCopy(m_context, value, 0)); > + g_assert(stringValue); > + > + size_t cStringLength = JSStringGetMaximumUTF8CStringSize(stringValue.get()); > + char* cString = static_cast<char*>(g_malloc(cStringLength)); > + JSStringGetUTF8CString(stringValue.get(), cString, cStringLength); It's important to access the value with the same JSC context that created the value. Thus it should probably be passed as property of the AsyncResult or kept as a property of the WebKitWebView. 559544 6 126740 mrobinson 2012-02-17 14:27:47 -0800 Comment on attachment 126740 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126740&action=review It seems that there are three things we want to return for every JavaScript invocation: a JSContextRef, a JSValueRef and a JSValueRef for exceptions. I'm not sure the cleanest way to pass all this to the user with the GIO style API. I'm am fairly certain though that it doesn't make sense to pass the exception as a GError. I think we should reserve GErrors for when we actually have problems executing the JavaScript. It's important that the client can distinguish between script exceptions and problems internal to WebKit. The exception must be a JSValueRef in the end anyhow. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1396 > + JSValueRef scriptValue = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, scriptContext, 0); Instead of throwing away the exception it would be better to pass it to the client somehow. It's a pretty important piece of the story. > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp:474 > + callbackData.expectedResult = "WebKitGTK+ Title"; > + test->runJavaScriptAndWaitUntilFinished("window.document.getElementById('WebKitLink').title;", testWebViewRunJavaScriptFinishedCallback, &callbackData); Instead of writing this with the use of a callback function, why not just store the results of the operation in WebKitWebView and read them after you call runJavaScriptAndWaitUntilFinished. This more closely matches how LoadTrackingTest works. I think it's a little more straight-forward too. > Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h:52 > + void runJavaScriptAndWaitUntilFinished(const char* js, JavascriptFinishedCallback, void* userData); Would prefer something like scriptString instead of just "js" 559748 7 cgarcia 2012-02-18 00:45:31 -0800 (In reply to comment #5) > (From update of attachment 126740 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=126740&action=review > > Looks pretty good, but it's an error to access JavaScript values with a different global context. You mean from a different global context than the one executing the script? because the context where the script executes is in the web process. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1399 > > + JSGlobalContextRef scriptContext = JSGlobalContextCreate(0); > > + JSValueRef scriptValue = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, scriptContext, 0); > > + g_simple_async_result_set_op_res_gpointer(result.get(), const_cast<OpaqueJSValue*>(scriptValue), 0); > > + g_simple_async_result_complete(result.get()); > > + JSGlobalContextRelease(scriptContext); > > Instead of creating a temporary JSGlobalContext, it would probably be better to create one with the WebView, so that JavaScriptCore values can stay alive longer. Ah, so the JSValueRef we return is actually a temp value because it's destroyed by the global context, right? So, is it correct to use the same global context for different scripts? Not that I don't know anything about javascript :-P > > Source/WebKit2/UIProcess/API/gtk/tests/ScriptContext.cpp:45 > > + JSRetainPtr<JSStringRef> stringValue(Adopt, JSValueToStringCopy(m_context, value, 0)); > > + g_assert(stringValue); > > + > > + size_t cStringLength = JSStringGetMaximumUTF8CStringSize(stringValue.get()); > > + char* cString = static_cast<char*>(g_malloc(cStringLength)); > > + JSStringGetUTF8CString(stringValue.get(), cString, cStringLength); > > It's important to access the value with the same JSC context that created the value. Ah, ok you mean the context that deserialized the value, not where the script executed. > Thus it should probably be passed as property of the AsyncResult or kept as a property of the WebKitWebView. So, if understand this correctly, we want to use a different context for every javascript execution, to make sure JSValueRefs are accessed with the same context that the one that created deserialized the value. So, I think we could make webkit_web_view_run_javascript_finish return a WebKitJavascripResult object containing the context, the value and the exception. That way the value will be alive until the WebKitJavaScript result is destroyed. 559750 8 cgarcia 2012-02-18 00:55:55 -0800 (In reply to comment #6) > (From update of attachment 126740 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=126740&action=review > > It seems that there are three things we want to return for every JavaScript invocation: a JSContextRef, a JSValueRef and a JSValueRef for exceptions. I'm not sure the cleanest way to pass all this to the user with the GIO style API. why not? > I'm am fairly certain though that it doesn't make sense to pass the exception as a GError. I think we should reserve GErrors for when we actually have problems executing the JavaScript. It's important that the client can distinguish between script exceptions and problems internal to WebKit. The exception must be a JSValueRef in the end anyhow. Agree, the GError passed to webkit_web_view_run_javascript_finish() wouldn't contain the javascript exection, because the script was correctly executed, if there's an error in the script that's not an error in the async operation. So as I suggested before, we could just return a WebKitJavascriptResult object (or boxed type, maybe) containing the context, the value and the exception. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1396 > > + JSValueRef scriptValue = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, scriptContext, 0); > > Instead of throwing away the exception it would be better to pass it to the client somehow. It's a pretty important piece of the story. Ok, I see now. > > Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp:474 > > + callbackData.expectedResult = "WebKitGTK+ Title"; > > + test->runJavaScriptAndWaitUntilFinished("window.document.getElementById('WebKitLink').title;", testWebViewRunJavaScriptFinishedCallback, &callbackData); > > Instead of writing this with the use of a callback function, why not just store the results of the operation in WebKitWebView and read them after you call runJavaScriptAndWaitUntilFinished. This more closely matches how LoadTrackingTest works. I think it's a little more straight-forward too. I didn't do that because with the current code the JSValueRef is a temporary value that is no longer alive after the execution of the callback. If we use the WebKitJavascriptResult, we could just store the result. I didn't like having to use a callback either. > > Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h:52 > > + void runJavaScriptAndWaitUntilFinished(const char* js, JavascriptFinishedCallback, void* userData); > > Would prefer something like scriptString instead of just "js" Ok. 559778 9 mrobinson 2012-02-18 07:55:43 -0800 (In reply to comment #8) > > It seems that there are three things we want to return for every JavaScript invocation: a JSContextRef, a JSValueRef and a JSValueRef for exceptions. I'm not sure the cleanest way to pass all this to the user with the GIO style API. > > why not? Sorry. This was a little unclear. What I meant here was that I couldn't quickly find any examples of this kind of situation with the GIO style APIs in devhelp. I guessed that you would just need to implement your own GAsyncResult, but I wasn't confident enough to suggest it. I didn't mean to say that we should do away with GIO style APIs. > So as I suggested before, we could just return a WebKitJavascriptResult object (or boxed type, maybe) containing the context, the value and the exception. That sound like a good plan. > I didn't do that because with the current code the JSValueRef is a temporary value that is no longer alive after the execution of the callback. If we use the WebKitJavascriptResult, we could just store the result. I didn't like having to use a callback either. Great. One thing that I think would be useful is to create only one JSGlobalContext for the entire WebKitWebView. Every deserialized JavaScript result could use that same global context. This would be useful because it would allow the user to create other bits of JavaScript and even to pass the return values of these APIs to functions that they create. You could add a getter to WebKitWebView for this global context. 559900 10 cgarcia 2012-02-19 08:05:13 -0800 (In reply to comment #9) > (In reply to comment #8) > > > > It seems that there are three things we want to return for every JavaScript invocation: a JSContextRef, a JSValueRef and a JSValueRef for exceptions. I'm not sure the cleanest way to pass all this to the user with the GIO style API. > > > > why not? > > Sorry. This was a little unclear. What I meant here was that I couldn't quickly find any examples of this kind of situation with the GIO style APIs in devhelp. There a lot of examples in GFile API, for example g_file_query_info_async(), g_file_query_info_finish() returns a GFileInfo object. > I guessed that you would just need to implement your own GAsyncResult, but I wasn't confident enough to suggest it. No, we can use a GSimpleAsyncResult and store the object with g_simple_async_result_set_op_res_gpointer(). > I didn't mean to say that we should do away with GIO style APIs. Ok, no problem. > > So as I suggested before, we could just return a WebKitJavascriptResult object (or boxed type, maybe) containing the context, the value and the exception. > > That sound like a good plan. > > > I didn't do that because with the current code the JSValueRef is a temporary value that is no longer alive after the execution of the callback. If we use the WebKitJavascriptResult, we could just store the result. I didn't like having to use a callback either. > > Great. > > One thing that I think would be useful is to create only one JSGlobalContext for the entire WebKitWebView. Every deserialized JavaScript result could use that same global context. This would be useful because it would allow the user to create other bits of JavaScript and even to pass the return values of these APIs to functions that they create. You could add a getter to WebKitWebView for this global context. Ok, created on demand I guess? 559905 11 mrobinson 2012-02-19 09:44:33 -0800 (In reply to comment #10) > There a lot of examples in GFile API, for example g_file_query_info_async(), g_file_query_info_finish() returns a GFileInfo object. Ah, I see. > > One thing that I think would be useful is to create only one JSGlobalContext for the entire WebKitWebView. Every deserialized JavaScript result could use that same global context. This would be useful because it would allow the user to create other bits of JavaScript and even to pass the return values of these APIs to functions that they create. You could add a getter to WebKitWebView for this global context. > > Ok, created on demand I guess? That should be fine. 560787 12 cgarcia 2012-02-21 03:33:26 -0800 I have found some problems reworking the patch WebProcess executes the javascript with a NULL exception, and in case of error it sends a NULL serialized value to the UI process. That means that from the UI we only know that the script failed to execute when serialized value is NULL, but we don't have more information about the exception. We only have information about the exception that might happen deserializing values in the UI process. I see two possible solutions: 1. Create a JSObjectRef with generic exception message (something like, and exception ocurred executing script) and create a WebKitJavascriptResult with that exception. 2. Add a new WebKitError (WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_EXCEPTION) and fill a GError to finish the async operation so no WebKitJavascriptResult is created. With first solution all exceptions are handled the same way, and we keep that the GError passed to webkit_web_view_run_javascript_finish() is only for errors of the async operation and not javascript exception. On the other hand, users will expect real exception, with information about the line number and source file, for example. We would be providing such info only for exceptions raised when deserializing the result. Which is a bit confusing. With the second option we make the async operation fail in case of error in the javascript execution, so we give a GError and the user will expect it to be a error defined by us, not a detailed javascript exception. So, my proposal is: Add WEBKIT_JAVASCRIPT_ERROR type with values WEBKIT_JAVASCRIPT_ERROR_EXECUTION and WEBKIT_JAVASCRIPT_ERROR_VALUE (or something like that) and make the async operation fail when the javascript failed to execute and when we fail to deserialize the value, filling a GError in both cases. Then WebKitJavascriptResult won't have any information about exceptions and its value will always be valid. 560937 13 mrobinson 2012-02-21 09:07:46 -0800 (In reply to comment #12) > I have found some problems reworking the patch > > WebProcess executes the javascript with a NULL exception, and in case of error it sends a NULL serialized value to the UI process. That means that from the UI we only know that the script failed to execute when serialized value is NULL, but we don't have more information about the exception. > We only have information about the exception that might happen deserializing values in the UI process. Would it make sense to get a real value on the WebProcess side and just send that to the UIProcess? That seems like a logical step, unless there is some reason it isn't done now. 561798 14 cgarcia 2012-02-22 03:06:03 -0800 (In reply to comment #13) > (In reply to comment #12) > > I have found some problems reworking the patch > > > > WebProcess executes the javascript with a NULL exception, and in case of error it sends a NULL serialized value to the UI process. That means that from the UI we only know that the script failed to execute when serialized value is NULL, but we don't have more information about the exception. > > We only have information about the exception that might happen deserializing values in the UI process. > > Would it make sense to get a real value on the WebProcess side and just send that to the UIProcess? That seems like a logical step, unless there is some reason it isn't done now. There are actually 3 possible exceptions involved: 1.- Exception raised by the script itself (This is the interesting one) 2.- Exception serializing the value in the web process (This is currently ignored) 3.- Exception deserializing the result value in the UI process 1 and 3 are probably very unlikely to happen. And the exception raised by the script itself, is emitted as an ErrorEvent so it ends up converted into a console message, so it's not possible to send that exception as a JSValueRef to the UI process. So, I guess we should provide a console-message signal that user might connect to to get exceptions and other messages. But addMessageToConsole is currently unimplemented in WebProcess. I'm not sure if there are pans to implement it, so I'm adding Anders and Sam to CC. 564246 15 cgarcia 2012-02-24 05:43:22 -0800 I've just filed: [WK2] Implement WebChromeClient::addMessageToConsole() https://bugs.webkit.org/show_bug.cgi?id=79482 580356 16 132244 cgarcia 2012-03-16 04:14:30 -0700 Created attachment 132244 New patch This patch adds WebKitJavascriptResult boxed type containing information about the result, the JSGlobalContextRef and the JSValueRef. That WebKitJavascriptResult is returned by webkit_web_view_run_javascript_finish(). I've left the exceptions out for now, for the reasons explained in previous comments. When bugs #79482 and #79918 are fixed, we can try to add the exception information to the WebKitJavascriptResult using the console, or just document that user should use the ::console-message signal to monitor script exceptions. 580560 17 132244 mrobinson 2012-03-16 09:07:25 -0700 Comment on attachment 132244 New patch View in context: https://bugs.webkit.org/attachment.cgi?id=132244&action=review > Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp:38 > +struct _WebKitJavascriptResult { > + _WebKitJavascriptResult(WebKitWebView* view, WKSerializedScriptValueRef wkSerializedScriptValue) > + : webView(view) > + , referenceCount(1) > + { > + value = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, webkit_web_view_get_javascript_global_context(view), 0); > + } > + > + GRefPtr<WebKitWebView> webView; > + JSValueRef value; > + > + int referenceCount; > +}; Instead of implementing your own reference counted type you could make this class extend from RefCounted<_WebKitJavaScriptResult> and use ref() and unref(). > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1504 > + g_set_error_literal(&error, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED, _("An exception was raised in Javascript")); Javascript -> JavaScript 583880 18 cgarcia 2012-03-21 01:02:37 -0700 (In reply to comment #17) > (From update of attachment 132244 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=132244&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp:38 > > +struct _WebKitJavascriptResult { > > + _WebKitJavascriptResult(WebKitWebView* view, WKSerializedScriptValueRef wkSerializedScriptValue) > > + : webView(view) > > + , referenceCount(1) > > + { > > + value = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, webkit_web_view_get_javascript_global_context(view), 0); > > + } > > + > > + GRefPtr<WebKitWebView> webView; > > + JSValueRef value; > > + > > + int referenceCount; > > +}; > > Instead of implementing your own reference counted type you could make this class extend from RefCounted<_WebKitJavaScriptResult> and use ref() and unref(). Is it worth converting that to a class? Is RefCounted better than our own implementation? it seems to use a mutex, while our implementation avoid the use of mutex by using atomic operations. I'll leave our current implementation for now, since it's pretty simple, and I'll write a patch to use RefCounted if it's really worth it and better. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:1504 > > + g_set_error_literal(&error, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED, _("An exception was raised in Javascript")); > > Javascript -> JavaScript Ok. 583896 19 cgarcia 2012-03-21 01:44:43 -0700 Committed r111510: <http://trac.webkit.org/changeset/111510> 126740 2012-02-13 02:46:30 -0800 2012-03-16 04:14:30 -0700 Patch wk2-run-javascript.diff text/plain 20287 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCBjMzFjMDMwLi4yYmEyMDYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkg QEAKKzIwMTItMDItMTMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtHVEtdIEFkZCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQoKSB0 byBXZWJLaXQyIEdUSysKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTc1NTQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRQcml2YXRlLmg6CisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHA6CisgICAgICAgICh3ZWJraXRXZWJWaWV3 UnVuSmF2YVNjcmlwdENhbGxiYWNrKTogQ2FsbGJhY2sgY2FsbGVkIGJ5IHRoZSBDIEFQSQorICAg ICAgICB3aGVuIGphdmFzcmlwdCBleGVjdXRpb24gaGFzIGZpbmlzaGVkLgorICAgICAgICAod2Vi a2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0KTogQXN5bmNocm9ub3VzbHkgcnVuIGEgZ2l2ZW4K KyAgICAgICAgamF2YXNjcmlwdC4KKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNj cmlwdF9maW5pc2gpOiBGaW5pc2ggYXN5bmMgb3BlcmF0aW9uCisgICAgICAgIHN0YXJ0ZWQgYnkg d2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0KCkuCisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay1zZWN0aW9ucy50eHQ6IEFkZCBuZXcgc3ltYm9scy4KKyAgICAgICAgKiBVSVBy b2Nlc3MvQVBJL2d0ay90ZXN0cy9HTlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBVSVByb2Nlc3Mv QVBJL2d0ay90ZXN0cy9TY3JpcHRDb250ZXh0LmNwcDogQWRkZWQuCisgICAgICAgIChTY3JpcHRD b250ZXh0OjpTY3JpcHRDb250ZXh0KTogSGVscGVyIG9iamVjdCB0byB3cmFwIGEKKyAgICAgICAg SlNHbG9iYWxDb250ZXh0UmVmLgorICAgICAgICAoU2NyaXB0Q29udGV4dDo6flNjcmlwdENvbnRl eHQpOgorICAgICAgICAoU2NyaXB0Q29udGV4dDo6anNWYWx1ZVRvQ1N0cmluZyk6IENvbnZlcnRz IGEgSlNWYWx1ZVJlZiBpbnRvIGEKKyAgICAgICAgY2hhciouCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9ndGsvdGVzdHMvU2NyaXB0Q29udGV4dC5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVByb2Nl c3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViS2l0V2ViVmlldy5jcHA6CisgICAgICAgIChKYXZhc2Ny aXB0Q2FsbGJhY2tEYXRhKToKKyAgICAgICAgKHRlc3RXZWJWaWV3UnVuSmF2YVNjcmlwdEZpbmlz aGVkQ2FsbGJhY2spOgorICAgICAgICAodGVzdFdlYlZpZXdSdW5KYXZhU2NyaXB0KToKKyAgICAg ICAgKGJlZm9yZUFsbCk6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmll d1Rlc3QuY3BwOgorICAgICAgICAocnVuSmF2YVNjcmlwdFJlYWR5Q2FsbGJhY2spOgorICAgICAg ICAoV2ViVmlld1Rlc3Q6OnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxGaW5pc2hlZCk6IEhlbHBl ciBmdW5jdGlvbgorICAgICAgICB0byBydW4gamF2YXNjcmlwdCBmcm9tIHRlc3RzLgorICAgICAg ICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0Lmg6CisKIDIwMTItMDItMTEg IFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVu cmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIxMDc0MzUuCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VM b2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYjBlMmNlOC4uNWNlNzU1OSAxMDA2NDQKLS0tIGEv VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisy MDEyLTAyLTEzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKwor ICAgICAgICBbR1RLXSBBZGQgd2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0KCkgdG8gV2Vi S2l0MiBHVEsrCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD03NTU0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogTWluaUJyb3dzZXIvZ3RrL0dOVW1ha2VmaWxlLmFtOiBBZGQgamF2YXNjcmlwdGNvcmVfY3Bw ZmxhZ3MgdG8KKyAgICAgICAgTWluaUJyb3dzZXIgQ1BQIGZsYWdzLgorCiAyMDEyLTAyLTEyICBL YW5naWwgSGFuICA8a2FuZ2lsLmhhbkBzYW1zdW5nLmNvbT4KIAogICAgICAgICBbRUZMXVtEUlRd IEltcGxlbWVudCB6b29tUGFnZXtJbixPdXR9IGFuZCB0ZXh0Wm9vbXtJbixPdXR9IGV2ZW50cy4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFByaXZh dGUuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFByaXZhdGUuaApp bmRleCA0M2QyNmNjLi4wZjM4OTE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0UHJpdmF0ZS5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8V2Vi S2l0Mi9XS0FQSUNhc3QuaD4KICNpbmNsdWRlIDxXZWJLaXQyL1dLRG93bmxvYWQuaD4KICNpbmNs dWRlIDxXZWJLaXQyL1dLUmV0YWluUHRyLmg+CisjaW5jbHVkZSA8V2ViS2l0Mi9XS1NlcmlhbGl6 ZWRTY3JpcHRWYWx1ZS5oPgogI2luY2x1ZGUgPFdlYktpdDIvV2ViS2l0Mi5oPgogI2luY2x1ZGUg PGdsaWIuaD4KICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCBhZjc5OTM1Li42 M2Y5ZjkxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJWaWV3LmNwcApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdQ cml2YXRlLmgiCiAjaW5jbHVkZSAiV2ViS2l0V2luZG93UHJvcGVydGllc1ByaXZhdGUuaCIKICNp bmNsdWRlICJXZWJQYWdlUHJveHkuaCIKKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9BUElDYXN0 Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9EcmFnSWNvbi5oPgogI2luY2x1ZGUgPFdlYkNvcmUvR3Rr VXRpbGl0aWVzLmg+CiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KQEAgLTEzMTUsNyArMTMx Niw2IEBAIGdkb3VibGUgd2Via2l0X3dlYl92aWV3X2dldF96b29tX2xldmVsKFdlYktpdFdlYlZp ZXcqIHdlYlZpZXcpCiAgICAgcmV0dXJuIFdLUGFnZUdldFBhZ2Vab29tRmFjdG9yKHdrUGFnZSk7 CiB9CiAKLQogc3RhdGljIHZvaWQgZGlkVmFsaWRhdGVDb21tYW5kKFdLU3RyaW5nUmVmIGNvbW1h bmQsIGJvb2wgaXNFbmFibGVkLCBpbnQzMl90IHN0YXRlLCBXS0Vycm9yUmVmLCB2b2lkKiBjb250 ZXh0KQogewogICAgIEdSZWZQdHI8R1NpbXBsZUFzeW5jUmVzdWx0PiByZXN1bHQgPSBhZG9wdEdS ZWYoR19TSU1QTEVfQVNZTkNfUkVTVUxUKGNvbnRleHQpKTsKQEAgLTEzODgsMyArMTM4OCwxMTQg QEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfZXhlY3V0ZV9lZGl0aW5nX2NvbW1hbmQoV2ViS2l0V2Vi Vmlldyogd2ViVmlldywgY29uc3QgY2hhcioKICAgICBXS1JldGFpblB0cjxXS1N0cmluZ1JlZj4g d2tDb21tYW5kKEFkb3B0V0ssIFdLU3RyaW5nQ3JlYXRlV2l0aFVURjhDU3RyaW5nKGNvbW1hbmQp KTsKICAgICBXS1BhZ2VFeGVjdXRlQ29tbWFuZCh0b0FQSShwYWdlKSwgd2tDb21tYW5kLmdldCgp KTsKIH0KKworc3RhdGljIHZvaWQgd2Via2l0V2ViVmlld1J1bkphdmFTY3JpcHRDYWxsYmFjayhX S1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZVJlZiB3a1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZSwgV0tFcnJv clJlZiwgdm9pZCogY29udGV4dCkKK3sKKyAgICBHUmVmUHRyPEdTaW1wbGVBc3luY1Jlc3VsdD4g cmVzdWx0ID0gYWRvcHRHUmVmKEdfU0lNUExFX0FTWU5DX1JFU1VMVChjb250ZXh0KSk7CisgICAg SlNHbG9iYWxDb250ZXh0UmVmIHNjcmlwdENvbnRleHQgPSBKU0dsb2JhbENvbnRleHRDcmVhdGUo MCk7CisgICAgSlNWYWx1ZVJlZiBzY3JpcHRWYWx1ZSA9IFdLU2VyaWFsaXplZFNjcmlwdFZhbHVl RGVzZXJpYWxpemUod2tTZXJpYWxpemVkU2NyaXB0VmFsdWUsIHNjcmlwdENvbnRleHQsIDApOwor ICAgIGdfc2ltcGxlX2FzeW5jX3Jlc3VsdF9zZXRfb3BfcmVzX2dwb2ludGVyKHJlc3VsdC5nZXQo KSwgY29uc3RfY2FzdDxPcGFxdWVKU1ZhbHVlKj4oc2NyaXB0VmFsdWUpLCAwKTsKKyAgICBnX3Np bXBsZV9hc3luY19yZXN1bHRfY29tcGxldGUocmVzdWx0LmdldCgpKTsKKyAgICBKU0dsb2JhbENv bnRleHRSZWxlYXNlKHNjcmlwdENvbnRleHQpOworfQorCisvKioKKyAqIHdlYmtpdF93ZWJfdmll d19ydW5famF2YXNjcmlwdDoKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICogQHNj cmlwdDogdGhlIHNjcmlwdCB0byBydW4KKyAqIEBjYWxsYmFjazogKHNjb3BlIGFzeW5jKTogYSAj R0FzeW5jUmVhZHlDYWxsYmFjayB0byBjYWxsIHdoZW4gdGhlIHNjcmlwdCBmaW5pc2hlZAorICog QHVzZXJfZGF0YTogKGNsb3N1cmUpOiB0aGUgZGF0YSB0byBwYXNzIHRvIGNhbGxiYWNrIGZ1bmN0 aW9uCisgKgorICogQXN5bmNocm9ub3VzbHkgcnVuIEBzY3JpcHQgaW4gdGhlIGNvbnRleHQgb2Yg dGhlIGN1cnJlbnQgcGFnZSBpbiBAd2ViX3ZpZXcuCisgKgorICogV2hlbiB0aGUgb3BlcmF0aW9u IGlzIGZpbmlzaGVkLCBAY2FsbGJhY2sgd2lsbCBiZSBjYWxsZWQuIFlvdSBjYW4gdGhlbiBjYWxs CisgKiB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHRfZmluaXNoKCkgdG8gZ2V0IHRoZSBy ZXN1bHQgb2YgdGhlIG9wZXJhdGlvbi4KKyAqLwordm9pZCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2ph dmFzY3JpcHQoV2ViS2l0V2ViVmlldyogd2ViVmlldywgY29uc3QgZ2NoYXIqIHNjcmlwdCwgR0Fz eW5jUmVhZHlDYWxsYmFjayBjYWxsYmFjaywgZ3BvaW50ZXIgdXNlckRhdGEpCit7CisgICAgZ19y ZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldykpOworICAgIGdfcmV0dXJu X2lmX2ZhaWwoc2NyaXB0KTsKKworICAgIFdLUGFnZVJlZiB3a1BhZ2UgPSB0b0FQSSh3ZWJraXRX ZWJWaWV3QmFzZUdldFBhZ2UoV0VCS0lUX1dFQl9WSUVXX0JBU0Uod2ViVmlldykpKTsKKyAgICBX S1JldGFpblB0cjxXS1N0cmluZ1JlZj4gd2tTY3JpcHQgPSBhZG9wdFdLKFdLU3RyaW5nQ3JlYXRl V2l0aFVURjhDU3RyaW5nKHNjcmlwdCkpOworICAgIEdTaW1wbGVBc3luY1Jlc3VsdCogcmVzdWx0 ID0gZ19zaW1wbGVfYXN5bmNfcmVzdWx0X25ldyhHX09CSkVDVCh3ZWJWaWV3KSwgY2FsbGJhY2ss IHVzZXJEYXRhLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZWludGVycHJldF9jYXN0PGdwb2ludGVyPih3ZWJraXRfd2ViX3ZpZXdf cnVuX2phdmFzY3JpcHQpKTsKKyAgICBXS1BhZ2VSdW5KYXZhU2NyaXB0SW5NYWluRnJhbWUod2tQ YWdlLCB3a1NjcmlwdC5nZXQoKSwgcmVzdWx0LCB3ZWJraXRXZWJWaWV3UnVuSmF2YVNjcmlwdENh bGxiYWNrKTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHRfZmlu aXNoOgorICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKiBAcmVzdWx0OiBhICNHQXN5 bmNSZXN1bHQKKyAqIEBlcnJvcjogcmV0dXJuIGxvY2F0aW9uIGZvciBlcnJvciBvciAlTlVMTCB0 byBpZ25vcmUKKyAqCisgKiBGaW5pc2ggYW4gYXN5bmNocm9ub3VzIG9wZXJhdGlvbiBzdGFydGVk IHdpdGggd2Via2l0X3dlYl92aWV3X2Nhbl9leGVjdXRlX2VkaXRpbmdfY29tbWFuZCgpLgorICog VGhlIHJldHVybmVkIEpTVmFsdWVSZWYgaXMgYSB0ZW1wb3JhcnkgdmFsdWUgdGhhdCBzaG91bGQg YmUgY29uc3VtZWQgaW5tZWRpYXRlbHkuCisgKgorICogVGhpcyBpcyBhbiBleGFtcGxlIG9mIHVz aW5nIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCgpIHdpdGggYSBzY3JpcHQgcmV0dXJu aW5nCisgKiBhIHN0cmluZzoKKyAqCisgKiA8aW5mb3JtYWxleGFtcGxlPjxwcm9ncmFtbGlzdGlu Zz4KKyAqIHN0YXRpYyB2b2lkCisgKiB3ZWJfdmlld19qYXZhc2NyaXB0X2ZpbmlzaGVkIChHT2Jq ZWN0ICAgICAgKm9iamVjdCwKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdBc3lu Y1Jlc3VsdCAqcmVzdWx0LAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3BvaW50 ZXIgICAgICB1c2VyX2RhdGEpCisgKiB7CisgKiAgICAgSlNWYWx1ZVJlZiAgICAgICAgIHZhbHVl OworICogICAgIEpTR2xvYmFsQ29udGV4dFJlZiBjb250ZXh0OworICogICAgIEdFcnJvciAgICAg ICAgICAgICplcnJvciA9IE5VTEw7CisgKgorICogICAgIHZhbHVlID0gd2Via2l0X3dlYl92aWV3 X3J1bl9qYXZhc2NyaXB0X2ZpbmlzaCAoV0VCS0lUX1dFQl9WSUVXIChvYmplY3QpLCByZXN1bHQs ICZlcnJvcik7CisgKiAgICAgaWYgKCF2YWx1ZSkgeworICogICAgICAgICBnX3dhcm5pbmcgKCJF cnJvciBydW5uaW5nIGphdmFzY3JpcHQ6ICVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICogICAgICAg ICBnX2Vycm9yX2ZyZWUgKGVycm9yKTsKKyAqICAgICAgICAgcmV0dXJuOworICogICAgIH0KKyAq CisgKiAgICAgY29udGV4dCA9IEpTR2xvYmFsQ29udGV4dENyZWF0ZSAoTlVMTCk7CisgKiAgICAg aWYgKEpTVmFsdWVJc1N0cmluZyAoY29udGV4dCwgdmFsdWUpKSB7CisgKiAgICAgICAgIEpTU3Ry aW5nUmVmICpqc19zdHJfdmFsdWU7CisgKiAgICAgICAgIGdjaGFyICAgICAgICpzdHJfdmFsdWU7 CisgKiAgICAgICAgIGdzaXplICAgICAgICBzdHJfbGVuZ3RoOworICoKKyAqICAgICAgICAganNf c3RyX3ZhbHVlID0gSlNWYWx1ZVRvU3RyaW5nQ29weSAoY29udGV4dCwgdmFsdWUsIE5VTEwpKTsK KyAqICAgICAgICAgc3RyX2xlbmd0aCA9IEpTU3RyaW5nR2V0TWF4aW11bVVURjhDU3RyaW5nU2l6 ZSAoanNfc3RyX3ZhbHVlKTsKKyAqICAgICAgICAgc3RyX3ZhbHVlID0gKGdjaGFyICopZ19tYWxs b2MgKHN0cl9sZW5ndGgpKTsKKyAqICAgICAgICAgSlNTdHJpbmdHZXRVVEY4Q1N0cmluZyAoanNf c3RyX3ZhbHVlLCBzdHJfdmFsdWUsIHN0cl9sZW5ndGgpOworICogICAgICAgICBKU1N0cmluZ1Jl bGVhc2UgKGpzX3N0cl92YWx1ZSk7CisgKiAgICAgICAgIGdfcHJpbnQgKCJTY3JpcHQgcmVzdWx0 OiAlc1xuIiwgc3RyX3ZhbHVlKTsKKyAqICAgICAgICAgZ19mcmVlIChzdHJfdmFsdWUpOworICog ICAgIH0gZWxzZSB7CisgKiAgICAgICAgIGdfd2FybmluZyAoIkVycm9yIHJ1bm5pbmcgamF2YXNj cmlwdDogdW5leHBlY3RlZCByZXR1cm4gdmFsdWUiKTsKKyAqICAgICB9CisgKiAgICAgSlNHbG9i YWxDb250ZXh0UmVsZWFzZSAoY29udGV4dCk7CisgKiB9CisgKgorICogc3RhdGljIHZvaWQKKyAq IHdlYl92aWV3X2dldF9saW5rX3VybCAoV2ViS2l0V2ViVmlldyAqd2ViX3ZpZXcsCisgKiAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IGdjaGFyICAgKmxpbmtfaWQpCisgKiB7CisgKiAgICAg Z2NoYXIgKnNjcmlwdDsKKyAqCisgKiAgICAgc2NyaXB0ID0gZ19zdHJkdXBfcHJpbnRmICgid2lu ZG93LmRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCclcycpLmhyZWY7IiwgbGlua19pZCk7CisgKiAg ICAgd2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0ICh3ZWJfdmlldywgc2NyaXB0LCB3ZWJf dmlld19qYXZhc2NyaXB0X2ZpbmlzaGVkLCBOVUxMKTsKKyAqICAgICBnX2ZyZWUgKHNjcmlwdCk7 CisgKiB9CisgKiA8L3Byb2dyYW1saXN0aW5nPjwvaW5mb3JtYWxleGFtcGxlPgorICoKKyAqIFJl dHVybnM6IGEgSlNWYWx1ZVJlZiB3aXRoIHRoZSB2YWx1ZSBvZiB0aGUgbGFzdCBleGVjdXRlZCBz dGF0ZW1lbnQgaW4gQHNjcmlwdAorICogICAgb3IgJU5VTEwgaW4gY2FzZSBvZiBlcnJvcgorICov CitKU1ZhbHVlUmVmIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdF9maW5pc2goV2ViS2l0 V2ViVmlldyogd2ViVmlldywgR0FzeW5jUmVzdWx0KiByZXN1bHQsIEdFcnJvcioqIGVycm9yKQor eworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSwg MCk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoR19JU19BU1lOQ19SRVNVTFQocmVzdWx0KSwg MCk7CisKKyAgICBHU2ltcGxlQXN5bmNSZXN1bHQqIHNpbXBsZVJlc3VsdCA9IEdfU0lNUExFX0FT WU5DX1JFU1VMVChyZXN1bHQpOworICAgIGdfd2Fybl9pZl9mYWlsKGdfc2ltcGxlX2FzeW5jX3Jl c3VsdF9nZXRfc291cmNlX3RhZyhzaW1wbGVSZXN1bHQpID09IHdlYmtpdF93ZWJfdmlld19ydW5f amF2YXNjcmlwdCk7CisKKyAgICBpZiAoZ19zaW1wbGVfYXN5bmNfcmVzdWx0X3Byb3BhZ2F0ZV9l cnJvcihzaW1wbGVSZXN1bHQsIGVycm9yKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1 cm4gc3RhdGljX2Nhc3Q8SlNWYWx1ZVJlZj4oZ19zaW1wbGVfYXN5bmNfcmVzdWx0X2dldF9vcF9y ZXNfZ3BvaW50ZXIoc2ltcGxlUmVzdWx0KSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmgKaW5kZXggMDA4MWJlMy4uMjdjMmQxNCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5o CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaApA QCAtMjgsNiArMjgsNyBAQAogI2lmbmRlZiBXZWJLaXRXZWJWaWV3X2gKICNkZWZpbmUgV2ViS2l0 V2ViVmlld19oCiAKKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0Jhc2UuaD4KICNpbmNsdWRl IDx3ZWJraXQyL1dlYktpdEJhY2tGb3J3YXJkTGlzdC5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2Vi S2l0RGVmaW5lcy5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0SGl0VGVzdFJlc3VsdC5oPgpA QCAtMjYzLDYgKzI2NCwxNyBAQCB3ZWJraXRfd2ViX3ZpZXdfY2FuX2V4ZWN1dGVfZWRpdGluZ19j b21tYW5kX2ZpbmlzaCAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqdwogV0VCS0lUX0FQSSB2 b2lkCiB3ZWJraXRfd2ViX3ZpZXdfZXhlY3V0ZV9lZGl0aW5nX2NvbW1hbmQgICAgICAgICAgICAo V2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgZ2NoYXIgICAgICAgICAgICAg ICAqY29tbWFuZCk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl92aWV3X3J1bl9qYXZh c2NyaXB0ICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICAgICAgKndl Yl92aWV3LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnN0IGdjaGFyICAgICAgICAgICAgICAgKnNjcmlwdCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHQXN5bmNSZWFkeUNhbGxiYWNrICAg ICAgICBjYWxsYmFjaywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBncG9pbnRlciAgICAgICAgICAgICAgICAgICB1c2VyX2RhdGEpOworV0VCS0lU X0FQSSBKU1ZhbHVlUmVmCit3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHRfZmluaXNoICAg ICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0FzeW5jUmVzdWx0 ICAgICAgICAgICAgICAqcmVzdWx0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIEdFcnJvciAgICAgICAgICAgICAgICAgICAqKmVycm9yKTsKKwog R19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0IGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dAppbmRleCA1MGM0 MmRiLi4wYmI0YmM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKQEAgLTg2LDYgKzg2LDgg QEAgd2Via2l0X3dlYl92aWV3X2dldF96b29tX2xldmVsCiB3ZWJraXRfd2ViX3ZpZXdfY2FuX2V4 ZWN1dGVfZWRpdGluZ19jb21tYW5kCiB3ZWJraXRfd2ViX3ZpZXdfY2FuX2V4ZWN1dGVfZWRpdGlu Z19jb21tYW5kX2ZpbmlzaAogd2Via2l0X3dlYl92aWV3X2V4ZWN1dGVfZWRpdGluZ19jb21tYW5k Cit3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQKK3dlYmtpdF93ZWJfdmlld19ydW5famF2 YXNjcmlwdF9maW5pc2gKIAogPFNVQlNFQ1RJT04gU3RhbmRhcmQ+CiBXZWJLaXRXZWJWaWV3Q2xh c3MKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL0dO VW1ha2VmaWxlLmFtIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvR05V bWFrZWZpbGUuYW0KaW5kZXggNzI0MWI5OS4uY2JlZmFjMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvR05VbWFrZWZpbGUuYW0KKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvR05VbWFrZWZpbGUuYW0KQEAgLTUzLDYg KzUzLDggQEAgTGlicmFyaWVzX2xpYldlYktpdDJBUElUZXN0Q29yZV9sYV9TT1VSQ0VTID0gXAog CVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYktpdFRlc3RTZXJ2ZXIu aCBcCiAJU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdE1haW4uY3Bw IFwKIAlTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0TWFpbi5oIFwK KwlTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9TY3JpcHRDb250ZXh0LmNw cCBcCisJU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvU2NyaXB0Q29udGV4 dC5oIFwKIAlTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVz dC5jcHAgXAogCVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdU ZXN0LmgKIExpYnJhcmllc19saWJXZWJLaXQyQVBJVGVzdENvcmVfbGFfQ1BQRkxBR1MgPSAkKHdl YmtpdDJfdGVzdHNfY3BwZmxhZ3MpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay90ZXN0cy9TY3JpcHRDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL3Rlc3RzL1NjcmlwdENvbnRleHQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjA1MTM1OTcKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9TY3JpcHRDb250ZXh0LmNwcApAQCAtMCwwICsxLDQ5 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIElnYWxpYSBTLkwuCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgor ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v ciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJTY3JpcHRDb250ZXh0LmgiCisKKyNpbmNsdWRlIDxKYXZhU2NyaXB0 Q29yZS9KU1JldGFpblB0ci5oPgorI2luY2x1ZGUgPGdsaWIuaD4KKworU2NyaXB0Q29udGV4dDo6 U2NyaXB0Q29udGV4dCgpCisgICAgOiBtX2NvbnRleHQoSlNHbG9iYWxDb250ZXh0Q3JlYXRlKDAp KQoreworfQorCitTY3JpcHRDb250ZXh0Ojp+U2NyaXB0Q29udGV4dCgpCit7CisgICAgSlNHbG9i YWxDb250ZXh0UmVsZWFzZShtX2NvbnRleHQpOworfQorCitjaGFyKiBTY3JpcHRDb250ZXh0Ojpq c1ZhbHVlVG9DU3RyaW5nKEpTVmFsdWVSZWYgdmFsdWUpCit7CisgICAgZ19hc3NlcnQoSlNWYWx1 ZUlzU3RyaW5nKG1fY29udGV4dCwgdmFsdWUpKTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5n UmVmPiBzdHJpbmdWYWx1ZShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShtX2NvbnRleHQsIHZh bHVlLCAwKSk7CisgICAgZ19hc3NlcnQoc3RyaW5nVmFsdWUpOworCisgICAgc2l6ZV90IGNTdHJp bmdMZW5ndGggPSBKU1N0cmluZ0dldE1heGltdW1VVEY4Q1N0cmluZ1NpemUoc3RyaW5nVmFsdWUu Z2V0KCkpOworICAgIGNoYXIqIGNTdHJpbmcgPSBzdGF0aWNfY2FzdDxjaGFyKj4oZ19tYWxsb2Mo Y1N0cmluZ0xlbmd0aCkpOworICAgIEpTU3RyaW5nR2V0VVRGOENTdHJpbmcoc3RyaW5nVmFsdWUu Z2V0KCksIGNTdHJpbmcsIGNTdHJpbmdMZW5ndGgpOworCisgICAgcmV0dXJuIGNTdHJpbmc7Cit9 CisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Nj cmlwdENvbnRleHQuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Nj cmlwdENvbnRleHQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMjg5NjQw Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVz dHMvU2NyaXB0Q29udGV4dC5oCkBAIC0wLDAgKzEsMzYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTIgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIu ICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu LCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0x MzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBTY3JpcHRDb250ZXh0X2gKKyNkZWZpbmUgU2NyaXB0 Q29udGV4dF9oCisKKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0NvbnRleHRSZWYuaD4KKwor Y2xhc3MgU2NyaXB0Q29udGV4dCB7CitwdWJsaWM6CisgICAgU2NyaXB0Q29udGV4dCgpOworICAg IH5TY3JpcHRDb250ZXh0KCk7CisKKyAgICBjaGFyKiBqc1ZhbHVlVG9DU3RyaW5nKEpTVmFsdWVS ZWYpOworCitwcml2YXRlOgorICAgIEpTR2xvYmFsQ29udGV4dFJlZiBtX2NvbnRleHQ7Cit9Owor CisjZW5kaWYgLy8gU2NyaXB0Q29udGV4dF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViS2l0V2ViVmlldy5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9UZXN0V2ViS2l0V2ViVmlldy5jcHAKaW5kZXgg NDdkYTk4ZS4uNDE2M2E0OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvdGVzdHMvVGVzdFdlYktpdFdlYlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcApAQCAtMTgsNiArMTgs NyBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTY3JpcHRDb250ZXh0 LmgiCiAjaW5jbHVkZSAiV2ViVmlld1Rlc3QuaCIKICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgog I2luY2x1ZGUgPHd0Zi9nb2JqZWN0L0dSZWZQdHIuaD4KQEAgLTQ0OSw2ICs0NTAsMzYgQEAgc3Rh dGljIHZvaWQgdGVzdFdlYlZpZXdab29tTGV2ZWwoV2ViVmlld1Rlc3QqIHRlc3QsIGdjb25zdHBv aW50ZXIpCiAgICAgZ19hc3NlcnRfY21wZmxvYXQod2Via2l0X3dlYl92aWV3X2dldF96b29tX2xl dmVsKHRlc3QtPm1fd2ViVmlldyksID09LCAyLjUpOwogfQogCitzdHJ1Y3QgSmF2YXNjcmlwdENh bGxiYWNrRGF0YSB7CisgICAgU2NyaXB0Q29udGV4dCBjb250ZXh0OworICAgIGNvbnN0IGNoYXIq IGV4cGVjdGVkUmVzdWx0OworfTsKKworc3RhdGljIHZvaWQgdGVzdFdlYlZpZXdSdW5KYXZhU2Ny aXB0RmluaXNoZWRDYWxsYmFjayhKU1ZhbHVlUmVmIHZhbHVlLCB2b2lkKiB1c2VyRGF0YSkKK3sK KyAgICBKYXZhc2NyaXB0Q2FsbGJhY2tEYXRhKiBkYXRhID0gc3RhdGljX2Nhc3Q8SmF2YXNjcmlw dENhbGxiYWNrRGF0YSo+KHVzZXJEYXRhKTsKKyAgICBHT3duUHRyPGNoYXI+IHZhbHVlU3RyaW5n KGRhdGEtPmNvbnRleHQuanNWYWx1ZVRvQ1N0cmluZyh2YWx1ZSkpOworICAgIGdfYXNzZXJ0X2Nt cHN0cih2YWx1ZVN0cmluZy5nZXQoKSwgPT0sIGRhdGEtPmV4cGVjdGVkUmVzdWx0KTsKK30KKwor c3RhdGljIHZvaWQgdGVzdFdlYlZpZXdSdW5KYXZhU2NyaXB0KFdlYlZpZXdUZXN0KiB0ZXN0LCBn Y29uc3Rwb2ludGVyKQoreworICAgIHN0YXRpYyBjb25zdCBjaGFyKiBodG1sID0gIjxodG1sPjxi b2R5PjxhIGlkPSdXZWJLaXRMaW5rJyBocmVmPSdodHRwOi8vd3d3LndlYmtpdGd0ay5vcmcvJyB0 aXRsZT0nV2ViS2l0R1RLKyBUaXRsZSc+V2ViS2l0R1RLKyBXZWJzaXRlPC9hPjwvYm9keT48L2h0 bWw+IjsKKyAgICB0ZXN0LT5sb2FkSHRtbChodG1sLCAwKTsKKyAgICB0ZXN0LT53YWl0VW50aWxM b2FkRmluaXNoZWQoKTsKKworICAgIEphdmFzY3JpcHRDYWxsYmFja0RhdGEgY2FsbGJhY2tEYXRh OworCisgICAgY2FsbGJhY2tEYXRhLmV4cGVjdGVkUmVzdWx0ID0gIldlYktpdEdUSysgVGl0bGUi OworICAgIHRlc3QtPnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxGaW5pc2hlZCgid2luZG93LmRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCdXZWJLaXRMaW5rJykudGl0bGU7IiwgdGVzdFdlYlZpZXdS dW5KYXZhU2NyaXB0RmluaXNoZWRDYWxsYmFjaywgJmNhbGxiYWNrRGF0YSk7CisKKyAgICBjYWxs YmFja0RhdGEuZXhwZWN0ZWRSZXN1bHQgPSAiaHR0cDovL3d3dy53ZWJraXRndGsub3JnLyI7Cisg ICAgdGVzdC0+cnVuSmF2YVNjcmlwdEFuZFdhaXRVbnRpbEZpbmlzaGVkKCJ3aW5kb3cuZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoJ1dlYktpdExpbmsnKS5ocmVmOyIsIHRlc3RXZWJWaWV3UnVuSmF2 YVNjcmlwdEZpbmlzaGVkQ2FsbGJhY2ssICZjYWxsYmFja0RhdGEpOworCisgICAgY2FsbGJhY2tE YXRhLmV4cGVjdGVkUmVzdWx0ID0gIldlYktpdEdUSysgV2Vic2l0ZSI7CisgICAgdGVzdC0+cnVu SmF2YVNjcmlwdEFuZFdhaXRVbnRpbEZpbmlzaGVkKCJ3aW5kb3cuZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoJ1dlYktpdExpbmsnKS50ZXh0Q29udGVudCIsIHRlc3RXZWJWaWV3UnVuSmF2YVNjcmlw dEZpbmlzaGVkQ2FsbGJhY2ssICZjYWxsYmFja0RhdGEpOworfQorCiB2b2lkIGJlZm9yZUFsbCgp CiB7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgiV2ViS2l0V2ViVmlldyIsICJkZWZhdWx0LWNvbnRl eHQiLCB0ZXN0V2ViVmlld0RlZmF1bHRDb250ZXh0KTsKQEAgLTQ2MCw2ICs0OTEsNyBAQCB2b2lk IGJlZm9yZUFsbCgpCiAgICAgVUlDbGllbnRUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAid2lu ZG93LXByb3BlcnRpZXMiLCB0ZXN0V2ViVmlld1dpbmRvd1Byb3BlcnRpZXMpOwogICAgIFVJQ2xp ZW50VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgIm1vdXNlLXRhcmdldCIsIHRlc3RXZWJWaWV3 TW91c2VUYXJnZXQpOwogICAgIFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAiem9v bS1sZXZlbCIsIHRlc3RXZWJWaWV3Wm9vbUxldmVsKTsKKyAgICBXZWJWaWV3VGVzdDo6YWRkKCJX ZWJLaXRXZWJWaWV3IiwgInJ1bi1qYXZhc2NyaXB0IiwgdGVzdFdlYlZpZXdSdW5KYXZhU2NyaXB0 KTsKIH0KIAogdm9pZCBhZnRlckFsbCgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVzdC5jcHAKaW5kZXggMDBkM2IzZS4uZjg4YjI3 YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvV2Vi Vmlld1Rlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3Rz L1dlYlZpZXdUZXN0LmNwcApAQCAtMTgwLDMgKzE4MCwyNCBAQCB2b2lkIFdlYlZpZXdUZXN0Ojpt b3VzZU1vdmVUbyhpbnQgeCwgaW50IHksIHVuc2lnbmVkIGludCBtb3VzZU1vZGlmaWVycykKICAg ICBndGtfbWFpbl9kb19ldmVudChldmVudC5nZXQoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIHJ1bkph dmFTY3JpcHRSZWFkeUNhbGxiYWNrKEdPYmplY3QqLCBHQXN5bmNSZXN1bHQqIHJlc3VsdCwgV2Vi Vmlld1Rlc3QqIHRlc3QpCit7CisgICAgR093blB0cjxHRXJyb3I+IGVycm9yOworICAgIEpTVmFs dWVSZWYgdmFsdWUgPSB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHRfZmluaXNoKHRlc3Qt Pm1fd2ViVmlldywgcmVzdWx0LCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGdfYXNzZXJ0KCFlcnJv cik7CisKKyAgICB0ZXN0LT5tX2pzRmluaXNoZWRDYWxsYmFjayh2YWx1ZSwgdGVzdC0+bV9qc0Zp bmlzaGVkQ2FsbGJhY2tEYXRhKTsKKyAgICBnX21haW5fbG9vcF9xdWl0KHRlc3QtPm1fbWFpbkxv b3ApOworfQorCisKK3ZvaWQgV2ViVmlld1Rlc3Q6OnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxG aW5pc2hlZChjb25zdCBjaGFyKiBqcywgSmF2YXNjcmlwdEZpbmlzaGVkQ2FsbGJhY2sgY2FsbGJh Y2ssIHZvaWQqIHVzZXJEYXRhKQoreworICAgIG1fanNGaW5pc2hlZENhbGxiYWNrID0gY2FsbGJh Y2s7CisgICAgbV9qc0ZpbmlzaGVkQ2FsbGJhY2tEYXRhID0gdXNlckRhdGE7CisgICAgd2Via2l0 X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0KG1fd2ViVmlldywganMsIHJlaW50ZXJwcmV0X2Nhc3Q8 R0FzeW5jUmVhZHlDYWxsYmFjaz4ocnVuSmF2YVNjcmlwdFJlYWR5Q2FsbGJhY2spLCB0aGlzKTsK KyAgICBnX21haW5fbG9vcF9ydW4obV9tYWluTG9vcCk7CisgICAgbV9qc0ZpbmlzaGVkQ2FsbGJh Y2sgPSAwOworICAgIG1fanNGaW5pc2hlZENhbGxiYWNrRGF0YSA9IDA7Cit9CisKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0Lmgg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVzdC5oCmlu ZGV4IDk1YTU2OWMuLmZjZjZmZTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmlld1Rlc3QuaApAQCAtMjgsNiArMjgsOSBAQAogY2xhc3Mg V2ViVmlld1Rlc3Q6IHB1YmxpYyBUZXN0IHsKIHB1YmxpYzoKICAgICBNQUtFX0dMSUJfVEVTVF9G SVhUVVJFKFdlYlZpZXdUZXN0KTsKKworICAgIHR5cGVkZWYgdm9pZCAoKkphdmFzY3JpcHRGaW5p c2hlZENhbGxiYWNrKSAoSlNWYWx1ZVJlZiwgdm9pZCogdXNlckRhdGEpOworCiAgICAgV2ViVmll d1Rlc3QoKTsKICAgICB2aXJ0dWFsIH5XZWJWaWV3VGVzdCgpOwogCkBAIC00NiwxMCArNDksMTQg QEAgcHVibGljOgogCiAgICAgdm9pZCBtb3VzZU1vdmVUbyhpbnQgeCwgaW50IHksIHVuc2lnbmVk IGludCBtb3VzZU1vZGlmaWVycyA9IDApOwogCisgICAgdm9pZCBydW5KYXZhU2NyaXB0QW5kV2Fp dFVudGlsRmluaXNoZWQoY29uc3QgY2hhcioganMsIEphdmFzY3JpcHRGaW5pc2hlZENhbGxiYWNr LCB2b2lkKiB1c2VyRGF0YSk7CisKICAgICBXZWJLaXRXZWJWaWV3KiBtX3dlYlZpZXc7CiAgICAg R01haW5Mb29wKiBtX21haW5Mb29wOwogICAgIENTdHJpbmcgbV9hY3RpdmVVUkk7CiAgICAgR3Rr V2lkZ2V0KiBtX3BhcmVudFdpbmRvdzsKKyAgICBKYXZhc2NyaXB0RmluaXNoZWRDYWxsYmFjayBt X2pzRmluaXNoZWRDYWxsYmFjazsKKyAgICB2b2lkKiBtX2pzRmluaXNoZWRDYWxsYmFja0RhdGE7 CiB9OwogCiAjZW5kaWYgLy8gV2ViVmlld1Rlc3RfaApkaWZmIC0tZ2l0IGEvVG9vbHMvTWluaUJy b3dzZXIvZ3RrL0dOVW1ha2VmaWxlLmFtIGIvVG9vbHMvTWluaUJyb3dzZXIvZ3RrL0dOVW1ha2Vm aWxlLmFtCmluZGV4IDJhMDIwZjYuLmUyZjdmYzUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL01pbmlCcm93 c2VyL2d0ay9HTlVtYWtlZmlsZS5hbQorKysgYi9Ub29scy9NaW5pQnJvd3Nlci9ndGsvR05VbWFr ZWZpbGUuYW0KQEAgLTgsNiArOCw3IEBAIFByb2dyYW1zX01pbmlCcm93c2VyX0NQUEZMQUdTID0g XAogCS1JJCh0b3BfYnVpbGRkaXIpL0Rlcml2ZWRTb3VyY2VzL1dlYktpdDIvd2Via2l0Mmd0ay9p bmNsdWRlIFwKIAktRFdFQktJVF9FWEVDX1BBVEg9XCIke3NoZWxsIHB3ZH0vJCh0b3BfYnVpbGRk aXIpL1Byb2dyYW1zL1wiIFwKIAkkKGdsb2JhbF9jcHBmbGFncykgXAorCSQoamF2YXNjcmlwdGNv cmVfY3BwZmxhZ3MpIFwKIAkkKEdMSUJfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCg== 132244 2012-03-16 04:14:30 -0700 2012-03-16 09:07:25 -0700 New patch wk2-run-js2.diff text/plain 38258 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA5YTdiNTA1Li5jZjY4OTViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjAg QEAKKzIwMTItMDMtMTYgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtHVEtdIEFkZCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQoKSB0 byBXZWJLaXQyIEdUSysKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTc1NTQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgKiBHTlVtYWtlZmlsZS5hbTogQWRkIG5ldyBmaWxlcyB0byBjb21waWxhdGlvbi4KKyAg ICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRFcnJvci5jcHA6CisgICAgICAgICh3ZWJr aXRfamF2YXNjcmlwdF9lcnJvcl9xdWFyayk6IEFkZCBuZXcgZXJyb3IgZG9tYWluIGZvcgorICAg ICAgICBKYXZhc2NyaXB0IGVycm9ycy4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRFcnJvci5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEphdmFzY3JpcHRS ZXN1bHQuY3BwOiBBZGRlZC4KKyAgICAgICAgKHdlYmtpdEphdmFzY3JpcHRSZXN1bHRDcmVhdGUp OiBDcmVhdGUgYSBXZWJLaXRKYXZhc2NyaXB0UmVzdWx0CisgICAgICAgIGZvciB0aGUgZ2l2ZW4g V0tTZXJpYWxpemVkU2NyaXB0VmFsdWVSZWYuCisgICAgICAgICh3ZWJraXRfamF2YXNjcmlwdF9y ZXN1bHRfcmVmKTogSW5jcmVtZW50IHJlZmVyZW5jZSBjb3VudCBvZgorICAgICAgICBXZWJLaXRK YXZhc2NyaXB0UmVzdWx0LgorICAgICAgICAod2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3VucmVm KTogRGVjcmVtZW50IHJlZmVyZW5jZSBjb3VudCBvZgorICAgICAgICBXZWJLaXRKYXZhc2NyaXB0 UmVzdWx0LgorICAgICAgICAod2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9iYWxfY29u dGV4dCk6IEdldCBnbG9iYWwKKyAgICAgICAgamF2YXNjcmlwdCBjb250ZXh0IG9mIHRoZSByZXN1 bHQuCisgICAgICAgICh3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X3ZhbHVlKTogR2V0IHRo ZSBKU1ZhbHVlUmVmIG9mIHRoZQorICAgICAgICByZXN1bHQuCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0SmF2YXNjcmlwdFJlc3VsdC5oOiBBZGRlZC4KKyAgICAgICAgKiBVSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0UHJpdmF0ZS5oOiBBZGRlZC4KKyAg ICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRQcml2YXRlLmg6CisgICAgICAgICogVUlQ cm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHA6CisgICAgICAgICh3ZWJraXRXZWJWaWV3 RmluYWxpemUpOiBSZWxlYXNlIHRoZSBnbG9iYWwgamF2YXNjcmlwdCBjb250ZXh0LgorICAgICAg ICAod2Via2l0X3dlYl92aWV3X2dldF9qYXZhc2NyaXB0X2dsb2JhbF9jb250ZXh0KTogR2V0IG9y IGNyZWF0ZSB0aGUKKyAgICAgICAgZ2xvYmFsIGphdmFzY3JpcHQgY29udGV4dC4KKyAgICAgICAg KHdlYmtpdFdlYlZpZXdSdW5KYXZhU2NyaXB0Q2FsbGJhY2spOiBDYWxsYmFjayBjYWxsZWQgYnkg QyBBUEkgd2hlbgorICAgICAgICBqYXZhc2NyaXB0IGV4ZWN1dGlvbiBmaW5pc2hlcy4KKyAgICAg ICAgKHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCk6IEFzeW5jaHJvbm91c2x5IHJ1biBh IGdpdmVuCisgICAgICAgIGphdmFzY3JpcHQuCisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfcnVu X2phdmFzY3JpcHRfZmluaXNoKTogRmluaXNoIGFzeW5jIG9wZXJhdGlvbgorICAgICAgICBzdGFy dGVkIGJ5IHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCgpLgorICAgICAgICAqIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0 ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0OiBBZGQgbmV3IHN5bWJvbHMuCisgICAgICAg ICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLnR5cGVzOiBBZGQKKyAgICAgICAg d2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF90eXBlKCkuCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFdlYlZpZXcuY3BwOgorICAgICAgICAodGVzdFdlYlZp ZXdSdW5KYXZhU2NyaXB0KToKKyAgICAgICAgKGJlZm9yZUFsbCk6CisgICAgICAgICogVUlQcm9j ZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmlld1Rlc3QuY3BwOgorICAgICAgICAoV2ViVmlld1Rlc3Q6 OldlYlZpZXdUZXN0KToKKyAgICAgICAgKFdlYlZpZXdUZXN0Ojp+V2ViVmlld1Rlc3QpOgorICAg ICAgICAocnVuSmF2YVNjcmlwdFJlYWR5Q2FsbGJhY2spOgorICAgICAgICAoV2ViVmlld1Rlc3Q6 OnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxGaW5pc2hlZCk6CisgICAgICAgIChqc1ZhbHVlVG9D U3RyaW5nKToKKyAgICAgICAgKFdlYlZpZXdUZXN0OjpqYXZhc2NyaXB0UmVzdWx0VG9DU3RyaW5n KToKKyAgICAgICAgKFdlYlZpZXdUZXN0OjpqYXZhc2NyaXB0UmVzdWx0VG9OdW1iZXIpOgorICAg ICAgICAoV2ViVmlld1Rlc3Q6OmphdmFzY3JpcHRSZXN1bHRUb0Jvb2xlYW4pOgorICAgICAgICAo V2ViVmlld1Rlc3Q6OmphdmFzY3JpcHRSZXN1bHRJc051bGwpOgorICAgICAgICAoV2ViVmlld1Rl c3Q6OmphdmFzY3JpcHRSZXN1bHRJc1VuZGVmaW5lZCk6CisgICAgICAgICogVUlQcm9jZXNzL0FQ SS9ndGsvdGVzdHMvV2ViVmlld1Rlc3QuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay93 ZWJraXQyLmg6CisKIDIwMTItMDMtMTUgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxl LmNvbT4KIAogICAgICAgICBUcnkgdG8gZml4IHRoZSBTbm93IExlb3BhcmQgYnVpbGQuCmRpZmYg LS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggODM3MjIzNi4u YTJhMjljMyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDEzIEBACisyMDEyLTAzLTE2ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNn YXJjaWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBBZGQgd2Via2l0X3dlYl92aWV3X3J1 bl9qYXZhc2NyaXB0KCkgdG8gV2ViS2l0MiBHVEsrCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NTU0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogTWluaUJyb3dzZXIvZ3RrL0dOVW1ha2VmaWxlLmFtOiBB ZGQgamF2YXNjcmlwdGNvcmVfY3BwZmxhZ3MgdG8KKyAgICAgICAgTWluaUJyb3dzZXIgQ1BQIGZs YWdzLgorCiAyMDEyLTAzLTE1ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAg ICAgICBNb3ZlIHBhcnNlX2J1Z19pZCBpbnRvIGNvbmZpZy91cmxzIGluIHByZXBhcmF0aW9uIGZv ciByZS11c2UgZWxzZXdoZXJlLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvR05VbWFrZWZp bGUuYW0gYi9Tb3VyY2UvV2ViS2l0Mi9HTlVtYWtlZmlsZS5hbQppbmRleCBhNjAxYWVmLi4zZDhl MzA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9HTlVtYWtlZmlsZS5hbQorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9HTlVtYWtlZmlsZS5hbQpAQCAtOTIsNiArOTIsNyBAQCBsaWJ3ZWJraXQyZ3Rr aW5jbHVkZV9IRUFERVJTID0gXAogCSQoV2ViS2l0MikvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 RXJyb3IuaCBcCiAJJChXZWJLaXQyKS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRGaW5kQ29udHJv bGxlci5oIFwKIAkkKFdlYktpdDIpL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEhpdFRlc3RSZXN1 bHQuaCBcCisJJChXZWJLaXQyKS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVz dWx0LmggXAogCSQoV2ViS2l0MikvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0TmF2aWdhdGlvblBv bGljeURlY2lzaW9uLmggXAogCSQoV2ViS2l0MikvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0UG9s aWN5RGVjaXNpb24uaCBcCiAJJChXZWJLaXQyKS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRQcmlu dE9wZXJhdGlvbi5oIFwKQEAgLTU1NSw2ICs1NTYsOSBAQCB3ZWJraXQyX3NvdXJjZXMgKz0gXAog CVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEhpdFRlc3RSZXN1bHQuY3Bw IFwKIAlTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRIaXRUZXN0UmVzdWx0 LmggXAogCVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEhpdFRlc3RSZXN1 bHRQcml2YXRlLmggXAorCVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEph dmFzY3JpcHRSZXN1bHQuY3BwIFwKKwlTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRKYXZhc2NyaXB0UmVzdWx0LmggXAorCVNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdEphdmFzY3JpcHRSZXN1bHRQcml2YXRlLmggXAogCVNvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdExvYWRlckNsaWVudC5oIFwKIAlTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRMb2FkZXJDbGllbnQuY3BwIFwKIAlTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRGaW5kQ29udHJvbGxlci5oIFwKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEVycm9yLmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEVycm9yLmNwcAppbmRleCAzMGFlNjg0 Li5kYWYwOWVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRFcnJvci5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0RXJyb3IuY3BwCkBAIC03NywzICs3Nyw4IEBAIEdRdWFyayB3ZWJraXRfcHJpbnRfZXJyb3Jf cXVhcmsoKQogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXRUJLSVRfUFJJTlRfRVJST1Jf R0VORVJBTCwgUHJpbnRFcnJvckdlbmVyYWwpOwogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5V TShXRUJLSVRfUFJJTlRfRVJST1JfUFJJTlRFUl9OT1RfRk9VTkQsIFByaW50RXJyb3JQcmludGVy Tm90Rm91bmQpOwogQ09NUElMRV9BU1NFUlRfTUFUQ0hJTkdfRU5VTShXRUJLSVRfUFJJTlRfRVJS T1JfSU5WQUxJRF9QQUdFX1JBTkdFLCBQcmludEVycm9ySW52YWxpZFBhZ2VSYW5nZSk7CisKK0dR dWFyayB3ZWJraXRfamF2YXNjcmlwdF9lcnJvcl9xdWFyaygpCit7CisgICAgcmV0dXJuIGdfcXVh cmtfZnJvbV9zdGF0aWNfc3RyaW5nKCJXZWJLaXRKYXZhc2NyaXB0RXJyb3IiKTsKK30KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEVycm9yLmggYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRFcnJvci5oCmluZGV4IDA3M2M0 MWQuLmMyMDU4MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdEVycm9yLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0RXJyb3IuaApAQCAtMjksMTEgKzI5LDEyIEBACiAKIEdfQkVHSU5fREVDTFMKIAotI2RlZmlu ZSBXRUJLSVRfTkVUV09SS19FUlJPUiAgd2Via2l0X25ldHdvcmtfZXJyb3JfcXVhcmsgKCkKLSNk ZWZpbmUgV0VCS0lUX1BPTElDWV9FUlJPUiAgIHdlYmtpdF9wb2xpY3lfZXJyb3JfcXVhcmsgKCkK LSNkZWZpbmUgV0VCS0lUX1BMVUdJTl9FUlJPUiAgIHdlYmtpdF9wbHVnaW5fZXJyb3JfcXVhcmsg KCkKLSNkZWZpbmUgV0VCS0lUX0RPV05MT0FEX0VSUk9SIHdlYmtpdF9kb3dubG9hZF9lcnJvcl9x dWFyayAoKQotI2RlZmluZSBXRUJLSVRfUFJJTlRfRVJST1IgICAgd2Via2l0X3ByaW50X2Vycm9y X3F1YXJrICgpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX0VSUk9SICAgIHdlYmtpdF9uZXR3b3Jr X2Vycm9yX3F1YXJrICgpCisjZGVmaW5lIFdFQktJVF9QT0xJQ1lfRVJST1IgICAgIHdlYmtpdF9w b2xpY3lfZXJyb3JfcXVhcmsgKCkKKyNkZWZpbmUgV0VCS0lUX1BMVUdJTl9FUlJPUiAgICAgd2Vi a2l0X3BsdWdpbl9lcnJvcl9xdWFyayAoKQorI2RlZmluZSBXRUJLSVRfRE9XTkxPQURfRVJST1Ig ICB3ZWJraXRfZG93bmxvYWRfZXJyb3JfcXVhcmsgKCkKKyNkZWZpbmUgV0VCS0lUX1BSSU5UX0VS Uk9SICAgICAgd2Via2l0X3ByaW50X2Vycm9yX3F1YXJrICgpCisjZGVmaW5lIFdFQktJVF9KQVZB U0NSSVBUX0VSUk9SIHdlYmtpdF9wcmludF9lcnJvcl9xdWFyayAoKQogCiAvKioKICAqIFdlYktp dE5ldHdvcmtFcnJvcjoKQEAgLTExOSwyMCArMTIwLDMzIEBAIHR5cGVkZWYgZW51bSB7CiAgICAg V0VCS0lUX1BSSU5UX0VSUk9SX0lOVkFMSURfUEFHRV9SQU5HRSA9IDUwMQogfSBXZWJLaXRQcmlu dEVycm9yOwogCisvKioKKyAqIFdlYktpdEphdmFzY3JpcHRFcnJvcjoKKyAqIEBXRUJLSVRfSkFW QVNDUklQVF9FUlJPUl9TQ1JJUFRfRkFJTEVEOiBBbiBleGNlcHRpb24gd2FzIHJhaXNlZCBpbiBK YXZhc2NyaXB0IGV4ZWN1dGlvbgorICoKKyAqIEVudW0gdmFsdWVzIHVzZWQgdG8gZGVub3RlIGVy cm9ycyBoYXBwZW5kaW5nIHdoZW4gZXhlY3V0aW5nIEphdmFzY3JpcHQKKyAqLwordHlwZWRlZiBl bnVtIHsKKyAgICBXRUJLSVRfSkFWQVNDUklQVF9FUlJPUl9TQ1JJUFRfRkFJTEVEID0gNjk5Cit9 IFdlYktpdEphdmFzY3JpcHRFcnJvcjsKKworV0VCS0lUX0FQSSBHUXVhcmsKK3dlYmtpdF9uZXR3 b3JrX2Vycm9yX3F1YXJrICAgICh2b2lkKTsKKwogV0VCS0lUX0FQSSBHUXVhcmsKLXdlYmtpdF9u ZXR3b3JrX2Vycm9yX3F1YXJrICAodm9pZCk7Cit3ZWJraXRfcG9saWN5X2Vycm9yX3F1YXJrICAg ICAodm9pZCk7CiAKIFdFQktJVF9BUEkgR1F1YXJrCi13ZWJraXRfcG9saWN5X2Vycm9yX3F1YXJr ICAgKHZvaWQpOword2Via2l0X3BsdWdpbl9lcnJvcl9xdWFyayAgICAgKHZvaWQpOwogCiBXRUJL SVRfQVBJIEdRdWFyawotd2Via2l0X3BsdWdpbl9lcnJvcl9xdWFyayAgICh2b2lkKTsKK3dlYmtp dF9kb3dubG9hZF9lcnJvcl9xdWFyayAgICh2b2lkKTsKIAogV0VCS0lUX0FQSSBHUXVhcmsKLXdl YmtpdF9kb3dubG9hZF9lcnJvcl9xdWFyayAodm9pZCk7Cit3ZWJraXRfcHJpbnRfZXJyb3JfcXVh cmsgICAgICAodm9pZCk7CiAKIFdFQktJVF9BUEkgR1F1YXJrCi13ZWJraXRfcHJpbnRfZXJyb3Jf cXVhcmsgICAgKHZvaWQpOword2Via2l0X2phdmFzY3JpcHRfZXJyb3JfcXVhcmsgKHZvaWQpOwog CiBHX0VORF9ERUNMUwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdEphdmFzY3JpcHRSZXN1bHQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjg0YWQwNGQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0LmNwcApAQCAtMCwwICsx LDEwNyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBJZ2FsaWEgUy5MLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVy YWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlv dXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisg KiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJh cnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGgg Rmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiV2ViS2l0SmF2YXNjcmlwdFJlc3VsdC5oIgorCisjaW5jbHVk ZSAiV2ViS2l0SmF2YXNjcmlwdFJlc3VsdFByaXZhdGUuaCIKKyNpbmNsdWRlIDx3dGYvZ29iamVj dC9HUmVmUHRyLmg+CisKK3N0cnVjdCBfV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCB7CisgICAgX1dl YktpdEphdmFzY3JpcHRSZXN1bHQoV2ViS2l0V2ViVmlldyogdmlldywgV0tTZXJpYWxpemVkU2Ny aXB0VmFsdWVSZWYgd2tTZXJpYWxpemVkU2NyaXB0VmFsdWUpCisgICAgICAgIDogd2ViVmlldyh2 aWV3KQorICAgICAgICAsIHJlZmVyZW5jZUNvdW50KDEpCisgICAgICAgIHsKKyAgICAgICAgICAg IHZhbHVlID0gV0tTZXJpYWxpemVkU2NyaXB0VmFsdWVEZXNlcmlhbGl6ZSh3a1NlcmlhbGl6ZWRT Y3JpcHRWYWx1ZSwgd2Via2l0X3dlYl92aWV3X2dldF9qYXZhc2NyaXB0X2dsb2JhbF9jb250ZXh0 KHZpZXcpLCAwKTsKKyAgICAgICAgfQorCisgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3PiB3ZWJW aWV3OworICAgIEpTVmFsdWVSZWYgdmFsdWU7CisKKyAgICBpbnQgcmVmZXJlbmNlQ291bnQ7Cit9 OworCitHX0RFRklORV9CT1hFRF9UWVBFKFdlYktpdEphdmFzY3JpcHRSZXN1bHQsIHdlYmtpdF9q YXZhc2NyaXB0X3Jlc3VsdCwgd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3JlZiwgd2Via2l0X2ph dmFzY3JpcHRfcmVzdWx0X3VucmVmKQorCitXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KiB3ZWJraXRK YXZhc2NyaXB0UmVzdWx0Q3JlYXRlKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsIFdLU2VyaWFsaXpl ZFNjcmlwdFZhbHVlUmVmIHdrU2VyaWFsaXplZFNjcmlwdFZhbHVlKQoreworICAgIFdlYktpdEph dmFzY3JpcHRSZXN1bHQqIHJlc3VsdCA9IGdfc2xpY2VfbmV3KFdlYktpdEphdmFzY3JpcHRSZXN1 bHQpOworICAgIG5ldyAocmVzdWx0KSBXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KHdlYlZpZXcsIHdr U2VyaWFsaXplZFNjcmlwdFZhbHVlKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCisvKioKKyAq IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9yZWY6CisgKiBAanNfcmVzdWx0OiBhICNXZWJLaXRK YXZhc2NyaXB0UmVzdWx0CisgKgorICogQXRvbWljYWxseSBpbmNyZW1lbnRzIHRoZSByZWZlcmVu Y2UgY291bnQgb2YgQGpzX3Jlc3VsdCBieSBvbmUuIFRoaXMKKyAqIGZ1bmN0aW9uIGlzIE1ULXNh ZmUgYW5kIG1heSBiZSBjYWxsZWQgZnJvbSBhbnkgdGhyZWFkLgorICoKKyAqIFJldHVybnM6IFRo ZSBwYXNzZWQgaW4gI1dlYktpdEphdmFzY3JpcHRSZXN1bHQKKyAqLworV2ViS2l0SmF2YXNjcmlw dFJlc3VsdCogd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3JlZihXZWJLaXRKYXZhc2NyaXB0UmVz dWx0KiBqYXZhc2NyaXB0UmVzdWx0KQoreworICAgIGdfYXRvbWljX2ludF9pbmMoJmphdmFzY3Jp cHRSZXN1bHQtPnJlZmVyZW5jZUNvdW50KTsKKyAgICByZXR1cm4gamF2YXNjcmlwdFJlc3VsdDsK K30KKworLyoqCisgKiB3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfdW5yZWY6CisgKiBAanNfcmVz dWx0OiBhICNXZWJLaXRKYXZhc2NyaXB0UmVzdWx0CisgKgorICogQXRvbWljYWxseSBkZWNyZW1l bnRzIHRoZSByZWZlcmVuY2UgY291bnQgb2YgQGpzX3Jlc3VsdCBieSBvbmUuIElmIHRoZQorICog cmVmZXJlbmNlIGNvdW50IGRyb3BzIHRvIDAsIGFsbCBtZW1vcnkgYWxsb2NhdGVkIGJ5IHRoZSAj V2ViS2l0SmF2YXNjcmlwdFJlc3VsdCBpcworICogcmVsZWFzZWQuIFRoaXMgZnVuY3Rpb24gaXMg TVQtc2FmZSBhbmQgbWF5IGJlIGNhbGxlZCBmcm9tIGFueQorICogdGhyZWFkLgorICovCit2b2lk IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF91bnJlZihXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KiBq YXZhc2NyaXB0UmVzdWx0KQoreworICAgIGlmIChnX2F0b21pY19pbnRfZGVjX2FuZF90ZXN0KCZq YXZhc2NyaXB0UmVzdWx0LT5yZWZlcmVuY2VDb3VudCkpIHsKKyAgICAgICAgamF2YXNjcmlwdFJl c3VsdC0+fldlYktpdEphdmFzY3JpcHRSZXN1bHQoKTsKKyAgICAgICAgZ19zbGljZV9mcmVlKFdl YktpdEphdmFzY3JpcHRSZXN1bHQsIGphdmFzY3JpcHRSZXN1bHQpOworICAgIH0KK30KKworLyoq CisgKiB3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X2dsb2JhbF9jb250ZXh0OgorICogQGpz X3Jlc3VsdDogYSAjV2ViS2l0SmF2YXNjcmlwdFJlc3VsdAorICoKKyAqIEdldCB0aGUgZ2xvYmFs IEphdmFzY3JpcHQgY29udGV4dCB0aGF0IHNob3VsZCBiZSB1c2VkIHdpdGggdGhlCisgKiA8ZnVu Y3Rpb24+SlNWYWx1ZVJlZjwvZnVuY3Rpb24+IHJldHVybmVkIGJ5IHdlYmtpdF9qYXZhc2NyaXB0 X3Jlc3VsdF9nZXRfdmFsdWUoKS4KKyAqCisgKiBSZXR1cm5zOiB0aGUgPGZ1bmN0aW9uPkpTR2xv YmFsQ29udGV4dFJlZjwvZnVuY3Rpb24+IGZvciB0aGUgI1dlYktpdEphdmFzY3JpcHRSZXN1bHQK KyAqLworSlNHbG9iYWxDb250ZXh0UmVmIHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRfZ2xv YmFsX2NvbnRleHQoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCogamF2YXNjcmlwdFJlc3VsdCkKK3sK KyAgICByZXR1cm4gd2Via2l0X3dlYl92aWV3X2dldF9qYXZhc2NyaXB0X2dsb2JhbF9jb250ZXh0 KGphdmFzY3JpcHRSZXN1bHQtPndlYlZpZXcuZ2V0KCkpOworfQorCisvKioKKyAqIHdlYmtpdF9q YXZhc2NyaXB0X3Jlc3VsdF9nZXRfdmFsdWU6CisgKiBAanNfcmVzdWx0OiBhICNXZWJLaXRKYXZh c2NyaXB0UmVzdWx0CisgKgorICogR2V0IHRoZSB2YWx1ZSBvZiBAanNfcmVzdWx0LiBZb3Ugc2hv dWxkIHVzZSB0aGUgPGZ1bmN0aW9uPkpTR2xvYmFsQ29udGV4dFJlZjwvZnVuY3Rpb24+CisgKiBy ZXR1cm5lZCBieSB3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X2dsb2JhbF9jb250ZXh0KCkg dG8gdXNlIHRoZSA8ZnVuY3Rpb24+SlNWYWx1ZVJlZjwvZnVuY3Rpb24+LgorICoKKyAqIFJldHVy bnM6IHRoZSA8ZnVuY3Rpb24+SlNWYWx1ZVJlZjwvZnVuY3Rpb24+IG9mIHRoZSAjV2ViS2l0SmF2 YXNjcmlwdFJlc3VsdAorICovCitKU1ZhbHVlUmVmIHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9n ZXRfdmFsdWUoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCogamF2YXNjcmlwdFJlc3VsdCkKK3sKKyAg ICByZXR1cm4gamF2YXNjcmlwdFJlc3VsdC0+dmFsdWU7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0LmggYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0LmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWE5ZjczOAotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEphdmFzY3JpcHRSZXN1 bHQuaApAQCAtMCwwICsxLDU1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIElnYWxpYSBT LkwuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICov CisKKyNpZiAhZGVmaW5lZChfX1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lU Ml9DT01QSUxBVElPTikKKyNlcnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBp bmNsdWRlZCBkaXJlY3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRKYXZhc2NyaXB0UmVz dWx0X2gKKyNkZWZpbmUgV2ViS2l0SmF2YXNjcmlwdFJlc3VsdF9oCisKKyNpbmNsdWRlIDxKYXZh U2NyaXB0Q29yZS9KU0Jhc2UuaD4KKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUg PHdlYmtpdDIvV2ViS2l0RGVmaW5lcy5oPgorCitHX0JFR0lOX0RFQ0xTCisKKyNkZWZpbmUgV0VC S0lUX1RZUEVfSkFWQVNDUklQVF9SRVNVTFQgKHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRf dHlwZSgpKQorCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCBXZWJLaXRK YXZhc2NyaXB0UmVzdWx0OworCisKK1dFQktJVF9BUEkgR1R5cGUKK3dlYmtpdF9qYXZhc2NyaXB0 X3Jlc3VsdF9nZXRfdHlwZSAgICAgICAgICAgKHZvaWQpOworCitXRUJLSVRfQVBJIFdlYktpdEph dmFzY3JpcHRSZXN1bHQgKgord2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3JlZiAgICAgICAgICAg ICAgICAoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCAqanNfcmVzdWx0KTsKKworV0VCS0lUX0FQSSB2 b2lkCit3ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfdW5yZWYgICAgICAgICAgICAgIChXZWJLaXRK YXZhc2NyaXB0UmVzdWx0ICpqc19yZXN1bHQpOworCitXRUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4 dFJlZgord2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9iYWxfY29udGV4dCAoV2ViS2l0 SmF2YXNjcmlwdFJlc3VsdCAqanNfcmVzdWx0KTsKKworV0VCS0lUX0FQSSBKU1ZhbHVlUmVmCit3 ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X3ZhbHVlICAgICAgICAgIChXZWJLaXRKYXZhc2Ny aXB0UmVzdWx0ICpqc19yZXN1bHQpOworCitHX0VORF9ERUNMUworCisjZW5kaWYKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdEphdmFzY3JpcHRSZXN1 bHRQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRKYXZh c2NyaXB0UmVzdWx0UHJpdmF0ZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu Ljg0MGVhZDAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRKYXZhc2NyaXB0UmVzdWx0UHJpdmF0ZS5oCkBAIC0wLDAgKzEsMjkgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2Rp ZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUK KyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog Qm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBXZWJLaXRKYXZhc2Ny aXB0UmVzdWx0UHJpdmF0ZV9oCisjZGVmaW5lIFdlYktpdEphdmFzY3JpcHRSZXN1bHRQcml2YXRl X2gKKworI2luY2x1ZGUgIldlYktpdEphdmFzY3JpcHRSZXN1bHQuaCIKKyNpbmNsdWRlICJXZWJL aXRQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0V2ViVmlldy5oIgorCitXZWJLaXRKYXZhc2Ny aXB0UmVzdWx0KiB3ZWJraXRKYXZhc2NyaXB0UmVzdWx0Q3JlYXRlKFdlYktpdFdlYlZpZXcqLCBX S1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZVJlZik7CisKKyNlbmRpZiAvLyBXZWJLaXRKYXZhc2NyaXB0 UmVzdWx0UHJpdmF0ZV9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRQcml2YXRlLmgKaW5kZXggZTc4NWMzNi4uZjYzNDgwYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0UHJpdmF0ZS5oCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFByaXZhdGUuaApAQCAtMzAsNiArMzAsNyBA QAogI2luY2x1ZGUgPFdlYktpdDIvV0tEb3dubG9hZC5oPgogI2luY2x1ZGUgPFdlYktpdDIvV0tG aW5kT3B0aW9ucy5oPgogI2luY2x1ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRl IDxXZWJLaXQyL1dLU2VyaWFsaXplZFNjcmlwdFZhbHVlLmg+CiAjaW5jbHVkZSA8V2ViS2l0Mi9X S1N0cmluZy5oPgogI2luY2x1ZGUgPFdlYktpdDIvV2ViS2l0Mi5oPgogI2luY2x1ZGUgPGdsaWIu aD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YlZpZXcuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmll dy5jcHAKaW5kZXggNGYxN2Q0Ni4uMWVjMzJmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAKQEAgLTI1LDYgKzI1LDcgQEAKICNp bmNsdWRlICJXZWJLaXRFbnVtVHlwZXMuaCIKICNpbmNsdWRlICJXZWJLaXRFcnJvci5oIgogI2lu Y2x1ZGUgIldlYktpdEhpdFRlc3RSZXN1bHRQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0SmF2 YXNjcmlwdFJlc3VsdFByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRMb2FkZXJDbGllbnQuaCIK ICNpbmNsdWRlICJXZWJLaXRNYXJzaGFsLmgiCiAjaW5jbHVkZSAiV2ViS2l0UG9saWN5Q2xpZW50 LmgiCkBAIC0zOCw2ICszOSw3IEBACiAjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1ByaXZhdGUuaCIK ICNpbmNsdWRlICJXZWJLaXRXaW5kb3dQcm9wZXJ0aWVzUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldl YlBhZ2VQcm94eS5oIgorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KICNpbmNs dWRlIDxXZWJDb3JlL0RyYWdJY29uLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9HdGtVdGlsaXRpZXMu aD4KICNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5oPgpAQCAtMTAwLDYgKzEwMiw3IEBAIHN0cnVj dCBfV2ViS2l0V2ViVmlld1ByaXZhdGUgewogICAgIHVuc2lnbmVkIG1vdXNlVGFyZ2V0TW9kaWZp ZXJzOwogCiAgICAgR1JlZlB0cjxXZWJLaXRGaW5kQ29udHJvbGxlcj4gZmluZENvbnRyb2xsZXI7 CisgICAgSlNHbG9iYWxDb250ZXh0UmVmIGphdmFzY3JpcHRHbG9iYWxDb250ZXh0OwogfTsKIAog c3RhdGljIGd1aW50IHNpZ25hbHNbTEFTVF9TSUdOQUxdID0geyAwLCB9OwpAQCAtMjU1LDcgKzI1 OCwxMCBAQCBzdGF0aWMgdm9pZCB3ZWJraXRXZWJWaWV3R2V0UHJvcGVydHkoR09iamVjdCogb2Jq ZWN0LCBndWludCBwcm9wSWQsIEdWYWx1ZSogdmFsdQogCiBzdGF0aWMgdm9pZCB3ZWJraXRXZWJW aWV3RmluYWxpemUoR09iamVjdCogb2JqZWN0KQogewotICAgIFdFQktJVF9XRUJfVklFVyhvYmpl Y3QpLT5wcml2LT5+V2ViS2l0V2ViVmlld1ByaXZhdGUoKTsKKyAgICBXZWJLaXRXZWJWaWV3UHJp dmF0ZSogcHJpdiA9IFdFQktJVF9XRUJfVklFVyhvYmplY3QpLT5wcml2OworICAgIGlmIChwcml2 LT5qYXZhc2NyaXB0R2xvYmFsQ29udGV4dCkKKyAgICAgICAgSlNHbG9iYWxDb250ZXh0UmVsZWFz ZShwcml2LT5qYXZhc2NyaXB0R2xvYmFsQ29udGV4dCk7CisgICAgcHJpdi0+fldlYktpdFdlYlZp ZXdQcml2YXRlKCk7CiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X3dlYl92aWV3X3BhcmVudF9j bGFzcyktPmZpbmFsaXplKG9iamVjdCk7CiB9CiAKQEAgLTE0NjYsMyArMTQ3MiwxNDAgQEAgV2Vi S2l0RmluZENvbnRyb2xsZXIqIHdlYmtpdF93ZWJfdmlld19nZXRfZmluZF9jb250cm9sbGVyKFdl YktpdFdlYlZpZXcqIHdlYlZpZXcKIAogICAgIHJldHVybiB3ZWJWaWV3LT5wcml2LT5maW5kQ29u dHJvbGxlci5nZXQoKTsKIH0KKworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2phdmFzY3Jp cHRfZ2xvYmFsX2NvbnRleHQ6CisgKiBAd2ViX3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAqCisg KiBHZXQgdGhlIGdsb2JhbCBKYXZhc2NyaXB0IGNvbnRleHQgdXNlZCBieSBAd2ViX3ZpZXcgdG8g ZGVzZXJpYWxpemUgdGhlCisgKiByZXN1bHQgdmFsdWVzIG9mIHNjcmlwdHMgZXhlY3V0ZWQgd2l0 aCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQoKS4KKyAqCisgKiBSZXR1cm5zOiB0aGUg PGZ1bmN0aW9uPkpTR2xvYmFsQ29udGV4dFJlZjwvZnVuY3Rpb24+IHVzZWQgYnkgQHdlYl92aWV3 IHRvIGRlc2VyaWFsaXplCisgKiAgICB0aGUgcmVzdWx0IHZhbHVlcyBvZiBzY3JpcHRzLgorICov CitKU0dsb2JhbENvbnRleHRSZWYgd2Via2l0X3dlYl92aWV3X2dldF9qYXZhc2NyaXB0X2dsb2Jh bF9jb250ZXh0KFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZpZXcpLCAwKTsKKworICAgIGlmICghd2ViVmll dy0+cHJpdi0+amF2YXNjcmlwdEdsb2JhbENvbnRleHQpCisgICAgICAgIHdlYlZpZXctPnByaXYt PmphdmFzY3JpcHRHbG9iYWxDb250ZXh0ID0gSlNHbG9iYWxDb250ZXh0Q3JlYXRlKDApOworICAg IHJldHVybiB3ZWJWaWV3LT5wcml2LT5qYXZhc2NyaXB0R2xvYmFsQ29udGV4dDsKK30KKworc3Rh dGljIHZvaWQgd2Via2l0V2ViVmlld1J1bkphdmFTY3JpcHRDYWxsYmFjayhXS1NlcmlhbGl6ZWRT Y3JpcHRWYWx1ZVJlZiB3a1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZSwgV0tFcnJvclJlZiwgdm9pZCog Y29udGV4dCkKK3sKKyAgICBHUmVmUHRyPEdTaW1wbGVBc3luY1Jlc3VsdD4gcmVzdWx0ID0gYWRv cHRHUmVmKEdfU0lNUExFX0FTWU5DX1JFU1VMVChjb250ZXh0KSk7CisgICAgaWYgKHdrU2VyaWFs aXplZFNjcmlwdFZhbHVlKSB7CisgICAgICAgIEdSZWZQdHI8V2ViS2l0V2ViVmlldz4gd2ViVmll dyA9IGFkb3B0R1JlZihXRUJLSVRfV0VCX1ZJRVcoZ19hc3luY19yZXN1bHRfZ2V0X3NvdXJjZV9v YmplY3QoR19BU1lOQ19SRVNVTFQocmVzdWx0LmdldCgpKSkpKTsKKyAgICAgICAgV2ViS2l0SmF2 YXNjcmlwdFJlc3VsdCogc2NyaXB0UmVzdWx0ID0gd2Via2l0SmF2YXNjcmlwdFJlc3VsdENyZWF0 ZSh3ZWJWaWV3LmdldCgpLCB3a1NlcmlhbGl6ZWRTY3JpcHRWYWx1ZSk7CisgICAgICAgIGdfc2lt cGxlX2FzeW5jX3Jlc3VsdF9zZXRfb3BfcmVzX2dwb2ludGVyKHJlc3VsdC5nZXQoKSwgc2NyaXB0 UmVzdWx0LCByZWludGVycHJldF9jYXN0PEdEZXN0cm95Tm90aWZ5Pih3ZWJraXRfamF2YXNjcmlw dF9yZXN1bHRfdW5yZWYpKTsKKyAgICB9IGVsc2UgeworICAgICAgICBHRXJyb3IqIGVycm9yID0g MDsKKyAgICAgICAgZ19zZXRfZXJyb3JfbGl0ZXJhbCgmZXJyb3IsIFdFQktJVF9KQVZBU0NSSVBU X0VSUk9SLCBXRUJLSVRfSkFWQVNDUklQVF9FUlJPUl9TQ1JJUFRfRkFJTEVELCBfKCJBbiBleGNl cHRpb24gd2FzIHJhaXNlZCBpbiBKYXZhc2NyaXB0IikpOworICAgICAgICBnX3NpbXBsZV9hc3lu Y19yZXN1bHRfdGFrZV9lcnJvcihyZXN1bHQuZ2V0KCksIGVycm9yKTsKKyAgICB9CisgICAgZ19z aW1wbGVfYXN5bmNfcmVzdWx0X2NvbXBsZXRlKHJlc3VsdC5nZXQoKSk7Cit9CisKKy8qKgorICog d2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0OgorICogQHdlYl92aWV3OiBhICNXZWJLaXRX ZWJWaWV3CisgKiBAc2NyaXB0OiB0aGUgc2NyaXB0IHRvIHJ1bgorICogQGNhbGxiYWNrOiAoc2Nv cGUgYXN5bmMpOiBhICNHQXN5bmNSZWFkeUNhbGxiYWNrIHRvIGNhbGwgd2hlbiB0aGUgc2NyaXB0 IGZpbmlzaGVkCisgKiBAdXNlcl9kYXRhOiAoY2xvc3VyZSk6IHRoZSBkYXRhIHRvIHBhc3MgdG8g Y2FsbGJhY2sgZnVuY3Rpb24KKyAqCisgKiBBc3luY2hyb25vdXNseSBydW4gQHNjcmlwdCBpbiB0 aGUgY29udGV4dCBvZiB0aGUgY3VycmVudCBwYWdlIGluIEB3ZWJfdmlldy4KKyAqCisgKiBXaGVu IHRoZSBvcGVyYXRpb24gaXMgZmluaXNoZWQsIEBjYWxsYmFjayB3aWxsIGJlIGNhbGxlZC4gWW91 IGNhbiB0aGVuIGNhbGwKKyAqIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdF9maW5pc2go KSB0byBnZXQgdGhlIHJlc3VsdCBvZiB0aGUgb3BlcmF0aW9uLgorICovCit2b2lkIHdlYmtpdF93 ZWJfdmlld19ydW5famF2YXNjcmlwdChXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3LCBjb25zdCBnY2hh ciogc2NyaXB0LCBHQXN5bmNSZWFkeUNhbGxiYWNrIGNhbGxiYWNrLCBncG9pbnRlciB1c2VyRGF0 YSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSk7 CisgICAgZ19yZXR1cm5faWZfZmFpbChzY3JpcHQpOworCisgICAgV0tQYWdlUmVmIHdrUGFnZSA9 IHRvQVBJKHdlYmtpdFdlYlZpZXdCYXNlR2V0UGFnZShXRUJLSVRfV0VCX1ZJRVdfQkFTRSh3ZWJW aWV3KSkpOworICAgIFdLUmV0YWluUHRyPFdLU3RyaW5nUmVmPiB3a1NjcmlwdCA9IGFkb3B0V0so V0tTdHJpbmdDcmVhdGVXaXRoVVRGOENTdHJpbmcoc2NyaXB0KSk7CisgICAgR1NpbXBsZUFzeW5j UmVzdWx0KiByZXN1bHQgPSBnX3NpbXBsZV9hc3luY19yZXN1bHRfbmV3KEdfT0JKRUNUKHdlYlZp ZXcpLCBjYWxsYmFjaywgdXNlckRhdGEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8Z3BvaW50ZXI+KHdl YmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCkpOworICAgIFdLUGFnZVJ1bkphdmFTY3JpcHRJ bk1haW5GcmFtZSh3a1BhZ2UsIHdrU2NyaXB0LmdldCgpLCByZXN1bHQsIHdlYmtpdFdlYlZpZXdS dW5KYXZhU2NyaXB0Q2FsbGJhY2spOworfQorCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19ydW5f amF2YXNjcmlwdF9maW5pc2g6CisgKiBAd2ViX3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAqIEBy ZXN1bHQ6IGEgI0dBc3luY1Jlc3VsdAorICogQGVycm9yOiByZXR1cm4gbG9jYXRpb24gZm9yIGVy cm9yIG9yICVOVUxMIHRvIGlnbm9yZQorICoKKyAqIEZpbmlzaCBhbiBhc3luY2hyb25vdXMgb3Bl cmF0aW9uIHN0YXJ0ZWQgd2l0aCB3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQoKS4KKyAq CisgKiBUaGlzIGlzIGFuIGV4YW1wbGUgb2YgdXNpbmcgd2Via2l0X3dlYl92aWV3X3J1bl9qYXZh c2NyaXB0KCkgd2l0aCBhIHNjcmlwdCByZXR1cm5pbmcKKyAqIGEgc3RyaW5nOgorICoKKyAqIDxp bmZvcm1hbGV4YW1wbGU+PHByb2dyYW1saXN0aW5nPgorICogc3RhdGljIHZvaWQKKyAqIHdlYl92 aWV3X2phdmFzY3JpcHRfZmluaXNoZWQgKEdPYmplY3QgICAgICAqb2JqZWN0LAorICogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgR0FzeW5jUmVzdWx0ICpyZXN1bHQsCisgKiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBncG9pbnRlciAgICAgIHVzZXJfZGF0YSkKKyAqIHsKKyAq ICAgICBXZWJLaXRKYXZhc2NyaXB0UmVzdWx0ICpqc19yZXN1bHQ7CisgKiAgICAgSlNWYWx1ZVJl ZiAgICAgICAgICAgICAgdmFsdWU7CisgKiAgICAgSlNHbG9iYWxDb250ZXh0UmVmICAgICAgY29u dGV4dDsKKyAqICAgICBHRXJyb3IgICAgICAgICAgICAgICAgICplcnJvciA9IE5VTEw7CisgKgor ICogICAgIGpzX3Jlc3VsdCA9IHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdF9maW5pc2gg KFdFQktJVF9XRUJfVklFVyAob2JqZWN0KSwgcmVzdWx0LCAmZXJyb3IpOworICogICAgIGlmICgh anNfcmVzdWx0KSB7CisgKiAgICAgICAgIGdfd2FybmluZyAoIkVycm9yIHJ1bm5pbmcgamF2YXNj cmlwdDogJXMiLCBlcnJvci0+bWVzc2FnZSk7CisgKiAgICAgICAgIGdfZXJyb3JfZnJlZSAoZXJy b3IpOworICogICAgICAgICByZXR1cm47CisgKiAgICAgfQorICoKKyAqICAgICBjb250ZXh0ID0g d2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9iYWxfY29udGV4dCAoanNfcmVzdWx0KTsK KyAqICAgICB2YWx1ZSA9IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRfdmFsdWUgKGpzX3Jl c3VsdCk7CisgKiAgICAgaWYgKEpTVmFsdWVJc1N0cmluZyAoY29udGV4dCwgdmFsdWUpKSB7Cisg KiAgICAgICAgIEpTU3RyaW5nUmVmICpqc19zdHJfdmFsdWU7CisgKiAgICAgICAgIGdjaGFyICAg ICAgICpzdHJfdmFsdWU7CisgKiAgICAgICAgIGdzaXplICAgICAgICBzdHJfbGVuZ3RoOworICoK KyAqICAgICAgICAganNfc3RyX3ZhbHVlID0gSlNWYWx1ZVRvU3RyaW5nQ29weSAoY29udGV4dCwg dmFsdWUsIE5VTEwpKTsKKyAqICAgICAgICAgc3RyX2xlbmd0aCA9IEpTU3RyaW5nR2V0TWF4aW11 bVVURjhDU3RyaW5nU2l6ZSAoanNfc3RyX3ZhbHVlKTsKKyAqICAgICAgICAgc3RyX3ZhbHVlID0g KGdjaGFyICopZ19tYWxsb2MgKHN0cl9sZW5ndGgpKTsKKyAqICAgICAgICAgSlNTdHJpbmdHZXRV VEY4Q1N0cmluZyAoanNfc3RyX3ZhbHVlLCBzdHJfdmFsdWUsIHN0cl9sZW5ndGgpOworICogICAg ICAgICBKU1N0cmluZ1JlbGVhc2UgKGpzX3N0cl92YWx1ZSk7CisgKiAgICAgICAgIGdfcHJpbnQg KCJTY3JpcHQgcmVzdWx0OiAlc1xuIiwgc3RyX3ZhbHVlKTsKKyAqICAgICAgICAgZ19mcmVlIChz dHJfdmFsdWUpOworICogICAgIH0gZWxzZSB7CisgKiAgICAgICAgIGdfd2FybmluZyAoIkVycm9y IHJ1bm5pbmcgamF2YXNjcmlwdDogdW5leHBlY3RlZCByZXR1cm4gdmFsdWUiKTsKKyAqICAgICB9 CisgKiAgICAgd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X3VucmVmIChqc19yZXN1bHQpOworICog fQorICoKKyAqIHN0YXRpYyB2b2lkCisgKiB3ZWJfdmlld19nZXRfbGlua191cmwgKFdlYktpdFdl YlZpZXcgKndlYl92aWV3LAorICogICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAg ICpsaW5rX2lkKQorICogeworICogICAgIGdjaGFyICpzY3JpcHQ7CisgKgorICogICAgIHNjcmlw dCA9IGdfc3RyZHVwX3ByaW50ZiAoIndpbmRvdy5kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnJXMn KS5ocmVmOyIsIGxpbmtfaWQpOworICogICAgIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlw dCAod2ViX3ZpZXcsIHNjcmlwdCwgd2ViX3ZpZXdfamF2YXNjcmlwdF9maW5pc2hlZCwgTlVMTCk7 CisgKiAgICAgZ19mcmVlIChzY3JpcHQpOworICogfQorICogPC9wcm9ncmFtbGlzdGluZz48L2lu Zm9ybWFsZXhhbXBsZT4KKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVsbCk6IGEgI1dlYktp dEphdmFzY3JpcHRSZXN1bHQgd2l0aCB0aGUgcmVzdWx0IG9mIHRoZSBsYXN0IGV4ZWN1dGVkIHN0 YXRlbWVudCBpbiBAc2NyaXB0CisgKiAgICBvciAlTlVMTCBpbiBjYXNlIG9mIGVycm9yCisgKi8K K1dlYktpdEphdmFzY3JpcHRSZXN1bHQqIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdF9m aW5pc2goV2ViS2l0V2ViVmlldyogd2ViVmlldywgR0FzeW5jUmVzdWx0KiByZXN1bHQsIEdFcnJv cioqIGVycm9yKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklF Vyh3ZWJWaWV3KSwgMCk7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoR19JU19BU1lOQ19SRVNV TFQocmVzdWx0KSwgMCk7CisKKyAgICBHU2ltcGxlQXN5bmNSZXN1bHQqIHNpbXBsZVJlc3VsdCA9 IEdfU0lNUExFX0FTWU5DX1JFU1VMVChyZXN1bHQpOworICAgIGdfd2Fybl9pZl9mYWlsKGdfc2lt cGxlX2FzeW5jX3Jlc3VsdF9nZXRfc291cmNlX3RhZyhzaW1wbGVSZXN1bHQpID09IHdlYmtpdF93 ZWJfdmlld19ydW5famF2YXNjcmlwdCk7CisKKyAgICBpZiAoZ19zaW1wbGVfYXN5bmNfcmVzdWx0 X3Byb3BhZ2F0ZV9lcnJvcihzaW1wbGVSZXN1bHQsIGVycm9yKSkKKyAgICAgICAgcmV0dXJuIDA7 CisKKyAgICBXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KiBzY3JpcHRSZXN1bHQgPSBzdGF0aWNfY2Fz dDxXZWJLaXRKYXZhc2NyaXB0UmVzdWx0Kj4oZ19zaW1wbGVfYXN5bmNfcmVzdWx0X2dldF9vcF9y ZXNfZ3BvaW50ZXIoc2ltcGxlUmVzdWx0KSk7CisgICAgcmV0dXJuIHNjcmlwdFJlc3VsdCA/IHdl YmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9yZWYoc2NyaXB0UmVzdWx0KSA6IDA7Cit9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmggYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmgKaW5kZXggZmI0 YzQ4YS4uNmE1NWUwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViVmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXcuaApAQCAtMjgsMTAgKzI4LDEyIEBACiAjaWZuZGVmIFdlYktpdFdlYlZp ZXdfaAogI2RlZmluZSBXZWJLaXRXZWJWaWV3X2gKIAorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0pTQmFzZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0QmFja0ZvcndhcmRMaXN0Lmg+CiAj aW5jbHVkZSA8d2Via2l0Mi9XZWJLaXREZWZpbmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRGaW5kQ29udHJvbGxlci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0SGl0VGVzdFJlc3Vs dC5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0SmF2YXNjcmlwdFJlc3VsdC5oPgogI2luY2x1 ZGUgPHdlYmtpdDIvV2ViS2l0U2NyaXB0RGlhbG9nLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRTZXR0aW5ncy5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0VVJJUmVxdWVzdC5oPgpAQCAt MjY3LDYgKzI2OSwxOCBAQCB3ZWJraXRfd2ViX3ZpZXdfZXhlY3V0ZV9lZGl0aW5nX2NvbW1hbmQg ICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqdwogV0VCS0lUX0FQSSBXZWJL aXRGaW5kQ29udHJvbGxlciAqCiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2ZpbmRfY29udHJvbGxlciAg ICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcpOwogCitX RUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4dFJlZgord2Via2l0X3dlYl92aWV3X2dldF9qYXZhc2Ny aXB0X2dsb2JhbF9jb250ZXh0ICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICAgICAgKndlYl92 aWV3KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2ViX3ZpZXdfcnVuX2phdmFzY3JpcHQg ICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29u c3QgZ2NoYXIgICAgICAgICAgICAgICAqc2NyaXB0LAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdBc3luY1JlYWR5Q2FsbGJhY2sgICAgICAgIGNh bGxiYWNrLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGdwb2ludGVyICAgICAgICAgICAgICAgICAgIHVzZXJfZGF0YSk7CitXRUJLSVRfQVBJIFdl YktpdEphdmFzY3JpcHRSZXN1bHQgKgord2Via2l0X3dlYl92aWV3X3J1bl9qYXZhc2NyaXB0X2Zp bmlzaCAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICAgICAgKndlYl92aWV3LAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdBc3lu Y1Jlc3VsdCAgICAgICAgICAgICAgKnJlc3VsdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBHRXJyb3IgICAgICAgICAgICAgICAgICAgKiplcnJv cik7CiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstc2VjdGlvbnMudHh0CmluZGV4 IGRkYWNmOGQuLmM4ZDM3NjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay1zZWN0aW9ucy50eHQKKysrIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLXNlY3Rpb25zLnR4dApAQCAtNDksOCAr NDksNiBAQCB3ZWJraXRfd2ViX2NvbnRleHRfZ2V0X3R5cGUKIFdlYktpdFdlYlZpZXcKIFdlYktp dExvYWRFdmVudAogV2ViS2l0UG9saWN5RGVjaXNpb25UeXBlCi1XZWJLaXRTY3JpcHREaWFsb2cK LVdlYktpdFNjcmlwdERpYWxvZ1R5cGUKIAogPFNVQlNFQ1RJT04gRWRpdGluZyBDb21tYW5kcz4K IFdFQktJVF9FRElUSU5HX0NPTU1BTkRfQ1VUCkBAIC04OSw2ICs4NywyMCBAQCB3ZWJraXRfd2Vi X3ZpZXdfY2FuX2V4ZWN1dGVfZWRpdGluZ19jb21tYW5kCiB3ZWJraXRfd2ViX3ZpZXdfY2FuX2V4 ZWN1dGVfZWRpdGluZ19jb21tYW5kX2ZpbmlzaAogd2Via2l0X3dlYl92aWV3X2V4ZWN1dGVfZWRp dGluZ19jb21tYW5kCiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2ZpbmRfY29udHJvbGxlcgord2Via2l0 X3dlYl92aWV3X2dldF9qYXZhc2NyaXB0X2dsb2JhbF9jb250ZXh0Cit3ZWJraXRfd2ViX3ZpZXdf cnVuX2phdmFzY3JpcHQKK3dlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdF9maW5pc2gKKwor PFNVQlNFQ1RJT04gV2ViS2l0SmF2YXNjcmlwdFJlc3VsdD4KK1dlYktpdEphdmFzY3JpcHRSZXN1 bHQKK3dlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9yZWYKK3dlYmtpdF9qYXZhc2NyaXB0X3Jlc3Vs dF91bnJlZgord2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9iYWxfY29udGV4dAord2Vi a2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF92YWx1ZQorCis8U1VCU0VDVElPTiBXZWJLaXRTY3Jp cHREaWFsb2c+CitXZWJLaXRTY3JpcHREaWFsb2cKK1dlYktpdFNjcmlwdERpYWxvZ1R5cGUKIHdl YmtpdF9zY3JpcHRfZGlhbG9nX2dldF9kaWFsb2dfdHlwZQogd2Via2l0X3NjcmlwdF9kaWFsb2df Z2V0X21lc3NhZ2UKIHdlYmtpdF9zY3JpcHRfZGlhbG9nX2NvbmZpcm1fc2V0X2NvbmZpcm1lZApA QCAtMTAzLDEwICsxMTUsMTIgQEAgV0VCS0lUX1RZUEVfV0VCX1ZJRVcKIFdFQktJVF9XRUJfVklF V19DTEFTUwogV0VCS0lUX0lTX1dFQl9WSUVXX0NMQVNTCiBXRUJLSVRfV0VCX1ZJRVdfR0VUX0NM QVNTCitXRUJLSVRfVFlQRV9KQVZBU0NSSVBUX1JFU1VMVAogV0VCS0lUX1RZUEVfU0NSSVBUX0RJ QUxPRwogCiA8U1VCU0VDVElPTiBQcml2YXRlPgogd2Via2l0X3dlYl92aWV3X2dldF90eXBlCit3 ZWJraXRfamF2YXNjcmlwdF9yZXN1bHRfZ2V0X3R5cGUKIHdlYmtpdF9zY3JpcHRfZGlhbG9nX2dl dF90eXBlCiBXZWJLaXRXZWJWaWV3UHJpdmF0ZQogPC9TRUNUSU9OPgpAQCAtNDY0LDE2ICs0Nzgs MTkgQEAgV0VCS0lUX1BMVUdJTl9FUlJPUgogV0VCS0lUX1BPTElDWV9FUlJPUgogV0VCS0lUX0RP V05MT0FEX0VSUk9SCiBXRUJLSVRfUFJJTlRfRVJST1IKK1dFQktJVF9KQVZBU0NSSVBUX0VSUk9S CiBXZWJLaXROZXR3b3JrRXJyb3IKIFdlYktpdFBsdWdpbkVycm9yCiBXZWJLaXRQb2xpY3lFcnJv cgogV2ViS2l0RG93bmxvYWRFcnJvcgogV2ViS2l0UHJpbnRFcnJvcgorV2ViS2l0SmF2YXNjcmlw dEVycm9yCiB3ZWJraXRfbmV0d29ya19lcnJvcl9xdWFyawogd2Via2l0X3BsdWdpbl9lcnJvcl9x dWFyawogd2Via2l0X3BvbGljeV9lcnJvcl9xdWFyawogd2Via2l0X2Rvd25sb2FkX2Vycm9yX3F1 YXJrCiB3ZWJraXRfcHJpbnRfZXJyb3JfcXVhcmsKK3dlYmtpdF9qYXZhc2NyaXB0X2Vycm9yX3F1 YXJrCiA8L1NFQ1RJT04+CiAKIDxTRUNUSU9OPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLnR5cGVzIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLnR5cGVzCmluZGV4IDhlOGQ3YjEuLmVm MzRiNDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay50eXBlcworKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGsudHlwZXMKQEAgLTExLDMgKzExLDQgQEAgd2Via2l0X3dpbmRvd19wcm9w ZXJ0aWVzX2dldF90eXBlCiB3ZWJraXRfZG93bmxvYWRfZ2V0X3R5cGUKIHdlYmtpdF9maW5kX2Nv bnRyb2xsZXJfZ2V0X3R5cGUKIHdlYmtpdF9zY3JpcHRfZGlhbG9nX2dldF90eXBlCit3ZWJraXRf amF2YXNjcmlwdF9yZXN1bHRfZ2V0X3R5cGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1Rlc3RXZWJLaXRXZWJWaWV3LmNwcAppbmRleCBi ZmVkYTE2Li43ODc3OTZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay90ZXN0cy9UZXN0V2ViS2l0V2ViVmlldy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvdGVzdHMvVGVzdFdlYktpdFdlYlZpZXcuY3BwCkBAIC00NTIsNiArNDUy LDY2IEBAIHN0YXRpYyB2b2lkIHRlc3RXZWJWaWV3Wm9vbUxldmVsKFdlYlZpZXdUZXN0KiB0ZXN0 LCBnY29uc3Rwb2ludGVyKQogICAgIGdfYXNzZXJ0X2NtcGZsb2F0KHdlYmtpdF93ZWJfdmlld19n ZXRfem9vbV9sZXZlbCh0ZXN0LT5tX3dlYlZpZXcpLCA9PSwgMi41KTsKIH0KIAorc3RhdGljIHZv aWQgdGVzdFdlYlZpZXdSdW5KYXZhU2NyaXB0KFdlYlZpZXdUZXN0KiB0ZXN0LCBnY29uc3Rwb2lu dGVyKQoreworICAgIHN0YXRpYyBjb25zdCBjaGFyKiBodG1sID0gIjxodG1sPjxib2R5PjxhIGlk PSdXZWJLaXRMaW5rJyBocmVmPSdodHRwOi8vd3d3LndlYmtpdGd0ay5vcmcvJyB0aXRsZT0nV2Vi S2l0R1RLKyBUaXRsZSc+V2ViS2l0R1RLKyBXZWJzaXRlPC9hPjwvYm9keT48L2h0bWw+IjsKKyAg ICB0ZXN0LT5sb2FkSHRtbChodG1sLCAwKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNo ZWQoKTsKKworICAgIEdPd25QdHI8R0Vycm9yPiBlcnJvcjsKKyAgICBXZWJLaXRKYXZhc2NyaXB0 UmVzdWx0KiBqYXZhc2NyaXB0UmVzdWx0ID0gdGVzdC0+cnVuSmF2YVNjcmlwdEFuZFdhaXRVbnRp bEZpbmlzaGVkKCJ3aW5kb3cuZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ1dlYktpdExpbmsnKS50 aXRsZTsiLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGdfYXNzZXJ0KGphdmFzY3JpcHRSZXN1bHQp OworICAgIGdfYXNzZXJ0KCFlcnJvci5nZXQoKSk7CisgICAgR093blB0cjxjaGFyPiB2YWx1ZVN0 cmluZyhXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdFRvQ1N0cmluZyhqYXZhc2NyaXB0UmVz dWx0KSk7CisgICAgZ19hc3NlcnRfY21wc3RyKHZhbHVlU3RyaW5nLmdldCgpLCA9PSwgIldlYktp dEdUSysgVGl0bGUiKTsKKworICAgIGphdmFzY3JpcHRSZXN1bHQgPSB0ZXN0LT5ydW5KYXZhU2Ny aXB0QW5kV2FpdFVudGlsRmluaXNoZWQoIndpbmRvdy5kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgn V2ViS2l0TGluaycpLmhyZWY7IiwgJmVycm9yLm91dFB0cigpKTsKKyAgICBnX2Fzc2VydChqYXZh c2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydCghZXJyb3IuZ2V0KCkpOworICAgIHZhbHVlU3Ry aW5nLnNldChXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdFRvQ1N0cmluZyhqYXZhc2NyaXB0 UmVzdWx0KSk7CisgICAgZ19hc3NlcnRfY21wc3RyKHZhbHVlU3RyaW5nLmdldCgpLCA9PSwgImh0 dHA6Ly93d3cud2Via2l0Z3RrLm9yZy8iKTsKKworICAgIGphdmFzY3JpcHRSZXN1bHQgPSB0ZXN0 LT5ydW5KYXZhU2NyaXB0QW5kV2FpdFVudGlsRmluaXNoZWQoIndpbmRvdy5kb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnV2ViS2l0TGluaycpLnRleHRDb250ZW50IiwgJmVycm9yLm91dFB0cigpKTsK KyAgICBnX2Fzc2VydChqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydCghZXJyb3IuZ2V0 KCkpOworICAgIHZhbHVlU3RyaW5nLnNldChXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdFRv Q1N0cmluZyhqYXZhc2NyaXB0UmVzdWx0KSk7CisgICAgZ19hc3NlcnRfY21wc3RyKHZhbHVlU3Ry aW5nLmdldCgpLCA9PSwgIldlYktpdEdUSysgV2Vic2l0ZSIpOworCisgICAgamF2YXNjcmlwdFJl c3VsdCA9IHRlc3QtPnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxGaW5pc2hlZCgiYSA9IDI1OyIs ICZlcnJvci5vdXRQdHIoKSk7CisgICAgZ19hc3NlcnQoamF2YXNjcmlwdFJlc3VsdCk7CisgICAg Z19hc3NlcnQoIWVycm9yLmdldCgpKTsKKyAgICBnX2Fzc2VydF9jbXBmbG9hdChXZWJWaWV3VGVz dDo6amF2YXNjcmlwdFJlc3VsdFRvTnVtYmVyKGphdmFzY3JpcHRSZXN1bHQpLCA9PSwgMjUpOwor CisgICAgamF2YXNjcmlwdFJlc3VsdCA9IHRlc3QtPnJ1bkphdmFTY3JpcHRBbmRXYWl0VW50aWxG aW5pc2hlZCgiYSA9IDIuNTsiLCAmZXJyb3Iub3V0UHRyKCkpOworICAgIGdfYXNzZXJ0KGphdmFz Y3JpcHRSZXN1bHQpOworICAgIGdfYXNzZXJ0KCFlcnJvci5nZXQoKSk7CisgICAgZ19hc3NlcnRf Y21wZmxvYXQoV2ViVmlld1Rlc3Q6OmphdmFzY3JpcHRSZXN1bHRUb051bWJlcihqYXZhc2NyaXB0 UmVzdWx0KSwgPT0sIDIuNSk7CisKKyAgICBqYXZhc2NyaXB0UmVzdWx0ID0gdGVzdC0+cnVuSmF2 YVNjcmlwdEFuZFdhaXRVbnRpbEZpbmlzaGVkKCJhID0gdHJ1ZSIsICZlcnJvci5vdXRQdHIoKSk7 CisgICAgZ19hc3NlcnQoamF2YXNjcmlwdFJlc3VsdCk7CisgICAgZ19hc3NlcnQoIWVycm9yLmdl dCgpKTsKKyAgICBnX2Fzc2VydChXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdFRvQm9vbGVh bihqYXZhc2NyaXB0UmVzdWx0KSk7CisKKyAgICBqYXZhc2NyaXB0UmVzdWx0ID0gdGVzdC0+cnVu SmF2YVNjcmlwdEFuZFdhaXRVbnRpbEZpbmlzaGVkKCJhID0gZmFsc2UiLCAmZXJyb3Iub3V0UHRy KCkpOworICAgIGdfYXNzZXJ0KGphdmFzY3JpcHRSZXN1bHQpOworICAgIGdfYXNzZXJ0KCFlcnJv ci5nZXQoKSk7CisgICAgZ19hc3NlcnQoIVdlYlZpZXdUZXN0OjpqYXZhc2NyaXB0UmVzdWx0VG9C b29sZWFuKGphdmFzY3JpcHRSZXN1bHQpKTsKKworICAgIGphdmFzY3JpcHRSZXN1bHQgPSB0ZXN0 LT5ydW5KYXZhU2NyaXB0QW5kV2FpdFVudGlsRmluaXNoZWQoImEgPSBudWxsIiwgJmVycm9yLm91 dFB0cigpKTsKKyAgICBnX2Fzc2VydChqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydCgh ZXJyb3IuZ2V0KCkpOworICAgIGdfYXNzZXJ0KFdlYlZpZXdUZXN0OjpqYXZhc2NyaXB0UmVzdWx0 SXNOdWxsKGphdmFzY3JpcHRSZXN1bHQpKTsKKworICAgIGphdmFzY3JpcHRSZXN1bHQgPSB0ZXN0 LT5ydW5KYXZhU2NyaXB0QW5kV2FpdFVudGlsRmluaXNoZWQoImZ1bmN0aW9uIEZvbygpIHsgYSA9 IDI1OyB9IEZvbygpOyIsICZlcnJvci5vdXRQdHIoKSk7CisgICAgZ19hc3NlcnQoamF2YXNjcmlw dFJlc3VsdCk7CisgICAgZ19hc3NlcnQoIWVycm9yLmdldCgpKTsKKyAgICBnX2Fzc2VydChXZWJW aWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdElzVW5kZWZpbmVkKGphdmFzY3JpcHRSZXN1bHQpKTsK KworICAgIGphdmFzY3JpcHRSZXN1bHQgPSB0ZXN0LT5ydW5KYXZhU2NyaXB0QW5kV2FpdFVudGls RmluaXNoZWQoImZvbygpOyIsICZlcnJvci5vdXRQdHIoKSk7CisgICAgZ19hc3NlcnQoIWphdmFz Y3JpcHRSZXN1bHQpOworICAgIGdfYXNzZXJ0X2Vycm9yKGVycm9yLmdldCgpLCBXRUJLSVRfSkFW QVNDUklQVF9FUlJPUiwgV0VCS0lUX0pBVkFTQ1JJUFRfRVJST1JfU0NSSVBUX0ZBSUxFRCk7Cit9 CisKIHZvaWQgYmVmb3JlQWxsKCkKIHsKICAgICBXZWJWaWV3VGVzdDo6YWRkKCJXZWJLaXRXZWJW aWV3IiwgImRlZmF1bHQtY29udGV4dCIsIHRlc3RXZWJWaWV3RGVmYXVsdENvbnRleHQpOwpAQCAt NDYzLDYgKzUyMyw3IEBAIHZvaWQgYmVmb3JlQWxsKCkKICAgICBVSUNsaWVudFRlc3Q6OmFkZCgi V2ViS2l0V2ViVmlldyIsICJ3aW5kb3ctcHJvcGVydGllcyIsIHRlc3RXZWJWaWV3V2luZG93UHJv cGVydGllcyk7CiAgICAgVUlDbGllbnRUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAibW91c2Ut dGFyZ2V0IiwgdGVzdFdlYlZpZXdNb3VzZVRhcmdldCk7CiAgICAgV2ViVmlld1Rlc3Q6OmFkZCgi V2ViS2l0V2ViVmlldyIsICJ6b29tLWxldmVsIiwgdGVzdFdlYlZpZXdab29tTGV2ZWwpOworICAg IFdlYlZpZXdUZXN0OjphZGQoIldlYktpdFdlYlZpZXciLCAicnVuLWphdmFzY3JpcHQiLCB0ZXN0 V2ViVmlld1J1bkphdmFTY3JpcHQpOwogfQogCiB2b2lkIGFmdGVyQWxsKCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0LmNwcCBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0LmNwcApp bmRleCA2MGJmN2ZiLi4wOWY5N2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmlld1Rlc3QuY3BwCkBAIC0yMSwxMiArMjEsMTQgQEAK ICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJWaWV3VGVzdC5oIgogCisjaW5jbHVk ZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL0dPd25Q dHJHdGsuaD4KIAogV2ViVmlld1Rlc3Q6OldlYlZpZXdUZXN0KCkKICAgICA6IG1fd2ViVmlldyhX RUJLSVRfV0VCX1ZJRVcoZ19vYmplY3RfcmVmX3Npbmsod2Via2l0X3dlYl92aWV3X25ldygpKSkp CiAgICAgLCBtX21haW5Mb29wKGdfbWFpbl9sb29wX25ldygwLCBUUlVFKSkKICAgICAsIG1fcGFy ZW50V2luZG93KDApCisgICAgLCBtX2phdmFzY3JpcHRSZXN1bHQoMCkKIHsKICAgICBhc3NlcnRP YmplY3RJc0RlbGV0ZWRXaGVuVGVzdEZpbmlzaGVzKEdfT0JKRUNUKG1fd2ViVmlldykpOwogfQpA QCAtMzUsNiArMzcsOCBAQCBXZWJWaWV3VGVzdDo6fldlYlZpZXdUZXN0KCkKIHsKICAgICBpZiAo bV9wYXJlbnRXaW5kb3cpCiAgICAgICAgIGd0a193aWRnZXRfZGVzdHJveShtX3BhcmVudFdpbmRv dyk7CisgICAgaWYgKG1famF2YXNjcmlwdFJlc3VsdCkKKyAgICAgICAgd2Via2l0X2phdmFzY3Jp cHRfcmVzdWx0X3VucmVmKG1famF2YXNjcmlwdFJlc3VsdCk7CiAgICAgZ19vYmplY3RfdW5yZWYo bV93ZWJWaWV3KTsKICAgICBnX21haW5fbG9vcF91bnJlZihtX21haW5Mb29wKTsKIH0KQEAgLTE5 NCwzICsxOTgsODQgQEAgdm9pZCBXZWJWaWV3VGVzdDo6bW91c2VNb3ZlVG8oaW50IHgsIGludCB5 LCB1bnNpZ25lZCBpbnQgbW91c2VNb2RpZmllcnMpCiAgICAgZ3RrX21haW5fZG9fZXZlbnQoZXZl bnQuZ2V0KCkpOwogfQogCitzdGF0aWMgdm9pZCBydW5KYXZhU2NyaXB0UmVhZHlDYWxsYmFjayhH T2JqZWN0KiwgR0FzeW5jUmVzdWx0KiByZXN1bHQsIFdlYlZpZXdUZXN0KiB0ZXN0KQoreworICAg IHRlc3QtPm1famF2YXNjcmlwdFJlc3VsdCA9IHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlw dF9maW5pc2godGVzdC0+bV93ZWJWaWV3LCByZXN1bHQsIHRlc3QtPm1famF2YXNjcmlwdEVycm9y KTsKKyAgICBnX21haW5fbG9vcF9xdWl0KHRlc3QtPm1fbWFpbkxvb3ApOworfQorCitXZWJLaXRK YXZhc2NyaXB0UmVzdWx0KiBXZWJWaWV3VGVzdDo6cnVuSmF2YVNjcmlwdEFuZFdhaXRVbnRpbEZp bmlzaGVkKGNvbnN0IGNoYXIqIGphdmFzY3JpcHQsIEdFcnJvcioqIGVycm9yKQoreworICAgIGlm IChtX2phdmFzY3JpcHRSZXN1bHQpCisgICAgICAgIHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF91 bnJlZihtX2phdmFzY3JpcHRSZXN1bHQpOworICAgIG1famF2YXNjcmlwdFJlc3VsdCA9IDA7Cisg ICAgbV9qYXZhc2NyaXB0RXJyb3IgPSBlcnJvcjsKKyAgICB3ZWJraXRfd2ViX3ZpZXdfcnVuX2ph dmFzY3JpcHQobV93ZWJWaWV3LCBqYXZhc2NyaXB0LCByZWludGVycHJldF9jYXN0PEdBc3luY1Jl YWR5Q2FsbGJhY2s+KHJ1bkphdmFTY3JpcHRSZWFkeUNhbGxiYWNrKSwgdGhpcyk7CisgICAgZ19t YWluX2xvb3BfcnVuKG1fbWFpbkxvb3ApOworCisgICAgcmV0dXJuIG1famF2YXNjcmlwdFJlc3Vs dDsKK30KKworc3RhdGljIGNoYXIqIGpzVmFsdWVUb0NTdHJpbmcoSlNHbG9iYWxDb250ZXh0UmVm IGNvbnRleHQsIEpTVmFsdWVSZWYgdmFsdWUpCit7CisgICAgZ19hc3NlcnQodmFsdWUpOworICAg IGdfYXNzZXJ0KEpTVmFsdWVJc1N0cmluZyhjb250ZXh0LCB2YWx1ZSkpOworCisgICAgSlNSZXRh aW5QdHI8SlNTdHJpbmdSZWY+IHN0cmluZ1ZhbHVlKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5 KGNvbnRleHQsIHZhbHVlLCAwKSk7CisgICAgZ19hc3NlcnQoc3RyaW5nVmFsdWUpOworCisgICAg c2l6ZV90IGNTdHJpbmdMZW5ndGggPSBKU1N0cmluZ0dldE1heGltdW1VVEY4Q1N0cmluZ1NpemUo c3RyaW5nVmFsdWUuZ2V0KCkpOworICAgIGNoYXIqIGNTdHJpbmcgPSBzdGF0aWNfY2FzdDxjaGFy Kj4oZ19tYWxsb2MoY1N0cmluZ0xlbmd0aCkpOworICAgIEpTU3RyaW5nR2V0VVRGOENTdHJpbmco c3RyaW5nVmFsdWUuZ2V0KCksIGNTdHJpbmcsIGNTdHJpbmdMZW5ndGgpOworICAgIHJldHVybiBj U3RyaW5nOworfQorCitjaGFyKiBXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdFRvQ1N0cmlu ZyhXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KiBqYXZhc2NyaXB0UmVzdWx0KQoreworICAgIEpTR2xv YmFsQ29udGV4dFJlZiBjb250ZXh0ID0gd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9i YWxfY29udGV4dChqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydChjb250ZXh0KTsKKyAg ICByZXR1cm4ganNWYWx1ZVRvQ1N0cmluZyhjb250ZXh0LCB3ZWJraXRfamF2YXNjcmlwdF9yZXN1 bHRfZ2V0X3ZhbHVlKGphdmFzY3JpcHRSZXN1bHQpKTsKK30KKworZG91YmxlIFdlYlZpZXdUZXN0 OjpqYXZhc2NyaXB0UmVzdWx0VG9OdW1iZXIoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCogamF2YXNj cmlwdFJlc3VsdCkKK3sKKyAgICBKU0dsb2JhbENvbnRleHRSZWYgY29udGV4dCA9IHdlYmtpdF9q YXZhc2NyaXB0X3Jlc3VsdF9nZXRfZ2xvYmFsX2NvbnRleHQoamF2YXNjcmlwdFJlc3VsdCk7Cisg ICAgZ19hc3NlcnQoY29udGV4dCk7CisgICAgSlNWYWx1ZVJlZiB2YWx1ZSA9IHdlYmtpdF9qYXZh c2NyaXB0X3Jlc3VsdF9nZXRfdmFsdWUoamF2YXNjcmlwdFJlc3VsdCk7CisgICAgZ19hc3NlcnQo dmFsdWUpOworICAgIGdfYXNzZXJ0KEpTVmFsdWVJc051bWJlcihjb250ZXh0LCB2YWx1ZSkpOwor CisgICAgcmV0dXJuIEpTVmFsdWVUb051bWJlcihjb250ZXh0LCB2YWx1ZSwgMCk7Cit9CisKK2Jv b2wgV2ViVmlld1Rlc3Q6OmphdmFzY3JpcHRSZXN1bHRUb0Jvb2xlYW4oV2ViS2l0SmF2YXNjcmlw dFJlc3VsdCogamF2YXNjcmlwdFJlc3VsdCkKK3sKKyAgICBKU0dsb2JhbENvbnRleHRSZWYgY29u dGV4dCA9IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRfZ2xvYmFsX2NvbnRleHQoamF2YXNj cmlwdFJlc3VsdCk7CisgICAgZ19hc3NlcnQoY29udGV4dCk7CisgICAgSlNWYWx1ZVJlZiB2YWx1 ZSA9IHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRfdmFsdWUoamF2YXNjcmlwdFJlc3VsdCk7 CisgICAgZ19hc3NlcnQodmFsdWUpOworICAgIGdfYXNzZXJ0KEpTVmFsdWVJc0Jvb2xlYW4oY29u dGV4dCwgdmFsdWUpKTsKKworICAgIHJldHVybiBKU1ZhbHVlVG9Cb29sZWFuKGNvbnRleHQsIHZh bHVlKTsKK30KKworYm9vbCBXZWJWaWV3VGVzdDo6amF2YXNjcmlwdFJlc3VsdElzTnVsbChXZWJL aXRKYXZhc2NyaXB0UmVzdWx0KiBqYXZhc2NyaXB0UmVzdWx0KQoreworICAgIEpTR2xvYmFsQ29u dGV4dFJlZiBjb250ZXh0ID0gd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF9nbG9iYWxfY29u dGV4dChqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydChjb250ZXh0KTsKKyAgICBKU1Zh bHVlUmVmIHZhbHVlID0gd2Via2l0X2phdmFzY3JpcHRfcmVzdWx0X2dldF92YWx1ZShqYXZhc2Ny aXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydCh2YWx1ZSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZUlz TnVsbChjb250ZXh0LCB2YWx1ZSk7Cit9CisKK2Jvb2wgV2ViVmlld1Rlc3Q6OmphdmFzY3JpcHRS ZXN1bHRJc1VuZGVmaW5lZChXZWJLaXRKYXZhc2NyaXB0UmVzdWx0KiBqYXZhc2NyaXB0UmVzdWx0 KQoreworICAgIEpTR2xvYmFsQ29udGV4dFJlZiBjb250ZXh0ID0gd2Via2l0X2phdmFzY3JpcHRf cmVzdWx0X2dldF9nbG9iYWxfY29udGV4dChqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2Vy dChjb250ZXh0KTsKKyAgICBKU1ZhbHVlUmVmIHZhbHVlID0gd2Via2l0X2phdmFzY3JpcHRfcmVz dWx0X2dldF92YWx1ZShqYXZhc2NyaXB0UmVzdWx0KTsKKyAgICBnX2Fzc2VydCh2YWx1ZSk7CisK KyAgICByZXR1cm4gSlNWYWx1ZUlzVW5kZWZpbmVkKGNvbnRleHQsIHZhbHVlKTsKK30KKwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmlld1Rl c3QuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3Rlc3RzL1dlYlZpZXdUZXN0 LmgKaW5kZXggMDFmNDY4NS4uMzRhZmIwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvdGVzdHMvV2ViVmlld1Rlc3QuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay90ZXN0cy9XZWJWaWV3VGVzdC5oCkBAIC00OCwxMSArNDgsMjIgQEAg cHVibGljOgogCiAgICAgdm9pZCBtb3VzZU1vdmVUbyhpbnQgeCwgaW50IHksIHVuc2lnbmVkIGlu dCBtb3VzZU1vZGlmaWVycyA9IDApOwogCisgICAgV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCogcnVu SmF2YVNjcmlwdEFuZFdhaXRVbnRpbEZpbmlzaGVkKGNvbnN0IGNoYXIqIGphdmFzY3JpcHQsIEdF cnJvcioqKTsKKworICAgIC8vIEphdmFzY3JpcHQgcmVzdWx0IGhlbHBlcnMuCisgICAgc3RhdGlj IGNoYXIqIGphdmFzY3JpcHRSZXN1bHRUb0NTdHJpbmcoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCop OworICAgIHN0YXRpYyBkb3VibGUgamF2YXNjcmlwdFJlc3VsdFRvTnVtYmVyKFdlYktpdEphdmFz Y3JpcHRSZXN1bHQqKTsKKyAgICBzdGF0aWMgYm9vbCBqYXZhc2NyaXB0UmVzdWx0VG9Cb29sZWFu KFdlYktpdEphdmFzY3JpcHRSZXN1bHQqKTsKKyAgICBzdGF0aWMgYm9vbCBqYXZhc2NyaXB0UmVz dWx0SXNOdWxsKFdlYktpdEphdmFzY3JpcHRSZXN1bHQqKTsKKyAgICBzdGF0aWMgYm9vbCBqYXZh c2NyaXB0UmVzdWx0SXNVbmRlZmluZWQoV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCopOworCiAgICAg V2ViS2l0V2ViVmlldyogbV93ZWJWaWV3OwogICAgIEdNYWluTG9vcCogbV9tYWluTG9vcDsKICAg ICBDU3RyaW5nIG1fYWN0aXZlVVJJOwogICAgIEd0a1dpZGdldCogbV9wYXJlbnRXaW5kb3c7CiAg ICAgQ1N0cmluZyBtX2V4cGVjdGVkVGl0bGU7CisgICAgV2ViS2l0SmF2YXNjcmlwdFJlc3VsdCog bV9qYXZhc2NyaXB0UmVzdWx0OworICAgIEdFcnJvcioqIG1famF2YXNjcmlwdEVycm9yOwogfTsK IAogI2VuZGlmIC8vIFdlYlZpZXdUZXN0X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL3dlYmtpdDIuaAppbmRleCAwYTgwN2JjLi5mNTU3NzZjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay93ZWJraXQyLmgKKysrIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSA8 d2Via2l0Mi9XZWJLaXRFcnJvci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0RmluZENvbnRy b2xsZXIuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdEhpdFRlc3RSZXN1bHQuaD4KKyNpbmNs dWRlIDx3ZWJraXQyL1dlYktpdEphdmFzY3JpcHRSZXN1bHQuaD4KICNpbmNsdWRlIDx3ZWJraXQy L1dlYktpdFByaW50T3BlcmF0aW9uLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRTY3JpcHRE aWFsb2cuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFNldHRpbmdzLmg+CmRpZmYgLS1naXQg YS9Ub29scy9NaW5pQnJvd3Nlci9ndGsvR05VbWFrZWZpbGUuYW0gYi9Ub29scy9NaW5pQnJvd3Nl ci9ndGsvR05VbWFrZWZpbGUuYW0KaW5kZXggOWU0MmUxOS4uZDI4ZDllNCAxMDA2NDQKLS0tIGEv VG9vbHMvTWluaUJyb3dzZXIvZ3RrL0dOVW1ha2VmaWxlLmFtCisrKyBiL1Rvb2xzL01pbmlCcm93 c2VyL2d0ay9HTlVtYWtlZmlsZS5hbQpAQCAtMTAsNiArMTAsNyBAQCBQcm9ncmFtc19NaW5pQnJv d3Nlcl9DUFBGTEFHUyA9IFwKIAktSSQodG9wX2J1aWxkZGlyKS9EZXJpdmVkU291cmNlcy9XZWJL aXQyL3dlYmtpdDJndGsvaW5jbHVkZSBcCiAJLURXRUJLSVRfRVhFQ19QQVRIPVwiJHtzaGVsbCBw d2R9LyQodG9wX2J1aWxkZGlyKS9Qcm9ncmFtcy9cIiBcCiAJJChnbG9iYWxfY3BwZmxhZ3MpIFwK KwkkKGphdmFzY3JpcHRjb3JlX2NwcGZsYWdzKSBcCiAJJChHTElCX0NGTEFHUykgXAogCSQoR1RL X0NGTEFHUykKIAo=