115600 2013-05-04 15:09:01 -0700 [GTK] Allow to save and restore session 2016-01-05 00:13:24 -0800 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Enhancement --- 0 dwnarvaez webkit-unassigned andersca cgarcia gustavo lantw44 mcatanzaro mrobinson pbrobinson sam oldest_to_newest 884592 0 dwnarvaez 2013-05-04 15:09:01 -0700 As pointed out in bug 69358, there is no way to restore only back/forward history in WebKit2 but it's possible to save and restore the whole session state (which in my opinion is much better). We should bind the two APIs in gtk. WK_EXPORT WKDataRef WKPageCopySessionState(WKPageRef page, void* context, WKPageSessionStateFilterCallback urlAllowedCallback); WK_EXPORT void WKPageRestoreFromSessionState(WKPageRef page, WKDataRef sessionStateData); 1115320 1 sam 2015-08-06 02:51:29 -0700 Newer discussion of this API: https://bugs.webkit.org/show_bug.cgi?id=147525 https://bugs.webkit.org/show_bug.cgi?id=69343#c23 1126328 2 261304 sam 2015-09-16 05:00:12 -0700 Created attachment 261304 Patch 1126331 3 sam 2015-09-16 05:05:00 -0700 As a little demo test, you can change BrowserWindow.c in minibrowser to have reloadOrStopCallback like: GBytes * state = NULL; /* Horrible style, just a demo */ static void reloadOrStopCallback(BrowserWindow *window) { if (!state) { state = webkit_web_view_serialize_session(window->webView); } else { webkit_web_view_restore_session(window->webView, state, TRUE); state = NULL; } } Then when you run minibrowser, press the stop button to save the session state. Then navigate around the web to somewhere else. Press the stop button again and you should be back to where you saved the state and the back forward lists, etc. should remain the same. 1126651 4 261304 cgarcia 2015-09-17 02:08:41 -0700 Comment on attachment 261304 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=261304&action=review Thanks for the patch. This adds new API, so it probably requires some discussion in the mailing list first. The patch should include unit tests to cover the new API added. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API. If we are going to expose the session state API, I think we should first implement the internal implementation and enabling the cross-platform unit tests to make sure it works. I think that adding a LegacySessionStateCoding implementation could be enough, and then enable the Tests in Tools/TestWebKitAPI/Tests/WebKit2 that use the WKSession API. We could use bug #84960 for that part. Once that is working, then we can expose it in our API. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3717 > + * webkit_web_view_serialize_session Missing trailing : here > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3724 > + * Returns: (transfer none): A GBytes buffer containing the state, or NULL. This says transfer none, but returns a newly created GBytes that we don't free. GBytes -> #GBytes NULL -> %NULL We should also document why this can return NULL. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3726 > + * Since: 2.10 Too late for 2.10, this should be 2.12 > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3728 > +GBytes* webkit_web_view_serialize_session(WebKitWebView *webView) WebKitWebView *webView -> WebKitWebView* webView > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3730 > + g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL); NULL -> nullptr > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3733 > + g_return_val_if_fail(!!page, NULL); Don't ue g_return macros for this. Use an ASSERT or and early return. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3735 > + SessionState x = page->sessionState(0); Do not use x for a variable name, use a word that better defines what this is for. And use nullptr instead o 0. See the WebKit coding style: http://www.webkit.org/coding/coding-style.html > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3740 > + GBytes* buf = g_bytes_new_take(encoder->buffer(), encoder->bufferSize()); > + return buf; We don't need the local variable. The ArgumentEncoder previously allocated is leaked here. And the data can't be taken by the GBytes, because it's owned by the ArgumentEncoder and because it will be freed by the GBytes using g_free, but was allocated by WebKit using bmalloc. In any case, I don't think we should use the ArgumentEncoder here this way. We should either return an object wrapping the SessionState, or if we really want to return encoded data, use the encodeLegacySessionState() method. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3744 > + * webkit_web_view_restore_session Missing trailing : here > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3747 > + * @navigate: a #gboolean that if #TRUE will trigger navigation to the site set in the state #TRUE -> %TRUE > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3751 > + * Since: 2.10 Too late for 2.10, this should be 2.12 > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3753 > +void webkit_web_view_restore_session(WebKitWebView *webView, GBytes *state, gboolean navigate) WebKitWebView *webView -> WebKitWebView* webView GBytes *state -> GBytes* state > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3758 > + WebPageProxy* page = getPage(webView); > + g_return_if_fail(!!page); Don't ue g_return macros for this. Use an ASSERT or and early return. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3762 > + (uint8_t *) g_bytes_get_data(state, &size), size); Use C++ style casts. > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3764 > + SessionState session_state; session_state -> sessionState > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3766 > + page->restoreFromSessionState(session_state, navigate); WTF::move(session_state) > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3767 > +} The decoder is also leaked here. 1126670 5 sam 2015-09-17 03:57:19 -0700 Thanks for the in depth review. I will look into the legacy state encoder - it seems to fit my needs better than this patch. > If we are going to expose the session state API, I think we should first implement the internal implementation and enabling the cross-platform unit tests to make sure it works. I think that adding a LegacySessionStateCoding implementation could be enough, and then enable the Tests in Tools/TestWebKitAPI/Tests/WebKit2 that use the WKSession API. We could use bug #84960 for that part. Once that is working, then we can expose it in our API. What do you mean by the internal implementation? A change to WebKitWebView.c or something more internal? 1146958 6 266798 cgarcia 2015-12-07 12:50:38 -0800 Created attachment 266798 Patch Some notes about the API: - It adds WebKitWebViewSessionState, a boxed type that can be created by the web view to get the current session state, or by the user from serialized data. - webkit_web_view_get_session_state() is transfer full because the session state is something that changes all the time, so you get the current state, it's not something we want to cache. - webkit_web_view_get_session_state() always passes nullptr as filter to WebPageProxy::sessionState. I'm not sure why the user would want to filter the bf list, so for now I left it that way, if we eventually want to add support for that we can add webkit_web_view_get_filtered_session_state() or something similar. 1147045 7 266798 andersca 2015-12-07 15:29:55 -0800 Comment on attachment 266798 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=266798&action=review > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:136 > + g_return_val_if_fail(state, nullptr); > + IPC::ArgumentEncoder encoder; > + encoder << state->sessionState.backForwardListState; > + encoder << state->sessionState.renderTreeSize; > + encoder << state->sessionState.provisionalURL; > + return g_bytes_new(encoder.buffer(), encoder.bufferSize()); NO. Don't do this, we DON'T want to rely on the IPC encoding for this. 1147186 8 cgarcia 2015-12-08 00:24:20 -0800 (In reply to comment #7) > Comment on attachment 266798 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=266798&action=review > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:136 > > + g_return_val_if_fail(state, nullptr); > > + IPC::ArgumentEncoder encoder; > > + encoder << state->sessionState.backForwardListState; > > + encoder << state->sessionState.renderTreeSize; > > + encoder << state->sessionState.provisionalURL; > > + return g_bytes_new(encoder.buffer(), encoder.bufferSize()); > > NO. > > Don't do this, we DON'T want to rely on the IPC encoding for this. Ok, I simply didn't know it. What's the right way then? Should I use my own encoding/decoding thing? 1147354 9 andersca 2015-12-08 10:38:43 -0800 (In reply to comment #8) > (In reply to comment #7) > > Comment on attachment 266798 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=266798&action=review > > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:136 > > > + g_return_val_if_fail(state, nullptr); > > > + IPC::ArgumentEncoder encoder; > > > + encoder << state->sessionState.backForwardListState; > > > + encoder << state->sessionState.renderTreeSize; > > > + encoder << state->sessionState.provisionalURL; > > > + return g_bytes_new(encoder.buffer(), encoder.bufferSize()); > > > > NO. > > > > Don't do this, we DON'T want to rely on the IPC encoding for this. > > Ok, I simply didn't know it. What's the right way then? Should I use my own > encoding/decoding thing? Yes. Preferably something that can be extended without breaking the format. FWIW, the reason we don't want this is because it means we can't change the IPC format without breaking compat. We did this on OS X in the past and it caused us lots of pain. 1147357 10 cgarcia 2015-12-08 10:41:52 -0800 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > Comment on attachment 266798 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=266798&action=review > > > > > > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:136 > > > > + g_return_val_if_fail(state, nullptr); > > > > + IPC::ArgumentEncoder encoder; > > > > + encoder << state->sessionState.backForwardListState; > > > > + encoder << state->sessionState.renderTreeSize; > > > > + encoder << state->sessionState.provisionalURL; > > > > + return g_bytes_new(encoder.buffer(), encoder.bufferSize()); > > > > > > NO. > > > > > > Don't do this, we DON'T want to rely on the IPC encoding for this. > > > > Ok, I simply didn't know it. What's the right way then? Should I use my own > > encoding/decoding thing? > > Yes. Preferably something that can be extended without breaking the format. > > FWIW, the reason we don't want this is because it means we can't change the > IPC format without breaking compat. We did this on OS X in the past and it > caused us lots of pain. Ok, understood, thanks for the explanation. I'll rework it. 1151612 11 268006 cgarcia 2015-12-30 09:59:50 -0800 Created attachment 268006 Updated patch It uses GVariant instead of IPC encoders/decoders. 1151613 12 268007 cgarcia 2015-12-30 10:21:29 -0800 Created attachment 268007 Rebased to apply on current trunk 1151623 13 268007 mcatanzaro 2015-12-30 13:53:54 -0800 Comment on attachment 268007 Rebased to apply on current trunk View in context: https://bugs.webkit.org/attachment.cgi?id=268007&action=review This gets API approval from me, but please propose it on the mailing list and wait a few days anyway, to give folks a chance to object, even though probably nobody will. I almost gave this r- for the messy implementation, since it took me a long time to accept that a GVariant of type (qa(ts(ssssasmaytt(ii)dm(sa(uaysxmxmds))av)u)mu) is really the best way to handle this, rather than using nice C++ iostreams like in your previous patch... but Anders is right, we can't use the IPC encoders because our serialization would break whenever the implementation changes. We hardly want to reimplement all the iostream encoders in this file, which is what it would take to use iostreams safely. It's unfortunate that GVariant is so much harder to use than iostreams, but the mess is contained into one file, and you split it up nicely into "nested" functions. And with GVariant, we know the serialization format is not going to change. My biggest issue with this patch is that we should have some way to detect changes to the implementation of HTTPBody, FrameState, PageState, BackForwardListState, so that we know to update the serialization here. Currently we can detect deletions, since we'd get a compiler error, but if any new state is added to these classes we will miss it. I think you can solve this using messy static_asserts and sizeof to check the size of the structs. Something like: #if CPU(X86_64) && COMPILER(GCC_OR_CLANG) && DEVELOPER_MODE static_assert(sizeof(HTTPBody::Element == sizeof(Type) + sizeof(Vector<char>) + sizeof(String) + sizeof(int64_t) + sizeof(Optional<int64_t>) + sizeof(Optional<double>) + sizeof(String)); #endif I guess that is pretty messy, though. > Source/WebKit2/ChangeLog:15 > + session state form the given WebKitWebViewSessionState. form -> rom > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3754 > + getPage(webView)->restoreFromSessionState(webkitWebViewSessionStatateGetSessionState(state), false); You need to fix this typo all over. webkitWebViewSessionStatateGetSessionState -> webkitWebViewSessionStateGetSessionState > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:59 > +static inline unsigned toExternalURLsPolicy(WebCore::ShouldOpenExternalURLsPolicy policy) I almost thought you did not need these enums (ExternalURLsPolicy, HTMLBodyElementType) or the conversion functions to go with them. After all, you could just do e.g. static_cast<unsigned>(myWebCoreEnumValue). Deleting them would save about 70 lines of code. Of course, you do need them to guarantee the serialization format, in case the WebCore enums get reordered or something. I recommend adding a comment, else someone like me might break this as a "code cleanup." > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestBackForwardList.cpp:285 > + webkit_web_view_session_state_unref(state); OK, but this reminds me, you forgot to declare an autocleanup in WebKitAutocleanups.h. 1151624 14 mcatanzaro 2015-12-30 14:04:24 -0800 (In reply to comment #13) > #if CPU(X86_64) && COMPILER(GCC_OR_CLANG) && DEVELOPER_MODE > static_assert(sizeof(HTTPBody::Element == sizeof(Type) + > sizeof(Vector<char>) + sizeof(String) + sizeof(int64_t) + > sizeof(Optional<int64_t>) + sizeof(Optional<double>) + sizeof(String)); > #endif You would then need to put __attribute__((__packed__)) on the structs, in an #ifdef, and get an owner to OK it. Maybe check && NDEBUG as well to make sure not to slow down release builds. I think it'd be worth it, to make sure we don't miss serializing new values. > > Source/WebKit2/ChangeLog:15 > > + session state form the given WebKitWebViewSessionState. > > form -> rom form -> from 1151692 15 cgarcia 2015-12-31 00:56:22 -0800 (In reply to comment #13) > Comment on attachment 268007 [details] > Rebased to apply on current trunk > > View in context: > https://bugs.webkit.org/attachment.cgi?id=268007&action=review Thanks for the review. > This gets API approval from me, but please propose it on the mailing list > and wait a few days anyway, to give folks a chance to object, even though > probably nobody will. Well, we normally do it the other way around, we propose a new API and once we agree on it in the mailing list we write a patch. Once the patch is written, people can comment here about the API or the implementation. > I almost gave this r- for the messy implementation, since it took me a long > time to accept that a GVariant of type > (qa(ts(ssssasmaytt(ii)dm(sa(uaysxmxmds))av)u)mu) is really the best way to > handle this, rather than using nice C++ iostreams like in your previous > patch... but Anders is right, we can't use the IPC encoders because our > serialization would break whenever the implementation changes. We hardly > want to reimplement all the iostream encoders in this file, which is what it > would take to use iostreams safely. It's unfortunate that GVariant is so > much harder to use than iostreams, but the mess is contained into one file, > and you split it up nicely into "nested" functions. And with GVariant, we > know the serialization format is not going to change. I agree, because it also took me a long time to get this right with GVariant, which is hard to use and even more to debug for complex data like this one. > My biggest issue with this patch is that we should have some way to detect > changes to the implementation of HTTPBody, FrameState, PageState, > BackForwardListState, so that we know to update the serialization here. Well, it's not that problematic, we only read and write the members we already know about. If something new is added, I assume it would not break anything if you don't use it, I don't know. But every time that happens we will need to bump the version and support both the current one and the new one, so I hope that doesn't happen often. > Currently we can detect deletions, since we'd get a compiler error, but if > any new state is added to these classes we will miss it. I think you can > solve this using messy static_asserts and sizeof to check the size of the > structs. Something like: > > #if CPU(X86_64) && COMPILER(GCC_OR_CLANG) && DEVELOPER_MODE > static_assert(sizeof(HTTPBody::Element == sizeof(Type) + > sizeof(Vector<char>) + sizeof(String) + sizeof(int64_t) + > sizeof(Optional<int64_t>) + sizeof(Optional<double>) + sizeof(String)); > #endif > > I guess that is pretty messy, though. Yes. I would rather create a watchlist rule to watch patches changing SessionState.h :-P > > Source/WebKit2/ChangeLog:15 > > + session state form the given WebKitWebViewSessionState. > > form -> rom Oops. > > Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp:3754 > > + getPage(webView)->restoreFromSessionState(webkitWebViewSessionStatateGetSessionState(state), false); > > You need to fix this typo all over. > webkitWebViewSessionStatateGetSessionState -> > webkitWebViewSessionStateGetSessionState :-D > > Source/WebKit2/UIProcess/API/gtk/WebKitWebViewSessionState.cpp:59 > > +static inline unsigned toExternalURLsPolicy(WebCore::ShouldOpenExternalURLsPolicy policy) > > I almost thought you did not need these enums (ExternalURLsPolicy, > HTMLBodyElementType) or the conversion functions to go with them. After all, > you could just do e.g. static_cast<unsigned>(myWebCoreEnumValue). Deleting > them would save about 70 lines of code. Of course, you do need them to > guarantee the serialization format, in case the WebCore enums get reordered > or something. I recommend adding a comment, else someone like me might break > this as a "code cleanup." Ok. > > Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestBackForwardList.cpp:285 > > + webkit_web_view_session_state_unref(state); > > OK, but this reminds me, you forgot to declare an autocleanup in > WebKitAutocleanups.h. Yep, we should update http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API to suggest adding autoptrs for new public objects/boxed types. 1151695 16 mcatanzaro 2015-12-31 06:42:13 -0800 (In reply to comment #15) > Well, we normally do it the other way around, we propose a new API and once > we agree on it in the mailing list we write a patch. Once the patch is > written, people can comment here about the API or the implementation. I would post it anyway; I'm pretty sure this API is ideal, but you never know if someone might suggest an improvement. > > I almost gave this r- for the messy implementation, since it took me a long > > time to accept that a GVariant of type > > (qa(ts(ssssasmaytt(ii)dm(sa(uaysxmxmds))av)u)mu) is really the best way to > > handle this, rather than using nice C++ iostreams like in your previous > > patch... To be clear, this is nuts, but I can't think of any better way to do it, and I really want the API. ;) > Yes. I would rather create a watchlist rule to watch patches changing > SessionState.h :-P OK, that's fine too. > Yep, we should update > http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API to suggest adding > autoptrs for new public objects/boxed types. Done. 1152133 17 mcatanzaro 2016-01-03 11:12:13 -0800 *** Bug 69358 has been marked as a duplicate of this bug. *** 1152320 18 268007 mrobinson 2016-01-04 08:17:14 -0800 Comment on attachment 268007 Rebased to apply on current trunk The API looks good to me as well. 1152671 19 cgarcia 2016-01-05 00:13:24 -0800 Committed r194579: <http://trac.webkit.org/changeset/194579> 261304 2015-09-16 05:00:12 -0700 2015-12-07 12:50:38 -0800 Patch bug-115600-20150916215959.patch text/plain 6825 sam U3VidmVyc2lvbiBSZXZpc2lvbjogMTg4NjM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYjE5ZWVkMTZiOWFmY2Fi YmUyMzg5M2I1NjI0OGJmODQyMjM3Zjc3Ni4uZmViMDEzMjdhMjY3ZjFlODEzOTc2Y2M4YjdkYjQz Yzc2OWEzNDUwYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDE1LTA5LTE2ICBTYW0g UGFya2luc29uICA8c2FtLnBhcmtpbnNvbjNAZ21haWwuY29tPgorCisgICAgICAgIFtHVEtdIEFs bG93IHRvIHNhdmUgYW5kIHJlc3RvcmUgc2Vzc2lvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE1NjAwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgV2ViS2l0MSBhcGkgcHJldmlvdXNseSBhbGxvd2VkIGZv ciBkaXJlY3QgY29udHJvbCBvZiB0aGUgYmFjayBmb3J3YXJkIGxpc3QuICBIb3dldmVyLCBpbgor ICAgICAgICBXZWJLaXQyIHRoaXMgaGFzIGJlZW4gcmVwbGFjZWQgd2l0aCB0aGUgc2Vzc2lvbiBz dGF0ZSBhcGlzLCB3aGljaCBoYXZlIG5vdCB5ZXQgYmVlbiBhZGRlZAorICAgICAgICB0byB0aGUg R3RrIGJpbmRpbmdzLiAgVGhpcyBjb21taXQgZXhwb3NlZCB0aGVtIHRocm91Z2ggZXhwb3J0aW5n IGEgc2VyYWxpemVkIGJ1ZmZlciwgaW4KKyAgICAgICAgdGhlIHNwaXJpdCBvZiBkaXNjb3VyYWdp bmcgYXBwcyBlZGl0aW5nIHRoZSBzdGF0ZSBhbmQgY2F1c2luZyBidWdzLgorCisgICAgICAgICog U2hhcmVkL1Nlc3Npb25TdGF0ZS5jcHA6IEFkZCBmdW5jdGlvbnMgc2VyaWFsaXplIHdob2xlIHNl c3Npb24gc3RhdGUgc3RydWN0LgorICAgICAgICAoV2ViS2l0OjpTZXNzaW9uU3RhdGU6OmVuY29k ZSk6CisgICAgICAgIChXZWJLaXQ6OlNlc3Npb25TdGF0ZTo6ZGVjb2RlKToKKyAgICAgICAgKiBT aGFyZWQvU2Vzc2lvblN0YXRlLmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0 V2ViVmlldy5jcHA6IEFkZCB3cmFwcGVycyB0byBleHBvcnQgYW5kIGxvYWQgc2VyaWFsaXplZCBk YXRhLgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3NlcmlhbGl6ZV9zZXNzaW9uKToKKyAgICAg ICAgKHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb24pOgorICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dDoKKwogMjAxNS0wOC0xOCAgWmFuIERvYmVy c2VrICA8emRvYmVyc2VrQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dMaWJdIEdNYWluTG9vcFNv dXJjZSBzaG91bGQgcmVjZWl2ZSB0aGUgc3RkOjpmdW5jdGlvbjw+IG9iamVjdHMgdGhyb3VnaCBy dmFsdWUgcmVmZXJlbmNlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1Nlc3Np b25TdGF0ZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvU2Vzc2lvblN0YXRlLmNwcAppbmRl eCAxY2QyZDliZmY1YWIwYmI4NDVhMGE1NDlhODFhYjFmMTU2M2U1NzYwLi42MTZlYzcwZWI2NzUz MTJmY2M4Y2VkNWFlZWNhYjhjODFmOGZmZGY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvU2Vzc2lvblN0YXRlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvU2Vzc2lv blN0YXRlLmNwcApAQCAtMjI5LDQgKzIyOSwyMyBAQCBib29sIEJhY2tGb3J3YXJkTGlzdFN0YXRl OjpkZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIsIEJhY2tGb3J3YXJkTGlzdAog ICAgIHJldHVybiB0cnVlOwogfQogCit2b2lkIFNlc3Npb25TdGF0ZTo6ZW5jb2RlKElQQzo6QXJn dW1lbnRFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIgPDwgYmFja0Zvcndh cmRMaXN0U3RhdGU7CisgICAgZW5jb2RlciA8PCByZW5kZXJUcmVlU2l6ZTsKKyAgICBlbmNvZGVy IDw8IHByb3Zpc2lvbmFsVVJMOworfQorCitib29sIFNlc3Npb25TdGF0ZTo6ZGVjb2RlKElQQzo6 QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBTZXNzaW9uU3RhdGUmIHJlc3VsdCkKK3sKKyAgICBp ZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5iYWNrRm9yd2FyZExpc3RTdGF0ZSkpCisgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5yZW5kZXJUcmVl U2l6ZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJl c3VsdC5wcm92aXNpb25hbFVSTCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVy biB0cnVlOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1NoYXJlZC9TZXNzaW9uU3RhdGUuaCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9TZXNz aW9uU3RhdGUuaAppbmRleCA3MzVhOWMzMmVmZGViNjUxY2Y0Y2FmOTMwODM5NDY4MGVhYjMyOTA1 Li4wNTk4NjdhMmY3M2ZmZGI2NDVmOTAyN2QyMjE1YzU1ZjdkNDQzY2I3IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9TaGFyZWQvU2Vzc2lvblN0YXRlLmgKKysrIGIvU291cmNlL1dlYktpdDIv U2hhcmVkL1Nlc3Npb25TdGF0ZS5oCkBAIC0xNDMsNiArMTQzLDkgQEAgc3RydWN0IEJhY2tGb3J3 YXJkTGlzdFN0YXRlIHsKIH07CiAKIHN0cnVjdCBTZXNzaW9uU3RhdGUgeworICAgIHZvaWQgZW5j b2RlKElQQzo6QXJndW1lbnRFbmNvZGVyJikgY29uc3Q7CisgICAgc3RhdGljIGJvb2wgZGVjb2Rl KElQQzo6QXJndW1lbnREZWNvZGVyJiwgU2Vzc2lvblN0YXRlJik7CisKICAgICBCYWNrRm9yd2Fy ZExpc3RTdGF0ZSBiYWNrRm9yd2FyZExpc3RTdGF0ZTsKICAgICB1aW50NjRfdCByZW5kZXJUcmVl U2l6ZTsKICAgICBXZWJDb3JlOjpVUkwgcHJvdmlzaW9uYWxVUkw7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcCBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuY3BwCmluZGV4IDAzMjI1ZGE4 OTMyNmNjOTI1Yzc5ZTA0YzYwNTZhMTcyMjM0NTE3OWYuLmJkNzE3M2I1NTdlYzg4MWRlMDNlNGE5 ZGYxYzk1OGFjMDkxNGJiYTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXcuY3BwCkBAIC0zNzEyLDMgKzM3MTIsNTYgQEAgV2ViS2l0RWRp dG9yU3RhdGUqIHdlYmtpdF93ZWJfdmlld19nZXRfZWRpdG9yX3N0YXRlKFdlYktpdFdlYlZpZXcg KndlYlZpZXcpCiAKICAgICByZXR1cm4gd2ViVmlldy0+cHJpdi0+ZWRpdG9yU3RhdGUuZ2V0KCk7 CiB9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3NlcmlhbGl6ZV9zZXNzaW9uCisgKiBAd2Vi X3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAqCisgKiBTYXZlcyB0aGUgc2Vzc2lvbiBvZiBhIEB3 ZWJfdmlldyB0byBhIGJ1ZmZlciB0byBiZSByZXN0b3JlZCBsYXRlci4gIFRoZQorICogZGF0YSBz ZXJpYWxpemVkIGluY2x1ZGVzIHRoZSBAd2ViX3ZpZXcgaGlzdG9yeSBhbmQgdGhlIHByb3Zpc2lv bmFsIFVSTAorICogYW1vbmcgb3RoZXIgaXRlbXMuCisgKgorICogUmV0dXJuczogKHRyYW5zZmVy IG5vbmUpOiBBIEdCeXRlcyBidWZmZXIgY29udGFpbmluZyB0aGUgc3RhdGUsIG9yIE5VTEwuCisg KgorICogU2luY2U6IDIuMTAKKyAqLworR0J5dGVzKiB3ZWJraXRfd2ViX3ZpZXdfc2VyaWFsaXpl X3Nlc3Npb24oV2ViS2l0V2ViVmlldyAqd2ViVmlldykKK3sKKyAgICBnX3JldHVybl92YWxfaWZf ZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldyksIE5VTEwpOworCisgICAgV2ViUGFnZVBy b3h5KiBwYWdlID0gZ2V0UGFnZSh3ZWJWaWV3KTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCgh IXBhZ2UsIE5VTEwpOworCisgICAgU2Vzc2lvblN0YXRlIHggPSBwYWdlLT5zZXNzaW9uU3RhdGUo MCk7CisgICAgSVBDOjpBcmd1bWVudEVuY29kZXIqIGVuY29kZXIgPSBuZXcgSVBDOjpBcmd1bWVu dEVuY29kZXI7CisgICAgeC5lbmNvZGUoKmVuY29kZXIpOworCisgICAgR0J5dGVzKiBidWYgPSBn X2J5dGVzX25ld190YWtlKGVuY29kZXItPmJ1ZmZlcigpLCBlbmNvZGVyLT5idWZmZXJTaXplKCkp OworICAgIHJldHVybiBidWY7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVf c2Vzc2lvbgorICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKiBAc3RhdGU6IGEgI0dC eXRlcyByZXR1cm5lZCBmcm9tIHdlYmtpdF93ZWJfdmlld19zZXJpYWxpemVfc2Vzc2lvbigpCisg KiBAbmF2aWdhdGU6IGEgI2dib29sZWFuIHRoYXQgaWYgI1RSVUUgd2lsbCB0cmlnZ2VyIG5hdmln YXRpb24gdG8gdGhlIHNpdGUgc2V0IGluIHRoZSBzdGF0ZQorICoKKyAqIFJlc3RvcmUgc2Vzc2lv biBzdGF0ZSBzZXJpYWxpemVkIGJ5IHdlYmtpdF93ZWJfdmlld19zZXJpYWxpemVfc2Vzc2lvbigp LgorICoKKyAqIFNpbmNlOiAyLjEwCisgKi8KK3ZvaWQgd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVf c2Vzc2lvbihXZWJLaXRXZWJWaWV3ICp3ZWJWaWV3LCBHQnl0ZXMgKnN0YXRlLCBnYm9vbGVhbiBu YXZpZ2F0ZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJW aWV3KSk7CisKKyAgICBXZWJQYWdlUHJveHkqIHBhZ2UgPSBnZXRQYWdlKHdlYlZpZXcpOworICAg IGdfcmV0dXJuX2lmX2ZhaWwoISFwYWdlKTsKKworICAgIGdzaXplIHNpemUgPSBnX2J5dGVzX2dl dF9zaXplKHN0YXRlKTsKKyAgICBJUEM6OkFyZ3VtZW50RGVjb2RlciogZGVjb2RlciA9IG5ldyBJ UEM6OkFyZ3VtZW50RGVjb2RlcigKKyAgICAgICAgKHVpbnQ4X3QgKikgZ19ieXRlc19nZXRfZGF0 YShzdGF0ZSwgJnNpemUpLCBzaXplKTsKKworICAgIFNlc3Npb25TdGF0ZSBzZXNzaW9uX3N0YXRl OworICAgIHNlc3Npb25fc3RhdGUuZGVjb2RlKCpkZWNvZGVyLCBzZXNzaW9uX3N0YXRlKTsKKyAg ICBwYWdlLT5yZXN0b3JlRnJvbVNlc3Npb25TdGF0ZShzZXNzaW9uX3N0YXRlLCBuYXZpZ2F0ZSk7 Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJWaWV3LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3 LmgKaW5kZXggOGRiOTY4NjA5OWUxNzM1ZTZiZWUyNmIxOWVmODY4MzhiNGIyYjY2ZS4uMWE4ZTM4 ZDQ0MTFkZTg3NWY4NDU0MDc2Mjc1NDZhOGYzMWM5N2VlOSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5oCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaApAQCAtNTAyLDYgKzUwMiwxNCBA QCB3ZWJraXRfd2ViX3ZpZXdfc2V0X2VkaXRhYmxlICAgICAgICAgICAgICAgICAgICAgICAgIChX ZWJLaXRXZWJWaWV3CiBXRUJLSVRfQVBJIFdlYktpdEVkaXRvclN0YXRlICoKIHdlYmtpdF93ZWJf dmlld19nZXRfZWRpdG9yX3N0YXRlICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcg ICAgICAgICAgICAgKndlYl92aWV3KTsKIAorV0VCS0lUX0FQSSBHQnl0ZXMgKgord2Via2l0X3dl Yl92aWV3X3NlcmlhbGl6ZV9zZXNzaW9uICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmll dyAgICAgICAgICAgICAqd2ViX3ZpZXcpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJf dmlld19yZXN0b3JlX3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcg ICAgICAgICAgICAgKndlYl92aWV3LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgR0J5dGVzICAgICAgICAgICAgICAgICAgICAqc3RhdGUsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnYm9v bGVhbiAgICAgICAgICAgICAgICAgIG5hdmlnYXRlKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlm CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtp dDJndGstNC4wLXNlY3Rpb25zLnR4dCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3Rr L2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CmluZGV4IDMyNzQ5OTUwMzEzYzJmYjBi MjBlMTMyZTA3MTIyYjNjZWYzY2NlNWEuLjU2YWUzMWU4YjZhODI5ZmIzOTA5YzAzMzhmOTM2Mjgx Yzk3YTYxODQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2Rv Y3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CkBAIC0yMTEsNiAr MjExLDggQEAgd2Via2l0X3dlYl92aWV3X2dldF9iYWNrZ3JvdW5kX2NvbG9yCiB3ZWJraXRfd2Vi X3ZpZXdfc2V0X2VkaXRhYmxlCiB3ZWJraXRfd2ViX3ZpZXdfaXNfZWRpdGFibGUKIHdlYmtpdF93 ZWJfdmlld19nZXRfZWRpdG9yX3N0YXRlCit3ZWJraXRfd2ViX3ZpZXdfc2VyaWFsaXplX3Nlc3Np b24KK3dlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb24KIAogPFNVQlNFQ1RJT04gV2ViS2l0 SmF2YXNjcmlwdFJlc3VsdD4KIFdlYktpdEphdmFzY3JpcHRSZXN1bHQK 266798 2015-12-07 12:50:38 -0800 2015-12-30 09:59:50 -0800 Patch wk2-session-state.diff text/plain 21562 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCA1MjQ2ZjI3Li5iOWM5NDI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMzcg QEAKIDIwMTUtMTItMDcgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgogCisgICAgICAgIFtHVEtdIEFsbG93IHRvIHNhdmUgYW5kIHJlc3RvcmUgc2Vzc2lvbgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE1NjAwCisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIG5ldyBBUEkg dG8gZ2V0IGFuZCByZXNvcmUgdGhlIHdlYiB2aWV3IHNlc3Npb24gc3RhdGUuCisKKyAgICAgICAg KiBQbGF0Zm9ybUdUSy5jbWFrZTogQWRkIG5ldyBmaWxlcyB0byBjb21waWxhdGlvbi4KKyAgICAg ICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcDoKKyAgICAgICAgKHdlYmtp dF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSk6IENyZWF0ZSBhIG5ldworICAgICAgICBXZWJL aXRXZWJWaWV3U2Vzc2lvblN0YXRlIHJlcHJlc2VudGluZyB0aGUgY3VycmVudCBzZXNzaW9uIHN0 YXRlLgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSk6IFJl c3RvcmVzIHRoZSB3ZSB2aWV3CisgICAgICAgIHNlc3Npb24gc3RhdGUgZm9ybSB0aGUgZ2l2ZW4g V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJWaWV3Lmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmll d1Nlc3Npb25TdGF0ZS5jcHA6IEFkZGVkLgorICAgICAgICAoX1dlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGU6Ol9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKToKKyAgICAgICAgKHdlYmtpdFdlYlZp ZXdTZXNzaW9uU3RhdGVDcmVhdGUpOgorICAgICAgICAod2Via2l0V2ViVmlld1Nlc3Npb25TdGF0 YXRlR2V0U2Vzc2lvblN0YXRlKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0 YXRlX25ldyk6IENyZWF0ZSBhCisgICAgICAgIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgZnJv bSBzZXJpYWxpemVkIGRhdGEuCisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0 ZV9yZWYpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYpOgor ICAgICAgICAod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKTogU2VyaWFs aXplIHRoZQorICAgICAgICBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLgorICAgICAgICAqIFVJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaDogQWRkZWQuCisgICAg ICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUu aDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQu MC1zZWN0aW9ucy50eHQ6IEFkZCBuZXcgc3ltYm9scy4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJ L2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLnR5cGVzOiBBZGQgd2Via2l0X3dlYl92aWV3X3Nlc3Np b25fc3RhdGVfZ2V0X3R5cGUuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5o OiBJbmNsdWRlIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaC4KKworMjAxNS0xMi0wNyAgQ2Fy bG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKICAgICAgICAgW0dUS10g QWRkIFdlYktpdFdlYlBhZ2U6OmNvbnNvbGUtbWVzc2FnZS1zZW50IHNpZ25hbCB0byBXZWIgRXh0 ZW5zaW9ucyBBUEkKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTc5OTE4CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtl IGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggOGYxNzE3Zi4uMmIyYWE4 NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291 cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTI2Myw2ICsyNjMsOSBAQCBsaXN0KEFQ UEVORCBXZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3 QmFzZUFjY2Vzc2libGUuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNl UHJpdmF0ZS5oCiAgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1ByaXZhdGUuaAor ICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuY3BwCisgICAg VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5oCisgICAgVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaAogICAgIFVJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhTWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYnNpdGVEYXRhTWFuYWdlclByaXZhdGUuaApAQCAtNDI4LDYgKzQzMSw3IEBAIHNl dChXZWJLaXQyR1RLX0lOU1RBTExFRF9IRUFERVJTCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViUmVzb3VyY2UuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmgKKyAgICAke1dFQktJVDJfRElSfS9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKICAgICAke1dFQktJVDJfRElS fS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuaAogICAgICR7V0VC S0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdpbmRvd1Byb3BlcnRpZXMuaAogICAg ICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCBiYzlh YzNkLi4xZGYxNGQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3LmNwcApAQCAtNjEsNiArNjEsNyBAQAogI2luY2x1ZGUgIldlYktpdFdl YlJlc291cmNlUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5o IgogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRXaW5kb3dQcm9wZXJ0 aWVzUHJpdmF0ZS5oIgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KICNpbmNs dWRlIDxXZWJDb3JlL0NlcnRpZmljYXRlSW5mby5oPgpAQCAtMzY2OCwzICszNjY5LDM4IEBAIFdl YktpdEVkaXRvclN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2VkaXRvcl9zdGF0ZShXZWJLaXRX ZWJWaWV3ICp3ZWJWaWV3KQogCiAgICAgcmV0dXJuIHdlYlZpZXctPnByaXYtPmVkaXRvclN0YXRl LmdldCgpOwogfQorCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZToK KyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICoKKyAqIEdldHMgdGhlIGN1cnJlbnQg c2Vzc2lvbiBzdGF0ZSBvZiBAd2ViX3ZpZXcKKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVs bCk6IGEgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICov CitXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25f c3RhdGUoV2ViS2l0V2ViVmlldyogd2ViVmlldykKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldyksIG51bGxwdHIpOworCisgICAgU2Vzc2lvblN0 YXRlIHNlc3Npb25TdGF0ZSA9IGdldFBhZ2Uod2ViVmlldyktPnNlc3Npb25TdGF0ZShudWxscHRy KTsKKyAgICByZXR1cm4gd2Via2l0V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXVEY6Om1vdmUo c2Vzc2lvblN0YXRlKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vz c2lvbl9zdGF0ZToKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICogQHN0YXRlOiBh ICNXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogUmVzdG9yZSB0aGUgQHdlYl92aWV3 IHNlc3Npb24gc3RhdGUgZnJvbSBAc3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICovCit2b2lk IHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUoV2ViS2l0V2ViVmlldyogd2Vi VmlldywgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogc3RhdGUpCit7CisgICAgZ19yZXR1cm5f aWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldykpOworICAgIGdfcmV0dXJuX2lmX2Zh aWwoc3RhdGUpOworCisgICAgZ2V0UGFnZSh3ZWJWaWV3KS0+cmVzdG9yZUZyb21TZXNzaW9uU3Rh dGUod2Via2l0V2ViVmlld1Nlc3Npb25TdGF0YXRlR2V0U2Vzc2lvblN0YXRlKHN0YXRlKSwgZmFs c2UpOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViVmlldy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlldy5oCmluZGV4IDhkYjk2ODYuLjM2ZmQ0YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmgKQEAgLTUyLDYgKzUyLDcgQEAKICNpbmNs dWRlIDx3ZWJraXQyL1dlYktpdFdlYkluc3BlY3Rvci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2Vi S2l0V2ViUmVzb3VyY2UuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYlZpZXdCYXNlLmg+ CisjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmg+CiAjaW5jbHVk ZSA8d2Via2l0Mi9XZWJLaXRXaW5kb3dQcm9wZXJ0aWVzLmg+CiAKIEdfQkVHSU5fREVDTFMKQEAg LTUwMiw2ICs1MDMsMTMgQEAgd2Via2l0X3dlYl92aWV3X3NldF9lZGl0YWJsZSAgICAgICAgICAg ICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldwogV0VCS0lUX0FQSSBXZWJLaXRFZGl0b3JTdGF0 ZSAqCiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2VkaXRvcl9zdGF0ZSAgICAgICAgICAgICAgICAgICAg IChXZWJLaXRXZWJWaWV3ICAgICAgICAgICAgICp3ZWJfdmlldyk7CiAKK1dFQktJVF9BUEkgV2Vi S2l0V2ViVmlld1Nlc3Npb25TdGF0ZSAqCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3Rh dGUgICAgICAgICAgICAgICAgICAgIChXZWJLaXRXZWJWaWV3ICAgICAgICAgICAgICp3ZWJfdmll dyk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9z dGF0ZSAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBX ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICpzdGF0ZSk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRp ZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwLi4wMGU4ZmU3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5jcHAKQEAgLTAsMCArMSwxMzcg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBz ZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIldlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaCIKKworI2luY2x1ZGUg IkFyZ3VtZW50RGVjb2Rlci5oIgorI2luY2x1ZGUgIkFyZ3VtZW50RW5jb2Rlci5oIgorI2luY2x1 ZGUgIldlYkNvcmVBcmd1bWVudENvZGVycy5oIgorI2luY2x1ZGUgIldlYktpdFdlYlZpZXdTZXNz aW9uU3RhdGVQcml2YXRlLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7CisKK3N0cnVjdCBf V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSB7CisgICAgX1dlYktpdFdlYlZpZXdTZXNzaW9uU3Rh dGUoU2Vzc2lvblN0YXRlJiYgc3RhdGUpCisgICAgICAgIDogc2Vzc2lvblN0YXRlKFdURjo6bW92 ZShzdGF0ZSkpCisgICAgICAgICwgcmVmZXJlbmNlQ291bnQoMSkKKyAgICB7CisgICAgfQorCisg ICAgU2Vzc2lvblN0YXRlIHNlc3Npb25TdGF0ZTsKKyAgICBpbnQgcmVmZXJlbmNlQ291bnQ7Cit9 OworCitHX0RFRklORV9CT1hFRF9UWVBFKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUsIHdlYmtp dF93ZWJfdmlld19zZXNzaW9uX3N0YXRlLCB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9y ZWYsIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmKQorCitXZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlKiB3ZWJraXRXZWJWaWV3U2Vzc2lvblN0YXRlQ3JlYXRlKFNlc3Npb25TdGF0 ZSYmIHNlc3Npb25TdGF0ZSkKK3sKKyAgICBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0 ZSA9IHN0YXRpY19jYXN0PFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqPihmYXN0TWFsbG9jKHNp emVvZihXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKSkpOworICAgIG5ldyAoc3RhdGUpIFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGUoV1RGOjptb3ZlKHNlc3Npb25TdGF0ZSkpOworICAgIHJldHVy biBzdGF0ZTsKK30KKworY29uc3QgU2Vzc2lvblN0YXRlJiB3ZWJraXRXZWJWaWV3U2Vzc2lvblN0 YXRhdGVHZXRTZXNzaW9uU3RhdGUoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogc3RhdGUpCit7 CisgICAgcmV0dXJuIHN0YXRlLT5zZXNzaW9uU3RhdGU7Cit9CisKKy8qKgorICogd2Via2l0X3dl Yl92aWV3X3Nlc3Npb25fc3RhdGVfbmV3OgorICogQGRhdGE6IGEgI0dCeXRlcworICoKKyAqIENy ZWF0ZXMgYSBuZXcgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgZnJvbSBzZXJhbGl6ZWQgZGF0 YS4KKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVsbCk6IGEgbmV3ICNXZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlLCBvciAlTlVMTCBpZiBAZGF0YSBkb2Vzbid0IGNvbnRhaW4gYQorICogICAg IHZhbGlkIHNlcmlhbGl6ZWQgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuCisgKgorICogU2lu Y2U6IDIuMTIKKyAqLworV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogd2Via2l0X3dlYl92aWV3 X3Nlc3Npb25fc3RhdGVfbmV3KEdCeXRlcyogZGF0YSkKK3sKKyAgICBnc2l6ZSBkYXRhU2l6ZTsK KyAgICBjb25zdCBhdXRvKiBkYXRhUHRyID0gc3RhdGljX2Nhc3Q8Y29uc3QgdWludDhfdCo+KGdf Ynl0ZXNfZ2V0X2RhdGEoZGF0YSwgJmRhdGFTaXplKSk7CisgICAgSVBDOjpBcmd1bWVudERlY29k ZXIgZGVjb2RlcihkYXRhUHRyLCBkYXRhU2l6ZSk7CisgICAgU2Vzc2lvblN0YXRlIHNlc3Npb25T dGF0ZTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHNlc3Npb25TdGF0ZS5iYWNrRm9yd2FyZExp c3RTdGF0ZSkpCisgICAgICAgIHJldHVybiBudWxscHRyOworICAgIGlmICghZGVjb2Rlci5kZWNv ZGUoc2Vzc2lvblN0YXRlLnJlbmRlclRyZWVTaXplKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7 CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShzZXNzaW9uU3RhdGUucHJvdmlzaW9uYWxVUkwpKQor ICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAgIHJldHVybiB3ZWJraXRXZWJWaWV3U2Vzc2lv blN0YXRlQ3JlYXRlKFdURjo6bW92ZShzZXNzaW9uU3RhdGUpKTsKK30KKworLyoqCisgKiB3ZWJr aXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9yZWY6CisgKiBAc3RhdGU6IGEgI1dlYktpdFdlYlZp ZXdTZXNzaW9uU3RhdGUKKyAqCisgKiBBdG9taWNhbGx5IGluY3JlbWVudHMgdGhlIHJlZmVyZW5j ZSBjb3VudCBvZiBAc3RhdGUgYnkgb25lLiBUaGlzCisgKiBmdW5jdGlvbiBpcyBNVC1zYWZlIGFu ZCBtYXkgYmUgY2FsbGVkIGZyb20gYW55IHRocmVhZC4KKyAqCisgKiBSZXR1cm5zOiBUaGUgcGFz c2VkIGluICNXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogU2luY2U6IDIuMTIKKyAq LworV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3Rh dGVfcmVmKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHN0YXRlKQoreworICAgIGdfcmV0dXJu X3ZhbF9pZl9mYWlsKHN0YXRlLCBudWxscHRyKTsKKyAgICBnX2F0b21pY19pbnRfaW5jKCZzdGF0 ZS0+cmVmZXJlbmNlQ291bnQpOworICAgIHJldHVybiBzdGF0ZTsKK30KKworLyoqCisgKiB3ZWJr aXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV91bnJlZjoKKyAqIEBzdGF0ZTogYSAjV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZQorICoKKyAqIEF0b21pY2FsbHkgZGVjcmVtZW50cyB0aGUgcmVmZXJl bmNlIGNvdW50IG9mIEBzdGF0ZSBieSBvbmUuIElmIHRoZQorICogcmVmZXJlbmNlIGNvdW50IGRy b3BzIHRvIDAsIGFsbCBtZW1vcnkgYWxsb2NhdGVkIGJ5IHRoZSAjV2ViS2l0V2ViVmlld1Nlc3Np b25TdGF0ZSBpcworICogcmVsZWFzZWQuIFRoaXMgZnVuY3Rpb24gaXMgTVQtc2FmZSBhbmQgbWF5 IGJlIGNhbGxlZCBmcm9tIGFueSB0aHJlYWQuCisgKgorICogU2luY2U6IDIuMTIKKyAqLwordm9p ZCB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV91bnJlZihXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlKiBzdGF0ZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKHN0YXRlKTsKKyAgICBpZiAo Z19hdG9taWNfaW50X2RlY19hbmRfdGVzdCgmc3RhdGUtPnJlZmVyZW5jZUNvdW50KSkgeworICAg ICAgICBzdGF0ZS0+fldlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUoKTsKKyAgICAgICAgZmFzdEZy ZWUoc3RhdGUpOworICAgIH0KK30KKworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9z dGF0ZV9zZXJpYWxpemU6CisgKiBAc3RhdGU6IGEgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUK KyAqCisgKiBTZXJpYWxpemVzIGEgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuCisgKgorICog UmV0dXJuczogKHRyYW5zZmVyIGZ1bGwpOiBhICNHQnl0ZXMgY29udGFpbmluZyB0aGUgQHN0YXRl IHNlcmlhbGl6ZWQuCisgKgorICogU2luY2U6IDIuMTIKKyAqLworR0J5dGVzKiB3ZWJraXRfd2Vi X3ZpZXdfc2Vzc2lvbl9zdGF0ZV9zZXJpYWxpemUoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSog c3RhdGUpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoc3RhdGUsIG51bGxwdHIpOworICAg IElQQzo6QXJndW1lbnRFbmNvZGVyIGVuY29kZXI7CisgICAgZW5jb2RlciA8PCBzdGF0ZS0+c2Vz c2lvblN0YXRlLmJhY2tGb3J3YXJkTGlzdFN0YXRlOworICAgIGVuY29kZXIgPDwgc3RhdGUtPnNl c3Npb25TdGF0ZS5yZW5kZXJUcmVlU2l6ZTsKKyAgICBlbmNvZGVyIDw8IHN0YXRlLT5zZXNzaW9u U3RhdGUucHJvdmlzaW9uYWxVUkw7CisgICAgcmV0dXJuIGdfYnl0ZXNfbmV3KGVuY29kZXIuYnVm ZmVyKCksIGVuY29kZXIuYnVmZmVyU2l6ZSgpKTsKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xYjM4OTkyCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Np b25TdGF0ZS5oCkBAIC0wLDAgKzEsNTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgSWdh bGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFu a2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0Eu CisgKi8KKworI2lmICFkZWZpbmVkKF9fV0VCS0lUMl9IX0lOU0lERV9fKSAmJiAhZGVmaW5lZChX RUJLSVQyX0NPTVBJTEFUSU9OKQorI2Vycm9yICJPbmx5IDx3ZWJraXQyL3dlYmtpdDIuaD4gY2Fu IGJlIGluY2x1ZGVkIGRpcmVjdGx5LiIKKyNlbmRpZgorCisjaWZuZGVmIFdlYktpdFdlYlZpZXdT ZXNzaW9uU3RhdGVfaAorI2RlZmluZSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlX2gKKworI2lu Y2x1ZGUgPGdsaWItb2JqZWN0Lmg+CisjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXREZWZpbmVzLmg+ CisKK0dfQkVHSU5fREVDTFMKKworI2RlZmluZSBXRUJLSVRfVFlQRV9XRUJfVklFV19TRVNTSU9O X1NUQVRFICh3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9nZXRfdHlwZSgpKQorCit0eXBl ZGVmIHN0cnVjdCBfV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSBXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlOworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0 ZV9nZXRfdHlwZSAgKHZvaWQpOworCitXRUJLSVRfQVBJIFdlYktpdFdlYlZpZXdTZXNzaW9uU3Rh dGUgKgord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfbmV3ICAgICAgIChHQnl0ZXMgKmRh dGEpOworCitXRUJLSVRfQVBJIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgKgord2Via2l0X3dl Yl92aWV3X3Nlc3Npb25fc3RhdGVfcmVmICAgICAgIChXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRl ICpzdGF0ZSk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3Rh dGVfdW5yZWYgICAgIChXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICpzdGF0ZSk7CisKK1dFQktJ VF9BUEkgR0J5dGVzICoKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3NlcmlhbGl6ZSAo V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSAqc3RhdGUpOworCitHX0VORF9ERUNMUworCisjZW5k aWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YlZpZXdTZXNzaW9uU3RhdGVQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlUHJpdmF0ZS5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmE2MjU1NWEKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlUHJpdmF0ZS5o CkBAIC0wLDAgKzEsMjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTUgSWdhbGlhIFMuTC4K KyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKwor I2luY2x1ZGUgIlNlc3Npb25TdGF0ZS5oIgorI2luY2x1ZGUgIldlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGUuaCIKKworI2lmbmRlZiBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlUHJpdmF0ZV9oCisj ZGVmaW5lIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGVQcml2YXRlX2gKKworV2ViS2l0V2ViVmll d1Nlc3Npb25TdGF0ZSogd2Via2l0V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXZWJLaXQ6OlNl c3Npb25TdGF0ZSYmKTsKK2NvbnN0IFdlYktpdDo6U2Vzc2lvblN0YXRlJiB3ZWJraXRXZWJWaWV3 U2Vzc2lvblN0YXRhdGVHZXRTZXNzaW9uU3RhdGUoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSop OworCisjZW5kaWYgLy8gV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGVfaApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQu MC1zZWN0aW9ucy50eHQgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dl YmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dAppbmRleCA3OWIxZTE0Li44MTgxYWI3IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4w LXNlY3Rpb25zLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2Nz L3dlYmtpdDJndGstNC4wLXNlY3Rpb25zLnR4dApAQCAtMjExLDYgKzIxMSw4IEBAIHdlYmtpdF93 ZWJfdmlld19nZXRfYmFja2dyb3VuZF9jb2xvcgogd2Via2l0X3dlYl92aWV3X3NldF9lZGl0YWJs ZQogd2Via2l0X3dlYl92aWV3X2lzX2VkaXRhYmxlCiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2VkaXRv cl9zdGF0ZQord2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uX3N0YXRlCit3ZWJraXRfd2ViX3Zp ZXdfcmVzdG9yZV9zZXNzaW9uX3N0YXRlCiAKIDxTVUJTRUNUSU9OIFdlYktpdEphdmFzY3JpcHRS ZXN1bHQ+CiBXZWJLaXRKYXZhc2NyaXB0UmVzdWx0CkBAIC0yMjksNiArMjMxLDEzIEBAIHdlYmtp dF9zY3JpcHRfZGlhbG9nX3Byb21wdF9nZXRfZGVmYXVsdF90ZXh0CiB3ZWJraXRfc2NyaXB0X2Rp YWxvZ19wcm9tcHRfc2V0X3RleHQKIHdlYmtpdF93ZWJfdmlld19nZXRfbWFpbl9yZXNvdXJjZQog Cis8U1VCU0VDVElPTiBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlPgorV2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZQord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfbmV3Cit3ZWJraXRfd2Vi X3ZpZXdfc2Vzc2lvbl9zdGF0ZV9yZWYKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3Vu cmVmCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9zZXJpYWxpemUKKwogPFNVQlNFQ1RJ T04gU3RhbmRhcmQ+CiBXZWJLaXRXZWJWaWV3Q2xhc3MKIFdFQktJVF9XRUJfVklFVwpAQCAtMjM5 LDExICsyNDgsMTMgQEAgV0VCS0lUX0lTX1dFQl9WSUVXX0NMQVNTCiBXRUJLSVRfV0VCX1ZJRVdf R0VUX0NMQVNTCiBXRUJLSVRfVFlQRV9KQVZBU0NSSVBUX1JFU1VMVAogV0VCS0lUX1RZUEVfU0NS SVBUX0RJQUxPRworV0VCS0lUX1RZUEVfV0VCX1ZJRVdfU0VTU0lPTl9TVEFURQogCiA8U1VCU0VD VElPTiBQcml2YXRlPgogd2Via2l0X3dlYl92aWV3X2dldF90eXBlCiB3ZWJraXRfamF2YXNjcmlw dF9yZXN1bHRfZ2V0X3R5cGUKIHdlYmtpdF9zY3JpcHRfZGlhbG9nX2dldF90eXBlCit3ZWJraXRf d2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9nZXRfdHlwZQogV2ViS2l0V2ViVmlld1ByaXZhdGUKIDwv U0VDVElPTj4KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv ZG9jcy93ZWJraXQyZ3RrLTQuMC50eXBlcyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAudHlwZXMKaW5kZXggZmVhOTVlNy4uMjYyZTA3YSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3Rr LTQuMC50eXBlcworKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dl YmtpdDJndGstNC4wLnR5cGVzCkBAIC0zMywzICszMyw0IEBAIHdlYmtpdF93ZWJzaXRlX2RhdGFf bWFuYWdlcl9nZXRfdHlwZQogd2Via2l0X2VkaXRvcl9zdGF0ZV9nZXRfdHlwZQogd2Via2l0X2lu c3RhbGxfbWlzc2luZ19tZWRpYV9wbHVnaW5zX3Blcm1pc3Npb25fcmVxdWVzdF9nZXRfdHlwZQog d2Via2l0X2NvbnNvbGVfbWVzc2FnZV9nZXRfdHlwZQord2Via2l0X3dlYl92aWV3X3Nlc3Npb25f c3RhdGVfZ2V0X3R5cGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkv Z3RrL3dlYmtpdDIuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIu aAppbmRleCBiOTVhNzYwLi4zZTQ0ZDYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL2d0ay93ZWJraXQyLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvd2Via2l0Mi5oCkBAIC03NCw2ICs3NCw3IEBACiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRXZWJSZXNvdXJjZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2ViVmlldy5oPgogI2lu Y2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2ViVmlld0Jhc2UuaD4KKyNpbmNsdWRlIDx3ZWJraXQyL1dl YktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYnNp dGVEYXRhTWFuYWdlci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2luZG93UHJvcGVydGll cy5oPgogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5k ZXggNGU2NWQxNi4uNGVkNTkyYyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rv b2xzL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDE4IEBACiAyMDE1LTEyLTA3ICBDYXJsb3MgR2FyY2lh IENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAorICAgICAgICBbR1RLXSBBbGxvdyB0byBz YXZlIGFuZCByZXN0b3JlIHNlc3Npb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTExNTYwMAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCB0ZXN0IGNhc2UgdG8gY2hlY2sgdGhlIG5ldyBzZXNzaW9uIEFQ SS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0QmFja0Zv cndhcmRMaXN0LmNwcDoKKyAgICAgICAgKHRlc3RXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKToK KyAgICAgICAgKGJlZm9yZUFsbCk6CisKKzIwMTUtMTItMDcgIENhcmxvcyBHYXJjaWEgQ2FtcG9z ICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCiAgICAgICAgIFtHVEtdIEFkZCBXZWJLaXRXZWJQYWdl Ojpjb25zb2xlLW1lc3NhZ2Utc2VudCBzaWduYWwgdG8gV2ViIEV4dGVuc2lvbnMgQVBJCiAgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03OTkxOAogCmRpZmYg LS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdEJhY2tGb3J3 YXJkTGlzdC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdEJh Y2tGb3J3YXJkTGlzdC5jcHAKaW5kZXggNjVjM2QyZC4uMjM3NjE0NiAxMDA2NDQKLS0tIGEvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2FyZExpc3QuY3Bw CisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0QmFja0Zvcndh cmRMaXN0LmNwcApAQCAtMjY0LDYgKzI2NCw2MiBAQCBzdGF0aWMgdm9pZCB0ZXN0QmFja0Zvcndh cmRMaXN0TGltaXRBbmRDYWNoZShCYWNrRm9yd2FyZExpc3RUZXN0KiB0ZXN0LCBnY29uc3Rwbwog ICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgo dGVzdC0+bV9saXN0KSwgPT0sIGtCYWNrRm9yd2FyZExpc3RMaW1pdCk7CiB9CiAKK3N0YXRpYyB2 b2lkIHRlc3RXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKEJhY2tGb3J3YXJkTGlzdFRlc3QqIHRl c3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgQ1N0cmluZyB1cmlQYWdlMSA9IGtTZXJ2ZXItPmdl dFVSSUZvclBhdGgoIi9QYWdlMSIpOworICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0Zv cndhcmRMaXN0VGVzdDo6Q3VycmVudEl0ZW0gfCBCYWNrRm9yd2FyZExpc3RUZXN0OjpBZGRlZEl0 ZW07CisgICAgdGVzdC0+bG9hZFVSSSh1cmlQYWdlMS5kYXRhKCkpOworICAgIHRlc3QtPndhaXRV bnRpbExvYWRGaW5pc2hlZCgpOworCisgICAgQ1N0cmluZyB1cmlQYWdlMiA9IGtTZXJ2ZXItPmdl dFVSSUZvclBhdGgoIi9QYWdlMiIpOworICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0Zv cndhcmRMaXN0VGVzdDo6Q3VycmVudEl0ZW0gfCBCYWNrRm9yd2FyZExpc3RUZXN0OjpBZGRlZEl0 ZW07CisgICAgdGVzdC0+bG9hZFVSSSh1cmlQYWdlMi5kYXRhKCkpOworICAgIHRlc3QtPndhaXRV bnRpbExvYWRGaW5pc2hlZCgpOworCisgICAgQ1N0cmluZyB1cmlQYWdlMyA9IGtTZXJ2ZXItPmdl dFVSSUZvclBhdGgoIi9QYWdlMyIpOworICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0Zv cndhcmRMaXN0VGVzdDo6Q3VycmVudEl0ZW0gfCBCYWNrRm9yd2FyZExpc3RUZXN0OjpBZGRlZEl0 ZW07CisgICAgdGVzdC0+bG9hZFVSSSh1cmlQYWdlMy5kYXRhKCkpOworICAgIHRlc3QtPndhaXRV bnRpbExvYWRGaW5pc2hlZCgpOworCisgICAgdGVzdC0+bV9jaGFuZ2VkRmxhZ3MgPSBCYWNrRm9y d2FyZExpc3RUZXN0OjpDdXJyZW50SXRlbTsKKyAgICB0ZXN0LT5nb0JhY2soKTsKKyAgICB0ZXN0 LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIFdlYktpdFdlYlZpZXdTZXNzaW9uU3Rh dGUqIHN0YXRlID0gd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uX3N0YXRlKHRlc3QtPm1fd2Vi Vmlldyk7CisgICAgZ19hc3NlcnQoc3RhdGUpOworCisgICAgR1JlZlB0cjxXZWJLaXRXZWJWaWV3 PiB2aWV3ID0gV0VCS0lUX1dFQl9WSUVXKHdlYmtpdF93ZWJfdmlld19uZXcoKSk7CisgICAgV2Vi S2l0QmFja0ZvcndhcmRMaXN0KiBiZkxpc3QgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9y d2FyZF9saXN0KHZpZXcuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tf Zm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJf dmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNz ZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwg PT0sIDMpOworCisgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6Y2hlY2tJdGVtKHdlYmtpdF9iYWNr X2ZvcndhcmRfbGlzdF9nZXRfbnRoX2l0ZW0oYmZMaXN0LCAtMSksICJQYWdlMSIsIHVyaVBhZ2Ux LmRhdGEoKSwgdXJpUGFnZTEuZGF0YSgpKTsKKyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjpjaGVj a0l0ZW0od2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9jdXJyZW50X2l0ZW0oYmZMaXN0KSwg IlBhZ2UyIiwgdXJpUGFnZTIuZGF0YSgpLCB1cmlQYWdlMi5kYXRhKCkpOworICAgIEJhY2tGb3J3 YXJkTGlzdFRlc3Q6OmNoZWNrSXRlbSh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X250aF9p dGVtKGJmTGlzdCwgMSksICJQYWdlMyIsIHVyaVBhZ2UzLmRhdGEoKSwgdXJpUGFnZTMuZGF0YSgp KTsKKworICAgIEdSZWZQdHI8R0J5dGVzPiBkYXRhID0gYWRvcHRHUmVmKHdlYmtpdF93ZWJfdmll d19zZXNzaW9uX3N0YXRlX3NlcmlhbGl6ZShzdGF0ZSkpOworICAgIGdfYXNzZXJ0KGRhdGEpOwor ICAgIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKKyAgICBzdGF0 ZSA9IHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX25ldyhkYXRhLmdldCgpKTsKKyAgICBn X2Fzc2VydChzdGF0ZSk7CisKKyAgICB2aWV3ID0gV0VCS0lUX1dFQl9WSUVXKHdlYmtpdF93ZWJf dmlld19uZXcoKSk7CisgICAgYmZMaXN0ID0gd2Via2l0X3dlYl92aWV3X2dldF9iYWNrX2Zvcndh cmRfbGlzdCh2aWV3LmdldCgpKTsKKyAgICBnX2Fzc2VydF9jbXB1aW50KHdlYmtpdF9iYWNrX2Zv cndhcmRfbGlzdF9nZXRfbGVuZ3RoKGJmTGlzdCksID09LCAwKTsKKyAgICB3ZWJraXRfd2ViX3Zp ZXdfcmVzdG9yZV9zZXNzaW9uX3N0YXRlKHZpZXcuZ2V0KCksIHN0YXRlKTsKKyAgICBnX2Fzc2Vy dF9jbXB1aW50KHdlYmtpdF9iYWNrX2ZvcndhcmRfbGlzdF9nZXRfbGVuZ3RoKGJmTGlzdCksID09 LCAzKTsKKyAgICB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV91bnJlZihzdGF0ZSk7CisK KyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjpjaGVja0l0ZW0od2Via2l0X2JhY2tfZm9yd2FyZF9s aXN0X2dldF9udGhfaXRlbShiZkxpc3QsIC0xKSwgIlBhZ2UxIiwgdXJpUGFnZTEuZGF0YSgpLCB1 cmlQYWdlMS5kYXRhKCkpOworICAgIEJhY2tGb3J3YXJkTGlzdFRlc3Q6OmNoZWNrSXRlbSh3ZWJr aXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2N1cnJlbnRfaXRlbShiZkxpc3QpLCAiUGFnZTIiLCB1 cmlQYWdlMi5kYXRhKCksIHVyaVBhZ2UyLmRhdGEoKSk7CisgICAgQmFja0ZvcndhcmRMaXN0VGVz dDo6Y2hlY2tJdGVtKHdlYmtpdF9iYWNrX2ZvcndhcmRfbGlzdF9nZXRfbnRoX2l0ZW0oYmZMaXN0 LCAxKSwgIlBhZ2UzIiwgdXJpUGFnZTMuZGF0YSgpLCB1cmlQYWdlMy5kYXRhKCkpOworCisgICAg c3RhdGljIGNvbnN0IGNoYXIqIGludmFsaWRTZXNzaW9uRGF0YSA9ICJpbnZhbGlkIHNlc3Npb24g ZGF0YSI7CisgICAgZGF0YSA9IGFkb3B0R1JlZihnX2J5dGVzX25ld19zdGF0aWMoaW52YWxpZFNl c3Npb25EYXRhLCBzdHJsZW4oaW52YWxpZFNlc3Npb25EYXRhKSkpOworICAgIGdfYXNzZXJ0KCF3 ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcoZGF0YS5nZXQoKSkpOworfQorCiB2b2lk IGJlZm9yZUFsbCgpCiB7CiAgICAga1NlcnZlciA9IG5ldyBXZWJLaXRUZXN0U2VydmVyKCk7CkBA IC0yNzEsNiArMzI3LDcgQEAgdm9pZCBiZWZvcmVBbGwoKQogCiAgICAgQmFja0ZvcndhcmRMaXN0 VGVzdDo6YWRkKCJCYWNrRm9yd2FyZExpc3QiLCAibmF2aWdhdGlvbiIsIHRlc3RCYWNrRm9yd2Fy ZExpc3ROYXZpZ2F0aW9uKTsKICAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjphZGQoIkJhY2tGb3J3 YXJkTGlzdCIsICJsaXN0LWxpbWl0LWFuZC1jYWNoZSIsIHRlc3RCYWNrRm9yd2FyZExpc3RMaW1p dEFuZENhY2hlKTsKKyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjphZGQoIldlYktpdFdlYlZpZXci LCAic2Vzc2lvbi1zdGF0ZSIsIHRlc3RXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKTsKIH0KIAog dm9pZCBhZnRlckFsbCgpCg== 268006 2015-12-30 09:59:50 -0800 2015-12-30 10:21:29 -0800 Updated patch wk2-session-state.diff text/plain 41069 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggMzBlODU0Ny4uOThmMWFmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VMb2cK KysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxNS0xMi0zMCAg Q2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dU S10gQWxsb3cgdG8gc2F2ZSBhbmQgcmVzdG9yZSBzZXNzaW9uCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTU2MDAKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgR1ZhcmlhbnRJdGVyIHNwZWNpYWxpemF0 aW9uIG9mIEdVbmlxdWVQdHIuCisKKyAgICAgICAgKiB3dGYvZ2xpYi9HVHlwZWRlZnMuaDoKKyAg ICAgICAgKiB3dGYvZ2xpYi9HVW5pcXVlUHRyLmg6CisKIDIwMTUtMTItMDggIEZpbGlwIFBpemxv ICA8ZnBpemxvQGFwcGxlLmNvbT4KIAogICAgICAgICBGVEwgQjMgc2hvdWxkIGhhdmUgYmFzaWMg R2V0QnlJZCBzdXBwb3J0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dUeXBlZGVm cy5oIGIvU291cmNlL1dURi93dGYvZ2xpYi9HVHlwZWRlZnMuaAppbmRleCAxNDU5Mzc0Li41MTA1 M2MwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dUeXBlZGVmcy5oCisrKyBiL1Nv dXJjZS9XVEYvd3RmL2dsaWIvR1R5cGVkZWZzLmgKQEAgLTYxLDYgKzYxLDcgQEAgdHlwZWRlZiBz dHJ1Y3QgX0dTb2NrZXRDb25uZWN0aW9uIEdTb2NrZXRDb25uZWN0aW9uOwogdHlwZWRlZiBzdHJ1 Y3QgX0dTb3VyY2UgR1NvdXJjZTsKIHR5cGVkZWYgc3RydWN0IF9HVmFyaWFudCBHVmFyaWFudDsK IHR5cGVkZWYgc3RydWN0IF9HVmFyaWFudEJ1aWxkZXIgR1ZhcmlhbnRCdWlsZGVyOwordHlwZWRl ZiBzdHJ1Y3QgX0dWYXJpYW50SXRlciBHVmFyaWFudEl0ZXI7CiB0eXBlZGVmIHVuaW9uIF9HZGtF dmVudCBHZGtFdmVudDsKIHR5cGVkZWYgc3RydWN0IF9HVGltZXIgR1RpbWVyOwogdHlwZWRlZiBz dHJ1Y3QgX0dLZXlGaWxlIEdLZXlGaWxlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvZ2xp Yi9HVW5pcXVlUHRyLmggYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dVbmlxdWVQdHIuaAppbmRleCBi Y2ZhYTNmLi42OThlYmM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dVbmlxdWVQ dHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dVbmlxdWVQdHIuaApAQCAtNDMsNyArNDMs OCBAQCB1c2luZyBHVW5pcXVlUHRyID0gc3RkOjp1bmlxdWVfcHRyPFQsIEdQdHJEZWxldGVyPFQ+ PjsKICAgICBtYWNybyhHUGF0dGVyblNwZWMsIGdfcGF0dGVybl9zcGVjX2ZyZWUpIFwKICAgICBt YWNybyhHRGlyLCBnX2Rpcl9jbG9zZSkgXAogICAgIG1hY3JvKEdUaW1lciwgZ190aW1lcl9kZXN0 cm95KSBcCi0gICAgbWFjcm8oR0tleUZpbGUsIGdfa2V5X2ZpbGVfZnJlZSkKKyAgICBtYWNybyhH S2V5RmlsZSwgZ19rZXlfZmlsZV9mcmVlKSBcCisgICAgbWFjcm8oR1ZhcmlhbnRJdGVyLCBnX3Zh cmlhbnRfaXRlcl9mcmVlKQogCiAjZGVmaW5lIFdURl9ERUZJTkVfR1BUUl9ERUxFVEVSKHR5cGVO YW1lLCBkZWxldGVyRnVuYykgXAogICAgIHRlbXBsYXRlPD4gc3RydWN0IEdQdHJEZWxldGVyPHR5 cGVOYW1lPiBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2Uv V2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNmJkODg3ZC4uM2ZkYzNhYyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAt MSwzICsxLDQ4IEBACisyMDE1LTEyLTMwICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFA aWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBBbGxvdyB0byBzYXZlIGFuZCByZXN0b3JlIHNl c3Npb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEx NTYwMAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBuZXcgQVBJIHRvIGdldCBhbmQgcmVzb3JlIHRoZSB3ZWIgdmlldyBzZXNzaW9uIHN0YXRlLgor CisgICAgICAgICogUGxhdGZvcm1HVEsuY21ha2U6IEFkZCBuZXcgZmlsZXMgdG8gY29tcGlsYXRp b24uCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHA6CisgICAg ICAgICh3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUpOiBDcmVhdGUgYSBuZXcKKyAg ICAgICAgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSByZXByZXNlbnRpbmcgdGhlIGN1cnJlbnQg c2Vzc2lvbiBzdGF0ZS4KKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25f c3RhdGUpOiBSZXN0b3JlIHRoZSB3ZWIgdmlldworICAgICAgICBzZXNzaW9uIHN0YXRlIGZvcm0g dGhlIGdpdmVuIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9ndGsvV2ViS2l0V2ViVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuY3BwOiBBZGRlZC4KKyAgICAgICAgKF9XZWJLaXRXZWJW aWV3U2Vzc2lvblN0YXRlOjpfV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSk6CisgICAgICAgICh0 b0V4dGVybmFsVVJMc1BvbGljeSk6CisgICAgICAgICh0b1dlYkNvcmVFeHRlcm5hbFVSTHNQb2xp Y3kpOgorICAgICAgICAodG9IVE1MQm9keUVsZW1lbnRUeXBlKToKKyAgICAgICAgKHRvSFRUUEJv ZHlFbGVtZW50VHlwZSk6CisgICAgICAgIChlbmNvZGVIVFRQQm9keSk6CisgICAgICAgIChlbmNv ZGVGcmFtZVN0YXRlKToKKyAgICAgICAgKGVuY29kZVBhZ2VTdGF0ZSk6CisgICAgICAgIChlbmNv ZGVCYWNrRm9yd2FyZExpc3RJdGVtU3RhdGUpOgorICAgICAgICAoZW5jb2RlQmFja0ZvcndhcmRM aXN0U3RhdGUpOgorICAgICAgICAoZW5jb2RlU2Vzc2lvblN0YXRlKToKKyAgICAgICAgKGRlY29k ZUhUVFBCb2R5KToKKyAgICAgICAgKGRlY29kZUZyYW1lU3RhdGUpOgorICAgICAgICAoZGVjb2Rl QmFja0ZvcndhcmRMaXN0SXRlbVN0YXRlKToKKyAgICAgICAgKGRlY29kZVNlc3Npb25TdGF0ZSk6 CisgICAgICAgICh3ZWJraXRXZWJWaWV3U2Vzc2lvblN0YXRlQ3JlYXRlKToKKyAgICAgICAgKHdl YmtpdFdlYlZpZXdTZXNzaW9uU3RhdGF0ZUdldFNlc3Npb25TdGF0ZSk6CisgICAgICAgICh3ZWJr aXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcpOiBDcmVhdGUgYQorICAgICAgICBXZWJLaXRX ZWJWaWV3U2Vzc2lvblN0YXRlIGZyb20gc2VyaWFsaXplZCBkYXRhLgorICAgICAgICAod2Via2l0 X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfcmVmKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19z ZXNzaW9uX3N0YXRlX3VucmVmKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0 YXRlX3NlcmlhbGl6ZSk6IFNlcmlhbGl6ZSB0aGUgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS4K KyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmg6 IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGVQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mv d2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0OiBBZGQgbmV3IHN5bWJvbHMuCisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC50eXBlczogQWRkIHdlYmtpdF93 ZWJfdmlld19zZXNzaW9uX3N0YXRlX2dldF90eXBlLgorICAgICAgICAqIFVJUHJvY2Vzcy9BUEkv Z3RrL3dlYmtpdDIuaDogSW5jbHVkZSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmguCisKIDIw MTUtMTItMTAgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgogCiAgICAgICAg IFtDb29yZGluYXRlZEdyYXBoaWNzXSBSZXNlcnZlIGNhcGFjaXR5IGZvciB0aGUgY2hpbGRyZW4g dmVjdG9yIGluIENvb3JkaW5hdGVkR3JhcGhpY3NTY2VuZTo6c2V0TGF5ZXJDaGlsZHJlbklmTmVl ZGVkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291 cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggOGYxNzE3Zi4uMmIyYWE4NiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dl YktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTI2Myw2ICsyNjMsOSBAQCBsaXN0KEFQUEVORCBX ZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZUFj Y2Vzc2libGUuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0 ZS5oCiAgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1ByaXZhdGUuaAorICAgIFVJ UHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuY3BwCisgICAgVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5oCisgICAgVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaAogICAgIFVJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhTWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktp dFdlYnNpdGVEYXRhTWFuYWdlclByaXZhdGUuaApAQCAtNDI4LDYgKzQzMSw3IEBAIHNldChXZWJL aXQyR1RLX0lOU1RBTExFRF9IRUFERVJTCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViUmVzb3VyY2UuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXcuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFdlYlZpZXdCYXNlLmgKKyAgICAke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvQVBJ L2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKICAgICAke1dFQktJVDJfRElSfS9VSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuaAogICAgICR7V0VCS0lUMl9E SVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdpbmRvd1Byb3BlcnRpZXMuaAogICAgICR7V0VC S0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCA2YjI1YzdiLi5k NDYwNzA2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJWaWV3LmNwcApAQCAtNjEsNiArNjEsNyBAQAogI2luY2x1ZGUgIldlYktpdFdlYlJlc291 cmNlUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oIgogI2lu Y2x1ZGUgIldlYktpdFdlYlZpZXdQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZVByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJLaXRXaW5kb3dQcm9wZXJ0aWVzUHJp dmF0ZS5oIgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KICNpbmNsdWRlIDxX ZWJDb3JlL0NlcnRpZmljYXRlSW5mby5oPgpAQCAtMzcxNywzICszNzE4LDM4IEBAIFdlYktpdEVk aXRvclN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2VkaXRvcl9zdGF0ZShXZWJLaXRXZWJWaWV3 ICp3ZWJWaWV3KQogCiAgICAgcmV0dXJuIHdlYlZpZXctPnByaXYtPmVkaXRvclN0YXRlLmdldCgp OwogfQorCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZToKKyAqIEB3 ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICoKKyAqIEdldHMgdGhlIGN1cnJlbnQgc2Vzc2lv biBzdGF0ZSBvZiBAd2ViX3ZpZXcKKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVsbCk6IGEg I1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICovCitXZWJL aXRXZWJWaWV3U2Vzc2lvblN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUo V2ViS2l0V2ViVmlldyogd2ViVmlldykKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJL SVRfSVNfV0VCX1ZJRVcod2ViVmlldyksIG51bGxwdHIpOworCisgICAgU2Vzc2lvblN0YXRlIHNl c3Npb25TdGF0ZSA9IGdldFBhZ2Uod2ViVmlldyktPnNlc3Npb25TdGF0ZShudWxscHRyKTsKKyAg ICByZXR1cm4gd2Via2l0V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXVEY6Om1vdmUoc2Vzc2lv blN0YXRlKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9z dGF0ZToKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICogQHN0YXRlOiBhICNXZWJL aXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogUmVzdG9yZSB0aGUgQHdlYl92aWV3IHNlc3Np b24gc3RhdGUgZnJvbSBAc3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICovCit2b2lkIHdlYmtp dF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUoV2ViS2l0V2ViVmlldyogd2ViVmlldywg V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogc3RhdGUpCit7CisgICAgZ19yZXR1cm5faWZfZmFp bChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldykpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoc3Rh dGUpOworCisgICAgZ2V0UGFnZSh3ZWJWaWV3KS0+cmVzdG9yZUZyb21TZXNzaW9uU3RhdGUod2Vi a2l0V2ViVmlld1Nlc3Npb25TdGF0YXRlR2V0U2Vzc2lvblN0YXRlKHN0YXRlKSwgZmFsc2UpOwor fQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlldy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5o CmluZGV4IDA1ZWM5YTkuLjcwMDk2OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXcuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmgKQEAgLTUyLDYgKzUyLDcgQEAKICNpbmNsdWRlIDx3 ZWJraXQyL1dlYktpdFdlYkluc3BlY3Rvci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2Vi UmVzb3VyY2UuaD4KICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYlZpZXdCYXNlLmg+CisjaW5j bHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmg+CiAjaW5jbHVkZSA8d2Vi a2l0Mi9XZWJLaXRXaW5kb3dQcm9wZXJ0aWVzLmg+CiAKIEdfQkVHSU5fREVDTFMKQEAgLTUwNSw2 ICs1MDYsMTMgQEAgd2Via2l0X3dlYl92aWV3X3NldF9lZGl0YWJsZSAgICAgICAgICAgICAgICAg ICAgICAgICAoV2ViS2l0V2ViVmlldwogV0VCS0lUX0FQSSBXZWJLaXRFZGl0b3JTdGF0ZSAqCiB3 ZWJraXRfd2ViX3ZpZXdfZ2V0X2VkaXRvcl9zdGF0ZSAgICAgICAgICAgICAgICAgICAgIChXZWJL aXRXZWJWaWV3ICAgICAgICAgICAgICp3ZWJfdmlldyk7CiAKK1dFQktJVF9BUEkgV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZSAqCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUgICAg ICAgICAgICAgICAgICAgIChXZWJLaXRXZWJWaWV3ICAgICAgICAgICAgICp3ZWJfdmlldyk7CisK K1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSAg ICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRX ZWJWaWV3U2Vzc2lvblN0YXRlICpzdGF0ZSk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJWaWV3U2Vzc2lvblN0YXRlLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li42NWFmM2JiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQ SS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5jcHAKQEAgLTAsMCArMSw0NTIgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2Rp ZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRB QklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUK KyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhl IGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICog Qm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIldlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaCIKKworI2luY2x1ZGUgIldlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGVQcml2YXRlLmgiCisjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KKwordXNpbmcgbmFtZXNwYWNl IFdlYktpdDsKKworc3RydWN0IF9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlIHsKKyAgICBfV2Vi S2l0V2ViVmlld1Nlc3Npb25TdGF0ZShTZXNzaW9uU3RhdGUmJiBzdGF0ZSkKKyAgICAgICAgOiBz ZXNzaW9uU3RhdGUoV1RGOjptb3ZlKHN0YXRlKSkKKyAgICAgICAgLCByZWZlcmVuY2VDb3VudCgx KQorICAgIHsKKyAgICB9CisKKyAgICBTZXNzaW9uU3RhdGUgc2Vzc2lvblN0YXRlOworICAgIGlu dCByZWZlcmVuY2VDb3VudDsKK307CisKK0dfREVGSU5FX0JPWEVEX1RZUEUoV2ViS2l0V2ViVmll d1Nlc3Npb25TdGF0ZSwgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGUsIHdlYmtpdF93ZWJf dmlld19zZXNzaW9uX3N0YXRlX3JlZiwgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5y ZWYpCisKK3N0YXRpYyBjb25zdCBndWludDE2IGdfc2Vzc2lvblN0YXRlVmVyc2lvbiA9IDE7Cisj ZGVmaW5lIEhUVFBfQk9EWV9FTEVNRU5UX1RZUEVfU1RSSU5HX1YxICIodWF5c3hteG1kcykiCisj ZGVmaW5lIEhUVFBfQk9EWV9FTEVNRU5UX0ZPUk1BVF9TVFJJTkdfVjEgIih1YXkmc3hteG1kJnMp IgorI2RlZmluZSBIVFRQX0JPRFlfVFlQRV9TVFJJTkdfVjEgIm0oc2EiIEhUVFBfQk9EWV9FTEVN RU5UX1RZUEVfU1RSSU5HX1YxICIpIgorI2RlZmluZSBIVFRQX0JPRFlfRk9STUFUX1NUUklOR19W MSAibSgmc2EiIEhUVFBfQk9EWV9FTEVNRU5UX1RZUEVfU1RSSU5HX1YxICIpIgorI2RlZmluZSBG UkFNRV9TVEFURV9UWVBFX1NUUklOR19WMSAgIihzc3NzYXNtYXl0dChpaSlkIiBIVFRQX0JPRFlf VFlQRV9TVFJJTkdfVjEgImF2KSIKKyNkZWZpbmUgRlJBTUVfU1RBVEVfRk9STUFUX1NUUklOR19W MSAgIigmcyZzJnMmc2FzbWF5dHQoaWkpZEAiIEhUVFBfQk9EWV9UWVBFX1NUUklOR19WMSAiYXYp IgorI2RlZmluZSBCQUNLX0ZPUldBUkRfTElTVF9JVEVNX1RZUEVfU1RSSU5HX1YxICAiKHRzIiBG UkFNRV9TVEFURV9UWVBFX1NUUklOR19WMSAidSkiCisjZGVmaW5lIEJBQ0tfRk9SV0FSRF9MSVNU X0lURU1fRk9STUFUX1NUUklOR19WMSAgIih0JnNAIiBGUkFNRV9TVEFURV9UWVBFX1NUUklOR19W MSAidSkiCisjZGVmaW5lIFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEgICIocWEiIEJBQ0tf Rk9SV0FSRF9MSVNUX0lURU1fVFlQRV9TVFJJTkdfVjEgIm11KSIKKworZW51bSBFeHRlcm5hbFVS THNQb2xpY3kgeworICAgIEFsbG93LAorICAgIEFsbG93RXh0ZXJuYWxTY2hlbWVzLAorICAgIE5v dEFsbG93Cit9OworCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIHRvRXh0ZXJuYWxVUkxzUG9saWN5 KFdlYkNvcmU6OlNob3VsZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3kgcG9saWN5KQoreworICAgIHN3 aXRjaCAocG9saWN5KSB7CisgICAgY2FzZSBXZWJDb3JlOjpTaG91bGRPcGVuRXh0ZXJuYWxVUkxz UG9saWN5OjpTaG91bGRBbGxvdzoKKyAgICAgICAgcmV0dXJuIEV4dGVybmFsVVJMc1BvbGljeTo6 QWxsb3c7CisgICAgY2FzZSBXZWJDb3JlOjpTaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9saWN5OjpT aG91bGRBbGxvd0V4dGVybmFsU2NoZW1lczoKKyAgICAgICAgcmV0dXJuIEV4dGVybmFsVVJMc1Bv bGljeTo6QWxsb3dFeHRlcm5hbFNjaGVtZXM7CisgICAgY2FzZSBXZWJDb3JlOjpTaG91bGRPcGVu RXh0ZXJuYWxVUkxzUG9saWN5OjpTaG91bGROb3RBbGxvdzoKKyAgICAgICAgcmV0dXJuIEV4dGVy bmFsVVJMc1BvbGljeTo6Tm90QWxsb3c7CisgICAgfQorCisgICAgcmV0dXJuIEV4dGVybmFsVVJM c1BvbGljeTo6Tm90QWxsb3c7Cit9CisKK3N0YXRpYyBpbmxpbmUgV2ViQ29yZTo6U2hvdWxkT3Bl bkV4dGVybmFsVVJMc1BvbGljeSB0b1dlYkNvcmVFeHRlcm5hbFVSTHNQb2xpY3kodW5zaWduZWQg cG9saWN5KQoreworICAgIHN3aXRjaCAocG9saWN5KSB7CisgICAgY2FzZSBFeHRlcm5hbFVSTHNQ b2xpY3k6OkFsbG93OgorICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hvdWxkT3BlbkV4dGVybmFs VVJMc1BvbGljeTo6U2hvdWxkQWxsb3c7CisgICAgY2FzZSBFeHRlcm5hbFVSTHNQb2xpY3k6OkFs bG93RXh0ZXJuYWxTY2hlbWVzOgorICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hvdWxkT3BlbkV4 dGVybmFsVVJMc1BvbGljeTo6U2hvdWxkQWxsb3dFeHRlcm5hbFNjaGVtZXM7CisgICAgY2FzZSBF eHRlcm5hbFVSTHNQb2xpY3k6Ok5vdEFsbG93OgorICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hv dWxkT3BlbkV4dGVybmFsVVJMc1BvbGljeTo6U2hvdWxkTm90QWxsb3c7CisgICAgfQorCisgICAg cmV0dXJuIFdlYkNvcmU6OlNob3VsZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3k6OlNob3VsZE5vdEFs bG93OworfQorCitlbnVtIEhUTUxCb2R5RWxlbWVudFR5cGUgeworICAgIERhdGEsCisgICAgRmls ZSwKKyAgICBCbG9iCit9OworCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIHRvSFRNTEJvZHlFbGVt ZW50VHlwZShIVFRQQm9keTo6RWxlbWVudDo6VHlwZSB0eXBlKQoreworICAgIHN3aXRjaCAodHlw ZSkgeworICAgIGNhc2UgSFRUUEJvZHk6OkVsZW1lbnQ6OlR5cGU6OkRhdGE6CisgICAgICAgIHJl dHVybiBIVE1MQm9keUVsZW1lbnRUeXBlOjpEYXRhOworICAgIGNhc2UgSFRUUEJvZHk6OkVsZW1l bnQ6OlR5cGU6OkZpbGU6CisgICAgICAgIHJldHVybiBIVE1MQm9keUVsZW1lbnRUeXBlOjpGaWxl OworICAgIGNhc2UgSFRUUEJvZHk6OkVsZW1lbnQ6OlR5cGU6OkJsb2I6CisgICAgICAgIHJldHVy biBIVE1MQm9keUVsZW1lbnRUeXBlOjpCbG9iOworICAgIH0KKworICAgIHJldHVybiBIVE1MQm9k eUVsZW1lbnRUeXBlOjpEYXRhOworfQorCitzdGF0aWMgaW5saW5lIEhUVFBCb2R5OjpFbGVtZW50 OjpUeXBlIHRvSFRUUEJvZHlFbGVtZW50VHlwZSh1bnNpZ25lZCB0eXBlKQoreworICAgIHN3aXRj aCAodHlwZSkgeworICAgIGNhc2UgSFRNTEJvZHlFbGVtZW50VHlwZTo6RGF0YToKKyAgICAgICAg cmV0dXJuIEhUVFBCb2R5OjpFbGVtZW50OjpUeXBlOjpEYXRhOworICAgIGNhc2UgSFRNTEJvZHlF bGVtZW50VHlwZTo6RmlsZToKKyAgICAgICAgcmV0dXJuIEhUVFBCb2R5OjpFbGVtZW50OjpUeXBl OjpGaWxlOworICAgIGNhc2UgSFRNTEJvZHlFbGVtZW50VHlwZTo6QmxvYjoKKyAgICAgICAgcmV0 dXJuIEhUVFBCb2R5OjpFbGVtZW50OjpUeXBlOjpCbG9iOworICAgIH0KKworICAgIHJldHVybiBI VFRQQm9keTo6RWxlbWVudDo6VHlwZTo6RGF0YTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVu Y29kZUhUVFBCb2R5KEdWYXJpYW50QnVpbGRlciogc2Vzc2lvbkJ1aWxkZXIsIGNvbnN0IEhUVFBC b2R5JiBodHRwQm9keSkKK3sKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWls ZGVyLCBHX1ZBUklBTlRfVFlQRSgiKHNhIiBIVFRQX0JPRFlfRUxFTUVOVF9UWVBFX1NUUklOR19W MSAiKSIpKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwg aHR0cEJvZHkuY29udGVudFR5cGUudXRmOCgpLmRhdGEoKSk7CisgICAgZ192YXJpYW50X2J1aWxk ZXJfb3BlbihzZXNzaW9uQnVpbGRlciwgR19WQVJJQU5UX1RZUEUoImEiIEhUVFBfQk9EWV9FTEVN RU5UX1RZUEVfU1RSSU5HX1YxKSk7CisgICAgZ192YXJpYW50X2J1aWxkZXJfb3BlbihzZXNzaW9u QnVpbGRlciwgR19WQVJJQU5UX1RZUEUoSFRUUF9CT0RZX0VMRU1FTlRfVFlQRV9TVFJJTkdfVjEp KTsKKyAgICBmb3IgKGNvbnN0IGF1dG8mIGVsZW1lbnQgOiBodHRwQm9keS5lbGVtZW50cykgewor ICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJ1IiwgdG9IVE1M Qm9keUVsZW1lbnRUeXBlKGVsZW1lbnQudHlwZSkpOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRl cl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgiYXkiKSk7CisgICAgICAgIGZv ciAoYXV0byBpdGVtIDogZWxlbWVudC5kYXRhKQorICAgICAgICAgICAgZ192YXJpYW50X2J1aWxk ZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAieSIsIGl0ZW0pOworICAgICAgICBnX3ZhcmlhbnRfYnVp bGRlcl9jbG9zZShzZXNzaW9uQnVpbGRlcik7CisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2Fk ZChzZXNzaW9uQnVpbGRlciwgInMiLCBlbGVtZW50LmZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpOwor ICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJ4IiwgZWxlbWVu dC5maWxlU3RhcnQpOworICAgICAgICBpZiAoZWxlbWVudC5maWxlTGVuZ3RoKQorICAgICAgICAg ICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAibXgiLCBUUlVFLCBlbGVt ZW50LmZpbGVMZW5ndGgudmFsdWUoKSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGdfdmFy aWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgIm14IiwgRkFMU0UpOworICAgICAgICBp ZiAoZWxlbWVudC5leHBlY3RlZEZpbGVNb2RpZmljYXRpb25UaW1lKQorICAgICAgICAgICAgZ192 YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAibWQiLCBUUlVFLCBlbGVtZW50LmV4 cGVjdGVkRmlsZU1vZGlmaWNhdGlvblRpbWUudmFsdWUoKSk7CisgICAgICAgIGVsc2UKKyAgICAg ICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgIm1kIiwgRkFMU0Up OworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZWxl bWVudC5ibG9iVVJMU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKyAgICBnX3ZhcmlhbnRf YnVpbGRlcl9jbG9zZShzZXNzaW9uQnVpbGRlcik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfY2xv c2Uoc2Vzc2lvbkJ1aWxkZXIpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2Nsb3NlKHNlc3Npb25C dWlsZGVyKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29kZUZyYW1lU3RhdGUoR1Zhcmlh bnRCdWlsZGVyKiBzZXNzaW9uQnVpbGRlciwgY29uc3QgRnJhbWVTdGF0ZSYgZnJhbWVTdGF0ZSkK K3sKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRf VFlQRShGUkFNRV9TVEFURV9UWVBFX1NUUklOR19WMSkpOworICAgIGdfdmFyaWFudF9idWlsZGVy X2FkZChzZXNzaW9uQnVpbGRlciwgInMiLCBmcmFtZVN0YXRlLnVybFN0cmluZy51dGY4KCkuZGF0 YSgpKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZnJh bWVTdGF0ZS5vcmlnaW5hbFVSTFN0cmluZy51dGY4KCkuZGF0YSgpKTsKKyAgICBnX3ZhcmlhbnRf YnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZnJhbWVTdGF0ZS5yZWZlcnJlci51dGY4 KCkuZGF0YSgpKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJz IiwgZnJhbWVTdGF0ZS50YXJnZXQudXRmOCgpLmRhdGEoKSk7CisgICAgZ192YXJpYW50X2J1aWxk ZXJfb3BlbihzZXNzaW9uQnVpbGRlciwgR19WQVJJQU5UX1RZUEUoImFzIikpOworICAgIGZvciAo Y29uc3QgYXV0byYgc3RhdGUgOiBmcmFtZVN0YXRlLmRvY3VtZW50U3RhdGUpCisgICAgICAgIGdf dmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInMiLCBzdGF0ZS51dGY4KCkuZGF0 YSgpKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9zZShzZXNzaW9uQnVpbGRlcik7CisgICAg aWYgKCFmcmFtZVN0YXRlLnN0YXRlT2JqZWN0RGF0YSkKKyAgICAgICAgZ192YXJpYW50X2J1aWxk ZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAibWF5IiwgRkFMU0UpOworICAgIGVsc2UgeworICAgICAg ICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgi bWF5IikpOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBH X1ZBUklBTlRfVFlQRSgiYXkiKSk7CisgICAgICAgIGZvciAoYXV0byBpdGVtIDogZnJhbWVTdGF0 ZS5zdGF0ZU9iamVjdERhdGEudmFsdWUoKSkKKyAgICAgICAgICAgIGdfdmFyaWFudF9idWlsZGVy X2FkZChzZXNzaW9uQnVpbGRlciwgInkiLCBpdGVtKTsKKyAgICAgICAgZ192YXJpYW50X2J1aWxk ZXJfY2xvc2Uoc2Vzc2lvbkJ1aWxkZXIpOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9z ZShzZXNzaW9uQnVpbGRlcik7CisgICAgfQorICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNz aW9uQnVpbGRlciwgInQiLCBmcmFtZVN0YXRlLmRvY3VtZW50U2VxdWVuY2VOdW1iZXIpOworICAg IGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInQiLCBmcmFtZVN0YXRlLml0 ZW1TZXF1ZW5jZU51bWJlcik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWls ZGVyLCAiKGlpKSIsIGZyYW1lU3RhdGUuc2Nyb2xsUG9pbnQueCgpLCBmcmFtZVN0YXRlLnNjcm9s bFBvaW50LnkoKSk7CisgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAi ZCIsIGZyYW1lU3RhdGUucGFnZVNjYWxlRmFjdG9yKTsKKyAgICBpZiAoIWZyYW1lU3RhdGUuaHR0 cEJvZHkpCisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgSFRU UF9CT0RZX1RZUEVfU1RSSU5HX1YxLCBGQUxTRSk7CisgICAgZWxzZSB7CisgICAgICAgIGdfdmFy aWFudF9idWlsZGVyX29wZW4oc2Vzc2lvbkJ1aWxkZXIsIEdfVkFSSUFOVF9UWVBFKEhUVFBfQk9E WV9UWVBFX1NUUklOR19WMSkpOworICAgICAgICBlbmNvZGVIVFRQQm9keShzZXNzaW9uQnVpbGRl ciwgZnJhbWVTdGF0ZS5odHRwQm9keS52YWx1ZSgpKTsKKyAgICAgICAgZ192YXJpYW50X2J1aWxk ZXJfY2xvc2Uoc2Vzc2lvbkJ1aWxkZXIpOworICAgIH0KKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9v cGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgiYXYiKSk7CisgICAgZm9yIChjb25z dCBhdXRvJiBjaGlsZCA6IGZyYW1lU3RhdGUuY2hpbGRyZW4pCisgICAgICAgIGVuY29kZUZyYW1l U3RhdGUoc2Vzc2lvbkJ1aWxkZXIsIGNoaWxkKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9z ZShzZXNzaW9uQnVpbGRlcik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfY2xvc2Uoc2Vzc2lvbkJ1 aWxkZXIpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgZW5jb2RlUGFnZVN0YXRlKEdWYXJpYW50 QnVpbGRlciogc2Vzc2lvbkJ1aWxkZXIsIGNvbnN0IFBhZ2VTdGF0ZSYgcGFnZVN0YXRlKQorewor ICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInMiLCBwYWdlU3RhdGUu dGl0bGUudXRmOCgpLmRhdGEoKSk7CisgICAgZW5jb2RlRnJhbWVTdGF0ZShzZXNzaW9uQnVpbGRl ciwgcGFnZVN0YXRlLm1haW5GcmFtZVN0YXRlKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQo c2Vzc2lvbkJ1aWxkZXIsICJ1IiwgdG9FeHRlcm5hbFVSTHNQb2xpY3kocGFnZVN0YXRlLnNob3Vs ZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3kpKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29k ZUJhY2tGb3J3YXJkTGlzdEl0ZW1TdGF0ZShHVmFyaWFudEJ1aWxkZXIqIHNlc3Npb25CdWlsZGVy LCBjb25zdCBCYWNrRm9yd2FyZExpc3RJdGVtU3RhdGUmIGl0ZW0pCit7CisgICAgZ192YXJpYW50 X2J1aWxkZXJfb3BlbihzZXNzaW9uQnVpbGRlciwgR19WQVJJQU5UX1RZUEUoQkFDS19GT1JXQVJE X0xJU1RfSVRFTV9UWVBFX1NUUklOR19WMSkpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChz ZXNzaW9uQnVpbGRlciwgInQiLCBpdGVtLmlkZW50aWZpZXIpOworICAgIGVuY29kZVBhZ2VTdGF0 ZShzZXNzaW9uQnVpbGRlciwgaXRlbS5wYWdlU3RhdGUpOworICAgIGdfdmFyaWFudF9idWlsZGVy X2Nsb3NlKHNlc3Npb25CdWlsZGVyKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29kZUJh Y2tGb3J3YXJkTGlzdFN0YXRlKEdWYXJpYW50QnVpbGRlciogc2Vzc2lvbkJ1aWxkZXIsIGNvbnN0 IEJhY2tGb3J3YXJkTGlzdFN0YXRlJiBiYWNrRm9yd2FyZExpc3RTdGF0ZSkKK3sKKyAgICBnX3Zh cmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgiYSIgQkFD S19GT1JXQVJEX0xJU1RfSVRFTV9UWVBFX1NUUklOR19WMSkpOworICAgIGZvciAoY29uc3QgYXV0 byYgaXRlbSA6IGJhY2tGb3J3YXJkTGlzdFN0YXRlLml0ZW1zKQorICAgICAgICBlbmNvZGVCYWNr Rm9yd2FyZExpc3RJdGVtU3RhdGUoc2Vzc2lvbkJ1aWxkZXIsIGl0ZW0pOworICAgIGdfdmFyaWFu dF9idWlsZGVyX2Nsb3NlKHNlc3Npb25CdWlsZGVyKTsKKworICAgIGlmIChiYWNrRm9yd2FyZExp c3RTdGF0ZS5jdXJyZW50SW5kZXgpCisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNz aW9uQnVpbGRlciwgIm11IiwgVFJVRSwgYmFja0ZvcndhcmRMaXN0U3RhdGUuY3VycmVudEluZGV4 LnZhbHVlKCkpOworICAgIGVsc2UKKyAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Np b25CdWlsZGVyLCAibXUiLCBGQUxTRSk7Cit9CisKK3N0YXRpYyBHQnl0ZXMqIGVuY29kZVNlc3Np b25TdGF0ZShjb25zdCBTZXNzaW9uU3RhdGUmIHNlc3Npb25TdGF0ZSkKK3sKKyAgICBHVmFyaWFu dEJ1aWxkZXIgc2Vzc2lvbkJ1aWxkZXI7CisgICAgZ192YXJpYW50X2J1aWxkZXJfaW5pdCgmc2Vz c2lvbkJ1aWxkZXIsIEdfVkFSSUFOVF9UWVBFKFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEp KTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoJnNlc3Npb25CdWlsZGVyLCAicSIsIGdfc2Vz c2lvblN0YXRlVmVyc2lvbik7CisgICAgZW5jb2RlQmFja0ZvcndhcmRMaXN0U3RhdGUoJnNlc3Np b25CdWlsZGVyLCBzZXNzaW9uU3RhdGUuYmFja0ZvcndhcmRMaXN0U3RhdGUpOworICAgIEdSZWZQ dHI8R1ZhcmlhbnQ+IHZhcmlhbnQgPSBnX3ZhcmlhbnRfYnVpbGRlcl9lbmQoJnNlc3Npb25CdWls ZGVyKTsKKyAgICByZXR1cm4gZ192YXJpYW50X2dldF9kYXRhX2FzX2J5dGVzKHZhcmlhbnQuZ2V0 KCkpOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgZGVjb2RlSFRUUEJvZHkoR1ZhcmlhbnQqIGh0 dHBCb2R5VmFyaWFudCwgSFRUUEJvZHkmIGh0dHBCb2R5KQoreworICAgIGdib29sZWFuIGhhc0hU VFBCb2R5OworICAgIGNvbnN0IGNoYXIqIGNvbnRlbnRUeXBlOworICAgIEdVbmlxdWVPdXRQdHI8 R1ZhcmlhbnRJdGVyPiBlbGVtZW50c0l0ZXI7CisgICAgZ192YXJpYW50X2dldChodHRwQm9keVZh cmlhbnQsIEhUVFBfQk9EWV9GT1JNQVRfU1RSSU5HX1YxLCAmaGFzSFRUUEJvZHksICZjb250ZW50 VHlwZSwgJmVsZW1lbnRzSXRlci5vdXRQdHIoKSk7CisgICAgaWYgKCFoYXNIVFRQQm9keSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgIGh0dHBCb2R5LmNvbnRlbnRUeXBlID0gU3RyaW5nOjpm cm9tVVRGOChjb250ZW50VHlwZSk7CisgICAgZ3NpemUgZWxlbWVudHNMZW5ndGggPSBnX3Zhcmlh bnRfaXRlcl9uX2NoaWxkcmVuKGVsZW1lbnRzSXRlci5nZXQoKSk7CisgICAgaWYgKCFlbGVtZW50 c0xlbmd0aCkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgaHR0cEJvZHkuZWxlbWVudHMucmVz ZXJ2ZUluaXRpYWxDYXBhY2l0eShlbGVtZW50c0xlbmd0aCk7CisgICAgdW5zaWduZWQgdHlwZTsK KyAgICBHVmFyaWFudEl0ZXIqIGRhdGFJdGVyOworICAgIGNvbnN0IGNoYXIqIGZpbGVQYXRoOwor ICAgIGdpbnQ2NCBmaWxlU3RhcnQ7CisgICAgZ2Jvb2xlYW4gaGFzRmlsZUxlbmd0aDsKKyAgICBn aW50NjQgZmlsZUxlbmd0aDsKKyAgICBnYm9vbGVhbiBoYXNGaWxlTW9kaWZpY2F0aW9uVGltZTsK KyAgICBnZG91YmxlIGZpbGVNb2RpZmljYXRpb25UaW1lOworICAgIGNvbnN0IGNoYXIqIGJsb2JV UkxTdHJpbmc7CisgICAgd2hpbGUgKGdfdmFyaWFudF9pdGVyX2xvb3AoZWxlbWVudHNJdGVyLmdl dCgpLCBIVFRQX0JPRFlfRUxFTUVOVF9GT1JNQVRfU1RSSU5HX1YxLCAmdHlwZSwgJmRhdGFJdGVy LCAmZmlsZVBhdGgsICZmaWxlU3RhcnQsICZoYXNGaWxlTGVuZ3RoLCAmZmlsZUxlbmd0aCwgJmhh c0ZpbGVNb2RpZmljYXRpb25UaW1lLCAmZmlsZU1vZGlmaWNhdGlvblRpbWUsICZibG9iVVJMU3Ry aW5nKSkgeworICAgICAgICBIVFRQQm9keTo6RWxlbWVudCBlbGVtZW50OworICAgICAgICBlbGVt ZW50LnR5cGUgPSB0b0hUVFBCb2R5RWxlbWVudFR5cGUodHlwZSk7CisgICAgICAgIGlmIChnc2l6 ZSBkYXRhTGVuZ3RoID0gZ192YXJpYW50X2l0ZXJfbl9jaGlsZHJlbihkYXRhSXRlcikpIHsKKyAg ICAgICAgICAgIGVsZW1lbnQuZGF0YS5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGRhdGFMZW5ndGgp OworICAgICAgICAgICAgZ3VjaGFyIGRhdGFWYWx1ZTsKKyAgICAgICAgICAgIHdoaWxlIChnX3Zh cmlhbnRfaXRlcl9uZXh0KGRhdGFJdGVyLCAieSIsICZkYXRhVmFsdWUpKQorICAgICAgICAgICAg ICAgIGVsZW1lbnQuZGF0YS51bmNoZWNrZWRBcHBlbmQoZGF0YVZhbHVlKTsKKyAgICAgICAgfQor ICAgICAgICBlbGVtZW50LmZpbGVQYXRoID0gU3RyaW5nOjpmcm9tVVRGOChmaWxlUGF0aCk7Cisg ICAgICAgIGVsZW1lbnQuZmlsZVN0YXJ0ID0gZmlsZVN0YXJ0OworICAgICAgICBpZiAoaGFzRmls ZUxlbmd0aCkKKyAgICAgICAgICAgIGVsZW1lbnQuZmlsZUxlbmd0aCA9IGZpbGVMZW5ndGg7Cisg ICAgICAgIGlmIChoYXNGaWxlTW9kaWZpY2F0aW9uVGltZSkKKyAgICAgICAgICAgIGVsZW1lbnQu ZXhwZWN0ZWRGaWxlTW9kaWZpY2F0aW9uVGltZSA9IGZpbGVNb2RpZmljYXRpb25UaW1lOworICAg ICAgICBlbGVtZW50LmJsb2JVUkxTdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KGJsb2JVUkxTdHJp bmcpOworCisgICAgICAgIGh0dHBCb2R5LmVsZW1lbnRzLnVuY2hlY2tlZEFwcGVuZChXVEY6Om1v dmUoZWxlbWVudCkpOworICAgIH0KKworICAgIHJldHVybiB0cnVlOworfQorCitzdGF0aWMgaW5s aW5lIHZvaWQgZGVjb2RlRnJhbWVTdGF0ZShHVmFyaWFudCogZnJhbWVTdGF0ZVZhcmlhbnQsIEZy YW1lU3RhdGUmIGZyYW1lU3RhdGUpCit7CisgICAgY29uc3QgY2hhciogdXJsU3RyaW5nOworICAg IGNvbnN0IGNoYXIqIG9yaWdpbmFsVVJMU3RyaW5nOworICAgIGNvbnN0IGNoYXIqIHJlZmVycmVy OworICAgIGNvbnN0IGNoYXIqIHRhcmdldDsKKyAgICBHVW5pcXVlT3V0UHRyPEdWYXJpYW50SXRl cj4gZG9jdW1lbnRTdGF0ZUl0ZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHVmFyaWFudEl0ZXI+IHN0 YXRlT2JqZWN0RGF0YUl0ZXI7CisgICAgZ3VpbnQ2NCBkb2N1bWVudFNlcXVlbmNlTnVtYmVyOwor ICAgIGd1aW50NjQgaXRlbVNlcXVlbmNlTnVtYmVyOworICAgIGdpbnQzMiBzY3JvbGxQb2ludFgs IHNjcm9sbFBvaW50WTsKKyAgICBnZG91YmxlIHBhZ2VTY2FsZUZhY3RvcjsKKyAgICBHVmFyaWFu dCogaHR0cEJvZHlWYXJpYW50OworICAgIEdVbmlxdWVPdXRQdHI8R1ZhcmlhbnRJdGVyPiBjaGls ZHJlbkl0ZXI7CisgICAgZ192YXJpYW50X2dldChmcmFtZVN0YXRlVmFyaWFudCwgRlJBTUVfU1RB VEVfRk9STUFUX1NUUklOR19WMSwgJnVybFN0cmluZywgJm9yaWdpbmFsVVJMU3RyaW5nLCAmcmVm ZXJyZXIsICZ0YXJnZXQsCisgICAgICAgICZkb2N1bWVudFN0YXRlSXRlci5vdXRQdHIoKSwgJnN0 YXRlT2JqZWN0RGF0YUl0ZXIub3V0UHRyKCksICZkb2N1bWVudFNlcXVlbmNlTnVtYmVyLCAmaXRl bVNlcXVlbmNlTnVtYmVyLAorICAgICAgICAmc2Nyb2xsUG9pbnRYLCAmc2Nyb2xsUG9pbnRZLCAm cGFnZVNjYWxlRmFjdG9yLCAmaHR0cEJvZHlWYXJpYW50LCAmY2hpbGRyZW5JdGVyLm91dFB0cigp KTsKKyAgICBmcmFtZVN0YXRlLnVybFN0cmluZyA9IFN0cmluZzo6ZnJvbVVURjgodXJsU3RyaW5n KTsKKyAgICBmcmFtZVN0YXRlLm9yaWdpbmFsVVJMU3RyaW5nID0gU3RyaW5nOjpmcm9tVVRGOChv cmlnaW5hbFVSTFN0cmluZyk7CisgICAgZnJhbWVTdGF0ZS5yZWZlcnJlciA9IFN0cmluZzo6ZnJv bVVURjgocmVmZXJyZXIpOworICAgIGZyYW1lU3RhdGUudGFyZ2V0ID0gU3RyaW5nOjpmcm9tVVRG OCh0YXJnZXQpOworICAgIGlmIChnc2l6ZSBkb2N1bWVudFN0YXRlTGVuZ3RoID0gZ192YXJpYW50 X2l0ZXJfbl9jaGlsZHJlbihkb2N1bWVudFN0YXRlSXRlci5nZXQoKSkpIHsKKyAgICAgICAgZnJh bWVTdGF0ZS5kb2N1bWVudFN0YXRlLnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoZG9jdW1lbnRTdGF0 ZUxlbmd0aCk7CisgICAgICAgIGNvbnN0IGNoYXIqIGRvY3VtZW50U3RhdGVTdHJpbmc7CisgICAg ICAgIHdoaWxlIChnX3ZhcmlhbnRfaXRlcl9uZXh0KGRvY3VtZW50U3RhdGVJdGVyLmdldCgpLCAi JnMiLCAmZG9jdW1lbnRTdGF0ZVN0cmluZykpCisgICAgICAgICAgICBmcmFtZVN0YXRlLmRvY3Vt ZW50U3RhdGUudW5jaGVja2VkQXBwZW5kKFN0cmluZzo6ZnJvbVVURjgoZG9jdW1lbnRTdGF0ZVN0 cmluZykpOworICAgIH0KKyAgICBpZiAoc3RhdGVPYmplY3REYXRhSXRlcikgeworICAgICAgICBW ZWN0b3I8dWludDhfdD4gc3RhdGVPYmplY3RWZWN0b3I7CisgICAgICAgIGlmIChnc2l6ZSBzdGF0 ZU9iamVjdERhdGFMZW5ndGggPSBnX3ZhcmlhbnRfaXRlcl9uX2NoaWxkcmVuKHN0YXRlT2JqZWN0 RGF0YUl0ZXIuZ2V0KCkpKSB7CisgICAgICAgICAgICBzdGF0ZU9iamVjdFZlY3Rvci5yZXNlcnZl SW5pdGlhbENhcGFjaXR5KHN0YXRlT2JqZWN0RGF0YUxlbmd0aCk7CisgICAgICAgICAgICBndWNo YXIgc3RhdGVPYmplY3REYXRhVmFsdWU7CisgICAgICAgICAgICB3aGlsZSAoZ192YXJpYW50X2l0 ZXJfbmV4dChzdGF0ZU9iamVjdERhdGFJdGVyLmdldCgpLCAieSIsICZzdGF0ZU9iamVjdERhdGFW YWx1ZSkpCisgICAgICAgICAgICAgICAgc3RhdGVPYmplY3RWZWN0b3IudW5jaGVja2VkQXBwZW5k KHN0YXRlT2JqZWN0RGF0YVZhbHVlKTsKKyAgICAgICAgfQorICAgICAgICBmcmFtZVN0YXRlLnN0 YXRlT2JqZWN0RGF0YSA9IFdURjo6bW92ZShzdGF0ZU9iamVjdFZlY3Rvcik7CisgICAgfQorICAg IGZyYW1lU3RhdGUuZG9jdW1lbnRTZXF1ZW5jZU51bWJlciA9IGRvY3VtZW50U2VxdWVuY2VOdW1i ZXI7CisgICAgZnJhbWVTdGF0ZS5pdGVtU2VxdWVuY2VOdW1iZXIgPSBpdGVtU2VxdWVuY2VOdW1i ZXI7CisgICAgZnJhbWVTdGF0ZS5zY3JvbGxQb2ludC5zZXRYKHNjcm9sbFBvaW50WCk7CisgICAg ZnJhbWVTdGF0ZS5zY3JvbGxQb2ludC5zZXRZKHNjcm9sbFBvaW50WSk7CisgICAgZnJhbWVTdGF0 ZS5wYWdlU2NhbGVGYWN0b3IgPSBwYWdlU2NhbGVGYWN0b3I7CisgICAgSFRUUEJvZHkgaHR0cEJv ZHk7CisgICAgaWYgKGRlY29kZUhUVFBCb2R5KGh0dHBCb2R5VmFyaWFudCwgaHR0cEJvZHkpKQor ICAgICAgICBmcmFtZVN0YXRlLmh0dHBCb2R5ID0gV1RGOjptb3ZlKGh0dHBCb2R5KTsKKyAgICBn X3ZhcmlhbnRfdW5yZWYoaHR0cEJvZHlWYXJpYW50KTsKKyAgICB3aGlsZSAoR1JlZlB0cjxHVmFy aWFudD4gY2hpbGQgPSBhZG9wdEdSZWYoZ192YXJpYW50X2l0ZXJfbmV4dF92YWx1ZShjaGlsZHJl bkl0ZXIuZ2V0KCkpKSkgeworICAgICAgICBGcmFtZVN0YXRlIGNoaWxkRnJhbWVTdGF0ZTsKKyAg ICAgICAgZGVjb2RlRnJhbWVTdGF0ZShjaGlsZC5nZXQoKSwgY2hpbGRGcmFtZVN0YXRlKTsKKyAg ICAgICAgZnJhbWVTdGF0ZS5jaGlsZHJlbi5hcHBlbmQoV1RGOjptb3ZlKGNoaWxkRnJhbWVTdGF0 ZSkpOworICAgIH0KK30KKworc3RhdGljIGlubGluZSB2b2lkIGRlY29kZUJhY2tGb3J3YXJkTGlz dEl0ZW1TdGF0ZShHVmFyaWFudEl0ZXIqIGJhY2tGb3J3YXJkTGlzdFN0YXRlSXRlciwgQmFja0Zv cndhcmRMaXN0U3RhdGUmIGJhY2tGb3J3YXJkTGlzdFN0YXRlKQoreworICAgIGdzaXplIGJhY2tG b3J3YXJkTGlzdFN0YXRlTGVuZ3RoID0gZ192YXJpYW50X2l0ZXJfbl9jaGlsZHJlbihiYWNrRm9y d2FyZExpc3RTdGF0ZUl0ZXIpOworICAgIGlmICghYmFja0ZvcndhcmRMaXN0U3RhdGVMZW5ndGgp CisgICAgICAgIHJldHVybjsKKworICAgIGJhY2tGb3J3YXJkTGlzdFN0YXRlLml0ZW1zLnJlc2Vy dmVJbml0aWFsQ2FwYWNpdHkoYmFja0ZvcndhcmRMaXN0U3RhdGVMZW5ndGgpOworICAgIGd1aW50 NjQgaWRlbnRpZmllcjsKKyAgICBjb25zdCBjaGFyKiB0aXRsZTsKKyAgICBHVmFyaWFudCogZnJh bWVTdGF0ZVZhcmlhbnQ7CisgICAgdW5zaWduZWQgc2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGlj eTsKKyAgICB3aGlsZSAoZ192YXJpYW50X2l0ZXJfbG9vcChiYWNrRm9yd2FyZExpc3RTdGF0ZUl0 ZXIsIEJBQ0tfRk9SV0FSRF9MSVNUX0lURU1fRk9STUFUX1NUUklOR19WMSwgJmlkZW50aWZpZXIs ICZ0aXRsZSwgJmZyYW1lU3RhdGVWYXJpYW50LCAmc2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGlj eSkpIHsKKyAgICAgICAgQmFja0ZvcndhcmRMaXN0SXRlbVN0YXRlIHN0YXRlOworICAgICAgICBz dGF0ZS5pZGVudGlmaWVyID0gaWRlbnRpZmllcjsKKyAgICAgICAgc3RhdGUucGFnZVN0YXRlLnRp dGxlID0gU3RyaW5nOjpmcm9tVVRGOCh0aXRsZSk7CisgICAgICAgIGRlY29kZUZyYW1lU3RhdGUo ZnJhbWVTdGF0ZVZhcmlhbnQsIHN0YXRlLnBhZ2VTdGF0ZS5tYWluRnJhbWVTdGF0ZSk7CisgICAg ICAgIHN0YXRlLnBhZ2VTdGF0ZS5zaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9saWN5ID0gdG9XZWJD b3JlRXh0ZXJuYWxVUkxzUG9saWN5KHNob3VsZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3kpOworICAg ICAgICBiYWNrRm9yd2FyZExpc3RTdGF0ZS5pdGVtcy51bmNoZWNrZWRBcHBlbmQoV1RGOjptb3Zl KHN0YXRlKSk7CisgICAgfQorfQorCitzdGF0aWMgYm9vbCBkZWNvZGVTZXNzaW9uU3RhdGUoR0J5 dGVzKiBkYXRhLCBTZXNzaW9uU3RhdGUmIHNlc3Npb25TdGF0ZSkKK3sKKyAgICBHUmVmUHRyPEdW YXJpYW50PiB2YXJpYW50ID0gZ192YXJpYW50X25ld19mcm9tX2J5dGVzKEdfVkFSSUFOVF9UWVBF KFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEpLCBkYXRhLCBGQUxTRSk7CisgICAgaWYgKCFn X3ZhcmlhbnRfaXNfbm9ybWFsX2Zvcm0odmFyaWFudC5nZXQoKSkpCisgICAgICAgIHJldHVybiBm YWxzZTsKKworICAgIGd1aW50MTYgdmVyc2lvbjsKKyAgICBHVW5pcXVlT3V0UHRyPEdWYXJpYW50 SXRlcj4gYmFja0ZvcndhcmRMaXN0U3RhdGVJdGVyOworICAgIGdib29sZWFuIGhhc0N1cnJlbnRJ bmRleDsKKyAgICBndWludDMyIGN1cnJlbnRJbmRleDsKKyAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlh bnQuZ2V0KCksIFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEsICZ2ZXJzaW9uLCAmYmFja0Zv cndhcmRMaXN0U3RhdGVJdGVyLm91dFB0cigpLCAmaGFzQ3VycmVudEluZGV4LCAmY3VycmVudElu ZGV4KTsKKyAgICBpZiAoIXZlcnNpb24gfHwgdmVyc2lvbiA+IGdfc2Vzc2lvblN0YXRlVmVyc2lv bikKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgZGVjb2RlQmFja0ZvcndhcmRMaXN0SXRl bVN0YXRlKGJhY2tGb3J3YXJkTGlzdFN0YXRlSXRlci5nZXQoKSwgc2Vzc2lvblN0YXRlLmJhY2tG b3J3YXJkTGlzdFN0YXRlKTsKKworICAgIGlmIChoYXNDdXJyZW50SW5kZXgpCisgICAgICAgIHNl c3Npb25TdGF0ZS5iYWNrRm9yd2FyZExpc3RTdGF0ZS5jdXJyZW50SW5kZXggPSBjdXJyZW50SW5k ZXg7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHdl YmtpdFdlYlZpZXdTZXNzaW9uU3RhdGVDcmVhdGUoU2Vzc2lvblN0YXRlJiYgc2Vzc2lvblN0YXRl KQoreworICAgIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHN0YXRlID0gc3RhdGljX2Nhc3Q8 V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSo+KGZhc3RNYWxsb2Moc2l6ZW9mKFdlYktpdFdlYlZp ZXdTZXNzaW9uU3RhdGUpKSk7CisgICAgbmV3IChzdGF0ZSkgV2ViS2l0V2ViVmlld1Nlc3Npb25T dGF0ZShXVEY6Om1vdmUoc2Vzc2lvblN0YXRlKSk7CisgICAgcmV0dXJuIHN0YXRlOworfQorCitj b25zdCBTZXNzaW9uU3RhdGUmIHdlYmtpdFdlYlZpZXdTZXNzaW9uU3RhdGF0ZUdldFNlc3Npb25T dGF0ZShXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSkKK3sKKyAgICByZXR1cm4gc3Rh dGUtPnNlc3Npb25TdGF0ZTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9z dGF0ZV9uZXc6CisgKiBAZGF0YTogYSAjR0J5dGVzCisgKgorICogQ3JlYXRlcyBhIG5ldyAjV2Vi S2l0V2ViVmlld1Nlc3Npb25TdGF0ZSBmcm9tIHNlcmFsaXplZCBkYXRhLgorICoKKyAqIFJldHVy bnM6ICh0cmFuc2ZlciBmdWxsKTogYSBuZXcgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUsIG9y ICVOVUxMIGlmIEBkYXRhIGRvZXNuJ3QgY29udGFpbiBhCisgKiAgICAgdmFsaWQgc2VyaWFsaXpl ZCAjV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS4KKyAqCisgKiBTaW5jZTogMi4xMgorICovCitX ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9u ZXcoR0J5dGVzKiBkYXRhKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKGRhdGEsIG51bGxw dHIpOworCisgICAgU2Vzc2lvblN0YXRlIHNlc3Npb25TdGF0ZTsKKyAgICBpZiAoIWRlY29kZVNl c3Npb25TdGF0ZShkYXRhLCBzZXNzaW9uU3RhdGUpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsK KyAgICByZXR1cm4gd2Via2l0V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXVEY6Om1vdmUoc2Vz c2lvblN0YXRlKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVf cmVmOgorICogQHN0YXRlOiBhICNXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogQXRv bWljYWxseSBpbmNyZW1lbnRzIHRoZSByZWZlcmVuY2UgY291bnQgb2YgQHN0YXRlIGJ5IG9uZS4g VGhpcworICogZnVuY3Rpb24gaXMgTVQtc2FmZSBhbmQgbWF5IGJlIGNhbGxlZCBmcm9tIGFueSB0 aHJlYWQuCisgKgorICogUmV0dXJuczogVGhlIHBhc3NlZCBpbiAjV2ViS2l0V2ViVmlld1Nlc3Np b25TdGF0ZQorICoKKyAqIFNpbmNlOiAyLjEyCisgKi8KK1dlYktpdFdlYlZpZXdTZXNzaW9uU3Rh dGUqIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3JlZihXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlKiBzdGF0ZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChzdGF0ZSwgbnVsbHB0 cik7CisgICAgZ19hdG9taWNfaW50X2luYygmc3RhdGUtPnJlZmVyZW5jZUNvdW50KTsKKyAgICBy ZXR1cm4gc3RhdGU7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVf dW5yZWY6CisgKiBAc3RhdGU6IGEgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUKKyAqCisgKiBB dG9taWNhbGx5IGRlY3JlbWVudHMgdGhlIHJlZmVyZW5jZSBjb3VudCBvZiBAc3RhdGUgYnkgb25l LiBJZiB0aGUKKyAqIHJlZmVyZW5jZSBjb3VudCBkcm9wcyB0byAwLCBhbGwgbWVtb3J5IGFsbG9j YXRlZCBieSB0aGUgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgaXMKKyAqIHJlbGVhc2VkLiBU aGlzIGZ1bmN0aW9uIGlzIE1ULXNhZmUgYW5kIG1heSBiZSBjYWxsZWQgZnJvbSBhbnkgdGhyZWFk LgorICoKKyAqIFNpbmNlOiAyLjEyCisgKi8KK3ZvaWQgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25f c3RhdGVfdW5yZWYoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogc3RhdGUpCit7CisgICAgZ19y ZXR1cm5faWZfZmFpbChzdGF0ZSk7CisgICAgaWYgKGdfYXRvbWljX2ludF9kZWNfYW5kX3Rlc3Qo JnN0YXRlLT5yZWZlcmVuY2VDb3VudCkpIHsKKyAgICAgICAgc3RhdGUtPn5XZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlKCk7CisgICAgICAgIGZhc3RGcmVlKHN0YXRlKTsKKyAgICB9Cit9CisKKy8q KgorICogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplOgorICogQHN0YXRl OiBhICNXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogU2VyaWFsaXplcyBhICNXZWJL aXRXZWJWaWV3U2Vzc2lvblN0YXRlLgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBmdWxsKTog YSAjR0J5dGVzIGNvbnRhaW5pbmcgdGhlIEBzdGF0ZSBzZXJpYWxpemVkLgorICoKKyAqIFNpbmNl OiAyLjEyCisgKi8KK0dCeXRlcyogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFs aXplKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHN0YXRlKQoreworICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKHN0YXRlLCBudWxscHRyKTsKKworICAgIHJldHVybiBlbmNvZGVTZXNzaW9uU3Rh dGUoc3RhdGUtPnNlc3Npb25TdGF0ZSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmggYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzNmNGE0YQotLS0gL2Rldi9udWxsCisrKyBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3Rh dGUuaApAQCAtMCwwICsxLDUzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBT LkwuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4g U3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICov CisKKyNpZiAhZGVmaW5lZChfX1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lU Ml9DT01QSUxBVElPTikKKyNlcnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBp bmNsdWRlZCBkaXJlY3RseS4iCisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlX2gKKyNkZWZpbmUgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZV9oCisKKyNpbmNsdWRl IDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0RGVmaW5lcy5oPgorCitH X0JFR0lOX0RFQ0xTCisKKyNkZWZpbmUgV0VCS0lUX1RZUEVfV0VCX1ZJRVdfU0VTU0lPTl9TVEFU RSAod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfZ2V0X3R5cGUoKSkKKwordHlwZWRlZiBz dHJ1Y3QgX1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0 ZTsKKworV0VCS0lUX0FQSSBHVHlwZQord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfZ2V0 X3R5cGUgICh2b2lkKTsKKworV0VCS0lUX0FQSSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICoK K3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX25ldyAgICAgICAoR0J5dGVzICpkYXRhKTsK KworV0VCS0lUX0FQSSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICoKK3dlYmtpdF93ZWJfdmll d19zZXNzaW9uX3N0YXRlX3JlZiAgICAgICAoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSAqc3Rh dGUpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3Vu cmVmICAgICAoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSAqc3RhdGUpOworCitXRUJLSVRfQVBJ IEdCeXRlcyAqCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9zZXJpYWxpemUgKFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGUgKnN0YXRlKTsKKworR19FTkRfREVDTFMKKworI2VuZGlmCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5hNjI1NTVhCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaApAQCAt MCwwICsxLDI5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IElnYWxpYSBTLkwuCisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICog dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNs dWRlICJTZXNzaW9uU3RhdGUuaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRl LmgiCisKKyNpZm5kZWYgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGVfaAorI2RlZmlu ZSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlUHJpdmF0ZV9oCisKK1dlYktpdFdlYlZpZXdTZXNz aW9uU3RhdGUqIHdlYmtpdFdlYlZpZXdTZXNzaW9uU3RhdGVDcmVhdGUoV2ViS2l0OjpTZXNzaW9u U3RhdGUmJik7Citjb25zdCBXZWJLaXQ6OlNlc3Npb25TdGF0ZSYgd2Via2l0V2ViVmlld1Nlc3Np b25TdGF0YXRlR2V0U2Vzc2lvblN0YXRlKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqKTsKKwor I2VuZGlmIC8vIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGVQcml2YXRlX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2Vj dGlvbnMudHh0IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQy Z3RrLTQuMC1zZWN0aW9ucy50eHQKaW5kZXggNWQ5ZDY1MDEuLjI0NWViNTQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2Vj dGlvbnMudHh0CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Vi a2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CkBAIC0yMTIsNiArMjEyLDggQEAgd2Via2l0X3dlYl92 aWV3X2dldF9iYWNrZ3JvdW5kX2NvbG9yCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2VkaXRhYmxlCiB3 ZWJraXRfd2ViX3ZpZXdfaXNfZWRpdGFibGUKIHdlYmtpdF93ZWJfdmlld19nZXRfZWRpdG9yX3N0 YXRlCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUKK3dlYmtpdF93ZWJfdmlld19y ZXN0b3JlX3Nlc3Npb25fc3RhdGUKIAogPFNVQlNFQ1RJT04gV2ViS2l0SmF2YXNjcmlwdFJlc3Vs dD4KIFdlYktpdEphdmFzY3JpcHRSZXN1bHQKQEAgLTIzMCw2ICsyMzIsMTMgQEAgd2Via2l0X3Nj cmlwdF9kaWFsb2dfcHJvbXB0X2dldF9kZWZhdWx0X3RleHQKIHdlYmtpdF9zY3JpcHRfZGlhbG9n X3Byb21wdF9zZXRfdGV4dAogd2Via2l0X3dlYl92aWV3X2dldF9tYWluX3Jlc291cmNlCiAKKzxT VUJTRUNUSU9OIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGU+CitXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcKK3dlYmtpdF93ZWJfdmll d19zZXNzaW9uX3N0YXRlX3JlZgord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYK K3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3NlcmlhbGl6ZQorCiA8U1VCU0VDVElPTiBT dGFuZGFyZD4KIFdlYktpdFdlYlZpZXdDbGFzcwogV0VCS0lUX1dFQl9WSUVXCkBAIC0yNDAsMTEg KzI0OSwxMyBAQCBXRUJLSVRfSVNfV0VCX1ZJRVdfQ0xBU1MKIFdFQktJVF9XRUJfVklFV19HRVRf Q0xBU1MKIFdFQktJVF9UWVBFX0pBVkFTQ1JJUFRfUkVTVUxUCiBXRUJLSVRfVFlQRV9TQ1JJUFRf RElBTE9HCitXRUJLSVRfVFlQRV9XRUJfVklFV19TRVNTSU9OX1NUQVRFCiAKIDxTVUJTRUNUSU9O IFByaXZhdGU+CiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3R5cGUKIHdlYmtpdF9qYXZhc2NyaXB0X3Jl c3VsdF9nZXRfdHlwZQogd2Via2l0X3NjcmlwdF9kaWFsb2dfZ2V0X3R5cGUKK3dlYmtpdF93ZWJf dmlld19zZXNzaW9uX3N0YXRlX2dldF90eXBlCiBXZWJLaXRXZWJWaWV3UHJpdmF0ZQogPC9TRUNU SU9OPgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2Nz L3dlYmtpdDJndGstNC4wLnR5cGVzIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv ZG9jcy93ZWJraXQyZ3RrLTQuMC50eXBlcwppbmRleCBmZWE5NWU3Li4yNjJlMDdhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4w LnR5cGVzCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0 Mmd0ay00LjAudHlwZXMKQEAgLTMzLDMgKzMzLDQgQEAgd2Via2l0X3dlYnNpdGVfZGF0YV9tYW5h Z2VyX2dldF90eXBlCiB3ZWJraXRfZWRpdG9yX3N0YXRlX2dldF90eXBlCiB3ZWJraXRfaW5zdGFs bF9taXNzaW5nX21lZGlhX3BsdWdpbnNfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlCiB3ZWJr aXRfY29uc29sZV9tZXNzYWdlX2dldF90eXBlCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0 ZV9nZXRfdHlwZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsv d2Via2l0Mi5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oCmlu ZGV4IGI5NWE3NjAuLjNlNDRkNjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9BUEkvZ3RrL3dlYmtpdDIuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay93ZWJraXQyLmgKQEAgLTc0LDYgKzc0LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdl YlJlc291cmNlLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3Lmg+CiAjaW5jbHVk ZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3QmFzZS5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0 V2ViVmlld1Nlc3Npb25TdGF0ZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2Vic2l0ZURh dGFNYW5hZ2VyLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXaW5kb3dQcm9wZXJ0aWVzLmg+ CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBj MjQyNzFkLi5lMzQ3ZGQxIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTUtMTItMzAgIENhcmxvcyBHYXJjaWEgQ2Ft cG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIEFsbG93IHRvIHNhdmUg YW5kIHJlc3RvcmUgc2Vzc2lvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTE1NjAwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkIHRlc3QgY2FzZSB0byBjaGVjayB0aGUgbmV3IHNlc3Npb24gQVBJLgor CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2Fy ZExpc3QuY3BwOgorICAgICAgICAodGVzdFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUpOgorICAg ICAgICAodGVzdFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGVXaXRoRm9ybURhdGEpOgorICAgICAg ICAoYmVmb3JlQWxsKToKKwogMjAxNS0xMi0wOSAgQWFrYXNoIEphaW4gIDxhYWthc2hfamFpbkBh cHBsZS5jb20+CiAKICAgICAgICAgUnVuIGF0bGVhc3Qgb25lIHNpbXVsYXRvciBldmVuIGlmIG1h eCBwcm9jZXNzIGxpbWl0IGlzIGxvdwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2FyZExpc3QuY3BwIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2FyZExpc3QuY3BwCmluZGV4IDY1YzNk MmQuLmY3YWJkNWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mkd0ay9UZXN0QmFja0ZvcndhcmRMaXN0LmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdDJHdGsvVGVzdEJhY2tGb3J3YXJkTGlzdC5jcHAKQEAgLTI2NCw2ICsyNjQsMTA4 IEBAIHN0YXRpYyB2b2lkIHRlc3RCYWNrRm9yd2FyZExpc3RMaW1pdEFuZENhY2hlKEJhY2tGb3J3 YXJkTGlzdFRlc3QqIHRlc3QsIGdjb25zdHBvCiAgICAgZ19hc3NlcnRfY21wdWludCh3ZWJraXRf YmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aCh0ZXN0LT5tX2xpc3QpLCA9PSwga0JhY2tGb3J3 YXJkTGlzdExpbWl0KTsKIH0KIAorc3RhdGljIHZvaWQgdGVzdFdlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGUoQmFja0ZvcndhcmRMaXN0VGVzdCogdGVzdCwgZ2NvbnN0cG9pbnRlcikKK3sKKyAgICBX ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSA9IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vz c2lvbl9zdGF0ZSh0ZXN0LT5tX3dlYlZpZXcpOworICAgIGdfYXNzZXJ0KHN0YXRlKTsKKyAgICBH UmVmUHRyPFdlYktpdFdlYlZpZXc+IHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92 aWV3X25ldygpKTsKKyAgICBXZWJLaXRCYWNrRm9yd2FyZExpc3QqIGJmTGlzdCA9IHdlYmtpdF93 ZWJfdmlld19nZXRfYmFja19mb3J3YXJkX2xpc3Qodmlldy5nZXQoKSk7CisgICAgZ19hc3NlcnRf Y21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aChiZkxpc3QpLCA9PSwg MCk7CisgICAgd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSh2aWV3LmdldCgp LCBzdGF0ZSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3Rf Z2V0X2xlbmd0aChiZkxpc3QpLCA9PSwgMCk7CisgICAgR1JlZlB0cjxHQnl0ZXM+IGRhdGEgPSBh ZG9wdEdSZWYod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKHN0YXRlKSk7 CisgICAgZ19hc3NlcnQoZGF0YSk7CisgICAgc3RhdGUgPSB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lv bl9zdGF0ZV9uZXcoZGF0YS5nZXQoKSk7CisgICAgZ19hc3NlcnQoc3RhdGUpOworICAgIHZpZXcg PSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBiZkxpc3QgPSB3 ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9yd2FyZF9saXN0KHZpZXcuZ2V0KCkpOworICAgIGdf YXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0 KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUodmll dy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2Fy ZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19z ZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKKworICAgIENTdHJpbmcgdXJpUGFnZTEgPSBrU2Vy dmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTEiKTsKKyAgICB0ZXN0LT5tX2NoYW5nZWRGbGFncyA9 IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwgQmFja0ZvcndhcmRMaXN0VGVzdDo6 QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFnZTEuZGF0YSgpKTsKKyAgICB0ZXN0 LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIENTdHJpbmcgdXJpUGFnZTIgPSBrU2Vy dmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTIiKTsKKyAgICB0ZXN0LT5tX2NoYW5nZWRGbGFncyA9 IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwgQmFja0ZvcndhcmRMaXN0VGVzdDo6 QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFnZTIuZGF0YSgpKTsKKyAgICB0ZXN0 LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIENTdHJpbmcgdXJpUGFnZTMgPSBrU2Vy dmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTMiKTsKKyAgICB0ZXN0LT5tX2NoYW5nZWRGbGFncyA9 IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwgQmFja0ZvcndhcmRMaXN0VGVzdDo6 QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFnZTMuZGF0YSgpKTsKKyAgICB0ZXN0 LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0g QmFja0ZvcndhcmRMaXN0VGVzdDo6Q3VycmVudEl0ZW07CisgICAgdGVzdC0+Z29CYWNrKCk7Cisg ICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisKKyAgICBzdGF0ZSA9IHdlYmtpdF93 ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSh0ZXN0LT5tX3dlYlZpZXcpOworICAgIGdfYXNzZXJ0 KHN0YXRlKTsKKworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0 X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19yZXN0b3Jl X3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQo d2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDMpOworCisg ICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6Y2hlY2tJdGVtKHdlYmtpdF9iYWNrX2ZvcndhcmRfbGlz dF9nZXRfbnRoX2l0ZW0oYmZMaXN0LCAtMSksICJQYWdlMSIsIHVyaVBhZ2UxLmRhdGEoKSwgdXJp UGFnZTEuZGF0YSgpKTsKKyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjpjaGVja0l0ZW0od2Via2l0 X2JhY2tfZm9yd2FyZF9saXN0X2dldF9jdXJyZW50X2l0ZW0oYmZMaXN0KSwgIlBhZ2UyIiwgdXJp UGFnZTIuZGF0YSgpLCB1cmlQYWdlMi5kYXRhKCkpOworICAgIEJhY2tGb3J3YXJkTGlzdFRlc3Q6 OmNoZWNrSXRlbSh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X250aF9pdGVtKGJmTGlzdCwg MSksICJQYWdlMyIsIHVyaVBhZ2UzLmRhdGEoKSwgdXJpUGFnZTMuZGF0YSgpKTsKKworICAgIGRh dGEgPSBhZG9wdEdSZWYod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKHN0 YXRlKSk7CisgICAgZ19hc3NlcnQoZGF0YSk7CisgICAgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25f c3RhdGVfdW5yZWYoc3RhdGUpOworICAgIHN0YXRlID0gd2Via2l0X3dlYl92aWV3X3Nlc3Npb25f c3RhdGVfbmV3KGRhdGEuZ2V0KCkpOworICAgIGdfYXNzZXJ0KHN0YXRlKTsKKworICAgIHZpZXcg PSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBiZkxpc3QgPSB3 ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9yd2FyZF9saXN0KHZpZXcuZ2V0KCkpOworICAgIGdf YXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0 KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUodmll dy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2Fy ZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDMpOworICAgIHdlYmtpdF93ZWJfdmlld19z ZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKKworICAgIEJhY2tGb3J3YXJkTGlzdFRlc3Q6OmNo ZWNrSXRlbSh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X250aF9pdGVtKGJmTGlzdCwgLTEp LCAiUGFnZTEiLCB1cmlQYWdlMS5kYXRhKCksIHVyaVBhZ2UxLmRhdGEoKSk7CisgICAgQmFja0Zv cndhcmRMaXN0VGVzdDo6Y2hlY2tJdGVtKHdlYmtpdF9iYWNrX2ZvcndhcmRfbGlzdF9nZXRfY3Vy cmVudF9pdGVtKGJmTGlzdCksICJQYWdlMiIsIHVyaVBhZ2UyLmRhdGEoKSwgdXJpUGFnZTIuZGF0 YSgpKTsKKyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjpjaGVja0l0ZW0od2Via2l0X2JhY2tfZm9y d2FyZF9saXN0X2dldF9udGhfaXRlbShiZkxpc3QsIDEpLCAiUGFnZTMiLCB1cmlQYWdlMy5kYXRh KCksIHVyaVBhZ2UzLmRhdGEoKSk7CisKKyAgICBzdGF0aWMgY29uc3QgY2hhciogaW52YWxpZFNl c3Npb25EYXRhID0gImludmFsaWQgc2Vzc2lvbiBkYXRhIjsKKyAgICBkYXRhID0gYWRvcHRHUmVm KGdfYnl0ZXNfbmV3X3N0YXRpYyhpbnZhbGlkU2Vzc2lvbkRhdGEsIHN0cmxlbihpbnZhbGlkU2Vz c2lvbkRhdGEpKSk7CisgICAgZ19hc3NlcnQoIXdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRl X25ldyhkYXRhLmdldCgpKSk7Cit9CisKK3N0YXRpYyB2b2lkIHRlc3RXZWJLaXRXZWJWaWV3U2Vz c2lvblN0YXRlV2l0aEZvcm1EYXRhKEJhY2tGb3J3YXJkTGlzdFRlc3QqIHRlc3QsIGdjb25zdHBv aW50ZXIpCit7CisgICAgR1VuaXF1ZVB0cjxjaGFyPiBodG1sUGF0aChnX2J1aWxkX2ZpbGVuYW1l KFRlc3Q6OmdldFJlc291cmNlc0RpcihUZXN0OjpXZWJLaXQyUmVzb3VyY2VzKS5kYXRhKCksICJz aW1wbGUtZm9ybS5odG1sIiwgbnVsbHB0cikpOworICAgIEdVbmlxdWVQdHI8Y2hhcj4gaHRtbFVS TChnX2ZpbGVuYW1lX3RvX3VyaShodG1sUGF0aC5nZXQoKSwgbnVsbHB0ciwgbnVsbHB0cikpOwor ICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0ZvcndhcmRMaXN0VGVzdDo6Q3VycmVudEl0 ZW0gfCBCYWNrRm9yd2FyZExpc3RUZXN0OjpBZGRlZEl0ZW07CisgICAgdGVzdC0+bG9hZFVSSSho dG1sVVJMLmdldCgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAg IHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCh0ZXN0LT5tX3dlYlZpZXcsICJzdWJtaXRG b3JtKCk7IiwgbnVsbHB0ciwgbnVsbHB0ciwgbnVsbHB0cik7CisgICAgdGVzdC0+d2FpdFVudGls TG9hZEZpbmlzaGVkKCk7CisKKyAgICBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSA9 IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSh0ZXN0LT5tX3dlYlZpZXcpOworICAg IGdfYXNzZXJ0KHN0YXRlKTsKKyAgICBHUmVmUHRyPFdlYktpdFdlYlZpZXc+IHZpZXcgPSBXRUJL SVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBXZWJLaXRCYWNrRm9yd2Fy ZExpc3QqIGJmTGlzdCA9IHdlYmtpdF93ZWJfdmlld19nZXRfYmFja19mb3J3YXJkX2xpc3Qodmll dy5nZXQoKSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3Rf Z2V0X2xlbmd0aChiZkxpc3QpLCA9PSwgMCk7CisgICAgd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVf c2Vzc2lvbl9zdGF0ZSh2aWV3LmdldCgpLCBzdGF0ZSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3 ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aChiZkxpc3QpLCA9PSwgMik7CisgICAg R1JlZlB0cjxHQnl0ZXM+IGRhdGEgPSBhZG9wdEdSZWYod2Via2l0X3dlYl92aWV3X3Nlc3Npb25f c3RhdGVfc2VyaWFsaXplKHN0YXRlKSk7CisgICAgZ19hc3NlcnQoZGF0YSk7CisgICAgc3RhdGUg PSB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcoZGF0YS5nZXQoKSk7CisgICAgZ19h c3NlcnQoc3RhdGUpOworICAgIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3 X25ldygpKTsKKyAgICBiZkxpc3QgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9yd2FyZF9s aXN0KHZpZXcuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2Fy ZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19y ZXN0b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2Nt cHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDIp OworICAgIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKK30KKwog dm9pZCBiZWZvcmVBbGwoKQogewogICAgIGtTZXJ2ZXIgPSBuZXcgV2ViS2l0VGVzdFNlcnZlcigp OwpAQCAtMjcxLDYgKzM3Myw4IEBAIHZvaWQgYmVmb3JlQWxsKCkKIAogICAgIEJhY2tGb3J3YXJk TGlzdFRlc3Q6OmFkZCgiQmFja0ZvcndhcmRMaXN0IiwgIm5hdmlnYXRpb24iLCB0ZXN0QmFja0Zv cndhcmRMaXN0TmF2aWdhdGlvbik7CiAgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6YWRkKCJCYWNr Rm9yd2FyZExpc3QiLCAibGlzdC1saW1pdC1hbmQtY2FjaGUiLCB0ZXN0QmFja0ZvcndhcmRMaXN0 TGltaXRBbmRDYWNoZSk7CisgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6YWRkKCJXZWJLaXRXZWJW aWV3IiwgInNlc3Npb24tc3RhdGUiLCB0ZXN0V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSk7Cisg ICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgInNlc3Npb24tc3Rh dGUtd2l0aC1mb3JtLWRhdGEiLCB0ZXN0V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVdpdGhGb3Jt RGF0YSk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwoKQo= 268007 2015-12-30 10:21:29 -0800 2015-12-30 13:53:54 -0800 Rebased to apply on current trunk wk2-session-state.diff text/plain 40976 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggYThjZmU1NS4uNmM2YWMwYyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VMb2cK KysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxNS0xMi0zMCAg Q2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dU S10gQWxsb3cgdG8gc2F2ZSBhbmQgcmVzdG9yZSBzZXNzaW9uCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTU2MDAKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgR1ZhcmlhbnRJdGVyIHNwZWNpYWxpemF0 aW9uIG9mIEdVbmlxdWVQdHIuCisKKyAgICAgICAgKiB3dGYvZ2xpYi9HVHlwZWRlZnMuaDoKKyAg ICAgICAgKiB3dGYvZ2xpYi9HVW5pcXVlUHRyLmg6CisKIDIwMTUtMTItMjUgIEFuZHkgRXN0ZXMg IDxhZXN0ZXNAYXBwbGUuY29tPgogCiAgICAgICAgIFN0b3AgbW92aW5nIGxvY2FsIG9iamVjdHMg aW4gcmV0dXJuIHN0YXRlbWVudHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL2dsaWIvR1R5 cGVkZWZzLmggYi9Tb3VyY2UvV1RGL3d0Zi9nbGliL0dUeXBlZGVmcy5oCmluZGV4IDE0NTkzNzQu LjUxMDUzYzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dsaWIvR1R5cGVkZWZzLmgKKysr IGIvU291cmNlL1dURi93dGYvZ2xpYi9HVHlwZWRlZnMuaApAQCAtNjEsNiArNjEsNyBAQCB0eXBl ZGVmIHN0cnVjdCBfR1NvY2tldENvbm5lY3Rpb24gR1NvY2tldENvbm5lY3Rpb247CiB0eXBlZGVm IHN0cnVjdCBfR1NvdXJjZSBHU291cmNlOwogdHlwZWRlZiBzdHJ1Y3QgX0dWYXJpYW50IEdWYXJp YW50OwogdHlwZWRlZiBzdHJ1Y3QgX0dWYXJpYW50QnVpbGRlciBHVmFyaWFudEJ1aWxkZXI7Cit0 eXBlZGVmIHN0cnVjdCBfR1ZhcmlhbnRJdGVyIEdWYXJpYW50SXRlcjsKIHR5cGVkZWYgdW5pb24g X0dka0V2ZW50IEdka0V2ZW50OwogdHlwZWRlZiBzdHJ1Y3QgX0dUaW1lciBHVGltZXI7CiB0eXBl ZGVmIHN0cnVjdCBfR0tleUZpbGUgR0tleUZpbGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0 Zi9nbGliL0dVbmlxdWVQdHIuaCBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvR1VuaXF1ZVB0ci5oCmlu ZGV4IGNkYTQ4OGEuLmIyZDcyZDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL2dsaWIvR1Vu aXF1ZVB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL2dsaWIvR1VuaXF1ZVB0ci5oCkBAIC00NCw3 ICs0NCw4IEBAIHVzaW5nIEdVbmlxdWVQdHIgPSBzdGQ6OnVuaXF1ZV9wdHI8VCwgR1B0ckRlbGV0 ZXI8VD4+OwogICAgIG1hY3JvKEdEaXIsIGdfZGlyX2Nsb3NlKSBcCiAgICAgbWFjcm8oR1RpbWVy LCBnX3RpbWVyX2Rlc3Ryb3kpIFwKICAgICBtYWNybyhHS2V5RmlsZSwgZ19rZXlfZmlsZV9mcmVl KSBcCi0gICAgbWFjcm8oY2hhciosIGdfc3RyZnJlZXYpCisgICAgbWFjcm8oY2hhciosIGdfc3Ry ZnJlZXYpIFwKKyAgICBtYWNybyhHVmFyaWFudEl0ZXIsIGdfdmFyaWFudF9pdGVyX2ZyZWUpCiAK ICNkZWZpbmUgV1RGX0RFRklORV9HUFRSX0RFTEVURVIodHlwZU5hbWUsIGRlbGV0ZXJGdW5jKSBc CiAgICAgdGVtcGxhdGU8PiBzdHJ1Y3QgR1B0ckRlbGV0ZXI8dHlwZU5hbWU+IFwKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpp bmRleCBlYjg5ODQxLi41YmZjNWFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDggQEAKKzIwMTUt MTItMzAgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAg ICAgIFtHVEtdIEFsbG93IHRvIHNhdmUgYW5kIHJlc3RvcmUgc2Vzc2lvbgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE1NjAwCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIG5ldyBBUEkgdG8gZ2V0IGFu ZCByZXNvcmUgdGhlIHdlYiB2aWV3IHNlc3Npb24gc3RhdGUuCisKKyAgICAgICAgKiBQbGF0Zm9y bUdUSy5jbWFrZTogQWRkIG5ldyBmaWxlcyB0byBjb21waWxhdGlvbi4KKyAgICAgICAgKiBVSVBy b2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcDoKKyAgICAgICAgKHdlYmtpdF93ZWJfdmll d19nZXRfc2Vzc2lvbl9zdGF0ZSk6IENyZWF0ZSBhIG5ldworICAgICAgICBXZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlIHJlcHJlc2VudGluZyB0aGUgY3VycmVudCBzZXNzaW9uIHN0YXRlLgorICAg ICAgICAod2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSk6IFJlc3RvcmUgdGhl IHdlYiB2aWV3CisgICAgICAgIHNlc3Npb24gc3RhdGUgZm9ybSB0aGUgZ2l2ZW4gV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJW aWV3Lmg6CisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25T dGF0ZS5jcHA6IEFkZGVkLgorICAgICAgICAoX1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGU6Ol9X ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKToKKyAgICAgICAgKHRvRXh0ZXJuYWxVUkxzUG9saWN5 KToKKyAgICAgICAgKHRvV2ViQ29yZUV4dGVybmFsVVJMc1BvbGljeSk6CisgICAgICAgICh0b0hU TUxCb2R5RWxlbWVudFR5cGUpOgorICAgICAgICAodG9IVFRQQm9keUVsZW1lbnRUeXBlKToKKyAg ICAgICAgKGVuY29kZUhUVFBCb2R5KToKKyAgICAgICAgKGVuY29kZUZyYW1lU3RhdGUpOgorICAg ICAgICAoZW5jb2RlUGFnZVN0YXRlKToKKyAgICAgICAgKGVuY29kZUJhY2tGb3J3YXJkTGlzdEl0 ZW1TdGF0ZSk6CisgICAgICAgIChlbmNvZGVCYWNrRm9yd2FyZExpc3RTdGF0ZSk6CisgICAgICAg IChlbmNvZGVTZXNzaW9uU3RhdGUpOgorICAgICAgICAoZGVjb2RlSFRUUEJvZHkpOgorICAgICAg ICAoZGVjb2RlRnJhbWVTdGF0ZSk6CisgICAgICAgIChkZWNvZGVCYWNrRm9yd2FyZExpc3RJdGVt U3RhdGUpOgorICAgICAgICAoZGVjb2RlU2Vzc2lvblN0YXRlKToKKyAgICAgICAgKHdlYmtpdFdl YlZpZXdTZXNzaW9uU3RhdGVDcmVhdGUpOgorICAgICAgICAod2Via2l0V2ViVmlld1Nlc3Npb25T dGF0YXRlR2V0U2Vzc2lvblN0YXRlKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19zZXNzaW9u X3N0YXRlX25ldyk6IENyZWF0ZSBhCisgICAgICAgIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUg ZnJvbSBzZXJpYWxpemVkIGRhdGEuCisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9z dGF0ZV9yZWYpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYp OgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKTogU2Vy aWFsaXplIHRoZSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLgorICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaDogQWRkZWQuCisgICAgICAgICog VUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaDogQWRk ZWQuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0 aW9ucy50eHQ6IEFkZCBuZXcgc3ltYm9scy4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9k b2NzL3dlYmtpdDJndGstNC4wLnR5cGVzOiBBZGQgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3Rh dGVfZ2V0X3R5cGUuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oOiBJbmNs dWRlIFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaC4KKwogMjAxNS0xMi0zMCAgWmFuIERvYmVy c2VrICA8emRvYmVyc2VrQGlnYWxpYS5jb20+CiAKICAgICAgICAgW1RleE1hcF0gQ2xlYW4gdXAg VGV4dHVyZU1hcHBlckFuaW1hdGlvbiwgVGV4dHVyZU1hcHBlckFuaW1hdGlvbnMKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxh dGZvcm1HVEsuY21ha2UKaW5kZXggZDZhMDg0My4uODljNjQ2NSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1H VEsuY21ha2UKQEAgLTI2Myw2ICsyNjMsOSBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMK ICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZUFjY2Vzc2libGUuaAogICAg IFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oCiAgICAgVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1ByaXZhdGUuaAorICAgIFVJUHJvY2Vzcy9BUEkvZ3Rr L1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuY3BwCisgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2Vi S2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5oCisgICAgVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YnNpdGVEYXRhTWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJzaXRl RGF0YU1hbmFnZXIuaAogICAgIFVJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYnNpdGVEYXRhTWFu YWdlclByaXZhdGUuaApAQCAtNDI4LDYgKzQzMSw3IEBAIHNldChXZWJLaXQyR1RLX0lOU1RBTExF RF9IRUFERVJTCiAgICAgJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi UmVzb3VyY2UuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdl YlZpZXcuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZp ZXdCYXNlLmgKKyAgICAke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJW aWV3U2Vzc2lvblN0YXRlLmgKICAgICAke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvQVBJL2d0ay9X ZWJLaXRXZWJzaXRlRGF0YU1hbmFnZXIuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdpbmRvd1Byb3BlcnRpZXMuaAogICAgICR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9BUEkvZ3RrL3dlYmtpdDIuaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcAppbmRleCA2YjI1YzdiLi5kNDYwNzA2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3LmNwcApA QCAtNjEsNiArNjEsNyBAQAogI2luY2x1ZGUgIldlYktpdFdlYlJlc291cmNlUHJpdmF0ZS5oIgog I2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYXNlUHJpdmF0ZS5oIgogI2luY2x1ZGUgIldlYktpdFdl YlZpZXdQcml2YXRlLmgiCisjaW5jbHVkZSAiV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZh dGUuaCIKICNpbmNsdWRlICJXZWJLaXRXaW5kb3dQcm9wZXJ0aWVzUHJpdmF0ZS5oIgogI2luY2x1 ZGUgPEphdmFTY3JpcHRDb3JlL0FQSUNhc3QuaD4KICNpbmNsdWRlIDxXZWJDb3JlL0NlcnRpZmlj YXRlSW5mby5oPgpAQCAtMzcxNywzICszNzE4LDM4IEBAIFdlYktpdEVkaXRvclN0YXRlKiB3ZWJr aXRfd2ViX3ZpZXdfZ2V0X2VkaXRvcl9zdGF0ZShXZWJLaXRXZWJWaWV3ICp3ZWJWaWV3KQogCiAg ICAgcmV0dXJuIHdlYlZpZXctPnByaXYtPmVkaXRvclN0YXRlLmdldCgpOwogfQorCisvKioKKyAq IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZToKKyAqIEB3ZWJfdmlldzogYSAjV2Vi S2l0V2ViVmlldworICoKKyAqIEdldHMgdGhlIGN1cnJlbnQgc2Vzc2lvbiBzdGF0ZSBvZiBAd2Vi X3ZpZXcKKyAqCisgKiBSZXR1cm5zOiAodHJhbnNmZXIgZnVsbCk6IGEgI1dlYktpdFdlYlZpZXdT ZXNzaW9uU3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICovCitXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUoV2ViS2l0V2ViVmlldyog d2ViVmlldykKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVco d2ViVmlldyksIG51bGxwdHIpOworCisgICAgU2Vzc2lvblN0YXRlIHNlc3Npb25TdGF0ZSA9IGdl dFBhZ2Uod2ViVmlldyktPnNlc3Npb25TdGF0ZShudWxscHRyKTsKKyAgICByZXR1cm4gd2Via2l0 V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXVEY6Om1vdmUoc2Vzc2lvblN0YXRlKSk7Cit9CisK Ky8qKgorICogd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZToKKyAqIEB3ZWJf dmlldzogYSAjV2ViS2l0V2ViVmlldworICogQHN0YXRlOiBhICNXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlCisgKgorICogUmVzdG9yZSB0aGUgQHdlYl92aWV3IHNlc3Npb24gc3RhdGUgZnJvbSBA c3RhdGUKKyAqCisgKiBTaW5jZTogMi4xMgorICovCit2b2lkIHdlYmtpdF93ZWJfdmlld19yZXN0 b3JlX3Nlc3Npb25fc3RhdGUoV2ViS2l0V2ViVmlldyogd2ViVmlldywgV2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZSogc3RhdGUpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VC X1ZJRVcod2ViVmlldykpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoc3RhdGUpOworCisgICAgZ2V0 UGFnZSh3ZWJWaWV3KS0+cmVzdG9yZUZyb21TZXNzaW9uU3RhdGUod2Via2l0V2ViVmlld1Nlc3Np b25TdGF0YXRlR2V0U2Vzc2lvblN0YXRlKHN0YXRlKSwgZmFsc2UpOworfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5oIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlldy5oCmluZGV4IDA1ZWM5YTku LjcwMDk2OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1dl YktpdFdlYlZpZXcuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJL aXRXZWJWaWV3LmgKQEAgLTUyLDYgKzUyLDcgQEAKICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdl Ykluc3BlY3Rvci5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2ViUmVzb3VyY2UuaD4KICNp bmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYlZpZXdCYXNlLmg+CisjaW5jbHVkZSA8d2Via2l0Mi9X ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXaW5k b3dQcm9wZXJ0aWVzLmg+CiAKIEdfQkVHSU5fREVDTFMKQEAgLTUwNSw2ICs1MDYsMTMgQEAgd2Vi a2l0X3dlYl92aWV3X3NldF9lZGl0YWJsZSAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0 V2ViVmlldwogV0VCS0lUX0FQSSBXZWJLaXRFZGl0b3JTdGF0ZSAqCiB3ZWJraXRfd2ViX3ZpZXdf Z2V0X2VkaXRvcl9zdGF0ZSAgICAgICAgICAgICAgICAgICAgIChXZWJLaXRXZWJWaWV3ICAgICAg ICAgICAgICp3ZWJfdmlldyk7CiAKK1dFQktJVF9BUEkgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0 ZSAqCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUgICAgICAgICAgICAgICAgICAg IChXZWJLaXRXZWJWaWV3ICAgICAgICAgICAgICp3ZWJfdmlldyk7CisKK1dFQktJVF9BUEkgdm9p ZAord2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSAgICAgICAgICAgICAgICAo V2ViS2l0V2ViVmlldyAgICAgICAgICAgICAqd2ViX3ZpZXcsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0 YXRlICpzdGF0ZSk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZS5jcHAg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0 YXRlLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NWFmM2JiCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZS5jcHAKQEAgLTAsMCArMSw0NTIgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTYgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5M SUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjEx MC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGUuaCIKKworI2luY2x1ZGUgIldlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGVQcml2YXRlLmgiCisjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0ci5oPgorI2luY2x1ZGUg PHd0Zi9nbGliL0dVbmlxdWVQdHIuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKKworc3Ry dWN0IF9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlIHsKKyAgICBfV2ViS2l0V2ViVmlld1Nlc3Np b25TdGF0ZShTZXNzaW9uU3RhdGUmJiBzdGF0ZSkKKyAgICAgICAgOiBzZXNzaW9uU3RhdGUoV1RG Ojptb3ZlKHN0YXRlKSkKKyAgICAgICAgLCByZWZlcmVuY2VDb3VudCgxKQorICAgIHsKKyAgICB9 CisKKyAgICBTZXNzaW9uU3RhdGUgc2Vzc2lvblN0YXRlOworICAgIGludCByZWZlcmVuY2VDb3Vu dDsKK307CisKK0dfREVGSU5FX0JPWEVEX1RZUEUoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSwg d2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGUsIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0 YXRlX3JlZiwgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYpCisKK3N0YXRpYyBj b25zdCBndWludDE2IGdfc2Vzc2lvblN0YXRlVmVyc2lvbiA9IDE7CisjZGVmaW5lIEhUVFBfQk9E WV9FTEVNRU5UX1RZUEVfU1RSSU5HX1YxICIodWF5c3hteG1kcykiCisjZGVmaW5lIEhUVFBfQk9E WV9FTEVNRU5UX0ZPUk1BVF9TVFJJTkdfVjEgIih1YXkmc3hteG1kJnMpIgorI2RlZmluZSBIVFRQ X0JPRFlfVFlQRV9TVFJJTkdfVjEgIm0oc2EiIEhUVFBfQk9EWV9FTEVNRU5UX1RZUEVfU1RSSU5H X1YxICIpIgorI2RlZmluZSBIVFRQX0JPRFlfRk9STUFUX1NUUklOR19WMSAibSgmc2EiIEhUVFBf Qk9EWV9FTEVNRU5UX1RZUEVfU1RSSU5HX1YxICIpIgorI2RlZmluZSBGUkFNRV9TVEFURV9UWVBF X1NUUklOR19WMSAgIihzc3NzYXNtYXl0dChpaSlkIiBIVFRQX0JPRFlfVFlQRV9TVFJJTkdfVjEg ImF2KSIKKyNkZWZpbmUgRlJBTUVfU1RBVEVfRk9STUFUX1NUUklOR19WMSAgIigmcyZzJnMmc2Fz bWF5dHQoaWkpZEAiIEhUVFBfQk9EWV9UWVBFX1NUUklOR19WMSAiYXYpIgorI2RlZmluZSBCQUNL X0ZPUldBUkRfTElTVF9JVEVNX1RZUEVfU1RSSU5HX1YxICAiKHRzIiBGUkFNRV9TVEFURV9UWVBF X1NUUklOR19WMSAidSkiCisjZGVmaW5lIEJBQ0tfRk9SV0FSRF9MSVNUX0lURU1fRk9STUFUX1NU UklOR19WMSAgIih0JnNAIiBGUkFNRV9TVEFURV9UWVBFX1NUUklOR19WMSAidSkiCisjZGVmaW5l IFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEgICIocWEiIEJBQ0tfRk9SV0FSRF9MSVNUX0lU RU1fVFlQRV9TVFJJTkdfVjEgIm11KSIKKworZW51bSBFeHRlcm5hbFVSTHNQb2xpY3kgeworICAg IEFsbG93LAorICAgIEFsbG93RXh0ZXJuYWxTY2hlbWVzLAorICAgIE5vdEFsbG93Cit9OworCitz dGF0aWMgaW5saW5lIHVuc2lnbmVkIHRvRXh0ZXJuYWxVUkxzUG9saWN5KFdlYkNvcmU6OlNob3Vs ZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3kgcG9saWN5KQoreworICAgIHN3aXRjaCAocG9saWN5KSB7 CisgICAgY2FzZSBXZWJDb3JlOjpTaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9saWN5OjpTaG91bGRB bGxvdzoKKyAgICAgICAgcmV0dXJuIEV4dGVybmFsVVJMc1BvbGljeTo6QWxsb3c7CisgICAgY2Fz ZSBXZWJDb3JlOjpTaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9saWN5OjpTaG91bGRBbGxvd0V4dGVy bmFsU2NoZW1lczoKKyAgICAgICAgcmV0dXJuIEV4dGVybmFsVVJMc1BvbGljeTo6QWxsb3dFeHRl cm5hbFNjaGVtZXM7CisgICAgY2FzZSBXZWJDb3JlOjpTaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9s aWN5OjpTaG91bGROb3RBbGxvdzoKKyAgICAgICAgcmV0dXJuIEV4dGVybmFsVVJMc1BvbGljeTo6 Tm90QWxsb3c7CisgICAgfQorCisgICAgcmV0dXJuIEV4dGVybmFsVVJMc1BvbGljeTo6Tm90QWxs b3c7Cit9CisKK3N0YXRpYyBpbmxpbmUgV2ViQ29yZTo6U2hvdWxkT3BlbkV4dGVybmFsVVJMc1Bv bGljeSB0b1dlYkNvcmVFeHRlcm5hbFVSTHNQb2xpY3kodW5zaWduZWQgcG9saWN5KQoreworICAg IHN3aXRjaCAocG9saWN5KSB7CisgICAgY2FzZSBFeHRlcm5hbFVSTHNQb2xpY3k6OkFsbG93Ogor ICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGljeTo6U2hv dWxkQWxsb3c7CisgICAgY2FzZSBFeHRlcm5hbFVSTHNQb2xpY3k6OkFsbG93RXh0ZXJuYWxTY2hl bWVzOgorICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGlj eTo6U2hvdWxkQWxsb3dFeHRlcm5hbFNjaGVtZXM7CisgICAgY2FzZSBFeHRlcm5hbFVSTHNQb2xp Y3k6Ok5vdEFsbG93OgorICAgICAgICByZXR1cm4gV2ViQ29yZTo6U2hvdWxkT3BlbkV4dGVybmFs VVJMc1BvbGljeTo6U2hvdWxkTm90QWxsb3c7CisgICAgfQorCisgICAgcmV0dXJuIFdlYkNvcmU6 OlNob3VsZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3k6OlNob3VsZE5vdEFsbG93OworfQorCitlbnVt IEhUTUxCb2R5RWxlbWVudFR5cGUgeworICAgIERhdGEsCisgICAgRmlsZSwKKyAgICBCbG9iCit9 OworCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIHRvSFRNTEJvZHlFbGVtZW50VHlwZShIVFRQQm9k eTo6RWxlbWVudDo6VHlwZSB0eXBlKQoreworICAgIHN3aXRjaCAodHlwZSkgeworICAgIGNhc2Ug SFRUUEJvZHk6OkVsZW1lbnQ6OlR5cGU6OkRhdGE6CisgICAgICAgIHJldHVybiBIVE1MQm9keUVs ZW1lbnRUeXBlOjpEYXRhOworICAgIGNhc2UgSFRUUEJvZHk6OkVsZW1lbnQ6OlR5cGU6OkZpbGU6 CisgICAgICAgIHJldHVybiBIVE1MQm9keUVsZW1lbnRUeXBlOjpGaWxlOworICAgIGNhc2UgSFRU UEJvZHk6OkVsZW1lbnQ6OlR5cGU6OkJsb2I6CisgICAgICAgIHJldHVybiBIVE1MQm9keUVsZW1l bnRUeXBlOjpCbG9iOworICAgIH0KKworICAgIHJldHVybiBIVE1MQm9keUVsZW1lbnRUeXBlOjpE YXRhOworfQorCitzdGF0aWMgaW5saW5lIEhUVFBCb2R5OjpFbGVtZW50OjpUeXBlIHRvSFRUUEJv ZHlFbGVtZW50VHlwZSh1bnNpZ25lZCB0eXBlKQoreworICAgIHN3aXRjaCAodHlwZSkgeworICAg IGNhc2UgSFRNTEJvZHlFbGVtZW50VHlwZTo6RGF0YToKKyAgICAgICAgcmV0dXJuIEhUVFBCb2R5 OjpFbGVtZW50OjpUeXBlOjpEYXRhOworICAgIGNhc2UgSFRNTEJvZHlFbGVtZW50VHlwZTo6Rmls ZToKKyAgICAgICAgcmV0dXJuIEhUVFBCb2R5OjpFbGVtZW50OjpUeXBlOjpGaWxlOworICAgIGNh c2UgSFRNTEJvZHlFbGVtZW50VHlwZTo6QmxvYjoKKyAgICAgICAgcmV0dXJuIEhUVFBCb2R5OjpF bGVtZW50OjpUeXBlOjpCbG9iOworICAgIH0KKworICAgIHJldHVybiBIVFRQQm9keTo6RWxlbWVu dDo6VHlwZTo6RGF0YTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29kZUhUVFBCb2R5KEdW YXJpYW50QnVpbGRlciogc2Vzc2lvbkJ1aWxkZXIsIGNvbnN0IEhUVFBCb2R5JiBodHRwQm9keSkK K3sKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRf VFlQRSgiKHNhIiBIVFRQX0JPRFlfRUxFTUVOVF9UWVBFX1NUUklOR19WMSAiKSIpKTsKKyAgICBn X3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgaHR0cEJvZHkuY29udGVu dFR5cGUudXRmOCgpLmRhdGEoKSk7CisgICAgZ192YXJpYW50X2J1aWxkZXJfb3BlbihzZXNzaW9u QnVpbGRlciwgR19WQVJJQU5UX1RZUEUoImEiIEhUVFBfQk9EWV9FTEVNRU5UX1RZUEVfU1RSSU5H X1YxKSk7CisgICAgZ192YXJpYW50X2J1aWxkZXJfb3BlbihzZXNzaW9uQnVpbGRlciwgR19WQVJJ QU5UX1RZUEUoSFRUUF9CT0RZX0VMRU1FTlRfVFlQRV9TVFJJTkdfVjEpKTsKKyAgICBmb3IgKGNv bnN0IGF1dG8mIGVsZW1lbnQgOiBodHRwQm9keS5lbGVtZW50cykgeworICAgICAgICBnX3Zhcmlh bnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJ1IiwgdG9IVE1MQm9keUVsZW1lbnRUeXBl KGVsZW1lbnQudHlwZSkpOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25C dWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgiYXkiKSk7CisgICAgICAgIGZvciAoYXV0byBpdGVtIDog ZWxlbWVudC5kYXRhKQorICAgICAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25C dWlsZGVyLCAieSIsIGl0ZW0pOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9zZShzZXNz aW9uQnVpbGRlcik7CisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRl ciwgInMiLCBlbGVtZW50LmZpbGVQYXRoLnV0ZjgoKS5kYXRhKCkpOworICAgICAgICBnX3Zhcmlh bnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJ4IiwgZWxlbWVudC5maWxlU3RhcnQpOwor ICAgICAgICBpZiAoZWxlbWVudC5maWxlTGVuZ3RoKQorICAgICAgICAgICAgZ192YXJpYW50X2J1 aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAibXgiLCBUUlVFLCBlbGVtZW50LmZpbGVMZW5ndGgu dmFsdWUoKSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2Fk ZChzZXNzaW9uQnVpbGRlciwgIm14IiwgRkFMU0UpOworICAgICAgICBpZiAoZWxlbWVudC5leHBl Y3RlZEZpbGVNb2RpZmljYXRpb25UaW1lKQorICAgICAgICAgICAgZ192YXJpYW50X2J1aWxkZXJf YWRkKHNlc3Npb25CdWlsZGVyLCAibWQiLCBUUlVFLCBlbGVtZW50LmV4cGVjdGVkRmlsZU1vZGlm aWNhdGlvblRpbWUudmFsdWUoKSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGdfdmFyaWFu dF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgIm1kIiwgRkFMU0UpOworICAgICAgICBnX3Zh cmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZWxlbWVudC5ibG9iVVJMU3Ry aW5nLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9zZShz ZXNzaW9uQnVpbGRlcik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfY2xvc2Uoc2Vzc2lvbkJ1aWxk ZXIpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2Nsb3NlKHNlc3Npb25CdWlsZGVyKTsKK30KKwor c3RhdGljIGlubGluZSB2b2lkIGVuY29kZUZyYW1lU3RhdGUoR1ZhcmlhbnRCdWlsZGVyKiBzZXNz aW9uQnVpbGRlciwgY29uc3QgRnJhbWVTdGF0ZSYgZnJhbWVTdGF0ZSkKK3sKKyAgICBnX3Zhcmlh bnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRShGUkFNRV9TVEFU RV9UWVBFX1NUUklOR19WMSkpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVp bGRlciwgInMiLCBmcmFtZVN0YXRlLnVybFN0cmluZy51dGY4KCkuZGF0YSgpKTsKKyAgICBnX3Zh cmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZnJhbWVTdGF0ZS5vcmlnaW5h bFVSTFN0cmluZy51dGY4KCkuZGF0YSgpKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vz c2lvbkJ1aWxkZXIsICJzIiwgZnJhbWVTdGF0ZS5yZWZlcnJlci51dGY4KCkuZGF0YSgpKTsKKyAg ICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIsICJzIiwgZnJhbWVTdGF0ZS50 YXJnZXQudXRmOCgpLmRhdGEoKSk7CisgICAgZ192YXJpYW50X2J1aWxkZXJfb3BlbihzZXNzaW9u QnVpbGRlciwgR19WQVJJQU5UX1RZUEUoImFzIikpOworICAgIGZvciAoY29uc3QgYXV0byYgc3Rh dGUgOiBmcmFtZVN0YXRlLmRvY3VtZW50U3RhdGUpCisgICAgICAgIGdfdmFyaWFudF9idWlsZGVy X2FkZChzZXNzaW9uQnVpbGRlciwgInMiLCBzdGF0ZS51dGY4KCkuZGF0YSgpKTsKKyAgICBnX3Zh cmlhbnRfYnVpbGRlcl9jbG9zZShzZXNzaW9uQnVpbGRlcik7CisgICAgaWYgKCFmcmFtZVN0YXRl LnN0YXRlT2JqZWN0RGF0YSkKKyAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25C dWlsZGVyLCAibWF5IiwgRkFMU0UpOworICAgIGVsc2UgeworICAgICAgICBnX3ZhcmlhbnRfYnVp bGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgibWF5IikpOworICAgICAg ICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgi YXkiKSk7CisgICAgICAgIGZvciAoYXV0byBpdGVtIDogZnJhbWVTdGF0ZS5zdGF0ZU9iamVjdERh dGEudmFsdWUoKSkKKyAgICAgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVp bGRlciwgInkiLCBpdGVtKTsKKyAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfY2xvc2Uoc2Vzc2lv bkJ1aWxkZXIpOworICAgICAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9zZShzZXNzaW9uQnVpbGRl cik7CisgICAgfQorICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInQi LCBmcmFtZVN0YXRlLmRvY3VtZW50U2VxdWVuY2VOdW1iZXIpOworICAgIGdfdmFyaWFudF9idWls ZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInQiLCBmcmFtZVN0YXRlLml0ZW1TZXF1ZW5jZU51bWJl cik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAiKGlpKSIsIGZy YW1lU3RhdGUuc2Nyb2xsUG9pbnQueCgpLCBmcmFtZVN0YXRlLnNjcm9sbFBvaW50LnkoKSk7Cisg ICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAiZCIsIGZyYW1lU3RhdGUu cGFnZVNjYWxlRmFjdG9yKTsKKyAgICBpZiAoIWZyYW1lU3RhdGUuaHR0cEJvZHkpCisgICAgICAg IGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgSFRUUF9CT0RZX1RZUEVfU1RS SU5HX1YxLCBGQUxTRSk7CisgICAgZWxzZSB7CisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX29w ZW4oc2Vzc2lvbkJ1aWxkZXIsIEdfVkFSSUFOVF9UWVBFKEhUVFBfQk9EWV9UWVBFX1NUUklOR19W MSkpOworICAgICAgICBlbmNvZGVIVFRQQm9keShzZXNzaW9uQnVpbGRlciwgZnJhbWVTdGF0ZS5o dHRwQm9keS52YWx1ZSgpKTsKKyAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfY2xvc2Uoc2Vzc2lv bkJ1aWxkZXIpOworICAgIH0KKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9vcGVuKHNlc3Npb25CdWls ZGVyLCBHX1ZBUklBTlRfVFlQRSgiYXYiKSk7CisgICAgZm9yIChjb25zdCBhdXRvJiBjaGlsZCA6 IGZyYW1lU3RhdGUuY2hpbGRyZW4pCisgICAgICAgIGVuY29kZUZyYW1lU3RhdGUoc2Vzc2lvbkJ1 aWxkZXIsIGNoaWxkKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9jbG9zZShzZXNzaW9uQnVpbGRl cik7CisgICAgZ192YXJpYW50X2J1aWxkZXJfY2xvc2Uoc2Vzc2lvbkJ1aWxkZXIpOworfQorCitz dGF0aWMgaW5saW5lIHZvaWQgZW5jb2RlUGFnZVN0YXRlKEdWYXJpYW50QnVpbGRlciogc2Vzc2lv bkJ1aWxkZXIsIGNvbnN0IFBhZ2VTdGF0ZSYgcGFnZVN0YXRlKQoreworICAgIGdfdmFyaWFudF9i dWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgInMiLCBwYWdlU3RhdGUudGl0bGUudXRmOCgpLmRh dGEoKSk7CisgICAgZW5jb2RlRnJhbWVTdGF0ZShzZXNzaW9uQnVpbGRlciwgcGFnZVN0YXRlLm1h aW5GcmFtZVN0YXRlKTsKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9hZGQoc2Vzc2lvbkJ1aWxkZXIs ICJ1IiwgdG9FeHRlcm5hbFVSTHNQb2xpY3kocGFnZVN0YXRlLnNob3VsZE9wZW5FeHRlcm5hbFVS THNQb2xpY3kpKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29kZUJhY2tGb3J3YXJkTGlz dEl0ZW1TdGF0ZShHVmFyaWFudEJ1aWxkZXIqIHNlc3Npb25CdWlsZGVyLCBjb25zdCBCYWNrRm9y d2FyZExpc3RJdGVtU3RhdGUmIGl0ZW0pCit7CisgICAgZ192YXJpYW50X2J1aWxkZXJfb3Blbihz ZXNzaW9uQnVpbGRlciwgR19WQVJJQU5UX1RZUEUoQkFDS19GT1JXQVJEX0xJU1RfSVRFTV9UWVBF X1NUUklOR19WMSkpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwg InQiLCBpdGVtLmlkZW50aWZpZXIpOworICAgIGVuY29kZVBhZ2VTdGF0ZShzZXNzaW9uQnVpbGRl ciwgaXRlbS5wYWdlU3RhdGUpOworICAgIGdfdmFyaWFudF9idWlsZGVyX2Nsb3NlKHNlc3Npb25C dWlsZGVyKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGVuY29kZUJhY2tGb3J3YXJkTGlzdFN0 YXRlKEdWYXJpYW50QnVpbGRlciogc2Vzc2lvbkJ1aWxkZXIsIGNvbnN0IEJhY2tGb3J3YXJkTGlz dFN0YXRlJiBiYWNrRm9yd2FyZExpc3RTdGF0ZSkKK3sKKyAgICBnX3ZhcmlhbnRfYnVpbGRlcl9v cGVuKHNlc3Npb25CdWlsZGVyLCBHX1ZBUklBTlRfVFlQRSgiYSIgQkFDS19GT1JXQVJEX0xJU1Rf SVRFTV9UWVBFX1NUUklOR19WMSkpOworICAgIGZvciAoY29uc3QgYXV0byYgaXRlbSA6IGJhY2tG b3J3YXJkTGlzdFN0YXRlLml0ZW1zKQorICAgICAgICBlbmNvZGVCYWNrRm9yd2FyZExpc3RJdGVt U3RhdGUoc2Vzc2lvbkJ1aWxkZXIsIGl0ZW0pOworICAgIGdfdmFyaWFudF9idWlsZGVyX2Nsb3Nl KHNlc3Npb25CdWlsZGVyKTsKKworICAgIGlmIChiYWNrRm9yd2FyZExpc3RTdGF0ZS5jdXJyZW50 SW5kZXgpCisgICAgICAgIGdfdmFyaWFudF9idWlsZGVyX2FkZChzZXNzaW9uQnVpbGRlciwgIm11 IiwgVFJVRSwgYmFja0ZvcndhcmRMaXN0U3RhdGUuY3VycmVudEluZGV4LnZhbHVlKCkpOworICAg IGVsc2UKKyAgICAgICAgZ192YXJpYW50X2J1aWxkZXJfYWRkKHNlc3Npb25CdWlsZGVyLCAibXUi LCBGQUxTRSk7Cit9CisKK3N0YXRpYyBHQnl0ZXMqIGVuY29kZVNlc3Npb25TdGF0ZShjb25zdCBT ZXNzaW9uU3RhdGUmIHNlc3Npb25TdGF0ZSkKK3sKKyAgICBHVmFyaWFudEJ1aWxkZXIgc2Vzc2lv bkJ1aWxkZXI7CisgICAgZ192YXJpYW50X2J1aWxkZXJfaW5pdCgmc2Vzc2lvbkJ1aWxkZXIsIEdf VkFSSUFOVF9UWVBFKFNFU1NJT05fU1RBVEVfVFlQRV9TVFJJTkdfVjEpKTsKKyAgICBnX3Zhcmlh bnRfYnVpbGRlcl9hZGQoJnNlc3Npb25CdWlsZGVyLCAicSIsIGdfc2Vzc2lvblN0YXRlVmVyc2lv bik7CisgICAgZW5jb2RlQmFja0ZvcndhcmRMaXN0U3RhdGUoJnNlc3Npb25CdWlsZGVyLCBzZXNz aW9uU3RhdGUuYmFja0ZvcndhcmRMaXN0U3RhdGUpOworICAgIEdSZWZQdHI8R1ZhcmlhbnQ+IHZh cmlhbnQgPSBnX3ZhcmlhbnRfYnVpbGRlcl9lbmQoJnNlc3Npb25CdWlsZGVyKTsKKyAgICByZXR1 cm4gZ192YXJpYW50X2dldF9kYXRhX2FzX2J5dGVzKHZhcmlhbnQuZ2V0KCkpOworfQorCitzdGF0 aWMgaW5saW5lIGJvb2wgZGVjb2RlSFRUUEJvZHkoR1ZhcmlhbnQqIGh0dHBCb2R5VmFyaWFudCwg SFRUUEJvZHkmIGh0dHBCb2R5KQoreworICAgIGdib29sZWFuIGhhc0hUVFBCb2R5OworICAgIGNv bnN0IGNoYXIqIGNvbnRlbnRUeXBlOworICAgIEdVbmlxdWVPdXRQdHI8R1ZhcmlhbnRJdGVyPiBl bGVtZW50c0l0ZXI7CisgICAgZ192YXJpYW50X2dldChodHRwQm9keVZhcmlhbnQsIEhUVFBfQk9E WV9GT1JNQVRfU1RSSU5HX1YxLCAmaGFzSFRUUEJvZHksICZjb250ZW50VHlwZSwgJmVsZW1lbnRz SXRlci5vdXRQdHIoKSk7CisgICAgaWYgKCFoYXNIVFRQQm9keSkKKyAgICAgICAgcmV0dXJuIGZh bHNlOworICAgIGh0dHBCb2R5LmNvbnRlbnRUeXBlID0gU3RyaW5nOjpmcm9tVVRGOChjb250ZW50 VHlwZSk7CisgICAgZ3NpemUgZWxlbWVudHNMZW5ndGggPSBnX3ZhcmlhbnRfaXRlcl9uX2NoaWxk cmVuKGVsZW1lbnRzSXRlci5nZXQoKSk7CisgICAgaWYgKCFlbGVtZW50c0xlbmd0aCkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgaHR0cEJvZHkuZWxlbWVudHMucmVzZXJ2ZUluaXRpYWxDYXBh Y2l0eShlbGVtZW50c0xlbmd0aCk7CisgICAgdW5zaWduZWQgdHlwZTsKKyAgICBHVmFyaWFudEl0 ZXIqIGRhdGFJdGVyOworICAgIGNvbnN0IGNoYXIqIGZpbGVQYXRoOworICAgIGdpbnQ2NCBmaWxl U3RhcnQ7CisgICAgZ2Jvb2xlYW4gaGFzRmlsZUxlbmd0aDsKKyAgICBnaW50NjQgZmlsZUxlbmd0 aDsKKyAgICBnYm9vbGVhbiBoYXNGaWxlTW9kaWZpY2F0aW9uVGltZTsKKyAgICBnZG91YmxlIGZp bGVNb2RpZmljYXRpb25UaW1lOworICAgIGNvbnN0IGNoYXIqIGJsb2JVUkxTdHJpbmc7CisgICAg d2hpbGUgKGdfdmFyaWFudF9pdGVyX2xvb3AoZWxlbWVudHNJdGVyLmdldCgpLCBIVFRQX0JPRFlf RUxFTUVOVF9GT1JNQVRfU1RSSU5HX1YxLCAmdHlwZSwgJmRhdGFJdGVyLCAmZmlsZVBhdGgsICZm aWxlU3RhcnQsICZoYXNGaWxlTGVuZ3RoLCAmZmlsZUxlbmd0aCwgJmhhc0ZpbGVNb2RpZmljYXRp b25UaW1lLCAmZmlsZU1vZGlmaWNhdGlvblRpbWUsICZibG9iVVJMU3RyaW5nKSkgeworICAgICAg ICBIVFRQQm9keTo6RWxlbWVudCBlbGVtZW50OworICAgICAgICBlbGVtZW50LnR5cGUgPSB0b0hU VFBCb2R5RWxlbWVudFR5cGUodHlwZSk7CisgICAgICAgIGlmIChnc2l6ZSBkYXRhTGVuZ3RoID0g Z192YXJpYW50X2l0ZXJfbl9jaGlsZHJlbihkYXRhSXRlcikpIHsKKyAgICAgICAgICAgIGVsZW1l bnQuZGF0YS5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KGRhdGFMZW5ndGgpOworICAgICAgICAgICAg Z3VjaGFyIGRhdGFWYWx1ZTsKKyAgICAgICAgICAgIHdoaWxlIChnX3ZhcmlhbnRfaXRlcl9uZXh0 KGRhdGFJdGVyLCAieSIsICZkYXRhVmFsdWUpKQorICAgICAgICAgICAgICAgIGVsZW1lbnQuZGF0 YS51bmNoZWNrZWRBcHBlbmQoZGF0YVZhbHVlKTsKKyAgICAgICAgfQorICAgICAgICBlbGVtZW50 LmZpbGVQYXRoID0gU3RyaW5nOjpmcm9tVVRGOChmaWxlUGF0aCk7CisgICAgICAgIGVsZW1lbnQu ZmlsZVN0YXJ0ID0gZmlsZVN0YXJ0OworICAgICAgICBpZiAoaGFzRmlsZUxlbmd0aCkKKyAgICAg ICAgICAgIGVsZW1lbnQuZmlsZUxlbmd0aCA9IGZpbGVMZW5ndGg7CisgICAgICAgIGlmIChoYXNG aWxlTW9kaWZpY2F0aW9uVGltZSkKKyAgICAgICAgICAgIGVsZW1lbnQuZXhwZWN0ZWRGaWxlTW9k aWZpY2F0aW9uVGltZSA9IGZpbGVNb2RpZmljYXRpb25UaW1lOworICAgICAgICBlbGVtZW50LmJs b2JVUkxTdHJpbmcgPSBTdHJpbmc6OmZyb21VVEY4KGJsb2JVUkxTdHJpbmcpOworCisgICAgICAg IGh0dHBCb2R5LmVsZW1lbnRzLnVuY2hlY2tlZEFwcGVuZChXVEY6Om1vdmUoZWxlbWVudCkpOwor ICAgIH0KKworICAgIHJldHVybiB0cnVlOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgZGVjb2Rl RnJhbWVTdGF0ZShHVmFyaWFudCogZnJhbWVTdGF0ZVZhcmlhbnQsIEZyYW1lU3RhdGUmIGZyYW1l U3RhdGUpCit7CisgICAgY29uc3QgY2hhciogdXJsU3RyaW5nOworICAgIGNvbnN0IGNoYXIqIG9y aWdpbmFsVVJMU3RyaW5nOworICAgIGNvbnN0IGNoYXIqIHJlZmVycmVyOworICAgIGNvbnN0IGNo YXIqIHRhcmdldDsKKyAgICBHVW5pcXVlT3V0UHRyPEdWYXJpYW50SXRlcj4gZG9jdW1lbnRTdGF0 ZUl0ZXI7CisgICAgR1VuaXF1ZU91dFB0cjxHVmFyaWFudEl0ZXI+IHN0YXRlT2JqZWN0RGF0YUl0 ZXI7CisgICAgZ3VpbnQ2NCBkb2N1bWVudFNlcXVlbmNlTnVtYmVyOworICAgIGd1aW50NjQgaXRl bVNlcXVlbmNlTnVtYmVyOworICAgIGdpbnQzMiBzY3JvbGxQb2ludFgsIHNjcm9sbFBvaW50WTsK KyAgICBnZG91YmxlIHBhZ2VTY2FsZUZhY3RvcjsKKyAgICBHVmFyaWFudCogaHR0cEJvZHlWYXJp YW50OworICAgIEdVbmlxdWVPdXRQdHI8R1ZhcmlhbnRJdGVyPiBjaGlsZHJlbkl0ZXI7CisgICAg Z192YXJpYW50X2dldChmcmFtZVN0YXRlVmFyaWFudCwgRlJBTUVfU1RBVEVfRk9STUFUX1NUUklO R19WMSwgJnVybFN0cmluZywgJm9yaWdpbmFsVVJMU3RyaW5nLCAmcmVmZXJyZXIsICZ0YXJnZXQs CisgICAgICAgICZkb2N1bWVudFN0YXRlSXRlci5vdXRQdHIoKSwgJnN0YXRlT2JqZWN0RGF0YUl0 ZXIub3V0UHRyKCksICZkb2N1bWVudFNlcXVlbmNlTnVtYmVyLCAmaXRlbVNlcXVlbmNlTnVtYmVy LAorICAgICAgICAmc2Nyb2xsUG9pbnRYLCAmc2Nyb2xsUG9pbnRZLCAmcGFnZVNjYWxlRmFjdG9y LCAmaHR0cEJvZHlWYXJpYW50LCAmY2hpbGRyZW5JdGVyLm91dFB0cigpKTsKKyAgICBmcmFtZVN0 YXRlLnVybFN0cmluZyA9IFN0cmluZzo6ZnJvbVVURjgodXJsU3RyaW5nKTsKKyAgICBmcmFtZVN0 YXRlLm9yaWdpbmFsVVJMU3RyaW5nID0gU3RyaW5nOjpmcm9tVVRGOChvcmlnaW5hbFVSTFN0cmlu Zyk7CisgICAgZnJhbWVTdGF0ZS5yZWZlcnJlciA9IFN0cmluZzo6ZnJvbVVURjgocmVmZXJyZXIp OworICAgIGZyYW1lU3RhdGUudGFyZ2V0ID0gU3RyaW5nOjpmcm9tVVRGOCh0YXJnZXQpOworICAg IGlmIChnc2l6ZSBkb2N1bWVudFN0YXRlTGVuZ3RoID0gZ192YXJpYW50X2l0ZXJfbl9jaGlsZHJl bihkb2N1bWVudFN0YXRlSXRlci5nZXQoKSkpIHsKKyAgICAgICAgZnJhbWVTdGF0ZS5kb2N1bWVu dFN0YXRlLnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoZG9jdW1lbnRTdGF0ZUxlbmd0aCk7CisgICAg ICAgIGNvbnN0IGNoYXIqIGRvY3VtZW50U3RhdGVTdHJpbmc7CisgICAgICAgIHdoaWxlIChnX3Zh cmlhbnRfaXRlcl9uZXh0KGRvY3VtZW50U3RhdGVJdGVyLmdldCgpLCAiJnMiLCAmZG9jdW1lbnRT dGF0ZVN0cmluZykpCisgICAgICAgICAgICBmcmFtZVN0YXRlLmRvY3VtZW50U3RhdGUudW5jaGVj a2VkQXBwZW5kKFN0cmluZzo6ZnJvbVVURjgoZG9jdW1lbnRTdGF0ZVN0cmluZykpOworICAgIH0K KyAgICBpZiAoc3RhdGVPYmplY3REYXRhSXRlcikgeworICAgICAgICBWZWN0b3I8dWludDhfdD4g c3RhdGVPYmplY3RWZWN0b3I7CisgICAgICAgIGlmIChnc2l6ZSBzdGF0ZU9iamVjdERhdGFMZW5n dGggPSBnX3ZhcmlhbnRfaXRlcl9uX2NoaWxkcmVuKHN0YXRlT2JqZWN0RGF0YUl0ZXIuZ2V0KCkp KSB7CisgICAgICAgICAgICBzdGF0ZU9iamVjdFZlY3Rvci5yZXNlcnZlSW5pdGlhbENhcGFjaXR5 KHN0YXRlT2JqZWN0RGF0YUxlbmd0aCk7CisgICAgICAgICAgICBndWNoYXIgc3RhdGVPYmplY3RE YXRhVmFsdWU7CisgICAgICAgICAgICB3aGlsZSAoZ192YXJpYW50X2l0ZXJfbmV4dChzdGF0ZU9i amVjdERhdGFJdGVyLmdldCgpLCAieSIsICZzdGF0ZU9iamVjdERhdGFWYWx1ZSkpCisgICAgICAg ICAgICAgICAgc3RhdGVPYmplY3RWZWN0b3IudW5jaGVja2VkQXBwZW5kKHN0YXRlT2JqZWN0RGF0 YVZhbHVlKTsKKyAgICAgICAgfQorICAgICAgICBmcmFtZVN0YXRlLnN0YXRlT2JqZWN0RGF0YSA9 IFdURjo6bW92ZShzdGF0ZU9iamVjdFZlY3Rvcik7CisgICAgfQorICAgIGZyYW1lU3RhdGUuZG9j dW1lbnRTZXF1ZW5jZU51bWJlciA9IGRvY3VtZW50U2VxdWVuY2VOdW1iZXI7CisgICAgZnJhbWVT dGF0ZS5pdGVtU2VxdWVuY2VOdW1iZXIgPSBpdGVtU2VxdWVuY2VOdW1iZXI7CisgICAgZnJhbWVT dGF0ZS5zY3JvbGxQb2ludC5zZXRYKHNjcm9sbFBvaW50WCk7CisgICAgZnJhbWVTdGF0ZS5zY3Jv bGxQb2ludC5zZXRZKHNjcm9sbFBvaW50WSk7CisgICAgZnJhbWVTdGF0ZS5wYWdlU2NhbGVGYWN0 b3IgPSBwYWdlU2NhbGVGYWN0b3I7CisgICAgSFRUUEJvZHkgaHR0cEJvZHk7CisgICAgaWYgKGRl Y29kZUhUVFBCb2R5KGh0dHBCb2R5VmFyaWFudCwgaHR0cEJvZHkpKQorICAgICAgICBmcmFtZVN0 YXRlLmh0dHBCb2R5ID0gV1RGOjptb3ZlKGh0dHBCb2R5KTsKKyAgICBnX3ZhcmlhbnRfdW5yZWYo aHR0cEJvZHlWYXJpYW50KTsKKyAgICB3aGlsZSAoR1JlZlB0cjxHVmFyaWFudD4gY2hpbGQgPSBh ZG9wdEdSZWYoZ192YXJpYW50X2l0ZXJfbmV4dF92YWx1ZShjaGlsZHJlbkl0ZXIuZ2V0KCkpKSkg eworICAgICAgICBGcmFtZVN0YXRlIGNoaWxkRnJhbWVTdGF0ZTsKKyAgICAgICAgZGVjb2RlRnJh bWVTdGF0ZShjaGlsZC5nZXQoKSwgY2hpbGRGcmFtZVN0YXRlKTsKKyAgICAgICAgZnJhbWVTdGF0 ZS5jaGlsZHJlbi5hcHBlbmQoV1RGOjptb3ZlKGNoaWxkRnJhbWVTdGF0ZSkpOworICAgIH0KK30K Kworc3RhdGljIGlubGluZSB2b2lkIGRlY29kZUJhY2tGb3J3YXJkTGlzdEl0ZW1TdGF0ZShHVmFy aWFudEl0ZXIqIGJhY2tGb3J3YXJkTGlzdFN0YXRlSXRlciwgQmFja0ZvcndhcmRMaXN0U3RhdGUm IGJhY2tGb3J3YXJkTGlzdFN0YXRlKQoreworICAgIGdzaXplIGJhY2tGb3J3YXJkTGlzdFN0YXRl TGVuZ3RoID0gZ192YXJpYW50X2l0ZXJfbl9jaGlsZHJlbihiYWNrRm9yd2FyZExpc3RTdGF0ZUl0 ZXIpOworICAgIGlmICghYmFja0ZvcndhcmRMaXN0U3RhdGVMZW5ndGgpCisgICAgICAgIHJldHVy bjsKKworICAgIGJhY2tGb3J3YXJkTGlzdFN0YXRlLml0ZW1zLnJlc2VydmVJbml0aWFsQ2FwYWNp dHkoYmFja0ZvcndhcmRMaXN0U3RhdGVMZW5ndGgpOworICAgIGd1aW50NjQgaWRlbnRpZmllcjsK KyAgICBjb25zdCBjaGFyKiB0aXRsZTsKKyAgICBHVmFyaWFudCogZnJhbWVTdGF0ZVZhcmlhbnQ7 CisgICAgdW5zaWduZWQgc2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGljeTsKKyAgICB3aGlsZSAo Z192YXJpYW50X2l0ZXJfbG9vcChiYWNrRm9yd2FyZExpc3RTdGF0ZUl0ZXIsIEJBQ0tfRk9SV0FS RF9MSVNUX0lURU1fRk9STUFUX1NUUklOR19WMSwgJmlkZW50aWZpZXIsICZ0aXRsZSwgJmZyYW1l U3RhdGVWYXJpYW50LCAmc2hvdWxkT3BlbkV4dGVybmFsVVJMc1BvbGljeSkpIHsKKyAgICAgICAg QmFja0ZvcndhcmRMaXN0SXRlbVN0YXRlIHN0YXRlOworICAgICAgICBzdGF0ZS5pZGVudGlmaWVy ID0gaWRlbnRpZmllcjsKKyAgICAgICAgc3RhdGUucGFnZVN0YXRlLnRpdGxlID0gU3RyaW5nOjpm cm9tVVRGOCh0aXRsZSk7CisgICAgICAgIGRlY29kZUZyYW1lU3RhdGUoZnJhbWVTdGF0ZVZhcmlh bnQsIHN0YXRlLnBhZ2VTdGF0ZS5tYWluRnJhbWVTdGF0ZSk7CisgICAgICAgIHN0YXRlLnBhZ2VT dGF0ZS5zaG91bGRPcGVuRXh0ZXJuYWxVUkxzUG9saWN5ID0gdG9XZWJDb3JlRXh0ZXJuYWxVUkxz UG9saWN5KHNob3VsZE9wZW5FeHRlcm5hbFVSTHNQb2xpY3kpOworICAgICAgICBiYWNrRm9yd2Fy ZExpc3RTdGF0ZS5pdGVtcy51bmNoZWNrZWRBcHBlbmQoV1RGOjptb3ZlKHN0YXRlKSk7CisgICAg fQorfQorCitzdGF0aWMgYm9vbCBkZWNvZGVTZXNzaW9uU3RhdGUoR0J5dGVzKiBkYXRhLCBTZXNz aW9uU3RhdGUmIHNlc3Npb25TdGF0ZSkKK3sKKyAgICBHUmVmUHRyPEdWYXJpYW50PiB2YXJpYW50 ID0gZ192YXJpYW50X25ld19mcm9tX2J5dGVzKEdfVkFSSUFOVF9UWVBFKFNFU1NJT05fU1RBVEVf VFlQRV9TVFJJTkdfVjEpLCBkYXRhLCBGQUxTRSk7CisgICAgaWYgKCFnX3ZhcmlhbnRfaXNfbm9y bWFsX2Zvcm0odmFyaWFudC5nZXQoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGd1 aW50MTYgdmVyc2lvbjsKKyAgICBHVW5pcXVlT3V0UHRyPEdWYXJpYW50SXRlcj4gYmFja0Zvcndh cmRMaXN0U3RhdGVJdGVyOworICAgIGdib29sZWFuIGhhc0N1cnJlbnRJbmRleDsKKyAgICBndWlu dDMyIGN1cnJlbnRJbmRleDsKKyAgICBnX3ZhcmlhbnRfZ2V0KHZhcmlhbnQuZ2V0KCksIFNFU1NJ T05fU1RBVEVfVFlQRV9TVFJJTkdfVjEsICZ2ZXJzaW9uLCAmYmFja0ZvcndhcmRMaXN0U3RhdGVJ dGVyLm91dFB0cigpLCAmaGFzQ3VycmVudEluZGV4LCAmY3VycmVudEluZGV4KTsKKyAgICBpZiAo IXZlcnNpb24gfHwgdmVyc2lvbiA+IGdfc2Vzc2lvblN0YXRlVmVyc2lvbikKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgZGVjb2RlQmFja0ZvcndhcmRMaXN0SXRlbVN0YXRlKGJhY2tGb3J3 YXJkTGlzdFN0YXRlSXRlci5nZXQoKSwgc2Vzc2lvblN0YXRlLmJhY2tGb3J3YXJkTGlzdFN0YXRl KTsKKworICAgIGlmIChoYXNDdXJyZW50SW5kZXgpCisgICAgICAgIHNlc3Npb25TdGF0ZS5iYWNr Rm9yd2FyZExpc3RTdGF0ZS5jdXJyZW50SW5kZXggPSBjdXJyZW50SW5kZXg7CisgICAgcmV0dXJu IHRydWU7Cit9CisKK1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHdlYmtpdFdlYlZpZXdTZXNz aW9uU3RhdGVDcmVhdGUoU2Vzc2lvblN0YXRlJiYgc2Vzc2lvblN0YXRlKQoreworICAgIFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGUqIHN0YXRlID0gc3RhdGljX2Nhc3Q8V2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZSo+KGZhc3RNYWxsb2Moc2l6ZW9mKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUp KSk7CisgICAgbmV3IChzdGF0ZSkgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZShXVEY6Om1vdmUo c2Vzc2lvblN0YXRlKSk7CisgICAgcmV0dXJuIHN0YXRlOworfQorCitjb25zdCBTZXNzaW9uU3Rh dGUmIHdlYmtpdFdlYlZpZXdTZXNzaW9uU3RhdGF0ZUdldFNlc3Npb25TdGF0ZShXZWJLaXRXZWJW aWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSkKK3sKKyAgICByZXR1cm4gc3RhdGUtPnNlc3Npb25TdGF0 ZTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXc6CisgKiBA ZGF0YTogYSAjR0J5dGVzCisgKgorICogQ3JlYXRlcyBhIG5ldyAjV2ViS2l0V2ViVmlld1Nlc3Np b25TdGF0ZSBmcm9tIHNlcmFsaXplZCBkYXRhLgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBm dWxsKTogYSBuZXcgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUsIG9yICVOVUxMIGlmIEBkYXRh IGRvZXNuJ3QgY29udGFpbiBhCisgKiAgICAgdmFsaWQgc2VyaWFsaXplZCAjV2ViS2l0V2ViVmll d1Nlc3Npb25TdGF0ZS4KKyAqCisgKiBTaW5jZTogMi4xMgorICovCitXZWJLaXRXZWJWaWV3U2Vz c2lvblN0YXRlKiB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcoR0J5dGVzKiBkYXRh KQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKGRhdGEsIG51bGxwdHIpOworCisgICAgU2Vz c2lvblN0YXRlIHNlc3Npb25TdGF0ZTsKKyAgICBpZiAoIWRlY29kZVNlc3Npb25TdGF0ZShkYXRh LCBzZXNzaW9uU3RhdGUpKQorICAgICAgICByZXR1cm4gbnVsbHB0cjsKKyAgICByZXR1cm4gd2Vi a2l0V2ViVmlld1Nlc3Npb25TdGF0ZUNyZWF0ZShXVEY6Om1vdmUoc2Vzc2lvblN0YXRlKSk7Cit9 CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfcmVmOgorICogQHN0YXRl OiBhICNXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCisgKgorICogQXRvbWljYWxseSBpbmNyZW1l bnRzIHRoZSByZWZlcmVuY2UgY291bnQgb2YgQHN0YXRlIGJ5IG9uZS4gVGhpcworICogZnVuY3Rp b24gaXMgTVQtc2FmZSBhbmQgbWF5IGJlIGNhbGxlZCBmcm9tIGFueSB0aHJlYWQuCisgKgorICog UmV0dXJuczogVGhlIHBhc3NlZCBpbiAjV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZQorICoKKyAq IFNpbmNlOiAyLjEyCisgKi8KK1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHdlYmtpdF93ZWJf dmlld19zZXNzaW9uX3N0YXRlX3JlZihXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSkK K3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChzdGF0ZSwgbnVsbHB0cik7CisgICAgZ19hdG9t aWNfaW50X2luYygmc3RhdGUtPnJlZmVyZW5jZUNvdW50KTsKKyAgICByZXR1cm4gc3RhdGU7Cit9 CisKKy8qKgorICogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWY6CisgKiBAc3Rh dGU6IGEgI1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUKKyAqCisgKiBBdG9taWNhbGx5IGRlY3Jl bWVudHMgdGhlIHJlZmVyZW5jZSBjb3VudCBvZiBAc3RhdGUgYnkgb25lLiBJZiB0aGUKKyAqIHJl ZmVyZW5jZSBjb3VudCBkcm9wcyB0byAwLCBhbGwgbWVtb3J5IGFsbG9jYXRlZCBieSB0aGUgI1dl YktpdFdlYlZpZXdTZXNzaW9uU3RhdGUgaXMKKyAqIHJlbGVhc2VkLiBUaGlzIGZ1bmN0aW9uIGlz IE1ULXNhZmUgYW5kIG1heSBiZSBjYWxsZWQgZnJvbSBhbnkgdGhyZWFkLgorICoKKyAqIFNpbmNl OiAyLjEyCisgKi8KK3ZvaWQgd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYoV2Vi S2l0V2ViVmlld1Nlc3Npb25TdGF0ZSogc3RhdGUpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChz dGF0ZSk7CisgICAgaWYgKGdfYXRvbWljX2ludF9kZWNfYW5kX3Rlc3QoJnN0YXRlLT5yZWZlcmVu Y2VDb3VudCkpIHsKKyAgICAgICAgc3RhdGUtPn5XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKCk7 CisgICAgICAgIGZhc3RGcmVlKHN0YXRlKTsKKyAgICB9Cit9CisKKy8qKgorICogd2Via2l0X3dl Yl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplOgorICogQHN0YXRlOiBhICNXZWJLaXRXZWJW aWV3U2Vzc2lvblN0YXRlCisgKgorICogU2VyaWFsaXplcyBhICNXZWJLaXRXZWJWaWV3U2Vzc2lv blN0YXRlLgorICoKKyAqIFJldHVybnM6ICh0cmFuc2ZlciBmdWxsKTogYSAjR0J5dGVzIGNvbnRh aW5pbmcgdGhlIEBzdGF0ZSBzZXJpYWxpemVkLgorICoKKyAqIFNpbmNlOiAyLjEyCisgKi8KK0dC eXRlcyogd2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKFdlYktpdFdlYlZp ZXdTZXNzaW9uU3RhdGUqIHN0YXRlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKHN0YXRl LCBudWxscHRyKTsKKworICAgIHJldHVybiBlbmNvZGVTZXNzaW9uU3RhdGUoc3RhdGUtPnNlc3Np b25TdGF0ZSk7Cit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0 ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uNzNmNGE0YQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUuaApAQCAtMCwwICsx LDUzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAq IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBG bG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZiAhZGVmaW5l ZChfX1dFQktJVDJfSF9JTlNJREVfXykgJiYgIWRlZmluZWQoV0VCS0lUMl9DT01QSUxBVElPTikK KyNlcnJvciAiT25seSA8d2Via2l0Mi93ZWJraXQyLmg+IGNhbiBiZSBpbmNsdWRlZCBkaXJlY3Rs eS4iCisjZW5kaWYKKworI2lmbmRlZiBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlX2gKKyNkZWZp bmUgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZV9oCisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5o PgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0RGVmaW5lcy5oPgorCitHX0JFR0lOX0RFQ0xTCisK KyNkZWZpbmUgV0VCS0lUX1RZUEVfV0VCX1ZJRVdfU0VTU0lPTl9TVEFURSAod2Via2l0X3dlYl92 aWV3X3Nlc3Npb25fc3RhdGVfZ2V0X3R5cGUoKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdl YlZpZXdTZXNzaW9uU3RhdGUgV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZTsKKworV0VCS0lUX0FQ SSBHVHlwZQord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfZ2V0X3R5cGUgICh2b2lkKTsK KworV0VCS0lUX0FQSSBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICoKK3dlYmtpdF93ZWJfdmll d19zZXNzaW9uX3N0YXRlX25ldyAgICAgICAoR0J5dGVzICpkYXRhKTsKKworV0VCS0lUX0FQSSBX ZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlICoKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRl X3JlZiAgICAgICAoV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZSAqc3RhdGUpOworCitXRUJLSVRf QVBJIHZvaWQKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmICAgICAoV2ViS2l0 V2ViVmlld1Nlc3Npb25TdGF0ZSAqc3RhdGUpOworCitXRUJLSVRfQVBJIEdCeXRlcyAqCit3ZWJr aXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9zZXJpYWxpemUgKFdlYktpdFdlYlZpZXdTZXNzaW9u U3RhdGUgKnN0YXRlKTsKKworR19FTkRfREVDTFMKKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlUHJp dmF0ZS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld1Nl c3Npb25TdGF0ZVByaXZhdGUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5h NjI1NTVhCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9n dGsvV2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGUuaApAQCAtMCwwICsxLDI5IEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDE1IElnYWxpYSBTLkwuCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V CisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRo ZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAq IEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJTZXNzaW9uU3Rh dGUuaCIKKyNpbmNsdWRlICJXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlLmgiCisKKyNpZm5kZWYg V2ViS2l0V2ViVmlld1Nlc3Npb25TdGF0ZVByaXZhdGVfaAorI2RlZmluZSBXZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlUHJpdmF0ZV9oCisKK1dlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqIHdlYmtp dFdlYlZpZXdTZXNzaW9uU3RhdGVDcmVhdGUoV2ViS2l0OjpTZXNzaW9uU3RhdGUmJik7Citjb25z dCBXZWJLaXQ6OlNlc3Npb25TdGF0ZSYgd2Via2l0V2ViVmlld1Nlc3Npb25TdGF0YXRlR2V0U2Vz c2lvblN0YXRlKFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUqKTsKKworI2VuZGlmIC8vIFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGVQcml2YXRlX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0IGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3RrLTQuMC1zZWN0aW9u cy50eHQKaW5kZXggNWQ5ZDY1MDEuLjI0NWViNTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2VjdGlvbnMudHh0CisrKyBi L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAtc2Vj dGlvbnMudHh0CkBAIC0yMTIsNiArMjEyLDggQEAgd2Via2l0X3dlYl92aWV3X2dldF9iYWNrZ3Jv dW5kX2NvbG9yCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2VkaXRhYmxlCiB3ZWJraXRfd2ViX3ZpZXdf aXNfZWRpdGFibGUKIHdlYmtpdF93ZWJfdmlld19nZXRfZWRpdG9yX3N0YXRlCit3ZWJraXRfd2Vi X3ZpZXdfZ2V0X3Nlc3Npb25fc3RhdGUKK3dlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25f c3RhdGUKIAogPFNVQlNFQ1RJT04gV2ViS2l0SmF2YXNjcmlwdFJlc3VsdD4KIFdlYktpdEphdmFz Y3JpcHRSZXN1bHQKQEAgLTIzMCw2ICsyMzIsMTMgQEAgd2Via2l0X3NjcmlwdF9kaWFsb2dfcHJv bXB0X2dldF9kZWZhdWx0X3RleHQKIHdlYmtpdF9zY3JpcHRfZGlhbG9nX3Byb21wdF9zZXRfdGV4 dAogd2Via2l0X3dlYl92aWV3X2dldF9tYWluX3Jlc291cmNlCiAKKzxTVUJTRUNUSU9OIFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGU+CitXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlCit3ZWJraXRf d2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRl X3JlZgord2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYKK3dlYmtpdF93ZWJfdmll d19zZXNzaW9uX3N0YXRlX3NlcmlhbGl6ZQorCiA8U1VCU0VDVElPTiBTdGFuZGFyZD4KIFdlYktp dFdlYlZpZXdDbGFzcwogV0VCS0lUX1dFQl9WSUVXCkBAIC0yNDAsMTEgKzI0OSwxMyBAQCBXRUJL SVRfSVNfV0VCX1ZJRVdfQ0xBU1MKIFdFQktJVF9XRUJfVklFV19HRVRfQ0xBU1MKIFdFQktJVF9U WVBFX0pBVkFTQ1JJUFRfUkVTVUxUCiBXRUJLSVRfVFlQRV9TQ1JJUFRfRElBTE9HCitXRUJLSVRf VFlQRV9XRUJfVklFV19TRVNTSU9OX1NUQVRFCiAKIDxTVUJTRUNUSU9OIFByaXZhdGU+CiB3ZWJr aXRfd2ViX3ZpZXdfZ2V0X3R5cGUKIHdlYmtpdF9qYXZhc2NyaXB0X3Jlc3VsdF9nZXRfdHlwZQog d2Via2l0X3NjcmlwdF9kaWFsb2dfZ2V0X3R5cGUKK3dlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0 YXRlX2dldF90eXBlCiBXZWJLaXRXZWJWaWV3UHJpdmF0ZQogPC9TRUNUSU9OPgogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4w LnR5cGVzIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvZG9jcy93ZWJraXQyZ3Rr LTQuMC50eXBlcwppbmRleCBmZWE5NWU3Li4yNjJlMDdhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9kb2NzL3dlYmtpdDJndGstNC4wLnR5cGVzCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL2RvY3Mvd2Via2l0Mmd0ay00LjAudHlwZXMK QEAgLTMzLDMgKzMzLDQgQEAgd2Via2l0X3dlYnNpdGVfZGF0YV9tYW5hZ2VyX2dldF90eXBlCiB3 ZWJraXRfZWRpdG9yX3N0YXRlX2dldF90eXBlCiB3ZWJraXRfaW5zdGFsbF9taXNzaW5nX21lZGlh X3BsdWdpbnNfcGVybWlzc2lvbl9yZXF1ZXN0X2dldF90eXBlCiB3ZWJraXRfY29uc29sZV9tZXNz YWdlX2dldF90eXBlCit3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9nZXRfdHlwZQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvd2Via2l0Mi5oCmluZGV4IGI5NWE3NjAuLjNl NDRkNjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL3dlYmtp dDIuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay93ZWJraXQyLmgKQEAg LTc0LDYgKzc0LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQyL1dlYktpdFdlYlJlc291cmNlLmg+CiAj aW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXZWJWaWV3Lmg+CiAjaW5jbHVkZSA8d2Via2l0Mi9XZWJL aXRXZWJWaWV3QmFzZS5oPgorI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2ViVmlld1Nlc3Npb25T dGF0ZS5oPgogI2luY2x1ZGUgPHdlYmtpdDIvV2ViS2l0V2Vic2l0ZURhdGFNYW5hZ2VyLmg+CiAj aW5jbHVkZSA8d2Via2l0Mi9XZWJLaXRXaW5kb3dQcm9wZXJ0aWVzLmg+CiAKZGlmZiAtLWdpdCBh L1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBjZWM3ZjlkLi5mZjc4MjQy IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTcgQEAKKzIwMTUtMTItMzAgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBp Z2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIEFsbG93IHRvIHNhdmUgYW5kIHJlc3RvcmUgc2Vz c2lvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTE1 NjAwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRk IHRlc3QgY2FzZSB0byBjaGVjayB0aGUgbmV3IHNlc3Npb24gQVBJLgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2FyZExpc3QuY3BwOgorICAg ICAgICAodGVzdFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUpOgorICAgICAgICAodGVzdFdlYktp dFdlYlZpZXdTZXNzaW9uU3RhdGVXaXRoRm9ybURhdGEpOgorICAgICAgICAoYmVmb3JlQWxsKToK KwogMjAxNS0xMi0zMCAgUGhpbGlwcGUgTm9ybWFuZCAgPHBub3JtYW5kQGlnYWxpYS5jb20+CiAK ICAgICAgICAgW01hY11bR1RLXSBKaGJ1aWxkIHN1cHBvcnQgZm9yIE9TWApkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2FyZExpc3Qu Y3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyR3RrL1Rlc3RCYWNrRm9yd2Fy ZExpc3QuY3BwCmluZGV4IDY1YzNkMmQuLmY3YWJkNWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mkd0ay9UZXN0QmFja0ZvcndhcmRMaXN0LmNwcAorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJHdGsvVGVzdEJhY2tGb3J3YXJkTGlzdC5j cHAKQEAgLTI2NCw2ICsyNjQsMTA4IEBAIHN0YXRpYyB2b2lkIHRlc3RCYWNrRm9yd2FyZExpc3RM aW1pdEFuZENhY2hlKEJhY2tGb3J3YXJkTGlzdFRlc3QqIHRlc3QsIGdjb25zdHBvCiAgICAgZ19h c3NlcnRfY21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aCh0ZXN0LT5t X2xpc3QpLCA9PSwga0JhY2tGb3J3YXJkTGlzdExpbWl0KTsKIH0KIAorc3RhdGljIHZvaWQgdGVz dFdlYktpdFdlYlZpZXdTZXNzaW9uU3RhdGUoQmFja0ZvcndhcmRMaXN0VGVzdCogdGVzdCwgZ2Nv bnN0cG9pbnRlcikKK3sKKyAgICBXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlKiBzdGF0ZSA9IHdl YmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSh0ZXN0LT5tX3dlYlZpZXcpOworICAgIGdf YXNzZXJ0KHN0YXRlKTsKKyAgICBHUmVmUHRyPFdlYktpdFdlYlZpZXc+IHZpZXcgPSBXRUJLSVRf V0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBXZWJLaXRCYWNrRm9yd2FyZExp c3QqIGJmTGlzdCA9IHdlYmtpdF93ZWJfdmlld19nZXRfYmFja19mb3J3YXJkX2xpc3Qodmlldy5n ZXQoKSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0 X2xlbmd0aChiZkxpc3QpLCA9PSwgMCk7CisgICAgd2Via2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vz c2lvbl9zdGF0ZSh2aWV3LmdldCgpLCBzdGF0ZSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJr aXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aChiZkxpc3QpLCA9PSwgMCk7CisgICAgR1Jl ZlB0cjxHQnl0ZXM+IGRhdGEgPSBhZG9wdEdSZWYod2Via2l0X3dlYl92aWV3X3Nlc3Npb25fc3Rh dGVfc2VyaWFsaXplKHN0YXRlKSk7CisgICAgZ19hc3NlcnQoZGF0YSk7CisgICAgc3RhdGUgPSB3 ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXcoZGF0YS5nZXQoKSk7CisgICAgZ19hc3Nl cnQoc3RhdGUpOworICAgIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25l dygpKTsKKyAgICBiZkxpc3QgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9yd2FyZF9saXN0 KHZpZXcuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9s aXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19yZXN0 b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2NtcHVp bnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOwor ICAgIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKKworICAgIENT dHJpbmcgdXJpUGFnZTEgPSBrU2VydmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTEiKTsKKyAgICB0 ZXN0LT5tX2NoYW5nZWRGbGFncyA9IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwg QmFja0ZvcndhcmRMaXN0VGVzdDo6QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFn ZTEuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIENT dHJpbmcgdXJpUGFnZTIgPSBrU2VydmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTIiKTsKKyAgICB0 ZXN0LT5tX2NoYW5nZWRGbGFncyA9IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwg QmFja0ZvcndhcmRMaXN0VGVzdDo6QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFn ZTIuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIENT dHJpbmcgdXJpUGFnZTMgPSBrU2VydmVyLT5nZXRVUklGb3JQYXRoKCIvUGFnZTMiKTsKKyAgICB0 ZXN0LT5tX2NoYW5nZWRGbGFncyA9IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OkN1cnJlbnRJdGVtIHwg QmFja0ZvcndhcmRMaXN0VGVzdDo6QWRkZWRJdGVtOworICAgIHRlc3QtPmxvYWRVUkkodXJpUGFn ZTMuZGF0YSgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxMb2FkRmluaXNoZWQoKTsKKworICAgIHRl c3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0ZvcndhcmRMaXN0VGVzdDo6Q3VycmVudEl0ZW07Cisg ICAgdGVzdC0+Z29CYWNrKCk7CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisK KyAgICBzdGF0ZSA9IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSh0ZXN0LT5tX3dl YlZpZXcpOworICAgIGdfYXNzZXJ0KHN0YXRlKTsKKworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Vi a2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdl YmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOwor ICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgo YmZMaXN0KSwgPT0sIDMpOworCisgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6Y2hlY2tJdGVtKHdl YmtpdF9iYWNrX2ZvcndhcmRfbGlzdF9nZXRfbnRoX2l0ZW0oYmZMaXN0LCAtMSksICJQYWdlMSIs IHVyaVBhZ2UxLmRhdGEoKSwgdXJpUGFnZTEuZGF0YSgpKTsKKyAgICBCYWNrRm9yd2FyZExpc3RU ZXN0OjpjaGVja0l0ZW0od2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9jdXJyZW50X2l0ZW0o YmZMaXN0KSwgIlBhZ2UyIiwgdXJpUGFnZTIuZGF0YSgpLCB1cmlQYWdlMi5kYXRhKCkpOworICAg IEJhY2tGb3J3YXJkTGlzdFRlc3Q6OmNoZWNrSXRlbSh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3Rf Z2V0X250aF9pdGVtKGJmTGlzdCwgMSksICJQYWdlMyIsIHVyaVBhZ2UzLmRhdGEoKSwgdXJpUGFn ZTMuZGF0YSgpKTsKKworICAgIGRhdGEgPSBhZG9wdEdSZWYod2Via2l0X3dlYl92aWV3X3Nlc3Np b25fc3RhdGVfc2VyaWFsaXplKHN0YXRlKSk7CisgICAgZ19hc3NlcnQoZGF0YSk7CisgICAgd2Vi a2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfdW5yZWYoc3RhdGUpOworICAgIHN0YXRlID0gd2Vi a2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfbmV3KGRhdGEuZ2V0KCkpOworICAgIGdfYXNzZXJ0 KHN0YXRlKTsKKworICAgIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25l dygpKTsKKyAgICBiZkxpc3QgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2JhY2tfZm9yd2FyZF9saXN0 KHZpZXcuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9s aXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOworICAgIHdlYmtpdF93ZWJfdmlld19yZXN0 b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3RhdGUpOworICAgIGdfYXNzZXJ0X2NtcHVp bnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDMpOwor ICAgIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRlX3VucmVmKHN0YXRlKTsKKworICAgIEJh Y2tGb3J3YXJkTGlzdFRlc3Q6OmNoZWNrSXRlbSh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0 X250aF9pdGVtKGJmTGlzdCwgLTEpLCAiUGFnZTEiLCB1cmlQYWdlMS5kYXRhKCksIHVyaVBhZ2Ux LmRhdGEoKSk7CisgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6Y2hlY2tJdGVtKHdlYmtpdF9iYWNr X2ZvcndhcmRfbGlzdF9nZXRfY3VycmVudF9pdGVtKGJmTGlzdCksICJQYWdlMiIsIHVyaVBhZ2Uy LmRhdGEoKSwgdXJpUGFnZTIuZGF0YSgpKTsKKyAgICBCYWNrRm9yd2FyZExpc3RUZXN0OjpjaGVj a0l0ZW0od2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9udGhfaXRlbShiZkxpc3QsIDEpLCAi UGFnZTMiLCB1cmlQYWdlMy5kYXRhKCksIHVyaVBhZ2UzLmRhdGEoKSk7CisKKyAgICBzdGF0aWMg Y29uc3QgY2hhciogaW52YWxpZFNlc3Npb25EYXRhID0gImludmFsaWQgc2Vzc2lvbiBkYXRhIjsK KyAgICBkYXRhID0gYWRvcHRHUmVmKGdfYnl0ZXNfbmV3X3N0YXRpYyhpbnZhbGlkU2Vzc2lvbkRh dGEsIHN0cmxlbihpbnZhbGlkU2Vzc2lvbkRhdGEpKSk7CisgICAgZ19hc3NlcnQoIXdlYmtpdF93 ZWJfdmlld19zZXNzaW9uX3N0YXRlX25ldyhkYXRhLmdldCgpKSk7Cit9CisKK3N0YXRpYyB2b2lk IHRlc3RXZWJLaXRXZWJWaWV3U2Vzc2lvblN0YXRlV2l0aEZvcm1EYXRhKEJhY2tGb3J3YXJkTGlz dFRlc3QqIHRlc3QsIGdjb25zdHBvaW50ZXIpCit7CisgICAgR1VuaXF1ZVB0cjxjaGFyPiBodG1s UGF0aChnX2J1aWxkX2ZpbGVuYW1lKFRlc3Q6OmdldFJlc291cmNlc0RpcihUZXN0OjpXZWJLaXQy UmVzb3VyY2VzKS5kYXRhKCksICJzaW1wbGUtZm9ybS5odG1sIiwgbnVsbHB0cikpOworICAgIEdV bmlxdWVQdHI8Y2hhcj4gaHRtbFVSTChnX2ZpbGVuYW1lX3RvX3VyaShodG1sUGF0aC5nZXQoKSwg bnVsbHB0ciwgbnVsbHB0cikpOworICAgIHRlc3QtPm1fY2hhbmdlZEZsYWdzID0gQmFja0Zvcndh cmRMaXN0VGVzdDo6Q3VycmVudEl0ZW0gfCBCYWNrRm9yd2FyZExpc3RUZXN0OjpBZGRlZEl0ZW07 CisgICAgdGVzdC0+bG9hZFVSSShodG1sVVJMLmdldCgpKTsKKyAgICB0ZXN0LT53YWl0VW50aWxM b2FkRmluaXNoZWQoKTsKKworICAgIHdlYmtpdF93ZWJfdmlld19ydW5famF2YXNjcmlwdCh0ZXN0 LT5tX3dlYlZpZXcsICJzdWJtaXRGb3JtKCk7IiwgbnVsbHB0ciwgbnVsbHB0ciwgbnVsbHB0cik7 CisgICAgdGVzdC0+d2FpdFVudGlsTG9hZEZpbmlzaGVkKCk7CisKKyAgICBXZWJLaXRXZWJWaWV3 U2Vzc2lvblN0YXRlKiBzdGF0ZSA9IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbl9zdGF0ZSh0 ZXN0LT5tX3dlYlZpZXcpOworICAgIGdfYXNzZXJ0KHN0YXRlKTsKKyAgICBHUmVmUHRyPFdlYktp dFdlYlZpZXc+IHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsK KyAgICBXZWJLaXRCYWNrRm9yd2FyZExpc3QqIGJmTGlzdCA9IHdlYmtpdF93ZWJfdmlld19nZXRf YmFja19mb3J3YXJkX2xpc3Qodmlldy5nZXQoKSk7CisgICAgZ19hc3NlcnRfY21wdWludCh3ZWJr aXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aChiZkxpc3QpLCA9PSwgMCk7CisgICAgd2Vi a2l0X3dlYl92aWV3X3Jlc3RvcmVfc2Vzc2lvbl9zdGF0ZSh2aWV3LmdldCgpLCBzdGF0ZSk7Cisg ICAgZ19hc3NlcnRfY21wdWludCh3ZWJraXRfYmFja19mb3J3YXJkX2xpc3RfZ2V0X2xlbmd0aChi Zkxpc3QpLCA9PSwgMik7CisgICAgR1JlZlB0cjxHQnl0ZXM+IGRhdGEgPSBhZG9wdEdSZWYod2Vi a2l0X3dlYl92aWV3X3Nlc3Npb25fc3RhdGVfc2VyaWFsaXplKHN0YXRlKSk7CisgICAgZ19hc3Nl cnQoZGF0YSk7CisgICAgc3RhdGUgPSB3ZWJraXRfd2ViX3ZpZXdfc2Vzc2lvbl9zdGF0ZV9uZXco ZGF0YS5nZXQoKSk7CisgICAgZ19hc3NlcnQoc3RhdGUpOworICAgIHZpZXcgPSBXRUJLSVRfV0VC X1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBiZkxpc3QgPSB3ZWJraXRfd2ViX3Zp ZXdfZ2V0X2JhY2tfZm9yd2FyZF9saXN0KHZpZXcuZ2V0KCkpOworICAgIGdfYXNzZXJ0X2NtcHVp bnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9sZW5ndGgoYmZMaXN0KSwgPT0sIDApOwor ICAgIHdlYmtpdF93ZWJfdmlld19yZXN0b3JlX3Nlc3Npb25fc3RhdGUodmlldy5nZXQoKSwgc3Rh dGUpOworICAgIGdfYXNzZXJ0X2NtcHVpbnQod2Via2l0X2JhY2tfZm9yd2FyZF9saXN0X2dldF9s ZW5ndGgoYmZMaXN0KSwgPT0sIDIpOworICAgIHdlYmtpdF93ZWJfdmlld19zZXNzaW9uX3N0YXRl X3VucmVmKHN0YXRlKTsKK30KKwogdm9pZCBiZWZvcmVBbGwoKQogewogICAgIGtTZXJ2ZXIgPSBu ZXcgV2ViS2l0VGVzdFNlcnZlcigpOwpAQCAtMjcxLDYgKzM3Myw4IEBAIHZvaWQgYmVmb3JlQWxs KCkKIAogICAgIEJhY2tGb3J3YXJkTGlzdFRlc3Q6OmFkZCgiQmFja0ZvcndhcmRMaXN0IiwgIm5h dmlnYXRpb24iLCB0ZXN0QmFja0ZvcndhcmRMaXN0TmF2aWdhdGlvbik7CiAgICAgQmFja0Zvcndh cmRMaXN0VGVzdDo6YWRkKCJCYWNrRm9yd2FyZExpc3QiLCAibGlzdC1saW1pdC1hbmQtY2FjaGUi LCB0ZXN0QmFja0ZvcndhcmRMaXN0TGltaXRBbmRDYWNoZSk7CisgICAgQmFja0ZvcndhcmRMaXN0 VGVzdDo6YWRkKCJXZWJLaXRXZWJWaWV3IiwgInNlc3Npb24tc3RhdGUiLCB0ZXN0V2ViS2l0V2Vi Vmlld1Nlc3Npb25TdGF0ZSk7CisgICAgQmFja0ZvcndhcmRMaXN0VGVzdDo6YWRkKCJXZWJLaXRX ZWJWaWV3IiwgInNlc3Npb24tc3RhdGUtd2l0aC1mb3JtLWRhdGEiLCB0ZXN0V2ViS2l0V2ViVmll d1Nlc3Npb25TdGF0ZVdpdGhGb3JtRGF0YSk7CiB9CiAKIHZvaWQgYWZ0ZXJBbGwoKQo=