26488 2009-06-17 11:38:46 -0700 No Support for Single Finger or Two Finger Panning in Windows 7 2009-06-25 15:43:18 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC Windows 7 RESOLVED FIXED InRadar, PlatformOnly P2 Normal --- 26486 1 bweinstein bweinstein aroben oldest_to_newest 126511 0 bweinstein 2009-06-17 11:38:46 -0700 <rdar:// 126513 1 bweinstein 2009-06-17 11:40:33 -0700 <rdar://problem/6781050> WebKit is currently unable to scroll using one or two finger panning on Windows 7. WM_GESTURE support will need to be added, and I am debating whether to reuse some of the WheelEventWin/EventHandler::handleWheelEvent code, or if I want to write new handling code that handles panning. Currently, I am leaning towards reusing the WheelEventWin and EventHandler::handleWheelEvent code, but would be open to discussion. 126989 2 31557 bweinstein 2009-06-19 11:57:36 -0700 Created attachment 31557 Patch to enable single finger and two-finger panning with Window bounce 127027 3 31557 sfalken 2009-06-19 13:51:24 -0700 Comment on attachment 31557 Patch to enable single finger and two-finger panning with Window bounce > Index: WebCore/ChangeLog > =================================================================== > --- WebCore/ChangeLog (revision 44858) > +++ WebCore/ChangeLog (working copy) > @@ -1,3 +1,19 @@ > +2009-06-19 Brian Weinstein <bweinstein@apple.com> > + > + Reviewed by NOBODY (OOPS!). > + > + https://bugs.webkit.org/show_bug.cgi?id=26488 Would be nice to include a short description of the bugzilla bug w/ the URL > Index: WebCore/platform/PlatformWheelEvent.h > =================================================================== > --- WebCore/platform/PlatformWheelEvent.h (revision 44832) > +++ WebCore/platform/PlatformWheelEvent.h (working copy) > @@ -99,6 +99,7 @@ namespace WebCore { > > #if PLATFORM(WIN) > PlatformWheelEvent(HWND, WPARAM, LPARAM, bool isMouseHWheel); > + PlatformWheelEvent(HWND, float, float, float, float); We include parameter names when it isn't obvious from the type. 4 floats strung together isn't understandable for someone to know how to call this. Also, it seems odd to call this PlatformWheelEvent if we're not actually calling this in response to a wheel event. > #endif > > #if PLATFORM(WX) > Index: WebCore/platform/win/WheelEventWin.cpp > =================================================================== > --- WebCore/platform/win/WheelEventWin.cpp (revision 44832) > +++ WebCore/platform/win/WheelEventWin.cpp (working copy) > @@ -62,6 +62,29 @@ static int verticalScrollLines() > return scrollLines; > } > > +PlatformWheelEvent::PlatformWheelEvent(HWND hWnd, float deltaX, float deltaY, float xLoc, float yLoc) > + : m_isAccepted(false) > + , m_shiftKey(false) > + , m_ctrlKey(false) // FIXME: Do we need modifier keys for gestures? Does the control key do something special for gestures? > + , m_altKey(false) > + , m_metaKey(false) > +{ > + // Scroll down scrolling in x direction to make it less finicky > + m_deltaX = deltaX / 3; The divide by 3 here looks out of place - I think you copied it from the other PlatformWheelEvent ctor - would be nice to combine the common code for these. > + m_deltaY = deltaY; > + > + m_wheelTicksX = m_deltaX; > + m_wheelTicksY = m_deltaY; > + > + // Global Position is just x, y location of event > + POINT point = {xLoc, yLoc}; > + m_globalPosition = (IntPoint) point; We like to avoid C style casts. I think you can just remove the cast completely, since there's a constructor for IntPoint that takes a POINT: m_globalPosition = point; > + > + // Position needs to be translated to our client > + ScreenToClient(hWnd, &point); > + m_position = (IntPoint) point; Same problem here. I'd recommend doing this without a cast. > Index: WebKit/win/WebView.cpp > =================================================================== > --- WebKit/win/WebView.cpp (revision 44832) > +++ WebKit/win/WebView.cpp (working copy) > @@ -95,6 +95,7 @@ > #include <WebCore/ResourceHandle.h> > #include <WebCore/ResourceHandleClient.h> > #include <WebCore/ScriptValue.h> > +#include <WebCore/Scrollbar.h> > #include <WebCore/ScrollbarTheme.h> > #include <WebCore/SecurityOrigin.h> > #include <WebCore/SelectionController.h> > @@ -127,6 +128,18 @@ > #include <ShlObj.h> > #include <tchar.h> > #include <windowsx.h> > +#include "SoftLinking.h" > +#include "WindowsTouch.h" Given the current include sorting in this file, I'd recommend moving these 2 new lines up with the other includes for files within WebKit. > > +bool WebView::gestureNotify(WPARAM wParam, LPARAM lParam) > +{ > + GESTURENOTIFYSTRUCT* gn = (GESTURENOTIFYSTRUCT*) lParam; You should use a C++ style cast. > + > + Frame* coreFrame = core(m_mainFrame); > + if (!coreFrame) > + return false; > + > + ScrollView* view = (ScrollView*) coreFrame->document()->view(); This should not require a cast, since view() returns a FrameView* and FrameView is derived from ScrollView. Also, I think this can be coreFrame->view(). > + if (!view) > + return false; > + > + // If we don't have this function, we shouldn't be receiving this message > + if (!SetGestureConfigPtr()) > + return false; I think this can just be an assert - I don't think you could end up with the WM_GESTURENOTIFY if the lib wasn't present. > + > + DWORD dwPanWant; > + DWORD dwPanBlock; > + > + if (gn->ptsLocation.x > view->visibleWidth()) { > + //We are in the scrollbar, turn off panning > + dwPanWant = GC_PAN | GC_PAN_WITH_INERTIA | GC_PAN_WITH_GUTTER; > + dwPanBlock = GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY | GC_PAN_WITH_SINGLE_FINGER_VERTICALLY; > + } else { > + //We aren't in the scrollbar, turn on panning > + dwPanWant = GC_PAN | GC_PAN_WITH_SINGLE_FINGER_VERTICALLY | GC_PAN_WITH_INERTIA | GC_PAN_WITH_GUTTER; > + dwPanBlock = GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY; > + } > + > + GESTURECONFIG gc = { GID_PAN, dwPanWant , dwPanBlock } ; > + UINT uiGcs = 1; Not necessary to stick this in a local temporarily. I'm not sure the name uiGcs adds a lot of value. > + BOOL bResult = SetGestureConfigPtr()(m_viewWindow, 0, uiGcs, &gc, sizeof(GESTURECONFIG)); > + > + return bResult; could just return the result of the call directly. No need to assign it to a temporary local. > +} > + > +bool WebView::gesture(WPARAM wParam, LPARAM lParam) > +{ > + GESTUREINFO gi = {0}; > + > + BOOL eventValue = false; > + > + PlatformWheelEvent* wheelEvent; > + long currentX; > + long currentY; > + long deltaX; > + long deltaY; Can define these closer to their first use. > + > + // We want to bail out if we don't have either of these functions > + if (!GetGestureInfoPtr() || !CloseGestureInfoHandlePtr()) > + return false; > + > + gi.cbSize = sizeof(GESTUREINFO); Could just move the gi definition directly above this line. That would make its initial state more clear. > + > + BOOL bResult = GetGestureInfoPtr()((HGESTUREINFO)lParam, (PGESTUREINFO) &gi); > + > + if (bResult){ Early return would be better here. Don't need bResult. Could just do if (GetGesture... You need a space between ){ > + switch (gi.dwID){ Space between ){ > + case GID_BEGIN: > + m_lastPanX = gi.ptsLocation.x; > + m_lastPanY = gi.ptsLocation.y; > + > + CloseGestureInfoHandlePtr()((HGESTUREINFO)lParam); C style cast - shouldn't use this. > + break; > + case GID_ZOOM: > + // FIXME: Do we want to implement a new kind of zoom here? <rdar://problem/6980304> > + CloseGestureInfoHandlePtr()((HGESTUREINFO)lParam); C style cast - shouldn't use this. > + break; > + case GID_PAN: { > + Frame* coreFrame = core(m_mainFrame); > + if (!coreFrame) > + return false; > + > + ScrollView* view = (ScrollView*) coreFrame->document()->view(); I don't think this cast is needed. > + if (!view) > + return false; > + > + Scrollbar* vertScrollbar = view->verticalScrollbar(); > + if (!vertScrollbar) > + return true; //No panning of any kind when no vertical scrollbar, matches IE8 Doesn't this leak the gesture info? > + > + // Where are the fingers currently? > + currentX = gi.ptsLocation.x; > + currentY = gi.ptsLocation.y; > + > + // How far did we pan in each direction? > + deltaX = currentX - m_lastPanX; > + deltaY = currentY - m_lastPanY; > + > + // Calculate the overpan for window bounce > + m_yOverpan -= m_lastPanY - currentY; > + m_xOverpan -= m_lastPanX - currentX; > + > + // Update our class variables with updated values > + m_lastPanX = currentX; > + m_lastPanY = currentY; > + > + // Represent the pan gesture as a mouse wheel event > + wheelEvent = new PlatformWheelEvent(m_viewWindow, deltaX, deltaY, currentX, currentY); It looks like you're leaking the wheelEvent. Can you just make this stack allocated? > + eventValue = coreFrame->eventHandler()->handleWheelEvent(*wheelEvent); > + > + // FIXME: Soon we'll have horizontal window bounce too, just haven't implemented yet > + if (vertScrollbar->currentPos() == 0) { > + // FIXME: Is something else besides 0 here? 0 worked in tests, and window bounce worked > + if (UpdatePanningFeedbackPtr()) { Is it useful to check for all of these functions separately? Seems like if 1 is available, they'd all be there. > + UpdatePanningFeedbackPtr()(m_viewWindow, 0, m_yOverpan, gi.dwFlags & GF_INERTIA); > + } > + } else if (vertScrollbar->currentPos() >= vertScrollbar->maximum()) { > + if (UpdatePanningFeedbackPtr()) { > + UpdatePanningFeedbackPtr()(m_viewWindow, 0, m_yOverpan, gi.dwFlags & GF_INERTIA); > + } > + } > + if (gi.dwFlags & GF_BEGIN) { > + if (BeginPanningFeedbackPtr()) { > + BeginPanningFeedbackPtr()(m_viewWindow); > + m_yOverpan = 0; > + } > + } else if (gi.dwFlags & GF_END) { > + if (EndPanningFeedbackPtr()) { > + EndPanningFeedbackPtr()(m_viewWindow, true); > + m_yOverpan = 0; > + } > + } > + > + CloseGestureInfoHandlePtr()((HGESTUREINFO)lParam); C style cast - shouldn't use this. > + return eventValue; Is it correct to close the gesture info if we could return false? > + > + break; > + } > + default: > + // You have encountered an unknown gesture - return false to pass it to DefWindowProc > + CloseGestureInfoHandlePtr()((HGESTUREINFO)lParam); C style cast - shouldn't use this. > + return false; > + break; > + } > + CloseGestureInfoHandlePtr()((HGESTUREINFO)lParam); > + } else { > + DWORD dwErr = GetLastError(); > + ASSERT(dwErr <= 0); //dwErr > 0 is an error condition Not sure this is a useful assert- seems odd since in this code path, we actually expect an error. > Index: WebKit/win/WebView.h > =================================================================== > --- WebKit/win/WebView.h (revision 44832) > +++ WebKit/win/WebView.h (working copy) > @@ -742,6 +742,8 @@ public: > bool onUninitMenuPopup(WPARAM, LPARAM); > void performContextMenuAction(WPARAM, LPARAM, bool byPosition); > bool mouseWheel(WPARAM, LPARAM, bool isMouseHWheel); > + bool gesture(WPARAM, LPARAM); > + bool gestureNotify(WPARAM, LPARAM); > bool execCommand(WPARAM wParam, LPARAM lParam); > bool keyDown(WPARAM, LPARAM, bool systemKeyDown = false); > bool keyUp(WPARAM, LPARAM, bool systemKeyDown = false); > @@ -911,6 +913,12 @@ protected: > HWND m_topLevelParent; > > OwnPtr<HashSet<WebCore::String> > m_embeddedViewMIMETypes; > + > + //Variables needed to store gesture information > + long m_lastPanX; > + long m_lastPanY; > + long m_xOverpan; > + long m_yOverpan; You need to initialize these in the WebView ctor. > }; > > #endif > Index: WebKit/win/WindowsTouch.h > =================================================================== > --- WebKit/win/WindowsTouch.h (revision 0) > +++ WebKit/win/WindowsTouch.h (revision 0) > +#ifndef WindowsTouch_H > +#define WindowsTouch_H I think our coding guidelines call for _h instead of _H. > +#endif > \ No newline at end of file You should add a newline. > > Property changes on: WebKit/win/WindowsTouch.h > ___________________________________________________________________ > Added: svn:executable > + * For new files you should: svn pd svn:executable svn ps svn:eol-style native 127036 4 bweinstein 2009-06-19 14:09:45 -0700 Dave Hyatt, Adam Roben and I discussed that a good way to handle this bug would be to "override" the PlatformWheelEvent, similar to how continuous scrolling works on the Mac, so that is why I made the decision I did to use a MouseWheelEvent, because it had so much of the scrolling logic built in. 127037 5 bweinstein 2009-06-19 14:11:19 -0700 The modifier keys don't do anytihng special for gestures, but I wasn't sure if I needed to declare those all as false for safety, just to make sure some other classes aren't trying to call an undefined variable. 127060 6 31570 bweinstein 2009-06-19 16:29:21 -0700 Created attachment 31570 Take 2 of Panning 127085 7 bweinstein 2009-06-19 17:37:35 -0700 Committed in r44883. 127933 8 31570 aroben 2009-06-24 09:59:52 -0700 Comment on attachment 31570 Take 2 of Panning > + PlatformWheelEvent(HWND, float deltaX, float deltaY, float xLoc, float yLoc); It would be even better for the signature to look like this: PlatformWheelEvent(HWND, const FloatSize& delta, const FloatPoint& location); 31557 2009-06-19 11:57:36 -0700 2009-06-19 16:29:21 -0700 Patch to enable single finger and two-finger panning with Window bounce Panning.patch text/plain 17739 bweinstein SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NDg1OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDktMDYtMTkgIEJyaWFuIFdlaW5zdGVpbiAgPGJ3ZWluc3RlaW5A YXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAg ICAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2NDg4 CisgICAgICAgIAorICAgICAgICBUaGUgY29kZSBpbiBXZWJDb3JlIGFsbG93cyB1cyB0byBpbnRl cnByZXQgYSBQYW4gZ2VzdHVyZSBhcworICAgICAgICBhIG1vdXNld2hlZWwgZXZlbnQsIGFuZCB3 ZSBhcmUgYWJsZSB0byByZXVzZSB0aGUgc2Nyb2xsaW5nIGNvZGUuCisgICAgICAgIEFub3RoZXIg Y29uc3RydWN0b3Igd2FzIGNyZWF0ZWQgaW4gV2hlZWxFdmVudFdpbiB3aGljaCB0YWtlcyBkYXRh CisgICAgICAgIGJldHRlciBzdWl0ZWQgdG8gdGhlIHBhbiBndWVzdHVyZSB0aGFuIHdoYXQgd2Fz IGN1cnJlbnRseSB0aGVyZS4gCisgICAgICAgIAorICAgICAgICBVbmFibGUgdG8gYWRkIHRlc3Rz IHRvIHNpbXVsYXRlIHRvdWNoIGJlaGF2aW9yL2dlc3R1cmVzLgorCisgICAgICAgICogcGxhdGZv cm0vUGxhdGZvcm1XaGVlbEV2ZW50Lmg6CisgICAgICAgICogcGxhdGZvcm0vd2luL1doZWVsRXZl bnRXaW4uY3BwOgorCiAyMDA5LTA2LTE5ICBKdW5nc2hpayBTaGluICA8anNoaW5AY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhdmlkIExldmluCkluZGV4OiBXZWJDb3JlL3Bs YXRmb3JtL1BsYXRmb3JtV2hlZWxFdmVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZv cm0vUGxhdGZvcm1XaGVlbEV2ZW50LmgJKHJldmlzaW9uIDQ0ODMyKQorKysgV2ViQ29yZS9wbGF0 Zm9ybS9QbGF0Zm9ybVdoZWVsRXZlbnQuaAkod29ya2luZyBjb3B5KQpAQCAtOTksNiArOTksNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICNpZiBQTEFURk9STShXSU4pCiAgICAgICAgIFBsYXRm b3JtV2hlZWxFdmVudChIV05ELCBXUEFSQU0sIExQQVJBTSwgYm9vbCBpc01vdXNlSFdoZWVsKTsK KyAgICAgICAgUGxhdGZvcm1XaGVlbEV2ZW50KEhXTkQsIGZsb2F0LCBmbG9hdCwgZmxvYXQsIGZs b2F0KTsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oV1gpCkluZGV4OiBXZWJDb3JlL3BsYXRmb3Jt L3dpbi9XaGVlbEV2ZW50V2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL3dp bi9XaGVlbEV2ZW50V2luLmNwcAkocmV2aXNpb24gNDQ4MzIpCisrKyBXZWJDb3JlL3BsYXRmb3Jt L3dpbi9XaGVlbEV2ZW50V2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjIsNiArNjIsMjkgQEAg c3RhdGljIGludCB2ZXJ0aWNhbFNjcm9sbExpbmVzKCkKICAgICByZXR1cm4gc2Nyb2xsTGluZXM7 CiB9CiAKK1BsYXRmb3JtV2hlZWxFdmVudDo6UGxhdGZvcm1XaGVlbEV2ZW50KEhXTkQgaFduZCwg ZmxvYXQgZGVsdGFYLCBmbG9hdCBkZWx0YVksIGZsb2F0IHhMb2MsIGZsb2F0IHlMb2MpCisgICAg OiBtX2lzQWNjZXB0ZWQoZmFsc2UpCisgICAgLCBtX3NoaWZ0S2V5KGZhbHNlKQorICAgICwgbV9j dHJsS2V5KGZhbHNlKSAvLyBGSVhNRTogRG8gd2UgbmVlZCBtb2RpZmllciBrZXlzIGZvciBnZXN0 dXJlcz8KKyAgICAsIG1fYWx0S2V5KGZhbHNlKQorICAgICwgbV9tZXRhS2V5KGZhbHNlKQorewor ICAgIC8vIFNjcm9sbCBkb3duIHNjcm9sbGluZyBpbiB4IGRpcmVjdGlvbiB0byBtYWtlIGl0IGxl c3MgZmluaWNreQorICAgIG1fZGVsdGFYID0gZGVsdGFYIC8gMzsKKyAgICBtX2RlbHRhWSA9IGRl bHRhWTsKKworICAgIG1fd2hlZWxUaWNrc1ggPSBtX2RlbHRhWDsKKyAgICBtX3doZWVsVGlja3NZ ID0gbV9kZWx0YVk7CisKKyAgICAvLyBHbG9iYWwgUG9zaXRpb24gaXMganVzdCB4LCB5IGxvY2F0 aW9uIG9mIGV2ZW50CisgICAgUE9JTlQgcG9pbnQgPSB7eExvYywgeUxvY307CisgICAgbV9nbG9i YWxQb3NpdGlvbiA9IChJbnRQb2ludCkgcG9pbnQ7CisKKyAgICAvLyBQb3NpdGlvbiBuZWVkcyB0 byBiZSB0cmFuc2xhdGVkIHRvIG91ciBjbGllbnQKKyAgICBTY3JlZW5Ub0NsaWVudChoV25kLCAm cG9pbnQpOworICAgIG1fcG9zaXRpb24gPSAoSW50UG9pbnQpIHBvaW50OworfQorCiBQbGF0Zm9y bVdoZWVsRXZlbnQ6OlBsYXRmb3JtV2hlZWxFdmVudChIV05EIGhXbmQsIFdQQVJBTSB3UGFyYW0s IExQQVJBTSBsUGFyYW0sIGJvb2wgaXNNb3VzZUhXaGVlbCkKICAgICA6IG1fcG9zaXRpb24ocG9z aXRpb25Gb3JFdmVudChoV25kLCBsUGFyYW0pKQogICAgICwgbV9nbG9iYWxQb3NpdGlvbihnbG9i YWxQb3NpdGlvbkZvckV2ZW50KGhXbmQsIGxQYXJhbSkpCkluZGV4OiBXZWJLaXQvd2luL0NoYW5n ZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gNDQ4NTgp CisrKyBXZWJLaXQvd2luL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIyIEBA CisyMDA5LTA2LTE5ICBCcmlhbiBXZWluc3RlaW4gIDxid2VpbnN0ZWluQGFwcGxlLmNvbT4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAgICAgCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjQ4OAorICAgICAgICAKKyAg ICAgICAgQWRkZWQgdGhlIGNvZGUgbmVjZXNzYXJ5IGZvciBzaW5nbGUgZmluZ2VyIGFuZCB0d28t ZmluZ2VyIHBhbm5pbmcgd2l0aAorICAgICAgICB3aW5kb3cgYm91bmNlLiBXZSBub3cgcmVnaXN0 ZXIgZm9yIFdNX0dFU1RVUkVOT1RJRlkgYW5kIFdNX0dFU1RVUkUgbWVzc2FnZXMsCisgICAgICAg IGFuZCBpbnRlcnByZXQgdGhlIHBhbm5pbmcgY29tbWFuZC4gQWxzbywgYWRkZWQgV2luZG93c1Rv dWNoLmggd2hpY2ggY29udGFpbnMgCisgICAgICAgIHN0cnVjdHMgYW5kICNkZWZpbmVzIGZyb20g dGhlIFdpbmRvd3MgNyBTREsuCisKKyAgICAgICAgKiBXZWJLaXQudmNwcm9qL1dlYktpdC52Y3By b2o6CisgICAgICAgICogV2ViVmlldy5jcHA6CisgICAgICAgIChXZWJWaWV3OjpnZXN0dXJlTm90 aWZ5KTogQ2hlY2tzIGlmIHdlIGFyZSBpbiBhIHBhbm5hYmxlIHJlZ2lvbiAtIElFOiBOb3QgaW4g dGhlIHNjcm9sbGJhcgorICAgICAgICAoV2ViVmlldzo6Z2VzdHVyZSk6IEhhbmRsZXMgdGhlIFBh bm5pbmcgZ2VzdHVyZSwgY3JlYXRpbmcgdGhlIFdoZWVsRXZlbnQKKyAgICAgICAgKFdlYlZpZXdX bmRQcm9jKTogQWRkZWQgY2FzZXMgZm9yIFdNX0dFU1RVUkUgYW5kIFdNX0dFU1RVUkVOT1RJRlkK KyAgICAgICAgKiBXZWJWaWV3Lmg6CisgICAgICAgICogV2luZG93c1RvdWNoLmg6IEFkZGVkLgor CiAyMDA5LTA2LTE4ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KSW5kZXg6IFdlYktpdC93aW4vV2ViVmlldy5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0L3dpbi9XZWJWaWV3LmNwcAkocmV2aXNpb24gNDQ4MzIpCisrKyBX ZWJLaXQvd2luL1dlYlZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC05NSw2ICs5NSw3IEBACiAj aW5jbHVkZSA8V2ViQ29yZS9SZXNvdXJjZUhhbmRsZS5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUmVz b3VyY2VIYW5kbGVDbGllbnQuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1NjcmlwdFZhbHVlLmg+Cisj aW5jbHVkZSA8V2ViQ29yZS9TY3JvbGxiYXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Njcm9sbGJh clRoZW1lLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbi5oPgogI2luY2x1ZGUg PFdlYkNvcmUvU2VsZWN0aW9uQ29udHJvbGxlci5oPgpAQCAtMTI3LDYgKzEyOCwxOCBAQAogI2lu Y2x1ZGUgPFNobE9iai5oPgogI2luY2x1ZGUgPHRjaGFyLmg+CiAjaW5jbHVkZSA8d2luZG93c3gu aD4KKyNpbmNsdWRlICJTb2Z0TGlua2luZy5oIgorI2luY2x1ZGUgIldpbmRvd3NUb3VjaC5oIgor CisvLyBTb2Z0IGxpbmsgZnVuY3Rpb25zIGZvciBnZXN0dXJlcyBhbmQgcGFubmluZyBmZWVkYmFj aworU09GVF9MSU5LX0xJQlJBUlkoVVNFUjMyKTsKK1NPRlRfTElOS19PUFRJT05BTChVU0VSMzIs IEdldEdlc3R1cmVJbmZvLCBCT09MLCBXSU5BUEksIChIR0VTVFVSRUlORk8sIFBHRVNUVVJFSU5G TykpOworU09GVF9MSU5LX09QVElPTkFMKFVTRVIzMiwgU2V0R2VzdHVyZUNvbmZpZywgQk9PTCwg V0lOQVBJLCAoSFdORCwgRFdPUkQsIFVJTlQsIFBHRVNUVVJFQ09ORklHLCBVSU5UKSk7CitTT0ZU X0xJTktfT1BUSU9OQUwoVVNFUjMyLCBDbG9zZUdlc3R1cmVJbmZvSGFuZGxlLCBCT09MLCBXSU5B UEksIChIR0VTVFVSRUlORk8pKTsKK1NPRlRfTElOS19MSUJSQVJZKFV4dGhlbWUpOworU09GVF9M SU5LX09QVElPTkFMKFV4dGhlbWUsIEJlZ2luUGFubmluZ0ZlZWRiYWNrLCBCT09MLCBXSU5BUEks IChIV05EKSk7CitTT0ZUX0xJTktfT1BUSU9OQUwoVXh0aGVtZSwgRW5kUGFubmluZ0ZlZWRiYWNr LCBCT09MLCBXSU5BUEksIChIV05ELCBCT09MKSk7CitTT0ZUX0xJTktfT1BUSU9OQUwoVXh0aGVt ZSwgVXBkYXRlUGFubmluZ0ZlZWRiYWNrLCBCT09MLCBXSU5BUEksIChIV05ELCBMT05HLCBMT05H LCBCT09MKSk7CiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogdXNpbmcgSlNDOjpKU0xvY2s7 CkBAIC0xMzI1LDYgKzEzMzgsMTUwIEBAIGJvb2wgV2ViVmlldzo6aGFuZGxlTW91c2VFdmVudChV SU5UIG1lc3MKICAgICByZXR1cm4gaGFuZGxlZDsKIH0KIAorYm9vbCBXZWJWaWV3OjpnZXN0dXJl Tm90aWZ5KFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0pCit7CisgICAgR0VTVFVSRU5PVElG WVNUUlVDVCogZ24gPSAoR0VTVFVSRU5PVElGWVNUUlVDVCopIGxQYXJhbTsKKworICAgIEZyYW1l KiBjb3JlRnJhbWUgPSBjb3JlKG1fbWFpbkZyYW1lKTsKKyAgICBpZiAoIWNvcmVGcmFtZSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgU2Nyb2xsVmlldyogdmlldyA9IChTY3JvbGxWaWV3 KikgY29yZUZyYW1lLT5kb2N1bWVudCgpLT52aWV3KCk7CisgICAgaWYgKCF2aWV3KQorICAgICAg ICByZXR1cm4gZmFsc2U7CisKKyAgICAvLyBJZiB3ZSBkb24ndCBoYXZlIHRoaXMgZnVuY3Rpb24s IHdlIHNob3VsZG4ndCBiZSByZWNlaXZpbmcgdGhpcyBtZXNzYWdlCisgICAgaWYgKCFTZXRHZXN0 dXJlQ29uZmlnUHRyKCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIERXT1JEIGR3UGFu V2FudDsKKyAgICBEV09SRCBkd1BhbkJsb2NrOyAKKworICAgIGlmIChnbi0+cHRzTG9jYXRpb24u eCA+IHZpZXctPnZpc2libGVXaWR0aCgpKSB7CisgICAgICAgIC8vV2UgYXJlIGluIHRoZSBzY3Jv bGxiYXIsIHR1cm4gb2ZmIHBhbm5pbmcKKyAgICAgICAgZHdQYW5XYW50ID0gR0NfUEFOICB8IEdD X1BBTl9XSVRIX0lORVJUSUEgfCBHQ19QQU5fV0lUSF9HVVRURVI7CisgICAgICAgIGR3UGFuQmxv Y2sgPSBHQ19QQU5fV0lUSF9TSU5HTEVfRklOR0VSX0hPUklaT05UQUxMWSB8IEdDX1BBTl9XSVRI X1NJTkdMRV9GSU5HRVJfVkVSVElDQUxMWTsJCisgICAgfSBlbHNlIHsKKyAgICAgICAgLy9XZSBh cmVuJ3QgaW4gdGhlIHNjcm9sbGJhciwgdHVybiBvbiBwYW5uaW5nCisgICAgICAgIGR3UGFuV2Fu dCA9IEdDX1BBTiAgfCBHQ19QQU5fV0lUSF9TSU5HTEVfRklOR0VSX1ZFUlRJQ0FMTFkgfCBHQ19Q QU5fV0lUSF9JTkVSVElBIHwgR0NfUEFOX1dJVEhfR1VUVEVSOworICAgICAgICBkd1BhbkJsb2Nr ID0gR0NfUEFOX1dJVEhfU0lOR0xFX0ZJTkdFUl9IT1JJWk9OVEFMTFk7CQorICAgIH0KKworICAg IEdFU1RVUkVDT05GSUcgZ2MgPSB7IEdJRF9QQU4sIGR3UGFuV2FudCAsIGR3UGFuQmxvY2sgfSA7 CisgICAgVUlOVCB1aUdjcyA9IDE7CisgICAgQk9PTCBiUmVzdWx0ID0gU2V0R2VzdHVyZUNvbmZp Z1B0cigpKG1fdmlld1dpbmRvdywgMCwgdWlHY3MsICZnYywgc2l6ZW9mKEdFU1RVUkVDT05GSUcp KTsKKworICAgIHJldHVybiBiUmVzdWx0OworfQorCitib29sIFdlYlZpZXc6Omdlc3R1cmUoV1BB UkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSkgCit7CisgICAgR0VTVFVSRUlORk8gZ2kgPSB7MH07 CisKKyAgICBCT09MIGV2ZW50VmFsdWUgPSBmYWxzZTsKKworICAgIFBsYXRmb3JtV2hlZWxFdmVu dCogd2hlZWxFdmVudDsKKyAgICBsb25nIGN1cnJlbnRYOworICAgIGxvbmcgY3VycmVudFk7Cisg ICAgbG9uZyBkZWx0YVg7CisgICAgbG9uZyBkZWx0YVk7CisKKyAgICAvLyBXZSB3YW50IHRvIGJh aWwgb3V0IGlmIHdlIGRvbid0IGhhdmUgZWl0aGVyIG9mIHRoZXNlIGZ1bmN0aW9ucworICAgIGlm ICghR2V0R2VzdHVyZUluZm9QdHIoKSB8fCAhQ2xvc2VHZXN0dXJlSW5mb0hhbmRsZVB0cigpKQor ICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBnaS5jYlNpemUgPSBzaXplb2YoR0VTVFVSRUlO Rk8pOworCisgICAgQk9PTCBiUmVzdWx0ID0gR2V0R2VzdHVyZUluZm9QdHIoKSgoSEdFU1RVUkVJ TkZPKWxQYXJhbSwgKFBHRVNUVVJFSU5GTykgJmdpKTsKKworICAgIGlmIChiUmVzdWx0KXsKKyAg ICAgICAgc3dpdGNoIChnaS5kd0lEKXsKKyAgICAgICAgICAgIGNhc2UgR0lEX0JFR0lOOgorICAg ICAgICAgICAgICAgIG1fbGFzdFBhblggPSBnaS5wdHNMb2NhdGlvbi54OworICAgICAgICAgICAg ICAgIG1fbGFzdFBhblkgPSBnaS5wdHNMb2NhdGlvbi55OworCisgICAgICAgICAgICAgICAgQ2xv c2VHZXN0dXJlSW5mb0hhbmRsZVB0cigpKChIR0VTVFVSRUlORk8pbFBhcmFtKTsKKyAgICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGNhc2UgR0lEX1pPT006ICAgIAorICAgICAgICAg ICAgICAgIC8vIEZJWE1FOiBEbyB3ZSB3YW50IHRvIGltcGxlbWVudCBhIG5ldyBraW5kIG9mIHpv b20gaGVyZT8gPHJkYXI6Ly9wcm9ibGVtLzY5ODAzMDQ+ICAgIAorICAgICAgICAgICAgICAgIENs b3NlR2VzdHVyZUluZm9IYW5kbGVQdHIoKSgoSEdFU1RVUkVJTkZPKWxQYXJhbSk7CisgICAgICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICBjYXNlIEdJRF9QQU46IHsKKyAgICAgICAgICAg ICAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZShtX21haW5GcmFtZSk7CisgICAgICAgICAgICAg ICAgaWYgKCFjb3JlRnJhbWUpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKwor ICAgICAgICAgICAgICAgIFNjcm9sbFZpZXcqIHZpZXcgPSAoU2Nyb2xsVmlldyopIGNvcmVGcmFt ZS0+ZG9jdW1lbnQoKS0+dmlldygpOworICAgICAgICAgICAgICAgIGlmICghdmlldykKKyAgICAg ICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgICAgICAgICAgU2Nyb2xsYmFy KiB2ZXJ0U2Nyb2xsYmFyID0gdmlldy0+dmVydGljYWxTY3JvbGxiYXIoKTsKKyAgICAgICAgICAg ICAgICBpZiAoIXZlcnRTY3JvbGxiYXIpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVl OwkvL05vIHBhbm5pbmcgb2YgYW55IGtpbmQgd2hlbiBubyB2ZXJ0aWNhbCBzY3JvbGxiYXIsIG1h dGNoZXMgSUU4CisKKyAgICAgICAgICAgICAgICAvLyBXaGVyZSBhcmUgdGhlIGZpbmdlcnMgY3Vy cmVudGx5PworICAgICAgICAgICAgICAgIGN1cnJlbnRYID0gZ2kucHRzTG9jYXRpb24ueDsKKyAg ICAgICAgICAgICAgICBjdXJyZW50WSA9IGdpLnB0c0xvY2F0aW9uLnk7CisgICAgICAgICAgICAg ICAgCisgICAgICAgICAgICAgICAgLy8gSG93IGZhciBkaWQgd2UgcGFuIGluIGVhY2ggZGlyZWN0 aW9uPworICAgICAgICAgICAgICAgIGRlbHRhWCA9IGN1cnJlbnRYIC0gbV9sYXN0UGFuWDsKKyAg ICAgICAgICAgICAgICBkZWx0YVkgPSBjdXJyZW50WSAtIG1fbGFzdFBhblk7CisgICAgICAgICAg ICAgICAgCisgICAgICAgICAgICAgICAgLy8gQ2FsY3VsYXRlIHRoZSBvdmVycGFuIGZvciB3aW5k b3cgYm91bmNlCisgICAgICAgICAgICAgICAgbV95T3ZlcnBhbiAtPSBtX2xhc3RQYW5ZIC0gY3Vy cmVudFk7CisgICAgICAgICAgICAgICAgbV94T3ZlcnBhbiAtPSBtX2xhc3RQYW5YIC0gY3VycmVu dFg7CisgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgLy8gVXBkYXRlIG91ciBjbGFz cyB2YXJpYWJsZXMgd2l0aCB1cGRhdGVkIHZhbHVlcworICAgICAgICAgICAgICAgIG1fbGFzdFBh blggPSBjdXJyZW50WDsKKyAgICAgICAgICAgICAgICBtX2xhc3RQYW5ZID0gY3VycmVudFk7CisK KyAgICAgICAgICAgICAgICAvLyBSZXByZXNlbnQgdGhlIHBhbiBnZXN0dXJlIGFzIGEgbW91c2Ug d2hlZWwgZXZlbnQKKyAgICAgICAgICAgICAgICB3aGVlbEV2ZW50ID0gbmV3IFBsYXRmb3JtV2hl ZWxFdmVudChtX3ZpZXdXaW5kb3csIGRlbHRhWCwgZGVsdGFZLCBjdXJyZW50WCwgY3VycmVudFkp OworICAgICAgICAgICAgICAgIGV2ZW50VmFsdWUgPSBjb3JlRnJhbWUtPmV2ZW50SGFuZGxlcigp LT5oYW5kbGVXaGVlbEV2ZW50KCp3aGVlbEV2ZW50KTsKKworICAgICAgICAgICAgICAgIC8vIEZJ WE1FOiBTb29uIHdlJ2xsIGhhdmUgaG9yaXpvbnRhbCB3aW5kb3cgYm91bmNlIHRvbywganVzdCBo YXZlbid0IGltcGxlbWVudGVkIHlldAorICAgICAgICAgICAgICAgIGlmICh2ZXJ0U2Nyb2xsYmFy LT5jdXJyZW50UG9zKCkgPT0gMCkgeworICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRTogSXMg c29tZXRoaW5nIGVsc2UgYmVzaWRlcyAwIGhlcmU/IDAgd29ya2VkIGluIHRlc3RzLCBhbmQgd2lu ZG93IGJvdW5jZSB3b3JrZWQKKyAgICAgICAgICAgICAgICAgICAgaWYgKFVwZGF0ZVBhbm5pbmdG ZWVkYmFja1B0cigpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBVcGRhdGVQYW5uaW5nRmVl ZGJhY2tQdHIoKShtX3ZpZXdXaW5kb3csIDAsIG1feU92ZXJwYW4sIGdpLmR3RmxhZ3MgJiBHRl9J TkVSVElBKTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0gZWxzZSBp ZiAodmVydFNjcm9sbGJhci0+Y3VycmVudFBvcygpID49IHZlcnRTY3JvbGxiYXItPm1heGltdW0o KSkgeworICAgICAgICAgICAgICAgICAgICBpZiAoVXBkYXRlUGFubmluZ0ZlZWRiYWNrUHRyKCkp IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIFVwZGF0ZVBhbm5pbmdGZWVkYmFja1B0cigpKG1f dmlld1dpbmRvdywgMCwgbV95T3ZlcnBhbiwgZ2kuZHdGbGFncyAmIEdGX0lORVJUSUEpOworICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGlm IChnaS5kd0ZsYWdzICYgR0ZfQkVHSU4pIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKEJlZ2lu UGFubmluZ0ZlZWRiYWNrUHRyKCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIEJlZ2luUGFu bmluZ0ZlZWRiYWNrUHRyKCkobV92aWV3V2luZG93KTsKKyAgICAgICAgICAgICAgICAgICAgICAg IG1feU92ZXJwYW4gPSAwOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg fSBlbHNlIGlmIChnaS5kd0ZsYWdzICYgR0ZfRU5EKSB7CisgICAgICAgICAgICAgICAgICAgIGlm IChFbmRQYW5uaW5nRmVlZGJhY2tQdHIoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgRW5k UGFubmluZ0ZlZWRiYWNrUHRyKCkobV92aWV3V2luZG93LCB0cnVlKTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIG1feU92ZXJwYW4gPSAwOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgQ2xvc2VHZXN0dXJlSW5mb0hhbmRsZVB0cigp KChIR0VTVFVSRUlORk8pbFBhcmFtKTsKKyAgICAgICAgICAgICAgICByZXR1cm4gZXZlbnRWYWx1 ZTsKKworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICAgICAg ZGVmYXVsdDoKKyAgICAgICAgICAgICAgICAvLyBZb3UgaGF2ZSBlbmNvdW50ZXJlZCBhbiB1bmtu b3duIGdlc3R1cmUgLSByZXR1cm4gZmFsc2UgdG8gcGFzcyBpdCB0byBEZWZXaW5kb3dQcm9jCisg ICAgICAgICAgICAgICAgQ2xvc2VHZXN0dXJlSW5mb0hhbmRsZVB0cigpKChIR0VTVFVSRUlORk8p bFBhcmFtKTsKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICAgICAg YnJlYWs7CisgICAgICAgIH0KKyAgICAgICAgQ2xvc2VHZXN0dXJlSW5mb0hhbmRsZVB0cigpKChI R0VTVFVSRUlORk8pbFBhcmFtKTsKKyAgICB9IGVsc2UgeworICAgICAgICBEV09SRCBkd0VyciA9 IEdldExhc3RFcnJvcigpOworICAgICAgICBBU1NFUlQoZHdFcnIgPD0gMCk7CQkJLy9kd0VyciA+ IDAgaXMgYW4gZXJyb3IgY29uZGl0aW9uCisgICAgfSAgICAgICAKKworICAgIHJldHVybiB0cnVl OworfQorCiBib29sIFdlYlZpZXc6Om1vdXNlV2hlZWwoV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQ YXJhbSwgYm9vbCBpc01vdXNlSFdoZWVsKQogewogICAgIC8vIEN0cmwrTW91c2Ugd2hlZWwgZG9l c24ndCBldmVyIGdvIGludG8gV2ViQ29yZS4gIEl0IGlzIHVzZWQgdG8KQEAgLTE3MDksNiArMTg2 NiwxMiBAQCBzdGF0aWMgTFJFU1VMVCBDQUxMQkFDSyBXZWJWaWV3V25kUHJvYyhICiAgICAgICAg ICAgICB3ZWJWaWV3LT5zZXRJc0JlaW5nRGVzdHJveWVkKCk7CiAgICAgICAgICAgICB3ZWJWaWV3 LT5yZXZva2VEcmFnRHJvcCgpOwogICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgV01f R0VTVFVSRU5PVElGWToKKyAgICAgICAgICAgIGhhbmRsZWQgPSB3ZWJWaWV3LT5nZXN0dXJlTm90 aWZ5KHdQYXJhbSwgbFBhcmFtKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFdN X0dFU1RVUkU6CisgICAgICAgICAgICBoYW5kbGVkID0gd2ViVmlldy0+Z2VzdHVyZSh3UGFyYW0s IGxQYXJhbSk7CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBXTV9NT1VTRU1PVkU6 CiAgICAgICAgIGNhc2UgV01fTEJVVFRPTkRPV046CiAgICAgICAgIGNhc2UgV01fTUJVVFRPTkRP V046CkluZGV4OiBXZWJLaXQvd2luL1dlYlZpZXcuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2lu L1dlYlZpZXcuaAkocmV2aXNpb24gNDQ4MzIpCisrKyBXZWJLaXQvd2luL1dlYlZpZXcuaAkod29y a2luZyBjb3B5KQpAQCAtNzQyLDYgKzc0Miw4IEBAIHB1YmxpYzoKICAgICBib29sIG9uVW5pbml0 TWVudVBvcHVwKFdQQVJBTSwgTFBBUkFNKTsKICAgICB2b2lkIHBlcmZvcm1Db250ZXh0TWVudUFj dGlvbihXUEFSQU0sIExQQVJBTSwgYm9vbCBieVBvc2l0aW9uKTsKICAgICBib29sIG1vdXNlV2hl ZWwoV1BBUkFNLCBMUEFSQU0sIGJvb2wgaXNNb3VzZUhXaGVlbCk7CisgICAgYm9vbCBnZXN0dXJl KFdQQVJBTSwgTFBBUkFNKTsKKyAgICBib29sIGdlc3R1cmVOb3RpZnkoV1BBUkFNLCBMUEFSQU0p OwogICAgIGJvb2wgZXhlY0NvbW1hbmQoV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSk7CiAg ICAgYm9vbCBrZXlEb3duKFdQQVJBTSwgTFBBUkFNLCBib29sIHN5c3RlbUtleURvd24gPSBmYWxz ZSk7CiAgICAgYm9vbCBrZXlVcChXUEFSQU0sIExQQVJBTSwgYm9vbCBzeXN0ZW1LZXlEb3duID0g ZmFsc2UpOwpAQCAtOTExLDYgKzkxMywxMiBAQCBwcm90ZWN0ZWQ6CiAgICAgSFdORCBtX3RvcExl dmVsUGFyZW50OwogCiAgICAgT3duUHRyPEhhc2hTZXQ8V2ViQ29yZTo6U3RyaW5nPiA+IG1fZW1i ZWRkZWRWaWV3TUlNRVR5cGVzOworCisJLy9WYXJpYWJsZXMgbmVlZGVkIHRvIHN0b3JlIGdlc3R1 cmUgaW5mb3JtYXRpb24KKwlsb25nIG1fbGFzdFBhblg7CisJbG9uZyBtX2xhc3RQYW5ZOworCWxv bmcgbV94T3ZlcnBhbjsKKwlsb25nIG1feU92ZXJwYW47CiB9OwogCiAjZW5kaWYKSW5kZXg6IFdl YktpdC93aW4vV2luZG93c1RvdWNoLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9XaW5kb3dz VG91Y2guaAkocmV2aXNpb24gMCkKKysrIFdlYktpdC93aW4vV2luZG93c1RvdWNoLmgJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsMTEyIEBACisvKg0KKyAqIENvcHlyaWdodCAoQykgMjAwOSBBcHBs ZSBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLg0KKyAqDQorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0DQorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zDQorICogYXJlIG1ldDoNCisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAyLiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNv cHlyaWdodA0KKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUNCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLg0KKyAqDQorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElT JycgQU5EIEFOWQ0KKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgVEhFDQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSDQorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SDQor ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsDQorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLA0KKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNU SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUg0KKyAqIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkNCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiANCisgKi8N CisNCisjaWZuZGVmIFdpbmRvd3NUb3VjaF9IDQorI2RlZmluZSBXaW5kb3dzVG91Y2hfSA0KKw0K Ky8qDQorICogVGhlIGZvbGxvd2luZyBjb25zdGFudHMgYXJlIHVzZWQgdG8gZGV0ZXJtaW5lIG11 bHRpdG91Y2ggYW5kIGdlc3R1cmUgYmVoYXZpb3INCisgKiBmb3IgV2luZG93cyA3LiBGb3IgbW9y ZSBpbmZvcm1hdGlvbiwgc2VlOg0KKyAqIGh0dHA6Ly9tc2RuLm1pY3Jvc29mdC5jb20vZW4tdXMv bGlicmFyeS9kZDU2MjE5NyhWUy44NSkuYXNweA0KKyAqLw0KKw0KKy8vIFZhbHVlIHVzZWQgaW4g V2ViVmlld1duZFByb2MgZm9yIEdlc3R1cmVzDQorI2RlZmluZSBXTV9HRVNUVVJFIDB4MDExOQ0K KyNkZWZpbmUgV01fR0VTVFVSRU5PVElGWSAweDAxMUENCisNCisvLyBHZXN0dXJlIEluZm9ybWF0 aW9uIEZsYWdzDQorI2RlZmluZSBHRl9CRUdJTiAweDAwMDAwMDAxDQorI2RlZmluZSBHRl9JTkVS VElBIDB4MDAwMDAwMDINCisjZGVmaW5lIEdGX0VORCAweDAwMDAwMDA0DQorDQorLy8gR2VzdHVy ZSBJRHMNCisjZGVmaW5lIEdJRF9CRUdJTiAxDQorI2RlZmluZSBHSURfRU5EIDINCisjZGVmaW5l IEdJRF9aT09NIDMNCisjZGVmaW5lIEdJRF9QQU4gNA0KKyNkZWZpbmUgR0lEX1JPVEFURSA1DQor I2RlZmluZSBHSURfVFdPRklOR0VSVEFQIDYNCisjZGVmaW5lIEdJRF9QUkVTU0FORFRBUCA3DQor I2RlZmluZSBHSURfUk9MTE9WRVIgR0lEX1BSRVNTQU5EVEFQDQorDQorLy8gWm9vbSBHZXN0dXJl IENvbmZpcmF0aW9uIEZsYWdzDQorI2RlZmluZSBHQ19aT09NIDB4MDAwMDAwMDENCisNCisvLyBQ YW4gR2VzdHVyZSBDb25maWd1cmF0aW9uIEZsYWdzDQorI2RlZmluZSBHQ19QQU4gMHgwMDAwMDAw MQ0KKyNkZWZpbmUgR0NfUEFOX1dJVEhfU0lOR0xFX0ZJTkdFUl9WRVJUSUNBTExZIDB4MDAwMDAw MDINCisjZGVmaW5lIEdDX1BBTl9XSVRIX1NJTkdMRV9GSU5HRVJfSE9SSVpPTlRBTExZIDB4MDAw MDAwMDQNCisjZGVmaW5lIEdDX1BBTl9XSVRIX0dVVFRFUiAweDAwMDAwMDA4DQorI2RlZmluZSBH Q19QQU5fV0lUSF9JTkVSVElBIDB4MDAwMDAwMTANCisNCisvLyBSb3RhdGUgR2VzdHVyZSBDb25m aWd1cmF0aW9uIEZsYWdzDQorI2RlZmluZSBHQ19ST1RBVEUgMHgwMDAwMDAwMQ0KKw0KKy8vIFR3 byBmaW5nZXIgdGFwIGNvbmZpZ3VyYXRpb24gZmxhZ3MNCisjZGVmaW5lIEdDX1RXT0ZJTkdFUlRB UCAweDAwMDAwMDAxDQorDQorLy8gUHJlc3MgYW5kIHRhcCBDb25maWd1cmF0aW9uIEZsYWdzDQor I2RlZmluZSBHQ19QUkVTU0FORFRBUCAweDAwMDAwMDAxDQorI2RlZmluZSBHQ19ST0xMT1ZFUiBH Q19QUkVTU0FORFRBUA0KKw0KKy8vIEdFU1RVUkVJTkZPIHN0cnVjdCBkZWZpbml0aW9uDQordHlw ZWRlZiBzdHJ1Y3QgdGFnR0VTVFVSRUlORk8gew0KKyAgICBVSU5UIGNiU2l6ZTsgICAgICAgICAg ICAgICAgICAgIC8vIHNpemUsIGluIGJ5dGVzLCBvZiB0aGlzIHN0cnVjdHVyZSAoaW5jbHVkaW5n IHZhcmlhYmxlIGxlbmd0aCBBcmdzIGZpZWxkKQ0KKyAgICBEV09SRCBkd0ZsYWdzOyAgICAgICAg ICAgICAgICAgIC8vIHNlZSBHRl8qIGZsYWdzDQorICAgIERXT1JEIGR3SUQ7ICAgICAgICAgICAg ICAgICAgICAgLy8gZ2VzdHVyZSBJRCwgc2VlIEdJRF8qIGRlZmluZXMNCisgICAgSFdORCBod25k VGFyZ2V0OyAgICAgICAgICAgICAgICAvLyBoYW5kbGUgdG8gd2luZG93IHRhcmdldGVkIGJ5IHRo aXMgZ2VzdHVyZQ0KKyAgICBQT0lOVFMgcHRzTG9jYXRpb247ICAgICAgICAgICAgIC8vIGN1cnJl bnQgbG9jYXRpb24gb2YgdGhpcyBnZXN0dXJlDQorICAgIERXT1JEIGR3SW5zdGFuY2VJRDsgICAg ICAgICAgICAgLy8gaW50ZXJuYWxseSB1c2VkDQorICAgIERXT1JEIGR3U2VxdWVuY2VJRDsgICAg ICAgICAgICAgLy8gaW50ZXJuYWxseSB1c2VkDQorICAgIFVMT05HTE9ORyB1bGxBcmd1bWVudHM7 ICAgICAgICAgLy8gYXJndW1lbnRzIGZvciBnZXN0dXJlcyB3aG9zZSBhcmd1bWVudHMgZml0IGlu IDggQllURVMNCisgICAgVUlOVCBjYkV4dHJhQXJnczsgICAgICAgICAgICAgICAvLyBzaXplLCBp biBieXRlcywgb2YgZXh0cmEgYXJndW1lbnRzLCBpZiBhbnksIHRoYXQgYWNjb21wYW55IHRoaXMg Z2VzdHVyZQ0KK30gR0VTVFVSRUlORk8sICpQR0VTVFVSRUlORk87DQordHlwZWRlZiBHRVNUVVJF SU5GTyBjb25zdCAqIFBDR0VTVFVSRUlORk87DQorDQorLy8gR0VTVFVSRUNPTkZJRyBzdHJ1Y3Qg ZGVmaW50aW9uDQordHlwZWRlZiBzdHJ1Y3QgdGFnR0VTVFVSRUNPTkZJRyB7DQorICAgIERXT1JE IGR3SUQ7ICAgICAgICAgICAgICAgICAgICAgLy8gZ2VzdHVyZSBJRA0KKyAgICBEV09SRCBkd1dh bnQ7ICAgICAgICAgICAgICAgICAgIC8vIHNldHRpbmdzIHJlbGF0ZWQgdG8gZ2VzdHVyZSBJRCB0 aGF0IGFyZSB0byBiZSB0dXJuZWQgb24NCisgICAgRFdPUkQgZHdCbG9jazsgICAgICAgICAgICAg ICAgICAvLyBzZXR0aW5ncyByZWxhdGVkIHRvIGdlc3R1cmUgSUQgdGhhdCBhcmUgdG8gYmUgdHVy bmVkIG9mZg0KK30gR0VTVFVSRUNPTkZJRywgKlBHRVNUVVJFQ09ORklHOw0KKw0KKy8qDQorICog R2VzdHVyZSBub3RpZmljYXRpb24gc3RydWN0dXJlDQorICogICAtIFRoZSBXTV9HRVNUVVJFTk9U SUZZIG1lc3NhZ2UgbFBhcmFtIGNvbnRhaW5zIGEgcG9pbnRlciB0byB0aGlzIHN0cnVjdHVyZS4N CisgKiAgIC0gVGhlIFdNX0dFU1RVUkVOT1RJRlkgbWVzc2FnZSBub3RpZmllcyBhIHdpbmRvdyB0 aGF0IGdlc3R1cmUgcmVjb2duaXRpb24gaXMNCisgKiAgICAgaW4gcHJvZ3Jlc3MgYW5kIGEgZ2Vz dHVyZSB3aWxsIGJlIGdlbmVyYXRlZCBpZiBvbmUgaXMgcmVjb2duaXplZCB1bmRlciB0aGUNCisg KiAgICAgY3VycmVudCBnZXN0dXJlIHNldHRpbmdzLg0KKyAqLw0KK3R5cGVkZWYgc3RydWN0IHRh Z0dFU1RVUkVOT1RJRllTVFJVQ1Qgew0KKyAgICBVSU5UIGNiU2l6ZTsgICAgICAgICAgICAgICAg ICAgIC8vIHNpemUsIGluIGJ5dGVzLCBvZiB0aGlzIHN0cnVjdHVyZQ0KKyAgICBEV09SRCBkd0Zs YWdzOyAgICAgICAgICAgICAgICAgIC8vIHVudXNlZA0KKyAgICBIV05EIGh3bmRUYXJnZXQ7ICAg ICAgICAgICAgICAgIC8vIGhhbmRsZSB0byB3aW5kb3cgdGFyZ2V0ZWQgYnkgdGhlIGdlc3R1cmUN CisgICAgUE9JTlRTIHB0c0xvY2F0aW9uOyAgICAgICAgICAgICAvLyBzdGFydGluZyBsb2NhdGlv bg0KKyAgICBEV09SRCBkd0luc3RhbmNlSUQ7ICAgICAgICAgICAgIC8vIGludGVybmFsbHkgdXNl ZA0KK30gR0VTVFVSRU5PVElGWVNUUlVDVCwgKlBHRVNUVVJFTk9USUZZU1RSVUNUOw0KKw0KK0RF Q0xBUkVfSEFORExFKEhHRVNUVVJFSU5GTyk7DQorDQorI2VuZGlmClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQoKUHJvcGVydHkgY2hhbmdlcyBvbjogV2ViS2l0L3dpbi9XaW5kb3dzVG91Y2gu aApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCkFkZGVkOiBzdm46ZXhlY3V0YWJsZQogICArICoKCkluZGV4OiBXZWJLaXQv d2luL1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvago9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2lu L1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvagkocmV2aXNpb24gNDQ4MzIpCisrKyBXZWJLaXQv d2luL1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAtNzM3LDYg KzczNywxMCBAQAogCQkJCVJlbGF0aXZlUGF0aD0iLi5cV2ViVmlldy5oIg0KIAkJCQk+DQogCQkJ PC9GaWxlPg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cV2luZG93c1RvdWNoLmgi DQorCQkJCT4NCisJCQk8L0ZpbGU+DQogCQk8L0ZpbHRlcj4NCiAJCTxGaWx0ZXINCiAJCQlOYW1l PSJDbGFzc2VzIg0K 31570 2009-06-19 16:29:21 -0700 2009-06-25 15:43:18 -0700 Take 2 of Panning Panning.patch text/plain 17466 bweinstein SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NDg1OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjAgQEAKKzIwMDktMDYtMTkgIEJyaWFuIFdlaW5zdGVpbiAgPGJ3ZWluc3RlaW5A YXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorICAgICAg ICAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2NDg4 CisgICAgICAgIE5vIFN1cHBvcnQgZm9yIFNpbmdsZSBGaW5nZXIgb3IgVHdvIEZpbmdlciBQYW5u aW5nIGluIFdpbmRvd3MgNworICAgICAgICAKKyAgICAgICAgVGhlIGNvZGUgaW4gV2ViQ29yZSBh bGxvd3MgdXMgdG8gaW50ZXJwcmV0IGEgUGFuIGdlc3R1cmUgYXMKKyAgICAgICAgYSBtb3VzZXdo ZWVsIGV2ZW50LCBhbmQgd2UgYXJlIGFibGUgdG8gcmV1c2UgdGhlIHNjcm9sbGluZyBjb2RlLgor ICAgICAgICBBbm90aGVyIGNvbnN0cnVjdG9yIHdhcyBjcmVhdGVkIGluIFdoZWVsRXZlbnRXaW4g d2hpY2ggdGFrZXMgZGF0YQorICAgICAgICBiZXR0ZXIgc3VpdGVkIHRvIHRoZSBwYW4gZ3Vlc3R1 cmUgdGhhbiB3aGF0IHdhcyBjdXJyZW50bHkgdGhlcmUuIAorICAgICAgICAKKyAgICAgICAgVW5h YmxlIHRvIGFkZCB0ZXN0cyB0byBzaW11bGF0ZSB0b3VjaCBiZWhhdmlvci9nZXN0dXJlcy4KKwor ICAgICAgICAqIHBsYXRmb3JtL1BsYXRmb3JtV2hlZWxFdmVudC5oOgorICAgICAgICAqIHBsYXRm b3JtL3dpbi9XaGVlbEV2ZW50V2luLmNwcDoKKwogMjAwOS0wNi0xOSAgSnVuZ3NoaWsgU2hpbiAg PGpzaGluQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBMZXZpbgpJ bmRleDogV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybVdoZWVsRXZlbnQuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BsYXRmb3JtL1BsYXRmb3JtV2hlZWxFdmVudC5oCShyZXZpc2lvbiA0NDgzMikK KysrIFdlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1XaGVlbEV2ZW50LmgJKHdvcmtpbmcgY29weSkK QEAgLTk5LDYgKzk5LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAjaWYgUExBVEZPUk0oV0lO KQogICAgICAgICBQbGF0Zm9ybVdoZWVsRXZlbnQoSFdORCwgV1BBUkFNLCBMUEFSQU0sIGJvb2wg aXNNb3VzZUhXaGVlbCk7CisgICAgICAgIFBsYXRmb3JtV2hlZWxFdmVudChIV05ELCBmbG9hdCBk ZWx0YVgsIGZsb2F0IGRlbHRhWSwgZmxvYXQgeExvYywgZmxvYXQgeUxvYyk7CiAjZW5kaWYKIAog I2lmIFBMQVRGT1JNKFdYKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS93aW4vV2hlZWxFdmVudFdp bi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS93aW4vV2hlZWxFdmVudFdpbi5j cHAJKHJldmlzaW9uIDQ0ODMyKQorKysgV2ViQ29yZS9wbGF0Zm9ybS93aW4vV2hlZWxFdmVudFdp bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYyLDYgKzYyLDI4IEBAIHN0YXRpYyBpbnQgdmVydGlj YWxTY3JvbGxMaW5lcygpCiAgICAgcmV0dXJuIHNjcm9sbExpbmVzOwogfQogCitQbGF0Zm9ybVdo ZWVsRXZlbnQ6OlBsYXRmb3JtV2hlZWxFdmVudChIV05EIGhXbmQsIGZsb2F0IGRlbHRhWCwgZmxv YXQgZGVsdGFZLCBmbG9hdCB4TG9jLCBmbG9hdCB5TG9jKQorICAgIDogbV9pc0FjY2VwdGVkKGZh bHNlKQorICAgICwgbV9zaGlmdEtleShmYWxzZSkKKyAgICAsIG1fY3RybEtleShmYWxzZSkKKyAg ICAsIG1fYWx0S2V5KGZhbHNlKQorICAgICwgbV9tZXRhS2V5KGZhbHNlKQoreworICAgIG1fZGVs dGFYID0gZGVsdGFYOworICAgIG1fZGVsdGFZID0gZGVsdGFZOworCisgICAgbV93aGVlbFRpY2tz WCA9IG1fZGVsdGFYOworICAgIG1fd2hlZWxUaWNrc1kgPSBtX2RlbHRhWTsKKworICAgIC8vIEds b2JhbCBQb3NpdGlvbiBpcyBqdXN0IHgsIHkgbG9jYXRpb24gb2YgZXZlbnQKKyAgICBQT0lOVCBw b2ludCA9IHt4TG9jLCB5TG9jfTsKKyAgICBtX2dsb2JhbFBvc2l0aW9uID0gcG9pbnQ7CisKKyAg ICAvLyBQb3NpdGlvbiBuZWVkcyB0byBiZSB0cmFuc2xhdGVkIHRvIG91ciBjbGllbnQKKyAgICBT Y3JlZW5Ub0NsaWVudChoV25kLCAmcG9pbnQpOworICAgIG1fcG9zaXRpb24gPSBwb2ludDsKK30K KwogUGxhdGZvcm1XaGVlbEV2ZW50OjpQbGF0Zm9ybVdoZWVsRXZlbnQoSFdORCBoV25kLCBXUEFS QU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtLCBib29sIGlzTW91c2VIV2hlZWwpCiAgICAgOiBtX3Bv c2l0aW9uKHBvc2l0aW9uRm9yRXZlbnQoaFduZCwgbFBhcmFtKSkKICAgICAsIG1fZ2xvYmFsUG9z aXRpb24oZ2xvYmFsUG9zaXRpb25Gb3JFdmVudChoV25kLCBsUGFyYW0pKQpJbmRleDogV2ViS2l0 L3dpbi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlz aW9uIDQ0ODU4KQorKysgV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwyMyBAQAorMjAwOS0wNi0xOSAgQnJpYW4gV2VpbnN0ZWluICA8YndlaW5zdGVpbkBhcHBs ZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjY0ODgKKyAg ICAgICAgTm8gU3VwcG9ydCBmb3IgU2luZ2xlIEZpbmdlciBvciBUd28gRmluZ2VyIFBhbm5pbmcg aW4gV2luZG93cyA3CisgICAgICAgIAorICAgICAgICBBZGRlZCB0aGUgY29kZSBuZWNlc3Nhcnkg Zm9yIHNpbmdsZSBmaW5nZXIgYW5kIHR3by1maW5nZXIgcGFubmluZyB3aXRoCisgICAgICAgIHdp bmRvdyBib3VuY2UuIFdlIG5vdyByZWdpc3RlciBmb3IgV01fR0VTVFVSRU5PVElGWSBhbmQgV01f R0VTVFVSRSBtZXNzYWdlcywKKyAgICAgICAgYW5kIGludGVycHJldCB0aGUgcGFubmluZyBjb21t YW5kLiBBbHNvLCBhZGRlZCBXaW5kb3dzVG91Y2guaCB3aGljaCBjb250YWlucyAKKyAgICAgICAg c3RydWN0cyBhbmQgI2RlZmluZXMgZnJvbSB0aGUgV2luZG93cyA3IFNESy4KKworICAgICAgICAq IFdlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvajoKKyAgICAgICAgKiBXZWJWaWV3LmNwcDoKKyAg ICAgICAgKFdlYlZpZXc6Omdlc3R1cmVOb3RpZnkpOiBDaGVja3MgaWYgd2UgYXJlIGluIGEgcGFu bmFibGUgcmVnaW9uIC0gSUU6IE5vdCBpbiB0aGUgc2Nyb2xsYmFyCisgICAgICAgIChXZWJWaWV3 OjpnZXN0dXJlKTogSGFuZGxlcyB0aGUgUGFubmluZyBnZXN0dXJlLCBjcmVhdGluZyB0aGUgV2hl ZWxFdmVudAorICAgICAgICAoV2ViVmlld1duZFByb2MpOiBBZGRlZCBjYXNlcyBmb3IgV01fR0VT VFVSRSBhbmQgV01fR0VTVFVSRU5PVElGWQorICAgICAgICAqIFdlYlZpZXcuaDoKKyAgICAgICAg KiBXaW5kb3dzVG91Y2guaDogQWRkZWQuCisKIDIwMDktMDYtMTggIEFkYW0gQmFydGggIDxhYmFy dGhAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDog V2ViS2l0L3dpbi9XZWJWaWV3LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlZpZXcu Y3BwCShyZXZpc2lvbiA0NDgzMikKKysrIFdlYktpdC93aW4vV2ViVmlldy5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJDRkRpY3Rpb25hcnlQcm9wZXJ0eUJh Zy5oIgogI2luY2x1ZGUgIkRPTUNvcmVDbGFzc2VzLmgiCiAjaW5jbHVkZSAiTWFyc2hhbGxpbmdI ZWxwZXJzLmgiCisjaW5jbHVkZSAiU29mdExpbmtpbmcuaCIKICNpbmNsdWRlICJXZWJEYXRhYmFz ZU1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJEb2N1bWVudExvYWRlci5oIgogI2luY2x1ZGUgIldl YkRvd25sb2FkLmgiCkBAIC01MCw2ICs1MSw3IEBACiAjaW5jbHVkZSAiV2ViTXV0YWJsZVVSTFJl cXVlc3QuaCIKICNpbmNsdWRlICJXZWJOb3RpZmljYXRpb25DZW50ZXIuaCIKICNpbmNsdWRlICJX ZWJQcmVmZXJlbmNlcy5oIgorI2luY2x1ZGUgIldpbmRvd3NUb3VjaC5oIgogI3ByYWdtYSB3YXJu aW5nKCBwdXNoLCAwICkKICNpbmNsdWRlIDxXZWJDb3JlL0FwcGxpY2F0aW9uQ2FjaGVTdG9yYWdl Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9BWE9iamVjdENhY2hlLmg+CkBAIC05NSw2ICs5Nyw3IEBA CiAjaW5jbHVkZSA8V2ViQ29yZS9SZXNvdXJjZUhhbmRsZS5oPgogI2luY2x1ZGUgPFdlYkNvcmUv UmVzb3VyY2VIYW5kbGVDbGllbnQuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1NjcmlwdFZhbHVlLmg+ CisjaW5jbHVkZSA8V2ViQ29yZS9TY3JvbGxiYXIuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1Njcm9s bGJhclRoZW1lLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9TZWN1cml0eU9yaWdpbi5oPgogI2luY2x1 ZGUgPFdlYkNvcmUvU2VsZWN0aW9uQ29udHJvbGxlci5oPgpAQCAtMTI4LDYgKzEzMSwxNiBAQAog I2luY2x1ZGUgPHRjaGFyLmg+CiAjaW5jbHVkZSA8d2luZG93c3guaD4KIAorLy8gU29mdCBsaW5r IGZ1bmN0aW9ucyBmb3IgZ2VzdHVyZXMgYW5kIHBhbm5pbmcgZmVlZGJhY2sKK1NPRlRfTElOS19M SUJSQVJZKFVTRVIzMik7CitTT0ZUX0xJTktfT1BUSU9OQUwoVVNFUjMyLCBHZXRHZXN0dXJlSW5m bywgQk9PTCwgV0lOQVBJLCAoSEdFU1RVUkVJTkZPLCBQR0VTVFVSRUlORk8pKTsKK1NPRlRfTElO S19PUFRJT05BTChVU0VSMzIsIFNldEdlc3R1cmVDb25maWcsIEJPT0wsIFdJTkFQSSwgKEhXTkQs IERXT1JELCBVSU5ULCBQR0VTVFVSRUNPTkZJRywgVUlOVCkpOworU09GVF9MSU5LX09QVElPTkFM KFVTRVIzMiwgQ2xvc2VHZXN0dXJlSW5mb0hhbmRsZSwgQk9PTCwgV0lOQVBJLCAoSEdFU1RVUkVJ TkZPKSk7CitTT0ZUX0xJTktfTElCUkFSWShVeHRoZW1lKTsKK1NPRlRfTElOS19PUFRJT05BTChV eHRoZW1lLCBCZWdpblBhbm5pbmdGZWVkYmFjaywgQk9PTCwgV0lOQVBJLCAoSFdORCkpOworU09G VF9MSU5LX09QVElPTkFMKFV4dGhlbWUsIEVuZFBhbm5pbmdGZWVkYmFjaywgQk9PTCwgV0lOQVBJ LCAoSFdORCwgQk9PTCkpOworU09GVF9MSU5LX09QVElPTkFMKFV4dGhlbWUsIFVwZGF0ZVBhbm5p bmdGZWVkYmFjaywgQk9PTCwgV0lOQVBJLCAoSFdORCwgTE9ORywgTE9ORywgQk9PTCkpOworCiB1 c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIHVzaW5nIEpTQzo6SlNMb2NrOwogdXNpbmcgc3RkOjpt aW47CkBAIC0yOTgsNiArMzExLDEwIEBAIFdlYlZpZXc6OldlYlZpZXcoKQogLCBtX2RlbGV0ZUJh Y2tpbmdTdG9yZVRpbWVyQWN0aXZlKGZhbHNlKQogLCBtX3RyYW5zcGFyZW50KGZhbHNlKQogLCBt X3NlbGVjdFRyYWlsaW5nV2hpdGVzcGFjZUVuYWJsZWQoZmFsc2UpCissIG1fbGFzdFBhblgoMCkK KywgbV9sYXN0UGFuWSgwKQorLCBtX3hPdmVycGFuKDApCissIG1feU92ZXJwYW4oMCkKIHsKICAg ICBKU0M6OmluaXRpYWxpemVUaHJlYWRpbmcoKTsKIApAQCAtMTMyNSw2ICsxMzQyLDEzMCBAQCBi b29sIFdlYlZpZXc6OmhhbmRsZU1vdXNlRXZlbnQoVUlOVCBtZXNzCiAgICAgcmV0dXJuIGhhbmRs ZWQ7CiB9CiAKK2Jvb2wgV2ViVmlldzo6Z2VzdHVyZU5vdGlmeShXUEFSQU0gd1BhcmFtLCBMUEFS QU0gbFBhcmFtKQoreworICAgIEdFU1RVUkVOT1RJRllTVFJVQ1QqIGduID0gcmVpbnRlcnByZXRf Y2FzdDxHRVNUVVJFTk9USUZZU1RSVUNUKj4obFBhcmFtKTsKKworICAgIEZyYW1lKiBjb3JlRnJh bWUgPSBjb3JlKG1fbWFpbkZyYW1lKTsKKyAgICBpZiAoIWNvcmVGcmFtZSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgU2Nyb2xsVmlldyogdmlldyA9IGNvcmVGcmFtZS0+dmlldygpOwor ICAgIGlmICghdmlldykKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgLy8gSWYgd2UgZG9u J3QgaGF2ZSB0aGlzIGZ1bmN0aW9uLCB3ZSBzaG91bGRuJ3QgYmUgcmVjZWl2aW5nIHRoaXMgbWVz c2FnZQorICAgIEFTU0VSVChTZXRHZXN0dXJlQ29uZmlnUHRyKCkpOworCisgICAgRFdPUkQgZHdQ YW5XYW50OworICAgIERXT1JEIGR3UGFuQmxvY2s7IAorCisgICAgLy8gVHJhbnNsYXRlIGdlc3R1 cmUgbG9jYXRpb24gdG8gY2xpZW50IHRvIGhpdCB0ZXN0IG9uIHNjcm9sbGJhcnMKKyAgICBQT0lO VCBnZXN0dXJlQmVnaW5Qb2ludCA9IHtnbi0+cHRzTG9jYXRpb24ueCwgZ24tPnB0c0xvY2F0aW9u Lnl9OworICAgIFNjcmVlblRvQ2xpZW50KG1fdmlld1dpbmRvdywgJmdlc3R1cmVCZWdpblBvaW50 KTsKKworICAgIGlmIChnZXN0dXJlQmVnaW5Qb2ludC54ID4gdmlldy0+dmlzaWJsZVdpZHRoKCkp IHsKKyAgICAgICAgLy8gV2UgYXJlIGluIHRoZSBzY3JvbGxiYXIsIHR1cm4gb2ZmIHBhbm5pbmcs IG5lZWQgdG8gYmUgYWJsZSB0byBkcmFnIHRoZSBzY3JvbGxiYXIKKyAgICAgICAgZHdQYW5XYW50 ID0gR0NfUEFOICB8IEdDX1BBTl9XSVRIX0lORVJUSUEgfCBHQ19QQU5fV0lUSF9HVVRURVI7Cisg ICAgICAgIGR3UGFuQmxvY2sgPSBHQ19QQU5fV0lUSF9TSU5HTEVfRklOR0VSX0hPUklaT05UQUxM WSB8IEdDX1BBTl9XSVRIX1NJTkdMRV9GSU5HRVJfVkVSVElDQUxMWTsJCisgICAgfSBlbHNlIHsK KyAgICAgICAgZHdQYW5XYW50ID0gR0NfUEFOICB8IEdDX1BBTl9XSVRIX1NJTkdMRV9GSU5HRVJf VkVSVElDQUxMWSB8IEdDX1BBTl9XSVRIX0lORVJUSUEgfCBHQ19QQU5fV0lUSF9HVVRURVI7Cisg ICAgICAgIGR3UGFuQmxvY2sgPSBHQ19QQU5fV0lUSF9TSU5HTEVfRklOR0VSX0hPUklaT05UQUxM WTsJCisgICAgfQorCisgICAgR0VTVFVSRUNPTkZJRyBnYyA9IHsgR0lEX1BBTiwgZHdQYW5XYW50 ICwgZHdQYW5CbG9jayB9IDsKKyAgICByZXR1cm4gU2V0R2VzdHVyZUNvbmZpZ1B0cigpKG1fdmll d1dpbmRvdywgMCwgMSwgJmdjLCBzaXplb2YoR0VTVFVSRUNPTkZJRykpOworfQorCitib29sIFdl YlZpZXc6Omdlc3R1cmUoV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSkgCit7CisgICAgLy8g V2Ugd2FudCB0byBiYWlsIG91dCBpZiB3ZSBkb24ndCBoYXZlIGVpdGhlciBvZiB0aGVzZSBmdW5j dGlvbnMKKyAgICBpZiAoIUdldEdlc3R1cmVJbmZvUHRyKCkgfHwgIUNsb3NlR2VzdHVyZUluZm9I YW5kbGVQdHIoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgR0VTVFVSRUlORk8gZ2kg PSB7MH07CisgICAgZ2kuY2JTaXplID0gc2l6ZW9mKEdFU1RVUkVJTkZPKTsKKworICAgIGlmICgh R2V0R2VzdHVyZUluZm9QdHIoKShyZWludGVycHJldF9jYXN0PEhHRVNUVVJFSU5GTz4obFBhcmFt KSwgcmVpbnRlcnByZXRfY2FzdDxQR0VTVFVSRUlORk8+KCZnaSkpKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisKKyAgICBzd2l0Y2ggKGdpLmR3SUQpIHsKKyAgICBjYXNlIEdJRF9CRUdJTjoKKyAg ICAgICAgbV9sYXN0UGFuWCA9IGdpLnB0c0xvY2F0aW9uLng7CisgICAgICAgIG1fbGFzdFBhblkg PSBnaS5wdHNMb2NhdGlvbi55OworCisgICAgICAgIENsb3NlR2VzdHVyZUluZm9IYW5kbGVQdHIo KShyZWludGVycHJldF9jYXN0PEhHRVNUVVJFSU5GTz4obFBhcmFtKSk7CisgICAgICAgIGJyZWFr OworICAgIGNhc2UgR0lEX1BBTjogeworICAgICAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZSht X21haW5GcmFtZSk7CisgICAgICAgIGlmICghY29yZUZyYW1lKSB7CisgICAgICAgICAgICBDbG9z ZUdlc3R1cmVJbmZvSGFuZGxlUHRyKCkocmVpbnRlcnByZXRfY2FzdDxIR0VTVFVSRUlORk8+KGxQ YXJhbSkpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisKKyAgICAgICAg U2Nyb2xsVmlldyogdmlldyA9IGNvcmVGcmFtZS0+dmlldygpOworICAgICAgICBpZiAoIXZpZXcp IHsKKyAgICAgICAgICAgIENsb3NlR2VzdHVyZUluZm9IYW5kbGVQdHIoKShyZWludGVycHJldF9j YXN0PEhHRVNUVVJFSU5GTz4obFBhcmFtKSk7CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7Cisg ICAgICAgIH0KKworICAgICAgICBTY3JvbGxiYXIqIHZlcnRTY3JvbGxiYXIgPSB2aWV3LT52ZXJ0 aWNhbFNjcm9sbGJhcigpOworICAgICAgICBpZiAoIXZlcnRTY3JvbGxiYXIpIHsKKyAgICAgICAg ICAgIENsb3NlR2VzdHVyZUluZm9IYW5kbGVQdHIoKShyZWludGVycHJldF9jYXN0PEhHRVNUVVJF SU5GTz4obFBhcmFtKSk7CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsJLy9ObyBwYW5uaW5nIG9m IGFueSBraW5kIHdoZW4gbm8gdmVydGljYWwgc2Nyb2xsYmFyLCBtYXRjaGVzIElFOAorICAgICAg ICB9CisKKyAgICAgICAgLy8gV2hlcmUgYXJlIHRoZSBmaW5nZXJzIGN1cnJlbnRseT8KKyAgICAg ICAgbG9uZyBjdXJyZW50WCA9IGdpLnB0c0xvY2F0aW9uLng7CisgICAgICAgIGxvbmcgY3VycmVu dFkgPSBnaS5wdHNMb2NhdGlvbi55OworICAgICAgICAKKyAgICAgICAgLy8gSG93IGZhciBkaWQg d2UgcGFuIGluIGVhY2ggZGlyZWN0aW9uPworICAgICAgICBsb25nIGRlbHRhWCA9IGN1cnJlbnRY IC0gbV9sYXN0UGFuWDsKKyAgICAgICAgbG9uZyBkZWx0YVkgPSBjdXJyZW50WSAtIG1fbGFzdFBh blk7CisgICAgICAgIAorICAgICAgICAvLyBDYWxjdWxhdGUgdGhlIG92ZXJwYW4gZm9yIHdpbmRv dyBib3VuY2UKKyAgICAgICAgbV95T3ZlcnBhbiAtPSBtX2xhc3RQYW5ZIC0gY3VycmVudFk7Cisg ICAgICAgIG1feE92ZXJwYW4gLT0gbV9sYXN0UGFuWCAtIGN1cnJlbnRYOworICAgICAgICAKKyAg ICAgICAgLy8gVXBkYXRlIG91ciBjbGFzcyB2YXJpYWJsZXMgd2l0aCB1cGRhdGVkIHZhbHVlcwor ICAgICAgICBtX2xhc3RQYW5YID0gY3VycmVudFg7CisgICAgICAgIG1fbGFzdFBhblkgPSBjdXJy ZW50WTsKKworICAgICAgICAvLyBSZXByZXNlbnQgdGhlIHBhbiBnZXN0dXJlIGFzIGEgbW91c2Ug d2hlZWwgZXZlbnQKKyAgICAgICAgUGxhdGZvcm1XaGVlbEV2ZW50IHdoZWVsRXZlbnQobV92aWV3 V2luZG93LCBkZWx0YVgsIGRlbHRhWSwgY3VycmVudFgsIGN1cnJlbnRZKTsKKyAgICAgICAgY29y ZUZyYW1lLT5ldmVudEhhbmRsZXIoKS0+aGFuZGxlV2hlZWxFdmVudCh3aGVlbEV2ZW50KTsKKwor ICAgICAgICBpZiAoIShVcGRhdGVQYW5uaW5nRmVlZGJhY2tQdHIoKSAmJiBCZWdpblBhbm5pbmdG ZWVkYmFja1B0cigpICYmIEVuZFBhbm5pbmdGZWVkYmFja1B0cigpKSkgeworICAgICAgICAgICAg Q2xvc2VHZXN0dXJlSW5mb0hhbmRsZVB0cigpKHJlaW50ZXJwcmV0X2Nhc3Q8SEdFU1RVUkVJTkZP PihsUGFyYW0pKTsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisKKyAgICAg ICAgLy8gRklYTUU6IFNvb24gd2UnbGwgaGF2ZSBob3Jpem9udGFsIHdpbmRvdyBib3VuY2UgdG9v LCBqdXN0IGhhdmVuJ3QgaW1wbGVtZW50ZWQgeWV0CisgICAgICAgIGlmICh2ZXJ0U2Nyb2xsYmFy LT5jdXJyZW50UG9zKCkgPT0gMCkKKyAgICAgICAgICAgIFVwZGF0ZVBhbm5pbmdGZWVkYmFja1B0 cigpKG1fdmlld1dpbmRvdywgMCwgbV95T3ZlcnBhbiwgZ2kuZHdGbGFncyAmIEdGX0lORVJUSUEp OworICAgICAgICBlbHNlIGlmICh2ZXJ0U2Nyb2xsYmFyLT5jdXJyZW50UG9zKCkgPj0gdmVydFNj cm9sbGJhci0+bWF4aW11bSgpKQorICAgICAgICAgICAgVXBkYXRlUGFubmluZ0ZlZWRiYWNrUHRy KCkobV92aWV3V2luZG93LCAwLCBtX3lPdmVycGFuLCBnaS5kd0ZsYWdzICYgR0ZfSU5FUlRJQSk7 CisgICAgICAgIAorICAgICAgICBpZiAoZ2kuZHdGbGFncyAmIEdGX0JFR0lOKSB7CisgICAgICAg ICAgICBCZWdpblBhbm5pbmdGZWVkYmFja1B0cigpKG1fdmlld1dpbmRvdyk7CisgICAgICAgICAg ICBtX3lPdmVycGFuID0gMDsKKyAgICAgICAgfSBlbHNlIGlmIChnaS5kd0ZsYWdzICYgR0ZfRU5E KSB7CisgICAgICAgICAgICBFbmRQYW5uaW5nRmVlZGJhY2tQdHIoKShtX3ZpZXdXaW5kb3csIHRy dWUpOworICAgICAgICAgICAgbV95T3ZlcnBhbiA9IDA7CisgICAgICAgIH0KKworICAgICAgICBD bG9zZUdlc3R1cmVJbmZvSGFuZGxlUHRyKCkocmVpbnRlcnByZXRfY2FzdDxIR0VTVFVSRUlORk8+ KGxQYXJhbSkpOworICAgICAgICBicmVhazsKKyAgICB9CisgICAgZGVmYXVsdDoKKyAgICAgICAg Ly8gV2UgaGF2ZSBlbmNvdW50ZXJlZCBhbiB1bmtub3duIGdlc3R1cmUgLSByZXR1cm4gZmFsc2Ug dG8gcGFzcyBpdCB0byBEZWZXaW5kb3dQcm9jCisgICAgICAgIENsb3NlR2VzdHVyZUluZm9IYW5k bGVQdHIoKShyZWludGVycHJldF9jYXN0PEhHRVNUVVJFSU5GTz4obFBhcmFtKSk7CisgICAgICAg IGJyZWFrOworICAgIH0KKworICAgIHJldHVybiB0cnVlOworfQorCiBib29sIFdlYlZpZXc6Om1v dXNlV2hlZWwoV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSwgYm9vbCBpc01vdXNlSFdoZWVs KQogewogICAgIC8vIEN0cmwrTW91c2Ugd2hlZWwgZG9lc24ndCBldmVyIGdvIGludG8gV2ViQ29y ZS4gIEl0IGlzIHVzZWQgdG8KQEAgLTE3MDksNiArMTg1MCwxMiBAQCBzdGF0aWMgTFJFU1VMVCBD QUxMQkFDSyBXZWJWaWV3V25kUHJvYyhICiAgICAgICAgICAgICB3ZWJWaWV3LT5zZXRJc0JlaW5n RGVzdHJveWVkKCk7CiAgICAgICAgICAgICB3ZWJWaWV3LT5yZXZva2VEcmFnRHJvcCgpOwogICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgV01fR0VTVFVSRU5PVElGWToKKyAgICAgICAg ICAgIGhhbmRsZWQgPSB3ZWJWaWV3LT5nZXN0dXJlTm90aWZ5KHdQYXJhbSwgbFBhcmFtKTsKKyAg ICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFdNX0dFU1RVUkU6CisgICAgICAgICAgICBo YW5kbGVkID0gd2ViVmlldy0+Z2VzdHVyZSh3UGFyYW0sIGxQYXJhbSk7CisgICAgICAgICAgICBi cmVhazsKICAgICAgICAgY2FzZSBXTV9NT1VTRU1PVkU6CiAgICAgICAgIGNhc2UgV01fTEJVVFRP TkRPV046CiAgICAgICAgIGNhc2UgV01fTUJVVFRPTkRPV046CkluZGV4OiBXZWJLaXQvd2luL1dl YlZpZXcuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlZpZXcuaAkocmV2aXNpb24gNDQ4 MzIpCisrKyBXZWJLaXQvd2luL1dlYlZpZXcuaAkod29ya2luZyBjb3B5KQpAQCAtNzQyLDYgKzc0 Miw4IEBAIHB1YmxpYzoKICAgICBib29sIG9uVW5pbml0TWVudVBvcHVwKFdQQVJBTSwgTFBBUkFN KTsKICAgICB2b2lkIHBlcmZvcm1Db250ZXh0TWVudUFjdGlvbihXUEFSQU0sIExQQVJBTSwgYm9v bCBieVBvc2l0aW9uKTsKICAgICBib29sIG1vdXNlV2hlZWwoV1BBUkFNLCBMUEFSQU0sIGJvb2wg aXNNb3VzZUhXaGVlbCk7CisgICAgYm9vbCBnZXN0dXJlKFdQQVJBTSwgTFBBUkFNKTsKKyAgICBi b29sIGdlc3R1cmVOb3RpZnkoV1BBUkFNLCBMUEFSQU0pOwogICAgIGJvb2wgZXhlY0NvbW1hbmQo V1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSk7CiAgICAgYm9vbCBrZXlEb3duKFdQQVJBTSwg TFBBUkFNLCBib29sIHN5c3RlbUtleURvd24gPSBmYWxzZSk7CiAgICAgYm9vbCBrZXlVcChXUEFS QU0sIExQQVJBTSwgYm9vbCBzeXN0ZW1LZXlEb3duID0gZmFsc2UpOwpAQCAtOTExLDYgKzkxMywx MiBAQCBwcm90ZWN0ZWQ6CiAgICAgSFdORCBtX3RvcExldmVsUGFyZW50OwogCiAgICAgT3duUHRy PEhhc2hTZXQ8V2ViQ29yZTo6U3RyaW5nPiA+IG1fZW1iZWRkZWRWaWV3TUlNRVR5cGVzOworCisJ Ly9WYXJpYWJsZXMgbmVlZGVkIHRvIHN0b3JlIGdlc3R1cmUgaW5mb3JtYXRpb24KKwlsb25nIG1f bGFzdFBhblg7CisJbG9uZyBtX2xhc3RQYW5ZOworCWxvbmcgbV94T3ZlcnBhbjsKKwlsb25nIG1f eU92ZXJwYW47CiB9OwogCiAjZW5kaWYKSW5kZXg6IFdlYktpdC93aW4vV2luZG93c1RvdWNoLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9XaW5kb3dzVG91Y2guaAkocmV2aXNpb24gMCkKKysr IFdlYktpdC93aW4vV2luZG93c1RvdWNoLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTEyIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBD T01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENP TVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuIAorICovCisKKyNpZm5kZWYgV2luZG93c1RvdWNoX2gKKyNkZWZpbmUgV2luZG93c1RvdWNo X2gKKworLyoKKyAqIFRoZSBmb2xsb3dpbmcgY29uc3RhbnRzIGFyZSB1c2VkIHRvIGRldGVybWlu ZSBtdWx0aXRvdWNoIGFuZCBnZXN0dXJlIGJlaGF2aW9yCisgKiBmb3IgV2luZG93cyA3LiBGb3Ig bW9yZSBpbmZvcm1hdGlvbiwgc2VlOgorICogaHR0cDovL21zZG4ubWljcm9zb2Z0LmNvbS9lbi11 cy9saWJyYXJ5L2RkNTYyMTk3KFZTLjg1KS5hc3B4CisgKi8KKworLy8gVmFsdWUgdXNlZCBpbiBX ZWJWaWV3V25kUHJvYyBmb3IgR2VzdHVyZXMKKyNkZWZpbmUgV01fR0VTVFVSRSAweDAxMTkKKyNk ZWZpbmUgV01fR0VTVFVSRU5PVElGWSAweDAxMUEKKworLy8gR2VzdHVyZSBJbmZvcm1hdGlvbiBG bGFncworI2RlZmluZSBHRl9CRUdJTiAweDAwMDAwMDAxCisjZGVmaW5lIEdGX0lORVJUSUEgMHgw MDAwMDAwMgorI2RlZmluZSBHRl9FTkQgMHgwMDAwMDAwNAorCisvLyBHZXN0dXJlIElEcworI2Rl ZmluZSBHSURfQkVHSU4gMQorI2RlZmluZSBHSURfRU5EIDIKKyNkZWZpbmUgR0lEX1pPT00gMwor I2RlZmluZSBHSURfUEFOIDQKKyNkZWZpbmUgR0lEX1JPVEFURSA1CisjZGVmaW5lIEdJRF9UV09G SU5HRVJUQVAgNgorI2RlZmluZSBHSURfUFJFU1NBTkRUQVAgNworI2RlZmluZSBHSURfUk9MTE9W RVIgR0lEX1BSRVNTQU5EVEFQCisKKy8vIFpvb20gR2VzdHVyZSBDb25maXJhdGlvbiBGbGFncwor I2RlZmluZSBHQ19aT09NIDB4MDAwMDAwMDEKKworLy8gUGFuIEdlc3R1cmUgQ29uZmlndXJhdGlv biBGbGFncworI2RlZmluZSBHQ19QQU4gMHgwMDAwMDAwMQorI2RlZmluZSBHQ19QQU5fV0lUSF9T SU5HTEVfRklOR0VSX1ZFUlRJQ0FMTFkgMHgwMDAwMDAwMgorI2RlZmluZSBHQ19QQU5fV0lUSF9T SU5HTEVfRklOR0VSX0hPUklaT05UQUxMWSAweDAwMDAwMDA0CisjZGVmaW5lIEdDX1BBTl9XSVRI X0dVVFRFUiAweDAwMDAwMDA4CisjZGVmaW5lIEdDX1BBTl9XSVRIX0lORVJUSUEgMHgwMDAwMDAx MAorCisvLyBSb3RhdGUgR2VzdHVyZSBDb25maWd1cmF0aW9uIEZsYWdzCisjZGVmaW5lIEdDX1JP VEFURSAweDAwMDAwMDAxCisKKy8vIFR3byBmaW5nZXIgdGFwIGNvbmZpZ3VyYXRpb24gZmxhZ3MK KyNkZWZpbmUgR0NfVFdPRklOR0VSVEFQIDB4MDAwMDAwMDEKKworLy8gUHJlc3MgYW5kIHRhcCBD b25maWd1cmF0aW9uIEZsYWdzCisjZGVmaW5lIEdDX1BSRVNTQU5EVEFQIDB4MDAwMDAwMDEKKyNk ZWZpbmUgR0NfUk9MTE9WRVIgR0NfUFJFU1NBTkRUQVAKKworLy8gR0VTVFVSRUlORk8gc3RydWN0 IGRlZmluaXRpb24KK3R5cGVkZWYgc3RydWN0IHRhZ0dFU1RVUkVJTkZPIHsKKyAgICBVSU5UIGNi U2l6ZTsgICAgICAgICAgICAgICAgICAgIC8vIHNpemUsIGluIGJ5dGVzLCBvZiB0aGlzIHN0cnVj dHVyZSAoaW5jbHVkaW5nIHZhcmlhYmxlIGxlbmd0aCBBcmdzIGZpZWxkKQorICAgIERXT1JEIGR3 RmxhZ3M7ICAgICAgICAgICAgICAgICAgLy8gc2VlIEdGXyogZmxhZ3MKKyAgICBEV09SRCBkd0lE OyAgICAgICAgICAgICAgICAgICAgIC8vIGdlc3R1cmUgSUQsIHNlZSBHSURfKiBkZWZpbmVzCisg ICAgSFdORCBod25kVGFyZ2V0OyAgICAgICAgICAgICAgICAvLyBoYW5kbGUgdG8gd2luZG93IHRh cmdldGVkIGJ5IHRoaXMgZ2VzdHVyZQorICAgIFBPSU5UUyBwdHNMb2NhdGlvbjsgICAgICAgICAg ICAgLy8gY3VycmVudCBsb2NhdGlvbiBvZiB0aGlzIGdlc3R1cmUKKyAgICBEV09SRCBkd0luc3Rh bmNlSUQ7ICAgICAgICAgICAgIC8vIGludGVybmFsbHkgdXNlZAorICAgIERXT1JEIGR3U2VxdWVu Y2VJRDsgICAgICAgICAgICAgLy8gaW50ZXJuYWxseSB1c2VkCisgICAgVUxPTkdMT05HIHVsbEFy Z3VtZW50czsgICAgICAgICAvLyBhcmd1bWVudHMgZm9yIGdlc3R1cmVzIHdob3NlIGFyZ3VtZW50 cyBmaXQgaW4gOCBCWVRFUworICAgIFVJTlQgY2JFeHRyYUFyZ3M7ICAgICAgICAgICAgICAgLy8g c2l6ZSwgaW4gYnl0ZXMsIG9mIGV4dHJhIGFyZ3VtZW50cywgaWYgYW55LCB0aGF0IGFjY29tcGFu eSB0aGlzIGdlc3R1cmUKK30gR0VTVFVSRUlORk8sICpQR0VTVFVSRUlORk87Cit0eXBlZGVmIEdF U1RVUkVJTkZPIGNvbnN0ICogUENHRVNUVVJFSU5GTzsKKworLy8gR0VTVFVSRUNPTkZJRyBzdHJ1 Y3QgZGVmaW50aW9uCit0eXBlZGVmIHN0cnVjdCB0YWdHRVNUVVJFQ09ORklHIHsKKyAgICBEV09S RCBkd0lEOyAgICAgICAgICAgICAgICAgICAgIC8vIGdlc3R1cmUgSUQKKyAgICBEV09SRCBkd1dh bnQ7ICAgICAgICAgICAgICAgICAgIC8vIHNldHRpbmdzIHJlbGF0ZWQgdG8gZ2VzdHVyZSBJRCB0 aGF0IGFyZSB0byBiZSB0dXJuZWQgb24KKyAgICBEV09SRCBkd0Jsb2NrOyAgICAgICAgICAgICAg ICAgIC8vIHNldHRpbmdzIHJlbGF0ZWQgdG8gZ2VzdHVyZSBJRCB0aGF0IGFyZSB0byBiZSB0dXJu ZWQgb2ZmCit9IEdFU1RVUkVDT05GSUcsICpQR0VTVFVSRUNPTkZJRzsKKworLyoKKyAqIEdlc3R1 cmUgbm90aWZpY2F0aW9uIHN0cnVjdHVyZQorICogICAtIFRoZSBXTV9HRVNUVVJFTk9USUZZIG1l c3NhZ2UgbFBhcmFtIGNvbnRhaW5zIGEgcG9pbnRlciB0byB0aGlzIHN0cnVjdHVyZS4KKyAqICAg LSBUaGUgV01fR0VTVFVSRU5PVElGWSBtZXNzYWdlIG5vdGlmaWVzIGEgd2luZG93IHRoYXQgZ2Vz dHVyZSByZWNvZ25pdGlvbiBpcworICogICAgIGluIHByb2dyZXNzIGFuZCBhIGdlc3R1cmUgd2ls bCBiZSBnZW5lcmF0ZWQgaWYgb25lIGlzIHJlY29nbml6ZWQgdW5kZXIgdGhlCisgKiAgICAgY3Vy cmVudCBnZXN0dXJlIHNldHRpbmdzLgorICovCit0eXBlZGVmIHN0cnVjdCB0YWdHRVNUVVJFTk9U SUZZU1RSVUNUIHsKKyAgICBVSU5UIGNiU2l6ZTsgICAgICAgICAgICAgICAgICAgIC8vIHNpemUs IGluIGJ5dGVzLCBvZiB0aGlzIHN0cnVjdHVyZQorICAgIERXT1JEIGR3RmxhZ3M7ICAgICAgICAg ICAgICAgICAgLy8gdW51c2VkCisgICAgSFdORCBod25kVGFyZ2V0OyAgICAgICAgICAgICAgICAv LyBoYW5kbGUgdG8gd2luZG93IHRhcmdldGVkIGJ5IHRoZSBnZXN0dXJlCisgICAgUE9JTlRTIHB0 c0xvY2F0aW9uOyAgICAgICAgICAgICAvLyBzdGFydGluZyBsb2NhdGlvbgorICAgIERXT1JEIGR3 SW5zdGFuY2VJRDsgICAgICAgICAgICAgLy8gaW50ZXJuYWxseSB1c2VkCit9IEdFU1RVUkVOT1RJ RllTVFJVQ1QsICpQR0VTVFVSRU5PVElGWVNUUlVDVDsKKworREVDTEFSRV9IQU5ETEUoSEdFU1RV UkVJTkZPKTsKKworI2VuZGlmCgpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBXZWJLaXQvd2luL1dpbmRv d3NUb3VjaC5oCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBuYXRpdmUKCklu ZGV4OiBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvago9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvagkocmV2aXNpb24gNDQ4MzIp CisrKyBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovV2ViS2l0LnZjcHJvagkod29ya2luZyBjb3B5 KQpAQCAtNzM3LDYgKzczNywxMCBAQAogCQkJCVJlbGF0aXZlUGF0aD0iLi5cV2ViVmlldy5oIg0K IAkJCQk+DQogCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cV2lu ZG93c1RvdWNoLmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQogCQk8L0ZpbHRlcj4NCiAJCTxGaWx0 ZXINCiAJCQlOYW1lPSJDbGFzc2VzIg0K