202219 2019-09-25 11:56:30 -0700 Web Inspector: attach to provisional pages early to not miss events during process swaps (PSON) 2019-11-13 12:16:10 -0800 1 1 1 Unclassified WebKit Web Inspector WebKit Nightly Build All All NEW P2 Normal --- 202937 202704 203427 204170 1 yurys yurys annulen ews-watchlist gyuyoung.kim hi inspector-bugzilla-changes joepeck keith_miller mark.lam msaboff rakuco ryuan.choi saam sergio tzagallo oldest_to_newest 1574150 0 yurys 2019-09-25 11:56:30 -0700 When inspected process swaps on navigation (PSON) inspector is notified asynchronously about the new page creation, only after its load request is committed. The front-end then attaches to the new page and restores states of the agents. By that point the navigation may have made significant progress and the page's scripts may have executed to some point. It means that user agent overrides, inline script breakpoints, main resource load instrumentation etc. will not work. To fix this and bring it on par with same process navigation (same origin) we'd like to try and start creating inspected targets for provisional pages before they start loading. This will enable inspector front-end to intercept the control flow before sending main resource load request and configure all agents at the very early stage. Once the page navigation commits, all agents will be in proper state and no events will be missed for the new page. Another alternative we've discussed on #webkit-inspector was resurrecting inspector state cookie and passing it from old page to the new one transparently to the front-end and hiding all PSON details from the front-end. Such approach is deemed to require more complicated logic on the backend because in addition to the state maintenance it'd have to broadcast commands from the front-end to both current and provisional pages and buffer up responses until navigation commits or gets aborted. 1575018 1 379777 yurys 2019-09-27 17:29:23 -0700 Created attachment 379777 Patch 1575019 2 ews-watchlist 2019-09-27 17:30:09 -0700 This patch modifies the inspector protocol. Please ensure that any frontend changes appropriately use feature checks for new protocol features. 1575805 3 379967 yurys 2019-10-01 16:52:55 -0700 Created attachment 379967 Patch 1577532 4 379967 hi 2019-10-07 15:28:16 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review Generally, the high level idea seems fine. I'd like to have a better grasp of what specifically (and how) you plan on doing with these changes (e.g. what you are implying when you say "For now there are no changes frontend behavior") if possible, as that may help me better fit these changes into my mind :) > Source/WebCore/ChangeLog:11 > + (WebCore::InspectorController::setIsUnderTest): This method maybe closed several times Typo: "maybe closed" => "may be called" > Source/WebInspectorUI/ChangeLog:9 > + no changes frontend bhavior, it will wait for the provisional target to commit Typo: "bhavior" => "behavior" > Source/WebInspectorUI/ChangeLog:25 > + send commands to the provisional targtets yet, it has to ignore all activities Typo: "targtets" => "targets" > Source/WebInspectorUI/ChangeLog:30 > + Better support for provisional targets will be added to frontend in a separate change. Can we have bug URL for this? > Source/WebInspectorUI/ChangeLog:34 > + of tasrgetDestroyed/targetCreated events which matches previous behavior. Typo: "tasrgetDestroyed" => "targetDestroyed" > Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:139 > + return; Style: please add a newline after this return > Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:140 > + InspectorTarget* target = m_targets.get(committedTargetID); NIT: `auto*` > Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:142 > + return; Ditto (139) > Source/JavaScriptCore/inspector/protocol/Target.json:11 > + { "name": "isProvisional", "type": "boolean", "optional": true, "description": "Whether this is a provisional page target." }, NIT: I prefer putting `optional` values at the end of a type's declaration, so it's easier to read what's required vs what's optional > Source/JavaScriptCore/inspector/protocol/Target.json:12 > + { "name": "previousTargetId", "type": "string", "optional": true }, Ditto Also, where is this actually used? I don't see the frontend using this value at all. It uses `oldTargetId` from `Target.event.didCommitProvisionalTarget` instead. Can they be merged? I'd rather have the `oldTargetId` parameter than add another optional value to `Target.TargetInfo`. > Source/WebCore/inspector/InspectorController.cpp:346 > void InspectorController::setIsUnderTest(bool value) NIT: we could inline this in the header now that it's so small/simple > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:311 > // Ignore errors if a worker went away quickly. NIT: please move this comment to be above the `if` so it's clear what it's referring to > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:312 > + WorkerAgent.sendMessageToWorker(this._workerId, message).catch(e => { Style: please use a full/descriptive parameter name, like `error` Style: we always add the `(...)` around the parameters of an arrow function, even if there's only one argument ```js WorkerAgent.sendMessageToWorker(this._workerId, message).catch((error) => { ``` > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:313 > + if (this.target.isDestroyed()) If the target is already destroyed, shouldn't we not even be sending the command to begin with? We should probably add an assertion somewhere `console.assert(!this.target.isDestroyed);`. Or is this to handle the situation where the target is destroyed after the command is dispatched, but before the response is received? > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:315 > + throw e; Rather than re-throw, please use `WI.reportInternalException(error)` instead. We try to avoid using `throw` as much as possible. > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:339 > + TargetAgent.sendMessageToTarget(this._targetId, message).catch(e => { Ditto > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:342 > + if (this.target.isDestroyed()) Ditto > Source/WebInspectorUI/UserInterface/Protocol/Connection.js:344 > + throw e; Ditto > Source/WebInspectorUI/UserInterface/Protocol/Target.js:208 > + isDestroyed() Why not use a getter? ```js get isDestroyed() { return this._isDestroyed; } ``` > Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:32 > + this._provisionalTargetIds = new Set; > + this._swappedTargetIds = new Set; Please move this logic to `WI.TargetManager`. We try to keep our observer classes (which are responsible for handling events received by the frontend) as "clean" of logic as possible, and instead have the various managers and model objects handle the actual logic. > Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:37 > + if (targetInfo.isProvisional) { Please add a compatibility statement. ``` // COMPATIBILITY (iOS 13.0): `Target.TargetInfo.isProvisional` did not exist yet. > Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:44 > + didCommitProvisionalTarget(previousTargetId, targetInfo) Along the lines of 30-31, I'd create a `WI.TargetManager.prototype.didCommitProvisionalTarget` function and move this logic inside of that. I'd strongly prefer keeping the name the same, so it's easier to follow the code through the various layers/transformations. > Source/WebInspectorUI/UserInterface/Test/Test.js:107 > WI.transitionPageTarget = function(target) It seems like we should move these functions to `WI.TargetManager` so they don't get out of sync between 'Main.js' and 'Test.js'. > Source/WebKit/UIProcess/InspectorTargetProxy.cpp:47 > + auto target = create(provisionalPage.page(), targetId, type); NIT: I think for the purposes of code searching, I'd rather you also have the class name here too: ```cpp auto target = InspectorTargetProxy::create(provisionalPage.page(), targetId, type); ``` > Source/WebKit/UIProcess/InspectorTargetProxy.cpp:65 > + } > if (m_page.hasRunningProcess()) Style: missing newline (since the previous `if` has an early return) > Source/WebKit/UIProcess/InspectorTargetProxy.cpp:75 > + } > if (m_page.hasRunningProcess()) Ditto > Source/WebKit/UIProcess/InspectorTargetProxy.cpp:85 > + } > if (m_page.hasRunningProcess()) Ditto > Source/WebKit/UIProcess/InspectorTargetProxy.h:51 > + bool isProvisional() const override; NIT: these could all be `final` instead of `override` (or even omitted, since the class is marked `final`). > Source/WebKit/UIProcess/InspectorTargetProxy.h:62 > + ProvisionalPageProxy* m_provisionalPage = nullptr; Can we use `Optional<ProvisionalPageProxy>` instead of a raw pointer? Then we could simply `m_provisionalPage.reset()` instead of assigning it to `nullptr` in `InspectorTargetProxy::didCommitProvisionalTarget`. Style: please use uniform initialization syntax ```cpp ProvisionalPageProxy* m_provisionalPage { nullptr }; ``` > Source/WebKit/UIProcess/ProvisionalPageProxy.cpp:96 > + m_page.inspectorController().didDestroyProvisionalPage(*this, m_wasCommitted); Rather than go through the trouble of telling Web Inspector about this even when `m_wasCommitted` (which we then use to immediately return inside `WebPageInspectorController::didDestroyProvisionalPage`), can we just move this call below the early-return `if` below? Also, should this be the first call inside this function? That's usually where we normally put these types of lifecycle things (the `didCreate*` is the last line and the `willDestroy*` is the first line). > Source/WebKit/UIProcess/ProvisionalPageProxy.h:67 > - WebPageProxy& page() { return m_page; } > + WebPageProxy& page() const { return m_page; } Why was this changed? It seems like it's because `WebPageInspectorController::didDestroyProvisionalPage` requires a `const WebCore::PageIdentifier&`, but is there a reason why it has to be that way? Can you just pass it as a non-`const` reference? > Source/WebKit/UIProcess/WebPageInspectorController.cpp:61 > + String pageTargetId = WebPageInspectorTarget::toTargetID(m_page.webPageID()); > + createInspectorTarget(pageTargetId, Inspector::InspectorTargetType::Page); I think we still want this to be at the very end of `WebPageProxy::WebPageProxy`, to ensure that we're not trying to access any uninitialized data. > Source/WebKit/UIProcess/WebPageInspectorController.cpp:194 > + m_targetAgent->didCommitProvisionalTarget(oldID, newID); > + // We've disconnected from the old page and will not receive any message from it, so Style: missing newline > Source/WebKit/UIProcess/WebPageInspectorController.h:69 > + void didDestroyProvisionalPage(const ProvisionalPageProxy&, bool wasCommitted); Our normal "lifecycle" function names are `didCreate*` and `willDestroy*`. Technically, when `didDestroyProvisionalPage` is called, the `ProvisionalPageProxy` hasn't actually been destructed yet, so it's not entirely accurate to say that we "did" destroy it. > Source/WebKit/UIProcess/WebPageInspectorController.h:71 > + void didCommitProvisionalPage(const WebCore::PageIdentifier& oldWebPageID, const WebCore::PageIdentifier& newWebPageID); These probably shouldn't be references, as `PageIdentifier` is basically just a `uint64_t`. Other cases of `PageIdentifier` as a parameter also are not references. > Source/WebKit/UIProcess/WebPageInspectorController.h:81 > + HashMap<String, std::unique_ptr<InspectorTargetProxy>> m_targets; Could we use `WTF::UniqueRef` instead? I don't think we ever want a situation where we'd have a `nullptr` value in this map. > Source/WebKit/UIProcess/WebPageProxy.cpp:2983 > + const auto oldWebPageID = m_webPageID; Ditto (+WebPageInspectorController.h:71), specifically to the drop the `const`. > Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.cpp:50 > + if (m_channel) Should we `ASSERT(!m_channel);` to make sure that we're not trying to connect to a target more than once? > Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.cpp:72 > +String WebPageInspectorTarget::toTargetID(const WebCore::PageIdentifier& pageID) Ditto (+WebPageInspectorController.h:71) > Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 > + ~WebPageInspectorTargetFrontendChannel() override = default; `virtual ~WebPageInspectorTargetFrontendChannel() = default;` > LayoutTests/ChangeLog:13 > + * http/tests/inspector/target/target-events-for-proisional-page-expected.txt: Added. > + * http/tests/inspector/target/target-events-for-proisional-page.html: Added. Typo: "proisional" => "provisional" > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page-expected.txt:8 > +PASS: received targetCreated event. We try to phrase our test messages as a "Should ___." (e.g. `Should receive `targetCreated` event."), as well as using complete sentences. > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page-expected.txt:9 > +PASS: target is provisional. e.g. "Target should be provisional." > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:10 > + let suite = InspectorTest.createAsyncSuite("Target.PSON"); > + suite.addTestCase({ Style: missing newline > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:14 > + const targetAgent = InspectorBackend.domains.Target; `InspectorBackend.domains` exists only for feature checking purposes. It's not meant to be used for actual invocations of commands. I think a clearer approach to this would be to instead make your own `TestPSONTargetManager` that extends from `WI.TargetManager` and just overrides the functions you care about. ```js class TestPSONTargetManager extends TargetManager { targetCreated(targetInfo) { newTargetId = targetInfo.targetId; InspectorTest.pass(`received ${prop} event.`); InspectorTest.expectTrue(targetInfo.isProvisional, "target is provisional."); InspectorTest.expectEqual(targetInfo.previousTargetId, mainTargetId, "previos target id is id of the current target."); super.targetCreated(targetInfo); } didCommitProvisionalTarget(previousTargetId, targetInfo) { InspectorTest.pass(`received ${prop} event.`); InspectorTest.expectEqual(previousTargetId, mainTargetId, "previous target is the current one."); InspectorTest.expectEqual(targetInfo.targetId, newTargetId, "committed target matches provisional target."); super.targetCreated(targetInfo); } targetDestroyed(targetId) { InspectorTest.pass(`received ${prop} event.`); InspectorTest.expectEqual(targetId, mainTargetId, "destroyed target is previos target."); super.targetCreated(targetInfo); } } let testPSONTargetManager = new TestPSONTargetManager; WI.managers.splice(WI.managers.indexOf(WI.targetManager), 1, testPSONTargetManager); WI.targetManager = new TestPSONTargetManager; ``` This still feels quite "hacky", but it's not a bad solution. Another option is to just modify the prototype functions directly (e.g. `WI.TargetManager.prototype.targetCreated`), or to add special event dispatches that are only fired for tests. > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:25 > + InspectorTest.expectEqual(targetInfo.previousTargetId, mainTargetId, "previos target id is id of the current target."); Typo: "previos" => "previous" > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:40 > + InspectorTest.expectEqual(targetId, mainTargetId, "destroyed target is previos target."); Ditto > LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:61 > + 1. Target.targetCreated for provisional page. > + 2. Target.didCommitProvisionalTarget when provisional load is committed. > + 3. Target.targetDestroyed for the old target after the navigation request is committed. Please make these into separate `<p>` so it is printed somewhat nicely in the expected results file. > LayoutTests/platform/wk2/TestExpectations:767 > +# Target domain is only present in WebKit2. NIT: just `WK2` is fine :) 1577826 5 379967 yurys 2019-10-08 10:45:46 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >> Source/WebCore/ChangeLog:11 >> + (WebCore::InspectorController::setIsUnderTest): This method maybe closed several times > > Typo: "maybe closed" => "may be called" Done. >> Source/WebInspectorUI/ChangeLog:9 >> + no changes frontend bhavior, it will wait for the provisional target to commit > > Typo: "bhavior" => "behavior" Done. >> Source/WebInspectorUI/ChangeLog:25 >> + send commands to the provisional targtets yet, it has to ignore all activities > > Typo: "targtets" => "targets" Done. >> Source/WebInspectorUI/ChangeLog:30 >> + Better support for provisional targets will be added to frontend in a separate change. > > Can we have bug URL for this? I was going to use the same https://webkit.org/b/202219, so that it's easier to track what's going on across multiple patches in a single bug. >> Source/WebInspectorUI/ChangeLog:34 >> + of tasrgetDestroyed/targetCreated events which matches previous behavior. > > Typo: "tasrgetDestroyed" => "targetDestroyed" Done. >> Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:139 >> + return; > > Style: please add a newline after this return Done. >> Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:140 >> + InspectorTarget* target = m_targets.get(committedTargetID); > > NIT: `auto*` Done. >> Source/JavaScriptCore/inspector/agents/InspectorTargetAgent.cpp:142 >> + return; > > Ditto (139) Done. >> Source/JavaScriptCore/inspector/protocol/Target.json:11 >> + { "name": "isProvisional", "type": "boolean", "optional": true, "description": "Whether this is a provisional page target." }, > > NIT: I prefer putting `optional` values at the end of a type's declaration, so it's easier to read what's required vs what's optional Done. >> Source/JavaScriptCore/inspector/protocol/Target.json:12 >> + { "name": "previousTargetId", "type": "string", "optional": true }, > > Ditto > > Also, where is this actually used? I don't see the frontend using this value at all. It uses `oldTargetId` from `Target.event.didCommitProvisionalTarget` instead. Can they be merged? I'd rather have the `oldTargetId` parameter than add another optional value to `Target.TargetInfo`. I removed oldTargetId parameters in favor of TargetInfo.previousTargetId. I couldn't decide first between adding it as a field to the info structure and passing as a separate parameter in events. After talking to other folks about the experience with DevTools procol it seems better to just put it into the structure passed as a parameter in different target related events. It makes receiver's code more consistent and keeps the signatures of c++ classes sane. >> Source/WebCore/inspector/InspectorController.cpp:346 >> void InspectorController::setIsUnderTest(bool value) > > NIT: we could inline this in the header now that it's so small/simple Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:311 >> // Ignore errors if a worker went away quickly. > > NIT: please move this comment to be above the `if` so it's clear what it's referring to Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:312 >> + WorkerAgent.sendMessageToWorker(this._workerId, message).catch(e => { > > Style: please use a full/descriptive parameter name, like `error` > Style: we always add the `(...)` around the parameters of an arrow function, even if there's only one argument > ```js > WorkerAgent.sendMessageToWorker(this._workerId, message).catch((error) => { > ``` Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:313 >> + if (this.target.isDestroyed()) > > If the target is already destroyed, shouldn't we not even be sending the command to begin with? We should probably add an assertion somewhere `console.assert(!this.target.isDestroyed);`. > > Or is this to handle the situation where the target is destroyed after the command is dispatched, but before the response is received? It's the latter. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:315 >> + throw e; > > Rather than re-throw, please use `WI.reportInternalException(error)` instead. We try to avoid using `throw` as much as possible. Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:339 >> + TargetAgent.sendMessageToTarget(this._targetId, message).catch(e => { > > Ditto Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:342 >> + if (this.target.isDestroyed()) > > Ditto Done. >> Source/WebInspectorUI/UserInterface/Protocol/Connection.js:344 >> + throw e; > > Ditto Done. >> Source/WebInspectorUI/UserInterface/Protocol/Target.js:208 >> + isDestroyed() > > Why not use a getter? > ```js > get isDestroyed() { return this._isDestroyed; } > ``` Done. Normally I'd avoid getters/setters as the may hide side effects of seemingly innocent field access. It breaks the principle of least surprise. Basically with a method call it's obvious that it may run some logic while member access is normally expected to be a simple cheap operation with no extra behavior. I see that front-end uses getters/setters a lot so I'll just follow the same style. >> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:32 >> + this._swappedTargetIds = new Set; > > Please move this logic to `WI.TargetManager`. We try to keep our observer classes (which are responsible for handling events received by the frontend) as "clean" of logic as possible, and instead have the various managers and model objects handle the actual logic. Done. All methods of TargetOberver are pure delegates to a singleton instance of TargetManager, what's the purpose of this class? Why not register TargetManager as event handler directly? >> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:37 >> + if (targetInfo.isProvisional) { > > Please add a compatibility statement. > ``` > // COMPATIBILITY (iOS 13.0): `Target.TargetInfo.isProvisional` did not exist yet. Done. >> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:44 >> + didCommitProvisionalTarget(previousTargetId, targetInfo) > > Along the lines of 30-31, I'd create a `WI.TargetManager.prototype.didCommitProvisionalTarget` function and move this logic inside of that. I'd strongly prefer keeping the name the same, so it's easier to follow the code through the various layers/transformations. Done. >> Source/WebInspectorUI/UserInterface/Test/Test.js:107 >> WI.transitionPageTarget = function(target) > > It seems like we should move these functions to `WI.TargetManager` so they don't get out of sync between 'Main.js' and 'Test.js'. Done. >> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:47 >> + auto target = create(provisionalPage.page(), targetId, type); > > NIT: I think for the purposes of code searching, I'd rather you also have the class name here too: > ```cpp > auto target = InspectorTargetProxy::create(provisionalPage.page(), targetId, type); > ``` Done. But it'd be better to improve the tooling so that it understands such calls :) >> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:65 >> if (m_page.hasRunningProcess()) > > Style: missing newline (since the previous `if` has an early return) Done. >> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:75 >> if (m_page.hasRunningProcess()) > > Ditto Done. >> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:85 >> if (m_page.hasRunningProcess()) > > Ditto Done. >> Source/WebKit/UIProcess/InspectorTargetProxy.h:51 >> + bool isProvisional() const override; > > NIT: these could all be `final` instead of `override` (or even omitted, since the class is marked `final`). This contradicts webkit.org/b/200959#c13, let's agree on the approach to override/final over there and I can update this patch accordingly. Omitting override/final altogether causes clang warnings as I mentioned in that bug and there is an outstanding patch generated via clang-tidy that fixes the issue (see https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-override.html#modernize-use-override). >> Source/WebKit/UIProcess/InspectorTargetProxy.h:62 >> + ProvisionalPageProxy* m_provisionalPage = nullptr; > > Can we use `Optional<ProvisionalPageProxy>` instead of a raw pointer? Then we could simply `m_provisionalPage.reset()` instead of assigning it to `nullptr` in `InspectorTargetProxy::didCommitProvisionalTarget`. > > Style: please use uniform initialization syntax > ```cpp > ProvisionalPageProxy* m_provisionalPage { nullptr }; > ``` Updated the initializer. I believe you meant Optional<ProvisionalPageProxy&> as this class doesn't own ProvisionalPageProxy. What is the advantage of using more verbose Optional<ProvisionalPageProxy&> than a raw pointer here? WebKit style guide doesn't provide any specific recommendations about it. >> Source/WebKit/UIProcess/ProvisionalPageProxy.cpp:96 >> + m_page.inspectorController().didDestroyProvisionalPage(*this, m_wasCommitted); > > Rather than go through the trouble of telling Web Inspector about this even when `m_wasCommitted` (which we then use to immediately return inside `WebPageInspectorController::didDestroyProvisionalPage`), can we just move this call below the early-return `if` below? > > Also, should this be the first call inside this function? That's usually where we normally put these types of lifecycle things (the `didCreate*` is the last line and the `willDestroy*` is the first line). I tried to keep create/destroy notifications balanced no regardless of the provisional navigation outcome. That's the reason didDestroyProvisionalPage was before 'if (m_wasCommitted)' check. Updated the patch to only call didDestroyProvisionalPage for not committed pages. >> Source/WebKit/UIProcess/ProvisionalPageProxy.h:67 >> + WebPageProxy& page() const { return m_page; } > > Why was this changed? It seems like it's because `WebPageInspectorController::didDestroyProvisionalPage` requires a `const WebCore::PageIdentifier&`, but is there a reason why it has to be that way? Can you just pass it as a non-`const` reference? This is exactly as you described. The argument of didDestroyProvisionalPage is marked const as I'd like to indicate that it does't change its parameter. More generally marking a method as const if it's known to not change the instance's state gives the compiler more room for optimization. >> Source/WebKit/UIProcess/WebPageInspectorController.cpp:61 >> + createInspectorTarget(pageTargetId, Inspector::InspectorTargetType::Page); > > I think we still want this to be at the very end of `WebPageProxy::WebPageProxy`, to ensure that we're not trying to access any uninitialized data. This is how this code was already written I'm not changing it. If your goal is to protect against access to a partially initialized instance of WebPageProxy it should not be passed to the WebPageInspectorController until it's sufficiently initialized. Do you you prefer moving WebPageInspectorController call from member initialization in WebPageProxy to the end of the constructor or introducing separate method WebPageInspectorController::init(WebPageProxy& page) ? The latter means that the member pointing to WebPageProxy cannot be a reference anymore. >> Source/WebKit/UIProcess/WebPageInspectorController.cpp:194 >> + // We've disconnected from the old page and will not receive any message from it, so > > Style: missing newline Done. >> Source/WebKit/UIProcess/WebPageInspectorController.h:69 >> + void didDestroyProvisionalPage(const ProvisionalPageProxy&, bool wasCommitted); > > Our normal "lifecycle" function names are `didCreate*` and `willDestroy*`. Technically, when `didDestroyProvisionalPage` is called, the `ProvisionalPageProxy` hasn't actually been destructed yet, so it's not entirely accurate to say that we "did" destroy it. Done. >> Source/WebKit/UIProcess/WebPageInspectorController.h:71 >> + void didCommitProvisionalPage(const WebCore::PageIdentifier& oldWebPageID, const WebCore::PageIdentifier& newWebPageID); > > These probably shouldn't be references, as `PageIdentifier` is basically just a `uint64_t`. Other cases of `PageIdentifier` as a parameter also are not references. Yeah, it's used as a value type. Updated. >> Source/WebKit/UIProcess/WebPageInspectorController.h:81 >> + HashMap<String, std::unique_ptr<InspectorTargetProxy>> m_targets; > > Could we use `WTF::UniqueRef` instead? I don't think we ever want a situation where we'd have a `nullptr` value in this map. I can't seem to be able to use UniqueRef as a type of HashMap values because emptyValue() is not defined for it: DerivedSources/ForwardingHeaders/wtf/HashTraits.h:67:36: error: no matching constructor for initialization of 'WTF::UniqueRef<WebKit::InspectorTargetProxy>' static T emptyValue() { return T(); } ^ DerivedSources/ForwardingHeaders/wtf/HashTraits.h:78:55: note: in instantiation of member function 'WTF::GenericHashTraits<WTF::UniqueRef<WebKit::InspectorTargetProxy> >::emptyValue' requested here new (NotNull, std::addressof(slot)) T(Traits::emptyValue()); Also I don't see any examples in the code where UniqueRef would be used to store map values. >> Source/WebKit/UIProcess/WebPageProxy.cpp:2983 >> + const auto oldWebPageID = m_webPageID; > > Ditto (+WebPageInspectorController.h:71), specifically to the drop the `const`. This is different as it's not a reference here. I'd like to make sure oldWebPageID is not modified accidentally before it is passed to the inspector controller. >> Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.cpp:50 >> + if (m_channel) > > Should we `ASSERT(!m_channel);` to make sure that we're not trying to connect to a target more than once? I believe in the current implementation it's possible that connect() is called more than once with different front-end types. >> Source/WebKit/WebProcess/WebPage/WebPageInspectorTarget.cpp:72 >> +String WebPageInspectorTarget::toTargetID(const WebCore::PageIdentifier& pageID) > > Ditto (+WebPageInspectorController.h:71) Done. >> Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 >> + ~WebPageInspectorTargetFrontendChannel() override = default; > > `virtual ~WebPageInspectorTargetFrontendChannel() = default;` Why? It overrides virtual destructor in its superclass. >> LayoutTests/ChangeLog:13 >> + * http/tests/inspector/target/target-events-for-proisional-page.html: Added. > > Typo: "proisional" => "provisional" Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page-expected.txt:8 >> +PASS: received targetCreated event. > > We try to phrase our test messages as a "Should ___." (e.g. `Should receive `targetCreated` event."), as well as using complete sentences. Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page-expected.txt:9 >> +PASS: target is provisional. > > e.g. "Target should be provisional." Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:10 >> + suite.addTestCase({ > > Style: missing newline Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:14 >> + const targetAgent = InspectorBackend.domains.Target; > > `InspectorBackend.domains` exists only for feature checking purposes. It's not meant to be used for actual invocations of commands. > > I think a clearer approach to this would be to instead make your own `TestPSONTargetManager` that extends from `WI.TargetManager` and just overrides the functions you care about. > ```js > class TestPSONTargetManager extends TargetManager { > targetCreated(targetInfo) { > newTargetId = targetInfo.targetId; > InspectorTest.pass(`received ${prop} event.`); > InspectorTest.expectTrue(targetInfo.isProvisional, "target is provisional."); > InspectorTest.expectEqual(targetInfo.previousTargetId, mainTargetId, "previos target id is id of the current target."); > > super.targetCreated(targetInfo); > } > > didCommitProvisionalTarget(previousTargetId, targetInfo) { > InspectorTest.pass(`received ${prop} event.`); > InspectorTest.expectEqual(previousTargetId, mainTargetId, "previous target is the current one."); > InspectorTest.expectEqual(targetInfo.targetId, newTargetId, "committed target matches provisional target."); > > super.targetCreated(targetInfo); > } > > targetDestroyed(targetId) { > InspectorTest.pass(`received ${prop} event.`); > InspectorTest.expectEqual(targetId, mainTargetId, "destroyed target is previos target."); > > super.targetCreated(targetInfo); > } > } > > let testPSONTargetManager = new TestPSONTargetManager; > WI.managers.splice(WI.managers.indexOf(WI.targetManager), 1, testPSONTargetManager); > WI.targetManager = new TestPSONTargetManager; > ``` > > This still feels quite "hacky", but it's not a bad solution. Another option is to just modify the prototype functions directly (e.g. `WI.TargetManager.prototype.targetCreated`), or to add special event dispatches that are only fired for tests. I don't like the idea of deriving from TargetManager which is called indirectly when dispatching protocol commands, I'd like to be as close as possible to the target domain handler. Ideally this would be a protocol test if it didn't depend on the dummy page and supported target domain but this is a different problem. I changed the code to use TargetAgent similar to how other tests use *Agents. I hope this will be changed to a clean protocol test eventually. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:25 >> + InspectorTest.expectEqual(targetInfo.previousTargetId, mainTargetId, "previos target id is id of the current target."); > > Typo: "previos" => "previous" Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:40 >> + InspectorTest.expectEqual(targetId, mainTargetId, "destroyed target is previos target."); > > Ditto Done. >> LayoutTests/http/tests/inspector/target/target-events-for-proisional-page.html:61 >> + 3. Target.targetDestroyed for the old target after the navigation request is committed. > > Please make these into separate `<p>` so it is printed somewhat nicely in the expected results file. Done. >> LayoutTests/platform/wk2/TestExpectations:767 >> +# Target domain is only present in WebKit2. > > NIT: just `WK2` is fine :) Most of the other comments in this file use WebKit2 so I'd rather be consistent. 1577828 6 380442 yurys 2019-10-08 10:47:24 -0700 Created attachment 380442 Patch 1577855 7 379967 hi 2019-10-08 11:42:57 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >>> Source/WebInspectorUI/ChangeLog:30 >>> + Better support for provisional targets will be added to frontend in a separate change. >> >> Can we have bug URL for this? > > I was going to use the same https://webkit.org/b/202219, so that it's easier to track what's going on across multiple patches in a single bug. I'd prefer if you created separate bugs for each and have a blocking/blocked-by hierarchy. It can be confusing to have multiple unrelated patches come from the same URL/title. >>> Source/JavaScriptCore/inspector/protocol/Target.json:12 >>> + { "name": "previousTargetId", "type": "string", "optional": true }, >> >> Ditto >> >> Also, where is this actually used? I don't see the frontend using this value at all. It uses `oldTargetId` from `Target.event.didCommitProvisionalTarget` instead. Can they be merged? I'd rather have the `oldTargetId` parameter than add another optional value to `Target.TargetInfo`. > > I removed oldTargetId parameters in favor of TargetInfo.previousTargetId. I couldn't decide first between adding it as a field to the info structure and passing as a separate parameter in events. After talking to other folks about the experience with DevTools procol it seems better to just put it into the structure passed as a parameter in different target related events. It makes receiver's code more consistent and keeps the signatures of c++ classes sane. NIT: I personally would've preferred keeping it as an additional parameter to `didCommitProvisionalTarget`, as it keeps `TargetInfo` more general and clean of event-specific information. >>> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:32 >>> + this._swappedTargetIds = new Set; >> >> Please move this logic to `WI.TargetManager`. We try to keep our observer classes (which are responsible for handling events received by the frontend) as "clean" of logic as possible, and instead have the various managers and model objects handle the actual logic. > > Done. All methods of TargetOberver are pure delegates to a singleton instance of TargetManager, what's the purpose of this class? Why not register TargetManager as event handler directly? Observers are created per-target, whereas the managers are global singletons. Even though the observers are basically pure-delegates, they do often handle some of the compatibility work, or are responsible for telling the manager what target the event came from (see `WI.DebuggerObserver` for examples). >>> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:47 >>> + auto target = create(provisionalPage.page(), targetId, type); >> >> NIT: I think for the purposes of code searching, I'd rather you also have the class name here too: >> ```cpp >> auto target = InspectorTargetProxy::create(provisionalPage.page(), targetId, type); >> ``` > > Done. But it'd be better to improve the tooling so that it understands such calls :) That puts the onus on the tooling. As an example, I sometimes use basic `grep` (or `ack`) to quickly search through the codebase from terminal. I shouldn't have to use some "special" tool in order to do basic searching of things. >>> Source/WebKit/UIProcess/InspectorTargetProxy.h:62 >>> + ProvisionalPageProxy* m_provisionalPage = nullptr; >> >> Can we use `Optional<ProvisionalPageProxy>` instead of a raw pointer? Then we could simply `m_provisionalPage.reset()` instead of assigning it to `nullptr` in `InspectorTargetProxy::didCommitProvisionalTarget`. >> >> Style: please use uniform initialization syntax >> ```cpp >> ProvisionalPageProxy* m_provisionalPage { nullptr }; >> ``` > > Updated the initializer. > > I believe you meant Optional<ProvisionalPageProxy&> as this class doesn't own ProvisionalPageProxy. What is the advantage of using more verbose Optional<ProvisionalPageProxy&> than a raw pointer here? WebKit style guide doesn't provide any specific recommendations about it. WebKit as a whole is trying to move away from using raw pointers wherever possible. Frankly, I'd be even happier to use `WeakPtr<ProvisionalPageProxy>` so we have greater safeguards against UAF, but Web Inspector is unlikely to run into these issues because of our instrumentation points being in the right places. >>> Source/WebKit/UIProcess/WebPageInspectorController.cpp:61 >>> + createInspectorTarget(pageTargetId, Inspector::InspectorTargetType::Page); >> >> I think we still want this to be at the very end of `WebPageProxy::WebPageProxy`, to ensure that we're not trying to access any uninitialized data. > > This is how this code was already written I'm not changing it. If your goal is to protect against access to a partially initialized instance of WebPageProxy it should not be passed to the WebPageInspectorController until it's sufficiently initialized. Do you you prefer moving WebPageInspectorController call from member initialization in WebPageProxy to the end of the constructor or introducing separate method WebPageInspectorController::init(WebPageProxy& page) ? The latter means that the member pointing to WebPageProxy cannot be a reference anymore. Yes the code may be the same, but where you're calling it from is vastly different. The previous location of this was in `WebPageProxy::createInspectorTargets`, which was called at the very end of `WebPageProxy::WebPageProxy`. This is now called halfway through that function, as part of `m_inspectorController`'s initialization. That difference could cause problems later down the line for other developers who are unaware of Web Inspector specific code, so I'd prefer if we kept the location to be functionally equivalent to what it was before, likely by just calling this code at the end of `WebPageProxy::WebPageProxy` (or restoring `WebPageProxy::createInspectorTargets`). >>> Source/WebKit/UIProcess/WebPageInspectorController.h:81 >>> + HashMap<String, std::unique_ptr<InspectorTargetProxy>> m_targets; >> >> Could we use `WTF::UniqueRef` instead? I don't think we ever want a situation where we'd have a `nullptr` value in this map. > > I can't seem to be able to use UniqueRef as a type of HashMap values because emptyValue() is not defined for it: > > DerivedSources/ForwardingHeaders/wtf/HashTraits.h:67:36: error: no matching constructor for initialization of 'WTF::UniqueRef<WebKit::InspectorTargetProxy>' > static T emptyValue() { return T(); } > ^ > DerivedSources/ForwardingHeaders/wtf/HashTraits.h:78:55: note: in instantiation of member function 'WTF::GenericHashTraits<WTF::UniqueRef<WebKit::InspectorTargetProxy> >::emptyValue' requested here > new (NotNull, std::addressof(slot)) T(Traits::emptyValue()); > > Also I don't see any examples in the code where UniqueRef would be used to store map values. Ah, right, there's no empty value for a `UniqueRef`. I suppose this is fine then. >>> Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 >>> + ~WebPageInspectorTargetFrontendChannel() override = default; >> >> `virtual ~WebPageInspectorTargetFrontendChannel() = default;` > > Why? It overrides virtual destructor in its superclass. We have never done this anywhere in WebKit. It's also a bit weird, because this doesn't "technically" override the destructor, as the super class' destructor will still get called. 1577967 8 379967 yurys 2019-10-08 14:58:48 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >>>> Source/WebInspectorUI/ChangeLog:30 >>>> + Better support for provisional targets will be added to frontend in a separate change. >>> >>> Can we have bug URL for this? >> >> I was going to use the same https://webkit.org/b/202219, so that it's easier to track what's going on across multiple patches in a single bug. > > I'd prefer if you created separate bugs for each and have a blocking/blocked-by hierarchy. It can be confusing to have multiple unrelated patches come from the same URL/title. Filed https://bugs.webkit.org/show_bug.cgi?id=202704 >>>> Source/JavaScriptCore/inspector/protocol/Target.json:12 >>>> + { "name": "previousTargetId", "type": "string", "optional": true }, >>> >>> Ditto >>> >>> Also, where is this actually used? I don't see the frontend using this value at all. It uses `oldTargetId` from `Target.event.didCommitProvisionalTarget` instead. Can they be merged? I'd rather have the `oldTargetId` parameter than add another optional value to `Target.TargetInfo`. >> >> I removed oldTargetId parameters in favor of TargetInfo.previousTargetId. I couldn't decide first between adding it as a field to the info structure and passing as a separate parameter in events. After talking to other folks about the experience with DevTools procol it seems better to just put it into the structure passed as a parameter in different target related events. It makes receiver's code more consistent and keeps the signatures of c++ classes sane. > > NIT: I personally would've preferred keeping it as an additional parameter to `didCommitProvisionalTarget`, as it keeps `TargetInfo` more general and clean of event-specific information. This field is now used in all events where TargetInfo is passed as parameter so I'd rather keep it inside the structure. Let me know if it doesn't make sense to you. >>>> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:32 >>>> + this._swappedTargetIds = new Set; >>> >>> Please move this logic to `WI.TargetManager`. We try to keep our observer classes (which are responsible for handling events received by the frontend) as "clean" of logic as possible, and instead have the various managers and model objects handle the actual logic. >> >> Done. All methods of TargetOberver are pure delegates to a singleton instance of TargetManager, what's the purpose of this class? Why not register TargetManager as event handler directly? > > Observers are created per-target, whereas the managers are global singletons. Even though the observers are basically pure-delegates, they do often handle some of the compatibility work, or are responsible for telling the manager what target the event came from (see `WI.DebuggerObserver` for examples). Do they ever store any state except for the target they are attached to? I'm thinking about the case when such manager would have to listen to provisional and current targets at the same time and keep their states separately somehow. This would essentially mean that each bit of the state should be associated with a target. >>>> Source/WebKit/UIProcess/InspectorTargetProxy.cpp:47 >>>> + auto target = create(provisionalPage.page(), targetId, type); >>> >>> NIT: I think for the purposes of code searching, I'd rather you also have the class name here too: >>> ```cpp >>> auto target = InspectorTargetProxy::create(provisionalPage.page(), targetId, type); >>> ``` >> >> Done. But it'd be better to improve the tooling so that it understands such calls :) > > That puts the onus on the tooling. As an example, I sometimes use basic `grep` (or `ack`) to quickly search through the codebase from terminal. I shouldn't have to use some "special" tool in order to do basic searching of things. Yeah, this is what I'm saying, it's 21 century and it'd be nice to have an IDE that supported nice code navigation rather than relying on plain text search. But there is still no good enough solution for c++ :) >>>> Source/WebKit/UIProcess/InspectorTargetProxy.h:62 >>>> + ProvisionalPageProxy* m_provisionalPage = nullptr; >>> >>> Can we use `Optional<ProvisionalPageProxy>` instead of a raw pointer? Then we could simply `m_provisionalPage.reset()` instead of assigning it to `nullptr` in `InspectorTargetProxy::didCommitProvisionalTarget`. >>> >>> Style: please use uniform initialization syntax >>> ```cpp >>> ProvisionalPageProxy* m_provisionalPage { nullptr }; >>> ``` >> >> Updated the initializer. >> >> I believe you meant Optional<ProvisionalPageProxy&> as this class doesn't own ProvisionalPageProxy. What is the advantage of using more verbose Optional<ProvisionalPageProxy&> than a raw pointer here? WebKit style guide doesn't provide any specific recommendations about it. > > WebKit as a whole is trying to move away from using raw pointers wherever possible. Frankly, I'd be even happier to use `WeakPtr<ProvisionalPageProxy>` so we have greater safeguards against UAF, but Web Inspector is unlikely to run into these issues because of our instrumentation points being in the right places. Using WeakPtr does make sense here as it protects against UAF, thanks for the pointer! I didn't know that WebKit was trying to use it. Also there is nothing special about inspector that would make its code less susceptible to this sort of bugs compared to other components. Replaced raw pointer with WeakPtr. It may also make sense to update references to WebPageProxy from inspector structures to use WeakPtr as well. WDYT? >>>> Source/WebKit/UIProcess/WebPageInspectorController.cpp:61 >>>> + createInspectorTarget(pageTargetId, Inspector::InspectorTargetType::Page); >>> >>> I think we still want this to be at the very end of `WebPageProxy::WebPageProxy`, to ensure that we're not trying to access any uninitialized data. >> >> This is how this code was already written I'm not changing it. If your goal is to protect against access to a partially initialized instance of WebPageProxy it should not be passed to the WebPageInspectorController until it's sufficiently initialized. Do you you prefer moving WebPageInspectorController call from member initialization in WebPageProxy to the end of the constructor or introducing separate method WebPageInspectorController::init(WebPageProxy& page) ? The latter means that the member pointing to WebPageProxy cannot be a reference anymore. > > Yes the code may be the same, but where you're calling it from is vastly different. The previous location of this was in `WebPageProxy::createInspectorTargets`, which was called at the very end of `WebPageProxy::WebPageProxy`. This is now called halfway through that function, as part of `m_inspectorController`'s initialization. That difference could cause problems later down the line for other developers who are unaware of Web Inspector specific code, so I'd prefer if we kept the location to be functionally equivalent to what it was before, likely by just calling this code at the end of `WebPageProxy::WebPageProxy` (or restoring `WebPageProxy::createInspectorTargets`). Moved this to init() method which is called when WebPageProxy is fully initialized. PTAL. >>>> Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 >>>> + ~WebPageInspectorTargetFrontendChannel() override = default; >>> >>> `virtual ~WebPageInspectorTargetFrontendChannel() = default;` >> >> Why? It overrides virtual destructor in its superclass. > > We have never done this anywhere in WebKit. It's also a bit weird, because this doesn't "technically" override the destructor, as the super class' destructor will still get called. Well, overriding method in general is free to call super class's implementation I don't see any issues with that. Here is an excerpt from the WebKit style guide (https://webkit.org/code-style-guidelines/#override-methods) which clearly says that overriding methods should be annotated as either override or final: "All subclasses of that class must either specify the override keyword when overriding the virtual method or the final keyword when overriding the virtual method and requiring that no further subclasses can override it." I believe the reason there is still a lot of code that violates the rule is that they predate c++11 usage in WebKit and nobody bothered updating them. Maybe worth bringing this up on webkit-dev. Annotating the destructor with override protects against a nasty error when super destructor accidentally not not marked as virtual but the clients try to destroy the object using its superclass interface. 1577968 9 379967 yurys 2019-10-08 15:01:27 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >>> Source/WebCore/inspector/InspectorController.cpp:346 >>> void InspectorController::setIsUnderTest(bool value) >> >> NIT: we could inline this in the header now that it's so small/simple > > Done. Actually this doesn't work: ERROR: Source/WebCore/inspector/InspectorController.h:104: Inline functions should not be annotated with WEBCORE_EXPORT. Remove the macro, or move the inline function definition out-of-line. [build/webcore_export] [4] 1577977 10 379967 hi 2019-10-08 15:22:00 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >>>> Source/WebCore/inspector/InspectorController.cpp:346 >>>> void InspectorController::setIsUnderTest(bool value) >>> >>> NIT: we could inline this in the header now that it's so small/simple >> >> Done. > > Actually this doesn't work: > > ERROR: Source/WebCore/inspector/InspectorController.h:104: Inline functions should not be annotated with WEBCORE_EXPORT. Remove the macro, or move the inline function definition out-of-line. [build/webcore_export] [4] We can remove the macro if it's in the header. >>>>> Source/WebInspectorUI/UserInterface/Protocol/TargetObserver.js:32 >>>>> + this._swappedTargetIds = new Set; >>>> >>>> Please move this logic to `WI.TargetManager`. We try to keep our observer classes (which are responsible for handling events received by the frontend) as "clean" of logic as possible, and instead have the various managers and model objects handle the actual logic. >>> >>> Done. All methods of TargetOberver are pure delegates to a singleton instance of TargetManager, what's the purpose of this class? Why not register TargetManager as event handler directly? >> >> Observers are created per-target, whereas the managers are global singletons. Even though the observers are basically pure-delegates, they do often handle some of the compatibility work, or are responsible for telling the manager what target the event came from (see `WI.DebuggerObserver` for examples). > > Do they ever store any state except for the target they are attached to? I'm thinking about the case when such manager would have to listen to provisional and current targets at the same time and keep their states separately somehow. This would essentially mean that each bit of the state should be associated with a target. My changes in <https://webkit.org/b/200384> pass in both the associated agent and target, both of which are able to be used (if needed) by the various observer subclasses. One thing that's worth mentioning is that in the case of the `WI.TargetObserver`, the `this._target` would actually be the direct connection to the `WebPage`, so it likely wouldn't be needed for really anything. The `this._target` is more useful for the rest of the domains (see `WI.DebuggerObserver` for examples). >>>>> Source/WebKit/UIProcess/InspectorTargetProxy.h:62 >>>>> + ProvisionalPageProxy* m_provisionalPage = nullptr; >>>> >>>> Can we use `Optional<ProvisionalPageProxy>` instead of a raw pointer? Then we could simply `m_provisionalPage.reset()` instead of assigning it to `nullptr` in `InspectorTargetProxy::didCommitProvisionalTarget`. >>>> >>>> Style: please use uniform initialization syntax >>>> ```cpp >>>> ProvisionalPageProxy* m_provisionalPage { nullptr }; >>>> ``` >>> >>> Updated the initializer. >>> >>> I believe you meant Optional<ProvisionalPageProxy&> as this class doesn't own ProvisionalPageProxy. What is the advantage of using more verbose Optional<ProvisionalPageProxy&> than a raw pointer here? WebKit style guide doesn't provide any specific recommendations about it. >> >> WebKit as a whole is trying to move away from using raw pointers wherever possible. Frankly, I'd be even happier to use `WeakPtr<ProvisionalPageProxy>` so we have greater safeguards against UAF, but Web Inspector is unlikely to run into these issues because of our instrumentation points being in the right places. > > Using WeakPtr does make sense here as it protects against UAF, thanks for the pointer! I didn't know that WebKit was trying to use it. Also there is nothing special about inspector that would make its code less susceptible to this sort of bugs compared to other components. Replaced raw pointer with WeakPtr. > > It may also make sense to update references to WebPageProxy from inspector structures to use WeakPtr as well. WDYT? I think generally it's safer to have anything that uses a raw pointer use a `WeakPtr` (or a `RefPtr`, but that has other issues [1]) instead. That should likely be done in a separate patch though. [1]: Web Inspector sometimes can't make use of `Ref`/`RefPtr` because we don't want to change the lifecycle of the object we're inspecting (see `Node`, `WebSocket`, `CanvasRenderingContext`, `WebGLProgram`, `WebGPUDevice`, or `WebGPUPipeline` for examples). >>>>> Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 >>>>> + ~WebPageInspectorTargetFrontendChannel() override = default; >>>> >>>> `virtual ~WebPageInspectorTargetFrontendChannel() = default;` >>> >>> Why? It overrides virtual destructor in its superclass. >> >> We have never done this anywhere in WebKit. It's also a bit weird, because this doesn't "technically" override the destructor, as the super class' destructor will still get called. > > Well, overriding method in general is free to call super class's implementation I don't see any issues with that. > > Here is an excerpt from the WebKit style guide (https://webkit.org/code-style-guidelines/#override-methods) which clearly says that overriding methods should be annotated as either override or final: > "All subclasses of that class must either specify the override keyword when overriding the virtual method or the final keyword when overriding the virtual method and requiring that no further subclasses can override it." > > I believe the reason there is still a lot of code that violates the rule is that they predate c++11 usage in WebKit and nobody bothered updating them. Maybe worth bringing this up on webkit-dev. Annotating the destructor with override protects against a nasty error when super destructor accidentally not not marked as virtual but the clients try to destroy the object using its superclass interface. That may be the case, but for now I'd ask you to use `virtual`, as it seems like that's what we use everywhere else in WebKit. Personally, I would also argue that constructors and destructors are considered a different "type" of method than other member functions, so that affects my stance on this too. Feel free to broach the subject on webkit-dev. 1578018 11 379967 yurys 2019-10-08 16:56:39 -0700 Comment on attachment 379967 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=379967&action=review >>>>> Source/WebCore/inspector/InspectorController.cpp:346 >>>>> void InspectorController::setIsUnderTest(bool value) >>>> >>>> NIT: we could inline this in the header now that it's so small/simple >>> >>> Done. >> >> Actually this doesn't work: >> >> ERROR: Source/WebCore/inspector/InspectorController.h:104: Inline functions should not be annotated with WEBCORE_EXPORT. Remove the macro, or move the inline function definition out-of-line. [build/webcore_export] [4] > > We can remove the macro if it's in the header. Done. >>>>>> Source/WebKit/WebProcess/WebPage/WebPageInspectorTargetFrontendChannel.h:41 >>>>>> + ~WebPageInspectorTargetFrontendChannel() override = default; >>>>> >>>>> `virtual ~WebPageInspectorTargetFrontendChannel() = default;` >>>> >>>> Why? It overrides virtual destructor in its superclass. >>> >>> We have never done this anywhere in WebKit. It's also a bit weird, because this doesn't "technically" override the destructor, as the super class' destructor will still get called. >> >> Well, overriding method in general is free to call super class's implementation I don't see any issues with that. >> >> Here is an excerpt from the WebKit style guide (https://webkit.org/code-style-guidelines/#override-methods) which clearly says that overriding methods should be annotated as either override or final: >> "All subclasses of that class must either specify the override keyword when overriding the virtual method or the final keyword when overriding the virtual method and requiring that no further subclasses can override it." >> >> I believe the reason there is still a lot of code that violates the rule is that they predate c++11 usage in WebKit and nobody bothered updating them. Maybe worth bringing this up on webkit-dev. Annotating the destructor with override protects against a nasty error when super destructor accidentally not not marked as virtual but the clients try to destroy the object using its superclass interface. > > That may be the case, but for now I'd ask you to use `virtual`, as it seems like that's what we use everywhere else in WebKit. Personally, I would also argue that constructors and destructors are considered a different "type" of method than other member functions, so that affects my stance on this too. Feel free to broach the subject on webkit-dev. Raised this on webkit-dev, let's discuss there and I'll update the patch to follow the conclusion. 379777 2019-09-27 17:29:23 -0700 2019-10-01 16:52:53 -0700 Patch bug-202219-20190927172922.patch text/plain 53588 yurys U3VidmVyc2lvbiBSZXZpc2lvbjogMjUwNDMxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz N2UzOGNlYzEzMTY1MmQyOTZkNTczY2Q2MTIzNTJlZmY0NjIyMjAyLi45MDgwMmE0NTdmM2NhNTAz ODg4MjQwZDA2NTc5MzJhODg4YzI4MWM4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNiBAQAorMjAxOS0wOS0yNyAgWXVyeSBTZW1pa2hhdHNreSAgPHl1cnlzQGNocm9taXVt Lm9yZz4KKworICAgICAgICBXZWIgSW5zcGVjdG9yOiBhdHRhY2ggdG8gcHJvdmlzaW9uYWwgcGFn ZXMgZWFybHkgdG8gbm90IG1pc3MgZXZlbnRzIGR1cmluZyBwcm9jZXNzIHN3YXBzIChQU09OKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyMjE5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBpbnNwZWN0 b3IvSW5zcGVjdG9yVGFyZ2V0Lmg6IGNoYW5nZWQgSW5zcGVjdG9yVGFyZ2V0IHRvIG5vdCByZXF1 aXJlIEZyb250ZW5kQ2hhbm5lbCBhcworICAgICAgICBhbGwgbWVzc2FnZXMgYXJlIHJvdXRlZCBi eSBtZWFucyBvZiB0aGUgb3duaW5nIEluc3BlY3RvclRhcmdldEFnZW50LgorICAgICAgICAqIGlu c3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6SW5zcGVjdG9yVGFyZ2V0QWdlbnQpOgorICAgICAg ICAoSW5zcGVjdG9yOjpidWlsZFRhcmdldEluZm9PYmplY3QpOgorICAgICAgICAoSW5zcGVjdG9y OjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6dGFyZ2V0Q3JlYXRlZCk6CisgICAgICAgIChJbnNwZWN0 b3I6Okluc3BlY3RvclRhcmdldEFnZW50Ojp0YXJnZXREZXN0cm95ZWQpOgorICAgICAgICAoSW5z cGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQp OiB0aGlzIG1ldGhvZCBpcyB1c2VkIHRvCisgICAgICAgIG5vdGlmeSBmcm9udGVuZCB0aGF0IGNv cnJlc3BvbmRpbmcgcHJvdmlzaW9uYWwgdGFyZ2V0IGhhcyBjb21taXR0ZWQgYW5kIHJlcGxhY2Vk IHByZXZpb3VzCisgICAgICAgIHRhcmdldC4KKyAgICAgICAgKEluc3BlY3Rvcjo6SW5zcGVjdG9y VGFyZ2V0QWdlbnQ6OmNvbm5lY3Rpb25UeXBlIGNvbnN0KToKKyAgICAgICAgKEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3RUb1RhcmdldHMpOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlzY29ubmVjdEZyb21UYXJnZXRzKToKKyAgICAg ICAgKiBpbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50Lmg6CisgICAgICAgICog aW5zcGVjdG9yL3Byb3RvY29sL1RhcmdldC5qc29uOgorCiAyMDE5LTA5LTI2ICBZdXN1a2UgU3V6 dWtpICA8eXN1enVraUBhcHBsZS5jb20+CiAKICAgICAgICAgW0pTQ10gREZHIHJlY3Vyc2l2ZS10 YWlsLWNhbGwgb3B0aW1pemF0aW9uIHNob3VsZCBub3QgZW1pdCBqdW1wIHRvIGNhbGwtZnJhbWUg d2l0aCB2YXJhcmdzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvQ2hhbmdlTG9n IGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwppbmRleCBjZTJmODE2ZGRlODc2NWI0 ZDk3NTJmNjEyNzQ2Nzc1ZWNmZjY4NTE0Li4wNDFlMDMzOTc0MzBhYTAwNjhkMDYwNDcxNGI1OWEz NDNhYmQ1ZmM5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAx OS0wOS0yNyAgWXVyeSBTZW1pa2hhdHNreSAgPHl1cnlzQGNocm9taXVtLm9yZz4KKworICAgICAg ICBXZWIgSW5zcGVjdG9yOiBhdHRhY2ggdG8gcHJvdmlzaW9uYWwgcGFnZXMgZWFybHkgdG8gbm90 IG1pc3MgZXZlbnRzIGR1cmluZyBwcm9jZXNzIHN3YXBzIChQU09OKQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyMjE5CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVXBkYXRlZCBmcm9udGVuZCBjb2RlIHRv IHVuZGVyc3RhbmQgcHJvdmlzaW9uYWwgdGFyZ2V0cy4gRm9yIG5vdyB0aGVyZSBhcmUKKyAgICAg ICAgbm8gY2hhbmdlcyBmcm9udGVuZCBiaGF2aW9yLCBpdCB3aWxsIHdhaXQgZm9yIHRoZSBwcm92 aXNpb25hbCB0YXJnZXQgdG8gY29tbWl0CisgICAgICAgIGFuZCB3aWxsIG5vdCBzZW5kIGFueSBj b21tYW5kcyB0byBpdCBiZWZvcmUgdGhhdC4KKworICAgICAgICAqIFVzZXJJbnRlcmZhY2UvUHJv dG9jb2wvVGFyZ2V0T2JzZXJ2ZXIuanM6IHNpbmNlIHRoZSBmcm9udC1lbmQgZG9lc24ndAorICAg ICAgICBzZW5kIGNvbW1hbmRzIHRvIHRoZSBwcm92aXNpb25hbCB0YXJndGV0cyB5ZXQsIGl0IGhh cyB0byBpZ25vcmUgYWxsIGFjdGl2aXRpZXMKKyAgICAgICAgcmVsYXRlZCB0byBwcm92aXNpb25h bCBwYWdlcy4gRm9yIHRoYXQgcmVhc29uIHdlIG5lZWQgdG8gbWFwcyB0byBrZWVwIHRyYWNrIG9m CisgICAgICAgIC0gcHJvdmlzaW9uYWwgcGFnZXMgdGhhdCB3ZXJlIGRlc3Ryb3llZCBhbmQgbmV2 ZXIgY29tbWl0dGVkCisgICAgICAgIC0gb2xkIHBhZ2VzIHdoaWNoIHdlcmUgcmVwbGFjZWQgYnkg Y29tbWl0dGVkIHBhZ2UgYW5kIGZvciB3aGljaCBmb2xsb3dpbmcgdGFyZ2V0RGVzdHJveWVkCisg ICAgICAgIGV2ZW50IHNob3VsZCBiZSBpZ25vcmVkCisgICAgICAgIEJldHRlciBzdXBwb3J0IGZv ciBwcm92aXNpb25hbCB0YXJnZXRzIHdpbGwgYmUgYWRkZWQgdG8gZnJvbnRlbmQgaW4gYSBzZXBh cmF0ZSBjaGFuZ2UuCisgICAgICAgIChXSS5UYXJnZXRPYnNlcnZlcik6CisgICAgICAgIChXSS5U YXJnZXRPYnNlcnZlci5wcm90b3R5cGUudGFyZ2V0Q3JlYXRlZCk6CisgICAgICAgIChXSS5UYXJn ZXRPYnNlcnZlci5wcm90b3R5cGUuZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQpOgorICAgICAg ICAoV0kuVGFyZ2V0T2JzZXJ2ZXIucHJvdG90eXBlLnRhcmdldERlc3Ryb3llZCk6CisgICAgICAg IChXSS5UYXJnZXRPYnNlcnZlci5wcm90b3R5cGUuZGlzcGF0Y2hNZXNzYWdlRnJvbVRhcmdldCk6 CisKIDIwMTktMDktMjYgIEpvc2VwaCBQZWNvcmFybyAgPHBlY29yYXJvQGFwcGxlLmNvbT4KIAog ICAgICAgICBXZWIgSW5zcGVjdG9yOiBJbmNsdWRlIExvY2FsUmVzb3VyY2VPdmVycmlkZXMgaW4g dGhlIE9wZW4gUmVzb3VyY2UgZGlhbG9nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5n ZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGMyNTZiMTJmZjhhNzVlYTQzZTY2 NGFlNWNjZWEwZGE0ZTk3OGM1YzUuLmNiZTQxOTNlZDZhOTVjZGI3NWU0N2YyMGVjOGFkYTdmZmU2 NzkzMTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9X ZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjUgQEAKKzIwMTktMDktMjcgIFl1cnkgU2VtaWto YXRza3kgIDx5dXJ5c0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogYXR0 YWNoIHRvIHByb3Zpc2lvbmFsIHBhZ2VzIGVhcmx5IHRvIG5vdCBtaXNzIGV2ZW50cyBkdXJpbmcg cHJvY2VzcyBzd2FwcyAoUFNPTikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwMjIxOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFRhcmdldC50YXJnZXRDcmVhdGVkIGV2ZW50IGlzIG5vdCBnZW5lcmF0ZWQg Zm9yIHByb3Zpc2lvbmFsIHBhZ2VzIGFzIHdlbGwgYXMgZm9yIHJlZ3VsYXIKKyAgICAgICAgb25l cy4gVGhpcyBpcyB0aGUgZmlyc3Qgc3RlcCB0b3dhcmRzIHJlYXR0YWNoaW5nIGluc3BlY3RvciBl YXJsaWVyIGR1cmluZyBQU09OLiBJbiB0aGUgZnV0dXJlCisgICAgICAgIGlmIGRlYnVnZ2luZyBp cyBpbiBwcm9ncmVzcyB0aGUgcHJvdmlzaW9uYWwgdGFyZ2V0IChwYWdlKSB3aWxsIGJlIHBhdXNl ZCB1bnRpbCBhIHNpZ25hbCBmcm9tCisgICAgICAgIGluc3BlY3RvciBmcm9udGVuZC4gVGhpcyB3 aWxsIGVuYWJsZSB0aGUgZnJvbnRlbmQgY29uZmlndXJlIGFsbCBhZ2VudHMgYmVmb3JlIG5hdmln YXRpb24gc3RhcnRzLgorCisgICAgICAgICogSW5zcGVjdG9yR1Jlc291cmNlcy5jbWFrZToKKyAg ICAgICAgKiBTb3VyY2VzLnR4dDoKKyAgICAgICAgKiBVSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0 UHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6Y3JlYXRl KToKKyAgICAgICAgKFdlYktpdDo6SW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNvbm5lY3QpOgorICAg ICAgICAoV2ViS2l0OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6ZGlzY29ubmVjdCk6CisgICAgICAg IChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5OjpzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2Vu ZCk6CisgICAgICAgIChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5OjpkaWRDb21taXRQcm92 aXNpb25hbFRhcmdldCk6CisgICAgICAgIChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5Ojpp c1Byb3Zpc2lvbmFsIGNvbnN0KToKKyAgICAgICAgKFdlYktpdDo6SW5zcGVjdG9yVGFyZ2V0UHJv eHk6OnByZXZpb3VzVGFyZ2V0SUQgY29uc3QpOgorICAgICAgICAqIFVJUHJvY2Vzcy9JbnNwZWN0 b3JUYXJnZXRQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94 eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OlByb3Zpc2lvbmFsUGFnZVByb3h5OjpQcm92aXNpb25h bFBhZ2VQcm94eSk6CisgICAgICAgIChXZWJLaXQ6OlByb3Zpc2lvbmFsUGFnZVByb3h5Ojp+UHJv dmlzaW9uYWxQYWdlUHJveHkpOgorICAgICAgICAoV2ViS2l0OjpQcm92aXNpb25hbFBhZ2VQcm94 eTo6ZGlkUmVjZWl2ZU1lc3NhZ2UpOgorICAgICAgICAqIFVJUHJvY2Vzcy9Qcm92aXNpb25hbFBh Z2VQcm94eS5oOgorICAgICAgICAoV2ViS2l0OjpQcm92aXNpb25hbFBhZ2VQcm94eTo6cGFnZSBj b25zdCk6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNw cDoKKyAgICAgICAgKFdlYktpdDo6Z2V0VGFyZ2V0SUQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIpOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6Y2xlYXJUYXJnZXRzKToK KyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNyZWF0ZUluc3Bl Y3RvclRhcmdldCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVy OjpkZXN0cm95SW5zcGVjdG9yVGFyZ2V0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3Bl Y3RvckNvbnRyb2xsZXI6OmRpZENyZWF0ZVByb3Zpc2lvbmFsUGFnZSk6CisgICAgICAgIChXZWJL aXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWREZXN0cm95UHJvdmlzaW9uYWxQYWdl KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmRpZENvbW1p dFByb3Zpc2lvbmFsUGFnZSk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250 cm9sbGVyOjphZGRUYXJnZXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9y Q29udHJvbGxlci5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 QWdlbnQuY3BwOiBSZW1vdmVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9y VGFyZ2V0QWdlbnQuaDogUmVtb3ZlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5 LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpmaW5pc2hBdHRhY2hpbmdUb1dl YlByb2Nlc3MpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmNvbW1pdFByb3Zpc2lv bmFsUGFnZSk6CisgICAgICAgICogV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6Cisg ICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjppZGVudGlmaWVyIGNvbnN0 KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldDo6Y29ubmVjdCk6Cisg ICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmRpc2Nvbm5lY3QpOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKToKKyAgICAg ICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldC5oOgorICAgICAg ICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpy ZW1vdmVUYXJnZXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29u dHJvbGxlcjo6Y29ubmVjdEluc3BlY3Rvcik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNw ZWN0b3JUYXJnZXRDb250cm9sbGVyOjpkaXNjb25uZWN0SW5zcGVjdG9yKToKKyAgICAgICAgKiBX ZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaDoKKyAg ICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWw6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwpOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsOjpzZW5k TWVzc2FnZVRvRnJvbnRlbmQpOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdl SW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmg6CisKIDIwMTktMDktMjcgIEpvaG4gV2ls YW5kZXIgIDx3aWxhbmRlckBhcHBsZS5jb20+CiAKICAgICAgICAgU3RvcmFnZSBBY2Nlc3MgQVBJ OiBkb2N1bWVudC5oYXNTdG9yYWdlQWNjZXNzKCkgc2hvdWxkIHJldHVybiBmYWxzZSBieSBkZWZh dWx0CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL0luc3BlY3Rv clRhcmdldC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9JbnNwZWN0b3JUYXJn ZXQuaAppbmRleCA5ZWRhYTFmNDIwOTVmMDYyZjQ1YTgxMDNmYTI3NGI1MTViNjJmMThiLi5mODI4 N2EzZGQ5YTBlYzc5OTQyODAzOGFiODdiY2Y5YzYxNWI0MmFlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL0luc3BlY3RvclRhcmdldC5oCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yVGFyZ2V0LmgKQEAgLTQ3LDkgKzQ3LDEy IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgPSAwOwog ICAgIHZpcnR1YWwgSW5zcGVjdG9yVGFyZ2V0VHlwZSB0eXBlKCkgY29uc3QgPSAwOwogCisgICAg dmlydHVhbCBib29sIGlzUHJvdmlzaW9uYWwoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorICAg IHZpcnR1YWwgU3RyaW5nIHByZXZpb3VzVGFyZ2V0SUQoKSBjb25zdCB7IHJldHVybiBTdHJpbmco KTsgfQorCiAgICAgLy8gQ29ubmVjdGlvbiBtYW5hZ2VtZW50LgotICAgIHZpcnR1YWwgdm9pZCBj b25uZWN0KEZyb250ZW5kQ2hhbm5lbCYpID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgZGlzY29ubmVj dChGcm9udGVuZENoYW5uZWwmKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGNvbm5lY3QoSW5zcGVj dG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlKSA9IDA7CisgICAgdmlydHVhbCB2 b2lkIGRpc2Nvbm5lY3QoKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIHNlbmRNZXNzYWdlVG9UYXJn ZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYpID0gMDsKIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50LmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFn ZW50LmNwcAppbmRleCBjNmM2YmY4MDZlMmUyNmIxNTRiZjljYTcyYzBjY2FlOTRmNTAzY2FhLi5j ZDZmNTc5NmMwMmNiNjU1YThhNTAyN2JjZTVjOWUxYmE1MjQxYTk4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5j cHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9y VGFyZ2V0QWdlbnQuY3BwCkBAIC0zMiw2ICszMiw3IEBAIG5hbWVzcGFjZSBJbnNwZWN0b3Igewog CiBJbnNwZWN0b3JUYXJnZXRBZ2VudDo6SW5zcGVjdG9yVGFyZ2V0QWdlbnQoRnJvbnRlbmRSb3V0 ZXImIGZyb250ZW5kUm91dGVyLCBCYWNrZW5kRGlzcGF0Y2hlciYgYmFja2VuZERpc3BhdGNoZXIp CiAgICAgOiBJbnNwZWN0b3JBZ2VudEJhc2UoIlRhcmdldCJfcykKKyAgICAsIG1fcm91dGVyKGZy b250ZW5kUm91dGVyKQogICAgICwgbV9mcm9udGVuZERpc3BhdGNoZXIobWFrZVVuaXF1ZTxUYXJn ZXRGcm9udGVuZERpc3BhdGNoZXI+KGZyb250ZW5kUm91dGVyKSkKICAgICAsIG1fYmFja2VuZERp c3BhdGNoZXIoVGFyZ2V0QmFja2VuZERpc3BhdGNoZXI6OmNyZWF0ZShiYWNrZW5kRGlzcGF0Y2hl ciwgdGhpcykpCiB7CkBAIC05NiwxMCArOTcsMTUgQEAgc3RhdGljIFByb3RvY29sOjpUYXJnZXQ6 OlRhcmdldEluZm86OlR5cGUgdGFyZ2V0VHlwZVRvUHJvdG9jb2xUeXBlKEluc3BlY3RvclRhcmcK IAogc3RhdGljIFJlZjxQcm90b2NvbDo6VGFyZ2V0OjpUYXJnZXRJbmZvPiBidWlsZFRhcmdldElu Zm9PYmplY3QoY29uc3QgSW5zcGVjdG9yVGFyZ2V0JiB0YXJnZXQpCiB7Ci0gICAgcmV0dXJuIFBy b3RvY29sOjpUYXJnZXQ6OlRhcmdldEluZm86OmNyZWF0ZSgpCisgICAgYXV0byByZXN1bHQgPSBQ cm90b2NvbDo6VGFyZ2V0OjpUYXJnZXRJbmZvOjpjcmVhdGUoKQogICAgICAgICAuc2V0VGFyZ2V0 SWQodGFyZ2V0LmlkZW50aWZpZXIoKSkKICAgICAgICAgLnNldFR5cGUodGFyZ2V0VHlwZVRvUHJv dG9jb2xUeXBlKHRhcmdldC50eXBlKCkpKQogICAgICAgICAucmVsZWFzZSgpOworICAgIGlmICh0 YXJnZXQuaXNQcm92aXNpb25hbCgpKSB7CisgICAgICAgIHJlc3VsdC0+c2V0SXNQcm92aXNpb25h bCh0cnVlKTsKKyAgICAgICAgcmVzdWx0LT5zZXRQcmV2aW91c1RhcmdldElkKHRhcmdldC5wcmV2 aW91c1RhcmdldElEKCkpOworICAgIH0KKyAgICByZXR1cm4gcmVzdWx0OwogfQogCiB2b2lkIElu c3BlY3RvclRhcmdldEFnZW50Ojp0YXJnZXRDcmVhdGVkKEluc3BlY3RvclRhcmdldCYgdGFyZ2V0 KQpAQCAtMTEwLDcgKzExNiw3IEBAIHZvaWQgSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OnRhcmdldENy ZWF0ZWQoSW5zcGVjdG9yVGFyZ2V0JiB0YXJnZXQpCiAgICAgaWYgKCFtX2lzQ29ubmVjdGVkKQog ICAgICAgICByZXR1cm47CiAKLSAgICB0YXJnZXQuY29ubmVjdChmcm9udGVuZENoYW5uZWwoKSk7 CisgICAgdGFyZ2V0LmNvbm5lY3QoY29ubmVjdGlvblR5cGUoKSk7CiAKICAgICBtX2Zyb250ZW5k RGlzcGF0Y2hlci0+dGFyZ2V0Q3JlYXRlZChidWlsZFRhcmdldEluZm9PYmplY3QodGFyZ2V0KSk7 CiB9CkBAIC0xMjIsMjcgKzEyOCwzOCBAQCB2b2lkIEluc3BlY3RvclRhcmdldEFnZW50Ojp0YXJn ZXREZXN0cm95ZWQoSW5zcGVjdG9yVGFyZ2V0JiB0YXJnZXQpCiAgICAgaWYgKCFtX2lzQ29ubmVj dGVkKQogICAgICAgICByZXR1cm47CiAKLSAgICB0YXJnZXQuZGlzY29ubmVjdChmcm9udGVuZENo YW5uZWwoKSk7CisgICAgdGFyZ2V0LmRpc2Nvbm5lY3QoKTsKIAogICAgIG1fZnJvbnRlbmREaXNw YXRjaGVyLT50YXJnZXREZXN0cm95ZWQodGFyZ2V0LmlkZW50aWZpZXIoKSk7CiB9CiAKLXZvaWQg SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3RUb1RhcmdldHMoKQordm9pZCBJbnNwZWN0b3JU YXJnZXRBZ2VudDo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQoY29uc3QgU3RyaW5nJiBvbGRU YXJnZXRJRCwgY29uc3QgU3RyaW5nJiBjb21taXR0ZWRUYXJnZXRJRCkKK3sKKyAgICBpZiAoIW1f aXNDb25uZWN0ZWQpCisgICAgICAgIHJldHVybjsKKyAgICBJbnNwZWN0b3JUYXJnZXQqIHRhcmdl dCA9IG1fdGFyZ2V0cy5nZXQoY29tbWl0dGVkVGFyZ2V0SUQpOworICAgIGlmICghdGFyZ2V0KQor ICAgICAgICByZXR1cm47CisgICAgbV9mcm9udGVuZERpc3BhdGNoZXItPmRpZENvbW1pdFByb3Zp c2lvbmFsVGFyZ2V0KG9sZFRhcmdldElELCBidWlsZFRhcmdldEluZm9PYmplY3QoKnRhcmdldCkp OworfQorCitGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIEluc3BlY3RvclRhcmdldEFn ZW50Ojpjb25uZWN0aW9uVHlwZSgpIGNvbnN0CiB7Ci0gICAgYXV0byYgY2hhbm5lbCA9IGZyb250 ZW5kQ2hhbm5lbCgpOworICAgIHJldHVybiBtX3JvdXRlci5oYXNMb2NhbEZyb250ZW5kKCkgPyBJ bnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGU6OkxvY2FsIDogSW5zcGVj dG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlOjpSZW1vdGU7Cit9CiAKK3ZvaWQg SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3RUb1RhcmdldHMoKQorewogICAgIGZvciAoSW5z cGVjdG9yVGFyZ2V0KiB0YXJnZXQgOiBtX3RhcmdldHMudmFsdWVzKCkpIHsKLSAgICAgICAgdGFy Z2V0LT5jb25uZWN0KGNoYW5uZWwpOworICAgICAgICB0YXJnZXQtPmNvbm5lY3QoY29ubmVjdGlv blR5cGUoKSk7CiAgICAgICAgIG1fZnJvbnRlbmREaXNwYXRjaGVyLT50YXJnZXRDcmVhdGVkKGJ1 aWxkVGFyZ2V0SW5mb09iamVjdCgqdGFyZ2V0KSk7CiAgICAgfQogfQogCiB2b2lkIEluc3BlY3Rv clRhcmdldEFnZW50OjpkaXNjb25uZWN0RnJvbVRhcmdldHMoKQogewotICAgIGF1dG8mIGNoYW5u ZWwgPSBmcm9udGVuZENoYW5uZWwoKTsKLQogICAgIGZvciAoSW5zcGVjdG9yVGFyZ2V0KiB0YXJn ZXQgOiBtX3RhcmdldHMudmFsdWVzKCkpCi0gICAgICAgIHRhcmdldC0+ZGlzY29ubmVjdChjaGFu bmVsKTsKKyAgICAgICAgdGFyZ2V0LT5kaXNjb25uZWN0KCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNl IEluc3BlY3RvcgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9h Z2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNw ZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50LmgKaW5kZXggMDBmYzNiMDIxNzM0NGJl NGNkZmY3OTExYzIxMzcxOGM1Yjk1Y2VlMy4uYTQ1YjgzMjg5YmQ1OGE0NjE0ODI4NjNlZGQ1MGEy MjY4NTRiMDg4MSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9h Z2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv aW5zcGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oCkBAIC0yNyw2ICsyNyw3IEBA CiAKICNpbmNsdWRlICJJbnNwZWN0b3JBZ2VudEJhc2UuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JC YWNrZW5kRGlzcGF0Y2hlcnMuaCIKKyNpbmNsdWRlICJJbnNwZWN0b3JGcm9udGVuZENoYW5uZWwu aCIKICNpbmNsdWRlICJJbnNwZWN0b3JGcm9udGVuZERpc3BhdGNoZXJzLmgiCiAjaW5jbHVkZSA8 d3RmL0ZvcndhcmQuaD4KIApAQCAtNDAsNiArNDEsNyBAQCBjbGFzcyBKU19FWFBPUlRfUFJJVkFU RSBJbnNwZWN0b3JUYXJnZXRBZ2VudCA6IHB1YmxpYyBJbnNwZWN0b3JBZ2VudEJhc2UsIHB1Ymxp YwogICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKEluc3BlY3RvclRhcmdldEFnZW50KTsKICAgICBX VEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKIHB1YmxpYzoKKyAgICBJbnNwZWN0b3JUYXJnZXRBZ2Vu dChGcm9udGVuZFJvdXRlciYsIEJhY2tlbmREaXNwYXRjaGVyJik7CiAgICAgdmlydHVhbCB+SW5z cGVjdG9yVGFyZ2V0QWdlbnQoKTsKIAogICAgIC8vIEluc3BlY3RvckFnZW50QmFzZQpAQCAtNTMs MTkgKzU1LDE4IEBAIHB1YmxpYzoKICAgICAvLyBUYXJnZXQgbGlmZWN5Y2xlLgogICAgIHZvaWQg dGFyZ2V0Q3JlYXRlZChJbnNwZWN0b3JUYXJnZXQmKTsKICAgICB2b2lkIHRhcmdldERlc3Ryb3ll ZChJbnNwZWN0b3JUYXJnZXQmKTsKKyAgICB2b2lkIGRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0 KGNvbnN0IFN0cmluZyYgb2xkVGFyZ2V0SUQsIGNvbnN0IFN0cmluZyYgY29tbWl0dGVkVGFyZ2V0 SUQpOwogCiAgICAgLy8gVGFyZ2V0IG1lc3NhZ2VzLgogICAgIHZvaWQgc2VuZE1lc3NhZ2VGcm9t VGFyZ2V0VG9Gcm9udGVuZChjb25zdCBTdHJpbmcmIHRhcmdldElkLCBjb25zdCBTdHJpbmcmIG1l c3NhZ2UpOwogCi1wcm90ZWN0ZWQ6Ci0gICAgSW5zcGVjdG9yVGFyZ2V0QWdlbnQoRnJvbnRlbmRS b3V0ZXImLCBCYWNrZW5kRGlzcGF0Y2hlciYpOwotCi0gICAgdmlydHVhbCBGcm9udGVuZENoYW5u ZWwmIGZyb250ZW5kQ2hhbm5lbCgpID0gMDsKLQogcHJpdmF0ZToKKyAgICAvLyBGcm9udGVuZENo YW5uZWwKKyAgICBGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBl KCkgY29uc3Q7CiAgICAgdm9pZCBjb25uZWN0VG9UYXJnZXRzKCk7CiAgICAgdm9pZCBkaXNjb25u ZWN0RnJvbVRhcmdldHMoKTsKIAorICAgIEluc3BlY3Rvcjo6RnJvbnRlbmRSb3V0ZXImIG1fcm91 dGVyOwogICAgIHN0ZDo6dW5pcXVlX3B0cjxUYXJnZXRGcm9udGVuZERpc3BhdGNoZXI+IG1fZnJv bnRlbmREaXNwYXRjaGVyOwogICAgIFJlZjxUYXJnZXRCYWNrZW5kRGlzcGF0Y2hlcj4gbV9iYWNr ZW5kRGlzcGF0Y2hlcjsKICAgICBIYXNoTWFwPFN0cmluZywgSW5zcGVjdG9yVGFyZ2V0Kj4gbV90 YXJnZXRzOwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9wcm90 b2NvbC9UYXJnZXQuanNvbiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvcHJvdG9j b2wvVGFyZ2V0Lmpzb24KaW5kZXggNjFhZDI2OWQ5NWUxOGZkNTlkYTU1YzdjM2VmN2Q1ZDE0YWQx MzJkYS4uZjBhZmNjMjgxNzVjMTI1MGYwOTE3NDgwZDcyNDY3MWI2NWZhYjczMSAxMDA2NDQKLS0t IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9wcm90b2NvbC9UYXJnZXQuanNvbgor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL3Byb3RvY29sL1RhcmdldC5qc29u CkBAIC04LDYgKzgsOCBAQAogICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIkRlc2NyaXB0aW9u IG9mIGEgdGFyZ2V0LiIsCiAgICAgICAgICAgICAicHJvcGVydGllcyI6IFsKICAgICAgICAgICAg ICAgICB7ICJuYW1lIjogInRhcmdldElkIiwgInR5cGUiOiAic3RyaW5nIiwgImRlc2NyaXB0aW9u IjogIlVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgdGFyZ2V0LiIgfSwKKyAgICAgICAgICAgICAg ICB7ICJuYW1lIjogImlzUHJvdmlzaW9uYWwiLCAidHlwZSI6ICJib29sZWFuIiwgIm9wdGlvbmFs IjogdHJ1ZSwgImRlc2NyaXB0aW9uIjogIldoZXRoZXIgdGhpcyBpcyBhIHByb3Zpc2lvbmFsIHBh Z2UgdGFyZ2V0LiIgfSwKKyAgICAgICAgICAgICAgICB7ICJuYW1lIjogInByZXZpb3VzVGFyZ2V0 SWQiLCAidHlwZSI6ICJzdHJpbmciLCAib3B0aW9uYWwiOiB0cnVlIH0sCiAgICAgICAgICAgICAg ICAgeyAibmFtZSI6ICJ0eXBlIiwgInR5cGUiOiAic3RyaW5nIiwgImVudW0iOiBbImphdmFzY3Jp cHQiLCAicGFnZSIsICJ3b3JrZXIiLCAic2VydmljZXdvcmtlciJdIH0KICAgICAgICAgICAgIF0K ICAgICAgICAgfQpAQCAtMzksNiArNDEsMTMgQEAKICAgICAgICAgICAgICAgICB7ICJuYW1lIjog InRhcmdldElkIiwgInR5cGUiOiAic3RyaW5nIiB9CiAgICAgICAgICAgICBdCiAgICAgICAgIH0s CisgICAgICAgIHsKKyAgICAgICAgICAgICJuYW1lIjogImRpZENvbW1pdFByb3Zpc2lvbmFsVGFy Z2V0IiwKKyAgICAgICAgICAgICJwYXJhbWV0ZXJzIjogWworICAgICAgICAgICAgICAgIHsgIm5h bWUiOiAib2xkVGFyZ2V0SWQiLCAidHlwZSI6ICJzdHJpbmciLCAiZGVzY3JpcHRpb24iOiAiSUQg b2YgdGhlIHByZXZpb3VzIHRhcmdldCB0aGF0IGlzIHN3YXBwZWQgd2l0aCB0aGUgY29tbWl0dGVk IG9uZS4iIH0sCisgICAgICAgICAgICAgICAgeyAibmFtZSI6ICJ0YXJnZXRJbmZvIiwgIiRyZWYi OiAiVGFyZ2V0SW5mbyIsICJkZXNjcmlwdGlvbiI6ICJDb21taXR0ZWQgdGFyZ2V0IGluZm8uIiB9 CisgICAgICAgICAgICBdCisgICAgICAgIH0sCiAgICAgICAgIHsKICAgICAgICAgICAgICJuYW1l IjogImRpc3BhdGNoTWVzc2FnZUZyb21UYXJnZXQiLAogICAgICAgICAgICAgInBhcmFtZXRlcnMi OiBbCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Qcm90 b2NvbC9UYXJnZXRPYnNlcnZlci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzCmluZGV4IDMxYjZmY2ZjMTg2OWVkMTM4Nzgx ZTEwNzFkZDE5YjU0N2MwOWNiZjQuLjZlZjQzMjBmYjkzOTc3NzkxMWRhMmFlZjI2ZTA0MjFmMzI3 NmUzZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1By b3RvY29sL1RhcmdldE9ic2VydmVyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2Vy SW50ZXJmYWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzCkBAIC0yNiwxOSArMjYsNDIgQEAK IFdJLlRhcmdldE9ic2VydmVyID0gY2xhc3MgVGFyZ2V0T2JzZXJ2ZXIKIHsKICAgICAvLyBFdmVu dHMgZGVmaW5lZCBieSB0aGUgIlRhcmdldCIgZG9tYWluLgorICAgIGNvbnN0cnVjdG9yKCkKKyAg ICB7CisgICAgICAgIHRoaXMuX3Byb3Zpc2lvbmFsVGFyZ2V0SWRzID0gbmV3IFNldDsKKyAgICAg ICAgdGhpcy5fc3dhcHBlZFRhcmdldElkcyA9IG5ldyBTZXQ7CisgICAgfQogCiAgICAgdGFyZ2V0 Q3JlYXRlZCh0YXJnZXRJbmZvKQogICAgIHsKKyAgICAgICAgaWYgKHRhcmdldEluZm8uaXNQcm92 aXNpb25hbCkgeworICAgICAgICAgICAgdGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMuYWRkKHRh cmdldEluZm8udGFyZ2V0SWQpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAg ICAgIFdJLnRhcmdldE1hbmFnZXIudGFyZ2V0Q3JlYXRlZCh0YXJnZXRJbmZvKTsKKyAgICB9CisK KyAgICBkaWRDb21taXRQcm92aXNpb25hbFRhcmdldChwcmV2aW91c1RhcmdldElkLCB0YXJnZXRJ bmZvKQorICAgIHsKKyAgICAgICAgV0kudGFyZ2V0TWFuYWdlci50YXJnZXREZXN0cm95ZWQocHJl dmlvdXNUYXJnZXRJZCk7CiAgICAgICAgIFdJLnRhcmdldE1hbmFnZXIudGFyZ2V0Q3JlYXRlZCh0 YXJnZXRJbmZvKTsKKyAgICAgICAgdGhpcy5fc3dhcHBlZFRhcmdldElkcy5hZGQocHJldmlvdXNU YXJnZXRJZCk7CisgICAgICAgIHRoaXMuX3Byb3Zpc2lvbmFsVGFyZ2V0SWRzLmRlbGV0ZSh0YXJn ZXRJbmZvLnRhcmdldElkKTsKICAgICB9CiAKICAgICB0YXJnZXREZXN0cm95ZWQodGFyZ2V0SWQp CiAgICAgeworICAgICAgICBpZiAodGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMuZGVsZXRlKHRh cmdldElkKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgaWYgKHRoaXMuX3N3YXBwZWRU YXJnZXRJZHMuZGVsZXRlKHRhcmdldElkKSkKKyAgICAgICAgICAgIHJldHVybjsKICAgICAgICAg V0kudGFyZ2V0TWFuYWdlci50YXJnZXREZXN0cm95ZWQodGFyZ2V0SWQpOwogICAgIH0KIAogICAg IGRpc3BhdGNoTWVzc2FnZUZyb21UYXJnZXQodGFyZ2V0SWQsIG1lc3NhZ2UpCiAgICAgeworICAg ICAgICBpZiAodGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMuaGFzKHRhcmdldElkKSkKKyAgICAg ICAgICAgIHJldHVybjsKICAgICAgICAgV0kudGFyZ2V0TWFuYWdlci5kaXNwYXRjaE1lc3NhZ2VG cm9tVGFyZ2V0KHRhcmdldElkLCBtZXNzYWdlKTsKICAgICB9CiB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9JbnNwZWN0b3JHUmVzb3VyY2VzLmNtYWtlIGIvU291cmNlL1dlYktpdC9JbnNw ZWN0b3JHUmVzb3VyY2VzLmNtYWtlCmluZGV4IGY0NmY0MGVjZGZmMTRkY2I0ZTE1NTZkZTNmZTNi ZGFlYmM2NzExMDQuLmViNGI5MTljNGM2MjhkOGU1YjE5ODVmOGFjYzQ3NzdlYzFjOWRhYzMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvSW5zcGVjdG9yR1Jlc291cmNlcy5jbWFrZQorKysgYi9T b3VyY2UvV2ViS2l0L0luc3BlY3RvckdSZXNvdXJjZXMuY21ha2UKQEAgLTQ5LDEwICs0OSwxMCBA QCBtYWNybyhXRUJLSVRfQlVJTERfSU5TUEVDVE9SX0dSRVNPVVJDRVMgX2Rlcml2ZWRfc291cmNl c19kaXIpCiAgICAgICAgIHNldChDT01CSU5FX0lOU1BFQ1RPUl9SRVNPVVJDRVMgTk8pCiAgICAg ICAgIHNldChDT01CSU5FX1RFU1RfUkVTT1VSQ0VTIFlFUykKICAgICBlbHNlaWYgKERFVkVMT1BF Ul9NT0RFKQotICAgICAgICBzZXQoQ09NQklORV9JTlNQRUNUT1JfUkVTT1VSQ0VTIFlFUykKKyAg ICAgICAgc2V0KENPTUJJTkVfSU5TUEVDVE9SX1JFU09VUkNFUyBOTykKICAgICAgICAgc2V0KENP TUJJTkVfVEVTVF9SRVNPVVJDRVMgWUVTKQogICAgIGVsc2UgKCkKLSAgICAgICAgc2V0KENPTUJJ TkVfSU5TUEVDVE9SX1JFU09VUkNFUyBZRVMpCisgICAgICAgIHNldChDT01CSU5FX0lOU1BFQ1RP Ul9SRVNPVVJDRVMgTk8pCiAgICAgICAgIHNldChDT01CSU5FX1RFU1RfUkVTT1VSQ0VTIE5PKQog ICAgIGVuZGlmICgpCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU291cmNlcy50eHQgYi9T b3VyY2UvV2ViS2l0L1NvdXJjZXMudHh0CmluZGV4IGZhNTI2MWY1NGM1NTEwNjRhNGI3MjBkY2Iz OThmMmI1MTcyMjliOWQuLmNkNmZhMTcxNmJhZDQ3MmVkNWJlMzU3NjU4ODVjNTViNjE3NTY5MzAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU291cmNlcy50eHQKKysrIGIvU291cmNlL1dlYktp dC9Tb3VyY2VzLnR4dApAQCAtMjg4LDcgKzI4OCw2IEBAIFVJUHJvY2Vzcy9XZWJQYWdlRGlhZ25v c3RpY0xvZ2dpbmdDbGllbnQuY3BwCiBVSVByb2Nlc3MvV2ViUGFnZUdyb3VwLmNwcAogVUlQcm9j ZXNzL1dlYlBhZ2VJbmplY3RlZEJ1bmRsZUNsaWVudC5jcHAKIFVJUHJvY2Vzcy9XZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlci5jcHAKLVVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdl bnQuY3BwCiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAogVUlQcm9jZXNzL1dlYlBhc3RlYm9h cmRQcm94eS5jcHAKIFVJUHJvY2Vzcy9XZWJQcmVmZXJlbmNlcy5jcHAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmNwcCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmNwcAppbmRleCA2MWI4ZjM2ZWZh NzUxZjFjODhkOTJiYTFhZGNkMTVlY2E2MTQ1ODIyLi5kYjhlMjZmMjk3ZWJkMmVjMzJiNmNiYWY4 ZGNmZmI4Yjc4ZDM4ZGE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNw ZWN0b3JUYXJnZXRQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVj dG9yVGFyZ2V0UHJveHkuY3BwCkBAIC0yNiw3ICsyNiw5IEBACiAjaW5jbHVkZSAiY29uZmlnLmgi CiAjaW5jbHVkZSAiSW5zcGVjdG9yVGFyZ2V0UHJveHkuaCIKIAorI2luY2x1ZGUgIlByb3Zpc2lv bmFsUGFnZVByb3h5LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVQcm94eS5oIgorI2luY2x1ZGUgIldl YlBhZ2VJbnNwZWN0b3JUYXJnZXQuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNp bmNsdWRlICJXZWJQYWdlUHJveHkuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUHJveHkuaCIKQEAg LTM1LDkgKzM3LDE2IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiB1c2luZyBuYW1lc3BhY2UgSW5z cGVjdG9yOwogCi1SZWY8SW5zcGVjdG9yVGFyZ2V0UHJveHk+IEluc3BlY3RvclRhcmdldFByb3h5 OjpjcmVhdGUoV2ViUGFnZVByb3h5JiBwYWdlLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNw ZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUgdHlwZSkKK3N0ZDo6dW5pcXVlX3B0cjxJbnNwZWN0 b3JUYXJnZXRQcm94eT4gSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZShXZWJQYWdlUHJveHkm IHBhZ2UsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0 VHlwZSB0eXBlKQogewotICAgIHJldHVybiBhZG9wdFJlZigqbmV3IEluc3BlY3RvclRhcmdldFBy b3h5KHBhZ2UsIHRhcmdldElkLCB0eXBlKSk7CisgICAgcmV0dXJuIG1ha2VVbmlxdWU8SW5zcGVj dG9yVGFyZ2V0UHJveHk+KHBhZ2UsIHRhcmdldElkLCB0eXBlKTsKK30KKworc3RkOjp1bmlxdWVf cHRyPEluc3BlY3RvclRhcmdldFByb3h5PiBJbnNwZWN0b3JUYXJnZXRQcm94eTo6Y3JlYXRlKFBy b3Zpc2lvbmFsUGFnZVByb3h5JiBwcm92aXNpb25hbFBhZ2UsIGNvbnN0IFN0cmluZyYgdGFyZ2V0 SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZSB0eXBlKQoreworICAgIGF1dG8gdGFy Z2V0ID0gY3JlYXRlKHByb3Zpc2lvbmFsUGFnZS5wYWdlKCksIHRhcmdldElkLCB0eXBlKTsKKyAg ICB0YXJnZXQtPm1fcHJvdmlzaW9uYWxQYWdlID0gJnByb3Zpc2lvbmFsUGFnZTsKKyAgICByZXR1 cm4gdGFyZ2V0OwogfQogCiBJbnNwZWN0b3JUYXJnZXRQcm94eTo6SW5zcGVjdG9yVGFyZ2V0UHJv eHkoV2ViUGFnZVByb3h5JiBwYWdlLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6 Okluc3BlY3RvclRhcmdldFR5cGUgdHlwZSkKQEAgLTQ3LDIyICs1Niw1MiBAQCBJbnNwZWN0b3JU YXJnZXRQcm94eTo6SW5zcGVjdG9yVGFyZ2V0UHJveHkoV2ViUGFnZVByb3h5JiBwYWdlLCBjb25z dCBTdHJpbmcmIHRhcgogewogfQogCi12b2lkIEluc3BlY3RvclRhcmdldFByb3h5Ojpjb25uZWN0 KEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsJiBjaGFubmVsKQordm9pZCBJbnNwZWN0b3JUYXJn ZXRQcm94eTo6Y29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5 cGUgY29ubmVjdGlvblR5cGUpCiB7CisgICAgaWYgKG1fcHJvdmlzaW9uYWxQYWdlKSB7CisgICAg ICAgIG1fcHJvdmlzaW9uYWxQYWdlLT5wcm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6 Q29ubmVjdEluc3BlY3RvcihpZGVudGlmaWVyKCksIGNvbm5lY3Rpb25UeXBlKSwgbV9wcm92aXNp b25hbFBhZ2UtPndlYlBhZ2VJRCgpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KICAgICBpZiAo bV9wYWdlLmhhc1J1bm5pbmdQcm9jZXNzKCkpCi0gICAgICAgIG1fcGFnZS5wcm9jZXNzKCkuc2Vu ZChNZXNzYWdlczo6V2ViUGFnZTo6Q29ubmVjdEluc3BlY3RvcihpZGVudGlmaWVyKCksIGNoYW5u ZWwuY29ubmVjdGlvblR5cGUoKSksIG1fcGFnZS53ZWJQYWdlSUQoKSk7CisgICAgICAgIG1fcGFn ZS5wcm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6Q29ubmVjdEluc3BlY3RvcihpZGVu dGlmaWVyKCksIGNvbm5lY3Rpb25UeXBlKSwgbV9wYWdlLndlYlBhZ2VJRCgpKTsKIH0KIAotdm9p ZCBJbnNwZWN0b3JUYXJnZXRQcm94eTo6ZGlzY29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hh bm5lbCYpCit2b2lkIEluc3BlY3RvclRhcmdldFByb3h5OjpkaXNjb25uZWN0KCkKIHsKKyAgICBp ZiAobV9wcm92aXNpb25hbFBhZ2UpIHsKKyAgICAgICAgbV9wcm92aXNpb25hbFBhZ2UtPnByb2Nl c3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpEaXNjb25uZWN0SW5zcGVjdG9yKGlkZW50aWZp ZXIoKSksIG1fcHJvdmlzaW9uYWxQYWdlLT53ZWJQYWdlSUQoKSk7CisgICAgICAgIHJldHVybjsK KyAgICB9CiAgICAgaWYgKG1fcGFnZS5oYXNSdW5uaW5nUHJvY2VzcygpKQogICAgICAgICBtX3Bh Z2UucHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OkRpc2Nvbm5lY3RJbnNwZWN0b3Io aWRlbnRpZmllcigpKSwgbV9wYWdlLndlYlBhZ2VJRCgpKTsKIH0KIAogdm9pZCBJbnNwZWN0b3JU YXJnZXRQcm94eTo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJiBtZXNz YWdlKQogeworICAgIGlmIChtX3Byb3Zpc2lvbmFsUGFnZSkgeworICAgICAgICBtX3Byb3Zpc2lv bmFsUGFnZS0+cHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OlNlbmRNZXNzYWdlVG9U YXJnZXRCYWNrZW5kKGlkZW50aWZpZXIoKSwgbWVzc2FnZSksIG1fcHJvdmlzaW9uYWxQYWdlLT53 ZWJQYWdlSUQoKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CiAgICAgaWYgKG1fcGFnZS5oYXNS dW5uaW5nUHJvY2VzcygpKQogICAgICAgICBtX3BhZ2UucHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6 OldlYlBhZ2U6OlNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGlkZW50aWZpZXIoKSwgbWVzc2Fn ZSksIG1fcGFnZS53ZWJQYWdlSUQoKSk7CiB9CiAKK3ZvaWQgSW5zcGVjdG9yVGFyZ2V0UHJveHk6 OmRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KCkKK3sKKyAgICBBU1NFUlQoaXNQcm92aXNpb25h bCgpKTsKKyAgICBtX3Byb3Zpc2lvbmFsUGFnZSA9IG51bGxwdHI7Cit9CisKK2Jvb2wgSW5zcGVj dG9yVGFyZ2V0UHJveHk6OmlzUHJvdmlzaW9uYWwoKSBjb25zdAoreworICAgIHJldHVybiBtX3By b3Zpc2lvbmFsUGFnZTsKK30KKworU3RyaW5nIEluc3BlY3RvclRhcmdldFByb3h5OjpwcmV2aW91 c1RhcmdldElEKCkgY29uc3QKK3sKKyAgICBpZiAobV90eXBlICE9IEluc3BlY3Rvcjo6SW5zcGVj dG9yVGFyZ2V0VHlwZTo6UGFnZSB8fCAhaXNQcm92aXNpb25hbCgpKQorICAgICAgICByZXR1cm4g U3RyaW5nKCk7CisgICAgcmV0dXJuIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OnRvVGFyZ2V0SUQo bV9wYWdlLndlYlBhZ2VJRCgpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNwZWN0b3JUYXJnZXRQcm94eS5oIGIvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0UHJveHkuaAppbmRleCBkMzgyYjAy NjUwOWM4Mzk1MTk5YWJkZDQ5NWFmNmEyYTUxYWY5MjdjLi4wY2NmZWQ0MjYyNDAyMWJiOGEwZTM1 YzhiMmZlZjNlMWQxODU4MmRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9J bnNwZWN0b3JUYXJnZXRQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0luc3Bl Y3RvclRhcmdldFByb3h5LmgKQEAgLTM1LDI1ICszNSwzMSBAQCBjbGFzcyBXZWJQYWdlUHJveHk7 CiAvLyBOT1RFOiBUaGlzIFVJUHJvY2VzcyBzaWRlIEluc3BlY3RvclRhcmdldCBkb2Vzbid0IGNh cmUgYWJvdXQgdGhlIGZyb250ZW5kIGNoYW5uZWwsIHNpbmNlCiAvLyBhbnkgdGFyZ2V0IC0+IGZy b250ZW5kIG1lc3NhZ2VzIHdpbGwgYmUgcm91dGVkIHRvIHRoZSBXZWJQYWdlUHJveHkgd2l0aCBh IHRhcmdldElkLgogCi1jbGFzcyBJbnNwZWN0b3JUYXJnZXRQcm94eSBmaW5hbCA6IHB1YmxpYyBJ bnNwZWN0b3I6Okluc3BlY3RvclRhcmdldCwgcHVibGljIFJlZkNvdW50ZWQ8SW5zcGVjdG9yVGFy Z2V0UHJveHk+IHsKK2NsYXNzIEluc3BlY3RvclRhcmdldFByb3h5IGZpbmFsIDogcHVibGljIElu c3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0IHsKICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsK ICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShJbnNwZWN0b3JUYXJnZXRQcm94eSk7CiBwdWJsaWM6 Ci0gICAgc3RhdGljIFJlZjxJbnNwZWN0b3JUYXJnZXRQcm94eT4gY3JlYXRlKFdlYlBhZ2VQcm94 eSYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlw ZSk7CisgICAgc3RhdGljIHN0ZDo6dW5pcXVlX3B0cjxJbnNwZWN0b3JUYXJnZXRQcm94eT4gY3Jl YXRlKFdlYlBhZ2VQcm94eSYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5z cGVjdG9yVGFyZ2V0VHlwZSk7CisgICAgc3RhdGljIHN0ZDo6dW5pcXVlX3B0cjxJbnNwZWN0b3JU YXJnZXRQcm94eT4gY3JlYXRlKFByb3Zpc2lvbmFsUGFnZVByb3h5JiwgY29uc3QgU3RyaW5nJiB0 YXJnZXRJZCwgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlKTsKICAgICBJbnNwZWN0b3JU YXJnZXRQcm94eShXZWJQYWdlUHJveHkmLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0 b3I6Okluc3BlY3RvclRhcmdldFR5cGUpOwogICAgIH5JbnNwZWN0b3JUYXJnZXRQcm94eSgpID0g ZGVmYXVsdDsKIAogICAgIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZSB0eXBlKCkgY29u c3QgZmluYWwgeyByZXR1cm4gbV90eXBlOyB9CiAgICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25z dCBmaW5hbCB7IHJldHVybiBtX2lkZW50aWZpZXI7IH0KIAotICAgIHZvaWQgY29ubmVjdChJbnNw ZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYpOwotICAgIHZvaWQgZGlzY29ubmVjdChJbnNwZWN0b3I6 OkZyb250ZW5kQ2hhbm5lbCYpOwotICAgIHZvaWQgc2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQo Y29uc3QgU3RyaW5nJik7CisgICAgdm9pZCBkaWRDb21taXRQcm92aXNpb25hbFRhcmdldCgpOwor ICAgIGJvb2wgaXNQcm92aXNpb25hbCgpIGNvbnN0IG92ZXJyaWRlOworICAgIFN0cmluZyBwcmV2 aW91c1RhcmdldElEKCkgY29uc3Qgb3ZlcnJpZGU7CisKKyAgICB2b2lkIGNvbm5lY3QoSW5zcGVj dG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlKSBvdmVycmlkZTsKKyAgICB2b2lk IGRpc2Nvbm5lY3QoKSBvdmVycmlkZTsKKyAgICB2b2lkIHNlbmRNZXNzYWdlVG9UYXJnZXRCYWNr ZW5kKGNvbnN0IFN0cmluZyYpIG92ZXJyaWRlOwogCiBwcml2YXRlOgogICAgIFdlYlBhZ2VQcm94 eSYgbV9wYWdlOwogICAgIFN0cmluZyBtX2lkZW50aWZpZXI7CiAgICAgSW5zcGVjdG9yOjpJbnNw ZWN0b3JUYXJnZXRUeXBlIG1fdHlwZTsKKyAgICBQcm92aXNpb25hbFBhZ2VQcm94eSogbV9wcm92 aXNpb25hbFBhZ2UgPSBudWxscHRyOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5jcHAg Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5jcHAKaW5kZXgg YTJhMDlkYzQ5MjVkZjQyZTU0ODQ0NTBiZWY0Nzk3OGMwMzk3ZjllNS4uOGU2MDI2MjAzMWQ3MDNm MDM4MmMzYjY2ZjViMGM1M2EyOGQ4YTM1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVBy b2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1Byb3Zpc2lvbmFsUGFnZVByb3h5LmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUg IldlYkVycm9ycy5oIgogI2luY2x1ZGUgIldlYk5hdmlnYXRpb25EYXRhU3RvcmUuaCIKICNpbmNs dWRlICJXZWJOYXZpZ2F0aW9uU3RhdGUuaCIKKyNpbmNsdWRlICJXZWJQYWdlSW5zcGVjdG9yQ29u dHJvbGxlci5oIgogI2luY2x1ZGUgIldlYlBhZ2VNZXNzYWdlcy5oIgogI2luY2x1ZGUgIldlYlBh Z2VQcm94eS5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eU1lc3NhZ2VzLmgiCkBAIC04NCwxMiAr ODUsMTYgQEAgUHJvdmlzaW9uYWxQYWdlUHJveHk6OlByb3Zpc2lvbmFsUGFnZVByb3h5KFdlYlBh Z2VQcm94eSYgcGFnZSwgUmVmPFdlYlByb2Nlc3NQcm8KICAgICB9CiAKICAgICBpbml0aWFsaXpl V2ViUGFnZSgpOworCisgICAgbV9wYWdlLmluc3BlY3RvckNvbnRyb2xsZXIoKS5kaWRDcmVhdGVQ cm92aXNpb25hbFBhZ2UoKnRoaXMpOwogfQogCiBQcm92aXNpb25hbFBhZ2VQcm94eTo6flByb3Zp c2lvbmFsUGFnZVByb3h5KCkKIHsKICAgICBtX3Byb2Nlc3MtPnJlbW92ZVByb3Zpc2lvbmFsUGFn ZVByb3h5KCp0aGlzKTsKIAorICAgIG1fcGFnZS5pbnNwZWN0b3JDb250cm9sbGVyKCkuZGlkRGVz dHJveVByb3Zpc2lvbmFsUGFnZSgqdGhpcywgbV93YXNDb21taXR0ZWQpOworCiAgICAgaWYgKG1f d2FzQ29tbWl0dGVkKQogICAgICAgICByZXR1cm47CiAKQEAgLTM5MSw2ICszOTYsOSBAQCB2b2lk IFByb3Zpc2lvbmFsUGFnZVByb3h5OjpkaWRSZWNlaXZlTWVzc2FnZShJUEM6OkNvbm5lY3Rpb24m IGNvbm5lY3Rpb24sIElQQzo6RAogICAgICAgICB8fCBkZWNvZGVyLm1lc3NhZ2VOYW1lKCkgPT0g TWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGlkU3RhcnRMb2FkRm9yUXVpY2tMb29rRG9jdW1lbnRJ bk1haW5GcmFtZTo6bmFtZSgpCiAgICAgICAgIHx8IGRlY29kZXIubWVzc2FnZU5hbWUoKSA9PSBN ZXNzYWdlczo6V2ViUGFnZVByb3h5OjpEaWRGaW5pc2hMb2FkRm9yUXVpY2tMb29rRG9jdW1lbnRJ bk1haW5GcmFtZTo6bmFtZSgpCiAjZW5kaWYKKyAgICAgICAgfHwgZGVjb2Rlci5tZXNzYWdlTmFt ZSgpID09IE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkNyZWF0ZUluc3BlY3RvclRhcmdldDo6bmFt ZSgpCisgICAgICAgIHx8IGRlY29kZXIubWVzc2FnZU5hbWUoKSA9PSBNZXNzYWdlczo6V2ViUGFn ZVByb3h5OjpEZXN0cm95SW5zcGVjdG9yVGFyZ2V0OjpuYW1lKCkKKyAgICAgICAgfHwgZGVjb2Rl ci5tZXNzYWdlTmFtZSgpID09IE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlNlbmRNZXNzYWdlVG9J bnNwZWN0b3JGcm9udGVuZDo6bmFtZSgpCiAgICAgICAgICkKICAgICB7CiAgICAgICAgIG1fcGFn ZS5kaWRSZWNlaXZlTWVzc2FnZShjb25uZWN0aW9uLCBkZWNvZGVyKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb3Zpc2lvbmFsUGFnZVByb3h5LmggYi9Tb3VyY2UvV2Vi S2l0L1VJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5oCmluZGV4IDE3NTIxNTA0NzQ4YmZi NmYyMDYzY2UxNGNhNDVmZDFjYzcxODNlY2IuLmJlZTgxYmMwYmQ5ZDcxYjRhNjhkZjRmOGI5ZTQ3 MzZiZDI5YThjZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb3Zpc2lv bmFsUGFnZVByb3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQ YWdlUHJveHkuaApAQCAtNjQsNyArNjQsNyBAQCBwdWJsaWM6CiAgICAgUHJvdmlzaW9uYWxQYWdl UHJveHkoV2ViUGFnZVByb3h5JiwgUmVmPFdlYlByb2Nlc3NQcm94eT4mJiwgc3RkOjp1bmlxdWVf cHRyPFN1c3BlbmRlZFBhZ2VQcm94eT4sIHVpbnQ2NF90IG5hdmlnYXRpb25JRCwgYm9vbCBpc1Nl cnZlclJlZGlyZWN0LCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBQcm9jZXNzU3dh cFJlcXVlc3RlZEJ5Q2xpZW50KTsKICAgICB+UHJvdmlzaW9uYWxQYWdlUHJveHkoKTsKIAotICAg IFdlYlBhZ2VQcm94eSYgcGFnZSgpIHsgcmV0dXJuIG1fcGFnZTsgfQorICAgIFdlYlBhZ2VQcm94 eSYgcGFnZSgpIGNvbnN0IHsgcmV0dXJuIG1fcGFnZTsgfQogICAgIFdlYkNvcmU6OlBhZ2VJZGVu dGlmaWVyIHdlYlBhZ2VJRCgpIGNvbnN0IHsgcmV0dXJuIG1fd2ViUGFnZUlEOyB9CiAgICAgV2Vi RnJhbWVQcm94eSogbWFpbkZyYW1lKCkgY29uc3QgeyByZXR1cm4gbV9tYWluRnJhbWUuZ2V0KCk7 IH0KICAgICBXZWJQcm9jZXNzUHJveHkmIHByb2Nlc3MoKSB7IHJldHVybiBtX3Byb2Nlc3MuZ2V0 KCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0 b3JDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0 b3JDb250cm9sbGVyLmNwcAppbmRleCBiZGE1OWNkODA1MTU3NjQ2YjMwOGQyZmQyMzZmM2QxMTgy NzFlMGI2Li5kY2NiYjNiY2YwNzM2OTNhYmQ5NmI0YmZmYzIzZGQxN2JiOTkyNjQzIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5j cHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNvbnRyb2xs ZXIuY3BwCkBAIC0yNiwyNCArMjYsMzIgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oIgogCisjaW5jbHVkZSAiUHJvdmlzaW9uYWxQ YWdlUHJveHkuaCIKICNpbmNsdWRlICJXZWJGcmFtZVByb3h5LmgiCi0jaW5jbHVkZSAiV2ViUGFn ZUluc3BlY3RvclRhcmdldEFnZW50LmgiCisjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdl dC5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0luc3BlY3RvckFnZW50QmFzZS5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0luc3BlY3Rv ckJhY2tlbmREaXNwYXRjaGVyLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSW5zcGVjdG9y QmFja2VuZERpc3BhdGNoZXJzLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSW5zcGVjdG9y RnJvbnRlbmRSb3V0ZXIuaD4KKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9JbnNwZWN0b3JUYXJn ZXRBZ2VudC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAKIG5hbWVzcGFjZSBXZWJLaXQg ewogCiB1c2luZyBuYW1lc3BhY2UgSW5zcGVjdG9yOwogCitzdGF0aWMgU3RyaW5nIGdldFRhcmdl dElEKGNvbnN0IFByb3Zpc2lvbmFsUGFnZVByb3h5JiBwcm92aXNpb25hbFBhZ2UpCit7CisgICAg cmV0dXJuIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OnRvVGFyZ2V0SUQocHJvdmlzaW9uYWxQYWdl LndlYlBhZ2VJRCgpKTsKK30KKwogV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OldlYlBhZ2VJ bnNwZWN0b3JDb250cm9sbGVyKFdlYlBhZ2VQcm94eSYgcGFnZSkKICAgICA6IG1fcGFnZShwYWdl KQogICAgICwgbV9mcm9udGVuZFJvdXRlcihGcm9udGVuZFJvdXRlcjo6Y3JlYXRlKCkpCiAgICAg LCBtX2JhY2tlbmREaXNwYXRjaGVyKEJhY2tlbmREaXNwYXRjaGVyOjpjcmVhdGUobV9mcm9udGVu ZFJvdXRlci5jb3B5UmVmKCkpKQogewotICAgIGF1dG8gdGFyZ2V0QWdlbnQgPSBtYWtlVW5pcXVl PFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudD4obV9mcm9udGVuZFJvdXRlci5nZXQoKSwgbV9i YWNrZW5kRGlzcGF0Y2hlci5nZXQoKSk7CisgICAgYXV0byB0YXJnZXRBZ2VudCA9IG1ha2VVbmlx dWU8SW5zcGVjdG9yVGFyZ2V0QWdlbnQ+KG1fZnJvbnRlbmRSb3V0ZXIuZ2V0KCksIG1fYmFja2Vu ZERpc3BhdGNoZXIuZ2V0KCkpOwogCiAgICAgbV90YXJnZXRBZ2VudCA9IHRhcmdldEFnZW50Lmdl dCgpOwogCkBAIC0xMzYsMzAgKzE0NCwyNCBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9s bGVyOjpzZXRJbmRpY2F0aW5nKGJvb2wgaW5kaWNhdGluZykKIAogdm9pZCBXZWJQYWdlSW5zcGVj dG9yQ29udHJvbGxlcjo6Y2xlYXJUYXJnZXRzKCkKIHsKLSAgICBmb3IgKGF1dG8mIHRhcmdldCA6 IG1fdGFyZ2V0cykKLSAgICAgICAgbV90YXJnZXRBZ2VudC0+dGFyZ2V0RGVzdHJveWVkKCp0YXJn ZXQuZ2V0KCkpOworICAgIGZvciAoYXV0byYgdGFyZ2V0IDogbV90YXJnZXRzLnZhbHVlcygpKQor ICAgICAgICBtX3RhcmdldEFnZW50LT50YXJnZXREZXN0cm95ZWQoKnRhcmdldCk7CiAKICAgICBt X3RhcmdldHMuY2xlYXIoKTsKIH0KIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6 Y3JlYXRlSW5zcGVjdG9yVGFyZ2V0KGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0VHlwZSB0eXBlKQogewotICAgIGF1dG8gdGFyZ2V0ID0gSW5zcGVjdG9y VGFyZ2V0UHJveHk6OmNyZWF0ZShtX3BhZ2UsIHRhcmdldElkLCB0eXBlKTsKLSAgICBtX3Rhcmdl dHMuYXBwZW5kKHRhcmdldC5jb3B5UmVmKCkpOwotCi0gICAgbV90YXJnZXRBZ2VudC0+dGFyZ2V0 Q3JlYXRlZCh0YXJnZXQuZ2V0KCkpOworICAgIGFkZFRhcmdldChJbnNwZWN0b3JUYXJnZXRQcm94 eTo6Y3JlYXRlKG1fcGFnZSwgdGFyZ2V0SWQsIHR5cGUpKTsKIH0KIAogdm9pZCBXZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlcjo6ZGVzdHJveUluc3BlY3RvclRhcmdldChjb25zdCBTdHJpbmcmIHRh cmdldElkKQogewotICAgIGF1dG8gcG9zaXRpb24gPSBtX3RhcmdldHMuZmluZE1hdGNoaW5nKFsm XShjb25zdCBhdXRvJiBpdGVtKSB7IHJldHVybiBpdGVtLT5pZGVudGlmaWVyKCkgPT0gdGFyZ2V0 SWQ7IH0pOwotICAgIGlmIChwb3NpdGlvbiA9PSBub3RGb3VuZCkKKyAgICBhdXRvIGl0ID0gbV90 YXJnZXRzLmZpbmQodGFyZ2V0SWQpOworICAgIGlmIChpdCA9PSBtX3RhcmdldHMuZW5kKCkpCiAg ICAgICAgIHJldHVybjsKLQotICAgIGF1dG8mIHRhcmdldCA9IG1fdGFyZ2V0c1twb3NpdGlvbl07 Ci0gICAgbV90YXJnZXRBZ2VudC0+dGFyZ2V0RGVzdHJveWVkKCp0YXJnZXQuZ2V0KCkpOwotCi0g ICAgbV90YXJnZXRzLnJlbW92ZShwb3NpdGlvbik7CisgICAgbV90YXJnZXRBZ2VudC0+dGFyZ2V0 RGVzdHJveWVkKCppdC0+dmFsdWUpOworICAgIG1fdGFyZ2V0cy5yZW1vdmUoaXQpOwogfQogCiB2 b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpzZW5kTWVzc2FnZVRvSW5zcGVjdG9yRnJv bnRlbmQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlKQpAQCAt MTY3LDQgKzE2OSwzNCBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpzZW5kTWVz c2FnZVRvSW5zcGVjdG9yRnJvbnRlbmQoY29uc3QgU3RyaW5nJiB0YQogICAgIG1fdGFyZ2V0QWdl bnQtPnNlbmRNZXNzYWdlRnJvbVRhcmdldFRvRnJvbnRlbmQodGFyZ2V0SWQsIG1lc3NhZ2UpOwog fQogCit2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWRDcmVhdGVQcm92aXNpb25h bFBhZ2UoUHJvdmlzaW9uYWxQYWdlUHJveHkmIHByb3Zpc2lvbmFsUGFnZSkKK3sKKyAgICBhZGRU YXJnZXQoSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZShwcm92aXNpb25hbFBhZ2UsIGdldFRh cmdldElEKHByb3Zpc2lvbmFsUGFnZSksIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZTo6 UGFnZSkpOworfQorCit2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWREZXN0cm95 UHJvdmlzaW9uYWxQYWdlKGNvbnN0IFByb3Zpc2lvbmFsUGFnZVByb3h5JiBwcm92aXNpb25hbFBh Z2UsIGJvb2wgd2FzQ29tbWl0dGVkKQoreworICAgIGlmICh3YXNDb21taXR0ZWQpCisgICAgICAg IHJldHVybjsKKyAgICBkZXN0cm95SW5zcGVjdG9yVGFyZ2V0KGdldFRhcmdldElEKHByb3Zpc2lv bmFsUGFnZSkpOworfQorCit2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWRDb21t aXRQcm92aXNpb25hbFBhZ2UoY29uc3QgV2ViQ29yZTo6UGFnZUlkZW50aWZpZXImIG9sZFdlYlBh Z2VJRCwgY29uc3QgV2ViQ29yZTo6UGFnZUlkZW50aWZpZXImIG5ld1dlYlBhZ2VJRCkKK3sKKyAg ICBTdHJpbmcgb2xkSUQgPSBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKG9sZFdl YlBhZ2VJRCk7CisgICAgU3RyaW5nIG5ld0lEID0gV2ViUGFnZUluc3BlY3RvclRhcmdldDo6dG9U YXJnZXRJRChuZXdXZWJQYWdlSUQpOworICAgIGlmIChhdXRvKiB0YXJnZXQgPSBtX3RhcmdldHMu Z2V0KG5ld0lEKSkKKyAgICAgICAgdGFyZ2V0LT5kaWRDb21taXRQcm92aXNpb25hbFRhcmdldCgp OworICAgIG1fdGFyZ2V0QWdlbnQtPmRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KG9sZElELCBu ZXdJRCk7CisgICAgLy8gV2UndmUgZGlzY29ubmVjdGVkIGZyb20gdGhlIG9sZCBwYWdlIGFuZCB3 aWxsIG5vdCByZWNlaXZlIGFueSBtZXNzYWdlIGZyb20gaXQsIHNvCisgICAgLy8gd2UgZGVzdHJv eSB0aGUgdGFyZ2V0IGhlcmUuCisgICAgZGVzdHJveUluc3BlY3RvclRhcmdldChvbGRJRCk7Cit9 CisKK3ZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmFkZFRhcmdldChzdGQ6OnVuaXF1 ZV9wdHI8SW5zcGVjdG9yVGFyZ2V0UHJveHk+JiYgdGFyZ2V0KQoreworICAgIG1fdGFyZ2V0QWdl bnQtPnRhcmdldENyZWF0ZWQoKnRhcmdldCk7CisgICAgbV90YXJnZXRzLnNldCh0YXJnZXQtPmlk ZW50aWZpZXIoKSwgV1RGTW92ZSh0YXJnZXQpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29u dHJvbGxlci5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNvbnRy b2xsZXIuaAppbmRleCAwY2FmNmExYzI3OTIwNDNkM2JlMDU3MWEyOGZkYjFlMTQxOTdhNjExLi5h MDMwYTE0YjVmOWJiZDVlMDUzODUzZDZmMGQyZDc1ODExODVjZTc4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmgKQEAgLTY1 LDEzICs2NSwyMCBAQCBwdWJsaWM6CiAgICAgdm9pZCBkZXN0cm95SW5zcGVjdG9yVGFyZ2V0KGNv bnN0IFN0cmluZyYgdGFyZ2V0SWQpOwogICAgIHZvaWQgc2VuZE1lc3NhZ2VUb0luc3BlY3RvckZy b250ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSk7CiAK KyAgICB2b2lkIGRpZENyZWF0ZVByb3Zpc2lvbmFsUGFnZShQcm92aXNpb25hbFBhZ2VQcm94eSYp OworICAgIHZvaWQgZGlkRGVzdHJveVByb3Zpc2lvbmFsUGFnZShjb25zdCBQcm92aXNpb25hbFBh Z2VQcm94eSYsIGJvb2wgd2FzQ29tbWl0dGVkKTsKKyAgICAvLyB2b2lkIGRpZENvbW1pdE5hdmln YXRpb24oY29uc3QgUHJvdmlzaW9uYWxQYWdlUHJveHkmLCBib29sIHdhc0NvbW1pdHRlZCk7Cisg ICAgdm9pZCBkaWRDb21taXRQcm92aXNpb25hbFBhZ2UoY29uc3QgV2ViQ29yZTo6UGFnZUlkZW50 aWZpZXImIG9sZFdlYlBhZ2VJRCwgY29uc3QgV2ViQ29yZTo6UGFnZUlkZW50aWZpZXImIG5ld1dl YlBhZ2VJRCk7CisKIHByaXZhdGU6CisgICAgdm9pZCBhZGRUYXJnZXQoc3RkOjp1bmlxdWVfcHRy PEluc3BlY3RvclRhcmdldFByb3h5PiYmKTsKKwogICAgIFdlYlBhZ2VQcm94eSYgbV9wYWdlOwog ICAgIFJlZjxJbnNwZWN0b3I6OkZyb250ZW5kUm91dGVyPiBtX2Zyb250ZW5kUm91dGVyOwogICAg IFJlZjxJbnNwZWN0b3I6OkJhY2tlbmREaXNwYXRjaGVyPiBtX2JhY2tlbmREaXNwYXRjaGVyOwog ICAgIEluc3BlY3Rvcjo6QWdlbnRSZWdpc3RyeSBtX2FnZW50czsKICAgICBJbnNwZWN0b3I6Oklu c3BlY3RvclRhcmdldEFnZW50KiBtX3RhcmdldEFnZW50OwotICAgIFZlY3RvcjxSZWZQdHI8SW5z cGVjdG9yVGFyZ2V0UHJveHk+PiBtX3RhcmdldHM7CisgICAgSGFzaE1hcDxTdHJpbmcsIHN0ZDo6 dW5pcXVlX3B0cjxJbnNwZWN0b3JUYXJnZXRQcm94eT4+IG1fdGFyZ2V0czsKIH07CiAKIH0gLy8g bmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2Vi UGFnZUluc3BlY3RvclRhcmdldEFnZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dl YlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5jcHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IGJhMDAxYzA4ZDAyZjdlZDZjMDA4NTY2ZjdhZjg5YTM4MWNkZWQyMTUuLjAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDU1 ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTggQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0Ogot ICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhl Ci0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgot ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IKLSAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkg VEhFT1JZCi0gKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0j aW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50 LmgiCi0KLW5hbWVzcGFjZSBXZWJLaXQgewotCi1XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6 OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudChJbnNwZWN0b3I6OkZyb250ZW5kUm91dGVyJiBm cm9udGVuZFJvdXRlciwgSW5zcGVjdG9yOjpCYWNrZW5kRGlzcGF0Y2hlciYgYmFja2VuZERpc3Bh dGNoZXIpCi0gICAgOiBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldEFnZW50KGZyb250ZW5kUm91 dGVyLCBiYWNrZW5kRGlzcGF0Y2hlcikKLSAgICAsIG1fcm91dGVyKGZyb250ZW5kUm91dGVyKQot ewotfQotCi1XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6On5XZWJQYWdlSW5zcGVjdG9yVGFy Z2V0QWdlbnQoKSA9IGRlZmF1bHQ7Ci0KLUluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsJiBXZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmZyb250ZW5kQ2hhbm5lbCgpCi17Ci0gICAgcmV0dXJu ICp0aGlzOwotfQotCi1JbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUg V2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50Ojpjb25uZWN0aW9uVHlwZSgpIGNvbnN0Ci17Ci0g ICAgcmV0dXJuIG1fcm91dGVyLmhhc0xvY2FsRnJvbnRlbmQoKSA/IEluc3BlY3Rvcjo6RnJvbnRl bmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZTo6TG9jYWwgOiBJbnNwZWN0b3I6OkZyb250ZW5kQ2hh bm5lbDo6Q29ubmVjdGlvblR5cGU6OlJlbW90ZTsKLX0KLQotdm9pZCBXZWJQYWdlSW5zcGVjdG9y VGFyZ2V0QWdlbnQ6OnNlbmRNZXNzYWdlVG9Gcm9udGVuZChjb25zdCBTdHJpbmcmKQotewotICAg IC8vIEludGVudGlvbmFsbHkgaWdub3JlZCwgdGhpcyBjaGFubmVsIGlzIG5vdCBhY3R1YWxseSB1 c2VkIHRvIHNlbmQgbWVzc2FnZXMuCi0gICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Ci19Ci0KLX0g Ly8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv V2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggOTYzZjljM2NjY2VhNTQ4N2E0Y2UyOTNlYzVlMDgzYThjYzhiNTE1NC4uMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaAorKysgL2Rldi9udWxsCkBAIC0xLDQ5ICsw LDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0g KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICog UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IK LSAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLAotICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZCi0gKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jcHJh Z21hIG9uY2UKLQotI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0luc3BlY3RvckZyb250ZW5kQ2hh bm5lbC5oPgotI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0luc3BlY3RvclRhcmdldEFnZW50Lmg+ Ci0KLW5hbWVzcGFjZSBXZWJLaXQgewotCi1jbGFzcyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdl bnQgZmluYWwgOiBwdWJsaWMgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudCwgcHVibGlj IEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsIHsKLXB1YmxpYzoKLSAgICBXZWJQYWdlSW5zcGVj dG9yVGFyZ2V0QWdlbnQoSW5zcGVjdG9yOjpGcm9udGVuZFJvdXRlciYsIEluc3BlY3Rvcjo6QmFj a2VuZERpc3BhdGNoZXImKTsKLSAgICB2aXJ0dWFsIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdl bnQoKTsKLQotICAgIC8vIEluc3BlY3RvclRhcmdldEFnZW50Ci0gICAgSW5zcGVjdG9yOjpGcm9u dGVuZENoYW5uZWwmIGZyb250ZW5kQ2hhbm5lbCgpOwotCi0gICAgLy8gRnJvbnRlbmRDaGFubmVs Ci0gICAgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rp b25UeXBlKCkgY29uc3Q7Ci0gICAgdm9pZCBzZW5kTWVzc2FnZVRvRnJvbnRlbmQoY29uc3QgU3Ry aW5nJik7Ci0KLXByaXZhdGU6Ci0gICAgSW5zcGVjdG9yOjpGcm9udGVuZFJvdXRlciYgbV9yb3V0 ZXI7Ci19OwotCi19IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkuY3BwCmluZGV4IDYzMDMxYzNjOGIzNTJjMzdhMDMxOTY1MmVlOTE5Y2YxODk3 YzQ5ZGUuLmMwZjVlZmRmYjU1YzQxNzY4MTQxOWQyZjkwM2VhNDljYzIyZWEwMDUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtODQwLDggKzg0MCw4IEBAIHZv aWQgV2ViUGFnZVByb3h5OjpmaW5pc2hBdHRhY2hpbmdUb1dlYlByb2Nlc3MoUHJvY2Vzc0xhdW5j aFJlYXNvbiByZWFzb24pCiAgICAgcmVtb3RlSW5zcGVjdG9ySW5mb3JtYXRpb25EaWRDaGFuZ2Uo KTsKICNlbmRpZgogCi0gICAgY2xlYXJJbnNwZWN0b3JUYXJnZXRzKCk7Ci0gICAgY3JlYXRlSW5z cGVjdG9yVGFyZ2V0cygpOworICAgIC8vIGNsZWFySW5zcGVjdG9yVGFyZ2V0cygpOworICAgIC8v IGNyZWF0ZUluc3BlY3RvclRhcmdldHMoKTsKIAogICAgIHBhZ2VDbGllbnQoKS5kaWRSZWxhdW5j aFByb2Nlc3MoKTsKICAgICBtX3BhZ2VMb2FkU3RhdGUuZGlkU3dhcFdlYlByb2Nlc3NlcygpOwpA QCAtMjk5NSw2ICsyOTk1LDcgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmNvbW1pdFByb3Zpc2lvbmFs UGFnZShGcmFtZUlkZW50aWZpZXIgZnJhbWVJRCwgdWludDY0X3QgbmF2aWcKICAgICBpZiAoIWRp ZFN1c3BlbmRQcmV2aW91c1BhZ2UpCiAgICAgICAgIG1fcHJvY2Vzcy0+c2VuZChNZXNzYWdlczo6 V2ViUGFnZTo6Q2xvc2UoKSwgbV93ZWJQYWdlSUQpOwogCisgICAgY29uc3QgYXV0byBvbGRXZWJQ YWdlSUQgPSBtX3dlYlBhZ2VJRDsKICAgICBzd2FwVG9XZWJQcm9jZXNzKG1fcHJvdmlzaW9uYWxQ YWdlLT5wcm9jZXNzKCksIG1fcHJvdmlzaW9uYWxQYWdlLT53ZWJQYWdlSUQoKSwgbV9wcm92aXNp b25hbFBhZ2UtPnRha2VEcmF3aW5nQXJlYSgpLCBtX3Byb3Zpc2lvbmFsUGFnZS0+bWFpbkZyYW1l KCkpOwogCiAjaWYgUExBVEZPUk0oQ09DT0EpCkBAIC0zMDA1LDYgKzMwMDYsNyBAQCB2b2lkIFdl YlBhZ2VQcm94eTo6Y29tbWl0UHJvdmlzaW9uYWxQYWdlKEZyYW1lSWRlbnRpZmllciBmcmFtZUlE LCB1aW50NjRfdCBuYXZpZwogCiAgICAgZGlkQ29tbWl0TG9hZEZvckZyYW1lKGZyYW1lSUQsIG5h dmlnYXRpb25JRCwgbWltZVR5cGUsIGZyYW1lSGFzQ3VzdG9tQ29udGVudFByb3ZpZGVyLCBmcmFt ZUxvYWRUeXBlLCBjZXJ0aWZpY2F0ZUluZm8sIGNvbnRhaW5zUGx1Z2luRG9jdW1lbnQsIGZvcmNl ZEhhc0luc2VjdXJlQ29udGVudCwgdXNlckRhdGEpOwogCisgICAgbV9pbnNwZWN0b3JDb250cm9s bGVyLT5kaWRDb21taXRQcm92aXNpb25hbFBhZ2Uob2xkV2ViUGFnZUlELCBtX3dlYlBhZ2VJRCk7 CiAgICAgbV9wcm92aXNpb25hbFBhZ2UgPSBudWxscHRyOwogfQogCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYktp dC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCAwNDJjYmIwODlkYmUyNjU5 MzBlNTBkYmM0NjMyNTEwY2UxOGQyZmZhLi4wYzE3ZjE4ZTExYTc1MWYyMWI2ZDE3NmU2NzNmOGQ3 ZjMzMWJjNDk4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKQEAgLTEzNjMsNyArMTM2Myw2IEBACiAJCUE1NDNFMzA3MjE1QUQxMzcwMDI3OUNE OSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBNTQzRTMwNTIxNUFEMTJEMDAyNzlD RDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oICovOyB9OwogCQlB NTQzRTMwQzIxNUM4QThEMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU0M0UzMDgyMTVDOEE4 MzAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaCAqLzsgfTsKIAkJQTU0M0UzMEQy MTVDOEE5MDAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBNTQzRTMwQjIxNUM4 QTg0MDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCAqLzsgfTsK LQkJQTU0M0UzMTAyMTVEOENFNjAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2Vu dC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU0M0Uz MEUyMTVEOENFMjAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oICovOyB9 OwogCQlBNTVCQTgxMDFCQTEzMTdFMDA3Q0QzM0QgLyogX1dLUmVtb3RlV2ViSW5zcGVjdG9yVmll d0NvbnRyb2xsZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEE1NUJBODBDMUJBMTJCRTEwMDdDRDMzRCAvKiBfV0tSZW1vdGVXZWJJbnNwZWN0b3JWaWV3 Q29udHJvbGxlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCUE1NUJBODE3MUJBMjNFMTIwMDdDRDMzRCAvKiBSZW1vdGVXZWJJbnNwZWN0b3JVSS5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU1QkE4MTMx QkEyM0UwNTAwN0NEMzNEIC8qIFJlbW90ZVdlYkluc3BlY3RvclVJLmggKi87IH07CiAJCUE1NUJB ODFGMUJBMjVCMjcwMDdDRDMzRCAvKiBSZW1vdGVXZWJJbnNwZWN0b3JQcm94eS5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU1QkE4MTkxQkEyNUIxRTAw N0NEMzNEIC8qIFJlbW90ZVdlYkluc3BlY3RvclByb3h5LmggKi87IH07CkBAIC00MDk4LDggKzQw OTcsNiBAQAogCQlBNTQzRTMwOTIxNUM4QTgzMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRh cmdldENvbnRyb2xsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2ViUGFnZUluc3BlY3RvclRh cmdldENvbnRyb2xsZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBNTQzRTMw QTIxNUM4QTg0MDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldC5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJQTU0M0UzMEIyMTVDOEE4NDAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JU YXJnZXRDb250cm9sbGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRD b250cm9sbGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCUE1NDNFMzBFMjE1RDhD RTIwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07Ci0JCUE1NDNFMzBGMjE1RDhDRTIwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 QWdlbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50 LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQTU1QkE4MEMxQkExMkJFMTAwN0NE MzNEIC8qIF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250cm9sbGVyLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250cm9sbGVy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE1NUJBODBEMUJBMTJCRTEwMDdDRDMz RCAvKiBfV0tSZW1vdGVXZWJJbnNwZWN0b3JWaWV3Q29udHJvbGxlci5tbSAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250 cm9sbGVyLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBNTVCQTgxMjFCQTIzRTA1 MDA3Q0QzM0QgLyogUmVtb3RlV2ViSW5zcGVjdG9yVUkuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gUmVtb3RlV2ViSW5zcGVjdG9yVUkuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwpAQCAtNzg3MSw4ICs3ODY4LDYgQEAKIAkJCQkyRDlFQTMwRTFBOTZDQkZG MDAyRDI4MDcgLyogV2ViUGFnZUluamVjdGVkQnVuZGxlQ2xpZW50LmggKi8sCiAJCQkJQTUxM0Y1 M0YyMTU0QTVDRDAwNjYyODQxIC8qIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNwcCAqLywK IAkJCQlBNTEzRjUzRTIxNTRBNUNDMDA2NjI4NDEgLyogV2ViUGFnZUluc3BlY3RvckNvbnRyb2xs ZXIuaCAqLywKLQkJCQlBNTQzRTMwRjIxNUQ4Q0UyMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3Rv clRhcmdldEFnZW50LmNwcCAqLywKLQkJCQlBNTQzRTMwRTIxNUQ4Q0UyMDAyNzlDRDkgLyogV2Vi UGFnZUluc3BlY3RvclRhcmdldEFnZW50LmggKi8sCiAJCQkJQkMxMTFCMEIxMTJGNUU0RjAwMzM3 QkFCIC8qIFdlYlBhZ2VQcm94eS5jcHAgKi8sCiAJCQkJQkMwMzJEQ0IxMEY0Mzg5RjAwNThDMTVB IC8qIFdlYlBhZ2VQcm94eS5oICovLAogCQkJCUJDQkQzOEZBMTI1QkFCOUEwMEQyQzI5RiAvKiBX ZWJQYWdlUHJveHkubWVzc2FnZXMuaW4gKi8sCkBAIC05OTQ4LDcgKzk5NDMsNiBAQAogCQkJCTJE OUVBMzBGMUE5NkNCRkYwMDJEMjgwNyAvKiBXZWJQYWdlSW5qZWN0ZWRCdW5kbGVDbGllbnQuaCBp biBIZWFkZXJzICovLAogCQkJCUE1MTNGNTQwMjE1NEE1RDcwMDY2Mjg0MSAvKiBXZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTU0M0UzMEMyMTVDOEE4RDAw Mjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaCBpbiBIZWFkZXJzICovLAotCQkJCUE1 NDNFMzEwMjE1RDhDRTYwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCBp biBIZWFkZXJzICovLAogCQkJCUE1NDNFMzBEMjE1QzhBOTAwMDI3OUNEOSAvKiBXZWJQYWdlSW5z cGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTU0M0UzMDcyMTVB RDEzNzAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaCBp biBIZWFkZXJzICovLAogCQkJCUMwQ0U3MkExMTI0N0U3MUQwMEJDMEVDNCAvKiBXZWJQYWdlTWVz c2FnZXMuaCBpbiBIZWFkZXJzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dl YlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcAppbmRleCA1NmIwZDUy ZWM1OTU3Y2M3M2ExM2YwNjdlYjNjZGEwMzJkZTIxNzU4Li4yMmJlYzYxODc1NmU2ZjAxOGQ3NzUz YzA0YzIzOGIxZWYyYzY2OGIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dl YlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcApAQCAtMjcsNiArMjcs NyBAQAogI2luY2x1ZGUgIldlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaCIKIAogI2luY2x1ZGUgIldl YlBhZ2UuaCIKKyNpbmNsdWRlICJXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVs LmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9JbnNwZWN0b3JDb250cm9sbGVyLmg+CiAjaW5jbHVkZSA8 V2ViQ29yZS9QYWdlLmg+CiAKQEAgLTQxLDE5ICs0MiwyNSBAQCBXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0KFdlYlBhZ2UmIHBhZ2UpCiAKIFN0cmluZyBXZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0OjppZGVudGlmaWVyKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbWFr ZVN0cmluZygicGFnZS0iLCBtX3BhZ2UuaWRlbnRpZmllcigpLnRvVUludDY0KCkpOworICAgIHJl dHVybiB0b1RhcmdldElEKG1fcGFnZS5pZGVudGlmaWVyKCkpOwogfQogCi12b2lkIFdlYlBhZ2VJ bnNwZWN0b3JUYXJnZXQ6OmNvbm5lY3QoSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWwmIGNoYW5u ZWwpCit2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmNvbm5lY3QoSW5zcGVjdG9yOjpGcm9u dGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQogeworICAgIGlmICht X2NoYW5uZWwpCisgICAgICAgIHJldHVybjsKKyAgICBtX2NoYW5uZWwgPSBtYWtlVW5pcXVlPFdl YlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWw+KG1fcGFnZSwgaWRlbnRpZmllcigp LCBjb25uZWN0aW9uVHlwZSk7CiAgICAgaWYgKG1fcGFnZS5jb3JlUGFnZSgpKQotICAgICAgICBt X3BhZ2UuY29yZVBhZ2UoKS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLmNvbm5lY3RGcm9udGVuZChj aGFubmVsKTsKKyAgICAgICAgbV9wYWdlLmNvcmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIo KS5jb25uZWN0RnJvbnRlbmQoKm1fY2hhbm5lbCk7CiB9CiAKLXZvaWQgV2ViUGFnZUluc3BlY3Rv clRhcmdldDo6ZGlzY29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYgY2hhbm5lbCkK K3ZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldDo6ZGlzY29ubmVjdCgpCiB7CisgICAgaWYgKCFt X2NoYW5uZWwpCisgICAgICAgIHJldHVybjsKICAgICBpZiAobV9wYWdlLmNvcmVQYWdlKCkpCi0g ICAgICAgIG1fcGFnZS5jb3JlUGFnZSgpLT5pbnNwZWN0b3JDb250cm9sbGVyKCkuZGlzY29ubmVj dEZyb250ZW5kKGNoYW5uZWwpOworICAgICAgICBtX3BhZ2UuY29yZVBhZ2UoKS0+aW5zcGVjdG9y Q29udHJvbGxlcigpLmRpc2Nvbm5lY3RGcm9udGVuZCgqbV9jaGFubmVsKTsKKyAgICBtX2NoYW5u ZWwucmVzZXQoKTsKIH0KIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjpzZW5kTWVzc2Fn ZVRvVGFyZ2V0QmFja2VuZChjb25zdCBTdHJpbmcmIG1lc3NhZ2UpCkBAIC02Miw0ICs2OSwxMCBA QCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OnNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5k KGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKICAgICAgICAgbV9wYWdlLmNvcmVQYWdlKCktPmluc3Bl Y3RvckNvbnRyb2xsZXIoKS5kaXNwYXRjaE1lc3NhZ2VGcm9tRnJvbnRlbmQobWVzc2FnZSk7CiB9 CiAKK1N0cmluZyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKGNvbnN0IFdlYkNv cmU6OlBhZ2VJZGVudGlmaWVyJiBwYWdlSUQpCit7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInBh Z2UtIiwgcGFnZUlELnRvVUludDY0KCkpOworfQorCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3Bl Y3RvclRhcmdldC5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUlu c3BlY3RvclRhcmdldC5oCmluZGV4IGI3MGUzMWM4Yjg3NzBjNGJmMWVjYjQ1ODhlYmYyNjc1YjNi OWY0NjQuLmUyYTc0NGRjNDAzZTQ2NmQ1NzI4ZDc4MDY0NjJhNjE3NzFjYWY5NmMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJn ZXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVj dG9yVGFyZ2V0LmgKQEAgLTI2LDI5ICsyNiwzNCBAQAogI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRl IDxKYXZhU2NyaXB0Q29yZS9JbnNwZWN0b3JUYXJnZXQuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL1Bh Z2VJZGVudGlmaWVyLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKIG5hbWVzcGFj ZSBXZWJLaXQgewogCiBjbGFzcyBXZWJQYWdlOworY2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdl dEZyb250ZW5kQ2hhbm5lbDsKIAogY2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdldCBmaW5hbCA6 IHB1YmxpYyBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldCB7CiAgICAgV1RGX01BS0VfRkFTVF9B TExPQ0FURUQ7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoV2ViUGFnZUluc3BlY3RvclRhcmdl dCk7CiBwdWJsaWM6Ci0gICAgV2ViUGFnZUluc3BlY3RvclRhcmdldChXZWJQYWdlJik7CisgICAg ZXhwbGljaXQgV2ViUGFnZUluc3BlY3RvclRhcmdldChXZWJQYWdlJik7CiAgICAgfldlYlBhZ2VJ bnNwZWN0b3JUYXJnZXQoKSA9IGRlZmF1bHQ7CiAKICAgICBJbnNwZWN0b3I6Okluc3BlY3RvclRh cmdldFR5cGUgdHlwZSgpIGNvbnN0IGZpbmFsIHsgcmV0dXJuIEluc3BlY3Rvcjo6SW5zcGVjdG9y VGFyZ2V0VHlwZTo6UGFnZTsgfQogCiAgICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25zdCBmaW5h bDsKIAotICAgIHZvaWQgY29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYpOwotICAg IHZvaWQgZGlzY29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYpOwotICAgIHZvaWQg c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJik7CisgICAgdm9pZCBjb25u ZWN0KEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSkgb3ZlcnJpZGU7 CisgICAgdm9pZCBkaXNjb25uZWN0KCkgb3ZlcnJpZGU7CisgICAgdm9pZCBzZW5kTWVzc2FnZVRv VGFyZ2V0QmFja2VuZChjb25zdCBTdHJpbmcmKSBvdmVycmlkZTsKKworICAgIHN0YXRpYyBTdHJp bmcgdG9UYXJnZXRJRChjb25zdCBXZWJDb3JlOjpQYWdlSWRlbnRpZmllciYpOwogCiBwcml2YXRl OgogICAgIFdlYlBhZ2UmIG1fcGFnZTsKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViUGFnZUluc3Bl Y3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4gbV9jaGFubmVsOwogfTsKIAogfSAvLyBuYW1lc3Bh Y2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9X ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHAKaW5kZXgg NTI1NDg5NjczZDY2YTJlNGE3ZmQzMmYzNjQ4NTM0Y2UzZWRlZWM0Ny4uY2RhNGYxZThkM2M1NzUz NjE2MmFhMzkwZWQ3NGI2ODFjODkxMzQwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQ cm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRD b250cm9sbGVyLmNwcApAQCAtNTgsNyArNTgsNiBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJn ZXRDb250cm9sbGVyOjpyZW1vdmVUYXJnZXQoSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXQmCiAg ICAgbV9wYWdlLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGVzdHJveUluc3BlY3RvclRh cmdldCh0YXJnZXQuaWRlbnRpZmllcigpKSk7CiAKICAgICBtX3RhcmdldHMucmVtb3ZlKHRhcmdl dC5pZGVudGlmaWVyKCkpOwotICAgIG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVscy5yZW1vdmUodGFy Z2V0LmlkZW50aWZpZXIoKSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRy b2xsZXI6OmNvbm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9y OjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQpAQCAtNjcs MTMgKzY2LDcgQEAgdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6Y29ubmVj dEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkLAogICAgIGlmICghdGFyZ2V0KQogICAg ICAgICByZXR1cm47CiAKLSAgICBSZWZQdHI8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbD4gY2hhbm5lbCA9IG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVscy5nZXQodGFyZ2V0SWQp OwotICAgIGlmICghY2hhbm5lbCkgewotICAgICAgICBjaGFubmVsID0gV2ViUGFnZUluc3BlY3Rv clRhcmdldEZyb250ZW5kQ2hhbm5lbDo6Y3JlYXRlKCp0aGlzLCB0YXJnZXRJZCwgY29ubmVjdGlv blR5cGUpOwotICAgICAgICBtX3RhcmdldEZyb250ZW5kQ2hhbm5lbHMuc2V0KHRhcmdldC0+aWRl bnRpZmllcigpLCBjaGFubmVsKTsKLSAgICB9Ci0KLSAgICB0YXJnZXQtPmNvbm5lY3QoKmNoYW5u ZWwuZ2V0KCkpOworICAgIHRhcmdldC0+Y29ubmVjdChjb25uZWN0aW9uVHlwZSk7CiB9CiAKIHZv aWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3Io Y29uc3QgU3RyaW5nJiB0YXJnZXRJZCkKQEAgLTgyLDExICs3NSw3IEBAIHZvaWQgV2ViUGFnZUlu c3BlY3RvclRhcmdldENvbnRyb2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5n JiB0YXJnZXRJCiAgICAgaWYgKCF0YXJnZXQpCiAgICAgICAgIHJldHVybjsKIAotICAgIFJlZlB0 cjxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsPiBjaGFubmVsID0gbV90YXJn ZXRGcm9udGVuZENoYW5uZWxzLnRha2UodGFyZ2V0SWQpOwotICAgIGlmICghY2hhbm5lbCkKLSAg ICAgICAgcmV0dXJuOwotCi0gICAgdGFyZ2V0LT5kaXNjb25uZWN0KCpjaGFubmVsLmdldCgpKTsK KyAgICB0YXJnZXQtPmRpc2Nvbm5lY3QoKTsKIH0KIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0Q29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJiB0 YXJnZXRJZCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlKQpAQCAtOTgsOSArODcsNCBAQCB2b2lkIFdl YlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2Vu ZChjb25zdCBTdHJpbmcmCiAgICAgdGFyZ2V0LT5zZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZCht ZXNzYWdlKTsKIH0KIAotdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6c2Vu ZE1lc3NhZ2VUb1RhcmdldEZyb250ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0 cmluZyYgbWVzc2FnZSkKLXsKLSAgICBtX3BhZ2Uuc2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5 OjpTZW5kTWVzc2FnZVRvSW5zcGVjdG9yRnJvbnRlbmQodGFyZ2V0SWQsIG1lc3NhZ2UpKTsKLX0K LQogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oIGIvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xs ZXIuaAppbmRleCAzZTkyYjdhOWRhOWU1NjA5ZTYwMTY2MzljMDliNzNjYjU5NmY4YWY1Li43Yzkz MWRhZDFjOTgwMGYwM2Q3M2Q0YTdjYTI1ODhkZDAyOGE4ZjI0IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxl ci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0 b3JUYXJnZXRDb250cm9sbGVyLmgKQEAgLTI2LDcgKzI2LDYgQEAKICNwcmFnbWEgb25jZQogCiAj aW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIgotI2luY2x1ZGUgIldlYlBhZ2VJbnNw ZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgog I2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCkBAIC01MCwxMyArNDksMTEgQEAgcHVi bGljOgogICAgIHZvaWQgY29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJ bnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUpOwogICAgIHZvaWQgZGlz Y29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkKTsKICAgICB2b2lkIHNlbmRN ZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0cmlu ZyYgbWVzc2FnZSk7Ci0gICAgdm9pZCBzZW5kTWVzc2FnZVRvVGFyZ2V0RnJvbnRlbmQoY29uc3Qg U3RyaW5nJiB0YXJnZXRJZCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlKTsKIAogcHJpdmF0ZToKICAg ICBXZWJQYWdlJiBtX3BhZ2U7CiAgICAgV2ViUGFnZUluc3BlY3RvclRhcmdldCBtX3BhZ2VUYXJn ZXQ7CiAgICAgSGFzaE1hcDxTdHJpbmcsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0Kj4gbV90 YXJnZXRzOwotICAgIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8V2ViUGFnZUluc3BlY3RvclRhcmdl dEZyb250ZW5kQ2hhbm5lbD4+IG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVsczsKIH07CiAKIH0gLy8g bmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dl YlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5jcHAgYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRD aGFubmVsLmNwcAppbmRleCA4ZDc4ODA3ODJhMjliMTcwY2U2NWFmYzcwMzc3ZDhiZDUwNjk0MzU4 Li42Y2RmZDdlMmU0MDVhOGY5NDJkYjcwMDkwY2U0ZjZlZjZmMzIwZTNjIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJv bnRlbmRDaGFubmVsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9X ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcApAQCAtMjYsMTcgKzI2LDEy IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdl dEZyb250ZW5kQ2hhbm5lbC5oIgogCi0jaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldENv bnRyb2xsZXIuaCIKKyNpbmNsdWRlICJXZWJQYWdlLmgiCiAKIG5hbWVzcGFjZSBXZWJLaXQgewog Ci1SZWY8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4gV2ViUGFnZUluc3Bl Y3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6Y3JlYXRlKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRD b250cm9sbGVyJiB0YXJnZXRDb250cm9sbGVyLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNw ZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgY29ubmVjdGlvblR5cGUpCi17 Ci0gICAgcmV0dXJuIGFkb3B0UmVmKCpuZXcgV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbCh0YXJnZXRDb250cm9sbGVyLCB0YXJnZXRJZCwgY29ubmVjdGlvblR5cGUpKTsKLX0K LQotV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6V2ViUGFnZUluc3BlY3Rv clRhcmdldEZyb250ZW5kQ2hhbm5lbChXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlciYg dGFyZ2V0Q29udHJvbGxlciwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpGcm9u dGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQotICAgIDogbV90YXJn ZXRDb250cm9sbGVyKHRhcmdldENvbnRyb2xsZXIpCitXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJv bnRlbmRDaGFubmVsOjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsKFdlYlBh Z2UmIHBhZ2UsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFu bmVsOjpDb25uZWN0aW9uVHlwZSBjb25uZWN0aW9uVHlwZSkKKyAgICA6IG1fcGFnZShwYWdlKQog ICAgICwgbV90YXJnZXRJZCh0YXJnZXRJZCkKICAgICAsIG1fY29ubmVjdGlvblR5cGUoY29ubmVj dGlvblR5cGUpCiB7CkBAIC00NCw3ICszOSw3IEBAIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWw6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwoV2ViCiAK IHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6c2VuZE1lc3NhZ2VU b0Zyb250ZW5kKGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKIHsKLSAgICBtX3RhcmdldENvbnRyb2xs ZXIuc2VuZE1lc3NhZ2VUb1RhcmdldEZyb250ZW5kKG1fdGFyZ2V0SWQsIG1lc3NhZ2UpOworICAg IG1fcGFnZS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlNlbmRNZXNzYWdlVG9JbnNwZWN0 b3JGcm9udGVuZChtX3RhcmdldElkLCBtZXNzYWdlKSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdl YktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFn ZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oCmluZGV4 IDc2YWY2MmE5N2JlZjQ4OGI2NDRlNWQ2MThkNDM5ZWM5YTQyZjIyZGEuLjk3NjA5OGRhNGQ3YmU1 NjNmMWI5MzExMjYxOTdlNDJmMDhkMWNjMTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaAor KysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFy Z2V0RnJvbnRlbmRDaGFubmVsLmgKQEAgLTMxLDIyICszMSwyMCBAQAogCiBuYW1lc3BhY2UgV2Vi S2l0IHsKIAotY2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI7CitjbGFzcyBX ZWJQYWdlOwogCi1jbGFzcyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsIGZp bmFsIDogcHVibGljIFJlZkNvdW50ZWQ8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hh bm5lbD4sIHB1YmxpYyBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCB7CitjbGFzcyBXZWJQYWdl SW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsIGZpbmFsIDogcHVibGljIEluc3BlY3Rvcjo6 RnJvbnRlbmRDaGFubmVsIHsKICAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKKyAgICBXVEZf TUFLRV9OT05DT1BZQUJMRShXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsKTsK IHB1YmxpYzoKLSAgICBzdGF0aWMgUmVmPFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENo YW5uZWw+IGNyZWF0ZShXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlciYsIGNvbnN0IFN0 cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlw ZSk7Ci0gICAgdmlydHVhbCB+V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbCgp ID0gZGVmYXVsdDsKKyAgICBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsKFdl YlBhZ2UmLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5l bDo6Q29ubmVjdGlvblR5cGUpOworICAgIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRD aGFubmVsKCkgb3ZlcnJpZGUgPSBkZWZhdWx0OwogCiBwcml2YXRlOgotICAgIFdlYlBhZ2VJbnNw ZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwoV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xs ZXImLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6 Q29ubmVjdGlvblR5cGUpOwotCiAgICAgQ29ubmVjdGlvblR5cGUgY29ubmVjdGlvblR5cGUoKSBj b25zdCBvdmVycmlkZSB7IHJldHVybiBtX2Nvbm5lY3Rpb25UeXBlOyB9CiAgICAgdm9pZCBzZW5k TWVzc2FnZVRvRnJvbnRlbmQoY29uc3QgU3RyaW5nJiBtZXNzYWdlKSBvdmVycmlkZTsKIAotcHJp dmF0ZToKLSAgICBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlciYgbV90YXJnZXRDb250 cm9sbGVyOworICAgIFdlYlBhZ2UmIG1fcGFnZTsKICAgICBTdHJpbmcgbV90YXJnZXRJZDsKICAg ICBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgbV9jb25uZWN0aW9u VHlwZSB7IEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZTo6UmVtb3Rl IH07CiB9Owo= 379967 2019-10-01 16:52:55 -0700 2019-10-08 10:47:23 -0700 Patch bug-202219-20191001165254.patch text/plain 70149 yurys U3VidmVyc2lvbiBSZXZpc2lvbjogMjUwNTU1CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBm OTVkOTViMzdlMGRkODg1YzcyMjUwOGVhZmEyOGE4N2JiNWUyYWFkLi5kOWM0MDM5ODJlZjYxZmJi MTZkNTk1NjhjODM5MGYwODAyYmVlMzQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyOCBAQAorMjAxOS0wOS0yNyAgWXVyeSBTZW1pa2hhdHNreSAgPHl1cnlzQGNocm9taXVt Lm9yZz4KKworICAgICAgICBXZWIgSW5zcGVjdG9yOiBhdHRhY2ggdG8gcHJvdmlzaW9uYWwgcGFn ZXMgZWFybHkgdG8gbm90IG1pc3MgZXZlbnRzIGR1cmluZyBwcm9jZXNzIHN3YXBzIChQU09OKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyMjE5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBpbnNwZWN0 b3IvSW5zcGVjdG9yVGFyZ2V0Lmg6IGNoYW5nZWQgSW5zcGVjdG9yVGFyZ2V0IHRvIG5vdCByZXF1 aXJlIEZyb250ZW5kQ2hhbm5lbCBhcworICAgICAgICBhbGwgbWVzc2FnZXMgYXJlIHJvdXRlZCBi eSBtZWFucyBvZiB0aGUgb3duaW5nIEluc3BlY3RvclRhcmdldEFnZW50LgorICAgICAgICAqIGlu c3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6SW5zcGVjdG9yVGFyZ2V0QWdlbnQpOgorICAgICAg ICAoSW5zcGVjdG9yOjpidWlsZFRhcmdldEluZm9PYmplY3QpOgorICAgICAgICAoSW5zcGVjdG9y OjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6dGFyZ2V0Q3JlYXRlZCk6CisgICAgICAgIChJbnNwZWN0 b3I6Okluc3BlY3RvclRhcmdldEFnZW50Ojp0YXJnZXREZXN0cm95ZWQpOgorICAgICAgICAoSW5z cGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQp OiB0aGlzIG1ldGhvZCBpcyB1c2VkIHRvCisgICAgICAgIG5vdGlmeSBmcm9udGVuZCB0aGF0IGNv cnJlc3BvbmRpbmcgcHJvdmlzaW9uYWwgdGFyZ2V0IGhhcyBjb21taXR0ZWQgYW5kIHJlcGxhY2Vk IHByZXZpb3VzCisgICAgICAgIHRhcmdldC4KKyAgICAgICAgKEluc3BlY3Rvcjo6SW5zcGVjdG9y VGFyZ2V0QWdlbnQ6OmNvbm5lY3Rpb25UeXBlIGNvbnN0KToKKyAgICAgICAgKEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3RUb1RhcmdldHMpOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlzY29ubmVjdEZyb21UYXJnZXRzKToKKyAgICAg ICAgKiBpbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50Lmg6CisgICAgICAgICog aW5zcGVjdG9yL3Byb3RvY29sL1RhcmdldC5qc29uOiBleHRlbmRlZCBUYXJnZXRJbmZvIHdpdGgg cHJvdmlzaW9uYWwgcGFnZSBkZXRhaWxzIGFuZAorICAgICAgICBhZGRlZCBldmVudCB3aGljaCBp cyBmaXJlZCB3aGVuIHByb3Zpc2lvbmFsIHBhZ2UgZ2V0cyBjb21taXR0ZWQuIElmIHByb3Zpc2lv bmFsCisgICAgICAgIGxvYWQgZmFpbHMgdGhlcmUgd2lsbCBiZSB0YXJnZXREZXN0cm95ZWQgZXZl bnQgd2l0aG91dCBjb3JyZXNwb25kaW5nIGNvbW1pdC4KKwogMjAxOS0wOS0zMCAgQWxleCBDaHJp c3RlbnNlbiAgPGFjaHJpc3RlbnNlbkB3ZWJraXQub3JnPgogCiAgICAgICAgIFJlc3VycmVjdCBN YWMgQ01ha2UgYnVpbGQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAzNTFiNDlmZTBkMzIzMTI1MjkxMmM0MzA0MzY5 NTU3Y2VlY2EyZTg1Li4zZWE2YmVhMGVhZDZmODEzOTYwNTAyNTdiOWI0NzRjZTFiOGYwNTQ3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTktMTAtMDEgIFl1cnkgU2VtaWtoYXRza3kg IDx5dXJ5c0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogYXR0YWNoIHRv IHByb3Zpc2lvbmFsIHBhZ2VzIGVhcmx5IHRvIG5vdCBtaXNzIGV2ZW50cyBkdXJpbmcgcHJvY2Vz cyBzd2FwcyAoUFNPTikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMjIxOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFRlc3Q6IGh0dHAvdGVzdHMvaW5zcGVjdG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZv ci1wcm9pc2lvbmFsLXBhZ2UuaHRtbAorCisgICAgICAgICogaW5zcGVjdG9yL0luc3BlY3RvckNv bnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zcGVjdG9yQ29udHJvbGxlcjo6c2V0 SXNVbmRlclRlc3QpOiBUaGlzIG1ldGhvZCBtYXliZSBjbG9zZWQgc2V2ZXJhbCB0aW1lcworICAg ICAgICB3aGVuIHJlbG9hZGluZyBpbnNwZWN0ZWQgcGFnZSB3aXRoIG9wZW5lZCBmcm9udGVuZCBz byB0aGUgYXNzdW1wdGlvbiB0aGF0IHRoZXJlIGFyZSBubworICAgICAgICBjb25uZWN0ZWQgZnJv bnRlbmRzIHdoZW4gdGhpcyBtZXRob2QgaXMgY2FsbGVkIGZyb20gdGVzdHMgZG9lc24ndCBob2xk IGFueW1vcmUuCisKIDIwMTktMTAtMDEgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtDb29yZEdyYXBoaWNzXSBJbXBsZW1lbnQgc3luYyBtZXRob2RzIGZv ciBwb3NpdGlvbiwgYm91bmRzIG9yaWdpbgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3Rv clVJL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKaW5kZXggZTAw NDI3N2QxM2JkZjhkNTNhODI4YWU4MjFhNjIyYzBiNTE0ODQ5Yy4uMDk2M2UxZTFlNjc3ZjFjNjU5 ZWFjNTU2Y2NlZDQyYjBkZWYzMjQ3ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJ L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsNDQgQEAKKzIwMTktMDktMjcgIFl1cnkgU2VtaWtoYXRza3kgIDx5dXJ5c0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogYXR0YWNoIHRvIHByb3Zpc2lvbmFsIHBhZ2Vz IGVhcmx5IHRvIG5vdCBtaXNzIGV2ZW50cyBkdXJpbmcgcHJvY2VzcyBzd2FwcyAoUFNPTikKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMjIxOQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVwZGF0ZWQgZnJv bnRlbmQgY29kZSB0byB1bmRlcnN0YW5kIHByb3Zpc2lvbmFsIHRhcmdldHMuIEZvciBub3cgdGhl cmUgYXJlCisgICAgICAgIG5vIGNoYW5nZXMgZnJvbnRlbmQgYmhhdmlvciwgaXQgd2lsbCB3YWl0 IGZvciB0aGUgcHJvdmlzaW9uYWwgdGFyZ2V0IHRvIGNvbW1pdAorICAgICAgICBhbmQgd2lsbCBu b3Qgc2VuZCBhbnkgY29tbWFuZHMgdG8gaXQgYmVmb3JlIHRoYXQuCisKKyAgICAgICAgKiBVc2Vy SW50ZXJmYWNlL0NvbnRyb2xsZXJzL1RhcmdldE1hbmFnZXIuanM6CisgICAgICAgIChXSS5UYXJn ZXRNYW5hZ2VyLnByb3RvdHlwZS5yZW1vdmVUYXJnZXQpOgorICAgICAgICAqIFVzZXJJbnRlcmZh Y2UvUHJvdG9jb2wvQ29ubmVjdGlvbi5qczoKKyAgICAgICAgKEluc3BlY3RvckJhY2tlbmQuV29y a2VyQ29ubmVjdGlvbi5zZW5kTWVzc2FnZVRvQmFja2VuZCk6CisgICAgICAgIChJbnNwZWN0b3JC YWNrZW5kLldvcmtlckNvbm5lY3Rpb24pOgorICAgICAgICAoSW5zcGVjdG9yQmFja2VuZC5UYXJn ZXRDb25uZWN0aW9uLnNlbmRNZXNzYWdlVG9CYWNrZW5kKToKKyAgICAgICAgKEluc3BlY3RvckJh Y2tlbmQuVGFyZ2V0Q29ubmVjdGlvbik6CisgICAgICAgICogVXNlckludGVyZmFjZS9Qcm90b2Nv bC9UYXJnZXQuanM6CisgICAgICAgIChXSS5UYXJnZXQucHJvdG90eXBlLmRlc3Ryb3kpOiBNYXJr IHRhcmdldCBhcyBkZXN0cm95ZWQgdG8gZGlzdGluZ3Vpc2ggZXhwZWN0ZWQgY29tbWFuZCBlcnJv cnMgZnJvbQorICAgICAgICBnZW51aW5lIGZhaWx1cmVzLgorCisgICAgICAgIChXSS5UYXJnZXQu cHJvdG90eXBlLmlzRGVzdHJveWVkKToKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1Byb3RvY29s L1RhcmdldE9ic2VydmVyLmpzOiBTaW5jZSB0aGUgZnJvbnQtZW5kIGRvZXNuJ3QKKyAgICAgICAg c2VuZCBjb21tYW5kcyB0byB0aGUgcHJvdmlzaW9uYWwgdGFyZ3RldHMgeWV0LCBpdCBoYXMgdG8g aWdub3JlIGFsbCBhY3Rpdml0aWVzCisgICAgICAgIHJlbGF0ZWQgdG8gcHJvdmlzaW9uYWwgcGFn ZXMuIEZvciB0aGF0IHJlYXNvbiB3ZSBuZWVkIHR3byBzZXRzIHRvIGtlZXAgdHJhY2sgb2YKKyAg ICAgICAgLSBwcm92aXNpb25hbCBwYWdlcyB0aGF0IHdlcmUgZGVzdHJveWVkIGFuZCBuZXZlciBj b21taXR0ZWQKKyAgICAgICAgLSBvbGQgcGFnZXMgd2hpY2ggd2VyZSByZXBsYWNlZCBieSBjb21t aXR0ZWQgcGFnZSBhbmQgZm9yIHdoaWNoIGZvbGxvd2luZyB0YXJnZXREZXN0cm95ZWQKKyAgICAg ICAgZXZlbnQgc2hvdWxkIGJlIGlnbm9yZWQKKyAgICAgICAgQmV0dGVyIHN1cHBvcnQgZm9yIHBy b3Zpc2lvbmFsIHRhcmdldHMgd2lsbCBiZSBhZGRlZCB0byBmcm9udGVuZCBpbiBhIHNlcGFyYXRl IGNoYW5nZS4KKyAgICAgICAgKFdJLlRhcmdldE9ic2VydmVyKToKKyAgICAgICAgKFdJLlRhcmdl dE9ic2VydmVyLnByb3RvdHlwZS50YXJnZXRDcmVhdGVkKToKKyAgICAgICAgKFdJLlRhcmdldE9i c2VydmVyLnByb3RvdHlwZS5kaWRDb21taXRQcm92aXNpb25hbFRhcmdldCk6IEZvciBub3cgY29u dmVydCB0aGUgZXZlbnQgaW50byBhIHN1YnNlcXVlbmNlCisgICAgICAgIG9mIHRhc3JnZXREZXN0 cm95ZWQvdGFyZ2V0Q3JlYXRlZCBldmVudHMgd2hpY2ggbWF0Y2hlcyBwcmV2aW91cyBiZWhhdmlv ci4KKworICAgICAgICAoV0kuVGFyZ2V0T2JzZXJ2ZXIucHJvdG90eXBlLnRhcmdldERlc3Ryb3ll ZCk6CisgICAgICAgIChXSS5UYXJnZXRPYnNlcnZlci5wcm90b3R5cGUuZGlzcGF0Y2hNZXNzYWdl RnJvbVRhcmdldCk6CisgICAgICAgICogVXNlckludGVyZmFjZS9UZXN0L1Rlc3QuanM6CisgICAg ICAgIChXSS50cmFuc2l0aW9uUGFnZVRhcmdldCk6CisgICAgICAgIChXSS50ZXJtaW5hdGVQYWdl VGFyZ2V0KToKKwogMjAxOS0wOS0zMCAgRGV2aW4gUm91c3NvICA8ZHJvdXNzb0BhcHBsZS5jb20+ CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogSlMgRm9ybWF0dGVyOiB1bmV4cGVjdGVkIG5ld2xp bmVzIGFkZGVkIGluc2lkZSB0ZW1wbGF0ZSBzdHJpbmcgZXhwcmVzc2lvbgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCBl NzY3MDA5ZmI1Zjg3ZDhiNWFiYTY3YzI3Nzk3YzJmNGMyNzBhZjJiLi43Yzg0MDEyNWY5ZWQ0Mjlm NGY4YTM3ZmNhZjI1YjNkMTYwZGYyZDM0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDc3IEBACisyMDE5 LTA5LTI3ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3JnPgorCisgICAgICAg IFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92aXNpb25hbCBwYWdlcyBlYXJseSB0byBub3Qg bWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dhcHMgKFBTT04pCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDIyMTkKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYXJnZXQudGFyZ2V0Q3JlYXRlZCBldmVu dCBpcyBub3cgZ2VuZXJhdGVkIGZvciBwcm92aXNpb25hbCBwYWdlcyBhcyB3ZWxsIGFzIGZvciBy ZWd1bGFyCisgICAgICAgIG9uZXMuIFRoaXMgaXMgdGhlIGZpcnN0IHN0ZXAgdG93YXJkIHJlYXR0 YWNoaW5nIGluc3BlY3RvciBlYXJsaWVyIGR1cmluZyBQU09OLiBJbiB0aGUgZnV0dXJlCisgICAg ICAgIGlmIGRlYnVnZ2luZyBpcyBpbiBwcm9ncmVzcyB0aGUgcHJvdmlzaW9uYWwgdGFyZ2V0IChw YWdlKSB3aWxsIGJlIHBhdXNlZCB1bnRpbCBhIHNpZ25hbCBmcm9tCisgICAgICAgIGluc3BlY3Rv ciBmcm9udGVuZC4gVGhpcyB3aWxsIGVuYWJsZSB0aGUgZnJvbnRlbmQgY29uZmlndXJlIGFsbCBh Z2VudHMgYmVmb3JlIG5hdmlnYXRpb24gc3RhcnRzLgorCisgICAgICAgICogU291cmNlcy50eHQ6 CisgICAgICAgICogVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmNwcDoKKyAgICAgICAg KFdlYktpdDo6SW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZSk6CisgICAgICAgIChXZWJLaXQ6 Okluc3BlY3RvclRhcmdldFByb3h5Ojpjb25uZWN0KToKKyAgICAgICAgKFdlYktpdDo6SW5zcGVj dG9yVGFyZ2V0UHJveHk6OmRpc2Nvbm5lY3QpOgorICAgICAgICAoV2ViS2l0OjpJbnNwZWN0b3JU YXJnZXRQcm94eTo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQpOgorICAgICAgICAoV2ViS2l0 OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQpOgorICAg ICAgICAoV2ViS2l0OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6aXNQcm92aXNpb25hbCBjb25zdCk6 CisgICAgICAgIChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5OjpwcmV2aW91c1RhcmdldElE IGNvbnN0KToKKyAgICAgICAgKiBVSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0UHJveHkuaDogVGFy Z2V0IHByb3h5IGNhbiBzdGFydCBhcyBhIHByb3Zpc2lvbmFsIHRhcmdldCAod2l0aCBhIHBvaW50 ZXIgdG8KKyAgICAgICAgUHJvdmlzaW9uYWxQYWdlUHJveHkpIGFuZCBsYXRlciBlaXRoZXIgYmUg Y29tbWl0dGVkIG9yIGRlc3Ryb3llZC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9Qcm92aXNpb25h bFBhZ2VQcm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OlByb3Zpc2lvbmFsUGFnZVByb3h5OjpQ cm92aXNpb25hbFBhZ2VQcm94eSk6CisgICAgICAgIChXZWJLaXQ6OlByb3Zpc2lvbmFsUGFnZVBy b3h5Ojp+UHJvdmlzaW9uYWxQYWdlUHJveHkpOgorICAgICAgICAoV2ViS2l0OjpQcm92aXNpb25h bFBhZ2VQcm94eTo6ZGlkUmVjZWl2ZU1lc3NhZ2UpOiBGb3J3YXJkIGluc3BlY3RvciBtZXNzYWdl cyB0byBwYXJlbnQgcGFnZSdzIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLgorICAgICAgICBT aW5jZSBlYWNoIFdlYlBhZ2UgaGFzIGEgdW5pcXVlIGlkZW50aWZpZXIgdGhlIHRhcmdldCBpZHMg d2lsbCBiZSBnbG9iYWxseSB1bmlxdWUgYW5kIHRoZXJlIGlzIG5vIHJpc2sgb2YgY29sbGlzaW9u cy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5oOgorICAgICAg ICAoV2ViS2l0OjpQcm92aXNpb25hbFBhZ2VQcm94eTo6cGFnZSBjb25zdCk6CisgICAgICAgICog VUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYktp dDo6Z2V0VGFyZ2V0SUQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yQ29udHJv bGxlcjo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIpOgorICAgICAgICAoV2ViS2l0OjpXZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6Y2xlYXJUYXJnZXRzKToKKyAgICAgICAgKFdlYktpdDo6 V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNyZWF0ZUluc3BlY3RvclRhcmdldCk6CisgICAg ICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkZXN0cm95SW5zcGVjdG9y VGFyZ2V0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmRp ZENyZWF0ZVByb3Zpc2lvbmFsUGFnZSk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0 b3JDb250cm9sbGVyOjpkaWREZXN0cm95UHJvdmlzaW9uYWxQYWdlKToKKyAgICAgICAgKFdlYktp dDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmRpZENvbW1pdFByb3Zpc2lvbmFsUGFnZSk6 CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjphZGRUYXJnZXQp OgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oOgorICAg ICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwOiBSZW1vdmVk LiBNZXJnZWQgdGhpcyBhZ2VudCBpbnRvIEluc3BlY3RvclRhcmdldEFnZW50LgorICAgICAgICAq IFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaDogUmVtb3ZlZC4KKyAgICAg ICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6bV9yZXNl dFJlY2VudENyYXNoQ291bnRUaW1lcik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6 ZmluaXNoQXR0YWNoaW5nVG9XZWJQcm9jZXNzKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVBy b3h5Ojpjb21taXRQcm92aXNpb25hbFBhZ2UpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdl UHJveHkuaDogTW92ZWQgdGhlIHRhcmdldCBtYW5hZ2VtZW50IGxvZ2ljIGludG8gV2ViUGFnZUlu c3BlY3RvckNvbnRyb2xsZXIuCisgICAgICAgIFdlYlBhZ2VQcm94eS9Qcm92aXNpb25hbFBhZ2VQ cm94eSBhcmUgZXhwZWN0ZWQgdG8gbm90aWZpeSBpdCBhYm91dCBrZXkgbGlmZWN5Y2xlIGV2ZW50 cyBhbmQgYWxzbworICAgICAgICBmb3J3YXJkIHRvIGl0IG1lc3NhZ2VzIGZyb20gaW5zcGVjdG9y IGluIHRoZSBpbnNwZWN0ZWQgV2ViUHJvY2Vzcy4gSG93IGl0IHRyYW5zbGF0ZXMgdG8gVGFyZ2V0 CisgICAgICAgIGV2ZW50cyBpcyBpbnNwZWN0b3IncyBidXNpbmVzcy4KKworICAgICAgICAqIFdl YktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFn ZUluc3BlY3RvclRhcmdldDo6aWRlbnRpZmllciBjb25zdCk6CisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmNvbm5lY3QpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdl SW5zcGVjdG9yVGFyZ2V0OjpkaXNjb25uZWN0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUlu c3BlY3RvclRhcmdldDo6dG9UYXJnZXRJRCk6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdl L1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaDogTWFkZSB0aGUgdGFyZ2V0IG93biBmcm9udGVuZCBj aGFubmVsIGluc3RhbmNlIGFzIGl0J3MgdGhlCisgICAgICAgIG9ubHkgcGxhY2Ugd2hlcmUgdGhl IHBhZ2Ugc3BlY2lmaWMgY2hhbm5lbCBpcyB1c2VkLgorCisgICAgICAgICogV2ViUHJvY2Vzcy9X ZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdl YktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OnJlbW92ZVRhcmdldCk6Cisg ICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpjb25uZWN0 SW5zcGVjdG9yKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRy b2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3IpOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFn ZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oOgorICAgICAgICAqIFdlYlByb2Nl c3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcDoKKyAg ICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6V2Vi UGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbCk6CisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWw6OnNlbmRNZXNzYWdlVG9Gcm9udGVu ZCk6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRG cm9udGVuZENoYW5uZWwuaDogVGhlIGNoYW5uZWwncyBsaWZldGltZSBpcyBtYW5hZ2VkIGJ5IG93 bmluZworICAgICAgICB0YXJnZXQuIE5vIG5lZWQgdG8gcmVmZXJlbmNlIGNvdW50IGl0LgorCiAy MDE5LTEwLTAxICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBS ZW1vdmUgcmFjZXMgY29uZGl0aW9uIHdoZW4gdmFsaWRhdGluZyBjYXB0dXJlIHNhbmRib3ggZXh0 ZW5zaW9uIHJldm9jYXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNw ZWN0b3IvSW5zcGVjdG9yVGFyZ2V0LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9y L0luc3BlY3RvclRhcmdldC5oCmluZGV4IDllZGFhMWY0MjA5NWYwNjJmNDVhODEwM2ZhMjc0YjUx NWI2MmYxOGIuLmY4Mjg3YTNkZDlhMGVjNzk5NDI4MDM4YWI4N2JjZjljNjE1YjQyYWUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yVGFyZ2V0LmgK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9JbnNwZWN0b3JUYXJnZXQuaApA QCAtNDcsOSArNDcsMTIgQEAgcHVibGljOgogICAgIHZpcnR1YWwgU3RyaW5nIGlkZW50aWZpZXIo KSBjb25zdCA9IDA7CiAgICAgdmlydHVhbCBJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUoKSBjb25z dCA9IDA7CiAKKyAgICB2aXJ0dWFsIGJvb2wgaXNQcm92aXNpb25hbCgpIGNvbnN0IHsgcmV0dXJu IGZhbHNlOyB9CisgICAgdmlydHVhbCBTdHJpbmcgcHJldmlvdXNUYXJnZXRJRCgpIGNvbnN0IHsg cmV0dXJuIFN0cmluZygpOyB9CisKICAgICAvLyBDb25uZWN0aW9uIG1hbmFnZW1lbnQuCi0gICAg dmlydHVhbCB2b2lkIGNvbm5lY3QoRnJvbnRlbmRDaGFubmVsJikgPSAwOwotICAgIHZpcnR1YWwg dm9pZCBkaXNjb25uZWN0KEZyb250ZW5kQ2hhbm5lbCYpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQg Y29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUpID0gMDsK KyAgICB2aXJ0dWFsIHZvaWQgZGlzY29ubmVjdCgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2Vu ZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJikgPSAwOwogfTsKIApkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFy Z2V0QWdlbnQuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9hZ2VudHMvSW5z cGVjdG9yVGFyZ2V0QWdlbnQuY3BwCmluZGV4IGM2YzZiZjgwNmUyZTI2YjE1NGJmOWNhNzJjMGNj YWU5NGY1MDNjYWEuLmNkNmY1Nzk2YzAyY2I2NTVhOGE1MDI3YmNlNWM5ZTFiYTUyNDFhOTggMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3Rv clRhcmdldEFnZW50LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL2Fn ZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5jcHAKQEAgLTMyLDYgKzMyLDcgQEAgbmFtZXNwYWNl IEluc3BlY3RvciB7CiAKIEluc3BlY3RvclRhcmdldEFnZW50OjpJbnNwZWN0b3JUYXJnZXRBZ2Vu dChGcm9udGVuZFJvdXRlciYgZnJvbnRlbmRSb3V0ZXIsIEJhY2tlbmREaXNwYXRjaGVyJiBiYWNr ZW5kRGlzcGF0Y2hlcikKICAgICA6IEluc3BlY3RvckFnZW50QmFzZSgiVGFyZ2V0Il9zKQorICAg ICwgbV9yb3V0ZXIoZnJvbnRlbmRSb3V0ZXIpCiAgICAgLCBtX2Zyb250ZW5kRGlzcGF0Y2hlciht YWtlVW5pcXVlPFRhcmdldEZyb250ZW5kRGlzcGF0Y2hlcj4oZnJvbnRlbmRSb3V0ZXIpKQogICAg ICwgbV9iYWNrZW5kRGlzcGF0Y2hlcihUYXJnZXRCYWNrZW5kRGlzcGF0Y2hlcjo6Y3JlYXRlKGJh Y2tlbmREaXNwYXRjaGVyLCB0aGlzKSkKIHsKQEAgLTk2LDEwICs5NywxNSBAQCBzdGF0aWMgUHJv dG9jb2w6OlRhcmdldDo6VGFyZ2V0SW5mbzo6VHlwZSB0YXJnZXRUeXBlVG9Qcm90b2NvbFR5cGUo SW5zcGVjdG9yVGFyZwogCiBzdGF0aWMgUmVmPFByb3RvY29sOjpUYXJnZXQ6OlRhcmdldEluZm8+ IGJ1aWxkVGFyZ2V0SW5mb09iamVjdChjb25zdCBJbnNwZWN0b3JUYXJnZXQmIHRhcmdldCkKIHsK LSAgICByZXR1cm4gUHJvdG9jb2w6OlRhcmdldDo6VGFyZ2V0SW5mbzo6Y3JlYXRlKCkKKyAgICBh dXRvIHJlc3VsdCA9IFByb3RvY29sOjpUYXJnZXQ6OlRhcmdldEluZm86OmNyZWF0ZSgpCiAgICAg ICAgIC5zZXRUYXJnZXRJZCh0YXJnZXQuaWRlbnRpZmllcigpKQogICAgICAgICAuc2V0VHlwZSh0 YXJnZXRUeXBlVG9Qcm90b2NvbFR5cGUodGFyZ2V0LnR5cGUoKSkpCiAgICAgICAgIC5yZWxlYXNl KCk7CisgICAgaWYgKHRhcmdldC5pc1Byb3Zpc2lvbmFsKCkpIHsKKyAgICAgICAgcmVzdWx0LT5z ZXRJc1Byb3Zpc2lvbmFsKHRydWUpOworICAgICAgICByZXN1bHQtPnNldFByZXZpb3VzVGFyZ2V0 SWQodGFyZ2V0LnByZXZpb3VzVGFyZ2V0SUQoKSk7CisgICAgfQorICAgIHJldHVybiByZXN1bHQ7 CiB9CiAKIHZvaWQgSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OnRhcmdldENyZWF0ZWQoSW5zcGVjdG9y VGFyZ2V0JiB0YXJnZXQpCkBAIC0xMTAsNyArMTE2LDcgQEAgdm9pZCBJbnNwZWN0b3JUYXJnZXRB Z2VudDo6dGFyZ2V0Q3JlYXRlZChJbnNwZWN0b3JUYXJnZXQmIHRhcmdldCkKICAgICBpZiAoIW1f aXNDb25uZWN0ZWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIHRhcmdldC5jb25uZWN0KGZyb250 ZW5kQ2hhbm5lbCgpKTsKKyAgICB0YXJnZXQuY29ubmVjdChjb25uZWN0aW9uVHlwZSgpKTsKIAog ICAgIG1fZnJvbnRlbmREaXNwYXRjaGVyLT50YXJnZXRDcmVhdGVkKGJ1aWxkVGFyZ2V0SW5mb09i amVjdCh0YXJnZXQpKTsKIH0KQEAgLTEyMiwyNyArMTI4LDM4IEBAIHZvaWQgSW5zcGVjdG9yVGFy Z2V0QWdlbnQ6OnRhcmdldERlc3Ryb3llZChJbnNwZWN0b3JUYXJnZXQmIHRhcmdldCkKICAgICBp ZiAoIW1faXNDb25uZWN0ZWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIHRhcmdldC5kaXNjb25u ZWN0KGZyb250ZW5kQ2hhbm5lbCgpKTsKKyAgICB0YXJnZXQuZGlzY29ubmVjdCgpOwogCiAgICAg bV9mcm9udGVuZERpc3BhdGNoZXItPnRhcmdldERlc3Ryb3llZCh0YXJnZXQuaWRlbnRpZmllcigp KTsKIH0KIAotdm9pZCBJbnNwZWN0b3JUYXJnZXRBZ2VudDo6Y29ubmVjdFRvVGFyZ2V0cygpCit2 b2lkIEluc3BlY3RvclRhcmdldEFnZW50OjpkaWRDb21taXRQcm92aXNpb25hbFRhcmdldChjb25z dCBTdHJpbmcmIG9sZFRhcmdldElELCBjb25zdCBTdHJpbmcmIGNvbW1pdHRlZFRhcmdldElEKQor eworICAgIGlmICghbV9pc0Nvbm5lY3RlZCkKKyAgICAgICAgcmV0dXJuOworICAgIEluc3BlY3Rv clRhcmdldCogdGFyZ2V0ID0gbV90YXJnZXRzLmdldChjb21taXR0ZWRUYXJnZXRJRCk7CisgICAg aWYgKCF0YXJnZXQpCisgICAgICAgIHJldHVybjsKKyAgICBtX2Zyb250ZW5kRGlzcGF0Y2hlci0+ ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQob2xkVGFyZ2V0SUQsIGJ1aWxkVGFyZ2V0SW5mb09i amVjdCgqdGFyZ2V0KSk7Cit9CisKK0Zyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgSW5z cGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3Rpb25UeXBlKCkgY29uc3QKIHsKLSAgICBhdXRvJiBj aGFubmVsID0gZnJvbnRlbmRDaGFubmVsKCk7CisgICAgcmV0dXJuIG1fcm91dGVyLmhhc0xvY2Fs RnJvbnRlbmQoKSA/IEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZTo6 TG9jYWwgOiBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGU6OlJlbW90 ZTsKK30KIAordm9pZCBJbnNwZWN0b3JUYXJnZXRBZ2VudDo6Y29ubmVjdFRvVGFyZ2V0cygpCit7 CiAgICAgZm9yIChJbnNwZWN0b3JUYXJnZXQqIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkg ewotICAgICAgICB0YXJnZXQtPmNvbm5lY3QoY2hhbm5lbCk7CisgICAgICAgIHRhcmdldC0+Y29u bmVjdChjb25uZWN0aW9uVHlwZSgpKTsKICAgICAgICAgbV9mcm9udGVuZERpc3BhdGNoZXItPnRh cmdldENyZWF0ZWQoYnVpbGRUYXJnZXRJbmZvT2JqZWN0KCp0YXJnZXQpKTsKICAgICB9CiB9CiAK IHZvaWQgSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmRpc2Nvbm5lY3RGcm9tVGFyZ2V0cygpCiB7Ci0g ICAgYXV0byYgY2hhbm5lbCA9IGZyb250ZW5kQ2hhbm5lbCgpOwotCiAgICAgZm9yIChJbnNwZWN0 b3JUYXJnZXQqIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkKLSAgICAgICAgdGFyZ2V0LT5k aXNjb25uZWN0KGNoYW5uZWwpOworICAgICAgICB0YXJnZXQtPmRpc2Nvbm5lY3QoKTsKIH0KIAog fSAvLyBuYW1lc3BhY2UgSW5zcGVjdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvaW5zcGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaAppbmRleCAw MGZjM2IwMjE3MzQ0YmU0Y2RmZjc5MTFjMjEzNzE4YzViOTVjZWUzLi5hNDViODMyODliZDU4YTQ2 MTQ4Mjg2M2VkZDUwYTIyNjg1NGIwODgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvaW5zcGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50LmgKQEAg LTI3LDYgKzI3LDcgQEAKIAogI2luY2x1ZGUgIkluc3BlY3RvckFnZW50QmFzZS5oIgogI2luY2x1 ZGUgIkluc3BlY3RvckJhY2tlbmREaXNwYXRjaGVycy5oIgorI2luY2x1ZGUgIkluc3BlY3RvckZy b250ZW5kQ2hhbm5lbC5oIgogI2luY2x1ZGUgIkluc3BlY3RvckZyb250ZW5kRGlzcGF0Y2hlcnMu aCIKICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogCkBAIC00MCw2ICs0MSw3IEBAIGNsYXNzIEpT X0VYUE9SVF9QUklWQVRFIEluc3BlY3RvclRhcmdldEFnZW50IDogcHVibGljIEluc3BlY3RvckFn ZW50QmFzZSwgcHVibGljCiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoSW5zcGVjdG9yVGFyZ2V0 QWdlbnQpOwogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgorICAgIEluc3Bl Y3RvclRhcmdldEFnZW50KEZyb250ZW5kUm91dGVyJiwgQmFja2VuZERpc3BhdGNoZXImKTsKICAg ICB2aXJ0dWFsIH5JbnNwZWN0b3JUYXJnZXRBZ2VudCgpOwogCiAgICAgLy8gSW5zcGVjdG9yQWdl bnRCYXNlCkBAIC01MywxOSArNTUsMTggQEAgcHVibGljOgogICAgIC8vIFRhcmdldCBsaWZlY3lj bGUuCiAgICAgdm9pZCB0YXJnZXRDcmVhdGVkKEluc3BlY3RvclRhcmdldCYpOwogICAgIHZvaWQg dGFyZ2V0RGVzdHJveWVkKEluc3BlY3RvclRhcmdldCYpOworICAgIHZvaWQgZGlkQ29tbWl0UHJv dmlzaW9uYWxUYXJnZXQoY29uc3QgU3RyaW5nJiBvbGRUYXJnZXRJRCwgY29uc3QgU3RyaW5nJiBj b21taXR0ZWRUYXJnZXRJRCk7CiAKICAgICAvLyBUYXJnZXQgbWVzc2FnZXMuCiAgICAgdm9pZCBz ZW5kTWVzc2FnZUZyb21UYXJnZXRUb0Zyb250ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNv bnN0IFN0cmluZyYgbWVzc2FnZSk7CiAKLXByb3RlY3RlZDoKLSAgICBJbnNwZWN0b3JUYXJnZXRB Z2VudChGcm9udGVuZFJvdXRlciYsIEJhY2tlbmREaXNwYXRjaGVyJik7Ci0KLSAgICB2aXJ0dWFs IEZyb250ZW5kQ2hhbm5lbCYgZnJvbnRlbmRDaGFubmVsKCkgPSAwOwotCiBwcml2YXRlOgorICAg IC8vIEZyb250ZW5kQ2hhbm5lbAorICAgIEZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUg Y29ubmVjdGlvblR5cGUoKSBjb25zdDsKICAgICB2b2lkIGNvbm5lY3RUb1RhcmdldHMoKTsKICAg ICB2b2lkIGRpc2Nvbm5lY3RGcm9tVGFyZ2V0cygpOwogCisgICAgSW5zcGVjdG9yOjpGcm9udGVu ZFJvdXRlciYgbV9yb3V0ZXI7CiAgICAgc3RkOjp1bmlxdWVfcHRyPFRhcmdldEZyb250ZW5kRGlz cGF0Y2hlcj4gbV9mcm9udGVuZERpc3BhdGNoZXI7CiAgICAgUmVmPFRhcmdldEJhY2tlbmREaXNw YXRjaGVyPiBtX2JhY2tlbmREaXNwYXRjaGVyOwogICAgIEhhc2hNYXA8U3RyaW5nLCBJbnNwZWN0 b3JUYXJnZXQqPiBtX3RhcmdldHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv aW5zcGVjdG9yL3Byb3RvY29sL1RhcmdldC5qc29uIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2lu c3BlY3Rvci9wcm90b2NvbC9UYXJnZXQuanNvbgppbmRleCA2MWFkMjY5ZDk1ZTE4ZmQ1OWRhNTVj N2MzZWY3ZDVkMTRhZDEzMmRhLi5mMGFmY2MyODE3NWMxMjUwZjA5MTc0ODBkNzI0NjcxYjY1ZmFi NzMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL3Byb3RvY29s L1RhcmdldC5qc29uCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvcHJvdG9j b2wvVGFyZ2V0Lmpzb24KQEAgLTgsNiArOCw4IEBACiAgICAgICAgICAgICAiZGVzY3JpcHRpb24i OiAiRGVzY3JpcHRpb24gb2YgYSB0YXJnZXQuIiwKICAgICAgICAgICAgICJwcm9wZXJ0aWVzIjog WwogICAgICAgICAgICAgICAgIHsgIm5hbWUiOiAidGFyZ2V0SWQiLCAidHlwZSI6ICJzdHJpbmci LCAiZGVzY3JpcHRpb24iOiAiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSB0YXJnZXQuIiB9LAor ICAgICAgICAgICAgICAgIHsgIm5hbWUiOiAiaXNQcm92aXNpb25hbCIsICJ0eXBlIjogImJvb2xl YW4iLCAib3B0aW9uYWwiOiB0cnVlLCAiZGVzY3JpcHRpb24iOiAiV2hldGhlciB0aGlzIGlzIGEg cHJvdmlzaW9uYWwgcGFnZSB0YXJnZXQuIiB9LAorICAgICAgICAgICAgICAgIHsgIm5hbWUiOiAi cHJldmlvdXNUYXJnZXRJZCIsICJ0eXBlIjogInN0cmluZyIsICJvcHRpb25hbCI6IHRydWUgfSwK ICAgICAgICAgICAgICAgICB7ICJuYW1lIjogInR5cGUiLCAidHlwZSI6ICJzdHJpbmciLCAiZW51 bSI6IFsiamF2YXNjcmlwdCIsICJwYWdlIiwgIndvcmtlciIsICJzZXJ2aWNld29ya2VyIl0gfQog ICAgICAgICAgICAgXQogICAgICAgICB9CkBAIC0zOSw2ICs0MSwxMyBAQAogICAgICAgICAgICAg ICAgIHsgIm5hbWUiOiAidGFyZ2V0SWQiLCAidHlwZSI6ICJzdHJpbmciIH0KICAgICAgICAgICAg IF0KICAgICAgICAgfSwKKyAgICAgICAgeworICAgICAgICAgICAgIm5hbWUiOiAiZGlkQ29tbWl0 UHJvdmlzaW9uYWxUYXJnZXQiLAorICAgICAgICAgICAgInBhcmFtZXRlcnMiOiBbCisgICAgICAg ICAgICAgICAgeyAibmFtZSI6ICJvbGRUYXJnZXRJZCIsICJ0eXBlIjogInN0cmluZyIsICJkZXNj cmlwdGlvbiI6ICJJRCBvZiB0aGUgcHJldmlvdXMgdGFyZ2V0IHRoYXQgaXMgc3dhcHBlZCB3aXRo IHRoZSBjb21taXR0ZWQgb25lLiIgfSwKKyAgICAgICAgICAgICAgICB7ICJuYW1lIjogInRhcmdl dEluZm8iLCAiJHJlZiI6ICJUYXJnZXRJbmZvIiwgImRlc2NyaXB0aW9uIjogIkNvbW1pdHRlZCB0 YXJnZXQgaW5mby4iIH0KKyAgICAgICAgICAgIF0KKyAgICAgICAgfSwKICAgICAgICAgewogICAg ICAgICAgICAgIm5hbWUiOiAiZGlzcGF0Y2hNZXNzYWdlRnJvbVRhcmdldCIsCiAgICAgICAgICAg ICAicGFyYW1ldGVycyI6IFsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9J bnNwZWN0b3JDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9JbnNwZWN0 b3JDb250cm9sbGVyLmNwcAppbmRleCBlNjE4MDVmMzZkNWY3M2E1MDc0NDk1ZDllYWY2ODE4OWQ2 YTkzMDcwLi4yYjUxZjQzODY3OGNlNDg0MGVjMGZjZDk4MGU0YzNmZjBhOTM2MmZmIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yQ29udHJvbGxlci5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL0luc3BlY3RvckNvbnRyb2xsZXIuY3BwCkBAIC0z NDUsMTMgKzM0NSw3IEBAIHZvaWQgSW5zcGVjdG9yQ29udHJvbGxlcjo6c2hvdygpCiAKIHZvaWQg SW5zcGVjdG9yQ29udHJvbGxlcjo6c2V0SXNVbmRlclRlc3QoYm9vbCB2YWx1ZSkKIHsKLSAgICBp ZiAodmFsdWUgPT0gbV9pc1VuZGVyVGVzdCkKLSAgICAgICAgcmV0dXJuOwotCiAgICAgbV9pc1Vu ZGVyVGVzdCA9IHZhbHVlOwotCi0gICAgLy8gPHJkYXI6Ly9wcm9ibGVtLzI2NzY4NjI4PiBUcnkg dG8gY2F0Y2ggc3VzcGljaW91cyBzY2VuYXJpb3Mgd2hlcmUgd2UgbWF5IGhhdmUgYSBkYW5nbGlu ZyBmcm9udGVuZCB3aGlsZSBydW5uaW5nIHRlc3RzLgotICAgIFJFTEVBU0VfQVNTRVJUKCFtX2lz VW5kZXJUZXN0IHx8ICFtX2Zyb250ZW5kUm91dGVyLT5oYXNGcm9udGVuZHMoKSk7CiB9CiAKIHZv aWQgSW5zcGVjdG9yQ29udHJvbGxlcjo6ZXZhbHVhdGVGb3JUZXN0SW5Gcm9udGVuZChjb25zdCBT dHJpbmcmIHNjcmlwdCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL0NvbnRyb2xsZXJzL1RhcmdldE1hbmFnZXIuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvVXNlckludGVyZmFjZS9Db250cm9sbGVycy9UYXJnZXRNYW5hZ2VyLmpzCmluZGV4IGE5ZmE0 ZGUwZTgzYTZiNjcxNzM0YjhhZTZhMzBjODhkMzVhYzdiMTguLmRjMThlN2Y4Y2RkYjE4YmFkM2Y3 ODU1MjQxZTkzMDhiN2Q2YTU2YTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9V c2VySW50ZXJmYWNlL0NvbnRyb2xsZXJzL1RhcmdldE1hbmFnZXIuanMKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJvbGxlcnMvVGFyZ2V0TWFuYWdlci5qcwpA QCAtODAsNiArODAsNyBAQCBXSS5UYXJnZXRNYW5hZ2VyID0gY2xhc3MgVGFyZ2V0TWFuYWdlciBl eHRlbmRzIFdJLk9iamVjdAogCiAgICAgICAgIHRoaXMuX2NhY2hlZFRhcmdldHNMaXN0ID0gbnVs bDsKICAgICAgICAgdGhpcy5fdGFyZ2V0cy5kZWxldGUodGFyZ2V0LmlkZW50aWZpZXIpOworICAg ICAgICB0YXJnZXQuZGVzdHJveSgpOwogCiAgICAgICAgIHRoaXMuZGlzcGF0Y2hFdmVudFRvTGlz dGVuZXJzKFdJLlRhcmdldE1hbmFnZXIuRXZlbnQuVGFyZ2V0UmVtb3ZlZCwge3RhcmdldH0pOwog ICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1By b3RvY29sL0Nvbm5lY3Rpb24uanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFj ZS9Qcm90b2NvbC9Db25uZWN0aW9uLmpzCmluZGV4IGIyNzM3ODdmM2IzNTk5NTcxZDBjMGU5ODIw MzExZWQ1NDkzNmIzZjYuLjRkZDIyOWMwMTRkOTI4N2IzYzczNWIwNGRhMGM1YjQ4NzczODQzNzcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Byb3RvY29s L0Nvbm5lY3Rpb24uanMKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv UHJvdG9jb2wvQ29ubmVjdGlvbi5qcwpAQCAtMzA5LDcgKzMwOSwxMSBAQCBJbnNwZWN0b3JCYWNr ZW5kLldvcmtlckNvbm5lY3Rpb24gPSBjbGFzcyBJbnNwZWN0b3JCYWNrZW5kV29ya2VyQ29ubmVj dGlvbiBleHRlbgogICAgIHNlbmRNZXNzYWdlVG9CYWNrZW5kKG1lc3NhZ2UpCiAgICAgewogICAg ICAgICAvLyBJZ25vcmUgZXJyb3JzIGlmIGEgd29ya2VyIHdlbnQgYXdheSBxdWlja2x5LgotICAg ICAgICBXb3JrZXJBZ2VudC5zZW5kTWVzc2FnZVRvV29ya2VyKHRoaXMuX3dvcmtlcklkLCBtZXNz YWdlKS5jYXRjaChmdW5jdGlvbigpe30pOworICAgICAgICBXb3JrZXJBZ2VudC5zZW5kTWVzc2Fn ZVRvV29ya2VyKHRoaXMuX3dvcmtlcklkLCBtZXNzYWdlKS5jYXRjaChlID0+IHsKKyAgICAgICAg ICAgIGlmICh0aGlzLnRhcmdldC5pc0Rlc3Ryb3llZCgpKQorICAgICAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgICAgIHRocm93IGU7CisgICAgICAgIH0pOwogICAgIH0KIH07CiAKQEAgLTMz Miw3ICszMzYsMTMgQEAgSW5zcGVjdG9yQmFja2VuZC5UYXJnZXRDb25uZWN0aW9uID0gY2xhc3Mg SW5zcGVjdG9yQmFja2VuZFRhcmdldENvbm5lY3Rpb24gZXh0ZW4KIAogICAgIHNlbmRNZXNzYWdl VG9CYWNrZW5kKG1lc3NhZ2UpCiAgICAgewotICAgICAgICBUYXJnZXRBZ2VudC5zZW5kTWVzc2Fn ZVRvVGFyZ2V0KHRoaXMuX3RhcmdldElkLCBtZXNzYWdlKTsKKyAgICAgICAgVGFyZ2V0QWdlbnQu c2VuZE1lc3NhZ2VUb1RhcmdldCh0aGlzLl90YXJnZXRJZCwgbWVzc2FnZSkuY2F0Y2goZSA9PiB7 CisgICAgICAgICAgICAvLyBDb21tYW5kIG1heSBiZSBzZW50IGFmdGVyIHRhcmdldCBpcyBhbHJl YWR5IGRlc3Ryb3llZCBvbiBiYWNrZW5kLAorICAgICAgICAgICAgLy8gaWdub3JlIHN1Y2ggZXJy b3JzLgorICAgICAgICAgICAgaWYgKHRoaXMudGFyZ2V0LmlzRGVzdHJveWVkKCkpCisgICAgICAg ICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgdGhyb3cgZTsKKyAgICAgICAgfSk7CiAgICAg fQogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv UHJvdG9jb2wvVGFyZ2V0LmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv UHJvdG9jb2wvVGFyZ2V0LmpzCmluZGV4IDIwMzM0MTBhNmI1MzM1OGViN2NhOTI1MTMxNzVkMzEy YWFkMWE0NDguLmE5MzgyMGMwOTYzY2NhZTRmZDdiOGE4YmE3NzY0OGJjYzJiYzBiMWEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Byb3RvY29sL1Rhcmdl dC5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Qcm90b2NvbC9U YXJnZXQuanMKQEAgLTIwMCw2ICsyMDAsMTYgQEAgV0kuVGFyZ2V0ID0gY2xhc3MgVGFyZ2V0IGV4 dGVuZHMgV0kuT2JqZWN0CiAgICAgICAgIHRoaXMuZGlzcGF0Y2hFdmVudFRvTGlzdGVuZXJzKFdJ LlRhcmdldC5FdmVudC5TY3JpcHRBZGRlZCwge3NjcmlwdH0pOwogICAgIH0KIAorICAgIGRlc3Ry b3koKQorICAgIHsKKyAgICAgICAgdGhpcy5faXNEZXN0cm95ZWQgPSB0cnVlOworICAgIH0KKwor ICAgIGlzRGVzdHJveWVkKCkKKyAgICB7CisgICAgICAgIHJldHVybiB0aGlzLl9pc0Rlc3Ryb3ll ZDsKKyAgICB9CisKICAgICAvLyBQcml2YXRlCiAKICAgICBfc3VwcG9ydGVkRG9tYWluc0ZvclRh cmdldFR5cGUodHlwZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJ L1VzZXJJbnRlcmZhY2UvUHJvdG9jb2wvVGFyZ2V0T2JzZXJ2ZXIuanMKaW5kZXggMzFiNmZjZmMx ODY5ZWQxMzg3ODFlMTA3MWRkMTliNTQ3YzA5Y2JmNC4uNmVmNDMyMGZiOTM5Nzc3OTExZGEyYWVm MjZlMDQyMWYzMjc2ZTNmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvUHJvdG9jb2wvVGFyZ2V0T2JzZXJ2ZXIuanMKKysrIGIvU291cmNlL1dlYkluc3Bl Y3RvclVJL1VzZXJJbnRlcmZhY2UvUHJvdG9jb2wvVGFyZ2V0T2JzZXJ2ZXIuanMKQEAgLTI2LDE5 ICsyNiw0MiBAQAogV0kuVGFyZ2V0T2JzZXJ2ZXIgPSBjbGFzcyBUYXJnZXRPYnNlcnZlcgogewog ICAgIC8vIEV2ZW50cyBkZWZpbmVkIGJ5IHRoZSAiVGFyZ2V0IiBkb21haW4uCisgICAgY29uc3Ry dWN0b3IoKQorICAgIHsKKyAgICAgICAgdGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMgPSBuZXcg U2V0OworICAgICAgICB0aGlzLl9zd2FwcGVkVGFyZ2V0SWRzID0gbmV3IFNldDsKKyAgICB9CiAK ICAgICB0YXJnZXRDcmVhdGVkKHRhcmdldEluZm8pCiAgICAgeworICAgICAgICBpZiAodGFyZ2V0 SW5mby5pc1Byb3Zpc2lvbmFsKSB7CisgICAgICAgICAgICB0aGlzLl9wcm92aXNpb25hbFRhcmdl dElkcy5hZGQodGFyZ2V0SW5mby50YXJnZXRJZCk7CisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIH0KKyAgICAgICAgV0kudGFyZ2V0TWFuYWdlci50YXJnZXRDcmVhdGVkKHRhcmdldEluZm8p OworICAgIH0KKworICAgIGRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KHByZXZpb3VzVGFyZ2V0 SWQsIHRhcmdldEluZm8pCisgICAgeworICAgICAgICBXSS50YXJnZXRNYW5hZ2VyLnRhcmdldERl c3Ryb3llZChwcmV2aW91c1RhcmdldElkKTsKICAgICAgICAgV0kudGFyZ2V0TWFuYWdlci50YXJn ZXRDcmVhdGVkKHRhcmdldEluZm8pOworICAgICAgICB0aGlzLl9zd2FwcGVkVGFyZ2V0SWRzLmFk ZChwcmV2aW91c1RhcmdldElkKTsKKyAgICAgICAgdGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMu ZGVsZXRlKHRhcmdldEluZm8udGFyZ2V0SWQpOwogICAgIH0KIAogICAgIHRhcmdldERlc3Ryb3ll ZCh0YXJnZXRJZCkKICAgICB7CisgICAgICAgIGlmICh0aGlzLl9wcm92aXNpb25hbFRhcmdldElk cy5kZWxldGUodGFyZ2V0SWQpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBpZiAodGhp cy5fc3dhcHBlZFRhcmdldElkcy5kZWxldGUodGFyZ2V0SWQpKQorICAgICAgICAgICAgcmV0dXJu OwogICAgICAgICBXSS50YXJnZXRNYW5hZ2VyLnRhcmdldERlc3Ryb3llZCh0YXJnZXRJZCk7CiAg ICAgfQogCiAgICAgZGlzcGF0Y2hNZXNzYWdlRnJvbVRhcmdldCh0YXJnZXRJZCwgbWVzc2FnZSkK ICAgICB7CisgICAgICAgIGlmICh0aGlzLl9wcm92aXNpb25hbFRhcmdldElkcy5oYXModGFyZ2V0 SWQpKQorICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICBXSS50YXJnZXRNYW5hZ2VyLmRpc3Bh dGNoTWVzc2FnZUZyb21UYXJnZXQodGFyZ2V0SWQsIG1lc3NhZ2UpOwogICAgIH0KIH07CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9UZXN0L1Rlc3QuanMg Yi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9UZXN0L1Rlc3QuanMKaW5kZXgg NzU3MDhhMDBjOTU4MTcyN2VlMGY0YzM4NTM0M2E0ZjI0NGIyM2QzNS4uY2QyZjA1YzNlNWE5NmYz YzUzMTRlNTNlZDJhNGEwNjcwYjk0MGY4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3Rv clVJL1VzZXJJbnRlcmZhY2UvVGVzdC9UZXN0LmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JV SS9Vc2VySW50ZXJmYWNlL1Rlc3QvVGVzdC5qcwpAQCAtMTA2LDEyICsxMDYsMzcgQEAgV0kuaW5p dGlhbGl6ZVBhZ2VUYXJnZXQgPSBmdW5jdGlvbih0YXJnZXQpCiAKIFdJLnRyYW5zaXRpb25QYWdl VGFyZ2V0ID0gZnVuY3Rpb24odGFyZ2V0KQogewotICAgIGNvbnNvbGUuZXJyb3IoIldJLnRyYW5z aXRpb25QYWdlVGFyZ2V0IHNob3VsZCBub3QgYmUgcmVhY2hlZCBpbiB0ZXN0cy4iKTsKKyAgICBj b25zb2xlLmFzc2VydCghV0kucGFnZVRhcmdldCk7CisgICAgY29uc29sZS5hc3NlcnQoV0kuc2hh cmVkQXBwLmRlYnVnZ2FibGVUeXBlID09PSBXSS5EZWJ1Z2dhYmxlVHlwZS5XZWIpOworICAgIGNv bnNvbGUuYXNzZXJ0KHRhcmdldC50eXBlID09PSBXSS5UYXJnZXQuVHlwZS5QYWdlKTsKKworICAg IFdJLnBhZ2VUYXJnZXQgPSB0YXJnZXQ7CisKKyAgICBXSS5yZWRpcmVjdEdsb2JhbEFnZW50c1Rv Q29ubmVjdGlvbihXSS5wYWdlVGFyZ2V0LmNvbm5lY3Rpb24pOworCisgICAgV0kucmVzZXRNYWlu RXhlY3V0aW9uQ29udGV4dCgpOworCisgICAgLy8gQWN0aW9ucyB0byB0cmFuc2l0aW9uIHRoZSBw YWdlIHRhcmdldC4KKyAgICBXSS5ub3RpZmljYXRpb25zLmRpc3BhdGNoRXZlbnRUb0xpc3RlbmVy cyhXSS5Ob3RpZmljYXRpb24uVHJhbnNpdGlvblBhZ2VUYXJnZXQpOworICAgIFdJLmRvbU1hbmFn ZXIudHJhbnNpdGlvblBhZ2VUYXJnZXQoKTsKKyAgICBXSS5uZXR3b3JrTWFuYWdlci50cmFuc2l0 aW9uUGFnZVRhcmdldCgpOworICAgIFdJLnRpbWVsaW5lTWFuYWdlci50cmFuc2l0aW9uUGFnZVRh cmdldCgpOwogfTsKIAogV0kudGVybWluYXRlUGFnZVRhcmdldCA9IGZ1bmN0aW9uKHRhcmdldCkK IHsKLSAgICBjb25zb2xlLmVycm9yKCJXSS50ZXJtaW5hdGVQYWdlVGFyZ2V0IHNob3VsZCBub3Qg YmUgcmVhY2hlZCBpbiB0ZXN0cy4iKTsKKyAgICBjb25zb2xlLmFzc2VydChXSS5wYWdlVGFyZ2V0 KTsKKyAgICBjb25zb2xlLmFzc2VydChXSS5wYWdlVGFyZ2V0ID09PSB0YXJnZXQpOworICAgIGNv bnNvbGUuYXNzZXJ0KFdJLnNoYXJlZEFwcC5kZWJ1Z2dhYmxlVHlwZSA9PT0gV0kuRGVidWdnYWJs ZVR5cGUuV2ViKTsKKworICAgIC8vIFJlbW92ZSBhbnkgV29ya2VyIHRhcmdldHMgYXNzb2NpYXRl ZCB3aXRoIHRoaXMgcGFnZS4KKyAgICBsZXQgd29ya2VyVGFyZ2V0cyA9IFdJLnRhcmdldHMuZmls dGVyKCh4KSA9PiB4LnR5cGUgPT09IFdJLlRhcmdldC5UeXBlLldvcmtlcik7CisgICAgZm9yIChs ZXQgd29ya2VyVGFyZ2V0IG9mIHdvcmtlclRhcmdldHMpCisgICAgICAgIFdJLndvcmtlck1hbmFn ZXIud29ya2VyVGVybWluYXRlZCh3b3JrZXJUYXJnZXQuaWRlbnRpZmllcik7CisKKyAgICBXSS5w YWdlVGFyZ2V0ID0gbnVsbDsKKworICAgIFdJLnJlZGlyZWN0R2xvYmFsQWdlbnRzVG9Db25uZWN0 aW9uKFdJLmJhY2tlbmRDb25uZWN0aW9uKTsKIH07CiAKIFdJLnJlc2V0TWFpbkV4ZWN1dGlvbkNv bnRleHQgPSBmdW5jdGlvbigpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NvdXJjZXMudHh0 IGIvU291cmNlL1dlYktpdC9Tb3VyY2VzLnR4dAppbmRleCBmYTUyNjFmNTRjNTUxMDY0YTRiNzIw ZGNiMzk4ZjJiNTE3MjI5YjlkLi5jZDZmYTE3MTZiYWQ0NzJlZDViZTM1NzY1ODg1YzU1YjYxNzU2 OTMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NvdXJjZXMudHh0CisrKyBiL1NvdXJjZS9X ZWJLaXQvU291cmNlcy50eHQKQEAgLTI4OCw3ICsyODgsNiBAQCBVSVByb2Nlc3MvV2ViUGFnZURp YWdub3N0aWNMb2dnaW5nQ2xpZW50LmNwcAogVUlQcm9jZXNzL1dlYlBhZ2VHcm91cC5jcHAKIFVJ UHJvY2Vzcy9XZWJQYWdlSW5qZWN0ZWRCdW5kbGVDbGllbnQuY3BwCiBVSVByb2Nlc3MvV2ViUGFn ZUluc3BlY3RvckNvbnRyb2xsZXIuY3BwCi1VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRhcmdl dEFnZW50LmNwcAogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKIFVJUHJvY2Vzcy9XZWJQYXN0 ZWJvYXJkUHJveHkuY3BwCiBVSVByb2Nlc3MvV2ViUHJlZmVyZW5jZXMuY3BwCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNwZWN0b3JUYXJnZXRQcm94eS5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNwZWN0b3JUYXJnZXRQcm94eS5jcHAKaW5kZXggNjFiOGYz NmVmYTc1MWYxYzg4ZDkyYmExYWRjZDE1ZWNhNjE0NTgyMi4uZGI4ZTI2ZjI5N2ViZDJlYzMyYjZj YmFmOGRjZmZiOGI3OGQzOGRhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv SW5zcGVjdG9yVGFyZ2V0UHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0lu c3BlY3RvclRhcmdldFByb3h5LmNwcApAQCAtMjYsNyArMjYsOSBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIkluc3BlY3RvclRhcmdldFByb3h5LmgiCiAKKyNpbmNsdWRlICJQcm92 aXNpb25hbFBhZ2VQcm94eS5oIgogI2luY2x1ZGUgIldlYkZyYW1lUHJveHkuaCIKKyNpbmNsdWRl ICJXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmgiCiAjaW5jbHVkZSAiV2ViUGFnZU1lc3NhZ2VzLmgi CiAjaW5jbHVkZSAiV2ViUGFnZVByb3h5LmgiCiAjaW5jbHVkZSAiV2ViUHJvY2Vzc1Byb3h5Lmgi CkBAIC0zNSw5ICszNywxNiBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogdXNpbmcgbmFtZXNwYWNl IEluc3BlY3RvcjsKIAotUmVmPEluc3BlY3RvclRhcmdldFByb3h5PiBJbnNwZWN0b3JUYXJnZXRQ cm94eTo6Y3JlYXRlKFdlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwg SW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUpCitzdGQ6OnVuaXF1ZV9wdHI8SW5z cGVjdG9yVGFyZ2V0UHJveHk+IEluc3BlY3RvclRhcmdldFByb3h5OjpjcmVhdGUoV2ViUGFnZVBy b3h5JiBwYWdlLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRh cmdldFR5cGUgdHlwZSkKIHsKLSAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBJbnNwZWN0b3JUYXJn ZXRQcm94eShwYWdlLCB0YXJnZXRJZCwgdHlwZSkpOworICAgIHJldHVybiBtYWtlVW5pcXVlPElu c3BlY3RvclRhcmdldFByb3h5PihwYWdlLCB0YXJnZXRJZCwgdHlwZSk7Cit9CisKK3N0ZDo6dW5p cXVlX3B0cjxJbnNwZWN0b3JUYXJnZXRQcm94eT4gSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0 ZShQcm92aXNpb25hbFBhZ2VQcm94eSYgcHJvdmlzaW9uYWxQYWdlLCBjb25zdCBTdHJpbmcmIHRh cmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUgdHlwZSkKK3sKKyAgICBhdXRv IHRhcmdldCA9IGNyZWF0ZShwcm92aXNpb25hbFBhZ2UucGFnZSgpLCB0YXJnZXRJZCwgdHlwZSk7 CisgICAgdGFyZ2V0LT5tX3Byb3Zpc2lvbmFsUGFnZSA9ICZwcm92aXNpb25hbFBhZ2U7CisgICAg cmV0dXJuIHRhcmdldDsKIH0KIAogSW5zcGVjdG9yVGFyZ2V0UHJveHk6Okluc3BlY3RvclRhcmdl dFByb3h5KFdlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUpCkBAIC00NywyMiArNTYsNTIgQEAgSW5zcGVj dG9yVGFyZ2V0UHJveHk6Okluc3BlY3RvclRhcmdldFByb3h5KFdlYlBhZ2VQcm94eSYgcGFnZSwg Y29uc3QgU3RyaW5nJiB0YXIKIHsKIH0KIAotdm9pZCBJbnNwZWN0b3JUYXJnZXRQcm94eTo6Y29u bmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYgY2hhbm5lbCkKK3ZvaWQgSW5zcGVjdG9y VGFyZ2V0UHJveHk6OmNvbm5lY3QoSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rp b25UeXBlIGNvbm5lY3Rpb25UeXBlKQogeworICAgIGlmIChtX3Byb3Zpc2lvbmFsUGFnZSkgewor ICAgICAgICBtX3Byb3Zpc2lvbmFsUGFnZS0+cHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6OldlYlBh Z2U6OkNvbm5lY3RJbnNwZWN0b3IoaWRlbnRpZmllcigpLCBjb25uZWN0aW9uVHlwZSksIG1fcHJv dmlzaW9uYWxQYWdlLT53ZWJQYWdlSUQoKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CiAgICAg aWYgKG1fcGFnZS5oYXNSdW5uaW5nUHJvY2VzcygpKQotICAgICAgICBtX3BhZ2UucHJvY2Vzcygp LnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OkNvbm5lY3RJbnNwZWN0b3IoaWRlbnRpZmllcigpLCBj aGFubmVsLmNvbm5lY3Rpb25UeXBlKCkpLCBtX3BhZ2Uud2ViUGFnZUlEKCkpOworICAgICAgICBt X3BhZ2UucHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OkNvbm5lY3RJbnNwZWN0b3Io aWRlbnRpZmllcigpLCBjb25uZWN0aW9uVHlwZSksIG1fcGFnZS53ZWJQYWdlSUQoKSk7CiB9CiAK LXZvaWQgSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmRpc2Nvbm5lY3QoSW5zcGVjdG9yOjpGcm9udGVu ZENoYW5uZWwmKQordm9pZCBJbnNwZWN0b3JUYXJnZXRQcm94eTo6ZGlzY29ubmVjdCgpCiB7Cisg ICAgaWYgKG1fcHJvdmlzaW9uYWxQYWdlKSB7CisgICAgICAgIG1fcHJvdmlzaW9uYWxQYWdlLT5w cm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6RGlzY29ubmVjdEluc3BlY3RvcihpZGVu dGlmaWVyKCkpLCBtX3Byb3Zpc2lvbmFsUGFnZS0+d2ViUGFnZUlEKCkpOworICAgICAgICByZXR1 cm47CisgICAgfQogICAgIGlmIChtX3BhZ2UuaGFzUnVubmluZ1Byb2Nlc3MoKSkKICAgICAgICAg bV9wYWdlLnByb2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpEaXNjb25uZWN0SW5zcGVj dG9yKGlkZW50aWZpZXIoKSksIG1fcGFnZS53ZWJQYWdlSUQoKSk7CiB9CiAKIHZvaWQgSW5zcGVj dG9yVGFyZ2V0UHJveHk6OnNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYg bWVzc2FnZSkKIHsKKyAgICBpZiAobV9wcm92aXNpb25hbFBhZ2UpIHsKKyAgICAgICAgbV9wcm92 aXNpb25hbFBhZ2UtPnByb2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpTZW5kTWVzc2Fn ZVRvVGFyZ2V0QmFja2VuZChpZGVudGlmaWVyKCksIG1lc3NhZ2UpLCBtX3Byb3Zpc2lvbmFsUGFn ZS0+d2ViUGFnZUlEKCkpOworICAgICAgICByZXR1cm47CisgICAgfQogICAgIGlmIChtX3BhZ2Uu aGFzUnVubmluZ1Byb2Nlc3MoKSkKICAgICAgICAgbV9wYWdlLnByb2Nlc3MoKS5zZW5kKE1lc3Nh Z2VzOjpXZWJQYWdlOjpTZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChpZGVudGlmaWVyKCksIG1l c3NhZ2UpLCBtX3BhZ2Uud2ViUGFnZUlEKCkpOwogfQogCit2b2lkIEluc3BlY3RvclRhcmdldFBy b3h5OjpkaWRDb21taXRQcm92aXNpb25hbFRhcmdldCgpCit7CisgICAgQVNTRVJUKGlzUHJvdmlz aW9uYWwoKSk7CisgICAgbV9wcm92aXNpb25hbFBhZ2UgPSBudWxscHRyOworfQorCitib29sIElu c3BlY3RvclRhcmdldFByb3h5Ojppc1Byb3Zpc2lvbmFsKCkgY29uc3QKK3sKKyAgICByZXR1cm4g bV9wcm92aXNpb25hbFBhZ2U7Cit9CisKK1N0cmluZyBJbnNwZWN0b3JUYXJnZXRQcm94eTo6cHJl dmlvdXNUYXJnZXRJRCgpIGNvbnN0Cit7CisgICAgaWYgKG1fdHlwZSAhPSBJbnNwZWN0b3I6Oklu c3BlY3RvclRhcmdldFR5cGU6OlBhZ2UgfHwgIWlzUHJvdmlzaW9uYWwoKSkKKyAgICAgICAgcmV0 dXJuIFN0cmluZygpOworICAgIHJldHVybiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1Rhcmdl dElEKG1fcGFnZS53ZWJQYWdlSUQoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0UHJveHkuaCBi L1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmgKaW5kZXggZDM4 MmIwMjY1MDljODM5NTE5OWFiZGQ0OTVhZjZhMmE1MWFmOTI3Yy4uMGNjZmVkNDI2MjQwMjFiYjhh MGUzNWM4YjJmZWYzZTFkMTg1ODJkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvSW5zcGVjdG9yVGFyZ2V0UHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9J bnNwZWN0b3JUYXJnZXRQcm94eS5oCkBAIC0zNSwyNSArMzUsMzEgQEAgY2xhc3MgV2ViUGFnZVBy b3h5OwogLy8gTk9URTogVGhpcyBVSVByb2Nlc3Mgc2lkZSBJbnNwZWN0b3JUYXJnZXQgZG9lc24n dCBjYXJlIGFib3V0IHRoZSBmcm9udGVuZCBjaGFubmVsLCBzaW5jZQogLy8gYW55IHRhcmdldCAt PiBmcm9udGVuZCBtZXNzYWdlcyB3aWxsIGJlIHJvdXRlZCB0byB0aGUgV2ViUGFnZVByb3h5IHdp dGggYSB0YXJnZXRJZC4KIAotY2xhc3MgSW5zcGVjdG9yVGFyZ2V0UHJveHkgZmluYWwgOiBwdWJs aWMgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXQsIHB1YmxpYyBSZWZDb3VudGVkPEluc3BlY3Rv clRhcmdldFByb3h5PiB7CitjbGFzcyBJbnNwZWN0b3JUYXJnZXRQcm94eSBmaW5hbCA6IHB1Ymxp YyBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldCB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FU RUQ7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoSW5zcGVjdG9yVGFyZ2V0UHJveHkpOwogcHVi bGljOgotICAgIHN0YXRpYyBSZWY8SW5zcGVjdG9yVGFyZ2V0UHJveHk+IGNyZWF0ZShXZWJQYWdl UHJveHkmLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdl dFR5cGUpOworICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8SW5zcGVjdG9yVGFyZ2V0UHJveHk+ IGNyZWF0ZShXZWJQYWdlUHJveHkmLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6 Okluc3BlY3RvclRhcmdldFR5cGUpOworICAgIHN0YXRpYyBzdGQ6OnVuaXF1ZV9wdHI8SW5zcGVj dG9yVGFyZ2V0UHJveHk+IGNyZWF0ZShQcm92aXNpb25hbFBhZ2VQcm94eSYsIGNvbnN0IFN0cmlu ZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZSk7CiAgICAgSW5zcGVj dG9yVGFyZ2V0UHJveHkoV2ViUGFnZVByb3h5JiwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5z cGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlKTsKICAgICB+SW5zcGVjdG9yVGFyZ2V0UHJveHko KSA9IGRlZmF1bHQ7CiAKICAgICBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUgdHlwZSgp IGNvbnN0IGZpbmFsIHsgcmV0dXJuIG1fdHlwZTsgfQogICAgIFN0cmluZyBpZGVudGlmaWVyKCkg Y29uc3QgZmluYWwgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9CiAKLSAgICB2b2lkIGNvbm5lY3Qo SW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWwmKTsKLSAgICB2b2lkIGRpc2Nvbm5lY3QoSW5zcGVj dG9yOjpGcm9udGVuZENoYW5uZWwmKTsKLSAgICB2b2lkIHNlbmRNZXNzYWdlVG9UYXJnZXRCYWNr ZW5kKGNvbnN0IFN0cmluZyYpOworICAgIHZvaWQgZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQo KTsKKyAgICBib29sIGlzUHJvdmlzaW9uYWwoKSBjb25zdCBvdmVycmlkZTsKKyAgICBTdHJpbmcg cHJldmlvdXNUYXJnZXRJRCgpIGNvbnN0IG92ZXJyaWRlOworCisgICAgdm9pZCBjb25uZWN0KElu c3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSkgb3ZlcnJpZGU7CisgICAg dm9pZCBkaXNjb25uZWN0KCkgb3ZlcnJpZGU7CisgICAgdm9pZCBzZW5kTWVzc2FnZVRvVGFyZ2V0 QmFja2VuZChjb25zdCBTdHJpbmcmKSBvdmVycmlkZTsKIAogcHJpdmF0ZToKICAgICBXZWJQYWdl UHJveHkmIG1fcGFnZTsKICAgICBTdHJpbmcgbV9pZGVudGlmaWVyOwogICAgIEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0VHlwZSBtX3R5cGU7CisgICAgUHJvdmlzaW9uYWxQYWdlUHJveHkqIG1f cHJvdmlzaW9uYWxQYWdlID0gbnVsbHB0cjsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHku Y3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuY3BwCmlu ZGV4IGEyYTA5ZGM0OTI1ZGY0MmU1NDg0NDUwYmVmNDc5NzhjMDM5N2Y5ZTUuLjhlNjAyNjIwMzFk NzAzZjAzODJjM2I2NmY1YjBjNTNhMjhkOGEzNWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv VUlQcm9jZXNzL1Byb3Zpc2lvbmFsUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNs dWRlICJXZWJFcnJvcnMuaCIKICNpbmNsdWRlICJXZWJOYXZpZ2F0aW9uRGF0YVN0b3JlLmgiCiAj aW5jbHVkZSAiV2ViTmF2aWdhdGlvblN0YXRlLmgiCisjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3Rv ckNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbmNsdWRlICJX ZWJQYWdlUHJveHkuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHlNZXNzYWdlcy5oIgpAQCAtODQs MTIgKzg1LDE2IEBAIFByb3Zpc2lvbmFsUGFnZVByb3h5OjpQcm92aXNpb25hbFBhZ2VQcm94eShX ZWJQYWdlUHJveHkmIHBhZ2UsIFJlZjxXZWJQcm9jZXNzUHJvCiAgICAgfQogCiAgICAgaW5pdGlh bGl6ZVdlYlBhZ2UoKTsKKworICAgIG1fcGFnZS5pbnNwZWN0b3JDb250cm9sbGVyKCkuZGlkQ3Jl YXRlUHJvdmlzaW9uYWxQYWdlKCp0aGlzKTsKIH0KIAogUHJvdmlzaW9uYWxQYWdlUHJveHk6On5Q cm92aXNpb25hbFBhZ2VQcm94eSgpCiB7CiAgICAgbV9wcm9jZXNzLT5yZW1vdmVQcm92aXNpb25h bFBhZ2VQcm94eSgqdGhpcyk7CiAKKyAgICBtX3BhZ2UuaW5zcGVjdG9yQ29udHJvbGxlcigpLmRp ZERlc3Ryb3lQcm92aXNpb25hbFBhZ2UoKnRoaXMsIG1fd2FzQ29tbWl0dGVkKTsKKwogICAgIGlm IChtX3dhc0NvbW1pdHRlZCkKICAgICAgICAgcmV0dXJuOwogCkBAIC0zOTEsNiArMzk2LDkgQEAg dm9pZCBQcm92aXNpb25hbFBhZ2VQcm94eTo6ZGlkUmVjZWl2ZU1lc3NhZ2UoSVBDOjpDb25uZWN0 aW9uJiBjb25uZWN0aW9uLCBJUEM6OkQKICAgICAgICAgfHwgZGVjb2Rlci5tZXNzYWdlTmFtZSgp ID09IE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkRpZFN0YXJ0TG9hZEZvclF1aWNrTG9va0RvY3Vt ZW50SW5NYWluRnJhbWU6Om5hbWUoKQogICAgICAgICB8fCBkZWNvZGVyLm1lc3NhZ2VOYW1lKCkg PT0gTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGlkRmluaXNoTG9hZEZvclF1aWNrTG9va0RvY3Vt ZW50SW5NYWluRnJhbWU6Om5hbWUoKQogI2VuZGlmCisgICAgICAgIHx8IGRlY29kZXIubWVzc2Fn ZU5hbWUoKSA9PSBNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpDcmVhdGVJbnNwZWN0b3JUYXJnZXQ6 Om5hbWUoKQorICAgICAgICB8fCBkZWNvZGVyLm1lc3NhZ2VOYW1lKCkgPT0gTWVzc2FnZXM6Oldl YlBhZ2VQcm94eTo6RGVzdHJveUluc3BlY3RvclRhcmdldDo6bmFtZSgpCisgICAgICAgIHx8IGRl Y29kZXIubWVzc2FnZU5hbWUoKSA9PSBNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpTZW5kTWVzc2Fn ZVRvSW5zcGVjdG9yRnJvbnRlbmQ6Om5hbWUoKQogICAgICAgICApCiAgICAgewogICAgICAgICBt X3BhZ2UuZGlkUmVjZWl2ZU1lc3NhZ2UoY29ubmVjdGlvbiwgZGVjb2Rlcik7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5oIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuaAppbmRleCAxNzUyMTUwNDc0 OGJmYjZmMjA2M2NlMTRjYTQ1ZmQxY2M3MTgzZWNiLi5iZWU4MWJjMGJkOWQ3MWI0YTY4ZGY0Zjhi OWU0NzM2YmQyOWE4Y2ZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm92 aXNpb25hbFBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1Byb3Zpc2lv bmFsUGFnZVByb3h5LmgKQEAgLTY0LDcgKzY0LDcgQEAgcHVibGljOgogICAgIFByb3Zpc2lvbmFs UGFnZVByb3h5KFdlYlBhZ2VQcm94eSYsIFJlZjxXZWJQcm9jZXNzUHJveHk+JiYsIHN0ZDo6dW5p cXVlX3B0cjxTdXNwZW5kZWRQYWdlUHJveHk+LCB1aW50NjRfdCBuYXZpZ2F0aW9uSUQsIGJvb2wg aXNTZXJ2ZXJSZWRpcmVjdCwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgUHJvY2Vz c1N3YXBSZXF1ZXN0ZWRCeUNsaWVudCk7CiAgICAgflByb3Zpc2lvbmFsUGFnZVByb3h5KCk7CiAK LSAgICBXZWJQYWdlUHJveHkmIHBhZ2UoKSB7IHJldHVybiBtX3BhZ2U7IH0KKyAgICBXZWJQYWdl UHJveHkmIHBhZ2UoKSBjb25zdCB7IHJldHVybiBtX3BhZ2U7IH0KICAgICBXZWJDb3JlOjpQYWdl SWRlbnRpZmllciB3ZWJQYWdlSUQoKSBjb25zdCB7IHJldHVybiBtX3dlYlBhZ2VJRDsgfQogICAg IFdlYkZyYW1lUHJveHkqIG1haW5GcmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fbWFpbkZyYW1lLmdl dCgpOyB9CiAgICAgV2ViUHJvY2Vzc1Byb3h5JiBwcm9jZXNzKCkgeyByZXR1cm4gbV9wcm9jZXNz LmdldCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlci5jcHAKaW5kZXggYmRhNTljZDgwNTE1NzY0NmIzMDhkMmZkMjM2ZjNk MTE4MjcxZTBiNi4uYjRmNWI2MWZjNmQ3YTI5NDAwZWJjMDFjNTEzYTcxZDhhNTg0YjQ3OSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNvbnRyb2xs ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250 cm9sbGVyLmNwcApAQCAtMjYsMjggKzI2LDM5IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5j bHVkZSAiV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaCIKIAorI2luY2x1ZGUgIlByb3Zpc2lv bmFsUGFnZVByb3h5LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVQcm94eS5oIgotI2luY2x1ZGUgIldl YlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oIgorI2luY2x1ZGUgIldlYlBhZ2VJbnNwZWN0b3JU YXJnZXQuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIKICNpbmNsdWRlIDxKYXZhU2NyaXB0 Q29yZS9JbnNwZWN0b3JBZ2VudEJhc2UuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9JbnNw ZWN0b3JCYWNrZW5kRGlzcGF0Y2hlci5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0luc3Bl Y3RvckJhY2tlbmREaXNwYXRjaGVycy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0luc3Bl Y3RvckZyb250ZW5kUm91dGVyLmg+CisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSW5zcGVjdG9y VGFyZ2V0QWdlbnQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiBuYW1lc3BhY2UgV2Vi S2l0IHsKIAogdXNpbmcgbmFtZXNwYWNlIEluc3BlY3RvcjsKIAorc3RhdGljIFN0cmluZyBnZXRU YXJnZXRJRChjb25zdCBQcm92aXNpb25hbFBhZ2VQcm94eSYgcHJvdmlzaW9uYWxQYWdlKQorewor ICAgIHJldHVybiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKHByb3Zpc2lvbmFs UGFnZS53ZWJQYWdlSUQoKSk7Cit9CisKIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpXZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlcihXZWJQYWdlUHJveHkmIHBhZ2UpCiAgICAgOiBtX3BhZ2Uo cGFnZSkKICAgICAsIG1fZnJvbnRlbmRSb3V0ZXIoRnJvbnRlbmRSb3V0ZXI6OmNyZWF0ZSgpKQog ICAgICwgbV9iYWNrZW5kRGlzcGF0Y2hlcihCYWNrZW5kRGlzcGF0Y2hlcjo6Y3JlYXRlKG1fZnJv bnRlbmRSb3V0ZXIuY29weVJlZigpKSkKIHsKLSAgICBhdXRvIHRhcmdldEFnZW50ID0gbWFrZVVu aXF1ZTxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ+KG1fZnJvbnRlbmRSb3V0ZXIuZ2V0KCks IG1fYmFja2VuZERpc3BhdGNoZXIuZ2V0KCkpOworICAgIGF1dG8gdGFyZ2V0QWdlbnQgPSBtYWtl VW5pcXVlPEluc3BlY3RvclRhcmdldEFnZW50PihtX2Zyb250ZW5kUm91dGVyLmdldCgpLCBtX2Jh Y2tlbmREaXNwYXRjaGVyLmdldCgpKTsKIAogICAgIG1fdGFyZ2V0QWdlbnQgPSB0YXJnZXRBZ2Vu dC5nZXQoKTsKIAogICAgIG1fYWdlbnRzLmFwcGVuZChXVEZNb3ZlKHRhcmdldEFnZW50KSk7CisK KyAgICBTdHJpbmcgcGFnZVRhcmdldElkID0gV2ViUGFnZUluc3BlY3RvclRhcmdldDo6dG9UYXJn ZXRJRChtX3BhZ2Uud2ViUGFnZUlEKCkpOworICAgIGNyZWF0ZUluc3BlY3RvclRhcmdldChwYWdl VGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZTo6UGFnZSk7CiB9CiAKIHZv aWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OnBhZ2VDbG9zZWQoKQpAQCAtMTM2LDMwICsx NDcsMjQgQEAgdm9pZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6c2V0SW5kaWNhdGluZyhi b29sIGluZGljYXRpbmcpCiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNsZWFy VGFyZ2V0cygpCiB7Ci0gICAgZm9yIChhdXRvJiB0YXJnZXQgOiBtX3RhcmdldHMpCi0gICAgICAg IG1fdGFyZ2V0QWdlbnQtPnRhcmdldERlc3Ryb3llZCgqdGFyZ2V0LmdldCgpKTsKKyAgICBmb3Ig KGF1dG8mIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkKKyAgICAgICAgbV90YXJnZXRBZ2Vu dC0+dGFyZ2V0RGVzdHJveWVkKCp0YXJnZXQpOwogCiAgICAgbV90YXJnZXRzLmNsZWFyKCk7CiB9 CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNyZWF0ZUluc3BlY3RvclRhcmdl dChjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUg dHlwZSkKIHsKLSAgICBhdXRvIHRhcmdldCA9IEluc3BlY3RvclRhcmdldFByb3h5OjpjcmVhdGUo bV9wYWdlLCB0YXJnZXRJZCwgdHlwZSk7Ci0gICAgbV90YXJnZXRzLmFwcGVuZCh0YXJnZXQuY29w eVJlZigpKTsKLQotICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldENyZWF0ZWQodGFyZ2V0LmdldCgp KTsKKyAgICBhZGRUYXJnZXQoSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZShtX3BhZ2UsIHRh cmdldElkLCB0eXBlKSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmRl c3Ryb3lJbnNwZWN0b3JUYXJnZXQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCkKIHsKLSAgICBhdXRv IHBvc2l0aW9uID0gbV90YXJnZXRzLmZpbmRNYXRjaGluZyhbJl0oY29uc3QgYXV0byYgaXRlbSkg eyByZXR1cm4gaXRlbS0+aWRlbnRpZmllcigpID09IHRhcmdldElkOyB9KTsKLSAgICBpZiAocG9z aXRpb24gPT0gbm90Rm91bmQpCisgICAgYXV0byBpdCA9IG1fdGFyZ2V0cy5maW5kKHRhcmdldElk KTsKKyAgICBpZiAoaXQgPT0gbV90YXJnZXRzLmVuZCgpKQogICAgICAgICByZXR1cm47Ci0KLSAg ICBhdXRvJiB0YXJnZXQgPSBtX3RhcmdldHNbcG9zaXRpb25dOwotICAgIG1fdGFyZ2V0QWdlbnQt PnRhcmdldERlc3Ryb3llZCgqdGFyZ2V0LmdldCgpKTsKLQotICAgIG1fdGFyZ2V0cy5yZW1vdmUo cG9zaXRpb24pOworICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldERlc3Ryb3llZCgqaXQtPnZhbHVl KTsKKyAgICBtX3RhcmdldHMucmVtb3ZlKGl0KTsKIH0KIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9y Q29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb0luc3BlY3RvckZyb250ZW5kKGNvbnN0IFN0cmluZyYg dGFyZ2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKQEAgLTE2Nyw0ICsxNzIsMzQgQEAgdm9p ZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb0luc3BlY3RvckZyb250 ZW5kKGNvbnN0IFN0cmluZyYgdGEKICAgICBtX3RhcmdldEFnZW50LT5zZW5kTWVzc2FnZUZyb21U YXJnZXRUb0Zyb250ZW5kKHRhcmdldElkLCBtZXNzYWdlKTsKIH0KIAordm9pZCBXZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlcjo6ZGlkQ3JlYXRlUHJvdmlzaW9uYWxQYWdlKFByb3Zpc2lvbmFsUGFn ZVByb3h5JiBwcm92aXNpb25hbFBhZ2UpCit7CisgICAgYWRkVGFyZ2V0KEluc3BlY3RvclRhcmdl dFByb3h5OjpjcmVhdGUocHJvdmlzaW9uYWxQYWdlLCBnZXRUYXJnZXRJRChwcm92aXNpb25hbFBh Z2UpLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGU6OlBhZ2UpKTsKK30KKwordm9pZCBX ZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6ZGlkRGVzdHJveVByb3Zpc2lvbmFsUGFnZShjb25z dCBQcm92aXNpb25hbFBhZ2VQcm94eSYgcHJvdmlzaW9uYWxQYWdlLCBib29sIHdhc0NvbW1pdHRl ZCkKK3sKKyAgICBpZiAod2FzQ29tbWl0dGVkKQorICAgICAgICByZXR1cm47CisgICAgZGVzdHJv eUluc3BlY3RvclRhcmdldChnZXRUYXJnZXRJRChwcm92aXNpb25hbFBhZ2UpKTsKK30KKwordm9p ZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxQYWdlKGNv bnN0IFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyJiBvbGRXZWJQYWdlSUQsIGNvbnN0IFdlYkNvcmU6 OlBhZ2VJZGVudGlmaWVyJiBuZXdXZWJQYWdlSUQpCit7CisgICAgU3RyaW5nIG9sZElEID0gV2Vi UGFnZUluc3BlY3RvclRhcmdldDo6dG9UYXJnZXRJRChvbGRXZWJQYWdlSUQpOworICAgIFN0cmlu ZyBuZXdJRCA9IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OnRvVGFyZ2V0SUQobmV3V2ViUGFnZUlE KTsKKyAgICBpZiAoYXV0byogdGFyZ2V0ID0gbV90YXJnZXRzLmdldChuZXdJRCkpCisgICAgICAg IHRhcmdldC0+ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQoKTsKKyAgICBtX3RhcmdldEFnZW50 LT5kaWRDb21taXRQcm92aXNpb25hbFRhcmdldChvbGRJRCwgbmV3SUQpOworICAgIC8vIFdlJ3Zl IGRpc2Nvbm5lY3RlZCBmcm9tIHRoZSBvbGQgcGFnZSBhbmQgd2lsbCBub3QgcmVjZWl2ZSBhbnkg bWVzc2FnZSBmcm9tIGl0LCBzbworICAgIC8vIHdlIGRlc3Ryb3kgdGhlIHRhcmdldCBoZXJlLgor ICAgIGRlc3Ryb3lJbnNwZWN0b3JUYXJnZXQob2xkSUQpOworfQorCit2b2lkIFdlYlBhZ2VJbnNw ZWN0b3JDb250cm9sbGVyOjphZGRUYXJnZXQoc3RkOjp1bmlxdWVfcHRyPEluc3BlY3RvclRhcmdl dFByb3h5PiYmIHRhcmdldCkKK3sKKyAgICBtX3RhcmdldEFnZW50LT50YXJnZXRDcmVhdGVkKCp0 YXJnZXQpOworICAgIG1fdGFyZ2V0cy5zZXQodGFyZ2V0LT5pZGVudGlmaWVyKCksIFdURk1vdmUo dGFyZ2V0KSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaCBiL1NvdXJjZS9X ZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmgKaW5kZXggMGNhZjZh MWMyNzkyMDQzZDNiZTA1NzFhMjhmZGIxZTE0MTk3YTYxMS4uYTAzMGExNGI1ZjliYmQ1ZTA1Mzg1 M2Q2ZjBkMmQ3NTgxMTg1Y2U3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9XZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oCkBAIC02NSwxMyArNjUsMjAgQEAgcHVibGlj OgogICAgIHZvaWQgZGVzdHJveUluc3BlY3RvclRhcmdldChjb25zdCBTdHJpbmcmIHRhcmdldElk KTsKICAgICB2b2lkIHNlbmRNZXNzYWdlVG9JbnNwZWN0b3JGcm9udGVuZChjb25zdCBTdHJpbmcm IHRhcmdldElkLCBjb25zdCBTdHJpbmcmIG1lc3NhZ2UpOwogCisgICAgdm9pZCBkaWRDcmVhdGVQ cm92aXNpb25hbFBhZ2UoUHJvdmlzaW9uYWxQYWdlUHJveHkmKTsKKyAgICB2b2lkIGRpZERlc3Ry b3lQcm92aXNpb25hbFBhZ2UoY29uc3QgUHJvdmlzaW9uYWxQYWdlUHJveHkmLCBib29sIHdhc0Nv bW1pdHRlZCk7CisgICAgLy8gdm9pZCBkaWRDb21taXROYXZpZ2F0aW9uKGNvbnN0IFByb3Zpc2lv bmFsUGFnZVByb3h5JiwgYm9vbCB3YXNDb21taXR0ZWQpOworICAgIHZvaWQgZGlkQ29tbWl0UHJv dmlzaW9uYWxQYWdlKGNvbnN0IFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyJiBvbGRXZWJQYWdlSUQs IGNvbnN0IFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyJiBuZXdXZWJQYWdlSUQpOworCiBwcml2YXRl OgorICAgIHZvaWQgYWRkVGFyZ2V0KHN0ZDo6dW5pcXVlX3B0cjxJbnNwZWN0b3JUYXJnZXRQcm94 eT4mJik7CisKICAgICBXZWJQYWdlUHJveHkmIG1fcGFnZTsKICAgICBSZWY8SW5zcGVjdG9yOjpG cm9udGVuZFJvdXRlcj4gbV9mcm9udGVuZFJvdXRlcjsKICAgICBSZWY8SW5zcGVjdG9yOjpCYWNr ZW5kRGlzcGF0Y2hlcj4gbV9iYWNrZW5kRGlzcGF0Y2hlcjsKICAgICBJbnNwZWN0b3I6OkFnZW50 UmVnaXN0cnkgbV9hZ2VudHM7CiAgICAgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudCog bV90YXJnZXRBZ2VudDsKLSAgICBWZWN0b3I8UmVmUHRyPEluc3BlY3RvclRhcmdldFByb3h5Pj4g bV90YXJnZXRzOworICAgIEhhc2hNYXA8U3RyaW5nLCBzdGQ6OnVuaXF1ZV9wdHI8SW5zcGVjdG9y VGFyZ2V0UHJveHk+PiBtX3RhcmdldHM7CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRB Z2VudC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 QWdlbnQuY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYTAwMWMwOGQwMmY3ZWQ2 YzAwODU2NmY3YWY4OWEzODFjZGVkMjE1Li4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwCi0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JU YXJnZXRBZ2VudC5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSw1NSArMCwwIEBACi0vKgotICogQ29w eXJpZ2h0IChDKSAyMDE4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCi0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K LSAqCi0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycn IEFORCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCi0gKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK LSAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKLSAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgotICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKLSAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgot I2luY2x1ZGUgIldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oIgotCi1uYW1lc3BhY2UgV2Vi S2l0IHsKLQotV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50OjpXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0QWdlbnQoSW5zcGVjdG9yOjpGcm9udGVuZFJvdXRlciYgZnJvbnRlbmRSb3V0ZXIsIEluc3Bl Y3Rvcjo6QmFja2VuZERpc3BhdGNoZXImIGJhY2tlbmREaXNwYXRjaGVyKQotICAgIDogSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudChmcm9udGVuZFJvdXRlciwgYmFja2VuZERpc3BhdGNo ZXIpCi0gICAgLCBtX3JvdXRlcihmcm9udGVuZFJvdXRlcikKLXsKLX0KLQotV2ViUGFnZUluc3Bl Y3RvclRhcmdldEFnZW50Ojp+V2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50KCkgPSBkZWZhdWx0 OwotCi1JbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYgV2ViUGFnZUluc3BlY3RvclRhcmdldEFn ZW50Ojpmcm9udGVuZENoYW5uZWwoKQotewotICAgIHJldHVybiAqdGhpczsKLX0KLQotSW5zcGVj dG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIFdlYlBhZ2VJbnNwZWN0b3JUYXJn ZXRBZ2VudDo6Y29ubmVjdGlvblR5cGUoKSBjb25zdAotewotICAgIHJldHVybiBtX3JvdXRlci5o YXNMb2NhbEZyb250ZW5kKCkgPyBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlv blR5cGU6OkxvY2FsIDogSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBl OjpSZW1vdGU7Ci19Ci0KLXZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50OjpzZW5kTWVz c2FnZVRvRnJvbnRlbmQoY29uc3QgU3RyaW5nJikKLXsKLSAgICAvLyBJbnRlbnRpb25hbGx5IGln bm9yZWQsIHRoaXMgY2hhbm5lbCBpcyBub3QgYWN0dWFsbHkgdXNlZCB0byBzZW5kIG1lc3NhZ2Vz LgotICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwotfQotCi19IC8vIG5hbWVzcGFjZSBXZWJLaXQK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JUYXJn ZXRBZ2VudC5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRhcmdl dEFnZW50LmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDk2M2Y5YzNjY2NlYTU0ODdh NGNlMjkzZWM1ZTA4M2E4Y2M4YjUxNTQuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRh cmdldEFnZW50LmgKKysrIC9kZXYvbnVsbApAQCAtMSw0OSArMCwwIEBACi0vKgotICogQ29weXJp Z2h0IChDKSAyMDE4IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSAqCi0gKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKLSAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucwotICogYXJlIG1ldDoKLSAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu Ci0gKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAq Ci0gKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFO RCBBTlkKLSAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCi0gKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKLSAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKLSAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgotICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQotICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKLSAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0gKi8KLQotI3ByYWdtYSBvbmNlCi0KLSNpbmNsdWRl IDxKYXZhU2NyaXB0Q29yZS9JbnNwZWN0b3JGcm9udGVuZENoYW5uZWwuaD4KLSNpbmNsdWRlIDxK YXZhU2NyaXB0Q29yZS9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oPgotCi1uYW1lc3BhY2UgV2ViS2l0 IHsKLQotY2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50IGZpbmFsIDogcHVibGljIElu c3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0QWdlbnQsIHB1YmxpYyBJbnNwZWN0b3I6OkZyb250ZW5k Q2hhbm5lbCB7Ci1wdWJsaWM6Ci0gICAgV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50KEluc3Bl Y3Rvcjo6RnJvbnRlbmRSb3V0ZXImLCBJbnNwZWN0b3I6OkJhY2tlbmREaXNwYXRjaGVyJik7Ci0g ICAgdmlydHVhbCB+V2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50KCk7Ci0KLSAgICAvLyBJbnNw ZWN0b3JUYXJnZXRBZ2VudAotICAgIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsJiBmcm9udGVu ZENoYW5uZWwoKTsKLQotICAgIC8vIEZyb250ZW5kQ2hhbm5lbAotICAgIEluc3BlY3Rvcjo6RnJv bnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSBjb25uZWN0aW9uVHlwZSgpIGNvbnN0OwotICAg IHZvaWQgc2VuZE1lc3NhZ2VUb0Zyb250ZW5kKGNvbnN0IFN0cmluZyYpOwotCi1wcml2YXRlOgot ICAgIEluc3BlY3Rvcjo6RnJvbnRlbmRSb3V0ZXImIG1fcm91dGVyOwotfTsKLQotfSAvLyBuYW1l c3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdl UHJveHkuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAppbmRl eCBmNGYwOGU0NzVmMzEwOGMyYTEzNTRhNmE2ZjVhNDM3OWNiZTMxMTQxLi5mNTkzYTc1ZjY2MTA5 YmM1OTEzNmM1NTg5MDUwYWQ4YWJkZDc0NjE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dl YlBhZ2VQcm94eS5jcHAKQEAgLTQ5MSw4ICs0OTEsNiBAQCBXZWJQYWdlUHJveHk6OldlYlBhZ2VQ cm94eShQYWdlQ2xpZW50JiBwYWdlQ2xpZW50LCBXZWJQcm9jZXNzUHJveHkmIHByb2Nlc3MsIFJl ZgogICAgIG1faW5zcGVjdG9yRGVidWdnYWJsZS0+c2V0UmVtb3RlRGVidWdnaW5nQWxsb3dlZCh0 cnVlKTsKICAgICBtX2luc3BlY3RvckRlYnVnZ2FibGUtPmluaXQoKTsKICNlbmRpZgotCi0gICAg Y3JlYXRlSW5zcGVjdG9yVGFyZ2V0cygpOwogfQogCiBXZWJQYWdlUHJveHk6On5XZWJQYWdlUHJv eHkoKQpAQCAtODQxLDkgKzgzOSw2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpmaW5pc2hBdHRhY2hp bmdUb1dlYlByb2Nlc3MoUHJvY2Vzc0xhdW5jaFJlYXNvbiByZWFzb24pCiAgICAgcmVtb3RlSW5z cGVjdG9ySW5mb3JtYXRpb25EaWRDaGFuZ2UoKTsKICNlbmRpZgogCi0gICAgY2xlYXJJbnNwZWN0 b3JUYXJnZXRzKCk7Ci0gICAgY3JlYXRlSW5zcGVjdG9yVGFyZ2V0cygpOwotCiAgICAgcGFnZUNs aWVudCgpLmRpZFJlbGF1bmNoUHJvY2VzcygpOwogICAgIG1fcGFnZUxvYWRTdGF0ZS5kaWRTd2Fw V2ViUHJvY2Vzc2VzKCk7CiAgICAgaWYgKHJlYXNvbiAhPSBQcm9jZXNzTGF1bmNoUmVhc29uOjpJ bml0aWFsUHJvY2VzcykKQEAgLTE2MjcsMTcgKzE2MjIsNiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6 cmVtb3RlSW5zcGVjdG9ySW5mb3JtYXRpb25EaWRDaGFuZ2UoKQogfQogI2VuZGlmCiAKLXZvaWQg V2ViUGFnZVByb3h5OjpjbGVhckluc3BlY3RvclRhcmdldHMoKQotewotICAgIG1faW5zcGVjdG9y Q29udHJvbGxlci0+Y2xlYXJUYXJnZXRzKCk7Ci19Ci0KLXZvaWQgV2ViUGFnZVByb3h5OjpjcmVh dGVJbnNwZWN0b3JUYXJnZXRzKCkKLXsKLSAgICBTdHJpbmcgcGFnZVRhcmdldElkID0gbWFrZVN0 cmluZygicGFnZS0iLCBtX3dlYlBhZ2VJRC50b1VJbnQ2NCgpKTsKLSAgICBtX2luc3BlY3RvckNv bnRyb2xsZXItPmNyZWF0ZUluc3BlY3RvclRhcmdldChwYWdlVGFyZ2V0SWQsIEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0VHlwZTo6UGFnZSk7Ci19Ci0KIHZvaWQgV2ViUGFnZVByb3h5OjpzZXRC YWNrZ3JvdW5kQ29sb3IoY29uc3QgT3B0aW9uYWw8Q29sb3I+JiBjb2xvcikKIHsKICAgICBpZiAo bV9iYWNrZ3JvdW5kQ29sb3IgPT0gY29sb3IpCkBAIC0yOTk2LDYgKzI5ODAsNyBAQCB2b2lkIFdl YlBhZ2VQcm94eTo6Y29tbWl0UHJvdmlzaW9uYWxQYWdlKEZyYW1lSWRlbnRpZmllciBmcmFtZUlE LCB1aW50NjRfdCBuYXZpZwogICAgIGlmICghZGlkU3VzcGVuZFByZXZpb3VzUGFnZSkKICAgICAg ICAgbV9wcm9jZXNzLT5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpDbG9zZSgpLCBtX3dlYlBhZ2VJ RCk7CiAKKyAgICBjb25zdCBhdXRvIG9sZFdlYlBhZ2VJRCA9IG1fd2ViUGFnZUlEOwogICAgIHN3 YXBUb1dlYlByb2Nlc3MobV9wcm92aXNpb25hbFBhZ2UtPnByb2Nlc3MoKSwgbV9wcm92aXNpb25h bFBhZ2UtPndlYlBhZ2VJRCgpLCBtX3Byb3Zpc2lvbmFsUGFnZS0+dGFrZURyYXdpbmdBcmVhKCks IG1fcHJvdmlzaW9uYWxQYWdlLT5tYWluRnJhbWUoKSk7CiAKICNpZiBQTEFURk9STShDT0NPQSkK QEAgLTMwMDYsNiArMjk5MSw3IEBAIHZvaWQgV2ViUGFnZVByb3h5Ojpjb21taXRQcm92aXNpb25h bFBhZ2UoRnJhbWVJZGVudGlmaWVyIGZyYW1lSUQsIHVpbnQ2NF90IG5hdmlnCiAKICAgICBkaWRD b21taXRMb2FkRm9yRnJhbWUoZnJhbWVJRCwgbmF2aWdhdGlvbklELCBtaW1lVHlwZSwgZnJhbWVI YXNDdXN0b21Db250ZW50UHJvdmlkZXIsIGZyYW1lTG9hZFR5cGUsIGNlcnRpZmljYXRlSW5mbywg Y29udGFpbnNQbHVnaW5Eb2N1bWVudCwgZm9yY2VkSGFzSW5zZWN1cmVDb250ZW50LCB1c2VyRGF0 YSk7CiAKKyAgICBtX2luc3BlY3RvckNvbnRyb2xsZXItPmRpZENvbW1pdFByb3Zpc2lvbmFsUGFn ZShvbGRXZWJQYWdlSUQsIG1fd2ViUGFnZUlEKTsKICAgICBtX3Byb3Zpc2lvbmFsUGFnZSA9IG51 bGxwdHI7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5oIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggMDc1 MGFhZDZiZDU1YjNlZWEwZDczNzI2YmUzMjI5Y2M2ZDQ3ZWUzMi4uZThhZjIwNWVjOTE0YTY4MDYz YmViNDM2Njk5NGJmMTU3OWUwZGM3MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvV2ViUGFnZVByb3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmgKQEAgLTIwNjIsOSArMjA2Miw2IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIHN0b3BBbGxV UkxTY2hlbWVUYXNrcyhXZWJQcm9jZXNzUHJveHkqID0gbnVsbHB0cik7CiAKLSAgICB2b2lkIGNs ZWFySW5zcGVjdG9yVGFyZ2V0cygpOwotICAgIHZvaWQgY3JlYXRlSW5zcGVjdG9yVGFyZ2V0cygp OwotCiAjaWYgRU5BQkxFKEFUVEFDSE1FTlRfRUxFTUVOVCkKICAgICB2b2lkIHJlZ2lzdGVyQXR0 YWNobWVudElkZW50aWZpZXJGcm9tRGF0YShjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIGNv bnRlbnRUeXBlLCBjb25zdCBTdHJpbmcmIHByZWZlcnJlZEZpbGVOYW1lLCBjb25zdCBJUEM6OkRh dGFSZWZlcmVuY2UmKTsKICAgICB2b2lkIHJlZ2lzdGVyQXR0YWNobWVudElkZW50aWZpZXJGcm9t RmlsZVBhdGgoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJiBjb250ZW50VHlwZSwgY29uc3Qg U3RyaW5nJiBmaWxlUGF0aCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYktpdC54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYktpdC9XZWJLaXQueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagppbmRleCAwNDJjYmIwODlkYmUyNjU5MzBlNTBkYmM0NjMyNTEwY2UxOGQy ZmZhLi4wYzE3ZjE4ZTExYTc1MWYyMWI2ZDE3NmU2NzNmOGQ3ZjMzMWJjNDk4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Nv dXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTEzNjMsNyAr MTM2Myw2IEBACiAJCUE1NDNFMzA3MjE1QUQxMzcwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9y VGFyZ2V0RnJvbnRlbmRDaGFubmVsLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBBNTQzRTMwNTIxNUFEMTJEMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3Rv clRhcmdldEZyb250ZW5kQ2hhbm5lbC5oICovOyB9OwogCQlBNTQzRTMwQzIxNUM4QThEMDAyNzlD RDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gQTU0M0UzMDgyMTVDOEE4MzAwMjc5Q0Q5IC8qIFdlYlBhZ2VJ bnNwZWN0b3JUYXJnZXQuaCAqLzsgfTsKIAkJQTU0M0UzMEQyMTVDOEE5MDAwMjc5Q0Q5IC8qIFdl YlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBNTQzRTMwQjIxNUM4QTg0MDAyNzlDRDkgLyogV2ViUGFn ZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCAqLzsgfTsKLQkJQTU0M0UzMTAyMTVEOENFNjAw Mjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU0M0UzMEUyMTVEOENFMjAwMjc5Q0Q5IC8q IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oICovOyB9OwogCQlBNTVCQTgxMDFCQTEzMTdF MDA3Q0QzM0QgLyogX1dLUmVtb3RlV2ViSW5zcGVjdG9yVmlld0NvbnRyb2xsZXIuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE1NUJBODBDMUJBMTJCRTEw MDdDRDMzRCAvKiBfV0tSZW1vdGVXZWJJbnNwZWN0b3JWaWV3Q29udHJvbGxlci5oICovOyBzZXR0 aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUE1NUJBODE3MUJBMjNF MTIwMDdDRDMzRCAvKiBSZW1vdGVXZWJJbnNwZWN0b3JVSS5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU1QkE4MTMxQkEyM0UwNTAwN0NEMzNEIC8qIFJl bW90ZVdlYkluc3BlY3RvclVJLmggKi87IH07CiAJCUE1NUJBODFGMUJBMjVCMjcwMDdDRDMzRCAv KiBSZW1vdGVXZWJJbnNwZWN0b3JQcm94eS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gQTU1QkE4MTkxQkEyNUIxRTAwN0NEMzNEIC8qIFJlbW90ZVdlYklu c3BlY3RvclByb3h5LmggKi87IH07CkBAIC00MDk4LDggKzQwOTcsNiBAQAogCQlBNTQzRTMwOTIx NUM4QTgzMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBNTQzRTMwQTIxNUM4QTg0MDAyNzlDRDkgLyog V2ViUGFnZUluc3BlY3RvclRhcmdldC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXZWJQYWdlSW5z cGVjdG9yVGFyZ2V0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQTU0M0UzMEIy MTVDOEE4NDAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07Ci0JCUE1NDNFMzBFMjE1RDhDRTIwMDI3OUNEOSAvKiBXZWJQYWdl SW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2ViUGFnZUluc3BlY3RvclRh cmdldEFnZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07Ci0JCUE1NDNFMzBGMjE1RDhD RTIwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJQTU1QkE4MEMxQkExMkJFMTAwN0NEMzNEIC8qIF9XS1JlbW90ZVdlYklu c3BlY3RvclZpZXdDb250cm9sbGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250cm9sbGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUE1NUJBODBEMUJBMTJCRTEwMDdDRDMzRCAvKiBfV0tSZW1vdGVXZWJJbnNw ZWN0b3JWaWV3Q29udHJvbGxlci5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLm9iamNwcDsg cGF0aCA9IF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250cm9sbGVyLm1tOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQlBNTVCQTgxMjFCQTIzRTA1MDA3Q0QzM0QgLyogUmVtb3RlV2Vi SW5zcGVjdG9yVUkuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVt b3RlV2ViSW5zcGVjdG9yVUkuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzg3 MSw4ICs3ODY4LDYgQEAKIAkJCQkyRDlFQTMwRTFBOTZDQkZGMDAyRDI4MDcgLyogV2ViUGFnZUlu amVjdGVkQnVuZGxlQ2xpZW50LmggKi8sCiAJCQkJQTUxM0Y1M0YyMTU0QTVDRDAwNjYyODQxIC8q IFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNwcCAqLywKIAkJCQlBNTEzRjUzRTIxNTRBNUND MDA2NjI4NDEgLyogV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaCAqLywKLQkJCQlBNTQzRTMw RjIxNUQ4Q0UyMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmNwcCAqLywK LQkJCQlBNTQzRTMwRTIxNUQ4Q0UyMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldEFn ZW50LmggKi8sCiAJCQkJQkMxMTFCMEIxMTJGNUU0RjAwMzM3QkFCIC8qIFdlYlBhZ2VQcm94eS5j cHAgKi8sCiAJCQkJQkMwMzJEQ0IxMEY0Mzg5RjAwNThDMTVBIC8qIFdlYlBhZ2VQcm94eS5oICov LAogCQkJCUJDQkQzOEZBMTI1QkFCOUEwMEQyQzI5RiAvKiBXZWJQYWdlUHJveHkubWVzc2FnZXMu aW4gKi8sCkBAIC05OTQ4LDcgKzk5NDMsNiBAQAogCQkJCTJEOUVBMzBGMUE5NkNCRkYwMDJEMjgw NyAvKiBXZWJQYWdlSW5qZWN0ZWRCdW5kbGVDbGllbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUE1 MTNGNTQwMjE1NEE1RDcwMDY2Mjg0MSAvKiBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oIGlu IEhlYWRlcnMgKi8sCiAJCQkJQTU0M0UzMEMyMTVDOEE4RDAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNw ZWN0b3JUYXJnZXQuaCBpbiBIZWFkZXJzICovLAotCQkJCUE1NDNFMzEwMjE1RDhDRTYwMDI3OUNE OSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCUE1 NDNFMzBEMjE1QzhBOTAwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxl ci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTU0M0UzMDcyMTVBRDEzNzAwMjc5Q0Q5IC8qIFdlYlBh Z2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaCBpbiBIZWFkZXJzICovLAogCQkJCUMw Q0U3MkExMTI0N0U3MUQwMEJDMEVDNCAvKiBXZWJQYWdlTWVzc2FnZXMuaCBpbiBIZWFkZXJzICov LApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUlu c3BlY3RvclRhcmdldC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0LmNwcAppbmRleCA1NmIwZDUyZWM1OTU3Y2M3M2ExM2YwNjdlYjNj ZGEwMzJkZTIxNzU4Li4yMmJlYzYxODc1NmU2ZjAxOGQ3NzUzYzA0YzIzOGIxZWYyYzY2OGIxIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVj dG9yVGFyZ2V0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0LmNwcApAQCAtMjcsNiArMjcsNyBAQAogI2luY2x1ZGUgIldlYlBh Z2VJbnNwZWN0b3JUYXJnZXQuaCIKIAogI2luY2x1ZGUgIldlYlBhZ2UuaCIKKyNpbmNsdWRlICJX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmgiCiAjaW5jbHVkZSA8V2ViQ29y ZS9JbnNwZWN0b3JDb250cm9sbGVyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9QYWdlLmg+CiAKQEAg LTQxLDE5ICs0MiwyNSBAQCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjpXZWJQYWdlSW5zcGVjdG9y VGFyZ2V0KFdlYlBhZ2UmIHBhZ2UpCiAKIFN0cmluZyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojpp ZGVudGlmaWVyKCkgY29uc3QKIHsKLSAgICByZXR1cm4gbWFrZVN0cmluZygicGFnZS0iLCBtX3Bh Z2UuaWRlbnRpZmllcigpLnRvVUludDY0KCkpOworICAgIHJldHVybiB0b1RhcmdldElEKG1fcGFn ZS5pZGVudGlmaWVyKCkpOwogfQogCi12b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmNvbm5l Y3QoSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWwmIGNoYW5uZWwpCit2b2lkIFdlYlBhZ2VJbnNw ZWN0b3JUYXJnZXQ6OmNvbm5lY3QoSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rp b25UeXBlIGNvbm5lY3Rpb25UeXBlKQogeworICAgIGlmIChtX2NoYW5uZWwpCisgICAgICAgIHJl dHVybjsKKyAgICBtX2NoYW5uZWwgPSBtYWtlVW5pcXVlPFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRG cm9udGVuZENoYW5uZWw+KG1fcGFnZSwgaWRlbnRpZmllcigpLCBjb25uZWN0aW9uVHlwZSk7CiAg ICAgaWYgKG1fcGFnZS5jb3JlUGFnZSgpKQotICAgICAgICBtX3BhZ2UuY29yZVBhZ2UoKS0+aW5z cGVjdG9yQ29udHJvbGxlcigpLmNvbm5lY3RGcm9udGVuZChjaGFubmVsKTsKKyAgICAgICAgbV9w YWdlLmNvcmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIoKS5jb25uZWN0RnJvbnRlbmQoKm1f Y2hhbm5lbCk7CiB9CiAKLXZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldDo6ZGlzY29ubmVjdChJ bnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYgY2hhbm5lbCkKK3ZvaWQgV2ViUGFnZUluc3BlY3Rv clRhcmdldDo6ZGlzY29ubmVjdCgpCiB7CisgICAgaWYgKCFtX2NoYW5uZWwpCisgICAgICAgIHJl dHVybjsKICAgICBpZiAobV9wYWdlLmNvcmVQYWdlKCkpCi0gICAgICAgIG1fcGFnZS5jb3JlUGFn ZSgpLT5pbnNwZWN0b3JDb250cm9sbGVyKCkuZGlzY29ubmVjdEZyb250ZW5kKGNoYW5uZWwpOwor ICAgICAgICBtX3BhZ2UuY29yZVBhZ2UoKS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLmRpc2Nvbm5l Y3RGcm9udGVuZCgqbV9jaGFubmVsKTsKKyAgICBtX2NoYW5uZWwucmVzZXQoKTsKIH0KIAogdm9p ZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjpzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChjb25z dCBTdHJpbmcmIG1lc3NhZ2UpCkBAIC02Miw0ICs2OSwxMCBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0 b3JUYXJnZXQ6OnNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYgbWVzc2Fn ZSkKICAgICAgICAgbV9wYWdlLmNvcmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIoKS5kaXNw YXRjaE1lc3NhZ2VGcm9tRnJvbnRlbmQobWVzc2FnZSk7CiB9CiAKK1N0cmluZyBXZWJQYWdlSW5z cGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKGNvbnN0IFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyJiBw YWdlSUQpCit7CisgICAgcmV0dXJuIG1ha2VTdHJpbmcoInBhZ2UtIiwgcGFnZUlELnRvVUludDY0 KCkpOworfQorCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIGIvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldC5oCmluZGV4 IGI3MGUzMWM4Yjg3NzBjNGJmMWVjYjQ1ODhlYmYyNjc1YjNiOWY0NjQuLmUyYTc0NGRjNDAzZTQ2 NmQ1NzI4ZDc4MDY0NjJhNjE3NzFjYWY5NmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmgKQEAgLTI2LDI5 ICsyNiwzNCBAQAogI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9JbnNw ZWN0b3JUYXJnZXQuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL1BhZ2VJZGVudGlmaWVyLmg+CiAjaW5j bHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBX ZWJQYWdlOworY2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDsKIAog Y2xhc3MgV2ViUGFnZUluc3BlY3RvclRhcmdldCBmaW5hbCA6IHB1YmxpYyBJbnNwZWN0b3I6Oklu c3BlY3RvclRhcmdldCB7CiAgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CiAgICAgV1RGX01B S0VfTk9OQ09QWUFCTEUoV2ViUGFnZUluc3BlY3RvclRhcmdldCk7CiBwdWJsaWM6Ci0gICAgV2Vi UGFnZUluc3BlY3RvclRhcmdldChXZWJQYWdlJik7CisgICAgZXhwbGljaXQgV2ViUGFnZUluc3Bl Y3RvclRhcmdldChXZWJQYWdlJik7CiAgICAgfldlYlBhZ2VJbnNwZWN0b3JUYXJnZXQoKSA9IGRl ZmF1bHQ7CiAKICAgICBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUgdHlwZSgpIGNvbnN0 IGZpbmFsIHsgcmV0dXJuIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZTo6UGFnZTsgfQog CiAgICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25zdCBmaW5hbDsKIAotICAgIHZvaWQgY29ubmVj dChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYpOwotICAgIHZvaWQgZGlzY29ubmVjdChJbnNw ZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYpOwotICAgIHZvaWQgc2VuZE1lc3NhZ2VUb1RhcmdldEJh Y2tlbmQoY29uc3QgU3RyaW5nJik7CisgICAgdm9pZCBjb25uZWN0KEluc3BlY3Rvcjo6RnJvbnRl bmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSkgb3ZlcnJpZGU7CisgICAgdm9pZCBkaXNjb25uZWN0 KCkgb3ZlcnJpZGU7CisgICAgdm9pZCBzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChjb25zdCBT dHJpbmcmKSBvdmVycmlkZTsKKworICAgIHN0YXRpYyBTdHJpbmcgdG9UYXJnZXRJRChjb25zdCBX ZWJDb3JlOjpQYWdlSWRlbnRpZmllciYpOwogCiBwcml2YXRlOgogICAgIFdlYlBhZ2UmIG1fcGFn ZTsKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hh bm5lbD4gbV9jaGFubmVsOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdl SW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHAKaW5kZXggNTI1NDg5NjczZDY2YTJlNGE3ZmQz MmYzNjQ4NTM0Y2UzZWRlZWM0Ny4uY2RhNGYxZThkM2M1NzUzNjE2MmFhMzkwZWQ3NGI2ODFjODkx MzQwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFn ZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmNwcApAQCAtNTgs NyArNTgsNiBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpyZW1vdmVU YXJnZXQoSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXQmCiAgICAgbV9wYWdlLnNlbmQoTWVzc2Fn ZXM6OldlYlBhZ2VQcm94eTo6RGVzdHJveUluc3BlY3RvclRhcmdldCh0YXJnZXQuaWRlbnRpZmll cigpKSk7CiAKICAgICBtX3RhcmdldHMucmVtb3ZlKHRhcmdldC5pZGVudGlmaWVyKCkpOwotICAg IG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVscy5yZW1vdmUodGFyZ2V0LmlkZW50aWZpZXIoKSk7CiB9 CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OmNvbm5lY3RJbnNwZWN0 b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNv bm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQpAQCAtNjcsMTMgKzY2LDcgQEAgdm9pZCBXZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6Y29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJp bmcmIHRhcmdldElkLAogICAgIGlmICghdGFyZ2V0KQogICAgICAgICByZXR1cm47CiAKLSAgICBS ZWZQdHI8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4gY2hhbm5lbCA9IG1f dGFyZ2V0RnJvbnRlbmRDaGFubmVscy5nZXQodGFyZ2V0SWQpOwotICAgIGlmICghY2hhbm5lbCkg ewotICAgICAgICBjaGFubmVsID0gV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5l bDo6Y3JlYXRlKCp0aGlzLCB0YXJnZXRJZCwgY29ubmVjdGlvblR5cGUpOwotICAgICAgICBtX3Rh cmdldEZyb250ZW5kQ2hhbm5lbHMuc2V0KHRhcmdldC0+aWRlbnRpZmllcigpLCBjaGFubmVsKTsK LSAgICB9Ci0KLSAgICB0YXJnZXQtPmNvbm5lY3QoKmNoYW5uZWwuZ2V0KCkpOworICAgIHRhcmdl dC0+Y29ubmVjdChjb25uZWN0aW9uVHlwZSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvclRh cmdldENvbnRyb2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJ ZCkKQEAgLTgyLDExICs3NSw3IEBAIHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xs ZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJCiAgICAgaWYgKCF0 YXJnZXQpCiAgICAgICAgIHJldHVybjsKIAotICAgIFJlZlB0cjxXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0RnJvbnRlbmRDaGFubmVsPiBjaGFubmVsID0gbV90YXJnZXRGcm9udGVuZENoYW5uZWxzLnRh a2UodGFyZ2V0SWQpOwotICAgIGlmICghY2hhbm5lbCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAg dGFyZ2V0LT5kaXNjb25uZWN0KCpjaGFubmVsLmdldCgpKTsKKyAgICB0YXJnZXQtPmRpc2Nvbm5l Y3QoKTsKIH0KIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6c2VuZE1l c3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgY29uc3QgU3RyaW5n JiBtZXNzYWdlKQpAQCAtOTgsOSArODcsNCBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRD b250cm9sbGVyOjpzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChjb25zdCBTdHJpbmcmCiAgICAg dGFyZ2V0LT5zZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChtZXNzYWdlKTsKIH0KIAotdm9pZCBX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb1RhcmdldEZyb250 ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKLXsKLSAg ICBtX3BhZ2Uuc2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpTZW5kTWVzc2FnZVRvSW5zcGVj dG9yRnJvbnRlbmQodGFyZ2V0SWQsIG1lc3NhZ2UpKTsKLX0KLQogfSAvLyBuYW1lc3BhY2UgV2Vi S2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdl SW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dl YlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaAppbmRleCAzZTkyYjdhOWRh OWU1NjA5ZTYwMTY2MzljMDliNzNjYjU5NmY4YWY1Li43YzkzMWRhZDFjOTgwMGYwM2Q3M2Q0YTdj YTI1ODhkZDAyOGE4ZjI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJL aXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmgK QEAgLTI2LDcgKzI2LDYgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSAiV2ViUGFnZUluc3Bl Y3RvclRhcmdldC5oIgotI2luY2x1ZGUgIldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENo YW5uZWwuaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1dU RlN0cmluZy5oPgogCkBAIC01MCwxMyArNDksMTEgQEAgcHVibGljOgogICAgIHZvaWQgY29ubmVj dEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6OkZyb250ZW5kQ2hh bm5lbDo6Q29ubmVjdGlvblR5cGUpOwogICAgIHZvaWQgZGlzY29ubmVjdEluc3BlY3Rvcihjb25z dCBTdHJpbmcmIHRhcmdldElkKTsKICAgICB2b2lkIHNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5k KGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSk7Ci0gICAgdm9p ZCBzZW5kTWVzc2FnZVRvVGFyZ2V0RnJvbnRlbmQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgY29u c3QgU3RyaW5nJiBtZXNzYWdlKTsKIAogcHJpdmF0ZToKICAgICBXZWJQYWdlJiBtX3BhZ2U7CiAg ICAgV2ViUGFnZUluc3BlY3RvclRhcmdldCBtX3BhZ2VUYXJnZXQ7CiAgICAgSGFzaE1hcDxTdHJp bmcsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0Kj4gbV90YXJnZXRzOwotICAgIEhhc2hNYXA8 U3RyaW5nLCBSZWZQdHI8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4+IG1f dGFyZ2V0RnJvbnRlbmRDaGFubmVsczsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3Rv clRhcmdldEZyb250ZW5kQ2hhbm5lbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcAppbmRleCA4ZDc4 ODA3ODJhMjliMTcwY2U2NWFmYzcwMzc3ZDhiZDUwNjk0MzU4Li5lMWI1ZjcxMzczM2EwOTUyNTIx MjJmMGEzODAxZjgyYzhjNjBkM2Y2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 RnJvbnRlbmRDaGFubmVsLmNwcApAQCAtMjYsMTcgKzI2LDEzIEBACiAjaW5jbHVkZSAiY29uZmln LmgiCiAjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oIgog Ci0jaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCIKKyNpbmNsdWRl ICJXZWJQYWdlLmgiCisjaW5jbHVkZSAiV2ViUGFnZVByb3h5TWVzc2FnZXMuaCIKIAogbmFtZXNw YWNlIFdlYktpdCB7CiAKLVJlZjxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVs PiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsOjpjcmVhdGUoV2ViUGFnZUlu c3BlY3RvclRhcmdldENvbnRyb2xsZXImIHRhcmdldENvbnRyb2xsZXIsIGNvbnN0IFN0cmluZyYg dGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSBjb25u ZWN0aW9uVHlwZSkKLXsKLSAgICByZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJQYWdlSW5zcGVjdG9y VGFyZ2V0RnJvbnRlbmRDaGFubmVsKHRhcmdldENvbnRyb2xsZXIsIHRhcmdldElkLCBjb25uZWN0 aW9uVHlwZSkpOwotfQotCi1XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsOjpX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsKFdlYlBhZ2VJbnNwZWN0b3JUYXJn ZXRDb250cm9sbGVyJiB0YXJnZXRDb250cm9sbGVyLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJ bnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgY29ubmVjdGlvblR5cGUp Ci0gICAgOiBtX3RhcmdldENvbnRyb2xsZXIodGFyZ2V0Q29udHJvbGxlcikKK1dlYlBhZ2VJbnNw ZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWw6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVu ZENoYW5uZWwoV2ViUGFnZSYgcGFnZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9y OjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQorICAgIDog bV9wYWdlKHBhZ2UpCiAgICAgLCBtX3RhcmdldElkKHRhcmdldElkKQogICAgICwgbV9jb25uZWN0 aW9uVHlwZShjb25uZWN0aW9uVHlwZSkKIHsKQEAgLTQ0LDcgKzQwLDcgQEAgV2ViUGFnZUluc3Bl Y3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbChXZWIKIAogdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVs OjpzZW5kTWVzc2FnZVRvRnJvbnRlbmQoY29uc3QgU3RyaW5nJiBtZXNzYWdlKQogewotICAgIG1f dGFyZ2V0Q29udHJvbGxlci5zZW5kTWVzc2FnZVRvVGFyZ2V0RnJvbnRlbmQobV90YXJnZXRJZCwg bWVzc2FnZSk7CisgICAgbV9wYWdlLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6U2VuZE1l c3NhZ2VUb0luc3BlY3RvckZyb250ZW5kKG1fdGFyZ2V0SWQsIG1lc3NhZ2UpKTsKIH0KIAogfSAv LyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmggYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRD aGFubmVsLmgKaW5kZXggNzZhZjYyYTk3YmVmNDg4YjY0NGU1ZDYxOGQ0MzllYzlhNDJmMjJkYS4u OTc2MDk4ZGE0ZDdiZTU2M2YxYjkzMTEyNjE5N2U0MmYwOGQxY2MxNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250 ZW5kQ2hhbm5lbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBh Z2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaApAQCAtMzEsMjIgKzMxLDIwIEBACiAK IG5hbWVzcGFjZSBXZWJLaXQgewogCi1jbGFzcyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJv bGxlcjsKK2NsYXNzIFdlYlBhZ2U7CiAKLWNsYXNzIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWwgZmluYWwgOiBwdWJsaWMgUmVmQ291bnRlZDxXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0RnJvbnRlbmRDaGFubmVsPiwgcHVibGljIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsIHsK K2NsYXNzIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwgZmluYWwgOiBwdWJs aWMgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWwgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NB VEVEOworICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWwpOwogcHVibGljOgotICAgIHN0YXRpYyBSZWY8V2ViUGFnZUluc3BlY3RvclRh cmdldEZyb250ZW5kQ2hhbm5lbD4gY3JlYXRlKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9s bGVyJiwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6 OkNvbm5lY3Rpb25UeXBlKTsKLSAgICB2aXJ0dWFsIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJv bnRlbmRDaGFubmVsKCkgPSBkZWZhdWx0OworICAgIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWwoV2ViUGFnZSYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6 RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSk7CisgICAgfldlYlBhZ2VJbnNwZWN0b3JU YXJnZXRGcm9udGVuZENoYW5uZWwoKSBvdmVycmlkZSA9IGRlZmF1bHQ7CiAKIHByaXZhdGU6Ci0g ICAgV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbChXZWJQYWdlSW5zcGVjdG9y VGFyZ2V0Q29udHJvbGxlciYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJv bnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSk7Ci0KICAgICBDb25uZWN0aW9uVHlwZSBjb25u ZWN0aW9uVHlwZSgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIG1fY29ubmVjdGlvblR5cGU7IH0K ICAgICB2b2lkIHNlbmRNZXNzYWdlVG9Gcm9udGVuZChjb25zdCBTdHJpbmcmIG1lc3NhZ2UpIG92 ZXJyaWRlOwogCi1wcml2YXRlOgotICAgIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVy JiBtX3RhcmdldENvbnRyb2xsZXI7CisgICAgV2ViUGFnZSYgbV9wYWdlOwogICAgIFN0cmluZyBt X3RhcmdldElkOwogICAgIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlw ZSBtX2Nvbm5lY3Rpb25UeXBlIHsgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rp b25UeXBlOjpSZW1vdGUgfTsKIH07CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cg Yi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggYWFlZmI3YjE0MzgyY2ViNjY0ODZlOGQ5NDdh NmYzNDAzNTY3NTE2OS4uNDEyYmM5MjQ5ZGZlZjE4NmIzNjY5YjI1MDRlYjQxNTNhYmUyNWU1YiAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE5LTEwLTAxICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVy eXNAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92 aXNpb25hbCBwYWdlcyBlYXJseSB0byBub3QgbWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dh cHMgKFBTT04pCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMDIyMTkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBBZGRlZCBuZXcgdGVzdCBmb3IgVGFyZ2V0IGV2ZW50cyBkdXJpbmcgUFNPTi4gSXQgaXMgb25s eSBlbmFibGVkIG9uIFdlYktpdDIgYXMgdGhlcmUgaXMKKyAgICAgICAgbm8gVGFyZ2V0IGFnZW50 IGluIFdlYktpdDEuCisKKyAgICAgICAgKiBUZXN0RXhwZWN0YXRpb25zOgorICAgICAgICAqIGh0 dHAvdGVzdHMvaW5zcGVjdG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZvci1wcm9pc2lvbmFsLXBh Z2UtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL2luc3BlY3Rvci90 YXJnZXQvdGFyZ2V0LWV2ZW50cy1mb3ItcHJvaXNpb25hbC1wYWdlLmh0bWw6IEFkZGVkLgorICAg ICAgICAqIHBsYXRmb3JtL3drMi9UZXN0RXhwZWN0YXRpb25zOgorCiAyMDE5LTEwLTAxICBBbnR0 aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBJbXBvcnQgV1BUIHRlc3Rz IGZvciBDU1MgU2hhZG93IFBhcnRzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9UZXN0RXhwZWN0 YXRpb25zIGIvTGF5b3V0VGVzdHMvVGVzdEV4cGVjdGF0aW9ucwppbmRleCBiN2Y4OWFhZGM5MTFl YjhhOGYzN2RkYjRjNzk5N2FkYWFmMzI1NDRhLi4wNTBhMGJkODdlMTRkNzliMTRiMzEyZGJjYjY0 MmYxOTBjNjQyOGVmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9UZXN0RXhwZWN0YXRpb25zCisr KyBiL0xheW91dFRlc3RzL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTkwNiw2ICs5MDYsOSBAQCB3ZWJr aXQub3JnL2IvMTYxOTUxIFsgRGVidWcgXSBpbnNwZWN0b3IvZGVidWdnZXIvcGF1c2VkLXNjb3Bl cy5odG1sIFsgU2tpcCBdCiBpbnNwZWN0b3IvZGVidWdnZXIvZXZhbHVhdGVPbkNhbGxGcmFtZS1l bXVsYXRlVXNlckdlc3R1cmUtdXNlcklzSW50ZXJhY3RpbmcuaHRtbCBbIFNraXAgXQogaW5zcGVj dG9yL3J1bnRpbWUvZXZhbHVhdGUtZW11bGF0ZVVzZXJHZXN0dXJlLXVzZXJJc0ludGVyYWN0aW5n Lmh0bWwgWyBTa2lwIF0KIAorIyBUYXJnZXQgZG9tYWluIGlzIG9ubHkgcHJlc2VudCBpbiBXSzIu CitodHRwL3Rlc3RzL2luc3BlY3Rvci90YXJnZXQgWyBTa2lwIF0KKwogIyBUaGVzZSBjb25mb3Jt YW5jZSB0ZXN0cyBhcmUgbm8gbG9uZ2VyIGluIHN5bmMgd2l0aCB0aGUgbGF0ZXN0IHNwZWNpZmlj YXRpb24KICMgYW5kIGV4cGVjdCBjb21wYXJlRG9jdW1lbnRQb3NpdGlvbigpIHRvIHJldHVybjoK ICMgRE9DVU1FTlRfUE9TSVRJT05fSU1QTEVNRU5UQVRJT05fU1BFQ0lGSUMgfCBET0NVTUVOVF9Q T1NJVElPTl9ESVNDT05ORUNURUQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv aW5zcGVjdG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZvci1wcm9pc2lvbmFsLXBhZ2UtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFyZ2V0L3RhcmdldC1l dmVudHMtZm9yLXByb2lzaW9uYWwtcGFnZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMWY2MTNh Yzk1NDU3MDE3NDAwN2M4ZGJlZDBjZDQ2ZGM4ZmFkN2I1ZQotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvaW5zcGVjdG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZvci1w cm9pc2lvbmFsLXBhZ2UtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTYgQEAKK1Rlc3QgdGhhdCBj cm9zcyBkb21haW4gbmF2aWdhdGlvbiByZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgc2VxdWVuY2Ug b2YgZXZlbnRzIGluIFRhcmdldCBkb21haW46IDEuIFRhcmdldC50YXJnZXRDcmVhdGVkIGZvciBw cm92aXNpb25hbCBwYWdlLiAyLiBUYXJnZXQuZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQgd2hl biBwcm92aXNpb25hbCBsb2FkIGlzIGNvbW1pdHRlZC4gMy4gVGFyZ2V0LnRhcmdldERlc3Ryb3ll ZCBmb3IgdGhlIG9sZCB0YXJnZXQgYWZ0ZXIgdGhlIG5hdmlnYXRpb24gcmVxdWVzdCBpcyBjb21t aXR0ZWQuCisKK1BBU1M6IHJlY2VpdmVkIHRhcmdldERlc3Ryb3llZCBldmVudC4KK1BBU1M6IGRl c3Ryb3llZCB0YXJnZXQgaXMgcHJldmlvcyB0YXJnZXQuCisKKz09IFJ1bm5pbmcgdGVzdCBzdWl0 ZTogVGFyZ2V0LlBTT04KKy0tIFJ1bm5pbmcgdGVzdCBjYXNlOiBQcm92aXNpb25hbFBhZ2VUYXJn ZXQKK1BBU1M6IHJlY2VpdmVkIHRhcmdldENyZWF0ZWQgZXZlbnQuCitQQVNTOiB0YXJnZXQgaXMg cHJvdmlzaW9uYWwuCitQQVNTOiBwcmV2aW9zIHRhcmdldCBpZCBpcyBpZCBvZiB0aGUgY3VycmVu dCB0YXJnZXQuCitQQVNTOiByZWNlaXZlZCBkaWRDb21taXRQcm92aXNpb25hbFRhcmdldCBldmVu dC4KK1BBU1M6IHByZXZpb3VzIHRhcmdldCBpcyB0aGUgY3VycmVudCBvbmUuCitQQVNTOiBjb21t aXR0ZWQgdGFyZ2V0IG1hdGNoZXMgcHJvdmlzaW9uYWwgdGFyZ2V0LgorUEFTUzogcmVjZWl2ZWQg dGFyZ2V0RGVzdHJveWVkIGV2ZW50LgorUEFTUzogZGVzdHJveWVkIHRhcmdldCBpcyBwcmV2aW9z IHRhcmdldC4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNwZWN0b3Iv dGFyZ2V0L3RhcmdldC1ldmVudHMtZm9yLXByb2lzaW9uYWwtcGFnZS5odG1sIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFyZ2V0L3RhcmdldC1ldmVudHMtZm9yLXByb2lzaW9u YWwtcGFnZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVhYWNkNTI1MjNlMjNiZDQ4ZDY4MGZlOTZkZTEzYTY5 MzgyZDBiZmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2luc3Bl Y3Rvci90YXJnZXQvdGFyZ2V0LWV2ZW50cy1mb3ItcHJvaXNpb25hbC1wYWdlLmh0bWwKQEAgLTAs MCArMSw2NCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgY2hhcnNl dD0idXRmLTgiPgorPHNjcmlwdCBzcmM9Ii4uL3Jlc291cmNlcy9pbnNwZWN0b3ItdGVzdC5qcyI+ PC9zY3JpcHQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgpCit7CisgICAgbGV0IHN1aXRlID0g SW5zcGVjdG9yVGVzdC5jcmVhdGVBc3luY1N1aXRlKCJUYXJnZXQuUFNPTiIpOworICAgIHN1aXRl LmFkZFRlc3RDYXNlKHsKKyAgICAgICAgbmFtZTogIlByb3Zpc2lvbmFsUGFnZVRhcmdldCIsCisg ICAgICAgIGRlc2NyaXB0aW9uOiAiQ2hlY2sgdGhhdCBhIG5ldyB0YXJnZXQgd2lsbCBiZSBjcmVh dGVkIGZvciBwcm92aXNpb25hbCBwYWdlLiIsCisgICAgICAgIHRlc3QocmVzb2x2ZSwgcmVqZWN0 KSB7CisgICAgICAgICAgICBjb25zdCB0YXJnZXRBZ2VudCA9IEluc3BlY3RvckJhY2tlbmQuZG9t YWlucy5UYXJnZXQ7CisgICAgICAgICAgICBjb25zdCBtYWluVGFyZ2V0SWQgPSBXSS5tYWluVGFy Z2V0LmlkZW50aWZpZXI7CisgICAgICAgICAgICBsZXQgbmV3VGFyZ2V0SWQ7CisgICAgICAgICAg ICBJbnNwZWN0b3JUZXN0LmFzc2VydChtYWluVGFyZ2V0SWQpOworICAgICAgICAgICAgdGFyZ2V0 QWdlbnQuZGlzcGF0Y2hlciA9IG5ldyBQcm94eSh0YXJnZXRBZ2VudC5kaXNwYXRjaGVyLCB7Cisg ICAgICAgICAgICAgICAgZ2V0KHRhcmdldCwgcHJvcCwgcmVjZWl2ZXIpIHsKKyAgICAgICAgICAg ICAgICAgICAgaWYgKHByb3AgPT09ICJ0YXJnZXRDcmVhdGVkIikgeworICAgICAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIHRhcmdldEluZm8gPT4geworICAgICAgICAgICAgICAgICAgICAgICAg ICAgIG5ld1RhcmdldElkID0gdGFyZ2V0SW5mby50YXJnZXRJZDsKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICBJbnNwZWN0b3JUZXN0LnBhc3MoYHJlY2VpdmVkICR7cHJvcH0gZXZlbnQuYCk7 CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgSW5zcGVjdG9yVGVzdC5leHBlY3RUcnVlKHRh cmdldEluZm8uaXNQcm92aXNpb25hbCwgInRhcmdldCBpcyBwcm92aXNpb25hbC4iKTsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICBJbnNwZWN0b3JUZXN0LmV4cGVjdEVxdWFsKHRhcmdldElu Zm8ucHJldmlvdXNUYXJnZXRJZCwgbWFpblRhcmdldElkLCAicHJldmlvcyB0YXJnZXQgaWQgaXMg aWQgb2YgdGhlIGN1cnJlbnQgdGFyZ2V0LiIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJldHVybiB0YXJnZXRbcHJvcF0uY2FsbChyZWNlaXZlciwgdGFyZ2V0SW5mbyk7CisgICAgICAg ICAgICAgICAgICAgICAgICB9OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgICAgIGlmIChwcm9wID09PSAiZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQiKSB7CisgICAg ICAgICAgICAgICAgICAgICAgICByZXR1cm4gKHByZXZpb3VzVGFyZ2V0SWQsIHRhcmdldEluZm8p ID0+IHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbnNwZWN0b3JUZXN0LnBhc3MoYHJl Y2VpdmVkICR7cHJvcH0gZXZlbnQuYCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgSW5z cGVjdG9yVGVzdC5leHBlY3RFcXVhbChwcmV2aW91c1RhcmdldElkLCBtYWluVGFyZ2V0SWQsICJw cmV2aW91cyB0YXJnZXQgaXMgdGhlIGN1cnJlbnQgb25lLiIpOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEluc3BlY3RvclRlc3QuZXhwZWN0RXF1YWwodGFyZ2V0SW5mby50YXJnZXRJZCwg bmV3VGFyZ2V0SWQsICJjb21taXR0ZWQgdGFyZ2V0IG1hdGNoZXMgcHJvdmlzaW9uYWwgdGFyZ2V0 LiIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0YXJnZXRbcHJvcF0uY2Fs bChyZWNlaXZlciwgcHJldmlvdXNUYXJnZXRJZCwgdGFyZ2V0SW5mbyk7CisgICAgICAgICAgICAg ICAgICAgICAgICB9OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAg IGlmIChwcm9wID09PSAidGFyZ2V0RGVzdHJveWVkIikgeworICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIHRhcmdldElkID0+IHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbnNw ZWN0b3JUZXN0LnBhc3MoYHJlY2VpdmVkICR7cHJvcH0gZXZlbnQuYCk7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgSW5zcGVjdG9yVGVzdC5leHBlY3RFcXVhbCh0YXJnZXRJZCwgbWFpblRh cmdldElkLCAiZGVzdHJveWVkIHRhcmdldCBpcyBwcmV2aW9zIHRhcmdldC4iKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZXNvbHZlKCk7CisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIHRhcmdldFtwcm9wXS5jYWxsKHJlY2VpdmVyLCB0YXJnZXRJZCk7CisgICAgICAg ICAgICAgICAgICAgICAgICB9OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgICAgIHJldHVybiB0YXJnZXRbcHJvcF07CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgfSk7CisgICAgICAgICAgICBjb25zdCBydW50aW1lQWdlbnQgPSBJbnNwZWN0b3JCYWNrZW5k LmRvbWFpbnMuUnVudGltZTsKKyAgICAgICAgICAgIHJ1bnRpbWVBZ2VudC5ldmFsdWF0ZSgibG9j YXRpb24uaG9zdG5hbWU9J2xvY2FsaG9zdCciKTsKKyAgICAgICAgfQorICAgIH0pOworCisgICAg c3VpdGUucnVuVGVzdENhc2VzQW5kRmluaXNoKCk7Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxi b2R5IG9ubG9hZD0icnVuVGVzdCgpIj4KKzxwPlRlc3QgdGhhdCBjcm9zcyBkb21haW4gbmF2aWdh dGlvbiByZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgc2VxdWVuY2Ugb2YgZXZlbnRzIGluIFRhcmdl dCBkb21haW46CisgIDEuIFRhcmdldC50YXJnZXRDcmVhdGVkIGZvciBwcm92aXNpb25hbCBwYWdl LgorICAyLiBUYXJnZXQuZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQgd2hlbiBwcm92aXNpb25h bCBsb2FkIGlzIGNvbW1pdHRlZC4KKyAgMy4gVGFyZ2V0LnRhcmdldERlc3Ryb3llZCBmb3IgdGhl IG9sZCB0YXJnZXQgYWZ0ZXIgdGhlIG5hdmlnYXRpb24gcmVxdWVzdCBpcyBjb21taXR0ZWQuCis8 L3A+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93 azIvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3drMi9UZXN0RXhwZWN0 YXRpb25zCmluZGV4IGUzZmFiYmQzMWJkMTE2Mzc5MjA0N2Q2MzJjYzhhZjZlMDEwODEzNGEuLjMw ZDg4MWFjODQ0OTE0MmFkYTIzYThhZWYyMjFkMWE0NDI5YmQyZmIgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL3drMi9UZXN0RXhwZWN0YXRpb25zCisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL3drMi9UZXN0RXhwZWN0YXRpb25zCkBAIC03NjQsNiArNzY0LDkgQEAgZmFzdC9mb3Jt cy9jYWxsLXRleHQtZGlkLWNoYW5nZS1pbi10ZXh0LWZpZWxkLXdoZW4tdHlwaW5nLmh0bWwgWyBQ YXNzIF0KIAogaHR0cC90ZXN0cy9hZENsaWNrQXR0cmlidXRpb24gWyBQYXNzIF0KIAorIyBUYXJn ZXQgZG9tYWluIGlzIG9ubHkgcHJlc2VudCBpbiBXZWJLaXQyLgoraHR0cC90ZXN0cy9pbnNwZWN0 b3IvdGFyZ2V0IFsgUGFzcyBdCisKICMjIyBFTkQgT0YgKDUpIFByb2dyZXNzaW9ucywgZXhwZWN0 ZWQgc3VjY2Vzc2VzIHRoYXQgYXJlIGV4cGVjdGVkIGZhaWx1cmVzIGluIFdlYktpdDEuCiAjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAK 380442 2019-10-08 10:47:24 -0700 2019-10-08 16:56:48 -0700 Patch bug-202219-20191008104724.patch text/plain 81151 yurys U3VidmVyc2lvbiBSZXZpc2lvbjogMjUwNzg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBi NmRhN2VjOTI2NzJhZTg5YTIwM2VjNzllYmM5YTliYjIzZjNhMTA3Li5jMGQ5M2VjYTAzNmRjMGJm ZGFhYjE1ZmM4NTQwMmUxYzViM2Q0Mzg5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyOCBAQAorMjAxOS0wOS0yNyAgWXVyeSBTZW1pa2hhdHNreSAgPHl1cnlzQGNocm9taXVt Lm9yZz4KKworICAgICAgICBXZWIgSW5zcGVjdG9yOiBhdHRhY2ggdG8gcHJvdmlzaW9uYWwgcGFn ZXMgZWFybHkgdG8gbm90IG1pc3MgZXZlbnRzIGR1cmluZyBwcm9jZXNzIHN3YXBzIChQU09OKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAyMjE5CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBpbnNwZWN0 b3IvSW5zcGVjdG9yVGFyZ2V0Lmg6IGNoYW5nZWQgSW5zcGVjdG9yVGFyZ2V0IHRvIG5vdCByZXF1 aXJlIEZyb250ZW5kQ2hhbm5lbCBhcworICAgICAgICBhbGwgbWVzc2FnZXMgYXJlIHJvdXRlZCBi eSBtZWFucyBvZiB0aGUgb3duaW5nIEluc3BlY3RvclRhcmdldEFnZW50LgorICAgICAgICAqIGlu c3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6SW5zcGVjdG9yVGFyZ2V0QWdlbnQpOgorICAgICAg ICAoSW5zcGVjdG9yOjpidWlsZFRhcmdldEluZm9PYmplY3QpOgorICAgICAgICAoSW5zcGVjdG9y OjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6dGFyZ2V0Q3JlYXRlZCk6CisgICAgICAgIChJbnNwZWN0 b3I6Okluc3BlY3RvclRhcmdldEFnZW50Ojp0YXJnZXREZXN0cm95ZWQpOgorICAgICAgICAoSW5z cGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQp OiB0aGlzIG1ldGhvZCBpcyB1c2VkIHRvCisgICAgICAgIG5vdGlmeSBmcm9udGVuZCB0aGF0IGNv cnJlc3BvbmRpbmcgcHJvdmlzaW9uYWwgdGFyZ2V0IGhhcyBjb21taXR0ZWQgYW5kIHJlcGxhY2Vk IHByZXZpb3VzCisgICAgICAgIHRhcmdldC4KKyAgICAgICAgKEluc3BlY3Rvcjo6SW5zcGVjdG9y VGFyZ2V0QWdlbnQ6OmNvbm5lY3Rpb25UeXBlIGNvbnN0KToKKyAgICAgICAgKEluc3BlY3Rvcjo6 SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmNvbm5lY3RUb1RhcmdldHMpOgorICAgICAgICAoSW5zcGVj dG9yOjpJbnNwZWN0b3JUYXJnZXRBZ2VudDo6ZGlzY29ubmVjdEZyb21UYXJnZXRzKToKKyAgICAg ICAgKiBpbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50Lmg6CisgICAgICAgICog aW5zcGVjdG9yL3Byb3RvY29sL1RhcmdldC5qc29uOiBleHRlbmRlZCBUYXJnZXRJbmZvIHdpdGgg cHJvdmlzaW9uYWwgcGFnZSBkZXRhaWxzIGFuZAorICAgICAgICBhZGRlZCBldmVudCB3aGljaCBp cyBmaXJlZCB3aGVuIHByb3Zpc2lvbmFsIHBhZ2UgZ2V0cyBjb21taXR0ZWQuIElmIHByb3Zpc2lv bmFsCisgICAgICAgIGxvYWQgZmFpbHMgdGhlcmUgd2lsbCBiZSB0YXJnZXREZXN0cm95ZWQgZXZl bnQgd2l0aG91dCBjb3JyZXNwb25kaW5nIGNvbW1pdC4KKwogMjAxOS0xMC0wNyAgTWF0dCBMZXdp cyAgPGpsZXdpczNAYXBwbGUuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0 IHIyNTA3NTAuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjc4Y2E3YjJhOTE3NDNhZjRhYmE2ZmJjNjg3YTBhNTVl YTJkYjUyYi4uNDY5NWNlNmExOWUxYzY2NDk5MDhhZTc1NjZhY2ZlMTM0NzQ3NjI0MiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE5LTEwLTAxICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVy eXNAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92 aXNpb25hbCBwYWdlcyBlYXJseSB0byBub3QgbWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dh cHMgKFBTT04pCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMDIyMTkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBUZXN0OiBodHRwL3Rlc3RzL2luc3BlY3Rvci90YXJnZXQvdGFyZ2V0LWV2ZW50cy1mb3ItcHJv aXNpb25hbC1wYWdlLmh0bWwKKworICAgICAgICAqIGluc3BlY3Rvci9JbnNwZWN0b3JDb250cm9s bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc3BlY3RvckNvbnRyb2xsZXI6OnNldElzVW5k ZXJUZXN0KTogVGhpcyBtZXRob2QgbWF5IGJlIGNhbGxlZCBzZXZlcmFsIHRpbWVzCisgICAgICAg IHdoZW4gcmVsb2FkaW5nIGluc3BlY3RlZCBwYWdlIHdpdGggb3BlbmVkIGZyb250ZW5kIHNvIHRo ZSBhc3N1bXB0aW9uIHRoYXQgdGhlcmUgYXJlIG5vCisgICAgICAgIGNvbm5lY3RlZCBmcm9udGVu ZHMgd2hlbiB0aGlzIG1ldGhvZCBpcyBjYWxsZWQgZnJvbSB0ZXN0cyBkb2Vzbid0IGhvbGQgYW55 bW9yZS4KKyAgICAgICAgKiBpbnNwZWN0b3IvSW5zcGVjdG9yQ29udHJvbGxlci5oOiBJbmxpbmVk IGRlZmluaXRpb24gb2Ygc2V0SXNVbmRlclRlc3QuCisKIDIwMTktMTAtMDcgIFJ5b3N1a2UgTml3 YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgZm9jdXMgcHNldWRvIGNsYXNzIHNob3Vs ZCBtYXRjaCBhIHNoYWRvdyBob3N0IHdob3NlIHNoYWRvdyB0cmVlIGNvbnRhaW5zIHRoZSBmb2N1 c2VkIGVsZW1lbnQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IDc3MDI1YzIyMzM2MWQyYTFm ZjU0YjliYWQ3N2JiZjdkNzVhMGIxNWUuLmJjMTUxMzlhOWU5ODA5ZDNmZWQzMGQ3Njk3MzI4Zjg5 YzZiYjkyMDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYxIEBACisyMDE5 LTA5LTI3ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3JnPgorCisgICAgICAg IFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92aXNpb25hbCBwYWdlcyBlYXJseSB0byBub3Qg bWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dhcHMgKFBTT04pCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDIyMTkKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVcGRhdGVkIGZyb250ZW5kIGNvZGUgdG8g dW5kZXJzdGFuZCBwcm92aXNpb25hbCB0YXJnZXRzLiBGb3Igbm93IHRoZXJlIGFyZQorICAgICAg ICBubyBjaGFuZ2VzIGZyb250ZW5kIGJlaGF2aW9yLCBpdCB3aWxsIHdhaXQgZm9yIHRoZSBwcm92 aXNpb25hbCB0YXJnZXQgdG8gY29tbWl0CisgICAgICAgIGFuZCB3aWxsIG5vdCBzZW5kIGFueSBj b21tYW5kcyB0byBpdCBiZWZvcmUgdGhhdC4KKworICAgICAgICAqIFVzZXJJbnRlcmZhY2UvQmFz ZS9NYWluLmpzOiBNb3ZlZCBhIGJ1bmNoIG9mIG1ldGhvZHMgc2hhcmVkIGJldHdlZW4gTWFpbi5q cyBhbmQgVGVzdC5qcworICAgICAgICB0byBUYXJnZXRNYW5hZ2VyLmpzIHRvIGtlZXAgdGhlbSBp biBzeW5jLgorICAgICAgICAqIFVzZXJJbnRlcmZhY2UvQ29udHJvbGxlcnMvVGFyZ2V0TWFuYWdl ci5qczoKKyAgICAgICAgKFdJLlRhcmdldE1hbmFnZXIpOgorICAgICAgICAoV0kuVGFyZ2V0TWFu YWdlci5wcm90b3R5cGUucmVtb3ZlVGFyZ2V0KToKKyAgICAgICAgKFdJLlRhcmdldE1hbmFnZXIu cHJvdG90eXBlLmNyZWF0ZU11bHRpcGxleGluZ0JhY2tlbmRUYXJnZXQpOgorICAgICAgICAoV0ku VGFyZ2V0TWFuYWdlci5wcm90b3R5cGUuY3JlYXRlRGlyZWN0QmFja2VuZFRhcmdldCk6CisgICAg ICAgIChXSS5UYXJnZXRNYW5hZ2VyLnByb3RvdHlwZS50YXJnZXRDcmVhdGVkKToKKyAgICAgICAg KFdJLlRhcmdldE1hbmFnZXIucHJvdG90eXBlLmRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KToK KyAgICAgICAgKFdJLlRhcmdldE1hbmFnZXIucHJvdG90eXBlLnRhcmdldERlc3Ryb3llZCk6Cisg ICAgICAgIChXSS5UYXJnZXRNYW5hZ2VyLnByb3RvdHlwZS5kaXNwYXRjaE1lc3NhZ2VGcm9tVGFy Z2V0KToKKyAgICAgICAgKFdJLlRhcmdldE1hbmFnZXIucHJvdG90eXBlLl9jaGVja0FuZEhhbmRs ZVBhZ2VUYXJnZXRUcmFuc2l0aW9uKToKKyAgICAgICAgKFdJLlRhcmdldE1hbmFnZXIucHJvdG90 eXBlLl9jaGVja0FuZEhhbmRsZVBhZ2VUYXJnZXRUZXJtaW5hdGlvbik6CisgICAgICAgIChXSS5U YXJnZXRNYW5hZ2VyLnByb3RvdHlwZS5faW5pdGlhbGl6ZUJhY2tlbmRUYXJnZXQpOgorICAgICAg ICAoV0kuVGFyZ2V0TWFuYWdlci5wcm90b3R5cGUuX2luaXRpYWxpemVQYWdlVGFyZ2V0KToKKyAg ICAgICAgKFdJLlRhcmdldE1hbmFnZXIucHJvdG90eXBlLl90cmFuc2l0aW9uUGFnZVRhcmdldCk6 CisgICAgICAgIChXSS5UYXJnZXRNYW5hZ2VyLnByb3RvdHlwZS5fdGVybWluYXRlUGFnZVRhcmdl dCk6CisgICAgICAgIChXSS5UYXJnZXRNYW5hZ2VyLnByb3RvdHlwZS5fcmVzZXRNYWluRXhlY3V0 aW9uQ29udGV4dCk6CisgICAgICAgIChXSS5UYXJnZXRNYW5hZ2VyLnByb3RvdHlwZS5fcmVkaXJl Y3RHbG9iYWxBZ2VudHNUb0Nvbm5lY3Rpb24pOgorICAgICAgICAqIFVzZXJJbnRlcmZhY2UvUHJv dG9jb2wvQ29ubmVjdGlvbi5qczoKKyAgICAgICAgKEluc3BlY3RvckJhY2tlbmQuV29ya2VyQ29u bmVjdGlvbi5zZW5kTWVzc2FnZVRvQmFja2VuZCk6CisgICAgICAgIChJbnNwZWN0b3JCYWNrZW5k LldvcmtlckNvbm5lY3Rpb24pOgorICAgICAgICAoSW5zcGVjdG9yQmFja2VuZC5UYXJnZXRDb25u ZWN0aW9uLnNlbmRNZXNzYWdlVG9CYWNrZW5kKToKKyAgICAgICAgKEluc3BlY3RvckJhY2tlbmQu VGFyZ2V0Q29ubmVjdGlvbik6CisgICAgICAgICogVXNlckludGVyZmFjZS9Qcm90b2NvbC9UYXJn ZXQuanM6CisgICAgICAgIChXSS5UYXJnZXQucHJvdG90eXBlLmRlc3Ryb3kpOiBNYXJrIHRhcmdl dCBhcyBkZXN0cm95ZWQgdG8gZGlzdGluZ3Vpc2ggZXhwZWN0ZWQgY29tbWFuZCBlcnJvcnMgZnJv bQorICAgICAgICBnZW51aW5lIGZhaWx1cmVzLgorCisgICAgICAgIChXSS5UYXJnZXQucHJvdG90 eXBlLmlzRGVzdHJveWVkKToKKyAgICAgICAgKiBVc2VySW50ZXJmYWNlL1Byb3RvY29sL1Rhcmdl dE9ic2VydmVyLmpzOiBTaW5jZSB0aGUgZnJvbnQtZW5kIGRvZXNuJ3QKKyAgICAgICAgc2VuZCBj b21tYW5kcyB0byB0aGUgcHJvdmlzaW9uYWwgdGFyZ2V0cyB5ZXQsIGl0IGhhcyB0byBpZ25vcmUg YWxsIGFjdGl2aXRpZXMKKyAgICAgICAgcmVsYXRlZCB0byBwcm92aXNpb25hbCBwYWdlcy4gRm9y IHRoYXQgcmVhc29uIHdlIG5lZWQgdHdvIHNldHMgdG8ga2VlcCB0cmFjayBvZgorICAgICAgICAt IHByb3Zpc2lvbmFsIHBhZ2VzIHRoYXQgd2VyZSBkZXN0cm95ZWQgYW5kIG5ldmVyIGNvbW1pdHRl ZAorICAgICAgICAtIG9sZCBwYWdlcyB3aGljaCB3ZXJlIHJlcGxhY2VkIGJ5IGNvbW1pdHRlZCBw YWdlIGFuZCBmb3Igd2hpY2ggZm9sbG93aW5nIHRhcmdldERlc3Ryb3llZAorICAgICAgICBldmVu dCBzaG91bGQgYmUgaWdub3JlZAorICAgICAgICBCZXR0ZXIgc3VwcG9ydCBmb3IgcHJvdmlzaW9u YWwgdGFyZ2V0cyB3aWxsIGJlIGFkZGVkIHRvIGZyb250ZW5kIGluIGEgc2VwYXJhdGUgY2hhbmdl LgorICAgICAgICAoV0kuVGFyZ2V0T2JzZXJ2ZXIpOgorICAgICAgICAoV0kuVGFyZ2V0T2JzZXJ2 ZXIucHJvdG90eXBlLnRhcmdldENyZWF0ZWQpOgorICAgICAgICAoV0kuVGFyZ2V0T2JzZXJ2ZXIu cHJvdG90eXBlLmRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KTogRm9yIG5vdyBjb252ZXJ0IHRo ZSBldmVudCBpbnRvIGEgc3Vic2VxdWVuY2UKKyAgICAgICAgb2YgdGFyZ2V0RGVzdHJveWVkL3Rh cmdldENyZWF0ZWQgZXZlbnRzIHdoaWNoIG1hdGNoZXMgcHJldmlvdXMgYmVoYXZpb3IuCisKKyAg ICAgICAgKFdJLlRhcmdldE9ic2VydmVyLnByb3RvdHlwZS50YXJnZXREZXN0cm95ZWQpOgorICAg ICAgICAoV0kuVGFyZ2V0T2JzZXJ2ZXIucHJvdG90eXBlLmRpc3BhdGNoTWVzc2FnZUZyb21UYXJn ZXQpOgorICAgICAgICAqIFVzZXJJbnRlcmZhY2UvVGVzdC9UZXN0LmpzOgorICAgICAgICAoV0ku dHJhbnNpdGlvblBhZ2VUYXJnZXQpOgorICAgICAgICAoV0kudGVybWluYXRlUGFnZVRhcmdldCk6 CisKIDIwMTktMTAtMDIgIE5pa2l0YSBWYXNpbHlldiAgPG52YXNpbHlldkBhcHBsZS5jb20+CiAK ICAgICAgICAgV2ViIEluc3BlY3RvcjogU3R5bGVzOiBmb3IgcnVsZXMgdGhhdCBkb24ndCBtYXRj aCBzZWxlY3RlZCBub2RlLCBwcm9wZXJ0eSB2YWx1ZXMgYWx3YXlzIHNob3cgYXMgaW52YWxpZApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5n ZUxvZwppbmRleCA4YTIxNWRjOTk2NWVlMmU0OThhMjc0ZDA4ZTIwYWUyYTZjNjM1OWY1Li4yZjNl NDMxNTZjNmQ1MWQyYTA1ZDRjY2MwMjQ0MzUyMjc1ZDBjMGFkIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAtMSwzICsx LDc3IEBACisyMDE5LTA5LTI3ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92aXNpb25hbCBwYWdlcyBl YXJseSB0byBub3QgbWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dhcHMgKFBTT04pCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDIyMTkKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUYXJnZXQudGFyZ2V0 Q3JlYXRlZCBldmVudCBpcyBub3cgZ2VuZXJhdGVkIGZvciBwcm92aXNpb25hbCBwYWdlcyBhcyB3 ZWxsIGFzIGZvciByZWd1bGFyCisgICAgICAgIG9uZXMuIFRoaXMgaXMgdGhlIGZpcnN0IHN0ZXAg dG93YXJkIHJlYXR0YWNoaW5nIGluc3BlY3RvciBlYXJsaWVyIGR1cmluZyBQU09OLiBJbiB0aGUg ZnV0dXJlCisgICAgICAgIGlmIGRlYnVnZ2luZyBpcyBpbiBwcm9ncmVzcyB0aGUgcHJvdmlzaW9u YWwgdGFyZ2V0IChwYWdlKSB3aWxsIGJlIHBhdXNlZCB1bnRpbCBhIHNpZ25hbCBmcm9tCisgICAg ICAgIGluc3BlY3RvciBmcm9udGVuZC4gVGhpcyB3aWxsIGVuYWJsZSB0aGUgZnJvbnRlbmQgY29u ZmlndXJlIGFsbCBhZ2VudHMgYmVmb3JlIG5hdmlnYXRpb24gc3RhcnRzLgorCisgICAgICAgICog U291cmNlcy50eHQ6CisgICAgICAgICogVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmNw cDoKKyAgICAgICAgKFdlYktpdDo6SW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZSk6CisgICAg ICAgIChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5Ojpjb25uZWN0KToKKyAgICAgICAgKFdl YktpdDo6SW5zcGVjdG9yVGFyZ2V0UHJveHk6OmRpc2Nvbm5lY3QpOgorICAgICAgICAoV2ViS2l0 OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQpOgorICAg ICAgICAoV2ViS2l0OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6ZGlkQ29tbWl0UHJvdmlzaW9uYWxU YXJnZXQpOgorICAgICAgICAoV2ViS2l0OjpJbnNwZWN0b3JUYXJnZXRQcm94eTo6aXNQcm92aXNp b25hbCBjb25zdCk6CisgICAgICAgIChXZWJLaXQ6Okluc3BlY3RvclRhcmdldFByb3h5OjpwcmV2 aW91c1RhcmdldElEIGNvbnN0KToKKyAgICAgICAgKiBVSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0 UHJveHkuaDogVGFyZ2V0IHByb3h5IGNhbiBzdGFydCBhcyBhIHByb3Zpc2lvbmFsIHRhcmdldCAo d2l0aCBhIHBvaW50ZXIgdG8KKyAgICAgICAgUHJvdmlzaW9uYWxQYWdlUHJveHkpIGFuZCBsYXRl ciBlaXRoZXIgYmUgY29tbWl0dGVkIG9yIGRlc3Ryb3llZC4KKworICAgICAgICAqIFVJUHJvY2Vz cy9Qcm92aXNpb25hbFBhZ2VQcm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OlByb3Zpc2lvbmFs UGFnZVByb3h5OjpQcm92aXNpb25hbFBhZ2VQcm94eSk6CisgICAgICAgIChXZWJLaXQ6OlByb3Zp c2lvbmFsUGFnZVByb3h5Ojp+UHJvdmlzaW9uYWxQYWdlUHJveHkpOgorICAgICAgICAoV2ViS2l0 OjpQcm92aXNpb25hbFBhZ2VQcm94eTo6ZGlkUmVjZWl2ZU1lc3NhZ2UpOiBGb3J3YXJkIGluc3Bl Y3RvciBtZXNzYWdlcyB0byBwYXJlbnQgcGFnZSdzIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVy LgorICAgICAgICBTaW5jZSBlYWNoIFdlYlBhZ2UgaGFzIGEgdW5pcXVlIGlkZW50aWZpZXIgdGhl IHRhcmdldCBpZHMgd2lsbCBiZSBnbG9iYWxseSB1bmlxdWUgYW5kIHRoZXJlIGlzIG5vIHJpc2sg b2YgY29sbGlzaW9ucy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94 eS5oOgorICAgICAgICAoV2ViS2l0OjpQcm92aXNpb25hbFBhZ2VQcm94eTo6cGFnZSBjb25zdCk6 CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNwcDoKKyAg ICAgICAgKFdlYktpdDo6Z2V0VGFyZ2V0SUQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlcjo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIpOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6Y2xlYXJUYXJnZXRzKToKKyAgICAg ICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNyZWF0ZUluc3BlY3RvclRh cmdldCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkZXN0 cm95SW5zcGVjdG9yVGFyZ2V0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNv bnRyb2xsZXI6OmRpZENyZWF0ZVByb3Zpc2lvbmFsUGFnZSk6CisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWREZXN0cm95UHJvdmlzaW9uYWxQYWdlKToKKyAg ICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmRpZENvbW1pdFByb3Zp c2lvbmFsUGFnZSk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVy OjphZGRUYXJnZXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29udHJv bGxlci5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQu Y3BwOiBSZW1vdmVkLiBNZXJnZWQgdGhpcyBhZ2VudCBpbnRvIEluc3BlY3RvclRhcmdldEFnZW50 LgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaDogUmVt b3ZlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdl YktpdDo6bV9yZXNldFJlY2VudENyYXNoQ291bnRUaW1lcik6CisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2VQcm94eTo6ZmluaXNoQXR0YWNoaW5nVG9XZWJQcm9jZXNzKToKKyAgICAgICAgKFdlYktp dDo6V2ViUGFnZVByb3h5Ojpjb21taXRQcm92aXNpb25hbFBhZ2UpOgorICAgICAgICAqIFVJUHJv Y2Vzcy9XZWJQYWdlUHJveHkuaDogTW92ZWQgdGhlIHRhcmdldCBtYW5hZ2VtZW50IGxvZ2ljIGlu dG8gV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuCisgICAgICAgIFdlYlBhZ2VQcm94eS9Qcm92 aXNpb25hbFBhZ2VQcm94eSBhcmUgZXhwZWN0ZWQgdG8gbm90aWZpeSBpdCBhYm91dCBrZXkgbGlm ZWN5Y2xlIGV2ZW50cyBhbmQgYWxzbworICAgICAgICBmb3J3YXJkIHRvIGl0IG1lc3NhZ2VzIGZy b20gaW5zcGVjdG9yIGluIHRoZSBpbnNwZWN0ZWQgV2ViUHJvY2Vzcy4gSG93IGl0IHRyYW5zbGF0 ZXMgdG8gVGFyZ2V0CisgICAgICAgIGV2ZW50cyBpcyBpbnNwZWN0b3IncyBidXNpbmVzcy4KKwor ICAgICAgICAqIFdlYktpdC54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFdl YlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmNwcDoKKyAgICAgICAgKFdl YktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldDo6aWRlbnRpZmllciBjb25zdCk6CisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmNvbm5lY3QpOgorICAgICAgICAoV2Vi S2l0OjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjpkaXNjb25uZWN0KToKKyAgICAgICAgKFdlYktp dDo6V2ViUGFnZUluc3BlY3RvclRhcmdldDo6dG9UYXJnZXRJRCk6CisgICAgICAgICogV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaDogTWFkZSB0aGUgdGFyZ2V0IG93 biBmcm9udGVuZCBjaGFubmVsIGluc3RhbmNlIGFzIGl0J3MgdGhlCisgICAgICAgIG9ubHkgcGxh Y2Ugd2hlcmUgdGhlIHBhZ2Ugc3BlY2lmaWMgY2hhbm5lbCBpcyB1c2VkLgorCisgICAgICAgICog V2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OnJlbW92 ZVRhcmdldCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9s bGVyOjpjb25uZWN0SW5zcGVjdG9yKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3Rv clRhcmdldENvbnRyb2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0b3IpOgorICAgICAgICAqIFdlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5oOgorICAgICAg ICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFu bmVsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbDo6V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbCk6CisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWw6OnNlbmRNZXNz YWdlVG9Gcm9udGVuZCk6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNw ZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaDogVGhlIGNoYW5uZWwncyBsaWZldGltZSBpcyBt YW5hZ2VkIGJ5IG93bmluZworICAgICAgICB0YXJnZXQuIE5vIG5lZWQgdG8gcmVmZXJlbmNlIGNv dW50IGl0LgorCiAyMDE5LTEwLTA3ICBEZWFuIEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KIAog ICAgICAgICBQcm92aWRlIG9wdGlvbnMgZm9yIERUVFogdG8gaGFwcGVuIGluIG1vcmUgc2l0dWF0 aW9ucwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9JbnNwZWN0 b3JUYXJnZXQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yVGFy Z2V0LmgKaW5kZXggOWVkYWExZjQyMDk1ZjA2MmY0NWE4MTAzZmEyNzRiNTE1YjYyZjE4Yi4uYTY5 NDM3NzIwNDZmYWM5N2MwZjk1MThmMjg0ODdlYjk1ODlhMjZmMiAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL2luc3BlY3Rvci9JbnNwZWN0b3JUYXJnZXQuaAorKysgYi9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL0luc3BlY3RvclRhcmdldC5oCkBAIC00Nyw5ICs0Nywx MiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBTdHJpbmcgaWRlbnRpZmllcigpIGNvbnN0ID0gMDsK ICAgICB2aXJ0dWFsIEluc3BlY3RvclRhcmdldFR5cGUgdHlwZSgpIGNvbnN0ID0gMDsKIAorICAg IHZpcnR1YWwgYm9vbCBpc1Byb3Zpc2lvbmFsKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKyAg ICB2aXJ0dWFsIFN0cmluZyBwcmV2aW91c1RhcmdldElEKCkgY29uc3QgeyByZXR1cm4gU3RyaW5n KCk7IH0KKwogICAgIC8vIENvbm5lY3Rpb24gbWFuYWdlbWVudC4KLSAgICB2aXJ0dWFsIHZvaWQg Y29ubmVjdChGcm9udGVuZENoYW5uZWwmKSA9IDA7Ci0gICAgdmlydHVhbCB2b2lkIGRpc2Nvbm5l Y3QoRnJvbnRlbmRDaGFubmVsJikgPSAwOworICAgIHZpcnR1YWwgdm9pZCBjb25uZWN0KEZyb250 ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgZGlzY29u bmVjdCgpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgc2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQo Y29uc3QgU3RyaW5nJikgPSAwOwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwCmlu ZGV4IGM2YzZiZjgwNmUyZTI2YjE1NGJmOWNhNzJjMGNjYWU5NGY1MDNjYWEuLmMzMGEwMjkyYTBi N2NhZWI5NjViMWUyMDBhNjhiODBkYWE4ZWYyNWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50LmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2Vu dC5jcHAKQEAgLTMyLDYgKzMyLDcgQEAgbmFtZXNwYWNlIEluc3BlY3RvciB7CiAKIEluc3BlY3Rv clRhcmdldEFnZW50OjpJbnNwZWN0b3JUYXJnZXRBZ2VudChGcm9udGVuZFJvdXRlciYgZnJvbnRl bmRSb3V0ZXIsIEJhY2tlbmREaXNwYXRjaGVyJiBiYWNrZW5kRGlzcGF0Y2hlcikKICAgICA6IElu c3BlY3RvckFnZW50QmFzZSgiVGFyZ2V0Il9zKQorICAgICwgbV9yb3V0ZXIoZnJvbnRlbmRSb3V0 ZXIpCiAgICAgLCBtX2Zyb250ZW5kRGlzcGF0Y2hlcihtYWtlVW5pcXVlPFRhcmdldEZyb250ZW5k RGlzcGF0Y2hlcj4oZnJvbnRlbmRSb3V0ZXIpKQogICAgICwgbV9iYWNrZW5kRGlzcGF0Y2hlcihU YXJnZXRCYWNrZW5kRGlzcGF0Y2hlcjo6Y3JlYXRlKGJhY2tlbmREaXNwYXRjaGVyLCB0aGlzKSkK IHsKQEAgLTk2LDEwICs5NywxNSBAQCBzdGF0aWMgUHJvdG9jb2w6OlRhcmdldDo6VGFyZ2V0SW5m bzo6VHlwZSB0YXJnZXRUeXBlVG9Qcm90b2NvbFR5cGUoSW5zcGVjdG9yVGFyZwogCiBzdGF0aWMg UmVmPFByb3RvY29sOjpUYXJnZXQ6OlRhcmdldEluZm8+IGJ1aWxkVGFyZ2V0SW5mb09iamVjdChj b25zdCBJbnNwZWN0b3JUYXJnZXQmIHRhcmdldCkKIHsKLSAgICByZXR1cm4gUHJvdG9jb2w6OlRh cmdldDo6VGFyZ2V0SW5mbzo6Y3JlYXRlKCkKKyAgICBhdXRvIHJlc3VsdCA9IFByb3RvY29sOjpU YXJnZXQ6OlRhcmdldEluZm86OmNyZWF0ZSgpCiAgICAgICAgIC5zZXRUYXJnZXRJZCh0YXJnZXQu aWRlbnRpZmllcigpKQogICAgICAgICAuc2V0VHlwZSh0YXJnZXRUeXBlVG9Qcm90b2NvbFR5cGUo dGFyZ2V0LnR5cGUoKSkpCiAgICAgICAgIC5yZWxlYXNlKCk7CisgICAgaWYgKHRhcmdldC5pc1By b3Zpc2lvbmFsKCkpIHsKKyAgICAgICAgcmVzdWx0LT5zZXRJc1Byb3Zpc2lvbmFsKHRydWUpOwor ICAgICAgICByZXN1bHQtPnNldFByZXZpb3VzVGFyZ2V0SWQodGFyZ2V0LnByZXZpb3VzVGFyZ2V0 SUQoKSk7CisgICAgfQorICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIHZvaWQgSW5zcGVjdG9yVGFy Z2V0QWdlbnQ6OnRhcmdldENyZWF0ZWQoSW5zcGVjdG9yVGFyZ2V0JiB0YXJnZXQpCkBAIC0xMTAs NyArMTE2LDcgQEAgdm9pZCBJbnNwZWN0b3JUYXJnZXRBZ2VudDo6dGFyZ2V0Q3JlYXRlZChJbnNw ZWN0b3JUYXJnZXQmIHRhcmdldCkKICAgICBpZiAoIW1faXNDb25uZWN0ZWQpCiAgICAgICAgIHJl dHVybjsKIAotICAgIHRhcmdldC5jb25uZWN0KGZyb250ZW5kQ2hhbm5lbCgpKTsKKyAgICB0YXJn ZXQuY29ubmVjdChjb25uZWN0aW9uVHlwZSgpKTsKIAogICAgIG1fZnJvbnRlbmREaXNwYXRjaGVy LT50YXJnZXRDcmVhdGVkKGJ1aWxkVGFyZ2V0SW5mb09iamVjdCh0YXJnZXQpKTsKIH0KQEAgLTEy MiwyNyArMTI4LDQyIEBAIHZvaWQgSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OnRhcmdldERlc3Ryb3ll ZChJbnNwZWN0b3JUYXJnZXQmIHRhcmdldCkKICAgICBpZiAoIW1faXNDb25uZWN0ZWQpCiAgICAg ICAgIHJldHVybjsKIAotICAgIHRhcmdldC5kaXNjb25uZWN0KGZyb250ZW5kQ2hhbm5lbCgpKTsK KyAgICB0YXJnZXQuZGlzY29ubmVjdCgpOwogCiAgICAgbV9mcm9udGVuZERpc3BhdGNoZXItPnRh cmdldERlc3Ryb3llZCh0YXJnZXQuaWRlbnRpZmllcigpKTsKIH0KIAotdm9pZCBJbnNwZWN0b3JU YXJnZXRBZ2VudDo6Y29ubmVjdFRvVGFyZ2V0cygpCit2b2lkIEluc3BlY3RvclRhcmdldEFnZW50 OjpkaWRDb21taXRQcm92aXNpb25hbFRhcmdldChjb25zdCBTdHJpbmcmIG9sZFRhcmdldElELCBj b25zdCBTdHJpbmcmIGNvbW1pdHRlZFRhcmdldElEKQoreworICAgIGlmICghbV9pc0Nvbm5lY3Rl ZCkKKyAgICAgICAgcmV0dXJuOworCisgICAgYXV0byogdGFyZ2V0ID0gbV90YXJnZXRzLmdldChj b21taXR0ZWRUYXJnZXRJRCk7CisgICAgaWYgKCF0YXJnZXQpCisgICAgICAgIHJldHVybjsKKwor ICAgIGF1dG8gdGFyZ2V0SW5mbyA9IGJ1aWxkVGFyZ2V0SW5mb09iamVjdCgqdGFyZ2V0KTsKKyAg ICB0YXJnZXRJbmZvLT5zZXRQcmV2aW91c1RhcmdldElkKG9sZFRhcmdldElEKTsKKyAgICBtX2Zy b250ZW5kRGlzcGF0Y2hlci0+ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQoV1RGTW92ZSh0YXJn ZXRJbmZvKSk7Cit9CisKK0Zyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgSW5zcGVjdG9y VGFyZ2V0QWdlbnQ6OmNvbm5lY3Rpb25UeXBlKCkgY29uc3QKIHsKLSAgICBhdXRvJiBjaGFubmVs ID0gZnJvbnRlbmRDaGFubmVsKCk7CisgICAgcmV0dXJuIG1fcm91dGVyLmhhc0xvY2FsRnJvbnRl bmQoKSA/IEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZTo6TG9jYWwg OiBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGU6OlJlbW90ZTsKK30K IAordm9pZCBJbnNwZWN0b3JUYXJnZXRBZ2VudDo6Y29ubmVjdFRvVGFyZ2V0cygpCit7CiAgICAg Zm9yIChJbnNwZWN0b3JUYXJnZXQqIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkgewotICAg ICAgICB0YXJnZXQtPmNvbm5lY3QoY2hhbm5lbCk7CisgICAgICAgIHRhcmdldC0+Y29ubmVjdChj b25uZWN0aW9uVHlwZSgpKTsKICAgICAgICAgbV9mcm9udGVuZERpc3BhdGNoZXItPnRhcmdldENy ZWF0ZWQoYnVpbGRUYXJnZXRJbmZvT2JqZWN0KCp0YXJnZXQpKTsKICAgICB9CiB9CiAKIHZvaWQg SW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmRpc2Nvbm5lY3RGcm9tVGFyZ2V0cygpCiB7Ci0gICAgYXV0 byYgY2hhbm5lbCA9IGZyb250ZW5kQ2hhbm5lbCgpOwotCiAgICAgZm9yIChJbnNwZWN0b3JUYXJn ZXQqIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkKLSAgICAgICAgdGFyZ2V0LT5kaXNjb25u ZWN0KGNoYW5uZWwpOworICAgICAgICB0YXJnZXQtPmRpc2Nvbm5lY3QoKTsKIH0KIAogfSAvLyBu YW1lc3BhY2UgSW5zcGVjdG9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5z cGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL2luc3BlY3Rvci9hZ2VudHMvSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaAppbmRleCAwMGZjM2Iw MjE3MzQ0YmU0Y2RmZjc5MTFjMjEzNzE4YzViOTVjZWUzLi5hNDViODMyODliZDU4YTQ2MTQ4Mjg2 M2VkZDUwYTIyNjg1NGIwODgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5z cGVjdG9yL2FnZW50cy9JbnNwZWN0b3JUYXJnZXRBZ2VudC5oCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9pbnNwZWN0b3IvYWdlbnRzL0luc3BlY3RvclRhcmdldEFnZW50LmgKQEAgLTI3LDYg KzI3LDcgQEAKIAogI2luY2x1ZGUgIkluc3BlY3RvckFnZW50QmFzZS5oIgogI2luY2x1ZGUgIklu c3BlY3RvckJhY2tlbmREaXNwYXRjaGVycy5oIgorI2luY2x1ZGUgIkluc3BlY3RvckZyb250ZW5k Q2hhbm5lbC5oIgogI2luY2x1ZGUgIkluc3BlY3RvckZyb250ZW5kRGlzcGF0Y2hlcnMuaCIKICNp bmNsdWRlIDx3dGYvRm9yd2FyZC5oPgogCkBAIC00MCw2ICs0MSw3IEBAIGNsYXNzIEpTX0VYUE9S VF9QUklWQVRFIEluc3BlY3RvclRhcmdldEFnZW50IDogcHVibGljIEluc3BlY3RvckFnZW50QmFz ZSwgcHVibGljCiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoSW5zcGVjdG9yVGFyZ2V0QWdlbnQp OwogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgorICAgIEluc3BlY3RvclRh cmdldEFnZW50KEZyb250ZW5kUm91dGVyJiwgQmFja2VuZERpc3BhdGNoZXImKTsKICAgICB2aXJ0 dWFsIH5JbnNwZWN0b3JUYXJnZXRBZ2VudCgpOwogCiAgICAgLy8gSW5zcGVjdG9yQWdlbnRCYXNl CkBAIC01MywxOSArNTUsMTggQEAgcHVibGljOgogICAgIC8vIFRhcmdldCBsaWZlY3ljbGUuCiAg ICAgdm9pZCB0YXJnZXRDcmVhdGVkKEluc3BlY3RvclRhcmdldCYpOwogICAgIHZvaWQgdGFyZ2V0 RGVzdHJveWVkKEluc3BlY3RvclRhcmdldCYpOworICAgIHZvaWQgZGlkQ29tbWl0UHJvdmlzaW9u YWxUYXJnZXQoY29uc3QgU3RyaW5nJiBvbGRUYXJnZXRJRCwgY29uc3QgU3RyaW5nJiBjb21taXR0 ZWRUYXJnZXRJRCk7CiAKICAgICAvLyBUYXJnZXQgbWVzc2FnZXMuCiAgICAgdm9pZCBzZW5kTWVz c2FnZUZyb21UYXJnZXRUb0Zyb250ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0 cmluZyYgbWVzc2FnZSk7CiAKLXByb3RlY3RlZDoKLSAgICBJbnNwZWN0b3JUYXJnZXRBZ2VudChG cm9udGVuZFJvdXRlciYsIEJhY2tlbmREaXNwYXRjaGVyJik7Ci0KLSAgICB2aXJ0dWFsIEZyb250 ZW5kQ2hhbm5lbCYgZnJvbnRlbmRDaGFubmVsKCkgPSAwOwotCiBwcml2YXRlOgorICAgIC8vIEZy b250ZW5kQ2hhbm5lbAorICAgIEZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgY29ubmVj dGlvblR5cGUoKSBjb25zdDsKICAgICB2b2lkIGNvbm5lY3RUb1RhcmdldHMoKTsKICAgICB2b2lk IGRpc2Nvbm5lY3RGcm9tVGFyZ2V0cygpOwogCisgICAgSW5zcGVjdG9yOjpGcm9udGVuZFJvdXRl ciYgbV9yb3V0ZXI7CiAgICAgc3RkOjp1bmlxdWVfcHRyPFRhcmdldEZyb250ZW5kRGlzcGF0Y2hl cj4gbV9mcm9udGVuZERpc3BhdGNoZXI7CiAgICAgUmVmPFRhcmdldEJhY2tlbmREaXNwYXRjaGVy PiBtX2JhY2tlbmREaXNwYXRjaGVyOwogICAgIEhhc2hNYXA8U3RyaW5nLCBJbnNwZWN0b3JUYXJn ZXQqPiBtX3RhcmdldHM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVj dG9yL3Byb3RvY29sL1RhcmdldC5qc29uIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2luc3BlY3Rv ci9wcm90b2NvbC9UYXJnZXQuanNvbgppbmRleCA2MWFkMjY5ZDk1ZTE4ZmQ1OWRhNTVjN2MzZWY3 ZDVkMTRhZDEzMmRhLi42MjY5Nzk3OTg4YzIyNmMyZjcyYzMxYzM4MzczY2Q4NDhlMzE2Mzc0IDEw MDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaW5zcGVjdG9yL3Byb3RvY29sL1Rhcmdl dC5qc29uCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9pbnNwZWN0b3IvcHJvdG9jb2wvVGFy Z2V0Lmpzb24KQEAgLTgsNyArOCw5IEBACiAgICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiRGVz Y3JpcHRpb24gb2YgYSB0YXJnZXQuIiwKICAgICAgICAgICAgICJwcm9wZXJ0aWVzIjogWwogICAg ICAgICAgICAgICAgIHsgIm5hbWUiOiAidGFyZ2V0SWQiLCAidHlwZSI6ICJzdHJpbmciLCAiZGVz Y3JpcHRpb24iOiAiVW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSB0YXJnZXQuIiB9LAotICAgICAg ICAgICAgICAgIHsgIm5hbWUiOiAidHlwZSIsICJ0eXBlIjogInN0cmluZyIsICJlbnVtIjogWyJq YXZhc2NyaXB0IiwgInBhZ2UiLCAid29ya2VyIiwgInNlcnZpY2V3b3JrZXIiXSB9CisgICAgICAg ICAgICAgICAgeyAibmFtZSI6ICJ0eXBlIiwgInR5cGUiOiAic3RyaW5nIiwgImVudW0iOiBbImph dmFzY3JpcHQiLCAicGFnZSIsICJ3b3JrZXIiLCAic2VydmljZXdvcmtlciJdIH0sCisgICAgICAg ICAgICAgICAgeyAibmFtZSI6ICJpc1Byb3Zpc2lvbmFsIiwgInR5cGUiOiAiYm9vbGVhbiIsICJv cHRpb25hbCI6IHRydWUsICJkZXNjcmlwdGlvbiI6ICJXaGV0aGVyIHRoaXMgaXMgYSBwcm92aXNp b25hbCBwYWdlIHRhcmdldC4iIH0sCisgICAgICAgICAgICAgICAgeyAibmFtZSI6ICJwcmV2aW91 c1RhcmdldElkIiwgInR5cGUiOiAic3RyaW5nIiwgIm9wdGlvbmFsIjogdHJ1ZSwgImRlc2NyaXB0 aW9uIjogIkZvciBhIHByb3Zpc2lvbmFsIHRhcmdldCByZXByZXNlbnMgSUQgb2YgdGhlIHRhcmdl dCBpdCBpcyBzd2FwcGVkIHdpdGggd2hlbiBjb21taXR0ZWQuIiB9CiAgICAgICAgICAgICBdCiAg ICAgICAgIH0KICAgICBdLApAQCAtMzksNiArNDEsMTIgQEAKICAgICAgICAgICAgICAgICB7ICJu YW1lIjogInRhcmdldElkIiwgInR5cGUiOiAic3RyaW5nIiB9CiAgICAgICAgICAgICBdCiAgICAg ICAgIH0sCisgICAgICAgIHsKKyAgICAgICAgICAgICJuYW1lIjogImRpZENvbW1pdFByb3Zpc2lv bmFsVGFyZ2V0IiwKKyAgICAgICAgICAgICJwYXJhbWV0ZXJzIjogWworICAgICAgICAgICAgICAg IHsgIm5hbWUiOiAidGFyZ2V0SW5mbyIsICIkcmVmIjogIlRhcmdldEluZm8iLCAiZGVzY3JpcHRp b24iOiAiQ29tbWl0dGVkIHRhcmdldCBpbmZvLiIgfQorICAgICAgICAgICAgXQorICAgICAgICB9 LAogICAgICAgICB7CiAgICAgICAgICAgICAibmFtZSI6ICJkaXNwYXRjaE1lc3NhZ2VGcm9tVGFy Z2V0IiwKICAgICAgICAgICAgICJwYXJhbWV0ZXJzIjogWwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaW5zcGVjdG9yL0luc3BlY3RvckNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUv aW5zcGVjdG9yL0luc3BlY3RvckNvbnRyb2xsZXIuY3BwCmluZGV4IGU2MTgwNWYzNmQ1ZjczYTUw NzQ0OTVkOWVhZjY4MTg5ZDZhOTMwNzAuLjY1ZGUyZjZmNGQ4YzFiYjFhMzhiMTFhNjk4ODk2NWQx Mjc3Yzg1NzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9JbnNwZWN0b3JD b250cm9sbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yQ29u dHJvbGxlci5jcHAKQEAgLTM0MywxNyArMzQzLDYgQEAgdm9pZCBJbnNwZWN0b3JDb250cm9sbGVy OjpzaG93KCkKICAgICAgICAgY29ubmVjdEZyb250ZW5kKCpmcm9udGVuZENoYW5uZWwpOwogfQog Ci12b2lkIEluc3BlY3RvckNvbnRyb2xsZXI6OnNldElzVW5kZXJUZXN0KGJvb2wgdmFsdWUpCi17 Ci0gICAgaWYgKHZhbHVlID09IG1faXNVbmRlclRlc3QpCi0gICAgICAgIHJldHVybjsKLQotICAg IG1faXNVbmRlclRlc3QgPSB2YWx1ZTsKLQotICAgIC8vIDxyZGFyOi8vcHJvYmxlbS8yNjc2ODYy OD4gVHJ5IHRvIGNhdGNoIHN1c3BpY2lvdXMgc2NlbmFyaW9zIHdoZXJlIHdlIG1heSBoYXZlIGEg ZGFuZ2xpbmcgZnJvbnRlbmQgd2hpbGUgcnVubmluZyB0ZXN0cy4KLSAgICBSRUxFQVNFX0FTU0VS VCghbV9pc1VuZGVyVGVzdCB8fCAhbV9mcm9udGVuZFJvdXRlci0+aGFzRnJvbnRlbmRzKCkpOwot fQotCiB2b2lkIEluc3BlY3RvckNvbnRyb2xsZXI6OmV2YWx1YXRlRm9yVGVzdEluRnJvbnRlbmQo Y29uc3QgU3RyaW5nJiBzY3JpcHQpCiB7CiAgICAgZW5zdXJlSW5zcGVjdG9yQWdlbnQoKS5ldmFs dWF0ZUZvclRlc3RJbkZyb250ZW5kKHNjcmlwdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9pbnNwZWN0b3IvSW5zcGVjdG9yQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvaW5zcGVj dG9yL0luc3BlY3RvckNvbnRyb2xsZXIuaAppbmRleCA0YmVhNDMyNjNkYTcwMzdmMTg4NjU5NjYy ZGE4ZGJmNmQ4MzE1OTZkLi44ZDg2NGNhZmJlNGQ0NThlZWEzNzRkMDI0ZWIxMzMyZWIyMzQwMDky IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvSW5zcGVjdG9yQ29udHJvbGxl ci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9JbnNwZWN0b3JDb250cm9sbGVyLmgK QEAgLTEwMSw3ICsxMDEsNyBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBkaWRD b21wb3NpdGUoRnJhbWUmKTsKIAogICAgIGJvb2wgaXNVbmRlclRlc3QoKSBjb25zdCB7IHJldHVy biBtX2lzVW5kZXJUZXN0OyB9Ci0gICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBzZXRJc1VuZGVyVGVz dChib29sKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIHNldElzVW5kZXJUZXN0KGJvb2wgdmFs dWUpIHsgbV9pc1VuZGVyVGVzdCA9IHZhbHVlOyB9CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBl dmFsdWF0ZUZvclRlc3RJbkZyb250ZW5kKGNvbnN0IFN0cmluZyYgc2NyaXB0KTsKIAogICAgIElu c3BlY3RvckNsaWVudCogaW5zcGVjdG9yQ2xpZW50KCkgY29uc3QgeyByZXR1cm4gbV9pbnNwZWN0 b3JDbGllbnQ7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL0Jhc2UvTWFpbi5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0Jh c2UvTWFpbi5qcwppbmRleCBmMjQ2MTYyOTZlNDc4ZDI5NjM5ZWYyM2QxMTdkOGQyNzZlMGYzZWE4 Li4zNzIzOGUzYTE4NTA1MWEyMDgxZTYwZTA4MzFiODJmODE2NjQ4ZjI1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9CYXNlL01haW4uanMKKysrIGIvU291 cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQmFzZS9NYWluLmpzCkBAIC0xNzksODUg KzE3OSw2IEBAIFdJLmxvYWRlZCA9IGZ1bmN0aW9uKCkKICAgICB9CiB9OwogCi1XSS5pbml0aWFs aXplQmFja2VuZFRhcmdldCA9IGZ1bmN0aW9uKHRhcmdldCkKLXsKLSAgICBjb25zb2xlLmFzc2Vy dCghV0kubWFpblRhcmdldCk7Ci0KLSAgICBXSS5iYWNrZW5kVGFyZ2V0ID0gdGFyZ2V0OwotCi0g ICAgV0kucmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgpOwotCi0gICAgV0kuX3RhcmdldHNBdmFp bGFibGVQcm9taXNlLnJlc29sdmUoKTsKLX07Ci0KLVdJLmluaXRpYWxpemVQYWdlVGFyZ2V0ID0g ZnVuY3Rpb24odGFyZ2V0KQotewotICAgIGNvbnNvbGUuYXNzZXJ0KFdJLnNoYXJlZEFwcC5kZWJ1 Z2dhYmxlVHlwZSA9PT0gV0kuRGVidWdnYWJsZVR5cGUuV2ViKTsKLSAgICBjb25zb2xlLmFzc2Vy dCh0YXJnZXQudHlwZSA9PT0gV0kuVGFyZ2V0LlR5cGUuUGFnZSB8fCB0YXJnZXQgaW5zdGFuY2Vv ZiBXSS5EaXJlY3RCYWNrZW5kVGFyZ2V0KTsKLQotICAgIFdJLnBhZ2VUYXJnZXQgPSB0YXJnZXQ7 Ci0KLSAgICBXSS5yZWRpcmVjdEdsb2JhbEFnZW50c1RvQ29ubmVjdGlvbihXSS5wYWdlVGFyZ2V0 LmNvbm5lY3Rpb24pOwotCi0gICAgV0kucmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgpOwotfTsK LQotV0kudHJhbnNpdGlvblBhZ2VUYXJnZXQgPSBmdW5jdGlvbih0YXJnZXQpCi17Ci0gICAgY29u c29sZS5hc3NlcnQoIVdJLnBhZ2VUYXJnZXQpOwotICAgIGNvbnNvbGUuYXNzZXJ0KFdJLnNoYXJl ZEFwcC5kZWJ1Z2dhYmxlVHlwZSA9PT0gV0kuRGVidWdnYWJsZVR5cGUuV2ViKTsKLSAgICBjb25z b2xlLmFzc2VydCh0YXJnZXQudHlwZSA9PT0gV0kuVGFyZ2V0LlR5cGUuUGFnZSk7Ci0KLSAgICBX SS5wYWdlVGFyZ2V0ID0gdGFyZ2V0OwotCi0gICAgV0kucmVkaXJlY3RHbG9iYWxBZ2VudHNUb0Nv bm5lY3Rpb24oV0kucGFnZVRhcmdldC5jb25uZWN0aW9uKTsKLQotICAgIFdJLnJlc2V0TWFpbkV4 ZWN1dGlvbkNvbnRleHQoKTsKLQotICAgIC8vIEFjdGlvbnMgdG8gdHJhbnNpdGlvbiB0aGUgcGFn ZSB0YXJnZXQuCi0gICAgV0kubm90aWZpY2F0aW9ucy5kaXNwYXRjaEV2ZW50VG9MaXN0ZW5lcnMo V0kuTm90aWZpY2F0aW9uLlRyYW5zaXRpb25QYWdlVGFyZ2V0KTsKLSAgICBXSS5kb21NYW5hZ2Vy LnRyYW5zaXRpb25QYWdlVGFyZ2V0KCk7Ci0gICAgV0kubmV0d29ya01hbmFnZXIudHJhbnNpdGlv blBhZ2VUYXJnZXQoKTsKLSAgICBXSS50aW1lbGluZU1hbmFnZXIudHJhbnNpdGlvblBhZ2VUYXJn ZXQoKTsKLX07Ci0KLVdJLnRlcm1pbmF0ZVBhZ2VUYXJnZXQgPSBmdW5jdGlvbih0YXJnZXQpCi17 Ci0gICAgY29uc29sZS5hc3NlcnQoV0kucGFnZVRhcmdldCk7Ci0gICAgY29uc29sZS5hc3NlcnQo V0kucGFnZVRhcmdldCA9PT0gdGFyZ2V0KTsKLSAgICBjb25zb2xlLmFzc2VydChXSS5zaGFyZWRB cHAuZGVidWdnYWJsZVR5cGUgPT09IFdJLkRlYnVnZ2FibGVUeXBlLldlYik7Ci0KLSAgICAvLyBS ZW1vdmUgYW55IFdvcmtlciB0YXJnZXRzIGFzc29jaWF0ZWQgd2l0aCB0aGlzIHBhZ2UuCi0gICAg bGV0IHdvcmtlclRhcmdldHMgPSBXSS50YXJnZXRzLmZpbHRlcigoeCkgPT4geC50eXBlID09PSBX SS5UYXJnZXQuVHlwZS5Xb3JrZXIpOwotICAgIGZvciAobGV0IHdvcmtlclRhcmdldCBvZiB3b3Jr ZXJUYXJnZXRzKQotICAgICAgICBXSS53b3JrZXJNYW5hZ2VyLndvcmtlclRlcm1pbmF0ZWQod29y a2VyVGFyZ2V0LmlkZW50aWZpZXIpOwotCi0gICAgV0kucGFnZVRhcmdldCA9IG51bGw7Ci0KLSAg ICBXSS5yZWRpcmVjdEdsb2JhbEFnZW50c1RvQ29ubmVjdGlvbihXSS5iYWNrZW5kQ29ubmVjdGlv bik7Ci19OwotCi1XSS5yZXNldE1haW5FeGVjdXRpb25Db250ZXh0ID0gZnVuY3Rpb24oKQotewot ICAgIGlmIChXSS5tYWluVGFyZ2V0IGluc3RhbmNlb2YgV0kuTXVsdGlwbGV4aW5nQmFja2VuZFRh cmdldCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgaWYgKFdJLm1haW5UYXJnZXQuZXhlY3V0aW9u Q29udGV4dCkgewotICAgICAgICBXSS5ydW50aW1lTWFuYWdlci5hY3RpdmVFeGVjdXRpb25Db250 ZXh0ID0gV0kubWFpblRhcmdldC5leGVjdXRpb25Db250ZXh0OwotICAgICAgICBpZiAoV0kucXVp Y2tDb25zb2xlKQotICAgICAgICAgICAgV0kucXVpY2tDb25zb2xlLmluaXRpYWxpemVNYWluRXhl Y3V0aW9uQ29udGV4dFBhdGhDb21wb25lbnQoKTsKLSAgICB9Ci19OwotCi1XSS5yZWRpcmVjdEds b2JhbEFnZW50c1RvQ29ubmVjdGlvbiA9IGZ1bmN0aW9uKGNvbm5lY3Rpb24pCi17Ci0gICAgLy8g VGhpcyBtYWtlcyBnbG9iYWwgd2luZG93LkZvb0FnZW50IGRpc3BhdGNoIHRvIHRoZSBhY3RpdmUg cGFnZSB0YXJnZXQuCi0gICAgZm9yIChsZXQgW2RvbWFpbiwgYWdlbnRdIG9mIE9iamVjdC5lbnRy aWVzKEluc3BlY3RvckJhY2tlbmQuX2FnZW50cykpIHsKLSAgICAgICAgaWYgKGRvbWFpbiAhPT0g IlRhcmdldCIpCi0gICAgICAgICAgICBhZ2VudC5jb25uZWN0aW9uID0gY29ubmVjdGlvbjsKLSAg ICB9Ci19OwotCiBXSS5jb250ZW50TG9hZGVkID0gZnVuY3Rpb24oKQogewogICAgIC8vIElmIHRo ZXJlIHdhcyBhbiB1bmNhdWdodCBleGNlcHRpb24gZWFybGllciBkdXJpbmcgbG9hZGluZywgdGhl bgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQ29udHJv bGxlcnMvVGFyZ2V0TWFuYWdlci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL0NvbnRyb2xsZXJzL1RhcmdldE1hbmFnZXIuanMKaW5kZXggYTlmYTRkZTBlODNhNmI2NzE3 MzRiOGFlNmEzMGM4OGQzNWFjN2IxOC4uYjE1ODZjMTU2YTA2ZWYzMjJiYzM4MTk5NThlNzdjZmMz MjNkNGQ5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv Q29udHJvbGxlcnMvVGFyZ2V0TWFuYWdlci5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9Db250cm9sbGVycy9UYXJnZXRNYW5hZ2VyLmpzCkBAIC0zMyw2ICszMyw5 IEBAIFdJLlRhcmdldE1hbmFnZXIgPSBjbGFzcyBUYXJnZXRNYW5hZ2VyIGV4dGVuZHMgV0kuT2Jq ZWN0CiAgICAgICAgIHRoaXMuX2NhY2hlZFRhcmdldHNMaXN0ID0gbnVsbDsKICAgICAgICAgdGhp cy5fc2VlblBhZ2VUYXJnZXQgPSBmYWxzZTsKICAgICAgICAgdGhpcy5fdHJhbnNpdGlvblRpbWVv dXRJZGVudGlmaWVyID0gdW5kZWZpbmVkOworCisgICAgICAgIHRoaXMuX3Byb3Zpc2lvbmFsVGFy Z2V0SWRzID0gbmV3IFNldDsKKyAgICAgICAgdGhpcy5fc3dhcHBlZFRhcmdldElkcyA9IG5ldyBT ZXQ7CiAgICAgfQogCiAgICAgLy8gUHVibGljCkBAIC04MCw2ICs4Myw3IEBAIFdJLlRhcmdldE1h bmFnZXIgPSBjbGFzcyBUYXJnZXRNYW5hZ2VyIGV4dGVuZHMgV0kuT2JqZWN0CiAKICAgICAgICAg dGhpcy5fY2FjaGVkVGFyZ2V0c0xpc3QgPSBudWxsOwogICAgICAgICB0aGlzLl90YXJnZXRzLmRl bGV0ZSh0YXJnZXQuaWRlbnRpZmllcik7CisgICAgICAgIHRhcmdldC5kZXN0cm95KCk7CiAKICAg ICAgICAgdGhpcy5kaXNwYXRjaEV2ZW50VG9MaXN0ZW5lcnMoV0kuVGFyZ2V0TWFuYWdlci5FdmVu dC5UYXJnZXRSZW1vdmVkLCB7dGFyZ2V0fSk7CiAgICAgfQpAQCAtODksNyArOTMsNyBAQCBXSS5U YXJnZXRNYW5hZ2VyID0gY2xhc3MgVGFyZ2V0TWFuYWdlciBleHRlbmRzIFdJLk9iamVjdAogICAg ICAgICBsZXQgdGFyZ2V0ID0gbmV3IFdJLk11bHRpcGxleGluZ0JhY2tlbmRUYXJnZXQ7CiAgICAg ICAgIHRhcmdldC5pbml0aWFsaXplKCk7CiAKLSAgICAgICAgV0kuaW5pdGlhbGl6ZUJhY2tlbmRU YXJnZXQodGFyZ2V0KTsKKyAgICAgICAgdGhpcy5faW5pdGlhbGl6ZUJhY2tlbmRUYXJnZXQodGFy Z2V0KTsKIAogICAgICAgICAvLyBBZGQgdGhlIHRhcmdldCB3aXRob3V0IGRpc3BhdGNoaW5nIGFu IGV2ZW50LgogICAgICAgICB0aGlzLl90YXJnZXRzLnNldCh0YXJnZXQuaWRlbnRpZmllciwgdGFy Z2V0KTsKQEAgLTEwMCwxMCArMTA0LDEwIEBAIFdJLlRhcmdldE1hbmFnZXIgPSBjbGFzcyBUYXJn ZXRNYW5hZ2VyIGV4dGVuZHMgV0kuT2JqZWN0CiAgICAgICAgIGxldCB0YXJnZXQgPSBuZXcgV0ku RGlyZWN0QmFja2VuZFRhcmdldDsKICAgICAgICAgdGFyZ2V0LmluaXRpYWxpemUoKTsKIAotICAg ICAgICBXSS5pbml0aWFsaXplQmFja2VuZFRhcmdldCh0YXJnZXQpOworICAgICAgICB0aGlzLl9p bml0aWFsaXplQmFja2VuZFRhcmdldCh0YXJnZXQpOwogCiAgICAgICAgIGlmIChXSS5zaGFyZWRB cHAuZGVidWdnYWJsZVR5cGUgPT09IFdJLkRlYnVnZ2FibGVUeXBlLldlYikKLSAgICAgICAgICAg IFdJLmluaXRpYWxpemVQYWdlVGFyZ2V0KHRhcmdldCk7CisgICAgICAgICAgICB0aGlzLl9pbml0 aWFsaXplUGFnZVRhcmdldCh0YXJnZXQpOwogCiAgICAgICAgIHRoaXMuYWRkVGFyZ2V0KHRhcmdl dCk7CiAgICAgfQpAQCAtMTEyLDYgKzExNiwxMiBAQCBXSS5UYXJnZXRNYW5hZ2VyID0gY2xhc3Mg VGFyZ2V0TWFuYWdlciBleHRlbmRzIFdJLk9iamVjdAogCiAgICAgdGFyZ2V0Q3JlYXRlZCh0YXJn ZXRJbmZvKQogICAgIHsKKyAgICAgICAgLy8gQ09NUEFUSUJJTElUWSAoaU9TIDEzLjApOiBgVGFy Z2V0LlRhcmdldEluZm8uaXNQcm92aXNpb25hbGAgZGlkIG5vdCBleGlzdCB5ZXQuCisgICAgICAg IGlmICh0YXJnZXRJbmZvLmlzUHJvdmlzaW9uYWwpIHsKKyAgICAgICAgICAgIHRoaXMuX3Byb3Zp c2lvbmFsVGFyZ2V0SWRzLmFkZCh0YXJnZXRJbmZvLnRhcmdldElkKTsKKyAgICAgICAgICAgIHJl dHVybjsKKyAgICAgICAgfQorCiAgICAgICAgIC8vIEZJWE1FOiBFbGltaW5hdGUgdGhpcyBvbmNl IHRoZSBsb2NhbCBpbnNwZWN0b3IgaXMgY29uZmlndXJlZCB0byB1c2UKICAgICAgICAgLy8gdGhl IE11bHRpcGxleGluZyBjb2RlIHBhdGguIFRoZW4gd2UgY2FuIHBlcmZvcm0gdGhpcyBpbW1lZGlh dGVseQogICAgICAgICAvLyBpbiBgV0kubG9hZGVkYCBpZiBhIFRhcmdldEFnZW50IGV4aXN0cy4K QEAgLTEyNiw4ICsxMzYsMjEgQEAgV0kuVGFyZ2V0TWFuYWdlciA9IGNsYXNzIFRhcmdldE1hbmFn ZXIgZXh0ZW5kcyBXSS5PYmplY3QKICAgICAgICAgdGhpcy5hZGRUYXJnZXQodGFyZ2V0KTsKICAg ICB9CiAKKyAgICBkaWRDb21taXRQcm92aXNpb25hbFRhcmdldCh0YXJnZXRJbmZvKQorICAgIHsK KyAgICAgICAgdGhpcy50YXJnZXREZXN0cm95ZWQodGFyZ2V0SW5mby5wcmV2aW91c1RhcmdldElk KTsKKyAgICAgICAgdGhpcy50YXJnZXRDcmVhdGVkKHRhcmdldEluZm8pOworICAgICAgICB0aGlz Ll9zd2FwcGVkVGFyZ2V0SWRzLmFkZCh0YXJnZXRJbmZvLnByZXZpb3VzVGFyZ2V0SWQpOworICAg ICAgICB0aGlzLl9wcm92aXNpb25hbFRhcmdldElkcy5kZWxldGUodGFyZ2V0SW5mby50YXJnZXRJ ZCk7CisKKyAgICB9CisKICAgICB0YXJnZXREZXN0cm95ZWQodGFyZ2V0SWQpCiAgICAgeworICAg ICAgICBpZiAodGhpcy5fcHJvdmlzaW9uYWxUYXJnZXRJZHMuZGVsZXRlKHRhcmdldElkKSkKKyAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgaWYgKHRoaXMuX3N3YXBwZWRUYXJnZXRJZHMuZGVs ZXRlKHRhcmdldElkKSkKKyAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgbGV0IHRhcmdldCA9 IHRoaXMuX3RhcmdldHMuZ2V0KHRhcmdldElkKTsKICAgICAgICAgdGhpcy5fY2hlY2tBbmRIYW5k bGVQYWdlVGFyZ2V0VGVybWluYXRpb24odGFyZ2V0KTsKICAgICAgICAgdGhpcy5yZW1vdmVUYXJn ZXQodGFyZ2V0KTsKQEAgLTEzNSw2ICsxNTgsOCBAQCBXSS5UYXJnZXRNYW5hZ2VyID0gY2xhc3Mg VGFyZ2V0TWFuYWdlciBleHRlbmRzIFdJLk9iamVjdAogCiAgICAgZGlzcGF0Y2hNZXNzYWdlRnJv bVRhcmdldCh0YXJnZXRJZCwgbWVzc2FnZSkKICAgICB7CisgICAgICAgIGlmICh0aGlzLl9wcm92 aXNpb25hbFRhcmdldElkcy5oYXModGFyZ2V0SWQpKQorICAgICAgICAgICAgcmV0dXJuOwogICAg ICAgICBsZXQgdGFyZ2V0ID0gdGhpcy5fdGFyZ2V0cy5nZXQodGFyZ2V0SWQpOwogICAgICAgICBj b25zb2xlLmFzc2VydCh0YXJnZXQpOwogICAgICAgICBpZiAoIXRhcmdldCkKQEAgLTE3MSwxMiAr MTk2LDEyIEBAIFdJLlRhcmdldE1hbmFnZXIgPSBjbGFzcyBUYXJnZXRNYW5hZ2VyIGV4dGVuZHMg V0kuT2JqZWN0CiAgICAgICAgIC8vIEZpcnN0IHBhZ2UgdGFyZ2V0LgogICAgICAgICBpZiAoIVdJ LnBhZ2VUYXJnZXQgJiYgIXRoaXMuX3NlZW5QYWdlVGFyZ2V0KSB7CiAgICAgICAgICAgICB0aGlz Ll9zZWVuUGFnZVRhcmdldCA9IHRydWU7Ci0gICAgICAgICAgICBXSS5pbml0aWFsaXplUGFnZVRh cmdldCh0YXJnZXQpOworICAgICAgICAgICAgdGhpcy5faW5pdGlhbGl6ZVBhZ2VUYXJnZXQodGFy Z2V0KTsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCiAgICAgICAgIC8vIFRyYW5z aXRpb25pbmcgcGFnZSB0YXJnZXQuCi0gICAgICAgIFdJLnRyYW5zaXRpb25QYWdlVGFyZ2V0KHRh cmdldCk7CisgICAgICAgIHRoaXMuX3RyYW5zaXRpb25QYWdlVGFyZ2V0KHRhcmdldCk7CiAgICAg fQogCiAgICAgX2NoZWNrQW5kSGFuZGxlUGFnZVRhcmdldFRlcm1pbmF0aW9uKHRhcmdldCkKQEAg LTE4OCw3ICsyMTMsNyBAQCBXSS5UYXJnZXRNYW5hZ2VyID0gY2xhc3MgVGFyZ2V0TWFuYWdlciBl eHRlbmRzIFdJLk9iamVjdAogICAgICAgICBjb25zb2xlLmFzc2VydCh0aGlzLl9zZWVuUGFnZVRh cmdldCk7CiAKICAgICAgICAgLy8gVGVybWluYXRpbmcgdGhlIHBhZ2UgdGFyZ2V0LgotICAgICAg ICBXSS50ZXJtaW5hdGVQYWdlVGFyZ2V0KHRhcmdldCk7CisgICAgICAgIHRoaXMuX3Rlcm1pbmF0 ZVBhZ2VUYXJnZXQodGFyZ2V0KTsKIAogICAgICAgICAvLyBFbnN1cmUgd2UgdHJhbnNpdGlvbiBp biBhIHJlYXNvbmFibGUgYW1vdW50IG9mIHRpbWUsIG90aGVyd2lzZSBjbG9zZS4KICAgICAgICAg Y29uc3QgdGltZVRvVHJhbnNpdGlvbiA9IDIwMDA7CkBAIC0yMDIsNiArMjI3LDg1IEBAIFdJLlRh cmdldE1hbmFnZXIgPSBjbGFzcyBUYXJnZXRNYW5hZ2VyIGV4dGVuZHMgV0kuT2JqZWN0CiAgICAg ICAgICAgICBXSS5jbG9zZSgpOwogICAgICAgICB9LCB0aW1lVG9UcmFuc2l0aW9uKTsKICAgICB9 CisKKyAgICBfaW5pdGlhbGl6ZUJhY2tlbmRUYXJnZXQodGFyZ2V0KQorICAgIHsKKyAgICAgICAg Y29uc29sZS5hc3NlcnQoIVdJLm1haW5UYXJnZXQpOworCisgICAgICAgIFdJLmJhY2tlbmRUYXJn ZXQgPSB0YXJnZXQ7CisKKyAgICAgICAgdGhpcy5fcmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgp OworCisgICAgICAgIFdJLl90YXJnZXRzQXZhaWxhYmxlUHJvbWlzZS5yZXNvbHZlKCk7CisgICAg fQorCisgICAgX2luaXRpYWxpemVQYWdlVGFyZ2V0KHRhcmdldCkKKyAgICB7CisgICAgICAgIGNv bnNvbGUuYXNzZXJ0KFdJLnNoYXJlZEFwcC5kZWJ1Z2dhYmxlVHlwZSA9PT0gV0kuRGVidWdnYWJs ZVR5cGUuV2ViKTsKKyAgICAgICAgY29uc29sZS5hc3NlcnQodGFyZ2V0LnR5cGUgPT09IFdJLlRh cmdldC5UeXBlLlBhZ2UgfHwgdGFyZ2V0IGluc3RhbmNlb2YgV0kuRGlyZWN0QmFja2VuZFRhcmdl dCk7CisKKyAgICAgICAgV0kucGFnZVRhcmdldCA9IHRhcmdldDsKKworICAgICAgICB0aGlzLl9y ZWRpcmVjdEdsb2JhbEFnZW50c1RvQ29ubmVjdGlvbihXSS5wYWdlVGFyZ2V0LmNvbm5lY3Rpb24p OworCisgICAgICAgIHRoaXMuX3Jlc2V0TWFpbkV4ZWN1dGlvbkNvbnRleHQoKTsKKyAgICB9CisK KyAgICBfdHJhbnNpdGlvblBhZ2VUYXJnZXQodGFyZ2V0KQorICAgIHsKKyAgICAgICAgY29uc29s ZS5hc3NlcnQoIVdJLnBhZ2VUYXJnZXQpOworICAgICAgICBjb25zb2xlLmFzc2VydChXSS5zaGFy ZWRBcHAuZGVidWdnYWJsZVR5cGUgPT09IFdJLkRlYnVnZ2FibGVUeXBlLldlYik7CisgICAgICAg IGNvbnNvbGUuYXNzZXJ0KHRhcmdldC50eXBlID09PSBXSS5UYXJnZXQuVHlwZS5QYWdlKTsKKwor ICAgICAgICBXSS5wYWdlVGFyZ2V0ID0gdGFyZ2V0OworCisgICAgICAgIHRoaXMuX3JlZGlyZWN0 R2xvYmFsQWdlbnRzVG9Db25uZWN0aW9uKFdJLnBhZ2VUYXJnZXQuY29ubmVjdGlvbik7CisKKyAg ICAgICAgdGhpcy5fcmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgpOworCisgICAgICAgIC8vIEFj dGlvbnMgdG8gdHJhbnNpdGlvbiB0aGUgcGFnZSB0YXJnZXQuCisgICAgICAgIFdJLm5vdGlmaWNh dGlvbnMuZGlzcGF0Y2hFdmVudFRvTGlzdGVuZXJzKFdJLk5vdGlmaWNhdGlvbi5UcmFuc2l0aW9u UGFnZVRhcmdldCk7CisgICAgICAgIFdJLmRvbU1hbmFnZXIudHJhbnNpdGlvblBhZ2VUYXJnZXQo KTsKKyAgICAgICAgV0kubmV0d29ya01hbmFnZXIudHJhbnNpdGlvblBhZ2VUYXJnZXQoKTsKKyAg ICAgICAgV0kudGltZWxpbmVNYW5hZ2VyLnRyYW5zaXRpb25QYWdlVGFyZ2V0KCk7CisgICAgfQor CisgICAgX3Rlcm1pbmF0ZVBhZ2VUYXJnZXQodGFyZ2V0KQorICAgIHsKKyAgICAgICAgY29uc29s ZS5hc3NlcnQoV0kucGFnZVRhcmdldCk7CisgICAgICAgIGNvbnNvbGUuYXNzZXJ0KFdJLnBhZ2VU YXJnZXQgPT09IHRhcmdldCk7CisgICAgICAgIGNvbnNvbGUuYXNzZXJ0KFdJLnNoYXJlZEFwcC5k ZWJ1Z2dhYmxlVHlwZSA9PT0gV0kuRGVidWdnYWJsZVR5cGUuV2ViKTsKKworICAgICAgICAvLyBS ZW1vdmUgYW55IFdvcmtlciB0YXJnZXRzIGFzc29jaWF0ZWQgd2l0aCB0aGlzIHBhZ2UuCisgICAg ICAgIGxldCB3b3JrZXJUYXJnZXRzID0gV0kudGFyZ2V0cy5maWx0ZXIoKHgpID0+IHgudHlwZSA9 PT0gV0kuVGFyZ2V0LlR5cGUuV29ya2VyKTsKKyAgICAgICAgZm9yIChsZXQgd29ya2VyVGFyZ2V0 IG9mIHdvcmtlclRhcmdldHMpCisgICAgICAgICAgICBXSS53b3JrZXJNYW5hZ2VyLndvcmtlclRl cm1pbmF0ZWQod29ya2VyVGFyZ2V0LmlkZW50aWZpZXIpOworCisgICAgICAgIFdJLnBhZ2VUYXJn ZXQgPSBudWxsOworCisgICAgICAgIHRoaXMuX3JlZGlyZWN0R2xvYmFsQWdlbnRzVG9Db25uZWN0 aW9uKFdJLmJhY2tlbmRDb25uZWN0aW9uKTsKKyAgICB9CisKKyAgICBfcmVzZXRNYWluRXhlY3V0 aW9uQ29udGV4dCgpCisgICAgeworICAgICAgICBpZiAoV0kubWFpblRhcmdldCBpbnN0YW5jZW9m IFdJLk11bHRpcGxleGluZ0JhY2tlbmRUYXJnZXQpCisgICAgICAgICAgICByZXR1cm47CisKKyAg ICAgICAgaWYgKFdJLm1haW5UYXJnZXQuZXhlY3V0aW9uQ29udGV4dCkgeworICAgICAgICAgICAg V0kucnVudGltZU1hbmFnZXIuYWN0aXZlRXhlY3V0aW9uQ29udGV4dCA9IFdJLm1haW5UYXJnZXQu ZXhlY3V0aW9uQ29udGV4dDsKKyAgICAgICAgICAgIGlmIChXSS5xdWlja0NvbnNvbGUpCisgICAg ICAgICAgICAgICAgV0kucXVpY2tDb25zb2xlLmluaXRpYWxpemVNYWluRXhlY3V0aW9uQ29udGV4 dFBhdGhDb21wb25lbnQoKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIF9yZWRpcmVjdEdsb2Jh bEFnZW50c1RvQ29ubmVjdGlvbihjb25uZWN0aW9uKQorICAgIHsKKyAgICAgICAgLy8gVGhpcyBt YWtlcyBnbG9iYWwgd2luZG93LkZvb0FnZW50IGRpc3BhdGNoIHRvIHRoZSBhY3RpdmUgcGFnZSB0 YXJnZXQuCisgICAgICAgIGZvciAobGV0IFtkb21haW4sIGFnZW50XSBvZiBPYmplY3QuZW50cmll cyhJbnNwZWN0b3JCYWNrZW5kLl9hZ2VudHMpKSB7CisgICAgICAgICAgICBpZiAoZG9tYWluICE9 PSAiVGFyZ2V0IikKKyAgICAgICAgICAgICAgICBhZ2VudC5jb25uZWN0aW9uID0gY29ubmVjdGlv bjsKKyAgICAgICAgfQorICAgIH07CiB9OwogCiBXSS5UYXJnZXRNYW5hZ2VyLkV2ZW50ID0gewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvUHJvdG9jb2wv Q29ubmVjdGlvbi5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Byb3Rv Y29sL0Nvbm5lY3Rpb24uanMKaW5kZXggYjI3Mzc4N2YzYjM1OTk1NzFkMGMwZTk4MjAzMTFlZDU0 OTM2YjNmNi4uYWVkNDZjZjI0ZWU5ZDAwMjhlMTc4MDVjOGVjODA4YTMzM2YwM2I5NyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvUHJvdG9jb2wvQ29ubmVj dGlvbi5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Qcm90b2Nv bC9Db25uZWN0aW9uLmpzCkBAIC0zMDgsOCArMzA4LDEyIEBAIEluc3BlY3RvckJhY2tlbmQuV29y a2VyQ29ubmVjdGlvbiA9IGNsYXNzIEluc3BlY3RvckJhY2tlbmRXb3JrZXJDb25uZWN0aW9uIGV4 dGVuCiAKICAgICBzZW5kTWVzc2FnZVRvQmFja2VuZChtZXNzYWdlKQogICAgIHsKLSAgICAgICAg Ly8gSWdub3JlIGVycm9ycyBpZiBhIHdvcmtlciB3ZW50IGF3YXkgcXVpY2tseS4KLSAgICAgICAg V29ya2VyQWdlbnQuc2VuZE1lc3NhZ2VUb1dvcmtlcih0aGlzLl93b3JrZXJJZCwgbWVzc2FnZSku Y2F0Y2goZnVuY3Rpb24oKXt9KTsKKyAgICAgICAgV29ya2VyQWdlbnQuc2VuZE1lc3NhZ2VUb1dv cmtlcih0aGlzLl93b3JrZXJJZCwgbWVzc2FnZSkuY2F0Y2goKGVycm9yKSA9PiB7CisgICAgICAg ICAgICAvLyBJZ25vcmUgZXJyb3JzIGlmIGEgd29ya2VyIHdlbnQgYXdheSBxdWlja2x5LgorICAg ICAgICAgICAgaWYgKHRoaXMudGFyZ2V0LmlzRGVzdHJveWVkKCkpCisgICAgICAgICAgICAgICAg cmV0dXJuOworICAgICAgICAgICAgV0kucmVwb3J0SW50ZXJuYWxFcnJvcihlcnJvcik7CisgICAg ICAgIH0pOwogICAgIH0KIH07CiAKQEAgLTMzMiw3ICszMzYsMTMgQEAgSW5zcGVjdG9yQmFja2Vu ZC5UYXJnZXRDb25uZWN0aW9uID0gY2xhc3MgSW5zcGVjdG9yQmFja2VuZFRhcmdldENvbm5lY3Rp b24gZXh0ZW4KIAogICAgIHNlbmRNZXNzYWdlVG9CYWNrZW5kKG1lc3NhZ2UpCiAgICAgewotICAg ICAgICBUYXJnZXRBZ2VudC5zZW5kTWVzc2FnZVRvVGFyZ2V0KHRoaXMuX3RhcmdldElkLCBtZXNz YWdlKTsKKyAgICAgICAgVGFyZ2V0QWdlbnQuc2VuZE1lc3NhZ2VUb1RhcmdldCh0aGlzLl90YXJn ZXRJZCwgbWVzc2FnZSkuY2F0Y2goKGVycm9yKSA9PiB7CisgICAgICAgICAgICAvLyBDb21tYW5k IG1heSBiZSBzZW50IGFmdGVyIHRhcmdldCBpcyBhbHJlYWR5IGRlc3Ryb3llZCBvbiBiYWNrZW5k LAorICAgICAgICAgICAgLy8gaWdub3JlIHN1Y2ggZXJyb3JzLgorICAgICAgICAgICAgaWYgKHRo aXMudGFyZ2V0LmlzRGVzdHJveWVkKCkpCisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAg ICAgICAgV0kucmVwb3J0SW50ZXJuYWxFcnJvcihlcnJvcik7CisgICAgICAgIH0pOwogICAgIH0K IH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1By b3RvY29sL1RhcmdldC5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1By b3RvY29sL1RhcmdldC5qcwppbmRleCAyMDMzNDEwYTZiNTMzNThlYjdjYTkyNTEzMTc1ZDMxMmFh ZDFhNDQ4Li5hOTM4MjBjMDk2M2NjYWU0ZmQ3YjhhOGJhNzc2NDhiY2MyYmMwYjFhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Qcm90b2NvbC9UYXJnZXQu anMKKysrIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvUHJvdG9jb2wvVGFy Z2V0LmpzCkBAIC0yMDAsNiArMjAwLDE2IEBAIFdJLlRhcmdldCA9IGNsYXNzIFRhcmdldCBleHRl bmRzIFdJLk9iamVjdAogICAgICAgICB0aGlzLmRpc3BhdGNoRXZlbnRUb0xpc3RlbmVycyhXSS5U YXJnZXQuRXZlbnQuU2NyaXB0QWRkZWQsIHtzY3JpcHR9KTsKICAgICB9CiAKKyAgICBkZXN0cm95 KCkKKyAgICB7CisgICAgICAgIHRoaXMuX2lzRGVzdHJveWVkID0gdHJ1ZTsKKyAgICB9CisKKyAg ICBpc0Rlc3Ryb3llZCgpCisgICAgeworICAgICAgICByZXR1cm4gdGhpcy5faXNEZXN0cm95ZWQ7 CisgICAgfQorCiAgICAgLy8gUHJpdmF0ZQogCiAgICAgX3N1cHBvcnRlZERvbWFpbnNGb3JUYXJn ZXRUeXBlKHR5cGUpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVy ZmFjZS9Qcm90b2NvbC9UYXJnZXRPYnNlcnZlci5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9V c2VySW50ZXJmYWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzCmluZGV4IDMxYjZmY2ZjMTg2 OWVkMTM4NzgxZTEwNzFkZDE5YjU0N2MwOWNiZjQuLmMzNGU4YWE3ZjM0ZGMyMjY1MWU3ZjFhYzAw OTdjYzYxZjBiZmQ5N2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0 b3JVSS9Vc2VySW50ZXJmYWNlL1Byb3RvY29sL1RhcmdldE9ic2VydmVyLmpzCkBAIC0yNiwxMiAr MjYsMjAgQEAKIFdJLlRhcmdldE9ic2VydmVyID0gY2xhc3MgVGFyZ2V0T2JzZXJ2ZXIKIHsKICAg ICAvLyBFdmVudHMgZGVmaW5lZCBieSB0aGUgIlRhcmdldCIgZG9tYWluLgorICAgIGNvbnN0cnVj dG9yKCkKKyAgICB7CisgICAgfQogCiAgICAgdGFyZ2V0Q3JlYXRlZCh0YXJnZXRJbmZvKQogICAg IHsKICAgICAgICAgV0kudGFyZ2V0TWFuYWdlci50YXJnZXRDcmVhdGVkKHRhcmdldEluZm8pOwog ICAgIH0KIAorICAgIGRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KHRhcmdldEluZm8pCisgICAg eworICAgICAgICBXSS50YXJnZXRNYW5hZ2VyLmRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KHRh cmdldEluZm8pOworICAgIH0KKwogICAgIHRhcmdldERlc3Ryb3llZCh0YXJnZXRJZCkKICAgICB7 CiAgICAgICAgIFdJLnRhcmdldE1hbmFnZXIudGFyZ2V0RGVzdHJveWVkKHRhcmdldElkKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Rlc3QvVGVzdC5q cyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL1Rlc3QvVGVzdC5qcwppbmRl eCA3NTcwOGEwMGM5NTgxNzI3ZWUwZjRjMzg1MzQzYTRmMjQ0YjIzZDM1Li5lNWM4ZWExYjY4ZTYw NDk1OWQ4ZWY3N2U4ZjhmOTNlNjU5NmVjODE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9UZXN0L1Rlc3QuanMKKysrIGIvU291cmNlL1dlYkluc3BlY3Rv clVJL1VzZXJJbnRlcmZhY2UvVGVzdC9UZXN0LmpzCkBAIC04Niw1MiArODYsNiBAQCBXSS5sb2Fk ZWQgPSBmdW5jdGlvbigpCiAgICAgfSk7CiB9OwogCi1XSS5pbml0aWFsaXplQmFja2VuZFRhcmdl dCA9IGZ1bmN0aW9uKHRhcmdldCkKLXsKLSAgICBXSS5iYWNrZW5kVGFyZ2V0ID0gdGFyZ2V0Owot Ci0gICAgV0kucmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgpOwotCi0gICAgV0kuX3RhcmdldHNB dmFpbGFibGVQcm9taXNlLnJlc29sdmUoKTsKLX07Ci0KLVdJLmluaXRpYWxpemVQYWdlVGFyZ2V0 ID0gZnVuY3Rpb24odGFyZ2V0KQotewotICAgIFdJLnBhZ2VUYXJnZXQgPSB0YXJnZXQ7Ci0KLSAg ICBXSS5yZWRpcmVjdEdsb2JhbEFnZW50c1RvQ29ubmVjdGlvbihXSS5wYWdlVGFyZ2V0LmNvbm5l Y3Rpb24pOwotCi0gICAgV0kucmVzZXRNYWluRXhlY3V0aW9uQ29udGV4dCgpOwotfTsKLQotV0ku dHJhbnNpdGlvblBhZ2VUYXJnZXQgPSBmdW5jdGlvbih0YXJnZXQpCi17Ci0gICAgY29uc29sZS5l cnJvcigiV0kudHJhbnNpdGlvblBhZ2VUYXJnZXQgc2hvdWxkIG5vdCBiZSByZWFjaGVkIGluIHRl c3RzLiIpOwotfTsKLQotV0kudGVybWluYXRlUGFnZVRhcmdldCA9IGZ1bmN0aW9uKHRhcmdldCkK LXsKLSAgICBjb25zb2xlLmVycm9yKCJXSS50ZXJtaW5hdGVQYWdlVGFyZ2V0IHNob3VsZCBub3Qg YmUgcmVhY2hlZCBpbiB0ZXN0cy4iKTsKLX07Ci0KLVdJLnJlc2V0TWFpbkV4ZWN1dGlvbkNvbnRl eHQgPSBmdW5jdGlvbigpCi17Ci0gICAgaWYgKFdJLm1haW5UYXJnZXQgaW5zdGFuY2VvZiBXSS5N dWx0aXBsZXhpbmdCYWNrZW5kVGFyZ2V0KQotICAgICAgICByZXR1cm47Ci0KLSAgICBpZiAoV0ku bWFpblRhcmdldC5leGVjdXRpb25Db250ZXh0KQotICAgICAgICBXSS5ydW50aW1lTWFuYWdlci5h Y3RpdmVFeGVjdXRpb25Db250ZXh0ID0gV0kubWFpblRhcmdldC5leGVjdXRpb25Db250ZXh0Owot fTsKLQotV0kucmVkaXJlY3RHbG9iYWxBZ2VudHNUb0Nvbm5lY3Rpb24gPSBmdW5jdGlvbihjb25u ZWN0aW9uKQotewotICAgIC8vIFRoaXMgbWFrZXMgZ2xvYmFsIHdpbmRvdy5Gb29BZ2VudCBkaXNw YXRjaCB0byB0aGUgYWN0aXZlIHBhZ2UgdGFyZ2V0LgotICAgIGZvciAobGV0IFtkb21haW4sIGFn ZW50XSBvZiBPYmplY3QuZW50cmllcyhJbnNwZWN0b3JCYWNrZW5kLl9hZ2VudHMpKSB7Ci0gICAg ICAgIGlmIChkb21haW4gIT09ICJUYXJnZXQiKQotICAgICAgICAgICAgYWdlbnQuY29ubmVjdGlv biA9IGNvbm5lY3Rpb247Ci0gICAgfQotfTsKLQogV0kuY29udGVudExvYWRlZCA9IGZ1bmN0aW9u KCkKIHsKICAgICAvLyBUaGluZ3MgdGhhdCB3b3VsZCBub3JtYWxseSBnZXQgY2FsbGVkIGJ5IHRo ZSBVSSwgdGhhdCB3ZSBzdGlsbCB3YW50IHRvIGRvIGluIHRlc3RzLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9XZWJLaXQvU291cmNlcy50eHQKaW5kZXgg MzczZDY1NWYxMGFmOGIzODAzNWI5NmJhYzdkOGYyOTUyYjBhNjhiYS4uMmZhZmMwMmE2ODkzNTBh NWUwMjU5ODc1YTEwZTRjODZmYjQ2YTBiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9Tb3Vy Y2VzLnR4dAorKysgYi9Tb3VyY2UvV2ViS2l0L1NvdXJjZXMudHh0CkBAIC0yODgsNyArMjg4LDYg QEAgVUlQcm9jZXNzL1dlYlBhZ2VEaWFnbm9zdGljTG9nZ2luZ0NsaWVudC5jcHAKIFVJUHJvY2Vz cy9XZWJQYWdlR3JvdXAuY3BwCiBVSVByb2Nlc3MvV2ViUGFnZUluamVjdGVkQnVuZGxlQ2xpZW50 LmNwcAogVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmNwcAotVUlQcm9jZXNz L1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5jcHAKIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHku Y3BwCiBVSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmNwcAogVUlQcm9jZXNzL1dlYlByZWZl cmVuY2VzLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVjdG9y VGFyZ2V0UHJveHkuY3BwIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVjdG9yVGFyZ2V0 UHJveHkuY3BwCmluZGV4IDYxYjhmMzZlZmE3NTFmMWM4OGQ5MmJhMWFkY2QxNWVjYTYxNDU4MjIu LjEyMWM4YTY2NmI5OTI2MDAwMzZhYjEzYjU2ODZiMDA4NmUzYjdlNDEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNwZWN0b3JUYXJnZXRQcm94eS5jcHAKQEAgLTI2LDcgKzI2 LDkgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJbnNwZWN0b3JUYXJnZXRQcm94 eS5oIgogCisjaW5jbHVkZSAiUHJvdmlzaW9uYWxQYWdlUHJveHkuaCIKICNpbmNsdWRlICJXZWJG cmFtZVByb3h5LmgiCisjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIgogI2luY2x1 ZGUgIldlYlBhZ2VNZXNzYWdlcy5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgogI2luY2x1 ZGUgIldlYlByb2Nlc3NQcm94eS5oIgpAQCAtMzUsOSArMzcsMTYgQEAgbmFtZXNwYWNlIFdlYktp dCB7CiAKIHVzaW5nIG5hbWVzcGFjZSBJbnNwZWN0b3I7CiAKLVJlZjxJbnNwZWN0b3JUYXJnZXRQ cm94eT4gSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZShXZWJQYWdlUHJveHkmIHBhZ2UsIGNv bnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZSB0eXBl KQorc3RkOjp1bmlxdWVfcHRyPEluc3BlY3RvclRhcmdldFByb3h5PiBJbnNwZWN0b3JUYXJnZXRQ cm94eTo6Y3JlYXRlKFdlYlBhZ2VQcm94eSYgcGFnZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwg SW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUpCiB7Ci0gICAgcmV0dXJuIGFkb3B0 UmVmKCpuZXcgSW5zcGVjdG9yVGFyZ2V0UHJveHkocGFnZSwgdGFyZ2V0SWQsIHR5cGUpKTsKKyAg ICByZXR1cm4gbWFrZVVuaXF1ZTxJbnNwZWN0b3JUYXJnZXRQcm94eT4ocGFnZSwgdGFyZ2V0SWQs IHR5cGUpOworfQorCitzdGQ6OnVuaXF1ZV9wdHI8SW5zcGVjdG9yVGFyZ2V0UHJveHk+IEluc3Bl Y3RvclRhcmdldFByb3h5OjpjcmVhdGUoUHJvdmlzaW9uYWxQYWdlUHJveHkmIHByb3Zpc2lvbmFs UGFnZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRU eXBlIHR5cGUpCit7CisgICAgYXV0byB0YXJnZXQgPSBJbnNwZWN0b3JUYXJnZXRQcm94eTo6Y3Jl YXRlKHByb3Zpc2lvbmFsUGFnZS5wYWdlKCksIHRhcmdldElkLCB0eXBlKTsKKyAgICB0YXJnZXQt Pm1fcHJvdmlzaW9uYWxQYWdlID0gJnByb3Zpc2lvbmFsUGFnZTsKKyAgICByZXR1cm4gdGFyZ2V0 OwogfQogCiBJbnNwZWN0b3JUYXJnZXRQcm94eTo6SW5zcGVjdG9yVGFyZ2V0UHJveHkoV2ViUGFn ZVByb3h5JiBwYWdlLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3Rv clRhcmdldFR5cGUgdHlwZSkKQEAgLTQ3LDIyICs1Niw1NiBAQCBJbnNwZWN0b3JUYXJnZXRQcm94 eTo6SW5zcGVjdG9yVGFyZ2V0UHJveHkoV2ViUGFnZVByb3h5JiBwYWdlLCBjb25zdCBTdHJpbmcm IHRhcgogewogfQogCi12b2lkIEluc3BlY3RvclRhcmdldFByb3h5Ojpjb25uZWN0KEluc3BlY3Rv cjo6RnJvbnRlbmRDaGFubmVsJiBjaGFubmVsKQordm9pZCBJbnNwZWN0b3JUYXJnZXRQcm94eTo6 Y29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgY29ubmVj dGlvblR5cGUpCiB7CisgICAgaWYgKG1fcHJvdmlzaW9uYWxQYWdlKSB7CisgICAgICAgIG1fcHJv dmlzaW9uYWxQYWdlLT5wcm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6Q29ubmVjdElu c3BlY3RvcihpZGVudGlmaWVyKCksIGNvbm5lY3Rpb25UeXBlKSwgbV9wcm92aXNpb25hbFBhZ2Ut PndlYlBhZ2VJRCgpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIGlmIChtX3BhZ2Uu aGFzUnVubmluZ1Byb2Nlc3MoKSkKLSAgICAgICAgbV9wYWdlLnByb2Nlc3MoKS5zZW5kKE1lc3Nh Z2VzOjpXZWJQYWdlOjpDb25uZWN0SW5zcGVjdG9yKGlkZW50aWZpZXIoKSwgY2hhbm5lbC5jb25u ZWN0aW9uVHlwZSgpKSwgbV9wYWdlLndlYlBhZ2VJRCgpKTsKKyAgICAgICAgbV9wYWdlLnByb2Nl c3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpDb25uZWN0SW5zcGVjdG9yKGlkZW50aWZpZXIo KSwgY29ubmVjdGlvblR5cGUpLCBtX3BhZ2Uud2ViUGFnZUlEKCkpOwogfQogCi12b2lkIEluc3Bl Y3RvclRhcmdldFByb3h5OjpkaXNjb25uZWN0KEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsJikK K3ZvaWQgSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmRpc2Nvbm5lY3QoKQogeworICAgIGlmIChtX3By b3Zpc2lvbmFsUGFnZSkgeworICAgICAgICBtX3Byb3Zpc2lvbmFsUGFnZS0+cHJvY2VzcygpLnNl bmQoTWVzc2FnZXM6OldlYlBhZ2U6OkRpc2Nvbm5lY3RJbnNwZWN0b3IoaWRlbnRpZmllcigpKSwg bV9wcm92aXNpb25hbFBhZ2UtPndlYlBhZ2VJRCgpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0K KwogICAgIGlmIChtX3BhZ2UuaGFzUnVubmluZ1Byb2Nlc3MoKSkKICAgICAgICAgbV9wYWdlLnBy b2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpEaXNjb25uZWN0SW5zcGVjdG9yKGlkZW50 aWZpZXIoKSksIG1fcGFnZS53ZWJQYWdlSUQoKSk7CiB9CiAKIHZvaWQgSW5zcGVjdG9yVGFyZ2V0 UHJveHk6OnNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYgbWVzc2FnZSkK IHsKKyAgICBpZiAobV9wcm92aXNpb25hbFBhZ2UpIHsKKyAgICAgICAgbV9wcm92aXNpb25hbFBh Z2UtPnByb2Nlc3MoKS5zZW5kKE1lc3NhZ2VzOjpXZWJQYWdlOjpTZW5kTWVzc2FnZVRvVGFyZ2V0 QmFja2VuZChpZGVudGlmaWVyKCksIG1lc3NhZ2UpLCBtX3Byb3Zpc2lvbmFsUGFnZS0+d2ViUGFn ZUlEKCkpOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgaWYgKG1fcGFnZS5oYXNSdW5u aW5nUHJvY2VzcygpKQogICAgICAgICBtX3BhZ2UucHJvY2VzcygpLnNlbmQoTWVzc2FnZXM6Oldl YlBhZ2U6OlNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGlkZW50aWZpZXIoKSwgbWVzc2FnZSks IG1fcGFnZS53ZWJQYWdlSUQoKSk7CiB9CiAKK3ZvaWQgSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmRp ZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KCkKK3sKKyAgICBBU1NFUlQoaXNQcm92aXNpb25hbCgp KTsKKyAgICBtX3Byb3Zpc2lvbmFsUGFnZSA9IG51bGxwdHI7Cit9CisKK2Jvb2wgSW5zcGVjdG9y VGFyZ2V0UHJveHk6OmlzUHJvdmlzaW9uYWwoKSBjb25zdAoreworICAgIHJldHVybiBtX3Byb3Zp c2lvbmFsUGFnZTsKK30KKworU3RyaW5nIEluc3BlY3RvclRhcmdldFByb3h5OjpwcmV2aW91c1Rh cmdldElEKCkgY29uc3QKK3sKKyAgICBpZiAobV90eXBlICE9IEluc3BlY3Rvcjo6SW5zcGVjdG9y VGFyZ2V0VHlwZTo6UGFnZSB8fCAhaXNQcm92aXNpb25hbCgpKQorICAgICAgICByZXR1cm4gU3Ry aW5nKCk7CisKKyAgICByZXR1cm4gV2ViUGFnZUluc3BlY3RvclRhcmdldDo6dG9UYXJnZXRJRCht X3BhZ2Uud2ViUGFnZUlEKCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0luc3BlY3RvclRhcmdldFByb3h5LmggYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9JbnNwZWN0b3JUYXJnZXRQcm94eS5oCmluZGV4IGQzODJiMDI2 NTA5YzgzOTUxOTlhYmRkNDk1YWY2YTJhNTFhZjkyN2MuLjE3YjE3YTJhZjM4MzVjZTY0YzM0MDM5 ZTA5OWM3ZTBkNDY5ODJiYmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0lu c3BlY3RvclRhcmdldFByb3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvSW5zcGVj dG9yVGFyZ2V0UHJveHkuaApAQCAtMzUsMjUgKzM1LDMxIEBAIGNsYXNzIFdlYlBhZ2VQcm94eTsK IC8vIE5PVEU6IFRoaXMgVUlQcm9jZXNzIHNpZGUgSW5zcGVjdG9yVGFyZ2V0IGRvZXNuJ3QgY2Fy ZSBhYm91dCB0aGUgZnJvbnRlbmQgY2hhbm5lbCwgc2luY2UKIC8vIGFueSB0YXJnZXQgLT4gZnJv bnRlbmQgbWVzc2FnZXMgd2lsbCBiZSByb3V0ZWQgdG8gdGhlIFdlYlBhZ2VQcm94eSB3aXRoIGEg dGFyZ2V0SWQuCiAKLWNsYXNzIEluc3BlY3RvclRhcmdldFByb3h5IGZpbmFsIDogcHVibGljIElu c3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0LCBwdWJsaWMgUmVmQ291bnRlZDxJbnNwZWN0b3JUYXJn ZXRQcm94eT4geworY2xhc3MgSW5zcGVjdG9yVGFyZ2V0UHJveHkgZmluYWwgOiBwdWJsaWMgSW5z cGVjdG9yOjpJbnNwZWN0b3JUYXJnZXQgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwog ICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKEluc3BlY3RvclRhcmdldFByb3h5KTsKIHB1YmxpYzoK LSAgICBzdGF0aWMgUmVmPEluc3BlY3RvclRhcmdldFByb3h5PiBjcmVhdGUoV2ViUGFnZVByb3h5 JiwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBl KTsKKyAgICBzdGF0aWMgc3RkOjp1bmlxdWVfcHRyPEluc3BlY3RvclRhcmdldFByb3h5PiBjcmVh dGUoV2ViUGFnZVByb3h5JiwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpJbnNw ZWN0b3JUYXJnZXRUeXBlKTsKKyAgICBzdGF0aWMgc3RkOjp1bmlxdWVfcHRyPEluc3BlY3RvclRh cmdldFByb3h5PiBjcmVhdGUoUHJvdmlzaW9uYWxQYWdlUHJveHkmLCBjb25zdCBTdHJpbmcmIHRh cmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGUpOwogICAgIEluc3BlY3RvclRh cmdldFByb3h5KFdlYlBhZ2VQcm94eSYsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rv cjo6SW5zcGVjdG9yVGFyZ2V0VHlwZSk7CiAgICAgfkluc3BlY3RvclRhcmdldFByb3h5KCkgPSBk ZWZhdWx0OwogCiAgICAgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUoKSBjb25z dCBmaW5hbCB7IHJldHVybiBtX3R5cGU7IH0KICAgICBTdHJpbmcgaWRlbnRpZmllcigpIGNvbnN0 IGZpbmFsIHsgcmV0dXJuIG1faWRlbnRpZmllcjsgfQogCi0gICAgdm9pZCBjb25uZWN0KEluc3Bl Y3Rvcjo6RnJvbnRlbmRDaGFubmVsJik7Ci0gICAgdm9pZCBkaXNjb25uZWN0KEluc3BlY3Rvcjo6 RnJvbnRlbmRDaGFubmVsJik7Ci0gICAgdm9pZCBzZW5kTWVzc2FnZVRvVGFyZ2V0QmFja2VuZChj b25zdCBTdHJpbmcmKTsKKyAgICB2b2lkIGRpZENvbW1pdFByb3Zpc2lvbmFsVGFyZ2V0KCk7Cisg ICAgYm9vbCBpc1Byb3Zpc2lvbmFsKCkgY29uc3Qgb3ZlcnJpZGU7CisgICAgU3RyaW5nIHByZXZp b3VzVGFyZ2V0SUQoKSBjb25zdCBvdmVycmlkZTsKKworICAgIHZvaWQgY29ubmVjdChJbnNwZWN0 b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUpIG92ZXJyaWRlOworICAgIHZvaWQg ZGlzY29ubmVjdCgpIG92ZXJyaWRlOworICAgIHZvaWQgc2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tl bmQoY29uc3QgU3RyaW5nJikgb3ZlcnJpZGU7CiAKIHByaXZhdGU6CiAgICAgV2ViUGFnZVByb3h5 JiBtX3BhZ2U7CiAgICAgU3RyaW5nIG1faWRlbnRpZmllcjsKICAgICBJbnNwZWN0b3I6Okluc3Bl Y3RvclRhcmdldFR5cGUgbV90eXBlOworICAgIFByb3Zpc2lvbmFsUGFnZVByb3h5KiBtX3Byb3Zp c2lvbmFsUGFnZSB7IG51bGxwdHIgfTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuY3Bw IGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuY3BwCmluZGV4 IGEyYTA5ZGM0OTI1ZGY0MmU1NDg0NDUwYmVmNDc5NzhjMDM5N2Y5ZTUuLjkwOWQ0OWFkODkyNTgy MTgyNzljOTUxM2IzMDUxN2ZiNjMwNTFiMjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQ cm9jZXNzL1Byb3Zpc2lvbmFsUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJv Y2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRl ICJXZWJFcnJvcnMuaCIKICNpbmNsdWRlICJXZWJOYXZpZ2F0aW9uRGF0YVN0b3JlLmgiCiAjaW5j bHVkZSAiV2ViTmF2aWdhdGlvblN0YXRlLmgiCisjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvckNv bnRyb2xsZXIuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbmNsdWRlICJXZWJQ YWdlUHJveHkuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHlNZXNzYWdlcy5oIgpAQCAtODQsNiAr ODUsOCBAQCBQcm92aXNpb25hbFBhZ2VQcm94eTo6UHJvdmlzaW9uYWxQYWdlUHJveHkoV2ViUGFn ZVByb3h5JiBwYWdlLCBSZWY8V2ViUHJvY2Vzc1BybwogICAgIH0KIAogICAgIGluaXRpYWxpemVX ZWJQYWdlKCk7CisKKyAgICBtX3BhZ2UuaW5zcGVjdG9yQ29udHJvbGxlcigpLmRpZENyZWF0ZVBy b3Zpc2lvbmFsUGFnZSgqdGhpcyk7CiB9CiAKIFByb3Zpc2lvbmFsUGFnZVByb3h5Ojp+UHJvdmlz aW9uYWxQYWdlUHJveHkoKQpAQCAtOTMsNiArOTYsOCBAQCBQcm92aXNpb25hbFBhZ2VQcm94eTo6 flByb3Zpc2lvbmFsUGFnZVByb3h5KCkKICAgICBpZiAobV93YXNDb21taXR0ZWQpCiAgICAgICAg IHJldHVybjsKIAorICAgIG1fcGFnZS5pbnNwZWN0b3JDb250cm9sbGVyKCkud2lsbERlc3Ryb3lQ cm92aXNpb25hbFBhZ2UoKnRoaXMpOworCiAgICAgaWYgKCZtX3Byb2Nlc3MtPndlYnNpdGVEYXRh U3RvcmUoKSAhPSAmbV9wYWdlLndlYnNpdGVEYXRhU3RvcmUoKSkKICAgICAgICAgbV9wcm9jZXNz LT5wcm9jZXNzUG9vbCgpLnBhZ2VFbmRVc2luZ1dlYnNpdGVEYXRhU3RvcmUobV9wYWdlLmlkZW50 aWZpZXIoKSwgbV9wcm9jZXNzLT53ZWJzaXRlRGF0YVN0b3JlKCkpOwogCkBAIC0zOTEsNiArMzk2 LDkgQEAgdm9pZCBQcm92aXNpb25hbFBhZ2VQcm94eTo6ZGlkUmVjZWl2ZU1lc3NhZ2UoSVBDOjpD b25uZWN0aW9uJiBjb25uZWN0aW9uLCBJUEM6OkQKICAgICAgICAgfHwgZGVjb2Rlci5tZXNzYWdl TmFtZSgpID09IE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkRpZFN0YXJ0TG9hZEZvclF1aWNrTG9v a0RvY3VtZW50SW5NYWluRnJhbWU6Om5hbWUoKQogICAgICAgICB8fCBkZWNvZGVyLm1lc3NhZ2VO YW1lKCkgPT0gTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGlkRmluaXNoTG9hZEZvclF1aWNrTG9v a0RvY3VtZW50SW5NYWluRnJhbWU6Om5hbWUoKQogI2VuZGlmCisgICAgICAgIHx8IGRlY29kZXIu bWVzc2FnZU5hbWUoKSA9PSBNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpDcmVhdGVJbnNwZWN0b3JU YXJnZXQ6Om5hbWUoKQorICAgICAgICB8fCBkZWNvZGVyLm1lc3NhZ2VOYW1lKCkgPT0gTWVzc2Fn ZXM6OldlYlBhZ2VQcm94eTo6RGVzdHJveUluc3BlY3RvclRhcmdldDo6bmFtZSgpCisgICAgICAg IHx8IGRlY29kZXIubWVzc2FnZU5hbWUoKSA9PSBNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpTZW5k TWVzc2FnZVRvSW5zcGVjdG9yRnJvbnRlbmQ6Om5hbWUoKQogICAgICAgICApCiAgICAgewogICAg ICAgICBtX3BhZ2UuZGlkUmVjZWl2ZU1lc3NhZ2UoY29ubmVjdGlvbiwgZGVjb2Rlcik7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9Qcm92aXNpb25hbFBhZ2VQcm94eS5oIGIv U291cmNlL1dlYktpdC9VSVByb2Nlc3MvUHJvdmlzaW9uYWxQYWdlUHJveHkuaAppbmRleCAxNzUy MTUwNDc0OGJmYjZmMjA2M2NlMTRjYTQ1ZmQxY2M3MTgzZWNiLi5iZWU4MWJjMGJkOWQ3MWI0YTY4 ZGY0ZjhiOWU0NzM2YmQyOWE4Y2ZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9Qcm92aXNpb25hbFBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1By b3Zpc2lvbmFsUGFnZVByb3h5LmgKQEAgLTY0LDcgKzY0LDcgQEAgcHVibGljOgogICAgIFByb3Zp c2lvbmFsUGFnZVByb3h5KFdlYlBhZ2VQcm94eSYsIFJlZjxXZWJQcm9jZXNzUHJveHk+JiYsIHN0 ZDo6dW5pcXVlX3B0cjxTdXNwZW5kZWRQYWdlUHJveHk+LCB1aW50NjRfdCBuYXZpZ2F0aW9uSUQs IGJvb2wgaXNTZXJ2ZXJSZWRpcmVjdCwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg UHJvY2Vzc1N3YXBSZXF1ZXN0ZWRCeUNsaWVudCk7CiAgICAgflByb3Zpc2lvbmFsUGFnZVByb3h5 KCk7CiAKLSAgICBXZWJQYWdlUHJveHkmIHBhZ2UoKSB7IHJldHVybiBtX3BhZ2U7IH0KKyAgICBX ZWJQYWdlUHJveHkmIHBhZ2UoKSBjb25zdCB7IHJldHVybiBtX3BhZ2U7IH0KICAgICBXZWJDb3Jl OjpQYWdlSWRlbnRpZmllciB3ZWJQYWdlSUQoKSBjb25zdCB7IHJldHVybiBtX3dlYlBhZ2VJRDsg fQogICAgIFdlYkZyYW1lUHJveHkqIG1haW5GcmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fbWFpbkZy YW1lLmdldCgpOyB9CiAgICAgV2ViUHJvY2Vzc1Byb3h5JiBwcm9jZXNzKCkgeyByZXR1cm4gbV9w cm9jZXNzLmdldCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlci5jcHAKaW5kZXggYmRhNTljZDgwNTE1NzY0NmIzMDhkMmZk MjM2ZjNkMTE4MjcxZTBiNi4uM2RkNDNiY2UwODJkMWRhZjFmYThlMzExNTc0MzFjNzUyZDI4M2M4 OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNv bnRyb2xsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0 b3JDb250cm9sbGVyLmNwcApAQCAtMjYsMjggKzI2LDM5IEBACiAjaW5jbHVkZSAiY29uZmlnLmgi CiAjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaCIKIAorI2luY2x1ZGUgIlBy b3Zpc2lvbmFsUGFnZVByb3h5LmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVQcm94eS5oIgotI2luY2x1 ZGUgIldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oIgorI2luY2x1ZGUgIldlYlBhZ2VJbnNw ZWN0b3JUYXJnZXQuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIKICNpbmNsdWRlIDxKYXZh U2NyaXB0Q29yZS9JbnNwZWN0b3JBZ2VudEJhc2UuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9JbnNwZWN0b3JCYWNrZW5kRGlzcGF0Y2hlci5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0luc3BlY3RvckJhY2tlbmREaXNwYXRjaGVycy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3Jl L0luc3BlY3RvckZyb250ZW5kUm91dGVyLmg+CisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSW5z cGVjdG9yVGFyZ2V0QWdlbnQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiBuYW1lc3Bh Y2UgV2ViS2l0IHsKIAogdXNpbmcgbmFtZXNwYWNlIEluc3BlY3RvcjsKIAorc3RhdGljIFN0cmlu ZyBnZXRUYXJnZXRJRChjb25zdCBQcm92aXNpb25hbFBhZ2VQcm94eSYgcHJvdmlzaW9uYWxQYWdl KQoreworICAgIHJldHVybiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Ojp0b1RhcmdldElEKHByb3Zp c2lvbmFsUGFnZS53ZWJQYWdlSUQoKSk7Cit9CisKIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVy OjpXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcihXZWJQYWdlUHJveHkmIHBhZ2UpCiAgICAgOiBt X3BhZ2UocGFnZSkKICAgICAsIG1fZnJvbnRlbmRSb3V0ZXIoRnJvbnRlbmRSb3V0ZXI6OmNyZWF0 ZSgpKQogICAgICwgbV9iYWNrZW5kRGlzcGF0Y2hlcihCYWNrZW5kRGlzcGF0Y2hlcjo6Y3JlYXRl KG1fZnJvbnRlbmRSb3V0ZXIuY29weVJlZigpKSkKIHsKLSAgICBhdXRvIHRhcmdldEFnZW50ID0g bWFrZVVuaXF1ZTxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ+KG1fZnJvbnRlbmRSb3V0ZXIu Z2V0KCksIG1fYmFja2VuZERpc3BhdGNoZXIuZ2V0KCkpOworICAgIGF1dG8gdGFyZ2V0QWdlbnQg PSBtYWtlVW5pcXVlPEluc3BlY3RvclRhcmdldEFnZW50PihtX2Zyb250ZW5kUm91dGVyLmdldCgp LCBtX2JhY2tlbmREaXNwYXRjaGVyLmdldCgpKTsKIAogICAgIG1fdGFyZ2V0QWdlbnQgPSB0YXJn ZXRBZ2VudC5nZXQoKTsKIAogICAgIG1fYWdlbnRzLmFwcGVuZChXVEZNb3ZlKHRhcmdldEFnZW50 KSk7CisKKyAgICBTdHJpbmcgcGFnZVRhcmdldElkID0gV2ViUGFnZUluc3BlY3RvclRhcmdldDo6 dG9UYXJnZXRJRChtX3BhZ2Uud2ViUGFnZUlEKCkpOworICAgIGNyZWF0ZUluc3BlY3RvclRhcmdl dChwYWdlVGFyZ2V0SWQsIEluc3BlY3Rvcjo6SW5zcGVjdG9yVGFyZ2V0VHlwZTo6UGFnZSk7CiB9 CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OnBhZ2VDbG9zZWQoKQpAQCAtMTM2 LDMwICsxNDcsMjQgQEAgdm9pZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6c2V0SW5kaWNh dGluZyhib29sIGluZGljYXRpbmcpCiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6 OmNsZWFyVGFyZ2V0cygpCiB7Ci0gICAgZm9yIChhdXRvJiB0YXJnZXQgOiBtX3RhcmdldHMpCi0g ICAgICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldERlc3Ryb3llZCgqdGFyZ2V0LmdldCgpKTsKKyAg ICBmb3IgKGF1dG8mIHRhcmdldCA6IG1fdGFyZ2V0cy52YWx1ZXMoKSkKKyAgICAgICAgbV90YXJn ZXRBZ2VudC0+dGFyZ2V0RGVzdHJveWVkKCp0YXJnZXQpOwogCiAgICAgbV90YXJnZXRzLmNsZWFy KCk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXI6OmNyZWF0ZUluc3BlY3Rv clRhcmdldChjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdl dFR5cGUgdHlwZSkKIHsKLSAgICBhdXRvIHRhcmdldCA9IEluc3BlY3RvclRhcmdldFByb3h5Ojpj cmVhdGUobV9wYWdlLCB0YXJnZXRJZCwgdHlwZSk7Ci0gICAgbV90YXJnZXRzLmFwcGVuZCh0YXJn ZXQuY29weVJlZigpKTsKLQotICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldENyZWF0ZWQodGFyZ2V0 LmdldCgpKTsKKyAgICBhZGRUYXJnZXQoSW5zcGVjdG9yVGFyZ2V0UHJveHk6OmNyZWF0ZShtX3Bh Z2UsIHRhcmdldElkLCB0eXBlKSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvckNvbnRyb2xs ZXI6OmRlc3Ryb3lJbnNwZWN0b3JUYXJnZXQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCkKIHsKLSAg ICBhdXRvIHBvc2l0aW9uID0gbV90YXJnZXRzLmZpbmRNYXRjaGluZyhbJl0oY29uc3QgYXV0byYg aXRlbSkgeyByZXR1cm4gaXRlbS0+aWRlbnRpZmllcigpID09IHRhcmdldElkOyB9KTsKLSAgICBp ZiAocG9zaXRpb24gPT0gbm90Rm91bmQpCisgICAgYXV0byBpdCA9IG1fdGFyZ2V0cy5maW5kKHRh cmdldElkKTsKKyAgICBpZiAoaXQgPT0gbV90YXJnZXRzLmVuZCgpKQogICAgICAgICByZXR1cm47 Ci0KLSAgICBhdXRvJiB0YXJnZXQgPSBtX3RhcmdldHNbcG9zaXRpb25dOwotICAgIG1fdGFyZ2V0 QWdlbnQtPnRhcmdldERlc3Ryb3llZCgqdGFyZ2V0LmdldCgpKTsKLQotICAgIG1fdGFyZ2V0cy5y ZW1vdmUocG9zaXRpb24pOworICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldERlc3Ryb3llZCgqaXQt PnZhbHVlKTsKKyAgICBtX3RhcmdldHMucmVtb3ZlKGl0KTsKIH0KIAogdm9pZCBXZWJQYWdlSW5z cGVjdG9yQ29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb0luc3BlY3RvckZyb250ZW5kKGNvbnN0IFN0 cmluZyYgdGFyZ2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKQEAgLTE2Nyw0ICsxNzIsMzMg QEAgdm9pZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb0luc3BlY3Rv ckZyb250ZW5kKGNvbnN0IFN0cmluZyYgdGEKICAgICBtX3RhcmdldEFnZW50LT5zZW5kTWVzc2Fn ZUZyb21UYXJnZXRUb0Zyb250ZW5kKHRhcmdldElkLCBtZXNzYWdlKTsKIH0KIAordm9pZCBXZWJQ YWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6ZGlkQ3JlYXRlUHJvdmlzaW9uYWxQYWdlKFByb3Zpc2lv bmFsUGFnZVByb3h5JiBwcm92aXNpb25hbFBhZ2UpCit7CisgICAgYWRkVGFyZ2V0KEluc3BlY3Rv clRhcmdldFByb3h5OjpjcmVhdGUocHJvdmlzaW9uYWxQYWdlLCBnZXRUYXJnZXRJRChwcm92aXNp b25hbFBhZ2UpLCBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGU6OlBhZ2UpKTsKK30KKwor dm9pZCBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlcjo6d2lsbERlc3Ryb3lQcm92aXNpb25hbFBh Z2UoY29uc3QgUHJvdmlzaW9uYWxQYWdlUHJveHkmIHByb3Zpc2lvbmFsUGFnZSkKK3sKKyAgICBk ZXN0cm95SW5zcGVjdG9yVGFyZ2V0KGdldFRhcmdldElEKHByb3Zpc2lvbmFsUGFnZSkpOworfQor Cit2b2lkIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyOjpkaWRDb21taXRQcm92aXNpb25hbFBh Z2UoV2ViQ29yZTo6UGFnZUlkZW50aWZpZXIgb2xkV2ViUGFnZUlELCBXZWJDb3JlOjpQYWdlSWRl bnRpZmllciBuZXdXZWJQYWdlSUQpCit7CisgICAgU3RyaW5nIG9sZElEID0gV2ViUGFnZUluc3Bl Y3RvclRhcmdldDo6dG9UYXJnZXRJRChvbGRXZWJQYWdlSUQpOworICAgIFN0cmluZyBuZXdJRCA9 IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OnRvVGFyZ2V0SUQobmV3V2ViUGFnZUlEKTsKKyAgICBp ZiAoYXV0byogdGFyZ2V0ID0gbV90YXJnZXRzLmdldChuZXdJRCkpCisgICAgICAgIHRhcmdldC0+ ZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQoKTsKKyAgICBtX3RhcmdldEFnZW50LT5kaWRDb21t aXRQcm92aXNpb25hbFRhcmdldChvbGRJRCwgbmV3SUQpOworCisgICAgLy8gV2UndmUgZGlzY29u bmVjdGVkIGZyb20gdGhlIG9sZCBwYWdlIGFuZCB3aWxsIG5vdCByZWNlaXZlIGFueSBtZXNzYWdl IGZyb20gaXQsIHNvCisgICAgLy8gd2UgZGVzdHJveSB0aGUgdGFyZ2V0IGhlcmUuCisgICAgZGVz dHJveUluc3BlY3RvclRhcmdldChvbGRJRCk7Cit9CisKK3ZvaWQgV2ViUGFnZUluc3BlY3RvckNv bnRyb2xsZXI6OmFkZFRhcmdldChzdGQ6OnVuaXF1ZV9wdHI8SW5zcGVjdG9yVGFyZ2V0UHJveHk+ JiYgdGFyZ2V0KQoreworICAgIG1fdGFyZ2V0QWdlbnQtPnRhcmdldENyZWF0ZWQoKnRhcmdldCk7 CisgICAgbV90YXJnZXRzLnNldCh0YXJnZXQtPmlkZW50aWZpZXIoKSwgV1RGTW92ZSh0YXJnZXQp KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oIGIvU291cmNlL1dlYktpdC9V SVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvckNvbnRyb2xsZXIuaAppbmRleCAwY2FmNmExYzI3OTIw NDNkM2JlMDU3MWEyOGZkYjFlMTQxOTdhNjExLi44MGMxYzEyZDI3ZGM4Mzk0ZDdlMDdhZTVkMzI1 ZjZlOTVlMmU0MDVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdl SW5zcGVjdG9yQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBh Z2VJbnNwZWN0b3JDb250cm9sbGVyLmgKQEAgLTY1LDEzICs2NSwxOSBAQCBwdWJsaWM6CiAgICAg dm9pZCBkZXN0cm95SW5zcGVjdG9yVGFyZ2V0KGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQpOwogICAg IHZvaWQgc2VuZE1lc3NhZ2VUb0luc3BlY3RvckZyb250ZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0 SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSk7CiAKKyAgICB2b2lkIGRpZENyZWF0ZVByb3Zpc2lv bmFsUGFnZShQcm92aXNpb25hbFBhZ2VQcm94eSYpOworICAgIHZvaWQgd2lsbERlc3Ryb3lQcm92 aXNpb25hbFBhZ2UoY29uc3QgUHJvdmlzaW9uYWxQYWdlUHJveHkmKTsKKyAgICB2b2lkIGRpZENv bW1pdFByb3Zpc2lvbmFsUGFnZShXZWJDb3JlOjpQYWdlSWRlbnRpZmllciBvbGRXZWJQYWdlSUQs IFdlYkNvcmU6OlBhZ2VJZGVudGlmaWVyIG5ld1dlYlBhZ2VJRCk7CisKIHByaXZhdGU6CisgICAg dm9pZCBhZGRUYXJnZXQoc3RkOjp1bmlxdWVfcHRyPEluc3BlY3RvclRhcmdldFByb3h5PiYmKTsK KwogICAgIFdlYlBhZ2VQcm94eSYgbV9wYWdlOwogICAgIFJlZjxJbnNwZWN0b3I6OkZyb250ZW5k Um91dGVyPiBtX2Zyb250ZW5kUm91dGVyOwogICAgIFJlZjxJbnNwZWN0b3I6OkJhY2tlbmREaXNw YXRjaGVyPiBtX2JhY2tlbmREaXNwYXRjaGVyOwogICAgIEluc3BlY3Rvcjo6QWdlbnRSZWdpc3Ry eSBtX2FnZW50czsKICAgICBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldEFnZW50KiBtX3Rhcmdl dEFnZW50OwotICAgIFZlY3RvcjxSZWZQdHI8SW5zcGVjdG9yVGFyZ2V0UHJveHk+PiBtX3Rhcmdl dHM7CisgICAgSGFzaE1hcDxTdHJpbmcsIHN0ZDo6dW5pcXVlX3B0cjxJbnNwZWN0b3JUYXJnZXRQ cm94eT4+IG1fdGFyZ2V0czsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmNw cCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5j cHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJhMDAxYzA4ZDAyZjdlZDZjMDA4NTY2 ZjdhZjg5YTM4MWNkZWQyMTUuLjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRhcmdldEFn ZW50LmNwcAorKysgL2Rldi9udWxsCkBAIC0xLDU1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQg KEMpIDIwMTggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAotICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFO WQotICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKLSAqIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAotICogRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi0gKiBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVk ZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmgiCi0KLW5hbWVzcGFjZSBXZWJLaXQgewot Ci1XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2Vu dChJbnNwZWN0b3I6OkZyb250ZW5kUm91dGVyJiBmcm9udGVuZFJvdXRlciwgSW5zcGVjdG9yOjpC YWNrZW5kRGlzcGF0Y2hlciYgYmFja2VuZERpc3BhdGNoZXIpCi0gICAgOiBJbnNwZWN0b3I6Oklu c3BlY3RvclRhcmdldEFnZW50KGZyb250ZW5kUm91dGVyLCBiYWNrZW5kRGlzcGF0Y2hlcikKLSAg ICAsIG1fcm91dGVyKGZyb250ZW5kUm91dGVyKQotewotfQotCi1XZWJQYWdlSW5zcGVjdG9yVGFy Z2V0QWdlbnQ6On5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQoKSA9IGRlZmF1bHQ7Ci0KLUlu c3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsJiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OmZy b250ZW5kQ2hhbm5lbCgpCi17Ci0gICAgcmV0dXJuICp0aGlzOwotfQotCi1JbnNwZWN0b3I6OkZy b250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUgV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50 Ojpjb25uZWN0aW9uVHlwZSgpIGNvbnN0Ci17Ci0gICAgcmV0dXJuIG1fcm91dGVyLmhhc0xvY2Fs RnJvbnRlbmQoKSA/IEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZTo6 TG9jYWwgOiBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGU6OlJlbW90 ZTsKLX0KLQotdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQ6OnNlbmRNZXNzYWdlVG9G cm9udGVuZChjb25zdCBTdHJpbmcmKQotewotICAgIC8vIEludGVudGlvbmFsbHkgaWdub3JlZCwg dGhpcyBjaGFubmVsIGlzIG5vdCBhY3R1YWxseSB1c2VkIHRvIHNlbmQgbWVzc2FnZXMuCi0gICAg QVNTRVJUX05PVF9SRUFDSEVEKCk7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50 LmggYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQu aApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTYzZjljM2NjY2VhNTQ4N2E0Y2UyOTNl YzVlMDgzYThjYzhiNTE1NC4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdl bnQuaAorKysgL2Rldi9udWxsCkBAIC0xLDQ5ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMp IDIwMTggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAot ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCi0gKiBhcmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0Ci0gKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQot ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKLSAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAotICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAotICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCi0gKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCi0gKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jcHJhZ21hIG9uY2UKLQotI2luY2x1ZGUgPEphdmFT Y3JpcHRDb3JlL0luc3BlY3RvckZyb250ZW5kQ2hhbm5lbC5oPgotI2luY2x1ZGUgPEphdmFTY3Jp cHRDb3JlL0luc3BlY3RvclRhcmdldEFnZW50Lmg+Ci0KLW5hbWVzcGFjZSBXZWJLaXQgewotCi1j bGFzcyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQgZmluYWwgOiBwdWJsaWMgSW5zcGVjdG9y OjpJbnNwZWN0b3JUYXJnZXRBZ2VudCwgcHVibGljIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVs IHsKLXB1YmxpYzoKLSAgICBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQoSW5zcGVjdG9yOjpG cm9udGVuZFJvdXRlciYsIEluc3BlY3Rvcjo6QmFja2VuZERpc3BhdGNoZXImKTsKLSAgICB2aXJ0 dWFsIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQoKTsKLQotICAgIC8vIEluc3BlY3RvclRh cmdldEFnZW50Ci0gICAgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWwmIGZyb250ZW5kQ2hhbm5l bCgpOwotCi0gICAgLy8gRnJvbnRlbmRDaGFubmVsCi0gICAgSW5zcGVjdG9yOjpGcm9udGVuZENo YW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKCkgY29uc3Q7Ci0gICAgdm9pZCBz ZW5kTWVzc2FnZVRvRnJvbnRlbmQoY29uc3QgU3RyaW5nJik7Ci0KLXByaXZhdGU6Ci0gICAgSW5z cGVjdG9yOjpGcm9udGVuZFJvdXRlciYgbV9yb3V0ZXI7Ci19OwotCi19IC8vIG5hbWVzcGFjZSBX ZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5j cHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDA0MTgy Yjk4Y2EyMDdmYzIyYTc0ZGUxOTEwNjdkNTg1NTZiYjg0NmEuLjdkMjhjMWU2YzE3YTAxMGE2N2Y1 MTQyZjU0MDYwNzE2MmIyMWYxOTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcApAQCAtNDkxLDggKzQ5MSw2IEBAIFdlYlBhZ2VQcm94eTo6V2ViUGFnZVByb3h5KFBh Z2VDbGllbnQmIHBhZ2VDbGllbnQsIFdlYlByb2Nlc3NQcm94eSYgcHJvY2VzcywgUmVmCiAgICAg bV9pbnNwZWN0b3JEZWJ1Z2dhYmxlLT5zZXRSZW1vdGVEZWJ1Z2dpbmdBbGxvd2VkKHRydWUpOwog ICAgIG1faW5zcGVjdG9yRGVidWdnYWJsZS0+aW5pdCgpOwogI2VuZGlmCi0KLSAgICBjcmVhdGVJ bnNwZWN0b3JUYXJnZXRzKCk7CiB9CiAKIFdlYlBhZ2VQcm94eTo6fldlYlBhZ2VQcm94eSgpCkBA IC04NDIsOSArODQwLDYgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmZpbmlzaEF0dGFjaGluZ1RvV2Vi UHJvY2VzcyhQcm9jZXNzTGF1bmNoUmVhc29uIHJlYXNvbikKICAgICByZW1vdGVJbnNwZWN0b3JJ bmZvcm1hdGlvbkRpZENoYW5nZSgpOwogI2VuZGlmCiAKLSAgICBjbGVhckluc3BlY3RvclRhcmdl dHMoKTsKLSAgICBjcmVhdGVJbnNwZWN0b3JUYXJnZXRzKCk7Ci0KICAgICBwYWdlQ2xpZW50KCku ZGlkUmVsYXVuY2hQcm9jZXNzKCk7CiAgICAgbV9wYWdlTG9hZFN0YXRlLmRpZFN3YXBXZWJQcm9j ZXNzZXMoKTsKICAgICBpZiAocmVhc29uICE9IFByb2Nlc3NMYXVuY2hSZWFzb246OkluaXRpYWxQ cm9jZXNzKQpAQCAtMTYyOCwxNyArMTYyMyw2IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpyZW1vdGVJ bnNwZWN0b3JJbmZvcm1hdGlvbkRpZENoYW5nZSgpCiB9CiAjZW5kaWYKIAotdm9pZCBXZWJQYWdl UHJveHk6OmNsZWFySW5zcGVjdG9yVGFyZ2V0cygpCi17Ci0gICAgbV9pbnNwZWN0b3JDb250cm9s bGVyLT5jbGVhclRhcmdldHMoKTsKLX0KLQotdm9pZCBXZWJQYWdlUHJveHk6OmNyZWF0ZUluc3Bl Y3RvclRhcmdldHMoKQotewotICAgIFN0cmluZyBwYWdlVGFyZ2V0SWQgPSBtYWtlU3RyaW5nKCJw YWdlLSIsIG1fd2ViUGFnZUlELnRvVUludDY0KCkpOwotICAgIG1faW5zcGVjdG9yQ29udHJvbGxl ci0+Y3JlYXRlSW5zcGVjdG9yVGFyZ2V0KHBhZ2VUYXJnZXRJZCwgSW5zcGVjdG9yOjpJbnNwZWN0 b3JUYXJnZXRUeXBlOjpQYWdlKTsKLX0KLQogdm9pZCBXZWJQYWdlUHJveHk6OnNldEJhY2tncm91 bmRDb2xvcihjb25zdCBPcHRpb25hbDxDb2xvcj4mIGNvbG9yKQogewogICAgIGlmIChtX2JhY2tn cm91bmRDb2xvciA9PSBjb2xvcikKQEAgLTI5OTcsNiArMjk4MSw3IEBAIHZvaWQgV2ViUGFnZVBy b3h5Ojpjb21taXRQcm92aXNpb25hbFBhZ2UoRnJhbWVJZGVudGlmaWVyIGZyYW1lSUQsIHVpbnQ2 NF90IG5hdmlnCiAgICAgaWYgKCFkaWRTdXNwZW5kUHJldmlvdXNQYWdlKQogICAgICAgICBtX3By b2Nlc3MtPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OkNsb3NlKCksIG1fd2ViUGFnZUlEKTsKIAor ICAgIGNvbnN0IGF1dG8gb2xkV2ViUGFnZUlEID0gbV93ZWJQYWdlSUQ7CiAgICAgc3dhcFRvV2Vi UHJvY2VzcyhtX3Byb3Zpc2lvbmFsUGFnZS0+cHJvY2VzcygpLCBtX3Byb3Zpc2lvbmFsUGFnZS0+ d2ViUGFnZUlEKCksIG1fcHJvdmlzaW9uYWxQYWdlLT50YWtlRHJhd2luZ0FyZWEoKSwgbV9wcm92 aXNpb25hbFBhZ2UtPm1haW5GcmFtZSgpKTsKIAogI2lmIFBMQVRGT1JNKENPQ09BKQpAQCAtMzAw Nyw2ICsyOTkyLDcgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmNvbW1pdFByb3Zpc2lvbmFsUGFnZShG cmFtZUlkZW50aWZpZXIgZnJhbWVJRCwgdWludDY0X3QgbmF2aWcKIAogICAgIGRpZENvbW1pdExv YWRGb3JGcmFtZShmcmFtZUlELCBuYXZpZ2F0aW9uSUQsIG1pbWVUeXBlLCBmcmFtZUhhc0N1c3Rv bUNvbnRlbnRQcm92aWRlciwgZnJhbWVMb2FkVHlwZSwgY2VydGlmaWNhdGVJbmZvLCBjb250YWlu c1BsdWdpbkRvY3VtZW50LCBmb3JjZWRIYXNJbnNlY3VyZUNvbnRlbnQsIHVzZXJEYXRhKTsKIAor ICAgIG1faW5zcGVjdG9yQ29udHJvbGxlci0+ZGlkQ29tbWl0UHJvdmlzaW9uYWxQYWdlKG9sZFdl YlBhZ2VJRCwgbV93ZWJQYWdlSUQpOwogICAgIG1fcHJvdmlzaW9uYWxQYWdlID0gbnVsbHB0cjsK IH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmgg Yi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAppbmRleCBhNDE2OTdjZDUx ZWJjOWFkMjM1Yzc1YTVmMzFmM2I2YmRhZTg4MDEzLi4yN2EwNGNjZmJmZTQ5NjQxMDMyNmQ2NjQ1 MGMzZTk1NGEwNWViNDg3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApA QCAtMjA2Miw5ICsyMDYyLDYgQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgc3RvcEFsbFVSTFNjaGVt ZVRhc2tzKFdlYlByb2Nlc3NQcm94eSogPSBudWxscHRyKTsKIAotICAgIHZvaWQgY2xlYXJJbnNw ZWN0b3JUYXJnZXRzKCk7Ci0gICAgdm9pZCBjcmVhdGVJbnNwZWN0b3JUYXJnZXRzKCk7Ci0KICNp ZiBFTkFCTEUoQVRUQUNITUVOVF9FTEVNRU5UKQogICAgIHZvaWQgcmVnaXN0ZXJBdHRhY2htZW50 SWRlbnRpZmllckZyb21EYXRhKGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYgY29udGVudFR5 cGUsIGNvbnN0IFN0cmluZyYgcHJlZmVycmVkRmlsZU5hbWUsIGNvbnN0IElQQzo6RGF0YVJlZmVy ZW5jZSYpOwogICAgIHZvaWQgcmVnaXN0ZXJBdHRhY2htZW50SWRlbnRpZmllckZyb21GaWxlUGF0 aChjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIGNvbnRlbnRUeXBlLCBjb25zdCBTdHJpbmcm IGZpbGVQYXRoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViS2l0L1dlYktpdC54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IGRhYWExN2ViNmJjYjI2NjQ4NjQ0ODQ1NWNhNjFlYmI0ZTJkYzhkN2UuLjEz YmM3YzRmNTQyYjk3ODgyNDYwOGIyMDQ5NWM5NGFlYjIzNjJjNjggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvV2ViS2l0Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dl YktpdC9XZWJLaXQueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTM2OCw3ICsxMzY4LDYg QEAKIAkJQTU0M0UzMDcyMTVBRDEzNzAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRG cm9udGVuZENoYW5uZWwuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEE1NDNFMzA1MjE1QUQxMkQwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 RnJvbnRlbmRDaGFubmVsLmggKi87IH07CiAJCUE1NDNFMzBDMjE1QzhBOEQwMDI3OUNEOSAvKiBX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBBNTQzRTMwODIxNUM4QTgzMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3Rv clRhcmdldC5oICovOyB9OwogCQlBNTQzRTMwRDIxNUM4QTkwMDAyNzlDRDkgLyogV2ViUGFnZUlu c3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEE1NDNFMzBCMjE1QzhBODQwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVj dG9yVGFyZ2V0Q29udHJvbGxlci5oICovOyB9OwotCQlBNTQzRTMxMDIxNUQ4Q0U2MDAyNzlDRDkg LyogV2ViUGFnZUluc3BlY3RvclRhcmdldEFnZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBNTQzRTMwRTIxNUQ4Q0UyMDAyNzlDRDkgLyogV2ViUGFn ZUluc3BlY3RvclRhcmdldEFnZW50LmggKi87IH07CiAJCUE1NUJBODEwMUJBMTMxN0UwMDdDRDMz RCAvKiBfV0tSZW1vdGVXZWJJbnNwZWN0b3JWaWV3Q29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTU1QkE4MEMxQkExMkJFMTAwN0NEMzNE IC8qIF9XS1JlbW90ZVdlYkluc3BlY3RvclZpZXdDb250cm9sbGVyLmggKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQTU1QkE4MTcxQkEyM0UxMjAwN0NE MzNEIC8qIFJlbW90ZVdlYkluc3BlY3RvclVJLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSBBNTVCQTgxMzFCQTIzRTA1MDA3Q0QzM0QgLyogUmVtb3RlV2Vi SW5zcGVjdG9yVUkuaCAqLzsgfTsKIAkJQTU1QkE4MUYxQkEyNUIyNzAwN0NEMzNEIC8qIFJlbW90 ZVdlYkluc3BlY3RvclByb3h5LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBBNTVCQTgxOTFCQTI1QjFFMDA3Q0QzM0QgLyogUmVtb3RlV2ViSW5zcGVjdG9y UHJveHkuaCAqLzsgfTsKQEAgLTQxMTIsOCArNDExMSw2IEBACiAJCUE1NDNFMzA5MjE1QzhBODMw MDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE1NDNFMzBBMjE1QzhBODQwMDI3OUNEOSAvKiBXZWJQYWdl SW5zcGVjdG9yVGFyZ2V0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdlYlBhZ2VJbnNwZWN0b3JU YXJnZXQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBNTQzRTMwQjIxNUM4QTg0 MDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXIuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKLQkJQTU0M0UzMEUyMTVEOENFMjAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0 b3JUYXJnZXRBZ2VudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdl bnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKLQkJQTU0M0UzMEYyMTVEOENFMjAwMjc5 Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlBNTVCQTgwQzFCQTEyQkUxMDA3Q0QzM0QgLyogX1dLUmVtb3RlV2ViSW5zcGVjdG9y Vmlld0NvbnRyb2xsZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gX1dLUmVt b3RlV2ViSW5zcGVjdG9yVmlld0NvbnRyb2xsZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJQTU1QkE4MEQxQkExMkJFMTAwN0NEMzNEIC8qIF9XS1JlbW90ZVdlYkluc3BlY3RvclZp ZXdDb250cm9sbGVyLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0g X1dLUmVtb3RlV2ViSW5zcGVjdG9yVmlld0NvbnRyb2xsZXIubW07IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUE1NUJBODEyMUJBMjNFMDUwMDdDRDMzRCAvKiBSZW1vdGVXZWJJbnNwZWN0 b3JVSS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW1vdGVXZWJJ bnNwZWN0b3JVSS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC03ODkzLDggKzc4 OTAsNiBAQAogCQkJCTJEOUVBMzBFMUE5NkNCRkYwMDJEMjgwNyAvKiBXZWJQYWdlSW5qZWN0ZWRC dW5kbGVDbGllbnQuaCAqLywKIAkJCQlBNTEzRjUzRjIxNTRBNUNEMDA2NjI4NDEgLyogV2ViUGFn ZUluc3BlY3RvckNvbnRyb2xsZXIuY3BwICovLAogCQkJCUE1MTNGNTNFMjE1NEE1Q0MwMDY2Mjg0 MSAvKiBXZWJQYWdlSW5zcGVjdG9yQ29udHJvbGxlci5oICovLAotCQkJCUE1NDNFMzBGMjE1RDhD RTIwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuY3BwICovLAotCQkJCUE1 NDNFMzBFMjE1RDhDRTIwMDI3OUNEOSAvKiBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0QWdlbnQuaCAq LywKIAkJCQlCQzExMUIwQjExMkY1RTRGMDAzMzdCQUIgLyogV2ViUGFnZVByb3h5LmNwcCAqLywK IAkJCQlCQzAzMkRDQjEwRjQzODlGMDA1OEMxNUEgLyogV2ViUGFnZVByb3h5LmggKi8sCiAJCQkJ QkNCRDM4RkExMjVCQUI5QTAwRDJDMjlGIC8qIFdlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbiAqLywK QEAgLTk5NzksNyArOTk3NCw2IEBACiAJCQkJMkQ5RUEzMEYxQTk2Q0JGRjAwMkQyODA3IC8qIFdl YlBhZ2VJbmplY3RlZEJ1bmRsZUNsaWVudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTUxM0Y1NDAy MTU0QTVENzAwNjYyODQxIC8qIFdlYlBhZ2VJbnNwZWN0b3JDb250cm9sbGVyLmggaW4gSGVhZGVy cyAqLywKIAkJCQlBNTQzRTMwQzIxNUM4QThEMDAyNzlDRDkgLyogV2ViUGFnZUluc3BlY3RvclRh cmdldC5oIGluIEhlYWRlcnMgKi8sCi0JCQkJQTU0M0UzMTAyMTVEOENFNjAwMjc5Q0Q5IC8qIFdl YlBhZ2VJbnNwZWN0b3JUYXJnZXRBZ2VudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTU0M0UzMEQy MTVDOEE5MDAwMjc5Q0Q5IC8qIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmggaW4g SGVhZGVycyAqLywKIAkJCQlBNTQzRTMwNzIxNUFEMTM3MDAyNzlDRDkgLyogV2ViUGFnZUluc3Bl Y3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzBDRTcyQTEx MjQ3RTcxRDAwQkMwRUM0IC8qIFdlYlBhZ2VNZXNzYWdlcy5oIGluIEhlYWRlcnMgKi8sCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9y VGFyZ2V0LmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNw ZWN0b3JUYXJnZXQuY3BwCmluZGV4IDU2YjBkNTJlYzU5NTdjYzczYTEzZjA2N2ViM2NkYTAzMmRl MjE3NTguLmE3MGY2ZmQ1MjA5NmE1ZGNhOTAxZWE3MGEzNzU1ZjE0ZDZiNGEwZmQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJn ZXQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNw ZWN0b3JUYXJnZXQuY3BwCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSAiV2ViUGFnZUluc3Bl Y3RvclRhcmdldC5oIgogCiAjaW5jbHVkZSAiV2ViUGFnZS5oIgorI2luY2x1ZGUgIldlYlBhZ2VJ bnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaCIKICNpbmNsdWRlIDxXZWJDb3JlL0luc3Bl Y3RvckNvbnRyb2xsZXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BhZ2UuaD4KIApAQCAtNDEsMTkg KzQyLDI1IEBAIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXQo V2ViUGFnZSYgcGFnZSkKIAogU3RyaW5nIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQ6OmlkZW50aWZp ZXIoKSBjb25zdAogewotICAgIHJldHVybiBtYWtlU3RyaW5nKCJwYWdlLSIsIG1fcGFnZS5pZGVu dGlmaWVyKCkudG9VSW50NjQoKSk7CisgICAgcmV0dXJuIHRvVGFyZ2V0SUQobV9wYWdlLmlkZW50 aWZpZXIoKSk7CiB9CiAKLXZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldDo6Y29ubmVjdChJbnNw ZWN0b3I6OkZyb250ZW5kQ2hhbm5lbCYgY2hhbm5lbCkKK3ZvaWQgV2ViUGFnZUluc3BlY3RvclRh cmdldDo6Y29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUg Y29ubmVjdGlvblR5cGUpCiB7CisgICAgaWYgKG1fY2hhbm5lbCkKKyAgICAgICAgcmV0dXJuOwor ICAgIG1fY2hhbm5lbCA9IG1ha2VVbmlxdWU8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5k Q2hhbm5lbD4obV9wYWdlLCBpZGVudGlmaWVyKCksIGNvbm5lY3Rpb25UeXBlKTsKICAgICBpZiAo bV9wYWdlLmNvcmVQYWdlKCkpCi0gICAgICAgIG1fcGFnZS5jb3JlUGFnZSgpLT5pbnNwZWN0b3JD b250cm9sbGVyKCkuY29ubmVjdEZyb250ZW5kKGNoYW5uZWwpOworICAgICAgICBtX3BhZ2UuY29y ZVBhZ2UoKS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLmNvbm5lY3RGcm9udGVuZCgqbV9jaGFubmVs KTsKIH0KIAotdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0OjpkaXNjb25uZWN0KEluc3BlY3Rv cjo6RnJvbnRlbmRDaGFubmVsJiBjaGFubmVsKQordm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 OjpkaXNjb25uZWN0KCkKIHsKKyAgICBpZiAoIW1fY2hhbm5lbCkKKyAgICAgICAgcmV0dXJuOwog ICAgIGlmIChtX3BhZ2UuY29yZVBhZ2UoKSkKLSAgICAgICAgbV9wYWdlLmNvcmVQYWdlKCktPmlu c3BlY3RvckNvbnRyb2xsZXIoKS5kaXNjb25uZWN0RnJvbnRlbmQoY2hhbm5lbCk7CisgICAgICAg IG1fcGFnZS5jb3JlUGFnZSgpLT5pbnNwZWN0b3JDb250cm9sbGVyKCkuZGlzY29ubmVjdEZyb250 ZW5kKCptX2NoYW5uZWwpOworICAgIG1fY2hhbm5lbC5yZXNldCgpOwogfQogCiB2b2lkIFdlYlBh Z2VJbnNwZWN0b3JUYXJnZXQ6OnNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmlu ZyYgbWVzc2FnZSkKQEAgLTYyLDQgKzY5LDEwIEBAIHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdl dDo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJiBtZXNzYWdlKQogICAg ICAgICBtX3BhZ2UuY29yZVBhZ2UoKS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLmRpc3BhdGNoTWVz c2FnZUZyb21Gcm9udGVuZChtZXNzYWdlKTsKIH0KIAorU3RyaW5nIFdlYlBhZ2VJbnNwZWN0b3JU YXJnZXQ6OnRvVGFyZ2V0SUQoV2ViQ29yZTo6UGFnZUlkZW50aWZpZXIgcGFnZUlEKQoreworICAg IHJldHVybiBtYWtlU3RyaW5nKCJwYWdlLSIsIHBhZ2VJRC50b1VJbnQ2NCgpKTsKK30KKworCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXQuaAppbmRleCBiNzBlMzFjOGI4Nzcw YzRiZjFlY2I0NTg4ZWJmMjY3NWIzYjlmNDY0Li42Y2JkN2ZhZDVmZjkxYWZkODU4ZGEzNDZhZGJm ZWVkNjQyNGIwYjJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFn ZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0LmgKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNz L1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldC5oCkBAIC0yNiwyOSArMjYsMzQgQEAKICNw cmFnbWEgb25jZQogCiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSW5zcGVjdG9yVGFyZ2V0Lmg+ CisjaW5jbHVkZSA8V2ViQ29yZS9QYWdlSWRlbnRpZmllci5oPgogI2luY2x1ZGUgPHd0Zi9Ob25j b3B5YWJsZS5oPgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViUGFnZTsKK2NsYXNz IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWw7CiAKIGNsYXNzIFdlYlBhZ2VJ bnNwZWN0b3JUYXJnZXQgZmluYWwgOiBwdWJsaWMgSW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXQg ewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogICAgIFdURl9NQUtFX05PTkNPUFlBQkxF KFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQpOwogcHVibGljOgotICAgIFdlYlBhZ2VJbnNwZWN0b3JU YXJnZXQoV2ViUGFnZSYpOworICAgIGV4cGxpY2l0IFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXQoV2Vi UGFnZSYpOwogICAgIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0KCkgPSBkZWZhdWx0OwogCiAgICAg SW5zcGVjdG9yOjpJbnNwZWN0b3JUYXJnZXRUeXBlIHR5cGUoKSBjb25zdCBmaW5hbCB7IHJldHVy biBJbnNwZWN0b3I6Okluc3BlY3RvclRhcmdldFR5cGU6OlBhZ2U7IH0KIAogICAgIFN0cmluZyBp ZGVudGlmaWVyKCkgY29uc3QgZmluYWw7CiAKLSAgICB2b2lkIGNvbm5lY3QoSW5zcGVjdG9yOjpG cm9udGVuZENoYW5uZWwmKTsKLSAgICB2b2lkIGRpc2Nvbm5lY3QoSW5zcGVjdG9yOjpGcm9udGVu ZENoYW5uZWwmKTsKLSAgICB2b2lkIHNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0 cmluZyYpOworICAgIHZvaWQgY29ubmVjdChJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29u bmVjdGlvblR5cGUpIG92ZXJyaWRlOworICAgIHZvaWQgZGlzY29ubmVjdCgpIG92ZXJyaWRlOwor ICAgIHZvaWQgc2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQoY29uc3QgU3RyaW5nJikgb3ZlcnJp ZGU7CisKKyAgICBzdGF0aWMgU3RyaW5nIHRvVGFyZ2V0SUQoV2ViQ29yZTo6UGFnZUlkZW50aWZp ZXIpOwogCiBwcml2YXRlOgogICAgIFdlYlBhZ2UmIG1fcGFnZTsKKyAgICBzdGQ6OnVuaXF1ZV9w dHI8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4gbV9jaGFubmVsOwogfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlci5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJv bGxlci5jcHAKaW5kZXggNTI1NDg5NjczZDY2YTJlNGE3ZmQzMmYzNjQ4NTM0Y2UzZWRlZWM0Ny4u Y2RhNGYxZThkM2M1NzUzNjE2MmFhMzkwZWQ3NGI2ODFjODkxMzQwZSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRy b2xsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJ bnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmNwcApAQCAtNTgsNyArNTgsNiBAQCB2b2lkIFdlYlBh Z2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpyZW1vdmVUYXJnZXQoSW5zcGVjdG9yOjpJbnNw ZWN0b3JUYXJnZXQmCiAgICAgbV9wYWdlLnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGVz dHJveUluc3BlY3RvclRhcmdldCh0YXJnZXQuaWRlbnRpZmllcigpKSk7CiAKICAgICBtX3Rhcmdl dHMucmVtb3ZlKHRhcmdldC5pZGVudGlmaWVyKCkpOwotICAgIG1fdGFyZ2V0RnJvbnRlbmRDaGFu bmVscy5yZW1vdmUodGFyZ2V0LmlkZW50aWZpZXIoKSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3Bl Y3RvclRhcmdldENvbnRyb2xsZXI6OmNvbm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5nJiB0YXJn ZXRJZCwgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlIGNvbm5lY3Rp b25UeXBlKQpAQCAtNjcsMTMgKzY2LDcgQEAgdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29u dHJvbGxlcjo6Y29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkLAogICAgIGlm ICghdGFyZ2V0KQogICAgICAgICByZXR1cm47CiAKLSAgICBSZWZQdHI8V2ViUGFnZUluc3BlY3Rv clRhcmdldEZyb250ZW5kQ2hhbm5lbD4gY2hhbm5lbCA9IG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVs cy5nZXQodGFyZ2V0SWQpOwotICAgIGlmICghY2hhbm5lbCkgewotICAgICAgICBjaGFubmVsID0g V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbDo6Y3JlYXRlKCp0aGlzLCB0YXJn ZXRJZCwgY29ubmVjdGlvblR5cGUpOwotICAgICAgICBtX3RhcmdldEZyb250ZW5kQ2hhbm5lbHMu c2V0KHRhcmdldC0+aWRlbnRpZmllcigpLCBjaGFubmVsKTsKLSAgICB9Ci0KLSAgICB0YXJnZXQt PmNvbm5lY3QoKmNoYW5uZWwuZ2V0KCkpOworICAgIHRhcmdldC0+Y29ubmVjdChjb25uZWN0aW9u VHlwZSk7CiB9CiAKIHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OmRpc2Nv bm5lY3RJbnNwZWN0b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCkKQEAgLTgyLDExICs3NSw3IEBA IHZvaWQgV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xsZXI6OmRpc2Nvbm5lY3RJbnNwZWN0 b3IoY29uc3QgU3RyaW5nJiB0YXJnZXRJCiAgICAgaWYgKCF0YXJnZXQpCiAgICAgICAgIHJldHVy bjsKIAotICAgIFJlZlB0cjxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsPiBj aGFubmVsID0gbV90YXJnZXRGcm9udGVuZENoYW5uZWxzLnRha2UodGFyZ2V0SWQpOwotICAgIGlm ICghY2hhbm5lbCkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgdGFyZ2V0LT5kaXNjb25uZWN0KCpj aGFubmVsLmdldCgpKTsKKyAgICB0YXJnZXQtPmRpc2Nvbm5lY3QoKTsKIH0KIAogdm9pZCBXZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb1RhcmdldEJhY2tlbmQo Y29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlKQpAQCAtOTgsOSAr ODcsNCBAQCB2b2lkIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyOjpzZW5kTWVzc2Fn ZVRvVGFyZ2V0QmFja2VuZChjb25zdCBTdHJpbmcmCiAgICAgdGFyZ2V0LT5zZW5kTWVzc2FnZVRv VGFyZ2V0QmFja2VuZChtZXNzYWdlKTsKIH0KIAotdm9pZCBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 Q29udHJvbGxlcjo6c2VuZE1lc3NhZ2VUb1RhcmdldEZyb250ZW5kKGNvbnN0IFN0cmluZyYgdGFy Z2V0SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKLXsKLSAgICBtX3BhZ2Uuc2VuZChNZXNzYWdl czo6V2ViUGFnZVByb3h5OjpTZW5kTWVzc2FnZVRvSW5zcGVjdG9yRnJvbnRlbmQodGFyZ2V0SWQs IG1lc3NhZ2UpKTsKLX0KLQogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJv bGxlci5oIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3Rv clRhcmdldENvbnRyb2xsZXIuaAppbmRleCAzZTkyYjdhOWRhOWU1NjA5ZTYwMTY2MzljMDliNzNj YjU5NmY4YWY1Li43YzkzMWRhZDFjOTgwMGYwM2Q3M2Q0YTdjYTI1ODhkZDAyOGE4ZjI0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9y VGFyZ2V0Q29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdl L1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyLmgKQEAgLTI2LDcgKzI2LDYgQEAKICNw cmFnbWEgb25jZQogCiAjaW5jbHVkZSAiV2ViUGFnZUluc3BlY3RvclRhcmdldC5oIgotI2luY2x1 ZGUgIldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwuaCIKICNpbmNsdWRlIDx3 dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCkBAIC01MCwx MyArNDksMTEgQEAgcHVibGljOgogICAgIHZvaWQgY29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJp bmcmIHRhcmdldElkLCBJbnNwZWN0b3I6OkZyb250ZW5kQ2hhbm5lbDo6Q29ubmVjdGlvblR5cGUp OwogICAgIHZvaWQgZGlzY29ubmVjdEluc3BlY3Rvcihjb25zdCBTdHJpbmcmIHRhcmdldElkKTsK ICAgICB2b2lkIHNlbmRNZXNzYWdlVG9UYXJnZXRCYWNrZW5kKGNvbnN0IFN0cmluZyYgdGFyZ2V0 SWQsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSk7Ci0gICAgdm9pZCBzZW5kTWVzc2FnZVRvVGFyZ2V0 RnJvbnRlbmQoY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgY29uc3QgU3RyaW5nJiBtZXNzYWdlKTsK IAogcHJpdmF0ZToKICAgICBXZWJQYWdlJiBtX3BhZ2U7CiAgICAgV2ViUGFnZUluc3BlY3RvclRh cmdldCBtX3BhZ2VUYXJnZXQ7CiAgICAgSGFzaE1hcDxTdHJpbmcsIEluc3BlY3Rvcjo6SW5zcGVj dG9yVGFyZ2V0Kj4gbV90YXJnZXRzOwotICAgIEhhc2hNYXA8U3RyaW5nLCBSZWZQdHI8V2ViUGFn ZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4+IG1fdGFyZ2V0RnJvbnRlbmRDaGFubmVs czsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5l bC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9y VGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcAppbmRleCA4ZDc4ODA3ODJhMjliMTcwY2U2NWFmYzcw Mzc3ZDhiZDUwNjk0MzU4Li5lMWI1ZjcxMzczM2EwOTUyNTIxMjJmMGEzODAxZjgyYzhjNjBkM2Y2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5z cGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlBy b2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmNwcApA QCAtMjYsMTcgKzI2LDEzIEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2ViUGFn ZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oIgogCi0jaW5jbHVkZSAiV2ViUGFnZUlu c3BlY3RvclRhcmdldENvbnRyb2xsZXIuaCIKKyNpbmNsdWRlICJXZWJQYWdlLmgiCisjaW5jbHVk ZSAiV2ViUGFnZVByb3h5TWVzc2FnZXMuaCIKIAogbmFtZXNwYWNlIFdlYktpdCB7CiAKLVJlZjxX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsPiBXZWJQYWdlSW5zcGVjdG9yVGFy Z2V0RnJvbnRlbmRDaGFubmVsOjpjcmVhdGUoV2ViUGFnZUluc3BlY3RvclRhcmdldENvbnRyb2xs ZXImIHRhcmdldENvbnRyb2xsZXIsIGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6 RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSBjb25uZWN0aW9uVHlwZSkKLXsKLSAgICBy ZXR1cm4gYWRvcHRSZWYoKm5ldyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVs KHRhcmdldENvbnRyb2xsZXIsIHRhcmdldElkLCBjb25uZWN0aW9uVHlwZSkpOwotfQotCi1XZWJQ YWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsOjpXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0 RnJvbnRlbmRDaGFubmVsKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyJiB0YXJnZXRD b250cm9sbGVyLCBjb25zdCBTdHJpbmcmIHRhcmdldElkLCBJbnNwZWN0b3I6OkZyb250ZW5kQ2hh bm5lbDo6Q29ubmVjdGlvblR5cGUgY29ubmVjdGlvblR5cGUpCi0gICAgOiBtX3RhcmdldENvbnRy b2xsZXIodGFyZ2V0Q29udHJvbGxlcikKK1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENo YW5uZWw6OldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwoV2ViUGFnZSYgcGFn ZSwgY29uc3QgU3RyaW5nJiB0YXJnZXRJZCwgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNv bm5lY3Rpb25UeXBlIGNvbm5lY3Rpb25UeXBlKQorICAgIDogbV9wYWdlKHBhZ2UpCiAgICAgLCBt X3RhcmdldElkKHRhcmdldElkKQogICAgICwgbV9jb25uZWN0aW9uVHlwZShjb25uZWN0aW9uVHlw ZSkKIHsKQEAgLTQ0LDcgKzQwLDcgQEAgV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hh bm5lbDo6V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbChXZWIKIAogdm9pZCBX ZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsOjpzZW5kTWVzc2FnZVRvRnJvbnRl bmQoY29uc3QgU3RyaW5nJiBtZXNzYWdlKQogewotICAgIG1fdGFyZ2V0Q29udHJvbGxlci5zZW5k TWVzc2FnZVRvVGFyZ2V0RnJvbnRlbmQobV90YXJnZXRJZCwgbWVzc2FnZSk7CisgICAgbV9wYWdl LnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6U2VuZE1lc3NhZ2VUb0luc3BlY3RvckZyb250 ZW5kKG1fdGFyZ2V0SWQsIG1lc3NhZ2UpKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlSW5zcGVj dG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmggYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsLmgKaW5kZXggNzZhZjYy YTk3YmVmNDg4YjY0NGU1ZDYxOGQ0MzllYzlhNDJmMjJkYS4uOTc2MDk4ZGE0ZDdiZTU2M2YxYjkz MTEyNjE5N2U0MmYwOGQxY2MxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNz L1dlYlBhZ2UvV2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9u dGVuZENoYW5uZWwuaApAQCAtMzEsMjIgKzMxLDIwIEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewog Ci1jbGFzcyBXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlcjsKK2NsYXNzIFdlYlBhZ2U7 CiAKLWNsYXNzIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwgZmluYWwgOiBw dWJsaWMgUmVmQ291bnRlZDxXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsPiwg cHVibGljIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsIHsKK2NsYXNzIFdlYlBhZ2VJbnNwZWN0 b3JUYXJnZXRGcm9udGVuZENoYW5uZWwgZmluYWwgOiBwdWJsaWMgSW5zcGVjdG9yOjpGcm9udGVu ZENoYW5uZWwgewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOworICAgIFdURl9NQUtFX05P TkNPUFlBQkxFKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwpOwogcHVibGlj OgotICAgIHN0YXRpYyBSZWY8V2ViUGFnZUluc3BlY3RvclRhcmdldEZyb250ZW5kQ2hhbm5lbD4g Y3JlYXRlKFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyJiwgY29uc3QgU3RyaW5nJiB0 YXJnZXRJZCwgSW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlKTsKLSAg ICB2aXJ0dWFsIH5XZWJQYWdlSW5zcGVjdG9yVGFyZ2V0RnJvbnRlbmRDaGFubmVsKCkgPSBkZWZh dWx0OworICAgIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwoV2ViUGFnZSYs IGNvbnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25u ZWN0aW9uVHlwZSk7CisgICAgfldlYlBhZ2VJbnNwZWN0b3JUYXJnZXRGcm9udGVuZENoYW5uZWwo KSBvdmVycmlkZSA9IGRlZmF1bHQ7CiAKIHByaXZhdGU6Ci0gICAgV2ViUGFnZUluc3BlY3RvclRh cmdldEZyb250ZW5kQ2hhbm5lbChXZWJQYWdlSW5zcGVjdG9yVGFyZ2V0Q29udHJvbGxlciYsIGNv bnN0IFN0cmluZyYgdGFyZ2V0SWQsIEluc3BlY3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0 aW9uVHlwZSk7Ci0KICAgICBDb25uZWN0aW9uVHlwZSBjb25uZWN0aW9uVHlwZSgpIGNvbnN0IG92 ZXJyaWRlIHsgcmV0dXJuIG1fY29ubmVjdGlvblR5cGU7IH0KICAgICB2b2lkIHNlbmRNZXNzYWdl VG9Gcm9udGVuZChjb25zdCBTdHJpbmcmIG1lc3NhZ2UpIG92ZXJyaWRlOwogCi1wcml2YXRlOgot ICAgIFdlYlBhZ2VJbnNwZWN0b3JUYXJnZXRDb250cm9sbGVyJiBtX3RhcmdldENvbnRyb2xsZXI7 CisgICAgV2ViUGFnZSYgbV9wYWdlOwogICAgIFN0cmluZyBtX3RhcmdldElkOwogICAgIEluc3Bl Y3Rvcjo6RnJvbnRlbmRDaGFubmVsOjpDb25uZWN0aW9uVHlwZSBtX2Nvbm5lY3Rpb25UeXBlIHsg SW5zcGVjdG9yOjpGcm9udGVuZENoYW5uZWw6OkNvbm5lY3Rpb25UeXBlOjpSZW1vdGUgfTsKIH07 CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKaW5kZXggZDc4MzAyYTZkZWFlMzI0YTM1ZjIzYWZkNTlkYzdkNTVkYjM0NzQwNi4uMDU2MmUx ZjI2MmY3OGQ0NTcyMDM3MmJhMDA4MGVlMDAxZjljNjA3MCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBA CisyMDE5LTEwLTAxICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3JnPgorCisg ICAgICAgIFdlYiBJbnNwZWN0b3I6IGF0dGFjaCB0byBwcm92aXNpb25hbCBwYWdlcyBlYXJseSB0 byBub3QgbWlzcyBldmVudHMgZHVyaW5nIHByb2Nlc3Mgc3dhcHMgKFBTT04pCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDIyMTkKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCBuZXcgdGVzdCBmb3Ig VGFyZ2V0IGV2ZW50cyBkdXJpbmcgUFNPTi4gSXQgaXMgb25seSBlbmFibGVkIG9uIFdlYktpdDIg YXMgdGhlcmUgaXMKKyAgICAgICAgbm8gVGFyZ2V0IGFnZW50IGluIFdlYktpdDEuCisKKyAgICAg ICAgKiBUZXN0RXhwZWN0YXRpb25zOgorICAgICAgICAqIGh0dHAvdGVzdHMvaW5zcGVjdG9yL3Rh cmdldC90YXJnZXQtZXZlbnRzLWZvci1wcm92aXNpb25hbC1wYWdlLWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFyZ2V0L3RhcmdldC1ldmVudHMt Zm9yLXByb3Zpc2lvbmFsLXBhZ2UuaHRtbDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vd2sy L1Rlc3RFeHBlY3RhdGlvbnM6CisKIDIwMTktMTAtMDcgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdl YmtpdC5vcmc+CiAKICAgICAgICAgZm9jdXMgcHNldWRvIGNsYXNzIHNob3VsZCBtYXRjaCBhIHNo YWRvdyBob3N0IHdob3NlIHNoYWRvdyB0cmVlIGNvbnRhaW5zIHRoZSBmb2N1c2VkIGVsZW1lbnQK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL1Rlc3RFeHBlY3RhdGlvbnMgYi9MYXlvdXRUZXN0cy9U ZXN0RXhwZWN0YXRpb25zCmluZGV4IDYxZTNhYzVlZGZiZTM1NTJkN2MyOTNiNzIxYzU2MGU3MWY4 ZTFhNWQuLmFlMDBmMmQ2ODYzZjgwMDJiNTk0OWIyNzZhZmFkOGEyYThiN2RjNzYgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMvVGVzdEV4 cGVjdGF0aW9ucwpAQCAtOTExLDYgKzkxMSw5IEBAIHdlYmtpdC5vcmcvYi8xNjE5NTEgWyBEZWJ1 ZyBdIGluc3BlY3Rvci9kZWJ1Z2dlci9wYXVzZWQtc2NvcGVzLmh0bWwgWyBTa2lwIF0KIGluc3Bl Y3Rvci9kZWJ1Z2dlci9ldmFsdWF0ZU9uQ2FsbEZyYW1lLWVtdWxhdGVVc2VyR2VzdHVyZS11c2Vy SXNJbnRlcmFjdGluZy5odG1sIFsgU2tpcCBdCiBpbnNwZWN0b3IvcnVudGltZS9ldmFsdWF0ZS1l bXVsYXRlVXNlckdlc3R1cmUtdXNlcklzSW50ZXJhY3RpbmcuaHRtbCBbIFNraXAgXQogCisjIFRh cmdldCBkb21haW4gaXMgb25seSBwcmVzZW50IGluIFdLMi4KK2h0dHAvdGVzdHMvaW5zcGVjdG9y L3RhcmdldCBbIFNraXAgXQorCiAjIFRoZXNlIGNvbmZvcm1hbmNlIHRlc3RzIGFyZSBubyBsb25n ZXIgaW4gc3luYyB3aXRoIHRoZSBsYXRlc3Qgc3BlY2lmaWNhdGlvbgogIyBhbmQgZXhwZWN0IGNv bXBhcmVEb2N1bWVudFBvc2l0aW9uKCkgdG8gcmV0dXJuOgogIyBET0NVTUVOVF9QT1NJVElPTl9J TVBMRU1FTlRBVElPTl9TUEVDSUZJQyB8IERPQ1VNRU5UX1BPU0lUSU9OX0RJU0NPTk5FQ1RFRApk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFyZ2V0L3Rhcmdl dC1ldmVudHMtZm9yLXByb3Zpc2lvbmFsLXBhZ2UtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFyZ2V0L3RhcmdldC1ldmVudHMtZm9yLXByb3Zpc2lvbmFs LXBhZ2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQzMTc0N2I3NGQxMTA1MTJjNjg2YTlmZDdj MTRlYTlhM2M4OGRjN2YKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L2luc3BlY3Rvci90YXJnZXQvdGFyZ2V0LWV2ZW50cy1mb3ItcHJvdmlzaW9uYWwtcGFnZS1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSwxOSBAQAorVGVzdCB0aGF0IGNyb3NzIGRvbWFpbiBuYXZpZ2F0 aW9uIHJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyBzZXF1ZW5jZSBvZiBldmVudHMgaW4gVGFyZ2V0 IGRvbWFpbjogCisxLiBUYXJnZXQudGFyZ2V0Q3JlYXRlZCBmb3IgcHJvdmlzaW9uYWwgcGFnZS4g CisyLiBUYXJnZXQuZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJnZXQgd2hlbiBwcm92aXNpb25hbCBs b2FkIGlzIGNvbW1pdHRlZC4gCiszLiBUYXJnZXQudGFyZ2V0RGVzdHJveWVkIGZvciB0aGUgb2xk IHRhcmdldCBhZnRlciB0aGUgbmF2aWdhdGlvbiByZXF1ZXN0IGlzIGNvbW1pdHRlZC4KKworUEFT UzogU2hvdWxkIHJlY2VpdmUgdGFyZ2V0RGVzdHJveWVkIGV2ZW50LgorUEFTUzogRGVzdHJveWVk IHRhcmdldCBzaG91bGQgYmUgcHJldmlvdXMgdGFyZ2V0LgorCis9PSBSdW5uaW5nIHRlc3Qgc3Vp dGU6IFRhcmdldC5QU09OCistLSBSdW5uaW5nIHRlc3QgY2FzZTogUHJvdmlzaW9uYWxQYWdlVGFy Z2V0CitQQVNTOiBTaG91bGQgcmVjZWl2ZSB0YXJnZXRDcmVhdGVkIGV2ZW50LgorUEFTUzogVGFy Z2V0IHNob3VsZCBiZSBwcm92aXNpb25hbC4KK1BBU1M6IFByZXZpb3VzIHRhcmdldCBpZCBzaG91 bGQgYmUgaWQgb2YgdGhlIGN1cnJlbnQgdGFyZ2V0LgorUEFTUzogU2hvdWxkIHJlY2VpdmUgZGlk Q29tbWl0UHJvdmlzaW9uYWxUYXJnZXQgZXZlbnQuCitQQVNTOiBQcmV2aW91cyB0YXJnZXQgc2hv dWxkIGJlIHRoZSBjdXJyZW50IG9uZS4KK1BBU1M6IENvbW1pdHRlZCB0YXJnZXQgc2hvdWxkIG1h dGNoIHByb3Zpc2lvbmFsIHRhcmdldC4KK1BBU1M6IFNob3VsZCByZWNlaXZlIHRhcmdldERlc3Ry b3llZCBldmVudC4KK1BBU1M6IERlc3Ryb3llZCB0YXJnZXQgc2hvdWxkIGJlIHByZXZpb3VzIHRh cmdldC4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9pbnNwZWN0b3IvdGFy Z2V0L3RhcmdldC1ldmVudHMtZm9yLXByb3Zpc2lvbmFsLXBhZ2UuaHRtbCBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvaW5zcGVjdG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZvci1wcm92aXNpb25h bC1wYWdlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTM3YzFmNjkzMTkzZjQ5ZTE1MGE5YjdhMWU5NzQ2MTdm Zjc4NDRjMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvaW5zcGVj dG9yL3RhcmdldC90YXJnZXQtZXZlbnRzLWZvci1wcm92aXNpb25hbC1wYWdlLmh0bWwKQEAgLTAs MCArMSw2MyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgY2hhcnNl dD0idXRmLTgiPgorPHNjcmlwdCBzcmM9Ii4uL3Jlc291cmNlcy9pbnNwZWN0b3ItdGVzdC5qcyI+ PC9zY3JpcHQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgpCit7CisgICAgbGV0IHN1aXRlID0g SW5zcGVjdG9yVGVzdC5jcmVhdGVBc3luY1N1aXRlKCJUYXJnZXQuUFNPTiIpOworCisgICAgc3Vp dGUuYWRkVGVzdENhc2UoeworICAgICAgICBuYW1lOiAiUHJvdmlzaW9uYWxQYWdlVGFyZ2V0IiwK KyAgICAgICAgZGVzY3JpcHRpb246ICJDaGVjayB0aGF0IGEgbmV3IHRhcmdldCB3aWxsIGJlIGNy ZWF0ZWQgZm9yIHByb3Zpc2lvbmFsIHBhZ2UuIiwKKyAgICAgICAgdGVzdChyZXNvbHZlLCByZWpl Y3QpIHsKKyAgICAgICAgICAgIGNvbnN0IG1haW5UYXJnZXRJZCA9IFdJLm1haW5UYXJnZXQuaWRl bnRpZmllcjsKKyAgICAgICAgICAgIGxldCBuZXdUYXJnZXRJZDsKKyAgICAgICAgICAgIEluc3Bl Y3RvclRlc3QuYXNzZXJ0KG1haW5UYXJnZXRJZCk7CisgICAgICAgICAgICBUYXJnZXRBZ2VudC5k aXNwYXRjaGVyID0gbmV3IFByb3h5KFRhcmdldEFnZW50LmRpc3BhdGNoZXIsIHsKKyAgICAgICAg ICAgICAgICBnZXQodGFyZ2V0LCBwcm9wLCByZWNlaXZlcikgeworICAgICAgICAgICAgICAgICAg ICBpZiAocHJvcCA9PT0gInRhcmdldENyZWF0ZWQiKSB7CisgICAgICAgICAgICAgICAgICAgICAg ICByZXR1cm4gKHRhcmdldEluZm8pID0+IHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBu ZXdUYXJnZXRJZCA9IHRhcmdldEluZm8udGFyZ2V0SWQ7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgSW5zcGVjdG9yVGVzdC5wYXNzKGBTaG91bGQgcmVjZWl2ZSAke3Byb3B9IGV2ZW50LmAp OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIEluc3BlY3RvclRlc3QuZXhwZWN0VHJ1ZSh0 YXJnZXRJbmZvLmlzUHJvdmlzaW9uYWwsICJUYXJnZXQgc2hvdWxkIGJlIHByb3Zpc2lvbmFsLiIp OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIEluc3BlY3RvclRlc3QuZXhwZWN0RXF1YWwo dGFyZ2V0SW5mby5wcmV2aW91c1RhcmdldElkLCBtYWluVGFyZ2V0SWQsICJQcmV2aW91cyB0YXJn ZXQgaWQgc2hvdWxkIGJlIGlkIG9mIHRoZSBjdXJyZW50IHRhcmdldC4iKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gdGFyZ2V0W3Byb3BdLmNhbGwocmVjZWl2ZXIsIHRhcmdl dEluZm8pOworICAgICAgICAgICAgICAgICAgICAgICAgfTsKKyAgICAgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgICAgICBpZiAocHJvcCA9PT0gImRpZENvbW1pdFByb3Zpc2lvbmFs VGFyZ2V0IikgeworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuICh0YXJnZXRJbmZvKSA9 PiB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgSW5zcGVjdG9yVGVzdC5wYXNzKGBTaG91 bGQgcmVjZWl2ZSAke3Byb3B9IGV2ZW50LmApOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IEluc3BlY3RvclRlc3QuZXhwZWN0RXF1YWwodGFyZ2V0SW5mby5wcmV2aW91c1RhcmdldElkLCBt YWluVGFyZ2V0SWQsICJQcmV2aW91cyB0YXJnZXQgc2hvdWxkIGJlIHRoZSBjdXJyZW50IG9uZS4i KTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbnNwZWN0b3JUZXN0LmV4cGVjdEVxdWFs KHRhcmdldEluZm8udGFyZ2V0SWQsIG5ld1RhcmdldElkLCAiQ29tbWl0dGVkIHRhcmdldCBzaG91 bGQgbWF0Y2ggcHJvdmlzaW9uYWwgdGFyZ2V0LiIpOworICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiB0YXJnZXRbcHJvcF0uY2FsbChyZWNlaXZlciwgdGFyZ2V0SW5mbyk7CisgICAg ICAgICAgICAgICAgICAgICAgICB9OworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgICAgIGlmIChwcm9wID09PSAidGFyZ2V0RGVzdHJveWVkIikgeworICAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuICh0YXJnZXRJZCkgPT4geworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEluc3BlY3RvclRlc3QucGFzcyhgU2hvdWxkIHJlY2VpdmUgJHtwcm9wfSBldmVudC5g KTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbnNwZWN0b3JUZXN0LmV4cGVjdEVxdWFs KHRhcmdldElkLCBtYWluVGFyZ2V0SWQsICJEZXN0cm95ZWQgdGFyZ2V0IHNob3VsZCBiZSBwcmV2 aW91cyB0YXJnZXQuIik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVzb2x2ZSgpOwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0YXJnZXRbcHJvcF0uY2FsbChyZWNl aXZlciwgdGFyZ2V0SWQpOworICAgICAgICAgICAgICAgICAgICAgICAgfTsKKyAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFyZ2V0W3Byb3BdOworICAg ICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0pOworICAgICAgICAgICAgUnVudGltZUFnZW50 LmV2YWx1YXRlKCJsb2NhdGlvbi5ob3N0bmFtZT0nbG9jYWxob3N0JyIpOworICAgICAgICB9Cisg ICAgfSk7CisKKyAgICBzdWl0ZS5ydW5UZXN0Q2FzZXNBbmRGaW5pc2goKTsKK30KKzwvc2NyaXB0 PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPgorPHA+VGVzdCB0aGF0IGNyb3Nz IGRvbWFpbiBuYXZpZ2F0aW9uIHJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyBzZXF1ZW5jZSBvZiBl dmVudHMgaW4gVGFyZ2V0IGRvbWFpbjoKKzxicj4xLiBUYXJnZXQudGFyZ2V0Q3JlYXRlZCBmb3Ig cHJvdmlzaW9uYWwgcGFnZS4KKzxicj4yLiBUYXJnZXQuZGlkQ29tbWl0UHJvdmlzaW9uYWxUYXJn ZXQgd2hlbiBwcm92aXNpb25hbCBsb2FkIGlzIGNvbW1pdHRlZC4KKzxicj4zLiBUYXJnZXQudGFy Z2V0RGVzdHJveWVkIGZvciB0aGUgb2xkIHRhcmdldCBhZnRlciB0aGUgbmF2aWdhdGlvbiByZXF1 ZXN0IGlzIGNvbW1pdHRlZC4KKzwvcD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL3drMi9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vd2syL1Rlc3RFeHBlY3RhdGlvbnMKaW5kZXggMDJkNjg5ODFiNTdlMWZjZTA5MDMyMmJm ZjNlNGMyMDNhZDQ5MmE4Ny4uN2Q0ZmI2NjA1MmY2YmQ5Mzc5NWEyZDEyMDU1MjFkMGUyNmNkYWM3 MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL1Rlc3RFeHBlY3RhdGlvbnMK KysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTc2NCw2 ICs3NjQsOSBAQCBodHRwL3Rlc3RzL2FkQ2xpY2tBdHRyaWJ1dGlvbiBbIFBhc3MgXQogaW5zcGVj dG9yL2RlYnVnZ2VyL2V2YWx1YXRlT25DYWxsRnJhbWUtZW11bGF0ZVVzZXJHZXN0dXJlLXVzZXJJ c0ludGVyYWN0aW5nLmh0bWwgWyBQYXNzIF0KIGluc3BlY3Rvci9ydW50aW1lL2V2YWx1YXRlLWVt dWxhdGVVc2VyR2VzdHVyZS11c2VySXNJbnRlcmFjdGluZy5odG1sIFsgUGFzcyBdCiAKKyMgVGFy Z2V0IGRvbWFpbiBpcyBvbmx5IHByZXNlbnQgaW4gV2ViS2l0Mi4KK2h0dHAvdGVzdHMvaW5zcGVj dG9yL3RhcmdldCBbIFBhc3MgXQorCiAjIyMgRU5EIE9GICg1KSBQcm9ncmVzc2lvbnMsIGV4cGVj dGVkIHN1Y2Nlc3NlcyB0aGF0IGFyZSBleHBlY3RlZCBmYWlsdXJlcyBpbiBXZWJLaXQxLgogIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogCg==