213555 2020-06-24 06:42:21 -0700 [WebXR] Implement WebXRSession::updateRenderState() 2020-08-14 10:31:30 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 208988 1 svillar svillar cdumez cgarcia darin esprehn+autocc ews-watchlist kondapallykalyan svillar webkit-bug-importer youennf zan zimmermann oldest_to_newest 1665717 0 svillar 2020-06-24 06:42:21 -0700 [WebXR] Implement WebXRSession::updateRenderState() 1665719 1 402648 svillar 2020-06-24 06:55:59 -0700 Created attachment 402648 Patch 1665726 2 402648 youennf 2020-06-24 07:23:53 -0700 Comment on attachment 402648 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=402648&action=review > Source/WebCore/Modules/webxr/WebXRRenderState.cpp:59 > + m_depth = other.m_depth; Would be better as m_depth(...), ... > Source/WebCore/Modules/webxr/WebXRRenderState.h:48 > + WebXRRenderState(const WebXRRenderState&); That is probably not great to have this one as a public constructor given this is a RefCounted object. Also, it might be best to pass the parameters, or have something like Ref<WebXRRenderState> clone() for instance > Source/WebCore/Modules/webxr/WebXRRenderState.h:59 > + RefPtr<WebXRWebGLLayer> baseLayer() const { return m_baseLayer; } WebXRWebGLLayer* > Source/WebCore/Modules/webxr/WebXRRenderState.h:60 > + void setBaseLayer(RefPtr<WebXRWebGLLayer> baseLayer) { m_baseLayer = baseLayer; } RefPtr<>&& and WTFMove 1665796 3 402648 darin 2020-06-24 11:02:25 -0700 Comment on attachment 402648 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=402648&action=review Looks OK, generally not sure what our strategy is to get all this right. Adding all this code without test coverage worries me. > Source/WebCore/Modules/webxr/WebXRRenderState.cpp:57 > +WebXRRenderState::WebXRRenderState(const WebXRRenderState& other) Can we just write this instead? WebXRRenderState::WebXRRenderState(const WebXRRenderState&) = default; I don’t see anything in the function that’s different from that. >> Source/WebCore/Modules/webxr/WebXRRenderState.h:48 >> + WebXRRenderState(const WebXRRenderState&); > > That is probably not great to have this one as a public constructor given this is a RefCounted object. > Also, it might be best to pass the parameters, or have something like Ref<WebXRRenderState> clone() for instance Yes, this should be private. > Source/WebCore/Modules/webxr/WebXRRenderState.h:57 > + void setInlineVerticalFieldOfView(double fieldOfView) { m_inlineVerticalFieldOfView = fieldOfView; } No way to set it back to null? >> Source/WebCore/Modules/webxr/WebXRRenderState.h:59 >> + RefPtr<WebXRWebGLLayer> baseLayer() const { return m_baseLayer; } > > WebXRWebGLLayer* Not so sure about that. Isn’t our new path to always return RefPtr as part of our long term security hardening? >> Source/WebCore/Modules/webxr/WebXRRenderState.h:60 >> + void setBaseLayer(RefPtr<WebXRWebGLLayer> baseLayer) { m_baseLayer = baseLayer; } > > RefPtr<>&& and WTFMove Given how we’re using it, a place where it seems we do have a RefPtr we can move, that seems a good choice. But, in general, setters like this can also just take WebXRWebGLLayer*. Can’t think of any case where we’d just want to take a RefPtr by value. > Source/WebCore/Modules/webxr/WebXRSession.cpp:127 > + m_pendingRenderState = makeRefPtr(new WebXRRenderState(*m_activeRenderState)); This is not a good pattern. We should be calling a create function in WebXRRenderState, not calling new directly here. Note that where we do call new directly, it should be makeRef(*new), not makeRefPtr(new). > Source/WebCore/Modules/webxr/WebXRSession.idl:42 > + [MayThrowException] void updateRenderState(optional XRRenderStateInit stateInit); I’m a little surprised that [MayThrowException] is still needed. We should improve IDL code generation so it’s not. > Source/WebCore/Modules/webxr/WebXRWebGLLayer.h:75 > + const WebXRSession& session() { return m_session.get(); } The call to ".get()" here should be unnecessary. > Source/WebCore/Modules/webxr/XRRenderStateInit.h:42 > + Optional<Vector<RefPtr<WebXRLayer>>> layers; Should be Vector<Ref>, not Vector<RefPtr>. > Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 > WebXRWebGLLayer? baseLayer; > + sequence<WebXRLayer>? layers; I am surprised that these "?" are needed in a dictionary. In a dictionary, optional is the default. What function does the "?" serve? Something about null rather than omitting? Do we have test coverage? Adding all this code with no tests seems risky. We could have a lot of things wrong and we wouldn’t know. 1665820 4 402648 svillar 2020-06-24 12:13:49 -0700 Comment on attachment 402648 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=402648&action=review Thanks Darin & Youenn! >> Source/WebCore/Modules/webxr/WebXRRenderState.cpp:57 >> +WebXRRenderState::WebXRRenderState(const WebXRRenderState& other) > > Can we just write this instead? > > WebXRRenderState::WebXRRenderState(const WebXRRenderState&) = default; > > I don’t see anything in the function that’s different from that. Hmm indeed. >>> Source/WebCore/Modules/webxr/WebXRRenderState.h:48 >>> + WebXRRenderState(const WebXRRenderState&); >> >> That is probably not great to have this one as a public constructor given this is a RefCounted object. >> Also, it might be best to pass the parameters, or have something like Ref<WebXRRenderState> clone() for instance > > Yes, this should be private. ACK. >> Source/WebCore/Modules/webxr/WebXRRenderState.h:57 >> + void setInlineVerticalFieldOfView(double fieldOfView) { m_inlineVerticalFieldOfView = fieldOfView; } > > No way to set it back to null? I don't see why we'd like to do that. The getter returns an Optional because it might not be set, but once set it should not even be changed. >>> Source/WebCore/Modules/webxr/WebXRRenderState.h:59 >>> + RefPtr<WebXRWebGLLayer> baseLayer() const { return m_baseLayer; } >> >> WebXRWebGLLayer* > > Not so sure about that. Isn’t our new path to always return RefPtr as part of our long term security hardening? Let's keep it as it then. >>> Source/WebCore/Modules/webxr/WebXRRenderState.h:60 >>> + void setBaseLayer(RefPtr<WebXRWebGLLayer> baseLayer) { m_baseLayer = baseLayer; } >> >> RefPtr<>&& and WTFMove > > Given how we’re using it, a place where it seems we do have a RefPtr we can move, that seems a good choice. But, in general, setters like this can also just take WebXRWebGLLayer*. Can’t think of any case where we’d just want to take a RefPtr by value. I'll take that into account. >> Source/WebCore/Modules/webxr/WebXRSession.cpp:127 >> + m_pendingRenderState = makeRefPtr(new WebXRRenderState(*m_activeRenderState)); > > This is not a good pattern. We should be calling a create function in WebXRRenderState, not calling new directly here. > > Note that where we do call new directly, it should be makeRef(*new), not makeRefPtr(new). Yeah, makes total sense. >> Source/WebCore/Modules/webxr/WebXRWebGLLayer.h:75 >> + const WebXRSession& session() { return m_session.get(); } > > The call to ".get()" here should be unnecessary. Correct. >> Source/WebCore/Modules/webxr/XRRenderStateInit.h:42 >> + Optional<Vector<RefPtr<WebXRLayer>>> layers; > > Should be Vector<Ref>, not Vector<RefPtr>. Indeed. >> Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 >> + sequence<WebXRLayer>? layers; > > I am surprised that these "?" are needed in a dictionary. In a dictionary, optional is the default. What function does the "?" serve? Something about null rather than omitting? Do we have test coverage? Adding all this code with no tests seems risky. We could have a lot of things wrong and we wouldn’t know. Yeah, the "?" is the nullable type https://heycam.github.io/webidl/#dfn-nullable-type. Regarding test coverage, there is no specific tests in the imported WPT for this code. I was planning to add a test to WPT and then import it. Would you be OK landing this and then importing the test in a follow-up or would it be better to wait until we have the test? 1665826 5 402648 darin 2020-06-24 12:33:47 -0700 Comment on attachment 402648 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=402648&action=review >>> Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 >>> + sequence<WebXRLayer>? layers; >> >> I am surprised that these "?" are needed in a dictionary. In a dictionary, optional is the default. What function does the "?" serve? Something about null rather than omitting? Do we have test coverage? Adding all this code with no tests seems risky. We could have a lot of things wrong and we wouldn’t know. > > Yeah, the "?" is the nullable type https://heycam.github.io/webidl/#dfn-nullable-type. > > Regarding test coverage, there is no specific tests in the imported WPT for this code. I was planning to add a test to WPT and then import it. Would you be OK landing this and then importing the test in a follow-up or would it be better to wait until we have the test? Here’s my thinking: If we aren’t landing the test at the same time as the code, or using a test that’s already checked in, I can’t check to see that we test both omitting layers and passing null for layers. It’s those kinds of questions that come to mind when the code is new. When the code is already there, it’s super-hard to spot what might be included or omitted in tests. I’m really not sure what the tradeoffs are here, and the best way for us to work. Whatl I care about is where we *end up*, not the intermediate states, but with this strategy, how will we remember to be thorough about testing? In the context of fuzzer-founded crashes I’ve recently encountered web platform tests that were not all that comprehensive in edge case testing. And I’d really like to help with that if I can. It’s easier when reading code and then looking at tests to see what the code does that isn’t verified by tests. Similarly it’s easier to see when reading specifications and looking at tests to see what the specification states that isn’t verified by tests. 1665838 6 svillar 2020-06-24 13:01:11 -0700 (In reply to Darin Adler from comment #5) > Comment on attachment 402648 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=402648&action=review > > >>> Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 > >>> + sequence<WebXRLayer>? layers; > >> > >> I am surprised that these "?" are needed in a dictionary. In a dictionary, optional is the default. What function does the "?" serve? Something about null rather than omitting? Do we have test coverage? Adding all this code with no tests seems risky. We could have a lot of things wrong and we wouldn’t know. > > > > Yeah, the "?" is the nullable type https://heycam.github.io/webidl/#dfn-nullable-type. > > > > Regarding test coverage, there is no specific tests in the imported WPT for this code. I was planning to add a test to WPT and then import it. Would you be OK landing this and then importing the test in a follow-up or would it be better to wait until we have the test? > > Here’s my thinking: > > If we aren’t landing the test at the same time as the code, or using a test > that’s already checked in, I can’t check to see that we test both omitting > layers and passing null for layers. It’s those kinds of questions that come > to mind when the code is new. When the code is already there, it’s > super-hard to spot what might be included or omitted in tests. > > I’m really not sure what the tradeoffs are here, and the best way for us to > work. Whatl I care about is where we *end up*, not the intermediate states, > but with this strategy, how will we remember to be thorough about testing? > In the context of fuzzer-founded crashes I’ve recently encountered web > platform tests that were not all that comprehensive in edge case testing. > And I’d really like to help with that if I can. It’s easier when reading > code and then looking at tests to see what the code does that isn’t verified > by tests. Similarly it’s easier to see when reading specifications and > looking at tests to see what the specification states that isn’t verified by > tests. Fair enough, I was not comfortable either landing it without proper test coverage. I'll work on the test then. It's generally easier from the WebKit POV to land it first in WPT and then import it (exporting is still far from automatic), so I guess that's the approach I'll follow. 1675572 7 zimmermann 2020-07-28 04:35:12 -0700 What's the status here? 1676768 8 svillar 2020-07-31 01:52:40 -0700 (In reply to Nikolas Zimmermann from comment #7) > What's the status here? We have to land & then import https://github.com/web-platform-tests/wpt/pull/24415 first. It's the test. 1679950 9 406505 svillar 2020-08-13 03:10:07 -0700 Created attachment 406505 Patch 1679951 10 svillar 2020-08-13 03:12:03 -0700 Test was imported in bug 215224 so we do have now a test for this change. Darin, mind taking another look please? 1680009 11 406505 darin 2020-08-13 09:48:16 -0700 Comment on attachment 406505 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=406505&action=review > Source/WebCore/Modules/webxr/WebXRRenderState.cpp:63 > +WebXRRenderState::WebXRRenderState(const WebXRRenderState& other) > { > - return m_outputCanvas.get(); > + m_baseLayer = other.baseLayer(); > + m_depth = other.m_depth; > + m_inlineVerticalFieldOfView = other.m_inlineVerticalFieldOfView; > } Would be nicer to use construction syntax rather than assignment. > Source/WebCore/Modules/webxr/WebXRRenderState.h:31 > +#include "HTMLCanvasElement.h" > +#include "WebXRWebGLLayer.h" Seems like if you add includes of these headers you can remove some (many?) of the others. > Source/WebCore/Modules/webxr/WebXRRenderState.h:50 > + Ref<WebXRRenderState> clone(); I think this should be const. Do you agree? > Source/WebCore/Modules/webxr/WebXRRenderState.h:62 > + void setBaseLayer(WebXRWebGLLayer* baseLayer) { m_baseLayer = WTFMove(baseLayer); } WTFMove has no effect on a raw pointer, so please omit it. > Source/WebCore/Modules/webxr/WebXRRenderState.h:65 > + HTMLCanvasElement* outputCanvas() const { return m_outputCanvas.get(); } > private: We’d normally have a blank line here. > Source/WebCore/Modules/webxr/WebXRRenderState.h:66 > explicit WebXRRenderState(Optional<double>&& fieldOfView); Seems unnecessary to use && for an optional of a scalar. Move is not more efficient than copy. > Source/WebCore/Modules/webxr/WebXRSession.cpp:90 > +static inline bool isImmersive(XRSessionMode mode) No real need to write "inline" here. Obviously we want this inlined, but I don’t think the keyword has effect on whether it is. > Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 > WebXRWebGLLayer? baseLayer; > + sequence<WebXRLayer>? layers; Everything in a dictionary is optional by default. So I am puzzled by the "?" on these two lines. 1680238 12 406505 svillar 2020-08-14 01:16:58 -0700 Comment on attachment 406505 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=406505&action=review Thanks for the review! >> Source/WebCore/Modules/webxr/WebXRRenderState.cpp:63 >> } > > Would be nicer to use construction syntax rather than assignment. OK >> Source/WebCore/Modules/webxr/WebXRRenderState.h:31 >> +#include "WebXRWebGLLayer.h" > > Seems like if you add includes of these headers you can remove some (many?) of the others. Good point. >> Source/WebCore/Modules/webxr/WebXRRenderState.h:50 >> + Ref<WebXRRenderState> clone(); > > I think this should be const. Do you agree? Sure! >> Source/WebCore/Modules/webxr/WebXRRenderState.h:62 >> + void setBaseLayer(WebXRWebGLLayer* baseLayer) { m_baseLayer = WTFMove(baseLayer); } > > WTFMove has no effect on a raw pointer, so please omit it. Right, it was a && but then I replaced it by a raw pointer and forgot about the move >> Source/WebCore/Modules/webxr/WebXRRenderState.h:66 >> explicit WebXRRenderState(Optional<double>&& fieldOfView); > > Seems unnecessary to use && for an optional of a scalar. Move is not more efficient than copy. Right. >> Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 >> + sequence<WebXRLayer>? layers; > > Everything in a dictionary is optional by default. So I am puzzled by the "?" on these two lines. I think we talked about that before. The "?" specifies that the type is nullable. As you said it's optional by default but apart from that we're specifying that null is a valid value for the type. WebIDL distinguish between - optional: a valid value would be "undefined" - nullable: a valid value would be null 1680239 13 svillar 2020-08-14 01:24:55 -0700 Committed r265665: <https://trac.webkit.org/changeset/265665> 1680240 14 webkit-bug-importer 2020-08-14 01:25:20 -0700 <rdar://problem/67054734> 1680318 15 406505 darin 2020-08-14 10:31:30 -0700 Comment on attachment 406505 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=406505&action=review >>> Source/WebCore/Modules/webxr/XRRenderStateInit.idl:34 >>> + sequence<WebXRLayer>? layers; >> >> Everything in a dictionary is optional by default. So I am puzzled by the "?" on these two lines. > > I think we talked about that before. The "?" specifies that the type is nullable. As you said it's optional by default but apart from that we're specifying that null is a valid value for the type. WebIDL distinguish between > - optional: a valid value would be "undefined" > - nullable: a valid value would be null We have tests that fail when we take out either one of those "?" 402648 2020-06-24 06:55:59 -0700 2020-06-24 11:02:25 -0700 Patch bug-213555-20200624155557.patch text/plain 12974 svillar U3VidmVyc2lvbiBSZXZpc2lvbjogMjYzNDUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGVhZDZlYTIzYTUzNzI1 NWI0ZmE1MTFlZTJlODJiNTI4MmE2MDc1ZS4uOTA5NjAxYTQ0ZGE2ZDI1YWJlZTkxODVhMWVjNmJm MzgyNzEyMzkwNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ1IEBACisyMDIwLTA2LTI0ICBTZXJn aW8gVmlsbGFyIFNlbmluICA8c3ZpbGxhckBpZ2FsaWEuY29tPgorCisgICAgICAgIFtXZWJYUl0g SW1wbGVtZW50IFdlYlhSU2Vzc2lvbjo6dXBkYXRlUmVuZGVyU3RhdGUoKQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEzNTU1CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgYW4gaW1wbGVtZW50YXRp b24gd2hpY2ggbWF0Y2hlcyB0aGUgY3VycmVudCBzcGVjcy4gVGhlIHVwZGF0ZVJlbmRlclN0YXRl KCkgaXMgc3BlY2lhbGx5IHVzZWZ1bCB0byBzZXQKKyAgICAgICAgdGhlIGJhc2UgbGF5ZXIgaW4g dGhlIHNlc3Npb24gd2hlcmUgV2ViWFIgY29udGVudHMgd291bGQgYmUgcmVuZGVyZWQuIEF1dGhv cnMgd291bGQgbm9ybWFsbHkgZG86CisKKyAgICAgICAgZ2xDYW52YXMuZ2V0Q29udGV4dCgid2Vi Z2wiKS5tYWtlWFJDb21wYXRpYmxlKCkudGhlbigoKSA9PiB7CisgICAgICAgICAgICB4clNlc3Np b24udXBkYXRlUmVuZGVyU3RhdGUoeyBiYXNlTGF5ZXI6IG5ldyBYUldlYkdMTGF5ZXIoeHJTZXNz aW9uLCBnbCkgfSk7CisgICAgICAgIH0pOworCisgICAgICAgIFRoZSBYUlJlbmRlclN0YXRlSW5p dCBoYXMgYWxzbyBiZWVuIHVwZGF0ZWQgdG8gdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIHNwZWNzLgor CisgICAgICAgICogTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OldlYlhSUmVuZGVyU3RhdGUpOgorICAgICAgICAo V2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6ZGVwdGhOZWFyIGNvbnN0KTogSW5saW5lZC4KKyAg ICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OmRlcHRoRmFyIGNvbnN0KTogRGl0dG8u CisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRlOjppbmxpbmVWZXJ0aWNhbEZpZWxk T2ZWaWV3IGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRl OjpiYXNlTGF5ZXIgY29uc3QpOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhS UmVuZGVyU3RhdGUuaDoKKyAgICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OmRlcHRo TmVhciBjb25zdCk6IElubGluZWQuCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRl OjpzZXREZXB0aE5lYXIpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3Rh dGU6OmRlcHRoRmFyIGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRl clN0YXRlOjpzZXREZXB0aEZhcik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJSZW5k ZXJTdGF0ZTo6aW5saW5lVmVydGljYWxGaWVsZE9mVmlldyBjb25zdCk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6c2V0SW5saW5lVmVydGljYWxGaWVsZE9mVmll dyk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6YmFzZUxheWVy IGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRlOjpzZXRC YXNlTGF5ZXIpOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhSU2Vzc2lvbi5j cHA6CisgICAgICAgIChXZWJDb3JlOjppc0ltbWVyc2l2ZSk6CisgICAgICAgIChXZWJDb3JlOjpX ZWJYUlNlc3Npb246OnVwZGF0ZVJlbmRlclN0YXRlKTogSW1wbGVtZW50ZWQuCisgICAgICAgIChX ZWJDb3JlOjpXZWJYUlNlc3Npb246OnJlZmVyZW5jZVNwYWNlSXNTdXBwb3J0ZWQgY29uc3QpOgor ICAgICAgICAqIE1vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmg6IHVwZGF0ZVJlbmRlclN0YXRl IG1heSB0aHJvdyBleGNlcHRpb24uCisgICAgICAgICogTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Np b24uaWRsOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhSV2ViR0xMYXllci5o OgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJXZWJHTExheWVyOjpzZXNzaW9uKTogQWRkZWQuCisg ICAgICAgICogTW9kdWxlcy93ZWJ4ci9YUlJlbmRlclN0YXRlSW5pdC5oOiBBZGRlZCBsYXllcnMg YW5kIG1hZGUgbWFueSBhdHRyaWJ1dGVzIG9wdGlvbmFsLgorICAgICAgICAqIE1vZHVsZXMvd2Vi eHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsOiBEaXR0by4KKwogMjAyMC0wNi0yNCAgQWxleGV5IFNo dmF5a2EgIDxzaHZhaWthbGVzaEBnbWFpbC5jb20+CiAKICAgICAgICAgUmVtb3ZlIFtDYWxsYmFj a05lZWRzT3BlcmF0b3JFcXVhbF0gZXh0ZW5kZWQgYXR0cmlidXRlCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSUmVuZGVyU3RhdGUuY3BwIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmNwcAppbmRleCBjMGY4OTViMmIx YzU5Njc2YmRjZjU4MzVjMDhmNGJiMDZlMDg0N2MwLi5iYjljMTM5YWMzZjFmNTM2MzQ1YTc2NDBk MTE5ZjNhMjY0NjQ1OTc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhy L1dlYlhSUmVuZGVyU3RhdGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIv V2ViWFJSZW5kZXJTdGF0ZS5jcHAKQEAgLTI4LDcgKzI4LDYgQEAKIAogI2lmIEVOQUJMRShXRUJY UikKIAotI2luY2x1ZGUgIldlYlhSV2ViR0xMYXllci5oIgogI2luY2x1ZGUgIlhSUmVuZGVyU3Rh dGVJbml0LmgiCiAjaW5jbHVkZSA8d3RmL0lzb01hbGxvY0lubGluZXMuaD4KICNpbmNsdWRlIDx3 dGYvTWF0aEV4dHJhcy5oPgpAQCAtNTUsMjQgKzU0LDExIEBAIFdlYlhSUmVuZGVyU3RhdGU6Oldl YlhSUmVuZGVyU3RhdGUoY29uc3QgWFJSZW5kZXJTdGF0ZUluaXQmKQogCiBXZWJYUlJlbmRlclN0 YXRlOjp+V2ViWFJSZW5kZXJTdGF0ZSgpID0gZGVmYXVsdDsKIAotZG91YmxlIFdlYlhSUmVuZGVy U3RhdGU6OmRlcHRoTmVhcigpIGNvbnN0CitXZWJYUlJlbmRlclN0YXRlOjpXZWJYUlJlbmRlclN0 YXRlKGNvbnN0IFdlYlhSUmVuZGVyU3RhdGUmIG90aGVyKQogewotICAgIHJldHVybiBtX2RlcHRo Lm5lYXI7Ci19Ci0KLWRvdWJsZSBXZWJYUlJlbmRlclN0YXRlOjpkZXB0aEZhcigpIGNvbnN0Ci17 Ci0gICAgcmV0dXJuIG1fZGVwdGguZmFyOwotfQotCi1PcHRpb25hbDxkb3VibGU+IFdlYlhSUmVu ZGVyU3RhdGU6OmlubGluZVZlcnRpY2FsRmllbGRPZlZpZXcoKSBjb25zdAotewotICAgIHJldHVy biBtX2lubGluZVZlcnRpY2FsRmllbGRPZlZpZXc7Ci19Ci0KLVJlZlB0cjxXZWJYUldlYkdMTGF5 ZXI+IFdlYlhSUmVuZGVyU3RhdGU6OmJhc2VMYXllcigpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1f YmFzZUxheWVyOworICAgIG1fZGVwdGggPSBvdGhlci5tX2RlcHRoOworICAgIG1fYmFzZUxheWVy ID0gb3RoZXIubV9iYXNlTGF5ZXI7CisgICAgbV9pbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3ID0g b3RoZXIubV9pbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3OwogfQogCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSUmVu ZGVyU3RhdGUuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJSZW5kZXJTdGF0 ZS5oCmluZGV4IDk1ZTk2NTZiMTIyYmIzM2FjNGM2ODllMGFhODIwNzZlZjQ3YzhjZTIuLjg5YzM2 OWZmZmI2YjU3NTc4MjhlZTQyNDA1OTY3OGU1NzNmMDNiODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJSZW5kZXJTdGF0ZS5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2VieHIvV2ViWFJSZW5kZXJTdGF0ZS5oCkBAIC0yNyw2ICsyNyw3IEBACiAK ICNpZiBFTkFCTEUoV0VCWFIpCiAKKyNpbmNsdWRlICJXZWJYUldlYkdMTGF5ZXIuaCIKICNpbmNs dWRlICJYUlNlc3Npb25Nb2RlLmgiCiAjaW5jbHVkZSA8d3RmL0lzb01hbGxvYy5oPgogI2luY2x1 ZGUgPHd0Zi9PcHRpb25hbC5oPgpAQCAtMzYsNyArMzcsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKLWNsYXNzIFdlYlhSV2ViR0xMYXllcjsKIHN0cnVjdCBYUlJlbmRlclN0YXRlSW5pdDsK IAogY2xhc3MgV2ViWFJSZW5kZXJTdGF0ZSA6IHB1YmxpYyBSZWZDb3VudGVkPFdlYlhSUmVuZGVy U3RhdGU+IHsKQEAgLTQ1LDEwICs0NSwxOSBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFJlZjxXZWJY UlJlbmRlclN0YXRlPiBjcmVhdGUoWFJTZXNzaW9uTW9kZSk7CiAgICAgfldlYlhSUmVuZGVyU3Rh dGUoKTsKIAotICAgIGRvdWJsZSBkZXB0aE5lYXIoKSBjb25zdDsKLSAgICBkb3VibGUgZGVwdGhG YXIoKSBjb25zdDsKLSAgICBPcHRpb25hbDxkb3VibGU+IGlubGluZVZlcnRpY2FsRmllbGRPZlZp ZXcoKSBjb25zdDsKLSAgICBSZWZQdHI8V2ViWFJXZWJHTExheWVyPiBiYXNlTGF5ZXIoKSBjb25z dDsKKyAgICBXZWJYUlJlbmRlclN0YXRlKGNvbnN0IFdlYlhSUmVuZGVyU3RhdGUmKTsKKworICAg IGRvdWJsZSBkZXB0aE5lYXIoKSBjb25zdCB7IHJldHVybiBtX2RlcHRoLm5lYXI7IH0KKyAgICB2 b2lkIHNldERlcHRoTmVhcihkb3VibGUgbmVhcikgeyBtX2RlcHRoLm5lYXIgPSBuZWFyOyB9CisK KyAgICBkb3VibGUgZGVwdGhGYXIoKSBjb25zdCB7IHJldHVybiBtX2RlcHRoLmZhcjsgfQorICAg IHZvaWQgc2V0RGVwdGhGYXIoZG91YmxlIGZhcikgeyBtX2RlcHRoLmZhciA9IGZhcjsgfTsKKwor ICAgIE9wdGlvbmFsPGRvdWJsZT4gaW5saW5lVmVydGljYWxGaWVsZE9mVmlldygpIGNvbnN0IHsg cmV0dXJuIG1faW5saW5lVmVydGljYWxGaWVsZE9mVmlldzsgfQorICAgIHZvaWQgc2V0SW5saW5l VmVydGljYWxGaWVsZE9mVmlldyhkb3VibGUgZmllbGRPZlZpZXcpIHsgbV9pbmxpbmVWZXJ0aWNh bEZpZWxkT2ZWaWV3ID0gZmllbGRPZlZpZXc7IH0KKworICAgIFJlZlB0cjxXZWJYUldlYkdMTGF5 ZXI+IGJhc2VMYXllcigpIGNvbnN0IHsgcmV0dXJuIG1fYmFzZUxheWVyOyB9CisgICAgdm9pZCBz ZXRCYXNlTGF5ZXIoUmVmUHRyPFdlYlhSV2ViR0xMYXllcj4gYmFzZUxheWVyKSB7IG1fYmFzZUxh eWVyID0gYmFzZUxheWVyOyB9CiAKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgV2ViWFJSZW5kZXJT dGF0ZShPcHRpb25hbDxkb3VibGU+JiYgZmllbGRPZlZpZXcpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uY3BwIGIvU291cmNlL1dlYkNvcmUv TW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uY3BwCmluZGV4IDhjNjYyY2NlZjMyZWFjMjdlMDVm ZDJkODY4MzA4MDgwOTE1OGE0YzkuLjBlZWI5NzJjZjlhZmJhYjVhMTIzYzY2MzEwZTQ5OGYxYjM0 NzY5NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNz aW9uLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSU2Vzc2lvbi5j cHAKQEAgLTMzLDcgKzMzLDkgQEAKICNpbmNsdWRlICJXZWJYUkZyYW1lLmgiCiAjaW5jbHVkZSAi V2ViWFJTeXN0ZW0uaCIKICNpbmNsdWRlICJYUkZyYW1lUmVxdWVzdENhbGxiYWNrLmgiCisjaW5j bHVkZSAiWFJSZW5kZXJTdGF0ZUluaXQuaCIKICNpbmNsdWRlIDx3dGYvSXNvTWFsbG9jSW5saW5l cy5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBA IC04Niw4ICs4OCw2MiBAQCBjb25zdCBXZWJYUklucHV0U291cmNlQXJyYXkmIFdlYlhSU2Vzc2lv bjo6aW5wdXRTb3VyY2VzKCkgY29uc3QKICAgICByZXR1cm4gKm1faW5wdXRTb3VyY2VzOwogfQog Ci12b2lkIFdlYlhSU2Vzc2lvbjo6dXBkYXRlUmVuZGVyU3RhdGUoY29uc3QgWFJSZW5kZXJTdGF0 ZUluaXQmKQorc3RhdGljIGlubGluZSBib29sIGlzSW1tZXJzaXZlKFhSU2Vzc2lvbk1vZGUgbW9k ZSkKIHsKKyAgICByZXR1cm4gbW9kZSA9PSBYUlNlc3Npb25Nb2RlOjpJbW1lcnNpdmVBciB8fCBt b2RlID09IFhSU2Vzc2lvbk1vZGU6OkltbWVyc2l2ZVZyOworfQorCisvLyBodHRwczovL2ltbWVy c2l2ZS13ZWIuZ2l0aHViLmlvL3dlYnhyLyNkb20teHJzZXNzaW9uLXVwZGF0ZXJlbmRlcnN0YXRl CitFeGNlcHRpb25Pcjx2b2lkPiBXZWJYUlNlc3Npb246OnVwZGF0ZVJlbmRlclN0YXRlKGNvbnN0 IFhSUmVuZGVyU3RhdGVJbml0JiBuZXdTdGF0ZSkKK3sKKyAgICAvLyAxLiBMZXQgc2Vzc2lvbiBi ZSB0aGlzLgorICAgIC8vIDIuIElmIHNlc3Npb24ncyBlbmRlZCB2YWx1ZSBpcyB0cnVlLCB0aHJv dyBhbiBJbnZhbGlkU3RhdGVFcnJvciBhbmQgYWJvcnQgdGhlc2Ugc3RlcHMuCisgICAgaWYgKG1f ZW5kZWQpCisgICAgICAgIHJldHVybiBFeGNlcHRpb24geyBJbnZhbGlkU3RhdGVFcnJvciB9Owor CisgICAgLy8gMy4gSWYgbmV3U3RhdGUncyBiYXNlTGF5ZXIgd2FzIGNyZWF0ZWQgd2l0aCBhbiBY UlNlc3Npb24gb3RoZXIgdGhhbiBzZXNzaW9uLAorICAgIC8vICAgIHRocm93IGFuIEludmFsaWRT dGF0ZUVycm9yIGFuZCBhYm9ydCB0aGVzZSBzdGVwcy4KKyAgICBpZiAoJm5ld1N0YXRlLmJhc2VM YXllci0+c2Vzc2lvbigpICE9IHRoaXMpCisgICAgICAgIHJldHVybiBFeGNlcHRpb24geyBJbnZh bGlkU3RhdGVFcnJvciB9OworCisgICAgLy8gNC4gSWYgbmV3U3RhdGUncyBpbmxpbmVWZXJ0aWNh bEZpZWxkT2ZWaWV3IGlzIHNldCBhbmQgc2Vzc2lvbiBpcyBhbiBpbW1lcnNpdmUgc2Vzc2lvbiwK KyAgICAvLyAgICB0aHJvdyBhbiBJbnZhbGlkU3RhdGVFcnJvciBhbmQgYWJvcnQgdGhlc2Ugc3Rl cHMuCisgICAgaWYgKG5ld1N0YXRlLmlubGluZVZlcnRpY2FsRmllbGRPZlZpZXcgJiYgaXNJbW1l cnNpdmUobV9tb2RlKSkKKyAgICAgICAgcmV0dXJuIEV4Y2VwdGlvbiB7IEludmFsaWRTdGF0ZUVy cm9yIH07CisKKyAgICAvLyA1LiBJZiBub25lIG9mIG5ld1N0YXRlJ3MgZGVwdGhOZWFyLCBkZXB0 aEZhciwgaW5saW5lVmVydGljYWxGaWVsZE9mVmlldywgYmFzZUxheWVyLAorICAgIC8vICAgIGxh eWVycyBhcmUgc2V0LCBhYm9ydCB0aGVzZSBzdGVwcy4KKyAgICBpZiAoIW5ld1N0YXRlLmRlcHRo TmVhciAmJiAhbmV3U3RhdGUuZGVwdGhGYXIgJiYgIW5ld1N0YXRlLmlubGluZVZlcnRpY2FsRmll bGRPZlZpZXcgJiYgIW5ld1N0YXRlLmJhc2VMYXllciAmJiAhbmV3U3RhdGUubGF5ZXJzKQorICAg ICAgICByZXR1cm4geyB9OworCisgICAgLy8gNi4gUnVuIHVwZGF0ZSB0aGUgcGVuZGluZyBsYXll cnMgc3RhdGUgd2l0aCBzZXNzaW9uIGFuZCBuZXdTdGF0ZS4KKyAgICAvLyBodHRwczovL2ltbWVy c2l2ZS13ZWIuZ2l0aHViLmlvL3dlYnhyLyN1cGRhdGUtdGhlLXBlbmRpbmctbGF5ZXJzLXN0YXRl CisgICAgaWYgKG5ld1N0YXRlLmxheWVycykKKyAgICAgICAgcmV0dXJuIEV4Y2VwdGlvbiB7IE5v dFN1cHBvcnRlZEVycm9yIH07CisKKyAgICAvLyA3LiBMZXQgYWN0aXZlU3RhdGUgYmUgc2Vzc2lv bidzIGFjdGl2ZSByZW5kZXIgc3RhdGUuCisgICAgLy8gOC4gSWYgc2Vzc2lvbidzIHBlbmRpbmcg cmVuZGVyIHN0YXRlIGlzIG51bGwsIHNldCBpdCB0byBhIGNvcHkgb2YgYWN0aXZlU3RhdGUuCisg ICAgaWYgKCFtX3BlbmRpbmdSZW5kZXJTdGF0ZSkKKyAgICAgICAgbV9wZW5kaW5nUmVuZGVyU3Rh dGUgPSBtYWtlUmVmUHRyKG5ldyBXZWJYUlJlbmRlclN0YXRlKCptX2FjdGl2ZVJlbmRlclN0YXRl KSk7CisKKyAgICAvLyA5LiBJZiBuZXdTdGF0ZSdzIGRlcHRoTmVhciB2YWx1ZSBpcyBzZXQsIHNl dCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3RhdGUncyBkZXB0aE5lYXIgdG8gbmV3U3RhdGUn cyBkZXB0aE5lYXIuCisgICAgaWYgKG5ld1N0YXRlLmRlcHRoTmVhcikKKyAgICAgICAgbV9wZW5k aW5nUmVuZGVyU3RhdGUtPnNldERlcHRoTmVhcihuZXdTdGF0ZS5kZXB0aE5lYXIudmFsdWUoKSk7 CisKKyAgICAvLyAxMC4gSWYgbmV3U3RhdGUncyBkZXB0aEZhciB2YWx1ZSBpcyBzZXQsIHNldCBz ZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3RhdGUncyBkZXB0aEZhciB0byBuZXdTdGF0ZSdzIGRl cHRoRmFyLgorICAgIGlmIChuZXdTdGF0ZS5kZXB0aEZhcikKKyAgICAgICAgbV9wZW5kaW5nUmVu ZGVyU3RhdGUtPnNldERlcHRoRmFyKG5ld1N0YXRlLmRlcHRoRmFyLnZhbHVlKCkpOworCisgICAg Ly8gMTEuIElmIG5ld1N0YXRlJ3MgaW5saW5lVmVydGljYWxGaWVsZE9mVmlldyBpcyBzZXQsIHNl dCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3RhdGUncyBpbmxpbmVWZXJ0aWNhbEZpZWxkT2ZW aWV3CisgICAgLy8gICAgIHRvIG5ld1N0YXRlJ3MgaW5saW5lVmVydGljYWxGaWVsZE9mVmlldy4K KyAgICBpZiAobmV3U3RhdGUuaW5saW5lVmVydGljYWxGaWVsZE9mVmlldykKKyAgICAgICAgbV9w ZW5kaW5nUmVuZGVyU3RhdGUtPnNldElubGluZVZlcnRpY2FsRmllbGRPZlZpZXcobmV3U3RhdGUu aW5saW5lVmVydGljYWxGaWVsZE9mVmlldy52YWx1ZSgpKTsKKworICAgIC8vIDEyLiBJZiBuZXdT dGF0ZSdzIGJhc2VMYXllciBpcyBzZXQsIHNldCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3Rh dGUncyBiYXNlTGF5ZXIgdG8gbmV3U3RhdGUncyBiYXNlTGF5ZXIuCisgICAgaWYgKG5ld1N0YXRl LmJhc2VMYXllcikKKyAgICAgICAgbV9wZW5kaW5nUmVuZGVyU3RhdGUtPnNldEJhc2VMYXllcihu ZXdTdGF0ZS5iYXNlTGF5ZXIpOworCisgICAgcmV0dXJuIHsgfTsKIH0KIAogLy8gaHR0cHM6Ly9p bW1lcnNpdmUtd2ViLmdpdGh1Yi5pby93ZWJ4ci8jcmVmZXJlbmNlLXNwYWNlLWlzLXN1cHBvcnRl ZApAQCAtMTAxLDcgKzE1Nyw3IEBAIGJvb2wgV2ViWFJTZXNzaW9uOjpyZWZlcmVuY2VTcGFjZUlz U3VwcG9ydGVkKFhSUmVmZXJlbmNlU3BhY2VUeXBlIHR5cGUpIGNvbnN0CiAgICAgaWYgKHR5cGUg PT0gWFJSZWZlcmVuY2VTcGFjZVR5cGU6OlZpZXdlcikKICAgICAgICAgcmV0dXJuIHRydWU7CiAK LSAgICBib29sIGlzSW1tZXJzaXZlU2Vzc2lvbiA9IG1fbW9kZSA9PSBYUlNlc3Npb25Nb2RlOjpJ bW1lcnNpdmVBciB8fCBtX21vZGUgPT0gWFJTZXNzaW9uTW9kZTo6SW1tZXJzaXZlVnI7CisgICAg Ym9vbCBpc0ltbWVyc2l2ZVNlc3Npb24gPSBpc0ltbWVyc2l2ZShtX21vZGUpOwogICAgIGlmICh0 eXBlID09IFhSUmVmZXJlbmNlU3BhY2VUeXBlOjpMb2NhbCB8fCB0eXBlID09IFhSUmVmZXJlbmNl U3BhY2VUeXBlOjpMb2NhbEZsb29yKSB7CiAgICAgICAgIC8vIDMuIElmIHR5cGUgaXMgbG9jYWwg b3IgbG9jYWwtZmxvb3IsIGFuZCBzZXNzaW9uIGlzIGFuIGltbWVyc2l2ZSBzZXNzaW9uLCByZXR1 cm4gdHJ1ZS4KICAgICAgICAgaWYgKGlzSW1tZXJzaXZlU2Vzc2lvbikKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmggYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL3dlYnhyL1dlYlhSU2Vzc2lvbi5oCmluZGV4IDk4YjkyOTM5ODhmODI4NmJhN2Yx ZTcyZTA0MWFmNTQxMTBiY2FjMzAuLjE5MjNjMTQ2M2QwYTIzYTZmNWU2OWYxOWUxNDRlMjc3ZmM0 NzkwM2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNz aW9uLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uaApA QCAtNzAsNyArNzAsNyBAQCBwdWJsaWM6CiAgICAgY29uc3QgV2ViWFJSZW5kZXJTdGF0ZSYgcmVu ZGVyU3RhdGUoKSBjb25zdDsKICAgICBjb25zdCBXZWJYUklucHV0U291cmNlQXJyYXkmIGlucHV0 U291cmNlcygpIGNvbnN0OwogCi0gICAgdm9pZCB1cGRhdGVSZW5kZXJTdGF0ZShjb25zdCBYUlJl bmRlclN0YXRlSW5pdCYpOworICAgIEV4Y2VwdGlvbk9yPHZvaWQ+IHVwZGF0ZVJlbmRlclN0YXRl KGNvbnN0IFhSUmVuZGVyU3RhdGVJbml0Jik7CiAgICAgdm9pZCByZXF1ZXN0UmVmZXJlbmNlU3Bh Y2UoWFJSZWZlcmVuY2VTcGFjZVR5cGUsIFJlcXVlc3RSZWZlcmVuY2VTcGFjZVByb21pc2UmJik7 CiAKICAgICB1bnNpZ25lZCByZXF1ZXN0QW5pbWF0aW9uRnJhbWUoUmVmPFhSRnJhbWVSZXF1ZXN0 Q2FsbGJhY2s+JiYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9X ZWJYUlNlc3Npb24uaWRsIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Np b24uaWRsCmluZGV4IDU0NWU2ZDQ2ODQ2ZGNjNWZlYTU1YWY5ODZhZjhiYzY5MGIxOWI1MjMuLjcz MGQ5ZWE1Mzc1ZmM1ZTM0NWE5NzAyMzY1MTZlMDdlMTY0NDI5YTIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmlkbAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSU2Vzc2lvbi5pZGwKQEAgLTM5LDcgKzM5LDcgQEAKICAg ICBbU2FtZU9iamVjdF0gcmVhZG9ubHkgYXR0cmlidXRlIFdlYlhSSW5wdXRTb3VyY2VBcnJheSBp bnB1dFNvdXJjZXM7CiAKICAgICAvLyBNZXRob2RzCi0gICAgdm9pZCB1cGRhdGVSZW5kZXJTdGF0 ZShvcHRpb25hbCBYUlJlbmRlclN0YXRlSW5pdCBzdGF0ZUluaXQpOworICAgIFtNYXlUaHJvd0V4 Y2VwdGlvbl0gdm9pZCB1cGRhdGVSZW5kZXJTdGF0ZShvcHRpb25hbCBYUlJlbmRlclN0YXRlSW5p dCBzdGF0ZUluaXQpOwogICAgIFtOZXdPYmplY3RdIFByb21pc2U8V2ViWFJSZWZlcmVuY2VTcGFj ZT4gcmVxdWVzdFJlZmVyZW5jZVNwYWNlKFhSUmVmZXJlbmNlU3BhY2VUeXBlIHR5cGUpOwogCiAg ICAgdW5zaWduZWQgbG9uZyByZXF1ZXN0QW5pbWF0aW9uRnJhbWUoWFJGcmFtZVJlcXVlc3RDYWxs YmFjayBjYWxsYmFjayk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhy L1dlYlhSV2ViR0xMYXllci5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUldl YkdMTGF5ZXIuaAppbmRleCBiYjNlYTc2MmYxMDExNzZjNjc5YmFkMTk2NmUwZGMxZWM5Yjk1MDY1 Li4xMTJiYzZiY2QxZDQ1YWZhZTY0NGJjOGRkNWUwZTc1YzVlOGY4NWYxIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSV2ViR0xMYXllci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJXZWJHTExheWVyLmgKQEAgLTcyLDYgKzcyLDgg QEAgcHVibGljOgogCiAgICAgc3RhdGljIGRvdWJsZSBnZXROYXRpdmVGcmFtZWJ1ZmZlclNjYWxl RmFjdG9yKGNvbnN0IFdlYlhSU2Vzc2lvbiYpOwogCisgICAgY29uc3QgV2ViWFJTZXNzaW9uJiBz ZXNzaW9uKCkgeyByZXR1cm4gbV9zZXNzaW9uLmdldCgpOyB9CisKIHByaXZhdGU6CiAgICAgV2Vi WFJXZWJHTExheWVyKFJlZjxXZWJYUlNlc3Npb24+JiYsIFdlYlhSUmVuZGVyaW5nQ29udGV4dCYm LCBjb25zdCBYUldlYkdMTGF5ZXJJbml0Jik7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaAppbmRleCA3MDcxODBiMGUwZjc4MmMyMTc2Nzk5 MzdiMTRjOTg3YjNiNGYxMjU2Li40YzQyOTNlMWE0M2Y4OGQ0MTM4NmQzZDEzMGE5Y2MyNzZjMWY1 NWNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1hSUmVuZGVyU3Rh dGVJbml0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9YUlJlbmRlclN0YXRl SW5pdC5oCkBAIC0yOCwxNSArMjgsMTggQEAKICNpZiBFTkFCTEUoV0VCWFIpCiAKICNpbmNsdWRl ICJXZWJYUldlYkdMTGF5ZXIuaCIKKyNpbmNsdWRlIDx3dGYvT3B0aW9uYWwuaD4KICNpbmNsdWRl IDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIHN0cnVjdCBYUlJlbmRlclN0YXRlSW5pdCB7Ci0gICAgZG91YmxlIGRlcHRoTmVh cjsKLSAgICBkb3VibGUgZGVwdGhGYXI7Ci0gICAgZG91YmxlIGlubGluZVZlcnRpY2FsRmllbGRP ZlZpZXc7CisgICAgT3B0aW9uYWw8ZG91YmxlPiBkZXB0aE5lYXI7CisgICAgT3B0aW9uYWw8ZG91 YmxlPiBkZXB0aEZhcjsKKyAgICBPcHRpb25hbDxkb3VibGU+IGlubGluZVZlcnRpY2FsRmllbGRP ZlZpZXc7CiAgICAgUmVmUHRyPFdlYlhSV2ViR0xMYXllcj4gYmFzZUxheWVyOworICAgIE9wdGlv bmFsPFZlY3RvcjxSZWZQdHI8V2ViWFJMYXllcj4+PiBsYXllcnM7CiB9OwogCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1hS UmVuZGVyU3RhdGVJbml0LmlkbCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5k ZXJTdGF0ZUluaXQuaWRsCmluZGV4IGE2MGVhZTRiMmE5ZDQxZjk0ZGE3Y2IyNWNiMDk5YmE1ZTJh ZWMxMTguLmU3OGJjMWRiZWUyNzdlM2E1NjY5ZDQ5YmRjYTIzNThkNDVkZWI0MWYgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsCisr KyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsCkBA IC0zMSw0ICszMSw1IEBACiAgICAgZG91YmxlIGRlcHRoRmFyOwogICAgIGRvdWJsZSBpbmxpbmVW ZXJ0aWNhbEZpZWxkT2ZWaWV3OwogICAgIFdlYlhSV2ViR0xMYXllcj8gYmFzZUxheWVyOworICAg IHNlcXVlbmNlPFdlYlhSTGF5ZXI+PyBsYXllcnM7CiB9Owo= 406505 2020-08-13 03:10:07 -0700 2020-08-13 09:48:16 -0700 Patch bug-213555-20200813121005.patch text/plain 17468 svillar U3VidmVyc2lvbiBSZXZpc2lvbjogMjY1NjAzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTYwZjFmMzUyZmUyZGYy YmYyOWNlNTQ4ZGM0NTY4ZGUyNDIwMDZiMy4uZTRlYjI4MTBhMmRkMjIzZjZkNGI5MjYyZDQ4NmE3 ZTM2ZGZiN2JkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ1IEBACisyMDIwLTA4LTEzICBTZXJn aW8gVmlsbGFyIFNlbmluICA8c3ZpbGxhckBpZ2FsaWEuY29tPgorCisgICAgICAgIFtXZWJYUl0g SW1wbGVtZW50IFdlYlhSU2Vzc2lvbjo6dXBkYXRlUmVuZGVyU3RhdGUoKQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjEzNTU1CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgYW4gaW1wbGVtZW50YXRp b24gd2hpY2ggbWF0Y2hlcyB0aGUgY3VycmVudCBzcGVjcy4gVGhlIHVwZGF0ZVJlbmRlclN0YXRl KCkgaXMgc3BlY2lhbGx5IHVzZWZ1bCB0byBzZXQKKyAgICAgICAgdGhlIGJhc2UgbGF5ZXIgaW4g dGhlIHNlc3Npb24gd2hlcmUgV2ViWFIgY29udGVudHMgd291bGQgYmUgcmVuZGVyZWQuIEF1dGhv cnMgd291bGQgbm9ybWFsbHkgZG86CisKKyAgICAgICAgZ2xDYW52YXMuZ2V0Q29udGV4dCgid2Vi Z2wiKS5tYWtlWFJDb21wYXRpYmxlKCkudGhlbigoKSA9PiB7CisgICAgICAgICAgICB4clNlc3Np b24udXBkYXRlUmVuZGVyU3RhdGUoeyBiYXNlTGF5ZXI6IG5ldyBYUldlYkdMTGF5ZXIoeHJTZXNz aW9uLCBnbCkgfSk7CisgICAgICAgIH0pOworCisgICAgICAgIFRoZSBYUlJlbmRlclN0YXRlSW5p dCBoYXMgYWxzbyBiZWVuIHVwZGF0ZWQgdG8gdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIHNwZWNzLgor CisgICAgICAgICogTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OldlYlhSUmVuZGVyU3RhdGUpOgorICAgICAgICAo V2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6ZGVwdGhOZWFyIGNvbnN0KTogSW5saW5lZC4KKyAg ICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OmRlcHRoRmFyIGNvbnN0KTogRGl0dG8u CisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRlOjppbmxpbmVWZXJ0aWNhbEZpZWxk T2ZWaWV3IGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRl OjpiYXNlTGF5ZXIgY29uc3QpOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhS UmVuZGVyU3RhdGUuaDoKKyAgICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3RhdGU6OmRlcHRo TmVhciBjb25zdCk6IElubGluZWQuCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRl OjpzZXREZXB0aE5lYXIpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OldlYlhSUmVuZGVyU3Rh dGU6OmRlcHRoRmFyIGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRl clN0YXRlOjpzZXREZXB0aEZhcik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJSZW5k ZXJTdGF0ZTo6aW5saW5lVmVydGljYWxGaWVsZE9mVmlldyBjb25zdCk6IEFkZGVkLgorICAgICAg ICAoV2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6c2V0SW5saW5lVmVydGljYWxGaWVsZE9mVmll dyk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJSZW5kZXJTdGF0ZTo6YmFzZUxheWVy IGNvbnN0KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpXZWJYUlJlbmRlclN0YXRlOjpzZXRC YXNlTGF5ZXIpOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhSU2Vzc2lvbi5j cHA6CisgICAgICAgIChXZWJDb3JlOjppc0ltbWVyc2l2ZSk6CisgICAgICAgIChXZWJDb3JlOjpX ZWJYUlNlc3Npb246OnVwZGF0ZVJlbmRlclN0YXRlKTogSW1wbGVtZW50ZWQuCisgICAgICAgIChX ZWJDb3JlOjpXZWJYUlNlc3Npb246OnJlZmVyZW5jZVNwYWNlSXNTdXBwb3J0ZWQgY29uc3QpOgor ICAgICAgICAqIE1vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmg6IHVwZGF0ZVJlbmRlclN0YXRl IG1heSB0aHJvdyBleGNlcHRpb24uCisgICAgICAgICogTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Np b24uaWRsOiBEaXR0by4KKyAgICAgICAgKiBNb2R1bGVzL3dlYnhyL1dlYlhSV2ViR0xMYXllci5o OgorICAgICAgICAoV2ViQ29yZTo6V2ViWFJXZWJHTExheWVyOjpzZXNzaW9uKTogQWRkZWQuCisg ICAgICAgICogTW9kdWxlcy93ZWJ4ci9YUlJlbmRlclN0YXRlSW5pdC5oOiBBZGRlZCBsYXllcnMg YW5kIG1hZGUgbWFueSBhdHRyaWJ1dGVzIG9wdGlvbmFsLgorICAgICAgICAqIE1vZHVsZXMvd2Vi eHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsOiBEaXR0by4KKwogMjAyMC0wOC0xMiAgTXlsZXMgQy4g TWF4ZmllbGQgIDxtbWF4ZmllbGRAYXBwbGUuY29tPgogCiAgICAgICAgIEZvbnQgbG9hZHMgcXVp Y2tseSBmb2xsb3dlZCBieSBuYXZpZ2F0aW9ucyBtYXkgZmFpbCBpbmRlZmluaXRlbHkKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJSZW5kZXJTdGF0ZS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSUmVuZGVyU3RhdGUuY3BwCmluZGV4 IDlmZjQwYzQ0YTZhMGE1NTg4Y2NjYTY4ZmI4OGUyNTAwNTIxMzgyN2YuLmI0MzIyZDU5NzhkYmU0 ZjMyZjBiNmUwMWZkOGY0MzYyNGY2YWZjYzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2VieHIvV2ViWFJSZW5kZXJTdGF0ZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmNwcApAQCAtMjgsOCArMjgsNiBAQAogCiAjaWYg RU5BQkxFKFdFQlhSKQogCi0jaW5jbHVkZSAiSFRNTENhbnZhc0VsZW1lbnQuaCIKLSNpbmNsdWRl ICJXZWJYUldlYkdMTGF5ZXIuaCIKICNpbmNsdWRlICJYUlJlbmRlclN0YXRlSW5pdC5oIgogI2lu Y2x1ZGUgPHd0Zi9Jc29NYWxsb2NJbmxpbmVzLmg+CiAjaW5jbHVkZSA8d3RmL01hdGhFeHRyYXMu aD4KQEAgLTUwLDM1ICs0OCwxOCBAQCBXZWJYUlJlbmRlclN0YXRlOjpXZWJYUlJlbmRlclN0YXRl KE9wdGlvbmFsPGRvdWJsZT4mJiBpbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3KQogewogfQogCi1X ZWJYUlJlbmRlclN0YXRlOjpXZWJYUlJlbmRlclN0YXRlKGNvbnN0IFhSUmVuZGVyU3RhdGVJbml0 JikKLXsKLX0KLQogV2ViWFJSZW5kZXJTdGF0ZTo6fldlYlhSUmVuZGVyU3RhdGUoKSA9IGRlZmF1 bHQ7CiAKLWRvdWJsZSBXZWJYUlJlbmRlclN0YXRlOjpkZXB0aE5lYXIoKSBjb25zdAotewotICAg IHJldHVybiBtX2RlcHRoLm5lYXI7Ci19Ci0KLWRvdWJsZSBXZWJYUlJlbmRlclN0YXRlOjpkZXB0 aEZhcigpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fZGVwdGguZmFyOwotfQotCi1PcHRpb25hbDxk b3VibGU+IFdlYlhSUmVuZGVyU3RhdGU6OmlubGluZVZlcnRpY2FsRmllbGRPZlZpZXcoKSBjb25z dAotewotICAgIHJldHVybiBtX2lubGluZVZlcnRpY2FsRmllbGRPZlZpZXc7Ci19Ci0KLVJlZlB0 cjxXZWJYUldlYkdMTGF5ZXI+IFdlYlhSUmVuZGVyU3RhdGU6OmJhc2VMYXllcigpIGNvbnN0CitS ZWY8V2ViWFJSZW5kZXJTdGF0ZT4gV2ViWFJSZW5kZXJTdGF0ZTo6Y2xvbmUoKQogewotICAgIHJl dHVybiBtX2Jhc2VMYXllcjsKKyAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJYUlJlbmRlclN0 YXRlKCp0aGlzKSk7CiB9CiAKLUhUTUxDYW52YXNFbGVtZW50KiBXZWJYUlJlbmRlclN0YXRlOjpv dXRwdXRDYW52YXMoKSBjb25zdAorV2ViWFJSZW5kZXJTdGF0ZTo6V2ViWFJSZW5kZXJTdGF0ZShj b25zdCBXZWJYUlJlbmRlclN0YXRlJiBvdGhlcikKIHsKLSAgICByZXR1cm4gbV9vdXRwdXRDYW52 YXMuZ2V0KCk7CisgICAgbV9iYXNlTGF5ZXIgPSBvdGhlci5iYXNlTGF5ZXIoKTsKKyAgICBtX2Rl cHRoID0gb3RoZXIubV9kZXB0aDsKKyAgICBtX2lubGluZVZlcnRpY2FsRmllbGRPZlZpZXcgPSBv dGhlci5tX2lubGluZVZlcnRpY2FsRmllbGRPZlZpZXc7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJSZW5k ZXJTdGF0ZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRl LmgKaW5kZXggMWIyMTFmMmZiZTU4NmUyOTI5NGQ2M2M5MmQ2NDk4ZDUzY2VkYTQzYi4uOGE3MjQz MWI4OGNjZjlhMzM4ZWM0ZDBiYTViYWQxNmVhNGVkNjQ5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmgKKysrIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlJlbmRlclN0YXRlLmgKQEAgLTI3LDYgKzI3LDggQEAKIAog I2lmIEVOQUJMRShXRUJYUikKIAorI2luY2x1ZGUgIkhUTUxDYW52YXNFbGVtZW50LmgiCisjaW5j bHVkZSAiV2ViWFJXZWJHTExheWVyLmgiCiAjaW5jbHVkZSAiWFJTZXNzaW9uTW9kZS5oIgogI2lu Y2x1ZGUgPHd0Zi9Jc29NYWxsb2MuaD4KICNpbmNsdWRlIDx3dGYvT3B0aW9uYWwuaD4KQEAgLTM3 LDggKzM5LDYgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1jbGFzcyBIVE1MQ2FudmFzRWxl bWVudDsKLWNsYXNzIFdlYlhSV2ViR0xMYXllcjsKIHN0cnVjdCBYUlJlbmRlclN0YXRlSW5pdDsK IAogY2xhc3MgV2ViWFJSZW5kZXJTdGF0ZSA6IHB1YmxpYyBSZWZDb3VudGVkPFdlYlhSUmVuZGVy U3RhdGU+IHsKQEAgLTQ3LDE1ICs0NywyNCBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFJlZjxXZWJY UlJlbmRlclN0YXRlPiBjcmVhdGUoWFJTZXNzaW9uTW9kZSk7CiAgICAgfldlYlhSUmVuZGVyU3Rh dGUoKTsKIAotICAgIGRvdWJsZSBkZXB0aE5lYXIoKSBjb25zdDsKLSAgICBkb3VibGUgZGVwdGhG YXIoKSBjb25zdDsKLSAgICBPcHRpb25hbDxkb3VibGU+IGlubGluZVZlcnRpY2FsRmllbGRPZlZp ZXcoKSBjb25zdDsKLSAgICBSZWZQdHI8V2ViWFJXZWJHTExheWVyPiBiYXNlTGF5ZXIoKSBjb25z dDsKLSAgICBIVE1MQ2FudmFzRWxlbWVudCogb3V0cHV0Q2FudmFzKCkgY29uc3Q7CisgICAgUmVm PFdlYlhSUmVuZGVyU3RhdGU+IGNsb25lKCk7CiAKKyAgICBkb3VibGUgZGVwdGhOZWFyKCkgY29u c3QgeyByZXR1cm4gbV9kZXB0aC5uZWFyOyB9CisgICAgdm9pZCBzZXREZXB0aE5lYXIoZG91Ymxl IG5lYXIpIHsgbV9kZXB0aC5uZWFyID0gbmVhcjsgfQorCisgICAgZG91YmxlIGRlcHRoRmFyKCkg Y29uc3QgeyByZXR1cm4gbV9kZXB0aC5mYXI7IH0KKyAgICB2b2lkIHNldERlcHRoRmFyKGRvdWJs ZSBmYXIpIHsgbV9kZXB0aC5mYXIgPSBmYXI7IH07CisKKyAgICBPcHRpb25hbDxkb3VibGU+IGlu bGluZVZlcnRpY2FsRmllbGRPZlZpZXcoKSBjb25zdCB7IHJldHVybiBtX2lubGluZVZlcnRpY2Fs RmllbGRPZlZpZXc7IH0KKyAgICB2b2lkIHNldElubGluZVZlcnRpY2FsRmllbGRPZlZpZXcoZG91 YmxlIGZpZWxkT2ZWaWV3KSB7IG1faW5saW5lVmVydGljYWxGaWVsZE9mVmlldyA9IGZpZWxkT2ZW aWV3OyB9CisKKyAgICBSZWZQdHI8V2ViWFJXZWJHTExheWVyPiBiYXNlTGF5ZXIoKSBjb25zdCB7 IHJldHVybiBtX2Jhc2VMYXllcjsgfQorICAgIHZvaWQgc2V0QmFzZUxheWVyKFdlYlhSV2ViR0xM YXllciogYmFzZUxheWVyKSB7IG1fYmFzZUxheWVyID0gV1RGTW92ZShiYXNlTGF5ZXIpOyB9CisK KyAgICBIVE1MQ2FudmFzRWxlbWVudCogb3V0cHV0Q2FudmFzKCkgY29uc3QgeyByZXR1cm4gbV9v dXRwdXRDYW52YXMuZ2V0KCk7IH0KIHByaXZhdGU6CiAgICAgZXhwbGljaXQgV2ViWFJSZW5kZXJT dGF0ZShPcHRpb25hbDxkb3VibGU+JiYgZmllbGRPZlZpZXcpOwotICAgIGV4cGxpY2l0IFdlYlhS UmVuZGVyU3RhdGUoY29uc3QgWFJSZW5kZXJTdGF0ZUluaXQmKTsKKyAgICBleHBsaWNpdCBXZWJY UlJlbmRlclN0YXRlKGNvbnN0IFdlYlhSUmVuZGVyU3RhdGUmKTsKIAogICAgIC8vIGh0dHBzOi8v aW1tZXJzaXZlLXdlYi5naXRodWIuaW8vd2VieHIvI2luaXRpYWxpemUtdGhlLXJlbmRlci1zdGF0 ZQogICAgIHN0cnVjdCB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhy L1dlYlhSU2Vzc2lvbi5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSU2Vz c2lvbi5jcHAKaW5kZXggZDM4OGJjMzFmNzRlZTZiZDM1MmE1OTczYTI4ZjllNGRlYTExMTUwNC4u ZGQ0ZjdlYTI0MjIxYzcxMDdmNDQxYWQ1NzIxNDE2Y2IzNTcyNGRiOSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmNwcApAQCAtMzMsNyArMzMsOSBAQAog I2luY2x1ZGUgIldlYlhSRnJhbWUuaCIKICNpbmNsdWRlICJXZWJYUlN5c3RlbS5oIgogI2luY2x1 ZGUgIlhSRnJhbWVSZXF1ZXN0Q2FsbGJhY2suaCIKKyNpbmNsdWRlICJYUlJlbmRlclN0YXRlSW5p dC5oIgogI2luY2x1ZGUgPHd0Zi9Jc29NYWxsb2NJbmxpbmVzLmg+CisjaW5jbHVkZSA8d3RmL1Jl ZlB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTg1LDggKzg3LDYyIEBAIGNvbnN0 IFdlYlhSSW5wdXRTb3VyY2VBcnJheSYgV2ViWFJTZXNzaW9uOjppbnB1dFNvdXJjZXMoKSBjb25z dAogICAgIHJldHVybiBtX2lucHV0U291cmNlczsKIH0KIAotdm9pZCBXZWJYUlNlc3Npb246OnVw ZGF0ZVJlbmRlclN0YXRlKGNvbnN0IFhSUmVuZGVyU3RhdGVJbml0JikKK3N0YXRpYyBpbmxpbmUg Ym9vbCBpc0ltbWVyc2l2ZShYUlNlc3Npb25Nb2RlIG1vZGUpCiB7CisgICAgcmV0dXJuIG1vZGUg PT0gWFJTZXNzaW9uTW9kZTo6SW1tZXJzaXZlQXIgfHwgbW9kZSA9PSBYUlNlc3Npb25Nb2RlOjpJ bW1lcnNpdmVWcjsKK30KKworLy8gaHR0cHM6Ly9pbW1lcnNpdmUtd2ViLmdpdGh1Yi5pby93ZWJ4 ci8jZG9tLXhyc2Vzc2lvbi11cGRhdGVyZW5kZXJzdGF0ZQorRXhjZXB0aW9uT3I8dm9pZD4gV2Vi WFJTZXNzaW9uOjp1cGRhdGVSZW5kZXJTdGF0ZShjb25zdCBYUlJlbmRlclN0YXRlSW5pdCYgbmV3 U3RhdGUpCit7CisgICAgLy8gMS4gTGV0IHNlc3Npb24gYmUgdGhpcy4KKyAgICAvLyAyLiBJZiBz ZXNzaW9uJ3MgZW5kZWQgdmFsdWUgaXMgdHJ1ZSwgdGhyb3cgYW4gSW52YWxpZFN0YXRlRXJyb3Ig YW5kIGFib3J0IHRoZXNlIHN0ZXBzLgorICAgIGlmIChtX2VuZGVkKQorICAgICAgICByZXR1cm4g RXhjZXB0aW9uIHsgSW52YWxpZFN0YXRlRXJyb3IgfTsKKworICAgIC8vIDMuIElmIG5ld1N0YXRl J3MgYmFzZUxheWVyIHdhcyBjcmVhdGVkIHdpdGggYW4gWFJTZXNzaW9uIG90aGVyIHRoYW4gc2Vz c2lvbiwKKyAgICAvLyAgICB0aHJvdyBhbiBJbnZhbGlkU3RhdGVFcnJvciBhbmQgYWJvcnQgdGhl c2Ugc3RlcHMuCisgICAgaWYgKG5ld1N0YXRlLmJhc2VMYXllciAmJiAmbmV3U3RhdGUuYmFzZUxh eWVyLT5zZXNzaW9uKCkgIT0gdGhpcykKKyAgICAgICAgcmV0dXJuIEV4Y2VwdGlvbiB7IEludmFs aWRTdGF0ZUVycm9yIH07CisKKyAgICAvLyA0LiBJZiBuZXdTdGF0ZSdzIGlubGluZVZlcnRpY2Fs RmllbGRPZlZpZXcgaXMgc2V0IGFuZCBzZXNzaW9uIGlzIGFuIGltbWVyc2l2ZSBzZXNzaW9uLAor ICAgIC8vICAgIHRocm93IGFuIEludmFsaWRTdGF0ZUVycm9yIGFuZCBhYm9ydCB0aGVzZSBzdGVw cy4KKyAgICBpZiAobmV3U3RhdGUuaW5saW5lVmVydGljYWxGaWVsZE9mVmlldyAmJiBpc0ltbWVy c2l2ZShtX21vZGUpKQorICAgICAgICByZXR1cm4gRXhjZXB0aW9uIHsgSW52YWxpZFN0YXRlRXJy b3IgfTsKKworICAgIC8vIDUuIElmIG5vbmUgb2YgbmV3U3RhdGUncyBkZXB0aE5lYXIsIGRlcHRo RmFyLCBpbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3LCBiYXNlTGF5ZXIsCisgICAgLy8gICAgbGF5 ZXJzIGFyZSBzZXQsIGFib3J0IHRoZXNlIHN0ZXBzLgorICAgIGlmICghbmV3U3RhdGUuZGVwdGhO ZWFyICYmICFuZXdTdGF0ZS5kZXB0aEZhciAmJiAhbmV3U3RhdGUuaW5saW5lVmVydGljYWxGaWVs ZE9mVmlldyAmJiAhbmV3U3RhdGUuYmFzZUxheWVyICYmICFuZXdTdGF0ZS5sYXllcnMpCisgICAg ICAgIHJldHVybiB7IH07CisKKyAgICAvLyA2LiBSdW4gdXBkYXRlIHRoZSBwZW5kaW5nIGxheWVy cyBzdGF0ZSB3aXRoIHNlc3Npb24gYW5kIG5ld1N0YXRlLgorICAgIC8vIGh0dHBzOi8vaW1tZXJz aXZlLXdlYi5naXRodWIuaW8vd2VieHIvI3VwZGF0ZS10aGUtcGVuZGluZy1sYXllcnMtc3RhdGUK KyAgICBpZiAobmV3U3RhdGUubGF5ZXJzKQorICAgICAgICByZXR1cm4gRXhjZXB0aW9uIHsgTm90 U3VwcG9ydGVkRXJyb3IgfTsKKworICAgIC8vIDcuIExldCBhY3RpdmVTdGF0ZSBiZSBzZXNzaW9u J3MgYWN0aXZlIHJlbmRlciBzdGF0ZS4KKyAgICAvLyA4LiBJZiBzZXNzaW9uJ3MgcGVuZGluZyBy ZW5kZXIgc3RhdGUgaXMgbnVsbCwgc2V0IGl0IHRvIGEgY29weSBvZiBhY3RpdmVTdGF0ZS4KKyAg ICBpZiAoIW1fcGVuZGluZ1JlbmRlclN0YXRlKQorICAgICAgICBtX3BlbmRpbmdSZW5kZXJTdGF0 ZSA9IG1fYWN0aXZlUmVuZGVyU3RhdGUtPmNsb25lKCk7CisKKyAgICAvLyA5LiBJZiBuZXdTdGF0 ZSdzIGRlcHRoTmVhciB2YWx1ZSBpcyBzZXQsIHNldCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIg c3RhdGUncyBkZXB0aE5lYXIgdG8gbmV3U3RhdGUncyBkZXB0aE5lYXIuCisgICAgaWYgKG5ld1N0 YXRlLmRlcHRoTmVhcikKKyAgICAgICAgbV9wZW5kaW5nUmVuZGVyU3RhdGUtPnNldERlcHRoTmVh cihuZXdTdGF0ZS5kZXB0aE5lYXIudmFsdWUoKSk7CisKKyAgICAvLyAxMC4gSWYgbmV3U3RhdGUn cyBkZXB0aEZhciB2YWx1ZSBpcyBzZXQsIHNldCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3Rh dGUncyBkZXB0aEZhciB0byBuZXdTdGF0ZSdzIGRlcHRoRmFyLgorICAgIGlmIChuZXdTdGF0ZS5k ZXB0aEZhcikKKyAgICAgICAgbV9wZW5kaW5nUmVuZGVyU3RhdGUtPnNldERlcHRoRmFyKG5ld1N0 YXRlLmRlcHRoRmFyLnZhbHVlKCkpOworCisgICAgLy8gMTEuIElmIG5ld1N0YXRlJ3MgaW5saW5l VmVydGljYWxGaWVsZE9mVmlldyBpcyBzZXQsIHNldCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIg c3RhdGUncyBpbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3CisgICAgLy8gICAgIHRvIG5ld1N0YXRl J3MgaW5saW5lVmVydGljYWxGaWVsZE9mVmlldy4KKyAgICBpZiAobmV3U3RhdGUuaW5saW5lVmVy dGljYWxGaWVsZE9mVmlldykKKyAgICAgICAgbV9wZW5kaW5nUmVuZGVyU3RhdGUtPnNldElubGlu ZVZlcnRpY2FsRmllbGRPZlZpZXcobmV3U3RhdGUuaW5saW5lVmVydGljYWxGaWVsZE9mVmlldy52 YWx1ZSgpKTsKKworICAgIC8vIDEyLiBJZiBuZXdTdGF0ZSdzIGJhc2VMYXllciBpcyBzZXQsIHNl dCBzZXNzaW9uJ3MgcGVuZGluZyByZW5kZXIgc3RhdGUncyBiYXNlTGF5ZXIgdG8gbmV3U3RhdGUn cyBiYXNlTGF5ZXIuCisgICAgaWYgKG5ld1N0YXRlLmJhc2VMYXllcikKKyAgICAgICAgbV9wZW5k aW5nUmVuZGVyU3RhdGUtPnNldEJhc2VMYXllcihuZXdTdGF0ZS5iYXNlTGF5ZXIuZ2V0KCkpOwor CisgICAgcmV0dXJuIHsgfTsKIH0KIAogLy8gaHR0cHM6Ly9pbW1lcnNpdmUtd2ViLmdpdGh1Yi5p by93ZWJ4ci8jcmVmZXJlbmNlLXNwYWNlLWlzLXN1cHBvcnRlZApAQCAtMTAwLDcgKzE1Niw3IEBA IGJvb2wgV2ViWFJTZXNzaW9uOjpyZWZlcmVuY2VTcGFjZUlzU3VwcG9ydGVkKFhSUmVmZXJlbmNl U3BhY2VUeXBlIHR5cGUpIGNvbnN0CiAgICAgaWYgKHR5cGUgPT0gWFJSZWZlcmVuY2VTcGFjZVR5 cGU6OlZpZXdlcikKICAgICAgICAgcmV0dXJuIHRydWU7CiAKLSAgICBib29sIGlzSW1tZXJzaXZl U2Vzc2lvbiA9IG1fbW9kZSA9PSBYUlNlc3Npb25Nb2RlOjpJbW1lcnNpdmVBciB8fCBtX21vZGUg PT0gWFJTZXNzaW9uTW9kZTo6SW1tZXJzaXZlVnI7CisgICAgYm9vbCBpc0ltbWVyc2l2ZVNlc3Np b24gPSBpc0ltbWVyc2l2ZShtX21vZGUpOwogICAgIGlmICh0eXBlID09IFhSUmVmZXJlbmNlU3Bh Y2VUeXBlOjpMb2NhbCB8fCB0eXBlID09IFhSUmVmZXJlbmNlU3BhY2VUeXBlOjpMb2NhbEZsb29y KSB7CiAgICAgICAgIC8vIDMuIElmIHR5cGUgaXMgbG9jYWwgb3IgbG9jYWwtZmxvb3IsIGFuZCBz ZXNzaW9uIGlzIGFuIGltbWVyc2l2ZSBzZXNzaW9uLCByZXR1cm4gdHJ1ZS4KICAgICAgICAgaWYg KGlzSW1tZXJzaXZlU2Vzc2lvbikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2VieHIvV2ViWFJTZXNzaW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhS U2Vzc2lvbi5oCmluZGV4IDQ3NmIxNmQ1NTZhZDA5MGIyOGY4YjQxNDVmNmI5NzQ2MzNjYTNhMTku LmU0YzI3ZGI0YjkwZDkyMWUyMTU1NWE2YTI4NjkwNmU5OGM2M2EwZTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvV2ViWFJTZXNzaW9uLmgKKysrIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uaApAQCAtNzAsNyArNzAsNyBAQCBwdWJs aWM6CiAgICAgY29uc3QgV2ViWFJSZW5kZXJTdGF0ZSYgcmVuZGVyU3RhdGUoKSBjb25zdDsKICAg ICBjb25zdCBXZWJYUklucHV0U291cmNlQXJyYXkmIGlucHV0U291cmNlcygpIGNvbnN0OwogCi0g ICAgdm9pZCB1cGRhdGVSZW5kZXJTdGF0ZShjb25zdCBYUlJlbmRlclN0YXRlSW5pdCYpOworICAg IEV4Y2VwdGlvbk9yPHZvaWQ+IHVwZGF0ZVJlbmRlclN0YXRlKGNvbnN0IFhSUmVuZGVyU3RhdGVJ bml0Jik7CiAgICAgdm9pZCByZXF1ZXN0UmVmZXJlbmNlU3BhY2UoWFJSZWZlcmVuY2VTcGFjZVR5 cGUsIFJlcXVlc3RSZWZlcmVuY2VTcGFjZVByb21pc2UmJik7CiAKICAgICB1bnNpZ25lZCByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUoUmVmPFhSRnJhbWVSZXF1ZXN0Q2FsbGJhY2s+JiYpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uaWRsIGIvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUlNlc3Npb24uaWRsCmluZGV4IDU0NWU2ZDQ2 ODQ2ZGNjNWZlYTU1YWY5ODZhZjhiYzY5MGIxOWI1MjMuLjczMGQ5ZWE1Mzc1ZmM1ZTM0NWE5NzAy MzY1MTZlMDdlMTY0NDI5YTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2Vi eHIvV2ViWFJTZXNzaW9uLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dl YlhSU2Vzc2lvbi5pZGwKQEAgLTM5LDcgKzM5LDcgQEAKICAgICBbU2FtZU9iamVjdF0gcmVhZG9u bHkgYXR0cmlidXRlIFdlYlhSSW5wdXRTb3VyY2VBcnJheSBpbnB1dFNvdXJjZXM7CiAKICAgICAv LyBNZXRob2RzCi0gICAgdm9pZCB1cGRhdGVSZW5kZXJTdGF0ZShvcHRpb25hbCBYUlJlbmRlclN0 YXRlSW5pdCBzdGF0ZUluaXQpOworICAgIFtNYXlUaHJvd0V4Y2VwdGlvbl0gdm9pZCB1cGRhdGVS ZW5kZXJTdGF0ZShvcHRpb25hbCBYUlJlbmRlclN0YXRlSW5pdCBzdGF0ZUluaXQpOwogICAgIFtO ZXdPYmplY3RdIFByb21pc2U8V2ViWFJSZWZlcmVuY2VTcGFjZT4gcmVxdWVzdFJlZmVyZW5jZVNw YWNlKFhSUmVmZXJlbmNlU3BhY2VUeXBlIHR5cGUpOwogCiAgICAgdW5zaWduZWQgbG9uZyByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUoWFJGcmFtZVJlcXVlc3RDYWxsYmFjayBjYWxsYmFjayk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1dlYlhSV2ViR0xMYXllci5oIGIv U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ4ci9XZWJYUldlYkdMTGF5ZXIuaAppbmRleCBiYjNl YTc2MmYxMDExNzZjNjc5YmFkMTk2NmUwZGMxZWM5Yjk1MDY1Li4zMTc1NWQ4NDk2YTZhNzAyZTIz MzI5Y2ZiZjMyOWI5Y2M0YjhhOWRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYnhyL1dlYlhSV2ViR0xMYXllci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2Vi eHIvV2ViWFJXZWJHTExheWVyLmgKQEAgLTcyLDYgKzcyLDggQEAgcHVibGljOgogCiAgICAgc3Rh dGljIGRvdWJsZSBnZXROYXRpdmVGcmFtZWJ1ZmZlclNjYWxlRmFjdG9yKGNvbnN0IFdlYlhSU2Vz c2lvbiYpOwogCisgICAgY29uc3QgV2ViWFJTZXNzaW9uJiBzZXNzaW9uKCkgeyByZXR1cm4gbV9z ZXNzaW9uOyB9CisKIHByaXZhdGU6CiAgICAgV2ViWFJXZWJHTExheWVyKFJlZjxXZWJYUlNlc3Np b24+JiYsIFdlYlhSUmVuZGVyaW5nQ29udGV4dCYmLCBjb25zdCBYUldlYkdMTGF5ZXJJbml0Jik7 CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0 ZUluaXQuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQu aAppbmRleCA3MDcxODBiMGUwZjc4MmMyMTc2Nzk5MzdiMTRjOTg3YjNiNGYxMjU2Li40YzQyOTNl MWE0M2Y4OGQ0MTM4NmQzZDEzMGE5Y2MyNzZjMWY1NWNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYnhyL1hSUmVuZGVyU3RhdGVJbml0LmgKKysrIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJ4ci9YUlJlbmRlclN0YXRlSW5pdC5oCkBAIC0yOCwxNSArMjgsMTggQEAK ICNpZiBFTkFCTEUoV0VCWFIpCiAKICNpbmNsdWRlICJXZWJYUldlYkdMTGF5ZXIuaCIKKyNpbmNs dWRlIDx3dGYvT3B0aW9uYWwuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8 d3RmL1ZlY3Rvci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0cnVjdCBYUlJlbmRlclN0 YXRlSW5pdCB7Ci0gICAgZG91YmxlIGRlcHRoTmVhcjsKLSAgICBkb3VibGUgZGVwdGhGYXI7Ci0g ICAgZG91YmxlIGlubGluZVZlcnRpY2FsRmllbGRPZlZpZXc7CisgICAgT3B0aW9uYWw8ZG91Ymxl PiBkZXB0aE5lYXI7CisgICAgT3B0aW9uYWw8ZG91YmxlPiBkZXB0aEZhcjsKKyAgICBPcHRpb25h bDxkb3VibGU+IGlubGluZVZlcnRpY2FsRmllbGRPZlZpZXc7CiAgICAgUmVmUHRyPFdlYlhSV2Vi R0xMYXllcj4gYmFzZUxheWVyOworICAgIE9wdGlvbmFsPFZlY3RvcjxSZWZQdHI8V2ViWFJMYXll cj4+PiBsYXllcnM7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYnhyL1hSUmVuZGVyU3RhdGVJbml0LmlkbCBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsCmluZGV4IGE2MGVh ZTRiMmE5ZDQxZjk0ZGE3Y2IyNWNiMDk5YmE1ZTJhZWMxMTguLmU3OGJjMWRiZWUyNzdlM2E1NjY5 ZDQ5YmRjYTIzNThkNDVkZWI0MWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2VieHIvWFJSZW5kZXJTdGF0ZUluaXQuaWRsCkBAIC0zMSw0ICszMSw1IEBACiAgICAgZG91Ymxl IGRlcHRoRmFyOwogICAgIGRvdWJsZSBpbmxpbmVWZXJ0aWNhbEZpZWxkT2ZWaWV3OwogICAgIFdl YlhSV2ViR0xMYXllcj8gYmFzZUxheWVyOworICAgIHNlcXVlbmNlPFdlYlhSTGF5ZXI+PyBsYXll cnM7CiB9OwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCmluZGV4IDU4NGY2ODcyMDBlMTk1M2E1N2NjMDQ2MjlhNTQ0OWMyYTEzYWFiOWEu LmIyNTNkN2NjOTRjNTQ5NDIxYzc1ODllNGMyMDUwYTZkYzAxMTY3YTQgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxMiBAQAorMjAyMC0wOC0xMyAgU2VyZ2lvIFZpbGxhciBTZW5pbiAgPHN2aWxsYXJAaWdhbGlh LmNvbT4KKworICAgICAgICBbV2ViWFJdIEltcGxlbWVudCBXZWJYUlNlc3Npb246OnVwZGF0ZVJl bmRlclN0YXRlKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIxMzU1NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogcGxhdGZvcm0vd3BlL1Rlc3RFeHBlY3RhdGlvbnM6IEFkZGVkIGEgY291cGxlIG9mIHRl c3RzIHRoYXQgcGFzcyBub3cuCisKIDIwMjAtMDgtMTIgIE15bGVzIEMuIE1heGZpZWxkICA8bW1h eGZpZWxkQGFwcGxlLmNvbT4KIAogICAgICAgICBGb250IGxvYWRzIHF1aWNrbHkgZm9sbG93ZWQg YnkgbmF2aWdhdGlvbnMgbWF5IGZhaWwgaW5kZWZpbml0ZWx5CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9pbXBvcnRlZC93M2MvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvaW1wb3J0ZWQvdzNjL0No YW5nZUxvZwppbmRleCA4Zjk4MjVhY2YzMjRhYjJhMjBkMWViY2ExZjUwNDM3NWJlZmZhNWIzLi5k YjI1ZDc3ZjU4NTE4ZmY5ODliNTY2ZTVkZGZkMjUyNWZjMDNkMDhlIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9pbXBvcnRlZC93M2MvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL2ltcG9ydGVk L3czYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMC0wOC0xMyAgU2VyZ2lvIFZpbGxh ciBTZW5pbiAgPHN2aWxsYXJAaWdhbGlhLmNvbT4KKworICAgICAgICBbV2ViWFJdIEltcGxlbWVu dCBXZWJYUlNlc3Npb246OnVwZGF0ZVJlbmRlclN0YXRlKCkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxMzU1NQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5ldyBleHBlY3RhdGlvbnMuCisKKyAgICAgICAg KiB3ZWItcGxhdGZvcm0tdGVzdHMvd2VieHIvcmVuZGVyX3N0YXRlX3VwZGF0ZS5odHRwcy1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHdlYi1wbGF0Zm9ybS10ZXN0cy93ZWJ4ci9yZW5k ZXJfc3RhdGVfdmVydGljYWxfZm92X2ltbWVyc2l2ZS5odHRwcy1leHBlY3RlZC50eHQ6IEFkZGVk LgorCiAyMDIwLTA4LTEyICBMYXVybyBNb3VyYSAgPGxtb3VyYUBpZ2FsaWEuY29tPgogCiAgICAg ICAgIEhpZ2hwYXNzIEJpcXVhZHMgdXNlIG9sZCBmb3JtdWxhcwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy93ZWJ4ci9yZW5kZXJfc3RhdGVf dXBkYXRlLmh0dHBzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2ltcG9ydGVkL3czYy93ZWIt cGxhdGZvcm0tdGVzdHMvd2VieHIvcmVuZGVyX3N0YXRlX3VwZGF0ZS5odHRwcy1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNTA0ZTcyMTgyOTIzNzUxMDNjYmM3ZWQzYjlkNWYyNmJlYmIyYWM3Nwot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2ltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0t dGVzdHMvd2VieHIvcmVuZGVyX3N0YXRlX3VwZGF0ZS5odHRwcy1leHBlY3RlZC50eHQKQEAgLTAs MCArMSw3IEBACisKK1BBU1MgdXBkYXRlUmVuZGVyU3RhdGUgaGFuZGxlcyBhcHByb3ByaWF0ZWx5 IGVuZGVkIHNlc3Npb25zIAorUEFTUyB1cGRhdGVSZW5kZXJTdGF0ZSBoYW5kbGVzIGFwcHJvcHJp YXRlbHkgYmFzZUxheWVycyBjcmVhdGVkIHdpdGggZGlmZmVyZW50IHNlc3Npb25zIAorUEFTUyB1 cGRhdGVSZW5kZXJTdGF0ZSBoYW5kbGVzIGFwcHJvcHJpYXRlbHkgaW1tZXJzaXZlIHNlc3Npb25z IHdpdGggc3BlY2lmaWVkIGlubGluZVZlcnRpY2FsRmllbGRPZlZpZXcgCitQQVNTIHVwZGF0ZVJl bmRlclN0YXRlIGhhbmRsZXMgYXBwcm9wcmlhdGVseSBYUlJlbmRlclN0YXRlSW5pdCB3aXRoIG5v IHBhcmFtcyAKK1BBU1MgdXBkYXRlUmVuZGVyU3RhdGUgaGFuZGxlcyBhcHByb3ByaWF0ZWx5IFhS UmVuZGVyU3RhdGVJbml0IHBhcmFtcyAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaW1wb3J0 ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy93ZWJ4ci9yZW5kZXJfc3RhdGVfdmVydGljYWxfZm92 X2ltbWVyc2l2ZS5odHRwcy1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9pbXBvcnRlZC93M2Mv d2ViLXBsYXRmb3JtLXRlc3RzL3dlYnhyL3JlbmRlcl9zdGF0ZV92ZXJ0aWNhbF9mb3ZfaW1tZXJz aXZlLmh0dHBzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iMDVkYjZjYWIwOTA1ZjFhNWY4MTY4 ZGE0MWUzNjhkZDg3ZTZkNDhjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaW1wb3J0 ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy93ZWJ4ci9yZW5kZXJfc3RhdGVfdmVydGljYWxfZm92 X2ltbWVyc2l2ZS5odHRwcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBACisKK1BBU1MgaW5s aW5lVmVydGljYWxGaWVsZE9mVmlldyBpcyBzZXQgYXBwcm9wcmlhdGVseSBvbiBpbW1lcnNpdmVs eSBzZXNzaW9ucyAKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd3BlL1Rlc3RF eHBlY3RhdGlvbnMgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93cGUvVGVzdEV4cGVjdGF0aW9ucwpp bmRleCA1N2M1OTg1M2Y0ZjRlZmNjYjI5NTZkYzY1YWVmNDU5ZGFiOGY4NTkyLi5hOTBlMmQ3MDgz NzY1MGM2MWYwOGJiZWU2MDFlYmU0N2YxZjZhMzI5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS93cGUvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93 cGUvVGVzdEV4cGVjdGF0aW9ucwpAQCAtOTE5LDYgKzkxOSw4IEBAIGltcG9ydGVkL3czYy93ZWIt cGxhdGZvcm0tdGVzdHMvd2VieHIvbmF2aWdhdG9yX3hyX3NhbWVPYmplY3QuaHR0cHMuaHRtbCBb IFBhc3MKIGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvd2VieHIveHJGcmFtZV9zZXNz aW9uX3NhbWVPYmplY3QuaHR0cHMuaHRtbCBbIFBhc3MgXQogaW1wb3J0ZWQvdzNjL3dlYi1wbGF0 Zm9ybS10ZXN0cy93ZWJ4ci94clJpZ2lkVHJhbnNmb3JtX2NvbnN0cnVjdG9yLmh0dHBzLmh0bWwg WyBQYXNzIF0KIGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvd2VieHIveHJTZXNzaW9u X3ByZXZlbnRfbXVsdGlwbGVfZXhjbHVzaXZlLmh0dHBzLmh0bWwgWyBQYXNzIF0KK2ltcG9ydGVk L3czYy93ZWItcGxhdGZvcm0tdGVzdHMvd2VieHIvcmVuZGVyX3N0YXRlX3ZlcnRpY2FsX2Zvdl9p bW1lcnNpdmUuaHR0cHMuaHRtbCBbIFBhc3MgXQoraW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10 ZXN0cy93ZWJ4ci9yZW5kZXJfc3RhdGVfdXBkYXRlLmh0dHBzLmh0bWwgWyBQYXNzIF0KIAogIyBQ YXNzaW5nIHNpbmNlIHIyNTk1MzIuCiBpbXBvcnRlZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3RzL2Nz cy9jc3MtdWkvb3V0bGluZS0wMTkuaHRtbAo=