137299 2014-10-01 04:13:52 -0700 POST form data is missing with a custom NSURLProtocol 2022-02-01 02:55:08 -0800 1 1 1 Unclassified WebKit WebKit API 528+ (Nightly build) iPhone / iPad Other RESOLVED INVALID https://bugs.webkit.org/show_bug.cgi?id=137302 https://bugs.webkit.org/show_bug.cgi?id=138131 https://bugs.webkit.org/show_bug.cgi?id=138169 https://bugs.webkit.org/show_bug.cgi?id=140188 http://world-backgammon.rhcloud.com/login.php P2 Major --- 138131 1 danielo webkit-unassigned aestes andersca ap benjamin buildbot darin dbates eric.carlson mjs rniwa sam stuartmorgan oldest_to_newest 1038520 0 danielo 2014-10-01 04:13:52 -0700 If a custom NSURLProtocol is handling an HTTP POST request, the request HTTPBody is nil. This only happens if [WKBrowsingContextController registerSchemeForCustomProtocol:] is called for that protocol. If this method is not called, then the POST request is simply bypassing the custom protocol. This happens on iOS 8.1 [12B401]. It's also reproducible on the master branch ( 809db5f8edac632ec3332b43dc90795d96914440 ). Test case: https://gist.github.com/anonymous/e4ef8586780b2194a6fa Run it with ./TestWebKitAPI --gtest_filter=WebKit2CustomProtocolsTest.FormPostBodyExists 1038521 1 239019 danielo 2014-10-01 04:21:11 -0700 Created attachment 239019 Automatic test case 1038539 2 danielo 2014-10-01 07:17:24 -0700 Manual test case: 1. go to http://world-backgammon.rhcloud.com/login.php 2. click "Login" button Expected results: a message "You did not fill in a required field." Actual results: the page is reloaded, and you see the form again, because POST parameters are not sent (and Content-Length = 0). For this to happen you need to register a custom NSURLProtocol handling HTTP. 1038607 3 aestes 2014-10-01 12:13:21 -0700 It looks like we don't serialize HTTP body when sending the request from the networking process to the UI process. See http://trac.webkit.org/browser/trunk/Source/WebKit2/Shared/mac/WebCoreArgumentCodersMac.mm#L60. 1038693 4 ap 2014-10-01 15:46:46 -0700 I think that custom protocol callbacks would need to serialize the body separately. However, the comment still holds - we can't possibly always make it work, because the body may be a stream, and thus not meaningfully serializable. 1038827 5 danielo 2014-10-02 02:41:40 -0700 A comment in the serialization code is saying: "We don't send HTTP body over IPC for better performance" What was the performance problem? Consider a use case of having a custom HTTP implementation using NSURLProtocol. Opera Coast and Google Chrome on iOS are using this approach. If the body is not sent to UIProcess, there's no way a correct request can be made from UIProcess. If HTTPBodyStream is present one would need to organize proper streaming between processes, where the sending process reads the stream block by block, and sends it through IPC as in series of calls, while in the UIProcess it makes a proxy stream on that request that accumulates data. I would say that allowing the HTTPBody to be serialized will fix most of the simple FORM POST requests, which might be good enough already. What are the use cases when HTTPBodyStream is not nil? Can it happen with XmlHttpRequest? Maybe some <input> for file uploads? 1038877 6 ap 2014-10-02 09:29:43 -0700 > I would say that allowing the HTTPBody to be serialized will fix most of the simple FORM POST requests, which might be good enough already. I expect that file upload won't work in this case, which is probably not good enough for a shipping browser. Beefing up custom protocols so that they could work to fully replace http stack does not seem like a worthy goal to me personally (Sam, Anders and Andy would be the authority on this, not me). Perhaps we should explicitly block anything but GET, to avoid giving an impression that this may sort of work? HTTP resource fetching is just too low level to meaningfully delegate. 1038921 7 sam 2014-10-02 11:47:32 -0700 (In reply to comment #6) > > I would say that allowing the HTTPBody to be serialized will fix most of the simple FORM POST requests, which might be good enough already. > > I expect that file upload won't work in this case, which is probably not good enough for a shipping browser. > > Beefing up custom protocols so that they could work to fully replace http stack does not seem like a worthy goal to me personally (Sam, Anders and Andy would be the authority on this, not me). Perhaps we should explicitly block anything but GET, to avoid giving an impression that this may sort of work? > > HTTP resource fetching is just too low level to meaningfully delegate. Please note that using custom protocol handlers with the Modern WebKit API is not supported at all at this time (it would require use of SPI which can change at any time). 1039213 8 danielo 2014-10-03 08:50:52 -0700 I'm aware that the Modern WebKit API doesn't support NSURLProtocol, so treat this discussion as a feature request. I would like to share with you some use cases that Opera Coast is having with this and why is it interesting to use HTTP delegation, but I can't freely discuss it in public, so please take a look on a bug rdar://18536522 . I'm sure that other browser product guys have something to say about this, I'll try to bring them into discussion. I just know that iOS Google Chrome, Opera Mini and Yandex Browser are all successfully utilising HTTP delegation with UIWebView by implementing some custom NSURLProtocols. 1039706 9 239328 danielo 2014-10-06 04:30:31 -0700 Created attachment 239328 Patch 1039738 10 239328 ap 2014-10-06 09:12:25 -0700 Comment on attachment 239328 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=239328&action=review I don't believe that this is acceptable for perform > Source/WebKit2/ChangeLog:9 > + This lets using a custom NSURLProtocol in the UI process > + to handle POST requests with form parameters. I do not believe that this is acceptable for performance reasons. 1039747 11 andersca 2014-10-06 09:45:11 -0700 While I do think it could be desirable to serialize the request body (assuming it's an NSData object), I don't think we want to do this for _all_ requests, and we have to be careful to not do unnecessary copies (so we would want to do copy-on-write shared memory mapping of the data). 1040006 12 stuartmorgan 2014-10-07 06:18:30 -0700 (In reply to comment #0) > If a custom NSURLProtocol is handling an HTTP POST request, the request HTTPBody is nil. > This only happens if [WKBrowsingContextController registerSchemeForCustomProtocol:] is called for that protocol. This is actually not true; the same problem exists in a stock WKWebView without calling any SPI. If you implement WKNavigationDelegate callbacks, the NSURLRequest provided in those callbacks is missing this data, so the delegate method is providing incorrect information to the client (this is filed as rdar://18399639 BTW). Even without custom protocol handlers, Chrome needs this information in order to correctly implement our back-forward handling. 1040022 13 stuartmorgan 2014-10-07 07:41:29 -0700 (In reply to comment #6) > Beefing up custom protocols so that they could work to fully replace http stack does not seem like a worthy goal Please keep in mind that given that UIWebView is increasingly crippled (slow JS, no IndexedDB support, etc.), this ends up being equivalent in practice to saying that continuing to allow at least the current level of support for an ecosystem of compelling third-party browsers on iOS is not a worthy goal. Speaking for Chromium on iOS, obviously we hope that does not end up being the team's official position. 1040249 14 239465 danielo 2014-10-08 03:46:21 -0700 Created attachment 239465 patch part 2 Please check out an update - patch part 2. Now request body is serialized only in the IPC message "CustomProtocolManagerProxy::StartLoading" (a message that's sent to initiate a resource loading in another process). In all other cases it works like before, that is the body is stripped. That's a rough implementation I'm sure there will be some review comments, so I didn't make a proper single patch with changelogs, sorry for that. 1044245 15 ap 2014-10-27 09:14:25 -0700 Does form upload work with this patch? If it does, can you please explain how it serializes a body stream? 1044443 16 danielo 2014-10-28 02:11:51 -0700 Right, this patch only sends NSURLRequest.HTTPBody, and doesn't handle NSURLRequest.HTTPBodyStream. HTTPBodyStream is stripped as before. It means that uploading a file won't work (for example on http://imgur.com ). I think that the file upload use case should be treated in a separate bug, because it's quite a different use case, and should be prioritized separately. It needs different test cases as well. I'm going to create a separate bug report for this if that's fine. The patch here fixes all the form types without "input type=file", including all sorts of login and registration forms. 1044456 17 danielo 2014-10-28 06:56:00 -0700 Separate bug report for handling file uploads (HTTPBodyStream): https://bugs.webkit.org/show_bug.cgi?id=138131 1044468 18 240538 danielo 2014-10-28 08:03:33 -0700 Created attachment 240538 Patch 1044469 19 danielo 2014-10-28 08:04:28 -0700 Submitted a combined patch with updated changelogs. 1044504 20 240538 darin 2014-10-28 09:32:00 -0700 Comment on attachment 240538 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=240538&action=review I don’t think the approach is quite right here. Also, the patch does not build on any of the EWS bots, so review-. > Source/WebCore/platform/network/ResourceRequestWithBody.h:35 > +class ResourceRequestWithBody { I don’t understand the purpose of this class. It seems to wrap a ResourceRequest and add nothing, with forwarding functions. Does not seem like a good pattern to add a class like this. I understand the desire to have clarity about whether a body is present, but this does not seem to be the right way to accomplish that. We don’t want a class that we have to keep updating every time we change the design of ResourceRequest. > Source/WebCore/platform/network/ResourceRequestWithBody.h:36 > + ResourceRequest m_request; This is the wrong style for WebKit. We put private data members last, after public members, and we explicitly write "private". > Source/WebCore/platform/network/ResourceRequestWithBody.h:49 > +#if ENABLE(CACHE_PARTITIONING) > + const String& cachePartition() const { return m_request.cachePartition(); } > +#endif > +#if ENABLE(INSPECTOR) > + // Whether this request should be hidden from the Inspector. > + bool hiddenFromInspector() const { return m_request.hiddenFromInspector(); } > +#endif These should have blank lines around them, so they make their own paragraphs. > Source/WebCore/platform/network/ResourceRequestWithBody.h:52 > + template<class Encoder> void encodeWithoutPlatformData(Encoder& e) const { m_request.encodeWithoutPlatformData(e); } We use words for argument names, not letters. This should be "encoder". 1044742 21 danielo 2014-10-29 06:01:30 -0700 > ResourceRequestWithBody { > I don’t understand the purpose of this class > I understand the desire to have clarity about whether a body is present, but this does not seem to be the right way to accomplish that. That's correct. It's only to trigger a different serialization method to work (pick a different ArgumentCoder<T>). The current IPC is implemented by using templates. When you call a send() method, it uses some magic (variadic templates) to determine an ArgumentCoder by type of the passed argument (for each argument). It's done at compile time. Another option to fix it would be to pass the message type (class MT) through this template code path. I could add a parameter MT that you pass to send(), so that it uses a different coder method in the end if the MT matches "StartLoading" type. Another option to fix it would be to add a flag to ResourceRequest. This sounds dirty to me, because this flag conceptually doesn't belong to ResourceRequest. It belongs to a party which is managing serialization. Another option would be to avoid using templates at all, and just inline them in a place where send() is called, so that all argument encoding parameters are fixed there, i.e. create a message to pass by hand instead of letting the template magic do it automatically. This is dirty as well. What do you think is best? Do you have other ideas? > I don’t think the approach is quite right here. Also, the patch does not build on any of the EWS bots, so review-. I'm looking at the errors ( https://webkit-queues.appspot.com/patch/240538 ), but I don't understand them. It looks like #import statements are missing, but it's not true. I'm building using Xcode and command line (build-webkit script), and it builds well, but I'm only building in debug mode. It's some release configuration problem. I'll try to build a release and see what's wrong. If you know what's wrong, please let me know. 1044754 22 danielo 2014-10-29 08:11:18 -0700 A release build on my machine with "build-webkit --release" worked fine, what's the difference on EWS? How to test this? 1045016 23 240667 danielo 2014-10-30 05:31:05 -0700 Created attachment 240667 Patch 1045017 24 danielo 2014-10-30 05:37:38 -0700 I reimplemented a patch so that it doesn't touch WebCore, and ResourceRequestWithBody is not needed. 1045026 25 danielo 2014-10-30 06:37:26 -0700 The windows build fails, but I can't find any error in the log: https://webkit-queues.appspot.com/results/5319787991269376 Seems like the TestWebKitAPI project fails, but why? 1045039 26 darin 2014-10-30 09:17:16 -0700 Anders is the right person to look at this. 1052210 27 mjs 2014-12-03 11:03:13 -0800 Two comments on this patch: (1) Both TwestWebKitAPI and ImageDiffLauncher fail reporting this warning: 1>..\Tests\WTF\MediaTime.cpp(174): warning C4056: overflow in floating-point constant arithmetic I didn't think warnings would ever cause a build failure on Windows but maybe this is the reason. Perhaps the patch should just be re-uploaded. (2) If serializing the body is right, I don't think it's correct to do it only for the custom protocol case. As Stuart Morgan mentioned, Chrome for iOS would have a use for it for purposes of the back-forward list even without custom protocols. Since custom protocols are not even supported in the Modern WebKit API at present, I am not sure how the patch posted here would even do anything. Can you explain in what cases it has an effect, and how you tested it? (3) The patch lacks tests. It should probably have an API test. (4) If the patch is changed to be global, it probably needs to be performance tested. If the body serialization is a performance hit, we may need to be clever about how to optimize, such as by using shared memory. I think if the patch could be done with no measurable slowdown and worked for even the non-custom-protocol case, likely no one would have a strong objection. (5) I don't think covering only HTTPBody but not HTTPBodyStream is sufficient for use in a browser, either for custom protocols or for the back/forward case. Any time a form contains a file upload, it will have a body stream. If a client relies on presence of the body, it will fail for this case. While there's no obvious way to serialize an arbitrary HTTPBodyStream, we might be able to special-case detect the one produced by WebKit and convert it back to an array of data chunks and file references. If we do support passing the body to the client, and possibly eventually support custom protocol handlers for HTTP, I think the feature should be done fully correctly instead of just trying to hit the 90% case. 1052434 28 danielo 2014-12-04 02:05:49 -0800 Thanks for taking a look Maciej. (1) I'll rebase and reupload to "unred" the windows. (2) You've asked 2 questions here: The first is "why it's not general, but only for startLoading case?". It's because it's a minimum that's enough for our use cases. Having this the Chrome team can adjust their code to take a body from on the protocol level, and then use it in the delegate callbacks. Another reason is that having it global is a vague performance problem (in some conditions, on some platforms, hard to test), and that's why it was stripped in the first place. Having it for a single case makes performance implications clear. My first attempt was to enable it to be passed globally, you can see it in obsolete patches: https://bugs.webkit.org/attachment.cgi?id=239328&action=prettypatch And it was rejected for performance reasons, which you mention as well. The 2nd question is: "how did I test it on iOS?". The answer is in the bug description: You have to call [WKBrowsingContextController registerSchemeForCustomProtocol:], then it works as expected. (3) The patch doesn't lack tests. The test case was uploaded in the first place (you can see it in obsolete patches), and it is still present in the last version of the patch. It's in the file Tools/TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm . See: https://bugs.webkit.org/attachment.cgi?id=240667&action=diff#a/Tools/TestWebKitAPI/Tests/WebKit2ObjC/CustomProtocolsTest.mm_sec1 (5) I agree about that having file upload support is important. I just want the work to be split in separate tasks, that's why I made a separate bug 138131 for supporting uploads. I don't think that the work done here code-wise depends on 138131 or vice-versa, because: a) separate fields are used for normal body and stream b) serialization is done separately c) different methods should be applied when passing this stream through IPC (and that can be a long discussion for streams) d) separate test case needs to be made For me this is enough to split it as a separate issue, and work on it separately. The second reason for splitting it is that some clients might be already happy by only having simple POST forms. The third reason is that it's the first experience, and I wanted to start gently with small and targeted changes, where it's easy for us to argue about the solution and if it makes sense or not. By no means I wanted to start with some huge architectural changes that affect performance in unknown ways, and require a lot of experience and testing. If this work is accepted, and a related 137302 is accepted (which is already reviewed, but blocked by this bug), I was planning to start working on uploads shortly, because we definitely need them as well. So don't worry, the streams case won't be forgotten. 1058689 29 243971 danielo 2015-01-05 03:50:16 -0800 Created attachment 243971 Patch 1058691 30 danielo 2015-01-05 04:22:23 -0800 Rebased to master. No conflicts, no changes. Waiting for reviewers to respond to the last comments. 1059129 31 sam 2015-01-06 13:08:03 -0800 After discussing this a bit, we have decided that since we do not support custom NSURLProtocols as API, there is no reason to complicate the code further by adding this functionality that no one will be allowed to use. As such, I don't think this bug is valid. I appreciate your work on it, and apologize for taking so long to come to a conclusive answer here. I am interested in the larger types of problems you are having that make you feel using a custom protocol would solve. Please feel free to file those. 1059389 32 stuartmorgan 2015-01-07 07:23:36 -0800 > we have decided that since we do not support custom NSURLProtocols as API, there > is no reason to complicate the code further by adding this functionality that no > one will be allowed to use. As noted in comment 12 and comment 27 this bug actually is not specific to NSURLProtocols and is a serious problem for Chromium on iOS without any SPI involved. Would retitling this bug to replace "with a custom NSURLProtocol" with "in navigation delegate callbacks" help change the resolution? 1059421 33 sam 2015-01-07 11:00:44 -0800 (In reply to comment #32) > > we have decided that since we do not support custom NSURLProtocols as API, there > > is no reason to complicate the code further by adding this functionality that no > > one will be allowed to use. > > As noted in comment 12 and comment 27 this bug actually is not specific to > NSURLProtocols and is a serious problem for Chromium on iOS without any SPI > involved. > > Would retitling this bug to replace "with a custom NSURLProtocol" with "in > navigation delegate callbacks" help change the resolution? Absolutely, though at this point, I think filing a new bug about an issue with the navigation delegate callbacks would be ideal, so we can have a cleaner conversation about that there. 1059422 34 sam 2015-01-07 11:01:56 -0800 (In reply to comment #32) > > we have decided that since we do not support custom NSURLProtocols as API, there > > is no reason to complicate the code further by adding this functionality that no > > one will be allowed to use. > > As noted in comment 12 and comment 27 this bug actually is not specific to > NSURLProtocols and is a serious problem for Chromium on iOS without any SPI > involved. > > Would retitling this bug to replace "with a custom NSURLProtocol" with "in > navigation delegate callbacks" help change the resolution? Absolutely, though at this point, I think filing a new bug about an issue with the navigation delegate callbacks would be ideal, so we can have a cleaner conversation about that there. 1059440 35 stuartmorgan 2015-01-07 11:34:38 -0800 (In reply to comment #34) > I think filing a new bug about an issue with the navigation delegate callbacks > would be ideal, so we can have a cleaner conversation about that there. Makes sense, thanks! Filed bug 140188. 239019 2014-10-01 04:21:11 -0700 2014-10-06 04:30:22 -0700 Automatic test case test_case.patch text/plain 3477 danielo RnJvbSA2ZGZjZmU3NjBhNWYzZjk2OWNjOWQwZTZiNmM2ZTc5OGU0MTEwOTk5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5pZWwgTGF6YXJlbmtvIDxkYW5pZWxvQG9wZXJhLmNvbT4K RGF0ZTogV2VkLCAxIE9jdCAyMDE0IDEzOjIwOjI5ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gQnVn IDEzNzI5OTogUE9TVCBpcyBtaXNzaW5nIGEgYm9keSBhZnRlcgogcmVnaXN0ZXJTY2hlbWVGb3JD dXN0b21Qcm90b2NvbAoKdGVzdCBjYXNlCi0tLQogLi4uL1Rlc3RzL1dlYktpdDJPYmpDL0N1c3Rv bVByb3RvY29sc1Rlc3QubW0gICAgICAgfCA1MSArKysrKysrKysrKysrKysrKysrKysrCiAxIGZp bGUgY2hhbmdlZCwgNTEgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVzdC5tbSBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVzdC5tbQppbmRl eCBiN2IzZWQ4Li4wMDFlZGFhIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW0KKysrIGIvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyT2JqQy9DdXN0b21Qcm90b2NvbHNUZXN0Lm1tCkBAIC0zMSwxNSAr MzEsNDIgQEAKICNpbXBvcnQgIlRlc3RQcm90b2NvbC5oIgogI2ltcG9ydCA8V2ViS2l0L1dlYktp dDIuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBvcnQgIldURlN0cmluZ1V0aWxp dGllcy5oIgogCiAjaWYgV0tfQVBJX0VOQUJMRUQKIAogc3RhdGljIGJvb2wgdGVzdEZpbmlzaGVk ID0gZmFsc2U7CiAKKworQGludGVyZmFjZSBXZWJLaXQyQ3VzdG9tUHJvdG9jb2xzVGVzdF9Gb3Jt UG9zdEJvZHlFeGlzdHNQcm90b2NvbCA6IFRlc3RQcm90b2NvbAorQGVuZAorCitAaW1wbGVtZW50 YXRpb24gV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9ybVBvc3RCb2R5RXhpc3RzUHJvdG9j b2wKKworLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoUmVxdWVzdDooTlNVUkxSZXF1ZXN0ICopcmVx dWVzdCBjYWNoZWRSZXNwb25zZTooTlNDYWNoZWRVUkxSZXNwb25zZSAqKWNhY2hlZFJlc3BvbnNl IGNsaWVudDooaWQ8TlNVUkxQcm90b2NvbENsaWVudD4pY2xpZW50Cit7CisgICAgTlNEYXRhICpi b2R5RGF0YSA9IHJlcXVlc3QuSFRUUEJvZHk7CisgICAgRVhQRUNUX05PVF9OVUxMKGJvZHlEYXRh KTsKKyAgICBFWFBFQ1RfTlVMTChyZXF1ZXN0LkhUVFBCb2R5U3RyZWFtKTsKKyAgICBpZiAoYm9k eURhdGEgIT0gbmlsKQorICAgIHsKKyAgICAgICAgUmV0YWluUHRyPE5TU3RyaW5nPiBib2R5ID0g YWRvcHROUyhbW05TU3RyaW5nIGFsbG9jXSBpbml0V2l0aERhdGE6Ym9keURhdGEgZW5jb2Rpbmc6 TlNVVEY4U3RyaW5nRW5jb2RpbmddKTsKKyAgICAgICAgRVhQRUNUX0VRKFN0cmluZygibG9naW49 am9obiIpLCBTdHJpbmcoYm9keS5nZXQoKSkpOworICAgIH0KKyAgICAKKyAgICB0ZXN0RmluaXNo ZWQgPSB0cnVlOworICAgIAorICAgIHJldHVybiBbc3VwZXIgaW5pdFdpdGhSZXF1ZXN0OnJlcXVl c3QgY2FjaGVkUmVzcG9uc2U6Y2FjaGVkUmVzcG9uc2UgY2xpZW50OmNsaWVudF07Cit9CisKK0Bl bmQKKworCiBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CiAKIFRFU1QoV2ViS2l0MkN1c3RvbVBy b3RvY29sc1Rlc3QsIE1haW5SZXNvdXJjZSkKIHsKKyAgICB0ZXN0RmluaXNoZWQgPSBmYWxzZTsK ICAgICBbTlNVUkxQcm90b2NvbCByZWdpc3RlckNsYXNzOltUZXN0UHJvdG9jb2wgY2xhc3NdXTsK ICAgICBbV0tCcm93c2luZ0NvbnRleHRDb250cm9sbGVyIHJlZ2lzdGVyU2NoZW1lRm9yQ3VzdG9t UHJvdG9jb2w6W1Rlc3RQcm90b2NvbCBzY2hlbWVdXTsKIApAQCAtNTQsNiArODEsMzAgQEAgVEVT VChXZWJLaXQyQ3VzdG9tUHJvdG9jb2xzVGVzdCwgTWFpblJlc291cmNlKQogICAgIFV0aWw6OnJ1 bigmdGVzdEZpbmlzaGVkKTsKIH0KIAorVEVTVChXZWJLaXQyQ3VzdG9tUHJvdG9jb2xzVGVzdCwg Rm9ybVBvc3RCb2R5RXhpc3RzKQoreworICAgIHRlc3RGaW5pc2hlZCA9IGZhbHNlOworICAgIFtO U1VSTFByb3RvY29sIHJlZ2lzdGVyQ2xhc3M6W1dlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zv cm1Qb3N0Qm9keUV4aXN0c1Byb3RvY29sIGNsYXNzXV07CisgICAgW1dLQnJvd3NpbmdDb250ZXh0 Q29udHJvbGxlciByZWdpc3RlclNjaGVtZUZvckN1c3RvbVByb3RvY29sOltUZXN0UHJvdG9jb2wg c2NoZW1lXV07CisgICAgCisgICAgUmV0YWluUHRyPFdLUHJvY2Vzc0dyb3VwPiBwcm9jZXNzR3Jv dXAgPSBhZG9wdE5TKFtbV0tQcm9jZXNzR3JvdXAgYWxsb2NdIGluaXRdKTsKKyAgICBSZXRhaW5Q dHI8V0tCcm93c2luZ0NvbnRleHRHcm91cD4gYnJvd3NpbmdDb250ZXh0R3JvdXAgPSBhZG9wdE5T KFtbV0tCcm93c2luZ0NvbnRleHRHcm91cCBhbGxvY10gaW5pdFdpdGhJZGVudGlmaWVyOkAiVGVz dElkZW50aWZpZXIiXSk7CisgICAgUmV0YWluUHRyPFdLVmlldz4gd2tWaWV3ID0gYWRvcHROUyhb W1dLVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU01ha2VSZWN0KDAsIDAsIDgwMCwgNjAwKSBw cm9jZXNzR3JvdXA6cHJvY2Vzc0dyb3VwLmdldCgpIGJyb3dzaW5nQ29udGV4dEdyb3VwOmJyb3dz aW5nQ29udGV4dEdyb3VwLmdldCgpXSk7CisKKyAgICBOU1VSTCAqdXJsID0gW05TVVJMIFVSTFdp dGhTdHJpbmc6W05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIlQDovL0Zvcm1Qb3N0Qm9keUV4 aXN0cyIsIFtUZXN0UHJvdG9jb2wgc2NoZW1lXV1dOworICAgIE5TU3RyaW5nICpodG1sID0gW05T U3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCI8aHRtbD48Ym9keSBvbmxvYWQ9XCJkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgnZicpLnN1Ym1pdCgpXCI+PGZvcm0gaWQ9XCJmXCIgYWN0aW9uPVwiJUBc IiBtZXRob2Q9XCJwb3N0XCI+PGlucHV0IG5hbWU9XCJsb2dpblwiIHZhbHVlPVwiam9oblwiIC8+ PC9mb3JtPjwvYm9keT48L2h0bWw+IiwgdXJsLmFic29sdXRlU3RyaW5nXTsKKyAgICBbd2tWaWV3 LmdldCgpLmJyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgbG9hZEhUTUxTdHJpbmc6aHRtbCBiYXNl VVJMOm5pbF07CisgICAgCisgICAgVXRpbDo6cnVuKCZ0ZXN0RmluaXNoZWQpOworICAgIFtOU1VS TFByb3RvY29sIHVucmVnaXN0ZXJDbGFzczpbV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9y bVBvc3RCb2R5RXhpc3RzUHJvdG9jb2wgY2xhc3NdXTsKKyAgICBbV0tCcm93c2luZ0NvbnRleHRD b250cm9sbGVyIHVucmVnaXN0ZXJTY2hlbWVGb3JDdXN0b21Qcm90b2NvbDpbVGVzdFByb3RvY29s IHNjaGVtZV1dOworfQorCisgICAgCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCiAKKwor CisKKwogI2VuZGlmIC8vIFdLX0FQSV9FTkFCTEVECi0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 239328 2014-10-06 04:30:31 -0700 2014-10-28 08:03:12 -0700 Patch bug-137299-20141006133233.patch text/plain 6968 danielo U3VidmVyc2lvbiBSZXZpc2lvbjogMTc0MTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMWMxMzQ0NzVlYTU3M2Uw NjMwY2U4OGE0Yzg1NTNmMTEzYzIzZWQ0YS4uYTUwZDY5ZDE1MWY5N2Q3MmJmYjZmYTBhMGFmYWZl NDZkYzAyNWQ5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE0LTEwLTA2ICBEYW5p ZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+CisKKyAgICAgICAgQWxsb3cgSFRUUCBQ T1NUIGJvZHkgdG8gYmUgc2VudCBvdmVyIElQQworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM3Mjk5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgVGhpcyBsZXRzIHVzaW5nIGEgY3VzdG9tIE5TVVJMUHJvdG9j b2wgaW4gdGhlIFVJIHByb2Nlc3MKKyAgICAgICAgdG8gaGFuZGxlIFBPU1QgcmVxdWVzdHMgd2l0 aCBmb3JtIHBhcmFtZXRlcnMuCisKKyAgICAgICAgKiBTaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVu dENvZGVyc01hYy5tbToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVl c3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEpOgorCiAyMDE0LTA5LTMwICBHeXV5b3VuZyBLaW0gIDxn eXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVuYW1lIFRFU1RfVEhF TUVfRElSIG1hY3JvCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNv cmVBcmd1bWVudENvZGVyc01hYy5tbSBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29y ZUFyZ3VtZW50Q29kZXJzTWFjLm1tCmluZGV4IGY0YWRkODU3MjhhZTBmYjQ4MjgyNGFiYmM1M2I5 NDg4ZmMxY2E5YmUuLjYyZDUyNGM4ODlhN2U3MmNjNGM4NTJkM2U4ZTE0NGM2MzY2ODQ3NWYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29kZXJz TWFjLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29k ZXJzTWFjLm1tCkBAIC01NywxNCArNTcsMTIgQEAgdm9pZCBBcmd1bWVudENvZGVyPFJlc291cmNl UmVxdWVzdD46OmVuY29kZVBsYXRmb3JtRGF0YShBcmd1bWVudEVuY29kZXImIGVuY29kZXIKICAg ICBpZiAoIXJlcXVlc3RJc1ByZXNlbnQpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8vIFdlIGRv bid0IHNlbmQgSFRUUCBib2R5IG92ZXIgSVBDIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCi0gICAg Ly8gQWxzbywgaXQncyBub3QgYWx3YXlzIHBvc3NpYmxlIHRvIGRvLCBhcyBzdHJlYW1zIGNhbiBv bmx5IGJlIGNyZWF0ZWQgaW4gcHJvY2VzcyB0aGF0IGRvZXMgbmV0d29ya2luZy4KLSAgICBSZXRh aW5QdHI8Q0ZEYXRhUmVmPiByZXF1ZXN0SFRUUEJvZHkgPSBhZG9wdENGKENGVVJMUmVxdWVzdENv cHlIVFRQUmVxdWVzdEJvZHkocmVxdWVzdFRvU2VyaWFsaXplLmdldCgpKSk7CisgICAgLy8gV2Ug ZG9uJ3Qgc2VuZCBIVFRQIGJvZHkgc3RyZWFtIG92ZXIgSVBDLAorICAgIC8vIGJlY2F1c2Ugc3Ry ZWFtIHByb3h5aW5nIGlzIG5vdCBpbXBsZW1lbnRlZCwgc3RyZWFtcyBjYW4gb25seSBiZSBjcmVh dGVkIGluIHByb2Nlc3MgdGhhdCBkb2VzIG5ldHdvcmtpbmcuCiAgICAgUmV0YWluUHRyPENGUmVh ZFN0cmVhbVJlZj4gcmVxdWVzdEhUVFBCb2R5U3RyZWFtID0gYWRvcHRDRihDRlVSTFJlcXVlc3RD b3B5SFRUUFJlcXVlc3RCb2R5U3RyZWFtKHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSkpOwotICAg IGlmIChyZXF1ZXN0SFRUUEJvZHkgfHwgcmVxdWVzdEhUVFBCb2R5U3RyZWFtKSB7CisgICAgaWYg KHJlcXVlc3RIVFRQQm9keVN0cmVhbSkgewogICAgICAgICBDRk11dGFibGVVUkxSZXF1ZXN0UmVm IG11dGFibGVSZXF1ZXN0ID0gQ0ZVUkxSZXF1ZXN0Q3JlYXRlTXV0YWJsZUNvcHkoMCwgcmVxdWVz dFRvU2VyaWFsaXplLmdldCgpKTsKICAgICAgICAgcmVxdWVzdFRvU2VyaWFsaXplID0gYWRvcHRD RihtdXRhYmxlUmVxdWVzdCk7Ci0gICAgICAgIENGVVJMUmVxdWVzdFNldEhUVFBSZXF1ZXN0Qm9k eShtdXRhYmxlUmVxdWVzdCwgbmlsKTsKICAgICAgICAgQ0ZVUkxSZXF1ZXN0U2V0SFRUUFJlcXVl c3RCb2R5U3RyZWFtKG11dGFibGVSZXF1ZXN0LCBuaWwpOwogICAgIH0KIApAQCAtODUsMTEgKzgz LDEwIEBAIHZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9y bURhdGEoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyCiAgICAgaWYgKCFyZXF1ZXN0SXNQcmVzZW50 KQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBXZSBkb24ndCBzZW5kIEhUVFAgYm9keSBvdmVy IElQQyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgotICAgIC8vIEFsc28sIGl0J3Mgbm90IGFsd2F5 cyBwb3NzaWJsZSB0byBkbywgYXMgc3RyZWFtcyBjYW4gb25seSBiZSBjcmVhdGVkIGluIHByb2Nl c3MgdGhhdCBkb2VzIG5ldHdvcmtpbmcuCi0gICAgaWYgKFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRU UEJvZHldIHx8IFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHlTdHJlYW1dKSB7CisgICAgLy8g V2UgZG9uJ3Qgc2VuZCBIVFRQIGJvZHkgc3RyZWFtIG92ZXIgSVBDLAorICAgIC8vIGJlY2F1c2Ug c3RyZWFtIHByb3h5aW5nIGlzIG5vdCBpbXBsZW1lbnRlZCwgc3RyZWFtcyBjYW4gb25seSBiZSBj cmVhdGVkIGluIHByb2Nlc3MgdGhhdCBkb2VzIG5ldHdvcmtpbmcuCisgICAgaWYgKFtyZXF1ZXN0 VG9TZXJpYWxpemUgSFRUUEJvZHlTdHJlYW1dKSB7CiAgICAgICAgIHJlcXVlc3RUb1NlcmlhbGl6 ZSA9IGFkb3B0TlMoW3JlcXVlc3RUb1NlcmlhbGl6ZSBtdXRhYmxlQ29weV0pOwotICAgICAgICBb KE5TTXV0YWJsZVVSTFJlcXVlc3QgKilyZXF1ZXN0VG9TZXJpYWxpemUgc2V0SFRUUEJvZHk6bmls XTsKICAgICAgICAgWyhOU011dGFibGVVUkxSZXF1ZXN0ICopcmVxdWVzdFRvU2VyaWFsaXplIHNl dEhUVFBCb2R5U3RyZWFtOm5pbF07CiAgICAgfQogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VM b2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYzg1OTQ0OWEzYjY1MmY0MDBiOWUxNDg4Y2U1OTc4 MTFlNDcwNTRhMC4uNDM4ZDhmOWJhY2ZiOTY2ZDA1YTZkZTA2MmVjYjI3ZDcxYmFiODc2MCAxMDA2 NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsx LDE0IEBACisyMDE0LTEwLTA2ICBEYW5pZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+ CisKKyAgICAgICAgVGVzdCBjYXNlIGZvciB1c2luZyBIVFRQIFBPU1Qgd2l0aCBhIGN1c3RvbSBO U1VSTFByb3RvY29sCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMzcyOTkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVz dC5tbToKKyAgICAgICAgKC1bV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9ybVBvc3RCb2R5 RXhpc3RzUHJvdG9jb2wgaW5pdFdpdGhSZXF1ZXN0OmNhY2hlZFJlc3BvbnNlOmNsaWVudDpdKToK KyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE0LTA5LTMwICBFdmEgQmFsYXpz ZmFsdmkgIDxldmFiLnUtc3plZ2VkQHBhcnRuZXIuc2Ftc3VuZy5jb20+CiAKICAgICAgICAgUmVt b3ZlIHRoaXJkcGFydHkvdW5pdHRlc3QyIGZyb20gd2Via2l0cHkKZGlmZiAtLWdpdCBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVzdC5tbSBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVz dC5tbQppbmRleCBiN2IzZWQ4YmUwMTI0NDEzOTFhODNkYTlkZTY3YTYyMzdiYmQ3YmIzLi41OTEy YmExODgxZmVlOTUzNWFmYmQ5YWE4ZTFlZjlkYjljMzM1ZmY1IDEwMDY0NAotLS0gYS9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW0KKysr IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyT2JqQy9DdXN0b21Qcm90b2NvbHNU ZXN0Lm1tCkBAIC0zMSwxNSArMzEsNDEgQEAKICNpbXBvcnQgIlRlc3RQcm90b2NvbC5oIgogI2lt cG9ydCA8V2ViS2l0L1dlYktpdDIuaD4KICNpbXBvcnQgPHd0Zi9SZXRhaW5QdHIuaD4KKyNpbXBv cnQgIldURlN0cmluZ1V0aWxpdGllcy5oIgogCiAjaWYgV0tfQVBJX0VOQUJMRUQKIAogc3RhdGlj IGJvb2wgdGVzdEZpbmlzaGVkID0gZmFsc2U7CiAKKworQGludGVyZmFjZSBXZWJLaXQyQ3VzdG9t UHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCA6IFRlc3RQcm90b2NvbAor QGVuZAorCitAaW1wbGVtZW50YXRpb24gV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9ybVBv c3RCb2R5RXhpc3RzUHJvdG9jb2wKKworLSAoaW5zdGFuY2V0eXBlKWluaXRXaXRoUmVxdWVzdDoo TlNVUkxSZXF1ZXN0ICopcmVxdWVzdCBjYWNoZWRSZXNwb25zZTooTlNDYWNoZWRVUkxSZXNwb25z ZSAqKWNhY2hlZFJlc3BvbnNlIGNsaWVudDooaWQ8TlNVUkxQcm90b2NvbENsaWVudD4pY2xpZW50 Cit7CisgICAgTlNEYXRhICpib2R5RGF0YSA9IHJlcXVlc3QuSFRUUEJvZHk7CisgICAgRVhQRUNU X05PVF9OVUxMKGJvZHlEYXRhKTsKKyAgICBFWFBFQ1RfTlVMTChyZXF1ZXN0LkhUVFBCb2R5U3Ry ZWFtKTsKKyAgICBpZiAoYm9keURhdGEgIT0gbmlsKSB7CisgICAgICAgIFJldGFpblB0cjxOU1N0 cmluZz4gYm9keSA9IGFkb3B0TlMoW1tOU1N0cmluZyBhbGxvY10gaW5pdFdpdGhEYXRhOmJvZHlE YXRhIGVuY29kaW5nOk5TVVRGOFN0cmluZ0VuY29kaW5nXSk7CisgICAgICAgIEVYUEVDVF9FUShT dHJpbmcoImxvZ2luPWpvaG4iKSwgU3RyaW5nKGJvZHkuZ2V0KCkpKTsKKyAgICB9CisKKyAgICB0 ZXN0RmluaXNoZWQgPSB0cnVlOworCisgICAgcmV0dXJuIFtzdXBlciBpbml0V2l0aFJlcXVlc3Q6 cmVxdWVzdCBjYWNoZWRSZXNwb25zZTpjYWNoZWRSZXNwb25zZSBjbGllbnQ6Y2xpZW50XTsKK30K KworQGVuZAorCisKIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKIAogVEVTVChXZWJLaXQyQ3Vz dG9tUHJvdG9jb2xzVGVzdCwgTWFpblJlc291cmNlKQogeworICAgIHRlc3RGaW5pc2hlZCA9IGZh bHNlOwogICAgIFtOU1VSTFByb3RvY29sIHJlZ2lzdGVyQ2xhc3M6W1Rlc3RQcm90b2NvbCBjbGFz c11dOwogICAgIFtXS0Jyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgcmVnaXN0ZXJTY2hlbWVGb3JD dXN0b21Qcm90b2NvbDpbVGVzdFByb3RvY29sIHNjaGVtZV1dOwogCkBAIC01NCw2ICs4MCwyNSBA QCBURVNUKFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0LCBNYWluUmVzb3VyY2UpCiAgICAgVXRp bDo6cnVuKCZ0ZXN0RmluaXNoZWQpOwogfQogCitURVNUKFdlYktpdDJDdXN0b21Qcm90b2NvbHNU ZXN0LCBGb3JtUG9zdEJvZHlFeGlzdHMpCit7CisgICAgdGVzdEZpbmlzaGVkID0gZmFsc2U7Cisg ICAgW05TVVJMUHJvdG9jb2wgcmVnaXN0ZXJDbGFzczpbV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rl c3RfRm9ybVBvc3RCb2R5RXhpc3RzUHJvdG9jb2wgY2xhc3NdXTsKKyAgICBbV0tCcm93c2luZ0Nv bnRleHRDb250cm9sbGVyIHJlZ2lzdGVyU2NoZW1lRm9yQ3VzdG9tUHJvdG9jb2w6W1Rlc3RQcm90 b2NvbCBzY2hlbWVdXTsKKworICAgIFJldGFpblB0cjxXS1Byb2Nlc3NHcm91cD4gcHJvY2Vzc0dy b3VwID0gYWRvcHROUyhbW1dLUHJvY2Vzc0dyb3VwIGFsbG9jXSBpbml0XSk7CisgICAgUmV0YWlu UHRyPFdLQnJvd3NpbmdDb250ZXh0R3JvdXA+IGJyb3dzaW5nQ29udGV4dEdyb3VwID0gYWRvcHRO UyhbW1dLQnJvd3NpbmdDb250ZXh0R3JvdXAgYWxsb2NdIGluaXRXaXRoSWRlbnRpZmllcjpAIlRl c3RJZGVudGlmaWVyIl0pOworICAgIFJldGFpblB0cjxXS1ZpZXc+IHdrVmlldyA9IGFkb3B0TlMo W1tXS1ZpZXcgYWxsb2NdIGluaXRXaXRoRnJhbWU6TlNNYWtlUmVjdCgwLCAwLCA4MDAsIDYwMCkg cHJvY2Vzc0dyb3VwOnByb2Nlc3NHcm91cC5nZXQoKSBicm93c2luZ0NvbnRleHRHcm91cDpicm93 c2luZ0NvbnRleHRHcm91cC5nZXQoKV0pOworCisgICAgTlNVUkwgKnVybCA9IFtOU1VSTCBVUkxX aXRoU3RyaW5nOltOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJUA6Ly9Gb3JtUG9zdEJvZHlF eGlzdHMiLCBbVGVzdFByb3RvY29sIHNjaGVtZV1dXTsKKyAgICBOU1N0cmluZyAqaHRtbCA9IFtO U1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiPGh0bWw+PGJvZHkgb25sb2FkPVwiZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2YnKS5zdWJtaXQoKVwiPjxmb3JtIGlkPVwiZlwiIGFjdGlvbj1cIiVA XCIgbWV0aG9kPVwicG9zdFwiPjxpbnB1dCBuYW1lPVwibG9naW5cIiB2YWx1ZT1cImpvaG5cIiAv PjwvZm9ybT48L2JvZHk+PC9odG1sPiIsIHVybC5hYnNvbHV0ZVN0cmluZ107CisgICAgW3drVmll dy5nZXQoKS5icm93c2luZ0NvbnRleHRDb250cm9sbGVyIGxvYWRIVE1MU3RyaW5nOmh0bWwgYmFz ZVVSTDpuaWxdOworCisgICAgVXRpbDo6cnVuKCZ0ZXN0RmluaXNoZWQpOworICAgIFtOU1VSTFBy b3RvY29sIHVucmVnaXN0ZXJDbGFzczpbV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9ybVBv c3RCb2R5RXhpc3RzUHJvdG9jb2wgY2xhc3NdXTsKKyAgICBbV0tCcm93c2luZ0NvbnRleHRDb250 cm9sbGVyIHVucmVnaXN0ZXJTY2hlbWVGb3JDdXN0b21Qcm90b2NvbDpbVGVzdFByb3RvY29sIHNj aGVtZV1dOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCiAKICNlbmRpZiAvLyBX S19BUElfRU5BQkxFRAo= 239465 2014-10-08 03:46:21 -0700 2014-10-28 08:03:23 -0700 patch part 2 patch text/plain 22224 danielo RnJvbSBhZmY1YzEzMTg0MGI5OGJkMjg0MTc5M2Y1ZjAyYjViOGVmZjJhZTU0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5pZWwgTGF6YXJlbmtvIDxkYW5pZWxvQG9wZXJhLmNvbT4K RGF0ZTogV2VkLCA4IE9jdCAyMDE0IDExOjA0OjI3ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gQnVn IDEzNzI5OTogUE9TVCBpcyBtaXNzaW5nIGEgYm9keSBhZnRlcgogcmVnaXN0ZXJTY2hlbWVGb3JD dXN0b21Qcm90b2NvbCAocGFydCAyKQoKQWRkIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdFdpdGhC b2R5IC0gYSBSZXNvdXJjZVJlcXVlc3Qgd3JhcHBlcgp0byBlbmNvZGUgUmVzb3VyY2VSZXF1ZXN0 IGZvciBJUEMgcHJlc2VydmluZyB0aGUgcmVxdWVzdCBIVFRQIGJvZHkuCgpSZXNvdXJjZVJlcXVl c3RXaXRoQm9keSBpcyBvbmx5IHVzZWQgZm9yCkN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpT dGFydExvYWRpbmcgbWVzc2FnZS4KSW4gb3RoZXIgY2FzZXMgdGhlIEhUVFAgYm9keSBpcyBzdHJp cHBlZC4KClJlZmFjdG9yIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlUGxh dGZvcm1EYXRhCmluIG9yZGVyIHRvIHJlbW92ZSBkdXBsaWNhdGUgY29kZS4KLS0tCiBTb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogICB8ICA0ICsrCiAuLi4v cGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oICAgICB8IDYwICsrKysr KysrKysrKysrKysKIC4uLi9Db2NvYS9DdXN0b21Qcm90b2NvbE1hbmFnZXJDb2NvYS5tbSAgICAg ICAgICAgIHwgIDQgKy0KIFNvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2Rl cnMuY3BwICAgIHwgMjYgKysrKysrLQogU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1 bWVudENvZGVycy5oICAgICAgfCAxMCArKysKIC4uLi9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29y ZUFyZ3VtZW50Q29kZXJzTWFjLm1tIHwgODQgKysrKysrKysrKysrKystLS0tLS0tLQogLi4uL0N1 c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5oICAgfCAgNCArLQogLi4u L0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5Lm1lc3NhZ2VzLmluICAgICAgICAgfCAgMiArLQog Li4uL21hYy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eU1hYy5tbSAgICAgICAgICAgfCAgNCAr LQogOSBmaWxlcyBjaGFuZ2VkLCAxNjEgaW5zZXJ0aW9ucygrKSwgMzcgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZVJlcXVlc3RXaXRoQm9keS5oCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGQ1NDNkNzkuLjY1N2Y5OTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTYxOTMsNiAr NjE5Myw3IEBACiAJCUU1MjZBRjNGMTcyN0Y4RjIwMEU0MTc4MSAvKiBQZXJmb3JtYW5jZS5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNTI2QUYzRTE3 MjdGOEYyMDBFNDE3ODEgLyogUGVyZm9ybWFuY2UuY3BwICovOyB9OwogCQlFNTVGNDk3QTE1MUI4 ODgwMDBCQjY3REIgLyogTGVuZ3RoRnVuY3Rpb25zLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU1NUY0OTc5MTUxQjg4ODAwMEJCNjdEQiAvKiBMZW5n dGhGdW5jdGlvbnMuY3BwICovOyB9OwogCQlFNUJBN0Q2MzE1MTQzN0NBMDBGRTFFM0YgLyogTGVu Z3RoRnVuY3Rpb25zLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBFNUJBN0Q2MjE1MTQzN0NBMDBGRTFFM0YgLyogTGVuZ3RoRnVuY3Rpb25zLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJRTY2NkVGRUYxOUU1 MkExNDAwNjkyNkNEIC8qIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNjY2RUZFRTE5RTUyMUJDMDA2OTI2Q0Qg LyogUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9 IChQcml2YXRlLCApOyB9OyB9OwogCQlFQkY1MTIxQzE2OTY0OTZDMDA1NkJEMjUgLyogSlNUeXBl Q29udmVyc2lvbnMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRUJGNTEyMUExNjk2NDk2QzAwNTZCRDI1IC8qIEpTVHlwZUNvbnZlcnNpb25zLmNwcCAq LzsgfTsKIAkJRUJGNTEyMUQxNjk2NDk2QzAwNTZCRDI1IC8qIEpTVHlwZUNvbnZlcnNpb25zLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFQkY1MTIxQjE2 OTY0OTZDMDA1NkJEMjUgLyogSlNUeXBlQ29udmVyc2lvbnMuaCAqLzsgfTsKIAkJRUQyQkE4M0Mw OUEyNEI5MTAwNkMwQUM0IC8qIERvY3VtZW50TWFya2VyLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFRDJCQTgzQjA5QTI0QjkxMDA2QzBBQzQgLyogRG9j dW1lbnRNYXJrZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwpAQCAtMTM3MDMsNiArMTM3MDQsNyBAQAogCQlFNTI2QUYzRTE3MjdGOEYyMDBFNDE3ODEg LyogUGVyZm9ybWFuY2UuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g UGVyZm9ybWFuY2UuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFNTVGNDk3OTE1 MUI4ODgwMDBCQjY3REIgLyogTGVuZ3RoRnVuY3Rpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IExlbmd0aEZ1bmN0aW9ucy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUU1QkE3RDYyMTUxNDM3Q0EwMEZFMUUzRiAvKiBMZW5ndGhGdW5jdGlvbnMu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoRnVuY3Rpb25zLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUU2NjZFRkVFMTlFNTIxQkMwMDY5MjZDRCAvKiBS ZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlFQjA4MUNEODE2OTYwODQ0MDA1NTM3MzAgLyogVHlwZUNvbnZlcnNpb25zLmggKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IFR5cGVDb252ZXJzaW9ucy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlF QjA4MUNEOTE2OTYwODQ0MDA1NTM3MzAgLyogVHlwZUNvbnZlcnNpb25zLmlkbCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBUeXBl Q29udmVyc2lvbnMuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlFQkY1MTIxQTE2 OTY0OTZDMDA1NkJEMjUgLyogSlNUeXBlQ29udmVyc2lvbnMuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gSlNUeXBlQ29udmVyc2lvbnMuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwpAQCAtMTYzMzAsNiArMTYzMzIsNyBAQAogCQkJCThBODFCRjg0MTFEQ0ZE OTAwMERBMkI5OCAvKiBSZXNvdXJjZUxvYWRUaW1pbmcuaCAqLywKIAkJCQk1MTRDNzY2NzBDRTky M0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VSZXF1ZXN0QmFzZS5jcHAgKi8sCiAJCQkJNTE0Qzc2Njgw Q0U5MjNBMTAwN0VGM0NEIC8qIFJlc291cmNlUmVxdWVzdEJhc2UuaCAqLywKKwkJCQlFNjY2RUZF RTE5RTUyMUJDMDA2OTI2Q0QgLyogUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaCAqLywKIAkJCQk1 MTRDNzY2OTBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VSZXNwb25zZUJhc2UuY3BwICovLAog CQkJCTUxNEM3NjZBMENFOTIzQTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlc3BvbnNlQmFzZS5oICov LAogCQkJCTUxMEQ0QTJEMTAzMTY1RUUwMDQ5RUE1NCAvKiBTb2NrZXRTdHJlYW1FcnJvckJhc2Uu Y3BwICovLApAQCAtMjU3MzYsNiArMjU3MzksNyBAQAogCQkJCTdFRTY4NDZEMTJEMjZFMzgwMEU3 OTQxNSAvKiBSZXNvdXJjZVJlcXVlc3QuaCBpbiBIZWFkZXJzICovLAogCQkJCTUxNEM3NjdEMENF OTIzQTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlcXVlc3RCYXNlLmggaW4gSGVhZGVycyAqLywKIAkJ CQk3RUU2ODQ2RjEyRDI2RTM4MDBFNzk0MTUgLyogUmVzb3VyY2VSZXF1ZXN0Q0ZOZXQuaCBpbiBI ZWFkZXJzICovLAorCQkJCUU2NjZFRkVGMTlFNTJBMTQwMDY5MjZDRCAvKiBSZXNvdXJjZVJlcXVl c3RXaXRoQm9keS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJN0VFNjg0NzAxMkQyNkUzODAwRTc5NDE1 IC8qIFJlc291cmNlUmVzcG9uc2UuaCBpbiBIZWFkZXJzICovLAogCQkJCTUxNEM3NjdGMENFOTIz QTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlc3BvbnNlQmFzZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJ RkQzMTYwQTUxMkIwMjZGNzAwQzFBMzU5IC8qIFJldmVyYi5oIGluIEhlYWRlcnMgKi8sCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdFdp dGhCb2R5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVz dFdpdGhCb2R5LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWI2YjViZQot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VSZXF1ZXN0V2l0aEJvZHkuaApAQCAtMCwwICsxLDYwIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDE0IERhbmllbCBMYXphcmVua28gKGRhbmllbG9Ab3BlcmEuY29tKQorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRS SUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJ VFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aWZuZGVmIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5X2gKKyNkZWZpbmUgUmVzb3VyY2VSZXF1ZXN0 V2l0aEJvZHlfaAorCisjaWYgRU5BQkxFKENVU1RPTV9QUk9UT0NPTFMpCisKKyNpbmNsdWRlICJS ZXNvdXJjZVJlcXVlc3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBSZXNvdXJj ZVJlcXVlc3RXaXRoQm9keQoreworICAgIFJlc291cmNlUmVxdWVzdCBtX3JlcXVlc3Q7CitwdWJs aWM6CisgICAgUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkoKSB7fQorICAgIFJlc291cmNlUmVxdWVz dFdpdGhCb2R5KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkgOiBtX3JlcXVlc3QocmVx dWVzdCkge30KKyAgICBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QoKSBjb25zdCB7IHJl dHVybiBtX3JlcXVlc3Q7IH0KKworI2lmIEVOQUJMRShDQUNIRV9QQVJUSVRJT05JTkcpCisgICAg Y29uc3QgU3RyaW5nJiBjYWNoZVBhcnRpdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fcmVxdWVzdC5j YWNoZVBhcnRpdGlvbigpOyB9CisjZW5kaWYKKyNpZiBFTkFCTEUoSU5TUEVDVE9SKQorICAgIC8v IFdoZXRoZXIgdGhpcyByZXF1ZXN0IHNob3VsZCBiZSBoaWRkZW4gZnJvbSB0aGUgSW5zcGVjdG9y LgorICAgIGJvb2wgaGlkZGVuRnJvbUluc3BlY3RvcigpIGNvbnN0IHsgcmV0dXJuIG1fcmVxdWVz dC5oaWRkZW5Gcm9tSW5zcGVjdG9yKCk7IH0KKyNlbmRpZgorICAgIGJvb2wgZW5jb2RpbmdSZXF1 aXJlc1BsYXRmb3JtRGF0YSgpIGNvbnN0IHsgcmV0dXJuIG1fcmVxdWVzdC5lbmNvZGluZ1JlcXVp cmVzUGxhdGZvcm1EYXRhKCk7IH0KKworICAgIHRlbXBsYXRlPGNsYXNzIEVuY29kZXI+IHZvaWQg ZW5jb2RlV2l0aG91dFBsYXRmb3JtRGF0YShFbmNvZGVyJiBlKSBjb25zdCB7IG1fcmVxdWVzdC5l bmNvZGVXaXRob3V0UGxhdGZvcm1EYXRhKGUpOyB9CisKK307CisKK307IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoQ1VTVE9NX1BST1RPQ09MUykKKworI2VuZGlmIC8v IFJlc291cmNlUmVxdWVzdFdpdGhCb2R5X2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9Db2NvYS9DdXN0b21Qcm90b2NvbE1hbmFnZXJD b2NvYS5tbSBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9D b2NvYS9DdXN0b21Qcm90b2NvbE1hbmFnZXJDb2NvYS5tbQppbmRleCBmZmI0ZDFlLi5jMDQwOWY1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmV0d29yay9DdXN0b21Qcm90b2Nv bHMvQ29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2EubW0KKysrIGIvU291cmNlL1dlYktp dDIvU2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0NvY29hL0N1c3RvbVByb3RvY29sTWFu YWdlckNvY29hLm1tCkBAIC0zNyw2ICszNyw3IEBACiAjaW1wb3J0IDxXZWJDb3JlL1VSTC5oPgog I2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZUVycm9yLmg+CiAjaW1wb3J0IDxXZWJDb3JlL1Jlc291 cmNlUmVxdWVzdC5oPgorI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5o PgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZVJlc3BvbnNlLmg+CiAKICNpZiBFTkFCTEUoTkVU V09SS19QUk9DRVNTKQpAQCAtMTA2LDcgKzEwNyw4IEBAIHN0YXRpYyB1aW50NjRfdCBnZW5lcmF0 ZUN1c3RvbVByb3RvY29sSUQoKQogCiAtICh2b2lkKXN0YXJ0TG9hZGluZwogewotICAgIHNoYXJl ZEN1c3RvbVByb3RvY29sTWFuYWdlci0+Y2hpbGRQcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6OkN1 c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFydExvYWRpbmcoc2VsZi5jdXN0b21Qcm90b2Nv bElELCBbc2VsZiByZXF1ZXN0XSksIDApOworICAgIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdFdp dGhCb2R5IGNvcmVSZXF1ZXN0V2l0aEJvZHkoW3NlbGYgcmVxdWVzdF0pOworICAgIHNoYXJlZEN1 c3RvbVByb3RvY29sTWFuYWdlci0+Y2hpbGRQcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6OkN1c3Rv bVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFydExvYWRpbmcoc2VsZi5jdXN0b21Qcm90b2NvbElE LCBjb3JlUmVxdWVzdFdpdGhCb2R5KSwgMCk7CiB9CiAKIC0gKHZvaWQpc3RvcExvYWRpbmcKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuY3Bw IGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5jcHAKaW5kZXgg Y2RmYTcwZi4uMWE3MGQyMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNv cmVBcmd1bWVudENvZGVycy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVB cmd1bWVudENvZGVycy5jcHAKQEAgLTU0LDYgKzU0LDcgQEAKICNpbmNsdWRlIDxXZWJDb3JlL1Jl Z2lvbi5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VFcnJvci5oPgogI2luY2x1ZGUgPFdl YkNvcmUvUmVzb3VyY2VSZXF1ZXN0Lmg+CisjaW5jbHVkZSA8V2ViQ29yZS9SZXNvdXJjZVJlcXVl c3RXaXRoQm9keS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VSZXNwb25zZS5oPgogI2lu Y2x1ZGUgPFdlYkNvcmUvU2Nyb2xsaW5nQ29uc3RyYWludHMuaD4KICNpbmNsdWRlIDxXZWJDb3Jl L1Njcm9sbGluZ0Nvb3JkaW5hdG9yLmg+CkBAIC03MDEsNyArNzAyLDggQEAgYm9vbCBBcmd1bWVu dENvZGVyPEN1cnNvcj46OmRlY29kZShBcmd1bWVudERlY29kZXImIGRlY29kZXIsIEN1cnNvciYg Y3Vyc29yKQogfQogI2VuZGlmCiAKLXZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+ OjplbmNvZGUoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlc291cmNlUmVxdWVzdCkKK3RlbXBsYXRlPGNsYXNzIFRSZXNvdXJjZVJlcXVlc3Q+Cit2b2lk IEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50KEFyZ3VtZW50RW5jb2RlciYgZW5jb2Rlciwg Y29uc3QgVFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQogewogI2lmIEVOQUJMRShD QUNIRV9QQVJUSVRJT05JTkcpCiAgICAgZW5jb2RlciA8PCByZXNvdXJjZVJlcXVlc3QuY2FjaGVQ YXJ0aXRpb24oKTsKQEAgLTcxMywxMyArNzE1LDE4IEBAIHZvaWQgQXJndW1lbnRDb2RlcjxSZXNv dXJjZVJlcXVlc3Q+OjplbmNvZGUoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNv CiAKICAgICBpZiAocmVzb3VyY2VSZXF1ZXN0LmVuY29kaW5nUmVxdWlyZXNQbGF0Zm9ybURhdGEo KSkgewogICAgICAgICBlbmNvZGVyIDw8IHRydWU7Ci0gICAgICAgIGVuY29kZVBsYXRmb3JtRGF0 YShlbmNvZGVyLCByZXNvdXJjZVJlcXVlc3QpOworICAgICAgICBBcmd1bWVudENvZGVyPFRSZXNv dXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0 KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICBlbmNvZGVyIDw8IGZhbHNlOwogICAgIHJl c291cmNlUmVxdWVzdC5lbmNvZGVXaXRob3V0UGxhdGZvcm1EYXRhKGVuY29kZXIpOwogfQogCit2 b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlKEFyZ3VtZW50RW5jb2Rl ciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCit7Cisg ICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnQoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0 KTsKK30KKwogYm9vbCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmRlY29kZShBcmd1 bWVudERlY29kZXImIGRlY29kZXIsIFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQog ewogI2lmIEVOQUJMRShDQUNIRV9QQVJUSVRJT05JTkcpCkBAIC03NDUsNiArNzUyLDIxIEBAIGJv b2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjpkZWNvZGUoQXJndW1lbnREZWNvZGVy JiBkZWNvZGVyLCBSZXNvdXJjZVJlCiAgICAgcmV0dXJuIHJlc291cmNlUmVxdWVzdC5kZWNvZGVX aXRob3V0UGxhdGZvcm1EYXRhKGRlY29kZXIpOwogfQogCisjaWYgRU5BQkxFKENVU1RPTV9QUk9U T0NPTFMpCisKK3ZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3RXaXRoQm9keT46OmVu Y29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlUmVxdWVzdFdpdGhC b2R5JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1l bnQoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0KTsKK30KKworYm9vbCBBcmd1bWVudENvZGVyPFJl c291cmNlUmVxdWVzdFdpdGhCb2R5Pjo6ZGVjb2RlKEFyZ3VtZW50RGVjb2RlciYgZGVjb2Rlciwg UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBSZXNvdXJj ZVJlcXVlc3QmIHJlcXVlc3QgPSBjb25zdF9jYXN0PFJlc291cmNlUmVxdWVzdCY+KHJlc291cmNl UmVxdWVzdC5yZXF1ZXN0KCkpOworICAgIHJldHVybiBBcmd1bWVudENvZGVyPFJlc291cmNlUmVx dWVzdD46OmRlY29kZShkZWNvZGVyLCByZXF1ZXN0KTsKK30KKworI2VuZGlmIC8vIEVOQUJMRShD VVNUT01fUFJPVE9DT0xTKQorCiB2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VFcnJvcj46OmVu Y29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlRXJyb3ImIHJlc291 cmNlRXJyb3IpCiB7CiAgICAgZW5jb2RlUGxhdGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlRXJy b3IpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENv ZGVycy5oIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5oCmlu ZGV4IDNjMTI4ODcuLmM4YzNjOWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9X ZWJDb3JlQXJndW1lbnRDb2RlcnMuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViQ29y ZUFyZ3VtZW50Q29kZXJzLmgKQEAgLTU3LDYgKzU3LDcgQEAgY2xhc3MgUHJvdGVjdGlvblNwYWNl OwogY2xhc3MgUmVnaW9uOwogY2xhc3MgUmVzb3VyY2VFcnJvcjsKIGNsYXNzIFJlc291cmNlUmVx dWVzdDsKK2NsYXNzIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5OwogY2xhc3MgUmVzb3VyY2VSZXNw b25zZTsKIGNsYXNzIFNlc3Npb25JRDsKIGNsYXNzIFN0ZXBzVGltaW5nRnVuY3Rpb247CkBAIC0y NTEsNiArMjUyLDE1IEBAIHRlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8V2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0PiB7CiAgICAgc3RhdGljIGJvb2wgZGVjb2RlUGxhdGZvcm1EYXRhKEFy Z3VtZW50RGVjb2RlciYsIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOwogfTsKIAorI2lmIEVO QUJMRShDVVNUT01fUFJPVE9DT0xTKQordGVtcGxhdGU8PiBzdHJ1Y3QgQXJndW1lbnRDb2RlcjxX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RXaXRoQm9keT4geworICAgIHN0YXRpYyB2b2lkIGVuY29k ZShBcmd1bWVudEVuY29kZXImLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RXaXRoQm9k eSYpOworICAgIHN0YXRpYyBib29sIGRlY29kZShBcmd1bWVudERlY29kZXImLCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3RXaXRoQm9keSYpOworICAgIHN0YXRpYyB2b2lkIGVuY29kZVBsYXRmb3Jt RGF0YShBcmd1bWVudEVuY29kZXImLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RXaXRo Qm9keSYpOworICAgIHN0YXRpYyBib29sIGRlY29kZVBsYXRmb3JtRGF0YShBcmd1bWVudERlY29k ZXImLCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RXaXRoQm9keSYpOworfTsKKyNlbmRpZiAvLyBF TkFCTEUoQ1VTVE9NX1BST1RPQ09MUykKKwogdGVtcGxhdGU8PiBzdHJ1Y3QgQXJndW1lbnRDb2Rl cjxXZWJDb3JlOjpSZXNvdXJjZUVycm9yPiB7CiAgICAgc3RhdGljIHZvaWQgZW5jb2RlKEFyZ3Vt ZW50RW5jb2RlciYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKICAgICBzdGF0aWMg Ym9vbCBkZWNvZGUoQXJndW1lbnREZWNvZGVyJiwgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL21hYy9XZWJDb3JlQXJndW1lbnRDb2Rl cnNNYWMubW0gYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVy c01hYy5tbQppbmRleCA2MmQ1MjRjLi5lNjgzNTYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVyc01hYy5tbQorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVyc01hYy5tbQpAQCAtMzcsNiArMzcs NyBAQAogI2ltcG9ydCA8V2ViQ29yZS9Qcm90ZWN0aW9uU3BhY2UuaD4KICNpbXBvcnQgPFdlYkNv cmUvUmVzb3VyY2VFcnJvci5oPgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZVJlcXVlc3QuaD4K KyNpbXBvcnQgPFdlYkNvcmUvUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaD4KIAogI2lmIFVTRShD Rk5FVFdPUkspCiAjaW1wb3J0IDxDRk5ldHdvcmsvQ0ZVUkxSZXF1ZXN0Lmg+CkBAIC00Nyw5ICs0 OCwxOCBAQCB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIG5hbWVzcGFjZSBJUEMgewogCiAjaWYg VVNFKENGTkVUV09SSykKLXZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNv ZGVQbGF0Zm9ybURhdGEoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlc291cmNlUmVxdWVzdCkKKyNkZWZpbmUgWFVSTFJlcXVlc3QgQ0ZVUkxSZXF1ZXN0 UmVmCisjZGVmaW5lIHhVUkxSZXF1ZXN0IGNmVVJMUmVxdWVzdAorI2RlZmluZSBYVVJMUmVxdWVz dENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uIFdLQ0ZVUkxSZXF1ZXN0Q3JlYXRlU2Vy aWFsaXphYmxlUmVwcmVzZW50YXRpb24KKyNlbHNlCisjZGVmaW5lIFhVUkxSZXF1ZXN0IE5TVVJM UmVxdWVzdAorI2RlZmluZSB4VVJMUmVxdWVzdCBuc1VSTFJlcXVlc3QKKyNkZWZpbmUgWFVSTFJl cXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbiBXS05TVVJMUmVxdWVzdENyZWF0 ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uCisjZW5kaWYgLy8gVVNFKENGTkVUV09SSykKKwor c3RhdGljIHZvaWQgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnRQbGF0Zm9ybURhdGEoQXJn dW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVx dWVzdCwgYm9vbCBzaG91bGRTdHJpcEhUVFBCb2R5KQogewotICAgIFJldGFpblB0cjxDRlVSTFJl cXVlc3RSZWY+IHJlcXVlc3RUb1NlcmlhbGl6ZSA9IHJlc291cmNlUmVxdWVzdC5jZlVSTFJlcXVl c3QoRG9Ob3RVcGRhdGVIVFRQQm9keSk7CisgICAgUmV0YWluUHRyPFhVUkxSZXF1ZXN0PiByZXF1 ZXN0VG9TZXJpYWxpemUgPSByZXNvdXJjZVJlcXVlc3QueFVSTFJlcXVlc3QoRG9Ob3RVcGRhdGVI VFRQQm9keSk7CiAKICAgICBib29sIHJlcXVlc3RJc1ByZXNlbnQgPSByZXF1ZXN0VG9TZXJpYWxp emU7CiAgICAgZW5jb2RlciA8PCByZXF1ZXN0SXNQcmVzZW50OwpAQCAtNTcsNDYgKzY3LDQ1IEBA IHZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEo QXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyCiAgICAgaWYgKCFyZXF1ZXN0SXNQcmVzZW50KQogICAg ICAgICByZXR1cm47CiAKLSAgICAvLyBXZSBkb24ndCBzZW5kIEhUVFAgYm9keSBzdHJlYW0gb3Zl ciBJUEMsCi0gICAgLy8gYmVjYXVzZSBzdHJlYW0gcHJveHlpbmcgaXMgbm90IGltcGxlbWVudGVk LCBzdHJlYW1zIGNhbiBvbmx5IGJlIGNyZWF0ZWQgaW4gcHJvY2VzcyB0aGF0IGRvZXMgbmV0d29y a2luZy4KKyAgICAvLyBXZSBkb24ndCBzZW5kIEhUVFAgYm9keSBvdmVyIElQQyBmb3IgYmV0dGVy IHBlcmZvcm1hbmNlLgorICAgIC8vIEFsc28sIGl0J3Mgbm90IGFsd2F5cyBwb3NzaWJsZSB0byBk bywgYXMgc3RyZWFtcyBjYW4gb25seSBiZSBjcmVhdGVkIGluIHByb2Nlc3MgdGhhdCBkb2VzIG5l dHdvcmtpbmcuCisjaWYgVVNFKENGTkVUV09SSykKKyAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBy ZXF1ZXN0SFRUUEJvZHkgPSBhZG9wdENGKENGVVJMUmVxdWVzdENvcHlIVFRQUmVxdWVzdEJvZHko cmVxdWVzdFRvU2VyaWFsaXplLmdldCgpKSk7CiAgICAgUmV0YWluUHRyPENGUmVhZFN0cmVhbVJl Zj4gcmVxdWVzdEhUVFBCb2R5U3RyZWFtID0gYWRvcHRDRihDRlVSTFJlcXVlc3RDb3B5SFRUUFJl cXVlc3RCb2R5U3RyZWFtKHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSkpOwotICAgIGlmIChyZXF1 ZXN0SFRUUEJvZHlTdHJlYW0pIHsKLSAgICAgICAgQ0ZNdXRhYmxlVVJMUmVxdWVzdFJlZiBtdXRh YmxlUmVxdWVzdCA9IENGVVJMUmVxdWVzdENyZWF0ZU11dGFibGVDb3B5KDAsIHJlcXVlc3RUb1Nl cmlhbGl6ZS5nZXQoKSk7CisgICAgQ0ZNdXRhYmxlVVJMUmVxdWVzdFJlZiBtdXRhYmxlUmVxdWVz dCA9IE5VTEw7CisgICAgaWYgKHJlcXVlc3RIVFRQQm9keSB8fCByZXF1ZXN0SFRUUEJvZHlTdHJl YW0pIHsKKyAgICAgICAgbXV0YWJsZVJlcXVlc3QgPSBDRlVSTFJlcXVlc3RDcmVhdGVNdXRhYmxl Q29weSgwLCByZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCkpOwogICAgICAgICByZXF1ZXN0VG9TZXJp YWxpemUgPSBhZG9wdENGKG11dGFibGVSZXF1ZXN0KTsKKyAgICB9CisgICAgaWYgKHJlcXVlc3RI VFRQQm9keSAmJiBzaG91bGRTdHJpcEhUVFBCb2R5KQorICAgICAgICBDRlVSTFJlcXVlc3RTZXRI VFRQUmVxdWVzdEJvZHkobXV0YWJsZVJlcXVlc3QsIG5pbCk7CisgICAgaWYgKHJlcXVlc3RIVFRQ Qm9keVN0cmVhbSkKICAgICAgICAgQ0ZVUkxSZXF1ZXN0U2V0SFRUUFJlcXVlc3RCb2R5U3RyZWFt KG11dGFibGVSZXF1ZXN0LCBuaWwpOworI2Vsc2UKKyAgICBOU0RhdGEgKnJlcXVlc3RIVFRQQm9k eSA9IFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHldOworICAgIE5TSW5wdXRTdHJlYW0gKnJl cXVlc3RIVFRQQm9keVN0cmVhbSA9IFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHlTdHJlYW1d OworICAgIE5TTXV0YWJsZVVSTFJlcXVlc3QgKm11dGFibGVSZXF1ZXN0ID0gbmlsOworICAgIGlm IChyZXF1ZXN0SFRUUEJvZHkgfHwgcmVxdWVzdEhUVFBCb2R5U3RyZWFtKSB7CisgICAgICAgIG11 dGFibGVSZXF1ZXN0ID0gW3JlcXVlc3RUb1NlcmlhbGl6ZSBtdXRhYmxlQ29weV07CisgICAgICAg IHJlcXVlc3RUb1NlcmlhbGl6ZSA9IGFkb3B0TlMobXV0YWJsZVJlcXVlc3QpOwogICAgIH0KKyAg ICBpZiAocmVxdWVzdEhUVFBCb2R5ICYmIHNob3VsZFN0cmlwSFRUUEJvZHkpCisgICAgICAgIFtt dXRhYmxlUmVxdWVzdCBzZXRIVFRQQm9keTpuaWxdOworICAgIGlmIChyZXF1ZXN0SFRUUEJvZHlT dHJlYW0pCisgICAgICAgIFttdXRhYmxlUmVxdWVzdCBzZXRIVFRQQm9keVN0cmVhbTpuaWxdOwor I2VuZGlmIC8vIFVTRShDRk5FVFdPUkspCiAKLSAgICBSZXRhaW5QdHI8Q0ZEaWN0aW9uYXJ5UmVm PiBkaWN0aW9uYXJ5ID0gYWRvcHRDRihXS0NGVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJl cHJlc2VudGF0aW9uKHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSwgSVBDOjp0b2tlbk51bGxUeXBl UmVmKCkpKTsKKyAgICBSZXRhaW5QdHI8Q0ZEaWN0aW9uYXJ5UmVmPiBkaWN0aW9uYXJ5ID0gYWRv cHRDRihYVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uKHJlcXVlc3RU b1NlcmlhbGl6ZS5nZXQoKSwgSVBDOjp0b2tlbk51bGxUeXBlUmVmKCkpKTsKICAgICBJUEM6OmVu Y29kZShlbmNvZGVyLCBkaWN0aW9uYXJ5LmdldCgpKTsKIAotICAgIC8vIFRoZSBmYWxsYmFjayBh cnJheSBpcyBwYXJ0IG9mIENGVVJMUmVxdWVzdCwgYnV0IGl0IGlzIG5vdCBlbmNvZGVkIGJ5IFdL Q0ZVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24uCisgICAgLy8gVGhl IGZhbGxiYWNrIGFycmF5IGlzIHBhcnQgb2YgWFVSTFJlcXVlc3QsIGJ1dCBpdCBpcyBub3QgZW5j b2RlZCBieSBYVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uLgogICAg IGVuY29kZXIgPDwgcmVzb3VyY2VSZXF1ZXN0LnJlc3BvbnNlQ29udGVudERpc3Bvc2l0aW9uRW5j b2RpbmdGYWxsYmFja0FycmF5KCk7CiB9Ci0jZWxzZQorCiB2b2lkIEFyZ3VtZW50Q29kZXI8UmVz b3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2Rl ciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCiB7Ci0gICAgUmV0YWlu UHRyPE5TVVJMUmVxdWVzdD4gcmVxdWVzdFRvU2VyaWFsaXplID0gcmVzb3VyY2VSZXF1ZXN0Lm5z VVJMUmVxdWVzdChEb05vdFVwZGF0ZUhUVFBCb2R5KTsKLQotICAgIGJvb2wgcmVxdWVzdElzUHJl c2VudCA9IHJlcXVlc3RUb1NlcmlhbGl6ZTsKLSAgICBlbmNvZGVyIDw8IHJlcXVlc3RJc1ByZXNl bnQ7Ci0KLSAgICBpZiAoIXJlcXVlc3RJc1ByZXNlbnQpCi0gICAgICAgIHJldHVybjsKLQotICAg IC8vIFdlIGRvbid0IHNlbmQgSFRUUCBib2R5IHN0cmVhbSBvdmVyIElQQywKLSAgICAvLyBiZWNh dXNlIHN0cmVhbSBwcm94eWluZyBpcyBub3QgaW1wbGVtZW50ZWQsIHN0cmVhbXMgY2FuIG9ubHkg YmUgY3JlYXRlZCBpbiBwcm9jZXNzIHRoYXQgZG9lcyBuZXR3b3JraW5nLgotICAgIGlmIChbcmVx dWVzdFRvU2VyaWFsaXplIEhUVFBCb2R5U3RyZWFtXSkgewotICAgICAgICByZXF1ZXN0VG9TZXJp YWxpemUgPSBhZG9wdE5TKFtyZXF1ZXN0VG9TZXJpYWxpemUgbXV0YWJsZUNvcHldKTsKLSAgICAg ICAgWyhOU011dGFibGVVUkxSZXF1ZXN0ICopcmVxdWVzdFRvU2VyaWFsaXplIHNldEhUVFBCb2R5 U3RyZWFtOm5pbF07Ci0gICAgfQotCi0gICAgUmV0YWluUHRyPENGRGljdGlvbmFyeVJlZj4gZGlj dGlvbmFyeSA9IGFkb3B0Q0YoV0tOU1VSTFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNl bnRhdGlvbihyZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCksIElQQzo6dG9rZW5OdWxsVHlwZVJlZigp KSk7Ci0gICAgSVBDOjplbmNvZGUoZW5jb2RlciwgZGljdGlvbmFyeS5nZXQoKSk7Ci0KLSAgICAv LyBUaGUgZmFsbGJhY2sgYXJyYXkgaXMgcGFydCBvZiBOU1VSTFJlcXVlc3QsIGJ1dCBpdCBpcyBu b3QgZW5jb2RlZCBieSBXS05TVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0 aW9uLgotICAgIGVuY29kZXIgPDwgcmVzb3VyY2VSZXF1ZXN0LnJlc3BvbnNlQ29udGVudERpc3Bv c2l0aW9uRW5jb2RpbmdGYWxsYmFja0FycmF5KCk7CisgICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0 QXJndW1lbnRQbGF0Zm9ybURhdGEoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0LCB0cnVlKTsKIH0K LSNlbmRpZgogCiBib29sIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZGVjb2RlUGxh dGZvcm1EYXRhKEFyZ3VtZW50RGVjb2RlciYgZGVjb2RlciwgUmVzb3VyY2VSZXF1ZXN0JiByZXNv dXJjZVJlcXVlc3QpCiB7CkBAIC0xNDAsNiArMTQ5LDIxIEBAIGJvb2wgQXJndW1lbnRDb2RlcjxS ZXNvdXJjZVJlcXVlc3Q+OjpkZWNvZGVQbGF0Zm9ybURhdGEoQXJndW1lbnREZWNvZGVyJiBkZWNv ZGVyCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKKyNpZiBFTkFCTEUoQ1VTVE9NX1BST1RPQ09MUykK Kwordm9pZCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdFdpdGhCb2R5Pjo6ZW5jb2RlUGxh dGZvcm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0 V2l0aEJvZHkmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBFbmNvZGVSZXNvdXJjZVJlcXVlc3RB cmd1bWVudFBsYXRmb3JtRGF0YShlbmNvZGVyLCByZXNvdXJjZVJlcXVlc3QucmVxdWVzdCgpLCBm YWxzZSk7Cit9CisKK2Jvb2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3RXaXRoQm9keT46 OmRlY29kZVBsYXRmb3JtRGF0YShBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFJlc291cmNlUmVx dWVzdFdpdGhCb2R5JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0ID0gY29uc3RfY2FzdDxSZXNvdXJjZVJlcXVlc3QmPihyZXNvdXJjZVJlcXVlc3QucmVx dWVzdCgpKTsKKyAgICByZXR1cm4gQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjpkZWNv ZGVQbGF0Zm9ybURhdGEoZGVjb2RlciwgcmVxdWVzdCk7Cit9CisKKyNlbmRpZiAvLyBFTkFCTEUo Q1VTVE9NX1BST1RPQ09MUykKKwogdm9pZCBBcmd1bWVudENvZGVyPENlcnRpZmljYXRlSW5mbz46 OmVuY29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IENlcnRpZmljYXRlSW5mbyYg Y2VydGlmaWNhdGVJbmZvKQogewogICAgIENGQXJyYXlSZWYgY2VydGlmaWNhdGVDaGFpbiA9IGNl cnRpZmljYXRlSW5mby5jZXJ0aWZpY2F0ZUNoYWluKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvQ3VzdG9tUHJvdG9jb2xNYW5h Z2VyUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3Rv Y29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5oCmluZGV4IDI1YTk2NzAuLmUyMzlmYTkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3Rv Y29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94 eS5oCkBAIC0zNyw3ICszNyw3IEBAIE9CSkNfQ0xBU1MgV0tDdXN0b21Qcm90b2NvbExvYWRlcjsK ICNlbmRpZgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7Ci1jbGFzcyBSZXNvdXJjZVJlcXVlc3Q7Citj bGFzcyBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keTsKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAog bmFtZXNwYWNlIFdlYktpdCB7CkBAIC00OSw3ICs0OSw3IEBAIGNsYXNzIEN1c3RvbVByb3RvY29s TWFuYWdlclByb3h5IDogcHVibGljIElQQzo6TWVzc2FnZVJlY2VpdmVyIHsKIHB1YmxpYzoKICAg ICBleHBsaWNpdCBDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eShDaGlsZFByb2Nlc3NQcm94eSos IFdlYkNvbnRleHQmKTsKIAotICAgIHZvaWQgc3RhcnRMb2FkaW5nKHVpbnQ2NF90IGN1c3RvbVBy b3RvY29sSUQsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZvaWQgc3Rh cnRMb2FkaW5nKHVpbnQ2NF90IGN1c3RvbVByb3RvY29sSUQsIGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdFdpdGhCb2R5Jik7CiAgICAgdm9pZCBzdG9wTG9hZGluZyh1aW50NjRfdCBjdXN0 b21Qcm90b2NvbElEKTsKIAogcHJpdmF0ZToKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94 eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVBy b3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5tZXNzYWdlcy5pbgppbmRleCA3YWVm MGUwLi5iMzU5OWUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvTmV0d29y ay9DdXN0b21Qcm90b2NvbHMvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHkubWVzc2FnZXMuaW4K KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0N1 c3RvbVByb3RvY29sTWFuYWdlclByb3h5Lm1lc3NhZ2VzLmluCkBAIC0yMyw3ICsyMyw3IEBACiAj aWYgRU5BQkxFKENVU1RPTV9QUk9UT0NPTFMpCiAKIG1lc3NhZ2VzIC0+IEN1c3RvbVByb3RvY29s TWFuYWdlclByb3h5IHsKLSAgICBTdGFydExvYWRpbmcodWludDY0X3QgY3VzdG9tUHJvdG9jb2xJ RCwgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3QpCisgICAgU3RhcnRMb2FkaW5nKHVp bnQ2NF90IGN1c3RvbVByb3RvY29sSUQsIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdFdpdGhCb2R5 IHJlcXVlc3QpCiAgICAgU3RvcExvYWRpbmcodWludDY0X3QgY3VzdG9tUHJvdG9jb2xJRCkKIH0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJv dG9jb2xzL21hYy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eU1hYy5tbSBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9tYWMvQ3VzdG9tUHJvdG9jb2xN YW5hZ2VyUHJveHlNYWMubW0KaW5kZXggN2QwZWZjYS4uNWQ3YWIzYSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL21hYy9DdXN0b21Q cm90b2NvbE1hbmFnZXJQcm94eU1hYy5tbQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv TmV0d29yay9DdXN0b21Qcm90b2NvbHMvbWFjL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5TWFj Lm1tCkBAIC0zNiw2ICszNiw3IEBACiAjaW1wb3J0ICJXZWJDb3JlQXJndW1lbnRDb2RlcnMuaCIK ICNpbXBvcnQgPFdlYkNvcmUvUmVzb3VyY2VFcnJvci5oPgogI2ltcG9ydCA8V2ViQ29yZS9SZXNv dXJjZVJlcXVlc3QuaD4KKyNpbXBvcnQgPFdlYkNvcmUvUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHku aD4KICNpbXBvcnQgPFdlYkNvcmUvUmVzb3VyY2VSZXNwb25zZS5oPgogCiB1c2luZyBuYW1lc3Bh Y2UgSVBDOwpAQCAtMTMwLDggKzEzMSw5IEBAIEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpD dXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eShDaGlsZFByb2Nlc3NQcm94eSogY2hpbGRQCiAgICAg bV9jaGlsZFByb2Nlc3NQcm94eS0+YWRkTWVzc2FnZVJlY2VpdmVyKE1lc3NhZ2VzOjpDdXN0b21Q cm90b2NvbE1hbmFnZXJQcm94eTo6bWVzc2FnZVJlY2VpdmVyTmFtZSgpLCAqdGhpcyk7CiB9CiAK LXZvaWQgQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHk6OnN0YXJ0TG9hZGluZyh1aW50NjRfdCBj dXN0b21Qcm90b2NvbElELCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIGNvcmVSZXF1ZXN0KQordm9p ZCBDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eTo6c3RhcnRMb2FkaW5nKHVpbnQ2NF90IGN1c3Rv bVByb3RvY29sSUQsIGNvbnN0IFJlc291cmNlUmVxdWVzdFdpdGhCb2R5JiBjb3JlUmVxdWVzdFdp dGhCb2R5KQogeworICAgIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgY29yZVJlcXVlc3QgPSBjb3Jl UmVxdWVzdFdpdGhCb2R5LnJlcXVlc3QoKTsKICAgICBOU1VSTFJlcXVlc3QgKnJlcXVlc3QgPSBj b3JlUmVxdWVzdC5uc1VSTFJlcXVlc3QoRG9Ob3RVcGRhdGVIVFRQQm9keSk7CiAgICAgaWYgKCFy ZXF1ZXN0KQogICAgICAgICByZXR1cm47Ci0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 240538 2014-10-28 08:03:33 -0700 2014-10-30 05:30:57 -0700 Patch bug-137299-20141028160340.patch text/plain 28540 danielo U3VidmVyc2lvbiBSZXZpc2lvbjogMTc0MTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmIyNmNiNmNkYzUzNDg0 MzUyZjY2MmI0YWRiODEzYjFhYmM0YWMzNi4uNjVhYTdmZDI4MTU5YTE3ODJiMTk3YTdkNGY2NzRm Y2M4YmIyMDQ1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE0LTEwLTI4ICBEYW5p ZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+CisKKyAgICAgICAgUE9TVCBmb3JtIGRh dGEgaXMgbWlzc2luZyB3aXRoIGEgY3VzdG9tIE5TVVJMUHJvdG9jb2wKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzI5OQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIG5ldyBjbGFzcyBSZXNvdXJj ZVJlcXVlc3RXaXRoQm9keSB0aGF0IHdyYXBzIFJlc291cmNlUmVxdWVzdCwKKyAgICAgICAgYnV0 IHRyaWdnZXJzIGEgZGlmZmVyZW50IFBPU1QgYm9keSBzZXJpYWxpemF0aW9uIG1ldGhvZC4KKwor ICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBw bGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdFdpdGhCb2R5Lmg6CisKIDIwMTQtMDktMzAg IEJyaWFuIEouIEJ1cmcgIDxidXJnQGNzLndhc2hpbmd0b24uZWR1PgogCiAgICAgICAgIFdlYiBJ bnNwZWN0b3I6IEVycm9yU3RyaW5nIHNob3VsZCBiZSBwYXNzZWQgYnkgcmVmZXJlbmNlCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKaW5kZXggMWMxMzQ0NzVlYTU3M2UwNjMwY2U4OGE0Yzg1NTNmMTEzYzIzZWQ0YS4uYTBjNmU1 ZTZkMDZhNDI0ZGFlNzVmNDZjYjVhODkyYmE1NjVmZWRiOCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsx LDQzIEBACisyMDE0LTEwLTI4ICBEYW5pZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+ CisKKyAgICAgICAgUE9TVCBmb3JtIGRhdGEgaXMgbWlzc2luZyB3aXRoIGEgY3VzdG9tIE5TVVJM UHJvdG9jb2wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEzNzI5OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoZSBQT1NUIHJlcXVlc3QgZm9ybSBkYXRhIHdhcyBtaXNzaW5nIGluIFVJUHJvY2VzcworICAg ICAgICB3aGVyZSBhIGN1c3RvbSBOU1VSTFByb3RvY29sIGxpdmVzLAorICAgICAgICBiZWNhdXNl IGl0IHdhcyBub3Qgc2VyaWFsaXplZCBvdmVyIElQQy4KKworICAgICAgICBUaGlzIGZpeCBhbGxv d3MgSFRUUCBQT1NUIGJvZHkgZm9ybSBkYXRhIHRvIGJlIHNlbnQgb3ZlciBJUEMKKyAgICAgICAg aW4gdGhlIEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFydExvYWRpbmcgbWVzc2FnZS4K KyAgICAgICAgSW4gb3RoZXIgY2FzZXMgdGhlIEhUVFAgYm9keSBpcyBzdHJpcHBlZCBhcyBiZWZv cmUgKGZvciBwZXJmb3JtYW5jZSByZWFzb25zKS4KKyAgICAgICAgSW4gb3JkZXIgdG8gdHJpZ2dl ciBhIGRpZmZlcmVudCBzZXJpYWxpemF0aW9uIGFsZ29yaXRobSBmb3IgUmVzb3VyY2VSZXF1ZXN0 CisgICAgICAgIGluIHRoaXMgY2FzZSwgYSBuZXcgY2xhc3MgaXMgYWRkZWQgLSBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3RXaXRoQm9keS4KKyAgICAgICAgSXQncyBhIFJlc291cmNlUmVxdWVzdCB3 cmFwcGVyIHRoYXQgaXMgc2VyaWFsaXplZCBwcmVzZXJ2aW5nIHRoZSBQT1NUIHJlcXVlc3QgYm9k eSBwYXJhbWV0ZXJzLgorCisgICAgICAgIEluIGFkZGl0aW9uOgorICAgICAgICBSZWZhY3RvciBB cmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29kZVBsYXRmb3JtRGF0YQorICAgICAg ICBpbiBvcmRlciB0byByZW1vdmUgZHVwbGljYXRlIGNvZGUuCisKKyAgICAgICAgKiBTaGFyZWQv TmV0d29yay9DdXN0b21Qcm90b2NvbHMvQ29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2Eu bW06CisgICAgICAgICgtW1dLQ3VzdG9tUHJvdG9jb2wgc3RhcnRMb2FkaW5nXSk6CisgICAgICAg ICogU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5jcHA6CisgICAgICAgIChJUEM6OkVuY29k ZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50KToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxS ZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGUpOgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVyPFJl c291cmNlUmVxdWVzdFdpdGhCb2R5Pjo6ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRD b2RlcjxSZXNvdXJjZVJlcXVlc3RXaXRoQm9keT46OmRlY29kZSk6CisgICAgICAgICogU2hhcmVk L1dlYkNvcmVBcmd1bWVudENvZGVycy5oOgorICAgICAgICAqIFNoYXJlZC9tYWMvV2ViQ29yZUFy Z3VtZW50Q29kZXJzTWFjLm1tOgorICAgICAgICAoSVBDOjpFbmNvZGVSZXNvdXJjZVJlcXVlc3RB cmd1bWVudFBsYXRmb3JtRGF0YSk6CisgICAgICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8UmVzb3Vy Y2VSZXF1ZXN0Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRD b2RlcjxSZXNvdXJjZVJlcXVlc3RXaXRoQm9keT46OmVuY29kZVBsYXRmb3JtRGF0YSk6CisgICAg ICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHk+OjpkZWNvZGVQ bGF0Zm9ybURhdGEpOgorICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29s cy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9OZXR3 b3JrL0N1c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eS5tZXNzYWdlcy5p bjoKKyAgICAgICAgKiBVSVByb2Nlc3MvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvbWFjL0N1c3Rv bVByb3RvY29sTWFuYWdlclByb3h5TWFjLm1tOgorICAgICAgICAoV2ViS2l0OjpDdXN0b21Qcm90 b2NvbE1hbmFnZXJQcm94eTo6c3RhcnRMb2FkaW5nKToKKwogMjAxNC0wOS0zMCAgR3l1eW91bmcg S2ltICA8Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFtFRkxdIFJlbmFtZSBU RVNUX1RIRU1FX0RJUiBtYWNybwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGQ1NDNkNzkyM2JmYTg0YmRlOWRmZjk5NjkzZDNkMzUz ZmEwNjc4NWEuLjY1N2Y5OThiOGE4NTg2YzI3YmJjOWZlMDcyOThkOTgyZGZlM2UwMjYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagor KysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAg LTYxOTMsNiArNjE5Myw3IEBACiAJCUU1MjZBRjNGMTcyN0Y4RjIwMEU0MTc4MSAvKiBQZXJmb3Jt YW5jZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBF NTI2QUYzRTE3MjdGOEYyMDBFNDE3ODEgLyogUGVyZm9ybWFuY2UuY3BwICovOyB9OwogCQlFNTVG NDk3QTE1MUI4ODgwMDBCQjY3REIgLyogTGVuZ3RoRnVuY3Rpb25zLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEU1NUY0OTc5MTUxQjg4ODAwMEJCNjdE QiAvKiBMZW5ndGhGdW5jdGlvbnMuY3BwICovOyB9OwogCQlFNUJBN0Q2MzE1MTQzN0NBMDBGRTFF M0YgLyogTGVuZ3RoRnVuY3Rpb25zLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBFNUJBN0Q2MjE1MTQzN0NBMDBGRTFFM0YgLyogTGVuZ3RoRnVuY3Rpb25z LmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJRTY2 NkVGRUYxOUU1MkExNDAwNjkyNkNEIC8qIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5LmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFNjY2RUZFRTE5RTUyMUJD MDA2OTI2Q0QgLyogUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaCAqLzsgc2V0dGluZ3MgPSB7QVRU UklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlFQkY1MTIxQzE2OTY0OTZDMDA1NkJEMjUg LyogSlNUeXBlQ29udmVyc2lvbnMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gRUJGNTEyMUExNjk2NDk2QzAwNTZCRDI1IC8qIEpTVHlwZUNvbnZlcnNp b25zLmNwcCAqLzsgfTsKIAkJRUJGNTEyMUQxNjk2NDk2QzAwNTZCRDI1IC8qIEpTVHlwZUNvbnZl cnNpb25zLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBF QkY1MTIxQjE2OTY0OTZDMDA1NkJEMjUgLyogSlNUeXBlQ29udmVyc2lvbnMuaCAqLzsgfTsKIAkJ RUQyQkE4M0MwOUEyNEI5MTAwNkMwQUM0IC8qIERvY3VtZW50TWFya2VyLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBFRDJCQTgzQjA5QTI0QjkxMDA2QzBB QzQgLyogRG9jdW1lbnRNYXJrZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OwpAQCAtMTM3MDMsNiArMTM3MDQsNyBAQAogCQlFNTI2QUYzRTE3MjdGOEYy MDBFNDE3ODEgLyogUGVyZm9ybWFuY2UuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gUGVyZm9ybWFuY2UuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlF NTVGNDk3OTE1MUI4ODgwMDBCQjY3REIgLyogTGVuZ3RoRnVuY3Rpb25zLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IExlbmd0aEZ1bmN0aW9ucy5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUU1QkE3RDYyMTUxNDM3Q0EwMEZFMUUzRiAvKiBMZW5ndGhG dW5jdGlvbnMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTGVuZ3RoRnVuY3Rp b25zLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUU2NjZFRkVFMTlFNTIxQkMwMDY5 MjZDRCAvKiBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlFQjA4MUNEODE2OTYwODQ0MDA1NTM3MzAgLyogVHlwZUNvbnZlcnNpb25zLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IFR5cGVDb252ZXJzaW9ucy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlFQjA4MUNEOTE2OTYwODQ0MDA1NTM3MzAgLyogVHlwZUNvbnZlcnNpb25zLmlkbCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBh dGggPSBUeXBlQ29udmVyc2lvbnMuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlF QkY1MTIxQTE2OTY0OTZDMDA1NkJEMjUgLyogSlNUeXBlQ29udmVyc2lvbnMuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gSlNUeXBlQ29udmVyc2lvbnMuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTYzMzAsNiArMTYzMzIsNyBAQAogCQkJCThBODFC Rjg0MTFEQ0ZEOTAwMERBMkI5OCAvKiBSZXNvdXJjZUxvYWRUaW1pbmcuaCAqLywKIAkJCQk1MTRD NzY2NzBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VSZXF1ZXN0QmFzZS5jcHAgKi8sCiAJCQkJ NTE0Qzc2NjgwQ0U5MjNBMTAwN0VGM0NEIC8qIFJlc291cmNlUmVxdWVzdEJhc2UuaCAqLywKKwkJ CQlFNjY2RUZFRTE5RTUyMUJDMDA2OTI2Q0QgLyogUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaCAq LywKIAkJCQk1MTRDNzY2OTBDRTkyM0ExMDA3RUYzQ0QgLyogUmVzb3VyY2VSZXNwb25zZUJhc2Uu Y3BwICovLAogCQkJCTUxNEM3NjZBMENFOTIzQTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlc3BvbnNl QmFzZS5oICovLAogCQkJCTUxMEQ0QTJEMTAzMTY1RUUwMDQ5RUE1NCAvKiBTb2NrZXRTdHJlYW1F cnJvckJhc2UuY3BwICovLApAQCAtMjU3MzYsNiArMjU3MzksNyBAQAogCQkJCTdFRTY4NDZEMTJE MjZFMzgwMEU3OTQxNSAvKiBSZXNvdXJjZVJlcXVlc3QuaCBpbiBIZWFkZXJzICovLAogCQkJCTUx NEM3NjdEMENFOTIzQTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlcXVlc3RCYXNlLmggaW4gSGVhZGVy cyAqLywKIAkJCQk3RUU2ODQ2RjEyRDI2RTM4MDBFNzk0MTUgLyogUmVzb3VyY2VSZXF1ZXN0Q0ZO ZXQuaCBpbiBIZWFkZXJzICovLAorCQkJCUU2NjZFRkVGMTlFNTJBMTQwMDY5MjZDRCAvKiBSZXNv dXJjZVJlcXVlc3RXaXRoQm9keS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJN0VFNjg0NzAxMkQyNkUz ODAwRTc5NDE1IC8qIFJlc291cmNlUmVzcG9uc2UuaCBpbiBIZWFkZXJzICovLAogCQkJCTUxNEM3 NjdGMENFOTIzQTEwMDdFRjNDRCAvKiBSZXNvdXJjZVJlc3BvbnNlQmFzZS5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJRkQzMTYwQTUxMkIwMjZGNzAwQzFBMzU5IC8qIFJldmVyYi5oIGluIEhlYWRlcnMg Ki8sCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl UmVxdWVzdFdpdGhCb2R5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291 cmNlUmVxdWVzdFdpdGhCb2R5LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTllNjk5MzhlNDFmYmY2MmY4NGRhMTVi ZTYzODZkMzkyZmI3MmY3NwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaApAQCAtMCwwICsxLDYwIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDE0IERhbmllbCBMYXphcmVua28gKGRhbmllbG9Ab3BlcmEu Y29tKQorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4g UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAg ICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUg ZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUg SU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICog VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjaWZuZGVmIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5X2gKKyNkZWZp bmUgUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHlfaAorCisjaWYgRU5BQkxFKENVU1RPTV9QUk9UT0NP TFMpCisKKyNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitjbGFzcyBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keSB7CisgICAgUmVzb3VyY2VSZXF1ZXN0 IG1fcmVxdWVzdDsKK3B1YmxpYzoKKyAgICBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keSgpIHsgfQor ICAgIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVz dCkKKyAgICAgICAgOiBtX3JlcXVlc3QocmVxdWVzdCkgeyB9CisgICAgY29uc3QgUmVzb3VyY2VS ZXF1ZXN0JiByZXF1ZXN0KCkgY29uc3QgeyByZXR1cm4gbV9yZXF1ZXN0OyB9CisKKyNpZiBFTkFC TEUoQ0FDSEVfUEFSVElUSU9OSU5HKQorICAgIGNvbnN0IFN0cmluZyYgY2FjaGVQYXJ0aXRpb24o KSBjb25zdCB7IHJldHVybiBtX3JlcXVlc3QuY2FjaGVQYXJ0aXRpb24oKTsgfQorI2VuZGlmCisj aWYgRU5BQkxFKElOU1BFQ1RPUikKKyAgICAvLyBXaGV0aGVyIHRoaXMgcmVxdWVzdCBzaG91bGQg YmUgaGlkZGVuIGZyb20gdGhlIEluc3BlY3Rvci4KKyAgICBib29sIGhpZGRlbkZyb21JbnNwZWN0 b3IoKSBjb25zdCB7IHJldHVybiBtX3JlcXVlc3QuaGlkZGVuRnJvbUluc3BlY3RvcigpOyB9Cisj ZW5kaWYKKyAgICBib29sIGVuY29kaW5nUmVxdWlyZXNQbGF0Zm9ybURhdGEoKSBjb25zdCB7IHJl dHVybiBtX3JlcXVlc3QuZW5jb2RpbmdSZXF1aXJlc1BsYXRmb3JtRGF0YSgpOyB9CisKKyAgICB0 ZW1wbGF0ZTxjbGFzcyBFbmNvZGVyPiB2b2lkIGVuY29kZVdpdGhvdXRQbGF0Zm9ybURhdGEoRW5j b2RlciYgZSkgY29uc3QgeyBtX3JlcXVlc3QuZW5jb2RlV2l0aG91dFBsYXRmb3JtRGF0YShlKTsg fQorCit9OworCit9OyAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKENV U1RPTV9QUk9UT0NPTFMpCisKKyNlbmRpZiAvLyBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keV9oCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmV0d29yay9DdXN0b21Qcm90b2NvbHMv Q29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2EubW0gYi9Tb3VyY2UvV2ViS2l0Mi9TaGFy ZWQvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvQ29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29j b2EubW0KaW5kZXggZmZiNGQxZTgyZTRmYjI4MzkxOTQ3ZGM1NDIxZDgxYzRhNDE4NjQwOS4uYzA0 MDlmNTBmMDAxODVlOTQ2MWM4MTI1ODk4MjlkZmY3NTg0NjlkMyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvU2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0NvY29hL0N1c3RvbVByb3Rv Y29sTWFuYWdlckNvY29hLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9OZXR3b3JrL0N1 c3RvbVByb3RvY29scy9Db2NvYS9DdXN0b21Qcm90b2NvbE1hbmFnZXJDb2NvYS5tbQpAQCAtMzcs NiArMzcsNyBAQAogI2ltcG9ydCA8V2ViQ29yZS9VUkwuaD4KICNpbXBvcnQgPFdlYkNvcmUvUmVz b3VyY2VFcnJvci5oPgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZVJlcXVlc3QuaD4KKyNpbXBv cnQgPFdlYkNvcmUvUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkuaD4KICNpbXBvcnQgPFdlYkNvcmUv UmVzb3VyY2VSZXNwb25zZS5oPgogCiAjaWYgRU5BQkxFKE5FVFdPUktfUFJPQ0VTUykKQEAgLTEw Niw3ICsxMDcsOCBAQCBzdGF0aWMgdWludDY0X3QgZ2VuZXJhdGVDdXN0b21Qcm90b2NvbElEKCkK IAogLSAodm9pZClzdGFydExvYWRpbmcKIHsKLSAgICBzaGFyZWRDdXN0b21Qcm90b2NvbE1hbmFn ZXItPmNoaWxkUHJvY2VzcygpLT5zZW5kKE1lc3NhZ2VzOjpDdXN0b21Qcm90b2NvbE1hbmFnZXJQ cm94eTo6U3RhcnRMb2FkaW5nKHNlbGYuY3VzdG9tUHJvdG9jb2xJRCwgW3NlbGYgcmVxdWVzdF0p LCAwKTsKKyAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3RXaXRoQm9keSBjb3JlUmVxdWVzdFdp dGhCb2R5KFtzZWxmIHJlcXVlc3RdKTsKKyAgICBzaGFyZWRDdXN0b21Qcm90b2NvbE1hbmFnZXIt PmNoaWxkUHJvY2VzcygpLT5zZW5kKE1lc3NhZ2VzOjpDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94 eTo6U3RhcnRMb2FkaW5nKHNlbGYuY3VzdG9tUHJvdG9jb2xJRCwgY29yZVJlcXVlc3RXaXRoQm9k eSksIDApOwogfQogCiAtICh2b2lkKXN0b3BMb2FkaW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuY3BwCmluZGV4IGNkZmE3MGZjMDY5NzFkNmYzZjIw ZDc3MjUwN2I5MGY1YTEyMWY5ZTcuLjFhNzBkMjFiZDc2ZTdhMGMyZTNiNzdlZTJmYmQxZjVmN2Jm M2E3ZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRD b2RlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2Rl cnMuY3BwCkBAIC01NCw2ICs1NCw3IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9SZWdpb24uaD4KICNp bmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlRXJyb3IuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Jlc291 cmNlUmVxdWVzdC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHku aD4KICNpbmNsdWRlIDxXZWJDb3JlL1Jlc291cmNlUmVzcG9uc2UuaD4KICNpbmNsdWRlIDxXZWJD b3JlL1Njcm9sbGluZ0NvbnN0cmFpbnRzLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9TY3JvbGxpbmdD b29yZGluYXRvci5oPgpAQCAtNzAxLDcgKzcwMiw4IEBAIGJvb2wgQXJndW1lbnRDb2RlcjxDdXJz b3I+OjpkZWNvZGUoQXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBDdXJzb3ImIGN1cnNvcikKIH0K ICNlbmRpZgogCi12b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlKEFy Z3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJl cXVlc3QpCit0ZW1wbGF0ZTxjbGFzcyBUUmVzb3VyY2VSZXF1ZXN0Pgordm9pZCBFbmNvZGVSZXNv dXJjZVJlcXVlc3RBcmd1bWVudChBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFRSZXNv dXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKIHsKICNpZiBFTkFCTEUoQ0FDSEVfUEFSVElU SU9OSU5HKQogICAgIGVuY29kZXIgPDwgcmVzb3VyY2VSZXF1ZXN0LmNhY2hlUGFydGl0aW9uKCk7 CkBAIC03MTMsMTMgKzcxNSwxOCBAQCB2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0 Pjo6ZW5jb2RlKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzbwogCiAgICAgaWYg KHJlc291cmNlUmVxdWVzdC5lbmNvZGluZ1JlcXVpcmVzUGxhdGZvcm1EYXRhKCkpIHsKICAgICAg ICAgZW5jb2RlciA8PCB0cnVlOwotICAgICAgICBlbmNvZGVQbGF0Zm9ybURhdGEoZW5jb2Rlciwg cmVzb3VyY2VSZXF1ZXN0KTsKKyAgICAgICAgQXJndW1lbnRDb2RlcjxUUmVzb3VyY2VSZXF1ZXN0 Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVzdCk7CiAgICAgICAg IHJldHVybjsKICAgICB9CiAgICAgZW5jb2RlciA8PCBmYWxzZTsKICAgICByZXNvdXJjZVJlcXVl c3QuZW5jb2RlV2l0aG91dFBsYXRmb3JtRGF0YShlbmNvZGVyKTsKIH0KIAordm9pZCBBcmd1bWVu dENvZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIs IGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQoreworICAgIEVuY29kZVJl c291cmNlUmVxdWVzdEFyZ3VtZW50KGVuY29kZXIsIHJlc291cmNlUmVxdWVzdCk7Cit9CisKIGJv b2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjpkZWNvZGUoQXJndW1lbnREZWNvZGVy JiBkZWNvZGVyLCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKIHsKICNpZiBFTkFC TEUoQ0FDSEVfUEFSVElUSU9OSU5HKQpAQCAtNzQ1LDYgKzc1MiwyMSBAQCBib29sIEFyZ3VtZW50 Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZGVjb2RlKEFyZ3VtZW50RGVjb2RlciYgZGVjb2Rlciwg UmVzb3VyY2VSZQogICAgIHJldHVybiByZXNvdXJjZVJlcXVlc3QuZGVjb2RlV2l0aG91dFBsYXRm b3JtRGF0YShkZWNvZGVyKTsKIH0KIAorI2lmIEVOQUJMRShDVVNUT01fUFJPVE9DT0xTKQorCit2 b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHk+OjplbmNvZGUoQXJndW1l bnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keSYgcmVzb3Vy Y2VSZXF1ZXN0KQoreworICAgIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50KGVuY29kZXIs IHJlc291cmNlUmVxdWVzdCk7Cit9CisKK2Jvb2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVl c3RXaXRoQm9keT46OmRlY29kZShBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFJlc291cmNlUmVx dWVzdFdpdGhCb2R5JiByZXNvdXJjZVJlcXVlc3QpCit7CisgICAgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0ID0gY29uc3RfY2FzdDxSZXNvdXJjZVJlcXVlc3QmPihyZXNvdXJjZVJlcXVlc3QucmVx dWVzdCgpKTsKKyAgICByZXR1cm4gQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjpkZWNv ZGUoZGVjb2RlciwgcmVxdWVzdCk7Cit9CisKKyNlbmRpZiAvLyBFTkFCTEUoQ1VTVE9NX1BST1RP Q09MUykKKwogdm9pZCBBcmd1bWVudENvZGVyPFJlc291cmNlRXJyb3I+OjplbmNvZGUoQXJndW1l bnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZUVycm9yJiByZXNvdXJjZUVycm9yKQog ewogICAgIGVuY29kZVBsYXRmb3JtRGF0YShlbmNvZGVyLCByZXNvdXJjZUVycm9yKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuaCBiL1Nv dXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuaAppbmRleCAzYzEyODg3 NjAxOTRmMWNiYzk2Njg1YmE1MTBlMTQwNTcwZWU4OGNiLi5jOGMzYzlkN2E0MmY3NTlmMjRhMmI3 YzRiMGZjZDQxYTczMzQyMzZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2Vi Q29yZUFyZ3VtZW50Q29kZXJzLmgKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVB cmd1bWVudENvZGVycy5oCkBAIC01Nyw2ICs1Nyw3IEBAIGNsYXNzIFByb3RlY3Rpb25TcGFjZTsK IGNsYXNzIFJlZ2lvbjsKIGNsYXNzIFJlc291cmNlRXJyb3I7CiBjbGFzcyBSZXNvdXJjZVJlcXVl c3Q7CitjbGFzcyBSZXNvdXJjZVJlcXVlc3RXaXRoQm9keTsKIGNsYXNzIFJlc291cmNlUmVzcG9u c2U7CiBjbGFzcyBTZXNzaW9uSUQ7CiBjbGFzcyBTdGVwc1RpbWluZ0Z1bmN0aW9uOwpAQCAtMjUx LDYgKzI1MiwxNSBAQCB0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1bWVudENvZGVyPFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdD4gewogICAgIHN0YXRpYyBib29sIGRlY29kZVBsYXRmb3JtRGF0YShBcmd1 bWVudERlY29kZXImLCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKIH07CiAKKyNpZiBFTkFC TEUoQ1VTVE9NX1BST1RPQ09MUykKK3RlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8V2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHk+IHsKKyAgICBzdGF0aWMgdm9pZCBlbmNvZGUo QXJndW1lbnRFbmNvZGVyJiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkm KTsKKyAgICBzdGF0aWMgYm9vbCBkZWNvZGUoQXJndW1lbnREZWNvZGVyJiwgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0V2l0aEJvZHkmKTsKKyAgICBzdGF0aWMgdm9pZCBlbmNvZGVQbGF0Zm9ybURh dGEoQXJndW1lbnRFbmNvZGVyJiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0V2l0aEJv ZHkmKTsKKyAgICBzdGF0aWMgYm9vbCBkZWNvZGVQbGF0Zm9ybURhdGEoQXJndW1lbnREZWNvZGVy JiwgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkmKTsKK307CisjZW5kaWYgLy8gRU5B QkxFKENVU1RPTV9QUk9UT0NPTFMpCisKIHRlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29kZXI8 V2ViQ29yZTo6UmVzb3VyY2VFcnJvcj4gewogICAgIHN0YXRpYyB2b2lkIGVuY29kZShBcmd1bWVu dEVuY29kZXImLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7CiAgICAgc3RhdGljIGJv b2wgZGVjb2RlKEFyZ3VtZW50RGVjb2RlciYsIFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29kZXJz TWFjLm1tIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL21hYy9XZWJDb3JlQXJndW1lbnRDb2RlcnNN YWMubW0KaW5kZXggZjRhZGQ4NTcyOGFlMGZiNDgyODI0YWJiYzUzYjk0ODhmYzFjYTliZS4uZTY4 MzU2MGNmNzA3OGRjNGQzOTM5MjlhMTA5N2NkNzBiODMzMTAzMyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvU2hhcmVkL21hYy9XZWJDb3JlQXJndW1lbnRDb2RlcnNNYWMubW0KKysrIGIvU291 cmNlL1dlYktpdDIvU2hhcmVkL21hYy9XZWJDb3JlQXJndW1lbnRDb2RlcnNNYWMubW0KQEAgLTM3 LDYgKzM3LDcgQEAKICNpbXBvcnQgPFdlYkNvcmUvUHJvdGVjdGlvblNwYWNlLmg+CiAjaW1wb3J0 IDxXZWJDb3JlL1Jlc291cmNlRXJyb3IuaD4KICNpbXBvcnQgPFdlYkNvcmUvUmVzb3VyY2VSZXF1 ZXN0Lmg+CisjaW1wb3J0IDxXZWJDb3JlL1Jlc291cmNlUmVxdWVzdFdpdGhCb2R5Lmg+CiAKICNp ZiBVU0UoQ0ZORVRXT1JLKQogI2ltcG9ydCA8Q0ZOZXR3b3JrL0NGVVJMUmVxdWVzdC5oPgpAQCAt NDcsOSArNDgsMTggQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiBuYW1lc3BhY2UgSVBDIHsK IAogI2lmIFVTRShDRk5FVFdPUkspCi12b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0 Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCisjZGVmaW5lIFhVUkxSZXF1ZXN0IENGVVJM UmVxdWVzdFJlZgorI2RlZmluZSB4VVJMUmVxdWVzdCBjZlVSTFJlcXVlc3QKKyNkZWZpbmUgWFVS TFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbiBXS0NGVVJMUmVxdWVzdENy ZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uCisjZWxzZQorI2RlZmluZSBYVVJMUmVxdWVz dCBOU1VSTFJlcXVlc3QKKyNkZWZpbmUgeFVSTFJlcXVlc3QgbnNVUkxSZXF1ZXN0CisjZGVmaW5l IFhVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24gV0tOU1VSTFJlcXVl c3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbgorI2VuZGlmIC8vIFVTRShDRk5FVFdP UkspCisKK3N0YXRpYyB2b2lkIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50UGxhdGZvcm1E YXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNv dXJjZVJlcXVlc3QsIGJvb2wgc2hvdWxkU3RyaXBIVFRQQm9keSkKIHsKLSAgICBSZXRhaW5QdHI8 Q0ZVUkxSZXF1ZXN0UmVmPiByZXF1ZXN0VG9TZXJpYWxpemUgPSByZXNvdXJjZVJlcXVlc3QuY2ZV UkxSZXF1ZXN0KERvTm90VXBkYXRlSFRUUEJvZHkpOworICAgIFJldGFpblB0cjxYVVJMUmVxdWVz dD4gcmVxdWVzdFRvU2VyaWFsaXplID0gcmVzb3VyY2VSZXF1ZXN0LnhVUkxSZXF1ZXN0KERvTm90 VXBkYXRlSFRUUEJvZHkpOwogCiAgICAgYm9vbCByZXF1ZXN0SXNQcmVzZW50ID0gcmVxdWVzdFRv U2VyaWFsaXplOwogICAgIGVuY29kZXIgPDwgcmVxdWVzdElzUHJlc2VudDsKQEAgLTU5LDQ3ICs2 OSw0MyBAQCB2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlUGxhdGZv cm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlcgogCiAgICAgLy8gV2UgZG9uJ3Qgc2VuZCBI VFRQIGJvZHkgb3ZlciBJUEMgZm9yIGJldHRlciBwZXJmb3JtYW5jZS4KICAgICAvLyBBbHNvLCBp dCdzIG5vdCBhbHdheXMgcG9zc2libGUgdG8gZG8sIGFzIHN0cmVhbXMgY2FuIG9ubHkgYmUgY3Jl YXRlZCBpbiBwcm9jZXNzIHRoYXQgZG9lcyBuZXR3b3JraW5nLgorI2lmIFVTRShDRk5FVFdPUksp CiAgICAgUmV0YWluUHRyPENGRGF0YVJlZj4gcmVxdWVzdEhUVFBCb2R5ID0gYWRvcHRDRihDRlVS TFJlcXVlc3RDb3B5SFRUUFJlcXVlc3RCb2R5KHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSkpOwog ICAgIFJldGFpblB0cjxDRlJlYWRTdHJlYW1SZWY+IHJlcXVlc3RIVFRQQm9keVN0cmVhbSA9IGFk b3B0Q0YoQ0ZVUkxSZXF1ZXN0Q29weUhUVFBSZXF1ZXN0Qm9keVN0cmVhbShyZXF1ZXN0VG9TZXJp YWxpemUuZ2V0KCkpKTsKKyAgICBDRk11dGFibGVVUkxSZXF1ZXN0UmVmIG11dGFibGVSZXF1ZXN0 ID0gTlVMTDsKICAgICBpZiAocmVxdWVzdEhUVFBCb2R5IHx8IHJlcXVlc3RIVFRQQm9keVN0cmVh bSkgewotICAgICAgICBDRk11dGFibGVVUkxSZXF1ZXN0UmVmIG11dGFibGVSZXF1ZXN0ID0gQ0ZV UkxSZXF1ZXN0Q3JlYXRlTXV0YWJsZUNvcHkoMCwgcmVxdWVzdFRvU2VyaWFsaXplLmdldCgpKTsK KyAgICAgICAgbXV0YWJsZVJlcXVlc3QgPSBDRlVSTFJlcXVlc3RDcmVhdGVNdXRhYmxlQ29weSgw LCByZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCkpOwogICAgICAgICByZXF1ZXN0VG9TZXJpYWxpemUg PSBhZG9wdENGKG11dGFibGVSZXF1ZXN0KTsKKyAgICB9CisgICAgaWYgKHJlcXVlc3RIVFRQQm9k eSAmJiBzaG91bGRTdHJpcEhUVFBCb2R5KQogICAgICAgICBDRlVSTFJlcXVlc3RTZXRIVFRQUmVx dWVzdEJvZHkobXV0YWJsZVJlcXVlc3QsIG5pbCk7CisgICAgaWYgKHJlcXVlc3RIVFRQQm9keVN0 cmVhbSkKICAgICAgICAgQ0ZVUkxSZXF1ZXN0U2V0SFRUUFJlcXVlc3RCb2R5U3RyZWFtKG11dGFi bGVSZXF1ZXN0LCBuaWwpOworI2Vsc2UKKyAgICBOU0RhdGEgKnJlcXVlc3RIVFRQQm9keSA9IFty ZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHldOworICAgIE5TSW5wdXRTdHJlYW0gKnJlcXVlc3RI VFRQQm9keVN0cmVhbSA9IFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHlTdHJlYW1dOworICAg IE5TTXV0YWJsZVVSTFJlcXVlc3QgKm11dGFibGVSZXF1ZXN0ID0gbmlsOworICAgIGlmIChyZXF1 ZXN0SFRUUEJvZHkgfHwgcmVxdWVzdEhUVFBCb2R5U3RyZWFtKSB7CisgICAgICAgIG11dGFibGVS ZXF1ZXN0ID0gW3JlcXVlc3RUb1NlcmlhbGl6ZSBtdXRhYmxlQ29weV07CisgICAgICAgIHJlcXVl c3RUb1NlcmlhbGl6ZSA9IGFkb3B0TlMobXV0YWJsZVJlcXVlc3QpOwogICAgIH0KKyAgICBpZiAo cmVxdWVzdEhUVFBCb2R5ICYmIHNob3VsZFN0cmlwSFRUUEJvZHkpCisgICAgICAgIFttdXRhYmxl UmVxdWVzdCBzZXRIVFRQQm9keTpuaWxdOworICAgIGlmIChyZXF1ZXN0SFRUUEJvZHlTdHJlYW0p CisgICAgICAgIFttdXRhYmxlUmVxdWVzdCBzZXRIVFRQQm9keVN0cmVhbTpuaWxdOworI2VuZGlm IC8vIFVTRShDRk5FVFdPUkspCiAKLSAgICBSZXRhaW5QdHI8Q0ZEaWN0aW9uYXJ5UmVmPiBkaWN0 aW9uYXJ5ID0gYWRvcHRDRihXS0NGVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2Vu dGF0aW9uKHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSwgSVBDOjp0b2tlbk51bGxUeXBlUmVmKCkp KTsKKyAgICBSZXRhaW5QdHI8Q0ZEaWN0aW9uYXJ5UmVmPiBkaWN0aW9uYXJ5ID0gYWRvcHRDRihY VVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uKHJlcXVlc3RUb1Nlcmlh bGl6ZS5nZXQoKSwgSVBDOjp0b2tlbk51bGxUeXBlUmVmKCkpKTsKICAgICBJUEM6OmVuY29kZShl bmNvZGVyLCBkaWN0aW9uYXJ5LmdldCgpKTsKIAotICAgIC8vIFRoZSBmYWxsYmFjayBhcnJheSBp cyBwYXJ0IG9mIENGVVJMUmVxdWVzdCwgYnV0IGl0IGlzIG5vdCBlbmNvZGVkIGJ5IFdLQ0ZVUkxS ZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24uCisgICAgLy8gVGhlIGZhbGxi YWNrIGFycmF5IGlzIHBhcnQgb2YgWFVSTFJlcXVlc3QsIGJ1dCBpdCBpcyBub3QgZW5jb2RlZCBi eSBYVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uLgogICAgIGVuY29k ZXIgPDwgcmVzb3VyY2VSZXF1ZXN0LnJlc3BvbnNlQ29udGVudERpc3Bvc2l0aW9uRW5jb2RpbmdG YWxsYmFja0FycmF5KCk7CiB9Ci0jZWxzZQorCiB2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VS ZXF1ZXN0Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29u c3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCiB7Ci0gICAgUmV0YWluUHRyPE5T VVJMUmVxdWVzdD4gcmVxdWVzdFRvU2VyaWFsaXplID0gcmVzb3VyY2VSZXF1ZXN0Lm5zVVJMUmVx dWVzdChEb05vdFVwZGF0ZUhUVFBCb2R5KTsKLQotICAgIGJvb2wgcmVxdWVzdElzUHJlc2VudCA9 IHJlcXVlc3RUb1NlcmlhbGl6ZTsKLSAgICBlbmNvZGVyIDw8IHJlcXVlc3RJc1ByZXNlbnQ7Ci0K LSAgICBpZiAoIXJlcXVlc3RJc1ByZXNlbnQpCi0gICAgICAgIHJldHVybjsKLQotICAgIC8vIFdl IGRvbid0IHNlbmQgSFRUUCBib2R5IG92ZXIgSVBDIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCi0g ICAgLy8gQWxzbywgaXQncyBub3QgYWx3YXlzIHBvc3NpYmxlIHRvIGRvLCBhcyBzdHJlYW1zIGNh biBvbmx5IGJlIGNyZWF0ZWQgaW4gcHJvY2VzcyB0aGF0IGRvZXMgbmV0d29ya2luZy4KLSAgICBp ZiAoW3JlcXVlc3RUb1NlcmlhbGl6ZSBIVFRQQm9keV0gfHwgW3JlcXVlc3RUb1NlcmlhbGl6ZSBI VFRQQm9keVN0cmVhbV0pIHsKLSAgICAgICAgcmVxdWVzdFRvU2VyaWFsaXplID0gYWRvcHROUyhb cmVxdWVzdFRvU2VyaWFsaXplIG11dGFibGVDb3B5XSk7Ci0gICAgICAgIFsoTlNNdXRhYmxlVVJM UmVxdWVzdCAqKXJlcXVlc3RUb1NlcmlhbGl6ZSBzZXRIVFRQQm9keTpuaWxdOwotICAgICAgICBb KE5TTXV0YWJsZVVSTFJlcXVlc3QgKilyZXF1ZXN0VG9TZXJpYWxpemUgc2V0SFRUUEJvZHlTdHJl YW06bmlsXTsKLSAgICB9Ci0KLSAgICBSZXRhaW5QdHI8Q0ZEaWN0aW9uYXJ5UmVmPiBkaWN0aW9u YXJ5ID0gYWRvcHRDRihXS05TVVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0 aW9uKHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSwgSVBDOjp0b2tlbk51bGxUeXBlUmVmKCkpKTsK LSAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBkaWN0aW9uYXJ5LmdldCgpKTsKLQotICAgIC8vIFRo ZSBmYWxsYmFjayBhcnJheSBpcyBwYXJ0IG9mIE5TVVJMUmVxdWVzdCwgYnV0IGl0IGlzIG5vdCBl bmNvZGVkIGJ5IFdLTlNVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24u Ci0gICAgZW5jb2RlciA8PCByZXNvdXJjZVJlcXVlc3QucmVzcG9uc2VDb250ZW50RGlzcG9zaXRp b25FbmNvZGluZ0ZhbGxiYWNrQXJyYXkoKTsKKyAgICBFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1 bWVudFBsYXRmb3JtRGF0YShlbmNvZGVyLCByZXNvdXJjZVJlcXVlc3QsIHRydWUpOwogfQotI2Vu ZGlmCiAKIGJvb2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjpkZWNvZGVQbGF0Zm9y bURhdGEoQXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNl UmVxdWVzdCkKIHsKQEAgLTE0Myw2ICsxNDksMjEgQEAgYm9vbCBBcmd1bWVudENvZGVyPFJlc291 cmNlUmVxdWVzdD46OmRlY29kZVBsYXRmb3JtRGF0YShBcmd1bWVudERlY29kZXImIGRlY29kZXIK ICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorI2lmIEVOQUJMRShDVVNUT01fUFJPVE9DT0xTKQorCit2 b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHk+OjplbmNvZGVQbGF0Zm9y bURhdGEoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3RXaXRo Qm9keSYgcmVzb3VyY2VSZXF1ZXN0KQoreworICAgIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3Vt ZW50UGxhdGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVzdC5yZXF1ZXN0KCksIGZhbHNl KTsKK30KKworYm9vbCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdFdpdGhCb2R5Pjo6ZGVj b2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50RGVjb2RlciYgZGVjb2RlciwgUmVzb3VyY2VSZXF1ZXN0 V2l0aEJvZHkmIHJlc291cmNlUmVxdWVzdCkKK3sKKyAgICBSZXNvdXJjZVJlcXVlc3QmIHJlcXVl c3QgPSBjb25zdF9jYXN0PFJlc291cmNlUmVxdWVzdCY+KHJlc291cmNlUmVxdWVzdC5yZXF1ZXN0 KCkpOworICAgIHJldHVybiBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmRlY29kZVBs YXRmb3JtRGF0YShkZWNvZGVyLCByZXF1ZXN0KTsKK30KKworI2VuZGlmIC8vIEVOQUJMRShDVVNU T01fUFJPVE9DT0xTKQorCiB2b2lkIEFyZ3VtZW50Q29kZXI8Q2VydGlmaWNhdGVJbmZvPjo6ZW5j b2RlKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgQ2VydGlmaWNhdGVJbmZvJiBjZXJ0 aWZpY2F0ZUluZm8pCiB7CiAgICAgQ0ZBcnJheVJlZiBjZXJ0aWZpY2F0ZUNoYWluID0gY2VydGlm aWNhdGVJbmZvLmNlcnRpZmljYXRlQ2hhaW4oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQ cm94eS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xz L0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5LmgKaW5kZXggMjVhOTY3MDJlNzc5Mzc0OTRmZmE4 ZGM1YjUxNDliMWJhMjQ5YzM5OC4uZTIzOWZhOTE0MDA0ZDRmNjdkYmJlZjU1NWU0NjlhZDU3NTdj NGUzMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9t UHJvdG9jb2xzL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5LmgKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0N1c3RvbVByb3RvY29sTWFuYWdl clByb3h5LmgKQEAgLTM3LDcgKzM3LDcgQEAgT0JKQ19DTEFTUyBXS0N1c3RvbVByb3RvY29sTG9h ZGVyOwogI2VuZGlmCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKLWNsYXNzIFJlc291cmNlUmVxdWVz dDsKK2NsYXNzIFJlc291cmNlUmVxdWVzdFdpdGhCb2R5OwogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTQ5LDcgKzQ5LDcgQEAgY2xhc3MgQ3VzdG9tUHJv dG9jb2xNYW5hZ2VyUHJveHkgOiBwdWJsaWMgSVBDOjpNZXNzYWdlUmVjZWl2ZXIgewogcHVibGlj OgogICAgIGV4cGxpY2l0IEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5KENoaWxkUHJvY2Vzc1By b3h5KiwgV2ViQ29udGV4dCYpOwogCi0gICAgdm9pZCBzdGFydExvYWRpbmcodWludDY0X3QgY3Vz dG9tUHJvdG9jb2xJRCwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdm9p ZCBzdGFydExvYWRpbmcodWludDY0X3QgY3VzdG9tUHJvdG9jb2xJRCwgY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0V2l0aEJvZHkmKTsKICAgICB2b2lkIHN0b3BMb2FkaW5nKHVpbnQ2NF90 IGN1c3RvbVByb3RvY29sSUQpOwogCiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0N1c3RvbVByb3RvY29sTWFuYWdl clByb3h5Lm1lc3NhZ2VzLmluIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3Vz dG9tUHJvdG9jb2xzL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5Lm1lc3NhZ2VzLmluCmluZGV4 IDdhZWYwZTBlNzkyODZiOGRlYTlhYjFkNmY4NjU0MWFjMGI1OTk0ZWIuLmIzNTk5ZTMzMDg0MWEx MjMxYmZmNzNmNTgzN2Y0MjFhMzQxM2U4N2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9DdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94 eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvTmV0d29yay9DdXN0 b21Qcm90b2NvbHMvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHkubWVzc2FnZXMuaW4KQEAgLTIz LDcgKzIzLDcgQEAKICNpZiBFTkFCTEUoQ1VTVE9NX1BST1RPQ09MUykKIAogbWVzc2FnZXMgLT4g Q3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHkgewotICAgIFN0YXJ0TG9hZGluZyh1aW50NjRfdCBj dXN0b21Qcm90b2NvbElELCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdCkKKyAgICBT dGFydExvYWRpbmcodWludDY0X3QgY3VzdG9tUHJvdG9jb2xJRCwgV2ViQ29yZTo6UmVzb3VyY2VS ZXF1ZXN0V2l0aEJvZHkgcmVxdWVzdCkKICAgICBTdG9wTG9hZGluZyh1aW50NjRfdCBjdXN0b21Q cm90b2NvbElEKQogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvTmV0 d29yay9DdXN0b21Qcm90b2NvbHMvbWFjL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5TWFjLm1t IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL21hYy9D dXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eU1hYy5tbQppbmRleCA3ZDBlZmNhNDNmMzc4N2ZkOWU3 YTRkYzdhMDkyMTRmNjMxOTc1ZWU4Li41ZDdhYjNhMmFmZWVhY2E1NTM1OTQ1MTM4NWYyMWQ0ODA5 NjYxYTRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvTmV0d29yay9DdXN0 b21Qcm90b2NvbHMvbWFjL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5TWFjLm1tCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9tYWMvQ3VzdG9t UHJvdG9jb2xNYW5hZ2VyUHJveHlNYWMubW0KQEAgLTM2LDYgKzM2LDcgQEAKICNpbXBvcnQgIldl YkNvcmVBcmd1bWVudENvZGVycy5oIgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZUVycm9yLmg+ CiAjaW1wb3J0IDxXZWJDb3JlL1Jlc291cmNlUmVxdWVzdC5oPgorI2ltcG9ydCA8V2ViQ29yZS9S ZXNvdXJjZVJlcXVlc3RXaXRoQm9keS5oPgogI2ltcG9ydCA8V2ViQ29yZS9SZXNvdXJjZVJlc3Bv bnNlLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBJUEM7CkBAIC0xMzAsOCArMTMxLDkgQEAgQ3VzdG9t UHJvdG9jb2xNYW5hZ2VyUHJveHk6OkN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5KENoaWxkUHJv Y2Vzc1Byb3h5KiBjaGlsZFAKICAgICBtX2NoaWxkUHJvY2Vzc1Byb3h5LT5hZGRNZXNzYWdlUmVj ZWl2ZXIoTWVzc2FnZXM6OkN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjptZXNzYWdlUmVjZWl2 ZXJOYW1lKCksICp0aGlzKTsKIH0KIAotdm9pZCBDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eTo6 c3RhcnRMb2FkaW5nKHVpbnQ2NF90IGN1c3RvbVByb3RvY29sSUQsIGNvbnN0IFJlc291cmNlUmVx dWVzdCYgY29yZVJlcXVlc3QpCit2b2lkIEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpzdGFy dExvYWRpbmcodWludDY0X3QgY3VzdG9tUHJvdG9jb2xJRCwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0 V2l0aEJvZHkmIGNvcmVSZXF1ZXN0V2l0aEJvZHkpCiB7CisgICAgY29uc3QgUmVzb3VyY2VSZXF1 ZXN0JiBjb3JlUmVxdWVzdCA9IGNvcmVSZXF1ZXN0V2l0aEJvZHkucmVxdWVzdCgpOwogICAgIE5T VVJMUmVxdWVzdCAqcmVxdWVzdCA9IGNvcmVSZXF1ZXN0Lm5zVVJMUmVxdWVzdChEb05vdFVwZGF0 ZUhUVFBCb2R5KTsKICAgICBpZiAoIXJlcXVlc3QpCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdp dCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBjODU5NDQ5YTNiNjUy ZjQwMGI5ZTE0ODhjZTU5NzgxMWU0NzA1NGEwLi42ODhjYTA4ZTVlNzc2MGVmY2I4MzJkZGMzNjdk MmJjY2E0N2I1Yjc0IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTQtMTAtMjggIERhbmllbCBMYXphcmVua28gIDxk YW5pZWxvQG9wZXJhLmNvbT4KKworICAgICAgICBQT1NUIGZvcm0gZGF0YSBpcyBtaXNzaW5nIHdp dGggYSBjdXN0b20gTlNVUkxQcm90b2NvbAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTM3Mjk5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGVzdCBjYXNlIGZvciB1c2luZyBIVFRQIFBPU1Qgd2l0aCBhIGN1 c3RvbSBOU1VSTFByb3RvY29sLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyT2JqQy9DdXN0b21Qcm90b2NvbHNUZXN0Lm1tOgorICAgICAgICAoLVtXZWJLaXQyQ3VzdG9t UHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCBpbml0V2l0aFJlcXVlc3Q6 Y2FjaGVkUmVzcG9uc2U6Y2xpZW50Ol0pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6 CisKIDIwMTQtMDktMzAgIEV2YSBCYWxhenNmYWx2aSAgPGV2YWIudS1zemVnZWRAcGFydG5lci5z YW1zdW5nLmNvbT4KIAogICAgICAgICBSZW1vdmUgdGhpcmRwYXJ0eS91bml0dGVzdDIgZnJvbSB3 ZWJraXRweQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyT2Jq Qy9DdXN0b21Qcm90b2NvbHNUZXN0Lm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyT2JqQy9DdXN0b21Qcm90b2NvbHNUZXN0Lm1tCmluZGV4IGI3YjNlZDhiZTAxMjQ0MTM5MWE4 M2RhOWRlNjdhNjIzN2JiZDdiYjMuLjU5MTJiYTE4ODFmZWU5NTM1YWZiZDlhYThlMWVmOWRiOWMz MzVmZjUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMv Q3VzdG9tUHJvdG9jb2xzVGVzdC5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW0KQEAgLTMxLDE1ICszMSw0MSBAQAogI2lt cG9ydCAiVGVzdFByb3RvY29sLmgiCiAjaW1wb3J0IDxXZWJLaXQvV2ViS2l0Mi5oPgogI2ltcG9y dCA8d3RmL1JldGFpblB0ci5oPgorI2ltcG9ydCAiV1RGU3RyaW5nVXRpbGl0aWVzLmgiCiAKICNp ZiBXS19BUElfRU5BQkxFRAogCiBzdGF0aWMgYm9vbCB0ZXN0RmluaXNoZWQgPSBmYWxzZTsKIAor CitAaW50ZXJmYWNlIFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4aXN0 c1Byb3RvY29sIDogVGVzdFByb3RvY29sCitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBXZWJLaXQy Q3VzdG9tUHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbAorCistIChpbnN0 YW5jZXR5cGUpaW5pdFdpdGhSZXF1ZXN0OihOU1VSTFJlcXVlc3QgKilyZXF1ZXN0IGNhY2hlZFJl c3BvbnNlOihOU0NhY2hlZFVSTFJlc3BvbnNlICopY2FjaGVkUmVzcG9uc2UgY2xpZW50OihpZDxO U1VSTFByb3RvY29sQ2xpZW50PiljbGllbnQKK3sKKyAgICBOU0RhdGEgKmJvZHlEYXRhID0gcmVx dWVzdC5IVFRQQm9keTsKKyAgICBFWFBFQ1RfTk9UX05VTEwoYm9keURhdGEpOworICAgIEVYUEVD VF9OVUxMKHJlcXVlc3QuSFRUUEJvZHlTdHJlYW0pOworICAgIGlmIChib2R5RGF0YSAhPSBuaWwp IHsKKyAgICAgICAgUmV0YWluUHRyPE5TU3RyaW5nPiBib2R5ID0gYWRvcHROUyhbW05TU3RyaW5n IGFsbG9jXSBpbml0V2l0aERhdGE6Ym9keURhdGEgZW5jb2Rpbmc6TlNVVEY4U3RyaW5nRW5jb2Rp bmddKTsKKyAgICAgICAgRVhQRUNUX0VRKFN0cmluZygibG9naW49am9obiIpLCBTdHJpbmcoYm9k eS5nZXQoKSkpOworICAgIH0KKworICAgIHRlc3RGaW5pc2hlZCA9IHRydWU7CisKKyAgICByZXR1 cm4gW3N1cGVyIGluaXRXaXRoUmVxdWVzdDpyZXF1ZXN0IGNhY2hlZFJlc3BvbnNlOmNhY2hlZFJl c3BvbnNlIGNsaWVudDpjbGllbnRdOworfQorCitAZW5kCisKKwogbmFtZXNwYWNlIFRlc3RXZWJL aXRBUEkgewogCiBURVNUKFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0LCBNYWluUmVzb3VyY2Up CiB7CisgICAgdGVzdEZpbmlzaGVkID0gZmFsc2U7CiAgICAgW05TVVJMUHJvdG9jb2wgcmVnaXN0 ZXJDbGFzczpbVGVzdFByb3RvY29sIGNsYXNzXV07CiAgICAgW1dLQnJvd3NpbmdDb250ZXh0Q29u dHJvbGxlciByZWdpc3RlclNjaGVtZUZvckN1c3RvbVByb3RvY29sOltUZXN0UHJvdG9jb2wgc2No ZW1lXV07CiAKQEAgLTU0LDYgKzgwLDI1IEBAIFRFU1QoV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rl c3QsIE1haW5SZXNvdXJjZSkKICAgICBVdGlsOjpydW4oJnRlc3RGaW5pc2hlZCk7CiB9CiAKK1RF U1QoV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3QsIEZvcm1Qb3N0Qm9keUV4aXN0cykKK3sKKyAg ICB0ZXN0RmluaXNoZWQgPSBmYWxzZTsKKyAgICBbTlNVUkxQcm90b2NvbCByZWdpc3RlckNsYXNz OltXZWJLaXQyQ3VzdG9tUHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCBj bGFzc11dOworICAgIFtXS0Jyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgcmVnaXN0ZXJTY2hlbWVG b3JDdXN0b21Qcm90b2NvbDpbVGVzdFByb3RvY29sIHNjaGVtZV1dOworCisgICAgUmV0YWluUHRy PFdLUHJvY2Vzc0dyb3VwPiBwcm9jZXNzR3JvdXAgPSBhZG9wdE5TKFtbV0tQcm9jZXNzR3JvdXAg YWxsb2NdIGluaXRdKTsKKyAgICBSZXRhaW5QdHI8V0tCcm93c2luZ0NvbnRleHRHcm91cD4gYnJv d3NpbmdDb250ZXh0R3JvdXAgPSBhZG9wdE5TKFtbV0tCcm93c2luZ0NvbnRleHRHcm91cCBhbGxv Y10gaW5pdFdpdGhJZGVudGlmaWVyOkAiVGVzdElkZW50aWZpZXIiXSk7CisgICAgUmV0YWluUHRy PFdLVmlldz4gd2tWaWV3ID0gYWRvcHROUyhbW1dLVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpO U01ha2VSZWN0KDAsIDAsIDgwMCwgNjAwKSBwcm9jZXNzR3JvdXA6cHJvY2Vzc0dyb3VwLmdldCgp IGJyb3dzaW5nQ29udGV4dEdyb3VwOmJyb3dzaW5nQ29udGV4dEdyb3VwLmdldCgpXSk7CisKKyAg ICBOU1VSTCAqdXJsID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6W05TU3RyaW5nIHN0cmluZ1dpdGhG b3JtYXQ6QCIlQDovL0Zvcm1Qb3N0Qm9keUV4aXN0cyIsIFtUZXN0UHJvdG9jb2wgc2NoZW1lXV1d OworICAgIE5TU3RyaW5nICpodG1sID0gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCI8aHRt bD48Ym9keSBvbmxvYWQ9XCJkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZicpLnN1Ym1pdCgpXCI+ PGZvcm0gaWQ9XCJmXCIgYWN0aW9uPVwiJUBcIiBtZXRob2Q9XCJwb3N0XCI+PGlucHV0IG5hbWU9 XCJsb2dpblwiIHZhbHVlPVwiam9oblwiIC8+PC9mb3JtPjwvYm9keT48L2h0bWw+IiwgdXJsLmFi c29sdXRlU3RyaW5nXTsKKyAgICBbd2tWaWV3LmdldCgpLmJyb3dzaW5nQ29udGV4dENvbnRyb2xs ZXIgbG9hZEhUTUxTdHJpbmc6aHRtbCBiYXNlVVJMOm5pbF07CisKKyAgICBVdGlsOjpydW4oJnRl c3RGaW5pc2hlZCk7CisgICAgW05TVVJMUHJvdG9jb2wgdW5yZWdpc3RlckNsYXNzOltXZWJLaXQy Q3VzdG9tUHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCBjbGFzc11dOwor ICAgIFtXS0Jyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgdW5yZWdpc3RlclNjaGVtZUZvckN1c3Rv bVByb3RvY29sOltUZXN0UHJvdG9jb2wgc2NoZW1lXV07Cit9CisKIH0gLy8gbmFtZXNwYWNlIFRl c3RXZWJLaXRBUEkKIAogI2VuZGlmIC8vIFdLX0FQSV9FTkFCTEVECg== 240667 2014-10-30 05:31:05 -0700 2015-01-05 03:50:06 -0800 Patch bug-137299-20141030133113.patch text/plain 15330 danielo U3VidmVyc2lvbiBSZXZpc2lvbjogMTc0MTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMWMxMzQ0NzVlYTU3M2Uw NjMwY2U4OGE0Yzg1NTNmMTEzYzIzZWQ0YS4uMjQ4NWVjNTE2N2M1MWVkNGU0OTY4YWQwOTEyNTM2 NDRjNzQ4ZjVhMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDE0LTEwLTMwICBEYW5p ZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+CisKKyAgICAgICAgUE9TVCBmb3JtIGRh dGEgaXMgbWlzc2luZyB3aXRoIGEgY3VzdG9tIE5TVVJMUHJvdG9jb2wKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzI5OQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBPU1QgcmVxdWVzdCBmb3JtIGRhdGEg d2FzIG1pc3NpbmcgaW4gVUlQcm9jZXNzCisgICAgICAgIHdoZXJlIGEgY3VzdG9tIE5TVVJMUHJv dG9jb2wgbGl2ZXMsCisgICAgICAgIGJlY2F1c2UgaXQgd2FzIG5vdCBzZXJpYWxpemVkIG92ZXIg SVBDLgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBhbiBIVFRQIFBPU1QgYm9keSBmb3JtIGRh dGEgdG8gYmUgc2VudCBvdmVyIElQQworICAgICAgICBpbiB0aGUgQ3VzdG9tUHJvdG9jb2xNYW5h Z2VyUHJveHk6OlN0YXJ0TG9hZGluZyBtZXNzYWdlLgorICAgICAgICBJbiBvdGhlciBjYXNlcyB0 aGUgSFRUUCBib2R5IGlzIHN0cmlwcGVkIGFzIGJlZm9yZSAoZm9yIHBlcmZvcm1hbmNlIHJlYXNv bnMpLgorCisgICAgICAgIEluIG9yZGVyIHRvIHRyaWdnZXIgYSBkaWZmZXJlbnQgc2VyaWFsaXph dGlvbiBhbGdvcml0aG0gZm9yIFJlc291cmNlUmVxdWVzdAorICAgICAgICBhIHBhcmFtZXRlciBp cyBhZGRlZCB0byBSZXNvdXJjZVJlcXVlc3QgSVBDIGFyZ3VtZW50IGVuY29kZXIsCisgICAgICAg IHdoaWNoIGNvbnRyb2xzIGlmIHRoZSBOU1VSTFJlcXVlc3QuSFRUUEJvZHkgaXMgc3RyaXBwZWQu CisgICAgICAgIFdoZW4gc2VuZGluZyBhIEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFy dExvYWRpbmcgbWVzc2FnZSwKKyAgICAgICAgZW5jb2RlIG1lc3NhZ2UgcGFyYW1ldGVycyBzbyB0 aGF0IHRoZSBib2R5IGlzIG5vdCBzdHJpcHBlZC4KKworICAgICAgICBJbiBhZGRpdGlvbjoKKyAg ICAgICAgUmVmYWN0b3IgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0 Zm9ybURhdGEKKyAgICAgICAgaW4gb3JkZXIgdG8gcmVtb3ZlIGR1cGxpY2F0ZSBjb2RlLgorCisg ICAgICAgICogU2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0NvY29hL0N1c3RvbVByb3Rv Y29sTWFuYWdlckNvY29hLm1tOgorICAgICAgICAoLVtXS0N1c3RvbVByb3RvY29sIHN0YXJ0TG9h ZGluZ10pOgorICAgICAgICAqIFNoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuY3BwOgorICAg ICAgICAoSVBDOjpFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1bWVudCk6CisgICAgICAgIChJUEM6 OkFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlKToKKyAgICAgICAgKiBTaGFy ZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmg6CisgICAgICAgICogU2hhcmVkL21hYy9XZWJDb3Jl QXJndW1lbnRDb2RlcnNNYWMubW06CisgICAgICAgIChJUEM6OkVuY29kZVJlc291cmNlUmVxdWVz dEFyZ3VtZW50UGxhdGZvcm1EYXRhKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxSZXNv dXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEpOgorCiAyMDE0LTA5LTMwICBHeXV5b3Vu ZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVuYW1l IFRFU1RfVEhFTUVfRElSIG1hY3JvCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQv TmV0d29yay9DdXN0b21Qcm90b2NvbHMvQ29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2Eu bW0gYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvQ29jb2Ev Q3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2EubW0KaW5kZXggZmZiNGQxZTgyZTRmYjI4MzkxOTQ3 ZGM1NDIxZDgxYzRhNDE4NjQwOS4uYWQ4NjRmZmY4YjVlNjY2ZWE0N2ExNWMyNDkwM2M4YzMxYTBh Yjk4NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJv dG9jb2xzL0NvY29hL0N1c3RvbVByb3RvY29sTWFuYWdlckNvY29hLm1tCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1NoYXJlZC9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9Db2NvYS9DdXN0b21Qcm90b2Nv bE1hbmFnZXJDb2NvYS5tbQpAQCAtMTA2LDcgKzEwNiwxOSBAQCBzdGF0aWMgdWludDY0X3QgZ2Vu ZXJhdGVDdXN0b21Qcm90b2NvbElEKCkKIAogLSAodm9pZClzdGFydExvYWRpbmcKIHsKLSAgICBz aGFyZWRDdXN0b21Qcm90b2NvbE1hbmFnZXItPmNoaWxkUHJvY2VzcygpLT5zZW5kKE1lc3NhZ2Vz OjpDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eTo6U3RhcnRMb2FkaW5nKHNlbGYuY3VzdG9tUHJv dG9jb2xJRCwgW3NlbGYgcmVxdWVzdF0pLCAwKTsKKyAgICAvLyBDcmVhdGUgYSBTdGFydExvYWRp bmcgbWVzc2FnZS4KKyAgICB1c2luZyBNZXNzYWdlczo6Q3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJv eHk6OlN0YXJ0TG9hZGluZzsKKyAgICBhdXRvIG1lc3NhZ2UgPSBTdGFydExvYWRpbmcoc2VsZi5j dXN0b21Qcm90b2NvbElELCBbc2VsZiByZXF1ZXN0XSk7CisKKyAgICAvLyBFbmNvZGUgdGhlIG1l c3NhZ2UgYXJndW1lbnRzIG1hbnVhbGx5IHRvIHByZXNlcnZlIHRoZSByZXF1ZXN0IEhUVFAgYm9k eS4KKyAgICBhdXRvIGVuY29kZXIgPSBzdGQ6Om1ha2VfdW5pcXVlPElQQzo6TWVzc2FnZUVuY29k ZXI+KFN0YXJ0TG9hZGluZzo6cmVjZWl2ZXJOYW1lKCksIFN0YXJ0TG9hZGluZzo6bmFtZSgpLCAw KTsKKyAgICBhdXRvIGFyZ3VtZW50cyA9IG1lc3NhZ2UuYXJndW1lbnRzKCk7CisgICAgKmVuY29k ZXIgPDwgc3RkOjpnZXQ8MD4oYXJndW1lbnRzKTsKKyAgICBJUEM6OkVuY29kZVJlc291cmNlUmVx dWVzdEFyZ3VtZW50KCplbmNvZGVyLCBzdGQ6OmdldDwxPihhcmd1bWVudHMpLCBmYWxzZSk7CisK KyAgICAvLyBTZW5kIHRoZSBtZXNzYWdlLgorICAgIGF1dG8gY2hpbGRQcm9jZXNzID0gc2hhcmVk Q3VzdG9tUHJvdG9jb2xNYW5hZ2VyLT5jaGlsZFByb2Nlc3MoKTsKKyAgICBjaGlsZFByb2Nlc3Mt PnNlbmRNZXNzYWdlKFdURjo6bW92ZShlbmNvZGVyKSwgMCk7CiB9CiAKIC0gKHZvaWQpc3RvcExv YWRpbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRD b2RlcnMuY3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5j cHAKaW5kZXggY2RmYTcwZmMwNjk3MWQ2ZjNmMjBkNzcyNTA3YjkwZjVhMTIxZjllNy4uMWQ0MmNm OGNkODAzM2Y5MjAwMTQ0ZmMzMmQyMmYzYzk5OGQxYTliYiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5jcHAKKysrIGIvU291cmNlL1dlYktp dDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5jcHAKQEAgLTcwMSw3ICs3MDEsNyBAQCBi b29sIEFyZ3VtZW50Q29kZXI8Q3Vyc29yPjo6ZGVjb2RlKEFyZ3VtZW50RGVjb2RlciYgZGVjb2Rl ciwgQ3Vyc29yJiBjdXJzb3IpCiB9CiAjZW5kaWYKIAotdm9pZCBBcmd1bWVudENvZGVyPFJlc291 cmNlUmVxdWVzdD46OmVuY29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291 cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQordm9pZCBFbmNvZGVSZXNvdXJjZVJlcXVlc3RB cmd1bWVudChBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYg cmVzb3VyY2VSZXF1ZXN0LCBib29sIHNob3VsZFN0cmlwSFRUUEJvZHkpCiB7CiAjaWYgRU5BQkxF KENBQ0hFX1BBUlRJVElPTklORykKICAgICBlbmNvZGVyIDw8IHJlc291cmNlUmVxdWVzdC5jYWNo ZVBhcnRpdGlvbigpOwpAQCAtNzEzLDEzICs3MTMsMjYgQEAgdm9pZCBBcmd1bWVudENvZGVyPFJl c291cmNlUmVxdWVzdD46OmVuY29kZShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJl c28KIAogICAgIGlmIChyZXNvdXJjZVJlcXVlc3QuZW5jb2RpbmdSZXF1aXJlc1BsYXRmb3JtRGF0 YSgpKSB7CiAgICAgICAgIGVuY29kZXIgPDwgdHJ1ZTsKLSAgICAgICAgZW5jb2RlUGxhdGZvcm1E YXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVzdCk7CisgICAgICAgIEVuY29kZVJlc291cmNlUmVx dWVzdEFyZ3VtZW50UGxhdGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVzdCwgc2hvdWxk U3RyaXBIVFRQQm9keSk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAgICAgZW5jb2RlciA8PCBm YWxzZTsKICAgICByZXNvdXJjZVJlcXVlc3QuZW5jb2RlV2l0aG91dFBsYXRmb3JtRGF0YShlbmNv ZGVyKTsKIH0KIAordm9pZCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29kZShB cmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VS ZXF1ZXN0KQoreworICAgIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50KGVuY29kZXIsIHJl c291cmNlUmVxdWVzdCwgdHJ1ZSk7Cit9CisKKy8vIFBsYXRmb3JtcyB3aGljaCBkb24ndCBpbXBs ZW1lbnQgInNob3VsZFN0cmlwSFRUUEJvZHkiIG9wdGlvbiBqdXN0IGNhbGwgQXJndW1lbnRDb2Rl cjo6ZW5jb2RlUGxhdGZvcm1EYXRhLgorI2lmICFQTEFURk9STShNQUMpICYmICFQTEFURk9STShJ T1MpCit2b2lkIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50UGxhdGZvcm1EYXRhKEFyZ3Vt ZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNv dXJjZVJlcXVlc3QsIGJvb2wgc2hvdWxkU3RyaXBIVFRQQm9keSkKK3sKKyAgICBBcmd1bWVudENv ZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29kZVBsYXRmb3JtRGF0YShlbmNvZGVyLCByZXNvdXJj ZVJlcXVlc3QpOworfQorI2VuZGlmCisKIGJvb2wgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVl c3Q+OjpkZWNvZGUoQXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBSZXNvdXJjZVJlcXVlc3QmIHJl c291cmNlUmVxdWVzdCkKIHsKICNpZiBFTkFCTEUoQ0FDSEVfUEFSVElUSU9OSU5HKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5oIGIvU291 cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5oCmluZGV4IDNjMTI4ODc2 MDE5NGYxY2JjOTY2ODViYTUxMGUxNDA1NzBlZTg4Y2IuLjM4MmM2ODU1ZDQ0YWM4Mjg1ZjYyOWY4 MWM4YTM3OTU3ZmI1NzYzNTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJD b3JlQXJndW1lbnRDb2RlcnMuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViQ29yZUFy Z3VtZW50Q29kZXJzLmgKQEAgLTI1MSw2ICsyNTEsOSBAQCB0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1 bWVudENvZGVyPFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdD4gewogICAgIHN0YXRpYyBib29sIGRl Y29kZVBsYXRmb3JtRGF0YShBcmd1bWVudERlY29kZXImLCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3QmKTsKIH07CiAKK3ZvaWQgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnQoQXJndW1lbnRF bmNvZGVyJiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgYm9vbCBzaG91bGRTdHJp cEhUVFBCb2R5KTsKK3ZvaWQgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnRQbGF0Zm9ybURh dGEoQXJndW1lbnRFbmNvZGVyJiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgYm9v bCBzaG91bGRTdHJpcEhUVFBCb2R5KTsKKwogdGVtcGxhdGU8PiBzdHJ1Y3QgQXJndW1lbnRDb2Rl cjxXZWJDb3JlOjpSZXNvdXJjZUVycm9yPiB7CiAgICAgc3RhdGljIHZvaWQgZW5jb2RlKEFyZ3Vt ZW50RW5jb2RlciYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKICAgICBzdGF0aWMg Ym9vbCBkZWNvZGUoQXJndW1lbnREZWNvZGVyJiwgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL21hYy9XZWJDb3JlQXJndW1lbnRDb2Rl cnNNYWMubW0gYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVy c01hYy5tbQppbmRleCBmNGFkZDg1NzI4YWUwZmI0ODI4MjRhYmJjNTNiOTQ4OGZjMWNhOWJlLi40 NDI0MjU3M2Q0NDMxOWYzZmMxOGE3ZTkwZjQ0YmYzYzM0YzE1OTlhIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVyc01hYy5tbQorKysgYi9T b3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVyc01hYy5tbQpAQCAt NDcsOSArNDcsMTggQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiBuYW1lc3BhY2UgSVBDIHsK IAogI2lmIFVTRShDRk5FVFdPUkspCi12b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0 Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCisjZGVmaW5lIFhVUkxSZXF1ZXN0IENGVVJM UmVxdWVzdFJlZgorI2RlZmluZSB4VVJMUmVxdWVzdCBjZlVSTFJlcXVlc3QKKyNkZWZpbmUgWFVS TFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbiBXS0NGVVJMUmVxdWVzdENy ZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uCisjZWxzZQorI2RlZmluZSBYVVJMUmVxdWVz dCBOU1VSTFJlcXVlc3QKKyNkZWZpbmUgeFVSTFJlcXVlc3QgbnNVUkxSZXF1ZXN0CisjZGVmaW5l IFhVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24gV0tOU1VSTFJlcXVl c3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbgorI2VuZGlmIC8vIFVTRShDRk5FVFdP UkspCisKK3ZvaWQgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnRQbGF0Zm9ybURhdGEoQXJn dW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVx dWVzdCwgYm9vbCBzaG91bGRTdHJpcEhUVFBCb2R5KQogewotICAgIFJldGFpblB0cjxDRlVSTFJl cXVlc3RSZWY+IHJlcXVlc3RUb1NlcmlhbGl6ZSA9IHJlc291cmNlUmVxdWVzdC5jZlVSTFJlcXVl c3QoRG9Ob3RVcGRhdGVIVFRQQm9keSk7CisgICAgUmV0YWluUHRyPFhVUkxSZXF1ZXN0PiByZXF1 ZXN0VG9TZXJpYWxpemUgPSByZXNvdXJjZVJlcXVlc3QueFVSTFJlcXVlc3QoRG9Ob3RVcGRhdGVI VFRQQm9keSk7CiAKICAgICBib29sIHJlcXVlc3RJc1ByZXNlbnQgPSByZXF1ZXN0VG9TZXJpYWxp emU7CiAgICAgZW5jb2RlciA8PCByZXF1ZXN0SXNQcmVzZW50OwpAQCAtNTksNDcgKzY4LDQzIEBA IHZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEo QXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyCiAKICAgICAvLyBXZSBkb24ndCBzZW5kIEhUVFAgYm9k eSBvdmVyIElQQyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgogICAgIC8vIEFsc28sIGl0J3Mgbm90 IGFsd2F5cyBwb3NzaWJsZSB0byBkbywgYXMgc3RyZWFtcyBjYW4gb25seSBiZSBjcmVhdGVkIGlu IHByb2Nlc3MgdGhhdCBkb2VzIG5ldHdvcmtpbmcuCisjaWYgVVNFKENGTkVUV09SSykKICAgICBS ZXRhaW5QdHI8Q0ZEYXRhUmVmPiByZXF1ZXN0SFRUUEJvZHkgPSBhZG9wdENGKENGVVJMUmVxdWVz dENvcHlIVFRQUmVxdWVzdEJvZHkocmVxdWVzdFRvU2VyaWFsaXplLmdldCgpKSk7CiAgICAgUmV0 YWluUHRyPENGUmVhZFN0cmVhbVJlZj4gcmVxdWVzdEhUVFBCb2R5U3RyZWFtID0gYWRvcHRDRihD RlVSTFJlcXVlc3RDb3B5SFRUUFJlcXVlc3RCb2R5U3RyZWFtKHJlcXVlc3RUb1NlcmlhbGl6ZS5n ZXQoKSkpOworICAgIENGTXV0YWJsZVVSTFJlcXVlc3RSZWYgbXV0YWJsZVJlcXVlc3QgPSBOVUxM OwogICAgIGlmIChyZXF1ZXN0SFRUUEJvZHkgfHwgcmVxdWVzdEhUVFBCb2R5U3RyZWFtKSB7Ci0g ICAgICAgIENGTXV0YWJsZVVSTFJlcXVlc3RSZWYgbXV0YWJsZVJlcXVlc3QgPSBDRlVSTFJlcXVl c3RDcmVhdGVNdXRhYmxlQ29weSgwLCByZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCkpOworICAgICAg ICBtdXRhYmxlUmVxdWVzdCA9IENGVVJMUmVxdWVzdENyZWF0ZU11dGFibGVDb3B5KDAsIHJlcXVl c3RUb1NlcmlhbGl6ZS5nZXQoKSk7CiAgICAgICAgIHJlcXVlc3RUb1NlcmlhbGl6ZSA9IGFkb3B0 Q0YobXV0YWJsZVJlcXVlc3QpOworICAgIH0KKyAgICBpZiAocmVxdWVzdEhUVFBCb2R5ICYmIHNo b3VsZFN0cmlwSFRUUEJvZHkpCiAgICAgICAgIENGVVJMUmVxdWVzdFNldEhUVFBSZXF1ZXN0Qm9k eShtdXRhYmxlUmVxdWVzdCwgbmlsKTsKKyAgICBpZiAocmVxdWVzdEhUVFBCb2R5U3RyZWFtKQog ICAgICAgICBDRlVSTFJlcXVlc3RTZXRIVFRQUmVxdWVzdEJvZHlTdHJlYW0obXV0YWJsZVJlcXVl c3QsIG5pbCk7CisjZWxzZQorICAgIE5TRGF0YSAqcmVxdWVzdEhUVFBCb2R5ID0gW3JlcXVlc3RU b1NlcmlhbGl6ZSBIVFRQQm9keV07CisgICAgTlNJbnB1dFN0cmVhbSAqcmVxdWVzdEhUVFBCb2R5 U3RyZWFtID0gW3JlcXVlc3RUb1NlcmlhbGl6ZSBIVFRQQm9keVN0cmVhbV07CisgICAgTlNNdXRh YmxlVVJMUmVxdWVzdCAqbXV0YWJsZVJlcXVlc3QgPSBuaWw7CisgICAgaWYgKHJlcXVlc3RIVFRQ Qm9keSB8fCByZXF1ZXN0SFRUUEJvZHlTdHJlYW0pIHsKKyAgICAgICAgbXV0YWJsZVJlcXVlc3Qg PSBbcmVxdWVzdFRvU2VyaWFsaXplIG11dGFibGVDb3B5XTsKKyAgICAgICAgcmVxdWVzdFRvU2Vy aWFsaXplID0gYWRvcHROUyhtdXRhYmxlUmVxdWVzdCk7CiAgICAgfQorICAgIGlmIChyZXF1ZXN0 SFRUUEJvZHkgJiYgc2hvdWxkU3RyaXBIVFRQQm9keSkKKyAgICAgICAgW211dGFibGVSZXF1ZXN0 IHNldEhUVFBCb2R5Om5pbF07CisgICAgaWYgKHJlcXVlc3RIVFRQQm9keVN0cmVhbSkKKyAgICAg ICAgW211dGFibGVSZXF1ZXN0IHNldEhUVFBCb2R5U3RyZWFtOm5pbF07CisjZW5kaWYgLy8gVVNF KENGTkVUV09SSykKIAotICAgIFJldGFpblB0cjxDRkRpY3Rpb25hcnlSZWY+IGRpY3Rpb25hcnkg PSBhZG9wdENGKFdLQ0ZVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24o cmVxdWVzdFRvU2VyaWFsaXplLmdldCgpLCBJUEM6OnRva2VuTnVsbFR5cGVSZWYoKSkpOworICAg IFJldGFpblB0cjxDRkRpY3Rpb25hcnlSZWY+IGRpY3Rpb25hcnkgPSBhZG9wdENGKFhVUkxSZXF1 ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24ocmVxdWVzdFRvU2VyaWFsaXplLmdl dCgpLCBJUEM6OnRva2VuTnVsbFR5cGVSZWYoKSkpOwogICAgIElQQzo6ZW5jb2RlKGVuY29kZXIs IGRpY3Rpb25hcnkuZ2V0KCkpOwogCi0gICAgLy8gVGhlIGZhbGxiYWNrIGFycmF5IGlzIHBhcnQg b2YgQ0ZVUkxSZXF1ZXN0LCBidXQgaXQgaXMgbm90IGVuY29kZWQgYnkgV0tDRlVSTFJlcXVlc3RD cmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbi4KKyAgICAvLyBUaGUgZmFsbGJhY2sgYXJy YXkgaXMgcGFydCBvZiBYVVJMUmVxdWVzdCwgYnV0IGl0IGlzIG5vdCBlbmNvZGVkIGJ5IFhVUkxS ZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24uCiAgICAgZW5jb2RlciA8PCBy ZXNvdXJjZVJlcXVlc3QucmVzcG9uc2VDb250ZW50RGlzcG9zaXRpb25FbmNvZGluZ0ZhbGxiYWNr QXJyYXkoKTsKIH0KLSNlbHNlCisKIHZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+ OjplbmNvZGVQbGF0Zm9ybURhdGEoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNv dXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCkKIHsKLSAgICBSZXRhaW5QdHI8TlNVUkxSZXF1 ZXN0PiByZXF1ZXN0VG9TZXJpYWxpemUgPSByZXNvdXJjZVJlcXVlc3QubnNVUkxSZXF1ZXN0KERv Tm90VXBkYXRlSFRUUEJvZHkpOwotCi0gICAgYm9vbCByZXF1ZXN0SXNQcmVzZW50ID0gcmVxdWVz dFRvU2VyaWFsaXplOwotICAgIGVuY29kZXIgPDwgcmVxdWVzdElzUHJlc2VudDsKLQotICAgIGlm ICghcmVxdWVzdElzUHJlc2VudCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgLy8gV2UgZG9uJ3Qg c2VuZCBIVFRQIGJvZHkgb3ZlciBJUEMgZm9yIGJldHRlciBwZXJmb3JtYW5jZS4KLSAgICAvLyBB bHNvLCBpdCdzIG5vdCBhbHdheXMgcG9zc2libGUgdG8gZG8sIGFzIHN0cmVhbXMgY2FuIG9ubHkg YmUgY3JlYXRlZCBpbiBwcm9jZXNzIHRoYXQgZG9lcyBuZXR3b3JraW5nLgotICAgIGlmIChbcmVx dWVzdFRvU2VyaWFsaXplIEhUVFBCb2R5XSB8fCBbcmVxdWVzdFRvU2VyaWFsaXplIEhUVFBCb2R5 U3RyZWFtXSkgewotICAgICAgICByZXF1ZXN0VG9TZXJpYWxpemUgPSBhZG9wdE5TKFtyZXF1ZXN0 VG9TZXJpYWxpemUgbXV0YWJsZUNvcHldKTsKLSAgICAgICAgWyhOU011dGFibGVVUkxSZXF1ZXN0 ICopcmVxdWVzdFRvU2VyaWFsaXplIHNldEhUVFBCb2R5Om5pbF07Ci0gICAgICAgIFsoTlNNdXRh YmxlVVJMUmVxdWVzdCAqKXJlcXVlc3RUb1NlcmlhbGl6ZSBzZXRIVFRQQm9keVN0cmVhbTpuaWxd OwotICAgIH0KLQotICAgIFJldGFpblB0cjxDRkRpY3Rpb25hcnlSZWY+IGRpY3Rpb25hcnkgPSBh ZG9wdENGKFdLTlNVUkxSZXF1ZXN0Q3JlYXRlU2VyaWFsaXphYmxlUmVwcmVzZW50YXRpb24ocmVx dWVzdFRvU2VyaWFsaXplLmdldCgpLCBJUEM6OnRva2VuTnVsbFR5cGVSZWYoKSkpOwotICAgIElQ Qzo6ZW5jb2RlKGVuY29kZXIsIGRpY3Rpb25hcnkuZ2V0KCkpOwotCi0gICAgLy8gVGhlIGZhbGxi YWNrIGFycmF5IGlzIHBhcnQgb2YgTlNVUkxSZXF1ZXN0LCBidXQgaXQgaXMgbm90IGVuY29kZWQg YnkgV0tOU1VSTFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbi4KLSAgICBl bmNvZGVyIDw8IHJlc291cmNlUmVxdWVzdC5yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29k aW5nRmFsbGJhY2tBcnJheSgpOworICAgIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50UGxh dGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVzdCwgdHJ1ZSk7CiB9Ci0jZW5kaWYKIAog Ym9vbCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmRlY29kZVBsYXRmb3JtRGF0YShB cmd1bWVudERlY29kZXImIGRlY29kZXIsIFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0 KQogewpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4 IGM4NTk0NDlhM2I2NTJmNDAwYjllMTQ4OGNlNTk3ODExZTQ3MDU0YTAuLjI5ZDJkMmUyMjZlNGI5 ZWMyODdhN2Y5NTI3N2I1MjdjMmQ4ZTA3N2QgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZwor KysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNiBAQAorMjAxNC0xMC0zMCAgRGFuaWVs IExhemFyZW5rbyAgPGRhbmllbG9Ab3BlcmEuY29tPgorCisgICAgICAgIFBPU1QgZm9ybSBkYXRh IGlzIG1pc3Npbmcgd2l0aCBhIGN1c3RvbSBOU1VSTFByb3RvY29sCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzcyOTkKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0IGNhc2UgZm9yIHVzaW5nIEhUVFAg UE9TVCB3aXRoIGEgY3VzdG9tIE5TVVJMUHJvdG9jb2wuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW06CisgICAgICAgICgt W1dlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4aXN0c1Byb3RvY29sIGlu aXRXaXRoUmVxdWVzdDpjYWNoZWRSZXNwb25zZTpjbGllbnQ6XSk6CisgICAgICAgIChUZXN0V2Vi S2l0QVBJOjpURVNUKToKKwogMjAxNC0wOS0zMCAgRXZhIEJhbGF6c2ZhbHZpICA8ZXZhYi51LXN6 ZWdlZEBwYXJ0bmVyLnNhbXN1bmcuY29tPgogCiAgICAgICAgIFJlbW92ZSB0aGlyZHBhcnR5L3Vu aXR0ZXN0MiBmcm9tIHdlYmtpdHB5CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW0gYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDJPYmpDL0N1c3RvbVByb3RvY29sc1Rlc3QubW0KaW5kZXggYjdiM2Vk OGJlMDEyNDQxMzkxYTgzZGE5ZGU2N2E2MjM3YmJkN2JiMy4uNTkxMmJhMTg4MWZlZTk1MzVhZmJk OWFhOGUxZWY5ZGI5YzMzNWZmNSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXQyT2JqQy9DdXN0b21Qcm90b2NvbHNUZXN0Lm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVzdC5tbQpAQCAtMzEsMTUg KzMxLDQxIEBACiAjaW1wb3J0ICJUZXN0UHJvdG9jb2wuaCIKICNpbXBvcnQgPFdlYktpdC9XZWJL aXQyLmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CisjaW1wb3J0ICJXVEZTdHJpbmdVdGls aXRpZXMuaCIKIAogI2lmIFdLX0FQSV9FTkFCTEVECiAKIHN0YXRpYyBib29sIHRlc3RGaW5pc2hl ZCA9IGZhbHNlOwogCisKK0BpbnRlcmZhY2UgV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9y bVBvc3RCb2R5RXhpc3RzUHJvdG9jb2wgOiBUZXN0UHJvdG9jb2wKK0BlbmQKKworQGltcGxlbWVu dGF0aW9uIFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4aXN0c1Byb3Rv Y29sCisKKy0gKGluc3RhbmNldHlwZSlpbml0V2l0aFJlcXVlc3Q6KE5TVVJMUmVxdWVzdCAqKXJl cXVlc3QgY2FjaGVkUmVzcG9uc2U6KE5TQ2FjaGVkVVJMUmVzcG9uc2UgKiljYWNoZWRSZXNwb25z ZSBjbGllbnQ6KGlkPE5TVVJMUHJvdG9jb2xDbGllbnQ+KWNsaWVudAoreworICAgIE5TRGF0YSAq Ym9keURhdGEgPSByZXF1ZXN0LkhUVFBCb2R5OworICAgIEVYUEVDVF9OT1RfTlVMTChib2R5RGF0 YSk7CisgICAgRVhQRUNUX05VTEwocmVxdWVzdC5IVFRQQm9keVN0cmVhbSk7CisgICAgaWYgKGJv ZHlEYXRhICE9IG5pbCkgeworICAgICAgICBSZXRhaW5QdHI8TlNTdHJpbmc+IGJvZHkgPSBhZG9w dE5TKFtbTlNTdHJpbmcgYWxsb2NdIGluaXRXaXRoRGF0YTpib2R5RGF0YSBlbmNvZGluZzpOU1VU RjhTdHJpbmdFbmNvZGluZ10pOworICAgICAgICBFWFBFQ1RfRVEoU3RyaW5nKCJsb2dpbj1qb2hu IiksIFN0cmluZyhib2R5LmdldCgpKSk7CisgICAgfQorCisgICAgdGVzdEZpbmlzaGVkID0gdHJ1 ZTsKKworICAgIHJldHVybiBbc3VwZXIgaW5pdFdpdGhSZXF1ZXN0OnJlcXVlc3QgY2FjaGVkUmVz cG9uc2U6Y2FjaGVkUmVzcG9uc2UgY2xpZW50OmNsaWVudF07Cit9CisKK0BlbmQKKworCiBuYW1l c3BhY2UgVGVzdFdlYktpdEFQSSB7CiAKIFRFU1QoV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3Qs IE1haW5SZXNvdXJjZSkKIHsKKyAgICB0ZXN0RmluaXNoZWQgPSBmYWxzZTsKICAgICBbTlNVUkxQ cm90b2NvbCByZWdpc3RlckNsYXNzOltUZXN0UHJvdG9jb2wgY2xhc3NdXTsKICAgICBbV0tCcm93 c2luZ0NvbnRleHRDb250cm9sbGVyIHJlZ2lzdGVyU2NoZW1lRm9yQ3VzdG9tUHJvdG9jb2w6W1Rl c3RQcm90b2NvbCBzY2hlbWVdXTsKIApAQCAtNTQsNiArODAsMjUgQEAgVEVTVChXZWJLaXQyQ3Vz dG9tUHJvdG9jb2xzVGVzdCwgTWFpblJlc291cmNlKQogICAgIFV0aWw6OnJ1bigmdGVzdEZpbmlz aGVkKTsKIH0KIAorVEVTVChXZWJLaXQyQ3VzdG9tUHJvdG9jb2xzVGVzdCwgRm9ybVBvc3RCb2R5 RXhpc3RzKQoreworICAgIHRlc3RGaW5pc2hlZCA9IGZhbHNlOworICAgIFtOU1VSTFByb3RvY29s IHJlZ2lzdGVyQ2xhc3M6W1dlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4 aXN0c1Byb3RvY29sIGNsYXNzXV07CisgICAgW1dLQnJvd3NpbmdDb250ZXh0Q29udHJvbGxlciBy ZWdpc3RlclNjaGVtZUZvckN1c3RvbVByb3RvY29sOltUZXN0UHJvdG9jb2wgc2NoZW1lXV07CisK KyAgICBSZXRhaW5QdHI8V0tQcm9jZXNzR3JvdXA+IHByb2Nlc3NHcm91cCA9IGFkb3B0TlMoW1tX S1Byb2Nlc3NHcm91cCBhbGxvY10gaW5pdF0pOworICAgIFJldGFpblB0cjxXS0Jyb3dzaW5nQ29u dGV4dEdyb3VwPiBicm93c2luZ0NvbnRleHRHcm91cCA9IGFkb3B0TlMoW1tXS0Jyb3dzaW5nQ29u dGV4dEdyb3VwIGFsbG9jXSBpbml0V2l0aElkZW50aWZpZXI6QCJUZXN0SWRlbnRpZmllciJdKTsK KyAgICBSZXRhaW5QdHI8V0tWaWV3PiB3a1ZpZXcgPSBhZG9wdE5TKFtbV0tWaWV3IGFsbG9jXSBp bml0V2l0aEZyYW1lOk5TTWFrZVJlY3QoMCwgMCwgODAwLCA2MDApIHByb2Nlc3NHcm91cDpwcm9j ZXNzR3JvdXAuZ2V0KCkgYnJvd3NpbmdDb250ZXh0R3JvdXA6YnJvd3NpbmdDb250ZXh0R3JvdXAu Z2V0KCldKTsKKworICAgIE5TVVJMICp1cmwgPSBbTlNVUkwgVVJMV2l0aFN0cmluZzpbTlNTdHJp bmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVAOi8vRm9ybVBvc3RCb2R5RXhpc3RzIiwgW1Rlc3RQcm90 b2NvbCBzY2hlbWVdXV07CisgICAgTlNTdHJpbmcgKmh0bWwgPSBbTlNTdHJpbmcgc3RyaW5nV2l0 aEZvcm1hdDpAIjxodG1sPjxib2R5IG9ubG9hZD1cImRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdm Jykuc3VibWl0KClcIj48Zm9ybSBpZD1cImZcIiBhY3Rpb249XCIlQFwiIG1ldGhvZD1cInBvc3Rc Ij48aW5wdXQgbmFtZT1cImxvZ2luXCIgdmFsdWU9XCJqb2huXCIgLz48L2Zvcm0+PC9ib2R5Pjwv aHRtbD4iLCB1cmwuYWJzb2x1dGVTdHJpbmddOworICAgIFt3a1ZpZXcuZ2V0KCkuYnJvd3NpbmdD b250ZXh0Q29udHJvbGxlciBsb2FkSFRNTFN0cmluZzpodG1sIGJhc2VVUkw6bmlsXTsKKworICAg IFV0aWw6OnJ1bigmdGVzdEZpbmlzaGVkKTsKKyAgICBbTlNVUkxQcm90b2NvbCB1bnJlZ2lzdGVy Q2xhc3M6W1dlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4aXN0c1Byb3Rv Y29sIGNsYXNzXV07CisgICAgW1dLQnJvd3NpbmdDb250ZXh0Q29udHJvbGxlciB1bnJlZ2lzdGVy U2NoZW1lRm9yQ3VzdG9tUHJvdG9jb2w6W1Rlc3RQcm90b2NvbCBzY2hlbWVdXTsKK30KKwogfSAv LyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQogCiAjZW5kaWYgLy8gV0tfQVBJX0VOQUJMRUQK 243971 2015-01-05 03:50:16 -0800 2015-01-06 13:39:50 -0800 Patch bug-137299-20150105125204.patch text/plain 15307 danielo U3VidmVyc2lvbiBSZXZpc2lvbjogMTc3ODk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggMmE5NDcwODRiNTBhMzIx MWM4NzdmZmZhYjc1OGNlYWJhOTY2MGY5NC4uOTc3YTdiODY4ZTYwNzdhNzBlNTRhYTU5YzQ2NjIz OWM2NDFmMzMwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDE1LTAxLTA1ICBEYW5p ZWwgTGF6YXJlbmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+CisKKyAgICAgICAgUE9TVCBmb3JtIGRh dGEgaXMgbWlzc2luZyB3aXRoIGEgY3VzdG9tIE5TVVJMUHJvdG9jb2wKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzI5OQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBPU1QgcmVxdWVzdCBmb3JtIGRhdGEg d2FzIG1pc3NpbmcgaW4gVUlQcm9jZXNzCisgICAgICAgIHdoZXJlIGEgY3VzdG9tIE5TVVJMUHJv dG9jb2wgbGl2ZXMsCisgICAgICAgIGJlY2F1c2UgaXQgd2FzIG5vdCBzZXJpYWxpemVkIG92ZXIg SVBDLgorCisgICAgICAgIFRoaXMgZml4IGFsbG93cyBhbiBIVFRQIFBPU1QgYm9keSBmb3JtIGRh dGEgdG8gYmUgc2VudCBvdmVyIElQQworICAgICAgICBpbiB0aGUgQ3VzdG9tUHJvdG9jb2xNYW5h Z2VyUHJveHk6OlN0YXJ0TG9hZGluZyBtZXNzYWdlLgorICAgICAgICBJbiBvdGhlciBjYXNlcyB0 aGUgSFRUUCBib2R5IGlzIHN0cmlwcGVkIGFzIGJlZm9yZSAoZm9yIHBlcmZvcm1hbmNlIHJlYXNv bnMpLgorCisgICAgICAgIEluIG9yZGVyIHRvIHRyaWdnZXIgYSBkaWZmZXJlbnQgc2VyaWFsaXph dGlvbiBhbGdvcml0aG0gZm9yIFJlc291cmNlUmVxdWVzdAorICAgICAgICBhIHBhcmFtZXRlciBp cyBhZGRlZCB0byBSZXNvdXJjZVJlcXVlc3QgSVBDIGFyZ3VtZW50IGVuY29kZXIsCisgICAgICAg IHdoaWNoIGNvbnRyb2xzIGlmIHRoZSBOU1VSTFJlcXVlc3QuSFRUUEJvZHkgaXMgc3RyaXBwZWQu CisgICAgICAgIFdoZW4gc2VuZGluZyBhIEN1c3RvbVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFy dExvYWRpbmcgbWVzc2FnZSwKKyAgICAgICAgZW5jb2RlIG1lc3NhZ2UgcGFyYW1ldGVycyBzbyB0 aGF0IHRoZSBib2R5IGlzIG5vdCBzdHJpcHBlZC4KKworICAgICAgICBJbiBhZGRpdGlvbjoKKyAg ICAgICAgUmVmYWN0b3IgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0 Zm9ybURhdGEKKyAgICAgICAgaW4gb3JkZXIgdG8gcmVtb3ZlIGR1cGxpY2F0ZSBjb2RlLgorCisg ICAgICAgICogU2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0NvY29hL0N1c3RvbVByb3Rv Y29sTWFuYWdlckNvY29hLm1tOgorICAgICAgICAoLVtXS0N1c3RvbVByb3RvY29sIHN0YXJ0TG9h ZGluZ10pOgorICAgICAgICAqIFNoYXJlZC9XZWJDb3JlQXJndW1lbnRDb2RlcnMuY3BwOgorICAg ICAgICAoSVBDOjpFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1bWVudCk6CisgICAgICAgIChJUEM6 OkFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlKToKKyAgICAgICAgKiBTaGFy ZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmg6CisgICAgICAgICogU2hhcmVkL21hYy9XZWJDb3Jl QXJndW1lbnRDb2RlcnNNYWMubW06CisgICAgICAgIChJUEM6OkVuY29kZVJlc291cmNlUmVxdWVz dEFyZ3VtZW50UGxhdGZvcm1EYXRhKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxSZXNv dXJjZVJlcXVlc3Q+OjplbmNvZGVQbGF0Zm9ybURhdGEpOgorCiAyMDE1LTAxLTA0ICBBbmRlcnMg Q2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgQ2xlYW4gdXAgc29tZSBv ZiB0aGUgSVBDIGNvZGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9OZXR3b3Jr L0N1c3RvbVByb3RvY29scy9Db2NvYS9DdXN0b21Qcm90b2NvbE1hbmFnZXJDb2NvYS5tbSBiL1Nv dXJjZS9XZWJLaXQyL1NoYXJlZC9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9Db2NvYS9DdXN0b21Q cm90b2NvbE1hbmFnZXJDb2NvYS5tbQppbmRleCAzZTQzZTJiYWU3NGVhNzE5YzM2MzVmNTliZTcw MjY1NDYzYTkzOTA5Li5lOGIwYzkwMmUxZTAzZGYxNmVmMTUwY2Q5MDM2YTViNDdmYmI1OTcxIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmV0d29yay9DdXN0b21Qcm90b2NvbHMv Q29jb2EvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyQ29jb2EubW0KKysrIGIvU291cmNlL1dlYktpdDIv U2hhcmVkL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL0NvY29hL0N1c3RvbVByb3RvY29sTWFuYWdl ckNvY29hLm1tCkBAIC0xMDQsNyArMTA0LDE5IEBAIHN0YXRpYyB1aW50NjRfdCBnZW5lcmF0ZUN1 c3RvbVByb3RvY29sSUQoKQogCiAtICh2b2lkKXN0YXJ0TG9hZGluZwogewotICAgIHNoYXJlZEN1 c3RvbVByb3RvY29sTWFuYWdlci0+Y2hpbGRQcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6OkN1c3Rv bVByb3RvY29sTWFuYWdlclByb3h5OjpTdGFydExvYWRpbmcoc2VsZi5jdXN0b21Qcm90b2NvbElE LCBbc2VsZiByZXF1ZXN0XSksIDApOworICAgIC8vIENyZWF0ZSBhIFN0YXJ0TG9hZGluZyBtZXNz YWdlLgorICAgIHVzaW5nIE1lc3NhZ2VzOjpDdXN0b21Qcm90b2NvbE1hbmFnZXJQcm94eTo6U3Rh cnRMb2FkaW5nOworICAgIGF1dG8gbWVzc2FnZSA9IFN0YXJ0TG9hZGluZyhzZWxmLmN1c3RvbVBy b3RvY29sSUQsIFtzZWxmIHJlcXVlc3RdKTsKKworICAgIC8vIEVuY29kZSB0aGUgbWVzc2FnZSBh cmd1bWVudHMgbWFudWFsbHkgdG8gcHJlc2VydmUgdGhlIHJlcXVlc3QgSFRUUCBib2R5LgorICAg IGF1dG8gZW5jb2RlciA9IHN0ZDo6bWFrZV91bmlxdWU8SVBDOjpNZXNzYWdlRW5jb2Rlcj4oU3Rh cnRMb2FkaW5nOjpyZWNlaXZlck5hbWUoKSwgU3RhcnRMb2FkaW5nOjpuYW1lKCksIDApOworICAg IGF1dG8gYXJndW1lbnRzID0gbWVzc2FnZS5hcmd1bWVudHMoKTsKKyAgICAqZW5jb2RlciA8PCBz dGQ6OmdldDwwPihhcmd1bWVudHMpOworICAgIElQQzo6RW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJn dW1lbnQoKmVuY29kZXIsIHN0ZDo6Z2V0PDE+KGFyZ3VtZW50cyksIGZhbHNlKTsKKworICAgIC8v IFNlbmQgdGhlIG1lc3NhZ2UuCisgICAgYXV0byBjaGlsZFByb2Nlc3MgPSBzaGFyZWRDdXN0b21Q cm90b2NvbE1hbmFnZXItPmNoaWxkUHJvY2VzcygpOworICAgIGNoaWxkUHJvY2Vzcy0+c2VuZE1l c3NhZ2UoV1RGOjptb3ZlKGVuY29kZXIpLCAwKTsKIH0KIAogLSAodm9pZClzdG9wTG9hZGluZwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1bWVudENvZGVycy5j cHAgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmNwcAppbmRl eCAyYjNmYjU2MzkwM2VhZDc1MGZhZTgxMGQ5ODUyMzAwMzk2MDQzY2U1Li4xN2MxZjM0YjVjMDNm MWE2ZDM4OGM2MzY1NmM3YWYzNjg2ZDQ1OTYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFy ZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmNwcApAQCAtNjgwLDcgKzY4MCw3IEBAIGJvb2wgQXJn dW1lbnRDb2RlcjxDdXJzb3I+OjpkZWNvZGUoQXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBDdXJz b3ImIGN1cnNvcikKIH0KICNlbmRpZgogCi12b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1 ZXN0Pjo6ZW5jb2RlKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1 ZXN0JiByZXNvdXJjZVJlcXVlc3QpCit2b2lkIEVuY29kZVJlc291cmNlUmVxdWVzdEFyZ3VtZW50 KEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJj ZVJlcXVlc3QsIGJvb2wgc2hvdWxkU3RyaXBIVFRQQm9keSkKIHsKICNpZiBFTkFCTEUoQ0FDSEVf UEFSVElUSU9OSU5HKQogICAgIGVuY29kZXIgPDwgcmVzb3VyY2VSZXF1ZXN0LmNhY2hlUGFydGl0 aW9uKCk7CkBAIC02OTIsMTMgKzY5MiwyNiBAQCB2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VS ZXF1ZXN0Pjo6ZW5jb2RlKEFyZ3VtZW50RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzbwogCiAg ICAgaWYgKHJlc291cmNlUmVxdWVzdC5lbmNvZGluZ1JlcXVpcmVzUGxhdGZvcm1EYXRhKCkpIHsK ICAgICAgICAgZW5jb2RlciA8PCB0cnVlOwotICAgICAgICBlbmNvZGVQbGF0Zm9ybURhdGEoZW5j b2RlciwgcmVzb3VyY2VSZXF1ZXN0KTsKKyAgICAgICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJn dW1lbnRQbGF0Zm9ybURhdGEoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0LCBzaG91bGRTdHJpcEhU VFBCb2R5KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICBlbmNvZGVyIDw8IGZhbHNlOwog ICAgIHJlc291cmNlUmVxdWVzdC5lbmNvZGVXaXRob3V0UGxhdGZvcm1EYXRhKGVuY29kZXIpOwog fQogCit2b2lkIEFyZ3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlKEFyZ3VtZW50 RW5jb2RlciYgZW5jb2RlciwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3Qp Cit7CisgICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnQoZW5jb2RlciwgcmVzb3VyY2VS ZXF1ZXN0LCB0cnVlKTsKK30KKworLy8gUGxhdGZvcm1zIHdoaWNoIGRvbid0IGltcGxlbWVudCAi c2hvdWxkU3RyaXBIVFRQQm9keSIgb3B0aW9uIGp1c3QgY2FsbCBBcmd1bWVudENvZGVyOjplbmNv ZGVQbGF0Zm9ybURhdGEuCisjaWYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKElPUykKK3Zv aWQgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnRQbGF0Zm9ybURhdGEoQXJndW1lbnRFbmNv ZGVyJiBlbmNvZGVyLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVx dWVzdCwgYm9vbCBzaG91bGRTdHJpcEhUVFBCb2R5KQoreworICAgIEFyZ3VtZW50Q29kZXI8UmVz b3VyY2VSZXF1ZXN0Pjo6ZW5jb2RlUGxhdGZvcm1EYXRhKGVuY29kZXIsIHJlc291cmNlUmVxdWVz dCk7Cit9CisjZW5kaWYKKwogYm9vbCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmRl Y29kZShBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VS ZXF1ZXN0KQogewogI2lmIEVOQUJMRShDQUNIRV9QQVJUSVRJT05JTkcpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmggYi9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvV2ViQ29yZUFyZ3VtZW50Q29kZXJzLmgKaW5kZXggMWNkZGI4OTM2NzhiYmMx ZTU4MmE3ZGQyZTYxMWE2MGRmNjQ3NGE3YS4uZmMyYzkxODE0ZGQyYjMzOTY3NjQ3YWJlYzAxODZj OWQ5OWM5MmQzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYkNvcmVBcmd1 bWVudENvZGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJDb3JlQXJndW1lbnRD b2RlcnMuaApAQCAtMjU0LDYgKzI1NCw5IEBAIHRlbXBsYXRlPD4gc3RydWN0IEFyZ3VtZW50Q29k ZXI8V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0PiB7CiAgICAgc3RhdGljIGJvb2wgZGVjb2RlUGxh dGZvcm1EYXRhKEFyZ3VtZW50RGVjb2RlciYsIFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOwog fTsKIAordm9pZCBFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1bWVudChBcmd1bWVudEVuY29kZXIm LCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBib29sIHNob3VsZFN0cmlwSFRUUEJv ZHkpOwordm9pZCBFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1bWVudFBsYXRmb3JtRGF0YShBcmd1 bWVudEVuY29kZXImLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBib29sIHNob3Vs ZFN0cmlwSFRUUEJvZHkpOworCiB0ZW1wbGF0ZTw+IHN0cnVjdCBBcmd1bWVudENvZGVyPFdlYkNv cmU6OlJlc291cmNlRXJyb3I+IHsKICAgICBzdGF0aWMgdm9pZCBlbmNvZGUoQXJndW1lbnRFbmNv ZGVyJiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwogICAgIHN0YXRpYyBib29sIGRl Y29kZShBcmd1bWVudERlY29kZXImLCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvbWFjL1dlYkNvcmVBcmd1bWVudENvZGVyc01hYy5t bSBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29kZXJzTWFjLm1t CmluZGV4IDNlYmE5MzY4ZTBlZmY5NjA0MWVjMmM3ZmZlOGNiODU3Njk5Mzc4YmUuLmNlOTkzMmU0 YTY3M2YxNTk0OWY5YmQ0YjEyNGYwMDljZWU4YjhlMWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29kZXJzTWFjLm1tCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1NoYXJlZC9tYWMvV2ViQ29yZUFyZ3VtZW50Q29kZXJzTWFjLm1tCkBAIC00OCw5ICs0 OCwxOCBAQCB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIG5hbWVzcGFjZSBJUEMgewogCiAjaWYg VVNFKENGTkVUV09SSykKLXZvaWQgQXJndW1lbnRDb2RlcjxSZXNvdXJjZVJlcXVlc3Q+OjplbmNv ZGVQbGF0Zm9ybURhdGEoQXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlc291cmNlUmVxdWVzdCkKKyNkZWZpbmUgWFVSTFJlcXVlc3QgQ0ZVUkxSZXF1ZXN0 UmVmCisjZGVmaW5lIHhVUkxSZXF1ZXN0IGNmVVJMUmVxdWVzdAorI2RlZmluZSBYVVJMUmVxdWVz dENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uIFdLQ0ZVUkxSZXF1ZXN0Q3JlYXRlU2Vy aWFsaXphYmxlUmVwcmVzZW50YXRpb24KKyNlbHNlCisjZGVmaW5lIFhVUkxSZXF1ZXN0IE5TVVJM UmVxdWVzdAorI2RlZmluZSB4VVJMUmVxdWVzdCBuc1VSTFJlcXVlc3QKKyNkZWZpbmUgWFVSTFJl cXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbiBXS05TVVJMUmVxdWVzdENyZWF0 ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uCisjZW5kaWYgLy8gVVNFKENGTkVUV09SSykKKwor dm9pZCBFbmNvZGVSZXNvdXJjZVJlcXVlc3RBcmd1bWVudFBsYXRmb3JtRGF0YShBcmd1bWVudEVu Y29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVzb3VyY2VSZXF1ZXN0LCBi b29sIHNob3VsZFN0cmlwSFRUUEJvZHkpCiB7Ci0gICAgUmV0YWluUHRyPENGVVJMUmVxdWVzdFJl Zj4gcmVxdWVzdFRvU2VyaWFsaXplID0gcmVzb3VyY2VSZXF1ZXN0LmNmVVJMUmVxdWVzdChEb05v dFVwZGF0ZUhUVFBCb2R5KTsKKyAgICBSZXRhaW5QdHI8WFVSTFJlcXVlc3Q+IHJlcXVlc3RUb1Nl cmlhbGl6ZSA9IHJlc291cmNlUmVxdWVzdC54VVJMUmVxdWVzdChEb05vdFVwZGF0ZUhUVFBCb2R5 KTsKIAogICAgIGJvb2wgcmVxdWVzdElzUHJlc2VudCA9IHJlcXVlc3RUb1NlcmlhbGl6ZTsKICAg ICBlbmNvZGVyIDw8IHJlcXVlc3RJc1ByZXNlbnQ7CkBAIC02MCw0NyArNjksNDMgQEAgdm9pZCBB cmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29kZVBsYXRmb3JtRGF0YShBcmd1bWVu dEVuY29kZXImIGVuY29kZXIKIAogICAgIC8vIFdlIGRvbid0IHNlbmQgSFRUUCBib2R5IG92ZXIg SVBDIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCiAgICAgLy8gQWxzbywgaXQncyBub3QgYWx3YXlz IHBvc3NpYmxlIHRvIGRvLCBhcyBzdHJlYW1zIGNhbiBvbmx5IGJlIGNyZWF0ZWQgaW4gcHJvY2Vz cyB0aGF0IGRvZXMgbmV0d29ya2luZy4KKyNpZiBVU0UoQ0ZORVRXT1JLKQogICAgIFJldGFpblB0 cjxDRkRhdGFSZWY+IHJlcXVlc3RIVFRQQm9keSA9IGFkb3B0Q0YoQ0ZVUkxSZXF1ZXN0Q29weUhU VFBSZXF1ZXN0Qm9keShyZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCkpKTsKICAgICBSZXRhaW5QdHI8 Q0ZSZWFkU3RyZWFtUmVmPiByZXF1ZXN0SFRUUEJvZHlTdHJlYW0gPSBhZG9wdENGKENGVVJMUmVx dWVzdENvcHlIVFRQUmVxdWVzdEJvZHlTdHJlYW0ocmVxdWVzdFRvU2VyaWFsaXplLmdldCgpKSk7 CisgICAgQ0ZNdXRhYmxlVVJMUmVxdWVzdFJlZiBtdXRhYmxlUmVxdWVzdCA9IE5VTEw7CiAgICAg aWYgKHJlcXVlc3RIVFRQQm9keSB8fCByZXF1ZXN0SFRUUEJvZHlTdHJlYW0pIHsKLSAgICAgICAg Q0ZNdXRhYmxlVVJMUmVxdWVzdFJlZiBtdXRhYmxlUmVxdWVzdCA9IENGVVJMUmVxdWVzdENyZWF0 ZU11dGFibGVDb3B5KDAsIHJlcXVlc3RUb1NlcmlhbGl6ZS5nZXQoKSk7CisgICAgICAgIG11dGFi bGVSZXF1ZXN0ID0gQ0ZVUkxSZXF1ZXN0Q3JlYXRlTXV0YWJsZUNvcHkoMCwgcmVxdWVzdFRvU2Vy aWFsaXplLmdldCgpKTsKICAgICAgICAgcmVxdWVzdFRvU2VyaWFsaXplID0gYWRvcHRDRihtdXRh YmxlUmVxdWVzdCk7CisgICAgfQorICAgIGlmIChyZXF1ZXN0SFRUUEJvZHkgJiYgc2hvdWxkU3Ry aXBIVFRQQm9keSkKICAgICAgICAgQ0ZVUkxSZXF1ZXN0U2V0SFRUUFJlcXVlc3RCb2R5KG11dGFi bGVSZXF1ZXN0LCBuaWwpOworICAgIGlmIChyZXF1ZXN0SFRUUEJvZHlTdHJlYW0pCiAgICAgICAg IENGVVJMUmVxdWVzdFNldEhUVFBSZXF1ZXN0Qm9keVN0cmVhbShtdXRhYmxlUmVxdWVzdCwgbmls KTsKKyNlbHNlCisgICAgTlNEYXRhICpyZXF1ZXN0SFRUUEJvZHkgPSBbcmVxdWVzdFRvU2VyaWFs aXplIEhUVFBCb2R5XTsKKyAgICBOU0lucHV0U3RyZWFtICpyZXF1ZXN0SFRUUEJvZHlTdHJlYW0g PSBbcmVxdWVzdFRvU2VyaWFsaXplIEhUVFBCb2R5U3RyZWFtXTsKKyAgICBOU011dGFibGVVUkxS ZXF1ZXN0ICptdXRhYmxlUmVxdWVzdCA9IG5pbDsKKyAgICBpZiAocmVxdWVzdEhUVFBCb2R5IHx8 IHJlcXVlc3RIVFRQQm9keVN0cmVhbSkgeworICAgICAgICBtdXRhYmxlUmVxdWVzdCA9IFtyZXF1 ZXN0VG9TZXJpYWxpemUgbXV0YWJsZUNvcHldOworICAgICAgICByZXF1ZXN0VG9TZXJpYWxpemUg PSBhZG9wdE5TKG11dGFibGVSZXF1ZXN0KTsKICAgICB9CisgICAgaWYgKHJlcXVlc3RIVFRQQm9k eSAmJiBzaG91bGRTdHJpcEhUVFBCb2R5KQorICAgICAgICBbbXV0YWJsZVJlcXVlc3Qgc2V0SFRU UEJvZHk6bmlsXTsKKyAgICBpZiAocmVxdWVzdEhUVFBCb2R5U3RyZWFtKQorICAgICAgICBbbXV0 YWJsZVJlcXVlc3Qgc2V0SFRUUEJvZHlTdHJlYW06bmlsXTsKKyNlbmRpZiAvLyBVU0UoQ0ZORVRX T1JLKQogCi0gICAgUmV0YWluUHRyPENGRGljdGlvbmFyeVJlZj4gZGljdGlvbmFyeSA9IGFkb3B0 Q0YoV0tDRlVSTFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbihyZXF1ZXN0 VG9TZXJpYWxpemUuZ2V0KCksIElQQzo6dG9rZW5OdWxsVHlwZVJlZigpKSk7CisgICAgUmV0YWlu UHRyPENGRGljdGlvbmFyeVJlZj4gZGljdGlvbmFyeSA9IGFkb3B0Q0YoWFVSTFJlcXVlc3RDcmVh dGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbihyZXF1ZXN0VG9TZXJpYWxpemUuZ2V0KCksIElQ Qzo6dG9rZW5OdWxsVHlwZVJlZigpKSk7CiAgICAgSVBDOjplbmNvZGUoZW5jb2RlciwgZGljdGlv bmFyeS5nZXQoKSk7CiAKLSAgICAvLyBUaGUgZmFsbGJhY2sgYXJyYXkgaXMgcGFydCBvZiBDRlVS TFJlcXVlc3QsIGJ1dCBpdCBpcyBub3QgZW5jb2RlZCBieSBXS0NGVVJMUmVxdWVzdENyZWF0ZVNl cmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uLgorICAgIC8vIFRoZSBmYWxsYmFjayBhcnJheSBpcyBw YXJ0IG9mIFhVUkxSZXF1ZXN0LCBidXQgaXQgaXMgbm90IGVuY29kZWQgYnkgWFVSTFJlcXVlc3RD cmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbi4KICAgICBlbmNvZGVyIDw8IHJlc291cmNl UmVxdWVzdC5yZXNwb25zZUNvbnRlbnREaXNwb3NpdGlvbkVuY29kaW5nRmFsbGJhY2tBcnJheSgp OwogfQotI2Vsc2UKKwogdm9pZCBBcmd1bWVudENvZGVyPFJlc291cmNlUmVxdWVzdD46OmVuY29k ZVBsYXRmb3JtRGF0YShBcmd1bWVudEVuY29kZXImIGVuY29kZXIsIGNvbnN0IFJlc291cmNlUmVx dWVzdCYgcmVzb3VyY2VSZXF1ZXN0KQogewotICAgIFJldGFpblB0cjxOU1VSTFJlcXVlc3Q+IHJl cXVlc3RUb1NlcmlhbGl6ZSA9IHJlc291cmNlUmVxdWVzdC5uc1VSTFJlcXVlc3QoRG9Ob3RVcGRh dGVIVFRQQm9keSk7Ci0KLSAgICBib29sIHJlcXVlc3RJc1ByZXNlbnQgPSByZXF1ZXN0VG9TZXJp YWxpemU7Ci0gICAgZW5jb2RlciA8PCByZXF1ZXN0SXNQcmVzZW50OwotCi0gICAgaWYgKCFyZXF1 ZXN0SXNQcmVzZW50KQotICAgICAgICByZXR1cm47Ci0KLSAgICAvLyBXZSBkb24ndCBzZW5kIEhU VFAgYm9keSBvdmVyIElQQyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgotICAgIC8vIEFsc28sIGl0 J3Mgbm90IGFsd2F5cyBwb3NzaWJsZSB0byBkbywgYXMgc3RyZWFtcyBjYW4gb25seSBiZSBjcmVh dGVkIGluIHByb2Nlc3MgdGhhdCBkb2VzIG5ldHdvcmtpbmcuCi0gICAgaWYgKFtyZXF1ZXN0VG9T ZXJpYWxpemUgSFRUUEJvZHldIHx8IFtyZXF1ZXN0VG9TZXJpYWxpemUgSFRUUEJvZHlTdHJlYW1d KSB7Ci0gICAgICAgIHJlcXVlc3RUb1NlcmlhbGl6ZSA9IGFkb3B0TlMoW3JlcXVlc3RUb1Nlcmlh bGl6ZSBtdXRhYmxlQ29weV0pOwotICAgICAgICBbKE5TTXV0YWJsZVVSTFJlcXVlc3QgKilyZXF1 ZXN0VG9TZXJpYWxpemUgc2V0SFRUUEJvZHk6bmlsXTsKLSAgICAgICAgWyhOU011dGFibGVVUkxS ZXF1ZXN0ICopcmVxdWVzdFRvU2VyaWFsaXplIHNldEhUVFBCb2R5U3RyZWFtOm5pbF07Ci0gICAg fQotCi0gICAgUmV0YWluUHRyPENGRGljdGlvbmFyeVJlZj4gZGljdGlvbmFyeSA9IGFkb3B0Q0Yo V0tOU1VSTFJlcXVlc3RDcmVhdGVTZXJpYWxpemFibGVSZXByZXNlbnRhdGlvbihyZXF1ZXN0VG9T ZXJpYWxpemUuZ2V0KCksIElQQzo6dG9rZW5OdWxsVHlwZVJlZigpKSk7Ci0gICAgSVBDOjplbmNv ZGUoZW5jb2RlciwgZGljdGlvbmFyeS5nZXQoKSk7Ci0KLSAgICAvLyBUaGUgZmFsbGJhY2sgYXJy YXkgaXMgcGFydCBvZiBOU1VSTFJlcXVlc3QsIGJ1dCBpdCBpcyBub3QgZW5jb2RlZCBieSBXS05T VVJMUmVxdWVzdENyZWF0ZVNlcmlhbGl6YWJsZVJlcHJlc2VudGF0aW9uLgotICAgIGVuY29kZXIg PDwgcmVzb3VyY2VSZXF1ZXN0LnJlc3BvbnNlQ29udGVudERpc3Bvc2l0aW9uRW5jb2RpbmdGYWxs YmFja0FycmF5KCk7CisgICAgRW5jb2RlUmVzb3VyY2VSZXF1ZXN0QXJndW1lbnRQbGF0Zm9ybURh dGEoZW5jb2RlciwgcmVzb3VyY2VSZXF1ZXN0LCB0cnVlKTsKIH0KLSNlbmRpZgogCiBib29sIEFy Z3VtZW50Q29kZXI8UmVzb3VyY2VSZXF1ZXN0Pjo6ZGVjb2RlUGxhdGZvcm1EYXRhKEFyZ3VtZW50 RGVjb2RlciYgZGVjb2RlciwgUmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpCiB7CmRp ZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNzY2MmNh NzhjZDlhYjkzYTFkNzE2MzZmYjhiNzAxNzYwYWQ4MDFjMS4uOWIwMGUwZGVjNTVlNTY1MTJjZDhl NWI2NjJiNjNlNDU5MzY2NmViMSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rv b2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDE1LTAxLTA1ICBEYW5pZWwgTGF6YXJl bmtvICA8ZGFuaWVsb0BvcGVyYS5jb20+CisKKyAgICAgICAgUE9TVCBmb3JtIGRhdGEgaXMgbWlz c2luZyB3aXRoIGEgY3VzdG9tIE5TVVJMUHJvdG9jb2wKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzI5OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3QgY2FzZSBmb3IgdXNpbmcgSFRUUCBQT1NUIHdp dGggYSBjdXN0b20gTlNVUkxQcm90b2NvbC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJvdG9jb2xzVGVzdC5tbToKKyAgICAgICAgKC1bV2ViS2l0 MkN1c3RvbVByb3RvY29sc1Rlc3RfRm9ybVBvc3RCb2R5RXhpc3RzUHJvdG9jb2wgaW5pdFdpdGhS ZXF1ZXN0OmNhY2hlZFJlc3BvbnNlOmNsaWVudDpdKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OlRFU1QpOgorCiAyMDE1LTAxLTAxICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBAYXBwbGUuY29t PgogCiAgICAgICAgIFNpbXBsaWZ5IFdlYktpdFRlc3RSdW5uZXIgdGltZW91dCB0cmFja2luZwpk aWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyT2JqQy9DdXN0b21Q cm90b2NvbHNUZXN0Lm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyT2JqQy9D dXN0b21Qcm90b2NvbHNUZXN0Lm1tCmluZGV4IDBhNjI5YzBhZTQ2Y2YxMmYwYjM0YjkyYWNmNWZi NTAzNzVjZjVkOTMuLjdlM2ZlYzVjMmFkNDdkMGUxYTI5NmNjZTgxMTc5YWVmZWZlMDlmMzkgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mk9iakMvQ3VzdG9tUHJv dG9jb2xzVGVzdC5tbQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDJPYmpD L0N1c3RvbVByb3RvY29sc1Rlc3QubW0KQEAgLTM0LDE1ICszNCw0MSBAQAogI2ltcG9ydCAiVGVz dFByb3RvY29sLmgiCiAjaW1wb3J0IDxXZWJLaXQvV2ViS2l0Mi5oPgogI2ltcG9ydCA8d3RmL1Jl dGFpblB0ci5oPgorI2ltcG9ydCAiV1RGU3RyaW5nVXRpbGl0aWVzLmgiCiAKICNpZiBXS19BUElf RU5BQkxFRAogCiBzdGF0aWMgYm9vbCB0ZXN0RmluaXNoZWQgPSBmYWxzZTsKIAorCitAaW50ZXJm YWNlIFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0X0Zvcm1Qb3N0Qm9keUV4aXN0c1Byb3RvY29s IDogVGVzdFByb3RvY29sCitAZW5kCisKK0BpbXBsZW1lbnRhdGlvbiBXZWJLaXQyQ3VzdG9tUHJv dG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbAorCistIChpbnN0YW5jZXR5cGUp aW5pdFdpdGhSZXF1ZXN0OihOU1VSTFJlcXVlc3QgKilyZXF1ZXN0IGNhY2hlZFJlc3BvbnNlOihO U0NhY2hlZFVSTFJlc3BvbnNlICopY2FjaGVkUmVzcG9uc2UgY2xpZW50OihpZDxOU1VSTFByb3Rv Y29sQ2xpZW50PiljbGllbnQKK3sKKyAgICBOU0RhdGEgKmJvZHlEYXRhID0gcmVxdWVzdC5IVFRQ Qm9keTsKKyAgICBFWFBFQ1RfTk9UX05VTEwoYm9keURhdGEpOworICAgIEVYUEVDVF9OVUxMKHJl cXVlc3QuSFRUUEJvZHlTdHJlYW0pOworICAgIGlmIChib2R5RGF0YSAhPSBuaWwpIHsKKyAgICAg ICAgUmV0YWluUHRyPE5TU3RyaW5nPiBib2R5ID0gYWRvcHROUyhbW05TU3RyaW5nIGFsbG9jXSBp bml0V2l0aERhdGE6Ym9keURhdGEgZW5jb2Rpbmc6TlNVVEY4U3RyaW5nRW5jb2RpbmddKTsKKyAg ICAgICAgRVhQRUNUX0VRKFN0cmluZygibG9naW49am9obiIpLCBTdHJpbmcoYm9keS5nZXQoKSkp OworICAgIH0KKworICAgIHRlc3RGaW5pc2hlZCA9IHRydWU7CisKKyAgICByZXR1cm4gW3N1cGVy IGluaXRXaXRoUmVxdWVzdDpyZXF1ZXN0IGNhY2hlZFJlc3BvbnNlOmNhY2hlZFJlc3BvbnNlIGNs aWVudDpjbGllbnRdOworfQorCitAZW5kCisKKwogbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgewog CiBURVNUKFdlYktpdDJDdXN0b21Qcm90b2NvbHNUZXN0LCBNYWluUmVzb3VyY2UpCiB7CisgICAg dGVzdEZpbmlzaGVkID0gZmFsc2U7CiAgICAgW05TVVJMUHJvdG9jb2wgcmVnaXN0ZXJDbGFzczpb VGVzdFByb3RvY29sIGNsYXNzXV07CiAgICAgW1dLQnJvd3NpbmdDb250ZXh0Q29udHJvbGxlciBy ZWdpc3RlclNjaGVtZUZvckN1c3RvbVByb3RvY29sOltUZXN0UHJvdG9jb2wgc2NoZW1lXV07CiAK QEAgLTU3LDYgKzgzLDI1IEBAIFRFU1QoV2ViS2l0MkN1c3RvbVByb3RvY29sc1Rlc3QsIE1haW5S ZXNvdXJjZSkKICAgICBVdGlsOjpydW4oJnRlc3RGaW5pc2hlZCk7CiB9CiAKK1RFU1QoV2ViS2l0 MkN1c3RvbVByb3RvY29sc1Rlc3QsIEZvcm1Qb3N0Qm9keUV4aXN0cykKK3sKKyAgICB0ZXN0Rmlu aXNoZWQgPSBmYWxzZTsKKyAgICBbTlNVUkxQcm90b2NvbCByZWdpc3RlckNsYXNzOltXZWJLaXQy Q3VzdG9tUHJvdG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCBjbGFzc11dOwor ICAgIFtXS0Jyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgcmVnaXN0ZXJTY2hlbWVGb3JDdXN0b21Q cm90b2NvbDpbVGVzdFByb3RvY29sIHNjaGVtZV1dOworCisgICAgUmV0YWluUHRyPFdLUHJvY2Vz c0dyb3VwPiBwcm9jZXNzR3JvdXAgPSBhZG9wdE5TKFtbV0tQcm9jZXNzR3JvdXAgYWxsb2NdIGlu aXRdKTsKKyAgICBSZXRhaW5QdHI8V0tCcm93c2luZ0NvbnRleHRHcm91cD4gYnJvd3NpbmdDb250 ZXh0R3JvdXAgPSBhZG9wdE5TKFtbV0tCcm93c2luZ0NvbnRleHRHcm91cCBhbGxvY10gaW5pdFdp dGhJZGVudGlmaWVyOkAiVGVzdElkZW50aWZpZXIiXSk7CisgICAgUmV0YWluUHRyPFdLVmlldz4g d2tWaWV3ID0gYWRvcHROUyhbW1dLVmlldyBhbGxvY10gaW5pdFdpdGhGcmFtZTpOU01ha2VSZWN0 KDAsIDAsIDgwMCwgNjAwKSBwcm9jZXNzR3JvdXA6cHJvY2Vzc0dyb3VwLmdldCgpIGJyb3dzaW5n Q29udGV4dEdyb3VwOmJyb3dzaW5nQ29udGV4dEdyb3VwLmdldCgpXSk7CisKKyAgICBOU1VSTCAq dXJsID0gW05TVVJMIFVSTFdpdGhTdHJpbmc6W05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIl QDovL0Zvcm1Qb3N0Qm9keUV4aXN0cyIsIFtUZXN0UHJvdG9jb2wgc2NoZW1lXV1dOworICAgIE5T U3RyaW5nICpodG1sID0gW05TU3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCI8aHRtbD48Ym9keSBv bmxvYWQ9XCJkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZicpLnN1Ym1pdCgpXCI+PGZvcm0gaWQ9 XCJmXCIgYWN0aW9uPVwiJUBcIiBtZXRob2Q9XCJwb3N0XCI+PGlucHV0IG5hbWU9XCJsb2dpblwi IHZhbHVlPVwiam9oblwiIC8+PC9mb3JtPjwvYm9keT48L2h0bWw+IiwgdXJsLmFic29sdXRlU3Ry aW5nXTsKKyAgICBbd2tWaWV3LmdldCgpLmJyb3dzaW5nQ29udGV4dENvbnRyb2xsZXIgbG9hZEhU TUxTdHJpbmc6aHRtbCBiYXNlVVJMOm5pbF07CisKKyAgICBVdGlsOjpydW4oJnRlc3RGaW5pc2hl ZCk7CisgICAgW05TVVJMUHJvdG9jb2wgdW5yZWdpc3RlckNsYXNzOltXZWJLaXQyQ3VzdG9tUHJv dG9jb2xzVGVzdF9Gb3JtUG9zdEJvZHlFeGlzdHNQcm90b2NvbCBjbGFzc11dOworICAgIFtXS0Jy b3dzaW5nQ29udGV4dENvbnRyb2xsZXIgdW5yZWdpc3RlclNjaGVtZUZvckN1c3RvbVByb3RvY29s OltUZXN0UHJvdG9jb2wgc2NoZW1lXV07Cit9CisKIH0gLy8gbmFtZXNwYWNlIFRlc3RXZWJLaXRB UEkKIAogI2VuZGlmIC8vIFdLX0FQSV9FTkFCTEVECg==