64580 2011-07-14 18:39:10 -0700 Add support for download='filename' in anchors 2012-11-21 03:13:03 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 0 sadrul abarth abarth ap bugmail darin fishd ian kennyluck rbyers webkit.review.bot oldest_to_newest 437458 0 sadrul 2011-07-14 18:39:10 -0700 This is a first cut at adding support for <a download=filename ...>. This is a very barebone patch, as in I haven't updated ChangeLog, and haven't actually made the change to send the filename to chromium. But I wanted to put it up for review, and if this approach looks acceptable, I will fill in the missing pieces. 437460 1 100911 sadrul 2011-07-14 18:39:49 -0700 Created attachment 100911 first cut for review 437464 2 webkit.review.bot 2011-07-14 18:43:05 -0700 Attachment 100911 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/html/HTMLAnchorElement.cpp'..." exit_code: 1 Source/WebCore/html/HTMLAnchorElement.h:118: The parameter name "event" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/loader/FrameLoader.h:111: Use 0 instead of NULL. [readability/null] [5] Source/WebCore/loader/FrameLoader.h:348: The parameter name "sourceRequest" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/loader/FrameLoader.h:348: Use 0 instead of NULL. [readability/null] [5] Source/WebCore/loader/FrameLoader.cpp:268: This { should be at the end of the previous line [whitespace/braces] [4] Total errors found: 5 in 6 files If any of these errors are false positives, please file a bug against check-webkit-style. 437468 3 100911 abarth 2011-07-14 18:49:12 -0700 Comment on attachment 100911 first cut for review View in context: https://bugs.webkit.org/attachment.cgi?id=100911&action=review Some notes below. You'll also need to add this to HTMLAnchorElement.idl so that it can be feature-detected. > Source/WebCore/html/HTMLAnchorElement.cpp:500 > + String url = stripLeadingAndTrailingHTMLSpaces(getAttribute(hrefAttr)); getAttribute -> fastGetAttibute, I believe. > Source/WebCore/html/HTMLAnchorElement.cpp:503 > + bool download = hasAttribute("download"); "download" should be added to the appropriate HTMLNames.in file, alongside the other attributes. > Source/WebCore/html/HTMLAnchorElement.cpp:504 > + String name = download ? getAttribute("download") : ""; We're using "" as distinct from String() here? Also probably should be fastGetAttribute. > Source/WebCore/loader/FrameLoader.cpp:264 > +void FrameLoader::urlSelected(const KURL& url, const String& passedTarget, PassRefPtr<Event> triggeringEvent, bool lockHistory, bool lockBackForwardList, ReferrerPolicy referrerPolicy, bool shouldDownload, const String* downloadName) const String& rather than const String* > Source/WebCore/platform/network/ResourceRequestBase.h:159 > + bool shouldDownload() const { return m_shouldDownload; } > + void setShouldDownload(bool should) { m_shouldDownload = should; } > + > + String downloadName() const { return m_downloadName; } > + void setDownloadName(String name) { m_downloadName = name; } You can't add things to ResourceRequestBase that don't round-trip through NSURLRequest (or whatever that type is called). 437491 4 100918 sadrul 2011-07-14 19:48:24 -0700 Created attachment 100918 updated Addressed the comments. Regarding ResourceRequestBase: are there additional places I need to change to make this acceptable, or is this not the right place to make the change at all? In the latter case, perhaps this could go in FrameLoadRequest instead? 437492 5 webkit.review.bot 2011-07-14 19:50:19 -0700 Attachment 100918 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/html/HTMLAnchorElement.cpp'..." exit_code: 1 Source/WebCore/html/HTMLAnchorElement.h:118: The parameter name "event" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/loader/FrameLoader.h:348: The parameter name "sourceRequest" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/loader/FrameLoader.h:348: Use 0 instead of NULL. [readability/null] [5] Source/WebCore/loader/FrameLoader.cpp:268: This { should be at the end of the previous line [whitespace/braces] [4] Total errors found: 4 in 8 files If any of these errors are false positives, please file a bug against check-webkit-style. 437498 6 darin 2011-07-14 20:11:54 -0700 (In reply to comment #4) > is this not the right place to make the change at all? I think it's not. > In the latter case, perhaps this could go in FrameLoadRequest instead? I think that would be better. Not sure. 437510 7 sadrul 2011-07-14 20:35:31 -0700 (In reply to comment #6) > (In reply to comment #4) > > is this not the right place to make the change at all? > > I think it's not. > > > In the latter case, perhaps this could go in FrameLoadRequest instead? > > I think that would be better. Not sure. Just to clarify: does the restriction on ResourceRequestBase apply to ResourceRequest too? :) 437515 8 darin 2011-07-14 20:41:30 -0700 ResourceRequest is the class. ResourceRequestBase is just an implementation detail. I don’t think that policy about downloading belongs in ResourceRequest. That class is only about the specifications needed when loading a resource. FrameLoadRequest is probably an OK place for this since it’s where we handle frame targeting, another feature of the anchor element. Longer term it would be nice to go more directly to the downloading machinery and not treat this as a frame load at all. It’s not a frame load. For example, I don’t think HTMLAnchorElement should necessarily even call urlSelected in the download case. 437568 9 100933 sadrul 2011-07-14 22:58:42 -0700 Created attachment 100933 directly call startDownload I have made the change to call startDownload early directly from HTMLAnchorElement instead of going through urlSelected. Some notes: (1) I have tried to make sure that the ResourceRequest is properly updated with the referrer, user-agent etc. by adding FrameLoader::prepareResourceRequest (2) Added an optional 'String& suggestedName' parameter to WebCore::FrameLoaderClient::startDownload. It's currently unused in all implementations, but if this looks reasonable, I will hook it up at least for chromium. I really appreciate the quick reviews. Thanks! 437573 10 webkit.review.bot 2011-07-14 23:01:57 -0700 Attachment 100933 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/html/HTMLAnchorElement.cpp'..." exit_code: 1 Source/WebCore/html/HTMLAnchorElement.h:118: Extra space before ) [whitespace/parens] [2] Source/WebCore/html/HTMLAnchorElement.cpp:506: This { should be at the end of the previous line [whitespace/braces] [4] Source/WebCore/html/HTMLAnchorElement.cpp:511: An else should appear on the same line as the preceding } [whitespace/newline] [4] Total errors found: 3 in 24 files If any of these errors are false positives, please file a bug against check-webkit-style. 437601 11 100933 webkit-ews 2011-07-15 00:09:36 -0700 Comment on attachment 100933 directly call startDownload Attachment 100933 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/9097139 437608 12 ap 2011-07-15 00:26:15 -0700 Where does this feature come from? I can't find it in HTML5 spec. 437695 13 sadrul 2011-07-15 06:23:57 -0700 (In reply to comment #12) > Where does this feature come from? I can't find it in HTML5 spec. This is being discussed here: http://www.mail-archive.com/whatwg@lists.whatwg.org/msg27416.html 437776 14 100933 ap 2011-07-15 08:56:05 -0700 Comment on attachment 100933 directly call startDownload Thank you! New features need to be discussed on webkit-dev mailing list prior to being added to WebKit: <http://www.webkit.org/coding/adding-features.html>. It may be good to wait until a discussion on WhatWG list settles down first. r- since this can't be landed unless there is a wide agreement that this is a good feature addition. 437971 15 100933 fishd 2011-07-15 14:07:49 -0700 Comment on attachment 100933 directly call startDownload View in context: https://bugs.webkit.org/attachment.cgi?id=100933&action=review > Source/WebCore/html/HTMLAnchorElement.idl:29 > + attribute [Reflect] DOMString download; ap: we are working on reaching consensus on how best to reflect this option. it is clearly something everyone wants, but we just have to find the right form for it to take. we may want to vendor prefix this as well just as was done for <input type=file webkitdirectory>: <a webkitdownload=filename>. of course, that depends on the outcome of the working group thread. 438054 16 fishd 2011-07-15 16:34:04 -0700 It looks like @download=filename now has the support of Mozilla: http://lists.whatwg.org/htdig.cgi/whatwg-whatwg.org/2011-July/032490.html 438106 17 101085 sadrul 2011-07-15 19:03:44 -0700 Created attachment 101085 Check origin before downloading As per the discussion, I have made the change to check the origin first before allowing download. With this change, blob URLs, filesystem URLs and URLs for the same origin can be downloaded. Otherwise, the 'download' attribute is silently ignored. Or would it be more desirable to not follow the link at all and show an error to the user instead? 438110 18 101085 abarth 2011-07-15 20:00:09 -0700 Comment on attachment 101085 Check origin before downloading View in context: https://bugs.webkit.org/attachment.cgi?id=101085&action=review > Source/WebCore/loader/FrameLoader.cpp:1237 > + String referrer = request.httpReferrer(); > + if (referrer.isEmpty()) > + referrer = m_outgoingReferrer; > + if (SecurityOrigin::shouldHideReferrer(request.url(), referrer) || referrerPolicy == NoReferrer) > + referrer = String(); Is this code duplicated from somewhere else in FrameLoader? It would be nice not to duplicate. 438111 19 abarth 2011-07-15 20:00:26 -0700 Obviously, this patch is missing tests. 438112 20 sadrul 2011-07-15 20:23:05 -0700 (In reply to comment #18) > (From update of attachment 101085 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101085&action=review > > > Source/WebCore/loader/FrameLoader.cpp:1237 > > + String referrer = request.httpReferrer(); > > + if (referrer.isEmpty()) > > + referrer = m_outgoingReferrer; > > + if (SecurityOrigin::shouldHideReferrer(request.url(), referrer) || referrerPolicy == NoReferrer) > > + referrer = String(); > > Is this code duplicated from somewhere else in FrameLoader? It would be nice not to duplicate. It's a slightly modified piece of code from FrameLoader::loadURL and FrameLoader::urlSelected. But it doesn't look easily possible to refactor in a way that it can be used from loadURL/urlSelected too. 438113 21 sadrul 2011-07-15 20:24:47 -0700 (In reply to comment #19) > Obviously, this patch is missing tests. Indeed. I wanted to make sure I have put the pieces in the right places before working on the tests and updating the ChangeLog files :-) 438124 22 101090 sadrul 2011-07-15 21:47:04 -0700 Created attachment 101090 Always allow data URLs Made change to always allow data URLs. 438125 23 101090 abarth 2011-07-15 21:55:03 -0700 Comment on attachment 101090 Always allow data URLs View in context: https://bugs.webkit.org/attachment.cgi?id=101090&action=review > Source/WebCore/html/HTMLAnchorElement.cpp:506 > + if (download && (kurl.protocolIsData() || document()->securityOrigin()->canRequest(kurl))) { Please don't add special cases for data URLs. The data URL bug is part of a larger problem in WebKit. 438252 24 101111 sadrul 2011-07-16 22:11:27 -0700 Created attachment 101111 Add test, remove special case for data URLs, ChangeLog I have removed the special casing for data URLs. I have also added a couple of tests. 438258 25 101111 abarth 2011-07-16 23:13:21 -0700 Comment on attachment 101111 Add test, remove special case for data URLs, ChangeLog View in context: https://bugs.webkit.org/attachment.cgi?id=101111&action=review R-, mostly for the Origin header / FrameLoader question. Please feel free to renominate if I'm not understanding things properly. Thanks for adding tests in this iteration! > Source/WebCore/html/HTMLAnchorElement.idl:29 > + attribute [Reflect] DOMString download; Doe this API need to be conditional on something? Do all the ports understand how to use the suggested file name? From reading the code, it seems like this feature might be half-implemented on most ports because it will trigger the download but not suggest the file name. Maybe I'm misunderstanding? > Source/WebCore/loader/FrameLoader.cpp:1243 > + if (!referrer.isEmpty()) { > + request.setHTTPReferrer(referrer); > + RefPtr<SecurityOrigin> referrerOrigin = SecurityOrigin::createFromString(referrer); > + addHTTPOriginIfNeeded(request, referrerOrigin->toString()); > + } else Why are we adding an Origin header to GET requests? Normally we don't do that unless we're using CORS. This request doesn't seem to be a CORS request, however, because it's not using the CORS functions for preparing the request (which do things like remove authentication information). > Source/WebCore/loader/FrameLoader.h:275 > + void prepareResourceRequest(ResourceRequest&, ReferrerPolicy); This function name is very confusing. Should we call this function all the time when sending a request, or only in some circumstances? With a name like "prepareResourceRequest" it sounds like we should call this all the time because we always want to prepare resource requests before issuing them. > Source/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp:1329 > -void FrameLoaderClient::startDownload(const ResourceRequest& request) > +void FrameLoaderClient::startDownload(const ResourceRequest& request, const String& suggestedName) For example, on GTK, this looks like this function triggers the download but ignores the suggestedName. 438259 26 abarth 2011-07-16 23:16:04 -0700 I haven't been following the whatwg thread in much detail, but are we supposed to use CORS when issuing these requests? If so, instead of adding the Origin header manually, we can use these functions: http://trac.webkit.org/browser/trunk/Source/WebCore/loader/CrossOriginAccessControl.h Specifically, updateRequestForAccessControl understands how to do this work correctly. 438260 27 101111 abarth 2011-07-16 23:19:08 -0700 Comment on attachment 101111 Add test, remove special case for data URLs, ChangeLog View in context: https://bugs.webkit.org/attachment.cgi?id=101111&action=review >> Source/WebCore/loader/FrameLoader.cpp:1243 >> + if (!referrer.isEmpty()) { >> + request.setHTTPReferrer(referrer); >> + RefPtr<SecurityOrigin> referrerOrigin = SecurityOrigin::createFromString(referrer); >> + addHTTPOriginIfNeeded(request, referrerOrigin->toString()); >> + } else > > Why are we adding an Origin header to GET requests? Normally we don't do that unless we're using CORS. This request doesn't seem to be a CORS request, however, because it's not using the CORS functions for preparing the request (which do things like remove authentication information). The more I think about this code, the more I realize that it's not correct. For example, if the document is sandboxed (e.g., with the HTML5 sandbox attribute), this code will give use a non-"null" Origin header, which is wrong because the document is in a unique origin. Instead, assuming we want to add an Origin header, we should generate the header from the document's SecurityOrigin object instead of creating a fake one from the Referer. That will do the right thing in all cases, and is what the updateRequestForAccessControl function does. 438300 28 ap 2011-07-17 11:09:41 -0700 See also this thread: <http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2010-July/027455.html>. The WhatWG discussion has not yet reached the point of reconciling these proposals. Honestly, I don't know if CORS should have anything to do with @download. Clearly, there are security implications, but CORS is not an answer to every security problem on the Web. There are two new capabilities given by the proposed attribute - force downloading a resource, and rename it in the process. Neither is what a server operator would think about when opening a resource for cross origin use. 438301 29 101111 sadrul 2011-07-17 11:28:14 -0700 Comment on attachment 101111 Add test, remove special case for data URLs, ChangeLog View in context: https://bugs.webkit.org/attachment.cgi?id=101111&action=review >> Source/WebCore/html/HTMLAnchorElement.idl:29 >> + attribute [Reflect] DOMString download; > > Doe this API need to be conditional on something? Do all the ports understand how to use the suggested file name? From reading the code, it seems like this feature might be half-implemented on most ports because it will trigger the download but not suggest the file name. Maybe I'm misunderstanding? Nope, you are correct. The suggested filename is not used in any of the ports yet. I will be submitting another CL to use this name in chromium (once it is updated to handle the suggested name). Should this be conditional on PLATFORM(CHROMIUM) in that case? >>> Source/WebCore/loader/FrameLoader.cpp:1243 >>> + } else >> >> Why are we adding an Origin header to GET requests? Normally we don't do that unless we're using CORS. This request doesn't seem to be a CORS request, however, because it's not using the CORS functions for preparing the request (which do things like remove authentication information). > > The more I think about this code, the more I realize that it's not correct. For example, if the document is sandboxed (e.g., with the HTML5 sandbox attribute), this code will give use a non-"null" Origin header, which is wrong because the document is in a unique origin. Instead, assuming we want to add an Origin header, we should generate the header from the document's SecurityOrigin object instead of creating a fake one from the Referer. That will do the right thing in all cases, and is what the updateRequestForAccessControl function does. Ah, I see. I am going to remove the Origin header since this is, indeed, not a CORS request. (I wasn't aware of the implications you point out. Thanks) >> Source/WebCore/loader/FrameLoader.h:275 >> + void prepareResourceRequest(ResourceRequest&, ReferrerPolicy); > > This function name is very confusing. Should we call this function all the time when sending a request, or only in some circumstances? With a name like "prepareResourceRequest" it sounds like we should call this all the time because we always want to prepare resource requests before issuing them. I can rename it (e.g. prepareResourceRequestForAnchorDownload) to make it more obvious what it does, or get rid of the function altogether and update the ResourceRequest in HTMLAnchorElement::handleClick. WDYS? 438303 30 abarth 2011-07-17 11:44:43 -0700 > Should this be conditional on PLATFORM(CHROMIUM) in that case? Maybe add an ENABLE macro? It seems somewhat silly to have an entire ENABLE macro for such a trivial feature. There isn't any necessary connection between PLATFORM(CHROMIUM) and the presence of this API, so using that macro seems inappropriate. > I can rename it (e.g. prepareResourceRequestForAnchorDownload) to make it more obvious what it does, or get rid of the function altogether and update the ResourceRequest in HTMLAnchorElement::handleClick. WDYS? I'd rather the preparation of the resource request happened naturally in the course of FrameLoader handling the request. It's not entirely clear to me why a ResourceRequest for an anchor download is a special case for FrameLoader. How do the other folks who call startDownload handle this issue? These are all detail points, however. It's important that you also address Alexey's comments in Comment #28. 438488 31 sadrul 2011-07-18 08:10:44 -0700 > > I can rename it (e.g. prepareResourceRequestForAnchorDownload) to make it more obvious what it does, or get rid of the function altogether and update the ResourceRequest in HTMLAnchorElement::handleClick. WDYS? > > I'd rather the preparation of the resource request happened naturally in the course of FrameLoader handling the request. It's not entirely clear to me why a ResourceRequest for an anchor download is a special case for FrameLoader. How do the other folks who call startDownload handle this issue? > Darin A suggested in https://bugs.webkit.org/show_bug.cgi?id=64580#c8 that perhaps HTMLAnchorElement could start the download directly without having to go through FrameLoader. I wanted to try that out and see if that is doable now cleanly. But perhaps a larger refactoring would be necessary for that, and for now it's best to go through FrameLoader? 438515 32 sadrul 2011-07-18 09:25:54 -0700 (In reply to comment #28) > See also this thread: <http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2010-July/027455.html>. The WhatWG discussion has not yet reached the point of reconciling these proposals. > > Honestly, I don't know if CORS should have anything to do with @download. Clearly, there are security implications, but CORS is not an answer to every security problem on the Web. There are two new capabilities given by the proposed attribute - force downloading a resource, and rename it in the process. Neither is what a server operator would think about when opening a resource for cross origin use. Indeed, the discussion around cross-origin URLs/CORS continues, and doesn't seem to have converged yet. This CL currently ignores 'download' for cross-origin URLs entirely. Perhaps it should remain like this until there is an agreement on how to deal with them? 438525 33 abarth 2011-07-18 09:45:03 -0700 > Perhaps it should remain like this until there is an agreement on how to deal with them? Unfortunately, I don't think the security check you've added in this patch deals correctly with redirects. How does the download system know not to follow cross-origin redirects? 438626 34 sadrul 2011-07-18 12:21:49 -0700 (In reply to comment #33) > > Perhaps it should remain like this until there is an agreement on how to deal with them? > > Unfortunately, I don't think the security check you've added in this patch deals correctly with redirects. How does the download system know not to follow cross-origin redirects? Ah, yes. You are correct. Cross-origin redirects will cause a problem. You had brought this up before, sorry I missed it. 440958 35 fishd 2011-07-22 08:20:56 -0700 Looks like this is specified now in HTML: http://www.whatwg.org/specs/web-apps/current-work/#attr-hyperlink-download 440976 36 101736 sadrul 2011-07-22 09:04:48 -0700 Created attachment 101736 updated I have updated the patch to remove the check for SecurityOrigin. I have removed FrameLoader::prepareResourceForRequest, so now the Request is updated directly in HTMLAnchorElement before starting the download. 440978 37 101736 abarth 2011-07-22 09:27:34 -0700 Comment on attachment 101736 updated View in context: https://bugs.webkit.org/attachment.cgi?id=101736&action=review I like the new approach of not change ResourceRequestBase. Two comments below. > Source/WebCore/html/HTMLAnchorElement.cpp:512 > + if (!referrer.isEmpty()) > + request.setHTTPReferrer(referrer); Don't we need to call shouldHideReferrer? > Source/WebCore/html/HTMLAnchorElement.idl:29 > + attribute [Reflect] DOMString download; Looks like we still have the problem of this feature being half-implemented on non-Chromium ports. We either need to fully implementing it or have it be invisible. I'm not sure we can fully implement it without changing the embedders on those platforms, so we'll probably need to disable it. 440980 38 101739 sadrul 2011-07-22 09:56:02 -0700 Created attachment 101739 shouldHideReferrer Indeed. Updated to use shouldHideReferrer. 440983 39 101739 abarth 2011-07-22 10:05:43 -0700 Comment on attachment 101739 shouldHideReferrer View in context: https://bugs.webkit.org/attachment.cgi?id=101739&action=review > Source/WebCore/html/HTMLAnchorElement.idl:29 > + attribute [Reflect] DOMString download; We still have the feature-detection / half-implementation issue. 440986 40 sadrul 2011-07-22 10:16:33 -0700 (In reply to comment #39) > (From update of attachment 101739 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101739&action=review > > > Source/WebCore/html/HTMLAnchorElement.idl:29 > > + attribute [Reflect] DOMString download; > > We still have the feature-detection / half-implementation issue. Indeed. How do you suggest we go about this? As you mentioned earlier, using a PLATFORM check or an ENABLE flag both seem ... kind of unreasonable for something like this. 440996 41 abarth 2011-07-22 10:39:16 -0700 > Indeed. How do you suggest we go about this? As you mentioned earlier, using a PLATFORM check or an ENABLE flag both seem ... kind of unreasonable for something like this. I think the ENABLE macro is the lesser of two evils here. My thinking process is the following: 1) We can't implement the entire feature in WebKit, so we'll need to be able to turn it on for some platforms but not others. 2) JSC doesn't support EnableAtRuntime yet, so we need a compile-time option in the IDL. 3) This feature isn't specific to the Chromium platform. Chromium is just the first platform to implement the feature. That means PLATFORM(CHROMIUM) isn't right. That leaves an ENABLE macro. The only problem with using an ENABLE macro is that the feature is small, but that's not really a big problem. 440999 42 fishd 2011-07-22 10:42:10 -0700 ENABLE_DOWNLOAD_ATTRIBUTE 441095 43 101754 sadrul 2011-07-22 12:34:01 -0700 Created attachment 101754 ENABLE Added ENABLE_DOWNLOAD_ATTRIBUTE check, and turned it on for chromium. 441136 44 101754 abarth 2011-07-22 13:45:02 -0700 Comment on attachment 101754 ENABLE View in context: https://bugs.webkit.org/attachment.cgi?id=101754&action=review > Source/WebCore/html/HTMLAnchorElement.cpp:505 > +#if defined(ENABLE_DOWNLOAD_ATTRIBUTE) #if ENABLE(DOWNLOAD_ATTRIBUTE) > Source/WebCore/html/HTMLAnchorElement.idl:59 > +#if defined(ENABLE_DOWNLOAD_ATTRIBUTE) #if ENABLE(DOWNLOAD_ATTRIBUTE) 441154 45 101763 sadrul 2011-07-22 14:08:24 -0700 Created attachment 101763 proper use of ENABLE macro, and ChangeLog files Used the proper ENABLE macro, and updated the ChangeLog files accordingly. 441155 46 101754 ap 2011-07-22 14:09:53 -0700 Comment on attachment 101754 ENABLE View in context: https://bugs.webkit.org/attachment.cgi?id=101754&action=review > Source/WebCore/html/HTMLAnchorElement.cpp:507 > + bool download = hasAttribute(downloadAttr); > + if (download) { Why not "if (hasAttribute(downloadAttr))"? > Source/WebCore/html/HTMLAnchorElement.cpp:515 > + if (!hasRel(RelationNoReferrer)) { > + String referrer = frame->loader()->outgoingReferrer(); > + if (!referrer.isEmpty() && !SecurityOrigin::shouldHideReferrer(kurl, referrer)) > + request.setHTTPReferrer(referrer); > + frame->loader()->addExtraFieldsToMainResourceRequest(request); > + } It's pretty horrible to duplicate this code. > Source/WebCore/html/HTMLAnchorElement.idl:60 > +#if defined(ENABLE_DOWNLOAD_ATTRIBUTE) > + attribute [Reflect] DOMString download; Don't we have Conditional for attributes now? 441157 47 101763 ap 2011-07-22 14:13:41 -0700 Comment on attachment 101763 proper use of ENABLE macro, and ChangeLog files View in context: https://bugs.webkit.org/attachment.cgi?id=101763&action=review There are no tests for programmatic setting and unsetting of download here. > Source/WebCore/loader/FrameLoaderClient.h:182 > + virtual void startDownload(const ResourceRequest&, const String& = String()) = 0; This argument definitely needs a name. 441159 48 101763 ap 2011-07-22 14:17:28 -0700 Comment on attachment 101763 proper use of ENABLE macro, and ChangeLog files View in context: https://bugs.webkit.org/attachment.cgi?id=101763&action=review > LayoutTests/fast/dom/HTMLAnchorElement/anchor-nodownload.html:24 > + var evt = document.createEvent("MouseEvent"); > + evt.initMouseEvent('click', true, true); > + link.dispatchEvent(evt); Ouch. I think that programmatically created mouse events should not be able to start download. > Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:795 > +void WebFrameLoaderClient::startDownload(const ResourceRequest& request, const String& suggestedName) > { > m_frame->startDownload(request); > } How doesn't this unused argument no break the build? Ditto elsewhere. > Source/WebKit2/WebProcess/WebPage/WebFrame.h:73 > + void startDownload(const WebCore::ResourceRequest&, const String& = String()); I guess it's not a big deal to modify to WebFrame, but it doesn't seem necessary. 441174 49 fishd 2011-07-22 14:29:05 -0700 (In reply to comment #48) > (From update of attachment 101763 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101763&action=review > > > LayoutTests/fast/dom/HTMLAnchorElement/anchor-nodownload.html:24 > > + var evt = document.createEvent("MouseEvent"); > > + evt.initMouseEvent('click', true, true); > > + link.dispatchEvent(evt); > > Ouch. I think that programmatically created mouse events should not be able to start download. You can programmatically navigate to an URL that may be configured to return a Content-Disposition header. Why is this any different? What are you worried about? 441210 50 ap 2011-07-22 15:18:30 -0700 I'm worried about Safari carpet bombing (e.g. <http://blogs.pcmag.com/securitywatch/2008/05/safari_carpet_bombing.php>). If my reading is correct, HTML5 says that synthetic events shouldn't work with links: ---------------- When a user agent is to run synthetic click activation steps on an element, the user agent must run pre-click activation steps on the element, then fire a click event at the element. The default action of this click event must be to run post-click activation steps on the element. If the event is canceled, the user agent must run canceled activation steps on the element instead. ---------------- 441239 51 fishd 2011-07-22 16:02:21 -0700 (In reply to comment #50) > I'm worried about Safari carpet bombing (e.g. <http://blogs.pcmag.com/securitywatch/2008/05/safari_carpet_bombing.php>). I don't understand why this adds any kind of new "carpet bombing" vector. A web page can already trigger downloads automatically using a cooperative server. What am I missing? > If my reading is correct, HTML5 says that synthetic events shouldn't work with links: I think your reading of the spec is correct. I would actually quote the 'activation behavior' section of a elements: If the click event in question is not trusted (i.e. a click() method call was the reason for the event being dispatched), and either the a element has a download attribute or the element's target attribute is present and applying the rules for choosing a browsing context given a browsing context name, using the value of the target attribute as the browsing context name, would result in there not being a chosen browsing context, then raise an INVALID_ACCESS_ERR exception and abort these steps. ^^^ We can extract the following from the above text: If the click event in question is not trusted, and [...] the a element has a download attribute [...], then raise an INVALID_ACCESS_ERR exception and abort these steps. I really wonder why that was put in the spec. I don't see what problem that is solving that wouldn't already exist. Will we require there to be a user gesture active in order for someone to use the FileSaver API? If it is so important that there be a user gesture present, then what about click jacking attacks? 441264 52 ap 2011-07-22 16:39:31 -0700 > I don't understand why this adds any kind of new "carpet bombing" vector. A web page can already trigger downloads automatically using a cooperative server. What am I missing? I think that your analysis is accurate. The difference is that this is a new feature, so it's super safe to prevent programmatic downloading here from the start, and look into changing regular link behavior as a more dangerous fix later. > I really wonder why that was put in the spec. I don't see what problem that > is solving that wouldn't already exist. Will we require there to be a user > gesture active in order for someone to use the FileSaver API? (1) I don't know the history of that, but I like that direction. (2) Yes. I guess so?.. > If it is so important that there be a user gesture present, then what about > click jacking attacks? Is that something that can easily be prevented from the start? Otherwise, that may be a problem to think about in the future as the HTML5 platform matures. As a possibly obvious comment, I'm not talking about a user gesture being present - if that were the requirement, then a page could click() any number of links when handling a click on text content, for example. It should be an actual difference between real and synthetic events. 441277 53 fishd 2011-07-22 16:49:44 -0700 (In reply to comment #52) > > I don't understand why this adds any kind of new "carpet bombing" vector. A web page can already trigger downloads automatically using a cooperative server. What am I missing? > > I think that your analysis is accurate. The difference is that this is a new feature, so it's super safe to prevent programmatic downloading here from the start, and look into changing regular link behavior as a more dangerous fix later. You agree with me that being conservative here has no technical merits, and yet you prefer to be conservative? I'm not sure which analysis you are agreeing with :-) > > If it is so important that there be a user gesture present, then what about > > click jacking attacks? > > Is that something that can easily be prevented from the start? Otherwise, that may be a problem to think about in the future as the HTML5 platform matures. I don't see how to avoid it. Clearly the page can be moving an anchor tag around, with the intention of tricking the user into clicking on the anchor tag accidentally. If we think we are protecting something by requiring a real user click on an anchor tag to authorize something, then we are mistaken. There are many things in HTML that were invented without considering click-jacking attacks. > As a possibly obvious comment, I'm not talking about a user gesture being present - if that were the requirement, then a page could click() any number of links when handling a click on text content, for example. It should be an actual difference between real and synthetic events. Yeah, sorry for introducing confusion there. There's not a big difference really. Though with click-jacking you can only get a single anchor tag to be clicked, as opposed to many, if the goal is to prevent @download from triggering a download without the user's intent, then the HTML spec doesn't achieve that goal. 441290 54 ap 2011-07-22 17:14:32 -0700 I'm only talking about preventing carpet bombing, not about preventing downloading a single file. As you explain, the latter cannot be always achieved if a download starts automatically, as it does in Safari on Mac. Oh, and I'm also talking about HTML5 compliance now :) 441330 55 ian 2011-07-22 19:55:41 -0700 The activation behaviour is irrelevant for synthetic click events, since the activation behaviour only runs for UA-created click events (either from real clicks, or from the click() method). I do not think that Web pages should be able to trigger downloads automatically using any kind of server, cooperative or otherwise. A navigation that triggers a fetch that is treated "as a download" (to use the new spec terminology) should IMHO not automatically result in a file being stored on the user's machine. (Those pages that use meta refreshes for downloads drive me crazy. Just let me download the file from the earlier page, don't show me a separate HTML page and trigger the download from there. Gah.) But I'm probably in the minority. If you are going to allow the click() method to trigger the download as well, then let me know and I'll make honouring it in that case optional instead of disallowed. 441346 56 101763 ap 2011-07-22 23:05:18 -0700 Comment on attachment 101763 proper use of ENABLE macro, and ChangeLog files r- since there were several comments to address, and other reviewers had a chance to see this in queue already. I recommend doing what HTML5 says now, and not allowing synthetic clicks to start downloads, unless there is a big reason for Chrome to want otherwise. 441414 57 sadrul 2011-07-23 15:21:57 -0700 (In reply to comment #56) > (From update of attachment 101763 [details]) > r- since there were several comments to address, and other reviewers had a chance to see this in queue already. > > I recommend doing what HTML5 says now, and not allowing synthetic clicks to start downloads, unless there is a big reason for Chrome to want otherwise. Should synthetic clicks on a link with 'download' be completely ignored, or should only the 'download' attribute be ignored, and the click should trigger a normal navigation? 441417 58 ap 2011-07-23 16:05:49 -0700 Let's not changing any currently existing behaviors in this patch. 441428 59 101825 sadrul 2011-07-23 17:31:51 -0700 Created attachment 101825 updated I believe I have addressed all the comments (e.g. use 'Conditional', add name for the new parameter to startDownload, comment out unused parameters etc.). I have also added two tests that sets/unsets the 'download' attribute. 441429 60 sadrul 2011-07-23 17:34:27 -0700 > > Source/WebCore/html/HTMLAnchorElement.cpp:515 > > + if (!hasRel(RelationNoReferrer)) { > > + String referrer = frame->loader()->outgoingReferrer(); > > + if (!referrer.isEmpty() && !SecurityOrigin::shouldHideReferrer(kurl, referrer)) > > + request.setHTTPReferrer(referrer); > > + frame->loader()->addExtraFieldsToMainResourceRequest(request); > > + } > > It's pretty horrible to duplicate this code. I couldn't find a clean way of avoiding the duplication here. The code is reasonably small and simple that perhaps this duplication is tolerable? But I am all-ears for suggestions to make this better :-) 441430 61 101763 sadrul 2011-07-23 17:37:23 -0700 Comment on attachment 101763 proper use of ENABLE macro, and ChangeLog files View in context: https://bugs.webkit.org/attachment.cgi?id=101763&action=review >> Source/WebCore/loader/FrameLoaderClient.h:182 >> + virtual void startDownload(const ResourceRequest&, const String& = String()) = 0; > > This argument definitely needs a name. Added name. >> Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:795 >> } > > How doesn't this unused argument no break the build? Ditto elsewhere. I think -Wno-unused-parameter flag is used for compiling? I have put the variable name in a /* comment since that style seems to be used in a few places in WebKit to avoid the issue. >> Source/WebKit2/WebProcess/WebPage/WebFrame.h:73 >> + void startDownload(const WebCore::ResourceRequest&, const String& = String()); > > I guess it's not a big deal to modify to WebFrame, but it doesn't seem necessary. I have removed this from here. 441438 62 101825 ap 2011-07-23 23:56:16 -0700 Comment on attachment 101825 updated View in context: https://bugs.webkit.org/attachment.cgi?id=101825&action=review But this still allows synthetic events to start download? I thought that you were going to not allow for that? > Source/WebKit/chromium/src/FrameLoaderClientImpl.cpp:1076 > +void FrameLoaderClientImpl::startDownload(const ResourceRequest& request, const String& /* suggestedName */) Another option would be to just omit the name. 441452 63 sadrul 2011-07-24 08:31:01 -0700 (In reply to comment #62) > (From update of attachment 101825 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101825&action=review > > But this still allows synthetic events to start download? I thought that you were going to not allow for that? Ah, I misunderstood the suggestion to not change the behaviour in this patch :) I will be making the change to not trigger a download for synthetic clicks; I suppose I should be using isSimulated() to check? 441461 64 abarth 2011-07-24 10:25:13 -0700 > I will be making the change to not trigger a download for synthetic clicks; I suppose I should be using isSimulated() to check? I'm not sure that's right: Document::createEvent calls MouseEvent::create(), which calls MouseEvent::MouseEvent(), which calls MouseRelatedEvent::MouseRelatedEvent(), which sets m_isSimulated(false). I'm not sure we distinguish between synthetic and non-synthetic events in the DOM. Another approach is to limit this action to occurring during a user gesture by checking ScriptController::isUserGesture. That's consistent with how we handle other spam-like issues, which this appears to be. 441464 65 ap 2011-07-24 10:45:28 -0700 As discussed with Darin, checking for user gesture is insufficient, because a handler for a single unrelated gesture could download any number of files, which is exactly what need to be prevented. We make a distinction for keyboard events implicitly, by checking whether there is an underlying platform event. I guess we need to make isSimulated() actually work - per Adam's analysis, it seems just broken now. 441465 66 abarth 2011-07-24 11:00:21 -0700 > As discussed with Darin, checking for user gesture is insufficient, because a handler for a single unrelated gesture could download any number of files, which is exactly what need to be prevented. I'm not sure why we're putting these anti-spam measures in WebCore. It seems like they should be the responsibility of the embedder. For example, Chrome already has embedder-side anti-spam measures for downloads. Other embedders, in different scenarios, might well want to make other trade-offs w.r.t. download spam. Perhaps the best approach is what we do with pop-ups: provide the embedder with a choice about whether to allow the download. In this case, specifically, Chrome would choose to have WebCore always allow the download and have the higher level anti-spam measures for downloads kick in. That approach has a number of advantages. For example, if a page initiates a download via this API and via another API, the anti-spam algorithm sees both downloads and can take appropriate action. For example, the algorithm might permit one of the downloads, block the other, and display some sort of UI explaining what happened to the user. Given that this feature is implemented only on PLATFORM(CHROMIUM) in this patch, adding anti-spam now is not necessary and would add unused complexity. It seems appropriate, then, to land this patch as-is and revisit the anti-spam question when another port is interested in implementing this API. 441470 67 ap 2011-07-24 11:58:21 -0700 > I'm not sure why we're putting these anti-spam measures in WebCore Just implementing what HTML5 says. 441472 68 101825 ap 2011-07-24 12:05:19 -0700 Comment on attachment 101825 updated Marking r- to that effect. 441484 69 abarth 2011-07-24 13:14:07 -0700 > Just implementing what HTML5 says. Hixie says in Comment #55 that he'll update the spec to allow this behavior if that's what we choose to implement. It seems clear to me that we should land this patch as-is, at least as a first iteration. If we want to add anti-spam in WebCore later, we can certainly do that. IMHO, we shouldn't handle anti-spam in WebCore because that's better handled by the embedder, like we do for other spam, like poups and alerts. 441485 70 101825 abarth 2011-07-24 13:21:19 -0700 Comment on attachment 101825 updated Marking R+ because this patch seems correct and ap only marked it r- based on the current spec text, which the editor has said he'll update if we go this route in the implementation. 441487 71 ian 2011-07-24 13:39:58 -0700 "The spec said so" is a pretty bad reason to implement something, especially when you're the first implementation, the spec is less than a week old, and it was written was someone with my track record at making mistakes. :-) 441534 72 ap 2011-07-24 19:29:14 -0700 This has been discussed in several rounds already, with no reason given not to do what the spec says. This bugzilla flag resetting war is stupid - Adam, could you please refrain from it until this is settled? 441537 73 ap 2011-07-24 19:33:16 -0700 Is there a reason for Google contributors to want making synthetic events work here? 441539 74 ap 2011-07-24 19:37:05 -0700 (In reply to comment #71) > "The spec said so" is a pretty bad reason to implement something, especially when you're the first implementation, the spec is less than a week old, and it was written was someone with my track record at making mistakes. :-) I thought that was a nice short reason to give after a few rounds of discussion, which seem to have been ignored by this particular reviewer. Said reviewer has also missed a number of other issues with this patch previously. Forcing cq+ over a previous r- on Sunday hasn't gone unnoticed, too. Stay classy! 441767 75 fishd 2011-07-25 11:42:17 -0700 (In reply to comment #73) > Is there a reason for Google contributors to want making synthetic events work here? It is not about enabling a feature for Google. AFAIK, the customer use case would be solved with the restricted form of a@download. My objection is that restricting a@download adds complexity to the platform in a way that is inconsistent with other features of the platform. Script can already create as many downloads as it likes by: 1- Creating a Data URL, Blob URL or FileSystem URL with mime type application/octet-stream, and navigating an iframe to that Data URL. (The FileSystem case just requires that you use an unknown file extension.) 2- Arranging to have a server provide a C-D header, and navigating an iframe to that HTTP URL. This means that placing a restriction on a@download doesn't prevent someone who wishes to spam the browser's download system. The browser will need to have anti-spam measures to manage those vectors. Second, on the topic of user-gesture. If we implement FileSaver, then we will not have a click target. We will instead need to rely on user-gesture if we wanted to limit FileSavers use. If we are going to limit FileSaver based on user-gesture, then we might as well use a consistent policy for scripts click()ing an anchor tag, otherwise it is just inconsistent policy. As you can see, I'm arguing for consistency in the platform. I think this is a good goal. My preference from most to least preferred: 1) No web platform restrictions on a@download and FileSaver. This is consistent with navigating an iframe. 2) Restrict a@download and FileSaver based on whether or not there is a user gesture. 441884 76 fishd 2011-07-25 14:52:30 -0700 Here's a motivating use case for unrestricted a@download. A web mail program might wish to offer the user the option to "download all" attachments. That would require clicks on multiple anchor tags, but if that clicking cannot be automated by JS, then the web app has no way to provide the user with this feature. However, an online web mail program could offer this feature. 442003 77 ap 2011-07-25 17:10:36 -0700 We had a long IRC discussion with Darin Fisher, and the above use case was the only one that needed default event handlers to work with simulated events. Seems that not letting a simulated event trigger a download is still the way to go for this bug. 442024 78 abarth 2011-07-25 17:32:27 -0700 > Seems that not letting a simulated event trigger a download is still the way to go for this bug. Maybe I'm missing something, but this restriction doesn't seem to actually prevent the web site from doing anything because there are lots of other avenues for spamming downloads. Is there some technical reason why this restriction buys us anything? 442291 79 ian 2011-07-26 08:43:56 -0700 I strongly agree with ap that dispatchEvent()-generated events should not cause a link to do anything. But that's got nothing to do with the changes for download=""; the spec has long said that script-dispatched events do not have UA-provided default actions, since the event model is that the default action is, by definition, whatever the code that dispatched the event makes it. When script dispatches the event, there is no browser-provided default action since the browser didn't dispatch the event, and thus the link should do nothing. However, when the click() method is called, it _should_ do something, because the click() method both dispatches the event *and does the default action*, again by definition. Now in this case there are two things the spec currently says should not happen that would happen in the case of a real trusted click: popups shouldn't open, and nothing should happen if the download="" attribute is present. I also think we should change the spec to say that if you navigate to a URL that then triggers a download, the download shouldn't happen. Currently this isn't in the spec. Unfortunately this not being in the spec means that the restriction on download="" is pretty lame, since it means you can do the downloads with a bunch of iframes but not with a bunch of links. In the medium term I intend to make the spec consistent so that either no downloads are allowed without user gesture, or all downloads triggered from click() will work as if they had a user gesture. I do not intend to change the thing with synthetic events (those should not ever work, that's a long-standing bug in WebKit), and do not intend to change the popup blocking. HTH. 442294 80 ian 2011-07-26 08:46:03 -0700 (The point being, you should definitely prevent synthetic events from ever having a default action, and for click(), you should really either add the restriction against downloads even in the navigation case, or remove it in the download="" case. Having it only for download="" makes no sense. I'll update the spec to match implementations when there are some.) 442299 81 ap 2011-07-26 08:59:00 -0700 For some context, WebKit doesn't currently expose click() on HTMLAnchorElement at all. I think that we only support it on buttons. 442304 82 101825 sadrul 2011-07-26 09:10:57 -0700 Comment on attachment 101825 updated Requesting r?/cq? since it sounds like there is agreement that synthetic clicks should be handled to not trigger default action in general, but doing that especially for only a@download in this bug is inconsistent. 442309 83 101825 ap 2011-07-26 09:20:52 -0700 Comment on attachment 101825 updated If you want to add a check for synthetic events for HTMLAnchorElement in general, you are welcome to do this in a separate bug. But adding a new feature without the check is not the way to go - it's something that needs to be done, and now is the best time to do it. 442311 84 fishd 2011-07-26 09:33:14 -0700 (In reply to comment #79) Hixie, thank you for the detailed explanation! It was very educational. I was indeed conflating click() and synthetic events. I agree that a synthetic "click" event should not perform the default action. Here's what I think we should do: 1- Add support for a@download. 2- Disable performing the default action for synthetic events. 3- Add support for HTMLAnchorElement::click(). I think each of these steps should be separate bugs / patches. > But adding a new feature without the check is not the way to go - it's something > that needs to be done, and now is the best time to do it. I think you are arguing that if we do not add the check for synthetic events in this case that we might lead people to depend on being able to use synthetic click events to trigger a download. That might make it harder to implement #2. I'm assuming the code to check for a synthetic event is fairly trivial? 442339 85 fishd 2011-07-26 10:19:34 -0700 (In reply to comment #80) > (The point being, you should definitely prevent synthetic events from ever having a default action, and for click(), you should really either add the restriction against downloads even in the navigation case, or remove it in the download="" case. Having it only for download="" makes no sense. I'll update the spec to match implementations when there are some.) Agreed. I don't think we can get away with preventing downloads triggered via script navigating a window as that would break many web sites. We can't require a user gesture. 442375 86 ap 2011-07-26 11:07:43 -0700 > I think you are arguing that if we do not add the check for synthetic events in this > case that we might lead people to depend on being able to use synthetic click events > to trigger a download. That might make it harder to implement #2. That's correct, I prefer this check to be implemented upfront for this reason. There is no good reason to land this patch with regression tests using dispatchEvent just to change them the next day, when dispatchEvent stops working. > I'm assuming the code to check for a synthetic event is fairly trivial? Yes, adding it in @download code path shouldn't be a significant slowdown to getting this feature implemented and enabled in Chrome. As Adam Barth mentioned in comment 64, there is some investigation to do, but it's unlikely to be very difficult. 442387 87 abarth 2011-07-26 11:18:12 -0700 > 2- Disable performing the default action for synthetic events. ^^^ It's unclear to me what sort of compatibility risk this change would incur. Whether we want to make that change globally throughout the project is a separate question from what we do with this patch. The correct way to implement (2) is to change when HTMLAnchorElement::defaultEventHandler is called, not do donk around with the "is synthetic" bool. Changing when HTMLAnchorElement::defaultEventHandler is called will change both the link following and the downloading behavior simultaneously, which means if we tried to implement that restriction this patch we'd either 1) face the compat risk of changing how dispatchEvent works for following hyperlinks, or 2) need to used a hacky implementation of the restriction other than changing when HTMLAnchorElement::defaultEventHandler is called. Neither of those alternatives is appealing. Therefore, we should proceed with this patch as-is and then decide whether to implement (2) globally. Once we make that decision, we can implement it correctly. 442389 88 abarth 2011-07-26 11:20:05 -0700 The fact that this patch contains a testing that uses dispatchEvent is irrelevant. If we globally change how dispatchEvent works in WebKit, there are going to be lots of tests that need to be updated. In any case, we're no longer talking about whether this patch is beneficial. We're now just talking about the order in which we wish to make future changes. IMHO, this patch has been delayed long enough by this non-issue. 442426 89 ap 2011-07-26 12:05:18 -0700 This is a new feature. It is very relevant it is implemented correctly from the start. The correct behavior could have been implemented in a fraction of time spent debating whether to land a patch with incorrect behavior. 442438 90 abarth 2011-07-26 12:17:43 -0700 > The correct behavior could have been implemented in a fraction of time spent debating whether to land a patch with incorrect behavior. You haven't responded the content of Comment #87, which explains why this is not as simple that. We shouldn't gate this feature on incurring the global compat risk, nor should we implement the restriction only for this feature because that's not the correct way to implement the restriction. In any case, I'm tired of this discussion. It's not going anywhere. This is an incredibly minor feature. The fact that we need to have a massive bug thread about this issue tells me there is something wrong with how the project is functioning. 442455 91 ap 2011-07-26 12:29:15 -0700 I don't know what to respond to comment 87. It contains a claim that a difficult and risky way to implement this is correct, but I don't know why it is better than the alternative. 442468 92 abarth 2011-07-26 12:48:00 -0700 What is the alternative? 442476 93 abarth 2011-07-26 12:59:45 -0700 To save a round-trip, if you're suggestion is to use isSynthetic, that's not a good design. We tried that approach with user gestures, and it was a mess because folks need to correct handle the bit in many places and the consequences are subtle. As an example, our implementation of isSynthetic is currently wrong in a couple places which I found by inspecting the code. The trail of tears from that sort of design is why I ripped out wasUserGesture. The model Hixie suggests in Comment #79 is a better approach for implementing that behavior (assuming we want to implement that behavior). 442484 94 abarth 2011-07-26 13:18:30 -0700 Looking into isSimulated in more detail, it's only used to adjust the location of the event based on zoom settings, which is why it's very robust. It's also only present on MouseRelatedEvent. I think the right way to resolve this issue is to change the test to use EventSender and then land this patch. We can take up the question of whether to globally change how we deal with default event handlers in another bug. 442488 95 fishd 2011-07-26 13:27:58 -0700 (In reply to comment #94) > I think the right way to resolve this issue is to change the test to use EventSender and then land this patch. We can take up the question of whether to globally change how we deal with default event handlers in another bug. ^^^ Agreed. I'm not against limiting what dispatchEvent can do, but I don't think we need to do that in this patch. I agree that it should be done globally in a clean, maintainable way. I also agree that EventSender is the right thing to use now, so that when we change the behavior of dispatchEvent, we don't have to rewrite these tests. 442494 96 102046 abarth 2011-07-26 13:38:33 -0700 Created attachment 102046 Patch with updated tests 442497 97 abarth 2011-07-26 13:40:09 -0700 > which is why it's very robust it's => it isn't 442510 98 ap 2011-07-26 13:58:35 -0700 Is anyone willing to take responsibility for making sure that dispatchEvent() on <a download> doesn't trigger a download before any significant WebKit browser release? 442511 99 102046 fishd 2011-07-26 13:59:15 -0700 Comment on attachment 102046 Patch with updated tests LGTM 442513 100 abarth 2011-07-26 14:01:50 -0700 > Is anyone willing to take responsibility for making sure that dispatchEvent() on <a download> doesn't trigger a download before any significant WebKit browser release? Perhaps more appropriate would be a willingness to undertake the compat risk of changing dispatchEvent not trigger a download if/when we change WebKit's behavior globally. 442517 101 ap 2011-07-26 14:06:00 -0700 No. If we can't implement this feature with standard compatible behavior because WebKit is "globally" not ready for that, then fixing synthetic events "globally" becomes a pre-requisite. 442528 102 102046 webkit.review.bot 2011-07-26 14:26:32 -0700 Comment on attachment 102046 Patch with updated tests Attachment 102046 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/9250472 442535 103 abarth 2011-07-26 14:40:49 -0700 > No. If we can't implement this feature with standard compatible behavior because WebKit is "globally" not ready for that, then fixing synthetic events "globally" becomes a pre-requisite. I don't believe it's reasonable to gate this feature on changing WebKit's default event handler behavior globally. Sorry. 442536 104 fishd 2011-07-26 14:41:57 -0700 (In reply to comment #101) > No. If we can't implement this feature with standard compatible behavior because WebKit is "globally" not ready for that, then fixing synthetic events "globally" becomes a pre-requisite. Alexey, I'm struggling to understand your argument. I think it makes sense to separate the a@download feature from the behavior of dispatchEvent. We can agree that changing the behavior of dispatchEvent is a larger challenge, and it should be done in a separate patch. I'm not concerned about the order of these patches. Here's why: No other browsers ship a@download yet. Firefox, which appears interested in this feature too, does not perform the default action when a synthetic event is dispatched on an anchor element. So, it is unlikely that apps would start depending on this behavior since it would not be universally supported. The HTML spec even disallows it. Frankly, I think you are making this into a much bigger deal than it needs to be. I think there is probably more risk involved with a one-off "isSynthetic" check than temporarily shipping code that permits a synethetic click to trigger a download. Put another way, I don't mind making a breaking change to Chrome later that removes the ability for a synthetic click to trigger a download. 442557 105 102058 abarth 2011-07-26 15:04:54 -0700 Created attachment 102058 Patch that builds on mac 442566 106 ap 2011-07-26 15:15:57 -0700 This patch adds a feature that's not working as specified in a significant way, and there is no clear path proposed towards fixing that. That's not a separate concern in my opinion. Thank you for updating the tests. After all this discussion, I think that it's appropriate to also add a test verifying that initEvent/dispatchEvent don't trigger a download. 442577 107 ap 2011-07-26 15:39:00 -0700 > I think there is probably more risk involved with a one-off "isSynthetic" check than temporarily shipping code that permits a synethetic click to trigger a download. I think that it's more about being a poor engineering practice than a direct risk. I'd grade the problems with this poor practice as very small. I appreciate your willingness to not get Chrome fixed on non-compliant behavior, but is there a need for it? It seems quite trivial to get it right from the start. 442596 108 fishd 2011-07-26 16:01:59 -0700 (In reply to comment #106) > This patch adds a feature that's not working as specified in a significant way, and there is no clear path proposed towards fixing that. That's not a separate concern in my opinion. Doesn't https://bugs.webkit.org/show_bug.cgi?id=64580#c84 provide a clear path toward fixing dispatchEvent to not perform the default action? At any rate, I filed a bug about suppressing the default action for synthetic events: https://bugs.webkit.org/show_bug.cgi?id=65215 442600 109 ap 2011-07-26 16:07:01 -0700 Sorry, I thought that later comments in the bug meant that the proposal from comment 84 was no longer on the table. I don't see any possible practical problem with landing this patch if fixing bug 65215 can get a higher priority than "if/when". Having both an implementation of a@download and a fix for this long-standing bug would be great, and more than what I was asking for. Thank you! 442610 110 fishd 2011-07-26 16:24:28 -0700 (In reply to comment #109) > Sorry, I thought that later comments in the bug meant that the proposal from comment 84 was no longer on the table. > > I don't see any possible practical problem with landing this patch if fixing bug 65215 can get a higher priority than "if/when". Having both an implementation of a@download and a fix for this long-standing bug would be great, and more than what I was asking for. Thank you! Yes, I think that it is valuable to match the spec with regards to dispatchEvent and default actions. I also like implementing the .click() property. 442611 111 102058 abarth 2011-07-26 16:25:54 -0700 Comment on attachment 102058 Patch that builds on mac Clearing flags on attachment: 102058 Committed r91797: <http://trac.webkit.org/changeset/91797> 442612 112 abarth 2011-07-26 16:26:03 -0700 All reviewed patches have been landed. Closing bug. 100911 2011-07-14 18:39:49 -0700 2011-07-14 19:48:24 -0700 first cut for review webkit-a-download.patch text/plain 10051 sadrul ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u OTAwMjQyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTE0NywxMCArMTQ3LDcgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoaXNMaW5rQ2xpY2so ZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShldmVudFR5cGUoZXZlbnQpKSkg ewotICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRNTFNw YWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAgICAgIGFwcGVuZFNlcnZlck1h cE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAgICBoYW5kbGVMaW5rQ2xpY2so ZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRhcmdldEF0dHIpLCBoYXNSZWwo UmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5kUGluZ3MoZG9jdW1lbnQoKS0+ Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVDbGljayhldmVudCk7CiAgICAg ICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYgKzQ4OSwyNCBAQCB2b2lkIEhU TUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgS1VSTCYgZGVzdGluYXRpb25VUkwpCiAg ICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5nKGRvY3VtZW50KCktPmZyYW1lKCksIGRvY3VtZW50 KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ldKSwgZGVzdGluYXRpb25VUkwpOwogfQogCit2b2lk IEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVDbGljayhFdmVudCogZXZlbnQpCit7CisgICAgZXZl bnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudCgp LT5mcmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIFN0cmlu ZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZ2V0QXR0cmlidXRlKGhy ZWZBdHRyKSk7CisgICAgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbih1cmwsIGV2ZW50KTsK KworICAgIGJvb2wgZG93bmxvYWQgPSBoYXNBdHRyaWJ1dGUoImRvd25sb2FkIik7CisgICAgU3Ry aW5nIG5hbWUgPSBkb3dubG9hZCA/IGdldEF0dHJpYnV0ZSgiZG93bmxvYWQiKSA6ICIiOworICAg IGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJs KSwgdGFyZ2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJy ZXIpID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlciwgZG93bmxvYWQsICZuYW1lKTsKKworICAg IHNlbmRQaW5ncyhkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwpKTsKK30KKwogSFRNTEFuY2hv ckVsZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5jaG9yRWxlbWVudDo6ZXZlbnRUeXBlKEV2ZW50KiBl dmVudCkKIHsKICAgICBpZiAoIWV2ZW50LT5pc01vdXNlRXZlbnQoKSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTEFuY2hvckVsZW1lbnQuaAppbmRleCA2MDdkMWY1Li5hOWJiNWIwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKKysrIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCkBAIC0xMTUsNiArMTE1LDggQEAgcHJpdmF0 ZToKIAogICAgIHZvaWQgc2VuZFBpbmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKTsKIAor ICAgIHZvaWQgaGFuZGxlQ2xpY2soRXZlbnQqIGV2ZW50KTsKKwogICAgIGVudW0gRXZlbnRUeXBl IHsKICAgICAgICAgTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleSwKICAgICAgICAgTW91c2VFdmVu dFdpdGhTaGlmdEtleSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxv YWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCmluZGV4IDM1 NDVhMTYuLjY5MmM2MjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxv YWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcApAQCAt MjYxLDkgKzI2MSwxNSBAQCB2b2lkIEZyYW1lTG9hZGVyOjpjaGFuZ2VMb2NhdGlvbihQYXNzUmVm UHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9yaWdpbiwgY29ucwogICAgICAgICAwLCBsb2Nr SGlzdG9yeSwgbG9ja0JhY2tGb3J3YXJkTGlzdCwgU2VuZFJlZmVycmVyLCBSZXBsYWNlRG9jdW1l bnRJZkphdmFTY3JpcHRVUkwpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyOjp1cmxTZWxlY3RlZChj b25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcGFzc2VkVGFyZ2V0LCBQYXNzUmVmUHRyPEV2 ZW50PiB0cmlnZ2VyaW5nRXZlbnQsIGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgbG9ja0JhY2tGb3J3 YXJkTGlzdCwgUmVmZXJyZXJQb2xpY3kgcmVmZXJyZXJQb2xpY3kpCit2b2lkIEZyYW1lTG9hZGVy Ojp1cmxTZWxlY3RlZChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgcGFzc2VkVGFyZ2V0 LCBQYXNzUmVmUHRyPEV2ZW50PiB0cmlnZ2VyaW5nRXZlbnQsIGJvb2wgbG9ja0hpc3RvcnksIGJv b2wgbG9ja0JhY2tGb3J3YXJkTGlzdCwgUmVmZXJyZXJQb2xpY3kgcmVmZXJyZXJQb2xpY3ksIGJv b2wgc2hvdWxkRG93bmxvYWQsIGNvbnN0IFN0cmluZyogZG93bmxvYWROYW1lKQogewotICAgIHVy bFNlbGVjdGVkKEZyYW1lTG9hZFJlcXVlc3QobV9mcmFtZS0+ZG9jdW1lbnQoKS0+c2VjdXJpdHlP cmlnaW4oKSwgUmVzb3VyY2VSZXF1ZXN0KHVybCksIHBhc3NlZFRhcmdldCksCisgICAgUmVzb3Vy Y2VSZXF1ZXN0IHJlcXVlc3QodXJsKTsKKyAgICBpZiAoc2hvdWxkRG93bmxvYWQpCisgICAgewor ICAgICAgICByZXF1ZXN0LnNldFNob3VsZERvd25sb2FkKHRydWUpOworICAgICAgICByZXF1ZXN0 LnNldERvd25sb2FkTmFtZSgqZG93bmxvYWROYW1lKTsKKyAgICB9CisgICAgdXJsU2VsZWN0ZWQo RnJhbWVMb2FkUmVxdWVzdChtX2ZyYW1lLT5kb2N1bWVudCgpLT5zZWN1cml0eU9yaWdpbigpLCBy ZXF1ZXN0LCBwYXNzZWRUYXJnZXQpLAogICAgICAgICB0cmlnZ2VyaW5nRXZlbnQsIGxvY2tIaXN0 b3J5LCBsb2NrQmFja0ZvcndhcmRMaXN0LCByZWZlcnJlclBvbGljeSwgRG9Ob3RSZXBsYWNlRG9j dW1lbnRJZkphdmFTY3JpcHRVUkwpOwogfQogCkBAIC0xMTQ3LDcgKzExNTMsNyBAQCB2b2lkIEZy YW1lTG9hZGVyOjpsb2FkRnJhbWVSZXF1ZXN0KGNvbnN0IEZyYW1lTG9hZFJlcXVlc3QmIHJlcXVl c3QsIGJvb2wgbG9ja0hpcwogICAgIGlmIChyZXF1ZXN0LnJlc291cmNlUmVxdWVzdCgpLmh0dHBN ZXRob2QoKSA9PSAiUE9TVCIpCiAgICAgICAgIGxvYWRQb3N0UmVxdWVzdChyZXF1ZXN0LnJlc291 cmNlUmVxdWVzdCgpLCByZWZlcnJlciwgcmVxdWVzdC5mcmFtZU5hbWUoKSwgbG9ja0hpc3Rvcnks IGxvYWRUeXBlLCBldmVudCwgZm9ybVN0YXRlLmdldCgpKTsKICAgICBlbHNlCi0gICAgICAgIGxv YWRVUkwocmVxdWVzdC5yZXNvdXJjZVJlcXVlc3QoKS51cmwoKSwgcmVmZXJyZXIsIHJlcXVlc3Qu ZnJhbWVOYW1lKCksIGxvY2tIaXN0b3J5LCBsb2FkVHlwZSwgZXZlbnQsIGZvcm1TdGF0ZS5nZXQo KSk7CisgICAgICAgIGxvYWRVUkwocmVxdWVzdC5yZXNvdXJjZVJlcXVlc3QoKS51cmwoKSwgcmVm ZXJyZXIsIHJlcXVlc3QuZnJhbWVOYW1lKCksIGxvY2tIaXN0b3J5LCBsb2FkVHlwZSwgZXZlbnQs IGZvcm1TdGF0ZS5nZXQoKSwgJnJlcXVlc3QucmVzb3VyY2VSZXF1ZXN0KCkpOwogCiAgICAgLy8g RklYTUU6IEl0J3MgcG9zc2libGUgdGhpcyB0YXJnZXRGcmFtZSB3aWxsIG5vdCBiZSB0aGUgc2Ft ZSBmcmFtZSB0aGF0IHdhcyB0YXJnZXRlZCBieSB0aGUgYWN0dWFsCiAgICAgLy8gbG9hZCBpZiBm cmFtZSBuYW1lcyBoYXZlIGNoYW5nZWQuCkBAIC0xMTYwLDcgKzExNjYsNyBAQCB2b2lkIEZyYW1l TG9hZGVyOjpsb2FkRnJhbWVSZXF1ZXN0KGNvbnN0IEZyYW1lTG9hZFJlcXVlc3QmIHJlcXVlc3Qs IGJvb2wgbG9ja0hpcwogfQogCiB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJMKGNvbnN0IEtVUkwm IG5ld1VSTCwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgY29uc3QgU3RyaW5nJiBmcmFtZU5hbWUs IGJvb2wgbG9ja0hpc3RvcnksIEZyYW1lTG9hZFR5cGUgbmV3TG9hZFR5cGUsCi0gICAgUGFzc1Jl ZlB0cjxFdmVudD4gZXZlbnQsIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPiBwcnBGb3JtU3RhdGUpCisg ICAgUGFzc1JlZlB0cjxFdmVudD4gZXZlbnQsIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPiBwcnBGb3Jt U3RhdGUsIGNvbnN0IFJlc291cmNlUmVxdWVzdCogc291cmNlUmVxdWVzdCkKIHsKICAgICBpZiAo bV9pblN0b3BBbGxMb2FkZXJzKQogICAgICAgICByZXR1cm47CkBAIC0xMTc4LDYgKzExODQsMTEg QEAgdm9pZCBGcmFtZUxvYWRlcjo6bG9hZFVSTChjb25zdCBLVVJMJiBuZXdVUkwsIGNvbnN0IFN0 cmluZyYgcmVmZXJyZXIsIGNvbnN0IFN0cmkKICAgICBpZiAobmV3TG9hZFR5cGUgPT0gRnJhbWVM b2FkVHlwZVJlbG9hZCB8fCBuZXdMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkRnJvbU9y aWdpbikKICAgICAgICAgcmVxdWVzdC5zZXRDYWNoZVBvbGljeShSZWxvYWRJZ25vcmluZ0NhY2hl RGF0YSk7CiAKKyAgICBpZiAoc291cmNlUmVxdWVzdCAmJiBzb3VyY2VSZXF1ZXN0LT5zaG91bGRE b3dubG9hZCgpKSB7CisgICAgICAgIHJlcXVlc3Quc2V0U2hvdWxkRG93bmxvYWQodHJ1ZSk7Cisg ICAgICAgIHJlcXVlc3Quc2V0RG93bmxvYWROYW1lKHNvdXJjZVJlcXVlc3QtPmRvd25sb2FkTmFt ZSgpKTsKKyAgICB9CisKICAgICBBU1NFUlQobmV3TG9hZFR5cGUgIT0gRnJhbWVMb2FkVHlwZVNh bWUpOwogCiAgICAgLy8gVGhlIHNlYXJjaCBmb3IgYSB0YXJnZXQgZnJhbWUgaXMgZG9uZSBlYXJs aWVyIGluIHRoZSBjYXNlIG9mIGZvcm0gc3VibWlzc2lvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1l TG9hZGVyLmgKaW5kZXggZmRkYWEwOC4uNDI1ZjQ3ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1l TG9hZGVyLmgKQEAgLTEwOCw3ICsxMDgsNyBAQCBwdWJsaWM6CiAgICAgdW5zaWduZWQgbG9uZyBs b2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIFN0b3JlZENy ZWRlbnRpYWxzLCBSZXNvdXJjZUVycm9yJiwgUmVzb3VyY2VSZXNwb25zZSYsIFZlY3RvcjxjaGFy PiYgZGF0YSk7CiAKICAgICB2b2lkIGNoYW5nZUxvY2F0aW9uKFBhc3NSZWZQdHI8U2VjdXJpdHlP cmlnaW4+LCBjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgYm9vbCBsb2NrSGlz dG9yeSA9IHRydWUsIGJvb2wgbG9ja0JhY2tGb3J3YXJkTGlzdCA9IHRydWUsIGJvb2wgcmVmcmVz aCA9IGZhbHNlKTsKLSAgICB2b2lkIHVybFNlbGVjdGVkKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJp bmcmIHRhcmdldCwgUGFzc1JlZlB0cjxFdmVudD4sIGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgbG9j a0JhY2tGb3J3YXJkTGlzdCwgUmVmZXJyZXJQb2xpY3kpOworICAgIHZvaWQgdXJsU2VsZWN0ZWQo Y29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBQYXNzUmVmUHRyPEV2ZW50PiwgYm9v bCBsb2NrSGlzdG9yeSwgYm9vbCBsb2NrQmFja0ZvcndhcmRMaXN0LCBSZWZlcnJlclBvbGljeSwg Ym9vbCBzaG91bGREb3dubG9hZCA9IGZhbHNlLCBjb25zdCBTdHJpbmcqIGRvd25sb2FkTmFtZSA9 IE5VTEwpOwogICAgIHZvaWQgc3VibWl0Rm9ybShQYXNzUmVmUHRyPEZvcm1TdWJtaXNzaW9uPik7 CiAKICAgICB2b2lkIHJlbG9hZChib29sIGVuZFRvRW5kUmVsb2FkID0gZmFsc2UpOwpAQCAtMzQ1 LDcgKzM0NSw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCBsb2FkUG9zdFJlcXVlc3QoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgICAgICAgICAgICAgICAgLy8g Q2FsbGVkIGJ5IGxvYWRGcmFtZVJlcXVlc3QsIGNhbGxzIGxvYWRXaXRoTmF2aWdhdGlvbkFjdGlv bgogICAgICAgICBjb25zdCBTdHJpbmcmIGZyYW1lTmFtZSwgYm9vbCBsb2NrSGlzdG9yeSwgRnJh bWVMb2FkVHlwZSwgUGFzc1JlZlB0cjxFdmVudD4sIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAg ICAgdm9pZCBsb2FkVVJMKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBjb25z dCBTdHJpbmcmIGZyYW1lTmFtZSwgICAgICAgICAgLy8gQ2FsbGVkIGJ5IGxvYWRGcmFtZVJlcXVl c3QsIGNhbGxzIGxvYWRXaXRoTmF2aWdhdGlvbkFjdGlvbiBvciBkaXNwYXRjaGVzIHRvIG5hdmln YXRpb24gcG9saWN5IGRlbGVnYXRlCi0gICAgICAgIGJvb2wgbG9ja0hpc3RvcnksIEZyYW1lTG9h ZFR5cGUsIFBhc3NSZWZQdHI8RXZlbnQ+LCBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICAgICAg ICBib29sIGxvY2tIaXN0b3J5LCBGcmFtZUxvYWRUeXBlLCBQYXNzUmVmUHRyPEV2ZW50PiwgUGFz c1JlZlB0cjxGb3JtU3RhdGU+LCBjb25zdCBSZXNvdXJjZVJlcXVlc3QqIHNvdXJjZVJlcXVlc3Qg PSBOVUxMKTsKIAogICAgIGJvb2wgc2hvdWxkUmVsb2FkKGNvbnN0IEtVUkwmIGN1cnJlbnRVUkws IGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZVJlcXVlc3RCYXNlLmggYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdEJhc2UuaAppbmRleCA0YzdhYmNiLi4x OTAxYTMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291 cmNlUmVxdWVzdEJhc2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jl c291cmNlUmVxdWVzdEJhc2UuaApAQCAtMTUyLDYgKzE1MiwxMiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIFRhcmdldFR5cGUgdGFyZ2V0VHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fdGFy Z2V0VHlwZTsgfQogICAgICAgICB2b2lkIHNldFRhcmdldFR5cGUoVGFyZ2V0VHlwZSB0eXBlKSB7 IG1fdGFyZ2V0VHlwZSA9IHR5cGU7IH0KIAorICAgICAgICBib29sIHNob3VsZERvd25sb2FkKCkg Y29uc3QgeyByZXR1cm4gbV9zaG91bGREb3dubG9hZDsgfQorICAgICAgICB2b2lkIHNldFNob3Vs ZERvd25sb2FkKGJvb2wgc2hvdWxkKSB7IG1fc2hvdWxkRG93bmxvYWQgPSBzaG91bGQ7IH0KKwor ICAgICAgICBTdHJpbmcgZG93bmxvYWROYW1lKCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZE5h bWU7IH0KKyAgICAgICAgdm9pZCBzZXREb3dubG9hZE5hbWUoU3RyaW5nIG5hbWUpIHsgbV9kb3du bG9hZE5hbWUgPSBuYW1lOyB9CisKICAgICAgICAgc3RhdGljIGRvdWJsZSBkZWZhdWx0VGltZW91 dEludGVydmFsKCk7IC8vIE1heSByZXR1cm4gMCB3aGVuIHVzaW5nIHBsYXRmb3JtIGRlZmF1bHQu CiAgICAgICAgIHN0YXRpYyB2b2lkIHNldERlZmF1bHRUaW1lb3V0SW50ZXJ2YWwoZG91YmxlKTsK IApAQCAtMTY3LDYgKzE3Myw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICwg bV9yZXBvcnRSYXdIZWFkZXJzKGZhbHNlKQogICAgICAgICAgICAgLCBtX3ByaW9yaXR5KFJlc291 cmNlTG9hZFByaW9yaXR5TG93KQogICAgICAgICAgICAgLCBtX3RhcmdldFR5cGUoVGFyZ2V0SXNT dWJyZXNvdXJjZSkKKyAgICAgICAgICAgICwgbV9zaG91bGREb3dubG9hZChmYWxzZSkKKyAgICAg ICAgICAgICwgbV9kb3dubG9hZE5hbWUoKQogICAgICAgICB7CiAgICAgICAgIH0KIApAQCAtMTgz LDYgKzE5MSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICwgbV9yZXBvcnRS YXdIZWFkZXJzKGZhbHNlKQogICAgICAgICAgICAgLCBtX3ByaW9yaXR5KFJlc291cmNlTG9hZFBy aW9yaXR5TG93KQogICAgICAgICAgICAgLCBtX3RhcmdldFR5cGUoVGFyZ2V0SXNTdWJyZXNvdXJj ZSkKKyAgICAgICAgICAgICwgbV9zaG91bGREb3dubG9hZChmYWxzZSkKKyAgICAgICAgICAgICwg bV9kb3dubG9hZE5hbWUoKQogICAgICAgICB7CiAgICAgICAgIH0KIApAQCAtMjA5LDYgKzIxOSw4 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgYm9vbCBtX3JlcG9ydFJhd0hlYWRlcnM7 CiAgICAgICAgIFJlc291cmNlTG9hZFByaW9yaXR5IG1fcHJpb3JpdHk7CiAgICAgICAgIFRhcmdl dFR5cGUgbV90YXJnZXRUeXBlOworICAgICAgICBib29sIG1fc2hvdWxkRG93bmxvYWQ7CisgICAg ICAgIFN0cmluZyBtX2Rvd25sb2FkTmFtZTsKIAogICAgIHByaXZhdGU6CiAgICAgICAgIGNvbnN0 IFJlc291cmNlUmVxdWVzdCYgYXNSZXNvdXJjZVJlcXVlc3QoKSBjb25zdDsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCmluZGV4 IDc5ZGRkNjguLjdlMTY0NGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcApAQCAtOTQzLDExICs5NDMsMTMgQEAgdm9pZCBG cmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFj dGlvbigKICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4gZm9ybVN0YXRlKSB7CiAgICAgUG9saWN5 QWN0aW9uIHBvbGljeUFjdGlvbiA9IFBvbGljeUlnbm9yZTsKIAotICAgIC8vIEl0IGlzIHZhbGlk IGZvciB0aGlzIGZ1bmN0aW9uIHRvIGJlIGludm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUK LSAgICAvLyB0aGUgd2VidmlldyBpcyBjbG9zZWQuCi0gICAgLy8gVGhlIG51bGwgY2hlY2sgaGVy ZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKLSAgICAvLyAoc2VlIC0gaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzNTU0KS4KLSAgICBpZiAobV93 ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3QudXJsKCkuaXNOdWxsKCkpIHsKKyAgICBpZiAo cmVxdWVzdC5zaG91bGREb3dubG9hZCgpKSB7CisgICAgICAgIHBvbGljeUFjdGlvbiA9IFBvbGlj eURvd25sb2FkOworICAgIH0gZWxzZSBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVl c3QudXJsKCkuaXNOdWxsKCkpIHsKKyAgICAgICAgLy8gSXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVu Y3Rpb24gdG8gYmUgaW52b2tlZCBpbiBjb2RlIHBhdGhzIHdoZXJlIHRoZQorICAgICAgICAvLyB3 ZWJ2aWV3IGlzIGNsb3NlZC4KKyAgICAgICAgLy8gVGhlIG51bGwgY2hlY2sgaGVyZSBpcyB0byBm aXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKKyAgICAgICAgLy8gKHNlZSAtIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzU1NCkuCiAgICAgICAgIFdlYk5hdmln YXRpb25Qb2xpY3kgbmF2aWdhdGlvblBvbGljeSA9IFdlYk5hdmlnYXRpb25Qb2xpY3lDdXJyZW50 VGFiOwogICAgICAgICBhY3Rpb25TcGVjaWZpZXNOYXZpZ2F0aW9uUG9saWN5KGFjdGlvbiwgJm5h dmlnYXRpb25Qb2xpY3kpOwogCg== 100918 2011-07-14 19:48:24 -0700 2011-07-14 22:58:42 -0700 updated webkit-a-download.patch text/plain 10993 sadrul ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u N2IxM2Q2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTE0NywxMCArMTQ3LDcgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFu ZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoaXNMaW5rQ2xpY2so ZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShldmVudFR5cGUoZXZlbnQpKSkg ewotICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRNTFNw YWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAgICAgIGFwcGVuZFNlcnZlck1h cE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAgICBoYW5kbGVMaW5rQ2xpY2so ZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRhcmdldEF0dHIpLCBoYXNSZWwo UmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5kUGluZ3MoZG9jdW1lbnQoKS0+ Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVDbGljayhldmVudCk7CiAgICAg ICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYgKzQ4OSwyNCBAQCB2b2lkIEhU TUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgS1VSTCYgZGVzdGluYXRpb25VUkwpCiAg ICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5nKGRvY3VtZW50KCktPmZyYW1lKCksIGRvY3VtZW50 KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ldKSwgZGVzdGluYXRpb25VUkwpOwogfQogCit2b2lk IEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVDbGljayhFdmVudCogZXZlbnQpCit7CisgICAgZXZl bnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudCgp LT5mcmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIFN0cmlu ZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZmFzdEdldEF0dHJpYnV0 ZShocmVmQXR0cikpOworICAgIGFwcGVuZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVu dCk7CisKKyAgICBib29sIGRvd25sb2FkID0gaGFzQXR0cmlidXRlKGRvd25sb2FkQXR0cik7Cisg ICAgU3RyaW5nIG5hbWUgPSBkb3dubG9hZCA/IGZhc3RHZXRBdHRyaWJ1dGUoZG93bmxvYWRBdHRy KSA6IEF0b21pY1N0cmluZygpOworICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoZG9j dW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSwgdGFyZ2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2Us IGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlciwg ZG93bmxvYWQsIG5hbWUpOworCisgICAgc2VuZFBpbmdzKGRvY3VtZW50KCktPmNvbXBsZXRlVVJM KHVybCkpOworfQorCiBIVE1MQW5jaG9yRWxlbWVudDo6RXZlbnRUeXBlIEhUTUxBbmNob3JFbGVt ZW50OjpldmVudFR5cGUoRXZlbnQqIGV2ZW50KQogewogICAgIGlmICghZXZlbnQtPmlzTW91c2VF dmVudCgpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCmluZGV4IDYwN2Qx ZjUuLmE5YmI1YjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKQEAg LTExNSw2ICsxMTUsOCBAQCBwcml2YXRlOgogCiAgICAgdm9pZCBzZW5kUGluZ3MoY29uc3QgS1VS TCYgZGVzdGluYXRpb25VUkwpOwogCisgICAgdm9pZCBoYW5kbGVDbGljayhFdmVudCogZXZlbnQp OworCiAgICAgZW51bSBFdmVudFR5cGUgewogICAgICAgICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0 S2V5LAogICAgICAgICBNb3VzZUV2ZW50V2l0aFNoaWZ0S2V5LApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxBbmNob3JFbGVtZW50LmlkbAppbmRleCA4NzFmY2RmLi4xZTljMTFkIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbApAQCAtMjYsNiArMjYsNyBAQCBtb2R1 bGUgaHRtbCB7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGFjY2Vzc0tl eTsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgY2hhcnNldDsKICAgICAg ICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgY29vcmRzOworICAgICAgICBhdHRyaWJ1 dGUgW1JlZmxlY3RdIERPTVN0cmluZyBkb3dubG9hZDsKICAgICAgICAgYXR0cmlidXRlIFtSZWZs ZWN0LCBVUkxdIERPTVN0cmluZyBocmVmOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERP TVN0cmluZyBocmVmbGFuZzsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcg bmFtZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVz LmluIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KaW5kZXggMTY3 OWU5Ni4uODQxMGRlNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmli dXRlTmFtZXMuaW4KKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMu aW4KQEAgLTkxLDYgKzkxLDcgQEAgZGVmZXIKIGRpcgogZGlyZWN0aW9uCiBkaXNhYmxlZAorZG93 bmxvYWQKIGRyYWdnYWJsZQogd2Via2l0ZHJvcHpvbmUKIGVuY3R5cGUKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvRnJhbWVMb2FkZXIuY3BwCmluZGV4IDM1NDVhMTYuLjBmZWQzYjUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv bG9hZGVyL0ZyYW1lTG9hZGVyLmNwcApAQCAtMjYxLDkgKzI2MSwxNSBAQCB2b2lkIEZyYW1lTG9h ZGVyOjpjaGFuZ2VMb2NhdGlvbihQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBzZWN1cml0eU9y aWdpbiwgY29ucwogICAgICAgICAwLCBsb2NrSGlzdG9yeSwgbG9ja0JhY2tGb3J3YXJkTGlzdCwg U2VuZFJlZmVycmVyLCBSZXBsYWNlRG9jdW1lbnRJZkphdmFTY3JpcHRVUkwpOwogfQogCi12b2lk IEZyYW1lTG9hZGVyOjp1cmxTZWxlY3RlZChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYg cGFzc2VkVGFyZ2V0LCBQYXNzUmVmUHRyPEV2ZW50PiB0cmlnZ2VyaW5nRXZlbnQsIGJvb2wgbG9j a0hpc3RvcnksIGJvb2wgbG9ja0JhY2tGb3J3YXJkTGlzdCwgUmVmZXJyZXJQb2xpY3kgcmVmZXJy ZXJQb2xpY3kpCit2b2lkIEZyYW1lTG9hZGVyOjp1cmxTZWxlY3RlZChjb25zdCBLVVJMJiB1cmws IGNvbnN0IFN0cmluZyYgcGFzc2VkVGFyZ2V0LCBQYXNzUmVmUHRyPEV2ZW50PiB0cmlnZ2VyaW5n RXZlbnQsIGJvb2wgbG9ja0hpc3RvcnksIGJvb2wgbG9ja0JhY2tGb3J3YXJkTGlzdCwgUmVmZXJy ZXJQb2xpY3kgcmVmZXJyZXJQb2xpY3ksIGJvb2wgc2hvdWxkRG93bmxvYWQsIGNvbnN0IFN0cmlu ZyYgZG93bmxvYWROYW1lKQogewotICAgIHVybFNlbGVjdGVkKEZyYW1lTG9hZFJlcXVlc3QobV9m cmFtZS0+ZG9jdW1lbnQoKS0+c2VjdXJpdHlPcmlnaW4oKSwgUmVzb3VyY2VSZXF1ZXN0KHVybCks IHBhc3NlZFRhcmdldCksCisgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3QodXJsKTsKKyAgICBp ZiAoc2hvdWxkRG93bmxvYWQpCisgICAgeworICAgICAgICByZXF1ZXN0LnNldFNob3VsZERvd25s b2FkKHRydWUpOworICAgICAgICByZXF1ZXN0LnNldERvd25sb2FkTmFtZShkb3dubG9hZE5hbWUp OworICAgIH0KKyAgICB1cmxTZWxlY3RlZChGcmFtZUxvYWRSZXF1ZXN0KG1fZnJhbWUtPmRvY3Vt ZW50KCktPnNlY3VyaXR5T3JpZ2luKCksIHJlcXVlc3QsIHBhc3NlZFRhcmdldCksCiAgICAgICAg IHRyaWdnZXJpbmdFdmVudCwgbG9ja0hpc3RvcnksIGxvY2tCYWNrRm9yd2FyZExpc3QsIHJlZmVy cmVyUG9saWN5LCBEb05vdFJlcGxhY2VEb2N1bWVudElmSmF2YVNjcmlwdFVSTCk7CiB9CiAKQEAg LTExNDcsNyArMTE1Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWRGcmFtZVJlcXVlc3QoY29u c3QgRnJhbWVMb2FkUmVxdWVzdCYgcmVxdWVzdCwgYm9vbCBsb2NrSGlzCiAgICAgaWYgKHJlcXVl c3QucmVzb3VyY2VSZXF1ZXN0KCkuaHR0cE1ldGhvZCgpID09ICJQT1NUIikKICAgICAgICAgbG9h ZFBvc3RSZXF1ZXN0KHJlcXVlc3QucmVzb3VyY2VSZXF1ZXN0KCksIHJlZmVycmVyLCByZXF1ZXN0 LmZyYW1lTmFtZSgpLCBsb2NrSGlzdG9yeSwgbG9hZFR5cGUsIGV2ZW50LCBmb3JtU3RhdGUuZ2V0 KCkpOwogICAgIGVsc2UKLSAgICAgICAgbG9hZFVSTChyZXF1ZXN0LnJlc291cmNlUmVxdWVzdCgp LnVybCgpLCByZWZlcnJlciwgcmVxdWVzdC5mcmFtZU5hbWUoKSwgbG9ja0hpc3RvcnksIGxvYWRU eXBlLCBldmVudCwgZm9ybVN0YXRlLmdldCgpKTsKKyAgICAgICAgbG9hZFVSTChyZXF1ZXN0LnJl c291cmNlUmVxdWVzdCgpLnVybCgpLCByZWZlcnJlciwgcmVxdWVzdC5mcmFtZU5hbWUoKSwgbG9j a0hpc3RvcnksIGxvYWRUeXBlLCBldmVudCwgZm9ybVN0YXRlLmdldCgpLCAmcmVxdWVzdC5yZXNv dXJjZVJlcXVlc3QoKSk7CiAKICAgICAvLyBGSVhNRTogSXQncyBwb3NzaWJsZSB0aGlzIHRhcmdl dEZyYW1lIHdpbGwgbm90IGJlIHRoZSBzYW1lIGZyYW1lIHRoYXQgd2FzIHRhcmdldGVkIGJ5IHRo ZSBhY3R1YWwKICAgICAvLyBsb2FkIGlmIGZyYW1lIG5hbWVzIGhhdmUgY2hhbmdlZC4KQEAgLTEx NjAsNyArMTE2Niw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWRGcmFtZVJlcXVlc3QoY29uc3Qg RnJhbWVMb2FkUmVxdWVzdCYgcmVxdWVzdCwgYm9vbCBsb2NrSGlzCiB9CiAKIHZvaWQgRnJhbWVM b2FkZXI6OmxvYWRVUkwoY29uc3QgS1VSTCYgbmV3VVJMLCBjb25zdCBTdHJpbmcmIHJlZmVycmVy LCBjb25zdCBTdHJpbmcmIGZyYW1lTmFtZSwgYm9vbCBsb2NrSGlzdG9yeSwgRnJhbWVMb2FkVHlw ZSBuZXdMb2FkVHlwZSwKLSAgICBQYXNzUmVmUHRyPEV2ZW50PiBldmVudCwgUGFzc1JlZlB0cjxG b3JtU3RhdGU+IHBycEZvcm1TdGF0ZSkKKyAgICBQYXNzUmVmUHRyPEV2ZW50PiBldmVudCwgUGFz c1JlZlB0cjxGb3JtU3RhdGU+IHBycEZvcm1TdGF0ZSwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0KiBz b3VyY2VSZXF1ZXN0KQogewogICAgIGlmIChtX2luU3RvcEFsbExvYWRlcnMpCiAgICAgICAgIHJl dHVybjsKQEAgLTExNzgsNiArMTE4NCwxMSBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJMKGNv bnN0IEtVUkwmIG5ld1VSTCwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgY29uc3QgU3RyaQogICAg IGlmIChuZXdMb2FkVHlwZSA9PSBGcmFtZUxvYWRUeXBlUmVsb2FkIHx8IG5ld0xvYWRUeXBlID09 IEZyYW1lTG9hZFR5cGVSZWxvYWRGcm9tT3JpZ2luKQogICAgICAgICByZXF1ZXN0LnNldENhY2hl UG9saWN5KFJlbG9hZElnbm9yaW5nQ2FjaGVEYXRhKTsKIAorICAgIGlmIChzb3VyY2VSZXF1ZXN0 ICYmIHNvdXJjZVJlcXVlc3QtPnNob3VsZERvd25sb2FkKCkpIHsKKyAgICAgICAgcmVxdWVzdC5z ZXRTaG91bGREb3dubG9hZCh0cnVlKTsKKyAgICAgICAgcmVxdWVzdC5zZXREb3dubG9hZE5hbWUo c291cmNlUmVxdWVzdC0+ZG93bmxvYWROYW1lKCkpOworICAgIH0KKwogICAgIEFTU0VSVChuZXdM b2FkVHlwZSAhPSBGcmFtZUxvYWRUeXBlU2FtZSk7CiAKICAgICAvLyBUaGUgc2VhcmNoIGZvciBh IHRhcmdldCBmcmFtZSBpcyBkb25lIGVhcmxpZXIgaW4gdGhlIGNhc2Ugb2YgZm9ybSBzdWJtaXNz aW9uLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmggYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuaAppbmRleCBmZGRhYTA4Li44MTY2ODcz IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuaApAQCAtMTA4LDcgKzEwOCw3IEBAIHB1 YmxpYzoKICAgICB1bnNpZ25lZCBsb25nIGxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiwgU3RvcmVkQ3JlZGVudGlhbHMsIFJlc291cmNlRXJyb3ImLCBSZXNv dXJjZVJlc3BvbnNlJiwgVmVjdG9yPGNoYXI+JiBkYXRhKTsKIAogICAgIHZvaWQgY2hhbmdlTG9j YXRpb24oUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4sIGNvbnN0IEtVUkwmLCBjb25zdCBTdHJp bmcmIHJlZmVycmVyLCBib29sIGxvY2tIaXN0b3J5ID0gdHJ1ZSwgYm9vbCBsb2NrQmFja0Zvcndh cmRMaXN0ID0gdHJ1ZSwgYm9vbCByZWZyZXNoID0gZmFsc2UpOwotICAgIHZvaWQgdXJsU2VsZWN0 ZWQoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0LCBQYXNzUmVmUHRyPEV2ZW50Piwg Ym9vbCBsb2NrSGlzdG9yeSwgYm9vbCBsb2NrQmFja0ZvcndhcmRMaXN0LCBSZWZlcnJlclBvbGlj eSk7CisgICAgdm9pZCB1cmxTZWxlY3RlZChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiB0YXJn ZXQsIFBhc3NSZWZQdHI8RXZlbnQ+LCBib29sIGxvY2tIaXN0b3J5LCBib29sIGxvY2tCYWNrRm9y d2FyZExpc3QsIFJlZmVycmVyUG9saWN5LCBib29sIHNob3VsZERvd25sb2FkID0gZmFsc2UsIGNv bnN0IFN0cmluZyYgZG93bmxvYWROYW1lID0gU3RyaW5nKCkpOwogICAgIHZvaWQgc3VibWl0Rm9y bShQYXNzUmVmUHRyPEZvcm1TdWJtaXNzaW9uPik7CiAKICAgICB2b2lkIHJlbG9hZChib29sIGVu ZFRvRW5kUmVsb2FkID0gZmFsc2UpOwpAQCAtMzQ1LDcgKzM0NSw3IEBAIHByaXZhdGU6CiAgICAg dm9pZCBsb2FkUG9zdFJlcXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5n JiByZWZlcnJlciwgICAgICAgICAgICAgICAgLy8gQ2FsbGVkIGJ5IGxvYWRGcmFtZVJlcXVlc3Qs IGNhbGxzIGxvYWRXaXRoTmF2aWdhdGlvbkFjdGlvbgogICAgICAgICBjb25zdCBTdHJpbmcmIGZy YW1lTmFtZSwgYm9vbCBsb2NrSGlzdG9yeSwgRnJhbWVMb2FkVHlwZSwgUGFzc1JlZlB0cjxFdmVu dD4sIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAgICAgdm9pZCBsb2FkVVJMKGNvbnN0IEtVUkwm LCBjb25zdCBTdHJpbmcmIHJlZmVycmVyLCBjb25zdCBTdHJpbmcmIGZyYW1lTmFtZSwgICAgICAg ICAgLy8gQ2FsbGVkIGJ5IGxvYWRGcmFtZVJlcXVlc3QsIGNhbGxzIGxvYWRXaXRoTmF2aWdhdGlv bkFjdGlvbiBvciBkaXNwYXRjaGVzIHRvIG5hdmlnYXRpb24gcG9saWN5IGRlbGVnYXRlCi0gICAg ICAgIGJvb2wgbG9ja0hpc3RvcnksIEZyYW1lTG9hZFR5cGUsIFBhc3NSZWZQdHI8RXZlbnQ+LCBQ YXNzUmVmUHRyPEZvcm1TdGF0ZT4pOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIAorICAgICAgICBib29sIGxvY2tIaXN0b3J5LCBGcmFtZUxv YWRUeXBlLCBQYXNzUmVmUHRyPEV2ZW50PiwgUGFzc1JlZlB0cjxGb3JtU3RhdGU+LCBjb25zdCBS ZXNvdXJjZVJlcXVlc3QqIHNvdXJjZVJlcXVlc3QgPSBOVUxMKTsKIAogICAgIGJvb2wgc2hvdWxk UmVsb2FkKGNvbnN0IEtVUkwmIGN1cnJlbnRVUkwsIGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJM KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZVJlcXVlc3RCYXNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl UmVxdWVzdEJhc2UuaAppbmRleCA0YzdhYmNiLi4xOTAxYTMzIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdEJhc2UuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlUmVxdWVzdEJhc2UuaApAQCAtMTUy LDYgKzE1MiwxMiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFRhcmdldFR5cGUgdGFy Z2V0VHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fdGFyZ2V0VHlwZTsgfQogICAgICAgICB2b2lkIHNl dFRhcmdldFR5cGUoVGFyZ2V0VHlwZSB0eXBlKSB7IG1fdGFyZ2V0VHlwZSA9IHR5cGU7IH0KIAor ICAgICAgICBib29sIHNob3VsZERvd25sb2FkKCkgY29uc3QgeyByZXR1cm4gbV9zaG91bGREb3du bG9hZDsgfQorICAgICAgICB2b2lkIHNldFNob3VsZERvd25sb2FkKGJvb2wgc2hvdWxkKSB7IG1f c2hvdWxkRG93bmxvYWQgPSBzaG91bGQ7IH0KKworICAgICAgICBTdHJpbmcgZG93bmxvYWROYW1l KCkgY29uc3QgeyByZXR1cm4gbV9kb3dubG9hZE5hbWU7IH0KKyAgICAgICAgdm9pZCBzZXREb3du bG9hZE5hbWUoU3RyaW5nIG5hbWUpIHsgbV9kb3dubG9hZE5hbWUgPSBuYW1lOyB9CisKICAgICAg ICAgc3RhdGljIGRvdWJsZSBkZWZhdWx0VGltZW91dEludGVydmFsKCk7IC8vIE1heSByZXR1cm4g MCB3aGVuIHVzaW5nIHBsYXRmb3JtIGRlZmF1bHQuCiAgICAgICAgIHN0YXRpYyB2b2lkIHNldERl ZmF1bHRUaW1lb3V0SW50ZXJ2YWwoZG91YmxlKTsKIApAQCAtMTY3LDYgKzE3Myw4IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICwgbV9yZXBvcnRSYXdIZWFkZXJzKGZhbHNlKQog ICAgICAgICAgICAgLCBtX3ByaW9yaXR5KFJlc291cmNlTG9hZFByaW9yaXR5TG93KQogICAgICAg ICAgICAgLCBtX3RhcmdldFR5cGUoVGFyZ2V0SXNTdWJyZXNvdXJjZSkKKyAgICAgICAgICAgICwg bV9zaG91bGREb3dubG9hZChmYWxzZSkKKyAgICAgICAgICAgICwgbV9kb3dubG9hZE5hbWUoKQog ICAgICAgICB7CiAgICAgICAgIH0KIApAQCAtMTgzLDYgKzE5MSw4IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKICAgICAgICAgICAgICwgbV9yZXBvcnRSYXdIZWFkZXJzKGZhbHNlKQogICAgICAgICAg ICAgLCBtX3ByaW9yaXR5KFJlc291cmNlTG9hZFByaW9yaXR5TG93KQogICAgICAgICAgICAgLCBt X3RhcmdldFR5cGUoVGFyZ2V0SXNTdWJyZXNvdXJjZSkKKyAgICAgICAgICAgICwgbV9zaG91bGRE b3dubG9hZChmYWxzZSkKKyAgICAgICAgICAgICwgbV9kb3dubG9hZE5hbWUoKQogICAgICAgICB7 CiAgICAgICAgIH0KIApAQCAtMjA5LDYgKzIxOSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgYm9vbCBtX3JlcG9ydFJhd0hlYWRlcnM7CiAgICAgICAgIFJlc291cmNlTG9hZFByaW9y aXR5IG1fcHJpb3JpdHk7CiAgICAgICAgIFRhcmdldFR5cGUgbV90YXJnZXRUeXBlOworICAgICAg ICBib29sIG1fc2hvdWxkRG93bmxvYWQ7CisgICAgICAgIFN0cmluZyBtX2Rvd25sb2FkTmFtZTsK IAogICAgIHByaXZhdGU6CiAgICAgICAgIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgYXNSZXNvdXJj ZVJlcXVlc3QoKSBjb25zdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9G cmFtZUxvYWRlckNsaWVudEltcGwuY3BwCmluZGV4IDc5ZGRkNjguLjdlMTY0NGYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNw cApAQCAtOTQzLDExICs5NDMsMTMgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3Bh dGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbigKICAgICBQYXNzUmVmUHRyPEZvcm1T dGF0ZT4gZm9ybVN0YXRlKSB7CiAgICAgUG9saWN5QWN0aW9uIHBvbGljeUFjdGlvbiA9IFBvbGlj eUlnbm9yZTsKIAotICAgIC8vIEl0IGlzIHZhbGlkIGZvciB0aGlzIGZ1bmN0aW9uIHRvIGJlIGlu dm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUKLSAgICAvLyB0aGUgd2VidmlldyBpcyBjbG9z ZWQuCi0gICAgLy8gVGhlIG51bGwgY2hlY2sgaGVyZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNl ZW1zIHN0cmFuZ2UKLSAgICAvLyAoc2VlIC0gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIzNTU0KS4KLSAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVl c3QudXJsKCkuaXNOdWxsKCkpIHsKKyAgICBpZiAocmVxdWVzdC5zaG91bGREb3dubG9hZCgpKSB7 CisgICAgICAgIHBvbGljeUFjdGlvbiA9IFBvbGljeURvd25sb2FkOworICAgIH0gZWxzZSBpZiAo bV93ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3QudXJsKCkuaXNOdWxsKCkpIHsKKyAgICAg ICAgLy8gSXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVuY3Rpb24gdG8gYmUgaW52b2tlZCBpbiBjb2Rl IHBhdGhzIHdoZXJlIHRoZQorICAgICAgICAvLyB3ZWJ2aWV3IGlzIGNsb3NlZC4KKyAgICAgICAg Ly8gVGhlIG51bGwgY2hlY2sgaGVyZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFu Z2UKKyAgICAgICAgLy8gKHNlZSAtIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMzU1NCkuCiAgICAgICAgIFdlYk5hdmlnYXRpb25Qb2xpY3kgbmF2aWdhdGlvblBvbGlj eSA9IFdlYk5hdmlnYXRpb25Qb2xpY3lDdXJyZW50VGFiOwogICAgICAgICBhY3Rpb25TcGVjaWZp ZXNOYXZpZ2F0aW9uUG9saWN5KGFjdGlvbiwgJm5hdmlnYXRpb25Qb2xpY3kpOwogCg== 100933 2011-07-14 22:58:42 -0700 2011-07-15 19:03:44 -0700 directly call startDownload webkit-a-download.patch text/plain 17906 sadrul ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u OGQyZmMxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJBdHRyaWJ1dGUuaCIKICNpbmNsdWRlICJFdmVudE5h bWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCkBAIC0xNDcsMTAgKzE0OCw3IEBAIHZvaWQg SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAg ICAgICB9CiAKICAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSAmJiB0cmVhdExpbmtBc0xp dmVGb3JFdmVudFR5cGUoZXZlbnRUeXBlKGV2ZW50KSkpIHsKLSAgICAgICAgICAgIFN0cmluZyB1 cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZ2V0QXR0cmlidXRlKGhyZWZB dHRyKSk7Ci0gICAgICAgICAgICBhcHBlbmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZl bnQpOwotICAgICAgICAgICAgaGFuZGxlTGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmws IGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpOwot ICAgICAgICAgICAgc2VuZFBpbmdzKGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCkpOworICAg ICAgICAgICAgaGFuZGxlQ2xpY2soZXZlbnQpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAg ICB9CiAKQEAgLTQ5Miw2ICs0OTAsMzAgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2VuZFBp bmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKQogICAgICAgICBQaW5nTG9hZGVyOjpzZW5k UGluZyhkb2N1bWVudCgpLT5mcmFtZSgpLCBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwaW5nVVJM c1tpXSksIGRlc3RpbmF0aW9uVVJMKTsKIH0KIAordm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6aGFu ZGxlQ2xpY2soRXZlbnQqIGV2ZW50KQoreworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgp OworCisgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQoKS0+ZnJhbWUoKTsKKyAgICBpZiAoIWZy YW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBTdHJpbmcgdXJsID0gc3RyaXBMZWFkaW5nQW5k VHJhaWxpbmdIVE1MU3BhY2VzKGZhc3RHZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKKyAgICBhcHBl bmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworCisgICAgYm9vbCBkb3dubG9h ZCA9IGhhc0F0dHJpYnV0ZShkb3dubG9hZEF0dHIpOworICAgIGlmIChkb3dubG9hZCkKKyAgICB7 CisgICAgICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KGRvY3VtZW50KCktPmNvbXBsZXRlVVJM KHVybCkpOworICAgICAgICBmcmFtZS0+bG9hZGVyKCktPnByZXBhcmVSZXNvdXJjZVJlcXVlc3Qo cmVxdWVzdCwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikgPyBOb1JlZmVycmVyIDogU2VuZFJl ZmVycmVyKTsKKyAgICAgICAgZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+c3RhcnREb3dubG9h ZChyZXF1ZXN0LCBmYXN0R2V0QXR0cmlidXRlKGRvd25sb2FkQXR0cikpOworICAgIH0KKyAgICBl bHNlCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoZG9jdW1lbnQoKS0+Y29t cGxldGVVUkwodXJsKSwgdGFyZ2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIGhhc1JlbChSZWxh dGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7CisKKyAgICBzZW5k UGluZ3MoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSk7Cit9CisKIEhUTUxBbmNob3JFbGVt ZW50OjpFdmVudFR5cGUgSFRNTEFuY2hvckVsZW1lbnQ6OmV2ZW50VHlwZShFdmVudCogZXZlbnQp CiB7CiAgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxBbmNob3JFbGVtZW50LmgKaW5kZXggNjA3ZDFmNS4uNjI3ZmJiNiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaApAQCAtMTE1LDYgKzExNSw4IEBAIHByaXZhdGU6CiAK ICAgICB2b2lkIHNlbmRQaW5ncyhjb25zdCBLVVJMJiBkZXN0aW5hdGlvblVSTCk7CiAKKyAgICB2 b2lkIGhhbmRsZUNsaWNrKEV2ZW50KiApOworCiAgICAgZW51bSBFdmVudFR5cGUgewogICAgICAg ICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5LAogICAgICAgICBNb3VzZUV2ZW50V2l0aFNoaWZ0 S2V5LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5p ZGwgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbAppbmRleCA4NzFm Y2RmLi4xZTljMTFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JF bGVtZW50LmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50Lmlk bApAQCAtMjYsNiArMjYsNyBAQCBtb2R1bGUgaHRtbCB7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVm bGVjdF0gRE9NU3RyaW5nIGFjY2Vzc0tleTsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBE T01TdHJpbmcgY2hhcnNldDsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcg Y29vcmRzOworICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBkb3dubG9hZDsK ICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0LCBVUkxdIERPTVN0cmluZyBocmVmOwogICAgICAg ICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBocmVmbGFuZzsKICAgICAgICAgYXR0cmli dXRlIFtSZWZsZWN0XSBET01TdHJpbmcgbmFtZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0 cmlidXRlTmFtZXMuaW4KaW5kZXggMTY3OWU5Ni4uODQxMGRlNiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KQEAgLTkxLDYgKzkxLDcgQEAgZGVmZXIKIGRpcgog ZGlyZWN0aW9uCiBkaXNhYmxlZAorZG93bmxvYWQKIGRyYWdnYWJsZQogd2Via2l0ZHJvcHpvbmUK IGVuY3R5cGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMu aCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAppbmRleCBmMWZhZTkyLi43 ZDQwMWM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgK KysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCkBAIC0zMDksNyArMzA5 LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVh ZHkoYm9vbCkgeyB9CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpIHsgfQogCiAgICAgdmly dHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsgfQogICAgIHZpcnR1 YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsgfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xv YWRlci9GcmFtZUxvYWRlci5jcHAKaW5kZXggMzU0NWExNi4uYjIyMGUzMSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCkBAIC0xMjI4LDYgKzEyMjgsMTkgQEAgdm9pZCBGcmFt ZUxvYWRlcjo6bG9hZFVSTChjb25zdCBLVVJMJiBuZXdVUkwsIGNvbnN0IFN0cmluZyYgcmVmZXJy ZXIsIGNvbnN0IFN0cmkKICAgICB9CiB9CiAKK3ZvaWQgRnJhbWVMb2FkZXI6OnByZXBhcmVSZXNv dXJjZVJlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBSZWZlcnJlclBvbGljeSByZWZl cnJlclBvbGljeSkKK3sKKyAgICBTdHJpbmcgcmVmZXJyZXIgPSByZXF1ZXN0Lmh0dHBSZWZlcnJl cigpOworICAgIGlmIChyZWZlcnJlci5pc0VtcHR5KCkpCisgICAgICAgIHJlZmVycmVyID0gbV9v dXRnb2luZ1JlZmVycmVyOworICAgIGlmIChTZWN1cml0eU9yaWdpbjo6c2hvdWxkSGlkZVJlZmVy cmVyKHJlcXVlc3QudXJsKCksIHJlZmVycmVyKSB8fCByZWZlcnJlclBvbGljeSA9PSBOb1JlZmVy cmVyKQorICAgICAgICByZWZlcnJlciA9IFN0cmluZygpOworCisgICAgcmVxdWVzdC5zZXRIVFRQ UmVmZXJyZXIocmVmZXJyZXIpOworCisgICAgYWRkRXh0cmFGaWVsZHNUb01haW5SZXNvdXJjZVJl cXVlc3QocmVxdWVzdCk7Cit9CisKIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0LCBib29sIGxvY2tIaXN0b3J5KQogewogICAgIGxvYWQocmVxdWVz dCwgU3Vic3RpdHV0ZURhdGEoKSwgbG9ja0hpc3RvcnkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXIuaAppbmRleCBmZGRhYTA4Li4wNmZiZDFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRnJhbWVMb2FkZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXIuaApAQCAtMjcyLDYgKzI3Miw4IEBAIHB1YmxpYzoKICAgICAKICAgICB2b2lkIHN0YXJ0 ZWQoKTsKIAorICAgIHZvaWQgcHJlcGFyZVJlc291cmNlUmVxdWVzdChSZXNvdXJjZVJlcXVlc3Qm LCBSZWZlcnJlclBvbGljeSk7CisKICAgICBlbnVtIFBhZ2VEaXNtaXNzYWxUeXBlIHsKICAgICAg ICAgTm9EaXNtaXNzYWwgPSAwLAogICAgICAgICBCZWZvcmVVbmxvYWREaXNtaXNzYWwgPSAxLApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmggYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAppbmRleCAzODUyMzgzLi5h YTBmMmYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGll bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaApAQCAt MTc5LDcgKzE3OSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAgICAgICAgIHZp cnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpID0gMDsKIAotICAgICAg ICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKSA9IDA7 CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkgPSAwOwogCiAgICAgICAgIHZpcnR1YWwgdm9p ZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CiAgICAgICAgIHZpcnR1YWwg dm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCmluZGV4IDc5 ZGRkNjguLmE4MDA4MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0Zy YW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv RnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcApAQCAtOTQzLDExICs5NDMsMTEgQEAgdm9pZCBGcmFt ZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlv bigKICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4gZm9ybVN0YXRlKSB7CiAgICAgUG9saWN5QWN0 aW9uIHBvbGljeUFjdGlvbiA9IFBvbGljeUlnbm9yZTsKIAotICAgIC8vIEl0IGlzIHZhbGlkIGZv ciB0aGlzIGZ1bmN0aW9uIHRvIGJlIGludm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUKLSAg ICAvLyB0aGUgd2VidmlldyBpcyBjbG9zZWQuCi0gICAgLy8gVGhlIG51bGwgY2hlY2sgaGVyZSBp cyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKLSAgICAvLyAoc2VlIC0gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzNTU0KS4KICAgICBpZiAobV93ZWJG cmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3QudXJsKCkuaXNOdWxsKCkpIHsKKyAgICAgICAgLy8g SXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVuY3Rpb24gdG8gYmUgaW52b2tlZCBpbiBjb2RlIHBhdGhz IHdoZXJlIHRoZQorICAgICAgICAvLyB3ZWJ2aWV3IGlzIGNsb3NlZC4KKyAgICAgICAgLy8gVGhl IG51bGwgY2hlY2sgaGVyZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKKyAg ICAgICAgLy8gKHNlZSAtIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y MzU1NCkuCiAgICAgICAgIFdlYk5hdmlnYXRpb25Qb2xpY3kgbmF2aWdhdGlvblBvbGljeSA9IFdl Yk5hdmlnYXRpb25Qb2xpY3lDdXJyZW50VGFiOwogICAgICAgICBhY3Rpb25TcGVjaWZpZXNOYXZp Z2F0aW9uUG9saWN5KGFjdGlvbiwgJm5hdmlnYXRpb25Qb2xpY3kpOwogCkBAIC0xMDczLDcgKzEw NzMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c2V0TWFpbkZyYW1lRG9jdW1lbnRS ZWFkeShib29sIHJlYWR5KQogCiAvLyBDcmVhdGVzIGEgbmV3IGNvbm5lY3Rpb24gYW5kIGJlZ2lu cyBkb3dubG9hZGluZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMKIC8vIHdpdGggfGRvd25sb2Fk fCkuCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3Ry aW5nKQogewogICAgIGlmIChtX3dlYkZyYW1lLT5jbGllbnQoKSkgewogICAgICAgICBXcmFwcGVk UmVzb3VyY2VSZXF1ZXN0IHdlYnJlcShyZXF1ZXN0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKaW5kZXggYWRhZjlkMy4uZjFmMDI0 ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGll bnRJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGll bnRJbXBsLmgKQEAgLTEzMSw3ICsxMzEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHBv c3RQcm9ncmVzc0VzdGltYXRlQ2hhbmdlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9p ZCBwb3N0UHJvZ3Jlc3NGaW5pc2hlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9pZCBz ZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwotICAgIHZpcnR1YWwgdm9pZCBzdGFydERv d25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0 cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJD b3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShX ZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBjb21taXR0ZWRMb2Fk KFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5j cHAgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVm bC5jcHAKaW5kZXggOWUyNzU3Zi4uOWEyZGZjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9l ZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcApAQCAtODcx LDcgKzg3MSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRFZmw6OnNldE1haW5Eb2N1bWVudEVy cm9yKERvY3VtZW50TG9hZGVyKiBsb2FkZXIsIGNvbnN0IFJlCiAgICAgbV9oYXNTZW50UmVzcG9u c2VUb1BsdWdpbiA9IGZhbHNlOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZsOjpzdGFy dERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2Fk ZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0 LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgaWYgKCFtX3ZpZXcpCiAgICAg ICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmggYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCmluZGV4IDQ3YWIzZDQuLjllNmQxY2MgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZs LmgKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRFZmwuaApAQCAtMTUzLDcgKzE1Myw3IEBAIGNsYXNzIEZyYW1lTG9hZGVyQ2xpZW50RWZsIDog cHVibGljIEZyYW1lTG9hZGVyQ2xpZW50IHsKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJh bWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAg IHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0 dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBi L1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cAppbmRleCAzMTY0MjVjLi41ZTZjZmExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2d0ay9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIvU291cmNlL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC0xMzI2LDcg KzEzMjYsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRG9jdW1lbnRFcnJvcihX ZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlcwogICAgIH0KIH0KIAotdm9pZCBGcmFt ZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVl c3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIEdS ZWZQdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+IG5ldHdvcmtSZXF1ZXN0KGFkb3B0R1JlZihraXRO ZXcocmVxdWVzdCkpKTsKICAgICBXZWJLaXRXZWJWaWV3KiB2aWV3ID0gZ2V0Vmlld0Zyb21GcmFt ZShtX2ZyYW1lKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmggYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCmluZGV4IDI0NDgyOWYuLjdjNTgzMjAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3Rr LmgKKysrIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuaApAQCAtMTMwLDcgKzEzMCw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgICAg IHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgICAg IHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgICAgIHZp cnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAg ICAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVy Kik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50SGFpa3UuY3BwIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcAppbmRleCAyODVhM2ZhLi4wYzQ2OGFmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50SGFpa3UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKQEAgLTcwOSw3ICs3MDksNyBAQCB2b2lkIEZyYW1lTG9h ZGVyQ2xpZW50SGFpa3U6OmRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVz b3VyY2VFcnJvcgogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJD bGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQordm9pZCBG cmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgp OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEhhaWt1LmggYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAppbmRleCA3OWVlOTE0Li45ZTg3MDkyIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 SGFpa3UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50SGFpa3UuaApAQCAtMjE5LDcgKzIxOSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0 Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yJik7CiAKLSAgICAg ICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7Cisg ICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYs IGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hv dWxkIHByb2JhYmx5IG5vdCBiZSBoZXJlLCBidXQgaXQncyBuZWVkZWQgZm9yIHRoZSB0ZXN0cyBj dXJyZW50bHkuCiAgICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRRdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50UXQuY3BwCmluZGV4IDhlYzdmNjAuLjE3ODZmYTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKKysrIGIvU291cmNl L1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcApAQCAtMTI5 Myw3ICsxMjkzLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaFVuYWJsZVRv SW1wbGVtZW50UG9saWN5KGNvbnN0IFdlYkNvcmU6OlJlc291cmMKICAgICBub3RJbXBsZW1lbnRl ZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3Qg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVu dFF0OjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVz dCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmICghbV93ZWJGcmFtZSkK ICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmggYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAppbmRleCAxMjEzMDNkLi45MThmYjIwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQu aAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuaApAQCAtMTQ5LDcgKzE0OSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRN YWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93 bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lk IHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3Ry aW5nJiA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9j dW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRM b2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcCBiL1Nv dXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcAppbmRleCBiOGJiMjQ5Li5mZDU5MGYwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYktp dC93aW4vV2ViRnJhbWUuY3BwCkBAIC0xOTA3LDcgKzE5MDcsNyBAQCB2b2lkIFdlYkZyYW1lOjpk aXNwYXRjaERpZEZhaWxMb2FkKGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9yKQogICAgIH0KIH0K IAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJl cXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGQtPndlYlZp ZXctPmRvd25sb2FkVVJMKHJlcXVlc3QudXJsKCkpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC93aW4vV2ViRnJhbWUuaCBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgKaW5kZXgg ODA0NmQ4NS4uNzczOTUwZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUu aAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oCkBAIC0zNDIsNyArMzQyLDcgQEAg cHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBkaXNwYXRjaERpZExvYWRSZXNvdXJjZUZyb21NZW1v cnlDYWNoZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNl UmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmLCBpbnQgbGVuZ3RoKTsK ICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWlsUHJvdmlzaW9uYWxMb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlRXJyb3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWls TG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7Ci0gICAgdmlydHVhbCB2b2lkIHN0 YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29u c3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAgICAgCiAgICAgdmlydHVhbCBQYXNzUmVmUHRy PFdlYkNvcmU6OldpZGdldD4gY3JlYXRlSmF2YUFwcGxldFdpZGdldChjb25zdCBXZWJDb3JlOjpJ bnRTaXplJiwgV2ViQ29yZTo6SFRNTEFwcGxldEVsZW1lbnQqLCBjb25zdCBXZWJDb3JlOjpLVVJM JiBiYXNlVVJMLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbU5hbWVzLCBjb25zdCBW ZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbVZhbHVlcyk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAgYi9T b3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0Uu Y3BwCmluZGV4IDY0YzEwZmUuLmRiNmVmNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2lu Y2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAKKysrIGIvU291cmNl L1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcApA QCAtNTk3LDcgKzU5Nyw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c2V0TWFpbkRv Y3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXNvdXJjCiAgICAgbV9oYXNTZW50 UmVzcG9uc2VUb1BsdWdpbiA9IGZhbHNlOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2lu Q0U6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JikKK3ZvaWQg RnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgbm90SW1w bGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oIGIvU291cmNlL1dlYktpdC93aW5jZS9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgKaW5kZXggNmJlYWIwZC4uOWEyZTI3 MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFdpbkNFLmgKKysrIGIvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgKQEAgLTEyNSw3ICsxMjUsNyBAQCBwdWJsaWM6CiAK ICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAg IHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZv aWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVh bCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5j cHAgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5j cHAKaW5kZXggZDE2ZjY3Ny4uOWU1MTJlMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93eC9X ZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv d3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcApAQCAtODQwLDcgKzg0MCw3 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6ZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBv bGljeShjb25zdCBSZXNvdXJjZUVycm9yJikKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12 b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1 ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgbm90SW1w bGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFd4LmggYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRXeC5oCmluZGV4IDBhZmRhZDkuLjIwZjA4MTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKKysr IGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaApA QCAtMjA2LDcgKzIwNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2 b2lkIGRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1 bmN0aW9uIGZ1bmN0aW9uLCBjb25zdCBOYXZpZ2F0aW9uQWN0aW9uJiwgY29uc3QgUmVzb3VyY2VS ZXF1ZXN0JiwgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRp c3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvciYpOwogCi0g ICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYp OworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgICAgICAKICAgICAgICAgLy8gRklY TUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IG5vdCBiZSBoZXJlLCBidXQgaXQncyBuZWVkZWQgZm9y IHRoZSB0ZXN0cyBjdXJyZW50bHkKICAgICAgICAgdmlydHVhbCB2b2lkIHBhcnRDbGVhcmVkSW5C ZWdpbigpOwo= 101085 2011-07-15 19:03:44 -0700 2011-07-15 21:47:04 -0700 Check origin before downloading webkit-a-download.patch text/plain 20232 sadrul ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u YTlhYWI4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJBdHRyaWJ1dGUuaCIKICNpbmNsdWRlICJFdmVudE5h bWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCkBAIC0xNDcsMTAgKzE0OCw3IEBAIHZvaWQg SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAg ICAgICB9CiAKICAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSAmJiB0cmVhdExpbmtBc0xp dmVGb3JFdmVudFR5cGUoZXZlbnRUeXBlKGV2ZW50KSkpIHsKLSAgICAgICAgICAgIFN0cmluZyB1 cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZ2V0QXR0cmlidXRlKGhyZWZB dHRyKSk7Ci0gICAgICAgICAgICBhcHBlbmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZl bnQpOwotICAgICAgICAgICAgaGFuZGxlTGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmws IGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpOwot ICAgICAgICAgICAgc2VuZFBpbmdzKGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCkpOworICAg ICAgICAgICAgaGFuZGxlQ2xpY2soZXZlbnQpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAg ICB9CiAKQEAgLTQ5Miw2ICs0OTAsMjkgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2VuZFBp bmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKQogICAgICAgICBQaW5nTG9hZGVyOjpzZW5k UGluZyhkb2N1bWVudCgpLT5mcmFtZSgpLCBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwaW5nVVJM c1tpXSksIGRlc3RpbmF0aW9uVVJMKTsKIH0KIAordm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6aGFu ZGxlQ2xpY2soRXZlbnQqIGV2ZW50KQoreworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgp OworCisgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQoKS0+ZnJhbWUoKTsKKyAgICBpZiAoIWZy YW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBTdHJpbmcgdXJsID0gc3RyaXBMZWFkaW5nQW5k VHJhaWxpbmdIVE1MU3BhY2VzKGZhc3RHZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKKyAgICBhcHBl bmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworICAgIEtVUkwga3VybCA9IGRv Y3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCk7CisKKyAgICBib29sIGRvd25sb2FkID0gaGFzQXR0 cmlidXRlKGRvd25sb2FkQXR0cik7CisgICAgaWYgKGRvd25sb2FkICYmIGRvY3VtZW50KCktPnNl Y3VyaXR5T3JpZ2luKCktPmNhblJlcXVlc3Qoa3VybCkpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1 ZXN0IHJlcXVlc3Qoa3VybCk7CisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+cHJlcGFyZVJlc291 cmNlUmVxdWVzdChyZXF1ZXN0LCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSA/IE5vUmVmZXJy ZXIgOiBTZW5kUmVmZXJyZXIpOworICAgICAgICBmcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5z dGFydERvd25sb2FkKHJlcXVlc3QsIGZhc3RHZXRBdHRyaWJ1dGUoZG93bmxvYWRBdHRyKSk7Cisg ICAgfSBlbHNlCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoa3VybCwgdGFy Z2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8g Tm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7CisKKyAgICBzZW5kUGluZ3Moa3VybCk7Cit9CisK IEhUTUxBbmNob3JFbGVtZW50OjpFdmVudFR5cGUgSFRNTEFuY2hvckVsZW1lbnQ6OmV2ZW50VHlw ZShFdmVudCogZXZlbnQpCiB7CiAgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKaW5kZXggNjA3ZDFmNS4uMTVmZTZkNiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaApAQCAtMTE1LDYgKzExNSw4 IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHNlbmRQaW5ncyhjb25zdCBLVVJMJiBkZXN0aW5hdGlv blVSTCk7CiAKKyAgICB2b2lkIGhhbmRsZUNsaWNrKEV2ZW50Kik7CisKICAgICBlbnVtIEV2ZW50 VHlwZSB7CiAgICAgICAgIE1vdXNlRXZlbnRXaXRob3V0U2hpZnRLZXksCiAgICAgICAgIE1vdXNl RXZlbnRXaXRoU2hpZnRLZXksCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxB bmNob3JFbGVtZW50LmlkbCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQu aWRsCmluZGV4IDg3MWZjZGYuLjFlOWMxMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFu Y2hvckVsZW1lbnQuaWRsCkBAIC0yNiw2ICsyNiw3IEBAIG1vZHVsZSBodG1sIHsKICAgICAgICAg YXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgYWNjZXNzS2V5OwogICAgICAgICBhdHRyaWJ1 dGUgW1JlZmxlY3RdIERPTVN0cmluZyBjaGFyc2V0OwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxl Y3RdIERPTVN0cmluZyBjb29yZHM7CisgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3Ry aW5nIGRvd25sb2FkOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3QsIFVSTF0gRE9NU3RyaW5n IGhyZWY7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGhyZWZsYW5nOwog ICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBuYW1lOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4gYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgppbmRleCAxNjc5ZTk2Li44NDEwZGU2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgpAQCAtOTEsNiArOTEsNyBA QCBkZWZlcgogZGlyCiBkaXJlY3Rpb24KIGRpc2FibGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3 ZWJraXRkcm9wem9uZQogZW5jdHlwZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVy L0VtcHR5Q2xpZW50cy5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCmlu ZGV4IGYxZmFlOTIuLjdkNDAxYzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9F bXB0eUNsaWVudHMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgK QEAgLTMwOSw3ICszMDksNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZy YW1lRG9jdW1lbnRSZWFkeShib29sKSB7IH0KIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25s b2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBzdGFydERv d25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkg eyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikg eyB9CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAppbmRleCAwMzJlNjgyLi4zNmNmNjlm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTEyMjgsNiArMTIyOCwx OSBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJMKGNvbnN0IEtVUkwmIG5ld1VSTCwgY29uc3Qg U3RyaW5nJiByZWZlcnJlciwgY29uc3QgU3RyaQogICAgIH0KIH0KIAordm9pZCBGcmFtZUxvYWRl cjo6cHJlcGFyZVJlc291cmNlUmVxdWVzdChSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIFJlZmVy cmVyUG9saWN5IHJlZmVycmVyUG9saWN5KQoreworICAgIFN0cmluZyByZWZlcnJlciA9IHJlcXVl c3QuaHR0cFJlZmVycmVyKCk7CisgICAgaWYgKHJlZmVycmVyLmlzRW1wdHkoKSkKKyAgICAgICAg cmVmZXJyZXIgPSBtX291dGdvaW5nUmVmZXJyZXI7CisgICAgaWYgKFNlY3VyaXR5T3JpZ2luOjpz aG91bGRIaWRlUmVmZXJyZXIocmVxdWVzdC51cmwoKSwgcmVmZXJyZXIpIHx8IHJlZmVycmVyUG9s aWN5ID09IE5vUmVmZXJyZXIpCisgICAgICAgIHJlZmVycmVyID0gU3RyaW5nKCk7CisKKyAgICBy ZXF1ZXN0LnNldEhUVFBSZWZlcnJlcihyZWZlcnJlcik7CisKKyAgICBhZGRFeHRyYUZpZWxkc1Rv TWFpblJlc291cmNlUmVxdWVzdChyZXF1ZXN0KTsKK30KKwogdm9pZCBGcmFtZUxvYWRlcjo6bG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGJvb2wgbG9ja0hpc3RvcnkpCiB7CiAg ICAgbG9hZChyZXF1ZXN0LCBTdWJzdGl0dXRlRGF0YSgpLCBsb2NrSGlzdG9yeSk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlci5oCmluZGV4IGEyMzZmYmMuLjJhMzk4MTMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlci5oCkBAIC0yNzIsNiArMjcyLDggQEAgcHVibGljOgogICAgIAog ICAgIHZvaWQgc3RhcnRlZCgpOwogCisgICAgdm9pZCBwcmVwYXJlUmVzb3VyY2VSZXF1ZXN0KFJl c291cmNlUmVxdWVzdCYsIFJlZmVycmVyUG9saWN5KTsKKwogICAgIGVudW0gUGFnZURpc21pc3Nh bFR5cGUgewogICAgICAgICBOb0Rpc21pc3NhbCA9IDAsCiAgICAgICAgIEJlZm9yZVVubG9hZERp c21pc3NhbCA9IDEsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2Fk ZXJDbGllbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCmlu ZGV4IDM4NTIzODMuLmFhMGYyZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRl ckNsaWVudC5oCkBAIC0xNzksNyArMTc5LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICAKICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCkg PSAwOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYpID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKSA9IDA7CiAKICAgICAg ICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsKICAg ICAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJ bXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1w bC5jcHAKaW5kZXggNzlkZGQ2OC4uYTJmZDEwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCkBAIC05NDQsNyArOTQ0LDcg QEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2 aWdhdGlvbkFjdGlvbigKICAgICBQb2xpY3lBY3Rpb24gcG9saWN5QWN0aW9uID0gUG9saWN5SWdu b3JlOwogCiAgICAgLy8gSXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVuY3Rpb24gdG8gYmUgaW52b2tl ZCBpbiBjb2RlIHBhdGhzIHdoZXJlIHRoZQotICAgIC8vIHRoZSB3ZWJ2aWV3IGlzIGNsb3NlZC4K KyAgICAvLyB3ZWJ2aWV3IGlzIGNsb3NlZC4KICAgICAvLyBUaGUgbnVsbCBjaGVjayBoZXJlIGlz IHRvIGZpeCBhIGNyYXNoIHRoYXQgc2VlbXMgc3RyYW5nZQogICAgIC8vIChzZWUgLSBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM1NTQpLgogICAgIGlmIChtX3dlYkZy YW1lLT5jbGllbnQoKSAmJiAhcmVxdWVzdC51cmwoKS5pc051bGwoKSkgewpAQCAtMTA3Myw3ICsx MDczLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnNldE1haW5GcmFtZURvY3VtZW50 UmVhZHkoYm9vbCByZWFkeSkKIAogLy8gQ3JlYXRlcyBhIG5ldyBjb25uZWN0aW9uIGFuZCBiZWdp bnMgZG93bmxvYWRpbmcgZnJvbSB0aGF0IChjb250cmFzdCB0aGlzCiAvLyB3aXRoIHxkb3dubG9h ZHwpLgotdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnN0YXJ0 RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1 Z2dlc3RlZE5hbWUpCiB7CiAgICAgaWYgKG1fd2ViRnJhbWUtPmNsaWVudCgpKSB7CiAgICAgICAg IFdyYXBwZWRSZXNvdXJjZVJlcXVlc3Qgd2VicmVxKHJlcXVlc3QpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmggYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaAppbmRleCBhZGFmOWQz Li5mMWYwMjRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxv YWRlckNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxv YWRlckNsaWVudEltcGwuaApAQCAtMTMxLDcgKzEzMSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgcG9zdFByb2dyZXNzRXN0aW1hdGVDaGFuZ2VkTm90aWZpY2F0aW9uKCk7CiAgICAgdmly dHVhbCB2b2lkIHBvc3RQcm9ncmVzc0ZpbmlzaGVkTm90aWZpY2F0aW9uKCk7CiAgICAgdmlydHVh bCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7Ci0gICAgdmlydHVhbCB2b2lk IHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmly dHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg Y29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRp dGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5n ZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGNvbW1p dHRlZExvYWQoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBjaGFyKiwgaW50KTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50RWZsLmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50RWZsLmNwcAppbmRleCA5ZTI3NTdmLi45YTJkZmNmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHAKKysrIGIv U291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3Bw CkBAIC04NzEsNyArODcxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c2V0TWFpbkRv Y3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgY29uc3QgUmUKICAgICBtX2hhc1Nl bnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRF Zmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBG cmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBpZiAoIW1fdmll dykKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKaW5kZXggNDdhYjNkNC4uOWU2ZDFjYyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRFZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEVmbC5oCkBAIC0xNTMsNyArMTUzLDcgQEAgY2xhc3MgRnJhbWVMb2FkZXJDbGll bnRFZmwgOiBwdWJsaWMgRnJhbWVMb2FkZXJDbGllbnQgewogCiAgICAgdmlydHVhbCB2b2lkIHNl dE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkp OwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwog ICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRH dGsuY3BwIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCmluZGV4IDMxNjQyNWMuLjVlNmNmYTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKQEAg LTEzMjYsNyArMTMyNiw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldE1haW5Eb2N1bWVu dEVycm9yKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzCiAgICAgfQogfQogCi12 b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7 CiAgICAgR1JlZlB0cjxXZWJLaXROZXR3b3JrUmVxdWVzdD4gbmV0d29ya1JlcXVlc3QoYWRvcHRH UmVmKGtpdE5ldyhyZXF1ZXN0KSkpOwogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBnZXRWaWV3 RnJvbUZyYW1lKG1fZnJhbWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKaW5kZXggMjQ0ODI5Zi4uN2M1ODMyMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRHdGsuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5oCkBAIC0xMzAsNyArMTMwLDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAK ICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAK LSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAg ICAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRl ciopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1l bnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCmluZGV4IDI4NWEzZmEuLjBjNDY4 YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRIYWlrdS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcApAQCAtNzA5LDcgKzcwOSw3IEBAIHZvaWQg RnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6ZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShj b25zdCBSZXNvdXJjZUVycm9yCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFt ZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYp Cit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG5vdEltcGxl bWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaCBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCmluZGV4IDc5ZWU5MTQuLjllODcwOTIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRIYWlrdS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCkBAIC0yMTksNyArMjE5LDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAgICAgICAgIHZpcnR1YWwgdm9p ZCBkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKTsK IAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VS ZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgICAgICAvLyBGSVhNRTog VGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJlIGhlcmUsIGJ1dCBpdCdzIG5lZWRlZCBmb3IgdGhl IHRlc3RzIGN1cnJlbnRseS4KICAgICAgICAgdmlydHVhbCB2b2lkIHBhcnRDbGVhcmVkSW5CZWdp bigpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFF0LmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRRdC5jcHAKaW5kZXggOGVjN2Y2MC4uMTc4NmZhMiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3Bw CkBAIC0xMjkzLDcgKzEyOTMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNo VW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgV2ViQ29yZTo6UmVzb3VyYwogICAgIG5vdElt cGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9h ZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9h ZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgaWYgKCFtX3dl YkZyYW1lKQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaCBiL1NvdXJjZS9XZWJLaXQvcXQvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oCmluZGV4IDEyMTMwM2QuLjkxOGZiMjAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRRdC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRRdC5oCkBAIC0xNDksNyArMTQ5LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2 b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQg c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0 dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBj b25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VU aXRsZShEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShE b2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUu Y3BwIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCmluZGV4IGI4YmIyNDkuLmZkNTkw ZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKQEAgLTE5MDcsNyArMTkwNyw3IEBAIHZvaWQgV2Vi RnJhbWU6OmRpc3BhdGNoRGlkRmFpbExvYWQoY29uc3QgUmVzb3VyY2VFcnJvciYgZXJyb3IpCiAg ICAgfQogfQogCi12b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVx dWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAg ZC0+d2ViVmlldy0+ZG93bmxvYWRVUkwocmVxdWVzdC51cmwoKSk7CiB9CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUu aAppbmRleCA4MDQ2ZDg1Li43NzM5NTBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbi9X ZWJGcmFtZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgKQEAgLTM0Miw3ICsz NDIsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGRpc3BhdGNoRGlkTG9hZFJlc291cmNl RnJvbU1lbW9yeUNhY2hlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSYsIGludCBs ZW5ndGgpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaERpZEZhaWxQcm92aXNpb25hbExvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRj aERpZEZhaWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKLSAgICB2aXJ0dWFs IHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAg ICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgICAgICAKICAgICB2aXJ0dWFsIFBh c3NSZWZQdHI8V2ViQ29yZTo6V2lkZ2V0PiBjcmVhdGVKYXZhQXBwbGV0V2lkZ2V0KGNvbnN0IFdl YkNvcmU6OkludFNpemUmLCBXZWJDb3JlOjpIVE1MQXBwbGV0RWxlbWVudCosIGNvbnN0IFdlYkNv cmU6OktVUkwmIGJhc2VVUkwsIGNvbnN0IFZlY3RvcjxXVEY6OlN0cmluZz4mIHBhcmFtTmFtZXMs IGNvbnN0IFZlY3RvcjxXVEY6OlN0cmluZz4mIHBhcmFtVmFsdWVzKTsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNF LmNwcCBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRXaW5DRS5jcHAKaW5kZXggNjRjMTBmZS4uZGI2ZWY2MyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2lu Q0UuY3BwCkBAIC01OTcsNyArNTk3LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpz ZXRNYWluRG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmMKICAgICBt X2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJD bGllbnRXaW5DRTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KQordm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAg ICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW5jZS9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmggYi9Tb3VyY2UvV2ViS2l0L3dp bmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaAppbmRleCA2YmVhYjBk Li45YTJlMjcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaApAQCAtMTI1LDcgKzEyNSw3IEBAIHB1 YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wp OwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29y ZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgIHZp cnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAg ICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudFd4LmNwcCBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudFd4LmNwcAppbmRleCBkMTZmNjc3Li45ZTUxMmUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAKKysrIGIvU291cmNl L1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwCkBAIC04NDAs NyArODQwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpkaXNwYXRjaFVuYWJsZVRvSW1w bGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKQogICAgIG5vdEltcGxlbWVudGVkKCk7 CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAg ICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93eC9XZWJL aXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaCBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0 U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKaW5kZXggMGFmZGFkOS4uMjBmMDgxMiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 V3guaAorKysgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRXeC5oCkBAIC0yMDYsNyArMjA2LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2 aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKEZyYW1l UG9saWN5RnVuY3Rpb24gZnVuY3Rpb24sIGNvbnN0IE5hdmlnYXRpb25BY3Rpb24mLCBjb25zdCBS ZXNvdXJjZVJlcXVlc3QmLCBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAgICAgICB2aXJ0dWFs IHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9y Jik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VS ZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgICAgIAogICAgICAg ICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJlIGhlcmUsIGJ1dCBpdCdzIG5l ZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseQogICAgICAgICB2aXJ0dWFsIHZvaWQgcGFydENs ZWFyZWRJbkJlZ2luKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCmluZGV4IGFl NzAwNjguLjNhNjdmMGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2Vi Q29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCkBAIC03 ODksNyArNzg5LDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c2V0TWFpbkZyYW1lRG9j dW1lbnRSZWFkeShib29sKQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgV2ViRnJh bWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0KQordm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAg ICBtX2ZyYW1lLT5zdGFydERvd25sb2FkKHJlcXVlc3QpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5o IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRl ckNsaWVudC5oCmluZGV4IDU2ZWY3ZWEuLmNlODQzZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVy Q2xpZW50LmgKQEAgLTEyMiw3ICsxMjIsNyBAQCBwcml2YXRlOgogICAgIAogICAgIHZpcnR1YWwg dm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogICAgIAotICAgIHZpcnR1YWwg dm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAg IHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHdp bGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9p ZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmNwcCBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5jcHAKaW5kZXggNDZmOTllMy4uNTU0 MGEwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZy YW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUu Y3BwCkBAIC0yMTUsNyArMjE1LDcgQEAgdm9pZCBXZWJGcmFtZTo6ZGlkUmVjZWl2ZVBvbGljeURl Y2lzaW9uKHVpbnQ2NF90IGxpc3RlbmVySUQsIFBvbGljeUFjdGlvbiBhY3Rpb24KICAgICAobV9j b3JlRnJhbWUtPmxvYWRlcigpLT5wb2xpY3lDaGVja2VyKCktPipmdW5jdGlvbikoYWN0aW9uKTsK IH0KIAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lKQogewogICAgIEFTU0VSVChtX3BvbGljeURvd25sb2FkSUQpOwogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuaCBiL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oCmluZGV4IDk3NTcxMmQuLjkwNjBhMzgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5o CisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oCkBAIC03 MCw3ICs3MCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGludmFsaWRhdGVQb2xpY3lMaXN0ZW5lcigp OwogICAgIHZvaWQgZGlkUmVjZWl2ZVBvbGljeURlY2lzaW9uKHVpbnQ2NF90IGxpc3RlbmVySUQs IFdlYkNvcmU6OlBvbGljeUFjdGlvbiwgdWludDY0X3QgZG93bmxvYWRJRCk7CiAKLSAgICB2b2lk IHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0 cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgdm9pZCBjb252ZXJ0SGFuZGxlVG9Eb3dubG9hZChXZWJD b3JlOjpSZXNvdXJjZUhhbmRsZSosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgaW5pdGlhbFJlcXVlc3QsIGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVzcG9uc2UmKTsKIAogICAgIFN0cmluZyBzb3VyY2UoKSBjb25zdDsK 101090 2011-07-15 21:47:04 -0700 2011-07-16 22:11:27 -0700 Always allow data URLs webkit-a-download.patch text/plain 20507 sadrul ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u YTVkZDVjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJBdHRyaWJ1dGUuaCIKICNpbmNsdWRlICJFdmVudE5h bWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCkBAIC0xNDcsMTAgKzE0OCw3IEBAIHZvaWQg SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAg ICAgICB9CiAKICAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSAmJiB0cmVhdExpbmtBc0xp dmVGb3JFdmVudFR5cGUoZXZlbnRUeXBlKGV2ZW50KSkpIHsKLSAgICAgICAgICAgIFN0cmluZyB1 cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZ2V0QXR0cmlidXRlKGhyZWZB dHRyKSk7Ci0gICAgICAgICAgICBhcHBlbmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZl bnQpOwotICAgICAgICAgICAgaGFuZGxlTGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmws IGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpOwot ICAgICAgICAgICAgc2VuZFBpbmdzKGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCkpOworICAg ICAgICAgICAgaGFuZGxlQ2xpY2soZXZlbnQpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAg ICB9CiAKQEAgLTQ5Miw2ICs0OTAsMjkgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2VuZFBp bmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKQogICAgICAgICBQaW5nTG9hZGVyOjpzZW5k UGluZyhkb2N1bWVudCgpLT5mcmFtZSgpLCBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwaW5nVVJM c1tpXSksIGRlc3RpbmF0aW9uVVJMKTsKIH0KIAordm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6aGFu ZGxlQ2xpY2soRXZlbnQqIGV2ZW50KQoreworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgp OworCisgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQoKS0+ZnJhbWUoKTsKKyAgICBpZiAoIWZy YW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBTdHJpbmcgdXJsID0gc3RyaXBMZWFkaW5nQW5k VHJhaWxpbmdIVE1MU3BhY2VzKGZhc3RHZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKKyAgICBhcHBl bmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworICAgIEtVUkwga3VybCA9IGRv Y3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCk7CisKKyAgICBib29sIGRvd25sb2FkID0gaGFzQXR0 cmlidXRlKGRvd25sb2FkQXR0cik7CisgICAgaWYgKGRvd25sb2FkICYmIChrdXJsLnByb3RvY29s SXNEYXRhKCkgfHwgZG9jdW1lbnQoKS0+c2VjdXJpdHlPcmlnaW4oKS0+Y2FuUmVxdWVzdChrdXJs KSkpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Qoa3VybCk7CisgICAgICAgIGZy YW1lLT5sb2FkZXIoKS0+cHJlcGFyZVJlc291cmNlUmVxdWVzdChyZXF1ZXN0LCBoYXNSZWwoUmVs YXRpb25Ob1JlZmVycmVyKSA/IE5vUmVmZXJyZXIgOiBTZW5kUmVmZXJyZXIpOworICAgICAgICBm cmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5zdGFydERvd25sb2FkKHJlcXVlc3QsIGZhc3RHZXRB dHRyaWJ1dGUoZG93bmxvYWRBdHRyKSk7CisgICAgfSBlbHNlCisgICAgICAgIGZyYW1lLT5sb2Fk ZXIoKS0+dXJsU2VsZWN0ZWQoa3VybCwgdGFyZ2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIGhh c1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7CisK KyAgICBzZW5kUGluZ3Moa3VybCk7Cit9CisKIEhUTUxBbmNob3JFbGVtZW50OjpFdmVudFR5cGUg SFRNTEFuY2hvckVsZW1lbnQ6OmV2ZW50VHlwZShFdmVudCogZXZlbnQpCiB7CiAgICAgaWYgKCFl dmVudC0+aXNNb3VzZUV2ZW50KCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxBbmNob3JFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50 LmgKaW5kZXggNjA3ZDFmNS4uMTVmZTZkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MQW5jaG9yRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuaApAQCAtMTE1LDYgKzExNSw4IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHNlbmRQ aW5ncyhjb25zdCBLVVJMJiBkZXN0aW5hdGlvblVSTCk7CiAKKyAgICB2b2lkIGhhbmRsZUNsaWNr KEV2ZW50Kik7CisKICAgICBlbnVtIEV2ZW50VHlwZSB7CiAgICAgICAgIE1vdXNlRXZlbnRXaXRo b3V0U2hpZnRLZXksCiAgICAgICAgIE1vdXNlRXZlbnRXaXRoU2hpZnRLZXksCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCmluZGV4IDg3MWZjZGYuLjFlOWMxMWQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCkBAIC0yNiw2ICsyNiw3 IEBAIG1vZHVsZSBodG1sIHsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcg YWNjZXNzS2V5OwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBjaGFyc2V0 OwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBjb29yZHM7CisgICAgICAg IGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGRvd25sb2FkOwogICAgICAgICBhdHRyaWJ1 dGUgW1JlZmxlY3QsIFVSTF0gRE9NU3RyaW5nIGhyZWY7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVm bGVjdF0gRE9NU3RyaW5nIGhyZWZsYW5nOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERP TVN0cmluZyBuYW1lOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmli dXRlTmFtZXMuaW4gYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgpp bmRleCAxNjc5ZTk2Li44NDEwZGU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hU TUxBdHRyaWJ1dGVOYW1lcy5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1 dGVOYW1lcy5pbgpAQCAtOTEsNiArOTEsNyBAQCBkZWZlcgogZGlyCiBkaXJlY3Rpb24KIGRpc2Fi bGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3ZWJraXRkcm9wem9uZQogZW5jdHlwZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCmluZGV4IGYxZmFlOTIuLjdkNDAxYzggMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgKQEAgLTMwOSw3ICszMDksNyBAQCBwdWJsaWM6CiAK ICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKSB7IH0KIAot ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIHsg fQorICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYs IGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkgeyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENo YW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5n ZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVy LmNwcAppbmRleCAwMzJlNjgyLi4wMGE4ZTJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxv YWRlci5jcHAKQEAgLTEyMjgsNiArMTIyOCwyNCBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJM KGNvbnN0IEtVUkwmIG5ld1VSTCwgY29uc3QgU3RyaW5nJiByZWZlcnJlciwgY29uc3QgU3RyaQog ICAgIH0KIH0KIAordm9pZCBGcmFtZUxvYWRlcjo6cHJlcGFyZVJlc291cmNlUmVxdWVzdChSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QsIFJlZmVycmVyUG9saWN5IHJlZmVycmVyUG9saWN5KQorewor ICAgIFN0cmluZyByZWZlcnJlciA9IHJlcXVlc3QuaHR0cFJlZmVycmVyKCk7CisgICAgaWYgKHJl ZmVycmVyLmlzRW1wdHkoKSkKKyAgICAgICAgcmVmZXJyZXIgPSBtX291dGdvaW5nUmVmZXJyZXI7 CisgICAgaWYgKFNlY3VyaXR5T3JpZ2luOjpzaG91bGRIaWRlUmVmZXJyZXIocmVxdWVzdC51cmwo KSwgcmVmZXJyZXIpIHx8IHJlZmVycmVyUG9saWN5ID09IE5vUmVmZXJyZXIpCisgICAgICAgIHJl ZmVycmVyID0gU3RyaW5nKCk7CisKKyAgICBpZiAoIXJlZmVycmVyLmlzRW1wdHkoKSkgeworICAg ICAgICByZXF1ZXN0LnNldEhUVFBSZWZlcnJlcihyZWZlcnJlcik7CisgICAgICAgIFJlZlB0cjxT ZWN1cml0eU9yaWdpbj4gcmVmZXJyZXJPcmlnaW4gPSBTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJv bVN0cmluZyhyZWZlcnJlcik7CisgICAgICAgIGFkZEhUVFBPcmlnaW5JZk5lZWRlZChyZXF1ZXN0 LCByZWZlcnJlck9yaWdpbi0+dG9TdHJpbmcoKSk7CisgICAgfSBlbHNlCisgICAgICAgIHJlcXVl c3QuY2xlYXJIVFRQUmVmZXJyZXIoKTsKKworICAgIGFkZEV4dHJhRmllbGRzVG9NYWluUmVzb3Vy Y2VSZXF1ZXN0KHJlcXVlc3QpOworfQorCiB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkKGNvbnN0IFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCwgYm9vbCBsb2NrSGlzdG9yeSkKIHsKICAgICBsb2FkKHJl cXVlc3QsIFN1YnN0aXR1dGVEYXRhKCksIGxvY2tIaXN0b3J5KTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0Zy YW1lTG9hZGVyLmgKaW5kZXggYTIzNmZiYy4uMmEzOTgxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0Zy YW1lTG9hZGVyLmgKQEAgLTI3Miw2ICsyNzIsOCBAQCBwdWJsaWM6CiAgICAgCiAgICAgdm9pZCBz dGFydGVkKCk7CiAKKyAgICB2b2lkIHByZXBhcmVSZXNvdXJjZVJlcXVlc3QoUmVzb3VyY2VSZXF1 ZXN0JiwgUmVmZXJyZXJQb2xpY3kpOworCiAgICAgZW51bSBQYWdlRGlzbWlzc2FsVHlwZSB7CiAg ICAgICAgIE5vRGlzbWlzc2FsID0gMCwKICAgICAgICAgQmVmb3JlVW5sb2FkRGlzbWlzc2FsID0g MSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5o IGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggMzg1MjM4 My4uYWEwZjJmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVy Q2xpZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgK QEAgLTE3OSw3ICsxNzksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIAogICAgICAg ICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKSA9IDA7CiAKLSAg ICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jikg PSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJl cXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpID0gMDsKIAogICAgICAgICB2aXJ0dWFs IHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwogICAgICAgICB2aXJ0 dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcAppbmRl eCA3OWRkZDY4Li5hMmZkMTAwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKQEAgLTk0NCw3ICs5NDQsNyBAQCB2b2lkIEZy YW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0 aW9uKAogICAgIFBvbGljeUFjdGlvbiBwb2xpY3lBY3Rpb24gPSBQb2xpY3lJZ25vcmU7CiAKICAg ICAvLyBJdCBpcyB2YWxpZCBmb3IgdGhpcyBmdW5jdGlvbiB0byBiZSBpbnZva2VkIGluIGNvZGUg cGF0aHMgd2hlcmUgdGhlCi0gICAgLy8gdGhlIHdlYnZpZXcgaXMgY2xvc2VkLgorICAgIC8vIHdl YnZpZXcgaXMgY2xvc2VkLgogICAgIC8vIFRoZSBudWxsIGNoZWNrIGhlcmUgaXMgdG8gZml4IGEg Y3Jhc2ggdGhhdCBzZWVtcyBzdHJhbmdlCiAgICAgLy8gKHNlZSAtIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzU1NCkuCiAgICAgaWYgKG1fd2ViRnJhbWUtPmNsaWVu dCgpICYmICFyZXF1ZXN0LnVybCgpLmlzTnVsbCgpKSB7CkBAIC0xMDczLDcgKzEwNzMsNyBAQCB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29s IHJlYWR5KQogCiAvLyBDcmVhdGVzIGEgbmV3IGNvbm5lY3Rpb24gYW5kIGJlZ2lucyBkb3dubG9h ZGluZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMKIC8vIHdpdGggfGRvd25sb2FkfCkuCi12b2lk IEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChj b25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFt ZSkKIHsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkpIHsKICAgICAgICAgV3JhcHBlZFJl c291cmNlUmVxdWVzdCB3ZWJyZXEocmVxdWVzdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCmluZGV4IGFkYWY5ZDMuLmYxZjAyNGYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50 SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50 SW1wbC5oCkBAIC0xMzEsNyArMTMxLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBwb3N0 UHJvZ3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmljYXRpb24oKTsKICAgICB2aXJ0dWFsIHZvaWQg cG9zdFByb2dyZXNzRmluaXNoZWROb3RpZmljYXRpb24oKTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0 TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQg c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJp bmcmID0gU3RyaW5nKCkpOwogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29y ZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2Vi Q29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgY29tbWl0dGVkTG9hZChX ZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IGNoYXIqLCBpbnQpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3Bw IGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwu Y3BwCmluZGV4IDllMjc1N2YuLjlhMmRmY2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZs L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHAKQEAgLTg3MSw3 ICs4NzEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZsOjpzZXRNYWluRG9jdW1lbnRFcnJv cihEb2N1bWVudExvYWRlciogbG9hZGVyLCBjb25zdCBSZQogICAgIG1faGFzU2VudFJlc3BvbnNl VG9QbHVnaW4gPSBmYWxzZTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVy Q2xpZW50RWZsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwg Y29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmICghbV92aWV3KQogICAgICAg ICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEVmbC5oIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRFZmwuaAppbmRleCA0N2FiM2Q0Li45ZTZkMWNjIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5o CisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 RWZsLmgKQEAgLTE1Myw3ICsxNTMsNyBAQCBjbGFzcyBGcmFtZUxvYWRlckNsaWVudEVmbCA6IHB1 YmxpYyBGcmFtZUxvYWRlckNsaWVudCB7CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1l RG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICB2 aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVh bCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9T b3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAK aW5kZXggMzE2NDI1Yy4uNWU2Y2ZhMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv Z3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAtMTMyNiw3ICsx MzI2LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoV2Vi Q29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXMKICAgICB9CiB9CiAKLXZvaWQgRnJhbWVM b2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0 KQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBHUmVm UHRyPFdlYktpdE5ldHdvcmtSZXF1ZXN0PiBuZXR3b3JrUmVxdWVzdChhZG9wdEdSZWYoa2l0TmV3 KHJlcXVlc3QpKSk7CiAgICAgV2ViS2l0V2ViVmlldyogdmlldyA9IGdldFZpZXdGcm9tRnJhbWUo bV9mcmFtZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5oIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuaAppbmRleCAyNDQ4MjlmLi43YzU4MzIwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5o CisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 R3RrLmgKQEAgLTEzMCw3ICsxMzAsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogICAgICAgICB2 aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgICAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgICAgICB2aXJ0 dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAg ICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciop OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEhhaWt1LmNwcCBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKaW5kZXggMjg1YTNmYS4uMGM0NjhhZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dEhhaWt1LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50SGFpa3UuY3BwCkBAIC03MDksNyArNzA5LDcgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudEhhaWt1OjpkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291 cmNlRXJyb3IKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xp ZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJh bWVMb2FkZXJDbGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsK IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRIYWlrdS5oIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEhhaWt1LmgKaW5kZXggNzllZTkxNC4uOWU4NzA5MiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhh aWt1LmgKKysrIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudEhhaWt1LmgKQEAgLTIxOSw3ICsyMTksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNo VW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvciYpOwogCi0gICAgICAg IHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpOworICAg ICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBj b25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHNob3Vs ZCBwcm9iYWJseSBub3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVlZGVkIGZvciB0aGUgdGVzdHMgY3Vy cmVudGx5LgogICAgICAgICB2aXJ0dWFsIHZvaWQgcGFydENsZWFyZWRJbkJlZ2luKCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuY3BwIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dFF0LmNwcAppbmRleCA4ZWM3ZjYwLi4xNzg2ZmEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKQEAgLTEyOTMs NyArMTI5Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hVbmFibGVUb0lt cGxlbWVudFBvbGljeShjb25zdCBXZWJDb3JlOjpSZXNvdXJjCiAgICAgbm90SW1wbGVtZW50ZWQo KTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRR dDo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3Qs IGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBpZiAoIW1fd2ViRnJhbWUpCiAg ICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFF0LmgKaW5kZXggMTIxMzAzZC4uOTE4ZmIyMCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmgK KysrIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0 LmgKQEAgLTE0OSw3ICsxNDksNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFp bkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25s b2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBz dGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmlu ZyYgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3Vt ZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9h ZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKaW5kZXggYjhiYjI0OS4uZmQ1OTBmMCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv d2luL1dlYkZyYW1lLmNwcApAQCAtMTkwNyw3ICsxOTA3LDcgQEAgdm9pZCBXZWJGcmFtZTo6ZGlz cGF0Y2hEaWRGYWlsTG9hZChjb25zdCBSZXNvdXJjZUVycm9yJiBlcnJvcikKICAgICB9CiB9CiAK LXZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0KQordm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBkLT53ZWJWaWV3 LT5kb3dubG9hZFVSTChyZXF1ZXN0LnVybCgpKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvd2luL1dlYkZyYW1lLmggYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oCmluZGV4IDgw NDZkODUuLjc3Mzk1MGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgK KysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaApAQCAtMzQyLDcgKzM0Miw3IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VGcm9tTWVtb3J5 Q2FjaGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJl cXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiwgaW50IGxlbmd0aCk7CiAg ICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbFByb3Zpc2lvbmFsTG9hZChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZUVycm9yJik7CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbExv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwotICAgIHZpcnR1YWwgdm9pZCBzdGFy dERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwg dm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0 IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgICAgIAogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxX ZWJDb3JlOjpXaWRnZXQ+IGNyZWF0ZUphdmFBcHBsZXRXaWRnZXQoY29uc3QgV2ViQ29yZTo6SW50 U2l6ZSYsIFdlYkNvcmU6OkhUTUxBcHBsZXRFbGVtZW50KiwgY29uc3QgV2ViQ29yZTo6S1VSTCYg YmFzZVVSTCwgY29uc3QgVmVjdG9yPFdURjo6U3RyaW5nPiYgcGFyYW1OYW1lcywgY29uc3QgVmVj dG9yPFdURjo6U3RyaW5nPiYgcGFyYW1WYWx1ZXMpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwIGIvU291 cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNw cAppbmRleCA2NGMxMGZlLi5kYjZlZjYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNl L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAKQEAg LTU5Nyw3ICs1OTcsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnNldE1haW5Eb2N1 bWVudEVycm9yKERvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzb3VyYwogICAgIG1faGFzU2VudFJl c3BvbnNlVG9QbHVnaW4gPSBmYWxzZTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNF OjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZy YW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG5vdEltcGxl bWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaCBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCmluZGV4IDZiZWFiMGQuLjlhMmUyNzEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRXaW5DRS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCkBAIC0xMjUsNyArMTI1LDcgQEAgcHVibGljOgogCiAg ICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lk IHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwg dm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3Bw IGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3Bw CmluZGV4IGQxNmY2NzcuLjllNTEyZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd3gvV2Vi S2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3d4 L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAKQEAgLTg0MCw3ICs4NDAsNyBA QCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OmRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xp Y3koY29uc3QgUmVzb3VyY2VFcnJvciYpCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9p ZCBGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG5vdEltcGxl bWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRXeC5oIGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V3guaAppbmRleCAwYWZkYWQ5Li4yMGYwODEyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oCisrKyBi L1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKQEAg LTIwNiw3ICsyMDYsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9p ZCBkaXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5j dGlvbiBmdW5jdGlvbiwgY29uc3QgTmF2aWdhdGlvbkFjdGlvbiYsIGNvbnN0IFJlc291cmNlUmVx dWVzdCYsIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaXNw YXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKTsKIAotICAg ICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsK KyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0 JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAgICAgCiAgICAgICAgIC8vIEZJWE1F OiBUaGlzIHNob3VsZCBwcm9iYWJseSBub3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVlZGVkIGZvciB0 aGUgdGVzdHMgY3VycmVudGx5CiAgICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVn aW4oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBv cnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHAKaW5kZXggYWU3MDA2OC4uM2E2 N2YwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHAKQEAgLTc4OSw3ICs3ODks NyBAQCB2b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50OjpzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5 KGJvb2wpCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBXZWJGcmFtZUxvYWRlckNs aWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lk IFdlYkZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG1fZnJhbWUt PnN0YXJ0RG93bmxvYWQocmVxdWVzdCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmggYi9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgK aW5kZXggNTZlZjdlYS4uY2U4NDNmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaApA QCAtMTIyLDcgKzEyMiw3IEBAIHByaXZhdGU6CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldE1h aW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAgICAgCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0 RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2 b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3Qg U3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRp dGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5n ZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3BwIGIvU291cmNlL1dlYktpdDIvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmNwcAppbmRleCA0NmY5OWUzLi41NTQwYTAyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5jcHAKQEAgLTIx NSw3ICsyMTUsNyBAQCB2b2lkIFdlYkZyYW1lOjpkaWRSZWNlaXZlUG9saWN5RGVjaXNpb24odWlu dDY0X3QgbGlzdGVuZXJJRCwgUG9saWN5QWN0aW9uIGFjdGlvbgogICAgIChtX2NvcmVGcmFtZS0+ bG9hZGVyKCktPnBvbGljeUNoZWNrZXIoKS0+KmZ1bmN0aW9uKShhY3Rpb24pOwogfQogCi12b2lk IFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYg cmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAg ICAgQVNTRVJUKG1fcG9saWN5RG93bmxvYWRJRCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgKaW5kZXggOTc1NzEyZC4uOTA2MGEzOCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgKKysrIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgKQEAgLTcwLDcgKzcwLDcg QEAgcHVibGljOgogICAgIHZvaWQgaW52YWxpZGF0ZVBvbGljeUxpc3RlbmVyKCk7CiAgICAgdm9p ZCBkaWRSZWNlaXZlUG9saWN5RGVjaXNpb24odWludDY0X3QgbGlzdGVuZXJJRCwgV2ViQ29yZTo6 UG9saWN5QWN0aW9uLCB1aW50NjRfdCBkb3dubG9hZElEKTsKIAotICAgIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2b2lkIHN0YXJ0RG93 bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0 cmluZygpKTsKICAgICB2b2lkIGNvbnZlcnRIYW5kbGVUb0Rvd25sb2FkKFdlYkNvcmU6OlJlc291 cmNlSGFuZGxlKiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29y ZTo6UmVzb3VyY2VSZXF1ZXN0JiBpbml0aWFsUmVxdWVzdCwgY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXNwb25zZSYpOwogCiAgICAgU3RyaW5nIHNvdXJjZSgpIGNvbnN0Owo= 101111 2011-07-16 22:11:27 -0700 2011-07-22 09:04:48 -0700 Add test, remove special case for data URLs, ChangeLog webkit-a-download.patch text/plain 34997 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMGNkNTkxLi4wY2NkODExIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTEtMDct MTYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD1maWxlbmFtZSBmb3IgYW5jaG9ycy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M QW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbDogQWRk ZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxv YWQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxl bWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sOiBBZGRlZC4KKwogMjAxMS0wNy0xNSAgTWlrZSBX ZXN0ICA8bWt3c3RAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IFJlbmFt ZSBjb25zb2xlLm1hcmtUaW1lbGluZSgpIHRvIGNvbnNvbGUudGltZVN0YW1wKCkgZm9yIEZpcmVi dWcgY29tcGF0aWJpbGl0eS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxB bmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE5NmZiNjkKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxv YWQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK0Jsb2IgVVJMCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1ZGI1YTIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It ZG93bmxvYWQuaHRtbApAQCAtMCwwICsxLDI5IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK KyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCIgZG93bmxvYWQ+QmxvYiBVUkw8L2E+Cis8 c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRCbG9i QnVpbGRlcigpOworICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRs ZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBs YXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxi b2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBs YXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7 CisgIHZhciBibG9iID0gYmIuZ2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2YXIg bGluayA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhyZWYg PSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0ID0g ZG9jdW1lbnQuY3JlYXRlRXZlbnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2ZW50 KCdjbGljaycsIHRydWUsIHRydWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30KK3J1 blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5v ZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjdlZjIyZTkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAor UEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLW5vZG93bmxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JF bGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uM2Y1Y2ZiMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKQEAgLTAsMCArMSwzMCBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0L2ph dmFzY3JpcHQnPgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRV bnRpbERvbmUoKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxvYi11 cmwiPkJsb2IgVVJMPC9hPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICB2YXIg YmIgPSBuZXcgV2ViS2l0QmxvYkJ1aWxkZXIoKTsKKyAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRt bD48aHRtbD48aGVhZD48dGl0bGU+VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIg KyAic2NyaXB0PjwvaGVhZD48Ym9keT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2Ny IiArICJpcHQ+PC9odG1sPiIpOworICB2YXIgYmxvYiA9IGJiLmdldEJsb2IoInRleHQvaHRtbCIs ICJpbmxpbmUiKTsKKyAgdmFyIGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11 cmwiKTsKKyAgbGluay5ocmVmID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwoYmxv Yik7CisKKyAgdmFyIGV2dCA9IGRvY3VtZW50LmNyZWF0ZUV2ZW50KCJNb3VzZUV2ZW50Iik7Cisg IGV2dC5pbml0TW91c2VFdmVudCgnY2xpY2snLCB0cnVlLCB0cnVlKTsKKyAgbGluay5kaXNwYXRj aEV2ZW50KGV2dCk7Cit9CitydW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K KwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDhmN2JlYTMuLjRkYzVkMDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy NiBAQAorMjAxMS0wNy0xNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPWZpbGVuYW1lIGZvciBh bmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBU ZXN0czogZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLmh0bWwKKyAg ICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2Fk Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgorICAgICAg ICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRsZUNsaWNrKToKKyAgICAgICAgKiBo dG1sL0hUTUxBbmNob3JFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5pZGw6CisgICAgICAgICogaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW46CisgICAgICAgICog bG9hZGVyL0VtcHR5Q2xpZW50cy5oOgorICAgICAgICAoV2ViQ29yZTo6RW1wdHlGcmFtZUxvYWRl ckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpwcmVwYXJlUmVzb3VyY2VSZXF1ZXN0 KToKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvRnJh bWVMb2FkZXJDbGllbnQuaDoKKwogMjAxMS0wNy0xNSAgTWlrZSBXZXN0ICA8bWt3c3RAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IFJlbmFtZSBjb25zb2xlLm1hcmtUaW1l bGluZSgpIHRvIGNvbnNvbGUudGltZVN0YW1wKCkgZm9yIEZpcmVidWcgY29tcGF0aWJpbGl0eS4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKaW5kZXggZDY1MTVlNC4u YTlhYWI4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKQEAg LTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJBdHRyaWJ1dGUuaCIKICNpbmNsdWRlICJFdmVudE5h bWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5o IgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCkBAIC0xNDcsMTAgKzE0OCw3IEBAIHZvaWQg SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIoRXZlbnQqIGV2ZW50KQogICAg ICAgICB9CiAKICAgICAgICAgaWYgKGlzTGlua0NsaWNrKGV2ZW50KSAmJiB0cmVhdExpbmtBc0xp dmVGb3JFdmVudFR5cGUoZXZlbnRUeXBlKGV2ZW50KSkpIHsKLSAgICAgICAgICAgIFN0cmluZyB1 cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFjZXMoZ2V0QXR0cmlidXRlKGhyZWZB dHRyKSk7Ci0gICAgICAgICAgICBhcHBlbmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZl bnQpOwotICAgICAgICAgICAgaGFuZGxlTGlua0NsaWNrKGV2ZW50LCBkb2N1bWVudCgpLCB1cmws IGdldEF0dHJpYnV0ZSh0YXJnZXRBdHRyKSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpOwot ICAgICAgICAgICAgc2VuZFBpbmdzKGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCkpOworICAg ICAgICAgICAgaGFuZGxlQ2xpY2soZXZlbnQpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAg ICB9CiAKQEAgLTQ5Miw2ICs0OTAsMjkgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6c2VuZFBp bmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKQogICAgICAgICBQaW5nTG9hZGVyOjpzZW5k UGluZyhkb2N1bWVudCgpLT5mcmFtZSgpLCBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwaW5nVVJM c1tpXSksIGRlc3RpbmF0aW9uVVJMKTsKIH0KIAordm9pZCBIVE1MQW5jaG9yRWxlbWVudDo6aGFu ZGxlQ2xpY2soRXZlbnQqIGV2ZW50KQoreworICAgIGV2ZW50LT5zZXREZWZhdWx0SGFuZGxlZCgp OworCisgICAgRnJhbWUqIGZyYW1lID0gZG9jdW1lbnQoKS0+ZnJhbWUoKTsKKyAgICBpZiAoIWZy YW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBTdHJpbmcgdXJsID0gc3RyaXBMZWFkaW5nQW5k VHJhaWxpbmdIVE1MU3BhY2VzKGZhc3RHZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKKyAgICBhcHBl bmRTZXJ2ZXJNYXBNb3VzZVBvc2l0aW9uKHVybCwgZXZlbnQpOworICAgIEtVUkwga3VybCA9IGRv Y3VtZW50KCktPmNvbXBsZXRlVVJMKHVybCk7CisKKyAgICBib29sIGRvd25sb2FkID0gaGFzQXR0 cmlidXRlKGRvd25sb2FkQXR0cik7CisgICAgaWYgKGRvd25sb2FkICYmIGRvY3VtZW50KCktPnNl Y3VyaXR5T3JpZ2luKCktPmNhblJlcXVlc3Qoa3VybCkpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1 ZXN0IHJlcXVlc3Qoa3VybCk7CisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+cHJlcGFyZVJlc291 cmNlUmVxdWVzdChyZXF1ZXN0LCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSA/IE5vUmVmZXJy ZXIgOiBTZW5kUmVmZXJyZXIpOworICAgICAgICBmcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5z dGFydERvd25sb2FkKHJlcXVlc3QsIGZhc3RHZXRBdHRyaWJ1dGUoZG93bmxvYWRBdHRyKSk7Cisg ICAgfSBlbHNlCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoa3VybCwgdGFy Z2V0KCksIGV2ZW50LCBmYWxzZSwgZmFsc2UsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8g Tm9SZWZlcnJlciA6IFNlbmRSZWZlcnJlcik7CisKKyAgICBzZW5kUGluZ3Moa3VybCk7Cit9CisK IEhUTUxBbmNob3JFbGVtZW50OjpFdmVudFR5cGUgSFRNTEFuY2hvckVsZW1lbnQ6OmV2ZW50VHlw ZShFdmVudCogZXZlbnQpCiB7CiAgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKaW5kZXggNjA3ZDFmNS4uMTVmZTZkNiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaApAQCAtMTE1LDYgKzExNSw4 IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHNlbmRQaW5ncyhjb25zdCBLVVJMJiBkZXN0aW5hdGlv blVSTCk7CiAKKyAgICB2b2lkIGhhbmRsZUNsaWNrKEV2ZW50Kik7CisKICAgICBlbnVtIEV2ZW50 VHlwZSB7CiAgICAgICAgIE1vdXNlRXZlbnRXaXRob3V0U2hpZnRLZXksCiAgICAgICAgIE1vdXNl RXZlbnRXaXRoU2hpZnRLZXksCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxB bmNob3JFbGVtZW50LmlkbCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQu aWRsCmluZGV4IDg3MWZjZGYuLjFlOWMxMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFu Y2hvckVsZW1lbnQuaWRsCkBAIC0yNiw2ICsyNiw3IEBAIG1vZHVsZSBodG1sIHsKICAgICAgICAg YXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgYWNjZXNzS2V5OwogICAgICAgICBhdHRyaWJ1 dGUgW1JlZmxlY3RdIERPTVN0cmluZyBjaGFyc2V0OwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxl Y3RdIERPTVN0cmluZyBjb29yZHM7CisgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3Ry aW5nIGRvd25sb2FkOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3QsIFVSTF0gRE9NU3RyaW5n IGhyZWY7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGhyZWZsYW5nOwog ICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBuYW1lOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4gYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgppbmRleCAxNjc5ZTk2Li44NDEwZGU2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgpAQCAtOTEsNiArOTEsNyBA QCBkZWZlcgogZGlyCiBkaXJlY3Rpb24KIGRpc2FibGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3 ZWJraXRkcm9wem9uZQogZW5jdHlwZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVy L0VtcHR5Q2xpZW50cy5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCmlu ZGV4IGYxZmFlOTIuLjdkNDAxYzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9F bXB0eUNsaWVudHMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgK QEAgLTMwOSw3ICszMDksNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZy YW1lRG9jdW1lbnRSZWFkeShib29sKSB7IH0KIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25s b2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBzdGFydERv d25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkg eyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikg eyB9CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAppbmRleCAwMzJlNjgyLi4wMGE4ZTJm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTEyMjgsNiArMTIyOCwy NCBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkVVJMKGNvbnN0IEtVUkwmIG5ld1VSTCwgY29uc3Qg U3RyaW5nJiByZWZlcnJlciwgY29uc3QgU3RyaQogICAgIH0KIH0KIAordm9pZCBGcmFtZUxvYWRl cjo6cHJlcGFyZVJlc291cmNlUmVxdWVzdChSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIFJlZmVy cmVyUG9saWN5IHJlZmVycmVyUG9saWN5KQoreworICAgIFN0cmluZyByZWZlcnJlciA9IHJlcXVl c3QuaHR0cFJlZmVycmVyKCk7CisgICAgaWYgKHJlZmVycmVyLmlzRW1wdHkoKSkKKyAgICAgICAg cmVmZXJyZXIgPSBtX291dGdvaW5nUmVmZXJyZXI7CisgICAgaWYgKFNlY3VyaXR5T3JpZ2luOjpz aG91bGRIaWRlUmVmZXJyZXIocmVxdWVzdC51cmwoKSwgcmVmZXJyZXIpIHx8IHJlZmVycmVyUG9s aWN5ID09IE5vUmVmZXJyZXIpCisgICAgICAgIHJlZmVycmVyID0gU3RyaW5nKCk7CisKKyAgICBp ZiAoIXJlZmVycmVyLmlzRW1wdHkoKSkgeworICAgICAgICByZXF1ZXN0LnNldEhUVFBSZWZlcnJl cihyZWZlcnJlcik7CisgICAgICAgIFJlZlB0cjxTZWN1cml0eU9yaWdpbj4gcmVmZXJyZXJPcmln aW4gPSBTZWN1cml0eU9yaWdpbjo6Y3JlYXRlRnJvbVN0cmluZyhyZWZlcnJlcik7CisgICAgICAg IGFkZEhUVFBPcmlnaW5JZk5lZWRlZChyZXF1ZXN0LCByZWZlcnJlck9yaWdpbi0+dG9TdHJpbmco KSk7CisgICAgfSBlbHNlCisgICAgICAgIHJlcXVlc3QuY2xlYXJIVFRQUmVmZXJyZXIoKTsKKwor ICAgIGFkZEV4dHJhRmllbGRzVG9NYWluUmVzb3VyY2VSZXF1ZXN0KHJlcXVlc3QpOworfQorCiB2 b2lkIEZyYW1lTG9hZGVyOjpsb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgYm9v bCBsb2NrSGlzdG9yeSkKIHsKICAgICBsb2FkKHJlcXVlc3QsIFN1YnN0aXR1dGVEYXRhKCksIGxv Y2tIaXN0b3J5KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRl ci5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgKaW5kZXggYTIzNmZiYy4u MmEzOTgxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmgKQEAgLTI3Miw2ICsyNzIs OCBAQCBwdWJsaWM6CiAgICAgCiAgICAgdm9pZCBzdGFydGVkKCk7CiAKKyAgICB2b2lkIHByZXBh cmVSZXNvdXJjZVJlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiwgUmVmZXJyZXJQb2xpY3kpOworCiAg ICAgZW51bSBQYWdlRGlzbWlzc2FsVHlwZSB7CiAgICAgICAgIE5vRGlzbWlzc2FsID0gMCwKICAg ICAgICAgQmVmb3JlVW5sb2FkRGlzbWlzc2FsID0gMSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0Zy YW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggMzg1MjM4My4uYWEwZjJmMiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKQEAgLTE3OSw3ICsxNzksNyBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgICAgIAogICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1l RG9jdW1lbnRSZWFkeShib29sKSA9IDA7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93 bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikgPSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQg c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3Ry aW5nKCkpID0gMDsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3Vt ZW50TG9hZGVyKikgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9j dW1lbnRMb2FkZXIqKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDQwNDU4MzEu LmI3MWM1OWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIw MTEtMDctMTYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgor CisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD1maWxlbmFtZSBmb3IgYW5jaG9ycy4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwdWJsaWMv V2ViRnJhbWVDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViRnJhbWVDbGllbnQ6OmxvYWRV UkxFeHRlcm5hbGx5KToKKyAgICAgICAgKiBzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcDoK KyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRJbXBsOjpkaXNwYXRjaERlY2lkZVBv bGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNs aWVudEltcGw6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIHNyYy9GcmFtZUxvYWRlckNsaWVu dEltcGwuaDoKKwogMjAxMS0wNy0xNCAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4K IAogICAgICAgICBSb2xsZWQgQ2hyb21pdW0gcmV2aXNpb24gdG8gOTI2MDYuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaAppbmRleCBiMTkzZmVjLi4w YWY5NmNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFt ZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xp ZW50LmgKQEAgLTExNiw2ICsxMTYsOCBAQCBwdWJsaWM6CiAgICAgLy8gVGhlIGNsaWVudCBzaG91 bGQgaGFuZGxlIHRoZSBuYXZpZ2F0aW9uIGV4dGVybmFsbHkuCiAgICAgdmlydHVhbCB2b2lkIGxv YWRVUkxFeHRlcm5hbGx5KAogICAgICAgICBXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3Qm LCBXZWJOYXZpZ2F0aW9uUG9saWN5KSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVy bmFsbHkoCisgICAgICAgIFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYsIFdlYk5hdmln YXRpb25Qb2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWROYW1lKSB7IH0KIAogCiAgICAg Ly8gTmF2aWdhdGlvbmFsIHF1ZXJpZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9G cmFtZUxvYWRlckNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJh bWVMb2FkZXJDbGllbnRJbXBsLmNwcAppbmRleCA3OWRkZDY4Li5hMmZkMTAwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAK QEAgLTk0NCw3ICs5NDQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hE ZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKAogICAgIFBvbGljeUFjdGlvbiBwb2xpY3lB Y3Rpb24gPSBQb2xpY3lJZ25vcmU7CiAKICAgICAvLyBJdCBpcyB2YWxpZCBmb3IgdGhpcyBmdW5j dGlvbiB0byBiZSBpbnZva2VkIGluIGNvZGUgcGF0aHMgd2hlcmUgdGhlCi0gICAgLy8gdGhlIHdl YnZpZXcgaXMgY2xvc2VkLgorICAgIC8vIHdlYnZpZXcgaXMgY2xvc2VkLgogICAgIC8vIFRoZSBu dWxsIGNoZWNrIGhlcmUgaXMgdG8gZml4IGEgY3Jhc2ggdGhhdCBzZWVtcyBzdHJhbmdlCiAgICAg Ly8gKHNlZSAtIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzU1NCku CiAgICAgaWYgKG1fd2ViRnJhbWUtPmNsaWVudCgpICYmICFyZXF1ZXN0LnVybCgpLmlzTnVsbCgp KSB7CkBAIC0xMDczLDcgKzEwNzMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c2V0 TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sIHJlYWR5KQogCiAvLyBDcmVhdGVzIGEgbmV3IGNv bm5lY3Rpb24gYW5kIGJlZ2lucyBkb3dubG9hZGluZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMK IC8vIHdpdGggfGRvd25sb2FkfCkuCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVy Q2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3Qs IGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xp ZW50KCkpIHsKICAgICAgICAgV3JhcHBlZFJlc291cmNlUmVxdWVzdCB3ZWJyZXEocmVxdWVzdCk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVu dEltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1w bC5oCmluZGV4IGFkYWY5ZDMuLmYxZjAyNGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCkBAIC0xMzEsNyArMTMxLDcgQEAgcHVi bGljOgogICAgIHZpcnR1YWwgdm9pZCBwb3N0UHJvZ3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmlj YXRpb24oKTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFByb2dyZXNzRmluaXNoZWROb3RpZmljYXRp b24oKTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsK LSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJl cXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgIHZpcnR1YWwg dm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0 dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2 aXJ0dWFsIHZvaWQgY29tbWl0dGVkTG9hZChXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0 IGNoYXIqLCBpbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nCmluZGV4IDY4M2E0MTcuLjk0ODNiMWYgMTAwNzU1 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0xNiAgU2FkcnVsIEhhYmliIENo b3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9y IGRvd25sb2FkPWZpbGVuYW1lIGZvciBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 RWZsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50RWZsOjpzdGFydERv d25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5o OgorCiAyMDExLTA3LTE0ICBKYWVodW4gTGltICA8bGphZWh1bi5saW1Ac2Ftc3VuZy5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcCBiL1NvdXJjZS9X ZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAppbmRleCA5 ZTI3NTdmLi45YTJkZmNmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3BwCkBAIC04NzEsNyArODcxLDcgQEAg dm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoRG9jdW1lbnRM b2FkZXIqIGxvYWRlciwgY29uc3QgUmUKICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0g ZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29u c3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6 c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmlu ZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBpZiAoIW1fdmlldykKICAgICAgICAgcmV0dXJuOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRFZmwuaCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50RWZsLmgKaW5kZXggNDdhYjNkNC4uOWU2ZDFjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCkBAIC0x NTMsNyArMTUzLDcgQEAgY2xhc3MgRnJhbWVMb2FkZXJDbGllbnRFZmwgOiBwdWJsaWMgRnJhbWVM b2FkZXJDbGllbnQgewogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVh ZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJj ZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lk IHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRD aGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9n dGsvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDU4Njc3MWEu LmRhMDc1YzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0xNiAg U2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg QWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPWZpbGVuYW1lIGZvciBhbmNob3JzLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGll bnQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmg6CisKIDIwMTEtMDctMTQgIEx1a2FzeiBTbGFjaGNpYWsgIDxsLnNsYWNoY2lh a0BzYW1zdW5nLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBHdXN0YXZvIE5vcm9uaGEuCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudEd0ay5jcHAKaW5kZXggMzE2NDI1Yy4uNWU2Y2ZhMSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cApAQCAtMTMyNiw3ICsxMzI2LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c2V0TWFpbkRv Y3VtZW50RXJyb3IoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXMKICAgICB9CiB9 CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VS ZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChj b25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFt ZSkKIHsKICAgICBHUmVmUHRyPFdlYktpdE5ldHdvcmtSZXF1ZXN0PiBuZXR3b3JrUmVxdWVzdChh ZG9wdEdSZWYoa2l0TmV3KHJlcXVlc3QpKSk7CiAgICAgV2ViS2l0V2ViVmlldyogdmlldyA9IGdl dFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oIGIvU291cmNlL1dlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaAppbmRleCAyNDQ4MjlmLi43YzU4 MzIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmgKQEAgLTEzMCw3ICsxMzAsNyBAQCBuYW1lc3BhY2UgV2ViS2l0 IHsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29s KTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29u c3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsK IAogICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50 TG9hZGVyKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpE b2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VM b2cgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L0NoYW5nZUxvZwppbmRleCAzNzI0OWUzLi5jMjgzMDY3 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L0NoYW5nZUxvZworKysgYi9Tb3VyY2Uv V2ViS2l0L2hhaWt1L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTE2ICBTYWRy dWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQg c3VwcG9ydCBmb3IgZG93bmxvYWQ9ZmlsZW5hbWUgZm9yIGFuY2hvcnMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRIYWlrdS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVu dEhhaWt1OjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEhhaWt1Lmg6CisKIDIwMTEtMDctMTIgIEpvc2VwaCBQZWNvcmFybyAgPGpvZXBl Y2tAd2Via2l0Lm9yZz4KIAogICAgICAgICBBcHBsaWNhdGlvbkNhY2hlIHVwZGF0ZSBzaG91bGQg bm90IGltbWVkaWF0ZWx5IGZhaWwgd2hlbiByZWFjaGluZyBwZXItb3JpZ2luIHF1b3RhCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50SGFpa3UuY3BwIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEhhaWt1LmNwcAppbmRleCAyODVhM2ZhLi4wYzQ2OGFmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3Uu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRIYWlrdS5jcHAKQEAgLTcwOSw3ICs3MDksNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 SGFpa3U6OmRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJv cgogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlr dTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRl ckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0 IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEhhaWt1LmggYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50SGFpa3UuaAppbmRleCA3OWVlOTE0Li45ZTg3MDkyIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAor KysgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 SGFpa3UuaApAQCAtMjE5LDcgKzIxOSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNz UmVmUHRyPEZvcm1TdGF0ZT4pOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVU b0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZp cnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0 cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHByb2Jh Ymx5IG5vdCBiZSBoZXJlLCBidXQgaXQncyBuZWVkZWQgZm9yIHRoZSB0ZXN0cyBjdXJyZW50bHku CiAgICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cK aW5kZXggODU3MzYzNS4uZDMxZTI4OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAor MjAxMS0wNy0xNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPWZpbGVuYW1lIGZvciBhbmNob3Jz LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oOgorCiAyMDExLTA3LTEzICBKb3NlcGggUGVjb3Jhcm8g IDxqb2VwZWNrQHdlYmtpdC5vcmc+CiAKICAgICAgICAgSW1wcm92ZSBuYW1lcyBvZiBzb21lIEFw cGxpY2F0aW9uQ2FjaGVTdG9yYWdlIGFjY2Vzc29yIG1ldGhvZHMKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCmluZGV4 IDhlYzdmNjAuLjE3ODZmYTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9xdC9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcApAQCAtMTI5Myw3ICsxMjkzLDcgQEAg dm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5 KGNvbnN0IFdlYkNvcmU6OlJlc291cmMKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lk IEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpzdGFydERvd25s b2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5n JiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmICghbV93ZWJGcmFtZSkKICAgICAgICAgcmV0dXJu OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFF0LmggYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50UXQuaAppbmRleCAxMjEzMDNkLi45MThmYjIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAorKysgYi9Tb3VyY2Uv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaApAQCAtMTQ5LDcg KzE0OSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVu dFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygp KTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsK ICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvd2luL0No YW5nZUxvZwppbmRleCA5MzEyN2I2Li4wNjhkNmNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L3dpbi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC93aW4vQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTQgQEAKKzIwMTEtMDctMTYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hy b21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD1maWxlbmFtZSBm b3IgYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgKiBXZWJGcmFtZS5jcHA6CisgICAgICAgIChXZWJGcmFtZTo6c3RhcnREb3dubG9hZCk6Cisg ICAgICAgICogV2ViRnJhbWUuaDoKKwogMjAxMS0wNy0xMiAgSm9zZXBoIFBlY29yYXJvICA8am9l cGVja0B3ZWJraXQub3JnPgogCiAgICAgICAgIEFwcGxpY2F0aW9uQ2FjaGUgdXBkYXRlIHNob3Vs ZCBub3QgaW1tZWRpYXRlbHkgZmFpbCB3aGVuIHJlYWNoaW5nIHBlci1vcmlnaW4gcXVvdGEKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcCBiL1NvdXJjZS9XZWJLaXQv d2luL1dlYkZyYW1lLmNwcAppbmRleCBiOGJiMjQ5Li5mZDU5MGYwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJh bWUuY3BwCkBAIC0xOTA3LDcgKzE5MDcsNyBAQCB2b2lkIFdlYkZyYW1lOjpkaXNwYXRjaERpZEZh aWxMb2FkKGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9yKQogICAgIH0KIH0KIAotdm9pZCBXZWJG cmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lk IFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwg Y29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGQtPndlYlZpZXctPmRvd25sb2Fk VVJMKHJlcXVlc3QudXJsKCkpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW4vV2Vi RnJhbWUuaCBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgKaW5kZXggODA0NmQ4NS4uNzcz OTUwZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaAorKysgYi9Tb3Vy Y2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oCkBAIC0zNDIsNyArMzQyLDcgQEAgcHVibGljOgogICAg IHZpcnR1YWwgYm9vbCBkaXNwYXRjaERpZExvYWRSZXNvdXJjZUZyb21NZW1vcnlDYWNoZShXZWJD b3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmLCBpbnQgbGVuZ3RoKTsKICAgICB2aXJ0dWFs IHZvaWQgZGlzcGF0Y2hEaWRGYWlsUHJvdmlzaW9uYWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlRXJyb3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWlsTG9hZChjb25zdCBX ZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7Ci0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0 RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9 IFN0cmluZygpKTsKICAgICAgICAgCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYkNvcmU6Oldp ZGdldD4gY3JlYXRlSmF2YUFwcGxldFdpZGdldChjb25zdCBXZWJDb3JlOjpJbnRTaXplJiwgV2Vi Q29yZTo6SFRNTEFwcGxldEVsZW1lbnQqLCBjb25zdCBXZWJDb3JlOjpLVVJMJiBiYXNlVVJMLCBj b25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbU5hbWVzLCBjb25zdCBWZWN0b3I8V1RGOjpT dHJpbmc+JiBwYXJhbVZhbHVlcyk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luY2Uv Q2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKaW5kZXggZjY4OWRkYy4u ZDQ4OGM1NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0x NiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPWZpbGVuYW1lIGZvciBhbmNob3JzLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRl ckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFdpbkNFLmg6CisKIDIwMTEtMDctMTIgIEpvc2VwaCBQZWNvcmFybyAg PGpvZXBlY2tAd2Via2l0Lm9yZz4KIAogICAgICAgICBBcHBsaWNhdGlvbkNhY2hlIHVwZGF0ZSBz aG91bGQgbm90IGltbWVkaWF0ZWx5IGZhaWwgd2hlbiByZWFjaGluZyBwZXItb3JpZ2luIHF1b3Rh CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50V2luQ0UuY3BwIGIvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcAppbmRleCA2NGMxMGZlLi5kYjZlZjYzIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 V2luQ0UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRXaW5DRS5jcHAKQEAgLTU5Nyw3ICs1OTcsNyBAQCB2b2lkIEZyYW1lTG9hZGVy Q2xpZW50V2luQ0U6OnNldE1haW5Eb2N1bWVudEVycm9yKERvY3VtZW50TG9hZGVyKiwgY29uc3Qg UmVzb3VyYwogICAgIG1faGFzU2VudFJlc3BvbnNlVG9QbHVnaW4gPSBmYWxzZTsKIH0KIAotdm9p ZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0 ZWROYW1lKQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaCBiL1Nv dXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5o CmluZGV4IDZiZWFiMGQuLjlhMmUyNzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luY2Uv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCisrKyBiL1NvdXJjZS9XZWJL aXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCkBAIC0xMjUs NyArMTI1LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3Vt ZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9h ZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5n KCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVu dExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1 bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93eC9DaGFuZ2VMb2cgYi9T b3VyY2UvV2ViS2l0L3d4L0NoYW5nZUxvZwppbmRleCBlYTRkNWNhLi45ODNjYjVhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L3d4L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L3d4L0No YW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTE2ICBTYWRydWwgSGFiaWIgQ2hvd2Ro dXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93 bmxvYWQ9ZmlsZW5hbWUgZm9yIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQp OgorICAgICAgICAqIFdlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oOgorCiAyMDEx LTA3LTEyICBKb3NlcGggUGVjb3Jhcm8gIDxqb2VwZWNrQHdlYmtpdC5vcmc+CiAKICAgICAgICAg QXBwbGljYXRpb25DYWNoZSB1cGRhdGUgc2hvdWxkIG5vdCBpbW1lZGlhdGVseSBmYWlsIHdoZW4g cmVhY2hpbmcgcGVyLW9yaWdpbiBxdW90YQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93eC9X ZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwIGIvU291cmNlL1dlYktpdC93eC9X ZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwCmluZGV4IGQxNmY2NzcuLjllNTEy ZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFd4LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRXeC5jcHAKQEAgLTg0MCw3ICs4NDAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50V3g6OmRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJv ciYpCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudFd4 OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVy Q2xpZW50V3g6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3Ry aW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5o IGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaApp bmRleCAwYWZkYWQ5Li4yMGYwODEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktp dFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvd3gvV2Vi S2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKQEAgLTIwNiw3ICsyMDYsNyBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaERlY2lkZVBvbGlj eUZvck5hdmlnYXRpb25BY3Rpb24oRnJhbWVQb2xpY3lGdW5jdGlvbiBmdW5jdGlvbiwgY29uc3Qg TmF2aWdhdGlvbkFjdGlvbiYsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIFBhc3NSZWZQdHI8Rm9y bVN0YXRlPik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50 UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3Rh cnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lk IHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0 cmluZygpKTsKICAgICAgICAgCiAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJs eSBub3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVlZGVkIGZvciB0aGUgdGVzdHMgY3VycmVudGx5CiAg ICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA0 Y2JmNmMxLi4yMzcwNDlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDctMTYg IFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAg IEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD1maWxlbmFtZSBmb3IgYW5jaG9ycy4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNv cmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2Vi RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYlByb2Nlc3Mv V2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaDoKKyAgICAgICAgKiBXZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZTo6c3Rh cnREb3dubG9hZCk6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmg6CisK IDIwMTEtMDctMTUgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IE1hcnRpbiBSb2JpbnNvbi4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQu Y3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxv YWRlckNsaWVudC5jcHAKaW5kZXggYWU3MDA2OC4uM2E2N2YwYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFt ZUxvYWRlckNsaWVudC5jcHAKQEAgLTc4OSw3ICs3ODksNyBAQCB2b2lkIFdlYkZyYW1lTG9hZGVy Q2xpZW50OjpzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpCiAgICAgbm90SW1wbGVtZW50 ZWQoKTsKIH0KIAotdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50Ojpz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5n JiBzdWdnZXN0ZWROYW1lKQogewogICAgIG1fZnJhbWUtPnN0YXJ0RG93bmxvYWQocmVxdWVzdCk7 CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNv cmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggNTZlZjdlYS4uY2U4NDNmMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJG cmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29y ZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaApAQCAtMTIyLDcgKzEyMiw3IEBAIHByaXZh dGU6CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9v bCk7CiAgICAgCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAg ICAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9h ZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50 TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViRnJhbWUuY3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1l LmNwcAppbmRleCA0NmY5OWUzLi41NTQwYTAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5jcHAKQEAgLTIxNSw3ICsyMTUsNyBAQCB2b2lkIFdlYkZy YW1lOjpkaWRSZWNlaXZlUG9saWN5RGVjaXNpb24odWludDY0X3QgbGlzdGVuZXJJRCwgUG9saWN5 QWN0aW9uIGFjdGlvbgogICAgIChtX2NvcmVGcmFtZS0+bG9hZGVyKCktPnBvbGljeUNoZWNrZXIo KS0+KmZ1bmN0aW9uKShhY3Rpb24pOwogfQogCi12b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2Fk KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6 OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBj b25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgQVNTRVJUKG1fcG9saWN5RG93bmxv YWRJRCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9X ZWJGcmFtZS5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgK aW5kZXggOTc1NzEyZC4uOTA2MGEzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJQYWdlL1dlYkZyYW1lLmgKQEAgLTcwLDcgKzcwLDcgQEAgcHVibGljOgogICAgIHZvaWQgaW52 YWxpZGF0ZVBvbGljeUxpc3RlbmVyKCk7CiAgICAgdm9pZCBkaWRSZWNlaXZlUG9saWN5RGVjaXNp b24odWludDY0X3QgbGlzdGVuZXJJRCwgV2ViQ29yZTo6UG9saWN5QWN0aW9uLCB1aW50NjRfdCBk b3dubG9hZElEKTsKIAotICAgIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QmKTsKKyAgICB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICB2b2lkIGNvbnZl cnRIYW5kbGVUb0Rvd25sb2FkKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlKiwgY29uc3QgV2ViQ29y ZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiBpbml0 aWFsUmVxdWVzdCwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSYpOwogCiAgICAgU3Ry aW5nIHNvdXJjZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMv Q2hhbmdlTG9nCmluZGV4IDJjNmNhODguLmY5YzM2YWEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5n ZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0xNiAg U2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg QWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPWZpbGVuYW1lIGZvciBhbmNob3JzLgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2No cm9taXVtL1dlYlZpZXdIb3N0LmNwcDoKKyAgICAgICAgKFdlYlZpZXdIb3N0Ojpsb2FkVVJMRXh0 ZXJuYWxseSk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3Qu aDoKKwogMjAxMS0wNy0xNSAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAg ICAgIE5SV1Qgc3RvcmVzIHRoZSBDaHJvbWl1bSByZXZpc2lvbiBudW1iZXIgaW4gZnVsbF9yZXN1 bHRzLmpzb24KZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZp ZXdIb3N0LmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNw cAppbmRleCA2ZmIzMDkxLi5mODllYjIxIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vV2ViVmlld0hvc3QuY3BwCkBAIC03OTksNyArNzk5LDEyIEBAIGJvb2wgV2ViVmlld0hv c3Q6OmFsbG93SW1hZ2VzKFdlYkZyYW1lKiBmcmFtZSwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3Mp CiAgICAgcmV0dXJuIGVuYWJsZWRQZXJTZXR0aW5nczsKIH0KIAotdm9pZCBXZWJWaWV3SG9zdDo6 bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0 LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSkKK3ZvaWQgV2ViVmlld0hvc3Q6OmxvYWRVUkxF eHRlcm5hbGx5KFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVxdWVzdCwg V2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3kpCit7CisgICAgbG9hZFVSTEV4dGVybmFsbHkoZnJh bWUsIHJlcXVlc3QsIHBvbGljeSwgV2ViU3RyaW5nKCkpOworfQorCit2b2lkIFdlYlZpZXdIb3N0 Ojpsb2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVl c3QsIFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5LCBjb25zdCBXZWJTdHJpbmcmIGRvd25sb2Fk TmFtZSkKIHsKICAgICBBU1NFUlQocG9saWN5ICE9ICBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xp Y3lDdXJyZW50VGFiKTsKICAgICBXZWJWaWV3SG9zdCogYW5vdGhlciA9IG1fc2hlbGwtPmNyZWF0 ZU5ld1dpbmRvdyhyZXF1ZXN0LnVybCgpKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1 bS9XZWJWaWV3SG9zdC5oCmluZGV4IDI5NTFhZmYuLmVjNzhhOTIgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKKysrIGIvVG9vbHMvRHVtcFJl bmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaApAQCAtMTc0LDYgKzE3NCw3IEBAIGNsYXNz IFdlYlZpZXdIb3N0IDogcHVibGljIFdlYktpdDo6V2ViU3BlbGxDaGVja0NsaWVudCwgcHVibGlj IFdlYktpdDo6V2ViVmlld0NsCiAgICAgIHZpcnR1YWwgYm9vbCBhbGxvd1BsdWdpbnMoV2ViS2l0 OjpXZWJGcmFtZSosIGJvb2wgZW5hYmxlZFBlclNldHRpbmdzKTsKICAgICB2aXJ0dWFsIGJvb2wg YWxsb3dJbWFnZXMoV2ViS2l0OjpXZWJGcmFtZSosIGJvb2wgZW5hYmxlZFBlclNldHRpbmdzKTsK ICAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNv bnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSk7 CisgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5KFdlYktpdDo6V2ViRnJhbWUqLCBj b25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLCBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xpY3ks IGNvbnN0IFdlYktpdDo6V2ViU3RyaW5nJiBkb3dubG9hZE5hbWUpOwogICAgIHZpcnR1YWwgV2Vi S2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5IGRlY2lkZVBvbGljeUZvck5hdmlnYXRpb24oCiAgICAg ICAgIFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLAogICAg ICAgICBXZWJLaXQ6OldlYk5hdmlnYXRpb25UeXBlLCBjb25zdCBXZWJLaXQ6OldlYk5vZGUmLAo= 101736 2011-07-22 09:04:48 -0700 2011-07-22 09:56:02 -0700 updated webkit-a-download.patch text/plain 24567 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmE5NmZiNjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEgQEAKK0Jsb2IgVVJMCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1ZGI1YTIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbApAQCAt MCwwICsxLDI5IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5 cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7 CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxh IGlkPSJibG9iLXVybCIgZG93bmxvYWQ+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24g cnVuVGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRCbG9iQnVpbGRlcigpOworICBiYi5h cHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgIHZhciBibG9iID0gYmIu Z2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2YXIgbGluayA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJM LmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZl bnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2ZW50KCdjbGljaycsIHRydWUsIHRy dWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdlZjIyZTkKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It bm9kb3dubG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rv d25sb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2Y1Y2ZiMgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50 L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKQEAgLTAsMCArMSwzMCBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPgoraWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK30KKzwv c2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxvYi11cmwiPkJsb2IgVVJMPC9hPgor PHNjcmlwdD4KK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICB2YXIgYmIgPSBuZXcgV2ViS2l0Qmxv YkJ1aWxkZXIoKTsKKyAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRtbD48aHRtbD48aGVhZD48dGl0 bGU+VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIgKyAic2NyaXB0PjwvaGVhZD48 Ym9keT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2NyIiArICJpcHQ+PC9odG1sPiIp OworICB2YXIgYmxvYiA9IGJiLmdldEJsb2IoInRleHQvaHRtbCIsICJpbmxpbmUiKTsKKyAgdmFy IGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgbGluay5ocmVm ID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwoYmxvYik7CisKKyAgdmFyIGV2dCA9 IGRvY3VtZW50LmNyZWF0ZUV2ZW50KCJNb3VzZUV2ZW50Iik7CisgIGV2dC5pbml0TW91c2VFdmVu dCgnY2xpY2snLCB0cnVlLCB0cnVlKTsKKyAgbGluay5kaXNwYXRjaEV2ZW50KGV2dCk7Cit9City dW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAppbmRleCBhYTcyYWQ3Li41MDZkY2ZkIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcApAQCAtMjcsNiArMjcsNyBAQAog I2luY2x1ZGUgIkF0dHJpYnV0ZS5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCiAjaW5jbHVkZSAiRnJh bWVMb2FkZXJUeXBlcy5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRl ICJIVE1MTmFtZXMuaCIKQEAgLTE0NywxMCArMTQ4LDcgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVu dDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAgIH0KIAogICAgICAg ICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShl dmVudFR5cGUoZXZlbnQpKSkgewotICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGlu Z0FuZFRyYWlsaW5nSFRNTFNwYWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAg ICAgIGFwcGVuZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAg ICBoYW5kbGVMaW5rQ2xpY2soZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRh cmdldEF0dHIpLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5k UGluZ3MoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVD bGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYg KzQ5MCwzNiBAQCB2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgS1VSTCYg ZGVzdGluYXRpb25VUkwpCiAgICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5nKGRvY3VtZW50KCkt PmZyYW1lKCksIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ldKSwgZGVzdGluYXRp b25VUkwpOwogfQogCit2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVDbGljayhFdmVudCog ZXZlbnQpCit7CisgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSog ZnJhbWUgPSBkb2N1bWVudCgpLT5mcmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJl dHVybjsKKworICAgIFN0cmluZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFj ZXMoZmFzdEdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGFwcGVuZFNlcnZlck1hcE1vdXNl UG9zaXRpb24odXJsLCBldmVudCk7CisgICAgS1VSTCBrdXJsID0gZG9jdW1lbnQoKS0+Y29tcGxl dGVVUkwodXJsKTsKKworICAgIGJvb2wgZG93bmxvYWQgPSBoYXNBdHRyaWJ1dGUoZG93bmxvYWRB dHRyKTsKKyAgICBpZiAoZG93bmxvYWQpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVl c3Qoa3VybCk7CisKKyAgICAgICAgaWYgKCFoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSkgewor ICAgICAgICAgICAgU3RyaW5nIHJlZmVycmVyID0gZnJhbWUtPmxvYWRlcigpLT5vdXRnb2luZ1Jl ZmVycmVyKCk7CisgICAgICAgICAgICBpZiAoIXJlZmVycmVyLmlzRW1wdHkoKSkKKyAgICAgICAg ICAgICAgICByZXF1ZXN0LnNldEhUVFBSZWZlcnJlcihyZWZlcnJlcik7CisgICAgICAgICAgICBm cmFtZS0+bG9hZGVyKCktPmFkZEV4dHJhRmllbGRzVG9NYWluUmVzb3VyY2VSZXF1ZXN0KHJlcXVl c3QpOworICAgICAgICB9CisKKyAgICAgICAgZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+c3Rh cnREb3dubG9hZChyZXF1ZXN0LCBmYXN0R2V0QXR0cmlidXRlKGRvd25sb2FkQXR0cikpOworICAg IH0gZWxzZQorICAgICAgICBmcmFtZS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGt1cmwsIHRhcmdl dCgpLCBldmVudCwgZmFsc2UsIGZhbHNlLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSA/IE5v UmVmZXJyZXIgOiBTZW5kUmVmZXJyZXIpOworCisgICAgc2VuZFBpbmdzKGt1cmwpOworfQorCiBI VE1MQW5jaG9yRWxlbWVudDo6RXZlbnRUeXBlIEhUTUxBbmNob3JFbGVtZW50OjpldmVudFR5cGUo RXZlbnQqIGV2ZW50KQogewogICAgIGlmICghZXZlbnQtPmlzTW91c2VFdmVudCgpKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCmluZGV4IDg2MGFkMzUuLjk0N2Y3NDYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKQEAgLTExNSw2ICsxMTUsOCBA QCBwcml2YXRlOgogCiAgICAgdm9pZCBzZW5kUGluZ3MoY29uc3QgS1VSTCYgZGVzdGluYXRpb25V UkwpOwogCisgICAgdm9pZCBoYW5kbGVDbGljayhFdmVudCopOworCiAgICAgZW51bSBFdmVudFR5 cGUgewogICAgICAgICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5LAogICAgICAgICBNb3VzZUV2 ZW50V2l0aFNoaWZ0S2V5LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5j aG9yRWxlbWVudC5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50Lmlk bAppbmRleCA4NzFmY2RmLi4xZTljMTFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxBbmNob3JFbGVtZW50LmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNo b3JFbGVtZW50LmlkbApAQCAtMjYsNiArMjYsNyBAQCBtb2R1bGUgaHRtbCB7CiAgICAgICAgIGF0 dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGFjY2Vzc0tleTsKICAgICAgICAgYXR0cmlidXRl IFtSZWZsZWN0XSBET01TdHJpbmcgY2hhcnNldDsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0 XSBET01TdHJpbmcgY29vcmRzOworICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmlu ZyBkb3dubG9hZDsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0LCBVUkxdIERPTVN0cmluZyBo cmVmOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBocmVmbGFuZzsKICAg ICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgbmFtZTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KaW5kZXggMTY3OWU5Ni4uODQxMGRlNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KQEAgLTkxLDYgKzkxLDcgQEAg ZGVmZXIKIGRpcgogZGlyZWN0aW9uCiBkaXNhYmxlZAorZG93bmxvYWQKIGRyYWdnYWJsZQogd2Vi a2l0ZHJvcHpvbmUKIGVuY3R5cGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9F bXB0eUNsaWVudHMuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAppbmRl eCA3ODViMTJjLi5kMGIyMGE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1w dHlDbGllbnRzLmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCkBA IC0zMTAsNyArMzEwLDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFt ZURvY3VtZW50UmVhZHkoYm9vbCkgeyB9CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpIHsg fQogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsg fQogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsgfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmggYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAppbmRleCAzODUyMzgzLi5h YTBmMmYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGll bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaApAQCAt MTc5LDcgKzE3OSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAgICAgICAgIHZp cnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpID0gMDsKIAotICAgICAg ICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKSA9IDA7 CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVz dCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkgPSAwOwogCiAgICAgICAgIHZpcnR1YWwgdm9p ZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CiAgICAgICAgIHZpcnR1YWwg dm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmggYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oCmluZGV4IGIxOTNmZWMuLjBhZjk2 Y2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xp ZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQu aApAQCAtMTE2LDYgKzExNiw4IEBAIHB1YmxpYzoKICAgICAvLyBUaGUgY2xpZW50IHNob3VsZCBo YW5kbGUgdGhlIG5hdmlnYXRpb24gZXh0ZXJuYWxseS4KICAgICB2aXJ0dWFsIHZvaWQgbG9hZFVS TEV4dGVybmFsbHkoCiAgICAgICAgIFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYsIFdl Yk5hdmlnYXRpb25Qb2xpY3kpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxs eSgKKyAgICAgICAgV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiwgV2ViTmF2aWdhdGlv blBvbGljeSwgY29uc3QgV2ViU3RyaW5nJiBkb3dubG9hZE5hbWUpIHsgfQogCiAKICAgICAvLyBO YXZpZ2F0aW9uYWwgcXVlcmllcyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1l TG9hZGVyQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxv YWRlckNsaWVudEltcGwuY3BwCmluZGV4IDc5ZGRkNjguLmEyZmQxMDAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcApAQCAt OTQ0LDcgKzk0NCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpkaXNwYXRjaERlY2lk ZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24oCiAgICAgUG9saWN5QWN0aW9uIHBvbGljeUFjdGlv biA9IFBvbGljeUlnbm9yZTsKIAogICAgIC8vIEl0IGlzIHZhbGlkIGZvciB0aGlzIGZ1bmN0aW9u IHRvIGJlIGludm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUKLSAgICAvLyB0aGUgd2Vidmll dyBpcyBjbG9zZWQuCisgICAgLy8gd2VidmlldyBpcyBjbG9zZWQuCiAgICAgLy8gVGhlIG51bGwg Y2hlY2sgaGVyZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKICAgICAvLyAo c2VlIC0gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzNTU0KS4KICAg ICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3QudXJsKCkuaXNOdWxsKCkpIHsK QEAgLTEwNzMsNyArMTA3Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpzZXRNYWlu RnJhbWVEb2N1bWVudFJlYWR5KGJvb2wgcmVhZHkpCiAKIC8vIENyZWF0ZXMgYSBuZXcgY29ubmVj dGlvbiBhbmQgYmVnaW5zIGRvd25sb2FkaW5nIGZyb20gdGhhdCAoY29udHJhc3QgdGhpcwogLy8g d2l0aCB8ZG93bmxvYWR8KS4KLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpzdGFydERvd25s b2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGll bnRJbXBsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29u c3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmIChtX3dlYkZyYW1lLT5jbGllbnQo KSkgewogICAgICAgICBXcmFwcGVkUmVzb3VyY2VSZXF1ZXN0IHdlYnJlcShyZXF1ZXN0KTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1w bC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgK aW5kZXggYWRhZjlkMy4uZjFmMDI0ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKQEAgLTEzMSw3ICsxMzEsNyBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIHBvc3RQcm9ncmVzc0VzdGltYXRlQ2hhbmdlZE5vdGlmaWNhdGlv bigpOwogICAgIHZpcnR1YWwgdm9pZCBwb3N0UHJvZ3Jlc3NGaW5pc2hlZE5vdGlmaWNhdGlvbigp OwogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwotICAg IHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgdmlydHVhbCB2b2lk IHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwg dm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1 YWwgdm9pZCBjb21taXR0ZWRMb2FkKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgY2hh ciosIGludCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEVmbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHAKaW5kZXggOWUyNzU3Zi4uOWEyZGZjZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRF ZmwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50RWZsLmNwcApAQCAtODcxLDcgKzg3MSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRF Zmw6OnNldE1haW5Eb2N1bWVudEVycm9yKERvY3VtZW50TG9hZGVyKiBsb2FkZXIsIGNvbnN0IFJl CiAgICAgbV9oYXNTZW50UmVzcG9uc2VUb1BsdWdpbiA9IGZhbHNlOwogfQogCi12b2lkIEZyYW1l TG9hZGVyQ2xpZW50RWZsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVx dWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAg ICAgaWYgKCFtX3ZpZXcpCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmggYi9Tb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCmluZGV4IDQ3YWIz ZDQuLjllNmQxY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaApAQCAtMTUzLDcgKzE1Myw3IEBAIGNsYXNzIEZy YW1lTG9hZGVyQ2xpZW50RWZsIDogcHVibGljIEZyYW1lTG9hZGVyQ2xpZW50IHsKIAogICAgIHZp cnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5n JiA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1l bnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2Fk ZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCAyNmM1MzRlLi41MmUzNzZjIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5j cHAKKysrIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCkBAIC0xMjIxLDcgKzEyMjEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojpz ZXRNYWluRG9jdW1lbnRFcnJvcihXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlcwog ICAgIH0KIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERv d25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdn ZXN0ZWROYW1lKQogewogICAgIEdSZWZQdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+IG5ldHdvcmtS ZXF1ZXN0KGFkb3B0R1JlZihraXROZXcocmVxdWVzdCkpKTsKICAgICBXZWJLaXRXZWJWaWV3KiB2 aWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmggYi9Tb3VyY2UvV2Vi S2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCmluZGV4IDI0NDgy OWYuLjdjNTgzMjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKKysrIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaApAQCAtMTMwLDcgKzEzMCw3IEBAIG5hbWVzcGFj ZSBXZWJLaXQgewogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJl YWR5KGJvb2wpOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3Ry aW5nKCkpOwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6 RG9jdW1lbnRMb2FkZXIqKTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdl YkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwIGIvU291cmNlL1dlYktp dC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcAppbmRleCAy ODVhM2ZhLi4wYzQ2OGFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFp a3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKQEAgLTcwOSw3ICs3 MDksNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OmRpc3BhdGNoVW5hYmxlVG9JbXBs ZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvcgogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9 CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsK ICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlr dS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmggYi9Tb3VyY2UvV2ViS2l0 L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAppbmRleCA3OWVl OTE0Li45ZTg3MDkyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaApAQCAtMjE5LDcgKzIxOSw3IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNv dXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICAg ICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IG5vdCBiZSBoZXJlLCBidXQgaXQncyBu ZWVkZWQgZm9yIHRoZSB0ZXN0cyBjdXJyZW50bHkuCiAgICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0 Q2xlYXJlZEluQmVnaW4oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCmluZGV4IDlhMWUxZmYuLmEyY2JiZmYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRRdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFF0LmNwcApAQCAtMTI5Niw3ICsxMjk2LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVu dFF0OjpkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFdlYkNvcmU6OlJlc291 cmMKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6 OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQor dm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewog ICAgIGlmICghbV93ZWJGcmFtZSkKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmggYi9Tb3VyY2Uv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAppbmRleCAxMjEz MDNkLi45MThmYjIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaApAQCAtMTQ5LDcgKzE0OSw3IEBAIHB1YmxpYzoKIAog ICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAg dmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9p ZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlk Q2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv d2luL1dlYkZyYW1lLmNwcCBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcAppbmRleCBi OGJiMjQ5Li5mZDU5MGYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5j cHAKKysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCkBAIC0xOTA3LDcgKzE5MDcs NyBAQCB2b2lkIFdlYkZyYW1lOjpkaXNwYXRjaERpZEZhaWxMb2FkKGNvbnN0IFJlc291cmNlRXJy b3ImIGVycm9yKQogICAgIH0KIH0KIAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lKQogewogICAgIGQtPndlYlZpZXctPmRvd25sb2FkVVJMKHJlcXVlc3QudXJsKCkpOwogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaCBiL1NvdXJjZS9XZWJLaXQv d2luL1dlYkZyYW1lLmgKaW5kZXggODA0NmQ4NS4uNzczOTUwZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC93aW4vV2ViRnJhbWUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5o CkBAIC0zNDIsNyArMzQyLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBkaXNwYXRjaERp ZExvYWRSZXNvdXJjZUZyb21NZW1vcnlDYWNoZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVz cG9uc2UmLCBpbnQgbGVuZ3RoKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWlsUHJv dmlzaW9uYWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKICAgICB2aXJ0dWFs IHZvaWQgZGlzcGF0Y2hEaWRGYWlsTG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7 Ci0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VS ZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAgICAgCiAg ICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYkNvcmU6OldpZGdldD4gY3JlYXRlSmF2YUFwcGxldFdp ZGdldChjb25zdCBXZWJDb3JlOjpJbnRTaXplJiwgV2ViQ29yZTo6SFRNTEFwcGxldEVsZW1lbnQq LCBjb25zdCBXZWJDb3JlOjpLVVJMJiBiYXNlVVJMLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+ JiBwYXJhbU5hbWVzLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbVZhbHVlcyk7CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRXaW5DRS5jcHAgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwCmluZGV4IDY0YzEwZmUuLmRiNmVmNjMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRX aW5DRS5jcHAKKysrIGIvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFdpbkNFLmNwcApAQCAtNTk3LDcgKzU5Nyw3IEBAIHZvaWQgRnJhbWVMb2FkZXJD bGllbnRXaW5DRTo6c2V0TWFpbkRvY3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqLCBjb25zdCBS ZXNvdXJjCiAgICAgbV9oYXNTZW50UmVzcG9uc2VUb1BsdWdpbiA9IGZhbHNlOwogfQogCi12b2lk IEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3RhcnREb3dubG9h ZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3Rl ZE5hbWUpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oIGIvU291 cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgK aW5kZXggNmJlYWIwZC4uOWEyZTI3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW5jZS9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgKKysrIGIvU291cmNlL1dlYktp dC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgKQEAgLTEyNSw3 ICsxMjUsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1l bnRSZWFkeShib29sKTsKIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2Fk KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmco KSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50 TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3Vt ZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRXeC5jcHAgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRXeC5jcHAKaW5kZXggZDE2ZjY3Ny4uOWU1MTJlMCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4 LmNwcApAQCAtODQwLDcgKzg0MCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6ZGlzcGF0 Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yJikKICAgICBub3RJ bXBsZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxv YWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3Rh cnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3Rl ZE5hbWUpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmggYi9Tb3VyY2UvV2Vi S2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oCmluZGV4IDBhZmRhZDku LjIwZjA4MTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudFd4LmgKKysrIGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V3guaApAQCAtMjA2LDcgKzIwNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlv bkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0aW9uIGZ1bmN0aW9uLCBjb25zdCBOYXZpZ2F0aW9uQWN0 aW9uJiwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAg ICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3Qg UmVzb3VyY2VFcnJvciYpOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAg ICAgICAKICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IG5vdCBiZSBoZXJl LCBidXQgaXQncyBuZWVkZWQgZm9yIHRoZSB0ZXN0cyBjdXJyZW50bHkKICAgICAgICAgdmlydHVh bCB2b2lkIHBhcnRDbGVhcmVkSW5CZWdpbigpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50 LmNwcAppbmRleCAzMDE3NTA2Li4wNWYwYTc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcAorKysgYi9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xp ZW50LmNwcApAQCAtNzg5LDcgKzc4OSw3IEBAIHZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnNl dE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCkKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQog Ci12b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxv YWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3Rl ZE5hbWUpCiB7CiAgICAgbV9mcmFtZS0+c3RhcnREb3dubG9hZChyZXF1ZXN0KTsKIH0KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVM b2FkZXJDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQv V2ViRnJhbWVMb2FkZXJDbGllbnQuaAppbmRleCA1NmVmN2VhLi5jZTg0M2YwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVy Q2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJGcmFtZUxvYWRlckNsaWVudC5oCkBAIC0xMjIsNyArMTIyLDcgQEAgcHJpdmF0ZToKICAgICAK ICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKICAgICAK LSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJl cXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgIAogICAgIHZp cnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAg ICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5j cHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3BwCmluZGV4 IDkyYWFkYzYuLmUyZjM1YjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQ YWdlL1dlYkZyYW1lLmNwcApAQCAtMjE1LDcgKzIxNSw3IEBAIHZvaWQgV2ViRnJhbWU6OmRpZFJl Y2VpdmVQb2xpY3lEZWNpc2lvbih1aW50NjRfdCBsaXN0ZW5lcklELCBQb2xpY3lBY3Rpb24gYWN0 aW9uCiAgICAgKG1fY29yZUZyYW1lLT5sb2FkZXIoKS0+cG9saWN5Q2hlY2tlcigpLT4qZnVuY3Rp b24pKGFjdGlvbik7CiB9CiAKLXZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZTo6c3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmlu ZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBBU1NFUlQobV9wb2xpY3lEb3dubG9hZElEKTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuaAppbmRleCA5NzU3 MTJkLi45MDYwYTM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBh Z2UvV2ViRnJhbWUuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2Vi RnJhbWUuaApAQCAtNzAsNyArNzAsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBpbnZhbGlkYXRlUG9s aWN5TGlzdGVuZXIoKTsKICAgICB2b2lkIGRpZFJlY2VpdmVQb2xpY3lEZWNpc2lvbih1aW50NjRf dCBsaXN0ZW5lcklELCBXZWJDb3JlOjpQb2xpY3lBY3Rpb24sIHVpbnQ2NF90IGRvd25sb2FkSUQp OwogCi0gICAgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYpOworICAgIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgIHZvaWQgY29udmVydEhhbmRsZVRv RG93bmxvYWQoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGUqLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIGluaXRpYWxSZXF1ZXN0 LCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJik7CiAKICAgICBTdHJpbmcgc291cmNl KCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJW aWV3SG9zdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5j cHAKaW5kZXggNmZiMzA5MS4uZjg5ZWIyMSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2No cm9taXVtL1dlYlZpZXdIb3N0LmNwcApAQCAtNzk5LDcgKzc5OSwxMiBAQCBib29sIFdlYlZpZXdI b3N0OjphbGxvd0ltYWdlcyhXZWJGcmFtZSogZnJhbWUsIGJvb2wgZW5hYmxlZFBlclNldHRpbmdz KQogICAgIHJldHVybiBlbmFibGVkUGVyU2V0dGluZ3M7CiB9CiAKLXZvaWQgV2ViVmlld0hvc3Q6 OmxvYWRVUkxFeHRlcm5hbGx5KFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVxdWVz dCwgV2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3kpCit2b2lkIFdlYlZpZXdIb3N0Ojpsb2FkVVJM RXh0ZXJuYWxseShXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVlc3Qs IFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5KQoreworICAgIGxvYWRVUkxFeHRlcm5hbGx5KGZy YW1lLCByZXF1ZXN0LCBwb2xpY3ksIFdlYlN0cmluZygpKTsKK30KKwordm9pZCBXZWJWaWV3SG9z dDo6bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1 ZXN0LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSwgY29uc3QgV2ViU3RyaW5nJiBkb3dubG9h ZE5hbWUpCiB7CiAgICAgQVNTRVJUKHBvbGljeSAhPSAgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9s aWN5Q3VycmVudFRhYik7CiAgICAgV2ViVmlld0hvc3QqIGFub3RoZXIgPSBtX3NoZWxsLT5jcmVh dGVOZXdXaW5kb3cocmVxdWVzdC51cmwoKSk7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVy VHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vV2ViVmlld0hvc3QuaAppbmRleCAyOTUxYWZmLi5lYzc4YTkyIDEwMDY0NAotLS0gYS9Ub29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCisrKyBiL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKQEAgLTE3NCw2ICsxNzQsNyBAQCBjbGFz cyBXZWJWaWV3SG9zdCA6IHB1YmxpYyBXZWJLaXQ6OldlYlNwZWxsQ2hlY2tDbGllbnQsIHB1Ymxp YyBXZWJLaXQ6OldlYlZpZXdDbAogICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dQbHVnaW5zKFdlYktp dDo6V2ViRnJhbWUqLCBib29sIGVuYWJsZWRQZXJTZXR0aW5ncyk7CiAgICAgdmlydHVhbCBib29s IGFsbG93SW1hZ2VzKFdlYktpdDo6V2ViRnJhbWUqLCBib29sIGVuYWJsZWRQZXJTZXR0aW5ncyk7 CiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5KFdlYktpdDo6V2ViRnJhbWUqLCBj b25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLCBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xpY3kp OworICAgIHZpcnR1YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxseShXZWJLaXQ6OldlYkZyYW1lKiwg Y29uc3QgV2ViS2l0OjpXZWJVUkxSZXF1ZXN0JiwgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5 LCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYgZG93bmxvYWROYW1lKTsKICAgICB2aXJ0dWFsIFdl YktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSBkZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uKAogICAg ICAgICBXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0OjpXZWJVUkxSZXF1ZXN0JiwKICAg ICAgICAgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uVHlwZSwgY29uc3QgV2ViS2l0OjpXZWJOb2RlJiwK 101739 2011-07-22 09:56:02 -0700 2011-07-22 12:34:01 -0700 shouldHideReferrer webkit-a-download.patch text/plain 24622 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmE5NmZiNjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEgQEAKK0Jsb2IgVVJMCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1ZGI1YTIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbApAQCAt MCwwICsxLDI5IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5 cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7 CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxh IGlkPSJibG9iLXVybCIgZG93bmxvYWQ+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24g cnVuVGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRCbG9iQnVpbGRlcigpOworICBiYi5h cHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgIHZhciBibG9iID0gYmIu Z2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2YXIgbGluayA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJM LmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZl bnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2ZW50KCdjbGljaycsIHRydWUsIHRy dWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdlZjIyZTkKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It bm9kb3dubG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rv d25sb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2Y1Y2ZiMgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50 L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKQEAgLTAsMCArMSwzMCBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPgoraWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK30KKzwv c2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxvYi11cmwiPkJsb2IgVVJMPC9hPgor PHNjcmlwdD4KK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICB2YXIgYmIgPSBuZXcgV2ViS2l0Qmxv YkJ1aWxkZXIoKTsKKyAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRtbD48aHRtbD48aGVhZD48dGl0 bGU+VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIgKyAic2NyaXB0PjwvaGVhZD48 Ym9keT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2NyIiArICJpcHQ+PC9odG1sPiIp OworICB2YXIgYmxvYiA9IGJiLmdldEJsb2IoInRleHQvaHRtbCIsICJpbmxpbmUiKTsKKyAgdmFy IGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgbGluay5ocmVm ID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwoYmxvYik7CisKKyAgdmFyIGV2dCA9 IGRvY3VtZW50LmNyZWF0ZUV2ZW50KCJNb3VzZUV2ZW50Iik7CisgIGV2dC5pbml0TW91c2VFdmVu dCgnY2xpY2snLCB0cnVlLCB0cnVlKTsKKyAgbGluay5kaXNwYXRjaEV2ZW50KGV2dCk7Cit9City dW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAppbmRleCBhYTcyYWQ3Li5lODI1YzU2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcApAQCAtMjcsNiArMjcsNyBAQAog I2luY2x1ZGUgIkF0dHJpYnV0ZS5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCiAjaW5jbHVkZSAiRnJh bWVMb2FkZXJUeXBlcy5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRl ICJIVE1MTmFtZXMuaCIKQEAgLTE0NywxMCArMTQ4LDcgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVu dDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAgIH0KIAogICAgICAg ICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShl dmVudFR5cGUoZXZlbnQpKSkgewotICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGlu Z0FuZFRyYWlsaW5nSFRNTFNwYWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAg ICAgIGFwcGVuZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAg ICBoYW5kbGVMaW5rQ2xpY2soZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRh cmdldEF0dHIpLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5k UGluZ3MoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVD bGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYg KzQ5MCwzNiBAQCB2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgS1VSTCYg ZGVzdGluYXRpb25VUkwpCiAgICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5nKGRvY3VtZW50KCkt PmZyYW1lKCksIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ldKSwgZGVzdGluYXRp b25VUkwpOwogfQogCit2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVDbGljayhFdmVudCog ZXZlbnQpCit7CisgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSog ZnJhbWUgPSBkb2N1bWVudCgpLT5mcmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJl dHVybjsKKworICAgIFN0cmluZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFj ZXMoZmFzdEdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGFwcGVuZFNlcnZlck1hcE1vdXNl UG9zaXRpb24odXJsLCBldmVudCk7CisgICAgS1VSTCBrdXJsID0gZG9jdW1lbnQoKS0+Y29tcGxl dGVVUkwodXJsKTsKKworICAgIGJvb2wgZG93bmxvYWQgPSBoYXNBdHRyaWJ1dGUoZG93bmxvYWRB dHRyKTsKKyAgICBpZiAoZG93bmxvYWQpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVl c3Qoa3VybCk7CisKKyAgICAgICAgaWYgKCFoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSkgewor ICAgICAgICAgICAgU3RyaW5nIHJlZmVycmVyID0gZnJhbWUtPmxvYWRlcigpLT5vdXRnb2luZ1Jl ZmVycmVyKCk7CisgICAgICAgICAgICBpZiAoIXJlZmVycmVyLmlzRW1wdHkoKSAmJiAhU2VjdXJp dHlPcmlnaW46OnNob3VsZEhpZGVSZWZlcnJlcihrdXJsLCByZWZlcnJlcikpCisgICAgICAgICAg ICAgICAgcmVxdWVzdC5zZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIpOworICAgICAgICAgICAgZnJh bWUtPmxvYWRlcigpLT5hZGRFeHRyYUZpZWxkc1RvTWFpblJlc291cmNlUmVxdWVzdChyZXF1ZXN0 KTsKKyAgICAgICAgfQorCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+Y2xpZW50KCktPnN0YXJ0 RG93bmxvYWQocmVxdWVzdCwgZmFzdEdldEF0dHJpYnV0ZShkb3dubG9hZEF0dHIpKTsKKyAgICB9 IGVsc2UKKyAgICAgICAgZnJhbWUtPmxvYWRlcigpLT51cmxTZWxlY3RlZChrdXJsLCB0YXJnZXQo KSwgZXZlbnQsIGZhbHNlLCBmYWxzZSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikgPyBOb1Jl ZmVycmVyIDogU2VuZFJlZmVycmVyKTsKKworICAgIHNlbmRQaW5ncyhrdXJsKTsKK30KKwogSFRN TEFuY2hvckVsZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5jaG9yRWxlbWVudDo6ZXZlbnRUeXBlKEV2 ZW50KiBldmVudCkKIHsKICAgICBpZiAoIWV2ZW50LT5pc01vdXNlRXZlbnQoKSkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaAppbmRleCA4NjBhZDM1Li45NDdmNzQ2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCkBAIC0xMTUsNiArMTE1LDggQEAg cHJpdmF0ZToKIAogICAgIHZvaWQgc2VuZFBpbmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJM KTsKIAorICAgIHZvaWQgaGFuZGxlQ2xpY2soRXZlbnQqKTsKKwogICAgIGVudW0gRXZlbnRUeXBl IHsKICAgICAgICAgTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleSwKICAgICAgICAgTW91c2VFdmVu dFdpdGhTaGlmdEtleSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuaWRsIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwK aW5kZXggODcxZmNkZi4uMWU5YzExZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MQW5jaG9yRWxlbWVudC5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9y RWxlbWVudC5pZGwKQEAgLTI2LDYgKzI2LDcgQEAgbW9kdWxlIGh0bWwgewogICAgICAgICBhdHRy aWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBhY2Nlc3NLZXk7CiAgICAgICAgIGF0dHJpYnV0ZSBb UmVmbGVjdF0gRE9NU3RyaW5nIGNoYXJzZXQ7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0g RE9NU3RyaW5nIGNvb3JkczsKKyAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcg ZG93bmxvYWQ7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdCwgVVJMXSBET01TdHJpbmcgaHJl ZjsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgaHJlZmxhbmc7CiAgICAg ICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIG5hbWU7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbiBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCmluZGV4IDE2NzllOTYuLjg0MTBkZTYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCkBAIC05MSw2ICs5MSw3IEBAIGRl ZmVyCiBkaXIKIGRpcmVjdGlvbgogZGlzYWJsZWQKK2Rvd25sb2FkCiBkcmFnZ2FibGUKIHdlYmtp dGRyb3B6b25lCiBlbmN0eXBlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1w dHlDbGllbnRzLmggYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgKaW5kZXgg Nzg1YjEyYy4uZDBiMjBhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5 Q2xpZW50cy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaApAQCAt MzEwLDcgKzMxMCw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVE b2N1bWVudFJlYWR5KGJvb2wpIHsgfQogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JikgeyB9CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxv YWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKSB7IH0K IAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSB7IH0K ICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSB7IH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvU291 cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggMzg1MjM4My4uYWEw ZjJmMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKQEAgLTE3 OSw3ICsxNzksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIAogICAgICAgICB2aXJ0 dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKSA9IDA7CiAKLSAgICAgICAg dmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikgPSAwOwor ICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm LCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpID0gMDsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQg d2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwogICAgICAgICB2aXJ0dWFsIHZv aWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaAppbmRleCBiMTkzZmVjLi4wYWY5NmNh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVu dC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgK QEAgLTExNiw2ICsxMTYsOCBAQCBwdWJsaWM6CiAgICAgLy8gVGhlIGNsaWVudCBzaG91bGQgaGFu ZGxlIHRoZSBuYXZpZ2F0aW9uIGV4dGVybmFsbHkuCiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxF eHRlcm5hbGx5KAogICAgICAgICBXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmLCBXZWJO YXZpZ2F0aW9uUG9saWN5KSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHko CisgICAgICAgIFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYsIFdlYk5hdmlnYXRpb25Q b2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWROYW1lKSB7IH0KIAogCiAgICAgLy8gTmF2 aWdhdGlvbmFsIHF1ZXJpZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxv YWRlckNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2Fk ZXJDbGllbnRJbXBsLmNwcAppbmRleCA3OWRkZDY4Li5hMmZkMTAwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKQEAgLTk0 NCw3ICs5NDQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEZWNpZGVQ b2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9uKAogICAgIFBvbGljeUFjdGlvbiBwb2xpY3lBY3Rpb24g PSBQb2xpY3lJZ25vcmU7CiAKICAgICAvLyBJdCBpcyB2YWxpZCBmb3IgdGhpcyBmdW5jdGlvbiB0 byBiZSBpbnZva2VkIGluIGNvZGUgcGF0aHMgd2hlcmUgdGhlCi0gICAgLy8gdGhlIHdlYnZpZXcg aXMgY2xvc2VkLgorICAgIC8vIHdlYnZpZXcgaXMgY2xvc2VkLgogICAgIC8vIFRoZSBudWxsIGNo ZWNrIGhlcmUgaXMgdG8gZml4IGEgY3Jhc2ggdGhhdCBzZWVtcyBzdHJhbmdlCiAgICAgLy8gKHNl ZSAtIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzU1NCkuCiAgICAg aWYgKG1fd2ViRnJhbWUtPmNsaWVudCgpICYmICFyZXF1ZXN0LnVybCgpLmlzTnVsbCgpKSB7CkBA IC0xMDczLDcgKzEwNzMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c2V0TWFpbkZy YW1lRG9jdW1lbnRSZWFkeShib29sIHJlYWR5KQogCiAvLyBDcmVhdGVzIGEgbmV3IGNvbm5lY3Rp b24gYW5kIGJlZ2lucyBkb3dubG9hZGluZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMKIC8vIHdp dGggfGRvd25sb2FkfCkuCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 SW1wbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0 IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkp IHsKICAgICAgICAgV3JhcHBlZFJlc291cmNlUmVxdWVzdCB3ZWJyZXEocmVxdWVzdCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwu aCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCmlu ZGV4IGFkYWY5ZDMuLmYxZjAyNGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCkBAIC0xMzEsNyArMTMxLDcgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgdm9pZCBwb3N0UHJvZ3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmljYXRpb24o KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFByb2dyZXNzRmluaXNoZWROb3RpZmljYXRpb24oKTsK ICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgIHZpcnR1YWwgdm9pZCB3 aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZv aWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFs IHZvaWQgY29tbWl0dGVkTG9hZChXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IGNoYXIq LCBpbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRFZmwuY3BwIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRFZmwuY3BwCmluZGV4IDllMjc1N2YuLjlhMmRmY2YgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZs LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEVmbC5jcHAKQEAgLTg3MSw3ICs4NzEsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZs OjpzZXRNYWluRG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRlciogbG9hZGVyLCBjb25zdCBSZQog ICAgIG1faGFzU2VudFJlc3BvbnNlVG9QbHVnaW4gPSBmYWxzZTsKIH0KIAotdm9pZCBGcmFtZUxv YWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVl c3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAg IGlmICghbV92aWV3KQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oIGIvU291cmNlL1dlYktp dC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAppbmRleCA0N2FiM2Q0 Li45ZTZkMWNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEVmbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKQEAgLTE1Myw3ICsxNTMsNyBAQCBjbGFzcyBGcmFt ZUxvYWRlckNsaWVudEVmbCA6IHB1YmxpYyBGcmFtZUxvYWRlckNsaWVudCB7CiAKICAgICB2aXJ0 dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgIHZpcnR1YWwg dm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwg dm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYg PSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50 TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVy Kik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggMjZjNTM0ZS4uNTJlMzc2YyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 R3RrLmNwcApAQCAtMTIyMSw3ICsxMjIxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c2V0 TWFpbkRvY3VtZW50RXJyb3IoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXMKICAg ICB9CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3du bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2Vz dGVkTmFtZSkKIHsKICAgICBHUmVmUHRyPFdlYktpdE5ldHdvcmtSZXF1ZXN0PiBuZXR3b3JrUmVx dWVzdChhZG9wdEdSZWYoa2l0TmV3KHJlcXVlc3QpKSk7CiAgICAgV2ViS2l0V2ViVmlldyogdmll dyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oIGIvU291cmNlL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaAppbmRleCAyNDQ4Mjlm Li43YzU4MzIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5oCisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKQEAgLTEzMCw3ICsxMzAsNyBAQCBuYW1lc3BhY2Ug V2ViS2l0IHsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFk eShib29sKTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmlu ZygpKTsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRv Y3VtZW50TG9hZGVyKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJD b3JlOjpEb2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9oYWlrdS9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcCBiL1NvdXJjZS9XZWJLaXQv aGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKaW5kZXggMjg1 YTNmYS4uMGM0NjhhZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCkBAIC03MDksNyArNzA5 LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpkaXNwYXRjaFVuYWJsZVRvSW1wbGVt ZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3IKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQog Ci12b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChj b25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAg ICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvaGFpa3Uv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oIGIvU291cmNlL1dlYktpdC9o YWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmgKaW5kZXggNzllZTkx NC4uOWU4NzA5MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmgKKysrIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmgKQEAgLTIxOSw3ICsyMTksNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAg dmlydHVhbCB2b2lkIGRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3Vy Y2VFcnJvciYpOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJl c291cmNlUmVxdWVzdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgICAg IC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBub3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVl ZGVkIGZvciB0aGUgdGVzdHMgY3VycmVudGx5LgogICAgICAgICB2aXJ0dWFsIHZvaWQgcGFydENs ZWFyZWRJbkJlZ2luKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcAppbmRleCA5YTFlMWZmLi5hMmNiYmZmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRRdC5jcHAKQEAgLTEyOTYsNyArMTI5Niw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRR dDo6ZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBXZWJDb3JlOjpSZXNvdXJj CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0Ojpz dGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3Zv aWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAg ICBpZiAoIW1fd2ViRnJhbWUpCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oIGIvU291cmNlL1dl YktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmgKaW5kZXggMTIxMzAz ZC4uOTE4ZmIyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFF0LmgKKysrIGIvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFF0LmgKQEAgLTE0OSw3ICsxNDksNyBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgIHZp cnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYp OworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNl UmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZvaWQg d2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENo YW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dp bi9XZWJGcmFtZS5jcHAgYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKaW5kZXggYjhi YjI0OS4uZmQ1OTBmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcApAQCAtMTkwNyw3ICsxOTA3LDcg QEAgdm9pZCBXZWJGcmFtZTo6ZGlzcGF0Y2hEaWRGYWlsTG9hZChjb25zdCBSZXNvdXJjZUVycm9y JiBlcnJvcikKICAgICB9CiB9CiAKLXZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChj b25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFt ZSkKIHsKICAgICBkLT53ZWJWaWV3LT5kb3dubG9hZFVSTChyZXF1ZXN0LnVybCgpKTsKIH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmggYi9Tb3VyY2UvV2ViS2l0L3dp bi9XZWJGcmFtZS5oCmluZGV4IDgwNDZkODUuLjc3Mzk1MGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvd2luL1dlYkZyYW1lLmgKKysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaApA QCAtMzQyLDcgKzM0Miw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgZGlzcGF0Y2hEaWRM b2FkUmVzb3VyY2VGcm9tTWVtb3J5Q2FjaGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25z dCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3Bv bnNlJiwgaW50IGxlbmd0aCk7CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbFByb3Zp c2lvbmFsTG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7CiAgICAgdmlydHVhbCB2 b2lkIGRpc3BhdGNoRGlkRmFpbExvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwot ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgICAgIAogICAg IHZpcnR1YWwgUGFzc1JlZlB0cjxXZWJDb3JlOjpXaWRnZXQ+IGNyZWF0ZUphdmFBcHBsZXRXaWRn ZXQoY29uc3QgV2ViQ29yZTo6SW50U2l6ZSYsIFdlYkNvcmU6OkhUTUxBcHBsZXRFbGVtZW50Kiwg Y29uc3QgV2ViQ29yZTo6S1VSTCYgYmFzZVVSTCwgY29uc3QgVmVjdG9yPFdURjo6U3RyaW5nPiYg cGFyYW1OYW1lcywgY29uc3QgVmVjdG9yPFdURjo6U3RyaW5nPiYgcGFyYW1WYWx1ZXMpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50V2luQ0UuY3BwIGIvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudFdpbkNFLmNwcAppbmRleCA2NGMxMGZlLi5kYjZlZjYzIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2lu Q0UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRXaW5DRS5jcHAKQEAgLTU5Nyw3ICs1OTcsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50V2luQ0U6OnNldE1haW5Eb2N1bWVudEVycm9yKERvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVz b3VyYwogICAgIG1faGFzU2VudFJlc3BvbnNlVG9QbHVnaW4gPSBmYWxzZTsKIH0KIAotdm9pZCBG cmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lKQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaCBiL1NvdXJj ZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCmlu ZGV4IDZiZWFiMGQuLjlhMmUyNzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luY2UvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCisrKyBiL1NvdXJjZS9XZWJLaXQv d2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCkBAIC0xMjUsNyAr MTI1LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50 UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChj b25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkp OwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExv YWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVu dExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V3guY3BwIGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V3guY3BwCmluZGV4IGQxNmY2NzcuLjllNTEyZTAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5j cHAKQEAgLTg0MCw3ICs4NDAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OmRpc3BhdGNo VW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvciYpCiAgICAgbm90SW1w bGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0 RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lKQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oIGIvU291cmNlL1dlYktp dC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaAppbmRleCAwYWZkYWQ5Li4y MGYwODEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRXeC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudFd4LmgKQEAgLTIwNiw3ICsyMDYsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25B Y3Rpb24oRnJhbWVQb2xpY3lGdW5jdGlvbiBmdW5jdGlvbiwgY29uc3QgTmF2aWdhdGlvbkFjdGlv biYsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAgICAg ICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJl c291cmNlRXJyb3ImKTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAg ICAgCiAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBub3QgYmUgaGVyZSwg YnV0IGl0J3MgbmVlZGVkIGZvciB0aGUgdGVzdHMgY3VycmVudGx5CiAgICAgICAgIHZpcnR1YWwg dm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwIGIvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5j cHAKaW5kZXggMzAxNzUwNi4uMDVmMGE3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2Vi UHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHAKKysrIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVu dC5jcHAKQEAgLTc4OSw3ICs3ODksNyBAQCB2b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50OjpzZXRN YWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAot dm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lKQogewogICAgIG1fZnJhbWUtPnN0YXJ0RG93bmxvYWQocmVxdWVzdCk7CiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9h ZGVyQ2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dl YkZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggNTZlZjdlYS4uY2U4NDNmMCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNs aWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2Vi RnJhbWVMb2FkZXJDbGllbnQuaApAQCAtMTIyLDcgKzEyMiw3IEBAIHByaXZhdGU6CiAgICAgCiAg ICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAgICAgCi0g ICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1 ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICAKICAgICB2aXJ0 dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAg dmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuY3Bw IGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmNwcAppbmRleCA5 MmFhZGM2Li5lMmYzNWIzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YlBhZ2UvV2ViRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFn ZS9XZWJGcmFtZS5jcHAKQEAgLTIxNSw3ICsyMTUsNyBAQCB2b2lkIFdlYkZyYW1lOjpkaWRSZWNl aXZlUG9saWN5RGVjaXNpb24odWludDY0X3QgbGlzdGVuZXJJRCwgUG9saWN5QWN0aW9uIGFjdGlv bgogICAgIChtX2NvcmVGcmFtZS0+bG9hZGVyKCktPnBvbGljeUNoZWNrZXIoKS0+KmZ1bmN0aW9u KShhY3Rpb24pOwogfQogCi12b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcm IHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgQVNTRVJUKG1fcG9saWN5RG93bmxvYWRJRCk7CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oIGIv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmgKaW5kZXggOTc1NzEy ZC4uOTA2MGEzOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdl L1dlYkZyYW1lLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZy YW1lLmgKQEAgLTcwLDcgKzcwLDcgQEAgcHVibGljOgogICAgIHZvaWQgaW52YWxpZGF0ZVBvbGlj eUxpc3RlbmVyKCk7CiAgICAgdm9pZCBkaWRSZWNlaXZlUG9saWN5RGVjaXNpb24odWludDY0X3Qg bGlzdGVuZXJJRCwgV2ViQ29yZTo6UG9saWN5QWN0aW9uLCB1aW50NjRfdCBkb3dubG9hZElEKTsK IAotICAgIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICB2b2lkIGNvbnZlcnRIYW5kbGVUb0Rv d25sb2FkKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlKiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VS ZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiBpbml0aWFsUmVxdWVzdCwg Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSYpOwogCiAgICAgU3RyaW5nIHNvdXJjZSgp IGNvbnN0OwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmll d0hvc3QuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3Bw CmluZGV4IDZmYjMwOTEuLmY4OWViMjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVl L2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJv bWl1bS9XZWJWaWV3SG9zdC5jcHAKQEAgLTc5OSw3ICs3OTksMTIgQEAgYm9vbCBXZWJWaWV3SG9z dDo6YWxsb3dJbWFnZXMoV2ViRnJhbWUqIGZyYW1lLCBib29sIGVuYWJsZWRQZXJTZXR0aW5ncykK ICAgICByZXR1cm4gZW5hYmxlZFBlclNldHRpbmdzOwogfQogCi12b2lkIFdlYlZpZXdIb3N0Ojps b2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVlc3Qs IFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5KQordm9pZCBXZWJWaWV3SG9zdDo6bG9hZFVSTEV4 dGVybmFsbHkoV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0LCBX ZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSkKK3sKKyAgICBsb2FkVVJMRXh0ZXJuYWxseShmcmFt ZSwgcmVxdWVzdCwgcG9saWN5LCBXZWJTdHJpbmcoKSk7Cit9CisKK3ZvaWQgV2ViVmlld0hvc3Q6 OmxvYWRVUkxFeHRlcm5hbGx5KFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVxdWVz dCwgV2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWRO YW1lKQogewogICAgIEFTU0VSVChwb2xpY3kgIT0gIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGlj eUN1cnJlbnRUYWIpOwogICAgIFdlYlZpZXdIb3N0KiBhbm90aGVyID0gbV9zaGVsbC0+Y3JlYXRl TmV3V2luZG93KHJlcXVlc3QudXJsKCkpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVt L1dlYlZpZXdIb3N0LmgKaW5kZXggMjk1MWFmZi4uZWM3OGE5MiAxMDA2NDQKLS0tIGEvVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaAorKysgYi9Ub29scy9EdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCkBAIC0xNzQsNiArMTc0LDcgQEAgY2xhc3Mg V2ViVmlld0hvc3QgOiBwdWJsaWMgV2ViS2l0OjpXZWJTcGVsbENoZWNrQ2xpZW50LCBwdWJsaWMg V2ViS2l0OjpXZWJWaWV3Q2wKICAgICAgdmlydHVhbCBib29sIGFsbG93UGx1Z2lucyhXZWJLaXQ6 OldlYkZyYW1lKiwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3MpOwogICAgIHZpcnR1YWwgYm9vbCBh bGxvd0ltYWdlcyhXZWJLaXQ6OldlYkZyYW1lKiwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3MpOwog ICAgIHZpcnR1YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxseShXZWJLaXQ6OldlYkZyYW1lKiwgY29u c3QgV2ViS2l0OjpXZWJVUkxSZXF1ZXN0JiwgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5KTsK KyAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNv bnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSwg Y29uc3QgV2ViS2l0OjpXZWJTdHJpbmcmIGRvd25sb2FkTmFtZSk7CiAgICAgdmlydHVhbCBXZWJL aXQ6OldlYk5hdmlnYXRpb25Qb2xpY3kgZGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbigKICAgICAg ICAgV2ViS2l0OjpXZWJGcmFtZSosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsCiAgICAg ICAgIFdlYktpdDo6V2ViTmF2aWdhdGlvblR5cGUsIGNvbnN0IFdlYktpdDo6V2ViTm9kZSYsCg== 101754 2011-07-22 12:34:01 -0700 2011-07-22 14:10:16 -0700 ENABLE webkit-a-download.patch text/plain 25079 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLmE5NmZiNjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEgQEAKK0Jsb2IgVVJMCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1ZGI1YTIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbApAQCAt MCwwICsxLDI5IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5 cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7 CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxh IGlkPSJibG9iLXVybCIgZG93bmxvYWQ+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24g cnVuVGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRCbG9iQnVpbGRlcigpOworICBiYi5h cHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNj cmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxl ci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgIHZhciBibG9iID0gYmIu Z2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2YXIgbGluayA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJM LmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZl bnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2ZW50KCdjbGljaycsIHRydWUsIHRy dWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdlZjIyZTkKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It bm9kb3dubG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rv d25sb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2Y1Y2ZiMgot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50 L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKQEAgLTAsMCArMSwzMCBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPgoraWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK30KKzwv c2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxvYi11cmwiPkJsb2IgVVJMPC9hPgor PHNjcmlwdD4KK2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICB2YXIgYmIgPSBuZXcgV2ViS2l0Qmxv YkJ1aWxkZXIoKTsKKyAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRtbD48aHRtbD48aGVhZD48dGl0 bGU+VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIgKyAic2NyaXB0PjwvaGVhZD48 Ym9keT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikg bGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2NyIiArICJpcHQ+PC9odG1sPiIp OworICB2YXIgYmxvYiA9IGJiLmdldEJsb2IoInRleHQvaHRtbCIsICJpbmxpbmUiKTsKKyAgdmFy IGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgbGluay5ocmVm ID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwoYmxvYik7CisKKyAgdmFyIGV2dCA9 IGRvY3VtZW50LmNyZWF0ZUV2ZW50KCJNb3VzZUV2ZW50Iik7CisgIGV2dC5pbml0TW91c2VFdmVu dCgnY2xpY2snLCB0cnVlLCB0cnVlKTsKKyAgbGluay5kaXNwYXRjaEV2ZW50KGV2dCk7Cit9City dW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KKwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAppbmRleCBhYTcyYWQ3Li5kNzY1ZjA4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcApAQCAtMjcsNiArMjcsNyBAQAog I2luY2x1ZGUgIkF0dHJpYnV0ZS5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCiAjaW5jbHVkZSAiRnJh bWVMb2FkZXJUeXBlcy5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRl ICJIVE1MTmFtZXMuaCIKQEAgLTE0NywxMCArMTQ4LDcgQEAgdm9pZCBIVE1MQW5jaG9yRWxlbWVu dDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAgIH0KIAogICAgICAg ICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShl dmVudFR5cGUoZXZlbnQpKSkgewotICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGlu Z0FuZFRyYWlsaW5nSFRNTFNwYWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAg ICAgIGFwcGVuZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAg ICBoYW5kbGVMaW5rQ2xpY2soZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRh cmdldEF0dHIpLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5k UGluZ3MoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVD bGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYg KzQ5MCwzOCBAQCB2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgS1VSTCYg ZGVzdGluYXRpb25VUkwpCiAgICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5nKGRvY3VtZW50KCkt PmZyYW1lKCksIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ldKSwgZGVzdGluYXRp b25VUkwpOwogfQogCit2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVDbGljayhFdmVudCog ZXZlbnQpCit7CisgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisKKyAgICBGcmFtZSog ZnJhbWUgPSBkb2N1bWVudCgpLT5mcmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJl dHVybjsKKworICAgIFN0cmluZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFpbGluZ0hUTUxTcGFj ZXMoZmFzdEdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGFwcGVuZFNlcnZlck1hcE1vdXNl UG9zaXRpb24odXJsLCBldmVudCk7CisgICAgS1VSTCBrdXJsID0gZG9jdW1lbnQoKS0+Y29tcGxl dGVVUkwodXJsKTsKKworI2lmIGRlZmluZWQoRU5BQkxFX0RPV05MT0FEX0FUVFJJQlVURSkKKyAg ICBib29sIGRvd25sb2FkID0gaGFzQXR0cmlidXRlKGRvd25sb2FkQXR0cik7CisgICAgaWYgKGRv d25sb2FkKSB7CisgICAgICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KGt1cmwpOworCisgICAg ICAgIGlmICghaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikpIHsKKyAgICAgICAgICAgIFN0cmlu ZyByZWZlcnJlciA9IGZyYW1lLT5sb2FkZXIoKS0+b3V0Z29pbmdSZWZlcnJlcigpOworICAgICAg ICAgICAgaWYgKCFyZWZlcnJlci5pc0VtcHR5KCkgJiYgIVNlY3VyaXR5T3JpZ2luOjpzaG91bGRI aWRlUmVmZXJyZXIoa3VybCwgcmVmZXJyZXIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3Quc2V0 SFRUUFJlZmVycmVyKHJlZmVycmVyKTsKKyAgICAgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+YWRk RXh0cmFGaWVsZHNUb01haW5SZXNvdXJjZVJlcXVlc3QocmVxdWVzdCk7CisgICAgICAgIH0KKwor ICAgICAgICBmcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5zdGFydERvd25sb2FkKHJlcXVlc3Qs IGZhc3RHZXRBdHRyaWJ1dGUoZG93bmxvYWRBdHRyKSk7CisgICAgfSBlbHNlCisjZW5kaWYKKyAg ICAgICAgZnJhbWUtPmxvYWRlcigpLT51cmxTZWxlY3RlZChrdXJsLCB0YXJnZXQoKSwgZXZlbnQs IGZhbHNlLCBmYWxzZSwgaGFzUmVsKFJlbGF0aW9uTm9SZWZlcnJlcikgPyBOb1JlZmVycmVyIDog U2VuZFJlZmVycmVyKTsKKworICAgIHNlbmRQaW5ncyhrdXJsKTsKK30KKwogSFRNTEFuY2hvckVs ZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5jaG9yRWxlbWVudDo6ZXZlbnRUeXBlKEV2ZW50KiBldmVu dCkKIHsKICAgICBpZiAoIWV2ZW50LT5pc01vdXNlRXZlbnQoKSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTEFuY2hvckVsZW1lbnQuaAppbmRleCA4NjBhZDM1Li45NDdmNzQ2IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCkBAIC0xMTUsNiArMTE1LDggQEAgcHJpdmF0ZToK IAogICAgIHZvaWQgc2VuZFBpbmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKTsKIAorICAg IHZvaWQgaGFuZGxlQ2xpY2soRXZlbnQqKTsKKwogICAgIGVudW0gRXZlbnRUeXBlIHsKICAgICAg ICAgTW91c2VFdmVudFdpdGhvdXRTaGlmdEtleSwKICAgICAgICAgTW91c2VFdmVudFdpdGhTaGlm dEtleSwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQu aWRsIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwKaW5kZXggODcx ZmNkZi4uZmQ3YmVjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9y RWxlbWVudC5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5p ZGwKQEAgLTU2LDYgKzU2LDEwIEBAIG1vZHVsZSBodG1sIHsKICAgICAgICAgcmVhZG9ubHkgYXR0 cmlidXRlIFtDb252ZXJ0TnVsbFRvTnVsbFN0cmluZ10gRE9NU3RyaW5nIG9yaWdpbjsKICNlbmRp ZgogCisjaWYgZGVmaW5lZChFTkFCTEVfRE9XTkxPQURfQVRUUklCVVRFKQorICAgICAgICBhdHRy aWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBkb3dubG9hZDsKKyNlbmRpZgorCiAgICAgICAgIERP TVN0cmluZyBnZXRQYXJhbWV0ZXIoaW4gRE9NU3RyaW5nIG5hbWUpOwogCiAgICAgICAgIHJlYWRv bmx5IGF0dHJpYnV0ZSBET01TdHJpbmcgdGV4dDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQXR0 cmlidXRlTmFtZXMuaW4KaW5kZXggMTY3OWU5Ni4uODQxMGRlNiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4KQEAgLTkxLDYgKzkxLDcgQEAgZGVmZXIKIGRpcgog ZGlyZWN0aW9uCiBkaXNhYmxlZAorZG93bmxvYWQKIGRyYWdnYWJsZQogd2Via2l0ZHJvcHpvbmUK IGVuY3R5cGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMu aCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAppbmRleCA3ODViMTJjLi5k MGIyMGE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgK KysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCkBAIC0zMTAsNyArMzEw LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVh ZHkoYm9vbCkgeyB9CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpIHsgfQogCiAgICAgdmly dHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsgfQogICAgIHZpcnR1 YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopIHsgfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmggYi9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAppbmRleCAzODUyMzgzLi5hYTBmMmYyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaApAQCAtMTc5LDcgKzE3OSw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAgICAgICAgIHZpcnR1YWwgdm9pZCBz ZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpID0gMDsKIAotICAgICAgICB2aXJ0dWFsIHZv aWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKSA9IDA7CisgICAgICAgIHZp cnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0 cmluZyYgPSBTdHJpbmcoKSkgPSAwOwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdl VGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFu Z2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vZmVhdHVyZXMuZ3lwaSBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vZmVhdHVyZXMu Z3lwaQppbmRleCA0M2RiNDgzLi45NmY3Y2QzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL2ZlYXR1cmVzLmd5cGkKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9mZWF0dXJl cy5neXBpCkBAIC00NCw2ICs0NCw3IEBACiAgICAgICAnRU5BQkxFX0RFVklDRV9PUklFTlRBVElP Tj0xJywKICAgICAgICdFTkFCTEVfRElSRUNUT1JZX1VQTE9BRD0xJywKICAgICAgICdFTkFCTEVf RE9NX1NUT1JBR0U9MScsCisgICAgICAnRU5BQkxFX0RPV05MT0FEX0FUVFJJQlVURT0xJywKICAg ICAgICdFTkFCTEVfRVZFTlRTT1VSQ0U9MScsCiAgICAgICAnRU5BQkxFX0pBVkFTQ1JJUFRfSTE4 Tl9BUEk9MScsCiAgICAgICAnRU5BQkxFX0ZJTEVfU1lTVEVNPTEnLApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgKaW5kZXggYjE5M2ZlYy4uMGFmOTZj YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGll bnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5o CkBAIC0xMTYsNiArMTE2LDggQEAgcHVibGljOgogICAgIC8vIFRoZSBjbGllbnQgc2hvdWxkIGhh bmRsZSB0aGUgbmF2aWdhdGlvbiBleHRlcm5hbGx5LgogICAgIHZpcnR1YWwgdm9pZCBsb2FkVVJM RXh0ZXJuYWxseSgKICAgICAgICAgV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiwgV2Vi TmF2aWdhdGlvblBvbGljeSkgeyB9CisgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5 KAorICAgICAgICBXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmLCBXZWJOYXZpZ2F0aW9u UG9saWN5LCBjb25zdCBXZWJTdHJpbmcmIGRvd25sb2FkTmFtZSkgeyB9CiAKIAogICAgIC8vIE5h dmlnYXRpb25hbCBxdWVyaWVzIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVM b2FkZXJDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9h ZGVyQ2xpZW50SW1wbC5jcHAKaW5kZXggNzlkZGQ2OC4uYTJmZDEwMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcAorKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCkBAIC05 NDQsNyArOTQ0LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGVjaWRl UG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbigKICAgICBQb2xpY3lBY3Rpb24gcG9saWN5QWN0aW9u ID0gUG9saWN5SWdub3JlOwogCiAgICAgLy8gSXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVuY3Rpb24g dG8gYmUgaW52b2tlZCBpbiBjb2RlIHBhdGhzIHdoZXJlIHRoZQotICAgIC8vIHRoZSB3ZWJ2aWV3 IGlzIGNsb3NlZC4KKyAgICAvLyB3ZWJ2aWV3IGlzIGNsb3NlZC4KICAgICAvLyBUaGUgbnVsbCBj aGVjayBoZXJlIGlzIHRvIGZpeCBhIGNyYXNoIHRoYXQgc2VlbXMgc3RyYW5nZQogICAgIC8vIChz ZWUgLSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM1NTQpLgogICAg IGlmIChtX3dlYkZyYW1lLT5jbGllbnQoKSAmJiAhcmVxdWVzdC51cmwoKS5pc051bGwoKSkgewpA QCAtMTA3Myw3ICsxMDczLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnNldE1haW5G cmFtZURvY3VtZW50UmVhZHkoYm9vbCByZWFkeSkKIAogLy8gQ3JlYXRlcyBhIG5ldyBjb25uZWN0 aW9uIGFuZCBiZWdpbnMgZG93bmxvYWRpbmcgZnJvbSB0aGF0IChjb250cmFzdCB0aGlzCiAvLyB3 aXRoIHxkb3dubG9hZHwpLgotdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnN0YXJ0RG93bmxv YWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVu dEltcGw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25z dCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAgICAgaWYgKG1fd2ViRnJhbWUtPmNsaWVudCgp KSB7CiAgICAgICAgIFdyYXBwZWRSZXNvdXJjZVJlcXVlc3Qgd2VicmVxKHJlcXVlc3QpOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBs LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaApp bmRleCBhZGFmOWQzLi5mMWYwMjRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaApAQCAtMTMxLDcgKzEzMSw3IEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIHZvaWQgcG9zdFByb2dyZXNzRXN0aW1hdGVDaGFuZ2VkTm90aWZpY2F0aW9u KCk7CiAgICAgdmlydHVhbCB2b2lkIHBvc3RQcm9ncmVzc0ZpbmlzaGVkTm90aWZpY2F0aW9uKCk7 CiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7Ci0gICAg dmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAgICB2aXJ0dWFsIHZvaWQg d2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2 b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVh bCB2b2lkIGNvbW1pdHRlZExvYWQoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBjaGFy KiwgaW50KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50RWZsLmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAppbmRleCA5ZTI3NTdmLi45YTJkZmNmIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVm bC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRFZmwuY3BwCkBAIC04NzEsNyArODcxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEVm bDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgY29uc3QgUmUK ICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVM b2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAg ICBpZiAoIW1fdmlldykKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaCBiL1NvdXJjZS9XZWJL aXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKaW5kZXggNDdhYjNk NC4uOWU2ZDFjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRFZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCkBAIC0xNTMsNyArMTUzLDcgQEAgY2xhc3MgRnJh bWVMb2FkZXJDbGllbnRFZmwgOiBwdWJsaWMgRnJhbWVMb2FkZXJDbGllbnQgewogCiAgICAgdmly dHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFs IHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFs IHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcm ID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVu dExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRl ciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRHdGsuY3BwIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDI2YzUzNGUuLjUyZTM3NmMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dEd0ay5jcHAKQEAgLTEyMjEsNyArMTIyMSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNl dE1haW5Eb2N1bWVudEVycm9yKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzCiAg ICAgfQogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93 bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dl c3RlZE5hbWUpCiB7CiAgICAgR1JlZlB0cjxXZWJLaXROZXR3b3JrUmVxdWVzdD4gbmV0d29ya1Jl cXVlc3QoYWRvcHRHUmVmKGtpdE5ldyhyZXF1ZXN0KSkpOwogICAgIFdlYktpdFdlYlZpZXcqIHZp ZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJL aXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKaW5kZXggMjQ0ODI5 Zi4uN2M1ODMyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCkBAIC0xMzAsNyArMTMwLDcgQEAgbmFtZXNwYWNl IFdlYktpdCB7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVh ZHkoYm9vbCk7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25s b2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJp bmcoKSk7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpE b2N1bWVudExvYWRlciopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2Vi Q29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvaGFpa3Uv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCmluZGV4IDI4 NWEzZmEuLjBjNDY4YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9oYWlr dS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcApAQCAtNzA5LDcgKzcw OSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6ZGlzcGF0Y2hVbmFibGVUb0ltcGxl bWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0K IAotdm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewog ICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaCBiL1NvdXJjZS9XZWJLaXQv aGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCmluZGV4IDc5ZWU5 MTQuLjllODcwOTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCkBAIC0yMTksNyArMjE5LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQdHI8Rm9ybVN0YXRlPik7CiAgICAgICAg IHZpcnR1YWwgdm9pZCBkaXNwYXRjaFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291 cmNlRXJyb3ImKTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29u c3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgICAg ICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJlIGhlcmUsIGJ1dCBpdCdzIG5l ZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseS4KICAgICAgICAgdmlydHVhbCB2b2lkIHBhcnRD bGVhcmVkSW5CZWdpbigpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKaW5kZXggOWExZTFmZi4uYTJjYmJmZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dFF0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50UXQuY3BwCkBAIC0xMjk2LDcgKzEyOTYsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 UXQ6OmRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgV2ViQ29yZTo6UmVzb3Vy YwogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6 c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAg ICAgaWYgKCFtX3dlYkZyYW1lKQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaCBiL1NvdXJjZS9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oCmluZGV4IDEyMTMw M2QuLjkxOGZiMjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRRdC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oCkBAIC0xNDksNyArMTQ5LDcgQEAgcHVibGljOgogCiAg ICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lk IHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRD aGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93 aW4vV2ViRnJhbWUuY3BwIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCmluZGV4IGI4 YmIyNDkuLmZkNTkwZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAKQEAgLTE5MDcsNyArMTkwNyw3 IEBAIHZvaWQgV2ViRnJhbWU6OmRpc3BhdGNoRGlkRmFpbExvYWQoY29uc3QgUmVzb3VyY2VFcnJv ciYgZXJyb3IpCiAgICAgfQogfQogCi12b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2FkKGNvbnN0 IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5h bWUpCiB7CiAgICAgZC0+d2ViVmlldy0+ZG93bmxvYWRVUkwocmVxdWVzdC51cmwoKSk7CiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oIGIvU291cmNlL1dlYktpdC93 aW4vV2ViRnJhbWUuaAppbmRleCA4MDQ2ZDg1Li43NzM5NTBmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L3dpbi9XZWJGcmFtZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgK QEAgLTM0Miw3ICszNDIsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGRpc3BhdGNoRGlk TG9hZFJlc291cmNlRnJvbU1lbW9yeUNhY2hlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29u c3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNw b25zZSYsIGludCBsZW5ndGgpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaERpZEZhaWxQcm92 aXNpb25hbExvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwogICAgIHZpcnR1YWwg dm9pZCBkaXNwYXRjaERpZEZhaWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsK LSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJl cXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgICAgICAKICAg ICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2ViQ29yZTo6V2lkZ2V0PiBjcmVhdGVKYXZhQXBwbGV0V2lk Z2V0KGNvbnN0IFdlYkNvcmU6OkludFNpemUmLCBXZWJDb3JlOjpIVE1MQXBwbGV0RWxlbWVudCos IGNvbnN0IFdlYkNvcmU6OktVUkwmIGJhc2VVUkwsIGNvbnN0IFZlY3RvcjxXVEY6OlN0cmluZz4m IHBhcmFtTmFtZXMsIGNvbnN0IFZlY3RvcjxXVEY6OlN0cmluZz4mIHBhcmFtVmFsdWVzKTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFdpbkNFLmNwcCBiL1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRXaW5DRS5jcHAKaW5kZXggNjRjMTBmZS4uZGI2ZWY2MyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdp bkNFLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50V2luQ0UuY3BwCkBAIC01OTcsNyArNTk3LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudFdpbkNFOjpzZXRNYWluRG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJl c291cmMKICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQg RnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2Fk KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVk TmFtZSkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmggYi9Tb3Vy Y2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaApp bmRleCA2YmVhYjBkLi45YTJlMjcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaAorKysgYi9Tb3VyY2UvV2ViS2l0 L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaApAQCAtMTI1LDcg KzEyNSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVu dFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygp KTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRM b2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1l bnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFd4LmNwcCBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFd4LmNwcAppbmRleCBkMTZmNjc3Li45ZTUxMmUwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAK KysrIGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3gu Y3BwCkBAIC04NDAsNyArODQwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpkaXNwYXRj aFVuYWJsZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKQogICAgIG5vdElt cGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFy dERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVk TmFtZSkKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaCBiL1NvdXJjZS9XZWJL aXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKaW5kZXggMGFmZGFkOS4u MjBmMDgxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50V3guaAorKysgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRXeC5oCkBAIC0yMDYsNyArMjA2LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9u QWN0aW9uKEZyYW1lUG9saWN5RnVuY3Rpb24gZnVuY3Rpb24sIGNvbnN0IE5hdmlnYXRpb25BY3Rp b24mLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAg ICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBS ZXNvdXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29u c3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAg ICAgIAogICAgICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJlIGhlcmUs IGJ1dCBpdCdzIG5lZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseQogICAgICAgICB2aXJ0dWFs IHZvaWQgcGFydENsZWFyZWRJbkJlZ2luKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQu Y3BwCmluZGV4IDMwMTc1MDYuLjA1ZjBhNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGll bnQuY3BwCkBAIC03ODksNyArNzg5LDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c2V0 TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAK LXZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VS ZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9h ZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVk TmFtZSkKIHsKICAgICBtX2ZyYW1lLT5zdGFydERvd25sb2FkKHJlcXVlc3QpOwogfQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxv YWRlckNsaWVudC5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJGcmFtZUxvYWRlckNsaWVudC5oCmluZGV4IDU2ZWY3ZWEuLmNlODQzZjAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJD bGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dl YkZyYW1lTG9hZGVyQ2xpZW50LmgKQEAgLTEyMiw3ICsxMjIsNyBAQCBwcml2YXRlOgogICAgIAog ICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogICAgIAot ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgCiAgICAgdmly dHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAg IHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1lLmNw cCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5jcHAKaW5kZXgg OTJhYWRjNi4uZTJmMzViMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJQYWdlL1dlYkZyYW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBh Z2UvV2ViRnJhbWUuY3BwCkBAIC0yMTUsNyArMjE1LDcgQEAgdm9pZCBXZWJGcmFtZTo6ZGlkUmVj ZWl2ZVBvbGljeURlY2lzaW9uKHVpbnQ2NF90IGxpc3RlbmVySUQsIFBvbGljeUFjdGlvbiBhY3Rp b24KICAgICAobV9jb3JlRnJhbWUtPmxvYWRlcigpLT5wb2xpY3lDaGVja2VyKCktPipmdW5jdGlv bikoYWN0aW9uKTsKIH0KIAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFydERvd25s b2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5n JiBzdWdnZXN0ZWROYW1lKQogewogICAgIEFTU0VSVChtX3BvbGljeURvd25sb2FkSUQpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUuaCBi L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oCmluZGV4IDk3NTcx MmQuLjkwNjBhMzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFn ZS9XZWJGcmFtZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJG cmFtZS5oCkBAIC03MCw3ICs3MCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGludmFsaWRhdGVQb2xp Y3lMaXN0ZW5lcigpOwogICAgIHZvaWQgZGlkUmVjZWl2ZVBvbGljeURlY2lzaW9uKHVpbnQ2NF90 IGxpc3RlbmVySUQsIFdlYkNvcmU6OlBvbGljeUFjdGlvbiwgdWludDY0X3QgZG93bmxvYWRJRCk7 CiAKLSAgICB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 Jik7CisgICAgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVz dCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgdm9pZCBjb252ZXJ0SGFuZGxlVG9E b3dubG9hZChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZSosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNl UmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgaW5pdGlhbFJlcXVlc3Qs IGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmKTsKIAogICAgIFN0cmluZyBzb3VyY2Uo KSBjb25zdDsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZp ZXdIb3N0LmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNw cAppbmRleCA2ZmIzMDkxLi5mODllYjIxIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vV2ViVmlld0hvc3QuY3BwCkBAIC03OTksNyArNzk5LDEyIEBAIGJvb2wgV2ViVmlld0hv c3Q6OmFsbG93SW1hZ2VzKFdlYkZyYW1lKiBmcmFtZSwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3Mp CiAgICAgcmV0dXJuIGVuYWJsZWRQZXJTZXR0aW5nczsKIH0KIAotdm9pZCBXZWJWaWV3SG9zdDo6 bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0 LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSkKK3ZvaWQgV2ViVmlld0hvc3Q6OmxvYWRVUkxF eHRlcm5hbGx5KFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVxdWVzdCwg V2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3kpCit7CisgICAgbG9hZFVSTEV4dGVybmFsbHkoZnJh bWUsIHJlcXVlc3QsIHBvbGljeSwgV2ViU3RyaW5nKCkpOworfQorCit2b2lkIFdlYlZpZXdIb3N0 Ojpsb2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVl c3QsIFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5LCBjb25zdCBXZWJTdHJpbmcmIGRvd25sb2Fk TmFtZSkKIHsKICAgICBBU1NFUlQocG9saWN5ICE9ICBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xp Y3lDdXJyZW50VGFiKTsKICAgICBXZWJWaWV3SG9zdCogYW5vdGhlciA9IG1fc2hlbGwtPmNyZWF0 ZU5ld1dpbmRvdyhyZXF1ZXN0LnVybCgpKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1 bS9XZWJWaWV3SG9zdC5oCmluZGV4IDI5NTFhZmYuLmVjNzhhOTIgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKKysrIGIvVG9vbHMvRHVtcFJl bmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaApAQCAtMTc0LDYgKzE3NCw3IEBAIGNsYXNz IFdlYlZpZXdIb3N0IDogcHVibGljIFdlYktpdDo6V2ViU3BlbGxDaGVja0NsaWVudCwgcHVibGlj IFdlYktpdDo6V2ViVmlld0NsCiAgICAgIHZpcnR1YWwgYm9vbCBhbGxvd1BsdWdpbnMoV2ViS2l0 OjpXZWJGcmFtZSosIGJvb2wgZW5hYmxlZFBlclNldHRpbmdzKTsKICAgICB2aXJ0dWFsIGJvb2wg YWxsb3dJbWFnZXMoV2ViS2l0OjpXZWJGcmFtZSosIGJvb2wgZW5hYmxlZFBlclNldHRpbmdzKTsK ICAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNv bnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSk7 CisgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5KFdlYktpdDo6V2ViRnJhbWUqLCBj b25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLCBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xpY3ks IGNvbnN0IFdlYktpdDo6V2ViU3RyaW5nJiBkb3dubG9hZE5hbWUpOwogICAgIHZpcnR1YWwgV2Vi S2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5IGRlY2lkZVBvbGljeUZvck5hdmlnYXRpb24oCiAgICAg ICAgIFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLAogICAg ICAgICBXZWJLaXQ6OldlYk5hdmlnYXRpb25UeXBlLCBjb25zdCBXZWJLaXQ6OldlYk5vZGUmLAo= 101763 2011-07-22 14:08:24 -0700 2011-07-23 17:37:23 -0700 proper use of ENABLE macro, and ChangeLog files webkit-a-download.patch text/plain 33879 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiYTJjZjkwLi5iMTM0NjMzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTEtMDct MjIgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNo b3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1 ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZh c3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9h ZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWw6IEFkZGVkLgorCiAyMDExLTA3 LTIyICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIEFub3RoZXIg Q2hyb21pdW0gcmViYXNlbGluZXMgYWZ0ZXIgcjkxNDkzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9h ZC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTk2ZmI2 OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1kb3dubG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorQmxvYiBVUkwK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLWRvd25sb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u ZDVkYjVhMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNo b3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCkBAIC0wLDAgKzEsMjkgQEAKKzwhRE9DVFlQ RSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0Jz4K K2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZHVtcEFzVGV4dCgpOworICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7 Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGEgaWQ9ImJsb2ItdXJsIiBkb3dubG9h ZD5CbG9iIFVSTDwvYT4KKzxzY3JpcHQ+CitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgdmFyIGJi ID0gbmV3IFdlYktpdEJsb2JCdWlsZGVyKCk7CisgIGJiLmFwcGVuZCgiPCFkb2N0eXBlIGh0bWw+ PGh0bWw+PGhlYWQ+PHRpdGxlPlRpdGxlPC90aXRsZT48c2NyaXB0PmlmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsgPC8iICsg InNjcmlwdD48L2hlYWQ+PGJvZHk+UEFTUzwvYm9keT48c2NyaXB0PmlmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTs8L3NjciIg KyAiaXB0PjwvaHRtbD4iKTsKKyAgdmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAi aW5saW5lIik7CisgIHZhciBsaW5rID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImJsb2ItdXJs Iik7CisgIGxpbmsuaHJlZiA9IHdpbmRvdy53ZWJraXRVUkwuY3JlYXRlT2JqZWN0VVJMKGJsb2Ip OworCisgIHZhciBldnQgPSBkb2N1bWVudC5jcmVhdGVFdmVudCgiTW91c2VFdmVudCIpOworICBl dnQuaW5pdE1vdXNlRXZlbnQoJ2NsaWNrJywgdHJ1ZSwgdHJ1ZSk7CisgIGxpbmsuZGlzcGF0Y2hF dmVudChldnQpOworfQorcnVuVGVzdCgpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It bm9kb3dubG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uN2VmMjJlOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZjVjZmIyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQuaHRt bApAQCAtMCwwICsxLDMwIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2Ny aXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVz dENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9k eT4KKzxhIGlkPSJibG9iLXVybCI+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVu VGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRCbG9iQnVpbGRlcigpOworICBiYi5hcHBl bmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlw dD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNjcmlw dD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5u b3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgIHZhciBibG9iID0gYmIuZ2V0 QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2YXIgbGluayA9IGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJMLmNy ZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZlbnQo Ik1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2ZW50KCdjbGljaycsIHRydWUsIHRydWUp OworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0Pgor PC9ib2R5PgorPC9odG1sPgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWVlZjY0Ni4uMDlmODMzZSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDExLTA3LTIyICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5 ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxv YWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1kb3dubG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCisKKyAgICAgICAgKiBodG1sL0hUTUxB bmNob3JFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxBbmNob3JFbGVtZW50Ojpk ZWZhdWx0RXZlbnRIYW5kbGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxBbmNob3JFbGVtZW50 OjpoYW5kbGVDbGljayk6CisgICAgICAgICogaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oOgorICAg ICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsOgorICAgICAgICAqIGh0bWwvSFRNTEF0 dHJpYnV0ZU5hbWVzLmluOgorICAgICAgICAqIGxvYWRlci9FbXB0eUNsaWVudHMuaDoKKyAgICAg ICAgKFdlYkNvcmU6OkVtcHR5RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQpOgorICAg ICAgICAqIGxvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oOgorCiAyMDExLTA3LTIyICBKaWEgUHUg IDxqcHVAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcAppbmRleCBhYTcyYWQ3Li44ZDVm YTAxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcApAQCAtMjcs NiArMjcsNyBAQAogI2luY2x1ZGUgIkF0dHJpYnV0ZS5oIgogI2luY2x1ZGUgIkV2ZW50TmFtZXMu aCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50LmgiCiAj aW5jbHVkZSAiRnJhbWVMb2FkZXJUeXBlcy5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQu aCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKQEAgLTE0NywxMCArMTQ4LDcgQEAgdm9pZCBIVE1M QW5jaG9yRWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiAgICAgICAg IH0KIAogICAgICAgICBpZiAoaXNMaW5rQ2xpY2soZXZlbnQpICYmIHRyZWF0TGlua0FzTGl2ZUZv ckV2ZW50VHlwZShldmVudFR5cGUoZXZlbnQpKSkgewotICAgICAgICAgICAgU3RyaW5nIHVybCA9 IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRNTFNwYWNlcyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIp KTsKLSAgICAgICAgICAgIGFwcGVuZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7 Ci0gICAgICAgICAgICBoYW5kbGVMaW5rQ2xpY2soZXZlbnQsIGRvY3VtZW50KCksIHVybCwgZ2V0 QXR0cmlidXRlKHRhcmdldEF0dHIpLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSk7Ci0gICAg ICAgICAgICBzZW5kUGluZ3MoZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKSk7CisgICAgICAg ICAgICBoYW5kbGVDbGljayhldmVudCk7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0K IApAQCAtNDkyLDYgKzQ5MCwzOCBAQCB2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpzZW5kUGluZ3Mo Y29uc3QgS1VSTCYgZGVzdGluYXRpb25VUkwpCiAgICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQaW5n KGRvY3VtZW50KCktPmZyYW1lKCksIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxzW2ld KSwgZGVzdGluYXRpb25VUkwpOwogfQogCit2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpoYW5kbGVD bGljayhFdmVudCogZXZlbnQpCit7CisgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7CisK KyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudCgpLT5mcmFtZSgpOworICAgIGlmICghZnJhbWUp CisgICAgICAgIHJldHVybjsKKworICAgIFN0cmluZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRUcmFp bGluZ0hUTUxTcGFjZXMoZmFzdEdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGFwcGVuZFNl cnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7CisgICAgS1VSTCBrdXJsID0gZG9jdW1l bnQoKS0+Y29tcGxldGVVUkwodXJsKTsKKworI2lmIEVOQUJMRShET1dOTE9BRF9BVFRSSUJVVEUp CisgICAgYm9vbCBkb3dubG9hZCA9IGhhc0F0dHJpYnV0ZShkb3dubG9hZEF0dHIpOworICAgIGlm IChkb3dubG9hZCkgeworICAgICAgICBSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsKKwor ICAgICAgICBpZiAoIWhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpKSB7CisgICAgICAgICAgICBT dHJpbmcgcmVmZXJyZXIgPSBmcmFtZS0+bG9hZGVyKCktPm91dGdvaW5nUmVmZXJyZXIoKTsKKyAg ICAgICAgICAgIGlmICghcmVmZXJyZXIuaXNFbXB0eSgpICYmICFTZWN1cml0eU9yaWdpbjo6c2hv dWxkSGlkZVJlZmVycmVyKGt1cmwsIHJlZmVycmVyKSkKKyAgICAgICAgICAgICAgICByZXF1ZXN0 LnNldEhUVFBSZWZlcnJlcihyZWZlcnJlcik7CisgICAgICAgICAgICBmcmFtZS0+bG9hZGVyKCkt PmFkZEV4dHJhRmllbGRzVG9NYWluUmVzb3VyY2VSZXF1ZXN0KHJlcXVlc3QpOworICAgICAgICB9 CisKKyAgICAgICAgZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+c3RhcnREb3dubG9hZChyZXF1 ZXN0LCBmYXN0R2V0QXR0cmlidXRlKGRvd25sb2FkQXR0cikpOworICAgIH0gZWxzZQorI2VuZGlm CisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+dXJsU2VsZWN0ZWQoa3VybCwgdGFyZ2V0KCksIGV2 ZW50LCBmYWxzZSwgZmFsc2UsIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpID8gTm9SZWZlcnJl ciA6IFNlbmRSZWZlcnJlcik7CisKKyAgICBzZW5kUGluZ3Moa3VybCk7Cit9CisKIEhUTUxBbmNo b3JFbGVtZW50OjpFdmVudFR5cGUgSFRNTEFuY2hvckVsZW1lbnQ6OmV2ZW50VHlwZShFdmVudCog ZXZlbnQpCiB7CiAgICAgaWYgKCFldmVudC0+aXNNb3VzZUV2ZW50KCkpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmgKaW5kZXggODYwYWQzNS4uOTQ3Zjc0NiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaApAQCAtMTE1LDYgKzExNSw4IEBAIHByaXZh dGU6CiAKICAgICB2b2lkIHNlbmRQaW5ncyhjb25zdCBLVVJMJiBkZXN0aW5hdGlvblVSTCk7CiAK KyAgICB2b2lkIGhhbmRsZUNsaWNrKEV2ZW50Kik7CisKICAgICBlbnVtIEV2ZW50VHlwZSB7CiAg ICAgICAgIE1vdXNlRXZlbnRXaXRob3V0U2hpZnRLZXksCiAgICAgICAgIE1vdXNlRXZlbnRXaXRo U2hpZnRLZXksCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVt ZW50LmlkbCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCmluZGV4 IDg3MWZjZGYuLmYxNzg0N2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFu Y2hvckVsZW1lbnQuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1l bnQuaWRsCkBAIC01Niw2ICs1NiwxMCBAQCBtb2R1bGUgaHRtbCB7CiAgICAgICAgIHJlYWRvbmx5 IGF0dHJpYnV0ZSBbQ29udmVydE51bGxUb051bGxTdHJpbmddIERPTVN0cmluZyBvcmlnaW47CiAj ZW5kaWYKIAorI2lmIEVOQUJMRShET1dOTE9BRF9BVFRSSUJVVEUpCisgICAgICAgIGF0dHJpYnV0 ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGRvd25sb2FkOworI2VuZGlmCisKICAgICAgICAgRE9NU3Ry aW5nIGdldFBhcmFtZXRlcihpbiBET01TdHJpbmcgbmFtZSk7CiAKICAgICAgICAgcmVhZG9ubHkg YXR0cmlidXRlIERPTVN0cmluZyB0ZXh0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MQXR0cmlidXRlTmFtZXMuaW4gYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1 dGVOYW1lcy5pbgppbmRleCAxNjc5ZTk2Li44NDEwZGU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgpAQCAtOTEsNiArOTEsNyBAQCBkZWZlcgogZGlyCiBkaXJl Y3Rpb24KIGRpc2FibGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3ZWJraXRkcm9wem9uZQogZW5j dHlwZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oIGIv U291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCmluZGV4IDc4NWIxMmMuLmQwYjIw YTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgKQEAgLTMxMCw3ICszMTAsNyBA QCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShi b29sKSB7IH0KIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSkgeyB9CiAKICAgICB2aXJ0dWFs IHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CiAgICAgdmlydHVhbCB2 b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2xv YWRlci9GcmFtZUxvYWRlckNsaWVudC5oCmluZGV4IDM4NTIzODMuLmFhMGYyZjIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCkBAIC0xNzksNyArMTc5LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAKICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1h aW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCkgPSAwOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpID0gMDsKKyAgICAgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5n JiA9IFN0cmluZygpKSA9IDA7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRs ZShEb2N1bWVudExvYWRlciopID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRp dGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCA5 YmFlOGUzLi41ZmJmMTNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4 IEBACisyMDExLTA3LTIyICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVt Lm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRy aWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBmZWF0dXJlcy5neXBpOgorICAgICAgICAqIHB1YmxpYy9XZWJGcmFtZUNsaWVu dC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZUNsaWVudDo6bG9hZFVSTEV4dGVybmFsbHkp OgorICAgICAgICAqIHNyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2Vi S2l0OjpGcmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdh dGlvbkFjdGlvbik6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3Rh cnREb3dubG9hZCk6CisgICAgICAgICogc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oOgorCiAy MDExLTA3LTIyICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJl dmVydCByOTE1MTAgZHVlIHRvIENocm9taXVtIGRlYnVnIHRlc3QgZmFpbHVyZXMuCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL2ZlYXR1cmVzLmd5cGkgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL2ZlYXR1cmVzLmd5cGkKaW5kZXggNDNkYjQ4My4uOTZmN2NkMyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9mZWF0dXJlcy5neXBpCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vZmVhdHVyZXMuZ3lwaQpAQCAtNDQsNiArNDQsNyBAQAogICAgICAgJ0VOQUJM RV9ERVZJQ0VfT1JJRU5UQVRJT049MScsCiAgICAgICAnRU5BQkxFX0RJUkVDVE9SWV9VUExPQUQ9 MScsCiAgICAgICAnRU5BQkxFX0RPTV9TVE9SQUdFPTEnLAorICAgICAgJ0VOQUJMRV9ET1dOTE9B RF9BVFRSSUJVVEU9MScsCiAgICAgICAnRU5BQkxFX0VWRU5UU09VUkNFPTEnLAogICAgICAgJ0VO QUJMRV9KQVZBU0NSSVBUX0kxOE5fQVBJPTEnLAogICAgICAgJ0VOQUJMRV9GSUxFX1NZU1RFTT0x JywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xp ZW50LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oCmlu ZGV4IGIxOTNmZWMuLjBhZjk2Y2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYkZyYW1lQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViRnJhbWVDbGllbnQuaApAQCAtMTE2LDYgKzExNiw4IEBAIHB1YmxpYzoKICAgICAvLyBU aGUgY2xpZW50IHNob3VsZCBoYW5kbGUgdGhlIG5hdmlnYXRpb24gZXh0ZXJuYWxseS4KICAgICB2 aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoCiAgICAgICAgIFdlYkZyYW1lKiwgY29uc3Qg V2ViVVJMUmVxdWVzdCYsIFdlYk5hdmlnYXRpb25Qb2xpY3kpIHsgfQorICAgIHZpcnR1YWwgdm9p ZCBsb2FkVVJMRXh0ZXJuYWxseSgKKyAgICAgICAgV2ViRnJhbWUqLCBjb25zdCBXZWJVUkxSZXF1 ZXN0JiwgV2ViTmF2aWdhdGlvblBvbGljeSwgY29uc3QgV2ViU3RyaW5nJiBkb3dubG9hZE5hbWUp IHsgfQogCiAKICAgICAvLyBOYXZpZ2F0aW9uYWwgcXVlcmllcyAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCmluZGV4IDc5ZGRkNjguLmEyZmQx MDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xp ZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJD bGllbnRJbXBsLmNwcApAQCAtOTQ0LDcgKzk0NCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRJ bXBsOjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24oCiAgICAgUG9saWN5 QWN0aW9uIHBvbGljeUFjdGlvbiA9IFBvbGljeUlnbm9yZTsKIAogICAgIC8vIEl0IGlzIHZhbGlk IGZvciB0aGlzIGZ1bmN0aW9uIHRvIGJlIGludm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUK LSAgICAvLyB0aGUgd2VidmlldyBpcyBjbG9zZWQuCisgICAgLy8gd2VidmlldyBpcyBjbG9zZWQu CiAgICAgLy8gVGhlIG51bGwgY2hlY2sgaGVyZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1z IHN0cmFuZ2UKICAgICAvLyAoc2VlIC0gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIzNTU0KS4KICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3Qu dXJsKCkuaXNOdWxsKCkpIHsKQEAgLTEwNzMsNyArMTA3Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXJD bGllbnRJbXBsOjpzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wgcmVhZHkpCiAKIC8vIENy ZWF0ZXMgYSBuZXcgY29ubmVjdGlvbiBhbmQgYmVnaW5zIGRvd25sb2FkaW5nIGZyb20gdGhhdCAo Y29udHJhc3QgdGhpcwogLy8gd2l0aCB8ZG93bmxvYWR8KS4KLXZvaWQgRnJhbWVMb2FkZXJDbGll bnRJbXBsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3Zv aWQgRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVx dWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmICht X3dlYkZyYW1lLT5jbGllbnQoKSkgewogICAgICAgICBXcmFwcGVkUmVzb3VyY2VSZXF1ZXN0IHdl YnJlcShyZXF1ZXN0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0Zy YW1lTG9hZGVyQ2xpZW50SW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVM b2FkZXJDbGllbnRJbXBsLmgKaW5kZXggYWRhZjlkMy4uZjFmMDI0ZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKKysrIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKQEAgLTEzMSw3 ICsxMzEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHBvc3RQcm9ncmVzc0VzdGltYXRl Q2hhbmdlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9pZCBwb3N0UHJvZ3Jlc3NGaW5p c2hlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVu dFJlYWR5KGJvb2wpOwotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7 CiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRl ciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExv YWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBjb21taXR0ZWRMb2FkKFdlYkNvcmU6OkRvY3VtZW50 TG9hZGVyKiwgY29uc3QgY2hhciosIGludCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Vm bC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggZmYxYjYyYi4u MmY0ZGE3NCAxMDA3NTUKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTIyICBT YWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBB ZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaDoKKwogMjAxMS0wNy0xOSAgR3l1eW91bmcgS2ltICA8 Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFtFRkxdIEFkZCBld2tfbmV0d29y ay5jcHB8aCBmaWxlcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAppbmRleCA5ZTI3NTdmLi45YTJkZmNmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudEVmbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRFZmwuY3BwCkBAIC04NzEsNyArODcxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudEVmbDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgY29u c3QgUmUKICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQg RnJhbWVMb2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0 JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkK IHsKICAgICBpZiAoIW1fdmlldykKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaCBiL1NvdXJj ZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKaW5kZXgg NDdhYjNkNC4uOWU2ZDFjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCkBAIC0xNTMsNyArMTUzLDcgQEAgY2xh c3MgRnJhbWVMb2FkZXJDbGllbnRFZmwgOiBwdWJsaWMgRnJhbWVMb2FkZXJDbGllbnQgewogCiAg ICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBT dHJpbmcmID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShE b2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVu dExvYWRlciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IGFkNTczZjEuLmFiNTc0MzEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhhYmliIENob3dk aHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRv d25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6c3Rh cnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRH dGsuaDoKKwogMjAxMS0wNy0xMSAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9y Zz4KIAogICAgICAgICBbR1RLXSBHb29nbGUgQ2FsZW5kYXIgdGhpbmtzIHdlJ3JlIG1vYmlsZQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRHdGsuY3BwIGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuY3BwCmluZGV4IDI2YzUzNGUuLjUyZTM3NmMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5j cHAKQEAgLTEyMjEsNyArMTIyMSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldE1haW5E b2N1bWVudEVycm9yKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzCiAgICAgfQog fQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5h bWUpCiB7CiAgICAgR1JlZlB0cjxXZWJLaXROZXR3b3JrUmVxdWVzdD4gbmV0d29ya1JlcXVlc3Qo YWRvcHRHUmVmKGtpdE5ldyhyZXF1ZXN0KSkpOwogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBn ZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaCBiL1NvdXJjZS9XZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKaW5kZXggMjQ0ODI5Zi4uN2M1 ODMyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRHdGsuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5oCkBAIC0xMzAsNyArMTMwLDcgQEAgbmFtZXNwYWNlIFdlYktp dCB7CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9v bCk7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7 CiAKICAgICAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVu dExvYWRlciopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6 RG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvQ2hhbmdl TG9nIGIvU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cKaW5kZXggN2JhNzFhMC4uMWJhNTdl YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yMiAgU2Fk cnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRk IHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1Lmg6CisKIDIwMTEtMDctMTUgIERhbiBCZXJuc3Rl aW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OOiBNb3VzZSBjdXJzb3Ig ZG9lc27igJl0IGhpZGUgd2hlbiBmdWxsIHNjcmVlbiB2aWRlbyBIVUQgaGlkZXMKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRI YWlrdS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50SGFpa3UuY3BwCmluZGV4IDI4NWEzZmEuLjBjNDY4YWYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAK KysrIGIvU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dEhhaWt1LmNwcApAQCAtNzA5LDcgKzcwOSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlr dTo6ZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yCiAg ICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1Ojpz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3Ry aW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 SGFpa3UuaCBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRIYWlrdS5oCmluZGV4IDc5ZWU5MTQuLjllODcwOTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5oCisrKyBi L1NvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlr dS5oCkBAIC0yMTksNyArMjE5LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBhc3NSZWZQ dHI8Rm9ybVN0YXRlPik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaFVuYWJsZVRvSW1w bGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKTsKIAotICAgICAgICB2aXJ0dWFsIHZv aWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5n JiA9IFN0cmluZygpKTsKIAogICAgICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkg bm90IGJlIGhlcmUsIGJ1dCBpdCdzIG5lZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseS4KICAg ICAgICAgdmlydHVhbCB2b2lkIHBhcnRDbGVhcmVkSW5CZWdpbigpOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRl eCBjMGI4OTdhLi5hYmExMTYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxv ZworKysgYi9Tb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEx LTA3LTIyICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4g YW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaDoKKwogMjAxMS0wNy0xOSAgQ2FpbyBNYXJj ZWxvIGRlIE9saXZlaXJhIEZpbGhvICA8Y2Fpby5vbGl2ZWlyYUBvcGVuYm9zc2Eub3JnPgogCiAg ICAgICAgIFtRdF0gSW1wcm92ZSBkb2N1bWVudGF0aW9uIG9mIFFXZWJWaWV3OjpzZXRQYWdlKCkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRRdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50UXQuY3BwCmluZGV4IDlhMWUxZmYuLmEyY2JiZmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKKysrIGIvU291 cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcApAQCAt MTI5Niw3ICsxMjk2LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaFVuYWJs ZVRvSW1wbGVtZW50UG9saWN5KGNvbnN0IFdlYkNvcmU6OlJlc291cmMKICAgICBub3RJbXBsZW1l bnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29u c3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNs aWVudFF0OjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVx dWVzdCwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIGlmICghbV93ZWJGcmFt ZSkKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmggYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAppbmRleCAxMjEzMDNkLi45MThmYjIwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50UXQuaApAQCAtMTQ5LDcgKzE0OSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBz ZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0 RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2 b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3Qg U3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUo RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1l bnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZwppbmRleCA0ZjI2YWZmLi44MGYwNTg2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC93aW4v Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDctMjIgIFNhZHJ1bCBIYWJpYiBDaG93 ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBk b3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkZyYW1lLmNwcDoKKyAgICAgICAg KFdlYkZyYW1lOjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJGcmFtZS5oOgorCiAyMDEx LTA3LTE4ICBEZWFuIEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KIAogICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ3NDIKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcCBiL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNw cAppbmRleCBiOGJiMjQ5Li5mZDU5MGYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbi9X ZWJGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCkBAIC0xOTA3 LDcgKzE5MDcsNyBAQCB2b2lkIFdlYkZyYW1lOjpkaXNwYXRjaERpZEZhaWxMb2FkKGNvbnN0IFJl c291cmNlRXJyb3ImIGVycm9yKQogICAgIH0KIH0KIAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3du bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFy dERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiBz dWdnZXN0ZWROYW1lKQogewogICAgIGQtPndlYlZpZXctPmRvd25sb2FkVVJMKHJlcXVlc3QudXJs KCkpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaCBiL1NvdXJj ZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgKaW5kZXggODA0NmQ4NS4uNzczOTUwZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbi9X ZWJGcmFtZS5oCkBAIC0zNDIsNyArMzQyLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBk aXNwYXRjaERpZExvYWRSZXNvdXJjZUZyb21NZW1vcnlDYWNoZShXZWJDb3JlOjpEb2N1bWVudExv YWRlciosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVzcG9uc2UmLCBpbnQgbGVuZ3RoKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hE aWRGYWlsUHJvdmlzaW9uYWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3ImKTsKICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWlsTG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZUVycm9yJik7Ci0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKICAg ICAgICAgCiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYkNvcmU6OldpZGdldD4gY3JlYXRlSmF2 YUFwcGxldFdpZGdldChjb25zdCBXZWJDb3JlOjpJbnRTaXplJiwgV2ViQ29yZTo6SFRNTEFwcGxl dEVsZW1lbnQqLCBjb25zdCBXZWJDb3JlOjpLVVJMJiBiYXNlVVJMLCBjb25zdCBWZWN0b3I8V1RG OjpTdHJpbmc+JiBwYXJhbU5hbWVzLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbVZh bHVlcyk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd2luY2UvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKaW5kZXggNTBlMzFlNC4uOWVlNzNhYiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC93 aW5jZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhhYmli IENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQg Zm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRXaW5DRS5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xp ZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50V2luQ0UuaDoKKwogMjAxMS0wNy0xNSAgRGFuIEJlcm5zdGVpbiAgPG1pdHpA YXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT046IE1vdXNlIGN1cnNvciBkb2VzbuKAmXQg aGlkZSB3aGVuIGZ1bGwgc2NyZWVuIHZpZGVvIEhVRCBoaWRlcwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcCBi L1NvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5D RS5jcHAKaW5kZXggNjRjMTBmZS4uZGI2ZWY2MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93 aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3Bw CkBAIC01OTcsNyArNTk3LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzZXRNYWlu RG9jdW1lbnRFcnJvcihEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmMKICAgICBtX2hhc1Nl bnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRX aW5DRTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKQordm9p ZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSkKIHsKICAgICBub3RJ bXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmggYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaAppbmRleCA2YmVhYjBkLi45YTJl MjcxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50V2luQ0UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaApAQCAtMTI1LDcgKzEyNSw3IEBAIHB1YmxpYzoK IAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0g ICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1 ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwg dm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0 dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC93eC9DaGFu Z2VMb2cKaW5kZXggYzU3NjRlMi4uNTIyODRhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93 eC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC93eC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NCBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0 cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQpOgorICAgICAg ICAqIFdlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oOgorCiAyMDExLTA3LTE1ICBE YW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgUkVHUkVTU0lPTjogTW91 c2UgY3Vyc29yIGRvZXNu4oCZdCBoaWRlIHdoZW4gZnVsbCBzY3JlZW4gdmlkZW8gSFVEIGhpZGVz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRXeC5jcHAgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRXeC5jcHAKaW5kZXggZDE2ZjY3Ny4uOWU1MTJlMCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcApAQCAtODQw LDcgKzg0MCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6ZGlzcGF0Y2hVbmFibGVUb0lt cGxlbWVudFBvbGljeShjb25zdCBSZXNvdXJjZUVycm9yJikKICAgICBub3RJbXBsZW1lbnRlZCgp OwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9hZChj b25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUpCiB7CiAg ICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvV2Vi S2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmggYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktp dFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oCmluZGV4IDBhZmRhZDkuLjIwZjA4MTIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dFd4LmgKKysrIGIvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xp ZW50V3guaApAQCAtMjA2LDcgKzIwNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAg dmlydHVhbCB2b2lkIGRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFt ZVBvbGljeUZ1bmN0aW9uIGZ1bmN0aW9uLCBjb25zdCBOYXZpZ2F0aW9uQWN0aW9uJiwgY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiwgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAgdmlydHVh bCB2b2lkIGRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJv ciYpOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNl UmVxdWVzdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmID0gU3RyaW5nKCkpOwogICAgICAgICAKICAgICAg ICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IG5vdCBiZSBoZXJlLCBidXQgaXQncyBu ZWVkZWQgZm9yIHRoZSB0ZXN0cyBjdXJyZW50bHkKICAgICAgICAgdmlydHVhbCB2b2lkIHBhcnRD bGVhcmVkSW5CZWdpbigpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDdlNTU3YmYuLjRjNWMwNDEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNyBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAg PHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2Fk PSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJG cmFtZUxvYWRlckNsaWVudC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkZyYW1lTG9hZGVyQ2xp ZW50OjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkZyYW1lTG9hZGVyQ2xpZW50Lmg6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dl YkZyYW1lLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQpOgor ICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oOgorCiAyMDExLTA3LTIxICBZ YWVsIEFoYXJvbiAgPHlhZWwuYWhhcm9uQG5va2lhLmNvbT4KIAogICAgICAgICBbUXRdW1dLMl0g Q29kZSBjbGVhbnVwIGZvciBkcmFnLWFuZC1kcm9wCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcCBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGll bnQuY3BwCmluZGV4IDMwMTc1MDYuLjA1ZjBhNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJD bGllbnQuY3BwCkBAIC03ODksNyArNzg5LDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6 c2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9 CiAKLXZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3du bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgc3VnZ2Vz dGVkTmFtZSkKIHsKICAgICBtX2ZyYW1lLT5zdGFydERvd25sb2FkKHJlcXVlc3QpOwogfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFt ZUxvYWRlckNsaWVudC5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCmluZGV4IDU2ZWY3ZWEuLmNlODQzZjAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2Fk ZXJDbGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgKQEAgLTEyMiw3ICsxMjIsNyBAQCBwcml2YXRlOgogICAg IAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogICAg IAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNl UmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6 OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwog ICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciop OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkZyYW1l LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5jcHAKaW5k ZXggOTJhYWRjNi4uZTJmMzViMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYkZyYW1lLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YlBhZ2UvV2ViRnJhbWUuY3BwCkBAIC0yMTUsNyArMjE1LDcgQEAgdm9pZCBXZWJGcmFtZTo6ZGlk UmVjZWl2ZVBvbGljeURlY2lzaW9uKHVpbnQ2NF90IGxpc3RlbmVySUQsIFBvbGljeUFjdGlvbiBh Y3Rpb24KICAgICAobV9jb3JlRnJhbWUtPmxvYWRlcigpLT5wb2xpY3lDaGVja2VyKCktPipmdW5j dGlvbikoYWN0aW9uKTsKIH0KIAotdm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIFdlYkZyYW1lOjpzdGFydERv d25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3Ry aW5nJiBzdWdnZXN0ZWROYW1lKQogewogICAgIEFTU0VSVChtX3BvbGljeURvd25sb2FkSUQpOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViRnJhbWUu aCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJGcmFtZS5oCmluZGV4IDk3 NTcxMmQuLjkwNjBhMzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJGcmFtZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9X ZWJGcmFtZS5oCkBAIC03MCw3ICs3MCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGludmFsaWRhdGVQ b2xpY3lMaXN0ZW5lcigpOwogICAgIHZvaWQgZGlkUmVjZWl2ZVBvbGljeURlY2lzaW9uKHVpbnQ2 NF90IGxpc3RlbmVySUQsIFdlYkNvcmU6OlBvbGljeUFjdGlvbiwgdWludDY0X3QgZG93bmxvYWRJ RCk7CiAKLSAgICB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1 ZXN0Jik7CisgICAgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdCYsIGNvbnN0IFN0cmluZyYgPSBTdHJpbmcoKSk7CiAgICAgdm9pZCBjb252ZXJ0SGFuZGxl VG9Eb3dubG9hZChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZSosIGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgaW5pdGlhbFJlcXVl c3QsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmKTsKIAogICAgIFN0cmluZyBzb3Vy Y2UoKSBjb25zdDsKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxv ZwppbmRleCBmOTMxZmU2Li40OWJiMmVhIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysr IGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDctMjIgIFNhZHJ1bCBI YWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBw b3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVl L2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcDoKKyAgICAgICAgKFdlYlZpZXdIb3N0Ojpsb2FkVVJM RXh0ZXJuYWxseSk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hv c3QuaDoKKwogMjAxMS0wNy0yMSAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAg ICAgICAgRml4IHR5cG8gaW4gVGVzdEZhaWx1cmVzCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKaW5kZXggNmZiMzA5MS4uZjg5ZWIyMSAxMDA2NDQKLS0t IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCisrKyBiL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcApAQCAtNzk5LDcgKzc5 OSwxMiBAQCBib29sIFdlYlZpZXdIb3N0OjphbGxvd0ltYWdlcyhXZWJGcmFtZSogZnJhbWUsIGJv b2wgZW5hYmxlZFBlclNldHRpbmdzKQogICAgIHJldHVybiBlbmFibGVkUGVyU2V0dGluZ3M7CiB9 CiAKLXZvaWQgV2ViVmlld0hvc3Q6OmxvYWRVUkxFeHRlcm5hbGx5KFdlYkZyYW1lKiwgY29uc3Qg V2ViVVJMUmVxdWVzdCYgcmVxdWVzdCwgV2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3kpCit2b2lk IFdlYlZpZXdIb3N0Ojpsb2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdl YlVSTFJlcXVlc3QmIHJlcXVlc3QsIFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5KQoreworICAg IGxvYWRVUkxFeHRlcm5hbGx5KGZyYW1lLCByZXF1ZXN0LCBwb2xpY3ksIFdlYlN0cmluZygpKTsK K30KKwordm9pZCBXZWJWaWV3SG9zdDo6bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUqLCBjb25z dCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSwgY29u c3QgV2ViU3RyaW5nJiBkb3dubG9hZE5hbWUpCiB7CiAgICAgQVNTRVJUKHBvbGljeSAhPSAgV2Vi S2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5Q3VycmVudFRhYik7CiAgICAgV2ViVmlld0hvc3QqIGFu b3RoZXIgPSBtX3NoZWxsLT5jcmVhdGVOZXdXaW5kb3cocmVxdWVzdC51cmwoKSk7CmRpZmYgLS1n aXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oIGIvVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaAppbmRleCAyOTUxYWZmLi5lYzc4 YTkyIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9z dC5oCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKQEAg LTE3NCw2ICsxNzQsNyBAQCBjbGFzcyBXZWJWaWV3SG9zdCA6IHB1YmxpYyBXZWJLaXQ6OldlYlNw ZWxsQ2hlY2tDbGllbnQsIHB1YmxpYyBXZWJLaXQ6OldlYlZpZXdDbAogICAgICB2aXJ0dWFsIGJv b2wgYWxsb3dQbHVnaW5zKFdlYktpdDo6V2ViRnJhbWUqLCBib29sIGVuYWJsZWRQZXJTZXR0aW5n cyk7CiAgICAgdmlydHVhbCBib29sIGFsbG93SW1hZ2VzKFdlYktpdDo6V2ViRnJhbWUqLCBib29s IGVuYWJsZWRQZXJTZXR0aW5ncyk7CiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5 KFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLCBXZWJLaXQ6 OldlYk5hdmlnYXRpb25Qb2xpY3kpOworICAgIHZpcnR1YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxs eShXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0OjpXZWJVUkxSZXF1ZXN0JiwgV2ViS2l0 OjpXZWJOYXZpZ2F0aW9uUG9saWN5LCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYgZG93bmxvYWRO YW1lKTsKICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSBkZWNpZGVQb2xp Y3lGb3JOYXZpZ2F0aW9uKAogICAgICAgICBXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0 OjpXZWJVUkxSZXF1ZXN0JiwKICAgICAgICAgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uVHlwZSwgY29u c3QgV2ViS2l0OjpXZWJOb2RlJiwK 101825 2011-07-23 17:31:51 -0700 2011-07-26 13:38:21 -0700 updated webkit-a-download.patch text/plain 37657 sadrul ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiYTJjZjkwLi41NjRhMWFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDct MjIgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNo b3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1 ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZh c3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9h ZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWw6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNldC1leHBlY3Rl ZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC11bnNldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAg ICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQu aHRtbDogQWRkZWQuCisKIDIwMTEtMDctMjIgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CiAKICAgICAgICAgQW5vdGhlciBDaHJvbWl1bSByZWJhc2VsaW5lcyBhZnRlciByOTE0OTMu CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3ItZG93bmxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hv ckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi5hOTZmYjY5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLWV4cGVjdGVkLnR4dApA QCAtMCwwICsxIEBACitCbG9iIFVSTApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLXVuc2V0LWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNl dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2VmMjJl OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1kb3dubG9hZC11bnNldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorUEFT UwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5j aG9yLWRvd25sb2FkLXVuc2V0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi4zMGQ1ZWQ5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLXVuc2V0Lmh0bWwKQEAgLTAs MCArMSwzMCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBl PSd0ZXh0L2phdmFzY3JpcHQnPgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewor ICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9s bGVyLndhaXRVbnRpbERvbmUoKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBp ZD0iYmxvYi11cmwiIGRvd25sb2FkPkJsb2IgVVJMPC9hPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHJ1 blRlc3QoKQoreworICB2YXIgYmIgPSBuZXcgV2ViS2l0QmxvYkJ1aWxkZXIoKTsKKyAgYmIuYXBw ZW5kKCI8IWRvY3R5cGUgaHRtbD48aHRtbD48aGVhZD48dGl0bGU+VGl0bGU8L3RpdGxlPjxzY3Jp cHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOyA8LyIgKyAic2NyaXB0PjwvaGVhZD48Ym9keT5QQVNTPC9ib2R5PjxzY3Jp cHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIu bm90aWZ5RG9uZSgpOzwvc2NyIiArICJpcHQ+PC9odG1sPiIpOworICB2YXIgYmxvYiA9IGJiLmdl dEJsb2IoInRleHQvaHRtbCIsICJpbmxpbmUiKTsKKyAgdmFyIGxpbmsgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgbGluay5ocmVmID0gd2luZG93LndlYmtpdFVSTC5j cmVhdGVPYmplY3RVUkwoYmxvYik7CisgIGxpbmsucmVtb3ZlQXR0cmlidXRlKCdkb3dubG9hZCcp OworCisgIHZhciBldnQgPSBkb2N1bWVudC5jcmVhdGVFdmVudCgiTW91c2VFdmVudCIpOworICBl dnQuaW5pdE1vdXNlRXZlbnQoJ2NsaWNrJywgdHJ1ZSwgdHJ1ZSk7CisgIGxpbmsuZGlzcGF0Y2hF dmVudChldnQpOworfQorcnVuVGVzdCgpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It ZG93bmxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1kb3dubG9hZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ1 ZGI1YTIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbApAQCAtMCwwICsxLDI5IEBACis8IURPQ1RZUEUg aHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+Citp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOwor fQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCIgZG93bmxvYWQ+ QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgIHZhciBiYiA9 IG5ldyBXZWJLaXRCbG9iQnVpbGRlcigpOworICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxo dG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJz Y3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsg ImlwdD48L2h0bWw+Iik7CisgIHZhciBibG9iID0gYmIuZ2V0QmxvYigidGV4dC9odG1sIiwgImlu bGluZSIpOworICB2YXIgbGluayA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJibG9iLXVybCIp OworICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsK KworICB2YXIgZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZlbnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0 LmluaXRNb3VzZUV2ZW50KCdjbGljaycsIHRydWUsIHRydWUpOworICBsaW5rLmRpc3BhdGNoRXZl bnQoZXZ0KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5v ZG93bmxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVs ZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjdlZjIyZTkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtc2V0LWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLXNldC1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTk2ZmI2OQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50 L2FuY2hvci1ub2Rvd25sb2FkLXNldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorQmxvYiBV UkwKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1ub2Rvd25sb2FkLXNldC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hv ckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtc2V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uOWE5OWJkYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLXNldC5odG1sCkBAIC0w LDAgKzEsMzEgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQgdHlw ZT0ndGV4dC9qYXZhc2NyaXB0Jz4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsK KyAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICBsYXlvdXRUZXN0Q29udHJv bGxlci53YWl0VW50aWxEb25lKCk7Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGEg aWQ9ImJsb2ItdXJsIj5CbG9iIFVSTDwvYT4KKzxzY3JpcHQ+CitmdW5jdGlvbiBydW5UZXN0KCkK K3sKKyAgdmFyIGJiID0gbmV3IFdlYktpdEJsb2JCdWlsZGVyKCk7CisgIGJiLmFwcGVuZCgiPCFk b2N0eXBlIGh0bWw+PGh0bWw+PGhlYWQ+PHRpdGxlPlRpdGxlPC90aXRsZT48c2NyaXB0PmlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsgPC8iICsgInNjcmlwdD48L2hlYWQ+PGJvZHk+UEFTUzwvYm9keT48c2NyaXB0PmlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTs8L3NjciIgKyAiaXB0PjwvaHRtbD4iKTsKKyAgdmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0 ZXh0L2h0bWwiLCAiaW5saW5lIik7CisgIHZhciBsaW5rID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImJsb2ItdXJsIik7CisgIGxpbmsuaHJlZiA9IHdpbmRvdy53ZWJraXRVUkwuY3JlYXRlT2Jq ZWN0VVJMKGJsb2IpOworICBsaW5rLnNldEF0dHJpYnV0ZSgnZG93bmxvYWQnKTsKKworICB2YXIg ZXZ0ID0gZG9jdW1lbnQuY3JlYXRlRXZlbnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3Vz ZUV2ZW50KCdjbGljaycsIHRydWUsIHRydWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsK K30KK3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgorCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9h ZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5v ZG93bmxvYWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZjVjZmIy Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1l bnQvYW5jaG9yLW5vZG93bmxvYWQuaHRtbApAQCAtMCwwICsxLDMwIEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQor PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCI+QmxvYiBVUkw8L2E+ Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgIHZhciBiYiA9IG5ldyBXZWJLaXRC bG9iQnVpbGRlcigpOworICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0 aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KSBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFk Pjxib2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+ Iik7CisgIHZhciBibG9iID0gYmIuZ2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICB2 YXIgbGluayA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJibG9iLXVybCIpOworICBsaW5rLmhy ZWYgPSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKworICB2YXIgZXZ0 ID0gZG9jdW1lbnQuY3JlYXRlRXZlbnQoIk1vdXNlRXZlbnQiKTsKKyAgZXZ0LmluaXRNb3VzZUV2 ZW50KCdjbGljaycsIHRydWUsIHRydWUpOworICBsaW5rLmRpc3BhdGNoRXZlbnQoZXZ0KTsKK30K K3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgorCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZWVlZjY0Ni4uYTIyNDJlNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDExLTA3LTIy ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAg ICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9y cy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgw CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdHM6 IGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCisgICAgICAg ICAgICAgICBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1s CisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxv YWQtdW5zZXQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLW5vZG93bmxvYWQtc2V0Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVs ZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRF dmVudEhhbmRsZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRs ZUNsaWNrKToKKyAgICAgICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50Lmg6CisgICAgICAgICog aHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGw6CisgICAgICAgICogaHRtbC9IVE1MQXR0cmlidXRl TmFtZXMuaW46CisgICAgICAgICogbG9hZGVyL0VtcHR5Q2xpZW50cy5oOgorICAgICAgICAoV2Vi Q29yZTo6RW1wdHlGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICog bG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50Lmg6CisKIDIwMTEtMDctMjIgIEppYSBQdSAgPGpwdUBh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwCmluZGV4IGFhNzJhZDcuLmUwYzI0NDkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwCkBAIC0yNyw2ICsyNyw3 IEBACiAjaW5jbHVkZSAiQXR0cmlidXRlLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2lu Y2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRl ICJGcmFtZUxvYWRlclR5cGVzLmgiCiAjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgogI2lu Y2x1ZGUgIkhUTUxOYW1lcy5oIgpAQCAtMTQ3LDEwICsxNDgsNyBAQCB2b2lkIEhUTUxBbmNob3JF bGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkKICAgICAgICAgfQogCiAg ICAgICAgIGlmIChpc0xpbmtDbGljayhldmVudCkgJiYgdHJlYXRMaW5rQXNMaXZlRm9yRXZlbnRU eXBlKGV2ZW50VHlwZShldmVudCkpKSB7Ci0gICAgICAgICAgICBTdHJpbmcgdXJsID0gc3RyaXBM ZWFkaW5nQW5kVHJhaWxpbmdIVE1MU3BhY2VzKGdldEF0dHJpYnV0ZShocmVmQXR0cikpOwotICAg ICAgICAgICAgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbih1cmwsIGV2ZW50KTsKLSAgICAg ICAgICAgIGhhbmRsZUxpbmtDbGljayhldmVudCwgZG9jdW1lbnQoKSwgdXJsLCBnZXRBdHRyaWJ1 dGUodGFyZ2V0QXR0ciksIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpKTsKLSAgICAgICAgICAg IHNlbmRQaW5ncyhkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwpKTsKKyAgICAgICAgICAgIGhh bmRsZUNsaWNrKGV2ZW50KTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCkBAIC00 OTIsNiArNDkwLDM3IEBAIHZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OnNlbmRQaW5ncyhjb25zdCBL VVJMJiBkZXN0aW5hdGlvblVSTCkKICAgICAgICAgUGluZ0xvYWRlcjo6c2VuZFBpbmcoZG9jdW1l bnQoKS0+ZnJhbWUoKSwgZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGluZ1VSTHNbaV0pLCBkZXN0 aW5hdGlvblVSTCk7CiB9CiAKK3ZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRsZUNsaWNrKEV2 ZW50KiBldmVudCkKK3sKKyAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKworICAgIEZy YW1lKiBmcmFtZSA9IGRvY3VtZW50KCktPmZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSkKKyAgICAg ICAgcmV0dXJuOworCisgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRN TFNwYWNlcyhmYXN0R2V0QXR0cmlidXRlKGhyZWZBdHRyKSk7CisgICAgYXBwZW5kU2VydmVyTWFw TW91c2VQb3NpdGlvbih1cmwsIGV2ZW50KTsKKyAgICBLVVJMIGt1cmwgPSBkb2N1bWVudCgpLT5j b21wbGV0ZVVSTCh1cmwpOworCisjaWYgRU5BQkxFKERPV05MT0FEX0FUVFJJQlVURSkKKyAgICBp ZiAoaGFzQXR0cmlidXRlKGRvd25sb2FkQXR0cikpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0 IHJlcXVlc3Qoa3VybCk7CisKKyAgICAgICAgaWYgKCFoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVy KSkgeworICAgICAgICAgICAgU3RyaW5nIHJlZmVycmVyID0gZnJhbWUtPmxvYWRlcigpLT5vdXRn b2luZ1JlZmVycmVyKCk7CisgICAgICAgICAgICBpZiAoIXJlZmVycmVyLmlzRW1wdHkoKSAmJiAh U2VjdXJpdHlPcmlnaW46OnNob3VsZEhpZGVSZWZlcnJlcihrdXJsLCByZWZlcnJlcikpCisgICAg ICAgICAgICAgICAgcmVxdWVzdC5zZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIpOworICAgICAgICAg ICAgZnJhbWUtPmxvYWRlcigpLT5hZGRFeHRyYUZpZWxkc1RvTWFpblJlc291cmNlUmVxdWVzdChy ZXF1ZXN0KTsKKyAgICAgICAgfQorCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+Y2xpZW50KCkt PnN0YXJ0RG93bmxvYWQocmVxdWVzdCwgZmFzdEdldEF0dHJpYnV0ZShkb3dubG9hZEF0dHIpKTsK KyAgICB9IGVsc2UKKyNlbmRpZgorICAgICAgICBmcmFtZS0+bG9hZGVyKCktPnVybFNlbGVjdGVk KGt1cmwsIHRhcmdldCgpLCBldmVudCwgZmFsc2UsIGZhbHNlLCBoYXNSZWwoUmVsYXRpb25Ob1Jl ZmVycmVyKSA/IE5vUmVmZXJyZXIgOiBTZW5kUmVmZXJyZXIpOworCisgICAgc2VuZFBpbmdzKGt1 cmwpOworfQorCiBIVE1MQW5jaG9yRWxlbWVudDo6RXZlbnRUeXBlIEhUTUxBbmNob3JFbGVtZW50 OjpldmVudFR5cGUoRXZlbnQqIGV2ZW50KQogewogICAgIGlmICghZXZlbnQtPmlzTW91c2VFdmVu dCgpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5o IGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCmluZGV4IDg2MGFkMzUu Ljk0N2Y3NDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1l bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgKQEAgLTEx NSw2ICsxMTUsOCBAQCBwcml2YXRlOgogCiAgICAgdm9pZCBzZW5kUGluZ3MoY29uc3QgS1VSTCYg ZGVzdGluYXRpb25VUkwpOwogCisgICAgdm9pZCBoYW5kbGVDbGljayhFdmVudCopOworCiAgICAg ZW51bSBFdmVudFR5cGUgewogICAgICAgICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0S2V5LAogICAg ICAgICBNb3VzZUV2ZW50V2l0aFNoaWZ0S2V5LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNo b3JFbGVtZW50LmlkbAppbmRleCA4NzFmY2RmLi40ZTA0NzQ0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBbmNob3JFbGVtZW50LmlkbApAQCAtMjYsNiArMjYsNyBAQCBtb2R1bGUgaHRtbCB7 CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGFjY2Vzc0tleTsKICAgICAg ICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgY2hhcnNldDsKICAgICAgICAgYXR0cmli dXRlIFtSZWZsZWN0XSBET01TdHJpbmcgY29vcmRzOworICAgICAgICBhdHRyaWJ1dGUgW0NvbmRp dGlvbmFsPURPV05MT0FEX0FUVFJJQlVURSwgUmVmbGVjdF0gRE9NU3RyaW5nIGRvd25sb2FkOwog ICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3QsIFVSTF0gRE9NU3RyaW5nIGhyZWY7CiAgICAgICAg IGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGhyZWZsYW5nOwogICAgICAgICBhdHRyaWJ1 dGUgW1JlZmxlY3RdIERPTVN0cmluZyBuYW1lOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW4gYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRy aWJ1dGVOYW1lcy5pbgppbmRleCAxNjc5ZTk2Li44NDEwZGU2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxBdHRyaWJ1dGVOYW1lcy5pbgpAQCAtOTEsNiArOTEsNyBAQCBkZWZlcgogZGlyCiBk aXJlY3Rpb24KIGRpc2FibGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3ZWJraXRkcm9wem9uZQog ZW5jdHlwZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5o IGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCmluZGV4IDc4NWIxMmMuLmU4 OGFiNDggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgKQEAgLTMxMCw3ICszMTAs NyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFk eShib29sKSB7IH0KIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKSB7 IH0KIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSB7 IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSB7IH0K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIv U291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggMzg1MjM4My4u MTQwODBlZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xp ZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyQ2xpZW50LmgKQEAg LTE3OSw3ICsxNzksNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIAogICAgICAgICB2 aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKSA9IDA7CiAKLSAgICAg ICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikgPSAw OworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSkgPSAwOwogCiAgICAg ICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CiAg ICAgICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggOWJhZThlMy4uNWZiZjEzYSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhh YmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBv cnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZmVhdHVyZXMuZ3lwaToK KyAgICAgICAgKiBwdWJsaWMvV2ViRnJhbWVDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6V2Vi RnJhbWVDbGllbnQ6OmxvYWRVUkxFeHRlcm5hbGx5KToKKyAgICAgICAgKiBzcmMvRnJhbWVMb2Fk ZXJDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRJbXBs OjpkaXNwYXRjaERlY2lkZVBvbGljeUZvck5hdmlnYXRpb25BY3Rpb24pOgorICAgICAgICAoV2Vi S2l0OjpGcmFtZUxvYWRlckNsaWVudEltcGw6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIHNy Yy9GcmFtZUxvYWRlckNsaWVudEltcGwuaDoKKwogMjAxMS0wNy0yMiAgUnlvc3VrZSBOaXdhICA8 cm5pd2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZlcnQgcjkxNTEwIGR1ZSB0byBDaHJvbWl1 bSBkZWJ1ZyB0ZXN0IGZhaWx1cmVzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9mZWF0dXJlcy5neXBpIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9mZWF0dXJlcy5neXBpCmlu ZGV4IDQzZGI0ODMuLjk2ZjdjZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v ZmVhdHVyZXMuZ3lwaQorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL2ZlYXR1cmVzLmd5cGkK QEAgLTQ0LDYgKzQ0LDcgQEAKICAgICAgICdFTkFCTEVfREVWSUNFX09SSUVOVEFUSU9OPTEnLAog ICAgICAgJ0VOQUJMRV9ESVJFQ1RPUllfVVBMT0FEPTEnLAogICAgICAgJ0VOQUJMRV9ET01fU1RP UkFHRT0xJywKKyAgICAgICdFTkFCTEVfRE9XTkxPQURfQVRUUklCVVRFPTEnLAogICAgICAgJ0VO QUJMRV9FVkVOVFNPVVJDRT0xJywKICAgICAgICdFTkFCTEVfSkFWQVNDUklQVF9JMThOX0FQST0x JywKICAgICAgICdFTkFCTEVfRklMRV9TWVNURU09MScsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaAppbmRleCBiMTkzZmVjLi4wYWY5NmNhIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgKQEAgLTEx Niw2ICsxMTYsOCBAQCBwdWJsaWM6CiAgICAgLy8gVGhlIGNsaWVudCBzaG91bGQgaGFuZGxlIHRo ZSBuYXZpZ2F0aW9uIGV4dGVybmFsbHkuCiAgICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5h bGx5KAogICAgICAgICBXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmLCBXZWJOYXZpZ2F0 aW9uUG9saWN5KSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoCisgICAg ICAgIFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYsIFdlYk5hdmlnYXRpb25Qb2xpY3ks IGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWROYW1lKSB7IH0KIAogCiAgICAgLy8gTmF2aWdhdGlv bmFsIHF1ZXJpZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNs aWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGll bnRJbXBsLmNwcAppbmRleCA3OWRkZDY4Li4xMWI3NjU0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKQEAgLTk0NCw3ICs5 NDQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lG b3JOYXZpZ2F0aW9uQWN0aW9uKAogICAgIFBvbGljeUFjdGlvbiBwb2xpY3lBY3Rpb24gPSBQb2xp Y3lJZ25vcmU7CiAKICAgICAvLyBJdCBpcyB2YWxpZCBmb3IgdGhpcyBmdW5jdGlvbiB0byBiZSBp bnZva2VkIGluIGNvZGUgcGF0aHMgd2hlcmUgdGhlCi0gICAgLy8gdGhlIHdlYnZpZXcgaXMgY2xv c2VkLgorICAgIC8vIHdlYnZpZXcgaXMgY2xvc2VkLgogICAgIC8vIFRoZSBudWxsIGNoZWNrIGhl cmUgaXMgdG8gZml4IGEgY3Jhc2ggdGhhdCBzZWVtcyBzdHJhbmdlCiAgICAgLy8gKHNlZSAtIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzU1NCkuCiAgICAgaWYgKG1f d2ViRnJhbWUtPmNsaWVudCgpICYmICFyZXF1ZXN0LnVybCgpLmlzTnVsbCgpKSB7CkBAIC0xMDcz LDcgKzEwNzMsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c2V0TWFpbkZyYW1lRG9j dW1lbnRSZWFkeShib29sIHJlYWR5KQogCiAvLyBDcmVhdGVzIGEgbmV3IGNvbm5lY3Rpb24gYW5k IGJlZ2lucyBkb3dubG9hZGluZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMKIC8vIHdpdGggfGRv d25sb2FkfCkuCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6 c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmlu ZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkp IHsKICAgICAgICAgV3JhcHBlZFJlc291cmNlUmVxdWVzdCB3ZWJyZXEocmVxdWVzdCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwu aCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCmlu ZGV4IGFkYWY5ZDMuLjcxZjdlNTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oCkBAIC0xMzEsNyArMTMxLDcgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgdm9pZCBwb3N0UHJvZ3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmljYXRpb24o KTsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFByb2dyZXNzRmluaXNoZWROb3RpZmljYXRpb24oKTsK ICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm KTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAgICAg dmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwog ICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciop OwogICAgIHZpcnR1YWwgdm9pZCBjb21taXR0ZWRMb2FkKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVy KiwgY29uc3QgY2hhciosIGludCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKaW5kZXggZmYxYjYyYi4uMmY0ZGE3 NCAxMDA3NTUKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9X ZWJLaXQvZWZsL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTIyICBTYWRydWwg SGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3Vw cG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRl ckNsaWVudEVmbDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRFZmwuaDoKKwogMjAxMS0wNy0xOSAgR3l1eW91bmcgS2ltICA8Z3l1eW91 bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAgICAgIFtFRkxdIEFkZCBld2tfbmV0d29yay5jcHB8 aCBmaWxlcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50RWZsLmNwcCBiL1NvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAppbmRleCA5ZTI3NTdmLi5hYjExNzlhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVm bC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRFZmwuY3BwCkBAIC04NzEsNyArODcxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEVm bDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoRG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgY29uc3QgUmUK ICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVM b2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykK IHsKICAgICBpZiAoIW1fdmlldykKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaCBiL1NvdXJj ZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKaW5kZXgg NDdhYjNkNC4uNmJiMzI2YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2VmbC9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5oCkBAIC0xNTMsNyArMTUzLDcgQEAgY2xh c3MgRnJhbWVMb2FkZXJDbGllbnRFZmwgOiBwdWJsaWMgRnJhbWVMb2FkZXJDbGllbnQgewogCiAg ICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2 aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBT dHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2ls bENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5n ZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggYWQ1NzNmMS4uYWI1 NzQzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTIyICBTYWRy dWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQg c3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9h ZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5oOgorCiAyMDExLTA3LTExICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEg IDxnbnNAZ25vbWUub3JnPgogCiAgICAgICAgIFtHVEtdIEdvb2dsZSBDYWxlbmRhciB0aGlua3Mg d2UncmUgbW9iaWxlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggMjZjNTM0ZS4uOWQxMGM1OSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50R3RrLmNwcApAQCAtMTIyMSw3ICsxMjIxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6c2V0TWFpbkRvY3VtZW50RXJyb3IoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25z dCBSZXMKICAgICB9CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6 c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmlu ZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBHUmVmUHRyPFdlYktpdE5ldHdvcmtSZXF1 ZXN0PiBuZXR3b3JrUmVxdWVzdChhZG9wdEdSZWYoa2l0TmV3KHJlcXVlc3QpKSk7CiAgICAgV2Vi S2l0V2ViVmlldyogdmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5o IGIvU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsu aAppbmRleCAyNDQ4MjlmLi5mMGRlMmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2d0ay9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCisrKyBiL1NvdXJjZS9XZWJLaXQv Z3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKQEAgLTEzMCw3ICsxMzAs NyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZy YW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAotICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICAgICAgdmlydHVhbCB2 b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3Qg U3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpOwogCiAgICAgICAgIHZpcnR1YWwgdm9p ZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICAgICAgdmly dHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvaGFp a3UvQ2hhbmdlTG9nCmluZGV4IDdiYTcxYTAuLjFiYTU3ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvaGFpa3UvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFpa3UvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDctMjIgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxz YWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0n ZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 SGFpa3UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6c3Rh cnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRI YWlrdS5oOgorCiAyMDExLTA3LTE1ICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAK ICAgICAgICAgUkVHUkVTU0lPTjogTW91c2UgY3Vyc29yIGRvZXNu4oCZdCBoaWRlIHdoZW4gZnVs bCBzY3JlZW4gdmlkZW8gSFVEIGhpZGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwIGIvU291cmNlL1dlYktp dC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcAppbmRleCAy ODVhM2ZhLi45YzQ4MzlhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvaGFp a3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHAKQEAgLTcwOSw3ICs3 MDksNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OmRpc3BhdGNoVW5hYmxlVG9JbXBs ZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvcgogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9 CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNv dXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAq LykKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmggYi9Tb3VyY2Uv V2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAppbmRl eCA3OWVlOTE0Li41MTc0MWExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2hh aWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaApAQCAtMjE5LDcgKzIx OSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwog ICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25z dCBSZXNvdXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25s b2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9 IFN0cmluZygpKTsKIAogICAgICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90 IGJlIGhlcmUsIGJ1dCBpdCdzIG5lZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseS4KICAgICAg ICAgdmlydHVhbCB2b2lkIHBhcnRDbGVhcmVkSW5CZWdpbigpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9tYWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaCBiL1NvdXJj ZS9XZWJLaXQvbWFjL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXgg MzFjYWEwMS4uNDY3ZjA0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViQ29yZVN1 cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L21hYy9XZWJD b3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCkBAIC0xNDAsNyArMTQwLDcgQEAgcHJp dmF0ZToKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShi b29sKTsKIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0 cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9j dW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6 RG9jdW1lbnRMb2FkZXIqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvbWFjL1dlYkNvcmVT dXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50Lm1tIGIvU291cmNlL1dlYktpdC9tYWMvV2ViQ29y ZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQubW0KaW5kZXggNjRjMjEyYy4uN2E1ZTFjOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9tYWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2Fk ZXJDbGllbnQubW0KKysrIGIvU291cmNlL1dlYktpdC9tYWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJh bWVMb2FkZXJDbGllbnQubW0KQEAgLTg3MCw3ICs4NzAsNyBAQCB2b2lkIFdlYkZyYW1lTG9hZGVy Q2xpZW50OjpzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wgcmVhZHkpCiAgICAgW2dldFdl YlZpZXcobV93ZWJGcmFtZS5nZXQoKSkgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeTpyZWFkeV07 CiB9CiAKLXZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyog c3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICAvLyBGSVhNRTogU2hvdWxkIGRvd25sb2FkIGZ1bGwg cmVxdWVzdC4KICAgICBXZWJEb3dubG9hZCAqZG93bmxvYWQgPSBbZ2V0V2ViVmlldyhtX3dlYkZy YW1lLmdldCgpKSBfZG93bmxvYWRVUkw6cmVxdWVzdC51cmwoKV07CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4 IGMwYjg5N2EuLmFiYTExNjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEt MDctMjIgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisg ICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBh bmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oOgorCiAyMDExLTA3LTE5ICBDYWlvIE1hcmNl bG8gZGUgT2xpdmVpcmEgRmlsaG8gIDxjYWlvLm9saXZlaXJhQG9wZW5ib3NzYS5vcmc+CiAKICAg ICAgICAgW1F0XSBJbXByb3ZlIGRvY3VtZW50YXRpb24gb2YgUVdlYlZpZXc6OnNldFBhZ2UoKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNs aWVudFF0LmNwcCBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRRdC5jcHAKaW5kZXggOWExZTFmZi4uMGRhOTE4MyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCkBAIC0x Mjk2LDcgKzEyOTYsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoVW5hYmxl VG9JbXBsZW1lbnRQb2xpY3koY29uc3QgV2ViQ29yZTo6UmVzb3VyYwogICAgIG5vdEltcGxlbWVu dGVkKCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZChjb25z dCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgaWYgKCFtX3dl YkZyYW1lKQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3F0L1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaCBiL1NvdXJjZS9XZWJLaXQvcXQvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oCmluZGV4IDEyMTMwM2QuLjc4NmMwMWMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRRdC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRRdC5oCkBAIC0xNDksNyArMTQ5LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2 b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQg c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0 dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBj b25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZv aWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRp ZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L3dpbi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L3dpbi9DaGFuZ2VMb2cKaW5kZXggNGYyNmFm Zi4uODBmMDU4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW4vQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTIy ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAg ICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9y cy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgw CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBXZWJG cmFtZS5jcHA6CisgICAgICAgIChXZWJGcmFtZTo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICog V2ViRnJhbWUuaDoKKwogMjAxMS0wNy0xOCAgRGVhbiBKYWNrc29uICA8ZGlub0BhcHBsZS5jb20+ CiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NzQy CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAgYi9Tb3VyY2UvV2Vi S2l0L3dpbi9XZWJGcmFtZS5jcHAKaW5kZXggYjhiYjI0OS4uN2RiOTlhZSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvd2luL1dl YkZyYW1lLmNwcApAQCAtMTkwNyw3ICsxOTA3LDcgQEAgdm9pZCBXZWJGcmFtZTo6ZGlzcGF0Y2hE aWRGYWlsTG9hZChjb25zdCBSZXNvdXJjZUVycm9yJiBlcnJvcikKICAgICB9CiB9CiAKLXZvaWQg V2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQor dm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVl c3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBkLT53ZWJWaWV3 LT5kb3dubG9hZFVSTChyZXF1ZXN0LnVybCgpKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvd2luL1dlYkZyYW1lLmggYi9Tb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oCmluZGV4IDgw NDZkODUuLjhiNjM5MjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgK KysrIGIvU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaApAQCAtMzQyLDcgKzM0Miw3IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VGcm9tTWVtb3J5 Q2FjaGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJl cXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiwgaW50IGxlbmd0aCk7CiAg ICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbFByb3Zpc2lvbmFsTG9hZChjb25zdCBXZWJD b3JlOjpSZXNvdXJjZUVycm9yJik7CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbExv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwotICAgIHZpcnR1YWwgdm9pZCBzdGFy dERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwg dm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0 IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsKICAgICAgICAgCiAgICAgdmlydHVh bCBQYXNzUmVmUHRyPFdlYkNvcmU6OldpZGdldD4gY3JlYXRlSmF2YUFwcGxldFdpZGdldChjb25z dCBXZWJDb3JlOjpJbnRTaXplJiwgV2ViQ29yZTo6SFRNTEFwcGxldEVsZW1lbnQqLCBjb25zdCBX ZWJDb3JlOjpLVVJMJiBiYXNlVVJMLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbU5h bWVzLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbVZhbHVlcyk7CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvd2luY2UvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC93aW5jZS9D aGFuZ2VMb2cKaW5kZXggNTBlMzFlNC4uOWVlNzNhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC93aW5jZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNCBAQAorMjAxMS0wNy0yMiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1 bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxl bmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5D RS5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93 bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0Uu aDoKKwogMjAxMS0wNy0xNSAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAg ICAgIFJFR1JFU1NJT046IE1vdXNlIGN1cnNvciBkb2VzbuKAmXQgaGlkZSB3aGVuIGZ1bGwgc2Ny ZWVuIHZpZGVvIEhVRCBoaWRlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcCBiL1NvdXJjZS9XZWJLaXQvd2lu Y2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAKaW5kZXggNjRjMTBm ZS4uNTRjMTI2NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwCkBAIC01OTcsNyArNTk3LDcg QEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzZXRNYWluRG9jdW1lbnRFcnJvcihEb2N1 bWVudExvYWRlciosIGNvbnN0IFJlc291cmMKICAgICBtX2hhc1NlbnRSZXNwb25zZVRvUGx1Z2lu ID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3RhcnREb3dubG9h ZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVu dFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNv bnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBub3RJbXBsZW1lbnRlZCgp OwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudFdpbkNFLmggYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaAppbmRleCA2YmVhYjBkLi5jNWQzMDA5IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 V2luQ0UuaAorKysgYi9Tb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50V2luQ0UuaApAQCAtMTI1LDcgKzEyNSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1 YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2 b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAg dmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVh bCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZp cnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC93eC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L3d4L0No YW5nZUxvZwppbmRleCBjNTc2NGUyLi41MjI4NGFhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L3d4L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L3d4L0NoYW5nZUxvZwpAQCAtMSwzICsx LDE0IEBACisyMDExLTA3LTIyICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9t aXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBh dHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBXZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9hZCk6CisgICAg ICAgICogV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4Lmg6CisKIDIwMTEtMDctMTUg IERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OOiBN b3VzZSBjdXJzb3IgZG9lc27igJl0IGhpZGUgd2hlbiBmdWxsIHNjcmVlbiB2aWRlbyBIVUQgaGlk ZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFd4LmNwcCBiL1NvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRl ckNsaWVudFd4LmNwcAppbmRleCBkMTZmNjc3Li5lMzgwZmIwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAKKysrIGIvU291 cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guY3BwCkBAIC04 NDAsNyArODQwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpkaXNwYXRjaFVuYWJsZVRv SW1wbGVtZW50UG9saWN5KGNvbnN0IFJlc291cmNlRXJyb3ImKQogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAq LykKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaCBiL1NvdXJjZS9XZWJLaXQv d3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKaW5kZXggMGFmZGFkOS4uZTE0 ODFjNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50V3guaAorKysgYi9Tb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRXeC5oCkBAIC0yMDYsNyArMjA2LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0 aW9uKEZyYW1lUG9saWN5RnVuY3Rpb24gZnVuY3Rpb24sIGNvbnN0IE5hdmlnYXRpb25BY3Rpb24m LCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBSZXNv dXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmlu ZygpKTsKICAgICAgICAgCiAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBwcm9iYWJseSBu b3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVlZGVkIGZvciB0aGUgdGVzdHMgY3VycmVudGx5CiAgICAg ICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA3ZTU1 N2JmLi5iOTgxZWYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDctMjIgIFNh ZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFk ZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYlByb2Nl c3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2Vi UHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oOgorCiAyMDExLTA3 LTIxICBZYWVsIEFoYXJvbiAgPHlhZWwuYWhhcm9uQG5va2lhLmNvbT4KIAogICAgICAgICBbUXRd W1dLMl0gQ29kZSBjbGVhbnVwIGZvciBkcmFnLWFuZC1kcm9wCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNw cCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2Fk ZXJDbGllbnQuY3BwCmluZGV4IDMwMTc1MDYuLjNiYzhhZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVM b2FkZXJDbGllbnQuY3BwCkBAIC03ODksNyArNzg5LDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNs aWVudDo6c2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKQogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKLXZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3Rh cnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYg Lyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBtX2ZyYW1lLT5zdGFydERvd25sb2FkKHJlcXVl c3QpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3Vw cG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCmluZGV4IDU2ZWY3ZWEuLmZlN2Mx MWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQv V2ViRnJhbWVMb2FkZXJDbGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgKQEAgLTEyMiw3ICsxMjIsNyBAQCBw cml2YXRlOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5 KGJvb2wpOwogICAgIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNv bnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFt ZSA9IFN0cmluZygpKTsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdl YkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxl KFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZjkzMWZlNi4uNDliYjJlYSAxMDA2NDQKLS0tIGEvVG9v bHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEx LTA3LTIyICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4g YW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHA6CisgICAgICAgIChXZWJW aWV3SG9zdDo6bG9hZFVSTEV4dGVybmFsbHkpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2No cm9taXVtL1dlYlZpZXdIb3N0Lmg6CisKIDIwMTEtMDctMjEgIEFkYW0gUm9iZW4gIDxhcm9iZW5A YXBwbGUuY29tPgogCiAgICAgICAgIEZpeCB0eXBvIGluIFRlc3RGYWlsdXJlcwpkaWZmIC0tZ2l0 IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwIGIvVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCmluZGV4IDZmYjMwOTEuLmY4 OWViMjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdI b3N0LmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5j cHAKQEAgLTc5OSw3ICs3OTksMTIgQEAgYm9vbCBXZWJWaWV3SG9zdDo6YWxsb3dJbWFnZXMoV2Vi RnJhbWUqIGZyYW1lLCBib29sIGVuYWJsZWRQZXJTZXR0aW5ncykKICAgICByZXR1cm4gZW5hYmxl ZFBlclNldHRpbmdzOwogfQogCi12b2lkIFdlYlZpZXdIb3N0Ojpsb2FkVVJMRXh0ZXJuYWxseShX ZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVlc3QsIFdlYk5hdmlnYXRpb25Qb2xp Y3kgcG9saWN5KQordm9pZCBXZWJWaWV3SG9zdDo6bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUq IGZyYW1lLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0LCBXZWJOYXZpZ2F0aW9uUG9saWN5 IHBvbGljeSkKK3sKKyAgICBsb2FkVVJMRXh0ZXJuYWxseShmcmFtZSwgcmVxdWVzdCwgcG9saWN5 LCBXZWJTdHJpbmcoKSk7Cit9CisKK3ZvaWQgV2ViVmlld0hvc3Q6OmxvYWRVUkxFeHRlcm5hbGx5 KFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVxdWVzdCwgV2ViTmF2aWdhdGlvblBv bGljeSBwb2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWROYW1lKQogewogICAgIEFTU0VS VChwb2xpY3kgIT0gIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeUN1cnJlbnRUYWIpOwogICAg IFdlYlZpZXdIb3N0KiBhbm90aGVyID0gbV9zaGVsbC0+Y3JlYXRlTmV3V2luZG93KHJlcXVlc3Qu dXJsKCkpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmll d0hvc3QuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKaW5k ZXggMjk1MWFmZi4uZWM3OGE5MiAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vV2ViVmlld0hvc3QuaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9X ZWJWaWV3SG9zdC5oCkBAIC0xNzQsNiArMTc0LDcgQEAgY2xhc3MgV2ViVmlld0hvc3QgOiBwdWJs aWMgV2ViS2l0OjpXZWJTcGVsbENoZWNrQ2xpZW50LCBwdWJsaWMgV2ViS2l0OjpXZWJWaWV3Q2wK ICAgICAgdmlydHVhbCBib29sIGFsbG93UGx1Z2lucyhXZWJLaXQ6OldlYkZyYW1lKiwgYm9vbCBl bmFibGVkUGVyU2V0dGluZ3MpOwogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0ltYWdlcyhXZWJLaXQ6 OldlYkZyYW1lKiwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3MpOwogICAgIHZpcnR1YWwgdm9pZCBs b2FkVVJMRXh0ZXJuYWxseShXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0OjpXZWJVUkxS ZXF1ZXN0JiwgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5KTsKKyAgICB2aXJ0dWFsIHZvaWQg bG9hZFVSTEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNvbnN0IFdlYktpdDo6V2ViVVJM UmVxdWVzdCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSwgY29uc3QgV2ViS2l0OjpXZWJT dHJpbmcmIGRvd25sb2FkTmFtZSk7CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYk5hdmlnYXRpb25Q b2xpY3kgZGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbigKICAgICAgICAgV2ViS2l0OjpXZWJGcmFt ZSosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsCiAgICAgICAgIFdlYktpdDo6V2ViTmF2 aWdhdGlvblR5cGUsIGNvbnN0IFdlYktpdDo6V2ViTm9kZSYsCg== 102046 2011-07-26 13:38:33 -0700 2011-07-26 15:04:48 -0700 Patch with updated tests bug-64580-20110726133831.patch text/plain 42850 abarth SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzkgQEAKKzIwMTEtMDctMjYgIFNhZHJ1bCBI YWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBw b3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAg ICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgIFRoZSBkb3dubG9hZCBhdHRyaWJ1 dGUgYWxsb3dzIHRoZSBhdXRob3Igb2YgdGhlIGh5cGVybGluayB0byBjYXVzZSB0aGUKKyAgICAg ICAgYnJvd3NlciB0byBkb3dubG9hZCB0aGUgbGlua2VkIFVSTC4gIFRoZSBhdXRob3IgY2FuIGFs c28gc3VwcGx5IGEKKyAgICAgICAgc3VnZ2VzdGVkIGZpbGUgbmFtZSBpbiB0aGUgYXR0cmlidXRl IHZhbHVlLiAgVGhpcyBmZWF0dXJlIGlzIGEgcmVjZW50CisgICAgICAgIGFkZGl0aW9uIHRvIEhU TUwgdG8gYmV0dGVyIHN1cHBvcnQgb2ZmbGluZSBhcHBsaWNhdGlvbnMgdGhhdCB1c2UgYmxvYgor ICAgICAgICBVUkxzLiAgVHJhZGl0aW9uYWxseSwgd2ViIHNpdGVzIHVzZSB0aGUgSFRUUCBDb250 ZW50LURpc3Bvc2l0aW9uIGhlYWRlcgorICAgICAgICB0byB0cmlnZ2VyIGRvd25sb2FkcywgYnV0 IHRoYXQgb3B0aW9uIGlzbid0IGF2YWlsYWJsZSB3aGVuIHdvcmtpbmcKKyAgICAgICAgb2ZmbGlu ZS4KKworICAgICAgICBUaGVyZSBpcyBzb21lIHF1ZXN0aW9uIGFib3V0IHdoZXRoZXIgd2Ugc2hv dWxkIGluaXRpYXRlIGEgZG93bmxvYWQgd2hlbgorICAgICAgICB3ZSByZWNlaXZlIGEgRE9NLWNy ZWF0ZWQgY2xpY2sgZXZlbnQuICBUaGlzIHBhdGNoIGRvZXMgaW5pdGlhdGUgdGhlCisgICAgICAg IGRvd25sb2FkLCBidXQgd2UgbWlnaHQgcmV2aXNlIHRoYXQgZGVjaXNpb24gaW4gdGhlIGZ1dHVy ZSBhcyBwYXJ0IG9mIGEKKyAgICAgICAgbGFyZ2VyIGNoYW5nZSBpbiBob3cgV2ViS2l0IHRyZWF0 cyB0aGUgaW50ZXJhY3Rpb24gYmV0d2VlbiBkZWZhdWx0CisgICAgICAgIGV2ZW50IGhhbmRsZXJz IGFuZCBET00tY3JlYXRlZCBldmVudHMuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvZG9tL0hUTUxB bmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2Rv bS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAor ICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxv YWQtc2V0Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRsZUNsaWNrKToKKyAgICAg ICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MQW5jaG9y RWxlbWVudC5pZGw6CisgICAgICAgICogaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW46CisgICAg ICAgICogbG9hZGVyL0VtcHR5Q2xpZW50cy5oOgorICAgICAgICAoV2ViQ29yZTo6RW1wdHlGcmFt ZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50Lmg6CisKIDIwMTEtMDctMjYgIFZpZXQtVHJ1bmcgTHV1ICA8dmlldHRydW5nbHV1 QGNocm9taXVtLm9yZz4KIAogICAgICAgICBJbXByb3ZlIChpLmUuLCBzcGVlZCB1cCkgLmd5cChp KSBmaWxlcyBmb3IgQ2hyb21pdW0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hv ckVsZW1lbnQuY3BwCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TEFuY2hvckVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5j bHVkZSAiQXR0cmlidXRlLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZy YW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRlICJGcmFtZUxv YWRlclR5cGVzLmgiCiAjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgogI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgpAQCAtMTQ3LDEwICsxNDgsNyBAQCB2b2lkIEhUTUxBbmNob3JFbGVtZW50Ojpk ZWZhdWx0RXZlbnRIYW5kCiAgICAgICAgIH0KIAogICAgICAgICBpZiAoaXNMaW5rQ2xpY2soZXZl bnQpICYmIHRyZWF0TGlua0FzTGl2ZUZvckV2ZW50VHlwZShldmVudFR5cGUoZXZlbnQpKSkgewot ICAgICAgICAgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRNTFNwYWNl cyhnZXRBdHRyaWJ1dGUoaHJlZkF0dHIpKTsKLSAgICAgICAgICAgIGFwcGVuZFNlcnZlck1hcE1v dXNlUG9zaXRpb24odXJsLCBldmVudCk7Ci0gICAgICAgICAgICBoYW5kbGVMaW5rQ2xpY2soZXZl bnQsIGRvY3VtZW50KCksIHVybCwgZ2V0QXR0cmlidXRlKHRhcmdldEF0dHIpLCBoYXNSZWwoUmVs YXRpb25Ob1JlZmVycmVyKSk7Ci0gICAgICAgICAgICBzZW5kUGluZ3MoZG9jdW1lbnQoKS0+Y29t cGxldGVVUkwodXJsKSk7CisgICAgICAgICAgICBoYW5kbGVDbGljayhldmVudCk7CiAgICAgICAg ICAgICByZXR1cm47CiAgICAgICAgIH0KIApAQCAtNDkyLDYgKzQ5MCwzNyBAQCB2b2lkIEhUTUxB bmNob3JFbGVtZW50OjpzZW5kUGluZ3MoY29uc3QgCiAgICAgICAgIFBpbmdMb2FkZXI6OnNlbmRQ aW5nKGRvY3VtZW50KCktPmZyYW1lKCksIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBpbmdVUkxz W2ldKSwgZGVzdGluYXRpb25VUkwpOwogfQogCit2b2lkIEhUTUxBbmNob3JFbGVtZW50OjpoYW5k bGVDbGljayhFdmVudCogZXZlbnQpCit7CisgICAgZXZlbnQtPnNldERlZmF1bHRIYW5kbGVkKCk7 CisKKyAgICBGcmFtZSogZnJhbWUgPSBkb2N1bWVudCgpLT5mcmFtZSgpOworICAgIGlmICghZnJh bWUpCisgICAgICAgIHJldHVybjsKKworICAgIFN0cmluZyB1cmwgPSBzdHJpcExlYWRpbmdBbmRU cmFpbGluZ0hUTUxTcGFjZXMoZmFzdEdldEF0dHJpYnV0ZShocmVmQXR0cikpOworICAgIGFwcGVu ZFNlcnZlck1hcE1vdXNlUG9zaXRpb24odXJsLCBldmVudCk7CisgICAgS1VSTCBrdXJsID0gZG9j dW1lbnQoKS0+Y29tcGxldGVVUkwodXJsKTsKKworI2lmIEVOQUJMRShET1dOTE9BRF9BVFRSSUJV VEUpCisgICAgaWYgKGhhc0F0dHJpYnV0ZShkb3dubG9hZEF0dHIpKSB7CisgICAgICAgIFJlc291 cmNlUmVxdWVzdCByZXF1ZXN0KGt1cmwpOworCisgICAgICAgIGlmICghaGFzUmVsKFJlbGF0aW9u Tm9SZWZlcnJlcikpIHsKKyAgICAgICAgICAgIFN0cmluZyByZWZlcnJlciA9IGZyYW1lLT5sb2Fk ZXIoKS0+b3V0Z29pbmdSZWZlcnJlcigpOworICAgICAgICAgICAgaWYgKCFyZWZlcnJlci5pc0Vt cHR5KCkgJiYgIVNlY3VyaXR5T3JpZ2luOjpzaG91bGRIaWRlUmVmZXJyZXIoa3VybCwgcmVmZXJy ZXIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3Quc2V0SFRUUFJlZmVycmVyKHJlZmVycmVyKTsK KyAgICAgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+YWRkRXh0cmFGaWVsZHNUb01haW5SZXNvdXJj ZVJlcXVlc3QocmVxdWVzdCk7CisgICAgICAgIH0KKworICAgICAgICBmcmFtZS0+bG9hZGVyKCkt PmNsaWVudCgpLT5zdGFydERvd25sb2FkKHJlcXVlc3QsIGZhc3RHZXRBdHRyaWJ1dGUoZG93bmxv YWRBdHRyKSk7CisgICAgfSBlbHNlCisjZW5kaWYKKyAgICAgICAgZnJhbWUtPmxvYWRlcigpLT51 cmxTZWxlY3RlZChrdXJsLCB0YXJnZXQoKSwgZXZlbnQsIGZhbHNlLCBmYWxzZSwgaGFzUmVsKFJl bGF0aW9uTm9SZWZlcnJlcikgPyBOb1JlZmVycmVyIDogU2VuZFJlZmVycmVyKTsKKworICAgIHNl bmRQaW5ncyhrdXJsKTsKK30KKwogSFRNTEFuY2hvckVsZW1lbnQ6OkV2ZW50VHlwZSBIVE1MQW5j aG9yRWxlbWVudDo6ZXZlbnRUeXBlKEV2ZW50KiBldmVudCkKIHsKICAgICBpZiAoIWV2ZW50LT5p c01vdXNlRXZlbnQoKSkKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1l bnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50 LmgJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxl bWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMTUsNiArMTE1LDggQEAgcHJpdmF0ZToKIAogICAg IHZvaWQgc2VuZFBpbmdzKGNvbnN0IEtVUkwmIGRlc3RpbmF0aW9uVVJMKTsKIAorICAgIHZvaWQg aGFuZGxlQ2xpY2soRXZlbnQqKTsKKwogICAgIGVudW0gRXZlbnRUeXBlIHsKICAgICAgICAgTW91 c2VFdmVudFdpdGhvdXRTaGlmdEtleSwKICAgICAgICAgTW91c2VFdmVudFdpdGhTaGlmdEtleSwK SW5kZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCShyZXZpc2lv biA5MTc3NikKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaWRsCSh3 b3JraW5nIGNvcHkpCkBAIC0yNiw2ICsyNiw3IEBAIG1vZHVsZSBodG1sIHsKICAgICAgICAgYXR0 cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgYWNjZXNzS2V5OwogICAgICAgICBhdHRyaWJ1dGUg W1JlZmxlY3RdIERPTVN0cmluZyBjaGFyc2V0OwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3Rd IERPTVN0cmluZyBjb29yZHM7CisgICAgICAgIGF0dHJpYnV0ZSBbQ29uZGl0aW9uYWw9RE9XTkxP QURfQVRUUklCVVRFLCBSZWZsZWN0XSBET01TdHJpbmcgZG93bmxvYWQ7CiAgICAgICAgIGF0dHJp YnV0ZSBbUmVmbGVjdCwgVVJMXSBET01TdHJpbmcgaHJlZjsKICAgICAgICAgYXR0cmlidXRlIFtS ZWZsZWN0XSBET01TdHJpbmcgaHJlZmxhbmc7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0g RE9NU3RyaW5nIG5hbWU7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVO YW1lcy5pbgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRyaWJ1dGVO YW1lcy5pbgkocmV2aXNpb24gOTE3NzYpCisrKyBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBdHRy aWJ1dGVOYW1lcy5pbgkod29ya2luZyBjb3B5KQpAQCAtOTEsNiArOTEsNyBAQCBkZWZlcgogZGly CiBkaXJlY3Rpb24KIGRpc2FibGVkCitkb3dubG9hZAogZHJhZ2dhYmxlCiB3ZWJraXRkcm9wem9u ZQogZW5jdHlwZQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAkocmV2aXNp b24gOTE3NzYpCisrKyBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgJKHdvcmtp bmcgY29weSkKQEAgLTMxMCw3ICszMTAsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQg c2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKSB7IH0KIAotICAgIHZpcnR1YWwgdm9pZCBz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpIHsgfQorICAgIHZpcnR1YWwgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3Vn Z2VzdGVkTmFtZSA9IFN0cmluZygpKSB7IH0KIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdl VGl0bGUoRG9jdW1lbnRMb2FkZXIqKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0 bGUoRG9jdW1lbnRMb2FkZXIqKSB7IH0KSW5kZXg6IFNvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFt ZUxvYWRlckNsaWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFt ZUxvYWRlckNsaWVudC5oCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRl ci9GcmFtZUxvYWRlckNsaWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNzksNyArMTc5LDcgQEAg bmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICAKICAgICAgICAgdmlydHVhbCB2b2lkIHNldE1h aW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCkgPSAwOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpID0gMDsKKyAgICAgICAgdmlydHVh bCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5n JiBzdWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpID0gMDsKIAogICAgICAgICB2aXJ0dWFsIHZvaWQg d2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwogICAgICAgICB2aXJ0dWFsIHZv aWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRMb2FkZXIqKSA9IDA7CkluZGV4OiBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCShy ZXZpc2lvbiA5MTc3NikKKysrIFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8 c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9 J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRh bSBCYXJ0aC4KKworICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVM b2FkZXJDbGllbnQuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZUxvYWRlckNsaWVudDo6 c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJG cmFtZUxvYWRlckNsaWVudC5oOgorCiAyMDExLTA3LTI2ICBBbmRyYXMgQmVjc2kgIDxhYmVjc2lA d2Via2l0Lm9yZz4KIAogICAgICAgICBbUXRdIFtXSzJdIERpc2FibGUgdGhlIGJ1aWxkIHdpdGgg UXQgdmVyc2lvbnMgb2xkZXIgdGhhbiA1LjAgCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVy Q2xpZW50LmNwcAkocmV2aXNpb24gOTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNzg5LDcgKzc4OSw3IEBAIHZvaWQgV2ViRnJhbWVMb2FkZXJDbGllbnQ6OnNldE1haW5GcmFt ZUQKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50 OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2Vi RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgbV9mcmFt ZS0+c3RhcnREb3dubG9hZChyZXF1ZXN0KTsKIH0KSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1dlYlBy b2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVy Q2xpZW50LmgJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0x MjIsNyArMTIyLDcgQEAgcHJpdmF0ZToKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZy YW1lRG9jdW1lbnRSZWFkeShib29sKTsKICAgICAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3du bG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQg c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJp bmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHdp bGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9p ZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwpJbmRleDogU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxOCBAQAorMjAxMS0wNy0y NiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hv cnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4 MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBmZWF0dXJl cy5neXBpOgorICAgICAgICAqIHB1YmxpYy9XZWJGcmFtZUNsaWVudC5oOgorICAgICAgICAoV2Vi S2l0OjpXZWJGcmFtZUNsaWVudDo6bG9hZFVSTEV4dGVybmFsbHkpOgorICAgICAgICAqIHNyYy9G cmFtZUxvYWRlckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNs aWVudEltcGw6OmRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbik6CisgICAg ICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZCk6CisgICAg ICAgICogc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5oOgorCiAyMDExLTA3LTI1ICBBbCBQYXRy aWNrICA8YXBhdHJpY2tAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJlbW92ZWQgc3VwcG9ydCBm b3IgdGhlIEdMX2xhdGNoX0NIUk9NSVVNIGV4dGVuc2lvbiB3aGljaCBDaHJvbWl1bSBubyBsb25n ZXIgc3VwcG9ydHMuCkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL2ZlYXR1cmVzLmd5cGkK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9mZWF0dXJlcy5neXBpCShyZXZp c2lvbiA5MTc3NikKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vZmVhdHVyZXMuZ3lwaQkod29y a2luZyBjb3B5KQpAQCAtNDQsNiArNDQsNyBAQAogICAgICAgJ0VOQUJMRV9ERVZJQ0VfT1JJRU5U QVRJT049MScsCiAgICAgICAnRU5BQkxFX0RJUkVDVE9SWV9VUExPQUQ9MScsCiAgICAgICAnRU5B QkxFX0RPTV9TVE9SQUdFPTEnLAorICAgICAgJ0VOQUJMRV9ET1dOTE9BRF9BVFRSSUJVVEU9MScs CiAgICAgICAnRU5BQkxFX0VWRU5UU09VUkNFPTEnLAogICAgICAgJ0VOQUJMRV9KQVZBU0NSSVBU X0kxOE5fQVBJPTEnLAogICAgICAgJ0VOQUJMRV9GSUxFX1NZU1RFTT0xJywKSW5kZXg6IFNvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaAkocmV2aXNpb24g OTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC0xMTYsNiArMTE2LDggQEAgcHVibGljOgogICAgIC8vIFRoZSBj bGllbnQgc2hvdWxkIGhhbmRsZSB0aGUgbmF2aWdhdGlvbiBleHRlcm5hbGx5LgogICAgIHZpcnR1 YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxseSgKICAgICAgICAgV2ViRnJhbWUqLCBjb25zdCBXZWJV UkxSZXF1ZXN0JiwgV2ViTmF2aWdhdGlvblBvbGljeSkgeyB9CisgICAgdmlydHVhbCB2b2lkIGxv YWRVUkxFeHRlcm5hbGx5KAorICAgICAgICBXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3Qm LCBXZWJOYXZpZ2F0aW9uUG9saWN5LCBjb25zdCBXZWJTdHJpbmcmIGRvd25sb2FkTmFtZSkgeyB9 CiAKIAogICAgIC8vIE5hdmlnYXRpb25hbCBxdWVyaWVzIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCShyZXZpc2lvbiA5MTc3NikK KysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTk0NCw3ICs5NDQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 SW1wbDo6ZGlzcGF0Y2hEZWNpCiAgICAgUG9saWN5QWN0aW9uIHBvbGljeUFjdGlvbiA9IFBvbGlj eUlnbm9yZTsKIAogICAgIC8vIEl0IGlzIHZhbGlkIGZvciB0aGlzIGZ1bmN0aW9uIHRvIGJlIGlu dm9rZWQgaW4gY29kZSBwYXRocyB3aGVyZSB0aGUKLSAgICAvLyB0aGUgd2VidmlldyBpcyBjbG9z ZWQuCisgICAgLy8gd2VidmlldyBpcyBjbG9zZWQuCiAgICAgLy8gVGhlIG51bGwgY2hlY2sgaGVy ZSBpcyB0byBmaXggYSBjcmFzaCB0aGF0IHNlZW1zIHN0cmFuZ2UKICAgICAvLyAoc2VlIC0gaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzNTU0KS4KICAgICBpZiAobV93 ZWJGcmFtZS0+Y2xpZW50KCkgJiYgIXJlcXVlc3QudXJsKCkuaXNOdWxsKCkpIHsKQEAgLTEwNzMs NyArMTA3Myw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpzZXRNYWluRnJhbWUKIAog Ly8gQ3JlYXRlcyBhIG5ldyBjb25uZWN0aW9uIGFuZCBiZWdpbnMgZG93bmxvYWRpbmcgZnJvbSB0 aGF0IChjb250cmFzdCB0aGlzCiAvLyB3aXRoIHxkb3dubG9hZHwpLgotdm9pZCBGcmFtZUxvYWRl ckNsaWVudEltcGw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0 KQordm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7 CiAgICAgaWYgKG1fd2ViRnJhbWUtPmNsaWVudCgpKSB7CiAgICAgICAgIFdyYXBwZWRSZXNvdXJj ZVJlcXVlc3Qgd2VicmVxKHJlcXVlc3QpOwpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgJKHJldmlzaW9uIDkxNzc2KQorKysg U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgJKHdvcmtp bmcgY29weSkKQEAgLTEzMSw3ICsxMzEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHBv c3RQcm9ncmVzc0VzdGltYXRlQ2hhbmdlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9p ZCBwb3N0UHJvZ3Jlc3NGaW5pc2hlZE5vdGlmaWNhdGlvbigpOwogICAgIHZpcnR1YWwgdm9pZCBz ZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwotICAgIHZpcnR1YWwgdm9pZCBzdGFydERv d25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0 cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENo YW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRp ZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lk IGNvbW1pdHRlZExvYWQoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBjaGFyKiwgaW50 KTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktp dC9lZmwvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDct MjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNo b3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1 ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgICogV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVMb2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmg6CisKIDIwMTEtMDctMjUgIEp1bmdKaWsgTGVlICA8 anVuZ2ppay5sZWVAc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VGTF0gUmVtb3ZlIHVudXNlZCBj b2RlIGluIGV3a190aWxlX21vZGVsLmMKSW5kZXg6IFNvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHAJKHJldmlzaW9u IDkxNzc2KQorKysgU291cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRFZmwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04NzEsNyArODcxLDcgQEAgdm9pZCBGcmFt ZUxvYWRlckNsaWVudEVmbDo6c2V0TWFpbkRvY3VtZQogICAgIG1faGFzU2VudFJlc3BvbnNlVG9Q bHVnaW4gPSBmYWxzZTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3du bG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50RWZsOjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29u c3QgU3RyaW5nJiAvKiBzdWdnZXN0ZWROYW1lICovKQogewogICAgIGlmICghbV92aWV3KQogICAg ICAgICByZXR1cm47CkluZGV4OiBTb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEVmbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvZWZsL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgJKHJldmlzaW9uIDkxNzc2KQorKysgU291 cmNlL1dlYktpdC9lZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAkod29y a2luZyBjb3B5KQpAQCAtMTUzLDcgKzE1Myw3IEBAIGNsYXNzIEZyYW1lTG9hZGVyQ2xpZW50RWZs IDogcHVibGljIEZyYW0KIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJl YWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3Vy Y2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpOwogCiAg ICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwogICAgIHZp cnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopOwpJbmRleDogU291cmNl L1dlYktpdC9ndGsvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvZ3RrL0No YW5nZUxvZwkocmV2aXNpb24gOTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cJ KHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmli IENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQg Zm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJl dmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50Ojpz dGFydERvd25sb2FkKToKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dEd0ay5oOgorCiAyMDExLTA3LTI2ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdh bGlhLmNvbT4KIAogICAgICAgICBbR1RLXSBSZW1vdmUgaGVhZGVyIHdlYmtpdHdlYnZpZXdjb21t b24uaApJbmRleDogU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRHdGsuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAkocmV2aXNpb24gOTE3NzYpCisrKyBTb3VyY2Uv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEyMjEsNyArMTIyMSw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNl dE1haW5Eb2N1bWVudEUKICAgICB9CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0 RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRl ckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNv bnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBHUmVmUHRyPFdlYktpdE5l dHdvcmtSZXF1ZXN0PiBuZXR3b3JrUmVxdWVzdChhZG9wdEdSZWYoa2l0TmV3KHJlcXVlc3QpKSk7 CiAgICAgV2ViS2l0V2ViVmlldyogdmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSk7Cklu ZGV4OiBTb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0 ay5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmgJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaAkod29ya2luZyBjb3B5KQpAQCAt MTMwLDcgKzEzMCw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgICAgIHZpcnR1YWwgdm9p ZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgICAgIHZpcnR1YWwgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgICAg ICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAKICAgICAgICAg dmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1bWVudExvYWRlciopOwog ICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2Fk ZXIqKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvaGFpa3UvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJLaXQvaGFpa3UvQ2hhbmdlTG9nCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJj ZS9XZWJLaXQvaGFpa3UvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTEtMDctMjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0 ZSBpbiBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAg ICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRIYWlrdS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKToKKyAgICAgICAg KiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1Lmg6CisKIDIwMTEtMDctMTUg IERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9OOiBN b3VzZSBjdXJzb3IgZG9lc27igJl0IGhpZGUgd2hlbiBmdWxsIHNjcmVlbiB2aWRlbyBIVUQgaGlk ZXMKSW5kZXg6IFNvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRIYWlrdS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcAkocmV2aXNpb24gOTE3NzYpCisrKyBT b3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3Uu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC03MDksNyArNzA5LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudEhhaWt1OjpkaXNwYXRjaFVuYQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQg RnJhbWVMb2FkZXJDbGllbnRIYWlrdTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAg ICBub3RJbXBsZW1lbnRlZCgpOwogfQpJbmRleDogU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmgJKHJldmlz aW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEhhaWt1LmgJKHdvcmtpbmcgY29weSkKQEAgLTIxOSw3ICsyMTksNyBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAgdmly dHVhbCB2b2lkIGRpc3BhdGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VF cnJvciYpOwogCi0gICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYpOworICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBS ZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7 CiAKICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIHByb2JhYmx5IG5vdCBiZSBoZXJlLCBi dXQgaXQncyBuZWVkZWQgZm9yIHRoZSB0ZXN0cyBjdXJyZW50bHkuCiAgICAgICAgIHZpcnR1YWwg dm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvbWFjL1dlYkNv cmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC9tYWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaAkocmV2aXNpb24g OTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0L21hYy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRl ckNsaWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNDAsNyArMTQwLDcgQEAgcHJpdmF0ZToKICAg ICAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsKIAot ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVx dWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsK IAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2Fk ZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRM b2FkZXIqKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvbWFjL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1l TG9hZGVyQ2xpZW50Lm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvbWFjL1dlYkNvcmVT dXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50Lm1tCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJj ZS9XZWJLaXQvbWFjL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50Lm1tCSh3b3Jr aW5nIGNvcHkpCkBAIC04NzAsNyArODcwLDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6 c2V0TWFpbkZyYW1lRAogICAgIFtnZXRXZWJWaWV3KG1fd2ViRnJhbWUuZ2V0KCkpIHNldE1haW5G cmFtZURvY3VtZW50UmVhZHk6cmVhZHldOwogfQogCi12b2lkIFdlYkZyYW1lTG9hZGVyQ2xpZW50 OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2Vi RnJhbWVMb2FkZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgLy8gRklY TUU6IFNob3VsZCBkb3dubG9hZCBmdWxsIHJlcXVlc3QuCiAgICAgV2ViRG93bmxvYWQgKmRvd25s b2FkID0gW2dldFdlYlZpZXcobV93ZWJGcmFtZS5nZXQoKSkgX2Rvd25sb2FkVVJMOnJlcXVlc3Qu dXJsKCldOwpJbmRleDogU291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYktpdC9xdC9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dl YktpdC9xdC9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0w Ny0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFu Y2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02 NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBXZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZy YW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaDoKKwogMjAxMS0wNy0yNiAgQWxleGlzIE1lbmFyZCAg PGFsZXhpcy5tZW5hcmRAb3BlbmJvc3NhLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBbmRy ZWFzIEtsaW5nLgpJbmRleDogU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJj ZS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEyOTYsNyArMTI5Niw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6 ZGlzcGF0Y2hVbmFibGUKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9h ZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0 JiByZXF1ZXN0KQordm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpzdGFydERvd25sb2FkKGNvbnN0 IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgU3RyaW5nJiAvKiBzdWdn ZXN0ZWROYW1lICovKQogewogICAgIGlmICghbV93ZWJGcmFtZSkKICAgICAgICAgcmV0dXJuOwpJ bmRleDogU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0 LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFF0LmgJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC9xdC9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0OSw3 ICsxNDksNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1l bnRSZWFkeShib29sKTsKIAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdl YkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2Fk KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVk TmFtZSA9IFN0cmluZygpKTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoRG9j dW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoRG9jdW1lbnRM b2FkZXIqKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzc2KQorKysgU291cmNl L1dlYktpdC93aW4vQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIw MTEtMDctMjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgor CisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBp biBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgICog V2ViRnJhbWUuY3BwOgorICAgICAgICAoV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQpOgorICAgICAg ICAqIFdlYkZyYW1lLmg6CisKIDIwMTEtMDctMTggIERlYW4gSmFja3NvbiAgPGRpbm9AYXBwbGUu Y29tPgogCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02 NDc0MgpJbmRleDogU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmNwcAkocmV2aXNpb24gOTE3NzYpCisrKyBTb3Vy Y2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE5MDcsNyArMTkw Nyw3IEBAIHZvaWQgV2ViRnJhbWU6OmRpc3BhdGNoRGlkRmFpbExvYWQoY29uc3QKICAgICB9CiB9 CiAKLXZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiBy ZXF1ZXN0KQordm9pZCBXZWJGcmFtZTo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAgICBk LT53ZWJWaWV3LT5kb3dubG9hZFVSTChyZXF1ZXN0LnVybCgpKTsKIH0KSW5kZXg6IFNvdXJjZS9X ZWJLaXQvd2luL1dlYkZyYW1lLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC93aW4vV2Vi RnJhbWUuaAkocmV2aXNpb24gOTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5o CSh3b3JraW5nIGNvcHkpCkBAIC0zNDIsNyArMzQyLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwg Ym9vbCBkaXNwYXRjaERpZExvYWRSZXNvdXJjZUZyb21NZW1vcnlDYWNoZShXZWJDb3JlOjpEb2N1 bWVudExvYWRlciosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNv cmU6OlJlc291cmNlUmVzcG9uc2UmLCBpbnQgbGVuZ3RoKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlz cGF0Y2hEaWRGYWlsUHJvdmlzaW9uYWxMb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlRXJyb3Im KTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRGYWlsTG9hZChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZUVycm9yJik7Ci0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWRO YW1lID0gU3RyaW5nKCkpOwogICAgICAgICAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2ViQ29y ZTo6V2lkZ2V0PiBjcmVhdGVKYXZhQXBwbGV0V2lkZ2V0KGNvbnN0IFdlYkNvcmU6OkludFNpemUm LCBXZWJDb3JlOjpIVE1MQXBwbGV0RWxlbWVudCosIGNvbnN0IFdlYkNvcmU6OktVUkwmIGJhc2VV UkwsIGNvbnN0IFZlY3RvcjxXVEY6OlN0cmluZz4mIHBhcmFtTmFtZXMsIGNvbnN0IFZlY3RvcjxX VEY6OlN0cmluZz4mIHBhcmFtVmFsdWVzKTsKIApJbmRleDogU291cmNlL1dlYktpdC93aW5jZS9D aGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cJKHJl dmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC93aW5jZS9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVy eSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25s b2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5 IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dFdpbkNFLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3Rh cnREb3dubG9hZCk6CisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRX aW5DRS5oOgorCiAyMDExLTA3LTE1ICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAK ICAgICAgICAgUkVHUkVTU0lPTjogTW91c2UgY3Vyc29yIGRvZXNu4oCZdCBoaWRlIHdoZW4gZnVs bCBzY3JlZW4gdmlkZW8gSFVEIGhpZGVzCkluZGV4OiBTb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAJ KHJldmlzaW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFdpbkNFLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTk3LDcgKzU5Nyw3 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c2V0TWFpbkRvY3UKICAgICBtX2hhc1Nl bnRSZXNwb25zZVRvUGx1Z2luID0gZmFsc2U7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnRX aW5DRTo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKQordm9p ZCBGcmFtZUxvYWRlckNsaWVudFdpbkNFOjpzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAg ICBub3RJbXBsZW1lbnRlZCgpOwogfQpJbmRleDogU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dl YktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNFLmgJKHJldmlz aW9uIDkxNzc2KQorKysgU291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudFdpbkNFLmgJKHdvcmtpbmcgY29weSkKQEAgLTEyNSw3ICsxMjUsNyBAQCBwdWJs aWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeShib29sKTsK IAotICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNl UmVxdWVzdCYpOworICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6 OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygp KTsKIAogICAgIHZpcnR1YWwgdm9pZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRM b2FkZXIqKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1l bnRMb2FkZXIqKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvd3gvQ2hhbmdlTG9nCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJLaXQvd3gvQ2hhbmdlTG9nCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJj ZS9XZWJLaXQvd3gvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIw MTEtMDctMjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgor CisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBp biBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgICog V2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYktpdFN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5oOgorCiAyMDExLTA3LTE1ICBEYW4gQmVybnN0ZWlu ICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAgICAgUkVHUkVTU0lPTjogTW91c2UgY3Vyc29yIGRv ZXNu4oCZdCBoaWRlIHdoZW4gZnVsbCBzY3JlZW4gdmlkZW8gSFVEIGhpZGVzCkluZGV4OiBTb3Vy Y2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 V3guY3BwCShyZXZpc2lvbiA5MTc3NikKKysrIFNvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcAkod29ya2luZyBjb3B5KQpAQCAtODQwLDcgKzg0MCw3 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6ZGlzcGF0Y2hVbmFibGUKICAgICBub3RJbXBs ZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXeDo6c3RhcnRE b3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3Rl ZE5hbWUgKi8pCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KSW5kZXg6IFNvdXJjZS9XZWJL aXQvd3gvV2ViS2l0U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaAkocmV2 aXNpb24gOTE3NzYpCisrKyBTb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRXeC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMDYsNyArMjA2LDcgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JO YXZpZ2F0aW9uQWN0aW9uKEZyYW1lUG9saWN5RnVuY3Rpb24gZnVuY3Rpb24sIGNvbnN0IE5hdmln YXRpb25BY3Rpb24mLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmLCBQYXNzUmVmUHRyPEZvcm1TdGF0 ZT4pOwogICAgICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGlj eShjb25zdCBSZXNvdXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93 bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFy dERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVk TmFtZSA9IFN0cmluZygpKTsKICAgICAgICAgCiAgICAgICAgIC8vIEZJWE1FOiBUaGlzIHNob3Vs ZCBwcm9iYWJseSBub3QgYmUgaGVyZSwgYnV0IGl0J3MgbmVlZGVkIGZvciB0aGUgdGVzdHMgY3Vy cmVudGx5CiAgICAgICAgIHZpcnR1YWwgdm9pZCBwYXJ0Q2xlYXJlZEluQmVnaW4oKTsKSW5kZXg6 IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9u IDkxNzc2KQorKysgVG9vbHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQg QEAKKzIwMTEtMDctMjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0u b3JnPgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJp YnV0ZSBpbiBhbmNob3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwOgorICAgICAgICAo V2ViVmlld0hvc3Q6OmxvYWRVUkxFeHRlcm5hbGx5KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oOgorCiAyMDExLTA3LTI2ICBBZGFtIEJhcnRoICA8YWJh cnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgV2luZG93cyBib3RzIG9uIGJ1aWxkLmNocm9taXVt Lm9yZyBjYW4ndCBmaWd1cmUgb3V0IHRoZSBoZWFkX3N2bl9yZXZpc2lvbgpJbmRleDogVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRv b2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAkocmV2aXNpb24gOTE3 NzYpCisrKyBUb29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTc5OSw3ICs3OTksMTIgQEAgYm9vbCBXZWJWaWV3SG9zdDo6YWxsb3dJ bWFnZXMoV2ViRnJhbWUqIAogICAgIHJldHVybiBlbmFibGVkUGVyU2V0dGluZ3M7CiB9CiAKLXZv aWQgV2ViVmlld0hvc3Q6OmxvYWRVUkxFeHRlcm5hbGx5KFdlYkZyYW1lKiwgY29uc3QgV2ViVVJM UmVxdWVzdCYgcmVxdWVzdCwgV2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3kpCit2b2lkIFdlYlZp ZXdIb3N0Ojpsb2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdlYlVSTFJl cXVlc3QmIHJlcXVlc3QsIFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5KQoreworICAgIGxvYWRV UkxFeHRlcm5hbGx5KGZyYW1lLCByZXF1ZXN0LCBwb2xpY3ksIFdlYlN0cmluZygpKTsKK30KKwor dm9pZCBXZWJWaWV3SG9zdDo6bG9hZFVSTEV4dGVybmFsbHkoV2ViRnJhbWUqLCBjb25zdCBXZWJV UkxSZXF1ZXN0JiByZXF1ZXN0LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSwgY29uc3QgV2Vi U3RyaW5nJiBkb3dubG9hZE5hbWUpCiB7CiAgICAgQVNTRVJUKHBvbGljeSAhPSAgV2ViS2l0OjpX ZWJOYXZpZ2F0aW9uUG9saWN5Q3VycmVudFRhYik7CiAgICAgV2ViVmlld0hvc3QqIGFub3RoZXIg PSBtX3NoZWxsLT5jcmVhdGVOZXdXaW5kb3cocmVxdWVzdC51cmwoKSk7CkluZGV4OiBUb29scy9E dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgJKHJldmlzaW9uIDkxNzc2KQor KysgVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaAkod29ya2luZyBj b3B5KQpAQCAtMTc0LDYgKzE3NCw3IEBAIGNsYXNzIFdlYlZpZXdIb3N0IDogcHVibGljIFdlYktp dDo6V2ViU3AKICAgICAgdmlydHVhbCBib29sIGFsbG93UGx1Z2lucyhXZWJLaXQ6OldlYkZyYW1l KiwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3MpOwogICAgIHZpcnR1YWwgYm9vbCBhbGxvd0ltYWdl cyhXZWJLaXQ6OldlYkZyYW1lKiwgYm9vbCBlbmFibGVkUGVyU2V0dGluZ3MpOwogICAgIHZpcnR1 YWwgdm9pZCBsb2FkVVJMRXh0ZXJuYWxseShXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0 OjpXZWJVUkxSZXF1ZXN0JiwgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5KTsKKyAgICB2aXJ0 dWFsIHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNvbnN0IFdlYktp dDo6V2ViVVJMUmVxdWVzdCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSwgY29uc3QgV2Vi S2l0OjpXZWJTdHJpbmcmIGRvd25sb2FkTmFtZSk7CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYk5h dmlnYXRpb25Qb2xpY3kgZGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbigKICAgICAgICAgV2ViS2l0 OjpXZWJGcmFtZSosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVxdWVzdCYsCiAgICAgICAgIFdlYktp dDo6V2ViTmF2aWdhdGlvblR5cGUsIGNvbnN0IFdlYktpdDo6V2ViTm9kZSYsCkluZGV4OiBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShy ZXZpc2lvbiA5MTc3NikKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpA QCAtMSwzICsxLDE5IEBACisyMDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2Fk cnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2Zp bGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBC YXJ0aC4KKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3du bG9hZC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JF bGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1k b3dubG9hZC11bnNldC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNldC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQtZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9h bmNob3Itbm9kb3dubG9hZC1zZXQuaHRtbDogQWRkZWQuCisKIDIwMTEtMDctMjYgIEFkcmllbm5l IFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21pdW1dIGdldENsaWVu dFJlY3RzIG5vdyBmYWlscyBzaW1pbGFybHkgb24gTWFjIGFmdGVyIHI5MTc2My4KSW5kZXg6IExh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC1leHBl Y3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVs ZW1lbnQvYW5jaG9yLWRvd25sb2FkLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC1leHBlY3Rl ZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEgQEAKK0Jsb2IgVVJMCkluZGV4OiBMYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQtZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JF bGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQt dW5zZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxIEBACitQQVNTCkluZGV4 OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQt dW5zZXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNldC5o dG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM4IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1s PgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+ Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCIgZG93bmxvYWQ+QmxvYiBVUkw8L2E+ Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkKK3sKKyAgICBpZiAoIXdpbmRvdy5ldmVu dFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sgdGhlIGxpbmsgdG8gcnVuIHRoZSB0ZXN0 LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRv KGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0VG9wICsgNSk7CisgICAgZXZlbnRTZW5k ZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworfQorCitmdW5jdGlv biBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcgV2ViS2l0QmxvYkJ1aWxkZXIoKTsKKyAg ICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0 bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2Jv ZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29u dHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgICAgdmFyIGJs b2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5saW5lIik7CisgICAgdmFyIGxpbmsgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgICBsaW5rLmhyZWYgPSB3aW5k b3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKyAgICBsaW5rLnJlbW92ZUF0dHJp YnV0ZSgnZG93bmxvYWQnKTsKKyAgICBjbGljayhsaW5rKTsKK30KK3J1blRlc3QoKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFu Y2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLmh0bWwJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It ZG93bmxvYWQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNyBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnPgoraWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKK30K Kzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxvYi11cmwiIGRvd25sb2FkPkJs b2IgVVJMPC9hPgorPHNjcmlwdD4KK2Z1bmN0aW9uIGNsaWNrKGVsbXQpCit7CisgICAgaWYgKCF3 aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICAgICAgYWxlcnQoJ0NsaWNrIHRoZSBsaW5rIHRvIHJ1 biB0aGUgdGVzdC4nKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBldmVudFNlbmRlci5t b3VzZU1vdmVUbyhlbG10Lm9mZnNldExlZnQgKyA1LCBlbG10Lm9mZnNldFRvcCArIDUpOworICAg IGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlVXAoKTsKK30K KworZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgICAgdmFyIGJiID0gbmV3IFdlYktpdEJsb2JCdWls ZGVyKCk7CisgICAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRtbD48aHRtbD48aGVhZD48dGl0bGU+ VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIgKyAic2NyaXB0PjwvaGVhZD48Ym9k eT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgbGF5 b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2NyIiArICJpcHQ+PC9odG1sPiIpOwor ICAgIHZhciBibG9iID0gYmIuZ2V0QmxvYigidGV4dC9odG1sIiwgImlubGluZSIpOworICAgIHZh ciBsaW5rID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImJsb2ItdXJsIik7CisgICAgbGluay5o cmVmID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwoYmxvYik7CisgICAgY2xpY2so bGluayk7Cit9CitydW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6 IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2Fk LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9h ZC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEgQEAKK1BBU1MKSW5kZXg6IExh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLXNl dC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFu Y2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtc2V0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24g MCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rv d25sb2FkLXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEgQEAKK0Jsb2Ig VVJMCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It bm9kb3dubG9hZC1zZXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQuaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25s b2FkLXNldC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM5IEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+CitpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQor PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCI+QmxvYiBVUkw8L2E+ Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkKK3sKKyAgICBpZiAoIXdpbmRvdy5ldmVu dFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sgdGhlIGxpbmsgdG8gcnVuIHRoZSB0ZXN0 LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRv KGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0VG9wICsgNSk7CisgICAgZXZlbnRTZW5k ZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworfQorCitmdW5jdGlv biBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcgV2ViS2l0QmxvYkJ1aWxkZXIoKTsKKyAg ICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0 bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBBU1M8L2Jv ZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRUZXN0Q29u dHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgICAgdmFyIGJs b2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5saW5lIik7CisgICAgdmFyIGxpbmsgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgICBsaW5rLmhyZWYgPSB3aW5k b3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKyAgICBsaW5rLnNldEF0dHJpYnV0 ZSgnZG93bmxvYWQnKTsKKyAgICBjbGljayhsaW5rKTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgorCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwJKHJl dmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3Itbm9kb3dubG9hZC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM4IEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+ CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgp OworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCI+QmxvYiBV Ukw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkKK3sKKyAgICBpZiAoIXdpbmRv dy5ldmVudFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sgdGhlIGxpbmsgdG8gcnVuIHRo ZSB0ZXN0LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGV2ZW50U2VuZGVyLm1vdXNl TW92ZVRvKGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0VG9wICsgNSk7CisgICAgZXZl bnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VVcCgpOworfQorCitm dW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcgV2ViS2l0QmxvYkJ1aWxkZXIo KTsKKyAgICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFkPjx0aXRsZT5UaXRs ZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9oZWFkPjxib2R5PlBB U1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0bWw+Iik7CisgICAg dmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5saW5lIik7CisgICAgdmFyIGxp bmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAgICBsaW5rLmhyZWYg PSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKyAgICBjbGljayhsaW5r KTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgorCkluZGV4OiBM YXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAkocmV2aXNpb24gOTE3NzYpCisrKyBMYXlvdXRUZXN0cy9w bGF0Zm9ybS9ndGsvU2tpcHBlZAkod29ya2luZyBjb3B5KQpAQCAtMTUyNSw2ICsxNTI1LDEyIEBA IGh0dHAvdGVzdHMvZXZlbnRzb3VyY2Uvd29ya2Vycy9ldmVudHNvdXIKICMgZmFpbGluZyBkcm9w em9uZSB0ZXN0KGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYxNjMwKQog ZmFzdC9ldmVudHMvZHJvcHpvbmUtMDAyLmh0bWwKIAorIyBUZXN0cyB0aGF0IHJlcXVpcmUgRU5B QkxFKERPV05MT0FEX0FUVFJJQlVURSkuCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3Itbm9kb3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93 bmxvYWQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQt c2V0Lmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNl dC5odG1sCisKICMgRmFpbGluZyBiZWNhdXNlIFdlYkdMIGlzIG5vdCBlbmFibGVkCiBodHRwL3Rl c3RzL3NlY3VyaXR5L3dlYmdsLXJlbW90ZS1yZWFkLXJlbW90ZS1pbWFnZS1hbGxvd2VkLmh0bWwK IGh0dHAvdGVzdHMvc2VjdXJpdHkvd2ViZ2wtcmVtb3RlLXJlYWQtcmVtb3RlLWltYWdlLWFsbG93 ZWQtd2l0aC1jcmVkZW50aWFscy5odG1sCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv U2tpcHBlZAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAko cmV2aXNpb24gOTE3NzYpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAkod29y a2luZyBjb3B5KQpAQCAtMzQxLDYgKzM0MSwxMiBAQCBzdG9yYWdlL3N0b3JhZ2VpbmZvLXF1ZXJ5 LXVzYWdlLmh0bWwKIHN0b3JhZ2Uvc3RvcmFnZWluZm8tcmVxdWVzdC1xdW90YS5odG1sCiBzdG9y YWdlL3N0b3JhZ2VpbmZvLW5vLWNhbGxiYWNrcy5odG1sCiAKKyMgVGVzdHMgdGhhdCByZXF1aXJl IEVOQUJMRShET1dOTE9BRF9BVFRSSUJVVEUpLgorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLW5vZG93bmxvYWQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9y LWRvd25sb2FkLmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25s b2FkLXNldC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQt dW5zZXQuaHRtbAorCiAjIEV4cG9zZSB0aXRsZSBkaXJlY3Rpb24gaW4gV2ViS2l0IEFQSQogIyBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTg4NDUKIGZhc3QvZG9tL3Rp dGxlLWRpcmVjdGlvbmFsaXR5Lmh0bWwKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3F0L1Nr aXBwZWQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvU2tpcHBlZAkocmV2 aXNpb24gOTE3NzYpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCSh3b3JraW5n IGNvcHkpCkBAIC0yMzk4LDYgKzIzOTgsMTIgQEAgaHR0cC90ZXN0cy9sb2FkaW5nL3ByZWxvYWQt c2xvdy1sb2FkaW5nLgogaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kv bWVkaWEtc3JjLWFsbG93ZWQuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9jb250ZW50U2VjdXJp dHlQb2xpY3kvbWVkaWEtc3JjLWJsb2NrZWQuaHRtbAogCisjIFRlc3RzIHRoYXQgcmVxdWlyZSBF TkFCTEUoRE9XTkxPQURfQVRUUklCVVRFKS4KK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1ub2Rvd25sb2FkLmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1k b3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9h ZC1zZXQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLXVu c2V0Lmh0bWwKKwogIyBUaGlzIHBsYXRmb3JtIGRvZXMgbm90IHN1cHBvcnQgdGhlIFBhZ2UgVmlz aWJpbGl0eSBBUEkuCiBmYXN0L2V2ZW50cy9wYWdlLXZpc2liaWxpdHktaWZyYW1lLWRlbGV0ZS10 ZXN0Lmh0bWwKIGZhc3QvZXZlbnRzL3BhZ2UtdmlzaWJpbGl0eS1pZnJhbWUtbW92ZS10ZXN0Lmh0 bWwKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCShyZXZpc2lvbiA5MTc3NikKKysrIExh eW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCSh3b3JraW5nIGNvcHkpCkBAIC0xMzQyLDYg KzEzNDIsMTIgQEAgaHR0cC90ZXN0cy9zZWN1cml0eS93ZWJnbC1yZW1vdGUtcmVhZC1yZQogaHR0 cC90ZXN0cy9zZWN1cml0eS93ZWJnbC1yZW1vdGUtcmVhZC1yZW1vdGUtaW1hZ2UtYWxsb3dlZC13 aXRoLWNyZWRlbnRpYWxzLmh0bWwKIGh0dHAvdGVzdHMvc2VjdXJpdHkvd2ViZ2wtcmVtb3RlLXJl YWQtcmVtb3RlLWltYWdlLWJsb2NrZWQtbm8tY3Jvc3NvcmlnaW4uaHRtbAogCisjIFRlc3RzIHRo YXQgcmVxdWlyZSBFTkFCTEUoRE9XTkxPQURfQVRUUklCVVRFKS4KK2Zhc3QvZG9tL0hUTUxBbmNo b3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1kb3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNo b3Itbm9kb3dubG9hZC1zZXQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9y LWRvd25sb2FkLXVuc2V0Lmh0bWwKKwogIyBOZXcgZmxleGJveCBpcyBub3QgeWV0IGVuYWJsZWQu IGh0dHA6Ly93ZWJraXQub3JnL2IvNjIwNDgKIGNzczMvZmxleGJveAogCg== 102058 2011-07-26 15:04:54 -0700 2011-07-26 16:25:54 -0700 Patch that builds on mac bug-64580-20110726150453.patch text/plain 42868 abarth SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzgzKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzkgQEAKKzIwMTEtMDctMjYgIFNhZHJ1bCBI YWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIEFkZCBzdXBw b3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNob3JzLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1ODAKKworICAgICAg ICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgIFRoZSBkb3dubG9hZCBhdHRyaWJ1 dGUgYWxsb3dzIHRoZSBhdXRob3Igb2YgdGhlIGh5cGVybGluayB0byBjYXVzZSB0aGUKKyAgICAg ICAgYnJvd3NlciB0byBkb3dubG9hZCB0aGUgbGlua2VkIFVSTC4gIFRoZSBhdXRob3IgY2FuIGFs c28gc3VwcGx5IGEKKyAgICAgICAgc3VnZ2VzdGVkIGZpbGUgbmFtZSBpbiB0aGUgYXR0cmlidXRl IHZhbHVlLiAgVGhpcyBmZWF0dXJlIGlzIGEgcmVjZW50CisgICAgICAgIGFkZGl0aW9uIHRvIEhU TUwgdG8gYmV0dGVyIHN1cHBvcnQgb2ZmbGluZSBhcHBsaWNhdGlvbnMgdGhhdCB1c2UgYmxvYgor ICAgICAgICBVUkxzLiAgVHJhZGl0aW9uYWxseSwgd2ViIHNpdGVzIHVzZSB0aGUgSFRUUCBDb250 ZW50LURpc3Bvc2l0aW9uIGhlYWRlcgorICAgICAgICB0byB0cmlnZ2VyIGRvd25sb2FkcywgYnV0 IHRoYXQgb3B0aW9uIGlzbid0IGF2YWlsYWJsZSB3aGVuIHdvcmtpbmcKKyAgICAgICAgb2ZmbGlu ZS4KKworICAgICAgICBUaGVyZSBpcyBzb21lIHF1ZXN0aW9uIGFib3V0IHdoZXRoZXIgd2Ugc2hv dWxkIGluaXRpYXRlIGEgZG93bmxvYWQgd2hlbgorICAgICAgICB3ZSByZWNlaXZlIGEgRE9NLWNy ZWF0ZWQgY2xpY2sgZXZlbnQuICBUaGlzIHBhdGNoIGRvZXMgaW5pdGlhdGUgdGhlCisgICAgICAg IGRvd25sb2FkLCBidXQgd2UgbWlnaHQgcmV2aXNlIHRoYXQgZGVjaXNpb24gaW4gdGhlIGZ1dHVy ZSBhcyBwYXJ0IG9mIGEKKyAgICAgICAgbGFyZ2VyIGNoYW5nZSBpbiBob3cgV2ViS2l0IHRyZWF0 cyB0aGUgaW50ZXJhY3Rpb24gYmV0d2VlbiBkZWZhdWx0CisgICAgICAgIGV2ZW50IGhhbmRsZXJz IGFuZCBET00tY3JlYXRlZCBldmVudHMuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvZG9tL0hUTUxB bmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2Rv bS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCisgICAgICAgICAgICAg ICBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAor ICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxv YWQtc2V0Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTEFuY2hvckVsZW1lbnQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRsZUNsaWNrKToKKyAgICAg ICAgKiBodG1sL0hUTUxBbmNob3JFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MQW5jaG9y RWxlbWVudC5pZGw6CisgICAgICAgICogaHRtbC9IVE1MQXR0cmlidXRlTmFtZXMuaW46CisgICAg ICAgICogbG9hZGVyL0VtcHR5Q2xpZW50cy5oOgorICAgICAgICAoV2ViQ29yZTo6RW1wdHlGcmFt ZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50Lmg6CisKIDIwMTEtMDctMjYgIERhdmlkIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29t PgogCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MDc3 OApJbmRleDogU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAJKHJldmlz aW9uIDkxNzgzKQorKysgU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJBdHRyaWJ1dGUuaCIK ICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJG cmFtZUxvYWRlckNsaWVudC5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyVHlwZXMuaCIKICNpbmNs dWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCkBAIC0xNDcs MTAgKzE0OCw3IEBAIHZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmQKICAg ICAgICAgfQogCiAgICAgICAgIGlmIChpc0xpbmtDbGljayhldmVudCkgJiYgdHJlYXRMaW5rQXNM aXZlRm9yRXZlbnRUeXBlKGV2ZW50VHlwZShldmVudCkpKSB7Ci0gICAgICAgICAgICBTdHJpbmcg dXJsID0gc3RyaXBMZWFkaW5nQW5kVHJhaWxpbmdIVE1MU3BhY2VzKGdldEF0dHJpYnV0ZShocmVm QXR0cikpOwotICAgICAgICAgICAgYXBwZW5kU2VydmVyTWFwTW91c2VQb3NpdGlvbih1cmwsIGV2 ZW50KTsKLSAgICAgICAgICAgIGhhbmRsZUxpbmtDbGljayhldmVudCwgZG9jdW1lbnQoKSwgdXJs LCBnZXRBdHRyaWJ1dGUodGFyZ2V0QXR0ciksIGhhc1JlbChSZWxhdGlvbk5vUmVmZXJyZXIpKTsK LSAgICAgICAgICAgIHNlbmRQaW5ncyhkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1cmwpKTsKKyAg ICAgICAgICAgIGhhbmRsZUNsaWNrKGV2ZW50KTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAg ICAgfQogCkBAIC00OTIsNiArNDkwLDM3IEBAIHZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OnNlbmRQ aW5ncyhjb25zdCAKICAgICAgICAgUGluZ0xvYWRlcjo6c2VuZFBpbmcoZG9jdW1lbnQoKS0+ZnJh bWUoKSwgZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGluZ1VSTHNbaV0pLCBkZXN0aW5hdGlvblVS TCk7CiB9CiAKK3ZvaWQgSFRNTEFuY2hvckVsZW1lbnQ6OmhhbmRsZUNsaWNrKEV2ZW50KiBldmVu dCkKK3sKKyAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKKworICAgIEZyYW1lKiBmcmFt ZSA9IGRvY3VtZW50KCktPmZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJu OworCisgICAgU3RyaW5nIHVybCA9IHN0cmlwTGVhZGluZ0FuZFRyYWlsaW5nSFRNTFNwYWNlcyhm YXN0R2V0QXR0cmlidXRlKGhyZWZBdHRyKSk7CisgICAgYXBwZW5kU2VydmVyTWFwTW91c2VQb3Np dGlvbih1cmwsIGV2ZW50KTsKKyAgICBLVVJMIGt1cmwgPSBkb2N1bWVudCgpLT5jb21wbGV0ZVVS TCh1cmwpOworCisjaWYgRU5BQkxFKERPV05MT0FEX0FUVFJJQlVURSkKKyAgICBpZiAoaGFzQXR0 cmlidXRlKGRvd25sb2FkQXR0cikpIHsKKyAgICAgICAgUmVzb3VyY2VSZXF1ZXN0IHJlcXVlc3Qo a3VybCk7CisKKyAgICAgICAgaWYgKCFoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSkgeworICAg ICAgICAgICAgU3RyaW5nIHJlZmVycmVyID0gZnJhbWUtPmxvYWRlcigpLT5vdXRnb2luZ1JlZmVy cmVyKCk7CisgICAgICAgICAgICBpZiAoIXJlZmVycmVyLmlzRW1wdHkoKSAmJiAhU2VjdXJpdHlP cmlnaW46OnNob3VsZEhpZGVSZWZlcnJlcihrdXJsLCByZWZlcnJlcikpCisgICAgICAgICAgICAg ICAgcmVxdWVzdC5zZXRIVFRQUmVmZXJyZXIocmVmZXJyZXIpOworICAgICAgICAgICAgZnJhbWUt PmxvYWRlcigpLT5hZGRFeHRyYUZpZWxkc1RvTWFpblJlc291cmNlUmVxdWVzdChyZXF1ZXN0KTsK KyAgICAgICAgfQorCisgICAgICAgIGZyYW1lLT5sb2FkZXIoKS0+Y2xpZW50KCktPnN0YXJ0RG93 bmxvYWQocmVxdWVzdCwgZmFzdEdldEF0dHJpYnV0ZShkb3dubG9hZEF0dHIpKTsKKyAgICB9IGVs c2UKKyNlbmRpZgorICAgICAgICBmcmFtZS0+bG9hZGVyKCktPnVybFNlbGVjdGVkKGt1cmwsIHRh cmdldCgpLCBldmVudCwgZmFsc2UsIGZhbHNlLCBoYXNSZWwoUmVsYXRpb25Ob1JlZmVycmVyKSA/ IE5vUmVmZXJyZXIgOiBTZW5kUmVmZXJyZXIpOworCisgICAgc2VuZFBpbmdzKGt1cmwpOworfQor CiBIVE1MQW5jaG9yRWxlbWVudDo6RXZlbnRUeXBlIEhUTUxBbmNob3JFbGVtZW50OjpldmVudFR5 cGUoRXZlbnQqIGV2ZW50KQogewogICAgIGlmICghZXZlbnQtPmlzTW91c2VFdmVudCgpKQpJbmRl eDogU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEFuY2hvckVsZW1lbnQuaAkocmV2aXNpb24gOTE3ODMp CisrKyBTb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxBbmNob3JFbGVtZW50LmgJKHdvcmtpbmcgY29w eSkKQEAgLTExNSw2ICsxMTUsOCBAQCBwcml2YXRlOgogCiAgICAgdm9pZCBzZW5kUGluZ3MoY29u c3QgS1VSTCYgZGVzdGluYXRpb25VUkwpOwogCisgICAgdm9pZCBoYW5kbGVDbGljayhFdmVudCop OworCiAgICAgZW51bSBFdmVudFR5cGUgewogICAgICAgICBNb3VzZUV2ZW50V2l0aG91dFNoaWZ0 S2V5LAogICAgICAgICBNb3VzZUV2ZW50V2l0aFNoaWZ0S2V5LApJbmRleDogU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwJKHJldmlzaW9uIDkxNzgzKQorKysgU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MQW5jaG9yRWxlbWVudC5pZGwJKHdvcmtpbmcgY29weSkKQEAgLTI2 LDYgKzI2LDcgQEAgbW9kdWxlIGh0bWwgewogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERP TVN0cmluZyBhY2Nlc3NLZXk7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5n IGNoYXJzZXQ7CiAgICAgICAgIGF0dHJpYnV0ZSBbUmVmbGVjdF0gRE9NU3RyaW5nIGNvb3JkczsK KyAgICAgICAgYXR0cmlidXRlIFtDb25kaXRpb25hbD1ET1dOTE9BRF9BVFRSSUJVVEUsIFJlZmxl Y3RdIERPTVN0cmluZyBkb3dubG9hZDsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0LCBVUkxd IERPTVN0cmluZyBocmVmOwogICAgICAgICBhdHRyaWJ1dGUgW1JlZmxlY3RdIERPTVN0cmluZyBo cmVmbGFuZzsKICAgICAgICAgYXR0cmlidXRlIFtSZWZsZWN0XSBET01TdHJpbmcgbmFtZTsKSW5k ZXg6IFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCShyZXZpc2lvbiA5 MTc4MykKKysrIFNvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEF0dHJpYnV0ZU5hbWVzLmluCSh3b3Jr aW5nIGNvcHkpCkBAIC05MSw2ICs5MSw3IEBAIGRlZmVyCiBkaXIKIGRpcmVjdGlvbgogZGlzYWJs ZWQKK2Rvd25sb2FkCiBkcmFnZ2FibGUKIHdlYmtpdGRyb3B6b25lCiBlbmN0eXBlCkluZGV4OiBT b3VyY2UvV2ViQ29yZS9sb2FkZXIvRW1wdHlDbGllbnRzLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dlYkNvcmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJj ZS9XZWJDb3JlL2xvYWRlci9FbXB0eUNsaWVudHMuaAkod29ya2luZyBjb3B5KQpAQCAtMzEwLDcg KzMxMCw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVu dFJlYWR5KGJvb2wpIHsgfQogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3Qg UmVzb3VyY2VSZXF1ZXN0JikgeyB9CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29u c3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3RyaW5n KCkpIHsgVU5VU0VEX1BBUkFNKHN1Z2dlc3RlZE5hbWUpOyB9CiAKICAgICB2aXJ0dWFsIHZvaWQg d2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CiAgICAgdmlydHVhbCB2b2lkIGRp ZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgeyB9CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2Vi Q29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTc5LDcg KzE3OSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgCiAgICAgICAgIHZpcnR1YWwg dm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpID0gMDsKIAotICAgICAgICB2aXJ0 dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmKSA9IDA7CisgICAg ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNv bnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKSA9IDA7CiAKICAgICAgICAgdmly dHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShEb2N1bWVudExvYWRlciopID0gMDsKICAgICAgICAg dmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKikgPSAwOwpJbmRleDog U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cJKHdv cmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENo b3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9y IGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmll d2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViRnJhbWVMb2Fk ZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1 cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaDoKKwogMjAxMS0wNy0yNiAgRGFuIEJlcm5zdGVp biAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIDxyZGFyOi8vcHJvYmxlbS85ODQyODg5PiBB ZGQgYSBnZW5lcmljIHBpY3RvZ3JhcGggZm9udCBmYW1pbHkKSW5kZXg6IFNvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJh bWVMb2FkZXJDbGllbnQuY3BwCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC03ODksNyArNzg5LDcgQEAgdm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c2V0 TWFpbkZyYW1lRAogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgV2ViRnJhbWVMb2Fk ZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQor dm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAg ICBtX2ZyYW1lLT5zdGFydERvd25sb2FkKHJlcXVlc3QpOwogfQpJbmRleDogU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJh bWVMb2FkZXJDbGllbnQuaAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xpZW50LmgJKHdvcmtpbmcgY29w eSkKQEAgLTEyMiw3ICsxMjIsNyBAQCBwcml2YXRlOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBz ZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJvb2wpOwogICAgIAotICAgIHZpcnR1YWwgdm9pZCBz dGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZpcnR1 YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNv bnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsKICAgICAKICAgICB2aXJ0dWFs IHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmly dHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CkluZGV4 OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2Vi S2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisy MDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4K KworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUg aW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICAq IGZlYXR1cmVzLmd5cGk6CisgICAgICAgICogcHVibGljL1dlYkZyYW1lQ2xpZW50Lmg6CisgICAg ICAgIChXZWJLaXQ6OldlYkZyYW1lQ2xpZW50Ojpsb2FkVVJMRXh0ZXJuYWxseSk6CisgICAgICAg ICogc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1l TG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEZWNpZGVQb2xpY3lGb3JOYXZpZ2F0aW9uQWN0aW9u KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRJbXBsOjpzdGFydERvd25sb2Fk KToKKyAgICAgICAgKiBzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmg6CisKIDIwMTEtMDctMjUg IEFsIFBhdHJpY2sgIDxhcGF0cmlja0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmVtb3ZlZCBz dXBwb3J0IGZvciB0aGUgR0xfbGF0Y2hfQ0hST01JVU0gZXh0ZW5zaW9uIHdoaWNoIENocm9taXVt IG5vIGxvbmdlciBzdXBwb3J0cy4KSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vZmVhdHVy ZXMuZ3lwaQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL2ZlYXR1cmVzLmd5 cGkJKHJldmlzaW9uIDkxNzgzKQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9mZWF0dXJlcy5n eXBpCSh3b3JraW5nIGNvcHkpCkBAIC00NCw2ICs0NCw3IEBACiAgICAgICAnRU5BQkxFX0RFVklD RV9PUklFTlRBVElPTj0xJywKICAgICAgICdFTkFCTEVfRElSRUNUT1JZX1VQTE9BRD0xJywKICAg ICAgICdFTkFCTEVfRE9NX1NUT1JBR0U9MScsCisgICAgICAnRU5BQkxFX0RPV05MT0FEX0FUVFJJ QlVURT0xJywKICAgICAgICdFTkFCTEVfRVZFTlRTT1VSQ0U9MScsCiAgICAgICAnRU5BQkxFX0pB VkFTQ1JJUFRfSTE4Tl9BUEk9MScsCiAgICAgICAnRU5BQkxFX0ZJTEVfU1lTVEVNPTEnLApJbmRl eDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRnJhbWVDbGllbnQuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oCShy ZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1l Q2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTExNiw2ICsxMTYsOCBAQCBwdWJsaWM6CiAgICAg Ly8gVGhlIGNsaWVudCBzaG91bGQgaGFuZGxlIHRoZSBuYXZpZ2F0aW9uIGV4dGVybmFsbHkuCiAg ICAgdmlydHVhbCB2b2lkIGxvYWRVUkxFeHRlcm5hbGx5KAogICAgICAgICBXZWJGcmFtZSosIGNv bnN0IFdlYlVSTFJlcXVlc3QmLCBXZWJOYXZpZ2F0aW9uUG9saWN5KSB7IH0KKyAgICB2aXJ0dWFs IHZvaWQgbG9hZFVSTEV4dGVybmFsbHkoCisgICAgICAgIFdlYkZyYW1lKiwgY29uc3QgV2ViVVJM UmVxdWVzdCYsIFdlYk5hdmlnYXRpb25Qb2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxvYWRO YW1lKSB7IH0KIAogCiAgICAgLy8gTmF2aWdhdGlvbmFsIHF1ZXJpZXMgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkluZGV4OiBTb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAJKHJldmlzaW9u IDkxNzgzKQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJ bXBsLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTQ0LDcgKzk0NCw3IEBAIHZvaWQgRnJhbWVMb2Fk ZXJDbGllbnRJbXBsOjpkaXNwYXRjaERlY2kKICAgICBQb2xpY3lBY3Rpb24gcG9saWN5QWN0aW9u ID0gUG9saWN5SWdub3JlOwogCiAgICAgLy8gSXQgaXMgdmFsaWQgZm9yIHRoaXMgZnVuY3Rpb24g dG8gYmUgaW52b2tlZCBpbiBjb2RlIHBhdGhzIHdoZXJlIHRoZQotICAgIC8vIHRoZSB3ZWJ2aWV3 IGlzIGNsb3NlZC4KKyAgICAvLyB3ZWJ2aWV3IGlzIGNsb3NlZC4KICAgICAvLyBUaGUgbnVsbCBj aGVjayBoZXJlIGlzIHRvIGZpeCBhIGNyYXNoIHRoYXQgc2VlbXMgc3RyYW5nZQogICAgIC8vIChz ZWUgLSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM1NTQpLgogICAg IGlmIChtX3dlYkZyYW1lLT5jbGllbnQoKSAmJiAhcmVxdWVzdC51cmwoKS5pc051bGwoKSkgewpA QCAtMTA3Myw3ICsxMDczLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OnNldE1haW5G cmFtZQogCiAvLyBDcmVhdGVzIGEgbmV3IGNvbm5lY3Rpb24gYW5kIGJlZ2lucyBkb3dubG9hZGlu ZyBmcm9tIHRoYXQgKGNvbnRyYXN0IHRoaXMKIC8vIHdpdGggfGRvd25sb2FkfCkuCi12b2lkIEZy YW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6c3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFt ZSAqLykKIHsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkpIHsKICAgICAgICAgV3JhcHBl ZFJlc291cmNlUmVxdWVzdCB3ZWJyZXEocmVxdWVzdCk7CkluZGV4OiBTb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaAkocmV2aXNpb24gOTE3 ODMpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwu aAkod29ya2luZyBjb3B5KQpAQCAtMTMxLDcgKzEzMSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgcG9zdFByb2dyZXNzRXN0aW1hdGVDaGFuZ2VkTm90aWZpY2F0aW9uKCk7CiAgICAgdmly dHVhbCB2b2lkIHBvc3RQcm9ncmVzc0ZpbmlzaGVkTm90aWZpY2F0aW9uKCk7CiAgICAgdmlydHVh bCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7Ci0gICAgdmlydHVhbCB2b2lk IHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmly dHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg Y29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpOwogICAgIHZpcnR1YWwgdm9p ZCB3aWxsQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0dWFs IHZvaWQgZGlkQ2hhbmdlVGl0bGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqKTsKICAgICB2aXJ0 dWFsIHZvaWQgY29tbWl0dGVkTG9hZChXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IGNo YXIqLCBpbnQpOwpJbmRleDogU291cmNlL1dlYktpdC9lZmwvQ2hhbmdlTG9nCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJLaXQvZWZsL0NoYW5nZUxvZwkocmV2aXNpb24gOTE3ODMpCisrKyBTb3Vy Y2UvV2ViS2l0L2VmbC9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAor MjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmlidXRl IGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAg KiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVmbC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpGcmFtZUxvYWRlckNsaWVudEVmbDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaDoKKwogMjAxMS0wNy0yNSAgSnVuZ0pp ayBMZWUgIDxqdW5namlrLmxlZUBzYW1zdW5nLmNvbT4KIAogICAgICAgICBbRUZMXSBSZW1vdmUg dW51c2VkIGNvZGUgaW4gZXdrX3RpbGVfbW9kZWwuYwpJbmRleDogU291cmNlL1dlYktpdC9lZmwv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmNwcAko cmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEVmbC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTg3MSw3ICs4NzEsNyBAQCB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZsOjpzZXRNYWluRG9jdW1lCiAgICAgbV9oYXNTZW50UmVz cG9uc2VUb1BsdWdpbiA9IGZhbHNlOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50RWZsOjpz dGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgRnJhbWVM b2FkZXJDbGllbnRFZmw6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1 ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgaWYgKCFtX3Zp ZXcpCiAgICAgICAgIHJldHVybjsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvZWZsL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50RWZsLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9l ZmwvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRFZmwuaAkocmV2aXNpb24gOTE3ODMp CisrKyBTb3VyY2UvV2ViS2l0L2VmbC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEVm bC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNTMsNyArMTUzLDcgQEAgY2xhc3MgRnJhbWVMb2FkZXJD bGllbnRFZmwgOiBwdWJsaWMgRnJhbQogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5GcmFtZURv Y3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25z dCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmco KSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7 CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVRpdGxlKERvY3VtZW50TG9hZGVyKik7CkluZGV4 OiBTb3VyY2UvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktp dC9ndGsvQ2hhbmdlTG9nCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQvZ3RrL0No YW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTI2ICBTYWRy dWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQg c3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJD bGllbnQ6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9h ZGVyQ2xpZW50R3RrLmg6CisKIDIwMTEtMDctMjYgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dh cmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIFJlbW92ZSBoZWFkZXIgd2Via2l0d2Vi dmlld2NvbW1vbi5oCkluZGV4OiBTb3VyY2UvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEd0ay5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9ndGsvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCShyZXZpc2lvbiA5MTc4MykKKysr IFNvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMTIyMSw3ICsxMjIxLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6c2V0TWFpbkRvY3VtZW50RQogICAgIH0KIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVu dDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZy YW1lTG9hZGVyQ2xpZW50OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVx dWVzdCwgY29uc3QgU3RyaW5nJiAvKiBzdWdnZXN0ZWROYW1lICovKQogewogICAgIEdSZWZQdHI8 V2ViS2l0TmV0d29ya1JlcXVlc3Q+IG5ldHdvcmtSZXF1ZXN0KGFkb3B0R1JlZihraXROZXcocmVx dWVzdCkpKTsKICAgICBXZWJLaXRXZWJWaWV3KiB2aWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2Zy YW1lKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2Vi S2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCSh3b3JraW5nIGNv cHkpCkBAIC0xMzAsNyArMTMwLDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICAgICAgICAgdmly dHVhbCB2b2lkIHNldE1haW5GcmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICAgICAgdmly dHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7 CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsKIAog ICAgICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9h ZGVyKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1 bWVudExvYWRlciopOwpJbmRleDogU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNzgzKQor KysgU291cmNlL1dlYktpdC9oYWlrdS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyAr MSwxNCBAQAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScg YXR0cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisK KyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEhhaWt1LmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQpOgor ICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaDoKKwogMjAx MS0wNy0xNSAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JF U1NJT046IE1vdXNlIGN1cnNvciBkb2VzbuKAmXQgaGlkZSB3aGVuIGZ1bGwgc2NyZWVuIHZpZGVv IEhVRCBoaWRlcwpJbmRleDogU291cmNlL1dlYktpdC9oYWlrdS9XZWJDb3JlU3VwcG9ydC9GcmFt ZUxvYWRlckNsaWVudEhhaWt1LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuY3BwCShyZXZpc2lvbiA5MTc4 MykKKysrIFNvdXJjZS9XZWJLaXQvaGFpa3UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRIYWlrdS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTcwOSw3ICs3MDksNyBAQCB2b2lkIEZyYW1l TG9hZGVyQ2xpZW50SGFpa3U6OmRpc3BhdGNoVW5hCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0K IAotdm9pZCBGcmFtZUxvYWRlckNsaWVudEhhaWt1OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291 cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SGFpa3U6OnN0YXJ0RG93bmxvYWQo Y29uc3QgUmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiAvKiBzdWdnZXN0ZWROYW1lICov KQogewogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CkluZGV4OiBTb3VyY2UvV2ViS2l0L2hhaWt1 L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3Uu aAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0L2hhaWt1L1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50SGFpa3UuaAkod29ya2luZyBjb3B5KQpAQCAtMjE5LDcgKzIxOSw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXNzUmVmUHRyPEZvcm1TdGF0ZT4pOwogICAg ICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hVbmFibGVUb0ltcGxlbWVudFBvbGljeShjb25zdCBS ZXNvdXJjZUVycm9yJik7CiAKLSAgICAgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29u c3QgUmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0 cmluZygpKTsKIAogICAgICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJl IGhlcmUsIGJ1dCBpdCdzIG5lZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseS4KICAgICAgICAg dmlydHVhbCB2b2lkIHBhcnRDbGVhcmVkSW5CZWdpbigpOwpJbmRleDogU291cmNlL1dlYktpdC9t YWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViS2l0L21hYy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5oCShy ZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQvbWFjL1dlYkNvcmVTdXBwb3J0L1dlYkZy YW1lTG9hZGVyQ2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0MCw3ICsxNDAsNyBAQCBwcml2 YXRlOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJhbWVEb2N1bWVudFJlYWR5KGJv b2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQoY29uc3QgV2Vi Q29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBzdWdnZXN0ZWROYW1lID0gU3Ry aW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VUaXRsZShXZWJDb3JlOjpEb2N1 bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShXZWJDb3JlOjpE b2N1bWVudExvYWRlciopOwpJbmRleDogU291cmNlL1dlYktpdC9tYWMvV2ViQ29yZVN1cHBvcnQv V2ViRnJhbWVMb2FkZXJDbGllbnQubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9tYWMv V2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQubW0JKHJldmlzaW9uIDkxNzgzKQor KysgU291cmNlL1dlYktpdC9tYWMvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQu bW0JKHdvcmtpbmcgY29weSkKQEAgLTg3MCw3ICs4NzAsNyBAQCB2b2lkIFdlYkZyYW1lTG9hZGVy Q2xpZW50OjpzZXRNYWluRnJhbWVECiAgICAgW2dldFdlYlZpZXcobV93ZWJGcmFtZS5nZXQoKSkg c2V0TWFpbkZyYW1lRG9jdW1lbnRSZWFkeTpyZWFkeV07CiB9CiAKLXZvaWQgV2ViRnJhbWVMb2Fk ZXJDbGllbnQ6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQor dm9pZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6c3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJl cXVlc3QmIHJlcXVlc3QsIGNvbnN0IFN0cmluZyYgLyogc3VnZ2VzdGVkTmFtZSAqLykKIHsKICAg ICAvLyBGSVhNRTogU2hvdWxkIGRvd25sb2FkIGZ1bGwgcmVxdWVzdC4KICAgICBXZWJEb3dubG9h ZCAqZG93bmxvYWQgPSBbZ2V0V2ViVmlldyhtX3dlYkZyYW1lLmdldCgpKSBfZG93bmxvYWRVUkw6 cmVxdWVzdC51cmwoKV07CkluZGV4OiBTb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwkocmV2aXNpb24gOTE3ODMpCisrKyBT b3VyY2UvV2ViS2l0L3F0L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBA CisyMDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9y Zz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1 dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAg ICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZCk6CisgICAgICAgICogV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5oOgorCiAyMDExLTA3LTI2ICBBbGV4aXMg TWVuYXJkICA8YWxleGlzLm1lbmFyZEBvcGVuYm9zc2Eub3JnPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IEFuZHJlYXMgS2xpbmcuCkluZGV4OiBTb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvcXQv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAJKHJldmlzaW9uIDkxNzgzKQor KysgU291cmNlL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNw cAkod29ya2luZyBjb3B5KQpAQCAtMTI5Niw3ICsxMjk2LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudFF0OjpkaXNwYXRjaFVuYWJsZQogICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQg RnJhbWVMb2FkZXJDbGllbnRRdDo6c3RhcnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmIHJlcXVlc3QpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnN0YXJ0RG93bmxv YWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcm IC8qIHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgaWYgKCFtX3dlYkZyYW1lKQogICAgICAgICBy ZXR1cm47CkluZGV4OiBTb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50UXQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0 L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0 L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuaAkod29ya2luZyBjb3B5KQpA QCAtMTQ5LDcgKzE0OSw3IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCBzZXRNYWluRnJh bWVEb2N1bWVudFJlYWR5KGJvb2wpOwogCi0gICAgdmlydHVhbCB2b2lkIHN0YXJ0RG93bmxvYWQo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0 RG93bmxvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgU3RyaW5nJiBz dWdnZXN0ZWROYW1lID0gU3RyaW5nKCkpOwogCiAgICAgdmlydHVhbCB2b2lkIHdpbGxDaGFuZ2VU aXRsZShEb2N1bWVudExvYWRlciopOwogICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VUaXRsZShE b2N1bWVudExvYWRlciopOwpJbmRleDogU291cmNlL1dlYktpdC93aW4vQ2hhbmdlTG9nCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gOTE3ODMpCisr KyBTb3VyY2UvV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwx NCBAQAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0 cmlidXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAg ICAgICAgKiBXZWJGcmFtZS5jcHA6CisgICAgICAgIChXZWJGcmFtZTo6c3RhcnREb3dubG9hZCk6 CisgICAgICAgICogV2ViRnJhbWUuaDoKKwogMjAxMS0wNy0yNiAgRGFuIEJlcm5zdGVpbiAgPG1p dHpAYXBwbGUuY29tPgogCiAgICAgICAgIDxyZGFyOi8vcHJvYmxlbS85ODQyODg5PiBBZGQgYSBn ZW5lcmljIHBpY3RvZ3JhcGggZm9udCBmYW1pbHkKSW5kZXg6IFNvdXJjZS9XZWJLaXQvd2luL1dl YkZyYW1lLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5jcHAJ KHJldmlzaW9uIDkxNzgzKQorKysgU291cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0xOTA3LDcgKzE5MDcsNyBAQCB2b2lkIFdlYkZyYW1lOjpkaXNwYXRjaERp ZEZhaWxMb2FkKGNvbnN0CiAgICAgfQogfQogCi12b2lkIFdlYkZyYW1lOjpzdGFydERvd25sb2Fk KGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3ZvaWQgV2ViRnJhbWU6OnN0YXJ0RG93 bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIC8qIHN1 Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgZC0+d2ViVmlldy0+ZG93bmxvYWRVUkwocmVxdWVzdC51 cmwoKSk7CiB9CkluZGV4OiBTb3VyY2UvV2ViS2l0L3dpbi9XZWJGcmFtZS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJLaXQvd2luL1dlYkZyYW1lLmgJKHJldmlzaW9uIDkxNzgzKQorKysgU291 cmNlL1dlYktpdC93aW4vV2ViRnJhbWUuaAkod29ya2luZyBjb3B5KQpAQCAtMzQyLDcgKzM0Miw3 IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VGcm9t TWVtb3J5Q2FjaGUoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiwgaW50IGxlbmd0 aCk7CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkRmFpbFByb3Zpc2lvbmFsTG9hZChjb25z dCBXZWJDb3JlOjpSZXNvdXJjZUVycm9yJik7CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlk RmFpbExvYWQoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VFcnJvciYpOwotICAgIHZpcnR1YWwgdm9p ZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYpOworICAgIHZp cnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYs IGNvbnN0IFN0cmluZyYgc3VnZ2VzdGVkTmFtZSA9IFN0cmluZygpKTsKICAgICAgICAgCiAgICAg dmlydHVhbCBQYXNzUmVmUHRyPFdlYkNvcmU6OldpZGdldD4gY3JlYXRlSmF2YUFwcGxldFdpZGdl dChjb25zdCBXZWJDb3JlOjpJbnRTaXplJiwgV2ViQ29yZTo6SFRNTEFwcGxldEVsZW1lbnQqLCBj b25zdCBXZWJDb3JlOjpLVVJMJiBiYXNlVVJMLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBw YXJhbU5hbWVzLCBjb25zdCBWZWN0b3I8V1RGOjpTdHJpbmc+JiBwYXJhbVZhbHVlcyk7CiAKSW5k ZXg6IFNvdXJjZS9XZWJLaXQvd2luY2UvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9X ZWJLaXQvd2luY2UvQ2hhbmdlTG9nCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQv d2luY2UvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTEtMDct MjYgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIEFkZCBzdXBwb3J0IGZvciBkb3dubG9hZD0nZmlsZW5hbWUnIGF0dHJpYnV0ZSBpbiBhbmNo b3JzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ1 ODAKKworICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgICogV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZy YW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQpOgorICAgICAgICAqIFdlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V2luQ0UuaDoKKwogMjAxMS0wNy0xNSAgRGFuIEJlcm5z dGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT046IE1vdXNlIGN1cnNv ciBkb2VzbuKAmXQgaGlkZSB3aGVuIGZ1bGwgc2NyZWVuIHZpZGVvIEhVRCBoaWRlcwpJbmRleDog U291cmNlL1dlYktpdC93aW5jZS9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFdpbkNF LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3dpbmNlL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50V2luQ0UuY3BwCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJL aXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTU5Nyw3ICs1OTcsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6 OnNldE1haW5Eb2N1CiAgICAgbV9oYXNTZW50UmVzcG9uc2VUb1BsdWdpbiA9IGZhbHNlOwogfQog Ci12b2lkIEZyYW1lTG9hZGVyQ2xpZW50V2luQ0U6OnN0YXJ0RG93bmxvYWQoY29uc3QgV2ViQ29y ZTo6UmVzb3VyY2VSZXF1ZXN0JikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnRXaW5DRTo6c3RhcnRE b3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcmIC8q IHN1Z2dlc3RlZE5hbWUgKi8pCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KSW5kZXg6IFNv dXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvd2luY2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVM b2FkZXJDbGllbnRXaW5DRS5oCShyZXZpc2lvbiA5MTc4MykKKysrIFNvdXJjZS9XZWJLaXQvd2lu Y2UvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXaW5DRS5oCSh3b3JraW5nIGNvcHkp CkBAIC0xMjUsNyArMTI1LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldE1haW5G cmFtZURvY3VtZW50UmVhZHkoYm9vbCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9h ZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3Rh cnREb3dubG9hZChjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBTdHJpbmcm IHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAKICAgICB2aXJ0dWFsIHZvaWQgd2lsbENoYW5n ZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CiAgICAgdmlydHVhbCB2b2lkIGRpZENo YW5nZVRpdGxlKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKik7CkluZGV4OiBTb3VyY2UvV2ViS2l0 L3d4L0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L3d4L0NoYW5nZUxvZwko cmV2aXNpb24gOTE3ODMpCisrKyBTb3VyY2UvV2ViS2l0L3d4L0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5 ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3IgZG93bmxv YWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg QWRhbSBCYXJ0aC4KKworICAgICAgICAqIFdlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRX eC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudFd4OjpzdGFydERvd25s b2FkKToKKyAgICAgICAgKiBXZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaDoKKwog MjAxMS0wNy0xNSAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIFJF R1JFU1NJT046IE1vdXNlIGN1cnNvciBkb2VzbuKAmXQgaGlkZSB3aGVuIGZ1bGwgc2NyZWVuIHZp ZGVvIEhVRCBoaWRlcwpJbmRleDogU291cmNlL1dlYktpdC93eC9XZWJLaXRTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50V3guY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvd3gvV2ViS2l0 U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFd4LmNwcAkocmV2aXNpb24gOTE3ODMpCisrKyBTb3Vy Y2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRXeC5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTg0MCw3ICs4NDAsNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50V3g6OmRp c3BhdGNoVW5hYmxlCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRl ckNsaWVudFd4OjpzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZy YW1lTG9hZGVyQ2xpZW50V3g6OnN0YXJ0RG93bmxvYWQoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jiwg Y29uc3QgU3RyaW5nJiAvKiBzdWdnZXN0ZWROYW1lICovKQogewogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CkluZGV4OiBTb3VyY2UvV2ViS2l0L3d4L1dlYktpdFN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRXeC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvd3gvV2ViS2l0U3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFd4LmgJKHJldmlzaW9uIDkxNzgzKQorKysgU291cmNlL1dlYktpdC93 eC9XZWJLaXRTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50V3guaAkod29ya2luZyBjb3B5KQpAQCAt MjA2LDcgKzIwNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lk IGRpc3BhdGNoRGVjaWRlUG9saWN5Rm9yTmF2aWdhdGlvbkFjdGlvbihGcmFtZVBvbGljeUZ1bmN0 aW9uIGZ1bmN0aW9uLCBjb25zdCBOYXZpZ2F0aW9uQWN0aW9uJiwgY29uc3QgUmVzb3VyY2VSZXF1 ZXN0JiwgUGFzc1JlZlB0cjxGb3JtU3RhdGU+KTsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3Bh dGNoVW5hYmxlVG9JbXBsZW1lbnRQb2xpY3koY29uc3QgUmVzb3VyY2VFcnJvciYpOwogCi0gICAg ICAgIHZpcnR1YWwgdm9pZCBzdGFydERvd25sb2FkKGNvbnN0IFJlc291cmNlUmVxdWVzdCYpOwor ICAgICAgICB2aXJ0dWFsIHZvaWQgc3RhcnREb3dubG9hZChjb25zdCBSZXNvdXJjZVJlcXVlc3Qm LCBjb25zdCBTdHJpbmcmIHN1Z2dlc3RlZE5hbWUgPSBTdHJpbmcoKSk7CiAgICAgICAgIAogICAg ICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgcHJvYmFibHkgbm90IGJlIGhlcmUsIGJ1dCBpdCdz IG5lZWRlZCBmb3IgdGhlIHRlc3RzIGN1cnJlbnRseQogICAgICAgICB2aXJ0dWFsIHZvaWQgcGFy dENsZWFyZWRJbkJlZ2luKCk7CkluZGV4OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g VG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA5MTc4MykKKysrIFRvb2xzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDExLTA3LTI2ICBTYWRydWwgSGFiaWIgQ2hv d2RodXJ5ICA8c2FkcnVsQGNocm9taXVtLm9yZz4KKworICAgICAgICBBZGQgc3VwcG9ydCBmb3Ig ZG93bmxvYWQ9J2ZpbGVuYW1lJyBhdHRyaWJ1dGUgaW4gYW5jaG9ycy4KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTgwCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dl YlZpZXdIb3N0LmNwcDoKKyAgICAgICAgKFdlYlZpZXdIb3N0Ojpsb2FkVVJMRXh0ZXJuYWxseSk6 CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaDoKKwogMjAx MS0wNy0yNiAgQWxleGFuZHJ1IENoaWN1bGl0YSAgPGFjaGljdUBhZG9iZS5jb20+CiAKICAgICAg ICAgQ1NTIFJlZ2lvbnMgYnVpbGQgYm90IHNob3VsZCBidWlsZCB3aXRoICItLWNzcy1yZWdpb25z IiBhbmQgIi0tY3NzLWV4Y2x1c2lvbiIgZmxhZ3MKSW5kZXg6IFRvb2xzL0R1bXBSZW5kZXJUcmVl L2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9EdW1wUmVuZGVy VHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAJKHJldmlzaW9uIDkxNzgzKQorKysgVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03OTksNyArNzk5LDEyIEBAIGJvb2wgV2ViVmlld0hvc3Q6OmFsbG93SW1hZ2VzKFdlYkZyYW1l KiAKICAgICByZXR1cm4gZW5hYmxlZFBlclNldHRpbmdzOwogfQogCi12b2lkIFdlYlZpZXdIb3N0 Ojpsb2FkVVJMRXh0ZXJuYWxseShXZWJGcmFtZSosIGNvbnN0IFdlYlVSTFJlcXVlc3QmIHJlcXVl c3QsIFdlYk5hdmlnYXRpb25Qb2xpY3kgcG9saWN5KQordm9pZCBXZWJWaWV3SG9zdDo6bG9hZFVS TEV4dGVybmFsbHkoV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXZWJVUkxSZXF1ZXN0JiByZXF1ZXN0 LCBXZWJOYXZpZ2F0aW9uUG9saWN5IHBvbGljeSkKK3sKKyAgICBsb2FkVVJMRXh0ZXJuYWxseShm cmFtZSwgcmVxdWVzdCwgcG9saWN5LCBXZWJTdHJpbmcoKSk7Cit9CisKK3ZvaWQgV2ViVmlld0hv c3Q6OmxvYWRVUkxFeHRlcm5hbGx5KFdlYkZyYW1lKiwgY29uc3QgV2ViVVJMUmVxdWVzdCYgcmVx dWVzdCwgV2ViTmF2aWdhdGlvblBvbGljeSBwb2xpY3ksIGNvbnN0IFdlYlN0cmluZyYgZG93bmxv YWROYW1lKQogewogICAgIEFTU0VSVChwb2xpY3kgIT0gIFdlYktpdDo6V2ViTmF2aWdhdGlvblBv bGljeUN1cnJlbnRUYWIpOwogICAgIFdlYlZpZXdIb3N0KiBhbm90aGVyID0gbV9zaGVsbC0+Y3Jl YXRlTmV3V2luZG93KHJlcXVlc3QudXJsKCkpOwpJbmRleDogVG9vbHMvRHVtcFJlbmRlclRyZWUv Y2hyb21pdW0vV2ViVmlld0hvc3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCShyZXZpc2lvbiA5MTc4MykKKysrIFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE3NCw2 ICsxNzQsNyBAQCBjbGFzcyBXZWJWaWV3SG9zdCA6IHB1YmxpYyBXZWJLaXQ6OldlYlNwCiAgICAg IHZpcnR1YWwgYm9vbCBhbGxvd1BsdWdpbnMoV2ViS2l0OjpXZWJGcmFtZSosIGJvb2wgZW5hYmxl ZFBlclNldHRpbmdzKTsKICAgICB2aXJ0dWFsIGJvb2wgYWxsb3dJbWFnZXMoV2ViS2l0OjpXZWJG cmFtZSosIGJvb2wgZW5hYmxlZFBlclNldHRpbmdzKTsKICAgICB2aXJ0dWFsIHZvaWQgbG9hZFVS TEV4dGVybmFsbHkoV2ViS2l0OjpXZWJGcmFtZSosIGNvbnN0IFdlYktpdDo6V2ViVVJMUmVxdWVz dCYsIFdlYktpdDo6V2ViTmF2aWdhdGlvblBvbGljeSk7CisgICAgdmlydHVhbCB2b2lkIGxvYWRV UkxFeHRlcm5hbGx5KFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlVSTFJlcXVl c3QmLCBXZWJLaXQ6OldlYk5hdmlnYXRpb25Qb2xpY3ksIGNvbnN0IFdlYktpdDo6V2ViU3RyaW5n JiBkb3dubG9hZE5hbWUpOwogICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJOYXZpZ2F0aW9uUG9saWN5 IGRlY2lkZVBvbGljeUZvck5hdmlnYXRpb24oCiAgICAgICAgIFdlYktpdDo6V2ViRnJhbWUqLCBj b25zdCBXZWJLaXQ6OldlYlVSTFJlcXVlc3QmLAogICAgICAgICBXZWJLaXQ6OldlYk5hdmlnYXRp b25UeXBlLCBjb25zdCBXZWJLaXQ6OldlYk5vZGUmLApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gOTE3ODMp CisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxOSBA QAorMjAxMS0wNy0yNiAgU2FkcnVsIEhhYmliIENob3dkaHVyeSAgPHNhZHJ1bEBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgQWRkIHN1cHBvcnQgZm9yIGRvd25sb2FkPSdmaWxlbmFtZScgYXR0cmli dXRlIGluIGFuY2hvcnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD02NDU4MAorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAg ICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It ZG93bmxvYWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEFuY2hvckVsZW1l bnQvYW5jaG9yLW5vZG93bmxvYWQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sOiBBZGRlZC4KKyAg ICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20v SFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtc2V0LWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxv YWQtc2V0Lmh0bWw6IEFkZGVkLgorCiAyMDExLTA3LTI2ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFw cGxlLmNvbT4KIAogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjA3NzgKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1kb3dubG9hZC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEgQEAKK0Jsb2Ig VVJMCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3It ZG93bmxvYWQtdW5zZXQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC11bnNldC1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3ItZG93bmxvYWQtdW5zZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCww ICsxIEBACitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hv ci1kb3dubG9hZC11bnNldC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM4IEBACis8IURP Q1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlw dCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250 cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9u ZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9iLXVybCIgZG93 bmxvYWQ+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkKK3sKKyAg ICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sgdGhlIGxp bmsgdG8gcnVuIHRoZSB0ZXN0LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGV2ZW50 U2VuZGVyLm1vdXNlTW92ZVRvKGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0VG9wICsg NSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VV cCgpOworfQorCitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcgV2ViS2l0 QmxvYkJ1aWxkZXIoKTsKKyAgICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFk Pjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9o ZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0 bWw+Iik7CisgICAgdmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5saW5lIik7 CisgICAgdmFyIGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAg ICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKyAg ICBsaW5rLnJlbW92ZUF0dHJpYnV0ZSgnZG93bmxvYWQnKTsKKyAgICBjbGljayhsaW5rKTsKK30K K3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLmh0bWwKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLWRv d25sb2FkLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwz NyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdCB0eXBlPSd0ZXh0 L2phdmFzY3JpcHQnPgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndh aXRVbnRpbERvbmUoKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8YSBpZD0iYmxv Yi11cmwiIGRvd25sb2FkPkJsb2IgVVJMPC9hPgorPHNjcmlwdD4KK2Z1bmN0aW9uIGNsaWNrKGVs bXQpCit7CisgICAgaWYgKCF3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICAgICAgYWxlcnQoJ0Ns aWNrIHRoZSBsaW5rIHRvIHJ1biB0aGUgdGVzdC4nKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyhlbG10Lm9mZnNldExlZnQgKyA1LCBlbG10Lm9m ZnNldFRvcCArIDUpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlRG93bigpOworICAgIGV2ZW50U2Vu ZGVyLm1vdXNlVXAoKTsKK30KKworZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgICAgdmFyIGJiID0g bmV3IFdlYktpdEJsb2JCdWlsZGVyKCk7CisgICAgYmIuYXBwZW5kKCI8IWRvY3R5cGUgaHRtbD48 aHRtbD48aGVhZD48dGl0bGU+VGl0bGU8L3RpdGxlPjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyA8LyIgKyAi c2NyaXB0PjwvaGVhZD48Ym9keT5QQVNTPC9ib2R5PjxzY3JpcHQ+aWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOzwvc2NyIiAr ICJpcHQ+PC9odG1sPiIpOworICAgIHZhciBibG9iID0gYmIuZ2V0QmxvYigidGV4dC9odG1sIiwg ImlubGluZSIpOworICAgIHZhciBsaW5rID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImJsb2It dXJsIik7CisgICAgbGluay5ocmVmID0gd2luZG93LndlYmtpdFVSTC5jcmVhdGVPYmplY3RVUkwo YmxvYik7CisgICAgY2xpY2sobGluayk7Cit9CitydW5UZXN0KCk7Cis8L3NjcmlwdD4KKzwvYm9k eT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50 L2FuY2hvci1ub2Rvd25sb2FkLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3Itbm9kb3dubG9hZC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEg QEAKK1BBU1MKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1ub2Rvd25sb2FkLXNldC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQtc2V0LWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JF bGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEgQEAKK0Jsb2IgVVJMCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5j aG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQuaHRtbAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQu aHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1ub2Rvd25sb2FkLXNldC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM5 IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9J3RleHQv amF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91 dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2Fp dFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlkPSJibG9i LXVybCI+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkKK3sKKyAg ICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sgdGhlIGxp bmsgdG8gcnVuIHRoZSB0ZXN0LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGV2ZW50 U2VuZGVyLm1vdXNlTW92ZVRvKGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0VG9wICsg NSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIubW91c2VV cCgpOworfQorCitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcgV2ViS2l0 QmxvYkJ1aWxkZXIoKTsKKyAgICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1sPjxoZWFk Pjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3JpcHQ+PC9o ZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlwdD48L2h0 bWw+Iik7CisgICAgdmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5saW5lIik7 CisgICAgdmFyIGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwiKTsKKyAg ICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9iKTsKKyAg ICBsaW5rLnNldEF0dHJpYnV0ZSgnZG93bmxvYWQnKTsKKyAgICBjbGljayhsaW5rKTsKK30KK3J1 blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgorCkluZGV4OiBMYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1u b2Rvd25sb2FkLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M QW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDM4IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0IHR5cGU9 J3RleHQvamF2YXNjcmlwdCc+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg IGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xs ZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxhIGlk PSJibG9iLXVybCI+QmxvYiBVUkw8L2E+Cis8c2NyaXB0PgorZnVuY3Rpb24gY2xpY2soZWxtdCkK K3sKKyAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikgeworICAgICAgICBhbGVydCgnQ2xpY2sg dGhlIGxpbmsgdG8gcnVuIHRoZSB0ZXN0LicpOworICAgICAgICByZXR1cm47CisgICAgfQorICAg IGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKGVsbXQub2Zmc2V0TGVmdCArIDUsIGVsbXQub2Zmc2V0 VG9wICsgNSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7CisgICAgZXZlbnRTZW5kZXIu bW91c2VVcCgpOworfQorCitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICB2YXIgYmIgPSBuZXcg V2ViS2l0QmxvYkJ1aWxkZXIoKTsKKyAgICBiYi5hcHBlbmQoIjwhZG9jdHlwZSBodG1sPjxodG1s PjxoZWFkPjx0aXRsZT5UaXRsZTwvdGl0bGU+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7IDwvIiArICJzY3Jp cHQ+PC9oZWFkPjxib2R5PlBBU1M8L2JvZHk+PHNjcmlwdD5pZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7PC9zY3IiICsgImlw dD48L2h0bWw+Iik7CisgICAgdmFyIGJsb2IgPSBiYi5nZXRCbG9iKCJ0ZXh0L2h0bWwiLCAiaW5s aW5lIik7CisgICAgdmFyIGxpbmsgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYmxvYi11cmwi KTsKKyAgICBsaW5rLmhyZWYgPSB3aW5kb3cud2Via2l0VVJMLmNyZWF0ZU9iamVjdFVSTChibG9i KTsKKyAgICBjbGljayhsaW5rKTsKK30KK3J1blRlc3QoKTsKKzwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgorCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAkocmV2aXNpb24gOTE3ODMp CisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAkod29ya2luZyBjb3B5KQpAQCAt MTUyNSw2ICsxNTI1LDEyIEBAIGh0dHAvdGVzdHMvZXZlbnRzb3VyY2Uvd29ya2Vycy9ldmVudHNv dXIKICMgZmFpbGluZyBkcm9wem9uZSB0ZXN0KGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTYxNjMwKQogZmFzdC9ldmVudHMvZHJvcHpvbmUtMDAyLmh0bWwKIAorIyBUZXN0 cyB0aGF0IHJlcXVpcmUgRU5BQkxFKERPV05MT0FEX0FUVFJJQlVURSkuCitmYXN0L2RvbS9IVE1M QW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9y RWxlbWVudC9hbmNob3ItZG93bmxvYWQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLW5vZG93bmxvYWQtc2V0Lmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2Fu Y2hvci1kb3dubG9hZC11bnNldC5odG1sCisKICMgRmFpbGluZyBiZWNhdXNlIFdlYkdMIGlzIG5v dCBlbmFibGVkCiBodHRwL3Rlc3RzL3NlY3VyaXR5L3dlYmdsLXJlbW90ZS1yZWFkLXJlbW90ZS1p bWFnZS1hbGxvd2VkLmh0bWwKIGh0dHAvdGVzdHMvc2VjdXJpdHkvd2ViZ2wtcmVtb3RlLXJlYWQt cmVtb3RlLWltYWdlLWFsbG93ZWQtd2l0aC1jcmVkZW50aWFscy5odG1sCkluZGV4OiBMYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0 Zm9ybS9tYWMvU2tpcHBlZAkocmV2aXNpb24gOTE3ODMpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMvU2tpcHBlZAkod29ya2luZyBjb3B5KQpAQCAtMzQxLDYgKzM0MSwxMiBAQCBzdG9yYWdl L3N0b3JhZ2VpbmZvLXF1ZXJ5LXVzYWdlLmh0bWwKIHN0b3JhZ2Uvc3RvcmFnZWluZm8tcmVxdWVz dC1xdW90YS5odG1sCiBzdG9yYWdlL3N0b3JhZ2VpbmZvLW5vLWNhbGxiYWNrcy5odG1sCiAKKyMg VGVzdHMgdGhhdCByZXF1aXJlIEVOQUJMRShET1dOTE9BRF9BVFRSSUJVVEUpLgorZmFzdC9kb20v SFRNTEFuY2hvckVsZW1lbnQvYW5jaG9yLW5vZG93bmxvYWQuaHRtbAorZmFzdC9kb20vSFRNTEFu Y2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVt ZW50L2FuY2hvci1ub2Rvd25sb2FkLXNldC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3ItZG93bmxvYWQtdW5zZXQuaHRtbAorCiAjIEV4cG9zZSB0aXRsZSBkaXJlY3Rpb24g aW4gV2ViS2l0IEFQSQogIyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NTg4NDUKIGZhc3QvZG9tL3RpdGxlLWRpcmVjdGlvbmFsaXR5Lmh0bWwKSW5kZXg6IExheW91dFRl c3RzL3BsYXRmb3JtL3F0L1NraXBwZWQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZv cm0vcXQvU2tpcHBlZAkocmV2aXNpb24gOTE3ODMpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9x dC9Ta2lwcGVkCSh3b3JraW5nIGNvcHkpCkBAIC0yMzk4LDYgKzIzOTgsMTIgQEAgaHR0cC90ZXN0 cy9sb2FkaW5nL3ByZWxvYWQtc2xvdy1sb2FkaW5nLgogaHR0cC90ZXN0cy9zZWN1cml0eS9jb250 ZW50U2VjdXJpdHlQb2xpY3kvbWVkaWEtc3JjLWFsbG93ZWQuaHRtbAogaHR0cC90ZXN0cy9zZWN1 cml0eS9jb250ZW50U2VjdXJpdHlQb2xpY3kvbWVkaWEtc3JjLWJsb2NrZWQuaHRtbAogCisjIFRl c3RzIHRoYXQgcmVxdWlyZSBFTkFCTEUoRE9XTkxPQURfQVRUUklCVVRFKS4KK2Zhc3QvZG9tL0hU TUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKK2Zhc3QvZG9tL0hUTUxBbmNo b3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1MQW5jaG9yRWxlbWVu dC9hbmNob3Itbm9kb3dubG9hZC1zZXQuaHRtbAorZmFzdC9kb20vSFRNTEFuY2hvckVsZW1lbnQv YW5jaG9yLWRvd25sb2FkLXVuc2V0Lmh0bWwKKwogIyBUaGlzIHBsYXRmb3JtIGRvZXMgbm90IHN1 cHBvcnQgdGhlIFBhZ2UgVmlzaWJpbGl0eSBBUEkuCiBmYXN0L2V2ZW50cy9wYWdlLXZpc2liaWxp dHktaWZyYW1lLWRlbGV0ZS10ZXN0Lmh0bWwKIGZhc3QvZXZlbnRzL3BhZ2UtdmlzaWJpbGl0eS1p ZnJhbWUtbW92ZS10ZXN0Lmh0bWwKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lw cGVkCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCShyZXZp c2lvbiA5MTc4MykKKysrIExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkCSh3b3JraW5n IGNvcHkpCkBAIC0xMzQyLDYgKzEzNDIsMTIgQEAgaHR0cC90ZXN0cy9zZWN1cml0eS93ZWJnbC1y ZW1vdGUtcmVhZC1yZQogaHR0cC90ZXN0cy9zZWN1cml0eS93ZWJnbC1yZW1vdGUtcmVhZC1yZW1v dGUtaW1hZ2UtYWxsb3dlZC13aXRoLWNyZWRlbnRpYWxzLmh0bWwKIGh0dHAvdGVzdHMvc2VjdXJp dHkvd2ViZ2wtcmVtb3RlLXJlYWQtcmVtb3RlLWltYWdlLWJsb2NrZWQtbm8tY3Jvc3NvcmlnaW4u aHRtbAogCisjIFRlc3RzIHRoYXQgcmVxdWlyZSBFTkFCTEUoRE9XTkxPQURfQVRUUklCVVRFKS4K K2Zhc3QvZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1ub2Rvd25sb2FkLmh0bWwKK2Zhc3Qv ZG9tL0hUTUxBbmNob3JFbGVtZW50L2FuY2hvci1kb3dubG9hZC5odG1sCitmYXN0L2RvbS9IVE1M QW5jaG9yRWxlbWVudC9hbmNob3Itbm9kb3dubG9hZC1zZXQuaHRtbAorZmFzdC9kb20vSFRNTEFu Y2hvckVsZW1lbnQvYW5jaG9yLWRvd25sb2FkLXVuc2V0Lmh0bWwKKwogIyBOZXcgZmxleGJveCBp cyBub3QgeWV0IGVuYWJsZWQuIGh0dHA6Ly93ZWJraXQub3JnL2IvNjIwNDgKIGNzczMvZmxleGJv eAogCg==