155995 2016-03-29 16:24:18 -0700 WebKit should dispatchDidFailProvisionalLoad while loading invalid URLs 2016-04-04 13:17:57 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=156117 InRadar P2 Normal --- 1 jiewen_tan jiewen_tan aestes bfulgham cdumez commit-queue japhet mitz sam webkit-bug-importer oldest_to_newest 1178854 0 jiewen_tan 2016-03-29 16:24:18 -0700 * SUMMARY Handling of invalid URLs should be investigated * STEPS TO REPRODUCE URLs that have certain invalid characters result in an about:blank page instead of a Safari error page. The following URLs can be used to demonstrate this. Try them out from href links. file://www.apple.com<>/ https://www.apple.com<>/ 1178855 1 jiewen_tan 2016-03-29 16:25:25 -0700 <rdar://problem/14967004> 1178861 2 275148 jiewen_tan 2016-03-29 16:35:42 -0700 Created attachment 275148 Patch 1178892 3 275148 bfulgham 2016-03-29 17:50:47 -0700 Comment on attachment 275148 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275148&action=review This looks great! I think the test cases need a little work. (1) I'd like to see a WK1 test case, since the 'cancelMainResourceLoad' is invoked for WK1 and WK2. (2) I'd like to see a "success" case for WK2 (and WK1) that confirms that normal loads work properly with this change. For those reasons, r- to add some additional test cases. > Source/WebCore/ChangeLog:9 > + Added API Tests. It looks like you added a WK2 test, but this code change is in WebCore. It seems like you should also have a WK1 test, following something like the code in BackForwardList.mm as an example. > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:77 > +} Please add another test for the "success" case where you navigate to a valid URL just to make sure we didn't break anything. 1178894 4 sam 2016-03-29 18:04:50 -0700 What security vulnerability is this bug in regards to? While it is not necessary to explain in detail in the bug the issue is (and you shouldn't) this bug should out line the concern. 1178900 5 jiewen_tan 2016-03-29 18:25:19 -0700 (In reply to comment #4) > What security vulnerability is this bug in regards to? While it is not > necessary to explain in detail in the bug the issue is (and you shouldn't) > this bug should out line the concern. The original concern is: Window objects that are scriptable from other windows such as the opener could potentially use this bug to mislead users about what page they are at However, I don't think it is valid now as the bug is not quite the same as it is originally reported. 1178906 6 275148 jiewen_tan 2016-03-29 18:39:35 -0700 Comment on attachment 275148 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275148&action=review >> Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:77 >> +} > > Please add another test for the "success" case where you navigate to a valid URL just to make sure we didn't break anything. I think existing layout tests/api tests should already cover the "success" case. 1178908 7 275148 aestes 2016-03-29 18:48:04 -0700 Comment on attachment 275148 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275148&action=review > Source/WebCore/loader/DocumentLoader.cpp:1516 > + if (!m_request.url().isValid()) > + cancelMainResourceLoad(frameLoader()->client().cannotShowURLError(m_request)); > + else { You should just return early after calling cancelMainResourceLoad(). > Source/WebCore/loader/FrameLoader.cpp:2213 > + if (!m_provisionalLoadErrorBeingHandledURL.isEmpty() && !error.isCancellation()) > + return; > + You don't explain why you moved this or why added a check for cancellation errors. You also don't test this new behavior. I think you need to do both of these things. 1178910 8 275148 aestes 2016-03-29 18:51:13 -0700 Comment on attachment 275148 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275148&action=review > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:69 > + [webView loadRequest:[NSURLRequest requestWithURL:contentURL]]; Is it actually necessary to load an HTML file that clicks a link to "https://www.apple.com&lt;&gt;/"? Would it not be sufficient to just call loadRequest: directly with that URL? 1178976 9 sam 2016-03-29 22:12:27 -0700 (In reply to comment #5) > (In reply to comment #4) > > What security vulnerability is this bug in regards to? While it is not > > necessary to explain in detail in the bug the issue is (and you shouldn't) > > this bug should out line the concern. > > The original concern is: > Window objects that are scriptable from other windows such as the opener > could potentially use this bug to mislead users about what page they are at > > However, I don't think it is valid now as the bug is not quite the same as > it is originally reported. Ok, then what is the issue now? 1178986 10 275148 jiewen_tan 2016-03-29 23:36:21 -0700 Comment on attachment 275148 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275148&action=review >> Source/WebCore/loader/DocumentLoader.cpp:1516 >> + else { > > You should just return early after calling cancelMainResourceLoad(). I have a return statement after the if else control. >> Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:69 >> + [webView loadRequest:[NSURLRequest requestWithURL:contentURL]]; > > Is it actually necessary to load an HTML file that clicks a link to "https://www.apple.com&lt;&gt;/"? Would it not be sufficient to just call loadRequest: directly with that URL? I cannot create a NSURL object by passing a string containing an invalid URL. There is a complicated way we use in WebCoreNSURLExtras.mm to create a NSURL that accepts invalid URL strings. I choose the current way as it is easier and more understandable. 1178987 11 jiewen_tan 2016-03-29 23:39:17 -0700 (In reply to comment #9) > (In reply to comment #5) > > (In reply to comment #4) > > > What security vulnerability is this bug in regards to? While it is not > > > necessary to explain in detail in the bug the issue is (and you shouldn't) > > > this bug should out line the concern. > > > > The original concern is: > > Window objects that are scriptable from other windows such as the opener > > could potentially use this bug to mislead users about what page they are at > > > > However, I don't think it is valid now as the bug is not quite the same as > > it is originally reported. > > Ok, then what is the issue now? I am not capable of reassessing the security vulnerability of this bug. From my understanding, it is that we should show a Safari error page by 1178988 12 jiewen_tan 2016-03-29 23:40:32 -0700 (In reply to comment #11) > (In reply to comment #9) > > (In reply to comment #5) > > > (In reply to comment #4) > > > > What security vulnerability is this bug in regards to? While it is not > > > > necessary to explain in detail in the bug the issue is (and you shouldn't) > > > > this bug should out line the concern. > > > > > > The original concern is: > > > Window objects that are scriptable from other windows such as the opener > > > could potentially use this bug to mislead users about what page they are at > > > > > > However, I don't think it is valid now as the bug is not quite the same as > > > it is originally reported. > > > > Ok, then what is the issue now? > > I am not capable of reassessing the security vulnerability of this bug. From > my understanding, it is that we should show a Safari error page by dispatchDidFailProvisionalLoad with proper error msg when users navigate to invalid URLs. 1179066 13 aestes 2016-03-30 09:01:38 -0700 (In reply to comment #10) > Comment on attachment 275148 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=275148&action=review > > >> Source/WebCore/loader/DocumentLoader.cpp:1516 > >> + else { > > > > You should just return early after calling cancelMainResourceLoad(). > > I have a return statement after the if else control. Right. I'm suggesting you don't add the else block and instead just return after calling cancelMainResourceLoad(). > > >> Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:69 > >> + [webView loadRequest:[NSURLRequest requestWithURL:contentURL]]; > > > > Is it actually necessary to load an HTML file that clicks a link to "https://www.apple.com&lt;&gt;/"? Would it not be sufficient to just call loadRequest: directly with that URL? > > I cannot create a NSURL object by passing a string containing an invalid > URL. There is a complicated way we use in WebCoreNSURLExtras.mm to create a > NSURL that accepts invalid URL strings. I choose the current way as it is > easier and more understandable. Ok, thank makes sense. 1179290 14 275254 jiewen_tan 2016-03-30 19:02:17 -0700 Created attachment 275254 Patch 1179672 15 275254 bfulgham 2016-03-31 16:34:40 -0700 Comment on attachment 275254 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275254&action=review > Source/WebKit2/UIProcess/WebPageProxy.cpp:1007 > + // the page load state will not transit in a desired order. // When the UIProcess is in the process of handling a failing provisional load, do not attempt to // start a second alternative HTML load as this will prevent the page load state from being // handled properly. > Source/WebKit2/UIProcess/WebPageProxy.h:1514 > + bool m_isDealingFailingProvisionalLoad; I think this should be "bool m_isDealingFailingProvisionalLoad { false };" 1179692 16 275254 aestes 2016-03-31 17:24:08 -0700 Comment on attachment 275254 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275254&action=review From your conversation with Sam, I'm somewhat unclear if this still needs to be a security bug. r=me. > Source/WebKit2/UIProcess/WebPageProxy.cpp:1008 > + if (m_isClosed || m_isDealingFailingProvisionalLoad) Wouldn't any new load started in response to a provisional load failure cause this problem? For instance, if the client called loadRequest: instead of _loadAlternateHTMLString:baseURL:forUnreachableURL:, would you see the same assertion? If so, seems like we need a fix that won't involve adding checks like this to every loading entry point in the UI process. I'm ok with this for now, since you are handling what Safari does, but we might need to come up with a better long-term solution. >> Source/WebKit2/UIProcess/WebPageProxy.h:1514 >> + bool m_isDealingFailingProvisionalLoad; > > I think this should be "bool m_isDealingFailingProvisionalLoad { false };" Not a fan of this name. Let's be specific: m_isLoadingAlternateHTMLStringForFailingProvisionalLoad. > Tools/ChangeLog:10 > + * TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm: It doesn't make sense to have a test with WebKit1 code inside Tests/WebKit2Cocoa/. Either add two files, or just put this in Tests/Cocoa/. > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:38 > +static int provisionalLoadCount = 0; You don't need to initialize this to 0. > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:48 > +static NSData *literalAsData(const char* literal) > +{ > + return [NSData dataWithBytes:literal length:strlen(literal)]; > +} > + > +static NSURL *literalURL(const char* literal) > +{ > + return WebCore::URLWithData(literalAsData(literal), nil); > +} Not sure you really need these functions. > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:58 > + [webView _loadAlternateHTMLString:@"error page" baseURL:nil forUnreachableURL:[NSURL URLWithString:@"data:"]]; The unreachable URL shouldn't be "data:", it should be the invalid URL you passed to loadRequest:. > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:122 > + [webView loadRequest:[NSURLRequest requestWithURL:literalURL("https://www.example.com<>/")]]; > + [webView loadRequest:[NSURLRequest requestWithURL:literalURL("https://www.example.com<>/")]]; Why create two of the same URLs when you could just have one local NSURL? > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:59 > +- (void)webView:(WKWebView *)webView didFailProvisionalNavigation:(WKNavigation *)navigation withError:(NSError *)error Can you check that the NSError has the domain/code/userInfo you'd expect for a cannotShowURLError? > Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadInvalidURLRequest.mm:80 > +- (void)webView:(WebView *)sender didFailProvisionalLoadWithError:(NSError *)error forFrame:(WebFrame *)frame Ditto. 1179698 17 275254 jiewen_tan 2016-03-31 17:52:12 -0700 Comment on attachment 275254 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275254&action=review Thanks Andy and Brent for giving comments! >> Source/WebKit2/UIProcess/WebPageProxy.cpp:1008 >> + if (m_isClosed || m_isDealingFailingProvisionalLoad) > > Wouldn't any new load started in response to a provisional load failure cause this problem? For instance, if the client called loadRequest: instead of _loadAlternateHTMLString:baseURL:forUnreachableURL:, would you see the same assertion? If so, seems like we need a fix that won't involve adding checks like this to every loading entry point in the UI process. I'm ok with this for now, since you are handling what Safari does, but we might need to come up with a better long-term solution. I don't think other APIs have the same problem. It should be only specific to loadAlternateHTMLString as the way we tell if we are in the process of responding to a provisional load failure in WebProcess is to check whether FrameLoader ::m_provisionalLoadErrorBeingHandledURL is empty. This member is only set/clear at WebPage::loadAlternateHTMLString. >> Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:48 >> +} > > Not sure you really need these functions. I can't initiate a NSURL object easily by passing a string containing invalid URLs. However, with the help of WebCore::URLWithData, it can be done. 1179703 18 aestes 2016-03-31 18:22:25 -0700 (In reply to comment #17) > Comment on attachment 275254 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=275254&action=review > > Thanks Andy and Brent for giving comments! > > >> Source/WebKit2/UIProcess/WebPageProxy.cpp:1008 > >> + if (m_isClosed || m_isDealingFailingProvisionalLoad) > > > > Wouldn't any new load started in response to a provisional load failure cause this problem? For instance, if the client called loadRequest: instead of _loadAlternateHTMLString:baseURL:forUnreachableURL:, would you see the same assertion? If so, seems like we need a fix that won't involve adding checks like this to every loading entry point in the UI process. I'm ok with this for now, since you are handling what Safari does, but we might need to come up with a better long-term solution. > > I don't think other APIs have the same problem. It should be only specific > to loadAlternateHTMLString as the way we tell if we are in the process of > responding to a provisional load failure in WebProcess is to check whether > FrameLoader ::m_provisionalLoadErrorBeingHandledURL is empty. This member is > only set/clear at WebPage::loadAlternateHTMLString. No, that's not true. m_provisionalLoadErrorBeingHandledURL is set in FrameLoader whenever there's a provisional load failure. It's also set in WebPage::loadAlternateHTMLString(), but that's just to account for the fact that WebKit2 clients do not load alternate HTML synchronously. My question was whether the assertion failure you saw would also occur in the presence of two sequential provisionally failing loads when the client responded to the second one with something other than _loadAlternateHTMLString:... > > >> Tools/TestWebKitAPI/Tests/WebKit2Cocoa/LoadAlternateHTMLString.mm:48 > >> +} > > > > Not sure you really need these functions. > > I can't initiate a NSURL object easily by passing a string containing > invalid URLs. However, with the help of WebCore::URLWithData, it can be done. I get that part. I was just suggesting that you didn't need to create new functions to do this; just call URLWithData() directly. 1179725 19 275254 jiewen_tan 2016-03-31 18:59:20 -0700 Comment on attachment 275254 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=275254&action=review >>>> Source/WebKit2/UIProcess/WebPageProxy.cpp:1008 >>>> + if (m_isClosed || m_isDealingFailingProvisionalLoad) >>> >>> Wouldn't any new load started in response to a provisional load failure cause this problem? For instance, if the client called loadRequest: instead of _loadAlternateHTMLString:baseURL:forUnreachableURL:, would you see the same assertion? If so, seems like we need a fix that won't involve adding checks like this to every loading entry point in the UI process. I'm ok with this for now, since you are handling what Safari does, but we might need to come up with a better long-term solution. >> >> I don't think other APIs have the same problem. It should be only specific to loadAlternateHTMLString as the way we tell if we are in the process of responding to a provisional load failure in WebProcess is to check whether FrameLoader ::m_provisionalLoadErrorBeingHandledURL is empty. This member is only set/clear at WebPage::loadAlternateHTMLString. > > No, that's not true. m_provisionalLoadErrorBeingHandledURL is set in FrameLoader whenever there's a provisional load failure. It's also set in WebPage::loadAlternateHTMLString(), but that's just to account for the fact that WebKit2 clients do not load alternate HTML synchronously. > > My question was whether the assertion failure you saw would also occur in the presence of two sequential provisionally failing loads when the client responded to the second one with something other than _loadAlternateHTMLString:... I think the situation you mentioned is fine, but what will cause problems is replacing the first one with some other load APIs. Once WebProcess enter the state of loadAlternateHTMLString, it will lose the ability to send DidFailProvisionalLoad error through checkLoadCompleteForThisFrame to the clients, and therefore any back to back load before loadAlternateHTMLString will cause the assertion to hit. The way how loadAlternateHTMLString lock things down is too heavy. I don't have any idea to fix this for long term so far. 1179726 20 aestes 2016-03-31 19:01:46 -0700 (In reply to comment #19) > Comment on attachment 275254 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=275254&action=review > > >>>> Source/WebKit2/UIProcess/WebPageProxy.cpp:1008 > >>>> + if (m_isClosed || m_isDealingFailingProvisionalLoad) > >>> > >>> Wouldn't any new load started in response to a provisional load failure cause this problem? For instance, if the client called loadRequest: instead of _loadAlternateHTMLString:baseURL:forUnreachableURL:, would you see the same assertion? If so, seems like we need a fix that won't involve adding checks like this to every loading entry point in the UI process. I'm ok with this for now, since you are handling what Safari does, but we might need to come up with a better long-term solution. > >> > >> I don't think other APIs have the same problem. It should be only specific to loadAlternateHTMLString as the way we tell if we are in the process of responding to a provisional load failure in WebProcess is to check whether FrameLoader ::m_provisionalLoadErrorBeingHandledURL is empty. This member is only set/clear at WebPage::loadAlternateHTMLString. > > > > No, that's not true. m_provisionalLoadErrorBeingHandledURL is set in FrameLoader whenever there's a provisional load failure. It's also set in WebPage::loadAlternateHTMLString(), but that's just to account for the fact that WebKit2 clients do not load alternate HTML synchronously. > > > > My question was whether the assertion failure you saw would also occur in the presence of two sequential provisionally failing loads when the client responded to the second one with something other than _loadAlternateHTMLString:... > > I think the situation you mentioned is fine, but what will cause problems is > replacing the first one with some other load APIs. > > Once WebProcess enter the state of loadAlternateHTMLString, it will lose the > ability to send DidFailProvisionalLoad error through > checkLoadCompleteForThisFrame to the clients, and therefore any back to back > load before loadAlternateHTMLString will cause the assertion to hit. > > The way how loadAlternateHTMLString lock things down is too heavy. I don't > have any idea to fix this for long term so far. It isn't urgent since we don't know if any clients actually do this, but filing a bug and writing some test cases is a good place to start. Thanks! 1179925 21 275426 jiewen_tan 2016-04-01 13:51:33 -0700 Created attachment 275426 Patch for landing 1179933 22 275426 commit-queue 2016-04-01 14:40:16 -0700 Comment on attachment 275426 Patch for landing Clearing flags on attachment: 275426 Committed r198956: <http://trac.webkit.org/changeset/198956> 1179938 23 jiewen_tan 2016-04-01 14:46:29 -0700 Bug 156117 is filed to address the issue of SPI: _LoadAlternateHTMLString. 1180003 24 jiewen_tan 2016-04-01 18:49:13 -0700 A build fix for adopting existing API tests to the new change has been landed: Committed r198964: <http://trac.webkit.org/changeset/198964> 1180177 25 aestes 2016-04-03 06:55:59 -0700 (In reply to comment #22) > Comment on attachment 275426 [details] > Patch for landing > > Clearing flags on attachment: 275426 > > Committed r198956: <http://trac.webkit.org/changeset/198956> > > +- (void)webView:(WKWebView *)webView didFailProvisionalNavigation:(WKNavigation *)navigation withError:(NSError *)error > +{ > + if ([error.domain isEqual:@"WebKitErrorDomain"] > + && error.code == WebKitErrorCannotShowURL > + && [error.userInfo[@"NSErrorFailingURLKey"] isEqual:literalURL(literal)]) > + didFailProvisionalLoad = true; > + didFinishTest = true; > +} This wasn't what I meant when I suggested that you "check that the NSError has the domain/code/userInfo you'd expect". I was suggesting that you use EXPECT macros to verify the error is of the form we expect. Sorry if I wasn't clear. 1180459 26 jiewen_tan 2016-04-04 13:17:57 -0700 (In reply to comment #25) > (In reply to comment #22) > > Comment on attachment 275426 [details] > > Patch for landing > > > > Clearing flags on attachment: 275426 > > > > Committed r198956: <http://trac.webkit.org/changeset/198956> > > > > +- (void)webView:(WKWebView *)webView didFailProvisionalNavigation:(WKNavigation *)navigation withError:(NSError *)error > > +{ > > + if ([error.domain isEqual:@"WebKitErrorDomain"] > > + && error.code == WebKitErrorCannotShowURL > > + && [error.userInfo[@"NSErrorFailingURLKey"] isEqual:literalURL(literal)]) > > + didFailProvisionalLoad = true; > > + didFinishTest = true; > > +} > > This wasn't what I meant when I suggested that you "check that the NSError > has the domain/code/userInfo you'd expect". I was suggesting that you use > EXPECT macros to verify the error is of the form we expect. Sorry if I > wasn't clear. Committed r199018: <http://trac.webkit.org/changeset/199018> to address Andy's comments. 275148 2016-03-29 16:35:42 -0700 2016-03-30 19:02:15 -0700 Patch bug-155995-20160329163545.patch text/plain 13707 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMTk4NTkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGU1OGU0OTNlOGRkNGEz MDUxNjU5NmY1OWFhYzc1Mjg1ZmQ5OTIyYy4uN2IyNTM2ZjQyMDBlODFiYzQ2NzFlN2IwNWFjZGVm YjgzNTFkOGIyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE2LTAzLTI5ICBKaWV3 ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0IHNob3VsZCBk aXNwYXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQgd2hpbGUgbG9hZGluZyBpbnZhbGlkIFVSTHMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTk5NQor ICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTQ5NjcwMDQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgQVBJIFRlc3RzLgorCisgICAgICAgIElm IGEgbG9hZGluZyByZXF1ZXN0IGNvbnRhaW5zIGFuIGludmFsaWQgVVJMLCBEb2N1bWVudExvYWRl ciB3aWxsIG5vdyBkaXNwYXRjaAorICAgICAgICBjYW5ub3RTaG93VVJMRXJyb3IgdG8gVUkgcHJv Y2Vzcy4KKworICAgICAgICAqIGxvYWRlci9Eb2N1bWVudExvYWRlci5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpEb2N1bWVudExvYWRlcjo6c3RhcnRMb2FkaW5nTWFpblJlc291cmNlKToKKyAgICAg ICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2Fk ZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKToKKwogMjAxNi0wMy0yMyAgQnJlbnQg RnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2ViR0xdIE5vbi1wb3dl ci1vZi10d28gdGV4dHVyZSBvcHRpbWl6YXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9Eb2N1bWVudExvYWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1l bnRMb2FkZXIuY3BwCmluZGV4IGYzODMzYzY4M2JmODk1ZWYwYjA1ZTc0NzRiODdiNjZhOTk2ZDUz MDMuLmY3ZGJlZWM2ZTI2MDhhZWRlNTk4OTZlZjJjZmVkNTI0OWFkZWM4N2EgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudExvYWRlci5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvbG9hZGVyL0RvY3VtZW50TG9hZGVyLmNwcApAQCAtMTUxMSwxMiArMTUxMSwxNyBAQCB2 b2lkIERvY3VtZW50TG9hZGVyOjpzdGFydExvYWRpbmdNYWluUmVzb3VyY2UoKQogI2VuZGlmCiAK ICAgICBpZiAoIW1fbWFpblJlc291cmNlKSB7Ci0gICAgICAgIHNldFJlcXVlc3QoUmVzb3VyY2VS ZXF1ZXN0KCkpOwotICAgICAgICAvLyBJZiB0aGUgbG9hZCB3YXMgYWJvcnRlZCBieSBjbGVhcmlu ZyBtX3JlcXVlc3QsIGl0J3MgcG9zc2libGUgdGhlIEFwcGxpY2F0aW9uQ2FjaGVIb3N0Ci0gICAg ICAgIC8vIGlzIG5vdyBpbiBhIHN0YXRlIHdoZXJlIHN0YXJ0aW5nIGFuIGVtcHR5IGxvYWQgd2ls bCBiZSBpbmNvbnNpc3RlbnQuIFJlcGxhY2UgaXQgd2l0aAotICAgICAgICAvLyBhIG5ldyBBcHBs aWNhdGlvbkNhY2hlSG9zdC4KLSAgICAgICAgbV9hcHBsaWNhdGlvbkNhY2hlSG9zdCA9IHN0ZDo6 bWFrZV91bmlxdWU8QXBwbGljYXRpb25DYWNoZUhvc3Q+KCp0aGlzKTsKLSAgICAgICAgbWF5YmVM b2FkRW1wdHkoKTsKKyAgICAgICAgaWYgKCFtX3JlcXVlc3QudXJsKCkuaXNWYWxpZCgpKQorICAg ICAgICAgICAgY2FuY2VsTWFpblJlc291cmNlTG9hZChmcmFtZUxvYWRlcigpLT5jbGllbnQoKS5j YW5ub3RTaG93VVJMRXJyb3IobV9yZXF1ZXN0KSk7CisgICAgICAgIGVsc2UgeworICAgICAgICAg ICAgc2V0UmVxdWVzdChSZXNvdXJjZVJlcXVlc3QoKSk7CisgICAgICAgICAgICAvLyBJZiB0aGUg bG9hZCB3YXMgYWJvcnRlZCBieSBjbGVhcmluZyBtX3JlcXVlc3QsIGl0J3MgcG9zc2libGUgdGhl IEFwcGxpY2F0aW9uQ2FjaGVIb3N0CisgICAgICAgICAgICAvLyBpcyBub3cgaW4gYSBzdGF0ZSB3 aGVyZSBzdGFydGluZyBhbiBlbXB0eSBsb2FkIHdpbGwgYmUgaW5jb25zaXN0ZW50LiBSZXBsYWNl IGl0IHdpdGgKKyAgICAgICAgICAgIC8vIGEgbmV3IEFwcGxpY2F0aW9uQ2FjaGVIb3N0LgorICAg ICAgICAgICAgbV9hcHBsaWNhdGlvbkNhY2hlSG9zdCA9IHN0ZDo6bWFrZV91bmlxdWU8QXBwbGlj YXRpb25DYWNoZUhvc3Q+KCp0aGlzKTsKKyAgICAgICAgICAgIG1heWJlTG9hZEVtcHR5KCk7Cisg ICAgICAgIH0KKwogICAgICAgICByZXR1cm47CiAgICAgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0Zy YW1lTG9hZGVyLmNwcAppbmRleCBmYjYwNGViOTkzNjcwYWUwYzg2ODAzMzFjOGEzMWU4NDEwOTYz MTJlLi4yOGVkOTJlODJjNWE3YWJlNDJiYWE1MDY5Y2FiNWExNTlkY2EyMjE0IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTIxOTksMTggKzIxOTksMTggQEAgdm9pZCBG cmFtZUxvYWRlcjo6Y2hlY2tMb2FkQ29tcGxldGVGb3JUaGlzRnJhbWUoKQogCiAgICAgc3dpdGNo IChtX3N0YXRlKSB7CiAgICAgICAgIGNhc2UgRnJhbWVTdGF0ZVByb3Zpc2lvbmFsOiB7Ci0gICAg ICAgICAgICBpZiAoIW1fcHJvdmlzaW9uYWxMb2FkRXJyb3JCZWluZ0hhbmRsZWRVUkwuaXNFbXB0 eSgpKQotICAgICAgICAgICAgICAgIHJldHVybjsKLQogICAgICAgICAgICAgUmVmUHRyPERvY3Vt ZW50TG9hZGVyPiBwZGwgPSBtX3Byb3Zpc2lvbmFsRG9jdW1lbnRMb2FkZXI7CiAgICAgICAgICAg ICBpZiAoIXBkbCkKICAgICAgICAgICAgICAgICByZXR1cm47Ci0gICAgICAgICAgICAgICAgCisK ICAgICAgICAgICAgIC8vIElmIHdlJ3ZlIHJlY2VpdmVkIGFueSBlcnJvcnMgd2UgbWF5IGJlIHN0 dWNrIGluIHRoZSBwcm92aXNpb25hbCBzdGF0ZSBhbmQgYWN0dWFsbHkgY29tcGxldGUuCiAgICAg ICAgICAgICBjb25zdCBSZXNvdXJjZUVycm9yJiBlcnJvciA9IHBkbC0+bWFpbkRvY3VtZW50RXJy b3IoKTsKICAgICAgICAgICAgIGlmIChlcnJvci5pc051bGwoKSkKICAgICAgICAgICAgICAgICBy ZXR1cm47CiAKKyAgICAgICAgICAgIGlmICghbV9wcm92aXNpb25hbExvYWRFcnJvckJlaW5nSGFu ZGxlZFVSTC5pc0VtcHR5KCkgJiYgIWVycm9yLmlzQ2FuY2VsbGF0aW9uKCkpCisgICAgICAgICAg ICAgICAgcmV0dXJuOworCiAgICAgICAgICAgICAvLyBDaGVjayBhbGwgY2hpbGRyZW4gZmlyc3Qu CiAgICAgICAgICAgICBSZWZQdHI8SGlzdG9yeUl0ZW0+IGl0ZW07CiAgICAgICAgICAgICBpZiAo UGFnZSogcGFnZSA9IG1fZnJhbWUucGFnZSgpKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9n IGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGVjMjM1OGU5NmE2NDhkMzkzYTU3YmM3ZmI1ZGEzNTUw MDVjNDllOTYuLjM2ZDIzNDM1ODQ4NzYzMGNlZWM4ZTc3NmUyMTJiZTcxNjJlZGY3NGMgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx OCBAQAorMjAxNi0wMy0yOSAgSmlld2VuIFRhbiAgPGppZXdlbl90YW5AYXBwbGUuY29tPgorCisg ICAgICAgIFdlYktpdCBzaG91bGQgZGlzcGF0Y2hEaWRGYWlsUHJvdmlzaW9uYWxMb2FkIHdoaWxl IGxvYWRpbmcgaW52YWxpZCBVUkxzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNTU5OTUKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzE0OTY3MDA0Pgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAg ICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9hZEludmFsaWRVUkxSZXF1ZXN0 Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0MkNvY29h L0xvYWRJbnZhbGlkVVJMUmVxdWVzdC5tbTogQWRkZWQuCisgICAgICAgICgtW0xvYWRJbnZhbGlk VVJMTmF2aWdhdGlvbkFjdGlvbkRlbGVnYXRlIHdlYlZpZXc6ZGlkRmFpbFByb3Zpc2lvbmFsTmF2 aWdhdGlvbjp3aXRoRXJyb3I6XSk6CisgICAgICAgICgtW0xvYWRJbnZhbGlkVVJMTmF2aWdhdGlv bkFjdGlvbkRlbGVnYXRlIHdlYlZpZXc6ZGlkQ29tbWl0TmF2aWdhdGlvbjpdKToKKyAgICAgICAg KFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE2LTAzLTIyICBLZWl0aCBSb2xsaW4gIDxrcm9s bGluQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkOiBhZGQgS2VpdGggUm9sbGluIHRv IHRoZSBjb21taXR0ZXJzIGxpc3QuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDZjODUyYzhi ZWI1ZDRkZTZlZTc5Y2I3MGIzMjM5OGVkZjI5Y2EyMjUuLmRiZmYxZjAzOTRiYWQ4Mzk4MmZjMTVh MjY4OTU4MWY0ZjY1ZGFiZmEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC04Nyw2ICs4Nyw4 IEBACiAJCTUyQjhDRjk4MTU4NjhEOTEwMDI4MTA1MyAvKiBTZXREb2N1bWVudFVSSS5odG1sIGlu IENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUyQjhD Rjk0MTU4NjhDRjAwMDI4MTA1MyAvKiBTZXREb2N1bWVudFVSSS5odG1sICovOyB9OwogCQk1MkQ2 NzNFRTFBRkIxMjczMDBGQTE5RkUgLyogV0tQYWdlQ29weVNlc3Npb25TdGF0ZVdpdGhGaWx0ZXJp bmcuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTJE NjczRUMxQUZCMTI2ODAwRkExOUZFIC8qIFdLUGFnZUNvcHlTZXNzaW9uU3RhdGVXaXRoRmlsdGVy aW5nLmNwcCAqLzsgfTsKIAkJNTJFNUNFNDkxNEQyMUVBQjAwM0IyQkQ4IC8qIFBhcmVudEZyYW1l X0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA1MkU1Q0U0ODE0RDIxRUFCMDAzQjJCRDggLyogUGFyZW50RnJhbWVfQnVuZGxlLmNwcCAqLzsg fTsKKwkJNTc4NkM4NTMxQ0FCMkQ3MzAwQ0IzNkRCIC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5t bSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3ODZDODUy MUNBQjJENzMwMENCMzZEQiAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gKi87IH07CisJCTU3 ODZDODU1MUNBQjM4QzMwMENCMzZEQiAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCBpbiBD b3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1Nzg2Qzg1 NDFDQUIzOEFEMDBDQjM2REIgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0bWwgKi87IH07CiAJ CTU3RjEwRDkzMUM3RTdCMzgwMEVDREYzMCAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLm1t IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTdGMTBEOTIx QzdFN0IzODAwRUNERjMwIC8qIElzTmF2aWdhdGlvbkFjdGlvblRydXN0ZWQubW0gKi87IH07CiAJ CTU3RjU2QTVDMUM3RjhDQzEwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0 bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2aWdhdGlvbkFjdGlvblRydXN0ZWQuaHRt bCAqLzsgfTsKIAkJNzY0MzIyRDcxQjYxQ0NDMzAwMjRGODAxIC8qIFdvcmRCb3VuZGFyeVR5cGlu Z0F0dHJpYnV0ZXMubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA3NjQzMjJENTFCNjFDQ0E0MDAyNEY4MDEgLyogV29yZEJvdW5kYXJ5VHlwaW5nQXR0cmli dXRlcy5tbSAqLzsgfTsKQEAgLTQwNyw2ICs0MDksNyBAQAogCQkJZHN0UGF0aCA9IFRlc3RXZWJL aXRBUEkucmVzb3VyY2VzOwogCQkJZHN0U3ViZm9sZGVyU3BlYyA9IDc7CiAJCQlmaWxlcyA9ICgK KwkJCQk1Nzg2Qzg1NTFDQUIzOEMzMDBDQjM2REIgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0 bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8sCiAJCQkJQ0Q5RTI5MkUxQzkwQzMzRjAwMEJCODAwIC8q IGF1ZGlvLW9ubHkuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJCQk1MUJDRUU0RTFDODRG NTNCMDA0MkM4MkUgLyogSW5kZXhlZERCTXVsdGlQcm9jZXNzLTEuaHRtbCBpbiBDb3B5IFJlc291 cmNlcyAqLywKIAkJCQk1MUJDRUU0RjFDODRGNTNCMDA0MkM4MkUgLyogSW5kZXhlZERCTXVsdGlQ cm9jZXNzLTIuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKQEAgLTY0NSw2ICs2NDgsOCBAQAog CQk1MkQ2NzNFQzFBRkIxMjY4MDBGQTE5RkUgLyogV0tQYWdlQ29weVNlc3Npb25TdGF0ZVdpdGhG aWx0ZXJpbmcuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV0tQYWdl Q29weVNlc3Npb25TdGF0ZVdpdGhGaWx0ZXJpbmcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk1MkU1Q0U0NTE0RDIxRTlEMDAzQjJCRDggLyogUGFyZW50RnJhbWUuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGFyZW50RnJhbWUuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk1MkU1Q0U0ODE0RDIxRUFCMDAzQjJCRDggLyogUGFyZW50 RnJhbWVfQnVuZGxlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFBh cmVudEZyYW1lX0J1bmRsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU3ODZD ODUyMUNBQjJENzMwMENCMzZEQiAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW07 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU3ODZDODU0MUNBQjM4QUQwMENCMzZEQiAv KiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9 IExvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk1N0YxMEQ5MjFDN0U3QjM4MDBFQ0RGMzAgLyogSXNOYXZpZ2F0aW9uQWN0aW9uVHJ1c3RlZC5t bSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IElzTmF2aWdhdGlvbkFj dGlvblRydXN0ZWQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTU3RjU2QTVCMUM3 RjhBNDAwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0bWwgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSB0ZXh0Lmh0bWw7IHBhdGggPSBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0bWw7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc1NjA5MTc3MTkyNTlDNTkwMDlFRjA2RSAvKiBNZW1v cnlDYWNoZUFkZEltYWdlVG9DYWNoZUlPUy5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9i amNwcDsgcGF0aCA9IE1lbW9yeUNhY2hlQWRkSW1hZ2VUb0NhY2hlSU9TLm1tOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtMTAxMyw2ICsxMDE4LDcgQEAKIAkJCQk1MUJDRUU0OTFDODRG NEFGMDA0MkM4MkUgLyogSW5kZXhlZERCTXVsdGlQcm9jZXNzLm1tICovLAogCQkJCTUxQjFFRThE MUM4MEY1ODgwMDY0RkI5OCAvKiBJbmRleGVkREJQZXJzaXN0ZW5jZS5tbSAqLywKIAkJCQkzN0Qz NkVENjFBRjQyRUNEMDBCQUY1RDkgLyogTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmcubW0gKi8sCisJ CQkJNTc4NkM4NTIxQ0FCMkQ3MzAwQ0IzNkRCIC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5tbSAq LywKIAkJCQk1MUNEMUM2QTFCMzhDRTM2MDAxNDJDQTUgLyogTW9kYWxBbGVydHMubW0gKi8sCiAJ CQkJMUFCQzNERUQxODk5QkU2RDAwNEYwNjI2IC8qIE5hdmlnYXRpb24ubW0gKi8sCiAJCQkJQTFE Rjc0MzAxQzQxQjY1ODAwQTJGNEQwIC8qIEFsd2F5c1JldmFsaWRhdGVkVVJMU2NoZW1lcy5tbSAq LywKQEAgLTExMTIsNiArMTExOCw3IEBACiAJCQkJNTFCQ0VFNEQxQzg0RjUyQzAwNDJDODJFIC8q IEluZGV4ZWREQk11bHRpUHJvY2Vzcy0yLmh0bWwgKi8sCiAJCQkJNTFCMUVFOTQxQzgwRkFERDAw NjRGQjk4IC8qIEluZGV4ZWREQlBlcnNpc3RlbmNlLTEuaHRtbCAqLywKIAkJCQk1MUIxRUU5NTFD ODBGQUREMDA2NEZCOTggLyogSW5kZXhlZERCUGVyc2lzdGVuY2UtMi5odG1sICovLAorCQkJCTU3 ODZDODU0MUNBQjM4QUQwMENCMzZEQiAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCAqLywK IAkJCSk7CiAJCQluYW1lID0gUmVzb3VyY2VzOwogCQkJc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsK QEAgLTE5MjksNiArMTkzNiw3IEBACiAJCQlidWlsZEFjdGlvbk1hc2sgPSAyMTQ3NDgzNjQ3Owog CQkJZmlsZXMgPSAoCiAJCQkJMkQ5QTUzQUYxQjMxRkE4RDAwNzRENUFBIC8qIFNocmlua1RvRml0 Lm1tIGluIFNvdXJjZXMgKi8sCisJCQkJNTc4NkM4NTMxQ0FCMkQ3MzAwQ0IzNkRCIC8qIExvYWRJ bnZhbGlkVVJMUmVxdWVzdC5tbSBpbiBTb3VyY2VzICovLAogCQkJCTUxQjQ1NEVDMUI0RTIzNkIw MDg1RUFBNiAvKiBXZWJWaWV3Q2xvc2VJbnNpZGVEaWRGaW5pc2hMb2FkRm9yRnJhbWUubW0gaW4g U291cmNlcyAqLywKIAkJCQk3QUEwMjFCQjFBQjA5RUE3MDA1Mjk1M0YgLyogRGF0ZU1hdGguY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJQ0U1MEQ4Q0ExQzg2NjVDRTAwNzJFQTVBIC8qIE9wdGlvblNl dC5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0MkNvY29hL0xvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uNDM3NmY3NTQxOWYxNDg4YzZkYTQyNGZmMDdiOGRiODU2N2E4OWZlOQotLS0gL2Rl di9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0MkNvY29hL0xvYWRJ bnZhbGlkVVJMUmVxdWVzdC5odG1sCkBAIC0wLDAgKzEsMTIgQEAKKzwhRE9DVFlQRSBodG1sPgor PGh0bWw+Cis8aGVhZD4KKzwvaGVhZD4KKzxib2R5PgorICAgIDxhIGlkPSJocmVmIiBocmVmPSJo dHRwczovL3d3dy5hcHBsZS5jb208Pi8iPmh0dHBzOi8vd3d3LmFwcGxlLmNvbSZsdDsmZ3Q7Lzwv YT4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgZWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJocmVmIik7CisgICAgICAgIGVsZW1lbnQuY2xpY2soKTsKKyAgICA8L3NjcmlwdD4K KzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkSW52YWxpZFVSTFJl cXVlc3QubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkSW52 YWxpZFVSTFJlcXVlc3QubW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMWY2M2JlOWFmZTdhZGRlYmExY2NlODVmMTE2 MzVkNDQyZDUwMDU5NAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0MkNvY29hL0xvYWRJbnZhbGlkVVJMUmVxdWVzdC5tbQpAQCAtMCwwICsxLDgyIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgV0tfQVBJX0VOQUJMRUQK KworI2ltcG9ydCAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbXBvcnQgPFdlYktpdC9XS05hdmln YXRpb25Qcml2YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3Lmg+CisjaW1wb3J0IDx3 dGYvUmV0YWluUHRyLmg+CisKK3N0YXRpYyBib29sIGRpZEZpbmlzaFRlc3Q7CitzdGF0aWMgYm9v bCBkaWRGYWlsUHJvdmlzaW9uYWxMb2FkOworc3RhdGljIE5TVVJMICpjb250ZW50VVJMID0gW1tO U0J1bmRsZSBtYWluQnVuZGxlXSBVUkxGb3JSZXNvdXJjZTpAIkxvYWRJbnZhbGlkVVJMUmVxdWVz dCIgd2l0aEV4dGVuc2lvbjpAImh0bWwiIHN1YmRpcmVjdG9yeTpAIlRlc3RXZWJLaXRBUEkucmVz b3VyY2VzIl07CisKK0BpbnRlcmZhY2UgTG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVs ZWdhdGUgOiBOU09iamVjdCA8V0tOYXZpZ2F0aW9uRGVsZWdhdGU+CitAZW5kCisKK0BpbXBsZW1l bnRhdGlvbiBMb2FkSW52YWxpZFVSTE5hdmlnYXRpb25BY3Rpb25EZWxlZ2F0ZQorCistICh2b2lk KXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkRmFpbFByb3Zpc2lvbmFsTmF2aWdhdGlv bjoobnVsbF91bnNwZWNpZmllZCBXS05hdmlnYXRpb24gKiluYXZpZ2F0aW9uIHdpdGhFcnJvcjoo TlNFcnJvciAqKWVycm9yCit7CisgICAgaWYgKCFbbmF2aWdhdGlvbi5fcmVxdWVzdC5VUkwgaXNF cXVhbDpjb250ZW50VVJMXSkgeworICAgICAgICBkaWRGYWlsUHJvdmlzaW9uYWxMb2FkID0gdHJ1 ZTsKKyAgICAgICAgZGlkRmluaXNoVGVzdCA9IHRydWU7CisgICAgfQorfQorCistICh2b2lkKXdl YlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkQ29tbWl0TmF2aWdhdGlvbjoobnVsbF91bnNw ZWNpZmllZCBXS05hdmlnYXRpb24gKiluYXZpZ2F0aW9uCit7CisgICAgaWYgKCFbbmF2aWdhdGlv bi5fcmVxdWVzdC5VUkwgaXNFcXVhbDpjb250ZW50VVJMXSkKKyAgICAgICAgZGlkRmluaXNoVGVz dCA9IHRydWU7Cit9CisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitURVNU KFdlYktpdDIsIExvYWRJbnZhbGlkVVJMUmVxdWVzdCkKK3sKKyAgICBAYXV0b3JlbGVhc2Vwb29s IHsKKyAgICAgICAgUmV0YWluUHRyPFdLV2ViVmlldz4gd2ViVmlldyA9IGFkb3B0TlMoW1tXS1dl YlZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVjdCgwLCAwLCA4MDAsIDYwMCldKTsK KworICAgICAgICBSZXRhaW5QdHI8TG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVsZWdh dGU+IGRlbGVnYXRlID0gYWRvcHROUyhbW0xvYWRJbnZhbGlkVVJMTmF2aWdhdGlvbkFjdGlvbkRl bGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgICAgIFt3ZWJWaWV3IHNldE5hdmlnYXRpb25EZWxl Z2F0ZTpkZWxlZ2F0ZS5nZXQoKV07CisgICAgICAgIFt3ZWJWaWV3IGxvYWRSZXF1ZXN0OltOU1VS TFJlcXVlc3QgcmVxdWVzdFdpdGhVUkw6Y29udGVudFVSTF1dOworCisgICAgICAgIGRpZEZpbmlz aFRlc3QgPSBmYWxzZTsKKyAgICAgICAgZGlkRmFpbFByb3Zpc2lvbmFsTG9hZCA9IGZhbHNlOwor ICAgICAgICBVdGlsOjpydW4oJmRpZEZpbmlzaFRlc3QpOworCisgICAgICAgIEVYUEVDVF9UUlVF KGRpZEZhaWxQcm92aXNpb25hbExvYWQpOworICAgIH0KK30KKyAgICAKK30gLy8gbmFtZXNwYWNl IFRlc3RXZWJLaXRBUEkKKworI2VuZGlmCisK 275254 2016-03-30 19:02:17 -0700 2016-03-31 17:24:08 -0700 Patch bug-155995-20160330190221.patch text/plain 17854 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMTk4NTkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGU1OGU0OTNlOGRkNGEz MDUxNjU5NmY1OWFhYzc1Mjg1ZmQ5OTIyYy4uZDk2NTM2MDhiZDJmODgwZTRhOGUyMjU4NmExZjcw YjcwNDE4MGViYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE2LTAzLTMwICBKaWV3 ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0IHNob3VsZCBk aXNwYXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQgd2hpbGUgbG9hZGluZyBpbnZhbGlkIFVSTHMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTk5NQor ICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTQ5NjcwMDQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgQVBJIFRlc3RzLgorCisgICAgICAgIElm IGEgbG9hZGluZyByZXF1ZXN0IGNvbnRhaW5zIGFuIGludmFsaWQgVVJMLCBEb2N1bWVudExvYWRl ciB3aWxsIG5vdyBkaXNwYXRjaAorICAgICAgICBjYW5ub3RTaG93VVJMRXJyb3IgdG8gdGhlIGNs aWVudHMuCisKKyAgICAgICAgKiBsb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6RG9jdW1lbnRMb2FkZXI6OnN0YXJ0TG9hZGluZ01haW5SZXNvdXJjZSk6CisKIDIw MTYtMDMtMjMgIEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hhbUBhcHBsZS5jb20+CiAKICAgICAgICAg W1dlYkdMXSBOb24tcG93ZXItb2YtdHdvIHRleHR1cmUgb3B0aW1pemF0aW9uCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5k ZXggZjJjOWY0ZTYxYmRiMjI4YjJlYmIwMTQwMzU3YzdjZTE0NmUzZTUzNy4uM2IzODIyOTdkYjNl ODBlODgwYTRiMGY3YTZiZjNlZDZhNmM0YjVjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBA CisyMDE2LTAzLTMwICBKaWV3ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CisKKyAgICAg ICAgV2ViS2l0IHNob3VsZCBkaXNwYXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQgd2hpbGUgbG9h ZGluZyBpbnZhbGlkIFVSTHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTE1NTk5NQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTQ5NjcwMDQ+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRW5zdXJlIHRoYXQg YWx0ZXJuYXRpdmUgSFRNTCBzdHJpbmcgd2lsbCBub3QgYmUgbG9hZGVkIGJhY2sgdG8gYmFjayBm b3IKKyAgICAgICAgZmFpbGluZyBwcm92aXNpb25hbCBsb2Fkcy4KKworICAgICAgICAqIFVJUHJv Y2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6Omxv YWRBbHRlcm5hdGVIVE1MU3RyaW5nKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpk aWRGaW5pc2hMb2FkRm9yRnJhbWUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHku aDoKKwogMjAxNi0wMy0yMyAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5j b20+CiAKICAgICAgICAgVXNlIFJlZ2lvbiBpbnN0ZWFkIG9mIEludFJlY3QgaW4gUGFnZUNsaWVu dCBhbmQgV2ViUGFnZVByb3h5IHNldFZpZXdOZWVkc0Rpc3BsYXkgbWV0aG9kCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL0RvY3VtZW50TG9hZGVyLmNwcAppbmRleCBmMzgzM2M2ODNiZjg5NWVmMGIwNWU3 NDc0Yjg3YjY2YTk5NmQ1MzAzLi43NWI4OGJiMDVjOTNjYzcxYzNlZGUwMTYxMDRmZDFmNGU2ZDgx MDA1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudExvYWRlci5jcHAKQEAgLTE1MTEs NiArMTUxMSwxMSBAQCB2b2lkIERvY3VtZW50TG9hZGVyOjpzdGFydExvYWRpbmdNYWluUmVzb3Vy Y2UoKQogI2VuZGlmCiAKICAgICBpZiAoIW1fbWFpblJlc291cmNlKSB7CisgICAgICAgIGlmICgh bV9yZXF1ZXN0LnVybCgpLmlzVmFsaWQoKSkgeworICAgICAgICAgICAgY2FuY2VsTWFpblJlc291 cmNlTG9hZChmcmFtZUxvYWRlcigpLT5jbGllbnQoKS5jYW5ub3RTaG93VVJMRXJyb3IobV9yZXF1 ZXN0KSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKwogICAgICAgICBzZXRSZXF1 ZXN0KFJlc291cmNlUmVxdWVzdCgpKTsKICAgICAgICAgLy8gSWYgdGhlIGxvYWQgd2FzIGFib3J0 ZWQgYnkgY2xlYXJpbmcgbV9yZXF1ZXN0LCBpdCdzIHBvc3NpYmxlIHRoZSBBcHBsaWNhdGlvbkNh Y2hlSG9zdAogICAgICAgICAvLyBpcyBub3cgaW4gYSBzdGF0ZSB3aGVyZSBzdGFydGluZyBhbiBl bXB0eSBsb2FkIHdpbGwgYmUgaW5jb25zaXN0ZW50LiBSZXBsYWNlIGl0IHdpdGgKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggZThjMDc2MmYyOTU1NmU2OTk0 MTkyMWM5MTBlYzBjZjc5YTcyZjkzYy4uZTMwNGY5ZWQxNDIyYmNhYmRmOGVlNzE3MTA4YjE5NGVl ODczOTQxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKQEAg LTEwMDAsOSArMTAwMCwxNyBAQCBSZWZQdHI8QVBJOjpOYXZpZ2F0aW9uPiBXZWJQYWdlUHJveHk6 OmxvYWRIVE1MU3RyaW5nKGNvbnN0IFN0cmluZyYgaHRtbFN0cmluZywgYwogCiB2b2lkIFdlYlBh Z2VQcm94eTo6bG9hZEFsdGVybmF0ZUhUTUxTdHJpbmcoY29uc3QgU3RyaW5nJiBodG1sU3RyaW5n LCBjb25zdCBTdHJpbmcmIGJhc2VVUkwsIGNvbnN0IFN0cmluZyYgdW5yZWFjaGFibGVVUkwsIEFQ STo6T2JqZWN0KiB1c2VyRGF0YSkKIHsKLSAgICBpZiAobV9pc0Nsb3NlZCkKKyAgICAvLyBXaGVu IFdlYlByb2Nlc3MgaXMgbG9hZGluZyBhbHRlcm5hdGl2ZSBIVE1MIHN0cmluZyBmb3IgYSBmYWls aW5nIHByb3Zpc2lvbmFsIGxvYWQsCisgICAgLy8gaXQgaXMgY29uZmlndXJlZCBub3QgdG8gc2Vu ZCBvdXQgYW55IGZhaWxpbmcgbWVzc2FnZXMgdG8gdGhlIFVJUHJvY2VzcywgaW5jbHVkaW5nIGNh bmNlbHMuCisgICAgLy8gVGhlcmVmb3JlLCBVSVByb2Nlc3Mgc2hvdWxkIG5vdCBzdGFydCBsb2Fk aW5nIHR3byBhbHRlcm5hdGl2ZSBIVE1MIHN0cmluZyBmb3IgZmFpbGluZworICAgIC8vIHByb3Zp c2lvbmFsIGxvYWRzIGJhY2sgdG8gYmFjayBhcyB0aGUgc2Vjb25kIG9uZSB3aWxsIG5vdCBjYW5j ZWwgdGhlIGZpcnN0IG9uZS4gT3RoZXJ3aXNlLAorICAgIC8vIHRoZSBwYWdlIGxvYWQgc3RhdGUg d2lsbCBub3QgdHJhbnNpdCBpbiBhIGRlc2lyZWQgb3JkZXIuCisgICAgaWYgKG1faXNDbG9zZWQg fHwgbV9pc0RlYWxpbmdGYWlsaW5nUHJvdmlzaW9uYWxMb2FkKQogICAgICAgICByZXR1cm47CiAK KyAgICBpZiAoIW1fZmFpbGluZ1Byb3Zpc2lvbmFsTG9hZFVSTC5pc0VtcHR5KCkpCisgICAgICAg IG1faXNEZWFsaW5nRmFpbGluZ1Byb3Zpc2lvbmFsTG9hZCA9IHRydWU7CisKICAgICBpZiAoIWlz VmFsaWQoKSkKICAgICAgICAgcmVhdHRhY2hUb1dlYlByb2Nlc3MoKTsKIApAQCAtMzEzMiw2ICsz MTQwLDggQEAgdm9pZCBXZWJQYWdlUHJveHk6OmRpZEZpbmlzaExvYWRGb3JGcmFtZSh1aW50NjRf dCBmcmFtZUlELCB1aW50NjRfdCBuYXZpZ2F0aW9uSUQKIAogICAgIGlmIChpc01haW5GcmFtZSkK ICAgICAgICAgbV9wYWdlQ2xpZW50LmRpZEZpbmlzaExvYWRGb3JNYWluRnJhbWUoKTsKKworICAg IG1faXNEZWFsaW5nRmFpbGluZ1Byb3Zpc2lvbmFsTG9hZCA9IGZhbHNlOwogfQogCiB2b2lkIFdl YlBhZ2VQcm94eTo6ZGlkRmFpbExvYWRGb3JGcmFtZSh1aW50NjRfdCBmcmFtZUlELCB1aW50NjRf dCBuYXZpZ2F0aW9uSUQsIGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9yLCBjb25zdCBVc2VyRGF0 YSYgdXNlckRhdGEpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXgg NDE0ZWJlZDBiZTA4YTdiMmQzYTlhZWRlNmM3MzkxMDEyNThhNDQ1ZC4uOGRkODFiNWRjM2Y1ZWEw OTkwZTA0MzYxYzVkNzNlNzliZjc5MjNkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuaApAQCAtMTUxMSw2ICsxNTExLDcgQEAgcHJpdmF0ZToKIAogICAgIHN0ZDo6dW5p cXVlX3B0cjxXZWJOYXZpZ2F0aW9uU3RhdGU+IG1fbmF2aWdhdGlvblN0YXRlOwogICAgIFN0cmlu ZyBtX2ZhaWxpbmdQcm92aXNpb25hbExvYWRVUkw7CisgICAgYm9vbCBtX2lzRGVhbGluZ0ZhaWxp bmdQcm92aXNpb25hbExvYWQ7CiAKICAgICBzdGQ6OnVuaXF1ZV9wdHI8RHJhd2luZ0FyZWFQcm94 eT4gbV9kcmF3aW5nQXJlYTsKICNpZiBFTkFCTEUoQVNZTkNfU0NST0xMSU5HKQpkaWZmIC0tZ2l0 IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGVjMjM1OGU5NmE2NDhk MzkzYTU3YmM3ZmI1ZGEzNTUwMDVjNDllOTYuLjE3M2M0ZDJiY2Q2ZjAwZjlmNTE3ZWI4ZThkMjMz MTNjMTMzNjE5NWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxNi0wMy0zMCAgSmlld2VuIFRhbiAgPGppZXdlbl90 YW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYktpdCBzaG91bGQgZGlzcGF0Y2hEaWRGYWlsUHJv dmlzaW9uYWxMb2FkIHdoaWxlIGxvYWRpbmcgaW52YWxpZCBVUkxzCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTU5OTUKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzE0OTY3MDA0PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9h ZEFsdGVybmF0ZUhUTUxTdHJpbmcubW06CisgICAgICAgIChsaXRlcmFsQXNEYXRhKToKKyAgICAg ICAgKGxpdGVyYWxVUkwpOgorICAgICAgICAoLVtMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ0Zyb21Q cm92aXNpb25hbExvYWRFcnJvckNvbnRyb2xsZXIgd2ViVmlldzpkaWRGYWlsUHJvdmlzaW9uYWxO YXZpZ2F0aW9uOndpdGhFcnJvcjpdKToKKyAgICAgICAgKC1bTG9hZEFsdGVybmF0ZUhUTUxTdHJp bmdGcm9tUHJvdmlzaW9uYWxMb2FkRXJyb3JDb250cm9sbGVyIHdlYlZpZXc6ZGlkU3RhcnRQcm92 aXNpb25hbE5hdmlnYXRpb246XSk6CisgICAgICAgIChURVNUKToKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkSW52YWxpZFVSTFJlcXVlc3QubW06IEFkZGVk LgorICAgICAgICAobGl0ZXJhbEFzRGF0YSk6CisgICAgICAgIChsaXRlcmFsVVJMKToKKyAgICAg ICAgKC1bTG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVsZWdhdGUgd2ViVmlldzpkaWRG YWlsUHJvdmlzaW9uYWxOYXZpZ2F0aW9uOndpdGhFcnJvcjpdKToKKyAgICAgICAgKC1bTG9hZElu dmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVsZWdhdGUgd2ViVmlldzpkaWRDb21taXROYXZpZ2F0 aW9uOl0pOgorICAgICAgICAoLVtMb2FkSW52YWxpZFVSTFdlYkZyYW1lTG9hZERlbGVnYXRlIHdl YlZpZXc6ZGlkQ29tbWl0TG9hZEZvckZyYW1lOl0pOgorICAgICAgICAoLVtMb2FkSW52YWxpZFVS TFdlYkZyYW1lTG9hZERlbGVnYXRlIHdlYlZpZXc6ZGlkRmFpbFByb3Zpc2lvbmFsTG9hZFdpdGhF cnJvcjpmb3JGcmFtZTpdKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE2 LTAzLTIyICBLZWl0aCBSb2xsaW4gIDxrcm9sbGluQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJl dmlld2VkOiBhZGQgS2VpdGggUm9sbGluIHRvIHRoZSBjb21taXR0ZXJzIGxpc3QuCmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCmluZGV4IDZjODUyYzhiZWI1ZDRkZTZlZTc5Y2I3MGIzMjM5OGVkZjI5Y2Ey MjUuLjliMTYwNWEwM2E0MzRhNjBiNGEzY2ZhYjBlY2UyMDQ2ODU2MTMwOGQgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCkBAIC04Nyw2ICs4Nyw3IEBACiAJCTUyQjhDRjk4MTU4NjhEOTEwMDI4MTA1 MyAvKiBTZXREb2N1bWVudFVSSS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUyQjhDRjk0MTU4NjhDRjAwMDI4MTA1MyAvKiBTZXREb2N1 bWVudFVSSS5odG1sICovOyB9OwogCQk1MkQ2NzNFRTFBRkIxMjczMDBGQTE5RkUgLyogV0tQYWdl Q29weVNlc3Npb25TdGF0ZVdpdGhGaWx0ZXJpbmcuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTJENjczRUMxQUZCMTI2ODAwRkExOUZFIC8qIFdLUGFn ZUNvcHlTZXNzaW9uU3RhdGVXaXRoRmlsdGVyaW5nLmNwcCAqLzsgfTsKIAkJNTJFNUNFNDkxNEQy MUVBQjAwM0IyQkQ4IC8qIFBhcmVudEZyYW1lX0J1bmRsZS5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1MkU1Q0U0ODE0RDIxRUFCMDAzQjJCRDggLyog UGFyZW50RnJhbWVfQnVuZGxlLmNwcCAqLzsgfTsKKwkJNTc4NkM4NTMxQ0FCMkQ3MzAwQ0IzNkRC IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDU3ODZDODUyMUNBQjJENzMwMENCMzZEQiAvKiBMb2FkSW52YWxp ZFVSTFJlcXVlc3QubW0gKi87IH07CiAJCTU3RjEwRDkzMUM3RTdCMzgwMEVDREYzMCAvKiBJc05h dmlnYXRpb25BY3Rpb25UcnVzdGVkLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNTdGMTBEOTIxQzdFN0IzODAwRUNERjMwIC8qIElzTmF2aWdhdGlvbkFj dGlvblRydXN0ZWQubW0gKi87IH07CiAJCTU3RjU2QTVDMUM3RjhDQzEwMEYzMUQ3RSAvKiBJc05h dmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2 aWdhdGlvbkFjdGlvblRydXN0ZWQuaHRtbCAqLzsgfTsKIAkJNzY0MzIyRDcxQjYxQ0NDMzAwMjRG ODAxIC8qIFdvcmRCb3VuZGFyeVR5cGluZ0F0dHJpYnV0ZXMubW0gaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjQzMjJENTFCNjFDQ0E0MDAyNEY4MDEgLyog V29yZEJvdW5kYXJ5VHlwaW5nQXR0cmlidXRlcy5tbSAqLzsgfTsKQEAgLTY0NSw2ICs2NDYsNyBA QAogCQk1MkQ2NzNFQzFBRkIxMjY4MDBGQTE5RkUgLyogV0tQYWdlQ29weVNlc3Npb25TdGF0ZVdp dGhGaWx0ZXJpbmcuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV0tQ YWdlQ29weVNlc3Npb25TdGF0ZVdpdGhGaWx0ZXJpbmcuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQk1MkU1Q0U0NTE0RDIxRTlEMDAzQjJCRDggLyogUGFyZW50RnJhbWUuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGFyZW50RnJhbWUuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MkU1Q0U0ODE0RDIxRUFCMDAzQjJCRDggLyogUGFy ZW50RnJhbWVfQnVuZGxlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFBhcmVudEZyYW1lX0J1bmRsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU3 ODZDODUyMUNBQjJENzMwMENCMzZEQiAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBMb2FkSW52YWxpZFVSTFJlcXVlc3Qu bW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTU3RjEwRDkyMUM3RTdCMzgwMEVDREYz MCAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAub2JqY3BwOyBwYXRoID0gSXNOYXZpZ2F0aW9uQWN0aW9uVHJ1c3RlZC5tbTsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTdGNTZBNUIxQzdGOEE0MDAwRjMxRDdFIC8qIElzTmF2aWdh dGlvbkFjdGlvblRydXN0ZWQuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IElzTmF2 aWdhdGlvbkFjdGlvblRydXN0ZWQuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NzU2MDkxNzcxOTI1OUM1OTAwOUVGMDZFIC8qIE1lbW9yeUNhY2hlQWRkSW1hZ2VUb0NhY2hlSU9T Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gTWVtb3J5Q2FjaGVB ZGRJbWFnZVRvQ2FjaGVJT1MubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMDEz LDYgKzEwMTUsNyBAQAogCQkJCTUxQkNFRTQ5MUM4NEY0QUYwMDQyQzgyRSAvKiBJbmRleGVkREJN dWx0aVByb2Nlc3MubW0gKi8sCiAJCQkJNTFCMUVFOEQxQzgwRjU4ODAwNjRGQjk4IC8qIEluZGV4 ZWREQlBlcnNpc3RlbmNlLm1tICovLAogCQkJCTM3RDM2RUQ2MUFGNDJFQ0QwMEJBRjVEOSAvKiBM b2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbSAqLywKKwkJCQk1Nzg2Qzg1MjFDQUIyRDczMDBDQjM2 REIgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tICovLAogCQkJCTUxQ0QxQzZBMUIzOENFMzYw MDE0MkNBNSAvKiBNb2RhbEFsZXJ0cy5tbSAqLywKIAkJCQkxQUJDM0RFRDE4OTlCRTZEMDA0RjA2 MjYgLyogTmF2aWdhdGlvbi5tbSAqLywKIAkJCQlBMURGNzQzMDFDNDFCNjU4MDBBMkY0RDAgLyog QWx3YXlzUmV2YWxpZGF0ZWRVUkxTY2hlbWVzLm1tICovLApAQCAtMTkyOSw2ICsxOTMyLDcgQEAK IAkJCWJ1aWxkQWN0aW9uTWFzayA9IDIxNDc0ODM2NDc7CiAJCQlmaWxlcyA9ICgKIAkJCQkyRDlB NTNBRjFCMzFGQThEMDA3NEQ1QUEgLyogU2hyaW5rVG9GaXQubW0gaW4gU291cmNlcyAqLywKKwkJ CQk1Nzg2Qzg1MzFDQUIyRDczMDBDQjM2REIgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tIGlu IFNvdXJjZXMgKi8sCiAJCQkJNTFCNDU0RUMxQjRFMjM2QjAwODVFQUE2IC8qIFdlYlZpZXdDbG9z ZUluc2lkZURpZEZpbmlzaExvYWRGb3JGcmFtZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCTdBQTAy MUJCMUFCMDlFQTcwMDUyOTUzRiAvKiBEYXRlTWF0aC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlD RTUwRDhDQTFDODY2NUNFMDA3MkVBNUEgLyogT3B0aW9uU2V0LmNwcCBpbiBTb3VyY2VzICovLApk aWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9hZEFs dGVybmF0ZUhUTUxTdHJpbmcubW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJD b2NvYS9Mb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbQppbmRleCAwOWI4ZTljN2QyMmFmYzhmYmE5 YjMwZTQ5Y2Q3YjFlZjlhMjUyNDRmLi5jYjk5Y2M5NzgwY2FiMjU5ZTExODhjYTNkMTdjMGU3Yzc2 NzE3MmQxIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJDb2Nv YS9Mb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdDJDb2NvYS9Mb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbQpAQCAtMzAsMTAgKzMw LDIyIEBACiAKICNpbXBvcnQgIlBsYXRmb3JtVXRpbGl0aWVzLmgiCiAjaW1wb3J0ICJUZXN0Lmgi CisjaW1wb3J0IDxXZWJDb3JlL1dlYkNvcmVOU1VSTEV4dHJhcy5oPgogI2ltcG9ydCA8V2ViS2l0 L1dLV2ViVmlld1ByaXZhdGUuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KIAogc3RhdGlj IGJvb2wgaXNEb25lOworc3RhdGljIGludCBwcm92aXNpb25hbExvYWRDb3VudCA9IDA7CisKK3N0 YXRpYyBOU0RhdGEgKmxpdGVyYWxBc0RhdGEoY29uc3QgY2hhciogbGl0ZXJhbCkKK3sKKyAgICBy ZXR1cm4gW05TRGF0YSBkYXRhV2l0aEJ5dGVzOmxpdGVyYWwgbGVuZ3RoOnN0cmxlbihsaXRlcmFs KV07Cit9CisKK3N0YXRpYyBOU1VSTCAqbGl0ZXJhbFVSTChjb25zdCBjaGFyKiBsaXRlcmFsKQor eworICAgIHJldHVybiBXZWJDb3JlOjpVUkxXaXRoRGF0YShsaXRlcmFsQXNEYXRhKGxpdGVyYWwp LCBuaWwpOworfQogCiBAaW50ZXJmYWNlIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5nRnJvbVByb3Zp c2lvbmFsTG9hZEVycm9yQ29udHJvbGxlciA6IE5TT2JqZWN0IDxXS05hdmlnYXRpb25EZWxlZ2F0 ZT4KIEBlbmQKQEAgLTQyLDcgKzU0LDggQEAgQGltcGxlbWVudGF0aW9uIExvYWRBbHRlcm5hdGVI VE1MU3RyaW5nRnJvbVByb3Zpc2lvbmFsTG9hZEVycm9yQ29udHJvbGxlcgogCiAtICh2b2lkKXdl YlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkRmFpbFByb3Zpc2lvbmFsTmF2aWdhdGlvbjoo V0tOYXZpZ2F0aW9uICopbmF2aWdhdGlvbiB3aXRoRXJyb3I6KE5TRXJyb3IgKillcnJvcgogewot ICAgIFt3ZWJWaWV3IF9sb2FkQWx0ZXJuYXRlSFRNTFN0cmluZzpAImVycm9yIHBhZ2UiIGJhc2VV Ukw6bmlsIGZvclVucmVhY2hhYmxlVVJMOltOU1VSTCBVUkxXaXRoU3RyaW5nOkAiZGF0YToiXV07 CisgICAgaWYgKGVycm9yLmNvZGUgIT0gTlNVUkxFcnJvckNhbmNlbGxlZCkKKyAgICAgICAgW3dl YlZpZXcgX2xvYWRBbHRlcm5hdGVIVE1MU3RyaW5nOkAiZXJyb3IgcGFnZSIgYmFzZVVSTDpuaWwg Zm9yVW5yZWFjaGFibGVVUkw6W05TVVJMIFVSTFdpdGhTdHJpbmc6QCJkYXRhOiJdXTsKIH0KIAog LSAodm9pZCl3ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IGRpZEZpbmlzaE5hdmlnYXRpb246 KFdLTmF2aWdhdGlvbiAqKW5hdmlnYXRpb24KQEAgLTUwLDYgKzYzLDExIEBAIC0gKHZvaWQpd2Vi VmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBkaWRGaW5pc2hOYXZpZ2F0aW9uOihXS05hdmlnYXRp b24gKiluYXZpZ2F0CiAgICAgaXNEb25lID0gdHJ1ZTsKIH0KIAorLSAodm9pZCl3ZWJWaWV3OihX S1dlYlZpZXcgKil3ZWJWaWV3IGRpZFN0YXJ0UHJvdmlzaW9uYWxOYXZpZ2F0aW9uOihudWxsX3Vu c3BlY2lmaWVkIFdLTmF2aWdhdGlvbiAqKW5hdmlnYXRpb24KK3sKKyAgICBwcm92aXNpb25hbExv YWRDb3VudCsrOworfQorCiBAZW5kCiAKIHN0YXRpYyBOU1N0cmluZyAqdW5sb2FkYWJsZVVSTCA9 IEAiZGF0YToiOwpAQCAtOTMsNCArMTExLDIxIEBAIFRFU1QoV0tXZWJWaWV3LCBMb2FkQWx0ZXJu YXRlSFRNTFN0cmluZ0Zyb21Qcm92aXNpb25hbExvYWRFcnJvcikKICAgICBFWFBFQ1RfU1RSRVEo W1tsaXN0LmN1cnJlbnRJdGVtIFVSTF0gYWJzb2x1dGVTdHJpbmddLlVURjhTdHJpbmcsIGxvYWRh YmxlVVJMLlVURjhTdHJpbmcpOwogfQogCitURVNUKFdLV2ViVmlldywgTG9hZEFsdGVybmF0ZUhU TUxTdHJpbmdGcm9tUHJvdmlzaW9uYWxMb2FkRXJyb3JCYWNrVG9CYWNrKQoreworICAgIEBhdXRv cmVsZWFzZXBvb2wgeworICAgICAgICBSZXRhaW5QdHI8V0tXZWJWaWV3PiB3ZWJWaWV3ID0gYWRv cHROUyhbW1dLV2ViVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU01ha2VSZWN0KDAsIDAsIDgw MCwgNjAwKV0pOworCisgICAgICAgIFJldGFpblB0cjxMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ0Zy b21Qcm92aXNpb25hbExvYWRFcnJvckNvbnRyb2xsZXI+IGRlbGVnYXRlID0gYWRvcHROUyhbW0xv YWRBbHRlcm5hdGVIVE1MU3RyaW5nRnJvbVByb3Zpc2lvbmFsTG9hZEVycm9yQ29udHJvbGxlciBh bGxvY10gaW5pdF0pOworICAgICAgICBbd2ViVmlldyBzZXROYXZpZ2F0aW9uRGVsZWdhdGU6ZGVs ZWdhdGUuZ2V0KCldOworICAgICAgICBbd2ViVmlldyBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0 IHJlcXVlc3RXaXRoVVJMOmxpdGVyYWxVUkwoImh0dHBzOi8vd3d3LmV4YW1wbGUuY29tPD4vIild XTsKKyAgICAgICAgW3dlYlZpZXcgbG9hZFJlcXVlc3Q6W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0 aFVSTDpsaXRlcmFsVVJMKCJodHRwczovL3d3dy5leGFtcGxlLmNvbTw+LyIpXV07CisKKyAgICAg ICAgaXNEb25lID0gZmFsc2U7CisgICAgICAgIFRlc3RXZWJLaXRBUEk6OlV0aWw6OnJ1bigmaXNE b25lKTsKKyAgICAgICAgLy8gSW4gc3VjY2Vzcywgd2Ugc2hvdWxkIG9ubHkgc3RhcnQgMyBwcm92 aXNpb25hbCBsb2FkczogMiBmb3IgdGhlIGxvYWRSZXF1ZXN0LCBhbmQgKm9ubHkgMSogZm9yIHRo ZSBfbG9hZEFsdGVybmF0ZUhUTUxTdHJpbmcuCisgICAgICAgIEVYUEVDVF9FUSgzLCBwcm92aXNp b25hbExvYWRDb3VudCk7CisgICAgfQorfQorCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0MkNvY29hL0xvYWRJbnZhbGlkVVJMUmVxdWVzdC5tbSBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0MkNvY29hL0xvYWRJbnZhbGlkVVJMUmVx dWVzdC5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4yYWVkZWRjOTIzOTlkZjcxN2UxM2UwNzViYWZjOTIwZjJiZmNh ZjkxCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy Q29jb2EvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tCkBAIC0wLDAgKzEsMTI5IEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDE2IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YK KyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up CisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW1wb3J0ICJQbGF0Zm9ybVV0aWxpdGllcy5o IgorI2ltcG9ydCA8V2ViQ29yZS9XZWJDb3JlTlNVUkxFeHRyYXMuaD4KKyNpbXBvcnQgPFdlYktp dC9XS05hdmlnYXRpb25Qcml2YXRlLmg+CisjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3Lmg+Cisj aW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisKK3N0YXRpYyBib29sIGRpZEZpbmlzaFRlc3Q7Citz dGF0aWMgYm9vbCBkaWRGYWlsUHJvdmlzaW9uYWxMb2FkOworCitzdGF0aWMgTlNEYXRhICpsaXRl cmFsQXNEYXRhKGNvbnN0IGNoYXIqIGxpdGVyYWwpCit7CisgICAgcmV0dXJuIFtOU0RhdGEgZGF0 YVdpdGhCeXRlczpsaXRlcmFsIGxlbmd0aDpzdHJsZW4obGl0ZXJhbCldOworfQorCitzdGF0aWMg TlNVUkwgKmxpdGVyYWxVUkwoY29uc3QgY2hhciogbGl0ZXJhbCkKK3sKKyAgICByZXR1cm4gV2Vi Q29yZTo6VVJMV2l0aERhdGEobGl0ZXJhbEFzRGF0YShsaXRlcmFsKSwgbmlsKTsKK30KKworI2lm IFdLX0FQSV9FTkFCTEVECisKK0BpbnRlcmZhY2UgTG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0 aW9uRGVsZWdhdGUgOiBOU09iamVjdCA8V0tOYXZpZ2F0aW9uRGVsZWdhdGU+CitAZW5kCisKK0Bp bXBsZW1lbnRhdGlvbiBMb2FkSW52YWxpZFVSTE5hdmlnYXRpb25BY3Rpb25EZWxlZ2F0ZQorCist ICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkQ29tbWl0TmF2aWdhdGlvbjoo V0tOYXZpZ2F0aW9uICopbmF2aWdhdGlvbgoreworICAgIGRpZEZpbmlzaFRlc3QgPSB0cnVlOwor fQorCistICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkRmFpbFByb3Zpc2lv bmFsTmF2aWdhdGlvbjooV0tOYXZpZ2F0aW9uICopbmF2aWdhdGlvbiB3aXRoRXJyb3I6KE5TRXJy b3IgKillcnJvcgoreworICAgIGRpZEZhaWxQcm92aXNpb25hbExvYWQgPSB0cnVlOworICAgIGRp ZEZpbmlzaFRlc3QgPSB0cnVlOworfQorCitAZW5kCisKKyNlbmRpZgorCitAaW50ZXJmYWNlIExv YWRJbnZhbGlkVVJMV2ViRnJhbWVMb2FkRGVsZWdhdGUgOiBOU09iamVjdCA8V2ViRnJhbWVMb2Fk RGVsZWdhdGU+IHsKK30KK0BlbmQKKworQGltcGxlbWVudGF0aW9uIExvYWRJbnZhbGlkVVJMV2Vi RnJhbWVMb2FkRGVsZWdhdGUKKworLSAodm9pZCl3ZWJWaWV3OihXZWJWaWV3ICopc2VuZGVyIGRp ZENvbW1pdExvYWRGb3JGcmFtZTooV2ViRnJhbWUgKilmcmFtZQoreworICAgIGRpZEZpbmlzaFRl c3QgPSB0cnVlOworfQorCistICh2b2lkKXdlYlZpZXc6KFdlYlZpZXcgKilzZW5kZXIgZGlkRmFp bFByb3Zpc2lvbmFsTG9hZFdpdGhFcnJvcjooTlNFcnJvciAqKWVycm9yIGZvckZyYW1lOihXZWJG cmFtZSAqKWZyYW1lCit7CisgICAgZGlkRmFpbFByb3Zpc2lvbmFsTG9hZCA9IHRydWU7CisgICAg ZGlkRmluaXNoVGVzdCA9IHRydWU7Cit9CisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRB UEkgeworCisjaWYgV0tfQVBJX0VOQUJMRUQKKworVEVTVChXZWJLaXQyLCBMb2FkSW52YWxpZFVS TFJlcXVlc3QpCit7CisgICAgQGF1dG9yZWxlYXNlcG9vbCB7CisgICAgICAgIFJldGFpblB0cjxX S1dlYlZpZXc+IHdlYlZpZXcgPSBhZG9wdE5TKFtbV0tXZWJWaWV3IGFsbG9jXSBpbml0V2l0aEZy YW1lOk5TTWFrZVJlY3QoMCwgMCwgODAwLCA2MDApXSk7CisKKyAgICAgICAgUmV0YWluUHRyPExv YWRJbnZhbGlkVVJMTmF2aWdhdGlvbkFjdGlvbkRlbGVnYXRlPiBkZWxlZ2F0ZSA9IGFkb3B0TlMo W1tMb2FkSW52YWxpZFVSTE5hdmlnYXRpb25BY3Rpb25EZWxlZ2F0ZSBhbGxvY10gaW5pdF0pOwor ICAgICAgICBbd2ViVmlldyBzZXROYXZpZ2F0aW9uRGVsZWdhdGU6ZGVsZWdhdGUuZ2V0KCldOwor ICAgICAgICBbd2ViVmlldyBsb2FkUmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJM OmxpdGVyYWxVUkwoImh0dHBzOi8vd3d3LmV4YW1wbGUuY29tPD4vIildXTsKKworICAgICAgICBk aWRGaW5pc2hUZXN0ID0gZmFsc2U7CisgICAgICAgIGRpZEZhaWxQcm92aXNpb25hbExvYWQgPSBm YWxzZTsKKyAgICAgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKKworICAgICAgICBFWFBF Q1RfVFJVRShkaWRGYWlsUHJvdmlzaW9uYWxMb2FkKTsKKyAgICB9Cit9CisKKyNlbmRpZgorCitU RVNUKFdlYktpdDEsIExvYWRJbnZhbGlkVVJMUmVxdWVzdCkKK3sKKyAgICBAYXV0b3JlbGVhc2Vw b29sIHsKKyAgICAgICAgUmV0YWluUHRyPFdlYlZpZXc+IHdlYlZpZXcgPSBhZG9wdE5TKFtbV2Vi VmlldyBhbGxvY10gaW5pdF0pOworCisgICAgICAgIFJldGFpblB0cjxMb2FkSW52YWxpZFVSTFdl YkZyYW1lTG9hZERlbGVnYXRlPiBkZWxlZ2F0ZSA9IGFkb3B0TlMoW1tMb2FkSW52YWxpZFVSTFdl YkZyYW1lTG9hZERlbGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgICAgIFt3ZWJWaWV3IHNldEZy YW1lTG9hZERlbGVnYXRlOmRlbGVnYXRlLmdldCgpXTsKKyAgICAgICAgW1t3ZWJWaWV3IG1haW5G cmFtZV0gbG9hZFJlcXVlc3Q6W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDpsaXRlcmFsVVJM KCJodHRwczovL3d3dy5leGFtcGxlLmNvbTw+LyIpXV07CisKKyAgICAgICAgZGlkRmluaXNoVGVz dCA9IGZhbHNlOworICAgICAgICBkaWRGYWlsUHJvdmlzaW9uYWxMb2FkID0gZmFsc2U7CisgICAg ICAgIFV0aWw6OnJ1bigmZGlkRmluaXNoVGVzdCk7CisKKyAgICAgICAgRVhQRUNUX1RSVUUoZGlk RmFpbFByb3Zpc2lvbmFsTG9hZCk7CisgICAgfQorfQorICAgIAorfSAvLyBuYW1lc3BhY2UgVGVz dFdlYktpdEFQSQorCg== 275426 2016-04-01 13:51:33 -0700 2016-04-01 14:40:16 -0700 Patch for landing bug-155995-20160401135138.patch text/plain 24536 jiewen_tan U3VidmVyc2lvbiBSZXZpc2lvbjogMTk4OTMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjgzY2Y2MDRmMDU5YzRj MDVkNzJmMzZhNjc3MTZhYzBlZDg4NDIwNC4uMjI4N2U4NzQ4MzJhYmFiZTgxYzBjMjdiNDA2ODhh Y2ZkMjAyOWIzMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE2LTA0LTAxICBKaWV3 ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0IHNob3VsZCBk aXNwYXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQgd2hpbGUgbG9hZGluZyBpbnZhbGlkIFVSTHMK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTk5NQor ICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTQ5NjcwMDQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg QW5keSBFc3Rlcy4KKworICAgICAgICBBZGRlZCBBUEkgVGVzdHMuCisKKyAgICAgICAgSWYgYSBs b2FkaW5nIHJlcXVlc3QgY29udGFpbnMgYW4gaW52YWxpZCBVUkwsIERvY3VtZW50TG9hZGVyIHdp bGwgbm93IGRpc3BhdGNoCisgICAgICAgIGNhbm5vdFNob3dVUkxFcnJvciB0byB0aGUgY2xpZW50 cy4KKworICAgICAgICAqIGxvYWRlci9Eb2N1bWVudExvYWRlci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEb2N1bWVudExvYWRlcjo6c3RhcnRMb2FkaW5nTWFpblJlc291cmNlKToKKwogMjAxNi0w My0zMSAgU2FhbSBiYXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZlcnQg cmV3cml0ZSBjb25zdCBhcyB2YXIgd29ya2Fyb3VuZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDA2MDNlMGE2ODE0 NmMyMTM3NGY2ZDU3M2MyOTBmY2ZiYTEwYTNkOWEuLmFiNTI0YWY2MTEwNDYwODgyMDg1ZjMxM2Qy ZjAzZDk0Zjg0MjdhZGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAxNi0wNC0wMSAg Smlld2VuIFRhbiAgPGppZXdlbl90YW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYktpdCBzaG91 bGQgZGlzcGF0Y2hEaWRGYWlsUHJvdmlzaW9uYWxMb2FkIHdoaWxlIGxvYWRpbmcgaW52YWxpZCBV UkxzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTU5 OTUKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzE0OTY3MDA0PgorCisgICAgICAgIFJldmlld2Vk IGJ5IEFuZHkgRXN0ZXMuCisKKyAgICAgICAgRW5zdXJlIHRoYXQgYWx0ZXJuYXRpdmUgSFRNTCBz dHJpbmcgd2lsbCBub3QgYmUgbG9hZGVkIGJhY2sgdG8gYmFjayBmb3IKKyAgICAgICAgZmFpbGlu ZyBwcm92aXNpb25hbCBsb2Fkcy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHku Y3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmxvYWRBbHRlcm5hdGVIVE1MU3Ry aW5nKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpkaWRGaW5pc2hMb2FkRm9yRnJh bWUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaDoKKwogMjAxNi0wMy0zMSAg U2FhbSBiYXJhdGkgIDxzYmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZlcnQgcmV3cml0 ZSBjb25zdCBhcyB2YXIgd29ya2Fyb3VuZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9h ZGVyL0RvY3VtZW50TG9hZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9Eb2N1bWVudExv YWRlci5jcHAKaW5kZXggZjM4MzNjNjgzYmY4OTVlZjBiMDVlNzQ3NGI4N2I2NmE5OTZkNTMwMy4u NzViODhiYjA1YzkzY2M3MWMzZWRlMDE2MTA0ZmQxZjRlNmQ4MTAwNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50TG9hZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRG9jdW1lbnRMb2FkZXIuY3BwCkBAIC0xNTExLDYgKzE1MTEsMTEgQEAgdm9pZCBE b2N1bWVudExvYWRlcjo6c3RhcnRMb2FkaW5nTWFpblJlc291cmNlKCkKICNlbmRpZgogCiAgICAg aWYgKCFtX21haW5SZXNvdXJjZSkgeworICAgICAgICBpZiAoIW1fcmVxdWVzdC51cmwoKS5pc1Zh bGlkKCkpIHsKKyAgICAgICAgICAgIGNhbmNlbE1haW5SZXNvdXJjZUxvYWQoZnJhbWVMb2FkZXIo KS0+Y2xpZW50KCkuY2Fubm90U2hvd1VSTEVycm9yKG1fcmVxdWVzdCkpOworICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB9CisKICAgICAgICAgc2V0UmVxdWVzdChSZXNvdXJjZVJlcXVlc3Qo KSk7CiAgICAgICAgIC8vIElmIHRoZSBsb2FkIHdhcyBhYm9ydGVkIGJ5IGNsZWFyaW5nIG1fcmVx dWVzdCwgaXQncyBwb3NzaWJsZSB0aGUgQXBwbGljYXRpb25DYWNoZUhvc3QKICAgICAgICAgLy8g aXMgbm93IGluIGEgc3RhdGUgd2hlcmUgc3RhcnRpbmcgYW4gZW1wdHkgbG9hZCB3aWxsIGJlIGlu Y29uc2lzdGVudC4gUmVwbGFjZSBpdCB3aXRoCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVy LmNwcAppbmRleCA3ZTBkMTU0YTBjOTBjZTQ5YWVlNmJjMTE0Mzk2ZWRhMTBjN2Y2YTc5Li5lZmE4 MTNjYjVjODg5YzRhMGU3ZDUxNjc4OWJmZDk5Y2JkOTdhODIyIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9GcmFtZUxvYWRlci5jcHAKQEAgLTIyMDYsNiArMjIwNiwxMCBAQCB2b2lkIEZyYW1lTG9hZGVy OjpjaGVja0xvYWRDb21wbGV0ZUZvclRoaXNGcmFtZSgpCiAKICAgICBzd2l0Y2ggKG1fc3RhdGUp IHsKICAgICAgICAgY2FzZSBGcmFtZVN0YXRlUHJvdmlzaW9uYWw6IHsKKyAgICAgICAgICAgIC8v IEZJWE1FOiBQcm9oaWJpdGluZyBhbnkgcHJvdmlzaW9uYWwgbG9hZCBmYWlsdXJlcyBmcm9tIGJl aW5nIHNlbnQgdG8gY2xpZW50cworICAgICAgICAgICAgLy8gd2hpbGUgaGFuZGxpbmcgcHJvdmlz aW9uYWwgbG9hZCBmYWlsdXJlcyBpcyB0b28gaGVhdnkuIEZvciBleGFtcGxlLCB0aGUgY3VycmVu dAorICAgICAgICAgICAgLy8gbG9hZCB3aWxsIGZhaWwgdG8gY2FuY2VsIGFub3RoZXIgb25nb2lu ZyBsb2FkLiBUaGF0IG1pZ2h0IHByZXZlbnQgY2xpZW50cycgcGFnZQorICAgICAgICAgICAgLy8g bG9hZCBzdGF0ZSBiZWluZyBoYW5kbGVkIHByb3Blcmx5LgogICAgICAgICAgICAgaWYgKCFtX3By b3Zpc2lvbmFsTG9hZEVycm9yQmVpbmdIYW5kbGVkVVJMLmlzRW1wdHkoKSkKICAgICAgICAgICAg ICAgICByZXR1cm47CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAK aW5kZXggNzE5YmE1NmYxYmQxMmNhM2ZiZjJkOGQ0NDk3NGY2MjVkODYxMWMxMy4uMWZiOTFhOWFk NWIyYjgxZGVjNTVmN2FiZGQ5YzY2MzRlOWM2N2YyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL1dlYlBhZ2VQcm94eS5jcHAKQEAgLTEwMDEsOSArMTAwMSwxNSBAQCBSZWZQdHI8QVBJOjpO YXZpZ2F0aW9uPiBXZWJQYWdlUHJveHk6OmxvYWRIVE1MU3RyaW5nKGNvbnN0IFN0cmluZyYgaHRt bFN0cmluZywgYwogCiB2b2lkIFdlYlBhZ2VQcm94eTo6bG9hZEFsdGVybmF0ZUhUTUxTdHJpbmco Y29uc3QgU3RyaW5nJiBodG1sU3RyaW5nLCBjb25zdCBTdHJpbmcmIGJhc2VVUkwsIGNvbnN0IFN0 cmluZyYgdW5yZWFjaGFibGVVUkwsIEFQSTo6T2JqZWN0KiB1c2VyRGF0YSkKIHsKLSAgICBpZiAo bV9pc0Nsb3NlZCkKKyAgICAvLyBXaGVuIHRoZSBVSVByb2Nlc3MgaXMgaW4gdGhlIHByb2Nlc3Mg b2YgaGFuZGxpbmcgYSBmYWlsaW5nIHByb3Zpc2lvbmFsIGxvYWQsIGRvIG5vdCBhdHRlbXB0IHRv CisgICAgLy8gc3RhcnQgYSBzZWNvbmQgYWx0ZXJuYXRpdmUgSFRNTCBsb2FkIGFzIHRoaXMgd2ls bCBwcmV2ZW50IHRoZSBwYWdlIGxvYWQgc3RhdGUgZnJvbSBiZWluZworICAgIC8vIGhhbmRsZWQg cHJvcGVybHkuCisgICAgaWYgKG1faXNDbG9zZWQgfHwgbV9pc0xvYWRpbmdBbHRlcm5hdGVIVE1M U3RyaW5nRm9yRmFpbGluZ1Byb3Zpc2lvbmFsTG9hZCkKICAgICAgICAgcmV0dXJuOwogCisgICAg aWYgKCFtX2ZhaWxpbmdQcm92aXNpb25hbExvYWRVUkwuaXNFbXB0eSgpKQorICAgICAgICBtX2lz TG9hZGluZ0FsdGVybmF0ZUhUTUxTdHJpbmdGb3JGYWlsaW5nUHJvdmlzaW9uYWxMb2FkID0gdHJ1 ZTsKKwogICAgIGlmICghaXNWYWxpZCgpKQogICAgICAgICByZWF0dGFjaFRvV2ViUHJvY2Vzcygp OwogCkBAIC0zMTQzLDYgKzMxNDksOCBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkRmluaXNoTG9h ZEZvckZyYW1lKHVpbnQ2NF90IGZyYW1lSUQsIHVpbnQ2NF90IG5hdmlnYXRpb25JRAogCiAgICAg aWYgKGlzTWFpbkZyYW1lKQogICAgICAgICBtX3BhZ2VDbGllbnQuZGlkRmluaXNoTG9hZEZvck1h aW5GcmFtZSgpOworCisgICAgbV9pc0xvYWRpbmdBbHRlcm5hdGVIVE1MU3RyaW5nRm9yRmFpbGlu Z1Byb3Zpc2lvbmFsTG9hZCA9IGZhbHNlOwogfQogCiB2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkRmFp bExvYWRGb3JGcmFtZSh1aW50NjRfdCBmcmFtZUlELCB1aW50NjRfdCBuYXZpZ2F0aW9uSUQsIGNv bnN0IFJlc291cmNlRXJyb3ImIGVycm9yLCBjb25zdCBVc2VyRGF0YSYgdXNlckRhdGEpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggMDliZWM4ZjRhYzEzMmZhYWZh MDQ2NGY5YTJlZGEwMTI5OGE3YzY3Ni4uMmM1YTVhMTg3ODA3OTI1ZTA3ODExNjQ4MTRkZTIzZjIw NWQzY2UyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtMTUx MSw2ICsxNTExLDcgQEAgcHJpdmF0ZToKIAogICAgIHN0ZDo6dW5pcXVlX3B0cjxXZWJOYXZpZ2F0 aW9uU3RhdGU+IG1fbmF2aWdhdGlvblN0YXRlOwogICAgIFN0cmluZyBtX2ZhaWxpbmdQcm92aXNp b25hbExvYWRVUkw7CisgICAgYm9vbCBtX2lzTG9hZGluZ0FsdGVybmF0ZUhUTUxTdHJpbmdGb3JG YWlsaW5nUHJvdmlzaW9uYWxMb2FkIHsgZmFsc2UgfTsKIAogICAgIHN0ZDo6dW5pcXVlX3B0cjxE cmF3aW5nQXJlYVByb3h5PiBtX2RyYXdpbmdBcmVhOwogI2lmIEVOQUJMRShBU1lOQ19TQ1JPTExJ TkcpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg MjU5YjU2Y2NlYzBiNTZkMTIxYzQxNjZjZTk3NGI1OTUwZGY5YjY3YS4uZGM4YTg2Njg5Yzg1ZWVl MGE2OWFjMTljNGJhM2VjYTg1OTk1YTIwNyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDE2LTA0LTAxICBKaWV3ZW4g VGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CisKKyAgICAgICAgV2ViS2l0IHNob3VsZCBkaXNw YXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQgd2hpbGUgbG9hZGluZyBpbnZhbGlkIFVSTHMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTk5NQorICAg ICAgICA8cmRhcjovL3Byb2JsZW0vMTQ5NjcwMDQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQW5k eSBFc3Rlcy4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 MkNvY29hL0xvYWRBbHRlcm5hdGVIVE1MU3RyaW5nLm1tOgorICAgICAgICAoLVtMb2FkQWx0ZXJu YXRlSFRNTFN0cmluZ0Zyb21Qcm92aXNpb25hbExvYWRFcnJvckNvbnRyb2xsZXIgd2ViVmlldzpk aWRGYWlsUHJvdmlzaW9uYWxOYXZpZ2F0aW9uOndpdGhFcnJvcjpdKToKKyAgICAgICAgKC1bTG9h ZEFsdGVybmF0ZUhUTUxTdHJpbmdGcm9tUHJvdmlzaW9uYWxMb2FkRXJyb3JDb250cm9sbGVyIHdl YlZpZXc6ZGlkU3RhcnRQcm92aXNpb25hbE5hdmlnYXRpb246XSk6CisgICAgICAgIChURVNUKToK KyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkSW52YWxpZFVS TFJlcXVlc3QubW06IEFkZGVkLgorICAgICAgICAobGl0ZXJhbFVSTCk6CisgICAgICAgICgtW0xv YWRJbnZhbGlkVVJMTmF2aWdhdGlvbkFjdGlvbkRlbGVnYXRlIHdlYlZpZXc6ZGlkQ29tbWl0TmF2 aWdhdGlvbjpdKToKKyAgICAgICAgKC1bTG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVs ZWdhdGUgd2ViVmlldzpkaWRGYWlsUHJvdmlzaW9uYWxOYXZpZ2F0aW9uOndpdGhFcnJvcjpdKToK KyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvbWFjL0xvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1Rlc3RzL21hYy9Mb2FkSW52YWxpZFVSTFJlcXVlc3QubW06IEFkZGVkLgor ICAgICAgICAoLVtMb2FkSW52YWxpZFVSTFdlYkZyYW1lTG9hZERlbGVnYXRlIHdlYlZpZXc6ZGlk Q29tbWl0TG9hZEZvckZyYW1lOl0pOgorICAgICAgICAoLVtMb2FkSW52YWxpZFVSTFdlYkZyYW1l TG9hZERlbGVnYXRlIHdlYlZpZXc6ZGlkRmFpbFByb3Zpc2lvbmFsTG9hZFdpdGhFcnJvcjpmb3JG cmFtZTpdKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE2LTAzLTMxICBE YW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAgICBydW4td2Via2l0LXRl c3RzIGZhaWxzIHRvIGNyZWF0ZSB1c2VyJ3MgY2FjaGUgZGlyZWN0b3J5IHdoZW4gU3lzdGVtIElu dGVncml0eSBQcm90ZWN0aW9uIGlzIGVuYWJsZWQKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg MWFmNjU5YzE3NGU1YjQyODJmYzEzZjY5MTFjYWJmMDYwNWRlOTU1Zi4uNDZlN2Q3NTQzNDFjOWFh MzFmM2FjNGU1YzllNzdkYTY0MDc0ZWQxYyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTkx LDYgKzkxLDkgQEAKIAkJNTcxNEVDQjkxQ0E4QjVCMDAwMDUxQUM4IC8qIERvd25sb2FkUmVxdWVz dE9yaWdpbmFsVVJMLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNTcxNEVDQjgxQ0E4QjU4ODAwMDUxQUM4IC8qIERvd25sb2FkUmVxdWVz dE9yaWdpbmFsVVJMLmh0bWwgKi87IH07CiAJCTU3MTRFQ0JCMUNBOEJGRTQwMDA1MUFDOCAvKiBE b3dubG9hZFJlcXVlc3RPcmlnaW5hbFVSTEZyYW1lLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTcxNEVDQkExQ0E4QkZEMTAwMDUxQUM4 IC8qIERvd25sb2FkUmVxdWVzdE9yaWdpbmFsVVJMRnJhbWUuaHRtbCAqLzsgfTsKIAkJNTcxNEVD QkQxQ0E4QzIyQTAwMDUxQUM4IC8qIERvd25sb2FkUmVxdWVzdE9yaWdpbmFsVVJMMi5odG1sIGlu IENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3MTRF Q0JDMUNBOEMyMTgwMDA1MUFDOCAvKiBEb3dubG9hZFJlcXVlc3RPcmlnaW5hbFVSTDIuaHRtbCAq LzsgfTsKKwkJNTc5MDFGQUQxQ0FGMTJDMjAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVz dC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3OTAx RkFDMUNBRjEyQzIwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gKi87IH07CisJ CTU3OTAxRkFGMUNBRjEzNzEwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1NzkwMUZBRTFDQUYx MzcxMDBFRDY0RjkgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tICovOyB9OworCQk1NzkwMUZC MTFDQUYxNDJEMDBFRDY0RjkgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0bWwgaW4gQ29weSBS ZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNTc5MDFGQjAxQ0FG MTQxQzAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sICovOyB9OwogCQk1N0Yx MEQ5MzFDN0U3QjM4MDBFQ0RGMzAgLyogSXNOYXZpZ2F0aW9uQWN0aW9uVHJ1c3RlZC5tbSBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3RjEwRDkyMUM3RTdC MzgwMEVDREYzMCAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLm1tICovOyB9OwogCQk1N0Y1 NkE1QzFDN0Y4Q0MxMDBGMzFEN0UgLyogSXNOYXZpZ2F0aW9uQWN0aW9uVHJ1c3RlZC5odG1sIGlu IENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDU3RjU2 QTVCMUM3RjhBNDAwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0bWwgKi87 IH07CiAJCTc2NDMyMkQ3MUI2MUNDQzMwMDI0RjgwMSAvKiBXb3JkQm91bmRhcnlUeXBpbmdBdHRy aWJ1dGVzLm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NzY0MzIyRDUxQjYxQ0NBNDAwMjRGODAxIC8qIFdvcmRCb3VuZGFyeVR5cGluZ0F0dHJpYnV0ZXMu bW0gKi87IH07CkBAIC00MTEsNiArNDE0LDcgQEAKIAkJCWRzdFBhdGggPSBUZXN0V2ViS2l0QVBJ LnJlc291cmNlczsKIAkJCWRzdFN1YmZvbGRlclNwZWMgPSA3OwogCQkJZmlsZXMgPSAoCisJCQkJ NTc5MDFGQjExQ0FGMTQyRDAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sIGlu IENvcHkgUmVzb3VyY2VzICovLAogCQkJCTU3MTRFQ0JEMUNBOEMyMkEwMDA1MUFDOCAvKiBEb3du bG9hZFJlcXVlc3RPcmlnaW5hbFVSTDIuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLywKIAkJCQk1 NzE0RUNCQjFDQThCRkU0MDAwNTFBQzggLyogRG93bmxvYWRSZXF1ZXN0T3JpZ2luYWxVUkxGcmFt ZS5odG1sIGluIENvcHkgUmVzb3VyY2VzICovLAogCQkJCTU3MTRFQ0I5MUNBOEI1QjAwMDA1MUFD OCAvKiBEb3dubG9hZFJlcXVlc3RPcmlnaW5hbFVSTC5odG1sIGluIENvcHkgUmVzb3VyY2VzICov LApAQCAtNjU2LDYgKzY2MCw5IEBACiAJCTU3MTRFQ0I4MUNBOEI1ODgwMDA1MUFDOCAvKiBEb3du bG9hZFJlcXVlc3RPcmlnaW5hbFVSTC5odG1sICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5odG1sOyBwYXRoID0g RG93bmxvYWRSZXF1ZXN0T3JpZ2luYWxVUkwuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJNTcxNEVDQkExQ0E4QkZEMTAwMDUxQUM4IC8qIERvd25sb2FkUmVxdWVzdE9yaWdpbmFs VVJMRnJhbWUuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9IERvd25sb2FkUmVxdWVz dE9yaWdpbmFsVVJMRnJhbWUuaHRtbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTcx NEVDQkMxQ0E4QzIxODAwMDUxQUM4IC8qIERvd25sb2FkUmVxdWVzdE9yaWdpbmFsVVJMMi5odG1s ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gdGV4dC5odG1sOyBwYXRoID0gRG93bmxvYWRSZXF1ZXN0T3JpZ2luYWxVUkwy Lmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU3OTAxRkFDMUNBRjEyQzIwMEVE NjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5vYmpjcHA7IHBhdGggPSBMb2FkSW52YWxpZFVSTFJlcXVlc3QubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCTU3OTAxRkFFMUNBRjEzNzEwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVS TFJlcXVlc3QubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGggPSBMb2Fk SW52YWxpZFVSTFJlcXVlc3QubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTU3OTAx RkIwMUNBRjE0MUMwMEVENjRGOSAvKiBMb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHRleHQuaHRtbDsgcGF0aCA9IExvYWRJbnZhbGlkVVJMUmVxdWVzdC5odG1sOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk1N0YxMEQ5MjFDN0U3QjM4MDBFQ0RGMzAgLyogSXNOYXZp Z2F0aW9uQWN0aW9uVHJ1c3RlZC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsg cGF0aCA9IElzTmF2aWdhdGlvbkFjdGlvblRydXN0ZWQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTU3RjU2QTVCMUM3RjhBNDAwMEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25U cnVzdGVkLmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSBJc05hdmlnYXRpb25BY3Rp b25UcnVzdGVkLmh0bWw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc1NjA5MTc3MTky NTlDNTkwMDlFRjA2RSAvKiBNZW1vcnlDYWNoZUFkZEltYWdlVG9DYWNoZUlPUy5tbSAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IE1lbW9yeUNhY2hlQWRkSW1hZ2VUb0Nh Y2hlSU9TLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTAyNCw2ICsxMDMxLDcg QEAKIAkJCQk1MUJDRUU0OTFDODRGNEFGMDA0MkM4MkUgLyogSW5kZXhlZERCTXVsdGlQcm9jZXNz Lm1tICovLAogCQkJCTUxQjFFRThEMUM4MEY1ODgwMDY0RkI5OCAvKiBJbmRleGVkREJQZXJzaXN0 ZW5jZS5tbSAqLywKIAkJCQkzN0QzNkVENjFBRjQyRUNEMDBCQUY1RDkgLyogTG9hZEFsdGVybmF0 ZUhUTUxTdHJpbmcubW0gKi8sCisJCQkJNTc5MDFGQUMxQ0FGMTJDMjAwRUQ2NEY5IC8qIExvYWRJ bnZhbGlkVVJMUmVxdWVzdC5tbSAqLywKIAkJCQk1MUNEMUM2QTFCMzhDRTM2MDAxNDJDQTUgLyog TW9kYWxBbGVydHMubW0gKi8sCiAJCQkJMUFCQzNERUQxODk5QkU2RDAwNEYwNjI2IC8qIE5hdmln YXRpb24ubW0gKi8sCiAJCQkJQTFERjc0MzAxQzQxQjY1ODAwQTJGNEQwIC8qIEFsd2F5c1JldmFs aWRhdGVkVVJMU2NoZW1lcy5tbSAqLywKQEAgLTE0NjQsNiArMTQ3Miw3IEBACiAJCQkJQzUwN0U4 QTYxNEM2NTQ1QjAwNUQ2QjNCIC8qIEluc3BlY3RvckJhci5tbSAqLywKIAkJCQk1N0YxMEQ5MjFD N0U3QjM4MDBFQ0RGMzAgLyogSXNOYXZpZ2F0aW9uQWN0aW9uVHJ1c3RlZC5tbSAqLywKIAkJCQk0 QkI0MTYwMTE2ODE1QjI2MDA4MjQyMzggLyogSlNXcmFwcGVyRm9yTm9kZUluV2ViRnJhbWUubW0g Ki8sCisJCQkJNTc5MDFGQUUxQ0FGMTM3MTAwRUQ2NEY5IC8qIExvYWRJbnZhbGlkVVJMUmVxdWVz dC5tbSAqLywKIAkJCQlFMTIyMEQ5RjE1NUIyNTQ4MDAxM0UyRkMgLyogTWVtb3J5Q2FjaGVEaXNh YmxlV2l0aGluUmVzb3VyY2VMb2FkRGVsZWdhdGUubW0gKi8sCiAJCQkJNTE3RTdERkIxNTExMEVB NjAwRDBCMDA4IC8qIE1lbW9yeUNhY2hlUHJ1bmVXaXRoaW5SZXNvdXJjZUxvYWREZWxlZ2F0ZS5t bSAqLywKIAkJCQk3QTk5RDk5MzFBRDRBMjlEMDAzNzMxNDEgLyogTWVudVR5cGVzRm9yTW91c2VF dmVudHMubW0gKi8sCkBAIC0xNTEzLDYgKzE1MjIsNyBAQAogCQkJCTU3RjU2QTVCMUM3RjhBNDAw MEYzMUQ3RSAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLmh0bWwgKi8sCiAJCQkJQzJDRjk3 NTgxNkNFQzY5RTAwNTRFOTlEIC8qIEpTQ29udGV4dEJhY2tGb3J3YXJkQ2FjaGUxLmh0bWwgKi8s CiAJCQkJQzJDRjk3NTkxNkNFQzY5RTAwNTRFOTlEIC8qIEpTQ29udGV4dEJhY2tGb3J3YXJkQ2Fj aGUyLmh0bWwgKi8sCisJCQkJNTc5MDFGQjAxQ0FGMTQxQzAwRUQ2NEY5IC8qIExvYWRJbnZhbGlk VVJMUmVxdWVzdC5odG1sICovLAogCQkJCUUxMjIwREM5MTU1QjI4N0QwMDEzRTJGQyAvKiBNZW1v cnlDYWNoZURpc2FibGVXaXRoaW5SZXNvdXJjZUxvYWREZWxlZ2F0ZS5odG1sICovLAogCQkJCTUx N0U3RTAzMTUxMTE4NzUwMEQwQjAwOCAvKiBNZW1vcnlDYWNoZVBydW5lV2l0aGluUmVzb3VyY2VM b2FkRGVsZWdhdGUuaHRtbCAqLywKIAkJCQkyOTBBOUJCODE3MzVGNDIzMDBENzFCQkMgLyogT3Bl bk5ld1dpbmRvdy5odG1sICovLApAQCAtMTk0NSw2ICsxOTU1LDcgQEAKIAkJCWZpbGVzID0gKAog CQkJCTJEOUE1M0FGMUIzMUZBOEQwMDc0RDVBQSAvKiBTaHJpbmtUb0ZpdC5tbSBpbiBTb3VyY2Vz ICovLAogCQkJCTUxQjQ1NEVDMUI0RTIzNkIwMDg1RUFBNiAvKiBXZWJWaWV3Q2xvc2VJbnNpZGVE aWRGaW5pc2hMb2FkRm9yRnJhbWUubW0gaW4gU291cmNlcyAqLywKKwkJCQk1NzkwMUZBRDFDQUYx MkMyMDBFRDY0RjkgLyogTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tIGluIFNvdXJjZXMgKi8sCiAJ CQkJN0FBMDIxQkIxQUIwOUVBNzAwNTI5NTNGIC8qIERhdGVNYXRoLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCUNFNTBEOENBMUM4NjY1Q0UwMDcyRUE1QSAvKiBPcHRpb25TZXQuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJMkQxRkUwQjAxQUQ0NjVDMTAwNkNEOUU2IC8qIEZpeGVkTGF5b3V0U2l6ZS5t bSBpbiBTb3VyY2VzICovLApAQCAtMTk1Myw2ICsxOTY0LDcgQEAKIAkJCQkyRDgxMDRDQzFCRUMx M0U3MDAyMERBNDYgLyogRmluZEluUGFnZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUNEMjI1QzA4 MUM0NUE2OTIwMDE0MDc2MSAvKiBQYXJzZWRDb250ZW50UmFuZ2UuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJNDE5NzNCNUQxQUYyMjg3NTAwNkM3QjM2IC8qIFNoYXJlZEJ1ZmZlci5jcHAgaW4gU291 cmNlcyAqLywKKwkJCQk1NzkwMUZBRjFDQUYxMzcxMDBFRDY0RjkgLyogTG9hZEludmFsaWRVUkxS ZXF1ZXN0Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJNTFCQ0VFNEExQzg0RjRBRjAwNDJDODJFIC8q IEluZGV4ZWREQk11bHRpUHJvY2Vzcy5tbSBpbiBTb3VyY2VzICovLAogCQkJCTU3RjEwRDkzMUM3 RTdCMzgwMEVDREYzMCAvKiBJc05hdmlnYXRpb25BY3Rpb25UcnVzdGVkLm1tIGluIFNvdXJjZXMg Ki8sCiAJCQkJMkREMzU1MzYxQkQwODM3ODAwNURGNEE3IC8qIEF1dG9MYXlvdXRJbnRlZ3JhdGlv bi5tbSBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXQyQ29jb2EvTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmcubW0gYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbQppbmRl eCAwOWI4ZTljN2QyMmFmYzhmYmE5YjMwZTQ5Y2Q3YjFlZjlhMjUyNDRmLi4wNjhhYjQ1NGJlYTQ0 MDhiMGY1ZWE2ZjQ2OGI3ZTA4ZDZjMmE2Y2Q0IDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy5tbQorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJDb2NvYS9Mb2FkQWx0ZXJuYXRlSFRNTFN0 cmluZy5tbQpAQCAtMzAsMTAgKzMwLDEyIEBACiAKICNpbXBvcnQgIlBsYXRmb3JtVXRpbGl0aWVz LmgiCiAjaW1wb3J0ICJUZXN0LmgiCisjaW1wb3J0IDxXZWJDb3JlL1dlYkNvcmVOU1VSTEV4dHJh cy5oPgogI2ltcG9ydCA8V2ViS2l0L1dLV2ViVmlld1ByaXZhdGUuaD4KICNpbXBvcnQgPHd0Zi9S ZXRhaW5QdHIuaD4KIAogc3RhdGljIGJvb2wgaXNEb25lOworc3RhdGljIGludCBwcm92aXNpb25h bExvYWRDb3VudDsKIAogQGludGVyZmFjZSBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ0Zyb21Qcm92 aXNpb25hbExvYWRFcnJvckNvbnRyb2xsZXIgOiBOU09iamVjdCA8V0tOYXZpZ2F0aW9uRGVsZWdh dGU+CiBAZW5kCkBAIC00Miw3ICs0NCw4IEBAIEBpbXBsZW1lbnRhdGlvbiBMb2FkQWx0ZXJuYXRl SFRNTFN0cmluZ0Zyb21Qcm92aXNpb25hbExvYWRFcnJvckNvbnRyb2xsZXIKIAogLSAodm9pZCl3 ZWJWaWV3OihXS1dlYlZpZXcgKil3ZWJWaWV3IGRpZEZhaWxQcm92aXNpb25hbE5hdmlnYXRpb246 KFdLTmF2aWdhdGlvbiAqKW5hdmlnYXRpb24gd2l0aEVycm9yOihOU0Vycm9yICopZXJyb3IKIHsK LSAgICBbd2ViVmlldyBfbG9hZEFsdGVybmF0ZUhUTUxTdHJpbmc6QCJlcnJvciBwYWdlIiBiYXNl VVJMOm5pbCBmb3JVbnJlYWNoYWJsZVVSTDpbTlNVUkwgVVJMV2l0aFN0cmluZzpAImRhdGE6Il1d OworICAgIGlmIChlcnJvci5jb2RlICE9IE5TVVJMRXJyb3JDYW5jZWxsZWQpCisgICAgICAgIFt3 ZWJWaWV3IF9sb2FkQWx0ZXJuYXRlSFRNTFN0cmluZzpAImVycm9yIHBhZ2UiIGJhc2VVUkw6bmls IGZvclVucmVhY2hhYmxlVVJMOmVycm9yLnVzZXJJbmZvW0AiTlNFcnJvckZhaWxpbmdVUkxLZXki XV07CiB9CiAKIC0gKHZvaWQpd2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBkaWRGaW5pc2hO YXZpZ2F0aW9uOihXS05hdmlnYXRpb24gKiluYXZpZ2F0aW9uCkBAIC01MCw2ICs1MywxMSBAQCAt ICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZpZXcgZGlkRmluaXNoTmF2aWdhdGlvbjoo V0tOYXZpZ2F0aW9uICopbmF2aWdhdAogICAgIGlzRG9uZSA9IHRydWU7CiB9CiAKKy0gKHZvaWQp d2ViVmlldzooV0tXZWJWaWV3ICopd2ViVmlldyBkaWRTdGFydFByb3Zpc2lvbmFsTmF2aWdhdGlv bjoobnVsbF91bnNwZWNpZmllZCBXS05hdmlnYXRpb24gKiluYXZpZ2F0aW9uCit7CisgICAgcHJv dmlzaW9uYWxMb2FkQ291bnQrKzsKK30KKwogQGVuZAogCiBzdGF0aWMgTlNTdHJpbmcgKnVubG9h ZGFibGVVUkwgPSBAImRhdGE6IjsKQEAgLTkzLDQgKzEwMSwyNCBAQCBURVNUKFdLV2ViVmlldywg TG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdGcm9tUHJvdmlzaW9uYWxMb2FkRXJyb3IpCiAgICAgRVhQ RUNUX1NUUkVRKFtbbGlzdC5jdXJyZW50SXRlbSBVUkxdIGFic29sdXRlU3RyaW5nXS5VVEY4U3Ry aW5nLCBsb2FkYWJsZVVSTC5VVEY4U3RyaW5nKTsKIH0KIAorVEVTVChXS1dlYlZpZXcsIExvYWRB bHRlcm5hdGVIVE1MU3RyaW5nRnJvbVByb3Zpc2lvbmFsTG9hZEVycm9yQmFja1RvQmFjaykKK3sK KyAgICBAYXV0b3JlbGVhc2Vwb29sIHsKKyAgICAgICAgUmV0YWluUHRyPFdLV2ViVmlldz4gd2Vi VmlldyA9IGFkb3B0TlMoW1tXS1dlYlZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVj dCgwLCAwLCA4MDAsIDYwMCldKTsKKworICAgICAgICBSZXRhaW5QdHI8TG9hZEFsdGVybmF0ZUhU TUxTdHJpbmdGcm9tUHJvdmlzaW9uYWxMb2FkRXJyb3JDb250cm9sbGVyPiBkZWxlZ2F0ZSA9IGFk b3B0TlMoW1tMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ0Zyb21Qcm92aXNpb25hbExvYWRFcnJvckNv bnRyb2xsZXIgYWxsb2NdIGluaXRdKTsKKyAgICAgICAgW3dlYlZpZXcgc2V0TmF2aWdhdGlvbkRl bGVnYXRlOmRlbGVnYXRlLmdldCgpXTsKKworICAgICAgICBjaGFyIGxpdGVyYWxbXSA9ICJodHRw czovL3d3dy5leGFtcGxlLmNvbTw+LyI7CisgICAgICAgIE5TVVJMKiB0YXJnZXRVUkwgPSBXZWJD b3JlOjpVUkxXaXRoRGF0YShbTlNEYXRhIGRhdGFXaXRoQnl0ZXM6bGl0ZXJhbCBsZW5ndGg6c3Ry bGVuKGxpdGVyYWwpXSwgbmlsKTsKKyAgICAgICAgW3dlYlZpZXcgbG9hZFJlcXVlc3Q6W05TVVJM UmVxdWVzdCByZXF1ZXN0V2l0aFVSTDp0YXJnZXRVUkxdXTsKKyAgICAgICAgW3dlYlZpZXcgbG9h ZFJlcXVlc3Q6W05TVVJMUmVxdWVzdCByZXF1ZXN0V2l0aFVSTDp0YXJnZXRVUkxdXTsKKworICAg ICAgICBpc0RvbmUgPSBmYWxzZTsKKyAgICAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZp c0RvbmUpOworICAgICAgICAvLyBJbiBzdWNjZXNzLCB3ZSBzaG91bGQgb25seSBzdGFydCAzIHBy b3Zpc2lvbmFsIGxvYWRzOiAyIGZvciB0aGUgbG9hZFJlcXVlc3QsIGFuZCAqb25seSAxKiBmb3Ig dGhlIF9sb2FkQWx0ZXJuYXRlSFRNTFN0cmluZy4KKyAgICAgICAgRVhQRUNUX0VRKDMsIHByb3Zp c2lvbmFsTG9hZENvdW50KTsKKyAgICB9Cit9CisKICNlbmRpZgpkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1t IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyQ29jb2EvTG9hZEludmFsaWRVUkxS ZXF1ZXN0Lm1tCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjkzNzY5OGU1OGNhN2FhMjkyZDhkOTQ3ZmU0OGRmNGVjMjRj YjAwNDAKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dDJDb2NvYS9Mb2FkSW52YWxpZFVSTFJlcXVlc3QubW0KQEAgLTAsMCArMSw4OCBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxNiBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIFdLX0FQSV9FTkFCTEVECisKKyNpbXBv cnQgIlBsYXRmb3JtVXRpbGl0aWVzLmgiCisjaW1wb3J0IDxXZWJDb3JlL1dlYkNvcmVOU1VSTEV4 dHJhcy5oPgorI2ltcG9ydCA8V2ViS2l0L1dLTmF2aWdhdGlvblByaXZhdGUuaD4KKyNpbXBvcnQg PFdlYktpdC9XS1dlYlZpZXcuaD4KKyNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKworc3RhdGlj IGJvb2wgZGlkRmluaXNoVGVzdDsKK3N0YXRpYyBib29sIGRpZEZhaWxQcm92aXNpb25hbExvYWQ7 CitzdGF0aWMgY29uc3QgY2hhciBsaXRlcmFsW10gPSAiaHR0cHM6Ly93d3cuZXhhbXBsZS5jb208 Pi8iOworCitzdGF0aWMgTlNVUkwgKmxpdGVyYWxVUkwoY29uc3QgY2hhciogbGl0ZXJhbCkKK3sK KyAgICByZXR1cm4gV2ViQ29yZTo6VVJMV2l0aERhdGEoW05TRGF0YSBkYXRhV2l0aEJ5dGVzOmxp dGVyYWwgbGVuZ3RoOnN0cmxlbihsaXRlcmFsKV0sIG5pbCk7Cit9CisKK0BpbnRlcmZhY2UgTG9h ZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVsZWdhdGUgOiBOU09iamVjdCA8V0tOYXZpZ2F0 aW9uRGVsZWdhdGU+CitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBMb2FkSW52YWxpZFVSTE5hdmln YXRpb25BY3Rpb25EZWxlZ2F0ZQorCistICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAqKXdlYlZp ZXcgZGlkQ29tbWl0TmF2aWdhdGlvbjooV0tOYXZpZ2F0aW9uICopbmF2aWdhdGlvbgoreworICAg IGRpZEZpbmlzaFRlc3QgPSB0cnVlOworfQorCistICh2b2lkKXdlYlZpZXc6KFdLV2ViVmlldyAq KXdlYlZpZXcgZGlkRmFpbFByb3Zpc2lvbmFsTmF2aWdhdGlvbjooV0tOYXZpZ2F0aW9uICopbmF2 aWdhdGlvbiB3aXRoRXJyb3I6KE5TRXJyb3IgKillcnJvcgoreworICAgIGlmIChbZXJyb3IuZG9t YWluIGlzRXF1YWw6QCJXZWJLaXRFcnJvckRvbWFpbiJdCisgICAgICAgICYmIGVycm9yLmNvZGUg PT0gV2ViS2l0RXJyb3JDYW5ub3RTaG93VVJMCisgICAgICAgICYmIFtlcnJvci51c2VySW5mb1tA Ik5TRXJyb3JGYWlsaW5nVVJMS2V5Il0gaXNFcXVhbDpsaXRlcmFsVVJMKGxpdGVyYWwpXSkKKyAg ICAgICAgZGlkRmFpbFByb3Zpc2lvbmFsTG9hZCA9IHRydWU7CisgICAgZGlkRmluaXNoVGVzdCA9 IHRydWU7Cit9CisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitURVNUKFdl YktpdDIsIExvYWRJbnZhbGlkVVJMUmVxdWVzdCkKK3sKKyAgICBAYXV0b3JlbGVhc2Vwb29sIHsK KyAgICAgICAgUmV0YWluUHRyPFdLV2ViVmlldz4gd2ViVmlldyA9IGFkb3B0TlMoW1tXS1dlYlZp ZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVjdCgwLCAwLCA4MDAsIDYwMCldKTsKKwor ICAgICAgICBSZXRhaW5QdHI8TG9hZEludmFsaWRVUkxOYXZpZ2F0aW9uQWN0aW9uRGVsZWdhdGU+ IGRlbGVnYXRlID0gYWRvcHROUyhbW0xvYWRJbnZhbGlkVVJMTmF2aWdhdGlvbkFjdGlvbkRlbGVn YXRlIGFsbG9jXSBpbml0XSk7CisgICAgICAgIFt3ZWJWaWV3IHNldE5hdmlnYXRpb25EZWxlZ2F0 ZTpkZWxlZ2F0ZS5nZXQoKV07CisgICAgICAgIFt3ZWJWaWV3IGxvYWRSZXF1ZXN0OltOU1VSTFJl cXVlc3QgcmVxdWVzdFdpdGhVUkw6bGl0ZXJhbFVSTChsaXRlcmFsKV1dOworCisgICAgICAgIGRp ZEZpbmlzaFRlc3QgPSBmYWxzZTsKKyAgICAgICAgZGlkRmFpbFByb3Zpc2lvbmFsTG9hZCA9IGZh bHNlOworICAgICAgICBVdGlsOjpydW4oJmRpZEZpbmlzaFRlc3QpOworCisgICAgICAgIEVYUEVD VF9UUlVFKGRpZEZhaWxQcm92aXNpb25hbExvYWQpOworICAgIH0KK30KKworfSAvLyBuYW1lc3Bh Y2UgVGVzdFdlYktpdEFQSQorCisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9tYWMvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0bWwgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL21hYy9Mb2FkSW52YWxpZFVSTFJlcXVlc3QuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5l MzQzNjc4MDJmYTczYWYwM2QwMDc0ZWRkZmUyYmFlYzFmOTFjMDE3Ci0tLSAvZGV2L251bGwKKysr IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9tYWMvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lmh0 bWwKQEAgLTAsMCArMSwxMiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPC9o ZWFkPgorPGJvZHk+CisgICAgPGEgaWQ9ImhyZWYiIGhyZWY9Imh0dHBzOi8vd3d3LmV4YW1wbGUu Y29tPD4vIj5odHRwczovL3d3dy5leGFtcGxlLmNvbSZsdDsmZ3Q7LzwvYT4KKyAgICA8c2NyaXB0 PgorICAgICAgICB2YXIgZWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJocmVmIik7 CisgICAgICAgIGVsZW1lbnQuY2xpY2soKTsKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvbWFjL0xvYWRJbnZhbGlk VVJMUmVxdWVzdC5tbSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvbWFjL0xvYWRJbnZhbGlk VVJMUmVxdWVzdC5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mOWJlZjM2ODg4ZGNhNjI1YjQ3YzE5MTYzZmY3YTE3 ZmRiYjFmZjhhCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9t YWMvTG9hZEludmFsaWRVUkxSZXF1ZXN0Lm1tCkBAIC0wLDAgKzEsODMgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTYgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENP TlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgor ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBP UiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICog U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAq IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbXBvcnQgIlBsYXRmb3JtVXRpbGl0aWVzLmgiCisj aW1wb3J0IDxXZWJDb3JlL1dlYkNvcmVOU1VSTEV4dHJhcy5oPgorI2ltcG9ydCA8V2ViS2l0L1dL TmF2aWdhdGlvblByaXZhdGUuaD4KKyNpbXBvcnQgPFdlYktpdC9XS1dlYlZpZXcuaD4KKyNpbXBv cnQgPHd0Zi9SZXRhaW5QdHIuaD4KKworc3RhdGljIGJvb2wgZGlkRmluaXNoVGVzdDsKK3N0YXRp YyBib29sIGRpZEZhaWxQcm92aXNpb25hbExvYWQ7CisKK0BpbnRlcmZhY2UgTG9hZEludmFsaWRV UkxXZWJGcmFtZUxvYWREZWxlZ2F0ZSA6IE5TT2JqZWN0IDxXZWJGcmFtZUxvYWREZWxlZ2F0ZT4g eworfQorQGVuZAorCitAaW1wbGVtZW50YXRpb24gTG9hZEludmFsaWRVUkxXZWJGcmFtZUxvYWRE ZWxlZ2F0ZQorCistICh2b2lkKXdlYlZpZXc6KFdlYlZpZXcgKilzZW5kZXIgZGlkQ29tbWl0TG9h ZEZvckZyYW1lOihXZWJGcmFtZSAqKWZyYW1lCit7CisgICAgZGlkRmluaXNoVGVzdCA9IHRydWU7 Cit9CisKKy0gKHZvaWQpd2ViVmlldzooV2ViVmlldyAqKXNlbmRlciBkaWRGYWlsUHJvdmlzaW9u YWxMb2FkV2l0aEVycm9yOihOU0Vycm9yICopZXJyb3IgZm9yRnJhbWU6KFdlYkZyYW1lICopZnJh bWUKK3sKKyAgICBzdGF0aWMgY2hhciBsaXRlcmFsW10gPSAiaHR0cHM6Ly93d3cuZXhhbXBsZS5j b208Pi8iOworICAgIE5TVVJMICpmYWlsZWRVUkwgPSBXZWJDb3JlOjpVUkxXaXRoRGF0YShbTlNE YXRhIGRhdGFXaXRoQnl0ZXM6bGl0ZXJhbCBsZW5ndGg6c3RybGVuKGxpdGVyYWwpXSwgbmlsKTsK KyAgICBpZiAoW2Vycm9yLmRvbWFpbiBpc0VxdWFsOkAiV2ViS2l0RXJyb3JEb21haW4iXQorICAg ICAgICAmJiBlcnJvci5jb2RlID09IFdlYktpdEVycm9yQ2Fubm90U2hvd1VSTAorICAgICAgICAm JiBbZXJyb3IudXNlckluZm9bQCJOU0Vycm9yRmFpbGluZ1VSTEtleSJdIGlzRXF1YWw6ZmFpbGVk VVJMXSkKKyAgICAgICAgZGlkRmFpbFByb3Zpc2lvbmFsTG9hZCA9IHRydWU7CisgICAgZGlkRmlu aXNoVGVzdCA9IHRydWU7Cit9CisKK0BlbmQKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgewor CitURVNUKFdlYktpdDEsIExvYWRJbnZhbGlkVVJMUmVxdWVzdCkKK3sKKyAgICBAYXV0b3JlbGVh c2Vwb29sIHsKKyAgICAgICAgUmV0YWluUHRyPFdlYlZpZXc+IHdlYlZpZXcgPSBhZG9wdE5TKFtb V2ViVmlldyBhbGxvY10gaW5pdF0pOworCisgICAgICAgIFJldGFpblB0cjxMb2FkSW52YWxpZFVS TFdlYkZyYW1lTG9hZERlbGVnYXRlPiBkZWxlZ2F0ZSA9IGFkb3B0TlMoW1tMb2FkSW52YWxpZFVS TFdlYkZyYW1lTG9hZERlbGVnYXRlIGFsbG9jXSBpbml0XSk7CisgICAgICAgIFt3ZWJWaWV3IHNl dEZyYW1lTG9hZERlbGVnYXRlOmRlbGVnYXRlLmdldCgpXTsKKworICAgICAgICBOU1VSTCAqY29u dGVudFVSTCA9IFtbTlNCdW5kbGUgbWFpbkJ1bmRsZV0gVVJMRm9yUmVzb3VyY2U6QCJMb2FkSW52 YWxpZFVSTFJlcXVlc3QiIHdpdGhFeHRlbnNpb246QCJodG1sIiBzdWJkaXJlY3Rvcnk6QCJUZXN0 V2ViS2l0QVBJLnJlc291cmNlcyJdOworICAgICAgICBbW3dlYlZpZXcgbWFpbkZyYW1lXSBsb2Fk UmVxdWVzdDpbTlNVUkxSZXF1ZXN0IHJlcXVlc3RXaXRoVVJMOmNvbnRlbnRVUkxdXTsKKworICAg ICAgICBkaWRGaW5pc2hUZXN0ID0gZmFsc2U7CisgICAgICAgIGRpZEZhaWxQcm92aXNpb25hbExv YWQgPSBmYWxzZTsKKyAgICAgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hUZXN0KTsKKworICAgICAg ICBFWFBFQ1RfVFJVRShkaWRGYWlsUHJvdmlzaW9uYWxMb2FkKTsKKyAgICB9Cit9CisKK30gLy8g bmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkKKwo=