146200 2015-06-22 02:30:55 -0700 MediaDevices.getUserMedia should migrate from callbacks to DOMPromise 2015-06-23 23:52:44 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 youennf youennf adam.bergkvist calvaris commit-queue darin dbates eric.carlson jer.noble jonlee mdaiter sam oldest_to_newest 1103794 0 youennf 2015-06-22 02:30:55 -0700 DOMPromise is introduced to simplify Promise-based APIs. MediaDevices.getUserMedia could use it. Since webkitGetUserMedia is a client of MediaDevices.getUserMedia and uses a typed callback approach, DOMPromise could be accommodated to also enable callback style. This might be beneficial for any Promise API clients: Promise/Callback APIs, ReadableStream::tee or MSE appendStream. 1103822 1 255347 youennf 2015-06-22 06:36:25 -0700 Created attachment 255347 Patch 1103823 2 commit-queue 2015-06-22 06:38:32 -0700 Attachment 255347 did not pass style-queue: ERROR: Source/WebCore/bindings/js/JSDOMPromise.h:91: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 1 in 11 files If any of these errors are false positives, please file a bug against check-webkit-style. 1103864 3 255347 darin 2015-06-22 10:15:23 -0700 Comment on attachment 255347 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=255347&action=review > Source/WebCore/Modules/mediastream/MediaDevices.h:59 > + typedef DOMPromiseWithCallback<RefPtr<MediaStream>, RefPtr<NavigatorUserMediaError>> Promise; Why are the two arguments to this RefPtr instead of Ref or a plain old reference (MediaStream&)? > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:67 > + ScriptExecutionContext* context = navigator->frame()->document(); > + ASSERT(context); Instead of capturing a pointer to the navigator, I think we should capture a pointer to the document, since the only thing we do with the navigator is get to its document. The assertion isn’t that helpful (why can we assert the document is not null later?) and using ScriptExecutionContext as the type for the local variable doesn’t seem great. We should just write: RefPtr<Document> protectedDocument = navigator->frame()->document(); And then capture protectedDocument instead of navigator. > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:69 > + RefPtr<MediaStream> mediaStream = stream; protectedStream, not mediaStream (see my comment in the other bug about this) > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:79 > + RefPtr<NavigatorUserMediaError> eventError = error; protectedError, not eventError (see my comment in the other bug about this) > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:86 > + RefPtr<UserMediaRequest> request = UserMediaRequest::create(navigator->frame()->document(), userMedia, options, MediaDevices::Promise(WTF::move(resolveCallback), WTF::move(rejectCallback)), ec); I think auto would be better here than RefPtr<UserMediaRequest>. > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:88 > ec = NOT_SUPPORTED_ERR; Is this right? UserMediaRequest might fail and set "ec", then we overwrite the more specific ec with just NOT_SUPPORTED_ERR? Do we have test coverage? > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:56 > +// Declarations for resolving/rejecting promises Not a helpful comment, I don’t think. > Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:58 > +JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, MediaStream*); > +JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, NavigatorUserMediaError*); Could make the arguments references instead of pointers, unless these actually need to be null. I don’t understand why these functions are declared here. If they are local to this file they should be marked "static" to get internal linkage, or use an anonymous namespace to accomplish the same thing. But if they are used outside this file, then the declarations should be in a header. > Source/WebCore/bindings/js/JSDOMPromise.h:88 > +template <typename Value, typename Error> I typically omit the space after "template". > Source/WebCore/bindings/js/JSDOMPromise.h:91 > + DOMPromiseWithCallback(DeferredWrapper&& wrapper) : m_wrapper(WTF::move(wrapper)) { } Probably should mark this explicit. > Source/WebCore/bindings/js/JSDOMPromise.h:92 > + DOMPromiseWithCallback(std::function<void(const Value&)>&& resolve, std::function<void(const Error&)>&& reject) Since std::function is a move-only type, these arguments could just be std::function; no real need for them to be std:function&&. > Source/WebCore/bindings/js/JSDOMPromise.h:99 > + DOMPromiseWithCallback(DOMPromiseWithCallback&& promise) Probably should mark this explicit. > Source/WebCore/bindings/js/JSDOMPromise.h:105 > + DOMPromiseWithCallback(const DOMPromiseWithCallback&)= delete; > + DOMPromiseWithCallback& operator=(DOMPromiseWithCallback const&) = delete; Since the class already has data members of move only type (std::function) there won’t be a copy constructor created, just a move constructor. So deleting here is unnecessary. Please omit these lines of code. > Source/WebCore/bindings/js/JSDOMPromise.h:226 > +template <typename Value, typename Error> I typically omit the space after "template". > Source/WebCore/bindings/js/JSDOMPromise.h:227 > +void DOMPromiseWithCallback<Value, Error>::resolve(const Value& value) This simple function possibly should be marked inline. > Source/WebCore/bindings/js/JSDOMPromise.h:237 > +template <typename Value, typename Error> I typically omit the space after "template". > Source/WebCore/bindings/js/JSDOMPromise.h:238 > +void DOMPromiseWithCallback<Value, Error>::reject(const Error& error) This simple function possibly should be marked inline. 1103905 4 255347 youennf 2015-06-22 13:06:15 -0700 Comment on attachment 255347 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=255347&action=review >> Source/WebCore/Modules/mediastream/MediaDevices.h:59 >> + typedef DOMPromiseWithCallback<RefPtr<MediaStream>, RefPtr<NavigatorUserMediaError>> Promise; > > Why are the two arguments to this RefPtr instead of Ref or a plain old reference (MediaStream&)? Thanks for the review. Yes, a Ref should be used. >> Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:67 >> + ASSERT(context); > > Instead of capturing a pointer to the navigator, I think we should capture a pointer to the document, since the only thing we do with the navigator is get to its document. > > The assertion isn’t that helpful (why can we assert the document is not null later?) and using ScriptExecutionContext as the type for the local variable doesn’t seem great. We should just write: > > RefPtr<Document> protectedDocument = navigator->frame()->document(); > > And then capture protectedDocument instead of navigator. OK >> Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:69 >> + RefPtr<MediaStream> mediaStream = stream; > > protectedStream, not mediaStream (see my comment in the other bug about this) OK >> Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:88 >> ec = NOT_SUPPORTED_ERR; > > Is this right? UserMediaRequest might fail and set "ec", then we overwrite the more specific ec with just NOT_SUPPORTED_ERR? Do we have test coverage? This patch does not change that behavior. The current behavior is probably spec conformant. Butit would probably just be better to set ec to NOT_SUPPORTED_ERR within UserMediaRequest::create. @adam, any thought on that? >> Source/WebCore/Modules/mediastream/UserMediaRequest.cpp:58 >> +JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, NavigatorUserMediaError*); > > Could make the arguments references instead of pointers, unless these actually need to be null. > > I don’t understand why these functions are declared here. If they are local to this file they should be marked "static" to get internal linkage, or use an anonymous namespace to accomplish the same thing. But if they are used outside this file, then the declarations should be in a header. These routines are defined in automatically generated files (JSXXX.h). I will add the necessary "JSMediaStream.h" and "JSNavigatorUserMediaError.h" #include. It seems a bit unfortunate to include these files just for these standalone routines. >> Source/WebCore/bindings/js/JSDOMPromise.h:88 >> +template <typename Value, typename Error> > > I typically omit the space after "template". OK >> Source/WebCore/bindings/js/JSDOMPromise.h:91 >> + DOMPromiseWithCallback(DeferredWrapper&& wrapper) : m_wrapper(WTF::move(wrapper)) { } > > Probably should mark this explicit. I am not sure, JSMediaDevices.getUserMedia expects a DOMPromiseWithCallback but the JSMediaDevices automatically generated code gives it a DeferredWrapper. >> Source/WebCore/bindings/js/JSDOMPromise.h:92 >> + DOMPromiseWithCallback(std::function<void(const Value&)>&& resolve, std::function<void(const Error&)>&& reject) > > Since std::function is a move-only type, these arguments could just be std::function; no real need for them to be std:function&&. OK >> Source/WebCore/bindings/js/JSDOMPromise.h:99 >> + DOMPromiseWithCallback(DOMPromiseWithCallback&& promise) > > Probably should mark this explicit. OK >> Source/WebCore/bindings/js/JSDOMPromise.h:105 >> + DOMPromiseWithCallback& operator=(DOMPromiseWithCallback const&) = delete; > > Since the class already has data members of move only type (std::function) there won’t be a copy constructor created, just a move constructor. So deleting here is unnecessary. Please omit these lines of code. OK 1104049 5 youennf 2015-06-23 00:09:55 -0700 (In reply to comment #3) > Comment on attachment 255347 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=255347&action=review > > > Source/WebCore/Modules/mediastream/MediaDevices.h:59 > > + typedef DOMPromiseWithCallback<RefPtr<MediaStream>, RefPtr<NavigatorUserMediaError>> Promise; > > Why are the two arguments to this RefPtr instead of Ref or a plain old > reference (MediaStream&)? > > > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:67 > > + ScriptExecutionContext* context = navigator->frame()->document(); > > + ASSERT(context); > > Instead of capturing a pointer to the navigator, I think we should capture a > pointer to the document, since the only thing we do with the navigator is > get to its document. > > The assertion isn’t that helpful (why can we assert the document is not null > later?) and using ScriptExecutionContext as the type for the local variable > doesn’t seem great. We should just write: > > RefPtr<Document> protectedDocument = navigator->frame()->document(); > > And then capture protectedDocument instead of navigator. I am not sure that we should protect the document here. UserMediaRequest is observing context destruction and will cancel itself if that happens. I plan to update the patch by capturing an unprotected document. 1104054 6 255347 adam.bergkvist 2015-06-23 00:12:20 -0700 Comment on attachment 255347 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=255347&action=review > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:78 > + if (errorCallback) { The errorCallback is mandatory nowadays so this check isn't necessary. Blame me for not updating the code in UserMediaRequest and the idl file. :/ Let's create an issue on what's left of that mistake when this lands. >>> Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:88 >>> ec = NOT_SUPPORTED_ERR; >> >> Is this right? UserMediaRequest might fail and set "ec", then we overwrite the more specific ec with just NOT_SUPPORTED_ERR? Do we have test coverage? > > This patch does not change that behavior. > The current behavior is probably spec conformant. Butit would probably just be better to set ec to NOT_SUPPORTED_ERR within UserMediaRequest::create. > > @adam, any thought on that? NOT_SUPPORTED_ERR (neither audio nor video is requested) is the only possible error at this point. I agree that we can do this code better. I noted that ec is set to TYPE_MISMATCH_ERR a few calls down the line, but that isn't, and shouldn't, be surfaced. 1104066 7 youennf 2015-06-23 02:38:00 -0700 (In reply to comment #6) > Comment on attachment 255347 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=255347&action=review > > > Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:78 > > + if (errorCallback) { > > The errorCallback is mandatory nowadays so this check isn't necessary. Blame > me for not updating the code in UserMediaRequest and the idl file. :/ Let's > create an issue on what's left of that mistake when this lands. > > >>> Source/WebCore/Modules/mediastream/NavigatorUserMedia.cpp:88 > >>> ec = NOT_SUPPORTED_ERR; > >> > >> Is this right? UserMediaRequest might fail and set "ec", then we overwrite the more specific ec with just NOT_SUPPORTED_ERR? Do we have test coverage? > > > > This patch does not change that behavior. > > The current behavior is probably spec conformant. Butit would probably just be better to set ec to NOT_SUPPORTED_ERR within UserMediaRequest::create. > > > > @adam, any thought on that? > > NOT_SUPPORTED_ERR (neither audio nor video is requested) is the only > possible error at this point. I agree that we can do this code better. I > noted that ec is set to TYPE_MISMATCH_ERR a few calls down the line, but > that isn't, and shouldn't, be surfaced. Most of this code is actually shared between NavigatorUserMedia::webkitGetUserMedia and MediaDevices::getUserMedia. Except callbacks, it might be shared within UserMediaRequest::create, which could be renamed UserMediaRequest::start(). @adam, let me know if you would like to look at it first. Otherwise, I can have a quick stab at this refactoring after landing this one. 1104088 8 adam.bergkvist 2015-06-23 06:18:08 -0700 Feel free to take a stab at it. 1104090 9 255409 youennf 2015-06-23 06:22:05 -0700 Created attachment 255409 Patch for landing 1104091 10 commit-queue 2015-06-23 06:24:23 -0700 Attachment 255409 did not pass style-queue: ERROR: Source/WebCore/bindings/js/JSDOMPromise.h:91: Should be indented on a separate line, with the colon or comma first on that line. [whitespace/indent] [4] Total errors found: 1 in 11 files If any of these errors are false positives, please file a bug against check-webkit-style. 1104092 11 youennf 2015-06-23 06:33:57 -0700 (In reply to comment #9) > Created attachment 255409 [details] > Patch for landing Missing improvement pieces: - Using Ref<> within DOMPromiseWithCallback and not RefPtr<> (It probably requires modifying JSDOMBinding.h) - Refactoring to share code between webkitGetUserMedia and MediaDevices.getUserMedia - Making errorCallback parameter mandatory at the IDL level I plan to tackle the first two points. 1104095 12 255409 commit-queue 2015-06-23 07:10:55 -0700 Comment on attachment 255409 Patch for landing Clearing flags on attachment: 255409 Committed r185873: <http://trac.webkit.org/changeset/185873> 1104096 13 commit-queue 2015-06-23 07:11:01 -0700 All reviewed patches have been landed. Closing bug. 1104116 14 darin 2015-06-23 10:17:03 -0700 (In reply to comment #5) > I am not sure that we should protect the document here. > UserMediaRequest is observing context destruction and will cancel itself if > that happens. > I plan to update the patch by capturing an unprotected document. What happens to the promise in the case? How airtight is the guarantee that the lambdas won’t ever be called in that case? I am usually quite reluctant to rely on high level guarantees for object lifetime; it’s best to have the lifetime guarantees be as local and as airtight as possible. 1104323 15 youennf 2015-06-23 23:52:44 -0700 (In reply to comment #14) > (In reply to comment #5) > > I am not sure that we should protect the document here. > > UserMediaRequest is observing context destruction and will cancel itself if > > that happens. > > I plan to update the patch by capturing an unprotected document. > > What happens to the promise in the case? How airtight is the guarantee that > the lambdas won’t ever be called in that case? I am usually quite reluctant > to rely on high level guarantees for object lifetime; it’s best to have the > lifetime guarantees be as local and as airtight as possible. For each of the 3 possible methods that reject/resolve promises, the context status is checked first. If we capture a Document reference within the callbacks, the document will not be destroyed as long as the request is pending. A solution might be to create a context destruction observer that gets captured by the lambdas. This is safer but is also redundant with what does UserMediaRequest. Note that this observer could wrap the postTask functionality. As of pending promises in case of destroyed document, cancelling the UserMediaRequest should lead to releasing the request from below, thus releasing the promise and its strong references. We could clear the promise within cancel. In the 3 reject/resolve promises methods, the context status check would be replaced by a check on the promise (was it cleared or not.). Same behavior as currently but maybe more readable. 255347 2015-06-22 06:36:25 -0700 2015-06-23 06:21:58 -0700 Patch bug-146200-20150622153542.patch text/plain 27968 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg1ODIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODllMjExNTVjYTA2YmY2 NDQ3YzMzMGRkZmQ1ZDc1Yzc3OTk3OGNmNS4uNDkwNWZlNTk1YzMxN2JhOTVmODkyYjI4MTIzMjg2 N2VmNjg3MTJjOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE1LTA2LTIyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSBzaG91bGQgbWlncmF0ZSBmcm9tIGNhbGxiYWNrcyB0byBET01Q cm9taXNlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NDYyMDAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJ bnRyb2R1Y2VkIERPTVByb21pc2VXaXRoQ2FsbGJhY2sgdG8gcmVzb2x2ZS9yZWplY3QgcHJvbWlz ZXMgd2hpbGUgYWxsb3dpbmcgcHJvbWlzZSBjbGllbnRzIHRvIHVzZSBhIHR5cGVkIGNhbGxiYWNr IGFwcHJvYWNoLgorICAgICAgICBNaWdyYXRlZCBNZWRpYURldmljZXMuZ2V0VXNlck1lZGlhIGZy b20gY2FsbGJhY2tzIHRvIERPTVByb21pc2VXaXRoQ2FsbGJhY2suCisgICAgICAgIFJlbW92ZWQg TWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSBjdXN0b20gYmluZGluZy4KKworICAgICAgICBDb3Zl cmVkIGJ5IGV4aXN0aW5nIHRlc3RzLgorCisgICAgICAgICogQ01ha2VMaXN0cy50eHQ6IFJlbW92 aW5nIGN1c3RvbSBiaW5kaW5nLgorICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFE ZXZpY2VzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhRGV2aWNlczo6Z2V0VXNlck1lZGlh KTogTW92aW5nIGZyb20gY2FsbGJhY2sgdG8gcHJvbWlzZS4KKyAgICAgICAgKiBNb2R1bGVzL21l ZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5oOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL21lZGlh c3RyZWFtL01lZGlhRGV2aWNlcy5pZGw6IFJlbW92aW5nIGN1c3RvbSBiaW5kaW5nLgorICAgICAg ICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0vTmF2aWdhdG9yVXNlck1lZGlhLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6Ok5hdmlnYXRvclVzZXJNZWRpYTo6d2Via2l0R2V0VXNlck1lZGlhKTogQ29udmVy dGluZyBmcm9tIHByb21pc2UgY2FsbGJhY2sgdG8gQVBJIGNhbGxiYWNrcy4KKyAgICAgICAgKiBN b2R1bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6VXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKTogTW92aW5nIGZyb20gY2FsbGJhY2sgdG8gcHJv bWlzZS4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJlcXVl c3QpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmRpZENyZWF0 ZVN0cmVhbSk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6ZmFp bGVkVG9DcmVhdGVTdHJlYW1XaXRoQ29uc3RyYWludHNFcnJvcik6IERpdHRvLgorICAgICAgICAo V2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoUGVybWlz c2lvbkVycm9yKTogRGl0dG8uCisgICAgICAgICogTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVk aWFSZXF1ZXN0Lmg6IERpdHRvLgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRE9NUHJvbWlzZS5o OiBJbnRyb2R1Y2luZyBET01Qcm9taXNlV2l0aENhbGxiYWNrIGFuZCByZW1vdmluZyBjcnlwdG8g c3BlY2lmaWMgaGVhZGVyLgorICAgICAgICAoV2ViQ29yZTo6RE9NUHJvbWlzZVdpdGhDYWxsYmFj azo6RE9NUHJvbWlzZVdpdGhDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpFcnJvcj46OnJl c29sdmUpOgorICAgICAgICAoV2ViQ29yZTo6RXJyb3I+OjpyZWplY3QpOgorICAgICAgICAqIGJp bmRpbmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBi aW5kaW5ncy9qcy9KU1N1YnRsZUNyeXB0b0N1c3RvbS5jcHA6IFVwZGF0aW5nIGhlYWRlcnMuCisK IDIwMTUtMDYtMjIgIEFkYW0gQmVyZ2t2aXN0ICA8YWRhbS5iZXJna3Zpc3RAZXJpY3Nzb24uY29t PgogCiAgICAgICAgIFdlYlJUQzogTmF2aWdhdG9yLndlYmtpdEdldFVzZXJNZWRpYSgpIHJlcXVp cmVzIHRocmVlIGFyZ3VtZW50cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0 cy50eHQgYi9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAppbmRleCBhNWNkYjY4ZDJmYTZk YzJjMDhiZGRiZWRmMWE4OTgxZGU3ZTc5NjI4Li5kMThlNDIzY2I1NzIxNzkzYzdiOTg1NjRjMzUx ZTViZGY3NjU5OTdjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAor KysgYi9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtMTE1Myw3ICsxMTUzLDYgQEAg c2V0KFdlYkNvcmVfU09VUkNFUwogICAgIGJpbmRpbmdzL2pzL0pTTGF6eUV2ZW50TGlzdGVuZXIu Y3BwCiAgICAgYmluZGluZ3MvanMvSlNMb2NhdGlvbkN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy9q cy9KU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwCi0gICAgYmluZGluZ3MvanMvSlNNZWRpYURldmlj ZXNDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvanMvSlNNZWRpYVNvdXJjZVN0YXRlc0N1c3RvbS5j cHAKICAgICBiaW5kaW5ncy9qcy9KU01lZGlhU3RyZWFtQ2FwYWJpbGl0aWVzQ3VzdG9tLmNwcAog ICAgIGJpbmRpbmdzL2pzL0pTTWVzc2FnZUNoYW5uZWxDdXN0b20uY3BwCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5jcHAKaW5kZXggMDJm YmM4NjRjYmE2MzA4YmY4YWJiZjMyMjFkZWI4OTc5ZDU0NWQzNi4uNmE5NGJiMjQ2NTdhMjZlNzk2 MDUyNDNiZDFkOGM4MmY5NGMwY2VkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmNwcApAQCAtNjAsOCArNjAsMTMgQEAgRG9jdW1l bnQqIE1lZGlhRGV2aWNlczo6ZG9jdW1lbnQoKSBjb25zdAogICAgIHJldHVybiBkb3duY2FzdDxE b2N1bWVudD4oc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpKTsKIH0KIAotdm9pZCBNZWRpYURldmlj ZXM6OmdldFVzZXJNZWRpYShjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBSZXNvbHZlQ2FsbGJh Y2sgcmVzb2x2ZUNhbGxiYWNrLCBSZWplY3RDYWxsYmFjayByZWplY3RDYWxsYmFjaywgRXhjZXB0 aW9uQ29kZSYgZWMpIGNvbnN0Cit2b2lkIE1lZGlhRGV2aWNlczo6Z2V0VXNlck1lZGlhKGNvbnN0 IERpY3Rpb25hcnkmIG9wdGlvbnMsIFByb21pc2UmJiBwcm9taXNlLCBFeGNlcHRpb25Db2RlJiBl YykgY29uc3QKIHsKKyAgICBpZiAoIW9wdGlvbnMuaXNPYmplY3QoKSkgeworICAgICAgICBlYyA9 IFR5cGVFcnJvcjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIFVzZXJNZWRpYUNvbnRy b2xsZXIqIHVzZXJNZWRpYSA9IFVzZXJNZWRpYUNvbnRyb2xsZXI6OmZyb20oZG9jdW1lbnQoKSA/ IGRvY3VtZW50KCktPnBhZ2UoKSA6IG51bGxwdHIpOwogICAgIGlmICghdXNlck1lZGlhKSB7CiAg ICAgICAgIC8vIEZJWE1FOiBXZSBwcm9iYWJseSB3YW50IHRvIHJldHVybiBhIE1lZGlhU3RyZWFt RXJyb3IgaGVyZSB1c2luZyB0aGUgcmVqZWN0Q2FsbGJhY2ssIGFuZCBnZXQgcmlkIG9mZiB0aGUg RXhjZXB0aW9uQ29kZSBwYXJhbWV0ZXIuCkBAIC02OSw3ICs3NCw3IEBAIHZvaWQgTWVkaWFEZXZp Y2VzOjpnZXRVc2VyTWVkaWEoY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgUmVzb2x2ZUNhbGxi YWNrIHJlc29sCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBSZWZQdHI8VXNlck1lZGlh UmVxdWVzdD4gcmVxdWVzdCA9IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShkb2N1bWVudCgpLCB1 c2VyTWVkaWEsIG9wdGlvbnMsIFdURjo6bW92ZShyZXNvbHZlQ2FsbGJhY2spLCBXVEY6Om1vdmUo cmVqZWN0Q2FsbGJhY2spLCBlYyk7CisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVl c3QgPSBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoZG9jdW1lbnQoKSwgdXNlck1lZGlhLCBvcHRp b25zLCBXVEY6Om1vdmUocHJvbWlzZSksIGVjKTsKICAgICBpZiAoIXJlcXVlc3QpIHsKICAgICAg ICAgZWMgPSBOT1RfU1VQUE9SVEVEX0VSUjsKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaCBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmgKaW5kZXggNzRhNzgx YzY0ZTNjMmYwMTY2NGYxMWIxOTY0NDViZjkzNmM4Y2RmMC4uMzc1OGExMDgxMjNiZDNhMDdmOWNh YzNhZmY0NzQ1ZGQ5N2ZiZTY0YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9t ZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21l ZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5oCkBAIC0zNCw2ICszNCw3IEBACiAjaWYgRU5BQkxFKE1F RElBX1NUUkVBTSkKIAogI2luY2x1ZGUgIkNvbnRleHREZXN0cnVjdGlvbk9ic2VydmVyLmgiCisj aW5jbHVkZSAiSlNET01Qcm9taXNlLmgiCiAjaW5jbHVkZSAiU2NyaXB0V3JhcHBhYmxlLmgiCiAj aW5jbHVkZSA8ZnVuY3Rpb25hbD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgpAQCAtNTUs MTAgKzU2LDggQEAgcHVibGljOgogCiAgICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3Q7CiAK LSAgICB0eXBlZGVmIHN0ZDo6ZnVuY3Rpb248dm9pZChNZWRpYVN0cmVhbSYpPiBSZXNvbHZlQ2Fs bGJhY2s7Ci0gICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQoTmF2aWdhdG9yVXNlck1lZGlh RXJyb3ImKT4gUmVqZWN0Q2FsbGJhY2s7Ci0KLSAgICB2b2lkIGdldFVzZXJNZWRpYShjb25zdCBE aWN0aW9uYXJ5JiwgUmVzb2x2ZUNhbGxiYWNrLCBSZWplY3RDYWxsYmFjaywgRXhjZXB0aW9uQ29k ZSYpIGNvbnN0OworICAgIHR5cGVkZWYgRE9NUHJvbWlzZVdpdGhDYWxsYmFjazxSZWZQdHI8TWVk aWFTdHJlYW0+LCBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+PiBQcm9taXNlOworICAg IHZvaWQgZ2V0VXNlck1lZGlhKGNvbnN0IERpY3Rpb25hcnkmLCBQcm9taXNlJiYsIEV4Y2VwdGlv bkNvZGUmKSBjb25zdDsKIAogcHJpdmF0ZToKICAgICBleHBsaWNpdCBNZWRpYURldmljZXMoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaWRsIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9t ZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaWRsCmluZGV4IDUzM2YxMGY3OGIwYTA5ZWM4OTVjYzg1 YTEwZjFjZjJhYzRhMzczOGYuLjZiMGI4NDM0OTliYWEyYWNiMmY0NWM2YmU0NzAzNWY1ZTA1ZWM4 ZDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFE ZXZpY2VzLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlh RGV2aWNlcy5pZGwKQEAgLTMyLDUgKzMyLDUgQEAKICAgICBOb0ludGVyZmFjZU9iamVjdCwKICAg ICBDb25kaXRpb25hbD1NRURJQV9TVFJFQU0KIF0gaW50ZXJmYWNlIE1lZGlhRGV2aWNlcyB7Ci0g ICAgW0N1c3RvbSwgUmFpc2VzRXhjZXB0aW9uXSBQcm9taXNlIGdldFVzZXJNZWRpYShEaWN0aW9u YXJ5IG9wdGlvbnMpOworICAgIFtSYWlzZXNFeGNlcHRpb25dIFByb21pc2UgZ2V0VXNlck1lZGlh KERpY3Rpb25hcnkgb3B0aW9ucyk7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy9tZWRpYXN0cmVhbS9OYXZpZ2F0b3JVc2VyTWVkaWEuY3BwIGIvU291cmNlL1dlYkNvcmUv TW9kdWxlcy9tZWRpYXN0cmVhbS9OYXZpZ2F0b3JVc2VyTWVkaWEuY3BwCmluZGV4IDE5YWJlNGRl NGU4NjY4MmM1MGRlZDk1YmVlMTFiMGJkMjY2ZDBlODIuLjk2NTA3NDdjNWU5MGQwNGZiZWM0ODky MWVkNmMxNDUyZGNlMGQwOTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVk aWFzdHJlYW0vTmF2aWdhdG9yVXNlck1lZGlhLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL21lZGlhc3RyZWFtL05hdmlnYXRvclVzZXJNZWRpYS5jcHAKQEAgLTI5LDcgKzI5LDkgQEAK ICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNs dWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIk1lZGlhU3RyZWFtLmgiCiAjaW5jbHVkZSAiTmF2aWdh dG9yLmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IuaCIKICNpbmNsdWRlICJO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yVXNl ck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgpAQCAtNTksNyArNjEs MjkgQEAgdm9pZCBOYXZpZ2F0b3JVc2VyTWVkaWE6OndlYmtpdEdldFVzZXJNZWRpYShOYXZpZ2F0 b3IqIG5hdmlnYXRvciwgY29uc3QgRGljdGlvbmEKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAot ICAgIFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gVXNlck1lZGlhUmVxdWVzdDo6 Y3JlYXRlKG5hdmlnYXRvci0+ZnJhbWUoKS0+ZG9jdW1lbnQoKSwgdXNlck1lZGlhLCBvcHRpb25z LCBzdWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGVjKTsKKyAgICBBU1NFUlQoc3VjY2Vz c0NhbGxiYWNrKTsKKyAgICBhdXRvIHJlc29sdmVDYWxsYmFjayA9IFtzdWNjZXNzQ2FsbGJhY2ss IG5hdmlnYXRvcl0oY29uc3QgUmVmUHRyPE1lZGlhU3RyZWFtPiYgc3RyZWFtKSBtdXRhYmxlIHsK KyAgICAgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCA9IG5hdmlnYXRvci0+ZnJh bWUoKS0+ZG9jdW1lbnQoKTsKKyAgICAgICAgQVNTRVJUKGNvbnRleHQpOworCisgICAgICAgIFJl ZlB0cjxNZWRpYVN0cmVhbT4gbWVkaWFTdHJlYW0gPSBzdHJlYW07CisgICAgICAgIGNvbnRleHQt PnBvc3RUYXNrKFtzdWNjZXNzQ2FsbGJhY2ssIG1lZGlhU3RyZWFtXShTY3JpcHRFeGVjdXRpb25D b250ZXh0JikgeworICAgICAgICAgICAgc3VjY2Vzc0NhbGxiYWNrLT5oYW5kbGVFdmVudChtZWRp YVN0cmVhbS5nZXQoKSk7CisgICAgICAgIH0pOworICAgIH07CisgICAgYXV0byByZWplY3RDYWxs YmFjayA9IFtlcnJvckNhbGxiYWNrLCBuYXZpZ2F0b3JdKGNvbnN0IFJlZlB0cjxOYXZpZ2F0b3JV c2VyTWVkaWFFcnJvcj4mIGVycm9yKSBtdXRhYmxlIHsKKyAgICAgICAgU2NyaXB0RXhlY3V0aW9u Q29udGV4dCogY29udGV4dCA9IG5hdmlnYXRvci0+ZnJhbWUoKS0+ZG9jdW1lbnQoKTsKKyAgICAg ICAgQVNTRVJUKGNvbnRleHQpOworCisgICAgICAgIGlmIChlcnJvckNhbGxiYWNrKSB7CisgICAg ICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGV2ZW50RXJyb3IgPSBlcnJv cjsKKyAgICAgICAgICAgIGNvbnRleHQtPnBvc3RUYXNrKFtlcnJvckNhbGxiYWNrLCBldmVudEVy cm9yXShTY3JpcHRFeGVjdXRpb25Db250ZXh0JikgeworICAgICAgICAgICAgICAgIGVycm9yQ2Fs bGJhY2stPmhhbmRsZUV2ZW50KGV2ZW50RXJyb3IuZ2V0KCkpOworICAgICAgICAgICAgfSk7Cisg ICAgICAgIH0KKyAgICB9OworCisgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHJlcXVlc3Qg PSBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUobmF2aWdhdG9yLT5mcmFtZSgpLT5kb2N1bWVudCgp LCB1c2VyTWVkaWEsIG9wdGlvbnMsIE1lZGlhRGV2aWNlczo6UHJvbWlzZShXVEY6Om1vdmUocmVz b2x2ZUNhbGxiYWNrKSwgV1RGOjptb3ZlKHJlamVjdENhbGxiYWNrKSksIGVjKTsKICAgICBpZiAo IXJlcXVlc3QpIHsKICAgICAgICAgZWMgPSBOT1RfU1VQUE9SVEVEX0VSUjsKICAgICAgICAgcmV0 dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2Vy TWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vVXNl ck1lZGlhUmVxdWVzdC5jcHAKaW5kZXggMDU5NzQ3MDU1MzNhMDZkZWQ3MzZlODdmZTllNjgwNmMy ZTgyMjZiNy4uOWMxNWVkMzRmODM0ODBjOTE4MDIxYjk3MTZlZWI5NDAxYTA5ZGNkZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJl cXVlc3QuY3BwCkBAIC01Myw2ICs1MywxMSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKKy8v IERlY2xhcmF0aW9ucyBmb3IgcmVzb2x2aW5nL3JlamVjdGluZyBwcm9taXNlcworSlNDOjpKU1Zh bHVlIHRvSlMoSlNDOjpFeGVjU3RhdGUqLCBKU0RPTUdsb2JhbE9iamVjdCosIE1lZGlhU3RyZWFt Kik7CitKU0M6OkpTVmFsdWUgdG9KUyhKU0M6OkV4ZWNTdGF0ZSosIEpTRE9NR2xvYmFsT2JqZWN0 KiwgTmF2aWdhdG9yVXNlck1lZGlhRXJyb3IqKTsKKworCiBzdGF0aWMgUGFzc1JlZlB0cjxNZWRp YUNvbnN0cmFpbnRzPiBwYXJzZU9wdGlvbnMoY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgY29u c3QgU3RyaW5nJiBtZWRpYVR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQogewogICAgIFJlZlB0cjxN ZWRpYUNvbnN0cmFpbnRzPiBjb25zdHJhaW50czsKQEAgLTcxLDM2ICs3Niw4IEBAIHN0YXRpYyBQ YXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+IHBhcnNlT3B0aW9ucyhjb25zdCBEaWN0aW9uYXJ5 JiBvcHRpb25zLCBjb25zCiAgICAgcmV0dXJuIGNvbnN0cmFpbnRzLnJlbGVhc2UoKTsKIH0KIAot UmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDb250cm9sbGVyKiBjb250cm9sbGVy LCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJNZWRp YVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPE5hdmlnYXRvclVz ZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssIEV4Y2VwdGlvbkNvZGUmIGVjKQot ewotICAgIEFTU0VSVChzdWNjZXNzQ2FsbGJhY2spOwotCi0gICAgYXV0byByZXNvbHZlQ2FsbGJh Y2sgPSBbc3VjY2Vzc0NhbGxiYWNrLCBjb250ZXh0XShNZWRpYVN0cmVhbSYgc3RyZWFtKSBtdXRh YmxlIHsKLSAgICAgICAgQVNTRVJUKGNvbnRleHQpOwotCi0gICAgICAgIFJlZlB0cjxNZWRpYVN0 cmVhbT4gbWVkaWFTdHJlYW0gPSAmc3RyZWFtOwotICAgICAgICBjb250ZXh0LT5wb3N0VGFzayhb c3VjY2Vzc0NhbGxiYWNrLCBtZWRpYVN0cmVhbV0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCYpIHsK LSAgICAgICAgICAgIHN1Y2Nlc3NDYWxsYmFjay0+aGFuZGxlRXZlbnQobWVkaWFTdHJlYW0uZ2V0 KCkpOwotICAgICAgICB9KTsKLSAgICB9OwotICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBbZXJy b3JDYWxsYmFjaywgY29udGV4dF0oTmF2aWdhdG9yVXNlck1lZGlhRXJyb3ImIGVycm9yKSBtdXRh YmxlIHsKLSAgICAgICAgQVNTRVJUKGNvbnRleHQpOwotCi0gICAgICAgIGlmIChlcnJvckNhbGxi YWNrKSB7Ci0gICAgICAgICAgICBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJyb3I+IGV2ZW50 RXJyb3IgPSAmZXJyb3I7Ci0gICAgICAgICAgICBjb250ZXh0LT5wb3N0VGFzayhbZXJyb3JDYWxs YmFjaywgZXZlbnRFcnJvcl0oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCYpIHsKLSAgICAgICAgICAg ICAgICBlcnJvckNhbGxiYWNrLT5oYW5kbGVFdmVudChldmVudEVycm9yLmdldCgpKTsKLSAgICAg ICAgICAgIH0pOwotICAgICAgICB9Ci0gICAgfTsKLQotICAgIHJldHVybiBVc2VyTWVkaWFSZXF1 ZXN0OjpjcmVhdGUoY29udGV4dCwgY29udHJvbGxlciwgb3B0aW9ucywgV1RGOjptb3ZlKHJlc29s dmVDYWxsYmFjayksIFdURjo6bW92ZShyZWplY3RDYWxsYmFjayksIGVjKTsKLX0KLQotUmVmUHRy PFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0ZShTY3JpcHRFeGVjdXRp b25Db250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDb250cm9sbGVyKiBjb250cm9sbGVyLCBjb25z dCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBNZWRpYURldmljZXM6OlJlc29sdmVDYWxsYmFjayYmIHJl c29sdmVDYWxsYmFjaywgTWVkaWFEZXZpY2VzOjpSZWplY3RDYWxsYmFjayYmIHJlamVjdENhbGxi YWNrLCBFeGNlcHRpb25Db2RlJiBlYykKK1JlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBVc2VyTWVk aWFSZXF1ZXN0OjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgVXNlck1l ZGlhQ29udHJvbGxlciogY29udHJvbGxlciwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgTWVk aWFEZXZpY2VzOjpQcm9taXNlJiYgcHJvbWlzZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAg QVNTRVJUKHJlc29sdmVDYWxsYmFjayAmJiByZWplY3RDYWxsYmFjayk7Ci0KICAgICBSZWZQdHI8 TWVkaWFDb25zdHJhaW50cz4gYXVkaW9Db25zdHJhaW50cyA9IHBhcnNlT3B0aW9ucyhvcHRpb25z LCBBdG9taWNTdHJpbmcoImF1ZGlvIiwgQXRvbWljU3RyaW5nOjpDb25zdHJ1Y3RGcm9tTGl0ZXJh bCksIGVjKTsKICAgICBpZiAoZWMpCiAgICAgICAgIHJldHVybiBudWxscHRyOwpAQCAtMTEyLDE2 ICs4OSwxNSBAQCBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gVXNlck1lZGlhUmVxdWVzdDo6Y3Jl YXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleAogICAgIGlmICghYXVkaW9Db25zdHJh aW50cyAmJiAhdmlkZW9Db25zdHJhaW50cykKICAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAKLSAg ICByZXR1cm4gYWRvcHRSZWYoKm5ldyBVc2VyTWVkaWFSZXF1ZXN0KGNvbnRleHQsIGNvbnRyb2xs ZXIsIGF1ZGlvQ29uc3RyYWludHMucmVsZWFzZSgpLCB2aWRlb0NvbnN0cmFpbnRzLnJlbGVhc2Uo KSwgV1RGOjptb3ZlKHJlc29sdmVDYWxsYmFjayksIFdURjo6bW92ZShyZWplY3RDYWxsYmFjaykp KTsKKyAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBVc2VyTWVkaWFSZXF1ZXN0KGNvbnRleHQsIGNv bnRyb2xsZXIsIGF1ZGlvQ29uc3RyYWludHMucmVsZWFzZSgpLCB2aWRlb0NvbnN0cmFpbnRzLnJl bGVhc2UoKSwgV1RGOjptb3ZlKHByb21pc2UpKSk7CiB9CiAKLVVzZXJNZWRpYVJlcXVlc3Q6OlVz ZXJNZWRpYVJlcXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgVXNlck1lZGlh Q29udHJvbGxlciogY29udHJvbGxlciwgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFpbnRzPiBhdWRp b0NvbnN0cmFpbnRzLCBQYXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+IHZpZGVvQ29uc3RyYWlu dHMsIE1lZGlhRGV2aWNlczo6UmVzb2x2ZUNhbGxiYWNrJiYgcmVzb2x2ZUNhbGxiYWNrLCBNZWRp YURldmljZXM6OlJlamVjdENhbGxiYWNrJiYgcmVqZWN0Q2FsbGJhY2spCitVc2VyTWVkaWFSZXF1 ZXN0OjpVc2VyTWVkaWFSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFVz ZXJNZWRpYUNvbnRyb2xsZXIqIGNvbnRyb2xsZXIsIFBhc3NSZWZQdHI8TWVkaWFDb25zdHJhaW50 cz4gYXVkaW9Db25zdHJhaW50cywgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFpbnRzPiB2aWRlb0Nv bnN0cmFpbnRzLCBNZWRpYURldmljZXM6OlByb21pc2UmJiBwcm9taXNlKQogICAgIDogQ29udGV4 dERlc3RydWN0aW9uT2JzZXJ2ZXIoY29udGV4dCkKICAgICAsIG1fYXVkaW9Db25zdHJhaW50cyhh dWRpb0NvbnN0cmFpbnRzKQogICAgICwgbV92aWRlb0NvbnN0cmFpbnRzKHZpZGVvQ29uc3RyYWlu dHMpCiAgICAgLCBtX2NvbnRyb2xsZXIoY29udHJvbGxlcikKLSAgICAsIG1fcmVzb2x2ZUNhbGxi YWNrKFdURjo6bW92ZShyZXNvbHZlQ2FsbGJhY2spKQotICAgICwgbV9yZWplY3RDYWxsYmFjayhX VEY6Om1vdmUocmVqZWN0Q2FsbGJhY2spKQorICAgICwgbV9wcm9taXNlKFdURjo6bW92ZShwcm9t aXNlKSkKIHsKIH0KIApAQCAtMTg2LDcgKzE2Miw3IEBAIHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6 ZGlkQ3JlYXRlU3RyZWFtKFBhc3NSZWZQdHI8TWVkaWFTdHJlYW1Qcml2YXRlPiBwcml2YXRlU3Ry CiAgICAgZm9yIChhdXRvJiB0cmFjayA6IHN0cmVhbS0+Z2V0VmlkZW9UcmFja3MoKSkKICAgICAg ICAgdHJhY2stPmFwcGx5Q29uc3RyYWludHMobV92aWRlb0NvbnN0cmFpbnRzKTsKIAotICAgIG1f cmVzb2x2ZUNhbGxiYWNrKCpzdHJlYW0pOworICAgIG1fcHJvbWlzZS5yZXNvbHZlKHN0cmVhbSk7 CiB9CiAKIHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoQ29u c3RyYWludHNFcnJvcihjb25zdCBTdHJpbmcmIGNvbnN0cmFpbnROYW1lKQpAQCAtMTk1LDcgKzE3 MSw3IEBAIHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoQ29u c3RyYWludHNFcnJvcihjb25zdCBTdHJpbmcmIGNvCiAgICAgaWYgKCFtX3NjcmlwdEV4ZWN1dGlv bkNvbnRleHQpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fcmVqZWN0Q2FsbGJhY2soTmF2aWdh dG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y29uc3Ry YWludE5vdFNhdGlzZmllZEVycm9yTmFtZSgpLCBjb25zdHJhaW50TmFtZSkuZ2V0KCkpOworICAg IG1fcHJvbWlzZS5yZWplY3QoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0 b3JVc2VyTWVkaWFFcnJvcjo6Y29uc3RyYWludE5vdFNhdGlzZmllZEVycm9yTmFtZSgpLCBjb25z dHJhaW50TmFtZSkpOwogfQogCiB2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OmZhaWxlZFRvQ3JlYXRl U3RyZWFtV2l0aFBlcm1pc3Npb25FcnJvcigpCkBAIC0yMDQsNyArMTgwLDcgQEAgdm9pZCBVc2Vy TWVkaWFSZXF1ZXN0OjpmYWlsZWRUb0NyZWF0ZVN0cmVhbVdpdGhQZXJtaXNzaW9uRXJyb3IoKQog ICAgICAgICByZXR1cm47CiAKICAgICAvLyBGSVhNRTogUmVwbGFjZSBOYXZpZ2F0b3JVc2VyTWVk aWFFcnJvciB3aXRoIE1lZGlhU3RyZWFtRXJyb3IgKHNlZSBidWcgMTQzMzM1KQotICAgIG1fcmVq ZWN0Q2FsbGJhY2soTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OmNyZWF0ZShOYXZpZ2F0b3JVc2Vy TWVkaWFFcnJvcjo6cGVybWlzc2lvbkRlbmllZEVycm9yTmFtZSgpLCBlbXB0eVN0cmluZygpKSk7 CisgICAgbV9wcm9taXNlLnJlamVjdChOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5h dmlnYXRvclVzZXJNZWRpYUVycm9yOjpwZXJtaXNzaW9uRGVuaWVkRXJyb3JOYW1lKCksIGVtcHR5 U3RyaW5nKCkpKTsKIH0KIAogdm9pZCBVc2VyTWVkaWFSZXF1ZXN0Ojpjb250ZXh0RGVzdHJveWVk KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vVXNlck1l ZGlhUmVxdWVzdC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVk aWFSZXF1ZXN0LmgKaW5kZXggZjM1MzlkYjI3OWJhY2Y1MDVhNzNiYzRhNmVmNjM1MzkwYjZhODBj Yy4uYTkzZjJiZGQ4MmE5Njg3ZjVhMDg5ODY1OGIzYTBkZmJiZGVmYWVlMSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmgKKysr IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFSZXF1ZXN0LmgK QEAgLTU4LDggKzU4LDcgQEAgdHlwZWRlZiBpbnQgRXhjZXB0aW9uQ29kZTsKIAogY2xhc3MgVXNl ck1lZGlhUmVxdWVzdCA6IHB1YmxpYyBNZWRpYVN0cmVhbUNyZWF0aW9uQ2xpZW50LCBwdWJsaWMg Q29udGV4dERlc3RydWN0aW9uT2JzZXJ2ZXIgewogcHVibGljOgotICAgIHN0YXRpYyBSZWZQdHI8 VXNlck1lZGlhUmVxdWVzdD4gY3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBVc2VyTWVk aWFDb250cm9sbGVyKiwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgUGFzc1JlZlB0cjxOYXZp Z2F0b3JVc2VyTWVkaWFTdWNjZXNzQ2FsbGJhY2s+LCBQYXNzUmVmUHRyPE5hdmlnYXRvclVzZXJN ZWRpYUVycm9yQ2FsbGJhY2s+LCBFeGNlcHRpb25Db2RlJik7Ci0gICAgc3RhdGljIFJlZlB0cjxV c2VyTWVkaWFSZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFVzZXJNZWRp YUNvbnRyb2xsZXIqLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBNZWRpYURldmljZXM6OlJl c29sdmVDYWxsYmFjayYmLCBNZWRpYURldmljZXM6OlJlamVjdENhbGxiYWNrJiYsIEV4Y2VwdGlv bkNvZGUmKTsKKyAgICBzdGF0aWMgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IGNyZWF0ZShTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiwgVXNlck1lZGlhQ29udHJvbGxlciosIGNvbnN0IERpY3Rpb25h cnkmIG9wdGlvbnMsIE1lZGlhRGV2aWNlczo6UHJvbWlzZSYmLCBFeGNlcHRpb25Db2RlJik7CiAg ICAgflVzZXJNZWRpYVJlcXVlc3QoKTsKIAogICAgIFdFQkNPUkVfRVhQT1JUIFNlY3VyaXR5T3Jp Z2luKiBzZWN1cml0eU9yaWdpbigpIGNvbnN0OwpAQCAtNzIsNyArNzEsNyBAQCBwdWJsaWM6CiAg ICAgYm9vbCByZXF1aXJlc1ZpZGVvKCkgY29uc3QgeyByZXR1cm4gbV92aWRlb0NvbnN0cmFpbnRz OyB9CiAKIHByaXZhdGU6Ci0gICAgVXNlck1lZGlhUmVxdWVzdChTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgVXNlck1lZGlhQ29udHJvbGxlciosIFBhc3NSZWZQdHI8TWVkaWFDb25zdHJhaW50cz4g YXVkaW9Db25zdHJhaW50cywgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFpbnRzPiB2aWRlb0NvbnN0 cmFpbnRzLCBNZWRpYURldmljZXM6OlJlc29sdmVDYWxsYmFjayYmLCBNZWRpYURldmljZXM6OlJl amVjdENhbGxiYWNrJiYpOworICAgIFVzZXJNZWRpYVJlcXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCosIFVzZXJNZWRpYUNvbnRyb2xsZXIqLCBQYXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+ IGF1ZGlvQ29uc3RyYWludHMsIFBhc3NSZWZQdHI8TWVkaWFDb25zdHJhaW50cz4gdmlkZW9Db25z dHJhaW50cywgTWVkaWFEZXZpY2VzOjpQcm9taXNlJiYpOwogCiAgICAgLy8gTWVkaWFTdHJlYW1D cmVhdGlvbkNsaWVudAogICAgIHZpcnR1YWwgdm9pZCBjb25zdHJhaW50c1ZhbGlkYXRlZCgpIG92 ZXJyaWRlIGZpbmFsOwpAQCAtODksOCArODgsNyBAQCBwcml2YXRlOgogCiAgICAgVXNlck1lZGlh Q29udHJvbGxlciogbV9jb250cm9sbGVyOwogCi0gICAgTWVkaWFEZXZpY2VzOjpSZXNvbHZlQ2Fs bGJhY2sgbV9yZXNvbHZlQ2FsbGJhY2s7Ci0gICAgTWVkaWFEZXZpY2VzOjpSZWplY3RDYWxsYmFj ayBtX3JlamVjdENhbGxiYWNrOworICAgIE1lZGlhRGV2aWNlczo6UHJvbWlzZSBtX3Byb21pc2U7 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggMTliNDVmYzY0ZjU2Nzk3YTFhMTEz MjUxZjAwNjZlMmIxMTBiMjU3ZC4uZWQ5OTc1Njc0MmFmNjNkZDVhODFkMWJmNjQ0ZTM2YTk0ZThk NTBmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagpAQCAtMjIwNSw3ICsyMjA1LDYgQEAKIAkJNURGRThGNTYwRDE2NDc3QjAwNzZFOTM3 IC8qIFNjaGVkdWxlZEFjdGlvbi5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBCQ0EzNzhCQTBEMTVGNjQyMDBCNzkzRDYgLyogU2NoZWR1bGVkQWN0aW9u LmNwcCAqLzsgfTsKIAkJNURGRThGNTcwRDE2NDc3QzAwNzZFOTM3IC8qIFNjaGVkdWxlZEFjdGlv bi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQkNBMzc4 QkIwRDE1RjY0MjAwQjc5M0Q2IC8qIFNjaGVkdWxlZEFjdGlvbi5oICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCTVERkVCQUI3MTg1OTJCNkQwMEM3NUJF QiAvKiBXZWJLaXRBdmFpbGFiaWxpdHkuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDVERkVCQUI2MTg1OTJCNkQwMEM3NUJFQiAvKiBXZWJLaXRBdmFpbGFi aWxpdHkuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9Owot CQk1RUE3MjVEMTFBQ0FCRDM4MDBFQUQxN0IgLyogSlNNZWRpYURldmljZXNDdXN0b20uY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNUVBNzI1RDAxQUNB QkQyNzAwRUFEMTdCIC8qIEpTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcCAqLzsgfTsKIAkJNUVBNzI1 RDIxQUNBQkQ0NzAwRUFEMTdCIC8qIE1lZGlhRGV2aWNlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1RUE3MjVDRDFBQ0FCQ0Q5MDBFQUQxN0IgLyog TWVkaWFEZXZpY2VzLmNwcCAqLzsgfTsKIAkJNUVBNzI1RDMxQUNBQkQ0NzAwRUFEMTdCIC8qIE1l ZGlhRGV2aWNlcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNUVBNzI1Q0UxQUNBQkNEOTAwRUFEMTdCIC8qIE1lZGlhRGV2aWNlcy5oICovOyB9OwogCQk1 RUE3MjVENTFBQ0FCRDU3MDBFQUQxN0IgLyogTmF2aWdhdG9yTWVkaWFEZXZpY2VzLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDVFQTcyNUNBMUFDQUJD QjUwMEVBRDE3QiAvKiBOYXZpZ2F0b3JNZWRpYURldmljZXMuY3BwICovOyB9OwpAQCAtOTQ2NCw3 ICs5NDYzLDYgQEAKIAkJNUVBNzI1Q0QxQUNBQkNEOTAwRUFEMTdCIC8qIE1lZGlhRGV2aWNlcy5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBNZWRpYURldmljZXMuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1RUE3MjVDRTFBQ0FCQ0Q5MDBFQUQxN0Ig LyogTWVkaWFEZXZpY2VzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE1lZGlh RGV2aWNlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1RUE3MjVDRjFBQ0FCQ0Q5 MDBFQUQxN0IgLyogTWVkaWFEZXZpY2VzLmlkbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBNZWRp YURldmljZXMuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwotCQk1RUE3MjVEMDFBQ0FC RDI3MDBFQUQxN0IgLyogSlNNZWRpYURldmljZXNDdXN0b20uY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gSlNNZWRpYURldmljZXNDdXN0b20uY3BwOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk1RjJEQkJFNzE3OEUzMzJEMDAxNDE0ODYgLyogQ2VydGlmaWNh dGVJbmZvTWFjLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gQ2Vy dGlmaWNhdGVJbmZvTWFjLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1RjJEQkJF ODE3OEUzMzY5MDAxNDE0ODYgLyogQ2VydGlmaWNhdGVJbmZvLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IENlcnRpZmljYXRlSW5mby5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk1RkM3REMyNkNGRTI1NjMyMDBCODVBRTUgLyogSlNFdmVudFRhcmdldC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNFdmVudFRhcmdldC5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtMjE0MDYsNyArMjE0MDQsNiBAQAogCQkJCUE3RDAzMThEMEU5 MzU0MDMwMEUyNEFDRCAvKiBKU0ltYWdlRGF0YUN1c3RvbS5jcHAgKi8sCiAJCQkJN0E3NEVDQkMx MDE4MzlEQTAwQkY5MzlFIC8qIEpTSW5zcGVjdG9yRnJvbnRlbmRIb3N0Q3VzdG9tLmNwcCAqLywK IAkJCQlCQ0UxQzQzRjBEOTgzMEY0MDAzQjAyRjIgLyogSlNMb2NhdGlvbkN1c3RvbS5jcHAgKi8s Ci0JCQkJNUVBNzI1RDAxQUNBQkQyNzAwRUFEMTdCIC8qIEpTTWVkaWFEZXZpY2VzQ3VzdG9tLmNw cCAqLywKIAkJCQlBRDcyNkZFNzE2RDlGMjA0MDAzQTRFNkQgLyogSlNNZWRpYUxpc3RDdXN0b20u aCAqLywKIAkJCQkwN0M1OUI2RDE3Rjc5NEY2MDAwRkJDQkIgLyogSlNNZWRpYVNvdXJjZVN0YXRl c0N1c3RvbS5jcHAgKi8sCiAJCQkJMDcwNTg1MTYxN0ZCNDBFOTAwNUYyQkNCIC8qIEpTTWVkaWFT dHJlYW1DYXBhYmlsaXRpZXNDdXN0b20uY3BwICovLApAQCAtMjg5ODQsNyArMjg5ODEsNiBAQAog CQkJCThGQUM3NzREMTE5ODcyQ0IwMDE1QUU5NCAvKiBKU01haW5UaHJlYWRFeGVjU3RhdGUuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJQ0QyN0Y2RTUxNDU3Njg1QTAwNzgyMDdEIC8qIEpTTWVkaWFD b250cm9sbGVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUNEQUI2RDJEMTdDODE0RUUwMEM2MEIz NCAvKiBKU01lZGlhQ29udHJvbHNIb3N0LmNwcCBpbiBTb3VyY2VzICovLAotCQkJCTVFQTcyNUQx MUFDQUJEMzgwMEVBRDE3QiAvKiBKU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgaW4gU291cmNlcyAq LywKIAkJCQlGRDIzQTEyNTEzRjVGQTU5MDBGNjcwMDEgLyogSlNNZWRpYUVsZW1lbnRBdWRpb1Nv dXJjZU5vZGUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTQ0NjE0MTgwQ0Q2ODI2OTAwRkFEQTc1 IC8qIEpTTWVkaWFFcnJvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlDREE5OERBMzE2MDE0NjQx MDBGRUEzQjEgLyogSlNNZWRpYUtleUVycm9yLmNwcCBpbiBTb3VyY2VzICovLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01Qcm9taXNlLmggYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU0RPTVByb21pc2UuaAppbmRleCAwOGRiMjljYjdkYmFkYTUyNzYw ZGJlYTQxNzU2ZTc4ZTIwM2Y3NjllLi4xZmNlMWJiNjZiYzIxYzIyMjcxYzE0ZDNkNzgyYTNhZDlm NDlmNjFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTVByb21p c2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTVByb21pc2UuaApAQCAt MjgsMTEgKzI4LDEwIEBACiAKICNpZiBFTkFCTEUoUFJPTUlTRVMpCiAKLSNpbmNsdWRlICJKU0Ny eXB0b0tleS5oIgotI2luY2x1ZGUgIkpTQ3J5cHRvS2V5UGFpci5oIgogI2luY2x1ZGUgIkpTRE9N QmluZGluZy5oIgogI2luY2x1ZGUgPGhlYXAvU3Ryb25nSW5saW5lcy5oPgogI2luY2x1ZGUgPHJ1 bnRpbWUvSlNQcm9taXNlRGVmZXJyZWQuaD4KKyNpbmNsdWRlIDx3dGYvT3B0aW9uYWwuaD4KIAog bmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC04Niw2ICs4NSwzNCBAQCBwcml2YXRlOgogICAgIERl ZmVycmVkV3JhcHBlciBtX3dyYXBwZXI7CiB9OwogCit0ZW1wbGF0ZSA8dHlwZW5hbWUgVmFsdWUs IHR5cGVuYW1lIEVycm9yPgorY2xhc3MgRE9NUHJvbWlzZVdpdGhDYWxsYmFjayB7CitwdWJsaWM6 CisgICAgRE9NUHJvbWlzZVdpdGhDYWxsYmFjayhEZWZlcnJlZFdyYXBwZXImJiB3cmFwcGVyKSA6 IG1fd3JhcHBlcihXVEY6Om1vdmUod3JhcHBlcikpIHsgfQorICAgIERPTVByb21pc2VXaXRoQ2Fs bGJhY2soc3RkOjpmdW5jdGlvbjx2b2lkKGNvbnN0IFZhbHVlJik+JiYgcmVzb2x2ZSwgc3RkOjpm dW5jdGlvbjx2b2lkKGNvbnN0IEVycm9yJik+JiYgcmVqZWN0KQorICAgICAgICA6IG1fcmVzb2x2 ZUNhbGxiYWNrKFdURjo6bW92ZShyZXNvbHZlKSkKKyAgICAgICAgLCBtX3JlamVjdENhbGxiYWNr KFdURjo6bW92ZShyZWplY3QpKQorICAgIHsKKyAgICAgICAgQVNTRVJUKG1fcmVzb2x2ZUNhbGxi YWNrKTsKKyAgICAgICAgQVNTRVJUKG1fcmVqZWN0Q2FsbGJhY2spOworICAgIH0KKyAgICBET01Q cm9taXNlV2l0aENhbGxiYWNrKERPTVByb21pc2VXaXRoQ2FsbGJhY2smJiBwcm9taXNlKQorICAg ICAgICA6IG1fd3JhcHBlcihXVEY6Om1vdmUocHJvbWlzZS5tX3dyYXBwZXIpKQorICAgICAgICAs IG1fcmVzb2x2ZUNhbGxiYWNrKFdURjo6bW92ZShwcm9taXNlLm1fcmVzb2x2ZUNhbGxiYWNrKSkK KyAgICAgICAgLCBtX3JlamVjdENhbGxiYWNrKFdURjo6bW92ZShwcm9taXNlLm1fcmVqZWN0Q2Fs bGJhY2spKSB7IH0KKworICAgIERPTVByb21pc2VXaXRoQ2FsbGJhY2soY29uc3QgRE9NUHJvbWlz ZVdpdGhDYWxsYmFjayYpPSBkZWxldGU7CisgICAgRE9NUHJvbWlzZVdpdGhDYWxsYmFjayYgb3Bl cmF0b3I9KERPTVByb21pc2VXaXRoQ2FsbGJhY2sgY29uc3QmKSA9IGRlbGV0ZTsKKworICAgIHZv aWQgcmVzb2x2ZShjb25zdCBWYWx1ZSYpOworICAgIHZvaWQgcmVqZWN0KGNvbnN0IEVycm9yJik7 CisKK3ByaXZhdGU6CisgICAgT3B0aW9uYWw8RE9NUHJvbWlzZTxWYWx1ZSwgRXJyb3I+PiBtX3dy YXBwZXI7CisgICAgc3RkOjpmdW5jdGlvbjx2b2lkKGNvbnN0IFZhbHVlJik+IG1fcmVzb2x2ZUNh bGxiYWNrOworICAgIHN0ZDo6ZnVuY3Rpb248dm9pZChjb25zdCBFcnJvciYpPiBtX3JlamVjdENh bGxiYWNrOworfTsKKwogdGVtcGxhdGU8Y2xhc3MgUmVzb2x2ZVJlc3VsdFR5cGU+CiBpbmxpbmUg dm9pZCBEZWZlcnJlZFdyYXBwZXI6OnJlc29sdmUoY29uc3QgUmVzb2x2ZVJlc3VsdFR5cGUmIHJl c3VsdCkKIHsKQEAgLTE5Niw2ICsyMjMsMjggQEAgaW5saW5lIHZvaWQgRGVmZXJyZWRXcmFwcGVy OjpyZWplY3Q8U3RyaW5nPihjb25zdCBTdHJpbmcmIHJlc3VsdCkKICAgICByZWplY3QoKmV4ZWMs IGpzU3RyaW5nKGV4ZWMsIHJlc3VsdCkpOwogfQogCit0ZW1wbGF0ZSA8dHlwZW5hbWUgVmFsdWUs IHR5cGVuYW1lIEVycm9yPgordm9pZCBET01Qcm9taXNlV2l0aENhbGxiYWNrPFZhbHVlLCBFcnJv cj46OnJlc29sdmUoY29uc3QgVmFsdWUmIHZhbHVlKQoreworICAgIGlmIChtX3Jlc29sdmVDYWxs YmFjaykgeworICAgICAgICBtX3Jlc29sdmVDYWxsYmFjayh2YWx1ZSk7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisgICAgQVNTRVJUKG1fd3JhcHBlcik7CisgICAgbV93cmFwcGVyLnZhbHVlKCku cmVzb2x2ZSh2YWx1ZSk7Cit9CisKK3RlbXBsYXRlIDx0eXBlbmFtZSBWYWx1ZSwgdHlwZW5hbWUg RXJyb3I+Cit2b2lkIERPTVByb21pc2VXaXRoQ2FsbGJhY2s8VmFsdWUsIEVycm9yPjo6cmVqZWN0 KGNvbnN0IEVycm9yJiBlcnJvcikKK3sKKyAgICBpZiAobV9yZWplY3RDYWxsYmFjaykgeworICAg ICAgICBtX3JlamVjdENhbGxiYWNrKGVycm9yKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAg ICBBU1NFUlQobV93cmFwcGVyKTsKKyAgICBtX3dyYXBwZXIudmFsdWUoKS5yZWplY3QoZXJyb3Ip OworfQorCiB9CiAKICNlbmRpZiAvLyBFTkFCTEUoUFJPTUlTRVMpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAKZGVsZXRlZCBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDZiZDJhNzJjYjkxMGQxYTU5YmM3NmIzOWE0MWEwMmMxOTY1ZjU1 YTQuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwCisrKyAvZGV2L251 bGwKQEAgLTEsODQgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBFcmljc3NvbiBB Qi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwot ICogYXJlIG1ldDoKLSAqCi0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK LSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lcgotICogICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZQotICogICAgZGlzdHJpYnV0aW9uLgotICogMy4gTmVpdGhl ciB0aGUgbmFtZSBvZiBFcmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMK LSAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVk IGZyb20gdGhpcwotICogICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVu IHBlcm1pc3Npb24uCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09Q WVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwotICogIkFTIElTIiBBTkQgQU5ZIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKLSAqIExJTUlURUQg VE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUgotICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIFRIRSBDT1BZUklHSFQKLSAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAotICogU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAotICogTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsCi0gKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKLSAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0KLSNpZiBFTkFC TEUoTUVESUFfU1RSRUFNKQotI2luY2x1ZGUgIkpTTWVkaWFEZXZpY2VzLmgiCi0KLSNpbmNsdWRl ICJEaWN0aW9uYXJ5LmgiCi0jaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgotI2luY2x1ZGUgIkpT RE9NQmluZGluZy5oIgotI2luY2x1ZGUgIkpTRE9NUHJvbWlzZS5oIgotI2luY2x1ZGUgIkpTTWVk aWFTdHJlYW0uaCIKLSNpbmNsdWRlICJKU05hdmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCi0jaW5j bHVkZSA8cnVudGltZS9FeGNlcHRpb24uaD4KLQotdXNpbmcgbmFtZXNwYWNlIEpTQzsKLQotbmFt ZXNwYWNlIFdlYkNvcmUgewotCi1KU1ZhbHVlIEpTTWVkaWFEZXZpY2VzOjpnZXRVc2VyTWVkaWEo RXhlY1N0YXRlKiBleGVjKQotewotICAgIEpTUHJvbWlzZURlZmVycmVkKiBwcm9taXNlRGVmZXJy ZWQgPSBKU1Byb21pc2VEZWZlcnJlZDo6Y3JlYXRlKGV4ZWMsIGdsb2JhbE9iamVjdCgpKTsKLSAg ICBEZWZlcnJlZFdyYXBwZXIgd3JhcHBlcihleGVjLCBnbG9iYWxPYmplY3QoKSwgcHJvbWlzZURl ZmVycmVkKTsKLQotICAgIERpY3Rpb25hcnkgb3B0aW9ucyhleGVjLCBleGVjLT5hcmd1bWVudCgw KSk7Ci0gICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKSB7Ci0gICAgICAgIEV4Y2VwdGlvbiog ZXhjZXB0aW9uID0gZXhlYy0+ZXhjZXB0aW9uKCk7Ci0gICAgICAgIGV4ZWMtPmNsZWFyRXhjZXB0 aW9uKCk7Ci0gICAgICAgIHdyYXBwZXIucmVqZWN0KGV4Y2VwdGlvbi0+dmFsdWUoKSk7Ci0gICAg ICAgIHJldHVybiBwcm9taXNlRGVmZXJyZWQtPnByb21pc2UoKTsKLSAgICB9Ci0KLSAgICBpZiAo IW9wdGlvbnMuaXNPYmplY3QoKSkgewotICAgICAgICBKU1ZhbHVlIGVycm9yID0gY3JlYXRlVHlw ZUVycm9yKGV4ZWMsICJGaXJzdCBhcmd1bWVudCBvZiBnZXRVc2VyTWVkaWEgbXVzdCBiZSBhIHZh bGlkIERpY3Rpb25hcnkiKTsKLSAgICAgICAgd3JhcHBlci5yZWplY3QoZXJyb3IpOwotICAgICAg ICByZXR1cm4gcHJvbWlzZURlZmVycmVkLT5wcm9taXNlKCk7Ci0gICAgfQotCi0gICAgYXV0byBy ZXNvbHZlQ2FsbGJhY2sgPSBbd3JhcHBlcl0oTWVkaWFTdHJlYW0mIHN0cmVhbSkgbXV0YWJsZSB7 Ci0gICAgICAgIHdyYXBwZXIucmVzb2x2ZSgmc3RyZWFtKTsKLSAgICB9OwotICAgIGF1dG8gcmVq ZWN0Q2FsbGJhY2sgPSBbd3JhcHBlcl0oTmF2aWdhdG9yVXNlck1lZGlhRXJyb3ImIGVycm9yKSBt dXRhYmxlIHsKLSAgICAgICAgd3JhcHBlci5yZWplY3QoJmVycm9yKTsKLSAgICB9OwotCi0gICAg RXhjZXB0aW9uQ29kZSBlYyA9IDA7Ci0gICAgaW1wbCgpLmdldFVzZXJNZWRpYShvcHRpb25zLCBX VEY6Om1vdmUocmVzb2x2ZUNhbGxiYWNrKSwgV1RGOjptb3ZlKHJlamVjdENhbGxiYWNrKSwgZWMp OwotICAgIGlmIChlYykKLSAgICAgICAgd3JhcHBlci5yZWplY3QoZWMpOwotCi0gICAgcmV0dXJu IHByb21pc2VEZWZlcnJlZC0+cHJvbWlzZSgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3Jl Ci0KLSNlbmRpZiAvLyBFTkFCTEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNTdWJ0bGVDcnlwdG9DdXN0b20uY3BwIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvanMvSlNTdWJ0bGVDcnlwdG9DdXN0b20uY3BwCmluZGV4IDRkZjViMjYxYjY2 NzRjZDM0YjQzZWUyYjIyM2Y5M2UxMzMxYThiMjQuLmQ4YzdmZjE1Nzg3M2Q3NWZkNzMzNzQ2ZGEz OWUzODliMTdmYjZkODggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pT U3VidGxlQ3J5cHRvQ3VzdG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9K U1N1YnRsZUNyeXB0b0N1c3RvbS5jcHAKQEAgLTM2LDYgKzM2LDggQEAKICNpbmNsdWRlICJEb2N1 bWVudC5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJKU0NyeXB0b0Fs Z29yaXRobURpY3Rpb25hcnkuaCIKKyNpbmNsdWRlICJKU0NyeXB0b0tleS5oIgorI2luY2x1ZGUg IkpTQ3J5cHRvS2V5UGFpci5oIgogI2luY2x1ZGUgIkpTQ3J5cHRvS2V5U2VyaWFsaXphdGlvbkpX Sy5oIgogI2luY2x1ZGUgIkpTQ3J5cHRvT3BlcmF0aW9uRGF0YS5oIgogI2luY2x1ZGUgIkpTRE9N UHJvbWlzZS5oIgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCmluZGV4IGU4MDdjZjFiZDA2NjA2MGNhMmZjMjJjYjE3NTc2OWI4MjYzNWQ0 ODMuLjFjMjRiNWE0MzJlMjBkNDgwNDc3ZGI3YzA1MGRlMmI4NWJhZjhjNjkgMTAwNjQ0Ci0tLSBh L0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxNS0wNi0yMiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubi5mYWJsZXRAY3Jm LmNhbm9uLmZyPgorCisgICAgICAgIE1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEgc2hvdWxkIG1p Z3JhdGUgZnJvbSBjYWxsYmFja3MgdG8gRE9NUHJvbWlzZQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ2MjAwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNl cy1nZXRVc2VyTWVkaWEtZXhwZWN0ZWQudHh0OgorCiAyMDE1LTA2LTIyICBYYWJpZXIgUm9kcmln dWV6IENhbHZhciAgPGNhbHZhcmlzQGlnYWxpYS5jb20+IGFuZCBZb3Vlbm4gRmFibGV0IDx5b3Vl bm4uZmFibGV0QGNyZi5jYW5vbi5mcj4KIAogICAgICAgICBbU3RyZWFtcyBBUEldIENvcnJlY3Qg cmVsZWFzZUxvY2sgdGVzdCBpbiByZWFkYWJsZS1zdHJlYW0tdGVtcGxhdGVkLmh0bWwKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVzZXJN ZWRpYS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2 aWNlcy1nZXRVc2VyTWVkaWEtZXhwZWN0ZWQudHh0CmluZGV4IGUwNTllMzFjZTBjMzlmOWY0ZGU3 ZWM4NTUxYzlhNDAzNjEyOWRhNTMuLjE5ZjViYjFlYzI3MzNiNmYxMTUzMTAxMTI1NTY1NWRmNDI4 MjhlOGEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZp Y2VzLWdldFVzZXJNZWRpYS1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9tZWRp YXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLWV4cGVjdGVkLnR4dApAQCAtNSw3ICs1 LDcgQEAgT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdl cywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUKIAogUEFTUyB0eXBlb2YgbmF2aWdhdG9yLm1l ZGlhRGV2aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEgaXMgJ3VuZGVmaW5lZCcKIFBBU1MgbmF2aWdh dG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KS50aGVuKGdvdFN0cmVh bTEpOyBkaWQgbm90IHRocm93IGV4Y2VwdGlvbi4KLVBBU1MgbmF2aWdhdG9yLm1lZGlhRGV2aWNl cy5nZXRVc2VyTWVkaWEoKSByZWplY3RlZCB3aXRoIGVycm9yOiBUeXBlRXJyb3I6IEZpcnN0IGFy Z3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeQorUEFTUyBu YXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSgpIHJlamVjdGVkIHdpdGggZXJyb3I6 IFR5cGVFcnJvcjogTm90IGVub3VnaCBhcmd1bWVudHMKIFBBU1MgIG5hdmlnYXRvci5tZWRpYURl dmljZXMuZ2V0VXNlck1lZGlhKHt9KSByZWplY3RlZCB3aXRoIGVycm9yOiBFcnJvcjogTm90U3Vw cG9ydGVkRXJyb3I6IERPTSBFeGNlcHRpb24gOQogUEFTUyBTdHJlYW0gZ2VuZXJhdGVkLgogUEFT UyBzdHJlYW0uZ2V0QXVkaW9UcmFja3MoKS5sZW5ndGggaXMgMQo= 255409 2015-06-23 06:22:05 -0700 2015-06-23 07:10:55 -0700 Patch for landing bug-146200-20150623152121.patch text/plain 28313 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMTg1ODYyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODk5ZTdjY2JmMmMxMDYz MTQ3YzJlOWU1ZWU5ZjA1YTQwZWYyNDc5My4uMjUwZWE1NWQ2YzdlNTEzNjU1NmYxYWYwYWE5ZWQ2 ZGNkNmUwNTZhMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE1LTA2LTIyICBZb3Vl bm4gRmFibGV0ICA8eW91ZW5uLmZhYmxldEBjcmYuY2Fub24uZnI+CisKKyAgICAgICAgTWVkaWFE ZXZpY2VzLmdldFVzZXJNZWRpYSBzaG91bGQgbWlncmF0ZSBmcm9tIGNhbGxiYWNrcyB0byBET01Q cm9taXNlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NDYyMDAKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KKworICAgICAgICBJbnRy b2R1Y2VkIERPTVByb21pc2VXaXRoQ2FsbGJhY2sgdG8gcmVzb2x2ZS9yZWplY3QgcHJvbWlzZXMg d2hpbGUgYWxsb3dpbmcgcHJvbWlzZSBjbGllbnRzIHRvIHVzZSBhIHR5cGVkIGNhbGxiYWNrIGFw cHJvYWNoLgorICAgICAgICBNaWdyYXRlZCBNZWRpYURldmljZXMuZ2V0VXNlck1lZGlhIGZyb20g Y2FsbGJhY2tzIHRvIERPTVByb21pc2VXaXRoQ2FsbGJhY2suCisgICAgICAgIFJlbW92ZWQgTWVk aWFEZXZpY2VzLmdldFVzZXJNZWRpYSBjdXN0b20gYmluZGluZy4KKworICAgICAgICBDb3ZlcmVk IGJ5IGV4aXN0aW5nIHRlc3RzLgorCisgICAgICAgICogQ01ha2VMaXN0cy50eHQ6IFJlbW92aW5n IGN1c3RvbSBiaW5kaW5nLgorICAgICAgICAqIE1vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZp Y2VzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhRGV2aWNlczo6Z2V0VXNlck1lZGlhKTog TW92aW5nIGZyb20gY2FsbGJhY2sgdG8gcHJvbWlzZS4KKyAgICAgICAgKiBNb2R1bGVzL21lZGlh c3RyZWFtL01lZGlhRGV2aWNlcy5oOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL21lZGlhc3Ry ZWFtL01lZGlhRGV2aWNlcy5pZGw6IFJlbW92aW5nIGN1c3RvbSBiaW5kaW5nLgorICAgICAgICAq IE1vZHVsZXMvbWVkaWFzdHJlYW0vTmF2aWdhdG9yVXNlck1lZGlhLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6Ok5hdmlnYXRvclVzZXJNZWRpYTo6d2Via2l0R2V0VXNlck1lZGlhKTogQ29udmVydGlu ZyBmcm9tIHByb21pc2UgY2FsbGJhY2sgdG8gQVBJIGNhbGxiYWNrcy4KKyAgICAgICAgKiBNb2R1 bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 VXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKTogTW92aW5nIGZyb20gY2FsbGJhY2sgdG8gcHJvbWlz ZS4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OlVzZXJNZWRpYVJlcXVlc3Qp OiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlVzZXJNZWRpYVJlcXVlc3Q6OmRpZENyZWF0ZVN0 cmVhbSk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6VXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVk VG9DcmVhdGVTdHJlYW1XaXRoQ29uc3RyYWludHNFcnJvcik6IERpdHRvLgorICAgICAgICAoV2Vi Q29yZTo6VXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9DcmVhdGVTdHJlYW1XaXRoUGVybWlzc2lv bkVycm9yKTogRGl0dG8uCisgICAgICAgICogTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFS ZXF1ZXN0Lmg6IERpdHRvLgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRE9NUHJvbWlzZS5oOiBJ bnRyb2R1Y2luZyBET01Qcm9taXNlV2l0aENhbGxiYWNrIGFuZCByZW1vdmluZyBjcnlwdG8gc3Bl Y2lmaWMgaGVhZGVyLgorICAgICAgICAoV2ViQ29yZTo6RE9NUHJvbWlzZVdpdGhDYWxsYmFjazo6 RE9NUHJvbWlzZVdpdGhDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpFcnJvcj46OnJlc29s dmUpOgorICAgICAgICAoV2ViQ29yZTo6RXJyb3I+OjpyZWplY3QpOgorICAgICAgICAqIGJpbmRp bmdzL2pzL0pTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcDogUmVtb3ZlZC4KKyAgICAgICAgKiBiaW5k aW5ncy9qcy9KU1N1YnRsZUNyeXB0b0N1c3RvbS5jcHA6IFVwZGF0aW5nIGhlYWRlcnMuCisKIDIw MTUtMDYtMjIgIFJ5dWFuIENob2kgIDxyeXVhbi5jaG9pQG5hdmVyY29ycC5jb20+CiAKICAgICAg ICAgW0VGTF0gSHlwaGVuYXRpb24gaXMgbm90IHN1cHBvcnRlZApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApp bmRleCBhNWNkYjY4ZDJmYTZkYzJjMDhiZGRiZWRmMWE4OTgxZGU3ZTc5NjI4Li5kMThlNDIzY2I1 NzIxNzkzYzdiOTg1NjRjMzUxZTViZGY3NjU5OTdjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DTWFrZUxpc3RzLnR4dAorKysgYi9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAt MTE1Myw3ICsxMTUzLDYgQEAgc2V0KFdlYkNvcmVfU09VUkNFUwogICAgIGJpbmRpbmdzL2pzL0pT TGF6eUV2ZW50TGlzdGVuZXIuY3BwCiAgICAgYmluZGluZ3MvanMvSlNMb2NhdGlvbkN1c3RvbS5j cHAKICAgICBiaW5kaW5ncy9qcy9KU01haW5UaHJlYWRFeGVjU3RhdGUuY3BwCi0gICAgYmluZGlu Z3MvanMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvanMvSlNNZWRpYVNv dXJjZVN0YXRlc0N1c3RvbS5jcHAKICAgICBiaW5kaW5ncy9qcy9KU01lZGlhU3RyZWFtQ2FwYWJp bGl0aWVzQ3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL2pzL0pTTWVzc2FnZUNoYW5uZWxDdXN0b20u Y3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlh RGV2aWNlcy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2 aWNlcy5jcHAKaW5kZXggMDJmYmM4NjRjYmE2MzA4YmY4YWJiZjMyMjFkZWI4OTc5ZDU0NWQzNi4u NmE5NGJiMjQ2NTdhMjZlNzk2MDUyNDNiZDFkOGM4MmY5NGMwY2VkMyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmNwcApAQCAtNjAs OCArNjAsMTMgQEAgRG9jdW1lbnQqIE1lZGlhRGV2aWNlczo6ZG9jdW1lbnQoKSBjb25zdAogICAg IHJldHVybiBkb3duY2FzdDxEb2N1bWVudD4oc2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpKTsKIH0K IAotdm9pZCBNZWRpYURldmljZXM6OmdldFVzZXJNZWRpYShjb25zdCBEaWN0aW9uYXJ5JiBvcHRp b25zLCBSZXNvbHZlQ2FsbGJhY2sgcmVzb2x2ZUNhbGxiYWNrLCBSZWplY3RDYWxsYmFjayByZWpl Y3RDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYgZWMpIGNvbnN0Cit2b2lkIE1lZGlhRGV2aWNlczo6 Z2V0VXNlck1lZGlhKGNvbnN0IERpY3Rpb25hcnkmIG9wdGlvbnMsIFByb21pc2UmJiBwcm9taXNl LCBFeGNlcHRpb25Db2RlJiBlYykgY29uc3QKIHsKKyAgICBpZiAoIW9wdGlvbnMuaXNPYmplY3Qo KSkgeworICAgICAgICBlYyA9IFR5cGVFcnJvcjsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwog ICAgIFVzZXJNZWRpYUNvbnRyb2xsZXIqIHVzZXJNZWRpYSA9IFVzZXJNZWRpYUNvbnRyb2xsZXI6 OmZyb20oZG9jdW1lbnQoKSA/IGRvY3VtZW50KCktPnBhZ2UoKSA6IG51bGxwdHIpOwogICAgIGlm ICghdXNlck1lZGlhKSB7CiAgICAgICAgIC8vIEZJWE1FOiBXZSBwcm9iYWJseSB3YW50IHRvIHJl dHVybiBhIE1lZGlhU3RyZWFtRXJyb3IgaGVyZSB1c2luZyB0aGUgcmVqZWN0Q2FsbGJhY2ssIGFu ZCBnZXQgcmlkIG9mZiB0aGUgRXhjZXB0aW9uQ29kZSBwYXJhbWV0ZXIuCkBAIC02OSw3ICs3NCw3 IEBAIHZvaWQgTWVkaWFEZXZpY2VzOjpnZXRVc2VyTWVkaWEoY29uc3QgRGljdGlvbmFyeSYgb3B0 aW9ucywgUmVzb2x2ZUNhbGxiYWNrIHJlc29sCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAg ICBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gcmVxdWVzdCA9IFVzZXJNZWRpYVJlcXVlc3Q6OmNy ZWF0ZShkb2N1bWVudCgpLCB1c2VyTWVkaWEsIG9wdGlvbnMsIFdURjo6bW92ZShyZXNvbHZlQ2Fs bGJhY2spLCBXVEY6Om1vdmUocmVqZWN0Q2FsbGJhY2spLCBlYyk7CisgICAgUmVmUHRyPFVzZXJN ZWRpYVJlcXVlc3Q+IHJlcXVlc3QgPSBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUoZG9jdW1lbnQo KSwgdXNlck1lZGlhLCBvcHRpb25zLCBXVEY6Om1vdmUocHJvbWlzZSksIGVjKTsKICAgICBpZiAo IXJlcXVlc3QpIHsKICAgICAgICAgZWMgPSBOT1RfU1VQUE9SVEVEX0VSUjsKICAgICAgICAgcmV0 dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRp YURldmljZXMuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTWVkaWFEZXZp Y2VzLmgKaW5kZXggNzRhNzgxYzY0ZTNjMmYwMTY2NGYxMWIxOTY0NDViZjkzNmM4Y2RmMC4uMzc1 OGExMDgxMjNiZDNhMDdmOWNhYzNhZmY0NzQ1ZGQ5N2ZiZTY0YiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5oCkBAIC0zNCw2ICszNCw3 IEBACiAjaWYgRU5BQkxFKE1FRElBX1NUUkVBTSkKIAogI2luY2x1ZGUgIkNvbnRleHREZXN0cnVj dGlvbk9ic2VydmVyLmgiCisjaW5jbHVkZSAiSlNET01Qcm9taXNlLmgiCiAjaW5jbHVkZSAiU2Ny aXB0V3JhcHBhYmxlLmgiCiAjaW5jbHVkZSA8ZnVuY3Rpb25hbD4KICNpbmNsdWRlIDx3dGYvUmVm Q291bnRlZC5oPgpAQCAtNTUsMTAgKzU2LDggQEAgcHVibGljOgogCiAgICAgRG9jdW1lbnQqIGRv Y3VtZW50KCkgY29uc3Q7CiAKLSAgICB0eXBlZGVmIHN0ZDo6ZnVuY3Rpb248dm9pZChNZWRpYVN0 cmVhbSYpPiBSZXNvbHZlQ2FsbGJhY2s7Ci0gICAgdHlwZWRlZiBzdGQ6OmZ1bmN0aW9uPHZvaWQo TmF2aWdhdG9yVXNlck1lZGlhRXJyb3ImKT4gUmVqZWN0Q2FsbGJhY2s7Ci0KLSAgICB2b2lkIGdl dFVzZXJNZWRpYShjb25zdCBEaWN0aW9uYXJ5JiwgUmVzb2x2ZUNhbGxiYWNrLCBSZWplY3RDYWxs YmFjaywgRXhjZXB0aW9uQ29kZSYpIGNvbnN0OworICAgIHR5cGVkZWYgRE9NUHJvbWlzZVdpdGhD YWxsYmFjazxSZWZQdHI8TWVkaWFTdHJlYW0+LCBSZWZQdHI8TmF2aWdhdG9yVXNlck1lZGlhRXJy b3I+PiBQcm9taXNlOworICAgIHZvaWQgZ2V0VXNlck1lZGlhKGNvbnN0IERpY3Rpb25hcnkmLCBQ cm9taXNlJiYsIEV4Y2VwdGlvbkNvZGUmKSBjb25zdDsKIAogcHJpdmF0ZToKICAgICBleHBsaWNp dCBNZWRpYURldmljZXMoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCopOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaWRsIGIvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9NZWRpYURldmljZXMuaWRsCmluZGV4IDUzM2Yx MGY3OGIwYTA5ZWM4OTVjYzg1YTEwZjFjZjJhYzRhMzczOGYuLjZiMGI4NDM0OTliYWEyYWNiMmY0 NWM2YmU0NzAzNWY1ZTA1ZWM4ZDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv bWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy5pZGwKQEAgLTMyLDUgKzMyLDUgQEAKICAgICBOb0lu dGVyZmFjZU9iamVjdCwKICAgICBDb25kaXRpb25hbD1NRURJQV9TVFJFQU0KIF0gaW50ZXJmYWNl IE1lZGlhRGV2aWNlcyB7Ci0gICAgW0N1c3RvbSwgUmFpc2VzRXhjZXB0aW9uXSBQcm9taXNlIGdl dFVzZXJNZWRpYShEaWN0aW9uYXJ5IG9wdGlvbnMpOworICAgIFtSYWlzZXNFeGNlcHRpb25dIFBy b21pc2UgZ2V0VXNlck1lZGlhKERpY3Rpb25hcnkgb3B0aW9ucyk7CiB9OwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9OYXZpZ2F0b3JVc2VyTWVkaWEuY3Bw IGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9OYXZpZ2F0b3JVc2VyTWVkaWEu Y3BwCmluZGV4IDE5YWJlNGRlNGU4NjY4MmM1MGRlZDk1YmVlMTFiMGJkMjY2ZDBlODIuLmUwM2M2 YWNjZmRkZDEzM2U4NDE2ZjU1YTc5YzA5NGY0ZGZmYTMzY2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJlYW0vTmF2aWdhdG9yVXNlck1lZGlhLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL05hdmlnYXRvclVzZXJNZWRpYS5jcHAK QEAgLTI5LDcgKzI5LDkgQEAKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkV4Y2Vw dGlvbkNvZGUuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIk1lZGlhU3RyZWFtLmgi CiAjaW5jbHVkZSAiTmF2aWdhdG9yLmgiCisjaW5jbHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhRXJy b3IuaCIKICNpbmNsdWRlICJOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvckNhbGxiYWNrLmgiCiAjaW5j bHVkZSAiTmF2aWdhdG9yVXNlck1lZGlhU3VjY2Vzc0NhbGxiYWNrLmgiCiAjaW5jbHVkZSAiUGFn ZS5oIgpAQCAtNDgsNiArNTAsNyBAQCBOYXZpZ2F0b3JVc2VyTWVkaWE6On5OYXZpZ2F0b3JVc2Vy TWVkaWEoKQogCiB2b2lkIE5hdmlnYXRvclVzZXJNZWRpYTo6d2Via2l0R2V0VXNlck1lZGlhKE5h dmlnYXRvciogbmF2aWdhdG9yLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBQYXNzUmVmUHRy PE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNz UmVmUHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssIEV4 Y2VwdGlvbkNvZGUmIGVjKQogeworICAgIC8vIEZJWE1FOiBSZW1vdmUgdGhpcyB0ZXN0IG9uY2Ug SURMIGlzIHVwZGF0ZWQgdG8gbWFrZSBlcnJyb0NhbGxiYWNrIHBhcmFtZXRlciBtYW5kYXRvcnku CiAgICAgaWYgKCFzdWNjZXNzQ2FsbGJhY2sgfHwgIWVycm9yQ2FsbGJhY2spIHsKICAgICAgICAg ZWMgPSBUWVBFX01JU01BVENIX0VSUjsKICAgICAgICAgcmV0dXJuOwpAQCAtNTksNyArNjIsMjUg QEAgdm9pZCBOYXZpZ2F0b3JVc2VyTWVkaWE6OndlYmtpdEdldFVzZXJNZWRpYShOYXZpZ2F0b3Iq IG5hdmlnYXRvciwgY29uc3QgRGljdGlvbmEKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IFJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiByZXF1ZXN0ID0gVXNlck1lZGlhUmVxdWVzdDo6Y3Jl YXRlKG5hdmlnYXRvci0+ZnJhbWUoKS0+ZG9jdW1lbnQoKSwgdXNlck1lZGlhLCBvcHRpb25zLCBz dWNjZXNzQ2FsbGJhY2ssIGVycm9yQ2FsbGJhY2ssIGVjKTsKKyAgICAvLyBXZSBkbyBub3QgbmVl ZCB0byBwcm90ZWN0IHRoZSBjb250ZXh0IChpLmUuIGRvY3VtZW50KSBoZXJlIGFzIFVzZXJNZWRp YVJlcXVlc3QgaXMgb2JzZXJ2aW5nIGNvbnRleHQgZGVzdHJ1Y3Rpb24gYW5kIHdpbGwgY2hlY2sg dmFsaWRpdHkgYmVmb3JlIHJlc29sdmluZy9yZWplY3RpbmcgcHJvbWlzZS4KKyAgICBEb2N1bWVu dCogZG9jdW1lbnQgPSBuYXZpZ2F0b3ItPmZyYW1lKCktPmRvY3VtZW50KCk7CisKKyAgICBBU1NF UlQoZXJyb3JDYWxsYmFjayk7CisgICAgQVNTRVJUKHN1Y2Nlc3NDYWxsYmFjayk7CisgICAgYXV0 byByZXNvbHZlQ2FsbGJhY2sgPSBbc3VjY2Vzc0NhbGxiYWNrLCBkb2N1bWVudF0oY29uc3QgUmVm UHRyPE1lZGlhU3RyZWFtPiYgc3RyZWFtKSBtdXRhYmxlIHsKKyAgICAgICAgUmVmUHRyPE1lZGlh U3RyZWFtPiBwcm90ZWN0ZWRTdHJlYW0gPSBzdHJlYW07CisgICAgICAgIGRvY3VtZW50LT5wb3N0 VGFzayhbc3VjY2Vzc0NhbGxiYWNrLCBwcm90ZWN0ZWRTdHJlYW1dKFNjcmlwdEV4ZWN1dGlvbkNv bnRleHQmKSB7CisgICAgICAgICAgICBzdWNjZXNzQ2FsbGJhY2stPmhhbmRsZUV2ZW50KHByb3Rl Y3RlZFN0cmVhbS5nZXQoKSk7CisgICAgICAgIH0pOworICAgIH07CisgICAgYXV0byByZWplY3RD YWxsYmFjayA9IFtlcnJvckNhbGxiYWNrLCBkb2N1bWVudF0oY29uc3QgUmVmUHRyPE5hdmlnYXRv clVzZXJNZWRpYUVycm9yPiYgZXJyb3IpIG11dGFibGUgeworICAgICAgICBSZWZQdHI8TmF2aWdh dG9yVXNlck1lZGlhRXJyb3I+IHByb3RlY3RlZEVycm9yID0gZXJyb3I7CisgICAgICAgIGRvY3Vt ZW50LT5wb3N0VGFzayhbZXJyb3JDYWxsYmFjaywgcHJvdGVjdGVkRXJyb3JdKFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQmKSB7CisgICAgICAgICAgICBlcnJvckNhbGxiYWNrLT5oYW5kbGVFdmVudChw cm90ZWN0ZWRFcnJvci5nZXQoKSk7CisgICAgICAgIH0pOworICAgIH07CisKKyAgICBhdXRvIHJl cXVlc3QgPSBVc2VyTWVkaWFSZXF1ZXN0OjpjcmVhdGUobmF2aWdhdG9yLT5mcmFtZSgpLT5kb2N1 bWVudCgpLCB1c2VyTWVkaWEsIG9wdGlvbnMsIE1lZGlhRGV2aWNlczo6UHJvbWlzZShXVEY6Om1v dmUocmVzb2x2ZUNhbGxiYWNrKSwgV1RGOjptb3ZlKHJlamVjdENhbGxiYWNrKSksIGVjKTsKICAg ICBpZiAoIXJlcXVlc3QpIHsKICAgICAgICAgZWMgPSBOT1RfU1VQUE9SVEVEX0VSUjsKICAgICAg ICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVh bS9Vc2VyTWVkaWFSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbWVkaWFzdHJl YW0vVXNlck1lZGlhUmVxdWVzdC5jcHAKaW5kZXggMDU5NzQ3MDU1MzNhMDZkZWQ3MzZlODdmZTll NjgwNmMyZTgyMjZiNy4uZDA5ZTA4MDE2OTU4ZDA1MDBhYmE5NmUxNWEzNzA2OGU4ODgyNGJhOCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9Vc2VyTWVkaWFS ZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1VzZXJN ZWRpYVJlcXVlc3QuY3BwCkBAIC00MSw2ICs0MSw4IEBACiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIK ICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRl ICJKU01lZGlhU3RyZWFtLmgiCisjaW5jbHVkZSAiSlNOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvci5o IgogI2luY2x1ZGUgIk1lZGlhQ29uc3RyYWludHNJbXBsLmgiCiAjaW5jbHVkZSAiTWVkaWFTdHJl YW0uaCIKICNpbmNsdWRlICJNZWRpYVN0cmVhbVByaXZhdGUuaCIKQEAgLTcxLDM2ICs3Myw4IEBA IHN0YXRpYyBQYXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+IHBhcnNlT3B0aW9ucyhjb25zdCBE aWN0aW9uYXJ5JiBvcHRpb25zLCBjb25zCiAgICAgcmV0dXJuIGNvbnN0cmFpbnRzLnJlbGVhc2Uo KTsKIH0KIAotUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0 ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDb250cm9sbGVyKiBj b250cm9sbGVyLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBQYXNzUmVmUHRyPE5hdmlnYXRv clVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPE5h dmlnYXRvclVzZXJNZWRpYUVycm9yQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2ssIEV4Y2VwdGlvbkNv ZGUmIGVjKQorUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IFVzZXJNZWRpYVJlcXVlc3Q6OmNyZWF0 ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBVc2VyTWVkaWFDb250cm9sbGVyKiBj b250cm9sbGVyLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBNZWRpYURldmljZXM6OlByb21p c2UmJiBwcm9taXNlLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKLSAgICBBU1NFUlQoc3VjY2Vzc0Nh bGxiYWNrKTsKLQotICAgIGF1dG8gcmVzb2x2ZUNhbGxiYWNrID0gW3N1Y2Nlc3NDYWxsYmFjaywg Y29udGV4dF0oTWVkaWFTdHJlYW0mIHN0cmVhbSkgbXV0YWJsZSB7Ci0gICAgICAgIEFTU0VSVChj b250ZXh0KTsKLQotICAgICAgICBSZWZQdHI8TWVkaWFTdHJlYW0+IG1lZGlhU3RyZWFtID0gJnN0 cmVhbTsKLSAgICAgICAgY29udGV4dC0+cG9zdFRhc2soW3N1Y2Nlc3NDYWxsYmFjaywgbWVkaWFT dHJlYW1dKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQmKSB7Ci0gICAgICAgICAgICBzdWNjZXNzQ2Fs bGJhY2stPmhhbmRsZUV2ZW50KG1lZGlhU3RyZWFtLmdldCgpKTsKLSAgICAgICAgfSk7Ci0gICAg fTsKLSAgICBhdXRvIHJlamVjdENhbGxiYWNrID0gW2Vycm9yQ2FsbGJhY2ssIGNvbnRleHRdKE5h dmlnYXRvclVzZXJNZWRpYUVycm9yJiBlcnJvcikgbXV0YWJsZSB7Ci0gICAgICAgIEFTU0VSVChj b250ZXh0KTsKLQotICAgICAgICBpZiAoZXJyb3JDYWxsYmFjaykgewotICAgICAgICAgICAgUmVm UHRyPE5hdmlnYXRvclVzZXJNZWRpYUVycm9yPiBldmVudEVycm9yID0gJmVycm9yOwotICAgICAg ICAgICAgY29udGV4dC0+cG9zdFRhc2soW2Vycm9yQ2FsbGJhY2ssIGV2ZW50RXJyb3JdKFNjcmlw dEV4ZWN1dGlvbkNvbnRleHQmKSB7Ci0gICAgICAgICAgICAgICAgZXJyb3JDYWxsYmFjay0+aGFu ZGxlRXZlbnQoZXZlbnRFcnJvci5nZXQoKSk7Ci0gICAgICAgICAgICB9KTsKLSAgICAgICAgfQot ICAgIH07Ci0KLSAgICByZXR1cm4gVXNlck1lZGlhUmVxdWVzdDo6Y3JlYXRlKGNvbnRleHQsIGNv bnRyb2xsZXIsIG9wdGlvbnMsIFdURjo6bW92ZShyZXNvbHZlQ2FsbGJhY2spLCBXVEY6Om1vdmUo cmVqZWN0Q2FsbGJhY2spLCBlYyk7Ci19Ci0KLVJlZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBVc2Vy TWVkaWFSZXF1ZXN0OjpjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgVXNl ck1lZGlhQ29udHJvbGxlciogY29udHJvbGxlciwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywg TWVkaWFEZXZpY2VzOjpSZXNvbHZlQ2FsbGJhY2smJiByZXNvbHZlQ2FsbGJhY2ssIE1lZGlhRGV2 aWNlczo6UmVqZWN0Q2FsbGJhY2smJiByZWplY3RDYWxsYmFjaywgRXhjZXB0aW9uQ29kZSYgZWMp Ci17Ci0gICAgQVNTRVJUKHJlc29sdmVDYWxsYmFjayAmJiByZWplY3RDYWxsYmFjayk7Ci0KICAg ICBSZWZQdHI8TWVkaWFDb25zdHJhaW50cz4gYXVkaW9Db25zdHJhaW50cyA9IHBhcnNlT3B0aW9u cyhvcHRpb25zLCBBdG9taWNTdHJpbmcoImF1ZGlvIiwgQXRvbWljU3RyaW5nOjpDb25zdHJ1Y3RG cm9tTGl0ZXJhbCksIGVjKTsKICAgICBpZiAoZWMpCiAgICAgICAgIHJldHVybiBudWxscHRyOwpA QCAtMTEyLDE2ICs4NiwxNSBAQCBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gVXNlck1lZGlhUmVx dWVzdDo6Y3JlYXRlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleAogICAgIGlmICghYXVk aW9Db25zdHJhaW50cyAmJiAhdmlkZW9Db25zdHJhaW50cykKICAgICAgICAgcmV0dXJuIG51bGxw dHI7CiAKLSAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBVc2VyTWVkaWFSZXF1ZXN0KGNvbnRleHQs IGNvbnRyb2xsZXIsIGF1ZGlvQ29uc3RyYWludHMucmVsZWFzZSgpLCB2aWRlb0NvbnN0cmFpbnRz LnJlbGVhc2UoKSwgV1RGOjptb3ZlKHJlc29sdmVDYWxsYmFjayksIFdURjo6bW92ZShyZWplY3RD YWxsYmFjaykpKTsKKyAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBVc2VyTWVkaWFSZXF1ZXN0KGNv bnRleHQsIGNvbnRyb2xsZXIsIGF1ZGlvQ29uc3RyYWludHMucmVsZWFzZSgpLCB2aWRlb0NvbnN0 cmFpbnRzLnJlbGVhc2UoKSwgV1RGOjptb3ZlKHByb21pc2UpKSk7CiB9CiAKLVVzZXJNZWRpYVJl cXVlc3Q6OlVzZXJNZWRpYVJlcXVlc3QoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwg VXNlck1lZGlhQ29udHJvbGxlciogY29udHJvbGxlciwgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFp bnRzPiBhdWRpb0NvbnN0cmFpbnRzLCBQYXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+IHZpZGVv Q29uc3RyYWludHMsIE1lZGlhRGV2aWNlczo6UmVzb2x2ZUNhbGxiYWNrJiYgcmVzb2x2ZUNhbGxi YWNrLCBNZWRpYURldmljZXM6OlJlamVjdENhbGxiYWNrJiYgcmVqZWN0Q2FsbGJhY2spCitVc2Vy TWVkaWFSZXF1ZXN0OjpVc2VyTWVkaWFSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNv bnRleHQsIFVzZXJNZWRpYUNvbnRyb2xsZXIqIGNvbnRyb2xsZXIsIFBhc3NSZWZQdHI8TWVkaWFD b25zdHJhaW50cz4gYXVkaW9Db25zdHJhaW50cywgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFpbnRz PiB2aWRlb0NvbnN0cmFpbnRzLCBNZWRpYURldmljZXM6OlByb21pc2UmJiBwcm9taXNlKQogICAg IDogQ29udGV4dERlc3RydWN0aW9uT2JzZXJ2ZXIoY29udGV4dCkKICAgICAsIG1fYXVkaW9Db25z dHJhaW50cyhhdWRpb0NvbnN0cmFpbnRzKQogICAgICwgbV92aWRlb0NvbnN0cmFpbnRzKHZpZGVv Q29uc3RyYWludHMpCiAgICAgLCBtX2NvbnRyb2xsZXIoY29udHJvbGxlcikKLSAgICAsIG1fcmVz b2x2ZUNhbGxiYWNrKFdURjo6bW92ZShyZXNvbHZlQ2FsbGJhY2spKQotICAgICwgbV9yZWplY3RD YWxsYmFjayhXVEY6Om1vdmUocmVqZWN0Q2FsbGJhY2spKQorICAgICwgbV9wcm9taXNlKFdURjo6 bW92ZShwcm9taXNlKSkKIHsKIH0KIApAQCAtMTQ0LDcgKzExNyw2IEBAIHZvaWQgVXNlck1lZGlh UmVxdWVzdDo6c3RhcnQoKQogICAgIFJlYWx0aW1lTWVkaWFTb3VyY2VDZW50ZXI6OnNpbmdsZXRv bigpLnZhbGlkYXRlUmVxdWVzdENvbnN0cmFpbnRzKHRoaXMsIG1fYXVkaW9Db25zdHJhaW50cywg bV92aWRlb0NvbnN0cmFpbnRzKTsKIH0KIAotICAgIAogdm9pZCBVc2VyTWVkaWFSZXF1ZXN0Ojpj b25zdHJhaW50c1ZhbGlkYXRlZCgpCiB7CiAgICAgUmVmUHRyPFVzZXJNZWRpYVJlcXVlc3Q+IHBy b3RlY3RlZFRoaXModGhpcyk7CkBAIC0xODYsNyArMTU4LDcgQEAgdm9pZCBVc2VyTWVkaWFSZXF1 ZXN0OjpkaWRDcmVhdGVTdHJlYW0oUGFzc1JlZlB0cjxNZWRpYVN0cmVhbVByaXZhdGU+IHByaXZh dGVTdHIKICAgICBmb3IgKGF1dG8mIHRyYWNrIDogc3RyZWFtLT5nZXRWaWRlb1RyYWNrcygpKQog ICAgICAgICB0cmFjay0+YXBwbHlDb25zdHJhaW50cyhtX3ZpZGVvQ29uc3RyYWludHMpOwogCi0g ICAgbV9yZXNvbHZlQ2FsbGJhY2soKnN0cmVhbSk7CisgICAgbV9wcm9taXNlLnJlc29sdmUoc3Ry ZWFtKTsKIH0KIAogdm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpmYWlsZWRUb0NyZWF0ZVN0cmVhbVdp dGhDb25zdHJhaW50c0Vycm9yKGNvbnN0IFN0cmluZyYgY29uc3RyYWludE5hbWUpCkBAIC0xOTUs NyArMTY3LDcgQEAgdm9pZCBVc2VyTWVkaWFSZXF1ZXN0OjpmYWlsZWRUb0NyZWF0ZVN0cmVhbVdp dGhDb25zdHJhaW50c0Vycm9yKGNvbnN0IFN0cmluZyYgY28KICAgICBpZiAoIW1fc2NyaXB0RXhl Y3V0aW9uQ29udGV4dCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV9yZWplY3RDYWxsYmFjayhO YXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpj b25zdHJhaW50Tm90U2F0aXNmaWVkRXJyb3JOYW1lKCksIGNvbnN0cmFpbnROYW1lKS5nZXQoKSk7 CisgICAgbV9wcm9taXNlLnJlamVjdChOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5h dmlnYXRvclVzZXJNZWRpYUVycm9yOjpjb25zdHJhaW50Tm90U2F0aXNmaWVkRXJyb3JOYW1lKCks IGNvbnN0cmFpbnROYW1lKSk7CiB9CiAKIHZvaWQgVXNlck1lZGlhUmVxdWVzdDo6ZmFpbGVkVG9D cmVhdGVTdHJlYW1XaXRoUGVybWlzc2lvbkVycm9yKCkKQEAgLTIwNCw3ICsxNzYsNyBAQCB2b2lk IFVzZXJNZWRpYVJlcXVlc3Q6OmZhaWxlZFRvQ3JlYXRlU3RyZWFtV2l0aFBlcm1pc3Npb25FcnJv cigpCiAgICAgICAgIHJldHVybjsKIAogICAgIC8vIEZJWE1FOiBSZXBsYWNlIE5hdmlnYXRvclVz ZXJNZWRpYUVycm9yIHdpdGggTWVkaWFTdHJlYW1FcnJvciAoc2VlIGJ1ZyAxNDMzMzUpCi0gICAg bV9yZWplY3RDYWxsYmFjayhOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjo6Y3JlYXRlKE5hdmlnYXRv clVzZXJNZWRpYUVycm9yOjpwZXJtaXNzaW9uRGVuaWVkRXJyb3JOYW1lKCksIGVtcHR5U3RyaW5n KCkpKTsKKyAgICBtX3Byb21pc2UucmVqZWN0KE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOjpjcmVh dGUoTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6OnBlcm1pc3Npb25EZW5pZWRFcnJvck5hbWUoKSwg ZW1wdHlTdHJpbmcoKSkpOwogfQogCiB2b2lkIFVzZXJNZWRpYVJlcXVlc3Q6OmNvbnRleHREZXN0 cm95ZWQoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXN0cmVhbS9V c2VyTWVkaWFSZXF1ZXN0LmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1Vz ZXJNZWRpYVJlcXVlc3QuaAppbmRleCBmMzUzOWRiMjc5YmFjZjUwNWE3M2JjNGE2ZWY2MzUzOTBi NmE4MGNjLi5hOTNmMmJkZDgyYTk2ODdmNWEwODk4NjU4YjNhMGRmYmJkZWZhZWUxIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVlc3Qu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhc3RyZWFtL1VzZXJNZWRpYVJlcXVl c3QuaApAQCAtNTgsOCArNTgsNyBAQCB0eXBlZGVmIGludCBFeGNlcHRpb25Db2RlOwogCiBjbGFz cyBVc2VyTWVkaWFSZXF1ZXN0IDogcHVibGljIE1lZGlhU3RyZWFtQ3JlYXRpb25DbGllbnQsIHB1 YmxpYyBDb250ZXh0RGVzdHJ1Y3Rpb25PYnNlcnZlciB7CiBwdWJsaWM6Ci0gICAgc3RhdGljIFJl ZlB0cjxVc2VyTWVkaWFSZXF1ZXN0PiBjcmVhdGUoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIFVz ZXJNZWRpYUNvbnRyb2xsZXIqLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBQYXNzUmVmUHRy PE5hdmlnYXRvclVzZXJNZWRpYVN1Y2Nlc3NDYWxsYmFjaz4sIFBhc3NSZWZQdHI8TmF2aWdhdG9y VXNlck1lZGlhRXJyb3JDYWxsYmFjaz4sIEV4Y2VwdGlvbkNvZGUmKTsKLSAgICBzdGF0aWMgUmVm UHRyPFVzZXJNZWRpYVJlcXVlc3Q+IGNyZWF0ZShTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgVXNl ck1lZGlhQ29udHJvbGxlciosIGNvbnN0IERpY3Rpb25hcnkmIG9wdGlvbnMsIE1lZGlhRGV2aWNl czo6UmVzb2x2ZUNhbGxiYWNrJiYsIE1lZGlhRGV2aWNlczo6UmVqZWN0Q2FsbGJhY2smJiwgRXhj ZXB0aW9uQ29kZSYpOworICAgIHN0YXRpYyBSZWZQdHI8VXNlck1lZGlhUmVxdWVzdD4gY3JlYXRl KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBVc2VyTWVkaWFDb250cm9sbGVyKiwgY29uc3QgRGlj dGlvbmFyeSYgb3B0aW9ucywgTWVkaWFEZXZpY2VzOjpQcm9taXNlJiYsIEV4Y2VwdGlvbkNvZGUm KTsKICAgICB+VXNlck1lZGlhUmVxdWVzdCgpOwogCiAgICAgV0VCQ09SRV9FWFBPUlQgU2VjdXJp dHlPcmlnaW4qIHNlY3VyaXR5T3JpZ2luKCkgY29uc3Q7CkBAIC03Miw3ICs3MSw3IEBAIHB1Ymxp YzoKICAgICBib29sIHJlcXVpcmVzVmlkZW8oKSBjb25zdCB7IHJldHVybiBtX3ZpZGVvQ29uc3Ry YWludHM7IH0KIAogcHJpdmF0ZToKLSAgICBVc2VyTWVkaWFSZXF1ZXN0KFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqLCBVc2VyTWVkaWFDb250cm9sbGVyKiwgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFp bnRzPiBhdWRpb0NvbnN0cmFpbnRzLCBQYXNzUmVmUHRyPE1lZGlhQ29uc3RyYWludHM+IHZpZGVv Q29uc3RyYWludHMsIE1lZGlhRGV2aWNlczo6UmVzb2x2ZUNhbGxiYWNrJiYsIE1lZGlhRGV2aWNl czo6UmVqZWN0Q2FsbGJhY2smJik7CisgICAgVXNlck1lZGlhUmVxdWVzdChTY3JpcHRFeGVjdXRp b25Db250ZXh0KiwgVXNlck1lZGlhQ29udHJvbGxlciosIFBhc3NSZWZQdHI8TWVkaWFDb25zdHJh aW50cz4gYXVkaW9Db25zdHJhaW50cywgUGFzc1JlZlB0cjxNZWRpYUNvbnN0cmFpbnRzPiB2aWRl b0NvbnN0cmFpbnRzLCBNZWRpYURldmljZXM6OlByb21pc2UmJik7CiAKICAgICAvLyBNZWRpYVN0 cmVhbUNyZWF0aW9uQ2xpZW50CiAgICAgdmlydHVhbCB2b2lkIGNvbnN0cmFpbnRzVmFsaWRhdGVk KCkgb3ZlcnJpZGUgZmluYWw7CkBAIC04OSw4ICs4OCw3IEBAIHByaXZhdGU6CiAKICAgICBVc2Vy TWVkaWFDb250cm9sbGVyKiBtX2NvbnRyb2xsZXI7CiAKLSAgICBNZWRpYURldmljZXM6OlJlc29s dmVDYWxsYmFjayBtX3Jlc29sdmVDYWxsYmFjazsKLSAgICBNZWRpYURldmljZXM6OlJlamVjdENh bGxiYWNrIG1fcmVqZWN0Q2FsbGJhY2s7CisgICAgTWVkaWFEZXZpY2VzOjpQcm9taXNlIG1fcHJv bWlzZTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCAzNGJlMjIxMWFkYjA1ZmZk ZjM3NjY0MWUxNDdiYWQ2NmY2MWRkOTJiLi5hOTdjZjY0MTQ2YWIwYzE1YWZkYjFlYWExNzAzNTFl OTQ0ZDRlZGRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCkBAIC0yMjA1LDcgKzIyMDUsNiBAQAogCQk1REZFOEY1NjBEMTY0NzdCMDA3 NkU5MzcgLyogU2NoZWR1bGVkQWN0aW9uLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEJDQTM3OEJBMEQxNUY2NDIwMEI3OTNENiAvKiBTY2hlZHVsZWRB Y3Rpb24uY3BwICovOyB9OwogCQk1REZFOEY1NzBEMTY0NzdDMDA3NkU5MzcgLyogU2NoZWR1bGVk QWN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBC Q0EzNzhCQjBEMTVGNjQyMDBCNzkzRDYgLyogU2NoZWR1bGVkQWN0aW9uLmggKi87IHNldHRpbmdz ID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNURGRUJBQjcxODU5MkI2RDAw Qzc1QkVCIC8qIFdlYktpdEF2YWlsYWJpbGl0eS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNURGRUJBQjYxODU5MkI2RDAwQzc1QkVCIC8qIFdlYktpdEF2 YWlsYWJpbGl0eS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07Ci0JCTVFQTcyNUQxMUFDQUJEMzgwMEVBRDE3QiAvKiBKU01lZGlhRGV2aWNlc0N1c3RvbS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA1RUE3MjVE MDFBQ0FCRDI3MDBFQUQxN0IgLyogSlNNZWRpYURldmljZXNDdXN0b20uY3BwICovOyB9OwogCQk1 RUE3MjVEMjFBQ0FCRDQ3MDBFQUQxN0IgLyogTWVkaWFEZXZpY2VzLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDVFQTcyNUNEMUFDQUJDRDkwMEVBRDE3 QiAvKiBNZWRpYURldmljZXMuY3BwICovOyB9OwogCQk1RUE3MjVEMzFBQ0FCRDQ3MDBFQUQxN0Ig LyogTWVkaWFEZXZpY2VzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA1RUE3MjVDRTFBQ0FCQ0Q5MDBFQUQxN0IgLyogTWVkaWFEZXZpY2VzLmggKi87IH07 CiAJCTVFQTcyNUQ1MUFDQUJENTcwMEVBRDE3QiAvKiBOYXZpZ2F0b3JNZWRpYURldmljZXMuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNUVBNzI1Q0Ex QUNBQkNCNTAwRUFEMTdCIC8qIE5hdmlnYXRvck1lZGlhRGV2aWNlcy5jcHAgKi87IH07CkBAIC05 NDY0LDcgKzk0NjMsNiBAQAogCQk1RUE3MjVDRDFBQ0FCQ0Q5MDBFQUQxN0IgLyogTWVkaWFEZXZp Y2VzLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IE1lZGlhRGV2aWNl cy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTVFQTcyNUNFMUFDQUJDRDkwMEVB RDE3QiAvKiBNZWRpYURldmljZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g TWVkaWFEZXZpY2VzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTVFQTcyNUNGMUFD QUJDRDkwMEVBRDE3QiAvKiBNZWRpYURldmljZXMuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9 IE1lZGlhRGV2aWNlcy5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCTVFQTcyNUQw MUFDQUJEMjcwMEVBRDE3QiAvKiBKU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU01lZGlhRGV2aWNlc0N1c3RvbS5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTVGMkRCQkU3MTc4RTMzMkQwMDE0MTQ4NiAvKiBDZXJ0 aWZpY2F0ZUluZm9NYWMubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IHBhdGgg PSBDZXJ0aWZpY2F0ZUluZm9NYWMubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTVG MkRCQkU4MTc4RTMzNjkwMDE0MTQ4NiAvKiBDZXJ0aWZpY2F0ZUluZm8uaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gQ2VydGlmaWNhdGVJbmZvLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTVGQzdEQzI2Q0ZFMjU2MzIwMEI4NUFFNSAvKiBKU0V2ZW50VGFyZ2V0Lmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU0V2ZW50VGFyZ2V0Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMTQwNiw3ICsyMTQwNCw2IEBACiAJCQkJQTdEMDMx OEQwRTkzNTQwMzAwRTI0QUNEIC8qIEpTSW1hZ2VEYXRhQ3VzdG9tLmNwcCAqLywKIAkJCQk3QTc0 RUNCQzEwMTgzOURBMDBCRjkzOUUgLyogSlNJbnNwZWN0b3JGcm9udGVuZEhvc3RDdXN0b20uY3Bw ICovLAogCQkJCUJDRTFDNDNGMEQ5ODMwRjQwMDNCMDJGMiAvKiBKU0xvY2F0aW9uQ3VzdG9tLmNw cCAqLywKLQkJCQk1RUE3MjVEMDFBQ0FCRDI3MDBFQUQxN0IgLyogSlNNZWRpYURldmljZXNDdXN0 b20uY3BwICovLAogCQkJCUFENzI2RkU3MTZEOUYyMDQwMDNBNEU2RCAvKiBKU01lZGlhTGlzdEN1 c3RvbS5oICovLAogCQkJCTA3QzU5QjZEMTdGNzk0RjYwMDBGQkNCQiAvKiBKU01lZGlhU291cmNl U3RhdGVzQ3VzdG9tLmNwcCAqLywKIAkJCQkwNzA1ODUxNjE3RkI0MEU5MDA1RjJCQ0IgLyogSlNN ZWRpYVN0cmVhbUNhcGFiaWxpdGllc0N1c3RvbS5jcHAgKi8sCkBAIC0yODk4NCw3ICsyODk4MSw2 IEBACiAJCQkJOEZBQzc3NEQxMTk4NzJDQjAwMTVBRTk0IC8qIEpTTWFpblRocmVhZEV4ZWNTdGF0 ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlDRDI3RjZFNTE0NTc2ODVBMDA3ODIwN0QgLyogSlNN ZWRpYUNvbnRyb2xsZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0RBQjZEMkQxN0M4MTRFRTAw QzYwQjM0IC8qIEpTTWVkaWFDb250cm9sc0hvc3QuY3BwIGluIFNvdXJjZXMgKi8sCi0JCQkJNUVB NzI1RDExQUNBQkQzODAwRUFEMTdCIC8qIEpTTWVkaWFEZXZpY2VzQ3VzdG9tLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUZEMjNBMTI1MTNGNUZBNTkwMEY2NzAwMSAvKiBKU01lZGlhRWxlbWVudEF1 ZGlvU291cmNlTm9kZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFNDQ2MTQxODBDRDY4MjY5MDBG QURBNzUgLyogSlNNZWRpYUVycm9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUNEQTk4REEzMTYw MTQ2NDEwMEZFQTNCMSAvKiBKU01lZGlhS2V5RXJyb3IuY3BwIGluIFNvdXJjZXMgKi8sCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTVByb21pc2UuaCBiL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NUHJvbWlzZS5oCmluZGV4IDA4ZGIyOWNiN2RiYWRh NTI3NjBkYmVhNDE3NTZlNzhlMjAzZjc2OWUuLmE4YWFkMDNjNzg0NjA1MjdlNDYxN2YyM2M3MDA4 NjE5NDUxNTY2NjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9N UHJvbWlzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NUHJvbWlzZS5o CkBAIC0yOCwxMSArMjgsMTAgQEAKIAogI2lmIEVOQUJMRShQUk9NSVNFUykKIAotI2luY2x1ZGUg IkpTQ3J5cHRvS2V5LmgiCi0jaW5jbHVkZSAiSlNDcnlwdG9LZXlQYWlyLmgiCiAjaW5jbHVkZSAi SlNET01CaW5kaW5nLmgiCiAjaW5jbHVkZSA8aGVhcC9TdHJvbmdJbmxpbmVzLmg+CiAjaW5jbHVk ZSA8cnVudGltZS9KU1Byb21pc2VEZWZlcnJlZC5oPgorI2luY2x1ZGUgPHd0Zi9PcHRpb25hbC5o PgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTg2LDYgKzg1LDMxIEBAIHByaXZhdGU6CiAg ICAgRGVmZXJyZWRXcmFwcGVyIG1fd3JhcHBlcjsKIH07CiAKK3RlbXBsYXRlPHR5cGVuYW1lIFZh bHVlLCB0eXBlbmFtZSBFcnJvcj4KK2NsYXNzIERPTVByb21pc2VXaXRoQ2FsbGJhY2sgeworcHVi bGljOgorICAgIERPTVByb21pc2VXaXRoQ2FsbGJhY2soRGVmZXJyZWRXcmFwcGVyJiYgd3JhcHBl cikgOiBtX3dyYXBwZXIoV1RGOjptb3ZlKHdyYXBwZXIpKSB7IH0KKyAgICBET01Qcm9taXNlV2l0 aENhbGxiYWNrKHN0ZDo6ZnVuY3Rpb248dm9pZChjb25zdCBWYWx1ZSYpPiByZXNvbHZlLCBzdGQ6 OmZ1bmN0aW9uPHZvaWQoY29uc3QgRXJyb3ImKT4gcmVqZWN0KQorICAgICAgICA6IG1fcmVzb2x2 ZUNhbGxiYWNrKFdURjo6bW92ZShyZXNvbHZlKSkKKyAgICAgICAgLCBtX3JlamVjdENhbGxiYWNr KFdURjo6bW92ZShyZWplY3QpKQorICAgIHsKKyAgICAgICAgQVNTRVJUKG1fcmVzb2x2ZUNhbGxi YWNrKTsKKyAgICAgICAgQVNTRVJUKG1fcmVqZWN0Q2FsbGJhY2spOworICAgIH0KKyAgICBleHBs aWNpdCBET01Qcm9taXNlV2l0aENhbGxiYWNrKERPTVByb21pc2VXaXRoQ2FsbGJhY2smJiBwcm9t aXNlKQorICAgICAgICA6IG1fd3JhcHBlcihXVEY6Om1vdmUocHJvbWlzZS5tX3dyYXBwZXIpKQor ICAgICAgICAsIG1fcmVzb2x2ZUNhbGxiYWNrKFdURjo6bW92ZShwcm9taXNlLm1fcmVzb2x2ZUNh bGxiYWNrKSkKKyAgICAgICAgLCBtX3JlamVjdENhbGxiYWNrKFdURjo6bW92ZShwcm9taXNlLm1f cmVqZWN0Q2FsbGJhY2spKSB7IH0KKworICAgIHZvaWQgcmVzb2x2ZShjb25zdCBWYWx1ZSYpOwor ICAgIHZvaWQgcmVqZWN0KGNvbnN0IEVycm9yJik7CisKK3ByaXZhdGU6CisgICAgT3B0aW9uYWw8 RE9NUHJvbWlzZTxWYWx1ZSwgRXJyb3I+PiBtX3dyYXBwZXI7CisgICAgc3RkOjpmdW5jdGlvbjx2 b2lkKGNvbnN0IFZhbHVlJik+IG1fcmVzb2x2ZUNhbGxiYWNrOworICAgIHN0ZDo6ZnVuY3Rpb248 dm9pZChjb25zdCBFcnJvciYpPiBtX3JlamVjdENhbGxiYWNrOworfTsKKwogdGVtcGxhdGU8Y2xh c3MgUmVzb2x2ZVJlc3VsdFR5cGU+CiBpbmxpbmUgdm9pZCBEZWZlcnJlZFdyYXBwZXI6OnJlc29s dmUoY29uc3QgUmVzb2x2ZVJlc3VsdFR5cGUmIHJlc3VsdCkKIHsKQEAgLTE5Niw2ICsyMjAsMjgg QEAgaW5saW5lIHZvaWQgRGVmZXJyZWRXcmFwcGVyOjpyZWplY3Q8U3RyaW5nPihjb25zdCBTdHJp bmcmIHJlc3VsdCkKICAgICByZWplY3QoKmV4ZWMsIGpzU3RyaW5nKGV4ZWMsIHJlc3VsdCkpOwog fQogCit0ZW1wbGF0ZTx0eXBlbmFtZSBWYWx1ZSwgdHlwZW5hbWUgRXJyb3I+CitpbmxpbmUgdm9p ZCBET01Qcm9taXNlV2l0aENhbGxiYWNrPFZhbHVlLCBFcnJvcj46OnJlc29sdmUoY29uc3QgVmFs dWUmIHZhbHVlKQoreworICAgIGlmIChtX3Jlc29sdmVDYWxsYmFjaykgeworICAgICAgICBtX3Jl c29sdmVDYWxsYmFjayh2YWx1ZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgQVNTRVJU KG1fd3JhcHBlcik7CisgICAgbV93cmFwcGVyLnZhbHVlKCkucmVzb2x2ZSh2YWx1ZSk7Cit9CisK K3RlbXBsYXRlPHR5cGVuYW1lIFZhbHVlLCB0eXBlbmFtZSBFcnJvcj4KK2lubGluZSB2b2lkIERP TVByb21pc2VXaXRoQ2FsbGJhY2s8VmFsdWUsIEVycm9yPjo6cmVqZWN0KGNvbnN0IEVycm9yJiBl cnJvcikKK3sKKyAgICBpZiAobV9yZWplY3RDYWxsYmFjaykgeworICAgICAgICBtX3JlamVjdENh bGxiYWNrKGVycm9yKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBBU1NFUlQobV93cmFw cGVyKTsKKyAgICBtX3dyYXBwZXIudmFsdWUoKS5yZWplY3QoZXJyb3IpOworfQorCiB9CiAKICNl bmRpZiAvLyBFTkFCTEUoUFJPTUlTRVMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy9qcy9KU01lZGlhRGV2aWNlc0N1c3RvbS5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDZiZDJhNzJjYjkxMGQxYTU5YmM3NmIzOWE0MWEwMmMxOTY1ZjU1YTQuLjAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvanMvSlNNZWRpYURldmljZXNDdXN0b20uY3BwCisrKyAvZGV2L251bGwKQEAgLTEsODQgKzAs MCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxNSBFcmljc3NvbiBBQi4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KLSAqCi0gKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAq Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgotICog ICAgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQotICogICAgZGlzdHJpYnV0aW9uLgotICogMy4gTmVpdGhlciB0aGUgbmFtZSBvZiBF cmljc3NvbiBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKLSAqICAgIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcwotICog ICAgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCi0g KgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMg QU5EIENPTlRSSUJVVE9SUwotICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKLSAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgotICogQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZ UklHSFQKLSAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLAotICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAotICogTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCi0gKiBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkKLSAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0KLSNpZiBFTkFCTEUoTUVESUFfU1RSRUFN KQotI2luY2x1ZGUgIkpTTWVkaWFEZXZpY2VzLmgiCi0KLSNpbmNsdWRlICJEaWN0aW9uYXJ5Lmgi Ci0jaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgotI2luY2x1ZGUgIkpTRE9NQmluZGluZy5oIgot I2luY2x1ZGUgIkpTRE9NUHJvbWlzZS5oIgotI2luY2x1ZGUgIkpTTWVkaWFTdHJlYW0uaCIKLSNp bmNsdWRlICJKU05hdmlnYXRvclVzZXJNZWRpYUVycm9yLmgiCi0jaW5jbHVkZSA8cnVudGltZS9F eGNlcHRpb24uaD4KLQotdXNpbmcgbmFtZXNwYWNlIEpTQzsKLQotbmFtZXNwYWNlIFdlYkNvcmUg ewotCi1KU1ZhbHVlIEpTTWVkaWFEZXZpY2VzOjpnZXRVc2VyTWVkaWEoRXhlY1N0YXRlKiBleGVj KQotewotICAgIEpTUHJvbWlzZURlZmVycmVkKiBwcm9taXNlRGVmZXJyZWQgPSBKU1Byb21pc2VE ZWZlcnJlZDo6Y3JlYXRlKGV4ZWMsIGdsb2JhbE9iamVjdCgpKTsKLSAgICBEZWZlcnJlZFdyYXBw ZXIgd3JhcHBlcihleGVjLCBnbG9iYWxPYmplY3QoKSwgcHJvbWlzZURlZmVycmVkKTsKLQotICAg IERpY3Rpb25hcnkgb3B0aW9ucyhleGVjLCBleGVjLT5hcmd1bWVudCgwKSk7Ci0gICAgaWYgKGV4 ZWMtPmhhZEV4Y2VwdGlvbigpKSB7Ci0gICAgICAgIEV4Y2VwdGlvbiogZXhjZXB0aW9uID0gZXhl Yy0+ZXhjZXB0aW9uKCk7Ci0gICAgICAgIGV4ZWMtPmNsZWFyRXhjZXB0aW9uKCk7Ci0gICAgICAg IHdyYXBwZXIucmVqZWN0KGV4Y2VwdGlvbi0+dmFsdWUoKSk7Ci0gICAgICAgIHJldHVybiBwcm9t aXNlRGVmZXJyZWQtPnByb21pc2UoKTsKLSAgICB9Ci0KLSAgICBpZiAoIW9wdGlvbnMuaXNPYmpl Y3QoKSkgewotICAgICAgICBKU1ZhbHVlIGVycm9yID0gY3JlYXRlVHlwZUVycm9yKGV4ZWMsICJG aXJzdCBhcmd1bWVudCBvZiBnZXRVc2VyTWVkaWEgbXVzdCBiZSBhIHZhbGlkIERpY3Rpb25hcnki KTsKLSAgICAgICAgd3JhcHBlci5yZWplY3QoZXJyb3IpOwotICAgICAgICByZXR1cm4gcHJvbWlz ZURlZmVycmVkLT5wcm9taXNlKCk7Ci0gICAgfQotCi0gICAgYXV0byByZXNvbHZlQ2FsbGJhY2sg PSBbd3JhcHBlcl0oTWVkaWFTdHJlYW0mIHN0cmVhbSkgbXV0YWJsZSB7Ci0gICAgICAgIHdyYXBw ZXIucmVzb2x2ZSgmc3RyZWFtKTsKLSAgICB9OwotICAgIGF1dG8gcmVqZWN0Q2FsbGJhY2sgPSBb d3JhcHBlcl0oTmF2aWdhdG9yVXNlck1lZGlhRXJyb3ImIGVycm9yKSBtdXRhYmxlIHsKLSAgICAg ICAgd3JhcHBlci5yZWplY3QoJmVycm9yKTsKLSAgICB9OwotCi0gICAgRXhjZXB0aW9uQ29kZSBl YyA9IDA7Ci0gICAgaW1wbCgpLmdldFVzZXJNZWRpYShvcHRpb25zLCBXVEY6Om1vdmUocmVzb2x2 ZUNhbGxiYWNrKSwgV1RGOjptb3ZlKHJlamVjdENhbGxiYWNrKSwgZWMpOwotICAgIGlmIChlYykK LSAgICAgICAgd3JhcHBlci5yZWplY3QoZWMpOwotCi0gICAgcmV0dXJuIHByb21pc2VEZWZlcnJl ZC0+cHJvbWlzZSgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJDb3JlCi0KLSNlbmRpZiAvLyBF TkFCTEUoTUVESUFfU1RSRUFNKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNTdWJ0bGVDcnlwdG9DdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMv SlNTdWJ0bGVDcnlwdG9DdXN0b20uY3BwCmluZGV4IDRkZjViMjYxYjY2NzRjZDM0YjQzZWUyYjIy M2Y5M2UxMzMxYThiMjQuLmQ4YzdmZjE1Nzg3M2Q3NWZkNzMzNzQ2ZGEzOWUzODliMTdmYjZkODgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTU3VidGxlQ3J5cHRvQ3Vz dG9tLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU1N1YnRsZUNyeXB0b0N1 c3RvbS5jcHAKQEAgLTM2LDYgKzM2LDggQEAKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1 ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJKU0NyeXB0b0FsZ29yaXRobURpY3Rpb25h cnkuaCIKKyNpbmNsdWRlICJKU0NyeXB0b0tleS5oIgorI2luY2x1ZGUgIkpTQ3J5cHRvS2V5UGFp ci5oIgogI2luY2x1ZGUgIkpTQ3J5cHRvS2V5U2VyaWFsaXphdGlvbkpXSy5oIgogI2luY2x1ZGUg IkpTQ3J5cHRvT3BlcmF0aW9uRGF0YS5oIgogI2luY2x1ZGUgIkpTRE9NUHJvbWlzZS5oIgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmlu ZGV4IDAyZjQ4MzAyMmUxNmMzZmU2MWQ4N2YyY2U1NGYyMDVhNzJkMDQ0MzkuLmQxYzRiZDcyYWRm MDY4MjZlNzhhMDE5NmNmMTQ5ZmRkYjhiOTkwZjIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0No YW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMiBAQAorMjAx NS0wNi0yMiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubi5mYWJsZXRAY3JmLmNhbm9uLmZyPgorCisg ICAgICAgIE1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEgc2hvdWxkIG1pZ3JhdGUgZnJvbSBjYWxs YmFja3MgdG8gRE9NUHJvbWlzZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTQ2MjAwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisK KyAgICAgICAgKiBmYXN0L21lZGlhc3RyZWFtL01lZGlhRGV2aWNlcy1nZXRVc2VyTWVkaWEtZXhw ZWN0ZWQudHh0OgorCiAyMDE1LTA2LTIyICBSeXVhbiBDaG9pICA8cnl1YW4uY2hvaUBuYXZlcmNv cnAuY29tPgogCiAgICAgICAgIFtFRkxdIEh5cGhlbmF0aW9uIGlzIG5vdCBzdXBwb3J0ZWQKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFEZXZpY2VzLWdldFVz ZXJNZWRpYS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L21lZGlhc3RyZWFtL01lZGlh RGV2aWNlcy1nZXRVc2VyTWVkaWEtZXhwZWN0ZWQudHh0CmluZGV4IGUwNTllMzFjZTBjMzlmOWY0 ZGU3ZWM4NTUxYzlhNDAzNjEyOWRhNTMuLjE5ZjViYjFlYzI3MzNiNmYxMTUzMTAxMTI1NTY1NWRm NDI4MjhlOGEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2Zhc3QvbWVkaWFzdHJlYW0vTWVkaWFE ZXZpY2VzLWdldFVzZXJNZWRpYS1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9t ZWRpYXN0cmVhbS9NZWRpYURldmljZXMtZ2V0VXNlck1lZGlhLWV4cGVjdGVkLnR4dApAQCAtNSw3 ICs1LDcgQEAgT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNz YWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUKIAogUEFTUyB0eXBlb2YgbmF2aWdhdG9y Lm1lZGlhRGV2aWNlcy53ZWJraXRHZXRVc2VyTWVkaWEgaXMgJ3VuZGVmaW5lZCcKIFBBU1MgbmF2 aWdhdG9yLm1lZGlhRGV2aWNlcy5nZXRVc2VyTWVkaWEoe2F1ZGlvOnRydWV9KS50aGVuKGdvdFN0 cmVhbTEpOyBkaWQgbm90IHRocm93IGV4Y2VwdGlvbi4KLVBBU1MgbmF2aWdhdG9yLm1lZGlhRGV2 aWNlcy5nZXRVc2VyTWVkaWEoKSByZWplY3RlZCB3aXRoIGVycm9yOiBUeXBlRXJyb3I6IEZpcnN0 IGFyZ3VtZW50IG9mIGdldFVzZXJNZWRpYSBtdXN0IGJlIGEgdmFsaWQgRGljdGlvbmFyeQorUEFT UyBuYXZpZ2F0b3IubWVkaWFEZXZpY2VzLmdldFVzZXJNZWRpYSgpIHJlamVjdGVkIHdpdGggZXJy b3I6IFR5cGVFcnJvcjogTm90IGVub3VnaCBhcmd1bWVudHMKIFBBU1MgIG5hdmlnYXRvci5tZWRp YURldmljZXMuZ2V0VXNlck1lZGlhKHt9KSByZWplY3RlZCB3aXRoIGVycm9yOiBFcnJvcjogTm90 U3VwcG9ydGVkRXJyb3I6IERPTSBFeGNlcHRpb24gOQogUEFTUyBTdHJlYW0gZ2VuZXJhdGVkLgog UEFTUyBzdHJlYW0uZ2V0QXVkaW9UcmFja3MoKS5sZW5ndGggaXMgMQo=