33224 2010-01-05 11:39:47 -0800 Chains of history items representing same-document navigation need to always remember that association 2010-02-19 10:11:00 -0800 1 1 1 Unclassified WebKit History 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 1 fishd fishd aroben beidson evan gustavo ian oldest_to_newest 177271 0 fishd 2010-01-05 11:39:47 -0800 popstate event is only fired when navigating back to a live document according to http://dev.w3.org/html5/spec/Overview.html#activating-state-object-entries, the popstate event should be fired after the load event. the implication is that it should be possible to reload the URL, and then fire the popstate event. fast/loader/stateobjects/document-destroyed-navigate-back.html seems to assert this "incorrect" behavior. I think this bug results from having HistoryItem objects store a pointer to a Document. Instead, I think they should probably have a "group id" or a "document id" that can be used to know that they are all associated with the same document even if the actual Document object changes. 177536 1 fishd 2010-01-05 21:32:56 -0800 whatwg discussion here: http://lists.whatwg.org/htdig.cgi/whatwg-whatwg.org/2010-January/024675.html 179885 2 beidson 2010-01-12 10:50:19 -0800 (In reply to comment #0) > popstate event is only fired when navigating back to a live document > > according to > http://dev.w3.org/html5/spec/Overview.html#activating-state-object-entries, the > popstate event should be fired after the load event. the implication is that > it should be possible to reload the URL, and then fire the popstate event. 5.10.1 states: "User agents may discard the Document objects of entries other than the current entry that are not referenced from any script, reloading the pages afresh when the user or script navigates back to such pages. This specification does not specify when user agents should discard Document objects and when they should cache them." 5.11.9.1 then states: "If there is no longer a Document object for the entry in question, the user agent must navigate the browsing context to the location for that entry to perform an entry update of that entry, and abort these steps." So your suggestion would *only* work in the case of a reload, *if* reload behavior is specified to reuse the same entry and same document. I'm looking through the spec to find out if this is the case but am so far coming up blank. Do you have a reference? I disagree that the language is an implication for the behavior you describe for another reason - there's another possibility where the language makes sense. If - while a document is loading - a script does a pushstate() followed by a history.back(), all before the document is loaded, then the popped state object will become the pending state object and the event will be fired after the load event. I coded for this case when developing the initial feature and thought I had a layout test that covered it. In experimenting before making this comment, I have proven that this appears to be broken and I've filed https://bugs.webkit.org/show_bug.cgi?id=33538 to cover fixing it. > fast/loader/stateobjects/document-destroyed-navigate-back.html seems to assert > this "incorrect" behavior. This seems *not* true, as this layout test does not describe the reload case, and therefore definitely plays along with the different-document-allowed-to-clear-at-any-time model described in the spec. > I think this bug results from having HistoryItem objects store a pointer to a > Document. Instead, I think they should probably have a "group id" or a > "document id" that can be used to know that they are all associated with the > same document even if the actual Document object changes. For the reasons I lay out above, I don't agree. The interesting thing I think we need an answer on is what the spec intends for the reload case. WebCore certainly uses different documents internally for a reload and adopting different behavior would have wide-ranging implications. 179905 3 fishd 2010-01-12 11:32:00 -0800 > 5.11.9.1 then states: > "If there is no longer a Document object for the entry in question, the user > agent must navigate the browsing context to the location for that entry to > perform an entry update of that entry, and abort these steps." The navigate algorithm (section 5.11.1) ends with "Some of the sections below, to which the above algorithm defers in certain cases, require the user agent to update the session history with the new page. When a user agent is required to do this, it must queue a task to run the following steps: 1) Unload the Document object of the current entry, with the recycle parameter set to false. 2) If the navigation was initiated for entry update of an entry 1) Replace the entry being updated with a new entry representing the new resource and its Document object and related state. The user agent may propagate state from the old entry to the new entry (e.g. scroll position). 2) Traverse the history to the new entry." Notice step 2.2 there. It says to repeat the steps at 5.11.9.1, given that we now have a live document associated with the session history entry, we can proceed with the history traversal algorithm. The reload case is a compelling argument for this bug. It seems pretty lame if all of the pushed state gets discarded by the act of reloading the document. > If - while a document is loading - a script does a pushstate() followed by a > history.back(), all before the document is loaded, then the popped state object > will become the pending state object and the event will be fired after the load > event. Good point. > > fast/loader/stateobjects/document-destroyed-navigate-back.html seems to assert > > this "incorrect" behavior. > > This seems *not* true, as this layout test does not describe the reload case, > and therefore definitely plays along with the > different-document-allowed-to-clear-at-any-time model described in the spec. That layout test asserts that navigating back to a session history entry for which there is no live document causes the pushed state to be discarded. Am I really misunderstanding? 179959 4 beidson 2010-01-12 13:19:06 -0800 (In reply to comment #3) > > 5.11.9.1 then states: > > "If there is no longer a Document object for the entry in question, the user > > agent must navigate the browsing context to the location for that entry to > > perform an entry update of that entry, and abort these steps." > > The navigate algorithm (section 5.11.1) ends with > > "Some of the sections below, to which the above algorithm defers in > certain cases, require the user agent to update the session history > with the new page. When a user agent is required to do this, it must > queue a task to run the following steps: > > 1) Unload the Document object of the current entry, with the recycle > parameter set to false. > > 2) If the navigation was initiated for entry update of an entry > > 1) Replace the entry being updated with a new entry representing > the new resource and its Document object and related state. The > user agent may propagate state from the old entry to the new > entry (e.g. scroll position). Step 2.1 states "replace the entry being updated with a new entry representing the new resource and its Document object and related state." It doesn't say the new entry is somehow a clone of the old entry, but rather an original entity representing the new Document object and its resource. I believe "state" in this context is not referring to "state objects", but rather "persisted user state" as set forth in 5.11.9 step 3: "For example, some user agents might want to persist the scroll position, or the values of form controls." This is supported by the second sentence of step 2.1: "The user agent may propagate state from the old entry to the new entry (e.g. scroll position)." We should probably file a bug on the docs to standardize on the term "persisted user state" in these situations. > 2) Traverse the history to the new entry." > > Notice step 2.2 there. It says to repeat the steps at 5.11.9.1, given > that we now have a live document associated with the session history > entry, we can proceed with the history traversal algorithm. Indeed. But this is a new live document, associated with a *NEW* session history entry, per step 2.1 which says we're now working with a new replacement entry. > The reload case is a compelling argument for this bug. It seems pretty > lame if all of the pushed state gets discarded by the act of reloading > the document. Users commonly hit the reload button in 2 cases: 1 - When they want to refresh the page to check for new content. 2 - When they think the current state of the page is broken and they want to "start over" In neither of those cases does the user care about preserving the state of the old page. > > > fast/loader/stateobjects/document-destroyed-navigate-back.html seems to assert > > > this "incorrect" behavior. > > > > This seems *not* true, as this layout test does not describe the reload case, > > and therefore definitely plays along with the > > different-document-allowed-to-clear-at-any-time model described in the spec. > > That layout test asserts that navigating back to a session history entry for > which there is no live document causes the pushed state to be discarded. For clarification, the state object is discarded not when navigating back to the old document's URL, but when the navigating *away* from the old document and everything associated with it is destroyed. > Am I really misunderstanding? I could've been more clear - That layout test *does* indeed assert that in WebCore, right now, navigating back to a session history entry for which there is no live document does not result in any popstate event being fired. We both agree on that. I'm saying that this is compatible with the spec, and you disagree. :) 181108 5 ian 2010-01-14 23:11:49 -0800 I've updated the spec. 182151 6 46891 fishd 2010-01-18 23:29:14 -0800 Created attachment 46891 work in progress 183041 7 46891 beidson 2010-01-20 19:33:01 -0800 Comment on attachment 46891 work in progress > Index: WebCore/history/BackForwardListChromium.cpp > =================================================================== > --- WebCore/history/BackForwardListChromium.cpp (revision 53388) > +++ WebCore/history/BackForwardListChromium.cpp (working copy) > @@ -50,13 +50,13 @@ BackForwardList::~BackForwardList() > ASSERT(m_closed); > } > > -void BackForwardList::addItem(PassRefPtr<HistoryItem> prpItem) > +void BackForwardList::addItem(PassRefPtr<HistoryItem> newItem) > { > - ASSERT(prpItem); > + ASSERT(newItem); > if (m_capacity == 0 || !m_enabled) > return; > > - m_client->addItem(prpItem); > + m_client->addItem(newItem); > } These changes seem unnecessary - the prp idiom is common within WebCore/Kit and this seems to just kludge the patch. > void BackForwardList::pushStateItem(PassRefPtr<HistoryItem> newItem) > { > - // FIXME: Need to implement state support for chromium. > + RefPtr<HistoryItem> current = m_client->currentItem(); > + > + addItem(newItem); > + > + if (!current->stateObject()) > + current->setStateObject(SerializedScriptValue::create()); > } I know this patch isn't the right time to address this, but I feel it would be a better design if the BackForwardList organization was with a class of shared functionality that split off the truly different methods into their own platform specific files. Like, if "getCurrentItem()" had a base implementation that everyone shared, but Chromium implemented their own with the client call. Then addItem() had a normal impl. and a Chromium impl, then this "pushStateItem()" method could be 100% shared and its logic could not possibly get out of sync between the ports. Like I said, something to be addressed another time... > > HistoryItemVector& BackForwardList::entries() > Index: WebCore/history/HistoryItem.cpp > =================================================================== > --- WebCore/history/HistoryItem.cpp (revision 53388) > +++ WebCore/history/HistoryItem.cpp (working copy) > @@ -33,9 +33,18 @@ > #include "PageCache.h" > #include "ResourceRequest.h" > #include <stdio.h> > +#include <wtf/CurrentTime.h> > > namespace WebCore { > > +static long long generateDocumentSequenceNumber() > +{ > + // Initialize to the current time to reduce the likelihood of generating > + // identifiers that overlap with those from past/future browser sessions. > + static long long next = static_cast<long long>(currentTime() * 1000000.0); > + return ++next; > +} *every* platform might want to get a full serialization of the session history in the future, that's for sure. But I don't like this. Can't we come up with a better way to get unique IDs across launches? And have them truly be unique and not just "probably" be unique? > + > Index: WebCore/loader/FrameLoader.cpp > =================================================================== > --- WebCore/loader/FrameLoader.cpp (revision 53388) > +++ WebCore/loader/FrameLoader.cpp (working copy) > @@ -3686,7 +3688,7 @@ Frame* FrameLoader::findFrameForNavigati > > void FrameLoader::navigateWithinDocument(HistoryItem* item) > { > - ASSERT(!item->document() || item->document() == m_frame->document()); > + ASSERT(item->documentSequenceNumber() == history()->currentItem()->documentSequenceNumber()); It's easy for logic to recognize that a sequence of historyitems with "0" as their sequence number are actually unrelated documents. It's harder to make sure that every history item has the right sequence number relationship with its neighbors before entering "navigateWithinDocument." I ran into at least a few edge cases in my initial implementation where that problem was the case, hence the allowance for a null document before your patch. I see you attempted to get at least one of these cases, but I remember (vaguely) that there were a handful. It might be better to retain the "null sequence number" that was representable by the null document pointer, and retain the full assertion here. > Index: WebCore/loader/FrameLoaderClient.h > =================================================================== > --- WebCore/loader/FrameLoaderClient.h (revision 53388) > +++ WebCore/loader/FrameLoaderClient.h (working copy) > @@ -116,6 +116,7 @@ namespace WebCore { > virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() = 0; > virtual void dispatchDidCancelClientRedirect() = 0; > virtual void dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate) = 0; > + virtual void dispatchDidNavigateWithinPage(bool isHashChange) = 0; A "Page" in WebCore nomenclature represents a top-level browsing context. I think this should be "didNavigateWithinDocument" Also, I don't like the bool. A within-document-navigation can be one of the following: -A state object navigation -A hash change navigation -Both I think an enum is more appropriate and allows for easier correction if more cases are added in the future. > void HistoryController::saveDocumentState() > @@ -629,18 +633,20 @@ void HistoryController::pushState(PassRe > { > Page* page = m_frame->page(); > ASSERT(page); > - > + > // Get a HistoryItem tree for the current frame tree. > RefPtr<HistoryItem> item = createItemTree(m_frame, false); > + ASSERT(item->isTargetItem()); > > - // Override data in the target item to reflect the pushState() arguments. > - HistoryItem* targetItem = item->targetItem(); > - ASSERT(targetItem->isTargetItem()); > - targetItem->setDocument(m_frame->document()); > - targetItem->setTitle(title); > - targetItem->setStateObject(stateObject); > - targetItem->setURLString(urlString); > - > + // Override data in the new item to reflect the pushState() arguments. > + item->setTitle(title); > + item->setStateObject(stateObject); > + item->setURLString(urlString); > + > + // Since the document isn't changed as a result of a fragment scroll, we should > + // preserve the DocumentSequenceNumber of the previous item. > + item->setDocumentSequenceNumber(m_previousItem->documentSequenceNumber()); > + > page->backForwardList()->pushStateItem(item.release()); > } Is this change of extracting the TargetItem necessary? I saw your FIXME in Page::goToItem(), and it seems related to this. And it's an interesting question. But this change seems unrelated to this patch and should probably be separate. I did not review the Chromium WebKit changes. 183103 8 fishd 2010-01-21 00:20:44 -0800 (In reply to comment #7) ... > > - m_client->addItem(prpItem); > > + m_client->addItem(newItem); > > } > > These changes seem unnecessary - the prp idiom is common within WebCore/Kit and > this seems to just kludge the patch. The prp idiom seemed like some ugly "hungarian notation" thing, and I didn't realize it was accepted *good* practice. I don't see any mention of this in the webkit style guide. > > > void BackForwardList::pushStateItem(PassRefPtr<HistoryItem> newItem) > > { > > - // FIXME: Need to implement state support for chromium. > > + RefPtr<HistoryItem> current = m_client->currentItem(); > > + > > + addItem(newItem); > > + > > + if (!current->stateObject()) > > + current->setStateObject(SerializedScriptValue::create()); > > } > > I know this patch isn't the right time to address this, but I feel it would be > a better design if the BackForwardList organization was with a class of shared > functionality that split off the truly different methods into their own > platform specific files. Like, if "getCurrentItem()" had a base implementation > that everyone shared, but Chromium implemented their own with the client call. > Then addItem() had a normal impl. and a Chromium impl, then this > "pushStateItem()" method could be 100% shared and its logic could not possibly > get out of sync between the ports. > > Like I said, something to be addressed another time... I totally agree. I had a similar idea in fact, but it definitely should happen as a separate patch. > > Index: WebCore/history/HistoryItem.cpp ... > > +static long long generateDocumentSequenceNumber() > > +{ > > + // Initialize to the current time to reduce the likelihood of generating > > + // identifiers that overlap with those from past/future browser sessions. > > + static long long next = static_cast<long long>(currentTime() * 1000000.0); > > + return ++next; > > +} > > *every* platform might want to get a full serialization of the session history > in the future, that's for sure. But I don't like this. Can't we come up with > a better way to get unique IDs across launches? And have them truly be unique > and not just "probably" be unique? Suggestions? I used this same technique in HTMLFormElement.cpp. > > Index: WebCore/loader/FrameLoader.cpp > > =================================================================== > > --- WebCore/loader/FrameLoader.cpp (revision 53388) > > +++ WebCore/loader/FrameLoader.cpp (working copy) > > @@ -3686,7 +3688,7 @@ Frame* FrameLoader::findFrameForNavigati > > > > void FrameLoader::navigateWithinDocument(HistoryItem* item) > > { > > - ASSERT(!item->document() || item->document() == m_frame->document()); > > + ASSERT(item->documentSequenceNumber() == history()->currentItem()->documentSequenceNumber()); > > It's easy for logic to recognize that a sequence of historyitems with "0" as > their sequence number are actually unrelated documents. It's harder to make > sure that every history item has the right sequence number relationship with > its neighbors before entering "navigateWithinDocument." I ran into at least a > few edge cases in my initial implementation where that problem was the case, > hence the allowance for a null document before your patch. > > I see you attempted to get at least one of these cases, but I remember > (vaguely) that there were a handful. > > It might be better to retain the "null sequence number" that was representable > by the null document pointer, and retain the full assertion here. I disagree. It seems like the common case is for each HistoryItem to correspond to a unique document. This is why I initialize each HistoryItem with a unique document sequence number. Only in the cases where we have a same document load do I then go back and set the sequence number of the newly created HistoryItem to the same value as the existing HistoryItem. This is done for state object navigation and hash change navigation, which are the only cases in which a new document isn't created. Either way we have to identify these cases. With the solution I've proposed, I don't have to go back and edit the previous HistoryItem when I realize that the newly created HistoryItem is going to refer to the same document. I just have to edit the newly created HistoryItem. I think that's cleaner. > > Index: WebCore/loader/FrameLoaderClient.h > > =================================================================== > > --- WebCore/loader/FrameLoaderClient.h (revision 53388) > > +++ WebCore/loader/FrameLoaderClient.h (working copy) > > @@ -116,6 +116,7 @@ namespace WebCore { > > virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() = 0; > > virtual void dispatchDidCancelClientRedirect() = 0; > > virtual void dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate) = 0; > > + virtual void dispatchDidNavigateWithinPage(bool isHashChange) = 0; > > A "Page" in WebCore nomenclature represents a top-level browsing context. I > think this should be "didNavigateWithinDocument" Yeah, I went back and forth on this. I chose WithinPage for consistency with existing methods. Perhaps those should also change to WithinDocument, or perhaps it is still reasonable to say WithinPage since the BackForwardList is a property of the Page. > Also, I don't like the bool. A within-document-navigation can be one of the > following: > -A state object navigation > -A hash change navigation > -Both Good idea. Like this? enum WithinDocumentNavigationType { StateObjectNavigation, HashChangeNavigation }; > > I think an enum is more appropriate and allows for easier correction if more > cases are added in the future. > > > void HistoryController::saveDocumentState() > > @@ -629,18 +633,20 @@ void HistoryController::pushState(PassRe > > { > > Page* page = m_frame->page(); > > ASSERT(page); > > - > > + > > // Get a HistoryItem tree for the current frame tree. > > RefPtr<HistoryItem> item = createItemTree(m_frame, false); > > + ASSERT(item->isTargetItem()); > > > > - // Override data in the target item to reflect the pushState() arguments. > > - HistoryItem* targetItem = item->targetItem(); > > - ASSERT(targetItem->isTargetItem()); > > - targetItem->setDocument(m_frame->document()); > > - targetItem->setTitle(title); > > - targetItem->setStateObject(stateObject); > > - targetItem->setURLString(urlString); > > - > > + // Override data in the new item to reflect the pushState() arguments. > > + item->setTitle(title); > > + item->setStateObject(stateObject); > > + item->setURLString(urlString); > > + > > + // Since the document isn't changed as a result of a fragment scroll, we should > > + // preserve the DocumentSequenceNumber of the previous item. > > + item->setDocumentSequenceNumber(m_previousItem->documentSequenceNumber()); > > + > > page->backForwardList()->pushStateItem(item.release()); > > } > > Is this change of extracting the TargetItem necessary? No, it is not strictly necessary. I just deleted it because I could prove that it was unnecessary. Hence, the assertion. Passing m_frame to createItemTree makes it true that the resulting HistoryItem is the target item. If you prefer it as a separate patch, I can certainly break it out, but it seemed trivial enough to include here. > I saw your FIXME in > Page::goToItem(), and it seems related to this. And it's an interesting > question. But this change seems unrelated to this patch and should probably be > separate. Yeah, I haven't fully tested subframe cases yet. I want to make sure I'm not regressing something. (There may already be layout tests for this.) > > I did not review the Chromium WebKit changes. Indeed, I plan to break them out as a separate patch. 183110 9 fishd 2010-01-21 00:45:01 -0800 >> > Index: WebCore/history/HistoryItem.cpp >... >> > +static long long generateDocumentSequenceNumber() >> > +{ >> > + // Initialize to the current time to reduce the likelihood of generating >> > + // identifiers that overlap with those from past/future browser >sessions. >> > + static long long next = static_cast<long long>(currentTime() * >1000000.0); >> > + return ++next; >> > +} >> >> *every* platform might want to get a full serialization of the session history >> in the future, that's for sure. But I don't like this. Can't we come up with >> a better way to get unique IDs across launches? And have them truly be unique >> and not just "probably" be unique? > > Suggestions? I used this same technique in HTMLFormElement.cpp. Note, this approach does a pretty good job of avoiding collisions. Notice that the counter is initialized to the current time in microseconds. To have collisions across browser sessions, you'd have to create more than 1 million page navigations per second. That seems extremely unlikely, and so I really question the need to do anything fancier. 183319 10 fishd 2010-01-21 14:26:45 -0800 (In reply to comment #8) ... > > Is this change of extracting the TargetItem necessary? > > No, it is not strictly necessary. I just deleted it because I could prove > that it was unnecessary. Hence, the assertion. Passing m_frame to > createItemTree makes it true that the resulting HistoryItem is the target > item. > > If you prefer it as a separate patch, I can certainly break it out, but it > seemed trivial enough to include here. I went ahead and broke this out as a separate patch. See https://bugs.webkit.org/show_bug.cgi?id=33969. 183688 11 beidson 2010-01-22 10:10:41 -0800 *** Bug 33823 has been marked as a duplicate of this bug. *** 183689 12 beidson 2010-01-22 10:11:40 -0800 Retitling to reflect the problem this bug is now actually trying to solve. 184507 13 47388 fishd 2010-01-25 22:42:10 -0800 Created attachment 47388 v1 patch Unlike the previous WIP, this version excludes the Chromium WebKit API bits. It also excludes the new FrameLoaderClient method. I'll come back to those in a follow-up. This patch just focuses on fixing this bug. I'll punt the other stuff to separate bugs. 184509 14 47388 beidson 2010-01-25 23:12:15 -0800 Comment on attachment 47388 v1 patch In reviewing this, I recalled a certain detail of the spec and dug in to it to remind myself. The spec states: "If the specified entry is a state object or the first entry for a Document, the user agent must activate that entry." I wonder if the document-destroyed-navigate-back test actually covers this. For example, if the sequence of entries for a document was: 1 - www.example.com 2 - www.example.com#someHash 3 - www.example.com#someHash (with a state object, via pushState()) Then going back from #3 to #2 should not generate a popstate because entry #2 is not a state object entry, and is also not the first entry for the document. Going back from #2 to #1 *should* generate a popstate event because entry #1 is the first entry, even though it is not a state object entry. Note that this is unrelated to your patch, and I don't think your patch changes WebKit's behavior whether we had it right or wrong. I'm just curious, and thought I'd mention it. Your patch looks fine. r+ 184510 15 beidson 2010-01-25 23:13:09 -0800 Actually, now that I think about it, the final history.back() might've been related to testing this edge case. My r+ is now conditional, based on you exploring that. =D 184650 16 fishd 2010-01-26 11:25:56 -0800 (In reply to comment #15) > Actually, now that I think about it, the final history.back() might've been > related to testing this edge case. My r+ is now conditional, based on you > exploring that. =D This particular layout test doesn't cover the scenario you described above. It does look like we have some issues to resolve w/ mixed hash changes and push states though. I'll file a bug. 184656 17 fishd 2010-01-26 11:42:22 -0800 Landed as http://trac.webkit.org/changeset/53861 184774 18 aroben 2010-01-26 15:00:47 -0800 Reverted r53861 for reason: Caused 2 regression tests to fail. Committed r53869: <http://trac.webkit.org/changeset/53869> 184780 19 fishd 2010-01-26 15:06:49 -0800 The tests that failed: fast/dom/location-hash.html fast/history/back-forward-is-asynchronous.html 184785 20 fishd 2010-01-26 15:17:48 -0800 It turns that those test regressions result because the tests are verifying that history.back() runs asynchronously even when navigating back to a reference fragment change. What this indicates is that r53672 did not actually change history.back() to work synchronously in the case of reference fragments. I think this has to do with the null check for HistoryItem::document(). Unless a state object was pushed, that would remain null. In the v1 patch above, I changed the code to just compare documentSequenceNumbers. As a result, the code now does synchronous history.back(). So, the tests just need to be adjusted to match the intent of r53672. 184943 21 47494 fishd 2010-01-26 22:06:33 -0800 Created attachment 47494 v2 patch Identical to v1 patch except that I reverted the layout test changes from http://trac.webkit.org/changeset/43274. 185174 22 47494 levin 2010-01-27 11:59:14 -0800 Comment on attachment 47494 v2 patch Based on previous r+ and the minor diff from them that looked reasonable. 185195 23 fishd 2010-01-27 13:19:00 -0800 Landed as http://trac.webkit.org/changeset/53950 186511 24 gustavo 2010-02-01 12:15:30 -0800 This change causes a crash in one of our unit tests. It looks like it's just a missing null-check. I am posting a patch to fix it here: https://bugs.webkit.org/show_bug.cgi?id=34443 191854 25 evan 2010-02-19 03:39:25 -0800 I think this caused a regression in an internal Google app. I don't have a reduction handy so I'm just linking to the internal bug. http://b/issue?id=2456001 191939 26 beidson 2010-02-19 09:15:54 -0800 Note that if this caused a regression in a test, then it is a strong possiblity that the test was operating on assumptions from the old and busted past, and is wrong in this new and hot future. ;) Get a reduction here and we can help explore. 191949 27 evan 2010-02-19 09:35:36 -0800 Darin said this commit fixed it: https://bugs.webkit.org/show_bug.cgi?id=35063 191957 28 beidson 2010-02-19 10:11:00 -0800 Ahh - I thought you were implying *behavorial* regression, not a *crashing* regression. Big difference ;) 46891 2010-01-18 23:29:14 -0800 2010-01-25 22:42:10 -0800 work in progress wip_1.txt text/plain 26188 fishd SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViQ29yZS9DaGFuZ2VM b2cJKHJldmlzaW9uIDUzNDU1KQorKysgV2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkK QEAgLTEsMyArMSw1OSBAQAorMjAxMC0wMS0xOCAgRGFyaW4gRmlzaGVyICA8ZGFyaW5AY2hyb21p dW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IE9PUFMhICBUSElTIElTIEEgV09SSyBJTiBQUk9HUkVTUy4KKworICAgICAgICBwb3BzdGF0ZSBl dmVudCBpcyBvbmx5IGZpcmVkIHdoZW4gbmF2aWdhdGluZyBiYWNrIHRvIGEgbGl2ZSBkb2N1bWVu dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzMyMjQK KworICAgICAgICBSZXBsYWNlIEhpc3RvcnlJdGVtJ3MgRG9jdW1lbnQgcG9pbnRlciB3aXRoIGEg RG9jdW1lbnRTZXF1ZW5jZU51bWJlci4KKyAgICAgICAgRHVyaW5nIHNlc3Npb24gaGlzdG9yeSB0 cmF2ZXJzYWwsIGlmIHRoZSBjdXJyZW50IEhpc3RvcnlJdGVtIGFuZCB0aGUKKyAgICAgICAgdGFy Z2V0IEhpc3RvcnlJdGVtIGhhdmUgdGhlIHNhbWUgRG9jdW1lbnRTZXF1ZW5jZU51bWJlciwgdGhl biBpdCBtZWFucworICAgICAgICB0aGF0IHRoZSBjdXJyZW50IERvY3VtZW50IHNob3VsZCByZW1h aW4uCisKKyAgICAgICAgTk9URTogVG8gc3VwcG9ydCBDaHJvbWl1bSdzIHNlcmlhbGl6YXRpb24g b2YgSGlzdG9yeUl0ZW1zLCBJIG5lZWQgdG8KKyAgICAgICAgZ2VuZXJhdGUgRG9jdW1lbnRTZXF1 ZW5jZU51bWJlcnMgdGhhdCBhcmUgdW5pcXVlIGFjcm9zcyBhcHBsaWNhdGlvbgorICAgICAgICBs YXVuY2hlcy4gIEZvciB0aGlzIHJlYXNvbiwgaW5pdGlhbGl6YXRpb24gaGFwcGVucyB1c2luZyB0 aW1lIG9mIGRheS4KKworICAgICAgICBJIGFkZGVkIGEgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3Bh dGNoRGlkTmF2aWdhdGVXaXRoaW5QYWdlIG5vdGlmaWNhdGlvbi4KKyAgICAgICAgSXQgaXMgaW1w b3J0YW50IHRoYXQgdGhpcyBydW5zIGJlZm9yZSB0aGUgcG9wc3RhdGUgb3IgaGFzaGNoYW5nZSBl dmVudHMKKyAgICAgICAgYXJlIGRlbGl2ZXJlZCB0byB0aGUgcGFnZS4gIFRoaXMgYWxsb3dzIENo cm9taXVtIHRvIHVwZGF0ZSBzb21lIHN0YXRlCisgICAgICAgIHRoYXQgd291bGQgYmUgdmlzaWJs ZSB0byBzY3JpcHQgaW4gdGhvc2UgZXZlbnQgaGFuZGxlcnMuCisKKyAgICAgICAgKiBkb20vRG9j dW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6OmRldGFjaCk6CisgICAgICAg ICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogaGlzdG9yeS9CYWNrRm9yd2FyZExpc3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6QmFja0ZvcndhcmRMaXN0OjpwdXNoU3RhdGVJdGVtKToKKyAg ICAgICAgKiBoaXN0b3J5L0JhY2tGb3J3YXJkTGlzdENocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkJhY2tGb3J3YXJkTGlzdDo6YWRkSXRlbSk6CisgICAgICAgIChXZWJDb3JlOjpCYWNr Rm9yd2FyZExpc3Q6OnB1c2hTdGF0ZUl0ZW0pOgorICAgICAgICAqIGhpc3RvcnkvSGlzdG9yeUl0 ZW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Z2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVy KToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbSk6CisgICAgICAg IChXZWJDb3JlOjpIaXN0b3J5SXRlbTo6fkhpc3RvcnlJdGVtKToKKyAgICAgICAgKFdlYkNvcmU6 Okhpc3RvcnlJdGVtOjpzZXRTdGF0ZU9iamVjdCk6CisgICAgICAgICogaGlzdG9yeS9IaXN0b3J5 SXRlbS5oOgorICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUl0ZW06OnNldERvY3VtZW50U2VxdWVu Y2VOdW1iZXIpOgorICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUl0ZW06OmRvY3VtZW50U2VxdWVu Y2VOdW1iZXIpOgorICAgICAgICAqIGxvYWRlci9FbXB0eUNsaWVudHMuaDoKKyAgICAgICAgKFdl YkNvcmU6OkVtcHR5RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkTmF2aWdhdGVXaXRoaW5Q YWdlKToKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXI6OnJlY2VpdmVkRmlyc3REYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OkZy YW1lTG9hZGVyOjpsb2FkSW5TYW1lRG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVM b2FkZXI6Om5hdmlnYXRlV2l0aGluRG9jdW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVM b2FkZXI6OmxvYWRJdGVtKToKKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaDoK KyAgICAgICAgKiBsb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SGlzdG9yeUNvbnRyb2xsZXI6OnVwZGF0ZUJhY2tGb3J3YXJkTGlzdEZvckZyYWdtZW50U2Ny b2xsKToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjpwdXNoU3RhdGUpOgor ICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUNvbnRyb2xsZXI6OnJlcGxhY2VTdGF0ZSk6CisgICAg ICAgICogcGFnZS9IaXN0b3J5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okhpc3Rvcnk6OnN0YXRl T2JqZWN0QWRkZWQpOgorICAgICAgICAqIHBhZ2UvUGFnZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpQYWdlOjpnb1RvSXRlbSk6CisKIDIwMTAtMDEtMTggIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVu QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBPbGl2ZXIgSHVudC4KSW5kZXg6IFdl YkNvcmUvZG9tL0RvY3VtZW50LmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcAkocmV2aXNpb24gNTMzODgpCisrKyBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTE1MzQsMTIgKzE1MzQsNiBAQCB2b2lkIERvY3VtZW50OjpkZXRhY2go KQogICAgIGlmIChyZW5kZXIpCiAgICAgICAgIHJlbmRlci0+ZGVzdHJveSgpOwogICAgIAotICAg IEhhc2hTZXQ8UmVmUHRyPEhpc3RvcnlJdGVtPiA+IGFzc29jaWF0ZWRIaXN0b3J5SXRlbXM7Ci0g ICAgYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5zd2FwKG1fYXNzb2NpYXRlZEhpc3RvcnlJdGVtcyk7 Ci0gICAgSGFzaFNldDxSZWZQdHI8SGlzdG9yeUl0ZW0+ID46Oml0ZXJhdG9yIGVuZCA9IGFzc29j aWF0ZWRIaXN0b3J5SXRlbXMuZW5kKCk7Ci0gICAgZm9yIChIYXNoU2V0PFJlZlB0cjxIaXN0b3J5 SXRlbT4gPjo6aXRlcmF0b3IgaSA9IGFzc29jaWF0ZWRIaXN0b3J5SXRlbXMuYmVnaW4oKTsgaSAh PSBlbmQ7ICsraSkKLSAgICAgICAgKCppKS0+ZG9jdW1lbnREZXRhY2hlZCh0aGlzKTsKLSAgICAK ICAgICAvLyBUaGlzIGlzIHJlcXVpcmVkLCBhcyBvdXIgRnJhbWUgbWlnaHQgZGVsZXRlIGl0c2Vs ZiBhcyBzb29uIGFzIGl0IGRldGFjaGVzCiAgICAgLy8gdXMuIEhvd2V2ZXIsIHRoaXMgdmlvbGF0 ZXMgTm9kZTo6ZGV0YWNoKCkgc3ltYW50aWNzLCBhcyBpdCdzIG5ldmVyCiAgICAgLy8gcG9zc2li bGUgdG8gcmUtYXR0YWNoLiBFdmVudHVhbGx5IERvY3VtZW50OjpkZXRhY2goKSBzaG91bGQgYmUg cmVuYW1lZCwKQEAgLTQ0MzIsMTggKzQ0MjYsNiBAQCB2b2lkIERvY3VtZW50OjpzdGF0ZVBvcHBl ZChTZXJpYWxpemVkU2NyCiAgICAgICAgIG1fcGVuZGluZ1N0YXRlT2JqZWN0ID0gc3RhdGVPYmpl Y3Q7CiB9CiAKLXZvaWQgRG9jdW1lbnQ6OnJlZ2lzdGVySGlzdG9yeUl0ZW0oSGlzdG9yeUl0ZW0q IGl0ZW0pCi17Ci0gICAgQVNTRVJUKCFtX2Fzc29jaWF0ZWRIaXN0b3J5SXRlbXMuY29udGFpbnMo aXRlbSkpOwotICAgIG1fYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5hZGQoaXRlbSk7Ci19Ci0KLXZv aWQgRG9jdW1lbnQ6OnVucmVnaXN0ZXJIaXN0b3J5SXRlbShIaXN0b3J5SXRlbSogaXRlbSkKLXsK LSAgICBBU1NFUlQobV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLmNvbnRhaW5zKGl0ZW0pIHx8IG1f YXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5pc0VtcHR5KCkpOwotICAgIG1fYXNzb2NpYXRlZEhpc3Rv cnlJdGVtcy5yZW1vdmUoaXRlbSk7Ci19Ci0KIHZvaWQgRG9jdW1lbnQ6OnVwZGF0ZVNhbmRib3hG bGFncygpCiB7CiAgICAgaWYgKG1fZnJhbWUgJiYgc2VjdXJpdHlPcmlnaW4oKSkKSW5kZXg6IFdl YkNvcmUvZG9tL0RvY3VtZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJDb3JlL2RvbS9Eb2N1bWVu dC5oCShyZXZpc2lvbiA1MzM4OCkKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJKHdvcmtpbmcg Y29weSkKQEAgLTkxNCw4ICs5MTQsNiBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHVwZGF0ZVVSTEZv clB1c2hPclJlcGxhY2VTdGF0ZShjb25zdCBLVVJMJik7CiAgICAgdm9pZCBzdGF0ZVBvcHBlZChT ZXJpYWxpemVkU2NyaXB0VmFsdWUqKTsKLSAgICB2b2lkIHJlZ2lzdGVySGlzdG9yeUl0ZW0oSGlz dG9yeUl0ZW0qIGl0ZW0pOwotICAgIHZvaWQgdW5yZWdpc3Rlckhpc3RvcnlJdGVtKEhpc3RvcnlJ dGVtKiBpdGVtKTsKIAogICAgIHZvaWQgdXBkYXRlU2FuZGJveEZsYWdzKCk7IC8vIFNldCBzYW5k Ym94IGZsYWdzIGFzIGRldGVybWluZWQgYnkgdGhlIGZyYW1lLgogCkluZGV4OiBXZWJDb3JlL2hp c3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvaGlzdG9y eS9CYWNrRm9yd2FyZExpc3QuY3BwCShyZXZpc2lvbiA1MzM4OCkKKysrIFdlYkNvcmUvaGlzdG9y eS9CYWNrRm9yd2FyZExpc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMzksMjAgKzIzOSwxNSBA QCBIaXN0b3J5SXRlbVZlY3RvciYgQmFja0ZvcndhcmRMaXN0OjplbnRyCiB2b2lkIEJhY2tGb3J3 YXJkTGlzdDo6cHVzaFN0YXRlSXRlbShQYXNzUmVmUHRyPEhpc3RvcnlJdGVtPiBuZXdJdGVtKQog ewogICAgIEFTU0VSVChuZXdJdGVtKTsKLSAgICBBU1NFUlQobmV3SXRlbS0+ZG9jdW1lbnQoKSk7 CiAgICAgQVNTRVJUKG5ld0l0ZW0tPnN0YXRlT2JqZWN0KCkpOwogICAgIAogICAgIFJlZlB0cjxI aXN0b3J5SXRlbT4gY3VycmVudCA9IGN1cnJlbnRJdGVtKCk7CiAgICAgQVNTRVJUKGN1cnJlbnQp OwogCi0gICAgRG9jdW1lbnQqIG5ld0l0ZW1Eb2N1bWVudCA9IG5ld0l0ZW0tPmRvY3VtZW50KCk7 Ci0KICAgICBhZGRJdGVtKG5ld0l0ZW0pOwogICAgIAotICAgIGlmICghY3VycmVudC0+ZG9jdW1l bnQoKSkgewotICAgICAgICBjdXJyZW50LT5zZXREb2N1bWVudChuZXdJdGVtRG9jdW1lbnQpOwor ICAgIGlmICghY3VycmVudC0+c3RhdGVPYmplY3QoKSkKICAgICAgICAgY3VycmVudC0+c2V0U3Rh dGVPYmplY3QoU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoKSk7Ci0gICAgfQogfQogCiB2 b2lkIEJhY2tGb3J3YXJkTGlzdDo6Y2xvc2UoKQpJbmRleDogV2ViQ29yZS9oaXN0b3J5L0JhY2tG b3J3YXJkTGlzdENocm9taXVtLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvaGlzdG9yeS9C YWNrRm9yd2FyZExpc3RDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUzMzg4KQorKysgV2ViQ29yZS9o aXN0b3J5L0JhY2tGb3J3YXJkTGlzdENocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTAs MTMgKzUwLDEzIEBAIEJhY2tGb3J3YXJkTGlzdDo6fkJhY2tGb3J3YXJkTGlzdCgpCiAgICAgQVNT RVJUKG1fY2xvc2VkKTsKIH0KIAotdm9pZCBCYWNrRm9yd2FyZExpc3Q6OmFkZEl0ZW0oUGFzc1Jl ZlB0cjxIaXN0b3J5SXRlbT4gcHJwSXRlbSkKK3ZvaWQgQmFja0ZvcndhcmRMaXN0OjphZGRJdGVt KFBhc3NSZWZQdHI8SGlzdG9yeUl0ZW0+IG5ld0l0ZW0pCiB7Ci0gICAgQVNTRVJUKHBycEl0ZW0p OworICAgIEFTU0VSVChuZXdJdGVtKTsKICAgICBpZiAobV9jYXBhY2l0eSA9PSAwIHx8ICFtX2Vu YWJsZWQpCiAgICAgICAgIHJldHVybjsKICAKLSAgICBtX2NsaWVudC0+YWRkSXRlbShwcnBJdGVt KTsKKyAgICBtX2NsaWVudC0+YWRkSXRlbShuZXdJdGVtKTsKIH0KIAogdm9pZCBCYWNrRm9yd2Fy ZExpc3Q6OmdvVG9JdGVtKEhpc3RvcnlJdGVtKiBpdGVtKQpAQCAtMTIzLDcgKzEyMywxMiBAQCBI aXN0b3J5SXRlbSogQmFja0ZvcndhcmRMaXN0OjppdGVtQXRJbmRlCiAKIHZvaWQgQmFja0Zvcndh cmRMaXN0OjpwdXNoU3RhdGVJdGVtKFBhc3NSZWZQdHI8SGlzdG9yeUl0ZW0+IG5ld0l0ZW0pCiB7 Ci0gIC8vIEZJWE1FOiBOZWVkIHRvIGltcGxlbWVudCBzdGF0ZSBzdXBwb3J0IGZvciBjaHJvbWl1 bS4KKyAgICBSZWZQdHI8SGlzdG9yeUl0ZW0+IGN1cnJlbnQgPSBtX2NsaWVudC0+Y3VycmVudEl0 ZW0oKTsKKworICAgIGFkZEl0ZW0obmV3SXRlbSk7CisKKyAgICBpZiAoIWN1cnJlbnQtPnN0YXRl T2JqZWN0KCkpCisgICAgICAgIGN1cnJlbnQtPnNldFN0YXRlT2JqZWN0KFNlcmlhbGl6ZWRTY3Jp cHRWYWx1ZTo6Y3JlYXRlKCkpOwogfQogCiBIaXN0b3J5SXRlbVZlY3RvciYgQmFja0ZvcndhcmRM aXN0OjplbnRyaWVzKCkKSW5kZXg6IFdlYkNvcmUvaGlzdG9yeS9IaXN0b3J5SXRlbS5jcHANCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBXZWJDb3JlL2hpc3RvcnkvSGlzdG9yeUl0ZW0uY3BwCShyZXZpc2lvbiA1 MzM4OCkKKysrIFdlYkNvcmUvaGlzdG9yeS9IaXN0b3J5SXRlbS5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTMzLDkgKzMzLDE4IEBACiAjaW5jbHVkZSAiUGFnZUNhY2hlLmgiCiAjaW5jbHVkZSAiUmVz b3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDx3dGYvQ3VycmVu dFRpbWUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitzdGF0aWMgbG9uZyBsb25nIGdlbmVy YXRlRG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpCit7CisgICAgLy8gSW5pdGlhbGl6ZSB0byB0aGUg Y3VycmVudCB0aW1lIHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9vZCBvZiBnZW5lcmF0aW5nCisgICAg Ly8gaWRlbnRpZmllcnMgdGhhdCBvdmVybGFwIHdpdGggdGhvc2UgZnJvbSBwYXN0L2Z1dHVyZSBi cm93c2VyIHNlc3Npb25zLgorICAgIHN0YXRpYyBsb25nIGxvbmcgbmV4dCA9IHN0YXRpY19jYXN0 PGxvbmcgbG9uZz4oY3VycmVudFRpbWUoKSAqIDEwMDAwMDAuMCk7CisgICAgcmV0dXJuICsrbmV4 dDsKK30KKwogc3RhdGljIHZvaWQgZGVmYXVsdE5vdGlmeUhpc3RvcnlJdGVtQ2hhbmdlZChIaXN0 b3J5SXRlbSopCiB7CiB9CkBAIC00OCw3ICs1Nyw3IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRl bSgpCiAgICAgLCBtX2xhc3RWaXNpdFdhc0ZhaWx1cmUoZmFsc2UpCiAgICAgLCBtX2lzVGFyZ2V0 SXRlbShmYWxzZSkKICAgICAsIG1fdmlzaXRDb3VudCgwKQotICAgICwgbV9kb2N1bWVudCgwKQor ICAgICwgbV9kb2N1bWVudFNlcXVlbmNlTnVtYmVyKGdlbmVyYXRlRG9jdW1lbnRTZXF1ZW5jZU51 bWJlcigpKQogewogfQogCkBAIC02MSw3ICs3MCw3IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRl bShjb25zdCBTdHJpbmcmIHUKICAgICAsIG1fbGFzdFZpc2l0V2FzRmFpbHVyZShmYWxzZSkKICAg ICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAgICwgbV92aXNpdENvdW50KDApCi0gICAgLCBt X2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1 bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7ICAgIAogICAgIGljb25EYXRhYmFzZSgpLT5yZXRhaW5J Y29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiB9CkBAIC03Niw3ICs4NSw3IEBAIEhpc3RvcnlJ dGVtOjpIaXN0b3J5SXRlbShjb25zdCBTdHJpbmcmIHUKICAgICAsIG1fbGFzdFZpc2l0V2FzRmFp bHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAgICwgbV92aXNpdENv dW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1i ZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7CiAgICAgaWNvbkRhdGFiYXNl KCktPnJldGFpbkljb25Gb3JQYWdlVVJMKG1fdXJsU3RyaW5nKTsKIH0KQEAgLTkyLDcgKzEwMSw3 IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBLVVJMJiB1cmwKICAgICAsIG1fbGFz dFZpc2l0V2FzRmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAg ICwgbV92aXNpdENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50 U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7ICAgIAog ICAgIGljb25EYXRhYmFzZSgpLT5yZXRhaW5JY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiB9 CkBAIC0xMDAsNyArMTA5LDYgQEAgSGlzdG9yeUl0ZW06Okhpc3RvcnlJdGVtKGNvbnN0IEtVUkwm IHVybAogSGlzdG9yeUl0ZW06On5IaXN0b3J5SXRlbSgpCiB7CiAgICAgQVNTRVJUKCFtX2NhY2hl ZFBhZ2UpOwotICAgIEFTU0VSVCghbV9kb2N1bWVudCk7CiAgICAgaWNvbkRhdGFiYXNlKCktPnJl bGVhc2VJY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiAjaWYgUExBVEZPUk0oQU5EUk9JRCkK ICAgICBpZiAobV9icmlkZ2UpCkBAIC0xMjUsNyArMTMzLDcgQEAgaW5saW5lIEhpc3RvcnlJdGVt OjpIaXN0b3J5SXRlbShjb25zdCBIaQogICAgICwgbV92aXNpdENvdW50KGl0ZW0ubV92aXNpdENv dW50KQogICAgICwgbV9kYWlseVZpc2l0Q291bnRzKGl0ZW0ubV9kYWlseVZpc2l0Q291bnRzKQog ICAgICwgbV93ZWVrbHlWaXNpdENvdW50cyhpdGVtLm1fd2Vla2x5VmlzaXRDb3VudHMpCi0gICAg LCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVE b2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiAgICAgLCBtX2Zvcm1Db250ZW50VHlwZShpdGVtLm1f Zm9ybUNvbnRlbnRUeXBlKQogewogICAgIGlmIChpdGVtLm1fZm9ybURhdGEpCkBAIC0zOTcsMjkg KzQwNSw5IEBAIHZvaWQgSGlzdG9yeUl0ZW06OnNldElzVGFyZ2V0SXRlbShib29sIGYKIAogdm9p ZCBIaXN0b3J5SXRlbTo6c2V0U3RhdGVPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0 VmFsdWU+IG9iamVjdCkKIHsKLSAgICBBU1NFUlQobV9kb2N1bWVudCk7CiAgICAgbV9zdGF0ZU9i amVjdCA9IG9iamVjdDsKIH0KIAotdm9pZCBIaXN0b3J5SXRlbTo6c2V0RG9jdW1lbnQoRG9jdW1l bnQqIGRvY3VtZW50KQotewotICAgIGlmIChtX2RvY3VtZW50ID09IGRvY3VtZW50KQotICAgICAg ICByZXR1cm47Ci0gICAgCi0gICAgaWYgKG1fZG9jdW1lbnQpCi0gICAgICAgIG1fZG9jdW1lbnQt PnVucmVnaXN0ZXJIaXN0b3J5SXRlbSh0aGlzKTsKLSAgICBpZiAoZG9jdW1lbnQpCi0gICAgICAg IGRvY3VtZW50LT5yZWdpc3Rlckhpc3RvcnlJdGVtKHRoaXMpOwotICAgICAgICAKLSAgICBtX2Rv Y3VtZW50ID0gZG9jdW1lbnQ7Ci19Ci0KLXZvaWQgSGlzdG9yeUl0ZW06OmRvY3VtZW50RGV0YWNo ZWQoRG9jdW1lbnQqIGRvY3VtZW50KQotewotICAgIEFTU0VSVF9VTlVTRUQoZG9jdW1lbnQsIG1f ZG9jdW1lbnQgPT0gZG9jdW1lbnQpOwotICAgIG1fZG9jdW1lbnQgPSAwOwotfQotCiB2b2lkIEhp c3RvcnlJdGVtOjphZGRDaGlsZEl0ZW0oUGFzc1JlZlB0cjxIaXN0b3J5SXRlbT4gY2hpbGQpCiB7 CiAgICAgQVNTRVJUKCFjaGlsZEl0ZW1XaXRoVGFyZ2V0KGNoaWxkLT50YXJnZXQoKSkpOwpJbmRl eDogV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJDb3Jl L2hpc3RvcnkvSGlzdG9yeUl0ZW0uaAkocmV2aXNpb24gNTMzODgpCisrKyBXZWJDb3JlL2hpc3Rv cnkvSGlzdG9yeUl0ZW0uaAkod29ya2luZyBjb3B5KQpAQCAtMTM1LDkgKzEzNSw5IEBAIHB1Ymxp YzogCiAgICAgCiAgICAgdm9pZCBzZXRTdGF0ZU9iamVjdChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRT Y3JpcHRWYWx1ZT4gb2JqZWN0KTsKICAgICBTZXJpYWxpemVkU2NyaXB0VmFsdWUqIHN0YXRlT2Jq ZWN0KCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZU9iamVjdC5nZXQoKTsgfQotICAgIHZvaWQgc2V0 RG9jdW1lbnQoRG9jdW1lbnQqIGRvY3VtZW50KTsKLSAgICBEb2N1bWVudCogZG9jdW1lbnQoKSBj b25zdCB7IHJldHVybiBtX2RvY3VtZW50OyB9Ci0gICAgdm9pZCBkb2N1bWVudERldGFjaGVkKERv Y3VtZW50Kik7CisKKyAgICB2b2lkIHNldERvY3VtZW50U2VxdWVuY2VOdW1iZXIobG9uZyBsb25n IG51bWJlcikgeyBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIgPSBudW1iZXI7IH0KKyAgICBsb25n IGxvbmcgZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpIGNvbnN0IHsgcmV0dXJuIG1fZG9jdW1lbnRT ZXF1ZW5jZU51bWJlcjsgfQogICAgIAogICAgIHZvaWQgc2V0Rm9ybUluZm9Gcm9tUmVxdWVzdChj b25zdCBSZXNvdXJjZVJlcXVlc3QmKTsKICAgICB2b2lkIHNldEZvcm1EYXRhKFBhc3NSZWZQdHI8 Rm9ybURhdGE+KTsKQEAgLTI0NCw3ICsyNDQsNyBAQCBwcml2YXRlOgogCiAgICAgLy8gU3VwcG9y dCBmb3IgSFRNTDUgSGlzdG9yeQogICAgIFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1f c3RhdGVPYmplY3Q7Ci0gICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CisgICAgbG9uZyBsb25nIG1f ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcjsKICAgICAKICAgICAvLyBpbmZvIHVzZWQgdG8gcmVwb3N0 IGZvcm0gZGF0YQogICAgIFJlZlB0cjxGb3JtRGF0YT4gbV9mb3JtRGF0YTsKSW5kZXg6IFdlYkNv cmUvbG9hZGVyL0VtcHR5Q2xpZW50cy5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViQ29yZS9sb2FkZXIv RW1wdHlDbGllbnRzLmgJKHJldmlzaW9uIDUzMzg4KQorKysgV2ViQ29yZS9sb2FkZXIvRW1wdHlD bGllbnRzLmgJKHdvcmtpbmcgY29weSkKQEAgLTIwMSw2ICsyMDEsNyBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkUmVjZWl2ZVNlcnZlclJlZGlyZWN0Rm9yUHJvdmlzaW9u YWxMb2FkKCkgeyB9CiAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkQ2FuY2VsQ2xpZW50UmVk aXJlY3QoKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hXaWxsUGVyZm9ybUNsaWVudFJl ZGlyZWN0KGNvbnN0IEtVUkwmLCBkb3VibGUsIGRvdWJsZSkgeyB9CisgICAgdmlydHVhbCB2b2lk IGRpc3BhdGNoRGlkTmF2aWdhdGVXaXRoaW5QYWdlKGJvb2wgaXNIYXNoQ2hhbmdlKSB7IH0KICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UoKSB7IH0K ICAgICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRQdXNoU3RhdGVXaXRoaW5QYWdlKCkgeyB9CiAg ICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkUmVwbGFjZVN0YXRlV2l0aGluUGFnZSgpIHsgfQpJ bmRleDogV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwDQo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2Vi Q29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCShyZXZpc2lvbiA1MzM4OCkKKysrIFdlYkNvcmUv bG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNzU4LDcgKzc1OCw3IEBA IHZvaWQgRnJhbWVMb2FkZXI6OnJlY2VpdmVkRmlyc3REYXRhKCkKIAogICAgIGRpc3BhdGNoRGlk Q29tbWl0TG9hZCgpOwogICAgIGRpc3BhdGNoRGlkQ2xlYXJXaW5kb3dPYmplY3RzSW5BbGxXb3Js ZHMoKTsKLSAgICAKKwogICAgIGlmIChtX2RvY3VtZW50TG9hZGVyKSB7CiAgICAgICAgIFN0cmlu ZyBwdGl0bGUgPSBtX2RvY3VtZW50TG9hZGVyLT50aXRsZSgpOwogICAgICAgICAvLyBJZiB3ZSBo YXZlIGEgdGl0bGUgbGV0IHRoZSBXZWJWaWV3IGtub3cgYWJvdXQgaXQuCkBAIC0xNzcwLDYgKzE3 NzAsOCBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkSW5TYW1lRG9jdW1lbnQoY29uCiAgICAgICAg IGNoZWNrTG9hZENvbXBsZXRlKCk7CiAgICAgfQogCisgICAgbV9jbGllbnQtPmRpc3BhdGNoRGlk TmF2aWdhdGVXaXRoaW5QYWdlKGhhc2hDaGFuZ2UpOworCiAgICAgaWYgKHN0YXRlT2JqZWN0KSB7 CiAgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50KCktPnN0YXRlUG9wcGVkKHN0YXRlT2JqZWN0KTsK ICAgICAgICAgbV9jbGllbnQtPmRpc3BhdGNoRGlkUG9wU3RhdGVXaXRoaW5QYWdlKCk7CkBAIC0z Njg2LDcgKzM2ODgsNyBAQCBGcmFtZSogRnJhbWVMb2FkZXI6OmZpbmRGcmFtZUZvck5hdmlnYXRp CiAKIHZvaWQgRnJhbWVMb2FkZXI6Om5hdmlnYXRlV2l0aGluRG9jdW1lbnQoSGlzdG9yeUl0ZW0q IGl0ZW0pCiB7Ci0gICAgQVNTRVJUKCFpdGVtLT5kb2N1bWVudCgpIHx8IGl0ZW0tPmRvY3VtZW50 KCkgPT0gbV9mcmFtZS0+ZG9jdW1lbnQoKSk7CisgICAgQVNTRVJUKGl0ZW0tPmRvY3VtZW50U2Vx dWVuY2VOdW1iZXIoKSA9PSBoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCktPmRvY3VtZW50U2VxdWVu Y2VOdW1iZXIoKSk7CiAKICAgICAvLyBTYXZlIHVzZXIgdmlldyBzdGF0ZSB0byB0aGUgY3VycmVu dCBoaXN0b3J5IGl0ZW0gaGVyZSBzaW5jZSB3ZSBkb24ndCBkbyBhIG5vcm1hbCBsb2FkLgogICAg IC8vIEZJWE1FOiBEb2VzIGZvcm0gc3RhdGUgbmVlZCB0byBiZSBzYXZlZCBoZXJlIHRvbz8KQEAg LTM4MTAsNyArMzgxMiw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OmxvYWRJdGVtKEhpc3RvcnlJdGVt KiAKICAgICAvLyAtIFRoZSBIaXN0b3J5SXRlbSBoYXMgYSBoaXN0b3J5IHN0YXRlIG9iamVjdAog ICAgIC8vIC0gTmF2aWdhdGluZyB0byBhbiBhbmNob3Igd2l0aGluIHRoZSBwYWdlLCB3aXRoIG5v IGZvcm0gZGF0YSBzdG9yZWQgb24gdGhlIHRhcmdldCBpdGVtIG9yIHRoZSBjdXJyZW50IGhpc3Rv cnkgZW50cnksCiAgICAgLy8gICBhbmQgdGhlIFVSTHMgaW4gdGhlIGZyYW1lIHRyZWUgbWF0Y2gg dGhlIGhpc3RvcnkgaXRlbSBmb3IgZnJhZ21lbnQgc2Nyb2xsaW5nLgotICAgIGJvb2wgc2FtZURv Y3VtZW50TmF2aWdhdGlvbiA9ICghaXRlbS0+Zm9ybURhdGEoKSAmJiAhKGhpc3RvcnkoKS0+Y3Vy cmVudEl0ZW0oKSAmJiBoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCktPmZvcm1EYXRhKCkpICYmIGhp c3RvcnkoKS0+dXJsc01hdGNoSXRlbShpdGVtKSkgfHwgaXRlbS0+ZG9jdW1lbnQoKSA9PSBtX2Zy YW1lLT5kb2N1bWVudCgpOworICAgIGJvb2wgc2FtZURvY3VtZW50TmF2aWdhdGlvbiA9ICghaXRl bS0+Zm9ybURhdGEoKSAmJiAhKGhpc3RvcnkoKS0+Y3VycmVudEl0ZW0oKSAmJiBoaXN0b3J5KCkt PmN1cnJlbnRJdGVtKCktPmZvcm1EYXRhKCkpICYmIGhpc3RvcnkoKS0+dXJsc01hdGNoSXRlbShp dGVtKSkgfHwgaXRlbS0+ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpID09IGhpc3RvcnkoKS0+Y3Vy cmVudEl0ZW0oKS0+ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpOwogCiAjaWYgRU5BQkxFKFdNTCkK ICAgICAvLyBBbGwgV01MIGRlY2tzIHNob3VsZCBnbyB0aHJvdWdoIHRoZSByZWFsIGxvYWQgbWVj aGFuaXNtLCBub3QgdGhlIHNjcm9sbC10by1hbmNob3IgY29kZQpJbmRleDogV2ViQ29yZS9sb2Fk ZXIvRnJhbWVMb2FkZXJDbGllbnQuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvbG9hZGVyL0Zy YW1lTG9hZGVyQ2xpZW50LmgJKHJldmlzaW9uIDUzMzg4KQorKysgV2ViQ29yZS9sb2FkZXIvRnJh bWVMb2FkZXJDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDYgKzExNiw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkUmVjZWl2ZVNl cnZlclJlZGlyZWN0Rm9yUHJvdmlzaW9uYWxMb2FkKCkgPSAwOwogICAgICAgICB2aXJ0dWFsIHZv aWQgZGlzcGF0Y2hEaWRDYW5jZWxDbGllbnRSZWRpcmVjdCgpID0gMDsKICAgICAgICAgdmlydHVh bCB2b2lkIGRpc3BhdGNoV2lsbFBlcmZvcm1DbGllbnRSZWRpcmVjdChjb25zdCBLVVJMJiwgZG91 YmxlIGludGVydmFsLCBkb3VibGUgZmlyZURhdGUpID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lk IGRpc3BhdGNoRGlkTmF2aWdhdGVXaXRoaW5QYWdlKGJvb2wgaXNIYXNoQ2hhbmdlKSA9IDA7CiAg ICAgICAgIHZpcnR1YWwgdm9pZCBkaXNwYXRjaERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZSgp ID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkUHVzaFN0YXRlV2l0aGluUGFn ZSgpID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkUmVwbGFjZVN0YXRlV2l0 aGluUGFnZSgpID0gMDsKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNw cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcAko cmV2aXNpb24gNTMzODgpCisrKyBXZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTEwNiw2ICsxMDYsMTAgQEAgdm9pZCBIaXN0b3J5Q29udHJvbGxl cjo6cmVzdG9yZVNjcm9sbFBvcwogdm9pZCBIaXN0b3J5Q29udHJvbGxlcjo6dXBkYXRlQmFja0Zv cndhcmRMaXN0Rm9yRnJhZ21lbnRTY3JvbGwoKQogewogICAgIHVwZGF0ZUJhY2tGb3J3YXJkTGlz dENsaXBwZWRBdFRhcmdldChmYWxzZSk7CisgICAgCisgICAgLy8gU2luY2UgdGhlIGRvY3VtZW50 IGlzbid0IGNoYW5nZWQgYXMgYSByZXN1bHQgb2YgYSBmcmFnbWVudCBzY3JvbGwsIHdlIHNob3Vs ZAorICAgIC8vIHByZXNlcnZlIHRoZSBEb2N1bWVudFNlcXVlbmNlTnVtYmVyIG9mIHRoZSBwcmV2 aW91cyBpdGVtLgorICAgIG1fY3VycmVudEl0ZW0tPnNldERvY3VtZW50U2VxdWVuY2VOdW1iZXIo bV9wcmV2aW91c0l0ZW0tPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSk7CiB9CiAKIHZvaWQgSGlz dG9yeUNvbnRyb2xsZXI6OnNhdmVEb2N1bWVudFN0YXRlKCkKQEAgLTYyOSwxOCArNjMzLDIwIEBA IHZvaWQgSGlzdG9yeUNvbnRyb2xsZXI6OnB1c2hTdGF0ZShQYXNzUmUKIHsKICAgICBQYWdlKiBw YWdlID0gbV9mcmFtZS0+cGFnZSgpOwogICAgIEFTU0VSVChwYWdlKTsKLQorICAgIAogICAgIC8v IEdldCBhIEhpc3RvcnlJdGVtIHRyZWUgZm9yIHRoZSBjdXJyZW50IGZyYW1lIHRyZWUuCiAgICAg UmVmUHRyPEhpc3RvcnlJdGVtPiBpdGVtID0gY3JlYXRlSXRlbVRyZWUobV9mcmFtZSwgZmFsc2Up OworICAgIEFTU0VSVChpdGVtLT5pc1RhcmdldEl0ZW0oKSk7CiAgICAgCi0gICAgLy8gT3ZlcnJp ZGUgZGF0YSBpbiB0aGUgdGFyZ2V0IGl0ZW0gdG8gcmVmbGVjdCB0aGUgcHVzaFN0YXRlKCkgYXJn dW1lbnRzLgotICAgIEhpc3RvcnlJdGVtKiB0YXJnZXRJdGVtID0gaXRlbS0+dGFyZ2V0SXRlbSgp OwotICAgIEFTU0VSVCh0YXJnZXRJdGVtLT5pc1RhcmdldEl0ZW0oKSk7Ci0gICAgdGFyZ2V0SXRl bS0+c2V0RG9jdW1lbnQobV9mcmFtZS0+ZG9jdW1lbnQoKSk7Ci0gICAgdGFyZ2V0SXRlbS0+c2V0 VGl0bGUodGl0bGUpOwotICAgIHRhcmdldEl0ZW0tPnNldFN0YXRlT2JqZWN0KHN0YXRlT2JqZWN0 KTsKLSAgICB0YXJnZXRJdGVtLT5zZXRVUkxTdHJpbmcodXJsU3RyaW5nKTsKLSAgICAKKyAgICAv LyBPdmVycmlkZSBkYXRhIGluIHRoZSBuZXcgaXRlbSB0byByZWZsZWN0IHRoZSBwdXNoU3RhdGUo KSBhcmd1bWVudHMuCisgICAgaXRlbS0+c2V0VGl0bGUodGl0bGUpOworICAgIGl0ZW0tPnNldFN0 YXRlT2JqZWN0KHN0YXRlT2JqZWN0KTsKKyAgICBpdGVtLT5zZXRVUkxTdHJpbmcodXJsU3RyaW5n KTsKKyAgICAKKyAgICAvLyBTaW5jZSB0aGUgZG9jdW1lbnQgaXNuJ3QgY2hhbmdlZCBhcyBhIHJl c3VsdCBvZiBhIGZyYWdtZW50IHNjcm9sbCwgd2Ugc2hvdWxkCisgICAgLy8gcHJlc2VydmUgdGhl IERvY3VtZW50U2VxdWVuY2VOdW1iZXIgb2YgdGhlIHByZXZpb3VzIGl0ZW0uCisgICAgaXRlbS0+ c2V0RG9jdW1lbnRTZXF1ZW5jZU51bWJlcihtX3ByZXZpb3VzSXRlbS0+ZG9jdW1lbnRTZXF1ZW5j ZU51bWJlcigpKTsKKwogICAgIHBhZ2UtPmJhY2tGb3J3YXJkTGlzdCgpLT5wdXNoU3RhdGVJdGVt KGl0ZW0ucmVsZWFzZSgpKTsKIH0KIApAQCAtNjUwLDEwICs2NTYsNyBAQCB2b2lkIEhpc3RvcnlD b250cm9sbGVyOjpyZXBsYWNlU3RhdGUoUGFzCiAgICAgQVNTRVJUKHBhZ2UpOwogICAgIEhpc3Rv cnlJdGVtKiBjdXJyZW50ID0gcGFnZS0+YmFja0ZvcndhcmRMaXN0KCktPmN1cnJlbnRJdGVtKCk7 CiAgICAgQVNTRVJUKGN1cnJlbnQpOwotICAgIAotICAgIEFTU0VSVCghY3VycmVudC0+ZG9jdW1l bnQoKSB8fCBjdXJyZW50LT5kb2N1bWVudCgpID09IG1fZnJhbWUtPmRvY3VtZW50KCkpOwotICAg IGN1cnJlbnQtPnNldERvY3VtZW50KG1fZnJhbWUtPmRvY3VtZW50KCkpOwotICAgIAorCiAgICAg aWYgKCF1cmxTdHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBjdXJyZW50LT5zZXRVUkxTdHJpbmco dXJsU3RyaW5nKTsKICAgICBjdXJyZW50LT5zZXRUaXRsZSh0aXRsZSk7CkluZGV4OiBXZWJDb3Jl L3BhZ2UvSGlzdG9yeS5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJDb3JlL3BhZ2UvSGlzdG9yeS5j cHAJKHJldmlzaW9uIDUzMzg4KQorKysgV2ViQ29yZS9wYWdlL0hpc3RvcnkuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0xMTMsMTMgKzExMywxMyBAQCB2b2lkIEhpc3Rvcnk6OnN0YXRlT2JqZWN0QWRk ZWQoUGFzc1JlZlB0CiAgICAgZWxzZSBpZiAoc3RhdGVPYmplY3RUeXBlID09IFN0YXRlT2JqZWN0 UmVwbGFjZSkKICAgICAgICAgbV9mcmFtZS0+bG9hZGVyKCktPmhpc3RvcnkoKS0+cmVwbGFjZVN0 YXRlKGRhdGEsIHRpdGxlLCBmdWxsVVJMLnN0cmluZygpKTsKICAgICAgICAgICAgIAotICAgIGlm ICghdXJsU3RyaW5nLmlzRW1wdHkoKSkgeworICAgIGlmICghdXJsU3RyaW5nLmlzRW1wdHkoKSkK ICAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+dXBkYXRlVVJMRm9yUHVzaE9yUmVwbGFjZVN0 YXRlKGZ1bGxVUkwpOwotICAgICAgICBpZiAoc3RhdGVPYmplY3RUeXBlID09IFN0YXRlT2JqZWN0 UHVzaCkKLSAgICAgICAgICAgIG1fZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+ZGlzcGF0Y2hE aWRQdXNoU3RhdGVXaXRoaW5QYWdlKCk7Ci0gICAgICAgIGVsc2UgaWYgKHN0YXRlT2JqZWN0VHlw ZSA9PSBTdGF0ZU9iamVjdFJlcGxhY2UpCi0gICAgICAgICAgICBtX2ZyYW1lLT5sb2FkZXIoKS0+ Y2xpZW50KCktPmRpc3BhdGNoRGlkUmVwbGFjZVN0YXRlV2l0aGluUGFnZSgpOwotICAgIH0KKwor ICAgIGlmIChzdGF0ZU9iamVjdFR5cGUgPT0gU3RhdGVPYmplY3RQdXNoKQorICAgICAgICBtX2Zy YW1lLT5sb2FkZXIoKS0+Y2xpZW50KCktPmRpc3BhdGNoRGlkUHVzaFN0YXRlV2l0aGluUGFnZSgp OworICAgIGVsc2UgaWYgKHN0YXRlT2JqZWN0VHlwZSA9PSBTdGF0ZU9iamVjdFJlcGxhY2UpCisg ICAgICAgIG1fZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+ZGlzcGF0Y2hEaWRSZXBsYWNlU3Rh dGVXaXRoaW5QYWdlKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNv cmUvcGFnZS9QYWdlLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYkNvcmUvcGFnZS9QYWdlLmNwcAko cmV2aXNpb24gNTMzODgpCisrKyBXZWJDb3JlL3BhZ2UvUGFnZS5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTI5MCw3ICsyOTAsOCBAQCB2b2lkIFBhZ2U6OmdvQmFja09yRm9yd2FyZChpbnQgZGlzdGFu Y2UpCiB2b2lkIFBhZ2U6OmdvVG9JdGVtKEhpc3RvcnlJdGVtKiBpdGVtLCBGcmFtZUxvYWRUeXBl IHR5cGUpCiB7CiAgICAgLy8gQWJvcnQgYW55IGN1cnJlbnQgbG9hZCB1bmxlc3Mgd2UncmUgbmF2 aWdhdGluZyB0aGUgY3VycmVudCBkb2N1bWVudCB0byBhIG5ldyBzdGF0ZSBvYmplY3QKLSAgICBp ZiAoIWl0ZW0tPnN0YXRlT2JqZWN0KCkgfHwgaXRlbS0+ZG9jdW1lbnQoKSAhPSBtX21haW5GcmFt ZS0+ZG9jdW1lbnQoKSkgeworICAgIC8vIFhYWDogd2hhdCBpZiB0aGUgSGlzdG9yeUl0ZW0gc3Bl Y2lmaWVzIGEgc3ViZnJhbWUgbmF2aWdhdGlvbj8KKyAgICBpZiAoIWl0ZW0tPnN0YXRlT2JqZWN0 KCkgfHwgaXRlbS0+ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpICE9IG1fbWFpbkZyYW1lLT5sb2Fk ZXIoKS0+aGlzdG9yeSgpLT5jdXJyZW50SXRlbSgpLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkp IHsKICAgICAgICAgLy8gRGVmaW5lIHdoYXQgdG8gZG8gd2l0aCBhbnkgb3BlbiBkYXRhYmFzZSBj b25uZWN0aW9ucy4gQnkgZGVmYXVsdCB3ZSBzdG9wIHRoZW0gYW5kIHRlcm1pbmF0ZSB0aGUgZGF0 YWJhc2UgdGhyZWFkLgogICAgICAgICBEYXRhYmFzZVBvbGljeSBkYXRhYmFzZVBvbGljeSA9IERh dGFiYXNlUG9saWN5U3RvcDsKIApJbmRleDogV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZw0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cJKHJldmlzaW9uIDUzNDU1KQor KysgV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDM2 IEBACisyMDEwLTAxLTE4ICBEYXJpbiBGaXNoZXIgIDxkYXJpbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT09QUyEgIFRISVMg SVMgQSBXT1JLIElOIFBST0dSRVNTLgorCisgICAgICAgIHBvcHN0YXRlIGV2ZW50IGlzIG9ubHkg ZmlyZWQgd2hlbiBuYXZpZ2F0aW5nIGJhY2sgdG8gYSBsaXZlIGRvY3VtZW50CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMzIyNAorCisgICAgICAgIEhv b2sgdXAgZGlzcGF0Y2hEaWROYXZpZ2F0ZVdpdGhpblBhZ2Ugbm90aWZpY2F0aW9uLiAgUHJvdmlk ZSBhY2Nlc3NvcnMKKyAgICAgICAgdG8gdGhlIERvY3VtZW50U2VxdWVuY2VOdW1iZXIuCisKKyAg ICAgICAgTk9URTogSW4gYSBwcmV2aW91cyB2ZXJzaW9uLCBJIHVzZWQgdGhlIG5hbWUgRG9jdW1l bnRJRCBpbiBwbGFjZSBvZgorICAgICAgICBEb2N1bWVudFNlcXVlbmNlTnVtYmVyLCBidXQgRG9j dW1lbnRJRCBpcyBjb25mdXNpbmcgZ2l2ZW4gdGhhdCBhCisgICAgICAgIERvY3VtZW50IGhhcyBh IGRvY0lEIG1lbWJlci4gIEkgd2lsbCBjaGFuZ2UgV2ViSGlzdG9yeUl0ZW0gdG8gdXNlCisgICAg ICAgIERvY3VtZW50U2VxdWVuY2VOdW1iZXIgYmVmb3JlIGZpbmFsaXppbmcgdGhpcyBwYXRjaC4K KworICAgICAgICAqIHB1YmxpYy9XZWJGcmFtZUNsaWVudC5oOgorICAgICAgICAoV2ViS2l0OjpX ZWJGcmFtZUNsaWVudDo6ZGlkTmF2aWdhdGVXaXRoaW5QYWdlKToKKyAgICAgICAgKiBwdWJsaWMv V2ViSGlzdG9yeUl0ZW0uaDoKKyAgICAgICAgKiBzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNw cDoKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRJbXBsOjpkaXNwYXRjaERpZE5h dmlnYXRlV2l0aGluUGFnZSk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50SW1w bDo6ZGlzcGF0Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UpOgorICAgICAgICAoV2ViS2l0 OjpGcmFtZUxvYWRlckNsaWVudEltcGw6OmRpc3BhdGNoRGlkUHVzaFN0YXRlV2l0aGluUGFnZSk6 CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEaWRSZXBs YWNlU3RhdGVXaXRoaW5QYWdlKToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnRJ bXBsOjpkaXNwYXRjaERpZFBvcFN0YXRlV2l0aGluUGFnZSk6CisgICAgICAgICogc3JjL0ZyYW1l TG9hZGVyQ2xpZW50SW1wbC5oOgorICAgICAgICAqIHNyYy9XZWJIaXN0b3J5SXRlbS5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OldlYkhpc3RvcnlJdGVtOjpkb2N1bWVudElEKToKKyAgICAgICAgKFdl YktpdDo6V2ViSGlzdG9yeUl0ZW06OnNldERvY3VtZW50SUQpOgorICAgICAgICAoV2ViS2l0OjpX ZWJIaXN0b3J5SXRlbTo6c3RhdGVPYmplY3QpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaXN0b3J5 SXRlbTo6c2V0U3RhdGVPYmplY3QpOgorCiAyMDEwLTAxLTE4ICBKb25hdGhhbiBEaXhvbiAgPGpv dGhAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCkluZGV4 OiBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgNCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0t LSBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkZyYW1lQ2xpZW50LmgJKHJldmlzaW9uIDUzMzQw KQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJGcmFtZUNsaWVudC5oCSh3b3JraW5nIGNv cHkpCkBAIC0xODIsOSArMTgyLDkgQEAgcHVibGljOgogICAgIC8vIFRoZSBmcmFtZSdzIGRvY3Vt ZW50IGFuZCBhbGwgb2YgaXRzIHN1YnJlc291cmNlcyBzdWNjZWVkZWQgdG8gbG9hZC4KICAgICB2 aXJ0dWFsIHZvaWQgZGlkRmluaXNoTG9hZChXZWJGcmFtZSopIHsgfQogCi0gICAgLy8gVGhlIG5h dmlnYXRpb24gcmVzdWx0ZWQgaW4gc2Nyb2xsaW5nIHRoZSBwYWdlIHRvIGEgbmFtZWQgYW5jaG9y IGluc3RlYWQKLSAgICAvLyBvZiBkb3dubG9hZGluZyBhIG5ldyBkb2N1bWVudC4KLSAgICB2aXJ0 dWFsIHZvaWQgZGlkQ2hhbmdlTG9jYXRpb25XaXRoaW5QYWdlKFdlYkZyYW1lKiwgYm9vbCBpc05l d05hdmlnYXRpb24pIHsgfQorICAgIC8vIFRoZSBuYXZpZ2F0aW9uIHJlc3VsdGVkIGluIGEgc3Rh dGUgY2hhbmdlIHdpdGhpbiB0aGUgcGFnZSAoZS5nLiwKKyAgICAvLyBzY3JvbGxpbmcgdG8gYSBu YW1lZCBhbmNob3IpLgorICAgIHZpcnR1YWwgdm9pZCBkaWROYXZpZ2F0ZVdpdGhpblBhZ2UoV2Vi RnJhbWUqLCBib29sIGlzTmV3TmF2aWdhdGlvbiwgYm9vbCBpc0hhc2hDaGFuZ2UpIHsgfQogCiAg ICAgLy8gQ2FsbGVkIHVwb24gdXBkYXRlIHRvIHNjcm9sbCBwb3NpdGlvbiwgZG9jdW1lbnQgc3Rh dGUsIGFuZCBvdGhlcgogICAgIC8vIG5vbi1uYXZpZ2F0aW9uYWwgZXZlbnRzIHJlbGF0ZWQgdG8g dGhlIGRhdGEgaGVsZCBieSBXZWJIaXN0b3J5SXRlbS4KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViSGlzdG9yeUl0ZW0uaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViSGlzdG9yeUl0ZW0uaAkocmV2aXNpb24gNTMzNDApCisrKyBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkhpc3RvcnlJdGVtLmgJKHdvcmtpbmcgY29weSkKQEAgLTEwNSw2ICsxMDUs MTIgQEAgcHVibGljOgogICAgIFdFQktJVF9BUEkgV2ViVmVjdG9yPFdlYlN0cmluZz4gZG9jdW1l bnRTdGF0ZSgpIGNvbnN0OwogICAgIFdFQktJVF9BUEkgdm9pZCBzZXREb2N1bWVudFN0YXRlKGNv bnN0IFdlYlZlY3RvcjxXZWJTdHJpbmc+Jik7CiAKKyAgICBXRUJLSVRfQVBJIGxvbmcgbG9uZyBk b2N1bWVudElEKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSB2b2lkIHNldERvY3VtZW50SUQobG9u ZyBsb25nKTsKKworICAgIFdFQktJVF9BUEkgV2ViU3RyaW5nIHN0YXRlT2JqZWN0KCkgY29uc3Q7 CisgICAgV0VCS0lUX0FQSSB2b2lkIHNldFN0YXRlT2JqZWN0KGNvbnN0IFdlYlN0cmluZyYpOwor CiAgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcgaHR0cENvbnRlbnRUeXBlKCkgY29uc3Q7CiAgICAg V0VCS0lUX0FQSSB2b2lkIHNldEhUVFBDb250ZW50VHlwZShjb25zdCBXZWJTdHJpbmcmKTsKIApJ bmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwDQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3Bw CShyZXZpc2lvbiA1MzM0MCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGll bnRJbXBsLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTQwLDcgKzU0MCw3IEBAIHZvaWQgRnJhbWVM b2FkZXJDbGllbnRJbXBsOjpkaXNwYXRjaFdpbGwKICAgICB9CiB9CiAKLXZvaWQgRnJhbWVMb2Fk ZXJDbGllbnRJbXBsOjpkaXNwYXRjaERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZSgpCit2b2lk IEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEaWROYXZpZ2F0ZVdpdGhpblBhZ2UoYm9v bCBpc0hhc2hDaGFuZ2UpCiB7CiAgICAgLy8gQW5jaG9yIGZyYWdtZW50IG5hdmlnYXRpb25zIGFy ZSBub3Qgbm9ybWFsIGxvYWRzLCBzbyB3ZSBuZWVkIHRvIHN5bnRoZXNpemUKICAgICAvLyBzb21l IGV2ZW50cyBmb3Igb3VyIGRlbGVnYXRlLgpAQCAtNTU5LDcgKzU1OSw3IEBAIHZvaWQgRnJhbWVM b2FkZXJDbGllbnRJbXBsOjpkaXNwYXRjaERpZEMKIAogICAgIFdlYkRhdGFTb3VyY2VJbXBsKiBk cyA9IG1fd2ViRnJhbWUtPmRhdGFTb3VyY2VJbXBsKCk7CiAgICAgQVNTRVJUKGRzKTsgIC8vIFNo b3VsZCBub3QgYmUgbnVsbCB3aGVuIG5hdmlnYXRpbmcgdG8gYSByZWZlcmVuY2UgZnJhZ21lbnQh Ci0gICAgaWYgKGRzKSB7CisgICAgaWYgKGRzICYmIGlzSGFzaENoYW5nZSkgewogICAgICAgICBL VVJMIHVybCA9IGRzLT5yZXF1ZXN0KCkudXJsKCk7CiAgICAgICAgIEtVUkwgY2hhaW5FbmQ7CiAg ICAgICAgIGlmIChkcy0+aGFzUmVkaXJlY3RDaGFpbigpKSB7CkBAIC01OTgsMjYgKzU5OCwzMSBA QCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEaWRDCiAgICAgYm9vbCBpc05l d05hdmlnYXRpb247CiAgICAgd2ViVmlldy0+ZGlkQ29tbWl0TG9hZCgmaXNOZXdOYXZpZ2F0aW9u KTsKICAgICBpZiAobV93ZWJGcmFtZS0+Y2xpZW50KCkpCi0gICAgICAgIG1fd2ViRnJhbWUtPmNs aWVudCgpLT5kaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UobV93ZWJGcmFtZSwgaXNOZXdOYXZp Z2F0aW9uKTsKKyAgICAgICAgbV93ZWJGcmFtZS0+Y2xpZW50KCktPmRpZE5hdmlnYXRlV2l0aGlu UGFnZShtX3dlYkZyYW1lLCBpc05ld05hdmlnYXRpb24sIGlzSGFzaENoYW5nZSk7CiAKICAgICAv LyBHZW5lcmF0ZSBkaWRTdG9wTG9hZGluZyBpZiBsb2FkZXIgaXMgY29tcGxldGVkLgogICAgIGlm ICh3ZWJWaWV3LT5jbGllbnQoKSAmJiBsb2FkZXJDb21wbGV0ZWQpCiAgICAgICAgIHdlYlZpZXct PmNsaWVudCgpLT5kaWRTdG9wTG9hZGluZygpOwogfQogCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 SW1wbDo6ZGlzcGF0Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UoKQoreworICAgIC8vIFhY WCBkZWxldGUgdGhpcyBtZXRob2QKK30KKwogdm9pZCBGcmFtZUxvYWRlckNsaWVudEltcGw6OmRp c3BhdGNoRGlkUHVzaFN0YXRlV2l0aGluUGFnZSgpCiB7Ci0gICAgLy8gRklYTUUKKyAgICBkaXNw YXRjaERpZE5hdmlnYXRlV2l0aGluUGFnZShmYWxzZSk7CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJD bGllbnRJbXBsOjpkaXNwYXRjaERpZFJlcGxhY2VTdGF0ZVdpdGhpblBhZ2UoKQogewotICAgIC8v IEZJWE1FCisgICAgZGlzcGF0Y2hEaWROYXZpZ2F0ZVdpdGhpblBhZ2UoZmFsc2UpOwogfQogCiB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hEaWRQb3BTdGF0ZVdpdGhpblBhZ2Uo KQogewotICAgIC8vIEZJWE1FCisgICAgLy8gWFhYIGRlbGV0ZSB0aGlzIG1ldGhvZAogfQogCiB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50SW1wbDo6ZGlzcGF0Y2hXaWxsQ2xvc2UoKQpJbmRleDogV2Vi S2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaA0KPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0t IFdlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgJKHJldmlzaW9uIDUz MzQwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaAkod29y a2luZyBjb3B5KQpAQCAtOTQsNiArOTQsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRp c3BhdGNoRGlkUmVjZWl2ZVNlcnZlclJlZGlyZWN0Rm9yUHJvdmlzaW9uYWxMb2FkKCk7CiAgICAg dmlydHVhbCB2b2lkIGRpc3BhdGNoRGlkQ2FuY2VsQ2xpZW50UmVkaXJlY3QoKTsKICAgICB2aXJ0 dWFsIHZvaWQgZGlzcGF0Y2hXaWxsUGVyZm9ybUNsaWVudFJlZGlyZWN0KGNvbnN0IFdlYkNvcmU6 OktVUkwmLCBkb3VibGUgaW50ZXJ2YWwsIGRvdWJsZSBmaXJlRGF0ZSk7CisgICAgdmlydHVhbCB2 b2lkIGRpc3BhdGNoRGlkTmF2aWdhdGVXaXRoaW5QYWdlKGJvb2wgaXNIYXNoQ2hhbmdlKTsKICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UoKTsKICAg ICB2aXJ0dWFsIHZvaWQgZGlzcGF0Y2hEaWRQdXNoU3RhdGVXaXRoaW5QYWdlKCk7CiAgICAgdmly dHVhbCB2b2lkIGRpc3BhdGNoRGlkUmVwbGFjZVN0YXRlV2l0aGluUGFnZSgpOwpJbmRleDogV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJIaXN0b3J5SXRlbS5jcHANCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJL aXQvY2hyb21pdW0vc3JjL1dlYkhpc3RvcnlJdGVtLmNwcAkocmV2aXNpb24gNTMzNDApCisrKyBX ZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpc3RvcnlJdGVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MjE4LDYgKzIxOCwzMyBAQCB2b2lkIFdlYkhpc3RvcnlJdGVtOjpzZXREb2N1bWVudFN0YXRlKGNv CiAgICAgbV9wcml2YXRlLT5zZXREb2N1bWVudFN0YXRlKGRzKTsKIH0KIAorbG9uZyBsb25nIFdl Ykhpc3RvcnlJdGVtOjpkb2N1bWVudElEKCkgY29uc3QKK3sKKyAgICBBU1NFUlQoIWlzTnVsbCgp KTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCk7Cit9CisK K3ZvaWQgV2ViSGlzdG9yeUl0ZW06OnNldERvY3VtZW50SUQobG9uZyBsb25nIGRvY3VtZW50SUQp Cit7CisgICAgZW5zdXJlTXV0YWJsZSgpOworICAgIG1fcHJpdmF0ZS0+c2V0RG9jdW1lbnRTZXF1 ZW5jZU51bWJlcihkb2N1bWVudElEKTsKK30KKworV2ViU3RyaW5nIFdlYkhpc3RvcnlJdGVtOjpz dGF0ZU9iamVjdCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKCFpc051bGwoKSk7CisgICAgcmV0dXJu IG1fcHJpdmF0ZS0+c3RhdGVPYmplY3QoKSA/IG1fcHJpdmF0ZS0+c3RhdGVPYmplY3QoKS0+dG9T dHJpbmcoKSA6IFN0cmluZygpOworfQorCit2b2lkIFdlYkhpc3RvcnlJdGVtOjpzZXRTdGF0ZU9i amVjdChjb25zdCBXZWJTdHJpbmcmIHN0YXRlKQoreworICAgIGVuc3VyZU11dGFibGUoKTsKKyAg ICBSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBuZXdWYWx1ZTsKKyAgICAvL2lmICghc3Rh dGUuaXNOdWxsKCkpCisgICAgICAgIG5ld1ZhbHVlID0gU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpj cmVhdGUoc3RhdGUpOworICAgIG1fcHJpdmF0ZS0+c2V0U3RhdGVPYmplY3QobmV3VmFsdWUpOwor fQorCiBXZWJTdHJpbmcgV2ViSGlzdG9yeUl0ZW06Omh0dHBDb250ZW50VHlwZSgpIGNvbnN0CiB7 CiAgICAgQVNTRVJUKCFpc051bGwoKSk7Cg== 47388 2010-01-25 22:42:10 -0800 2010-01-26 22:06:33 -0800 v1 patch hist_1.txt text/plain 18689 fishd SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1Mzg0MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTMgQEAKKzIwMTAtMDEtMjUgIERhcmluIEZpc2hlciAgPGRhcmluQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBD aGFpbnMgb2YgaGlzdG9yeSBpdGVtcyByZXByZXNlbnRpbmcgc2FtZS1kb2N1bWVudCBuYXZpZ2F0 aW9uIG5lZWQgdG8KKyAgICAgICAgYWx3YXlzIHJlbWVtYmVyIHRoYXQgYXNzb2NpYXRpb24KKwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzMyMjQKKwor ICAgICAgICBSZXBsYWNlIEhpc3RvcnlJdGVtJ3MgRG9jdW1lbnQgcG9pbnRlciB3aXRoIGEgRG9j dW1lbnRTZXF1ZW5jZU51bWJlci4KKyAgICAgICAgRHVyaW5nIHNlc3Npb24gaGlzdG9yeSB0cmF2 ZXJzYWwsIGlmIHRoZSBjdXJyZW50IEhpc3RvcnlJdGVtIGFuZCB0aGUKKyAgICAgICAgdGFyZ2V0 IEhpc3RvcnlJdGVtIGhhdmUgdGhlIHNhbWUgRG9jdW1lbnRTZXF1ZW5jZU51bWJlciwgdGhlbiBp dCBtZWFucworICAgICAgICB0aGF0IHRoZSBjdXJyZW50IERvY3VtZW50IHNob3VsZCByZW1haW4u CisKKyAgICAgICAgTk9URTogVG8gc3VwcG9ydCBDaHJvbWl1bSdzIHNlcmlhbGl6YXRpb24gb2Yg SGlzdG9yeUl0ZW1zLCBJIGdlbmVyYXRlCisgICAgICAgIERvY3VtZW50U2VxdWVuY2VOdW1iZXJz IHRoYXQgYXJlIHVuaXF1ZSBhY3Jvc3MgYXBwbGljYXRpb24gbGF1bmNoZXMuCisgICAgICAgIERv Y3VtZW50U2VxdWVuY2VOdW1iZXJzIGFyZSBnZW5lcmF0ZWQgdXNpbmcgYSBjb3VudGVyIGluaXRp YWxpemVkIHdpdGgKKyAgICAgICAgdGhlIHRpbWUgb2YgZGF5LgorCisgICAgICAgIFRlc3Q6IGZh c3QvbG9hZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5o dG1sCisKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9j dW1lbnQ6OmRldGFjaCk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogaGlz dG9yeS9CYWNrRm9yd2FyZExpc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QmFja0ZvcndhcmRM aXN0OjpwdXNoU3RhdGVJdGVtKToKKyAgICAgICAgKiBoaXN0b3J5L0JhY2tGb3J3YXJkTGlzdENo cm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkJhY2tGb3J3YXJkTGlzdDo6cHVzaFN0YXRl SXRlbSk6CisgICAgICAgICogaGlzdG9yeS9IaXN0b3J5SXRlbS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpnZW5lcmF0ZURvY3VtZW50U2VxdWVuY2VOdW1iZXIpOgorICAgICAgICAoV2ViQ29yZTo6 SGlzdG9yeUl0ZW06Okhpc3RvcnlJdGVtKToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlJdGVt Ojp+SGlzdG9yeUl0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUl0ZW06OnNldFN0YXRl T2JqZWN0KToKKyAgICAgICAgKiBoaXN0b3J5L0hpc3RvcnlJdGVtLmg6CisgICAgICAgIChXZWJD b3JlOjpIaXN0b3J5SXRlbTo6c2V0RG9jdW1lbnRTZXF1ZW5jZU51bWJlcik6CisgICAgICAgIChX ZWJDb3JlOjpIaXN0b3J5SXRlbTo6ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcik6CisgICAgICAgICog bG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpu YXZpZ2F0ZVdpdGhpbkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjps b2FkSXRlbSk6CisgICAgICAgICogbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjp1cGRhdGVCYWNrRm9yd2FyZExpc3RGb3JG cmFnbWVudFNjcm9sbCk6CisgICAgICAgIChXZWJDb3JlOjpIaXN0b3J5Q29udHJvbGxlcjo6cHVz aFN0YXRlKToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjpyZXBsYWNlU3Rh dGUpOgorICAgICAgICAqIGxvYWRlci9SZWRpcmVjdFNjaGVkdWxlci5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpSZWRpcmVjdFNjaGVkdWxlcjo6c2NoZWR1bGVIaXN0b3J5TmF2aWdhdGlvbik6Cisg ICAgICAgICogcGFnZS9IaXN0b3J5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okhpc3Rvcnk6OnN0 YXRlT2JqZWN0QWRkZWQpOgorICAgICAgICAqIHBhZ2UvUGFnZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpQYWdlOjpnb1RvSXRlbSk6CisKIDIwMTAtMDEtMjIgIEplcmVteSBPcmxvdyAgPGpvcmxv d0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4 OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20vRG9j dW1lbnQuY3BwCShyZXZpc2lvbiA1MzgzNykKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAko d29ya2luZyBjb3B5KQpAQCAtMTU0NywxMiArMTU0Nyw2IEBAIHZvaWQgRG9jdW1lbnQ6OmRldGFj aCgpCiAgICAgaWYgKHJlbmRlcikKICAgICAgICAgcmVuZGVyLT5kZXN0cm95KCk7CiAgICAgCi0g ICAgSGFzaFNldDxSZWZQdHI8SGlzdG9yeUl0ZW0+ID4gYXNzb2NpYXRlZEhpc3RvcnlJdGVtczsK LSAgICBhc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLnN3YXAobV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1z KTsKLSAgICBIYXNoU2V0PFJlZlB0cjxIaXN0b3J5SXRlbT4gPjo6aXRlcmF0b3IgZW5kID0gYXNz b2NpYXRlZEhpc3RvcnlJdGVtcy5lbmQoKTsKLSAgICBmb3IgKEhhc2hTZXQ8UmVmUHRyPEhpc3Rv cnlJdGVtPiA+OjppdGVyYXRvciBpID0gYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5iZWdpbigpOyBp ICE9IGVuZDsgKytpKQotICAgICAgICAoKmkpLT5kb2N1bWVudERldGFjaGVkKHRoaXMpOwotICAg IAogICAgIC8vIFRoaXMgaXMgcmVxdWlyZWQsIGFzIG91ciBGcmFtZSBtaWdodCBkZWxldGUgaXRz ZWxmIGFzIHNvb24gYXMgaXQgZGV0YWNoZXMKICAgICAvLyB1cy4gSG93ZXZlciwgdGhpcyB2aW9s YXRlcyBOb2RlOjpkZXRhY2goKSBzZW1hbnRpY3MsIGFzIGl0J3MgbmV2ZXIKICAgICAvLyBwb3Nz aWJsZSB0byByZS1hdHRhY2guIEV2ZW50dWFsbHkgRG9jdW1lbnQ6OmRldGFjaCgpIHNob3VsZCBi ZSByZW5hbWVkLApAQCAtNDQ3NCwxOCArNDQ2OCw2IEBAIHZvaWQgRG9jdW1lbnQ6OnN0YXRlUG9w cGVkKFNlcmlhbGl6ZWRTY3IKICAgICAgICAgbV9wZW5kaW5nU3RhdGVPYmplY3QgPSBzdGF0ZU9i amVjdDsKIH0KIAotdm9pZCBEb2N1bWVudDo6cmVnaXN0ZXJIaXN0b3J5SXRlbShIaXN0b3J5SXRl bSogaXRlbSkKLXsKLSAgICBBU1NFUlQoIW1fYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5jb250YWlu cyhpdGVtKSk7Ci0gICAgbV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLmFkZChpdGVtKTsKLX0KLQot dm9pZCBEb2N1bWVudDo6dW5yZWdpc3Rlckhpc3RvcnlJdGVtKEhpc3RvcnlJdGVtKiBpdGVtKQot ewotICAgIEFTU0VSVChtX2Fzc29jaWF0ZWRIaXN0b3J5SXRlbXMuY29udGFpbnMoaXRlbSkgfHwg bV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLmlzRW1wdHkoKSk7Ci0gICAgbV9hc3NvY2lhdGVkSGlz dG9yeUl0ZW1zLnJlbW92ZShpdGVtKTsKLX0KLQogdm9pZCBEb2N1bWVudDo6dXBkYXRlU2FuZGJv eEZsYWdzKCkKIHsKICAgICBpZiAobV9mcmFtZSAmJiBzZWN1cml0eU9yaWdpbigpKQpJbmRleDog V2ViQ29yZS9kb20vRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9Eb2N1bWVu dC5oCShyZXZpc2lvbiA1MzgzNykKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJKHdvcmtpbmcg Y29weSkKQEAgLTkwNCw4ICs5MDQsNiBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHVwZGF0ZVVSTEZv clB1c2hPclJlcGxhY2VTdGF0ZShjb25zdCBLVVJMJik7CiAgICAgdm9pZCBzdGF0ZVBvcHBlZChT ZXJpYWxpemVkU2NyaXB0VmFsdWUqKTsKLSAgICB2b2lkIHJlZ2lzdGVySGlzdG9yeUl0ZW0oSGlz dG9yeUl0ZW0qIGl0ZW0pOwotICAgIHZvaWQgdW5yZWdpc3Rlckhpc3RvcnlJdGVtKEhpc3RvcnlJ dGVtKiBpdGVtKTsKIAogICAgIHZvaWQgdXBkYXRlU2FuZGJveEZsYWdzKCk7IC8vIFNldCBzYW5k Ym94IGZsYWdzIGFzIGRldGVybWluZWQgYnkgdGhlIGZyYW1lLgogCkluZGV4OiBXZWJDb3JlL2hp c3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2hpc3Rvcnkv QmFja0ZvcndhcmRMaXN0LmNwcAkocmV2aXNpb24gNTM4MzcpCisrKyBXZWJDb3JlL2hpc3Rvcnkv QmFja0ZvcndhcmRMaXN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjM5LDIwICsyMzksMTUgQEAg SGlzdG9yeUl0ZW1WZWN0b3ImIEJhY2tGb3J3YXJkTGlzdDo6ZW50cgogdm9pZCBCYWNrRm9yd2Fy ZExpc3Q6OnB1c2hTdGF0ZUl0ZW0oUGFzc1JlZlB0cjxIaXN0b3J5SXRlbT4gbmV3SXRlbSkKIHsK ICAgICBBU1NFUlQobmV3SXRlbSk7Ci0gICAgQVNTRVJUKG5ld0l0ZW0tPmRvY3VtZW50KCkpOwog ICAgIEFTU0VSVChuZXdJdGVtLT5zdGF0ZU9iamVjdCgpKTsKICAgICAKICAgICBSZWZQdHI8SGlz dG9yeUl0ZW0+IGN1cnJlbnQgPSBjdXJyZW50SXRlbSgpOwogICAgIEFTU0VSVChjdXJyZW50KTsK IAotICAgIERvY3VtZW50KiBuZXdJdGVtRG9jdW1lbnQgPSBuZXdJdGVtLT5kb2N1bWVudCgpOwot CiAgICAgYWRkSXRlbShuZXdJdGVtKTsKICAgICAKLSAgICBpZiAoIWN1cnJlbnQtPmRvY3VtZW50 KCkpIHsKLSAgICAgICAgY3VycmVudC0+c2V0RG9jdW1lbnQobmV3SXRlbURvY3VtZW50KTsKKyAg ICBpZiAoIWN1cnJlbnQtPnN0YXRlT2JqZWN0KCkpCiAgICAgICAgIGN1cnJlbnQtPnNldFN0YXRl T2JqZWN0KFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZTo6Y3JlYXRlKCkpOwotICAgIH0KIH0KIAogdm9p ZCBCYWNrRm9yd2FyZExpc3Q6OmNsb3NlKCkKSW5kZXg6IFdlYkNvcmUvaGlzdG9yeS9CYWNrRm9y d2FyZExpc3RDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9oaXN0b3J5L0JhY2tG b3J3YXJkTGlzdENocm9taXVtLmNwcAkocmV2aXNpb24gNTM4MzcpCisrKyBXZWJDb3JlL2hpc3Rv cnkvQmFja0ZvcndhcmRMaXN0Q2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMjMsNyAr MTIzLDEyIEBAIEhpc3RvcnlJdGVtKiBCYWNrRm9yd2FyZExpc3Q6Oml0ZW1BdEluZGUKIAogdm9p ZCBCYWNrRm9yd2FyZExpc3Q6OnB1c2hTdGF0ZUl0ZW0oUGFzc1JlZlB0cjxIaXN0b3J5SXRlbT4g bmV3SXRlbSkKIHsKLSAgLy8gRklYTUU6IE5lZWQgdG8gaW1wbGVtZW50IHN0YXRlIHN1cHBvcnQg Zm9yIGNocm9taXVtLgorICAgIFJlZlB0cjxIaXN0b3J5SXRlbT4gY3VycmVudCA9IG1fY2xpZW50 LT5jdXJyZW50SXRlbSgpOworCisgICAgYWRkSXRlbShuZXdJdGVtKTsKKworICAgIGlmICghY3Vy cmVudC0+c3RhdGVPYmplY3QoKSkKKyAgICAgICAgY3VycmVudC0+c2V0U3RhdGVPYmplY3QoU2Vy aWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoKSk7CiB9CiAKIEhpc3RvcnlJdGVtVmVjdG9yJiBC YWNrRm9yd2FyZExpc3Q6OmVudHJpZXMoKQpJbmRleDogV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJ dGVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2hpc3RvcnkvSGlzdG9yeUl0ZW0uY3BwCShy ZXZpc2lvbiA1MzgzNykKKysrIFdlYkNvcmUvaGlzdG9yeS9IaXN0b3J5SXRlbS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTMzLDkgKzMzLDE4IEBACiAjaW5jbHVkZSAiUGFnZUNhY2hlLmgiCiAjaW5j bHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDx3 dGYvQ3VycmVudFRpbWUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitzdGF0aWMgbG9uZyBs b25nIGdlbmVyYXRlRG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpCit7CisgICAgLy8gSW5pdGlhbGl6 ZSB0byB0aGUgY3VycmVudCB0aW1lIHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9vZCBvZiBnZW5lcmF0 aW5nCisgICAgLy8gaWRlbnRpZmllcnMgdGhhdCBvdmVybGFwIHdpdGggdGhvc2UgZnJvbSBwYXN0 L2Z1dHVyZSBicm93c2VyIHNlc3Npb25zLgorICAgIHN0YXRpYyBsb25nIGxvbmcgbmV4dCA9IHN0 YXRpY19jYXN0PGxvbmcgbG9uZz4oY3VycmVudFRpbWUoKSAqIDEwMDAwMDAuMCk7CisgICAgcmV0 dXJuICsrbmV4dDsKK30KKwogc3RhdGljIHZvaWQgZGVmYXVsdE5vdGlmeUhpc3RvcnlJdGVtQ2hh bmdlZChIaXN0b3J5SXRlbSopCiB7CiB9CkBAIC00OCw3ICs1Nyw3IEBAIEhpc3RvcnlJdGVtOjpI aXN0b3J5SXRlbSgpCiAgICAgLCBtX2xhc3RWaXNpdFdhc0ZhaWx1cmUoZmFsc2UpCiAgICAgLCBt X2lzVGFyZ2V0SXRlbShmYWxzZSkKICAgICAsIG1fdmlzaXRDb3VudCgwKQotICAgICwgbV9kb2N1 bWVudCgwKQorICAgICwgbV9kb2N1bWVudFNlcXVlbmNlTnVtYmVyKGdlbmVyYXRlRG9jdW1lbnRT ZXF1ZW5jZU51bWJlcigpKQogewogfQogCkBAIC02MSw3ICs3MCw3IEBAIEhpc3RvcnlJdGVtOjpI aXN0b3J5SXRlbShjb25zdCBTdHJpbmcmIHUKICAgICAsIG1fbGFzdFZpc2l0V2FzRmFpbHVyZShm YWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAgICwgbV92aXNpdENvdW50KDAp Ci0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIoZ2Vu ZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7ICAgIAogICAgIGljb25EYXRhYmFzZSgp LT5yZXRhaW5JY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiB9CkBAIC03Niw3ICs4NSw3IEBA IEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBTdHJpbmcmIHUKICAgICAsIG1fbGFzdFZp c2l0V2FzRmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAgICwg bV92aXNpdENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2Vx dWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7CiAgICAgaWNv bkRhdGFiYXNlKCktPnJldGFpbkljb25Gb3JQYWdlVVJMKG1fdXJsU3RyaW5nKTsKIH0KQEAgLTky LDcgKzEwMSw3IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBLVVJMJiB1cmwKICAg ICAsIG1fbGFzdFZpc2l0V2FzRmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZh bHNlKQogICAgICwgbV92aXNpdENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBt X2RvY3VtZW50U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkp CiB7ICAgIAogICAgIGljb25EYXRhYmFzZSgpLT5yZXRhaW5JY29uRm9yUGFnZVVSTChtX3VybFN0 cmluZyk7CiB9CkBAIC0xMDAsNyArMTA5LDYgQEAgSGlzdG9yeUl0ZW06Okhpc3RvcnlJdGVtKGNv bnN0IEtVUkwmIHVybAogSGlzdG9yeUl0ZW06On5IaXN0b3J5SXRlbSgpCiB7CiAgICAgQVNTRVJU KCFtX2NhY2hlZFBhZ2UpOwotICAgIEFTU0VSVCghbV9kb2N1bWVudCk7CiAgICAgaWNvbkRhdGFi YXNlKCktPnJlbGVhc2VJY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiAjaWYgUExBVEZPUk0o QU5EUk9JRCkKICAgICBpZiAobV9icmlkZ2UpCkBAIC0xMjUsNyArMTMzLDcgQEAgaW5saW5lIEhp c3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBIaQogICAgICwgbV92aXNpdENvdW50KGl0ZW0u bV92aXNpdENvdW50KQogICAgICwgbV9kYWlseVZpc2l0Q291bnRzKGl0ZW0ubV9kYWlseVZpc2l0 Q291bnRzKQogICAgICwgbV93ZWVrbHlWaXNpdENvdW50cyhpdGVtLm1fd2Vla2x5VmlzaXRDb3Vu dHMpCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIo Z2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiAgICAgLCBtX2Zvcm1Db250ZW50VHlw ZShpdGVtLm1fZm9ybUNvbnRlbnRUeXBlKQogewogICAgIGlmIChpdGVtLm1fZm9ybURhdGEpCkBA IC0zOTcsMjkgKzQwNSw5IEBAIHZvaWQgSGlzdG9yeUl0ZW06OnNldElzVGFyZ2V0SXRlbShib29s IGYKIAogdm9pZCBIaXN0b3J5SXRlbTo6c2V0U3RhdGVPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxp emVkU2NyaXB0VmFsdWU+IG9iamVjdCkKIHsKLSAgICBBU1NFUlQobV9kb2N1bWVudCk7CiAgICAg bV9zdGF0ZU9iamVjdCA9IG9iamVjdDsKIH0KIAotdm9pZCBIaXN0b3J5SXRlbTo6c2V0RG9jdW1l bnQoRG9jdW1lbnQqIGRvY3VtZW50KQotewotICAgIGlmIChtX2RvY3VtZW50ID09IGRvY3VtZW50 KQotICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgaWYgKG1fZG9jdW1lbnQpCi0gICAgICAgIG1f ZG9jdW1lbnQtPnVucmVnaXN0ZXJIaXN0b3J5SXRlbSh0aGlzKTsKLSAgICBpZiAoZG9jdW1lbnQp Ci0gICAgICAgIGRvY3VtZW50LT5yZWdpc3Rlckhpc3RvcnlJdGVtKHRoaXMpOwotICAgICAgICAK LSAgICBtX2RvY3VtZW50ID0gZG9jdW1lbnQ7Ci19Ci0KLXZvaWQgSGlzdG9yeUl0ZW06OmRvY3Vt ZW50RGV0YWNoZWQoRG9jdW1lbnQqIGRvY3VtZW50KQotewotICAgIEFTU0VSVF9VTlVTRUQoZG9j dW1lbnQsIG1fZG9jdW1lbnQgPT0gZG9jdW1lbnQpOwotICAgIG1fZG9jdW1lbnQgPSAwOwotfQot CiB2b2lkIEhpc3RvcnlJdGVtOjphZGRDaGlsZEl0ZW0oUGFzc1JlZlB0cjxIaXN0b3J5SXRlbT4g Y2hpbGQpCiB7CiAgICAgQVNTRVJUKCFjaGlsZEl0ZW1XaXRoVGFyZ2V0KGNoaWxkLT50YXJnZXQo KSkpOwpJbmRleDogV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgJKHJldmlzaW9uIDUzODM3KQorKysgV2ViQ29y ZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgJKHdvcmtpbmcgY29weSkKQEAgLTEzNSw5ICsxMzUsOSBA QCBwdWJsaWM6IAogICAgIAogICAgIHZvaWQgc2V0U3RhdGVPYmplY3QoUGFzc1JlZlB0cjxTZXJp YWxpemVkU2NyaXB0VmFsdWU+IG9iamVjdCk7CiAgICAgU2VyaWFsaXplZFNjcmlwdFZhbHVlKiBz dGF0ZU9iamVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fc3RhdGVPYmplY3QuZ2V0KCk7IH0KLSAgICB2 b2lkIHNldERvY3VtZW50KERvY3VtZW50KiBkb2N1bWVudCk7Ci0gICAgRG9jdW1lbnQqIGRvY3Vt ZW50KCkgY29uc3QgeyByZXR1cm4gbV9kb2N1bWVudDsgfQotICAgIHZvaWQgZG9jdW1lbnREZXRh Y2hlZChEb2N1bWVudCopOworCisgICAgdm9pZCBzZXREb2N1bWVudFNlcXVlbmNlTnVtYmVyKGxv bmcgbG9uZyBudW1iZXIpIHsgbV9kb2N1bWVudFNlcXVlbmNlTnVtYmVyID0gbnVtYmVyOyB9Cisg ICAgbG9uZyBsb25nIGRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2Rv Y3VtZW50U2VxdWVuY2VOdW1iZXI7IH0KICAgICAKICAgICB2b2lkIHNldEZvcm1JbmZvRnJvbVJl cXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CiAgICAgdm9pZCBzZXRGb3JtRGF0YShQYXNz UmVmUHRyPEZvcm1EYXRhPik7CkBAIC0yNDQsNyArMjQ0LDcgQEAgcHJpdmF0ZToKIAogICAgIC8v IFN1cHBvcnQgZm9yIEhUTUw1IEhpc3RvcnkKICAgICBSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZh bHVlPiBtX3N0YXRlT2JqZWN0OwotICAgIERvY3VtZW50KiBtX2RvY3VtZW50OworICAgIGxvbmcg bG9uZyBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXI7CiAgICAgCiAgICAgLy8gaW5mbyB1c2VkIHRv IHJlcG9zdCBmb3JtIGRhdGEKICAgICBSZWZQdHI8Rm9ybURhdGE+IG1fZm9ybURhdGE7CkluZGV4 OiBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwCShyZXZpc2lvbiA1MzgzNykKKysrIFdlYkNvcmUvbG9hZGVy L0ZyYW1lTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzY5Myw3ICszNjkzLDcgQEAgRnJh bWUqIEZyYW1lTG9hZGVyOjpmaW5kRnJhbWVGb3JOYXZpZ2F0aQogCiB2b2lkIEZyYW1lTG9hZGVy OjpuYXZpZ2F0ZVdpdGhpbkRvY3VtZW50KEhpc3RvcnlJdGVtKiBpdGVtKQogewotICAgIEFTU0VS VCghaXRlbS0+ZG9jdW1lbnQoKSB8fCBpdGVtLT5kb2N1bWVudCgpID09IG1fZnJhbWUtPmRvY3Vt ZW50KCkpOworICAgIEFTU0VSVChpdGVtLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkgPT0gaGlz dG9yeSgpLT5jdXJyZW50SXRlbSgpLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpOwogCiAgICAg Ly8gU2F2ZSB1c2VyIHZpZXcgc3RhdGUgdG8gdGhlIGN1cnJlbnQgaGlzdG9yeSBpdGVtIGhlcmUg c2luY2Ugd2UgZG9uJ3QgZG8gYSBub3JtYWwgbG9hZC4KICAgICAvLyBGSVhNRTogRG9lcyBmb3Jt IHN0YXRlIG5lZWQgdG8gYmUgc2F2ZWQgaGVyZSB0b28/CkBAIC0zODE0LDcgKzM4MTQsNyBAQCB2 b2lkIEZyYW1lTG9hZGVyOjpsb2FkSXRlbShIaXN0b3J5SXRlbSogCiAgICAgLy8gLSBUaGUgSGlz dG9yeUl0ZW0gaGFzIGEgaGlzdG9yeSBzdGF0ZSBvYmplY3QKICAgICAvLyAtIE5hdmlnYXRpbmcg dG8gYW4gYW5jaG9yIHdpdGhpbiB0aGUgcGFnZSwgd2l0aCBubyBmb3JtIGRhdGEgc3RvcmVkIG9u IHRoZSB0YXJnZXQgaXRlbSBvciB0aGUgY3VycmVudCBoaXN0b3J5IGVudHJ5LAogICAgIC8vICAg YW5kIHRoZSBVUkxzIGluIHRoZSBmcmFtZSB0cmVlIG1hdGNoIHRoZSBoaXN0b3J5IGl0ZW0gZm9y IGZyYWdtZW50IHNjcm9sbGluZy4KLSAgICBib29sIHNhbWVEb2N1bWVudE5hdmlnYXRpb24gPSAo IWl0ZW0tPmZvcm1EYXRhKCkgJiYgIShoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCkgJiYgaGlzdG9y eSgpLT5jdXJyZW50SXRlbSgpLT5mb3JtRGF0YSgpKSAmJiBoaXN0b3J5KCktPnVybHNNYXRjaEl0 ZW0oaXRlbSkpIHx8IGl0ZW0tPmRvY3VtZW50KCkgPT0gbV9mcmFtZS0+ZG9jdW1lbnQoKTsKKyAg ICBib29sIHNhbWVEb2N1bWVudE5hdmlnYXRpb24gPSAoIWl0ZW0tPmZvcm1EYXRhKCkgJiYgISho aXN0b3J5KCktPmN1cnJlbnRJdGVtKCkgJiYgaGlzdG9yeSgpLT5jdXJyZW50SXRlbSgpLT5mb3Jt RGF0YSgpKSAmJiBoaXN0b3J5KCktPnVybHNNYXRjaEl0ZW0oaXRlbSkpIHx8IGl0ZW0tPmRvY3Vt ZW50U2VxdWVuY2VOdW1iZXIoKSA9PSBoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCktPmRvY3VtZW50 U2VxdWVuY2VOdW1iZXIoKTsKIAogI2lmIEVOQUJMRShXTUwpCiAgICAgLy8gQWxsIFdNTCBkZWNr cyBzaG91bGQgZ28gdGhyb3VnaCB0aGUgcmVhbCBsb2FkIG1lY2hhbmlzbSwgbm90IHRoZSBzY3Jv bGwtdG8tYW5jaG9yIGNvZGUKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9sbGVy LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAJ KHJldmlzaW9uIDUzODM3KQorKysgV2ViQ29yZS9sb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0xMDYsNiArMTA2LDEwIEBAIHZvaWQgSGlzdG9yeUNvbnRyb2xs ZXI6OnJlc3RvcmVTY3JvbGxQb3MKIHZvaWQgSGlzdG9yeUNvbnRyb2xsZXI6OnVwZGF0ZUJhY2tG b3J3YXJkTGlzdEZvckZyYWdtZW50U2Nyb2xsKCkKIHsKICAgICB1cGRhdGVCYWNrRm9yd2FyZExp c3RDbGlwcGVkQXRUYXJnZXQoZmFsc2UpOworICAgIAorICAgIC8vIFNpbmNlIHRoZSBkb2N1bWVu dCBpc24ndCBjaGFuZ2VkIGFzIGEgcmVzdWx0IG9mIGEgZnJhZ21lbnQgc2Nyb2xsLCB3ZSBzaG91 bGQKKyAgICAvLyBwcmVzZXJ2ZSB0aGUgRG9jdW1lbnRTZXF1ZW5jZU51bWJlciBvZiB0aGUgcHJl dmlvdXMgaXRlbS4KKyAgICBtX2N1cnJlbnRJdGVtLT5zZXREb2N1bWVudFNlcXVlbmNlTnVtYmVy KG1fcHJldmlvdXNJdGVtLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpOwogfQogCiB2b2lkIEhp c3RvcnlDb250cm9sbGVyOjpzYXZlRG9jdW1lbnRTdGF0ZSgpCkBAIC02MzUsMTAgKzYzOSwxMyBA QCB2b2lkIEhpc3RvcnlDb250cm9sbGVyOjpwdXNoU3RhdGUoUGFzc1JlCiAgICAgQVNTRVJUKGl0 ZW0tPmlzVGFyZ2V0SXRlbSgpKTsKICAgICAKICAgICAvLyBPdmVycmlkZSBkYXRhIGluIHRoZSB0 YXJnZXQgaXRlbSB0byByZWZsZWN0IHRoZSBwdXNoU3RhdGUoKSBhcmd1bWVudHMuCi0gICAgaXRl bS0+c2V0RG9jdW1lbnQobV9mcmFtZS0+ZG9jdW1lbnQoKSk7CiAgICAgaXRlbS0+c2V0VGl0bGUo dGl0bGUpOwogICAgIGl0ZW0tPnNldFN0YXRlT2JqZWN0KHN0YXRlT2JqZWN0KTsKICAgICBpdGVt LT5zZXRVUkxTdHJpbmcodXJsU3RyaW5nKTsKKworICAgIC8vIFNpbmNlIHRoZSBkb2N1bWVudCBp c24ndCBjaGFuZ2VkIGFzIGEgcmVzdWx0IG9mIGEgcHVzaFN0YXRlIGNhbGwsIHdlCisgICAgLy8g c2hvdWxkIHByZXNlcnZlIHRoZSBEb2N1bWVudFNlcXVlbmNlTnVtYmVyIG9mIHRoZSBwcmV2aW91 cyBpdGVtLgorICAgIGl0ZW0tPnNldERvY3VtZW50U2VxdWVuY2VOdW1iZXIobV9wcmV2aW91c0l0 ZW0tPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSk7CiAgICAgCiAgICAgcGFnZS0+YmFja0Zvcndh cmRMaXN0KCktPnB1c2hTdGF0ZUl0ZW0oaXRlbS5yZWxlYXNlKCkpOwogfQpAQCAtNjQ5LDEwICs2 NTYsNyBAQCB2b2lkIEhpc3RvcnlDb250cm9sbGVyOjpyZXBsYWNlU3RhdGUoUGFzCiAgICAgQVNT RVJUKHBhZ2UpOwogICAgIEhpc3RvcnlJdGVtKiBjdXJyZW50ID0gcGFnZS0+YmFja0ZvcndhcmRM aXN0KCktPmN1cnJlbnRJdGVtKCk7CiAgICAgQVNTRVJUKGN1cnJlbnQpOwotICAgIAotICAgIEFT U0VSVCghY3VycmVudC0+ZG9jdW1lbnQoKSB8fCBjdXJyZW50LT5kb2N1bWVudCgpID09IG1fZnJh bWUtPmRvY3VtZW50KCkpOwotICAgIGN1cnJlbnQtPnNldERvY3VtZW50KG1fZnJhbWUtPmRvY3Vt ZW50KCkpOwotICAgIAorCiAgICAgaWYgKCF1cmxTdHJpbmcuaXNFbXB0eSgpKQogICAgICAgICBj dXJyZW50LT5zZXRVUkxTdHJpbmcodXJsU3RyaW5nKTsKICAgICBjdXJyZW50LT5zZXRUaXRsZSh0 aXRsZSk7CkluZGV4OiBXZWJDb3JlL2xvYWRlci9SZWRpcmVjdFNjaGVkdWxlci5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvUmVkaXJlY3RTY2hlZHVsZXIuY3BwCShyZXZpc2lvbiA1 MzgzNykKKysrIFdlYkNvcmUvbG9hZGVyL1JlZGlyZWN0U2NoZWR1bGVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtMjc3LDcgKzI3Nyw3IEBAIHZvaWQgUmVkaXJlY3RTY2hlZHVsZXI6OnNjaGVkdWxl SGlzdG9yeU4KICAgICAvLyBJZiB0aGUgc3BlY2lmaWVkIGVudHJ5IGFuZCB0aGUgY3VycmVudCBl bnRyeSBoYXZlIHRoZSBzYW1lIGRvY3VtZW50LCB0aGlzIGlzIGVpdGhlciBhIHN0YXRlIG9iamVj dCB0cmF2ZXJzYWwgb3IgYSBmcmFnbWVudCAKICAgICAvLyB0cmF2ZXJzYWwgKG9yIGJvdGgpIGFu ZCBzaG91bGQgYmUgcGVyZm9ybWVkIHN5bmNocm9ub3VzbHkuCiAgICAgSGlzdG9yeUl0ZW0qIGN1 cnJlbnRFbnRyeSA9IG1fZnJhbWUtPmxvYWRlcigpLT5oaXN0b3J5KCktPmN1cnJlbnRJdGVtKCk7 Ci0gICAgaWYgKGN1cnJlbnRFbnRyeSAhPSBzcGVjaWZpZWRFbnRyeSAmJiBzcGVjaWZpZWRFbnRy eS0+ZG9jdW1lbnQoKSAmJiBjdXJyZW50RW50cnktPmRvY3VtZW50KCkgPT0gc3BlY2lmaWVkRW50 cnktPmRvY3VtZW50KCkpIHsKKyAgICBpZiAoY3VycmVudEVudHJ5ICE9IHNwZWNpZmllZEVudHJ5 ICYmIGN1cnJlbnRFbnRyeS0+ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpID09IHNwZWNpZmllZEVu dHJ5LT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpIHsKICAgICAgICAgbV9mcmFtZS0+bG9hZGVy KCktPmhpc3RvcnkoKS0+Z29Ub0l0ZW0oc3BlY2lmaWVkRW50cnksIEZyYW1lTG9hZFR5cGVJbmRl eGVkQmFja0ZvcndhcmQpOwogICAgICAgICByZXR1cm47CiAgICAgfQpJbmRleDogV2ViQ29yZS9w YWdlL0hpc3RvcnkuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9IaXN0b3J5LmNwcAko cmV2aXNpb24gNTM4MzcpCisrKyBXZWJDb3JlL3BhZ2UvSGlzdG9yeS5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTExMiwxMyArMTEyLDEzIEBAIHZvaWQgSGlzdG9yeTo6c3RhdGVPYmplY3RBZGRlZChQ YXNzUmVmUHQKICAgICBlbHNlIGlmIChzdGF0ZU9iamVjdFR5cGUgPT0gU3RhdGVPYmplY3RSZXBs YWNlKQogICAgICAgICBtX2ZyYW1lLT5sb2FkZXIoKS0+aGlzdG9yeSgpLT5yZXBsYWNlU3RhdGUo ZGF0YSwgdGl0bGUsIGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAgICAgCi0gICAgaWYgKCF1 cmxTdHJpbmcuaXNFbXB0eSgpKSB7CisgICAgaWYgKCF1cmxTdHJpbmcuaXNFbXB0eSgpKQogICAg ICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVVUkxGb3JQdXNoT3JSZXBsYWNlU3RhdGUo ZnVsbFVSTCk7Ci0gICAgICAgIGlmIChzdGF0ZU9iamVjdFR5cGUgPT0gU3RhdGVPYmplY3RQdXNo KQotICAgICAgICAgICAgbV9mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5kaXNwYXRjaERpZFB1 c2hTdGF0ZVdpdGhpblBhZ2UoKTsKLSAgICAgICAgZWxzZSBpZiAoc3RhdGVPYmplY3RUeXBlID09 IFN0YXRlT2JqZWN0UmVwbGFjZSkKLSAgICAgICAgICAgIG1fZnJhbWUtPmxvYWRlcigpLT5jbGll bnQoKS0+ZGlzcGF0Y2hEaWRSZXBsYWNlU3RhdGVXaXRoaW5QYWdlKCk7Ci0gICAgfQorCisgICAg aWYgKHN0YXRlT2JqZWN0VHlwZSA9PSBTdGF0ZU9iamVjdFB1c2gpCisgICAgICAgIG1fZnJhbWUt PmxvYWRlcigpLT5jbGllbnQoKS0+ZGlzcGF0Y2hEaWRQdXNoU3RhdGVXaXRoaW5QYWdlKCk7Cisg ICAgZWxzZSBpZiAoc3RhdGVPYmplY3RUeXBlID09IFN0YXRlT2JqZWN0UmVwbGFjZSkKKyAgICAg ICAgbV9mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5kaXNwYXRjaERpZFJlcGxhY2VTdGF0ZVdp dGhpblBhZ2UoKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9w YWdlL1BhZ2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9QYWdlLmNwcAkocmV2aXNp b24gNTM4MzcpCisrKyBXZWJDb3JlL3BhZ2UvUGFnZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI5 MCw3ICsyOTAsNyBAQCB2b2lkIFBhZ2U6OmdvQmFja09yRm9yd2FyZChpbnQgZGlzdGFuY2UpCiB2 b2lkIFBhZ2U6OmdvVG9JdGVtKEhpc3RvcnlJdGVtKiBpdGVtLCBGcmFtZUxvYWRUeXBlIHR5cGUp CiB7CiAgICAgLy8gQWJvcnQgYW55IGN1cnJlbnQgbG9hZCB1bmxlc3Mgd2UncmUgbmF2aWdhdGlu ZyB0aGUgY3VycmVudCBkb2N1bWVudCB0byBhIG5ldyBzdGF0ZSBvYmplY3QKLSAgICBpZiAoIWl0 ZW0tPnN0YXRlT2JqZWN0KCkgfHwgaXRlbS0+ZG9jdW1lbnQoKSAhPSBtX21haW5GcmFtZS0+ZG9j dW1lbnQoKSkgeworICAgIGlmICghaXRlbS0+c3RhdGVPYmplY3QoKSB8fCBpdGVtLT5kb2N1bWVu dFNlcXVlbmNlTnVtYmVyKCkgIT0gbV9tYWluRnJhbWUtPmxvYWRlcigpLT5oaXN0b3J5KCktPmN1 cnJlbnRJdGVtKCktPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSkgewogICAgICAgICAvLyBEZWZp bmUgd2hhdCB0byBkbyB3aXRoIGFueSBvcGVuIGRhdGFiYXNlIGNvbm5lY3Rpb25zLiBCeSBkZWZh dWx0IHdlIHN0b3AgdGhlbSBhbmQgdGVybWluYXRlIHRoZSBkYXRhYmFzZSB0aHJlYWQuCiAgICAg ICAgIERhdGFiYXNlUG9saWN5IGRhdGFiYXNlUG9saWN5ID0gRGF0YWJhc2VQb2xpY3lTdG9wOwog CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg0MCkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEwLTAxLTI1ICBEYXJpbiBGaXNoZXIgIDxk YXJpbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQ2hhaW5zIG9mIGhpc3RvcnkgaXRlbXMgcmVwcmVzZW50aW5nIHNhbWUtZG9j dW1lbnQgbmF2aWdhdGlvbiBuZWVkIHRvCisgICAgICAgIGFsd2F5cyByZW1lbWJlciB0aGF0IGFz c29jaWF0aW9uCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTMzMjI0CisKKyAgICAgICAgKiBmYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9jdW1lbnQt ZGVzdHJveWVkLW5hdmlnYXRlLWJhY2stZXhwZWN0ZWQudHh0OgorICAgICAgICAqIGZhc3QvbG9h ZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5odG1sOiBS ZXZpc2VkCisgICAgICAgIHRlc3QgcmVzdWx0cyB0byBtYXRjaCBjb3JyZWN0ZWQgYmVoYXZpb3Iu ICBBbHNvIHJlbW92ZWQgdGhlIHJlZHVuZGFudAorICAgICAgICBoaXN0b3J5LmJhY2soKSBjYWxs LCB3aGljaCBoZWxwcyBtYWtlIHRoZSB0ZXN0IGEgYml0IGVhc2llciB0byB1bmRlcnN0YW5kLgor CiAyMDEwLTAxLTIyICBKZXJlbXkgT3Jsb3cgIDxqb3Jsb3dAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9sb2Fk ZXIvc3RhdGVvYmplY3RzL2RvY3VtZW50LWRlc3Ryb3llZC1uYXZpZ2F0ZS1iYWNrLWV4cGVjdGVk LnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMv ZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2stZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA1 MzgzNykKKysrIExheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVudC1k ZXN0cm95ZWQtbmF2aWdhdGUtYmFjay1leHBlY3RlZC50eHQJKHdvcmtpbmcgY29weSkKQEAgLTUs OCArNSw2IEBAIEFMRVJUOiBOYXZpZ2F0aW5nIGJhY2suLi4KIG1haW4gZnJhbWUgLSBoYXMgMSBv bnVubG9hZCBoYW5kbGVyKHMpCiBBTEVSVDogTGFzdCBwYXRoIGNvbXBvbmVudCBvZiBsb2NhdGlv biBpcyBkb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5odG1sP1NlY29uZEVudHJ5V2ls bExhdGVyQmVSZWFjdGl2YXRlZAogQUxFUlQ6IFN0YXRlIHBvcHBlZCAtIFNlY29uZEVudHJ5V2ls bExhdGVyQmVSZWFjdGl2YXRlZCAodHlwZSBzdHJpbmcpCi1tYWluIGZyYW1lIC0gaGFzIDEgb251 bmxvYWQgaGFuZGxlcihzKQotQUxFUlQ6IExhc3QgcGF0aCBjb21wb25lbnQgb2YgbG9jYXRpb24g aXMgZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbD9GaXJzdEVudHJ5V2lsbExh dGVyQmVSZWFjdGl2YXRlZAogQUxFUlQ6IFN0YXRlIHBvcHBlZCAtIEZpcnN0RW50cnlXaWxsTGF0 ZXJCZVJlYWN0aXZhdGVkICh0eXBlIHN0cmluZykKIEFMRVJUOiBUZXN0IGNvbXBsZXRlCiBUaGlz IHRlc3Q6CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9jdW1l bnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJh Y2suaHRtbAkocmV2aXNpb24gNTM4MzcpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9zdGF0 ZW9iamVjdHMvZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbAkod29ya2luZyBj b3B5KQpAQCAtMjQsNyArMjQsNiBAQCBmdW5jdGlvbiBydW5GaXJzdFN0YWdlT2ZUZXN0KCkKIGZ1 bmN0aW9uIHJ1blNlY29uZFN0YWdlT2ZUZXN0KCkKIHsKICAgICBhbGVydCgiTGFzdCBwYXRoIGNv bXBvbmVudCBvZiBsb2NhdGlvbiBpcyAiICsgbGFzdFBhdGhDb21wb25lbnQoKSk7Ci0gICAgaGlz dG9yeS5iYWNrKCk7CiB9CiAKIGZ1bmN0aW9uIHJ1blRoaXJkU3RhZ2VPZlRlc3QoKQo= 47494 2010-01-26 22:06:33 -0800 2010-01-27 11:59:13 -0800 v2 patch hist_2.txt text/plain 24677 fishd SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1Mzg5NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTMgQEAKKzIwMTAtMDEtMjYgIERhcmluIEZpc2hlciAgPGRhcmluQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBD aGFpbnMgb2YgaGlzdG9yeSBpdGVtcyByZXByZXNlbnRpbmcgc2FtZS1kb2N1bWVudCBuYXZpZ2F0 aW9uIG5lZWQgdG8KKyAgICAgICAgYWx3YXlzIHJlbWVtYmVyIHRoYXQgYXNzb2NpYXRpb24KKwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzMyMjQKKwor ICAgICAgICBSZXBsYWNlIEhpc3RvcnlJdGVtJ3MgRG9jdW1lbnQgcG9pbnRlciB3aXRoIGEgRG9j dW1lbnRTZXF1ZW5jZU51bWJlci4KKyAgICAgICAgRHVyaW5nIHNlc3Npb24gaGlzdG9yeSB0cmF2 ZXJzYWwsIGlmIHRoZSBjdXJyZW50IEhpc3RvcnlJdGVtIGFuZCB0aGUKKyAgICAgICAgdGFyZ2V0 IEhpc3RvcnlJdGVtIGhhdmUgdGhlIHNhbWUgRG9jdW1lbnRTZXF1ZW5jZU51bWJlciwgdGhlbiBp dCBtZWFucworICAgICAgICB0aGF0IHRoZSBjdXJyZW50IERvY3VtZW50IHNob3VsZCByZW1haW4u CisKKyAgICAgICAgTk9URTogVG8gc3VwcG9ydCBDaHJvbWl1bSdzIHNlcmlhbGl6YXRpb24gb2Yg SGlzdG9yeUl0ZW1zLCBJIGdlbmVyYXRlCisgICAgICAgIERvY3VtZW50U2VxdWVuY2VOdW1iZXJz IHRoYXQgYXJlIHVuaXF1ZSBhY3Jvc3MgYXBwbGljYXRpb24gbGF1bmNoZXMuCisgICAgICAgIERv Y3VtZW50U2VxdWVuY2VOdW1iZXJzIGFyZSBnZW5lcmF0ZWQgdXNpbmcgYSBjb3VudGVyIGluaXRp YWxpemVkIHdpdGgKKyAgICAgICAgdGhlIHRpbWUgb2YgZGF5LgorCisgICAgICAgIFRlc3Q6IGZh c3QvbG9hZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5o dG1sCisKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9j dW1lbnQ6OmRldGFjaCk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogaGlz dG9yeS9CYWNrRm9yd2FyZExpc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QmFja0ZvcndhcmRM aXN0OjpwdXNoU3RhdGVJdGVtKToKKyAgICAgICAgKiBoaXN0b3J5L0JhY2tGb3J3YXJkTGlzdENo cm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkJhY2tGb3J3YXJkTGlzdDo6cHVzaFN0YXRl SXRlbSk6CisgICAgICAgICogaGlzdG9yeS9IaXN0b3J5SXRlbS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpnZW5lcmF0ZURvY3VtZW50U2VxdWVuY2VOdW1iZXIpOgorICAgICAgICAoV2ViQ29yZTo6 SGlzdG9yeUl0ZW06Okhpc3RvcnlJdGVtKToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlJdGVt Ojp+SGlzdG9yeUl0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUl0ZW06OnNldFN0YXRl T2JqZWN0KToKKyAgICAgICAgKiBoaXN0b3J5L0hpc3RvcnlJdGVtLmg6CisgICAgICAgIChXZWJD b3JlOjpIaXN0b3J5SXRlbTo6c2V0RG9jdW1lbnRTZXF1ZW5jZU51bWJlcik6CisgICAgICAgIChX ZWJDb3JlOjpIaXN0b3J5SXRlbTo6ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcik6CisgICAgICAgICog bG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpu YXZpZ2F0ZVdpdGhpbkRvY3VtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjps b2FkSXRlbSk6CisgICAgICAgICogbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjp1cGRhdGVCYWNrRm9yd2FyZExpc3RGb3JG cmFnbWVudFNjcm9sbCk6CisgICAgICAgIChXZWJDb3JlOjpIaXN0b3J5Q29udHJvbGxlcjo6cHVz aFN0YXRlKToKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjpyZXBsYWNlU3Rh dGUpOgorICAgICAgICAqIGxvYWRlci9SZWRpcmVjdFNjaGVkdWxlci5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpSZWRpcmVjdFNjaGVkdWxlcjo6c2NoZWR1bGVIaXN0b3J5TmF2aWdhdGlvbik6Cisg ICAgICAgICogcGFnZS9IaXN0b3J5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okhpc3Rvcnk6OnN0 YXRlT2JqZWN0QWRkZWQpOgorICAgICAgICAqIHBhZ2UvUGFnZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpQYWdlOjpnb1RvSXRlbSk6CisKIDIwMTAtMDEtMjYgIEFsZXhhbmRlciBQYXZsb3YgIDxh cGF2bG92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBUaW1vdGh5IEhhdGNo ZXIuCkluZGV4OiBXZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCShyZXZpc2lvbiA1Mzg5NSkKKysrIFdlYkNvcmUvZG9tL0RvY3Vt ZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTU1MywxMiArMTU1Myw2IEBAIHZvaWQgRG9jdW1l bnQ6OmRldGFjaCgpCiAgICAgaWYgKHJlbmRlcikKICAgICAgICAgcmVuZGVyLT5kZXN0cm95KCk7 CiAgICAgCi0gICAgSGFzaFNldDxSZWZQdHI8SGlzdG9yeUl0ZW0+ID4gYXNzb2NpYXRlZEhpc3Rv cnlJdGVtczsKLSAgICBhc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLnN3YXAobV9hc3NvY2lhdGVkSGlz dG9yeUl0ZW1zKTsKLSAgICBIYXNoU2V0PFJlZlB0cjxIaXN0b3J5SXRlbT4gPjo6aXRlcmF0b3Ig ZW5kID0gYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5lbmQoKTsKLSAgICBmb3IgKEhhc2hTZXQ8UmVm UHRyPEhpc3RvcnlJdGVtPiA+OjppdGVyYXRvciBpID0gYXNzb2NpYXRlZEhpc3RvcnlJdGVtcy5i ZWdpbigpOyBpICE9IGVuZDsgKytpKQotICAgICAgICAoKmkpLT5kb2N1bWVudERldGFjaGVkKHRo aXMpOwotICAgIAogICAgIC8vIFRoaXMgaXMgcmVxdWlyZWQsIGFzIG91ciBGcmFtZSBtaWdodCBk ZWxldGUgaXRzZWxmIGFzIHNvb24gYXMgaXQgZGV0YWNoZXMKICAgICAvLyB1cy4gSG93ZXZlciwg dGhpcyB2aW9sYXRlcyBOb2RlOjpkZXRhY2goKSBzZW1hbnRpY3MsIGFzIGl0J3MgbmV2ZXIKICAg ICAvLyBwb3NzaWJsZSB0byByZS1hdHRhY2guIEV2ZW50dWFsbHkgRG9jdW1lbnQ6OmRldGFjaCgp IHNob3VsZCBiZSByZW5hbWVkLApAQCAtNDQ5OSwxOCArNDQ5Myw2IEBAIHZvaWQgRG9jdW1lbnQ6 OnN0YXRlUG9wcGVkKFNlcmlhbGl6ZWRTY3IKICAgICAgICAgbV9wZW5kaW5nU3RhdGVPYmplY3Qg PSBzdGF0ZU9iamVjdDsKIH0KIAotdm9pZCBEb2N1bWVudDo6cmVnaXN0ZXJIaXN0b3J5SXRlbShI aXN0b3J5SXRlbSogaXRlbSkKLXsKLSAgICBBU1NFUlQoIW1fYXNzb2NpYXRlZEhpc3RvcnlJdGVt cy5jb250YWlucyhpdGVtKSk7Ci0gICAgbV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLmFkZChpdGVt KTsKLX0KLQotdm9pZCBEb2N1bWVudDo6dW5yZWdpc3Rlckhpc3RvcnlJdGVtKEhpc3RvcnlJdGVt KiBpdGVtKQotewotICAgIEFTU0VSVChtX2Fzc29jaWF0ZWRIaXN0b3J5SXRlbXMuY29udGFpbnMo aXRlbSkgfHwgbV9hc3NvY2lhdGVkSGlzdG9yeUl0ZW1zLmlzRW1wdHkoKSk7Ci0gICAgbV9hc3Nv Y2lhdGVkSGlzdG9yeUl0ZW1zLnJlbW92ZShpdGVtKTsKLX0KLQogdm9pZCBEb2N1bWVudDo6dXBk YXRlU2FuZGJveEZsYWdzKCkKIHsKICAgICBpZiAobV9mcmFtZSAmJiBzZWN1cml0eU9yaWdpbigp KQpJbmRleDogV2ViQ29yZS9kb20vRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Rv bS9Eb2N1bWVudC5oCShyZXZpc2lvbiA1Mzg5NSkKKysrIFdlYkNvcmUvZG9tL0RvY3VtZW50LmgJ KHdvcmtpbmcgY29weSkKQEAgLTkwNyw4ICs5MDcsNiBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHVw ZGF0ZVVSTEZvclB1c2hPclJlcGxhY2VTdGF0ZShjb25zdCBLVVJMJik7CiAgICAgdm9pZCBzdGF0 ZVBvcHBlZChTZXJpYWxpemVkU2NyaXB0VmFsdWUqKTsKLSAgICB2b2lkIHJlZ2lzdGVySGlzdG9y eUl0ZW0oSGlzdG9yeUl0ZW0qIGl0ZW0pOwotICAgIHZvaWQgdW5yZWdpc3Rlckhpc3RvcnlJdGVt KEhpc3RvcnlJdGVtKiBpdGVtKTsKIAogICAgIHZvaWQgdXBkYXRlU2FuZGJveEZsYWdzKCk7IC8v IFNldCBzYW5kYm94IGZsYWdzIGFzIGRldGVybWluZWQgYnkgdGhlIGZyYW1lLgogCkluZGV4OiBX ZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcAkocmV2aXNpb24gNTM4OTUpCisrKyBXZWJDb3Jl L2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjM5LDIwICsy MzksMTUgQEAgSGlzdG9yeUl0ZW1WZWN0b3ImIEJhY2tGb3J3YXJkTGlzdDo6ZW50cgogdm9pZCBC YWNrRm9yd2FyZExpc3Q6OnB1c2hTdGF0ZUl0ZW0oUGFzc1JlZlB0cjxIaXN0b3J5SXRlbT4gbmV3 SXRlbSkKIHsKICAgICBBU1NFUlQobmV3SXRlbSk7Ci0gICAgQVNTRVJUKG5ld0l0ZW0tPmRvY3Vt ZW50KCkpOwogICAgIEFTU0VSVChuZXdJdGVtLT5zdGF0ZU9iamVjdCgpKTsKICAgICAKICAgICBS ZWZQdHI8SGlzdG9yeUl0ZW0+IGN1cnJlbnQgPSBjdXJyZW50SXRlbSgpOwogICAgIEFTU0VSVChj dXJyZW50KTsKIAotICAgIERvY3VtZW50KiBuZXdJdGVtRG9jdW1lbnQgPSBuZXdJdGVtLT5kb2N1 bWVudCgpOwotCiAgICAgYWRkSXRlbShuZXdJdGVtKTsKICAgICAKLSAgICBpZiAoIWN1cnJlbnQt PmRvY3VtZW50KCkpIHsKLSAgICAgICAgY3VycmVudC0+c2V0RG9jdW1lbnQobmV3SXRlbURvY3Vt ZW50KTsKKyAgICBpZiAoIWN1cnJlbnQtPnN0YXRlT2JqZWN0KCkpCiAgICAgICAgIGN1cnJlbnQt PnNldFN0YXRlT2JqZWN0KFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZTo6Y3JlYXRlKCkpOwotICAgIH0K IH0KIAogdm9pZCBCYWNrRm9yd2FyZExpc3Q6OmNsb3NlKCkKSW5kZXg6IFdlYkNvcmUvaGlzdG9y eS9CYWNrRm9yd2FyZExpc3RDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9oaXN0 b3J5L0JhY2tGb3J3YXJkTGlzdENocm9taXVtLmNwcAkocmV2aXNpb24gNTM4OTUpCisrKyBXZWJD b3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0Q2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xMjMsNyArMTIzLDEyIEBAIEhpc3RvcnlJdGVtKiBCYWNrRm9yd2FyZExpc3Q6Oml0ZW1BdElu ZGUKIAogdm9pZCBCYWNrRm9yd2FyZExpc3Q6OnB1c2hTdGF0ZUl0ZW0oUGFzc1JlZlB0cjxIaXN0 b3J5SXRlbT4gbmV3SXRlbSkKIHsKLSAgLy8gRklYTUU6IE5lZWQgdG8gaW1wbGVtZW50IHN0YXRl IHN1cHBvcnQgZm9yIGNocm9taXVtLgorICAgIFJlZlB0cjxIaXN0b3J5SXRlbT4gY3VycmVudCA9 IG1fY2xpZW50LT5jdXJyZW50SXRlbSgpOworCisgICAgYWRkSXRlbShuZXdJdGVtKTsKKworICAg IGlmICghY3VycmVudC0+c3RhdGVPYmplY3QoKSkKKyAgICAgICAgY3VycmVudC0+c2V0U3RhdGVP YmplY3QoU2VyaWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoKSk7CiB9CiAKIEhpc3RvcnlJdGVt VmVjdG9yJiBCYWNrRm9yd2FyZExpc3Q6OmVudHJpZXMoKQpJbmRleDogV2ViQ29yZS9oaXN0b3J5 L0hpc3RvcnlJdGVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2hpc3RvcnkvSGlzdG9yeUl0 ZW0uY3BwCShyZXZpc2lvbiA1Mzg5NSkKKysrIFdlYkNvcmUvaGlzdG9yeS9IaXN0b3J5SXRlbS5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTMzLDkgKzMzLDE4IEBACiAjaW5jbHVkZSAiUGFnZUNhY2hl LmgiCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KKyNp bmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitzdGF0 aWMgbG9uZyBsb25nIGdlbmVyYXRlRG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpCit7CisgICAgLy8g SW5pdGlhbGl6ZSB0byB0aGUgY3VycmVudCB0aW1lIHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9vZCBv ZiBnZW5lcmF0aW5nCisgICAgLy8gaWRlbnRpZmllcnMgdGhhdCBvdmVybGFwIHdpdGggdGhvc2Ug ZnJvbSBwYXN0L2Z1dHVyZSBicm93c2VyIHNlc3Npb25zLgorICAgIHN0YXRpYyBsb25nIGxvbmcg bmV4dCA9IHN0YXRpY19jYXN0PGxvbmcgbG9uZz4oY3VycmVudFRpbWUoKSAqIDEwMDAwMDAuMCk7 CisgICAgcmV0dXJuICsrbmV4dDsKK30KKwogc3RhdGljIHZvaWQgZGVmYXVsdE5vdGlmeUhpc3Rv cnlJdGVtQ2hhbmdlZChIaXN0b3J5SXRlbSopCiB7CiB9CkBAIC00OCw3ICs1Nyw3IEBAIEhpc3Rv cnlJdGVtOjpIaXN0b3J5SXRlbSgpCiAgICAgLCBtX2xhc3RWaXNpdFdhc0ZhaWx1cmUoZmFsc2Up CiAgICAgLCBtX2lzVGFyZ2V0SXRlbShmYWxzZSkKICAgICAsIG1fdmlzaXRDb3VudCgwKQotICAg ICwgbV9kb2N1bWVudCgwKQorICAgICwgbV9kb2N1bWVudFNlcXVlbmNlTnVtYmVyKGdlbmVyYXRl RG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpKQogewogfQogCkBAIC02MSw3ICs3MCw3IEBAIEhpc3Rv cnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBTdHJpbmcmIHUKICAgICAsIG1fbGFzdFZpc2l0V2Fz RmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNlKQogICAgICwgbV92aXNp dENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VO dW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7ICAgIAogICAgIGljb25E YXRhYmFzZSgpLT5yZXRhaW5JY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiB9CkBAIC03Niw3 ICs4NSw3IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBTdHJpbmcmIHUKICAgICAs IG1fbGFzdFZpc2l0V2FzRmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJnZXRJdGVtKGZhbHNl KQogICAgICwgbV92aXNpdENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2Rv Y3VtZW50U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiB7 CiAgICAgaWNvbkRhdGFiYXNlKCktPnJldGFpbkljb25Gb3JQYWdlVVJMKG1fdXJsU3RyaW5nKTsK IH0KQEAgLTkyLDcgKzEwMSw3IEBAIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBLVVJM JiB1cmwKICAgICAsIG1fbGFzdFZpc2l0V2FzRmFpbHVyZShmYWxzZSkKICAgICAsIG1faXNUYXJn ZXRJdGVtKGZhbHNlKQogICAgICwgbV92aXNpdENvdW50KDApCi0gICAgLCBtX2RvY3VtZW50KDAp CisgICAgLCBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNl TnVtYmVyKCkpCiB7ICAgIAogICAgIGljb25EYXRhYmFzZSgpLT5yZXRhaW5JY29uRm9yUGFnZVVS TChtX3VybFN0cmluZyk7CiB9CkBAIC0xMDAsNyArMTA5LDYgQEAgSGlzdG9yeUl0ZW06Okhpc3Rv cnlJdGVtKGNvbnN0IEtVUkwmIHVybAogSGlzdG9yeUl0ZW06On5IaXN0b3J5SXRlbSgpCiB7CiAg ICAgQVNTRVJUKCFtX2NhY2hlZFBhZ2UpOwotICAgIEFTU0VSVCghbV9kb2N1bWVudCk7CiAgICAg aWNvbkRhdGFiYXNlKCktPnJlbGVhc2VJY29uRm9yUGFnZVVSTChtX3VybFN0cmluZyk7CiAjaWYg UExBVEZPUk0oQU5EUk9JRCkKICAgICBpZiAobV9icmlkZ2UpCkBAIC0xMjUsNyArMTMzLDcgQEAg aW5saW5lIEhpc3RvcnlJdGVtOjpIaXN0b3J5SXRlbShjb25zdCBIaQogICAgICwgbV92aXNpdENv dW50KGl0ZW0ubV92aXNpdENvdW50KQogICAgICwgbV9kYWlseVZpc2l0Q291bnRzKGl0ZW0ubV9k YWlseVZpc2l0Q291bnRzKQogICAgICwgbV93ZWVrbHlWaXNpdENvdW50cyhpdGVtLm1fd2Vla2x5 VmlzaXRDb3VudHMpCi0gICAgLCBtX2RvY3VtZW50KDApCisgICAgLCBtX2RvY3VtZW50U2VxdWVu Y2VOdW1iZXIoZ2VuZXJhdGVEb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpCiAgICAgLCBtX2Zvcm1D b250ZW50VHlwZShpdGVtLm1fZm9ybUNvbnRlbnRUeXBlKQogewogICAgIGlmIChpdGVtLm1fZm9y bURhdGEpCkBAIC0zOTcsMjkgKzQwNSw5IEBAIHZvaWQgSGlzdG9yeUl0ZW06OnNldElzVGFyZ2V0 SXRlbShib29sIGYKIAogdm9pZCBIaXN0b3J5SXRlbTo6c2V0U3RhdGVPYmplY3QoUGFzc1JlZlB0 cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG9iamVjdCkKIHsKLSAgICBBU1NFUlQobV9kb2N1bWVu dCk7CiAgICAgbV9zdGF0ZU9iamVjdCA9IG9iamVjdDsKIH0KIAotdm9pZCBIaXN0b3J5SXRlbTo6 c2V0RG9jdW1lbnQoRG9jdW1lbnQqIGRvY3VtZW50KQotewotICAgIGlmIChtX2RvY3VtZW50ID09 IGRvY3VtZW50KQotICAgICAgICByZXR1cm47Ci0gICAgCi0gICAgaWYgKG1fZG9jdW1lbnQpCi0g ICAgICAgIG1fZG9jdW1lbnQtPnVucmVnaXN0ZXJIaXN0b3J5SXRlbSh0aGlzKTsKLSAgICBpZiAo ZG9jdW1lbnQpCi0gICAgICAgIGRvY3VtZW50LT5yZWdpc3Rlckhpc3RvcnlJdGVtKHRoaXMpOwot ICAgICAgICAKLSAgICBtX2RvY3VtZW50ID0gZG9jdW1lbnQ7Ci19Ci0KLXZvaWQgSGlzdG9yeUl0 ZW06OmRvY3VtZW50RGV0YWNoZWQoRG9jdW1lbnQqIGRvY3VtZW50KQotewotICAgIEFTU0VSVF9V TlVTRUQoZG9jdW1lbnQsIG1fZG9jdW1lbnQgPT0gZG9jdW1lbnQpOwotICAgIG1fZG9jdW1lbnQg PSAwOwotfQotCiB2b2lkIEhpc3RvcnlJdGVtOjphZGRDaGlsZEl0ZW0oUGFzc1JlZlB0cjxIaXN0 b3J5SXRlbT4gY2hpbGQpCiB7CiAgICAgQVNTRVJUKCFjaGlsZEl0ZW1XaXRoVGFyZ2V0KGNoaWxk LT50YXJnZXQoKSkpOwpJbmRleDogV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgJKHJldmlzaW9uIDUzODk1KQor KysgV2ViQ29yZS9oaXN0b3J5L0hpc3RvcnlJdGVtLmgJKHdvcmtpbmcgY29weSkKQEAgLTEzNSw5 ICsxMzUsOSBAQCBwdWJsaWM6IAogICAgIAogICAgIHZvaWQgc2V0U3RhdGVPYmplY3QoUGFzc1Jl ZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG9iamVjdCk7CiAgICAgU2VyaWFsaXplZFNjcmlw dFZhbHVlKiBzdGF0ZU9iamVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fc3RhdGVPYmplY3QuZ2V0KCk7 IH0KLSAgICB2b2lkIHNldERvY3VtZW50KERvY3VtZW50KiBkb2N1bWVudCk7Ci0gICAgRG9jdW1l bnQqIGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9kb2N1bWVudDsgfQotICAgIHZvaWQgZG9j dW1lbnREZXRhY2hlZChEb2N1bWVudCopOworCisgICAgdm9pZCBzZXREb2N1bWVudFNlcXVlbmNl TnVtYmVyKGxvbmcgbG9uZyBudW1iZXIpIHsgbV9kb2N1bWVudFNlcXVlbmNlTnVtYmVyID0gbnVt YmVyOyB9CisgICAgbG9uZyBsb25nIGRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSBjb25zdCB7IHJl dHVybiBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXI7IH0KICAgICAKICAgICB2b2lkIHNldEZvcm1J bmZvRnJvbVJlcXVlc3QoY29uc3QgUmVzb3VyY2VSZXF1ZXN0Jik7CiAgICAgdm9pZCBzZXRGb3Jt RGF0YShQYXNzUmVmUHRyPEZvcm1EYXRhPik7CkBAIC0yNDQsNyArMjQ0LDcgQEAgcHJpdmF0ZToK IAogICAgIC8vIFN1cHBvcnQgZm9yIEhUTUw1IEhpc3RvcnkKICAgICBSZWZQdHI8U2VyaWFsaXpl ZFNjcmlwdFZhbHVlPiBtX3N0YXRlT2JqZWN0OwotICAgIERvY3VtZW50KiBtX2RvY3VtZW50Owor ICAgIGxvbmcgbG9uZyBtX2RvY3VtZW50U2VxdWVuY2VOdW1iZXI7CiAgICAgCiAgICAgLy8gaW5m byB1c2VkIHRvIHJlcG9zdCBmb3JtIGRhdGEKICAgICBSZWZQdHI8Rm9ybURhdGE+IG1fZm9ybURh dGE7CkluZGV4OiBXZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCShyZXZpc2lvbiA1Mzg5NSkKKysrIFdlYkNv cmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzY5Myw3ICszNjkz LDcgQEAgRnJhbWUqIEZyYW1lTG9hZGVyOjpmaW5kRnJhbWVGb3JOYXZpZ2F0aQogCiB2b2lkIEZy YW1lTG9hZGVyOjpuYXZpZ2F0ZVdpdGhpbkRvY3VtZW50KEhpc3RvcnlJdGVtKiBpdGVtKQogewot ICAgIEFTU0VSVCghaXRlbS0+ZG9jdW1lbnQoKSB8fCBpdGVtLT5kb2N1bWVudCgpID09IG1fZnJh bWUtPmRvY3VtZW50KCkpOworICAgIEFTU0VSVChpdGVtLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVy KCkgPT0gaGlzdG9yeSgpLT5jdXJyZW50SXRlbSgpLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkp OwogCiAgICAgLy8gU2F2ZSB1c2VyIHZpZXcgc3RhdGUgdG8gdGhlIGN1cnJlbnQgaGlzdG9yeSBp dGVtIGhlcmUgc2luY2Ugd2UgZG9uJ3QgZG8gYSBub3JtYWwgbG9hZC4KICAgICAvLyBGSVhNRTog RG9lcyBmb3JtIHN0YXRlIG5lZWQgdG8gYmUgc2F2ZWQgaGVyZSB0b28/CkBAIC0zODE0LDcgKzM4 MTQsNyBAQCB2b2lkIEZyYW1lTG9hZGVyOjpsb2FkSXRlbShIaXN0b3J5SXRlbSogCiAgICAgLy8g LSBUaGUgSGlzdG9yeUl0ZW0gaGFzIGEgaGlzdG9yeSBzdGF0ZSBvYmplY3QKICAgICAvLyAtIE5h dmlnYXRpbmcgdG8gYW4gYW5jaG9yIHdpdGhpbiB0aGUgcGFnZSwgd2l0aCBubyBmb3JtIGRhdGEg c3RvcmVkIG9uIHRoZSB0YXJnZXQgaXRlbSBvciB0aGUgY3VycmVudCBoaXN0b3J5IGVudHJ5LAog ICAgIC8vICAgYW5kIHRoZSBVUkxzIGluIHRoZSBmcmFtZSB0cmVlIG1hdGNoIHRoZSBoaXN0b3J5 IGl0ZW0gZm9yIGZyYWdtZW50IHNjcm9sbGluZy4KLSAgICBib29sIHNhbWVEb2N1bWVudE5hdmln YXRpb24gPSAoIWl0ZW0tPmZvcm1EYXRhKCkgJiYgIShoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCkg JiYgaGlzdG9yeSgpLT5jdXJyZW50SXRlbSgpLT5mb3JtRGF0YSgpKSAmJiBoaXN0b3J5KCktPnVy bHNNYXRjaEl0ZW0oaXRlbSkpIHx8IGl0ZW0tPmRvY3VtZW50KCkgPT0gbV9mcmFtZS0+ZG9jdW1l bnQoKTsKKyAgICBib29sIHNhbWVEb2N1bWVudE5hdmlnYXRpb24gPSAoIWl0ZW0tPmZvcm1EYXRh KCkgJiYgIShoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCkgJiYgaGlzdG9yeSgpLT5jdXJyZW50SXRl bSgpLT5mb3JtRGF0YSgpKSAmJiBoaXN0b3J5KCktPnVybHNNYXRjaEl0ZW0oaXRlbSkpIHx8IGl0 ZW0tPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSA9PSBoaXN0b3J5KCktPmN1cnJlbnRJdGVtKCkt PmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKTsKIAogI2lmIEVOQUJMRShXTUwpCiAgICAgLy8gQWxs IFdNTCBkZWNrcyBzaG91bGQgZ28gdGhyb3VnaCB0aGUgcmVhbCBsb2FkIG1lY2hhbmlzbSwgbm90 IHRoZSBzY3JvbGwtdG8tYW5jaG9yIGNvZGUKSW5kZXg6IFdlYkNvcmUvbG9hZGVyL0hpc3RvcnlD b250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJv bGxlci5jcHAJKHJldmlzaW9uIDUzODk1KQorKysgV2ViQ29yZS9sb2FkZXIvSGlzdG9yeUNvbnRy b2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDYsNiArMTA2LDEwIEBAIHZvaWQgSGlzdG9y eUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3MKIHZvaWQgSGlzdG9yeUNvbnRyb2xsZXI6OnVw ZGF0ZUJhY2tGb3J3YXJkTGlzdEZvckZyYWdtZW50U2Nyb2xsKCkKIHsKICAgICB1cGRhdGVCYWNr Rm9yd2FyZExpc3RDbGlwcGVkQXRUYXJnZXQoZmFsc2UpOworICAgIAorICAgIC8vIFNpbmNlIHRo ZSBkb2N1bWVudCBpc24ndCBjaGFuZ2VkIGFzIGEgcmVzdWx0IG9mIGEgZnJhZ21lbnQgc2Nyb2xs LCB3ZSBzaG91bGQKKyAgICAvLyBwcmVzZXJ2ZSB0aGUgRG9jdW1lbnRTZXF1ZW5jZU51bWJlciBv ZiB0aGUgcHJldmlvdXMgaXRlbS4KKyAgICBtX2N1cnJlbnRJdGVtLT5zZXREb2N1bWVudFNlcXVl bmNlTnVtYmVyKG1fcHJldmlvdXNJdGVtLT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpOwogfQog CiB2b2lkIEhpc3RvcnlDb250cm9sbGVyOjpzYXZlRG9jdW1lbnRTdGF0ZSgpCkBAIC02MzUsMTAg KzYzOSwxMyBAQCB2b2lkIEhpc3RvcnlDb250cm9sbGVyOjpwdXNoU3RhdGUoUGFzc1JlCiAgICAg QVNTRVJUKGl0ZW0tPmlzVGFyZ2V0SXRlbSgpKTsKICAgICAKICAgICAvLyBPdmVycmlkZSBkYXRh IGluIHRoZSB0YXJnZXQgaXRlbSB0byByZWZsZWN0IHRoZSBwdXNoU3RhdGUoKSBhcmd1bWVudHMu Ci0gICAgaXRlbS0+c2V0RG9jdW1lbnQobV9mcmFtZS0+ZG9jdW1lbnQoKSk7CiAgICAgaXRlbS0+ c2V0VGl0bGUodGl0bGUpOwogICAgIGl0ZW0tPnNldFN0YXRlT2JqZWN0KHN0YXRlT2JqZWN0KTsK ICAgICBpdGVtLT5zZXRVUkxTdHJpbmcodXJsU3RyaW5nKTsKKworICAgIC8vIFNpbmNlIHRoZSBk b2N1bWVudCBpc24ndCBjaGFuZ2VkIGFzIGEgcmVzdWx0IG9mIGEgcHVzaFN0YXRlIGNhbGwsIHdl CisgICAgLy8gc2hvdWxkIHByZXNlcnZlIHRoZSBEb2N1bWVudFNlcXVlbmNlTnVtYmVyIG9mIHRo ZSBwcmV2aW91cyBpdGVtLgorICAgIGl0ZW0tPnNldERvY3VtZW50U2VxdWVuY2VOdW1iZXIobV9w cmV2aW91c0l0ZW0tPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSk7CiAgICAgCiAgICAgcGFnZS0+ YmFja0ZvcndhcmRMaXN0KCktPnB1c2hTdGF0ZUl0ZW0oaXRlbS5yZWxlYXNlKCkpOwogfQpAQCAt NjQ5LDEwICs2NTYsNyBAQCB2b2lkIEhpc3RvcnlDb250cm9sbGVyOjpyZXBsYWNlU3RhdGUoUGFz CiAgICAgQVNTRVJUKHBhZ2UpOwogICAgIEhpc3RvcnlJdGVtKiBjdXJyZW50ID0gcGFnZS0+YmFj a0ZvcndhcmRMaXN0KCktPmN1cnJlbnRJdGVtKCk7CiAgICAgQVNTRVJUKGN1cnJlbnQpOwotICAg IAotICAgIEFTU0VSVCghY3VycmVudC0+ZG9jdW1lbnQoKSB8fCBjdXJyZW50LT5kb2N1bWVudCgp ID09IG1fZnJhbWUtPmRvY3VtZW50KCkpOwotICAgIGN1cnJlbnQtPnNldERvY3VtZW50KG1fZnJh bWUtPmRvY3VtZW50KCkpOwotICAgIAorCiAgICAgaWYgKCF1cmxTdHJpbmcuaXNFbXB0eSgpKQog ICAgICAgICBjdXJyZW50LT5zZXRVUkxTdHJpbmcodXJsU3RyaW5nKTsKICAgICBjdXJyZW50LT5z ZXRUaXRsZSh0aXRsZSk7CkluZGV4OiBXZWJDb3JlL2xvYWRlci9SZWRpcmVjdFNjaGVkdWxlci5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9sb2FkZXIvUmVkaXJlY3RTY2hlZHVsZXIuY3BwCShy ZXZpc2lvbiA1Mzg5NSkKKysrIFdlYkNvcmUvbG9hZGVyL1JlZGlyZWN0U2NoZWR1bGVyLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMjc3LDcgKzI3Nyw3IEBAIHZvaWQgUmVkaXJlY3RTY2hlZHVsZXI6 OnNjaGVkdWxlSGlzdG9yeU4KICAgICAvLyBJZiB0aGUgc3BlY2lmaWVkIGVudHJ5IGFuZCB0aGUg Y3VycmVudCBlbnRyeSBoYXZlIHRoZSBzYW1lIGRvY3VtZW50LCB0aGlzIGlzIGVpdGhlciBhIHN0 YXRlIG9iamVjdCB0cmF2ZXJzYWwgb3IgYSBmcmFnbWVudCAKICAgICAvLyB0cmF2ZXJzYWwgKG9y IGJvdGgpIGFuZCBzaG91bGQgYmUgcGVyZm9ybWVkIHN5bmNocm9ub3VzbHkuCiAgICAgSGlzdG9y eUl0ZW0qIGN1cnJlbnRFbnRyeSA9IG1fZnJhbWUtPmxvYWRlcigpLT5oaXN0b3J5KCktPmN1cnJl bnRJdGVtKCk7Ci0gICAgaWYgKGN1cnJlbnRFbnRyeSAhPSBzcGVjaWZpZWRFbnRyeSAmJiBzcGVj aWZpZWRFbnRyeS0+ZG9jdW1lbnQoKSAmJiBjdXJyZW50RW50cnktPmRvY3VtZW50KCkgPT0gc3Bl Y2lmaWVkRW50cnktPmRvY3VtZW50KCkpIHsKKyAgICBpZiAoY3VycmVudEVudHJ5ICE9IHNwZWNp ZmllZEVudHJ5ICYmIGN1cnJlbnRFbnRyeS0+ZG9jdW1lbnRTZXF1ZW5jZU51bWJlcigpID09IHNw ZWNpZmllZEVudHJ5LT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkpIHsKICAgICAgICAgbV9mcmFt ZS0+bG9hZGVyKCktPmhpc3RvcnkoKS0+Z29Ub0l0ZW0oc3BlY2lmaWVkRW50cnksIEZyYW1lTG9h ZFR5cGVJbmRleGVkQmFja0ZvcndhcmQpOwogICAgICAgICByZXR1cm47CiAgICAgfQpJbmRleDog V2ViQ29yZS9wYWdlL0hpc3RvcnkuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9IaXN0 b3J5LmNwcAkocmV2aXNpb24gNTM4OTUpCisrKyBXZWJDb3JlL3BhZ2UvSGlzdG9yeS5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTExMiwxMyArMTEyLDEzIEBAIHZvaWQgSGlzdG9yeTo6c3RhdGVPYmpl Y3RBZGRlZChQYXNzUmVmUHQKICAgICBlbHNlIGlmIChzdGF0ZU9iamVjdFR5cGUgPT0gU3RhdGVP YmplY3RSZXBsYWNlKQogICAgICAgICBtX2ZyYW1lLT5sb2FkZXIoKS0+aGlzdG9yeSgpLT5yZXBs YWNlU3RhdGUoZGF0YSwgdGl0bGUsIGZ1bGxVUkwuc3RyaW5nKCkpOwogICAgICAgICAgICAgCi0g ICAgaWYgKCF1cmxTdHJpbmcuaXNFbXB0eSgpKSB7CisgICAgaWYgKCF1cmxTdHJpbmcuaXNFbXB0 eSgpKQogICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVVUkxGb3JQdXNoT3JSZXBs YWNlU3RhdGUoZnVsbFVSTCk7Ci0gICAgICAgIGlmIChzdGF0ZU9iamVjdFR5cGUgPT0gU3RhdGVP YmplY3RQdXNoKQotICAgICAgICAgICAgbV9mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5kaXNw YXRjaERpZFB1c2hTdGF0ZVdpdGhpblBhZ2UoKTsKLSAgICAgICAgZWxzZSBpZiAoc3RhdGVPYmpl Y3RUeXBlID09IFN0YXRlT2JqZWN0UmVwbGFjZSkKLSAgICAgICAgICAgIG1fZnJhbWUtPmxvYWRl cigpLT5jbGllbnQoKS0+ZGlzcGF0Y2hEaWRSZXBsYWNlU3RhdGVXaXRoaW5QYWdlKCk7Ci0gICAg fQorCisgICAgaWYgKHN0YXRlT2JqZWN0VHlwZSA9PSBTdGF0ZU9iamVjdFB1c2gpCisgICAgICAg IG1fZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+ZGlzcGF0Y2hEaWRQdXNoU3RhdGVXaXRoaW5Q YWdlKCk7CisgICAgZWxzZSBpZiAoc3RhdGVPYmplY3RUeXBlID09IFN0YXRlT2JqZWN0UmVwbGFj ZSkKKyAgICAgICAgbV9mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5kaXNwYXRjaERpZFJlcGxh Y2VTdGF0ZVdpdGhpblBhZ2UoKTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDog V2ViQ29yZS9wYWdlL1BhZ2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9QYWdlLmNw cAkocmV2aXNpb24gNTM4OTUpCisrKyBXZWJDb3JlL3BhZ2UvUGFnZS5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTI5MCw3ICsyOTAsNyBAQCB2b2lkIFBhZ2U6OmdvQmFja09yRm9yd2FyZChpbnQgZGlz dGFuY2UpCiB2b2lkIFBhZ2U6OmdvVG9JdGVtKEhpc3RvcnlJdGVtKiBpdGVtLCBGcmFtZUxvYWRU eXBlIHR5cGUpCiB7CiAgICAgLy8gQWJvcnQgYW55IGN1cnJlbnQgbG9hZCB1bmxlc3Mgd2UncmUg bmF2aWdhdGluZyB0aGUgY3VycmVudCBkb2N1bWVudCB0byBhIG5ldyBzdGF0ZSBvYmplY3QKLSAg ICBpZiAoIWl0ZW0tPnN0YXRlT2JqZWN0KCkgfHwgaXRlbS0+ZG9jdW1lbnQoKSAhPSBtX21haW5G cmFtZS0+ZG9jdW1lbnQoKSkgeworICAgIGlmICghaXRlbS0+c3RhdGVPYmplY3QoKSB8fCBpdGVt LT5kb2N1bWVudFNlcXVlbmNlTnVtYmVyKCkgIT0gbV9tYWluRnJhbWUtPmxvYWRlcigpLT5oaXN0 b3J5KCktPmN1cnJlbnRJdGVtKCktPmRvY3VtZW50U2VxdWVuY2VOdW1iZXIoKSkgewogICAgICAg ICAvLyBEZWZpbmUgd2hhdCB0byBkbyB3aXRoIGFueSBvcGVuIGRhdGFiYXNlIGNvbm5lY3Rpb25z LiBCeSBkZWZhdWx0IHdlIHN0b3AgdGhlbSBhbmQgdGVybWluYXRlIHRoZSBkYXRhYmFzZSB0aHJl YWQuCiAgICAgICAgIERhdGFiYXNlUG9saWN5IGRhdGFiYXNlUG9saWN5ID0gRGF0YWJhc2VQb2xp Y3lTdG9wOwogCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg5NikKKysrIExheW91dFRlc3RzL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDI1IEBACisyMDEwLTAxLTI2ICBEYXJpbiBG aXNoZXIgIDxkYXJpbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQ2hhaW5zIG9mIGhpc3RvcnkgaXRlbXMgcmVwcmVzZW50aW5n IHNhbWUtZG9jdW1lbnQgbmF2aWdhdGlvbiBuZWVkIHRvCisgICAgICAgIGFsd2F5cyByZW1lbWJl ciB0aGF0IGFzc29jaWF0aW9uCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTMzMjI0CisKKyAgICAgICAgKiBmYXN0L2RvbS9sb2NhdGlvbi1oYXNoLWV4 cGVjdGVkLnR4dDoKKyAgICAgICAgKiBmYXN0L2RvbS9sb2NhdGlvbi1oYXNoLmh0bWw6IFJldmVy dCBjaGFuZ2VzIGZyb20gcjQzMjc0IHNpbmNlCisgICAgICAgIGhpc3RvcnkuYmFjayB0byBhIHJl ZmVyZW5jZSBmcmFnbWVudCBpcyBub3cgc3luY2hyb25vdXMuCisKKyAgICAgICAgKiBmYXN0L2hp c3RvcnkvYmFjay1mb3J3YXJkLWlzLWFzeW5jaHJvbm91cy1leHBlY3RlZC50eHQ6IFJlbW92ZWQu CisgICAgICAgICogZmFzdC9oaXN0b3J5L2JhY2stZm9yd2FyZC1pcy1hc3luY2hyb25vdXMuaHRt bDogUmVtb3ZlZC4KKyAgICAgICAgVGhpcyB0ZXN0IGlzIG5vIGxvbmdlciB2YWxpZCAocmV2ZXJ0 IHI0MzI3NCkuCisKKyAgICAgICAgKiBmYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9jdW1lbnQt ZGVzdHJveWVkLW5hdmlnYXRlLWJhY2stZXhwZWN0ZWQudHh0OgorICAgICAgICAqIGZhc3QvbG9h ZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5odG1sOiBS ZXZpc2VkCisgICAgICAgIHRlc3QgcmVzdWx0cyB0byBtYXRjaCBjb3JyZWN0ZWQgYmVoYXZpb3Iu ICBBbHNvIHJlbW92ZWQgdGhlIHJlZHVuZGFudAorICAgICAgICBoaXN0b3J5LmJhY2soKSBjYWxs LCB3aGljaCBoZWxwcyBtYWtlIHRoZSB0ZXN0IGEgYml0IGVhc2llciB0byB1bmRlcnN0YW5kLgor CiAyMDEwLTAxLTI2ICBEaWVnbyBHb256YWxleiAgPGRpZWdvLmdvbnphbGV6QG9wZW5ib3NzYS5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4uCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9sb2NhdGlvbi1oYXNoLWV4cGVjdGVkLnR4dAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9sb2NhdGlvbi1oYXNoLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gNTM4OTUpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2RvbS9sb2NhdGlvbi1oYXNo LWV4cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMTEsMTYgKzExLDEwIEBAIFBBU1M6IHdp bmRvdy5oaXN0b3J5Lmxlbmd0aCA9PSBvcmlnaW5hbEgKIFBBU1M6IHdpbmRvdy5sb2NhdGlvbi5o YXNoIHNob3VsZCBiZSAjYmFyIGFuZCBpcy4KIFBBU1M6IHdpbmRvdy5sb2NhdGlvbiA9PSBvcmln aW5hbExvY2F0aW9uICsgJyNiYXInIHNob3VsZCBiZSB0cnVlIGFuZCBpcy4KIFBBU1M6IHdpbmRv dy5oaXN0b3J5Lmxlbmd0aCA9PSBvcmlnaW5hbEhpc3RvcnlMZW5ndGggKyAyIHNob3VsZCBiZSB0 cnVlIGFuZCBpcy4KLVBBU1M6IHdpbmRvdy5sb2NhdGlvbi5oYXNoIHNob3VsZCBiZSAjYmFyIGFu ZCBpcy4KLVBBU1M6IHdpbmRvdy5sb2NhdGlvbiA9PSBvcmlnaW5hbExvY2F0aW9uICsgJyNiYXIn IHNob3VsZCBiZSB0cnVlIGFuZCBpcy4KLVBBU1M6IHdpbmRvdy5sb2NhdGlvbi5oYXNoIHNob3Vs ZCBiZSAjZm9vIGFuZCBpcy4KLVBBU1M6IHdpbmRvdy5sb2NhdGlvbiA9PSBvcmlnaW5hbExvY2F0 aW9uICsgJyNmb28nIHNob3VsZCBiZSB0cnVlIGFuZCBpcy4KIFBBU1M6IHdpbmRvdy5sb2NhdGlv bi5oYXNoIHNob3VsZCBiZSAjZm9vIGFuZCBpcy4KIFBBU1M6IHdpbmRvdy5sb2NhdGlvbiA9PSBv cmlnaW5hbExvY2F0aW9uICsgJyNmb28nIHNob3VsZCBiZSB0cnVlIGFuZCBpcy4KIFBBU1M6IHdp bmRvdy5sb2NhdGlvbi5oYXNoIHNob3VsZCBiZSBhbmQgaXMuCiBQQVNTOiB3aW5kb3cubG9jYXRp b24gPT0gb3JpZ2luYWxMb2NhdGlvbiBzaG91bGQgYmUgdHJ1ZSBhbmQgaXMuCi1QQVNTOiB3aW5k b3cubG9jYXRpb24uaGFzaCBzaG91bGQgYmUgYW5kIGlzLgotUEFTUzogd2luZG93LmxvY2F0aW9u ID09IG9yaWdpbmFsTG9jYXRpb24gc2hvdWxkIGJlIHRydWUgYW5kIGlzLgogUEFTUzogd2luZG93 LmxvY2F0aW9uLmhhc2ggc2hvdWxkIGJlICNmb28gYW5kIGlzLgogUEFTUzogd2luZG93LmxvY2F0 aW9uID09IG9yaWdpbmFsTG9jYXRpb24gKyAnI2Zvbycgc2hvdWxkIGJlIHRydWUgYW5kIGlzLgog U1VDQ0VTUyEKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZG9tL2xvY2F0aW9uLWhhc2guaHRtbAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9sb2NhdGlvbi1oYXNoLmh0bWwJKHJl dmlzaW9uIDUzODk1KQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vbG9jYXRpb24taGFzaC5odG1s CSh3b3JraW5nIGNvcHkpCkBAIC0yNCw3ICsyNCw3IEBACiAgICAgCiAgICAgZnVuY3Rpb24gc3Rl cCgpIHsKICAgICAgICAgc3dpdGNoIChzdGF0ZSkgewotICAgICAgICBjYXNlIDA6CisgICAgICAg ICAgICBjYXNlIDA6CiAgICAgICAgICAgICBzaG91bGRCZSgnd2luZG93Lmhpc3RvcnkubGVuZ3Ro ID09IG9yaWdpbmFsSGlzdG9yeUxlbmd0aCcsIHRydWUpOwogICAgICAgICAgICAgc2hvdWxkQmUo J3dpbmRvdy5sb2NhdGlvbi5oYXNoJywgJycpOwogICAgICAgICAgICAgd2luZG93LmxvY2F0aW9u Lmhhc2ggPSAnZm9vJzsKQEAgLTQ1LDMzICs0NSwyMSBAQAogICAgICAgICAgICAgc2hvdWxkQmUo J3dpbmRvdy5oaXN0b3J5Lmxlbmd0aCA9PSBvcmlnaW5hbEhpc3RvcnlMZW5ndGggKyAyJywgdHJ1 ZSk7CiAgICAgICAgICAgICBicmVhazsgICAgICAgIAogICAgICAgICBjYXNlIDM6Ci0gICAgICAg ICAgICB3aW5kb3cuaGlzdG9yeS5iYWNrKCk7IC8vIFRoaXMgc2hvdWxkIHRha2UgZWZmZWN0IGFz eW5jaHJvbm91c2x5Ci0gICAgICAgICAgICBzaG91bGRCZSgnd2luZG93LmxvY2F0aW9uLmhhc2gn LCAnI2JhcicpOwotICAgICAgICAgICAgc2hvdWxkQmUoIndpbmRvdy5sb2NhdGlvbiA9PSBvcmln aW5hbExvY2F0aW9uICsgJyNiYXInIiwgdHJ1ZSk7Ci0gICAgICAgICAgICBicmVhazsKLSAgICAg ICAgY2FzZSA0OgotICAgICAgICAgICAgc2hvdWxkQmUoJ3dpbmRvdy5sb2NhdGlvbi5oYXNoJywg JyNmb28nKTsKLSAgICAgICAgICAgIHNob3VsZEJlKCJ3aW5kb3cubG9jYXRpb24gPT0gb3JpZ2lu YWxMb2NhdGlvbiArICcjZm9vJyIsIHRydWUpOwotICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAg IGNhc2UgNToKLSAgICAgICAgICAgIHdpbmRvdy5oaXN0b3J5LmJhY2soKTsgLy8gVGhpcyBzaG91 bGQgdGFrZSBlZmZlY3QgYXN5bmNocm9ub3VzbHkKKyAgICAgICAgICAgIHdpbmRvdy5oaXN0b3J5 LmJhY2soKTsKICAgICAgICAgICAgIHNob3VsZEJlKCd3aW5kb3cubG9jYXRpb24uaGFzaCcsICcj Zm9vJyk7CiAgICAgICAgICAgICBzaG91bGRCZSgid2luZG93LmxvY2F0aW9uID09IG9yaWdpbmFs TG9jYXRpb24gKyAnI2ZvbyciLCB0cnVlKTsKICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICBj YXNlIDY6Ci0gICAgICAgICAgICBzaG91bGRCZSgnd2luZG93LmxvY2F0aW9uLmhhc2gnLCAnJyk7 Ci0gICAgICAgICAgICBzaG91bGRCZSgid2luZG93LmxvY2F0aW9uID09IG9yaWdpbmFsTG9jYXRp b24iLCB0cnVlKTsKLSAgICAgICAgICAgIGJyZWFrOwotICAgICAgICBjYXNlIDc6Ci0gICAgICAg ICAgICB3aW5kb3cuaGlzdG9yeS5mb3J3YXJkKCk7IC8vIFRoaXMgc2hvdWxkIHRha2UgZWZmZWN0 IGFzeW5jaHJvbm91c2x5CisgICAgICAgIGNhc2UgNDoKKyAgICAgICAgICAgIHdpbmRvdy5oaXN0 b3J5LmJhY2soKTsKICAgICAgICAgICAgIHNob3VsZEJlKCd3aW5kb3cubG9jYXRpb24uaGFzaCcs ICcnKTsKICAgICAgICAgICAgIHNob3VsZEJlKCJ3aW5kb3cubG9jYXRpb24gPT0gb3JpZ2luYWxM b2NhdGlvbiIsIHRydWUpOwogICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIGNhc2UgODoKKyAg ICAgICAgY2FzZSA1OgorICAgICAgICAgICAgd2luZG93Lmhpc3RvcnkuZm9yd2FyZCgpOwogICAg ICAgICAgICAgc2hvdWxkQmUoJ3dpbmRvdy5sb2NhdGlvbi5oYXNoJywgJyNmb28nKTsKICAgICAg ICAgICAgIHNob3VsZEJlKCJ3aW5kb3cubG9jYXRpb24gPT0gb3JpZ2luYWxMb2NhdGlvbiArICcj Zm9vJyIsIHRydWUpOwogICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIGNhc2UgOToKKyAgICAg ICAgY2FzZSA2OgogICAgICAgICAgICAgd2luZG93LmxvY2F0aW9uLmhhc2ggPSAnJzsKICAgICAg ICAgICAgIGlmIChudW1FcnJvcnMgPT0gMCkKICAgICAgICAgICAgICAgICBwcmludCgiU1VDQ0VT UyEiLCAiZ3JlZW4iKQpAQCAtODUsNyArNzMsNyBAQAogICAgICAgICB9CiAgICAgICAgIAogICAg ICAgICBzdGF0ZSArKzsKLSAgICAgICAgc2V0VGltZW91dChzdGVwLCAwKTsKKyAgICAgICAgc3Rl cCgpOwogICAgIH0KICAgICAgICAgCiAgICAgZnVuY3Rpb24gcnVuVGVzdHMoKSB7CkluZGV4OiBM YXlvdXRUZXN0cy9mYXN0L2hpc3RvcnkvYmFjay1mb3J3YXJkLWlzLWFzeW5jaHJvbm91cy1leHBl Y3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9oaXN0b3J5L2JhY2stZm9y d2FyZC1pcy1hc3luY2hyb25vdXMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA1Mzg5NSkKKysrIExh eW91dFRlc3RzL2Zhc3QvaGlzdG9yeS9iYWNrLWZvcndhcmQtaXMtYXN5bmNocm9ub3VzLWV4cGVj dGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMSArMCwwIEBACi1QQVNTCkluZGV4OiBMYXlvdXRU ZXN0cy9mYXN0L2hpc3RvcnkvYmFjay1mb3J3YXJkLWlzLWFzeW5jaHJvbm91cy5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGlzdG9yeS9iYWNrLWZvcndhcmQtaXMtYXN5bmNo cm9ub3VzLmh0bWwJKHJldmlzaW9uIDUzODk1KQorKysgTGF5b3V0VGVzdHMvZmFzdC9oaXN0b3J5 L2JhY2stZm9yd2FyZC1pcy1hc3luY2hyb25vdXMuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMSw0 MCArMCwwIEBACi08aHRtbD4KLTxoZWFkPgotPHNjcmlwdD4KLXZhciBzY3JvbGxDb3VudGVyID0g MDsKLQotZnVuY3Rpb24gcnVuVGVzdCgpCi17Ci0gICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgewotICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Ci0g ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKLSAgICB9Ci0KLSAg ICAvLyBUaGlzIHRha2VzIGVmZmVjdCBzeW5jaHJvbm91c2x5LCBhbmQgdGhlIHJlc3VsdCBpcyB0 aGF0IHdlIHNjcm9sbCB0byAiZm9vIi4KLSAgICBsb2NhdGlvbi5oYXNoID0gIiNmb28iOwotCi0g ICAgLy8gVGhpcyBzaG91bGQgdGFrZSBlZmZlY3QgYXN5bmNocm9ub3VzbHksIGFuZCB0aGUgcmVz dWx0IHNob3VsZCBiZSB0aGF0IHdlCi0gICAgLy8gc2Nyb2xsIGJhY2sgdG8gdGhlIHRvcCBvZiB0 aGUgcGFnZS4gIElmIHRoaXMgaGFwcGVucyBzeW5jaHJvbm91c2x5LCB0aGVuCi0gICAgLy8gc2Ny b2xsQ291bnRlciB3aWxsIGJlIGluY3JlbWVudGVkIGFnYWluIGJ5IHRoZSB0aW1lIGhpc3Rvcnku YmFjayByZXR1cm5zLgotICAgIGhpc3RvcnkuYmFjaygpOwotCi0gICAgdmFyIGRpZFNjcm9sbEFn YWluID0gc2Nyb2xsQ291bnRlciAhPSAxOwotICAKLSAgICBkb2N1bWVudC5ib2R5LnJlcGxhY2VD aGlsZCgKLSAgICAgICAgZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUoZGlkU2Nyb2xsQWdhaW4gPyAi RkFJTCIgOiAiUEFTUyIpLAotICAgICAgICBkb2N1bWVudC5ib2R5LmdldEVsZW1lbnRzQnlUYWdO YW1lKCJESVYiKVswXSkKLQotICAgIC8vIERlZmVyIGNhbGxpbmcgbm90aWZ5RG9uZSB1bnRpbCB0 aGUgaGlzdG9yeS5iYWNrKCkgY2FsbCBjb21wbGV0ZXMuICBUaGlzCi0gICAgLy8gc2hvdWxkIG5v dCBiZSBuZWNlc3NhcnksIGJ1dCB0aGUgdGVzdCBmcmFtZXdvcmsgbWlnaHQgZ2V0IGNvbmZ1c2Vk IGlmIGl0Ci0gICAgLy8gbmF2aWdhdGVzIHRvIHRoZSBuZXh0IHRlc3QgYmVmb3JlIHRoZSBoaXN0 b3J5LmJhY2soKSBjYWxsIGNvbXBsZXRlcy4KLSAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKQotICAgICAgICBzZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeyBsYXlvdXRUZXN0Q29udHJv bGxlci5ub3RpZnlEb25lKCkgfSwgMCk7Ci19Ci08L3NjcmlwdD4KLTwvaGVhZD4KLTxib2R5IG9u bG9hZD0icnVuVGVzdCgpIiBvbnNjcm9sbD0ic2Nyb2xsQ291bnRlcisrIj4KLSAgICA8ZGl2IHN0 eWxlPSJwYWRkaW5nLXRvcDogMTAwMDBweCI+Ci0gICAgICAgIDxhIG5hbWU9ImZvbyI+Zm9vPC9h PgotICAgIDwvZGl2PgotPC9ib2R5PgotPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9s b2FkZXIvc3RhdGVvYmplY3RzL2RvY3VtZW50LWRlc3Ryb3llZC1uYXZpZ2F0ZS1iYWNrLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVj dHMvZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2stZXhwZWN0ZWQudHh0CShyZXZpc2lv biA1Mzg5NSkKKysrIExheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3N0YXRlb2JqZWN0cy9kb2N1bWVu dC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay1leHBlY3RlZC50eHQJKHdvcmtpbmcgY29weSkKQEAg LTUsOCArNSw2IEBAIEFMRVJUOiBOYXZpZ2F0aW5nIGJhY2suLi4KIG1haW4gZnJhbWUgLSBoYXMg MSBvbnVubG9hZCBoYW5kbGVyKHMpCiBBTEVSVDogTGFzdCBwYXRoIGNvbXBvbmVudCBvZiBsb2Nh dGlvbiBpcyBkb2N1bWVudC1kZXN0cm95ZWQtbmF2aWdhdGUtYmFjay5odG1sP1NlY29uZEVudHJ5 V2lsbExhdGVyQmVSZWFjdGl2YXRlZAogQUxFUlQ6IFN0YXRlIHBvcHBlZCAtIFNlY29uZEVudHJ5 V2lsbExhdGVyQmVSZWFjdGl2YXRlZCAodHlwZSBzdHJpbmcpCi1tYWluIGZyYW1lIC0gaGFzIDEg b251bmxvYWQgaGFuZGxlcihzKQotQUxFUlQ6IExhc3QgcGF0aCBjb21wb25lbnQgb2YgbG9jYXRp b24gaXMgZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbD9GaXJzdEVudHJ5V2ls bExhdGVyQmVSZWFjdGl2YXRlZAogQUxFUlQ6IFN0YXRlIHBvcHBlZCAtIEZpcnN0RW50cnlXaWxs TGF0ZXJCZVJlYWN0aXZhdGVkICh0eXBlIHN0cmluZykKIEFMRVJUOiBUZXN0IGNvbXBsZXRlCiBU aGlzIHRlc3Q6CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9j dW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRU ZXN0cy9mYXN0L2xvYWRlci9zdGF0ZW9iamVjdHMvZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRl LWJhY2suaHRtbAkocmV2aXNpb24gNTM4OTUpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2xvYWRlci9z dGF0ZW9iamVjdHMvZG9jdW1lbnQtZGVzdHJveWVkLW5hdmlnYXRlLWJhY2suaHRtbAkod29ya2lu ZyBjb3B5KQpAQCAtMjQsNyArMjQsNiBAQCBmdW5jdGlvbiBydW5GaXJzdFN0YWdlT2ZUZXN0KCkK IGZ1bmN0aW9uIHJ1blNlY29uZFN0YWdlT2ZUZXN0KCkKIHsKICAgICBhbGVydCgiTGFzdCBwYXRo IGNvbXBvbmVudCBvZiBsb2NhdGlvbiBpcyAiICsgbGFzdFBhdGhDb21wb25lbnQoKSk7Ci0gICAg aGlzdG9yeS5iYWNrKCk7CiB9CiAKIGZ1bmN0aW9uIHJ1blRoaXJkU3RhZ2VPZlRlc3QoKQo=