51049 2010-12-14 11:55:15 -0800 IME support in WebKit2 on Windows 2011-06-18 12:14:39 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) PC Windows 7 RESOLVED FIXED InRadar P2 Normal --- 1 enrica enrica aroben darin oldest_to_newest 322088 0 enrica 2010-12-14 11:55:15 -0800 Adding IME support to WebKit2 on Windows. 322096 1 76553 enrica 2010-12-14 12:05:19 -0800 Created attachment 76553 Patch 322126 2 76553 aroben 2010-12-14 12:44:10 -0800 Comment on attachment 76553 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=76553&action=review > WebKit2/ChangeLog:59 > + * UIProcess/API/qt/qwkpage.cpp: > + (QWKPagePrivate::compositionSelectionChanged): Added empty stub. > + * UIProcess/API/qt/qwkpage_p.h: > + * UIProcess/PageClient.h: Added compositionSelectionChanged. > + * UIProcess/WebPageProxy.cpp: > + Added new messages to support IME on Windows. > + (WebKit::WebPageProxy::firstRectForCharacterRange): > + (WebKit::WebPageProxy::getSelectedText): > + (WebKit::WebPageProxy::didCompositionSelectionChange): > + (WebKit::WebPageProxy::confirmComposition): > + (WebKit::WebPageProxy::setComposition): > + * UIProcess/WebPageProxy.h: > + * UIProcess/WebPageProxy.messages.in: > + * UIProcess/win/WebView.cpp: > + Added WndProc messages to support IME. > + (WebKit::WebView::wndProc): > + (WebKit::WebView::WebView): > + (WebKit::IMMDict::dict): > + (WebKit::IMMDict::IMMDict): > + (WebKit::WebView::getIMMContext): > + (WebKit::WebView::releaseIMMContext): > + (WebKit::WebView::prepareCandidateWindow): > + (WebKit::WebView::resetIME): > + (WebKit::WebView::setInputMethodState): > + (WebKit::WebView::selectionChanged): > + (WebKit::WebView::compositionSelectionChanged): > + (WebKit::WebView::onIMEStartComposition): > + (WebKit::getCompositionString): > + (WebKit::compositionToUnderlines): > + (WebKit::imeCompositionArgumentNames): > + (WebKit::imeNotificationName): > + (WebKit::imeRequestName): > + Message handlers. > + (WebKit::WebView::onIMEComposition): > + (WebKit::WebView::onIMEEndComposition): > + (WebKit::WebView::onIMEChar): > + (WebKit::WebView::onIMENotify): > + (WebKit::WebView::onIMERequestCharPosition): > + (WebKit::WebView::onIMERequestReconvertString): > + (WebKit::WebView::onIMERequest): > + (WebKit::WebView::onIMESelect): > + (WebKit::WebView::onIMESetContext): > + * UIProcess/win/WebView.h: > + * WebProcess/WebCoreSupport/WebEditorClient.cpp: > + (WebKit::WebEditorClient::respondToChangedSelection): > + * WebProcess/WebPage/WebPage.cpp: > + (WebKit::WebPage::confirmComposition): > + (WebKit::WebPage::setComposition): > + (WebKit::WebPage::firstRectForCharacterRange): > + (WebKit::WebPage::getSelectedText): > + * WebProcess/WebPage/WebPage.h: > + * WebProcess/WebPage/WebPage.messages.in: All this boilerplate without any comments isn't really helpful. It would be great to add comments, but if you aren't going to, you should probably remove all the function names. (Maybe the filenames, too.) > WebKit2/UIProcess/WebPageProxy.cpp:505 > +WebCore::IntRect WebPageProxy::firstRectForCharacterRange(int characterPosition) The name of this function seems wrong. You're not passing in a range, you're passing in a position. > WebKit2/UIProcess/WebPageProxy.cpp:508 > + process()->sendSync(Messages::WebPage::FirstRectForCharacterRange(characterPosition), Messages::WebPage::FirstRectForCharacterRange::Reply(resultRect), m_pageID); Likewise, the name of this message seems wrong. > WebKit2/UIProcess/WebPageProxy.cpp:1349 > +void WebPageProxy::didCompositionSelectionChange(bool hasComposition) This function sounds like it's asking a question. I think compositionSelectionDidChange would be clearer. > WebKit2/UIProcess/WebPageProxy.h:188 > #else > void didSelectionChange(bool, bool, bool, bool); > + void didCompositionSelectionChange(bool); > + void confirmComposition(const String&); > + void setComposition(const String&, Vector<WebCore::CompositionUnderline>&, int); > + WebCore::IntRect firstRectForCharacterRange(int); > + String getSelectedText(); > #endif Do non-Windows platforms really want all these new functions? didSelectionChange sounds like it's asking a question. I think selectionDidChange would be better. All those boolean parameters are very unreadable; enums might be better, but you should at least add some parameter names. "bool, bool, bool, bool" is basically meaningless. > WebKit2/UIProcess/win/WebView.cpp:695 > +class IMMDict { > + typedef HIMC (CALLBACK *getContextPtr)(HWND); > + typedef BOOL (CALLBACK *releaseContextPtr)(HWND, HIMC); > + typedef LONG (CALLBACK *getCompositionStringPtr)(HIMC, DWORD, LPVOID, DWORD); > + typedef BOOL (CALLBACK *setCandidateWindowPtr)(HIMC, LPCANDIDATEFORM); > + typedef BOOL (CALLBACK *setOpenStatusPtr)(HIMC, BOOL); > + typedef BOOL (CALLBACK *notifyIMEPtr)(HIMC, DWORD, DWORD, DWORD); > + typedef BOOL (CALLBACK *associateContextExPtr)(HWND, HIMC, DWORD); > + > +public: > + getContextPtr getContext; > + releaseContextPtr releaseContext; > + getCompositionStringPtr getCompositionString; > + setCandidateWindowPtr setCandidateWindow; > + setOpenStatusPtr setOpenStatus; > + notifyIMEPtr notifyIME; > + associateContextExPtr associateContextEx; > + > + static const IMMDict& dict(); > +private: > + IMMDict(); > + HMODULE m_instance; > +}; > + > +const IMMDict& IMMDict::dict() > +{ > + static IMMDict instance; > + return instance; > +} > + > +IMMDict::IMMDict() > +{ > + m_instance = ::LoadLibrary(TEXT("IMM32.DLL")); > + getContext = reinterpret_cast<getContextPtr>(::GetProcAddress(m_instance, "ImmGetContext")); > + ASSERT(getContext); > + releaseContext = reinterpret_cast<releaseContextPtr>(::GetProcAddress(m_instance, "ImmReleaseContext")); > + ASSERT(releaseContext); > + getCompositionString = reinterpret_cast<getCompositionStringPtr>(::GetProcAddress(m_instance, "ImmGetCompositionStringW")); > + ASSERT(getCompositionString); > + setCandidateWindow = reinterpret_cast<setCandidateWindowPtr>(::GetProcAddress(m_instance, "ImmSetCandidateWindow")); > + ASSERT(setCandidateWindow); > + setOpenStatus = reinterpret_cast<setOpenStatusPtr>(::GetProcAddress(m_instance, "ImmSetOpenStatus")); > + ASSERT(setOpenStatus); > + notifyIME = reinterpret_cast<notifyIMEPtr>(::GetProcAddress(m_instance, "ImmNotifyIME")); > + ASSERT(notifyIME); > + associateContextEx = reinterpret_cast<associateContextExPtr>(::GetProcAddress(m_instance, "ImmAssociateContextEx")); > + ASSERT(associateContextEx); > +} All of this could be replaced with the soft linking macros from WebCore/platform/win/SoftLinking.h. I think that would be a lot cleaner. > WebKit2/UIProcess/win/WebView.cpp:717 > + form.ptCurrentPos.y = caret.y() + caret.height(); I think caret.bottom() would work here. > WebKit2/UIProcess/win/WebView.cpp:727 > + if (HIMC hInputContext = getIMMContext()) { An early return would be better here. > WebKit2/UIProcess/win/WebView.cpp:769 > + compositionLength = IMMDict::dict().getCompositionString(hInputContext, type, (LPVOID)compositionBuffer.data(), compositionLength); static_cast<void*> would be better than (LPVOID). But I don't think you need a cast at all. > WebKit2/UIProcess/win/WebView.cpp:770 > + result = String(compositionBuffer.data(), compositionLength / 2); result = String::adopt(compositionBuffer); would be better. > WebKit2/UIProcess/win/WebView.cpp:783 > + const size_t numBoundaries = clauses.size() - 1; We don't normally use const for locals like this. > WebKit2/UIProcess/win/WebView.cpp:790 > + underlines[i].color = Color(0,0,0); Maybe we could use Color::black here instead. > WebKit2/UIProcess/win/WebView.cpp:805 > + // ENRICA - OK Huh? > WebKit2/UIProcess/win/WebView.cpp:811 > + if (lparam & GCS_COMPATTR) { > + result = "GCS_COMPATTR"; > + needsComma = true; > + } Why not use the macro for this case, too? > WebKit2/UIProcess/win/WebView.cpp:904 > + if (lparam & GCS_RESULTSTR || !lparam) { > + String compositionString; > + if (!getCompositionString(hInputContext, GCS_RESULTSTR, compositionString) && lparam) > + return true; > + > + m_page->confirmComposition(compositionString); > + } else { You could add an early return at the end of the if block. > WebKit2/UIProcess/win/WebView.cpp:916 > + int numClauses = IMMDict::dict().getCompositionString(hInputContext, GCS_COMPCLAUSE, 0, 0); > + Vector<DWORD> clauses(numClauses / sizeof(DWORD)); numClauses seems clearly misnamed. It's a number of bytes, not a number of clauses. (The same is true of numAttributes, though it's a little less egregious in that case, since an attribute is apparently just a single byte.) > WebKit2/UIProcess/win/WebView.cpp:957 > +bool WebView::onIMEChar(WPARAM wparam, LPARAM lparam) > +{ > + UNUSED_PARAM(wparam); > + UNUSED_PARAM(lparam); > + LOG(TextInput, "onIMEChar U+%04X %08X", wparam, lparam); > + return true; > +} > + > +bool WebView::onIMENotify(WPARAM wparam, LPARAM, LRESULT*) > +{ > + UNUSED_PARAM(wparam); > + LOG(TextInput, "onIMENotify %s", imeNotificationName(wparam).latin1().data()); > + return false; > +} Do we need to do anything more here? If so, FIXMEs and bugs would be appropriate. > WebKit2/UIProcess/win/WebView.cpp:978 > + if (!reconvertString) > + return sizeof(RECONVERTSTRING) + text.length() * sizeof(UChar); > + > + unsigned totalSize = sizeof(RECONVERTSTRING) + text.length() * sizeof(UChar); If we computed totalSize just a little earlier, we could use it in the early return. > WebKit2/WebProcess/WebPage/WebPage.messages.in:108 > +#if !PLATFORM(MAC) > + ConfirmComposition(WTF::String compositionString) > + SetComposition(WTF::String compositionString, WTF::Vector<WebCore::CompositionUnderline> underlines, uint64_t cursorPosition) > + FirstRectForCharacterRange(uint64_t characterPosition) -> (WebCore::IntRect resultRect) > + GetSelectedText() -> (WTF::String text) > +#endif Do non-Windows platforms really want all these new messages? 322157 3 enrica 2010-12-14 13:21:36 -0800 (In reply to comment #2) > (From update of attachment 76553 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=76553&action=review > > > WebKit2/ChangeLog:59 > All this boilerplate without any comments isn't really helpful. It would be great to add comments, but if you aren't going to, you should probably remove all the function names. (Maybe the filenames, too.) I'll add some more comments. > > > WebKit2/UIProcess/WebPageProxy.cpp:505 > > +WebCore::IntRect WebPageProxy::firstRectForCharacterRange(int characterPosition) > > The name of this function seems wrong. You're not passing in a range, you're passing in a position. > Actually, the rect is calculated starting from the selected range and the character is an offset in that range. I could change it to firstRectForSelectedRange? > This function sounds like it's asking a question. I think compositionSelectionDidChange would be clearer. Ok. > > > WebKit2/UIProcess/WebPageProxy.h:188 > > #else > > void didSelectionChange(bool, bool, bool, bool); > > + void didCompositionSelectionChange(bool); > > + void confirmComposition(const String&); > > + void setComposition(const String&, Vector<WebCore::CompositionUnderline>&, int); > > + WebCore::IntRect firstRectForCharacterRange(int); > > + String getSelectedText(); > > #endif > > Do non-Windows platforms really want all these new functions? I wasn't sure at all. I can definitely limit it to Windows, even though there is no platform specific code in there. > All your other comments are relative to code that exists in the same form in WebKit today. I thought that code has been reviewed and r+ before and it was safer not to modify it to avoid potential bugs. I agree that the code needs to be modernized, from a style standpoint. I'll address the comments and post a new patch. Thanks. 322161 4 76553 aroben 2010-12-14 13:27:38 -0800 Comment on attachment 76553 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=76553&action=review >>> WebKit2/UIProcess/WebPageProxy.cpp:505 >>> +WebCore::IntRect WebPageProxy::firstRectForCharacterRange(int characterPosition) >> >> The name of this function seems wrong. You're not passing in a range, you're passing in a position. > > Actually, the rect is calculated starting from the selected range and the character is an offset in that range. I could change it to firstRectForSelectedRange? I think the "For" part of the function name (even your new proposed name) is confusing me. Normally, "fooForBar" is a function that takes "bar" and returns "foo". In this case, we're taking something other than "bar". I don't understand what the function does enough to be confident of what a good name would be, but perhaps firstRectForCharacterInSelectedRange would work. >>> WebKit2/UIProcess/WebPageProxy.h:188 >>> #endif >> >> Do non-Windows platforms really want all these new functions? >> >> didSelectionChange sounds like it's asking a question. I think selectionDidChange would be better. All those boolean parameters are very unreadable; enums might be better, but you should at least add some parameter names. "bool, bool, bool, bool" is basically meaningless. > > I wasn't sure at all. I can definitely limit it to Windows, even though there is no platform specific code in there. It seems worth limiting it to Windows unless we're fairly confident that other ports will want to use these functions. If we limit it and end up being wrong, other ports can always un-limit it. 322389 5 76600 enrica 2010-12-14 17:34:06 -0800 Created attachment 76600 Patch2 The new patch addresses all the comments from Adam. 322874 6 76600 aroben 2010-12-15 15:32:30 -0800 Comment on attachment 76600 Patch2 View in context: https://bugs.webkit.org/attachment.cgi?id=76600&action=review > WebKit2/ChangeLog:20 > + The followinf methods send asynchronous messages to the WebProcess. Typo: followinf > WebKit2/UIProcess/PageClient.h:75 > virtual void selectionChanged(bool, bool, bool, bool) = 0; I still think it would be good to give names to these parameters. You could do that in a separate patch. > WebKit2/UIProcess/WebPageProxy.cpp:1343 > -void WebPageProxy::didSelectionChange(bool isNone, bool isContentEditable, bool isPasswordField, bool hasComposition) > +void WebPageProxy::didChangeSelection(bool isNone, bool isContentEditable, bool isPasswordField, bool hasComposition) I thought you were going to do this in a separate patch? > WebKit2/UIProcess/WebPageProxy.h:182 > - void didSelectionChange(bool, bool, bool, bool); > + void didChangeSelection(bool, bool, bool, bool); Same comment here about parameter names. > WebKit2/UIProcess/win/WebView.cpp:654 > +HIMC WebView::getIMMContext() > +{ > + return WebKit::ImmGetContext(m_window); No need for the "WebKit::" here. But I think it would be better to put the soft-linking macros outside of the WebKit namespace so that you can say "::ImmGetContext" like we do for other Win32 API calls. This function doesn't seem necessary. > WebKit2/UIProcess/win/WebView.cpp:662 > +void WebView::releaseIMMContext(HIMC hIMC) > +{ > + if (!hIMC) > + return; > + WebKit::ImmReleaseContext(m_window, hIMC); > +} This function also doesn't seem necessary, unless the null-checking is helping us. But maybe callers should just null-check. (In fact, I think they already do!) > WebKit2/UIProcess/win/WebView.cpp:714 > + HIMC hInputContext = getIMMContext(); > + prepareCandidateWindow(hInputContext); > + releaseIMMContext(hInputContext); Do we need a null-check here (if you get rid of releaseIMMContext)? > WebKit2/UIProcess/win/WebView.cpp:738 > + for (unsigned i = 0; i < numBoundaries; i++) { You should use size_t here. We tend to prefer prefix (++i) instead of postfix, even when it doesn't matter, as in this case. > WebKit2/UIProcess/win/WebView.cpp:903 > + return onIMERequestReconvertString((RECONVERTSTRING*)data); > + > + case IMR_QUERYCHARPOSITION: > + return onIMERequestCharPosition((IMECHARPOSITION*)data); reinterpret_cast would be better here. > WebKit2/UIProcess/win/WebView.h:145 > + // Text input state values > + bool m_selectionIsNone; > + bool m_selectionIsEditable; > + bool m_selectionInPasswordField; > + bool m_hasMarkedText; > + unsigned m_inIMEComposition; I'd putt these after the other data members, not before. Data members like "m_window" seem far more essential than these, and I think it's nice to have data members in rough order of decreasing importance. > WebKit2/WebProcess/WebCoreSupport/WebEditorClient.cpp:198 > +#if PLATFORM(WIN) > + if (!frame->editor()->hasComposition() || frame->editor()->ignoreCompositionSelectionChange()) > + return; > + > + unsigned start; > + unsigned end; > + m_page->send(Messages::WebPageProxy::DidChangeCompositionSelection(frame->editor()->getCompositionSelection(start, end))); > +#endif Maybe you should add a new platformRespondToChangedSelection function to hold this code? > WebKit2/WebProcess/WebPage/WebPage.cpp:1057 > +#if PLATFORM(WIN) > +void WebPage::confirmComposition(const String& compositionString) > +{ > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > + if (!frame || !frame->editor()->canEdit()) > + return; > + frame->editor()->confirmComposition(compositionString); > +} > + > +void WebPage::setComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition) > +{ > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > + if (!frame || !frame->editor()->canEdit()) > + return; > + frame->editor()->setComposition(compositionString, underlines, cursorPosition, 0); > +} > + > +void WebPage::firstRectForCharacterInSelectedRange(const uint64_t characterPosition, WebCore::IntRect& resultRect) > +{ > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > + IntRect rect; > + if (RefPtr<Range> range = frame->editor()->hasComposition() ? frame->editor()->compositionRange() : frame->selection()->selection().toNormalizedRange()) { > + ExceptionCode ec = 0; > + RefPtr<Range> tempRange = range->cloneRange(ec); > + tempRange->setStart(tempRange->startContainer(ec), tempRange->startOffset(ec) + characterPosition, ec); > + rect = frame->editor()->firstRectForRange(tempRange.get()); > + } > + resultRect = frame->view()->contentsToWindow(rect); > +} > + > +void WebPage::getSelectedText(String& text) > +{ > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > + RefPtr<Range> selectedRange = frame->selection()->toNormalizedRange(); > + text = selectedRange->text(); > +} > +#endif This should all go in WebPageWin.cpp. > WebKit2/WebProcess/WebPage/WebPage.messages.in:98 > + // This is a dummy message to avoid breaking the build for platforms that don't require > + // synchronous messages. > + Dummy() -> (bool dummyReturn) This seems like a bug in our scripts. Ideally this wouldn't be necessary. Can you file a bug about it and reference the bug number here? 322898 7 enrica 2010-12-15 15:51:31 -0800 (In reply to comment #6) > Typo: followinf ok. > > > WebKit2/UIProcess/PageClient.h:75 > > virtual void selectionChanged(bool, bool, bool, bool) = 0; > > I still think it would be good to give names to these parameters. You could do that in a separate patch. Just followed the style used in this class. I will not change this now. > > > WebKit2/UIProcess/WebPageProxy.cpp:1343 > > -void WebPageProxy::didSelectionChange(bool isNone, bool isContentEditable, bool isPasswordField, bool hasComposition) > > +void WebPageProxy::didChangeSelection(bool isNone, bool isContentEditable, bool isPasswordField, bool hasComposition) > > I thought you were going to do this in a separate patch? I was going to do in a separate patch, the Mac version. This is for all the other platforms. > > > WebKit2/UIProcess/WebPageProxy.h:182 > > - void didSelectionChange(bool, bool, bool, bool); > > + void didChangeSelection(bool, bool, bool, bool); > > Same comment here about parameter names. Again, I followed the existing style. I agree that using parameter names is better, I just don't like mixing different styles. > > > WebKit2/UIProcess/win/WebView.cpp:654 > > +HIMC WebView::getIMMContext() > > +{ > > + return WebKit::ImmGetContext(m_window); > > No need for the "WebKit::" here. But I think it would be better to put the soft-linking macros outside of the WebKit namespace so that you can say "::ImmGetContext" like we do for other Win32 API calls. > > This function doesn't seem necessary. > > > WebKit2/UIProcess/win/WebView.cpp:662 > > +void WebView::releaseIMMContext(HIMC hIMC) > > +{ > > + if (!hIMC) > > + return; > > + WebKit::ImmReleaseContext(m_window, hIMC); > > +} > > This function also doesn't seem necessary, unless the null-checking is helping us. But maybe callers should just null-check. (In fact, I think they already do!) > > > WebKit2/UIProcess/win/WebView.cpp:714 > > + HIMC hInputContext = getIMMContext(); > > + prepareCandidateWindow(hInputContext); > > + releaseIMMContext(hInputContext); > > Do we need a null-check here (if you get rid of releaseIMMContext)? > > > WebKit2/UIProcess/win/WebView.cpp:738 > > + for (unsigned i = 0; i < numBoundaries; i++) { > > You should use size_t here. We tend to prefer prefix (++i) instead of postfix, even when it doesn't matter, as in this case. > Will do. > > WebKit2/UIProcess/win/WebView.cpp:903 > > + return onIMERequestReconvertString((RECONVERTSTRING*)data); > > + > > + case IMR_QUERYCHARPOSITION: > > + return onIMERequestCharPosition((IMECHARPOSITION*)data); > > reinterpret_cast would be better here. > Ok. > > WebKit2/UIProcess/win/WebView.h:145 > > + // Text input state values > > + bool m_selectionIsNone; > > + bool m_selectionIsEditable; > > + bool m_selectionInPasswordField; > > + bool m_hasMarkedText; > > + unsigned m_inIMEComposition; > > I'd putt these after the other data members, not before. Data members like "m_window" seem far more essential than these, and I think it's nice to have data members in rough order of decreasing importance. > ok. > > WebKit2/WebProcess/WebCoreSupport/WebEditorClient.cpp:198 > > +#if PLATFORM(WIN) > > + if (!frame->editor()->hasComposition() || frame->editor()->ignoreCompositionSelectionChange()) > > + return; > > + > > + unsigned start; > > + unsigned end; > > + m_page->send(Messages::WebPageProxy::DidChangeCompositionSelection(frame->editor()->getCompositionSelection(start, end))); > > +#endif > > Maybe you should add a new platformRespondToChangedSelection function to hold this code? > Sure... > > WebKit2/WebProcess/WebPage/WebPage.cpp:1057 > > +#if PLATFORM(WIN) > > +void WebPage::confirmComposition(const String& compositionString) > > +{ > > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > > + if (!frame || !frame->editor()->canEdit()) > > + return; > > + frame->editor()->confirmComposition(compositionString); > > +} > > + > > +void WebPage::setComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition) > > +{ > > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > > + if (!frame || !frame->editor()->canEdit()) > > + return; > > + frame->editor()->setComposition(compositionString, underlines, cursorPosition, 0); > > +} > > + > > +void WebPage::firstRectForCharacterInSelectedRange(const uint64_t characterPosition, WebCore::IntRect& resultRect) > > +{ > > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > > + IntRect rect; > > + if (RefPtr<Range> range = frame->editor()->hasComposition() ? frame->editor()->compositionRange() : frame->selection()->selection().toNormalizedRange()) { > > + ExceptionCode ec = 0; > > + RefPtr<Range> tempRange = range->cloneRange(ec); > > + tempRange->setStart(tempRange->startContainer(ec), tempRange->startOffset(ec) + characterPosition, ec); > > + rect = frame->editor()->firstRectForRange(tempRange.get()); > > + } > > + resultRect = frame->view()->contentsToWindow(rect); > > +} > > + > > +void WebPage::getSelectedText(String& text) > > +{ > > + Frame* frame = m_page->focusController()->focusedOrMainFrame(); > > + RefPtr<Range> selectedRange = frame->selection()->toNormalizedRange(); > > + text = selectedRange->text(); > > +} > > +#endif > > This should all go in WebPageWin.cpp. > Ok. > > WebKit2/WebProcess/WebPage/WebPage.messages.in:98 > > + // This is a dummy message to avoid breaking the build for platforms that don't require > > + // synchronous messages. > > + Dummy() -> (bool dummyReturn) > > This seems like a bug in our scripts. Ideally this wouldn't be necessary. Can you file a bug about it and reference the bug number here? ok 322910 8 aroben 2010-12-15 16:04:28 -0800 (In reply to comment #7) > (In reply to comment #6) > > Typo: followinf > ok. > > > > > WebKit2/UIProcess/PageClient.h:75 > > > virtual void selectionChanged(bool, bool, bool, bool) = 0; > > > > I still think it would be good to give names to these parameters. You could do that in a separate patch. > Just followed the style used in this class. I will not change this now. PageClient.h has parameter names for some of its functions (e.g., setFindIndicator has a "bool fadeOut" parameter). I'd argue that we should be adding more parameter names to that file, not less. > > > WebKit2/UIProcess/WebPageProxy.h:182 > > > - void didSelectionChange(bool, bool, bool, bool); > > > + void didChangeSelection(bool, bool, bool, bool); > > > > Same comment here about parameter names. > Again, I followed the existing style. I agree that using parameter names is better, I just don't like mixing different styles. WebPageProxy.h also has plenty of functions with parameter names. WebKit's defacto style (though it isn't written down anywhere) is to always use parameter names except where they don't add any value (e.g., "setString(const String& string)" is just as understandable without the "string"). We should be following that style in new code. Multiple boolean paramters in a row are especially opaque without parameter names. 76553 2010-12-14 12:05:19 -0800 2010-12-14 17:34:06 -0800 Patch ime-win.txt text/plain 29678 enrica SW5kZXg6IFdlYktpdDIvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdDIvQ2hhbmdlTG9n CShyZXZpc2lvbiA3NDA0NikKKysrIFdlYktpdDIvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjMgQEAKKzIwMTAtMTItMTQgIEVucmljYSBDYXN1Y2NpICA8ZW5yaWNhQGFwcGxl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB ZGQgSU1FIHN1cHBvcnQgdG8gV2ViS2l0MiBvbiBXaW5kb3dzCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MTA0OQorCisgICAgICAgICogVUlQcm9jZXNz L0FQSS9xdC9xd2twYWdlLmNwcDoKKyAgICAgICAgKFFXS1BhZ2VQcml2YXRlOjpjb21wb3NpdGlv blNlbGVjdGlvbkNoYW5nZWQpOiBBZGRlZCBlbXB0eSBzdHViLgorICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvcXQvcXdrcGFnZV9wLmg6CisgICAgICAgICogVUlQcm9jZXNzL1BhZ2VDbGllbnQuaDog QWRkZWQgY29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2VkLgorICAgICAgICAqIFVJUHJvY2Vzcy9X ZWJQYWdlUHJveHkuY3BwOgorICAgICAgICBBZGRlZCBuZXcgbWVzc2FnZXMgdG8gc3VwcG9ydCBJ TUUgb24gV2luZG93cy4KKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpmaXJzdFJlY3RG b3JDaGFyYWN0ZXJSYW5nZSk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6Z2V0U2Vs ZWN0ZWRUZXh0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpkaWRDb21wb3NpdGlv blNlbGVjdGlvbkNoYW5nZSk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6Y29uZmly bUNvbXBvc2l0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzZXRDb21wb3Np dGlvbik6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAqIFVJ UHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW46CisgICAgICAgICogVUlQcm9jZXNzL3dp bi9XZWJWaWV3LmNwcDoKKyAgICAgICAgQWRkZWQgV25kUHJvYyBtZXNzYWdlcyB0byBzdXBwb3J0 IElNRS4KKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6d25kUHJvYyk6CisgICAgICAgIChXZWJL aXQ6OldlYlZpZXc6OldlYlZpZXcpOgorICAgICAgICAoV2ViS2l0OjpJTU1EaWN0OjpkaWN0KToK KyAgICAgICAgKFdlYktpdDo6SU1NRGljdDo6SU1NRGljdCk6CisgICAgICAgIChXZWJLaXQ6Oldl YlZpZXc6OmdldElNTUNvbnRleHQpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpyZWxlYXNl SU1NQ29udGV4dCk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OnByZXBhcmVDYW5kaWRhdGVX aW5kb3cpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpyZXNldElNRSk6CisgICAgICAgIChX ZWJLaXQ6OldlYlZpZXc6OnNldElucHV0TWV0aG9kU3RhdGUpOgorICAgICAgICAoV2ViS2l0OjpX ZWJWaWV3OjpzZWxlY3Rpb25DaGFuZ2VkKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6Y29t cG9zaXRpb25TZWxlY3Rpb25DaGFuZ2VkKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6b25J TUVTdGFydENvbXBvc2l0aW9uKToKKyAgICAgICAgKFdlYktpdDo6Z2V0Q29tcG9zaXRpb25TdHJp bmcpOgorICAgICAgICAoV2ViS2l0Ojpjb21wb3NpdGlvblRvVW5kZXJsaW5lcyk6CisgICAgICAg IChXZWJLaXQ6OmltZUNvbXBvc2l0aW9uQXJndW1lbnROYW1lcyk6CisgICAgICAgIChXZWJLaXQ6 OmltZU5vdGlmaWNhdGlvbk5hbWUpOgorICAgICAgICAoV2ViS2l0OjppbWVSZXF1ZXN0TmFtZSk6 CisgICAgICAgIE1lc3NhZ2UgaGFuZGxlcnMuCisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6Om9u SU1FQ29tcG9zaXRpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpvbklNRUVuZENvbXBv c2l0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6b25JTUVDaGFyKToKKyAgICAgICAg KFdlYktpdDo6V2ViVmlldzo6b25JTUVOb3RpZnkpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3 OjpvbklNRVJlcXVlc3RDaGFyUG9zaXRpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3Ojpv bklNRVJlcXVlc3RSZWNvbnZlcnRTdHJpbmcpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3Ojpv bklNRVJlcXVlc3QpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpvbklNRVNlbGVjdCk6Cisg ICAgICAgIChXZWJLaXQ6OldlYlZpZXc6Om9uSU1FU2V0Q29udGV4dCk6CisgICAgICAgICogVUlQ cm9jZXNzL3dpbi9XZWJWaWV3Lmg6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJFZGl0b3JDbGllbnQuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJFZGl0b3JDbGllbnQ6 OnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24pOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFn ZS9XZWJQYWdlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6Y29uZmlybUNvbXBvc2l0 aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6c2V0Q29tcG9zaXRpb24pOgorICAgICAg ICAoV2ViS2l0OjpXZWJQYWdlOjpmaXJzdFJlY3RGb3JDaGFyYWN0ZXJSYW5nZSk6CisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2U6OmdldFNlbGVjdGVkVGV4dCk6CisgICAgICAgICogV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2UuaDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFn ZS5tZXNzYWdlcy5pbjoKKwogMjAxMC0xMi0xNCAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FA YXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCkluZGV4OiBXZWJL aXQyL1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0Mi9VSVByb2Nl c3MvUGFnZUNsaWVudC5oCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvVUlQcm9jZXNzL1Bh Z2VDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAtNzMsNiArNzMsNyBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoYm9vbCwgYm9vbCwgYm9vbCwgYm9vbCwgdWlu dDY0X3QsIHVpbnQ2NF90KSA9IDA7CiAjZWxzZQogICAgIHZpcnR1YWwgdm9pZCBzZWxlY3Rpb25D aGFuZ2VkKGJvb2wsIGJvb2wsIGJvb2wsIGJvb2wpID0gMDsKKyAgICB2aXJ0dWFsIHZvaWQgY29t cG9zaXRpb25TZWxlY3Rpb25DaGFuZ2VkKGJvb2wpID0gMDsKICNlbmRpZgogICAgIHZpcnR1YWwg V2ViQ29yZTo6RmxvYXRSZWN0IGNvbnZlcnRUb0RldmljZVNwYWNlKGNvbnN0IFdlYkNvcmU6OkZs b2F0UmVjdCYpID0gMDsKICAgICB2aXJ0dWFsIFdlYkNvcmU6OkZsb2F0UmVjdCBjb252ZXJ0VG9V c2VyU3BhY2UoY29uc3QgV2ViQ29yZTo6RmxvYXRSZWN0JikgPSAwOwpJbmRleDogV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQyL1VJUHJvY2Vz cy9XZWJQYWdlUHJveHkuY3BwCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUwMCw3ICs1MDAsMjIgQEAgV2Vi Q29yZTo6SW50UmVjdCBXZWJQYWdlUHJveHk6OmZpcnN0UmVjdAogICAgIEludFJlY3QgcmVzdWx0 UmVjdDsKICAgICBwcm9jZXNzKCktPnNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJQYWdlOjpGaXJzdFJl Y3RGb3JDaGFyYWN0ZXJSYW5nZShsb2NhdGlvbiwgbGVuZ3RoKSwgTWVzc2FnZXM6OldlYlBhZ2U6 OkZpcnN0UmVjdEZvckNoYXJhY3RlclJhbmdlOjpSZXBseShyZXN1bHRSZWN0KSwgbV9wYWdlSUQp OwogICAgIHJldHVybiByZXN1bHRSZWN0OwotfSAgICAKK30KKyNlbHNlCitXZWJDb3JlOjpJbnRS ZWN0IFdlYlBhZ2VQcm94eTo6Zmlyc3RSZWN0Rm9yQ2hhcmFjdGVyUmFuZ2UoaW50IGNoYXJhY3Rl clBvc2l0aW9uKQoreworICAgIEludFJlY3QgcmVzdWx0UmVjdDsKKyAgICBwcm9jZXNzKCktPnNl bmRTeW5jKE1lc3NhZ2VzOjpXZWJQYWdlOjpGaXJzdFJlY3RGb3JDaGFyYWN0ZXJSYW5nZShjaGFy YWN0ZXJQb3NpdGlvbiksIE1lc3NhZ2VzOjpXZWJQYWdlOjpGaXJzdFJlY3RGb3JDaGFyYWN0ZXJS YW5nZTo6UmVwbHkocmVzdWx0UmVjdCksIG1fcGFnZUlEKTsKKyAgICByZXR1cm4gcmVzdWx0UmVj dDsKK30KKworU3RyaW5nIFdlYlBhZ2VQcm94eTo6Z2V0U2VsZWN0ZWRUZXh0KCkKK3sKKyAgICBT dHJpbmcgdGV4dDsKKyAgICBwcm9jZXNzKCktPnNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJQYWdlOjpH ZXRTZWxlY3RlZFRleHQoKSwgTWVzc2FnZXM6OldlYlBhZ2U6OkdldFNlbGVjdGVkVGV4dDo6UmVw bHkodGV4dCksIG1fcGFnZUlEKTsKKyAgICByZXR1cm4gdGV4dDsKK30KKwogI2VuZGlmCiAKICNp ZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKQEAgLTEzMzAsNiArMTM0NSwyMiBAQCB2b2lk IFdlYlBhZ2VQcm94eTo6ZGlkU2VsZWN0aW9uQ2hhbmdlKGJvCiB7CiAgICAgbV9wYWdlQ2xpZW50 LT5zZWxlY3Rpb25DaGFuZ2VkKGlzTm9uZSwgaXNDb250ZW50RWRpdGFibGUsIGlzUGFzc3dvcmRG aWVsZCwgaGFzQ29tcG9zaXRpb24pOwogfQorCit2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkQ29tcG9z aXRpb25TZWxlY3Rpb25DaGFuZ2UoYm9vbCBoYXNDb21wb3NpdGlvbikKK3sKKyAgICBtX3BhZ2VD bGllbnQtPmNvbXBvc2l0aW9uU2VsZWN0aW9uQ2hhbmdlZChoYXNDb21wb3NpdGlvbik7Cit9CisK K3ZvaWQgV2ViUGFnZVByb3h5Ojpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiBjb21w b3NpdGlvblN0cmluZykKK3sKKyAgICBwcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6 OkNvbmZpcm1Db21wb3NpdGlvbihjb21wb3NpdGlvblN0cmluZyksIG1fcGFnZUlEKTsKK30KKwor dm9pZCBXZWJQYWdlUHJveHk6OnNldENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgY29tcG9zaXRp b25TdHJpbmcsIFZlY3RvcjxXZWJDb3JlOjpDb21wb3NpdGlvblVuZGVybGluZT4mIHVuZGVybGlu ZXMsIGludCBjdXJzb3JQb3NpdGlvbikKK3sKKyAgICBwcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6 OldlYlBhZ2U6OlNldENvbXBvc2l0aW9uKGNvbXBvc2l0aW9uU3RyaW5nLCB1bmRlcmxpbmVzLCBj dXJzb3JQb3NpdGlvbiksIG1fcGFnZUlEKTsKK30KKwogI2VuZGlmCiAgICAgCiAvLyBVbmRvIG1h bmFnZW1lbnQKSW5kZXg6IFdlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCShyZXZpc2lvbiA3NDA0MikK KysrIFdlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCSh3b3JraW5nIGNvcHkpCkBAIC0x ODAsNiArMTgwLDExIEBAIHB1YmxpYzoKICAgICB2b2lkIGRpZFNlbGVjdGlvbkNoYW5nZShib29s LCBib29sLCBib29sLCBib29sLCB1aW50NjRfdCwgdWludDY0X3QpOwogI2Vsc2UKICAgICB2b2lk IGRpZFNlbGVjdGlvbkNoYW5nZShib29sLCBib29sLCBib29sLCBib29sKTsKKyAgICB2b2lkIGRp ZENvbXBvc2l0aW9uU2VsZWN0aW9uQ2hhbmdlKGJvb2wpOworICAgIHZvaWQgY29uZmlybUNvbXBv c2l0aW9uKGNvbnN0IFN0cmluZyYpOworICAgIHZvaWQgc2V0Q29tcG9zaXRpb24oY29uc3QgU3Ry aW5nJiwgVmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPiYsIGludCk7CisgICAg V2ViQ29yZTo6SW50UmVjdCBmaXJzdFJlY3RGb3JDaGFyYWN0ZXJSYW5nZShpbnQpOworICAgIFN0 cmluZyBnZXRTZWxlY3RlZFRleHQoKTsKICNlbmRpZgogCiAjaWYgRU5BQkxFKFRJTEVEX0JBQ0tJ TkdfU1RPUkUpCkluZGV4OiBXZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMu aW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2Vz LmluCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5t ZXNzYWdlcy5pbgkod29ya2luZyBjb3B5KQpAQCAtMTI1LDYgKzEyNSw3IEBAIG1lc3NhZ2VzIC0+ IFdlYlBhZ2VQcm94eSB7CiAjZW5kaWYKICNpZiAhUExBVEZPUk0oTUFDKQogICAgIERpZFNlbGVj dGlvbkNoYW5nZShib29sIGlzTm9uZSwgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZSwgYm9vbCBpc1Bh c3N3b3JkRmllbGQsIGJvb2wgaGFzQ29tcG9zaXRpb24pCisgICAgRGlkQ29tcG9zaXRpb25TZWxl Y3Rpb25DaGFuZ2UoYm9vbCBoYXNDaGFuZ2VkKQogI2VuZGlmCiAKICAgICAjIEZpbmQuCkluZGV4 OiBXZWJLaXQyL1VJUHJvY2Vzcy9BUEkvcXQvcXdrcGFnZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL3F0L3F3a3BhZ2UuY3BwCShyZXZpc2lvbiA3NDA0MikKKysrIFdl YktpdDIvVUlQcm9jZXNzL0FQSS9xdC9xd2twYWdlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMy LDYgKzEzMiwxMCBAQCB2b2lkIFFXS1BhZ2VQcml2YXRlOjpzZWxlY3Rpb25DaGFuZ2VkKGJvCiB7 CiB9CiAKK3ZvaWQgUVdLUGFnZVByaXZhdGU6OmNvbXBvc2l0aW9uU2VsZWN0aW9uQ2hhbmdlZChi b29sKQoreworfQorCiB2b2lkIFFXS1BhZ2VQcml2YXRlOjpkaWROb3RIYW5kbGVLZXlFdmVudChj b25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JikKIHsKIH0KSW5kZXg6IFdlYktpdDIvVUlQcm9j ZXNzL0FQSS9xdC9xd2twYWdlX3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQyL1VJUHJvY2Vzcy9B UEkvcXQvcXdrcGFnZV9wLmgJKHJldmlzaW9uIDc0MDQyKQorKysgV2ViS2l0Mi9VSVByb2Nlc3Mv QVBJL3F0L3F3a3BhZ2VfcC5oCSh3b3JraW5nIGNvcHkpCkBAIC02Miw2ICs2Miw3IEBAIHB1Ymxp YzoKICAgICB2aXJ0dWFsIFdlYkNvcmU6OkZsb2F0UmVjdCBjb252ZXJ0VG9Vc2VyU3BhY2UoY29u c3QgV2ViQ29yZTo6RmxvYXRSZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIGRpZE5vdEhhbmRsZUtl eUV2ZW50KGNvbnN0IFdlYktpdDo6TmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYpOwogICAgIHZpcnR1 YWwgdm9pZCBzZWxlY3Rpb25DaGFuZ2VkKGJvb2wsIGJvb2wsIGJvb2wsIGJvb2wpOworICAgIHZp cnR1YWwgdm9pZCBjb21wb3NpdGlvblNlbGVjdGlvbkNoYW5nZWQoYm9vbCk7CiAgICAgdmlydHVh bCBQYXNzUmVmUHRyPFdlYktpdDo6V2ViUG9wdXBNZW51UHJveHk+IGNyZWF0ZVBvcHVwTWVudVBy b3h5KCk7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPFdlYktpdDo6V2ViQ29udGV4dE1lbnVQcm94 eT4gY3JlYXRlQ29udGV4dE1lbnVQcm94eShXZWJLaXQ6OldlYlBhZ2VQcm94eSopOwogCkluZGV4 OiBXZWJLaXQyL1VJUHJvY2Vzcy93aW4vV2ViVmlldy5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 Mi9VSVByb2Nlc3Mvd2luL1dlYlZpZXcuY3BwCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIv VUlQcm9jZXNzL3dpbi9XZWJWaWV3LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgsNiArMjgsNyBA QAogI2luY2x1ZGUgIkNodW5rZWRVcGRhdGVEcmF3aW5nQXJlYVByb3h5LmgiCiAjaW5jbHVkZSAi RmluZEluZGljYXRvci5oIgogI2luY2x1ZGUgIkxheWVyQmFja2VkRHJhd2luZ0FyZWFQcm94eS5o IgorI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJSdW5Mb29wLmgiCiAjaW5jbHVkZSAi TmF0aXZlV2ViS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIldlYkNvbnRleHQuaCIKQEAgLTE0 Niw2ICsxNDcsMzAgQEAgTFJFU1VMVCBXZWJWaWV3Ojp3bmRQcm9jKEhXTkQgaFduZCwgVUlOVAog ICAgICAgICBjYXNlIFdNX1NFVENVUlNPUjoKICAgICAgICAgICAgIGxSZXN1bHQgPSBvblNldEN1 cnNvcihoV25kLCBtZXNzYWdlLCB3UGFyYW0sIGxQYXJhbSwgaGFuZGxlZCk7CiAgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgY2FzZSBXTV9JTUVfU1RBUlRDT01QT1NJVElPTjoKKyAgICAgICAg ICAgIGhhbmRsZWQgPSBvbklNRVN0YXJ0Q29tcG9zaXRpb24oKTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICBjYXNlIFdNX0lNRV9SRVFVRVNUOgorICAgICAgICAgICAgbFJlc3VsdCA9IG9u SU1FUmVxdWVzdCh3UGFyYW0sIGxQYXJhbSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAg Y2FzZSBXTV9JTUVfQ09NUE9TSVRJT046CisgICAgICAgICAgICBoYW5kbGVkID0gb25JTUVDb21w b3NpdGlvbihsUGFyYW0pOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgV01fSU1F X0VORENPTVBPU0lUSU9OOgorICAgICAgICAgICAgaGFuZGxlZCA9IG9uSU1FRW5kQ29tcG9zaXRp b24oKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFdNX0lNRV9DSEFSOgorICAg ICAgICAgICAgaGFuZGxlZCA9IG9uSU1FQ2hhcih3UGFyYW0sIGxQYXJhbSk7CisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgY2FzZSBXTV9JTUVfTk9USUZZOgorICAgICAgICAgICAgaGFuZGxl ZCA9IG9uSU1FTm90aWZ5KHdQYXJhbSwgbFBhcmFtLCAmbFJlc3VsdCk7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBXTV9JTUVfU0VMRUNUOgorICAgICAgICAgICAgaGFuZGxlZCA9 IG9uSU1FU2VsZWN0KHdQYXJhbSwgbFBhcmFtKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAg ICBjYXNlIFdNX0lNRV9TRVRDT05URVhUOgorICAgICAgICAgICAgaGFuZGxlZCA9IG9uSU1FU2V0 Q29udGV4dCh3UGFyYW0sIGxQYXJhbSk7CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgZGVm YXVsdDoKICAgICAgICAgICAgIGhhbmRsZWQgPSBmYWxzZTsKICAgICAgICAgICAgIGJyZWFrOwpA QCAtMTkxLDYgKzIxNiwxMSBAQCBXZWJWaWV3OjpXZWJWaWV3KFJFQ1QgcmVjdCwgV2ViQ29udGV4 dCoKICAgICAsIG1fb3ZlcnJpZGVDdXJzb3IoMCkKICAgICAsIG1fdHJhY2tpbmdNb3VzZUxlYXZl KGZhbHNlKQogICAgICwgbV9pc0JlaW5nRGVzdHJveWVkKGZhbHNlKQorICAgICwgbV9zZWxlY3Rp b25Jc05vbmUodHJ1ZSkKKyAgICAsIG1fc2VsZWN0aW9uSXNFZGl0YWJsZShmYWxzZSkKKyAgICAs IG1fc2VsZWN0aW9uSW5QYXNzd29yZEZpZWxkKGZhbHNlKQorICAgICwgbV9oYXNNYXJrZWRUZXh0 KGZhbHNlKQorICAgICwgbV9pbklNRUNvbXBvc2l0aW9uKDApCiB7CiAgICAgcmVnaXN0ZXJXZWJW aWV3V2luZG93Q2xhc3MoKTsKIApAQCAtNjE1LDkgKzY0NSwzNzUgQEAgRmxvYXRSZWN0IFdlYlZp ZXc6OmNvbnZlcnRUb1VzZXJTcGFjZShjbwogICAgIHJldHVybiByZWN0OwogfQogCi12b2lkIFdl YlZpZXc6OnNlbGVjdGlvbkNoYW5nZWQoYm9vbCwgYm9vbCwgYm9vbCwgYm9vbCkKK2NsYXNzIElN TURpY3QgeworICAgIHR5cGVkZWYgSElNQyAoQ0FMTEJBQ0sgKmdldENvbnRleHRQdHIpKEhXTkQp OworICAgIHR5cGVkZWYgQk9PTCAoQ0FMTEJBQ0sgKnJlbGVhc2VDb250ZXh0UHRyKShIV05ELCBI SU1DKTsKKyAgICB0eXBlZGVmIExPTkcgKENBTExCQUNLICpnZXRDb21wb3NpdGlvblN0cmluZ1B0 cikoSElNQywgRFdPUkQsIExQVk9JRCwgRFdPUkQpOworICAgIHR5cGVkZWYgQk9PTCAoQ0FMTEJB Q0sgKnNldENhbmRpZGF0ZVdpbmRvd1B0cikoSElNQywgTFBDQU5ESURBVEVGT1JNKTsKKyAgICB0 eXBlZGVmIEJPT0wgKENBTExCQUNLICpzZXRPcGVuU3RhdHVzUHRyKShISU1DLCBCT09MKTsKKyAg ICB0eXBlZGVmIEJPT0wgKENBTExCQUNLICpub3RpZnlJTUVQdHIpKEhJTUMsIERXT1JELCBEV09S RCwgRFdPUkQpOworICAgIHR5cGVkZWYgQk9PTCAoQ0FMTEJBQ0sgKmFzc29jaWF0ZUNvbnRleHRF eFB0cikoSFdORCwgSElNQywgRFdPUkQpOworCitwdWJsaWM6CisgICAgZ2V0Q29udGV4dFB0ciBn ZXRDb250ZXh0OworICAgIHJlbGVhc2VDb250ZXh0UHRyIHJlbGVhc2VDb250ZXh0OworICAgIGdl dENvbXBvc2l0aW9uU3RyaW5nUHRyIGdldENvbXBvc2l0aW9uU3RyaW5nOworICAgIHNldENhbmRp ZGF0ZVdpbmRvd1B0ciBzZXRDYW5kaWRhdGVXaW5kb3c7CisgICAgc2V0T3BlblN0YXR1c1B0ciBz ZXRPcGVuU3RhdHVzOworICAgIG5vdGlmeUlNRVB0ciBub3RpZnlJTUU7CisgICAgYXNzb2NpYXRl Q29udGV4dEV4UHRyIGFzc29jaWF0ZUNvbnRleHRFeDsKKworICAgIHN0YXRpYyBjb25zdCBJTU1E aWN0JiBkaWN0KCk7Citwcml2YXRlOgorICAgIElNTURpY3QoKTsKKyAgICBITU9EVUxFIG1faW5z dGFuY2U7Cit9OworCitjb25zdCBJTU1EaWN0JiBJTU1EaWN0OjpkaWN0KCkKK3sKKyAgICBzdGF0 aWMgSU1NRGljdCBpbnN0YW5jZTsKKyAgICByZXR1cm4gaW5zdGFuY2U7Cit9CisKK0lNTURpY3Q6 OklNTURpY3QoKQoreworICAgIG1faW5zdGFuY2UgPSA6OkxvYWRMaWJyYXJ5KFRFWFQoIklNTTMy LkRMTCIpKTsKKyAgICBnZXRDb250ZXh0ID0gcmVpbnRlcnByZXRfY2FzdDxnZXRDb250ZXh0UHRy Pig6OkdldFByb2NBZGRyZXNzKG1faW5zdGFuY2UsICJJbW1HZXRDb250ZXh0IikpOworICAgIEFT U0VSVChnZXRDb250ZXh0KTsKKyAgICByZWxlYXNlQ29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8 cmVsZWFzZUNvbnRleHRQdHI+KDo6R2V0UHJvY0FkZHJlc3MobV9pbnN0YW5jZSwgIkltbVJlbGVh c2VDb250ZXh0IikpOworICAgIEFTU0VSVChyZWxlYXNlQ29udGV4dCk7CisgICAgZ2V0Q29tcG9z aXRpb25TdHJpbmcgPSByZWludGVycHJldF9jYXN0PGdldENvbXBvc2l0aW9uU3RyaW5nUHRyPig6 OkdldFByb2NBZGRyZXNzKG1faW5zdGFuY2UsICJJbW1HZXRDb21wb3NpdGlvblN0cmluZ1ciKSk7 CisgICAgQVNTRVJUKGdldENvbXBvc2l0aW9uU3RyaW5nKTsKKyAgICBzZXRDYW5kaWRhdGVXaW5k b3cgPSByZWludGVycHJldF9jYXN0PHNldENhbmRpZGF0ZVdpbmRvd1B0cj4oOjpHZXRQcm9jQWRk cmVzcyhtX2luc3RhbmNlLCAiSW1tU2V0Q2FuZGlkYXRlV2luZG93IikpOworICAgIEFTU0VSVChz ZXRDYW5kaWRhdGVXaW5kb3cpOworICAgIHNldE9wZW5TdGF0dXMgPSByZWludGVycHJldF9jYXN0 PHNldE9wZW5TdGF0dXNQdHI+KDo6R2V0UHJvY0FkZHJlc3MobV9pbnN0YW5jZSwgIkltbVNldE9w ZW5TdGF0dXMiKSk7CisgICAgQVNTRVJUKHNldE9wZW5TdGF0dXMpOworICAgIG5vdGlmeUlNRSA9 IHJlaW50ZXJwcmV0X2Nhc3Q8bm90aWZ5SU1FUHRyPig6OkdldFByb2NBZGRyZXNzKG1faW5zdGFu Y2UsICJJbW1Ob3RpZnlJTUUiKSk7CisgICAgQVNTRVJUKG5vdGlmeUlNRSk7CisgICAgYXNzb2Np YXRlQ29udGV4dEV4ID0gcmVpbnRlcnByZXRfY2FzdDxhc3NvY2lhdGVDb250ZXh0RXhQdHI+KDo6 R2V0UHJvY0FkZHJlc3MobV9pbnN0YW5jZSwgIkltbUFzc29jaWF0ZUNvbnRleHRFeCIpKTsKKyAg ICBBU1NFUlQoYXNzb2NpYXRlQ29udGV4dEV4KTsKK30KKworSElNQyBXZWJWaWV3OjpnZXRJTU1D b250ZXh0KCkgCit7CisgICAgSElNQyBjb250ZXh0ID0gSU1NRGljdDo6ZGljdCgpLmdldENvbnRl eHQobV93aW5kb3cpOworICAgIHJldHVybiBjb250ZXh0OworfQorCit2b2lkIFdlYlZpZXc6OnJl bGVhc2VJTU1Db250ZXh0KEhJTUMgaElNQykKK3sKKyAgICBpZiAoIWhJTUMpCisgICAgICAgIHJl dHVybjsKKyAgICBJTU1EaWN0OjpkaWN0KCkucmVsZWFzZUNvbnRleHQobV93aW5kb3csIGhJTUMp OworfQorCit2b2lkIFdlYlZpZXc6OnByZXBhcmVDYW5kaWRhdGVXaW5kb3coSElNQyBoSW5wdXRD b250ZXh0KSAKK3sKKyAgICBJbnRSZWN0IGNhcmV0ID0gbV9wYWdlLT5maXJzdFJlY3RGb3JDaGFy YWN0ZXJSYW5nZSgwKTsKKyAgICBDQU5ESURBVEVGT1JNIGZvcm07CisgICAgZm9ybS5kd0luZGV4 ID0gMDsKKyAgICBmb3JtLmR3U3R5bGUgPSBDRlNfRVhDTFVERTsKKyAgICBmb3JtLnB0Q3VycmVu dFBvcy54ID0gY2FyZXQueCgpOworICAgIGZvcm0ucHRDdXJyZW50UG9zLnkgPSBjYXJldC55KCkg KyBjYXJldC5oZWlnaHQoKTsKKyAgICBmb3JtLnJjQXJlYS50b3AgPSBjYXJldC55KCk7CisgICAg Zm9ybS5yY0FyZWEuYm90dG9tID0gY2FyZXQuYm90dG9tKCk7CisgICAgZm9ybS5yY0FyZWEubGVm dCA9IGNhcmV0LngoKTsKKyAgICBmb3JtLnJjQXJlYS5yaWdodCA9IGNhcmV0LnJpZ2h0KCk7Cisg ICAgSU1NRGljdDo6ZGljdCgpLnNldENhbmRpZGF0ZVdpbmRvdyhoSW5wdXRDb250ZXh0LCAmZm9y bSk7Cit9CisKK3ZvaWQgV2ViVmlldzo6cmVzZXRJTUUoKQoreworICAgIGlmIChISU1DIGhJbnB1 dENvbnRleHQgPSBnZXRJTU1Db250ZXh0KCkpIHsKKyAgICAgICAgSU1NRGljdDo6ZGljdCgpLm5v dGlmeUlNRShoSW5wdXRDb250ZXh0LCBOSV9DT01QT1NJVElPTlNUUiwgQ1BTX0NBTkNFTCwgMCk7 CisgICAgICAgIHJlbGVhc2VJTU1Db250ZXh0KGhJbnB1dENvbnRleHQpOworICAgIH0KK30KKwor dm9pZCBXZWJWaWV3OjpzZXRJbnB1dE1ldGhvZFN0YXRlKGJvb2wgZW5hYmxlZCkKK3sKKyAgICBJ TU1EaWN0OjpkaWN0KCkuYXNzb2NpYXRlQ29udGV4dEV4KG1fd2luZG93LCAwLCBlbmFibGVkID8g SUFDRV9ERUZBVUxUIDogMCk7Cit9CisKK3ZvaWQgV2ViVmlldzo6c2VsZWN0aW9uQ2hhbmdlZChi b29sIGlzTm9uZSwgYm9vbCBpc0VkaXRhYmxlLCBib29sIGlzUGFzc3dvcmRGaWVsZCwgYm9vbCBo YXNDb21wb3NpdGlvbikKK3sKKyAgICBtX3NlbGVjdGlvbklzTm9uZSA9IGlzTm9uZTsKKyAgICBt X3NlbGVjdGlvbklzRWRpdGFibGUgPSBpc0VkaXRhYmxlOworICAgIG1fc2VsZWN0aW9uSW5QYXNz d29yZEZpZWxkID0gaXNQYXNzd29yZEZpZWxkOworICAgIG1faGFzTWFya2VkVGV4dCA9IGhhc0Nv bXBvc2l0aW9uOworfQorCit2b2lkIFdlYlZpZXc6OmNvbXBvc2l0aW9uU2VsZWN0aW9uQ2hhbmdl ZChib29sIGhhc0NoYW5nZWQpCit7CisgICAgaWYgKG1faGFzTWFya2VkVGV4dCAmJiAhaGFzQ2hh bmdlZCkKKyAgICAgICAgcmVzZXRJTUUoKTsKK30KKworYm9vbCBXZWJWaWV3OjpvbklNRVN0YXJ0 Q29tcG9zaXRpb24oKQoreworICAgIExPRyhUZXh0SW5wdXQsICJvbklNRVN0YXJ0Q29tcG9zaXRp b24iKTsKKyAgICBtX2luSU1FQ29tcG9zaXRpb24rKzsKKworICAgIEhJTUMgaElucHV0Q29udGV4 dCA9IGdldElNTUNvbnRleHQoKTsKKyAgICBwcmVwYXJlQ2FuZGlkYXRlV2luZG93KGhJbnB1dENv bnRleHQpOworICAgIHJlbGVhc2VJTU1Db250ZXh0KGhJbnB1dENvbnRleHQpOworICAgIHJldHVy biB0cnVlOworfQorCitzdGF0aWMgYm9vbCBnZXRDb21wb3NpdGlvblN0cmluZyhISU1DIGhJbnB1 dENvbnRleHQsIERXT1JEIHR5cGUsIFN0cmluZyYgcmVzdWx0KQoreworICAgIGludCBjb21wb3Np dGlvbkxlbmd0aCA9IElNTURpY3Q6OmRpY3QoKS5nZXRDb21wb3NpdGlvblN0cmluZyhoSW5wdXRD b250ZXh0LCB0eXBlLCAwLCAwKTsKKyAgICBpZiAoY29tcG9zaXRpb25MZW5ndGggPD0gMCkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgIFZlY3RvcjxVQ2hhcj4gY29tcG9zaXRpb25CdWZmZXIo Y29tcG9zaXRpb25MZW5ndGggLyAyKTsKKyAgICBjb21wb3NpdGlvbkxlbmd0aCA9IElNTURpY3Q6 OmRpY3QoKS5nZXRDb21wb3NpdGlvblN0cmluZyhoSW5wdXRDb250ZXh0LCB0eXBlLCAoTFBWT0lE KWNvbXBvc2l0aW9uQnVmZmVyLmRhdGEoKSwgY29tcG9zaXRpb25MZW5ndGgpOworICAgIHJlc3Vs dCA9IFN0cmluZyhjb21wb3NpdGlvbkJ1ZmZlci5kYXRhKCksIGNvbXBvc2l0aW9uTGVuZ3RoIC8g Mik7CisgICAgQVNTRVJUKCFjb21wb3NpdGlvbkxlbmd0aCB8fCBjb21wb3NpdGlvbkJ1ZmZlclsw XSk7CisgICAgQVNTRVJUKCFjb21wb3NpdGlvbkxlbmd0aCB8fCBjb21wb3NpdGlvbkJ1ZmZlcltj b21wb3NpdGlvbkxlbmd0aCAvIDIgLSAxXSk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRp YyB2b2lkIGNvbXBvc2l0aW9uVG9VbmRlcmxpbmVzKGNvbnN0IFZlY3RvcjxEV09SRD4mIGNsYXVz ZXMsIGNvbnN0IFZlY3RvcjxCWVRFPiYgYXR0cmlidXRlcywgVmVjdG9yPENvbXBvc2l0aW9uVW5k ZXJsaW5lPiYgdW5kZXJsaW5lcykKK3sKKyAgICBpZiAoY2xhdXNlcy5pc0VtcHR5KCkpIHsKKyAg ICAgICAgdW5kZXJsaW5lcy5jbGVhcigpOworICAgICAgICByZXR1cm47CisgICAgfQorICAKKyAg ICBjb25zdCBzaXplX3QgbnVtQm91bmRhcmllcyA9IGNsYXVzZXMuc2l6ZSgpIC0gMTsKKyAgICB1 bmRlcmxpbmVzLnJlc2l6ZShudW1Cb3VuZGFyaWVzKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAw OyBpIDwgbnVtQm91bmRhcmllczsgaSsrKSB7CisgICAgICAgIHVuZGVybGluZXNbaV0uc3RhcnRP ZmZzZXQgPSBjbGF1c2VzW2ldOworICAgICAgICB1bmRlcmxpbmVzW2ldLmVuZE9mZnNldCA9IGNs YXVzZXNbaSArIDFdOworICAgICAgICBCWVRFIGF0dHJpYnV0ZSA9IGF0dHJpYnV0ZXNbY2xhdXNl c1tpXV07CisgICAgICAgIHVuZGVybGluZXNbaV0udGhpY2sgPSBhdHRyaWJ1dGUgPT0gQVRUUl9U QVJHRVRfQ09OVkVSVEVEIHx8IGF0dHJpYnV0ZSA9PSBBVFRSX1RBUkdFVF9OT1RDT05WRVJURUQ7 CisgICAgICAgIHVuZGVybGluZXNbaV0uY29sb3IgPSBDb2xvcigwLDAsMCk7CisgICAgfQorfQor CisjaWYgIUxPR19ESVNBQkxFRAorI2RlZmluZSBBUFBFTkRfQVJHVU1FTlRfTkFNRShuYW1lKSBc CisgICAgaWYgKGxwYXJhbSAmIG5hbWUpIHsgXAorICAgICAgICBpZiAobmVlZHNDb21tYSkgXAor ICAgICAgICAgICAgcmVzdWx0ICs9ICIsICI7IFwKKyAgICAgICAgICAgIHJlc3VsdCArPSAjbmFt ZTsgXAorICAgICAgICBuZWVkc0NvbW1hID0gdHJ1ZTsgXAorICAgIH0KKworc3RhdGljIFN0cmlu ZyBpbWVDb21wb3NpdGlvbkFyZ3VtZW50TmFtZXMoTFBBUkFNIGxwYXJhbSkKK3sKKyAgICAvLyBF TlJJQ0EgLSBPSworICAgIFN0cmluZyByZXN1bHQ7CisgICAgYm9vbCBuZWVkc0NvbW1hID0gZmFs c2U7CisgICAgaWYgKGxwYXJhbSAmIEdDU19DT01QQVRUUikgeworICAgICAgICByZXN1bHQgPSAi R0NTX0NPTVBBVFRSIjsKKyAgICAgICAgbmVlZHNDb21tYSA9IHRydWU7CisgICAgfQorICAgIEFQ UEVORF9BUkdVTUVOVF9OQU1FKEdDU19DT01QQ0xBVVNFKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRf TkFNRShHQ1NfQ09NUFJFQURTVFIpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1FKEdDU19DT01Q UkVBREFUVFIpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1FKEdDU19DT01QUkVBRENMQVVTRSk7 CisgICAgQVBQRU5EX0FSR1VNRU5UX05BTUUoR0NTX0NPTVBTVFIpOworICAgIEFQUEVORF9BUkdV TUVOVF9OQU1FKEdDU19DVVJTT1JQT1MpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1FKEdDU19E RUxUQVNUQVJUKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfUkVTVUxUQ0xBVVNFKTsK KyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfUkVTVUxUUkVBRENMQVVTRSk7CisgICAgQVBQ RU5EX0FSR1VNRU5UX05BTUUoR0NTX1JFU1VMVFJFQURTVFIpOworICAgIEFQUEVORF9BUkdVTUVO VF9OQU1FKEdDU19SRVNVTFRTVFIpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1FKENTX0lOU0VS VENIQVIpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1FKENTX05PTU9WRUNBUkVUKTsKKworICAg IHJldHVybiByZXN1bHQ7Cit9CisKK3N0YXRpYyBTdHJpbmcgaW1lTm90aWZpY2F0aW9uTmFtZShX UEFSQU0gd3BhcmFtKQoreworICAgIHN3aXRjaCAod3BhcmFtKSB7CisgICAgY2FzZSBJTU5fQ0hB TkdFQ0FORElEQVRFOgorICAgICAgICByZXR1cm4gIklNTl9DSEFOR0VDQU5ESURBVEUiOworICAg IGNhc2UgSU1OX0NMT1NFQ0FORElEQVRFOgorICAgICAgICByZXR1cm4gIklNTl9DTE9TRUNBTkRJ REFURSI7CisgICAgY2FzZSBJTU5fQ0xPU0VTVEFUVVNXSU5ET1c6CisgICAgICAgIHJldHVybiAi SU1OX0NMT1NFU1RBVFVTV0lORE9XIjsKKyAgICBjYXNlIElNTl9HVUlERUxJTkU6CisgICAgICAg IHJldHVybiAiSU1OX0dVSURFTElORSI7CisgICAgY2FzZSBJTU5fT1BFTkNBTkRJREFURToKKyAg ICAgICAgcmV0dXJuICJJTU5fT1BFTkNBTkRJREFURSI7CisgICAgY2FzZSBJTU5fT1BFTlNUQVRV U1dJTkRPVzoKKyAgICAgICAgcmV0dXJuICJJTU5fT1BFTlNUQVRVU1dJTkRPVyI7CisgICAgY2Fz ZSBJTU5fU0VUQ0FORElEQVRFUE9TOgorICAgICAgICByZXR1cm4gIklNTl9TRVRDQU5ESURBVEVQ T1MiOworICAgIGNhc2UgSU1OX1NFVENPTVBPU0lUSU9ORk9OVDoKKyAgICAgICAgcmV0dXJuICJJ TU5fU0VUQ09NUE9TSVRJT05GT05UIjsKKyAgICBjYXNlIElNTl9TRVRDT01QT1NJVElPTldJTkRP VzoKKyAgICAgICAgcmV0dXJuICJJTU5fU0VUQ09NUE9TSVRJT05XSU5ET1ciOworICAgIGNhc2Ug SU1OX1NFVENPTlZFUlNJT05NT0RFOgorICAgICAgICByZXR1cm4gIklNTl9TRVRDT05WRVJTSU9O TU9ERSI7CisgICAgY2FzZSBJTU5fU0VUT1BFTlNUQVRVUzoKKyAgICAgICAgcmV0dXJuICJJTU5f U0VUT1BFTlNUQVRVUyI7CisgICAgY2FzZSBJTU5fU0VUU0VOVEVOQ0VNT0RFOgorICAgICAgICBy ZXR1cm4gIklNTl9TRVRTRU5URU5DRU1PREUiOworICAgIGNhc2UgSU1OX1NFVFNUQVRVU1dJTkRP V1BPUzoKKyAgICAgICAgcmV0dXJuICJJTU5fU0VUU1RBVFVTV0lORE9XUE9TIjsKKyAgICBkZWZh dWx0OgorICAgICAgICByZXR1cm4gIlVua25vd24gKCIgKyBTdHJpbmc6Om51bWJlcih3cGFyYW0p ICsgIikiOworICAgIH0KK30KKworc3RhdGljIFN0cmluZyBpbWVSZXF1ZXN0TmFtZShXUEFSQU0g d3BhcmFtKQoreworICAgIHN3aXRjaCAod3BhcmFtKSB7CisgICAgY2FzZSBJTVJfQ0FORElEQVRF V0lORE9XOgorICAgICAgICByZXR1cm4gIklNUl9DQU5ESURBVEVXSU5ET1ciOworICAgIGNhc2Ug SU1SX0NPTVBPU0lUSU9ORk9OVDoKKyAgICAgICAgcmV0dXJuICJJTVJfQ09NUE9TSVRJT05GT05U IjsKKyAgICBjYXNlIElNUl9DT01QT1NJVElPTldJTkRPVzoKKyAgICAgICAgcmV0dXJuICJJTVJf Q09NUE9TSVRJT05XSU5ET1ciOworICAgIGNhc2UgSU1SX0NPTkZJUk1SRUNPTlZFUlRTVFJJTkc6 CisgICAgICAgIHJldHVybiAiSU1SX0NPTkZJUk1SRUNPTlZFUlRTVFJJTkciOworICAgIGNhc2Ug SU1SX0RPQ1VNRU5URkVFRDoKKyAgICAgICAgcmV0dXJuICJJTVJfRE9DVU1FTlRGRUVEIjsKKyAg ICBjYXNlIElNUl9RVUVSWUNIQVJQT1NJVElPTjoKKyAgICAgICAgcmV0dXJuICJJTVJfUVVFUllD SEFSUE9TSVRJT04iOworICAgIGNhc2UgSU1SX1JFQ09OVkVSVFNUUklORzoKKyAgICAgICAgcmV0 dXJuICJJTVJfUkVDT05WRVJUU1RSSU5HIjsKKyAgICBkZWZhdWx0OgorICAgICAgICByZXR1cm4g IlVua25vd24gKCIgKyBTdHJpbmc6Om51bWJlcih3cGFyYW0pICsgIikiOworICAgIH0KK30KKyNl bmRpZgorCitib29sIFdlYlZpZXc6Om9uSU1FQ29tcG9zaXRpb24oTFBBUkFNIGxwYXJhbSkKK3sK KyAgICBMT0coVGV4dElucHV0LCAib25JTUVDb21wb3NpdGlvbiAlcyIsIGltZUNvbXBvc2l0aW9u QXJndW1lbnROYW1lcyhscGFyYW0pLmxhdGluMSgpLmRhdGEoKSk7CisgICAgSElNQyBoSW5wdXRD b250ZXh0ID0gZ2V0SU1NQ29udGV4dCgpOworICAgIGlmICghaElucHV0Q29udGV4dCkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAoIW1fc2VsZWN0aW9uSXNFZGl0YWJsZSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisKKyAgICBwcmVwYXJlQ2FuZGlkYXRlV2luZG93KGhJbnB1dENvbnRl eHQpOworCisgICAgaWYgKGxwYXJhbSAmIEdDU19SRVNVTFRTVFIgfHwgIWxwYXJhbSkgeworICAg ICAgICBTdHJpbmcgY29tcG9zaXRpb25TdHJpbmc7CisgICAgICAgIGlmICghZ2V0Q29tcG9zaXRp b25TdHJpbmcoaElucHV0Q29udGV4dCwgR0NTX1JFU1VMVFNUUiwgY29tcG9zaXRpb25TdHJpbmcp ICYmIGxwYXJhbSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAKKyAgICAgICAg bV9wYWdlLT5jb25maXJtQ29tcG9zaXRpb24oY29tcG9zaXRpb25TdHJpbmcpOworICAgIH0gZWxz ZSB7CisgICAgICAgIFN0cmluZyBjb21wb3NpdGlvblN0cmluZzsKKyAgICAgICAgaWYgKCFnZXRD b21wb3NpdGlvblN0cmluZyhoSW5wdXRDb250ZXh0LCBHQ1NfQ09NUFNUUiwgY29tcG9zaXRpb25T dHJpbmcpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIAorICAgICAgICAvLyBD b21wb3NpdGlvbiBzdHJpbmcgYXR0cmlidXRlcworICAgICAgICBpbnQgbnVtQXR0cmlidXRlcyA9 IElNTURpY3Q6OmRpY3QoKS5nZXRDb21wb3NpdGlvblN0cmluZyhoSW5wdXRDb250ZXh0LCBHQ1Nf Q09NUEFUVFIsIDAsIDApOworICAgICAgICBWZWN0b3I8QllURT4gYXR0cmlidXRlcyhudW1BdHRy aWJ1dGVzKTsKKyAgICAgICAgSU1NRGljdDo6ZGljdCgpLmdldENvbXBvc2l0aW9uU3RyaW5nKGhJ bnB1dENvbnRleHQsIEdDU19DT01QQVRUUiwgYXR0cmlidXRlcy5kYXRhKCksIG51bUF0dHJpYnV0 ZXMpOworCisgICAgICAgIC8vIEdldCBjbGF1c2VzCisgICAgICAgIGludCBudW1DbGF1c2VzID0g SU1NRGljdDo6ZGljdCgpLmdldENvbXBvc2l0aW9uU3RyaW5nKGhJbnB1dENvbnRleHQsIEdDU19D T01QQ0xBVVNFLCAwLCAwKTsKKyAgICAgICAgVmVjdG9yPERXT1JEPiBjbGF1c2VzKG51bUNsYXVz ZXMgLyBzaXplb2YoRFdPUkQpKTsKKyAgICAgICAgSU1NRGljdDo6ZGljdCgpLmdldENvbXBvc2l0 aW9uU3RyaW5nKGhJbnB1dENvbnRleHQsIEdDU19DT01QQ0xBVVNFLCBjbGF1c2VzLmRhdGEoKSwg bnVtQ2xhdXNlcyk7CisKKyAgICAgICAgVmVjdG9yPENvbXBvc2l0aW9uVW5kZXJsaW5lPiB1bmRl cmxpbmVzOworICAgICAgICBjb21wb3NpdGlvblRvVW5kZXJsaW5lcyhjbGF1c2VzLCBhdHRyaWJ1 dGVzLCB1bmRlcmxpbmVzKTsKKworICAgICAgICBpbnQgY3Vyc29yUG9zaXRpb24gPSBMT1dPUkQo SU1NRGljdDo6ZGljdCgpLmdldENvbXBvc2l0aW9uU3RyaW5nKGhJbnB1dENvbnRleHQsIEdDU19D VVJTT1JQT1MsIDAsIDApKTsKKworICAgICAgICBtX3BhZ2UtPnNldENvbXBvc2l0aW9uKGNvbXBv c2l0aW9uU3RyaW5nLCB1bmRlcmxpbmVzLCBjdXJzb3JQb3NpdGlvbik7CisgICAgfQorCisgICAg cmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgV2ViVmlldzo6b25JTUVFbmRDb21wb3NpdGlvbigpCit7 CisgICAgTE9HKFRleHRJbnB1dCwgIm9uSU1FRW5kQ29tcG9zaXRpb24iKTsKKyAgICAvLyBJZiB0 aGUgY29tcG9zaXRpb24gaGFzbid0IGJlZW4gY29uZmlybWVkIHlldCwgaXQgbmVlZHMgdG8gYmUg Y2FuY2VsbGVkLgorICAgIC8vIFRoaXMgaGFwcGVucyBhZnRlciBkZWxldGluZyB0aGUgbGFzdCBj aGFyYWN0ZXIgZnJvbSBpbmxpbmUgaW5wdXQgaG9sZS4KKyAgICBpZiAobV9oYXNNYXJrZWRUZXh0 KQorICAgICAgICBtX3BhZ2UtPmNvbmZpcm1Db21wb3NpdGlvbihTdHJpbmcoKSk7CisKKyAgICBp ZiAobV9pbklNRUNvbXBvc2l0aW9uKQorICAgICAgICBtX2luSU1FQ29tcG9zaXRpb24tLTsKKwor ICAgIHJldHVybiB0cnVlOworfQorCitib29sIFdlYlZpZXc6Om9uSU1FQ2hhcihXUEFSQU0gd3Bh cmFtLCBMUEFSQU0gbHBhcmFtKQoreworICAgIFVOVVNFRF9QQVJBTSh3cGFyYW0pOworICAgIFVO VVNFRF9QQVJBTShscGFyYW0pOworICAgIExPRyhUZXh0SW5wdXQsICJvbklNRUNoYXIgVSslMDRY ICUwOFgiLCB3cGFyYW0sIGxwYXJhbSk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgV2Vi Vmlldzo6b25JTUVOb3RpZnkoV1BBUkFNIHdwYXJhbSwgTFBBUkFNLCBMUkVTVUxUKikKK3sKKyAg ICBVTlVTRURfUEFSQU0od3BhcmFtKTsKKyAgICBMT0coVGV4dElucHV0LCAib25JTUVOb3RpZnkg JXMiLCBpbWVOb3RpZmljYXRpb25OYW1lKHdwYXJhbSkubGF0aW4xKCkuZGF0YSgpKTsKKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK0xSRVNVTFQgV2ViVmlldzo6b25JTUVSZXF1ZXN0Q2hhclBvc2l0 aW9uKElNRUNIQVJQT1NJVElPTiogY2hhclBvcykKK3sKKyAgICBpZiAoY2hhclBvcy0+ZHdDaGFy UG9zICYmICFtX2hhc01hcmtlZFRleHQpCisgICAgICAgIHJldHVybiAwOworICAgIEludFJlY3Qg Y2FyZXQgPSBtX3BhZ2UtPmZpcnN0UmVjdEZvckNoYXJhY3RlclJhbmdlKGNoYXJQb3MtPmR3Q2hh clBvcyk7CisgICAgY2hhclBvcy0+cHQueCA9IGNhcmV0LngoKTsKKyAgICBjaGFyUG9zLT5wdC55 ID0gY2FyZXQueSgpOworICAgIDo6Q2xpZW50VG9TY3JlZW4obV93aW5kb3csICZjaGFyUG9zLT5w dCk7CisgICAgY2hhclBvcy0+Y0xpbmVIZWlnaHQgPSBjYXJldC5oZWlnaHQoKTsKKyAgICA6Okdl dFdpbmRvd1JlY3QobV93aW5kb3csICZjaGFyUG9zLT5yY0RvY3VtZW50KTsKKyAgICByZXR1cm4g dHJ1ZTsKK30KKworTFJFU1VMVCBXZWJWaWV3OjpvbklNRVJlcXVlc3RSZWNvbnZlcnRTdHJpbmco UkVDT05WRVJUU1RSSU5HKiByZWNvbnZlcnRTdHJpbmcpCit7CisgICAgU3RyaW5nIHRleHQgPSBt X3BhZ2UtPmdldFNlbGVjdGVkVGV4dCgpOworICAgIGlmICghcmVjb252ZXJ0U3RyaW5nKQorICAg ICAgICByZXR1cm4gc2l6ZW9mKFJFQ09OVkVSVFNUUklORykgKyB0ZXh0Lmxlbmd0aCgpICogc2l6 ZW9mKFVDaGFyKTsKKworICAgIHVuc2lnbmVkIHRvdGFsU2l6ZSA9IHNpemVvZihSRUNPTlZFUlRT VFJJTkcpICsgdGV4dC5sZW5ndGgoKSAqIHNpemVvZihVQ2hhcik7CisgICAgaWYgKHRvdGFsU2l6 ZSA+IHJlY29udmVydFN0cmluZy0+ZHdTaXplKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZWNv bnZlcnRTdHJpbmctPmR3Q29tcFN0ckxlbiA9IHRleHQubGVuZ3RoKCk7CisgICAgcmVjb252ZXJ0 U3RyaW5nLT5kd1N0ckxlbiA9IHRleHQubGVuZ3RoKCk7CisgICAgcmVjb252ZXJ0U3RyaW5nLT5k d1RhcmdldFN0ckxlbiA9IHRleHQubGVuZ3RoKCk7CisgICAgcmVjb252ZXJ0U3RyaW5nLT5kd1N0 ck9mZnNldCA9IHNpemVvZihSRUNPTlZFUlRTVFJJTkcpOworICAgIG1lbWNweShyZWNvbnZlcnRT dHJpbmcgKyAxLCB0ZXh0LmNoYXJhY3RlcnMoKSwgdGV4dC5sZW5ndGgoKSAqIHNpemVvZihVQ2hh cikpOworICAgIHJldHVybiB0b3RhbFNpemU7Cit9CisKK0xSRVNVTFQgV2ViVmlldzo6b25JTUVS ZXF1ZXN0KFdQQVJBTSByZXF1ZXN0LCBMUEFSQU0gZGF0YSkKK3sKKyAgICBMT0coVGV4dElucHV0 LCAib25JTUVSZXF1ZXN0ICVzIiwgaW1lUmVxdWVzdE5hbWUocmVxdWVzdCkubGF0aW4xKCkuZGF0 YSgpKTsKKyAgICBpZiAoIW1fc2VsZWN0aW9uSXNFZGl0YWJsZSkKKyAgICAgICAgcmV0dXJuIDA7 CisKKyAgICBzd2l0Y2ggKHJlcXVlc3QpIHsKKyAgICAgICAgY2FzZSBJTVJfUkVDT05WRVJUU1RS SU5HOgorICAgICAgICAgICAgcmV0dXJuIG9uSU1FUmVxdWVzdFJlY29udmVydFN0cmluZygoUkVD T05WRVJUU1RSSU5HKilkYXRhKTsKKworICAgICAgICBjYXNlIElNUl9RVUVSWUNIQVJQT1NJVElP TjoKKyAgICAgICAgICAgIHJldHVybiBvbklNRVJlcXVlc3RDaGFyUG9zaXRpb24oKElNRUNIQVJQ T1NJVElPTiopZGF0YSk7CisgICAgfQorICAgIHJldHVybiAwOworfQorCitib29sIFdlYlZpZXc6 Om9uSU1FU2VsZWN0KFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCit7CisgICAgVU5VU0VE X1BBUkFNKHdwYXJhbSk7CisgICAgVU5VU0VEX1BBUkFNKGxwYXJhbSk7CisgICAgTE9HKFRleHRJ bnB1dCwgIm9uSU1FU2VsZWN0IGxvY2FsZSAlbGQgJXMiLCBscGFyYW0sIHdwYXJhbSA/ICJzZWxl Y3QiIDogImRlc2VsZWN0Iik7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYlZpZXc6 Om9uSU1FU2V0Q29udGV4dChXUEFSQU0gd3BhcmFtLCBMUEFSQU0pCiB7Ci0gICAgLy8gRklYTUU6 IEltcGxlbWVudC4KKyAgICBMT0coVGV4dElucHV0LCAib25JTUVTZXRDb250ZXh0ICVzIiwgd3Bh cmFtID8gImFjdGl2ZSIgOiAiaW5hY3RpdmUiKTsKKyAgICByZXR1cm4gZmFsc2U7CiB9CiAKIHZv aWQgV2ViVmlldzo6ZGlkTm90SGFuZGxlS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRF dmVudCYgZXZlbnQpCkluZGV4OiBXZWJLaXQyL1VJUHJvY2Vzcy93aW4vV2ViVmlldy5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdDIvVUlQcm9jZXNzL3dpbi9XZWJWaWV3LmgJKHJldmlzaW9uIDc0MDQy KQorKysgV2ViS2l0Mi9VSVByb2Nlc3Mvd2luL1dlYlZpZXcuaAkod29ya2luZyBjb3B5KQpAQCAt NzcsNiArNzcsMjEgQEAgcHJpdmF0ZToKICAgICBMUkVTVUxUIG9uVGltZXJFdmVudChIV05EIGhX bmQsIFVJTlQgbWVzc2FnZSwgV1BBUkFNLCBMUEFSQU0sIGJvb2wmIGhhbmRsZWQpOwogICAgIExS RVNVTFQgb25TaG93V2luZG93RXZlbnQoSFdORCBoV25kLCBVSU5UIG1lc3NhZ2UsIFdQQVJBTSwg TFBBUkFNLCBib29sJiBoYW5kbGVkKTsKICAgICBMUkVTVUxUIG9uU2V0Q3Vyc29yKEhXTkQgaFdu ZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0sIExQQVJBTSwgYm9vbCYgaGFuZGxlZCk7CisgICAgYm9v bCBvbklNRVN0YXJ0Q29tcG9zaXRpb24oKTsKKyAgICBib29sIG9uSU1FQ29tcG9zaXRpb24oTFBB UkFNKTsKKyAgICBib29sIG9uSU1FRW5kQ29tcG9zaXRpb24oKTsKKyAgICBib29sIG9uSU1FQ2hh cihXUEFSQU0sIExQQVJBTSk7CisgICAgYm9vbCBvbklNRU5vdGlmeShXUEFSQU0sIExQQVJBTSwg TFJFU1VMVCopOworICAgIExSRVNVTFQgb25JTUVSZXF1ZXN0KFdQQVJBTSwgTFBBUkFNKTsKKyAg ICBib29sIG9uSU1FU2VsZWN0KFdQQVJBTSwgTFBBUkFNKTsKKyAgICBib29sIG9uSU1FU2V0Q29u dGV4dChXUEFSQU0sIExQQVJBTSk7CisgICAgdm9pZCByZXNldElNRSgpOworICAgIHZvaWQgc2V0 SW5wdXRNZXRob2RTdGF0ZShib29sKTsKKyAgICBISU1DIGdldElNTUNvbnRleHQoKTsKKyAgICB2 b2lkIHJlbGVhc2VJTU1Db250ZXh0KEhJTUMpOworICAgIHZvaWQgcHJlcGFyZUNhbmRpZGF0ZVdp bmRvdyhISU1DKTsKKyAgICBMUkVTVUxUIG9uSU1FUmVxdWVzdENoYXJQb3NpdGlvbihJTUVDSEFS UE9TSVRJT04qKTsKKyAgICBMUkVTVUxUIG9uSU1FUmVxdWVzdFJlY29udmVydFN0cmluZyhSRUNP TlZFUlRTVFJJTkcqKTsKIAogICAgIGJvb2wgaXNBY3RpdmUoKTsKICAgICB2b2lkIHVwZGF0ZUFj dGl2ZVN0YXRlKCk7CkBAIC0xMDUsNiArMTIwLDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIFdl YkNvcmU6OkZsb2F0UmVjdCBjb252ZXJ0VG9Vc2VyU3BhY2UoY29uc3QgV2ViQ29yZTo6RmxvYXRS ZWN0Jik7CiAgICAgdmlydHVhbCB2b2lkIGRpZE5vdEhhbmRsZUtleUV2ZW50KGNvbnN0IE5hdGl2 ZVdlYktleWJvYXJkRXZlbnQmKTsKICAgICB2aXJ0dWFsIHZvaWQgc2VsZWN0aW9uQ2hhbmdlZChi b29sLCBib29sLCBib29sLCBib29sKTsKKyAgICB2aXJ0dWFsIHZvaWQgY29tcG9zaXRpb25TZWxl Y3Rpb25DaGFuZ2VkKGJvb2wpOwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxXZWJQb3B1cE1lbnVQ cm94eT4gY3JlYXRlUG9wdXBNZW51UHJveHkoKTsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8V2Vi Q29udGV4dE1lbnVQcm94eT4gY3JlYXRlQ29udGV4dE1lbnVQcm94eShXZWJQYWdlUHJveHkqKTsK ICAgICB2aXJ0dWFsIHZvaWQgc2V0RmluZEluZGljYXRvcihQYXNzUmVmUHRyPEZpbmRJbmRpY2F0 b3I+LCBib29sIGZhZGVPdXQpOwpAQCAtMTIzLDYgKzEzOSwxMyBAQCBwcml2YXRlOgogICAgIC8v IFdlYkNvcmU6OldpbmRvd01lc3NhZ2VMaXN0ZW5lcgogICAgIHZpcnR1YWwgdm9pZCB3aW5kb3dS ZWNlaXZlZE1lc3NhZ2UoSFdORCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0sIExQQVJBTSk7CiAKKyAg ICAvLyBUZXh0IGlucHV0IHN0YXRlIHZhbHVlcworICAgIGJvb2wgbV9zZWxlY3Rpb25Jc05vbmU7 CisgICAgYm9vbCBtX3NlbGVjdGlvbklzRWRpdGFibGU7CisgICAgYm9vbCBtX3NlbGVjdGlvbklu UGFzc3dvcmRGaWVsZDsKKyAgICBib29sIG1faGFzTWFya2VkVGV4dDsKKyAgICB1bnNpZ25lZCBt X2luSU1FQ29tcG9zaXRpb247CisKICAgICBSRUNUIG1fcmVjdDsKICAgICBIV05EIG1fd2luZG93 OwogICAgIEhXTkQgbV90b3BMZXZlbFBhcmVudFdpbmRvdzsKSW5kZXg6IFdlYktpdDIvV2ViUHJv Y2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJFZGl0b3JDbGllbnQuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJFZGl0b3JDbGllbnQuY3BwCShyZXZp c2lvbiA3NDA0MikKKysrIFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJFZGl0 b3JDbGllbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xODYsNyArMTg2LDE1IEBAIHZvaWQgV2Vi RWRpdG9yQ2xpZW50OjpyZXNwb25kVG9DaGFuZ2VkU2UKICAgICBGcmFtZSogZnJhbWUgPSBtX3Bh Z2UtPmNvcmVQYWdlKCktPmZvY3VzQ29udHJvbGxlcigpLT5mb2N1c2VkRnJhbWUoKTsKICAgICBp ZiAoIWZyYW1lKQogICAgICAgICByZXR1cm47CisKICAgICBtX3BhZ2UtPnNlbmQoTWVzc2FnZXM6 OldlYlBhZ2VQcm94eTo6RGlkU2VsZWN0aW9uQ2hhbmdlKGZyYW1lLT5zZWxlY3Rpb24oKS0+aXNO b25lKCksIGZyYW1lLT5zZWxlY3Rpb24oKS0+aXNDb250ZW50RWRpdGFibGUoKSwgZnJhbWUtPnNl bGVjdGlvbigpLT5pc0luUGFzc3dvcmRGaWVsZCgpLCBmcmFtZS0+ZWRpdG9yKCktPmhhc0NvbXBv c2l0aW9uKCkpKTsKKworICAgIGlmICghZnJhbWUtPmVkaXRvcigpLT5oYXNDb21wb3NpdGlvbigp IHx8IGZyYW1lLT5lZGl0b3IoKS0+aWdub3JlQ29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2UoKSkK KyAgICAgICAgcmV0dXJuOworCisgICAgdW5zaWduZWQgc3RhcnQ7CisgICAgdW5zaWduZWQgZW5k OworICAgIG1fcGFnZS0+c2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpEaWRDb21wb3NpdGlv blNlbGVjdGlvbkNoYW5nZShmcmFtZS0+ZWRpdG9yKCktPmdldENvbXBvc2l0aW9uU2VsZWN0aW9u KHN0YXJ0LCBlbmQpKSk7CiB9CiAjZW5kaWYKICAgICAKSW5kZXg6IFdlYktpdDIvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdDIvV2ViUHJvY2Vzcy9X ZWJQYWdlL1dlYlBhZ2UuY3BwCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYlBhZ2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDE2LDYgKzEwMTYsNDIg QEAgYm9vbCBXZWJQYWdlOjpoYW5kbGVFZGl0aW5nS2V5Ym9hcmRFdmVudAogCiAgICAgcmV0dXJu IGZyYW1lLT5lZGl0b3IoKS0+aW5zZXJ0VGV4dChldnQtPmtleUV2ZW50KCktPnRleHQoKSwgZXZ0 KTsKIH0KKwordm9pZCBXZWJQYWdlOjpjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiBj b21wb3NpdGlvblN0cmluZykKK3sKKyAgICBGcmFtZSogZnJhbWUgPSBtX3BhZ2UtPmZvY3VzQ29u dHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lIHx8ICFmcmFt ZS0+ZWRpdG9yKCktPmNhbkVkaXQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGZyYW1lLT5lZGl0 b3IoKS0+Y29uZmlybUNvbXBvc2l0aW9uKGNvbXBvc2l0aW9uU3RyaW5nKTsKK30KKwordm9pZCBX ZWJQYWdlOjpzZXRDb21wb3NpdGlvbihjb25zdCBTdHJpbmcmIGNvbXBvc2l0aW9uU3RyaW5nLCBj b25zdCBWZWN0b3I8V2ViQ29yZTo6Q29tcG9zaXRpb25VbmRlcmxpbmU+JiB1bmRlcmxpbmVzLCB1 aW50NjRfdCBjdXJzb3JQb3NpdGlvbikKK3sKKyAgICBGcmFtZSogZnJhbWUgPSBtX3BhZ2UtPmZv Y3VzQ29udHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBpZiAoIWZyYW1lIHx8 ICFmcmFtZS0+ZWRpdG9yKCktPmNhbkVkaXQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGZyYW1l LT5lZGl0b3IoKS0+c2V0Q29tcG9zaXRpb24oY29tcG9zaXRpb25TdHJpbmcsIHVuZGVybGluZXMs IGN1cnNvclBvc2l0aW9uLCAwKTsKK30KKwordm9pZCBXZWJQYWdlOjpmaXJzdFJlY3RGb3JDaGFy YWN0ZXJSYW5nZShjb25zdCB1aW50NjRfdCBjaGFyYWN0ZXJQb3NpdGlvbiwgV2ViQ29yZTo6SW50 UmVjdCYgcmVzdWx0UmVjdCkKK3sKKyAgICBGcmFtZSogZnJhbWUgPSBtX3BhZ2UtPmZvY3VzQ29u dHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBJbnRSZWN0IHJlY3Q7CisgICAg aWYgKFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBmcmFtZS0+ZWRpdG9yKCktPmhhc0NvbXBvc2l0aW9u KCkgPyBmcmFtZS0+ZWRpdG9yKCktPmNvbXBvc2l0aW9uUmFuZ2UoKSA6IGZyYW1lLT5zZWxlY3Rp b24oKS0+c2VsZWN0aW9uKCkudG9Ob3JtYWxpemVkUmFuZ2UoKSkgeworICAgICAgICBFeGNlcHRp b25Db2RlIGVjID0gMDsKKyAgICAgICAgUmVmUHRyPFJhbmdlPiB0ZW1wUmFuZ2UgPSByYW5nZS0+ Y2xvbmVSYW5nZShlYyk7CisgICAgICAgIHRlbXBSYW5nZS0+c2V0U3RhcnQodGVtcFJhbmdlLT5z dGFydENvbnRhaW5lcihlYyksIHRlbXBSYW5nZS0+c3RhcnRPZmZzZXQoZWMpICsgY2hhcmFjdGVy UG9zaXRpb24sIGVjKTsKKyAgICAgICAgcmVjdCA9IGZyYW1lLT5lZGl0b3IoKS0+Zmlyc3RSZWN0 Rm9yUmFuZ2UodGVtcFJhbmdlLmdldCgpKTsKKyAgICB9CisgICAgcmVzdWx0UmVjdCA9IGZyYW1l LT52aWV3KCktPmNvbnRlbnRzVG9XaW5kb3cocmVjdCk7Cit9CisKK3ZvaWQgV2ViUGFnZTo6Z2V0 U2VsZWN0ZWRUZXh0KFN0cmluZyYgdGV4dCkKK3sKKyAgICBGcmFtZSogZnJhbWUgPSBtX3BhZ2Ut PmZvY3VzQ29udHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBSZWZQdHI8UmFu Z2U+IHNlbGVjdGVkUmFuZ2UgPSBmcmFtZS0+c2VsZWN0aW9uKCktPnRvTm9ybWFsaXplZFJhbmdl KCk7CisgICAgdGV4dCA9IHNlbGVjdGVkUmFuZ2UtPnRleHQoKTsKK30KICNlbmRpZgogICAgIAog V2ViRWRpdENvbW1hbmQqIFdlYlBhZ2U6OndlYkVkaXRDb21tYW5kKHVpbnQ2NF90IGNvbW1hbmRJ RCkKSW5kZXg6IFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHJldmlzaW9uIDc0MDQy KQorKysgV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCSh3b3JraW5nIGNvcHkp CkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAiUGx1Z2luLmgiCiAjaW5jbHVkZSAiU2FuZGJv eEV4dGVuc2lvbi5oIgogI2luY2x1ZGUgIldlYkVkaXRDb21tYW5kLmgiCisjaW5jbHVkZSA8V2Vi Q29yZS9FZGl0b3IuaD4KICNpbmNsdWRlIDxXZWJDb3JlL0ZyYW1lTG9hZGVyVHlwZXMuaD4KICNp bmNsdWRlIDxXZWJDb3JlL0ludFJlY3QuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgpAQCAt MjQ0LDYgKzI0NSwxMSBAQCBwdWJsaWM6CiAgICAgdm9pZCBjaGFyYWN0ZXJJbmRleEZvclBvaW50 KGNvbnN0IFdlYkNvcmU6OkludFBvaW50IHBvaW50LCB1aW50NjRfdCYgcmVzdWx0KTsKICAgICB2 b2lkIGZpcnN0UmVjdEZvckNoYXJhY3RlclJhbmdlKHVpbnQ2NF90IGxvY2F0aW9uLCB1aW50NjRf dCBsZW5ndGgsIFdlYkNvcmU6OkludFJlY3QmIHJlc3VsdFJlY3QpOwogICAgIHN0YXRpYyB2b2lk IGNvbnZlcnRSYW5nZVRvUGxhdGZvcm1SYW5nZShXZWJDb3JlOjpGcmFtZSogZnJhbWUsIFdlYkNv cmU6OlJhbmdlICpyYW5nZSwgdWludDY0X3QmIGxvY2F0aW9uLCB1aW50NjRfdCYgbGVuZ3RoKTsK KyNlbHNlCisgICAgdm9pZCBjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiBjb21wb3Np dGlvblN0cmluZyk7CisgICAgdm9pZCBzZXRDb21wb3NpdGlvbihjb25zdCBXVEY6OlN0cmluZyYg Y29tcG9zaXRpb25TdHJpbmcsIGNvbnN0IFdURjo6VmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9u VW5kZXJsaW5lPiYgdW5kZXJsaW5lcywgdWludDY0X3QgY3Vyc29yUG9zaXRpb24pOworICAgIHZv aWQgZmlyc3RSZWN0Rm9yQ2hhcmFjdGVyUmFuZ2UoY29uc3QgdWludDY0X3QgY2hhcmFjdGVyUG9z aXRpb24sIFdlYkNvcmU6OkludFJlY3QmIHJlc3VsdFJlY3QpOworICAgIHZvaWQgZ2V0U2VsZWN0 ZWRUZXh0KFdURjo6U3RyaW5nJik7CiAjZW5kaWYKICAgICB2b2lkIGR1bW15KGJvb2wmKTsKIApJ bmRleDogV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmlu CShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2Uu bWVzc2FnZXMuaW4JKHdvcmtpbmcgY29weSkKQEAgLTEwMCw5ICsxMDAsMTIgQEAgbWVzc2FnZXMg LT4gV2ViUGFnZSB7CiAgICAgQ2hhcmFjdGVySW5kZXhGb3JQb2ludChXZWJDb3JlOjpJbnRQb2lu dCBwb2ludCkgLT4gKHVpbnQ2NF90IHJlc3VsdCkKICAgICBGaXJzdFJlY3RGb3JDaGFyYWN0ZXJS YW5nZSh1aW50NjRfdCBsb2NhdGlvbiwgdWludDY0X3QgbGVuZ3RoKSAtPiAoV2ViQ29yZTo6SW50 UmVjdCByZXN1bHRSZWN0KQogI2VuZGlmCi0JLy8gVGhpcyBpcyBhIGR1bW15IG1lc3NhZ2UgdG8g YXZvaWQgYnJlYWtpbmcgdGhlIGJ1aWxkIGZvciBwbGF0Zm9ybXMgdGhhdCBkb24ndCByZXF1aXJl IAotCS8vIHN5bmNocm9ub3VzIG1lc3NhZ2VzLgotCUR1bW15KCkgLT4gKGJvb2wgZHVtbXlSZXR1 cm4pCisjaWYgIVBMQVRGT1JNKE1BQykKKyAgICBDb25maXJtQ29tcG9zaXRpb24oV1RGOjpTdHJp bmcgY29tcG9zaXRpb25TdHJpbmcpCisgICAgU2V0Q29tcG9zaXRpb24oV1RGOjpTdHJpbmcgY29t cG9zaXRpb25TdHJpbmcsIFdURjo6VmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5l PiB1bmRlcmxpbmVzLCB1aW50NjRfdCBjdXJzb3JQb3NpdGlvbikKKyAgICBGaXJzdFJlY3RGb3JD aGFyYWN0ZXJSYW5nZSh1aW50NjRfdCBjaGFyYWN0ZXJQb3NpdGlvbikgLT4gKFdlYkNvcmU6Oklu dFJlY3QgcmVzdWx0UmVjdCkKKyAgICBHZXRTZWxlY3RlZFRleHQoKSAtPiAoV1RGOjpTdHJpbmcg dGV4dCkKKyNlbmRpZgogI2lmIFBMQVRGT1JNKFFUKQogICAgIEZpbmRab29tYWJsZUFyZWFGb3JQ b2ludChXZWJDb3JlOjpJbnRQb2ludCBwb2ludCkKICNlbmRpZgo= 76600 2010-12-14 17:34:06 -0800 2010-12-15 15:32:30 -0800 Patch2 ime-win.txt text/plain 27434 enrica SW5kZXg6IFdlYktpdDIvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdDIvQ2hhbmdlTG9n CShyZXZpc2lvbiA3NDA3NSkKKysrIFdlYktpdDIvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDkgQEAKKzIwMTAtMTItMTQgIEVucmljYSBDYXN1Y2NpICA8ZW5yaWNhQGFwcGxl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB ZGQgSU1FIHN1cHBvcnQgdG8gV2ViS2l0MiBvbiBXaW5kb3dzCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MTA0OQorICAgICAgICBUaGUgaW1wbGVtZW50 YXRpb24gaXMgdmVyeSBjbG9zZSB0byB0aGUgb25lIGluIFdlYktpdC4KKyAgICAgICAgVGhlIG1h aW4gY2hhbmdlIGlzIHRoZSBhZGRpdGlvbiBvZiBoYW5kbGVycyBmb3IgV01fSU1FX1NUQVJUQ09N UE9TSVRJT04sCisgICAgICAgIFdNX0lNRV9SRVFVRVNULCBXTV9JTUVfQ09NUE9TSVRJT04sIFdN X0lNRV9FTkRDT01QT1NJVElPTiwKKyAgICAgICAgV01fSU1FX1NFTEVDVCwgV01fSU1FX1NFVENP TlRFWFQgYW5kIGEgbnVtYmVyIG9mIG5ldyBtZXNzYWdlcworICAgICAgICBiZXR3ZWVuIHRoZSBV SSBwcm9jZXNzIGFuZCB0aGUgV2ViUHJvY2VzcyB0byBzZW5kL3JldHJpZXZlCisgICAgICAgIHRo ZSBkYXRhIGJlaW5nIGhhbmRsZWQgYnkgdGhlIG1lc3NhZ2VzIGxpc3RlZCBhYm92ZS4KKworICAg ICAgICAqIFVJUHJvY2Vzcy9QYWdlQ2xpZW50Lmg6IEFkZGVkIGNvbXBvc2l0aW9uU2VsZWN0aW9u Q2hhbmdlZCBmb3IgV2luZG93cyBwbGF0Zm9ybS4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcDoKKyAgICAgICAgVGhlIGZvbGxvd2luZyBtZXRob2RzIHNlbmQgc3luY2hyb25v dXMgbWVzc2FnZXMgdG8gdGhlIFdlYlByb2Nlc3MuCisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQ cm94eTo6Zmlyc3RSZWN0Rm9yQ2hhcmFjdGVySW5TZWxlY3RlZFJhbmdlKTogUmV0cmlldmVzIHRo ZSByZWN0YW5nbGUgdG8gcG9zaXRpb24KKyAgICAgICAgdGhlIGNuYWRpZGF0ZXMgd2luZG93Lgor ICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmdldFNlbGVjdGVkVGV4dCk6IFJldHJpZXZl cyB0aGUgY3VycmVudGx5IHNlbGVjdGVkIHRleHQuCisgICAgICAgIFRoZSBmb2xsb3dpbmYgbWV0 aG9kcyBzZW5kIGFzeW5jaHJvbm91cyBtZXNzYWdlcyB0byB0aGUgV2ViUHJvY2Vzcy4KKyAgICAg ICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpjb25maXJtQ29tcG9zaXRpb24pOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlUHJveHk6OnNldENvbXBvc2l0aW9uKToKKyAgICAgICAgKFdlYktpdDo6 V2ViUGFnZVByb3h5OjpkaWRDaGFuZ2VTZWxlY3Rpb24pOiBOYW1lIGNoYW5nZWQuCisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6ZGlkQ2hhbmdlQ29tcG9zaXRpb25TZWxlY3Rpb24pOiBD YWxsZWQgd2hlbiB0aGVyZSBpcyBhIGNoYW5nZQorICAgICAgICBpbiB0aGUgY29tcG9zaXRpb24g c2VsZWN0aW9uLgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2FnZXMuaW46 IEFkZGVkIG1lc3NhZ2VzIGNvcnJlc3BvbmRpbmcgdG8gdGhlIG1ldGhvZHMgYWJvdmUuCisgICAg ICAgICogVUlQcm9jZXNzL3dpbi9XZWJWaWV3LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmll dzo6d25kUHJvYyk6IEFkZGVkIGhhbmRsaW5nIG9mIG1lc3NhZ2VzIGZvciBJTUUuCisgICAgICAg IFRoZSBmb2xsb3dpbmcgYXJlIHRoZSBoYW5kbGVycyBmb3IgdGhlIHdpbmRvdyBtZXNzYWdlIGJl aW5nIHNlbnQgZHVyaW5nIGNvbXBvc2l0aW9uLgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3Ojpv bklNRUNvbXBvc2l0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6b25JTUVFbmRDb21w b3NpdGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6Om9uSU1FUmVxdWVzdENoYXJQb3Np dGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6Om9uSU1FUmVxdWVzdFJlY29udmVydFN0 cmluZyk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6Om9uSU1FUmVxdWVzdCk6CisgICAgICAg IChXZWJLaXQ6OldlYlZpZXc6Om9uSU1FU2VsZWN0KToKKyAgICAgICAgKFdlYktpdDo6V2ViVmll dzo6b25JTUVTZXRDb250ZXh0KToKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYkVkaXRvckNsaWVudC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkVkaXRvckNsaWVudDo6 cmVzcG9uZFRvQ2hhbmdlZFNlbGVjdGlvbik6IEFkZGVkIG5vdGlmaWNhdGlvbgorICAgICAgICBv ZiBjb21wb3NpdGlvbiBzZWxlY3Rpb24gY2hhbmdlZCBmb3IgV2luZG93cy4KKyAgICAgICAgKiBX ZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5jcHA6CisgICAgICAgIFRoZSBmb2xsb3dpbmcgYXJl IHRoZSBXZWJQcm9jZXNzIGNvdW50ZXJwYXJ0cyBvZiB0aGUgbmV3IG1lc3NhZ2VzLgorICAgICAg ICAoV2ViS2l0OjpXZWJQYWdlOjpjb25maXJtQ29tcG9zaXRpb24pOgorICAgICAgICAoV2ViS2l0 OjpXZWJQYWdlOjpzZXRDb21wb3NpdGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2U6OmZp cnN0UmVjdEZvckNoYXJhY3RlckluU2VsZWN0ZWRSYW5nZSk6CisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2U6OmdldFNlbGVjdGVkVGV4dCk6CisKIDIwMTAtMTItMTQgIEFuZGVycyBDYXJsc3NvbiAg PGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJ bmRleDogV2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAkocmV2aXNpb24gNzQwNDIpCisrKyBXZWJLaXQyL1VJ UHJvY2Vzcy9QYWdlQ2xpZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTc0LDYgKzc0LDkgQEAgcHVi bGljOgogI2Vsc2UKICAgICB2aXJ0dWFsIHZvaWQgc2VsZWN0aW9uQ2hhbmdlZChib29sLCBib29s LCBib29sLCBib29sKSA9IDA7CiAjZW5kaWYKKyNpZiBQTEFURk9STShXSU4pCisgICAgdmlydHVh bCB2b2lkIGNvbXBvc2l0aW9uU2VsZWN0aW9uQ2hhbmdlZChib29sKSA9IDA7CisjZW5kaWYKICAg ICB2aXJ0dWFsIFdlYkNvcmU6OkZsb2F0UmVjdCBjb252ZXJ0VG9EZXZpY2VTcGFjZShjb25zdCBX ZWJDb3JlOjpGbG9hdFJlY3QmKSA9IDA7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpGbG9hdFJlY3Qg Y29udmVydFRvVXNlclNwYWNlKGNvbnN0IFdlYkNvcmU6OkZsb2F0UmVjdCYpID0gMDsKIApJbmRl eDogV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUwMCw3ICs1 MDAsMjEgQEAgV2ViQ29yZTo6SW50UmVjdCBXZWJQYWdlUHJveHk6OmZpcnN0UmVjdAogICAgIElu dFJlY3QgcmVzdWx0UmVjdDsKICAgICBwcm9jZXNzKCktPnNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJQ YWdlOjpGaXJzdFJlY3RGb3JDaGFyYWN0ZXJSYW5nZShsb2NhdGlvbiwgbGVuZ3RoKSwgTWVzc2Fn ZXM6OldlYlBhZ2U6OkZpcnN0UmVjdEZvckNoYXJhY3RlclJhbmdlOjpSZXBseShyZXN1bHRSZWN0 KSwgbV9wYWdlSUQpOwogICAgIHJldHVybiByZXN1bHRSZWN0OwotfSAgICAKK30KKyNlbGlmIFBM QVRGT1JNKFdJTikKK1dlYkNvcmU6OkludFJlY3QgV2ViUGFnZVByb3h5OjpmaXJzdFJlY3RGb3JD aGFyYWN0ZXJJblNlbGVjdGVkUmFuZ2UoaW50IGNoYXJhY3RlclBvc2l0aW9uKQoreworICAgIElu dFJlY3QgcmVzdWx0UmVjdDsKKyAgICBwcm9jZXNzKCktPnNlbmRTeW5jKE1lc3NhZ2VzOjpXZWJQ YWdlOjpGaXJzdFJlY3RGb3JDaGFyYWN0ZXJJblNlbGVjdGVkUmFuZ2UoY2hhcmFjdGVyUG9zaXRp b24pLCBNZXNzYWdlczo6V2ViUGFnZTo6Rmlyc3RSZWN0Rm9yQ2hhcmFjdGVySW5TZWxlY3RlZFJh bmdlOjpSZXBseShyZXN1bHRSZWN0KSwgbV9wYWdlSUQpOworICAgIHJldHVybiByZXN1bHRSZWN0 OworfQorCitTdHJpbmcgV2ViUGFnZVByb3h5OjpnZXRTZWxlY3RlZFRleHQoKQoreworICAgIFN0 cmluZyB0ZXh0OworICAgIHByb2Nlc3MoKS0+c2VuZFN5bmMoTWVzc2FnZXM6OldlYlBhZ2U6Okdl dFNlbGVjdGVkVGV4dCgpLCBNZXNzYWdlczo6V2ViUGFnZTo6R2V0U2VsZWN0ZWRUZXh0OjpSZXBs eSh0ZXh0KSwgbV9wYWdlSUQpOworICAgIHJldHVybiB0ZXh0OworfQogI2VuZGlmCiAKICNpZiBF TkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkKQEAgLTEzMjYsMTEgKzEzNDAsMjggQEAgdm9pZCBX ZWJQYWdlUHJveHk6OmRpZFNlbGVjdGlvbkNoYW5nZShibwogICAgIG1fcGFnZUNsaWVudC0+c2Vs ZWN0aW9uQ2hhbmdlZChpc05vbmUsIGlzQ29udGVudEVkaXRhYmxlLCBpc1Bhc3N3b3JkRmllbGQs IGhhc0NvbXBvc2l0aW9uLCBsb2NhdGlvbiwgbGVuZ3RoKTsKIH0KICNlbHNlICAgIAotdm9pZCBX ZWJQYWdlUHJveHk6OmRpZFNlbGVjdGlvbkNoYW5nZShib29sIGlzTm9uZSwgYm9vbCBpc0NvbnRl bnRFZGl0YWJsZSwgYm9vbCBpc1Bhc3N3b3JkRmllbGQsIGJvb2wgaGFzQ29tcG9zaXRpb24pCit2 b2lkIFdlYlBhZ2VQcm94eTo6ZGlkQ2hhbmdlU2VsZWN0aW9uKGJvb2wgaXNOb25lLCBib29sIGlz Q29udGVudEVkaXRhYmxlLCBib29sIGlzUGFzc3dvcmRGaWVsZCwgYm9vbCBoYXNDb21wb3NpdGlv bikKIHsKICAgICBtX3BhZ2VDbGllbnQtPnNlbGVjdGlvbkNoYW5nZWQoaXNOb25lLCBpc0NvbnRl bnRFZGl0YWJsZSwgaXNQYXNzd29yZEZpZWxkLCBoYXNDb21wb3NpdGlvbik7CiB9CiAjZW5kaWYK KworI2lmIFBMQVRGT1JNKFdJTikKK3ZvaWQgV2ViUGFnZVByb3h5OjpkaWRDaGFuZ2VDb21wb3Np dGlvblNlbGVjdGlvbihib29sIGhhc0NvbXBvc2l0aW9uKQoreworICAgIG1fcGFnZUNsaWVudC0+ Y29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2VkKGhhc0NvbXBvc2l0aW9uKTsKK30KKwordm9pZCBX ZWJQYWdlUHJveHk6OmNvbmZpcm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcmIGNvbXBvc2l0aW9u U3RyaW5nKQoreworICAgIHByb2Nlc3MoKS0+c2VuZChNZXNzYWdlczo6V2ViUGFnZTo6Q29uZmly bUNvbXBvc2l0aW9uKGNvbXBvc2l0aW9uU3RyaW5nKSwgbV9wYWdlSUQpOworfQorCit2b2lkIFdl YlBhZ2VQcm94eTo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiBjb21wb3NpdGlvblN0cmlu ZywgVmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPiYgdW5kZXJsaW5lcywgaW50 IGN1cnNvclBvc2l0aW9uKQoreworICAgIHByb2Nlc3MoKS0+c2VuZChNZXNzYWdlczo6V2ViUGFn ZTo6U2V0Q29tcG9zaXRpb24oY29tcG9zaXRpb25TdHJpbmcsIHVuZGVybGluZXMsIGN1cnNvclBv c2l0aW9uKSwgbV9wYWdlSUQpOworfQorI2VuZGlmCiAgICAgCiAvLyBVbmRvIG1hbmFnZW1lbnQK IApJbmRleDogV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgJKHJldmlzaW9uIDc0MDQyKQorKysgV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgJKHdvcmtpbmcgY29weSkKQEAgLTE3OSw5ICsx NzksMTUgQEAgcHVibGljOgogICAgIFdlYkNvcmU6OkludFJlY3QgZmlyc3RSZWN0Rm9yQ2hhcmFj dGVyUmFuZ2UodWludDY0X3QsIHVpbnQ2NF90KTsKICAgICB2b2lkIGRpZFNlbGVjdGlvbkNoYW5n ZShib29sLCBib29sLCBib29sLCBib29sLCB1aW50NjRfdCwgdWludDY0X3QpOwogI2Vsc2UKLSAg ICB2b2lkIGRpZFNlbGVjdGlvbkNoYW5nZShib29sLCBib29sLCBib29sLCBib29sKTsKKyAgICB2 b2lkIGRpZENoYW5nZVNlbGVjdGlvbihib29sLCBib29sLCBib29sLCBib29sKTsKKyNlbmRpZgor I2lmIFBMQVRGT1JNKFdJTikKKyAgICB2b2lkIGRpZENoYW5nZUNvbXBvc2l0aW9uU2VsZWN0aW9u KGJvb2wpOworICAgIHZvaWQgY29uZmlybUNvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYpOworICAg IHZvaWQgc2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiwgVmVjdG9yPFdlYkNvcmU6OkNvbXBv c2l0aW9uVW5kZXJsaW5lPiYsIGludCk7CisgICAgV2ViQ29yZTo6SW50UmVjdCBmaXJzdFJlY3RG b3JDaGFyYWN0ZXJJblNlbGVjdGVkUmFuZ2UoaW50KTsKKyAgICBTdHJpbmcgZ2V0U2VsZWN0ZWRU ZXh0KCk7CiAjZW5kaWYKLQogI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQogICAgIHZv aWQgc2V0QWN0dWFsVmlzaWJsZUNvbnRlbnRSZWN0KGNvbnN0IFdlYkNvcmU6OkludFJlY3QmIHJl Y3QpOwogI2VuZGlmCkluZGV4OiBXZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2Fn ZXMuaW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3Nh Z2VzLmluCShyZXZpc2lvbiA3NDA0MikKKysrIFdlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5tZXNzYWdlcy5pbgkod29ya2luZyBjb3B5KQpAQCAtMTI0LDkgKzEyNCwxMSBAQCBtZXNzYWdl cyAtPiBXZWJQYWdlUHJveHkgewogICAgIERpZFNlbGVjdGlvbkNoYW5nZShib29sIGlzTm9uZSwg Ym9vbCBpc0NvbnRlbnRFZGl0YWJsZSwgYm9vbCBpc1Bhc3N3b3JkRmllbGQsIGJvb2wgaGFzQ29t cG9zaXRpb24sIHVpbnQ2NF90IGxvY2F0aW9uLCB1aW50NjRfdCBsZW5ndGgpCiAjZW5kaWYKICNp ZiAhUExBVEZPUk0oTUFDKQotICAgIERpZFNlbGVjdGlvbkNoYW5nZShib29sIGlzTm9uZSwgYm9v bCBpc0NvbnRlbnRFZGl0YWJsZSwgYm9vbCBpc1Bhc3N3b3JkRmllbGQsIGJvb2wgaGFzQ29tcG9z aXRpb24pCisgICAgRGlkQ2hhbmdlU2VsZWN0aW9uKGJvb2wgaXNOb25lLCBib29sIGlzQ29udGVu dEVkaXRhYmxlLCBib29sIGlzUGFzc3dvcmRGaWVsZCwgYm9vbCBoYXNDb21wb3NpdGlvbikKKyNl bmRpZgorI2lmIFBMQVRGT1JNKFdJTikKKyAgICBEaWRDaGFuZ2VDb21wb3NpdGlvblNlbGVjdGlv bihib29sIGhhc0NoYW5nZWQpCiAjZW5kaWYKLQogICAgICMgRmluZC4KICAgICBEaWRDb3VudFN0 cmluZ01hdGNoZXMoV1RGOjpTdHJpbmcgc3RyaW5nLCB1aW50MzJfdCBtYXRjaENvdW50KQogICAg IFNldEZpbmRJbmRpY2F0b3IoV2ViQ29yZTo6RmxvYXRSZWN0IHNlbGVjdGlvblJlY3QsIFZlY3Rv cjxXZWJDb3JlOjpGbG9hdFJlY3Q+IHRleHRSZWN0cywgV2ViS2l0OjpTaGFyZWRNZW1vcnk6Okhh bmRsZSBjb250ZW50SW1hZ2VIYW5kbGUsIGJvb2wgZmFkZU91dCkKSW5kZXg6IFdlYktpdDIvVUlQ cm9jZXNzL3dpbi9XZWJWaWV3LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQyL1VJUHJvY2Vzcy93 aW4vV2ViVmlldy5jcHAJKHJldmlzaW9uIDc0MDQyKQorKysgV2ViS2l0Mi9VSVByb2Nlc3Mvd2lu L1dlYlZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSAi Q2h1bmtlZFVwZGF0ZURyYXdpbmdBcmVhUHJveHkuaCIKICNpbmNsdWRlICJGaW5kSW5kaWNhdG9y LmgiCiAjaW5jbHVkZSAiTGF5ZXJCYWNrZWREcmF3aW5nQXJlYVByb3h5LmgiCisjaW5jbHVkZSAi TG9nZ2luZy5oIgogI2luY2x1ZGUgIlJ1bkxvb3AuaCIKICNpbmNsdWRlICJOYXRpdmVXZWJLZXli b2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiV2ViQ29udGV4dC5oIgpAQCAtNDAsNiArNDEsNyBAQAog I2luY2x1ZGUgPFdlYkNvcmUvQ3Vyc29yLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9GbG9hdFJlY3Qu aD4KICNpbmNsdWRlIDxXZWJDb3JlL0ludFJlY3QuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL1NvZnRM aW5raW5nLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9XZWJDb3JlSW5zdGFuY2VIYW5kbGUuaD4KICNp bmNsdWRlIDxXZWJDb3JlL1dpbmRvd01lc3NhZ2VCcm9hZGNhc3Rlci5oPgogI2luY2x1ZGUgPHd0 Zi90ZXh0L1dURlN0cmluZy5oPgpAQCAtNjAsNiArNjIsMTUgQEAgZW51bSB7CiAgICAgVXBkYXRl QWN0aXZlU3RhdGVUaW1lciA9IDEsCiB9OwogCitTT0ZUX0xJTktfTElCUkFSWShJTU0zMikKK1NP RlRfTElOSyhJTU0zMiwgSW1tR2V0Q29udGV4dCwgSElNQywgV0lOQVBJLCAoSFdORCBod25kKSwg KGh3bmQpKQorU09GVF9MSU5LKElNTTMyLCBJbW1SZWxlYXNlQ29udGV4dCwgQk9PTCwgV0lOQVBJ LCAoSFdORCBoV25kLCBISU1DIGhJTUMpLCAoaFduZCwgaElNQykpCitTT0ZUX0xJTksoSU1NMzIs IEltbUdldENvbXBvc2l0aW9uU3RyaW5nVywgTE9ORywgV0lOQVBJLCAoSElNQyBoSU1DLCBEV09S RCBkd0luZGV4LCBMUFZPSUQgbHBCdWYsIERXT1JEIGR3QnVmTGVuKSwgKGhJTUMsIGR3SW5kZXgs IGxwQnVmLCBkd0J1ZkxlbikpCitTT0ZUX0xJTksoSU1NMzIsIEltbVNldENhbmRpZGF0ZVdpbmRv dywgQk9PTCwgV0lOQVBJLCAoSElNQyBoSU1DLCBMUENBTkRJREFURUZPUk0gbHBDYW5kaWRhdGUp LCAoaElNQywgbHBDYW5kaWRhdGUpKQorU09GVF9MSU5LKElNTTMyLCBJbW1TZXRPcGVuU3RhdHVz LCBCT09MLCBXSU5BUEksIChISU1DIGhJTUMsIEJPT0wgZk9wZW4pLCAoaElNQywgZk9wZW4pKQor U09GVF9MSU5LKElNTTMyLCBJbW1Ob3RpZnlJTUUsIEJPT0wsIFdJTkFQSSwgKEhJTUMgaElNQywg RFdPUkQgZHdBY3Rpb24sIERXT1JEIGR3SW5kZXgsIERXT1JEIGR3VmFsdWUpLCAoaElNQywgZHdB Y3Rpb24sIGR3SW5kZXgsIGR3VmFsdWUpKQorU09GVF9MSU5LKElNTTMyLCBJbW1Bc3NvY2lhdGVD b250ZXh0RXgsIEJPT0wsIFdJTkFQSSwgKEhXTkQgaFduZCwgSElNQyBoSU1DLCBEV09SRCBkd0Zs YWdzKSwgKGhXbmQsIGhJTUMsIGR3RmxhZ3MpKQorCiBMUkVTVUxUIENBTExCQUNLIFdlYlZpZXc6 OldlYlZpZXdXbmRQcm9jKEhXTkQgaFduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBM UEFSQU0gbFBhcmFtKQogewogICAgIExPTkdfUFRSIGxvbmdQdHIgPSA6OkdldFdpbmRvd0xvbmdQ dHIoaFduZCwgMCk7CkBAIC0xNDYsNiArMTU3LDI0IEBAIExSRVNVTFQgV2ViVmlldzo6d25kUHJv YyhIV05EIGhXbmQsIFVJTlQKICAgICAgICAgY2FzZSBXTV9TRVRDVVJTT1I6CiAgICAgICAgICAg ICBsUmVzdWx0ID0gb25TZXRDdXJzb3IoaFduZCwgbWVzc2FnZSwgd1BhcmFtLCBsUGFyYW0sIGhh bmRsZWQpOwogICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgV01fSU1FX1NUQVJUQ09N UE9TSVRJT046CisgICAgICAgICAgICBoYW5kbGVkID0gb25JTUVTdGFydENvbXBvc2l0aW9uKCk7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBXTV9JTUVfUkVRVUVTVDoKKyAgICAg ICAgICAgIGxSZXN1bHQgPSBvbklNRVJlcXVlc3Qod1BhcmFtLCBsUGFyYW0pOworICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgIGNhc2UgV01fSU1FX0NPTVBPU0lUSU9OOgorICAgICAgICAgICAg aGFuZGxlZCA9IG9uSU1FQ29tcG9zaXRpb24obFBhcmFtKTsKKyAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICBjYXNlIFdNX0lNRV9FTkRDT01QT1NJVElPTjoKKyAgICAgICAgICAgIGhhbmRsZWQg PSBvbklNRUVuZENvbXBvc2l0aW9uKCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2Fz ZSBXTV9JTUVfU0VMRUNUOgorICAgICAgICAgICAgaGFuZGxlZCA9IG9uSU1FU2VsZWN0KHdQYXJh bSwgbFBhcmFtKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFdNX0lNRV9TRVRD T05URVhUOgorICAgICAgICAgICAgaGFuZGxlZCA9IG9uSU1FU2V0Q29udGV4dCh3UGFyYW0sIGxQ YXJhbSk7CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAg IGhhbmRsZWQgPSBmYWxzZTsKICAgICAgICAgICAgIGJyZWFrOwpAQCAtMTkxLDYgKzIyMCwxMSBA QCBXZWJWaWV3OjpXZWJWaWV3KFJFQ1QgcmVjdCwgV2ViQ29udGV4dCoKICAgICAsIG1fb3ZlcnJp ZGVDdXJzb3IoMCkKICAgICAsIG1fdHJhY2tpbmdNb3VzZUxlYXZlKGZhbHNlKQogICAgICwgbV9p c0JlaW5nRGVzdHJveWVkKGZhbHNlKQorICAgICwgbV9zZWxlY3Rpb25Jc05vbmUodHJ1ZSkKKyAg ICAsIG1fc2VsZWN0aW9uSXNFZGl0YWJsZShmYWxzZSkKKyAgICAsIG1fc2VsZWN0aW9uSW5QYXNz d29yZEZpZWxkKGZhbHNlKQorICAgICwgbV9oYXNNYXJrZWRUZXh0KGZhbHNlKQorICAgICwgbV9p bklNRUNvbXBvc2l0aW9uKDApCiB7CiAgICAgcmVnaXN0ZXJXZWJWaWV3V2luZG93Q2xhc3MoKTsK IApAQCAtNjE1LDkgKzY0OSwyNzQgQEAgRmxvYXRSZWN0IFdlYlZpZXc6OmNvbnZlcnRUb1VzZXJT cGFjZShjbwogICAgIHJldHVybiByZWN0OwogfQogCi12b2lkIFdlYlZpZXc6OnNlbGVjdGlvbkNo YW5nZWQoYm9vbCwgYm9vbCwgYm9vbCwgYm9vbCkKK0hJTUMgV2ViVmlldzo6Z2V0SU1NQ29udGV4 dCgpIAoreworICAgIHJldHVybiBXZWJLaXQ6OkltbUdldENvbnRleHQobV93aW5kb3cpOworfQor Cit2b2lkIFdlYlZpZXc6OnJlbGVhc2VJTU1Db250ZXh0KEhJTUMgaElNQykKK3sKKyAgICBpZiAo IWhJTUMpCisgICAgICAgIHJldHVybjsKKyAgICBXZWJLaXQ6OkltbVJlbGVhc2VDb250ZXh0KG1f d2luZG93LCBoSU1DKTsKK30KKwordm9pZCBXZWJWaWV3OjpwcmVwYXJlQ2FuZGlkYXRlV2luZG93 KEhJTUMgaElucHV0Q29udGV4dCkgCit7CisgICAgSW50UmVjdCBjYXJldCA9IG1fcGFnZS0+Zmly c3RSZWN0Rm9yQ2hhcmFjdGVySW5TZWxlY3RlZFJhbmdlKDApOworICAgIENBTkRJREFURUZPUk0g Zm9ybTsKKyAgICBmb3JtLmR3SW5kZXggPSAwOworICAgIGZvcm0uZHdTdHlsZSA9IENGU19FWENM VURFOworICAgIGZvcm0ucHRDdXJyZW50UG9zLnggPSBjYXJldC54KCk7CisgICAgZm9ybS5wdEN1 cnJlbnRQb3MueSA9IGNhcmV0LmJvdHRvbSgpOworICAgIGZvcm0ucmNBcmVhLnRvcCA9IGNhcmV0 LnkoKTsKKyAgICBmb3JtLnJjQXJlYS5ib3R0b20gPSBjYXJldC5ib3R0b20oKTsKKyAgICBmb3Jt LnJjQXJlYS5sZWZ0ID0gY2FyZXQueCgpOworICAgIGZvcm0ucmNBcmVhLnJpZ2h0ID0gY2FyZXQu cmlnaHQoKTsKKyAgICBXZWJLaXQ6OkltbVNldENhbmRpZGF0ZVdpbmRvdyhoSW5wdXRDb250ZXh0 LCAmZm9ybSk7Cit9CisKK3ZvaWQgV2ViVmlldzo6cmVzZXRJTUUoKQoreworICAgIEhJTUMgaElu cHV0Q29udGV4dCA9IGdldElNTUNvbnRleHQoKTsKKyAgICBpZiAoIWhJbnB1dENvbnRleHQpCisg ICAgICAgIHJldHVybjsKKyAgICBXZWJLaXQ6OkltbU5vdGlmeUlNRShoSW5wdXRDb250ZXh0LCBO SV9DT01QT1NJVElPTlNUUiwgQ1BTX0NBTkNFTCwgMCk7CisgICAgcmVsZWFzZUlNTUNvbnRleHQo aElucHV0Q29udGV4dCk7Cit9CisKK3ZvaWQgV2ViVmlldzo6c2V0SW5wdXRNZXRob2RTdGF0ZShi b29sIGVuYWJsZWQpCit7CisgICAgV2ViS2l0OjpJbW1Bc3NvY2lhdGVDb250ZXh0RXgobV93aW5k b3csIDAsIGVuYWJsZWQgPyBJQUNFX0RFRkFVTFQgOiAwKTsKK30KKwordm9pZCBXZWJWaWV3Ojpz ZWxlY3Rpb25DaGFuZ2VkKGJvb2wgaXNOb25lLCBib29sIGlzRWRpdGFibGUsIGJvb2wgaXNQYXNz d29yZEZpZWxkLCBib29sIGhhc0NvbXBvc2l0aW9uKQoreworICAgIG1fc2VsZWN0aW9uSXNOb25l ID0gaXNOb25lOworICAgIG1fc2VsZWN0aW9uSXNFZGl0YWJsZSA9IGlzRWRpdGFibGU7CisgICAg bV9zZWxlY3Rpb25JblBhc3N3b3JkRmllbGQgPSBpc1Bhc3N3b3JkRmllbGQ7CisgICAgbV9oYXNN YXJrZWRUZXh0ID0gaGFzQ29tcG9zaXRpb247Cit9CisKK3ZvaWQgV2ViVmlldzo6Y29tcG9zaXRp b25TZWxlY3Rpb25DaGFuZ2VkKGJvb2wgaGFzQ2hhbmdlZCkKK3sKKyAgICBpZiAobV9oYXNNYXJr ZWRUZXh0ICYmICFoYXNDaGFuZ2VkKQorICAgICAgICByZXNldElNRSgpOworfQorCitib29sIFdl YlZpZXc6Om9uSU1FU3RhcnRDb21wb3NpdGlvbigpCit7CisgICAgTE9HKFRleHRJbnB1dCwgIm9u SU1FU3RhcnRDb21wb3NpdGlvbiIpOworICAgIG1faW5JTUVDb21wb3NpdGlvbisrOworCisgICAg SElNQyBoSW5wdXRDb250ZXh0ID0gZ2V0SU1NQ29udGV4dCgpOworICAgIHByZXBhcmVDYW5kaWRh dGVXaW5kb3coaElucHV0Q29udGV4dCk7CisgICAgcmVsZWFzZUlNTUNvbnRleHQoaElucHV0Q29u dGV4dCk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyBib29sIGdldENvbXBvc2l0aW9u U3RyaW5nKEhJTUMgaElucHV0Q29udGV4dCwgRFdPUkQgdHlwZSwgU3RyaW5nJiByZXN1bHQpCit7 CisgICAgTE9ORyBjb21wb3NpdGlvbkxlbmd0aCA9IFdlYktpdDo6SW1tR2V0Q29tcG9zaXRpb25T dHJpbmdXKGhJbnB1dENvbnRleHQsIHR5cGUsIDAsIDApOworICAgIGlmIChjb21wb3NpdGlvbkxl bmd0aCA8PSAwKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgVmVjdG9yPFVDaGFyPiBjb21w b3NpdGlvbkJ1ZmZlcihjb21wb3NpdGlvbkxlbmd0aCAvIDIpOworICAgIGNvbXBvc2l0aW9uTGVu Z3RoID0gV2ViS2l0OjpJbW1HZXRDb21wb3NpdGlvblN0cmluZ1coaElucHV0Q29udGV4dCwgdHlw ZSwgY29tcG9zaXRpb25CdWZmZXIuZGF0YSgpLCBjb21wb3NpdGlvbkxlbmd0aCk7CisgICAgcmVz dWx0ID0gU3RyaW5nOjphZG9wdChjb21wb3NpdGlvbkJ1ZmZlcik7CisgICAgcmV0dXJuIHRydWU7 Cit9CisKK3N0YXRpYyB2b2lkIGNvbXBvc2l0aW9uVG9VbmRlcmxpbmVzKGNvbnN0IFZlY3RvcjxE V09SRD4mIGNsYXVzZXMsIGNvbnN0IFZlY3RvcjxCWVRFPiYgYXR0cmlidXRlcywgVmVjdG9yPENv bXBvc2l0aW9uVW5kZXJsaW5lPiYgdW5kZXJsaW5lcykKK3sKKyAgICBpZiAoY2xhdXNlcy5pc0Vt cHR5KCkpIHsKKyAgICAgICAgdW5kZXJsaW5lcy5jbGVhcigpOworICAgICAgICByZXR1cm47Cisg ICAgfQorICAKKyAgICBzaXplX3QgbnVtQm91bmRhcmllcyA9IGNsYXVzZXMuc2l6ZSgpIC0gMTsK KyAgICB1bmRlcmxpbmVzLnJlc2l6ZShudW1Cb3VuZGFyaWVzKTsKKyAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbnVtQm91bmRhcmllczsgaSsrKSB7CisgICAgICAgIHVuZGVybGluZXNbaV0u c3RhcnRPZmZzZXQgPSBjbGF1c2VzW2ldOworICAgICAgICB1bmRlcmxpbmVzW2ldLmVuZE9mZnNl dCA9IGNsYXVzZXNbaSArIDFdOworICAgICAgICBCWVRFIGF0dHJpYnV0ZSA9IGF0dHJpYnV0ZXNb Y2xhdXNlc1tpXV07CisgICAgICAgIHVuZGVybGluZXNbaV0udGhpY2sgPSBhdHRyaWJ1dGUgPT0g QVRUUl9UQVJHRVRfQ09OVkVSVEVEIHx8IGF0dHJpYnV0ZSA9PSBBVFRSX1RBUkdFVF9OT1RDT05W RVJURUQ7CisgICAgICAgIHVuZGVybGluZXNbaV0uY29sb3IgPSBDb2xvcjo6YmxhY2s7CisgICAg fQorfQorCisjaWYgIUxPR19ESVNBQkxFRAorI2RlZmluZSBBUFBFTkRfQVJHVU1FTlRfTkFNRShu YW1lKSBcCisgICAgaWYgKGxwYXJhbSAmIG5hbWUpIHsgXAorICAgICAgICBpZiAobmVlZHNDb21t YSkgXAorICAgICAgICAgICAgcmVzdWx0ICs9ICIsICI7IFwKKyAgICAgICAgICAgIHJlc3VsdCAr PSAjbmFtZTsgXAorICAgICAgICBuZWVkc0NvbW1hID0gdHJ1ZTsgXAorICAgIH0KKworc3RhdGlj IFN0cmluZyBpbWVDb21wb3NpdGlvbkFyZ3VtZW50TmFtZXMoTFBBUkFNIGxwYXJhbSkKK3sKKyAg ICBTdHJpbmcgcmVzdWx0OworICAgIGJvb2wgbmVlZHNDb21tYSA9IGZhbHNlOworCisgICAgQVBQ RU5EX0FSR1VNRU5UX05BTUUoR0NTX0NPTVBBVFRSKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFN RShHQ1NfQ09NUENMQVVTRSk7CisgICAgQVBQRU5EX0FSR1VNRU5UX05BTUUoR0NTX0NPTVBSRUFE U1RSKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfQ09NUFJFQURBVFRSKTsKKyAgICBB UFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfQ09NUFJFQURDTEFVU0UpOworICAgIEFQUEVORF9BUkdV TUVOVF9OQU1FKEdDU19DT01QU1RSKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfQ1VS U09SUE9TKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfREVMVEFTVEFSVCk7CisgICAg QVBQRU5EX0FSR1VNRU5UX05BTUUoR0NTX1JFU1VMVENMQVVTRSk7CisgICAgQVBQRU5EX0FSR1VN RU5UX05BTUUoR0NTX1JFU1VMVFJFQURDTEFVU0UpOworICAgIEFQUEVORF9BUkdVTUVOVF9OQU1F KEdDU19SRVNVTFRSRUFEU1RSKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShHQ1NfUkVTVUxU U1RSKTsKKyAgICBBUFBFTkRfQVJHVU1FTlRfTkFNRShDU19JTlNFUlRDSEFSKTsKKyAgICBBUFBF TkRfQVJHVU1FTlRfTkFNRShDU19OT01PVkVDQVJFVCk7CisKKyAgICByZXR1cm4gcmVzdWx0Owor fQorCitzdGF0aWMgU3RyaW5nIGltZVJlcXVlc3ROYW1lKFdQQVJBTSB3cGFyYW0pCit7CisgICAg c3dpdGNoICh3cGFyYW0pIHsKKyAgICBjYXNlIElNUl9DQU5ESURBVEVXSU5ET1c6CisgICAgICAg IHJldHVybiAiSU1SX0NBTkRJREFURVdJTkRPVyI7CisgICAgY2FzZSBJTVJfQ09NUE9TSVRJT05G T05UOgorICAgICAgICByZXR1cm4gIklNUl9DT01QT1NJVElPTkZPTlQiOworICAgIGNhc2UgSU1S X0NPTVBPU0lUSU9OV0lORE9XOgorICAgICAgICByZXR1cm4gIklNUl9DT01QT1NJVElPTldJTkRP VyI7CisgICAgY2FzZSBJTVJfQ09ORklSTVJFQ09OVkVSVFNUUklORzoKKyAgICAgICAgcmV0dXJu ICJJTVJfQ09ORklSTVJFQ09OVkVSVFNUUklORyI7CisgICAgY2FzZSBJTVJfRE9DVU1FTlRGRUVE OgorICAgICAgICByZXR1cm4gIklNUl9ET0NVTUVOVEZFRUQiOworICAgIGNhc2UgSU1SX1FVRVJZ Q0hBUlBPU0lUSU9OOgorICAgICAgICByZXR1cm4gIklNUl9RVUVSWUNIQVJQT1NJVElPTiI7Cisg ICAgY2FzZSBJTVJfUkVDT05WRVJUU1RSSU5HOgorICAgICAgICByZXR1cm4gIklNUl9SRUNPTlZF UlRTVFJJTkciOworICAgIGRlZmF1bHQ6CisgICAgICAgIHJldHVybiAiVW5rbm93biAoIiArIFN0 cmluZzo6bnVtYmVyKHdwYXJhbSkgKyAiKSI7CisgICAgfQorfQorI2VuZGlmCisKK2Jvb2wgV2Vi Vmlldzo6b25JTUVDb21wb3NpdGlvbihMUEFSQU0gbHBhcmFtKQoreworICAgIExPRyhUZXh0SW5w dXQsICJvbklNRUNvbXBvc2l0aW9uICVzIiwgaW1lQ29tcG9zaXRpb25Bcmd1bWVudE5hbWVzKGxw YXJhbSkubGF0aW4xKCkuZGF0YSgpKTsKKyAgICBISU1DIGhJbnB1dENvbnRleHQgPSBnZXRJTU1D b250ZXh0KCk7CisgICAgaWYgKCFoSW5wdXRDb250ZXh0KQorICAgICAgICByZXR1cm4gdHJ1ZTsK KworICAgIGlmICghbV9zZWxlY3Rpb25Jc0VkaXRhYmxlKQorICAgICAgICByZXR1cm4gdHJ1ZTsK KworICAgIHByZXBhcmVDYW5kaWRhdGVXaW5kb3coaElucHV0Q29udGV4dCk7CisKKyAgICBpZiAo bHBhcmFtICYgR0NTX1JFU1VMVFNUUiB8fCAhbHBhcmFtKSB7CisgICAgICAgIFN0cmluZyBjb21w b3NpdGlvblN0cmluZzsKKyAgICAgICAgaWYgKCFnZXRDb21wb3NpdGlvblN0cmluZyhoSW5wdXRD b250ZXh0LCBHQ1NfUkVTVUxUU1RSLCBjb21wb3NpdGlvblN0cmluZykgJiYgbHBhcmFtKQorICAg ICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIAorICAgICAgICBtX3BhZ2UtPmNvbmZpcm1D b21wb3NpdGlvbihjb21wb3NpdGlvblN0cmluZyk7CisgICAgICAgIHJldHVybiB0cnVlOworICAg IH0KKworICAgIFN0cmluZyBjb21wb3NpdGlvblN0cmluZzsKKyAgICBpZiAoIWdldENvbXBvc2l0 aW9uU3RyaW5nKGhJbnB1dENvbnRleHQsIEdDU19DT01QU1RSLCBjb21wb3NpdGlvblN0cmluZykp CisgICAgICAgIHJldHVybiB0cnVlOworICAgIAorICAgIC8vIENvbXBvc2l0aW9uIHN0cmluZyBh dHRyaWJ1dGVzCisgICAgaW50IG51bUF0dHJpYnV0ZXMgPSBXZWJLaXQ6OkltbUdldENvbXBvc2l0 aW9uU3RyaW5nVyhoSW5wdXRDb250ZXh0LCBHQ1NfQ09NUEFUVFIsIDAsIDApOworICAgIFZlY3Rv cjxCWVRFPiBhdHRyaWJ1dGVzKG51bUF0dHJpYnV0ZXMpOworICAgIFdlYktpdDo6SW1tR2V0Q29t cG9zaXRpb25TdHJpbmdXKGhJbnB1dENvbnRleHQsIEdDU19DT01QQVRUUiwgYXR0cmlidXRlcy5k YXRhKCksIG51bUF0dHJpYnV0ZXMpOworCisgICAgLy8gR2V0IGNsYXVzZXMKKyAgICBpbnQgbnVt Qnl0ZXMgPSBXZWJLaXQ6OkltbUdldENvbXBvc2l0aW9uU3RyaW5nVyhoSW5wdXRDb250ZXh0LCBH Q1NfQ09NUENMQVVTRSwgMCwgMCk7CisgICAgVmVjdG9yPERXT1JEPiBjbGF1c2VzKG51bUJ5dGVz IC8gc2l6ZW9mKERXT1JEKSk7CisgICAgV2ViS2l0OjpJbW1HZXRDb21wb3NpdGlvblN0cmluZ1co aElucHV0Q29udGV4dCwgR0NTX0NPTVBDTEFVU0UsIGNsYXVzZXMuZGF0YSgpLCBudW1CeXRlcyk7 CisKKyAgICBWZWN0b3I8Q29tcG9zaXRpb25VbmRlcmxpbmU+IHVuZGVybGluZXM7CisgICAgY29t cG9zaXRpb25Ub1VuZGVybGluZXMoY2xhdXNlcywgYXR0cmlidXRlcywgdW5kZXJsaW5lcyk7CisK KyAgICBpbnQgY3Vyc29yUG9zaXRpb24gPSBMT1dPUkQoV2ViS2l0OjpJbW1HZXRDb21wb3NpdGlv blN0cmluZ1coaElucHV0Q29udGV4dCwgR0NTX0NVUlNPUlBPUywgMCwgMCkpOworCisgICAgbV9w YWdlLT5zZXRDb21wb3NpdGlvbihjb21wb3NpdGlvblN0cmluZywgdW5kZXJsaW5lcywgY3Vyc29y UG9zaXRpb24pOworCisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgV2ViVmlldzo6b25JTUVF bmRDb21wb3NpdGlvbigpCit7CisgICAgTE9HKFRleHRJbnB1dCwgIm9uSU1FRW5kQ29tcG9zaXRp b24iKTsKKyAgICAvLyBJZiB0aGUgY29tcG9zaXRpb24gaGFzbid0IGJlZW4gY29uZmlybWVkIHll dCwgaXQgbmVlZHMgdG8gYmUgY2FuY2VsbGVkLgorICAgIC8vIFRoaXMgaGFwcGVucyBhZnRlciBk ZWxldGluZyB0aGUgbGFzdCBjaGFyYWN0ZXIgZnJvbSBpbmxpbmUgaW5wdXQgaG9sZS4KKyAgICBp ZiAobV9oYXNNYXJrZWRUZXh0KQorICAgICAgICBtX3BhZ2UtPmNvbmZpcm1Db21wb3NpdGlvbihT dHJpbmcoKSk7CisKKyAgICBpZiAobV9pbklNRUNvbXBvc2l0aW9uKQorICAgICAgICBtX2luSU1F Q29tcG9zaXRpb24tLTsKKworICAgIHJldHVybiB0cnVlOworfQorCitMUkVTVUxUIFdlYlZpZXc6 Om9uSU1FUmVxdWVzdENoYXJQb3NpdGlvbihJTUVDSEFSUE9TSVRJT04qIGNoYXJQb3MpCit7Cisg ICAgaWYgKGNoYXJQb3MtPmR3Q2hhclBvcyAmJiAhbV9oYXNNYXJrZWRUZXh0KQorICAgICAgICBy ZXR1cm4gMDsKKyAgICBJbnRSZWN0IGNhcmV0ID0gbV9wYWdlLT5maXJzdFJlY3RGb3JDaGFyYWN0 ZXJJblNlbGVjdGVkUmFuZ2UoY2hhclBvcy0+ZHdDaGFyUG9zKTsKKyAgICBjaGFyUG9zLT5wdC54 ID0gY2FyZXQueCgpOworICAgIGNoYXJQb3MtPnB0LnkgPSBjYXJldC55KCk7CisgICAgOjpDbGll bnRUb1NjcmVlbihtX3dpbmRvdywgJmNoYXJQb3MtPnB0KTsKKyAgICBjaGFyUG9zLT5jTGluZUhl aWdodCA9IGNhcmV0LmhlaWdodCgpOworICAgIDo6R2V0V2luZG93UmVjdChtX3dpbmRvdywgJmNo YXJQb3MtPnJjRG9jdW1lbnQpOworICAgIHJldHVybiB0cnVlOworfQorCitMUkVTVUxUIFdlYlZp ZXc6Om9uSU1FUmVxdWVzdFJlY29udmVydFN0cmluZyhSRUNPTlZFUlRTVFJJTkcqIHJlY29udmVy dFN0cmluZykKK3sKKyAgICBTdHJpbmcgdGV4dCA9IG1fcGFnZS0+Z2V0U2VsZWN0ZWRUZXh0KCk7 CisgICAgdW5zaWduZWQgdG90YWxTaXplID0gc2l6ZW9mKFJFQ09OVkVSVFNUUklORykgKyB0ZXh0 Lmxlbmd0aCgpICogc2l6ZW9mKFVDaGFyKTsKKyAgICAKKyAgICBpZiAoIXJlY29udmVydFN0cmlu ZykKKyAgICAgICAgcmV0dXJuIHRvdGFsU2l6ZTsKKworICAgIGlmICh0b3RhbFNpemUgPiByZWNv bnZlcnRTdHJpbmctPmR3U2l6ZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmVjb252ZXJ0U3Ry aW5nLT5kd0NvbXBTdHJMZW4gPSB0ZXh0Lmxlbmd0aCgpOworICAgIHJlY29udmVydFN0cmluZy0+ ZHdTdHJMZW4gPSB0ZXh0Lmxlbmd0aCgpOworICAgIHJlY29udmVydFN0cmluZy0+ZHdUYXJnZXRT dHJMZW4gPSB0ZXh0Lmxlbmd0aCgpOworICAgIHJlY29udmVydFN0cmluZy0+ZHdTdHJPZmZzZXQg PSBzaXplb2YoUkVDT05WRVJUU1RSSU5HKTsKKyAgICBtZW1jcHkocmVjb252ZXJ0U3RyaW5nICsg MSwgdGV4dC5jaGFyYWN0ZXJzKCksIHRleHQubGVuZ3RoKCkgKiBzaXplb2YoVUNoYXIpKTsKKyAg ICByZXR1cm4gdG90YWxTaXplOworfQorCitMUkVTVUxUIFdlYlZpZXc6Om9uSU1FUmVxdWVzdChX UEFSQU0gcmVxdWVzdCwgTFBBUkFNIGRhdGEpCit7CisgICAgTE9HKFRleHRJbnB1dCwgIm9uSU1F UmVxdWVzdCAlcyIsIGltZVJlcXVlc3ROYW1lKHJlcXVlc3QpLmxhdGluMSgpLmRhdGEoKSk7Cisg ICAgaWYgKCFtX3NlbGVjdGlvbklzRWRpdGFibGUpCisgICAgICAgIHJldHVybiAwOworCisgICAg c3dpdGNoIChyZXF1ZXN0KSB7CisgICAgICAgIGNhc2UgSU1SX1JFQ09OVkVSVFNUUklORzoKKyAg ICAgICAgICAgIHJldHVybiBvbklNRVJlcXVlc3RSZWNvbnZlcnRTdHJpbmcoKFJFQ09OVkVSVFNU UklORyopZGF0YSk7CisKKyAgICAgICAgY2FzZSBJTVJfUVVFUllDSEFSUE9TSVRJT046CisgICAg ICAgICAgICByZXR1cm4gb25JTUVSZXF1ZXN0Q2hhclBvc2l0aW9uKChJTUVDSEFSUE9TSVRJT04q KWRhdGEpOworICAgIH0KKyAgICByZXR1cm4gMDsKK30KKworYm9vbCBXZWJWaWV3OjpvbklNRVNl bGVjdChXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKQoreworICAgIFVOVVNFRF9QQVJBTSh3 cGFyYW0pOworICAgIFVOVVNFRF9QQVJBTShscGFyYW0pOworICAgIExPRyhUZXh0SW5wdXQsICJv bklNRVNlbGVjdCBsb2NhbGUgJWxkICVzIiwgbHBhcmFtLCB3cGFyYW0gPyAic2VsZWN0IiA6ICJk ZXNlbGVjdCIpOworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJWaWV3OjpvbklNRVNl dENvbnRleHQoV1BBUkFNIHdwYXJhbSwgTFBBUkFNKQogewotICAgIC8vIEZJWE1FOiBJbXBsZW1l bnQuCisgICAgTE9HKFRleHRJbnB1dCwgIm9uSU1FU2V0Q29udGV4dCAlcyIsIHdwYXJhbSA/ICJh Y3RpdmUiIDogImluYWN0aXZlIik7CisgICAgcmV0dXJuIGZhbHNlOwogfQogCiB2b2lkIFdlYlZp ZXc6OmRpZE5vdEhhbmRsZUtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2 ZW50KQpJbmRleDogV2ViS2l0Mi9VSVByb2Nlc3Mvd2luL1dlYlZpZXcuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQyL1VJUHJvY2Vzcy93aW4vV2ViVmlldy5oCShyZXZpc2lvbiA3NDA0MikKKysrIFdl YktpdDIvVUlQcm9jZXNzL3dpbi9XZWJWaWV3LmgJKHdvcmtpbmcgY29weSkKQEAgLTc3LDYgKzc3 LDE5IEBAIHByaXZhdGU6CiAgICAgTFJFU1VMVCBvblRpbWVyRXZlbnQoSFdORCBoV25kLCBVSU5U IG1lc3NhZ2UsIFdQQVJBTSwgTFBBUkFNLCBib29sJiBoYW5kbGVkKTsKICAgICBMUkVTVUxUIG9u U2hvd1dpbmRvd0V2ZW50KEhXTkQgaFduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0sIExQQVJBTSwg Ym9vbCYgaGFuZGxlZCk7CiAgICAgTFJFU1VMVCBvblNldEN1cnNvcihIV05EIGhXbmQsIFVJTlQg bWVzc2FnZSwgV1BBUkFNLCBMUEFSQU0sIGJvb2wmIGhhbmRsZWQpOworICAgIGJvb2wgb25JTUVT dGFydENvbXBvc2l0aW9uKCk7CisgICAgYm9vbCBvbklNRUNvbXBvc2l0aW9uKExQQVJBTSk7Cisg ICAgYm9vbCBvbklNRUVuZENvbXBvc2l0aW9uKCk7CisgICAgTFJFU1VMVCBvbklNRVJlcXVlc3Qo V1BBUkFNLCBMUEFSQU0pOworICAgIGJvb2wgb25JTUVTZWxlY3QoV1BBUkFNLCBMUEFSQU0pOwor ICAgIGJvb2wgb25JTUVTZXRDb250ZXh0KFdQQVJBTSwgTFBBUkFNKTsKKyAgICB2b2lkIHJlc2V0 SU1FKCk7CisgICAgdm9pZCBzZXRJbnB1dE1ldGhvZFN0YXRlKGJvb2wpOworICAgIEhJTUMgZ2V0 SU1NQ29udGV4dCgpOworICAgIHZvaWQgcmVsZWFzZUlNTUNvbnRleHQoSElNQyk7CisgICAgdm9p ZCBwcmVwYXJlQ2FuZGlkYXRlV2luZG93KEhJTUMpOworICAgIExSRVNVTFQgb25JTUVSZXF1ZXN0 Q2hhclBvc2l0aW9uKElNRUNIQVJQT1NJVElPTiopOworICAgIExSRVNVTFQgb25JTUVSZXF1ZXN0 UmVjb252ZXJ0U3RyaW5nKFJFQ09OVkVSVFNUUklORyopOwogCiAgICAgYm9vbCBpc0FjdGl2ZSgp OwogICAgIHZvaWQgdXBkYXRlQWN0aXZlU3RhdGUoKTsKQEAgLTEwNSw2ICsxMTgsNyBAQCBwcml2 YXRlOgogICAgIHZpcnR1YWwgV2ViQ29yZTo6RmxvYXRSZWN0IGNvbnZlcnRUb1VzZXJTcGFjZShj b25zdCBXZWJDb3JlOjpGbG9hdFJlY3QmKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkTm90SGFuZGxl S2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYpOwogICAgIHZpcnR1YWwgdm9p ZCBzZWxlY3Rpb25DaGFuZ2VkKGJvb2wsIGJvb2wsIGJvb2wsIGJvb2wpOworICAgIHZpcnR1YWwg dm9pZCBjb21wb3NpdGlvblNlbGVjdGlvbkNoYW5nZWQoYm9vbCk7CiAgICAgdmlydHVhbCBQYXNz UmVmUHRyPFdlYlBvcHVwTWVudVByb3h5PiBjcmVhdGVQb3B1cE1lbnVQcm94eSgpOwogICAgIHZp cnR1YWwgUGFzc1JlZlB0cjxXZWJDb250ZXh0TWVudVByb3h5PiBjcmVhdGVDb250ZXh0TWVudVBy b3h5KFdlYlBhZ2VQcm94eSopOwogICAgIHZpcnR1YWwgdm9pZCBzZXRGaW5kSW5kaWNhdG9yKFBh c3NSZWZQdHI8RmluZEluZGljYXRvcj4sIGJvb2wgZmFkZU91dCk7CkBAIC0xMjMsNiArMTM3LDEz IEBAIHByaXZhdGU6CiAgICAgLy8gV2ViQ29yZTo6V2luZG93TWVzc2FnZUxpc3RlbmVyCiAgICAg dmlydHVhbCB2b2lkIHdpbmRvd1JlY2VpdmVkTWVzc2FnZShIV05ELCBVSU5UIG1lc3NhZ2UsIFdQ QVJBTSwgTFBBUkFNKTsKIAorICAgIC8vIFRleHQgaW5wdXQgc3RhdGUgdmFsdWVzCisgICAgYm9v bCBtX3NlbGVjdGlvbklzTm9uZTsKKyAgICBib29sIG1fc2VsZWN0aW9uSXNFZGl0YWJsZTsKKyAg ICBib29sIG1fc2VsZWN0aW9uSW5QYXNzd29yZEZpZWxkOworICAgIGJvb2wgbV9oYXNNYXJrZWRU ZXh0OworICAgIHVuc2lnbmVkIG1faW5JTUVDb21wb3NpdGlvbjsKKwogICAgIFJFQ1QgbV9yZWN0 OwogICAgIEhXTkQgbV93aW5kb3c7CiAgICAgSFdORCBtX3RvcExldmVsUGFyZW50V2luZG93OwpJ bmRleDogV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkVkaXRvckNsaWVudC5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkVk aXRvckNsaWVudC5jcHAJKHJldmlzaW9uIDc0MDQyKQorKysgV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L1dlYkVkaXRvckNsaWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE4Niw3 ICsxODYsMTYgQEAgdm9pZCBXZWJFZGl0b3JDbGllbnQ6OnJlc3BvbmRUb0NoYW5nZWRTZQogICAg IEZyYW1lKiBmcmFtZSA9IG1fcGFnZS0+Y29yZVBhZ2UoKS0+Zm9jdXNDb250cm9sbGVyKCktPmZv Y3VzZWRGcmFtZSgpOwogICAgIGlmICghZnJhbWUpCiAgICAgICAgIHJldHVybjsKLSAgICBtX3Bh Z2UtPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6RGlkU2VsZWN0aW9uQ2hhbmdlKGZyYW1l LT5zZWxlY3Rpb24oKS0+aXNOb25lKCksIGZyYW1lLT5zZWxlY3Rpb24oKS0+aXNDb250ZW50RWRp dGFibGUoKSwgZnJhbWUtPnNlbGVjdGlvbigpLT5pc0luUGFzc3dvcmRGaWVsZCgpLCBmcmFtZS0+ ZWRpdG9yKCktPmhhc0NvbXBvc2l0aW9uKCkpKTsKKworICAgIG1fcGFnZS0+c2VuZChNZXNzYWdl czo6V2ViUGFnZVByb3h5OjpEaWRDaGFuZ2VTZWxlY3Rpb24oZnJhbWUtPnNlbGVjdGlvbigpLT5p c05vbmUoKSwgZnJhbWUtPnNlbGVjdGlvbigpLT5pc0NvbnRlbnRFZGl0YWJsZSgpLCBmcmFtZS0+ c2VsZWN0aW9uKCktPmlzSW5QYXNzd29yZEZpZWxkKCksIGZyYW1lLT5lZGl0b3IoKS0+aGFzQ29t cG9zaXRpb24oKSkpOworI2lmIFBMQVRGT1JNKFdJTikKKyAgICBpZiAoIWZyYW1lLT5lZGl0b3Io KS0+aGFzQ29tcG9zaXRpb24oKSB8fCBmcmFtZS0+ZWRpdG9yKCktPmlnbm9yZUNvbXBvc2l0aW9u U2VsZWN0aW9uQ2hhbmdlKCkpCisgICAgICAgIHJldHVybjsKKworICAgIHVuc2lnbmVkIHN0YXJ0 OworICAgIHVuc2lnbmVkIGVuZDsKKyAgICBtX3BhZ2UtPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQ cm94eTo6RGlkQ2hhbmdlQ29tcG9zaXRpb25TZWxlY3Rpb24oZnJhbWUtPmVkaXRvcigpLT5nZXRD b21wb3NpdGlvblNlbGVjdGlvbihzdGFydCwgZW5kKSkpOworI2VuZGlmCiB9CiAjZW5kaWYKICAg ICAKSW5kZXg6IFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCShyZXZpc2lvbiA3 NDA0MikKKysrIFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0xMDE3LDYgKzEwMTcsNDQgQEAgYm9vbCBXZWJQYWdlOjpoYW5kbGVFZGl0aW5n S2V5Ym9hcmRFdmVudAogICAgIHJldHVybiBmcmFtZS0+ZWRpdG9yKCktPmluc2VydFRleHQoZXZ0 LT5rZXlFdmVudCgpLT50ZXh0KCksIGV2dCk7CiB9CiAjZW5kaWYKKworI2lmIFBMQVRGT1JNKFdJ TikKK3ZvaWQgV2ViUGFnZTo6Y29uZmlybUNvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgY29tcG9z aXRpb25TdHJpbmcpCit7CisgICAgRnJhbWUqIGZyYW1lID0gbV9wYWdlLT5mb2N1c0NvbnRyb2xs ZXIoKS0+Zm9jdXNlZE9yTWFpbkZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSB8fCAhZnJhbWUtPmVk aXRvcigpLT5jYW5FZGl0KCkpCisgICAgICAgIHJldHVybjsKKyAgICBmcmFtZS0+ZWRpdG9yKCkt PmNvbmZpcm1Db21wb3NpdGlvbihjb21wb3NpdGlvblN0cmluZyk7Cit9CisKK3ZvaWQgV2ViUGFn ZTo6c2V0Q29tcG9zaXRpb24oY29uc3QgU3RyaW5nJiBjb21wb3NpdGlvblN0cmluZywgY29uc3Qg VmVjdG9yPFdlYkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPiYgdW5kZXJsaW5lcywgdWludDY0 X3QgY3Vyc29yUG9zaXRpb24pCit7CisgICAgRnJhbWUqIGZyYW1lID0gbV9wYWdlLT5mb2N1c0Nv bnRyb2xsZXIoKS0+Zm9jdXNlZE9yTWFpbkZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSB8fCAhZnJh bWUtPmVkaXRvcigpLT5jYW5FZGl0KCkpCisgICAgICAgIHJldHVybjsKKyAgICBmcmFtZS0+ZWRp dG9yKCktPnNldENvbXBvc2l0aW9uKGNvbXBvc2l0aW9uU3RyaW5nLCB1bmRlcmxpbmVzLCBjdXJz b3JQb3NpdGlvbiwgMCk7Cit9CisKK3ZvaWQgV2ViUGFnZTo6Zmlyc3RSZWN0Rm9yQ2hhcmFjdGVy SW5TZWxlY3RlZFJhbmdlKGNvbnN0IHVpbnQ2NF90IGNoYXJhY3RlclBvc2l0aW9uLCBXZWJDb3Jl OjpJbnRSZWN0JiByZXN1bHRSZWN0KQoreworICAgIEZyYW1lKiBmcmFtZSA9IG1fcGFnZS0+Zm9j dXNDb250cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOworICAgIEludFJlY3QgcmVjdDsK KyAgICBpZiAoUmVmUHRyPFJhbmdlPiByYW5nZSA9IGZyYW1lLT5lZGl0b3IoKS0+aGFzQ29tcG9z aXRpb24oKSA/IGZyYW1lLT5lZGl0b3IoKS0+Y29tcG9zaXRpb25SYW5nZSgpIDogZnJhbWUtPnNl bGVjdGlvbigpLT5zZWxlY3Rpb24oKS50b05vcm1hbGl6ZWRSYW5nZSgpKSB7CisgICAgICAgIEV4 Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICBSZWZQdHI8UmFuZ2U+IHRlbXBSYW5nZSA9IHJh bmdlLT5jbG9uZVJhbmdlKGVjKTsKKyAgICAgICAgdGVtcFJhbmdlLT5zZXRTdGFydCh0ZW1wUmFu Z2UtPnN0YXJ0Q29udGFpbmVyKGVjKSwgdGVtcFJhbmdlLT5zdGFydE9mZnNldChlYykgKyBjaGFy YWN0ZXJQb3NpdGlvbiwgZWMpOworICAgICAgICByZWN0ID0gZnJhbWUtPmVkaXRvcigpLT5maXJz dFJlY3RGb3JSYW5nZSh0ZW1wUmFuZ2UuZ2V0KCkpOworICAgIH0KKyAgICByZXN1bHRSZWN0ID0g ZnJhbWUtPnZpZXcoKS0+Y29udGVudHNUb1dpbmRvdyhyZWN0KTsKK30KKwordm9pZCBXZWJQYWdl OjpnZXRTZWxlY3RlZFRleHQoU3RyaW5nJiB0ZXh0KQoreworICAgIEZyYW1lKiBmcmFtZSA9IG1f cGFnZS0+Zm9jdXNDb250cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOworICAgIFJlZlB0 cjxSYW5nZT4gc2VsZWN0ZWRSYW5nZSA9IGZyYW1lLT5zZWxlY3Rpb24oKS0+dG9Ob3JtYWxpemVk UmFuZ2UoKTsKKyAgICB0ZXh0ID0gc2VsZWN0ZWRSYW5nZS0+dGV4dCgpOworfQorI2VuZGlmCiAg ICAgCiBXZWJFZGl0Q29tbWFuZCogV2ViUGFnZTo6d2ViRWRpdENvbW1hbmQodWludDY0X3QgY29t bWFuZElEKQogewpJbmRleDogV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaAkocmV2aXNp b24gNzQwNDIpCisrKyBXZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgJKHdvcmtp bmcgY29weSkKQEAgLTM4LDYgKzM4LDcgQEAKICNpbmNsdWRlICJQbHVnaW4uaCIKICNpbmNsdWRl ICJTYW5kYm94RXh0ZW5zaW9uLmgiCiAjaW5jbHVkZSAiV2ViRWRpdENvbW1hbmQuaCIKKyNpbmNs dWRlIDxXZWJDb3JlL0VkaXRvci5oPgogI2luY2x1ZGUgPFdlYkNvcmUvRnJhbWVMb2FkZXJUeXBl cy5oPgogI2luY2x1ZGUgPFdlYkNvcmUvSW50UmVjdC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFw Lmg+CkBAIC0yNDQsNiArMjQ1LDExIEBAIHB1YmxpYzoKICAgICB2b2lkIGNoYXJhY3RlckluZGV4 Rm9yUG9pbnQoY29uc3QgV2ViQ29yZTo6SW50UG9pbnQgcG9pbnQsIHVpbnQ2NF90JiByZXN1bHQp OwogICAgIHZvaWQgZmlyc3RSZWN0Rm9yQ2hhcmFjdGVyUmFuZ2UodWludDY0X3QgbG9jYXRpb24s IHVpbnQ2NF90IGxlbmd0aCwgV2ViQ29yZTo6SW50UmVjdCYgcmVzdWx0UmVjdCk7CiAgICAgc3Rh dGljIHZvaWQgY29udmVydFJhbmdlVG9QbGF0Zm9ybVJhbmdlKFdlYkNvcmU6OkZyYW1lKiBmcmFt ZSwgV2ViQ29yZTo6UmFuZ2UgKnJhbmdlLCB1aW50NjRfdCYgbG9jYXRpb24sIHVpbnQ2NF90JiBs ZW5ndGgpOworI2VsaWYgUExBVEZPUk0oV0lOKQorICAgIHZvaWQgY29uZmlybUNvbXBvc2l0aW9u KGNvbnN0IFN0cmluZyYgY29tcG9zaXRpb25TdHJpbmcpOworICAgIHZvaWQgc2V0Q29tcG9zaXRp b24oY29uc3QgV1RGOjpTdHJpbmcmIGNvbXBvc2l0aW9uU3RyaW5nLCBjb25zdCBXVEY6OlZlY3Rv cjxXZWJDb3JlOjpDb21wb3NpdGlvblVuZGVybGluZT4mIHVuZGVybGluZXMsIHVpbnQ2NF90IGN1 cnNvclBvc2l0aW9uKTsKKyAgICB2b2lkIGZpcnN0UmVjdEZvckNoYXJhY3RlckluU2VsZWN0ZWRS YW5nZShjb25zdCB1aW50NjRfdCBjaGFyYWN0ZXJQb3NpdGlvbiwgV2ViQ29yZTo6SW50UmVjdCYg cmVzdWx0UmVjdCk7CisgICAgdm9pZCBnZXRTZWxlY3RlZFRleHQoV1RGOjpTdHJpbmcmKTsKICNl bmRpZgogICAgIHZvaWQgZHVtbXkoYm9vbCYpOwogCkluZGV4OiBXZWJLaXQyL1dlYlByb2Nlc3Mv V2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmluCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW4JKHJldmlzaW9uIDc0MDQyKQorKysgV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgkod29ya2luZyBjb3B5 KQpAQCAtOTMsNiArOTMsMTAgQEAgbWVzc2FnZXMgLT4gV2ViUGFnZSB7CiAKICAgICBTZXRXaW5k b3dSZXNpemVyU2l6ZShXZWJDb3JlOjpJbnRTaXplIGludGVyc2VjdHNWaWV3KQogCisJLy8gVGhp cyBpcyBhIGR1bW15IG1lc3NhZ2UgdG8gYXZvaWQgYnJlYWtpbmcgdGhlIGJ1aWxkIGZvciBwbGF0 Zm9ybXMgdGhhdCBkb24ndCByZXF1aXJlDQorCS8vIHN5bmNocm9ub3VzIG1lc3NhZ2VzLg0KKwlE dW1teSgpIC0+IChib29sIGR1bW15UmV0dXJuKQorCQogI2lmIFBMQVRGT1JNKE1BQykKICAgICBT ZXRXaW5kb3dJc1Zpc2libGUoYm9vbCB3aW5kb3dJc1Zpc2libGUpCiAgICAgV2luZG93QW5kVmll d0ZyYW1lc0NoYW5nZWQoV2ViQ29yZTo6SW50UmVjdCB3aW5kb3dGcmFtZUluU2NyZWVuQ29vcmRp bmF0ZXMsIFdlYkNvcmU6OkludFJlY3Qgdmlld0ZyYW1lSW5XaW5kb3dDb29yZGluYXRlcykKQEAg LTEwMCw5ICsxMDQsMTIgQEAgbWVzc2FnZXMgLT4gV2ViUGFnZSB7CiAgICAgQ2hhcmFjdGVySW5k ZXhGb3JQb2ludChXZWJDb3JlOjpJbnRQb2ludCBwb2ludCkgLT4gKHVpbnQ2NF90IHJlc3VsdCkK ICAgICBGaXJzdFJlY3RGb3JDaGFyYWN0ZXJSYW5nZSh1aW50NjRfdCBsb2NhdGlvbiwgdWludDY0 X3QgbGVuZ3RoKSAtPiAoV2ViQ29yZTo6SW50UmVjdCByZXN1bHRSZWN0KQogI2VuZGlmCi0JLy8g VGhpcyBpcyBhIGR1bW15IG1lc3NhZ2UgdG8gYXZvaWQgYnJlYWtpbmcgdGhlIGJ1aWxkIGZvciBw bGF0Zm9ybXMgdGhhdCBkb24ndCByZXF1aXJlIAotCS8vIHN5bmNocm9ub3VzIG1lc3NhZ2VzLgot CUR1bW15KCkgLT4gKGJvb2wgZHVtbXlSZXR1cm4pCisjaWYgUExBVEZPUk0oV0lOKQorICAgIENv bmZpcm1Db21wb3NpdGlvbihXVEY6OlN0cmluZyBjb21wb3NpdGlvblN0cmluZykKKyAgICBTZXRD b21wb3NpdGlvbihXVEY6OlN0cmluZyBjb21wb3NpdGlvblN0cmluZywgV1RGOjpWZWN0b3I8V2Vi Q29yZTo6Q29tcG9zaXRpb25VbmRlcmxpbmU+IHVuZGVybGluZXMsIHVpbnQ2NF90IGN1cnNvclBv c2l0aW9uKQorICAgIEZpcnN0UmVjdEZvckNoYXJhY3RlckluU2VsZWN0ZWRSYW5nZSh1aW50NjRf dCBjaGFyYWN0ZXJQb3NpdGlvbikgLT4gKFdlYkNvcmU6OkludFJlY3QgcmVzdWx0UmVjdCkKKyAg ICBHZXRTZWxlY3RlZFRleHQoKSAtPiAoV1RGOjpTdHJpbmcgdGV4dCkKKyNlbmRpZgogI2lmIFBM QVRGT1JNKFFUKQogICAgIEZpbmRab29tYWJsZUFyZWFGb3JQb2ludChXZWJDb3JlOjpJbnRQb2lu dCBwb2ludCkKICNlbmRpZgo=